I am not able to receive the push notifications when app is terminates [killed from background].

[sajal02062000]

Hi community,
I need help in identifying the issue. Because i have already checked my code multiple times but still i am not able to figure-out the issue with my code.

Problem: The problem i am facing is when i terminates the app then i am not able to receive the notifications. But the notifications are working perfectly in foreground and background state.

Sharing code for the better reference:

main.dart:

`

Future<void> main() async {
  await Hive.initFlutter();
  await Firebase.initializeApp(
    options: DefaultFirebaseOptions.currentPlatform,
  );
  NotificationService.init();
  await NotificationService.localNotiInit();

  // Listen to background notifications
  FirebaseMessaging.onBackgroundMessage(_firebaseBackgroundMessage);

  FirebaseMessaging.onMessageOpenedApp.listen(
    (RemoteMessage remoteMessage) {
      try {
        if (remoteMessage.notification != null) {
          var data = remoteMessage.data;
          if (data['type'] == 'chat') {
            try {
              var json = jsonDecode(
                data['data'],
              );
              Get.put(ChatControllers()).goToChatDetailedScreen(
                ChatUserModel(
                  id: int.parse(json['id']),
                  patientId: json['patient_id'],
                  name: json['name'],
                  phoneNumber: json['phone_number'],
                  photo: json['photo'],
                  latestMessage: json['latest_message'],
                  unreadMessagesCount:
                      int.tryParse(json['unread_messages_count']) ?? 0,
                ),
              );
            } catch (e) {
              debugPrint("ERROR ENCOUNTERED");
              debugPrint(e.toString());
            }
          }
        }
      } catch (e) {
        log(e.toString());
      }
    },
  );

  // to handle foreground notifications
  FirebaseMessaging.onMessage.listen((RemoteMessage message) {
    String payloadData = jsonEncode(message.data);
    if (kDebugMode) {
      print("Got a message in foreground");
    }
    if (message.notification != null) {
      NotificationService.showSimpleNotification(
          title: message.notification!.title!,
          body: message.notification!.body!,
          payload: payloadData);
    }
  });

  // for handling in terminated state
  final RemoteMessage? message =
      await FirebaseMessaging.instance.getInitialMessage();

  if (message != null) {
    if (kDebugMode) {
      print("Launched from terminated state");
      try {
        if (message.notification != null) {
          var data = message.data;
          if (data['type'] == 'chat') {
            try {
              var json = jsonDecode(
                data['data'],
              );
              Get.put(ChatControllers()).goToChatDetailedScreen(
                ChatUserModel(
                  id: int.parse(json['id']),
                  patientId: json['patient_id'],
                  name: json['name'],
                  phoneNumber: json['phone_number'],
                  photo: json['photo'],
                  latestMessage: json['latest_message'],
                  unreadMessagesCount:
                      int.tryParse(json['unread_messages_count']) ?? 0,
                ),
              );
            } catch (e) {
              debugPrint("ERROR ENCOUNTERED");
              debugPrint(e.toString());
            }
          }
        }
      } catch (e) {
        log(e.toString());
      }
    }
  }
  runApp(const MyApp());
}

// function to listen to background changes
@pragma("vm:entry-point")
Future _firebaseBackgroundMessage(RemoteMessage message) async {
  await Firebase.initializeApp(
    options: DefaultFirebaseOptions.currentPlatform,
  );
  if (message.notification != null) {
    if (kDebugMode) {
      print("Some notification Received in background...");
    }
  }
}

class MyApp extends StatefulWidget {
  const MyApp({
    super.key,
  });

  @override
  State<MyApp> createState() => _MyAppState();
}

class _MyAppState extends State<MyApp> {
  @override
  Widget build(BuildContext context) {
    return DismissKeyboard(
      child: GetMaterialApp(
        debugShowCheckedModeBanner: false,
        defaultTransition: Transition.cupertino,
        title: <My App title>,
        theme: ThemeData(
          scaffoldBackgroundColor: colorsController.whiteColor.value,
          primaryColor: colorsController.primaryColor.value,
          appBarTheme: AppBarTheme(
            surfaceTintColor: colorsController.whiteColor.value,
            backgroundColor: colorsController.whiteColor.value,
            elevation: 0,
          ),
        ),
        home: const SplashScreen(),
      ),
    );
  }
}

`

notification_service.dart:

import 'dart:convert';
import 'dart:io';
import 'dart:math';
import 'package:firebase_messaging/firebase_messaging.dart';
import 'package:flutter/foundation.dart';
import 'package:flutter_local_notifications/flutter_local_notifications.dart';
import 'package:get/get.dart';
import 'package:permission_handler/permission_handler.dart';

