Feat/in app notification center

README.md

@@ -50,7 +50,7 @@ A robust, backend-driven notification system keeps users informed and brings the
 - **Multi-Provider Architecture:** Built on an abstraction that supports any push notification service. It ships with production-ready providers for Firebase (FCM) and OneSignal.
 - **Remote Provider Switching:** The primary notification provider is selected via remote configuration, allowing you to switch services on the fly without shipping an app update.
 - **Intelligent Deep-Linking:** Tapping a notification opens the app and navigates directly to the relevant content, such as a specific news article, providing a seamless user experience.
-- **Foreground Notification Handling:** Displays a subtle in-app indicator when a notification arrives while the user is active, avoiding intrusive alerts.
+- **Integrated Notification Center:** Includes a full-featured in-app notification center where users can view their history. Foreground notifications are handled gracefully, appearing as an unread indicator that leads the user to this central hub, avoiding intrusive system alerts during active use.
 > **Your Advantage:** You get a highly flexible and scalable notification system that avoids vendor lock-in and is ready to re-engage users from day one.
 
 </details>

lib/account/bloc/in_app_notification_center_bloc.dart

@@ -0,0 +1,244 @@
+import 'dart:async';
+
+import 'package:bloc/bloc.dart';
+import 'package:core/core.dart';
+import 'package:data_repository/data_repository.dart';
+import 'package:equatable/equatable.dart';
+import 'package:flutter_news_app_mobile_client_full_source_code/app/bloc/app_bloc.dart';
+import 'package:logging/logging.dart';
+
+part 'in_app_notification_center_event.dart';
+part 'in_app_notification_center_state.dart';
+
+/// {@template in_app_notification_center_bloc}
+/// Manages the state for the in-app notification center.
+///
+/// This BLoC is responsible for fetching the user's notifications,
+/// handling actions to mark them as read individually or in bulk, and
+/// coordinating with the global [AppBloc] to update the unread status
+/// indicator across the app.
+/// {@endtemplate}
+class InAppNotificationCenterBloc
+    extends Bloc<InAppNotificationCenterEvent, InAppNotificationCenterState> {
+  /// {@macro in_app_notification_center_bloc}
+  InAppNotificationCenterBloc({
+    required DataRepository<InAppNotification> inAppNotificationRepository,
+    required AppBloc appBloc,
+    required Logger logger,
+  }) : _inAppNotificationRepository = inAppNotificationRepository,
+       _appBloc = appBloc,
+       _logger = logger,
+       super(const InAppNotificationCenterState()) {
+    on<InAppNotificationCenterSubscriptionRequested>(_onSubscriptionRequested);
+    on<InAppNotificationCenterMarkedAsRead>(_onMarkedAsRead);
+    on<InAppNotificationCenterMarkAllAsRead>(_onMarkAllAsRead);
+    on<InAppNotificationCenterTabChanged>(_onTabChanged);
+  }
+
+  final DataRepository<InAppNotification> _inAppNotificationRepository;
+  final AppBloc _appBloc;
+  final Logger _logger;
+
+  /// Handles the request to load all notifications for the current user.
+  Future<void> _onSubscriptionRequested(
+    InAppNotificationCenterSubscriptionRequested event,
+    Emitter<InAppNotificationCenterState> emit,
+  ) async {
+    emit(state.copyWith(status: InAppNotificationCenterStatus.loading));
+
+    final userId = _appBloc.state.user?.id;
+    if (userId == null) {
+      _logger.warning('Cannot fetch notifications: user is not logged in.');
+      emit(state.copyWith(status: InAppNotificationCenterStatus.failure));
+      return;
+    }
+
+    try {
+      final response = await _inAppNotificationRepository.readAll(
+        userId: userId,
+        sort: [const SortOption('createdAt', SortOrder.desc)],
+      );
+
+      final allNotifications = response.items;
+
+      final breakingNews = <InAppNotification>[];
+      final digests = <InAppNotification>[];
+
+      // Filter notifications into their respective categories based on the
+      // contentType specified in the payload's data map.
+      for (final n in allNotifications) {
+        final contentType = n.payload.data['contentType'] as String?;
+        if (contentType == 'digest') {
+          digests.add(n);
+        } else {
+          // Treat 'headline' and any other unknown types as breaking news
+          // to ensure all notifications are visible to the user.
+          breakingNews.add(n);
+        }
+      }
+
+      emit(
+        state.copyWith(
+          status: InAppNotificationCenterStatus.success,
+          breakingNewsNotifications: breakingNews,
+          digestNotifications: digests,
+        ),
+      );
+    } on HttpException catch (e, s) {
+      _logger.severe('Failed to fetch in-app notifications.', e, s);
+      emit(
+        state.copyWith(status: InAppNotificationCenterStatus.failure, error: e),
+      );
+    } catch (e, s) {
+      _logger.severe(
+        'An unexpected error occurred while fetching in-app notifications.',
+        e,
+        s,
+      );
+      emit(
+        state.copyWith(
+          status: InAppNotificationCenterStatus.failure,
+          error: UnknownException(e.toString()),
+        ),
+      );
+    }
+  }
+
+  /// Handles the event to change the active tab.
+  Future<void> _onTabChanged(
+    InAppNotificationCenterTabChanged event,
+    Emitter<InAppNotificationCenterState> emit,
+  ) async {
+    emit(state.copyWith(currentTabIndex: event.tabIndex));
+  }
+
+  /// Handles marking a single notification as read.
+  Future<void> _onMarkedAsRead(
+    InAppNotificationCenterMarkedAsRead event,
+    Emitter<InAppNotificationCenterState> emit,
+  ) async {
+    final notification = state.notifications.firstWhere(
+      (n) => n.id == event.notificationId,
+      orElse: () => throw Exception('Notification not found in state'),
+    );
+
+    // If already read, do nothing.
+    if (notification.isRead) return;
+
+    final updatedNotification = notification.copyWith(readAt: DateTime.now());
+
+    try {
+      await _inAppNotificationRepository.update(
+        id: notification.id,
+        item: updatedNotification,
+        userId: _appBloc.state.user?.id,
+      );
+
+      // Update the local state to reflect the change immediately.
+      final updatedBreakingNewsList = state.breakingNewsNotifications
+          .map((n) => n.id == notification.id ? updatedNotification : n)
+          .toList();
+
+      final updatedDigestList = state.digestNotifications
+          .map((n) => n.id == notification.id ? updatedNotification : n)
+          .toList();
+
+      emit(
+        state.copyWith(
+          breakingNewsNotifications: updatedBreakingNewsList,
+          digestNotifications: updatedDigestList,
+        ),
+      );
+
+      // Notify the global AppBloc to re-check the unread count.
+      _appBloc.add(const AppInAppNotificationMarkedAsRead());
+    } on HttpException catch (e, s) {
+      _logger.severe(
+        'Failed to mark notification ${notification.id} as read.',
+        e,
+        s,
+      );
+      emit(
+        state.copyWith(status: InAppNotificationCenterStatus.failure, error: e),
+      );
+      // Do not revert state to avoid UI flicker. The error is logged.
+    } catch (e, s) {
+      _logger.severe(
+        'An unexpected error occurred while marking notification as read.',
+        e,
+        s,
+      );
+      emit(
+        state.copyWith(
+          status: InAppNotificationCenterStatus.failure,
+          error: UnknownException(e.toString()),
+        ),
+      );
+    }
+  }
+
+  /// Handles marking all unread notifications as read.
+  Future<void> _onMarkAllAsRead(
+    InAppNotificationCenterMarkAllAsRead event,
+    Emitter<InAppNotificationCenterState> emit,
+  ) async {
+    final unreadNotifications = state.notifications
+        .where((n) => !n.isRead)
+        .toList();
+
+    if (unreadNotifications.isEmpty) return;
+
+    final now = DateTime.now();
+    final updatedNotifications = unreadNotifications
+        .map((n) => n.copyWith(readAt: now))
+        .toList();
+
+    try {
+      // Perform all updates in parallel.
+      await Future.wait(
+        updatedNotifications.map(
+          (n) => _inAppNotificationRepository.update(
+            id: n.id,
+            item: n,
+            userId: _appBloc.state.user?.id,
+          ),
+        ),
+      );
+
+      // Update local state with all notifications marked as read.
+      final fullyUpdatedBreakingNewsList = state.breakingNewsNotifications
+          .map((n) => n.isRead ? n : n.copyWith(readAt: now))
+          .toList();
+
+      final fullyUpdatedDigestList = state.digestNotifications
+          .map((n) => n.isRead ? n : n.copyWith(readAt: now))
+          .toList();
+      emit(
+        state.copyWith(
+          breakingNewsNotifications: fullyUpdatedBreakingNewsList,
+          digestNotifications: fullyUpdatedDigestList,
+        ),
+      );
+
+      // Notify the global AppBloc to clear the unread indicator.
+      _appBloc.add(const AppAllInAppNotificationsMarkedAsRead());
+    } on HttpException catch (e, s) {
+      _logger.severe('Failed to mark all notifications as read.', e, s);
+      emit(
+        state.copyWith(status: InAppNotificationCenterStatus.failure, error: e),
+      );
+    } catch (e, s) {
+      _logger.severe(
+        'An unexpected error occurred while marking all notifications as read.',
+        e,
+        s,
+      );
+      emit(
+        state.copyWith(
+          status: InAppNotificationCenterStatus.failure,
+          error: UnknownException(e.toString()),
+        ),
+      );
+    }
+  }
+}

