Update so that null is handled for removing keys.

Add ClearDefaultEventParameters since we can't pass in null.

Author: jonsimantov

analytics/integration_test/src/integration_test.cc

@@ -341,26 +341,32 @@ TEST_F(FirebaseAnalyticsTest, TestSetConsent) {
   did_test_setconsent_ = true;
 }
 
-// Test that it compiles and runs on all platforms.
 TEST_F(FirebaseAnalyticsTest, TestSetDefaultEventParameters) {
   LogInfo("Testing SetDefaultEventParameters().");
 
-  // Set some default parameters.
+  // Set some default parameters with various types.
   std::map<std::string, firebase::Variant> defaults;
-  defaults["default_int"] = 123;
-  defaults["default_string"] = "default_value";
+  defaults["default_int"] = static_cast<int64_t>(123);  // int64_t
+  defaults["default_double"] = 45.67;                   // double
+  defaults["default_bool"] = true;                      // bool
+  defaults["default_string"] = "test_string_value";     // const char*
+  defaults["default_to_clear"] = "will_be_cleared";     // Another string
+
   firebase::analytics::SetDefaultEventParameters(defaults);
+  LogInfo("Set initial default parameters.");
 
   // Log an event - the defaults should be included automatically by the
   // underlying SDK if logging immediately after setting is supported.
   // Verification might need manual checking in the Analytics console or
   // via platform-specific debug logs if possible.
-  firebase::analytics::LogEvent("event_with_defaults");
-  LogInfo("Logged event_with_defaults");
+  firebase::analytics::LogEvent("event_with_mixed_defaults");
+  LogInfo("Logged event_with_mixed_defaults");
 
-  // Clear one default parameter by setting it to null.
-  defaults["default_int"] = firebase::Variant::Null();
+  // Clear one default parameter and update another.
+  defaults["default_to_clear"] = firebase::Variant::Null();  // Clear this one
+  defaults["default_int"] = static_cast<int64_t>(999);       // Update this one
   firebase::analytics::SetDefaultEventParameters(defaults);
+  LogInfo("Cleared one parameter and updated another.");
 
   // Log another event.
   firebase::analytics::LogEvent("event_with_one_default_cleared");
@@ -369,22 +375,36 @@ TEST_F(FirebaseAnalyticsTest, TestSetDefaultEventParameters) {
   // Set only one parameter, clearing others implicitly if underlying SDK works
   // like that
   std::map<std::string, firebase::Variant> single_default;
-  single_default["only_this"] = 45.6;
+  single_default["only_this_double"] = 78.9;
   firebase::analytics::SetDefaultEventParameters(single_default);
-  firebase::analytics::LogEvent("event_with_only_one_default");
+  LogInfo("Set a single different default parameter.");
+  firebase::analytics::LogEvent(
+      "event_with_only_one_default");  // Changed log event name slightly
   LogInfo("Logged event_with_only_one_default");
 
-  // Clear all defaults by passing an empty map.
-  std::map<std::string, firebase::Variant> empty_defaults;
-  firebase::analytics::SetDefaultEventParameters(empty_defaults);
-
-  // Log an event with no defaults.
-  firebase::analytics::LogEvent("event_with_no_defaults");
-  LogInfo("Logged event_with_no_defaults");
-
   // If we reach here without crashing, consider the basic test passed for the
   // C++ layer. Deeper verification requires platform tools.
   LogInfo("SetDefaultEventParameters() tests completed.");
 }
 
+TEST_F(FirebaseAnalyticsTest, TestClearDefaultEventParameters) {
+  LogInfo("Testing ClearDefaultEventParameters().");
+
+  // Set some defaults first.
+  std::map<std::string, firebase::Variant> defaults;
+  defaults["temp_default"] = "will_be_cleared";
+  firebase::analytics::SetDefaultEventParameters(defaults);
+
+  // Now clear them all.
+  firebase::analytics::ClearDefaultEventParameters();
+
+  // Log an event - no defaults should be included.
+  firebase::analytics::LogEvent("event_after_clear_defaults");
+  LogInfo("Logged event_after_clear_defaults");
+
+  // If we reach here without crashing, consider the basic test passed for the
+  // C++ layer.
+  LogInfo("ClearDefaultEventParameters() test completed.");
+}
+
 }  // namespace firebase_testapp_automated

analytics/src/analytics_android.cc

