Executing some task when app is killed

[ysavr]

What happened?

Currently i can't execute some task like requesting an API on flutter from the IOS widget when the app is being killed

What do you expect?

Able to call API from the IOS widget even though the app is kill

Relevant log output

Execute in a terminal and put output into the code block below

Output of: flutter doctor -v

On which Platform do you experience this issue?

iOS

Other information

No response

Are you interested in working on a PR for this?

• I want to work on this

[ABausG]

Can you please share some more context of your code?

Also please check this section from the docs:

5. With the current setup the Widget is now Interactive as long as the App is still in the background. If you want to have the Widget be able to wake the App up you need to add the following to your AppIntent file

@available(iOS 16, *)
@available(iOSApplicationExtension, unavailable)
extension BackgroundIntent: ForegroundContinuableIntent {}

This code tells the system to always perform the Intent in the App and not in a process attached to the Widget. Note however that this will start your Flutter App using the normal main entrypoint meaning your full app might be run in the background. To counter this you should add checks in the very first Widget you build inside runApp to only perform necessary calls/setups while the App is launched in the background

https://docs.page/abausg/home_widget/features/interactive-widgets#ios-setup

[ysavr]

i tried to create timer widget, that have check in and checkout button(executing api then update the widget), the widget not updating when app is killed

//
//  AttendanceWidget.swift
//  AttendanceWidget
//
//

import WidgetKit
import SwiftUI

struct Provider: TimelineProvider {
    
    private let appGroupIdentifier = "group.attendanceApp"
    
    private var userDefaults: UserDefaults? {
        return UserDefaults(suiteName: appGroupIdentifier)
    }
    
    private func getDataFromFlutter() -> SimpleEntry {
        let userDefault = UserDefaults(suiteName: "group.attendanceApp")
        
        var isCheckOut = userDefault?.bool(forKey: "isCheckOut") ?? false
        var checkInTimeString = userDefault?.string(forKey: "checkInTime") ?? ""
        
        if isCheckOut {
            // Force reset if logout
            userDefault?.set(false, forKey: "status")
            userDefault?.set("00:00:00", forKey: "checkInTime")
            userDefault?.set(0, forKey: "checkInTimestamp") // Reset timestamp
            
            checkInTimeString = "00:00:00"
            isCheckOut = false
            userDefault?.set(true, forKey: "isCheckOut")
            userDefault?.set(false, forKey: "status")
        } else if !checkInTimeString.isEmpty && checkInTimeString != "00:00:00" {
            // Update timestamp if checkInTime has changed
            let formatter = DateFormatter()
            formatter.dateFormat = "yyyy-MM-dd HH:mm:ss"
            formatter.timeZone = TimeZone.current
            
            if let checkInDate = formatter.date(from: checkInTimeString) {
                let newTimestamp = checkInDate.timeIntervalSince1970
                if let storedTimestamp = userDefault?.double(forKey: "checkInTimestamp"), storedTimestamp != newTimestamp {
                    userDefault?.set(newTimestamp, forKey: "checkInTimestamp")
                    NSLog("Updated checkInTimestamp to: \(newTimestamp)")
                }
            }
        }
        
        let timerText: String
        if checkInTimeString.isEmpty || checkInTimeString == "00:00:00" {
            timerText = "00:00:00"
        } else {
            timerText = calculateElapsedTime(from: checkInTimeString, at: Date())
        }
        
        let checkInStatus = userDefault?.bool(forKey: "status") ?? false
        let loading = userDefault?.bool(forKey: "onLoading") ?? false
        let employee = userDefault?.string(forKey: "lastEmployee") ?? ""
        let isLogin = userDefault?.bool(forKey: "isLoginWidget") ?? false
        let message = userDefault?.string(forKey: "message") ?? ""
        NSLog("getDataFromFlutter called")
        NSLog("isLogin: %@", isLogin.description)
        NSLog("employee: %@", employee)
        NSLog("UserDefaults: isCheckOut=%@, checkInTime=%@, status=%@, onLoading=%@, lastEmployee=%@, isLoginWidget=%@",
              isCheckOut.description,
              checkInTimeString,
              checkInStatus.description,
              loading.description,
              employee,
              isLogin.description)
        return SimpleEntry(date: Date(), timer: timerText, status: checkInStatus, loading: loading, employee: employee, isLogin: isLogin, message: message)
    }
    
