Source Code added

mobile/ios/Runner/BackgroundSync/BackgroundServicePlugin.swift

@@ -0,0 +1,408 @@
+//
+//  BackgroundServicePlugin.swift
+//  Runner
+//
+//  Created by Marty Fuhry on 2/14/23.
+//
+
+import Flutter
+import BackgroundTasks
+import path_provider_foundation
+import CryptoKit
+import Network
+
+class BackgroundServicePlugin: NSObject, FlutterPlugin {
+    
+    public static var flutterPluginRegistrantCallback: FlutterPluginRegistrantCallback?
+    
+    public static func setPluginRegistrantCallback(_ callback: FlutterPluginRegistrantCallback) {
+        flutterPluginRegistrantCallback = callback
+    }
+
+    //  Pause the application in XCode, then enter
+    // e -l objc -- (void)[[BGTaskScheduler sharedScheduler] _simulateLaunchForTaskWithIdentifier:@"app.alextran.immich.backgroundFetch"]
+    // or
+    // e -l objc -- (void)[[BGTaskScheduler sharedScheduler] _simulateLaunchForTaskWithIdentifier:@"app.alextran.immich.backgroundProcessing"]
+    // Then resume the application see the background code run
+    // Tested on a physical device, not a simulator
+    // This will submit either the Fetch or Processing command to the BGTaskScheduler for immediate processing.
+    // In my tests, I can only get app.alextran.immich.backgroundProcessing simulated by running the above command
+    
+    // This is the task ID in Info.plist to register as our background task ID
+    public static let backgroundFetchTaskID = "app.alextran.immich.backgroundFetch"
+    public static let backgroundProcessingTaskID = "app.alextran.immich.backgroundProcessing"
+    
+    // Establish communication with the main isolate and set up the channel call
+    // to this BackgroundServicePlugion()
+    public static func register(with registrar: FlutterPluginRegistrar) {
+        let channel = FlutterMethodChannel(
+            name: "immich/foregroundChannel",
+            binaryMessenger: registrar.messenger()
+        )
+
+        let instance = BackgroundServicePlugin()
+        registrar.addMethodCallDelegate(instance, channel: channel)
+        registrar.addApplicationDelegate(instance)
+    }
+    
+    // Registers the Flutter engine with the plugins, used by the other Background Flutter engine
+    public static func register(engine: FlutterEngine) {
+        GeneratedPluginRegistrant.register(with: engine)
+    }
+
+    // Registers the task IDs from the system so that we can process them here in this class
+    public static func registerBackgroundProcessing() {
+ 
+        let processingRegisterd = BGTaskScheduler.shared.register(
+            forTaskWithIdentifier: backgroundProcessingTaskID,
+            using: nil) { task in
+            if task is BGProcessingTask {
+                handleBackgroundProcessing(task: task as! BGProcessingTask)
+            }
+        }
+        
+        let fetchRegisterd = BGTaskScheduler.shared.register(
+            forTaskWithIdentifier: backgroundFetchTaskID,
+            using: nil) { task in
+            if task is BGAppRefreshTask {
+                handleBackgroundFetch(task: task as! BGAppRefreshTask)
+            }
+        }
+    }
+
+    // Handles the channel methods from Flutter
+    public func handle(_ call: FlutterMethodCall, result: @escaping FlutterResult) {
+        switch call.method {
+            case "enable":
+                handleBackgroundEnable(call: call, result: result)
+                break
+            case "configure":
+                handleConfigure(call: call, result: result)
+                break
+            case "disable":
+                handleDisable(call: call, result: result)
+                break
+            case "isEnabled":
+                handleIsEnabled(call: call, result: result)
+                break
+            case "isIgnoringBatteryOptimizations":
+                result(FlutterMethodNotImplemented)
+                break
+            case "lastBackgroundFetchTime":
+                let defaults = UserDefaults.standard
+                let lastRunTime = defaults.value(forKey: "last_background_fetch_run_time")
+                result(lastRunTime)
+                break
+            case "lastBackgroundProcessingTime":
+                let defaults = UserDefaults.standard
+                let lastRunTime = defaults.value(forKey: "last_background_processing_run_time")
+                result(lastRunTime)
+                break
+            case "numberOfBackgroundProcesses":
+                handleNumberOfProcesses(call: call, result: result)
+                break
+            case "backgroundAppRefreshEnabled":
+                handleBackgroundRefreshStatus(call: call, result: result)
+                break
+            case "digestFiles":
+                handleDigestFiles(call: call, result: result)
+                break
+            default:
+                result(FlutterMethodNotImplemented)
+                break
+        }
+    }
+    
+    // Calculates the SHA-1 hash of each file from the list of paths provided
+    func handleDigestFiles(call: FlutterMethodCall, result: @escaping FlutterResult) {
+        
+        let bufsize = 2 * 1024 * 1024
+        // Private error to throw if file cannot be read
+        enum DigestError: String, LocalizedError {
+            case NoFileHandle = "Cannot Open File Handle"
+
+            public var errorDescription: String? { self.rawValue }
+        }
+        
+        // Parse the arguments or else fail
+        guard let args = call.arguments as? Array<String> else {
+            print("Cannot parse args as array: \(String(describing: call.arguments))")
+            result(FlutterError(code: "Malformed",
+                                message: "Received args is not an Array<String>",
+                                details: nil))
+            return
+        }
+        
+        // Compute hash in background thread
+        DispatchQueue.global(qos: .background).async {
+            var hashes: [FlutterStandardTypedData?] = Array(repeating: nil, count: args.count)
+            for i in (0 ..< args.count) {
+                do {
+                    guard let file = FileHandle(forReadingAtPath: args[i]) else { throw DigestError.NoFileHandle }
+                    var hasher = Insecure.SHA1.init();
+                    while autoreleasepool(invoking: {
+                        let chunk = file.readData(ofLength: bufsize)
+                        guard !chunk.isEmpty else { return false } // EOF
+                        hasher.update(data: chunk)
+                        return true // continue
+                    }) { }
+                    let digest = hasher.finalize()
+                    hashes[i] = FlutterStandardTypedData(bytes: Data(Array(digest.makeIterator())))
+                } catch {
+                    print("Cannot calculate the digest of the file \(args[i]) due to \(error.localizedDescription)")
+                }
+            }
+            
+            // Return result in main thread
+            DispatchQueue.main.async {
+                result(Array(hashes))
+            }
+        }
+    }
+    
+    // Called by the flutter code when enabled so that we can turn on the background services
+    // and save the callback information to communicate on this method channel
+    public func handleBackgroundEnable(call: FlutterMethodCall, result: FlutterResult) {
+        
+        // Needs to parse the arguments from the method call
+        guard let args = call.arguments as? Array<Any> else {
+            print("Cannot parse args as array: \(call.arguments)")
+            result(FlutterMethodNotImplemented)
+            return
+        }
+        
+        // Requires 3 arguments in the array
+        guard args.count == 3 else {
+            print("Requires 3 arguments and received \(args.count)")
+            result(FlutterMethodNotImplemented)
+            return
+        }
+                
+        // Parses the arguments
+        let callbackHandle = args[0] as? Int64
+        let notificationTitle = args[1] as? String
+        let instant = args[2] as? Bool
+        
+        // Write enabled to settings
+        let defaults = UserDefaults.standard
+        
+        // We are now enabled, so store this
+        defaults.set(true, forKey: "background_service_enabled")
+        
+        // The callback handle is an int64 address to communicate with the main isolate's
+        // entry function
+        defaults.set(callbackHandle, forKey: "callback_handle")
+        
+        // This is not used yet and will need to be implemented
+        defaults.set(notificationTitle, forKey: "notification_title")
+        
+        // Schedule the background services
+        BackgroundServicePlugin.scheduleBackgroundSync()
+        BackgroundServicePlugin.scheduleBackgroundFetch()
+
+        result(true)
+    }
+    
+    // Called by the flutter code at launch to see if the background service is enabled or not
+    func handleIsEnabled(call: FlutterMethodCall, result: FlutterResult) {
+        let defaults = UserDefaults.standard
+        let enabled = defaults.value(forKey: "background_service_enabled") as? Bool
+        
+        // False by default
+        result(enabled ?? false)
+    }
+    
+    // Called by the Flutter code whenever a change in configuration is set
+    func handleConfigure(call: FlutterMethodCall, result: FlutterResult) {
+        
+        // Needs to be able to parse the arguments or else fail
+        guard let args = call.arguments as? Array<Any> else {
+            print("Cannot parse args as array: \(call.arguments)")
+            result(FlutterError())
+            return
+        }
+        
+        // Needs to have 4 arguments in the call or else fail
+        guard args.count == 4 else {
+            print("Not enough arguments, 4 required: \(args.count) given")
+            result(FlutterError())
+            return
+        }
+        
+        // Parse the arguments from the method call
+        let requireUnmeteredNetwork = args[0] as? Bool
+        let requireCharging = args[1] as? Bool
+        let triggerUpdateDelay = args[2] as? Int
+        let triggerMaxDelay = args[3] as? Int
+        
+        // Store the values from the call in the defaults
+        let defaults = UserDefaults.standard
+        defaults.set(requireUnmeteredNetwork, forKey: "require_unmetered_network")
+        defaults.set(requireCharging, forKey: "require_charging")
+        defaults.set(triggerUpdateDelay, forKey: "trigger_update_delay")
+        defaults.set(triggerMaxDelay, forKey: "trigger_max_delay")
+
+        // Cancel the background services and reschedule them
+        BGTaskScheduler.shared.cancelAllTaskRequests()
+        BackgroundServicePlugin.scheduleBackgroundSync()
+        BackgroundServicePlugin.scheduleBackgroundFetch()
+        result(true)
+    }
+    
+    // Returns the number of currently scheduled background processes to Flutter, strictly
+    // for debugging
+    func handleNumberOfProcesses(call: FlutterMethodCall, result: @escaping FlutterResult) {
+        BGTaskScheduler.shared.getPendingTaskRequests { requests in
+            result(requests.count)
+        }
+    }
+    
+    // Disables the service, cancels all the task requests
+    func handleDisable(call: FlutterMethodCall, result: FlutterResult) {
+        let defaults = UserDefaults.standard
+        defaults.set(false, forKey: "background_service_enabled")
+        
+        BGTaskScheduler.shared.cancelAllTaskRequests()
+        result(true)
+    }
+  
+    // Checks the status of the Background App Refresh from the system
+    // Returns true if the service is enabled for Immich, and false otherwise
+    func handleBackgroundRefreshStatus(call: FlutterMethodCall, result: FlutterResult) {
+        switch UIApplication.shared.backgroundRefreshStatus {
+        case .available:
+            result(true)
+            break
+        case .denied:
+            result(false)
+            break
+        case .restricted:
+            result(false)
+            break
+        default:
+            result(false)
+            break
+        }
+    }
+
+    
+    // Schedules a short-running background sync to sync only a few photos
+    static func scheduleBackgroundFetch() {
+        // We will schedule this task to run no matter the charging or wifi requirents from the end user
+        // 1. They can set Background App Refresh to Off / Wi-Fi / Wi-Fi & Cellular Data from Settings
+        // 2. We will check the battery connectivity when we begin running the background activity
+        let backgroundFetch = BGAppRefreshTaskRequest(identifier: BackgroundServicePlugin.backgroundFetchTaskID)
+        
+        // Use 5 minutes from now as earliest begin date
+        backgroundFetch.earliestBeginDate = Date(timeIntervalSinceNow: 5 * 60)
+        
+        do {
+            try BGTaskScheduler.shared.submit(backgroundFetch)
+        } catch {
+            print("Could not schedule the background task \(error.localizedDescription)")
+        }
+    }
+    
+    // Schedules a long-running background sync for syncing all of the photos
+    static func scheduleBackgroundSync() {
+        let backgroundProcessing = BGProcessingTaskRequest(identifier: BackgroundServicePlugin.backgroundProcessingTaskID)
+        
+        // We need the values for requiring charging
+        let defaults = UserDefaults.standard
+        let requireCharging = defaults.value(forKey: "require_charging") as? Bool
+        
+        // Always require network connectivity, and set the require charging from the above
+        backgroundProcessing.requiresNetworkConnectivity = true
+        backgroundProcessing.requiresExternalPower = requireCharging ?? true
+                
+        // Use 15 minutes from now as earliest begin date
+        backgroundProcessing.earliestBeginDate = Date(timeIntervalSinceNow: 15 * 60)
+        
+        do {
+            // Submit the task to the scheduler
+            try BGTaskScheduler.shared.submit(backgroundProcessing)
+        } catch {
+            print("Could not schedule the background task \(error.localizedDescription)")
+        }
+    }
+    
+    // This function runs when the system kicks off the BGAppRefreshTask from the Background Task Scheduler
+    static func handleBackgroundFetch(task: BGAppRefreshTask) {
+        // Schedule the next sync task so we can run this again later
+        scheduleBackgroundFetch()
+        
+        // Log the time of last background processing to now
+        let defaults = UserDefaults.standard
+        defaults.set(Date().timeIntervalSince1970, forKey: "last_background_fetch_run_time")
+        
+        // If we have required charging, we should check the charging status
+        let requireCharging = defaults.value(forKey: "require_charging") as? Bool ?? false
+        if (requireCharging) {
+            UIDevice.current.isBatteryMonitoringEnabled = true
+            if (UIDevice.current.batteryState == .unplugged) {
+                // The device is unplugged and we have required charging
+                // Therefore, we will simply complete the task without
+                // running it.
+                task.setTaskCompleted(success: true)
+                return
+            }
+        }
+        
+        // If we have required Wi-Fi, we can check the isExpensive property
+        let requireWifi = defaults.value(forKey: "require_wifi") as? Bool ?? false
+        if (requireWifi) {
+            let wifiMonitor = NWPathMonitor(requiredInterfaceType: .wifi)
+            let isExpensive = wifiMonitor.currentPath.isExpensive
+            if (isExpensive) {
+                // The network is expensive and we have required Wi-Fi
+                // Therefore, we will simply complete the task without
+                // running it
+                task.setTaskCompleted(success: true)
+                return
+            }
+        }
+        
+        // Schedule the next sync task so we can run this again later
+        scheduleBackgroundFetch()
+        
+        // The background sync task should only run for 20 seconds at most
+        BackgroundServicePlugin.runBackgroundSync(task, maxSeconds: 20)
+    }
+    
+    // This function runs when the system kicks off the BGProcessingTask from the Background Task Scheduler
+    static func handleBackgroundProcessing(task: BGProcessingTask) {
+        // Schedule the next sync task so we run this again later
+        scheduleBackgroundSync()
+
+        // Log the time of last background processing to now
+        let defaults = UserDefaults.standard
+        defaults.set(Date().timeIntervalSince1970, forKey: "last_background_processing_run_time")
+        
+        // We won't specify a max time for the background sync service, so this can run for longer
+        BackgroundServicePlugin.runBackgroundSync(task, maxSeconds: nil)
+    }
+    
+    // This is a synchronous function which uses a semaphore to run the background sync worker's run
+    // function, which will create a background Isolate and communicate with the Flutter code to back
+    // up the assets. When it completes, we signal the semaphore and complete the execution allowing the
+    // control to pass back to the caller synchronously
+    static func runBackgroundSync(_ task: BGTask, maxSeconds: Int?) {
+
+        let semaphore = DispatchSemaphore(value: 0)
+        DispatchQueue.main.async {
+            let backgroundWorker = BackgroundSyncWorker { _ in
+                semaphore.signal()
+            }
+            task.expirationHandler = {
+                backgroundWorker.cancel()
+                task.setTaskCompleted(success: true)
+            }
+            
+            backgroundWorker.run(maxSeconds: maxSeconds)
+            task.setTaskCompleted(success: true)
+        }
+        semaphore.wait()
+    }
+
+
+}

