Merge branch 'dev-shady-clockToolLastTimeSave'

veloce · veloce · commit 3ed1eaf7d828 · 2026-07-14T13:00:56.000-05:00
diff --git a/lib/src/model/clock/clock_tool_controller.dart b/lib/src/model/clock/clock_tool_controller.dart
@@ -4,6 +4,7 @@ import 'package:flutter/foundation.dart';
 import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:freezed_annotation/freezed_annotation.dart';
 import 'package:lichess_mobile/src/model/clock/chess_clock.dart';
+import 'package:lichess_mobile/src/model/clock/clock_tool_preferences.dart';
 import 'package:lichess_mobile/src/model/common/service/sound_service.dart';
 import 'package:lichess_mobile/src/model/common/time_increment.dart';
 
@@ -32,26 +33,36 @@ class ClockToolController extends Notifier<ClockState> {
     ClockSide.top: false,
     ClockSide.bottom: false,
   };
-  late Duration _emergencyThreshold;
+  final Map<ClockSide, Duration> _emergencyThresholds = {
+    ClockSide.top: Duration.zero,
+    ClockSide.bottom: Duration.zero,
+  };
   DateTime? _delayStartedAt;
   Duration? _delayDuration;
   Duration? _pausedDelayRemaining;
   Duration? _activeTurnStartedWithTime;
 
   @override
   ClockState build() {
-    const time = Duration(minutes: 10);
-    const increment = Duration.zero;
-    _emergencyThreshold = _calculateEmergencyThreshold(time);
-    const options = ClockOptions(
+    // using read is good enough as config change updates in-memory state which re-renders the ui
+    // and prefs are also saved
+    final topTimeIncrement = ref.read(clockToolPreferencesProvider).topTimeIncrement;
+    final topTime = Duration(seconds: topTimeIncrement.time);
+    final topIncrement = Duration(seconds: topTimeIncrement.increment);
+    final bottomTimeIncrement = ref.read(clockToolPreferencesProvider).bottomTimeIncrement;
+    final bottomTime = Duration(seconds: bottomTimeIncrement.time);
+    final bottomIncrement = Duration(seconds: bottomTimeIncrement.increment);
+    _emergencyThresholds[ClockSide.top] = _calculateEmergencyThreshold(topTime);
+    _emergencyThresholds[ClockSide.bottom] = _calculateEmergencyThreshold(bottomTime);
+    final options = ClockOptions(
       type: ClockTimeControlType.increment,
-      topTime: time,
-      bottomTime: time,
-      topIncrement: increment,
-      bottomIncrement: increment,
+      topTime: topTime,
+      bottomTime: bottomTime,
+      topIncrement: topIncrement,
+      bottomIncrement: bottomIncrement,
     );
 
-    _clock = ChessClock(blackTime: time, whiteTime: time, onFlag: _onFlagged);
+    _clock = ChessClock(blackTime: topTime, whiteTime: bottomTime, onFlag: _onFlagged);
 
     // Add listeners for both clocks
     _clock.whiteTime.addListener(onClockEmergency);
@@ -84,7 +95,7 @@ class ClockToolController extends Notifier<ClockState> {
     final activeSideTime = activeSide == ClockSide.top
         ? _clock.blackTime.value
         : _clock.whiteTime.value;
-    if (activeSideTime <= _emergencyThreshold) {
+    if (activeSideTime <= _emergencyThresholds[activeSide]!) {
       ref.read(soundServiceProvider).play(Sound.lowTime);
       _hasPlayedLowTimeSound[activeSide] = true;
     }
@@ -113,20 +124,11 @@ class ClockToolController extends Notifier<ClockState> {
     _startActiveSide(playerType.opposite);
   }
 
-  void updateDuration(ClockSide playerType, Duration duration) {
-    if (state.flagged != null || state.paused) {
-      return;
-    }
-
-    _clock.setTimes(
-      whiteTime: playerType == ClockSide.bottom ? duration + state.options.topIncrement : null,
-      blackTime: playerType == ClockSide.top ? duration + state.options.bottomIncrement : null,
-    );
-  }
-
   void updateOptions(TimeIncrement timeIncrement) {
     final options = ClockOptions.fromTimeIncrement(timeIncrement, type: state.options.type);
-    _emergencyThreshold = _calculateEmergencyThreshold(Duration(seconds: timeIncrement.time));
+    final threshold = _calculateEmergencyThreshold(Duration(seconds: timeIncrement.time));
+    _emergencyThresholds[ClockSide.top] = threshold;
+    _emergencyThresholds[ClockSide.bottom] = threshold;
     _hasPlayedLowTimeSound[ClockSide.top] = false;
     _hasPlayedLowTimeSound[ClockSide.bottom] = false;
     _clock.setTimes(blackTime: options.topTime, whiteTime: options.bottomTime);
@@ -135,6 +137,7 @@ class ClockToolController extends Notifier<ClockState> {
       topTime: _clock.blackTime,
       bottomTime: _clock.whiteTime,
     );
+    ref.read(clockToolPreferencesProvider.notifier).setTimeIncrement(timeIncrement);
   }
 
   void updateOptionsCustom(TimeIncrement clock, ClockSide player) {
@@ -151,6 +154,8 @@ class ClockToolController extends Notifier<ClockState> {
           ? Duration(seconds: clock.increment)
           : state.options.bottomIncrement,
     );
+    _emergencyThresholds[player] = _calculateEmergencyThreshold(Duration(seconds: clock.time));
+    _hasPlayedLowTimeSound[player] = false;
     _clock.setTimes(blackTime: options.topTime, whiteTime: options.bottomTime);
     state = ClockState(
       options: options,
@@ -159,6 +164,12 @@ class ClockToolController extends Notifier<ClockState> {
       activeSide: state.activeSide,
       clockOrientation: state.clockOrientation,
     );
+
+    if (player == ClockSide.top) {
+      ref.read(clockToolPreferencesProvider.notifier).setTopTimeIncrement(clock);
+    } else {
+      ref.read(clockToolPreferencesProvider.notifier).setBottomTimeIncrement(clock);
+    }
   }
 
   void updateClockType(ClockTimeControlType type) {
@@ -199,14 +210,10 @@ class ClockToolController extends Notifier<ClockState> {
     final active = state.activeSide;
     // If the active side started at zero, only resume ticking after that side
     // has completed at least one move; otherwise behave normally.
-    final Duration initialOfActive = active == ClockSide.top
-        ? state.options.topTime
-        : state.options.bottomTime;
-    final bool hasActiveMoved = active == ClockSide.top
-        ? state.topMoves > 0
-        : state.bottomMoves > 0;
-
-    if (active != null && (initialOfActive.inMilliseconds != 0 || hasActiveMoved)) {
+    final bool hasActiveMoved = active != null && state.getMovesCount(active) > 0;
+
+    if (active != null &&
+        (state.options.getStartTime(active).inMilliseconds != 0 || hasActiveMoved)) {
       final delay = _pausedDelayRemaining;
       _markDelay(delay);
       _clock.start(delay: delay);
@@ -223,13 +230,8 @@ class ClockToolController extends Notifier<ClockState> {
     // Start the countdown only if either this is not a zero-start clock
     // or the active side has already made at least one move.
     // This makes 0+increment modes usable.
-    final Duration initialOfActive = activeSide == ClockSide.top
-        ? state.options.topTime
-        : state.options.bottomTime;
-    final bool hasActiveMoved = activeSide == ClockSide.top
-        ? state.topMoves > 0
-        : state.bottomMoves > 0;
-    if (initialOfActive.inMilliseconds != 0 || hasActiveMoved) {
+    final bool hasActiveMoved = state.getMovesCount(activeSide) > 0;
+    if (state.options.getStartTime(activeSide).inMilliseconds != 0 || hasActiveMoved) {
       final delay = _delayFor(activeSide);
       _markDelay(delay);
       _activeTurnStartedWithTime = state.getDuration(activeSide).value;
@@ -334,6 +336,10 @@ sealed class ClockOptions with _$ClockOptions {
   bool hasIncrement(ClockSide playerType) {
     return getIncrement(playerType) > 0;
   }
+
+  Duration getStartTime(ClockSide playerType) {
+    return playerType == ClockSide.top ? topTime : bottomTime;
+  }
 }
 
 @freezed
diff --git a/lib/src/model/clock/clock_tool_preferences.dart b/lib/src/model/clock/clock_tool_preferences.dart
@@ -0,0 +1,79 @@
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:freezed_annotation/freezed_annotation.dart';
+import 'package:lichess_mobile/src/model/common/time_increment.dart';
+import 'package:lichess_mobile/src/model/settings/preferences_storage.dart';
+import 'package:lichess_mobile/src/model/user/user.dart';
+
+part 'clock_tool_preferences.freezed.dart';
+part 'clock_tool_preferences.g.dart';
+
+final clockToolPreferencesProvider = NotifierProvider<ClockToolPreferences, ClockToolPrefs>(
+  ClockToolPreferences.new,
+  name: 'ClockToolPreferencesProvider',
+);
+
+class ClockToolPreferences extends Notifier<ClockToolPrefs>
+    with SessionPreferencesStorage<ClockToolPrefs> {
+  @override
+  @protected
+  final prefCategory = PrefCategory.clockTool;
+
+  @override
+  ClockToolPrefs defaults({LightUser? user}) => ClockToolPrefs.defaults;
+
+  @override
+  ClockToolPrefs fromJson(Map<String, dynamic> json) => ClockToolPrefs.fromJson(json);
+
+  @override
+  ClockToolPrefs build() {
+    return fetch();
+  }
+
+  /// Sets both clocks to the same [timeIncrement] and remembers it as the last
+  /// global choice (used to seed the global clock settings modal).
+  Future<void> setTimeIncrement(TimeIncrement timeIncrement) {
+    return save(
+      state.copyWith(
+        timeIncrement: timeIncrement,
+        topTimeIncrement: timeIncrement,
+        bottomTimeIncrement: timeIncrement,
+      ),
+    );
+  }
+
+  Future<void> setTopTimeIncrement(TimeIncrement timeIncrement) {
+    return save(state.copyWith(topTimeIncrement: timeIncrement));
+  }
+
+  Future<void> setBottomTimeIncrement(TimeIncrement timeIncrement) {
+    return save(state.copyWith(bottomTimeIncrement: timeIncrement));
+  }
+}
+
+@Freezed(fromJson: true, toJson: true)
+sealed class ClockToolPrefs with _$ClockToolPrefs implements Serializable {
+  const ClockToolPrefs._();
+
+  const factory ClockToolPrefs({
+    /// The last time increment chosen from the global settings modal (which sets
+    /// both clocks at once). Used to seed that modal's sliders, so that editing a
+    /// single clock does not change what the global modal shows.
+    required TimeIncrement timeIncrement,
+    required TimeIncrement topTimeIncrement,
+    required TimeIncrement bottomTimeIncrement,
+  }) = _ClockToolPrefs;
+
+  static const defaults = ClockToolPrefs(
+    timeIncrement: TimeIncrement(600, 0),
+    topTimeIncrement: TimeIncrement(600, 0),
+    bottomTimeIncrement: TimeIncrement(600, 0),
+  );
+
+  factory ClockToolPrefs.fromJson(Map<String, dynamic> json) {
+    try {
+      return _$ClockToolPrefsFromJson(json);
+    } catch (_) {
+      return defaults;
+    }
+  }
+}
diff --git a/lib/src/model/settings/preferences_storage.dart b/lib/src/model/settings/preferences_storage.dart
@@ -31,7 +31,8 @@ enum PrefCategory {
   broadcast('preferences.broadcast'),
   engineEvaluation('preferences.engineEvaluation'),
   offlineComputerGame('preferences.offlineComputerGame'),
-  log('preferences.log');
+  log('preferences.log'),
+  clockTool('preferences.clockTool');
 
   const PrefCategory(this.storageKey);
 
diff --git a/lib/src/view/clock/clock_settings.dart b/lib/src/view/clock/clock_settings.dart
@@ -1,7 +1,7 @@
 import 'package:flutter/material.dart';
 import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:lichess_mobile/src/model/clock/clock_tool_controller.dart';
-import 'package:lichess_mobile/src/model/common/time_increment.dart';
+import 'package:lichess_mobile/src/model/clock/clock_tool_preferences.dart';
 import 'package:lichess_mobile/src/model/settings/general_preferences.dart';
 import 'package:lichess_mobile/src/utils/l10n_context.dart';
 import 'package:lichess_mobile/src/view/clock/clock_tool_settings_modal.dart';
@@ -64,15 +64,18 @@ class ClockSettings extends ConsumerWidget {
                         isScrollControlled: true,
                         constraints: BoxConstraints(maxHeight: screenHeight - (screenHeight / 10)),
                         builder: (BuildContext context) {
-                          final options = ref.watch(
-                            clockToolControllerProvider.select((value) => value.options),
+                          final clockType = ref.watch(
+                            clockToolControllerProvider.select((value) => value.options.type),
+                          );
+                          // Seed from the last global choice, not the current per-side
+                          // times, so editing a single clock does not change what this
+                          // modal shows.
+                          final timeIncrement = ref.watch(
+                            clockToolPreferencesProvider.select((prefs) => prefs.timeIncrement),
                           );
                           return ClockToolSettingsModal(
-                            clockType: options.type,
-                            timeIncrement: TimeIncrement(
-                              options.bottomTime.inSeconds,
-                              options.bottomIncrement.inSeconds,
-                            ),
+                            clockType: clockType,
+                            timeIncrement: timeIncrement,
                             onClockTypeSelected: (type) {
                               ref.read(clockToolControllerProvider.notifier).updateClockType(type);
                             },
diff --git a/test/model/clock/clock_tool_controller_test.dart b/test/model/clock/clock_tool_controller_test.dart
@@ -2,15 +2,34 @@ import 'package:fake_async/fake_async.dart';
 import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:flutter_test/flutter_test.dart';
 import 'package:lichess_mobile/src/model/clock/clock_tool_controller.dart';
+import 'package:lichess_mobile/src/model/clock/clock_tool_preferences.dart';
 import 'package:lichess_mobile/src/model/common/service/sound_service.dart';
 import 'package:lichess_mobile/src/model/common/time_increment.dart';
 
 import '../common/service/fake_sound_service.dart';
 
+class FakeClockToolPreferences extends ClockToolPreferences {
+  @override
+  ClockToolPrefs build() => ClockToolPrefs.defaults;
+
+  @override
+  Future<void> setTimeIncrement(TimeIncrement timeIncrement) async {
+    await Future<void>.delayed(Duration.zero);
+    state = state.copyWith(
+      timeIncrement: timeIncrement,
+      topTimeIncrement: timeIncrement,
+      bottomTimeIncrement: timeIncrement,
+    );
+  }
+}
+
 void main() {
   ProviderContainer makeClockContainer() {
     final container = ProviderContainer(
-      overrides: [soundServiceProvider.overrideWithValue(FakeSoundService())],
+      overrides: [
+        soundServiceProvider.overrideWithValue(FakeSoundService()),
+        clockToolPreferencesProvider.overrideWith(FakeClockToolPreferences.new),
+      ],
     );
     final subscription = container.listen(clockToolControllerProvider, (_, _) {});
     addTearDown(subscription.close);
