Add support for Realtime RC (#690)

* init the listener change

* callbacks pipeline setup and build

* Remove ConfigUpdate, and general cleanup

* Update RemoteConfigError.cs

* Update RemoteConfigError.cs

* Fix typo

* Update readme.md

* Use an IntPtr instead of the Internal class

* Update FirebaseRemoteConfig.cs

* Fix some comments

* Update readme.md

---------

Co-authored-by: Cynthia Jiang <cynthiajiang@google.com>
Co-authored-by: a-maurice <amaurice@google.com>

Author: 3 people

docs/readme.md

@@ -72,6 +72,11 @@ Release Notes
 ### 11.0.0
 - Changes
     - Messaging: Remove deprecated calls `Send`, `Subscribe`, and `Unsubscribe`.
+    - Remote Config (Android/iOS): Added support for real-time config updates. Use the new
+      `OnConfigUpdateListener` API to get real-time updates. Existing
+      `FetchAsync` and `ActivateAsync` APIs aren't affected by this change.
+      To learn more, see
+      [Get started with Firebase Remote Config](https://firebase.google.com/docs/remote-config/get-started?platform=unity#add-real-time-listener).
 
 ### 10.7.0
 - Changes

remote_config/CMakeLists.txt

@@ -24,8 +24,10 @@ set(firebase_remote_config_swig
 # Firebase RemoteConfig CSharp files
 set(firebase_remote_config_src
   src/ConfigSettings.cs
+  src/ConfigUpdateEventArgs.cs
   src/ConfigValue.cs
   src/FirebaseRemoteConfig.cs
+  src/RemoteConfigError.cs
 )
 
 firebase_swig_add_library(firebase_remote_config_swig

remote_config/src/ConfigUpdateEventArgs.cs

@@ -0,0 +1,29 @@
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file 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. */
+
+using System.Collections;
+using System.Collections.Generic;
+
+namespace Firebase.RemoteConfig {
+  // Object passed to ConfigUpdateEventHandlers that contains ConfigUpdate arguments.
+  public sealed class ConfigUpdateEventArgs : System.EventArgs {
+    // The keys that have changes in the config.
+    public IEnumerable<string> UpdatedKeys { get; set; }
+    
+    // Remote Config Errors that may have come up while listening for updates.
+    public RemoteConfigError Error { get; set; }
+  }
+}
+

remote_config/src/FirebaseRemoteConfig.cs

@@ -34,11 +34,41 @@ public sealed class FirebaseRemoteConfig {
     // Key of this instance within remoteConfigByInstanceKey.
     private string instanceKey;
 
+    // Function for C++ to call when the config is updated.
+    private static RemoteConfigUtil.ConfigUpdateDelegate configUpdateDelegate =
+      new RemoteConfigUtil.ConfigUpdateDelegate(ConfigUpdateMethod);
+
     /// @brief App object associated with this FirebaseRemoteConfig.
     public FirebaseApp App {
       get { return firebaseApp; }
     }
 
+    private event EventHandler<ConfigUpdateEventArgs> ConfigUpdateListenerImpl;
+    // EventHandlers that will be used as ConfigUpdateListeners. The first listener added will open 
+    // the stream connection and the last removed will close the stream.
+    public event EventHandler<ConfigUpdateEventArgs> OnConfigUpdateListener {
+      add {
+        ThrowIfNull();
+        // If this is the first listener, hook into C++.
+        if (ConfigUpdateListenerImpl == null ||
+            ConfigUpdateListenerImpl.GetInvocationList().Length == 0) {
+          RemoteConfigUtil.SetConfigUpdateCallback(remoteConfigInternal, configUpdateDelegate);
+        }
+
+        ConfigUpdateListenerImpl += value;
+      }
+      remove {
+        ThrowIfNull();
+        ConfigUpdateListenerImpl -= value;
+
+        // If that was the last listener, remove the C++ hooks.
+        if (ConfigUpdateListenerImpl == null ||
+            ConfigUpdateListenerImpl.GetInvocationList().Length == 0) {
+          RemoteConfigUtil.SetConfigUpdateCallback(remoteConfigInternal, null);
+        }
+      }
+    }
+
     private FirebaseRemoteConfig(FirebaseRemoteConfigInternal remoteConfig, FirebaseApp app) {
       firebaseApp = app;
       firebaseApp.AppDisposed += OnAppDisposed;
@@ -313,5 +343,31 @@ public static TimeSpan DefaultCacheExpiration {
     public static ulong DefaultTimeoutInMilliseconds {
       get { return RemoteConfigUtil.kDefaultTimeoutInMilliseconds; }
     }
+
+    internal void OnConfigUpdate(ConfigUpdateInternal configUpdate, RemoteConfigError error) {
+      EventHandler<ConfigUpdateEventArgs> handler = ConfigUpdateListenerImpl;
+      if (handler != null) {
+        // Make a copy of the list, to not rely on the Swig list
+        List<string> updatedKeys = new List<string>(configUpdate.updated_keys);
+        handler(this, new ConfigUpdateEventArgs {
+          UpdatedKeys = updatedKeys,
+          Error = error
+        });
+      }
+    }
+
+    [MonoPInvokeCallback(typeof(RemoteConfigUtil.ConfigUpdateDelegate))]
+    private static void ConfigUpdateMethod(string appName, System.IntPtr configUpdatePtr, 
+        int error) {
+      FirebaseRemoteConfig rc;
+      if (remoteConfigByInstanceKey.TryGetValue(appName, out rc)) {
+        // Create a ConfigUpdateInternal with the given pointer
+        ConfigUpdateInternal configUpdate = new ConfigUpdateInternal(configUpdatePtr, false);
+        // convert error to RemoteConfigError
+        RemoteConfigError errorInternal = (RemoteConfigError)error;
+
+        rc.OnConfigUpdate(configUpdate, errorInternal);
+      }
+    }
   }
 }  // namespace Firebase.RemoteConfig

remote_config/src/RemoteConfigError.cs

@@ -0,0 +1,34 @@
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file 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. */
+
+namespace Firebase.RemoteConfig {
+  /// <summary>
+  /// Describes the error codes returned by Remote Config.
+  /// </summary>
+  public enum RemoteConfigError {
+    // Unimplemented error found.
+    Unimplemented = -1,
+    // No error.
+    None = 0,
+    // Unable to make a connection to the Remote Config backend.
+    ConfigUpdateStreamError,
+    // The ConfigUpdate message was unparsable.
+    ConfigUpdateMessageInvalid,
+    // Unable to fetch the latest version of the config.
+    ConfigUpdateNotFetched,
+    // The Remote Config real-time config update service is unavailable.
+    ConfigUpdateUnavailable,
+  }
+}

remote_config/src/swig/remote_config.i

@@ -27,20 +27,31 @@
 %include "app/src/swig/serial_dispose.i"
 %include "app/src/swig/future.i"
 
+// Start of code added to the C++ module file
 %{
 #include <algorithm>
 #include <map>
 #include <vector>
+#include "app/src/callback.h"
 #include "app/src/cpp_instance_manager.h"
 #include "remote_config/src/include/firebase/remote_config.h"
 
 namespace firebase {
 namespace remote_config {
 
+// Declare the C++ callback delegate equivalent to C# RemoteConfigUtil.ConfigUpdateDelegate
+typedef void (SWIGSTDCALL *ConfigUpdateListener)(const char* app_name, ConfigUpdate* config_update, int error);
+
 // Reference count manager for C++ RemoteConfig instance, using pointer as the
 // key for searching.
 static CppInstanceManager<RemoteConfig> g_rc_instances;
 
+// App -> C++ ConfigUpdateListener map.
+static std::map<App*, firebase::remote_config::ConfigUpdateListenerRegistration> g_registered_listeners;
+
+// Should be set to the C# function FirebaseRemoteConfig.ConfigUpdateMethod
+static ConfigUpdateListener g_config_updated = nullptr;
+
 // Internal struct used to pass the Remote Config stored data from C++ to C#.
 struct ConfigValueInternal {
   // The raw data.
@@ -49,36 +60,61 @@ struct ConfigValueInternal {
   ValueSource source;
 };
 
+// Wrapper that calls g_config_updated. Should be used with the
+// callback logic to guarantee it is on the Unity thread.
+static void CallConfigUpdate(ConfigUpdate cu, RemoteConfigError error, const char* name) {
+  if (g_config_updated) {
+    // Should be calling FirebaseRemoteConfig.ConfigUpdateMethod
+    g_config_updated(name, &cu, static_cast<int>(error));
+  }
+}
+// Called by C# to register a RemoteConfig instance for config updates,
+// provided via the callback method provided.
+void SetConfigUpdateCallback(RemoteConfig* rc, firebase::remote_config::ConfigUpdateListener on_config_updated) {
+  // If given a method, save it, and add a new listener for Config Updates.
+  if (on_config_updated) {
+    if (!g_config_updated) {
+      g_config_updated = on_config_updated;
+    }
+    std::string app_name = rc->app()->name();
+    ConfigUpdateListenerRegistration registration = rc->AddOnConfigUpdateListener([app_name](ConfigUpdate&& cu, RemoteConfigError error) {
+      // Queue up a call to g_config_updated
+      ConfigUpdate cuLocal = std::move(cu);
+      firebase::callback::AddCallback(
+        new firebase::callback::CallbackValue2String1<ConfigUpdate, RemoteConfigError>(
+          cuLocal, error, app_name.c_str(), CallConfigUpdate));
+    });
+    
+    // Save the registration in a map so that it can be removed later if needed.
+    g_registered_listeners[rc->app()] = registration;
+  } else {
+    // Remove the listener, and cleanup the callback if no more remain.
+    ConfigUpdateListenerRegistration registration = g_registered_listeners[rc->app()];
+    g_registered_listeners.erase(rc->app());
+    registration.Remove();
+
+    if (g_registered_listeners.empty()) {
+      g_config_updated = nullptr;
+    }
+  }
+}
+
 }  // remote_config
 }  // firebase
-%}
+
+%} // End of code added to the C++ module file
 
 // All outputs of CharVector should instead be IEnumerable<byte>
 %typemap(cstype, out="global::System.Collections.Generic.IEnumerable<byte>") std::vector<unsigned char> "CharVector";
 // All outputs of StringList should instead be IEnumerable<string>
 %typemap(cstype, out="global::System.Collections.Generic.IEnumerable<string>") std::vector<std::string> "StringList";
 
-// Ignore all the deprecated static functions
-%ignore firebase::remote_config::Initialize;
-%ignore firebase::remote_config::Terminate;
-%ignore firebase::remote_config::SetDefaults;
-%ignore firebase::remote_config::GetConfigSetting;
-%ignore firebase::remote_config::SetConfigSetting;
-%ignore firebase::remote_config::GetBoolean;
-%ignore firebase::remote_config::GetLong;
-%ignore firebase::remote_config::GetDouble;
-%ignore firebase::remote_config::GetString;
-%ignore firebase::remote_config::GetData;
-%ignore firebase::remote_config::GetKeysByPrefix;
-%ignore firebase::remote_config::GetKeys;
-%ignore firebase::remote_config::Fetch;
-%ignore firebase::remote_config::ActivateFetched;
-%ignore firebase::remote_config::GetInfo;
-
 // Ignore unused structs and enums
 %ignore firebase::remote_config::ValueInfo;
 %ignore firebase::remote_config::ConfigKeyValue;
 %ignore firebase::remote_config::ConfigSetting;
+%ignore firebase::remote_config::RemoteConfigError;
+%ignore firebase::remote_config::ConfigUpdateListenerRegistration;
 
 // Configure the ConfigInfo class
 %csmethodmodifiers fetch_time "internal";
@@ -131,6 +167,8 @@ struct ConfigValueInternal {
 
 %rename (ConfigSettingsInternal) firebase::remote_config::ConfigSettings;
 
+%rename (ConfigUpdateInternal) firebase::remote_config::ConfigUpdate;
+
 // Configure properties for get / set methods on the FirebaseRemoteConfigInternal class.
 %attribute(firebase::remote_config::RemoteConfig, firebase::App*, App, app);
 
@@ -147,6 +185,7 @@ struct ConfigValueInternal {
 %ignore firebase::remote_config::RemoteConfig::GetData;
 // Ignore GetAll, as we do not rely on the C++ function for it.
 %ignore firebase::remote_config::RemoteConfig::GetAll;
+%ignore firebase::remote_config::RemoteConfig::AddOnConfigUpdateListener;
 
 %typemap(cscode) firebase::remote_config::RemoteConfig %{
   // Generates a key that uniquely identifies this instance.
@@ -176,8 +215,13 @@ struct ConfigValueInternal {
   System.GC.SuppressFinalize(this);
 }
 
+SWIG_MAP_CFUNC_TO_CSDELEGATE(
+    firebase::remote_config::ConfigUpdateListener,
+    Firebase.RemoteConfig.RemoteConfigUtil.ConfigUpdateDelegate)
+
 %include "remote_config/src/include/firebase/remote_config.h"
 
+// Start of C++ definitions that Swig needs to know of, to generate C# for
 namespace firebase {
 namespace remote_config {
 
@@ -186,10 +230,17 @@ struct ConfigValueInternal {
   ValueSource source;
 };
 
+void SetConfigUpdateCallback(firebase::remote_config::RemoteConfig* rc,
+                             firebase::remote_config::ConfigUpdateListener config_listener);
+
 }
-}
+} // End of C++ definitions
+
 
 %pragma(csharp) modulecode=%{
+
+  internal delegate void ConfigUpdateDelegate(string appName, System.IntPtr configUpdatePtr, int error);
+  
   /// The C++ mapping requires a StringStringMap, so convert the more generic
   /// dictionary into that map.
   internal static StringStringMap ConvertDictionaryToMap(