@react-native-firebase/app 26.3.3 → 27.0.0

package/ios/RNFBApp/RNFBNullSentinelDecoding.swift

@@ -0,0 +1,135 @@
+/**
+ * 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 Foundation
+
+/**
+ * Decodes `{ "__rnfbNull": true }` sentinel dictionaries produced by the JS bridge
+ * into `NSNull`, walking nested arrays/dictionaries iteratively.
+ *
+ * The flag must be an `NSNumber` (JS sends boolean `true`). String flags are not
+ * treated as sentinels.
+ */
+@objc(RNFBNullSentinelDecoder)
+public final class RNFBNullSentinelDecoder: NSObject {
+  private static let sentinelKey = "__rnfbNull"
+
+  @objc(decodeNullSentinels:)
+  public static func decodeNullSentinels(_ value: Any?) -> Any? {
+    decode(value)
+  }
+
+  @objc(decode:)
+  public static func decode(_ value: Any?) -> Any? {
+    guard let value else {
+      return nil
+    }
+
+    // Non-container values are returned as-is (identity preserved).
+    guard value is NSDictionary || value is NSArray else {
+      return value
+    }
+
+    if let dict = value as? NSDictionary, isNullSentinel(dict) {
+      return NSNull()
+    }
+
+    let rootMutable: AnyObject
+    if let dict = value as? NSDictionary {
+      rootMutable = NSMutableDictionary(capacity: dict.count)
+    } else {
+      let array = value as! NSArray
+      rootMutable = NSMutableArray(capacity: array.count)
+    }
+
+    // Stack frames: (original container, mutable container)
+    var stack: [(original: AnyObject, mutable: AnyObject)] = [
+      (value as AnyObject, rootMutable),
+    ]
+
+    while let frame = stack.popLast() {
+      if let origDict = frame.original as? NSDictionary {
+        let mutableDict = frame.mutable as! NSMutableDictionary
+        for key in origDict.allKeys {
+          let child = origDict[key]
+          processChild(
+            child,
+            parentMutable: mutableDict,
+            key: (key as! any NSCopying),
+            isParentDict: true,
+            stack: &stack
+          )
+        }
+      } else if let origArray = frame.original as? NSArray {
+        let mutableArray = frame.mutable as! NSMutableArray
+        for child in origArray {
+          processChild(
+            child,
+            parentMutable: mutableArray,
+            key: nil,
+            isParentDict: false,
+            stack: &stack
+          )
+        }
+      }
+    }
+
+    return rootMutable
+  }
+
+  /// Flag must be an NSNumber whose `boolValue` is true. Strings and other types are not sentinels.
+  private static func isNullSentinel(_ dict: NSDictionary) -> Bool {
+    guard dict.count == 1, let flag = dict[sentinelKey] as? NSNumber else {
+      return false
+    }
+    return flag.boolValue
+  }
+
+  private static func processChild(
+    _ child: Any?,
+    parentMutable: AnyObject,
+    key: NSCopying?,
+    isParentDict: Bool,
+    stack: inout [(original: AnyObject, mutable: AnyObject)]
+  ) {
+    let processedValue: AnyObject
+
+    if let childDict = child as? NSDictionary {
+      if isNullSentinel(childDict) {
+        processedValue = NSNull()
+      } else {
+        let childMut = NSMutableDictionary(capacity: childDict.count)
+        processedValue = childMut
+        stack.append((childDict, childMut))
+      }
+    } else if let childArray = child as? NSArray {
+      let childMut = NSMutableArray(capacity: childArray.count)
+      processedValue = childMut
+      stack.append((childArray, childMut))
+    } else {
+      // Preserve primitives; nil → NSNull (enumeration never yields nil).
+      processedValue = (child as AnyObject?) ?? NSNull()
+    }
+
+    if isParentDict {
+      let mutDict = parentMutable as! NSMutableDictionary
+      mutDict[key!] = processedValue
+    } else {
+      let mutArray = parentMutable as! NSMutableArray
+      mutArray.add(processedValue)
+    }
+  }
+}

package/ios/RNFBApp/RNFBNullSentinelInterceptor.h

@@ -32,15 +32,42 @@
  * This class uses method swizzling on RCTCxxConvert to intercept all TurboModule
  * data conversion methods (JS_*Module_Spec*Data:), decoding sentinels before the
  * data reaches the C++ bridging layer and ultimately your module methods.
