High performance self-hosted photo and video management solution.
TypeScript backup-toolfluttergoogle-photosgoogle-photos-alternativejavascriptmobile-appnestjsnodejsphoto-galleryphotosphotos-managementself-hostedsveltesveltekittypescriptvideos
feat: beta background sync (#21243)
shenlong0df88fc22bca
diff --git a/mobile/analysis_options.yaml b/mobile/analysis_options.yamlindex 1b0b7170d2..bef051bff2 100644--- a/mobile/analysis_options.yaml+++ b/mobile/analysis_options.yaml@@ -81,6 +81,7 @@ custom_lint:# acceptable exceptions for the time being (until Isar is fully replaced)- lib/providers/app_life_cycle.provider.dart- integration_test/test_utils/general_helper.dart+ - lib/domain/services/background_worker.service.dart- lib/main.dart- lib/pages/album/album_asset_selection.page.dart- lib/routing/router.dartdiff --git a/mobile/android/app/src/main/kotlin/app/alextran/immich/ImmichApp.kt b/mobile/android/app/src/main/kotlin/app/alextran/immich/ImmichApp.ktindex ff806870f9..4237643233 100644--- a/mobile/android/app/src/main/kotlin/app/alextran/immich/ImmichApp.kt+++ b/mobile/android/app/src/main/kotlin/app/alextran/immich/ImmichApp.kt@@ -5,15 +5,15 @@ import androidx.work.Configurationimport androidx.work.WorkManagerclass ImmichApp : Application() {- override fun onCreate() {- super.onCreate()- val config = Configuration.Builder().build()- WorkManager.initialize(this, config)- // always start BackupWorker after WorkManager init; this fixes the following bug:- // After the process is killed (by user or system), the first trigger (taking a new picture) is lost.- // Thus, the BackupWorker is not started. If the system kills the process after each initialization- // (because of low memory etc.), the backup is never performed.- // As a workaround, we also run a backup check when initializing the application- ContentObserverWorker.startBackupWorker(context = this, delayMilliseconds = 0)- }-}\ No newline at end of file+ override fun onCreate() {+ super.onCreate()+ val config = Configuration.Builder().build()+ WorkManager.initialize(this, config)+ // always start BackupWorker after WorkManager init; this fixes the following bug:+ // After the process is killed (by user or system), the first trigger (taking a new picture) is lost.+ // Thus, the BackupWorker is not started. If the system kills the process after each initialization+ // (because of low memory etc.), the backup is never performed.+ // As a workaround, we also run a backup check when initializing the application+ ContentObserverWorker.startBackupWorker(context = this, delayMilliseconds = 0)+ }+}diff --git a/mobile/android/app/src/main/kotlin/app/alextran/immich/MainActivity.kt b/mobile/android/app/src/main/kotlin/app/alextran/immich/MainActivity.ktindex b1a50695a3..a87feddd1a 100644--- a/mobile/android/app/src/main/kotlin/app/alextran/immich/MainActivity.kt+++ b/mobile/android/app/src/main/kotlin/app/alextran/immich/MainActivity.kt@@ -1,8 +1,10 @@package app.alextran.immich+import android.content.Contextimport android.os.Buildimport android.os.ext.SdkExtensions-import androidx.annotation.NonNull+import app.alextran.immich.background.BackgroundWorkerApiImpl+import app.alextran.immich.background.BackgroundWorkerFgHostApiimport app.alextran.immich.images.ThumbnailApiimport app.alextran.immich.images.ThumbnailsImplimport app.alextran.immich.sync.NativeSyncApi@@ -12,19 +14,26 @@ import io.flutter.embedding.android.FlutterFragmentActivityimport io.flutter.embedding.engine.FlutterEngineclass MainActivity : FlutterFragmentActivity() {- override fun configureFlutterEngine(@NonNull flutterEngine: FlutterEngine) {+ override fun configureFlutterEngine(flutterEngine: FlutterEngine) {super.configureFlutterEngine(flutterEngine)- flutterEngine.plugins.add(BackgroundServicePlugin())- flutterEngine.plugins.add(HttpSSLOptionsPlugin())- // No need to set up method channel here as it's now handled in the plugin+ registerPlugins(this, flutterEngine)+ }++ companion object {+ fun registerPlugins(ctx: Context, flutterEngine: FlutterEngine) {+ flutterEngine.plugins.add(BackgroundServicePlugin())+ flutterEngine.plugins.add(HttpSSLOptionsPlugin())- val nativeSyncApiImpl =- if (Build.VERSION.SDK_INT < Build.VERSION_CODES.R || SdkExtensions.getExtensionVersion(Build.VERSION_CODES.R) < 1) {- NativeSyncApiImpl26(this)- } else {- NativeSyncApiImpl30(this)- }- NativeSyncApi.setUp(flutterEngine.dartExecutor.binaryMessenger, nativeSyncApiImpl)- ThumbnailApi.setUp(flutterEngine.dartExecutor.binaryMessenger, ThumbnailsImpl(this))+ val messenger = flutterEngine.dartExecutor.binaryMessenger+ val nativeSyncApiImpl =+ if (Build.VERSION.SDK_INT < Build.VERSION_CODES.R || SdkExtensions.getExtensionVersion(Build.VERSION_CODES.R) < 1) {+ NativeSyncApiImpl26(ctx)+ } else {+ NativeSyncApiImpl30(ctx)+ }+ NativeSyncApi.setUp(messenger, nativeSyncApiImpl)+ ThumbnailApi.setUp(messenger, ThumbnailsImpl(ctx))+ BackgroundWorkerFgHostApi.setUp(messenger, BackgroundWorkerApiImpl(ctx))+ }}}diff --git a/mobile/android/app/src/main/kotlin/app/alextran/immich/background/BackgroundWorker.g.kt b/mobile/android/app/src/main/kotlin/app/alextran/immich/background/BackgroundWorker.g.ktnew file mode 100644index 0000000000..39a2345a9b--- /dev/null+++ b/mobile/android/app/src/main/kotlin/app/alextran/immich/background/BackgroundWorker.g.kt@@ -0,0 +1,238 @@+// Autogenerated from Pigeon (v26.0.0), do not edit directly.+// See also: https://pub.dev/packages/pigeon+@file:Suppress("UNCHECKED_CAST", "ArrayInDataClass")++package app.alextran.immich.background++import android.util.Log+import io.flutter.plugin.common.BasicMessageChannel+import io.flutter.plugin.common.BinaryMessenger+import io.flutter.plugin.common.EventChannel+import io.flutter.plugin.common.MessageCodec+import io.flutter.plugin.common.StandardMethodCodec+import io.flutter.plugin.common.StandardMessageCodec+import java.io.ByteArrayOutputStream+import java.nio.ByteBuffer+private object BackgroundWorkerPigeonUtils {++ fun createConnectionError(channelName: String): FlutterError {+ return FlutterError("channel-error", "Unable to establish connection on channel: '$channelName'.", "") }++ fun wrapResult(result: Any?): List<Any?> {+ return listOf(result)+ }++ fun wrapError(exception: Throwable): List<Any?> {+ return if (exception is FlutterError) {+ listOf(+ exception.code,+ exception.message,+ exception.details+ )+ } else {+ listOf(+ exception.javaClass.simpleName,+ exception.toString(),+ "Cause: " + exception.cause + ", Stacktrace: " + Log.getStackTraceString(exception)+ )+ }+ }+}++/**+ * Error class for passing custom error details to Flutter via a thrown PlatformException.+ * @property code The error code.+ * @property message The error message.+ * @property details The error details. Must be a datatype supported by the api codec.+ */+class FlutterError (+ val code: String,+ override val message: String? = null,+ val details: Any? = null+) : Throwable()+private open class BackgroundWorkerPigeonCodec : StandardMessageCodec() {+ override fun readValueOfType(type: Byte, buffer: ByteBuffer): Any? {+ return super.readValueOfType(type, buffer)+ }+ override fun writeValue(stream: ByteArrayOutputStream, value: Any?) {+ super.writeValue(stream, value)+ }+}++/** Generated interface from Pigeon that represents a handler of messages from Flutter. */+interface BackgroundWorkerFgHostApi {+ fun enableSyncWorker()+ fun enableUploadWorker(callbackHandle: Long)+ fun disableUploadWorker()++ companion object {+ /** The codec used by BackgroundWorkerFgHostApi. */+ val codec: MessageCodec<Any?> by lazy {+ BackgroundWorkerPigeonCodec()+ }+ /** Sets up an instance of `BackgroundWorkerFgHostApi` to handle messages through the `binaryMessenger`. */+ @JvmOverloads+ fun setUp(binaryMessenger: BinaryMessenger, api: BackgroundWorkerFgHostApi?, messageChannelSuffix: String = "") {+ val separatedMessageChannelSuffix = if (messageChannelSuffix.isNotEmpty()) ".$messageChannelSuffix" else ""+ run {+ val channel = BasicMessageChannel<Any?>(binaryMessenger, "dev.flutter.pigeon.immich_mobile.BackgroundWorkerFgHostApi.enableSyncWorker$separatedMessageChannelSuffix", codec)+ if (api != null) {+ channel.setMessageHandler { _, reply ->+ val wrapped: List<Any?> = try {+ api.enableSyncWorker()+ listOf(null)+ } catch (exception: Throwable) {+ BackgroundWorkerPigeonUtils.wrapError(exception)+ }+ reply.reply(wrapped)+ }+ } else {+ channel.setMessageHandler(null)+ }+ }+ run {+ val channel = BasicMessageChannel<Any?>(binaryMessenger, "dev.flutter.pigeon.immich_mobile.BackgroundWorkerFgHostApi.enableUploadWorker$separatedMessageChannelSuffix", codec)+ if (api != null) {+ channel.setMessageHandler { message, reply ->+ val args = message as List<Any?>+ val callbackHandleArg = args[0] as Long+ val wrapped: List<Any?> = try {+ api.enableUploadWorker(callbackHandleArg)+ listOf(null)+ } catch (exception: Throwable) {+ BackgroundWorkerPigeonUtils.wrapError(exception)+ }+ reply.reply(wrapped)+ }+ } else {+ channel.setMessageHandler(null)+ }+ }+ run {+ val channel = BasicMessageChannel<Any?>(binaryMessenger, "dev.flutter.pigeon.immich_mobile.BackgroundWorkerFgHostApi.disableUploadWorker$separatedMessageChannelSuffix", codec)+ if (api != null) {+ channel.setMessageHandler { _, reply ->+ val wrapped: List<Any?> = try {+ api.disableUploadWorker()+ listOf(null)+ } catch (exception: Throwable) {+ BackgroundWorkerPigeonUtils.wrapError(exception)+ }+ reply.reply(wrapped)+ }+ } else {+ channel.setMessageHandler(null)+ }+ }+ }+ }+}+/** Generated interface from Pigeon that represents a handler of messages from Flutter. */+interface BackgroundWorkerBgHostApi {+ fun onInitialized()++ companion object {+ /** The codec used by BackgroundWorkerBgHostApi. */+ val codec: MessageCodec<Any?> by lazy {+ BackgroundWorkerPigeonCodec()+ }+ /** Sets up an instance of `BackgroundWorkerBgHostApi` to handle messages through the `binaryMessenger`. */+ @JvmOverloads+ fun setUp(binaryMessenger: BinaryMessenger, api: BackgroundWorkerBgHostApi?, messageChannelSuffix: String = "") {+ val separatedMessageChannelSuffix = if (messageChannelSuffix.isNotEmpty()) ".$messageChannelSuffix" else ""+ run {+ val channel = BasicMessageChannel<Any?>(binaryMessenger, "dev.flutter.pigeon.immich_mobile.BackgroundWorkerBgHostApi.onInitialized$separatedMessageChannelSuffix", codec)+ if (api != null) {+ channel.setMessageHandler { _, reply ->+ val wrapped: List<Any?> = try {+ api.onInitialized()+ listOf(null)+ } catch (exception: Throwable) {+ BackgroundWorkerPigeonUtils.wrapError(exception)+ }+ reply.reply(wrapped)+ }+ } else {+ channel.setMessageHandler(null)+ }+ }+ }+ }+}+/** Generated class from Pigeon that represents Flutter messages that can be called from Kotlin. */+class BackgroundWorkerFlutterApi(private val binaryMessenger: BinaryMessenger, private val messageChannelSuffix: String = "") {+ companion object {+ /** The codec used by BackgroundWorkerFlutterApi. */+ val codec: MessageCodec<Any?> by lazy {+ BackgroundWorkerPigeonCodec()+ }+ }+ fun onLocalSync(maxSecondsArg: Long?, callback: (Result<Unit>) -> Unit)+{+ val separatedMessageChannelSuffix = if (messageChannelSuffix.isNotEmpty()) ".$messageChannelSuffix" else ""+ val channelName = "dev.flutter.pigeon.immich_mobile.BackgroundWorkerFlutterApi.onLocalSync$separatedMessageChannelSuffix"+ val channel = BasicMessageChannel<Any?>(binaryMessenger, channelName, codec)+ channel.send(listOf(maxSecondsArg)) {+ if (it is List<*>) {+ if (it.size > 1) {+ callback(Result.failure(FlutterError(it[0] as String, it[1] as String, it[2] as String?)))+ } else {+ callback(Result.success(Unit))+ }+ } else {+ callback(Result.failure(BackgroundWorkerPigeonUtils.createConnectionError(channelName)))+ }+ }+ }+ fun onIosUpload(isRefreshArg: Boolean, maxSecondsArg: Long?, callback: (Result<Unit>) -> Unit)+{+ val separatedMessageChannelSuffix = if (messageChannelSuffix.isNotEmpty()) ".$messageChannelSuffix" else ""+ val channelName = "dev.flutter.pigeon.immich_mobile.BackgroundWorkerFlutterApi.onIosUpload$separatedMessageChannelSuffix"+ val channel = BasicMessageChannel<Any?>(binaryMessenger, channelName, codec)+ channel.send(listOf(isRefreshArg, maxSecondsArg)) {+ if (it is List<*>) {+ if (it.size > 1) {+ callback(Result.failure(FlutterError(it[0] as String, it[1] as String, it[2] as String?)))+ } else {+ callback(Result.success(Unit))+ }+ } else {+ callback(Result.failure(BackgroundWorkerPigeonUtils.createConnectionError(channelName)))+ }+ }+ }+ fun onAndroidUpload(callback: (Result<Unit>) -> Unit)+{+ val separatedMessageChannelSuffix = if (messageChannelSuffix.isNotEmpty()) ".$messageChannelSuffix" else ""+ val channelName = "dev.flutter.pigeon.immich_mobile.BackgroundWorkerFlutterApi.onAndroidUpload$separatedMessageChannelSuffix"+ val channel = BasicMessageChannel<Any?>(binaryMessenger, channelName, codec)+ channel.send(null) {+ if (it is List<*>) {+ if (it.size > 1) {+ callback(Result.failure(FlutterError(it[0] as String, it[1] as String, it[2] as String?)))+ } else {+ callback(Result.success(Unit))+ }+ } else {+ callback(Result.failure(BackgroundWorkerPigeonUtils.createConnectionError(channelName)))+ }+ }+ }+ fun cancel(callback: (Result<Unit>) -> Unit)+{+ val separatedMessageChannelSuffix = if (messageChannelSuffix.isNotEmpty()) ".$messageChannelSuffix" else ""+ val channelName = "dev.flutter.pigeon.immich_mobile.BackgroundWorkerFlutterApi.cancel$separatedMessageChannelSuffix"+ val channel = BasicMessageChannel<Any?>(binaryMessenger, channelName, codec)+ channel.send(null) {+ if (it is List<*>) {+ if (it.size > 1) {+ callback(Result.failure(FlutterError(it[0] as String, it[1] as String, it[2] as String?)))+ } else {+ callback(Result.success(Unit))+ }+ } else {+ callback(Result.failure(BackgroundWorkerPigeonUtils.createConnectionError(channelName)))+ }+ }+ }+}diff --git a/mobile/android/app/src/main/kotlin/app/alextran/immich/background/BackgroundWorker.kt b/mobile/android/app/src/main/kotlin/app/alextran/immich/background/BackgroundWorker.ktnew file mode 100644index 0000000000..0ce601b363--- /dev/null+++ b/mobile/android/app/src/main/kotlin/app/alextran/immich/background/BackgroundWorker.kt@@ -0,0 +1,162 @@+package app.alextran.immich.background++import android.content.Context+import android.os.Handler+import android.os.Looper+import android.util.Log+import androidx.work.ListenableWorker+import androidx.work.WorkerParameters+import app.alextran.immich.MainActivity+import com.google.common.util.concurrent.ListenableFuture+import com.google.common.util.concurrent.SettableFuture+import io.flutter.FlutterInjector+import io.flutter.embedding.engine.FlutterEngine+import io.flutter.embedding.engine.dart.DartExecutor.DartCallback+import io.flutter.embedding.engine.loader.FlutterLoader+import io.flutter.view.FlutterCallbackInformation++private const val TAG = "BackgroundWorker"++enum class BackgroundTaskType {+ LOCAL_SYNC,+ UPLOAD,+}++class BackgroundWorker(context: Context, params: WorkerParameters) :+ ListenableWorker(context, params), BackgroundWorkerBgHostApi {+ private val ctx: Context = context.applicationContext++ /// The Flutter loader that loads the native Flutter library and resources.+ /// This must be initialized before starting the Flutter engine.+ private var loader: FlutterLoader = FlutterInjector.instance().flutterLoader()++ /// The Flutter engine created specifically for background execution.+ /// This is a separate instance from the main Flutter engine that handles the UI.+ /// It operates in its own isolate and doesn't share memory with the main engine.+ /// Must be properly started, registered, and torn down during background execution.+ private var engine: FlutterEngine? = null++ // Used to call methods on the flutter side+ private var flutterApi: BackgroundWorkerFlutterApi? = null++ /// Result returned when the background task completes. This is used to signal+ /// to the WorkManager that the task has finished, either successfully or with failure.+ private val completionHandler: SettableFuture<Result> = SettableFuture.create()++ /// Flag to track whether the background task has completed to prevent duplicate completions+ private var isComplete = false++ init {+ if (!loader.initialized()) {+ loader.startInitialization(ctx)+ }+ }++ override fun startWork(): ListenableFuture<Result> {+ Log.i(TAG, "Starting background upload worker")++ loader.ensureInitializationCompleteAsync(ctx, null, Handler(Looper.getMainLooper())) {+ engine = FlutterEngine(ctx)++ // Retrieve the callback handle stored by the main Flutter app+ // This handle points to the Flutter function that should be executed in the background+ val callbackHandle =+ ctx.getSharedPreferences(BackgroundWorkerApiImpl.SHARED_PREF_NAME, Context.MODE_PRIVATE)+ .getLong(BackgroundWorkerApiImpl.SHARED_PREF_CALLBACK_HANDLE, 0L)++ if (callbackHandle == 0L) {+ // Without a valid callback handle, we cannot start the Flutter background execution+ complete(Result.failure())+ return@ensureInitializationCompleteAsync+ }++ // Start the Flutter engine with the specified callback as the entry point+ val callback = FlutterCallbackInformation.lookupCallbackInformation(callbackHandle)+ if (callback == null) {+ complete(Result.failure())+ return@ensureInitializationCompleteAsync+ }++ // Register custom plugins+ MainActivity.registerPlugins(ctx, engine!!)+ flutterApi =+ BackgroundWorkerFlutterApi(binaryMessenger = engine!!.dartExecutor.binaryMessenger)+ BackgroundWorkerBgHostApi.setUp(+ binaryMessenger = engine!!.dartExecutor.binaryMessenger,+ api = this+ )++ engine!!.dartExecutor.executeDartCallback(+ DartCallback(ctx.assets, loader.findAppBundlePath(), callback)+ )+ }++ return completionHandler+ }++ /**+ * Called by the Flutter side when it has finished initialization and is ready to receive commands.+ * Routes the appropriate task type (refresh or processing) to the corresponding Flutter method.+ * This method acts as a bridge between the native Android background task system and Flutter.+ */+ override fun onInitialized() {+ val taskTypeIndex = inputData.getInt(BackgroundWorkerApiImpl.WORKER_DATA_TASK_TYPE, 0)+ val taskType = BackgroundTaskType.entries[taskTypeIndex]++ when (taskType) {+ BackgroundTaskType.LOCAL_SYNC -> flutterApi?.onLocalSync(null) { handleHostResult(it) }+ BackgroundTaskType.UPLOAD -> flutterApi?.onAndroidUpload { handleHostResult(it) }+ }+ }++ /**+ * Called when the system has to stop this worker because constraints are+ * no longer met or the system needs resources for more important tasks+ * This is also called when the worker has been explicitly cancelled or replaced+ */+ override fun onStopped() {+ Log.d(TAG, "About to stop BackupWorker")++ if (isComplete) {+ return+ }++ Handler(Looper.getMainLooper()).postAtFrontOfQueue {+ if (flutterApi != null) {+ flutterApi?.cancel {+ complete(Result.failure())+ }+ }+ }++ Handler(Looper.getMainLooper()).postDelayed({+ complete(Result.failure())+ }, 5000)+ }++ private fun handleHostResult(result: kotlin.Result<Unit>) {+ if (isComplete) {+ return+ }++ result.fold(+ onSuccess = { _ -> complete(Result.success()) },+ onFailure = { _ -> onStopped() }+ )+ }++ /**+ * Cleans up resources by destroying the Flutter engine context and invokes the completion handler.+ * This method ensures that the background task is marked as complete, releases the Flutter engine,+ * and notifies the caller of the task's success or failure. This is the final step in the+ * background task lifecycle and should only be called once per task instance.+ *+ * - Parameter success: Indicates whether the background task completed successfully+ */+ private fun complete(success: Result) {+ isComplete = true+ engine?.destroy()+ flutterApi = null+ completionHandler.set(success)+ }+}diff --git a/mobile/android/app/src/main/kotlin/app/alextran/immich/background/BackgroundWorkerApiImpl.kt b/mobile/android/app/src/main/kotlin/app/alextran/immich/background/BackgroundWorkerApiImpl.ktnew file mode 100644index 0000000000..7a3226f961--- /dev/null+++ b/mobile/android/app/src/main/kotlin/app/alextran/immich/background/BackgroundWorkerApiImpl.kt@@ -0,0 +1,92 @@+package app.alextran.immich.background++import android.content.Context+import android.provider.MediaStore+import android.util.Log+import androidx.core.content.edit+import androidx.work.BackoffPolicy+import androidx.work.Constraints+import androidx.work.Data+import androidx.work.ExistingWorkPolicy+import androidx.work.OneTimeWorkRequest+import androidx.work.WorkManager+import java.util.concurrent.TimeUnit++private const val TAG = "BackgroundUploadImpl"++class BackgroundWorkerApiImpl(context: Context) : BackgroundWorkerFgHostApi {+ private val ctx: Context = context.applicationContext+ override fun enableSyncWorker() {+ enqueueMediaObserver(ctx)+ Log.i(TAG, "Scheduled media observer")+ }++ override fun enableUploadWorker(callbackHandle: Long) {+ updateUploadEnabled(ctx, true)+ updateCallbackHandle(ctx, callbackHandle)+ Log.i(TAG, "Scheduled background upload tasks")+ }++ override fun disableUploadWorker() {+ updateUploadEnabled(ctx, false)+ WorkManager.getInstance(ctx).cancelUniqueWork(BACKGROUND_WORKER_NAME)+ Log.i(TAG, "Cancelled background upload tasks")+ }++ companion object {+ private const val BACKGROUND_WORKER_NAME = "immich/BackgroundWorkerV1"+ private const val OBSERVER_WORKER_NAME = "immich/MediaObserverV1"++ const val WORKER_DATA_TASK_TYPE = "taskType"++ const val SHARED_PREF_NAME = "Immich::Background"+ const val SHARED_PREF_BACKUP_ENABLED = "Background::backup::enabled"+ const val SHARED_PREF_CALLBACK_HANDLE = "Background::backup::callbackHandle"++ private fun updateUploadEnabled(context: Context, enabled: Boolean) {+ context.getSharedPreferences(SHARED_PREF_NAME, Context.MODE_PRIVATE).edit {+ putBoolean(SHARED_PREF_BACKUP_ENABLED, enabled)+ }+ }++ private fun updateCallbackHandle(context: Context, callbackHandle: Long) {+ context.getSharedPreferences(SHARED_PREF_NAME, Context.MODE_PRIVATE).edit {+ putLong(SHARED_PREF_CALLBACK_HANDLE, callbackHandle)+ }+ }++ fun enqueueMediaObserver(ctx: Context) {+ val constraints = Constraints.Builder()+ .addContentUriTrigger(MediaStore.Images.Media.INTERNAL_CONTENT_URI, true)+ .addContentUriTrigger(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, true)+ .addContentUriTrigger(MediaStore.Video.Media.INTERNAL_CONTENT_URI, true)+ .addContentUriTrigger(MediaStore.Video.Media.EXTERNAL_CONTENT_URI, true)+ .setTriggerContentUpdateDelay(5, TimeUnit.SECONDS)+ .setTriggerContentMaxDelay(1, TimeUnit.MINUTES)+ .build()++ val work = OneTimeWorkRequest.Builder(MediaObserver::class.java)+ .setConstraints(constraints)+ .build()+ WorkManager.getInstance(ctx)+ .enqueueUniqueWork(OBSERVER_WORKER_NAME, ExistingWorkPolicy.REPLACE, work)++ Log.i(TAG, "Enqueued media observer worker with name: $OBSERVER_WORKER_NAME")+ }++ fun enqueueBackgroundWorker(ctx: Context, taskType: BackgroundTaskType) {+ val constraints = Constraints.Builder().setRequiresBatteryNotLow(true).build()++ val data = Data.Builder()+ data.putInt(WORKER_DATA_TASK_TYPE, taskType.ordinal)+ val work = OneTimeWorkRequest.Builder(BackgroundWorker::class.java)+ .setConstraints(constraints)+ .setBackoffCriteria(BackoffPolicy.EXPONENTIAL, 1, TimeUnit.MINUTES)+ .setInputData(data.build()).build()+ WorkManager.getInstance(ctx)+ .enqueueUniqueWork(BACKGROUND_WORKER_NAME, ExistingWorkPolicy.REPLACE, work)++ Log.i(TAG, "Enqueued background worker with name: $BACKGROUND_WORKER_NAME")+ }+ }+}diff --git a/mobile/android/app/src/main/kotlin/app/alextran/immich/background/MediaObserver.kt b/mobile/android/app/src/main/kotlin/app/alextran/immich/background/MediaObserver.ktnew file mode 100644index 0000000000..0ec6eeb3a5--- /dev/null+++ b/mobile/android/app/src/main/kotlin/app/alextran/immich/background/MediaObserver.kt@@ -0,0 +1,34 @@+package app.alextran.immich.background++import android.content.Context+import android.util.Log+import androidx.work.Worker+import androidx.work.WorkerParameters++class MediaObserver(context: Context, params: WorkerParameters) : Worker(context, params) {+ private val ctx: Context = context.applicationContext++ override fun doWork(): Result {+ Log.i("MediaObserver", "Content change detected, starting background worker")++ // Enqueue backup worker only if there are new media changes+ if (triggeredContentUris.isNotEmpty()) {+ val type =+ if (isBackupEnabled(ctx)) BackgroundTaskType.UPLOAD else BackgroundTaskType.LOCAL_SYNC+ BackgroundWorkerApiImpl.enqueueBackgroundWorker(ctx, type)+ }++ // Re-enqueue itself to listen for future changes+ BackgroundWorkerApiImpl.enqueueMediaObserver(ctx)+ return Result.success()+ }++ private fun isBackupEnabled(context: Context): Boolean {+ val prefs =+ context.getSharedPreferences(+ BackgroundWorkerApiImpl.SHARED_PREF_NAME,+ Context.MODE_PRIVATE+ )+ return prefs.getBoolean(BackgroundWorkerApiImpl.SHARED_PREF_BACKUP_ENABLED, false)+ }+}diff --git a/mobile/ios/Runner.xcodeproj/project.pbxproj b/mobile/ios/Runner.xcodeproj/project.pbxprojindex 827c9be881..087297ab71 100644--- a/mobile/ios/Runner.xcodeproj/project.pbxproj+++ b/mobile/ios/Runner.xcodeproj/project.pbxproj@@ -3,7 +3,7 @@archiveVersion = 1;classes = {};- objectVersion = 54;+ objectVersion = 77;objects = {/* Begin PBXBuildFile section */@@ -16,6 +16,9 @@97C146FC1CF9000F007C117D /* Main.storyboard in Resources */ = {isa = PBXBuildFile; fileRef = 97C146FA1CF9000F007C117D /* Main.storyboard */; };97C146FE1CF9000F007C117D /* Assets.xcassets in Resources */ = {isa = PBXBuildFile; fileRef = 97C146FD1CF9000F007C117D /* Assets.xcassets */; };97C147011CF9000F007C117D /* LaunchScreen.storyboard in Resources */ = {isa = PBXBuildFile; fileRef = 97C146FF1CF9000F007C117D /* LaunchScreen.storyboard */; };+ B21E34AA2E5AFD2B0031FDB9 /* BackgroundWorkerApiImpl.swift in Sources */ = {isa = PBXBuildFile; fileRef = B21E34A92E5AFD210031FDB9 /* BackgroundWorkerApiImpl.swift */; };+ B21E34AC2E5B09190031FDB9 /* BackgroundWorker.swift in Sources */ = {isa = PBXBuildFile; fileRef = B21E34AB2E5B09100031FDB9 /* BackgroundWorker.swift */; };+ B2BE315F2E5E5229006EEF88 /* BackgroundWorker.g.swift in Sources */ = {isa = PBXBuildFile; fileRef = B2BE315E2E5E5229006EEF88 /* BackgroundWorker.g.swift */; };D218389C4A4C4693F141F7D1 /* Pods_Runner.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 886774DBDDE6B35BF2B4F2CD /* Pods_Runner.framework */; };F02538E92DFBCBDD008C3FA3 /* Assets.xcassets in Resources */ = {isa = PBXBuildFile; fileRef = 97C146FD1CF9000F007C117D /* Assets.xcassets */; };F0B57D3A2DF764BD00DC5BCC /* WidgetKit.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = F0B57D392DF764BD00DC5BCC /* WidgetKit.framework */; };@@ -92,6 +95,9 @@97C147001CF9000F007C117D /* Base */ = {isa = PBXFileReference; lastKnownFileType = file.storyboard; name = Base; path = Base.lproj/LaunchScreen.storyboard; sourceTree = "<group>"; };97C147021CF9000F007C117D /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = "<group>"; };B1FBA9EE014DE20271B0FE77 /* Pods-ShareExtension.profile.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-ShareExtension.profile.xcconfig"; path = "Target Support Files/Pods-ShareExtension/Pods-ShareExtension.profile.xcconfig"; sourceTree = "<group>"; };+ B21E34A92E5AFD210031FDB9 /* BackgroundWorkerApiImpl.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = BackgroundWorkerApiImpl.swift; sourceTree = "<group>"; };+ B21E34AB2E5B09100031FDB9 /* BackgroundWorker.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = BackgroundWorker.swift; sourceTree = "<group>"; };+ B2BE315E2E5E5229006EEF88 /* BackgroundWorker.g.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = BackgroundWorker.g.swift; sourceTree = "<group>"; };E0E99CDC17B3EB7FA8BA2332 /* Pods-Runner.release.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-Runner.release.xcconfig"; path = "Target Support Files/Pods-Runner/Pods-Runner.release.xcconfig"; sourceTree = "<group>"; };F0B57D382DF764BD00DC5BCC /* WidgetExtension.appex */ = {isa = PBXFileReference; explicitFileType = "wrapper.app-extension"; includeInIndex = 0; path = WidgetExtension.appex; sourceTree = BUILT_PRODUCTS_DIR; };F0B57D392DF764BD00DC5BCC /* WidgetKit.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = WidgetKit.framework; path = System/Library/Frameworks/WidgetKit.framework; sourceTree = SDKROOT; };@@ -123,8 +129,6 @@/* Begin PBXFileSystemSynchronizedRootGroup section */B2CF7F8C2DDE4EBB00744BF6 /* Sync */ = {isa = PBXFileSystemSynchronizedRootGroup;- exceptions = (- );path = Sync;sourceTree = "<group>";};@@ -237,6 +241,7 @@97C146F01CF9000F007C117D /* Runner */ = {isa = PBXGroup;children = (+ B21E34A62E5AF9760031FDB9 /* Background */,B2CF7F8C2DDE4EBB00744BF6 /* Sync */,FA9973382CF6DF4B000EF859 /* Runner.entitlements */,65DD438629917FAD0047FFA8 /* BackgroundSync */,@@ -254,6 +259,16 @@path = Runner;sourceTree = "<group>";};+ B21E34A62E5AF9760031FDB9 /* Background */ = {+ isa = PBXGroup;+ children = (+ B2BE315E2E5E5229006EEF88 /* BackgroundWorker.g.swift */,+ B21E34AB2E5B09100031FDB9 /* BackgroundWorker.swift */,+ B21E34A92E5AFD210031FDB9 /* BackgroundWorkerApiImpl.swift */,+ );+ path = Background;+ sourceTree = "<group>";+ };FAC6F8B62D287F120078CB2F /* ShareExtension */ = {isa = PBXGroup;children = (@@ -490,10 +505,14 @@inputFileListPaths = ("${PODS_ROOT}/Target Support Files/Pods-Runner/Pods-Runner-resources-${CONFIGURATION}-input-files.xcfilelist",);+ inputPaths = (+ );name = "[CP] Copy Pods Resources";outputFileListPaths = ("${PODS_ROOT}/Target Support Files/Pods-Runner/Pods-Runner-resources-${CONFIGURATION}-output-files.xcfilelist",);+ outputPaths = (+ );runOnlyForDeploymentPostprocessing = 0;shellPath = /bin/sh;shellScript = "\"${PODS_ROOT}/Target Support Files/Pods-Runner/Pods-Runner-resources.sh\"\n";@@ -522,10 +541,14 @@inputFileListPaths = ("${PODS_ROOT}/Target Support Files/Pods-Runner/Pods-Runner-frameworks-${CONFIGURATION}-input-files.xcfilelist",);+ inputPaths = (+ );name = "[CP] Embed Pods Frameworks";outputFileListPaths = ("${PODS_ROOT}/Target Support Files/Pods-Runner/Pods-Runner-frameworks-${CONFIGURATION}-output-files.xcfilelist",);+ outputPaths = (+ );runOnlyForDeploymentPostprocessing = 0;shellPath = /bin/sh;shellScript = "\"${PODS_ROOT}/Target Support Files/Pods-Runner/Pods-Runner-frameworks.sh\"\n";@@ -540,10 +563,13 @@files = (65F32F31299BD2F800CE9261 /* BackgroundServicePlugin.swift in Sources */,74858FAF1ED2DC5600515810 /* AppDelegate.swift in Sources */,+ B21E34AC2E5B09190031FDB9 /* BackgroundWorker.swift in Sources */,FEAFA8732E4D42F4001E47FE /* Thumbhash.swift in Sources */,FED3B1962E253E9B0030FD97 /* ThumbnailsImpl.swift in Sources */,+ B21E34AA2E5AFD2B0031FDB9 /* BackgroundWorkerApiImpl.swift in Sources */,FED3B1972E253E9B0030FD97 /* Thumbnails.g.swift in Sources */,1498D2341E8E89220040F4C2 /* GeneratedPluginRegistrant.m in Sources */,+ B2BE315F2E5E5229006EEF88 /* BackgroundWorker.g.swift in Sources */,65F32F33299D349D00CE9261 /* BackgroundSyncWorker.swift in Sources */,);runOnlyForDeploymentPostprocessing = 0;diff --git a/mobile/ios/Runner/AppDelegate.swift b/mobile/ios/Runner/AppDelegate.swiftindex dedda5bd12..04422eb2b4 100644--- a/mobile/ios/Runner/AppDelegate.swift+++ b/mobile/ios/Runner/AppDelegate.swift@@ -19,13 +19,12 @@ import UIKit}GeneratedPluginRegistrant.register(with: self)- BackgroundServicePlugin.registerBackgroundProcessing()-- BackgroundServicePlugin.register(with: self.registrar(forPlugin: "BackgroundServicePlugin")!)-let controller: FlutterViewController = window?.rootViewController as! FlutterViewController- NativeSyncApiSetup.setUp(binaryMessenger: controller.binaryMessenger, api: NativeSyncApiImpl())- ThumbnailApiSetup.setUp(binaryMessenger: controller.binaryMessenger, api: ThumbnailApiImpl())+ AppDelegate.registerPlugins(binaryMessenger: controller.binaryMessenger)+ BackgroundServicePlugin.register(with: self.registrar(forPlugin: "BackgroundServicePlugin")!)++ BackgroundServicePlugin.registerBackgroundProcessing()+ BackgroundWorkerApiImpl.registerBackgroundProcessing()BackgroundServicePlugin.setPluginRegistrantCallback { registry inif !registry.hasPlugin("org.cocoapods.path-provider-foundation") {@@ -51,4 +50,10 @@ import UIKitreturn super.application(application, didFinishLaunchingWithOptions: launchOptions)}++ public static func registerPlugins(binaryMessenger: FlutterBinaryMessenger) {+ NativeSyncApiSetup.setUp(binaryMessenger: binaryMessenger, api: NativeSyncApiImpl())+ ThumbnailApiSetup.setUp(binaryMessenger: binaryMessenger, api: ThumbnailApiImpl())+ BackgroundWorkerFgHostApiSetup.setUp(binaryMessenger: binaryMessenger, api: BackgroundWorkerApiImpl())+ }}diff --git a/mobile/ios/Runner/Background/BackgroundWorker.g.swift b/mobile/ios/Runner/Background/BackgroundWorker.g.swiftnew file mode 100644index 0000000000..e9513db8da--- /dev/null+++ b/mobile/ios/Runner/Background/BackgroundWorker.g.swift@@ -0,0 +1,245 @@+// Autogenerated from Pigeon (v26.0.0), do not edit directly.+// See also: https://pub.dev/packages/pigeon++import Foundation++#if os(iOS)+ import Flutter+#elseif os(macOS)+ import FlutterMacOS+#else+ #error("Unsupported platform.")+#endif++private func wrapResult(_ result: Any?) -> [Any?] {+ return [result]+}++private func wrapError(_ error: Any) -> [Any?] {+ if let pigeonError = error as? PigeonError {+ return [+ pigeonError.code,+ pigeonError.message,+ pigeonError.details,+ ]+ }+ if let flutterError = error as? FlutterError {+ return [+ flutterError.code,+ flutterError.message,+ flutterError.details,+ ]+ }+ return [+ "\(error)",+ "\(type(of: error))",+ "Stacktrace: \(Thread.callStackSymbols)",+ ]+}++private func createConnectionError(withChannelName channelName: String) -> PigeonError {+ return PigeonError(code: "channel-error", message: "Unable to establish connection on channel: '\(channelName)'.", details: "")+}++private func isNullish(_ value: Any?) -> Bool {+ return value is NSNull || value == nil+}++private func nilOrValue<T>(_ value: Any?) -> T? {+ if value is NSNull { return nil }+ return value as! T?+}+++private class BackgroundWorkerPigeonCodecReader: FlutterStandardReader {+}++private class BackgroundWorkerPigeonCodecWriter: FlutterStandardWriter {+}++private class BackgroundWorkerPigeonCodecReaderWriter: FlutterStandardReaderWriter {+ override func reader(with data: Data) -> FlutterStandardReader {+ return BackgroundWorkerPigeonCodecReader(data: data)+ }++ override func writer(with data: NSMutableData) -> FlutterStandardWriter {+ return BackgroundWorkerPigeonCodecWriter(data: data)+ }+}++class BackgroundWorkerPigeonCodec: FlutterStandardMessageCodec, @unchecked Sendable {+ static let shared = BackgroundWorkerPigeonCodec(readerWriter: BackgroundWorkerPigeonCodecReaderWriter())+}++/// Generated protocol from Pigeon that represents a handler of messages from Flutter.+protocol BackgroundWorkerFgHostApi {+ func enableSyncWorker() throws+ func enableUploadWorker(callbackHandle: Int64) throws+ func disableUploadWorker() throws+}++/// Generated setup class from Pigeon to handle messages through the `binaryMessenger`.+class BackgroundWorkerFgHostApiSetup {+ static var codec: FlutterStandardMessageCodec { BackgroundWorkerPigeonCodec.shared }+ /// Sets up an instance of `BackgroundWorkerFgHostApi` to handle messages through the `binaryMessenger`.+ static func setUp(binaryMessenger: FlutterBinaryMessenger, api: BackgroundWorkerFgHostApi?, messageChannelSuffix: String = "") {+ let channelSuffix = messageChannelSuffix.count > 0 ? ".\(messageChannelSuffix)" : ""+ let enableSyncWorkerChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.immich_mobile.BackgroundWorkerFgHostApi.enableSyncWorker\(channelSuffix)", binaryMessenger: binaryMessenger, codec: codec)+ if let api = api {+ enableSyncWorkerChannel.setMessageHandler { _, reply in+ do {+ try api.enableSyncWorker()+ reply(wrapResult(nil))+ } catch {+ reply(wrapError(error))+ }+ }+ } else {+ enableSyncWorkerChannel.setMessageHandler(nil)+ }+ let enableUploadWorkerChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.immich_mobile.BackgroundWorkerFgHostApi.enableUploadWorker\(channelSuffix)", binaryMessenger: binaryMessenger, codec: codec)+ if let api = api {+ enableUploadWorkerChannel.setMessageHandler { message, reply in+ let args = message as! [Any?]+ let callbackHandleArg = args[0] as! Int64+ do {+ try api.enableUploadWorker(callbackHandle: callbackHandleArg)+ reply(wrapResult(nil))+ } catch {+ reply(wrapError(error))+ }+ }+ } else {+ enableUploadWorkerChannel.setMessageHandler(nil)+ }+ let disableUploadWorkerChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.immich_mobile.BackgroundWorkerFgHostApi.disableUploadWorker\(channelSuffix)", binaryMessenger: binaryMessenger, codec: codec)+ if let api = api {+ disableUploadWorkerChannel.setMessageHandler { _, reply in+ do {+ try api.disableUploadWorker()+ reply(wrapResult(nil))+ } catch {+ reply(wrapError(error))+ }+ }+ } else {+ disableUploadWorkerChannel.setMessageHandler(nil)+ }+ }+}+/// Generated protocol from Pigeon that represents a handler of messages from Flutter.+protocol BackgroundWorkerBgHostApi {+ func onInitialized() throws+}++/// Generated setup class from Pigeon to handle messages through the `binaryMessenger`.+class BackgroundWorkerBgHostApiSetup {+ static var codec: FlutterStandardMessageCodec { BackgroundWorkerPigeonCodec.shared }+ /// Sets up an instance of `BackgroundWorkerBgHostApi` to handle messages through the `binaryMessenger`.+ static func setUp(binaryMessenger: FlutterBinaryMessenger, api: BackgroundWorkerBgHostApi?, messageChannelSuffix: String = "") {+ let channelSuffix = messageChannelSuffix.count > 0 ? ".\(messageChannelSuffix)" : ""+ let onInitializedChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.immich_mobile.BackgroundWorkerBgHostApi.onInitialized\(channelSuffix)", binaryMessenger: binaryMessenger, codec: codec)+ if let api = api {+ onInitializedChannel.setMessageHandler { _, reply in+ do {+ try api.onInitialized()+ reply(wrapResult(nil))+ } catch {+ reply(wrapError(error))+ }+ }+ } else {+ onInitializedChannel.setMessageHandler(nil)+ }+ }+}+/// Generated protocol from Pigeon that represents Flutter messages that can be called from Swift.+protocol BackgroundWorkerFlutterApiProtocol {+ func onLocalSync(maxSeconds maxSecondsArg: Int64?, completion: @escaping (Result<Void, PigeonError>) -> Void)+ func onIosUpload(isRefresh isRefreshArg: Bool, maxSeconds maxSecondsArg: Int64?, completion: @escaping (Result<Void, PigeonError>) -> Void)+ func onAndroidUpload(completion: @escaping (Result<Void, PigeonError>) -> Void)+ func cancel(completion: @escaping (Result<Void, PigeonError>) -> Void)+}+class BackgroundWorkerFlutterApi: BackgroundWorkerFlutterApiProtocol {+ private let binaryMessenger: FlutterBinaryMessenger+ private let messageChannelSuffix: String+ init(binaryMessenger: FlutterBinaryMessenger, messageChannelSuffix: String = "") {+ self.binaryMessenger = binaryMessenger+ self.messageChannelSuffix = messageChannelSuffix.count > 0 ? ".\(messageChannelSuffix)" : ""+ }+ var codec: BackgroundWorkerPigeonCodec {+ return BackgroundWorkerPigeonCodec.shared+ }+ func onLocalSync(maxSeconds maxSecondsArg: Int64?, completion: @escaping (Result<Void, PigeonError>) -> Void) {+ let channelName: String = "dev.flutter.pigeon.immich_mobile.BackgroundWorkerFlutterApi.onLocalSync\(messageChannelSuffix)"+ let channel = FlutterBasicMessageChannel(name: channelName, binaryMessenger: binaryMessenger, codec: codec)+ channel.sendMessage([maxSecondsArg] as [Any?]) { response in+ guard let listResponse = response as? [Any?] else {+ completion(.failure(createConnectionError(withChannelName: channelName)))+ return+ }+ if listResponse.count > 1 {+ let code: String = listResponse[0] as! String+ let message: String? = nilOrValue(listResponse[1])+ let details: String? = nilOrValue(listResponse[2])+ completion(.failure(PigeonError(code: code, message: message, details: details)))+ } else {+ completion(.success(()))+ }+ }+ }+ func onIosUpload(isRefresh isRefreshArg: Bool, maxSeconds maxSecondsArg: Int64?, completion: @escaping (Result<Void, PigeonError>) -> Void) {+ let channelName: String = "dev.flutter.pigeon.immich_mobile.BackgroundWorkerFlutterApi.onIosUpload\(messageChannelSuffix)"+ let channel = FlutterBasicMessageChannel(name: channelName, binaryMessenger: binaryMessenger, codec: codec)+ channel.sendMessage([isRefreshArg, maxSecondsArg] as [Any?]) { response in+ guard let listResponse = response as? [Any?] else {+ completion(.failure(createConnectionError(withChannelName: channelName)))+ return+ }+ if listResponse.count > 1 {+ let code: String = listResponse[0] as! String+ let message: String? = nilOrValue(listResponse[1])+ let details: String? = nilOrValue(listResponse[2])+ completion(.failure(PigeonError(code: code, message: message, details: details)))+ } else {+ completion(.success(()))+ }+ }+ }+ func onAndroidUpload(completion: @escaping (Result<Void, PigeonError>) -> Void) {+ let channelName: String = "dev.flutter.pigeon.immich_mobile.BackgroundWorkerFlutterApi.onAndroidUpload\(messageChannelSuffix)"+ let channel = FlutterBasicMessageChannel(name: channelName, binaryMessenger: binaryMessenger, codec: codec)+ channel.sendMessage(nil) { response in+ guard let listResponse = response as? [Any?] else {+ completion(.failure(createConnectionError(withChannelName: channelName)))+ return+ }+ if listResponse.count > 1 {+ let code: String = listResponse[0] as! String+ let message: String? = nilOrValue(listResponse[1])+ let details: String? = nilOrValue(listResponse[2])+ completion(.failure(PigeonError(code: code, message: message, details: details)))+ } else {+ completion(.success(()))+ }+ }+ }+ func cancel(completion: @escaping (Result<Void, PigeonError>) -> Void) {+ let channelName: String = "dev.flutter.pigeon.immich_mobile.BackgroundWorkerFlutterApi.cancel\(messageChannelSuffix)"+ let channel = FlutterBasicMessageChannel(name: channelName, binaryMessenger: binaryMessenger, codec: codec)+ channel.sendMessage(nil) { response in+ guard let listResponse = response as? [Any?] else {+ completion(.failure(createConnectionError(withChannelName: channelName)))+ return+ }+ if listResponse.count > 1 {+ let code: String = listResponse[0] as! String+ let message: String? = nilOrValue(listResponse[1])+ let details: String? = nilOrValue(listResponse[2])+ completion(.failure(PigeonError(code: code, message: message, details: details)))+ } else {+ completion(.success(()))+ }+ }+ }+}diff --git a/mobile/ios/Runner/Background/BackgroundWorker.swift b/mobile/ios/Runner/Background/BackgroundWorker.swiftnew file mode 100644index 0000000000..db849d942b--- /dev/null+++ b/mobile/ios/Runner/Background/BackgroundWorker.swift@@ -0,0 +1,202 @@+import BackgroundTasks+import Flutter++enum BackgroundTaskType { case localSync, refreshUpload, processingUpload }++/*+ * DEBUG: Testing Background Tasks in Xcode+ *+ * To test background task functionality during development:+ * 1. Pause the application in Xcode debugger+ * 2. In the debugger console, enter one of the following commands:++ ## For local sync (short-running sync):++ e -l objc -- (void)[[BGTaskScheduler sharedScheduler] _simulateLaunchForTaskWithIdentifier:@"app.alextran.immich.background.localSync"]++ ## For background refresh (short-running sync):++ e -l objc -- (void)[[BGTaskScheduler sharedScheduler] _simulateLaunchForTaskWithIdentifier:@"app.alextran.immich.background.refreshUpload"]++ ## For background processing (long-running upload):++ e -l objc -- (void)[[BGTaskScheduler sharedScheduler] _simulateLaunchForTaskWithIdentifier:@"app.alextran.immich.background.processingUpload"]++ * To simulate task expiration (useful for testing expiration handlers):++ e -l objc -- (void)[[BGTaskScheduler sharedScheduler] _simulateExpirationForTaskWithIdentifier:@"app.alextran.immich.background.localSync"]++ e -l objc -- (void)[[BGTaskScheduler sharedScheduler] _simulateExpirationForTaskWithIdentifier:@"app.alextran.immich.background.refreshUpload"]++ e -l objc -- (void)[[BGTaskScheduler sharedScheduler] _simulateExpirationForTaskWithIdentifier:@"app.alextran.immich.background.processingUpload"]++ * 3. Resume the application to see the background code execute+ *+ * NOTE: This must be tested on a physical device, not in the simulator.+ * In testing, only the background processing task can be reliably simulated.+ * These commands submit the respective task to BGTaskScheduler for immediate processing.+ * Use the expiration commands to test how the app handles iOS terminating background tasks.+ */+++/// 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.+/// This class manages a separate Flutter engine instance for background execution,+/// independent of the main UI Flutter engine.+class BackgroundWorker: BackgroundWorkerBgHostApi {+ private let taskType: BackgroundTaskType+ /// The maximum number of seconds to run the task before timing out+ private let maxSeconds: Int?+ /// Callback function to invoke when the background task completes+ private let completionHandler: (_ success: Bool) -> Void++ /// The Flutter engine created specifically for background execution.+ /// This is a separate instance from the main Flutter engine that handles the UI.+ /// It operates in its own isolate and doesn't share memory with the main engine.+ /// Must be properly started, registered, and torn down during background execution.+ private let engine = FlutterEngine(name: "BackgroundImmich")++ /// Used to call methods on the flutter side+ private var flutterApi: BackgroundWorkerFlutterApi?++ /// Flag to track whether the background task has completed to prevent duplicate completions+ private var isComplete = false++ /**+ * Initializes a new background worker with the specified task type and execution constraints.+ * Creates a new Flutter engine instance for background execution and sets up the necessary+ * communication channels between native iOS and Flutter code.+ *+ * - Parameters:+ * - taskType: The type of background task to execute (upload or sync task)+ * - maxSeconds: Optional maximum execution time in seconds before the task is cancelled+ * - completionHandler: Callback function invoked when the task completes, with success status+ */+ init(taskType: BackgroundTaskType, maxSeconds: Int?, completionHandler: @escaping (_ success: Bool) -> Void) {+ self.taskType = taskType+ self.maxSeconds = maxSeconds+ self.completionHandler = completionHandler+ // Should be initialized only after the engine starts running+ self.flutterApi = nil+ }++ /**+ * Starts the background Flutter engine and begins execution of the background task.+ * Retrieves the callback handle from UserDefaults, looks up the Flutter callback,+ * starts the engine, and sets up a timeout timer if specified.+ */+ func run() {+ // Retrieve the callback handle stored by the main Flutter app+ // This handle points to the Flutter function that should be executed in the background+ let callbackHandle = Int64(UserDefaults.standard.string(+ forKey: BackgroundWorkerApiImpl.backgroundUploadCallbackHandleKey) ?? "0") ?? 0++ if callbackHandle == 0 {+ // Without a valid callback handle, we cannot start the Flutter background execution+ complete(success: false)+ return+ }++ // Use the callback handle to retrieve the actual Flutter callback information+ guard let callback = FlutterCallbackCache.lookupCallbackInformation(callbackHandle) else {+ // The callback handle is invalid or the callback was not found+ complete(success: false)+ return+ }++ // Start the Flutter engine with the specified callback as the entry point+ let isRunning = engine.run(+ withEntrypoint: callback.callbackName,+ libraryURI: callback.callbackLibraryPath+ )++ // Verify that the Flutter engine started successfully+ if !isRunning {+ complete(success: false)+ return+ }++ // Register plugins in the new engine+ GeneratedPluginRegistrant.register(with: engine)+ // Register custom plugins+ AppDelegate.registerPlugins(binaryMessenger: engine.binaryMessenger)+ flutterApi = BackgroundWorkerFlutterApi(binaryMessenger: engine.binaryMessenger)+ BackgroundWorkerBgHostApiSetup.setUp(binaryMessenger: engine.binaryMessenger, api: self)++ // Set up a timeout timer if maxSeconds was specified to prevent runaway background tasks+ if maxSeconds != nil {+ // Schedule a timer to cancel the task after the specified timeout period+ Timer.scheduledTimer(withTimeInterval: TimeInterval(maxSeconds!), repeats: false) { _ in+ self.cancel()+ }+ }+ }++ /**+ * Called by the Flutter side when it has finished initialization and is ready to receive commands.+ * Routes the appropriate task type (refresh or processing) to the corresponding Flutter method.+ * This method acts as a bridge between the native iOS background task system and Flutter.+ */+ func onInitialized() throws {+ switch self.taskType {+ case .refreshUpload, .processingUpload:+ flutterApi?.onIosUpload(isRefresh: self.taskType == .refreshUpload,+ maxSeconds: maxSeconds.map { Int64($0) }, completion: { result in+ self.handleHostResult(result: result)+ })+ case .localSync:+ flutterApi?.onLocalSync(maxSeconds: maxSeconds.map { Int64($0) }, completion: { result in+ self.handleHostResult(result: result)+ })+ }+ }++ /**+ * Cancels the currently running background task, either due to timeout or external request.+ * Sends a cancel signal to the Flutter side and sets up a fallback timer to ensure+ * the completion handler is eventually called even if Flutter doesn't respond.+ */+ func cancel() {+ if isComplete {+ return+ }++ isComplete = true+ flutterApi?.cancel { result in+ self.complete(success: false)+ }++ // Fallback safety mechanism: ensure completion is called within 2 seconds+ // This prevents the background task from hanging indefinitely if Flutter doesn't respond+ Timer.scheduledTimer(withTimeInterval: 2, repeats: false) { _ in+ self.complete(success: false)+ }+ }++ /**+ * Handles the result from Flutter API calls and determines the success/failure status.+ * Converts Flutter's Result type to a simple boolean success indicator for task completion.+ *+ * - Parameter result: The result returned from a Flutter API call+ */+ private func handleHostResult(result: Result<Void, PigeonError>) {+ switch result {+ case .success(): self.complete(success: true)+ case .failure(_): self.cancel()+ }+ }++ /**+ * Cleans up resources by destroying the Flutter engine context and invokes the completion handler.+ * This method ensures that the background task is marked as complete, releases the Flutter engine,+ * and notifies the caller of the task's success or failure. This is the final step in the+ * background task lifecycle and should only be called once per task instance.+ *+ * - Parameter success: Indicates whether the background task completed successfully+ */+ private func complete(success: Bool) {+ isComplete = true+ engine.destroyContext()+ completionHandler(success)+ }+}diff --git a/mobile/ios/Runner/Background/BackgroundWorkerApiImpl.swift b/mobile/ios/Runner/Background/BackgroundWorkerApiImpl.swiftnew file mode 100644index 0000000000..f36085de0b--- /dev/null+++ b/mobile/ios/Runner/Background/BackgroundWorkerApiImpl.swift@@ -0,0 +1,155 @@+import BackgroundTasks++class BackgroundWorkerApiImpl: BackgroundWorkerFgHostApi {+ func enableSyncWorker() throws {+ BackgroundWorkerApiImpl.scheduleLocalSync()+ print("BackgroundUploadImpl:enableSyncWorker Local Sync worker scheduled")+ }++ func enableUploadWorker(callbackHandle: Int64) throws {+ BackgroundWorkerApiImpl.updateUploadEnabled(true)+ // Store the callback handle for later use when starting background Flutter isolates+ BackgroundWorkerApiImpl.updateUploadCallbackHandle(callbackHandle)++ BackgroundWorkerApiImpl.scheduleRefreshUpload()+ BackgroundWorkerApiImpl.scheduleProcessingUpload()+ print("BackgroundUploadImpl:enableUploadWorker Scheduled background upload tasks")+ }++ func disableUploadWorker() throws {+ BackgroundWorkerApiImpl.updateUploadEnabled(false)+ BackgroundWorkerApiImpl.cancelUploadTasks()+ print("BackgroundUploadImpl:disableUploadWorker Disabled background upload tasks")+ }++ public static let backgroundUploadEnabledKey = "immich:background:backup:enabled"+ public static let backgroundUploadCallbackHandleKey = "immich:background:backup:callbackHandle"++ private static let localSyncTaskID = "app.alextran.immich.background.localSync"+ private static let refreshUploadTaskID = "app.alextran.immich.background.refreshUpload"+ private static let processingUploadTaskID = "app.alextran.immich.background.processingUpload"++ private static func updateUploadEnabled(_ isEnabled: Bool) {+ return UserDefaults.standard.set(isEnabled, forKey: BackgroundWorkerApiImpl.backgroundUploadEnabledKey)+ }++ private static func updateUploadCallbackHandle(_ callbackHandle: Int64) {+ return UserDefaults.standard.set(String(callbackHandle), forKey: BackgroundWorkerApiImpl.backgroundUploadCallbackHandleKey)+ }++ private static func cancelUploadTasks() {+ BackgroundWorkerApiImpl.updateUploadEnabled(false)+ BGTaskScheduler.shared.cancel(taskRequestWithIdentifier: refreshUploadTaskID);+ BGTaskScheduler.shared.cancel(taskRequestWithIdentifier: processingUploadTaskID);+ }++ public static func registerBackgroundProcessing() {+ BGTaskScheduler.shared.register(+ forTaskWithIdentifier: processingUploadTaskID, using: nil) { task in+ if task is BGProcessingTask {+ handleBackgroundProcessing(task: task as! BGProcessingTask)+ }+ }++ BGTaskScheduler.shared.register(+ forTaskWithIdentifier: refreshUploadTaskID, using: nil) { task in+ if task is BGAppRefreshTask {+ handleBackgroundRefresh(task: task as! BGAppRefreshTask, taskType: .refreshUpload)+ }+ }++ BGTaskScheduler.shared.register(+ forTaskWithIdentifier: localSyncTaskID, using: nil) { task in+ if task is BGAppRefreshTask {+ handleBackgroundRefresh(task: task as! BGAppRefreshTask, taskType: .localSync)+ }+ }+ }++ private static func scheduleLocalSync() {+ let backgroundRefresh = BGAppRefreshTaskRequest(identifier: localSyncTaskID)+ backgroundRefresh.earliestBeginDate = Date(timeIntervalSinceNow: 5 * 60) // 5 mins++ do {+ try BGTaskScheduler.shared.submit(backgroundRefresh)+ } catch {+ print("Could not schedule the local sync task \(error.localizedDescription)")+ }+ }++ private static func scheduleRefreshUpload() {+ let backgroundRefresh = BGAppRefreshTaskRequest(identifier: refreshUploadTaskID)+ backgroundRefresh.earliestBeginDate = Date(timeIntervalSinceNow: 5 * 60) // 5 mins++ do {+ try BGTaskScheduler.shared.submit(backgroundRefresh)+ } catch {+ print("Could not schedule the refresh upload task \(error.localizedDescription)")+ }+ }++ private static func scheduleProcessingUpload() {+ let backgroundProcessing = BGProcessingTaskRequest(identifier: processingUploadTaskID)++ backgroundProcessing.requiresNetworkConnectivity = true+ backgroundProcessing.earliestBeginDate = Date(timeIntervalSinceNow: 15 * 60) // 15 mins++ do {+ try BGTaskScheduler.shared.submit(backgroundProcessing)+ } catch {+ print("Could not schedule the processing upload task \(error.localizedDescription)")+ }+ }++ private static func handleBackgroundRefresh(task: BGAppRefreshTask, taskType: BackgroundTaskType) {+ scheduleRefreshUpload()+ // Restrict the refresh task to run only for a maximum of 20 seconds+ runBackgroundWorker(task: task, taskType: taskType, maxSeconds: 20)+ }++ private static func handleBackgroundProcessing(task: BGProcessingTask) {+ scheduleProcessingUpload()+ // There are no restrictions for processing tasks. Although, the OS could signal expiration at any time+ runBackgroundWorker(task: task, taskType: .processingUpload, maxSeconds: nil)+ }++ /**+ * Executes the background worker within the context of a background task.+ * This method creates a BackgroundWorker, sets up task expiration handling,+ * and manages the synchronization between the background task and the Flutter engine.+ *+ * - Parameters:+ * - task: The iOS background task that provides the execution context+ * - taskType: The type of background operation to perform (refresh or processing)+ * - maxSeconds: Optional timeout for the operation in seconds+ */+ private static func runBackgroundWorker(task: BGTask, taskType: BackgroundTaskType, maxSeconds: Int?) {+ let semaphore = DispatchSemaphore(value: 0)+ var isSuccess = true++ let backgroundWorker = BackgroundWorker(taskType: taskType, maxSeconds: maxSeconds) { success in+ isSuccess = success+ semaphore.signal()+ }++ task.expirationHandler = {+ DispatchQueue.main.async {+ backgroundWorker.cancel()+ }+ isSuccess = false++ // Schedule a timer to signal the semaphore after 2 seconds+ Timer.scheduledTimer(withTimeInterval: 2, repeats: false) { _ in+ semaphore.signal()+ }+ }++ DispatchQueue.main.async {+ backgroundWorker.run()+ }++ semaphore.wait()+ task.setTaskCompleted(success: isSuccess)+ print("Background task completed with success: \(isSuccess)")+ }+}diff --git a/mobile/ios/Runner/Info.plist b/mobile/ios/Runner/Info.plistindex 5db281ea86..1a3658ed16 100644--- a/mobile/ios/Runner/Info.plist+++ b/mobile/ios/Runner/Info.plist@@ -6,6 +6,9 @@<string>$(CUSTOM_GROUP_ID)</string><key>BGTaskSchedulerPermittedIdentifiers</key><array>+ <string>app.alextran.immich.background.localSync</string>+ <string>app.alextran.immich.background.refreshUpload</string>+ <string>app.alextran.immich.background.processingUpload</string><string>app.alextran.immich.backgroundFetch</string><string>app.alextran.immich.backgroundProcessing</string></array>@@ -78,7 +81,7 @@<key>CFBundlePackageType</key><string>APPL</string><key>CFBundleShortVersionString</key>- <string>1.139.4</string>+ <string>1.139.3</string><key>CFBundleSignature</key><string>????</string><key>CFBundleURLTypes</key>@@ -105,7 +108,7 @@</dict></array><key>CFBundleVersion</key>- <string>218</string>+ <string>217</string><key>FLTEnableImpeller</key><true /><key>ITSAppUsesNonExemptEncryption</key>@@ -134,6 +137,9 @@<string>We need to access the camera to let you take beautiful video using this app</string><key>NSFaceIDUsageDescription</key><string>We need to use FaceID to allow access to your locked folder</string>+ <key>NSLocalNetworkUsageDescription</key>+ <string>We need local network permission to connect to the local server using IP address and+ allow the casting feature to work</string><key>NSLocationAlwaysAndWhenInUseUsageDescription</key><string>We require this permission to access the local WiFi name for background upload mechanism</string><key>NSLocationUsageDescription</key>@@ -180,8 +186,5 @@<true /><key>io.flutter.embedded_views_preview</key><true />- <key>NSLocalNetworkUsageDescription</key>- <string>We need local network permission to connect to the local server using IP address and- allow the casting feature to work</string></dict>-</plist>+</plist>\ No newline at end of filediff --git a/mobile/lib/domain/services/background_worker.service.dart b/mobile/lib/domain/services/background_worker.service.dartnew file mode 100644index 0000000000..33c58cf743--- /dev/null+++ b/mobile/lib/domain/services/background_worker.service.dart@@ -0,0 +1,232 @@+import 'dart:async';+import 'dart:ui';++import 'package:background_downloader/background_downloader.dart';+import 'package:flutter/material.dart';+import 'package:hooks_riverpod/hooks_riverpod.dart';+import 'package:immich_mobile/constants/constants.dart';+import 'package:immich_mobile/infrastructure/repositories/db.repository.dart';+import 'package:immich_mobile/infrastructure/repositories/logger_db.repository.dart';+import 'package:immich_mobile/platform/background_worker_api.g.dart';+import 'package:immich_mobile/providers/app_settings.provider.dart';+import 'package:immich_mobile/providers/background_sync.provider.dart';+import 'package:immich_mobile/providers/backup/drift_backup.provider.dart';+import 'package:immich_mobile/providers/db.provider.dart';+import 'package:immich_mobile/providers/infrastructure/db.provider.dart';+import 'package:immich_mobile/providers/user.provider.dart';+import 'package:immich_mobile/services/app_settings.service.dart';+import 'package:immich_mobile/services/auth.service.dart';+import 'package:immich_mobile/services/localization.service.dart';+import 'package:immich_mobile/services/upload.service.dart';+import 'package:immich_mobile/utils/bootstrap.dart';+import 'package:immich_mobile/utils/http_ssl_options.dart';+import 'package:isar/isar.dart';+import 'package:logging/logging.dart';++class BackgroundWorkerFgService {+ final BackgroundWorkerFgHostApi _foregroundHostApi;++ const BackgroundWorkerFgService(this._foregroundHostApi);++ // TODO: Move this call to native side once old timeline is removed+ Future<void> enableSyncService() => _foregroundHostApi.enableSyncWorker();++ Future<void> enableUploadService() => _foregroundHostApi.enableUploadWorker(+ PluginUtilities.getCallbackHandle(_backgroundSyncNativeEntrypoint)!.toRawHandle(),+ );++ Future<void> disableUploadService() => _foregroundHostApi.disableUploadWorker();+}++class BackgroundWorkerBgService extends BackgroundWorkerFlutterApi {+ late final ProviderContainer _ref;+ final Isar _isar;+ final Drift _drift;+ final DriftLogger _driftLogger;+ final BackgroundWorkerBgHostApi _backgroundHostApi;+ final Logger _logger = Logger('BackgroundUploadBgService');++ bool _isCleanedUp = false;++ BackgroundWorkerBgService({required Isar isar, required Drift drift, required DriftLogger driftLogger})+ : _isar = isar,+ _drift = drift,+ _driftLogger = driftLogger,+ _backgroundHostApi = BackgroundWorkerBgHostApi() {+ _ref = ProviderContainer(+ overrides: [+ dbProvider.overrideWithValue(isar),+ isarProvider.overrideWithValue(isar),+ driftProvider.overrideWith(driftOverride(drift)),+ ],+ );+ BackgroundWorkerFlutterApi.setUp(this);+ }++ bool get _isBackupEnabled => _ref.read(appSettingsServiceProvider).getSetting(AppSettingsEnum.enableBackup);++ Future<void> init() async {+ await loadTranslations();+ HttpSSLOptions.apply(applyNative: false);+ await _ref.read(authServiceProvider).setOpenApiServiceEndpoint();++ // Initialize the file downloader+ await FileDownloader().configure(+ globalConfig: [+ // maxConcurrent: 6, maxConcurrentByHost(server):6, maxConcurrentByGroup: 3+ (Config.holdingQueue, (6, 6, 3)),+ // On Android, if files are larger than 256MB, run in foreground service+ (Config.runInForegroundIfFileLargerThan, 256),+ ],+ );+ await FileDownloader().trackTasksInGroup(kDownloadGroupLivePhoto, markDownloadedComplete: false);+ await FileDownloader().trackTasks();+ configureFileDownloaderNotifications();++ // Notify the host that the background upload service has been initialized and is ready to use+ await _backgroundHostApi.onInitialized();+ }++ @override+ Future<void> onLocalSync(int? maxSeconds) async {+ _logger.info('Local background syncing started');+ final sw = Stopwatch()..start();++ final timeout = maxSeconds != null ? Duration(seconds: maxSeconds) : null;+ await _syncAssets(hashTimeout: timeout, syncRemote: false);++ sw.stop();+ _logger.info("Local sync completed in ${sw.elapsed.inSeconds}s");+ }++ /* We do the following on Android upload+ * - Sync local assets+ * - Hash local assets 3 / 6 minutes+ * - Sync remote assets+ * - Check and requeue upload tasks+ */+ @override+ Future<void> onAndroidUpload() async {+ _logger.info('Android background processing started');+ final sw = Stopwatch()..start();++ await _syncAssets(hashTimeout: Duration(minutes: _isBackupEnabled ? 3 : 6));+ await _handleBackup(processBulk: false);++ await _cleanup();++ sw.stop();+ _logger.info("Android background processing completed in ${sw.elapsed.inSeconds}s");+ }++ /* We do the following on background upload+ * - Sync local assets+ * - Hash local assets+ * - Sync remote assets+ * - Check and requeue upload tasks+ *+ * The native side will not send the maxSeconds value for processing tasks+ */+ @override+ Future<void> onIosUpload(bool isRefresh, int? maxSeconds) async {+ _logger.info('iOS background upload started with maxSeconds: ${maxSeconds}s');+ final sw = Stopwatch()..start();++ final timeout = isRefresh ? const Duration(seconds: 5) : Duration(minutes: _isBackupEnabled ? 3 : 6);+ await _syncAssets(hashTimeout: timeout);++ final backupFuture = _handleBackup();+ if (maxSeconds != null) {+ await backupFuture.timeout(Duration(seconds: maxSeconds - 1), onTimeout: () {});+ } else {+ await backupFuture;+ }++ await _cleanup();++ sw.stop();+ _logger.info("iOS background upload completed in ${sw.elapsed.inSeconds}s");+ }++ @override+ Future<void> cancel() async {+ _logger.warning("Background upload cancelled");+ await _cleanup();+ }++ Future<void> _cleanup() async {+ if (_isCleanedUp) {+ return;+ }++ _isCleanedUp = true;+ await _ref.read(backgroundSyncProvider).cancel();+ await _ref.read(backgroundSyncProvider).cancelLocal();+ await _isar.close();+ await _drift.close();+ await _driftLogger.close();+ _ref.dispose();+ }++ Future<void> _handleBackup({bool processBulk = true}) async {+ if (!_isBackupEnabled) {+ return;+ }++ final currentUser = _ref.read(currentUserProvider);+ if (currentUser == null) {+ return;+ }++ if (processBulk) {+ return _ref.read(driftBackupProvider.notifier).handleBackupResume(currentUser.id);+ }++ final activeTask = await _ref.read(uploadServiceProvider).getActiveTasks(currentUser.id);+ if (activeTask.isNotEmpty) {+ await _ref.read(uploadServiceProvider).resumeBackup();+ } else {+ await _ref.read(uploadServiceProvider).startBackupSerial(currentUser.id);+ }+ }++ Future<void> _syncAssets({Duration? hashTimeout, bool syncRemote = true}) async {+ final futures = <Future<void>>[];++ final localSyncFuture = _ref.read(backgroundSyncProvider).syncLocal().then((_) async {+ if (_isCleanedUp) {+ return;+ }++ var hashFuture = _ref.read(backgroundSyncProvider).hashAssets();+ if (hashTimeout != null) {+ hashFuture = hashFuture.timeout(+ hashTimeout,+ onTimeout: () {+ // Consume cancellation errors as we want to continue processing+ },+ );+ }++ return hashFuture;+ });++ futures.add(localSyncFuture);+ if (syncRemote) {+ final remoteSyncFuture = _ref.read(backgroundSyncProvider).syncRemote();+ futures.add(remoteSyncFuture);+ }++ await Future.wait(futures);+ }+}++@pragma('vm:entry-point')+Future<void> _backgroundSyncNativeEntrypoint() async {+ WidgetsFlutterBinding.ensureInitialized();+ DartPluginRegistrant.ensureInitialized();++ final (isar, drift, logDB) = await Bootstrap.initDB();+ await Bootstrap.initDomain(isar, drift, logDB, shouldBufferLogs: false);+ await BackgroundWorkerBgService(isar: isar, drift: drift, driftLogger: logDB).init();+}diff --git a/mobile/lib/domain/services/hash.service.dart b/mobile/lib/domain/services/hash.service.dartindex a8eea2c25e..90720fdc76 100644--- a/mobile/lib/domain/services/hash.service.dart+++ b/mobile/lib/domain/services/hash.service.dart@@ -15,6 +15,7 @@ class HashService {final DriftLocalAssetRepository _localAssetRepository;final StorageRepository _storageRepository;final NativeSyncApi _nativeSyncApi;+ final bool Function()? _cancelChecker;final _log = Logger('HashService');HashService({@@ -22,13 +23,17 @@ class HashService {required DriftLocalAssetRepository localAssetRepository,required StorageRepository storageRepository,required NativeSyncApi nativeSyncApi,+ bool Function()? cancelChecker,this.batchSizeLimit = kBatchHashSizeLimit,this.batchFileLimit = kBatchHashFileLimit,}) : _localAlbumRepository = localAlbumRepository,_localAssetRepository = localAssetRepository,_storageRepository = storageRepository,+ _cancelChecker = cancelChecker,_nativeSyncApi = nativeSyncApi;+ bool get isCancelled => _cancelChecker?.call() ?? false;+Future<void> hashAssets() async {final Stopwatch stopwatch = Stopwatch()..start();// Sorted by backupSelection followed by isCloud@@ -37,6 +42,11 @@ class HashService {);for (final album in localAlbums) {+ if (isCancelled) {+ _log.warning("Hashing cancelled. Stopped processing albums.");+ break;+ }+final assetsToHash = await _localAlbumRepository.getAssetsToHash(album.id);if (assetsToHash.isNotEmpty) {await _hashAssets(assetsToHash);@@ -55,6 +65,11 @@ class HashService {final toHash = <_AssetToPath>[];for (final asset in assetsToHash) {+ if (isCancelled) {+ _log.warning("Hashing cancelled. Stopped processing assets.");+ return;+ }+final file = await _storageRepository.getFileForAsset(asset.id);if (file == null) {continue;@@ -89,6 +104,11 @@ class HashService {);for (int i = 0; i < hashes.length; i++) {+ if (isCancelled) {+ _log.warning("Hashing cancelled. Stopped processing batch.");+ return;+ }+final hash = hashes[i];final asset = toHash[i].asset;if (hash?.length == 20) {diff --git a/mobile/lib/domain/services/log.service.dart b/mobile/lib/domain/services/log.service.dartindex 1053d5e54f..d21cb7ab09 100644--- a/mobile/lib/domain/services/log.service.dart+++ b/mobile/lib/domain/services/log.service.dart@@ -123,6 +123,11 @@ class LogService {_flushTimer = null;final buffer = [..._msgBuffer];_msgBuffer.clear();++ if (buffer.isEmpty) {+ return;+ }+await _logRepository.insertAll(buffer);}}diff --git a/mobile/lib/domain/utils/background_sync.dart b/mobile/lib/domain/utils/background_sync.dartindex cbf4030788..d8042c707c 100644--- a/mobile/lib/domain/utils/background_sync.dart+++ b/mobile/lib/domain/utils/background_sync.dart@@ -59,6 +59,28 @@ class BackgroundSyncManager {}}+ Future<void> cancelLocal() async {+ final futures = <Future>[];++ if (_hashTask != null) {+ futures.add(_hashTask!.future);+ }+ _hashTask?.cancel();+ _hashTask = null;++ if (_deviceAlbumSyncTask != null) {+ futures.add(_deviceAlbumSyncTask!.future);+ }+ _deviceAlbumSyncTask?.cancel();+ _deviceAlbumSyncTask = null;++ try {+ await Future.wait(futures);+ } on CanceledError {+ // Ignore cancellation errors+ }+ }+// No need to cancel the task, as it can also be run when the user logs outFuture<void> syncLocal({bool full = false}) {if (_deviceAlbumSyncTask != null) {diff --git a/mobile/lib/main.dart b/mobile/lib/main.dartindex 0cab21748c..21093df24d 100644--- a/mobile/lib/main.dart+++ b/mobile/lib/main.dart@@ -12,10 +12,13 @@ import 'package:flutter_displaymode/flutter_displaymode.dart';import 'package:hooks_riverpod/hooks_riverpod.dart';import 'package:immich_mobile/constants/constants.dart';import 'package:immich_mobile/constants/locales.dart';+import 'package:immich_mobile/entities/store.entity.dart';import 'package:immich_mobile/extensions/build_context_extensions.dart';import 'package:immich_mobile/generated/codegen_loader.g.dart';import 'package:immich_mobile/providers/app_life_cycle.provider.dart';+import 'package:immich_mobile/providers/app_settings.provider.dart';import 'package:immich_mobile/providers/asset_viewer/share_intent_upload.provider.dart';+import 'package:immich_mobile/providers/backup/backup.provider.dart';import 'package:immich_mobile/providers/db.provider.dart';import 'package:immich_mobile/providers/infrastructure/db.provider.dart';import 'package:immich_mobile/providers/locale_provider.dart';@@ -23,6 +26,7 @@ import 'package:immich_mobile/providers/routes.provider.dart';import 'package:immich_mobile/providers/theme.provider.dart';import 'package:immich_mobile/routing/app_navigation_observer.dart';import 'package:immich_mobile/routing/router.dart';+import 'package:immich_mobile/services/app_settings.service.dart';import 'package:immich_mobile/services/background.service.dart';import 'package:immich_mobile/services/deep_link.service.dart';import 'package:immich_mobile/services/local_notification.service.dart';@@ -165,36 +169,6 @@ class ImmichAppState extends ConsumerState<ImmichApp> with WidgetsBindingObserveawait ref.read(localNotificationService).setup();}- void _configureFileDownloaderNotifications() {- FileDownloader().configureNotificationForGroup(- kDownloadGroupImage,- running: TaskNotification('downloading_media'.tr(), '${'file_name'.tr()}: {filename}'),- complete: TaskNotification('download_finished'.tr(), '${'file_name'.tr()}: {filename}'),- progressBar: true,- );-- FileDownloader().configureNotificationForGroup(- kDownloadGroupVideo,- running: TaskNotification('downloading_media'.tr(), '${'file_name'.tr()}: {filename}'),- complete: TaskNotification('download_finished'.tr(), '${'file_name'.tr()}: {filename}'),- progressBar: true,- );-- FileDownloader().configureNotificationForGroup(- kManualUploadGroup,- running: TaskNotification('uploading_media'.tr(), '${'file_name'.tr()}: {displayName}'),- complete: TaskNotification('upload_finished'.tr(), '${'file_name'.tr()}: {displayName}'),- progressBar: true,- );-- FileDownloader().configureNotificationForGroup(- kBackupGroup,- running: TaskNotification('uploading_media'.tr(), '${'file_name'.tr()}: {displayName}'),- complete: TaskNotification('upload_finished'.tr(), '${'file_name'.tr()}: {displayName}'),- progressBar: true,- );- }-Future<DeepLink> _deepLinkBuilder(PlatformDeepLink deepLink) async {final deepLinkHandler = ref.read(deepLinkServiceProvider);final currentRouteName = ref.read(currentRouteNameProvider.notifier).state;@@ -221,7 +195,7 @@ class ImmichAppState extends ConsumerState<ImmichApp> with WidgetsBindingObservesuper.didChangeDependencies();Intl.defaultLocale = context.locale.toLanguageTag();WidgetsBinding.instance.addPostFrameCallback((_) {- _configureFileDownloaderNotifications();+ configureFileDownloaderNotifications();});}@@ -231,7 +205,16 @@ class ImmichAppState extends ConsumerState<ImmichApp> with WidgetsBindingObserveinitApp().then((_) => debugPrint("App Init Completed"));WidgetsBinding.instance.addPostFrameCallback((_) {// needs to be delayed so that EasyLocalization is working- ref.read(backgroundServiceProvider).resumeServiceIfEnabled();+ if (Store.isBetaTimelineEnabled) {+ ref.read(driftBackgroundUploadFgService).enableSyncService();+ if (ref.read(appSettingsServiceProvider).getSetting(AppSettingsEnum.enableBackup)) {+ ref.read(backgroundServiceProvider).disableService();+ ref.read(driftBackgroundUploadFgService).enableUploadService();+ }+ } else {+ ref.read(backgroundServiceProvider).resumeServiceIfEnabled();+ ref.read(driftBackgroundUploadFgService).disableUploadService();+ }});ref.read(shareIntentUploadProvider.notifier).init();diff --git a/mobile/lib/pages/backup/drift_backup.page.dart b/mobile/lib/pages/backup/drift_backup.page.dartindex b125c35908..5140c62a0d 100644--- a/mobile/lib/pages/backup/drift_backup.page.dart+++ b/mobile/lib/pages/backup/drift_backup.page.dart@@ -8,6 +8,7 @@ import 'package:immich_mobile/extensions/theme_extensions.dart';import 'package:immich_mobile/extensions/translate_extensions.dart';import 'package:immich_mobile/presentation/widgets/backup/backup_toggle_button.widget.dart';import 'package:immich_mobile/providers/background_sync.provider.dart';+import 'package:immich_mobile/providers/backup/backup.provider.dart';import 'package:immich_mobile/providers/backup/backup_album.provider.dart';import 'package:immich_mobile/providers/backup/drift_backup.provider.dart';import 'package:immich_mobile/providers/user.provider.dart';@@ -42,10 +43,12 @@ class _DriftBackupPageState extends ConsumerState<DriftBackupPage> {await ref.read(backgroundSyncProvider).syncRemote();await ref.read(driftBackupProvider.notifier).getBackupStatus(currentUser.id);+ await ref.read(driftBackgroundUploadFgService).enableUploadService();await ref.read(driftBackupProvider.notifier).startBackup(currentUser.id);}Future<void> stopBackup() async {+ await ref.read(driftBackgroundUploadFgService).disableUploadService();await ref.read(driftBackupProvider.notifier).cancel();}diff --git a/mobile/lib/pages/common/change_experience.page.dart b/mobile/lib/pages/common/change_experience.page.dartindex 3e9747ce32..9064f32066 100644--- a/mobile/lib/pages/common/change_experience.page.dart+++ b/mobile/lib/pages/common/change_experience.page.dart@@ -14,6 +14,7 @@ import 'package:immich_mobile/providers/backup/manual_upload.provider.dart';import 'package:immich_mobile/providers/gallery_permission.provider.dart';import 'package:immich_mobile/providers/infrastructure/db.provider.dart';import 'package:immich_mobile/providers/websocket.provider.dart';+import 'package:immich_mobile/services/background.service.dart';import 'package:immich_mobile/utils/migration.dart';import 'package:logging/logging.dart';import 'package:permission_handler/permission_handler.dart';@@ -68,12 +69,15 @@ class _ChangeExperiencePageState extends ConsumerState<ChangeExperiencePage> {await migrateDeviceAssetToSqlite(ref.read(isarProvider), ref.read(driftProvider));await migrateBackupAlbumsToSqlite(ref.read(isarProvider), ref.read(driftProvider));await migrateStoreToSqlite(ref.read(isarProvider), ref.read(driftProvider));+ await ref.read(backgroundServiceProvider).disableService();}} else {await ref.read(backgroundSyncProvider).cancel();ref.read(websocketProvider.notifier).stopListeningToBetaEvents();ref.read(websocketProvider.notifier).startListeningToOldEvents();await migrateStoreToIsar(ref.read(isarProvider), ref.read(driftProvider));+ await ref.read(backgroundServiceProvider).resumeServiceIfEnabled();+ await ref.read(driftBackgroundUploadFgService).disableUploadService();}await IsarStoreRepository(ref.read(isarProvider)).upsert(StoreKey.betaTimeline, widget.switchingToBeta);diff --git a/mobile/lib/platform/background_worker_api.g.dart b/mobile/lib/platform/background_worker_api.g.dartnew file mode 100644index 0000000000..646eb63b76--- /dev/null+++ b/mobile/lib/platform/background_worker_api.g.dart@@ -0,0 +1,296 @@+// Autogenerated from Pigeon (v26.0.0), do not edit directly.+// See also: https://pub.dev/packages/pigeon+// ignore_for_file: public_member_api_docs, non_constant_identifier_names, avoid_as, unused_import, unnecessary_parenthesis, prefer_null_aware_operators, omit_local_variable_types, unused_shown_name, unnecessary_import, no_leading_underscores_for_local_identifiers++import 'dart:async';+import 'dart:typed_data' show Float64List, Int32List, Int64List, Uint8List;++import 'package:flutter/foundation.dart' show ReadBuffer, WriteBuffer;+import 'package:flutter/services.dart';++PlatformException _createConnectionError(String channelName) {+ return PlatformException(+ code: 'channel-error',+ message: 'Unable to establish connection on channel: "$channelName".',+ );+}++List<Object?> wrapResponse({Object? result, PlatformException? error, bool empty = false}) {+ if (empty) {+ return <Object?>[];+ }+ if (error == null) {+ return <Object?>[result];+ }+ return <Object?>[error.code, error.message, error.details];+}++class _PigeonCodec extends StandardMessageCodec {+ const _PigeonCodec();+ @override+ void writeValue(WriteBuffer buffer, Object? value) {+ if (value is int) {+ buffer.putUint8(4);+ buffer.putInt64(value);+ } else {+ super.writeValue(buffer, value);+ }+ }++ @override+ Object? readValueOfType(int type, ReadBuffer buffer) {+ switch (type) {+ default:+ return super.readValueOfType(type, buffer);+ }+ }+}++class BackgroundWorkerFgHostApi {+ /// Constructor for [BackgroundWorkerFgHostApi]. The [binaryMessenger] named argument is+ /// available for dependency injection. If it is left null, the default+ /// BinaryMessenger will be used which routes to the host platform.+ BackgroundWorkerFgHostApi({BinaryMessenger? binaryMessenger, String messageChannelSuffix = ''})+ : pigeonVar_binaryMessenger = binaryMessenger,+ pigeonVar_messageChannelSuffix = messageChannelSuffix.isNotEmpty ? '.$messageChannelSuffix' : '';+ final BinaryMessenger? pigeonVar_binaryMessenger;++ static const MessageCodec<Object?> pigeonChannelCodec = _PigeonCodec();++ final String pigeonVar_messageChannelSuffix;++ Future<void> enableSyncWorker() async {+ final String pigeonVar_channelName =+ 'dev.flutter.pigeon.immich_mobile.BackgroundWorkerFgHostApi.enableSyncWorker$pigeonVar_messageChannelSuffix';+ final BasicMessageChannel<Object?> pigeonVar_channel = BasicMessageChannel<Object?>(+ pigeonVar_channelName,+ pigeonChannelCodec,+ binaryMessenger: pigeonVar_binaryMessenger,+ );+ final Future<Object?> pigeonVar_sendFuture = pigeonVar_channel.send(null);+ final List<Object?>? pigeonVar_replyList = await pigeonVar_sendFuture as List<Object?>?;+ if (pigeonVar_replyList == null) {+ throw _createConnectionError(pigeonVar_channelName);+ } else if (pigeonVar_replyList.length > 1) {+ throw PlatformException(+ code: pigeonVar_replyList[0]! as String,+ message: pigeonVar_replyList[1] as String?,+ details: pigeonVar_replyList[2],+ );+ } else {+ return;+ }+ }++ Future<void> enableUploadWorker(int callbackHandle) async {+ final String pigeonVar_channelName =+ 'dev.flutter.pigeon.immich_mobile.BackgroundWorkerFgHostApi.enableUploadWorker$pigeonVar_messageChannelSuffix';+ final BasicMessageChannel<Object?> pigeonVar_channel = BasicMessageChannel<Object?>(+ pigeonVar_channelName,+ pigeonChannelCodec,+ binaryMessenger: pigeonVar_binaryMessenger,+ );+ final Future<Object?> pigeonVar_sendFuture = pigeonVar_channel.send(<Object?>[callbackHandle]);+ final List<Object?>? pigeonVar_replyList = await pigeonVar_sendFuture as List<Object?>?;+ if (pigeonVar_replyList == null) {+ throw _createConnectionError(pigeonVar_channelName);+ } else if (pigeonVar_replyList.length > 1) {+ throw PlatformException(+ code: pigeonVar_replyList[0]! as String,+ message: pigeonVar_replyList[1] as String?,+ details: pigeonVar_replyList[2],+ );+ } else {+ return;+ }+ }++ Future<void> disableUploadWorker() async {+ final String pigeonVar_channelName =+ 'dev.flutter.pigeon.immich_mobile.BackgroundWorkerFgHostApi.disableUploadWorker$pigeonVar_messageChannelSuffix';+ final BasicMessageChannel<Object?> pigeonVar_channel = BasicMessageChannel<Object?>(+ pigeonVar_channelName,+ pigeonChannelCodec,+ binaryMessenger: pigeonVar_binaryMessenger,+ );+ final Future<Object?> pigeonVar_sendFuture = pigeonVar_channel.send(null);+ final List<Object?>? pigeonVar_replyList = await pigeonVar_sendFuture as List<Object?>?;+ if (pigeonVar_replyList == null) {+ throw _createConnectionError(pigeonVar_channelName);+ } else if (pigeonVar_replyList.length > 1) {+ throw PlatformException(+ code: pigeonVar_replyList[0]! as String,+ message: pigeonVar_replyList[1] as String?,+ details: pigeonVar_replyList[2],+ );+ } else {+ return;+ }+ }+}++class BackgroundWorkerBgHostApi {+ /// Constructor for [BackgroundWorkerBgHostApi]. The [binaryMessenger] named argument is+ /// available for dependency injection. If it is left null, the default+ /// BinaryMessenger will be used which routes to the host platform.+ BackgroundWorkerBgHostApi({BinaryMessenger? binaryMessenger, String messageChannelSuffix = ''})+ : pigeonVar_binaryMessenger = binaryMessenger,+ pigeonVar_messageChannelSuffix = messageChannelSuffix.isNotEmpty ? '.$messageChannelSuffix' : '';+ final BinaryMessenger? pigeonVar_binaryMessenger;++ static const MessageCodec<Object?> pigeonChannelCodec = _PigeonCodec();++ final String pigeonVar_messageChannelSuffix;++ Future<void> onInitialized() async {+ final String pigeonVar_channelName =+ 'dev.flutter.pigeon.immich_mobile.BackgroundWorkerBgHostApi.onInitialized$pigeonVar_messageChannelSuffix';+ final BasicMessageChannel<Object?> pigeonVar_channel = BasicMessageChannel<Object?>(+ pigeonVar_channelName,+ pigeonChannelCodec,+ binaryMessenger: pigeonVar_binaryMessenger,+ );+ final Future<Object?> pigeonVar_sendFuture = pigeonVar_channel.send(null);+ final List<Object?>? pigeonVar_replyList = await pigeonVar_sendFuture as List<Object?>?;+ if (pigeonVar_replyList == null) {+ throw _createConnectionError(pigeonVar_channelName);+ } else if (pigeonVar_replyList.length > 1) {+ throw PlatformException(+ code: pigeonVar_replyList[0]! as String,+ message: pigeonVar_replyList[1] as String?,+ details: pigeonVar_replyList[2],+ );+ } else {+ return;+ }+ }+}++abstract class BackgroundWorkerFlutterApi {+ static const MessageCodec<Object?> pigeonChannelCodec = _PigeonCodec();++ Future<void> onLocalSync(int? maxSeconds);++ Future<void> onIosUpload(bool isRefresh, int? maxSeconds);++ Future<void> onAndroidUpload();++ Future<void> cancel();++ static void setUp(+ BackgroundWorkerFlutterApi? api, {+ BinaryMessenger? binaryMessenger,+ String messageChannelSuffix = '',+ }) {+ messageChannelSuffix = messageChannelSuffix.isNotEmpty ? '.$messageChannelSuffix' : '';+ {+ final BasicMessageChannel<Object?> pigeonVar_channel = BasicMessageChannel<Object?>(+ 'dev.flutter.pigeon.immich_mobile.BackgroundWorkerFlutterApi.onLocalSync$messageChannelSuffix',+ pigeonChannelCodec,+ binaryMessenger: binaryMessenger,+ );+ if (api == null) {+ pigeonVar_channel.setMessageHandler(null);+ } else {+ pigeonVar_channel.setMessageHandler((Object? message) async {+ assert(+ message != null,+ 'Argument for dev.flutter.pigeon.immich_mobile.BackgroundWorkerFlutterApi.onLocalSync was null.',+ );+ final List<Object?> args = (message as List<Object?>?)!;+ final int? arg_maxSeconds = (args[0] as int?);+ try {+ await api.onLocalSync(arg_maxSeconds);+ return wrapResponse(empty: true);+ } on PlatformException catch (e) {+ return wrapResponse(error: e);+ } catch (e) {+ return wrapResponse(+ error: PlatformException(code: 'error', message: e.toString()),+ );+ }+ });+ }+ }+ {+ final BasicMessageChannel<Object?> pigeonVar_channel = BasicMessageChannel<Object?>(+ 'dev.flutter.pigeon.immich_mobile.BackgroundWorkerFlutterApi.onIosUpload$messageChannelSuffix',+ pigeonChannelCodec,+ binaryMessenger: binaryMessenger,+ );+ if (api == null) {+ pigeonVar_channel.setMessageHandler(null);+ } else {+ pigeonVar_channel.setMessageHandler((Object? message) async {+ assert(+ message != null,+ 'Argument for dev.flutter.pigeon.immich_mobile.BackgroundWorkerFlutterApi.onIosUpload was null.',+ );+ final List<Object?> args = (message as List<Object?>?)!;+ final bool? arg_isRefresh = (args[0] as bool?);+ assert(+ arg_isRefresh != null,+ 'Argument for dev.flutter.pigeon.immich_mobile.BackgroundWorkerFlutterApi.onIosUpload was null, expected non-null bool.',+ );+ final int? arg_maxSeconds = (args[1] as int?);+ try {+ await api.onIosUpload(arg_isRefresh!, arg_maxSeconds);+ return wrapResponse(empty: true);+ } on PlatformException catch (e) {+ return wrapResponse(error: e);+ } catch (e) {+ return wrapResponse(+ error: PlatformException(code: 'error', message: e.toString()),+ );+ }+ });+ }+ }+ {+ final BasicMessageChannel<Object?> pigeonVar_channel = BasicMessageChannel<Object?>(+ 'dev.flutter.pigeon.immich_mobile.BackgroundWorkerFlutterApi.onAndroidUpload$messageChannelSuffix',+ pigeonChannelCodec,+ binaryMessenger: binaryMessenger,+ );+ if (api == null) {+ pigeonVar_channel.setMessageHandler(null);+ } else {+ pigeonVar_channel.setMessageHandler((Object? message) async {+ try {+ await api.onAndroidUpload();+ return wrapResponse(empty: true);+ } on PlatformException catch (e) {+ return wrapResponse(error: e);+ } catch (e) {+ return wrapResponse(+ error: PlatformException(code: 'error', message: e.toString()),+ );+ }+ });+ }+ }+ {+ final BasicMessageChannel<Object?> pigeonVar_channel = BasicMessageChannel<Object?>(+ 'dev.flutter.pigeon.immich_mobile.BackgroundWorkerFlutterApi.cancel$messageChannelSuffix',+ pigeonChannelCodec,+ binaryMessenger: binaryMessenger,+ );+ if (api == null) {+ pigeonVar_channel.setMessageHandler(null);+ } else {+ pigeonVar_channel.setMessageHandler((Object? message) async {+ try {+ await api.cancel();+ return wrapResponse(empty: true);+ } on PlatformException catch (e) {+ return wrapResponse(error: e);+ } catch (e) {+ return wrapResponse(+ error: PlatformException(code: 'error', message: e.toString()),+ );+ }+ });+ }+ }+ }+}diff --git a/mobile/lib/providers/backup/backup.provider.dart b/mobile/lib/providers/backup/backup.provider.dartindex 76cb383465..6035e53e5d 100644--- a/mobile/lib/providers/backup/backup.provider.dart+++ b/mobile/lib/providers/backup/backup.provider.dart@@ -6,6 +6,7 @@ import 'package:flutter/foundation.dart';import 'package:flutter/widgets.dart';import 'package:hooks_riverpod/hooks_riverpod.dart';import 'package:immich_mobile/domain/models/store.model.dart';+import 'package:immich_mobile/domain/services/background_worker.service.dart';import 'package:immich_mobile/entities/album.entity.dart';import 'package:immich_mobile/entities/backup_album.entity.dart';import 'package:immich_mobile/entities/store.entity.dart';@@ -17,6 +18,7 @@ import 'package:immich_mobile/models/backup/current_upload_asset.model.dart';import 'package:immich_mobile/models/backup/error_upload_asset.model.dart';import 'package:immich_mobile/models/backup/success_upload_asset.model.dart';import 'package:immich_mobile/models/server_info/server_disk_info.model.dart';+import 'package:immich_mobile/platform/background_worker_api.g.dart';import 'package:immich_mobile/providers/app_life_cycle.provider.dart';import 'package:immich_mobile/providers/auth.provider.dart';import 'package:immich_mobile/providers/backup/error_backup_list.provider.dart';@@ -34,6 +36,8 @@ import 'package:logging/logging.dart';import 'package:permission_handler/permission_handler.dart';import 'package:photo_manager/photo_manager.dart' show PMProgressHandler;+final driftBackgroundUploadFgService = Provider((ref) => BackgroundWorkerFgService(BackgroundWorkerFgHostApi()));+final backupProvider = StateNotifierProvider<BackupNotifier, BackUpState>((ref) {return BackupNotifier(ref.watch(backupServiceProvider),diff --git a/mobile/lib/repositories/upload.repository.dart b/mobile/lib/repositories/upload.repository.dartindex 220dbf81c3..c8b06ae102 100644--- a/mobile/lib/repositories/upload.repository.dart+++ b/mobile/lib/repositories/upload.repository.dart@@ -27,8 +27,12 @@ class UploadRepository {);}- void enqueueBackgroundAll(List<UploadTask> tasks) {- FileDownloader().enqueueAll(tasks);+ Future<void> enqueueBackground(UploadTask task) {+ return FileDownloader().enqueue(task);+ }++ Future<void> enqueueBackgroundAll(List<UploadTask> tasks) {+ return FileDownloader().enqueueAll(tasks);}Future<void> deleteDatabaseRecords(String group) {diff --git a/mobile/lib/services/upload.service.dart b/mobile/lib/services/upload.service.dartindex 9e5193c8cb..635604b096 100644--- a/mobile/lib/services/upload.service.dart+++ b/mobile/lib/services/upload.service.dart@@ -78,8 +78,8 @@ class UploadService {_taskProgressController.close();}- void enqueueTasks(List<UploadTask> tasks) {- _uploadRepository.enqueueBackgroundAll(tasks);+ Future<void> enqueueTasks(List<UploadTask> tasks) {+ return _uploadRepository.enqueueBackgroundAll(tasks);}Future<List<Task>> getActiveTasks(String group) {@@ -113,7 +113,7 @@ class UploadService {}if (tasks.isNotEmpty) {- enqueueTasks(tasks);+ await enqueueTasks(tasks);}}@@ -149,13 +149,37 @@ class UploadService {if (tasks.isNotEmpty && !shouldAbortQueuingTasks) {count += tasks.length;- enqueueTasks(tasks);+ await enqueueTasks(tasks);onEnqueueTasks(EnqueueStatus(enqueueCount: count, totalCount: candidates.length));}}}+ // Enqueue All does not work from the background on Android yet. This method is a temporary workaround+ // that enqueues tasks one by one.+ Future<void> startBackupSerial(String userId) async {+ await _storageRepository.clearCache();++ shouldAbortQueuingTasks = false;++ final candidates = await _backupRepository.getCandidates(userId);+ if (candidates.isEmpty) {+ return;+ }++ for (final asset in candidates) {+ if (shouldAbortQueuingTasks) {+ break;+ }++ final task = await _getUploadTask(asset);+ if (task != null) {+ await _uploadRepository.enqueueBackground(task);+ }+ }+ }+/// Cancel all ongoing uploads and reset the upload queue////// Return the number of left over tasks in the queuediff --git a/mobile/lib/utils/bootstrap.dart b/mobile/lib/utils/bootstrap.dartindex 480d918b4e..e7abc66040 100644--- a/mobile/lib/utils/bootstrap.dart+++ b/mobile/lib/utils/bootstrap.dart@@ -1,6 +1,8 @@import 'dart:io';+import 'package:background_downloader/background_downloader.dart';import 'package:flutter/foundation.dart';+import 'package:immich_mobile/constants/constants.dart';import 'package:immich_mobile/domain/models/store.model.dart';import 'package:immich_mobile/domain/services/log.service.dart';import 'package:immich_mobile/domain/services/store.service.dart';@@ -11,6 +13,7 @@ import 'package:immich_mobile/entities/backup_album.entity.dart';import 'package:immich_mobile/entities/duplicated_asset.entity.dart';import 'package:immich_mobile/entities/etag.entity.dart';import 'package:immich_mobile/entities/ios_device_asset.entity.dart';+import 'package:immich_mobile/extensions/translate_extensions.dart';import 'package:immich_mobile/infrastructure/entities/device_asset.entity.dart';import 'package:immich_mobile/infrastructure/entities/exif.entity.dart';import 'package:immich_mobile/infrastructure/entities/store.entity.dart';@@ -22,6 +25,36 @@ import 'package:immich_mobile/infrastructure/repositories/store.repository.dart'import 'package:isar/isar.dart';import 'package:path_provider/path_provider.dart';+void configureFileDownloaderNotifications() {+ FileDownloader().configureNotificationForGroup(+ kDownloadGroupImage,+ running: TaskNotification('downloading_media'.t(), '${'file_name'.t()}: {filename}'),+ complete: TaskNotification('download_finished'.t(), '${'file_name'.t()}: {filename}'),+ progressBar: true,+ );++ FileDownloader().configureNotificationForGroup(+ kDownloadGroupVideo,+ running: TaskNotification('downloading_media'.t(), '${'file_name'.t()}: {filename}'),+ complete: TaskNotification('download_finished'.t(), '${'file_name'.t()}: {filename}'),+ progressBar: true,+ );++ FileDownloader().configureNotificationForGroup(+ kManualUploadGroup,+ running: TaskNotification('uploading_media'.t(), 'backup_background_service_in_progress_notification'.t()),+ complete: TaskNotification('upload_finished'.t(), 'backup_background_service_in_progress_notification'.t()),+ groupNotificationId: kManualUploadGroup,+ );++ FileDownloader().configureNotificationForGroup(+ kBackupGroup,+ running: TaskNotification('uploading_media'.t(), 'backup_background_service_in_progress_notification'.t()),+ complete: TaskNotification('upload_finished'.t(), 'backup_background_service_in_progress_notification'.t()),+ groupNotificationId: kBackupGroup,+ );+}+abstract final class Bootstrap {static Future<(Isar isar, Drift drift, DriftLogger logDb)> initDB() async {final drift = Drift();diff --git a/mobile/lib/utils/isolate.dart b/mobile/lib/utils/isolate.dartindex 58e7ad7f25..cca1498e0f 100644--- a/mobile/lib/utils/isolate.dart+++ b/mobile/lib/utils/isolate.dart@@ -57,7 +57,7 @@ Cancelable<T?> runInIsolateGentle<T>({log.severe("Error in runInIsolateGentle ${debugLabel == null ? '' : ' for $debugLabel'}", error, stack);} finally {try {- await LogService.I.flush();+ await LogService.I.dispose();await logDb.close();await ref.read(driftProvider).close();@@ -72,8 +72,8 @@ Cancelable<T?> runInIsolateGentle<T>({}ref.dispose();- } catch (error) {- debugPrint("Error closing resources in isolate: $error");+ } catch (error, stack) {+ debugPrint("Error closing resources in isolate: $error, $stack");} finally {ref.dispose();// Delay to ensure all resources are releaseddiff --git a/mobile/makefile b/mobile/makefileindex 5a31481f45..1a20e769ef 100644--- a/mobile/makefile+++ b/mobile/makefile@@ -8,8 +8,10 @@ build:pigeon:dart run pigeon --input pigeon/native_sync_api.dartdart run pigeon --input pigeon/thumbnail_api.dart+ dart run pigeon --input pigeon/background_worker_api.dartdart format lib/platform/native_sync_api.g.dartdart format lib/platform/thumbnail_api.g.dart+ dart format lib/platform/background_worker_api.g.dartwatch:dart run build_runner watch --delete-conflicting-outputsdiff --git a/mobile/pigeon/background_worker_api.dart b/mobile/pigeon/background_worker_api.dartnew file mode 100644index 0000000000..eb1b7a2c5e--- /dev/null+++ b/mobile/pigeon/background_worker_api.dart@@ -0,0 +1,48 @@+import 'package:pigeon/pigeon.dart';++@ConfigurePigeon(+ PigeonOptions(+ dartOut: 'lib/platform/background_worker_api.g.dart',+ swiftOut: 'ios/Runner/Background/BackgroundWorker.g.swift',+ swiftOptions: SwiftOptions(includeErrorClass: false),+ kotlinOut: 'android/app/src/main/kotlin/app/alextran/immich/background/BackgroundWorker.g.kt',+ kotlinOptions: KotlinOptions(package: 'app.alextran.immich.background'),+ dartOptions: DartOptions(),+ dartPackageName: 'immich_mobile',+ ),+)+@HostApi()+abstract class BackgroundWorkerFgHostApi {+ void enableSyncWorker();++ // Enables the background upload service with the given callback handle+ void enableUploadWorker(int callbackHandle);++ // Disables the background upload service+ void disableUploadWorker();+}++@HostApi()+abstract class BackgroundWorkerBgHostApi {+ // Called from the background flutter engine when it has bootstrapped and established the+ // required platform channels to notify the native side to start the background upload+ void onInitialized();+}++@FlutterApi()+abstract class BackgroundWorkerFlutterApi {+ // Android & iOS: Called when the local sync is triggered+ @async+ void onLocalSync(int? maxSeconds);++ // iOS Only: Called when the iOS background upload is triggered+ @async+ void onIosUpload(bool isRefresh, int? maxSeconds);++ // Android Only: Called when the Android background upload is triggered+ @async+ void onAndroidUpload();++ @async+ void cancel();+}