Implement lichess announces notifications (#2786)

Author: veloce

lib/src/app.dart

@@ -11,6 +11,7 @@ import 'package:lichess_mobile/src/app_links.dart';
 import 'package:lichess_mobile/src/log.dart';
 import 'package:lichess_mobile/src/model/account/account_service.dart';
 import 'package:lichess_mobile/src/model/account/ongoing_game.dart';
+import 'package:lichess_mobile/src/model/announce/announce_service.dart';
 import 'package:lichess_mobile/src/model/challenge/challenge_service.dart';
 import 'package:lichess_mobile/src/model/common/preloaded_data.dart';
 import 'package:lichess_mobile/src/model/correspondence/correspondence_service.dart';
@@ -82,6 +83,7 @@ class _AppState extends ConsumerState<Application> {
     ref.read(accountServiceProvider).start();
     ref.read(correspondenceServiceProvider).start();
     ref.read(quickActionServiceProvider).start();
+    ref.read(announceServiceProvider).start();
 
     // Listen for connectivity changes and perform actions accordingly.
     ref.listenManual(connectivityChangesProvider, (prev, current) async {

lib/src/init.dart

@@ -81,6 +81,7 @@ Future<void> initializeLocalNotifications(Locale locale) async {
         notificationCategories: <DarwinNotificationCategory>[
           ChallengeNotification.darwinPlayableVariantCategory(l10n),
           ChallengeNotification.darwinUnplayableVariantCategory(l10n),
+          AnnounceNotification.darwinCategory(l10n),
         ],
       ),
       linux: const LinuxInitializationSettings(defaultActionName: 'Action'),

lib/src/model/announce/announce_service.dart

@@ -0,0 +1,81 @@
+import 'dart:async';
+
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:lichess_mobile/src/model/common/socket.dart';
+import 'package:lichess_mobile/src/model/notifications/notification_service.dart';
+import 'package:lichess_mobile/src/model/notifications/notifications.dart';
+import 'package:lichess_mobile/src/network/socket.dart';
+
+final announceServiceProvider = Provider<AnnounceService>((ref) {
+  final service = AnnounceService(ref);
+  ref.onDispose(service._dispose);
+  return service;
+});
+
+class AnnounceService {
+  AnnounceService(this._ref);
+
+  final Ref _ref;
+
+  StreamSubscription<SocketEvent>? _socketSubscription;
+  StreamSubscription<ParsedLocalNotification>? _responseSubscription;
+  Timer? _dismissTimer;
+
+  void start() {
+    _socketSubscription = socketGlobalStream.listen(_handleSocketEvent);
+    _responseSubscription = NotificationService.responseStream.listen(_handleNotificationResponse);
+  }
+
+  void _dispose() {
+    _socketSubscription?.cancel();
+    _responseSubscription?.cancel();
+    _dismissTimer?.cancel();
+  }
+
+  void _handleNotificationResponse(ParsedLocalNotification event) {
+    final (response, notification) = event;
+    if (notification is AnnounceNotification &&
+        response.actionId == AnnounceNotification.dismissActionId) {
+      _cancelAnnounce();
+    }
+  }
+
+  void _handleSocketEvent(SocketEvent event) {
+    if (event.topic != 'announce') return;
+
+    final data = event.data;
+    if (data == null || data is! Map<String, dynamic> || data.isEmpty) {
+      _cancelAnnounce();
+      return;
+    }
+
+    final msg = data['msg'] as String?;
+    if (msg == null || msg.isEmpty) {
+      _cancelAnnounce();
+      return;
+    }
+
+    final dateStr = data['date'] as String?;
+    final date = dateStr != null ? DateTime.tryParse(dateStr) : null;
+
+    _dismissTimer?.cancel();
+    _dismissTimer = null;
+
+    if (date != null) {
+      final remaining = date.difference(DateTime.now());
+      if (remaining.isNegative) {
+        _cancelAnnounce();
+        return;
+      }
+      _dismissTimer = Timer(remaining, _cancelAnnounce);
+    }
+
+    _ref.read(notificationServiceProvider).show(AnnounceNotification(msg, date: date));
+  }
+
+  void _cancelAnnounce() {
+    _dismissTimer?.cancel();
+    _dismissTimer = null;
+    _ref.read(notificationServiceProvider).cancel(AnnounceNotification.notificationId);
+  }
+}

lib/src/model/notifications/notifications.dart

@@ -9,6 +9,7 @@ import 'package:lichess_mobile/src/model/common/id.dart';
 import 'package:lichess_mobile/src/model/game/playable_game.dart';
 import 'package:lichess_mobile/src/model/user/user.dart' show TemporaryBan;
 import 'package:lichess_mobile/src/utils/json.dart';
+import 'package:lichess_mobile/src/utils/l10n.dart' show relativeDate;
 import 'package:meta/meta.dart';
 
 /// FCM Messages
@@ -226,6 +227,8 @@ sealed class LocalNotification {
         return ChallengeAcceptedNotification.fromJson(json);
       case 'challengeCreate':
         return ChallengeCreatedNotification.fromJson(json);
+      case 'announce':
+        return AnnounceNotification.fromJson(json);
       default:
         throw ArgumentError('Unknown notification channel: $channel');
     }
@@ -518,6 +521,84 @@ class ChallengeCreatedNotification extends LocalNotification {
   );
 }
 
+/// A notification for a server-wide announcement.
+///
+/// There can only be one announce notification at a time. It is shown when the server
+/// sends an announce message through the WebSocket, and cancelled when the server
+/// clears it or the optional countdown date is reached.
+class AnnounceNotification extends LocalNotification {
+  const AnnounceNotification(this.message, {this.date});
+
+  final String message;
+
+  /// Optional date shown as a relative time in the notification body.
+  final DateTime? date;
+
+  static final int notificationId = 'announce'.hashCode;
+
+  static const _channelId = 'announce';
+
+  static const dismissActionId = 'dismiss';
+
+  static const darwinCategoryId = 'announce-notification';
+
+  factory AnnounceNotification.fromJson(Map<String, dynamic> json) {
+    final dateStr = json['date'] as String?;
+    return AnnounceNotification(
+      json['message'] as String,
+      date: dateStr != null ? DateTime.parse(dateStr) : null,
+    );
+  }
+
+  static DarwinNotificationCategory darwinCategory(AppLocalizations l10n) =>
+      DarwinNotificationCategory(
+        darwinCategoryId,
+        actions: [
+          DarwinNotificationAction.plain(dismissActionId, l10n.mobileCustomizeHomeTipDismiss),
+        ],
+      );
+
+  @override
+  int get id => notificationId;
+
+  @override
+  String get channelId => _channelId;
+
+  @override
+  Map<String, dynamic> get _concretePayload => {
+    'message': message,
+    if (date != null) 'date': date!.toIso8601String(),
+  };
+
+  @override
+  String title(AppLocalizations _) => message;
+
+  @override
+  String? body(AppLocalizations l10n) => date != null ? relativeDate(l10n, date!) : null;
+
+  @override
+  NotificationDetails details(AppLocalizations l10n) => NotificationDetails(
+    android: AndroidNotificationDetails(
+      _channelId,
+      'Lichess Announcements',
+      importance: Importance.high,
+      priority: Priority.high,
+      autoCancel: false,
+      actions: [
+        AndroidNotificationAction(
+          dismissActionId,
+          l10n.mobileCustomizeHomeTipDismiss,
+          showsUserInterface: false,
+        ),
+      ],
+    ),
+    iOS: const DarwinNotificationDetails(
+      threadIdentifier: _channelId,
+      categoryIdentifier: darwinCategoryId,
+    ),
+  );
+}
+
 /// A notification for a received challenge.
 ///
 /// This notification is shown when a challenge is received from the server through

lib/src/network/socket.dart

@@ -40,7 +40,7 @@ const _kDisconnectOnBackgroundTimeout = Duration(minutes: 1);
 final _logger = Logger('Socket');
 
 /// Set of topics that are allowed to be broadcasted to the global stream.
-const _globalSocketStreamAllowedTopics = {'n', 'message', 'challenges'};
+const _globalSocketStreamAllowedTopics = {'n', 'message', 'challenges', 'announce'};
 
 final _globalStreamController = StreamController<SocketEvent>.broadcast();