User full game list

android/gradle.properties

@@ -3,4 +3,4 @@ android.useAndroidX=true
 android.enableJetifier=true
 android.defaults.buildfeatures.buildconfig=true
 android.nonTransitiveRClass=false
-android.nonFinalResIds=false
+android.nonFinalResIds=false

lib/src/model/game/game_history.dart

@@ -0,0 +1,85 @@
+import 'dart:async';
+
+import 'package:async/async.dart';
+import 'package:fast_immutable_collections/fast_immutable_collections.dart';
+import 'package:freezed_annotation/freezed_annotation.dart';
+import 'package:lichess_mobile/src/model/common/http.dart';
+import 'package:lichess_mobile/src/model/common/id.dart';
+import 'package:lichess_mobile/src/model/game/archived_game.dart';
+import 'package:lichess_mobile/src/model/game/game_repository.dart';
+import 'package:lichess_mobile/src/model/game/game_repository_providers.dart';
+import 'package:lichess_mobile/src/utils/riverpod.dart';
+import 'package:result_extensions/result_extensions.dart';
+import 'package:riverpod_annotation/riverpod_annotation.dart';
+
+part 'game_history.freezed.dart';
+part 'game_history.g.dart';
+
+const _nbPerPage = 20;
+
+@riverpod
+class UserGameHistory extends _$UserGameHistory {
+  final _list = <LightArchivedGame>[];
+
+  @override
+  Future<UserGameHistoryState> build(UserId id) async {
+    ref.cacheFor(const Duration(minutes: 30));
+    ref.onDispose(() {
+      _list.clear();
+    });
+    final recentGames =
+        await ref.watch(userRecentGamesProvider(userId: id).future);
+    _list.addAll(recentGames);
+    return UserGameHistoryState(
+      gameList: _list.toIList(),
+      isLoading: false,
+      hasMore: true,
+      hasError: false,
+    );
+  }
+
+  void getNext() {
+    if (!state.hasValue) return;
+
+    final currentVal = state.requireValue;
+    state = AsyncData(currentVal.copyWith(isLoading: true));
+    Result.capture(
+      ref.withClient(
+        (client) => GameRepository(client)
+            .getFullGames(id, _nbPerPage, until: _list.last.createdAt),
+      ),
+    ).fold(
+      (value) {
+        if (value.isEmpty) {
+          state = AsyncData(
+            currentVal.copyWith(hasMore: false, isLoading: false),
+          );
+          return;
+        }
+        _list.addAll(value);
+        state = AsyncData(
+          UserGameHistoryState(
+            gameList: _list.toIList(),
+            isLoading: false,
+            hasMore: true,
+            hasError: false,
+          ),
+        );
+      },
+      (error, stackTrace) {
+        state =
+            AsyncData(currentVal.copyWith(isLoading: false, hasError: true));
+      },
+    );
+  }
+}
+
+@freezed
+class UserGameHistoryState with _$UserGameHistoryState {
+  const factory UserGameHistoryState({
+    required IList<LightArchivedGame> gameList,
+    required bool isLoading,
+    required bool hasMore,
+    required bool hasError,
+  }) = _UserGameHistoryState;
+}

lib/src/model/game/game_repository.dart

@@ -51,6 +51,28 @@ class GameRepository {
     );
   }
 
