Here's what I've done to add SetDefaultEventParameters and ClearDefaultEventParameters to Analytics.

This change introduces two new C++ Analytics SDK functions:
- `SetDefaultEventParameters(const std::map<std::string, firebase::Variant>& params)`:
  This allows you to set default parameters (string, int64, double, bool, null)
  that will be included in all subsequent `LogEvent` calls.
  If a `firebase::Variant::Null()` is provided for a key, that specific
  default parameter will be cleared. Aggregate types (maps, vectors) are not
  supported and will be skipped with an error logged.
- `ClearDefaultEventParameters()`: This clears all currently set default event
  parameters.

Platform implementations:
- iOS: Uses `[FIRAnalytics setDefaultEventParameters:]`. `firebase::Variant::Null()`
  maps to `[NSNull null]`. Unsupported types are skipped.
- Android: Uses `FirebaseAnalytics.setDefaultEventParameters(Bundle)`.
  `firebase::Variant::Null()` results in `Bundle.putString(key, null)`.
  Unsupported types are skipped. `AddVariantToBundle` is used for efficiency
  with scalar types.
- Stub: Implemented as no-ops.

I've reviewed and updated the unit tests and integration tests to cover these
functionalities and type constraints.

Namespace usage for `Variant` has been refined:
- Public API (`analytics.h`) and integration tests use `firebase::Variant`.
- Internal SDK implementation code uses unqualified `Variant` where appropriate,
  relying on the enclosing `firebase` namespace.

I've also applied code formatting using the project's script and updated and shortened the release notes in `release_build_files/readme.md`.

Author: google-labs-jules[bot]

analytics/src/analytics_android.cc

