[firebase_messaging]: onMessage/onMessageOpenedApp functions not triggered when the application is terminated

[Connerrhia]

Hello, everyone. I need your help.
I send a notification using Firebase Functions and want it to open when the application is terminated. But when I click on the notification, the FirebaseMessaging.onMessageOpenedApp method does not work.
I am attaching a method to send notifications, and the notification service itself.

async function sendNotification(notificationTitle, notificationBody, notificationTrackingNumber, tokens) {
    console.log(tokens);

    const messages = [];
    for (const token of tokens) {
        const message = {
            token: token,
            notification: {
                title: notificationTitle,
                body: notificationBody,
            },
            data: {
                trackingNumber: notificationTrackingNumber,
            }
        };
        messages.push(message);
    }
    await messaging.sendAll(messages);
};

import 'dart:async';
import 'dart:io';

import 'package:connectivity_plus/connectivity_plus.dart';
import 'package:ensure_initialized/ensure_initialized.dart';
import 'package:firebase_messaging/firebase_messaging.dart';
import 'package:flutter_local_notifications/flutter_local_notifications.dart';
import 'package:get/get.dart';
import 'package:parcie/services/connctivity/connectivity_service.dart';
import 'package:parcie/services/hud/hud.dart';
import 'package:parcie/services/notifications/tracking_notification_service.dart';
import 'package:parcie_data/parcie_data.dart';
import 'package:parcie_logging/parcie_logging.dart';

// To work correctly in background, we should provide a handler.
// Accordingly to this: https://github.com/SByteDev/Parcie/pull/284#issuecomment-963870694
// For now we should not do anything on our own with the incoming notification.
// Firebase will display the background notification on its own.
Future<void> _stub(_) async {}

@pragma('vm:entry-point', true)
class NotificationsService with EnsureInitializedMixin, LogableMixin {
  static const _preProcessDelay = Duration(milliseconds: 200);
  static const _parcieNotificationChannel = 'parcie_notifications_channel';
  static const _trackingTag = 'tracking';
  static const _trackingNumberDataKey = 'trackingNumber';

  static final fltNotificationPlugin = FlutterLocalNotificationsPlugin();

  final _userSession = Get.find<UserSession>();
  final _connectivityService = Get.find<ConnectivityService>();
  final _trackingNotificationHandler = Get.find<TrackingNotificationService>();

  late final String token;
  late final StreamSubscription _onConnectivityStreamSubscription;

  bool _isNotificationActive = false;

  Future<String> _getFcmToken() async {
    return await FirebaseMessaging.instance.getToken() ?? '';
  }

  Future<void> _onNotificationOpened(RemoteMessage result) async {
    await _userSession.ensureInitialized;

    return Hud.executeFunc(() async {
      await Future.delayed(_preProcessDelay);

      final trackingNumber = result.data[_trackingNumberDataKey];

      if (trackingNumber == null) {
        return;
      }

      await _trackingNotificationHandler.tryProcessNotification(
        trackingNumber,
      );
    });
  }

  Future<void> _onNotificationViaTrackingNumberOpened(
    String trackingNumber,
  ) async {
    await _userSession.ensureInitialized;

    return Hud.executeFunc(() async {
      await Future.delayed(_preProcessDelay);

      await _trackingNotificationHandler.tryProcessNotification(
        trackingNumber,
      );
    });
  }

  void _onConnectivityUpdated(
    ConnectivityResult state,
  ) async {
    final isOfflineModeEnabled = _connectivityService.connectionChanged(state);

    if (isOfflineModeEnabled) {
      return;
    }

    await _initNotificationConfigurate();
  }

  Future initListener() async {
    _onConnectivityStreamSubscription = _connectivityService.connectivityStream
        .listen((_onConnectivityUpdated));
  }

  Future<void> _initNotificationConfigurate() async {
    if (_isNotificationActive) {
      return;
    }

    try {
      if (Platform.isIOS) {
        await FirebaseMessaging.instance.requestPermission();
      }

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

      token = await _getFcmToken();

      logger.i('The FCM token is $token');

      // This must be a top level or a static function.
      // Not a lambda, not a class member.
      FirebaseMessaging.onBackgroundMessage(_stub);

      FirebaseMessaging.onMessage.listen(_showNotification);

      FirebaseMessaging.onMessageOpenedApp.listen(_onNotificationOpened);

      const channel = AndroidNotificationChannel(
        _parcieNotificationChannel,
        'Parcie Notifications Channel',
        description: 'This channel is used for Parcie notifications.',
        importance: Importance.max,
      );

      final androidInit = AndroidInitializationSettings('@mipmap/ic_launcher');

      final DarwinInitializationSettings darwinInit =
          DarwinInitializationSettings(
        requestAlertPermission: false,
        requestBadgePermission: false,
        requestSoundPermission: false,
        onDidReceiveLocalNotification:
            (int id, String? title, String? body, String? payload) async {},
      );

      final initSetting = InitializationSettings(
        android: androidInit,
        iOS: darwinInit,
      );

      fltNotificationPlugin.initialize(
        initSetting,
        onDidReceiveNotificationResponse:
            (NotificationResponse notificationResponse) {
          if (notificationResponse.payload == null) {
            return;
          }

          _onNotificationViaTrackingNumberOpened(notificationResponse.payload!);
        },
      );

      await fltNotificationPlugin
          .resolvePlatformSpecificImplementation<
              AndroidFlutterLocalNotificationsPlugin>()
          ?.createNotificationChannel(channel);
    } on Exception catch (e, s) {
      logger.e('Unable to initialize the NotificationService', e, s);
    } finally {
      _isNotificationActive = true;

      initializedSuccessfully();
    }
  }

  Future<void> _showNotification(
    RemoteMessage message,
  ) async {
    final notification = message.notification;

    if (notification == null) {
      return;
    }

    logger.i('Starting the processing of the notification...');

    final canBeProcessed = await _trackingNotificationHandler.canBeProcessed(
      message,
    );

    if (!canBeProcessed) {
      logger.i('The notification will not be displayed.');

      return;
    }

    logger.i('The notification is valid and will be displayed.');

    final androidDetails = AndroidNotificationDetails(
      _parcieNotificationChannel,
      'Parcie Notifications Channel',
      channelDescription: 'This channel is used for Parcie notifications.',
      importance: Importance.max,
      tag: _trackingTag,
    );

    final iosDetails = DarwinNotificationDetails();

    final notificationDetails = NotificationDetails(
      android: androidDetails,
      iOS: iosDetails,
    );

    await fltNotificationPlugin.show(
      notification.hashCode,
      notification.title,
      notification.body,
      notificationDetails,
      payload: message.data[_trackingNumberDataKey],
    );
  }

  void dispose() {
    _onConnectivityStreamSubscription.cancel();
  }
}