@react-native-firebase/app 26.3.3 → 27.0.0

package/ios/RNFBApp/RNFBHandleMap.h

@@ -0,0 +1,73 @@
+/**
+ * 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/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+FOUNDATION_EXPORT NSErrorDomain const RNFBHandleMapErrorDomain;
+
+typedef NS_ERROR_ENUM(RNFBHandleMapErrorDomain, RNFBHandleMapErrorCode){
+    RNFBHandleMapErrorCollision = 1,
+};
+
+/**
+ * Thread-safe id → handle registry. The lock only moves pointers; this class never invokes methods
+ * on stored values (no SDK cancel/remove). Callers `take` or `takeAll`, then act on the returned
+ * object(s) outside the lock. Keys are typically NSNumber or NSString.
+ *
+ * `put` is unique: an occupied id fails with `RNFBHandleMapErrorCollision`. There is no upsert.
+ * Use `putIfAbsent` (first wins), `putIfAbsentOrSame` (first wins or same instance), or
+ * `putReplacing` (last wins) for atomic upsert.
+ *
+ * Do not lock on a `RNFBHandleMap` instance. This type uses a private lock object; callers that
+ * synchronize on the map can deadlock. Never `@synchronized(handleMap)` around these methods.
+ */
+@interface RNFBHandleMap : NSObject
+
+/// Registers `value` under `key`. Returns NO and sets `error` if `key` is already occupied.
+- (BOOL)put:(id)key value:(id)value error:(NSError *_Nullable *_Nullable)error;
+
+/// Stores `value` under `key` only when the key is free (first wins). Returns NO if occupied.
+- (BOOL)putIfAbsent:(id)key value:(id)value;
+
+/// Under one lock: stores when free, or YES when existing is the same instance (`==`). NO if
+/// occupied by a different value.
+- (BOOL)putIfAbsentOrSame:(id)key value:(id)value;
+
+/// Atomically replaces the mapping for `key` (last wins). Returns the previous value, or nil.
+- (nullable id)putReplacing:(id)key value:(id)value;
+
+/// Peeks at the handle for `key` without removing it (for emit while still registered).
+- (nullable id)get:(id)key;
+
+/// Removes and returns the handle for `key`, or nil if absent.
+- (nullable id)take:(id)key;
+
+/// When `key` is mapped and `condition` returns YES for the handle, removes and returns it;
+/// otherwise returns nil and leaves the map unchanged. Lookup, condition, and removal run under one
+/// lock — use for check-and-take that must not race with concurrent `put` / `take` on the same key.
+/// Keep `condition` lightweight (no SDK cancel/remove).
+- (nullable id)takeIf:(id)key when:(BOOL (^)(id value))condition;
+
+/// Snapshot of current values, then clear. Cancel/remove each returned object after this method
+/// returns, not under this map's lock.
+- (NSArray *)takeAll;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/RNFBApp/RNFBHandleMap.m

