refactor(mobile): remove shared module (#9363)

mobile/lib/utils/cache/custom_image_cache.dart

@@ -0,0 +1,80 @@
+import 'package:flutter/painting.dart';
+import 'package:immich_mobile/providers/image/immich_local_image_provider.dart';
+import 'package:immich_mobile/providers/image/immich_local_thumbnail_provider.dart';
+import 'package:immich_mobile/providers/image/immich_remote_image_provider.dart';
+import 'package:immich_mobile/providers/image/immich_remote_thumbnail_provider.dart';
+
+/// [ImageCache] that uses two caches for small and large images
+/// so that a single large image does not evict all small iamges
+final class CustomImageCache implements ImageCache {
+  final _small = ImageCache();
+  final _large = ImageCache()..maximumSize = 5; // Maximum 5 images
+
+  @override
+  int get maximumSize => _small.maximumSize + _large.maximumSize;
+
+  @override
+  int get maximumSizeBytes => _small.maximumSizeBytes + _large.maximumSizeBytes;
+
+  @override
+  set maximumSize(int value) => _small.maximumSize = value;
+
+  @override
+  set maximumSizeBytes(int value) => _small.maximumSize = value;
+
+  @override
+  void clear() {
+    _small.clear();
+    _large.clear();
+  }
+
+  @override
+  void clearLiveImages() {
+    _small.clearLiveImages();
+    _large.clearLiveImages();
+  }
+
+  /// Gets the cache for the given key
+  /// [_large] is used for [ImmichLocalImageProvider] and [ImmichRemoteImageProvider]
+  /// [_small] is used for [ImmichLocalThumbnailProvider] and [ImmichRemoteThumbnailProvider]
+  ImageCache _cacheForKey(Object key) =>
+      (key is ImmichLocalImageProvider || key is ImmichRemoteImageProvider)
+          ? _large
+          : _small;
+
+  @override
+  bool containsKey(Object key) {
+    // [ImmichLocalImageProvider] and [ImmichRemoteImageProvider] are both
+    // large size images while the other thumbnail providers are small
+    return _cacheForKey(key).containsKey(key);
+  }
+
+  @override
+  int get currentSize => _small.currentSize + _large.currentSize;
+
+  @override
+  int get currentSizeBytes => _small.currentSizeBytes + _large.currentSizeBytes;
+
+  @override
+  bool evict(Object key, {bool includeLive = true}) =>
+      _cacheForKey(key).evict(key, includeLive: includeLive);
+
+  @override
+  int get liveImageCount => _small.liveImageCount + _large.liveImageCount;
+
+  @override
+  int get pendingImageCount =>
+      _small.pendingImageCount + _large.pendingImageCount;
+
+  @override
+  ImageStreamCompleter? putIfAbsent(
+    Object key,
+    ImageStreamCompleter Function() loader, {
+    ImageErrorListener? onError,
+  }) =>
+      _cacheForKey(key).putIfAbsent(key, loader, onError: onError);
+
+  @override
+  ImageCacheStatus statusForKey(Object key) =>
+      _cacheForKey(key).statusForKey(key);
+}

mobile/lib/utils/cache/widgets_binding.dart

@@ -0,0 +1,8 @@
+import 'package:flutter/widgets.dart';
+
+import 'custom_image_cache.dart';
+
+final class ImmichWidgetsBinding extends WidgetsFlutterBinding {
+  @override
+  ImageCache createImageCache() => CustomImageCache();
+}

mobile/lib/utils/hooks/app_settings_update_hook.dart

@@ -0,0 +1,18 @@
+import 'package:flutter/cupertino.dart';
+import 'package:flutter_hooks/flutter_hooks.dart' hide Store;
+import 'package:immich_mobile/services/app_settings.service.dart';
+import 'package:immich_mobile/entities/store.entity.dart';
+
+ValueNotifier<T> useAppSettingsState<T>(
+  AppSettingsEnum<T> key,
+) {
+  final notifier = useState<T>(Store.get(key.storeKey, key.defaultValue));
+
+  // Listen to changes to the notifier and update app settings
+  useValueChanged(
+    notifier.value,
+    (_, __) => Store.put(key.storeKey, notifier.value),
+  );
+
+  return notifier;
+}

mobile/lib/utils/hooks/blurhash_hook.dart

@@ -0,0 +1,17 @@
+import 'dart:convert';
+import 'dart:typed_data';
+import 'package:flutter_hooks/flutter_hooks.dart';
+import 'package:immich_mobile/entities/asset.entity.dart';
+import 'package:thumbhash/thumbhash.dart' as thumbhash;
+
+ObjectRef<Uint8List?> useBlurHashRef(Asset? asset) {
+  if (asset?.thumbhash == null) {
+    return useRef(null);
+  }
+
+  final rbga = thumbhash.thumbHashToRGBA(
+    base64Decode(asset!.thumbhash!),
+  );
+
+  return useRef(thumbhash.rgbaToBmp(rbga));
+}

mobile/lib/utils/hooks/chewiew_controller_hook.dart

@@ -0,0 +1,156 @@
+import 'package:chewie/chewie.dart';
+import 'package:flutter/material.dart';
+import 'package:flutter_hooks/flutter_hooks.dart';
+import 'package:video_player/video_player.dart';
+
+/// Provides the initialized video player controller
+/// If the asset is local, use the local file
+/// Otherwise, use a video player with a URL
+ChewieController useChewieController({
+  required VideoPlayerController controller,
+  EdgeInsets controlsSafeAreaMinimum = const EdgeInsets.only(
+    bottom: 100,
+  ),
+  bool showOptions = true,
+  bool showControlsOnInitialize = false,
+  bool autoPlay = true,
+  bool allowFullScreen = false,
+  bool allowedScreenSleep = false,
+  bool showControls = true,
+  Widget? customControls,
+  Widget? placeholder,
+  Duration hideControlsTimer = const Duration(seconds: 1),
+  VoidCallback? onPlaying,
+  VoidCallback? onPaused,
+  VoidCallback? onVideoEnded,
+}) {
+  return use(
+    _ChewieControllerHook(
+      controller: controller,
+      placeholder: placeholder,
+      showOptions: showOptions,
+      controlsSafeAreaMinimum: controlsSafeAreaMinimum,
+      autoPlay: autoPlay,
+      allowFullScreen: allowFullScreen,
+      customControls: customControls,
+      hideControlsTimer: hideControlsTimer,
+      showControlsOnInitialize: showControlsOnInitialize,
+      showControls: showControls,
+      allowedScreenSleep: allowedScreenSleep,
+      onPlaying: onPlaying,
+      onPaused: onPaused,
+      onVideoEnded: onVideoEnded,
+    ),
+  );
+}
+
+class _ChewieControllerHook extends Hook<ChewieController> {
+  final VideoPlayerController controller;
+  final EdgeInsets controlsSafeAreaMinimum;
+  final bool showOptions;
+  final bool showControlsOnInitialize;
+  final bool autoPlay;
+  final bool allowFullScreen;
+  final bool allowedScreenSleep;
+  final bool showControls;
+  final Widget? customControls;
+  final Widget? placeholder;
+  final Duration hideControlsTimer;
+  final VoidCallback? onPlaying;
+  final VoidCallback? onPaused;
+  final VoidCallback? onVideoEnded;
+
+  const _ChewieControllerHook({
+    required this.controller,
+    this.controlsSafeAreaMinimum = const EdgeInsets.only(
+      bottom: 100,
+    ),
+    this.showOptions = true,
+    this.showControlsOnInitialize = false,
+    this.autoPlay = true,
+    this.allowFullScreen = false,
+    this.allowedScreenSleep = false,
+    this.showControls = true,
+    this.customControls,
+    this.placeholder,
+    this.hideControlsTimer = const Duration(seconds: 3),
+    this.onPlaying,
+    this.onPaused,
+    this.onVideoEnded,
+  });
+
+  @override
+  createState() => _ChewieControllerHookState();
+}
+
+class _ChewieControllerHookState
+    extends HookState<ChewieController, _ChewieControllerHook> {
+  late ChewieController chewieController = ChewieController(
+    videoPlayerController: hook.controller,
+    controlsSafeAreaMinimum: hook.controlsSafeAreaMinimum,
+    showOptions: hook.showOptions,
+    showControlsOnInitialize: hook.showControlsOnInitialize,
+    autoPlay: hook.autoPlay,
+    allowFullScreen: hook.allowFullScreen,
+    allowedScreenSleep: hook.allowedScreenSleep,
+    showControls: hook.showControls,
+    customControls: hook.customControls,
+    placeholder: hook.placeholder,
+    hideControlsTimer: hook.hideControlsTimer,
+  );
+
+  @override
+  void dispose() {
+    chewieController.dispose();
+    super.dispose();
+  }
+
+  @override
+  ChewieController build(BuildContext context) {
+    return chewieController;
+  }
+
+  /*
+  /// Initializes the chewie controller and video player controller
+  Future<void> _initialize() async {
+    if (hook.asset.isLocal && hook.asset.livePhotoVideoId == null) {
+      // Use a local file for the video player controller
+      final file = await hook.asset.local!.file;
+      if (file == null) {
+        throw Exception('No file found for the video');
+      }
+      videoPlayerController = VideoPlayerController.file(file);
+    } else {
+      // Use a network URL for the video player controller
+      final serverEndpoint = store.Store.get(store.StoreKey.serverEndpoint);
+      final String videoUrl = hook.asset.livePhotoVideoId != null
+          ? '$serverEndpoint/asset/file/${hook.asset.livePhotoVideoId}'
+          : '$serverEndpoint/asset/file/${hook.asset.remoteId}';
+
+      final url = Uri.parse(videoUrl);
+      final accessToken = store.Store.get(StoreKey.accessToken);
+
+      videoPlayerController = VideoPlayerController.networkUrl(
+        url,
+        httpHeaders: {"x-immich-user-token": accessToken},
+      );
+    }
+
+    await videoPlayerController!.initialize();
+
+    chewieController = ChewieController(
+      videoPlayerController: videoPlayerController!,
+      controlsSafeAreaMinimum: hook.controlsSafeAreaMinimum,
+      showOptions: hook.showOptions,
+      showControlsOnInitialize: hook.showControlsOnInitialize,
+      autoPlay: hook.autoPlay,
+      allowFullScreen: hook.allowFullScreen,
+      allowedScreenSleep: hook.allowedScreenSleep,
+      showControls: hook.showControls,
+      customControls: hook.customControls,
+      placeholder: hook.placeholder,
+      hideControlsTimer: hook.hideControlsTimer,
+    );
+  }
+  */
+}

mobile/lib/utils/hooks/timer_hook.dart

@@ -0,0 +1,48 @@
+import 'package:async/async.dart';
+import 'package:flutter/material.dart';
+import 'package:flutter_hooks/flutter_hooks.dart';
+
+RestartableTimer useTimer(
+  Duration duration,
+  void Function() callback,
+) {
+  return use(
+    _TimerHook(
+      duration: duration,
+      callback: callback,
+    ),
+  );
+}
+
+class _TimerHook extends Hook<RestartableTimer> {
+  final Duration duration;
+  final void Function() callback;
+
+  const _TimerHook({
+    required this.duration,
+    required this.callback,
+  });
+  @override
+  HookState<RestartableTimer, Hook<RestartableTimer>> createState() =>
+      _TimerHookState();
+}
+
+class _TimerHookState extends HookState<RestartableTimer, _TimerHook> {
+  late RestartableTimer timer;
+  @override
+  void initHook() {
+    super.initHook();
+    timer = RestartableTimer(hook.duration, hook.callback);
+  }
+
+  @override
+  RestartableTimer build(BuildContext context) {
+    return timer;
+  }
+
+  @override
+  void dispose() {
+    timer.cancel();
+    super.dispose();
+  }
+}