Source Code added

mobile/lib/providers/activity.provider.dart

@@ -0,0 +1,92 @@
+import 'package:collection/collection.dart';
+import 'package:immich_mobile/models/activities/activity.model.dart';
+import 'package:immich_mobile/providers/activity_service.provider.dart';
+import 'package:immich_mobile/providers/activity_statistics.provider.dart';
+import 'package:riverpod_annotation/riverpod_annotation.dart';
+
+part 'activity.provider.g.dart';
+
+// ignore: unintended_html_in_doc_comment
+/// Maintains the current list of all activities for <share-album-id, asset>
+@riverpod
+class AlbumActivity extends _$AlbumActivity {
+  @override
+  Future<List<Activity>> build(String albumId, [String? assetId]) async {
+    return ref.watch(activityServiceProvider).getAllActivities(albumId, assetId: assetId);
+  }
+
+  Future<void> removeActivity(String id) async {
+    if (await ref.watch(activityServiceProvider).removeActivity(id)) {
+      final removedActivity = _removeFromState(id);
+      if (removedActivity == null) {
+        return;
+      }
+
+      if (assetId != null) {
+        ref.read(albumActivityProvider(albumId).notifier)._removeFromState(id);
+      }
+
+      if (removedActivity.type == ActivityType.comment) {
+        ref.watch(activityStatisticsProvider(albumId, assetId).notifier).removeActivity();
+        if (assetId != null) {
+          ref.watch(activityStatisticsProvider(albumId).notifier).removeActivity();
+        }
+      }
+    }
+  }
+
+  Future<void> addLike() async {
+    final activity = await ref.watch(activityServiceProvider).addActivity(albumId, ActivityType.like, assetId: assetId);
+    if (activity.hasValue) {
+      _addToState(activity.requireValue);
+      if (assetId != null) {
+        ref.read(albumActivityProvider(albumId).notifier)._addToState(activity.requireValue);
+      }
+    }
+  }
+
+  Future<void> addComment(String comment) async {
+    final activity = await ref
+        .watch(activityServiceProvider)
+        .addActivity(albumId, ActivityType.comment, assetId: assetId, comment: comment);
+
+    if (activity.hasValue) {
+      _addToState(activity.requireValue);
+      if (assetId != null) {
+        ref.read(albumActivityProvider(albumId).notifier)._addToState(activity.requireValue);
+      }
+      ref.watch(activityStatisticsProvider(albumId, assetId).notifier).addActivity();
+      // The previous addActivity call would increase the count of an asset if assetId != null
+      // To also increase the activity count of the album, calling it once again with assetId set to null
+      if (assetId != null) {
+        ref.watch(activityStatisticsProvider(albumId).notifier).addActivity();
+      }
+    }
+  }
+
+  void _addToState(Activity activity) {
+    final activities = state.valueOrNull ?? [];
+    if (activities.any((a) => a.id == activity.id)) {
+      return;
+    }
+    state = AsyncData([...activities, activity]);
+  }
+
+  Activity? _removeFromState(String id) {
+    final activities = state.valueOrNull;
+    if (activities == null) {
+      return null;
+    }
+    final activity = activities.firstWhereOrNull((a) => a.id == id);
+    if (activity == null) {
+      return null;
+    }
+
+    final updated = [...activities]..remove(activity);
+    state = AsyncData(updated);
+    return activity;
+  }
+}
+
+/// Mock class for testing
+abstract class AlbumActivityInternal extends _$AlbumActivity {}

mobile/lib/providers/activity.provider.g.dart

@@ -0,0 +1,194 @@
+// GENERATED CODE - DO NOT MODIFY BY HAND
+
+part of 'activity.provider.dart';
+
+// **************************************************************************
+// RiverpodGenerator
+// **************************************************************************
+
+String _$albumActivityHash() => r'154e8ae98da3efc142369eae46d4005468fd67da';
+
+/// Copied from Dart SDK
+class _SystemHash {
+  _SystemHash._();
+
+  static int combine(int hash, int value) {
+    // ignore: parameter_assignments
+    hash = 0x1fffffff & (hash + value);
+    // ignore: parameter_assignments
+    hash = 0x1fffffff & (hash + ((0x0007ffff & hash) << 10));
+    return hash ^ (hash >> 6);
+  }
+
+  static int finish(int hash) {
+    // ignore: parameter_assignments
+    hash = 0x1fffffff & (hash + ((0x03ffffff & hash) << 3));
+    // ignore: parameter_assignments
+    hash = hash ^ (hash >> 11);
+    return 0x1fffffff & (hash + ((0x00003fff & hash) << 15));
+  }
+}
+
+abstract class _$AlbumActivity
+    extends BuildlessAutoDisposeAsyncNotifier<List<Activity>> {
+  late final String albumId;
+  late final String? assetId;
+
+  FutureOr<List<Activity>> build(String albumId, [String? assetId]);
+}
+
+/// Maintains the current list of all activities for <share-album-id, asset>
+///
+/// Copied from [AlbumActivity].
+@ProviderFor(AlbumActivity)
+const albumActivityProvider = AlbumActivityFamily();
+
+/// Maintains the current list of all activities for <share-album-id, asset>
+///
+/// Copied from [AlbumActivity].
+class AlbumActivityFamily extends Family<AsyncValue<List<Activity>>> {
+  /// Maintains the current list of all activities for <share-album-id, asset>
+  ///
+  /// Copied from [AlbumActivity].
+  const AlbumActivityFamily();
+
+  /// Maintains the current list of all activities for <share-album-id, asset>
+  ///
+  /// Copied from [AlbumActivity].
+  AlbumActivityProvider call(String albumId, [String? assetId]) {
+    return AlbumActivityProvider(albumId, assetId);
+  }
+
+  @override
+  AlbumActivityProvider getProviderOverride(
+    covariant AlbumActivityProvider provider,
+  ) {
+    return call(provider.albumId, provider.assetId);
+  }
+
+  static const Iterable<ProviderOrFamily>? _dependencies = null;
+
+  @override
+  Iterable<ProviderOrFamily>? get dependencies => _dependencies;
+
+  static const Iterable<ProviderOrFamily>? _allTransitiveDependencies = null;
+
+  @override
+  Iterable<ProviderOrFamily>? get allTransitiveDependencies =>
+      _allTransitiveDependencies;
+
+  @override
+  String? get name => r'albumActivityProvider';
+}
+
+/// Maintains the current list of all activities for <share-album-id, asset>
+///
+/// Copied from [AlbumActivity].
+class AlbumActivityProvider
+    extends
+        AutoDisposeAsyncNotifierProviderImpl<AlbumActivity, List<Activity>> {
+  /// Maintains the current list of all activities for <share-album-id, asset>
+  ///
+  /// Copied from [AlbumActivity].
+  AlbumActivityProvider(String albumId, [String? assetId])
+    : this._internal(
+        () => AlbumActivity()
+          ..albumId = albumId
+          ..assetId = assetId,
+        from: albumActivityProvider,
+        name: r'albumActivityProvider',
+        debugGetCreateSourceHash: const bool.fromEnvironment('dart.vm.product')
+            ? null
+            : _$albumActivityHash,
+        dependencies: AlbumActivityFamily._dependencies,
+        allTransitiveDependencies:
+            AlbumActivityFamily._allTransitiveDependencies,
+        albumId: albumId,
+        assetId: assetId,
+      );
+
+  AlbumActivityProvider._internal(
+    super._createNotifier, {
+    required super.name,
+    required super.dependencies,
+    required super.allTransitiveDependencies,
+    required super.debugGetCreateSourceHash,
+    required super.from,
+    required this.albumId,
+    required this.assetId,
+  }) : super.internal();
+
+  final String albumId;
+  final String? assetId;
+
+  @override
+  FutureOr<List<Activity>> runNotifierBuild(covariant AlbumActivity notifier) {
+    return notifier.build(albumId, assetId);
+  }
+
+  @override
+  Override overrideWith(AlbumActivity Function() create) {
+    return ProviderOverride(
+      origin: this,
+      override: AlbumActivityProvider._internal(
+        () => create()
+          ..albumId = albumId
+          ..assetId = assetId,
+        from: from,
+        name: null,
+        dependencies: null,
+        allTransitiveDependencies: null,
+        debugGetCreateSourceHash: null,
+        albumId: albumId,
+        assetId: assetId,
+      ),
+    );
+  }
+
+  @override
+  AutoDisposeAsyncNotifierProviderElement<AlbumActivity, List<Activity>>
+  createElement() {
+    return _AlbumActivityProviderElement(this);
+  }
+
+  @override
+  bool operator ==(Object other) {
+    return other is AlbumActivityProvider &&
+        other.albumId == albumId &&
+        other.assetId == assetId;
+  }
+
+  @override
+  int get hashCode {
+    var hash = _SystemHash.combine(0, runtimeType.hashCode);
+    hash = _SystemHash.combine(hash, albumId.hashCode);
+    hash = _SystemHash.combine(hash, assetId.hashCode);
+
+    return _SystemHash.finish(hash);
+  }
+}
+
+@Deprecated('Will be removed in 3.0. Use Ref instead')
+// ignore: unused_element
+mixin AlbumActivityRef on AutoDisposeAsyncNotifierProviderRef<List<Activity>> {
+  /// The parameter `albumId` of this provider.
+  String get albumId;
+
+  /// The parameter `assetId` of this provider.
+  String? get assetId;
+}
+
+class _AlbumActivityProviderElement
+    extends
+        AutoDisposeAsyncNotifierProviderElement<AlbumActivity, List<Activity>>
+    with AlbumActivityRef {
+  _AlbumActivityProviderElement(super.provider);
+
+  @override
+  String get albumId => (origin as AlbumActivityProvider).albumId;
+  @override
+  String? get assetId => (origin as AlbumActivityProvider).assetId;
+}
+
+// ignore_for_file: type=lint
+// ignore_for_file: subtype_of_sealed_class, invalid_use_of_internal_member, invalid_use_of_visible_for_testing_member, deprecated_member_use_from_same_package

mobile/lib/providers/activity_service.provider.dart

@@ -0,0 +1,15 @@
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+import 'package:immich_mobile/providers/infrastructure/asset.provider.dart';
+import 'package:immich_mobile/providers/infrastructure/timeline.provider.dart';
+import 'package:immich_mobile/repositories/activity_api.repository.dart';
+import 'package:immich_mobile/services/activity.service.dart';
+import 'package:riverpod_annotation/riverpod_annotation.dart';
+
+part 'activity_service.provider.g.dart';
+
+@riverpod
+ActivityService activityService(Ref ref) => ActivityService(
+  ref.watch(activityApiRepositoryProvider),
+  ref.watch(timelineFactoryProvider),
+  ref.watch(assetServiceProvider),
+);

mobile/lib/providers/activity_service.provider.g.dart

@@ -0,0 +1,27 @@
+// GENERATED CODE - DO NOT MODIFY BY HAND
+
+part of 'activity_service.provider.dart';
+
+// **************************************************************************
+// RiverpodGenerator
+// **************************************************************************
+
+String _$activityServiceHash() => r'3ce0eb33948138057cc63f07a7598047b99e7599';
+
+/// See also [activityService].
+@ProviderFor(activityService)
+final activityServiceProvider = AutoDisposeProvider<ActivityService>.internal(
+  activityService,
+  name: r'activityServiceProvider',
+  debugGetCreateSourceHash: const bool.fromEnvironment('dart.vm.product')
+      ? null
+      : _$activityServiceHash,
+  dependencies: null,
+  allTransitiveDependencies: null,
+);
+
+@Deprecated('Will be removed in 3.0. Use Ref instead')
+// ignore: unused_element
+typedef ActivityServiceRef = AutoDisposeProviderRef<ActivityService>;
+// ignore_for_file: type=lint
+// ignore_for_file: subtype_of_sealed_class, invalid_use_of_internal_member, invalid_use_of_visible_for_testing_member, deprecated_member_use_from_same_package

mobile/lib/providers/activity_statistics.provider.dart

@@ -0,0 +1,22 @@
+import 'package:immich_mobile/providers/activity_service.provider.dart';
+import 'package:riverpod_annotation/riverpod_annotation.dart';
+
+part 'activity_statistics.provider.g.dart';
+
+// ignore: unintended_html_in_doc_comment
+/// Maintains the current number of comments by <shared-album, asset>
+@riverpod
+class ActivityStatistics extends _$ActivityStatistics {
+  @override
+  int build(String albumId, [String? assetId]) {
+    ref.watch(activityServiceProvider).getStatistics(albumId, assetId: assetId).then((stats) => state = stats.comments);
+    return 0;
+  }
+
+  void addActivity() => state = state + 1;
+
+  void removeActivity() => state = state - 1;
+}
+
+/// Mock class for testing
+abstract class ActivityStatisticsInternal extends _$ActivityStatistics {}

mobile/lib/providers/activity_statistics.provider.g.dart

@@ -0,0 +1,191 @@
+// GENERATED CODE - DO NOT MODIFY BY HAND
+
+part of 'activity_statistics.provider.dart';
+
+// **************************************************************************
+// RiverpodGenerator
+// **************************************************************************
+
+String _$activityStatisticsHash() =>
+    r'1f43f0bcb11c754ca3cb586a13570db25023b9a8';
+
+/// Copied from Dart SDK
+class _SystemHash {
+  _SystemHash._();
+
+  static int combine(int hash, int value) {
+    // ignore: parameter_assignments
+    hash = 0x1fffffff & (hash + value);
+    // ignore: parameter_assignments
+    hash = 0x1fffffff & (hash + ((0x0007ffff & hash) << 10));
+    return hash ^ (hash >> 6);
+  }
+
+  static int finish(int hash) {
+    // ignore: parameter_assignments
+    hash = 0x1fffffff & (hash + ((0x03ffffff & hash) << 3));
+    // ignore: parameter_assignments
+    hash = hash ^ (hash >> 11);
+    return 0x1fffffff & (hash + ((0x00003fff & hash) << 15));
+  }
+}
+
+abstract class _$ActivityStatistics extends BuildlessAutoDisposeNotifier<int> {
+  late final String albumId;
+  late final String? assetId;
+
+  int build(String albumId, [String? assetId]);
+}
+
+/// Maintains the current number of comments by <shared-album, asset>
+///
+/// Copied from [ActivityStatistics].
+@ProviderFor(ActivityStatistics)
+const activityStatisticsProvider = ActivityStatisticsFamily();
+
+/// Maintains the current number of comments by <shared-album, asset>
+///
+/// Copied from [ActivityStatistics].
+class ActivityStatisticsFamily extends Family<int> {
+  /// Maintains the current number of comments by <shared-album, asset>
+  ///
+  /// Copied from [ActivityStatistics].
+  const ActivityStatisticsFamily();
+
+  /// Maintains the current number of comments by <shared-album, asset>
+  ///
+  /// Copied from [ActivityStatistics].
+  ActivityStatisticsProvider call(String albumId, [String? assetId]) {
+    return ActivityStatisticsProvider(albumId, assetId);
+  }
+
+  @override
+  ActivityStatisticsProvider getProviderOverride(
+    covariant ActivityStatisticsProvider provider,
+  ) {
+    return call(provider.albumId, provider.assetId);
+  }
+
+  static const Iterable<ProviderOrFamily>? _dependencies = null;
+
+  @override
+  Iterable<ProviderOrFamily>? get dependencies => _dependencies;
+
+  static const Iterable<ProviderOrFamily>? _allTransitiveDependencies = null;
+
+  @override
+  Iterable<ProviderOrFamily>? get allTransitiveDependencies =>
+      _allTransitiveDependencies;
+
+  @override
+  String? get name => r'activityStatisticsProvider';
+}
+
+/// Maintains the current number of comments by <shared-album, asset>
+///
+/// Copied from [ActivityStatistics].
+class ActivityStatisticsProvider
+    extends AutoDisposeNotifierProviderImpl<ActivityStatistics, int> {
+  /// Maintains the current number of comments by <shared-album, asset>
+  ///
+  /// Copied from [ActivityStatistics].
+  ActivityStatisticsProvider(String albumId, [String? assetId])
+    : this._internal(
+        () => ActivityStatistics()
+          ..albumId = albumId
+          ..assetId = assetId,
+        from: activityStatisticsProvider,
+        name: r'activityStatisticsProvider',
+        debugGetCreateSourceHash: const bool.fromEnvironment('dart.vm.product')
+            ? null
+            : _$activityStatisticsHash,
+        dependencies: ActivityStatisticsFamily._dependencies,
+        allTransitiveDependencies:
+            ActivityStatisticsFamily._allTransitiveDependencies,
+        albumId: albumId,
+        assetId: assetId,
+      );
+
+  ActivityStatisticsProvider._internal(
+    super._createNotifier, {
+    required super.name,
+    required super.dependencies,
+    required super.allTransitiveDependencies,
+    required super.debugGetCreateSourceHash,
+    required super.from,
+    required this.albumId,
+    required this.assetId,
+  }) : super.internal();
+
+  final String albumId;
+  final String? assetId;
+
+  @override
+  int runNotifierBuild(covariant ActivityStatistics notifier) {
+    return notifier.build(albumId, assetId);
+  }
+
+  @override
+  Override overrideWith(ActivityStatistics Function() create) {
+    return ProviderOverride(
+      origin: this,
+      override: ActivityStatisticsProvider._internal(
+        () => create()
+          ..albumId = albumId
+          ..assetId = assetId,
+        from: from,
+        name: null,
+        dependencies: null,
+        allTransitiveDependencies: null,
+        debugGetCreateSourceHash: null,
+        albumId: albumId,
+        assetId: assetId,
+      ),
+    );
+  }
+
+  @override
+  AutoDisposeNotifierProviderElement<ActivityStatistics, int> createElement() {
+    return _ActivityStatisticsProviderElement(this);
+  }
+
+  @override
+  bool operator ==(Object other) {
+    return other is ActivityStatisticsProvider &&
+        other.albumId == albumId &&
+        other.assetId == assetId;
+  }
+
+  @override
+  int get hashCode {
+    var hash = _SystemHash.combine(0, runtimeType.hashCode);
+    hash = _SystemHash.combine(hash, albumId.hashCode);
+    hash = _SystemHash.combine(hash, assetId.hashCode);
+
+    return _SystemHash.finish(hash);
+  }
+}
+
+@Deprecated('Will be removed in 3.0. Use Ref instead')
+// ignore: unused_element
+mixin ActivityStatisticsRef on AutoDisposeNotifierProviderRef<int> {
+  /// The parameter `albumId` of this provider.
+  String get albumId;
+
+  /// The parameter `assetId` of this provider.
+  String? get assetId;
+}
+
+class _ActivityStatisticsProviderElement
+    extends AutoDisposeNotifierProviderElement<ActivityStatistics, int>
+    with ActivityStatisticsRef {
+  _ActivityStatisticsProviderElement(super.provider);
+
+  @override
+  String get albumId => (origin as ActivityStatisticsProvider).albumId;
+  @override
+  String? get assetId => (origin as ActivityStatisticsProvider).assetId;
+}
+
+// ignore_for_file: type=lint
+// ignore_for_file: subtype_of_sealed_class, invalid_use_of_internal_member, invalid_use_of_visible_for_testing_member, deprecated_member_use_from_same_package

mobile/lib/providers/album/album.provider.dart

@@ -0,0 +1,151 @@
+import 'dart:async';
+
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+import 'package:immich_mobile/constants/enums.dart';
+import 'package:immich_mobile/domain/models/user.model.dart';
+import 'package:immich_mobile/entities/album.entity.dart';
+import 'package:immich_mobile/entities/asset.entity.dart';
+import 'package:immich_mobile/models/albums/album_search.model.dart';
+import 'package:immich_mobile/services/album.service.dart';
+
+final isRefreshingRemoteAlbumProvider = StateProvider<bool>((ref) => false);
+
+class AlbumNotifier extends StateNotifier<List<Album>> {
+  AlbumNotifier(this.albumService, this.ref) : super([]) {
+    albumService.getAllRemoteAlbums().then((value) {
+      if (mounted) {
+        state = value;
+      }
+    });
+
+    _streamSub = albumService.watchRemoteAlbums().listen((data) => state = data);
+  }
+
+  final AlbumService albumService;
+  final Ref ref;
+  late final StreamSubscription<List<Album>> _streamSub;
+
+  Future<void> refreshRemoteAlbums() async {
+    ref.read(isRefreshingRemoteAlbumProvider.notifier).state = true;
+    await albumService.refreshRemoteAlbums();
+    ref.read(isRefreshingRemoteAlbumProvider.notifier).state = false;
+  }
+
+  Future<void> refreshDeviceAlbums() => albumService.refreshDeviceAlbums();
+
+  Future<bool> deleteAlbum(Album album) => albumService.deleteAlbum(album);
+
+  Future<Album?> createAlbum(String albumTitle, Set<Asset> assets) => albumService.createAlbum(albumTitle, assets, []);
+
+  Future<Album?> getAlbumByName(String albumName, {bool? remote, bool? shared, bool? owner}) =>
+      albumService.getAlbumByName(albumName, remote: remote, shared: shared, owner: owner);
+
+  /// Create an album on the server with the same name as the selected album for backup
+  /// First this will check if the album already exists on the server with name
+  /// If it does not exist, it will create the album on the server
+  Future<void> createSyncAlbum(String albumName) async {
+    final album = await getAlbumByName(albumName, remote: true, owner: true);
+    if (album != null) {
+      return;
+    }
+
+    await createAlbum(albumName, {});
+  }
+
+  Future<bool> leaveAlbum(Album album) async {
+    var res = await albumService.leaveAlbum(album);
+
+    if (res) {
+      await deleteAlbum(album);
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  void searchAlbums(String searchTerm, QuickFilterMode filterMode) async {
+    state = await albumService.search(searchTerm, filterMode);
+  }
+
+  Future<void> addUsers(Album album, List<String> userIds) async {
+    await albumService.addUsers(album, userIds);
+  }
+
+  Future<bool> removeUser(Album album, UserDto user) async {
+    final isRemoved = await albumService.removeUser(album, user);
+
+    if (isRemoved && album.sharedUsers.isEmpty) {
+      state = state.where((element) => element.id != album.id).toList();
+    }
+
+    return isRemoved;
+  }
+
+  Future<void> addAssets(Album album, Iterable<Asset> assets) async {
+    await albumService.addAssets(album, assets);
+  }
+
+  Future<bool> removeAsset(Album album, Iterable<Asset> assets) async {
+    return await albumService.removeAsset(album, assets);
+  }
+
+  Future<bool> setActivitystatus(Album album, bool enabled) {
+    return albumService.setActivityStatus(album, enabled);
+  }
+
+  Future<Album?> toggleSortOrder(Album album) {
+    final order = album.sortOrder == SortOrder.asc ? SortOrder.desc : SortOrder.asc;
+
+    return albumService.updateSortOrder(album, order);
+  }
+
+  @override
+  void dispose() {
+    _streamSub.cancel();
+    super.dispose();
+  }
+}
+
+final albumProvider = StateNotifierProvider.autoDispose<AlbumNotifier, List<Album>>((ref) {
+  return AlbumNotifier(ref.watch(albumServiceProvider), ref);
+});
+
+final albumWatcher = StreamProvider.autoDispose.family<Album, int>((ref, id) async* {
+  final albumService = ref.watch(albumServiceProvider);
+
+  final album = await albumService.getAlbumById(id);
+  if (album != null) {
+    yield album;
+  }
+
+  await for (final album in albumService.watchAlbum(id)) {
+    if (album != null) {
+      yield album;
+    }
+  }
+});
+
+class LocalAlbumsNotifier extends StateNotifier<List<Album>> {
+  LocalAlbumsNotifier(this.albumService) : super([]) {
+    albumService.getAllLocalAlbums().then((value) {
+      if (mounted) {
+        state = value;
+      }
+    });
+
+    _streamSub = albumService.watchLocalAlbums().listen((data) => state = data);
+  }
+
+  final AlbumService albumService;
+  late final StreamSubscription<List<Album>> _streamSub;
+
+  @override
+  void dispose() {
+    _streamSub.cancel();
+    super.dispose();
+  }
+}
+
+final localAlbumsProvider = StateNotifierProvider.autoDispose<LocalAlbumsNotifier, List<Album>>((ref) {
+  return LocalAlbumsNotifier(ref.watch(albumServiceProvider));
+});

mobile/lib/providers/album/album_sort_by_options.provider.dart

@@ -0,0 +1,115 @@
+import 'package:collection/collection.dart';
+import 'package:immich_mobile/providers/app_settings.provider.dart';
+import 'package:immich_mobile/services/app_settings.service.dart';
+import 'package:immich_mobile/entities/album.entity.dart';
+import 'package:riverpod_annotation/riverpod_annotation.dart';
+
+part 'album_sort_by_options.provider.g.dart';
+
+typedef AlbumSortFn = List<Album> Function(List<Album> albums, bool isReverse);
+
+class _AlbumSortHandlers {
+  const _AlbumSortHandlers._();
+
+  static const AlbumSortFn created = _sortByCreated;
+  static List<Album> _sortByCreated(List<Album> albums, bool isReverse) {
+    final sorted = albums.sortedBy((album) => album.createdAt);
+    return (isReverse ? sorted.reversed : sorted).toList();
+  }
+
+  static const AlbumSortFn title = _sortByTitle;
+  static List<Album> _sortByTitle(List<Album> albums, bool isReverse) {
+    final sorted = albums.sortedBy((album) => album.name);
+    return (isReverse ? sorted.reversed : sorted).toList();
+  }
+
+  static const AlbumSortFn lastModified = _sortByLastModified;
+  static List<Album> _sortByLastModified(List<Album> albums, bool isReverse) {
+    final sorted = albums.sortedBy((album) => album.modifiedAt);
+    return (isReverse ? sorted.reversed : sorted).toList();
+  }
+
+  static const AlbumSortFn assetCount = _sortByAssetCount;
+  static List<Album> _sortByAssetCount(List<Album> albums, bool isReverse) {
+    final sorted = albums.sorted((a, b) => a.assetCount.compareTo(b.assetCount));
+    return (isReverse ? sorted.reversed : sorted).toList();
+  }
+
+  static const AlbumSortFn mostRecent = _sortByMostRecent;
+  static List<Album> _sortByMostRecent(List<Album> albums, bool isReverse) {
+    final sorted = albums.sorted((a, b) {
+      if (a.endDate == null && b.endDate == null) {
+        return 0;
+      }
+
+      if (a.endDate == null) {
+        // Put nulls at the end for recent sorting
+        return 1;
+      }
+
+      if (b.endDate == null) {
+        return -1;
+      }
+
+      // Sort by descending recent date
+      return b.endDate!.compareTo(a.endDate!);
+    });
+    return (isReverse ? sorted.reversed : sorted).toList();
+  }
+
+  static const AlbumSortFn mostOldest = _sortByMostOldest;
+  static List<Album> _sortByMostOldest(List<Album> albums, bool isReverse) {
+    final sorted = albums.sorted((a, b) {
+      if (a.startDate != null && b.startDate != null) {
+        return a.startDate!.compareTo(b.startDate!);
+      }
+      if (a.startDate == null) return 1;
+      if (b.startDate == null) return -1;
+      return 0;
+    });
+    return (isReverse ? sorted.reversed : sorted).toList();
+  }
+}
+
+// Store index allows us to re-arrange the values without affecting the saved prefs
+enum AlbumSortMode {
+  title(1, "library_page_sort_title", _AlbumSortHandlers.title),
+  assetCount(4, "library_page_sort_asset_count", _AlbumSortHandlers.assetCount),
+  lastModified(3, "library_page_sort_last_modified", _AlbumSortHandlers.lastModified),
+  created(0, "library_page_sort_created", _AlbumSortHandlers.created),
+  mostRecent(2, "sort_recent", _AlbumSortHandlers.mostRecent),
+  mostOldest(5, "sort_oldest", _AlbumSortHandlers.mostOldest);
+
+  final int storeIndex;
+  final String label;
+  final AlbumSortFn sortFn;
+
+  const AlbumSortMode(this.storeIndex, this.label, this.sortFn);
+}
+
+@riverpod
+class AlbumSortByOptions extends _$AlbumSortByOptions {
+  @override
+  AlbumSortMode build() {
+    final sortOpt = ref.watch(appSettingsServiceProvider).getSetting(AppSettingsEnum.selectedAlbumSortOrder);
+    return AlbumSortMode.values.firstWhere((e) => e.storeIndex == sortOpt, orElse: () => AlbumSortMode.title);
+  }
+
+  void changeSortMode(AlbumSortMode sortOption) {
+    state = sortOption;
+    ref.watch(appSettingsServiceProvider).setSetting(AppSettingsEnum.selectedAlbumSortOrder, sortOption.storeIndex);
+  }
+}
+
+@riverpod
+class AlbumSortOrder extends _$AlbumSortOrder {
+  @override
+  bool build() {
+    return ref.watch(appSettingsServiceProvider).getSetting(AppSettingsEnum.selectedAlbumSortReverse);
+  }
+
+  void changeSortDirection(bool isReverse) {
+    state = isReverse;
+    ref.watch(appSettingsServiceProvider).setSetting(AppSettingsEnum.selectedAlbumSortReverse, isReverse);
+  }
+}

mobile/lib/providers/album/album_sort_by_options.provider.g.dart

@@ -0,0 +1,43 @@
+// GENERATED CODE - DO NOT MODIFY BY HAND
+
+part of 'album_sort_by_options.provider.dart';
+
+// **************************************************************************
+// RiverpodGenerator
+// **************************************************************************
+
+String _$albumSortByOptionsHash() =>
+    r'dd8da5e730af555de1b86c3b157b6c93183523ac';
+
+/// See also [AlbumSortByOptions].
+@ProviderFor(AlbumSortByOptions)
+final albumSortByOptionsProvider =
+    AutoDisposeNotifierProvider<AlbumSortByOptions, AlbumSortMode>.internal(
+      AlbumSortByOptions.new,
+      name: r'albumSortByOptionsProvider',
+      debugGetCreateSourceHash: const bool.fromEnvironment('dart.vm.product')
+          ? null
+          : _$albumSortByOptionsHash,
+      dependencies: null,
+      allTransitiveDependencies: null,
+    );
+
+typedef _$AlbumSortByOptions = AutoDisposeNotifier<AlbumSortMode>;
+String _$albumSortOrderHash() => r'573dea45b4519e69386fc7104c72522e35713440';
+
+/// See also [AlbumSortOrder].
+@ProviderFor(AlbumSortOrder)
+final albumSortOrderProvider =
+    AutoDisposeNotifierProvider<AlbumSortOrder, bool>.internal(
+      AlbumSortOrder.new,
+      name: r'albumSortOrderProvider',
+      debugGetCreateSourceHash: const bool.fromEnvironment('dart.vm.product')
+          ? null
+          : _$albumSortOrderHash,
+      dependencies: null,
+      allTransitiveDependencies: null,
+    );
+
+typedef _$AlbumSortOrder = AutoDisposeNotifier<bool>;
+// ignore_for_file: type=lint
+// ignore_for_file: subtype_of_sealed_class, invalid_use_of_internal_member, invalid_use_of_visible_for_testing_member, deprecated_member_use_from_same_package

mobile/lib/providers/album/album_title.provider.dart

@@ -0,0 +1,15 @@
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+
+class AlbumTitleNotifier extends StateNotifier<String> {
+  AlbumTitleNotifier() : super("");
+
+  setAlbumTitle(String title) {
+    state = title;
+  }
+
+  clearAlbumTitle() {
+    state = "";
+  }
+}
+
+final albumTitleProvider = StateNotifierProvider<AlbumTitleNotifier, String>((ref) => AlbumTitleNotifier());

mobile/lib/providers/album/album_viewer.provider.dart

@@ -0,0 +1,74 @@
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+import 'package:immich_mobile/entities/album.entity.dart';
+import 'package:immich_mobile/models/albums/album_viewer_page_state.model.dart';
+import 'package:immich_mobile/services/album.service.dart';
+
+class AlbumViewerNotifier extends StateNotifier<AlbumViewerPageState> {
+  AlbumViewerNotifier(this.ref)
+    : super(const AlbumViewerPageState(editTitleText: "", isEditAlbum: false, editDescriptionText: ""));
+
+  final Ref ref;
+
+  void enableEditAlbum() {
+    state = state.copyWith(isEditAlbum: true);
+  }
+
+  void disableEditAlbum() {
+    state = state.copyWith(isEditAlbum: false);
+  }
+
+  void setEditTitleText(String newTitle) {
+    state = state.copyWith(editTitleText: newTitle);
+  }
+
+  void setEditDescriptionText(String newDescription) {
+    state = state.copyWith(editDescriptionText: newDescription);
+  }
+
+  void remoteEditTitleText() {
+    state = state.copyWith(editTitleText: "");
+  }
+
+  void remoteEditDescriptionText() {
+    state = state.copyWith(editDescriptionText: "");
+  }
+
+  void resetState() {
+    state = state.copyWith(editTitleText: "", isEditAlbum: false, editDescriptionText: "");
+  }
+
+  Future<bool> changeAlbumTitle(Album album, String newAlbumTitle) async {
+    AlbumService service = ref.watch(albumServiceProvider);
+
+    bool isSuccess = await service.changeTitleAlbum(album, newAlbumTitle);
+
+    if (isSuccess) {
+      state = state.copyWith(editTitleText: "", isEditAlbum: false);
+
+      return true;
+    }
+
+    state = state.copyWith(editTitleText: "", isEditAlbum: false);
+    return false;
+  }
+
+  Future<bool> changeAlbumDescription(Album album, String newAlbumDescription) async {
+    AlbumService service = ref.watch(albumServiceProvider);
+
+    bool isSuccess = await service.changeDescriptionAlbum(album, newAlbumDescription);
+
+    if (isSuccess) {
+      state = state.copyWith(editDescriptionText: "", isEditAlbum: false);
+
+      return true;
+    }
+
+    state = state.copyWith(editDescriptionText: "", isEditAlbum: false);
+
+    return false;
+  }
+}
+
+final albumViewerProvider = StateNotifierProvider<AlbumViewerNotifier, AlbumViewerPageState>((ref) {
+  return AlbumViewerNotifier(ref);
+});

mobile/lib/providers/album/current_album.provider.dart

@@ -0,0 +1,15 @@
+import 'package:immich_mobile/entities/album.entity.dart';
+import 'package:riverpod_annotation/riverpod_annotation.dart';
+
+part 'current_album.provider.g.dart';
+
+@riverpod
+class CurrentAlbum extends _$CurrentAlbum {
+  @override
+  Album? build() => null;
+
+  void set(Album? a) => state = a;
+}
+
+/// Mock class for testing
+abstract class CurrentAlbumInternal extends _$CurrentAlbum {}

mobile/lib/providers/album/current_album.provider.g.dart

@@ -0,0 +1,26 @@
+// GENERATED CODE - DO NOT MODIFY BY HAND
+
+part of 'current_album.provider.dart';
+
+// **************************************************************************
+// RiverpodGenerator
+// **************************************************************************
+
+String _$currentAlbumHash() => r'61f00273d6b69da45add1532cc3d3a076ee55110';
+
+/// See also [CurrentAlbum].
+@ProviderFor(CurrentAlbum)
+final currentAlbumProvider =
+    AutoDisposeNotifierProvider<CurrentAlbum, Album?>.internal(
+      CurrentAlbum.new,
+      name: r'currentAlbumProvider',
+      debugGetCreateSourceHash: const bool.fromEnvironment('dart.vm.product')
+          ? null
+          : _$currentAlbumHash,
+      dependencies: null,
+      allTransitiveDependencies: null,
+    );
+
+typedef _$CurrentAlbum = AutoDisposeNotifier<Album?>;
+// ignore_for_file: type=lint
+// ignore_for_file: subtype_of_sealed_class, invalid_use_of_internal_member, invalid_use_of_visible_for_testing_member, deprecated_member_use_from_same_package

mobile/lib/providers/album/suggested_shared_users.provider.dart

@@ -0,0 +1,14 @@
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+import 'package:immich_mobile/domain/models/user.model.dart';
+import 'package:immich_mobile/domain/services/user.service.dart';
+import 'package:immich_mobile/providers/infrastructure/user.provider.dart';
+import 'package:immich_mobile/providers/user.provider.dart';
+
+final otherUsersProvider = FutureProvider.autoDispose<List<UserDto>>((ref) async {
+  UserService userService = ref.watch(userServiceProvider);
+  final currentUser = ref.watch(currentUserProvider);
+
+  final allUsers = await userService.getAll();
+  allUsers.removeWhere((u) => currentUser?.id == u.id);
+  return allUsers;
+});

mobile/lib/providers/api.provider.dart

@@ -0,0 +1,8 @@
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+import 'package:immich_mobile/services/api.service.dart';
+import 'package:riverpod_annotation/riverpod_annotation.dart';
+
+part 'api.provider.g.dart';
+
+@Riverpod(keepAlive: true)
+ApiService apiService(Ref _) => ApiService();

mobile/lib/providers/api.provider.g.dart

@@ -0,0 +1,27 @@
+// GENERATED CODE - DO NOT MODIFY BY HAND
+
+part of 'api.provider.dart';
+
+// **************************************************************************
+// RiverpodGenerator
+// **************************************************************************
+
+String _$apiServiceHash() => r'187a7de59b064fab1104c23717f18ce0ae3e426c';
+
+/// See also [apiService].
+@ProviderFor(apiService)
+final apiServiceProvider = Provider<ApiService>.internal(
+  apiService,
+  name: r'apiServiceProvider',
+  debugGetCreateSourceHash: const bool.fromEnvironment('dart.vm.product')
+      ? null
+      : _$apiServiceHash,
+  dependencies: null,
+  allTransitiveDependencies: null,
+);
+
+@Deprecated('Will be removed in 3.0. Use Ref instead')
+// ignore: unused_element
+typedef ApiServiceRef = ProviderRef<ApiService>;
+// ignore_for_file: type=lint
+// ignore_for_file: subtype_of_sealed_class, invalid_use_of_internal_member, invalid_use_of_visible_for_testing_member, deprecated_member_use_from_same_package

mobile/lib/providers/app_life_cycle.provider.dart

@@ -0,0 +1,292 @@
+import 'dart:async';
+
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+import 'package:immich_mobile/domain/models/store.model.dart';
+import 'package:immich_mobile/domain/services/log.service.dart';
+import 'package:immich_mobile/entities/store.entity.dart';
+import 'package:immich_mobile/extensions/platform_extensions.dart';
+import 'package:immich_mobile/models/backup/backup_state.model.dart';
+import 'package:immich_mobile/providers/album/album.provider.dart';
+import 'package:immich_mobile/providers/app_settings.provider.dart';
+import 'package:immich_mobile/providers/asset.provider.dart';
+import 'package:immich_mobile/providers/auth.provider.dart';
+import 'package:immich_mobile/providers/background_sync.provider.dart';
+import 'package:immich_mobile/providers/backup/backup.provider.dart';
+import 'package:immich_mobile/providers/backup/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';
+import 'package:immich_mobile/providers/tab.provider.dart';
+import 'package:immich_mobile/providers/websocket.provider.dart';
+import 'package:immich_mobile/services/app_settings.service.dart';
+import 'package:immich_mobile/services/background.service.dart';
+import 'package:isar/isar.dart';
+import 'package:logging/logging.dart';
+import 'package:permission_handler/permission_handler.dart';
+
+enum AppLifeCycleEnum { active, inactive, paused, resumed, detached, hidden }
+
+class AppLifeCycleNotifier extends StateNotifier<AppLifeCycleEnum> {
+  final Ref _ref;
+  bool _wasPaused = false;
+
+  // Add operation coordination
+  Completer<void>? _resumeOperation;
+  Completer<void>? _pauseOperation;
+
+  final _log = Logger("AppLifeCycleNotifier");
+
+  AppLifeCycleNotifier(this._ref) : super(AppLifeCycleEnum.active);
+
+  AppLifeCycleEnum getAppState() {
+    return state;
+  }
+
+  void handleAppResume() async {
+    state = AppLifeCycleEnum.resumed;
+
+    // Prevent overlapping resume operations
+    if (_resumeOperation != null && !_resumeOperation!.isCompleted) {
+      await _resumeOperation!.future;
+      return;
+    }
+
+    // Cancel any ongoing pause operation
+    if (_pauseOperation != null && !_pauseOperation!.isCompleted) {
+      _pauseOperation!.complete();
+    }
+
+    _resumeOperation = Completer<void>();
+
+    try {
+      await _performResume();
+    } catch (e, stackTrace) {
+      _log.severe("Error during app resume", e, stackTrace);
+    } finally {
+      if (!_resumeOperation!.isCompleted) {
+        _resumeOperation!.complete();
+      }
+      _resumeOperation = null;
+    }
+  }
+
+  Future<void> _performResume() async {
+    // no need to resume because app was never really paused
+    if (!_wasPaused) return;
+    _wasPaused = false;
+
+    final isAuthenticated = _ref.read(authProvider).isAuthenticated;
+
+    // Needs to be logged in
+    if (isAuthenticated) {
+      // switch endpoint if needed
+      final endpoint = await _ref.read(authProvider.notifier).setOpenApiServiceEndpoint();
+      _log.info("Using server URL: $endpoint");
+
+      if (!Store.isBetaTimelineEnabled) {
+        final permission = _ref.watch(galleryPermissionNotifier);
+        if (permission.isGranted || permission.isLimited) {
+          await _ref.read(backupProvider.notifier).resumeBackup();
+          await _ref.read(backgroundServiceProvider).resumeServiceIfEnabled();
+        }
+      }
+
+      await _ref.read(serverInfoProvider.notifier).getServerVersion();
+    }
+
+    if (!Store.isBetaTimelineEnabled) {
+      switch (_ref.read(tabProvider)) {
+        case TabEnum.home:
+          await _ref.read(assetProvider.notifier).getAllAsset();
+
+        case TabEnum.albums:
+          await _ref.read(albumProvider.notifier).refreshRemoteAlbums();
+
+        case TabEnum.library:
+        case TabEnum.search:
+          break;
+      }
+    } else {
+      _ref.read(websocketProvider.notifier).connect();
+      await _handleBetaTimelineResume();
+    }
+
+    await _ref.read(notificationPermissionProvider.notifier).getNotificationPermission();
+
+    await _ref.read(galleryPermissionNotifier.notifier).getGalleryPermissionStatus();
+
+    if (!Store.isBetaTimelineEnabled) {
+      await _ref.read(iOSBackgroundSettingsProvider.notifier).refresh();
+
+      _ref.invalidate(memoryFutureProvider);
+    }
+  }
+
+  Future<void> _safeRun(Future<void> action, String debugName) async {
+    if (!_shouldContinueOperation()) {
+      return;
+    }
+
+    try {
+      await action;
+    } catch (e, stackTrace) {
+      _log.warning("Error during $debugName operation", e, stackTrace);
+    }
+  }
+
+  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));
+
+    final backgroundManager = _ref.read(backgroundSyncProvider);
+    final isAlbumLinkedSyncEnable = _ref.read(appSettingsServiceProvider).getSetting(AppSettingsEnum.syncAlbums);
+
+    try {
+      bool syncSuccess = false;
+      await Future.wait([
+        _safeRun(backgroundManager.syncLocal(full: CurrentPlatform.isAndroid ? true : false), "syncLocal"),
+        _safeRun(backgroundManager.syncRemote().then((success) => syncSuccess = success), "syncRemote"),
+      ]);
+      if (syncSuccess) {
+        await Future.wait([
+          _safeRun(backgroundManager.hashAssets(), "hashAssets").then((_) {
+            _resumeBackup();
+          }),
+          _resumeBackup(),
+          // TODO: Bring back when the soft freeze issue is addressed
+          // _safeRun(backgroundManager.syncCloudIds(), "syncCloudIds"),
+        ]);
+      } else {
+        await _safeRun(backgroundManager.hashAssets(), "hashAssets");
+      }
+
+      if (isAlbumLinkedSyncEnable) {
+        await _safeRun(backgroundManager.syncLinkedAlbum(), "syncLinkedAlbum");
+      }
+    } catch (e, stackTrace) {
+      _log.severe("Error during background sync", e, stackTrace);
+    }
+  }
+
+  Future<void> _resumeBackup() async {
+    final isEnableBackup = _ref.read(appSettingsServiceProvider).getSetting(AppSettingsEnum.enableBackup);
+
+    if (isEnableBackup) {
+      final currentUser = Store.tryGet(StoreKey.currentUser);
+      if (currentUser != null) {
+        await _safeRun(
+          _ref.read(driftBackupProvider.notifier).startForegroundBackup(currentUser.id),
+          "handleBackupResume",
+        );
+      }
+    }
+  }
+
+  // Helper method to check if operations should continue
+  bool _shouldContinueOperation() {
+    return [AppLifeCycleEnum.resumed, AppLifeCycleEnum.active].contains(state) &&
+        (_resumeOperation?.isCompleted == false || _resumeOperation == null);
+  }
+
+  void handleAppInactivity() {
+    state = AppLifeCycleEnum.inactive;
+    // do not stop/clean up anything on inactivity: issued on every orientation change
+  }
+
+  Future<void> handleAppPause() async {
+    state = AppLifeCycleEnum.paused;
+    _wasPaused = true;
+
+    // Prevent overlapping pause operations
+    if (_pauseOperation != null && !_pauseOperation!.isCompleted) {
+      await _pauseOperation!.future;
+      return;
+    }
+
+    // Cancel any ongoing resume operation
+    if (_resumeOperation != null && !_resumeOperation!.isCompleted) {
+      _resumeOperation!.complete();
+    }
+
+    _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);
+    } finally {
+      if (!_pauseOperation!.isCompleted) {
+        _pauseOperation!.complete();
+      }
+      _pauseOperation = null;
+    }
+  }
+
+  Future<void> _performPause() async {
+    if (_ref.read(authProvider).isAuthenticated) {
+      if (!Store.isBetaTimelineEnabled) {
+        // Do not cancel backup if manual upload is in progress
+        if (_ref.read(backupProvider.notifier).backupProgress != BackUpProgressEnum.manualInProgress) {
+          _ref.read(backupProvider.notifier).cancelBackup();
+        }
+      } else {
+        await _ref.read(driftBackupProvider.notifier).stopForegroundBackup();
+      }
+
+      _ref.read(websocketProvider.notifier).disconnect();
+    }
+
+    try {
+      await LogService.I.flush();
+    } catch (_) {}
+  }
+
+  Future<void> handleAppDetached() async {
+    state = AppLifeCycleEnum.detached;
+
+    if (Store.isBetaTimelineEnabled) {
+      unawaited(_ref.read(backgroundWorkerLockServiceProvider).unlock());
+    }
+
+    // Flush logs before closing database
+    try {
+      await LogService.I.flush();
+    } catch (_) {}
+
+    // Close Isar database safely
+    try {
+      final isar = Isar.getInstance();
+      if (isar != null && isar.isOpen) {
+        await isar.close();
+      }
+    } catch (_) {}
+
+    if (Store.isBetaTimelineEnabled) {
+      return;
+    }
+
+    // no guarantee this is called at all
+    try {
+      _ref.read(manualUploadProvider.notifier).cancelBackup();
+    } catch (_) {}
+  }
+
+  void handleAppHidden() {
+    state = AppLifeCycleEnum.hidden;
+    // do not stop/clean up anything on inactivity: issued on every orientation change
+  }
+}
+
+final appStateProvider = StateNotifierProvider<AppLifeCycleNotifier, AppLifeCycleEnum>((ref) {
+  return AppLifeCycleNotifier(ref);
+});