@@ -530,12 +530,22 @@ jobject StringVariantMapToBundle(JNIEnv* env,
     // Bundle keys must be strings.
     const char* key = pair.first.c_str();
     const Variant& value = pair.second;
-    // AddVariantToBundle handles all Variant types, including null.
-    if (!AddVariantToBundle(env, bundle, key, value)) {
+    // A null variant clears the default parameter for that key.
+    // The Android SDK uses Bundle.putString(key, null) for this.
+    if (value.is_null()) {
+      jstring key_string = env->NewStringUTF(key);
+      // Call Bundle.putString(key, null)
+      env->CallVoidMethod(bundle,
+                          util::bundle::GetMethodId(util::bundle::kPutString),
+                          key_string, nullptr);
+      util::CheckAndClearJniExceptions(env);
+      env->DeleteLocalRef(key_string);
+    } else if (!AddVariantToBundle(env, bundle, key, value)) {
       LogError("SetDefaultEventParameters: Unsupported type (%s) for key %s.",
                Variant::TypeName(value.type()), key);
     }
-    // CheckAndClearJniExceptions is called within AddVariantToBundle.
+    // CheckAndClearJniExceptions is called within AddVariantToBundle or above
+    // for the null case.
   }
   return bundle;
 }
@@ -555,6 +565,19 @@ void SetDefaultEventParameters(
   env->DeleteLocalRef(bundle);
 }
 
+void ClearDefaultEventParameters() {
+  FIREBASE_ASSERT_RETURN_VOID(internal::IsInitialized());
+  JNIEnv* env = g_app->GetJNIEnv();
+
+  // Call FirebaseAnalytics.setDefaultEventParameters(null)
+  env->CallVoidMethod(
+      g_analytics_class_instance,
+      analytics::GetMethodId(analytics::kSetDefaultEventParameters),
+      nullptr);  // Pass null Bundle to clear all parameters
+
+  util::CheckAndClearJniExceptions(env);
+}
+
 /// Initiates on-device conversion measurement given a user email address on iOS
 /// (no-op on Android). On iOS, requires dependency
 /// GoogleAppMeasurementOnDeviceConversion to be linked in, otherwise it is a

analytics/src/analytics_ios.mm

@@ -322,10 +322,15 @@ void SetDefaultEventParameters(const std::map<std::string, Variant>& default_par
     NSString* key = firebase::util::StringToNSString(pair.first);
     // A null Variant indicates the default parameter should be cleared.
     // In ObjC, setting a key to [NSNull null] in the dictionary achieves this.
+    // A null Variant indicates the default parameter for that key should be
+    // cleared. In ObjC, setting a key to [NSNull null] in the dictionary
+    // achieves this.
     id value = pair.second.is_null() ? [NSNull null] : firebase::util::VariantToId(pair.second);
     if (value) {
       [parameters_dict setObject:value forKey:key];
     } else {
+      // VariantToId could return nil if the variant type is unsupported.
+      // Log an error but continue, as NSNull case is handled above.
       LogError("SetDefaultEventParameters: Failed to convert value for key %s.",
                pair.first.c_str());
     }
@@ -334,6 +339,12 @@ void SetDefaultEventParameters(const std::map<std::string, Variant>& default_par
   [FIRAnalytics setDefaultEventParameters:parameters_dict];
 }
 
+void ClearDefaultEventParameters() {
+  FIREBASE_ASSERT_RETURN_VOID(internal::IsInitialized());
+  // Passing nil to the underlying SDK method clears all parameters.
+  [FIRAnalytics setDefaultEventParameters:nil];
+}
+
 /// Initiates on-device conversion measurement given a user email address on iOS (no-op on
 /// Android). On iOS, requires dependency GoogleAppMeasurementOnDeviceConversion to be linked
 /// in, otherwise it is a no-op.

analytics/src/analytics_stub.cc

@@ -103,6 +103,11 @@ void SetDefaultEventParameters(
   // No-op on stub.
 }
 
+void ClearDefaultEventParameters() {
+  FIREBASE_ASSERT_RETURN_VOID(internal::IsInitialized());
+  // No-op on stub.
+}
+
 /// Initiates on-device conversion measurement given a user email address on iOS
 /// (no-op on Android). On iOS, requires dependency
 /// GoogleAppMeasurementOnDeviceConversion to be linked in, otherwise it is a

analytics/src/include/firebase/analytics.h

@@ -483,10 +483,14 @@ void LogEvent(const char* name, const Parameter* parameters,
 /// The same limitations apply to these parameters as are documented for
 /// `LogEvent`.
 /// @param[in] default_parameters Map of default parameter names and values.
-/// Passing a null value for a parameter name clears the default parameter.
+/// Passing a null `Variant` value for a parameter name clears the default
+/// parameter for that key.
 void SetDefaultEventParameters(
     const std::map<std::string, Variant>& default_parameters);
 
+/// @brief Clears all default event parameters.
+void ClearDefaultEventParameters();
+
 /// Initiates on-device conversion measurement given a user email address on iOS
 /// and tvOS (no-op on Android). On iOS and tvOS, this method requires the
 /// dependency GoogleAppMeasurementOnDeviceConversion to be linked in,