feat(mobile): new mobile UI (#12582)

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

@@ -1,21 +1,21 @@
 import 'dart:async';
 
 import 'package:hooks_riverpod/hooks_riverpod.dart';
+import 'package:immich_mobile/entities/user.entity.dart';
+import 'package:immich_mobile/models/albums/album_search.model.dart';
 import 'package:immich_mobile/services/album.service.dart';
 import 'package:immich_mobile/widgets/asset_grid/asset_grid_data_structure.dart';
 import 'package:immich_mobile/entities/asset.entity.dart';
 import 'package:immich_mobile/entities/album.entity.dart';
-import 'package:immich_mobile/entities/store.entity.dart';
-import 'package:immich_mobile/entities/user.entity.dart';
 import 'package:immich_mobile/providers/db.provider.dart';
 import 'package:immich_mobile/utils/renderlist_generator.dart';
 import 'package:isar/isar.dart';
 
+final isRefreshingRemoteAlbumProvider = StateProvider<bool>((ref) => false);
+
 class AlbumNotifier extends StateNotifier<List<Album>> {
-  AlbumNotifier(this._albumService, Isar db) : super([]) {
-    final query = db.albums
-        .filter()
-        .owner((q) => q.isarIdEqualTo(Store.get(StoreKey.currentUser).isarId));
+  AlbumNotifier(this._albumService, this.db, this.ref) : super([]) {
+    final query = db.albums.filter().remoteIdIsNotNull();
     query.findAll().then((value) {
       if (mounted) {
         state = value;
@@ -25,14 +25,22 @@ class AlbumNotifier extends StateNotifier<List<Album>> {
   }
 
   final AlbumService _albumService;
+  final Isar db;
+  final Ref ref;
   late final StreamSubscription<List<Album>> _streamSub;
 
-  Future<void> getAllAlbums() => Future.wait([
-        _albumService.refreshDeviceAlbums(),
-        _albumService.refreshRemoteAlbums(isShared: false),
-      ]);
+  Future<void> refreshRemoteAlbums() async {
+    final isRefresing =
+        ref.read(isRefreshingRemoteAlbumProvider.notifier).state;
 
-  Future<void> getDeviceAlbums() => _albumService.refreshDeviceAlbums();
+    if (isRefresing) return;
+
+    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);
 
@@ -59,6 +67,50 @@ class AlbumNotifier extends StateNotifier<List<Album>> {
     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, User 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);
+  }
+
   @override
   void dispose() {
     _streamSub.cancel();
@@ -71,6 +123,7 @@ final albumProvider =
   return AlbumNotifier(
     ref.watch(albumServiceProvider),
     ref.watch(dbProvider),
+    ref,
   );
 });
 
@@ -94,3 +147,31 @@ final albumRenderlistProvider =
   }
   return const Stream.empty();
 });
+
+class LocalAlbumsNotifier extends StateNotifier<List<Album>> {
+  LocalAlbumsNotifier(this.db) : super([]) {
+    final query = db.albums.where().remoteIdIsNull();
+
+    query.findAll().then((value) {
+      if (mounted) {
+        state = value;
+      }
+    });
+
+    _streamSub = query.watch().listen((data) => state = data);
+  }
+
+  final Isar db;
+  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(dbProvider));
+});