Skip to content

High performance self-hosted photo and video management solution.

feat: beta background sync (#21243)

shenlong0df88fc22bca
diff --git a/mobile/analysis_options.yaml b/mobile/analysis_options.yaml
index 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.dart
diff --git a/mobile/android/app/src/main/kotlin/app/alextran/immich/ImmichApp.kt b/mobile/android/app/src/main/kotlin/app/alextran/immich/ImmichApp.kt
index 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.Configuration
import androidx.work.WorkManager
class 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.kt
index 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.Context
import android.os.Build
import android.os.ext.SdkExtensions
-import androidx.annotation.NonNull
+import app.alextran.immich.background.BackgroundWorkerApiImpl
+import app.alextran.immich.background.BackgroundWorkerFgHostApi
import app.alextran.immich.images.ThumbnailApi
import app.alextran.immich.images.ThumbnailsImpl
import app.alextran.immich.sync.NativeSyncApi
@@ -12,19 +14,26 @@ import io.flutter.embedding.android.FlutterFragmentActivity
import io.flutter.embedding.engine.FlutterEngine
class 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.kt
new file mode 100644
index 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.kt
new file mode 100644
index 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.kt
new file mode 100644
index 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.kt
new file mode 100644
index 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.pbxproj
index 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.swift
index 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 in
if !registry.hasPlugin("org.cocoapods.path-provider-foundation") {
@@ -51,4 +50,10 @@ import UIKit
return 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.swift
new file mode 100644
index 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.swift
new file mode 100644
index 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.swift
new file mode 100644
index 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.plist
index 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 file
diff --git a/mobile/lib/domain/services/background_worker.service.dart b/mobile/lib/domain/services/background_worker.service.dart
new file mode 100644
index 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.dart
index 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.dart
index 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.dart
index 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 out
Future<void> syncLocal({bool full = false}) {
if (_deviceAlbumSyncTask != null) {
diff --git a/mobile/lib/main.dart b/mobile/lib/main.dart
index 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 WidgetsBindingObserve
await 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 WidgetsBindingObserve
super.didChangeDependencies();
Intl.defaultLocale = context.locale.toLanguageTag();
WidgetsBinding.instance.addPostFrameCallback((_) {
- _configureFileDownloaderNotifications();
+ configureFileDownloaderNotifications();
});
}
@@ -231,7 +205,16 @@ class ImmichAppState extends ConsumerState<ImmichApp> with WidgetsBindingObserve
initApp().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.dart
index 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.dart
index 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.dart
new file mode 100644
index 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.dart
index 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.dart
index 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.dart
index 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 queue
diff --git a/mobile/lib/utils/bootstrap.dart b/mobile/lib/utils/bootstrap.dart
index 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.dart
index 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 released
diff --git a/mobile/makefile b/mobile/makefile
index 5a31481f45..1a20e769ef 100644
--- a/mobile/makefile
+++ b/mobile/makefile
@@ -8,8 +8,10 @@ build:
pigeon:
dart run pigeon --input pigeon/native_sync_api.dart
dart run pigeon --input pigeon/thumbnail_api.dart
+ dart run pigeon --input pigeon/background_worker_api.dart
dart format lib/platform/native_sync_api.g.dart
dart format lib/platform/thumbnail_api.g.dart
+ dart format lib/platform/background_worker_api.g.dart
watch:
dart run build_runner watch --delete-conflicting-outputs
diff --git a/mobile/pigeon/background_worker_api.dart b/mobile/pigeon/background_worker_api.dart
new file mode 100644
index 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();
+}