+ *
+ * Swizzling is scheduled on the main queue from +load so codegen category methods
+ * on RCTCxxConvert are attached before the method list is copied.
  */
 @interface RNFBNullSentinelInterceptor : NSObject
 
 /**
- * Initializes the null sentinel interceptor.
- * This swizzles RCTCxxConvert (TurboModule converter) to automatically decode null sentinels.
+ * Schedules TurboModule converter swizzling on the main queue.
  * Called automatically when the class is loaded via +load.
  */
-+ (void)initialize;
++ (void)load;
+
+/**
+ * Production entry used by +load. Schedules swizzleRCTConvertMethods on the main
+ * queue behind a process-wide once-token.
+ */
++ (void)scheduleSwizzleOnMainQueue;
+
+/**
+ * Testable schedule path. When turboConvertClass is Nil, behaves like production
+ * (swizzleRCTConvertMethods). When non-Nil, swizzles that class instead so unit
+ * tests can observe deferral without RCTCxxConvert.
+ */
++ (void)scheduleSwizzleOnMainQueueWithOnceToken:(dispatch_once_t *)onceToken
+                              turboConvertClass:(Class)turboConvertClass;
+
+/**
+ * Looks up RCTCxxConvert and swizzles matching TurboModule conversion methods.
+ */
++ (void)swizzleRCTConvertMethods;
+
+/**
+ * Swizzles JS_NativeRNFBTurbo*_Spec* class methods on the given converter class
+ * so decodeNullSentinels runs before the original IMP.
+ */
++ (void)swizzleTurboModuleConversions:(Class)cxxConvertClass;
 
 @end
 

package/ios/RNFBApp/RNFBNullSentinelInterceptor.m

@@ -17,14 +17,38 @@
 
 #import "RNFBNullSentinelInterceptor.h"
 #import <objc/runtime.h>
