@react-native-firebase/remote-config 25.1.0 → 26.1.0

package/ios/RNFBConfig/{RNFBConfigModule.m → RNFBConfigHelper.m}

@@ -15,22 +15,23 @@
  *
  */
 
+#if __has_include(<Firebase/Firebase.h>)
 #import <Firebase/Firebase.h>
+#else
+@import FirebaseCore;
+@import FirebaseRemoteConfig;
+#endif
 #import <React/RCTConvert.h>
-#import <React/RCTUtils.h>
 
-#import "RNFBConfigModule.h"
-#import "RNFBSharedUtils.h"
+#import "RNFBApp/RCTConvert+FIRApp.h"
+#import "RNFBApp/RNFBSharedUtils.h"
+#import "RNFBConfigHelper.h"
 
 static NSString *const ON_CONFIG_UPDATED_EVENT = @"on_config_updated";
 
 static __strong NSMutableDictionary *configUpdateHandlers;
 
-@implementation RNFBConfigModule
-#pragma mark -
-#pragma mark Converters
-
-NSString *convertFIRRemoteConfigFetchStatusToNSString(FIRRemoteConfigFetchStatus value) {
+static NSString *convertFIRRemoteConfigFetchStatusToNSString(FIRRemoteConfigFetchStatus value) {
   switch (value) {
     case FIRRemoteConfigFetchStatusNoFetchYet:
       return @"no_fetch_yet";
@@ -45,7 +46,8 @@ NSString *convertFIRRemoteConfigFetchStatusToNSString(FIRRemoteConfigFetchStatus
   }
 }
 
-NSString *convertFIRRemoteConfigFetchStatusToNSStringDescription(FIRRemoteConfigFetchStatus value) {
+static NSString *convertFIRRemoteConfigFetchStatusToNSStringDescription(
+    FIRRemoteConfigFetchStatus value) {
   switch (value) {
     case FIRRemoteConfigFetchStatusThrottled:
       return @"fetch() operation cannot be completed successfully, due to throttling.";
@@ -55,7 +57,7 @@ NSString *convertFIRRemoteConfigFetchStatusToNSStringDescription(FIRRemoteConfig
   }
 }
 
-NSString *convertFIRRemoteConfigSourceToNSString(FIRRemoteConfigSource value) {
+static NSString *convertFIRRemoteConfigSourceToNSString(FIRRemoteConfigSource value) {
   switch (value) {
     case FIRRemoteConfigSourceDefault:
       return @"default";
@@ -68,7 +70,7 @@ NSString *convertFIRRemoteConfigSourceToNSString(FIRRemoteConfigSource value) {
   }
 }
 
-NSString *convertFIRRemoteConfigUpdateErrorToNSString(FIRRemoteConfigUpdateError value) {
+static NSString *convertFIRRemoteConfigUpdateErrorToNSString(FIRRemoteConfigUpdateError value) {
   switch (value) {
     case FIRRemoteConfigUpdateErrorStreamError:
       return @"config_update_stream_error";
@@ -83,55 +85,77 @@ NSString *convertFIRRemoteConfigUpdateErrorToNSString(FIRRemoteConfigUpdateError
   }
 }
 
-NSDictionary *convertFIRRemoteConfigValueToNSDictionary(FIRRemoteConfigValue *value) {
+static NSDictionary *convertFIRRemoteConfigValueToNSDictionary(FIRRemoteConfigValue *value) {
   return @{
     @"value" : (id)value.stringValue ?: [NSNull null],
     @"source" : convertFIRRemoteConfigSourceToNSString(value.source)
   };
 }
 
-#pragma mark -
-#pragma mark Module Setup
+static FIRApp *firebaseAppForName(NSString *appName) {
+  return [RCTConvert firAppFromString:appName];
+}
 
-RCT_EXPORT_MODULE();
+@implementation RNFBConfigHelper
 
-- (dispatch_queue_t)methodQueue {
-  return dispatch_get_main_queue();
++ (NSDictionary *)getConstantsForAppName:(NSString *)appName {
+  FIRApp *firebaseApp = firebaseAppForName(appName);
+  return [self getConstantsForApp:firebaseApp];
 }
 
-+ (BOOL)requiresMainQueueSetup {
-  return YES;
-}
++ (NSDictionary *)getConstantsForApp:(FIRApp *)firebaseApp {
+  FIRRemoteConfig *remoteConfig = [FIRRemoteConfig remoteConfigWithApp:firebaseApp];
 
-- (id)init {
-  self = [super init];
-  static dispatch_once_t onceToken;
-  dispatch_once(&onceToken, ^{
-    configUpdateHandlers = [[NSMutableDictionary alloc] init];
-  });
-  return self;
-}
+  NSDate *lastFetchTime = remoteConfig.lastFetchTime;
+  NSString *lastFetchStatus =
+      convertFIRRemoteConfigFetchStatusToNSString(remoteConfig.lastFetchStatus);
+  double minimumFetchInterval =
+      [RCTConvert double:@([remoteConfig configSettings].minimumFetchInterval)];
+  double fetchTimeout = [RCTConvert double:@([remoteConfig configSettings].fetchTimeout)];
 
-- (void)dealloc {
-  [self invalidate];
-}
+  NSMutableDictionary *values = [NSMutableDictionary new];
+  NSSet *keys = [[FIRRemoteConfig remoteConfigWithApp:firebaseApp] keysWithPrefix:nil];
+  for (NSString *key in keys) {
+    FIRRemoteConfigValue *value =
+        [[FIRRemoteConfig remoteConfigWithApp:firebaseApp] configValueForKey:key];
+    values[key] = convertFIRRemoteConfigValueToNSDictionary(value);
+  }
 
-- (void)invalidate {
-  for (NSString *key in configUpdateHandlers) {
-    FIRConfigUpdateListenerRegistration *registration = [configUpdateHandlers objectForKey:key];
-    [registration remove];
+  NSArray *defaultKeys = [remoteConfig allKeysFromSource:FIRRemoteConfigSourceDefault];
+  for (NSString *key in defaultKeys) {
+    if ([values valueForKey:key] == nil) {
+      FIRRemoteConfigValue *value =
+          [[FIRRemoteConfig remoteConfigWithApp:firebaseApp] configValueForKey:key];
+      values[key] = convertFIRRemoteConfigValueToNSDictionary(value);
+    }
   }
 
-  [configUpdateHandlers removeAllObjects];
+  return @{
+    @"values" : values,
+    @"lastFetchStatus" : lastFetchStatus,
+    @"lastFetchTime" : @(round([lastFetchTime timeIntervalSince1970] * 1000.0)),
+    @"minimumFetchInterval" : @(minimumFetchInterval),
+    @"fetchTimeout" : @(fetchTimeout)
+  };
+}
+
++ (NSDictionary *)resultWithConstants:(id)result firebaseApp:(FIRApp *)firebaseApp {
+  NSMutableDictionary *responseDict = [NSMutableDictionary new];
+  responseDict[@"result"] = result;
+  responseDict[@"constants"] = [self getConstantsForApp:firebaseApp];
+  return responseDict;
 }
 
-#pragma mark -
-#pragma mark Firebase Config Methods
++ (NSDictionary *)resultWithVoidConstantsForApp:(FIRApp *)firebaseApp {
+  NSMutableDictionary *responseDict = [NSMutableDictionary new];
+  responseDict[@"constants"] = [self getConstantsForApp:firebaseApp];
+  return responseDict;
+}
 
-RCT_EXPORT_METHOD(ensureInitialized
-                  : (FIRApp *)firebaseApp
-                  : (RCTPromiseResolveBlock)resolve
-                  : (RCTPromiseRejectBlock)reject) {
++ (void)ensureInitialized:(NSString *)appName
+                  resolve:(RCTPromiseResolveBlock)resolve
+                   reject:(RCTPromiseRejectBlock)reject {
+  FIRApp *firebaseApp = firebaseAppForName(appName);
   FIRRemoteConfigInitializationCompletion completionHandler = ^(NSError *__nullable error) {
     if (error) {
       [RNFBSharedUtils rejectPromiseWithNSError:reject error:error];
@@ -144,11 +168,11 @@ RCT_EXPORT_METHOD(ensureInitialized
       ensureInitializedWithCompletionHandler:completionHandler];
 }
 
-RCT_EXPORT_METHOD(fetch
-                  : (FIRApp *)firebaseApp
-                  : (nonnull NSNumber *)expirationDuration
-                  : (RCTPromiseResolveBlock)resolve
-                  : (RCTPromiseRejectBlock)reject) {
++ (void)fetch:(NSString *)appName
+    expirationDurationSeconds:(double)expirationDurationSeconds
+                      resolve:(RCTPromiseResolveBlock)resolve
+                       reject:(RCTPromiseRejectBlock)reject {
+  FIRApp *firebaseApp = firebaseAppForName(appName);
   FIRRemoteConfigFetchCompletion completionHandler =
       ^(FIRRemoteConfigFetchStatus status, NSError *__nullable error) {
         if (error) {
@@ -164,46 +188,23 @@ RCT_EXPORT_METHOD(fetch
         }
       };
 
-  if (expirationDuration.integerValue == -1) {
+  if (expirationDurationSeconds == -1) {
     [[FIRRemoteConfig remoteConfigWithApp:firebaseApp]
         fetchWithCompletionHandler:completionHandler];
   } else {
     [[FIRRemoteConfig remoteConfigWithApp:firebaseApp]
-        fetchWithExpirationDuration:expirationDuration.doubleValue
+        fetchWithExpirationDuration:expirationDurationSeconds
                   completionHandler:completionHandler];
   }
 }
 
-RCT_EXPORT_METHOD(fetchAndActivate
-                  : (FIRApp *)firebaseApp
-                  : (RCTPromiseResolveBlock)resolve
-                  : (RCTPromiseRejectBlock)reject) {
-  FIRRemoteConfigFetchAndActivateCompletion completionHandler =
-      ^(FIRRemoteConfigFetchAndActivateStatus status, NSError *__nullable error) {
-        if (error) {
-          if (error.userInfo && error.userInfo[@"ActivationFailureReason"] != nil &&
-              [error.userInfo[@"ActivationFailureReason"] containsString:@"already activated"]) {
-            resolve([self resultWithConstants:@([RCTConvert BOOL:@(YES)]) firebaseApp:firebaseApp]);
-          } else {
-            [RNFBSharedUtils rejectPromiseWithNSError:reject error:error];
-          }
-        } else {
-          if (status == FIRRemoteConfigFetchAndActivateStatusSuccessFetchedFromRemote) {
-            resolve([self resultWithConstants:@([RCTConvert BOOL:@(YES)]) firebaseApp:firebaseApp]);
-            return;
-          }
-          // if no data fetched remotely, return false
-          resolve([self resultWithConstants:@([RCTConvert BOOL:@(NO)]) firebaseApp:firebaseApp]);
-        }
-      };
-
-  [[FIRRemoteConfig remoteConfig] fetchAndActivateWithCompletionHandler:completionHandler];
-}
-
-RCT_EXPORT_METHOD(activate
-                  : (FIRApp *)firebaseApp
-                  : (RCTPromiseResolveBlock)resolve
-                  : (RCTPromiseRejectBlock)reject) {
+// Shared by `activate:` and `fetchAndActivate:` below - resolves with the `changed` BOOL from
+// `-[FIRRemoteConfig activateWithCompletion:]`, treating the SDK's "already activated" error as a
+// non-error `false` result rather than a rejection, since it just means there was nothing new to
+// activate.
++ (void)rnfb_activateRemoteConfig:(FIRApp *)firebaseApp
+                          resolve:(RCTPromiseResolveBlock)resolve
+                           reject:(RCTPromiseRejectBlock)reject {
   [[FIRRemoteConfig remoteConfigWithApp:firebaseApp] activateWithCompletion:^(
                                                          BOOL changed, NSError *_Nullable error) {
     if (error) {
@@ -219,41 +220,78 @@ RCT_EXPORT_METHOD(activate
   }];
 }
 
-RCT_EXPORT_METHOD(setConfigSettings
-                  : (FIRApp *)firebaseApp
-                  : (NSDictionary *)configSettings
-                  : (RCTPromiseResolveBlock)resolve
-                  : (RCTPromiseRejectBlock)reject) {
-  FIRRemoteConfigSettings *remoteConfigSettings = [[FIRRemoteConfigSettings alloc] init];
++ (void)fetchAndActivate:(NSString *)appName
+                 resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject {
+  // NOTE: We deliberately do not use `-[FIRRemoteConfig fetchAndActivateWithCompletionHandler:]`
+  // here. Its `FIRRemoteConfigFetchAndActivateStatus` result only reflects whether the fetch
+  // succeeded (`SuccessFetchedFromRemote`) vs fell back to previously fetched data
+  // (`SuccessUsingPreFetchedData`) - it does NOT reflect whether activation actually changed any
+  // config values, so it reports `SuccessFetchedFromRemote` (=> we'd resolve `true`) even when the
+  // fetched values are identical to what's already active. See
+  // https://github.com/invertase/react-native-firebase/issues/7779
+  //
+  // Instead we perform the fetch ourselves and hand off to the same activation + resolution logic
+  // `activate()` uses, so `fetchAndActivate()` resolves `true` only when activation changed the
+  // in-use config values - matching `activate()`'s own semantics as well as the Android
+  // implementation.
+  FIRApp *firebaseApp = firebaseAppForName(appName);
+  FIRRemoteConfigFetchCompletion fetchCompletion =
+      ^(FIRRemoteConfigFetchStatus status, NSError *__nullable error) {
+        if (error) {
+          [RNFBSharedUtils
+              rejectPromiseWithUserInfo:reject
+                               userInfo:[@{
+                                 @"code" : convertFIRRemoteConfigFetchStatusToNSString(status),
+                                 @"message" :
+                                     convertFIRRemoteConfigFetchStatusToNSStringDescription(status)
+                               } mutableCopy]];
+          return;
+        }
 
-  if ([configSettings objectForKey:@"minimumFetchInterval"]) {
-    remoteConfigSettings.minimumFetchInterval =
-        [configSettings[@"minimumFetchInterval"] doubleValue];
-  }
+        [self rnfb_activateRemoteConfig:firebaseApp resolve:resolve reject:reject];
+      };
 
-  if ([configSettings objectForKey:@"fetchTimeout"]) {
-    remoteConfigSettings.fetchTimeout = [configSettings[@"fetchTimeout"] doubleValue];
-  }
+  [[FIRRemoteConfig remoteConfigWithApp:firebaseApp] fetchWithCompletionHandler:fetchCompletion];
+}
+
++ (void)activate:(NSString *)appName
+         resolve:(RCTPromiseResolveBlock)resolve
+          reject:(RCTPromiseRejectBlock)reject {
+  FIRApp *firebaseApp = firebaseAppForName(appName);
+  [self rnfb_activateRemoteConfig:firebaseApp resolve:resolve reject:reject];
+}
+
++ (void)setConfigSettings:(NSString *)appName
+     minimumFetchInterval:(double)minimumFetchInterval
+             fetchTimeout:(double)fetchTimeout
+                  resolve:(RCTPromiseResolveBlock)resolve
+                   reject:(RCTPromiseRejectBlock)reject {
+  FIRApp *firebaseApp = firebaseAppForName(appName);
+  FIRRemoteConfigSettings *remoteConfigSettings = [[FIRRemoteConfigSettings alloc] init];
+  remoteConfigSettings.minimumFetchInterval = minimumFetchInterval;
+  remoteConfigSettings.fetchTimeout = fetchTimeout;
 
   [FIRRemoteConfig remoteConfigWithApp:firebaseApp].configSettings = remoteConfigSettings;
   resolve([self resultWithVoidConstantsForApp:firebaseApp]);
 }
 
-RCT_EXPORT_METHOD(setDefaults
-                  : (FIRApp *)firebaseApp
-                  : (NSDictionary *)defaults
-                  : (RCTPromiseResolveBlock)resolve
-                  : (RCTPromiseRejectBlock)reject) {
++ (void)setDefaults:(NSString *)appName
+           defaults:(NSDictionary *)defaults
+            resolve:(RCTPromiseResolveBlock)resolve
+             reject:(RCTPromiseRejectBlock)reject {
+  FIRApp *firebaseApp = firebaseAppForName(appName);
   [[FIRRemoteConfig remoteConfigWithApp:firebaseApp] setDefaults:defaults];
   resolve([self resultWithConstants:[NSNull null] firebaseApp:firebaseApp]);
 }
-RCT_EXPORT_METHOD(setDefaultsFromResource
-                  : (FIRApp *)firebaseApp
-                  : (NSString *)fileName
-                  : (RCTPromiseResolveBlock)resolve
-                  : (RCTPromiseRejectBlock)reject) {
-  if ([[NSBundle mainBundle] pathForResource:fileName ofType:@"plist"] != nil) {
-    [[FIRRemoteConfig remoteConfigWithApp:firebaseApp] setDefaultsFromPlistFileName:fileName];
+
++ (void)setDefaultsFromResource:(NSString *)appName
+                   resourceName:(NSString *)resourceName
+                        resolve:(RCTPromiseResolveBlock)resolve
+                         reject:(RCTPromiseRejectBlock)reject {
+  FIRApp *firebaseApp = firebaseAppForName(appName);
+  if ([[NSBundle mainBundle] pathForResource:resourceName ofType:@"plist"] != nil) {
+    [[FIRRemoteConfig remoteConfigWithApp:firebaseApp] setDefaultsFromPlistFileName:resourceName];
     resolve([self resultWithConstants:[NSNull null] firebaseApp:firebaseApp]);
   } else {
     [RNFBSharedUtils rejectPromiseWithUserInfo:reject
@@ -264,7 +302,20 @@ RCT_EXPORT_METHOD(setDefaultsFromResource
   }
 }
 
-RCT_EXPORT_METHOD(onConfigUpdated : (FIRApp *)firebaseApp) {
++ (void)reset:(NSString *)appName
+      resolve:(RCTPromiseResolveBlock)resolve
+       reject:(RCTPromiseRejectBlock)reject {
+  FIRApp *firebaseApp = firebaseAppForName(appName);
+  resolve([self resultWithVoidConstantsForApp:firebaseApp]);
+}
+
++ (void)onConfigUpdated:(NSString *)appName {
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    configUpdateHandlers = [[NSMutableDictionary alloc] init];
+  });
+
+  FIRApp *firebaseApp = firebaseAppForName(appName);
   if (![configUpdateHandlers valueForKey:firebaseApp.name]) {
     FIRConfigUpdateListenerRegistration *newRegistration =
         [[FIRRemoteConfig remoteConfigWithApp:firebaseApp]
@@ -274,7 +325,8 @@ RCT_EXPORT_METHOD(onConfigUpdated : (FIRApp *)firebaseApp) {
                 NSMutableDictionary *userInfo = [NSMutableDictionary dictionary];
 
                 [userInfo setValue:@"error" forKey:@"resultType"];
-                [userInfo setValue:convertFIRRemoteConfigUpdateErrorToNSString(error.code)
+                [userInfo setValue:convertFIRRemoteConfigUpdateErrorToNSString(
+                                       (FIRRemoteConfigUpdateError)error.code)
                             forKey:@"code"];
                 [userInfo setValue:error.localizedDescription forKey:@"message"];
                 [userInfo setValue:error.localizedDescription forKey:@"nativeErrorMessage"];
@@ -298,20 +350,31 @@ RCT_EXPORT_METHOD(onConfigUpdated : (FIRApp *)firebaseApp) {
   }
 }
 
-RCT_EXPORT_METHOD(removeConfigUpdateRegistration : (FIRApp *)firebaseApp) {
++ (void)removeConfigUpdateRegistration:(NSString *)appName {
+  FIRApp *firebaseApp = firebaseAppForName(appName);
   if ([configUpdateHandlers valueForKey:firebaseApp.name]) {
     [[configUpdateHandlers objectForKey:firebaseApp.name] remove];
     [configUpdateHandlers removeObjectForKey:firebaseApp.name];
   }
 }
 
-RCT_EXPORT_METHOD(setCustomSignals
-                  : (FIRApp *)firebaseApp
-                  : (NSDictionary *)customSignals
-                  : (RCTPromiseResolveBlock)resolve
-                  : (RCTPromiseRejectBlock)reject) {
++ (void)removeAllConfigUpdateRegistrations {
+  for (NSString *key in [configUpdateHandlers allKeys]) {
+    FIRConfigUpdateListenerRegistration *registration = [configUpdateHandlers objectForKey:key];
+    [registration remove];
+  }
+
+  [configUpdateHandlers removeAllObjects];
+}
+
++ (void)setCustomSignals:(NSString *)appName
+           customSignals:(NSDictionary *)customSignals
+                 resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject {
+  FIRApp *firebaseApp = firebaseAppForName(appName);
+  NSDictionary *decodedCustomSignals = [RNFBSharedUtils decodeNullSentinels:customSignals];
   [[FIRRemoteConfig remoteConfigWithApp:firebaseApp]
-      setCustomSignals:customSignals
+      setCustomSignals:decodedCustomSignals
         withCompletion:^(NSError *_Nullable error) {
           if (error != nil) {
             [RNFBSharedUtils rejectPromiseWithNSError:reject error:error];
@@ -321,56 +384,4 @@ RCT_EXPORT_METHOD(setCustomSignals
         }];
 }
 
-#pragma mark -
-#pragma mark Internal Helper Methods
-
-- (NSDictionary *)resultWithConstants:(id)result firebaseApp:(FIRApp *)firebaseApp {
-  NSMutableDictionary *responseDict = [NSMutableDictionary new];
-  responseDict[@"result"] = result;
-  responseDict[@"constants"] = [self getConstantsForApp:firebaseApp];
-  return responseDict;
-}
-
-- (NSDictionary *)resultWithVoidConstantsForApp:(FIRApp *)firebaseApp {
-  NSMutableDictionary *responseDict = [NSMutableDictionary new];
-  responseDict[@"constants"] = [self getConstantsForApp:firebaseApp];
-  return responseDict;
-}
-
-- (NSDictionary *)getConstantsForApp:(FIRApp *)firebaseApp {
-  FIRRemoteConfig *remoteConfig = [FIRRemoteConfig remoteConfigWithApp:firebaseApp];
-
-  NSDate *lastFetchTime = remoteConfig.lastFetchTime;
-  NSString *lastFetchStatus =
-      convertFIRRemoteConfigFetchStatusToNSString(remoteConfig.lastFetchStatus);
-  double minimumFetchInterval =
-      [RCTConvert double:@([remoteConfig configSettings].minimumFetchInterval)];
-  double fetchTimeout = [RCTConvert double:@([remoteConfig configSettings].fetchTimeout)];
-
-  NSMutableDictionary *values = [NSMutableDictionary new];
-  NSSet *keys = [[FIRRemoteConfig remoteConfigWithApp:firebaseApp] keysWithPrefix:nil];
-  for (NSString *key in keys) {
-    FIRRemoteConfigValue *value =
-        [[FIRRemoteConfig remoteConfigWithApp:firebaseApp] configValueForKey:key];
-    values[key] = convertFIRRemoteConfigValueToNSDictionary(value);
-  }
-
-  NSArray *defaultKeys = [remoteConfig allKeysFromSource:FIRRemoteConfigSourceDefault];
-  for (NSString *key in defaultKeys) {
-    if ([values valueForKey:key] == nil) {
-      FIRRemoteConfigValue *value =
-          [[FIRRemoteConfig remoteConfigWithApp:firebaseApp] configValueForKey:key];
-      values[key] = convertFIRRemoteConfigValueToNSDictionary(value);
-    }
-  }
-
-  return @{
-    @"values" : values,
-    @"lastFetchStatus" : lastFetchStatus,
-    @"lastFetchTime" : @(round([lastFetchTime timeIntervalSince1970] * 1000.0)),
-    @"minimumFetchInterval" : @(minimumFetchInterval),
-    @"fetchTimeout" : @(fetchTimeout)
-  };
-}
-
 @end

package/ios/RNFBConfig/RNFBConfigModule.h

@@ -17,8 +17,9 @@
 
 #import <Foundation/Foundation.h>
 
-#import <React/RCTBridgeModule.h>
+#import <React/RCTInvalidating.h>
+#import "RNFBRemoteConfigTurboModules.h"
 
-@interface RNFBConfigModule : NSObject <RCTBridgeModule>
+@interface RNFBConfigModule : NSObject <NativeRNFBTurboConfigSpec, RCTInvalidating>
 
 @end

package/ios/RNFBConfig/RNFBConfigModule.mm

@@ -0,0 +1,134 @@
+/**
+ * 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 "RNFBConfigModule.h"
+#import "RNFBApp/RNFBSharedUtils.h"
+#import "RNFBConfigHelper.h"
+
+@implementation RNFBConfigModule
+#pragma mark -
+#pragma mark Module Setup
+
+RCT_EXPORT_MODULE(NativeRNFBTurboConfig)
+
++ (BOOL)requiresMainQueueSetup {
+  return NO;
+}
+
+- (void)invalidate {
+  [RNFBConfigHelper removeAllConfigUpdateRegistrations];
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params {
+  return std::make_shared<facebook::react::NativeRNFBTurboConfigSpecJSI>(params);
+}
+
+- (facebook::react::ModuleConstants<JS::NativeRNFBTurboConfig::Constants::Builder>)
+    constantsToExport {
+  return [_RCTTypedModuleConstants
+      newWithUnsafeDictionary:[RNFBConfigHelper getConstantsForAppName:DEFAULT_APP_DISPLAY_NAME]];
+}
+
+- (facebook::react::ModuleConstants<JS::NativeRNFBTurboConfig::Constants::Builder>)getConstants {
+  return [self constantsToExport];
+}
+
+#pragma mark -
+#pragma mark Firebase Config Methods
+
+- (void)ensureInitialized:(NSString *)appName
+                  resolve:(RCTPromiseResolveBlock)resolve
+                   reject:(RCTPromiseRejectBlock)reject {
+  [RNFBConfigHelper ensureInitialized:appName resolve:resolve reject:reject];
+}
+
+- (void)fetch:(NSString *)appName
+    expirationDurationSeconds:(double)expirationDurationSeconds
+                      resolve:(RCTPromiseResolveBlock)resolve
+                       reject:(RCTPromiseRejectBlock)reject {
+  [RNFBConfigHelper fetch:appName
+      expirationDurationSeconds:expirationDurationSeconds
+                        resolve:resolve
+                         reject:reject];
+}
+
+- (void)fetchAndActivate:(NSString *)appName
+                 resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject {
+  [RNFBConfigHelper fetchAndActivate:appName resolve:resolve reject:reject];
+}
+
+- (void)activate:(NSString *)appName
+         resolve:(RCTPromiseResolveBlock)resolve
+          reject:(RCTPromiseRejectBlock)reject {
+  [RNFBConfigHelper activate:appName resolve:resolve reject:reject];
+}
+
+- (void)setConfigSettings:(NSString *)appName
+                 settings:(JS::NativeRNFBTurboConfig::ConfigSettings &)configSettings
+                  resolve:(RCTPromiseResolveBlock)resolve
+                   reject:(RCTPromiseRejectBlock)reject {
+  [RNFBConfigHelper setConfigSettings:appName
+                 minimumFetchInterval:configSettings.minimumFetchInterval()
+                         fetchTimeout:configSettings.fetchTimeout()
+                              resolve:resolve
+                               reject:reject];
+}
+
+- (void)setDefaults:(NSString *)appName
+           defaults:(NSDictionary *)defaults
+            resolve:(RCTPromiseResolveBlock)resolve
+             reject:(RCTPromiseRejectBlock)reject {
+  [RNFBConfigHelper setDefaults:appName defaults:defaults resolve:resolve reject:reject];
+}
+
+- (void)setDefaultsFromResource:(NSString *)appName
+                   resourceName:(NSString *)resourceName
+                        resolve:(RCTPromiseResolveBlock)resolve
+                         reject:(RCTPromiseRejectBlock)reject {
+  [RNFBConfigHelper setDefaultsFromResource:appName
+                               resourceName:resourceName
+                                    resolve:resolve
+                                     reject:reject];
+}
+
+- (void)reset:(NSString *)appName
+      resolve:(RCTPromiseResolveBlock)resolve
+       reject:(RCTPromiseRejectBlock)reject {
+  [RNFBConfigHelper reset:appName resolve:resolve reject:reject];
+}
+
+- (void)onConfigUpdated:(NSString *)appName {
+  [RNFBConfigHelper onConfigUpdated:appName];
+}
+
+- (void)removeConfigUpdateRegistration:(NSString *)appName {
+  [RNFBConfigHelper removeConfigUpdateRegistration:appName];
+}
+
+- (void)setCustomSignals:(NSString *)appName
+           customSignals:(NSDictionary *)customSignals
+                 resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject {
+  [RNFBConfigHelper setCustomSignals:appName
+                       customSignals:customSignals
+                             resolve:resolve
+                              reject:reject];
+}
+
+@end