@react-native-firebase/analytics 23.8.0 → 23.8.2

package/RNFBAnalytics.podspec

@@ -0,0 +1,71 @@
+require 'json'
+package = JSON.parse(File.read(File.join(__dir__, 'package.json')))
+appPackage = JSON.parse(File.read(File.join('..', 'app', 'package.json')))
+
+coreVersionDetected = appPackage['version']
+coreVersionRequired = package['peerDependencies'][appPackage['name']]
+firebase_sdk_version = appPackage['sdkVersions']['ios']['firebase']
+if coreVersionDetected != coreVersionRequired
+  Pod::UI.warn "NPM package '#{package['name']}' depends on '#{appPackage['name']}' v#{coreVersionRequired} but found v#{coreVersionDetected}, this might cause build issues or runtime crashes."
+end
+firebase_ios_target = appPackage['sdkVersions']['ios']['iosTarget']
+firebase_macos_target = appPackage['sdkVersions']['ios']['macosTarget']
+firebase_tvos_target = appPackage['sdkVersions']['ios']['tvosTarget']
+
+Pod::Spec.new do |s|
+  s.name                = "RNFBAnalytics"
+  s.version             = package["version"]
+  s.description         = package["description"]
+  s.summary             = <<-DESC
+                            A well tested feature rich Firebase implementation for React Native, supporting iOS & Android.
+                          DESC
+  s.homepage            = "http://invertase.io/oss/react-native-firebase"
+  s.license             = package['license']
+  s.authors             = "Invertase Limited"
+  s.source              = { :git => "https://github.com/invertase/react-native-firebase.git", :tag => "v#{s.version}" }
+  s.social_media_url    = 'http://twitter.com/invertaseio'
+  s.ios.deployment_target = firebase_ios_target
+  s.macos.deployment_target = firebase_macos_target
+  s.tvos.deployment_target = firebase_tvos_target
+  s.source_files        = 'ios/**/*.{h,m}'
+
+  # React Native dependencies
+  s.dependency          'React-Core'
+  s.dependency          'RNFBApp'
+
+  if defined?($FirebaseSDKVersion)
+    Pod::UI.puts "#{s.name}: Using user specified Firebase SDK version '#{$FirebaseSDKVersion}'"
+    firebase_sdk_version = $FirebaseSDKVersion
+  end
+
+  # Firebase dependencies
+  s.dependency          'FirebaseAnalytics/Core', firebase_sdk_version
+  if defined?($RNFirebaseAnalyticsWithoutAdIdSupport) && ($RNFirebaseAnalyticsWithoutAdIdSupport == true)
+    Pod::UI.puts "#{s.name}: Not installing FirebaseAnalytics/IdentitySupport Pod, no IDFA will be collected."
+  else
+    if !defined?($RNFirebaseAnalyticsWithoutAdIdSupport)
+      Pod::UI.puts "#{s.name}: Using FirebaseAnalytics/IdentitySupport with Ad Ids. May require App Tracking Transparency. Not allowed for Kids apps."
+      Pod::UI.puts "#{s.name}: You may set variable `$RNFirebaseAnalyticsWithoutAdIdSupport=true` in Podfile to use analytics without ad ids."
+    end
+    s.dependency          'FirebaseAnalytics/IdentitySupport', firebase_sdk_version
+
+    # Special pod for on-device conversion
+    if defined?($RNFirebaseAnalyticsEnableAdSupport) && ($RNFirebaseAnalyticsEnableAdSupport == true)
+      Pod::UI.puts "#{s.name}: Adding Apple AdSupport.framework dependency for optional analytics features"
+      s.frameworks =       'AdSupport'
+    end
+  end
+
+  # Special pod for on-device conversion
+  if defined?($RNFirebaseAnalyticsGoogleAppMeasurementOnDeviceConversion) && ($RNFirebaseAnalyticsGoogleAppMeasurementOnDeviceConversion == true)
+    Pod::UI.puts "#{s.name}: GoogleAdsOnDeviceConversion pod added"
+    s.dependency          'GoogleAdsOnDeviceConversion'
+  end
+
+  if defined?($RNFirebaseAsStaticFramework)
+    Pod::UI.puts "#{s.name}: Using overridden static_framework value of '#{$RNFirebaseAsStaticFramework}'"
+    s.static_framework = $RNFirebaseAsStaticFramework
+  else
+    s.static_framework = false
+  end
+end