import '../Controllers/chat_controllers.dart';
import '../Models/chat_user_model.dart';

class NotificationService {
  static final _firebaseMessaging = FirebaseMessaging.instance;
  static final FlutterLocalNotificationsPlugin
      _flutterLocalNotificationsPlugin = FlutterLocalNotificationsPlugin();

  // request notification permission
  static Future init() async {
    NotificationSettings settings = await _firebaseMessaging.requestPermission(
      alert: true,
      announcement: true,
      badge: true,
      carPlay: false,
      criticalAlert: true,
      provisional: false,
      sound: true,
    );
    if (Platform.isIOS) {
      await _firebaseMessaging.setForegroundNotificationPresentationOptions(
        alert: true,
        badge: true,
        sound: true,
      );
    }
    await _firebaseMessaging.setAutoInitEnabled(true);

    if (settings.authorizationStatus == AuthorizationStatus.authorized) {
      debugPrint("Notification Permission Allowed");
    } else if (settings.authorizationStatus ==
        AuthorizationStatus.provisional) {
      debugPrint("Provisional Notification Permission Allowed");
    } else {
      openAppSettings();
    }
  }

  // initalize local notifications
  static Future localNotiInit() async {
    // initialise the plugin. app_icon needs to be a added as a drawable resource to the Android head project
    const AndroidInitializationSettings initializationSettingsAndroid =
        AndroidInitializationSettings(
      '@mipmap/ic_launcher',
    );
    final DarwinInitializationSettings initializationSettingsDarwin =
        DarwinInitializationSettings(
      defaultPresentSound: true,
      requestAlertPermission: true,
      requestBadgePermission: true,
      requestCriticalPermission: true,
      requestProvisionalPermission: true,
      requestSoundPermission: true,
      onDidReceiveLocalNotification: (id, title, body, payload) {
        if (kDebugMode) {
          print("=====IOS Notification Receive Hud");
          print(id);
          print(title);
          print(body);
          print(payload);
        }
      },
    );
    final InitializationSettings initializationSettings =
        InitializationSettings(
      android: initializationSettingsAndroid,
      iOS: initializationSettingsDarwin,
    );

    // request notification permissions for android 13 or above
    if (Platform.isAndroid) {
      _flutterLocalNotificationsPlugin
          .resolvePlatformSpecificImplementation<
              AndroidFlutterLocalNotificationsPlugin>()!
          .requestNotificationsPermission();
    }

    _flutterLocalNotificationsPlugin.initialize(initializationSettings,
        onDidReceiveNotificationResponse: handleNotificationRouting,
        onDidReceiveBackgroundNotificationResponse: handleNotificationRouting);
  }

  // Function to handle notification routing
  static void handleNotificationRouting(
      NotificationResponse notificationResponse) {
    if (notificationResponse.payload != null) {
      Map data = jsonDecode(notificationResponse.payload ?? "{}");
      if (data['type'] == 'chat') {
        try {
          var json = jsonDecode(
            data['data'],
          );
          Get.put(ChatControllers()).goToChatDetailedScreen(
            ChatUserModel(
              id: int.parse(json['id']),
              patientId: json['patient_id'],
              name: json['name'],
              phoneNumber: json['phone_number'],
              photo: json['photo'],
              latestMessage: json['latest_message'],
              unreadMessagesCount:
                  int.tryParse(json['unread_messages_count']) ?? 0,
            ),
          );
        } catch (e) {
          debugPrint("ERROR ENCOUNTERED");
          debugPrint(e.toString());
        }
      }
    }
  }

  // show a simple notification
  static Future showSimpleNotification({
    required String title,
    required String body,
    required String payload,
  }) async {
    const AndroidNotificationDetails androidNotificationDetails =
        AndroidNotificationDetails(
      'high_importance_channel',
      'High Importance Notifications',
      channelDescription: 'This channel is used for important notifications.',
      importance: Importance.max,
      priority: Priority.high,
      ticker: 'ticker',
    );
    const DarwinNotificationDetails darwinNotificationDetails =
        DarwinNotificationDetails(
      presentAlert: true,
      presentBadge: true,
      presentSound: true,
    );
    NotificationDetails notificationDetails = const NotificationDetails(
      android: androidNotificationDetails,
      iOS: darwinNotificationDetails,
    );
    if (kDebugMode) {
      print("Notification to show $title");
    }
    try {
      await _flutterLocalNotificationsPlugin.show(
        Random.secure().nextInt(1000),
        title,
        body,
        notificationDetails,
        payload: payload,
      );
    } catch (e) {
      debugPrint("Notification catch");
      debugPrint(e.toString());
    }
  }
}
```
`

Also  have checked for the firebase configurations.

Anyone please help me identify the issue. Thanks in advance.