@react-native-firebase/crashlytics 26.4.0 → 27.1.0

package/CHANGELOG.md

@@ -3,6 +3,29 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [27.1.0](https://github.com/invertase/react-native-firebase/compare/v27.0.0...v27.1.0) (2026-10-23)
+
+### Bug Fixes
+
+- **crashlytics, ios:** time out SPM upload-symbols so a stalled upload cannot hang the build ([1cdb7de](https://github.com/invertase/react-native-firebase/commit/1cdb7de24ef5ca12a24cf599cce11d3d8797cbb2))
+- **crashlytics:** reach Android Crashlytics internals by reflection only ([c3f15e3](https://github.com/invertase/react-native-firebase/commit/c3f15e37b1f53e0a81469183e896003ea6e80141))
+- **crashlytics:** save JS fatal report before exiting when chaining is disabled ([cfd00b6](https://github.com/invertase/react-native-firebase/commit/cfd00b65754186aad0f765f61a5db3f19e84b716))
+
+## [27.0.0](https://github.com/invertase/react-native-firebase/compare/v26.4.0...v27.0.0) (2026-10-19)
+
+### ⚠ BREAKING CHANGES
+
+- **app, sdk:** bump Firebase Android 35, Apple 13, and JS 13
+
+### Features
+
+- **app, sdk:** bump Firebase Android 35, Apple 13, and JS 13 ([0ca03d1](https://github.com/invertase/react-native-firebase/commit/0ca03d11b0c271fb37cfbee8a0c3074a21969f0b))
+- **test-expo:** add Expo Router example with a route per package ([#9313](https://github.com/invertase/react-native-firebase/issues/9313)) ([50a946a](https://github.com/invertase/react-native-firebase/commit/50a946ab4f6c11670890940b55e8bb71f6332dcf))
+
+### Bug Fixes
+
+- **crashlytics, ios:** resolve target-folder GoogleService-Info.plist for SPM dSYM upload ([a2b7e57](https://github.com/invertase/react-native-firebase/commit/a2b7e5789b6df07d3aa2729f734582de6a5feb92)), closes [#9304](https://github.com/invertase/react-native-firebase/issues/9304)
+
 ## [26.4.0](https://github.com/invertase/react-native-firebase/compare/v26.3.3...v26.4.0) (2026-09-05)
 
 **Note:** Version bump only for package @react-native-firebase/crashlytics

package/RNFBCrashlytics.podspec

@@ -32,8 +32,14 @@ Pod::Spec.new do |s|
   s.tvos.deployment_target = firebase_tvos_target
   s.source_files        = 'ios/**/*.{h,m,mm,cpp,swift}'
   s.private_header_files = "ios/**/*.h"
-  s.exclude_files       = 'ios/generated/RCTThirdPartyComponentsProvider.*', 'ios/generated/RCTAppDependencyProvider.*', 'ios/generated/RCTModuleProviders.*', 'ios/generated/RCTModulesConformingToProtocolsProvider.*', 'ios/generated/RCTUnstableModulesRequiringMainQueueSetupProvider.*'
+  # CocoaPods FileList uses FNM_PATHNAME: `ios/*UnitTests/**` does not match nested
+  # files under HostStubs; use `ios/*UnitTests/**/*` (same as sibling packages).
+  s.exclude_files       = 'ios/generated/RCTThirdPartyComponentsProvider.*', 'ios/generated/RCTAppDependencyProvider.*', 'ios/generated/RCTModuleProviders.*', 'ios/generated/RCTModulesConformingToProtocolsProvider.*', 'ios/generated/RCTUnstableModulesRequiringMainQueueSetupProvider.*', 'ios/*UnitTests/**/*'
+  s.swift_version       = '5.10'
+
+  # DEFINES_MODULE is required for the generated RNFBCrashlytics-Swift.h interface.
   s.pod_target_xcconfig = {
+    "DEFINES_MODULE" => "YES",
     "HEADER_SEARCH_PATHS" => "\"$(PODS_TARGET_SRCROOT)/ios/generated/RNFBCrashlyticsTurboModules\" \"$(PODS_TARGET_SRCROOT)/ios/generated\"",
     "CLANG_ALLOW_NON_MODULAR_INCLUDES_IN_FRAMEWORK_MODULES" => "YES",
   }

package/android/build.gradle

@@ -13,6 +13,7 @@ buildscript {
 
     dependencies {
       classpath("com.android.tools.build:gradle:8.4.0")
+      classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:${project.findProperty('kotlinVersion') ?: '2.4.0'}")
     }
   }
 }
@@ -21,6 +22,8 @@ plugins {
   id "io.invertase.gradle.build" version "1.5"
 }
 
+apply plugin: "org.jetbrains.kotlin.android"
+
 def appProject
 if (findProject(':@react-native-firebase_app')) {
   appProject = project(':@react-native-firebase_app')
@@ -65,6 +68,7 @@ android {
 
   defaultConfig {
     multiDexEnabled = true
+    consumerProguardFiles 'proguard-rules.pro'
   }
 
   buildFeatures {
@@ -99,6 +103,10 @@ dependencies {
   implementation platform("com.google.firebase:firebase-bom:${ReactNative.ext.getVersion("firebase", "bom")}")
   implementation "com.google.firebase:firebase-crashlytics"
   implementation "com.google.firebase:firebase-crashlytics-ndk"
+
+  testImplementation "junit:junit:4.13.2"
+  testImplementation "org.robolectric:robolectric:4.14.1"
+  testImplementation "org.mockito:mockito-core:5.14.2"
 }
 
 ReactNative.shared.applyPackageVersion()

package/android/proguard-rules.pro

@@ -0,0 +1,20 @@
+# Consumer R8/ProGuard rules for @react-native-firebase/crashlytics.
+#
+# io.invertase.firebase.crashlytics.ReactNativeFirebaseCrashlyticsInternal reaches these Crashlytics
+# SDK internals by reflection to wait for a JS fatal's event write before the process exits. Keep
+# this list in sync with the names there. A missing rule (or an SDK without these members) only
+# makes the barrier fail, which falls back to a bounded wait; it never crashes.
+-keepclassmembers class com.google.firebase.crashlytics.FirebaseCrashlytics {
+  com.google.firebase.crashlytics.internal.common.CrashlyticsCore core;
+}
+-keepclassmembers class com.google.firebase.crashlytics.internal.common.CrashlyticsCore {
+  com.google.firebase.crashlytics.internal.concurrency.CrashlyticsWorkers crashlyticsWorkers;
+}
+-keepclassmembers class com.google.firebase.crashlytics.internal.concurrency.CrashlyticsWorkers {
+  com.google.firebase.crashlytics.internal.concurrency.CrashlyticsWorker common;
+  com.google.firebase.crashlytics.internal.concurrency.CrashlyticsWorker diskWrite;
+}
+-keepclassmembers class com.google.firebase.crashlytics.internal.concurrency.CrashlyticsWorker {
+  com.google.android.gms.tasks.Task submit(java.lang.Runnable);
+  com.google.android.gms.tasks.Task submitTask(java.util.concurrent.Callable);
+}

package/android/src/main/java/io/invertase/firebase/crashlytics/Constants.kt

@@ -0,0 +1,42 @@
+package io.invertase.firebase.crashlytics
+
+/*
+ * 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.
+ *
+ */
+
+/**
+ * Preference / meta / JSON keys for Crashlytics init. Historical Java shape was a
+ * package-private class of `static final String` fields; Kotlin [object] + `@JvmField`
+ * keeps `import static …Constants.*` and `Constants.KEY_…` working for same-module Java.
+ */
+internal object Constants {
+  @JvmField
+  val KEY_CRASHLYTICS_NDK_ENABLED: String = "crashlytics_ndk_enabled"
+
+  @JvmField
+  val KEY_CRASHLYTICS_DEBUG_ENABLED: String = "crashlytics_debug_enabled"
+
+  @JvmField
+  val KEY_CRASHLYTICS_AUTO_COLLECTION_ENABLED: String = "crashlytics_auto_collection_enabled"
+
+  @JvmField
+  val KEY_CRASHLYTICS_IS_ERROR_GENERATION_ON_JS_CRASH_ENABLED: String =
+    "crashlytics_is_error_generation_on_js_crash_enabled"
+
+  @JvmField
+  val KEY_CRASHLYTICS_JAVASCRIPT_EXCEPTION_HANDLER_CHAINING_ENABLED: String =
+    "crashlytics_javascript_exception_handler_chaining_enabled"
+}

package/android/src/main/java/io/invertase/firebase/crashlytics/{JavaScriptError.java → JavaScriptError.kt}

@@ -1,4 +1,4 @@
-package io.invertase.firebase.crashlytics;
+package io.invertase.firebase.crashlytics
 
 /*
  * Copyright (c) 2016-present Invertase Limited & Contributors
@@ -21,8 +21,6 @@ package io.invertase.firebase.crashlytics;
  * This class is purely cosmetic - to indicate on the Crashlytics console that it's a JavaScript
  * error rather than the generic `java.lang.Exception`.
  */
-class JavaScriptError extends Exception {
-  JavaScriptError(String message) {
-    super(message);
-  }
-}
+internal class JavaScriptError(
+  message: String,
+) : Exception(message)

package/android/src/main/java/io/invertase/firebase/crashlytics/NativeRNFBTurboCrashlytics.java

@@ -35,6 +35,9 @@ import java.util.Objects;
 
 public class NativeRNFBTurboCrashlytics extends NativeRNFBTurboCrashlyticsSpec {
   private static final String TAG = "Crashlytics";
+  // Process-wide so a second JS fatal during the bounded wait neither records nor exits again.
+  private static final ReactNativeFirebaseCrashlyticsFatalExit FATAL_EXIT =
+      ReactNativeFirebaseCrashlyticsFatalExit.create();
 
   public NativeRNFBTurboCrashlytics(ReactApplicationContext reactContext) {
     super(reactContext);
@@ -83,10 +86,14 @@ public class NativeRNFBTurboCrashlytics extends NativeRNFBTurboCrashlyticsSpec {
   @Override
   public void crashWithStackPromise(ReadableMap jsErrorMap, Promise promise) {
     if (ReactNativeFirebaseCrashlyticsInitProvider.isCrashlyticsCollectionEnabled()) {
-      Exception e = recordJavaScriptError(jsErrorMap);
-      e.printStackTrace(System.err);
-      Log.e(TAG, "Crash logged. Terminating app.");
-      System.exit(0);
+      // Coverage exception: this branch ends the process, so neither JVM tests nor e2e can
+      // observe it. Keep it a thin delegate; barrier, timeout, fallback and the second-fatal guard
+      // live in ReactNativeFirebaseCrashlyticsFatalExit (unit-tested). The promise is
+      // intentionally never resolved: that keeps the JS global handler suspended (no chaining to
+      // the previous handler, no fall-through) until termination.
+      Log.e(TAG, "Logging crash and terminating app.");
+      FATAL_EXIT.recordThenTerminate(() -> recordJavaScriptError(jsErrorMap).printStackTrace());
+      return;
     } else {
       Log.i(TAG, "crashlytics collection is not enabled, not crashing.");
     }

package/android/src/main/java/io/invertase/firebase/crashlytics/ReactNativeFirebaseCrashlyticsFatalExit.java

@@ -0,0 +1,117 @@
+package io.invertase.firebase.crashlytics;
+
+/*
+ * 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.google.android.gms.tasks.Tasks;
+import com.google.firebase.crashlytics.FirebaseCrashlytics;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+/**
+ * Records a JS fatal, then terminates the process once the record has been written.
+ *
+ * <p>{@code FirebaseCrashlytics.recordException} writes asynchronously on SDK worker threads, so
+ * exiting right after it usually loses the event. This waits on a barrier that completes after the
+ * queued event write, bounded by {@link #TIMEOUT_MS}. On any barrier failure (SDK internals
+ * changed, timeout, interruption) it waits out the rest of the bound, then terminates anyway.
+ *
+ * <p>Must run on a background thread (the TurboModule's native-modules thread), never main.
+ */
+final class ReactNativeFirebaseCrashlyticsFatalExit {
+  static final long TIMEOUT_MS = 2000;
+
+  interface Barrier {
+    void await(long timeoutMs) throws Exception;
+  }
+
+  interface Sleeper {
+    void sleep(long millis) throws InterruptedException;
+  }
+
+  interface Clock {
+    long nowMillis();
+  }
+
+  final Barrier barrier;
+  final Sleeper sleeper;
+  final Clock clock;
+  final Runnable terminator;
+  final long timeoutMs;
+  private final AtomicBoolean exiting = new AtomicBoolean(false);
+
+  ReactNativeFirebaseCrashlyticsFatalExit(
+      Barrier barrier, Sleeper sleeper, Clock clock, Runnable terminator, long timeoutMs) {
+    this.barrier = barrier;
+    this.sleeper = sleeper;
+    this.clock = clock;
+    this.terminator = terminator;
+    this.timeoutMs = timeoutMs;
+  }
+
+  static ReactNativeFirebaseCrashlyticsFatalExit create() {
+    return new ReactNativeFirebaseCrashlyticsFatalExit(
+        timeoutMs ->
+            Tasks.await(
+                ReactNativeFirebaseCrashlyticsInternal.pendingEventWritesBarrier(
+                    FirebaseCrashlytics.getInstance()),
+                timeoutMs,
+                TimeUnit.MILLISECONDS),
+        Thread::sleep,
+        () -> TimeUnit.NANOSECONDS.toMillis(System.nanoTime()),
+        // Coverage exception: ends the process, so no test can run it.
+        () -> System.exit(0),
+        TIMEOUT_MS);
+  }
+
+  /**
+   * Runs {@code record}, waits (bounded) for it to be written, then terminates, even when {@code
+   * record} throws. Returns false without running {@code record} when an earlier call already
+   * started terminating.
+   */
+  boolean recordThenTerminate(Runnable record) {
+    if (!exiting.compareAndSet(false, true)) {
+      return false;
+    }
+    try {
+      record.run();
+    } catch (Throwable recordFailed) {
+      // The guard is already set, so terminate anyway rather than leave the app running with
+      // every later fatal ignored.
+      recordFailed.printStackTrace();
+    }
+    long deadline = clock.nowMillis() + timeoutMs;
+    try {
+      barrier.await(timeoutMs);
+    } catch (Throwable barrierUnavailable) {
+      waitUntil(deadline);
+    }
+    terminator.run();
+    return true;
+  }
+
+  private void waitUntil(long deadline) {
+    long remaining;
+    while ((remaining = deadline - clock.nowMillis()) > 0) {
+      try {
+        sleeper.sleep(remaining);
+      } catch (InterruptedException ignored) {
+        // Keep waiting out the bound; the process terminates right after.
+      }
+    }
+  }
+}

package/android/src/main/java/io/invertase/firebase/crashlytics/ReactNativeFirebaseCrashlyticsInternal.java

@@ -0,0 +1,80 @@
+package io.invertase.firebase.crashlytics;
+
+/*
+ * 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.google.android.gms.tasks.Task;
+import com.google.firebase.crashlytics.FirebaseCrashlytics;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.Objects;
+import java.util.concurrent.Callable;
+
+/**
+ * Reaches Firebase Crashlytics SDK internals that have no public API.
+ *
+ * <p>{@code recordException} queues its event on the {@code common} worker, which then queues the
+ * event write on the {@code diskWrite} worker. Both workers are serial, so a {@code common} task
+ * that itself queues a no-op on {@code diskWrite} completes only after every event write already
+ * queued by earlier {@code recordException} calls.
+ *
+ * <p>Apps can override the Firebase BoM, so every internal member is reached by reflection: an SDK
+ * without them still builds, and any mismatch throws at runtime. Callers must treat every failure
+ * as "barrier unavailable". The reflected members are kept by the package's consumer R8/ProGuard
+ * rules ({@code proguard-rules.pro}); keep both lists in sync.
+ */
+final class ReactNativeFirebaseCrashlyticsInternal {
+  static final String CORE_FIELD = "core";
+  static final String WORKERS_FIELD = "crashlyticsWorkers";
+  static final String COMMON_FIELD = "common";
+  static final String DISK_WRITE_FIELD = "diskWrite";
+  static final String SUBMIT_TASK_METHOD = "submitTask";
+  static final String SUBMIT_METHOD = "submit";
+
+  private ReactNativeFirebaseCrashlyticsInternal() {}
+
+  /** Returns a task that completes after all event writes already queued by the SDK. */
+  static Task<?> pendingEventWritesBarrier(FirebaseCrashlytics crashlytics)
+      throws ReflectiveOperationException {
+    return barrierOn(read(read(crashlytics, CORE_FIELD), WORKERS_FIELD));
+  }
+
+  /** {@code workers.common.submitTask(() -> workers.diskWrite.submit(() -> {}))}, reflectively. */
+  static Task<?> barrierOn(Object workers) throws ReflectiveOperationException {
+    Object common = read(workers, COMMON_FIELD);
+    Object diskWrite = read(workers, DISK_WRITE_FIELD);
+    Method submit = diskWrite.getClass().getMethod(SUBMIT_METHOD, Runnable.class);
+    Method submitTask = common.getClass().getMethod(SUBMIT_TASK_METHOD, Callable.class);
+    Runnable noop = () -> {};
+    Callable<Object> queueNoopOnDiskWrite = () -> submit.invoke(diskWrite, noop);
+    return (Task<?>) submitTask.invoke(common, queueNoopOnDiskWrite);
+  }
+
+  /** Reads field {@code name} declared on {@code owner}'s class or a superclass; never null. */
+  static Object read(Object owner, String name) throws ReflectiveOperationException {
+    for (Class<?> type = owner.getClass(); type != null; type = type.getSuperclass()) {
+      try {
+        Field field = type.getDeclaredField(name);
+        field.setAccessible(true);
+        return Objects.requireNonNull(field.get(owner), name);
+      } catch (NoSuchFieldException notDeclaredHere) {
+        // Keep looking up the hierarchy (e.g. a subclass of the SDK type).
+      }
+    }
+    throw new NoSuchFieldException(name);
+  }
+}

package/android/src/main/java/io/invertase/firebase/crashlytics/ReactNativeFirebaseCrashlyticsNativeHelper.kt

@@ -0,0 +1,45 @@
+package io.invertase.firebase.crashlytics
+
+/*
+ * 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.google.firebase.crashlytics.FirebaseCrashlytics
+
+/**
+ * Public static helpers for native/Android callers that need Crashlytics without going through the
+ * TurboModule. Historical Java shape was a class of static methods; Kotlin [object] + `@JvmStatic`
+ * keeps `ReactNativeFirebaseCrashlyticsNativeHelper.recordNativeException(...)` working for Java.
+ */
+object ReactNativeFirebaseCrashlyticsNativeHelper {
+  @JvmStatic
+  fun recordNativeException(throwable: Throwable) {
+    FirebaseCrashlytics.getInstance().recordException(throwable)
+  }
+
+  @JvmStatic
+  fun log(message: String) {
+    FirebaseCrashlytics.getInstance().log(message)
+  }
+
+  @JvmStatic
+  fun setCustomKey(
+    key: String,
+    value: String,
+  ) {
+    FirebaseCrashlytics.getInstance().setCustomKey(key, value)
+  }
+}

package/android/src/main/java/io/invertase/firebase/crashlytics/{UnhandledPromiseRejection.java → UnhandledPromiseRejection.kt}

@@ -1,4 +1,4 @@
-package io.invertase.firebase.crashlytics;
+package io.invertase.firebase.crashlytics
 
 /*
  * Copyright (c) 2016-present Invertase Limited & Contributors
@@ -21,8 +21,6 @@ package io.invertase.firebase.crashlytics;
  * This class is purely cosmetic - to indicate on the Crashlytics console that it's an
  * UnhandledPromiseRejection JS error rather than the generic `java.lang.Exception`.
  */
-class UnhandledPromiseRejection extends Exception {
-  UnhandledPromiseRejection(String message) {
-    super(message);
-  }
-}
+internal class UnhandledPromiseRejection(
+  message: String,
+) : Exception(message)

package/android/src/test/java/io/invertase/firebase/crashlytics/ConstantsAndJsErrorTypesTest.java

@@ -0,0 +1,84 @@
+package io.invertase.firebase.crashlytics;
+
+/*
+ * 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 static io.invertase.firebase.crashlytics.Constants.KEY_CRASHLYTICS_AUTO_COLLECTION_ENABLED;
+import static io.invertase.firebase.crashlytics.Constants.KEY_CRASHLYTICS_DEBUG_ENABLED;
+import static io.invertase.firebase.crashlytics.Constants.KEY_CRASHLYTICS_IS_ERROR_GENERATION_ON_JS_CRASH_ENABLED;
+import static io.invertase.firebase.crashlytics.Constants.KEY_CRASHLYTICS_JAVASCRIPT_EXCEPTION_HANDLER_CHAINING_ENABLED;
+import static io.invertase.firebase.crashlytics.Constants.KEY_CRASHLYTICS_NDK_ENABLED;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+import org.junit.Test;
+
+/**
+ * JVM coverage for Kotlin-ported {@link Constants}, {@link JavaScriptError}, and {@link
+ * UnhandledPromiseRejection}. Asserts preference-key string values, Java static-field shape for
+ * InitProvider static imports, and cosmetic Crashlytics console type names.
+ */
+public class ConstantsAndJsErrorTypesTest {
+
+  @Test
+  public void constants_stringValuesMatchExpectedKeys() {
+    assertEquals("crashlytics_ndk_enabled", KEY_CRASHLYTICS_NDK_ENABLED);
+    assertEquals("crashlytics_debug_enabled", KEY_CRASHLYTICS_DEBUG_ENABLED);
+    assertEquals("crashlytics_auto_collection_enabled", KEY_CRASHLYTICS_AUTO_COLLECTION_ENABLED);
+    assertEquals(
+        "crashlytics_is_error_generation_on_js_crash_enabled",
+        KEY_CRASHLYTICS_IS_ERROR_GENERATION_ON_JS_CRASH_ENABLED);
+    assertEquals(
+        "crashlytics_javascript_exception_handler_chaining_enabled",
+        KEY_CRASHLYTICS_JAVASCRIPT_EXCEPTION_HANDLER_CHAINING_ENABLED);
+  }
+
+  @Test
+  public void constants_fieldsArePublicStaticForJavaStaticImport() throws Exception {
+    String[] names = {
+      "KEY_CRASHLYTICS_NDK_ENABLED",
+      "KEY_CRASHLYTICS_DEBUG_ENABLED",
+      "KEY_CRASHLYTICS_AUTO_COLLECTION_ENABLED",
+      "KEY_CRASHLYTICS_IS_ERROR_GENERATION_ON_JS_CRASH_ENABLED",
+      "KEY_CRASHLYTICS_JAVASCRIPT_EXCEPTION_HANDLER_CHAINING_ENABLED",
+    };
+    for (String name : names) {
+      Field field = Constants.class.getField(name);
+      int modifiers = field.getModifiers();
+      assertTrue(name, Modifier.isPublic(modifiers));
+      assertTrue(name, Modifier.isStatic(modifiers));
+      assertTrue(name, Modifier.isFinal(modifiers));
+      assertEquals(name, String.class, field.getType());
+    }
+  }
+
+  @Test
+  public void javaScriptError_constructsWithMessageAndCosmeticSimpleName() {
+    JavaScriptError error = new JavaScriptError("js-boom");
+    assertEquals("js-boom", error.getMessage());
+    assertEquals("JavaScriptError", error.getClass().getSimpleName());
+  }
+
+  @Test
+  public void unhandledPromiseRejection_constructsWithMessageAndCosmeticSimpleName() {
+    UnhandledPromiseRejection error = new UnhandledPromiseRejection("promise-boom");
+    assertEquals("promise-boom", error.getMessage());
+    assertEquals("UnhandledPromiseRejection", error.getClass().getSimpleName());
+  }
+}

package/android/src/test/java/io/invertase/firebase/crashlytics/ReactNativeFirebaseCrashlyticsFatalExitBarrierTest.java

@@ -0,0 +1,122 @@
+package io.invertase.firebase.crashlytics;
+
+/*
+ * 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 static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.mockStatic;
+
+import com.google.firebase.crashlytics.FirebaseCrashlytics;
+import com.google.firebase.crashlytics.internal.common.CrashlyticsCore;
+import com.google.firebase.crashlytics.internal.concurrency.CrashlyticsWorkers;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import org.junit.After;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.MockedStatic;
+import org.robolectric.RobolectricTestRunner;
+
+/**
+ * Covers the production barrier wired by {@link ReactNativeFirebaseCrashlyticsFatalExit#create()}
+ * against real Crashlytics workers. Robolectric for the SDK classes; AndroidTest-AD-1. The barrier
+ * runs on a pool thread (as on the native-modules thread in production), and {@code mockStatic} is
+ * thread-bound, so it is opened on that thread.
+ */
+@RunWith(RobolectricTestRunner.class)
+public class ReactNativeFirebaseCrashlyticsFatalExitBarrierTest {
+  private final ExecutorService pool = Executors.newCachedThreadPool();
+
+  @After
+  public void tearDown() {
+    pool.shutdownNow();
+  }
+
+  @Test
+  public void productionBarrier_waitsForTheQueuedEventWrite() throws Exception {
+    CrashlyticsWorkers workers = new CrashlyticsWorkers(pool, pool);
+    FirebaseCrashlytics crashlytics =
+        ReactNativeFirebaseCrashlyticsInternalTest.crashlyticsWith(workers);
+    AtomicBoolean eventWritten = new AtomicBoolean(false);
+    workers.diskWrite.submit(
+        () -> {
+          try {
+            Thread.sleep(150);
+          } catch (InterruptedException e) {
+            throw new IllegalStateException(e);
+          }
+          eventWritten.set(true);
+        });
+
+    ReactNativeFirebaseCrashlyticsFatalExit fatalExit =
+        ReactNativeFirebaseCrashlyticsFatalExit.create();
+    pool.submit(
+            () -> {
+              try (MockedStatic<FirebaseCrashlytics> firebaseCrashlytics =
+                  mockStatic(FirebaseCrashlytics.class)) {
+                firebaseCrashlytics.when(FirebaseCrashlytics::getInstance).thenReturn(crashlytics);
+                fatalExit.barrier.await(fatalExit.timeoutMs);
+              }
+              return null;
+            })
+        .get(10, TimeUnit.SECONDS);
+
+    assertTrue(eventWritten.get());
+  }
+
+  /**
+   * When the barrier is unavailable (here: an unset {@code crashlyticsWorkers}), the production
+   * barrier fails and the fatal exit waits out the bound, then terminates.
+   */
+  @Test
+  public void productionBarrier_barrierUnavailable_fallsBackToTheBoundedWait() throws Exception {
+    FirebaseCrashlytics crashlytics =
+        ReactNativeFirebaseCrashlyticsInternalTest.crashlyticsWithCore(mock(CrashlyticsCore.class));
+    List<String> events = new ArrayList<>();
+    long[] now = {0};
+    ReactNativeFirebaseCrashlyticsFatalExit fatalExit =
+        new ReactNativeFirebaseCrashlyticsFatalExit(
+            ReactNativeFirebaseCrashlyticsFatalExit.create().barrier,
+            millis -> {
+              events.add("sleep:" + millis);
+              now[0] += millis;
+            },
+            () -> now[0],
+            () -> events.add("exit"),
+            ReactNativeFirebaseCrashlyticsFatalExit.TIMEOUT_MS);
+
+    pool.submit(
+            () -> {
+              try (MockedStatic<FirebaseCrashlytics> firebaseCrashlytics =
+                  mockStatic(FirebaseCrashlytics.class)) {
+                firebaseCrashlytics.when(FirebaseCrashlytics::getInstance).thenReturn(crashlytics);
+                assertTrue(fatalExit.recordThenTerminate(() -> events.add("record")));
+              }
+              return null;
+            })
+        .get(10, TimeUnit.SECONDS);
+
+    assertEquals(Arrays.asList("record", "sleep:2000", "exit"), events);
+  }
+}