fix(mobile): map unresponsive after viewing asset (#27036)

* fix(mobile): map unresponsive after viewing asset

* chore: better fix

mobile/lib/domain/models/events.model.dart

@@ -24,6 +24,12 @@ class ViewerReloadAssetEvent extends Event {
   const ViewerReloadAssetEvent();
 }
 
+class ViewerStackAssetDeletedEvent extends Event {
+  final int stackIndex;
+
+  const ViewerStackAssetDeletedEvent({required this.stackIndex});
+}
+
 // Multi-Select Events
 class MultiSelectToggleEvent extends Event {
   final bool isEnabled;

mobile/lib/domain/models/settings_key.dart

@@ -1,17 +1,16 @@
-import 'dart:convert';
-
 import 'package:flutter/material.dart';
 import 'package:immich_mobile/constants/colors.dart';
 import 'package:immich_mobile/constants/enums.dart';
 import 'package:immich_mobile/domain/models/log.model.dart';
 import 'package:immich_mobile/domain/models/timeline.model.dart';
+import 'package:immich_mobile/domain/models/value_codec.dart';
 import 'package:immich_mobile/providers/album/album_sort_by_options.provider.dart';
 import 'package:immich_mobile/utils/semver.dart';
 
 enum SettingsKey<T> {
   // Theme
-  themePrimaryColor<ImmichColorPreset>(codec: _EnumCodec(ImmichColorPreset.values)),
-  themeMode<ThemeMode>(codec: _EnumCodec(ThemeMode.values)),
+  themePrimaryColor<ImmichColorPreset>(codec: EnumCodec(ImmichColorPreset.values)),
+  themeMode<ThemeMode>(codec: EnumCodec(ThemeMode.values)),
   themeDynamic<bool>(),
   themeColorfulInterface<bool>(),
 
@@ -27,13 +26,13 @@ enum SettingsKey<T> {
 
   // Network
   networkAutoEndpointSwitching<bool>(),
+  networkExternalEndpointList<List<String>>(codec: ListCodec(PrimitiveCodec.string)),
+  networkCustomHeaders<Map<String, String>>(codec: MapCodec(PrimitiveCodec.string, PrimitiveCodec.string)),
   networkPreferredWifiName<String?>(),
   networkLocalEndpoint<String?>(),
-  networkExternalEndpointList<List<String>>(codec: _ListCodec(_PrimitiveCodec.string)),
-  networkCustomHeaders<Map<String, String>>(codec: _MapCodec(_PrimitiveCodec.string, _PrimitiveCodec.string)),
 
   // Album
-  albumSortMode<AlbumSortMode>(codec: _EnumCodec(AlbumSortMode.values)),
+  albumSortMode<AlbumSortMode>(codec: EnumCodec(AlbumSortMode.values)),
   albumIsReverse<bool>(),
   albumIsGrid<bool>(),
 
@@ -47,195 +46,45 @@ enum SettingsKey<T> {
 
   // Timeline
   timelineTilesPerRow<int>(),
-  timelineGroupAssetsBy<GroupAssetsBy>(codec: _EnumCodec(GroupAssetsBy.values)),
+  timelineGroupAssetsBy<GroupAssetsBy>(codec: EnumCodec(GroupAssetsBy.values)),
   timelineStorageIndicator<bool>(),
 
   // Log
-  logLevel<LogLevel>(codec: _EnumCodec(LogLevel.values)),
+  logLevel<LogLevel>(codec: EnumCodec(LogLevel.values)),
 
   // Map
   mapShowFavoriteOnly<bool>(),
   mapRelativeDate<int>(),
   mapIncludeArchived<bool>(),
-  mapThemeMode<ThemeMode>(codec: _EnumCodec(ThemeMode.values)),
+  mapThemeMode<ThemeMode>(codec: EnumCodec(ThemeMode.values)),
   mapWithPartners<bool>(),
 
   // Cleanup
   cleanupKeepFavorites<bool>(),
-  cleanupKeepMediaType<AssetKeepType>(codec: _EnumCodec(AssetKeepType.values)),
-  cleanupKeepAlbumIds<List<String>>(codec: _ListCodec(_PrimitiveCodec.string)),
+  cleanupKeepMediaType<AssetKeepType>(codec: EnumCodec(AssetKeepType.values)),
+  cleanupKeepAlbumIds<List<String>>(codec: ListCodec(PrimitiveCodec.string)),
   cleanupCutoffDaysAgo<int>(),
   cleanupDefaultsInitialized<bool>(),
 
   // Share
-  shareFileType<ShareAssetType>(codec: _EnumCodec(ShareAssetType.values)),
+  shareFileType<ShareAssetType>(codec: EnumCodec(ShareAssetType.values)),
 
   // Slideshow
   slideshowRepeat<bool>(),
   slideshowDuration<int>(),
-  slideshowLook<SlideshowLook>(codec: _EnumCodec(SlideshowLook.values)),
-  slideshowDirection<SlideshowDirection>(codec: _EnumCodec(SlideshowDirection.values)),
+  slideshowLook<SlideshowLook>(codec: EnumCodec(SlideshowLook.values)),
+  slideshowDirection<SlideshowDirection>(codec: EnumCodec(SlideshowDirection.values)),
 
   // Feature message
-  featureMessageSeenRelease<SemVer>(codec: _SemVerCodec());
+  featureMessageSeenRelease<SemVer>(codec: SemVerCodec());
 
-  final _SettingsCodec<T>? _codecOverride;
+  final ValueCodec<T>? _codecOverride;
 
-  const SettingsKey({_SettingsCodec<T>? codec}) : _codecOverride = codec;
+  const SettingsKey({ValueCodec<T>? codec}) : _codecOverride = codec;
 
-  _SettingsCodec<T> get _codec => _codecOverride ?? _SettingsCodec.forType(T);
+  ValueCodec<T> get _codec => _codecOverride ?? ValueCodec.forType(T);
 
   String encode(T value) => _codec.encode(value);
 
   T decode(String raw) => _codec.decode(raw);
 }
-
-sealed class _SettingsCodec<T> {
-  const _SettingsCodec();
-
-  String encode(T value);
-  T decode(String raw);
-
-  static final Map<Type, _SettingsCodec<Object>> _primitives = {
-    ..._register<int>(_PrimitiveCodec.integer),
-    ..._register<double>(_PrimitiveCodec.real),
-    ..._register<bool>(_PrimitiveCodec.boolean),
-    ..._register<String>(_PrimitiveCodec.string),
-    ..._register<DateTime>(const _DateTimeCodec()),
-  };
-
-  static Map<Type, _SettingsCodec<Object>> _register<T>(_SettingsCodec<Object> codec) => {
-    T: codec,
-    // Reifies the nullable type T so it can be used as a key in the _primitives map
-    _typeOf<T?>(): codec,
-  };
-
-  static Type _typeOf<T>() => T;
-
-  static _SettingsCodec<T> forType<T>(Type runtimeType) {
-    final codec = _primitives[runtimeType];
-    if (codec == null) {
-      throw StateError('No primitive codec for $runtimeType. Provide an explicit codec when defining the SettingsKey.');
-    }
-    return codec as _SettingsCodec<T>;
-  }
-}
-
-final class _EnumCodec<T extends Enum> extends _SettingsCodec<T> {
-  final List<T> values;
-
-  const _EnumCodec(this.values);
-
-  @override
-  String encode(T value) => value.name;
-
-  @override
-  T decode(String raw) => values.firstWhere((v) => v.name == raw);
-}
-
-final class _DateTimeCodec extends _SettingsCodec<DateTime> {
-  const _DateTimeCodec();
-
-  @override
-  String encode(DateTime value) => value.toIso8601String();
-
-  @override
-  DateTime decode(String raw) => DateTime.parse(raw);
-}
-
-final class _SemVerCodec extends _SettingsCodec<SemVer> {
-  const _SemVerCodec();
-
-  @override
-  String encode(SemVer value) => value.toString();
-
-  @override
-  SemVer decode(String raw) => SemVer.fromString(raw);
-}
-
-final class _MapCodec<K extends Object, V extends Object> extends _SettingsCodec<Map<K, V>> {
-  final _SettingsCodec<K> _keyCodec;
-  final _SettingsCodec<V> _valueCodec;
-
-  const _MapCodec(this._keyCodec, this._valueCodec);
-
-  @override
-  String encode(Map<K, V> value) {
-    final entries = <String, String>{};
-    value.forEach((k, v) => entries[_keyCodec.encode(k)] = _valueCodec.encode(v));
-    return jsonEncode(entries);
-  }
-
-  @override
-  Map<K, V> decode(String raw) {
-    try {
-      final decoded = jsonDecode(raw);
-      if (decoded is! Map) {
-        return {};
-      }
-      final result = <K, V>{};
-      for (final entry in decoded.entries) {
-        final rawKey = entry.key;
-        final rawValue = entry.value;
-        if (rawKey is! String || rawValue is! String) {
-          return {};
-        }
-        final k = _keyCodec.decode(rawKey);
-        final v = _valueCodec.decode(rawValue);
-        result[k] = v;
-      }
-      return result;
-    } on FormatException {
-      return {};
-    }
-  }
-}
-
-final class _ListCodec<T extends Object> extends _SettingsCodec<List<T>> {
-  final _SettingsCodec<T> _elementCodec;
-
-  const _ListCodec(this._elementCodec);
-
-  @override
-  String encode(List<T> value) => jsonEncode(value.map(_elementCodec.encode).toList());
-
-  @override
-  List<T> decode(String raw) {
-    try {
-      final decoded = jsonDecode(raw);
-      if (decoded is! List) {
-        return [];
-      }
-      final result = <T>[];
-      for (final item in decoded) {
-        if (item is! String) {
-          return [];
-        }
-        final element = _elementCodec.decode(item);
-        result.add(element);
-      }
-      return result;
-    } on FormatException {
-      return [];
-    }
-  }
-}
-
-final class _PrimitiveCodec<T extends Object> extends _SettingsCodec<T> {
-  final T Function(String) _parse;
-
-  const _PrimitiveCodec._(this._parse);
-
-  @override
-  String encode(T value) => value.toString();
-
-  @override
-  T decode(String raw) => _parse(raw);
-
-  static const integer = _PrimitiveCodec<int>._(int.parse);
-  static const real = _PrimitiveCodec<double>._(double.parse);
-  static const boolean = _PrimitiveCodec<bool>._(bool.parse);
-  static const string = _PrimitiveCodec<String>._(_identity);
-
-  static String _identity(String s) => s;
-}

mobile/lib/domain/models/value_codec.dart

@@ -0,0 +1,153 @@
+import 'dart:convert';
+
+import 'package:immich_mobile/utils/semver.dart';
+
+sealed class ValueCodec<T> {
+  const ValueCodec();
+
+  String encode(T value);
+  T decode(String raw);
+
+  static final Map<Type, ValueCodec<Object>> _primitives = {
+    ..._register<int>(PrimitiveCodec.integer),
+    ..._register<double>(PrimitiveCodec.real),
+    ..._register<bool>(PrimitiveCodec.boolean),
+    ..._register<String>(PrimitiveCodec.string),
+    ..._register<DateTime>(const DateTimeCodec()),
+  };
+
+  static Map<Type, ValueCodec<Object>> _register<T>(ValueCodec<Object> codec) => {
+    T: codec,
+    // Reifies the nullable type T so it can be used as a key in the _primitives map
+    _typeOf<T?>(): codec,
+  };
+
+  static Type _typeOf<T>() => T;
+
+  static ValueCodec<T> forType<T>(Type runtimeType) {
+    final codec = _primitives[runtimeType];
+    if (codec == null) {
+      throw StateError('No primitive codec for $runtimeType. Provide an explicit codec when defining the key.');
+    }
+    return codec as ValueCodec<T>;
+  }
+}
+
+final class EnumCodec<T extends Enum> extends ValueCodec<T> {
+  final List<T> values;
+
+  const EnumCodec(this.values);
+
+  @override
+  String encode(T value) => value.name;
+
+  @override
+  T decode(String raw) => values.firstWhere((v) => v.name == raw);
+}
+
+final class DateTimeCodec extends ValueCodec<DateTime> {
+  const DateTimeCodec();
+
+  @override
+  String encode(DateTime value) => value.toIso8601String();
+
+  @override
+  DateTime decode(String raw) => DateTime.parse(raw);
+}
+
+final class SemVerCodec extends ValueCodec<SemVer> {
+  const SemVerCodec();
+
+  @override
+  String encode(SemVer value) => value.toString();
+
+  @override
+  SemVer decode(String raw) => SemVer.fromString(raw);
+}
+
+final class MapCodec<K extends Object, V extends Object> extends ValueCodec<Map<K, V>> {
+  final ValueCodec<K> _keyCodec;
+  final ValueCodec<V> _valueCodec;
+
+  const MapCodec(this._keyCodec, this._valueCodec);
+
+  @override
+  String encode(Map<K, V> value) {
+    final entries = <String, String>{};
+    value.forEach((k, v) => entries[_keyCodec.encode(k)] = _valueCodec.encode(v));
+    return jsonEncode(entries);
+  }
+
+  @override
+  Map<K, V> decode(String raw) {
+    try {
+      final decoded = jsonDecode(raw);
+      if (decoded is! Map) {
+        return {};
+      }
+      final result = <K, V>{};
+      for (final entry in decoded.entries) {
+        final rawKey = entry.key;
+        final rawValue = entry.value;
+        if (rawKey is! String || rawValue is! String) {
+          continue;
+        }
+        final k = _keyCodec.decode(rawKey);
+        final v = _valueCodec.decode(rawValue);
+        result[k] = v;
+      }
+      return result;
+    } on FormatException {
+      return {};
+    }
+  }
+}
+
+final class ListCodec<T extends Object> extends ValueCodec<List<T>> {
+  final ValueCodec<T> _elementCodec;
+
+  const ListCodec(this._elementCodec);
+
+  @override
+  String encode(List<T> value) => jsonEncode(value.map(_elementCodec.encode).toList());
+
+  @override
+  List<T> decode(String raw) {
+    try {
+      final decoded = jsonDecode(raw);
+      if (decoded is! List) {
+        return [];
+      }
+      final result = <T>[];
+      for (final item in decoded) {
+        if (item is! String) {
+          return [];
+        }
+        final element = _elementCodec.decode(item);
+        result.add(element);
+      }
+      return result;
+    } on FormatException {
+      return [];
+    }
+  }
+}
+
+final class PrimitiveCodec<T extends Object> extends ValueCodec<T> {
+  final T Function(String) _parse;
+
+  const PrimitiveCodec._(this._parse);
+
+  @override
+  String encode(T value) => value.toString();
+
+  @override
+  T decode(String raw) => _parse(raw);
+
+  static const integer = PrimitiveCodec<int>._(int.parse);
+  static const real = PrimitiveCodec<double>._(double.parse);
+  static const boolean = PrimitiveCodec<bool>._(bool.parse);
+  static const string = PrimitiveCodec<String>._(_identity);
+
+  static String _identity(String s) => s;
+}

mobile/lib/infrastructure/repositories/cached_key_value_repository.dart

@@ -0,0 +1,41 @@
+import 'package:collection/collection.dart';
+import 'package:drift/drift.dart';
+// ignore: depend_on_referenced_packages
+import 'package:meta/meta.dart';
+
+abstract class CachedKeyValueRepository<K extends Enum, S> {
+  CachedKeyValueRepository(this._snapshot);
+
+  S _snapshot;
+  S get snapshot => _snapshot;
+  @protected
+  set snapshot(S value) => _snapshot = value;
+
+  List<K> get keys;
+
+  Object decodeValue(K key, String raw);
+
+  S buildSnapshot(Map<K, Object?> overrides);
+
+  Selectable<({String key, String? value})> selectable();
+
+  Future<void> refresh() async => _snapshot = _build(await selectable().get());
+
+  Stream<S> watchSnapshot() => selectable().watch().map((rows) => _snapshot = _build(rows));
+
+  S _build(List<({String key, String? value})> rows) => buildSnapshot(
+    rows.fold({}, (overrides, row) {
+      final key = keys.firstWhereOrNull((key) => key.name == row.key);
+      if (key == null) {
+        return overrides;
+      }
+
+      Object? decodedValue;
+      if (row.value != null) {
+        decodedValue = decodeValue(key, row.value!);
+      }
+
+      return {...overrides, key: decodedValue};
+    }),
+  );
+}

mobile/lib/infrastructure/repositories/remote_asset.repository.dart

@@ -71,7 +71,13 @@ class RemoteAssetRepository extends DriftDatabaseRepository {
     }
 
     final query = _db.remoteAssetEntity.select()
-      ..where((row) => row.stackId.equals(stackId) & row.id.equals(asset.id).not())
+      ..where(
+        (row) =>
+            row.stackId.equals(stackId) &
+            row.id.equals(asset.id).not() &
+            row.deletedAt.isNull() &
+            row.visibility.equalsValue(AssetVisibility.timeline),
+      )
       ..orderBy([(row) => OrderingTerm.desc(row.createdAt)]);
 
     return query.map((row) => row.toDto()).get();

mobile/lib/infrastructure/repositories/settings.repository.dart

@@ -1,13 +1,14 @@
-import 'package:collection/collection.dart';
+import 'package:drift/drift.dart';
 import 'package:immich_mobile/domain/models/config/app_config.dart';
 import 'package:immich_mobile/domain/models/settings_key.dart';
 import 'package:immich_mobile/infrastructure/entities/settings.entity.drift.dart';
+import 'package:immich_mobile/infrastructure/repositories/cached_key_value_repository.dart';
 import 'package:immich_mobile/infrastructure/repositories/db.repository.dart';
 
-class SettingsRepository extends DriftDatabaseRepository {
+class SettingsRepository extends CachedKeyValueRepository<SettingsKey, AppConfig> {
   final Drift _db;
 
-  SettingsRepository._(this._db) : super(_db);
+  SettingsRepository._(this._db) : super(const .new());
 
   static SettingsRepository? _instance;
 
@@ -19,9 +20,6 @@ class SettingsRepository extends DriftDatabaseRepository {
     return instance;
   }
 
-  AppConfig _appConfig = const .new();
-  AppConfig get appConfig => _appConfig;
-
   static Future<SettingsRepository> ensureInitialized(Drift db) async {
     if (_instance == null) {
       final instance = SettingsRepository._(db);
@@ -31,7 +29,20 @@ class SettingsRepository extends DriftDatabaseRepository {
     return _instance!;
   }
 
-  Future<void> refresh() async => _applyOverrides(await _db.select(_db.settingsEntity).get());
+  @override
+  List<SettingsKey> get keys => SettingsKey.values;
+
+  @override
+  Object decodeValue(SettingsKey key, String raw) => key.decode(raw);
+
+  @override
+  AppConfig buildSnapshot(Map<SettingsKey, Object?> overrides) => AppConfig.fromEntries(overrides);
+
+  @override
+  Selectable<({String key, String? value})> selectable() =>
+      _db.select(_db.settingsEntity).map((row) => (key: row.key, value: row.value));
+
+  AppConfig get appConfig => snapshot;
 
   Future<void> clear(Iterable<SettingsKey> keys) async {
     if (keys.isEmpty) {
@@ -41,13 +52,15 @@ class SettingsRepository extends DriftDatabaseRepository {
     final names = keys.map((key) => key.name).toList();
     await (_db.delete(_db.settingsEntity)..where((row) => row.key.isIn(names))).go();
 
+    var config = snapshot;
     for (final key in keys) {
-      _appConfig = _appConfig.write(key, defaultConfig.read(key));
+      config = config.write(key, defaultConfig.read(key));
     }
+    snapshot = config;
   }
 
   Future<void> write<T, U extends T>(SettingsKey<T> key, U value) async {
-    if (value == _appConfig.read(key)) {
+    if (value == snapshot.read(key)) {
       return;
     }
 
@@ -65,29 +78,8 @@ class SettingsRepository extends DriftDatabaseRepository {
         .insertOnConflictUpdate(
           SettingsEntityCompanion.insert(key: key.name, value: .new(resolvedValue), updatedAt: .new(DateTime.now())),
         );
-    _appConfig = _appConfig.write(key, value);
+    snapshot = snapshot.write(key, value);
   }
 
-  Stream<AppConfig> watchConfig() => _db.select(_db.settingsEntity).watch().map((rows) {
-    _applyOverrides(rows);
-    return _appConfig;
-  });
-
-  void _applyOverrides(List<SettingsEntityData> rows) {
-    _appConfig = AppConfig.fromEntries(
-      rows.fold({}, (overrides, row) {
-        final metadataKey = SettingsKey.values.firstWhereOrNull((key) => key.name == row.key);
-        if (metadataKey == null) {
-          return overrides;
-        }
-
-        Object? decodedValue;
-        if (row.value != null) {
-          decodedValue = metadataKey.decode(row.value!);
-        }
-
-        return {...overrides, metadataKey: decodedValue};
-      }),
-    );
-  }
+  Stream<AppConfig> watchConfig() => watchSnapshot();
 }

mobile/lib/presentation/pages/drift_slideshow.page.dart

@@ -51,6 +51,7 @@ class _DriftSlideshowPageState extends ConsumerState<DriftSlideshowPage> with Si
   int? _crossfadeFromIndex;
   int? _crossfadeToIndex;
   int _zoomCycle = 0;
+  bool _disableAnimations = false;
 
   @override
   initState() {
@@ -70,6 +71,12 @@ class _DriftSlideshowPageState extends ConsumerState<DriftSlideshowPage> with Si
     unawaited(WakelockPlus.enable());
   }
 
+  @override
+  void didChangeDependencies() {
+    super.didChangeDependencies();
+    _disableAnimations = MediaQuery.disableAnimationsOf(context);
+  }
+
   @override
   dispose() {
     _timer.cancel();
@@ -166,6 +173,11 @@ class _DriftSlideshowPageState extends ConsumerState<DriftSlideshowPage> with Si
   }
 
   void _crossFadeToPage(int page) {
+    if (_disableAnimations) {
+      _pageController.jumpToPage(page);
+      return;
+    }
+
     final previousIndex = _index;
     _pageController.jumpToPage(page);
     setState(() {
@@ -273,19 +285,12 @@ class _DriftSlideshowPageState extends ConsumerState<DriftSlideshowPage> with Si
     }
 
     if (asset.isImage) {
-      final elapsed = _stopwatch.elapsedMilliseconds;
-      final duration = _config.duration * 1000;
-
-      return TweenAnimationBuilder(
+      return _SlideshowProgressBar(
         key: Key(_index.toString()),
-        tween: Tween<double>(begin: elapsed / duration.toDouble(), end: _paused ? elapsed / duration.toDouble() : 1.0),
-        duration: Duration(milliseconds: _paused ? 1 : max(duration - elapsed, 1)),
-        builder: (context, value, _) => LinearProgressIndicator(
-          color: context.colorScheme.primary,
-          borderRadius: const BorderRadius.all(Radius.zero),
-          minHeight: 5,
-          value: value,
-        ),
+        durationMs: _config.duration * 1000,
+        elapsedMs: _stopwatch.elapsedMilliseconds,
+        paused: _paused,
+        color: context.colorScheme.primary,
       );
     } else {
       return LinearProgressIndicator(
@@ -334,6 +339,21 @@ class _DriftSlideshowPageState extends ConsumerState<DriftSlideshowPage> with Si
     final imageProvider = getFullImageProvider(asset, size: context.sizeData);
 
     if (asset.isImage) {
+      PhotoView buildPhotoView(PhotoViewComputedScale initialScale) => PhotoView(
+        imageProvider: imageProvider,
+        index: index,
+        disableScaleGestures: true,
+        gaplessPlayback: true,
+        filterQuality: FilterQuality.high,
+        initialScale: initialScale,
+        controller: PhotoViewController(),
+        onTapUp: (_, _, _) => _onTapUp(),
+      );
+
+      if (_disableAnimations) {
+        return buildPhotoView(scale);
+      }
+
       final zoomOut = _zoomCycle.isOdd;
       final elapsed = _stopwatch.elapsedMilliseconds;
       final duration = _config.duration * 1000;
@@ -349,16 +369,7 @@ class _DriftSlideshowPageState extends ConsumerState<DriftSlideshowPage> with Si
               : 1.0,
         ),
         duration: Duration(milliseconds: _paused ? 1 : max(duration - elapsed, 1)),
-        builder: (context, value, _) => PhotoView(
-          imageProvider: imageProvider,
-          index: index,
-          disableScaleGestures: true,
-          gaplessPlayback: true,
-          filterQuality: FilterQuality.high,
-          initialScale: scale * (1.0 + value * _kenBurnsZoom),
-          controller: PhotoViewController(),
-          onTapUp: (_, _, _) => _onTapUp(),
-        ),
+        builder: (context, value, _) => buildPhotoView(scale * (1.0 + value * _kenBurnsZoom)),
       );
     } else {
       final status = ref.watch(videoPlayerProvider(asset.heroTag).select((s) => s.status));
@@ -463,3 +474,75 @@ class _DriftSlideshowPageState extends ConsumerState<DriftSlideshowPage> with Si
     );
   }
 }
+
+/// Progress bar for image slides, driven by an explicit [AnimationController].
+///
+/// [TweenAnimationBuilder] creates its controller internally with the default
+/// [AnimationBehavior.normal], which makes it run ~20x too fast while the system
+/// "reduce motion" setting is on (flutter/flutter#164287). This owns its
+/// controller so it can use [AnimationBehavior.preserve] and animate at the real
+/// slide duration regardless of that setting.
+class _SlideshowProgressBar extends StatefulWidget {
+  final int durationMs;
+  final int elapsedMs;
+  final bool paused;
+  final Color color;
+
+  const _SlideshowProgressBar({
+    super.key,
+    required this.durationMs,
+    required this.elapsedMs,
+    required this.paused,
+    required this.color,
+  });
+
+  @override
+  State<_SlideshowProgressBar> createState() => _SlideshowProgressBarState();
+}
+
+class _SlideshowProgressBarState extends State<_SlideshowProgressBar> with SingleTickerProviderStateMixin {
+  late final AnimationController _controller;
+
+  @override
+  void initState() {
+    super.initState();
+    _controller = AnimationController(
+      vsync: this,
+      duration: Duration(milliseconds: widget.durationMs),
+      animationBehavior: AnimationBehavior.preserve,
+    )..value = (widget.elapsedMs / widget.durationMs).clamp(0.0, 1.0);
+    if (!widget.paused) {
+      _controller.forward();
+    }
+  }
+
+  @override
+  void didUpdateWidget(_SlideshowProgressBar oldWidget) {
+    super.didUpdateWidget(oldWidget);
+    if (widget.durationMs != oldWidget.durationMs) {
+      _controller.duration = Duration(milliseconds: widget.durationMs);
+    }
+    if (widget.paused != oldWidget.paused) {
+      widget.paused ? _controller.stop() : _controller.forward();
+    }
+  }
+
+  @override
+  void dispose() {
+    _controller.dispose();
+    super.dispose();
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return AnimatedBuilder(
+      animation: _controller,
+      builder: (context, _) => LinearProgressIndicator(
+        color: widget.color,
+        borderRadius: const BorderRadius.all(Radius.zero),
+        minHeight: 5,
+        value: _controller.value,
+      ),
+    );
+  }
+}

mobile/lib/presentation/widgets/action_buttons/delete_action_button.widget.dart

@@ -2,11 +2,13 @@ import 'package:flutter/material.dart';
 import 'package:fluttertoast/fluttertoast.dart';
 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/domain/models/events.model.dart';
 import 'package:immich_mobile/domain/utils/event_stream.dart';
 import 'package:immich_mobile/extensions/build_context_extensions.dart';
 import 'package:immich_mobile/extensions/translate_extensions.dart';
 import 'package:immich_mobile/presentation/widgets/action_buttons/base_action_button.widget.dart';
+import 'package:immich_mobile/providers/asset_viewer/asset_viewer.provider.dart';
 import 'package:immich_mobile/providers/infrastructure/action.provider.dart';
 import 'package:immich_mobile/providers/timeline/multiselect.provider.dart';
 import 'package:immich_mobile/widgets/common/immich_toast.dart';
@@ -59,13 +61,19 @@ class DeleteActionButton extends ConsumerWidget {
       }
     }
 
-    if (source == ActionSource.viewer) {
-      EventStream.shared.emit(const ViewerReloadAssetEvent());
-    }
+    final currentAsset = ref.read(assetViewerProvider).currentAsset;
+    final stackIndex = ref.read(assetViewerProvider).stackIndex;
 
     final result = await ref.read(actionProvider.notifier).trashRemoteAndDeleteLocal(source);
     ref.read(multiSelectProvider.notifier).reset();
 
+    if (source == ActionSource.viewer && result.success) {
+      final shouldRefreshStack = currentAsset is RemoteAsset && currentAsset.stackId != null;
+      EventStream.shared.emit(
+        shouldRefreshStack ? ViewerStackAssetDeletedEvent(stackIndex: stackIndex) : const ViewerReloadAssetEvent(),
+      );
+    }
+
     final successMessage = 'delete_action_prompt'.t(context: context, args: {'count': result.count.toString()});
 
     if (context.mounted) {

mobile/lib/presentation/widgets/asset_viewer/asset_page.widget.dart

@@ -413,7 +413,8 @@ class _AssetPageState extends ConsumerState<AssetPage> {
     final showAssetStack = ref.watch(timelineServiceProvider.select((s) => s.origin != TimelineOrigin.trash));
     final stackChildren = showAssetStack ? ref.watch(stackChildrenNotifier(asset)).valueOrNull : null;
     if (stackChildren != null && stackChildren.isNotEmpty) {
-      displayAsset = stackChildren.elementAt(stackIndex);
+      final safeStackIndex = stackIndex.clamp(0, stackChildren.length - 1);
+      displayAsset = stackChildren.elementAt(safeStackIndex);
     }
 
     final isCurrent = currentAsset != null && currentAsset.refersToSameAsset(displayAsset);

mobile/lib/presentation/widgets/asset_viewer/asset_stack.provider.dart

@@ -11,6 +11,10 @@ class StackChildrenNotifier extends AutoDisposeFamilyAsyncNotifier<List<RemoteAs
 
     return ref.watch(assetServiceProvider).getStack(asset);
   }
+
+  void setStack(List<RemoteAsset> stack) {
+    state = AsyncData(stack);
+  }
 }
 
 final stackChildrenNotifier = AsyncNotifierProvider.autoDispose

mobile/lib/presentation/widgets/asset_viewer/asset_viewer.page.dart

@@ -1,4 +1,5 @@
 import 'dart:async';
+import 'dart:math' as math;
 
 import 'package:auto_route/auto_route.dart';
 import 'package:easy_localization/easy_localization.dart';
@@ -221,6 +222,8 @@ class _AssetViewerState extends ConsumerState<AssetViewer> {
         _onTimelineReloadEvent();
       case ViewerReloadAssetEvent():
         _onViewerReloadEvent();
+      case ViewerStackAssetDeletedEvent event:
+        _onViewerStackAssetDeletedEvent(event);
       default:
     }
   }
@@ -236,6 +239,33 @@ class _AssetViewerState extends ConsumerState<AssetViewer> {
     _onAssetChanged(target);
   }
 
+  Future<void> _onViewerStackAssetDeletedEvent(ViewerStackAssetDeletedEvent event) async {
+    final timelineAsset = ref.read(timelineServiceProvider).getAssetSafe(_currentPage);
+    if (timelineAsset == null) {
+      _onViewerReloadEvent();
+      return;
+    }
+
+    final stackProvider = stackChildrenNotifier(timelineAsset);
+
+    ref.invalidate(stackProvider);
+    final stack = await ref.read(stackProvider.future);
+
+    if (!mounted) {
+      return;
+    }
+
+    if (stack.isEmpty) {
+      _onViewerReloadEvent();
+      return;
+    }
+
+    final targetIndex = math.min(event.stackIndex, stack.length - 1);
+    ref.read(assetViewerProvider.notifier)
+      ..setAsset(stack[targetIndex])
+      ..setStackIndex(targetIndex);
+  }
+
   void _onTimelineReloadEvent() {
     final timelineService = ref.read(timelineServiceProvider);
     final totalAssets = timelineService.totalAssets;
@@ -252,6 +282,11 @@ class _AssetViewerState extends ConsumerState<AssetViewer> {
     if (index != _currentPage) {
       _pageController.jumpToPage(index);
       _onAssetChanged(index);
+    } else if (currentAsset is RemoteAsset && currentAsset.stackId != null && assetIndex == null) {
+      final timelineAsset = timelineService.getAssetSafe(index);
+      if (timelineAsset is! RemoteAsset || currentAsset.stackId != timelineAsset.stackId) {
+        _onAssetChanged(index);
+      }
     } else if (currentAsset != null && assetIndex == null) {
       _onAssetChanged(index);
     }

mobile/lib/presentation/widgets/asset_viewer/bottom_bar.widget.dart

@@ -101,7 +101,7 @@ class ViewerBottomBar extends ConsumerWidget {
                       child: Column(
                         mainAxisSize: MainAxisSize.min,
                         children: [
-                          OcrToggleButton(asset: asset),
+                          if (asset.isImage) OcrToggleButton(asset: asset),
                           if (asset.isVideo) VideoControls(videoPlayerName: asset.heroTag),
                           if (!isReadonlyModeEnabled)
                             Row(mainAxisAlignment: MainAxisAlignment.spaceEvenly, children: actions),

mobile/lib/presentation/widgets/map/map.widget.dart

@@ -16,7 +16,6 @@ import 'package:immich_mobile/presentation/widgets/bottom_sheet/map_bottom_sheet
 import 'package:immich_mobile/presentation/widgets/map/map.state.dart';
 import 'package:immich_mobile/presentation/widgets/map/map_utils.dart';
 import 'package:immich_mobile/providers/routes.provider.dart';
-import 'package:immich_mobile/routing/router.dart';
 import 'package:immich_mobile/utils/async_mutex.dart';
 import 'package:immich_mobile/utils/debounce.dart';
 import 'package:immich_mobile/widgets/common/immich_toast.dart';
@@ -133,8 +132,7 @@ class _DriftMapState extends ConsumerState<DriftMap> {
     // When the AssetViewer is open, the DriftMap route stays alive in the background.
     // If we continue to update bounds, the map-scoped timeline service gets recreated and the previous one disposed,
     // which can invalidate the TimelineService instance that was passed into AssetViewerRoute (causing "loading forever").
-    final currentRoute = ref.read(currentRouteNameProvider);
-    if (currentRoute == AssetViewerRoute.name) {
+    if (ref.read(isAssetViewerOpenProvider)) {
       return;
     }
 
@@ -183,6 +181,11 @@ class _DriftMapState extends ConsumerState<DriftMap> {
 
   @override
   Widget build(BuildContext context) {
+    ref.listen<bool>(isAssetViewerOpenProvider, (previous, current) {
+      if (previous == true && !current) {
+        _debouncer.run(() => setBounds(forceReload: true));
+      }
+    });
     return Stack(
       children: [
         _Map(initialLocation: widget.initialLocation, onMapCreated: onMapCreated, onMapReady: onMapReady),

mobile/lib/providers/routes.provider.dart

@@ -2,6 +2,7 @@ import 'package:flutter/widgets.dart';
 import 'package:hooks_riverpod/hooks_riverpod.dart';
 
 final inLockedViewProvider = StateProvider<bool>((ref) => false);
+final isAssetViewerOpenProvider = StateProvider<bool>((ref) => false);
 final currentRouteNameProvider = StateProvider<String?>((ref) => null);
 final previousRouteNameProvider = StateProvider<String?>((ref) => null);
 final previousRouteDataProvider = StateProvider<RouteSettings?>((ref) => null);

mobile/lib/routing/app_navigation_observer.dart

@@ -24,9 +24,20 @@ class AppNavigationObserver extends AutoRouterObserver {
       ref.read(currentRouteNameProvider.notifier).state = route.settings.name;
       ref.read(previousRouteNameProvider.notifier).state = previousRoute?.settings.name;
       ref.read(previousRouteDataProvider.notifier).state = previousRoute?.settings;
+      if (route.settings.name == AssetViewerRoute.name) {
+        ref.read(isAssetViewerOpenProvider.notifier).state = true;
+      }
     });
   }
 
+  @override
+  void didPop(Route route, Route? previousRoute) {
+    _handleDriftLockedFolderState(previousRoute ?? route, null);
+    if (route.settings.name == AssetViewerRoute.name) {
+      Future(() => ref.read(isAssetViewerOpenProvider.notifier).state = false);
+    }
+  }
+
   _handleDriftLockedFolderState(Route route, Route? previousRoute) {
     final isInLockedView = ref.read(inLockedViewProvider);
     final isFromLockedViewToDetailView =

server/src/services/auth.service.spec.ts

@@ -1140,6 +1140,125 @@ describe(AuthService.name, () => {
 
       expect(mocks.user.create).toHaveBeenCalledWith(expect.objectContaining({ isAdmin: true }));
     });
+
+    it('should create an admin user if the role claim is an array containing admin', async () => {
+      mocks.systemMetadata.get.mockResolvedValue(systemConfigStub.oauthWithAutoRegister);
+      mocks.oauth.getProfileAndOAuthSid.mockResolvedValue({
+        profile: OAuthProfileFactory.create({ immich_role: ['user', 'admin'] }),
+      });
+      mocks.user.getByEmail.mockResolvedValue(void 0);
+      mocks.user.getByOAuthId.mockResolvedValue(void 0);
+      mocks.user.create.mockResolvedValue(UserFactory.create({ oauthId: 'oauth-id' }));
+      mocks.session.create.mockResolvedValue(SessionFactory.create());
+
+      await sut.callback(
+        { url: 'http://immich/auth/login?code=abc123', state: 'xyz789', codeVerifier: 'foo' },
+        {},
+        loginDetails,
+      );
+
+      expect(mocks.user.create).toHaveBeenCalledWith(expect.objectContaining({ isAdmin: true }));
+    });
+
+    it('should create a standard user if the role claim is an array containing only user', async () => {
+      mocks.systemMetadata.get.mockResolvedValue(systemConfigStub.oauthWithAutoRegister);
+      mocks.oauth.getProfileAndOAuthSid.mockResolvedValue({
+        profile: OAuthProfileFactory.create({ immich_role: ['user'] }),
+      });
+      mocks.user.getByEmail.mockResolvedValue(void 0);
+      mocks.user.getByOAuthId.mockResolvedValue(void 0);
+      mocks.user.getAdmin.mockResolvedValue(UserFactory.create({ isAdmin: true }));
+      mocks.user.create.mockResolvedValue(UserFactory.create({ oauthId: 'oauth-id' }));
+      mocks.session.create.mockResolvedValue(SessionFactory.create());
+
+      await sut.callback(
+        { url: 'http://immich/auth/login?code=abc123', state: 'xyz789', codeVerifier: 'foo' },
+        {},
+        loginDetails,
+      );
+
+      expect(mocks.user.create).toHaveBeenCalledWith(expect.objectContaining({ isAdmin: false }));
+    });
+
+    it('should promote an existing user to admin if the role claim contains admin on login', async () => {
+      const user = UserFactory.create({ isAdmin: false, oauthId: 'oauth-id' });
+
+      mocks.systemMetadata.get.mockResolvedValue(systemConfigStub.oauthEnabled);
+      mocks.oauth.getProfileAndOAuthSid.mockResolvedValue({
+        profile: OAuthProfileFactory.create({ sub: user.oauthId, immich_role: 'admin' }),
+      });
+      mocks.user.getByOAuthId.mockResolvedValue(user);
+      mocks.user.update.mockResolvedValue({ ...user, isAdmin: true });
+      mocks.session.create.mockResolvedValue(SessionFactory.create());
+
+      await sut.callback(
+        { url: 'http://immich/auth/login?code=abc123', state: 'xyz789', codeVerifier: 'foo' },
+        {},
+        loginDetails,
+      );
+
+      expect(mocks.user.update).toHaveBeenCalledWith(user.id, { isAdmin: true });
+    });
+
+    it('should demote an existing admin if the role claim only contains user on login', async () => {
+      const user = UserFactory.create({ isAdmin: true, oauthId: 'oauth-id' });
+
+      mocks.systemMetadata.get.mockResolvedValue(systemConfigStub.oauthEnabled);
+      mocks.oauth.getProfileAndOAuthSid.mockResolvedValue({
+        profile: OAuthProfileFactory.create({ sub: user.oauthId, immich_role: ['user'] }),
+      });
+      mocks.user.getByOAuthId.mockResolvedValue(user);
+      mocks.user.update.mockResolvedValue({ ...user, isAdmin: false });
+      mocks.session.create.mockResolvedValue(SessionFactory.create());
+
+      await sut.callback(
+        { url: 'http://immich/auth/login?code=abc123', state: 'xyz789', codeVerifier: 'foo' },
+        {},
+        loginDetails,
+      );
+
+      expect(mocks.user.update).toHaveBeenCalledWith(user.id, { isAdmin: false });
+    });
+
+    it('should not change isAdmin for an existing user if the role claim is blank', async () => {
+      const user = UserFactory.create({ isAdmin: true, oauthId: 'oauth-id' });
+
+      mocks.systemMetadata.get.mockResolvedValue(systemConfigStub.oauthEnabled);
+      mocks.oauth.getProfileAndOAuthSid.mockResolvedValue({
+        profile: OAuthProfileFactory.create({ sub: user.oauthId }),
+      });
+      mocks.user.getByOAuthId.mockResolvedValue(user);
+      mocks.session.create.mockResolvedValue(SessionFactory.create());
+
+      await sut.callback(
+        { url: 'http://immich/auth/login?code=abc123', state: 'xyz789', codeVerifier: 'foo' },
+        {},
+        loginDetails,
+      );
+
+      expect(mocks.user.update).not.toHaveBeenCalled();
+    });
+
+    it('should re-evaluate the role claim for a user linked by email', async () => {
+      const user = UserFactory.create({ isAdmin: false });
+      const profile = OAuthProfileFactory.create({ immich_role: 'admin' });
+
+      mocks.systemMetadata.get.mockResolvedValue(systemConfigStub.oauthEnabled);
+      mocks.oauth.getProfileAndOAuthSid.mockResolvedValue({ profile });
+      mocks.user.getByEmail.mockResolvedValue(user);
+      mocks.user.update.mockResolvedValueOnce({ ...user, oauthId: profile.sub });
+      mocks.user.update.mockResolvedValueOnce({ ...user, oauthId: profile.sub, isAdmin: true });
+      mocks.session.create.mockResolvedValue(SessionFactory.create());
+
+      await sut.callback(
+        { url: 'http://immich/auth/login?code=abc123', state: 'xyz789', codeVerifier: 'foobar' },
+        {},
+        loginDetails,
+      );
+
+      expect(mocks.user.update).toHaveBeenCalledWith(user.id, { oauthId: profile.sub });
+      expect(mocks.user.update).toHaveBeenCalledWith(user.id, { isAdmin: true });
+    });
   });
 
   describe('link', () => {

server/src/services/auth.service.ts

@@ -331,6 +331,13 @@ export class AuthService extends BaseService {
       }
     }
 
+    const role = this.getRoleClaim(profile, roleClaim);
+    const isAdmin = role === 'admin';
+
+    if (user && role && isAdmin !== user.isAdmin) {
+      user = await this.userRepository.update(user.id, { isAdmin });
+    }
+
     // register new user
     if (!user) {
       if (!autoRegister) {
@@ -356,11 +363,6 @@ export class AuthService extends BaseService {
         default: defaultStorageQuota,
         isValid: (value: unknown) => Number(value) >= 0,
       });
-      const role = this.getClaim<'admin' | 'user'>(profile, {
-        key: roleClaim,
-        default: 'user',
-        isValid: (value: unknown) => typeof value === 'string' && ['admin', 'user'].includes(value),
-      });
 
       user = await this.createUser({
         name:
@@ -372,7 +374,7 @@ export class AuthService extends BaseService {
         oauthId: profile.sub,
         quotaSizeInBytes: storageQuota === null ? null : storageQuota * HumanReadableSize.GiB,
         storageLabel: storageLabel || null,
-        isAdmin: role === 'admin',
+        isAdmin,
       });
     }
 
@@ -641,6 +643,19 @@ export class AuthService extends BaseService {
     return options.isValid(value) ? (value as T) : options.default;
   }
 
+  private getRoleClaim(profile: OAuthProfile, roleClaim: string): 'admin' | 'user' | undefined {
+    const value = profile[roleClaim as keyof OAuthProfile];
+    const roles = Array.isArray(value) ? value : [value];
+    const isRole = (role: string) => roles.includes(role);
+
+    if (isRole('admin')) {
+      return 'admin';
+    }
+    if (isRole('user')) {
+      return 'user';
+    }
+  }
+
   private resolveRedirectUri(
     { mobileRedirectUri, mobileOverrideEnabled }: { mobileRedirectUri: string; mobileOverrideEnabled: boolean },
     url: string,