package/android/.editorconfig

@@ -0,0 +1,10 @@
+# editorconfig
+root = true
+
+[*]
+indent_style = space
+indent_size = 2
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true

package/android/build.gradle

@@ -0,0 +1,177 @@
+/* groovylint-disable DuplicateStringLiteral */
+
+import com.android.Version
+import io.invertase.gradle.common.PackageJson
+
+buildscript {
+  // The Android Gradle plugin is only required when opening the android folder stand-alone.
+  // This avoids unnecessary downloads and potential conflicts when the library is included as a
+  // module dependency in an application project.
+  if (project == rootProject) {
+    repositories {
+      google()
+      mavenCentral()
+    }
+
+    dependencies {
+      classpath("com.android.tools.build:gradle:8.4.0")
+    }
+  }
+}
+
+plugins {
+  id "io.invertase.gradle.build" version "1.5"
+}
+
+def appProject
+if (findProject(':@react-native-firebase_app')) {
+  appProject = project(':@react-native-firebase_app')
+} else if (findProject(':react-native-firebase_app')) {
+  appProject = project(':react-native-firebase_app')
+} else {
+  throw new GradleException('Could not find the react-native-firebase/app package, have you installed it?')
+}
+def packageJson = PackageJson.getForProject(project)
+def appPackageJson = PackageJson.getForProject(appProject)
+def firebaseBomVersion = appPackageJson['sdkVersions']['android']['firebase']
+def jsonMinSdk = appPackageJson['sdkVersions']['android']['minSdk']
+def jsonTargetSdk = appPackageJson['sdkVersions']['android']['targetSdk']
+def jsonCompileSdk = appPackageJson['sdkVersions']['android']['compileSdk']
+def coreVersionDetected = appPackageJson['version']
+def coreVersionRequired = packageJson['peerDependencies'][appPackageJson['name']]
+if (coreVersionDetected != coreVersionRequired) {
+  project.logger.warn("ReactNativeFirebase WARNING: NPM package '${packageJson['name']}' depends on '${appPackageJson['name']}' v${coreVersionRequired} but found v${coreVersionDetected}, this might cause build issues or runtime crashes.")
+}
+
+project.ext {
+  set('react-native', [
+    versions: [
+      android : [
+        minSdk    : jsonMinSdk,
+        targetSdk : jsonTargetSdk,
+        compileSdk: jsonCompileSdk,
+      ],
+
+      firebase: [
+        bom: firebaseBomVersion,
+      ],
+    ],
+  ])
+}
+
+apply from: file('./../../app/android/firebase-json.gradle')
+
+String collectionDeactivated = 'false'
+String adidEnabled = 'true'
+String ssaidEnabled = 'true'
+String automaticScreenReportingEnabled = 'true'
+String analyticsStorageEnabled = 'true'
+String adStorageEnabled = 'true'
+String adUserDataEnabled = 'true'
+String personalizationEnabled = 'true'
+
+// If nothing is defined, data collection defaults to true
+String dataCollectionEnabled = 'true'
+
+if (rootProject.ext && rootProject.ext.firebaseJson) {
+  /* groovylint-disable-next-line NoDef, VariableTypeRequired */
+  def rnfbConfig = rootProject.ext.firebaseJson
+  // If the SDK-wide data collection flag is defined and false, our default flips to false
+  if (rnfbConfig.isFlagEnabled('app_data_collection_default_enabled', true) == false) {
+    dataCollectionEnabled = 'false'
+  }
+  // If our specific collection flag is defined, it's status takes precedence
+  if (rnfbConfig.isDefined('analytics_auto_collection_enabled')) {
+    if (rnfbConfig.isFlagEnabled('analytics_auto_collection_enabled', true)) {
+      dataCollectionEnabled = 'true'
+    } else {
+      dataCollectionEnabled = 'false'
+    }
+  }
+
+  if (rnfbConfig.isFlagEnabled('analytics_collection_deactivated', false) == true) {
+    collectionDeactivated = 'true'
+  }
+  if (rnfbConfig.isFlagEnabled('google_analytics_adid_collection_enabled', true) == false) {
+    adidEnabled = 'false'
+  }
+  if (rnfbConfig.isFlagEnabled('google_analytics_ssaid_collection_enabled', true) == false) {
+    ssaidEnabled = 'false'
+  }
+  if (rnfbConfig.isFlagEnabled('google_analytics_automatic_screen_reporting_enabled', true) == false) {
+    automaticScreenReportingEnabled = 'false'
+  }
+  if (rnfbConfig.isFlagEnabled('analytics_default_allow_analytics_storage', true) == false) {
+    analyticsStorageEnabled = 'false'
+  }
+  if (rnfbConfig.isFlagEnabled('analytics_default_allow_ad_storage', true) == false) {
+    adStorageEnabled = 'false'
+  }
+  if (rnfbConfig.isFlagEnabled('analytics_default_allow_ad_user_data', true) == false) {
+    adUserDataEnabled = 'false'
+  }
+  if (rnfbConfig.isFlagEnabled('analytics_default_allow_ad_personalization_signals', true) == false) {
+    personalizationEnabled = 'false'
+  }
+}
+
+android {
+  def agpVersion = Version.ANDROID_GRADLE_PLUGIN_VERSION.tokenize('.')[0].toInteger()
+  if (agpVersion >= 7) {
+    namespace = 'io.invertase.firebase.analytics'
+  }
+
+  defaultConfig {
+    multiDexEnabled = true
+    manifestPlaceholders = [
+      firebaseJsonAutoCollectionEnabled: dataCollectionEnabled,
+      firebaseJsonCollectionDeactivated: collectionDeactivated,
+      firebaseJsonAdidEnabled: adidEnabled,
+      firebaseJsonSsaidEnabled: ssaidEnabled,
+      firebaseJsonAutomaticScreenReportingEnabled: automaticScreenReportingEnabled,
+      firebaseJsonAnalyticsStorageEnabled: analyticsStorageEnabled,
+      firebaseJsonAdStorageEnabled: adStorageEnabled,
+      firebaseJsonAdUserDataEnabled: adUserDataEnabled,
+      firebaseJsonPersonalizationEnabled: personalizationEnabled
+    ]
+  }
+
+  buildFeatures {
+    // AGP 8 no longer builds config by default
+    buildConfig = true
+  }
+
+  lintOptions {
+    disable 'GradleCompatible'
+    abortOnError = false
+  }
+
+  if (agpVersion < 8) {
+    compileOptions {
+      sourceCompatibility = JavaVersion.VERSION_11
+      targetCompatibility = JavaVersion.VERSION_11
+    }
+  }
+
+  sourceSets {
+    main {
+      java.srcDirs = ['src/main/java', 'src/reactnative/java']
+    }
+  }
+}
+
+repositories {
+  google()
+  mavenCentral()
+}
+
+dependencies {
+  api appProject
+  implementation platform("com.google.firebase:firebase-bom:${ReactNative.ext.getVersion("firebase", "bom")}")
+  implementation "com.google.firebase:firebase-analytics"
+}
+
+ReactNative.shared.applyPackageVersion()
+ReactNative.shared.applyDefaultExcludes()
+ReactNative.module.applyAndroidVersions()
+ReactNative.module.applyReactNativeDependency("api")

