@react-native-firebase/messaging 23.7.0 → 23.8.0

package/lib/namespaced.ts

@@ -0,0 +1,583 @@
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+import {
+  hasOwnProperty,
+  isAndroid,
+  isBoolean,
+  isFunction,
+  isIOS,
+  isObject,
+  isString,
+  isUndefined,
+} from '@react-native-firebase/app/lib/common';
+import {
+  createModuleNamespace,
+  FirebaseModule,
+  getFirebaseRoot,
+} from '@react-native-firebase/app/lib/internal';
+import { AppRegistry } from 'react-native';
+import remoteMessageOptions from './remoteMessageOptions';
+import { version } from './version';
+import {
+  AuthorizationStatus,
+  NotificationAndroidPriority,
+  NotificationAndroidVisibility,
+} from './statics';
+import type {
+  Messaging,
+  Statics,
+  RemoteMessage,
+  IOSPermissions,
+  AuthorizationStatus as AuthorizationStatusType,
+} from './types/messaging';
+import type { ReactNativeFirebase } from '@react-native-firebase/app';
+
+const statics: Partial<Statics> = {
+  AuthorizationStatus,
+  NotificationAndroidPriority,
+  NotificationAndroidVisibility,
+};
+const namespace = 'messaging';
+
+const nativeModuleName = 'RNFBMessagingModule';
+
+let backgroundMessageHandler: ((remoteMessage: RemoteMessage) => Promise<any>) | undefined;
+let openSettingsForNotificationHandler: ((remoteMessage: RemoteMessage) => any) | undefined;
+let playServicesAvailability: any;
+
+class FirebaseMessagingModule extends FirebaseModule implements Messaging {
+  _isAutoInitEnabled: boolean;
+  _isDeliveryMetricsExportToBigQueryEnabled: boolean;
+  _isRegisteredForRemoteNotifications: boolean;
+  _isNotificationDelegationEnabled: boolean;
+
+  constructor(
+    app: ReactNativeFirebase.FirebaseAppBase,
+    config: any,
+    customUrlOrRegion?: string | null,
+  ) {
+    super(app, config, customUrlOrRegion);
+    this._isAutoInitEnabled =
+      this.native.isAutoInitEnabled != null ? this.native.isAutoInitEnabled : true;
+    this._isDeliveryMetricsExportToBigQueryEnabled =
+      this.native.isDeliveryMetricsExportToBigQueryEnabled != null
+        ? this.native.isDeliveryMetricsExportToBigQueryEnabled
+        : false;
+    this._isRegisteredForRemoteNotifications =
+      this.native.isRegisteredForRemoteNotifications != null
+        ? this.native.isRegisteredForRemoteNotifications
+        : true;
+    this._isNotificationDelegationEnabled =
+      this.native.isNotificationDelegationEnabled != null
+        ? this.native.isNotificationDelegationEnabled
+        : false;
+
+    AppRegistry.registerHeadlessTask('ReactNativeFirebaseMessagingHeadlessTask', () => {
+      if (!backgroundMessageHandler) {
+        // eslint-disable-next-line no-console
+        console.warn(
+          'No background message handler has been set. Set a handler via the "setBackgroundMessageHandler" method.',
+        );
+        return () => Promise.resolve();
+      }
+      return (remoteMessage: RemoteMessage) => backgroundMessageHandler!(remoteMessage);
+    });
+
+    if (isIOS) {
+      this.emitter.addListener(
+        'messaging_message_received_background',
+        (remoteMessage: RemoteMessage) => {
+          if (!backgroundMessageHandler) {
+            // eslint-disable-next-line no-console
+            console.warn(
+              'No background message handler has been set. Set a handler via the "setBackgroundMessageHandler" method.',
+            );
+            return Promise.resolve();
+          }
+
+          // Ensure the handler is a promise
+          const handlerPromise = Promise.resolve(backgroundMessageHandler(remoteMessage));
+          handlerPromise.finally(() => {
+            this.native.completeNotificationProcessing();
+          });
+
+          return handlerPromise;
+        },
+      );
+
+      this.emitter.addListener(
+        'messaging_settings_for_notification_opened',
+        (remoteMessage: RemoteMessage) => {
+          if (!openSettingsForNotificationHandler) {
+            // eslint-disable-next-line no-console
+            console.warn(
+              'No handler for notification settings link has been set. Set a handler via the "setOpenSettingsForNotificationsHandler" method',
+            );
+
+            return Promise.resolve();
+          }
+
+          return openSettingsForNotificationHandler(remoteMessage);
+        },
+      );
+    }
+  }
+
+  get isAutoInitEnabled(): boolean {
+    return this._isAutoInitEnabled;
+  }
+
+  /**
+   * @ios
+   */
+  get isDeviceRegisteredForRemoteMessages(): boolean {
+    if (isAndroid) {
+      return true;
+    }
+
+    return this._isRegisteredForRemoteNotifications;
+  }
+
+  get isNotificationDelegationEnabled(): boolean {
+    return this._isNotificationDelegationEnabled;
+  }
+
+  get isDeliveryMetricsExportToBigQueryEnabled(): boolean {
+    return this._isDeliveryMetricsExportToBigQueryEnabled;
+  }
+
+  setAutoInitEnabled(enabled: boolean): Promise<void> {
+    if (!isBoolean(enabled)) {
+      throw new Error(
+        "firebase.messaging().setAutoInitEnabled(*) 'enabled' expected a boolean value.",
+      );
+    }
+
+    this._isAutoInitEnabled = enabled;
+    return this.native.setAutoInitEnabled(enabled);
+  }
+
+  getInitialNotification(): Promise<RemoteMessage | null> {
+    return this.native.getInitialNotification().then((value: RemoteMessage | null) => {
+      if (value) {
+        return value;
+      }
+      return null;
+    });
+  }
+
+  getDidOpenSettingsForNotification(): Promise<boolean> {
+    if (!isIOS) return Promise.resolve(false);
+    return this.native.getDidOpenSettingsForNotification().then((value: boolean) => value);
+  }
+
+  getIsHeadless(): Promise<boolean> {
+    return this.native.getIsHeadless();
+  }
+
+  getToken(options?: { appName?: string; senderId?: string }): Promise<string> {
+    if (!isUndefined(options?.appName) && !isString(options?.appName)) {
+      throw new Error("firebase.messaging().getToken(*) 'appName' expected a string.");
+    }
+
+    if (!isUndefined(options?.senderId) && !isString(options?.senderId)) {
+      throw new Error("firebase.messaging().getToken(*) 'senderId' expected a string.");
+    }
+
+    const appName = options?.appName || this.app.name;
+    const senderId = options?.senderId || this.app.options.messagingSenderId;
+
+    return this.native.getToken(appName, senderId);
+  }
+
+  deleteToken(options?: { appName?: string; senderId?: string }): Promise<void> {
+    if (!isUndefined(options?.appName) && !isString(options?.appName)) {
+      throw new Error("firebase.messaging().deleteToken(*) 'appName' expected a string.");
+    }
+
+    if (!isUndefined(options?.senderId) && !isString(options?.senderId)) {
+      throw new Error("firebase.messaging().deleteToken(*) 'senderId' expected a string.");
+    }
+
+    const appName = options?.appName || this.app.name;
+    const senderId = options?.senderId || this.app.options.messagingSenderId;
+
+    return this.native.deleteToken(appName, senderId);
+  }
+
+  onMessage(listener: (message: RemoteMessage) => any): () => void {
+    if (!isFunction(listener)) {
+      throw new Error("firebase.messaging().onMessage(*) 'listener' expected a function.");
+    }
+
+    const subscription = this.emitter.addListener('messaging_message_received', listener);
+    return () => subscription.remove();
+  }
+
+  onNotificationOpenedApp(listener: (message: RemoteMessage) => any): () => void {
+    if (!isFunction(listener)) {
+      throw new Error(
+        "firebase.messaging().onNotificationOpenedApp(*) 'listener' expected a function.",
+      );
+    }
+
+    const subscription = this.emitter.addListener('messaging_notification_opened', listener);
+    return () => subscription.remove();
+  }
+
+  onTokenRefresh(listener: (token: string) => any): () => void {
+    if (!isFunction(listener)) {
+      throw new Error("firebase.messaging().onTokenRefresh(*) 'listener' expected a function.");
+    }
+
+    const subscription = this.emitter.addListener(
+      'messaging_token_refresh',
+      (event: { token: string }) => {
+        const { token } = event;
+        listener(token);
+      },
+    );
+    return () => subscription.remove();
+  }
+
+  /**
+   * @platform ios
+   */
+  requestPermission(permissions?: IOSPermissions): Promise<AuthorizationStatusType> {
+    if (isAndroid) {
+      return Promise.resolve(AuthorizationStatus.AUTHORIZED);
+    }
+
+    const defaultPermissions: IOSPermissions = {
+      alert: true,
+      announcement: false,
+      badge: true,
+      carPlay: true,
+      provisional: false,
+      sound: true,
+      criticalAlert: false,
+      providesAppNotificationSettings: false,
+    };
+
+    if (!permissions) {
+      return this.native.requestPermission(defaultPermissions);
+    }
+
+    if (!isObject(permissions)) {
+      throw new Error('firebase.messaging().requestPermission(*) expected an object value.');
+    }
+
+    Object.entries(permissions).forEach(([key, value]) => {
+      if (!hasOwnProperty(defaultPermissions, key)) {
+        throw new Error(
+          `firebase.messaging().requestPermission(*) unexpected key "${key}" provided to permissions object.`,
+        );
+      }
+
+      if (!isBoolean(value)) {
+        throw new Error(
+          `firebase.messaging().requestPermission(*) the permission "${key}" expected a boolean value.`,
+        );
+      }
+
+      (defaultPermissions as any)[key] = value;
+    });
+
+    return this.native.requestPermission(defaultPermissions);
+  }
+
+  registerDeviceForRemoteMessages(): Promise<void> {
+    if (isAndroid) {
+      return Promise.resolve();
+    }
+
+    const autoRegister = this.firebaseJson['messaging_ios_auto_register_for_remote_messages'];
+    if (autoRegister === undefined || autoRegister === true) {
+      // eslint-disable-next-line no-console
+      console.warn(
+        `Usage of "messaging().registerDeviceForRemoteMessages()" is not required. You only need to register if auto-registration is disabled in your 'firebase.json' configuration file via the 'messaging_ios_auto_register_for_remote_messages' property.`,
+      );
+    }
+
+    this._isRegisteredForRemoteNotifications = true;
+    return this.native.registerForRemoteNotifications();
+  }
+
+  /**
+   * @platform ios
+   */
+  unregisterDeviceForRemoteMessages(): Promise<void> {
+    if (isAndroid) {
+      return Promise.resolve();
+    }
+    this._isRegisteredForRemoteNotifications = false;
+    return this.native.unregisterForRemoteNotifications();
+  }
+
+  /**
+   * @platform ios
+   */
+  getAPNSToken(): Promise<string | null> {
+    if (isAndroid) {
+      return Promise.resolve(null);
+    }
+    return this.native.getAPNSToken();
+  }
+
+  /**
+   * @platform ios
+   */
+  setAPNSToken(token: string, type?: string): Promise<void> {
+    if (isUndefined(token) || !isString(token)) {
+      throw new Error("firebase.messaging().setAPNSToken(*) 'token' expected a string value.");
+    }
+
+    if (!isUndefined(type) && (!isString(type) || !['prod', 'sandbox', 'unknown'].includes(type))) {
+      throw new Error(
+        "firebase.messaging().setAPNSToken(*) 'type' expected one of 'prod', 'sandbox', or 'unknown'.",
+      );
+    }
+
+    if (isAndroid) {
+      return Promise.resolve();
+    }
+
+    return this.native.setAPNSToken(token, type);
+  }
+
+  hasPermission(): Promise<AuthorizationStatusType> {
+    return this.native.hasPermission();
+  }
+
+  // https://firebase.google.com/docs/reference/android/com/google/firebase/messaging/FirebaseMessagingService.html#public-void-ondeletedmessages-
+  onDeletedMessages(listener: () => void): () => void {
+    if (!isFunction(listener)) {
+      throw new Error("firebase.messaging().onDeletedMessages(*) 'listener' expected a function.");
+    }
+
+    const subscription = this.emitter.addListener('messaging_message_deleted', listener);
+    return () => subscription.remove();
+  }
+
+  // https://firebase.google.com/docs/reference/android/com/google/firebase/messaging/FirebaseMessagingService.html#onMessageSent(java.lang.String)
+  onMessageSent(listener: (messageId: string) => any): () => void {
+    if (!isFunction(listener)) {
+      throw new Error("firebase.messaging().onMessageSent(*) 'listener' expected a function.");
+    }
+
+    const subscription = this.emitter.addListener('messaging_message_sent', listener);
+    return () => {
+      subscription.remove();
+    };
+  }
+
+  // https://firebase.google.com/docs/reference/android/com/google/firebase/messaging/FirebaseMessagingService.html#onSendError(java.lang.String,%20java.lang.Exception)
+  onSendError(
+    listener: (evt: { messageId: string; error: ReactNativeFirebase.NativeFirebaseError }) => any,
+  ): () => void {
+    if (!isFunction(listener)) {
+      throw new Error("firebase.messaging().onSendError(*) 'listener' expected a function.");
+    }
+
+    const subscription = this.emitter.addListener('messaging_message_send_error', listener);
+    return () => subscription.remove();
+  }
+
+  /**
+   * Set a handler that will be called when a message is received while the app is in the background.
+   * Should be called before the app is registered in `AppRegistry`, for example in `index.js`.
+   * An app is considered to be in the background if no active window is displayed.
+   * @param handler called with an argument of type messaging.RemoteMessage that must be async and return a Promise
+   */
+  setBackgroundMessageHandler(handler: (message: RemoteMessage) => Promise<any>): void {
+    if (!isFunction(handler)) {
+      throw new Error(
+        "firebase.messaging().setBackgroundMessageHandler(*) 'handler' expected a function.",
+      );
+    }
+
+    backgroundMessageHandler = handler;
+    if (isIOS) {
+      this.native.signalBackgroundMessageHandlerSet();
+    }
+  }
+
+  setOpenSettingsForNotificationsHandler(handler: (message: RemoteMessage) => any): void {
+    if (!isIOS) {
+      return;
+    }
+
+    if (!isFunction(handler)) {
+      throw new Error(
+        "firebase.messaging().setOpenSettingsForNotificationsHandler(*) 'handler' expected a function.",
+      );
+    }
+
+    openSettingsForNotificationHandler = handler;
+  }
+
+  sendMessage(remoteMessage: RemoteMessage): Promise<void> {
+    if (isIOS) {
+      throw new Error(`firebase.messaging().sendMessage() is only supported on Android devices.`);
+    }
+    let options;
+    try {
+      const senderId = this.app.options.messagingSenderId;
+      if (!senderId) {
+        throw new Error("'messagingSenderId' is required in Firebase app options.");
+      }
+      options = remoteMessageOptions(senderId, remoteMessage);
+    } catch (e: any) {
+      throw new Error(`firebase.messaging().sendMessage(*) ${e.message}.`);
+    }
+
+    return this.native.sendMessage(options);
+  }
+
+  subscribeToTopic(topic: string): Promise<void> {
+    if (!isString(topic)) {
+      throw new Error("firebase.messaging().subscribeToTopic(*) 'topic' expected a string value.");
+    }
+
+    if (topic.indexOf('/') > -1) {
+      throw new Error('firebase.messaging().subscribeToTopic(*) \'topic\' must not include "/".');
+    }
+
+    return this.native.subscribeToTopic(topic);
+  }
+
+  unsubscribeFromTopic(topic: string): Promise<void> {
+    if (!isString(topic)) {
+      throw new Error(
+        "firebase.messaging().unsubscribeFromTopic(*) 'topic' expected a string value.",
+      );
+    }
+
+    if (topic.indexOf('/') > -1) {
+      throw new Error(
+        'firebase.messaging().unsubscribeFromTopic(*) \'topic\' must not include "/".',
+      );
+    }
+
+    return this.native.unsubscribeFromTopic(topic);
+  }
+
+  /**
+   * unsupported
+   */
+
+  useServiceWorker(): void {
+    // eslint-disable-next-line no-console
+    console.warn(
+      'firebase.messaging().useServiceWorker() is not supported on react-native-firebase.',
+    );
+  }
+
+  usePublicVapidKey(): void {
+    // eslint-disable-next-line no-console
+    console.warn(
+      'firebase.messaging().usePublicVapidKey() is not supported on react-native-firebase.',
+    );
+  }
+
+  setDeliveryMetricsExportToBigQuery(enabled: boolean): Promise<void> {
+    if (!isBoolean(enabled)) {
+      throw new Error(
+        "firebase.messaging().setDeliveryMetricsExportToBigQuery(*) 'enabled' expected a boolean value.",
+      );
+    }
+
+    this._isDeliveryMetricsExportToBigQueryEnabled = enabled;
+    return this.native.setDeliveryMetricsExportToBigQuery(enabled);
+  }
+
+  setNotificationDelegationEnabled(enabled: boolean): Promise<void> {
+    if (!isBoolean(enabled)) {
+      throw new Error(
+        "firebase.messaging().setNotificationDelegationEnabled(*) 'enabled' expected a boolean value.",
+      );
+    }
+
+    this._isNotificationDelegationEnabled = enabled;
+    if (isIOS) {
+      return Promise.resolve();
+    }
+
+    return this.native.setNotificationDelegationEnabled(enabled);
+  }
+
+  async isSupported(): Promise<boolean> {
+    if (isAndroid) {
+      const firebase = getFirebaseRoot();
+      const app = this.app;
+      // @ts-ignore - secret "app" argument to avoid deprecation warning when getApp() is called under the hood
+      playServicesAvailability = firebase.utils(app).playServicesAvailability;
+      return playServicesAvailability.isAvailable;
+    }
+    // Always return "true" for iOS. Web will be implemented when it is supported
+    return true;
+  }
+}
+
+// import { SDK_VERSION } from '@react-native-firebase/messaging';
+export const SDK_VERSION = version;
+
+// import messaging from '@react-native-firebase/messaging';
+// messaging().X(...);
+const messagingNamespace = createModuleNamespace({
+  statics,
+  version,
+  namespace,
+  nativeModuleName,
+  nativeEvents: [
+    'messaging_token_refresh',
+    'messaging_message_sent',
+    'messaging_message_deleted',
+    'messaging_message_received',
+    'messaging_message_send_error',
+    'messaging_notification_opened',
+    ...(isIOS
+      ? ['messaging_message_received_background', 'messaging_settings_for_notification_opened']
+      : []),
+  ],
+  hasMultiAppSupport: false,
+  hasCustomUrlOrRegionSupport: false,
+  ModuleClass: FirebaseMessagingModule,
+});
+
+type MessagingNamespace = ReactNativeFirebase.FirebaseModuleWithStaticsAndApp<
+  Messaging,
+  Statics
+> & {
+  messaging: ReactNativeFirebase.FirebaseModuleWithStaticsAndApp<Messaging, Statics>;
+  firebase: ReactNativeFirebase.Module;
+  app(name?: string): ReactNativeFirebase.FirebaseApp;
+};
+
+export default messagingNamespace as unknown as MessagingNamespace;
+
+// import messaging, { firebase } from '@react-native-firebase/messaging';
+// messaging().X(...);
+// firebase.messaging().X(...);
+export const firebase =
+  getFirebaseRoot() as unknown as ReactNativeFirebase.FirebaseNamespacedExport<
+    'messaging',
+    Messaging,
+    Statics,
+    false
+  >;

