[firebase_messaging] Disable interception of notification to allow for local notification generation

[Minituff]

Background

I am trying to create a chat app which delivers reliable notifications that includes action buttons such as Mark as Read and Reply which creates an input field.

Unfortunately the firebase_messaging plugin does not support advanced options like Action/Input buttons. So, to do this in Flutter, I am using a great package called AwesomeNotifications which allows for all these advanced features. For anyone unfamiliar, it is like a more advanced version of the Local Notifications plugin.
Using this plugin, I am able to handle the FirebaseMessaging.onBackgroundMessage(_fcmBackgroundHandler); callback from firebase_messaging and generate the notification with all the properties and actions that I like.

The Problem

If the notification includes the notification property then firebase_messaging will automatically display the notification AND AwesomeNotifications will then display its notification--resulting in duplicate notifications.
However, removing the notification property turns it into a data-only notification which, according to the FlutterFire docs are low-priority

As mentioned above, data only messages are classed as "low priority". Devices can throttle and ignore these messages if your application is in the background, terminated, or a variety of other conditions such as low battery or currently high CPU usage.

You should not rely on data only messages to be delivered, they should only be used to support your applications non-critical functionality, e.g. pre-fetching data so the next time the user opens your app the data is ready to be displayed and if the message never gets delivered then your app still functions and fetches data on open.

To help improve delivery, you can bump the priority of messages. Note; this does still not guarantee delivery.

I have also tested this with my own IOS and Android devices and I would not receive data-only messages unless the app was in the foreground or the last used app on IOS. Notifications would not come through if I was using another app, or it was swiped away from recents.

For a chat application, getting reliable messages is a priority and therefore I need to use the notification property to ensure delivery of my notifications. The issues:

1. I cannot use a plugin like AwesomeNotifications or Local Notifications to create advanced functioning notifications because it will create duplicate notifications as long as the notification property is set. However, the notification property is required for reliable notifications.
2. The firebase_messaging plugin does not support advanced features such as Action/Input buttons.

A greater explanation of (number 1):
firebase_messaging automatically intercepts notifications and displays them and I don't think there is a way to disable that. Per the docs below:

Messages can be handled via the onBackgroundMessage handler. 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.
and further
If your message is a notification one (includes a notification property), the Firebase SDKs will intercept this and display a visible notification to your users (assuming you have requested permission & the user has notifications enabled). Once displayed, the background handler will be executed (if provided).

The Feature Request

I would like to be able to disable the firebase_messaging automatic notification display while still having the onBackgroundMessage callback fire. This way I can send reliable notifications (with the notification property) and have them be displayed by the more advanced flutter tools.

If this is not possible, then I would love to see ActionButtons and Input fields come to the firebase_messaging plugin.

Additional Infromation

I created another issue here https://github.com/rafaelsetragni/awesome_notifications/issues/165

Below are the plugin versions I am using at the time of writing this

  firebase_core: ^1.1.1
  firebase_messaging: ^9.1.4

[briankariuki]

I second you on this. We should have a way to prevent the default notification if we'd like to handle some logic onBackgroundMessage() then show the notification.

[scalz]

Hello,
Same here, I'm using awesome_notifications, but this is the same with local_notifications package, this would be awesome if this would be doable (just have an option to not show the fcm notification) 🙏

[briankariuki]

A solution to this would be to implement our own onMessage() handler which would allow getting payload from data field and show on the notification. A few guides and leads can be found on this question on stackoverflow

https://stackoverflow.com/questions/37711082/how-to-handle-notification-when-app-in-background-in-firebase

[briankariuki]

This means we do not require firebase_messaging package

[scalz]

