notification_service.dart

Go to the documentation of this file.

import 'dart:async';
import 'dart:convert';
import 'dart:io';
 
import 'package:connect/core/router/routes.dart';
import 'package:firebase_core/firebase_core.dart';
import 'package:firebase_messaging/firebase_messaging.dart';
import 'package:flutter_local_notifications/flutter_local_notifications.dart';
import 'package:cloud_firestore/cloud_firestore.dart';
import 'package:go_router/go_router.dart';
import 'package:connect/core/router/router.dart' show rootNavigatorKey;
import 'package:shared_preferences/shared_preferences.dart';
import '../../features/authentication/domain/entities/session_entity.dart';
import 'package:flutter_bloc/flutter_bloc.dart';
import '../../features/collections/presentation/logic/collection_requests_history_bloc/collection_requests_history_bloc.dart';
import '../../features/authentication/presentation/logic/authentication_bloc/authentication_bloc.dart';
 
@pragma('vm:entry-point')
Future<void> firebaseMessagingBackgroundHandler(RemoteMessage message) async {
  await Firebase.initializeApp();
  await SharedPreferences.getInstance().then((prefs) {
    if (message.data['type'] == 'business') {
      prefs.setString('pending_notification', json.encode(message.data));
    }
  });
}
 
class NotificationService {
  bool _hasPendingNavigation = false;
  final navigatorKey = rootNavigatorKey;
  static final NotificationService _instance = NotificationService._internal();
  factory NotificationService() => _instance;
 
  NotificationService._internal();
 
  SessionEntity? _currentSession;
 
  final FirebaseMessaging _firebaseMessaging = FirebaseMessaging.instance;
  final FlutterLocalNotificationsPlugin _flutterLocalNotificationsPlugin =
      FlutterLocalNotificationsPlugin();
 
  void updateSession(SessionEntity? session) {
    _currentSession = session;
  }
 
  Future<void> init() async {
    await _firebaseMessaging.setForegroundNotificationPresentationOptions(
      alert: true,
      badge: true,
      sound: true,
    );
 
    NotificationSettings settings = await _firebaseMessaging.requestPermission(
      alert: true,
      badge: true,
      sound: true,
      provisional: false,
    );
 
    if (settings.authorizationStatus == AuthorizationStatus.authorized) {
      await _initLocalNotifications();
      FirebaseMessaging.onMessage.listen(_handleForegroundMessage);
      FirebaseMessaging.onMessageOpenedApp.listen(_handleNotificationTap);
      FirebaseMessaging.onBackgroundMessage(firebaseMessagingBackgroundHandler);
      await _checkPendingNotification();
    }
  }
 
  Future<void> _checkPendingNotification() async {
    final prefs = await SharedPreferences.getInstance();
    final pendingNotification = prefs.getString('pending_notification');
    final wasClicked = prefs.getBool('notification_clicked') ?? false;
 
    if (pendingNotification != null && wasClicked) {
      _hasPendingNavigation = true;
    } else {
      final initialMessage = await _firebaseMessaging.getInitialMessage();
      if (initialMessage != null) {
        await prefs.setString(
          'pending_notification',
          json.encode(initialMessage.data),
        );
        await prefs.setBool('notification_clicked', true);
        _hasPendingNavigation = true;
      }
    }
  }
 
  Future<void> setupAfterAuthentication(SessionEntity session) async {
    updateSession(session);
    String? token = await _firebaseMessaging.getToken();
    if (token != null) {
      await _saveDeviceToken(token);
    }
    _firebaseMessaging.onTokenRefresh.listen(_saveDeviceToken);
 
    if (_hasPendingNavigation) {
      Future.delayed(const Duration(milliseconds: 500), () async {
        _hasPendingNavigation = false;
        final prefs = await SharedPreferences.getInstance();
        final pendingNotification = prefs.getString('pending_notification');
        if (pendingNotification != null) {
          final data = json.decode(pendingNotification);
          _navigateBasedOnNotification(data);
          // Clear both notification data and click flag
          await prefs.remove('pending_notification');
          await prefs.remove('notification_clicked');
        }
      });
    }
  }
 