lib/account/bloc/in_app_notification_center_event.dart

@@ -0,0 +1,44 @@
+part of 'in_app_notification_center_bloc.dart';
+
+/// Base class for all events in the [InAppNotificationCenterBloc].
+abstract class InAppNotificationCenterEvent extends Equatable {
+  const InAppNotificationCenterEvent();
+
+  @override
+  List<Object> get props => [];
+}
+
+/// Dispatched when the notification center is opened and needs to load
+/// the initial list of notifications.
+class InAppNotificationCenterSubscriptionRequested
+    extends InAppNotificationCenterEvent {
+  const InAppNotificationCenterSubscriptionRequested();
+}
+
+/// Dispatched when a single in-app notification is marked as read.
+class InAppNotificationCenterMarkedAsRead extends InAppNotificationCenterEvent {
+  const InAppNotificationCenterMarkedAsRead(this.notificationId);
+
+  /// The ID of the notification to be marked as read.
+  final String notificationId;
+
+  @override
+  List<Object> get props => [notificationId];
+}
+
+/// Dispatched when the user requests to mark all notifications as read.
+class InAppNotificationCenterMarkAllAsRead
+    extends InAppNotificationCenterEvent {
+  const InAppNotificationCenterMarkAllAsRead();
+}
+
+/// Dispatched when the user changes the selected tab in the notification center.
+class InAppNotificationCenterTabChanged extends InAppNotificationCenterEvent {
+  const InAppNotificationCenterTabChanged(this.tabIndex);
+
+  /// The index of the newly selected tab. 0: Breaking News, 1: Digests.
+  final int tabIndex;
+
+  @override
+  List<Object> get props => [tabIndex];
+}

