Skip to content

High performance self-hosted photo and video management solution.

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

shenlong61c3f27fdc48
diff --git a/i18n/en.json b/i18n/en.json
index fef3243ec0..aa1999adcb 100644
--- a/i18n/en.json
+++ b/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",
diff --git a/mobile/android/app/src/main/kotlin/app/alextran/immich/background/BackgroundWorker.g.kt b/mobile/android/app/src/main/kotlin/app/alextran/immich/background/BackgroundWorker.g.kt
index 4d9e2c0caf..052395c172 100644
--- a/mobile/android/app/src/main/kotlin/app/alextran/immich/background/BackgroundWorker.g.kt
+++ b/mobile/android/app/src/main/kotlin/app/alextran/immich/background/BackgroundWorker.g.kt
@@ -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) {
diff --git a/mobile/android/app/src/main/kotlin/app/alextran/immich/background/BackgroundWorkerApiImpl.kt b/mobile/android/app/src/main/kotlin/app/alextran/immich/background/BackgroundWorkerApiImpl.kt
index 6cbda073d8..259e3244bc 100644
--- a/mobile/android/app/src/main/kotlin/app/alextran/immich/background/BackgroundWorkerApiImpl.kt
+++ b/mobile/android/app/src/main/kotlin/app/alextran/immich/background/BackgroundWorkerApiImpl.kt
@@ -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),
+ )
+ }
+}
diff --git a/mobile/ios/Runner/Background/BackgroundWorker.g.swift b/mobile/ios/Runner/Background/BackgroundWorker.g.swift
index 45a6402fe8..ece5cd5f64 100644
--- a/mobile/ios/Runner/Background/BackgroundWorker.g.swift
+++ b/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
diff --git a/mobile/ios/Runner/Background/BackgroundWorkerApiImpl.swift b/mobile/ios/Runner/Background/BackgroundWorkerApiImpl.swift
index 184b797133..ca2453404c 100644
--- a/mobile/ios/Runner/Background/BackgroundWorkerApiImpl.swift
+++ b/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);
diff --git a/mobile/lib/domain/services/background_worker.service.dart b/mobile/lib/domain/services/background_worker.service.dart
index 90e2ddff4c..d57fe507d9 100644
--- a/mobile/lib/domain/services/background_worker.service.dart
+++ b/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();
}
diff --git a/mobile/lib/platform/background_worker_api.g.dart b/mobile/lib/platform/background_worker_api.g.dart
index 9398b0a15b..af7c78fd4b 100644
--- a/mobile/lib/platform/background_worker_api.g.dart
+++ b/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';
diff --git a/mobile/lib/services/app_settings.service.dart b/mobile/lib/services/app_settings.service.dart
index d53cd85b95..03d91328d1 100644
--- a/mobile/lib/services/app_settings.service.dart
+++ b/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);
diff --git a/mobile/lib/widgets/settings/backup_settings/drift_backup_settings.dart b/mobile/lib/widgets/settings/backup_settings/drift_backup_settings.dart
index ac9866d4da..743d38fc48 100644
--- a/mobile/lib/widgets/settings/backup_settings/drift_backup_settings.dart
+++ b/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 const _SettingsSwitchTile(
+ appSettingsEnum: AppSettingsEnum.useCellularForUploadPhotos,
+ titleKey: "photos",
+ subtitleKey: "network_requirement_photos_upload",
+ );
+ }
+}
- 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);
- },
- );
- },
- ),
+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),
+ ),
+ ],
);
}
}
diff --git a/mobile/pigeon/background_worker_api.dart b/mobile/pigeon/background_worker_api.dart
index 8aa0f5f5ee..6f6c781de2 100644
--- a/mobile/pigeon/background_worker_api.dart
+++ b/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();
}