feat(notifications): implement push notification token refresh handling

fulleni · fulleni · commit eba2604af042 · 2025-11-20T07:33:58.000+01:00
- Add AppPushNotificationTokenRefreshed event to app_bloc.dart
- Implement token refresh listeners in Firebase and OneSignal services
- Update device registration process to use delete-then-create pattern
- Add error handling and logging for token refresh and device registration
diff --git a/lib/app/bloc/app_bloc.dart b/lib/app/bloc/app_bloc.dart
@@ -87,6 +87,14 @@ class AppBloc extends Bloc<AppEvent, AppState> {
     );
     on<AppInAppNotificationReceived>(_onAppInAppNotificationReceived);
     on<AppLogoutRequested>(_onLogoutRequested);
+    on<AppPushNotificationTokenRefreshed>(_onAppPushNotificationTokenRefreshed);
+
+    // Listen to token refresh events from the push notification service.
+    // When a token is refreshed, dispatch an event to trigger device
+    // re-registration with the backend.
+    _pushNotificationService.onTokenRefreshed.listen((_) {
+      add(const AppPushNotificationTokenRefreshed());
+    });
   }
 
   final Logger _logger;
@@ -117,6 +125,14 @@ class AppBloc extends Bloc<AppEvent, AppState> {
         '[AppBloc] App started with user ${state.user!.id}. '
         'Attempting to register device for push notifications.',
       );