  Future<void> _initLocalNotifications() async {
    const AndroidInitializationSettings initializationSettingsAndroid =
        AndroidInitializationSettings('@mipmap/ic_launcher');
 
    final DarwinInitializationSettings initializationSettingsIOS =
        DarwinInitializationSettings(
      requestSoundPermission: true,
      requestBadgePermission: true,
      requestAlertPermission: true,
    );
 
    final InitializationSettings initializationSettings =
        InitializationSettings(
      android: initializationSettingsAndroid,
      iOS: initializationSettingsIOS,
    );
 
    await _flutterLocalNotificationsPlugin.initialize(
      initializationSettings,
      onDidReceiveNotificationResponse: _onNotificationTap,
    );
  }
 
  Future<void> _saveDeviceToken(String token) async {
    if (_currentSession?.partnerId == null) return;
 
    final parentId = _currentSession!.parentId.toString();
    final deviceTokenDoc = {
      'token': token,
      'platform': Platform.operatingSystem,
      'loginTimestamp': FieldValue.serverTimestamp(),
      'isActive': true,
    };
 
    await FirebaseFirestore.instance
        .collection('users')
        .doc(parentId)
        .collection('deviceTokens')
        .doc(token)
        .set(deviceTokenDoc, SetOptions(merge: true));
  }
 
  Future<void> removeDeviceToken(String token) async {
    if (_currentSession?.parentId == null) return;
 
    final parentId = _currentSession!.parentId.toString();
    await FirebaseFirestore.instance
        .collection('users')
        .doc(parentId)
        .collection('deviceTokens')
        .doc(token)
        .update({'isActive': false});
  }
 
  Future<void> _handleForegroundMessage(RemoteMessage message) async {
    if (message.notification != null) {
      _showLocalNotification(
        title: message.notification!.title ?? 'Notification',
        body: message.notification!.body ?? '',
        payload: message.data,
      );
    }
  }
 
  Future<void> _showLocalNotification({
    required String title,
    required String body,
    required Map<String, dynamic> payload,
  }) async {
    const AndroidNotificationDetails androidPlatformChannelSpecifics =
        AndroidNotificationDetails(
      'high_importance_channel',
      'High Importance Notifications',
      importance: Importance.max,
      priority: Priority.high,
    );
 
    const DarwinNotificationDetails iOSPlatformChannelSpecifics =
        DarwinNotificationDetails(
      presentAlert: true,
      presentBadge: true,
      presentSound: true,
    );
 
    const NotificationDetails platformChannelSpecifics = NotificationDetails(
      android: androidPlatformChannelSpecifics,
      iOS: iOSPlatformChannelSpecifics,
    );
 
    await _flutterLocalNotificationsPlugin.show(
      0,
      title,
      body,
      platformChannelSpecifics,
      payload: json.encode(payload),
    );
  }
 
  void _handleNotificationTap(RemoteMessage message) async {
    await SharedPreferences.getInstance().then((prefs) {
      prefs.setBool('notification_clicked', true);
    });
 
    _navigateBasedOnNotification(message.data);
  }
 
  void _onNotificationTap(NotificationResponse notificationResponse) {
    if (notificationResponse.payload != null) {
      final payload = _parsePayload(notificationResponse.payload!);
      _navigateBasedOnNotification(payload);
    }
  }
 
  Map<String, dynamic> _parsePayload(String payloadString) {
    try {
      return json.decode(payloadString);
    } catch (e) {
      return {};
    }
  }
 
  void _navigateBasedOnNotification(Map<String, dynamic> data) {
    final String? notificationType = data['type'] as String?;
    if (notificationType == 'business') {
      final context = rootNavigatorKey.currentContext!;
      final authState = context.read<AuthenticationBloc>().state;
      if (authState is AuthenticatedState) {
        final String? partnerId = authState.session.partnerId;
        if (partnerId != null) {
          context.read<CollectionRequestsHistoryBloc>().add(
                LoadOnGoingCollectionRequestsEvent(
                  partnerId: partnerId,
                ),
              );
          GoRouter.of(context).push(Routes.transactionHistory.route);
        }
      }
    }
  }
}