Refactor preferences

lib/core/utils/preferences_utils.dart

@@ -0,0 +1,156 @@
+import 'package:hiddify/core/preferences/preferences_provider.dart';
+import 'package:hiddify/utils/custom_loggers.dart';
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+import 'package:shared_preferences/shared_preferences.dart';
+
+class PreferencesEntry<T, P> with InfraLogger {
+  PreferencesEntry({
+    required this.preferences,
+    required this.key,
+    required this.defaultValue,
+    this.mapFrom,
+    this.mapTo,
+    this.validator,
+  });
+
+  final SharedPreferences preferences;
+  final String key;
+  final T defaultValue;
+  final T Function(P value)? mapFrom;
+  final P Function(T value)? mapTo;
+  final bool Function(T value)? validator;
+
+  T read() {
+    try {
+      loggy.debug("getting persisted preference [$key]($T)");
+      final T value;
+      if (mapFrom != null) {
+        final persisted = preferences.get(key) as P?;
+        if (persisted == null) {
+          value = defaultValue;
+        } else {
+          value = mapFrom!(persisted);
+        }
+      } else if (T == List<String>) {
+        value = preferences.getStringList(key) as T? ?? defaultValue;
+      } else {
+        value = preferences.get(key) as T? ?? defaultValue;
+      }
+
+      if (validator?.call(value) ?? true) return value;
+      return defaultValue;
+    } catch (e, stackTrace) {
+      loggy.warning("error getting preference[$key]: $e", e, stackTrace);
+      return defaultValue;
+    }
+  }
+
+  Future<bool> write(T value) async {
+    Object? mapped = value;
+    if (mapTo != null) {
+      mapped = mapTo!(value);
+    }
+    loggy.debug("updating preference [$key]($T) to [$mapped]");
+    try {
+      if (!(validator?.call(value) ?? true)) {
+        loggy.warning("invalid value [$value] for preference [$key]($T)");
+        return false;
+      }
+
+      return switch (mapped) {
+        final String value => await preferences.setString(key, value),
+        final bool value => await preferences.setBool(key, value),
+        final int value => await preferences.setInt(key, value),
+        final double value => await preferences.setDouble(key, value),
+        final List<String> value => await preferences.setStringList(key, value),
+        _ => throw const FormatException("Invalid Type"),
+      };
+    } catch (e, stackTrace) {
+      loggy.warning("error updating preference[$key]: $e", e, stackTrace);
+      return false;
+    }
+  }
+
+  Future<void> remove() async {
+    try {
+      await preferences.remove(key);
+    } catch (e, stackTrace) {
+      loggy.warning("error removing preference[$key]: $e", e, stackTrace);
+    }
+  }
+}
+
+class PreferencesNotifier<T, P> extends StateNotifier<T> {
+  PreferencesNotifier._({
+    required Ref ref,
+    required this.entry,
+    this.overrideValue,
+  })  : _ref = ref,
+        super(overrideValue ?? entry.read());
+
+  final Ref _ref;
+  final PreferencesEntry<T, P> entry;
+  final T? overrideValue;
+
+  static StateNotifierProvider<PreferencesNotifier<T, P>, T> create<T, P>(
+    String key,
+    T defaultValue, {
+    T Function(P value)? mapFrom,
+    P Function(T value)? mapTo,
+    bool Function(T value)? validator,
+    T? overrideValue,
+  }) =>
+      StateNotifierProvider(
+        (ref) => PreferencesNotifier._(
+          ref: ref,
+          entry: PreferencesEntry<T, P>(
+            preferences: ref.read(sharedPreferencesProvider).requireValue,
+            key: key,
+            defaultValue: defaultValue,
+            mapFrom: mapFrom,
+            mapTo: mapTo,
+            validator: validator,
+          ),
+          overrideValue: overrideValue,
+        ),
+      );
+
+  static AutoDisposeStateNotifierProvider<PreferencesNotifier<T, P>, T>
+      createAutoDispose<T, P>(
+    String key,
+    T defaultValue, {
+    T Function(P value)? mapFrom,
+    P Function(T value)? mapTo,
+    bool Function(T value)? validator,
+    T? overrideValue,
+  }) =>
+          StateNotifierProvider.autoDispose(
+            (ref) => PreferencesNotifier._(
+              ref: ref,
+              entry: PreferencesEntry<T, P>(
+                preferences: ref.read(sharedPreferencesProvider).requireValue,
+                key: key,
+                defaultValue: defaultValue,
+                mapFrom: mapFrom,
+                mapTo: mapTo,
+                validator: validator,
+              ),
+              overrideValue: overrideValue,
+            ),
+          );
+
+  P raw() {
+    final value = overrideValue ?? state;
+    if (entry.mapTo != null) return entry.mapTo!(value);
+    return value as P;
+  }
+
+  Future<void> update(T value) async {
+    if (await entry.write(value)) state = value;
+  }
+
+  Future<void> reset() async {
+    await entry.remove();
+    _ref.invalidateSelf();
+  }
+}