@react-native-firebase/remote-config 18.0.0 → 18.2.0

package/CHANGELOG.md

@@ -3,6 +3,22 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [18.2.0](https://github.com/invertase/react-native-firebase/compare/v18.1.0...v18.2.0) (2023-07-13)
+
+### Bug Fixes
+
+- **app, ios:** incorporate firebase-ios-sdk 10.12.0 ([#7231](https://github.com/invertase/react-native-firebase/issues/7231)) ([ee66459](https://github.com/invertase/react-native-firebase/commit/ee66459cd214ffb84ce2d4e15eef79d047f075ab))
+
+## [18.1.0](https://github.com/invertase/react-native-firebase/compare/v18.0.0...v18.1.0) (2023-06-22)
+
+### Features
+
+- **remote-config:** realtime config updates ([9ded619](https://github.com/invertase/react-native-firebase/commit/9ded619e81c1523d7fa0cdbda8fc94929450a967))
+
+### Bug Fixes
+
+- **remote-config, ios:** workaround firebase-ios-sdk[#11458](https://github.com/invertase/react-native-firebase/issues/11458) until SDK v10.12.0 ([8c75849](https://github.com/invertase/react-native-firebase/commit/8c758496c2fadc506805f81d1619ebce21a413df))
+
 ## [18.0.0](https://github.com/invertase/react-native-firebase/compare/v17.5.0...v18.0.0) (2023-06-05)
 
 **Note:** Version bump only for package @react-native-firebase/remote-config

package/android/src/reactnative/java/io/invertase/firebase/config/ReactNativeFirebaseConfigModule.java

@@ -19,21 +19,46 @@ package io.invertase.firebase.config;
 
 import com.facebook.react.bridge.*;
 import com.google.firebase.FirebaseApp;
-import com.google.firebase.remoteconfig.FirebaseRemoteConfigFetchThrottledException;
+import com.google.firebase.remoteconfig.*;
+import io.invertase.firebase.common.ReactNativeFirebaseEvent;
+import io.invertase.firebase.common.ReactNativeFirebaseEventEmitter;
 import io.invertase.firebase.common.ReactNativeFirebaseModule;
+import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
 import java.util.Map;
+import java.util.Set;
 import javax.annotation.Nullable;
+import org.jetbrains.annotations.NotNull;
 
 public class ReactNativeFirebaseConfigModule extends ReactNativeFirebaseModule {
   private static final String SERVICE_NAME = "Config";
   private final UniversalFirebaseConfigModule module;
 
+  private static HashMap<String, ConfigUpdateListenerRegistration> mConfigUpdateRegistrations =
+      new HashMap<>();
+
   ReactNativeFirebaseConfigModule(ReactApplicationContext reactContext) {
     super(reactContext, SERVICE_NAME);
     module = new UniversalFirebaseConfigModule(reactContext, SERVICE_NAME);
   }
 
+  @Override
+  public void onCatalystInstanceDestroy() {
+    super.onCatalystInstanceDestroy();
+
+    Iterator<Map.Entry<String, ConfigUpdateListenerRegistration>> configRegistrationsIterator =
+        mConfigUpdateRegistrations.entrySet().iterator();
+
+    while (configRegistrationsIterator.hasNext()) {
+      Map.Entry<String, ConfigUpdateListenerRegistration> pair = configRegistrationsIterator.next();
+      ConfigUpdateListenerRegistration mConfigRegistration = pair.getValue();
+      mConfigRegistration.remove();
+      configRegistrationsIterator.remove();
+    }
+  }
+
   @ReactMethod
   public void activate(String appName, Promise promise) {
     module
@@ -151,6 +176,85 @@ public class ReactNativeFirebaseConfigModule extends ReactNativeFirebaseModule {
             });
   }
 
+  @ReactMethod
+  public void onConfigUpdated(String appName) {
+    if (mConfigUpdateRegistrations.get(appName) == null) {
+      FirebaseApp firebaseApp = FirebaseApp.getInstance(appName);
+      ConfigUpdateListenerRegistration registration =
+          FirebaseRemoteConfig.getInstance(firebaseApp)
+              .addOnConfigUpdateListener(
+                  new ConfigUpdateListener() {
+                    @Override
+                    public void onUpdate(@NotNull ConfigUpdate configUpdate) {
+                      ReactNativeFirebaseEventEmitter emitter =
+                          ReactNativeFirebaseEventEmitter.getSharedInstance();
+
+                      Set<String> updatedKeys = configUpdate.getUpdatedKeys();
+                      List<String> updatedKeysList = new ArrayList<>(updatedKeys);
+
+                      Map<String, Object> results = new HashMap<>();
+                      results.put("appName", appName);
+                      results.put("resultType", "success");
+                      results.put("updatedKeys", updatedKeysList);
+                      ReactNativeFirebaseEvent event =
+                          new ReactNativeFirebaseEvent(
+                              "on_config_updated", Arguments.makeNativeMap(results), appName);
+                      emitter.sendEvent(event);
+                    }
+
+                    @Override
+                    public void onError(@NotNull FirebaseRemoteConfigException error) {
+                      ReactNativeFirebaseEventEmitter emitter =
+                          ReactNativeFirebaseEventEmitter.getSharedInstance();
+
+                      WritableMap userInfoMap = Arguments.createMap();
+                      userInfoMap.putString("resultType", "error");
+                      userInfoMap.putString("appName", appName);
+
+                      FirebaseRemoteConfigException.Code code = error.getCode();
+                      switch (code) {
+                        case CONFIG_UPDATE_STREAM_ERROR:
+                          userInfoMap.putString("code", "config_update_stream_error");
+                          break;
+                        case CONFIG_UPDATE_MESSAGE_INVALID:
+                          userInfoMap.putString("code", "config_update_message_invalid");
+                          break;
+                        case CONFIG_UPDATE_NOT_FETCHED:
+                          userInfoMap.putString("code", "config_update_not_fetched");
+                          break;
+                        case CONFIG_UPDATE_UNAVAILABLE:
+                          userInfoMap.putString("code", "config_update_unavailable");
+                          break;
+                        case UNKNOWN:
+                          userInfoMap.putString("code", "unknown");
+                          break;
+                        default:
+                          // contract violation internal to the RNFB / SDK boundary
+                          userInfoMap.putString("code", "internal");
+                      }
+
+                      userInfoMap.putString("message", error.getMessage());
+                      userInfoMap.putString("nativeErrorMessage", error.getMessage());
+                      ReactNativeFirebaseEvent event =
+                          new ReactNativeFirebaseEvent("on_config_updated", userInfoMap, appName);
+                      emitter.sendEvent(event);
+                    }
+                  });
+
+      mConfigUpdateRegistrations.put(appName, registration);
+    }
+  }
+
+  @ReactMethod
+  public void removeConfigUpdateRegistration(String appName) {
+    ConfigUpdateListenerRegistration mConfigRegistration = mConfigUpdateRegistrations.get(appName);
+
+    if (mConfigRegistration != null) {
+      mConfigRegistration.remove();
+      mConfigUpdateRegistrations.remove(appName);
+    }
+  }
+
   private WritableMap resultWithConstants(Object result) {
     Map<String, Object> responseMap = new HashMap<>(2);
     responseMap.put("result", result);

package/ios/RNFBConfig/RNFBConfigModule.m

@@ -22,6 +22,10 @@
 #import "RNFBConfigModule.h"
 #import "RNFBSharedUtils.h"
 
+static NSString *const ON_CONFIG_UPDATED_EVENT = @"on_config_updated";
+
+static __strong NSMutableDictionary *configUpdateHandlers;
+
 @implementation RNFBConfigModule
 #pragma mark -
 #pragma mark Converters
@@ -64,6 +68,21 @@ NSString *convertFIRRemoteConfigSourceToNSString(FIRRemoteConfigSource value) {
   }
 }
 
+NSString *convertFIRRemoteConfigUpdateErrorToNSString(FIRRemoteConfigUpdateError value) {
+  switch (value) {
+    case FIRRemoteConfigUpdateErrorStreamError:
+      return @"config_update_stream_error";
+    case FIRRemoteConfigUpdateErrorMessageInvalid:
+      return @"config_update_message_invalid";
+    case FIRRemoteConfigUpdateErrorNotFetched:
+      return @"config_update_not_fetched";
+    case FIRRemoteConfigUpdateErrorUnavailable:
+      return @"config_update_unavailable";
+    default:
+      return @"internal";
+  }
+}
+
 NSDictionary *convertFIRRemoteConfigValueToNSDictionary(FIRRemoteConfigValue *value) {
   return @{
     @"value" : (id)value.stringValue ?: [NSNull null],
@@ -84,6 +103,28 @@ RCT_EXPORT_MODULE();
   return YES;
 }
 
+- (id)init {
+  self = [super init];
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    configUpdateHandlers = [[NSMutableDictionary alloc] init];
+  });
+  return self;
+}
+
+- (void)dealloc {
+  [self invalidate];
+}
+
+- (void)invalidate {
+  for (NSString *key in configUpdateHandlers) {
+    FIRConfigUpdateListenerRegistration *registration = [configUpdateHandlers objectForKey:key];
+    [registration remove];
+  }
+
+  [configUpdateHandlers removeAllObjects];
+}
+
 #pragma mark -
 #pragma mark Firebase Config Methods
 
@@ -223,6 +264,47 @@ RCT_EXPORT_METHOD(setDefaultsFromResource
   }
 }
 
+RCT_EXPORT_METHOD(onConfigUpdated : (FIRApp *)firebaseApp) {
+  if (![configUpdateHandlers valueForKey:firebaseApp.name]) {
+    FIRConfigUpdateListenerRegistration *newRegistration =
+        [[FIRRemoteConfig remoteConfigWithApp:firebaseApp]
+            addOnConfigUpdateListener:^(FIRRemoteConfigUpdate *_Nonnull configUpdate,
+                                        NSError *_Nullable error) {
+              if (error != nil) {
+                NSMutableDictionary *userInfo = [NSMutableDictionary dictionary];
+
+                [userInfo setValue:@"error" forKey:@"resultType"];
+                [userInfo setValue:convertFIRRemoteConfigUpdateErrorToNSString(error.code)
+                            forKey:@"code"];
+                [userInfo setValue:error.localizedDescription forKey:@"message"];
+                [userInfo setValue:error.localizedDescription forKey:@"nativeErrorMessage"];
+                [RNFBSharedUtils sendJSEventForApp:firebaseApp
+                                              name:ON_CONFIG_UPDATED_EVENT
+                                              body:userInfo];
+                return;
+              }
+
+              NSMutableDictionary *results = [NSMutableDictionary dictionary];
+
+              [results setValue:@"success" forKey:@"resultType"];
+              [results setValue:[configUpdate.updatedKeys allObjects] forKey:@"updatedKeys"];
+
+              [RNFBSharedUtils sendJSEventForApp:firebaseApp
+                                            name:ON_CONFIG_UPDATED_EVENT
+                                            body:results];
+            }];
+
+    configUpdateHandlers[firebaseApp.name] = newRegistration;
+  }
+}
+
+RCT_EXPORT_METHOD(removeConfigUpdateRegistration : (FIRApp *)firebaseApp) {
+  if ([configUpdateHandlers valueForKey:firebaseApp.name]) {
+    [[configUpdateHandlers objectForKey:firebaseApp.name] remove];
+    [configUpdateHandlers removeObjectForKey:firebaseApp.name];
+  }
+}
+
 #pragma mark -
 #pragma mark Internal Helper Methods
 

package/lib/index.d.ts

@@ -376,6 +376,17 @@ export namespace FirebaseRemoteConfigTypes {
      */
     setDefaultsFromResource(resourceName: string): Promise<null>;
 
+    /**
+     * Start listening for real-time config updates from the Remote Config backend and
+     * automatically fetch updates when they’re available. Note that the list of updated keys
+     * passed to the callback will include all keys not currently active, and the config update
+     * process fetches the new config but does not automatically activate for you. Typically
+     * you will want to activate the config in your callback so the new values are in force.
+     *
+     * @param listener called with either array of updated keys or error arg when config changes
+     */
+    onConfigUpdated(listener: CallbackOrObserver<OnConfigUpdatedListenerCallback>): () => void;
+
     /**
      * Moves fetched data to the apps active config.
      * Resolves with a boolean value true if new local values were activated
@@ -543,6 +554,17 @@ export const firebase: ReactNativeFirebase.Module & {
   ): ReactNativeFirebase.FirebaseApp & { remoteConfig(): FirebaseRemoteConfigTypes.Module };
 };
 
+type CallbackOrObserver<T extends (...args: any[]) => any> = T | { next: T };
+
+type OnConfigUpdatedListenerCallback = (
+  event?: { updatedKeys: string[] },
+  error?: {
+    code: string;
+    message: string;
+    nativeErrorMessage: string;
+  },
+) => void;
+
 export default defaultExport;
 
 /**

package/lib/index.js

@@ -53,6 +53,7 @@ export {
   fetch,
   setDefaults,
   setDefaultsFromResource,
+  onConfigUpdated,
 } from './modular/index';
 
 const statics = {
@@ -84,6 +85,7 @@ class FirebaseConfigModule extends FirebaseModule {
     this._lastFetchTime = -1;
     this._values = {};
     this._isWeb = Platform.OS !== 'ios' && Platform.OS !== 'android';
+    this._configUpdateListenerCount = 0;
   }
 
   get defaultConfig() {
@@ -282,6 +284,59 @@ class FirebaseConfigModule extends FirebaseModule {
     return this._promiseWithConstants(this.native.setDefaultsFromResource(resourceName));
   }
 
+  /**
+   * Registers a listener to changes in the configuration.
+   *
+   * @param listenerOrObserver - function called on config change
+   * @returns {function} unsubscribe listener
+   */
+  onConfigUpdated(listenerOrObserver) {
+    const listener = this._parseListener(listenerOrObserver);
+    let unsubscribed = false;
+    const subscription = this.emitter.addListener(
+      this.eventNameForApp('on_config_updated'),
+      event => {
+        const { resultType } = event;
+        if (resultType === 'success') {
+          listener({ updatedKeys: event.updatedKeys }, undefined);
+          return;
+        }
+
+        listener(undefined, {
+          code: event.code,
+          message: event.message,
+          nativeErrorMessage: event.nativeErrorMessage,
+        });
+      },
+    );
+    if (this._configUpdateListenerCount === 0) {
+      this.native.onConfigUpdated();
+    }
+
+    this._configUpdateListenerCount++;
+
+    return () => {
+      if (unsubscribed) {
+        // there is no harm in calling this multiple times to unsubscribe,
+        // but anything after the first call is a no-op
+        return;
+      } else {
+        unsubscribed = true;
+      }
+      subscription.remove();
+      this._configUpdateListenerCount--;
+      if (this._configUpdateListenerCount === 0) {
+        this.native.removeConfigUpdateRegistration();
+      }
+    };
+  }
+
+  _parseListener(listenerOrObserver) {
+    return typeof listenerOrObserver === 'object'
+      ? listenerOrObserver.next.bind(listenerOrObserver)
+      : listenerOrObserver;
+  }
+
   _updateFromConstants(constants) {
     // Wrapped this as we update using sync getters initially for `defaultConfig` & `settings`
     if (constants.lastFetchTime) {
@@ -326,7 +381,7 @@ export default createModuleNamespace({
   version,
   namespace,
   nativeModuleName,
-  nativeEvents: false,
+  nativeEvents: ['on_config_updated'],
   hasMultiAppSupport: true,
   hasCustomUrlOrRegionSupport: false,
   ModuleClass: FirebaseConfigModule,

package/lib/modular/index.js

@@ -221,3 +221,14 @@ export function setDefaults(remoteConfig, defaults) {
 export function setDefaultsFromResource(remoteConfig, resourceName) {
   return remoteConfig.setDefaultsFromResource(resourceName);
 }
+
+/**
+ * Registers a listener to changes in the configuration.
+ *
+ * @param remoteConfig - RemoteConfig instance
+ * @param callback - function called on config change
+ * @returns {function} unsubscribe listener
+ */
+export function onConfigUpdated(remoteConfig, callback) {
+  return remoteConfig.onConfigUpdated(callback);
+}

package/lib/version.js

@@ -1,2 +1,2 @@
 // Generated by genversion.
-module.exports = '18.0.0';
+module.exports = '18.2.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@react-native-firebase/remote-config",
-  "version": "18.0.0",
+  "version": "18.2.0",
   "author": "Invertase <oss@invertase.io> (http://invertase.io)",
   "description": "React Native Firebase - React Native Firebase provides native integration with Remote Config, allowing you to change the appearance and/or functionality of your app without requiring an app update.",
   "main": "lib/index.js",
@@ -24,11 +24,11 @@
     "remote-config"
   ],
   "peerDependencies": {
-    "@react-native-firebase/analytics": "18.0.0",
-    "@react-native-firebase/app": "18.0.0"
+    "@react-native-firebase/analytics": "18.2.0",
+    "@react-native-firebase/app": "18.2.0"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "db49dfeab62fa0c52530ccf2bfdfe9e27947bdbd"
+  "gitHead": "4c666df92028ddc3c0010a7ac102f54b600e6644"
 }