package/lib/remoteMessageOptions.ts

@@ -0,0 +1,110 @@
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+import {
+  generateFirestoreId,
+  hasOwnProperty,
+  isInteger,
+  isNumber,
+  isObject,
+  isString,
+  isUndefined,
+} from '@react-native-firebase/app/lib/common';
+import type { RemoteMessage } from './types/messaging';
+
+interface RemoteMessageOptions {
+  to: string;
+  messageId: string;
+  ttl: number;
+  data: { [key: string]: string };
+  collapseKey?: string;
+  messageType?: string;
+}
+
+export default function remoteMessageOptions(
+  messagingSenderId: string,
+  remoteMessage: RemoteMessage,
+): RemoteMessageOptions {
+  const out: Partial<RemoteMessageOptions> = {};
+
+  if (isUndefined(remoteMessage) || !isObject(remoteMessage)) {
+    throw new Error("'remoteMessage' expected an object value");
+  }
+
+  if (!remoteMessage.to) {
+    out.to = `${messagingSenderId}@fcm.googleapis.com`;
+  } else if (!isString(remoteMessage.to)) {
+    throw new Error("'remoteMessage.to' expected a string value");
+  } else {
+    out.to = remoteMessage.to;
+  }
+
+  if (!remoteMessage.messageId) {
+    out.messageId = generateFirestoreId();
+  } else if (!isString(remoteMessage.messageId)) {
+    throw new Error("'remoteMessage.messageId' expected a string value");
+  } else {
+    out.messageId = remoteMessage.messageId;
+  }
+
+  if (!hasOwnProperty(remoteMessage, 'ttl')) {
+    out.ttl = 3600;
+  } else {
+    if (!isNumber(remoteMessage.ttl)) {
+      throw new Error("'remoteMessage.ttl' expected a number value");
+    }
+    if (remoteMessage.ttl! < 0 || !isInteger(remoteMessage.ttl!)) {
+      throw new Error("'remoteMessage.ttl' expected a positive integer value");
+    }
+    out.ttl = remoteMessage.ttl!;
+  }
+
+  if (!remoteMessage.data) {
+    out.data = {};
+  } else if (!isObject(remoteMessage.data)) {
+    throw new Error("'remoteMessage.data' expected an object value");
+  } else {
+    // Serialize all objects to strings
+    out.data = {};
+    for (const key in remoteMessage.data) {
+      if (hasOwnProperty(remoteMessage.data, key)) {
+        const value = remoteMessage.data[key];
+        if (typeof value === 'object' && !Array.isArray(value) && value !== null) {
+          out.data[key] = JSON.stringify(value);
+        } else {
+          out.data[key] = String(value);
+        }
+      }
+    }
+  }
+
+  if (remoteMessage.collapseKey) {
+    if (!isString(remoteMessage.collapseKey)) {
+      throw new Error("'remoteMessage.collapseKey' expected a string value");
+    }
+    out.collapseKey = remoteMessage.collapseKey;
+  }
+
+  if (remoteMessage.messageType) {
+    if (!isString(remoteMessage.messageType)) {
+      throw new Error("'remoteMessage.messageType' expected a string value");
+    }
+    out.messageType = remoteMessage.messageType;
+  }
+
+  return out as RemoteMessageOptions;
+}