mobile/lib/providers/app_settings.provider.dart

@@ -0,0 +1,8 @@
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+import 'package:immich_mobile/services/app_settings.service.dart';
+import 'package:riverpod_annotation/riverpod_annotation.dart';
+
+part 'app_settings.provider.g.dart';
+
+@Riverpod(keepAlive: true)
+AppSettingsService appSettingsService(Ref _) => const AppSettingsService();

mobile/lib/providers/app_settings.provider.g.dart

@@ -0,0 +1,28 @@
+// GENERATED CODE - DO NOT MODIFY BY HAND
+
+part of 'app_settings.provider.dart';
+
+// **************************************************************************
+// RiverpodGenerator
+// **************************************************************************
+
+String _$appSettingsServiceHash() =>
+    r'89cece3a19e06612f5639ae290120e854a0c5a31';
+
+/// See also [appSettingsService].
+@ProviderFor(appSettingsService)
+final appSettingsServiceProvider = Provider<AppSettingsService>.internal(
+  appSettingsService,
+  name: r'appSettingsServiceProvider',
+  debugGetCreateSourceHash: const bool.fromEnvironment('dart.vm.product')
+      ? null
+      : _$appSettingsServiceHash,
+  dependencies: null,
+  allTransitiveDependencies: null,
+);
+
+@Deprecated('Will be removed in 3.0. Use Ref instead')
+// ignore: unused_element
+typedef AppSettingsServiceRef = ProviderRef<AppSettingsService>;
+// ignore_for_file: type=lint
+// ignore_for_file: subtype_of_sealed_class, invalid_use_of_internal_member, invalid_use_of_visible_for_testing_member, deprecated_member_use_from_same_package

mobile/lib/providers/asset.provider.dart

@@ -0,0 +1,182 @@
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+import 'package:immich_mobile/constants/enums.dart';
+import 'package:immich_mobile/domain/models/store.model.dart';
+import 'package:immich_mobile/domain/services/user.service.dart';
+import 'package:immich_mobile/entities/asset.entity.dart';
+import 'package:immich_mobile/entities/store.entity.dart';
+import 'package:immich_mobile/providers/infrastructure/user.provider.dart';
+import 'package:immich_mobile/providers/memory.provider.dart';
+import 'package:immich_mobile/services/album.service.dart';
+import 'package:immich_mobile/services/asset.service.dart';
+import 'package:immich_mobile/services/etag.service.dart';
+import 'package:immich_mobile/services/exif.service.dart';
+import 'package:immich_mobile/services/sync.service.dart';
+import 'package:logging/logging.dart';
+import 'package:immich_mobile/utils/debug_print.dart';
+
+final assetProvider = StateNotifierProvider<AssetNotifier, bool>((ref) {
+  return AssetNotifier(
+    ref.watch(assetServiceProvider),
+    ref.watch(albumServiceProvider),
+    ref.watch(userServiceProvider),
+    ref.watch(syncServiceProvider),
+    ref.watch(etagServiceProvider),
+    ref.watch(exifServiceProvider),
+    ref,
+  );
+});
+
+class AssetNotifier extends StateNotifier<bool> {
+  final AssetService _assetService;
+  final AlbumService _albumService;
+  final UserService _userService;
+  final SyncService _syncService;
+  final ETagService _etagService;
+  final ExifService _exifService;
+  final Ref _ref;
+  final log = Logger('AssetNotifier');
+  bool _getAllAssetInProgress = false;
+  bool _deleteInProgress = false;
+
+  AssetNotifier(
+    this._assetService,
+    this._albumService,
+    this._userService,
+    this._syncService,
+    this._etagService,
+    this._exifService,
+    this._ref,
+  ) : super(false);
+
+  Future<void> getAllAsset({bool clear = false}) async {
+    if (_getAllAssetInProgress || _deleteInProgress) {
+      // guard against multiple calls to this method while it's still working
+      return;
+    }
+    final stopwatch = Stopwatch()..start();
+    try {
+      _getAllAssetInProgress = true;
+      state = true;
+      if (clear) {
+        await clearAllAssets();
+        log.info("Manual refresh requested, cleared assets and albums from db");
+      }
+      final users = await _syncService.getUsersFromServer();
+      bool changedUsers = false;
+      if (users != null) {
+        changedUsers = await _syncService.syncUsersFromServer(users);
+      }
+      final bool newRemote = await _assetService.refreshRemoteAssets();
+      final bool newLocal = await _albumService.refreshDeviceAlbums();
+      dPrint(() => "changedUsers: $changedUsers, newRemote: $newRemote, newLocal: $newLocal");
+      if (newRemote) {
+        _ref.invalidate(memoryFutureProvider);
+      }
+
+      log.info("Load assets: ${stopwatch.elapsedMilliseconds}ms");
+    } catch (error) {
+      // If there is error in getting the remote assets, still showing the new local assets
+      await _albumService.refreshDeviceAlbums();
+    } finally {
+      _getAllAssetInProgress = false;
+      if (mounted) {
+        state = false;
+      }
+    }
+  }
+
+  Future<void> clearAllAssets() async {
+    await Store.delete(StoreKey.assetETag);
+    await Future.wait([
+      _assetService.clearTable(),
+      _exifService.clearTable(),
+      _albumService.clearTable(),
+      _userService.deleteAll(),
+      _etagService.clearTable(),
+    ]);
+  }
+
+  Future<void> onNewAssetUploaded(Asset newAsset) async {
+    // eTag on device is not valid after partially modifying the assets
+    await Store.delete(StoreKey.assetETag);
+    await _syncService.syncNewAssetToDb(newAsset);
+  }
+
+  Future<bool> deleteLocalAssets(List<Asset> assets) async {
+    _deleteInProgress = true;
+    state = true;
+    try {
+      await _assetService.deleteLocalAssets(assets);
+      return true;
+    } catch (error) {
+      log.severe("Failed to delete local assets", error);
+      return false;
+    } finally {
+      _deleteInProgress = false;
+      state = false;
+    }
+  }
+
+  /// Delete remote asset only
+  ///
+  /// Default behavior is trashing the asset
+  Future<bool> deleteRemoteAssets(Iterable<Asset> deleteAssets, {bool shouldDeletePermanently = false}) async {
+    _deleteInProgress = true;
+    state = true;
+    try {
+      await _assetService.deleteRemoteAssets(deleteAssets, shouldDeletePermanently: shouldDeletePermanently);
+      return true;
+    } catch (error) {
+      log.severe("Failed to delete remote assets", error);
+      return false;
+    } finally {
+      _deleteInProgress = false;
+      state = false;
+    }
+  }
+
+  Future<bool> deleteAssets(Iterable<Asset> deleteAssets, {bool force = false}) async {
+    _deleteInProgress = true;
+    state = true;
+    try {
+      await _assetService.deleteAssets(deleteAssets, shouldDeletePermanently: force);
+      return true;
+    } catch (error) {
+      log.severe("Failed to delete assets", error);
+      return false;
+    } finally {
+      _deleteInProgress = false;
+      state = false;
+    }
+  }
+
+  Future<void> toggleFavorite(List<Asset> assets, [bool? status]) {
+    status ??= !assets.every((a) => a.isFavorite);
+    return _assetService.changeFavoriteStatus(assets, status);
+  }
+
+  Future<void> toggleArchive(List<Asset> assets, [bool? status]) {
+    status ??= !assets.every((a) => a.isArchived);
+    return _assetService.changeArchiveStatus(assets, status);
+  }
+
+  Future<void> setLockedView(List<Asset> selection, AssetVisibilityEnum visibility) {
+    return _assetService.setVisibility(selection, visibility);
+  }
+}
+
+final assetDetailProvider = StreamProvider.autoDispose.family<Asset, Asset>((ref, asset) async* {
+  final assetService = ref.watch(assetServiceProvider);
+  yield await assetService.loadExif(asset);
+
+  await for (final asset in assetService.watchAsset(asset.id)) {
+    if (asset != null) {
+      yield await ref.watch(assetServiceProvider).loadExif(asset);
+    }
+  }
+});
+
+final assetWatcher = StreamProvider.autoDispose.family<Asset?, Asset>((ref, asset) {
+  final assetService = ref.watch(assetServiceProvider);
+  return assetService.watchAsset(asset.id, fireImmediately: true);
+});

mobile/lib/providers/asset_viewer/asset_people.provider.dart

@@ -0,0 +1,49 @@
+import 'package:immich_mobile/entities/asset.entity.dart';
+import 'package:immich_mobile/services/asset.service.dart';
+import 'package:logging/logging.dart';
+import 'package:openapi/api.dart';
+import 'package:riverpod_annotation/riverpod_annotation.dart';
+
+part 'asset_people.provider.g.dart';
+
+/// Maintains the list of people for an asset.
+@riverpod
+class AssetPeopleNotifier extends _$AssetPeopleNotifier {
+  final log = Logger('AssetPeopleNotifier');
+
+  @override
+  Future<List<PersonWithFacesResponseDto>> build(Asset asset) async {
+    if (!asset.isRemote) {
+      return [];
+    }
+
+    final list = await ref.watch(assetServiceProvider).getRemotePeopleOfAsset(asset.remoteId!);
+    if (list == null) {
+      return [];
+    }
+
+    // explicitly a sorted slice to make it deterministic
+    // named people will be at the beginning, and names are sorted
+    // ascendingly
+    list.sort((a, b) {
+      final aNotEmpty = a.name.isNotEmpty;
+      final bNotEmpty = b.name.isNotEmpty;
+      if (aNotEmpty && !bNotEmpty) {
+        return -1;
+      } else if (!aNotEmpty && bNotEmpty) {
+        return 1;
+      } else if (!aNotEmpty && !bNotEmpty) {
+        return 0;
+      }
+
+      return a.name.compareTo(b.name);
+    });
+    return list;
+  }
+
+  Future<void> refresh() async {
+    // invalidate the state – this way we don't have to
+    // duplicate the code from build.
+    ref.invalidateSelf();
+  }
+}

mobile/lib/providers/asset_viewer/asset_people.provider.g.dart

@@ -0,0 +1,192 @@
+// GENERATED CODE - DO NOT MODIFY BY HAND
+
+part of 'asset_people.provider.dart';
+
+// **************************************************************************
+// RiverpodGenerator
+// **************************************************************************
+
+String _$assetPeopleNotifierHash() =>
+    r'9835b180984a750c91e923e7b64dbda94f6d7574';
+
+/// Copied from Dart SDK
+class _SystemHash {
+  _SystemHash._();
+
+  static int combine(int hash, int value) {
+    // ignore: parameter_assignments
+    hash = 0x1fffffff & (hash + value);
+    // ignore: parameter_assignments
+    hash = 0x1fffffff & (hash + ((0x0007ffff & hash) << 10));
+    return hash ^ (hash >> 6);
+  }
+
+  static int finish(int hash) {
+    // ignore: parameter_assignments
+    hash = 0x1fffffff & (hash + ((0x03ffffff & hash) << 3));
+    // ignore: parameter_assignments
+    hash = hash ^ (hash >> 11);
+    return 0x1fffffff & (hash + ((0x00003fff & hash) << 15));
+  }
+}
+
+abstract class _$AssetPeopleNotifier
+    extends
+        BuildlessAutoDisposeAsyncNotifier<List<PersonWithFacesResponseDto>> {
+  late final Asset asset;
+
+  FutureOr<List<PersonWithFacesResponseDto>> build(Asset asset);
+}
+
+/// Maintains the list of people for an asset.
+///
+/// Copied from [AssetPeopleNotifier].
+@ProviderFor(AssetPeopleNotifier)
+const assetPeopleNotifierProvider = AssetPeopleNotifierFamily();
+
+/// Maintains the list of people for an asset.
+///
+/// Copied from [AssetPeopleNotifier].
+class AssetPeopleNotifierFamily
+    extends Family<AsyncValue<List<PersonWithFacesResponseDto>>> {
+  /// Maintains the list of people for an asset.
+  ///
+  /// Copied from [AssetPeopleNotifier].
+  const AssetPeopleNotifierFamily();
+
+  /// Maintains the list of people for an asset.
+  ///
+  /// Copied from [AssetPeopleNotifier].
+  AssetPeopleNotifierProvider call(Asset asset) {
+    return AssetPeopleNotifierProvider(asset);
+  }
+
+  @override
+  AssetPeopleNotifierProvider getProviderOverride(
+    covariant AssetPeopleNotifierProvider provider,
+  ) {
+    return call(provider.asset);
+  }
+
+  static const Iterable<ProviderOrFamily>? _dependencies = null;
+
+  @override
+  Iterable<ProviderOrFamily>? get dependencies => _dependencies;
+
+  static const Iterable<ProviderOrFamily>? _allTransitiveDependencies = null;
+
+  @override
+  Iterable<ProviderOrFamily>? get allTransitiveDependencies =>
+      _allTransitiveDependencies;
+
+  @override
+  String? get name => r'assetPeopleNotifierProvider';
+}
+
+/// Maintains the list of people for an asset.
+///
+/// Copied from [AssetPeopleNotifier].
+class AssetPeopleNotifierProvider
+    extends
+        AutoDisposeAsyncNotifierProviderImpl<
+          AssetPeopleNotifier,
+          List<PersonWithFacesResponseDto>
+        > {
+  /// Maintains the list of people for an asset.
+  ///
+  /// Copied from [AssetPeopleNotifier].
+  AssetPeopleNotifierProvider(Asset asset)
+    : this._internal(
+        () => AssetPeopleNotifier()..asset = asset,
+        from: assetPeopleNotifierProvider,
+        name: r'assetPeopleNotifierProvider',
+        debugGetCreateSourceHash: const bool.fromEnvironment('dart.vm.product')
+            ? null
+            : _$assetPeopleNotifierHash,
+        dependencies: AssetPeopleNotifierFamily._dependencies,
+        allTransitiveDependencies:
+            AssetPeopleNotifierFamily._allTransitiveDependencies,
+        asset: asset,
+      );
+
+  AssetPeopleNotifierProvider._internal(
+    super._createNotifier, {
+    required super.name,
+    required super.dependencies,
+    required super.allTransitiveDependencies,
+    required super.debugGetCreateSourceHash,
+    required super.from,
+    required this.asset,
+  }) : super.internal();
+
+  final Asset asset;
+
+  @override
+  FutureOr<List<PersonWithFacesResponseDto>> runNotifierBuild(
+    covariant AssetPeopleNotifier notifier,
+  ) {
+    return notifier.build(asset);
+  }
+
+  @override
+  Override overrideWith(AssetPeopleNotifier Function() create) {
+    return ProviderOverride(
+      origin: this,
+      override: AssetPeopleNotifierProvider._internal(
+        () => create()..asset = asset,
+        from: from,
+        name: null,
+        dependencies: null,
+        allTransitiveDependencies: null,
+        debugGetCreateSourceHash: null,
+        asset: asset,
+      ),
+    );
+  }
+
+  @override
+  AutoDisposeAsyncNotifierProviderElement<
+    AssetPeopleNotifier,
+    List<PersonWithFacesResponseDto>
+  >
+  createElement() {
+    return _AssetPeopleNotifierProviderElement(this);
+  }
+
+  @override
+  bool operator ==(Object other) {
+    return other is AssetPeopleNotifierProvider && other.asset == asset;
+  }
+
+  @override
+  int get hashCode {
+    var hash = _SystemHash.combine(0, runtimeType.hashCode);
+    hash = _SystemHash.combine(hash, asset.hashCode);
+
+    return _SystemHash.finish(hash);
+  }
+}
+
+@Deprecated('Will be removed in 3.0. Use Ref instead')
+// ignore: unused_element
+mixin AssetPeopleNotifierRef
+    on AutoDisposeAsyncNotifierProviderRef<List<PersonWithFacesResponseDto>> {
+  /// The parameter `asset` of this provider.
+  Asset get asset;
+}
+
+class _AssetPeopleNotifierProviderElement
+    extends
+        AutoDisposeAsyncNotifierProviderElement<
+          AssetPeopleNotifier,
+          List<PersonWithFacesResponseDto>
+        >
+    with AssetPeopleNotifierRef {
+  _AssetPeopleNotifierProviderElement(super.provider);
+
+  @override
+  Asset get asset => (origin as AssetPeopleNotifierProvider).asset;
+}
+
+// ignore_for_file: type=lint
+// ignore_for_file: subtype_of_sealed_class, invalid_use_of_internal_member, invalid_use_of_visible_for_testing_member, deprecated_member_use_from_same_package

mobile/lib/providers/asset_viewer/asset_stack.provider.dart

@@ -0,0 +1,42 @@
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+import 'package:immich_mobile/entities/asset.entity.dart';
+import 'package:immich_mobile/services/asset.service.dart';
+import 'package:riverpod_annotation/riverpod_annotation.dart';
+
+part 'asset_stack.provider.g.dart';
+
+class AssetStackNotifier extends StateNotifier<List<Asset>> {
+  final AssetService assetService;
+  final String _stackId;
+
+  AssetStackNotifier(this.assetService, this._stackId) : super([]) {
+    _fetchStack(_stackId);
+  }
+
+  void _fetchStack(String stackId) async {
+    if (!mounted) {
+      return;
+    }
+
+    final stack = await assetService.getStackAssets(stackId);
+    if (stack.isNotEmpty) {
+      state = stack;
+    }
+  }
+
+  void removeChild(int index) {
+    if (index < state.length) {
+      state.removeAt(index);
+      state = List<Asset>.from(state);
+    }
+  }
+}
+
+final assetStackStateProvider = StateNotifierProvider.autoDispose.family<AssetStackNotifier, List<Asset>, String>(
+  (ref, stackId) => AssetStackNotifier(ref.watch(assetServiceProvider), stackId),
+);
+
+@riverpod
+int assetStackIndex(Ref _) {
+  return -1;
+}

mobile/lib/providers/asset_viewer/asset_stack.provider.g.dart

@@ -0,0 +1,27 @@
+// GENERATED CODE - DO NOT MODIFY BY HAND
+
+part of 'asset_stack.provider.dart';
+
+// **************************************************************************
+// RiverpodGenerator
+// **************************************************************************
+
+String _$assetStackIndexHash() => r'086ddb782e3eb38b80d755666fe35be8fe7322d7';
+
+/// See also [assetStackIndex].
+@ProviderFor(assetStackIndex)
+final assetStackIndexProvider = AutoDisposeProvider<int>.internal(
+  assetStackIndex,
+  name: r'assetStackIndexProvider',
+  debugGetCreateSourceHash: const bool.fromEnvironment('dart.vm.product')
+      ? null
+      : _$assetStackIndexHash,
+  dependencies: null,
+  allTransitiveDependencies: null,
+);
+
+@Deprecated('Will be removed in 3.0. Use Ref instead')
+// ignore: unused_element
+typedef AssetStackIndexRef = AutoDisposeProviderRef<int>;
+// ignore_for_file: type=lint
+// ignore_for_file: subtype_of_sealed_class, invalid_use_of_internal_member, invalid_use_of_visible_for_testing_member, deprecated_member_use_from_same_package

mobile/lib/providers/asset_viewer/current_asset.provider.dart

@@ -0,0 +1,15 @@
+import 'package:immich_mobile/entities/asset.entity.dart';
+import 'package:riverpod_annotation/riverpod_annotation.dart';
+
+part 'current_asset.provider.g.dart';
+
+@riverpod
+class CurrentAsset extends _$CurrentAsset {
+  @override
+  Asset? build() => null;
+
+  void set(Asset? a) => state = a;
+}
+
+/// Mock class for testing
+abstract class CurrentAssetInternal extends _$CurrentAsset {}

mobile/lib/providers/asset_viewer/current_asset.provider.g.dart

@@ -0,0 +1,26 @@
+// GENERATED CODE - DO NOT MODIFY BY HAND
+
+part of 'current_asset.provider.dart';
+
+// **************************************************************************
+// RiverpodGenerator
+// **************************************************************************
+
+String _$currentAssetHash() => r'2def10ea594152c984ae2974d687ab6856d7bdd0';
+
+/// See also [CurrentAsset].
+@ProviderFor(CurrentAsset)
+final currentAssetProvider =
+    AutoDisposeNotifierProvider<CurrentAsset, Asset?>.internal(
+      CurrentAsset.new,
+      name: r'currentAssetProvider',
+      debugGetCreateSourceHash: const bool.fromEnvironment('dart.vm.product')
+          ? null
+          : _$currentAssetHash,
+      dependencies: null,
+      allTransitiveDependencies: null,
+    );
+
+typedef _$CurrentAsset = AutoDisposeNotifier<Asset?>;
+// ignore_for_file: type=lint
+// ignore_for_file: subtype_of_sealed_class, invalid_use_of_internal_member, invalid_use_of_visible_for_testing_member, deprecated_member_use_from_same_package

mobile/lib/providers/asset_viewer/download.provider.dart