    private func calculateElapsedTime(from dateString: String, at date: Date) -> String {
        if dateString.isEmpty || dateString == "00:00:00" {
            return "00:00:00"
        }
        
        guard let userDefaults = userDefaults else {
            NSLog("UserDefaults not available")
            return "00:00:00"
        }
        
        let storedTimestamp = userDefaults.double(forKey: "checkInTimestamp")
        NSLog("Stored checkInTimestamp: \(storedTimestamp)")
        
        if storedTimestamp <= 0 {
            // Parse and store the timestamp if not set
            let formatter = DateFormatter()
            formatter.dateFormat = "yyyy-MM-dd HH:mm:ss"
            formatter.timeZone = TimeZone.current
            
            guard let pastDate = formatter.date(from: dateString) else {
                NSLog("Error parsing date: \(dateString)")
                return "00:00:00"
            }
            
            let checkInTimestamp = pastDate.timeIntervalSince1970
            userDefaults.set(checkInTimestamp, forKey: "checkInTimestamp")
            NSLog("Stored new checkInTimestamp: \(checkInTimestamp)")
            
            let elapsed = max(0, date.timeIntervalSince(pastDate))
            let hours = Int(elapsed) / 3600
            let minutes = (Int(elapsed) % 3600) / 60
            let seconds = Int(elapsed) % 60
            return String(format: "%02d:%02d:%02d", hours, minutes, seconds)
        }
        
        // Calculate elapsed time using stored timestamp
        let pastDate = Date(timeIntervalSince1970: storedTimestamp)
        let elapsed = max(0, date.timeIntervalSince(pastDate))
        let hours = Int(elapsed) / 3600
        let minutes = (Int(elapsed) % 3600) / 60
        let seconds = Int(elapsed) % 60
        
        let timerText = String(format: "%02d:%02d:%02d", hours, minutes, seconds)
        NSLog("Calculated timerText using timestamp: \(timerText)")
        return timerText
    }
    
    func placeholder(in context: Context) -> SimpleEntry {
        SimpleEntry(date: Date(), timer: "00:00:00", status: false, loading: false, employee: nil, isLogin: false, message: nil)
    }
    
    func getSnapshot(in context: Context, completion: @escaping (SimpleEntry) -> ()) {
        let entry = SimpleEntry(date: Date(), timer: "00:00:00", status: false, loading: false, employee: nil, isLogin: false, message: nil)
        completion(entry)
    }
    
    func getTimeline(in context: Context, completion: @escaping (Timeline<Entry>) -> ()) {
        let entry = getDataFromFlutter()
        
        // Create multiple timeline entries to ensure timer continues updating
        var entries: [SimpleEntry] = []
        
        // If there's an active check-in, create multiple entries for the next few minutes
        // This ensures the timer keeps updating even if the system throttles refreshes
        if let employee = entry.employee, !employee.isEmpty, entry.isLogin, entry.status {
            let currentDate = Date()
            // Create entries for the next 5 minutes (at 15-second intervals)
            for offset in stride(from: 0, to: 300, by: 15) {
                guard let entryDate = Calendar.current.date(byAdding: .second, value: offset, to: currentDate) else {
                    continue
                }
                
                // Copy the current entry but update the date and timer
                let timerText = calculateElapsedTime(from: userDefaults?.string(forKey: "checkInTime") ?? "00:00:00", at: entryDate)
                let updatedEntry = SimpleEntry(
                    date: entryDate,
                    timer: timerText,
                    status: entry.status,
                    loading: entry.loading,
                    employee: entry.employee,
                    isLogin: entry.isLogin,
                    message: entry.message
                )
                entries.append(updatedEntry)
            }
        } else {
            // If no active check-in, just use the current entry
            entries = [entry]
        }
        
        // Refresh every 15 seconds as a fallback
        let nextUpdate = Calendar.current.date(byAdding: .second, value: 15, to: Date())!
        let timeline = Timeline(entries: entries, policy: .after(nextUpdate))
        completion(timeline)
    }
}