package/android/lint.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<lint>
+  <!-- Disable the given check in this project -->
+  <issue id="GradleCompatible" severity="ignore" />
+</lint>

package/android/settings.gradle

@@ -0,0 +1 @@
+rootProject.name = '@react-native-firebase_analytics'

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest package="io.invertase.firebase.analytics"
+  xmlns:android="http://schemas.android.com/apk/res/android">
+
+  <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+  <uses-permission android:name="android.permission.INTERNET" />
+  <uses-permission android:name="android.permission.WAKE_LOCK" />
+
+  <application>
+    <meta-data android:name="firebase_analytics_collection_enabled" android:value="${firebaseJsonAutoCollectionEnabled}"/>
+    <meta-data android:name="firebase_analytics_collection_deactivated" android:value="${firebaseJsonCollectionDeactivated}" />
+    <meta-data android:name="google_analytics_adid_collection_enabled" android:value="${firebaseJsonAdidEnabled}" />
+    <meta-data android:name="google_analytics_ssaid_collection_enabled" android:value="${firebaseJsonSsaidEnabled}" />
+    <meta-data android:name="google_analytics_automatic_screen_reporting_enabled" android:value="${firebaseJsonAutomaticScreenReportingEnabled}" />
+    <meta-data android:name="google_analytics_default_allow_analytics_storage" android:value="${firebaseJsonAnalyticsStorageEnabled}" />
+    <meta-data android:name="google_analytics_default_allow_ad_storage" android:value="${firebaseJsonAdStorageEnabled}" />
+    <meta-data android:name="google_analytics_default_allow_ad_user_data" android:value="${firebaseJsonAdUserDataEnabled}" />
+    <meta-data android:name="google_analytics_default_allow_ad_personalization_signals" android:value="${firebaseJsonPersonalizationEnabled}" />
+
+  </application>
+</manifest>