@@ -0,0 +1,194 @@
+import 'dart:async';
+
+import 'package:background_downloader/background_downloader.dart';
+import 'package:easy_localization/easy_localization.dart';
+import 'package:flutter/material.dart';
+import 'package:fluttertoast/fluttertoast.dart';
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+import 'package:immich_mobile/entities/asset.entity.dart';
+import 'package:immich_mobile/extensions/build_context_extensions.dart';
+import 'package:immich_mobile/models/download/download_state.model.dart';
+import 'package:immich_mobile/models/download/livephotos_medatada.model.dart';
+import 'package:immich_mobile/services/album.service.dart';
+import 'package:immich_mobile/services/download.service.dart';
+import 'package:immich_mobile/services/share.service.dart';
+import 'package:immich_mobile/widgets/common/immich_toast.dart';
+import 'package:immich_mobile/widgets/common/share_dialog.dart';
+
+class DownloadStateNotifier extends StateNotifier<DownloadState> {
+  final DownloadService _downloadService;
+  final ShareService _shareService;
+  final AlbumService _albumService;
+
+  DownloadStateNotifier(this._downloadService, this._shareService, this._albumService)
+    : super(
+        const DownloadState(
+          downloadStatus: TaskStatus.complete,
+          showProgress: false,
+          taskProgress: <String, DownloadInfo>{},
+        ),
+      ) {
+    _downloadService.onImageDownloadStatus = _downloadImageCallback;
+    _downloadService.onVideoDownloadStatus = _downloadVideoCallback;
+    _downloadService.onLivePhotoDownloadStatus = _downloadLivePhotoCallback;
+    _downloadService.onTaskProgress = _taskProgressCallback;
+  }
+
+  void _updateDownloadStatus(String taskId, TaskStatus status) {
+    if (status == TaskStatus.canceled) {
+      return;
+    }
+
+    state = state.copyWith(
+      taskProgress: <String, DownloadInfo>{}
+        ..addAll(state.taskProgress)
+        ..addAll({
+          taskId: DownloadInfo(
+            progress: state.taskProgress[taskId]?.progress ?? 0,
+            fileName: state.taskProgress[taskId]?.fileName ?? '',
+            status: status,
+          ),
+        }),
+    );
+  }
+
+  // Download live photo callback
+  void _downloadLivePhotoCallback(TaskStatusUpdate update) {
+    _updateDownloadStatus(update.task.taskId, update.status);
+
+    switch (update.status) {
+      case TaskStatus.complete:
+        if (update.task.metaData.isEmpty) {
+          return;
+        }
+        final livePhotosId = LivePhotosMetadata.fromJson(update.task.metaData).id;
+        _downloadService.saveLivePhotos(update.task, livePhotosId);
+        _onDownloadComplete(update.task.taskId);
+        break;
+
+      default:
+        break;
+    }
+  }
+
+  // Download image callback
+  void _downloadImageCallback(TaskStatusUpdate update) {
+    _updateDownloadStatus(update.task.taskId, update.status);
+
+    switch (update.status) {
+      case TaskStatus.complete:
+        _downloadService.saveImageWithPath(update.task);
+        _onDownloadComplete(update.task.taskId);
+        break;
+
+      default:
+        break;
+    }
+  }
+
+  // Download video callback
+  void _downloadVideoCallback(TaskStatusUpdate update) {
+    _updateDownloadStatus(update.task.taskId, update.status);
+
+    switch (update.status) {
+      case TaskStatus.complete:
+        _downloadService.saveVideo(update.task);
+        _onDownloadComplete(update.task.taskId);
+        break;
+
+      default:
+        break;
+    }
+  }
+
+  void _taskProgressCallback(TaskProgressUpdate update) {
+    // Ignore if the task is canceled or completed
+    if (update.progress == -2 || update.progress == -1) {
+      return;
+    }
+
+    state = state.copyWith(
+      showProgress: true,
+      taskProgress: <String, DownloadInfo>{}
+        ..addAll(state.taskProgress)
+        ..addAll({
+          update.task.taskId: DownloadInfo(
+            progress: update.progress,
+            fileName: update.task.filename,
+            status: TaskStatus.running,
+          ),
+        }),
+    );
+  }
+
+  void _onDownloadComplete(String id) {
+    Future.delayed(const Duration(seconds: 2), () {
+      state = state.copyWith(
+        taskProgress: <String, DownloadInfo>{}
+          ..addAll(state.taskProgress)
+          ..remove(id),
+      );
+
+      if (state.taskProgress.isEmpty) {
+        state = state.copyWith(showProgress: false);
+      }
+      _albumService.refreshDeviceAlbums();
+    });
+  }
+
+  Future<List<bool>> downloadAllAsset(List<Asset> assets) async {
+    return await _downloadService.downloadAll(assets);
+  }
+
+  void downloadAsset(Asset asset) async {
+    await _downloadService.download(asset);
+  }
+
+  void cancelDownload(String id) async {
+    final isCanceled = await _downloadService.cancelDownload(id);
+
+    if (isCanceled) {
+      state = state.copyWith(
+        taskProgress: <String, DownloadInfo>{}
+          ..addAll(state.taskProgress)
+          ..remove(id),
+      );
+    }
+
+    if (state.taskProgress.isEmpty) {
+      state = state.copyWith(showProgress: false);
+    }
+  }
+
+  void shareAsset(Asset asset, BuildContext context) async {
+    unawaited(
+      showDialog(
+        context: context,
+        builder: (BuildContext buildContext) {
+          _shareService.shareAsset(asset, context).then((bool status) {
+            if (!status) {
+              ImmichToast.show(
+                context: context,
+                msg: 'image_viewer_page_state_provider_share_error'.tr(),
+                toastType: ToastType.error,
+                gravity: ToastGravity.BOTTOM,
+              );
+            }
+            buildContext.pop();
+          });
+          return const ShareDialog();
+        },
+        barrierDismissible: false,
+        useRootNavigator: false,
+      ),
+    );
+  }
+}
+
+final downloadStateProvider = StateNotifierProvider<DownloadStateNotifier, DownloadState>(
+  ((ref) => DownloadStateNotifier(
+    ref.watch(downloadServiceProvider),
+    ref.watch(shareServiceProvider),
+    ref.watch(albumServiceProvider),
+  )),
+);

mobile/lib/providers/asset_viewer/is_motion_video_playing.provider.dart

@@ -0,0 +1,22 @@
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+
+/// Whether to display the video part of a motion photo
+final isPlayingMotionVideoProvider = StateNotifierProvider<IsPlayingMotionVideo, bool>((ref) {
+  return IsPlayingMotionVideo(ref);
+});
+
+class IsPlayingMotionVideo extends StateNotifier<bool> {
+  IsPlayingMotionVideo(this.ref) : super(false);
+
+  final Ref ref;
+
+  bool get playing => state;
+
+  set playing(bool value) {
+    state = value;
+  }
+
+  void toggle() {
+    state = !state;
+  }
+}

mobile/lib/providers/asset_viewer/render_list_status_provider.dart

@@ -0,0 +1,19 @@
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+
+enum RenderListStatusEnum { complete, empty, error, loading }
+
+final renderListStatusProvider = StateNotifierProvider<RenderListStatus, RenderListStatusEnum>((ref) {
+  return RenderListStatus(ref);
+});
+
+class RenderListStatus extends StateNotifier<RenderListStatusEnum> {
+  RenderListStatus(this.ref) : super(RenderListStatusEnum.complete);
+
+  final Ref ref;
+
+  RenderListStatusEnum get status => state;
+
+  set status(RenderListStatusEnum value) {
+    state = value;
+  }
+}

mobile/lib/providers/asset_viewer/scroll_notifier.provider.dart

@@ -0,0 +1,9 @@
+import 'package:flutter/material.dart';
+
+final scrollToTopNotifierProvider = ScrollNotifier();
+
+class ScrollNotifier with ChangeNotifier {
+  void scrollToTop() {
+    notifyListeners();
+  }
+}

mobile/lib/providers/asset_viewer/scroll_to_date_notifier.provider.dart

@@ -0,0 +1,14 @@
+import 'package:flutter/material.dart';
+
+final scrollToDateNotifierProvider = ScrollToDateNotifier(null);
+
+class ScrollToDateNotifier extends ValueNotifier<DateTime?> {
+  ScrollToDateNotifier(super.value);
+
+  void scrollToDate(DateTime date) {
+    value = date;
+
+    // Manually notify listeners to trigger the scroll, even if the value hasn't changed
+    notifyListeners();
+  }
+}

mobile/lib/providers/asset_viewer/share_intent_upload.provider.dart

@@ -0,0 +1,101 @@
+import 'dart:io';
+
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+import 'package:immich_mobile/models/upload/share_intent_attachment.model.dart';
+import 'package:immich_mobile/routing/router.dart';
+import 'package:immich_mobile/services/share_intent_service.dart';
+import 'package:immich_mobile/services/foreground_upload.service.dart';
+import 'package:logging/logging.dart';
+import 'package:path/path.dart' as p;
+
+final shareIntentUploadProvider = StateNotifierProvider<ShareIntentUploadStateNotifier, List<ShareIntentAttachment>>(
+  ((ref) => ShareIntentUploadStateNotifier(
+    ref.watch(appRouterProvider),
+    ref.read(foregroundUploadServiceProvider),
+    ref.read(shareIntentServiceProvider),
+  )),
+);
+
+class ShareIntentUploadStateNotifier extends StateNotifier<List<ShareIntentAttachment>> {
+  final AppRouter router;
+  final ForegroundUploadService _foregroundUploadService;
+  final ShareIntentService _shareIntentService;
+  final Logger _logger = Logger('ShareIntentUploadStateNotifier');
+
+  ShareIntentUploadStateNotifier(this.router, this._foregroundUploadService, this._shareIntentService) : super([]);
+
+  void init() {
+    _shareIntentService.onSharedMedia = onSharedMedia;
+    _shareIntentService.init();
+  }
+
+  void onSharedMedia(List<ShareIntentAttachment> attachments) {
+    router.removeWhere((route) => route.name == "ShareIntentRoute");
+    clearAttachments();
+    addAttachments(attachments);
+    router.push(ShareIntentRoute(attachments: attachments));
+  }
+
+  void addAttachments(List<ShareIntentAttachment> attachments) {
+    if (attachments.isEmpty) {
+      return;
+    }
+    state = [...state, ...attachments];
+  }
+
+  void removeAttachment(ShareIntentAttachment attachment) {
+    final updatedState = state.where((element) => element != attachment).toList();
+    if (updatedState.length != state.length) {
+      state = updatedState;
+    }
+  }
+
+  void clearAttachments() {
+    if (state.isEmpty) {
+      return;
+    }
+
+    state = [];
+  }
+
+  Future<void> uploadAll(List<File> files) async {
+    for (final file in files) {
+      final fileId = p.hash(file.path).toString();
+      _updateStatus(fileId, UploadStatus.running);
+    }
+
+    await _foregroundUploadService.uploadShareIntent(
+      files,
+      onProgress: (fileId, bytes, totalBytes) {
+        final progress = totalBytes > 0 ? bytes / totalBytes : 0.0;
+        _updateProgress(fileId, progress);
+      },
+      onSuccess: (fileId) {
+        _updateStatus(fileId, UploadStatus.complete, progress: 1.0);
+      },
+      onError: (fileId, errorMessage) {
+        _logger.warning("Upload failed for file: $fileId, error: $errorMessage");
+        _updateStatus(fileId, UploadStatus.failed);
+      },
+    );
+  }
+
+  void _updateStatus(String fileId, UploadStatus status, {double? progress}) {
+    final id = int.parse(fileId);
+    state = [
+      for (final attachment in state)
+        if (attachment.id == id)
+          attachment.copyWith(status: status, uploadProgress: progress ?? attachment.uploadProgress)
+        else
+          attachment,
+    ];
+  }
+
+  void _updateProgress(String fileId, double progress) {
+    final id = int.parse(fileId);
+    state = [
+      for (final attachment in state)
+        if (attachment.id == id) attachment.copyWith(uploadProgress: progress) else attachment,
+    ];
+  }
+}

mobile/lib/providers/asset_viewer/show_controls.provider.dart

@@ -0,0 +1,21 @@
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+
+final showControlsProvider = StateNotifierProvider<ShowControls, bool>((ref) {
+  return ShowControls(ref);
+});
+
+class ShowControls extends StateNotifier<bool> {
+  ShowControls(this.ref) : super(true);
+
+  final Ref ref;
+
+  bool get show => state;
+
+  set show(bool value) {
+    state = value;
+  }
+
+  void toggle() {
+    state = !state;
+  }
+}

mobile/lib/providers/asset_viewer/video_player_controls_provider.dart

@@ -0,0 +1,71 @@
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+import 'package:immich_mobile/providers/asset_viewer/video_player_value_provider.dart';
+
+class VideoPlaybackControls {
+  const VideoPlaybackControls({required this.position, required this.pause, this.restarted = false});
+
+  final Duration position;
+  final bool pause;
+  final bool restarted;
+}
+
+final videoPlayerControlsProvider = StateNotifierProvider<VideoPlayerControls, VideoPlaybackControls>((ref) {
+  return VideoPlayerControls(ref);
+});
+
+const videoPlayerControlsDefault = VideoPlaybackControls(position: Duration.zero, pause: false);
+
+class VideoPlayerControls extends StateNotifier<VideoPlaybackControls> {
+  VideoPlayerControls(this.ref) : super(videoPlayerControlsDefault);
+
+  final Ref ref;
+
+  VideoPlaybackControls get value => state;
+
+  set value(VideoPlaybackControls value) {
+    state = value;
+  }
+
+  void reset() {
+    state = videoPlayerControlsDefault;
+  }
+
+  Duration get position => state.position;
+  bool get paused => state.pause;
+
+  set position(Duration value) {
+    if (state.position == value) {
+      return;
+    }
+
+    state = VideoPlaybackControls(position: value, pause: state.pause);
+  }
+
+  void pause() {
+    if (state.pause) {
+      return;
+    }
+
+    state = VideoPlaybackControls(position: state.position, pause: true);
+  }
+
+  void play() {
+    if (!state.pause) {
+      return;
+    }
+
+    state = VideoPlaybackControls(position: state.position, pause: false);
+  }
+
+  void togglePlay() {
+    state = VideoPlaybackControls(position: state.position, pause: !state.pause);
+  }
+
+  void restart() {
+    state = const VideoPlaybackControls(position: Duration.zero, pause: false, restarted: true);
+    ref.read(videoPlaybackValueProvider.notifier).value = ref
+        .read(videoPlaybackValueProvider.notifier)
+        .value
+        .copyWith(state: VideoPlaybackState.playing, position: Duration.zero);
+  }
+}

mobile/lib/providers/asset_viewer/video_player_value_provider.dart

@@ -0,0 +1,88 @@
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+import 'package:native_video_player/native_video_player.dart';
+
+enum VideoPlaybackState { initializing, paused, playing, buffering, completed }
+
+class VideoPlaybackValue {
+  /// The current position of the video
+  final Duration position;
+
+  /// The total duration of the video
+  final Duration duration;
+
+  /// The current state of the video playback
+  final VideoPlaybackState state;
+
+  /// The volume of the video
+  final double volume;
+
+  const VideoPlaybackValue({required this.position, required this.duration, required this.state, required this.volume});
+
+  factory VideoPlaybackValue.fromNativeController(NativeVideoPlayerController controller) {
+    final playbackInfo = controller.playbackInfo;
+    final videoInfo = controller.videoInfo;
+
+    if (playbackInfo == null || videoInfo == null) {
+      return videoPlaybackValueDefault;
+    }
+
+    final VideoPlaybackState status = switch (playbackInfo.status) {
+      PlaybackStatus.playing => VideoPlaybackState.playing,
+      PlaybackStatus.paused => VideoPlaybackState.paused,
+      PlaybackStatus.stopped => VideoPlaybackState.completed,
+    };
+
+    return VideoPlaybackValue(
+      position: Duration(milliseconds: playbackInfo.position),
+      duration: Duration(milliseconds: videoInfo.duration),
+      state: status,
+      volume: playbackInfo.volume,
+    );
+  }
+
+  VideoPlaybackValue copyWith({Duration? position, Duration? duration, VideoPlaybackState? state, double? volume}) {
+    return VideoPlaybackValue(
+      position: position ?? this.position,
+      duration: duration ?? this.duration,
+      state: state ?? this.state,
+      volume: volume ?? this.volume,
+    );
+  }
+}
+
+const VideoPlaybackValue videoPlaybackValueDefault = VideoPlaybackValue(
+  position: Duration.zero,
+  duration: Duration.zero,
+  state: VideoPlaybackState.initializing,
+  volume: 0.0,
+);
+
+final videoPlaybackValueProvider = StateNotifierProvider<VideoPlaybackValueState, VideoPlaybackValue>((ref) {
+  return VideoPlaybackValueState(ref);
+});
+
+class VideoPlaybackValueState extends StateNotifier<VideoPlaybackValue> {
+  VideoPlaybackValueState(this.ref) : super(videoPlaybackValueDefault);
+
+  final Ref ref;
+
+  VideoPlaybackValue get value => state;
+
+  set value(VideoPlaybackValue value) {
+    state = value;
+  }
+
+  set position(Duration value) {
+    if (state.position == value) return;
+    state = VideoPlaybackValue(position: value, duration: state.duration, state: state.state, volume: state.volume);
+  }
+
+  set status(VideoPlaybackState value) {
+    if (state.state == value) return;
+    state = VideoPlaybackValue(position: state.position, duration: state.duration, state: value, volume: state.volume);
+  }
+
+  void reset() {
+    state = videoPlaybackValueDefault;
+  }
+}

mobile/lib/providers/auth.provider.dart

@@ -0,0 +1,214 @@
+import 'package:flutter_udid/flutter_udid.dart';
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+import 'package:immich_mobile/constants/constants.dart';
+import 'package:immich_mobile/domain/models/store.model.dart';
+import 'package:immich_mobile/domain/models/user.model.dart';
+import 'package:immich_mobile/domain/services/user.service.dart';
+import 'package:immich_mobile/entities/store.entity.dart';
+import 'package:immich_mobile/models/auth/auth_state.model.dart';
+import 'package:immich_mobile/models/auth/login_response.model.dart';
+import 'package:immich_mobile/providers/api.provider.dart';
+import 'package:immich_mobile/providers/infrastructure/user.provider.dart';
+import 'package:immich_mobile/services/api.service.dart';
+import 'package:immich_mobile/services/auth.service.dart';
+import 'package:immich_mobile/services/foreground_upload.service.dart';
+import 'package:immich_mobile/services/secure_storage.service.dart';
+import 'package:immich_mobile/services/background_upload.service.dart';
+import 'package:immich_mobile/services/widget.service.dart';
+import 'package:immich_mobile/utils/debug_print.dart';
+import 'package:immich_mobile/utils/hash.dart';
+import 'package:logging/logging.dart';
+import 'package:openapi/api.dart';
+
+final authProvider = StateNotifierProvider<AuthNotifier, AuthState>((ref) {
+  return AuthNotifier(
+    ref.watch(authServiceProvider),
+    ref.watch(apiServiceProvider),
+    ref.watch(userServiceProvider),
+    ref.watch(secureStorageServiceProvider),
+    ref.watch(widgetServiceProvider),
+    ref,
+  );
+});
+
+class AuthNotifier extends StateNotifier<AuthState> {
+  final AuthService _authService;
+  final ApiService _apiService;
+  final UserService _userService;
+
+  final SecureStorageService _secureStorageService;
+  final WidgetService _widgetService;
+  final Ref _ref;
+  final _log = Logger("AuthenticationNotifier");
+
+  static const Duration _timeoutDuration = Duration(seconds: 7);
+
+  AuthNotifier(
+    this._authService,
+    this._apiService,
+    this._userService,
+
+    this._secureStorageService,
+    this._widgetService,
+    this._ref,
+  ) : super(
+        const AuthState(
+          deviceId: "",
+          userId: "",
+          userEmail: "",
+          name: '',
+          profileImagePath: '',
+          isAdmin: false,
+          isAuthenticated: false,
+        ),
+      );
+
+  Future<String> validateServerUrl(String url) {
+    return _authService.validateServerUrl(url);
+  }
+
+  /// Validating the url is the alternative connecting server url without
+  /// saving the information to the local database
+  Future<bool> validateAuxilaryServerUrl(String url) async {
+    try {
+      final validEndpoint = await _apiService.resolveEndpoint(url);
+      return await _authService.validateAuxilaryServerUrl(validEndpoint);
+    } catch (_) {
+      return false;
+    }
+  }
+
+  Future<LoginResponse> login(String email, String password) async {
+    final response = await _authService.login(email, password);
+    await saveAuthInfo(accessToken: response.accessToken);
+    return response;
+  }
+
+  Future<void> logout() async {
+    try {
+      await _secureStorageService.delete(kSecuredPinCode);
+      await _widgetService.clearCredentials();
+
+      await _authService.logout();
+      await _ref.read(backgroundUploadServiceProvider).cancel();
+      _ref.read(foregroundUploadServiceProvider).cancel();
+    } finally {
+      await _cleanUp();
+    }
+  }
+
+  Future<void> _cleanUp() async {
+    state = const AuthState(
+      deviceId: "",
+      userId: "",
+      userEmail: "",
+      name: '',
+      profileImagePath: '',
+      isAdmin: false,
+      isAuthenticated: false,
+    );
+  }
+
+  void updateUserProfileImagePath(String path) {
+    state = state.copyWith(profileImagePath: path);
+  }
+
+  Future<bool> changePassword(String newPassword) async {
+    try {
+      await _authService.changePassword(newPassword);
+      return true;
+    } catch (_) {
+      return false;
+    }
+  }
+
+  Future<bool> saveAuthInfo({required String accessToken}) async {
+    await _apiService.setAccessToken(accessToken);
+
+    final serverEndpoint = Store.get(StoreKey.serverEndpoint);
+    final customHeaders = Store.tryGet(StoreKey.customHeaders);
+    await _widgetService.writeCredentials(serverEndpoint, accessToken, customHeaders);
+
+    // Get the deviceid from the store if it exists, otherwise generate a new one
+    String deviceId = Store.tryGet(StoreKey.deviceId) ?? await FlutterUdid.consistentUdid;
+
+    UserDto? user = _userService.tryGetMyUser();
+
+    try {
+      final serverUser = await _userService.refreshMyUser().timeout(_timeoutDuration);
+      if (serverUser == null) {
+        _log.severe("Unable to get user information from the server.");
+      } else {
+        // If the user information is successfully retrieved, update the store
+        // Due to the flow of the code, this will always happen on first login
+        user = serverUser;
+        await Store.put(StoreKey.deviceId, deviceId);
+        await Store.put(StoreKey.deviceIdHash, fastHash(deviceId));
+        await Store.put(StoreKey.accessToken, accessToken);
+      }
+    } on ApiException catch (error, stackTrace) {
+      if (error.code == 401) {
+        _log.severe("Unauthorized access, token likely expired. Logging out.");
+        return false;
+      }
+      _log.severe("Error getting user information from the server [API EXCEPTION]", stackTrace);
+    } catch (error, stackTrace) {
+      _log.severe("Error getting user information from the server [CATCH ALL]", error, stackTrace);
+      dPrint(() => "Error getting user information from the server [CATCH ALL] $error $stackTrace");
+    }
+
+    // If the user is null, the login was not successful
+    // and we don't have a local copy of the user from a prior successful login
+    if (user == null) {
+      return false;
+    }
+
+    state = state.copyWith(
+      deviceId: deviceId,
+      userId: user.id,
+      userEmail: user.email,
+      isAuthenticated: true,
+      name: user.name,
+      isAdmin: user.isAdmin,
+    );
+
+    return true;
+  }
+
+  Future<void> saveWifiName(String wifiName) async {
+    await Store.put(StoreKey.preferredWifiName, wifiName);
+  }
+
+  Future<void> saveLocalEndpoint(String url) async {
+    await Store.put(StoreKey.localEndpoint, url);
+  }
+
+  String? getSavedWifiName() {
+    return Store.tryGet(StoreKey.preferredWifiName);
+  }
+
+  String? getSavedLocalEndpoint() {
+    return Store.tryGet(StoreKey.localEndpoint);
+  }
+
+  /// Returns the current server endpoint (with /api) URL from the store
+  String? getServerEndpoint() {
+    return Store.tryGet(StoreKey.serverEndpoint);
+  }
+
+  Future<String?> setOpenApiServiceEndpoint() {
+    return _authService.setOpenApiServiceEndpoint();
+  }
+
+  Future<bool> unlockPinCode(String pinCode) {
+    return _authService.unlockPinCode(pinCode);
+  }
+
+  Future<void> lockPinCode() {
+    return _authService.lockPinCode();
+  }
+
+  Future<void> setupPinCode(String pinCode) {
+    return _authService.setupPinCode(pinCode);
+  }
+}

mobile/lib/providers/background_sync.provider.dart

@@ -0,0 +1,37 @@
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+import 'package:immich_mobile/domain/utils/background_sync.dart';
+import 'package:immich_mobile/providers/backup/drift_backup.provider.dart';
+import 'package:immich_mobile/providers/sync_status.provider.dart';
+
+final backgroundSyncProvider = Provider<BackgroundSyncManager>((ref) {
+  final syncStatusNotifier = ref.read(syncStatusProvider.notifier);
+
+  final manager = BackgroundSyncManager(
+    onRemoteSyncStart: () {
+      syncStatusNotifier.startRemoteSync();
+      final backupProvider = ref.read(driftBackupProvider.notifier);
+      if (backupProvider.mounted) {
+        backupProvider.updateError(BackupError.none);
+      }
+    },
+    onRemoteSyncComplete: (isSuccess) {
+      syncStatusNotifier.completeRemoteSync();
+      final backupProvider = ref.read(driftBackupProvider.notifier);
+      if (backupProvider.mounted) {
+        backupProvider.updateError(isSuccess == true ? BackupError.none : BackupError.syncFailed);
+      }
+    },
+    onRemoteSyncError: syncStatusNotifier.errorRemoteSync,
+    onLocalSyncStart: syncStatusNotifier.startLocalSync,
+    onLocalSyncComplete: syncStatusNotifier.completeLocalSync,
+    onLocalSyncError: syncStatusNotifier.errorLocalSync,
+    onHashingStart: syncStatusNotifier.startHashJob,
+    onHashingComplete: syncStatusNotifier.completeHashJob,
+    onHashingError: syncStatusNotifier.errorHashJob,
+    onCloudIdSyncStart: syncStatusNotifier.startCloudIdSync,
+    onCloudIdSyncComplete: syncStatusNotifier.completeCloudIdSync,
+    onCloudIdSyncError: syncStatusNotifier.errorCloudIdSync,
+  );
+  ref.onDispose(manager.cancel);
+  return manager;
+});

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

@@ -0,0 +1,33 @@
+import 'package:cancellation_token_http/http.dart';
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+
+/// Tracks per-asset upload progress.
+/// Key: local asset ID, Value: upload progress 0.0 to 1.0, or -1.0 for error
+class AssetUploadProgressNotifier extends Notifier<Map<String, double>> {
+  static const double errorValue = -1.0;
+
+  @override
+  Map<String, double> build() => {};
+
+  void setProgress(String localAssetId, double progress) {
+    state = {...state, localAssetId: progress};
+  }
+
+  void setError(String localAssetId) {
+    state = {...state, localAssetId: errorValue};
+  }
+
+  void remove(String localAssetId) {
+    state = Map.from(state)..remove(localAssetId);
+  }
+
+  void clear() {
+    state = {};
+  }
+}
+
+final assetUploadProgressProvider = NotifierProvider<AssetUploadProgressNotifier, Map<String, double>>(
+  AssetUploadProgressNotifier.new,
+);
+
+final manualUploadCancelTokenProvider = StateProvider<CancellationToken?>((ref) => null);

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

