Move exif settings to a separated page

app/lib/controller/pref_controller.dart

@@ -32,35 +32,51 @@ class PrefController {
   ValueStream<int> get albumBrowserZoomLevel =>
       _albumBrowserZoomLevelController.stream;
 
-  Future<void> setAlbumBrowserZoomLevel(int value) async {
-    final backup = _albumBrowserZoomLevelController.value;
-    _albumBrowserZoomLevelController.add(value);
-    try {
-      if (!await _c.pref.setAlbumBrowserZoomLevel(value)) {
-        throw StateError("Unknown error");
-      }
-    } catch (e, stackTrace) {
-      _log.severe("[setAlbumBrowserZoomLevel] Failed setting preference", e,
-          stackTrace);
-      _albumBrowserZoomLevelController
-        ..addError(e, stackTrace)
-        ..add(backup);
-    }
-  }
+  Future<void> setAlbumBrowserZoomLevel(int value) => _set<int>(
+        controller: _albumBrowserZoomLevelController,
+        setter: (pref, value) => pref.setAlbumBrowserZoomLevel(value),
+        value: value,
+      );
 
   ValueStream<int> get homeAlbumsSort => _homeAlbumsSortController.stream;
 
-  Future<void> setHomeAlbumsSort(int value) async {
-    final backup = _homeAlbumsSortController.value;
-    _homeAlbumsSortController.add(value);
+  Future<void> setHomeAlbumsSort(int value) => _set<int>(
+        controller: _homeAlbumsSortController,
+        setter: (pref, value) => pref.setHomeAlbumsSort(value),
+        value: value,
+      );
+
+  ValueStream<bool> get isEnableExif => _isEnableExifController.stream;
+
+  Future<void> setEnableExif(bool value) => _set<bool>(
+        controller: _isEnableExifController,
+        setter: (pref, value) => pref.setEnableExif(value),
+        value: value,
+      );
+
+  ValueStream<bool> get shouldProcessExifWifiOnly =>
+      _shouldProcessExifWifiOnlyController.stream;
+
+  Future<void> setProcessExifWifiOnly(bool value) => _set<bool>(
+        controller: _shouldProcessExifWifiOnlyController,
+        setter: (pref, value) => pref.setProcessExifWifiOnly(value),
+        value: value,
+      );
+
+  Future<void> _set<T>({
+    required BehaviorSubject<T> controller,
+    required Future<bool> Function(Pref pref, T value) setter,
+    required T value,
+  }) async {
+    final backup = controller.value;
+    controller.add(value);
     try {
-      if (!await _c.pref.setHomeAlbumsSort(value)) {
+      if (!await setter(_c.pref, value)) {
         throw StateError("Unknown error");
       }
     } catch (e, stackTrace) {
-      _log.severe(
-          "[setHomeAlbumsSort] Failed setting preference", e, stackTrace);
-      _homeAlbumsSortController
+      _log.severe("[_set] Failed setting preference", e, stackTrace);
+      controller
         ..addError(e, stackTrace)
         ..add(backup);
     }
@@ -87,4 +103,8 @@ class PrefController {
       BehaviorSubject.seeded(_c.pref.getAlbumBrowserZoomLevelOr(0));
   late final _homeAlbumsSortController =
       BehaviorSubject.seeded(_c.pref.getHomeAlbumsSortOr(0));
+  late final _isEnableExifController =
+      BehaviorSubject.seeded(_c.pref.isEnableExifOr(true));
+  late final _shouldProcessExifWifiOnlyController =
+      BehaviorSubject.seeded(_c.pref.shouldProcessExifWifiOnlyOr(true));
 }

app/lib/l10n/app_en.arb

@@ -270,6 +270,10 @@
 	"@settingsLanguageOptionSystemDefaultLabel": {
 		"description": "Follow the Android system language"
 	},
+	"settingsMetadataTitle": "File metadata",
+	"@settingsMetadataTitle": {
+		"description": "Metadata (e.g., date, resolution, GPS, etc)"
+	},
 	"settingsExifSupportTitle": "EXIF support",
 	"@settingsExifSupportTitle": {
 		"description": "Title of the EXIF support setting"

app/lib/widget/settings.dart

@@ -16,7 +16,6 @@ import 'package:nc_photos/mobile/platform.dart'
 import 'package:nc_photos/platform/features.dart' as features;
 import 'package:nc_photos/platform/k.dart' as platform_k;
 import 'package:nc_photos/platform/notification.dart';
-import 'package:nc_photos/service.dart';
 import 'package:nc_photos/snack_bar_manager.dart';
 import 'package:nc_photos/stream_util.dart';
 import 'package:nc_photos/url_launcher_util.dart';
@@ -26,6 +25,7 @@ import 'package:nc_photos/widget/list_tile_center_leading.dart';
 import 'package:nc_photos/widget/settings/developer_settings.dart';
 import 'package:nc_photos/widget/settings/expert_settings.dart';
 import 'package:nc_photos/widget/settings/language_settings.dart';
+import 'package:nc_photos/widget/settings/metadata_settings.dart';
 import 'package:nc_photos/widget/settings/settings_list_caption.dart';
 import 'package:nc_photos/widget/settings/theme_settings.dart';
 import 'package:nc_photos/widget/stateful_slider.dart';
@@ -70,9 +70,6 @@ class _SettingsState extends State<Settings> {
   @override
   initState() {
     super.initState();
-    _isEnableExif = Pref().isEnableExifOr();
-    _shouldProcessExifWifiOnly = Pref().shouldProcessExifWifiOnlyOr();
-
     _prefUpdatedListener.begin();
   }
 
@@ -115,23 +112,12 @@ class _SettingsState extends State<Settings> {
                   },
                 ),
               ),
-              SwitchListTile(
-                title: Text(L10n.global().settingsExifSupportTitle),
-                subtitle: _isEnableExif
-                    ? Text(L10n.global().settingsExifSupportTrueSubtitle)
-                    : null,
-                value: _isEnableExif,
-                onChanged: (value) => _onExifSupportChanged(context, value),
+              _buildSubSettings(
+                context,
+                leading: const Icon(Icons.local_offer_outlined),
+                label: L10n.global().settingsMetadataTitle,
+                builder: () => const MetadataSettings(),
               ),
-              if (platform_k.isMobile)
-                SwitchListTile(
-                  title: Text(L10n.global().settingsExifWifiOnlyTitle),
-                  subtitle: _shouldProcessExifWifiOnly
-                      ? null
-                      : Text(L10n.global().settingsExifWifiOnlyFalseSubtitle),
-                  value: _shouldProcessExifWifiOnly,
-                  onChanged: _isEnableExif ? _onExifWifiOnlyChanged : null,
-                ),
               _buildSubSettings(
                 context,
                 leading: const Icon(Icons.image_outlined),
@@ -275,60 +261,6 @@ class _SettingsState extends State<Settings> {
     );
   }
 
-  void _onExifSupportChanged(BuildContext context, bool value) {
-    if (value) {
-      showDialog(
-        context: context,
-        builder: (context) => AlertDialog(
-          title: Text(L10n.global().exifSupportConfirmationDialogTitle),
-          content: Text(L10n.global().exifSupportDetails),
-          actions: <Widget>[
-            TextButton(
-              onPressed: () {
-                Navigator.of(context).pop();
-              },
-              child: Text(MaterialLocalizations.of(context).cancelButtonLabel),
-            ),
-            TextButton(
-              onPressed: () {
-                Navigator.of(context).pop(true);
-              },
-              child: Text(L10n.global().enableButtonLabel),
-            ),
-          ],
-        ),
-      ).then((value) {
-        if (value == true) {
-          _setExifSupport(true);
-        }
-      });
-    } else {
-      _setExifSupport(false);
-    }
-  }
-
-  Future<void> _onExifWifiOnlyChanged(bool value) async {
-    _log.info("[_onExifWifiOnlyChanged] New value: $value");
-    final oldValue = _shouldProcessExifWifiOnly;
-    setState(() {
-      _shouldProcessExifWifiOnly = value;
-    });
-    if (!await Pref().setProcessExifWifiOnly(value)) {
-      _log.severe("[_onExifWifiOnlyChanged] Failed writing pref");
-      SnackBarManager().showSnackBar(SnackBar(
-        content: Text(L10n.global().writePreferenceFailureNotification),
-        duration: k.snackBarDurationNormal,
-      ));
-      setState(() {
-        _shouldProcessExifWifiOnly = oldValue;
-      });
-    } else {
-      // this is not very important since the config will be synced during
-      // service startup
-      ServiceConfig.setProcessExifWifiOnly(value).ignore();
-    }
-  }
-
   Future<void> _onCaptureLogChanged(BuildContext context, bool value) async {
     if (value) {
       final result = await showDialog<bool>(
@@ -377,26 +309,6 @@ class _SettingsState extends State<Settings> {
     }
   }
 
-  Future<void> _setExifSupport(bool value) async {
-    final oldValue = _isEnableExif;
-    setState(() {
-      _isEnableExif = value;
-    });
-    if (!await Pref().setEnableExif(value)) {
-      _log.severe("[_setExifSupport] Failed writing pref");
-      SnackBarManager().showSnackBar(SnackBar(
-        content: Text(L10n.global().writePreferenceFailureNotification),
-        duration: k.snackBarDurationNormal,
-      ));
-      setState(() {
-        _isEnableExif = oldValue;
-      });
-    }
-  }
-
-  late bool _isEnableExif;
-  late bool _shouldProcessExifWifiOnly;
-
   var _devSettingsUnlockCount = 3;
   var _isShowDevSettings = false;
 

app/lib/widget/settings/metadata/bloc.dart

@@ -0,0 +1,50 @@
+part of '../metadata_settings.dart';
+
+@npLog
+class _Bloc extends Bloc<_Event, _State> {
+  _Bloc({
+    required this.prefController,
+  }) : super(_State(
+          isEnable: prefController.isEnableExif.value,
+          isWifiOnly: prefController.shouldProcessExifWifiOnly.value,
+        )) {
+    on<_Init>(_onInit);
+    on<_SetEnable>(_onSetEnable);
+    on<_SetWifiOnly>(_onSetWifiOnly);
+  }
+
+  Future<void> _onInit(_Init ev, Emitter<_State> emit) async {
+    _log.info(ev);
+    await Future.wait([
+      emit.forEach<bool>(
+        prefController.isEnableExif,
+        onData: (data) => state.copyWith(isEnable: data),
+        onError: (e, stackTrace) {
+          _log.severe("[_onInit] Uncaught exception", e, stackTrace);
+          return state.copyWith(error: ExceptionEvent(e, stackTrace));
+        },
+      ),
+      emit.forEach<bool>(
+        prefController.shouldProcessExifWifiOnly,
+        onData: (data) => state.copyWith(isWifiOnly: data),
+        onError: (e, stackTrace) {
+          _log.severe("[_onInit] Uncaught exception", e, stackTrace);
+          return state.copyWith(error: ExceptionEvent(e, stackTrace));
+        },
+      ),
+    ]);
+  }
+
+  void _onSetEnable(_SetEnable ev, Emitter<_State> emit) {
+    _log.info(ev);
+    prefController.setEnableExif(ev.value);
+  }
+
+  Future<void> _onSetWifiOnly(_SetWifiOnly ev, Emitter<_State> emit) async {
+    _log.info(ev);
+    await prefController.setProcessExifWifiOnly(ev.value);
+    ServiceConfig.setProcessExifWifiOnly(ev.value).ignore();
+  }
+
+  final PrefController prefController;
+}

app/lib/widget/settings/metadata/state_event.dart

@@ -0,0 +1,51 @@
+part of '../metadata_settings.dart';
+
+@genCopyWith
+@toString
+class _State {
+  const _State({
+    required this.isEnable,
+    required this.isWifiOnly,
+    this.error,
+  });
+
+  @override
+  String toString() => _$toString();
+
+  final bool isEnable;
+  final bool isWifiOnly;
+
+  final ExceptionEvent? error;
+}
+
+abstract class _Event {
+  const _Event();
+}
+
+@toString
+class _Init implements _Event {
+  const _Init();
+
+  @override
+  String toString() => _$toString();
+}
+
+@toString
+class _SetEnable implements _Event {
+  const _SetEnable(this.value);
+
+  @override
+  String toString() => _$toString();
+
+  final bool value;
+}
+
+@toString
+class _SetWifiOnly implements _Event {
+  const _SetWifiOnly(this.value);
+
+  @override
+  String toString() => _$toString();
+
+  final bool value;
+}

app/lib/widget/settings/metadata_settings.dart

@@ -0,0 +1,157 @@
+import 'package:copy_with/copy_with.dart';
+import 'package:flutter/material.dart';
+import 'package:flutter_bloc/flutter_bloc.dart';
+import 'package:logging/logging.dart';
+import 'package:nc_photos/app_localizations.dart';
+import 'package:nc_photos/controller/pref_controller.dart';
+import 'package:nc_photos/exception_event.dart';
+import 'package:nc_photos/exception_util.dart' as exception_util;
+import 'package:nc_photos/k.dart' as k;
+import 'package:nc_photos/platform/k.dart' as platform_k;
+import 'package:nc_photos/service.dart';
+import 'package:nc_photos/snack_bar_manager.dart';
+import 'package:nc_photos/widget/page_visibility_mixin.dart';
+import 'package:np_codegen/np_codegen.dart';
+import 'package:to_string/to_string.dart';
+
+part 'metadata/bloc.dart';
+part 'metadata/state_event.dart';
+part 'metadata_settings.g.dart';
+
+typedef _BlocBuilder = BlocBuilder<_Bloc, _State>;
+typedef _BlocListener = BlocListener<_Bloc, _State>;
+typedef _BlocSelector<T> = BlocSelector<_Bloc, _State, T>;
+
+class MetadataSettings extends StatelessWidget {
+  const MetadataSettings({super.key});
+
+  @override
+  Widget build(BuildContext context) {
+    return BlocProvider(
+      create: (_) => _Bloc(
+        prefController: context.read(),
+      ),
+      child: const _WrappedMetadataSettings(),
+    );
+  }
+}
+
+class _WrappedMetadataSettings extends StatefulWidget {
+  const _WrappedMetadataSettings();
+
+  @override
+  State<StatefulWidget> createState() => _WrappedMetadataSettingsState();
+}
+
+class _WrappedMetadataSettingsState extends State<_WrappedMetadataSettings>
+    with RouteAware, PageVisibilityMixin {
+  @override
+  void initState() {
+    super.initState();
+    _bloc.add(const _Init());
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return Scaffold(
+      body: MultiBlocListener(
+        listeners: [
+          _BlocListener(
+            listenWhen: (previous, current) => previous.error != current.error,
+            listener: (context, state) {
+              if (state.error != null && isPageVisible()) {
+                SnackBarManager().showSnackBar(SnackBar(
+                  content:
+                      Text(exception_util.toUserString(state.error!.error)),
+                  duration: k.snackBarDurationNormal,
+                ));
+              }
+            },
+          ),
+        ],
+        child: CustomScrollView(
+          slivers: [
+            SliverAppBar(
+              pinned: true,
+              title: Text(L10n.global().settingsMetadataTitle),
+            ),
+            SliverList(
+              delegate: SliverChildListDelegate(
+                [
+                  _BlocSelector<bool>(
+                    selector: (state) => state.isEnable,
+                    builder: (context, state) {
+                      return SwitchListTile(
+                        title: Text(L10n.global().settingsExifSupportTitle),
+                        subtitle: state
+                            ? Text(
+                                L10n.global().settingsExifSupportTrueSubtitle)
+                            : null,
+                        value: state,
+                        onChanged: (value) => _onEnableChanged(context, value),
+                      );
+                    },
+                  ),
+                  if (platform_k.isMobile)
+                    _BlocBuilder(
+                      buildWhen: (previous, current) =>
+                          previous.isEnable != current.isEnable ||
+                          previous.isWifiOnly != current.isWifiOnly,
+                      builder: (context, state) {
+                        return SwitchListTile(
+                          title: Text(L10n.global().settingsExifWifiOnlyTitle),
+                          subtitle: state.isWifiOnly
+                              ? null
+                              : Text(L10n.global()
+                                  .settingsExifWifiOnlyFalseSubtitle),
+                          value: state.isWifiOnly,
+                          onChanged: state.isEnable
+                              ? (value) {
+                                  _bloc.add(_SetWifiOnly(value));
+                                }
+                              : null,
+                        );
+                      },
+                    ),
+                ],
+              ),
+            ),
+          ],
+        ),
+      ),
+    );
+  }
+
+  Future<void> _onEnableChanged(BuildContext context, bool value) async {
+    if (value) {
+      final result = await showDialog<bool>(
+        context: context,
+        builder: (context) => AlertDialog(
+          title: Text(L10n.global().exifSupportConfirmationDialogTitle),
+          content: Text(L10n.global().exifSupportDetails),
+          actions: [
+            TextButton(
+              onPressed: () {
+                Navigator.of(context).pop();
+              },
+              child: Text(MaterialLocalizations.of(context).cancelButtonLabel),
+            ),
+            TextButton(
+              onPressed: () {
+                Navigator.of(context).pop(true);
+              },
+              child: Text(L10n.global().enableButtonLabel),
+            ),
+          ],
+        ),
+      );
+      if (context.mounted && result == true) {
+        _bloc.add(const _SetEnable(true));
+      }
+    } else {
+      _bloc.add(const _SetEnable(false));
+    }
+  }
+
+  late final _bloc = context.read<_Bloc>();
+}

app/lib/widget/settings/metadata_settings.g.dart

@@ -0,0 +1,80 @@
+// GENERATED CODE - DO NOT MODIFY BY HAND
+
+part of 'metadata_settings.dart';
+
+// **************************************************************************
+// CopyWithLintRuleGenerator
+// **************************************************************************
+
+// ignore_for_file: library_private_types_in_public_api, duplicate_ignore
+
+// **************************************************************************
+// CopyWithGenerator
+// **************************************************************************
+
+abstract class $_StateCopyWithWorker {
+  _State call({bool? isEnable, bool? isWifiOnly, ExceptionEvent? error});
+}
+
+class _$_StateCopyWithWorkerImpl implements $_StateCopyWithWorker {
+  _$_StateCopyWithWorkerImpl(this.that);
+
+  @override
+  _State call(
+      {dynamic isEnable, dynamic isWifiOnly, dynamic error = copyWithNull}) {
+    return _State(
+        isEnable: isEnable as bool? ?? that.isEnable,
+        isWifiOnly: isWifiOnly as bool? ?? that.isWifiOnly,
+        error: error == copyWithNull ? that.error : error as ExceptionEvent?);
+  }
+
+  final _State that;
+}
+
+extension $_StateCopyWith on _State {
+  $_StateCopyWithWorker get copyWith => _$copyWith;
+  $_StateCopyWithWorker get _$copyWith => _$_StateCopyWithWorkerImpl(this);
+}
+
+// **************************************************************************
+// NpLogGenerator
+// **************************************************************************
+
+extension _$_BlocNpLog on _Bloc {
+  // ignore: unused_element
+  Logger get _log => log;
+
+  static final log = Logger("widget.settings.metadata_settings._Bloc");
+}
+
+// **************************************************************************
+// ToStringGenerator
+// **************************************************************************
+
+extension _$_StateToString on _State {
+  String _$toString() {
+    // ignore: unnecessary_string_interpolations
+    return "_State {isEnable: $isEnable, isWifiOnly: $isWifiOnly, error: $error}";
+  }
+}
+
+extension _$_InitToString on _Init {
+  String _$toString() {
+    // ignore: unnecessary_string_interpolations
+    return "_Init {}";
+  }
+}
+
+extension _$_SetEnableToString on _SetEnable {
+  String _$toString() {
+    // ignore: unnecessary_string_interpolations
+    return "_SetEnable {value: $value}";
+  }
+}
+
+extension _$_SetWifiOnlyToString on _SetWifiOnly {
+  String _$toString() {
+    // ignore: unnecessary_string_interpolations
+    return "_SetWifiOnly {value: $value}";
+  }
+}