mobile/ios/Runner/BackgroundSync/BackgroundSyncWorker.swift

@@ -0,0 +1,271 @@
+//
+//  BackgroundSyncProcessing.swift
+//  Runner
+//
+//  Created by Marty Fuhry on 2/6/23.
+//
+// Credit to https://github.com/fluttercommunity/flutter_workmanager/blob/main/ios/Classes/BackgroundWorker.swift
+
+import Foundation
+import Flutter
+import BackgroundTasks
+
+// The background worker which creates a new Flutter VM, communicates with it
+// to run the backup job, and then finishes execution and calls back to its callback
+// handler
+class BackgroundSyncWorker {
+
+    // The Flutter engine we create for background execution.
+    // This is not the main Flutter engine which shows the UI,
+    // this is a brand new isolate created and managed in this code
+    // here. It does not share memory with the main
+    // Flutter engine which shows the UI.
+    // It needs to be started up, registered, and torn down here
+    let engine: FlutterEngine? = FlutterEngine(
+        name: "BackgroundImmich"
+    )
+    
+    let notificationId = "com.alextran.immich/backgroundNotifications"
+    // The background message passing channel
+    var channel: FlutterMethodChannel?
+    
+    var completionHandler: (UIBackgroundFetchResult) -> Void
+    let taskSessionStart = Date()
+    
+    // We need the completion handler to tell the system when we are done running
+    init(_ completionHandler: @escaping (UIBackgroundFetchResult) -> Void) {
+        
+        // This is the background message passing channel to be used with the background engine
+        // created here in this platform code
+        self.channel = FlutterMethodChannel(
+            name: "immich/backgroundChannel",
+            binaryMessenger: engine!.binaryMessenger
+        )
+        self.completionHandler = completionHandler
+    }
+    
+    // Handles all of the messages from the Flutter VM called into this platform code
+    public func handle(_ call: FlutterMethodCall, result: @escaping FlutterResult) {
+        switch call.method {
+        case "initialized":
+            // Initialize tells us that we can now call into the Flutter VM to tell it to begin the update
+            self.channel?.invokeMethod(
+                "backgroundProcessing",
+                arguments: nil,
+                result: { flutterResult in
+                    
+                    // This is the result we send back to the BGTaskScheduler to let it know whether we'll need more time later or
+                    // if this execution failed
+                    let result: UIBackgroundFetchResult = (flutterResult as? Bool ?? false) ? .newData : .failed
+                    
+                    // Show the task duration
+                    let taskSessionCompleter = Date()
+                    let taskDuration = taskSessionCompleter.timeIntervalSince(self.taskSessionStart)
+                    print("[\(String(describing: self))] \(#function) -> performBackgroundRequest.\(result) (finished in \(taskDuration) seconds)")
+                    
+                    // Complete the execution
+                    self.complete(result)
+                })
+            break
+        case "updateNotification":
+            let handled = self.handleNotification(call)
+            result(handled)
+            break
+        case "showError":
+            let handled = self.handleError(call)
+            result(handled)
+            break
+        case "clearErrorNotifications":
+            self.handleClearErrorNotifications()
+            result(true)
+            break
+        case "hasContentChanged":
+            // This is only called for Android, but we provide an implementation here
+            // telling Flutter that we don't have any information about whether the gallery
+            // contents have changed or not, so we can just say "no, they've not changed"
+            result(false)
+            break
+        default:
+            result(FlutterError()) 
+            self.complete(UIBackgroundFetchResult.failed)
+        }
+    }
+    
+    // Runs the background sync by starting up a new isolate and handling the calls
+    // until it completes
+    public func run(maxSeconds: Int?) {
+        // We need the callback handle to start up the Flutter VM from the entry point
+        let defaults = UserDefaults.standard
+        guard let callbackHandle = defaults.value(forKey: "callback_handle") as? Int64 else {
+            // Can't find the callback handle, this is fatal
+            complete(UIBackgroundFetchResult.failed)
+            return
+            
+        }
+        
+        // Use the provided callbackHandle to get the callback function
+        guard let callback = FlutterCallbackCache.lookupCallbackInformation(callbackHandle) else {
+            // We need this callback or else this is fatal
+            complete(UIBackgroundFetchResult.failed)
+            return
+        }
+        
+        // Sanity check for the engine existing
+        if engine == nil {
+            complete(UIBackgroundFetchResult.failed)
+            return
+        }
+               
+        // Run the engine
+        let isRunning = engine!.run(
+            withEntrypoint: callback.callbackName,
+            libraryURI: callback.callbackLibraryPath
+        )
+        
+        // If this engine isn't running, this is fatal
+        if !isRunning {
+            complete(UIBackgroundFetchResult.failed)
+            return
+        }
+        
+        // If we have a timer, we need to start the timer to cancel ourselves
+        // so that we don't run longer than the provided maxSeconds
+        // After maxSeconds has elapsed, we will invoke "systemStop"
+        if maxSeconds != nil {
+            // Schedule a non-repeating timer to run after maxSeconds
+            let timer = Timer.scheduledTimer(withTimeInterval: TimeInterval(maxSeconds!),
+                                                      repeats: false) { timer in
+                // The callback invalidates the timer and stops execution
+                timer.invalidate()
+                
+                // If the channel is already deallocated, we don't need to do anything
+                if self.channel == nil {
+                    return
+                }
+                
+                // Tell the Flutter VM to stop backing up now
+                self.channel?.invokeMethod(
+                    "systemStop",
+                    arguments: nil,
+                    result: nil)
+                
+                // Complete the execution
+                self.complete(UIBackgroundFetchResult.newData)
+            }
+        }
+        
+        // Set the handle function to the channel message handler
+        self.channel?.setMethodCallHandler(handle)
+        
+        // Register this to get access to the plugins on the platform channel
+        BackgroundServicePlugin.flutterPluginRegistrantCallback?(engine!)
+    }
+    
+    // Cancels execution of this task, used by the system's task expiration handler
+    // which is called shortly before execution is about to expire
+    public func cancel() {
+        // If the channel is already deallocated, we don't need to do anything
+        if self.channel == nil {
+            return
+        }
+        
+        // Tell the Flutter VM to stop backing up now
+        self.channel?.invokeMethod(
+            "systemStop",
+            arguments: nil,
+            result: nil)
+        
+        // Complete the execution
+        self.complete(UIBackgroundFetchResult.newData)
+    }
+
+    // Completes the execution, destroys the engine, and sends a completion to our callback completionHandler
+    private func complete(_ fetchResult: UIBackgroundFetchResult) {
+        engine?.destroyContext()
+        channel = nil
+        completionHandler(fetchResult)
+    }
+    
+    private func handleNotification(_ call: FlutterMethodCall) -> Bool {
+        
+        // Parse the arguments as an array list
+        guard let args = call.arguments as? Array<Any> else {
+            print("Failed to parse \(call.arguments) as array")
+            return false;
+        }
+        
+        // Requires 7 arguments passed or else fail
+        guard args.count == 7 else {
+            print("Needs 7 arguments, but was only passed \(args.count)")
+            return false
+        }
+        
+        // Parse the arguments to send the notification update
+        let title = args[0] as? String
+        let content = args[1] as? String
+        let progress = args[2] as? Int
+        let maximum = args[3] as? Int
+        let indeterminate = args[4] as? Bool
+        let isDetail = args[5] as? Bool
+        let onlyIfForeground = args[6] as? Bool
+        
+        // Build the notification
+        let notificationContent = UNMutableNotificationContent()
+        notificationContent.body = content ?? "Uploading..."
+        notificationContent.title = title ?? "Immich"
+        
+        // Add it to the Notification center
+        let notification = UNNotificationRequest(
+            identifier: notificationId,
+            content: notificationContent,
+            trigger: nil
+        )
+        let center = UNUserNotificationCenter.current()
+        center.add(notification) { (error: Error?) in
+            if let theError = error {
+                print("Error showing notifications: \(theError)")
+            }
+        }
+        
+        return true
+    }
+    
+    private func handleError(_ call: FlutterMethodCall) -> Bool {
+        // Parse the arguments as an array list
+        guard let args = call.arguments as? Array<Any> else {
+            return false;
+        }
+        
+        // Requires 7 arguments passed or else fail
+        guard args.count == 3 else {
+            return false
+        }
+        
+        let title = args[0] as? String
+        let content = args[1] as? String
+        let individualTag = args[2] as? String
+        
+        // Build the notification
+        let notificationContent = UNMutableNotificationContent()
+        notificationContent.body = content ?? "Error running the backup job."
+        notificationContent.title = title ?? "Immich"
+        
+        // Add it to the Notification center
+        let notification = UNNotificationRequest(
+            identifier: notificationId,
+            content: notificationContent,
+            trigger: nil
+        )
+        let center = UNUserNotificationCenter.current()
+        center.add(notification)
+        
+        return true
+    }
+    
+    private func handleClearErrorNotifications() {
+        let center = UNUserNotificationCenter.current()
+        center.removeDeliveredNotifications(withIdentifiers: [notificationId])
+        center.removePendingNotificationRequests(withIdentifiers: [notificationId])
+    }
+}
+