Source Code added

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