Interesting. Well, I hope there is a solution for this, by keeping firebase_messaging, this would be sexy.
I wonder how people handle this case (I've no idea how this handled in others frameworks).
Still, firebase_messaging got lot of great improvements last months, so I'm crossing fingers, and will follow this with interest for sure :)

Thanks Team for all your work you're providing to the community, this is really neat

[mutasimbillah]

any update to this problem ?

[rulefahd]

Any update!!?

[alsoLut]

one year later, the problem is still unresolved.

[SMKH-PRO]

2 more years later still unresolved

[dharmik-hb]

3 more years later still unresolved

[chasseuragace]

Yes you can intercept , but disabling notification payload from your server is a must have for this .

Also if you're using firebase console ui. You're out of luck

[STRATZ-Ken]

Any word on this?

[Minituff]

It looks like the flutter team has decided this will never be implemented: #7874 (comment) ☹️

[briankariuki]

Its possible to handle the fcm message yourself.

//listen to the onMessage stream
FirebaseMessaging.onMessage.listen((RemoteMessage message) async {
     final data = message.data; 

     FlutterLocalNotificationsPlugin flutterLocalNotificationsPlugin = FlutterLocalNotificationsPlugin();

      //add your configs to the notifications plugin, here i'm using flutter_local_notifications.
      //then show your notification

    flutterLocalNotificationsPlugin.show(
        data['payload']['id],
        data["title"],
        data["body"],
        NotificationDetails(),
        payload: data['payload']
    )
})

one thing to note is that for the above to work you should send a data only message from your firebase-admin sdk, with the contents of your message as the payload

[FDuhen]

The onMessage method is triggered when the app is in Foreground : it doesn't really fix the original problem since the notifications are not displaying in this case

[yuwankmr]

Thanks It works!

[mutasimbillah]

I have solved this issue by updating packages to :
firebase_core: ^1.19.2
firebase_messaging: ^12.0.0
flutter_local_notifications: ^9.7.0

And add Android Notification Default Channel in AndroidManifest.xml

        android:name="com.google.firebase.messaging.default_notification_channel_id"
        android:value="notification_id"

For More check :
https://github.com/mutasimbillah/Flutter-Push-Notification-with-Custom-Sound-Tutorial

I will update this repository, with proper documentation in near future. Hope it will help some one...

[rulefahd]

What about ios?

[bhanubbs]

ios don't need an advance level of implementation!
because you thread them!

[iosephmagno]

@Minituff I dont think you can use "notification" if you are coding a chat application. Because notifications will display before you have time to decrypt your messages. In case of a chat app, you should use silent (data-only) notification only. This way you can get the payload, decrypt it and use flutter local notification or awesome notification to display a badge.

[rulefahd]

@Minituff I dont think you can use "notification" if you are coding a chat application. Because notifications will display before you have time to decrypt your messages. In case of a chat app, you should use silent (data-only) notification only. This way you can get the payload, decrypt it and use flutter local notification or awesome notification to display a badge.

What about on termination state, data only is not guaranteed to be delivered

[iosephmagno]

Use a non disturbing “notification”

[iosephmagno]

@Minituff added this #7874 (comment)

Indeed there would be this option but firebase team should do their part.

[iosephmagno]

Hello guys, just added feature request #9317

[abhay-s-rawat]

If there is notification json property in the notifications sent from fcm then default fcm notification will show up.
I sent below object via postman, you can test it as well.

{
 "to" : "fcm token id",
 "notification" : { // remove this part to let it handle yourself.
     "body" : "Body of Your Notification 2", 
     "title": "Title of Your Notification 2"
 },
 "data" : {
     "body" : "Body of Your Notification in Data 2",
     "title": "Title of Your Notification in Title 2",
     "key_1" : "Value for key_3",
     "key_2" : "Value for key_4"
 }
}

[Minituff]

@abhay-s-rawat This was mentioned in my original post. If you remove the notification section then the message becomes data-only. A data-only message is considered low priority and you cannot count on its delivery. Check out the docs here.

[wiztensai]

any update?

[akaomarfahim]

firebase_core: ^2.4.0
firebase_messaging: ^14.2.0

I'm using this, strill firebase generates a notification by default.
any update on that.

Though, I can control custom notification with #flutter_local_notifications: ^12.0.4
but, it doesn't route to other specific page from #terminated_state.

[briankariuki]

Remove the notification field from your fcm payload

[agent515]

Same issue. What notification solution should a E2EE chat app implement where message needs to be decrypted before showing in the notification banner? Background Service was my guess but again it poses unpredictability on iOS.

[akshaybengani]

it's just a simple thing for the Flutter and Firebase messaging team, just give us a toggle to automatically show notifications on receive or not, and we developers will do the rest of decrypting and issuing our local notifications.

I don't understand how difficult it can be for a multi-billion dollar company, very disappointed that after 3 years of this thread, we still have no solution 🤬😡

[akshaybengani]

https://developer.apple.com/documentation/usernotifications/modifying-content-in-newly-delivered-notifications

Can someone please try this workaround for IOS?

it says we can modify a remote notification and publish our own by using the notification service app extenstion.

[agent515]

https://developer.apple.com/documentation/usernotifications/modifying-content-in-newly-delivered-notifications

Can someone please try this workaround for IOS?

it says we can modify a remote notification and publish our own by using the notification service app extenstion.

I had tried using Notification Service Extension for modifying iOS notifications before showing them but didReceive method in it was never trigged on receiving notifications. I posted a SO question without any solution as of now.

[Ahmad0Tanveer]

in my case i have done this
this working to

 @pragma('vm:entry-point')
Future myBackgroundMessageHandlerAndroid(RemoteMessage message) async {
  LocalNotificationService.initialize();
  LocalNotificationService.displayNotification(
      message, message.notification!.title);
}

@pragma('vm:entry-point')
void notificationTapBackground(NotificationResponse response) async {
 
  if (response.actionId == null && response.payload != null) {
    NotificationModel notificationModel =
        NotificationModel.fromJson(jsonDecode(response.payload!));
    if (notificationModel.type == NotificationsType.messages ||
        notificationModel.type == "message") {
      navigatorKey.currentState!.push(MaterialPageRoute(
            builder: (_) =>
                PrivateChatDetailScreen(user_id: notificationModel.senderId)));
    }
  }
  if (response.actionId == ActionsIds.reply) {
   
    if (response.input != null) {
     String messageInNotificationInput = response.input;
     //send here
  }
}

final FlutterLocalNotificationsPlugin notificationsPlugin =
    FlutterLocalNotificationsPlugin();
const AndroidInitializationSettings androidInitializationSettings =
    AndroidInitializationSettings("@mipmap/ic_launcher");

class LocalNotificationService {
  static void initialize() async {
    const InitializationSettings initializationSettings =
        InitializationSettings(android: androidInitializationSettings);
    await notificationsPlugin.initialize(initializationSettings,
        onDidReceiveBackgroundNotificationResponse: notificationTapBackground,
        onDidReceiveNotificationResponse: notificationTapBackground);
  }

  static void displayNotification(RemoteMessage message, title) async {
    try {
      String? title = message.notification!.title;
      NotificationModel notificationModel =
          NotificationModel.fromJson(message.data);
      String callId = const Uuid().v4();
      final id = DateTime.now().millisecondsSinceEpoch ~/ 1000;
      final String largeIconPath = await _downloadAndSaveFile("image url");
      NotificationDetails notificationDetails = NotificationDetails(
          android: AndroidNotificationDetails("AAAAA", "BBBB",
              importance: Importance.max,
              ongoing: true,
              priority: Priority.high,
              largeIcon: FilePathAndroidBitmap(largeIconPath),
              actions: [
                AndroidNotificationAction(ActionsIds.reply, "REPLY",
                    showsUserInterface: true,
                    allowGeneratedReplies: true,
                    inputs: [
                      const AndroidNotificationActionInput(
                        label: 'Enter a message',
                      ),
                    ]),
                AndroidNotificationAction(
                  ActionsIds.markAsRead,
                  "Mark as Read",
                  showsUserInterface: true,
                ),
                AndroidNotificationAction(ActionsIds.mute, "MUTE"),
              ],
              additionalFlags: Int32List.fromList(<int>[2])));
      await notificationsPlugin.show(
            id,
            title,
            notificationModel.body,
            notificationDetails,
            payload: jsonEncode(notificationModel.toJson()),
          );
    } on Exception catch (e) {
      print(e);
    }
  }
}

take idea from this code this not using awesome notifications flutter packages i am using this package
https://pub.dev/packages/flutter_local_notifications_plus

[Ahmad0Tanveer]

for ios i have done only notifications not actions buttons and for ios i. have remove the notifications initialtiontion wallah working fine i don't know why but its sending me notification 2 devices thats why i remove ios
@akshaybengani

if (GetPlatform.isAndroid) {
    LocalNotificationService.initialize();
    FirebaseMessaging.instance.getInitialMessage();
  }
  FirebaseMessaging.onBackgroundMessage(backGroundHandler);
  await FirebaseMessaging.instance.requestPermission(
    alert: true,
    badge: true,
    sound: true,
  );
  await FirebaseMessaging.instance.setForegroundNotificationPresentationOptions(
    alert: true,
    badge: true,
    sound: true,
  );

[felipecastrosales]

hey, any expectations or suggestions about it that made works as expected?

[iamnabink]

Hi @felipecastrosales and all, the default notification displays because you included the notification property in the JSON object. The FCM plugin will show a default notification based on the parameters in that JSON. So, to resolve this, simply remove the notification property from the JSON when sending the message and show notification from flutter_local_notifications or awesome_notifications using FCM's onMessage and _firebaseMessagingBackgroundHandler callback functions. Please try it out.

{
  "to": "user_token",
  "notificaton": {}, // remove this 
  "data": {
    "channelId": "session_alert",
    "sound": "mysound",
    "title": "message title",
    "body": "message body"
  }
}

[phamquoctrongdev]

If you remove the notification key, it becomes a low-priority notification and may not show in the background.

[flute]

any update?

[Belveloper]

same problem here
when i send notification from admin panel it works perfectly on android and i manage to receive the notification in foreground and background state
BUT
on IOS i get the notification with as expected in foreground but in background i only get the title and body data no payload

are there any solutions please ?

[vgavrilovikj]

Yes, we fixed it using: https://pub.dev/packages/awesome_notifications_fcm

Our NotificationService.swift looks like this:

import UserNotifications
import awesome_notifications_fcm

@available(iOS 10.0, *)
class NotificationService: DartAwesomeServiceExtension {
    var contentHandler: ((UNNotificationContent) -> Void)?
    var bestAttemptContent: UNMutableNotificationContent?
    
    override func didReceive(_ request: UNNotificationRequest, withContentHandler contentHandler: @escaping (UNNotificationContent) -> Void) {
        bestAttemptContent = (request.content.mutableCopy() as? UNMutableNotificationContent)
        
        super.didReceive(request, withContentHandler: { content in
                    self.bestAttemptContent = (content.mutableCopy() as? UNMutableNotificationContent)
                    
                    guard let bestAttemptContent = self.bestAttemptContent else {
                        return
                    }

                    bestAttemptContent.sound = UNNotificationSound(named: UNNotificationSoundName(rawValue: "common_notification_sound.aiff"))
                    
                    contentHandler(bestAttemptContent)
                })
    }
}

And this is the AppDelegate.swift

import UIKit
import Flutter
import awesome_notifications
import awesome_notifications_fcm
import shared_preferences_ios
import flutter_secure_storage
import workmanager

@UIApplicationMain
@objc class AppDelegate: FlutterAppDelegate {

    override func application(
        _ application: UIApplication,
        didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?
      ) -> Bool {
          GeneratedPluginRegistrant.register(with: self)
          
          WorkmanagerPlugin.setPluginRegistrantCallback { registry in
              GeneratedPluginRegistrant.register(with: registry)
              FlutterSecureStoragePlugin.register(
                with: registry.registrar(forPlugin: "io.flutter.plugins.fluttersecurestorage.FlutterSecureStoragePlugin")!)
          }
          
          WorkmanagerPlugin.registerBGProcessingTask(withIdentifier: "updateFirebaseToken")
          
          WorkmanagerPlugin.registerPeriodicTask(withIdentifier: "aspartnership.commonBusiness.updateFirebaseToken", frequency: NSNumber(value: 30*24*60*60))

          // This function register the desired plugins to be used within a notification background action
          SwiftAwesomeNotificationsPlugin.setPluginRegistrantCallback { registry in
              SwiftAwesomeNotificationsPlugin.register(
                with: registry.registrar(forPlugin: "io.flutter.plugins.awesomenotifications.AwesomeNotificationsPlugin")!)
              FLTSharedPreferencesPlugin.register(
                with: registry.registrar(forPlugin: "io.flutter.plugins.sharedpreferences.SharedPreferencesPlugin")!)
              FlutterSecureStoragePlugin.register(
                with: registry.registrar(forPlugin: "io.flutter.plugins.fluttersecurestorage.FlutterSecureStoragePlugin")!)
          }

          // This function register the desired plugins to be used within silent push notifications
          SwiftAwesomeNotificationsFcmPlugin.setPluginRegistrantCallback { registry in
              SwiftAwesomeNotificationsPlugin.register(
                with: registry.registrar(forPlugin: "io.flutter.plugins.awesomenotifications.AwesomeNotificationsPlugin")!)
              FLTSharedPreferencesPlugin.register(
                with: registry.registrar(forPlugin: "io.flutter.plugins.sharedpreferences.SharedPreferencesPlugin")!)
              FlutterSecureStoragePlugin.register(
                with: registry.registrar(forPlugin: "io.flutter.plugins.fluttersecurestorage.FlutterSecureStoragePlugin")!)
          }

          return super.application(application, didFinishLaunchingWithOptions: launchOptions)
      }
}

[demjm]

Tried many different solutions, none really worked properly. I ended up with a mixed solution that works for me, while using flutter_local_notifications.
The trick is if you don't want your default firebase_messaging notification to show up, you need to disable it in the setForegroundNotificationPresentationOptions method of your instance :

      await _firebaseMessaging.setForegroundNotificationPresentationOptions(
        // do not display default fcm notification
        alert: false,
        badge: false,
        sound: false,
      );

then in your FirebaseMessaging.onMessage.listen(callback) you can call your flutter_local_notifications show method, or whatever you've called it. Doing so will still compute the notification field sent via your backend, and avoid collision with any local plugin you may use.

To ensure the sound and vibration are working for fcm default notification when the app is in background, specify it in your backend payload :

...

"notification": {
            title: `some title`,
            body: `some body`,
          },
          "apns": {
            "payload": {
              aps: {
                sound: "default", // <- required
              },
            },
            "headers": {
              "apns-priority": "10", <- optional
            },
          },

My 2 cents. Hope it helps someone 👌

[kevin4dhd]

Hi, thank you very much for sharing your solution. I'm about to use it but I want to know if you have tried it with several devices and on several versions of Android, and has it worked on all of them? Thanks again.

[Joshuauzor]

Tried many different solutions, none really worked properly. I ended up with a mixed solution that works for me, while using flutter_local_notifications. The trick is if you don't want your default firebase_messaging notification to show up, you need to disable it in the setForegroundNotificationPresentationOptions method of your instance :

      await _firebaseMessaging.setForegroundNotificationPresentationOptions(
        // do not display default fcm notification
        alert: false,
        badge: false,
        sound: false,
      );

then in your FirebaseMessaging.onMessage.listen(callback) you can call your flutter_local_notifications show method, or whatever you've called it. Doing so will still compute the notification field sent via your backend, and avoid collision with any local plugin you may use.

To ensure the sound and vibration are working for fcm default notification when the app is in background, specify it in your backend payload :

...

"notification": {
            title: `some title`,
            body: `some body`,
          },
          "apns": {
            "payload": {
              aps: {
                sound: "default", // <- required
              },
            },
            "headers": {
              "apns-priority": "10", <- optional
            },
          },

My 2 cents. Hope it helps someone 👌

This is the temporary workaround that worked for me

[demjm]

@kevin4dhd I tried it on multiple iOS devices and on Redmi phone, my workaround work fine with them.

[MichalDanielDobrzanski]

Well, not that far is the documentation of setForegroundNotificationPresentationOptions, which states:

  /// Sets the presentation options for Apple notifications when received in
  /// the foreground.
  ///
  /// By default, on Apple devices notification messages are only shown when
  /// the application is in the background or terminated. Calling this method
  /// updates these options to allow customizing notification presentation behavior whilst
  /// the application is in the foreground.

  /// If all arguments are `false` or are omitted, a notification will not be displayed in the
  /// foreground, however you will still receive events relating to the notification.

So clearly Android is not affected by the change.

Also, we disable the foreground ones (the duplicates), which leaves us with background ones being sent even when the iOS app is in foreground.

We can even not call setForegroundNotificationPresentationOptions at all, since all its defaults are false.

Weird, but working fine.

[chasseuragace]

To prevent notifications from showing when the app is in the background on iOS, your code uses the userNotificationCenter(_:willPresent:withCompletionHandler:) method. Here's how it works:

1. Checks App State:

   • The method checks if the app is in the background using UIApplication.shared.applicationState == .background.

2. Suppresses Background Notifications:

   • If the app is in the background, it passes an empty array ([]) to the completionHandler, preventing the notification from displaying.
   • If the app is in the foreground, it allows the notification to show by passing [.alert, .badge, .sound].

Why It Works

• iOS shows notifications by default when an app is in the background.
• By overriding this method, you gain control over whether to display notifications, suppressing them in the background while still allowing them in the foreground.

This approach ensures a better user experience by preventing unnecessary notifications when your app isn't actively being used.

import UIKit
import Flutter
import FirebaseMessaging

@UIApplicationMain
class AppDelegate: FlutterAppDelegate {
    override func application(
        _ application: UIApplication,
        didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?
    ) -> Bool {
        GeneratedPluginRegistrant.register(with: self)
        
        // Configure Firebase Messaging delegate
        Messaging.messaging().delegate = self
        
        if #available(iOS 10.0, *) {
            UNUserNotificationCenter.current().delegate = self
        }
        
        return super.application(application, didFinishLaunchingWithOptions: launchOptions)
    }
    
    // Override this method to prevent background notifications
    override func userNotificationCenter(
        _ center: UNUserNotificationCenter,
        willPresent notification: UNNotification,
        withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void
    ) {
        let userInfo = notification.request.content.userInfo
        
        // Check if the app is in background
        if UIApplication.shared.applicationState == .background {
            // Don't show the notification
            completionHandler([])
        } else {
            // Show the notification when app is in foreground
            completionHandler([.alert, .badge, .sound])
        }
    }
}

extension AppDelegate: MessagingDelegate {
    func messaging(_ messaging: Messaging, didReceiveRegistrationToken fcmToken: String?) {
        print("Firebase registration token: \(String(describing: fcmToken))")
    }
}

[phamquoctrongdev]

It's been 4 years, and this issue still exists. OMG.

[gorkemmalp]

Hello everyone! After two weeks of research and work, I think I've finally found a solution. FINALLY!

It seems there is no way to disable the automatic system notification for messages sent as "Notification" messages through Firebase, or to detect "Data" messages in a terminated app.

I remembered seeing two WhatsApp icons in the notification bar sometimes when a message arrives, and one of them disappearing shortly after. This gave me an idea:
We send a "Notification" message through Firebase, capture this message in our Flutter application, and then send a local notification using local_notification package.

Of course, this causes two notifications: one belonging to the system and the other to the local_notification package. However, we cancel the notification sent with local_notification after 800 milliseconds (you can try a shorter duration as well) and remove it from the notification list.

As a result, two notifications appear momentarily, but one is only used for showing a popup and is then removed from the notification panel. The system's automatic notification remains in the notification panel.

static Future<void> showPlanNotification({
  required String title,
  required String text,
  bool? cancelOnComplete = false,
}) async {
  await _initTimeZone();
  final DateTime dtNow = DateTime.now();
  final int id = dtNow.millisecondsSinceEpoch;
  final int channelId = int.parse(id.toString().substring(6, 12));

  // Disable sound for the canceled notification
  final details = await _details(sound: cancelOnComplete! == false);

  try {
    await plugin.show(channelId, title, text, details, payload: 'plan');

    // If cancelOnComplete = true, the notification will be removed
    if (cancelOnComplete) {
      await Future.delayed(const Duration(milliseconds: 800));
      await cancel(channelId);
    }
  } catch (e) {
    debugPrint("show() - e:$e");
  }
}

static Future<void> cancel(int id) async {
  await plugin.cancel(id);
}

static Future<NotificationDetails> _details({bool? sound = true}) async {
  AndroidNotificationDetails androidDetails = AndroidNotificationDetails(
    'main_channel',
    'Main Channel',
    channelDescription: "ashwin",
    importance: Importance.max,
    priority: Priority.high,
    playSound: sound!, // If false, the canceled notification won't play a sound
    enableVibration: sound, // If false, the canceled notification won't vibrate
  );
  DarwinNotificationDetails? iosDetails = DarwinNotificationDetails(
    sound: sound ? 'default.wav' : null, // If null, the canceled notification won't play a sound
    presentAlert: true,
    presentSound: sound, // If false, the canceled notification won't play a sound
  );

  return NotificationDetails(android: androidDetails, iOS: iosDetails);
}

Possible Issues and Solutions:

1. Two notifications may cause the sound to play twice.

• To prevent this, you should disable the sound and vibration features of the notification that will be canceled.
• In the code above, the playSound and enableVibration properties for Android and the sound and presentSound properties for iOS have been set to false or null to prevent sound.
• The silent parameter for Android should remain false because setting it to true prevents the popup.

2. Custom actions on notification click do not work with the system's automatic notification.

• To resolve this, I used an alternative method:

static init() async {
  await Firebase.initializeApp();
  RemoteMessage? initialMessage = await FirebaseMessaging.instance.getInitialMessage();
  if (initialMessage != null) {
    // If your app is launched by clicking on a notification, initialMessage won't be null
    NotificationService.openCalendar();
  }

  await messagingInit();
  FirebaseMessaging.onBackgroundMessage(_messagingBackgroundHandler);
}

• After Firebase initialization, the “if (initialMessage != null)” check ensures you can perform actions if your app is launched via a notification click.
• If the app was awakened by clicking a notification, this value won't be null.

3. Notifications received while the app is already running.

• Since the system's automatic notification does not appear when the app is open:
  You can send local notifications without any canceling or silencing when capturing notifications via FirebaseMessaging.onMessage and FirebaseMessaging.onMessageOpenedApp.

4. I haven't tested this method on iOS yet.

• I tested the method on Android, and it worked. However, I haven't had a chance to test it on iOS.
• Since there doesn't seem to be any platform-specific behavior that would cause issues, I believe it should work the same way on iOS.

Conclusion:
Until Firebase provides a better solution, I think this is the best workaround.
With this method, I can receive notifications with popups both while the app is open and when it's closed, and I can trigger custom actions on notification clicks.

Thank you!

[MattyBoy4444]

Is there any better solution?

[bensonarafat]

No solution for this yet?

[chasseuragace]

You'll need to disable notification form the server payload .

No solutions if using firebase console .

[bensonarafat]

what you explained was just for iOS, what about Android? @chasseuragace

[chasseuragace]

When you dont send the notification payload , in android as well it supresses the automatic notification display

[bensonarafat]

automatic

This do not work for android.
When the phone is on background it will still show the notification but empty title

[elia-ba]

It's unbelievable that there is no solution for such a basic requirement. data-only messages are NOT a solution, as it's already been explained multiple times - these data-only messages are unreliable and might never be delivered.

The mere fact this was moved to a discussion and the original issue closed is absurd, this is clearly a massive oversight in the implementation.