feat: add configurable backup on charging only and delay settings for android (#22114)

* feat: add configurable on charging only and delay

* Segmented and style the settings

---------

Co-authored-by: shenlong-tanwen <139912620+shalong-tanwen@users.noreply.github.com>
Co-authored-by: Alex <alex.tran1502@gmail.com>

i18n/en.json

@@ -533,6 +533,7 @@
   "background_backup_running_error": "Background backup is currently running, cannot start manual backup",
   "background_location_permission": "Background location permission",
   "background_location_permission_content": "In order to switch networks when running in the background, Immich must *always* have precise location access so the app can read the Wi-Fi network's name",
+  "background_options": "Background Options",
   "backup": "Backup",
   "backup_album_selection_page_albums_device": "Albums on device ({count})",
   "backup_album_selection_page_albums_tap": "Tap to include, double tap to exclude",
@@ -540,6 +541,7 @@
   "backup_album_selection_page_select_albums": "Select albums",
   "backup_album_selection_page_selection_info": "Selection Info",
   "backup_album_selection_page_total_assets": "Total unique assets",
+  "backup_albums_sync": "Backup albums synchronization",
   "backup_all": "All",
   "backup_background_service_backup_failed_message": "Failed to backup assets. Retrying…",
   "backup_background_service_connection_failed_message": "Failed to connect to the server. Retrying…",
@@ -656,6 +658,8 @@
   "change_pin_code": "Change PIN code",
   "change_your_password": "Change your password",
   "changed_visibility_successfully": "Changed visibility successfully",
+  "charging": "Charging",
+  "charging_requirement_mobile_backup": "Background backup requires the device to be charging",
   "check_corrupt_asset_backup": "Check for corrupt asset backups",
   "check_corrupt_asset_backup_button": "Perform check",
   "check_corrupt_asset_backup_description": "Run this check only over Wi-Fi and once all assets have been backed-up. The procedure might take a few minutes.",
@@ -1351,6 +1355,7 @@
   "name_or_nickname": "Name or nickname",
   "network_requirement_photos_upload": "Use cellular data to backup photos",
   "network_requirement_videos_upload": "Use cellular data to backup videos",
+  "network_requirements": "Network Requirements",
   "network_requirements_updated": "Network requirements changed, resetting backup queue",
   "networking_settings": "Networking",
   "networking_subtitle": "Manage the server endpoint settings",

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

@@ -37,6 +37,36 @@ private object BackgroundWorkerPigeonUtils {
       )
     }
   }
