Flutter firebase receiving notification when closed or in background - how to pass message to class

Question

I'm building a Flutter app with Firebase push notifications.

When a message is received I want the app to show a popup modal with the text.

• When the app is in the foreground the popup modal displays - this works

• When the app is the background and the message is received by the mobile it appears in the system tray, the user clicks on it, the app opens and the initial message is found and displayed to the user in the popup modal - eg. FirebaseMessaging.onMessageOpenedApp function - this works.

• When the app is in the background, the notification is received by the phone (and the firebase listener is working because it outputs the message data using debugPrint to test), it appears in the system tray, but the user chooses NOT to click the message - when the app is brought back to the foreground the message is ignored - This is a problem.

The "FirebaseMessaging.onBackgroundMessage" function needs to be placed in the TOP LEVEL (outside of any class). Therefore when the app is once again placed in the foreground, how do I push message data from a message that may have been received whilst the app is in the background, in to my App Class to display the message content? I'm using "AppLifecycleState" to detect when the app is returned to the foreground, but I can't grab the message data because it is received in the top level, not in the class.

Please see my code below (see last few lines for the bit I'm stuck on)...

  //TOP LEVEL-----
  Future<void> _firebaseMessagingBackgroundHandler(RemoteMessage message) async {
    if (message.messageId!="") {
        debugPrint("Have received a background message! Will have to grab the message from here somehow if the user didn't interact with the system tray message link");
    } 
  }

  Future<void> main() async {
       await Firebase.initializeApp(options: DefaultFirebaseOptions.currentPlatform);
       FirebaseMessaging.onBackgroundMessage(_firebaseMessagingBackgroundHandler);
       runApp(MyApp());
  }

  //APP CLASS-----
  class MyAppextends StatefulWidget {        
       State<MyApp> createState() => _MyAppState();
  }

       
  //APP STATE CLASS
  class _MyAppState extends State<MyApp>  with WidgetsBindingObserver{


       @override  
       void initState() {
          super.initState();
          _initiateNotificationForegroundListener();
          _initiateInteractedMessage();
       }

       // This variable will tell you whether the application is in foreground or not. 
       bool _isInForeground = true;

       //Initiate Foreground Notification Listener (works)
       void _initiateNotificationForegroundListener() {
         FirebaseMessaging.onMessage.listen((RemoteMessage message) {
            _handleNotificationInstruction(message);
         });
       }

       //Initiate Background/Closed Notification Listener if user clicks the message in the system try (works)
       Future<void> _initiateInteractedMessage() async {
            RemoteMessage? message = await FirebaseMessaging.instance.getInitialMessage();
           if (message != null) {     
                _handleNotificationInstruction(message);
           }
           // When app is in background (Stream listener) 
           FirebaseMessaging.onMessageOpenedApp
           .listen(_handleNotificationInstruction);

       }

        void _handleNotificationInstruction(RemoteMessage message) {
           //Create popup to display message info (works)
        }

        //Detect when an app moves in to the foreground
        @override
        void didChangeAppLifecycleState(AppLifecycleState state) {

             super.didChangeAppLifecycleState(state);
             _isInForeground = state == AppLifecycleState.resumed;

             if(_isInForeground){

                     /** HELP!!!
                     /* How can I check what message might have been received while app was in the background?? ie. the top-level _firebaseMessagingBackgroundHandler function??
                     **/

             }

        }

Answer 1

I was facing this problem too, this is annoying but thanks to this thread, I found the solution. The FCM's document states:

When received, an isolate is spawned (Android only, iOS/macOS does not require a separate isolate) allowing you to handle messages even when your application is not running.

An important note is that each isolate has its own memory so that your SharedPreferences in foreground will be different from it in background. You can 'synchronize' the data by calling SharedPreferences.reload() when your app resumes.