@@ -0,0 +1,87 @@
+/**
+ * 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 "RNFBHandleMap.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 "RNFBHandleMapStorage Swift interface not found"
+#endif
+
+NSErrorDomain const RNFBHandleMapErrorDomain = @"io.invertase.firebase.RNFBHandleMap";
+
+@interface RNFBHandleMap ()
+@property(nonatomic, strong) RNFBHandleMapStorage *storage;
+@end
+
+@implementation RNFBHandleMap
+
+- (instancetype)init {
+  self = [super init];
+  if (self) {
+    _storage = [[RNFBHandleMapStorage alloc] init];
+  }
+  return self;
+}
+
+- (BOOL)put:(id)key value:(id)value error:(NSError **)error {
+  if (![self.storage putIfAbsent:key value:value]) {
+    if (error != nil) {
+      NSString *message = [NSString stringWithFormat:@"Handle id already registered: %@", key];
+      *error = [NSError errorWithDomain:RNFBHandleMapErrorDomain
+                                   code:RNFBHandleMapErrorCollision
+                               userInfo:@{NSLocalizedDescriptionKey : message}];
+    }
+    return NO;
+  }
+  return YES;
+}
+
+- (BOOL)putIfAbsent:(id)key value:(id)value {
+  return [self.storage putIfAbsent:key value:value];
+}
+
+- (BOOL)putIfAbsentOrSame:(id)key value:(id)value {
+  return [self.storage putIfAbsentOrSame:key value:value];
+}
+
+- (id)putReplacing:(id)key value:(id)value {
+  return [self.storage putReplacing:key value:value];
+}
+
+- (id)get:(id)key {
+  return [self.storage get:key];
+}
+
+- (id)take:(id)key {
+  return [self.storage take:key];
+}
+
+- (id)takeIf:(id)key when:(BOOL (^)(id))condition {
+  return [self.storage takeIf:key when:condition];
+}
+
+- (NSArray *)takeAll {
+  return [self.storage takeAll];
+}
+
+@end

package/ios/RNFBApp/RNFBHandleMapStorage.swift

@@ -0,0 +1,90 @@
+/**
+ * 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
+
+@objc(RNFBHandleMapStorage)
+public final class RNFBHandleMapStorage: NSObject {
+  private let map = NSMutableDictionary()
+  private let lock = NSRecursiveLock()
+
+  @objc(putIfAbsent:value:)
+  public func putIfAbsent(_ key: AnyObject, value: AnyObject) -> Bool {
+    lock.withLock {
+      guard map.object(forKey: key) == nil else {
+        return false
+      }
+      map[key] = value
+      return true
+    }
+  }
+
+  @objc(putIfAbsentOrSame:value:)
+  public func putIfAbsentOrSame(_ key: AnyObject, value: AnyObject) -> Bool {
+    lock.withLock {
+      guard let existing = map.object(forKey: key) as AnyObject? else {
+        map[key] = value
+        return true
+      }
+      return existing === value
+    }
+  }
+
+  @objc(putReplacing:value:)
+  public func putReplacing(_ key: AnyObject, value: AnyObject) -> AnyObject? {
+    lock.withLock {
+      let previous = map.object(forKey: key) as AnyObject?
+      map[key] = value
+      return previous
+    }
+  }
+
+  @objc(get:)
+  public func get(_ key: AnyObject) -> AnyObject? {
+    lock.withLock {
+      map.object(forKey: key) as AnyObject?
+    }
+  }
+
+  @objc(take:)
+  public func take(_ key: AnyObject) -> AnyObject? {
+    lock.withLock {
+      let value = map.object(forKey: key) as AnyObject?
+      map.removeObject(forKey: key)
+      return value
+    }
+  }
+
+  @objc(takeIf:when:)
+  public func takeIf(_ key: AnyObject, when condition: (AnyObject) -> Bool) -> AnyObject? {
+    lock.withLock {
+      guard let value = map.object(forKey: key) as AnyObject?, condition(value) else {
+        return nil
+      }
+      map.removeObject(forKey: key)
+      return value
+    }
+  }
+
+  @objc
+  public func takeAll() -> [AnyObject] {
+    lock.withLock {
+      let values = map.allValues as [AnyObject]
+      map.removeAllObjects()
+      return values
+    }
+  }
+}

package/ios/RNFBApp/RNFBInitializeAppArguments.swift

@@ -0,0 +1,82 @@
+/**
+ * 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
+
+/**
+ * Foundation-only normalisation of the `options` and `appConfig` dictionaries passed to
+ * `initializeApp`. Decodes `{__rnfbNull: true}` sentinels and drops optional keys whose
+ * value is `NSNull` (except `automaticDataCollectionEnabled`, where null means false).
+ */
+@objc(RNFBInitializeAppArguments)
+public final class RNFBInitializeAppArguments: NSObject {
+  @objc(normalizedOptions:)
+  public static func normalizedOptions(_ options: NSDictionary?) -> NSDictionary? {
+    decodedDictionary(
+      options,
+      optionalKeys: [
+        "databaseURL",
+        "storageBucket",
+        "iosBundleId",
+        "iosClientId",
+        "appGroupId",
+        "authDomain",
+      ],
+      nullReplacements: [:]
+    )
+  }
+
+  @objc(normalizedAppConfig:)
+  public static func normalizedAppConfig(_ appConfig: NSDictionary?) -> NSDictionary? {
+    decodedDictionary(
+      appConfig,
+      optionalKeys: ["name"],
+      nullReplacements: ["automaticDataCollectionEnabled": NSNumber(value: false)]
+    )
+  }
+
+  @objc(automaticDataCollectionEnabledFromAppConfig:)
+  public static func automaticDataCollectionEnabled(fromAppConfig appConfig: NSDictionary?) -> NSNumber? {
+    guard let value = appConfig?["automaticDataCollectionEnabled"] as? NSNumber else {
+      return nil
+    }
+    return NSNumber(value: value.boolValue)
+  }
+
+  private static func decodedDictionary(
+    _ dictionary: NSDictionary?,
+    optionalKeys: [String],
+    nullReplacements: [String: Any]
+  ) -> NSDictionary? {
+    let decoded = RNFBNullSentinelDecoder.decodeNullSentinels(dictionary)
+    guard let decodedDict = decoded as? NSDictionary else {
+      return nil
+    }
+
+    let normalized = NSMutableDictionary(dictionary: decodedDict)
+    for key in optionalKeys {
+      if normalized[key] is NSNull {
+        normalized.removeObject(forKey: key)
+      }
+    }
+    for (key, replacement) in nullReplacements {
+      if normalized[key] is NSNull {
+        normalized[key] = replacement
+      }
+    }
+    return normalized
+  }
+}

