Merge branch 'main' into fix/save-album-sort

mobile/android/app/src/main/kotlin/app/alextran/immich/MainActivity.kt

@@ -6,6 +6,7 @@ import android.os.ext.SdkExtensions
 import app.alextran.immich.background.BackgroundEngineLock
 import app.alextran.immich.background.BackgroundWorkerApiImpl
 import app.alextran.immich.background.BackgroundWorkerFgHostApi
+import app.alextran.immich.background.BackgroundWorkerLockApi
 import app.alextran.immich.connectivity.ConnectivityApi
 import app.alextran.immich.connectivity.ConnectivityApiImpl
 import app.alextran.immich.images.ThumbnailApi
@@ -24,11 +25,9 @@ class MainActivity : FlutterFragmentActivity() {
 
   companion object {
     fun registerPlugins(ctx: Context, flutterEngine: FlutterEngine) {
-      flutterEngine.plugins.add(BackgroundServicePlugin())
-      flutterEngine.plugins.add(HttpSSLOptionsPlugin())
-      flutterEngine.plugins.add(BackgroundEngineLock())
-
       val messenger = flutterEngine.dartExecutor.binaryMessenger
+      val backgroundEngineLockImpl = BackgroundEngineLock(ctx)
+      BackgroundWorkerLockApi.setUp(messenger, backgroundEngineLockImpl)
       val nativeSyncApiImpl =
         if (Build.VERSION.SDK_INT < Build.VERSION_CODES.R || SdkExtensions.getExtensionVersion(Build.VERSION_CODES.R) < 1) {
           NativeSyncApiImpl26(ctx)
@@ -39,6 +38,10 @@ class MainActivity : FlutterFragmentActivity() {
       ThumbnailApi.setUp(messenger, ThumbnailsImpl(ctx))
       BackgroundWorkerFgHostApi.setUp(messenger, BackgroundWorkerApiImpl(ctx))
       ConnectivityApi.setUp(messenger, ConnectivityApiImpl(ctx))
+
+      flutterEngine.plugins.add(BackgroundServicePlugin())
+      flutterEngine.plugins.add(HttpSSLOptionsPlugin())
+      flutterEngine.plugins.add(backgroundEngineLockImpl)
     }
   }
 }

mobile/android/app/src/main/kotlin/app/alextran/immich/background/BackgroundEngineLock.kt

@@ -1,33 +1,50 @@
 package app.alextran.immich.background
 
+import android.content.Context
 import android.util.Log
-import androidx.work.WorkManager
-import io.flutter.embedding.engine.FlutterEngineCache
 import io.flutter.embedding.engine.plugins.FlutterPlugin
 import java.util.concurrent.atomic.AtomicInteger
 
 private const val TAG = "BackgroundEngineLock"
 
-class BackgroundEngineLock : FlutterPlugin {
-  companion object {
-    const val ENGINE_CACHE_KEY = "immich::background_worker::engine"
-    var engineCount = AtomicInteger(0)
-  }
+class BackgroundEngineLock(context: Context) : BackgroundWorkerLockApi, FlutterPlugin {
+    private val ctx: Context = context.applicationContext
 
-  override fun onAttachedToEngine(binding: FlutterPlugin.FlutterPluginBinding) {
-    // work manager task is running while the main app is opened, cancel the worker
-    if (engineCount.incrementAndGet() > 1 && FlutterEngineCache.getInstance()
-        .get(ENGINE_CACHE_KEY) != null
-    ) {
-      WorkManager.getInstance(binding.applicationContext)
-        .cancelUniqueWork(BackgroundWorkerApiImpl.BACKGROUND_WORKER_NAME)
-      FlutterEngineCache.getInstance().remove(ENGINE_CACHE_KEY)
+    companion object {
+
+        private var engineCount = AtomicInteger(0)
+
+        private fun checkAndEnforceBackgroundLock(ctx: Context) {
+            // work manager task is running while the main app is opened, cancel the worker
+            if (BackgroundWorkerPreferences(ctx).isLocked() &&
+                engineCount.get() > 1 &&
+                BackgroundWorkerApiImpl.isBackgroundWorkerRunning()
+            ) {
+                Log.i(TAG, "Background worker is locked, cancelling the background worker")
+                BackgroundWorkerApiImpl.cancelBackgroundWorker(ctx)
+            }
+        }
     }
-    Log.i(TAG, "Flutter engine attached. Attached Engines count: $engineCount")
-  }
 
-  override fun onDetachedFromEngine(binding: FlutterPlugin.FlutterPluginBinding) {
-    engineCount.decrementAndGet()
-    Log.i(TAG, "Flutter engine detached. Attached Engines count: $engineCount")
-  }
+    override fun lock() {
+        BackgroundWorkerPreferences(ctx).setLocked(true)
+        checkAndEnforceBackgroundLock(ctx)
+        Log.i(TAG, "Background worker is locked")
+    }
+
+    override fun unlock() {
+        BackgroundWorkerPreferences(ctx).setLocked(false)
+        Log.i(TAG, "Background worker is unlocked")
+    }
+
+    override fun onAttachedToEngine(binding: FlutterPlugin.FlutterPluginBinding) {
+        checkAndEnforceBackgroundLock(binding.applicationContext)
+        engineCount.incrementAndGet()
+        Log.i(TAG, "Flutter engine attached. Attached Engines count: $engineCount")
+    }
+
+    override fun onDetachedFromEngine(binding: FlutterPlugin.FlutterPluginBinding) {
+        engineCount.decrementAndGet()
+        Log.i(TAG, "Flutter engine detached. Attached Engines count: $engineCount")
+    }
 }

mobile/android/app/src/main/kotlin/app/alextran/immich/background/BackgroundWorker.kt

@@ -76,9 +76,7 @@ class BackgroundWorker(context: Context, params: WorkerParameters) :
 
     loader.ensureInitializationCompleteAsync(ctx, null, Handler(Looper.getMainLooper())) {
       engine = FlutterEngine(ctx)
-      FlutterEngineCache.getInstance().remove(BackgroundEngineLock.ENGINE_CACHE_KEY);
-      FlutterEngineCache.getInstance()
-        .put(BackgroundEngineLock.ENGINE_CACHE_KEY, engine!!)
+      FlutterEngineCache.getInstance().put(BackgroundWorkerApiImpl.ENGINE_CACHE_KEY, engine!!)
 
       // Register custom plugins
       MainActivity.registerPlugins(ctx, engine!!)
@@ -192,9 +190,9 @@ class BackgroundWorker(context: Context, params: WorkerParameters) :
     isComplete = true
     engine?.destroy()
     engine = null
-    FlutterEngineCache.getInstance().remove(BackgroundEngineLock.ENGINE_CACHE_KEY);
     flutterApi = null
     notificationManager.cancel(NOTIFICATION_ID)
+    FlutterEngineCache.getInstance().remove(BackgroundWorkerApiImpl.ENGINE_CACHE_KEY)
     waitForForegroundPromotion()
     completionHandler.set(success)
   }

mobile/android/app/src/main/kotlin/app/alextran/immich/background/BackgroundWorkerApiImpl.kt

@@ -1,7 +1,6 @@
 package app.alextran.immich.background
 
 import android.content.Context
-import android.content.SharedPreferences
 import android.provider.MediaStore
 import android.util.Log
 import androidx.work.BackoffPolicy
@@ -9,6 +8,7 @@ import androidx.work.Constraints
 import androidx.work.ExistingWorkPolicy
 import androidx.work.OneTimeWorkRequest
 import androidx.work.WorkManager
+import io.flutter.embedding.engine.FlutterEngineCache
 import java.util.concurrent.TimeUnit
 
 private const val TAG = "BackgroundWorkerApiImpl"
@@ -34,8 +34,10 @@ class BackgroundWorkerApiImpl(context: Context) : BackgroundWorkerFgHostApi {
   }
 
   companion object {
-    const val BACKGROUND_WORKER_NAME = "immich/BackgroundWorkerV1"
+    private const val BACKGROUND_WORKER_NAME = "immich/BackgroundWorkerV1"
     private const val OBSERVER_WORKER_NAME = "immich/MediaObserverV1"
+    const val ENGINE_CACHE_KEY = "immich::background_worker::engine"
+
 
     fun enqueueMediaObserver(ctx: Context) {
       val settings = BackgroundWorkerPreferences(ctx).getSettings()
@@ -73,35 +75,18 @@ class BackgroundWorkerApiImpl(context: Context) : BackgroundWorkerFgHostApi {
 
       Log.i(TAG, "Enqueued background worker with name: $BACKGROUND_WORKER_NAME")
     }
-  }
-}
 
-private class BackgroundWorkerPreferences(private val ctx: Context) {
-  companion object {
-    private const val SHARED_PREF_NAME = "Immich::BackgroundWorker"
-    private const val SHARED_PREF_MIN_DELAY_KEY = "BackgroundWorker::minDelaySeconds"
-    private const val SHARED_PREF_REQUIRE_CHARGING_KEY = "BackgroundWorker::requireCharging"
+    fun isBackgroundWorkerRunning(): Boolean {
+      // Easier to check if the engine is cached as we always cache the engine when starting the worker
+      // and remove it when the worker is finished
+      return FlutterEngineCache.getInstance().get(ENGINE_CACHE_KEY) != null
+    }
 
-    private const val DEFAULT_MIN_DELAY_SECONDS = 30L
-    private const val DEFAULT_REQUIRE_CHARGING = false
-  }
+    fun cancelBackgroundWorker(ctx: Context) {
+      WorkManager.getInstance(ctx).cancelUniqueWork(BACKGROUND_WORKER_NAME)
+      FlutterEngineCache.getInstance().remove(ENGINE_CACHE_KEY)
 
-  private val sp: SharedPreferences by lazy {
-    ctx.getSharedPreferences(SHARED_PREF_NAME, Context.MODE_PRIVATE)
-  }
-
-  fun updateSettings(settings: BackgroundWorkerSettings) {
-    sp.edit().apply {
-      putLong(SHARED_PREF_MIN_DELAY_KEY, settings.minimumDelaySeconds)
-      putBoolean(SHARED_PREF_REQUIRE_CHARGING_KEY, settings.requiresCharging)
-      apply()
+      Log.i(TAG, "Cancelled background upload task")
     }
   }
-
-  fun getSettings(): BackgroundWorkerSettings {
-    return BackgroundWorkerSettings(
-      minimumDelaySeconds = sp.getLong(SHARED_PREF_MIN_DELAY_KEY, DEFAULT_MIN_DELAY_SECONDS),
-      requiresCharging = sp.getBoolean(SHARED_PREF_REQUIRE_CHARGING_KEY, DEFAULT_REQUIRE_CHARGING),
-    )
-  }
 }

mobile/android/app/src/main/kotlin/app/alextran/immich/background/BackgroundWorkerLock.g.kt

@@ -0,0 +1,95 @@
+// 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 BackgroundWorkerLockPigeonUtils {
+
+  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)
+      )
+    }
+  }
+}
+private open class BackgroundWorkerLockPigeonCodec : 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 BackgroundWorkerLockApi {
+  fun lock()
+  fun unlock()
+
+  companion object {
+    /** The codec used by BackgroundWorkerLockApi. */
+    val codec: MessageCodec<Any?> by lazy {
+      BackgroundWorkerLockPigeonCodec()
+    }
+    /** Sets up an instance of `BackgroundWorkerLockApi` to handle messages through the `binaryMessenger`. */
+    @JvmOverloads
+    fun setUp(binaryMessenger: BinaryMessenger, api: BackgroundWorkerLockApi?, messageChannelSuffix: String = "") {
+      val separatedMessageChannelSuffix = if (messageChannelSuffix.isNotEmpty()) ".$messageChannelSuffix" else ""
+      run {
+        val channel = BasicMessageChannel<Any?>(binaryMessenger, "dev.flutter.pigeon.immich_mobile.BackgroundWorkerLockApi.lock$separatedMessageChannelSuffix", codec)
+        if (api != null) {
+          channel.setMessageHandler { _, reply ->
+            val wrapped: List<Any?> = try {
+              api.lock()
+              listOf(null)
+            } catch (exception: Throwable) {
+              BackgroundWorkerLockPigeonUtils.wrapError(exception)
+            }
+            reply.reply(wrapped)
+          }
+        } else {
+          channel.setMessageHandler(null)
+        }
+      }
+      run {
+        val channel = BasicMessageChannel<Any?>(binaryMessenger, "dev.flutter.pigeon.immich_mobile.BackgroundWorkerLockApi.unlock$separatedMessageChannelSuffix", codec)
+        if (api != null) {
+          channel.setMessageHandler { _, reply ->
+            val wrapped: List<Any?> = try {
+              api.unlock()
+              listOf(null)
+            } catch (exception: Throwable) {
+              BackgroundWorkerLockPigeonUtils.wrapError(exception)
+            }
+            reply.reply(wrapped)
+          }
+        } else {
+          channel.setMessageHandler(null)
+        }
+      }
+    }
+  }
+}

mobile/android/app/src/main/kotlin/app/alextran/immich/background/BackgroundWorkerPreferences.kt

@@ -0,0 +1,49 @@
+package app.alextran.immich.background
+
+import android.content.Context
+import android.content.SharedPreferences
+import androidx.core.content.edit
+
+class BackgroundWorkerPreferences(private val ctx: Context) {
+    companion object {
+        const val SHARED_PREF_NAME = "Immich::BackgroundWorker"
+        private const val SHARED_PREF_MIN_DELAY_KEY = "BackgroundWorker::minDelaySeconds"
+        private const val SHARED_PREF_REQUIRE_CHARGING_KEY = "BackgroundWorker::requireCharging"
+        private const val SHARED_PREF_LOCK_KEY = "BackgroundWorker::isLocked"
+
+        private const val DEFAULT_MIN_DELAY_SECONDS = 30L
+        private const val DEFAULT_REQUIRE_CHARGING = false
+    }
+
+    private val sp: SharedPreferences by lazy {
+        ctx.getSharedPreferences(SHARED_PREF_NAME, Context.MODE_PRIVATE)
+    }
+
+    fun updateSettings(settings: BackgroundWorkerSettings) {
+        sp.edit {
+            putLong(SHARED_PREF_MIN_DELAY_KEY, settings.minimumDelaySeconds)
+            putBoolean(SHARED_PREF_REQUIRE_CHARGING_KEY, settings.requiresCharging)
+        }
+    }
+
+    fun getSettings(): BackgroundWorkerSettings {
+        return BackgroundWorkerSettings(
+            minimumDelaySeconds = sp.getLong(SHARED_PREF_MIN_DELAY_KEY, DEFAULT_MIN_DELAY_SECONDS),
+            requiresCharging = sp.getBoolean(
+                SHARED_PREF_REQUIRE_CHARGING_KEY,
+                DEFAULT_REQUIRE_CHARGING
+            ),
+        )
+    }
+
+    fun setLocked(paused: Boolean) {
+        sp.edit {
+            putBoolean(SHARED_PREF_LOCK_KEY, paused)
+        }
+    }
+
+    fun isLocked(): Boolean {
+        return sp.getBoolean(SHARED_PREF_LOCK_KEY, true)
+    }
+}
+

mobile/android/app/src/main/kotlin/app/alextran/immich/images/ThumbnailsImpl.kt

@@ -17,6 +17,7 @@ import java.util.concurrent.Executors
 import com.bumptech.glide.Glide
 import com.bumptech.glide.Priority
 import com.bumptech.glide.load.DecodeFormat
+import com.bumptech.glide.request.target.Target.SIZE_ORIGINAL
 import java.util.Base64
 import java.util.concurrent.CancellationException
 import java.util.concurrent.ConcurrentHashMap
