feat(messaging, android): notification delegation APIs, firebase.json feature toggle

with Android Q+ and current Google Play Services, android does notification delegation by
default now for REST v1 API FCM, but this causes react-native-firebase message handlers to fail

Implement a feature toggle in AndroidManifest.xml via firebase.json that defaults to false so
most users won't be affected

Implement the programmatic APIs to dynamically set and fetch current state for the feature as well

Author: mikehardy

.spellcheck.dict.txt

@@ -215,6 +215,7 @@ uri-scheme
 userData
 utils
 Utils
+v1
 v15
 v5
 v6

docs/messaging/usage/index.md

@@ -64,6 +64,16 @@ If you require `remote notification` on Expo, you can also add this to your Expo
 }
 ```
 
+## Android - Google Play Notification Delegation
+
+If you use the REST v1 APIs (used by the Firebase admin SDKs) and your app is running on Android Q+ with current Google Play services, Google implemented "Notification Delegation" for messages. Notification delegation is not currently compatible with react-native-firebase. Specifically, if your notifications are delegated via proxy to Play Services, then your messaging listeners will not be called.
+
+To work around this incompatibility, react-native-firebase disables notification delegation by default currently, using the `AndroidManifest.xml` method listed as one of the options described here: <https://firebase.google.com/docs/cloud-messaging/android/message-priority#proxy>.
+
+You may re-enable notification delegation if your use case requires it and you can accept the messaging listener methods not executing for delegated messages by altering the firebase.json setting `messaging_android_notification_delegation_enabled` to `true`.
+
+You may also use the new messaging APIs to get and set the notification delegation state for the app, as desired.
+
 # What does it do
 
 React Native Firebase provides native integration of Firebase Cloud Messaging (FCM) for both Android & iOS. FCM is a cost

packages/app/firebase-schema.json

@@ -56,12 +56,7 @@
         "app_log_level": {
           "description": "Set the log level across all modules. Only applies to iOS currently. Can be 'error', 'warn', 'info', 'debug'.\n Logs messages at the configured level or lower.\n Note that if an app is running from AppStore, it will never log above info even if level is set to a higher (more verbose) setting",
           "type": "string",
-          "enum": [
-            "error",
-            "warn",
-            "info",
-            "debug"
-          ]
+          "enum": ["error", "warn", "info", "debug"]
         },
         "app_check_token_auto_refresh": {
           "description": "If this flag is disabled then Firebase App Check will not periodically auto-refresh the app check token.\n This is useful for opt-in-first data flows, for example when dealing with GDPR compliance. \nIf unset it will default to the SDK-wide data collection default enabled setting. This may be overridden dynamically in Javascript.",
@@ -100,6 +95,10 @@
           "type": "number",
           "minimum": 0
         },
+        "messaging_android_notification_delegation_enabled": {
+          "description": "On Android Q+ and current Play Services, your FCM may be delegated which disables firebase message listeners. Disabled by default. You may re-enable if necessary",
+          "type": "boolean"
+        },
         "messaging_android_notification_channel_id": {
           "description": "On Android, any message which displays a Notification use a default Notification Channel (created by FCM called `Miscellaneous`). This channel contains basic notification settings which may not be appropriate for your application. You can change what Channel is used by updating the `messaging_android_notification_channel_id` property.",
           "type": "string"

packages/messaging/android/build.gradle

@@ -71,6 +71,8 @@ String deliveryMetricsExportEnabled = 'false'
 // If nothing is defined, data collection defaults to true
 String dataCollectionEnabled = 'true'
 
+String notificationDelegationEnabled = 'false'
+
 if (rootProject.ext && rootProject.ext.firebaseJson) {
   /* groovylint-disable-next-line NoDef, VariableTypeRequired */
   def rnfbConfig = rootProject.ext.firebaseJson
@@ -92,6 +94,10 @@ if (rootProject.ext && rootProject.ext.firebaseJson) {
   }
   notificationChannelId = rnfbConfig.getStringValue('messaging_android_notification_channel_id', defaultNotificationChannelId)
   notificationColor = rnfbConfig.getStringValue('messaging_android_notification_color', defaultNotificationColor)
+
+  if (rnfbConfig.isFlagEnabled('messaging_android_notification_delegation_enabled', false)) {
+    notificationDelegationEnabled = 'true'
+  }
 }
 
 android {
@@ -106,7 +112,8 @@ android {
       firebaseJsonDeliveryMetricsExportEnabled: deliveryMetricsExportEnabled,
       firebaseJsonAutoInitEnabled: dataCollectionEnabled,
       firebaseJsonNotificationChannelId: notificationChannelId,
-      firebaseJsonNotificationColor: notificationColor
+      firebaseJsonNotificationColor: notificationColor,
+      firebaseJsonNotificationDelegationEnabled: notificationDelegationEnabled
     ]
   }
 

packages/messaging/android/src/main/AndroidManifest.xml

@@ -30,6 +30,9 @@
     <meta-data
       android:name="firebase_messaging_auto_init_enabled"
       android:value="${firebaseJsonAutoInitEnabled}"/>
+    <meta-data
+      android:name="firebase_messaging_notification_delegation_enabled"
+      android:value="${firebaseJsonNotificationDelegationEnabled}"/>
     <meta-data
       android:name="com.google.firebase.messaging.default_notification_channel_id"
       android:value="${firebaseJsonNotificationChannelId}" />

packages/messaging/android/src/main/java/io/invertase/firebase/messaging/ReactNativeFirebaseMessagingModule.java

@@ -120,6 +120,42 @@ public void setAutoInitEnabled(Boolean enabled, Promise promise) {
             });
   }
 
+  @ReactMethod
+  public void isNotificationDelegationEnabled(Promise promise) {
+    Tasks.call(
+            getExecutor(),
+            () -> {
+              FirebaseMessaging.getInstance().isNotificationDelegationEnabled();
+              return null;
+            })
+        .addOnCompleteListener(
+            task -> {
+              if (task.isSuccessful()) {
+                promise.resolve(task.getResult());
+              } else {
+                rejectPromiseWithExceptionMap(promise, task.getException());
+              }
+            });
+  }
+
+  @ReactMethod
+  public void setNotificationDelegationEnabled(Boolean enabled, Promise promise) {
+    Tasks.call(
+            getExecutor(),
+            () -> {
+              FirebaseMessaging.getInstance().setNotificationDelegationEnabled(enabled);
+              return null;
+            })
+        .addOnCompleteListener(
+            task -> {
+              if (task.isSuccessful()) {
+                promise.resolve(FirebaseMessaging.getInstance().isNotificationDelegationEnabled());
+              } else {
+                rejectPromiseWithExceptionMap(promise, task.getException());
+              }
+            });
+  }
+
   @ReactMethod
   public void getToken(String appName, String senderId, Promise promise) {
     FirebaseMessaging messagingInstance =
@@ -247,6 +283,9 @@ public Map<String, Object> getConstants() {
     constants.put(
         "isDeliveryMetricsExportToBigQueryEnabled",
         FirebaseMessaging.getInstance().deliveryMetricsExportToBigQueryEnabled());
+    constants.put(
+        "isNotificationDelegationEnabled",
+        FirebaseMessaging.getInstance().isNotificationDelegationEnabled());
     return constants;
   }
 

packages/messaging/e2e/messaging.e2e.js

@@ -445,6 +445,28 @@ describe('messaging()', function () {
       });
     });
 
+    describe('setNotificationDelegationEnabled()', function () {
+      afterEach(async function () {
+        await firebase.messaging().setNotificationDelegationEnabled(false);
+      });
+
+      it('throws if enabled is not a boolean', function () {
+        try {
+          firebase.messaging().setNotificationDelegationEnabled(123);
+          return Promise.reject(new Error('Did not throw Error.'));
+        } catch (e) {
+          e.message.should.containEql("'enabled' expected a boolean value");
+          return Promise.resolve();
+        }
+      });
+
+      it('sets the value', async function () {
+        should.equal(firebase.messaging().isNotificationDelegationEnabled, false);
+        await firebase.messaging().setNotificationDelegationEnabled(true);
+        should.equal(firebase.messaging().isNotificationDelegationEnabled, true);
+      });
+    });
+
     describe('isSupported()', function () {
       it('should return "true" if the device or browser supports Firebase Messaging', async function () {
         // For android, when the play services are available, it will return "true"
@@ -897,6 +919,33 @@ describe('messaging()', function () {
       });
     });
 
+    describe('setNotificationDelegationEnabled()', function () {
+      afterEach(async function () {
+        const { getMessaging, setNotificationDelegationEnabled } = messagingModular;
+        await setNotificationDelegationEnabled(getMessaging(), false);
+      });
+
+      it('throws if enabled is not a boolean', function () {
+        const { getMessaging, setNotificationDelegationEnabled } = messagingModular;
+        try {
+          setNotificationDelegationEnabled(getMessaging(), 123);
+          return Promise.reject(new Error('Did not throw Error.'));
+        } catch (e) {
+          e.message.should.containEql("'enabled' expected a boolean value");
+          return Promise.resolve();
+        }
+      });
+
+      it('sets the value', async function () {
+        const { getMessaging, setNotificationDelegationEnabled, isNotificationDelegationEnabled } =
+          messagingModular;
+
+        should.equal(isNotificationDelegationEnabled(getMessaging()), false);
+        await setNotificationDelegationEnabled(getMessaging(), true);
+        should.equal(isNotificationDelegationEnabled(getMessaging()), true);
+      });
+    });
+
     describe('isSupported()', function () {
       it('should return "true" if the device or browser supports Firebase Messaging', async function () {
         const { isSupported, getMessaging } = messagingModular;

packages/messaging/lib/index.d.ts

@@ -1145,6 +1145,40 @@ export namespace FirebaseMessagingTypes {
      * @param enabled A boolean value to enable or disable exporting of message delivery metrics to BigQuery.
      */
     setDeliveryMetricsExportToBigQuery(enabled: boolean): Promise<void>;
+
+    /**
+     * Sets whether remote notification delegation to Google Play Services is enabled or disabled.
+     *
+     * The value is false by default. Set this to true to allow remote notification delegation.
+     *
+     * Warning: this will disable notification handlers on Android, and on iOS it has no effect
+     *
+     *
+     * #### Example
+     *
+     * ```js
+     * // Enable delegation of remote notifications to Google Play Services
+     * await firebase.messaging().setNotificationDelegationEnabled(true);
+     * ```
+     *
+     * @param enabled A boolean value to enable or disable remote notification delegation to Google Play Services.
+     */
+    setNotificationDelegationEnabled(enabled: boolean): Promise<void>;
+
+    /**
+     * Gets whether remote notification delegation to Google Play Services is enabled or disabled.
+     *
+     * #### Example
+     *
+     * ```js
+     * // Determine if delegation of remote notifications to Google Play Services is enabled
+     * const delegationEnabled = await firebase.messaging().isNotificationDelegationEnabled();
+     * ```
+     *
+     * @returns enabled A boolean value indicatign if remote notification delegation to Google Play Services is enabled.
+     */
+    istNotificationDelegationEnabled(): Promise<boolean>;
+
     /**
      * Checks if all required APIs exist in the browser.
      *

packages/messaging/lib/index.js

@@ -60,6 +60,10 @@ class FirebaseMessagingModule extends FirebaseModule {
       this.native.isRegisteredForRemoteNotifications != null
         ? this.native.isRegisteredForRemoteNotifications
         : true;
+    this._isNotificationDelegationEnabled =
+      this.native.isNotificationDelegationEnabled != null
+        ? this.native.isNotificationDelegationEnabled
+        : false;
 
     AppRegistry.registerHeadlessTask('ReactNativeFirebaseMessagingHeadlessTask', () => {
       if (!backgroundMessageHandler) {
@@ -121,6 +125,10 @@ class FirebaseMessagingModule extends FirebaseModule {
     return this._isRegisteredForRemoteNotifications;
   }
 
+  get isNotificationDelegationEnabled() {
+    return this._isNotificationDelegationEnabled;
+  }
+
   get isDeliveryMetricsExportToBigQueryEnabled() {
     return this._isDeliveryMetricsExportToBigQueryEnabled;
   }
@@ -460,6 +468,21 @@ class FirebaseMessagingModule extends FirebaseModule {
     return this.native.setDeliveryMetricsExportToBigQuery(enabled);
   }
 
+  setNotificationDelegationEnabled(enabled) {
+    if (!isBoolean(enabled)) {
+      throw new Error(
+        "firebase.messaging().setNotificationDelegationEnabled(*) 'enabled' expected a boolean value.",
+      );
+    }
+
+    this._isNotificationDelegationEnabled = enabled;
+    if (isIOS) {
+      return;
+    }
+
+    return this.native.setNotificationDelegationEnabled(enabled);
+  }
+
   async isSupported() {
     if (Platform.isAndroid) {
       playServicesAvailability = firebase.utils().playServicesAvailability;

packages/messaging/lib/modular/index.d.ts

@@ -99,6 +99,29 @@ export function isAutoInitEnabled(messaging: Messaging): boolean;
  */
 export function setAutoInitEnabled(messaging: Messaging, enabled: boolean): Promise<void>;
 
+/**
+ * Sets whether remote notification delegation to Google Play Services is enabled or disabled.
+ *
+ * The value is false by default. Set this to true to allow remote notification delegation.
+ *
+ * Warning: this will disable notification handlers on Android, and on iOS it has no effect
+ *
+ * @param messaging - Messaging instance.
+ * @param enabled A boolean value to enable or disable remote notification delegation to Google Play Services.
+ */
+export function setNotificationDelegationEnabled(
+  messaging: Messaging,
+  enabled: boolean,
+): Promise<void>;
+
+/**
+ * Gets whether remote notification delegation to Google Play Services is enabled or disabled.
+ *
+ * @param messaging - Messaging instance.
+ * @returns enabled A boolean value indicatign if remote notification delegation to Google Play Services is enabled.
+ */
+export function istNotificationDelegationEnabled(messaging: Messaging): Promise<boolean>;
+
 /**
  * When a notification from FCM has triggered the application to open from a quit state,
  * this method will return a `RemoteMessage` containing the notification data, or `null` if

packages/messaging/lib/modular/index.js

@@ -317,6 +317,28 @@ export function isDeliveryMetricsExportToBigQueryEnabled(messaging) {
   return messaging.isDeliveryMetricsExportToBigQueryEnabled;
 }
 
+/**
+ * Returns a boolean whether message delegation is enabled. Android only,
+ * always returns false on iOS
+ * @param {Messaging} messaging - Messaging instance.
+ * @returns {boolean}
+ */
+export function isNotificationDelegationEnabled(messaging) {
+  return messaging.isNotificationDelegationEnabled;
+}
+
+/**
+ * Sets whether message notification delegation is enabled or disabled.
+ * The value is false by default. Set this to true to allow delegation of notification to Google Play Services.
+ * Note if true message handlers will not function on Android, and it has no effect on iOS
+ * @param {Messaging} messaging - Messaging instance.
+ * @param {boolean} enabled - A boolean value to enable or disable delegation of messages to Google Play Services.
+ * @returns {Promise<void>}
+ */
+export function setNotificationDelegationEnabled(messaging, enabled) {
+  return messaging.setNotificationDelegationEnabled(enabled);
+}
+
 /**
  * Checks if all required APIs exist in the browser.
  * @param {Messaging} messaging - Messaging instance.

tests/firebase.json

@@ -20,6 +20,7 @@
     "messaging_android_notification_channel_id": "",
     "messaging_android_notification_color": "@color/hotpink",
     "messaging_ios_auto_register_for_remote_messages": false,
+    "messaging_android_notification_delegation_enabled": true,
 
     "analytics_auto_collection_enabled": true,
     "analytics_collection_deactivated": false,