package/ios/RNFBApp/RNFBJSON.m

@@ -17,8 +17,18 @@
 
 #import "RNFBJSON.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 "RNFBJSONImplementation Swift interface not found"
+#endif
+
 @interface RNFBJSON ()
-@property(nonatomic, strong) NSDictionary *firebaseJson;
+@property(nonatomic, strong) RNFBJSONImplementation *implementation;
 @end
 
 @implementation RNFBJSON
@@ -31,69 +41,43 @@
     sharedInstance = [[RNFBJSON alloc] init];
     NSString *__nullable firebaseJsonRaw =
         [[NSBundle mainBundle].infoDictionary valueForKey:@"firebase_json_raw"];
-
-    if (firebaseJsonRaw == nil) {
-      sharedInstance.firebaseJson = [NSDictionary dictionary];
-      return;
-    }
-
-    NSData *data = [[NSData alloc] initWithBase64EncodedString:firebaseJsonRaw options:0];
-
-    if (data == nil) {
-      sharedInstance.firebaseJson = [NSDictionary dictionary];
-      return;
-    }
-
-    NSError *jsonError = nil;
-    NSDictionary *dictionary = [NSJSONSerialization JSONObjectWithData:data
-                                                               options:0
-                                                                 error:&jsonError];
-    if (jsonError != nil) {
-      sharedInstance.firebaseJson = [NSDictionary dictionary];
-      return;
-    }
-
-    sharedInstance.firebaseJson = dictionary;
+    sharedInstance.implementation =
+        [[RNFBJSONImplementation alloc] initWithRawValue:firebaseJsonRaw];
   });
 
   return sharedInstance;
 }
 
 - (BOOL)contains:(NSString *)key {
-  return [_firebaseJson valueForKey:key] != nil;
+  return [self.implementation contains:key];
 }
 
 - (BOOL)getBooleanValue:(NSString *)key defaultValue:(BOOL)defaultValue {
-  if ([_firebaseJson valueForKey:key] == nil) return defaultValue;
-  NSNumber *boolean = [_firebaseJson valueForKey:key];
+  NSNumber *boolean = [self.implementation valueForKey:key defaultValue:nil];
+  if (boolean == nil) return defaultValue;
   return [boolean boolValue];
 }
 
 - (NSString *)getStringValue:(NSString *)key defaultValue:(NSString *)defaultValue {
-  if ([_firebaseJson valueForKey:key] == nil) return defaultValue;
-  NSString *string = [_firebaseJson valueForKey:key];
-  return string;
+  return [self.implementation valueForKey:key defaultValue:defaultValue];
 }
 
 - (NSArray *)getArrayValue:(NSString *)key defaultValue:(NSArray *)defaultValue {
-  if ([_firebaseJson valueForKey:key] == nil) return defaultValue;
-  NSArray *array = [_firebaseJson valueForKey:key];
-  return array;
+  return [self.implementation valueForKey:key defaultValue:defaultValue];
 }
 
 - (NSDictionary *)getAll {
-  return [[NSDictionary alloc] initWithDictionary:_firebaseJson copyItems:YES];
+  return [[NSDictionary alloc] initWithDictionary:(NSDictionary *)self.implementation.jsonObject
+                                        copyItems:YES];
 }
 
 - (NSString *)getRawJSON {
   NSString *__nullable firebaseJsonRaw =
       [[NSBundle mainBundle].infoDictionary valueForKey:@"firebase_json_raw"];
   if (firebaseJsonRaw == nil) {
-    return @"{}";
+    return [RNFBJSONImplementation rawJSONFromRawValue:nil];
   }
 
-  NSData *data = [[NSData alloc] initWithBase64EncodedString:firebaseJsonRaw options:0];
-  return [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
-  ;
+  return [RNFBJSONImplementation rawJSONFromRawValue:firebaseJsonRaw];
 }
 @end

package/ios/RNFBApp/RNFBJSONImplementation.swift

@@ -0,0 +1,71 @@
+/**
+ * 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
+
+@objc(RNFBJSONImplementation)
+public final class RNFBJSONImplementation: NSObject {
+  private let firebaseJSON: NSObject
+
+  @objc(initWithRawValue:)
+  public init(rawValue: String?) {
+    guard
+      let rawValue,
+      let data = Data(base64Encoded: rawValue),
+      let object = try? JSONSerialization.jsonObject(with: data),
+      let firebaseJSON = object as? NSObject
+    else {
+      self.firebaseJSON = NSDictionary()
+      super.init()
+      return
+    }
+
+    self.firebaseJSON = firebaseJSON
+    super.init()
+  }
+
+  @objc(initWithJSONObject:)
+  public init(jsonObject: NSObject) {
+    firebaseJSON = jsonObject
+    super.init()
+  }
+
+  @objc(contains:)
+  public func contains(_ key: String) -> Bool {
+    firebaseJSON.value(forKey: key) != nil
+  }
+
+  @objc(valueForKey:defaultValue:)
+  public func value(forKey key: String, defaultValue: AnyObject?) -> AnyObject? {
+    firebaseJSON.value(forKey: key) as AnyObject? ?? defaultValue
+  }
+
+  @objc
+  public func jsonObject() -> NSObject {
+    firebaseJSON
+  }
+
+  @objc(rawJSONFromRawValue:)
+  public static func rawJSON(from rawValue: String?) -> String? {
+    guard let rawValue else {
+      return "{}"
+    }
+    guard let data = Data(base64Encoded: rawValue) else {
+      return nil
+    }
+    return String(data: data, encoding: .utf8)
+  }
+}

package/ios/RNFBApp/RNFBMeta.m

@@ -17,45 +17,43 @@
 
 #import "RNFBMeta.h"
 
-@interface RNFBMeta ()
-@property(nonatomic, strong) NSDictionary *firebaseJson;
-@end
-
-NSString *const RNFBMetaPrefix = @"rnfirebase_";
+#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 "RNFBMetaStorage Swift interface not found"
+#endif
 
 @implementation RNFBMeta
 
++ (RNFBMetaStorage *)sharedStorage {
+  static dispatch_once_t once;
+  static RNFBMetaStorage *sharedStorage;
+
+  dispatch_once(&once, ^{
+    sharedStorage = [[RNFBMetaStorage alloc] init];
+  });
+
+  return sharedStorage;
+}
+
 + (BOOL)contains:(NSString *)key {
-  id keyValue = [[NSBundle mainBundle].infoDictionary
-      valueForKey:[RNFBMetaPrefix stringByAppendingString:key]];
-  return keyValue != nil;
+  return [[self sharedStorage] contains:key];
 }
 
 + (BOOL)getBooleanValue:(NSString *)key defaultValue:(BOOL)defaultValue {
-  NSNumber *keyValue = [[NSBundle mainBundle].infoDictionary
-      valueForKey:[RNFBMetaPrefix stringByAppendingString:key]];
-  if (keyValue == nil) return defaultValue;
-  return [keyValue boolValue];
+  return [[self sharedStorage] getBooleanValue:key defaultValue:defaultValue];
 }
 
 + (NSString *)getStringValue:(NSString *)key defaultValue:(NSString *)defaultValue {
-  NSString *keyValue = [[NSBundle mainBundle].infoDictionary
-      valueForKey:[RNFBMetaPrefix stringByAppendingString:key]];
-  if (keyValue == nil) return defaultValue;
-  return keyValue;
+  return [[self sharedStorage] getStringValue:key defaultValue:defaultValue];
 }
 
 + (NSDictionary *)getAll {
-  NSMutableDictionary *allMetaValues = [NSMutableDictionary dictionary];
-
-  NSArray *keys = [[NSBundle mainBundle].infoDictionary allKeys];
-  for (NSString *key in keys) {
-    if ([key hasPrefix:RNFBMetaPrefix]) {
-      allMetaValues[key] = [NSBundle mainBundle].infoDictionary[key];
-    }
-  }
-
-  return allMetaValues;
+  return [[self sharedStorage] getAll];
 }
 
 @end

package/ios/RNFBApp/RNFBMetaStorage.swift

@@ -0,0 +1,76 @@
+/**
+ * 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 RNFBMetaPrefix = "rnfirebase_"
+
+@objc(RNFBMetaStorage)
+public final class RNFBMetaStorage: NSObject {
+  private let infoDictionary: NSDictionary
+
+  public override convenience init() {
+    self.init(infoDictionary: Bundle.main.infoDictionary ?? [:])
+  }
+
+  @objc(initWithInfoDictionary:)
+  public init(infoDictionary: [String: Any]) {
+    self.infoDictionary = infoDictionary as NSDictionary
+    super.init()
+  }
+
+  private func prefixed(_ key: String) -> String {
+    RNFBMetaPrefix + key
+  }
+
+  @objc(contains:)
+  public func contains(_ key: String) -> Bool {
+    infoDictionary.value(forKey: prefixed(key)) != nil
+  }
+
+  @objc(getBooleanValue:defaultValue:)
+  public func getBooleanValue(_ key: String, defaultValue: Bool) -> Bool {
+    guard let keyValue = infoDictionary.value(forKey: prefixed(key)) else {
+      return defaultValue
+    }
+    // Pre-port: `[NSNumber boolValue]` after KVC lookup (NSString also responds).
+    if let number = keyValue as? NSNumber {
+      return number.boolValue
+    }
+    return (keyValue as! NSString).boolValue
+  }
+
+  @objc(getStringValue:defaultValue:)
+  public func getStringValue(_ key: String, defaultValue: String) -> String {
+    guard let keyValue = infoDictionary.value(forKey: prefixed(key)) else {
+      return defaultValue
+    }
+    // Pre-port returned the unchecked `id` typed as `NSString *`.
+    return keyValue as! String
+  }
+
+  @objc
+  public func getAll() -> [String: Any] {
+    var allMetaValues: [String: Any] = [:]
+    for key in infoDictionary.allKeys {
+      guard let key = key as? String, key.hasPrefix(RNFBMetaPrefix) else {
+        continue
+      }
+      allMetaValues[key] = infoDictionary[key]
+    }
+    return allMetaValues
+  }
+}