More progress on broadcast feature

lib/src/model/analysis/analysis_controller.dart

@@ -27,12 +27,15 @@ part 'analysis_controller.g.dart';
 
 const standaloneAnalysisId = StringId('standalone_analysis');
 const standaloneOpeningExplorerId = StringId('standalone_opening_explorer');
+const standaloneBroadcastId = StringId('standalone_broadcast');
 
 final _dateFormat = DateFormat('yyyy.MM.dd');
 
 /// Whether the analysis is a standalone analysis (not a lichess game analysis).
 bool _isStandaloneAnalysis(StringId id) =>
-    id == standaloneAnalysisId || id == standaloneOpeningExplorerId;
+    id == standaloneAnalysisId ||
+    id == standaloneOpeningExplorerId ||
+    id == standaloneBroadcastId;
 
 @freezed
 class AnalysisOptions with _$AnalysisOptions {
@@ -46,6 +49,7 @@ class AnalysisOptions with _$AnalysisOptions {
     int? initialMoveCursor,
     LightOpening? opening,
     Division? division,
+    @Default(false) bool isBroadcast,
 
     /// Optional server analysis to display player stats.
     ({PlayerAnalysis white, PlayerAnalysis black})? serverAnalysis,
@@ -148,6 +152,9 @@ class AnalysisController extends _$AnalysisController {
       variant: options.variant,
       id: options.id,
       currentPath: currentPath,
+      livePath: options.isBroadcast && pgnHeaders['Result'] == '*'
+          ? currentPath
+          : null,
       isOnMainline: _root.isOnMainline(currentPath),
       root: _root.view,
       currentNode: AnalysisCurrentNode.fromNode(currentNode),
@@ -162,6 +169,7 @@ class AnalysisController extends _$AnalysisController {
       playersAnalysis: options.serverAnalysis,
       acplChartData:
           options.serverAnalysis != null ? _makeAcplChartData() : null,
+      clocks: options.isBroadcast ? _makeClocks(currentPath) : null,
     );
 
     if (analysisState.isEngineAvailable) {
@@ -210,6 +218,24 @@ class AnalysisController extends _$AnalysisController {
     }
   }
 
+  void onBroadcastMove(UciPath path, Move move, Duration? clock) {
+    final (newPath, isNewNode) = _root.addMoveAt(path, move, clock: clock);
+
+    if (newPath != null) {
+      if (state.livePath == state.currentPath) {
+        _setPath(
+          newPath,
+          shouldRecomputeRootView: isNewNode,
+          shouldForceShowVariation: true,
+          isBroadcastMove: true,
+        );
+      } else {
+        _root.promoteAt(newPath, toMainline: true);
+        state = state.copyWith(livePath: newPath, root: _root.view);
+      }
+    }
+  }
+
   void onPromotionSelection(Role? role) {
     if (role == null) {
       state = state.copyWith(promotionMove: null);
@@ -400,6 +426,7 @@ class AnalysisController extends _$AnalysisController {
     bool shouldForceShowVariation = false,
     bool shouldRecomputeRootView = false,
     bool replaying = false,
+    bool isBroadcastMove = false,
   }) {
     final pathChange = state.currentPath != path;
     final (currentNode, opening) = _nodeOpeningAt(_root, path);
@@ -448,22 +475,26 @@ class AnalysisController extends _$AnalysisController {
 
       state = state.copyWith(
         currentPath: path,
+        livePath: isBroadcastMove ? path : state.livePath,
         isOnMainline: _root.isOnMainline(path),
         currentNode: AnalysisCurrentNode.fromNode(currentNode),
         currentBranchOpening: opening,
         lastMove: currentNode.sanMove.move,
         promotionMove: null,
         root: rootView,
+        clocks: options.isBroadcast ? _makeClocks(path) : null,
       );
     } else {
       state = state.copyWith(
         currentPath: path,
+        livePath: isBroadcastMove ? path : state.livePath,
         isOnMainline: _root.isOnMainline(path),
         currentNode: AnalysisCurrentNode.fromNode(currentNode),
         currentBranchOpening: opening,
         lastMove: null,
         promotionMove: null,
         root: rootView,
+        clocks: options.isBroadcast ? _makeClocks(path) : null,
       );
     }
 
@@ -625,6 +656,16 @@ class AnalysisController extends _$AnalysisController {
     ).toList(growable: false);
     return list.isEmpty ? null : IList(list);
   }
+
+  ({Duration? parentClock, Duration? clock}) _makeClocks(UciPath path) {
+    final nodeView = _root.nodeAt(path).view;
+    final parentView = _root.parentAt(path).view;
+
+    return (
+      parentClock: (parentView is ViewBranch) ? parentView.clock : null,
+      clock: (nodeView is ViewBranch) ? nodeView.clock : null,
+    );
+  }
 }
 
 enum DisplayMode {
@@ -656,6 +697,9 @@ class AnalysisState with _$AnalysisState {
     /// The path to the current node in the analysis view.
     required UciPath currentPath,
 
+    // The path to the current broadcast live move.
+    required UciPath? livePath,
+
     /// Whether the current path is on the mainline.
     required bool isOnMainline,
 
@@ -673,6 +717,9 @@ class AnalysisState with _$AnalysisState {
     /// It can be either moves, summary or opening explorer.
     required DisplayMode displayMode,
 
+    /// Clocks if avaible. Only used by the broadcast analysis screen.
+    ({Duration? parentClock, Duration? clock})? clocks,
+
     /// The last move played.
     Move? lastMove,
 
@@ -755,6 +802,14 @@ class AnalysisState with _$AnalysisState {
         variant: variant,
         initialMoveCursor: currentPath.size,
       );
+
+  static AnalysisOptions get broadcastOptions => const AnalysisOptions(
+        id: standaloneAnalysisId,
+        isLocalEvaluationAllowed: true,
+        orientation: Side.white,
+        variant: Variant.standard,
+        isBroadcast: true,
+      );
 }
 
 @freezed

lib/src/model/broadcast/broadcast.dart

@@ -17,7 +17,7 @@ class Broadcast with _$Broadcast {
   const Broadcast._();
 
   const factory Broadcast({
-    required BroadcastTournament tour,
+    required BroadcastTournamentData tour,
     required BroadcastRound round,
     required String? group,
 
@@ -32,9 +32,42 @@ class Broadcast with _$Broadcast {
   String get title => group ?? tour.name;
 }
 
-typedef BroadcastTournament = ({
+@freezed
+class BroadcastTournament with _$BroadcastTournament {
+  const factory BroadcastTournament({
+    required BroadcastTournamentData data,
+    required IList<BroadcastRound> rounds,
+    required BroadcastRoundId defaultRoundId,
+    required IList<BroadcastTournamentGroup>? group,
+  }) = _BroadcastTournament;
+}
+
+@freezed
+class BroadcastTournamentData with _$BroadcastTournamentData {
+  const factory BroadcastTournamentData({
+    required BroadcastTournamentId id,
+    required String name,
+    required String? imageUrl,
+    required String? description,
+    required BroadcastTournamentInformation information,
+  }) = _BroadcastTournamentData;
+}
+
+typedef BroadcastTournamentInformation = ({
+  String? format,
+  String? timeControl,
+  String? players,
+  BroadcastTournamentDates? dates,
+});
+
+typedef BroadcastTournamentDates = ({
+  DateTime startsAt,
+  DateTime? endsAt,
+});
+
+typedef BroadcastTournamentGroup = ({
+  BroadcastTournamentId id,
   String name,
-  String? imageUrl,
 });
 
 @freezed
@@ -45,25 +78,37 @@ class BroadcastRound with _$BroadcastRound {
     required BroadcastRoundId id,
     required String name,
     required RoundStatus status,
-    required DateTime startsAt,
+    required DateTime? startsAt,
   }) = _BroadcastRound;
 }
 
-typedef BroadcastRoundGames = IMap<BroadcastGameId, BroadcastGameSnapshot>;
+typedef BroadcastRoundGames = IMap<BroadcastGameId, BroadcastGame>;
 
 @freezed
-class BroadcastGameSnapshot with _$BroadcastGameSnapshot {
-  const BroadcastGameSnapshot._();
+class BroadcastGame with _$BroadcastGame {
+  const BroadcastGame._();
 
-  const factory BroadcastGameSnapshot({
+  const factory BroadcastGame({
+    required BroadcastGameId id,
     required IMap<Side, BroadcastPlayer> players,
     required String fen,
     required Move? lastMove,
-    required String status,
+    required String? status,
 
     /// The amount of time that the player whose turn it is has been thinking since his last move
-    required Duration? thinkTime,
-  }) = _BroadcastGameSnapshot;
+    required Duration thinkTime,
+  }) = _BroadcastGame;
+
+  bool get isPlaying => status == '*';
+  Side get playingSide => Setup.parseFen(fen).turn;
+  Duration? get timeLeft {
+    final clock = players[playingSide]!.clock;
+    if (clock == null) return null;
+    final timeLeftMaybeNegative = clock - thinkTime;
+    return timeLeftMaybeNegative.isNegative
+        ? Duration.zero
+        : timeLeftMaybeNegative;
+  }
 }
 
 @freezed

lib/src/model/broadcast/broadcast_game_controller.dart

@@ -0,0 +1,111 @@
+import 'dart:async';
+
+import 'package:deep_pick/deep_pick.dart';
+import 'package:lichess_mobile/src/model/analysis/analysis_controller.dart';
+import 'package:lichess_mobile/src/model/broadcast/broadcast_providers.dart';
+import 'package:lichess_mobile/src/model/common/chess.dart';
+import 'package:lichess_mobile/src/model/common/id.dart';
+import 'package:lichess_mobile/src/network/socket.dart';
+import 'package:lichess_mobile/src/utils/json.dart';
+import 'package:riverpod_annotation/riverpod_annotation.dart';
+
+part 'broadcast_game_controller.g.dart';
+
+@riverpod
+class BroadcastGameController extends _$BroadcastGameController {
+  static Uri broadcastSocketUri(BroadcastRoundId broadcastRoundId) =>
+      Uri(path: 'study/$broadcastRoundId/socket/v6');
+
+  StreamSubscription<SocketEvent>? _subscription;
+
+  late SocketClient _socketClient;
+
+  @override
+  Future<String> build(BroadcastRoundId roundId, BroadcastGameId gameId) async {
+    _socketClient = ref
+        .watch(socketPoolProvider)
+        .open(BroadcastGameController.broadcastSocketUri(roundId));
+
+    _subscription = _socketClient.stream.listen(_handleSocketEvent);
+
+    ref.onDispose(() {
+      _subscription?.cancel();
+    });
+
+    final pgn = await ref.watch(
+      broadcastGameProvider(roundId: roundId, gameId: gameId).future,
+    );
+    return pgn;
+  }
+
+  void _handleSocketEvent(SocketEvent event) {
+    if (!state.hasValue) return;
+
+    switch (event.topic) {
+      // Sent when a node is recevied from the broadcast
+      case 'addNode':
+        _handleAddNodeEvent(event);
+      // Sent when a pgn tag changes
+      case 'setTags':
+        _handleSetTagsEvent(event);
+    }
+  }
+
+  void _handleAddNodeEvent(SocketEvent event) {
+    final broadcastGameId =
+        pick(event.data, 'p', 'chapterId').asBroadcastGameIdOrThrow();
+
+    // We check if the event is for this game
+    if (broadcastGameId != gameId) return;
+
+    // The path of the last and current move of the broadcasted game
+    // Its value is "!" if the path is identical to one of the node that was received
+    final currentPath = pick(event.data, 'relayPath').asUciPathOrThrow();
+
+    // We check that the event we received is for the last move of the game
+    if (currentPath.value != '!') return;
+
+    // The path for the node that was received
+    final path = pick(event.data, 'p', 'path').asUciPathOrThrow();
+    final uciMove = pick(event.data, 'n', 'uci').asUciMoveOrThrow();
+    final clock =
+        pick(event.data, 'n', 'clock').asDurationFromCentiSecondsOrNull();
+
+    final ctrlProviderNotifier = ref.read(
+      analysisControllerProvider(
+        state.requireValue,
+        AnalysisState.broadcastOptions,
+      ).notifier,
+    );
+
+    ctrlProviderNotifier.onBroadcastMove(path, uciMove, clock);
+  }
+
+  void _handleSetTagsEvent(SocketEvent event) {
+    final broadcastGameId =
+        pick(event.data, 'chapterId').asBroadcastGameIdOrThrow();
+
+    // We check if the event is for this game
+    if (broadcastGameId != gameId) return;
+
+    final ctrlProviderNotifier = ref.read(
+      analysisControllerProvider(
+        state.requireValue,
+        AnalysisState.broadcastOptions,
+      ).notifier,
+    );
+
+    final headers = Map.fromEntries(
+      pick(event.data, 'tags').asListOrThrow(
+        (header) => MapEntry(
+          header(0).asStringOrThrow(),
+          header(1).asStringOrThrow(),
+        ),
+      ),
+    );
+
+    for (final entry in headers.entries) {
+      ctrlProviderNotifier.updatePgnHeader(entry.key, entry.value);
+    }
+  }
+}