Merge branch 'realtime-rc-main' into realtime-rc-android

Author: AlmostMatt

remote_config/CMakeLists.txt

@@ -45,8 +45,7 @@ build_flatbuffers("${flatbuffer_schemas}"
 # Common source files used by all platforms
 set(common_SRCS
     src/common.cc
-    src/remote_config.cc
-    src/config_update_listener_registration.cc)
+    src/remote_config.cc)
 
 
 # Run gradle command to make jar
@@ -64,6 +63,7 @@ set(android_SRCS
 
 # Source files used by the iOS implementation.
 set(ios_SRCS
+    src/ios/config_update_listener_registration.cc
     src/ios/remote_config_ios.mm)
 
 # Source files used by the desktop implementation.

remote_config/integration_test/src/integration_test.cc

@@ -15,15 +15,20 @@
 #include <inttypes.h>
 
 #include <algorithm>
+#include <chrono>
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
 #include <ctime>
+#include <future>
+#include <memory>
 
 #include "app_framework.h"  // NOLINT
 #include "firebase/app.h"
+#include "firebase/internal/platform.h"
 #include "firebase/log.h"
 #include "firebase/remote_config.h"
+#include "firebase/remote_config/config_update_listener_registration.h"
 #include "firebase/util.h"
 #include "firebase_test_framework.h"  // NOLINT
 
@@ -188,6 +193,60 @@ static Future<void> SetZeroIntervalConfigSettings(RemoteConfig* rc) {
 
 // Test cases below.
 
+/// This test requires to be run on a device or simulator that does not have the
+/// template version number stored on the disk.
+TEST_F(FirebaseRemoteConfigTest, TestAddOnConfigUpdateListener) {
+  ASSERT_NE(rc_, nullptr);
+
+  EXPECT_TRUE(WaitForCompletion(SetDefaults(rc_), "SetDefaults"));
+
+#if FIREBASE_PLATFORM_IOS
+
+  auto config_update_promise = std::make_shared<std::promise<void>>();
+
+  firebase::remote_config::ConfigUpdateListenerRegistration* registration =
+      rc_->AddOnConfigUpdateListener(
+          [&, config_update_promise](
+              firebase::remote_config::ConfigUpdate&& configUpdate,
+              firebase::remote_config::RemoteConfigError remoteConfigError) {
+            EXPECT_EQ(configUpdate.updated_keys.size(), 5);
+            EXPECT_TRUE(WaitForCompletion(rc_->Activate(), "Activate"));
+            LogDebug("Real-time Config Update keys retrieved.");
+
+            std::map<std::string, firebase::Variant> key_values = rc_->GetAll();
+            EXPECT_EQ(key_values.size(), 6);
+
+            for (auto key_valur_pair : kServerValue) {
+              firebase::Variant k_value = key_valur_pair.value;
+              firebase::Variant fetched_value = key_values[key_valur_pair.key];
+              EXPECT_EQ(k_value.type(), fetched_value.type());
+              EXPECT_EQ(k_value, fetched_value);
+            }
+            config_update_promise->set_value();
+          });
+  EXPECT_NE(nullptr, registration);
+  auto config_update_future = config_update_promise->get_future();
+  ASSERT_EQ(std::future_status::ready,
+            config_update_future.wait_for(std::chrono::milliseconds(10000)));
+
+  registration->Remove();
+
+#endif
+}
+
+TEST_F(FirebaseRemoteConfigTest, TestRemoveConfigUpdateListener) {
+#if FIREBASE_PLATFORM_IOS
+
+  firebase::remote_config::ConfigUpdateListenerRegistration* registration =
+      rc_->AddOnConfigUpdateListener(
+          [](firebase::remote_config::ConfigUpdate&& configUpdate,
+             firebase::remote_config::RemoteConfigError remoteConfigError) {});
+
+  registration->Remove();
+
+#endif
+}
+
 TEST_F(FirebaseRemoteConfigTest, TestInitializeAndTerminate) {
   // Already tested via SetUp() and TearDown().
 }
@@ -405,15 +464,4 @@ TEST_F(FirebaseRemoteConfigTest, TestFetchSecondsParameter) {
 
   FLAKY_TEST_SECTION_END();
 }
-
-TEST_F(FirebaseRemoteConfigTest, TestAddOnConfigUpdateListener) {
-  EXPECT_EQ(nullptr, rc_->AddOnConfigUpdateListener(
-                         [](ConfigUpdate&&, RemoteConfigError) {}));
-}
-
-TEST_F(FirebaseRemoteConfigTest, TestRemoveConfigUpdateListener) {
-  EXPECT_EQ(nullptr, rc_->AddOnConfigUpdateListener(
-                         [](ConfigUpdate&&, RemoteConfigError) {}));
-}
-
 }  // namespace firebase_testapp_automated

remote_config/src/include/firebase/remote_config.h

@@ -24,8 +24,7 @@
 #include "firebase/future.h"
 #include "firebase/internal/common.h"
 #include "firebase/internal/platform.h"
-#include "remote_config/src/common.h"
-#include "remote_config/src/include/firebase/remote_config/config_update_listener_registration.h"
+#include "remote_config/config_update_listener_registration.h"
 #ifndef SWIG
 #include "firebase/variant.h"
 #endif  // SWIG

remote_config/src/include/firebase/remote_config/config_update_listener_registration.h

@@ -29,6 +29,12 @@ class ConfigUpdateListenerRegistration {
  public:
   ConfigUpdateListenerRegistration(std::function<void()> listener_removal_function);
 
+  /// @brief ConfigUpdateListenerRegistration constructor that takes in a
+  /// function as a parameter. The parameter function connects `Remove` to the
+  /// native platform's `Remove` method.
+  ConfigUpdateListenerRegistration(
+      std::function<void()> listener_removal_function);
+
   ~ConfigUpdateListenerRegistration();
 
   /// @brief The listener being tracked by this

remote_config/src/config_update_listener_registration.cc renamed to remote_config/src/ios/config_update_listener_registration.cc

@@ -17,13 +17,16 @@
 namespace firebase {
 namespace remote_config {
 
+ConfigUpdateListenerRegistration::ConfigUpdateListenerRegistration(
+    std::function<void()> listener_removal_function)
+    : listenerRemovalFunction(listener_removal_function) {}
+
 ConfigUpdateListenerRegistration::ConfigUpdateListenerRegistration(
     std::function<void()> listener_removal_function)
     : listenerRemovalFunction(listener_removal_function) {}
 
 ConfigUpdateListenerRegistration::~ConfigUpdateListenerRegistration() {}
 
-// TODO: almostmatt, merge this with quan's ios changes. also see about whether to make this no-op after first call
 void ConfigUpdateListenerRegistration::Remove() {
   this->listenerRemovalFunction();
 }

remote_config/src/ios/remote_config_ios.h

@@ -15,6 +15,8 @@
 #ifndef FIREBASE_REMOTE_CONFIG_SRC_IOS_REMOTE_CONFIG_IOS_H_
 #define FIREBASE_REMOTE_CONFIG_SRC_IOS_REMOTE_CONFIG_IOS_H_
 
+#include <functional>
+
 #include "firebase/app.h"
 #include "app/memory/unique_ptr.h"
 #include "app/src/reference_counted_future_impl.h"
@@ -86,8 +88,8 @@ class RemoteConfigInternal {
   const ConfigInfo GetInfo() const;
 
   ConfigUpdateListenerRegistration* AddOnConfigUpdateListener(
-      std::function<void(ConfigUpdate&&, RemoteConfigError)>
-          config_update_listener);
+    std::function<void(ConfigUpdate&&, RemoteConfigError)>
+        config_update_listener);
 
   bool Initialized() const;
 

remote_config/src/ios/remote_config_ios.mm

@@ -23,6 +23,7 @@
 #include "app/src/log.h"
 #include "app/src/time.h"
 #include "remote_config/src/common.h"
+#include "remote_config/src/include/firebase/remote_config.h"
 
 namespace firebase {
 namespace remote_config {
@@ -173,6 +174,30 @@ static void GetInfoFromFIRRemoteConfig(FIRRemoteConfig *rc_instance, ConfigInfo
   }
 }
 
+static RemoteConfigError ConvertFIRRemoteConfigUpdateError(NSError *error) {
+  switch(error.code) {
+    case FIRRemoteConfigUpdateErrorStreamError:
+      return kRemoteConfigErrorConfigUpdateStreamError;
+    case FIRRemoteConfigUpdateErrorNotFetched:
+      return kRemoteConfigErrorConfigUpdateNotFetched;
+    case FIRRemoteConfigUpdateErrorMessageInvalid:
+      return kRemoteConfigErrorConfigUpdateMessageInvalid;
+    case FIRRemoteConfigUpdateErrorUnavailable:
+      return kRemoteConfigErrorConfigUpdateUnavailable;
+    default:
+      return kRemoteConfigErrorUnimplemented;
+  }
+}
+
+static ConfigUpdate ConvertConfigUpdateKeys(NSSet<NSString *> *keys) {
+  ConfigUpdate configUpdate;
+
+  for (NSString *key in keys) {
+    configUpdate.updated_keys.push_back(util::NSStringToString(key).c_str());
+  }
+  return configUpdate;
+}
+
 namespace internal {
 RemoteConfigInternal::RemoteConfigInternal(const firebase::App &app)
     : app_(app), future_impl_(kRemoteConfigFnCount) {
@@ -492,8 +517,24 @@ static Variant FIRValueToVariant(FIRRemoteConfigValue *in_value, ValueInfo *valu
 
 ConfigUpdateListenerRegistration* RemoteConfigInternal::AddOnConfigUpdateListener(
       std::function<void(ConfigUpdate&&, RemoteConfigError)>
-          config_update_listener) {
-            return nullptr;
+        config_update_listener) {
+    FIRConfigUpdateListenerRegistration *registration;
+    registration = [impl() addOnConfigUpdateListener: ^(FIRRemoteConfigUpdate *_Nullable update,
+                                  NSError *_Nullable error) {
+          if (error) {
+            config_update_listener({}, ConvertFIRRemoteConfigUpdateError(error));
+            return;
+          }
+
+          config_update_listener(ConvertConfigUpdateKeys(update.updatedKeys), kRemoteConfigErrorNone);
+    }];
+
+    ConfigUpdateListenerRegistration *registrationWrapper =
+      new ConfigUpdateListenerRegistration([registration]() {
+        [registration remove];
+      });
+
+    return registrationWrapper;
 }
 }  // namespace internal
 }  // namespace remote_config