struct SimpleEntry: TimelineEntry {
    let date: Date
    let timer: String
    let status: Bool
    var checkInStatusText: String {
        status ? "Check Out" : "Check In"
    }
    let loading: Bool
    let employee: String?
    let isLogin: Bool
    let message: String?
}

struct AttendanceWidgetEntryView : View {
    var entry: Provider.Entry
    
    var body: some View {
        VStack(spacing: 16) {
            if let errorMessage = entry.message, !errorMessage.isEmpty {
                VStack(spacing: 8) {
                    Button(
                        intent: BackgroundIntent(
                            url: URL(string: "homeWidget://reload"),
                            appGroup: "group.attendanceApp"
                        )
                    ) {
                        Image(systemName: "arrow.clockwise")
                            .resizable()
                            .frame(width: 24, height: 24)
                            .foregroundColor(.gray)
                    }
                    .buttonStyle(.plain)
                    
                    Text(errorMessage)
                        .font(.system(size: 14))
                        .foregroundColor(.gray)
                        .multilineTextAlignment(.center)
                }
                .padding()
            } else if let employee = entry.employee, !employee.isEmpty, entry.isLogin {
                Text("Work Time")
                    .font(.headline)
                    .foregroundColor(.black)
                
                HStack(spacing: 8) {
                    Image(systemName: "clock")
                        .foregroundColor(.black)
                    Text(entry.timer)
                        .font(.system(size: 36, weight: .bold, design: .monospaced))
                        .foregroundColor(.black)
                }
                
                Button(
                    intent: BackgroundIntent(
                        url: URL(string: entry.status ? "homeWidget://checkout" : "homeWidget://checkin"),
                        appGroup: "group.attendanceApp"
                    )
                ) {
                    RoundedRectangle(cornerRadius: 12)
                        .fill(Color.white.opacity(0.2))
                        .overlay(
                            VStack {
                                if entry.loading {
                                    ProgressView()
                                        .progressViewStyle(CircularProgressViewStyle(tint: .white))
                                        .frame(maxWidth: .infinity)
                                        .padding(.vertical, 12)
                                } else {
                                    HStack {
                                        Image(systemName: "arrow.right.circle.fill")
                                            .foregroundColor(.white)
                                        
                                        Text(entry.checkInStatusText)
                                            .font(.system(size: 16, weight: .semibold))
                                            .foregroundColor(.white)
                                    }
                                    .frame(maxWidth: .infinity)
                                    .padding(.vertical, 12)
                                }
                            }
                                .background(Color(red: 0/255, green: 222/255, blue: 156/255))
                                .cornerRadius(12)
                                .padding(.horizontal, 16)
                        )
                        .frame(height: 44)
                }
                .buttonStyle(.plain)
                .disabled(entry.loading)
            } else if !entry.isLogin {
                Text("Log In to start your day ☺️")
                    .font(.system(size: 14, weight: .semibold))
                    .foregroundColor(.white)
                    .padding(.vertical, 8)
                    .padding(.horizontal, 16)
                    .background(Color(red: 0/255, green: 222/255, blue: 156/255))
                    .cornerRadius(8)
            } else {
                Text("Check in at least once to start")
                    .font(.system(size: 14))
                    .foregroundColor(.gray)
                    .multilineTextAlignment(.center)
                    .padding()
                    .cornerRadius(8)
            }
            
        }
        .background(Color.clear)
        .cornerRadius(20)
        .containerBackground(.fill.tertiary, for: .widget)
    }
}

struct AttendanceWidget: Widget {
    let kind: String = "AttendanceWidget"
    
