Add default params

analytics/integration_test/src/integration_test.cc

@@ -341,4 +341,50 @@ 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.
+  std::map<std::string, firebase::Variant> defaults;
+  defaults["default_int"] = 123;
+  defaults["default_string"] = "default_value";
+  firebase::analytics::SetDefaultEventParameters(defaults);
+
+  // 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");
+
+  // Clear one default parameter by setting it to null.
+  defaults["default_int"] = firebase::Variant::Null();
+  firebase::analytics::SetDefaultEventParameters(defaults);
+
+  // Log another event.
+  firebase::analytics::LogEvent("event_with_one_default_cleared");
+  LogInfo("Logged event_with_one_default_cleared");
+
+  // 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;
+  firebase::analytics::SetDefaultEventParameters(single_default);
+  firebase::analytics::LogEvent("event_with_only_one_default");
+  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.");
+}
+
 }  // namespace firebase_testapp_automated

analytics/src/analytics_android.cc

@@ -58,6 +58,8 @@ static const ::firebase::App* g_app = nullptr;
     "()Lcom/google/android/gms/tasks/Task;"),                                 \
   X(GetSessionId, "getSessionId",                                             \
     "()Lcom/google/android/gms/tasks/Task;"),                                 \
+  X(SetDefaultEventParameters, "setDefaultEventParameters",                   \
+    "(Landroid/os/Bundle;)V"),                                                \
   X(GetInstance, "getInstance", "(Landroid/content/Context;)"                 \
     "Lcom/google/firebase/analytics/FirebaseAnalytics;",                      \
     firebase::util::kMethodTypeStatic)
@@ -518,6 +520,41 @@ void LogEvent(const char* name, const Parameter* parameters,
   });
 }
 
+// Convert std::map<std::string, Variant> to Bundle.
+jobject StringVariantMapToBundle(JNIEnv* env,
+                                 const std::map<std::string, Variant>& map) {
+  jobject bundle =
+      env->NewObject(util::bundle::GetClass(),
+                     util::bundle::GetMethodId(util::bundle::kConstructor));
+  for (const auto& pair : map) {
+    // 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)) {
+      LogError("SetDefaultEventParameters: Unsupported type (%s) for key %s.",
+               Variant::TypeName(value.type()), key);
+    }
+    // CheckAndClearJniExceptions is called within AddVariantToBundle.
+  }
+  return bundle;
+}
+
+void SetDefaultEventParameters(
+    const std::map<std::string, Variant>& default_parameters) {
+  FIREBASE_ASSERT_RETURN_VOID(internal::IsInitialized());
+  JNIEnv* env = g_app->GetJNIEnv();
+
+  jobject bundle = StringVariantMapToBundle(env, default_parameters);
+
+  env->CallVoidMethod(
+      g_analytics_class_instance,
+      analytics::GetMethodId(analytics::kSetDefaultEventParameters), bundle);
+
+  util::CheckAndClearJniExceptions(env);
+  env->DeleteLocalRef(bundle);
+}
+
 /// 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

@@ -312,6 +312,28 @@ void LogEvent(const char* name, const Parameter* parameters, size_t number_of_pa
   [FIRAnalytics logEventWithName:@(name) parameters:parameters_dict];
 }
 
+void SetDefaultEventParameters(const std::map<std::string, Variant>& default_parameters) {
+  FIREBASE_ASSERT_RETURN_VOID(internal::IsInitialized());
+  // Convert the std::map<std::string, Variant> to NSDictionary*
+  // The keys must be strings for FIRAnalytics.
+  NSMutableDictionary* parameters_dict =
+      [NSMutableDictionary dictionaryWithCapacity:default_parameters.size()];
+  for (const auto& pair : default_parameters) {
+    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.
+    id value = pair.second.is_null() ? [NSNull null] : firebase::util::VariantToId(pair.second);
+    if (value) {
+      [parameters_dict setObject:value forKey:key];
+    } else {
+      LogError("SetDefaultEventParameters: Failed to convert value for key %s.",
+               pair.first.c_str());
+    }
+  }
+
+  [FIRAnalytics setDefaultEventParameters:parameters_dict];
+}
+
 /// 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

@@ -97,6 +97,12 @@ void LogEvent(const char* /*name*/, const Parameter* /*parameters*/,
   FIREBASE_ASSERT_RETURN_VOID(internal::IsInitialized());
 }
 
+void SetDefaultEventParameters(
+    const std::map<std::string, Variant>& default_parameters) {
+  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

@@ -476,6 +476,17 @@ void LogEvent(const char* name);
 void LogEvent(const char* name, const Parameter* parameters,
               size_t number_of_parameters);
 
+/// @brief Sets default event parameters for this app.
+///
+/// This specifies parameters to be included with every subsequent call to
+/// `LogEvent`, in addition to the parameters passed to `LogEvent`.
+/// 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.
+void SetDefaultEventParameters(
+    const std::map<std::string, Variant>& default_parameters);
+
 /// 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,

release_build_files/readme.md

@@ -631,6 +631,11 @@ workflow use only during the development of your app, not for publicly shipping
 code.
 
 ## Release Notes
+### Upcoming Release
+-   Changes
+    - Analytics: Add SetDefaultEventParams to set default parameters for
+      all LogEvent calls.
+
 ### 12.7.0
 -   Changes
     - General (iOS): Update to Firebase Cocoapods version 11.10.0.