Source Code added

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;
+});