@@ -0,0 +1,670 @@
+import 'dart:io';
+
+import 'package:cancellation_token_http/http.dart';
+import 'package:collection/collection.dart';
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+import 'package:immich_mobile/domain/models/store.model.dart';
+import 'package:immich_mobile/entities/album.entity.dart';
+import 'package:immich_mobile/entities/backup_album.entity.dart';
+import 'package:immich_mobile/entities/store.entity.dart';
+import 'package:immich_mobile/models/auth/auth_state.model.dart';
+import 'package:immich_mobile/models/backup/available_album.model.dart';
+import 'package:immich_mobile/models/backup/backup_candidate.model.dart';
+import 'package:immich_mobile/models/backup/backup_state.model.dart';
+import 'package:immich_mobile/models/backup/current_upload_asset.model.dart';
+import 'package:immich_mobile/models/backup/error_upload_asset.model.dart';
+import 'package:immich_mobile/models/backup/success_upload_asset.model.dart';
+import 'package:immich_mobile/models/server_info/server_disk_info.model.dart';
+import 'package:immich_mobile/providers/app_life_cycle.provider.dart';
+import 'package:immich_mobile/providers/auth.provider.dart';
+import 'package:immich_mobile/providers/backup/error_backup_list.provider.dart';
+import 'package:immich_mobile/providers/gallery_permission.provider.dart';
+import 'package:immich_mobile/repositories/album_media.repository.dart';
+import 'package:immich_mobile/repositories/backup.repository.dart';
+import 'package:immich_mobile/repositories/file_media.repository.dart';
+import 'package:immich_mobile/services/background.service.dart';
+import 'package:immich_mobile/services/backup.service.dart';
+import 'package:immich_mobile/services/backup_album.service.dart';
+import 'package:immich_mobile/services/server_info.service.dart';
+import 'package:immich_mobile/utils/backup_progress.dart';
+import 'package:immich_mobile/utils/diff.dart';
+import 'package:logging/logging.dart';
+import 'package:permission_handler/permission_handler.dart';
+import 'package:photo_manager/photo_manager.dart' show PMProgressHandler;
+import 'package:immich_mobile/utils/debug_print.dart';
+
+final backupProvider = StateNotifierProvider<BackupNotifier, BackUpState>((ref) {
+  return BackupNotifier(
+    ref.watch(backupServiceProvider),
+    ref.watch(serverInfoServiceProvider),
+    ref.watch(authProvider),
+    ref.watch(backgroundServiceProvider),
+    ref.watch(galleryPermissionNotifier.notifier),
+    ref.watch(albumMediaRepositoryProvider),
+    ref.watch(fileMediaRepositoryProvider),
+    ref.watch(backupAlbumServiceProvider),
+    ref,
+  );
+});
+
+class BackupNotifier extends StateNotifier<BackUpState> {
+  BackupNotifier(
+    this._backupService,
+    this._serverInfoService,
+    this._authState,
+    this._backgroundService,
+    this._galleryPermissionNotifier,
+    this._albumMediaRepository,
+    this._fileMediaRepository,
+    this._backupAlbumService,
+    this.ref,
+  ) : super(
+        BackUpState(
+          backupProgress: BackUpProgressEnum.idle,
+          allAssetsInDatabase: const [],
+          progressInPercentage: 0,
+          progressInFileSize: "0 B / 0 B",
+          progressInFileSpeed: 0,
+          progressInFileSpeeds: const [],
+          progressInFileSpeedUpdateTime: DateTime.now(),
+          progressInFileSpeedUpdateSentBytes: 0,
+          cancelToken: CancellationToken(),
+          autoBackup: Store.get(StoreKey.autoBackup, false),
+          backgroundBackup: Store.get(StoreKey.backgroundBackup, false),
+          backupRequireWifi: Store.get(StoreKey.backupRequireWifi, true),
+          backupRequireCharging: Store.get(StoreKey.backupRequireCharging, false),
+          backupTriggerDelay: Store.get(StoreKey.backupTriggerDelay, 5000),
+          serverInfo: const ServerDiskInfo(diskAvailable: "0", diskSize: "0", diskUse: "0", diskUsagePercentage: 0),
+          availableAlbums: const [],
+          selectedBackupAlbums: const {},
+          excludedBackupAlbums: const {},
+          allUniqueAssets: const {},
+          selectedAlbumsBackupAssetsIds: const {},
+          currentUploadAsset: CurrentUploadAsset(
+            id: '...',
+            fileCreatedAt: DateTime.parse('2020-10-04'),
+            fileName: '...',
+            fileType: '...',
+            fileSize: 0,
+            iCloudAsset: false,
+          ),
+          iCloudDownloadProgress: 0.0,
+        ),
+      );
+
+  final log = Logger('BackupNotifier');
+  final BackupService _backupService;
+  final ServerInfoService _serverInfoService;
+  final AuthState _authState;
+  final BackgroundService _backgroundService;
+  final GalleryPermissionNotifier _galleryPermissionNotifier;
+  final AlbumMediaRepository _albumMediaRepository;
+  final FileMediaRepository _fileMediaRepository;
+  final BackupAlbumService _backupAlbumService;
+  final Ref ref;
+
+  ///
+  /// UI INTERACTION
+  ///
+  /// Album selection
+  /// Due to the overlapping assets across multiple albums on the device
+  /// We have method to include and exclude albums
+  /// The total unique assets will be used for backing mechanism
+  ///
+  void addAlbumForBackup(AvailableAlbum album) {
+    if (state.excludedBackupAlbums.contains(album)) {
+      removeExcludedAlbumForBackup(album);
+    }
+
+    state = state.copyWith(selectedBackupAlbums: {...state.selectedBackupAlbums, album});
+  }
+
+  void addExcludedAlbumForBackup(AvailableAlbum album) {
+    if (state.selectedBackupAlbums.contains(album)) {
+      removeAlbumForBackup(album);
+    }
+    state = state.copyWith(excludedBackupAlbums: {...state.excludedBackupAlbums, album});
+  }
+
+  void removeAlbumForBackup(AvailableAlbum album) {
+    Set<AvailableAlbum> currentSelectedAlbums = state.selectedBackupAlbums;
+
+    currentSelectedAlbums.removeWhere((a) => a == album);
+
+    state = state.copyWith(selectedBackupAlbums: currentSelectedAlbums);
+  }
+
+  void removeExcludedAlbumForBackup(AvailableAlbum album) {
+    Set<AvailableAlbum> currentExcludedAlbums = state.excludedBackupAlbums;
+
+    currentExcludedAlbums.removeWhere((a) => a == album);
+
+    state = state.copyWith(excludedBackupAlbums: currentExcludedAlbums);
+  }
+
+  Future<void> backupAlbumSelectionDone() {
+    if (state.selectedBackupAlbums.isEmpty) {
+      // disable any backup
+      cancelBackup();
+      setAutoBackup(false);
+      configureBackgroundBackup(enabled: false, onError: (msg) {}, onBatteryInfo: () {});
+    }
+    return _updateBackupAssetCount();
+  }
+
+  void setAutoBackup(bool enabled) {
+    Store.put(StoreKey.autoBackup, enabled);
+    state = state.copyWith(autoBackup: enabled);
+  }
+
+  void configureBackgroundBackup({
+    bool? enabled,
+    bool? requireWifi,
+    bool? requireCharging,
+    int? triggerDelay,
+    required void Function(String msg) onError,
+    required void Function() onBatteryInfo,
+  }) async {
+    assert(enabled != null || requireWifi != null || requireCharging != null || triggerDelay != null);
+    final bool wasEnabled = state.backgroundBackup;
+    final bool wasWifi = state.backupRequireWifi;
+    final bool wasCharging = state.backupRequireCharging;
+    final int oldTriggerDelay = state.backupTriggerDelay;
+    state = state.copyWith(
+      backgroundBackup: enabled,
+      backupRequireWifi: requireWifi,
+      backupRequireCharging: requireCharging,
+      backupTriggerDelay: triggerDelay,
+    );
+
+    if (state.backgroundBackup) {
+      bool success = true;
+      if (!wasEnabled) {
+        if (!await _backgroundService.isIgnoringBatteryOptimizations()) {
+          onBatteryInfo();
+        }
+        success &= await _backgroundService.enableService(immediate: true);
+      }
+      success &=
+          success &&
+          await _backgroundService.configureService(
+            requireUnmetered: state.backupRequireWifi,
+            requireCharging: state.backupRequireCharging,
+            triggerUpdateDelay: state.backupTriggerDelay,
+            triggerMaxDelay: state.backupTriggerDelay * 10,
+          );
+      if (success) {
+        await Store.put(StoreKey.backupRequireWifi, state.backupRequireWifi);
+        await Store.put(StoreKey.backupRequireCharging, state.backupRequireCharging);
+        await Store.put(StoreKey.backupTriggerDelay, state.backupTriggerDelay);
+        await Store.put(StoreKey.backgroundBackup, state.backgroundBackup);
+      } else {
+        state = state.copyWith(
+          backgroundBackup: wasEnabled,
+          backupRequireWifi: wasWifi,
+          backupRequireCharging: wasCharging,
+          backupTriggerDelay: oldTriggerDelay,
+        );
+        onError("backup_controller_page_background_configure_error");
+      }
+    } else {
+      final bool success = await _backgroundService.disableService();
+      if (!success) {
+        state = state.copyWith(backgroundBackup: wasEnabled);
+        onError("backup_controller_page_background_configure_error");
+      }
+    }
+  }
+
+  ///
+  /// Get all album on the device
+  /// Get all selected and excluded album from the user's persistent storage
+  /// If this is the first time performing backup - set the default selected album to be
+  /// the one that has all assets (`Recent` on Android, `Recents` on iOS)
+  ///
+  Future<void> _getBackupAlbumsInfo() async {
+    Stopwatch stopwatch = Stopwatch()..start();
+    // Get all albums on the device
+    List<AvailableAlbum> availableAlbums = [];
+    List<Album> albums = await _albumMediaRepository.getAll();
+
+    // Map of id -> album for quick album lookup later on.
+    Map<String, Album> albumMap = {};
+
+    log.info('Found ${albums.length} local albums');
+
+    for (Album album in albums) {
+      AvailableAlbum availableAlbum = AvailableAlbum(
+        album: album,
+        assetCount: await ref.read(albumMediaRepositoryProvider).getAssetCount(album.localId!),
+      );
+
+      availableAlbums.add(availableAlbum);
+
+      albumMap[album.localId!] = album;
+    }
+    state = state.copyWith(availableAlbums: availableAlbums);
+
+    final List<BackupAlbum> excludedBackupAlbums = await _backupAlbumService.getAllBySelection(BackupSelection.exclude);
+    final List<BackupAlbum> selectedBackupAlbums = await _backupAlbumService.getAllBySelection(BackupSelection.select);
+
+    final Set<AvailableAlbum> selectedAlbums = {};
+    for (final BackupAlbum ba in selectedBackupAlbums) {
+      final albumAsset = albumMap[ba.id];
+
+      if (albumAsset != null) {
+        selectedAlbums.add(
+          AvailableAlbum(
+            album: albumAsset,
+            assetCount: await _albumMediaRepository.getAssetCount(albumAsset.localId!),
+            lastBackup: ba.lastBackup,
+          ),
+        );
+      } else {
+        log.severe('Selected album not found');
+      }
+    }
+
+    final Set<AvailableAlbum> excludedAlbums = {};
+    for (final BackupAlbum ba in excludedBackupAlbums) {
+      final albumAsset = albumMap[ba.id];
+
+      if (albumAsset != null) {
+        excludedAlbums.add(
+          AvailableAlbum(
+            album: albumAsset,
+            assetCount: await ref.read(albumMediaRepositoryProvider).getAssetCount(albumAsset.localId!),
+            lastBackup: ba.lastBackup,
+          ),
+        );
+      } else {
+        log.severe('Excluded album not found');
+      }
+    }
+
+    state = state.copyWith(selectedBackupAlbums: selectedAlbums, excludedBackupAlbums: excludedAlbums);
+
+    log.info("_getBackupAlbumsInfo: Found ${availableAlbums.length} available albums");
+    dPrint(() => "_getBackupAlbumsInfo takes ${stopwatch.elapsedMilliseconds}ms");
+  }
+
+  ///
+  /// From all the selected and albums assets
+  /// Find the assets that are not overlapping between the two sets
+  /// Those assets are unique and are used as the total assets
+  ///
+  Future<void> _updateBackupAssetCount() async {
+    // Save to persistent storage
+    await _updatePersistentAlbumsSelection();
+
+    final duplicatedAssetIds = await _backupService.getDuplicatedAssetIds();
+    final Set<BackupCandidate> assetsFromSelectedAlbums = {};
+    final Set<BackupCandidate> assetsFromExcludedAlbums = {};
+
+    for (final album in state.selectedBackupAlbums) {
+      final assetCount = await ref.read(albumMediaRepositoryProvider).getAssetCount(album.album.localId!);
+
+      if (assetCount == 0) {
+        continue;
+      }
+
+      final assets = await ref.read(albumMediaRepositoryProvider).getAssets(album.album.localId!);
+
+      // Add album's name to the asset info
+      for (final asset in assets) {
+        List<String> albumNames = [album.name];
+
+        final existingAsset = assetsFromSelectedAlbums.firstWhereOrNull((a) => a.asset.localId == asset.localId);
+
+        if (existingAsset != null) {
+          albumNames.addAll(existingAsset.albumNames);
+          assetsFromSelectedAlbums.remove(existingAsset);
+        }
+
+        assetsFromSelectedAlbums.add(BackupCandidate(asset: asset, albumNames: albumNames));
+      }
+    }
+
+    for (final album in state.excludedBackupAlbums) {
+      final assetCount = await ref.read(albumMediaRepositoryProvider).getAssetCount(album.album.localId!);
+
+      if (assetCount == 0) {
+        continue;
+      }
+
+      final assets = await ref.read(albumMediaRepositoryProvider).getAssets(album.album.localId!);
+
+      for (final asset in assets) {
+        assetsFromExcludedAlbums.add(BackupCandidate(asset: asset, albumNames: [album.name]));
+      }
+    }
+
+    final Set<BackupCandidate> allUniqueAssets = assetsFromSelectedAlbums.difference(assetsFromExcludedAlbums);
+
+    final allAssetsInDatabase = await _backupService.getDeviceBackupAsset();
+
+    if (allAssetsInDatabase == null) {
+      return;
+    }
+
+    // Find asset that were backup from selected albums
+    final Set<String> selectedAlbumsBackupAssets = Set.from(allUniqueAssets.map((e) => e.asset.localId));
+
+    selectedAlbumsBackupAssets.removeWhere((assetId) => !allAssetsInDatabase.contains(assetId));
+
+    // Remove duplicated asset from all unique assets
+    allUniqueAssets.removeWhere((candidate) => duplicatedAssetIds.contains(candidate.asset.localId));
+
+    if (allUniqueAssets.isEmpty) {
+      log.info("No assets are selected for back up");
+      state = state.copyWith(
+        backupProgress: BackUpProgressEnum.idle,
+        allAssetsInDatabase: allAssetsInDatabase,
+        allUniqueAssets: {},
+        selectedAlbumsBackupAssetsIds: selectedAlbumsBackupAssets,
+      );
+    } else {
+      state = state.copyWith(
+        allAssetsInDatabase: allAssetsInDatabase,
+        allUniqueAssets: allUniqueAssets,
+        selectedAlbumsBackupAssetsIds: selectedAlbumsBackupAssets,
+      );
+    }
+  }
+
+  /// Get all necessary information for calculating the available albums,
+  /// which albums are selected or excluded
+  /// and then update the UI according to those information
+  Future<void> getBackupInfo() async {
+    final isEnabled = await _backgroundService.isBackgroundBackupEnabled();
+
+    state = state.copyWith(backgroundBackup: isEnabled);
+    if (isEnabled != Store.get(StoreKey.backgroundBackup, !isEnabled)) {
+      await Store.put(StoreKey.backgroundBackup, isEnabled);
+    }
+
+    if (state.backupProgress != BackUpProgressEnum.inBackground) {
+      await _getBackupAlbumsInfo();
+      await updateDiskInfo();
+      await _updateBackupAssetCount();
+    } else {
+      log.warning("cannot get backup info - background backup is in progress!");
+    }
+  }
+
+  /// Save user selection of selected albums and excluded albums to database
+  Future<void> _updatePersistentAlbumsSelection() async {
+    final epoch = DateTime.fromMillisecondsSinceEpoch(0, isUtc: true);
+    final selected = state.selectedBackupAlbums.map(
+      (e) => BackupAlbum(e.id, e.lastBackup ?? epoch, BackupSelection.select),
+    );
+    final excluded = state.excludedBackupAlbums.map(
+      (e) => BackupAlbum(e.id, e.lastBackup ?? epoch, BackupSelection.exclude),
+    );
+    final candidates = selected.followedBy(excluded).toList();
+    candidates.sortBy((e) => e.id);
+
+    final savedBackupAlbums = await _backupAlbumService.getAll(sort: BackupAlbumSort.id);
+    final List<int> toDelete = [];
+    final List<BackupAlbum> toUpsert = [];
+
+    diffSortedListsSync(
+      savedBackupAlbums,
+      candidates,
+      compare: (BackupAlbum a, BackupAlbum b) => a.id.compareTo(b.id),
+      both: (BackupAlbum a, BackupAlbum b) {
+        b.lastBackup = a.lastBackup.isAfter(b.lastBackup) ? a.lastBackup : b.lastBackup;
+        toUpsert.add(b);
+        return true;
+      },
+      onlyFirst: (BackupAlbum a) => toDelete.add(a.isarId),
+      onlySecond: (BackupAlbum b) => toUpsert.add(b),
+    );
+
+    await _backupAlbumService.deleteAll(toDelete);
+    await _backupAlbumService.updateAll(toUpsert);
+  }
+
+  /// Invoke backup process
+  Future<void> startBackupProcess() async {
+    dPrint(() => "Start backup process");
+    assert(state.backupProgress == BackUpProgressEnum.idle);
+    state = state.copyWith(backupProgress: BackUpProgressEnum.inProgress);
+
+    await getBackupInfo();
+
+    final hasPermission = _galleryPermissionNotifier.hasPermission;
+    if (hasPermission) {
+      await _fileMediaRepository.clearFileCache();
+
+      if (state.allUniqueAssets.isEmpty) {
+        log.info("No Asset On Device - Abort Backup Process");
+        state = state.copyWith(backupProgress: BackUpProgressEnum.idle);
+        return;
+      }
+
+      Set<BackupCandidate> assetsWillBeBackup = Set.from(state.allUniqueAssets);
+      // Remove item that has already been backed up
+      for (final assetId in state.allAssetsInDatabase) {
+        assetsWillBeBackup.removeWhere((e) => e.asset.localId == assetId);
+      }
+
+      if (assetsWillBeBackup.isEmpty) {
+        state = state.copyWith(backupProgress: BackUpProgressEnum.idle);
+      }
+
+      // Perform Backup
+      state = state.copyWith(cancelToken: CancellationToken());
+
+      final pmProgressHandler = Platform.isIOS ? PMProgressHandler() : null;
+
+      pmProgressHandler?.stream.listen((event) {
+        final double progress = event.progress;
+        state = state.copyWith(iCloudDownloadProgress: progress);
+      });
+
+      await _backupService.backupAsset(
+        assetsWillBeBackup,
+        state.cancelToken,
+        pmProgressHandler: pmProgressHandler,
+        onSuccess: _onAssetUploaded,
+        onProgress: _onUploadProgress,
+        onCurrentAsset: _onSetCurrentBackupAsset,
+        onError: _onBackupError,
+      );
+      await notifyBackgroundServiceCanRun();
+    } else {
+      await openAppSettings();
+    }
+  }
+
+  void setAvailableAlbums(availableAlbums) {
+    state = state.copyWith(availableAlbums: availableAlbums);
+  }
+
+  void _onBackupError(ErrorUploadAsset errorAssetInfo) {
+    ref.watch(errorBackupListProvider.notifier).add(errorAssetInfo);
+  }
+
+  void _onSetCurrentBackupAsset(CurrentUploadAsset currentUploadAsset) {
+    state = state.copyWith(currentUploadAsset: currentUploadAsset);
+  }
+
+  void cancelBackup() {
+    if (state.backupProgress != BackUpProgressEnum.inProgress) {
+      notifyBackgroundServiceCanRun();
+    }
+    state.cancelToken.cancel();
+    state = state.copyWith(
+      backupProgress: BackUpProgressEnum.idle,
+      progressInPercentage: 0.0,
+      progressInFileSize: "0 B / 0 B",
+      progressInFileSpeed: 0,
+      progressInFileSpeedUpdateTime: DateTime.now(),
+      progressInFileSpeedUpdateSentBytes: 0,
+    );
+  }
+
+  void _onAssetUploaded(SuccessUploadAsset result) async {
+    if (result.isDuplicate) {
+      state = state.copyWith(
+        allUniqueAssets: state.allUniqueAssets
+            .where((candidate) => candidate.asset.localId != result.candidate.asset.localId)
+            .toSet(),
+      );
+    } else {
+      state = state.copyWith(
+        selectedAlbumsBackupAssetsIds: {...state.selectedAlbumsBackupAssetsIds, result.candidate.asset.localId!},
+        allAssetsInDatabase: [...state.allAssetsInDatabase, result.candidate.asset.localId!],
+      );
+    }
+
+    if (state.allUniqueAssets.length - state.selectedAlbumsBackupAssetsIds.length == 0) {
+      final latestAssetBackup = state.allUniqueAssets
+          .map((candidate) => candidate.asset.fileModifiedAt)
+          .reduce((v, e) => e.isAfter(v) ? e : v);
+      state = state.copyWith(
+        selectedBackupAlbums: state.selectedBackupAlbums.map((e) => e.copyWith(lastBackup: latestAssetBackup)).toSet(),
+        excludedBackupAlbums: state.excludedBackupAlbums.map((e) => e.copyWith(lastBackup: latestAssetBackup)).toSet(),
+        backupProgress: BackUpProgressEnum.done,
+        progressInPercentage: 0.0,
+        progressInFileSize: "0 B / 0 B",
+        progressInFileSpeed: 0,
+        progressInFileSpeedUpdateTime: DateTime.now(),
+        progressInFileSpeedUpdateSentBytes: 0,
+      );
+      await _updatePersistentAlbumsSelection();
+    }
+
+    await updateDiskInfo();
+  }
+
+  void _onUploadProgress(int sent, int total) {
+    double lastUploadSpeed = state.progressInFileSpeed;
+    List<double> lastUploadSpeeds = state.progressInFileSpeeds.toList();
+    DateTime lastUpdateTime = state.progressInFileSpeedUpdateTime;
+    int lastSentBytes = state.progressInFileSpeedUpdateSentBytes;
+
+    final now = DateTime.now();
+    final duration = now.difference(lastUpdateTime);
+
+    // Keep the upload speed average span limited, to keep it somewhat relevant
+    if (lastUploadSpeeds.length > 10) {
+      lastUploadSpeeds.removeAt(0);
+    }
+
+    if (duration.inSeconds > 0) {
+      lastUploadSpeeds.add(((sent - lastSentBytes) / duration.inSeconds).abs().roundToDouble());
+
+      lastUploadSpeed = lastUploadSpeeds.average.abs().roundToDouble();
+      lastUpdateTime = now;
+      lastSentBytes = sent;
+    }
+
+    state = state.copyWith(
+      progressInPercentage: (sent.toDouble() / total.toDouble() * 100),
+      progressInFileSize: humanReadableFileBytesProgress(sent, total),
+      progressInFileSpeed: lastUploadSpeed,
+      progressInFileSpeeds: lastUploadSpeeds,
+      progressInFileSpeedUpdateTime: lastUpdateTime,
+      progressInFileSpeedUpdateSentBytes: lastSentBytes,
+    );
+  }
+
+  Future<void> updateDiskInfo() async {
+    final diskInfo = await _serverInfoService.getDiskInfo();
+
+    // Update server info
+    if (diskInfo != null) {
+      state = state.copyWith(serverInfo: diskInfo);
+    }
+  }
+
+  Future<void> _resumeBackup() async {
+    // Check if user is login
+    final accessKey = Store.tryGet(StoreKey.accessToken);
+
+    // User has been logged out return
+    if (accessKey == null || !_authState.isAuthenticated) {
+      log.info("[_resumeBackup] not authenticated - abort");
+      return;
+    }
+
+    // Check if this device is enable backup by the user
+    if (state.autoBackup) {
+      // check if backup is already in process - then return
+      if (state.backupProgress == BackUpProgressEnum.inProgress) {
+        log.info("[_resumeBackup] Auto Backup is already in progress - abort");
+        return;
+      }
+
+      if (state.backupProgress == BackUpProgressEnum.inBackground) {
+        log.info("[_resumeBackup] Background backup is running - abort");
+        return;
+      }
+
+      if (state.backupProgress == BackUpProgressEnum.manualInProgress) {
+        log.info("[_resumeBackup] Manual upload is running - abort");
+        return;
+      }
+
+      // Run backup
+      log.info("[_resumeBackup] Start back up");
+      await startBackupProcess();
+    }
+    return;
+  }
+
+  Future<void> resumeBackup() async {
+    final List<BackupAlbum> selectedBackupAlbums = await _backupAlbumService.getAllBySelection(BackupSelection.select);
+    final List<BackupAlbum> excludedBackupAlbums = await _backupAlbumService.getAllBySelection(BackupSelection.exclude);
+    Set<AvailableAlbum> selectedAlbums = state.selectedBackupAlbums;
+    Set<AvailableAlbum> excludedAlbums = state.excludedBackupAlbums;
+    if (selectedAlbums.isNotEmpty) {
+      selectedAlbums = _updateAlbumsBackupTime(selectedAlbums, selectedBackupAlbums);
+    }
+
+    if (excludedAlbums.isNotEmpty) {
+      excludedAlbums = _updateAlbumsBackupTime(excludedAlbums, excludedBackupAlbums);
+    }
+    final BackUpProgressEnum previous = state.backupProgress;
+    state = state.copyWith(
+      backupProgress: BackUpProgressEnum.inBackground,
+      selectedBackupAlbums: selectedAlbums,
+      excludedBackupAlbums: excludedAlbums,
+    );
+    // assumes the background service is currently running
+    // if true, waits until it has stopped to start the backup
+    final bool hasLock = await _backgroundService.acquireLock();
+    if (hasLock) {
+      state = state.copyWith(backupProgress: previous);
+    }
+    return _resumeBackup();
+  }
+
+  Set<AvailableAlbum> _updateAlbumsBackupTime(Set<AvailableAlbum> albums, List<BackupAlbum> backupAlbums) {
+    Set<AvailableAlbum> result = {};
+    for (BackupAlbum ba in backupAlbums) {
+      try {
+        AvailableAlbum a = albums.firstWhere((e) => e.id == ba.id);
+        result.add(a.copyWith(lastBackup: ba.lastBackup));
+      } on StateError {
+        log.severe("[_updateAlbumBackupTime] failed to find album in state", "State Error", StackTrace.current);
+      }
+    }
+    return result;
+  }
+
+  Future<void> notifyBackgroundServiceCanRun() async {
+    const allowedStates = [AppLifeCycleEnum.inactive, AppLifeCycleEnum.paused, AppLifeCycleEnum.detached];
+    if (allowedStates.contains(ref.read(appStateProvider.notifier).state)) {
+      _backgroundService.releaseLock();
+    }
+  }
+
+  BackUpProgressEnum get backupProgress => state.backupProgress;
+
+  void updateBackupProgress(BackUpProgressEnum backupProgress) {
+    state = state.copyWith(backupProgress: backupProgress);
+  }
+}

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

@@ -0,0 +1,59 @@
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+import 'package:immich_mobile/domain/models/album/local_album.model.dart';
+import 'package:immich_mobile/domain/services/local_album.service.dart';
+import 'package:immich_mobile/infrastructure/repositories/local_album.repository.dart';
+import 'package:immich_mobile/providers/infrastructure/album.provider.dart';
+
+final backupAlbumProvider = StateNotifierProvider<BackupAlbumNotifier, List<LocalAlbum>>(
+  (ref) => BackupAlbumNotifier(ref.watch(localAlbumServiceProvider)),
+);
+
+class BackupAlbumNotifier extends StateNotifier<List<LocalAlbum>> {
+  BackupAlbumNotifier(this._localAlbumService) : super([]) {
+    getAll();
+  }
+
+  final LocalAlbumService _localAlbumService;
+
+  Future<void> getAll() async {
+    state = await _localAlbumService.getAll(sortBy: {SortLocalAlbumsBy.assetCount});
+  }
+
+  Future<void> selectAlbum(LocalAlbum album) async {
+    album = album.copyWith(backupSelection: BackupSelection.selected);
+    await _localAlbumService.update(album);
+
+    state = state
+        .map(
+          (currentAlbum) => currentAlbum.id == album.id
+              ? currentAlbum.copyWith(backupSelection: BackupSelection.selected)
+              : currentAlbum,
+        )
+        .toList();
+  }
+
+  Future<void> deselectAlbum(LocalAlbum album) async {
+    album = album.copyWith(backupSelection: BackupSelection.none);
+    await _localAlbumService.update(album);
+
+    state = state
+        .map(
+          (currentAlbum) =>
+              currentAlbum.id == album.id ? currentAlbum.copyWith(backupSelection: BackupSelection.none) : currentAlbum,
+        )
+        .toList();
+  }
+
+  Future<void> excludeAlbum(LocalAlbum album) async {
+    album = album.copyWith(backupSelection: BackupSelection.excluded);
+    await _localAlbumService.update(album);
+
+    state = state
+        .map(
+          (currentAlbum) => currentAlbum.id == album.id
+              ? currentAlbum.copyWith(backupSelection: BackupSelection.excluded)
+              : currentAlbum,
+        )
+        .toList();
+  }
+}

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

@@ -0,0 +1,101 @@
+import 'dart:async';
+
+import 'package:connectivity_plus/connectivity_plus.dart';
+import 'package:flutter/material.dart';
+import 'package:immich_mobile/entities/asset.entity.dart';
+import 'package:immich_mobile/providers/asset.provider.dart';
+import 'package:immich_mobile/providers/backup/backup.provider.dart';
+import 'package:immich_mobile/services/backup_verification.service.dart';
+import 'package:immich_mobile/widgets/common/confirm_dialog.dart';
+import 'package:immich_mobile/widgets/common/immich_toast.dart';
+import 'package:riverpod_annotation/riverpod_annotation.dart';
+import 'package:wakelock_plus/wakelock_plus.dart';
+
+part 'backup_verification.provider.g.dart';
+
+@riverpod
+class BackupVerification extends _$BackupVerification {
+  @override
+  bool build() => false;
+
+  void performBackupCheck(BuildContext context) async {
+    try {
+      state = true;
+      final backupState = ref.read(backupProvider);
+
+      if (backupState.allUniqueAssets.length > backupState.selectedAlbumsBackupAssetsIds.length) {
+        if (context.mounted) {
+          ImmichToast.show(
+            context: context,
+            msg: "Backup all assets before starting this check!",
+            toastType: ToastType.error,
+          );
+        }
+        return;
+      }
+      final connection = await Connectivity().checkConnectivity();
+      if (!connection.contains(ConnectivityResult.wifi)) {
+        if (context.mounted) {
+          ImmichToast.show(
+            context: context,
+            msg: "Make sure to be connected to unmetered Wi-Fi",
+            toastType: ToastType.error,
+          );
+        }
+        return;
+      }
+      unawaited(WakelockPlus.enable());
+
+      const limit = 100;
+      final toDelete = await ref.read(backupVerificationServiceProvider).findWronglyBackedUpAssets(limit: limit);
+      if (toDelete.isEmpty) {
+        if (context.mounted) {
+          ImmichToast.show(
+            context: context,
+            msg: "Did not find any corrupt asset backups!",
+            toastType: ToastType.success,
+          );
+        }
+      } else {
+        if (context.mounted) {
+          await showDialog(
+            context: context,
+            builder: (ctx) => ConfirmDialog(
+              onOk: () => _performDeletion(context, toDelete),
+              title: "Corrupt backups!",
+              ok: "Delete",
+              content:
+                  "Found ${toDelete.length} (max $limit at once) corrupt asset backups. "
+                  "Run the check again to find more.\n"
+                  "Do you want to delete the corrupt asset backups now?",
+            ),
+          );
+        }
+      }
+    } finally {
+      unawaited(WakelockPlus.disable());
+      state = false;
+    }
+  }
+
+  Future<void> _performDeletion(BuildContext context, List<Asset> assets) async {
+    try {
+      state = true;
+      if (context.mounted) {
+        ImmichToast.show(context: context, msg: "Deleting ${assets.length} assets on the server...");
+      }
+      await ref.read(assetProvider.notifier).deleteAssets(assets, force: true);
+      if (context.mounted) {
+        ImmichToast.show(
+          context: context,
+          msg:
+              "Deleted ${assets.length} assets on the server. "
+              "You can now start a manual backup",
+          toastType: ToastType.success,
+        );
+      }
+    } finally {
+      state = false;
+    }
+  }
+}

mobile/lib/providers/backup/backup_verification.provider.g.dart

@@ -0,0 +1,27 @@
+// GENERATED CODE - DO NOT MODIFY BY HAND
+
+part of 'backup_verification.provider.dart';
+
+// **************************************************************************
+// RiverpodGenerator
+// **************************************************************************
+
+String _$backupVerificationHash() =>
+    r'b4b34909ed1af3f28877ea457d53a4a18b6417f8';
+
+/// See also [BackupVerification].
+@ProviderFor(BackupVerification)
+final backupVerificationProvider =
+    AutoDisposeNotifierProvider<BackupVerification, bool>.internal(
+      BackupVerification.new,
+      name: r'backupVerificationProvider',
+      debugGetCreateSourceHash: const bool.fromEnvironment('dart.vm.product')
+          ? null
+          : _$backupVerificationHash,
+      dependencies: null,
+      allTransitiveDependencies: null,
+    );
+
+typedef _$BackupVerification = AutoDisposeNotifier<bool>;
+// ignore_for_file: type=lint
+// ignore_for_file: subtype_of_sealed_class, invalid_use_of_internal_member, invalid_use_of_visible_for_testing_member, deprecated_member_use_from_same_package

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

