@react-native-firebase/app 25.1.0 → 26.1.0

package/android/src/reactnative/java/io/invertase/firebase/common/ReactNativeFirebaseEventEmitter.java

@@ -17,27 +17,64 @@ package io.invertase.firebase.common;
  *
  */
 
+import android.content.Context;
 import android.os.Handler;
 import android.os.Looper;
 import android.util.Log;
 import androidx.annotation.MainThread;
+import androidx.annotation.Nullable;
+import com.facebook.react.ReactApplication;
+import com.facebook.react.ReactHost;
+import com.facebook.react.ReactNativeHost;
 import com.facebook.react.bridge.Arguments;
 import com.facebook.react.bridge.ReactContext;
 import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.modules.core.DeviceEventManagerModule;
+import io.invertase.firebase.app.ReactNativeFirebaseApp;
 import io.invertase.firebase.interfaces.NativeEvent;
+import java.lang.ref.WeakReference;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 
 public class ReactNativeFirebaseEventEmitter {
+  private static final String TAG = "RNFB_EMITTER";
   private static ReactNativeFirebaseEventEmitter sharedInstance =
       new ReactNativeFirebaseEventEmitter();
-  private final List<NativeEvent> queuedEvents = new ArrayList<>();
   private final Handler handler = new Handler(Looper.getMainLooper());
+
+  // All mutable state below is guarded by the jsListeners monitor. Attach/detach/ready
+  // transitions happen synchronously at cause time under the same monitor as listener
+  // registration: with more than one ReactContext generation alive during an instance
+  // reload, deferring any of these transitions (e.g. to a congested main looper) reorders
+  // them against a replacement runtime's synchronous registrations and can wipe or wedge
+  // that runtime's state. Only queue flushing is posted to the main thread.
+  private final List<NativeEvent> queuedEvents = new ArrayList<>();
   private final HashMap<String, Integer> jsListeners = new HashMap<>();
-  private ReactContext reactContext;
-  private Boolean jsReady = false;
+  // Weak so the emitter never pins a dead ReactContext (and its module graph) for the
+  // lifetime of the process if a runtime is torn down without a paired detach.
+  private WeakReference<ReactContext> attachedReactContext = new WeakReference<>(null);
+  // When the host still names a dying generation, a live module's attach is remembered here
+  // and promoted once that dying context detaches or the host catches up — without waiting
+  // solely on a later Activity resume that may never arrive.
+  private WeakReference<ReactContext> pendingReactContext = new WeakReference<>(null);
+  // Host identity we moved past while converging onto pending/attached; late attaches of this
+  // identity must not displace the live generation while the host ref lags.
+  private WeakReference<ReactContext> hostLagReactContext = new WeakReference<>(null);
+  // When a new pending candidate enters while the attached generation still lives, listener
+  // accounting is reset so events queue until the pending JS re-registers. Keep a snapshot of
+  // the attached generation's accounting so a pending-only cancel can restore it — otherwise
+  // the surviving attached runtime stays deaf for the rest of the session (#8374-class).
+  @Nullable private HashMap<String, Integer> attachedListenersSnapshot;
+  private boolean attachedJsReadySnapshot;
+  private int attachedJsListenerCountSnapshot;
+  // After pending-only cancel restores that snapshot, emit must keep targeting the restored
+  // attached generation even if the host has already advanced to an unrelated unattached
+  // context — otherwise resolveEmitContext prefers raw hostCurrent and silently loses events
+  // into a runtime with no RNFB JS subscribers (R1 class after cancel). Cleared when a new
+  // generation attaches through acceptAttachedContext / convergence / full detach.
+  private boolean emitPrefersRestoredAttached;
+  private boolean jsReady = false;
   private int jsListenerCount;
 
   public static ReactNativeFirebaseEventEmitter getSharedInstance() {
@@ -45,26 +82,187 @@ public class ReactNativeFirebaseEventEmitter {
   }
 
   public void attachReactContext(final ReactContext reactContext) {
-    handler.post(
-        () -> {
-          ReactNativeFirebaseEventEmitter.this.reactContext = reactContext;
-          sendQueuedEvents();
-        });
+    // Resolve host current outside jsListeners so ReactApplication getters are not held
+    // under the listener monitor (they are RN-owned and not expected to re-enter, but the
+    // coupling is unnecessary for attach arbitration).
+    ReactContext hostCurrent = getCurrentReactContextFromHost(reactContext);
+
+    synchronized (jsListeners) {
+      // Under the new architecture more than one ReactContext generation can exist while an
+      // instance is destroyed and recreated: a module belonging to the dying generation may
+      // run initialize() after the replacement generation has already attached (for example
+      // TurboModuleManager creates requested-but-never-built modules during invalidate).
+      // Attach is fail-closed when something is already attached: accept the candidate only
+      // when the host currently names it. A null host current keeps the previous attachment
+      // rather than accepting a late stale context. When the host still names the previous
+      // (dying) context, remember the candidate as pending so detach/host catch-up can
+      // converge without depending only on a later Activity resume.
+      ReactContext previousContext = attachedReactContext.get();
+      if (previousContext != null && previousContext != reactContext) {
+        if (hostCurrent == null) {
+          Log.w(
+              TAG,
+              "Ignoring attach of ReactContext@"
+                  + System.identityHashCode(reactContext)
+                  + " while host current is null; keeping @"
+                  + System.identityHashCode(previousContext));
+          return;
+        }
+
+        ReactContext hostLag = hostLagReactContext.get();
+        if (hostCurrent == reactContext) {
+          if (hostLag != null && hostLag == reactContext) {
+            Log.w(
+                TAG,
+                "Ignoring attach of host-lag ReactContext@"
+                    + System.identityHashCode(reactContext)
+                    + "; keeping live @"
+                    + System.identityHashCode(previousContext));
+            return;
+          }
+          acceptAttachedContext(
+              reactContext, /* resetListenerState= */ pendingReactContext.get() != reactContext);
+          clearConvergenceState();
+          discardAttachedListenerSnapshot();
+        } else if (hostCurrent == previousContext) {
+          // Host still names the dying attached generation. Remember the candidate as pending
+          // so detach/host catch-up can converge. Idempotent re-attach of the same pending
+          // identity (e.g. async onHostResume while the host still lags) must not wipe
+          // listeners the pending JS already registered. Reset only when entering pending for
+          // a new candidate: first pending, or last-writer-wins replace of a different one.
+          ReactContext existingPending = pendingReactContext.get();
+          boolean newPendingCandidate = existingPending != reactContext;
+          Log.i(
+              TAG,
+              "Host still on @"
+                  + System.identityHashCode(previousContext)
+                  + "; pending attach of @"
+                  + System.identityHashCode(reactContext)
+                  + (newPendingCandidate ? "" : " (idempotent)"));
+          pendingReactContext = new WeakReference<>(reactContext);
+          hostLagReactContext = new WeakReference<>(previousContext);
+          if (newPendingCandidate) {
+            // Drop previous-generation listener accounting; replacement JS will re-register.
+            // Snapshot once per pending window so pending-only cancel can restore the
+            // surviving attached generation (last-writer-wins replace keeps the first
+            // snapshot — that is still the attached runtime's pre-pending state).
+            snapshotAttachedListenerStateIfNeeded();
+            resetListenerState();
+          }
+          handler.post(this::tryConvergePendingReactContext);
+          return;
+        } else {
+          Log.w(
+              TAG,
+              "Ignoring attach of non-current ReactContext@"
+                  + System.identityHashCode(reactContext)
+                  + ", current is @"
+                  + System.identityHashCode(hostCurrent));
+          return;
+        }
+      } else if (previousContext != reactContext) {
+        acceptAttachedContext(reactContext, /* resetListenerState= */ false);
+        clearConvergenceState();
+      } else {
+        // Same context re-attach (e.g. resume). Clear lag only when this identity is the
+        // live pending/attached generation the host has caught up to — not when we are
+        // still the dying hostLag while a different pending replacement is waiting.
+        if (hostCurrent == reactContext) {
+          ReactContext pending = pendingReactContext.get();
+          if (pending == null || pending == reactContext) {
+            clearConvergenceState();
+          }
+        }
+      }
+    }
+
+    handler.post(this::sendQueuedEvents);
+  }
+
+  public void detachReactContext(final ReactContext reactContext) {
+    synchronized (jsListeners) {
+      // Pending-only invalidate (failed replacement startup / overlapping teardown): the
+      // candidate never became attached, so cancel it before the attached-identity check.
+      // Restore the surviving attached generation's listener / jsReady snapshot taken when
+      // pending first entered — pending-window registrations belong to the cancelled
+      // generation and must not leave the attached runtime deaf. Superseded identities that
+      // are not the current pending fall through and no-op below — they must not wipe a
+      // newer live pending's registrations.
+      ReactContext pending = pendingReactContext.get();
+      if (pending == reactContext && attachedReactContext.get() != reactContext) {
+        Log.i(
+            TAG,
+            "Cancelled pending ReactContext@"
+                + System.identityHashCode(reactContext)
+                + "; attached remains @"
+                + System.identityHashCode(attachedReactContext.get()));
+        clearConvergenceState();
+        restoreAttachedListenerSnapshot();
+        // Events queued while the pending window wiped listeners must drain now — attached
+        // JS already registered before pending entered and will not re-addListener.
+        handler.post(this::sendQueuedEvents);
+        return;
+      }
+
+      // Only clear state installed by the runtime that is going away; a dying generation
+      // must not wipe listener registrations a replacement runtime has already made. A
+      // replacement runtime always attaches (synchronously, at module creation) before its
+      // JS can register listeners, so an identity match here means the dying state is ours.
+      if (attachedReactContext.get() != reactContext) {
+        return;
+      }
+
+      if (pending != null && pending != reactContext) {
+        Log.i(
+            TAG,
+            "Detached ReactContext@"
+                + System.identityHashCode(reactContext)
+                + "; promoting pending @"
+                + System.identityHashCode(pending));
+        attachedReactContext = new WeakReference<>(pending);
+        pendingReactContext = new WeakReference<>(null);
+        // Keep jsReady / jsListeners: they belong to the promoted generation's JS.
+        // hostLag stays set so emit and late attaches do not regress to the dying identity
+        // while the host ref still names it.
+        discardAttachedListenerSnapshot();
+        emitPrefersRestoredAttached = false;
+        handler.post(this::sendQueuedEvents);
+        return;
+      }
+
+      Log.i(TAG, "Detached ReactContext@" + System.identityHashCode(reactContext));
+      attachedReactContext = new WeakReference<>(null);
+      resetListenerState();
+      clearConvergenceState();
+      discardAttachedListenerSnapshot();
+      emitPrefersRestoredAttached = false;
+      // queuedEvents are intentionally kept: they drain once the next runtime attaches and
+      // registers listeners, which is how events raised while no runtime is alive (for
+      // example messaging events for a killed app) reach JS.
+    }
   }
 
   public void notifyJsReady(Boolean ready) {
-    handler.post(
-        () -> {
-          jsReady = ready;
-          sendQueuedEvents();
-        });
+    synchronized (jsListeners) {
+      jsReady = ready;
+    }
+
+    handler.post(this::sendQueuedEvents);
   }
 
   public void sendEvent(final NativeEvent event) {
     handler.post(
         () -> {
           synchronized (jsListeners) {
-            if (!jsListeners.containsKey(event.getEventName()) || !emit(event)) {
+            if (!jsListeners.containsKey(event.getEventName())) {
+              queuedEvents.add(event);
+              return;
+            }
+          }
+          // emit() resolves ReactApplication host current outside jsListeners; do not hold
+          // the monitor across that call.
+          if (!emit(event)) {
+            synchronized (jsListeners) {
               queuedEvents.add(event);
             }
           }
@@ -105,15 +303,36 @@ public class ReactNativeFirebaseEventEmitter {
     WritableMap writableMap = Arguments.createMap();
     WritableMap events = Arguments.createMap();
 
-    writableMap.putInt("listeners", jsListenerCount);
-    writableMap.putInt("queued", queuedEvents.size());
+    // Resolve host current outside jsListeners; converge/snapshot under the monitor.
+    ReactContext pendingHint;
+    ReactContext attachedHint;
+    synchronized (jsListeners) {
+      pendingHint = pendingReactContext.get();
+      attachedHint = attachedReactContext.get();
+    }
+    ReactContext hostForConverge =
+        getCurrentReactContextFromHost(pendingHint != null ? pendingHint : attachedHint);
 
+    ReactContext attachedContext;
     synchronized (jsListeners) {
+      tryConvergePendingReactContextLocked(hostForConverge);
+      attachedContext = attachedReactContext.get();
+
+      writableMap.putInt("listeners", jsListenerCount);
+      writableMap.putInt("queued", queuedEvents.size());
+      writableMap.putBoolean("jsReady", jsReady);
+      writableMap.putInt(
+          "attachedContextHash",
+          attachedContext == null ? 0 : System.identityHashCode(attachedContext));
+
       for (HashMap.Entry<String, Integer> entry : jsListeners.entrySet()) {
         events.putInt(entry.getKey(), entry.getValue());
       }
     }
 
+    ReactContext currentContext = getCurrentReactContextFromHost(attachedContext);
+    writableMap.putInt(
+        "currentContextHash", currentContext == null ? 0 : System.identityHashCode(currentContext));
     writableMap.putMap("events", events);
 
     return writableMap;
@@ -121,31 +340,267 @@ public class ReactNativeFirebaseEventEmitter {
 
   @MainThread
   private void sendQueuedEvents() {
+    List<NativeEvent> toSend;
     synchronized (jsListeners) {
+      toSend = new ArrayList<>();
       for (NativeEvent event : new ArrayList<>(queuedEvents)) {
         if (jsListeners.containsKey(event.getEventName())) {
           queuedEvents.remove(event);
-          sendEvent(event);
+          toSend.add(event);
         }
       }
     }
+    for (NativeEvent event : toSend) {
+      sendEvent(event);
+    }
   }
 
   @MainThread
   private boolean emit(final NativeEvent event) {
-    if (!jsReady || reactContext == null || !reactContext.hasActiveCatalystInstance()) {
+    // Snapshot readiness / pointers under the monitor, resolve host current outside (avoid
+    // holding jsListeners across ReactApplication getters), then re-enter to converge/resolve.
+    ReactContext attachedHint;
+    boolean ready;
+    synchronized (jsListeners) {
+      ready = jsReady;
+      if (!ready) {
+        return false;
+      }
+      attachedHint = attachedReactContext.get();
+      if (attachedHint == null) {
+        attachedHint = pendingReactContext.get();
+      }
+    }
+    ReactContext hostCurrent = getCurrentReactContextFromHost(attachedHint);
+
+    ReactContext emitContext;
+    synchronized (jsListeners) {
+      if (!jsReady) {
+        return false;
+      }
+      tryConvergePendingReactContextLocked(hostCurrent);
+
+      // Resolve the context hosting the live JS runtime at emit time rather than trusting the
+      // attached one alone: a context captured at module-creation time can belong to a previous
+      // generation whose runtime no longer contains the JS listeners, and on bridgeless a stale
+      // context still reports an active instance so it cannot be validated - only replaced
+      // (#8374, #8900). When attached has already converged ahead of a lagging host ref, prefer
+      // attached over the dying host current so events are not delivered into a runtime with no
+      // listeners.
+      ReactContext attached = attachedReactContext.get();
+      emitContext = resolveEmitContext(attached, hostCurrent);
+    }
+
+    if (emitContext == null || !emitContext.hasActiveReactInstance()) {
       return false;
     }
 
     try {
-      reactContext
+      emitContext
           .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
           .emit("rnfb_" + event.getEventName(), event.getEventBody());
     } catch (Exception e) {
-      Log.wtf("RNFB_EMITTER", "Error sending Event " + event.getEventName(), e);
+      Log.wtf(TAG, "Error sending Event " + event.getEventName(), e);
       return false;
     }
 
     return true;
   }
+
+  @Nullable
+  private ReactContext resolveEmitContext(
+      @Nullable ReactContext attached, @Nullable ReactContext hostCurrent) {
+    ReactContext pending = pendingReactContext.get();
+    ReactContext hostLag = hostLagReactContext.get();
+
+    // A pending replacement owns (or will own) the listener map. Prefer it over host/attached
+    // for the whole pending window — including when the host has already advanced to an
+    // unrelated third generation that has not yet attached via this emitter. Emitting into
+    // that third context would return true with no RNFB JS subscribers and no re-queue.
+    if (pending != null) {
+      return pending;
+    }
+
+    if (hostCurrent == null) {
+      return attached;
+    }
+    if (attached == null || attached == hostCurrent) {
+      if (attached == hostCurrent) {
+        clearConvergenceState();
+        emitPrefersRestoredAttached = false;
+      }
+      return hostCurrent;
+    }
+
+    if (hostLag != null && hostLag == hostCurrent) {
+      return attached;
+    }
+
+    // Pending-only cancel restored listeners onto attached; an unrelated hostCurrent that has
+    // not yet attached through this emitter must not steal delivery (silent loss, no re-queue).
+    // Flag is only set while an attached generation still owns the restored map.
+    if (emitPrefersRestoredAttached) {
+      return attached;
+    }
+
+    // Attached is stale relative to a host that has moved on — prefer the host.
+    return hostCurrent;
+  }
+
+  private void tryConvergePendingReactContext() {
+    ReactContext pendingHint;
+    synchronized (jsListeners) {
+      pendingHint = pendingReactContext.get();
+    }
+    if (pendingHint == null) {
+      return;
+    }
+    ReactContext hostCurrent = getCurrentReactContextFromHost(pendingHint);
+    synchronized (jsListeners) {
+      if (tryConvergePendingReactContextLocked(hostCurrent)) {
+        handler.post(this::sendQueuedEvents);
+      }
+    }
+  }
+
+  /**
+   * Prefer resolving {@code hostCurrent} outside {@code jsListeners} and passing it in so
+   * ReactApplication getters are not held under the listener monitor.
+   *
+   * @return true when attachment changed
+   */
+  private boolean tryConvergePendingReactContextLocked(@Nullable ReactContext hostCurrent) {
+    ReactContext pending = pendingReactContext.get();
+    if (pending == null) {
+      return false;
+    }
+    if (hostCurrent != pending) {
+      return false;
+    }
+    ReactContext previous = attachedReactContext.get();
+    if (previous == pending) {
+      clearConvergenceState();
+      return false;
+    }
+    Log.i(
+        TAG, "Host caught up; attaching pending ReactContext@" + System.identityHashCode(pending));
+    acceptAttachedContext(pending, /* resetListenerState= */ false);
+    clearConvergenceState();
+    discardAttachedListenerSnapshot();
+    return true;
+  }
+
+  private void acceptAttachedContext(ReactContext reactContext, boolean resetListenerState) {
+    ReactContext previousContext = attachedReactContext.get();
+    if (previousContext != reactContext) {
+      Log.i(
+          TAG,
+          "ReactContext changed: @"
+              + System.identityHashCode(previousContext)
+              + " -> @"
+              + System.identityHashCode(reactContext));
+      attachedReactContext = new WeakReference<>(reactContext);
+      // A real attach of a new generation supersedes restored-attached emit affinity.
+      emitPrefersRestoredAttached = false;
+      if (resetListenerState) {
+        discardAttachedListenerSnapshot();
+        resetListenerState();
+      }
+    }
+  }
+
+  private void resetListenerState() {
+    jsReady = false;
+    jsListeners.clear();
+    jsListenerCount = 0;
+  }
+
+  private void snapshotAttachedListenerStateIfNeeded() {
+    if (attachedListenersSnapshot != null) {
+      return;
+    }
+    attachedListenersSnapshot = new HashMap<>(jsListeners);
+    attachedJsReadySnapshot = jsReady;
+    attachedJsListenerCountSnapshot = jsListenerCount;
+  }
+
+  private void restoreAttachedListenerSnapshot() {
+    if (attachedListenersSnapshot == null) {
+      resetListenerState();
+      emitPrefersRestoredAttached = false;
+      return;
+    }
+    jsListeners.clear();
+    jsListeners.putAll(attachedListenersSnapshot);
+    jsReady = attachedJsReadySnapshot;
+    jsListenerCount = attachedJsListenerCountSnapshot;
+    discardAttachedListenerSnapshot();
+    emitPrefersRestoredAttached = true;
+  }
+
+  private void discardAttachedListenerSnapshot() {
+    attachedListenersSnapshot = null;
+    attachedJsReadySnapshot = false;
+    attachedJsListenerCountSnapshot = 0;
+  }
+
+  private void clearConvergenceState() {
+    pendingReactContext = new WeakReference<>(null);
+    hostLagReactContext = new WeakReference<>(null);
+  }
+
+  @Nullable
+  private static ReactContext getCurrentReactContextFromHost(@Nullable ReactContext contextHint) {
+    Context applicationContext =
+        contextHint != null
+            ? contextHint.getApplicationContext()
+            : ReactNativeFirebaseApp.getApplicationContext();
+    if (applicationContext != null) {
+      // Normalize in case a non-application context (for example a ContentProvider context)
+      // was stored as the fallback.
+      applicationContext = applicationContext.getApplicationContext();
+    }
+    if (!(applicationContext instanceof ReactApplication)) {
+      // Brownfield hosts that do not implement ReactApplication fall back to the attached
+      // context, preserving pre-existing behaviour.
+      return null;
+    }
+
+    ReactApplication reactApplication = (ReactApplication) applicationContext;
+
+    // Note: these getters may lazily construct their host on first call; that is acceptable
+    // here because a live react-native-firebase module implies the app's host already exists.
+    ReactContext fromReactHost = null;
+    try {
+      ReactHost reactHost = reactApplication.getReactHost();
+      if (reactHost != null) {
+        fromReactHost = reactHost.getCurrentReactContext();
+        if (fromReactHost != null) {
+          return fromReactHost;
+        }
+        // Hybrid / transitional hosts may expose a non-null ReactHost whose current context
+        // is briefly null while the bridge ReactNativeHost still carries the live context.
+        // Fall through rather than treating null as a permanent answer.
+      }
+    } catch (RuntimeException | LinkageError e) {
+      // App-authored hosts may throw, and react-native 0.83+ throws from the deprecated
+      // reactNativeHost getter on bridgeless-only apps.
+      Log.d(TAG, "Failed to resolve current ReactContext via ReactHost", e);
+    }
+
+    try {
+      ReactNativeHost reactNativeHost = reactApplication.getReactNativeHost();
+      // hasInstance() guards against getReactInstanceManager() eagerly creating an instance
+      // manager purely as a side effect of emitting an event.
+      if (reactNativeHost != null && reactNativeHost.hasInstance()) {
+        return reactNativeHost.getReactInstanceManager().getCurrentReactContext();
+      }
+    } catch (RuntimeException | LinkageError e) {
+      // Bridgeless-only apps throw from getReactNativeHost(); if ReactHost was present but
+      // returned null current, that null stands — still log so the failure is visible.
+      Log.d(TAG, "Failed to resolve current ReactContext via ReactNativeHost", e);
+    }
+
+    return fromReactHost;
+  }
 }

package/android/src/reactnative/java/io/invertase/firebase/common/ReactNativeFirebaseMeta.java

@@ -70,6 +70,12 @@ public class ReactNativeFirebaseMeta {
     return metaData.getString(META_PREFIX + key, defaultValue);
   }
 
+  public int getIntValue(String key, int defaultValue) {
+    Bundle metaData = getMetaData();
+    if (metaData == null) return defaultValue;
+    return metaData.getInt(META_PREFIX + key, defaultValue);
+  }
+
   public WritableMap getAll() {
     Bundle metaData = getMetaData();
     WritableMap map = Arguments.createMap();
@@ -84,6 +90,8 @@ public class ReactNativeFirebaseMeta {
           map.putString(key, (String) value);
         } else if (value instanceof Boolean) {
           map.putBoolean(key, (Boolean) value);
+        } else if (value instanceof Integer) {
+          map.putInt(key, (Integer) value);
         }
       }
     }

package/android/src/reactnative/java/io/invertase/firebase/common/ReactNativeFirebasePreferences.java

@@ -46,6 +46,14 @@ public class ReactNativeFirebasePreferences {
     return getPreferences().getBoolean(key, defaultValue);
   }
 
+  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);
+  }
+
   public void setLongValue(String key, long value) {
     getPreferences().edit().putLong(key, value).apply();
   }