+  fun deepEquals(a: Any?, b: Any?): Boolean {
+    if (a is ByteArray && b is ByteArray) {
+        return a.contentEquals(b)
+    }
+    if (a is IntArray && b is IntArray) {
+        return a.contentEquals(b)
+    }
+    if (a is LongArray && b is LongArray) {
+        return a.contentEquals(b)
+    }
+    if (a is DoubleArray && b is DoubleArray) {
+        return a.contentEquals(b)
+    }
+    if (a is Array<*> && b is Array<*>) {
+      return a.size == b.size &&
+          a.indices.all{ deepEquals(a[it], b[it]) }
+    }
+    if (a is List<*> && b is List<*>) {
+      return a.size == b.size &&
+          a.indices.all{ deepEquals(a[it], b[it]) }
+    }
+    if (a is Map<*, *> && b is Map<*, *>) {
+      return a.size == b.size && a.all {
+          (b as Map<Any?, Any?>).containsKey(it.key) &&
+          deepEquals(it.value, b[it.key])
+      }
+    }
+    return a == b
+  }
+      
 }
 
 /**
@@ -50,18 +80,63 @@ class FlutterError (
   override val message: String? = null,
   val details: Any? = null
 ) : Throwable()
+
+/** Generated class from Pigeon that represents data sent in messages. */
+data class BackgroundWorkerSettings (
+  val requiresCharging: Boolean,
+  val minimumDelaySeconds: Long
+)
+ {
+  companion object {
+    fun fromList(pigeonVar_list: List<Any?>): BackgroundWorkerSettings {
+      val requiresCharging = pigeonVar_list[0] as Boolean
+      val minimumDelaySeconds = pigeonVar_list[1] as Long
+      return BackgroundWorkerSettings(requiresCharging, minimumDelaySeconds)
+    }
+  }
+  fun toList(): List<Any?> {
+    return listOf(
+      requiresCharging,
+      minimumDelaySeconds,
+    )
+  }
+  override fun equals(other: Any?): Boolean {
+    if (other !is BackgroundWorkerSettings) {
+      return false
+    }
+    if (this === other) {
+      return true
+    }
+    return BackgroundWorkerPigeonUtils.deepEquals(toList(), other.toList())  }
+
+  override fun hashCode(): Int = toList().hashCode()
+}
 private open class BackgroundWorkerPigeonCodec : StandardMessageCodec() {
   override fun readValueOfType(type: Byte, buffer: ByteBuffer): Any? {
-    return     super.readValueOfType(type, buffer)
+    return when (type) {
+      129.toByte() -> {
+        return (readValue(buffer) as? List<Any?>)?.let {
+          BackgroundWorkerSettings.fromList(it)
+        }
+      }
+      else -> super.readValueOfType(type, buffer)
+    }
   }
   override fun writeValue(stream: ByteArrayOutputStream, value: Any?)   {
-    super.writeValue(stream, value)
+    when (value) {
+      is BackgroundWorkerSettings -> {
+        stream.write(129)
+        writeValue(stream, value.toList())
+      }
+      else -> super.writeValue(stream, value)
+    }
   }
 }
 
 /** Generated interface from Pigeon that represents a handler of messages from Flutter. */
 interface BackgroundWorkerFgHostApi {
   fun enable()
+  fun configure(settings: BackgroundWorkerSettings)
   fun disable()
 
   companion object {
@@ -89,6 +164,24 @@ interface BackgroundWorkerFgHostApi {
           channel.setMessageHandler(null)
         }
       }
+      run {
+        val channel = BasicMessageChannel<Any?>(binaryMessenger, "dev.flutter.pigeon.immich_mobile.BackgroundWorkerFgHostApi.configure$separatedMessageChannelSuffix", codec)
+        if (api != null) {
+          channel.setMessageHandler { message, reply ->
+            val args = message as List<Any?>
+            val settingsArg = args[0] as BackgroundWorkerSettings
+            val wrapped: List<Any?> = try {
+              api.configure(settingsArg)
+              listOf(null)
+            } catch (exception: Throwable) {
+              BackgroundWorkerPigeonUtils.wrapError(exception)
+            }
+            reply.reply(wrapped)
+          }
+        } else {
+          channel.setMessageHandler(null)
+        }
+      }
       run {
         val channel = BasicMessageChannel<Any?>(binaryMessenger, "dev.flutter.pigeon.immich_mobile.BackgroundWorkerFgHostApi.disable$separatedMessageChannelSuffix", codec)
         if (api != null) {

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

@@ -1,6 +1,7 @@
 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
@@ -10,7 +11,7 @@ import androidx.work.OneTimeWorkRequest
 import androidx.work.WorkManager
 import java.util.concurrent.TimeUnit
 
-private const val TAG = "BackgroundUploadImpl"
+private const val TAG = "BackgroundWorkerApiImpl"
 
 class BackgroundWorkerApiImpl(context: Context) : BackgroundWorkerFgHostApi {
   private val ctx: Context = context.applicationContext
@@ -19,9 +20,16 @@ class BackgroundWorkerApiImpl(context: Context) : BackgroundWorkerFgHostApi {
     enqueueMediaObserver(ctx)
   }
 
+  override fun configure(settings: BackgroundWorkerSettings) {
+    BackgroundWorkerPreferences(ctx).updateSettings(settings)
+    enqueueMediaObserver(ctx)
+  }
+
   override fun disable() {
-    WorkManager.getInstance(ctx).cancelUniqueWork(OBSERVER_WORKER_NAME)
-    WorkManager.getInstance(ctx).cancelUniqueWork(BACKGROUND_WORKER_NAME)
+    WorkManager.getInstance(ctx).apply {
+      cancelUniqueWork(OBSERVER_WORKER_NAME)
+      cancelUniqueWork(BACKGROUND_WORKER_NAME)
+    }
     Log.i(TAG, "Cancelled background upload tasks")
   }
 
@@ -30,14 +38,16 @@ class BackgroundWorkerApiImpl(context: Context) : BackgroundWorkerFgHostApi {
     private const val OBSERVER_WORKER_NAME = "immich/MediaObserverV1"
 
     fun enqueueMediaObserver(ctx: Context) {
-      val constraints = Constraints.Builder()
-        .addContentUriTrigger(MediaStore.Images.Media.INTERNAL_CONTENT_URI, true)
-        .addContentUriTrigger(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, true)
-        .addContentUriTrigger(MediaStore.Video.Media.INTERNAL_CONTENT_URI, true)
-        .addContentUriTrigger(MediaStore.Video.Media.EXTERNAL_CONTENT_URI, true)
-        .setTriggerContentUpdateDelay(30, TimeUnit.SECONDS)
-        .setTriggerContentMaxDelay(3, TimeUnit.MINUTES)
-        .build()
+      val settings = BackgroundWorkerPreferences(ctx).getSettings()
+      val constraints = Constraints.Builder().apply {
+        addContentUriTrigger(MediaStore.Images.Media.INTERNAL_CONTENT_URI, true)
+        addContentUriTrigger(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, true)
+        addContentUriTrigger(MediaStore.Video.Media.INTERNAL_CONTENT_URI, true)
+        addContentUriTrigger(MediaStore.Video.Media.EXTERNAL_CONTENT_URI, true)
+        setTriggerContentUpdateDelay(settings.minimumDelaySeconds, TimeUnit.SECONDS)
+        setTriggerContentMaxDelay(settings.minimumDelaySeconds * 10, TimeUnit.MINUTES)
+        setRequiresCharging(settings.requiresCharging)
+      }.build()
 
       val work = OneTimeWorkRequest.Builder(MediaObserver::class.java)
         .setConstraints(constraints)
@@ -45,7 +55,10 @@ class BackgroundWorkerApiImpl(context: Context) : BackgroundWorkerFgHostApi {
       WorkManager.getInstance(ctx)
         .enqueueUniqueWork(OBSERVER_WORKER_NAME, ExistingWorkPolicy.REPLACE, work)
 
-      Log.i(TAG, "Enqueued media observer worker with name: $OBSERVER_WORKER_NAME")
+      Log.i(
+        TAG,
+        "Enqueued media observer worker with name: $OBSERVER_WORKER_NAME and settings: $settings"
+      )
     }
 
     fun enqueueBackgroundWorker(ctx: Context) {
@@ -62,3 +75,33 @@ class BackgroundWorkerApiImpl(context: Context) : BackgroundWorkerFgHostApi {
     }
   }
 }
+
+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"
+
+    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().apply {
+      putLong(SHARED_PREF_MIN_DELAY_KEY, settings.minimumDelaySeconds)
+      putBoolean(SHARED_PREF_REQUIRE_CHARGING_KEY, settings.requiresCharging)
+      apply()
+    }
+  }
+
+  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/ios/Runner/Background/BackgroundWorker.g.swift

@@ -50,11 +50,119 @@ private func nilOrValue<T>(_ value: Any?) -> T? {
   return value as! T?
 }
 
+func deepEqualsBackgroundWorker(_ lhs: Any?, _ rhs: Any?) -> Bool {
+  let cleanLhs = nilOrValue(lhs) as Any?
+  let cleanRhs = nilOrValue(rhs) as Any?
+  switch (cleanLhs, cleanRhs) {
+  case (nil, nil):
+    return true
+
+  case (nil, _), (_, nil):
+    return false
+
+  case is (Void, Void):
+    return true
+
+  case let (cleanLhsHashable, cleanRhsHashable) as (AnyHashable, AnyHashable):
+    return cleanLhsHashable == cleanRhsHashable
+
+  case let (cleanLhsArray, cleanRhsArray) as ([Any?], [Any?]):
+    guard cleanLhsArray.count == cleanRhsArray.count else { return false }
+    for (index, element) in cleanLhsArray.enumerated() {
+      if !deepEqualsBackgroundWorker(element, cleanRhsArray[index]) {
+        return false
+      }
+    }
+    return true
+
+  case let (cleanLhsDictionary, cleanRhsDictionary) as ([AnyHashable: Any?], [AnyHashable: Any?]):
+    guard cleanLhsDictionary.count == cleanRhsDictionary.count else { return false }
+    for (key, cleanLhsValue) in cleanLhsDictionary {
+      guard cleanRhsDictionary.index(forKey: key) != nil else { return false }
+      if !deepEqualsBackgroundWorker(cleanLhsValue, cleanRhsDictionary[key]!) {
+        return false
+      }
+    }
+    return true
+
+  default:
+    // Any other type shouldn't be able to be used with pigeon. File an issue if you find this to be untrue.
+    return false
+  }
+}
+
+func deepHashBackgroundWorker(value: Any?, hasher: inout Hasher) {
+  if let valueList = value as? [AnyHashable] {
+     for item in valueList { deepHashBackgroundWorker(value: item, hasher: &hasher) }
+     return
+  }
+
+  if let valueDict = value as? [AnyHashable: AnyHashable] {
+    for key in valueDict.keys { 
+      hasher.combine(key)
+      deepHashBackgroundWorker(value: valueDict[key]!, hasher: &hasher)
+    }
+    return
+  }
+
+  if let hashableValue = value as? AnyHashable {
+    hasher.combine(hashableValue.hashValue)
+  }
+
+  return hasher.combine(String(describing: value))
+}
+
+    
+
+/// Generated class from Pigeon that represents data sent in messages.
+struct BackgroundWorkerSettings: Hashable {
+  var requiresCharging: Bool
+  var minimumDelaySeconds: Int64
+
+
+  // swift-format-ignore: AlwaysUseLowerCamelCase
+  static func fromList(_ pigeonVar_list: [Any?]) -> BackgroundWorkerSettings? {
+    let requiresCharging = pigeonVar_list[0] as! Bool
+    let minimumDelaySeconds = pigeonVar_list[1] as! Int64
+
+    return BackgroundWorkerSettings(
+      requiresCharging: requiresCharging,
+      minimumDelaySeconds: minimumDelaySeconds
+    )
+  }
+  func toList() -> [Any?] {
+    return [
+      requiresCharging,
+      minimumDelaySeconds,
+    ]
+  }
+  static func == (lhs: BackgroundWorkerSettings, rhs: BackgroundWorkerSettings) -> Bool {
+    return deepEqualsBackgroundWorker(lhs.toList(), rhs.toList())  }
+  func hash(into hasher: inout Hasher) {
+    deepHashBackgroundWorker(value: toList(), hasher: &hasher)
+  }
+}
 
 private class BackgroundWorkerPigeonCodecReader: FlutterStandardReader {
+  override func readValue(ofType type: UInt8) -> Any? {
+    switch type {
+    case 129:
+      return BackgroundWorkerSettings.fromList(self.readValue() as! [Any?])
+    default:
+      return super.readValue(ofType: type)
+    }
+  }
 }
 
 private class BackgroundWorkerPigeonCodecWriter: FlutterStandardWriter {
+  override func writeValue(_ value: Any) {
+    if let value = value as? BackgroundWorkerSettings {
+      super.writeByte(129)
+      super.writeValue(value.toList())
+    } else {
+      super.writeValue(value)
+    }
+  }
 }
 
 private class BackgroundWorkerPigeonCodecReaderWriter: FlutterStandardReaderWriter {
@@ -74,6 +182,7 @@ class BackgroundWorkerPigeonCodec: FlutterStandardMessageCodec, @unchecked Senda
 /// Generated protocol from Pigeon that represents a handler of messages from Flutter.
 protocol BackgroundWorkerFgHostApi {
   func enable() throws
+  func configure(settings: BackgroundWorkerSettings) throws
   func disable() throws
 }
 
@@ -96,6 +205,21 @@ class BackgroundWorkerFgHostApiSetup {
     } else {
       enableChannel.setMessageHandler(nil)
     }
+    let configureChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.immich_mobile.BackgroundWorkerFgHostApi.configure\(channelSuffix)", binaryMessenger: binaryMessenger, codec: codec)
+    if let api = api {
+      configureChannel.setMessageHandler { message, reply in
+        let args = message as! [Any?]
+        let settingsArg = args[0] as! BackgroundWorkerSettings
+        do {
+          try api.configure(settings: settingsArg)
+          reply(wrapResult(nil))
+        } catch {
+          reply(wrapError(error))
+        }
+      }
+    } else {
+      configureChannel.setMessageHandler(nil)
+    }
     let disableChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.immich_mobile.BackgroundWorkerFgHostApi.disable\(channelSuffix)", binaryMessenger: binaryMessenger, codec: codec)
     if let api = api {
       disableChannel.setMessageHandler { _, reply in

mobile/ios/Runner/Background/BackgroundWorkerApiImpl.swift

@@ -8,6 +8,10 @@ class BackgroundWorkerApiImpl: BackgroundWorkerFgHostApi {
     print("BackgroundUploadImpl:enbale Background worker scheduled")
   }
   
+  func configure(settings: BackgroundWorkerSettings) throws {
+    // Android only
+  }
+  
   func disable() throws {
     BGTaskScheduler.shared.cancel(taskRequestWithIdentifier: BackgroundWorkerApiImpl.refreshTaskID);
     BGTaskScheduler.shared.cancel(taskRequestWithIdentifier: BackgroundWorkerApiImpl.processingTaskID);

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

@@ -43,6 +43,17 @@ class BackgroundWorkerFgService {
   // TODO: Move this call to native side once old timeline is removed
   Future<void> enable() => _foregroundHostApi.enable();
 
+  Future<void> configure({int? minimumDelaySeconds, bool? requireCharging}) => _foregroundHostApi.configure(
+    BackgroundWorkerSettings(
+      minimumDelaySeconds:
+          minimumDelaySeconds ??
+          Store.get(AppSettingsEnum.backupTriggerDelay.storeKey, AppSettingsEnum.backupTriggerDelay.defaultValue),
+      requiresCharging:
+          requireCharging ??
+          Store.get(AppSettingsEnum.backupRequireCharging.storeKey, AppSettingsEnum.backupRequireCharging.defaultValue),
+    ),
+  );
+
   Future<void> disable() => _foregroundHostApi.disable();
 }
 

mobile/lib/platform/background_worker_api.g.dart

@@ -25,6 +25,57 @@ List<Object?> wrapResponse({Object? result, PlatformException? error, bool empty
   return <Object?>[error.code, error.message, error.details];
 }
 
+bool _deepEquals(Object? a, Object? b) {
+  if (a is List && b is List) {
+    return a.length == b.length && a.indexed.every(((int, dynamic) item) => _deepEquals(item.$2, b[item.$1]));
+  }
+  if (a is Map && b is Map) {
+    return a.length == b.length &&
+        a.entries.every(
+          (MapEntry<Object?, Object?> entry) =>
+              (b as Map<Object?, Object?>).containsKey(entry.key) && _deepEquals(entry.value, b[entry.key]),
+        );
+  }
+  return a == b;
+}
+
+class BackgroundWorkerSettings {
+  BackgroundWorkerSettings({required this.requiresCharging, required this.minimumDelaySeconds});
+
+  bool requiresCharging;
+
+  int minimumDelaySeconds;
+
+  List<Object?> _toList() {
+    return <Object?>[requiresCharging, minimumDelaySeconds];
+  }
+
+  Object encode() {
+    return _toList();
+  }
+
+  static BackgroundWorkerSettings decode(Object result) {
+    result as List<Object?>;
+    return BackgroundWorkerSettings(requiresCharging: result[0]! as bool, minimumDelaySeconds: result[1]! as int);
+  }
+
+  @override
+  // ignore: avoid_equals_and_hash_code_on_mutable_classes
+  bool operator ==(Object other) {
+    if (other is! BackgroundWorkerSettings || 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
@@ -32,6 +83,9 @@ class _PigeonCodec extends StandardMessageCodec {
     if (value is int) {
       buffer.putUint8(4);
       buffer.putInt64(value);
+    } else if (value is BackgroundWorkerSettings) {
+      buffer.putUint8(129);
+      writeValue(buffer, value.encode());
     } else {
       super.writeValue(buffer, value);
     }
@@ -40,6 +94,8 @@ class _PigeonCodec extends StandardMessageCodec {
   @override
   Object? readValueOfType(int type, ReadBuffer buffer) {
     switch (type) {
+      case 129:
+        return BackgroundWorkerSettings.decode(readValue(buffer)!);
       default:
         return super.readValueOfType(type, buffer);
     }
@@ -82,6 +138,29 @@ class BackgroundWorkerFgHostApi {
     }
   }
 
+  Future<void> configure(BackgroundWorkerSettings settings) async {
+    final String pigeonVar_channelName =
+        'dev.flutter.pigeon.immich_mobile.BackgroundWorkerFgHostApi.configure$pigeonVar_messageChannelSuffix';
+    final BasicMessageChannel<Object?> pigeonVar_channel = BasicMessageChannel<Object?>(
+      pigeonVar_channelName,
+      pigeonChannelCodec,
+      binaryMessenger: pigeonVar_binaryMessenger,
+    );
+    final Future<Object?> pigeonVar_sendFuture = pigeonVar_channel.send(<Object?>[settings]);
+    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> disable() async {
     final String pigeonVar_channelName =
         'dev.flutter.pigeon.immich_mobile.BackgroundWorkerFgHostApi.disable$pigeonVar_messageChannelSuffix';

mobile/lib/services/app_settings.service.dart

@@ -50,6 +50,8 @@ enum AppSettingsEnum<T> {
   enableBackup<bool>(StoreKey.enableBackup, null, false),
   useCellularForUploadVideos<bool>(StoreKey.useWifiForUploadVideos, null, false),
   useCellularForUploadPhotos<bool>(StoreKey.useWifiForUploadPhotos, null, false),
+  backupRequireCharging<bool>(StoreKey.backupRequireCharging, null, false),
+  backupTriggerDelay<int>(StoreKey.backupTriggerDelay, null, 30),
   readonlyModeEnabled<bool>(StoreKey.readonlyModeEnabled, "readonlyModeEnabled", false);
 
   const AppSettingsEnum(this.storeKey, this.hiveKey, this.defaultValue);

mobile/lib/widgets/settings/backup_settings/drift_backup_settings.dart

@@ -1,14 +1,19 @@
+import 'dart:async';
+
+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/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:immich_mobile/extensions/build_context_extensions.dart';
+import 'package:immich_mobile/extensions/platform_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/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/settings/settings_sub_page_scaffold.dart';
@@ -18,12 +23,40 @@ class DriftBackupSettings extends ConsumerWidget {
 
   @override
   Widget build(BuildContext context, WidgetRef ref) {
-    return const SettingsSubPageScaffold(
+    return SettingsSubPageScaffold(
       settings: [
-        _UseWifiForUploadVideosButton(),
-        _UseWifiForUploadPhotosButton(),
-        Divider(indent: 16, endIndent: 16),
-        _AlbumSyncActionButton(),
+        Padding(
+          padding: const EdgeInsets.only(left: 16.0),
+          child: Text(
+            "network_requirements".t(context: context).toUpperCase(),
+            style: context.textTheme.labelSmall?.copyWith(color: context.colorScheme.onSurface.withValues(alpha: 0.7)),
+          ),
+        ),
+        const _UseWifiForUploadVideosButton(),
+        const _UseWifiForUploadPhotosButton(),
+        if (CurrentPlatform.isAndroid) ...[
+          const Divider(),
+          Padding(
+            padding: const EdgeInsets.only(left: 16.0),
+            child: Text(
+              "background_options".t(context: context).toUpperCase(),
+              style: context.textTheme.labelSmall?.copyWith(
+                color: context.colorScheme.onSurface.withValues(alpha: 0.7),
+              ),
+            ),
+          ),
+          const _BackupOnlyWhenChargingButton(),
+          const _BackupDelaySlider(),
+        ],
+        const Divider(),
+        Padding(
+          padding: const EdgeInsets.only(left: 16.0),
+          child: Text(
+            "backup_albums_sync".t(context: context).toUpperCase(),
+            style: context.textTheme.labelSmall?.copyWith(color: context.colorScheme.onSurface.withValues(alpha: 0.7)),
+          ),
+        ),
+        const _AlbumSyncActionButton(),
       ],
     );
   }
@@ -151,30 +184,59 @@ class _AlbumSyncActionButtonState extends ConsumerState<_AlbumSyncActionButton>
   }
 }
 
-class _UseWifiForUploadVideosButton extends ConsumerWidget {
-  const _UseWifiForUploadVideosButton();
+class _SettingsSwitchTile extends ConsumerStatefulWidget {
+  final AppSettingsEnum<bool> appSettingsEnum;
+  final String titleKey;
+  final String subtitleKey;
+  final void Function(bool?)? onChanged;
+
+  const _SettingsSwitchTile({
+    required this.appSettingsEnum,
+    required this.titleKey,
+    required this.subtitleKey,
+    this.onChanged,
+  });
 
   @override
-  Widget build(BuildContext context, WidgetRef ref) {
-    final valueStream = Store.watch(StoreKey.useWifiForUploadVideos);
+  ConsumerState createState() => _SettingsSwitchTileState();
+}
 
+class _SettingsSwitchTileState extends ConsumerState<_SettingsSwitchTile> {
+  late final Stream<bool?> valueStream;
+  late final StreamSubscription<bool?> subscription;
+
+  @override
+  void initState() {
+    super.initState();
+    valueStream = Store.watch(widget.appSettingsEnum.storeKey).asBroadcastStream();
+    subscription = valueStream.listen((value) {
+      widget.onChanged?.call(value);
+    });
+  }
+
+  @override
+  void dispose() {
+    subscription.cancel();
+    super.dispose();
+  }
+
+  @override
+  Widget build(BuildContext context) {
     return ListTile(
       title: Text(
-        "videos".t(context: context),
+        widget.titleKey.t(context: context),
         style: context.textTheme.titleMedium?.copyWith(color: context.primaryColor),
       ),
-      subtitle: Text("network_requirement_videos_upload".t(context: context), style: context.textTheme.labelLarge),
+      subtitle: Text(widget.subtitleKey.t(context: context), style: context.textTheme.labelLarge),
       trailing: StreamBuilder(
         stream: valueStream,
-        initialData: Store.tryGet(StoreKey.useWifiForUploadVideos) ?? false,
+        initialData: Store.tryGet(widget.appSettingsEnum.storeKey) ?? widget.appSettingsEnum.defaultValue,
         builder: (context, snapshot) {
           final value = snapshot.data ?? false;
           return Switch(
             value: value,
             onChanged: (bool newValue) async {
-              await ref
-                  .read(appSettingsServiceProvider)
-                  .setSetting(AppSettingsEnum.useCellularForUploadVideos, newValue);
+              await ref.read(appSettingsServiceProvider).setSetting(widget.appSettingsEnum, newValue);
             },
           );
         },
@@ -183,34 +245,135 @@ class _UseWifiForUploadVideosButton extends ConsumerWidget {
   }
 }
 
+class _UseWifiForUploadVideosButton extends ConsumerWidget {
+  const _UseWifiForUploadVideosButton();
+
+  @override
+  Widget build(BuildContext context, WidgetRef ref) {
+    return const _SettingsSwitchTile(
+      appSettingsEnum: AppSettingsEnum.useCellularForUploadVideos,
+      titleKey: "videos",
+      subtitleKey: "network_requirement_videos_upload",
+    );
+  }
+}
+
 class _UseWifiForUploadPhotosButton extends ConsumerWidget {
   const _UseWifiForUploadPhotosButton();
 
   @override
   Widget build(BuildContext context, WidgetRef ref) {
-    final valueStream = Store.watch(StoreKey.useWifiForUploadPhotos);
-
-    return ListTile(
-      title: Text(
-        "photos".t(context: context),
-        style: context.textTheme.titleMedium?.copyWith(color: context.primaryColor),
-      ),
-      subtitle: Text("network_requirement_photos_upload".t(context: context), style: context.textTheme.labelLarge),
-      trailing: StreamBuilder(
-        stream: valueStream,
-        initialData: Store.tryGet(StoreKey.useWifiForUploadPhotos) ?? false,
-        builder: (context, snapshot) {
-          final value = snapshot.data ?? false;
-          return Switch(
-            value: value,
-            onChanged: (bool newValue) async {
-              await ref
-                  .read(appSettingsServiceProvider)
-                  .setSetting(AppSettingsEnum.useCellularForUploadPhotos, newValue);
-            },
-          );
-        },
-      ),
+    return const _SettingsSwitchTile(
+      appSettingsEnum: AppSettingsEnum.useCellularForUploadPhotos,
+      titleKey: "photos",
+      subtitleKey: "network_requirement_photos_upload",
+    );
+  }
+}
+
+class _BackupOnlyWhenChargingButton extends ConsumerWidget {
+  const _BackupOnlyWhenChargingButton();
+
+  @override
+  Widget build(BuildContext context, WidgetRef ref) {
+    return _SettingsSwitchTile(
+      appSettingsEnum: AppSettingsEnum.backupRequireCharging,
+      titleKey: "charging",
+      subtitleKey: "charging_requirement_mobile_backup",
+      onChanged: (value) {
+        ref.read(backgroundWorkerFgServiceProvider).configure(requireCharging: value ?? false);
+      },
+    );
+  }
+}
+
+class _BackupDelaySlider extends ConsumerStatefulWidget {
+  const _BackupDelaySlider();
+
+  @override
+  ConsumerState<_BackupDelaySlider> createState() => _BackupDelaySliderState();
+}
+
+class _BackupDelaySliderState extends ConsumerState<_BackupDelaySlider> {
+  late final Stream<int?> valueStream;
+  late final StreamSubscription<int?> subscription;
+  late int currentValue;
+
+  static int backupDelayToSliderValue(int ms) => switch (ms) {
+    5 => 0,
+    30 => 1,
+    120 => 2,
+    _ => 3,
+  };
+
+  static int backupDelayToSeconds(int v) => switch (v) {
+    0 => 5,
+    1 => 30,
+    2 => 120,
+    _ => 600,
+  };
+
+  static String formatBackupDelaySliderValue(int v) => switch (v) {
+    0 => 'setting_notifications_notify_seconds'.tr(namedArgs: {'count': '5'}),
+    1 => 'setting_notifications_notify_seconds'.tr(namedArgs: {'count': '30'}),
+    2 => 'setting_notifications_notify_minutes'.tr(namedArgs: {'count': '2'}),
+    _ => 'setting_notifications_notify_minutes'.tr(namedArgs: {'count': '10'}),
+  };
+
+  @override
+  void initState() {
+    super.initState();
+    final initialValue =
+        Store.tryGet(AppSettingsEnum.backupTriggerDelay.storeKey) ?? AppSettingsEnum.backupTriggerDelay.defaultValue;
+    currentValue = backupDelayToSliderValue(initialValue);
+
+    valueStream = Store.watch(AppSettingsEnum.backupTriggerDelay.storeKey).asBroadcastStream();
+    subscription = valueStream.listen((value) {
+      if (mounted && value != null) {
+        setState(() {
+          currentValue = backupDelayToSliderValue(value);
+        });
+      }
+    });
+  }
+
+  @override
+  void dispose() {
+    subscription.cancel();
+    super.dispose();
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return Column(
+      crossAxisAlignment: CrossAxisAlignment.start,
+      children: [
+        Padding(
+          padding: const EdgeInsets.only(left: 16.0, top: 8.0),
+          child: Text(
+            'backup_controller_page_background_delay'.tr(
+              namedArgs: {'duration': formatBackupDelaySliderValue(currentValue)},
+            ),
+            style: context.textTheme.titleMedium?.copyWith(color: context.primaryColor),
+          ),
+        ),
+        Slider(
+          value: currentValue.toDouble(),
+          onChanged: (double v) {
+            setState(() {
+              currentValue = v.toInt();
+            });
+          },
+          onChangeEnd: (double v) async {
+            final milliseconds = backupDelayToSeconds(v.toInt());
+            await ref.read(appSettingsServiceProvider).setSetting(AppSettingsEnum.backupTriggerDelay, milliseconds);
+          },
+          max: 3.0,
+          min: 0.0,
+          divisions: 3,
+          label: formatBackupDelaySliderValue(currentValue),
+        ),
+      ],
     );
   }
 }

mobile/pigeon/background_worker_api.dart

@@ -11,10 +11,19 @@ import 'package:pigeon/pigeon.dart';
     dartPackageName: 'immich_mobile',
   ),
 )
+class BackgroundWorkerSettings {
+  final bool requiresCharging;
+  final int minimumDelaySeconds;
+
+  const BackgroundWorkerSettings({required this.requiresCharging, required this.minimumDelaySeconds});
+}
+
 @HostApi()
 abstract class BackgroundWorkerFgHostApi {
   void enable();
 
+  void configure(BackgroundWorkerSettings settings);
+
   void disable();
 }