Sendbird Chat SDK Notifications Don't Trigger Firebase Messaging Callbacks

[Arhamss]

So, I've configured push notifications in my app. I'm receiving them from my backend and Sendbird. My backend push notifications work perfectly. Send bird chat push notifications also work perfectly on Android. However, in iOS, none of my push notification callbacks work.

I'm using Firebase Messaging and Local Notifications to listen and implement callbacks to incoming notifications. While these callbacks are triggering on Android, they don't trigger at all on iOS.

I know my iOS permissions, etc, are correct; otherwise, I wouldn't be receiving notifications from my backend in iOS.

My app goes into production two weeks from now and I really need to get this wrapped up. Can someone from the team help me out with this?

Here's my Firebase messaging class:

import 'dart:io';

import 'package:dawlati/core/network/shared_models/push_notification_response.dart';
import 'package:dawlati/core/network/shared_models/sendbird_notification_model.dart';
import 'package:dawlati/core/notifications/local/location_notification_service.dart';
import 'package:dawlati/core/notifications/notification_type_enum.dart';
import 'package:dawlati/utils/router/router.dart';
import 'package:firebase_messaging/firebase_messaging.dart';
import 'package:flutter/cupertino.dart';
import 'package:flutter/material.dart';

class FirebaseNotificationService {
  static final FirebaseMessaging _firebaseMessaging =
      FirebaseMessaging.instance;

  static final StreamController<Map<String, dynamic>>
      _navigationStreamController = StreamController.broadcast();

  static Stream<Map<String, dynamic>> get navigationStream =>
      _navigationStreamController.stream;

  static Future<String?> getFcmToken() async {
    try {
      String? token = '';
      token = await _firebaseMessaging.getToken();
      debugPrint('FCM Token: $token');

      if (token != null) {
        return token;
      }
    } catch (e) {
      debugPrint('Error fetching FCM token: $e');
    }
    return null;
  }

  static Future<String?> getFcmOrApnsToken() async {
    try {
      String? token = '';
      if (Platform.isIOS) {
        token = await _firebaseMessaging.getAPNSToken();
      } else {
        token = await _firebaseMessaging.getToken();
      }
      debugPrint('FCM Token: $token');

      if (token != null) {
        return token;
      }
    } catch (e) {
      debugPrint('Error fetching FCM token: $e');
    }
    return null;
  }

  static Future<void> initialize() async {
    await _firebaseMessaging.requestPermission();

    await FirebaseMessaging.instance
        .setForegroundNotificationPresentationOptions(
      alert: true,
      badge: true,
      sound: true,
    );

    await _firebaseMessaging.setAutoInitEnabled(true);
    FirebaseMessaging.onBackgroundMessage(_firebaseMessagingBackgroundHandler);
    FirebaseMessaging.onMessage.listen(_onMessageReceived);
    FirebaseMessaging.onMessageOpenedApp.listen(_onMessageOpenedApp);
  }

  @pragma('vm:entry-point')
  static Future<void> _firebaseMessagingBackgroundHandler(
    RemoteMessage message,
  ) async {
    try {
      debugPrint('Background message: ${message.data}');

      await _handleNotification(message);

      await sendNavigationEvent(message.data);
    } catch (e) {
      debugPrint('Error in background handler: $e');
    }
  }

  @pragma('vm:entry-point')
  static Future<void> _onMessageReceived(RemoteMessage message) async {
    debugPrint('Foreground message is here');
    if (Platform.isIOS) {
      await FirebaseMessaging.instance
          .setForegroundNotificationPresentationOptions(
        alert: true,
        badge: true,
        sound: true,
      );
    }

    await _handleNotification(message);
  }

  static Future<void> _handleNotification(RemoteMessage message) async {
    if (message.data.containsKey('sendbird')) {
      debugPrint('Notification is from Sendbird');
      await _handleSendbirdNotification(message);
    } else {
      debugPrint('Notification is from custom backend');
      await _handleCustomBackendNotification(message);
    }
  }

  static Future<void> _handleSendbirdNotification(RemoteMessage message) async {
    final payload = SendbirdNotificationModel.fromJson(message.data);

    final currentLocation =
        AppRouter.router.routerDelegate.currentConfiguration.uri;
    debugPrint('Current route location: $currentLocation');

    if (currentLocation.toString().contains(
        'chat_message_page?channelUrl=${payload.sendbird.channel.channelUrl}')) {
      return;
    }

    await LocalNotificationService.showSendbirdNotification(
      title: payload.sendbird.sender.name,
      body: payload.message,
      type: NotificationType.sendBird,
      notificationResponse: payload,
    );
  }

  static Future<void> _handleCustomBackendNotification(
    RemoteMessage message,
  ) async {
    final payload = PushNotificationResponseModel.fromJson(message.data);
    await LocalNotificationService.showBackendNotification(
      title: message.notification?.title ?? 'No Title',
      body: message.notification?.body ?? 'No Body',
      type: NotificationHelper.getNotificationType(payload.eventType) ??
          NotificationType.newJobListing,
      notificationResponse:
          PushNotificationResponseModel.fromJson(message.data),
    );
  }

  @pragma('vm:entry-point')
  static Future<void> _onMessageOpenedApp(RemoteMessage message) async {
    debugPrint('Notification clicked (terminated state): ${message.data}');
    await sendNavigationEvent(message.data);
  }

  static Future<void> sendNavigationEvent(Map<String, dynamic> payload) async {
    _navigationStreamController.add(payload);
  }
}