add adaptive_scaffold

mobile-v2/lib/domain/repositories/database.repository.dart

@@ -2,6 +2,8 @@ import 'dart:io';
 
 import 'package:drift/drift.dart';
 import 'package:drift/native.dart';
+import 'package:immich_mobile/domain/entities/album.entity.dart';
+import 'package:immich_mobile/domain/entities/asset.entity.dart';
 import 'package:immich_mobile/domain/entities/log.entity.dart';
 import 'package:immich_mobile/domain/entities/store.entity.dart';
 import 'package:immich_mobile/domain/interfaces/database.interface.dart';
@@ -12,7 +14,7 @@ import 'package:sqlite3_flutter_libs/sqlite3_flutter_libs.dart';
 
 import 'database.repository.drift.dart';
 
-@DriftDatabase(tables: [Logs, Store])
+@DriftDatabase(tables: [Logs, Store, LocalAlbum, LocalAsset])
 class DriftDatabaseRepository extends $DriftDatabaseRepository
     implements IDatabaseRepository<GeneratedDatabase> {
   DriftDatabaseRepository() : super(_openConnection());

mobile-v2/lib/domain/repositories/store.repository.dart

@@ -1,66 +1,89 @@
 import 'dart:async';
 
+import 'package:collection/collection.dart';
 import 'package:drift/drift.dart';
 import 'package:immich_mobile/domain/entities/store.entity.drift.dart';
 import 'package:immich_mobile/domain/interfaces/store.interface.dart';
 import 'package:immich_mobile/domain/models/store.model.dart';
 import 'package:immich_mobile/domain/repositories/database.repository.dart';
+import 'package:immich_mobile/utils/mixins/log_context.mixin.dart';
 
-class StoreDriftRepository implements IStoreRepository {
+class StoreDriftRepository with LogContext implements IStoreRepository {
   final DriftDatabaseRepository db;
 
   const StoreDriftRepository(this.db);
 
   @override
-  FutureOr<T?> getValue<T>(StoreKey key) async {
-    final value = await db.managers.store
+  FutureOr<T?> getValue<T, U>(StoreKey<T, U> key) async {
+    final storeData = await db.managers.store
         .filter((s) => s.id.equals(key.id))
         .getSingleOrNull();
-    return value?.toModel().extract(key.type);
+    return _getValueFromStoreData(key, storeData);
   }
 
   @override
-  FutureOr<void> setValue<T>(StoreKey key, T value) {
-    return db.transaction(() async {
-      final storeValue = StoreValue.of(key, value);
-      await db.into(db.store).insertOnConflictUpdate(StoreCompanion.insert(
-            id: Value(storeValue.id),
-            intValue: Value(storeValue.intValue),
-            stringValue: Value(storeValue.stringValue),
-          ));
-    });
+  FutureOr<bool> setValue<T, U>(StoreKey<T, U> key, T value) async {
+    try {
+      await db.transaction(() async {
+        final storeValue = key.converter.toPrimitive(value);
+        final intValue = (key.type == int) ? storeValue as int : null;
+        final stringValue = (key.type == String) ? storeValue as String : null;
+        await db.into(db.store).insertOnConflictUpdate(StoreCompanion.insert(
+              id: Value(key.id),
+              intValue: Value(intValue),
+              stringValue: Value(stringValue),
+            ));
+      });
+      return true;
+    } catch (e, s) {
+      log.severe("Cannot set store value - ${key.name}; id - ${key.id}", e, s);
+      return false;
+    }
   }
 
   @override
-  FutureOr<void> deleteValue(StoreKey key) {
-    return db.transaction(() async {
+  FutureOr<void> deleteValue(StoreKey key) async {
+    return await db.transaction(() async {
       await db.managers.store.filter((s) => s.id.equals(key.id)).delete();
     });
   }
 
   @override
   Stream<List<StoreValue>> watchStore() {
-    return (db.select(db.store).map((s) => s.toModel())).watch();
+    return (db.select(db.store).map((s) {
+      final key = StoreKey.values.firstWhereOrNull((e) => e.id == s.id);
+      if (key != null) {
+        final value = _getValueFromStoreData(key, s);
+        return StoreValue(id: s.id, value: value);
+      }
+      return StoreValue(id: s.id, value: null);
+    })).watch();
   }
 
   @override
-  Stream<T?> watchValue<T>(StoreKey key) {
+  Stream<T?> watchValue<T, U>(StoreKey<T, U> key) {
     return db.managers.store
         .filter((s) => s.id.equals(key.id))
         .watchSingleOrNull()
-        .map((e) => e?.toModel().extract(key.type));
+        .map((e) => _getValueFromStoreData(key, e));
   }
 
   @override
-  FutureOr<void> clearStore() {
-    return db.transaction(() async {
+  FutureOr<void> clearStore() async {
+    return await db.transaction(() async {
       await db.managers.store.delete();
     });
   }
-}
 
-extension _StoreDataToStoreValue on StoreData {
-  StoreValue toModel() {
-    return StoreValue(id: id, intValue: intValue, stringValue: stringValue);
+  T? _getValueFromStoreData<T, U>(StoreKey<T, U> key, StoreData? data) {
+    final primitive = switch (key.type) {
+      const (int) => data?.intValue,
+      const (String) => data?.stringValue,
+      _ => null,
+    } as U?;
+    if (primitive != null) {
+      return key.converter.fromPrimitive(primitive);
+    }
+    return null;
   }
 }