-#import "RNFBSharedUtils.h"
+
+#if __has_include(<RNFBApp/RNFBApp-Swift.h>)
+#import <RNFBApp/RNFBApp-Swift.h>
+#elif __has_include("RNFBApp-Swift.h")
+#import "RNFBApp-Swift.h"
+#elif __has_include("RNFBHandleMapStorage-Swift.inc")
+#import "RNFBHandleMapStorage-Swift.inc"
+#else
+#error "RNFBApp Swift interface not found"
+#endif
 
 @implementation RNFBNullSentinelInterceptor
 
 + (void)load {
+  [self scheduleSwizzleOnMainQueue];
+}
+
++ (void)scheduleSwizzleOnMainQueue {
   static dispatch_once_t onceToken;
-  dispatch_once(&onceToken, ^{
-    [self swizzleRCTConvertMethods];
+  [self scheduleSwizzleOnMainQueueWithOnceToken:&onceToken turboConvertClass:Nil];
+}
+
++ (void)scheduleSwizzleOnMainQueueWithOnceToken:(dispatch_once_t *)onceToken
+                              turboConvertClass:(Class)turboConvertClass {
+  dispatch_async(dispatch_get_main_queue(), ^{
+    dispatch_once(onceToken, ^{
+      if (turboConvertClass) {
+        [self swizzleTurboModuleConversions:turboConvertClass];
+      } else {
+        [self swizzleRCTConvertMethods];
+      }
+    });
   });
 }
 
@@ -51,12 +75,11 @@
     if ([selectorName hasPrefix:@"JS_NativeRNFBTurbo"] && [selectorName containsString:@"_Spec"]) {
       // Create a swizzled version using IMP
       IMP originalIMP = method_getImplementation(method);
-      const char *typeEncoding = method_getTypeEncoding(method);
 
       // Replace with our wrapper that decodes nulls
       IMP newIMP = imp_implementationWithBlock(^id(id self, id json) {
         // Decode null sentinels before passing to original conversion
-        id decoded = [RNFBSharedUtils decodeNullSentinels:json];
+        id decoded = [RNFBNullSentinelDecoder decodeNullSentinels:json];
 
         // Call original implementation with decoded data
         typedef id (*OriginalFunc)(id, SEL, id);

package/ios/RNFBApp/RNFBPreferences.m

@@ -17,12 +17,20 @@
 
 #import "RNFBPreferences.h"
 
+#if __has_include(<RNFBApp/RNFBApp-Swift.h>)
+#import <RNFBApp/RNFBApp-Swift.h>
+#elif __has_include("RNFBApp-Swift.h")
+#import "RNFBApp-Swift.h"
+#elif __has_include("RNFBHandleMapStorage-Swift.inc")
+#import "RNFBHandleMapStorage-Swift.inc"
+#else
+#error "RNFBPreferencesStorage Swift interface not found"
+#endif
+
 @interface RNFBPreferences ()
-@property(nonatomic, strong) NSUserDefaults *userDefaults;
+@property(nonatomic, strong) RNFBPreferencesStorage *storage;
 @end
 
-static NSString *const RNFBDomainIdentifier = @"io.invertase.firebase";
-
 @implementation RNFBPreferences
 
 static RNFBPreferences *sharedInstance;
@@ -35,56 +43,50 @@ static RNFBPreferences *sharedInstance;
   self = [super init];
 
   if (self) {
-    _userDefaults = [[NSUserDefaults alloc] initWithSuiteName:RNFBDomainIdentifier];
+    _storage = [[RNFBPreferencesStorage alloc] init];
   }
 
   return self;
 }
 
 - (BOOL)contains:(NSString *)key {
-  return [_userDefaults objectForKey:key] != nil;
+  return [self.storage contains:key];
 }
 
 - (BOOL)getBooleanValue:(NSString *)key defaultValue:(BOOL)defaultValue {
-  if ([_userDefaults objectForKey:key] == nil) return defaultValue;
-  return [_userDefaults boolForKey:key];
+  return [self.storage getBooleanValue:key defaultValue:defaultValue];
 }
 
 - (void)setBooleanValue:(NSString *)key boolValue:(BOOL)boolValue {
-  [_userDefaults setBool:boolValue forKey:key];
-  [_userDefaults synchronize];
+  [self.storage setBooleanValue:key boolValue:boolValue];
 }
 
 - (void)setIntegerValue:(NSString *)key integerValue:(NSInteger)integerValue {
-  [_userDefaults setInteger:(NSInteger)integerValue forKey:key];
-  [_userDefaults synchronize];
+  [self.storage setIntegerValue:key integerValue:integerValue];
 }
 
 - (NSInteger)getIntegerValue:(NSString *)key defaultValue:(NSInteger)defaultValue {
-  if ([_userDefaults objectForKey:key] == nil) return defaultValue;
-  return [_userDefaults integerForKey:key];
+  return [self.storage getIntegerValue:key defaultValue:defaultValue];
 }
 
 - (NSString *)getStringValue:(NSString *)key defaultValue:(NSString *)defaultValue {
-  if ([_userDefaults objectForKey:key] == nil) return defaultValue;
-  return [_userDefaults stringForKey:key];
+  return [self.storage getStringValue:key defaultValue:defaultValue];
 }
 
 - (void)setStringValue:(NSString *)key stringValue:(NSString *)stringValue {
-  [_userDefaults setValue:stringValue forKey:key];
-  [_userDefaults synchronize];
+  [self.storage setStringValue:key stringValue:stringValue];
 }
 
 - (NSDictionary *)getAll {
-  return [_userDefaults dictionaryRepresentation];
+  return [self.storage getAll];
 }
 
 - (void)clearAll {
-  [_userDefaults removePersistentDomainForName:RNFBDomainIdentifier];
+  [self.storage clearAll];
 }
 
 - (void)remove:(NSString *)key {
-  [_userDefaults removeObjectForKey:key];
+  [self.storage remove:key];
 }
 
 + (RNFBPreferences *)shared {

package/ios/RNFBApp/RNFBPreferencesStorage.swift

@@ -0,0 +1,101 @@
+/**
+ * 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 Foundation
+
+private let RNFBPreferencesDomainIdentifier = "io.invertase.firebase"
+
+@objc(RNFBPreferencesStorage)
+public final class RNFBPreferencesStorage: NSObject {
+  private let userDefaults: UserDefaults
+  private let domainIdentifier: String
+
+  public override convenience init() {
+    self.init(
+      userDefaults: UserDefaults(suiteName: RNFBPreferencesDomainIdentifier)!,
+      domainIdentifier: RNFBPreferencesDomainIdentifier
+    )
+  }
+
+  @objc(initWithUserDefaults:domainIdentifier:)
+  public init(userDefaults: UserDefaults, domainIdentifier: String) {
+    self.userDefaults = userDefaults
+    self.domainIdentifier = domainIdentifier
+    super.init()
+  }
+
+  @objc(contains:)
+  public func contains(_ key: String) -> Bool {
+    userDefaults.object(forKey: key) != nil
+  }
+
+  @objc(getBooleanValue:defaultValue:)
+  public func getBooleanValue(_ key: String, defaultValue: Bool) -> Bool {
+    guard contains(key) else {
+      return defaultValue
+    }
+    return userDefaults.bool(forKey: key)
+  }
+
+  @objc(setBooleanValue:boolValue:)
+  public func setBooleanValue(_ key: String, boolValue: Bool) {
+    userDefaults.set(boolValue, forKey: key)
+    userDefaults.synchronize()
+  }
+
+  @objc(setIntegerValue:integerValue:)
+  public func setIntegerValue(_ key: String, integerValue: Int) {
+    userDefaults.set(integerValue, forKey: key)
+    userDefaults.synchronize()
+  }
+
+  @objc(getIntegerValue:defaultValue:)
+  public func getIntegerValue(_ key: String, defaultValue: Int) -> Int {
+    guard contains(key) else {
+      return defaultValue
+    }
+    return userDefaults.integer(forKey: key)
+  }
+
+  @objc(getStringValue:defaultValue:)
+  public func getStringValue(_ key: String, defaultValue: String) -> String? {
+    guard contains(key) else {
+      return defaultValue
+    }
+    return userDefaults.string(forKey: key)
+  }
+
+  @objc(setStringValue:stringValue:)
+  public func setStringValue(_ key: String, stringValue: String) {
+    userDefaults.set(stringValue, forKey: key)
+    userDefaults.synchronize()
+  }
+
+  @objc
+  public func getAll() -> [String: Any] {
+    userDefaults.dictionaryRepresentation()
+  }
+
+  @objc
+  public func clearAll() {
+    userDefaults.removePersistentDomain(forName: domainIdentifier)
+  }
+
+  @objc(remove:)
+  public func remove(_ key: String) {
+    userDefaults.removeObject(forKey: key)
+  }
+}

package/ios/RNFBApp/RNFBRCTEventEmitter.m

@@ -17,26 +17,24 @@
 
 #import "RNFBRCTEventEmitter.h"
 
+#import <React/RCTBridge.h>
+
+#if __has_include(<RNFBApp/RNFBApp-Swift.h>)
+#import <RNFBApp/RNFBApp-Swift.h>
+#elif __has_include("RNFBApp-Swift.h")
+#import "RNFBApp-Swift.h"
+#elif __has_include("RNFBHandleMapStorage-Swift.inc")
+#import "RNFBHandleMapStorage-Swift.inc"
+#else
+#error "RNFBRCTEventEmitterCore Swift interface not found"
+#endif
+
 @interface RNFBRCTEventEmitter ()
-@property(atomic, assign) BOOL jsReady;
-@property(atomic, assign) NSInteger jsListenerCount;
-@property(nonatomic, strong) NSMutableDictionary *jsListeners;
-@property(nonatomic, strong) NSMutableArray *queuedEvents;
-@property(readonly) BOOL isObserving;
+@property(nonatomic, strong) RNFBRCTEventEmitterCore *core;
 @end
 
-NSString *const RNFBRCTEventNameKey = @"name";
-NSString *const RNFBRCTEventBodyKey = @"body";
-
 @implementation RNFBRCTEventEmitter
 
-- (void)invalidate {
-  self.jsReady = FALSE;
-  self.queuedEvents = [NSMutableArray array];
-  self.jsListeners = [NSMutableDictionary dictionary];
-  self.jsListenerCount = 0;
-}
-
 + (instancetype)shared {
   static dispatch_once_t once;
   static RNFBRCTEventEmitter *sharedInstance;
@@ -50,102 +48,47 @@ NSString *const RNFBRCTEventBodyKey = @"body";
   self = [super init];
 
   if (self) {
-    self.jsReady = FALSE;
-    self.queuedEvents = [NSMutableArray array];
-    self.jsListeners = [NSMutableDictionary dictionary];
+    __weak typeof(self) weakSelf = self;
+    _core = [[RNFBRCTEventEmitterCore alloc]
+        initWithIsBridgePresent:^BOOL {
+          return weakSelf.bridge != nil;
+        }
+        emitHandler:^(NSString *eventName, id body) {
+          __strong typeof(weakSelf) strongSelf = weakSelf;
+          NSString *prefixedEventName = [@"rnfb_" stringByAppendingString:eventName];
+          [strongSelf.bridge
+              enqueueJSCall:@"RCTDeviceEventEmitter"
+                     method:@"emit"
+                       args:body ? @[ prefixedEventName, body ] : @[ prefixedEventName ]
+                 completion:NULL];
+        }];
   }
 
   return self;
 }
 
+- (void)invalidate {
+  [self.core invalidate];
+}
+
 - (void)notifyJsReady:(BOOL)jsReady {
-  @synchronized(self.jsListeners) {
-    self.jsReady = jsReady;
-    if (jsReady) {
-      for (id event in [self.queuedEvents copy]) {
-        [self sendEventWithName:event[RNFBRCTEventNameKey] body:event[RNFBRCTEventBodyKey]];
-        @synchronized(self.queuedEvents) {
-          [self.queuedEvents removeObject:event];
-        }
-      }
-    }
-  }
+  [self.core notifyJsReady:jsReady];
 }
 
 - (void)sendEventWithName:(NSString *)eventName body:(id)body {
-  @synchronized(self.jsListeners) {
-    if (self.bridge && self.isObserving && self.jsListeners[eventName] != nil) {
-      NSString *prefixedEventName = [@"rnfb_" stringByAppendingString:eventName];
-      [self.bridge enqueueJSCall:@"RCTDeviceEventEmitter"
-                          method:@"emit"
-                            args:body ? @[ prefixedEventName, body ] : @[ prefixedEventName ]
-                      completion:NULL];
-    } else {
-      @synchronized(self.queuedEvents) {
-        [self.queuedEvents
-            addObject:@{RNFBRCTEventNameKey : eventName, RNFBRCTEventBodyKey : body}];
-      }
-    }
-  }
+  [self.core sendEventWithName:eventName body:body];
 }
 
 - (void)addListener:(NSString *)eventName {
-  @synchronized(self.jsListeners) {
-    self.jsListenerCount++;
-
-    if (self.jsListeners[eventName] == nil) {
-      self.jsListeners[eventName] = @([@1 integerValue]);
-    } else {
-      self.jsListeners[eventName] =
-          @([self.jsListeners[eventName] integerValue] + [@1 integerValue]);
-    }
-
-    for (id event in [self.queuedEvents copy]) {
-      if ([event[RNFBRCTEventNameKey] isEqualToString:eventName]) {
-        [self sendEventWithName:event[RNFBRCTEventNameKey] body:event[RNFBRCTEventBodyKey]];
-        @synchronized(self.queuedEvents) {
-          [self.queuedEvents removeObject:event];
-        }
-      }
-    }
-  }
+  [self.core addListener:eventName];
 }
 
 - (void)removeListeners:(NSString *)eventName all:(BOOL)all {
-  @synchronized(self.jsListeners) {
-    if (self.jsListeners[eventName] != nil) {
-      NSInteger listenersForEvent = [self.jsListeners[eventName] integerValue];
-
-      if (listenersForEvent <= 1 || all) {
-        @synchronized(self.jsListeners) {
-          [self.jsListeners removeObjectForKey:eventName];
-        }
-      } else {
-        @synchronized(self.jsListeners) {
-          self.jsListeners[eventName] =
-              @([self.jsListeners[eventName] integerValue] - [@1 integerValue]);
-        }
-      }
-
-      if (all) {
-        self.jsListenerCount = self.jsListenerCount - listenersForEvent;
-      } else {
-        self.jsListenerCount = self.jsListenerCount - [@1 integerValue];
-      }
-    }
-  }
+  [self.core removeListeners:eventName all:all];
 }
 
 - (NSDictionary *)getListenersDictionary {
-  NSMutableDictionary *listenersDictionary = [NSMutableDictionary new];
-  listenersDictionary[@"listeners"] = @(self.jsListenerCount);
-  listenersDictionary[@"queued"] = @([self.queuedEvents count]);
-  listenersDictionary[@"events"] = [self.jsListeners copy];
-  return listenersDictionary;
-}
-
-- (BOOL)isObserving {
-  return self.jsReady && self.jsListenerCount > 0;
+  return [self.core getListenersDictionary];
 }
 
 @end