    var body: some WidgetConfiguration {
        StaticConfiguration(kind: kind, provider: Provider()) { entry in
            if #available(iOS 17.0, *) {
                AttendanceWidgetEntryView(entry: entry)
                    .containerBackground(.fill.tertiary, for: .widget)
            } else {
                AttendanceWidgetEntryView(entry: entry)
                    .padding()
                    .background()
            }
        }
        .configurationDisplayName("My Widget")
        .description("This is an example widget.")
    }
}

#Preview(as: .systemSmall) {
    AttendanceWidget()
} timeline: {
    SimpleEntry(date: .now, timer: "00:00:00", status: false, loading: false, employee: nil, isLogin: false, message: nil)
    SimpleEntry(date: .now, timer: "00:00:00", status: false, loading: false, employee: nil, isLogin: false, message: nil)
}

Flutter

main.dart

await HomeWidget.setAppGroupId(StaticConstant.appGroupId);
HomeWidget.registerInteractivityCallback(interactiveCallback);

@pragma('vm:entry-point')
Future<void> interactiveCallback(Uri? uri) async {
  log.d('interactiveCallback uri: $uri');
  await HomeWidget.setAppGroupId(StaticConstant.appGroupId);
  if (uri?.host == 'checkout') {
    log.d('interactiveCallback callback checkout');

    try {
      final sp = await SharedPreferences.getInstance();
      final baseUrl = sp.getString(StaticConstant.prevCurrentBaseUrl);
      final dio = Dio(BaseOptions(baseUrl: baseUrl ?? ""));
      dio.interceptors.add(WidgetInterceptor(dio: dio, prefs: sp));
      final presenceRepo = PresenceRepoImpl(dio: dio, sharedPreferences: sp);
      final result = await presenceRepo.getCurrentCheckin();

      log.d('interactiveCallback result: $result');
      executeLogout(result);
    } catch (e) {
      log.e("checkout Callback $e");
    }
  } else if (uri?.host == 'checkin') {
    log.d('interactiveCallback callback checkin');
    executeCheckIn();
  } else if (uri?.host == 'reload') {
    log.d("reload error message");
    await HomeWidget.saveWidgetData(StaticConstant.widgetKeyMessage, "");
    await HomeWidget.updateWidget(
        iOSName: StaticConstant.iosWidgetName,
        androidName: StaticConstant.androidWidgetName
    );
  }
}

Future<void> executeCheckIn() async {
    final presenceRepo = PresenceRepoImpl(dio: dio, sharedPreferences: sp);
    final result = await presenceRepo.getCheckin(
        employee: widgetLastEmployee ?? "",
    );
    await HomeWidget.saveWidgetData(StaticConstant.widgetKeyMessage, "");
      await HomeWidget.saveWidgetData(StaticConstant.widgetKeyCheckInTime, checkInTime);
      await HomeWidget.saveWidgetData(StaticConstant.widgetIsCheckOut, false);
      await HomeWidget.saveWidgetData(StaticConstant.widgetKeyStatus, true);
      await HomeWidget.saveWidgetData(StaticConstant.widgetOnLoading, false);
      await HomeWidget.updateWidget(
          iOSName: StaticConstant.iosWidgetName,
          androidName: StaticConstant.androidWidgetName
      );
}

the widget not update even though call updateWidget, also applies to check out

[ABausG]

Can you share your intent configuration as well? please ensure you extend ForegroundContinuableIntent

[ysavr]

Background Intent configuration

import AppIntents
import Foundation
import home_widget
import WidgetKit

@available(iOS 17, *)
public struct BackgroundIntent: AppIntent {
   static public var title: LocalizedStringResource = "HomeWidget Background Intent"

   @Parameter(title: "Widget URI")
   var url: URL?

   @Parameter(title: "AppGroup")
   var appGroup: String?

   public init() {}

   public init(url: URL?, appGroup: String?) {
      self.url = url
      self.appGroup = appGroup
   }

   public func perform() async throws -> some IntentResult {
      await HomeWidgetBackgroundWorker.run(url: url, appGroup: appGroup!)

      return .result()
   }
}

@available(iOS 17, *)
@available(iOSApplicationExtension, unavailable)
extension BackgroundIntent: ForegroundContinuableIntent {}