@@ -0,0 +1,411 @@
+import 'dart:async';
+
+import 'package:cancellation_token_http/http.dart';
+import 'package:collection/collection.dart';
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+import 'package:logging/logging.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/utils/upload_speed_calculator.dart';
+import 'package:immich_mobile/providers/infrastructure/asset.provider.dart';
+import 'package:immich_mobile/providers/user.provider.dart';
+import 'package:immich_mobile/services/foreground_upload.service.dart';
+import 'package:immich_mobile/services/background_upload.service.dart';
+
+class EnqueueStatus {
+  final int enqueueCount;
+  final int totalCount;
+
+  const EnqueueStatus({required this.enqueueCount, required this.totalCount});
+
+  EnqueueStatus copyWith({int? enqueueCount, int? totalCount}) {
+    return EnqueueStatus(enqueueCount: enqueueCount ?? this.enqueueCount, totalCount: totalCount ?? this.totalCount);
+  }
+
+  @override
+  String toString() => 'EnqueueStatus(enqueueCount: $enqueueCount, totalCount: $totalCount)';
+}
+
+class DriftUploadStatus {
+  final String taskId;
+  final String filename;
+  final double progress;
+  final int fileSize;
+  final String networkSpeedAsString;
+  final bool? isFailed;
+  final String? error;
+
+  const DriftUploadStatus({
+    required this.taskId,
+    required this.filename,
+    required this.progress,
+    required this.fileSize,
+    required this.networkSpeedAsString,
+    this.isFailed,
+    this.error,
+  });
+
+  DriftUploadStatus copyWith({
+    String? taskId,
+    String? filename,
+    double? progress,
+    int? fileSize,
+    String? networkSpeedAsString,
+    bool? isFailed,
+    String? error,
+  }) {
+    return DriftUploadStatus(
+      taskId: taskId ?? this.taskId,
+      filename: filename ?? this.filename,
+      progress: progress ?? this.progress,
+      fileSize: fileSize ?? this.fileSize,
+      networkSpeedAsString: networkSpeedAsString ?? this.networkSpeedAsString,
+      isFailed: isFailed ?? this.isFailed,
+      error: error ?? this.error,
+    );
+  }
+
+  @override
+  String toString() {
+    return 'DriftUploadStatus(taskId: $taskId, filename: $filename, progress: $progress, fileSize: $fileSize, networkSpeedAsString: $networkSpeedAsString, isFailed: $isFailed, error: $error)';
+  }
+
+  @override
+  bool operator ==(covariant DriftUploadStatus other) {
+    if (identical(this, other)) return true;
+
+    return other.taskId == taskId &&
+        other.filename == filename &&
+        other.progress == progress &&
+        other.fileSize == fileSize &&
+        other.networkSpeedAsString == networkSpeedAsString &&
+        other.isFailed == isFailed &&
+        other.error == error;
+  }
+
+  @override
+  int get hashCode {
+    return taskId.hashCode ^
+        filename.hashCode ^
+        progress.hashCode ^
+        fileSize.hashCode ^
+        networkSpeedAsString.hashCode ^
+        isFailed.hashCode ^
+        error.hashCode;
+  }
+}
+
+enum BackupError { none, syncFailed }
+
+class DriftBackupState {
+  final int totalCount;
+  final int backupCount;
+  final int remainderCount;
+  final int processingCount;
+
+  final bool isSyncing;
+  final BackupError error;
+
+  final Map<String, DriftUploadStatus> uploadItems;
+  final CancellationToken? cancelToken;
+
+  final Map<String, double> iCloudDownloadProgress;
+
+  const DriftBackupState({
+    required this.totalCount,
+    required this.backupCount,
+    required this.remainderCount,
+    required this.processingCount,
+    required this.isSyncing,
+    this.error = BackupError.none,
+    required this.uploadItems,
+    this.cancelToken,
+    this.iCloudDownloadProgress = const {},
+  });
+
+  DriftBackupState copyWith({
+    int? totalCount,
+    int? backupCount,
+    int? remainderCount,
+    int? processingCount,
+    bool? isSyncing,
+    BackupError? error,
+    Map<String, DriftUploadStatus>? uploadItems,
+    CancellationToken? cancelToken,
+    Map<String, double>? iCloudDownloadProgress,
+  }) {
+    return DriftBackupState(
+      totalCount: totalCount ?? this.totalCount,
+      backupCount: backupCount ?? this.backupCount,
+      remainderCount: remainderCount ?? this.remainderCount,
+      processingCount: processingCount ?? this.processingCount,
+      isSyncing: isSyncing ?? this.isSyncing,
+      error: error ?? this.error,
+      uploadItems: uploadItems ?? this.uploadItems,
+      cancelToken: cancelToken ?? this.cancelToken,
+      iCloudDownloadProgress: iCloudDownloadProgress ?? this.iCloudDownloadProgress,
+    );
+  }
+
+  int get errorCount => uploadItems.values.where((item) => item.isFailed == true).length;
+
+  @override
+  String toString() {
+    return 'DriftBackupState(totalCount: $totalCount, backupCount: $backupCount, remainderCount: $remainderCount, processingCount: $processingCount, isSyncing: $isSyncing, error: $error, uploadItems: $uploadItems, cancelToken: $cancelToken, iCloudDownloadProgress: $iCloudDownloadProgress)';
+  }
+
+  @override
+  bool operator ==(covariant DriftBackupState other) {
+    if (identical(this, other)) return true;
+    final mapEquals = const DeepCollectionEquality().equals;
+
+    return other.totalCount == totalCount &&
+        other.backupCount == backupCount &&
+        other.remainderCount == remainderCount &&
+        other.processingCount == processingCount &&
+        other.isSyncing == isSyncing &&
+        other.error == error &&
+        mapEquals(other.iCloudDownloadProgress, iCloudDownloadProgress) &&
+        mapEquals(other.uploadItems, uploadItems) &&
+        other.cancelToken == cancelToken;
+  }
+
+  @override
+  int get hashCode {
+    return totalCount.hashCode ^
+        backupCount.hashCode ^
+        remainderCount.hashCode ^
+        processingCount.hashCode ^
+        isSyncing.hashCode ^
+        error.hashCode ^
+        uploadItems.hashCode ^
+        cancelToken.hashCode ^
+        iCloudDownloadProgress.hashCode;
+  }
+}
+
+final driftBackupProvider = StateNotifierProvider<DriftBackupNotifier, DriftBackupState>((ref) {
+  return DriftBackupNotifier(
+    ref.watch(foregroundUploadServiceProvider),
+    ref.watch(backgroundUploadServiceProvider),
+    UploadSpeedManager(),
+  );
+});
+
+class DriftBackupNotifier extends StateNotifier<DriftBackupState> {
+  DriftBackupNotifier(this._foregroundUploadService, this._backgroundUploadService, this._uploadSpeedManager)
+    : super(
+        const DriftBackupState(
+          totalCount: 0,
+          backupCount: 0,
+          remainderCount: 0,
+          processingCount: 0,
+          isSyncing: false,
+          uploadItems: {},
+          error: BackupError.none,
+        ),
+      );
+
+  final ForegroundUploadService _foregroundUploadService;
+  final BackgroundUploadService _backgroundUploadService;
+  final UploadSpeedManager _uploadSpeedManager;
+
+  final _logger = Logger("DriftBackupNotifier");
+
+  /// Remove upload item from state
+  void _removeUploadItem(String taskId) {
+    if (!mounted) {
+      _logger.warning("Skip _removeUploadItem: notifier disposed");
+      return;
+    }
+    if (state.uploadItems.containsKey(taskId)) {
+      final updatedItems = Map<String, DriftUploadStatus>.from(state.uploadItems);
+      updatedItems.remove(taskId);
+      state = state.copyWith(uploadItems: updatedItems);
+    }
+  }
+
+  Future<void> getBackupStatus(String userId) async {
+    if (!mounted) {
+      _logger.warning("Skip getBackupStatus (pre-call): notifier disposed");
+      return;
+    }
+    final counts = await _foregroundUploadService.getBackupCounts(userId);
+    if (!mounted) {
+      _logger.warning("Skip getBackupStatus (post-call): notifier disposed");
+      return;
+    }
+
+    state = state.copyWith(
+      totalCount: counts.total,
+      backupCount: counts.total - counts.remainder,
+      remainderCount: counts.remainder,
+      processingCount: counts.processing,
+    );
+  }
+
+  void updateError(BackupError error) async {
+    if (!mounted) {
+      _logger.warning("Skip updateError: notifier disposed");
+      return;
+    }
+    state = state.copyWith(error: error);
+  }
+
+  void updateSyncing(bool isSyncing) async {
+    state = state.copyWith(isSyncing: isSyncing);
+  }
+
+  Future<void> startForegroundBackup(String userId) async {
+    state = state.copyWith(error: BackupError.none);
+
+    final cancelToken = CancellationToken();
+    state = state.copyWith(cancelToken: cancelToken);
+
+    return _foregroundUploadService.uploadCandidates(
+      userId,
+      cancelToken,
+      callbacks: UploadCallbacks(
+        onProgress: _handleForegroundBackupProgress,
+        onSuccess: _handleForegroundBackupSuccess,
+        onError: _handleForegroundBackupError,
+        onICloudProgress: _handleICloudProgress,
+      ),
+    );
+  }
+
+  Future<void> stopForegroundBackup() async {
+    state.cancelToken?.cancel();
+    _uploadSpeedManager.clear();
+    state = state.copyWith(cancelToken: null, uploadItems: {}, iCloudDownloadProgress: {});
+  }
+
+  void _handleICloudProgress(String localAssetId, double progress) {
+    state = state.copyWith(iCloudDownloadProgress: {...state.iCloudDownloadProgress, localAssetId: progress});
+
+    if (progress >= 1.0) {
+      Future.delayed(const Duration(milliseconds: 250), () {
+        final updatedProgress = Map<String, double>.from(state.iCloudDownloadProgress);
+        updatedProgress.remove(localAssetId);
+        state = state.copyWith(iCloudDownloadProgress: updatedProgress);
+      });
+    }
+  }
+
+  void _handleForegroundBackupProgress(String localAssetId, String filename, int bytes, int totalBytes) {
+    if (state.cancelToken == null) {
+      return;
+    }
+
+    final progress = totalBytes > 0 ? bytes / totalBytes : 0.0;
+    final networkSpeedAsString = _uploadSpeedManager.updateProgress(localAssetId, bytes, totalBytes);
+    final currentItem = state.uploadItems[localAssetId];
+    if (currentItem != null) {
+      state = state.copyWith(
+        uploadItems: {
+          ...state.uploadItems,
+          localAssetId: currentItem.copyWith(
+            filename: filename,
+            progress: progress,
+            fileSize: totalBytes,
+            networkSpeedAsString: networkSpeedAsString,
+          ),
+        },
+      );
+    } else {
+      state = state.copyWith(
+        uploadItems: {
+          ...state.uploadItems,
+          localAssetId: DriftUploadStatus(
+            taskId: localAssetId,
+            filename: filename,
+            progress: progress,
+            fileSize: totalBytes,
+            networkSpeedAsString: networkSpeedAsString,
+          ),
+        },
+      );
+    }
+  }
+
+  void _handleForegroundBackupSuccess(String localAssetId, String remoteAssetId) {
+    state = state.copyWith(backupCount: state.backupCount + 1, remainderCount: state.remainderCount - 1);
+    _uploadSpeedManager.removeTask(localAssetId);
+
+    Future.delayed(const Duration(milliseconds: 1000), () {
+      _removeUploadItem(localAssetId);
+    });
+  }
+
+  void _handleForegroundBackupError(String localAssetId, String errorMessage) {
+    _logger.severe("Upload failed for $localAssetId: $errorMessage");
+
+    final currentItem = state.uploadItems[localAssetId];
+    if (currentItem != null) {
+      state = state.copyWith(
+        uploadItems: {
+          ...state.uploadItems,
+          localAssetId: currentItem.copyWith(isFailed: true, error: errorMessage),
+        },
+      );
+    } else {
+      state = state.copyWith(
+        uploadItems: {
+          ...state.uploadItems,
+          localAssetId: DriftUploadStatus(
+            taskId: localAssetId,
+            filename: 'Unknown',
+            progress: 0,
+            fileSize: 0,
+            networkSpeedAsString: '',
+            isFailed: true,
+            error: errorMessage,
+          ),
+        },
+      );
+    }
+
+    _uploadSpeedManager.removeTask(localAssetId);
+  }
+
+  Future<void> startBackupWithURLSession(String userId) async {
+    if (!mounted) {
+      _logger.warning("Skip handleBackupResume (pre-call): notifier disposed");
+      return;
+    }
+    _logger.info("Resuming backup tasks...");
+    state = state.copyWith(error: BackupError.none);
+    final tasks = await _backgroundUploadService.getActiveTasks(kBackupGroup);
+    if (!mounted) {
+      _logger.warning("Skip handleBackupResume (post-call): notifier disposed");
+      return;
+    }
+    _logger.info("Found ${tasks.length} tasks");
+
+    if (tasks.isEmpty) {
+      _logger.info("Start backup with URLSession");
+      return _backgroundUploadService.uploadBackupCandidates(userId);
+    }
+
+    _logger.info("Tasks to resume: ${tasks.length}");
+    return _backgroundUploadService.resume();
+  }
+}
+
+final driftBackupCandidateProvider = FutureProvider.autoDispose<List<LocalAsset>>((ref) async {
+  final user = ref.watch(currentUserProvider);
+  if (user == null) {
+    return [];
+  }
+
+  return ref.read(foregroundUploadServiceProvider).getBackupCandidates(user.id, onlyHashed: false);
+});
+
+final driftCandidateBackupAlbumInfoProvider = FutureProvider.autoDispose.family<List<LocalAlbum>, String>((
+  ref,
+  assetId,
+) {
+  return ref.read(localAssetRepository).getSourceAlbums(assetId, backupSelection: BackupSelection.selected);
+});

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

@@ -0,0 +1,22 @@
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+import 'package:immich_mobile/models/backup/error_upload_asset.model.dart';
+
+class ErrorBackupListNotifier extends StateNotifier<Set<ErrorUploadAsset>> {
+  ErrorBackupListNotifier() : super({});
+
+  add(ErrorUploadAsset errorAsset) {
+    state = state.union({errorAsset});
+  }
+
+  remove(ErrorUploadAsset errorAsset) {
+    state = state.difference({errorAsset});
+  }
+
+  empty() {
+    state = {};
+  }
+}
+
+final errorBackupListProvider = StateNotifierProvider<ErrorBackupListNotifier, Set<ErrorUploadAsset>>(
+  (ref) => ErrorBackupListNotifier(),
+);

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

@@ -0,0 +1,54 @@
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+import 'package:immich_mobile/services/background.service.dart';
+
+class IOSBackgroundSettings {
+  final bool appRefreshEnabled;
+  final int numberOfBackgroundTasksQueued;
+  final DateTime? timeOfLastFetch;
+  final DateTime? timeOfLastProcessing;
+
+  const IOSBackgroundSettings({
+    required this.appRefreshEnabled,
+    required this.numberOfBackgroundTasksQueued,
+    this.timeOfLastFetch,
+    this.timeOfLastProcessing,
+  });
+}
+
+class IOSBackgroundSettingsNotifier extends StateNotifier<IOSBackgroundSettings?> {
+  final BackgroundService _service;
+  IOSBackgroundSettingsNotifier(this._service) : super(null);
+
+  IOSBackgroundSettings? get settings => state;
+
+  Future<IOSBackgroundSettings> refresh() async {
+    final lastFetchTime = await _service.getIOSBackupLastRun(IosBackgroundTask.fetch);
+    final lastProcessingTime = await _service.getIOSBackupLastRun(IosBackgroundTask.processing);
+    int numberOfProcesses = await _service.getIOSBackupNumberOfProcesses();
+    final appRefreshEnabled = await _service.getIOSBackgroundAppRefreshEnabled();
+
+    // If this is enabled and there are no background processes,
+    // the user just enabled app refresh in Settings.
+    // But we don't have any background services running, since it was disabled
+    // before.
+    if (await _service.isBackgroundBackupEnabled() && numberOfProcesses == 0) {
+      // We need to restart the background service
+      await _service.enableService();
+      numberOfProcesses = await _service.getIOSBackupNumberOfProcesses();
+    }
+
+    final settings = IOSBackgroundSettings(
+      appRefreshEnabled: appRefreshEnabled,
+      numberOfBackgroundTasksQueued: numberOfProcesses,
+      timeOfLastFetch: lastFetchTime,
+      timeOfLastProcessing: lastProcessingTime,
+    );
+
+    state = settings;
+    return settings;
+  }
+}
+
+final iOSBackgroundSettingsProvider = StateNotifierProvider<IOSBackgroundSettingsNotifier, IOSBackgroundSettings?>(
+  (ref) => IOSBackgroundSettingsNotifier(ref.watch(backgroundServiceProvider)),
+);

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

@@ -0,0 +1,390 @@
+import 'dart:async';
+import 'dart:io';
+
+import 'package:cancellation_token_http/http.dart';
+import 'package:collection/collection.dart';
+import 'package:easy_localization/easy_localization.dart';
+import 'package:flutter/widgets.dart';
+import 'package:fluttertoast/fluttertoast.dart';
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+import 'package:immich_mobile/entities/asset.entity.dart';
+import 'package:immich_mobile/entities/backup_album.entity.dart';
+import 'package:immich_mobile/models/backup/backup_candidate.model.dart';
+import 'package:immich_mobile/models/backup/backup_state.model.dart';
+import 'package:immich_mobile/models/backup/current_upload_asset.model.dart';
+import 'package:immich_mobile/models/backup/error_upload_asset.model.dart';
+import 'package:immich_mobile/models/backup/manual_upload_state.model.dart';
+import 'package:immich_mobile/models/backup/success_upload_asset.model.dart';
+import 'package:immich_mobile/providers/app_life_cycle.provider.dart';
+import 'package:immich_mobile/providers/app_settings.provider.dart';
+import 'package:immich_mobile/providers/backup/backup.provider.dart';
+import 'package:immich_mobile/providers/backup/error_backup_list.provider.dart';
+import 'package:immich_mobile/providers/gallery_permission.provider.dart';
+import 'package:immich_mobile/repositories/file_media.repository.dart';
+import 'package:immich_mobile/services/app_settings.service.dart';
+import 'package:immich_mobile/services/background.service.dart';
+import 'package:immich_mobile/services/backup.service.dart';
+import 'package:immich_mobile/services/backup_album.service.dart';
+import 'package:immich_mobile/services/local_notification.service.dart';
+import 'package:immich_mobile/utils/backup_progress.dart';
+import 'package:immich_mobile/utils/debug_print.dart';
+import 'package:immich_mobile/widgets/common/immich_toast.dart';
+import 'package:logging/logging.dart';
+import 'package:permission_handler/permission_handler.dart';
+import 'package:photo_manager/photo_manager.dart' show PMProgressHandler;
+
+final manualUploadProvider = StateNotifierProvider<ManualUploadNotifier, ManualUploadState>((ref) {
+  return ManualUploadNotifier(
+    ref.watch(localNotificationService),
+    ref.watch(backupProvider.notifier),
+    ref.watch(backupServiceProvider),
+    ref.watch(backupAlbumServiceProvider),
+    ref,
+  );
+});
+
+class ManualUploadNotifier extends StateNotifier<ManualUploadState> {
+  final Logger _log = Logger("ManualUploadNotifier");
+  final LocalNotificationService _localNotificationService;
+  final BackupNotifier _backupProvider;
+  final BackupService _backupService;
+  final BackupAlbumService _backupAlbumService;
+  final Ref ref;
+
+  ManualUploadNotifier(
+    this._localNotificationService,
+    this._backupProvider,
+    this._backupService,
+    this._backupAlbumService,
+    this.ref,
+  ) : super(
+        ManualUploadState(
+          progressInPercentage: 0,
+          progressInFileSize: "0 B / 0 B",
+          progressInFileSpeed: 0,
+          progressInFileSpeeds: const [],
+          progressInFileSpeedUpdateTime: DateTime.now(),
+          progressInFileSpeedUpdateSentBytes: 0,
+          cancelToken: CancellationToken(),
+          currentUploadAsset: CurrentUploadAsset(
+            id: '...',
+            fileCreatedAt: DateTime.parse('2020-10-04'),
+            fileName: '...',
+            fileType: '...',
+          ),
+          totalAssetsToUpload: 0,
+          successfulUploads: 0,
+          currentAssetIndex: 0,
+          showDetailedNotification: false,
+        ),
+      );
+
+  String _lastPrintedDetailContent = '';
+  String? _lastPrintedDetailTitle;
+
+  static const notifyInterval = Duration(milliseconds: 500);
+  late final ThrottleProgressUpdate _throttledNotifiy = ThrottleProgressUpdate(_updateProgress, notifyInterval);
+  late final ThrottleProgressUpdate _throttledDetailNotify = ThrottleProgressUpdate(
+    _updateDetailProgress,
+    notifyInterval,
+  );
+
+  void _updateProgress(String? title, int progress, int total) {
+    // Guard against throttling calling this method after the upload is done
+    if (_backupProvider.backupProgress == BackUpProgressEnum.manualInProgress) {
+      _localNotificationService.showOrUpdateManualUploadStatus(
+        "backup_background_service_in_progress_notification".tr(),
+        formatAssetBackupProgress(state.currentAssetIndex, state.totalAssetsToUpload),
+        maxProgress: state.totalAssetsToUpload,
+        progress: state.currentAssetIndex,
+        showActions: true,
+      );
+    }
+  }
+
+  void _updateDetailProgress(String? title, int progress, int total) {
+    // Guard against throttling calling this method after the upload is done
+    if (_backupProvider.backupProgress == BackUpProgressEnum.manualInProgress) {
+      final String msg = total > 0 ? humanReadableBytesProgress(progress, total) : "";
+      // only update if message actually differs (to stop many useless notification updates on large assets or slow connections)
+      if (msg != _lastPrintedDetailContent || title != _lastPrintedDetailTitle) {
+        _lastPrintedDetailContent = msg;
+        _lastPrintedDetailTitle = title;
+        _localNotificationService.showOrUpdateManualUploadStatus(
+          title ?? 'Uploading',
+          msg,
+          progress: total > 0 ? (progress * 1000) ~/ total : 0,
+          maxProgress: 1000,
+          isDetailed: true,
+          // Detailed noitifcation is displayed for Single asset uploads. Show actions for such case
+          showActions: state.totalAssetsToUpload == 1,
+        );
+      }
+    }
+  }
+
+  void _onAssetUploaded(SuccessUploadAsset result) {
+    state = state.copyWith(successfulUploads: state.successfulUploads + 1);
+    _backupProvider.updateDiskInfo();
+  }
+
+  void _onAssetUploadError(ErrorUploadAsset errorAssetInfo) {
+    ref.watch(errorBackupListProvider.notifier).add(errorAssetInfo);
+  }
+
+  void _onProgress(int sent, int total) {
+    double lastUploadSpeed = state.progressInFileSpeed;
+    List<double> lastUploadSpeeds = state.progressInFileSpeeds.toList();
+    DateTime lastUpdateTime = state.progressInFileSpeedUpdateTime;
+    int lastSentBytes = state.progressInFileSpeedUpdateSentBytes;
+
+    final now = DateTime.now();
+    final duration = now.difference(lastUpdateTime);
+
+    // Keep the upload speed average span limited, to keep it somewhat relevant
+    if (lastUploadSpeeds.length > 10) {
+      lastUploadSpeeds.removeAt(0);
+    }
+
+    if (duration.inSeconds > 0) {
+      lastUploadSpeeds.add(((sent - lastSentBytes) / duration.inSeconds).abs().roundToDouble());
+
+      lastUploadSpeed = lastUploadSpeeds.average.abs().roundToDouble();
+      lastUpdateTime = now;
+      lastSentBytes = sent;
+    }
+
+    state = state.copyWith(
+      progressInPercentage: (sent.toDouble() / total.toDouble() * 100),
+      progressInFileSize: humanReadableFileBytesProgress(sent, total),
+      progressInFileSpeed: lastUploadSpeed,
+      progressInFileSpeeds: lastUploadSpeeds,
+      progressInFileSpeedUpdateTime: lastUpdateTime,
+      progressInFileSpeedUpdateSentBytes: lastSentBytes,
+    );
+
+    if (state.showDetailedNotification) {
+      final title = "backup_background_service_current_upload_notification".tr(
+        namedArgs: {'filename': state.currentUploadAsset.fileName},
+      );
+      _throttledDetailNotify(title: title, progress: sent, total: total);
+    }
+  }
+
+  void _onSetCurrentBackupAsset(CurrentUploadAsset currentUploadAsset) {
+    state = state.copyWith(currentUploadAsset: currentUploadAsset, currentAssetIndex: state.currentAssetIndex + 1);
+    if (state.totalAssetsToUpload > 1) {
+      _throttledNotifiy();
+    }
+    if (state.showDetailedNotification) {
+      _throttledDetailNotify.title = "backup_background_service_current_upload_notification".tr(
+        namedArgs: {'filename': currentUploadAsset.fileName},
+      );
+      _throttledDetailNotify.progress = 0;
+      _throttledDetailNotify.total = 0;
+    }
+  }
+
+  Future<bool> _startUpload(Iterable<Asset> allManualUploads) async {
+    bool hasErrors = false;
+    try {
+      _backupProvider.updateBackupProgress(BackUpProgressEnum.manualInProgress);
+
+      if (ref.read(galleryPermissionNotifier.notifier).hasPermission) {
+        await ref.read(fileMediaRepositoryProvider).clearFileCache();
+
+        final allAssetsFromDevice = allManualUploads.where((e) => e.isLocal && !e.isRemote).toList();
+
+        if (allAssetsFromDevice.length != allManualUploads.length) {
+          _log.warning(
+            '[_startUpload] Refreshed upload list -> ${allManualUploads.length - allAssetsFromDevice.length} asset will not be uploaded',
+          );
+        }
+
+        final selectedBackupAlbums = await _backupAlbumService.getAllBySelection(BackupSelection.select);
+        final excludedBackupAlbums = await _backupAlbumService.getAllBySelection(BackupSelection.exclude);
+
+        // Get candidates from selected albums and excluded albums
+        Set<BackupCandidate> candidates = await _backupService.buildUploadCandidates(
+          selectedBackupAlbums,
+          excludedBackupAlbums,
+          useTimeFilter: false,
+        );
+
+        // Extrack candidate from allAssetsFromDevice
+        final uploadAssets = candidates.where(
+          (candidate) =>
+              allAssetsFromDevice.firstWhereOrNull((asset) => asset.localId == candidate.asset.localId) != null,
+        );
+
+        if (uploadAssets.isEmpty) {
+          dPrint(() => "[_startUpload] No Assets to upload - Abort Process");
+          _backupProvider.updateBackupProgress(BackUpProgressEnum.idle);
+          return false;
+        }
+
+        state = state.copyWith(
+          progressInPercentage: 0,
+          progressInFileSize: "0 B / 0 B",
+          progressInFileSpeed: 0,
+          totalAssetsToUpload: uploadAssets.length,
+          successfulUploads: 0,
+          currentAssetIndex: 0,
+          currentUploadAsset: CurrentUploadAsset(
+            id: '...',
+            fileCreatedAt: DateTime.parse('2020-10-04'),
+            fileName: '...',
+            fileType: '...',
+          ),
+          cancelToken: CancellationToken(),
+        );
+        // Reset Error List
+        ref.watch(errorBackupListProvider.notifier).empty();
+
+        if (state.totalAssetsToUpload > 1) {
+          _throttledNotifiy();
+        }
+
+        // Show detailed asset if enabled in settings or if a single asset is uploaded
+        bool showDetailedNotification =
+            ref.read(appSettingsServiceProvider).getSetting<bool>(AppSettingsEnum.backgroundBackupSingleProgress) ||
+            state.totalAssetsToUpload == 1;
+        state = state.copyWith(showDetailedNotification: showDetailedNotification);
+        final pmProgressHandler = Platform.isIOS ? PMProgressHandler() : null;
+
+        final bool ok = await ref
+            .read(backupServiceProvider)
+            .backupAsset(
+              uploadAssets,
+              state.cancelToken,
+              pmProgressHandler: pmProgressHandler,
+              onSuccess: _onAssetUploaded,
+              onProgress: _onProgress,
+              onCurrentAsset: _onSetCurrentBackupAsset,
+              onError: _onAssetUploadError,
+            );
+
+        // Close detailed notification
+        await _localNotificationService.closeNotification(LocalNotificationService.manualUploadDetailedNotificationID);
+
+        _log.info(
+          '[_startUpload] Manual Upload Completed - success: ${state.successfulUploads},'
+          ' failed: ${state.totalAssetsToUpload - state.successfulUploads}',
+        );
+
+        // User cancelled upload
+        if (!ok && state.cancelToken.isCancelled) {
+          await _localNotificationService.showOrUpdateManualUploadStatus(
+            "backup_manual_title".tr(),
+            "backup_manual_cancelled".tr(),
+            presentBanner: true,
+          );
+          hasErrors = true;
+        } else if (state.successfulUploads == 0 || (!ok && !state.cancelToken.isCancelled)) {
+          await _localNotificationService.showOrUpdateManualUploadStatus(
+            "backup_manual_title".tr(),
+            "failed".tr(),
+            presentBanner: true,
+          );
+          hasErrors = true;
+        } else {
+          await _localNotificationService.showOrUpdateManualUploadStatus(
+            "backup_manual_title".tr(),
+            "backup_manual_success".tr(),
+            presentBanner: true,
+          );
+        }
+      } else {
+        unawaited(openAppSettings());
+        dPrint(() => "[_startUpload] Do not have permission to the gallery");
+      }
+    } catch (e) {
+      dPrint(() => "ERROR _startUpload: ${e.toString()}");
+      hasErrors = true;
+    } finally {
+      _backupProvider.updateBackupProgress(BackUpProgressEnum.idle);
+      _handleAppInActivity();
+      await _localNotificationService.closeNotification(LocalNotificationService.manualUploadDetailedNotificationID);
+      await _backupProvider.notifyBackgroundServiceCanRun();
+    }
+    return !hasErrors;
+  }
+
+  void _handleAppInActivity() {
+    final appState = ref.read(appStateProvider.notifier).getAppState();
+    // The app is currently in background. Perform the necessary cleanups which
+    // are on-hold for upload completion
+    if (appState != AppLifeCycleEnum.active && appState != AppLifeCycleEnum.resumed) {
+      ref.read(backupProvider.notifier).cancelBackup();
+    }
+  }
+
+  void cancelBackup() {
+    if (_backupProvider.backupProgress != BackUpProgressEnum.inProgress &&
+        _backupProvider.backupProgress != BackUpProgressEnum.manualInProgress) {
+      _backupProvider.notifyBackgroundServiceCanRun();
+    }
+    state.cancelToken.cancel();
+    if (_backupProvider.backupProgress != BackUpProgressEnum.manualInProgress) {
+      _backupProvider.updateBackupProgress(BackUpProgressEnum.idle);
+    }
+    state = state.copyWith(
+      progressInPercentage: 0,
+      progressInFileSize: "0 B / 0 B",
+      progressInFileSpeed: 0,
+      progressInFileSpeedUpdateTime: DateTime.now(),
+      progressInFileSpeedUpdateSentBytes: 0,
+    );
+  }
+
+  Future<bool> uploadAssets(BuildContext context, Iterable<Asset> allManualUploads) async {
+    // assumes the background service is currently running and
+    // waits until it has stopped to start the backup.
+    final bool hasLock = await ref.read(backgroundServiceProvider).acquireLock();
+    if (!hasLock) {
+      dPrint(() => "[uploadAssets] could not acquire lock, exiting");
+      ImmichToast.show(
+        context: context,
+        msg: "failed".tr(),
+        toastType: ToastType.info,
+        gravity: ToastGravity.BOTTOM,
+        durationInSecond: 3,
+      );
+      return false;
+    }
+
+    bool showInProgress = false;
+
+    // check if backup is already in process - then return
+    if (_backupProvider.backupProgress == BackUpProgressEnum.manualInProgress) {
+      dPrint(() => "[uploadAssets] Manual upload is already running - abort");
+      showInProgress = true;
+    }
+
+    if (_backupProvider.backupProgress == BackUpProgressEnum.inProgress) {
+      dPrint(() => "[uploadAssets] Auto Backup is already in progress - abort");
+      showInProgress = true;
+      return false;
+    }
+
+    if (_backupProvider.backupProgress == BackUpProgressEnum.inBackground) {
+      dPrint(() => "[uploadAssets] Background backup is running - abort");
+      showInProgress = true;
+    }
+
+    if (showInProgress) {
+      if (context.mounted) {
+        ImmichToast.show(
+          context: context,
+          msg: "backup_manual_in_progress".tr(),
+          toastType: ToastType.info,
+          gravity: ToastGravity.BOTTOM,
+          durationInSecond: 3,
+        );
+      }
+      return false;
+    }
+
+    return _startUpload(allManualUploads);
+  }
+}

mobile/lib/providers/cast.provider.dart

@@ -0,0 +1,113 @@
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+import 'package:immich_mobile/domain/models/asset/base_asset.model.dart';
+import 'package:immich_mobile/entities/asset.entity.dart' as old_asset_entity;
+import 'package:immich_mobile/models/cast/cast_manager_state.dart';
+import 'package:immich_mobile/services/gcast.service.dart';
+
+final castProvider = StateNotifierProvider<CastNotifier, CastManagerState>(
+  (ref) => CastNotifier(ref.watch(gCastServiceProvider)),
+);
+
+class CastNotifier extends StateNotifier<CastManagerState> {
+  // more cast providers can be added here (ie Fcast)
+  final GCastService _gCastService;
+
+  List<(String, CastDestinationType, dynamic)> discovered = List.empty();
+
+  CastNotifier(this._gCastService)
+    : super(
+        const CastManagerState(
+          isCasting: false,
+          currentTime: Duration.zero,
+          duration: Duration.zero,
+          receiverName: '',
+          castState: CastState.idle,
+        ),
+      ) {
+    _gCastService.onConnectionState = _onConnectionState;
+    _gCastService.onCurrentTime = _onCurrentTime;
+    _gCastService.onDuration = _onDuration;
+    _gCastService.onReceiverName = _onReceiverName;
+    _gCastService.onCastState = _onCastState;
+  }
+
+  void _onConnectionState(bool isCasting) {
+    state = state.copyWith(isCasting: isCasting);
+  }
+
+  void _onCurrentTime(Duration currentTime) {
+    state = state.copyWith(currentTime: currentTime);
+  }
+
+  void _onDuration(Duration duration) {
+    state = state.copyWith(duration: duration);
+  }
+
+  void _onReceiverName(String receiverName) {
+    state = state.copyWith(receiverName: receiverName);
+  }
+
+  void _onCastState(CastState castState) {
+    state = state.copyWith(castState: castState);
+  }
+
+  void loadMedia(RemoteAsset asset, bool reload) {
+    _gCastService.loadMedia(asset, reload);
+  }
+
+  // TODO: remove this when we migrate to new timeline
+  void loadMediaOld(old_asset_entity.Asset asset, bool reload) {
+    final remoteAsset = RemoteAsset(
+      id: asset.remoteId.toString(),
+      name: asset.name,
+      ownerId: asset.ownerId.toString(),
+      checksum: asset.checksum,
+      type: asset.type == old_asset_entity.AssetType.image
+          ? AssetType.image
+          : asset.type == old_asset_entity.AssetType.video
+          ? AssetType.video
+          : AssetType.other,
+      createdAt: asset.fileCreatedAt,
+      updatedAt: asset.updatedAt,
+      isEdited: false,
+    );
+
+    _gCastService.loadMedia(remoteAsset, reload);
+  }
+
+  Future<void> connect(CastDestinationType type, dynamic device) async {
+    switch (type) {
+      case CastDestinationType.googleCast:
+        await _gCastService.connect(device);
+        break;
+    }
+  }
+
+  Future<List<(String, CastDestinationType, dynamic)>> getDevices() async {
+    if (discovered.isEmpty) {
+      discovered = await _gCastService.getDevices();
+    }
+
+    return discovered;
+  }
+
+  void play() {
+    _gCastService.play();
+  }
+
+  void pause() {
+    _gCastService.pause();
+  }
+
+  void seekTo(Duration position) {
+    _gCastService.seekTo(position);
+  }
+
+  void stop() {
+    _gCastService.stop();
+  }
+
+  Future<void> disconnect() async {
+    await _gCastService.disconnect();
+  }
+}

mobile/lib/providers/cleanup.provider.dart

@@ -0,0 +1,194 @@
+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/providers/app_settings.provider.dart';
+import 'package:immich_mobile/providers/user.provider.dart';
+import 'package:immich_mobile/services/app_settings.service.dart';
+import 'package:immich_mobile/services/cleanup.service.dart';
+
+class CleanupState {
+  final DateTime? selectedDate;
+  final List<LocalAsset> assetsToDelete;
+  final int totalBytes;
+  final bool isScanning;
+  final bool isDeleting;
+  final AssetKeepType keepMediaType;
+  final bool keepFavorites;
+  final Set<String> keepAlbumIds;
+
+  const CleanupState({
+    this.selectedDate,
+    this.assetsToDelete = const [],
+    this.totalBytes = 0,
+    this.isScanning = false,
+    this.isDeleting = false,
+    this.keepMediaType = AssetKeepType.none,
+    this.keepFavorites = true,
+    this.keepAlbumIds = const {},
+  });
+
+  CleanupState copyWith({
+    DateTime? selectedDate,
+    List<LocalAsset>? assetsToDelete,
+    int? totalBytes,
+    bool? isScanning,
+    bool? isDeleting,
+    AssetKeepType? keepMediaType,
+    bool? keepFavorites,
+    Set<String>? keepAlbumIds,
+  }) {
+    return CleanupState(
+      selectedDate: selectedDate ?? this.selectedDate,
+      assetsToDelete: assetsToDelete ?? this.assetsToDelete,
+      totalBytes: totalBytes ?? this.totalBytes,
+      isScanning: isScanning ?? this.isScanning,
+      isDeleting: isDeleting ?? this.isDeleting,
+      keepMediaType: keepMediaType ?? this.keepMediaType,
+      keepFavorites: keepFavorites ?? this.keepFavorites,
+      keepAlbumIds: keepAlbumIds ?? this.keepAlbumIds,
+    );
+  }
+}
+
+final cleanupProvider = StateNotifierProvider<CleanupNotifier, CleanupState>((ref) {
+  return CleanupNotifier(
+    ref.watch(cleanupServiceProvider),
+    ref.watch(currentUserProvider)?.id,
+    ref.watch(appSettingsServiceProvider),
+  );
+});
+
+class CleanupNotifier extends StateNotifier<CleanupState> {
+  final CleanupService _cleanupService;
+  final String? _userId;
+  final AppSettingsService _appSettingsService;
+
+  CleanupNotifier(this._cleanupService, this._userId, this._appSettingsService) : super(const CleanupState()) {
+    _loadPersistedSettings();
+  }
+
+  void _loadPersistedSettings() {
+    final keepFavorites = _appSettingsService.getSetting(AppSettingsEnum.cleanupKeepFavorites);
+    final keepMediaTypeIndex = _appSettingsService.getSetting(AppSettingsEnum.cleanupKeepMediaType);
+    final keepAlbumIdsString = _appSettingsService.getSetting(AppSettingsEnum.cleanupKeepAlbumIds);
+    final cutoffDaysAgo = _appSettingsService.getSetting(AppSettingsEnum.cleanupCutoffDaysAgo);
+
+    final keepMediaType = AssetKeepType.values[keepMediaTypeIndex.clamp(0, AssetKeepType.values.length - 1)];
+    final keepAlbumIds = keepAlbumIdsString.isEmpty ? <String>{} : keepAlbumIdsString.split(',').toSet();
+    final selectedDate = cutoffDaysAgo >= 0 ? DateTime.now().subtract(Duration(days: cutoffDaysAgo)) : null;
+
+    state = state.copyWith(
+      keepFavorites: keepFavorites,
+      keepMediaType: keepMediaType,
+      keepAlbumIds: keepAlbumIds,
+      selectedDate: selectedDate,
+    );
+  }
+
+  void setSelectedDate(DateTime? date) {
+    state = state.copyWith(selectedDate: date, assetsToDelete: []);
+    if (date != null) {
+      final daysAgo = DateTime.now().difference(date).inDays;
+      _appSettingsService.setSetting(AppSettingsEnum.cleanupCutoffDaysAgo, daysAgo);
+    }
+  }
+
+  void setKeepMediaType(AssetKeepType keepMediaType) {
+    state = state.copyWith(keepMediaType: keepMediaType, assetsToDelete: []);
+    _appSettingsService.setSetting(AppSettingsEnum.cleanupKeepMediaType, keepMediaType.index);
+  }
+
+  void setKeepFavorites(bool keepFavorites) {
+    state = state.copyWith(keepFavorites: keepFavorites, assetsToDelete: []);
+    _appSettingsService.setSetting(AppSettingsEnum.cleanupKeepFavorites, keepFavorites);
+  }
+
+  void toggleKeepAlbum(String albumId) {
+    final newKeepAlbumIds = Set<String>.from(state.keepAlbumIds);
+    if (newKeepAlbumIds.contains(albumId)) {
+      newKeepAlbumIds.remove(albumId);
+    } else {
+      newKeepAlbumIds.add(albumId);
+    }
+    state = state.copyWith(keepAlbumIds: newKeepAlbumIds, assetsToDelete: []);
+    _persistExcludedAlbumIds(newKeepAlbumIds);
+  }
+
+  void setExcludedAlbumIds(Set<String> albumIds) {
+    state = state.copyWith(keepAlbumIds: albumIds, assetsToDelete: []);
+    _persistExcludedAlbumIds(albumIds);
+  }
+
+  void _persistExcludedAlbumIds(Set<String> albumIds) {
+    _appSettingsService.setSetting(AppSettingsEnum.cleanupKeepAlbumIds, albumIds.join(','));
+  }
+
+  void cleanupStaleAlbumIds(Set<String> existingAlbumIds) {
+    final staleIds = state.keepAlbumIds.difference(existingAlbumIds);
+    if (staleIds.isNotEmpty) {
+      final cleanedIds = state.keepAlbumIds.intersection(existingAlbumIds);
+      state = state.copyWith(keepAlbumIds: cleanedIds);
+      _persistExcludedAlbumIds(cleanedIds);
+    }
+  }
+
+  void applyDefaultAlbumSelections(List<(String id, String name)> albums) {
+    final isInitialized = _appSettingsService.getSetting(AppSettingsEnum.cleanupDefaultsInitialized);
+    if (isInitialized) return;
+
+    final toKeep = _cleanupService.getDefaultKeepAlbumIds(albums);
+
+    if (toKeep.isNotEmpty) {
+      final keepAlbumIds = {...state.keepAlbumIds, ...toKeep};
+      state = state.copyWith(keepAlbumIds: keepAlbumIds);
+      _persistExcludedAlbumIds(keepAlbumIds);
+    }
+
+    _appSettingsService.setSetting(AppSettingsEnum.cleanupDefaultsInitialized, true);
+  }
+
+  Future<void> scanAssets() async {
+    if (_userId == null || state.selectedDate == null) {
+      return;
+    }
+
+    state = state.copyWith(isScanning: true);
+    try {
+      final result = await _cleanupService.getRemovalCandidates(
+        _userId,
+        state.selectedDate!,
+        keepMediaType: state.keepMediaType,
+        keepFavorites: state.keepFavorites,
+        keepAlbumIds: state.keepAlbumIds,
+      );
+
+      state = state.copyWith(assetsToDelete: result.assets, totalBytes: result.totalBytes, isScanning: false);
+    } catch (e) {
+      state = state.copyWith(isScanning: false);
+      rethrow;
+    }
+  }
+
+  Future<int> deleteAssets() async {
+    if (state.assetsToDelete.isEmpty) {
+      return 0;
+    }
+
+    state = state.copyWith(isDeleting: true);
+    try {
+      final deletedCount = await _cleanupService.deleteLocalAssets(state.assetsToDelete.map((a) => a.id).toList());
+
+      state = state.copyWith(assetsToDelete: [], isDeleting: false);
+
+      return deletedCount;
+    } catch (e) {
+      state = state.copyWith(isDeleting: false);
+      rethrow;
+    }
+  }
+
+  void reset() {
+    // Only reset transient state, keep the persisted filter settings
+    state = state.copyWith(selectedDate: null, assetsToDelete: [], isScanning: false, isDeleting: false);
+  }
+}

