feat: persist ongoing OTB games

tom-anders · tom-anders · commit a3faf2de6741 · 2025-12-31T11:21:05.000+01:00
Closes #2466
diff --git a/lib/src/model/game/over_the_board_game.dart b/lib/src/model/game/over_the_board_game.dart
@@ -19,6 +19,8 @@ part 'over_the_board_game.g.dart';
 abstract class OverTheBoardGame with _$OverTheBoardGame, BaseGame, IndexableSteps {
   const OverTheBoardGame._();
 
+  factory OverTheBoardGame.fromJson(Map<String, dynamic> json) => _$OverTheBoardGameFromJson(json);
+
   @override
   Player get white => Player(
     onGame: true,
diff --git a/lib/src/model/over_the_board/over_the_board_clock.dart b/lib/src/model/over_the_board/over_the_board_clock.dart
@@ -48,11 +48,15 @@ class OverTheBoardClock extends Notifier<OverTheBoardClockState> {
     );
   }
 
-  void setupClock(TimeIncrement timeIncrement) {
+  void setupClock(TimeIncrement timeIncrement, {Duration? whiteTimeLeft, Duration? blackTimeLeft}) {
     _stopwatch.stop();
     _stopwatch.reset();
 
-    state = OverTheBoardClockState.fromTimeIncrement(timeIncrement);
+    state = OverTheBoardClockState.fromTimeIncrement(
+      timeIncrement,
+      whiteTimeLeft: whiteTimeLeft,
+      blackTimeLeft: blackTimeLeft,
+    );
   }
 
   void restart() {
@@ -111,15 +115,19 @@ sealed class OverTheBoardClockState with _$OverTheBoardClockState {
     required Side? flagSide,
   }) = _OverTheBoardClockState;
 
-  factory OverTheBoardClockState.fromTimeIncrement(TimeIncrement timeIncrement) {
+  factory OverTheBoardClockState.fromTimeIncrement(
+    TimeIncrement timeIncrement, {
+    Duration? whiteTimeLeft,
+    Duration? blackTimeLeft,
+  }) {
     final initialTime = timeIncrement.isInfinite
         ? null
         : Duration(seconds: max(timeIncrement.time, timeIncrement.increment));
 
     return OverTheBoardClockState(
       timeIncrement: timeIncrement,
-      whiteTimeLeft: initialTime,
-      blackTimeLeft: initialTime,
+      whiteTimeLeft: whiteTimeLeft ?? initialTime,
+      blackTimeLeft: blackTimeLeft ?? initialTime,
       activeClock: null,
       flagSide: null,
     );
diff --git a/lib/src/model/over_the_board/over_the_board_game_controller.dart b/lib/src/model/over_the_board/over_the_board_game_controller.dart
@@ -32,6 +32,10 @@ class OverTheBoardGameController extends Notifier<OverTheBoardGameState> {
     state = OverTheBoardGameState.fromVariant(variant, Speed.fromTimeIncrement(timeIncrement));
   }
 
+  void loadOngoingGame(OverTheBoardGame game) {
+    state = OverTheBoardGameState(game: game, stepCursor: game.steps.length - 1);
+  }
+
   void rematch() {
     state = OverTheBoardGameState.fromVariant(state.game.meta.variant, state.game.meta.speed);
   }
diff --git a/lib/src/model/over_the_board/over_the_board_game_storage.dart b/lib/src/model/over_the_board/over_the_board_game_storage.dart
@@ -0,0 +1,92 @@
+import 'dart:convert';
+import 'dart:io';
+
+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/common/time_increment.dart';
+import 'package:lichess_mobile/src/model/game/over_the_board_game.dart';
+import 'package:logging/logging.dart';
+import 'package:path_provider/path_provider.dart';
+
+part 'over_the_board_game_storage.freezed.dart';
+part 'over_the_board_game_storage.g.dart';
+
+final _logger = Logger('OverTheBoardGameStorage');
+
+@Freezed(fromJson: true, toJson: true)
+sealed class SavedOtbGame with _$SavedOtbGame {
+  const SavedOtbGame._();
+
+  factory SavedOtbGame({
+    required OverTheBoardGame game,
+    required TimeIncrement timeIncrement,
+    Duration? whiteTimeLeft,
+    Duration? blackTimeLeft,
+  }) = _SavedOtbGame;
+
+  factory SavedOtbGame.fromJson(Map<String, dynamic> json) => _$SavedOtbGameFromJson(json);
+}
+
+/// A provider for [OverTheBoardGameStorage].
+final overTheBoardGameStorageProvider = Provider<OverTheBoardGameStorage>((Ref ref) {
+  return OverTheBoardGameStorage(ref);
+}, name: 'OverTheBoardGameStorageProvider');
+
+const kOtbGameFileName = 'otb_game.json';
+
+class OverTheBoardGameStorage {
+  const OverTheBoardGameStorage(this.ref);
+  final Ref ref;
+
+  Future<File> _getFile() async {
+    final dir = await getApplicationCacheDirectory();
+    return File('${dir.path}/$kOtbGameFileName');
+  }
+
+  /// Loads an ongoing OTB game from storage. Returns null if there's no ongoing game or if an error occurs.
+  Future<SavedOtbGame?> fetchOngoingGame() async {
+    try {
+      final file = await _getFile();
+      if (!await file.exists()) {
+        return null;
+      }
+
+      final contents = await file.readAsString();
+      final json = jsonDecode(contents);
+
+      if (json is! Map<String, dynamic>) {
+        throw const FormatException('[OtbGameStorage] cannot fetch game: expected an object');
+      }
+
+      return SavedOtbGame.fromJson(json);
+    } catch (e) {
+      _logger.warning('[OtbGameStorage] failed to fetch game: $e');
+      return null;
+    }
+  }
+
+  /// Persist the ongoing OTB game to storage. Use [fetchOngoingGame] to retrieve it later.
+  Future<void> save(
+    OverTheBoardGame game, {
+    required TimeIncrement timeIncrement,
+    required Duration? whiteTimeLeft,
+    required Duration? blackTimeLeft,
+  }) async {
+    try {
+      final file = await _getFile();
+      await file.writeAsString(
+        jsonEncode(
+          SavedOtbGame(
+            game: game,
+            timeIncrement: timeIncrement,
+            whiteTimeLeft: whiteTimeLeft,
+            blackTimeLeft: blackTimeLeft,
+          ).toJson(),
+        ),
+      );
+    } catch (e) {
+      _logger.warning('[OtbGameStorage] failed to save game: $e');
+    }
+  }
+}
diff --git a/lib/src/view/over_the_board/over_the_board_screen.dart b/lib/src/view/over_the_board/over_the_board_screen.dart
@@ -9,8 +9,10 @@ import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:lichess_mobile/src/model/analysis/analysis_controller.dart';
 import 'package:lichess_mobile/src/model/over_the_board/over_the_board_clock.dart';
 import 'package:lichess_mobile/src/model/over_the_board/over_the_board_game_controller.dart';
+import 'package:lichess_mobile/src/model/over_the_board/over_the_board_game_storage.dart';
 import 'package:lichess_mobile/src/model/settings/board_preferences.dart';
 import 'package:lichess_mobile/src/model/settings/over_the_board_preferences.dart';
+import 'package:lichess_mobile/src/utils/focus_detector.dart';
 import 'package:lichess_mobile/src/utils/immersive_mode.dart';
 import 'package:lichess_mobile/src/utils/l10n_context.dart';
 import 'package:lichess_mobile/src/utils/navigation.dart';
@@ -66,8 +68,23 @@ class _BodyState extends ConsumerState<_Body> {
   @override
   void initState() {
     super.initState();
-    WidgetsBinding.instance.addPostFrameCallback((_) {
-      showConfigureGameSheet(context, isDismissible: true);
+
+    WidgetsBinding.instance.addPostFrameCallback((_) async {
+      final ongoingGame = await ref.read(overTheBoardGameStorageProvider).fetchOngoingGame();
+      if (ongoingGame != null && ongoingGame.game.steps.length > 1 && !ongoingGame.game.finished) {
+        ref.read(overTheBoardGameControllerProvider.notifier).loadOngoingGame(ongoingGame.game);
+
+        ref
+            .read(overTheBoardClockProvider.notifier)
+            .setupClock(
+              ongoingGame.timeIncrement,
+              whiteTimeLeft: ongoingGame.whiteTimeLeft,
+              blackTimeLeft: ongoingGame.blackTimeLeft,
+            );
+      } else {
+        if (!mounted) return;
+        showConfigureGameSheet(context, isDismissible: true);
+      }
     });
   }
 
@@ -131,6 +148,9 @@ class _BodyState extends ConsumerState<_Body> {
       }
     });
 
+    final clockState = ref.read(overTheBoardClockProvider);
+    final otbGameStorage = ref.read(overTheBoardGameStorageProvider);
+
     return WakelockWidget(
       child: PopScope(
         canPop: false,
@@ -141,7 +161,7 @@ class _BodyState extends ConsumerState<_Body> {
 
           final navigator = Navigator.of(context);
           final game = gameState.game;
-          if (game.abortable) {
+          if (game.abortable || game.finished) {
             return navigator.pop();
           }
 
@@ -154,7 +174,7 @@ class _BodyState extends ConsumerState<_Body> {
             builder: (context) {
               return YesNoDialog(
                 title: Text(context.l10n.mobileAreYouSure),
-                content: const Text('Your game will be lost.'),
+                content: const Text('No worries, your game will be saved.'),
                 onNo: () => Navigator.of(context).pop(false),
                 onYes: () => Navigator.of(context).pop(true),
               );
@@ -166,69 +186,79 @@ class _BodyState extends ConsumerState<_Body> {
             ref.read(overTheBoardClockProvider.notifier).resume(gameState.turn);
           }
         },
-        child: Column(
-          children: [
-            Expanded(
-              child: SafeArea(
-                child: GameLayout(
-                  key: _boardKey,
-                  topTable: _Player(
-                    side: orientation.opposite,
-                    upsideDown:
-                        !overTheBoardPrefs.flipPiecesAfterMove || orientation != gameState.turn,
-                    clockKey: const ValueKey('topClock'),
-                  ),
-                  bottomTable: _Player(
-                    side: orientation,
-                    upsideDown:
-                        overTheBoardPrefs.flipPiecesAfterMove && orientation != gameState.turn,
-                    clockKey: const ValueKey('bottomClock'),
-                  ),
-                  orientation: orientation,
-                  fen: gameState.currentPosition.fen,
-                  lastMove: gameState.lastMove,
-                  interactiveBoardParams: (
-                    variant: gameState.game.meta.variant,
-                    position: gameState.currentPosition,
-                    playerSide: gameState.game.finished
-                        ? PlayerSide.none
-                        : gameState.turn == Side.white
-                        ? PlayerSide.white
-                        : PlayerSide.black,
-                    onPromotionSelection: ref
-                        .read(overTheBoardGameControllerProvider.notifier)
-                        .onPromotionSelection,
-                    promotionMove: gameState.promotionMove,
-                    onMove: (move, {isDrop}) {
-                      ref
-                          .read(overTheBoardClockProvider.notifier)
-                          .onMove(newSideToMove: gameState.turn.opposite);
-                      ref.read(overTheBoardGameControllerProvider.notifier).makeMove(move);
-                    },
-                    premovable: null,
-                  ),
-                  moves: gameState.moves,
-                  currentMoveIndex: gameState.stepCursor,
-                  boardSettingsOverrides: BoardSettingsOverrides(
-                    drawShape: const DrawShapeOptions(enable: false),
-                    pieceOrientationBehavior: overTheBoardPrefs.flipPiecesAfterMove
-                        ? PieceOrientationBehavior.sideToPlay
-                        : PieceOrientationBehavior.opponentUpsideDown,
-                    pieceAssets: overTheBoardPrefs.symmetricPieces
-                        ? PieceSet.symmetric.assets
-                        : null,
-                  ),
-                  userActionsBar: _BottomBar(
-                    onFlipBoard: () {
-                      setState(() {
-                        orientation = orientation.opposite;
-                      });
-                    },
+        child: FocusDetector(
+          onFocusLost: () {
+            otbGameStorage.save(
+              gameState.game,
+              timeIncrement: clockState.timeIncrement,
+              whiteTimeLeft: clockState.whiteTimeLeft,
+              blackTimeLeft: clockState.blackTimeLeft,
+            );
+          },
+          child: Column(
+            children: [
+              Expanded(
+                child: SafeArea(
+                  child: GameLayout(
+                    key: _boardKey,
+                    topTable: _Player(
+                      side: orientation.opposite,
+                      upsideDown:
+                          !overTheBoardPrefs.flipPiecesAfterMove || orientation != gameState.turn,
+                      clockKey: const ValueKey('topClock'),
+                    ),
+                    bottomTable: _Player(
+                      side: orientation,
+                      upsideDown:
+                          overTheBoardPrefs.flipPiecesAfterMove && orientation != gameState.turn,
+                      clockKey: const ValueKey('bottomClock'),
+                    ),
+                    orientation: orientation,
+                    fen: gameState.currentPosition.fen,
+                    lastMove: gameState.lastMove,
+                    interactiveBoardParams: (
+                      variant: gameState.game.meta.variant,
+                      position: gameState.currentPosition,
+                      playerSide: gameState.game.finished
+                          ? PlayerSide.none
+                          : gameState.turn == Side.white
+                          ? PlayerSide.white
+                          : PlayerSide.black,
+                      onPromotionSelection: ref
+                          .read(overTheBoardGameControllerProvider.notifier)
+                          .onPromotionSelection,
+                      promotionMove: gameState.promotionMove,
+                      onMove: (move, {isDrop}) {
+                        ref
+                            .read(overTheBoardClockProvider.notifier)
+                            .onMove(newSideToMove: gameState.turn.opposite);
+                        ref.read(overTheBoardGameControllerProvider.notifier).makeMove(move);
+                      },
+                      premovable: null,
+                    ),
+                    moves: gameState.moves,
+                    currentMoveIndex: gameState.stepCursor,
+                    boardSettingsOverrides: BoardSettingsOverrides(
+                      drawShape: const DrawShapeOptions(enable: false),
+                      pieceOrientationBehavior: overTheBoardPrefs.flipPiecesAfterMove
+                          ? PieceOrientationBehavior.sideToPlay
+                          : PieceOrientationBehavior.opponentUpsideDown,
+                      pieceAssets: overTheBoardPrefs.symmetricPieces
+                          ? PieceSet.symmetric.assets
+                          : null,
+                    ),
+                    userActionsBar: _BottomBar(
+                      onFlipBoard: () {
+                        setState(() {
+                          orientation = orientation.opposite;
+                        });
+                      },
+                    ),
                   ),
                 ),
               ),
-            ),
-          ],
+            ],
+          ),
         ),
       ),
     );
diff --git a/test/view/over_the_board/over_the_board_screen_test.dart b/test/view/over_the_board/over_the_board_screen_test.dart

Original file line number	Diff line number	Diff line change
`@@ -32,6 +32,10 @@ class OverTheBoardGameController extends Notifier<OverTheBoardGameState> {`
`32`	`32`	`state = OverTheBoardGameState.fromVariant(variant, Speed.fromTimeIncrement(timeIncrement));`
`33`	`33`	`}`
`34`	`34`
	`35`	`+ void loadOngoingGame(OverTheBoardGame game) {`
	`36`	`+ state = OverTheBoardGameState(game: game, stepCursor: game.steps.length - 1);`
	`37`	`+ }`
	`38`	`+`
`35`	`39`	`void rematch() {`
`36`	`40`	`state = OverTheBoardGameState.fromVariant(state.game.meta.variant, state.game.meta.speed);`
`37`	`41`	`}`