package/android/src/main/java/io/invertase/firebase/analytics/UniversalFirebaseAnalyticsModule.java

@@ -0,0 +1,141 @@
+package io.invertase.firebase.analytics;
+
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+import android.content.Context;
+import android.os.Bundle;
+import com.google.android.gms.tasks.Task;
+import com.google.android.gms.tasks.Tasks;
+import com.google.firebase.analytics.FirebaseAnalytics;
+import com.google.firebase.analytics.FirebaseAnalytics.ConsentStatus;
+import com.google.firebase.analytics.FirebaseAnalytics.ConsentType;
+import io.invertase.firebase.common.UniversalFirebaseModule;
+import java.util.EnumMap;
+import java.util.Map;
+import java.util.Set;
+
+@SuppressWarnings("WeakerAccess")
+public class UniversalFirebaseAnalyticsModule extends UniversalFirebaseModule {
+
+  UniversalFirebaseAnalyticsModule(Context context, String serviceName) {
+    super(context, serviceName);
+  }
+
+  Task<Void> logEvent(String name, Bundle parameters) {
+    return Tasks.call(
+        () -> {
+          FirebaseAnalytics.getInstance(getContext()).logEvent(name, parameters);
+          return null;
+        });
+  }
+
+  Task<Void> setAnalyticsCollectionEnabled(Boolean enabled) {
+    return Tasks.call(
+        () -> {
+          FirebaseAnalytics.getInstance(getContext()).setAnalyticsCollectionEnabled(enabled);
+          return null;
+        });
+  }
+
+  Task<Void> setSessionTimeoutDuration(long milliseconds) {
+    return Tasks.call(
+        () -> {
+          FirebaseAnalytics.getInstance(getContext()).setSessionTimeoutDuration(milliseconds);
+          return null;
+        });
+  }
+
+  Task<String> getAppInstanceId() {
+    return FirebaseAnalytics.getInstance(getContext()).getAppInstanceId();
+  }
+
+  Task<Long> getSessionId() {
+    return FirebaseAnalytics.getInstance(getContext()).getSessionId();
+  }
+
+  Task<Void> setUserId(String id) {
+    return Tasks.call(
+        () -> {
+          FirebaseAnalytics.getInstance(getContext()).setUserId(id);
+          return null;
+        });
+  }
+
+  Task<Void> setUserProperty(String name, String value) {
+    return Tasks.call(
+        () -> {
+          FirebaseAnalytics.getInstance(getContext()).setUserProperty(name, value);
+          return null;
+        });
+  }
+
+  Task<Void> setUserProperties(Bundle properties) {
+    return Tasks.call(
+        () -> {
+          Set<String> bundleKeys = properties.keySet();
+          FirebaseAnalytics firebaseAnalytics = FirebaseAnalytics.getInstance(getContext());
+
+          for (String bundleKey : bundleKeys) {
+            firebaseAnalytics.setUserProperty(bundleKey, (String) properties.get(bundleKey));
+          }
+
+          return null;
+        });
+  }
+
+  Task<Void> resetAnalyticsData() {
+    return Tasks.call(
+        () -> {
+          FirebaseAnalytics.getInstance(getContext()).resetAnalyticsData();
+          return null;
+        });
+  }
+
+  Task<Void> setDefaultEventParameters(Bundle parameters) {
+    return Tasks.call(
+        () -> {
+          FirebaseAnalytics.getInstance(getContext()).setDefaultEventParameters(parameters);
+          return null;
+        });
+  }
+
+  Task<Void> setConsent(Bundle consentSettings) {
+    return Tasks.call(
+        () -> {
+          boolean analyticsStorage = consentSettings.getBoolean("analytics_storage");
+          boolean adStorage = consentSettings.getBoolean("ad_storage");
+          boolean adUserData = consentSettings.getBoolean("ad_user_data");
+          boolean adPersonalization = consentSettings.getBoolean("ad_personalization");
+
+          Map<ConsentType, ConsentStatus> consentMap = new EnumMap<>(ConsentType.class);
+          consentMap.put(
+              ConsentType.ANALYTICS_STORAGE,
+              analyticsStorage ? ConsentStatus.GRANTED : ConsentStatus.DENIED);
+          consentMap.put(
+              ConsentType.AD_STORAGE, adStorage ? ConsentStatus.GRANTED : ConsentStatus.DENIED);
+          consentMap.put(
+              ConsentType.AD_USER_DATA, adUserData ? ConsentStatus.GRANTED : ConsentStatus.DENIED);
+          consentMap.put(
+              ConsentType.AD_PERSONALIZATION,
+              adPersonalization ? ConsentStatus.GRANTED : ConsentStatus.DENIED);
+
+          FirebaseAnalytics.getInstance(getContext()).setConsent(consentMap);
+          return null;
+        });
+  }
+}