mobile/lib/providers/db.provider.dart

@@ -0,0 +1,5 @@
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+import 'package:isar/isar.dart';
+
+// overwritten in main.dart due to async loading
+final dbProvider = Provider<Isar>((_) => throw UnimplementedError());

mobile/lib/providers/folder.provider.dart

@@ -0,0 +1,51 @@
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+import 'package:immich_mobile/constants/enums.dart';
+import 'package:immich_mobile/models/folder/root_folder.model.dart';
+import 'package:immich_mobile/services/folder.service.dart';
+import 'package:immich_mobile/widgets/asset_grid/asset_grid_data_structure.dart';
+import 'package:logging/logging.dart';
+
+class FolderStructureNotifier extends StateNotifier<AsyncValue<RootFolder>> {
+  final FolderService _folderService;
+  final Logger _log = Logger("FolderStructureNotifier");
+
+  FolderStructureNotifier(this._folderService) : super(const AsyncLoading());
+
+  Future<void> fetchFolders(SortOrder order) async {
+    try {
+      final folders = await _folderService.getFolderStructure(order);
+      state = AsyncData(folders);
+    } catch (e, stack) {
+      _log.severe("Failed to build folder structure", e, stack);
+      state = AsyncError(e, stack);
+    }
+  }
+}
+
+final folderStructureProvider = StateNotifierProvider<FolderStructureNotifier, AsyncValue<RootFolder>>((ref) {
+  return FolderStructureNotifier(ref.watch(folderServiceProvider));
+});
+
+class FolderRenderListNotifier extends StateNotifier<AsyncValue<RenderList>> {
+  final FolderService _folderService;
+  final RootFolder _folder;
+  final Logger _log = Logger("FolderAssetsNotifier");
+
+  FolderRenderListNotifier(this._folderService, this._folder) : super(const AsyncLoading());
+
+  Future<void> fetchAssets(SortOrder order) async {
+    try {
+      final assets = await _folderService.getFolderAssets(_folder, order);
+      final renderList = await RenderList.fromAssets(assets, GroupAssetsBy.none);
+      state = AsyncData(renderList);
+    } catch (e, stack) {
+      _log.severe("Failed to fetch folder assets", e, stack);
+      state = AsyncError(e, stack);
+    }
+  }
+}
+
+final folderRenderListProvider =
+    StateNotifierProvider.family<FolderRenderListNotifier, AsyncValue<RenderList>, RootFolder>((ref, folder) {
+      return FolderRenderListNotifier(ref.watch(folderServiceProvider), folder);
+    });

mobile/lib/providers/gallery_permission.provider.dart

@@ -0,0 +1,108 @@
+import 'dart:io';
+
+import 'package:device_info_plus/device_info_plus.dart';
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+import 'package:permission_handler/permission_handler.dart';
+
+class GalleryPermissionNotifier extends StateNotifier<PermissionStatus> {
+  GalleryPermissionNotifier()
+    : super(PermissionStatus.denied) // Denied is the initial state
+      {
+    // Sets the initial state
+    getGalleryPermissionStatus();
+  }
+
+  get hasPermission => state.isGranted || state.isLimited;
+
+  /// Requests the gallery permission
+  Future<PermissionStatus> requestGalleryPermission() async {
+    PermissionStatus result;
+    // Android 32 and below uses Permission.storage
+    if (Platform.isAndroid) {
+      final androidInfo = await DeviceInfoPlugin().androidInfo;
+      if (androidInfo.version.sdkInt <= 32) {
+        // Android 32 and below need storage
+        final permission = await Permission.storage.request();
+        result = permission;
+      } else {
+        // Android 33 need photo & video
+        final photos = await Permission.photos.request();
+        if (!photos.isGranted) {
+          // Don't ask twice for the same permission
+          state = photos;
+          return photos;
+        }
+        final videos = await Permission.videos.request();
+
+        // Return the joint result of those two permissions
+        final PermissionStatus status;
+        if ((photos.isGranted && videos.isGranted) || (photos.isLimited && videos.isLimited)) {
+          status = PermissionStatus.granted;
+        } else if (photos.isDenied || videos.isDenied) {
+          status = PermissionStatus.denied;
+        } else if (photos.isPermanentlyDenied || videos.isPermanentlyDenied) {
+          status = PermissionStatus.permanentlyDenied;
+        } else {
+          status = PermissionStatus.denied;
+        }
+
+        result = status;
+      }
+      if (result == PermissionStatus.granted && androidInfo.version.sdkInt >= 29) {
+        result = await Permission.accessMediaLocation.request();
+      }
+    } else {
+      // iOS can use photos
+      final photos = await Permission.photos.request();
+      result = photos;
+    }
+    state = result;
+    return result;
+  }
+
+  /// Checks the current state of the gallery permissions without
+  /// requesting them again
+  Future<PermissionStatus> getGalleryPermissionStatus() async {
+    PermissionStatus result;
+    // Android 32 and below uses Permission.storage
+    if (Platform.isAndroid) {
+      final androidInfo = await DeviceInfoPlugin().androidInfo;
+      if (androidInfo.version.sdkInt <= 32) {
+        // Android 32 and below need storage
+        final permission = await Permission.storage.status;
+        result = permission;
+      } else {
+        // Android 33 needs photo & video
+        final photos = await Permission.photos.status;
+        final videos = await Permission.videos.status;
+
+        // Return the joint result of those two permissions
+        final PermissionStatus status;
+        if ((photos.isGranted && videos.isGranted) || (photos.isLimited && videos.isLimited)) {
+          status = PermissionStatus.granted;
+        } else if (photos.isDenied || videos.isDenied) {
+          status = PermissionStatus.denied;
+        } else if (photos.isPermanentlyDenied || videos.isPermanentlyDenied) {
+          status = PermissionStatus.permanentlyDenied;
+        } else {
+          status = PermissionStatus.denied;
+        }
+
+        result = status;
+      }
+      if (state == PermissionStatus.granted && androidInfo.version.sdkInt >= 29) {
+        result = await Permission.accessMediaLocation.status;
+      }
+    } else {
+      // iOS can use photos
+      final photos = await Permission.photos.status;
+      result = photos;
+    }
+    state = result;
+    return result;
+  }
+}
+
+final galleryPermissionNotifier = StateNotifierProvider<GalleryPermissionNotifier, PermissionStatus>(
+  (ref) => GalleryPermissionNotifier(),
+);

mobile/lib/providers/haptic_feedback.provider.dart

@@ -0,0 +1,45 @@
+import 'package:flutter/services.dart';
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+import 'package:immich_mobile/providers/app_settings.provider.dart';
+import 'package:immich_mobile/services/app_settings.service.dart';
+
+final hapticFeedbackProvider = StateNotifierProvider<HapticNotifier, void>((ref) {
+  return HapticNotifier(ref);
+});
+
+class HapticNotifier extends StateNotifier<void> {
+  void build() {}
+  final Ref _ref;
+
+  HapticNotifier(this._ref) : super(null);
+
+  selectionClick() {
+    if (_ref.read(appSettingsServiceProvider).getSetting(AppSettingsEnum.enableHapticFeedback)) {
+      HapticFeedback.selectionClick();
+    }
+  }
+
+  lightImpact() {
+    if (_ref.read(appSettingsServiceProvider).getSetting(AppSettingsEnum.enableHapticFeedback)) {
+      HapticFeedback.lightImpact();
+    }
+  }
+
+  mediumImpact() {
+    if (_ref.read(appSettingsServiceProvider).getSetting(AppSettingsEnum.enableHapticFeedback)) {
+      HapticFeedback.mediumImpact();
+    }
+  }
+
+  heavyImpact() {
+    if (_ref.read(appSettingsServiceProvider).getSetting(AppSettingsEnum.enableHapticFeedback)) {
+      HapticFeedback.heavyImpact();
+    }
+  }
+
+  vibrate() {
+    if (_ref.read(appSettingsServiceProvider).getSetting(AppSettingsEnum.enableHapticFeedback)) {
+      HapticFeedback.vibrate();
+    }
+  }
+}

mobile/lib/providers/image/cache/image_loader.dart

@@ -0,0 +1,40 @@
+import 'dart:async';
+import 'dart:ui' as ui;
+
+import 'package:flutter/material.dart';
+import 'package:flutter_cache_manager/flutter_cache_manager.dart';
+import 'package:immich_mobile/providers/image/exceptions/image_loading_exception.dart';
+import 'package:immich_mobile/services/api.service.dart';
+
+/// Loads the codec from the URI and sends the events to the [chunkEvents] stream
+///
+/// Credit to [flutter_cached_network_image](https://github.com/Baseflow/flutter_cached_network_image/blob/develop/cached_network_image/lib/src/image_provider/_image_loader.dart)
+/// for this wonderful implementation of their image loader
+class ImageLoader {
+  static Future<ui.Codec> loadImageFromCache(
+    String uri, {
+    required CacheManager cache,
+    required ImageDecoderCallback decode,
+    StreamController<ImageChunkEvent>? chunkEvents,
+  }) async {
+    final headers = ApiService.getRequestHeaders();
+
+    final stream = cache.getFileStream(uri, withProgress: chunkEvents != null, headers: headers);
+
+    await for (final result in stream) {
+      if (result is DownloadProgress) {
+        // We are downloading the file, so update the [chunkEvents]
+        chunkEvents?.add(
+          ImageChunkEvent(cumulativeBytesLoaded: result.downloaded, expectedTotalBytes: result.totalSize),
+        );
+      } else if (result is FileInfo) {
+        // We have the file
+        final buffer = await ui.ImmutableBuffer.fromFilePath(result.file.path);
+        return decode(buffer);
+      }
+    }
+
+    // If we get here, the image failed to load from the cache stream
+    throw const ImageLoadingException('Could not load image from stream');
+  }
+}

mobile/lib/providers/image/cache/remote_image_cache_manager.dart

@@ -0,0 +1,25 @@
+import 'package:flutter_cache_manager/flutter_cache_manager.dart';
+
+class RemoteImageCacheManager extends CacheManager {
+  static const key = 'remoteImageCacheKey';
+  static final RemoteImageCacheManager _instance = RemoteImageCacheManager._();
+  static final _config = Config(key, maxNrOfCacheObjects: 500, stalePeriod: const Duration(days: 30));
+
+  factory RemoteImageCacheManager() {
+    return _instance;
+  }
+
+  RemoteImageCacheManager._() : super(_config);
+}
+
+class RemoteThumbnailCacheManager extends CacheManager {
+  static const key = 'remoteThumbnailCacheKey';
+  static final RemoteThumbnailCacheManager _instance = RemoteThumbnailCacheManager._();
+  static final _config = Config(key, maxNrOfCacheObjects: 5000, stalePeriod: const Duration(days: 30));
+
+  factory RemoteThumbnailCacheManager() {
+    return _instance;
+  }
+
+  RemoteThumbnailCacheManager._() : super(_config);
+}

mobile/lib/providers/image/cache/thumbnail_image_cache_manager.dart

@@ -0,0 +1,13 @@
+import 'package:flutter_cache_manager/flutter_cache_manager.dart';
+
+/// The cache manager for thumbnail images [ImmichRemoteThumbnailProvider]
+class ThumbnailImageCacheManager extends CacheManager {
+  static const key = 'thumbnailImageCacheKey';
+  static final ThumbnailImageCacheManager _instance = ThumbnailImageCacheManager._();
+
+  factory ThumbnailImageCacheManager() {
+    return _instance;
+  }
+
+  ThumbnailImageCacheManager._() : super(Config(key, maxNrOfCacheObjects: 5000, stalePeriod: const Duration(days: 30)));
+}

mobile/lib/providers/image/exceptions/image_loading_exception.dart

@@ -0,0 +1,5 @@
+/// An exception for the [ImageLoader] and the Immich image providers
+class ImageLoadingException implements Exception {
+  final String message;
+  const ImageLoadingException(this.message);
+}

mobile/lib/providers/image/immich_local_image_provider.dart

@@ -0,0 +1,94 @@
+import 'dart:async';
+import 'dart:io';
+import 'dart:ui' as ui;
+
+import 'package:cached_network_image/cached_network_image.dart';
+import 'package:flutter/foundation.dart';
+import 'package:flutter/painting.dart';
+import 'package:immich_mobile/entities/asset.entity.dart';
+import 'package:logging/logging.dart';
+import 'package:photo_manager/photo_manager.dart' show ThumbnailSize;
+
+/// The local image provider for an asset
+class ImmichLocalImageProvider extends ImageProvider<ImmichLocalImageProvider> {
+  final Asset asset;
+  // only used for videos
+  final double width;
+  final double height;
+  final Logger log = Logger('ImmichLocalImageProvider');
+
+  ImmichLocalImageProvider({required this.asset, required this.width, required this.height})
+    : assert(asset.local != null, 'Only usable when asset.local is set');
+
+  /// Converts an [ImageProvider]'s settings plus an [ImageConfiguration] to a key
+  /// that describes the precise image to load.
+  @override
+  Future<ImmichLocalImageProvider> obtainKey(ImageConfiguration configuration) {
+    return SynchronousFuture(this);
+  }
+
+  @override
+  ImageStreamCompleter loadImage(ImmichLocalImageProvider key, ImageDecoderCallback decode) {
+    final chunkEvents = StreamController<ImageChunkEvent>();
+    return MultiImageStreamCompleter(
+      codec: _codec(key.asset, decode, chunkEvents),
+      scale: 1.0,
+      chunkEvents: chunkEvents.stream,
+      informationCollector: () sync* {
+        yield ErrorDescription(asset.fileName);
+      },
+    );
+  }
+
+  // Streams in each stage of the image as we ask for it
+  Stream<ui.Codec> _codec(
+    Asset asset,
+    ImageDecoderCallback decode,
+    StreamController<ImageChunkEvent> chunkEvents,
+  ) async* {
+    try {
+      final local = asset.local;
+      if (local == null) {
+        throw StateError('Asset ${asset.fileName} has no local data');
+      }
+
+      switch (asset.type) {
+        case AssetType.image:
+          final File? file = await local.originFile;
+          if (file == null) {
+            throw StateError("Opening file for asset ${asset.fileName} failed");
+          }
+          final buffer = await ui.ImmutableBuffer.fromFilePath(file.path);
+          yield await decode(buffer);
+          break;
+        case AssetType.video:
+          final size = ThumbnailSize(width.ceil(), height.ceil());
+          final thumbBytes = await local.thumbnailDataWithSize(size);
+          if (thumbBytes == null) {
+            throw StateError("Failed to load preview for ${asset.fileName}");
+          }
+          final buffer = await ui.ImmutableBuffer.fromUint8List(thumbBytes);
+          yield await decode(buffer);
+          break;
+        default:
+          throw StateError('Unsupported asset type ${asset.type}');
+      }
+    } catch (error, stack) {
+      log.severe('Error loading local image ${asset.fileName}', error, stack);
+    } finally {
+      unawaited(chunkEvents.close());
+    }
+  }
+
+  @override
+  bool operator ==(Object other) {
+    if (identical(this, other)) return true;
+    if (other is ImmichLocalImageProvider) {
+      return asset.id == other.asset.id && asset.localId == other.asset.localId;
+    }
+    return false;
+  }
+
+  @override
+  int get hashCode => Object.hash(asset.id, asset.localId);
+}

mobile/lib/providers/image/immich_local_thumbnail_provider.dart

@@ -0,0 +1,88 @@
+import 'dart:async';
+import 'dart:ui' as ui;
+
+import 'package:cached_network_image/cached_network_image.dart';
+import 'package:flutter_cache_manager/flutter_cache_manager.dart';
+import 'package:immich_mobile/providers/image/cache/thumbnail_image_cache_manager.dart';
+
+import 'package:flutter/foundation.dart';
+import 'package:flutter/painting.dart';
+import 'package:immich_mobile/entities/asset.entity.dart';
+import 'package:photo_manager/photo_manager.dart' show ThumbnailSize;
+import 'package:logging/logging.dart';
+
+/// The local image provider for an asset
+/// Only viable
+class ImmichLocalThumbnailProvider extends ImageProvider<ImmichLocalThumbnailProvider> {
+  final Asset asset;
+  final int height;
+  final int width;
+  final CacheManager? cacheManager;
+  final Logger log = Logger("ImmichLocalThumbnailProvider");
+  final String? userId;
+
+  ImmichLocalThumbnailProvider({
+    required this.asset,
+    this.height = 256,
+    this.width = 256,
+    this.cacheManager,
+    this.userId,
+  }) : assert(asset.local != null, 'Only usable when asset.local is set');
+
+  /// Converts an [ImageProvider]'s settings plus an [ImageConfiguration] to a key
+  /// that describes the precise image to load.
+  @override
+  Future<ImmichLocalThumbnailProvider> obtainKey(ImageConfiguration configuration) {
+    return SynchronousFuture(this);
+  }
+
+  @override
+  ImageStreamCompleter loadImage(ImmichLocalThumbnailProvider key, ImageDecoderCallback decode) {
+    final cache = cacheManager ?? ThumbnailImageCacheManager();
+    return MultiImageStreamCompleter(
+      codec: _codec(key.asset, cache, decode),
+      scale: 1.0,
+      informationCollector: () sync* {
+        yield ErrorDescription(key.asset.fileName);
+      },
+    );
+  }
+
+  // Streams in each stage of the image as we ask for it
+  Stream<ui.Codec> _codec(Asset assetData, CacheManager cache, ImageDecoderCallback decode) async* {
+    final cacheKey = '$userId${assetData.localId}${assetData.checksum}$width$height';
+    final fileFromCache = await cache.getFileFromCache(cacheKey);
+    if (fileFromCache != null) {
+      try {
+        final buffer = await ui.ImmutableBuffer.fromFilePath(fileFromCache.file.path);
+        final codec = await decode(buffer);
+        yield codec;
+        return;
+      } catch (error) {
+        log.severe('Found thumbnail in cache, but loading it failed', error);
+      }
+    }
+
+    final thumbnailBytes = await assetData.local?.thumbnailDataWithSize(ThumbnailSize(width, height), quality: 80);
+    if (thumbnailBytes == null) {
+      throw StateError("Loading thumb for local photo ${assetData.fileName} failed");
+    }
+
+    final buffer = await ui.ImmutableBuffer.fromUint8List(thumbnailBytes);
+    final codec = await decode(buffer);
+    yield codec;
+    await cache.putFile(cacheKey, thumbnailBytes);
+  }
+
+  @override
+  bool operator ==(Object other) {
+    if (identical(this, other)) return true;
+    if (other is ImmichLocalThumbnailProvider) {
+      return asset.id == other.asset.id && asset.localId == other.asset.localId;
+    }
+    return false;
+  }
+
+  @override
+  int get hashCode => Object.hash(asset.id, asset.localId);
+}

mobile/lib/providers/image/immich_remote_image_provider.dart

@@ -0,0 +1,82 @@
+import 'dart:async';
+import 'dart:ui' as ui;
+
+import 'package:cached_network_image/cached_network_image.dart';
+import 'package:flutter_cache_manager/flutter_cache_manager.dart';
+import 'package:immich_mobile/providers/image/cache/image_loader.dart';
+import 'package:immich_mobile/providers/image/cache/remote_image_cache_manager.dart';
+import 'package:openapi/api.dart' as api;
+
+import 'package:flutter/foundation.dart';
+import 'package:flutter/painting.dart';
+import 'package:immich_mobile/services/app_settings.service.dart';
+import 'package:immich_mobile/entities/asset.entity.dart';
+import 'package:immich_mobile/entities/store.entity.dart';
+import 'package:immich_mobile/utils/image_url_builder.dart';
+
+/// The remote image provider for full size remote images
+class ImmichRemoteImageProvider extends ImageProvider<ImmichRemoteImageProvider> {
+  /// The [Asset.remoteId] of the asset to fetch
+  final String assetId;
+
+  /// The image cache manager
+  final CacheManager? cacheManager;
+
+  const ImmichRemoteImageProvider({required this.assetId, this.cacheManager});
+
+  /// Converts an [ImageProvider]'s settings plus an [ImageConfiguration] to a key
+  /// that describes the precise image to load.
+  @override
+  Future<ImmichRemoteImageProvider> obtainKey(ImageConfiguration configuration) {
+    return SynchronousFuture(this);
+  }
+
+  @override
+  ImageStreamCompleter loadImage(ImmichRemoteImageProvider key, ImageDecoderCallback decode) {
+    final cache = cacheManager ?? RemoteImageCacheManager();
+    final chunkEvents = StreamController<ImageChunkEvent>();
+    return MultiImageStreamCompleter(
+      codec: _codec(key, cache, decode, chunkEvents),
+      scale: 1.0,
+      chunkEvents: chunkEvents.stream,
+    );
+  }
+
+  /// Whether to show the original file or load a compressed version
+  bool get _useOriginal => Store.get(AppSettingsEnum.loadOriginal.storeKey, AppSettingsEnum.loadOriginal.defaultValue);
+
+  // Streams in each stage of the image as we ask for it
+  Stream<ui.Codec> _codec(
+    ImmichRemoteImageProvider key,
+    CacheManager cache,
+    ImageDecoderCallback decode,
+    StreamController<ImageChunkEvent> chunkEvents,
+  ) async* {
+    // Load the higher resolution version of the image
+    final url = getThumbnailUrlForRemoteId(key.assetId, type: api.AssetMediaSize.preview);
+    final codec = await ImageLoader.loadImageFromCache(url, cache: cache, decode: decode, chunkEvents: chunkEvents);
+    yield codec;
+
+    // Load the final remote image
+    if (_useOriginal) {
+      // Load the original image
+      final url = getOriginalUrlForRemoteId(key.assetId);
+      final codec = await ImageLoader.loadImageFromCache(url, cache: cache, decode: decode, chunkEvents: chunkEvents);
+      yield codec;
+    }
+    await chunkEvents.close();
+  }
+
+  @override
+  bool operator ==(Object other) {
+    if (identical(this, other)) return true;
+    if (other is ImmichRemoteImageProvider) {
+      return assetId == other.assetId;
+    }
+
+    return false;
+  }
+
+  @override
+  int get hashCode => assetId.hashCode;
+}

mobile/lib/providers/image/immich_remote_thumbnail_provider.dart

@@ -0,0 +1,61 @@
+import 'dart:async';
+import 'dart:ui' as ui;
+
+import 'package:cached_network_image/cached_network_image.dart';
+import 'package:flutter_cache_manager/flutter_cache_manager.dart';
+import 'package:immich_mobile/providers/image/cache/image_loader.dart';
+import 'package:immich_mobile/providers/image/cache/thumbnail_image_cache_manager.dart';
+import 'package:openapi/api.dart' as api;
+
+import 'package:flutter/foundation.dart';
+import 'package:flutter/painting.dart';
+import 'package:immich_mobile/entities/asset.entity.dart';
+import 'package:immich_mobile/utils/image_url_builder.dart';
+
+/// The remote image provider
+class ImmichRemoteThumbnailProvider extends ImageProvider<ImmichRemoteThumbnailProvider> {
+  /// The [Asset.remoteId] of the asset to fetch
+  final String assetId;
+
+  final int? height;
+  final int? width;
+
+  /// The image cache manager
+  final CacheManager? cacheManager;
+
+  const ImmichRemoteThumbnailProvider({required this.assetId, this.height, this.width, this.cacheManager});
+
+  /// Converts an [ImageProvider]'s settings plus an [ImageConfiguration] to a key
+  /// that describes the precise image to load.
+  @override
+  Future<ImmichRemoteThumbnailProvider> obtainKey(ImageConfiguration configuration) {
+    return SynchronousFuture(this);
+  }
+
+  @override
+  ImageStreamCompleter loadImage(ImmichRemoteThumbnailProvider key, ImageDecoderCallback decode) {
+    final cache = cacheManager ?? ThumbnailImageCacheManager();
+    return MultiImageStreamCompleter(codec: _codec(key, cache, decode), scale: 1.0);
+  }
+
+  // Streams in each stage of the image as we ask for it
+  Stream<ui.Codec> _codec(ImmichRemoteThumbnailProvider key, CacheManager cache, ImageDecoderCallback decode) async* {
+    // Load a preview to the chunk events
+    final preview = getThumbnailUrlForRemoteId(key.assetId, type: api.AssetMediaSize.thumbnail);
+
+    yield await ImageLoader.loadImageFromCache(preview, cache: cache, decode: decode);
+  }
+
+  @override
+  bool operator ==(Object other) {
+    if (identical(this, other)) return true;
+    if (other is ImmichRemoteThumbnailProvider) {
+      return assetId == other.assetId;
+    }
+
+    return false;
+  }
+
+  @override
+  int get hashCode => assetId.hashCode;
+}

mobile/lib/providers/immich_logo_provider.dart

@@ -0,0 +1,14 @@
+import 'dart:convert';
+
+import 'package:flutter/services.dart';
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+import 'package:riverpod_annotation/riverpod_annotation.dart';
+
+part 'immich_logo_provider.g.dart';
+
+@riverpod
+Future<Uint8List> immichLogo(Ref _) async {
+  final json = await rootBundle.loadString('assets/immich-logo.json');
+  final j = jsonDecode(json);
+  return base64Decode(j['content']);
+}

mobile/lib/providers/immich_logo_provider.g.dart

@@ -0,0 +1,27 @@
+// GENERATED CODE - DO NOT MODIFY BY HAND
+
+part of 'immich_logo_provider.dart';
+
+// **************************************************************************
+// RiverpodGenerator
+// **************************************************************************
+
+String _$immichLogoHash() => r'6de7fcca1ef9acef6ab7398eb0c664080747e0ea';
+
+/// See also [immichLogo].
+@ProviderFor(immichLogo)
+final immichLogoProvider = AutoDisposeFutureProvider<Uint8List>.internal(
+  immichLogo,
+  name: r'immichLogoProvider',
+  debugGetCreateSourceHash: const bool.fromEnvironment('dart.vm.product')
+      ? null
+      : _$immichLogoHash,
+  dependencies: null,
+  allTransitiveDependencies: null,
+);
+
+@Deprecated('Will be removed in 3.0. Use Ref instead')
+// ignore: unused_element
+typedef ImmichLogoRef = AutoDisposeFutureProviderRef<Uint8List>;
+// ignore_for_file: type=lint
+// ignore_for_file: subtype_of_sealed_class, invalid_use_of_internal_member, invalid_use_of_visible_for_testing_member, deprecated_member_use_from_same_package

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

