@react-native-firebase/messaging 25.1.0 → 26.0.0

package/ios/RNFBMessaging/RNFBMessaging+UNUserNotificationCenter.m

@@ -106,24 +106,13 @@ struct {
   // if list or banner is true, ignore `alert` property
   if (banner || list) {
     if (banner) {
-      if (@available(iOS 14, *)) {
-        presentationOptions |= UNNotificationPresentationOptionBanner;
-      } else {
-        // for iOS 13 we need to set `alert`
-        presentationOptions |= UNNotificationPresentationOptionAlert;
-      }
+      presentationOptions |= UNNotificationPresentationOptionBanner;
     }
 
     if (list) {
-      if (@available(iOS 14, *)) {
-        presentationOptions |= UNNotificationPresentationOptionList;
-      } else {
-        // for iOS 13 we need to set `alert`
-        presentationOptions |= UNNotificationPresentationOptionAlert;
-      }
+      presentationOptions |= UNNotificationPresentationOptionList;
     }
   } else if (alert) {
-    // TODO: Remove `alert` once iOS 14 becomes the minimum deployment target
     presentationOptions |= UNNotificationPresentationOptionAlert;
   }
 
@@ -139,22 +128,32 @@ struct {
     }
   }
 
-  if (_originalDelegate != nil && originalDelegateRespondsTo.willPresentNotification) {
-    [_originalDelegate userNotificationCenter:center
-                      willPresentNotification:notification
-                        withCompletionHandler:completionHandler];
+  // completionHandler must be invoked exactly once. If the original delegate
+  // implements willPresentNotification, defer to it entirely - it owns the
+  // completionHandler contract (and may call it asynchronously). Only fall
+  // back to our own presentationOptions when there is no original delegate
+  // to hand off to.
+  //
+  // _originalDelegate is weak, so it is captured into a strong local first -
+  // otherwise it could be deallocated between the nil-check and the message
+  // send (turning the send into a no-op) and completionHandler would never
+  // be called at all.
+  id<UNUserNotificationCenterDelegate> strongOriginalDelegate = _originalDelegate;
+  if (strongOriginalDelegate != nil && originalDelegateRespondsTo.willPresentNotification) {
+    [strongOriginalDelegate userNotificationCenter:center
+                           willPresentNotification:notification
+                             withCompletionHandler:completionHandler];
+  } else {
+    completionHandler(presentationOptions);
   }
-
-  // Don't consume completionHandler before the _originalDelegate has been
-  // processed
-  completionHandler(presentationOptions);
 }
 
 - (void)userNotificationCenter:(UNUserNotificationCenter *)center
     didReceiveNotificationResponse:(UNNotificationResponse *)response
              withCompletionHandler:(void (^)(void))completionHandler {
   NSDictionary *remoteNotification = response.notification.request.content.userInfo;
-  if (remoteNotification[@"gcm.message_id"]) {
+  if ([[response actionIdentifier] isEqualToString:UNNotificationDefaultActionIdentifier] &&
+      remoteNotification[@"gcm.message_id"]) {
     NSDictionary *notificationDict =
         [RNFBMessagingSerializer remoteMessageUserInfoToDict:remoteNotification];
     [[RNFBRCTEventEmitter shared] sendEventWithName:@"messaging_notification_opened"
@@ -162,10 +161,13 @@ struct {
     _initialNotification = notificationDict;
   }
 
-  if (_originalDelegate != nil && originalDelegateRespondsTo.didReceiveNotificationResponse) {
-    [_originalDelegate userNotificationCenter:center
-               didReceiveNotificationResponse:response
-                        withCompletionHandler:completionHandler];
+  // _originalDelegate is weak — capture strong local before nil-check + message
+  // (same race as willPresent; otherwise completionHandler may never run).
+  id<UNUserNotificationCenterDelegate> strongOriginalDelegate = _originalDelegate;
+  if (strongOriginalDelegate != nil && originalDelegateRespondsTo.didReceiveNotificationResponse) {
+    [strongOriginalDelegate userNotificationCenter:center
+                    didReceiveNotificationResponse:response
+                             withCompletionHandler:completionHandler];
   } else {
     completionHandler();
   }
@@ -173,8 +175,9 @@ struct {
 
 - (void)userNotificationCenter:(UNUserNotificationCenter *)center
     openSettingsForNotification:(nullable UNNotification *)notification {
-  if (_originalDelegate != nil && originalDelegateRespondsTo.openSettingsForNotification) {
-    [_originalDelegate userNotificationCenter:center openSettingsForNotification:notification];
+  id<UNUserNotificationCenterDelegate> strongOriginalDelegate = _originalDelegate;
+  if (strongOriginalDelegate != nil && originalDelegateRespondsTo.openSettingsForNotification) {
+    [strongOriginalDelegate userNotificationCenter:center openSettingsForNotification:notification];
   } else {
     NSDictionary *notificationDict = [RNFBMessagingSerializer notificationToDict:notification];
     [[RNFBRCTEventEmitter shared] sendEventWithName:@"messaging_settings_for_notification_opened"

package/ios/RNFBMessaging/RNFBMessagingModule.h

@@ -16,9 +16,10 @@
  */
 
 #import <Foundation/Foundation.h>
-#import <React/RCTBridgeModule.h>
 
-@interface RNFBMessagingModule : NSObject <RCTBridgeModule>
+// Public / AppDelegate-safe: no C++/codegen imports. TurboModule conformance lives in .mm.
+// Kept public for documented isHeadless integration via addCustomPropsToUserProps.
+@interface RNFBMessagingModule : NSObject
 + (NSDictionary *_Nonnull)addCustomPropsToUserProps:(NSDictionary *_Nullable)userProps
                                   withLaunchOptions:(NSDictionary *_Nullable)launchOptions;
 @property BOOL isDeliveryMetricsExportToBigQueryEnabled;

package/ios/RNFBMessaging/RNFBMessagingModule.mm

@@ -0,0 +1,500 @@
+/**
+ * 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 <Firebase/Firebase.h>
+#import <RNFBApp/RNFBSharedUtils.h>
+#import <React/RCTConvert.h>
+#import <React/RCTUtils.h>
+
+#import "RNFBMessaging+AppDelegate.h"
+#import "RNFBMessaging+NSNotificationCenter.h"
+#import "RNFBMessaging+UNUserNotificationCenter.h"
+#import "RNFBMessagingModule.h"
+#import "RNFBMessagingSerializer.h"
+#import "RNFBMessagingTurboModules.h"
+
+@interface RNFBMessagingModule () <NativeRNFBTurboMessagingSpec>
+@end
+
+@implementation RNFBMessagingModule
+#pragma mark -
+#pragma mark Module Setup
+
+RCT_EXPORT_MODULE(NativeRNFBTurboMessaging)
+
++ (BOOL)requiresMainQueueSetup {
+  return NO;
+}
+
+- (id)init {
+  self = [super init];
+  return self;
+}
+
++ (NSDictionary *)addCustomPropsToUserProps:(NSDictionary *_Nullable)userProps
+                          withLaunchOptions:(NSDictionary *_Nullable)launchOptions {
+  NSMutableDictionary *appProperties =
+      userProps != nil ? [userProps mutableCopy] : [NSMutableDictionary dictionary];
+  appProperties[@"isHeadless"] = @([RCTConvert BOOL:@(NO)]);
+
+  if (launchOptions[UIApplicationLaunchOptionsRemoteNotificationKey]) {
+    if ([UIApplication sharedApplication].applicationState == UIApplicationStateBackground) {
+      appProperties[@"isHeadless"] = @([RCTConvert BOOL:@(YES)]);
+    }
+  }
+
+  return [NSDictionary dictionaryWithDictionary:appProperties];
+}
+
+- (NSDictionary *)messagingConstantsDictionary {
+  NSMutableDictionary *constants = [NSMutableDictionary new];
+  constants[@"isAutoInitEnabled"] =
+      @([RCTConvert BOOL:@([FIRMessaging messaging].autoInitEnabled)]);
+#if TARGET_IPHONE_SIMULATOR
+  constants[@"isRegisteredForRemoteNotifications"] = @NO;
+#else
+  constants[@"isRegisteredForRemoteNotifications"] = @(
+      [RCTConvert BOOL:@([[UIApplication sharedApplication] isRegisteredForRemoteNotifications])]);
+#endif
+  constants[@"isDeliveryMetricsExportToBigQueryEnabled"] =
+      @([RCTConvert BOOL:@(_isDeliveryMetricsExportToBigQueryEnabled)]);
+  return constants;
+}
+
+- (facebook::react::ModuleConstants<JS::NativeRNFBTurboMessaging::Constants::Builder>)
+    constantsToExport {
+  return [_RCTTypedModuleConstants newWithUnsafeDictionary:[self messagingConstantsDictionary]];
+}
+
+- (facebook::react::ModuleConstants<JS::NativeRNFBTurboMessaging::Constants::Builder>)getConstants {
+  return [self constantsToExport];
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params {
+  return std::make_shared<facebook::react::NativeRNFBTurboMessagingSpecJSI>(params);
+}
+
+#pragma mark -
+#pragma mark Firebase Messaging Methods
+
+- (void)getInitialNotification:(RCTPromiseResolveBlock)resolve
+                        reject:(RCTPromiseRejectBlock)reject {
+  resolve([[RNFBMessagingUNUserNotificationCenter sharedInstance] getInitialNotification]);
+}
+
+- (void)getDidOpenSettingsForNotification:(RCTPromiseResolveBlock)resolve
+                                   reject:(RCTPromiseRejectBlock)reject {
+  resolve(
+      [[RNFBMessagingUNUserNotificationCenter sharedInstance] getDidOpenSettingsForNotification]);
+}
+
+- (void)setAutoInitEnabled:(BOOL)enabled
+                   resolve:(RCTPromiseResolveBlock)resolve
+                    reject:(RCTPromiseRejectBlock)reject {
+  @try {
+    [FIRMessaging messaging].autoInitEnabled = enabled;
+  } @catch (NSException *exception) {
+    return [RNFBSharedUtils rejectPromiseWithExceptionDict:reject exception:exception];
+  }
+
+  return resolve([NSNull null]);
+}
+
+- (void)signalBackgroundMessageHandlerSet {
+  DLog(@"signalBackgroundMessageHandlerSet called");
+  @try {
+    [[RNFBMessagingAppDelegate sharedInstance] signalBackgroundMessageHandlerSet];
+  } @catch (NSException *exception) {
+    ELog(@"signalBackgroundMessageHandlerSet failed");
+  }
+}
+
+- (void)getToken:(NSString *)appName
+        senderId:(NSString *)senderId
+         resolve:(RCTPromiseResolveBlock)resolve
+          reject:(RCTPromiseRejectBlock)reject {
+  if ([UIApplication sharedApplication].isRegisteredForRemoteNotifications == NO) {
+    [RNFBSharedUtils
+        rejectPromiseWithUserInfo:reject
+                         userInfo:(NSMutableDictionary *)@{
+                           @"code" : @"unregistered",
+                           @"message" : @"You must be registered for remote "
+                                        @"messages before calling "
+                                        @"getToken, see "
+                                        @"registerDeviceForRemoteMessages(getMessaging()).",
+                         }];
+    return;
+  }
+
+  NSData *apnsToken = [FIRMessaging messaging].APNSToken;
+  if (apnsToken == nil) {
+    DLog(@"RNFBMessaging getToken - no APNS token is available. Firebase "
+         @"requires an APNS token to "
+         @"vend an FCM token in firebase-ios-sdk 10.4.0 and higher. See "
+         @"documentation on "
+         @"setAPNSToken and getAPNSToken.")
+  }
+
+  [[FIRMessaging messaging]
+      retrieveFCMTokenForSenderID:senderId
+                       completion:^(NSString *_Nullable token, NSError *_Nullable error) {
+                         if (error) {
+                           [RNFBSharedUtils rejectPromiseWithNSError:reject error:error];
+                         } else {
+                           resolve(token);
+                         }
+                       }];
+}
+
+- (void)deleteToken:(NSString *)appName
+           senderId:(NSString *)senderId
+            resolve:(RCTPromiseResolveBlock)resolve
+             reject:(RCTPromiseRejectBlock)reject {
+  [[FIRMessaging messaging] deleteFCMTokenForSenderID:senderId
+                                           completion:^(NSError *_Nullable error) {
+                                             if (error) {
+                                               [RNFBSharedUtils rejectPromiseWithNSError:reject
+                                                                                   error:error];
+                                             } else {
+                                               resolve([NSNull null]);
+                                             }
+                                           }];
+}
+
+- (void)getAPNSToken:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {
+  NSData *apnsToken = [FIRMessaging messaging].APNSToken;
+  if (apnsToken) {
+    resolve([RNFBMessagingSerializer APNSTokenFromNSData:apnsToken]);
+  } else {
+#if TARGET_IPHONE_SIMULATOR
+#if !TARGET_CPU_ARM64
+    DLog(@"RNFBMessaging getAPNSToken - Simulator without APNS support "
+         @"detected, with no token "
+         @"set. Use setAPNSToken with an arbitrary string if needed for "
+         @"testing.") resolve([NSNull null]);
+    return;
+#endif
+    DLog(@"RNFBMessaging getAPNSToken - ARM64 Simulator detected, but no APNS "
+         @"token available. "
+         @"APNS token may be possible. macOS13+ / iOS16+ / M1 mac required for "
+         @"assumption to be "
+         @"valid. "
+         @"Use setAPNSToken in testing if needed.");
+#endif
+    if ([UIApplication sharedApplication].isRegisteredForRemoteNotifications == NO) {
+      [RNFBSharedUtils
+          rejectPromiseWithUserInfo:reject
+                           userInfo:(NSMutableDictionary *)@{
+                             @"code" : @"unregistered",
+                             @"message" : @"You must be registered for remote "
+                                          @"messages before "
+                                          @"calling getAPNSToken, see "
+                                          @"registerDeviceForRemoteMessages(getMessaging()).",
+                           }];
+      return;
+    }
+    resolve([NSNull null]);
+  }
+}
+
+- (void)setAPNSToken:(NSString *)token
+                type:(NSString *)type
+             resolve:(RCTPromiseResolveBlock)resolve
+              reject:(RCTPromiseRejectBlock)reject {
+  FIRMessagingAPNSTokenType tokenType = FIRMessagingAPNSTokenTypeUnknown;
+  if (type != nil && [@"prod" isEqualToString:type]) {
+    tokenType = FIRMessagingAPNSTokenTypeProd;
+  } else if (type != nil && [@"sandbox" isEqualToString:type]) {
+    tokenType = FIRMessagingAPNSTokenTypeSandbox;
+  }
+
+  [[FIRMessaging messaging] setAPNSToken:[RNFBMessagingSerializer APNSTokenDataFromNSString:token]
+                                    type:tokenType];
+  resolve([NSNull null]);
+}
+
+- (void)getIsHeadless:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {
+  RNFBMessagingNSNotificationCenter *notifCenter =
+      [RNFBMessagingNSNotificationCenter sharedInstance];
+
+  return resolve(@([RCTConvert BOOL:@(notifCenter.isHeadless)]));
+}
+
+- (void)completeNotificationProcessing {
+  dispatch_async(dispatch_get_main_queue(), ^{
+    RNFBMessagingAppDelegate *appDelegate = [RNFBMessagingAppDelegate sharedInstance];
+    if (appDelegate.completionHandler) {
+      appDelegate.completionHandler(UIBackgroundFetchResultNewData);
+      appDelegate.completionHandler = nil;
+    }
+    if (appDelegate.backgroundTaskId != UIBackgroundTaskInvalid) {
+      [[UIApplication sharedApplication] endBackgroundTask:appDelegate.backgroundTaskId];
+      appDelegate.backgroundTaskId = UIBackgroundTaskInvalid;
+    }
+  });
+}
+
+- (void)requestPermission:(JS::NativeRNFBTurboMessaging::IOSPermissions &)permissions
+                  resolve:(RCTPromiseResolveBlock)resolve
+                   reject:(RCTPromiseRejectBlock)reject {
+  if (RCTRunningInAppExtension()) {
+    [RNFBSharedUtils rejectPromiseWithUserInfo:reject
+                                      userInfo:[@{
+                                        @"code" : @"unavailable-in-extension",
+                                        @"message" : @"requestPermission can not be called "
+                                                     @"in App Extensions"
+                                      } mutableCopy]];
+    return;
+  }
+
+  UNAuthorizationOptions options = UNAuthorizationOptionNone;
+
+  if (permissions.alert().has_value() && permissions.alert().value()) {
+    options |= UNAuthorizationOptionAlert;
+  }
+
+  if (permissions.announcement().has_value() && permissions.announcement().value()) {
+    options |= UNAuthorizationOptionAnnouncement;
+  }
+
+  if (permissions.badge().has_value() && permissions.badge().value()) {
+    options |= UNAuthorizationOptionBadge;
+  }
+
+  if (permissions.sound().has_value() && permissions.sound().value()) {
+    options |= UNAuthorizationOptionSound;
+  }
+
+  if (permissions.criticalAlert().has_value() && permissions.criticalAlert().value()) {
+    options |= UNAuthorizationOptionCriticalAlert;
+  }
+
+  if (permissions.provisional().has_value() && permissions.provisional().value()) {
+    options |= UNAuthorizationOptionProvisional;
+  }
+
+  if (permissions.carPlay().has_value() && permissions.carPlay().value()) {
+    options |= UNAuthorizationOptionCarPlay;
+  }
+
+  if (permissions.providesAppNotificationSettings().has_value() &&
+      permissions.providesAppNotificationSettings().value()) {
+    options |= UNAuthorizationOptionProvidesAppNotificationSettings;
+  }
+
+  UNUserNotificationCenter *center = [UNUserNotificationCenter currentNotificationCenter];
+  [center requestAuthorizationWithOptions:options
+                        completionHandler:^(BOOL granted, NSError *_Nullable error) {
+                          if (error) {
+                            [RNFBSharedUtils rejectPromiseWithNSError:reject error:error];
+                          } else {
+#if TARGET_IPHONE_SIMULATOR && TARGET_CPU_ARM64
+                            // Intentional: do not call UIKit registerForRemoteNotifications on
+                            // ARM64 Simulator — it can wedge main indefinitely. See
+                            // registerForRemoteNotifications:reject: for the same policy.
+                            DLog(@"RNFBMessaging requestPermission - ARM64 Simulator detected, "
+                                 @"skipping UIKit registerForRemoteNotifications.");
+#else
+          dispatch_async(dispatch_get_main_queue(), ^{
+            [[UIApplication sharedApplication] registerForRemoteNotifications];
+          });
+#endif
+                            [self hasPermission:resolve reject:reject];
+                          }
+                        }];
+}
+
+- (void)registerForRemoteNotifications:(RCTPromiseResolveBlock)resolve
+                                reject:(RCTPromiseRejectBlock)reject {
+  // Schedule the timeout BEFORE any UIKit work. UIKit getters / registerForRemoteNotifications
+  // must run on main; if main is already stalled (ARM64 Simulator APNs), scheduling the timer
+  // first guarantees the JS promise cannot hang forever. Reject from a global queue so the
+  // timer itself does not depend on main. Overlapping calls supersede the prior promise
+  // (registration-superseded) and bump a generation so stale timeouts cannot settle a newer call.
+  NSUInteger generation =
+      [[RNFBMessagingAppDelegate sharedInstance] beginRegisterPromiseResolve:resolve
+                                                            andPromiseReject:reject];
+
+  dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(10.0 * NSEC_PER_SEC)),
+                 dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0), ^{
+                   RCTPromiseResolveBlock pendingResolve = nil;
+                   RCTPromiseRejectBlock pendingReject = nil;
+                   if (![[RNFBMessagingAppDelegate sharedInstance]
+                           claimPendingRegisterPromiseGeneration:generation
+                                                         resolve:&pendingResolve
+                                                          reject:&pendingReject]) {
+                     DLog(@"RNFBMessaging registerForRemoteNotifications timeout: already settled "
+                          @"(generation %lu).",
+                          (unsigned long)generation);
+                     return;
+                   }
+                   DLog(@"RNFBMessaging registerForRemoteNotifications timed out; rejecting.");
+                   if (pendingReject != nil) {
+                     [RNFBSharedUtils
+                         rejectPromiseWithUserInfo:pendingReject
+                                          userInfo:[@{
+                                            @"code" : @"registration-timeout",
+                                            @"message" : @"registerDeviceForRemoteMessages "
+                                                         @"timed out waiting for APNs "
+                                                         @"device registration. The system "
+                                                         @"did not respond — possibly "
+                                                         @"missing notification permission, "
+                                                         @"or the main thread is blocked "
+                                                         @"(common on ARM64 Simulator)."
+                                          } mutableCopy]];
+                   }
+                 });
+
+  dispatch_async(dispatch_get_main_queue(), ^{
+#if TARGET_IPHONE_SIMULATOR
+#if !TARGET_CPU_ARM64
+    // Intel simulator: APNs unsupported — settle immediately after poking UIKit.
+    RCTPromiseResolveBlock pendingResolve = nil;
+    RCTPromiseRejectBlock pendingReject = nil;
+    if ([[RNFBMessagingAppDelegate sharedInstance]
+            claimPendingRegisterPromiseGeneration:generation
+                                          resolve:&pendingResolve
+                                           reject:&pendingReject] &&
+        pendingResolve != nil) {
+      [[UIApplication sharedApplication] registerForRemoteNotifications];
+      pendingResolve(@([RCTConvert BOOL:@(YES)]));
+    }
+    return;
+#else
+    // ARM64 Simulator (intentional product policy): do NOT call UIKit
+    // registerForRemoteNotifications. Calling it can wedge the main thread so
+    // the JS bridge cannot observe the global-queue registration-timeout reject
+    // even though the timer fires. Leave the promise pending; the 10s
+    // global-queue timeout rejects with registration-timeout. Use a physical
+    // device for real APNs tokens. Documented in docs/messaging and OKF.
+    DLog(@"RNFBMessaging registerForRemoteNotifications ARM64 Simulator "
+         @"detected — skipping UIKit registerForRemoteNotifications; "
+         @"global-queue timeout will reject with registration-timeout.");
+    return;
+#endif
+#endif
+    if ([UIApplication sharedApplication].isRegisteredForRemoteNotifications == YES) {
+      DLog(@"RNFBMessaging registerForRemoteNotifications - already registered.");
+      RCTPromiseResolveBlock pendingResolve = nil;
+      RCTPromiseRejectBlock pendingReject = nil;
+      if ([[RNFBMessagingAppDelegate sharedInstance]
+              claimPendingRegisterPromiseGeneration:generation
+                                            resolve:&pendingResolve
+                                             reject:&pendingReject] &&
+          pendingResolve != nil) {
+        pendingResolve(@([RCTConvert BOOL:@(YES)]));
+      }
+      return;
+    }
+
+    [[UIApplication sharedApplication] registerForRemoteNotifications];
+  });
+}
+
+- (void)unregisterForRemoteNotifications:(RCTPromiseResolveBlock)resolve
+                                  reject:(RCTPromiseRejectBlock)reject {
+  [[UIApplication sharedApplication] unregisterForRemoteNotifications];
+  resolve(nil);
+}
+
+- (void)hasPermission:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {
+  [[UNUserNotificationCenter currentNotificationCenter]
+      getNotificationSettingsWithCompletionHandler:^(UNNotificationSettings *_Nonnull settings) {
+        NSNumber *authorizedStatus = @-1;
+        if (settings.authorizationStatus == UNAuthorizationStatusNotDetermined) {
+          authorizedStatus = @-1;
+        } else if (settings.authorizationStatus == UNAuthorizationStatusDenied) {
+          authorizedStatus = @0;
+        } else if (settings.authorizationStatus == UNAuthorizationStatusAuthorized) {
+          authorizedStatus = @1;
+        } else if (settings.authorizationStatus == UNAuthorizationStatusProvisional) {
+          authorizedStatus = @2;
+        }
+
+        if (@available(iOS 14.0, macCatalyst 14.0, *)) {
+          if (settings.authorizationStatus == UNAuthorizationStatusEphemeral) {
+            authorizedStatus = @3;
+          }
+        }
+
+        resolve(authorizedStatus);
+      }];
+}
+
+- (void)sendMessage:(NSDictionary *)remoteMessageMap
+            resolve:(RCTPromiseResolveBlock)resolve
+             reject:(RCTPromiseRejectBlock)reject {
+  [RNFBSharedUtils rejectPromiseWithUserInfo:reject
+                                    userInfo:[@{
+                                      @"code" : @"unimplemented",
+                                      @"message" : @"sendMessage is only supported on "
+                                                   @"Android devices."
+                                    } mutableCopy]];
+}
+
+- (void)subscribeToTopic:(NSString *)topic
+                 resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject {
+  [[FIRMessaging messaging] subscribeToTopic:topic
+                                  completion:^(NSError *error) {
+                                    if (error) {
+                                      [RNFBSharedUtils rejectPromiseWithNSError:reject error:error];
+                                    } else {
+                                      resolve(nil);
+                                    }
+                                  }];
+}
+
+- (void)unsubscribeFromTopic:(NSString *)topic
+                     resolve:(RCTPromiseResolveBlock)resolve
+                      reject:(RCTPromiseRejectBlock)reject {
+  [[FIRMessaging messaging] unsubscribeFromTopic:topic
+                                      completion:^(NSError *error) {
+                                        if (error) {
+                                          [RNFBSharedUtils rejectPromiseWithNSError:reject
+                                                                              error:error];
+                                        } else {
+                                          resolve(nil);
+                                        }
+                                      }];
+}
+
+- (void)setDeliveryMetricsExportToBigQuery:(BOOL)enabled
+                                   resolve:(RCTPromiseResolveBlock)resolve
+                                    reject:(RCTPromiseRejectBlock)reject {
+  @try {
+    _isDeliveryMetricsExportToBigQueryEnabled = enabled;
+  } @catch (NSException *exception) {
+    return [RNFBSharedUtils rejectPromiseWithExceptionDict:reject exception:exception];
+  }
+
+  return resolve([NSNull null]);
+}
+
+- (void)setNotificationDelegationEnabled:(BOOL)enabled
+                                 resolve:(RCTPromiseResolveBlock)resolve
+                                  reject:(RCTPromiseRejectBlock)reject {
+  resolve([NSNull null]);
+}
+
+- (void)isNotificationDelegationEnabled:(RCTPromiseResolveBlock)resolve
+                                 reject:(RCTPromiseRejectBlock)reject {
+  resolve(@NO);
+}
+
+@end