+  Future<IList<LightArchivedGame>> getFullGames(
+    UserId userId,
+    int max, {
+    DateTime? until,
+  }) {
+    return client.readNdJsonList(
+      Uri(
+        path: '/api/games/user/$userId',
+        queryParameters: {
+          'max': max.toString(),
+          if (until != null) 'until': until.millisecondsSinceEpoch.toString(),
+          'moves': 'false',
+          'lastFen': 'true',
+          'accuracy': 'true',
+          'opening': 'true',
+        },
+      ),
+      headers: {'Accept': 'application/x-ndjson'},
+      mapper: LightArchivedGame.fromServerJson,
+    );
+  }
+
   /// Returns the games of the current user, given a list of ids.
   Future<IList<PlayableGame>> getMyGamesByIds(ISet<GameId> ids) {
     if (ids.isEmpty) {

lib/src/model/game/game_repository_providers.dart

@@ -24,6 +24,22 @@ Future<ArchivedGame> archivedGame(
   );
 }
 
+@riverpod
+Future<IList<LightArchivedGame>> userRecentGames(
+  UserRecentGamesRef ref, {
+  required UserId userId,
+}) {
+  return ref.withClientCacheFor(
+    (client) => GameRepository(client).getRecentGames(userId),
+    // cache is important because the associated widget is in a [ListView] and
+    // the provider may be instanciated multiple times in a short period of time
+    // (e.g. when scrolling)
+    // TODO: consider debouncing the request instead of caching it, or make the
+    // request in the parent widget and pass the result to the child
+    const Duration(minutes: 1),
+  );
+}
+
 @riverpod
 Future<IList<LightArchivedGame>> gamesById(
   GamesByIdRef ref, {

lib/src/view/game/game_list_tile.dart

@@ -4,19 +4,26 @@ import 'package:flutter/material.dart';
 import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:lichess_mobile/src/model/analysis/analysis_controller.dart';
 import 'package:lichess_mobile/src/model/common/http.dart';
+import 'package:lichess_mobile/src/model/common/id.dart';
 import 'package:lichess_mobile/src/model/game/archived_game.dart';
 import 'package:lichess_mobile/src/model/game/game_share_service.dart';
+import 'package:lichess_mobile/src/model/game/game_status.dart';
+import 'package:lichess_mobile/src/styles/lichess_colors.dart';
 import 'package:lichess_mobile/src/styles/styles.dart';
 import 'package:lichess_mobile/src/utils/chessground_compat.dart';
 import 'package:lichess_mobile/src/utils/l10n_context.dart';
 import 'package:lichess_mobile/src/utils/navigation.dart';
 import 'package:lichess_mobile/src/utils/share.dart';
 import 'package:lichess_mobile/src/view/analysis/analysis_screen.dart';
+import 'package:lichess_mobile/src/view/game/archived_game_screen.dart';
+import 'package:lichess_mobile/src/view/game/standalone_game_screen.dart';
 import 'package:lichess_mobile/src/view/game/status_l10n.dart';
 import 'package:lichess_mobile/src/widgets/adaptive_bottom_sheet.dart';
 import 'package:lichess_mobile/src/widgets/board_thumbnail.dart';
 import 'package:lichess_mobile/src/widgets/feedback.dart';
 import 'package:lichess_mobile/src/widgets/list.dart';
+import 'package:lichess_mobile/src/widgets/user_full_name.dart';
+import 'package:timeago/timeago.dart' as timeago;
 
 /// A list tile that shows game info.
 class GameListTile extends StatelessWidget {
@@ -402,3 +409,101 @@ class _ContextMenu extends ConsumerWidget {
     );
   }
 }
+
+class ExtendedGameListTile extends StatelessWidget {
+  const ExtendedGameListTile({required this.game, this.userId});
+
+  final LightArchivedGame game;
+  final UserId? userId;
+
+  @override
+  Widget build(BuildContext context) {
+    final mySide = game.white.user?.id == userId ? Side.white : Side.black;
+    final me = game.white.user?.id == userId ? game.white : game.black;
+    final opponent = game.white.user?.id == userId ? game.black : game.white;
+
+    Widget getResultIcon(LightArchivedGame game, Side mySide) {
+      if (game.status == GameStatus.aborted ||
+          game.status == GameStatus.noStart) {
+        return const Icon(
+          CupertinoIcons.xmark_square_fill,
+          color: LichessColors.grey,
+        );
+      } else {
+        return game.winner == null
+            ? Icon(
+                CupertinoIcons.equal_square_fill,
+                color: context.lichessColors.brag,
+              )
+            : game.winner == mySide
+                ? Icon(
+                    CupertinoIcons.plus_square_fill,
+                    color: context.lichessColors.good,
+                  )
+                : Icon(
+                    CupertinoIcons.minus_square_fill,
+                    color: context.lichessColors.error,
+                  );
+      }
+    }
+
+    return GameListTile(
+      game: game,
+      mySide: userId == game.white.user?.id ? Side.white : Side.black,
+      onTap: game.variant.isSupported
+          ? () {
+              pushPlatformRoute(
+                context,
+                rootNavigator: true,
+                builder: (context) => game.fullId != null
+                    ? StandaloneGameScreen(
+                        params: InitialStandaloneGameParams(
+                          id: game.fullId!,
+                        ),
+                      )
+                    : ArchivedGameScreen(
+                        gameData: game,
+                        orientation: userId == game.white.user?.id
+                            ? Side.white
+                            : Side.black,
+                      ),
+              );
+            }
+          : null,
+      icon: game.perf.icon,
+      playerTitle: UserFullNameWidget.player(
+        user: opponent.user,
+        aiLevel: opponent.aiLevel,
+        rating: opponent.rating,
+      ),
+      subtitle: Text(
+        timeago.format(game.lastMoveAt),
+      ),
+      trailing: Row(
+        mainAxisSize: MainAxisSize.min,
+        children: [
+          if (me.analysis != null) ...[
+            Column(
+              mainAxisSize: MainAxisSize.min,
+              children: [
+                Icon(
+                  CupertinoIcons.chart_bar_alt_fill,
+                  color: textShade(context, 0.5),
+                ),
+                Text(
+                  me.analysis!.accuracy.toString(),
+                  style: TextStyle(
+                    fontSize: 10,
+                    color: textShade(context, Styles.subtitleOpacity),
+                  ),
+                ),
+              ],
+            ),
+            const SizedBox(width: 5),
+          ],
+          getResultIcon(game, mySide),
+        ],
+      ),
+    );
+  }
+}