@@ -380,18 +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<firebase::Variant, firebase::Variant>& map);
+jobject MapToBundle(JNIEnv* env, const std::map<Variant, 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<firebase::Variant>& vector) {
+                                const std::vector<Variant>& vector) {
   jobject arraylist = env->NewObject(
       util::array_list::GetClass(),
       util::array_list::GetMethodId(util::array_list::kConstructor));
 
-  for (const firebase::Variant& element : vector) {
+  for (const Variant& element : vector) {
     if (element.is_map()) {
       jobject bundle = MapToBundle(env, element.map());
       env->CallBooleanMethod(
@@ -401,15 +400,15 @@ jobject VectorOfMapsToArrayList(JNIEnv* env,
       env->DeleteLocalRef(bundle);
     } else {
       LogError("VectorOfMapsToArrayList: Unsupported type (%s) within vector.",
-               firebase::Variant::TypeName(element.type()));
+               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 firebase::Variant& value) {
+                        const Variant& value) {
   if (value.is_int64()) {
     AddToBundle(env, bundle, key, value.int64_value());
   } else if (value.is_double()) {
@@ -441,8 +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<firebase::Variant, firebase::Variant>& map) {
+jobject MapToBundle(JNIEnv* env, const std::map<Variant, Variant>& map) {
   jobject bundle =
       env->NewObject(util::bundle::GetClass(),
                      util::bundle::GetMethodId(util::bundle::kConstructor));
@@ -454,7 +452,7 @@ jobject MapToBundle(JNIEnv* env,
     if (!AddVariantToBundle(env, bundle, pair.first.string_value(),
                             pair.second)) {
       LogError("MapToBundle: Unsupported type (%s) within map with key %s.",
-               firebase::Variant::TypeName(pair.second.type()),
+               Variant::TypeName(pair.second.type()),
                pair.first.string_value());
     }
     util::CheckAndClearJniExceptions(env);
@@ -630,7 +628,7 @@ void SetDefaultEventParameters(
   }
 
   for (const auto& pair : default_parameters) {
-    const firebase::Variant& value = pair.second;
+    const Variant& value = pair.second;
     const char* key_cstr = pair.first.c_str();
 
     if (value.is_null()) {
@@ -665,21 +663,21 @@ void SetDefaultEventParameters(
             "SetDefaultEventParameters: Failed to add parameter for key '%s' "
             "with supported type '%s'. This might indicate a JNI issue during "
             "conversion.",
-            key_cstr, firebase::Variant::TypeName(value.type()));
+            key_cstr, Variant::TypeName(value.type()));
       }
     } else if (value.is_vector() || value.is_map()) {
       LogError(
           "SetDefaultEventParameters: Value for key '%s' has type '%s' which "
           "is not supported for default event parameters. Only string, int64, "
           "double, bool, and null are supported. Skipping.",
-          key_cstr, firebase::Variant::TypeName(value.type()));
+          key_cstr, Variant::TypeName(value.type()));
     } else {
       // This case handles other fundamental Variant types that are not scalars
       // and not vector/map.
       LogError(
           "SetDefaultEventParameters: Value for key '%s' has an unexpected and "
           "unsupported type '%s'. Skipping.",
-          key_cstr, firebase::Variant::TypeName(value.type()));
+          key_cstr, Variant::TypeName(value.type()));
     }
   }
 

analytics/src/analytics_ios.mm

@@ -232,26 +232,25 @@ void LogEvent(const char* name) {
 }
 
 // Declared here so that it can be used, defined below.
-NSDictionary* MapToDictionary(const std::map<firebase::Variant, firebase::Variant>& map);
+NSDictionary* MapToDictionary(const std::map<Variant, Variant>& map);
 
 // Converts the given vector of Maps into an ObjC NSArray of ObjC NSDictionaries.
-NSArray* VectorOfMapsToArray(const std::vector<firebase::Variant>& vector) {
+NSArray* VectorOfMapsToArray(const std::vector<Variant>& vector) {
   NSMutableArray* array = [NSMutableArray arrayWithCapacity:vector.size()];
-  for (const firebase::Variant& element : vector) {
+  for (const Variant& element : vector) {
     if (element.is_map()) {
       NSDictionary* dict = MapToDictionary(element.map());
       [array addObject:dict];
     } else {
       LogError("VectorOfMapsToArray: Unsupported type (%s) within vector.",
-               firebase::Variant::TypeName(element.type()));
+               Variant::TypeName(element.type()));
     }
   }
   return array;
 }
 
 // Converts and adds the Variant to the given Dictionary.
-bool AddVariantToDictionary(NSMutableDictionary* dict, NSString* key,
-                            const firebase::Variant& value) {
+bool AddVariantToDictionary(NSMutableDictionary* dict, NSString* key, const Variant& value) {
   if (value.is_int64()) {
     [dict setObject:[NSNumber numberWithLongLong:value.int64_value()] forKey:key];
   } else if (value.is_double()) {
@@ -278,18 +277,18 @@ bool AddVariantToDictionary(NSMutableDictionary* dict, NSString* key,
 }
 
 // Converts the given map into an ObjC dictionary of ObjC objects.
-NSDictionary* MapToDictionary(const std::map<firebase::Variant, firebase::Variant>& map) {
+NSDictionary* MapToDictionary(const std::map<Variant, 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 firebase::Variant& value = pair.second;
+    const Variant& value = pair.second;
     if (!AddVariantToDictionary(dict, key, value)) {
       LogError("MapToDictionary: Unsupported type (%s) within map with key %s.",
-               firebase::Variant::TypeName(value.type()), key);
+               Variant::TypeName(value.type()), key);
     }
   }
   return dict;
@@ -380,7 +379,7 @@ void SetDefaultEventParameters(const std::map<std::string, firebase::Variant>& d
       [[NSMutableDictionary alloc] initWithCapacity:default_parameters.size()];
   for (const auto& pair : default_parameters) {
     NSString* key = SafeString(pair.first.c_str());
-    const firebase::Variant& value = pair.second;
+    const Variant& value = pair.second;
 
     if (value.is_null()) {
       [ns_default_parameters setObject:[NSNull null] forKey:key];
@@ -397,11 +396,11 @@ void SetDefaultEventParameters(const std::map<std::string, firebase::Variant>& d
       LogError("SetDefaultEventParameters: Value for key '%s' has type '%s' which is not supported "
                "for default event parameters. Only string, int64, double, bool, and null are "
                "supported. Skipping.",
-               pair.first.c_str(), firebase::Variant::TypeName(value.type()));
+               pair.first.c_str(), Variant::TypeName(value.type()));
     } else {
       LogError("SetDefaultEventParameters: Value for key '%s' has an unexpected type '%s' which is "
                "not supported. Skipping.",
-               pair.first.c_str(), firebase::Variant::TypeName(value.type()));
+               pair.first.c_str(), Variant::TypeName(value.type()));
     }
   }
   [FIRAnalytics setDefaultEventParameters:ns_default_parameters];

analytics/src/analytics_stub.cc

@@ -143,7 +143,7 @@ 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());
   // This is a stub implementation. No operation needed.
 }