@react-native-firebase/app 23.8.0 → 23.8.2

package/RNFBApp.podspec

@@ -0,0 +1,49 @@
+require 'json'
+require './firebase_json'
+package = JSON.parse(File.read(File.join(__dir__, 'package.json')))
+firebase_sdk_version = package['sdkVersions']['ios']['firebase']
+firebase_ios_target = package['sdkVersions']['ios']['iosTarget']
+firebase_macos_target = package['sdkVersions']['ios']['macosTarget']
+firebase_tvos_target = package['sdkVersions']['ios']['tvosTarget']
+
+Pod::Spec.new do |s|
+  s.name                = "RNFBApp"
+  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.cocoapods_version   = '>= 1.12.0'
+  s.source_files        = "ios/**/*.{h,m}"
+
+  # React Native dependencies
+  s.dependency          'React-Core'
+
+  if (ENV.include?('FIREBASE_SDK_VERSION'))
+    Pod::UI.puts "#{s.name}: Found Firebase SDK version in environment '#{ENV['FIREBASE_SDK_VERSION']}'"
+    $FirebaseSDKVersion = ENV['FIREBASE_SDK_VERSION']
+  end
+
+  if defined?($FirebaseSDKVersion)
+    Pod::UI.puts "#{s.name}: Using user specified Firebase SDK version '#{$FirebaseSDKVersion}'"
+    firebase_sdk_version = $FirebaseSDKVersion
+  end
+
+  # Firebase dependencies
+  s.dependency          'Firebase/CoreOnly', firebase_sdk_version
+
+  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,129 @@
+import com.android.Version
+import io.invertase.gradle.common.PackageJson
+import org.gradle.internal.jvm.Jvm
+
+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 packageJson = PackageJson.getForProject(project)
+def firebaseBomVersion = packageJson['sdkVersions']['android']['firebase']
+def playServicesAuthVersion = packageJson['sdkVersions']['android']['playServicesAuth']
+def jsonMinSdk = packageJson['sdkVersions']['android']['minSdk']
+def jsonTargetSdk = packageJson['sdkVersions']['android']['targetSdk']
+def jsonCompileSdk = packageJson['sdkVersions']['android']['compileSdk']
+
+project.ext {
+  set('react-native', [
+    versions: [
+      android : [
+        minSdk    : jsonMinSdk,
+        targetSdk : jsonTargetSdk,
+        compileSdk: jsonCompileSdk,
+      ],
+
+      firebase: [
+        bom: firebaseBomVersion,
+      ],
+
+      play     : [
+        "play-services-auth": playServicesAuthVersion,
+      ],
+    ],
+  ])
+}
+
+apply from: file('./firebase-json.gradle')
+
+// If data collection isn't specifically disabled, default is enabled
+String dataCollectionDefaultEnabled = 'true'
+
+if (rootProject.ext && rootProject.ext.firebaseJson) {
+  if (rootProject.ext.firebaseJson.isFlagEnabled('app_data_collection_default_enabled', true) == false) {
+    dataCollectionDefaultEnabled = 'false'
+  }
+}
+
+android {
+  def agpVersion = Version.ANDROID_GRADLE_PLUGIN_VERSION.tokenize('.')[0].toInteger()
+  if (agpVersion >= 7) {
+    namespace = 'io.invertase.firebase'
+  }
+
+  defaultConfig {
+    multiDexEnabled = true
+    manifestPlaceholders = [
+      firebaseJsonDataCollectionDefaultEnabled: dataCollectionDefaultEnabled
+    ]
+  }
+
+  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 {
+  implementation platform("com.google.firebase:firebase-bom:${ReactNative.ext.getVersion("firebase", "bom")}")
+  implementation "com.google.firebase:firebase-common"
+  implementation "com.google.android.gms:play-services-auth:${ReactNative.ext.getVersion("play", "play-services-auth")}"
+}
+
+def jvmVersion = Jvm.current().javaVersion?.majorVersion
+// if it cannot get version, just allow it to pass. This is just a helper for developers
+if ((jvmVersion?.toInteger() ?: 17) < 17) {
+  println("\n\n\n")
+  println("**************************************************************************************************************")
+  println("\n\n\n")
+  println("ERROR: React Native Firebase builds with a minimum JVM version 17. We test with JVM 17 and 21.")
+  println("  Incompatible major version detected: '" + jvmVersion + "'")
+  println("\n\n\n")
+  println("  If you receive this error because you want to use a different JDK, we may accept PRs to support new versions.")
+  println("\n\n\n")
+  println("**************************************************************************************************************")
+  println("\n\n\n")
+  System.exit(1)
+}
+
+ReactNative.shared.applyPackageVersion()
+ReactNative.shared.applyDefaultExcludes()
+ReactNative.module.applyAndroidVersions()
+ReactNative.module.applyReactNativeDependency("api")

package/android/firebase-json.gradle

@@ -0,0 +1,73 @@
+/* groovylint-disable CatchException, CompileStatic, DuplicateStringLiteral, JavaIoPackageAccess */
+import groovy.json.JsonOutput
+import groovy.json.JsonSlurper
+
+String fileName = 'firebase.json'
+String jsonRoot = 'react-native'
+
+File jsonFile = null
+File parentDir = rootProject.projectDir
+
+for (int i = 0; i <= 3; i++) {
+  if (parentDir == null) { break }
+  parentDir = parentDir.parentFile
+  if (parentDir != null) {
+    jsonFile = new File(parentDir, fileName)
+    if (jsonFile.exists()) { break }
+  }
+}
+
+if (jsonFile?.exists()) {
+  rootProject.logger.info ":${project.name} firebase.json found at ${jsonFile}"
+  Object json = null
+
+  try {
+    json = new JsonSlurper().parseText(jsonFile.text)
+  } catch (Exception ignored) {
+    rootProject.logger.warn ":${project.name} failed to parse firebase.json found at ${jsonFile}."
+    rootProject.logger.warn ignored.toString()
+  }
+
+  if (json && json[jsonRoot]) {
+    String jsonStr = JsonOutput.toJson(JsonOutput.toJson(json[jsonRoot]))
+
+    rootProject.ext.firebaseJson = [
+      raw: json[jsonRoot],
+      isDefined: { key ->
+        return (json[jsonRoot] != null && json[jsonRoot][key] != null)
+      },
+      isFlagEnabled: { key, defaultValue ->
+        if (json[jsonRoot] == null || json[jsonRoot][key] == null) { return defaultValue }
+        return json[jsonRoot][key] == true
+      },
+      getStringValue: { key, defaultValue ->
+        if (json[jsonRoot] == null) { return defaultValue }
+        return json[jsonRoot][key] ? json[jsonRoot][key] : defaultValue
+      }
+    ]
+
+    rootProject.logger
+      .info ":${project.name} found react-native json root in firebase.json, creating firebase build config"
+    android {
+      defaultConfig {
+        buildConfigField 'String', 'FIREBASE_JSON_RAW', jsonStr
+      }
+    }
+  } else {
+    rootProject.ext.firebaseJson = false
+    rootProject.logger.info ":${project.name} firebase.json found with no react-native config, skipping"
+    android {
+      defaultConfig {
+        buildConfigField 'String', 'FIREBASE_JSON_RAW', '"{}"'
+      }
+    }
+  }
+} else {
+  rootProject.ext.firebaseJson = false
+  rootProject.logger.info ":${project.name} no firebase.json found, skipping"
+  android {
+    defaultConfig {
+      buildConfigField 'String', 'FIREBASE_JSON_RAW', '"{}"'
+    }
+  }
+}

package/android/gradle.properties

@@ -0,0 +1,2 @@
+android.useAndroidX=true
+android.enableJetifier=true

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_app'

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+  xmlns:tools="http://schemas.android.com/tools"
+  package="io.invertase.firebase">
+
+  <application>
+    <meta-data android:name="app_data_collection_default_enabled" android:value="${firebaseJsonDataCollectionDefaultEnabled}"/>
+    <service
+      android:name="com.google.firebase.components.ComponentDiscoveryService"
+      android:directBootAware="true"
+      android:exported="false"
+      tools:targetApi="n"
+    >
+      <meta-data
+        android:name="com.google.firebase.components:io.invertase.firebase.app.ReactNativeFirebaseAppRegistrar"
+        android:value="com.google.firebase.components.ComponentRegistrar" />
+    </service>
+    <provider
+      android:name="io.invertase.firebase.app.ReactNativeFirebaseAppInitProvider"
+      android:authorities="${applicationId}.reactnativefirebaseappinitprovider"
+      android:exported="false"
+      android:initOrder="99" /> <!-- Firebase = 100, using 99 to run after Firebase initialises (highest first) -->
+  </application>
+</manifest>

package/android/src/main/java/io/invertase/firebase/common/TaskExecutorService.java

@@ -0,0 +1,124 @@
+package io.invertase.firebase.common;
+
+/*
+ * 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 java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.RejectedExecutionHandler;
+import java.util.concurrent.SynchronousQueue;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+
+public class TaskExecutorService {
+  private static final String MAXIMUM_POOL_SIZE_KEY = "android_task_executor_maximum_pool_size";
+  private static final String KEEP_ALIVE_SECONDS_KEY = "android_task_executor_keep_alive_seconds";
+
+  private final String name;
+  private final int maximumPoolSize;
+  private final int keepAliveSeconds;
+  private static final Map<String, ExecutorService> executors = new HashMap<>();
+
+  TaskExecutorService(String name) {
+    this.name = name;
+    ReactNativeFirebaseJSON json = ReactNativeFirebaseJSON.getSharedInstance();
+    this.maximumPoolSize = json.getIntValue(MAXIMUM_POOL_SIZE_KEY, 1);
+    this.keepAliveSeconds = json.getIntValue(KEEP_ALIVE_SECONDS_KEY, 3);
+  }
+
+  public ExecutorService getExecutor() {
+    boolean isTransactional = maximumPoolSize <= 1;
+    return getExecutor(isTransactional, "");
+  }
+
+  public ExecutorService getTransactionalExecutor() {
+    return getExecutor(true, "");
+  }
+
+  public ExecutorService getTransactionalExecutor(String identifier) {
+    String executorIdentifier = maximumPoolSize != 0 ? identifier : "";
+    return getExecutor(true, executorIdentifier);
+  }
+
+  public ExecutorService getExecutor(boolean isTransactional, String identifier) {
+    String executorName = getExecutorName(isTransactional, identifier);
+    synchronized (executors) {
+      ExecutorService existingExecutor = executors.get(executorName);
+      if (existingExecutor == null) {
+        ExecutorService newExecutor = getNewExecutor(isTransactional);
+        executors.put(executorName, newExecutor);
+        return newExecutor;
+      }
+      return existingExecutor;
+    }
+  }
+
+  private ExecutorService getNewExecutor(boolean isTransactional) {
+    if (isTransactional) {
+      return Executors.newSingleThreadExecutor();
+    } else {
+      ThreadPoolExecutor threadPoolExecutor =
+          new ThreadPoolExecutor(
+              0, maximumPoolSize, keepAliveSeconds, TimeUnit.SECONDS, new SynchronousQueue<>());
+      threadPoolExecutor.setRejectedExecutionHandler(executeInFallback);
+      return threadPoolExecutor;
+    }
+  }
+
+  private final RejectedExecutionHandler executeInFallback =
+      (r, executor) -> {
+        if (executor.isShutdown() || executor.isTerminated() || executor.isTerminating()) {
+          return;
+        }
+        ExecutorService fallbackExecutor = getTransactionalExecutor();
+        fallbackExecutor.execute(r);
+      };
+
+  public String getExecutorName(boolean isTransactional, String identifier) {
+    if (isTransactional) {
+      return name + "TransactionalExecutor" + identifier;
+    }
+    return name + "Executor" + identifier;
+  }
+
+  public void shutdown() {
+    synchronized (executors) {
+      List<String> existingExecutorNames = new ArrayList<>(executors.keySet());
+      for (String executorName : existingExecutorNames) {
+        if (!executorName.startsWith(name)) {
+          executors.remove(executorName);
+        } else {
+          removeExecutor(executorName);
+        }
+      }
+    }
+  }
+
+  public void removeExecutor(String executorName) {
+    synchronized (executors) {
+      ExecutorService existingExecutor = executors.get(executorName);
+      if (existingExecutor != null) {
+        existingExecutor.shutdownNow();
+        executors.remove(executorName);
+      }
+    }
+  }
+}

package/android/src/main/java/io/invertase/firebase/common/UniversalFirebaseModule.java

@@ -0,0 +1,62 @@
+package io.invertase.firebase.common;
+
+/*
+ * 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 java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.ExecutorService;
+import javax.annotation.OverridingMethodsMustInvokeSuper;
+
+public class UniversalFirebaseModule {
+  private final TaskExecutorService executorService;
+
+  private final Context context;
+  private final String serviceName;
+
+  public UniversalFirebaseModule(Context context, String serviceName) {
+    this.context = context;
+    this.serviceName = serviceName;
+    this.executorService = new TaskExecutorService(getName());
+  }
+
+  public Context getContext() {
+    return context;
+  }
+
+  public Context getApplicationContext() {
+    return getContext().getApplicationContext();
+  }
+
+  public ExecutorService getExecutor() {
+    return executorService.getExecutor();
+  }
+
+  public String getName() {
+    return "Universal" + serviceName + "Module";
+  }
+
+  @OverridingMethodsMustInvokeSuper
+  public void onTearDown() {
+    executorService.shutdown();
+  }
+
+  public Map<String, Object> getConstants() {
+    return new HashMap<>();
+  }
+}

package/android/src/main/java/io/invertase/firebase/common/UniversalFirebasePreferences.java

@@ -0,0 +1,91 @@
+package io.invertase.firebase.common;
+
+/*
+ * 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.content.SharedPreferences;
+import io.invertase.firebase.app.ReactNativeFirebaseApp;
+
+public class UniversalFirebasePreferences {
+  private static final String PREFERENCES_FILE = "io.invertase.firebase";
+  private static UniversalFirebasePreferences sharedInstance = new UniversalFirebasePreferences();
+  private SharedPreferences preferences;
+
+  public static UniversalFirebasePreferences getSharedInstance() {
+    return sharedInstance;
+  }
+
+  public boolean contains(String key) {
+    return getPreferences().contains(key);
+  }
+
+  // Boolean
+  public void setBooleanValue(String key, boolean value) {
+    getPreferences().edit().putBoolean(key, value).apply();
+  }
+
+  public boolean getBooleanValue(String key, boolean defaultValue) {
+    return getPreferences().getBoolean(key, defaultValue);
+  }
+
+  // Int
+  public void setIntValue(String key, int value) {
+    getPreferences().edit().putInt(key, value).apply();
+  }
+
+  public int getIntValue(String key, int defaultValue) {
+    return getPreferences().getInt(key, defaultValue);
+  }
+
+  // Long
+  public void setLongValue(String key, long value) {
+    getPreferences().edit().putLong(key, value).apply();
+  }
+
+  public long getLongValue(String key, long defaultValue) {
+    return getPreferences().getLong(key, defaultValue);
+  }
+
+  // String
+  public void setStringValue(String key, String value) {
+    getPreferences().edit().putString(key, value).apply();
+  }
+
+  public String getStringValue(String key, String defaultValue) {
+    return getPreferences().getString(key, defaultValue);
+  }
+
+  public void clearAll() {
+    getPreferences().edit().clear().apply();
+  }
+
+  // Note the caller is responsible for calling apply() or commit() on the
+  // returned SharedPreferences.Editor object for the remove to take affect
+  public SharedPreferences.Editor remove(String key) {
+    return getPreferences().edit().remove(key);
+  }
+
+  private SharedPreferences getPreferences() {
+    if (preferences == null) {
+      preferences =
+          ReactNativeFirebaseApp.getApplicationContext()
+              .getSharedPreferences(PREFERENCES_FILE, Context.MODE_PRIVATE);
+    }
+    return preferences;
+  }
+}

package/android/src/reactnative/AndroidManifest.xml

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

package/android/src/reactnative/java/io/invertase/firebase/app/ReactNativeFirebaseApp.java

@@ -0,0 +1,46 @@
+package io.invertase.firebase.app;
+
+/*
+ * 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.util.Log;
+import com.google.firebase.FirebaseApp;
+import com.google.firebase.FirebaseOptions;
+
+public class ReactNativeFirebaseApp {
+  private static Context applicationContext;
+
+  public static Context getApplicationContext() {
+    return applicationContext;
+  }
+
+  public static void setApplicationContext(Context applicationContext) {
+    Log.d("ReactNativeFirebaseApp", "received application context.");
+    ReactNativeFirebaseApp.applicationContext = applicationContext;
+  }
+
+  public static void initializeSecondaryApp(String name) {
+    FirebaseOptions options = FirebaseOptions.fromResource(applicationContext);
+    FirebaseApp.initializeApp(applicationContext, options, name);
+  }
+
+  public static void initializeSecondaryApp(String name, Context applicationContext) {
+    FirebaseOptions options = FirebaseOptions.fromResource(applicationContext);
+    FirebaseApp.initializeApp(applicationContext, options, name);
+  }
+}

package/android/src/reactnative/java/io/invertase/firebase/app/ReactNativeFirebaseAppInitProvider.java

@@ -0,0 +1,22 @@
+package io.invertase.firebase.app;
+
+/*
+ * 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 io.invertase.firebase.common.ReactNativeFirebaseInitProvider;
+
+public class ReactNativeFirebaseAppInitProvider extends ReactNativeFirebaseInitProvider {}