+      // The PushNotificationService will handle getting the token and
+      // calling the repository's create method. This call is now wrapped in a
+      // try-catch to prevent unhandled exceptions from crashing the app if
+      // registration fails.
+      //
+      // The `registerDevice` method now implements a "delete-then-create"
+      // pattern to ensure idempotency and align with backend expectations.
+      // It uses a composite ID of userId and provider name.
       try {
         await _pushNotificationService.registerDevice(userId: state.user!.id);
         add(const AppPushNotificationDeviceRegistered());
@@ -242,11 +258,19 @@ class AppBloc extends Bloc<AppEvent, AppState> {
           'for push notifications.',
         );
         try {
-          // The PushNotificationService will handle getting the token and
-          // calling the repository's update method.
+          // The PushNotificationService will handle getting the token and calling
+          // the repository's create method. This call is now wrapped in a
+          // try-catch to prevent unhandled exceptions from crashing the app if
+          // registration fails.
+          //
+          // The `registerDevice` method now implements a "delete-then-create"
+          // pattern to ensure idempotency and align with backend expectations.
+          // It uses a composite ID of userId and provider name.
           await _pushNotificationService.registerDevice(userId: user.id);
           add(const AppPushNotificationDeviceRegistered());
         } catch (e, s) {
+          // Log the error but allow the app to continue functioning.
+          // The user can still use the app even if push registration fails.
           _logger.severe(
             '[AppBloc] Failed to register push notification device for user ${user.id}.',
             e,
@@ -640,4 +664,26 @@ class AppBloc extends Bloc<AppEvent, AppState> {
   ) {
     emit(state.copyWith(hasUnreadInAppNotifications: true));
   }
+
+  /// Handles the [AppPushNotificationTokenRefreshed] event.
+  ///
+  /// This event is triggered when the underlying push notification provider
+  /// (e.g., FCM, OneSignal) refreshes its device token. The AppBloc then
+  /// attempts to re-register the device with the backend using the current
+  /// user's ID.
+  Future<void> _onAppPushNotificationTokenRefreshed(
+    AppPushNotificationTokenRefreshed event,
+    Emitter<AppState> emit,
+  ) async {
+    if (state.user == null) {
+      _logger.info(
+        '[AppBloc] Skipping token re-registration: User is null.',
+      );
+      return;
+    }
+    _logger.info(
+      '[AppBloc] Push notification token refreshed. Re-registering device.',
+    );
+    await _pushNotificationService.registerDevice(userId: state.user!.id);
+  }
 }
diff --git a/lib/app/bloc/app_event.dart b/lib/app/bloc/app_event.dart
@@ -205,3 +205,15 @@ class AppInAppNotificationReceived extends AppEvent {
   /// {@macro app_in_app_notification_received}
   const AppInAppNotificationReceived();
 }
+
+/// {@template app_push_notification_token_refreshed}
+/// Dispatched when the underlying push notification provider refreshes its
+/// device token.
+///
+/// This event triggers the AppBloc to re-register the device with the backend
+/// using the current user's ID.
+/// {@endtemplate}
+class AppPushNotificationTokenRefreshed extends AppEvent {
+  /// {@macro app_push_notification_token_refreshed}
+  const AppPushNotificationTokenRefreshed();
+}
diff --git a/lib/notifications/services/firebase_push_notification_service.dart b/lib/notifications/services/firebase_push_notification_service.dart
@@ -25,6 +25,7 @@ class FirebasePushNotificationService implements PushNotificationService {
   final _onMessageController = StreamController<PushNotificationPayload>();
   final _onMessageOpenedAppController =
       StreamController<PushNotificationPayload>();
+  final _onTokenRefreshedController = StreamController<String>();
 
   @override
   Stream<PushNotificationPayload> get onMessage => _onMessageController.stream;
@@ -33,16 +34,19 @@ class FirebasePushNotificationService implements PushNotificationService {
   Stream<PushNotificationPayload> get onMessageOpenedApp =>
       _onMessageOpenedAppController.stream;
 
+  @override
+  Stream<String> get onTokenRefreshed => _onTokenRefreshedController.stream;
+
   @override
   Future<void> initialize() async {
     _logger.info('Initializing FirebasePushNotificationService...');
 
     // Listen for token refresh events from FCM. If the token changes while
     // the app is running, re-register the device with the new token to
     // ensure continued notification delivery.
-    FirebaseMessaging.instance.onTokenRefresh.listen((newToken) {
-      _logger.info('FCM token refreshed. Re-registering device.');
-      registerDevice(userId: ''); // userId will be updated by AppBloc
+    FirebaseMessaging.instance.onTokenRefresh.listen((newToken) async {
+      _logger.info('FCM token refreshed. Emitting new token.');
+      _onTokenRefreshedController.add(newToken);
     });
 
     // Handle messages that are tapped and open the app from a terminated state.
@@ -110,8 +114,25 @@ class FirebasePushNotificationService implements PushNotificationService {
       }
 
       _logger.fine('FCM token received for registration: $token');
-      final device = PushNotificationDevice(
-        id: token, // Use token as a unique ID for the device
+      // The device ID is now a composite key of userId and provider name to
+      // ensure idempotency and align with the backend's delete-then-create
+      // pattern.
+      final deviceId = '${userId}_${PushNotificationProvider.firebase.name}';
+
+      // First, attempt to delete any existing device registration for this user
+      // and provider. This ensures a clean state and handles token updates
+      // by effectively performing a "delete-then-create".
+      try {
+        await _pushNotificationDeviceRepository.delete(id: deviceId);
+        _logger.info('Existing device registration deleted for $deviceId.');
+      } on NotFoundException {
+        _logger.info('No existing device registration found for $deviceId. Proceeding with creation.');
+      } catch (e, s) {
+        _logger.warning('Failed to delete existing device registration for $deviceId. Proceeding with creation anyway. Error: $e', e, s);
+      }
+
+      final newDevice = PushNotificationDevice(
+        id: deviceId,
         userId: userId,
         platform: Platform.isIOS ? DevicePlatform.ios : DevicePlatform.android,
         providerTokens: {PushNotificationProvider.firebase: token},
@@ -120,9 +141,7 @@ class FirebasePushNotificationService implements PushNotificationService {
         updatedAt: DateTime.now(),
       );
 
-      // Use the standard `update` method from the repository for an
-      // idempotent "upsert" operation. The device token is the resource ID.
-      await _pushNotificationDeviceRepository.update(id: token, item: device);
+      await _pushNotificationDeviceRepository.create(item: newDevice);
       _logger.info('Device successfully registered with backend.');
     } catch (e, s) {
       _logger.severe('Failed to register device.', e, s);
@@ -147,6 +166,7 @@ class FirebasePushNotificationService implements PushNotificationService {
   Future<void> close() async {
     await _onMessageController.close();
     await _onMessageOpenedAppController.close();
+    await _onTokenRefreshedController.close();
   }
 
   @override
diff --git a/lib/notifications/services/one_signal_push_notification_service.dart b/lib/notifications/services/one_signal_push_notification_service.dart
@@ -27,6 +27,7 @@ class OneSignalPushNotificationService extends PushNotificationService {
   final _onMessageController = StreamController<PushNotificationPayload>();
   final _onMessageOpenedAppController =
       StreamController<PushNotificationPayload>();
+  final _onTokenRefreshedController = StreamController<String>();
 
   // OneSignal doesn't have a direct equivalent of `getInitialMessage`.
   // We rely on the `setNotificationOpenedHandler`.
@@ -40,6 +41,9 @@ class OneSignalPushNotificationService extends PushNotificationService {
   Stream<PushNotificationPayload> get onMessageOpenedApp =>
       _onMessageOpenedAppController.stream;
 
+  @override
+  Stream<String> get onTokenRefreshed => _onTokenRefreshedController.stream;
+
   @override
   Future<void> initialize() async {
     _logger.info('Initializing OneSignalPushNotificationService...');
@@ -49,10 +53,12 @@ class OneSignalPushNotificationService extends PushNotificationService {
     // Listen for changes to the push subscription state. If the token (player
     // ID) changes, re-register the device with the new token to ensure
     // continued notification delivery.
-    OneSignal.User.pushSubscription.addObserver((state) {
-      if (state.current.id != state.previous.id) {
-        _logger.info('OneSignal push subscription ID changed. Re-registering.');
-        registerDevice(userId: ''); // userId will be updated by AppBloc
+    OneSignal.User.pushSubscription.addObserver((state) async {
+      if (state.current.id != state.previous.id && state.current.id != null) {
+        _logger.info(
+          'OneSignal push subscription ID changed. Emitting new token.',
+        );
+        _onTokenRefreshedController.add(state.current.id!);
       }
     });
 
@@ -109,18 +115,33 @@ class OneSignalPushNotificationService extends PushNotificationService {
       }
 
       _logger.fine('OneSignal Player ID received: $token');
-      final device = PushNotificationDevice(
-        id: token, // Use player ID as a unique ID for the device
+      // The device ID is now a composite key of userId and provider name to
+      // ensure idempotency and align with the backend's delete-then-create
+      // pattern.
+      final deviceId = '${userId}_${PushNotificationProvider.oneSignal.name}';
+
+      // First, attempt to delete any existing device registration for this user
+      // and provider. This ensures a clean state and handles token updates
+      // by effectively performing a "delete-then-create".
+      try {
+        await _pushNotificationDeviceRepository.delete(id: deviceId);
+        _logger.info('Existing device registration deleted for $deviceId.');
+      } on NotFoundException {
+        _logger.info('No existing device registration found for $deviceId. Proceeding with creation.');
+      } catch (e, s) {
+        _logger.warning('Failed to delete existing device registration for $deviceId. Proceeding with creation anyway. Error: $e', e, s);
+      }
+
+      final newDevice = PushNotificationDevice(
+        id: deviceId,
         userId: userId,
         platform: Platform.isIOS ? DevicePlatform.ios : DevicePlatform.android,
         providerTokens: {PushNotificationProvider.oneSignal: token},
         createdAt: DateTime.now(),
         updatedAt: DateTime.now(),
       );
 
-      // Use the standard `update` method from the repository for an
-      // idempotent "upsert" operation. The player ID is the resource ID.
-      await _pushNotificationDeviceRepository.update(id: token, item: device);
+      await _pushNotificationDeviceRepository.create(item: newDevice);
       _logger.info('Device successfully registered with backend.');
     } catch (e, s) {
       _logger.severe('Failed to register device.', e, s);
@@ -147,6 +168,7 @@ class OneSignalPushNotificationService extends PushNotificationService {
   Future<void> close() async {
     await _onMessageController.close();
     await _onMessageOpenedAppController.close();
+    await _onTokenRefreshedController.close();
   }
 
   @override
diff --git a/lib/notifications/services/push_notification_service.dart b/lib/notifications/services/push_notification_service.dart
@@ -46,6 +46,12 @@ abstract class PushNotificationService extends Equatable {
   /// terminated.
   Stream<PushNotificationPayload> get onMessageOpenedApp;
 
+  /// A stream that emits a new device token when it is refreshed by the
+  /// underlying push notification provider.
+  ///
+  /// This is used by the AppBloc to trigger device re-registration.
+  Stream<String> get onTokenRefreshed;
+
   /// Gets the initial notification that caused the app to open from a
   /// terminated state.
   ///