@@ -0,0 +1,481 @@
+import 'dart:async';
+
+import 'package:auto_route/auto_route.dart';
+import 'package:background_downloader/background_downloader.dart';
+import 'package:cancellation_token_http/http.dart';
+import 'package:flutter/material.dart';
+import 'package:immich_mobile/constants/enums.dart';
+import 'package:immich_mobile/domain/models/asset/base_asset.model.dart';
+import 'package:immich_mobile/domain/services/asset.service.dart';
+import 'package:immich_mobile/models/download/livephotos_medatada.model.dart';
+import 'package:immich_mobile/presentation/widgets/asset_viewer/asset_viewer.state.dart';
+import 'package:immich_mobile/providers/infrastructure/asset.provider.dart';
+import 'package:immich_mobile/providers/infrastructure/asset_viewer/current_asset.provider.dart';
+import 'package:immich_mobile/providers/timeline/multiselect.provider.dart';
+import 'package:immich_mobile/providers/user.provider.dart';
+import 'package:immich_mobile/routing/router.dart';
+import 'package:immich_mobile/providers/backup/asset_upload_progress.provider.dart';
+import 'package:immich_mobile/services/action.service.dart';
+import 'package:immich_mobile/services/download.service.dart';
+import 'package:immich_mobile/services/timeline.service.dart';
+import 'package:immich_mobile/services/foreground_upload.service.dart';
+import 'package:immich_mobile/widgets/asset_grid/delete_dialog.dart';
+import 'package:logging/logging.dart';
+import 'package:riverpod_annotation/riverpod_annotation.dart';
+
+final actionProvider = NotifierProvider<ActionNotifier, void>(
+  ActionNotifier.new,
+  dependencies: [multiSelectProvider, timelineServiceProvider],
+);
+
+class ActionResult {
+  final int count;
+  final bool success;
+  final String? error;
+
+  const ActionResult({required this.count, required this.success, this.error});
+
+  @override
+  String toString() => 'ActionResult(count: $count, success: $success, error: $error)';
+}
+
+class ActionNotifier extends Notifier<void> {
+  final Logger _logger = Logger('ActionNotifier');
+  late ActionService _service;
+  late ForegroundUploadService _foregroundUploadService;
+  late DownloadService _downloadService;
+  late AssetService _assetService;
+
+  ActionNotifier() : super();
+
+  @override
+  void build() {
+    _foregroundUploadService = ref.watch(foregroundUploadServiceProvider);
+    _service = ref.watch(actionServiceProvider);
+    _assetService = ref.watch(assetServiceProvider);
+    _downloadService = ref.watch(downloadServiceProvider);
+    _downloadService.onImageDownloadStatus = _downloadImageCallback;
+    _downloadService.onVideoDownloadStatus = _downloadVideoCallback;
+    _downloadService.onLivePhotoDownloadStatus = _downloadLivePhotoCallback;
+  }
+
+  void _downloadImageCallback(TaskStatusUpdate update) {
+    if (update.status == TaskStatus.complete) {
+      _downloadService.saveImageWithPath(update.task);
+    }
+  }
+
+  void _downloadVideoCallback(TaskStatusUpdate update) {
+    if (update.status == TaskStatus.complete) {
+      _downloadService.saveVideo(update.task);
+    }
+  }
+
+  void _downloadLivePhotoCallback(TaskStatusUpdate update) async {
+    if (update.status == TaskStatus.complete) {
+      final livePhotosId = LivePhotosMetadata.fromJson(update.task.metaData).id;
+      unawaited(_downloadService.saveLivePhotos(update.task, livePhotosId));
+    }
+  }
+
+  List<String> _getRemoteIdsForSource(ActionSource source) {
+    return _getAssets(source).whereType<RemoteAsset>().toIds().toList(growable: false);
+  }
+
+  List<String> _getLocalIdsForSource(ActionSource source, {bool ignoreLocalOnly = false}) {
+    final Set<BaseAsset> assets = _getAssets(source);
+    final List<String> localIds = [];
+
+    for (final asset in assets) {
+      if (ignoreLocalOnly && asset.storage != AssetState.merged) {
+        continue;
+      }
+      if (asset is LocalAsset) {
+        localIds.add(asset.id);
+      } else if (asset is RemoteAsset && asset.localId != null) {
+        localIds.add(asset.localId!);
+      }
+    }
+
+    return localIds;
+  }
+
+  List<String> _getOwnedRemoteIdsForSource(ActionSource source) {
+    final ownerId = ref.read(currentUserProvider)?.id;
+    return _getAssets(source).whereType<RemoteAsset>().ownedAssets(ownerId).toIds().toList(growable: false);
+  }
+
+  List<RemoteAsset> _getOwnedRemoteAssetsForSource(ActionSource source) {
+    final ownerId = ref.read(currentUserProvider)?.id;
+    return _getIdsForSource<RemoteAsset>(source).ownedAssets(ownerId).toList();
+  }
+
+  Iterable<T> _getIdsForSource<T extends BaseAsset>(ActionSource source) {
+    final Set<BaseAsset> assets = _getAssets(source);
+    return switch (T) {
+          const (RemoteAsset) => assets.whereType<RemoteAsset>(),
+          const (LocalAsset) => assets.whereType<LocalAsset>(),
+          _ => const [],
+        }
+        as Iterable<T>;
+  }
+
+  Set<BaseAsset> _getAssets(ActionSource source) {
+    return switch (source) {
+      ActionSource.timeline => ref.read(multiSelectProvider).selectedAssets,
+      ActionSource.viewer => switch (ref.read(currentAssetNotifier)) {
+        BaseAsset asset => {asset},
+        null => const {},
+      },
+    };
+  }
+
+  Future<ActionResult> troubleshoot(ActionSource source, BuildContext context) async {
+    final assets = _getAssets(source);
+    if (assets.length > 1) {
+      return ActionResult(count: assets.length, success: false, error: 'Cannot troubleshoot multiple assets');
+    }
+    unawaited(context.pushRoute(AssetTroubleshootRoute(asset: assets.first)));
+
+    return ActionResult(count: assets.length, success: true);
+  }
+
+  Future<ActionResult> shareLink(ActionSource source, BuildContext context) async {
+    final ids = _getRemoteIdsForSource(source);
+    try {
+      await _service.shareLink(ids, context);
+      return ActionResult(count: ids.length, success: true);
+    } catch (error, stack) {
+      _logger.severe('Failed to create shared link for assets', error, stack);
+      return ActionResult(count: ids.length, success: false, error: error.toString());
+    }
+  }
+
+  Future<ActionResult> favorite(ActionSource source) async {
+    final ids = _getOwnedRemoteIdsForSource(source);
+    try {
+      await _service.favorite(ids);
+      return ActionResult(count: ids.length, success: true);
+    } catch (error, stack) {
+      _logger.severe('Failed to favorite assets', error, stack);
+      return ActionResult(count: ids.length, success: false, error: error.toString());
+    }
+  }
+
+  Future<ActionResult> unFavorite(ActionSource source) async {
+    final ids = _getOwnedRemoteIdsForSource(source);
+    try {
+      await _service.unFavorite(ids);
+      return ActionResult(count: ids.length, success: true);
+    } catch (error, stack) {
+      _logger.severe('Failed to unfavorite assets', error, stack);
+      return ActionResult(count: ids.length, success: false, error: error.toString());
+    }
+  }
+
+  Future<ActionResult> archive(ActionSource source) async {
+    final ids = _getOwnedRemoteIdsForSource(source);
+    try {
+      await _service.archive(ids);
+      return ActionResult(count: ids.length, success: true);
+    } catch (error, stack) {
+      _logger.severe('Failed to archive assets', error, stack);
+      return ActionResult(count: ids.length, success: false, error: error.toString());
+    }
+  }
+
+  Future<ActionResult> unArchive(ActionSource source) async {
+    final ids = _getOwnedRemoteIdsForSource(source);
+    try {
+      await _service.unArchive(ids);
+      return ActionResult(count: ids.length, success: true);
+    } catch (error, stack) {
+      _logger.severe('Failed to unarchive assets', error, stack);
+      return ActionResult(count: ids.length, success: false, error: error.toString());
+    }
+  }
+
+  Future<ActionResult> moveToLockFolder(ActionSource source) async {
+    final ids = _getOwnedRemoteIdsForSource(source);
+    final localIds = _getLocalIdsForSource(source, ignoreLocalOnly: true);
+    try {
+      await _service.moveToLockFolder(ids, localIds);
+      return ActionResult(count: ids.length, success: true);
+    } catch (error, stack) {
+      _logger.severe('Failed to move assets to lock folder', error, stack);
+      return ActionResult(count: ids.length, success: false, error: error.toString());
+    }
+  }
+
+  Future<ActionResult> removeFromLockFolder(ActionSource source) async {
+    final ids = _getOwnedRemoteIdsForSource(source);
+    try {
+      await _service.removeFromLockFolder(ids);
+      return ActionResult(count: ids.length, success: true);
+    } catch (error, stack) {
+      _logger.severe('Failed to remove assets from lock folder', error, stack);
+      return ActionResult(count: ids.length, success: false, error: error.toString());
+    }
+  }
+
+  Future<ActionResult> trash(ActionSource source) async {
+    final ids = _getOwnedRemoteIdsForSource(source);
+
+    try {
+      await _service.trash(ids);
+      return ActionResult(count: ids.length, success: true);
+    } catch (error, stack) {
+      _logger.severe('Failed to trash assets', error, stack);
+      return ActionResult(count: ids.length, success: false, error: error.toString());
+    }
+  }
+
+  Future<ActionResult> restoreTrash(ActionSource source) async {
+    final ids = _getOwnedRemoteIdsForSource(source);
+    try {
+      await _service.restoreTrash(ids);
+      return ActionResult(count: ids.length, success: true);
+    } catch (error, stack) {
+      _logger.severe('Failed to restore trash assets', error, stack);
+      return ActionResult(count: ids.length, success: false, error: error.toString());
+    }
+  }
+
+  Future<ActionResult> trashRemoteAndDeleteLocal(ActionSource source) async {
+    final ids = _getOwnedRemoteIdsForSource(source);
+    final localIds = _getLocalIdsForSource(source);
+    try {
+      await _service.trashRemoteAndDeleteLocal(ids, localIds);
+      return ActionResult(count: ids.length, success: true);
+    } catch (error, stack) {
+      _logger.severe('Failed to delete assets', error, stack);
+      return ActionResult(count: ids.length, success: false, error: error.toString());
+    }
+  }
+
+  Future<ActionResult> deleteRemoteAndLocal(ActionSource source) async {
+    final ids = _getOwnedRemoteIdsForSource(source);
+    final localIds = _getLocalIdsForSource(source);
+    try {
+      await _service.deleteRemoteAndLocal(ids, localIds);
+      return ActionResult(count: ids.length, success: true);
+    } catch (error, stack) {
+      _logger.severe('Failed to delete assets', error, stack);
+      return ActionResult(count: ids.length, success: false, error: error.toString());
+    }
+  }
+
+  Future<ActionResult?> deleteLocal(ActionSource source, BuildContext context) async {
+    final assets = _getAssets(source);
+    bool? backedUpOnly = assets.every((asset) => asset.storage == AssetState.merged)
+        ? true
+        : await showDialog<bool>(
+            context: context,
+            builder: (BuildContext context) => DeleteLocalOnlyDialog(onDeleteLocal: (_) {}),
+          );
+
+    if (backedUpOnly == null) {
+      // User cancelled the dialog
+      return null;
+    }
+
+    final List<String> ids;
+    if (backedUpOnly) {
+      ids = assets.where((asset) => asset.storage == AssetState.merged).map((asset) => asset.localId!).toList();
+    } else {
+      ids = _getLocalIdsForSource(source);
+    }
+
+    try {
+      final deletedCount = await _service.deleteLocal(ids);
+      return ActionResult(count: deletedCount, success: true);
+    } catch (error, stack) {
+      _logger.severe('Failed to delete assets', error, stack);
+      return ActionResult(count: ids.length, success: false, error: error.toString());
+    }
+  }
+
+  Future<ActionResult?> editLocation(ActionSource source, BuildContext context) async {
+    final ids = _getOwnedRemoteIdsForSource(source);
+    try {
+      final isEdited = await _service.editLocation(ids, context);
+      if (!isEdited) {
+        return null;
+      }
+
+      // This must be called since editing location
+      // does not update the currentAsset which means
+      // the exif provider will not be refreshed automatically
+      if (source == ActionSource.viewer) {
+        ref.invalidate(currentAssetExifProvider);
+      }
+
+      return ActionResult(count: ids.length, success: true);
+    } catch (error, stack) {
+      _logger.severe('Failed to edit location for assets', error, stack);
+      return ActionResult(count: ids.length, success: false, error: error.toString());
+    }
+  }
+
+  Future<ActionResult?> editDateTime(ActionSource source, BuildContext context) async {
+    final ids = _getOwnedRemoteIdsForSource(source);
+    try {
+      final isEdited = await _service.editDateTime(ids, context);
+      if (!isEdited) {
+        return null;
+      }
+
+      return ActionResult(count: ids.length, success: true);
+    } catch (error, stack) {
+      _logger.severe('Failed to edit date and time for assets', error, stack);
+      return ActionResult(count: ids.length, success: false, error: error.toString());
+    }
+  }
+
+  Future<ActionResult> removeFromAlbum(ActionSource source, String albumId) async {
+    final ids = _getRemoteIdsForSource(source);
+    try {
+      final removedCount = await _service.removeFromAlbum(ids, albumId);
+      return ActionResult(count: removedCount, success: true);
+    } catch (error, stack) {
+      _logger.severe('Failed to remove assets from album', error, stack);
+      return ActionResult(count: ids.length, success: false, error: error.toString());
+    }
+  }
+
+  Future<ActionResult> updateDescription(ActionSource source, String description) async {
+    final ids = _getRemoteIdsForSource(source);
+    if (ids.length != 1) {
+      _logger.warning('updateDescription called with multiple assets, expected single asset');
+      return ActionResult(count: ids.length, success: false, error: 'Expected single asset for description update');
+    }
+
+    try {
+      final isUpdated = await _service.updateDescription(ids.first, description);
+      return ActionResult(count: 1, success: isUpdated);
+    } catch (error, stack) {
+      _logger.severe('Failed to update description for asset', error, stack);
+      return ActionResult(count: 1, success: false, error: error.toString());
+    }
+  }
+
+  Future<ActionResult> updateRating(ActionSource source, int rating) async {
+    final ids = _getRemoteIdsForSource(source);
+    if (ids.length != 1) {
+      _logger.warning('updateRating called with multiple assets, expected single asset');
+      return ActionResult(count: ids.length, success: false, error: 'Expected single asset for rating update');
+    }
+
+    try {
+      final isUpdated = await _service.updateRating(ids.first, rating);
+      return ActionResult(count: 1, success: isUpdated);
+    } catch (error, stack) {
+      _logger.severe('Failed to update rating for asset', error, stack);
+      return ActionResult(count: 1, success: false, error: error.toString());
+    }
+  }
+
+  Future<ActionResult> stack(String userId, ActionSource source) async {
+    final ids = _getOwnedRemoteIdsForSource(source);
+    try {
+      await _service.stack(userId, ids);
+      return ActionResult(count: ids.length, success: true);
+    } catch (error, stack) {
+      _logger.severe('Failed to stack assets', error, stack);
+      return ActionResult(count: ids.length, success: false, error: error.toString());
+    }
+  }
+
+  Future<ActionResult> unStack(ActionSource source) async {
+    final assets = _getOwnedRemoteAssetsForSource(source);
+    try {
+      await _service.unStack(assets.map((e) => e.stackId).nonNulls.toList());
+      if (source == ActionSource.viewer) {
+        final updatedParent = await _assetService.getRemoteAsset(assets.first.id);
+        if (updatedParent != null) {
+          ref.read(currentAssetNotifier.notifier).setAsset(updatedParent);
+          ref.read(assetViewerProvider.notifier).setAsset(updatedParent);
+        }
+      }
+
+      return ActionResult(count: assets.length, success: true);
+    } catch (error, stack) {
+      _logger.severe('Failed to unstack assets', error, stack);
+      return ActionResult(count: assets.length, success: false);
+    }
+  }
+
+  Future<ActionResult> shareAssets(ActionSource source, BuildContext context) async {
+    final ids = _getAssets(source).toList(growable: false);
+
+    try {
+      await _service.shareAssets(ids, context);
+      return ActionResult(count: ids.length, success: true);
+    } catch (error, stack) {
+      _logger.severe('Failed to share assets', error, stack);
+      return ActionResult(count: ids.length, success: false, error: error.toString());
+    }
+  }
+
+  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;
+      return ActionResult(count: enqueueCount, success: true);
+    } catch (error, stack) {
+      _logger.severe('Failed to download assets', error, stack);
+      return ActionResult(count: assets.length, success: false, error: error.toString());
+    }
+  }
+
+  Future<ActionResult> upload(ActionSource source, {List<LocalAsset>? assets}) async {
+    final assetsToUpload = assets ?? _getAssets(source).whereType<LocalAsset>().toList();
+
+    final progressNotifier = ref.read(assetUploadProgressProvider.notifier);
+    final cancelToken = CancellationToken();
+    ref.read(manualUploadCancelTokenProvider.notifier).state = cancelToken;
+
+    // Initialize progress for all assets
+    for (final asset in assetsToUpload) {
+      progressNotifier.setProgress(asset.id, 0.0);
+    }
+
+    try {
+      await _foregroundUploadService.uploadManual(
+        assetsToUpload,
+        cancelToken,
+        callbacks: UploadCallbacks(
+          onProgress: (localAssetId, filename, bytes, totalBytes) {
+            final progress = totalBytes > 0 ? bytes / totalBytes : 0.0;
+            progressNotifier.setProgress(localAssetId, progress);
+          },
+          onSuccess: (localAssetId, remoteAssetId) {
+            progressNotifier.remove(localAssetId);
+          },
+          onError: (localAssetId, errorMessage) {
+            progressNotifier.setError(localAssetId);
+          },
+        ),
+      );
+      return ActionResult(count: assetsToUpload.length, success: true);
+    } catch (error, stack) {
+      _logger.severe('Failed manually upload assets', error, stack);
+      return ActionResult(count: assetsToUpload.length, success: false, error: error.toString());
+    } finally {
+      ref.read(manualUploadCancelTokenProvider.notifier).state = null;
+      Future.delayed(const Duration(seconds: 2), () {
+        progressNotifier.clear();
+      });
+    }
+  }
+}
+
+extension on Iterable<RemoteAsset> {
+  Iterable<String> toIds() => map((e) => e.id);
+
+  Iterable<RemoteAsset> ownedAssets(String? ownerId) {
+    if (ownerId == null) return const [];
+    return whereType<RemoteAsset>().where((a) => a.ownerId == ownerId);
+  }
+}

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

@@ -0,0 +1,47 @@
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+import 'package:immich_mobile/domain/models/album/album.model.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/domain/services/local_album.service.dart';
+import 'package:immich_mobile/domain/services/remote_album.service.dart';
+import 'package:immich_mobile/infrastructure/repositories/local_album.repository.dart';
+import 'package:immich_mobile/infrastructure/repositories/remote_album.repository.dart';
+import 'package:immich_mobile/providers/infrastructure/db.provider.dart';
+import 'package:immich_mobile/providers/infrastructure/remote_album.provider.dart';
+import 'package:immich_mobile/repositories/drift_album_api_repository.dart';
+
+final localAlbumRepository = Provider<DriftLocalAlbumRepository>(
+  (ref) => DriftLocalAlbumRepository(ref.watch(driftProvider)),
+);
+
+final localAlbumServiceProvider = Provider<LocalAlbumService>(
+  (ref) => LocalAlbumService(ref.watch(localAlbumRepository)),
+);
+
+final localAlbumProvider = FutureProvider<List<LocalAlbum>>(
+  (ref) => LocalAlbumService(ref.watch(localAlbumRepository))
+      .getAll(sortBy: {SortLocalAlbumsBy.newestAsset})
+      .then((albums) => albums.where((album) => album.assetCount > 0).toList()),
+);
+
+final localAlbumThumbnailProvider = FutureProvider.family<LocalAsset?, String>(
+  (ref, albumId) => LocalAlbumService(ref.watch(localAlbumRepository)).getThumbnail(albumId),
+);
+
+final remoteAlbumRepository = Provider<DriftRemoteAlbumRepository>(
+  (ref) => DriftRemoteAlbumRepository(ref.watch(driftProvider)),
+);
+
+final remoteAlbumServiceProvider = Provider<RemoteAlbumService>(
+  (ref) => RemoteAlbumService(ref.watch(remoteAlbumRepository), ref.watch(driftAlbumApiRepositoryProvider)),
+  dependencies: [remoteAlbumRepository],
+);
+
+final remoteAlbumProvider = NotifierProvider<RemoteAlbumNotifier, RemoteAlbumState>(
+  RemoteAlbumNotifier.new,
+  dependencies: [remoteAlbumServiceProvider],
+);
+
+final albumsContainingAssetProvider = FutureProvider.family<List<RemoteAlbum>, String>(
+  (ref, assetId) => ref.watch(remoteAlbumServiceProvider).getAlbumsContainingAsset(assetId),
+);

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

@@ -0,0 +1,37 @@
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+import 'package:immich_mobile/domain/services/asset.service.dart';
+import 'package:immich_mobile/infrastructure/repositories/local_asset.repository.dart';
+import 'package:immich_mobile/infrastructure/repositories/remote_asset.repository.dart';
+import 'package:immich_mobile/infrastructure/repositories/trashed_local_asset.repository.dart';
+import 'package:immich_mobile/providers/infrastructure/db.provider.dart';
+import 'package:immich_mobile/providers/user.provider.dart';
+
+final localAssetRepository = Provider<DriftLocalAssetRepository>(
+  (ref) => DriftLocalAssetRepository(ref.watch(driftProvider)),
+);
+
+final remoteAssetRepositoryProvider = Provider<RemoteAssetRepository>(
+  (ref) => RemoteAssetRepository(ref.watch(driftProvider)),
+);
+
+final trashedLocalAssetRepository = Provider<DriftTrashedLocalAssetRepository>(
+  (ref) => DriftTrashedLocalAssetRepository(ref.watch(driftProvider)),
+);
+
+final assetServiceProvider = Provider(
+  (ref) => AssetService(
+    remoteAssetRepository: ref.watch(remoteAssetRepositoryProvider),
+    localAssetRepository: ref.watch(localAssetRepository),
+  ),
+);
+
+final placesProvider = FutureProvider<List<(String, String)>>((ref) {
+  final assetService = ref.watch(assetServiceProvider);
+  final auth = ref.watch(currentUserProvider);
+
+  if (auth == null) {
+    return Future.value(const []);
+  }
+
+  return assetService.getPlaces(auth.id);
+});

mobile/lib/providers/infrastructure/asset_viewer/current_asset.provider.dart

@@ -0,0 +1,40 @@
+import 'dart:async';
+
+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';
+
+final currentAssetNotifier = AutoDisposeNotifierProvider<CurrentAssetNotifier, BaseAsset?>(CurrentAssetNotifier.new);
+
+class CurrentAssetNotifier extends AutoDisposeNotifier<BaseAsset?> {
+  KeepAliveLink? _keepAliveLink;
+  StreamSubscription<BaseAsset?>? _assetSubscription;
+
+  @override
+  BaseAsset? build() => null;
+
+  void setAsset(BaseAsset asset) {
+    _keepAliveLink?.close();
+    _assetSubscription?.cancel();
+    state = asset;
+    _assetSubscription = ref.watch(assetServiceProvider).watchAsset(asset).listen((updatedAsset) {
+      if (updatedAsset != null) {
+        state = updatedAsset;
+      }
+    });
+    _keepAliveLink = ref.keepAlive();
+  }
+
+  void dispose() {
+    _keepAliveLink?.close();
+    _assetSubscription?.cancel();
+  }
+}
+
+final currentAssetExifProvider = FutureProvider.autoDispose((ref) {
+  final currentAsset = ref.watch(currentAssetNotifier);
+  if (currentAsset == null) {
+    return null;
+  }
+  return ref.watch(assetServiceProvider).getExif(currentAsset);
+});

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

@@ -0,0 +1,12 @@
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+
+/// Provider holding a boolean function that returns true when cancellation is requested.
+/// A computation running in the isolate uses the function to implement cooperative cancellation.
+final cancellationProvider = Provider<bool Function()>(
+  // This will be overridden in the isolate's container.
+  // Throwing ensures it's not used without an override.
+  (ref) => throw UnimplementedError(
+    "cancellationProvider must be overridden in the isolate's ProviderContainer and not to be used in the root isolate",
+  ),
+  name: 'cancellationProvider',
+);

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

@@ -0,0 +1,30 @@
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+import 'package:immich_mobile/domain/models/album/album.model.dart';
+import 'package:immich_mobile/providers/infrastructure/album.provider.dart';
+
+final currentRemoteAlbumScopedProvider = Provider<RemoteAlbum?>((ref) => null);
+final currentRemoteAlbumProvider = NotifierProvider<CurrentAlbumNotifier, RemoteAlbum?>(
+  CurrentAlbumNotifier.new,
+  dependencies: [currentRemoteAlbumScopedProvider, remoteAlbumServiceProvider],
+);
+
+class CurrentAlbumNotifier extends Notifier<RemoteAlbum?> {
+  @override
+  RemoteAlbum? build() {
+    final album = ref.watch(currentRemoteAlbumScopedProvider);
+
+    if (album == null) {
+      return null;
+    }
+
+    final watcher = ref.watch(remoteAlbumServiceProvider).watchAlbum(album.id).listen((updatedAlbum) {
+      if (updatedAlbum != null) {
+        state = updatedAlbum;
+      }
+    });
+
+    ref.onDispose(watcher.cancel);
+
+    return album;
+  }
+}

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

@@ -0,0 +1,21 @@
+import 'dart:async';
+
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+import 'package:immich_mobile/infrastructure/repositories/db.repository.dart';
+import 'package:isar/isar.dart';
+import 'package:riverpod_annotation/riverpod_annotation.dart';
+
+part 'db.provider.g.dart';
+
+@Riverpod(keepAlive: true)
+Isar isar(Ref ref) => throw UnimplementedError('isar');
+
+Drift Function(Ref ref) driftOverride(Drift drift) => (ref) {
+  ref.onDispose(() => unawaited(drift.close()));
+  ref.keepAlive();
+  return drift;
+};
+
+final driftProvider = Provider<Drift>(
+  (ref) => throw UnimplementedError("driftProvider must be overridden in the isolate's ProviderContainer before use"),
+);

mobile/lib/providers/infrastructure/db.provider.g.dart

@@ -0,0 +1,27 @@
+// GENERATED CODE - DO NOT MODIFY BY HAND
+
+part of 'db.provider.dart';
+
+// **************************************************************************
+// RiverpodGenerator
+// **************************************************************************
+
+String _$isarHash() => r'69d3a06aa7e69a4381478e03f7956eb07d7f7feb';
+
+/// See also [isar].
+@ProviderFor(isar)
+final isarProvider = Provider<Isar>.internal(
+  isar,
+  name: r'isarProvider',
+  debugGetCreateSourceHash: const bool.fromEnvironment('dart.vm.product')
+      ? null
+      : _$isarHash,
+  dependencies: null,
+  allTransitiveDependencies: null,
+);
+
+@Deprecated('Will be removed in 3.0. Use Ref instead')
+// ignore: unused_element
+typedef IsarRef = ProviderRef<Isar>;
+// ignore_for_file: type=lint
+// ignore_for_file: subtype_of_sealed_class, invalid_use_of_internal_member, invalid_use_of_visible_for_testing_member, deprecated_member_use_from_same_package

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

@@ -0,0 +1,7 @@
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+import 'package:immich_mobile/infrastructure/repositories/device_asset.repository.dart';
+import 'package:immich_mobile/providers/infrastructure/db.provider.dart';
+
+final deviceAssetRepositoryProvider = Provider<IsarDeviceAssetRepository>(
+  (ref) => IsarDeviceAssetRepository(ref.watch(isarProvider)),
+);

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

@@ -0,0 +1,9 @@
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+import 'package:immich_mobile/infrastructure/repositories/exif.repository.dart';
+import 'package:immich_mobile/providers/infrastructure/db.provider.dart';
+import 'package:riverpod_annotation/riverpod_annotation.dart';
+
+part 'exif.provider.g.dart';
+
+@Riverpod(keepAlive: true)
+IsarExifRepository exifRepository(Ref ref) => IsarExifRepository(ref.watch(isarProvider));

mobile/lib/providers/infrastructure/exif.provider.g.dart

@@ -0,0 +1,27 @@
+// GENERATED CODE - DO NOT MODIFY BY HAND
+
+part of 'exif.provider.dart';
+
+// **************************************************************************
+// RiverpodGenerator
+// **************************************************************************
+
+String _$exifRepositoryHash() => r'bf4a3f6a50d954a23d317659b4f3e2f381066463';
+
+/// See also [exifRepository].
+@ProviderFor(exifRepository)
+final exifRepositoryProvider = Provider<IsarExifRepository>.internal(
+  exifRepository,
+  name: r'exifRepositoryProvider',
+  debugGetCreateSourceHash: const bool.fromEnvironment('dart.vm.product')
+      ? null
+      : _$exifRepositoryHash,
+  dependencies: null,
+  allTransitiveDependencies: null,
+);
+
+@Deprecated('Will be removed in 3.0. Use Ref instead')
+// ignore: unused_element
+typedef ExifRepositoryRef = ProviderRef<IsarExifRepository>;
+// ignore_for_file: type=lint
+// ignore_for_file: subtype_of_sealed_class, invalid_use_of_internal_member, invalid_use_of_visible_for_testing_member, deprecated_member_use_from_same_package

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

@@ -0,0 +1,30 @@
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+import 'package:immich_mobile/domain/services/map.service.dart';
+import 'package:immich_mobile/infrastructure/repositories/map.repository.dart';
+import 'package:immich_mobile/presentation/widgets/map/map.state.dart';
+import 'package:immich_mobile/providers/infrastructure/db.provider.dart';
+import 'package:immich_mobile/providers/infrastructure/timeline.provider.dart';
+import 'package:immich_mobile/providers/user.provider.dart';
+
+final mapRepositoryProvider = Provider<DriftMapRepository>((ref) => DriftMapRepository(ref.watch(driftProvider)));
+
+final mapServiceProvider = Provider<MapService>(
+  (ref) {
+    final user = ref.watch(currentUserProvider);
+    if (user == null) {
+      throw Exception('User must be logged in to access map');
+    }
+
+    final users = ref.watch(mapStateProvider).withPartners
+        ? ref.watch(timelineUsersProvider).valueOrNull ?? [user.id]
+        : [user.id];
+
+    final mapService = ref.watch(mapFactoryProvider).remote(users, ref.watch(mapStateProvider).toOptions());
+    return mapService;
+  },
+  // Empty dependencies to inform the framework that this provider
+  // might be used in a ProviderScope
+  dependencies: const [],
+);
+
+final mapFactoryProvider = Provider<MapFactory>((ref) => MapFactory(mapRepository: ref.watch(mapRepositoryProvider)));

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

@@ -0,0 +1,25 @@
+import 'package:immich_mobile/domain/models/memory.model.dart';
+import 'package:immich_mobile/domain/services/memory.service.dart';
+import 'package:immich_mobile/infrastructure/repositories/memory.repository.dart';
+import 'package:immich_mobile/providers/user.provider.dart';
+import 'package:riverpod_annotation/riverpod_annotation.dart';
+
+import 'db.provider.dart';
+
+final driftMemoryRepositoryProvider = Provider<DriftMemoryRepository>(
+  (ref) => DriftMemoryRepository(ref.watch(driftProvider)),
+);
+
+final driftMemoryServiceProvider = Provider<DriftMemoryService>(
+  (ref) => DriftMemoryService(ref.watch(driftMemoryRepositoryProvider)),
+);
+
+final driftMemoryFutureProvider = FutureProvider.autoDispose<List<DriftMemory>>((ref) {
+  final (userId, enabled) = ref.watch(currentUserProvider.select((user) => (user?.id, user?.memoryEnabled ?? true)));
+  if (userId == null || !enabled) {
+    return const [];
+  }
+
+  final service = ref.watch(driftMemoryServiceProvider);
+  return service.getMemoryLane(userId);
+});

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

@@ -0,0 +1,87 @@
+import 'package:immich_mobile/domain/models/user.model.dart';
+import 'package:immich_mobile/domain/services/partner.service.dart';
+import 'package:immich_mobile/providers/infrastructure/user.provider.dart';
+import 'package:immich_mobile/providers/user.provider.dart';
+import 'package:riverpod_annotation/riverpod_annotation.dart';
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+
+class PartnerNotifier extends Notifier<List<PartnerUserDto>> {
+  late DriftPartnerService _driftPartnerService;
+
+  @override
+  List<PartnerUserDto> build() {
+    _driftPartnerService = ref.read(driftPartnerServiceProvider);
+    return [];
+  }
+
+  Future<void> _loadPartners() async {
+    final currentUser = ref.read(currentUserProvider);
+    if (currentUser == null) {
+      return;
+    }
+
+    state = await _driftPartnerService.getSharedWith(currentUser.id);
+  }
+
+  Future<List<PartnerUserDto>> getPartners(String userId) async {
+    final partners = await _driftPartnerService.getSharedWith(userId);
+    state = partners;
+    return partners;
+  }
+
+  Future<void> toggleShowInTimeline(String partnerId, String userId) async {
+    await _driftPartnerService.toggleShowInTimeline(partnerId, userId);
+    await _loadPartners();
+  }
+
+  Future<void> addPartner(PartnerUserDto partner) async {
+    final currentUser = ref.read(currentUserProvider);
+    if (currentUser == null) {
+      return;
+    }
+
+    await _driftPartnerService.addPartner(partner.id, currentUser.id);
+    await _loadPartners();
+    ref.invalidate(driftAvailablePartnerProvider);
+    ref.invalidate(driftSharedByPartnerProvider);
+  }
+
+  Future<void> removePartner(PartnerUserDto partner) async {
+    final currentUser = ref.read(currentUserProvider);
+    if (currentUser == null) {
+      return;
+    }
+
+    await _driftPartnerService.removePartner(partner.id, currentUser.id);
+    await _loadPartners();
+    ref.invalidate(driftAvailablePartnerProvider);
+    ref.invalidate(driftSharedByPartnerProvider);
+  }
+}
+
+final driftAvailablePartnerProvider = FutureProvider.autoDispose<List<PartnerUserDto>>((ref) {
+  final currentUser = ref.watch(currentUserProvider);
+  if (currentUser == null) {
+    return [];
+  }
+
+  return ref.watch(driftPartnerServiceProvider).getAvailablePartners(currentUser.id);
+});
+
+final driftSharedByPartnerProvider = FutureProvider.autoDispose<List<PartnerUserDto>>((ref) {
+  final currentUser = ref.watch(currentUserProvider);
+  if (currentUser == null) {
+    return [];
+  }
+
+  return ref.watch(driftPartnerServiceProvider).getSharedBy(currentUser.id);
+});
+
+final driftSharedWithPartnerProvider = FutureProvider.autoDispose<List<PartnerUserDto>>((ref) {
+  final currentUser = ref.watch(currentUserProvider);
+  if (currentUser == null) {
+    return [];
+  }
+
+  return ref.watch(driftPartnerServiceProvider).getSharedWith(currentUser.id);
+});

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

@@ -0,0 +1,24 @@
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+import 'package:immich_mobile/domain/models/person.model.dart';
+import 'package:immich_mobile/domain/services/people.service.dart';
+import 'package:immich_mobile/infrastructure/repositories/people.repository.dart';
+import 'package:immich_mobile/providers/infrastructure/db.provider.dart';
+import 'package:immich_mobile/repositories/person_api.repository.dart';
+
+final driftPeopleRepositoryProvider = Provider<DriftPeopleRepository>(
+  (ref) => DriftPeopleRepository(ref.watch(driftProvider)),
+);
+
+final driftPeopleServiceProvider = Provider<DriftPeopleService>(
+  (ref) => DriftPeopleService(ref.watch(driftPeopleRepositoryProvider), ref.watch(personApiRepositoryProvider)),
+);
+
+final driftPeopleAssetProvider = FutureProvider.family<List<DriftPerson>, String>((ref, assetId) async {
+  final service = ref.watch(driftPeopleServiceProvider);
+  return service.getAssetPeople(assetId);
+});
+
+final driftGetAllPeopleProvider = FutureProvider<List<DriftPerson>>((ref) async {
+  final service = ref.watch(driftPeopleServiceProvider);
+  return service.getAllPeople();
+});

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

@@ -0,0 +1,22 @@
+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/local_image_api.g.dart';
+import 'package:immich_mobile/platform/remote_image_api.g.dart';
+
+final backgroundWorkerFgServiceProvider = Provider((_) => BackgroundWorkerFgService(BackgroundWorkerFgHostApi()));
+
+final backgroundWorkerLockServiceProvider = Provider<BackgroundWorkerLockService>(
+  (_) => BackgroundWorkerLockService(BackgroundWorkerLockApi()),
+);
+
+final nativeSyncApiProvider = Provider<NativeSyncApi>((_) => NativeSyncApi());
+
+final connectivityApiProvider = Provider<ConnectivityApi>((_) => ConnectivityApi());
+
+final localImageApi = LocalImageApi();
+
+final remoteImageApi = RemoteImageApi();

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

@@ -0,0 +1,36 @@
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+import 'package:immich_mobile/providers/app_settings.provider.dart';
+import 'package:immich_mobile/routing/router.dart';
+import 'package:immich_mobile/services/app_settings.service.dart';
+
+class ReadOnlyModeNotifier extends Notifier<bool> {
+  late AppSettingsService _appSettingService;
+
+  @override
+  bool build() {
+    _appSettingService = ref.read(appSettingsServiceProvider);
+    final readonlyMode = _appSettingService.getSetting(AppSettingsEnum.readonlyModeEnabled);
+    return readonlyMode;
+  }
+
+  void setMode(bool value) {
+    _appSettingService.setSetting(AppSettingsEnum.readonlyModeEnabled, value);
+    state = value;
+
+    if (value) {
+      ref.read(appRouterProvider).navigate(const MainTimelineRoute());
+    }
+  }
+
+  void setReadonlyMode(bool isEnabled) {
+    state = isEnabled;
+    setMode(state);
+  }
+
+  void toggleReadonlyMode() {
+    state = !state;
+    setMode(state);
+  }
+}
+
+final readonlyModeProvider = NotifierProvider<ReadOnlyModeNotifier, bool>(() => ReadOnlyModeNotifier());

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