lib/account/bloc/in_app_notification_center_state.dart

@@ -0,0 +1,80 @@
+part of 'in_app_notification_center_bloc.dart';
+
+/// The status of the [InAppNotificationCenterBloc].
+enum InAppNotificationCenterStatus {
+  /// The initial state.
+  initial,
+
+  /// The state when notifications are being loaded.
+  loading,
+
+  /// The state when notifications have been successfully loaded.
+  success,
+
+  /// The state when an error has occurred.
+  failure,
+}
+
+/// {@template in_app_notification_center_state}
+/// The state of the in-app notification center.
+/// {@endtemplate}
+class InAppNotificationCenterState extends Equatable {
+  /// {@macro in_app_notification_center_state}
+  const InAppNotificationCenterState({
+    this.status = InAppNotificationCenterStatus.initial,
+    this.breakingNewsNotifications = const [],
+    this.digestNotifications = const [],
+    this.currentTabIndex = 0,
+    this.error,
+  });
+
+  /// The currently selected tab index.
+  /// 0: Breaking News, 1: Digests.
+  final int currentTabIndex;
+
+  /// The list of breaking news notifications.
+  final List<InAppNotification> breakingNewsNotifications;
+
+  /// The list of digest notifications (daily and weekly roundups).
+  final List<InAppNotification> digestNotifications;
+
+  /// The current status of the notification center.
+  final InAppNotificationCenterStatus status;
+
+  /// The combined list of all notifications.
+  List<InAppNotification> get notifications => [
+    ...breakingNewsNotifications,
+    ...digestNotifications,
+  ];
+
+  /// An error that occurred during notification loading or processing.
+  final HttpException? error;
+
+  @override
+  List<Object> get props => [
+    status,
+    currentTabIndex,
+    breakingNewsNotifications,
+    digestNotifications,
+    error ?? Object(), // Include error in props, handle nullability
+  ];
+
+  /// Creates a copy of this state with the given fields replaced with the new
+  /// values.
+  InAppNotificationCenterState copyWith({
+    InAppNotificationCenterStatus? status,
+    HttpException? error,
+    int? currentTabIndex,
+    List<InAppNotification>? breakingNewsNotifications,
+    List<InAppNotification>? digestNotifications,
+  }) {
+    return InAppNotificationCenterState(
+      status: status ?? this.status,
+      error: error ?? this.error,
+      currentTabIndex: currentTabIndex ?? this.currentTabIndex,
+      breakingNewsNotifications:
+          breakingNewsNotifications ?? this.breakingNewsNotifications,
+      digestNotifications: digestNotifications ?? this.digestNotifications,
+    );
+  }
+}