Add SetDefaultEventParameters and ClearDefaultEventParameters to Analytics

This change introduces two new C++ Analytics SDK functions:
- `SetDefaultEventParameters(const std::map<std::string, firebase::Variant>& params)`: Allows setting default parameters that will be included in all subsequent `LogEvent` calls. If a `firebase::Variant::Null()` is provided as a value for a key, that specific default parameter will be cleared/removed.
- `ClearDefaultEventParameters()`: Clears all currently set default event parameters.

Platform implementations:
- iOS: Uses `[FIRAnalytics setDefaultEventParameters:]`. `firebase::Variant::Null()` maps to `[NSNull null]` for clearing individual parameters. Calling with `nil` clears all.
- Android: Uses `FirebaseAnalytics.setDefaultEventParameters(Bundle)`. `firebase::Variant::Null()` results in `Bundle.putString(key, null)`. Calling with a `null` Bundle clears all.
- Stub: Implemented as no-ops.

Unit tests and integration tests have been updated to cover these new functionalities, including the null-value handling for clearing specific parameters and the overall clearing of all parameters.

Author: google-labs-jules[bot]

analytics/integration_test/src/integration_test.cc

@@ -344,7 +344,7 @@ TEST_F(FirebaseAnalyticsTest, TestSetConsent) {
 TEST_F(FirebaseAnalyticsTest, TestDefaultEventParametersUsage) {
   LogInfo("Testing SetDefaultEventParameters with initial values, then updating with Null.");
 
-  std::map<std::string, firebase::analytics::Variant> initial_defaults;
+  std::map<std::string, firebase::Variant> initial_defaults;
   initial_defaults["initial_key"] = "initial_value";
   initial_defaults["key_to_be_nulled"] = "text_before_null";
   initial_defaults["numeric_default"] = 12345LL;
@@ -356,8 +356,8 @@ TEST_F(FirebaseAnalyticsTest, TestDefaultEventParametersUsage) {
   LogInfo("Logged event_with_initial_defaults.");
   ProcessEvents(500); // Short pause for event logging, if it matters for backend.
 
-  std::map<std::string, firebase::analytics::Variant> updated_defaults;
-  updated_defaults["key_to_be_nulled"] = firebase::analytics::Variant::Null();
+  std::map<std::string, firebase::Variant> updated_defaults;
+  updated_defaults["key_to_be_nulled"] = firebase::Variant::Null();
   updated_defaults["another_key"] = "another_value";
   // "initial_key" should persist if not overwritten.
   // "numeric_default" should persist.
@@ -377,7 +377,7 @@ TEST_F(FirebaseAnalyticsTest, TestDefaultEventParametersUsage) {
 TEST_F(FirebaseAnalyticsTest, TestClearDefaultEventParametersFunctionality) {
   LogInfo("Testing ClearDefaultEventParameters.");
 
-  std::map<std::string, firebase::analytics::Variant> defaults_to_clear;
+  std::map<std::string, firebase::Variant> defaults_to_clear;
   defaults_to_clear["default_one"] = "will_be_cleared";
   defaults_to_clear["default_two"] = 9876LL;
 

analytics/src/analytics_android.cc

@@ -380,17 +380,17 @@ void AddBundleToBundle(JNIEnv* env, jobject bundle, const char* key,
 }
 
 // Declared here so that it can be used, defined below.
-jobject MapToBundle(JNIEnv* env, const std::map<Variant, Variant>& map);
+jobject MapToBundle(JNIEnv* env, const std::map<firebase::Variant, firebase::Variant>& map);
 
 // Converts the given vector into a Java ArrayList. It is up to the
 // caller to delete the local reference when done.
 jobject VectorOfMapsToArrayList(JNIEnv* env,
-                                const std::vector<Variant>& vector) {
+                                const std::vector<firebase::Variant>& vector) {
   jobject arraylist = env->NewObject(
       util::array_list::GetClass(),
       util::array_list::GetMethodId(util::array_list::kConstructor));
 
-  for (const Variant& element : vector) {
+  for (const firebase::Variant& element : vector) {
     if (element.is_map()) {
       jobject bundle = MapToBundle(env, element.map());
       env->CallBooleanMethod(
@@ -400,15 +400,15 @@ jobject VectorOfMapsToArrayList(JNIEnv* env,
       env->DeleteLocalRef(bundle);
     } else {
       LogError("VectorOfMapsToArrayList: Unsupported type (%s) within vector.",
-               Variant::TypeName(element.type()));
+               firebase::Variant::TypeName(element.type()));
     }
   }
   return arraylist;
 }
 
 // Converts and adds the Variant to the given Bundle.
 bool AddVariantToBundle(JNIEnv* env, jobject bundle, const char* key,
-                        const Variant& value) {
+                        const firebase::Variant& value) {
   if (value.is_int64()) {
     AddToBundle(env, bundle, key, value.int64_value());
   } else if (value.is_double()) {
@@ -440,7 +440,7 @@ bool AddVariantToBundle(JNIEnv* env, jobject bundle, const char* key,
 
 // Converts the given map into a Java Bundle. It is up to the caller
 // to delete the local reference when done.
-jobject MapToBundle(JNIEnv* env, const std::map<Variant, Variant>& map) {
+jobject MapToBundle(JNIEnv* env, const std::map<firebase::Variant, firebase::Variant>& map) {
   jobject bundle =
       env->NewObject(util::bundle::GetClass(),
                      util::bundle::GetMethodId(util::bundle::kConstructor));
@@ -452,7 +452,7 @@ jobject MapToBundle(JNIEnv* env, const std::map<Variant, Variant>& map) {
     if (!AddVariantToBundle(env, bundle, pair.first.string_value(),
                             pair.second)) {
       LogError("MapToBundle: Unsupported type (%s) within map with key %s.",
-               Variant::TypeName(pair.second.type()),
+               firebase::Variant::TypeName(pair.second.type()),
                pair.first.string_value());
     }
     util::CheckAndClearJniExceptions(env);
@@ -514,7 +514,7 @@ void LogEvent(const char* name, const Parameter* parameters,
         LogError(
             "LogEvent(%s): %s is not a valid parameter value type. "
             "No event was logged.",
-            parameter.name, Variant::TypeName(parameter.value.type()));
+            parameter.name, firebase::Variant::TypeName(parameter.value.type()));
       }
     }
   });
@@ -612,7 +612,7 @@ void ResetAnalyticsData() {
 }
 
 void SetDefaultEventParameters(
-    const std::map<std::string, Variant>& default_parameters) {
+    const std::map<std::string, firebase::Variant>& default_parameters) {
   FIREBASE_ASSERT_RETURN_VOID(internal::IsInitialized());
   JNIEnv* env = g_app->GetJNIEnv();
   if (!env) return;

analytics/src/analytics_ios.mm

@@ -232,25 +232,25 @@ void LogEvent(const char* name) {
 }
 
 // Declared here so that it can be used, defined below.
-NSDictionary* MapToDictionary(const std::map<Variant, Variant>& map);
+NSDictionary* MapToDictionary(const std::map<firebase::Variant, firebase::Variant>& map);
 
 // Converts the given vector of Maps into an ObjC NSArray of ObjC NSDictionaries.
-NSArray* VectorOfMapsToArray(const std::vector<Variant>& vector) {
+NSArray* VectorOfMapsToArray(const std::vector<firebase::Variant>& vector) {
   NSMutableArray* array = [NSMutableArray arrayWithCapacity:vector.size()];
-  for (const Variant& element : vector) {
+  for (const firebase::Variant& element : vector) {
     if (element.is_map()) {
       NSDictionary* dict = MapToDictionary(element.map());
       [array addObject:dict];
     } else {
       LogError("VectorOfMapsToArray: Unsupported type (%s) within vector.",
-               Variant::TypeName(element.type()));
+               firebase::Variant::TypeName(element.type()));
     }
   }
   return array;
 }
 
 // Converts and adds the Variant to the given Dictionary.
-bool AddVariantToDictionary(NSMutableDictionary* dict, NSString* key, const Variant& value) {
+bool AddVariantToDictionary(NSMutableDictionary* dict, NSString* key, const firebase::Variant& value) {
   if (value.is_int64()) {
     [dict setObject:[NSNumber numberWithLongLong:value.int64_value()] forKey:key];
   } else if (value.is_double()) {
@@ -277,18 +277,18 @@ bool AddVariantToDictionary(NSMutableDictionary* dict, NSString* key, const Vari
 }
 
 // Converts the given map into an ObjC dictionary of ObjC objects.
-NSDictionary* MapToDictionary(const std::map<Variant, Variant>& map) {
+NSDictionary* MapToDictionary(const std::map<firebase::Variant, firebase::Variant>& map) {
   NSMutableDictionary* dict = [NSMutableDictionary dictionaryWithCapacity:map.size()];
   for (const auto& pair : map) {
     // Only add elements that use a string key
     if (!pair.first.is_string()) {
       continue;
     }
     NSString* key = SafeString(pair.first.string_value());
-    const Variant& value = pair.second;
+    const firebase::Variant& value = pair.second;
     if (!AddVariantToDictionary(dict, key, value)) {
       LogError("MapToDictionary: Unsupported type (%s) within map with key %s.",
-               Variant::TypeName(value.type()), key);
+               firebase::Variant::TypeName(value.type()), key);
     }
   }
   return dict;
@@ -306,7 +306,7 @@ void LogEvent(const char* name, const Parameter* parameters, size_t number_of_pa
       // A Variant type that couldn't be handled was passed in.
       LogError("LogEvent(%s): %s is not a valid parameter value type. "
                "No event was logged.",
-               parameter.name, Variant::TypeName(parameter.value.type()));
+               parameter.name, firebase::Variant::TypeName(parameter.value.type()));
     }
   }
   [FIRAnalytics logEventWithName:@(name) parameters:parameters_dict];
@@ -374,13 +374,13 @@ void SetSessionTimeoutDuration(int64_t milliseconds) {
 }
 
 void SetDefaultEventParameters(
-    const std::map<std::string, Variant>& default_parameters) {
+    const std::map<std::string, firebase::Variant>& default_parameters) {
   FIREBASE_ASSERT_RETURN_VOID(internal::IsInitialized());
   NSMutableDictionary* ns_default_parameters =
       [[NSMutableDictionary alloc] initWithCapacity:default_parameters.size()];
   for (const auto& pair : default_parameters) {
     NSString* key = SafeString(pair.first.c_str());
-    const Variant& value = pair.second;
+    const firebase::Variant& value = pair.second;
 
     if (value.is_null()) {
       [ns_default_parameters setObject:[NSNull null] forKey:key];
@@ -398,7 +398,7 @@ void SetDefaultEventParameters(
       // It does not support nested collections (NSArray, NSDictionary) unlike LogEvent.
       LogError("SetDefaultEventParameters: Unsupported Variant type (%s) for key %s. "
                "Only Int64, Double, String, Bool, and Null are supported for default event parameters.",
-               Variant::TypeName(value.type()), pair.first.c_str());
+               firebase::Variant::TypeName(value.type()), pair.first.c_str());
     }
   }
   [FIRAnalytics setDefaultEventParameters:ns_default_parameters];

analytics/src/include/firebase/analytics.h

@@ -142,7 +142,7 @@ struct Parameter {
   /// @param parameter_name Name of the parameter (see Parameter::name).
   /// @param parameter_value Value for the parameter. Variants can
   /// hold numbers and strings.
-  Parameter(const char* parameter_name, Variant parameter_value)
+  Parameter(const char* parameter_name, firebase::Variant parameter_value)
       : name(parameter_name) {
     value = parameter_value;
   }
@@ -245,7 +245,7 @@ struct Parameter {
   ///
   /// See firebase::Variant for usage information.
   /// @note String values can be up to 100 characters long.
-  Variant value;
+  firebase::Variant value;
 #endif  // SWIG
 };
 
@@ -570,7 +570,7 @@ void ResetAnalyticsData();
 ///
 /// @param[in] default_parameters A map of parameter names to Variant values.
 void SetDefaultEventParameters(
-    const std::map<std::string, Variant>& default_parameters);
+    const std::map<std::string, firebase::Variant>& default_parameters);
 
 /// @brief Clears all default event parameters.
 void ClearDefaultEventParameters();