@@ -0,0 +1,181 @@
+import 'package:collection/collection.dart';
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+import 'package:immich_mobile/domain/models/album/album.model.dart';
+import 'package:immich_mobile/domain/models/asset/base_asset.model.dart';
+import 'package:immich_mobile/domain/models/user.model.dart';
+import 'package:immich_mobile/domain/services/remote_album.service.dart';
+import 'package:immich_mobile/models/albums/album_search.model.dart';
+import 'package:immich_mobile/providers/album/album_sort_by_options.provider.dart';
+import 'package:logging/logging.dart';
+import 'package:riverpod_annotation/riverpod_annotation.dart';
+
+import 'album.provider.dart';
+
+class RemoteAlbumState {
+  final List<RemoteAlbum> albums;
+
+  const RemoteAlbumState({required this.albums});
+
+  RemoteAlbumState copyWith({List<RemoteAlbum>? albums}) {
+    return RemoteAlbumState(albums: albums ?? this.albums);
+  }
+
+  @override
+  String toString() => 'RemoteAlbumState(albums: ${albums.length})';
+
+  @override
+  bool operator ==(covariant RemoteAlbumState other) {
+    if (identical(this, other)) return true;
+    final listEquals = const DeepCollectionEquality().equals;
+
+    return listEquals(other.albums, albums);
+  }
+
+  @override
+  int get hashCode => albums.hashCode;
+}
+
+class RemoteAlbumNotifier extends Notifier<RemoteAlbumState> {
+  late RemoteAlbumService _remoteAlbumService;
+  final _logger = Logger('RemoteAlbumNotifier');
+
+  @override
+  RemoteAlbumState build() {
+    _remoteAlbumService = ref.read(remoteAlbumServiceProvider);
+    return const RemoteAlbumState(albums: []);
+  }
+
+  Future<List<RemoteAlbum>> _getAll() async {
+    try {
+      final albums = await _remoteAlbumService.getAll();
+      state = state.copyWith(albums: albums);
+      return albums;
+    } catch (error, stack) {
+      _logger.severe('Failed to fetch albums', error, stack);
+      rethrow;
+    }
+  }
+
+  Future<void> refresh() async {
+    await _getAll();
+  }
+
+  List<RemoteAlbum> searchAlbums(
+    List<RemoteAlbum> albums,
+    String query,
+    String? userId, [
+    QuickFilterMode filterMode = QuickFilterMode.all,
+  ]) {
+    return _remoteAlbumService.searchAlbums(albums, query, userId, filterMode);
+  }
+
+  Future<List<RemoteAlbum>> sortAlbums(
+    List<RemoteAlbum> albums,
+    AlbumSortMode sortMode, {
+    bool isReverse = false,
+  }) async {
+    return await _remoteAlbumService.sortAlbums(albums, sortMode, isReverse: isReverse);
+  }
+
+  Future<RemoteAlbum?> createAlbum({
+    required String title,
+    String? description,
+    List<String> assetIds = const [],
+  }) async {
+    try {
+      final album = await _remoteAlbumService.createAlbum(title: title, description: description, assetIds: assetIds);
+
+      state = state.copyWith(albums: [...state.albums, album]);
+
+      return album;
+    } catch (error, stack) {
+      _logger.severe('Failed to create album', error, stack);
+      rethrow;
+    }
+  }
+
+  Future<RemoteAlbum?> updateAlbum(
+    String albumId, {
+    String? name,
+    String? description,
+    String? thumbnailAssetId,
+    bool? isActivityEnabled,
+    AlbumAssetOrder? order,
+  }) async {
+    try {
+      final updatedAlbum = await _remoteAlbumService.updateAlbum(
+        albumId,
+        name: name,
+        description: description,
+        thumbnailAssetId: thumbnailAssetId,
+        isActivityEnabled: isActivityEnabled,
+        order: order,
+      );
+
+      final updatedAlbums = state.albums.map((album) {
+        return album.id == albumId ? updatedAlbum : album;
+      }).toList();
+
+      state = state.copyWith(albums: updatedAlbums);
+
+      return updatedAlbum;
+    } catch (error, stack) {
+      _logger.severe('Failed to update album', error, stack);
+      rethrow;
+    }
+  }
+
+  Future<RemoteAlbum?> toggleAlbumOrder(String albumId) async {
+    final currentAlbum = state.albums.firstWhere((album) => album.id == albumId);
+
+    final newOrder = currentAlbum.order == AlbumAssetOrder.asc ? AlbumAssetOrder.desc : AlbumAssetOrder.asc;
+
+    return updateAlbum(albumId, order: newOrder);
+  }
+
+  Future<void> deleteAlbum(String albumId) async {
+    await _remoteAlbumService.deleteAlbum(albumId);
+
+    final updatedAlbums = state.albums.where((album) => album.id != albumId).toList();
+    state = state.copyWith(albums: updatedAlbums);
+  }
+
+  Future<List<RemoteAsset>> getAssets(String albumId) {
+    return _remoteAlbumService.getAssets(albumId);
+  }
+
+  Future<int> addAssets(String albumId, List<String> assetIds) {
+    return _remoteAlbumService.addAssets(albumId: albumId, assetIds: assetIds);
+  }
+
+  Future<void> addUsers(String albumId, List<String> userIds) {
+    return _remoteAlbumService.addUsers(albumId: albumId, userIds: userIds);
+  }
+
+  Future<void> removeUser(String albumId, String userId) {
+    return _remoteAlbumService.removeUser(albumId, userId: userId);
+  }
+
+  Future<void> leaveAlbum(String albumId, {required String userId}) async {
+    await _remoteAlbumService.removeUser(albumId, userId: userId);
+
+    final updatedAlbums = state.albums.where((album) => album.id != albumId).toList();
+    state = state.copyWith(albums: updatedAlbums);
+  }
+
+  Future<void> setActivityStatus(String albumId, bool enabled) {
+    return _remoteAlbumService.setActivityStatus(albumId, enabled);
+  }
+}
+
+final remoteAlbumDateRangeProvider = FutureProvider.family<(DateTime, DateTime), String>((ref, albumId) async {
+  final service = ref.watch(remoteAlbumServiceProvider);
+  return service.getDateRange(albumId);
+});
+
+final remoteAlbumSharedUsersProvider = FutureProvider.autoDispose.family<List<UserDto>, String>((ref, albumId) async {
+  final link = ref.keepAlive();
+  ref.onDispose(() => link.close());
+  final service = ref.watch(remoteAlbumServiceProvider);
+  return service.getSharedUsers(albumId);
+});

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

@@ -0,0 +1,8 @@
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+import 'package:immich_mobile/domain/services/search.service.dart';
+import 'package:immich_mobile/infrastructure/repositories/search_api.repository.dart';
+import 'package:immich_mobile/providers/api.provider.dart';
+
+final searchApiRepositoryProvider = Provider((ref) => SearchApiRepository(ref.watch(apiServiceProvider).searchApi));
+
+final searchServiceProvider = Provider((ref) => SearchService(ref.watch(searchApiRepositoryProvider)));

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

@@ -0,0 +1,20 @@
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+import 'package:immich_mobile/domain/models/setting.model.dart';
+import 'package:immich_mobile/domain/services/setting.service.dart';
+import 'package:immich_mobile/providers/infrastructure/store.provider.dart';
+
+class SettingsNotifier extends Notifier<SettingsService> {
+  @override
+  SettingsService build() => SettingsService(storeService: ref.read(storeServiceProvider));
+
+  T get<T>(Setting<T> setting) => state.get(setting);
+
+  Future<void> set<T>(Setting<T> setting, T value) async {
+    await state.set(setting, value);
+    ref.invalidateSelf();
+  }
+
+  Stream<T> watch<T>(Setting<T> setting) => state.watch(setting);
+}
+
+final settingsProvider = NotifierProvider<SettingsNotifier, SettingsService>(SettingsNotifier.new);

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

@@ -0,0 +1,5 @@
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+import 'package:immich_mobile/infrastructure/repositories/stack.repository.dart';
+import 'package:immich_mobile/providers/infrastructure/db.provider.dart';
+
+final driftStackProvider = Provider<DriftStackRepository>((ref) => DriftStackRepository(ref.watch(driftProvider)));

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

@@ -0,0 +1,4 @@
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+import 'package:immich_mobile/infrastructure/repositories/storage.repository.dart';
+
+final storageRepositoryProvider = Provider<StorageRepository>((ref) => StorageRepository());

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

@@ -0,0 +1,13 @@
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+import 'package:immich_mobile/domain/services/store.service.dart';
+import 'package:immich_mobile/infrastructure/repositories/store.repository.dart';
+import 'package:immich_mobile/providers/infrastructure/db.provider.dart';
+import 'package:riverpod_annotation/riverpod_annotation.dart';
+
+part 'store.provider.g.dart';
+
+@Riverpod(keepAlive: true)
+IsarStoreRepository storeRepository(Ref ref) => IsarStoreRepository(ref.watch(isarProvider));
+
+@Riverpod(keepAlive: true)
+StoreService storeService(Ref _) => StoreService.I;

mobile/lib/providers/infrastructure/store.provider.g.dart

@@ -0,0 +1,44 @@
+// GENERATED CODE - DO NOT MODIFY BY HAND
+
+part of 'store.provider.dart';
+
+// **************************************************************************
+// RiverpodGenerator
+// **************************************************************************
+
+String _$storeRepositoryHash() => r'659cb134466e4b0d5f04e2fc93e426350d99545f';
+
+/// See also [storeRepository].
+@ProviderFor(storeRepository)
+final storeRepositoryProvider = Provider<IsarStoreRepository>.internal(
+  storeRepository,
+  name: r'storeRepositoryProvider',
+  debugGetCreateSourceHash: const bool.fromEnvironment('dart.vm.product')
+      ? null
+      : _$storeRepositoryHash,
+  dependencies: null,
+  allTransitiveDependencies: null,
+);
+
+@Deprecated('Will be removed in 3.0. Use Ref instead')
+// ignore: unused_element
+typedef StoreRepositoryRef = ProviderRef<IsarStoreRepository>;
+String _$storeServiceHash() => r'250e10497c42df360e9e1f9a618d0b19c1b5b0a0';
+
+/// See also [storeService].
+@ProviderFor(storeService)
+final storeServiceProvider = Provider<StoreService>.internal(
+  storeService,
+  name: r'storeServiceProvider',
+  debugGetCreateSourceHash: const bool.fromEnvironment('dart.vm.product')
+      ? null
+      : _$storeServiceHash,
+  dependencies: null,
+  allTransitiveDependencies: null,
+);
+
+@Deprecated('Will be removed in 3.0. Use Ref instead')
+// ignore: unused_element
+typedef StoreServiceRef = ProviderRef<StoreService>;
+// ignore_for_file: type=lint
+// ignore_for_file: subtype_of_sealed_class, invalid_use_of_internal_member, invalid_use_of_visible_for_testing_member, deprecated_member_use_from_same_package

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

@@ -0,0 +1,55 @@
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+import 'package:immich_mobile/domain/services/hash.service.dart';
+import 'package:immich_mobile/domain/services/local_sync.service.dart';
+import 'package:immich_mobile/domain/services/sync_stream.service.dart';
+import 'package:immich_mobile/infrastructure/repositories/sync_api.repository.dart';
+import 'package:immich_mobile/infrastructure/repositories/sync_migration.repository.dart';
+import 'package:immich_mobile/infrastructure/repositories/sync_stream.repository.dart';
+import 'package:immich_mobile/providers/api.provider.dart';
+import 'package:immich_mobile/providers/infrastructure/album.provider.dart';
+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';
+import 'package:immich_mobile/repositories/local_files_manager.repository.dart';
+
+final syncMigrationRepositoryProvider = Provider((ref) => SyncMigrationRepository(ref.watch(driftProvider)));
+
+final syncStreamServiceProvider = Provider(
+  (ref) => SyncStreamService(
+    syncApiRepository: ref.watch(syncApiRepositoryProvider),
+    syncStreamRepository: ref.watch(syncStreamRepositoryProvider),
+    localAssetRepository: ref.watch(localAssetRepository),
+    trashedLocalAssetRepository: ref.watch(trashedLocalAssetRepository),
+    localFilesManager: ref.watch(localFilesManagerRepositoryProvider),
+    storageRepository: ref.watch(storageRepositoryProvider),
+    syncMigrationRepository: ref.watch(syncMigrationRepositoryProvider),
+    api: ref.watch(apiServiceProvider),
+    cancelChecker: ref.watch(cancellationProvider),
+  ),
+);
+
+final syncApiRepositoryProvider = Provider((ref) => SyncApiRepository(ref.watch(apiServiceProvider)));
+
+final syncStreamRepositoryProvider = Provider((ref) => SyncStreamRepository(ref.watch(driftProvider)));
+
+final localSyncServiceProvider = Provider(
+  (ref) => LocalSyncService(
+    localAlbumRepository: ref.watch(localAlbumRepository),
+    localAssetRepository: ref.watch(localAssetRepository),
+    trashedLocalAssetRepository: ref.watch(trashedLocalAssetRepository),
+    localFilesManager: ref.watch(localFilesManagerRepositoryProvider),
+    storageRepository: ref.watch(storageRepositoryProvider),
+    nativeSyncApi: ref.watch(nativeSyncApiProvider),
+  ),
+);
+
+final hashServiceProvider = Provider(
+  (ref) => HashService(
+    localAlbumRepository: ref.watch(localAlbumRepository),
+    localAssetRepository: ref.watch(localAssetRepository),
+    nativeSyncApi: ref.watch(nativeSyncApiProvider),
+    trashedLocalAssetRepository: ref.watch(trashedLocalAssetRepository),
+  ),
+);

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

@@ -0,0 +1,43 @@
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+import 'package:immich_mobile/domain/services/timeline.service.dart';
+import 'package:immich_mobile/infrastructure/repositories/timeline.repository.dart';
+import 'package:immich_mobile/presentation/widgets/timeline/timeline.state.dart';
+import 'package:immich_mobile/providers/infrastructure/db.provider.dart';
+import 'package:immich_mobile/providers/infrastructure/setting.provider.dart';
+import 'package:immich_mobile/providers/user.provider.dart';
+
+final timelineRepositoryProvider = Provider<DriftTimelineRepository>(
+  (ref) => DriftTimelineRepository(ref.watch(driftProvider)),
+);
+
+final timelineArgsProvider = Provider.autoDispose<TimelineArgs>(
+  (ref) => throw UnimplementedError('Will be overridden through a ProviderScope.'),
+);
+
+final timelineServiceProvider = Provider<TimelineService>(
+  (ref) {
+    final timelineUsers = ref.watch(timelineUsersProvider).valueOrNull ?? [];
+    final timelineService = ref.watch(timelineFactoryProvider).main(timelineUsers);
+    ref.onDispose(timelineService.dispose);
+    return timelineService;
+  },
+  // Empty dependencies to inform the framework that this provider
+  // might be used in a ProviderScope
+  dependencies: [],
+);
+
+final timelineFactoryProvider = Provider<TimelineFactory>(
+  (ref) => TimelineFactory(
+    timelineRepository: ref.watch(timelineRepositoryProvider),
+    settingsService: ref.watch(settingsProvider),
+  ),
+);
+
+final timelineUsersProvider = StreamProvider<List<String>>((ref) {
+  final currentUserId = ref.watch(currentUserProvider.select((u) => u?.id));
+  if (currentUserId == null) {
+    return Stream.value([]);
+  }
+
+  return ref.watch(timelineRepositoryProvider).watchTimelineUserIds(currentUserId);
+});

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

@@ -0,0 +1,12 @@
+import 'package:async/async.dart';
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+import 'package:immich_mobile/providers/infrastructure/asset.provider.dart';
+
+typedef TrashedAssetsCount = ({int total, int hashed});
+
+final trashedAssetsCountProvider = StreamProvider<TrashedAssetsCount>((ref) {
+  final repo = ref.watch(trashedLocalAssetRepository);
+  final total$ = repo.watchCount();
+  final hashed$ = repo.watchHashedCount();
+  return StreamZip<int>([total$, hashed$]).map((values) => (total: values[0], hashed: values[1]));
+});

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

@@ -0,0 +1,39 @@
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+import 'package:immich_mobile/domain/models/user.model.dart';
+import 'package:immich_mobile/domain/services/partner.service.dart';
+import 'package:immich_mobile/domain/services/user.service.dart';
+import 'package:immich_mobile/infrastructure/repositories/partner.repository.dart';
+import 'package:immich_mobile/infrastructure/repositories/user.repository.dart';
+import 'package:immich_mobile/infrastructure/repositories/user_api.repository.dart';
+import 'package:immich_mobile/providers/api.provider.dart';
+import 'package:immich_mobile/providers/infrastructure/db.provider.dart';
+import 'package:immich_mobile/providers/infrastructure/partner.provider.dart';
+import 'package:immich_mobile/providers/infrastructure/store.provider.dart';
+import 'package:immich_mobile/repositories/partner_api.repository.dart';
+import 'package:riverpod_annotation/riverpod_annotation.dart';
+
+part 'user.provider.g.dart';
+
+@Riverpod(keepAlive: true)
+IsarUserRepository userRepository(Ref ref) => IsarUserRepository(ref.watch(isarProvider));
+
+@Riverpod(keepAlive: true)
+UserApiRepository userApiRepository(Ref ref) => UserApiRepository(ref.watch(apiServiceProvider).usersApi);
+
+@Riverpod(keepAlive: true)
+UserService userService(Ref ref) => UserService(
+  isarUserRepository: ref.watch(userRepositoryProvider),
+  userApiRepository: ref.watch(userApiRepositoryProvider),
+  storeService: ref.watch(storeServiceProvider),
+);
+
+/// Drifts
+final driftPartnerRepositoryProvider = Provider<DriftPartnerRepository>(
+  (ref) => DriftPartnerRepository(ref.watch(driftProvider)),
+);
+
+final driftPartnerServiceProvider = Provider<DriftPartnerService>(
+  (ref) => DriftPartnerService(ref.watch(driftPartnerRepositoryProvider), ref.watch(partnerApiRepositoryProvider)),
+);
+
+final partnerUsersProvider = NotifierProvider<PartnerNotifier, List<PartnerUserDto>>(PartnerNotifier.new);

mobile/lib/providers/infrastructure/user.provider.g.dart

@@ -0,0 +1,61 @@
+// GENERATED CODE - DO NOT MODIFY BY HAND
+
+part of 'user.provider.dart';
+
+// **************************************************************************
+// RiverpodGenerator
+// **************************************************************************
+
+String _$userRepositoryHash() => r'538791a4ad126ed086c9db682c67fc5c654d54f3';
+
+/// See also [userRepository].
+@ProviderFor(userRepository)
+final userRepositoryProvider = Provider<IsarUserRepository>.internal(
+  userRepository,
+  name: r'userRepositoryProvider',
+  debugGetCreateSourceHash: const bool.fromEnvironment('dart.vm.product')
+      ? null
+      : _$userRepositoryHash,
+  dependencies: null,
+  allTransitiveDependencies: null,
+);
+
+@Deprecated('Will be removed in 3.0. Use Ref instead')
+// ignore: unused_element
+typedef UserRepositoryRef = ProviderRef<IsarUserRepository>;
+String _$userApiRepositoryHash() => r'8a7340ca4544c8c6b20225c65bff2abb9e96baa2';
+
+/// See also [userApiRepository].
+@ProviderFor(userApiRepository)
+final userApiRepositoryProvider = Provider<UserApiRepository>.internal(
+  userApiRepository,
+  name: r'userApiRepositoryProvider',
+  debugGetCreateSourceHash: const bool.fromEnvironment('dart.vm.product')
+      ? null
+      : _$userApiRepositoryHash,
+  dependencies: null,
+  allTransitiveDependencies: null,
+);
+
+@Deprecated('Will be removed in 3.0. Use Ref instead')
+// ignore: unused_element
+typedef UserApiRepositoryRef = ProviderRef<UserApiRepository>;
+String _$userServiceHash() => r'181414dddc7891be6237e13d568c287a804228d1';
+
+/// See also [userService].
+@ProviderFor(userService)
+final userServiceProvider = Provider<UserService>.internal(
+  userService,
+  name: r'userServiceProvider',
+  debugGetCreateSourceHash: const bool.fromEnvironment('dart.vm.product')
+      ? null
+      : _$userServiceHash,
+  dependencies: null,
+  allTransitiveDependencies: null,
+);
+
+@Deprecated('Will be removed in 3.0. Use Ref instead')
+// ignore: unused_element
+typedef UserServiceRef = ProviderRef<UserService>;
+// ignore_for_file: type=lint
+// ignore_for_file: subtype_of_sealed_class, invalid_use_of_internal_member, invalid_use_of_visible_for_testing_member, deprecated_member_use_from_same_package

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

@@ -0,0 +1,22 @@
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+import 'package:immich_mobile/domain/models/user_metadata.model.dart';
+import 'package:immich_mobile/infrastructure/repositories/user_metadata.repository.dart';
+import 'package:immich_mobile/providers/infrastructure/db.provider.dart';
+import 'package:immich_mobile/providers/user.provider.dart';
+
+final userMetadataRepository = Provider<DriftUserMetadataRepository>(
+  (ref) => DriftUserMetadataRepository(ref.watch(driftProvider)),
+);
+
+final userMetadataProvider = FutureProvider<List<UserMetadata>>((ref) async {
+  final repository = ref.watch(userMetadataRepository);
+  final user = ref.watch(currentUserProvider);
+  if (user == null) return [];
+  return repository.getUserMetadata(user.id);
+});
+
+final userMetadataPreferencesProvider = FutureProvider<Preferences?>((ref) async {
+  final metadataList = await ref.watch(userMetadataProvider.future);
+  final metadataWithPrefs = metadataList.firstWhere((meta) => meta.preferences != null);
+  return metadataWithPrefs.preferences;
+});

mobile/lib/providers/local_auth.provider.dart

@@ -0,0 +1,81 @@
+import 'package:easy_localization/easy_localization.dart';
+import 'package:flutter/material.dart';
+import 'package:flutter/services.dart';
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+import 'package:immich_mobile/constants/constants.dart';
+import 'package:immich_mobile/extensions/build_context_extensions.dart';
+import 'package:immich_mobile/models/auth/biometric_status.model.dart';
+import 'package:immich_mobile/services/local_auth.service.dart';
+import 'package:immich_mobile/services/secure_storage.service.dart';
+import 'package:logging/logging.dart';
+
+final localAuthProvider = StateNotifierProvider<LocalAuthNotifier, BiometricStatus>((ref) {
+  return LocalAuthNotifier(ref.watch(localAuthServiceProvider), ref.watch(secureStorageServiceProvider));
+});
+
+class LocalAuthNotifier extends StateNotifier<BiometricStatus> {
+  final LocalAuthService _localAuthService;
+  final SecureStorageService _secureStorageService;
+
+  final _log = Logger("LocalAuthNotifier");
+
+  LocalAuthNotifier(this._localAuthService, this._secureStorageService)
+    : super(const BiometricStatus(availableBiometrics: [], canAuthenticate: false)) {
+    _localAuthService.getStatus().then((value) {
+      state = state.copyWith(canAuthenticate: value.canAuthenticate, availableBiometrics: value.availableBiometrics);
+    });
+  }
+
+  Future<bool> registerBiometric(BuildContext context, String pinCode) async {
+    final isAuthenticated = await authenticate(context, 'Authenticate to enable biometrics');
+
+    if (!isAuthenticated) {
+      return false;
+    }
+
+    await _secureStorageService.write(kSecuredPinCode, pinCode);
+
+    return true;
+  }
+
+  Future<bool> authenticate(BuildContext context, String? message) async {
+    String errorMessage = "";
+
+    try {
+      return await _localAuthService.authenticate(message);
+    } on PlatformException catch (error) {
+      switch (error.code) {
+        case "NotEnrolled":
+          _log.warning("User is not enrolled in biometrics");
+          errorMessage = "biometric_no_options".tr();
+          break;
+        case "NotAvailable":
+          _log.warning("Biometric authentication is not available");
+          errorMessage = "biometric_not_available".tr();
+          break;
+        case "LockedOut":
+          _log.warning("User is locked out of biometric authentication");
+          errorMessage = "biometric_locked_out".tr();
+          break;
+        default:
+          _log.warning("Failed to authenticate with unknown reason");
+          errorMessage = 'failed_to_authenticate'.tr();
+      }
+    } catch (error) {
+      _log.warning("Error during authentication: $error");
+      errorMessage = 'failed_to_authenticate'.tr();
+    } finally {
+      if (errorMessage.isNotEmpty) {
+        context.showSnackBar(
+          SnackBar(
+            content: Text(errorMessage, style: context.textTheme.labelLarge),
+            duration: const Duration(seconds: 3),
+            backgroundColor: context.colorScheme.errorContainer,
+          ),
+        );
+      }
+    }
+
+    return false;
+  }
+}

mobile/lib/providers/locale_provider.dart

@@ -0,0 +1,4 @@
+import 'package:flutter/widgets.dart';
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+
+final localeProvider = Provider<Locale>((_) => throw UnimplementedError());

mobile/lib/providers/map/map_marker.provider.dart

@@ -0,0 +1,34 @@
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+import 'package:immich_mobile/models/map/map_marker.model.dart';
+import 'package:immich_mobile/providers/map/map_service.provider.dart';
+import 'package:immich_mobile/providers/map/map_state.provider.dart';
+import 'package:riverpod_annotation/riverpod_annotation.dart';
+
+part 'map_marker.provider.g.dart';
+
+@riverpod
+Future<List<MapMarker>> mapMarkers(Ref ref) async {
+  final service = ref.read(mapServiceProvider);
+  final mapState = ref.read(mapStateNotifierProvider);
+  DateTime? fileCreatedAfter;
+  bool? isFavorite;
+  bool isIncludeArchived = mapState.includeArchived;
+  bool isWithPartners = mapState.withPartners;
+
+  if (mapState.relativeTime != 0) {
+    fileCreatedAfter = DateTime.now().subtract(Duration(days: mapState.relativeTime));
+  }
+
+  if (mapState.showFavoriteOnly) {
+    isFavorite = true;
+  }
+
+  final markers = await service.getMapMarkers(
+    isFavorite: isFavorite,
+    withArchived: isIncludeArchived,
+    withPartners: isWithPartners,
+    fileCreatedAfter: fileCreatedAfter,
+  );
+
+  return markers.toList();
+}

mobile/lib/providers/map/map_marker.provider.g.dart

@@ -0,0 +1,27 @@
+// GENERATED CODE - DO NOT MODIFY BY HAND
+
+part of 'map_marker.provider.dart';
+
+// **************************************************************************
+// RiverpodGenerator
+// **************************************************************************
+
+String _$mapMarkersHash() => r'a0c129fcddbf1b9bce4aafcd2e47a858ab6ef1c9';
+
+/// See also [mapMarkers].
+@ProviderFor(mapMarkers)
+final mapMarkersProvider = AutoDisposeFutureProvider<List<MapMarker>>.internal(
+  mapMarkers,
+  name: r'mapMarkersProvider',
+  debugGetCreateSourceHash: const bool.fromEnvironment('dart.vm.product')
+      ? null
+      : _$mapMarkersHash,
+  dependencies: null,
+  allTransitiveDependencies: null,
+);
+
+@Deprecated('Will be removed in 3.0. Use Ref instead')
+// ignore: unused_element
+typedef MapMarkersRef = AutoDisposeFutureProviderRef<List<MapMarker>>;
+// ignore_for_file: type=lint
+// ignore_for_file: subtype_of_sealed_class, invalid_use_of_internal_member, invalid_use_of_visible_for_testing_member, deprecated_member_use_from_same_package

mobile/lib/providers/map/map_service.provider.dart

@@ -0,0 +1,9 @@
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+import 'package:immich_mobile/services/map.service.dart';
+import 'package:immich_mobile/providers/api.provider.dart';
+import 'package:riverpod_annotation/riverpod_annotation.dart';
+
+part 'map_service.provider.g.dart';
+
+@riverpod
+MapService mapService(Ref ref) => MapService(ref.watch(apiServiceProvider));

mobile/lib/providers/map/map_service.provider.g.dart

@@ -0,0 +1,27 @@
+// GENERATED CODE - DO NOT MODIFY BY HAND
+
+part of 'map_service.provider.dart';
+
+// **************************************************************************
+// RiverpodGenerator
+// **************************************************************************
+
+String _$mapServiceHash() => r'ffc8f38b726083452b9df236ed58903879348987';
+
+/// See also [mapService].
+@ProviderFor(mapService)
+final mapServiceProvider = AutoDisposeProvider<MapService>.internal(
+  mapService,
+  name: r'mapServiceProvider',
+  debugGetCreateSourceHash: const bool.fromEnvironment('dart.vm.product')
+      ? null
+      : _$mapServiceHash,
+  dependencies: null,
+  allTransitiveDependencies: null,
+);
+
+@Deprecated('Will be removed in 3.0. Use Ref instead')
+// ignore: unused_element
+typedef MapServiceRef = AutoDisposeProviderRef<MapService>;
+// ignore_for_file: type=lint
+// ignore_for_file: subtype_of_sealed_class, invalid_use_of_internal_member, invalid_use_of_visible_for_testing_member, deprecated_member_use_from_same_package

mobile/lib/providers/map/map_state.provider.dart

@@ -0,0 +1,58 @@
+import 'package:flutter/material.dart';
+import 'package:immich_mobile/models/map/map_state.model.dart';
+import 'package:immich_mobile/providers/app_settings.provider.dart';
+import 'package:immich_mobile/providers/server_info.provider.dart';
+import 'package:immich_mobile/services/app_settings.service.dart';
+import 'package:riverpod_annotation/riverpod_annotation.dart';
+
+part 'map_state.provider.g.dart';
+
+@Riverpod(keepAlive: true)
+class MapStateNotifier extends _$MapStateNotifier {
+  @override
+  MapState build() {
+    final appSettingsProvider = ref.read(appSettingsServiceProvider);
+
+    final lightStyleUrl = ref.read(serverInfoProvider).serverConfig.mapLightStyleUrl;
+    final darkStyleUrl = ref.read(serverInfoProvider).serverConfig.mapDarkStyleUrl;
+
+    return MapState(
+      themeMode: ThemeMode.values[appSettingsProvider.getSetting<int>(AppSettingsEnum.mapThemeMode)],
+      showFavoriteOnly: appSettingsProvider.getSetting<bool>(AppSettingsEnum.mapShowFavoriteOnly),
+      includeArchived: appSettingsProvider.getSetting<bool>(AppSettingsEnum.mapIncludeArchived),
+      withPartners: appSettingsProvider.getSetting<bool>(AppSettingsEnum.mapwithPartners),
+      relativeTime: appSettingsProvider.getSetting<int>(AppSettingsEnum.mapRelativeDate),
+      lightStyleFetched: AsyncData(lightStyleUrl),
+      darkStyleFetched: AsyncData(darkStyleUrl),
+    );
+  }
+
+  void switchTheme(ThemeMode mode) {
+    ref.read(appSettingsServiceProvider).setSetting(AppSettingsEnum.mapThemeMode, mode.index);
+    state = state.copyWith(themeMode: mode);
+  }
+
+  void switchFavoriteOnly(bool isFavoriteOnly) {
+    ref.read(appSettingsServiceProvider).setSetting(AppSettingsEnum.mapShowFavoriteOnly, isFavoriteOnly);
+    state = state.copyWith(showFavoriteOnly: isFavoriteOnly, shouldRefetchMarkers: true);
+  }
+
+  void setRefetchMarkers(bool shouldRefetch) {
+    state = state.copyWith(shouldRefetchMarkers: shouldRefetch);
+  }
+
+  void switchIncludeArchived(bool isIncludeArchived) {
+    ref.read(appSettingsServiceProvider).setSetting(AppSettingsEnum.mapIncludeArchived, isIncludeArchived);
+    state = state.copyWith(includeArchived: isIncludeArchived, shouldRefetchMarkers: true);
+  }
+
+  void switchWithPartners(bool isWithPartners) {
+    ref.read(appSettingsServiceProvider).setSetting(AppSettingsEnum.mapwithPartners, isWithPartners);
+    state = state.copyWith(withPartners: isWithPartners, shouldRefetchMarkers: true);
+  }
+
+  void setRelativeTime(int relativeTime) {
+    ref.read(appSettingsServiceProvider).setSetting(AppSettingsEnum.mapRelativeDate, relativeTime);
+    state = state.copyWith(relativeTime: relativeTime, shouldRefetchMarkers: true);
+  }
+}

mobile/lib/providers/map/map_state.provider.g.dart

@@ -0,0 +1,26 @@
+// GENERATED CODE - DO NOT MODIFY BY HAND
+
+part of 'map_state.provider.dart';
+
+// **************************************************************************
+// RiverpodGenerator
+// **************************************************************************
+
+String _$mapStateNotifierHash() => r'22e4e571bd0730dbc34b109255a62b920e9c7d66';
+
+/// See also [MapStateNotifier].
+@ProviderFor(MapStateNotifier)
+final mapStateNotifierProvider =
+    NotifierProvider<MapStateNotifier, MapState>.internal(
+      MapStateNotifier.new,
+      name: r'mapStateNotifierProvider',
+      debugGetCreateSourceHash: const bool.fromEnvironment('dart.vm.product')
+          ? null
+          : _$mapStateNotifierHash,
+      dependencies: null,
+      allTransitiveDependencies: null,
+    );
+
+typedef _$MapStateNotifier = Notifier<MapState>;
+// ignore_for_file: type=lint
+// ignore_for_file: subtype_of_sealed_class, invalid_use_of_internal_member, invalid_use_of_visible_for_testing_member, deprecated_member_use_from_same_package