package/android/src/reactnative/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest package="io.invertase.firebase.analytics" />

package/android/src/reactnative/java/io/invertase/firebase/analytics/ReactNativeFirebaseAnalyticsModule.java

@@ -0,0 +1,213 @@
+package io.invertase.firebase.analytics;
+
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+import android.os.Bundle;
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableMap;
+import com.google.firebase.analytics.FirebaseAnalytics;
+import io.invertase.firebase.common.ReactNativeFirebaseModule;
+import java.util.ArrayList;
+import javax.annotation.Nullable;
+
+public class ReactNativeFirebaseAnalyticsModule extends ReactNativeFirebaseModule {
+  private static final String SERVICE_NAME = "Analytics";
+  private final UniversalFirebaseAnalyticsModule module;
+
+  ReactNativeFirebaseAnalyticsModule(ReactApplicationContext reactContext) {
+    super(reactContext, SERVICE_NAME);
+    module = new UniversalFirebaseAnalyticsModule(reactContext, SERVICE_NAME);
+  }
+
+  @ReactMethod
+  public void logEvent(String name, @Nullable ReadableMap params, Promise promise) {
+    module
+        .logEvent(name, toBundle(params))
+        .addOnCompleteListener(
+            task -> {
+              if (task.isSuccessful()) {
+                promise.resolve(task.getResult());
+              } else {
+                rejectPromiseWithExceptionMap(promise, task.getException());
+              }
+            });
+  }
+
+  @ReactMethod
+  public void setAnalyticsCollectionEnabled(Boolean enabled, Promise promise) {
+    module
+        .setAnalyticsCollectionEnabled(enabled)
+        .addOnCompleteListener(
+            task -> {
+              if (task.isSuccessful()) {
+                promise.resolve(task.getResult());
+              } else {
+                rejectPromiseWithExceptionMap(promise, task.getException());
+              }
+            });
+  }
+
+  @ReactMethod
+  public void setSessionTimeoutDuration(double milliseconds, Promise promise) {
+    module
+        .setSessionTimeoutDuration((long) milliseconds)
+        .addOnCompleteListener(
+            task -> {
+              if (task.isSuccessful()) {
+                promise.resolve(task.getResult());
+              } else {
+                rejectPromiseWithExceptionMap(promise, task.getException());
+              }
+            });
+  }
+
+  @ReactMethod
+  public void getAppInstanceId(Promise promise) {
+    module
+        .getAppInstanceId()
+        .addOnCompleteListener(
+            task -> {
+              if (task.isSuccessful()) {
+                promise.resolve(task.getResult());
+              } else {
+                rejectPromiseWithExceptionMap(promise, task.getException());
+              }
+            });
+  }
+
+  @ReactMethod
+  public void getSessionId(Promise promise) {
+    module
+        .getSessionId()
+        .addOnCompleteListener(
+            task -> {
+              if (task.isSuccessful()) {
+                Long result = task.getResult();
+                promise.resolve(result != null ? result.doubleValue() : null);
+              } else {
+                rejectPromiseWithExceptionMap(promise, task.getException());
+              }
+            });
+  }
+
+  @ReactMethod
+  public void setUserId(String id, Promise promise) {
+    module
+        .setUserId(id)
+        .addOnCompleteListener(
+            task -> {
+              if (task.isSuccessful()) {
+                promise.resolve(task.getResult());
+              } else {
+                rejectPromiseWithExceptionMap(promise, task.getException());
+              }
+            });
+  }
+
+  @ReactMethod
+  public void setUserProperty(String name, String value, Promise promise) {
+    module
+        .setUserProperty(name, value)
+        .addOnCompleteListener(
+            task -> {
+              if (task.isSuccessful()) {
+                promise.resolve(task.getResult());
+              } else {
+                rejectPromiseWithExceptionMap(promise, task.getException());
+              }
+            });
+  }
+
+  @ReactMethod
+  public void setUserProperties(ReadableMap properties, Promise promise) {
+    module
+        .setUserProperties(Arguments.toBundle(properties))
+        .addOnCompleteListener(
+            task -> {
+              if (task.isSuccessful()) {
+                promise.resolve(task.getResult());
+              } else {
+                rejectPromiseWithExceptionMap(promise, task.getException());
+              }
+            });
+  }
+
+  @ReactMethod
+  public void resetAnalyticsData(Promise promise) {
+    module
+        .resetAnalyticsData()
+        .addOnCompleteListener(
+            task -> {
+              if (task.isSuccessful()) {
+                promise.resolve(task.getResult());
+              } else {
+                rejectPromiseWithExceptionMap(promise, task.getException());
+              }
+            });
+  }
+
+  @ReactMethod
+  public void setDefaultEventParameters(@Nullable ReadableMap params, Promise promise) {
+    module
+        .setDefaultEventParameters(toBundle(params))
+        .addOnCompleteListener(
+            task -> {
+              if (task.isSuccessful()) {
+                promise.resolve(task.getResult());
+              } else {
+                rejectPromiseWithExceptionMap(promise, task.getException());
+              }
+            });
+  }
+
+  @ReactMethod
+  public void setConsent(ReadableMap consentSettings, Promise promise) {
+    module
+        .setConsent(Arguments.toBundle(consentSettings))
+        .addOnCompleteListener(
+            task -> {
+              if (task.isSuccessful()) {
+                promise.resolve(task.getResult());
+              } else {
+                rejectPromiseWithExceptionMap(promise, task.getException());
+              }
+            });
+  }
+
+  private Bundle toBundle(ReadableMap readableMap) {
+    Bundle bundle = Arguments.toBundle(readableMap);
+    if (bundle == null) {
+      return null;
+    }
+    ArrayList itemsArray = (ArrayList) bundle.getSerializable(FirebaseAnalytics.Param.ITEMS);
+    for (Object item : itemsArray != null ? itemsArray : new ArrayList()) {
+      if (item instanceof Bundle && ((Bundle) item).containsKey(FirebaseAnalytics.Param.QUANTITY)) {
+        double number = ((Bundle) item).getDouble(FirebaseAnalytics.Param.QUANTITY);
+        ((Bundle) item).putInt(FirebaseAnalytics.Param.QUANTITY, (int) number);
+      }
+    }
+    if (bundle.containsKey(FirebaseAnalytics.Param.EXTEND_SESSION)) {
+      double number = bundle.getDouble(FirebaseAnalytics.Param.EXTEND_SESSION);
+      bundle.putLong(FirebaseAnalytics.Param.EXTEND_SESSION, (long) number);
+    }
+    return bundle;
+  }
+}

package/android/src/reactnative/java/io/invertase/firebase/analytics/ReactNativeFirebaseAnalyticsPackage.java

@@ -0,0 +1,41 @@
+package io.invertase.firebase.analytics;
+
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.uimanager.ViewManager;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+@SuppressWarnings("unused")
+public class ReactNativeFirebaseAnalyticsPackage implements ReactPackage {
+  @Override
+  public List<NativeModule> createNativeModules(ReactApplicationContext reactContext) {
+    List<NativeModule> modules = new ArrayList<>();
+    modules.add(new ReactNativeFirebaseAnalyticsModule(reactContext));
+    return modules;
+  }
+
+  @Override
+  public List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {
+    return Collections.emptyList();
+  }
+}