@@ -120,15 +121,14 @@ class ThumbnailsImpl(context: Context) : ThumbnailApi {
     signal: CancellationSignal
   ) {
     signal.throwIfCanceled()
-    val targetWidth = width.toInt()
-    val targetHeight = height.toInt()
+    val size = Size(width.toInt(), height.toInt())
     val id = assetId.toLong()
 
     signal.throwIfCanceled()
     val bitmap = if (isVideo) {
-      decodeVideoThumbnail(id, targetWidth, targetHeight, signal)
+      decodeVideoThumbnail(id, size, signal)
     } else {
-      decodeImage(id, targetWidth, targetHeight, signal)
+      decodeImage(id, size, signal)
     }
 
     processBitmap(bitmap, callback, signal)
@@ -151,9 +151,7 @@ class ThumbnailsImpl(context: Context) : ThumbnailApi {
       bitmap.recycle()
       signal.throwIfCanceled()
       val res = mapOf(
-        "pointer" to pointer,
-        "width" to actualWidth.toLong(),
-        "height" to actualHeight.toLong()
+        "pointer" to pointer, "width" to actualWidth.toLong(), "height" to actualHeight.toLong()
       )
       callback(Result.success(res))
     } catch (e: Exception) {
@@ -162,55 +160,54 @@ class ThumbnailsImpl(context: Context) : ThumbnailApi {
     }
   }
 
-  private fun decodeImage(
-    id: Long, targetWidth: Int, targetHeight: Int, signal: CancellationSignal
-  ): Bitmap {
+  private fun decodeImage(id: Long, size: Size, signal: CancellationSignal): Bitmap {
     signal.throwIfCanceled()
     val uri = ContentUris.withAppendedId(Images.Media.EXTERNAL_CONTENT_URI, id)
-    if (targetHeight > 768 || targetWidth > 768) {
-      return decodeSource(uri, targetWidth, targetHeight, signal)
+    if (size.width <= 0 || size.height <= 0 || size.width > 768 || size.height > 768) {
+      return decodeSource(uri, size, signal)
     }
 
     return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
-      resolver.loadThumbnail(uri, Size(targetWidth, targetHeight), signal)
+      resolver.loadThumbnail(uri, size, signal)
     } else {
       signal.setOnCancelListener { Images.Thumbnails.cancelThumbnailRequest(resolver, id) }
       Images.Thumbnails.getThumbnail(resolver, id, Images.Thumbnails.MINI_KIND, OPTIONS)
     }
   }
 
-  private fun decodeVideoThumbnail(
-    id: Long, targetWidth: Int, targetHeight: Int, signal: CancellationSignal
-  ): Bitmap {
+  private fun decodeVideoThumbnail(id: Long, target: Size, signal: CancellationSignal): Bitmap {
     signal.throwIfCanceled()
     return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
       val uri = ContentUris.withAppendedId(Video.Media.EXTERNAL_CONTENT_URI, id)
-      resolver.loadThumbnail(uri, Size(targetWidth, targetHeight), signal)
+      // ensure a valid resolution as the thumbnail is used for videos even when no scaling is needed
+      val size = if (target.width > 0 && target.height > 0) target else Size(768, 768)
+      resolver.loadThumbnail(uri, size, signal)
     } else {
       signal.setOnCancelListener { Video.Thumbnails.cancelThumbnailRequest(resolver, id) }
       Video.Thumbnails.getThumbnail(resolver, id, Video.Thumbnails.MINI_KIND, OPTIONS)
     }
   }
 
-  private fun decodeSource(
-    uri: Uri, targetWidth: Int, targetHeight: Int, signal: CancellationSignal
-  ): Bitmap {
+  private fun decodeSource(uri: Uri, target: Size, signal: CancellationSignal): Bitmap {
     signal.throwIfCanceled()
     return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
       val source = ImageDecoder.createSource(resolver, uri)
       signal.throwIfCanceled()
       ImageDecoder.decodeBitmap(source) { decoder, info, _ ->
-        if (targetWidth > 0 && targetHeight > 0) {
-          val sample = max(1, min(info.size.width / targetWidth, info.size.height / targetHeight))
+        if (target.width > 0 && target.height > 0) {
+          val sample = max(1, min(info.size.width / target.width, info.size.height / target.height))
           decoder.setTargetSampleSize(sample)
         }
         decoder.allocator = ImageDecoder.ALLOCATOR_SOFTWARE
         decoder.setTargetColorSpace(ColorSpace.get(ColorSpace.Named.SRGB))
       }
     } else {
-      val ref = Glide.with(ctx).asBitmap().priority(Priority.IMMEDIATE).load(uri)
-        .disallowHardwareConfig().format(DecodeFormat.PREFER_ARGB_8888)
-        .submit(targetWidth, targetHeight)
+      val ref =
+        Glide.with(ctx).asBitmap().priority(Priority.IMMEDIATE).load(uri).disallowHardwareConfig()
+          .format(DecodeFormat.PREFER_ARGB_8888).submit(
+            if (target.width > 0) target.width else SIZE_ORIGINAL,
+            if (target.height > 0) target.height else SIZE_ORIGINAL,
+          )
       signal.setOnCancelListener { Glide.with(ctx).clear(ref) }
       ref.get()
     }

mobile/android/app/src/main/kotlin/app/alextran/immich/sync/Messages.g.kt

@@ -209,6 +209,40 @@ data class SyncDelta (
 
   override fun hashCode(): Int = toList().hashCode()
 }
+
+/** Generated class from Pigeon that represents data sent in messages. */
+data class HashResult (
+  val assetId: String,
+  val error: String? = null,
+  val hash: String? = null
+)
+ {
+  companion object {
+    fun fromList(pigeonVar_list: List<Any?>): HashResult {
+      val assetId = pigeonVar_list[0] as String
+      val error = pigeonVar_list[1] as String?
+      val hash = pigeonVar_list[2] as String?
+      return HashResult(assetId, error, hash)
+    }
+  }
+  fun toList(): List<Any?> {
+    return listOf(
+      assetId,
+      error,
+      hash,
+    )
+  }
+  override fun equals(other: Any?): Boolean {
+    if (other !is HashResult) {
+      return false
+    }
+    if (this === other) {
+      return true
+    }
+    return MessagesPigeonUtils.deepEquals(toList(), other.toList())  }
+
+  override fun hashCode(): Int = toList().hashCode()
+}
 private open class MessagesPigeonCodec : StandardMessageCodec() {
   override fun readValueOfType(type: Byte, buffer: ByteBuffer): Any? {
     return when (type) {
@@ -227,6 +261,11 @@ private open class MessagesPigeonCodec : StandardMessageCodec() {
           SyncDelta.fromList(it)
         }
       }
+      132.toByte() -> {
+        return (readValue(buffer) as? List<Any?>)?.let {
+          HashResult.fromList(it)
+        }
+      }
       else -> super.readValueOfType(type, buffer)
     }
   }
@@ -244,11 +283,16 @@ private open class MessagesPigeonCodec : StandardMessageCodec() {
         stream.write(131)
         writeValue(stream, value.toList())
       }
+      is HashResult -> {
+        stream.write(132)
+        writeValue(stream, value.toList())
+      }
       else -> super.writeValue(stream, value)
     }
   }
 }
 
+
 /** Generated interface from Pigeon that represents a handler of messages from Flutter. */
 interface NativeSyncApi {
   fun shouldFullSync(): Boolean
@@ -259,7 +303,8 @@ interface NativeSyncApi {
   fun getAlbums(): List<PlatformAlbum>
   fun getAssetsCountSince(albumId: String, timestamp: Long): Long
   fun getAssetsForAlbum(albumId: String, updatedTimeCond: Long?): List<PlatformAsset>
-  fun hashPaths(paths: List<String>): List<ByteArray?>
+  fun hashAssets(assetIds: List<String>, allowNetworkAccess: Boolean, callback: (Result<List<HashResult>>) -> Unit)
+  fun cancelHashing()
 
   companion object {
     /** The codec used by NativeSyncApi. */
@@ -402,13 +447,33 @@ interface NativeSyncApi {
         }
       }
       run {
-        val channel = BasicMessageChannel<Any?>(binaryMessenger, "dev.flutter.pigeon.immich_mobile.NativeSyncApi.hashPaths$separatedMessageChannelSuffix", codec, taskQueue)
+        val channel = BasicMessageChannel<Any?>(binaryMessenger, "dev.flutter.pigeon.immich_mobile.NativeSyncApi.hashAssets$separatedMessageChannelSuffix", codec, taskQueue)
         if (api != null) {
           channel.setMessageHandler { message, reply ->
             val args = message as List<Any?>
-            val pathsArg = args[0] as List<String>
+            val assetIdsArg = args[0] as List<String>
+            val allowNetworkAccessArg = args[1] as Boolean
+            api.hashAssets(assetIdsArg, allowNetworkAccessArg) { result: Result<List<HashResult>> ->
+              val error = result.exceptionOrNull()
+              if (error != null) {
+                reply.reply(MessagesPigeonUtils.wrapError(error))
+              } else {
+                val data = result.getOrNull()
+                reply.reply(MessagesPigeonUtils.wrapResult(data))
+              }
+            }
+          }
+        } else {
+          channel.setMessageHandler(null)
+        }
+      }
+      run {
+        val channel = BasicMessageChannel<Any?>(binaryMessenger, "dev.flutter.pigeon.immich_mobile.NativeSyncApi.cancelHashing$separatedMessageChannelSuffix", codec)
+        if (api != null) {
+          channel.setMessageHandler { _, reply ->
             val wrapped: List<Any?> = try {
-              listOf(api.hashPaths(pathsArg))
+              api.cancelHashing()
+              listOf(null)
             } catch (exception: Throwable) {
               MessagesPigeonUtils.wrapError(exception)
             }

mobile/android/app/src/main/kotlin/app/alextran/immich/sync/MessagesImplBase.kt

@@ -1,14 +1,25 @@
 package app.alextran.immich.sync
 
 import android.annotation.SuppressLint
+import android.content.ContentUris
 import android.content.Context
 import android.database.Cursor
 import android.provider.MediaStore
-import android.util.Log
+import android.util.Base64
 import androidx.core.database.getStringOrNull
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.async
+import kotlinx.coroutines.awaitAll
+import kotlinx.coroutines.ensureActive
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.sync.Semaphore
+import kotlinx.coroutines.sync.withPermit
 import java.io.File
-import java.io.FileInputStream
 import java.security.MessageDigest
+import kotlin.coroutines.cancellation.CancellationException
+import kotlin.coroutines.coroutineContext
 
 sealed class AssetResult {
   data class ValidAsset(val asset: PlatformAsset, val albumId: String) : AssetResult()
@@ -19,8 +30,12 @@ sealed class AssetResult {
 open class NativeSyncApiImplBase(context: Context) {
   private val ctx: Context = context.applicationContext
 
+  private var hashTask: Job? = null
+
   companion object {
-    private const val TAG = "NativeSyncApiImplBase"
+    private const val MAX_CONCURRENT_HASH_OPERATIONS = 16
+    private val hashSemaphore = Semaphore(MAX_CONCURRENT_HASH_OPERATIONS)
+    private const val HASHING_CANCELLED_CODE = "HASH_CANCELLED"
 
     const val MEDIA_SELECTION =
       "(${MediaStore.Files.FileColumns.MEDIA_TYPE} = ? OR ${MediaStore.Files.FileColumns.MEDIA_TYPE} = ?)"
@@ -215,23 +230,74 @@ open class NativeSyncApiImplBase(context: Context) {
       .toList()
   }
 
-  fun hashPaths(paths: List<String>): List<ByteArray?> {
-    val buffer = ByteArray(HASH_BUFFER_SIZE)
-    val digest = MessageDigest.getInstance("SHA-1")
+  fun hashAssets(
+    assetIds: List<String>,
+    // allowNetworkAccess is only used on the iOS implementation
+    @Suppress("UNUSED_PARAMETER") allowNetworkAccess: Boolean,
+    callback: (Result<List<HashResult>>) -> Unit
+  ) {
+    if (assetIds.isEmpty()) {
+      callback(Result.success(emptyList()))
+      return
+    }
 
-    return paths.map { path ->
+    hashTask?.cancel()
+    hashTask = CoroutineScope(Dispatchers.IO).launch {
       try {
-        FileInputStream(path).use { file ->
-          var bytesRead: Int
-          while (file.read(buffer).also { bytesRead = it } > 0) {
-            digest.update(buffer, 0, bytesRead)
+        val results = assetIds.map { assetId ->
+          async {
+            hashSemaphore.withPermit {
+              ensureActive()
+              hashAsset(assetId)
+            }
           }
-        }
-        digest.digest()
+        }.awaitAll()
+
+        callback(Result.success(results))
+      } catch (e: CancellationException) {
+        callback(
+          Result.failure(
+            FlutterError(
+              HASHING_CANCELLED_CODE,
+              "Hashing operation was cancelled",
+              null
+            )
+          )
+        )
       } catch (e: Exception) {
-        Log.w(TAG, "Failed to hash file $path: $e")
-        null
+        callback(Result.failure(e))
       }
     }
   }
+
+  private suspend fun hashAsset(assetId: String): HashResult {
+    return try {
+      val assetUri = ContentUris.withAppendedId(
+        MediaStore.Files.getContentUri(MediaStore.VOLUME_EXTERNAL),
+        assetId.toLong()
+      )
+
+      val digest = MessageDigest.getInstance("SHA-1")
+      ctx.contentResolver.openInputStream(assetUri)?.use { inputStream ->
+        var bytesRead: Int
+        val buffer = ByteArray(HASH_BUFFER_SIZE)
+        while (inputStream.read(buffer).also { bytesRead = it } > 0) {
+          coroutineContext.ensureActive()
+          digest.update(buffer, 0, bytesRead)
+        }
+      } ?: return HashResult(assetId, "Cannot open input stream for asset", null)
+
+      val hashString = Base64.encodeToString(digest.digest(), Base64.NO_WRAP)
+      HashResult(assetId, null, hashString)
+    } catch (e: SecurityException) {
+      HashResult(assetId, "Permission denied accessing asset: ${e.message}", null)
+    } catch (e: Exception) {
+      HashResult(assetId, "Failed to hash asset: ${e.message}", null)
+    }
+  }
+
+  fun cancelHashing() {
+    hashTask?.cancel()
+    hashTask = null
+  }
 }

mobile/android/fastlane/Fastfile

@@ -35,8 +35,8 @@ platform :android do
       task: 'bundle', 
       build_type: 'Release',
       properties: {
-        "android.injected.version.code" => 3015,
-        "android.injected.version.name" => "1.142.1",
+        "android.injected.version.code" => 3016,
+        "android.injected.version.name" => "1.143.0",
       }
     )
     upload_to_play_store(skip_upload_apk: true, skip_upload_images: true, skip_upload_screenshots: true, aab: '../build/app/outputs/bundle/release/app-release.aab')

mobile/ios/.gitignore

@@ -4,7 +4,6 @@
 *.moved-aside
 *.pbxuser
 *.perspectivev3
-**/*sync/
 .sconsign.dblite
 .tags*
 **/.vagrant/

mobile/ios/Runner/Background/BackgroundWorkerApiImpl.swift

@@ -5,7 +5,7 @@ class BackgroundWorkerApiImpl: BackgroundWorkerFgHostApi {
   func enable() throws {
     BackgroundWorkerApiImpl.scheduleRefreshWorker()
     BackgroundWorkerApiImpl.scheduleProcessingWorker()
-    print("BackgroundUploadImpl:enbale Background worker scheduled")
+    print("BackgroundWorkerApiImpl:enable Background worker scheduled")
   }
   
   func configure(settings: BackgroundWorkerSettings) throws {
@@ -15,7 +15,7 @@ class BackgroundWorkerApiImpl: BackgroundWorkerFgHostApi {
   func disable() throws {
     BGTaskScheduler.shared.cancel(taskRequestWithIdentifier: BackgroundWorkerApiImpl.refreshTaskID);
     BGTaskScheduler.shared.cancel(taskRequestWithIdentifier: BackgroundWorkerApiImpl.processingTaskID);
-    print("BackgroundUploadImpl:disableUploadWorker Disabled background workers")
+    print("BackgroundWorkerApiImpl:disableUploadWorker Disabled background workers")
   }
   
   private static let refreshTaskID = "app.alextran.immich.background.refreshUpload"

mobile/ios/Runner/Sync/Messages.g.swift

@@ -267,6 +267,39 @@ struct SyncDelta: Hashable {
   }
 }
 
+/// Generated class from Pigeon that represents data sent in messages.
+struct HashResult: Hashable {
+  var assetId: String
+  var error: String? = nil
+  var hash: String? = nil
+
+
+  // swift-format-ignore: AlwaysUseLowerCamelCase
+  static func fromList(_ pigeonVar_list: [Any?]) -> HashResult? {
+    let assetId = pigeonVar_list[0] as! String
+    let error: String? = nilOrValue(pigeonVar_list[1])
+    let hash: String? = nilOrValue(pigeonVar_list[2])
+
+    return HashResult(
+      assetId: assetId,
+      error: error,
+      hash: hash
+    )
+  }
+  func toList() -> [Any?] {
+    return [
+      assetId,
+      error,
+      hash,
+    ]
+  }
+  static func == (lhs: HashResult, rhs: HashResult) -> Bool {
+    return deepEqualsMessages(lhs.toList(), rhs.toList())  }
+  func hash(into hasher: inout Hasher) {
+    deepHashMessages(value: toList(), hasher: &hasher)
+  }
+}
+
 private class MessagesPigeonCodecReader: FlutterStandardReader {
   override func readValue(ofType type: UInt8) -> Any? {
     switch type {
@@ -276,6 +309,8 @@ private class MessagesPigeonCodecReader: FlutterStandardReader {
       return PlatformAlbum.fromList(self.readValue() as! [Any?])
     case 131:
       return SyncDelta.fromList(self.readValue() as! [Any?])
+    case 132:
+      return HashResult.fromList(self.readValue() as! [Any?])
     default:
       return super.readValue(ofType: type)
     }
@@ -293,6 +328,9 @@ private class MessagesPigeonCodecWriter: FlutterStandardWriter {
     } else if let value = value as? SyncDelta {
       super.writeByte(131)
       super.writeValue(value.toList())
+    } else if let value = value as? HashResult {
+      super.writeByte(132)
+      super.writeValue(value.toList())
     } else {
       super.writeValue(value)
     }
@@ -313,6 +351,7 @@ class MessagesPigeonCodec: FlutterStandardMessageCodec, @unchecked Sendable {
   static let shared = MessagesPigeonCodec(readerWriter: MessagesPigeonCodecReaderWriter())
 }
 
+
 /// Generated protocol from Pigeon that represents a handler of messages from Flutter.
 protocol NativeSyncApi {
   func shouldFullSync() throws -> Bool
@@ -323,7 +362,8 @@ protocol NativeSyncApi {
   func getAlbums() throws -> [PlatformAlbum]
   func getAssetsCountSince(albumId: String, timestamp: Int64) throws -> Int64
   func getAssetsForAlbum(albumId: String, updatedTimeCond: Int64?) throws -> [PlatformAsset]
-  func hashPaths(paths: [String]) throws -> [FlutterStandardTypedData?]
+  func hashAssets(assetIds: [String], allowNetworkAccess: Bool, completion: @escaping (Result<[HashResult], Error>) -> Void)
+  func cancelHashing() throws
 }
 
 /// Generated setup class from Pigeon to handle messages through the `binaryMessenger`.
@@ -459,22 +499,38 @@ class NativeSyncApiSetup {
     } else {
       getAssetsForAlbumChannel.setMessageHandler(nil)
     }
-    let hashPathsChannel = taskQueue == nil
-      ? FlutterBasicMessageChannel(name: "dev.flutter.pigeon.immich_mobile.NativeSyncApi.hashPaths\(channelSuffix)", binaryMessenger: binaryMessenger, codec: codec)
-      : FlutterBasicMessageChannel(name: "dev.flutter.pigeon.immich_mobile.NativeSyncApi.hashPaths\(channelSuffix)", binaryMessenger: binaryMessenger, codec: codec, taskQueue: taskQueue)
+    let hashAssetsChannel = taskQueue == nil
+      ? FlutterBasicMessageChannel(name: "dev.flutter.pigeon.immich_mobile.NativeSyncApi.hashAssets\(channelSuffix)", binaryMessenger: binaryMessenger, codec: codec)
+      : FlutterBasicMessageChannel(name: "dev.flutter.pigeon.immich_mobile.NativeSyncApi.hashAssets\(channelSuffix)", binaryMessenger: binaryMessenger, codec: codec, taskQueue: taskQueue)
     if let api = api {
-      hashPathsChannel.setMessageHandler { message, reply in
+      hashAssetsChannel.setMessageHandler { message, reply in
         let args = message as! [Any?]
-        let pathsArg = args[0] as! [String]
+        let assetIdsArg = args[0] as! [String]
+        let allowNetworkAccessArg = args[1] as! Bool
+        api.hashAssets(assetIds: assetIdsArg, allowNetworkAccess: allowNetworkAccessArg) { result in
+          switch result {
+          case .success(let res):
+            reply(wrapResult(res))
+          case .failure(let error):
+            reply(wrapError(error))
+          }
+        }
+      }
+    } else {
+      hashAssetsChannel.setMessageHandler(nil)
+    }
+    let cancelHashingChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.immich_mobile.NativeSyncApi.cancelHashing\(channelSuffix)", binaryMessenger: binaryMessenger, codec: codec)
+    if let api = api {
+      cancelHashingChannel.setMessageHandler { _, reply in
         do {
-          let result = try api.hashPaths(paths: pathsArg)
-          reply(wrapResult(result))
+          try api.cancelHashing()
+          reply(wrapResult(nil))
         } catch {
           reply(wrapError(error))
         }
       }
     } else {
-      hashPathsChannel.setMessageHandler(nil)
+      cancelHashingChannel.setMessageHandler(nil)
     }
   }
 }

mobile/ios/Runner/Sync/MessagesImpl.swift

@@ -17,30 +17,16 @@ struct AssetWrapper: Hashable, Equatable {
   }
 }
 
-extension PHAsset {
-  func toPlatformAsset() -> PlatformAsset {
-    return PlatformAsset(
-      id: localIdentifier,
-      name: title(),
-      type: Int64(mediaType.rawValue),
-      createdAt: creationDate.map { Int64($0.timeIntervalSince1970) },
-      updatedAt: modificationDate.map { Int64($0.timeIntervalSince1970) },
-      width: Int64(pixelWidth),
-      height: Int64(pixelHeight),
-      durationInSeconds: Int64(duration),
-      orientation: 0,
-      isFavorite: isFavorite
-    )
-  }
-}
-
 class NativeSyncApiImpl: NativeSyncApi {
   private let defaults: UserDefaults
   private let changeTokenKey = "immich:changeToken"
   private let albumTypes: [PHAssetCollectionType] = [.album, .smartAlbum]
   private let recoveredAlbumSubType = 1000000219
   
-  private let hashBufferSize = 2 * 1024 * 1024
+  private var hashTask: Task<Void, Error>?
+  private static let hashCancelledCode = "HASH_CANCELLED"
+  private static let hashCancelled = Result<[HashResult], Error>.failure(PigeonError(code: hashCancelledCode, message: "Hashing cancelled", details: nil))
+  
   
   init(with defaults: UserDefaults = .standard) {
     self.defaults = defaults
@@ -96,7 +82,7 @@ class NativeSyncApiImpl: NativeSyncApi {
       let collections = PHAssetCollection.fetchAssetCollections(with: type, subtype: .any, options: nil)
       for i in 0..<collections.count {
         let album = collections.object(at: i)
-      
+        
         // Ignore recovered album
         if(album.assetCollectionSubtype.rawValue == self.recoveredAlbumSubType) {
           continue;
@@ -254,7 +240,7 @@ class NativeSyncApiImpl: NativeSyncApi {
       let date = NSDate(timeIntervalSince1970: TimeInterval(updatedTimeCond!))
       options.predicate = NSPredicate(format: "creationDate > %@ OR modificationDate > %@", date, date)
     }
-
+    
     let result = PHAsset.fetchAssets(in: album, options: options)
     if(result.count == 0) {
       return []
@@ -267,23 +253,114 @@ class NativeSyncApiImpl: NativeSyncApi {
     return assets
   }
   
-  func hashPaths(paths: [String]) throws -> [FlutterStandardTypedData?] {
-      return paths.map { path in
-          guard let file = FileHandle(forReadingAtPath: path) else {
-              print("Cannot open file: \(path)")
-              return nil
-          }
-          
-          var hasher = Insecure.SHA1()
-          while autoreleasepool(invoking: {
-              let chunk = file.readData(ofLength: hashBufferSize)
-              guard !chunk.isEmpty else { return false }
-              hasher.update(data: chunk)
-              return true
-          }) { }
-          
-          let digest = hasher.finalize()
-          return FlutterStandardTypedData(bytes: Data(digest))
+  func hashAssets(assetIds: [String], allowNetworkAccess: Bool, completion: @escaping (Result<[HashResult], Error>) -> Void) {
+    if let prevTask = hashTask {
+      prevTask.cancel()
+      hashTask = nil
+    }
+    hashTask = Task { [weak self] in
+      var missingAssetIds = Set(assetIds)
+      var assets = [PHAsset]()
+      assets.reserveCapacity(assetIds.count)
+      PHAsset.fetchAssets(withLocalIdentifiers: assetIds, options: nil).enumerateObjects { (asset, _, stop) in
+        if Task.isCancelled {
+          stop.pointee = true
+          return
+        }
+        missingAssetIds.remove(asset.localIdentifier)
+        assets.append(asset)
       }
+      
+      if Task.isCancelled {
+        return completion(Self.hashCancelled)
+      }
+      
+      await withTaskGroup(of: HashResult?.self) { taskGroup in
+        var results = [HashResult]()
+        results.reserveCapacity(assets.count)
+        for asset in assets {
+          if Task.isCancelled {
+            return completion(Self.hashCancelled)
+          }
+          taskGroup.addTask {
+            guard let self = self else { return nil }
+            return await self.hashAsset(asset, allowNetworkAccess: allowNetworkAccess)
+          }
+        }
+        
+        for await result in taskGroup {
+          guard let result = result else {
+            return completion(Self.hashCancelled)
+          }
+          results.append(result)
+        }
+        
+        for missing in missingAssetIds {
+          results.append(HashResult(assetId: missing, error: "Asset not found in library", hash: nil))
+        }
+        
+        completion(.success(results))
+      }
+    }
+  }
+  
+  func cancelHashing() {
+    hashTask?.cancel()
+    hashTask = nil
+  }
+  
+  private func hashAsset(_ asset: PHAsset, allowNetworkAccess: Bool) async -> HashResult? {
+    class RequestRef {
+      var id: PHAssetResourceDataRequestID?
+    }
+    let requestRef = RequestRef()
+    return await withTaskCancellationHandler(operation: {
+      if Task.isCancelled {
+        return nil
+      }
+      
+      guard let resource = asset.getResource() else {
+        return HashResult(assetId: asset.localIdentifier, error: "Cannot get asset resource", hash: nil)
+      }
+      
+      if Task.isCancelled {
+        return nil
+      }
+      
+      let options = PHAssetResourceRequestOptions()
+      options.isNetworkAccessAllowed = allowNetworkAccess
+      
+      return await withCheckedContinuation { continuation in
+        var hasher = Insecure.SHA1()
+        
+        requestRef.id = PHAssetResourceManager.default().requestData(
+          for: resource,
+          options: options,
+          dataReceivedHandler: { data in
+            hasher.update(data: data)
+          },
+          completionHandler: { error in
+            let result: HashResult? = switch (error) {
+            case let e as PHPhotosError where e.code == .userCancelled: nil
+            case let .some(e): HashResult(
+              assetId: asset.localIdentifier,
+              error: "Failed to hash asset: \(e.localizedDescription)",
+              hash: nil
+            )
+            case .none:
+              HashResult(
+                assetId: asset.localIdentifier,
+                error: nil,
+                hash: Data(hasher.finalize()).base64EncodedString()
+              )
+            }
+            continuation.resume(returning: result)
+          }
+        )
+      }
+    }, onCancel: {
+      guard let requestId = requestRef.id else { return }
+      PHAssetResourceManager.default().cancelDataRequest(requestId)
+    })
   }
 }

mobile/ios/Runner/Sync/PHAssetExtensions.swift

@@ -0,0 +1,77 @@
+import Photos
+
+extension PHAsset {
+  func toPlatformAsset() -> PlatformAsset {
+    return PlatformAsset(
+      id: localIdentifier,
+      name: title,
+      type: Int64(mediaType.rawValue),
+      createdAt: creationDate.map { Int64($0.timeIntervalSince1970) },
+      updatedAt: modificationDate.map { Int64($0.timeIntervalSince1970) },
+      width: Int64(pixelWidth),
+      height: Int64(pixelHeight),
+      durationInSeconds: Int64(duration),
+      orientation: 0,
+      isFavorite: isFavorite
+    )
+  }
+
+  var title: String {
+    return filename ?? originalFilename ?? "<unknown>"
+  }
+
+  var filename: String? {
+    return value(forKey: "filename") as? String
+  }
+
+  // This method is expected to be slow as it goes through the asset resources to fetch the originalFilename
+  var originalFilename: String? {
+    return getResource()?.originalFilename
+  }
+
+  func getResource() -> PHAssetResource? {
+    let resources = PHAssetResource.assetResources(for: self)
+
+    let filteredResources = resources.filter { $0.isMediaResource && isValidResourceType($0.type) }
+
+    guard !filteredResources.isEmpty else {
+      return nil
+    }
+
+    if filteredResources.count == 1 {
+      return filteredResources.first
+    }
+
+    if let currentResource = filteredResources.first(where: { $0.isCurrent }) {
+      return currentResource
+    }
+
+    if let fullSizeResource = filteredResources.first(where: { isFullSizeResourceType($0.type) }) {
+      return fullSizeResource
+    }
+
+    return nil
+  }
+
+  private func isValidResourceType(_ type: PHAssetResourceType) -> Bool {
+    switch mediaType {
+    case .image:
+      return [.photo, .alternatePhoto, .fullSizePhoto].contains(type)
+    case .video:
+      return [.video, .fullSizeVideo, .fullSizePairedVideo].contains(type)
+    default:
+      return false
+    }
+  }
+
+  private func isFullSizeResourceType(_ type: PHAssetResourceType) -> Bool {
+    switch mediaType {
+    case .image:
+      return type == .fullSizePhoto
+    case .video:
+      return type == .fullSizeVideo
+    default:
+      return false
+    }
+  }
+}

mobile/ios/Runner/Sync/PHAssetResourceExtensions.swift

@@ -0,0 +1,16 @@
+
+import Photos
+
+extension PHAssetResource {
+  var isCurrent: Bool {
+    return value(forKey: "isCurrent") as? Bool ?? false
+  }
+  
+  var isMediaResource: Bool {
+    var isMedia = type != .adjustmentData
+    if #available(iOS 17, *) {
+      isMedia = isMedia && type != .photoProxy
+    }
+    return isMedia
+  }
+}

mobile/ios/fastlane/Fastfile

@@ -22,7 +22,7 @@ platform :ios do
       path: "./Runner.xcodeproj",
     )
     increment_version_number(
-      version_number: "1.142.1"
+      version_number: "1.143.0"
     )
     increment_build_number(
       build_number: latest_testflight_build_number + 1,

mobile/lib/constants/constants.dart

@@ -1,3 +1,5 @@
+import 'dart:io';
+
 const int noDbId = -9223372036854775808; // from Isar
 const double downloadCompleted = -1;
 const double downloadFailed = -2;
@@ -10,7 +12,7 @@ const int kSyncEventBatchSize = 5000;
 const int kFetchLocalAssetsBatchSize = 40000;
 
 // Hash batch limits
-const int kBatchHashFileLimit = 256;
+final int kBatchHashFileLimit = Platform.isIOS ? 32 : 512;
 const int kBatchHashSizeLimit = 1024 * 1024 * 1024; // 1GB
 
 // Secure storage keys

mobile/lib/domain/services/asset.service.dart

@@ -40,13 +40,12 @@ class AssetService {
 
   Future<List<RemoteAsset>> getStack(RemoteAsset asset) async {
     if (asset.stackId == null) {
-      return [];
+      return const [];
     }
 
-    return _remoteAssetRepository.getStackChildren(asset).then((assets) {
-      // Include the primary asset in the stack as the first item
-      return [asset, ...assets];
-    });
+    final stack = await _remoteAssetRepository.getStackChildren(asset);
+    // Include the primary asset in the stack as the first item
+    return [asset, ...stack];
   }
 
   Future<ExifInfo?> getExif(BaseAsset asset) async {

mobile/lib/domain/services/background_worker.service.dart

@@ -10,11 +10,13 @@ import 'package:immich_mobile/constants/constants.dart';
 import 'package:immich_mobile/domain/services/log.service.dart';
 import 'package:immich_mobile/entities/store.entity.dart';
 import 'package:immich_mobile/extensions/network_capability_extensions.dart';
+import 'package:immich_mobile/extensions/platform_extensions.dart';
 import 'package:immich_mobile/extensions/translate_extensions.dart';
 import 'package:immich_mobile/generated/intl_keys.g.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/platform/background_worker_lock_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';
@@ -58,7 +60,7 @@ class BackgroundWorkerFgService {
 }
 
 class BackgroundWorkerBgService extends BackgroundWorkerFlutterApi {
-  late final ProviderContainer _ref;
+  ProviderContainer? _ref;
   final Isar _isar;
   final Drift _drift;
   final DriftLogger _driftLogger;
@@ -83,29 +85,31 @@ class BackgroundWorkerBgService extends BackgroundWorkerFlutterApi {
     BackgroundWorkerFlutterApi.setUp(this);
   }
 
-  bool get _isBackupEnabled => _ref.read(appSettingsServiceProvider).getSetting(AppSettingsEnum.enableBackup);
+  bool get _isBackupEnabled => _ref?.read(appSettingsServiceProvider).getSetting(AppSettingsEnum.enableBackup) ?? false;
 
   Future<void> init() async {
     try {
       HttpSSLOptions.apply(applyNative: false);
 
-      await Future.wait([
-        loadTranslations(),
-        workerManager.init(dynamicSpawning: true),
-        _ref.read(authServiceProvider).setOpenApiServiceEndpoint(),
-        // Initialize the file downloader
-        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),
-          ],
-        ),
-        FileDownloader().trackTasksInGroup(kDownloadGroupLivePhoto, markDownloadedComplete: false),
-        FileDownloader().trackTasks(),
-        _ref.read(fileMediaRepositoryProvider).enableBackgroundAccess(),
-      ]);
+      await Future.wait(
+        [
+          loadTranslations(),
+          workerManager.init(dynamicSpawning: true),
+          _ref?.read(authServiceProvider).setOpenApiServiceEndpoint(),
+          // Initialize the file downloader
+          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),
+            ],
+          ),
+          FileDownloader().trackTasksInGroup(kDownloadGroupLivePhoto, markDownloadedComplete: false),
+          FileDownloader().trackTasks(),
+          _ref?.read(fileMediaRepositoryProvider).enableBackgroundAccess(),
+        ].nonNulls,
+      );
 
       configureFileDownloaderNotifications();
 
@@ -178,14 +182,17 @@ class BackgroundWorkerBgService extends BackgroundWorkerFlutterApi {
   }
 
   Future<void> _cleanup() async {
-    if (_isCleanedUp) {
+    // If ref is null, it means the service was never initialized properly
+    if (_isCleanedUp || _ref == null) {
       return;
     }
 
     try {
-      final backgroundSyncManager = _ref.read(backgroundSyncProvider);
       _isCleanedUp = true;
-      _ref.dispose();
+      final backgroundSyncManager = _ref?.read(backgroundSyncProvider);
+      final nativeSyncApi = _ref?.read(nativeSyncApiProvider);
+      _ref?.dispose();
+      _ref = null;
 
       _cancellationToken.cancel();
       _logger.info("Cleaning up background worker");
@@ -198,14 +205,14 @@ class BackgroundWorkerBgService extends BackgroundWorkerFlutterApi {
         Store.dispose(),
         _drift.close(),
         _driftLogger.close(),
-        backgroundSyncManager.cancel(),
-        backgroundSyncManager.cancelLocal(),
+        backgroundSyncManager?.cancel(),
+        nativeSyncApi?.cancelHashing(),
       ];
 
       if (_isar.isOpen) {
         cleanupFutures.add(_isar.close());
       }
-      await Future.wait(cleanupFutures);
+      await Future.wait(cleanupFutures.nonNulls);
       _logger.info("Background worker resources cleaned up");
     } catch (error, stack) {
       dPrint(() => 'Failed to cleanup background worker: $error with stack: $stack');
@@ -215,14 +222,18 @@ class BackgroundWorkerBgService extends BackgroundWorkerFlutterApi {
   Future<void> _handleBackup() async {
     await runZonedGuarded(
       () async {
-        if (!_isBackupEnabled || _isCleanedUp) {
+        if (_isCleanedUp) {
+          return;
+        }
+
+        if (!_isBackupEnabled) {
           _logger.info("[_handleBackup 1] Backup is disabled. Skipping backup routine");
           return;
         }
 
         _logger.info("[_handleBackup 2] Enqueuing assets for backup from the background service");
 
-        final currentUser = _ref.read(currentUserProvider);
+        final currentUser = _ref?.read(currentUserProvider);
         if (currentUser == null) {
           _logger.warning("[_handleBackup 3] No current user found. Skipping backup from background");
           return;
@@ -230,19 +241,18 @@ class BackgroundWorkerBgService extends BackgroundWorkerFlutterApi {
 
         _logger.info("[_handleBackup 4] Resume backup from background");
         if (Platform.isIOS) {
-          return _ref.read(driftBackupProvider.notifier).handleBackupResume(currentUser.id);
+          return _ref?.read(driftBackupProvider.notifier).handleBackupResume(currentUser.id);
         }
 
-        final canPing = await _ref.read(serverInfoServiceProvider).ping();
+        final canPing = await _ref?.read(serverInfoServiceProvider).ping() ?? false;
         if (!canPing) {
           _logger.warning("[_handleBackup 5] Server is not reachable. Skipping backup from background");
           return;
         }
 
-        final networkCapabilities = await _ref.read(connectivityApiProvider).getCapabilities();
-
+        final networkCapabilities = await _ref?.read(connectivityApiProvider).getCapabilities() ?? [];
         return _ref
-            .read(uploadServiceProvider)
+            ?.read(uploadServiceProvider)
             .startBackupWithHttpClient(currentUser.id, networkCapabilities.hasWifi, _cancellationToken);
       },
       (error, stack) {
@@ -252,18 +262,18 @@ class BackgroundWorkerBgService extends BackgroundWorkerFlutterApi {
   }
 
   Future<void> _syncAssets({Duration? hashTimeout}) async {
-    await _ref.read(backgroundSyncProvider).syncLocal();
+    await _ref?.read(backgroundSyncProvider).syncLocal();
     if (_isCleanedUp) {
       return;
     }
 
-    await _ref.read(backgroundSyncProvider).syncRemote();
+    await _ref?.read(backgroundSyncProvider).syncRemote();
     if (_isCleanedUp) {
       return;
     }
 
-    var hashFuture = _ref.read(backgroundSyncProvider).hashAssets();
-    if (hashTimeout != null) {
+    var hashFuture = _ref?.read(backgroundSyncProvider).hashAssets();
+    if (hashTimeout != null && hashFuture != null) {
       hashFuture = hashFuture.timeout(
         hashTimeout,
         onTimeout: () {
@@ -276,6 +286,23 @@ class BackgroundWorkerBgService extends BackgroundWorkerFlutterApi {
   }
 }
 
+class BackgroundWorkerLockService {
+  final BackgroundWorkerLockApi _hostApi;
+  const BackgroundWorkerLockService(this._hostApi);
+
+  Future<void> lock() async {
+    if (CurrentPlatform.isAndroid) {
+      return _hostApi.lock();
+    }
+  }
+
+  Future<void> unlock() async {
+    if (CurrentPlatform.isAndroid) {
+      return _hostApi.unlock();
+    }
+  }
+}
+
 /// Native entry invoked from the background worker. If renaming or moving this to a different
 /// library, make sure to update the entry points and URI in native workers as well
 @pragma('vm:entry-point')

mobile/lib/domain/services/hash.service.dart

@@ -1,20 +1,18 @@
-import 'dart:convert';
-
+import 'package:flutter/services.dart';
 import 'package:immich_mobile/constants/constants.dart';
 import 'package:immich_mobile/domain/models/album/local_album.model.dart';
 import 'package:immich_mobile/domain/models/asset/base_asset.model.dart';
 import 'package:immich_mobile/infrastructure/repositories/local_album.repository.dart';
 import 'package:immich_mobile/infrastructure/repositories/local_asset.repository.dart';
-import 'package:immich_mobile/infrastructure/repositories/storage.repository.dart';
 import 'package:immich_mobile/platform/native_sync_api.g.dart';
 import 'package:logging/logging.dart';
 
+const String _kHashCancelledCode = "HASH_CANCELLED";
+
 class HashService {
-  final int batchSizeLimit;
-  final int batchFileLimit;
+  final int _batchSize;
   final DriftLocalAlbumRepository _localAlbumRepository;
   final DriftLocalAssetRepository _localAssetRepository;
-  final StorageRepository _storageRepository;
   final NativeSyncApi _nativeSyncApi;
   final bool Function()? _cancelChecker;
   final _log = Logger('HashService');
@@ -22,37 +20,42 @@ class HashService {
   HashService({
     required DriftLocalAlbumRepository localAlbumRepository,
     required DriftLocalAssetRepository localAssetRepository,
-    required StorageRepository storageRepository,
     required NativeSyncApi nativeSyncApi,
     bool Function()? cancelChecker,
-    this.batchSizeLimit = kBatchHashSizeLimit,
-    this.batchFileLimit = kBatchHashFileLimit,
+    int? batchSize,
   }) : _localAlbumRepository = localAlbumRepository,
        _localAssetRepository = localAssetRepository,
-       _storageRepository = storageRepository,
        _cancelChecker = cancelChecker,
-       _nativeSyncApi = nativeSyncApi;
+       _nativeSyncApi = nativeSyncApi,
+       _batchSize = batchSize ?? kBatchHashFileLimit;
 
   bool get isCancelled => _cancelChecker?.call() ?? false;
 
   Future<void> hashAssets() async {
     _log.info("Starting hashing of assets");
     final Stopwatch stopwatch = Stopwatch()..start();
-    // Sorted by backupSelection followed by isCloud
-    final localAlbums = await _localAlbumRepository.getAll(
-      sortBy: {SortLocalAlbumsBy.backupSelection, SortLocalAlbumsBy.isIosSharedAlbum},
-    );
+    try {
+      // Sorted by backupSelection followed by isCloud
+      final localAlbums = await _localAlbumRepository.getBackupAlbums();
 
-    for (final album in localAlbums) {
-      if (isCancelled) {
-        _log.warning("Hashing cancelled. Stopped processing albums.");
-        break;
-      }
+      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(album, assetsToHash);
+        final assetsToHash = await _localAlbumRepository.getAssetsToHash(album.id);
+        if (assetsToHash.isNotEmpty) {
+          await _hashAssets(album, assetsToHash);
+        }
       }
+    } on PlatformException catch (e) {
+      if (e.code == _kHashCancelledCode) {
+        _log.warning("Hashing cancelled by platform");
+        return;
+      }
+    } catch (e, s) {
+      _log.severe("Error during hashing", e, s);
     }
 
     stopwatch.stop();
@@ -63,8 +66,7 @@ class HashService {
   /// with hash for those that were successfully hashed. Hashes are looked up in a table
   /// [LocalAssetHashEntity] by local id. Only missing entries are newly hashed and added to the DB.
   Future<void> _hashAssets(LocalAlbum album, List<LocalAsset> assetsToHash) async {
-    int bytesProcessed = 0;
-    final toHash = <_AssetToPath>[];
+    final toHash = <String, LocalAsset>{};
 
     for (final asset in assetsToHash) {
       if (isCancelled) {
@@ -72,21 +74,10 @@ class HashService {
         return;
       }
 
-      final file = await _storageRepository.getFileForAsset(asset.id);
-      if (file == null) {
-        _log.warning(
-          "Cannot get file for asset ${asset.id}, name: ${asset.name}, created on: ${asset.createdAt} from album: ${album.name}",
-        );
-        continue;
-      }
-
-      bytesProcessed += await file.length();
-      toHash.add(_AssetToPath(asset: asset, path: file.path));
-
-      if (toHash.length >= batchFileLimit || bytesProcessed >= batchSizeLimit) {
+      toHash[asset.id] = asset;
+      if (toHash.length == _batchSize) {
         await _processBatch(album, toHash);
         toHash.clear();
-        bytesProcessed = 0;
       }
     }
 
@@ -94,33 +85,36 @@ class HashService {
   }
 
   /// Processes a batch of assets.
-  Future<void> _processBatch(LocalAlbum album, List<_AssetToPath> toHash) async {
+  Future<void> _processBatch(LocalAlbum album, Map<String, LocalAsset> toHash) async {
     if (toHash.isEmpty) {
       return;
     }
 
     _log.fine("Hashing ${toHash.length} files");
 
-    final hashed = <LocalAsset>[];
-    final hashes = await _nativeSyncApi.hashPaths(toHash.map((e) => e.path).toList());
+    final hashed = <String, String>{};
+    final hashResults = await _nativeSyncApi.hashAssets(
+      toHash.keys.toList(),
+      allowNetworkAccess: album.backupSelection == BackupSelection.selected,
+    );
     assert(
-      hashes.length == toHash.length,
-      "Hashes length does not match toHash length: ${hashes.length} != ${toHash.length}",
+      hashResults.length == toHash.length,
+      "Hashes length does not match toHash length: ${hashResults.length} != ${toHash.length}",
     );
 
-    for (int i = 0; i < hashes.length; i++) {
+    for (int i = 0; i < hashResults.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) {
-        hashed.add(asset.copyWith(checksum: base64.encode(hash!)));
+      final hashResult = hashResults[i];
+      if (hashResult.hash != null) {
+        hashed[hashResult.assetId] = hashResult.hash!;
       } else {
+        final asset = toHash[hashResult.assetId];
         _log.warning(
-          "Failed to hash file for ${asset.id}: ${asset.name} created at ${asset.createdAt} from album: ${album.name}",
+          "Failed to hash asset with id: ${hashResult.assetId}, name: ${asset?.name}, createdAt: ${asset?.createdAt}, from album: ${album.name}. Error: ${hashResult.error ?? "unknown"}",
         );
       }
     }
@@ -128,13 +122,5 @@ class HashService {
     _log.fine("Hashed ${hashed.length}/${toHash.length} assets");
 
     await _localAssetRepository.updateHashes(hashed);
-    await _storageRepository.clearCache();
   }
 }
-
-class _AssetToPath {
-  final LocalAsset asset;
-  final String path;
-
-  const _AssetToPath({required this.asset, required this.path});
-}

mobile/lib/domain/services/sync_linked_album.service.dart

@@ -4,8 +4,8 @@ import 'package:immich_mobile/infrastructure/repositories/local_album.repository
 import 'package:immich_mobile/infrastructure/repositories/remote_album.repository.dart';
 import 'package:immich_mobile/providers/infrastructure/album.provider.dart';
 import 'package:immich_mobile/repositories/drift_album_api_repository.dart';
-import 'package:logging/logging.dart';
 import 'package:immich_mobile/utils/debug_print.dart';
+import 'package:logging/logging.dart';
 
 final syncLinkedAlbumServiceProvider = Provider(
   (ref) => SyncLinkedAlbumService(
@@ -31,17 +31,19 @@ class SyncLinkedAlbumService {
       selectedAlbums.map((localAlbum) async {
         final linkedRemoteAlbumId = localAlbum.linkedRemoteAlbumId;
         if (linkedRemoteAlbumId == null) {
+          _log.warning("No linked remote album ID found for local album: ${localAlbum.name}");
           return;
         }
 
         final remoteAlbum = await _remoteAlbumRepository.get(linkedRemoteAlbumId);
         if (remoteAlbum == null) {
+          _log.warning("Linked remote album not found for ID: $linkedRemoteAlbumId");
           return;
         }
 
         // get assets that are uploaded but not in the remote album
         final assetIds = await _remoteAlbumRepository.getLinkedAssetIds(userId, localAlbum.id, linkedRemoteAlbumId);
-
+        _log.fine("Syncing ${assetIds.length} assets to remote album: ${remoteAlbum.name}");
         if (assetIds.isNotEmpty) {
           final album = await _albumApiRepository.addAssets(remoteAlbum.id, assetIds);
           await _remoteAlbumRepository.addAssets(remoteAlbum.id, album.added);

mobile/lib/domain/utils/sync_linked_album.dart

@@ -2,10 +2,12 @@ import 'package:hooks_riverpod/hooks_riverpod.dart';
 import 'package:immich_mobile/domain/models/store.model.dart';
 import 'package:immich_mobile/domain/services/sync_linked_album.service.dart';
 import 'package:immich_mobile/entities/store.entity.dart';
+import 'package:logging/logging.dart';
 
 Future<void> syncLinkedAlbumsIsolated(ProviderContainer ref) {
   final user = Store.tryGet(StoreKey.currentUser);
   if (user == null) {
+    Logger("SyncLinkedAlbum").warning("No user logged in, skipping linked album sync");
     return Future.value();
   }
   return ref.read(syncLinkedAlbumServiceProvider).syncLinkedAlbums(user.id);

mobile/lib/infrastructure/entities/local_album_asset.entity.dart

@@ -10,6 +10,9 @@ class LocalAlbumAssetEntity extends Table with DriftDefaultsMixin {
 
   TextColumn get albumId => text().references(LocalAlbumEntity, #id, onDelete: KeyAction.cascade)();
 
+  // Used for mark & sweep
+  BoolColumn get marker_ => boolean().nullable()();
+
   @override
   Set<Column> get primaryKey => {assetId, albumId};
 }

mobile/lib/infrastructure/entities/local_album_asset.entity.drift.dart

@@ -15,11 +15,13 @@ typedef $$LocalAlbumAssetEntityTableCreateCompanionBuilder =
     i1.LocalAlbumAssetEntityCompanion Function({
       required String assetId,
       required String albumId,
+      i0.Value<bool?> marker_,
     });
 typedef $$LocalAlbumAssetEntityTableUpdateCompanionBuilder =
     i1.LocalAlbumAssetEntityCompanion Function({
       i0.Value<String> assetId,
       i0.Value<String> albumId,
+      i0.Value<bool?> marker_,
     });
 
 final class $$LocalAlbumAssetEntityTableReferences
@@ -113,6 +115,11 @@ class $$LocalAlbumAssetEntityTableFilterComposer
     super.$addJoinBuilderToRootComposer,
     super.$removeJoinBuilderFromRootComposer,
   });
+  i0.ColumnFilters<bool> get marker_ => $composableBuilder(
+    column: $table.marker_,
+    builder: (column) => i0.ColumnFilters(column),
+  );
+
   i3.$$LocalAssetEntityTableFilterComposer get assetId {
     final i3.$$LocalAssetEntityTableFilterComposer composer = $composerBuilder(
       composer: this,
@@ -177,6 +184,11 @@ class $$LocalAlbumAssetEntityTableOrderingComposer
     super.$addJoinBuilderToRootComposer,
     super.$removeJoinBuilderFromRootComposer,
   });
+  i0.ColumnOrderings<bool> get marker_ => $composableBuilder(
+    column: $table.marker_,
+    builder: (column) => i0.ColumnOrderings(column),
+  );
+
   i3.$$LocalAssetEntityTableOrderingComposer get assetId {
     final i3.$$LocalAssetEntityTableOrderingComposer composer =
         $composerBuilder(
@@ -243,6 +255,9 @@ class $$LocalAlbumAssetEntityTableAnnotationComposer
     super.$addJoinBuilderToRootComposer,
     super.$removeJoinBuilderFromRootComposer,
   });
+  i0.GeneratedColumn<bool> get marker_ =>
+      $composableBuilder(column: $table.marker_, builder: (column) => column);
+
   i3.$$LocalAssetEntityTableAnnotationComposer get assetId {
     final i3.$$LocalAssetEntityTableAnnotationComposer composer =
         $composerBuilder(
@@ -344,16 +359,22 @@ class $$LocalAlbumAssetEntityTableTableManager
               ({
                 i0.Value<String> assetId = const i0.Value.absent(),
                 i0.Value<String> albumId = const i0.Value.absent(),
+                i0.Value<bool?> marker_ = const i0.Value.absent(),
               }) => i1.LocalAlbumAssetEntityCompanion(
                 assetId: assetId,
                 albumId: albumId,
+                marker_: marker_,
               ),
           createCompanionCallback:
-              ({required String assetId, required String albumId}) =>
-                  i1.LocalAlbumAssetEntityCompanion.insert(
-                    assetId: assetId,
-                    albumId: albumId,
-                  ),
+              ({
+                required String assetId,
+                required String albumId,
+                i0.Value<bool?> marker_ = const i0.Value.absent(),
+              }) => i1.LocalAlbumAssetEntityCompanion.insert(
+                assetId: assetId,
+                albumId: albumId,
+                marker_: marker_,
+              ),
           withReferenceMapper: (p0) => p0
               .map(
                 (e) => (
@@ -477,8 +498,22 @@ class $LocalAlbumAssetEntityTable extends i2.LocalAlbumAssetEntity
       'REFERENCES local_album_entity (id) ON DELETE CASCADE',
     ),
   );
+  static const i0.VerificationMeta _marker_Meta = const i0.VerificationMeta(
+    'marker_',
+  );
   @override
-  List<i0.GeneratedColumn> get $columns => [assetId, albumId];
+  late final i0.GeneratedColumn<bool> marker_ = i0.GeneratedColumn<bool>(
+    'marker',
+    aliasedName,
+    true,
+    type: i0.DriftSqlType.bool,
+    requiredDuringInsert: false,
+    defaultConstraints: i0.GeneratedColumn.constraintIsAlways(
+      'CHECK ("marker" IN (0, 1))',
+    ),
+  );
+  @override
+  List<i0.GeneratedColumn> get $columns => [assetId, albumId, marker_];
   @override
   String get aliasedName => _alias ?? actualTableName;
   @override
@@ -507,6 +542,12 @@ class $LocalAlbumAssetEntityTable extends i2.LocalAlbumAssetEntity
     } else if (isInserting) {
       context.missing(_albumIdMeta);
     }
+    if (data.containsKey('marker')) {
+      context.handle(
+        _marker_Meta,
+        marker_.isAcceptableOrUnknown(data['marker']!, _marker_Meta),
+      );
+    }
     return context;
   }
 
@@ -527,6 +568,10 @@ class $LocalAlbumAssetEntityTable extends i2.LocalAlbumAssetEntity
         i0.DriftSqlType.string,
         data['${effectivePrefix}album_id'],
       )!,
+      marker_: attachedDatabase.typeMapping.read(
+        i0.DriftSqlType.bool,
+        data['${effectivePrefix}marker'],
+      ),
     );
   }
 
@@ -545,15 +590,20 @@ class LocalAlbumAssetEntityData extends i0.DataClass
     implements i0.Insertable<i1.LocalAlbumAssetEntityData> {
   final String assetId;
   final String albumId;
+  final bool? marker_;
   const LocalAlbumAssetEntityData({
     required this.assetId,
     required this.albumId,
+    this.marker_,
   });
   @override
   Map<String, i0.Expression> toColumns(bool nullToAbsent) {
     final map = <String, i0.Expression>{};
     map['asset_id'] = i0.Variable<String>(assetId);
     map['album_id'] = i0.Variable<String>(albumId);
+    if (!nullToAbsent || marker_ != null) {
+      map['marker'] = i0.Variable<bool>(marker_);
+    }
     return map;
   }
 
@@ -565,6 +615,7 @@ class LocalAlbumAssetEntityData extends i0.DataClass
     return LocalAlbumAssetEntityData(
       assetId: serializer.fromJson<String>(json['assetId']),
       albumId: serializer.fromJson<String>(json['albumId']),
+      marker_: serializer.fromJson<bool?>(json['marker_']),
     );
   }
   @override
@@ -573,20 +624,26 @@ class LocalAlbumAssetEntityData extends i0.DataClass
     return <String, dynamic>{
       'assetId': serializer.toJson<String>(assetId),
       'albumId': serializer.toJson<String>(albumId),
+      'marker_': serializer.toJson<bool?>(marker_),
     };
   }
 
-  i1.LocalAlbumAssetEntityData copyWith({String? assetId, String? albumId}) =>
-      i1.LocalAlbumAssetEntityData(
-        assetId: assetId ?? this.assetId,
-        albumId: albumId ?? this.albumId,
-      );
+  i1.LocalAlbumAssetEntityData copyWith({
+    String? assetId,
+    String? albumId,
+    i0.Value<bool?> marker_ = const i0.Value.absent(),
+  }) => i1.LocalAlbumAssetEntityData(
+    assetId: assetId ?? this.assetId,
+    albumId: albumId ?? this.albumId,
+    marker_: marker_.present ? marker_.value : this.marker_,
+  );
   LocalAlbumAssetEntityData copyWithCompanion(
     i1.LocalAlbumAssetEntityCompanion data,
   ) {
     return LocalAlbumAssetEntityData(
       assetId: data.assetId.present ? data.assetId.value : this.assetId,
       albumId: data.albumId.present ? data.albumId.value : this.albumId,
+      marker_: data.marker_.present ? data.marker_.value : this.marker_,
     );
   }
 
@@ -594,51 +651,60 @@ class LocalAlbumAssetEntityData extends i0.DataClass
   String toString() {
     return (StringBuffer('LocalAlbumAssetEntityData(')
           ..write('assetId: $assetId, ')
-          ..write('albumId: $albumId')
+          ..write('albumId: $albumId, ')
+          ..write('marker_: $marker_')
           ..write(')'))
         .toString();
   }
 
   @override
-  int get hashCode => Object.hash(assetId, albumId);
+  int get hashCode => Object.hash(assetId, albumId, marker_);
   @override
   bool operator ==(Object other) =>
       identical(this, other) ||
       (other is i1.LocalAlbumAssetEntityData &&
           other.assetId == this.assetId &&
-          other.albumId == this.albumId);
+          other.albumId == this.albumId &&
+          other.marker_ == this.marker_);
 }
 
 class LocalAlbumAssetEntityCompanion
     extends i0.UpdateCompanion<i1.LocalAlbumAssetEntityData> {
   final i0.Value<String> assetId;
   final i0.Value<String> albumId;
+  final i0.Value<bool?> marker_;
   const LocalAlbumAssetEntityCompanion({
     this.assetId = const i0.Value.absent(),
     this.albumId = const i0.Value.absent(),
+    this.marker_ = const i0.Value.absent(),
   });
   LocalAlbumAssetEntityCompanion.insert({
     required String assetId,
     required String albumId,
+    this.marker_ = const i0.Value.absent(),
   }) : assetId = i0.Value(assetId),
        albumId = i0.Value(albumId);
   static i0.Insertable<i1.LocalAlbumAssetEntityData> custom({
     i0.Expression<String>? assetId,
     i0.Expression<String>? albumId,
+    i0.Expression<bool>? marker_,
   }) {
     return i0.RawValuesInsertable({
       if (assetId != null) 'asset_id': assetId,
       if (albumId != null) 'album_id': albumId,
+      if (marker_ != null) 'marker': marker_,
     });
   }
 
   i1.LocalAlbumAssetEntityCompanion copyWith({
     i0.Value<String>? assetId,
     i0.Value<String>? albumId,
+    i0.Value<bool?>? marker_,
   }) {
     return i1.LocalAlbumAssetEntityCompanion(
       assetId: assetId ?? this.assetId,
       albumId: albumId ?? this.albumId,
+      marker_: marker_ ?? this.marker_,
     );
   }
 
@@ -651,6 +717,9 @@ class LocalAlbumAssetEntityCompanion
     if (albumId.present) {
       map['album_id'] = i0.Variable<String>(albumId.value);
     }
+    if (marker_.present) {
+      map['marker'] = i0.Variable<bool>(marker_.value);
+    }
     return map;
   }
 
@@ -658,7 +727,8 @@ class LocalAlbumAssetEntityCompanion
   String toString() {
     return (StringBuffer('LocalAlbumAssetEntityCompanion(')
           ..write('assetId: $assetId, ')
-          ..write('albumId: $albumId')
+          ..write('albumId: $albumId, ')
+          ..write('marker_: $marker_')
           ..write(')'))
         .toString();
   }

mobile/lib/infrastructure/repositories/backup.repository.dart

@@ -29,82 +29,56 @@ class DriftBackupRepository extends DriftDatabaseRepository {
       ..where(_db.localAlbumEntity.backupSelection.equalsValue(BackupSelection.excluded));
   }
 
-  Future<int> getTotalCount() async {
-    final query = _db.localAlbumAssetEntity.selectOnly(distinct: true)
-      ..addColumns([_db.localAlbumAssetEntity.assetId])
-      ..join([
-        innerJoin(
-          _db.localAlbumEntity,
-          _db.localAlbumAssetEntity.albumId.equalsExp(_db.localAlbumEntity.id),
-          useColumns: false,
-        ),
-      ])
-      ..where(
-        _db.localAlbumEntity.backupSelection.equalsValue(BackupSelection.selected) &
-            _db.localAlbumAssetEntity.assetId.isNotInQuery(_getExcludedSubquery()),
-      );
+  /// Returns all backup-related counts in a single query.
+  ///
+  /// - total:     number of distinct assets in selected albums, excluding those that are also in excluded albums
+  /// - backup:    number of those assets that already exist on the server for [userId]
+  /// - remainder: number of those assets that do not yet exist on the server for [userId]
+  ///              (includes processing)
+  /// - processing: number of those assets that are still preparing/have a null checksum
+  Future<({int total, int remainder, int processing})> getAllCounts(String userId) async {
+    const sql = '''
+        SELECT
+        COUNT(*) AS total_count,
+        COUNT(*) FILTER (WHERE lae.checksum IS NULL) AS processing_count,
+        COUNT(*) FILTER (WHERE rae.id IS NULL) AS remainder_count
+        FROM local_asset_entity lae
+        LEFT JOIN main.remote_asset_entity rae
+            ON lae.checksum = rae.checksum AND rae.owner_id = ?1
+        WHERE EXISTS (
+            SELECT 1
+            FROM local_album_asset_entity laa
+            INNER JOIN main.local_album_entity la on laa.album_id = la.id
+            WHERE laa.asset_id = lae.id
+                AND la.backup_selection = ?2
+        )
+        AND NOT EXISTS (
+            SELECT 1
+            FROM local_album_asset_entity laa
+            INNER JOIN main.local_album_entity la on laa.album_id = la.id
+            WHERE laa.asset_id = lae.id
+                AND la.backup_selection = ?3
+        );
+      ''';
 
-    return query.get().then((rows) => rows.length);
-  }
+    final row = await _db
+        .customSelect(
+          sql,
+          variables: [
+            Variable.withString(userId),
+            Variable.withInt(BackupSelection.selected.index),
+            Variable.withInt(BackupSelection.excluded.index),
+          ],
+          readsFrom: {_db.localAlbumAssetEntity, _db.localAlbumEntity, _db.localAssetEntity, _db.remoteAssetEntity},
+        )
+        .getSingle();
 
-  Future<int> getRemainderCount(String userId) async {
-    final query = _db.localAlbumAssetEntity.selectOnly(distinct: true)
-      ..addColumns([_db.localAlbumAssetEntity.assetId])
-      ..join([
-        innerJoin(
-          _db.localAlbumEntity,
-          _db.localAlbumAssetEntity.albumId.equalsExp(_db.localAlbumEntity.id),
-          useColumns: false,
-        ),
-        innerJoin(
-          _db.localAssetEntity,
-          _db.localAlbumAssetEntity.assetId.equalsExp(_db.localAssetEntity.id),
-          useColumns: false,
-        ),
-        leftOuterJoin(
-          _db.remoteAssetEntity,
-          _db.localAssetEntity.checksum.equalsExp(_db.remoteAssetEntity.checksum) &
-              _db.remoteAssetEntity.ownerId.equals(userId),
-          useColumns: false,
-        ),
-      ])
-      ..where(
-        _db.localAlbumEntity.backupSelection.equalsValue(BackupSelection.selected) &
-            _db.remoteAssetEntity.id.isNull() &
-            _db.localAlbumAssetEntity.assetId.isNotInQuery(_getExcludedSubquery()),
-      );
-
-    return query.get().then((rows) => rows.length);
-  }
-
-  Future<int> getBackupCount(String userId) async {
-    final query = _db.localAlbumAssetEntity.selectOnly(distinct: true)
-      ..addColumns([_db.localAlbumAssetEntity.assetId])
-      ..join([
-        innerJoin(
-          _db.localAlbumEntity,
-          _db.localAlbumAssetEntity.albumId.equalsExp(_db.localAlbumEntity.id),
-          useColumns: false,
-        ),
-        innerJoin(
-          _db.localAssetEntity,
-          _db.localAlbumAssetEntity.assetId.equalsExp(_db.localAssetEntity.id),
-          useColumns: false,
-        ),
-        innerJoin(
-          _db.remoteAssetEntity,
-          _db.localAssetEntity.checksum.equalsExp(_db.remoteAssetEntity.checksum),
-          useColumns: false,
-        ),
-      ])
-      ..where(
-        _db.localAlbumEntity.backupSelection.equalsValue(BackupSelection.selected) &
-            _db.remoteAssetEntity.id.isNotNull() &
-            _db.remoteAssetEntity.ownerId.equals(userId) &
-            _db.localAlbumAssetEntity.assetId.isNotInQuery(_getExcludedSubquery()),
-      );
-
-    return query.get().then((rows) => rows.length);
+    final data = row.data;
+    return (
+      total: (data['total_count'] as int?) ?? 0,
+      remainder: (data['remainder_count'] as int?) ?? 0,
+      processing: (data['processing_count'] as int?) ?? 0,
+    );
   }
 
   Future<List<LocalAsset>> getCandidates(String userId) async {

mobile/lib/infrastructure/repositories/db.repository.dart

@@ -93,7 +93,7 @@ class Drift extends $Drift implements IDatabaseRepository {
   }
 
   @override
-  int get schemaVersion => 10;
+  int get schemaVersion => 11;
 
   @override
   MigrationStrategy get migration => MigrationStrategy(
@@ -156,6 +156,9 @@ class Drift extends $Drift implements IDatabaseRepository {
             await m.addColumn(v10.userEntity, v10.userEntity.avatarColor);
             await m.alterTable(TableMigration(v10.userEntity));
           },
+          from10To11: (m, v11) async {
+            await m.addColumn(v11.localAlbumAssetEntity, v11.localAlbumAssetEntity.marker_);
+          },
         ),
       );
 

mobile/lib/infrastructure/repositories/db.repository.steps.dart

@@ -4270,6 +4270,395 @@ i1.GeneratedColumn<String> _column_94(String aliasedName) =>
       true,
       type: i1.DriftSqlType.string,
     );
+
+final class Schema11 extends i0.VersionedSchema {
+  Schema11({required super.database}) : super(version: 11);
+  @override
+  late final List<i1.DatabaseSchemaEntity> entities = [
+    userEntity,
+    remoteAssetEntity,
+    stackEntity,
+    localAssetEntity,
+    remoteAlbumEntity,
+    localAlbumEntity,
+    localAlbumAssetEntity,
+    idxLocalAssetChecksum,
+    idxRemoteAssetOwnerChecksum,
+    uQRemoteAssetsOwnerChecksum,
+    uQRemoteAssetsOwnerLibraryChecksum,
+    idxRemoteAssetChecksum,
+    authUserEntity,
+    userMetadataEntity,
+    partnerEntity,
+    remoteExifEntity,
+    remoteAlbumAssetEntity,
+    remoteAlbumUserEntity,
+    memoryEntity,
+    memoryAssetEntity,
+    personEntity,
+    assetFaceEntity,
+    storeEntity,
+    idxLatLng,
+  ];
+  late final Shape20 userEntity = Shape20(
+    source: i0.VersionedTable(
+      entityName: 'user_entity',
+      withoutRowId: true,
+      isStrict: true,
+      tableConstraints: ['PRIMARY KEY(id)'],
+      columns: [
+        _column_0,
+        _column_1,
+        _column_3,
+        _column_84,
+        _column_85,
+        _column_91,
+      ],
+      attachedDatabase: database,
+    ),
+    alias: null,
+  );
+  late final Shape17 remoteAssetEntity = Shape17(
+    source: i0.VersionedTable(
+      entityName: 'remote_asset_entity',
+      withoutRowId: true,
+      isStrict: true,
+      tableConstraints: ['PRIMARY KEY(id)'],
+      columns: [
+        _column_1,
+        _column_8,
+        _column_9,
+        _column_5,
+        _column_10,
+        _column_11,
+        _column_12,
+        _column_0,
+        _column_13,
+        _column_14,
+        _column_15,
+        _column_16,
+        _column_17,
+        _column_18,
+        _column_19,
+        _column_20,
+        _column_21,
+        _column_86,
+      ],
+      attachedDatabase: database,
+    ),
+    alias: null,
+  );
+  late final Shape3 stackEntity = Shape3(
+    source: i0.VersionedTable(
+      entityName: 'stack_entity',
+      withoutRowId: true,
+      isStrict: true,
+      tableConstraints: ['PRIMARY KEY(id)'],
+      columns: [_column_0, _column_9, _column_5, _column_15, _column_75],
+      attachedDatabase: database,
+    ),
+    alias: null,
+  );
+  late final Shape2 localAssetEntity = Shape2(
+    source: i0.VersionedTable(
+      entityName: 'local_asset_entity',
+      withoutRowId: true,
+      isStrict: true,
+      tableConstraints: ['PRIMARY KEY(id)'],
+      columns: [
+        _column_1,
+        _column_8,
+        _column_9,
+        _column_5,
+        _column_10,
+        _column_11,
+        _column_12,
+        _column_0,
+        _column_22,
+        _column_14,
+        _column_23,
+      ],
+      attachedDatabase: database,
+    ),
+    alias: null,
+  );
+  late final Shape9 remoteAlbumEntity = Shape9(
+    source: i0.VersionedTable(
+      entityName: 'remote_album_entity',
+      withoutRowId: true,
+      isStrict: true,
+      tableConstraints: ['PRIMARY KEY(id)'],
+      columns: [
+        _column_0,
+        _column_1,
+        _column_56,
+        _column_9,
+        _column_5,
+        _column_15,
+        _column_57,
+        _column_58,
+        _column_59,
+      ],
+      attachedDatabase: database,
+    ),
+    alias: null,
+  );
+  late final Shape19 localAlbumEntity = Shape19(
+    source: i0.VersionedTable(
+      entityName: 'local_album_entity',
+      withoutRowId: true,
+      isStrict: true,
+      tableConstraints: ['PRIMARY KEY(id)'],
+      columns: [
+        _column_0,
+        _column_1,
+        _column_5,
+        _column_31,
+        _column_32,
+        _column_90,
+        _column_33,
+      ],
+      attachedDatabase: database,
+    ),
+    alias: null,
+  );
+  late final Shape22 localAlbumAssetEntity = Shape22(
+    source: i0.VersionedTable(
+      entityName: 'local_album_asset_entity',
+      withoutRowId: true,
+      isStrict: true,
+      tableConstraints: ['PRIMARY KEY(asset_id, album_id)'],
+      columns: [_column_34, _column_35, _column_33],
+      attachedDatabase: database,
+    ),
+    alias: null,
+  );
+  final i1.Index idxLocalAssetChecksum = i1.Index(
+    'idx_local_asset_checksum',
+    'CREATE INDEX IF NOT EXISTS idx_local_asset_checksum ON local_asset_entity (checksum)',
+  );
+  final i1.Index idxRemoteAssetOwnerChecksum = i1.Index(
+    'idx_remote_asset_owner_checksum',
+    'CREATE INDEX IF NOT EXISTS idx_remote_asset_owner_checksum ON remote_asset_entity (owner_id, checksum)',
+  );
+  final i1.Index uQRemoteAssetsOwnerChecksum = i1.Index(
+    'UQ_remote_assets_owner_checksum',
+    'CREATE UNIQUE INDEX IF NOT EXISTS UQ_remote_assets_owner_checksum ON remote_asset_entity (owner_id, checksum) WHERE(library_id IS NULL)',
+  );
+  final i1.Index uQRemoteAssetsOwnerLibraryChecksum = i1.Index(
+    'UQ_remote_assets_owner_library_checksum',
+    'CREATE UNIQUE INDEX IF NOT EXISTS UQ_remote_assets_owner_library_checksum ON remote_asset_entity (owner_id, library_id, checksum) WHERE(library_id IS NOT NULL)',
+  );
+  final i1.Index idxRemoteAssetChecksum = i1.Index(
+    'idx_remote_asset_checksum',
+    'CREATE INDEX IF NOT EXISTS idx_remote_asset_checksum ON remote_asset_entity (checksum)',
+  );
+  late final Shape21 authUserEntity = Shape21(
+    source: i0.VersionedTable(
+      entityName: 'auth_user_entity',
+      withoutRowId: true,
+      isStrict: true,
+      tableConstraints: ['PRIMARY KEY(id)'],
+      columns: [
+        _column_0,
+        _column_1,
+        _column_3,
+        _column_2,
+        _column_84,
+        _column_85,
+        _column_92,
+        _column_93,
+        _column_7,
+        _column_94,
+      ],
+      attachedDatabase: database,
+    ),
+    alias: null,
+  );
+  late final Shape4 userMetadataEntity = Shape4(
+    source: i0.VersionedTable(
+      entityName: 'user_metadata_entity',
+      withoutRowId: true,
+      isStrict: true,
+      tableConstraints: ['PRIMARY KEY(user_id, "key")'],
+      columns: [_column_25, _column_26, _column_27],
+      attachedDatabase: database,
+    ),
+    alias: null,
+  );
+  late final Shape5 partnerEntity = Shape5(
+    source: i0.VersionedTable(
+      entityName: 'partner_entity',
+      withoutRowId: true,
+      isStrict: true,
+      tableConstraints: ['PRIMARY KEY(shared_by_id, shared_with_id)'],
+      columns: [_column_28, _column_29, _column_30],
+      attachedDatabase: database,
+    ),
+    alias: null,
+  );
+  late final Shape8 remoteExifEntity = Shape8(
+    source: i0.VersionedTable(
+      entityName: 'remote_exif_entity',
+      withoutRowId: true,
+      isStrict: true,
+      tableConstraints: ['PRIMARY KEY(asset_id)'],
+      columns: [
+        _column_36,
+        _column_37,
+        _column_38,
+        _column_39,
+        _column_40,
+        _column_41,
+        _column_11,
+        _column_10,
+        _column_42,
+        _column_43,
+        _column_44,
+        _column_45,
+        _column_46,
+        _column_47,
+        _column_48,
+        _column_49,
+        _column_50,
+        _column_51,
+        _column_52,
+        _column_53,
+        _column_54,
+        _column_55,
+      ],
+      attachedDatabase: database,
+    ),
+    alias: null,
+  );
+  late final Shape7 remoteAlbumAssetEntity = Shape7(
+    source: i0.VersionedTable(
+      entityName: 'remote_album_asset_entity',
+      withoutRowId: true,
+      isStrict: true,
+      tableConstraints: ['PRIMARY KEY(asset_id, album_id)'],
+      columns: [_column_36, _column_60],
+      attachedDatabase: database,
+    ),
+    alias: null,
+  );
+  late final Shape10 remoteAlbumUserEntity = Shape10(
+    source: i0.VersionedTable(
+      entityName: 'remote_album_user_entity',
+      withoutRowId: true,
+      isStrict: true,
+      tableConstraints: ['PRIMARY KEY(album_id, user_id)'],
+      columns: [_column_60, _column_25, _column_61],
+      attachedDatabase: database,
+    ),
+    alias: null,
+  );
+  late final Shape11 memoryEntity = Shape11(
+    source: i0.VersionedTable(
+      entityName: 'memory_entity',
+      withoutRowId: true,
+      isStrict: true,
+      tableConstraints: ['PRIMARY KEY(id)'],
+      columns: [
+        _column_0,
+        _column_9,
+        _column_5,
+        _column_18,
+        _column_15,
+        _column_8,
+        _column_62,
+        _column_63,
+        _column_64,
+        _column_65,
+        _column_66,
+        _column_67,
+      ],
+      attachedDatabase: database,
+    ),
+    alias: null,
+  );
+  late final Shape12 memoryAssetEntity = Shape12(
+    source: i0.VersionedTable(
+      entityName: 'memory_asset_entity',
+      withoutRowId: true,
+      isStrict: true,
+      tableConstraints: ['PRIMARY KEY(asset_id, memory_id)'],
+      columns: [_column_36, _column_68],
+      attachedDatabase: database,
+    ),
+    alias: null,
+  );
+  late final Shape14 personEntity = Shape14(
+    source: i0.VersionedTable(
+      entityName: 'person_entity',
+      withoutRowId: true,
+      isStrict: true,
+      tableConstraints: ['PRIMARY KEY(id)'],
+      columns: [
+        _column_0,
+        _column_9,
+        _column_5,
+        _column_15,
+        _column_1,
+        _column_69,
+        _column_71,
+        _column_72,
+        _column_73,
+        _column_74,
+      ],
+      attachedDatabase: database,
+    ),
+    alias: null,
+  );
+  late final Shape15 assetFaceEntity = Shape15(
+    source: i0.VersionedTable(
+      entityName: 'asset_face_entity',
+      withoutRowId: true,
+      isStrict: true,
+      tableConstraints: ['PRIMARY KEY(id)'],
+      columns: [
+        _column_0,
+        _column_36,
+        _column_76,
+        _column_77,
+        _column_78,
+        _column_79,
+        _column_80,
+        _column_81,
+        _column_82,
+        _column_83,
+      ],
+      attachedDatabase: database,
+    ),
+    alias: null,
+  );
+  late final Shape18 storeEntity = Shape18(
+    source: i0.VersionedTable(
+      entityName: 'store_entity',
+      withoutRowId: true,
+      isStrict: true,
+      tableConstraints: ['PRIMARY KEY(id)'],
+      columns: [_column_87, _column_88, _column_89],
+      attachedDatabase: database,
+    ),
+    alias: null,
+  );
+  final i1.Index idxLatLng = i1.Index(
+    'idx_lat_lng',
+    'CREATE INDEX IF NOT EXISTS idx_lat_lng ON remote_exif_entity (latitude, longitude)',
+  );
+}
+
+class Shape22 extends i0.VersionedTable {
+  Shape22({required super.source, required super.alias}) : super.aliased();
+  i1.GeneratedColumn<String> get assetId =>
+      columnsByName['asset_id']! as i1.GeneratedColumn<String>;
+  i1.GeneratedColumn<String> get albumId =>
+      columnsByName['album_id']! as i1.GeneratedColumn<String>;
+  i1.GeneratedColumn<bool> get marker_ =>
+      columnsByName['marker']! as i1.GeneratedColumn<bool>;
+}
+
 i0.MigrationStepWithVersion migrationSteps({
   required Future<void> Function(i1.Migrator m, Schema2 schema) from1To2,
   required Future<void> Function(i1.Migrator m, Schema3 schema) from2To3,
@@ -4280,6 +4669,7 @@ i0.MigrationStepWithVersion migrationSteps({
   required Future<void> Function(i1.Migrator m, Schema8 schema) from7To8,
   required Future<void> Function(i1.Migrator m, Schema9 schema) from8To9,
   required Future<void> Function(i1.Migrator m, Schema10 schema) from9To10,
+  required Future<void> Function(i1.Migrator m, Schema11 schema) from10To11,
 }) {
   return (currentVersion, database) async {
     switch (currentVersion) {
@@ -4328,6 +4718,11 @@ i0.MigrationStepWithVersion migrationSteps({
         final migrator = i1.Migrator(database, schema);
         await from9To10(migrator, schema);
         return 10;
+      case 10:
+        final schema = Schema11(database: database);
+        final migrator = i1.Migrator(database, schema);
+        await from10To11(migrator, schema);
+        return 11;
       default:
         throw ArgumentError.value('Unknown migration from $currentVersion');
     }
@@ -4344,6 +4739,7 @@ i1.OnUpgrade stepByStep({
   required Future<void> Function(i1.Migrator m, Schema8 schema) from7To8,
   required Future<void> Function(i1.Migrator m, Schema9 schema) from8To9,
   required Future<void> Function(i1.Migrator m, Schema10 schema) from9To10,
+  required Future<void> Function(i1.Migrator m, Schema11 schema) from10To11,
 }) => i0.VersionedSchema.stepByStepHelper(
   step: migrationSteps(
     from1To2: from1To2,
@@ -4355,5 +4751,6 @@ i1.OnUpgrade stepByStep({
     from7To8: from7To8,
     from8To9: from8To9,
     from9To10: from9To10,
+    from10To11: from10To11,
   ),
 );

mobile/lib/infrastructure/repositories/local_album.repository.dart

@@ -72,17 +72,33 @@ class DriftLocalAlbumRepository extends DriftDatabaseRepository {
       return Future.value();
     }
 
-    final deleteSmt = _db.localAssetEntity.delete();
-    deleteSmt.where((localAsset) {
-      final subQuery = _db.localAlbumAssetEntity.selectOnly()
-        ..addColumns([_db.localAlbumAssetEntity.assetId])
-        ..join([innerJoin(_db.localAlbumEntity, _db.localAlbumAssetEntity.albumId.equalsExp(_db.localAlbumEntity.id))]);
-      subQuery.where(
-        _db.localAlbumEntity.id.equals(albumId) & _db.localAlbumAssetEntity.assetId.isNotIn(assetIdsToKeep),
-      );
-      return localAsset.id.isInQuery(subQuery);
+    return _db.transaction(() async {
+      await _db.managers.localAlbumAssetEntity
+          .filter((row) => row.albumId.id.equals(albumId))
+          .update((album) => album(marker_: const Value(true)));
+
+      await _db.batch((batch) {
+        for (final assetId in assetIdsToKeep) {
+          batch.update(
+            _db.localAlbumAssetEntity,
+            const LocalAlbumAssetEntityCompanion(marker_: Value(null)),
+            where: (row) => row.assetId.equals(assetId) & row.albumId.equals(albumId),
+          );
+        }
+      });
+
+      final query = _db.localAssetEntity.delete()
+        ..where(
+          (row) => row.id.isInQuery(
+            _db.localAlbumAssetEntity.selectOnly()
+              ..addColumns([_db.localAlbumAssetEntity.assetId])
+              ..where(
+                _db.localAlbumAssetEntity.albumId.equals(albumId) & _db.localAlbumAssetEntity.marker_.isNotNull(),
+              ),
+          ),
+        );
+      await query.go();
     });
-    await deleteSmt.go();
   }
 
   Future<void> upsert(
@@ -198,10 +214,9 @@ class DriftLocalAlbumRepository extends DriftDatabaseRepository {
       // List<String>
       await _db.batch((batch) async {
         assetAlbums.cast<String, List<Object?>>().forEach((assetId, albumIds) {
-          batch.deleteWhere(
-            _db.localAlbumAssetEntity,
-            (f) => f.albumId.isNotIn(albumIds.cast<String?>().nonNulls) & f.assetId.equals(assetId),
-          );
+          for (final albumId in albumIds.cast<String?>().nonNulls) {
+            batch.deleteWhere(_db.localAlbumAssetEntity, (f) => f.albumId.equals(albumId) & f.assetId.equals(assetId));
+          }
         });
       });
       await _db.batch((batch) async {
@@ -288,12 +303,14 @@ class DriftLocalAlbumRepository extends DriftDatabaseRepository {
 
     return transaction(() async {
       if (assetsToUnLink.isNotEmpty) {
-        await _db.batch(
-          (batch) => batch.deleteWhere(
-            _db.localAlbumAssetEntity,
-            (f) => f.assetId.isIn(assetsToUnLink) & f.albumId.equals(albumId),
-          ),
-        );
+        await _db.batch((batch) {
+          for (final assetId in assetsToUnLink) {
+            batch.deleteWhere(
+              _db.localAlbumAssetEntity,
+              (row) => row.assetId.equals(assetId) & row.albumId.equals(albumId),
+            );
+          }
+        });
       }
 
       await _deleteAssets(assetsToDelete);
@@ -320,7 +337,9 @@ class DriftLocalAlbumRepository extends DriftDatabaseRepository {
     }
 
     return _db.batch((batch) {
-      batch.deleteWhere(_db.localAssetEntity, (f) => f.id.isIn(ids));
+      for (final id in ids) {
+        batch.deleteWhere(_db.localAssetEntity, (row) => row.id.equals(id));
+      }
     });
   }
 

mobile/lib/infrastructure/repositories/local_asset.repository.dart

@@ -1,4 +1,3 @@
-import 'package:collection/collection.dart';
 import 'package:drift/drift.dart';
 import 'package:immich_mobile/domain/models/album/local_album.model.dart';
 import 'package:immich_mobile/domain/models/asset/base_asset.model.dart';
@@ -36,17 +35,17 @@ class DriftLocalAssetRepository extends DriftDatabaseRepository {
 
   Stream<LocalAsset?> watch(String id) => _assetSelectable(id).watchSingleOrNull();
 
-  Future<void> updateHashes(Iterable<LocalAsset> hashes) {
+  Future<void> updateHashes(Map<String, String> hashes) {
     if (hashes.isEmpty) {
       return Future.value();
     }
 
     return _db.batch((batch) async {
-      for (final asset in hashes) {
+      for (final entry in hashes.entries) {
         batch.update(
           _db.localAssetEntity,
-          LocalAssetEntityCompanion(checksum: Value(asset.checksum)),
-          where: (e) => e.id.equals(asset.id),
+          LocalAssetEntityCompanion(checksum: Value(entry.value)),
+          where: (e) => e.id.equals(entry.key),
         );
       }
     });
@@ -58,8 +57,8 @@ class DriftLocalAssetRepository extends DriftDatabaseRepository {
     }
 
     return _db.batch((batch) {
-      for (final slice in ids.slices(32000)) {
-        batch.deleteWhere(_db.localAssetEntity, (e) => e.id.isIn(slice));
+      for (final id in ids) {
+        batch.deleteWhere(_db.localAssetEntity, (e) => e.id.equals(id));
       }
     });
   }

mobile/lib/infrastructure/repositories/remote_album.repository.dart

@@ -166,8 +166,15 @@ class DriftRemoteAlbumRepository extends DriftDatabaseRepository {
     );
   }
 
-  Future<int> removeAssets(String albumId, List<String> assetIds) {
-    return _db.remoteAlbumAssetEntity.deleteWhere((tbl) => tbl.albumId.equals(albumId) & tbl.assetId.isIn(assetIds));
+  Future<void> removeAssets(String albumId, List<String> assetIds) {
+    return _db.batch((batch) {
+      for (final assetId in assetIds) {
+        batch.deleteWhere(
+          _db.remoteAlbumAssetEntity,
+          (row) => row.albumId.equals(albumId) & row.assetId.equals(assetId),
+        );
+      }
+    });
   }
 
   FutureOr<(DateTime, DateTime)> getDateRange(String albumId) {

mobile/lib/infrastructure/repositories/remote_asset.repository.dart

@@ -62,12 +62,13 @@ class RemoteAssetRepository extends DriftDatabaseRepository {
   }
 
   Future<List<RemoteAsset>> getStackChildren(RemoteAsset asset) {
-    if (asset.stackId == null) {
-      return Future.value([]);
+    final stackId = asset.stackId;
+    if (stackId == null) {
+      return Future.value(const []);
     }
 
     final query = _db.remoteAssetEntity.select()
-      ..where((row) => row.stackId.equals(asset.stackId!) & row.id.equals(asset.id).not())
+      ..where((row) => row.stackId.equals(stackId) & row.id.equals(asset.id).not())
       ..orderBy([(row) => OrderingTerm.desc(row.createdAt)]);
 
     return query.map((row) => row.toDto()).get();
@@ -159,7 +160,11 @@ class RemoteAssetRepository extends DriftDatabaseRepository {
   }
 
   Future<void> delete(List<String> ids) {
-    return _db.remoteAssetEntity.deleteWhere((row) => row.id.isIn(ids));
+    return _db.batch((batch) {
+      for (final id in ids) {
+        batch.deleteWhere(_db.remoteAssetEntity, (row) => row.id.equals(id));
+      }
+    });
   }
 
   Future<void> updateLocation(List<String> ids, LatLng location) {
@@ -198,7 +203,11 @@ class RemoteAssetRepository extends DriftDatabaseRepository {
           .map((row) => row.id)
           .get();
 
-      await _db.stackEntity.deleteWhere((row) => row.id.isIn(stackIds));
+      await _db.batch((batch) {
+        for (final stackId in stackIds) {
+          batch.deleteWhere(_db.stackEntity, (row) => row.id.equals(stackId));
+        }
+      });
 
       await _db.batch((batch) {
         final companion = StackEntityCompanion(ownerId: Value(userId), primaryAssetId: Value(stack.primaryAssetId));
@@ -218,15 +227,21 @@ class RemoteAssetRepository extends DriftDatabaseRepository {
 
   Future<void> unStack(List<String> stackIds) {
     return _db.transaction(() async {
-      await _db.stackEntity.deleteWhere((row) => row.id.isIn(stackIds));
+      await _db.batch((batch) {
+        for (final stackId in stackIds) {
+          batch.deleteWhere(_db.stackEntity, (row) => row.id.equals(stackId));
+        }
+      });
 
       // TODO: delete this after adding foreign key on stackId
       await _db.batch((batch) {
-        batch.update(
-          _db.remoteAssetEntity,
-          const RemoteAssetEntityCompanion(stackId: Value(null)),
-          where: (e) => e.stackId.isIn(stackIds),
-        );
+        for (final stackId in stackIds) {
+          batch.update(
+            _db.remoteAssetEntity,
+            const RemoteAssetEntityCompanion(stackId: Value(null)),
+            where: (e) => e.stackId.equals(stackId),
+          );
+        }
       });
     });
   }

mobile/lib/infrastructure/repositories/search_api.repository.dart

@@ -33,7 +33,7 @@ class SearchApiRepository extends ApiRepository {
           personIds: filter.people.map((e) => e.id).toList(),
           type: type,
           page: page,
-          size: 1000,
+          size: 100,
         ),
       );
     }

mobile/lib/infrastructure/repositories/sync_stream.repository.dart

@@ -93,7 +93,11 @@ class SyncStreamRepository extends DriftDatabaseRepository {
 
   Future<void> deleteUsersV1(Iterable<SyncUserDeleteV1> data) async {
     try {
-      await _db.userEntity.deleteWhere((row) => row.id.isIn(data.map((e) => e.userId)));
+      await _db.batch((batch) {
+        for (final user in data) {
+          batch.deleteWhere(_db.userEntity, (row) => row.id.equals(user.userId));
+        }
+      });
     } catch (error, stack) {
       _logger.severe('Error: SyncUserDeleteV1', error, stack);
       rethrow;
@@ -158,7 +162,11 @@ class SyncStreamRepository extends DriftDatabaseRepository {
 
   Future<void> deleteAssetsV1(Iterable<SyncAssetDeleteV1> data, {String debugLabel = 'user'}) async {
     try {
-      await _db.remoteAssetEntity.deleteWhere((row) => row.id.isIn(data.map((e) => e.assetId)));
+      await _db.batch((batch) {
+        for (final asset in data) {
+          batch.deleteWhere(_db.remoteAssetEntity, (row) => row.id.equals(asset.assetId));
+        }
+      });
     } catch (error, stack) {
       _logger.severe('Error: deleteAssetsV1 - $debugLabel', error, stack);
       rethrow;
@@ -243,7 +251,11 @@ class SyncStreamRepository extends DriftDatabaseRepository {
 
   Future<void> deleteAlbumsV1(Iterable<SyncAlbumDeleteV1> data) async {
     try {
-      await _db.remoteAlbumEntity.deleteWhere((row) => row.id.isIn(data.map((e) => e.albumId)));
+      await _db.batch((batch) {
+        for (final album in data) {
+          batch.deleteWhere(_db.remoteAlbumEntity, (row) => row.id.equals(album.albumId));
+        }
+      });
     } catch (error, stack) {
       _logger.severe('Error: deleteAlbumsV1', error, stack);
       rethrow;
@@ -379,7 +391,11 @@ class SyncStreamRepository extends DriftDatabaseRepository {
 
   Future<void> deleteMemoriesV1(Iterable<SyncMemoryDeleteV1> data) async {
     try {
-      await _db.memoryEntity.deleteWhere((row) => row.id.isIn(data.map((e) => e.memoryId)));
+      await _db.batch((batch) {
+        for (final memory in data) {
+          batch.deleteWhere(_db.memoryEntity, (row) => row.id.equals(memory.memoryId));
+        }
+      });
     } catch (error, stack) {
       _logger.severe('Error: deleteMemoriesV1', error, stack);
       rethrow;
@@ -443,7 +459,11 @@ class SyncStreamRepository extends DriftDatabaseRepository {
 
   Future<void> deleteStacksV1(Iterable<SyncStackDeleteV1> data, {String debugLabel = 'user'}) async {
     try {
-      await _db.stackEntity.deleteWhere((row) => row.id.isIn(data.map((e) => e.stackId)));
+      await _db.batch((batch) {
+        for (final stack in data) {
+          batch.deleteWhere(_db.stackEntity, (row) => row.id.equals(stack.stackId));
+        }
+      });
     } catch (error, stack) {
       _logger.severe('Error: deleteStacksV1 - $debugLabel', error, stack);
       rethrow;

mobile/lib/main.dart

@@ -12,9 +12,11 @@ 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/domain/services/background_worker.service.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/platform/background_worker_lock_api.g.dart';
 import 'package:immich_mobile/providers/app_life_cycle.provider.dart';
 import 'package:immich_mobile/providers/asset_viewer/share_intent_upload.provider.dart';
 import 'package:immich_mobile/providers/db.provider.dart';
@@ -32,6 +34,7 @@ import 'package:immich_mobile/theme/dynamic_theme.dart';
 import 'package:immich_mobile/theme/theme_data.dart';
 import 'package:immich_mobile/utils/bootstrap.dart';
 import 'package:immich_mobile/utils/cache/widgets_binding.dart';
+import 'package:immich_mobile/utils/debug_print.dart';
 import 'package:immich_mobile/utils/http_ssl_options.dart';
 import 'package:immich_mobile/utils/licenses.dart';
 import 'package:immich_mobile/utils/migration.dart';
@@ -39,10 +42,10 @@ import 'package:intl/date_symbol_data_local.dart';
 import 'package:logging/logging.dart';
 import 'package:timezone/data/latest.dart';
 import 'package:worker_manager/worker_manager.dart';
-import 'package:immich_mobile/utils/debug_print.dart';
 
 void main() async {
   ImmichWidgetsBinding();
+  unawaited(BackgroundWorkerLockService(BackgroundWorkerLockApi()).lock());
   final (isar, drift, logDb) = await Bootstrap.initDB();
   await Bootstrap.initDomain(isar, drift, logDb);
   await initApp();

mobile/lib/pages/backup/drift_backup.page.dart

@@ -12,9 +12,13 @@ import 'package:immich_mobile/presentation/widgets/backup/backup_toggle_button.w
 import 'package:immich_mobile/providers/background_sync.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/sync_status.provider.dart';
 import 'package:immich_mobile/providers/user.provider.dart';
 import 'package:immich_mobile/routing/router.dart';
 import 'package:immich_mobile/widgets/backup/backup_info_card.dart';
+import 'dart:async';
+
+import 'package:wakelock_plus/wakelock_plus.dart';
 
 @RoutePage()
 class DriftBackupPage extends ConsumerStatefulWidget {
@@ -28,12 +32,28 @@ class _DriftBackupPageState extends ConsumerState<DriftBackupPage> {
   @override
   void initState() {
     super.initState();
+
+    WakelockPlus.enable();
+
     final currentUser = ref.read(currentUserProvider);
     if (currentUser == null) {
       return;
     }
 
-    ref.read(driftBackupProvider.notifier).getBackupStatus(currentUser.id);
+    WidgetsBinding.instance.addPostFrameCallback((_) async {
+      await ref.read(driftBackupProvider.notifier).getBackupStatus(currentUser.id);
+      await ref.read(backgroundSyncProvider).syncRemote();
+
+      if (mounted) {
+        await ref.read(driftBackupProvider.notifier).getBackupStatus(currentUser.id);
+      }
+    });
+  }
+
+  @override
+  dispose() {
+    super.dispose();
+    WakelockPlus.disable();
   }
 
   @override
@@ -44,7 +64,6 @@ class _DriftBackupPageState extends ConsumerState<DriftBackupPage> {
         .toList();
 
     final backupNotifier = ref.read(driftBackupProvider.notifier);
-    final backgroundManager = ref.read(backgroundSyncProvider);
 
     Future<void> startBackup() async {
       final currentUser = Store.tryGet(StoreKey.currentUser);
@@ -52,7 +71,6 @@ class _DriftBackupPageState extends ConsumerState<DriftBackupPage> {
         return;
       }
 
-      await backgroundManager.syncRemote();
       await backupNotifier.getBackupStatus(currentUser.id);
       await backupNotifier.startBackup(currentUser.id);
     }
@@ -235,11 +253,13 @@ class _BackupCard extends ConsumerWidget {
   @override
   Widget build(BuildContext context, WidgetRef ref) {
     final backupCount = ref.watch(driftBackupProvider.select((p) => p.backupCount));
+    final syncStatus = ref.watch(syncStatusProvider);
 
     return BackupInfoCard(
       title: "backup_controller_page_backup".tr(),
       subtitle: "backup_controller_page_backup_sub".tr(),
       info: backupCount.toString(),
+      isLoading: syncStatus.isRemoteSyncing,
     );
   }
 }
@@ -250,11 +270,207 @@ class _RemainderCard extends ConsumerWidget {
   @override
   Widget build(BuildContext context, WidgetRef ref) {
     final remainderCount = ref.watch(driftBackupProvider.select((p) => p.remainderCount));
-    return BackupInfoCard(
-      title: "backup_controller_page_remainder".tr(),
-      subtitle: "backup_controller_page_remainder_sub".tr(),
-      info: remainderCount.toString(),
-      onTap: () => context.pushRoute(const DriftBackupAssetDetailRoute()),
+    final syncStatus = ref.watch(syncStatusProvider);
+
+    return Card(
+      shape: RoundedRectangleBorder(
+        borderRadius: const BorderRadius.all(Radius.circular(20)),
+        side: BorderSide(color: context.colorScheme.outlineVariant, width: 1),
+      ),
+      elevation: 0,
+      borderOnForeground: false,
+      child: Column(
+        children: [
+          ListTile(
+            minVerticalPadding: 18,
+            isThreeLine: true,
+            title: Text("backup_controller_page_remainder".t(context: context), style: context.textTheme.titleMedium),
+            subtitle: Padding(
+              padding: const EdgeInsets.only(top: 4.0, right: 18.0),
+              child: Text(
+                "backup_controller_page_remainder_sub".t(context: context),
+                style: context.textTheme.bodyMedium?.copyWith(color: context.colorScheme.onSurfaceSecondary),
+              ),
+            ),
+            trailing: Column(
+              mainAxisAlignment: MainAxisAlignment.center,
+              children: [
+                Stack(
+                  children: [
+                    Text(
+                      remainderCount.toString(),
+                      style: context.textTheme.titleLarge?.copyWith(
+                        color: context.colorScheme.onSurface.withAlpha(syncStatus.isRemoteSyncing ? 50 : 255),
+                      ),
+                    ),
+                    if (syncStatus.isRemoteSyncing)
+                      Positioned.fill(
+                        child: Align(
+                          alignment: Alignment.center,
+                          child: SizedBox(
+                            width: 16,
+                            height: 16,
+                            child: CircularProgressIndicator(
+                              strokeWidth: 2,
+                              color: context.colorScheme.onSurface.withAlpha(150),
+                            ),
+                          ),
+                        ),
+                      ),
+                  ],
+                ),
+                Text(
+                  "backup_info_card_assets",
+                  style: context.textTheme.labelLarge?.copyWith(
+                    color: context.colorScheme.onSurface.withAlpha(syncStatus.isRemoteSyncing ? 50 : 255),
+                  ),
+                ).tr(),
+              ],
+            ),
+          ),
+          const Divider(height: 0),
+          const _PreparingStatus(),
+          const Divider(height: 0),
+
+          ListTile(
+            enableFeedback: true,
+            visualDensity: VisualDensity.compact,
+            contentPadding: const EdgeInsets.symmetric(horizontal: 16.0, vertical: 0.0),
+            shape: const RoundedRectangleBorder(
+              borderRadius: BorderRadius.only(bottomLeft: Radius.circular(20), bottomRight: Radius.circular(20)),
+            ),
+            onTap: () => context.pushRoute(const DriftBackupAssetDetailRoute()),
+            title: Text(
+              "view_details".t(context: context),
+              style: context.textTheme.labelLarge?.copyWith(color: context.colorScheme.onSurface.withAlpha(200)),
+            ),
+            trailing: Icon(Icons.arrow_forward_ios, size: 16, color: context.colorScheme.onSurfaceVariant),
+          ),
+        ],
+      ),
+    );
+  }
+}
+
+class _PreparingStatus extends ConsumerStatefulWidget {
+  const _PreparingStatus();
+
+  @override
+  _PreparingStatusState createState() => _PreparingStatusState();
+}
+
+class _PreparingStatusState extends ConsumerState {
+  Timer? _pollingTimer;
+
+  @override
+  void dispose() {
+    _pollingTimer?.cancel();
+    super.dispose();
+  }
+
+  void _startPollingIfNeeded() {
+    if (_pollingTimer != null) return;
+
+    _pollingTimer = Timer.periodic(const Duration(seconds: 3), (timer) async {
+      final currentUser = ref.read(currentUserProvider);
+      if (currentUser != null && mounted) {
+        await ref.read(driftBackupProvider.notifier).getBackupStatus(currentUser.id);
+
+        // Stop polling if processing count reaches 0
+        final updatedProcessingCount = ref.read(driftBackupProvider.select((p) => p.processingCount));
+        if (updatedProcessingCount == 0) {
+          timer.cancel();
+          _pollingTimer = null;
+        }
+      } else {
+        timer.cancel();
+        _pollingTimer = null;
+      }
+    });
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final syncStatus = ref.watch(syncStatusProvider);
+    final remainderCount = ref.watch(driftBackupProvider.select((p) => p.remainderCount));
+    final processingCount = ref.watch(driftBackupProvider.select((p) => p.processingCount));
+    final readyForUploadCount = remainderCount - processingCount;
+
+    ref.listen<int>(driftBackupProvider.select((p) => p.processingCount), (previous, next) {
+      if (next > 0 && _pollingTimer == null) {
+        _startPollingIfNeeded();
+      } else if (next == 0 && _pollingTimer != null) {
+        _pollingTimer?.cancel();
+        _pollingTimer = null;
+      }
+    });
+
+    if (!syncStatus.isHashing) {
+      return const SizedBox.shrink();
+    }
+
+    return Row(
+      children: [
+        Expanded(
+          child: Padding(
+            padding: const EdgeInsets.only(left: 1.0),
+            child: Container(
+              padding: const EdgeInsets.symmetric(horizontal: 16.0, vertical: 8),
+              decoration: BoxDecoration(
+                color: context.colorScheme.surfaceContainerHigh.withValues(alpha: 0.5),
+                shape: BoxShape.rectangle,
+              ),
+              child: Column(
+                crossAxisAlignment: CrossAxisAlignment.start,
+                children: [
+                  Row(
+                    children: [
+                      Text(
+                        "preparing".t(context: context),
+                        style: context.textTheme.labelLarge?.copyWith(
+                          color: context.colorScheme.onSurface.withAlpha(200),
+                        ),
+                      ),
+                      const SizedBox(width: 18, height: 18, child: CircularProgressIndicator(strokeWidth: 1.5)),
+                    ],
+                  ),
+                  const SizedBox(height: 2),
+                  Text(
+                    processingCount.toString(),
+                    style: context.textTheme.titleMedium?.copyWith(
+                      color: context.colorScheme.primary,
+                      fontWeight: FontWeight.w600,
+                    ),
+                  ),
+                ],
+              ),
+            ),
+          ),
+        ),
+        Expanded(
+          child: Container(
+            padding: const EdgeInsets.symmetric(horizontal: 16.0, vertical: 8),
+            decoration: BoxDecoration(color: context.colorScheme.primary.withValues(alpha: 0.1)),
+            child: Column(
+              crossAxisAlignment: CrossAxisAlignment.end,
+              children: [
+                Text(
+                  "ready_for_upload".t(context: context),
+                  style: context.textTheme.labelLarge?.copyWith(color: context.colorScheme.onSurface.withAlpha(200)),
+                ),
+                const SizedBox(height: 2),
+                Text(
+                  readyForUploadCount.toString(),
+                  style: context.textTheme.titleMedium?.copyWith(
+                    color: context.primaryColor,
+                    fontWeight: FontWeight.w600,
+                  ),
+                ),
+              ],
+            ),
+          ),
+        ),
+      ],
     );
   }
 }

mobile/lib/pages/backup/drift_backup_album_selection.page.dart

@@ -1,3 +1,4 @@
+import 'dart:async';
 import 'dart:io';
 
 import 'package:auto_route/auto_route.dart';
@@ -5,12 +6,14 @@ import 'package:easy_localization/easy_localization.dart';
 import 'package:flutter/material.dart';
 import 'package:hooks_riverpod/hooks_riverpod.dart';
 import 'package:immich_mobile/domain/models/album/local_album.model.dart';
+import 'package:immich_mobile/domain/services/sync_linked_album.service.dart';
 import 'package:immich_mobile/extensions/build_context_extensions.dart';
 import 'package:immich_mobile/extensions/translate_extensions.dart';
 import 'package:immich_mobile/providers/app_settings.provider.dart';
-import 'package:immich_mobile/domain/services/sync_linked_album.service.dart';
+import 'package:immich_mobile/providers/background_sync.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/infrastructure/platform.provider.dart';
 import 'package:immich_mobile/providers/user.provider.dart';
 import 'package:immich_mobile/services/app_settings.service.dart';
 import 'package:immich_mobile/widgets/backup/drift_album_info_list_tile.dart';
@@ -64,16 +67,6 @@ class _DriftBackupAlbumSelectionPageState extends ConsumerState<DriftBackupAlbum
       });
       await _handleLinkedAlbumFuture;
     }
-
-    // Restart backup if total count changed and backup is enabled
-    final currentTotalAssetCount = ref.read(driftBackupProvider.select((p) => p.totalCount));
-    final totalChanged = currentTotalAssetCount != _initialTotalAssetCount;
-    final isBackupEnabled = ref.read(appSettingsServiceProvider).getSetting(AppSettingsEnum.enableBackup);
-
-    if (totalChanged && isBackupEnabled) {
-      await ref.read(driftBackupProvider.notifier).cancel();
-      await ref.read(driftBackupProvider.notifier).startBackup(user.id);
-    }
   }
 
   @override
@@ -102,6 +95,27 @@ class _DriftBackupAlbumSelectionPageState extends ConsumerState<DriftBackupAlbum
       onPopInvokedWithResult: (didPop, _) async {
         if (!didPop) {
           await _handlePagePopped();
+
+          final user = ref.read(currentUserProvider);
+          if (user == null) {
+            return;
+          }
+
+          final isBackupEnabled = ref.read(appSettingsServiceProvider).getSetting(AppSettingsEnum.enableBackup);
+          await ref.read(driftBackupProvider.notifier).getBackupStatus(user.id);
+          final currentTotalAssetCount = ref.read(driftBackupProvider.select((p) => p.totalCount));
+          final totalChanged = currentTotalAssetCount != _initialTotalAssetCount;
+          final backupNotifier = ref.read(driftBackupProvider.notifier);
+          final backgroundSync = ref.read(backgroundSyncProvider);
+          final nativeSync = ref.read(nativeSyncApiProvider);
+          if (totalChanged) {
+            // Waits for hashing to be cancelled before starting a new one
+            unawaited(nativeSync.cancelHashing().whenComplete(() => backgroundSync.hashAssets()));
+            if (isBackupEnabled) {
+              unawaited(backupNotifier.cancel().whenComplete(() => backupNotifier.startBackup(user.id)));
+            }
+          }
+
           Navigator.of(context).pop();
         }
       },

mobile/lib/pages/common/splash_screen.page.dart

@@ -1,3 +1,5 @@
+import 'dart:async';
+
 import 'package:auto_route/auto_route.dart';
 import 'package:flutter/material.dart';
 import 'package:hooks_riverpod/hooks_riverpod.dart';

mobile/lib/platform/background_worker_lock_api.g.dart

@@ -0,0 +1,97 @@
+// 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".',
+  );
+}
+
+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 BackgroundWorkerLockApi {
+  /// Constructor for [BackgroundWorkerLockApi].  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.
+  BackgroundWorkerLockApi({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> lock() async {
+    final String pigeonVar_channelName =
+        'dev.flutter.pigeon.immich_mobile.BackgroundWorkerLockApi.lock$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> unlock() async {
+    final String pigeonVar_channelName =
+        'dev.flutter.pigeon.immich_mobile.BackgroundWorkerLockApi.unlock$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;
+    }
+  }
+}

mobile/lib/platform/native_sync_api.g.dart

@@ -205,6 +205,45 @@ class SyncDelta {
   int get hashCode => Object.hashAll(_toList());
 }
 
+class HashResult {
+  HashResult({required this.assetId, this.error, this.hash});
+
+  String assetId;
+
+  String? error;
+
+  String? hash;
+
+  List<Object?> _toList() {
+    return <Object?>[assetId, error, hash];
+  }
+
+  Object encode() {
+    return _toList();
+  }
+
+  static HashResult decode(Object result) {
+    result as List<Object?>;
+    return HashResult(assetId: result[0]! as String, error: result[1] as String?, hash: result[2] as String?);
+  }
+
+  @override
+  // ignore: avoid_equals_and_hash_code_on_mutable_classes
+  bool operator ==(Object other) {
+    if (other is! HashResult || other.runtimeType != runtimeType) {
+      return false;
+    }
+    if (identical(this, other)) {
+      return true;
+    }
+    return _deepEquals(encode(), other.encode());
+  }
+
+  @override
+  // ignore: avoid_equals_and_hash_code_on_mutable_classes
+  int get hashCode => Object.hashAll(_toList());
+}
+
 class _PigeonCodec extends StandardMessageCodec {
   const _PigeonCodec();
   @override
@@ -221,6 +260,9 @@ class _PigeonCodec extends StandardMessageCodec {
     } else if (value is SyncDelta) {
       buffer.putUint8(131);
       writeValue(buffer, value.encode());
+    } else if (value is HashResult) {
+      buffer.putUint8(132);
+      writeValue(buffer, value.encode());
     } else {
       super.writeValue(buffer, value);
     }
@@ -235,6 +277,8 @@ class _PigeonCodec extends StandardMessageCodec {
         return PlatformAlbum.decode(readValue(buffer)!);
       case 131:
         return SyncDelta.decode(readValue(buffer)!);
+      case 132:
+        return HashResult.decode(readValue(buffer)!);
       default:
         return super.readValueOfType(type, buffer);
     }
@@ -468,15 +512,15 @@ class NativeSyncApi {
     }
   }
 
-  Future<List<Uint8List?>> hashPaths(List<String> paths) async {
+  Future<List<HashResult>> hashAssets(List<String> assetIds, {bool allowNetworkAccess = false}) async {
     final String pigeonVar_channelName =
-        'dev.flutter.pigeon.immich_mobile.NativeSyncApi.hashPaths$pigeonVar_messageChannelSuffix';
+        'dev.flutter.pigeon.immich_mobile.NativeSyncApi.hashAssets$pigeonVar_messageChannelSuffix';
     final BasicMessageChannel<Object?> pigeonVar_channel = BasicMessageChannel<Object?>(
       pigeonVar_channelName,
       pigeonChannelCodec,
       binaryMessenger: pigeonVar_binaryMessenger,
     );
-    final Future<Object?> pigeonVar_sendFuture = pigeonVar_channel.send(<Object?>[paths]);
+    final Future<Object?> pigeonVar_sendFuture = pigeonVar_channel.send(<Object?>[assetIds, allowNetworkAccess]);
     final List<Object?>? pigeonVar_replyList = await pigeonVar_sendFuture as List<Object?>?;
     if (pigeonVar_replyList == null) {
       throw _createConnectionError(pigeonVar_channelName);
@@ -492,7 +536,30 @@ class NativeSyncApi {
         message: 'Host platform returned null value for non-null return value.',
       );
     } else {
-      return (pigeonVar_replyList[0] as List<Object?>?)!.cast<Uint8List?>();
+      return (pigeonVar_replyList[0] as List<Object?>?)!.cast<HashResult>();
+    }
+  }
+
+  Future<void> cancelHashing() async {
+    final String pigeonVar_channelName =
+        'dev.flutter.pigeon.immich_mobile.NativeSyncApi.cancelHashing$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;
     }
   }
 }

mobile/lib/presentation/pages/download_info.page.dart

@@ -0,0 +1,57 @@
+import 'package:auto_route/auto_route.dart';
+import 'package:flutter/material.dart';
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+import 'package:immich_mobile/extensions/build_context_extensions.dart';
+import 'package:immich_mobile/extensions/translate_extensions.dart';
+import 'package:immich_mobile/pages/common/download_panel.dart';
+import 'package:immich_mobile/providers/asset_viewer/download.provider.dart';
+
+@RoutePage()
+class DownloadInfoPage extends ConsumerWidget {
+  const DownloadInfoPage({super.key});
+
+  @override
+  Widget build(BuildContext context, WidgetRef ref) {
+    final tasks = ref.watch(downloadStateProvider.select((state) => state.taskProgress)).entries.toList();
+
+    onCancelDownload(String id) {
+      ref.watch(downloadStateProvider.notifier).cancelDownload(id);
+    }
+
+    return Scaffold(
+      appBar: AppBar(
+        title: Text("download".t(context: context)),
+        actions: [],
+      ),
+      body: ListView.builder(
+        physics: const ClampingScrollPhysics(),
+        shrinkWrap: true,
+        itemCount: tasks.length,
+        itemBuilder: (context, index) {
+          final task = tasks[index];
+          return Padding(
+            padding: const EdgeInsets.symmetric(horizontal: 8.0, vertical: 4.0),
+            child: DownloadTaskTile(
+              progress: task.value.progress,
+              fileName: task.value.fileName,
+              status: task.value.status,
+              onCancelDownload: () => onCancelDownload(task.key),
+            ),
+          );
+        },
+      ),
+      persistentFooterButtons: [
+        OutlinedButton(
+          onPressed: () {
+            tasks.map((e) => e.key).forEach(onCancelDownload);
+          },
+          style: OutlinedButton.styleFrom(side: BorderSide(color: context.colorScheme.primary)),
+          child: Text(
+            'clear_all'.t(context: context),
+            style: context.textTheme.labelLarge?.copyWith(color: context.colorScheme.primary),
+          ),
+        ),
+      ],
+    );
+  }
+}

mobile/lib/presentation/pages/search/drift_search.page.dart

@@ -633,7 +633,7 @@ class _SearchResultGrid extends ConsumerWidget {
             groupBy: GroupAssetsBy.none,
             appBar: null,
             bottomSheet: const GeneralBottomSheet(minChildSize: 0.20),
-            withScrubber: false,
+            snapToMonth: false,
           ),
         ),
       ),

mobile/lib/presentation/widgets/action_buttons/download_action_button.widget.dart

@@ -1,54 +1,45 @@
-import 'package:fluttertoast/fluttertoast.dart';
 import 'package:immich_mobile/constants/enums.dart';
 import 'package:flutter/material.dart';
 import 'package:hooks_riverpod/hooks_riverpod.dart';
+import 'package:immich_mobile/domain/utils/background_sync.dart';
 import 'package:immich_mobile/extensions/translate_extensions.dart';
 import 'package:immich_mobile/presentation/widgets/action_buttons/base_action_button.widget.dart';
+import 'package:immich_mobile/providers/background_sync.provider.dart';
 import 'package:immich_mobile/providers/infrastructure/action.provider.dart';
 import 'package:immich_mobile/providers/timeline/multiselect.provider.dart';
-import 'package:immich_mobile/widgets/common/immich_toast.dart';
 
 class DownloadActionButton extends ConsumerWidget {
   final ActionSource source;
+  final bool menuItem;
+  const DownloadActionButton({super.key, required this.source, this.menuItem = false});
 
-  const DownloadActionButton({super.key, required this.source});
-
-  void _onTap(BuildContext context, WidgetRef ref) async {
+  void _onTap(BuildContext context, WidgetRef ref, BackgroundSyncManager backgroundSyncManager) async {
     if (!context.mounted) {
       return;
     }
 
-    final result = await ref.read(actionProvider.notifier).downloadAll(source);
-    ref.read(multiSelectProvider.notifier).reset();
+    try {
+      await ref.read(actionProvider.notifier).downloadAll(source);
 
-    if (!context.mounted) {
-      return;
-    }
-
-    if (!result.success) {
-      ImmichToast.show(
-        context: context,
-        msg: 'scaffold_body_error_occurred'.t(context: context),
-        gravity: ToastGravity.BOTTOM,
-        toastType: ToastType.error,
-      );
-    } else if (result.count > 0) {
-      ImmichToast.show(
-        context: context,
-        msg: 'download_action_prompt'.t(context: context, args: {'count': result.count.toString()}),
-        gravity: ToastGravity.BOTTOM,
-        toastType: ToastType.success,
-      );
+      Future.delayed(const Duration(seconds: 1), () async {
+        await backgroundSyncManager.syncLocal();
+        await backgroundSyncManager.hashAssets();
+      });
+    } finally {
+      ref.read(multiSelectProvider.notifier).reset();
     }
   }
 
   @override
   Widget build(BuildContext context, WidgetRef ref) {
+    final backgroundManager = ref.watch(backgroundSyncProvider);
+
     return BaseActionButton(
       iconData: Icons.download,
       maxWidth: 95,
       label: "download".t(context: context),
-      onPressed: () => _onTap(context, ref),
+      menuItem: menuItem,
+      onPressed: () => _onTap(context, ref, backgroundManager),
     );
   }
 }

mobile/lib/presentation/widgets/action_buttons/download_status_floating_button.widget.dart

@@ -0,0 +1,64 @@
+import 'package:auto_route/auto_route.dart';
+import 'package:flutter/material.dart';
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+import 'package:immich_mobile/extensions/build_context_extensions.dart';
+import 'package:immich_mobile/providers/asset_viewer/download.provider.dart';
+import 'package:immich_mobile/routing/router.dart';
+
+class DownloadStatusFloatingButton extends ConsumerWidget {
+  const DownloadStatusFloatingButton({super.key});
+
+  @override
+  Widget build(BuildContext context, WidgetRef ref) {
+    final shouldShow = ref.watch(downloadStateProvider.select((state) => state.showProgress));
+    final itemCount = ref.watch(downloadStateProvider.select((state) => state.taskProgress.length));
+    final isDownloading = ref
+        .watch(downloadStateProvider.select((state) => state.taskProgress))
+        .values
+        .where((element) => element.progress != 1)
+        .isNotEmpty;
+
+    return shouldShow
+        ? Badge.count(
+            count: itemCount,
+            textColor: context.colorScheme.onPrimary,
+            backgroundColor: context.colorScheme.primary,
+            child: FloatingActionButton(
+              shape: RoundedRectangleBorder(
+                borderRadius: const BorderRadius.all(Radius.circular(20)),
+                side: BorderSide(color: context.colorScheme.outlineVariant, width: 1),
+              ),
+              backgroundColor: context.isDarkTheme
+                  ? context.colorScheme.surfaceContainer
+                  : context.colorScheme.surfaceBright,
+              elevation: 2,
+              onPressed: () {
+                context.pushRoute(const DownloadInfoRoute());
+              },
+              child: Stack(
+                alignment: AlignmentDirectional.center,
+                children: [
+                  isDownloading
+                      ? Icon(Icons.downloading_rounded, color: context.colorScheme.primary, size: 28)
+                      : Icon(
+                          Icons.download_done,
+                          color: context.isDarkTheme ? Colors.green[200] : Colors.green[400],
+                          size: 28,
+                        ),
+                  if (isDownloading)
+                    const SizedBox(
+                      height: 31,
+                      width: 31,
+                      child: CircularProgressIndicator(
+                        strokeWidth: 2,
+                        backgroundColor: Colors.transparent,
+                        value: null, // Indeterminate progress
+                      ),
+                    ),
+                ],
+              ),
+            ),
+          )
+        : const SizedBox.shrink();
+  }
+}

mobile/lib/presentation/widgets/action_buttons/share_action_button.widget.dart

@@ -42,7 +42,7 @@ class ShareActionButton extends ConsumerWidget {
     showDialog(
       context: context,
       builder: (BuildContext buildContext) {
-        ref.read(actionProvider.notifier).shareAssets(source).then((ActionResult result) {
+        ref.read(actionProvider.notifier).shareAssets(source, context).then((ActionResult result) {
           ref.read(multiSelectProvider.notifier).reset();
 
           if (!context.mounted) {

mobile/lib/presentation/widgets/asset_viewer/asset_stack.provider.dart

@@ -2,11 +2,11 @@ import 'package:hooks_riverpod/hooks_riverpod.dart';
 import 'package:immich_mobile/domain/models/asset/base_asset.model.dart';
 import 'package:immich_mobile/providers/infrastructure/asset.provider.dart';
 
-class StackChildrenNotifier extends AutoDisposeFamilyAsyncNotifier<List<RemoteAsset>, BaseAsset?> {
+class StackChildrenNotifier extends AutoDisposeFamilyAsyncNotifier<List<RemoteAsset>, BaseAsset> {
   @override
-  Future<List<RemoteAsset>> build(BaseAsset? asset) async {
-    if (asset == null || asset is! RemoteAsset || asset.stackId == null) {
-      return const [];
+  Future<List<RemoteAsset>> build(BaseAsset asset) {
+    if (asset is! RemoteAsset || asset.stackId == null) {
+      return Future.value(const []);
     }
 
     return ref.watch(assetServiceProvider).getStack(asset);
@@ -14,4 +14,4 @@ class StackChildrenNotifier extends AutoDisposeFamilyAsyncNotifier<List<RemoteAs
 }
 
 final stackChildrenNotifier = AsyncNotifierProvider.autoDispose
-    .family<StackChildrenNotifier, List<RemoteAsset>, BaseAsset?>(StackChildrenNotifier.new);
+    .family<StackChildrenNotifier, List<RemoteAsset>, BaseAsset>(StackChildrenNotifier.new);

mobile/lib/presentation/widgets/asset_viewer/asset_stack.widget.dart

@@ -3,7 +3,7 @@ import 'package:hooks_riverpod/hooks_riverpod.dart';
 import 'package:immich_mobile/domain/models/asset/base_asset.model.dart';
 import 'package:immich_mobile/presentation/widgets/asset_viewer/asset_stack.provider.dart';
 import 'package:immich_mobile/presentation/widgets/asset_viewer/asset_viewer.state.dart';
-import 'package:immich_mobile/presentation/widgets/images/image_provider.dart';
+import 'package:immich_mobile/presentation/widgets/images/thumbnail.widget.dart';
 import 'package:immich_mobile/providers/infrastructure/asset_viewer/current_asset.provider.dart';
 
 class AssetStackRow extends ConsumerWidget {
@@ -11,27 +11,25 @@ class AssetStackRow extends ConsumerWidget {
 
   @override
   Widget build(BuildContext context, WidgetRef ref) {
-    int opacity = ref.watch(assetViewerProvider.select((state) => state.backgroundOpacity));
-    final showControls = ref.watch(assetViewerProvider.select((s) => s.showingControls));
-
-    if (!showControls) {
-      opacity = 0;
+    final asset = ref.watch(assetViewerProvider.select((state) => state.currentAsset));
+    if (asset == null) {
+      return const SizedBox.shrink();
     }
 
-    final asset = ref.watch(assetViewerProvider.select((s) => s.currentAsset));
+    final stackChildren = ref.watch(stackChildrenNotifier(asset)).valueOrNull;
+    if (stackChildren == null || stackChildren.isEmpty) {
+      return const SizedBox.shrink();
+    }
+
+    final showControls = ref.watch(assetViewerProvider.select((s) => s.showingControls));
+    final opacity = showControls ? ref.watch(assetViewerProvider.select((state) => state.backgroundOpacity)) : 0;
 
     return IgnorePointer(
       ignoring: opacity < 255,
       child: AnimatedOpacity(
         opacity: opacity / 255,
         duration: Durations.short2,
-        child: ref
-            .watch(stackChildrenNotifier(asset))
-            .when(
-              data: (state) => SizedBox.square(dimension: 80, child: _StackList(stack: state)),
-              error: (_, __) => const SizedBox.shrink(),
-              loading: () => const SizedBox.shrink(),
-            ),
+        child: _StackList(stack: stackChildren),
       ),
     );
   }
@@ -44,58 +42,77 @@ class _StackList extends ConsumerWidget {
 
   @override
   Widget build(BuildContext context, WidgetRef ref) {
-    return ListView.builder(
-      scrollDirection: Axis.horizontal,
-      padding: const EdgeInsets.only(left: 5, right: 5, bottom: 30),
-      itemCount: stack.length,
-      itemBuilder: (ctx, index) {
-        final asset = stack[index];
-        return Padding(
-          padding: const EdgeInsets.only(right: 5),
-          child: GestureDetector(
-            onTap: () {
-              ref.read(assetViewerProvider.notifier).setStackIndex(index);
-              ref.read(currentAssetNotifier.notifier).setAsset(asset);
-            },
-            child: Container(
-              height: 60,
-              width: 60,
-              decoration: index == ref.watch(assetViewerProvider.select((s) => s.stackIndex))
-                  ? const BoxDecoration(
-                      color: Colors.white,
-                      borderRadius: BorderRadius.all(Radius.circular(6)),
-                      border: Border.fromBorderSide(BorderSide(color: Colors.white, width: 2)),
-                    )
-                  : const BoxDecoration(
-                      color: Colors.white,
-                      borderRadius: BorderRadius.all(Radius.circular(6)),
-                      border: null,
-                    ),
-              child: ClipRRect(
-                borderRadius: const BorderRadius.all(Radius.circular(4)),
-                child: Stack(
-                  fit: StackFit.expand,
-                  children: [
-                    Image(
-                      fit: BoxFit.cover,
-                      image: getThumbnailImageProvider(remoteId: asset.id, size: const Size.square(60)),
-                    ),
-                    if (asset.isVideo)
-                      const Icon(
-                        Icons.play_circle_outline_rounded,
-                        color: Colors.white,
-                        size: 16,
-                        shadows: [
-                          Shadow(blurRadius: 5.0, color: Color.fromRGBO(0, 0, 0, 0.6), offset: Offset(0.0, 0.0)),
-                        ],
-                      ),
-                  ],
-                ),
-              ),
-            ),
+    return Center(
+      child: SingleChildScrollView(
+        scrollDirection: Axis.horizontal,
+        child: Padding(
+          padding: const EdgeInsets.only(left: 10.0, right: 10.0, bottom: 20.0),
+          child: Row(
+            mainAxisAlignment: MainAxisAlignment.center,
+            spacing: 5.0,
+            children: List.generate(stack.length, (i) {
+              final asset = stack[i];
+              return _StackItem(key: ValueKey(asset.heroTag), asset: asset, index: i);
+            }),
           ),
-        );
-      },
+        ),
+      ),
+    );
+  }
+}
+
+class _StackItem extends ConsumerStatefulWidget {
+  final RemoteAsset asset;
+  final int index;
+
+  const _StackItem({super.key, required this.asset, required this.index});
+
+  @override
+  ConsumerState<_StackItem> createState() => _StackItemState();
+}
+
+class _StackItemState extends ConsumerState<_StackItem> {
+  void _onTap() {
+    ref.read(currentAssetNotifier.notifier).setAsset(widget.asset);
+    ref.read(assetViewerProvider.notifier).setStackIndex(widget.index);
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    const playIcon = Center(
+      child: Icon(
+        Icons.play_circle_outline_rounded,
+        color: Colors.white,
+        size: 16,
+        shadows: [Shadow(blurRadius: 5.0, color: Color.fromRGBO(0, 0, 0, 0.6), offset: Offset(0.0, 0.0))],
+      ),
+    );
+    const selectedDecoration = BoxDecoration(
+      border: Border.fromBorderSide(BorderSide(color: Colors.white, width: 2)),
+      borderRadius: BorderRadius.all(Radius.circular(10)),
+    );
+    const unselectedDecoration = BoxDecoration(
+      border: Border.fromBorderSide(BorderSide(color: Colors.grey, width: 0.5)),
+      borderRadius: BorderRadius.all(Radius.circular(10)),
+    );
+
+    Widget thumbnail = Thumbnail.fromAsset(asset: widget.asset, size: const Size(60, 40));
+    if (widget.asset.isVideo) {
+      thumbnail = Stack(children: [thumbnail, playIcon]);
+    }
+    thumbnail = ClipRRect(borderRadius: const BorderRadius.all(Radius.circular(10)), child: thumbnail);
+    final isSelected = ref.watch(assetViewerProvider.select((s) => s.stackIndex == widget.index));
+    return SizedBox(
+      width: 60,
+      height: 40,
+      child: GestureDetector(
+        onTap: _onTap,
+        child: DecoratedBox(
+          decoration: isSelected ? selectedDecoration : unselectedDecoration,
+          position: DecorationPosition.foreground,
+          child: thumbnail,
+        ),
+      ),
     );
   }
 }

mobile/lib/presentation/widgets/asset_viewer/asset_viewer.page.dart

@@ -12,6 +12,7 @@ import 'package:immich_mobile/domain/utils/event_stream.dart';
 import 'package:immich_mobile/extensions/build_context_extensions.dart';
 import 'package:immich_mobile/extensions/platform_extensions.dart';
 import 'package:immich_mobile/extensions/scroll_extensions.dart';
+import 'package:immich_mobile/presentation/widgets/action_buttons/download_status_floating_button.widget.dart';
 import 'package:immich_mobile/presentation/widgets/asset_viewer/asset_stack.provider.dart';
 import 'package:immich_mobile/presentation/widgets/asset_viewer/asset_stack.widget.dart';
 import 'package:immich_mobile/presentation/widgets/asset_viewer/asset_viewer.state.dart';
@@ -61,6 +62,15 @@ class AssetViewer extends ConsumerStatefulWidget {
   ConsumerState createState() => _AssetViewerState();
 
   static void setAsset(WidgetRef ref, BaseAsset asset) {
+    ref.read(assetViewerProvider.notifier).reset();
+    _setAsset(ref, asset);
+  }
+
+  void changeAsset(WidgetRef ref, BaseAsset asset) {
+    _setAsset(ref, asset);
+  }
+
+  static void _setAsset(WidgetRef ref, BaseAsset asset) {
     // Always holds the current asset from the timeline
     ref.read(assetViewerProvider.notifier).setAsset(asset);
     // The currentAssetNotifier actually holds the current asset that is displayed
@@ -107,6 +117,8 @@ class _AssetViewerState extends ConsumerState<AssetViewer> {
   ImageStream? _prevPreCacheStream;
   ImageStream? _nextPreCacheStream;
 
+  KeepAliveLink? _stackChildrenKeepAlive;
+
   @override
   void initState() {
     super.initState();
@@ -117,6 +129,10 @@ class _AssetViewerState extends ConsumerState<AssetViewer> {
     WidgetsBinding.instance.addPostFrameCallback(_onAssetInit);
     reloadSubscription = EventStream.shared.listen(_onEvent);
     heroOffset = widget.heroOffset ?? TabsRouterScope.of(context)?.controller.activeIndex ?? 0;
+    final asset = ref.read(currentAssetNotifier);
+    if (asset != null) {
+      _stackChildrenKeepAlive = ref.read(stackChildrenNotifier(asset).notifier).ref.keepAlive();
+    }
   }
 
   @override
@@ -128,6 +144,7 @@ class _AssetViewerState extends ConsumerState<AssetViewer> {
     _prevPreCacheStream?.removeListener(_dummyListener);
     _nextPreCacheStream?.removeListener(_dummyListener);
     SystemChrome.setEnabledSystemUIMode(SystemUiMode.edgeToEdge);
+    _stackChildrenKeepAlive?.close();
     super.dispose();
   }
 
@@ -188,9 +205,11 @@ class _AssetViewerState extends ConsumerState<AssetViewer> {
       return;
     }
 
-    AssetViewer.setAsset(ref, asset);
+    widget.changeAsset(ref, asset);
     _precacheAssets(index);
     _handleCasting();
+    _stackChildrenKeepAlive?.close();
+    _stackChildrenKeepAlive = ref.read(stackChildrenNotifier(asset).notifier).ref.keepAlive();
   }
 
   void _handleCasting() {
@@ -518,7 +537,7 @@ class _AssetViewerState extends ConsumerState<AssetViewer> {
     BaseAsset displayAsset = asset;
     final stackChildren = ref.read(stackChildrenNotifier(asset)).valueOrNull;
     if (stackChildren != null && stackChildren.isNotEmpty) {
-      displayAsset = stackChildren.elementAt(ref.read(assetViewerProvider.select((s) => s.stackIndex)));
+      displayAsset = stackChildren.elementAt(ref.read(assetViewerProvider).stackIndex);
     }
 
     final isPlayingMotionVideo = ref.read(isPlayingMotionVideoProvider);
@@ -631,20 +650,25 @@ class _AssetViewerState extends ConsumerState<AssetViewer> {
         appBar: const ViewerTopAppBar(),
         extendBody: true,
         extendBodyBehindAppBar: true,
-        body: PhotoViewGallery.builder(
-          gaplessPlayback: true,
-          loadingBuilder: _placeholderBuilder,
-          pageController: pageController,
-          scrollPhysics: CurrentPlatform.isIOS
-              ? const FastScrollPhysics() // Use bouncing physics for iOS
-              : const FastClampingScrollPhysics(), // Use heavy physics for Android
-          itemCount: totalAssets,
-          onPageChanged: _onPageChanged,
-          onPageBuild: _onPageBuild,
-          scaleStateChangedCallback: _onScaleStateChanged,
-          builder: _assetBuilder,
-          backgroundDecoration: BoxDecoration(color: backgroundColor),
-          enablePanAlways: true,
+        floatingActionButton: const DownloadStatusFloatingButton(),
+        body: Stack(
+          children: [
+            PhotoViewGallery.builder(
+              gaplessPlayback: true,
+              loadingBuilder: _placeholderBuilder,
+              pageController: pageController,
+              scrollPhysics: CurrentPlatform.isIOS
+                  ? const FastScrollPhysics() // Use bouncing physics for iOS
+                  : const FastClampingScrollPhysics(), // Use heavy physics for Android
+              itemCount: totalAssets,
+              onPageChanged: _onPageChanged,
+              onPageBuild: _onPageBuild,
+              scaleStateChangedCallback: _onScaleStateChanged,
+              builder: _assetBuilder,
+              backgroundDecoration: BoxDecoration(color: backgroundColor),
+              enablePanAlways: true,
+            ),
+          ],
         ),
         bottomNavigationBar: showingBottomSheet
             ? const SizedBox.shrink()

mobile/lib/presentation/widgets/asset_viewer/asset_viewer.state.dart

@@ -68,12 +68,16 @@ class AssetViewerState {
       stackIndex.hashCode;
 }
 
-class AssetViewerStateNotifier extends AutoDisposeNotifier<AssetViewerState> {
+class AssetViewerStateNotifier extends Notifier<AssetViewerState> {
   @override
   AssetViewerState build() {
     return const AssetViewerState();
   }
 
+  void reset() {
+    state = const AssetViewerState();
+  }
+
   void setAsset(BaseAsset? asset) {
     if (asset == state.currentAsset) {
       return;
@@ -117,6 +121,4 @@ class AssetViewerStateNotifier extends AutoDisposeNotifier<AssetViewerState> {
   }
 }
 
-final assetViewerProvider = AutoDisposeNotifierProvider<AssetViewerStateNotifier, AssetViewerState>(
-  AssetViewerStateNotifier.new,
-);
+final assetViewerProvider = NotifierProvider<AssetViewerStateNotifier, AssetViewerState>(AssetViewerStateNotifier.new);

mobile/lib/presentation/widgets/asset_viewer/top_app_bar.widget.dart

@@ -8,6 +8,7 @@ import 'package:immich_mobile/domain/utils/event_stream.dart';
 import 'package:immich_mobile/extensions/build_context_extensions.dart';
 import 'package:immich_mobile/extensions/translate_extensions.dart';
 import 'package:immich_mobile/presentation/widgets/action_buttons/cast_action_button.widget.dart';
+import 'package:immich_mobile/presentation/widgets/action_buttons/download_action_button.widget.dart';
 import 'package:immich_mobile/presentation/widgets/action_buttons/favorite_action_button.widget.dart';
 import 'package:immich_mobile/presentation/widgets/action_buttons/motion_photo_action_button.widget.dart';
 import 'package:immich_mobile/presentation/widgets/action_buttons/unfavorite_action_button.widget.dart';
@@ -56,6 +57,7 @@ class ViewerTopAppBar extends ConsumerWidget implements PreferredSizeWidget {
     final isCasting = ref.watch(castProvider.select((c) => c.isCasting));
 
     final actions = <Widget>[
+      if (asset.hasRemote) const DownloadActionButton(source: ActionSource.viewer, menuItem: true),
       if (isCasting || (asset.hasRemote)) const CastActionButton(menuItem: true),
       if (album != null && album.isActivityEnabled && album.isShared)
         IconButton(

mobile/lib/presentation/widgets/images/thumbnail.widget.dart

@@ -326,7 +326,7 @@ class _ThumbnailRenderBox extends RenderBox {
         image: _previousImage!,
         fit: _fit,
         filterQuality: FilterQuality.low,
-        opacity: 1.0 - _fadeValue,
+        opacity: 1.0,
       );
     } else if (_image == null || _fadeValue < 1.0) {
       final paint = Paint()..shader = _placeholderGradient.createShader(rect);

mobile/lib/presentation/widgets/timeline/fixed/segment.model.dart

@@ -101,7 +101,6 @@ class _FixedSegmentRow extends ConsumerWidget {
     if (isScrubbing) {
       return _buildPlaceholder(context);
     }
-
     if (timelineService.hasRange(assetIndex, assetCount)) {
       return _buildAssetRow(context, timelineService.getAssets(assetIndex, assetCount), timelineService);
     }

mobile/lib/presentation/widgets/timeline/scrubber.widget.dart

@@ -11,6 +11,7 @@ import 'package:immich_mobile/presentation/widgets/timeline/constants.dart';
 import 'package:immich_mobile/presentation/widgets/timeline/segment.model.dart';
 import 'package:immich_mobile/presentation/widgets/timeline/timeline.state.dart';
 import 'package:immich_mobile/providers/haptic_feedback.provider.dart';
+import 'package:immich_mobile/utils/debounce.dart';
 import 'package:intl/intl.dart' hide TextDirection;
 
 /// A widget that will display a BoxScrollView with a ScrollThumb that can be dragged
@@ -30,6 +31,11 @@ class Scrubber extends ConsumerStatefulWidget {
 
   final double? monthSegmentSnappingOffset;
 
+  final bool snapToMonth;
+
+  /// Whether an app bar is present, affects coordinate calculations
+  final bool hasAppBar;
+
   Scrubber({
     super.key,
     Key? scrollThumbKey,
@@ -38,6 +44,8 @@ class Scrubber extends ConsumerStatefulWidget {
     this.topPadding = 0,
     this.bottomPadding = 0,
     this.monthSegmentSnappingOffset,
+    this.snapToMonth = true,
+    this.hasAppBar = true,
     required this.child,
   }) : assert(child.scrollDirection == Axis.vertical);
 
@@ -81,6 +89,8 @@ class ScrubberState extends ConsumerState<Scrubber> with TickerProviderStateMixi
   bool _isDragging = false;
   List<_Segment> _segments = [];
   int _monthCount = 0;
+  DateTime? _currentScrubberDate;
+  Debouncer? _scrubberDebouncer;
 
   late AnimationController _thumbAnimationController;
   Timer? _fadeOutTimer;
@@ -133,6 +143,7 @@ class ScrubberState extends ConsumerState<Scrubber> with TickerProviderStateMixi
     _thumbAnimationController.dispose();
     _labelAnimationController.dispose();
     _fadeOutTimer?.cancel();
+    _scrubberDebouncer?.dispose();
     super.dispose();
   }
 
@@ -176,11 +187,25 @@ class ScrubberState extends ConsumerState<Scrubber> with TickerProviderStateMixi
     return false;
   }
 
-  void _onDragStart(DragStartDetails _) {
-    if (_monthCount >= kMinMonthsToEnableScrubberSnap) {
+  void _onScrubberDateChanged(DateTime date) {
+    if (_currentScrubberDate != date) {
+      // Date changed, immediately set scrubbing to true
+      _currentScrubberDate = date;
       ref.read(timelineStateProvider.notifier).setScrubbing(true);
-    }
 
+      // Initialize debouncer if needed
+      _scrubberDebouncer ??= Debouncer(interval: const Duration(milliseconds: 50));
+
+      // Debounce setting scrubbing to false
+      _scrubberDebouncer!.run(() {
+        if (_currentScrubberDate == date) {
+          ref.read(timelineStateProvider.notifier).setScrubbing(false);
+        }
+      });
+    }
+  }
+
+  void _onDragStart(DragStartDetails _) {
     setState(() {
       _isDragging = true;
       _labelAnimationController.forward();
@@ -206,10 +231,15 @@ class ScrubberState extends ConsumerState<Scrubber> with TickerProviderStateMixi
       if (_lastLabel != label) {
         ref.read(hapticFeedbackProvider.notifier).selectionClick();
         _lastLabel = label;
+
+        // Notify timeline state of the new scrubber date position
+        if (_monthCount >= kMinMonthsToEnableScrubberSnap) {
+          _onScrubberDateChanged(nearestMonthSegment.date);
+        }
       }
     }
 
-    if (_monthCount < kMinMonthsToEnableScrubberSnap) {
+    if (_monthCount < kMinMonthsToEnableScrubberSnap || !widget.snapToMonth) {
       // If there are less than kMinMonthsToEnableScrubberSnap months, we don't need to snap to segments
       setState(() {
         _thumbTopOffset = dragPosition;
@@ -236,14 +266,28 @@ class ScrubberState extends ConsumerState<Scrubber> with TickerProviderStateMixi
   /// - If user drags to global Y position that's 100 pixels from the top
   /// - The relative position would be 100 - 50 = 50 (50 pixels into the scrubber area)
   double _calculateDragPosition(DragUpdateDetails details) {
+    if (widget.hasAppBar) {
+      final dragAreaTop = widget.topPadding;
+      final dragAreaBottom = widget.timelineHeight - widget.bottomPadding;
+      final dragAreaHeight = dragAreaBottom - dragAreaTop;
+
+      final relativePosition = details.globalPosition.dy - dragAreaTop;
+
+      // Make sure the position stays within the scrubber's bounds
+      return relativePosition.clamp(0.0, dragAreaHeight);
+    }
+
+    // Get the local position relative to the gesture detector
+    final RenderBox? renderBox = context.findRenderObject() as RenderBox?;
+    if (renderBox != null) {
+      final localPosition = renderBox.globalToLocal(details.globalPosition);
+      return localPosition.dy.clamp(0.0, _scrubberHeight);
+    }
+
+    // Fallback to current logic if render box is not available
     final dragAreaTop = widget.topPadding;
-    final dragAreaBottom = widget.timelineHeight - widget.bottomPadding;
-    final dragAreaHeight = dragAreaBottom - dragAreaTop;
-
     final relativePosition = details.globalPosition.dy - dragAreaTop;
-
-    // Make sure the position stays within the scrubber's bounds
-    return relativePosition.clamp(0.0, dragAreaHeight);
+    return relativePosition.clamp(0.0, _scrubberHeight);
   }
 
   /// Find the segment closest to the given position
@@ -294,12 +338,18 @@ class ScrubberState extends ConsumerState<Scrubber> with TickerProviderStateMixi
   }
 
   void _onDragEnd(DragEndDetails _) {
-    ref.read(timelineStateProvider.notifier).setScrubbing(false);
     _labelAnimationController.reverse();
     setState(() {
       _isDragging = false;
     });
 
+    ref.read(timelineStateProvider.notifier).setScrubbing(false);
+
+    // Reset scrubber tracking when drag ends
+    _currentScrubberDate = null;
+    _scrubberDebouncer?.dispose();
+    _scrubberDebouncer = null;
+
     _resetThumbTimer();
   }
 

mobile/lib/presentation/widgets/timeline/timeline.state.dart

@@ -72,8 +72,6 @@ class TimelineState {
 }
 
 class TimelineStateNotifier extends Notifier<TimelineState> {
-  TimelineStateNotifier();
-
   void setScrubbing(bool isScrubbing) {
     state = state.copyWith(isScrubbing: isScrubbing);
   }

mobile/lib/presentation/widgets/timeline/timeline.widget.dart

@@ -14,6 +14,7 @@ import 'package:immich_mobile/domain/models/timeline.model.dart';
 import 'package:immich_mobile/domain/utils/event_stream.dart';
 import 'package:immich_mobile/extensions/asyncvalue_extensions.dart';
 import 'package:immich_mobile/extensions/build_context_extensions.dart';
+import 'package:immich_mobile/presentation/widgets/action_buttons/download_status_floating_button.widget.dart';
 import 'package:immich_mobile/presentation/widgets/bottom_sheet/general_bottom_sheet.widget.dart';
 import 'package:immich_mobile/presentation/widgets/timeline/scrubber.widget.dart';
 import 'package:immich_mobile/presentation/widgets/timeline/segment.model.dart';
@@ -38,6 +39,7 @@ class Timeline extends StatelessWidget {
     this.bottomSheet = const GeneralBottomSheet(minChildSize: 0.18),
     this.groupBy,
     this.withScrubber = true,
+    this.snapToMonth = true,
   });
 
   final Widget? topSliverWidget;
@@ -48,11 +50,13 @@ class Timeline extends StatelessWidget {
   final bool withStack;
   final GroupAssetsBy? groupBy;
   final bool withScrubber;
+  final bool snapToMonth;
 
   @override
   Widget build(BuildContext context) {
     return Scaffold(
       resizeToAvoidBottomInset: false,
+      floatingActionButton: const DownloadStatusFloatingButton(),
       body: LayoutBuilder(
         builder: (_, constraints) => ProviderScope(
           overrides: [
@@ -73,6 +77,7 @@ class Timeline extends StatelessWidget {
             appBar: appBar,
             bottomSheet: bottomSheet,
             withScrubber: withScrubber,
+            snapToMonth: snapToMonth,
           ),
         ),
       ),
@@ -87,6 +92,7 @@ class _SliverTimeline extends ConsumerStatefulWidget {
     this.appBar,
     this.bottomSheet,
     this.withScrubber = true,
+    this.snapToMonth = true,
   });
 
   final Widget? topSliverWidget;
@@ -94,13 +100,14 @@ class _SliverTimeline extends ConsumerStatefulWidget {
   final Widget? appBar;
   final Widget? bottomSheet;
   final bool withScrubber;
+  final bool snapToMonth;
 
   @override
   ConsumerState createState() => _SliverTimelineState();
 }
 
 class _SliverTimelineState extends ConsumerState<_SliverTimeline> {
-  final _scrollController = ScrollController();
+  late final ScrollController _scrollController;
   StreamSubscription? _eventSubscription;
 
   // Drag selection state
@@ -112,10 +119,12 @@ class _SliverTimelineState extends ConsumerState<_SliverTimeline> {
   int _perRow = 4;
   double _scaleFactor = 3.0;
   double _baseScaleFactor = 3.0;
+  int? _scaleRestoreAssetIndex;
 
   @override
   void initState() {
     super.initState();
+    _scrollController = ScrollController(onAttach: _restoreScalePosition);
     _eventSubscription = EventStream.shared.listen(_onEvent);
 
     final currentTilesPerRow = ref.read(settingsProvider).get(Setting.tilesPerRow);
@@ -129,7 +138,11 @@ class _SliverTimelineState extends ConsumerState<_SliverTimeline> {
   void _onEvent(Event event) {
     switch (event) {
       case ScrollToTopEvent():
-        _scrollController.animateTo(0, duration: const Duration(milliseconds: 250), curve: Curves.easeInOut);
+        ref.read(timelineStateProvider.notifier).setScrubbing(true);
+        _scrollController
+            .animateTo(0, duration: const Duration(milliseconds: 250), curve: Curves.easeInOut)
+            .whenComplete(() => ref.read(timelineStateProvider.notifier).setScrubbing(false));
+
       case ScrollToDateEvent scrollToDateEvent:
         _scrollToDate(scrollToDateEvent.date);
       case TimelineReloadEvent():
@@ -143,6 +156,28 @@ class _SliverTimelineState extends ConsumerState<_SliverTimeline> {
     EventStream.shared.emit(MultiSelectToggleEvent(isEnabled));
   }
 
+  void _restoreScalePosition(_) {
+    if (_scaleRestoreAssetIndex == null) return;
+
+    final asyncSegments = ref.read(timelineSegmentProvider);
+    asyncSegments.whenData((segments) {
+      final targetSegment = segments.lastWhereOrNull((segment) => segment.firstAssetIndex <= _scaleRestoreAssetIndex!);
+      if (targetSegment != null) {
+        final assetIndexInSegment = _scaleRestoreAssetIndex! - targetSegment.firstAssetIndex;
+        final newColumnCount = ref.read(timelineArgsProvider).columnCount;
+        final rowIndexInSegment = (assetIndexInSegment / newColumnCount).floor();
+        final targetRowIndex = targetSegment.firstIndex + 1 + rowIndexInSegment;
+        final targetOffset = targetSegment.indexToLayoutOffset(targetRowIndex);
+        WidgetsBinding.instance.addPostFrameCallback((_) {
+          if (mounted) {
+            _scrollController.jumpTo(targetOffset.clamp(0.0, _scrollController.position.maxScrollExtent));
+          }
+        });
+      }
+    });
+    _scaleRestoreAssetIndex = null;
+  }
+
   @override
   void dispose() {
     _scrollController.dispose();
@@ -305,11 +340,13 @@ class _SliverTimelineState extends ConsumerState<_SliverTimeline> {
           final Widget timeline;
           if (widget.withScrubber) {
             timeline = Scrubber(
+              snapToMonth: widget.snapToMonth,
               layoutSegments: segments,
               timelineHeight: maxHeight,
               topPadding: topPadding,
               bottomPadding: bottomPadding,
               monthSegmentSnappingOffset: widget.topSliverWidgetHeight ?? 0 + appBarExpandedHeight,
+              hasAppBar: widget.appBar != null,
               child: grid,
             );
           } else {
@@ -332,9 +369,28 @@ class _SliverTimelineState extends ConsumerState<_SliverTimeline> {
                       final newPerRow = 7 - newScaleFactor.toInt();
 
                       if (newPerRow != _perRow) {
+                        final currentOffset = _scrollController.offset.clamp(
+                          0.0,
+                          _scrollController.position.maxScrollExtent,
+                        );
+                        final segment = segments.findByOffset(currentOffset) ?? segments.lastOrNull;
+                        int? targetAssetIndex;
+                        if (segment != null) {
+                          final rowIndex = segment.getMinChildIndexForScrollOffset(currentOffset);
+                          if (rowIndex > segment.firstIndex) {
+                            final rowIndexInSegment = rowIndex - (segment.firstIndex + 1);
+                            final assetsPerRow = ref.read(timelineArgsProvider).columnCount;
+                            final assetIndexInSegment = rowIndexInSegment * assetsPerRow;
+                            targetAssetIndex = segment.firstAssetIndex + assetIndexInSegment;
+                          } else {
+                            targetAssetIndex = segment.firstAssetIndex;
+                          }
+                        }
+
                         setState(() {
                           _scaleFactor = newScaleFactor;
                           _perRow = newPerRow;
+                          _scaleRestoreAssetIndex = targetAssetIndex;
                         });
 
                         ref.read(settingsProvider.notifier).set(Setting.tilesPerRow, _perRow);

mobile/lib/providers/app_life_cycle.provider.dart

@@ -15,6 +15,7 @@ import 'package:immich_mobile/providers/backup/drift_backup.provider.dart';
 import 'package:immich_mobile/providers/backup/ios_background_settings.provider.dart';
 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/platform.provider.dart';
 import 'package:immich_mobile/providers/memory.provider.dart';
 import 'package:immich_mobile/providers/notification_permission.provider.dart';
 import 'package:immich_mobile/providers/server_info.provider.dart';
@@ -138,6 +139,7 @@ class AppLifeCycleNotifier extends StateNotifier<AppLifeCycleEnum> {
 
   Future<void> _handleBetaTimelineResume() async {
     _ref.read(backupProvider.notifier).cancelBackup();
+    unawaited(_ref.read(backgroundWorkerLockServiceProvider).lock());
 
     // Give isolates time to complete any ongoing database transactions
     await Future.delayed(const Duration(milliseconds: 500));
@@ -209,6 +211,9 @@ class AppLifeCycleNotifier extends StateNotifier<AppLifeCycleEnum> {
     _pauseOperation = Completer<void>();
 
     try {
+      if (Store.isBetaTimelineEnabled) {
+        unawaited(_ref.read(backgroundWorkerLockServiceProvider).unlock());
+      }
       await _performPause();
     } catch (e, stackTrace) {
       _log.severe("Error during app pause", e, stackTrace);
@@ -240,6 +245,10 @@ class AppLifeCycleNotifier extends StateNotifier<AppLifeCycleEnum> {
   Future<void> handleAppDetached() async {
     state = AppLifeCycleEnum.detached;
 
+    if (Store.isBetaTimelineEnabled) {
+      unawaited(_ref.read(backgroundWorkerLockServiceProvider).unlock());
+    }
+
     // Flush logs before closing database
     try {
       LogService.I.flush();

mobile/lib/providers/backup/drift_backup.provider.dart

@@ -123,6 +123,7 @@ class DriftBackupState {
   final int totalCount;
   final int backupCount;
   final int remainderCount;
+  final int processingCount;
 
   final int enqueueCount;
   final int enqueueTotalCount;
@@ -135,6 +136,7 @@ class DriftBackupState {
     required this.totalCount,
     required this.backupCount,
     required this.remainderCount,
+    required this.processingCount,
     required this.enqueueCount,
     required this.enqueueTotalCount,
     required this.isCanceling,
@@ -145,6 +147,7 @@ class DriftBackupState {
     int? totalCount,
     int? backupCount,
     int? remainderCount,
+    int? processingCount,
     int? enqueueCount,
     int? enqueueTotalCount,
     bool? isCanceling,
@@ -154,6 +157,7 @@ class DriftBackupState {
       totalCount: totalCount ?? this.totalCount,
       backupCount: backupCount ?? this.backupCount,
       remainderCount: remainderCount ?? this.remainderCount,
+      processingCount: processingCount ?? this.processingCount,
       enqueueCount: enqueueCount ?? this.enqueueCount,
       enqueueTotalCount: enqueueTotalCount ?? this.enqueueTotalCount,
       isCanceling: isCanceling ?? this.isCanceling,
@@ -163,7 +167,7 @@ class DriftBackupState {
 
   @override
   String toString() {
-    return 'DriftBackupState(totalCount: $totalCount, backupCount: $backupCount, remainderCount: $remainderCount, enqueueCount: $enqueueCount, enqueueTotalCount: $enqueueTotalCount, isCanceling: $isCanceling, uploadItems: $uploadItems)';
+    return 'DriftBackupState(totalCount: $totalCount, backupCount: $backupCount, remainderCount: $remainderCount, processingCount: $processingCount, enqueueCount: $enqueueCount, enqueueTotalCount: $enqueueTotalCount, isCanceling: $isCanceling, uploadItems: $uploadItems)';
   }
 
   @override
@@ -174,6 +178,7 @@ class DriftBackupState {
     return other.totalCount == totalCount &&
         other.backupCount == backupCount &&
         other.remainderCount == remainderCount &&
+        other.processingCount == processingCount &&
         other.enqueueCount == enqueueCount &&
         other.enqueueTotalCount == enqueueTotalCount &&
         other.isCanceling == isCanceling &&
@@ -185,6 +190,7 @@ class DriftBackupState {
     return totalCount.hashCode ^
         backupCount.hashCode ^
         remainderCount.hashCode ^
+        processingCount.hashCode ^
         enqueueCount.hashCode ^
         enqueueTotalCount.hashCode ^
         isCanceling.hashCode ^
@@ -203,6 +209,7 @@ class DriftBackupNotifier extends StateNotifier<DriftBackupState> {
           totalCount: 0,
           backupCount: 0,
           remainderCount: 0,
+          processingCount: 0,
           enqueueCount: 0,
           enqueueTotalCount: 0,
           isCanceling: false,
@@ -235,7 +242,9 @@ class DriftBackupNotifier extends StateNotifier<DriftBackupState> {
     switch (update.status) {
       case TaskStatus.complete:
         if (update.task.group == kBackupGroup) {
-          state = state.copyWith(backupCount: state.backupCount + 1, remainderCount: state.remainderCount - 1);
+          if (update.responseStatusCode == 201) {
+            state = state.copyWith(backupCount: state.backupCount + 1, remainderCount: state.remainderCount - 1);
+          }
         }
 
         // Remove the completed task from the upload items
@@ -311,13 +320,14 @@ class DriftBackupNotifier extends StateNotifier<DriftBackupState> {
   }
 
   Future<void> getBackupStatus(String userId) async {
-    final [totalCount, backupCount, remainderCount] = await Future.wait([
-      _uploadService.getBackupTotalCount(),
-      _uploadService.getBackupFinishedCount(userId),
-      _uploadService.getBackupRemainderCount(userId),
-    ]);
+    final counts = await _uploadService.getBackupCounts(userId);
 
-    state = state.copyWith(totalCount: totalCount, backupCount: backupCount, remainderCount: remainderCount);
+    state = state.copyWith(
+      totalCount: counts.total,
+      backupCount: counts.total - counts.remainder,
+      remainderCount: counts.remainder,
+      processingCount: counts.processing,
+    );
   }
 
   Future<void> startBackup(String userId) {

mobile/lib/providers/infrastructure/action.provider.dart

@@ -342,11 +342,11 @@ class ActionNotifier extends Notifier<void> {
     }
   }
 
-  Future<ActionResult> shareAssets(ActionSource source) async {
+  Future<ActionResult> shareAssets(ActionSource source, BuildContext context) async {
     final ids = _getAssets(source).toList(growable: false);
 
     try {
-      await _service.shareAssets(ids);
+      await _service.shareAssets(ids, context);
       return ActionResult(count: ids.length, success: true);
     } catch (error, stack) {
       _logger.severe('Failed to share assets', error, stack);
@@ -356,7 +356,6 @@ class ActionNotifier extends Notifier<void> {
 
   Future<ActionResult> downloadAll(ActionSource source) async {
     final assets = _getAssets(source).whereType<RemoteAsset>().toList(growable: false);
-
     try {
       final didEnqueue = await _service.downloadAll(assets);
       final enqueueCount = didEnqueue.where((e) => e).length;

mobile/lib/providers/infrastructure/platform.provider.dart

@@ -1,12 +1,17 @@
 import 'package:hooks_riverpod/hooks_riverpod.dart';
 import 'package:immich_mobile/domain/services/background_worker.service.dart';
 import 'package:immich_mobile/platform/background_worker_api.g.dart';
+import 'package:immich_mobile/platform/background_worker_lock_api.g.dart';
 import 'package:immich_mobile/platform/connectivity_api.g.dart';
 import 'package:immich_mobile/platform/native_sync_api.g.dart';
 import 'package:immich_mobile/platform/thumbnail_api.g.dart';
 
 final backgroundWorkerFgServiceProvider = Provider((_) => BackgroundWorkerFgService(BackgroundWorkerFgHostApi()));
 
+final backgroundWorkerLockServiceProvider = Provider<BackgroundWorkerLockService>(
+  (_) => BackgroundWorkerLockService(BackgroundWorkerLockApi()),
+);
+
 final nativeSyncApiProvider = Provider<NativeSyncApi>((_) => NativeSyncApi());
 
 final connectivityApiProvider = Provider<ConnectivityApi>((_) => ConnectivityApi());

mobile/lib/providers/infrastructure/sync.provider.dart

@@ -10,7 +10,6 @@ import 'package:immich_mobile/providers/infrastructure/asset.provider.dart';
 import 'package:immich_mobile/providers/infrastructure/cancel.provider.dart';
 import 'package:immich_mobile/providers/infrastructure/db.provider.dart';
 import 'package:immich_mobile/providers/infrastructure/platform.provider.dart';
-import 'package:immich_mobile/providers/infrastructure/storage.provider.dart';
 
 final syncStreamServiceProvider = Provider(
   (ref) => SyncStreamService(
@@ -35,7 +34,6 @@ final hashServiceProvider = Provider(
   (ref) => HashService(
     localAlbumRepository: ref.watch(localAlbumRepository),
     localAssetRepository: ref.watch(localAssetRepository),
-    storageRepository: ref.watch(storageRepositoryProvider),
     nativeSyncApi: ref.watch(nativeSyncApiProvider),
   ),
 );

mobile/lib/repositories/asset_media.repository.dart

@@ -1,17 +1,19 @@
 import 'dart:io';
 
+import 'package:flutter/widgets.dart';
 import 'package:hooks_riverpod/hooks_riverpod.dart';
+import 'package:immich_mobile/domain/models/asset/base_asset.model.dart';
 import 'package:immich_mobile/domain/models/exif.model.dart';
 import 'package:immich_mobile/domain/models/store.model.dart';
 import 'package:immich_mobile/entities/asset.entity.dart' as asset_entity;
 import 'package:immich_mobile/entities/store.entity.dart';
+import 'package:immich_mobile/extensions/build_context_extensions.dart';
+import 'package:immich_mobile/extensions/response_extensions.dart';
 import 'package:immich_mobile/repositories/asset_api.repository.dart';
 import 'package:immich_mobile/utils/hash.dart';
 import 'package:logging/logging.dart';
 import 'package:path_provider/path_provider.dart';
 import 'package:photo_manager/photo_manager.dart';
-import 'package:immich_mobile/domain/models/asset/base_asset.model.dart';
-import 'package:immich_mobile/extensions/response_extensions.dart';
 import 'package:share_plus/share_plus.dart';
 
 final assetMediaRepositoryProvider = Provider((ref) => AssetMediaRepository(ref.watch(assetApiRepositoryProvider)));
@@ -68,7 +70,7 @@ class AssetMediaRepository {
   }
 
   // TODO: make this more efficient
-  Future<int> shareAssets(List<BaseAsset> assets) async {
+  Future<int> shareAssets(List<BaseAsset> assets, BuildContext context) async {
     final downloadedXFiles = <XFile>[];
 
     for (var asset in assets) {
@@ -105,8 +107,12 @@ class AssetMediaRepository {
     }
 
     // we dont want to await the share result since the
-    // "preparing" dialog will not disappear unti
-    Share.shareXFiles(downloadedXFiles).then((result) async {
+    // "preparing" dialog will not disappear until
+    final size = context.sizeData;
+    Share.shareXFiles(
+      downloadedXFiles,
+      sharePositionOrigin: Rect.fromPoints(Offset.zero, Offset(size.width / 3, size.height)),
+    ).then((result) async {
       for (var file in downloadedXFiles) {
         try {
           await File(file.path).delete();

mobile/lib/repositories/download.repository.dart

@@ -90,7 +90,11 @@ class DownloadRepository {
       final isVideo = asset.isVideo;
       final url = getOriginalUrlForRemoteId(id);
 
-      if (Platform.isAndroid || livePhotoVideoId == null || isVideo) {
+      // on iOS it cannot link the image, check if the filename has .MP extension
+      // to avoid downloading the video part
+      final isAndroidMotionPhoto = asset.name.contains(".MP");
+
+      if (Platform.isAndroid || livePhotoVideoId == null || isVideo || isAndroidMotionPhoto) {
         tasks[taskIndex++] = DownloadTask(
           taskId: id,
           url: url,

mobile/lib/routing/router.dart

@@ -81,6 +81,7 @@ import 'package:immich_mobile/pages/share_intent/share_intent.page.dart';
 import 'package:immich_mobile/presentation/pages/dev/feat_in_development.page.dart';
 import 'package:immich_mobile/presentation/pages/dev/main_timeline.page.dart';
 import 'package:immich_mobile/presentation/pages/dev/media_stat.page.dart';
+import 'package:immich_mobile/presentation/pages/download_info.page.dart';
 import 'package:immich_mobile/presentation/pages/drift_activities.page.dart';
 import 'package:immich_mobile/presentation/pages/drift_album.page.dart';
 import 'package:immich_mobile/presentation/pages/drift_album_options.page.dart';
@@ -345,6 +346,7 @@ class AppRouter extends RootStackRouter {
     AutoRoute(page: DriftActivitiesRoute.page, guards: [_authGuard, _duplicateGuard]),
     AutoRoute(page: DriftBackupAssetDetailRoute.page, guards: [_authGuard, _duplicateGuard]),
     AutoRoute(page: AssetTroubleshootRoute.page, guards: [_authGuard, _duplicateGuard]),
+    AutoRoute(page: DownloadInfoRoute.page, guards: [_authGuard, _duplicateGuard]),
     // required to handle all deeplinks in deep_link.service.dart
     // auto_route_library#1722
     RedirectRoute(path: '*', redirectTo: '/'),

mobile/lib/routing/router.gr.dart

@@ -688,6 +688,22 @@ class CropImageRouteArgs {
   }
 }
 
+/// generated route for
+/// [DownloadInfoPage]
+class DownloadInfoRoute extends PageRouteInfo<void> {
+  const DownloadInfoRoute({List<PageRouteInfo>? children})
+    : super(DownloadInfoRoute.name, initialChildren: children);
+
+  static const String name = 'DownloadInfoRoute';
+
+  static PageInfo page = PageInfo(
+    name,
+    builder: (data) {
+      return const DownloadInfoPage();
+    },
+  );
+}
+
 /// generated route for
 /// [DriftActivitiesPage]
 class DriftActivitiesRoute extends PageRouteInfo<void> {

mobile/lib/services/action.service.dart

@@ -1,7 +1,6 @@
-import 'package:hooks_riverpod/hooks_riverpod.dart';
-import 'package:immich_mobile/repositories/download.repository.dart';
 import 'package:auto_route/auto_route.dart';
 import 'package:flutter/material.dart';
+import 'package:hooks_riverpod/hooks_riverpod.dart';
 import 'package:immich_mobile/constants/enums.dart';
 import 'package:immich_mobile/domain/models/asset/base_asset.model.dart';
 import 'package:immich_mobile/infrastructure/repositories/local_asset.repository.dart';
@@ -11,6 +10,7 @@ import 'package:immich_mobile/providers/infrastructure/album.provider.dart';
 import 'package:immich_mobile/providers/infrastructure/asset.provider.dart';
 import 'package:immich_mobile/repositories/asset_api.repository.dart';
 import 'package:immich_mobile/repositories/asset_media.repository.dart';
+import 'package:immich_mobile/repositories/download.repository.dart';
 import 'package:immich_mobile/repositories/drift_album_api_repository.dart';
 import 'package:immich_mobile/routing/router.dart';
 import 'package:immich_mobile/widgets/common/date_time_picker.dart';
@@ -199,14 +199,11 @@ class ActionService {
   }
 
   Future<int> removeFromAlbum(List<String> remoteIds, String albumId) async {
-    int removedCount = 0;
     final result = await _albumApiRepository.removeAssets(albumId, remoteIds);
-
     if (result.removed.isNotEmpty) {
-      removedCount = await _remoteAlbumRepository.removeAssets(albumId, result.removed);
+      await _remoteAlbumRepository.removeAssets(albumId, result.removed);
     }
-
-    return removedCount;
+    return result.removed.length;
   }
 
   Future<bool> updateDescription(String assetId, String description) async {
@@ -227,8 +224,8 @@ class ActionService {
     await _assetApiRepository.unStack(stackIds);
   }
 
-  Future<int> shareAssets(List<BaseAsset> assets) {
-    return _assetMediaRepository.shareAssets(assets);
+  Future<int> shareAssets(List<BaseAsset> assets, BuildContext context) {
+    return _assetMediaRepository.shareAssets(assets, context);
   }
 
   Future<List<bool>> downloadAll(List<RemoteAsset> assets) {

mobile/lib/services/hash.service.dart

@@ -16,9 +16,10 @@ class HashService {
     required IsarDeviceAssetRepository deviceAssetRepository,
     required BackgroundService backgroundService,
     this.batchSizeLimit = kBatchHashSizeLimit,
-    this.batchFileLimit = kBatchHashFileLimit,
+    int? batchFileLimit,
   }) : _deviceAssetRepository = deviceAssetRepository,
-       _backgroundService = backgroundService;
+       _backgroundService = backgroundService,
+       batchFileLimit = batchFileLimit ?? kBatchHashFileLimit;
 
   final IsarDeviceAssetRepository _deviceAssetRepository;
   final BackgroundService _backgroundService;

mobile/lib/services/upload.service.dart

@@ -89,16 +89,8 @@ class UploadService {
     return _uploadRepository.getActiveTasks(group);
   }
 
-  Future<int> getBackupTotalCount() {
-    return _backupRepository.getTotalCount();
-  }
-
-  Future<int> getBackupRemainderCount(String userId) {
-    return _backupRepository.getRemainderCount(userId);
-  }
-
-  Future<int> getBackupFinishedCount(String userId) {
-    return _backupRepository.getBackupCount(userId);
+  Future<({int total, int remainder, int processing})> getBackupCounts(String userId) {
+    return _backupRepository.getAllCounts(userId);
   }
 
   Future<void> manualBackup(List<LocalAsset> localAssets) async {

mobile/lib/utils/migration.dart

@@ -62,30 +62,7 @@ Future<void> migrateDatabaseIfNeeded(Isar db, Drift drift) async {
     await Store.populateCache();
   }
 
-  // Handle migration only for this version
-  // TODO: remove when old timeline is removed
-  final needBetaMigration = Store.tryGet(StoreKey.needBetaMigration);
-  if (version >= 15 && needBetaMigration == null) {
-    // Check both databases directly instead of relying on cache
-
-    final isBeta = Store.tryGet(StoreKey.betaTimeline);
-    final isNewInstallation = await _isNewInstallation(db, drift);
-
-    // For new installations, no migration needed
-    // For existing installations, only migrate if beta timeline is not enabled (null or false)
-    if (isNewInstallation || isBeta == true || (version > 15 && isBeta == null)) {
-      await Store.put(StoreKey.needBetaMigration, false);
-      await Store.put(StoreKey.betaTimeline, true);
-    } else {
-      await drift.reset();
-      await Store.put(StoreKey.needBetaMigration, true);
-    }
-  }
-
-  if (version < 16) {
-    await SyncStreamRepository(drift).reset();
-    await Store.put(StoreKey.shouldResetSync, true);
-  }
+  await handleBetaMigration(version, await _isNewInstallation(db, drift), SyncStreamRepository(drift));
 
   if (targetVersion >= 12) {
     await Store.put(StoreKey.version, targetVersion);
@@ -99,6 +76,37 @@ Future<void> migrateDatabaseIfNeeded(Isar db, Drift drift) async {
   }
 }
 
+Future<void> handleBetaMigration(int version, bool isNewInstallation, SyncStreamRepository syncStreamRepository) async {
+  // Handle migration only for this version
+  // TODO: remove when old timeline is removed
+  final isBeta = Store.tryGet(StoreKey.betaTimeline);
+  final needBetaMigration = Store.tryGet(StoreKey.needBetaMigration);
+  if (version <= 15 && needBetaMigration == null) {
+    // For new installations, no migration needed
+    // For existing installations, only migrate if beta timeline is not enabled (null or false)
+    if (isNewInstallation || isBeta == true) {
+      await Store.put(StoreKey.needBetaMigration, false);
+      await Store.put(StoreKey.betaTimeline, true);
+    } else {
+      await Store.put(StoreKey.needBetaMigration, true);
+    }
+  }
+
+  if (version > 15) {
+    if (isBeta == null || isBeta) {
+      await Store.put(StoreKey.needBetaMigration, false);
+      await Store.put(StoreKey.betaTimeline, true);
+    } else {
+      await Store.put(StoreKey.needBetaMigration, false);
+    }
+  }
+
+  if (version < 16) {
+    await syncStreamRepository.reset();
+    await Store.put(StoreKey.shouldResetSync, true);
+  }
+}
+
 Future<bool> _isNewInstallation(Isar db, Drift drift) async {
   try {
     final isarUserCount = await db.users.count();

mobile/lib/widgets/backup/backup_info_card.dart

@@ -8,8 +8,17 @@ class BackupInfoCard extends StatelessWidget {
   final String title;
   final String subtitle;
   final String info;
+
   final VoidCallback? onTap;
-  const BackupInfoCard({super.key, required this.title, required this.subtitle, required this.info, this.onTap});
+  final bool isLoading;
+  const BackupInfoCard({
+    super.key,
+    required this.title,
+    required this.subtitle,
+    required this.info,
+    this.onTap,
+    this.isLoading = false,
+  });
 
   @override
   Widget build(BuildContext context) {
@@ -38,8 +47,36 @@ class BackupInfoCard extends StatelessWidget {
             trailing: Column(
               mainAxisAlignment: MainAxisAlignment.center,
               children: [
-                Text(info, style: context.textTheme.titleLarge),
-                Text("backup_info_card_assets", style: context.textTheme.labelLarge).tr(),
+                Stack(
+                  children: [
+                    Text(
+                      info,
+                      style: context.textTheme.titleLarge?.copyWith(
+                        color: context.colorScheme.onSurface.withAlpha(isLoading ? 50 : 255),
+                      ),
+                    ),
+                    if (isLoading)
+                      Positioned.fill(
+                        child: Align(
+                          alignment: Alignment.center,
+                          child: SizedBox(
+                            width: 16,
+                            height: 16,
+                            child: CircularProgressIndicator(
+                              strokeWidth: 2,
+                              color: context.colorScheme.onSurface.withAlpha(150),
+                            ),
+                          ),
+                        ),
+                      ),
+                  ],
+                ),
+                Text(
+                  "backup_info_card_assets",
+                  style: context.textTheme.labelLarge?.copyWith(
+                    color: context.colorScheme.onSurface.withAlpha(isLoading ? 50 : 255),
+                  ),
+                ).tr(),
               ],
             ),
           ),

mobile/lib/widgets/forms/login/login_form.dart

@@ -19,6 +19,7 @@ import 'package:immich_mobile/providers/backup/backup.provider.dart';
 import 'package:immich_mobile/providers/gallery_permission.provider.dart';
 import 'package:immich_mobile/providers/oauth.provider.dart';
 import 'package:immich_mobile/providers/server_info.provider.dart';
+import 'package:immich_mobile/providers/websocket.provider.dart';
 import 'package:immich_mobile/routing/router.dart';
 import 'package:immich_mobile/utils/provider_utils.dart';
 import 'package:immich_mobile/utils/url_helper.dart';
@@ -193,6 +194,7 @@ class LoginForm extends HookConsumerWidget {
           if (isBeta) {
             await ref.read(galleryPermissionNotifier.notifier).requestGalleryPermission();
             handleSyncFlow();
+            ref.read(websocketProvider.notifier).connect();
             context.replaceRoute(const TabShellRoute());
             return;
           }

mobile/makefile

@@ -9,10 +9,12 @@ 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 run pigeon --input pigeon/background_worker_lock_api.dart
 	dart run pigeon --input pigeon/connectivity_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
+	dart format lib/platform/background_worker_lock_api.g.dart
 	dart format lib/platform/connectivity_api.g.dart
 
 watch:

mobile/openapi/README.md

@@ -3,7 +3,7 @@ Immich API
 
 This Dart package is automatically generated by the [OpenAPI Generator](https://openapi-generator.tech) project:
 
-- API version: 1.142.1
+- API version: 1.143.0
 - Generator version: 7.8.0
 - Build package: org.openapitools.codegen.languages.DartClientCodegen
 
@@ -393,6 +393,7 @@ Class | Method | HTTP request | Description
  - [LoginCredentialDto](doc//LoginCredentialDto.md)
  - [LoginResponseDto](doc//LoginResponseDto.md)
  - [LogoutResponseDto](doc//LogoutResponseDto.md)
+ - [MachineLearningAvailabilityChecksDto](doc//MachineLearningAvailabilityChecksDto.md)
  - [ManualJobName](doc//ManualJobName.md)
  - [MapMarkerResponseDto](doc//MapMarkerResponseDto.md)
  - [MapReverseGeocodeResponseDto](doc//MapReverseGeocodeResponseDto.md)

mobile/openapi/lib/api.dart

@@ -164,6 +164,7 @@ part 'model/log_level.dart';
 part 'model/login_credential_dto.dart';
 part 'model/login_response_dto.dart';
 part 'model/logout_response_dto.dart';
+part 'model/machine_learning_availability_checks_dto.dart';
 part 'model/manual_job_name.dart';
 part 'model/map_marker_response_dto.dart';
 part 'model/map_reverse_geocode_response_dto.dart';

mobile/openapi/lib/api_client.dart

@@ -382,6 +382,8 @@ class ApiClient {
           return LoginResponseDto.fromJson(value);
         case 'LogoutResponseDto':
           return LogoutResponseDto.fromJson(value);
+        case 'MachineLearningAvailabilityChecksDto':
+          return MachineLearningAvailabilityChecksDto.fromJson(value);
         case 'ManualJobName':
           return ManualJobNameTypeTransformer().decode(value);
         case 'MapMarkerResponseDto':

mobile/openapi/lib/model/machine_learning_availability_checks_dto.dart

@@ -0,0 +1,115 @@
+//
+// AUTO-GENERATED FILE, DO NOT MODIFY!
+//
+// @dart=2.18
+
+// ignore_for_file: unused_element, unused_import
+// ignore_for_file: always_put_required_named_parameters_first
+// ignore_for_file: constant_identifier_names
+// ignore_for_file: lines_longer_than_80_chars
+
+part of openapi.api;
+
+class MachineLearningAvailabilityChecksDto {
+  /// Returns a new [MachineLearningAvailabilityChecksDto] instance.
+  MachineLearningAvailabilityChecksDto({
+    required this.enabled,
+    required this.interval,
+    required this.timeout,
+  });
+
+  bool enabled;
+
+  num interval;
+
+  num timeout;
+
+  @override
+  bool operator ==(Object other) => identical(this, other) || other is MachineLearningAvailabilityChecksDto &&
+    other.enabled == enabled &&
+    other.interval == interval &&
+    other.timeout == timeout;
+
+  @override
+  int get hashCode =>
+    // ignore: unnecessary_parenthesis
+    (enabled.hashCode) +
+    (interval.hashCode) +
+    (timeout.hashCode);
+
+  @override
+  String toString() => 'MachineLearningAvailabilityChecksDto[enabled=$enabled, interval=$interval, timeout=$timeout]';
+
+  Map<String, dynamic> toJson() {
+    final json = <String, dynamic>{};
+      json[r'enabled'] = this.enabled;
+      json[r'interval'] = this.interval;
+      json[r'timeout'] = this.timeout;
+    return json;
+  }
+
+  /// Returns a new [MachineLearningAvailabilityChecksDto] instance and imports its values from
+  /// [value] if it's a [Map], null otherwise.
+  // ignore: prefer_constructors_over_static_methods
+  static MachineLearningAvailabilityChecksDto? fromJson(dynamic value) {
+    upgradeDto(value, "MachineLearningAvailabilityChecksDto");
+    if (value is Map) {
+      final json = value.cast<String, dynamic>();
+
+      return MachineLearningAvailabilityChecksDto(
+        enabled: mapValueOfType<bool>(json, r'enabled')!,
+        interval: num.parse('${json[r'interval']}'),
+        timeout: num.parse('${json[r'timeout']}'),
+      );
+    }
+    return null;
+  }
+
+  static List<MachineLearningAvailabilityChecksDto> listFromJson(dynamic json, {bool growable = false,}) {
+    final result = <MachineLearningAvailabilityChecksDto>[];
+    if (json is List && json.isNotEmpty) {
+      for (final row in json) {
+        final value = MachineLearningAvailabilityChecksDto.fromJson(row);
+        if (value != null) {
+          result.add(value);
+        }
+      }
+    }
+    return result.toList(growable: growable);
+  }
+
+  static Map<String, MachineLearningAvailabilityChecksDto> mapFromJson(dynamic json) {
+    final map = <String, MachineLearningAvailabilityChecksDto>{};
+    if (json is Map && json.isNotEmpty) {
+      json = json.cast<String, dynamic>(); // ignore: parameter_assignments
+      for (final entry in json.entries) {
+        final value = MachineLearningAvailabilityChecksDto.fromJson(entry.value);
+        if (value != null) {
+          map[entry.key] = value;
+        }
+      }
+    }
+    return map;
+  }
+
+  // maps a json object with a list of MachineLearningAvailabilityChecksDto-objects as value to a dart map
+  static Map<String, List<MachineLearningAvailabilityChecksDto>> mapListFromJson(dynamic json, {bool growable = false,}) {
+    final map = <String, List<MachineLearningAvailabilityChecksDto>>{};
+    if (json is Map && json.isNotEmpty) {
+      // ignore: parameter_assignments
+      json = json.cast<String, dynamic>();
+      for (final entry in json.entries) {
+        map[entry.key] = MachineLearningAvailabilityChecksDto.listFromJson(entry.value, growable: growable,);
+      }
+    }
+    return map;
+  }
+
+  /// The list of required keys that must be present in a JSON.
+  static const requiredKeys = <String>{
+    'enabled',
+    'interval',
+    'timeout',
+  };
+}
+

mobile/openapi/lib/model/system_config_machine_learning_dto.dart

@@ -13,14 +13,16 @@ part of openapi.api;
 class SystemConfigMachineLearningDto {
   /// Returns a new [SystemConfigMachineLearningDto] instance.
   SystemConfigMachineLearningDto({
+    required this.availabilityChecks,
     required this.clip,
     required this.duplicateDetection,
     required this.enabled,
     required this.facialRecognition,
-    this.url,
     this.urls = const [],
   });
 
+  MachineLearningAvailabilityChecksDto availabilityChecks;
+
   CLIPConfig clip;
 
   DuplicateDetectionConfig duplicateDetection;
@@ -29,50 +31,37 @@ class SystemConfigMachineLearningDto {
 
   FacialRecognitionConfig facialRecognition;
 
-  /// This property was deprecated in v1.122.0
-  ///
-  /// Please note: This property should have been non-nullable! Since the specification file
-  /// does not include a default value (using the "default:" property), however, the generated
-  /// source code must fall back to having a nullable type.
-  /// Consider adding a "default:" property in the specification file to hide this note.
-  ///
-  String? url;
-
   List<String> urls;
 
   @override
   bool operator ==(Object other) => identical(this, other) || other is SystemConfigMachineLearningDto &&
+    other.availabilityChecks == availabilityChecks &&
     other.clip == clip &&
     other.duplicateDetection == duplicateDetection &&
     other.enabled == enabled &&
     other.facialRecognition == facialRecognition &&
-    other.url == url &&
     _deepEquality.equals(other.urls, urls);
 
   @override
   int get hashCode =>
     // ignore: unnecessary_parenthesis
+    (availabilityChecks.hashCode) +
     (clip.hashCode) +
     (duplicateDetection.hashCode) +
     (enabled.hashCode) +
     (facialRecognition.hashCode) +
-    (url == null ? 0 : url!.hashCode) +
     (urls.hashCode);
 
   @override
-  String toString() => 'SystemConfigMachineLearningDto[clip=$clip, duplicateDetection=$duplicateDetection, enabled=$enabled, facialRecognition=$facialRecognition, url=$url, urls=$urls]';
+  String toString() => 'SystemConfigMachineLearningDto[availabilityChecks=$availabilityChecks, clip=$clip, duplicateDetection=$duplicateDetection, enabled=$enabled, facialRecognition=$facialRecognition, urls=$urls]';
 
   Map<String, dynamic> toJson() {
     final json = <String, dynamic>{};
+      json[r'availabilityChecks'] = this.availabilityChecks;
       json[r'clip'] = this.clip;
       json[r'duplicateDetection'] = this.duplicateDetection;
       json[r'enabled'] = this.enabled;
       json[r'facialRecognition'] = this.facialRecognition;
-    if (this.url != null) {
-      json[r'url'] = this.url;
-    } else {
-    //  json[r'url'] = null;
-    }
       json[r'urls'] = this.urls;
     return json;
   }
@@ -86,11 +75,11 @@ class SystemConfigMachineLearningDto {
       final json = value.cast<String, dynamic>();
 
       return SystemConfigMachineLearningDto(
+        availabilityChecks: MachineLearningAvailabilityChecksDto.fromJson(json[r'availabilityChecks'])!,
         clip: CLIPConfig.fromJson(json[r'clip'])!,
         duplicateDetection: DuplicateDetectionConfig.fromJson(json[r'duplicateDetection'])!,
         enabled: mapValueOfType<bool>(json, r'enabled')!,
         facialRecognition: FacialRecognitionConfig.fromJson(json[r'facialRecognition'])!,
-        url: mapValueOfType<String>(json, r'url'),
         urls: json[r'urls'] is Iterable
             ? (json[r'urls'] as Iterable).cast<String>().toList(growable: false)
             : const [],
@@ -141,6 +130,7 @@ class SystemConfigMachineLearningDto {
 
   /// The list of required keys that must be present in a JSON.
   static const requiredKeys = <String>{
+    'availabilityChecks',
     'clip',
     'duplicateDetection',
     'enabled',

mobile/pigeon/background_worker_lock_api.dart

@@ -0,0 +1,17 @@
+import 'package:pigeon/pigeon.dart';
+
+@ConfigurePigeon(
+  PigeonOptions(
+    dartOut: 'lib/platform/background_worker_lock_api.g.dart',
+    kotlinOut: 'android/app/src/main/kotlin/app/alextran/immich/background/BackgroundWorkerLock.g.kt',
+    kotlinOptions: KotlinOptions(package: 'app.alextran.immich.background', includeErrorClass: false),
+    dartOptions: DartOptions(),
+    dartPackageName: 'immich_mobile',
+  ),
+)
+@HostApi()
+abstract class BackgroundWorkerLockApi {
+  void lock();
+
+  void unlock();
+}

mobile/pigeon/native_sync_api.dart

@@ -71,6 +71,14 @@ class SyncDelta {
   });
 }
 
+class HashResult {
+  final String assetId;
+  final String? error;
+  final String? hash;
+
+  const HashResult({required this.assetId, this.error, this.hash});
+}
+
 @HostApi()
 abstract class NativeSyncApi {
   bool shouldFullSync();
@@ -94,6 +102,9 @@ abstract class NativeSyncApi {
   @TaskQueue(type: TaskQueueType.serialBackgroundThread)
   List<PlatformAsset> getAssetsForAlbum(String albumId, {int? updatedTimeCond});
 
+  @async
   @TaskQueue(type: TaskQueueType.serialBackgroundThread)
-  List<Uint8List?> hashPaths(List<String> paths);
+  List<HashResult> hashAssets(List<String> assetIds, {bool allowNetworkAccess = false});
+
+  void cancelHashing();
 }

mobile/pubspec.yaml

@@ -2,7 +2,7 @@ name: immich_mobile
 description: Immich - selfhosted backup media file on mobile phone
 
 publish_to: 'none'
-version: 1.142.1+3015
+version: 1.143.0+3016
 
 environment:
   sdk: '>=3.8.0 <4.0.0'

mobile/test/domain/services/hash_service_test.dart

@@ -1,11 +1,7 @@
-import 'dart:convert';
-import 'dart:io';
-import 'dart:typed_data';
-
 import 'package:flutter_test/flutter_test.dart';
-import 'package:immich_mobile/domain/models/asset/base_asset.model.dart';
+import 'package:immich_mobile/domain/models/album/local_album.model.dart';
 import 'package:immich_mobile/domain/services/hash.service.dart';
-import 'package:immich_mobile/infrastructure/repositories/local_album.repository.dart';
+import 'package:immich_mobile/platform/native_sync_api.g.dart';
 import 'package:mocktail/mocktail.dart';
 
 import '../../fixtures/album.stub.dart';
@@ -13,192 +9,137 @@ import '../../fixtures/asset.stub.dart';
 import '../../infrastructure/repository.mock.dart';
 import '../service.mock.dart';
 
-class MockFile extends Mock implements File {}
-
 void main() {
   late HashService sut;
   late MockLocalAlbumRepository mockAlbumRepo;
   late MockLocalAssetRepository mockAssetRepo;
-  late MockStorageRepository mockStorageRepo;
   late MockNativeSyncApi mockNativeApi;
-  final sortBy = {SortLocalAlbumsBy.backupSelection, SortLocalAlbumsBy.isIosSharedAlbum};
 
   setUp(() {
     mockAlbumRepo = MockLocalAlbumRepository();
     mockAssetRepo = MockLocalAssetRepository();
-    mockStorageRepo = MockStorageRepository();
     mockNativeApi = MockNativeSyncApi();
 
     sut = HashService(
       localAlbumRepository: mockAlbumRepo,
       localAssetRepository: mockAssetRepo,
-      storageRepository: mockStorageRepo,
       nativeSyncApi: mockNativeApi,
     );
 
     registerFallbackValue(LocalAlbumStub.recent);
     registerFallbackValue(LocalAssetStub.image1);
+    registerFallbackValue(<String, String>{});
 
     when(() => mockAssetRepo.updateHashes(any())).thenAnswer((_) async => {});
-    when(() => mockStorageRepo.clearCache()).thenAnswer((_) async => {});
   });
 
   group('HashService hashAssets', () {
     test('skips albums with no assets to hash', () async {
       when(
-        () => mockAlbumRepo.getAll(sortBy: sortBy),
+        () => mockAlbumRepo.getBackupAlbums(),
       ).thenAnswer((_) async => [LocalAlbumStub.recent.copyWith(assetCount: 0)]);
       when(() => mockAlbumRepo.getAssetsToHash(LocalAlbumStub.recent.id)).thenAnswer((_) async => []);
 
       await sut.hashAssets();
 
-      verifyNever(() => mockStorageRepo.getFileForAsset(any()));
-      verifyNever(() => mockNativeApi.hashPaths(any()));
+      verifyNever(() => mockNativeApi.hashAssets(any(), allowNetworkAccess: any(named: 'allowNetworkAccess')));
     });
   });
 
   group('HashService _hashAssets', () {
-    test('skips assets without files', () async {
+    test('skips empty batches', () async {
       final album = LocalAlbumStub.recent;
-      final asset = LocalAssetStub.image1;
-      when(() => mockAlbumRepo.getAll(sortBy: sortBy)).thenAnswer((_) async => [album]);
-      when(() => mockAlbumRepo.getAssetsToHash(album.id)).thenAnswer((_) async => [asset]);
-      when(() => mockStorageRepo.getFileForAsset(asset.id)).thenAnswer((_) async => null);
+      when(() => mockAlbumRepo.getBackupAlbums()).thenAnswer((_) async => [album]);
+      when(() => mockAlbumRepo.getAssetsToHash(album.id)).thenAnswer((_) async => []);
 
       await sut.hashAssets();
 
-      verifyNever(() => mockNativeApi.hashPaths(any()));
+      verifyNever(() => mockNativeApi.hashAssets(any(), allowNetworkAccess: any(named: 'allowNetworkAccess')));
     });
 
     test('processes assets when available', () async {
       final album = LocalAlbumStub.recent;
       final asset = LocalAssetStub.image1;
-      final mockFile = MockFile();
-      final hash = Uint8List.fromList(List.generate(20, (i) => i));
 
-      when(() => mockFile.length()).thenAnswer((_) async => 1000);
-      when(() => mockFile.path).thenReturn('image-path');
-
-      when(() => mockAlbumRepo.getAll(sortBy: sortBy)).thenAnswer((_) async => [album]);
+      when(() => mockAlbumRepo.getBackupAlbums()).thenAnswer((_) async => [album]);
       when(() => mockAlbumRepo.getAssetsToHash(album.id)).thenAnswer((_) async => [asset]);
-      when(() => mockStorageRepo.getFileForAsset(asset.id)).thenAnswer((_) async => mockFile);
-      when(() => mockNativeApi.hashPaths(['image-path'])).thenAnswer((_) async => [hash]);
+      when(
+        () => mockNativeApi.hashAssets([asset.id], allowNetworkAccess: false),
+      ).thenAnswer((_) async => [HashResult(assetId: asset.id, hash: 'test-hash')]);
 
       await sut.hashAssets();
 
-      verify(() => mockNativeApi.hashPaths(['image-path'])).called(1);
-      final captured = verify(() => mockAssetRepo.updateHashes(captureAny())).captured.first as List<LocalAsset>;
+      verify(() => mockNativeApi.hashAssets([asset.id], allowNetworkAccess: false)).called(1);
+      final captured = verify(() => mockAssetRepo.updateHashes(captureAny())).captured.first as Map<String, String>;
       expect(captured.length, 1);
-      expect(captured[0].checksum, base64.encode(hash));
+      expect(captured[asset.id], 'test-hash');
     });
 
     test('handles failed hashes', () async {
       final album = LocalAlbumStub.recent;
       final asset = LocalAssetStub.image1;
-      final mockFile = MockFile();
-      when(() => mockFile.length()).thenAnswer((_) async => 1000);
-      when(() => mockFile.path).thenReturn('image-path');
 
-      when(() => mockAlbumRepo.getAll(sortBy: sortBy)).thenAnswer((_) async => [album]);
+      when(() => mockAlbumRepo.getBackupAlbums()).thenAnswer((_) async => [album]);
       when(() => mockAlbumRepo.getAssetsToHash(album.id)).thenAnswer((_) async => [asset]);
-      when(() => mockStorageRepo.getFileForAsset(asset.id)).thenAnswer((_) async => mockFile);
-      when(() => mockNativeApi.hashPaths(['image-path'])).thenAnswer((_) async => [null]);
-      when(() => mockAssetRepo.updateHashes(any())).thenAnswer((_) async => {});
+      when(
+        () => mockNativeApi.hashAssets([asset.id], allowNetworkAccess: false),
+      ).thenAnswer((_) async => [HashResult(assetId: asset.id, error: 'Failed to hash')]);
 
       await sut.hashAssets();
 
-      final captured = verify(() => mockAssetRepo.updateHashes(captureAny())).captured.first as List<LocalAsset>;
+      final captured = verify(() => mockAssetRepo.updateHashes(captureAny())).captured.first as Map<String, String>;
       expect(captured.length, 0);
     });
 
-    test('handles invalid hash length', () async {
+    test('handles null hash results', () async {
       final album = LocalAlbumStub.recent;
       final asset = LocalAssetStub.image1;
-      final mockFile = MockFile();
-      when(() => mockFile.length()).thenAnswer((_) async => 1000);
-      when(() => mockFile.path).thenReturn('image-path');
 
-      when(() => mockAlbumRepo.getAll(sortBy: sortBy)).thenAnswer((_) async => [album]);
+      when(() => mockAlbumRepo.getBackupAlbums()).thenAnswer((_) async => [album]);
       when(() => mockAlbumRepo.getAssetsToHash(album.id)).thenAnswer((_) async => [asset]);
-      when(() => mockStorageRepo.getFileForAsset(asset.id)).thenAnswer((_) async => mockFile);
-
-      final invalidHash = Uint8List.fromList([1, 2, 3]);
-      when(() => mockNativeApi.hashPaths(['image-path'])).thenAnswer((_) async => [invalidHash]);
-      when(() => mockAssetRepo.updateHashes(any())).thenAnswer((_) async => {});
+      when(
+        () => mockNativeApi.hashAssets([asset.id], allowNetworkAccess: false),
+      ).thenAnswer((_) async => [HashResult(assetId: asset.id, hash: null)]);
 
       await sut.hashAssets();
 
-      final captured = verify(() => mockAssetRepo.updateHashes(captureAny())).captured.first as List<LocalAsset>;
+      final captured = verify(() => mockAssetRepo.updateHashes(captureAny())).captured.first as Map<String, String>;
       expect(captured.length, 0);
     });
 
-    test('batches by file count limit', () async {
-      final sut = HashService(
-        localAlbumRepository: mockAlbumRepo,
-        localAssetRepository: mockAssetRepo,
-        storageRepository: mockStorageRepo,
-        nativeSyncApi: mockNativeApi,
-        batchFileLimit: 1,
-      );
-
-      final album = LocalAlbumStub.recent;
-      final asset1 = LocalAssetStub.image1;
-      final asset2 = LocalAssetStub.image2;
-      final mockFile1 = MockFile();
-      final mockFile2 = MockFile();
-      when(() => mockFile1.length()).thenAnswer((_) async => 100);
-      when(() => mockFile1.path).thenReturn('path-1');
-      when(() => mockFile2.length()).thenAnswer((_) async => 100);
-      when(() => mockFile2.path).thenReturn('path-2');
-
-      when(() => mockAlbumRepo.getAll(sortBy: sortBy)).thenAnswer((_) async => [album]);
-      when(() => mockAlbumRepo.getAssetsToHash(album.id)).thenAnswer((_) async => [asset1, asset2]);
-      when(() => mockStorageRepo.getFileForAsset(asset1.id)).thenAnswer((_) async => mockFile1);
-      when(() => mockStorageRepo.getFileForAsset(asset2.id)).thenAnswer((_) async => mockFile2);
-
-      final hash = Uint8List.fromList(List.generate(20, (i) => i));
-      when(() => mockNativeApi.hashPaths(any())).thenAnswer((_) async => [hash]);
-      when(() => mockAssetRepo.updateHashes(any())).thenAnswer((_) async => {});
-
-      await sut.hashAssets();
-
-      verify(() => mockNativeApi.hashPaths(['path-1'])).called(1);
-      verify(() => mockNativeApi.hashPaths(['path-2'])).called(1);
-      verify(() => mockAssetRepo.updateHashes(any())).called(2);
-    });
-
     test('batches by size limit', () async {
+      const batchSize = 2;
       final sut = HashService(
         localAlbumRepository: mockAlbumRepo,
         localAssetRepository: mockAssetRepo,
-        storageRepository: mockStorageRepo,
         nativeSyncApi: mockNativeApi,
-        batchSizeLimit: 80,
+        batchSize: batchSize,
       );
 
       final album = LocalAlbumStub.recent;
       final asset1 = LocalAssetStub.image1;
       final asset2 = LocalAssetStub.image2;
-      final mockFile1 = MockFile();
-      final mockFile2 = MockFile();
-      when(() => mockFile1.length()).thenAnswer((_) async => 100);
-      when(() => mockFile1.path).thenReturn('path-1');
-      when(() => mockFile2.length()).thenAnswer((_) async => 100);
-      when(() => mockFile2.path).thenReturn('path-2');
+      final asset3 = LocalAssetStub.image1.copyWith(id: 'image3', name: 'image3.jpg');
 
-      when(() => mockAlbumRepo.getAll(sortBy: sortBy)).thenAnswer((_) async => [album]);
-      when(() => mockAlbumRepo.getAssetsToHash(album.id)).thenAnswer((_) async => [asset1, asset2]);
-      when(() => mockStorageRepo.getFileForAsset(asset1.id)).thenAnswer((_) async => mockFile1);
-      when(() => mockStorageRepo.getFileForAsset(asset2.id)).thenAnswer((_) async => mockFile2);
+      final capturedCalls = <List<String>>[];
 
-      final hash = Uint8List.fromList(List.generate(20, (i) => i));
-      when(() => mockNativeApi.hashPaths(any())).thenAnswer((_) async => [hash]);
       when(() => mockAssetRepo.updateHashes(any())).thenAnswer((_) async => {});
+      when(() => mockAlbumRepo.getBackupAlbums()).thenAnswer((_) async => [album]);
+      when(() => mockAlbumRepo.getAssetsToHash(album.id)).thenAnswer((_) async => [asset1, asset2, asset3]);
+      when(() => mockNativeApi.hashAssets(any(), allowNetworkAccess: any(named: 'allowNetworkAccess'))).thenAnswer((
+        invocation,
+      ) async {
+        final assetIds = invocation.positionalArguments[0] as List<String>;
+        capturedCalls.add(List<String>.from(assetIds));
+        return assetIds.map((id) => HashResult(assetId: id, hash: '$id-hash')).toList();
+      });
 
       await sut.hashAssets();
 
-      verify(() => mockNativeApi.hashPaths(['path-1'])).called(1);
-      verify(() => mockNativeApi.hashPaths(['path-2'])).called(1);
+      expect(capturedCalls.length, 2, reason: 'Should make exactly 2 calls to hashAssets');
+      expect(capturedCalls[0], [asset1.id, asset2.id], reason: 'First call should batch the first two assets');
+      expect(capturedCalls[1], [asset3.id], reason: 'Second call should have the remaining asset');
+
       verify(() => mockAssetRepo.updateHashes(any())).called(2);
     });
 
@@ -206,27 +147,43 @@ void main() {
       final album = LocalAlbumStub.recent;
       final asset1 = LocalAssetStub.image1;
       final asset2 = LocalAssetStub.image2;
-      final mockFile1 = MockFile();
-      final mockFile2 = MockFile();
-      when(() => mockFile1.length()).thenAnswer((_) async => 100);
-      when(() => mockFile1.path).thenReturn('path-1');
-      when(() => mockFile2.length()).thenAnswer((_) async => 100);
-      when(() => mockFile2.path).thenReturn('path-2');
 
-      when(() => mockAlbumRepo.getAll(sortBy: sortBy)).thenAnswer((_) async => [album]);
+      when(() => mockAlbumRepo.getBackupAlbums()).thenAnswer((_) async => [album]);
       when(() => mockAlbumRepo.getAssetsToHash(album.id)).thenAnswer((_) async => [asset1, asset2]);
-      when(() => mockStorageRepo.getFileForAsset(asset1.id)).thenAnswer((_) async => mockFile1);
-      when(() => mockStorageRepo.getFileForAsset(asset2.id)).thenAnswer((_) async => mockFile2);
-
-      final validHash = Uint8List.fromList(List.generate(20, (i) => i));
-      when(() => mockNativeApi.hashPaths(['path-1', 'path-2'])).thenAnswer((_) async => [validHash, null]);
-      when(() => mockAssetRepo.updateHashes(any())).thenAnswer((_) async => {});
+      when(() => mockNativeApi.hashAssets([asset1.id, asset2.id], allowNetworkAccess: false)).thenAnswer(
+        (_) async => [
+          HashResult(assetId: asset1.id, hash: 'asset1-hash'),
+          HashResult(assetId: asset2.id, error: 'Failed to hash asset2'),
+        ],
+      );
 
       await sut.hashAssets();
 
-      final captured = verify(() => mockAssetRepo.updateHashes(captureAny())).captured.first as List<LocalAsset>;
+      final captured = verify(() => mockAssetRepo.updateHashes(captureAny())).captured.first as Map<String, String>;
       expect(captured.length, 1);
-      expect(captured.first.id, asset1.id);
+      expect(captured[asset1.id], 'asset1-hash');
+    });
+
+    test('uses allowNetworkAccess based on album backup selection', () async {
+      final selectedAlbum = LocalAlbumStub.recent.copyWith(backupSelection: BackupSelection.selected);
+      final nonSelectedAlbum = LocalAlbumStub.recent.copyWith(id: 'album2', backupSelection: BackupSelection.excluded);
+      final asset1 = LocalAssetStub.image1;
+      final asset2 = LocalAssetStub.image2;
+
+      when(() => mockAlbumRepo.getBackupAlbums()).thenAnswer((_) async => [selectedAlbum, nonSelectedAlbum]);
+      when(() => mockAlbumRepo.getAssetsToHash(selectedAlbum.id)).thenAnswer((_) async => [asset1]);
+      when(() => mockAlbumRepo.getAssetsToHash(nonSelectedAlbum.id)).thenAnswer((_) async => [asset2]);
+      when(() => mockNativeApi.hashAssets(any(), allowNetworkAccess: any(named: 'allowNetworkAccess'))).thenAnswer((
+        invocation,
+      ) async {
+        final assetIds = invocation.positionalArguments[0] as List<String>;
+        return assetIds.map((id) => HashResult(assetId: id, hash: '$id-hash')).toList();
+      });
+
+      await sut.hashAssets();
+
+      verify(() => mockNativeApi.hashAssets([asset1.id], allowNetworkAccess: true)).called(1);
+      verify(() => mockNativeApi.hashAssets([asset2.id], allowNetworkAccess: false)).called(1);
     });
   });
 }

mobile/test/drift/main/generated/schema.dart

@@ -13,6 +13,7 @@ import 'schema_v7.dart' as v7;
 import 'schema_v8.dart' as v8;
 import 'schema_v9.dart' as v9;
 import 'schema_v10.dart' as v10;
+import 'schema_v11.dart' as v11;
 
 class GeneratedHelper implements SchemaInstantiationHelper {
   @override
@@ -38,10 +39,12 @@ class GeneratedHelper implements SchemaInstantiationHelper {
         return v9.DatabaseAtV9(db);
       case 10:
         return v10.DatabaseAtV10(db);
+      case 11:
+        return v11.DatabaseAtV11(db);
       default:
         throw MissingSchemaException(version, versions);
     }
   }
 
-  static const versions = const [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+  static const versions = const [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
 }

mobile/test/modules/utils/migration_test.dart

@@ -0,0 +1,131 @@
+import 'package:drift/drift.dart' hide isNull;
+import 'package:drift/native.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:immich_mobile/domain/models/store.model.dart';
+import 'package:immich_mobile/domain/services/store.service.dart';
+import 'package:immich_mobile/entities/store.entity.dart';
+import 'package:immich_mobile/infrastructure/repositories/db.repository.dart';
+import 'package:immich_mobile/infrastructure/repositories/store.repository.dart';
+import 'package:immich_mobile/infrastructure/repositories/sync_stream.repository.dart';
+import 'package:immich_mobile/utils/migration.dart';
+import 'package:mocktail/mocktail.dart';
+
+import '../../infrastructure/repository.mock.dart';
+
+void main() {
+  late Drift db;
+  late SyncStreamRepository mockSyncStreamRepository;
+
+  setUpAll(() async {
+    db = Drift(DatabaseConnection(NativeDatabase.memory(), closeStreamsSynchronously: true));
+    await StoreService.init(storeRepository: DriftStoreRepository(db));
+    mockSyncStreamRepository = MockSyncStreamRepository();
+    when(() => mockSyncStreamRepository.reset()).thenAnswer((_) async => {});
+  });
+
+  tearDown(() async {
+    await Store.clear();
+  });
+
+  group('handleBetaMigration Tests', () {
+    group("version < 15", () {
+      test('already on new timeline', () async {
+        await Store.put(StoreKey.betaTimeline, true);
+
+        await handleBetaMigration(14, false, mockSyncStreamRepository);
+
+        expect(Store.tryGet(StoreKey.betaTimeline), true);
+        expect(Store.tryGet(StoreKey.needBetaMigration), false);
+      });
+
+      test('already on old timeline', () async {
+        await Store.put(StoreKey.betaTimeline, false);
+
+        await handleBetaMigration(14, false, mockSyncStreamRepository);
+
+        expect(Store.tryGet(StoreKey.needBetaMigration), true);
+      });
+
+      test('fresh install', () async {
+        await Store.delete(StoreKey.betaTimeline);
+        await handleBetaMigration(14, true, mockSyncStreamRepository);
+
+        expect(Store.tryGet(StoreKey.betaTimeline), true);
+        expect(Store.tryGet(StoreKey.needBetaMigration), false);
+      });
+    });
+
+    group("version == 15", () {
+      test('already on new timeline', () async {
+        await Store.put(StoreKey.betaTimeline, true);
+
+        await handleBetaMigration(15, false, mockSyncStreamRepository);
+
+        expect(Store.tryGet(StoreKey.betaTimeline), true);
+        expect(Store.tryGet(StoreKey.needBetaMigration), false);
+      });
+
+      test('already on old timeline', () async {
+        await Store.put(StoreKey.betaTimeline, false);
+
+        await handleBetaMigration(15, false, mockSyncStreamRepository);
+
+        expect(Store.tryGet(StoreKey.needBetaMigration), true);
+      });
+
+      test('fresh install', () async {
+        await Store.delete(StoreKey.betaTimeline);
+        await handleBetaMigration(15, true, mockSyncStreamRepository);
+
+        expect(Store.tryGet(StoreKey.betaTimeline), true);
+        expect(Store.tryGet(StoreKey.needBetaMigration), false);
+      });
+    });
+
+    group("version > 15", () {
+      test('already on new timeline', () async {
+        await Store.put(StoreKey.betaTimeline, true);
+
+        await handleBetaMigration(16, false, mockSyncStreamRepository);
+
+        expect(Store.tryGet(StoreKey.betaTimeline), true);
+        expect(Store.tryGet(StoreKey.needBetaMigration), false);
+      });
+
+      test('already on old timeline', () async {
+        await Store.put(StoreKey.betaTimeline, false);
+
+        await handleBetaMigration(16, false, mockSyncStreamRepository);
+
+        expect(Store.tryGet(StoreKey.betaTimeline), false);
+        expect(Store.tryGet(StoreKey.needBetaMigration), false);
+      });
+
+      test('fresh install', () async {
+        await Store.delete(StoreKey.betaTimeline);
+        await handleBetaMigration(16, true, mockSyncStreamRepository);
+
+        expect(Store.tryGet(StoreKey.betaTimeline), true);
+        expect(Store.tryGet(StoreKey.needBetaMigration), false);
+      });
+    });
+  });
+
+  group('sync reset tests', () {
+    test('version < 16', () async {
+      await Store.put(StoreKey.shouldResetSync, false);
+
+      await handleBetaMigration(15, false, mockSyncStreamRepository);
+
+      expect(Store.tryGet(StoreKey.shouldResetSync), true);
+    });
+
+    test('version >= 16', () async {
+      await Store.put(StoreKey.shouldResetSync, false);
+
+      await handleBetaMigration(16, false, mockSyncStreamRepository);
+
+      expect(Store.tryGet(StoreKey.shouldResetSync), false);
+    });
+  });
+}