Fix Fabric out-of-order event delivery on Android

Summary:
Fixes #54636. Thanks to the Software Mansion team for the detailed reproduction and analysis.

Based on #56634

On Android Fabric, events emitted for a tag whose `EventEmitterWrapper` has not yet been set (e.g. the view is preallocated but not mounted) are buffered in a per-ViewState queue. When `updateEventEmitter` later sets the emitter, it drains the queue. However, events arriving between the queue-post and the drain could bypass the queue and dispatch directly, delivering events to JS out of receive order.

This change replaces the lambda-based `enqueuePendingEvent` (which deferred event buffering to a `runOnUiThread` lambda, leaving events "in limbo" in the Handler queue) with direct queue insertion under a `synchronized(viewState)` lock:

- `dispatchEvent` fast path: two volatile reads (`eventEmitter`, `pendingEventQueue`). If the emitter is set and no queue exists, dispatch directly — no lock, no allocation.
- `dispatchEvent` slow path (rare, during view init): `synchronized(viewState)` — re-check emitter under lock; if still null, create queue and enqueue the event. If the emitter became available between the volatile read and the lock, a barrier (`synchronized<Unit>(viewState) {}`) waits for any in-progress drain before dispatching.
- `updateEventEmitter`: `synchronized(viewState)` — set emitter, drain queue, null the queue reference. The queue stays non-null during the drain, so concurrent fast-path checks correctly fall through to the barrier.

Queue nullability (`pendingEventQueue == null`) is the cross-thread signal that replaces the previous `AtomicInteger` counter approach.

## Changelog:

[ANDROID][FIXED] - Fix Fabric out-of-order event delivery for events emitted before view mount
[ANDROID][BREAKING] - Removed SurfaceMountingManager#enqueuePendingEvent

Reviewed By: mdvacca

Differential Revision: D102822618

fbshipit-source-id: d683ef50e8c6bcd52cc947b3eda9cb2c1e1296ff

Co-authored-by: Mohanraj Venkatesan <mohanraj.venkatesan2304@gmail.com>

Author: 2 people

packages/react-native/ReactAndroid/api/ReactAndroid.api

@@ -2281,8 +2281,6 @@ public final class com/facebook/react/fabric/mounting/SurfaceMountingManager {
 	public final fun applyViewSnapshot (ILandroid/graphics/Bitmap;)V
 	public final fun attachRootView (Landroid/view/View;Lcom/facebook/react/uimanager/ThemedReactContext;)V
 	public final fun deleteView (I)V
-	public final fun enqueuePendingEvent (ILjava/lang/String;ZLcom/facebook/react/bridge/WritableMap;I)V
-	public final fun enqueuePendingEvent (ILjava/lang/String;ZLcom/facebook/react/bridge/WritableMap;IJ)V
 	public final fun getContext ()Lcom/facebook/react/uimanager/ThemedReactContext;
 	public final fun getSurfaceId ()I
 	public final fun getView (I)Landroid/view/View;

packages/react-native/ReactAndroid/src/main/java/com/facebook/react/fabric/mounting/SurfaceMountingManager.kt

@@ -9,7 +9,6 @@ package com.facebook.react.fabric.mounting
 
 import android.annotation.SuppressLint
 import android.graphics.Bitmap
-import android.os.SystemClock
 import android.view.View
 import android.view.ViewGroup
 import android.view.ViewParent
@@ -965,22 +964,19 @@ internal constructor(
           }
           vs
         }
+
     val previousEventEmitterWrapper = viewState.eventEmitter
-    viewState.eventEmitter = eventEmitter
+    synchronized(viewState) {
+      viewState.eventEmitter = eventEmitter
+      // Invoke pending events queued to the view state
+      viewState.pendingEventQueue?.forEach { it.dispatch(eventEmitter) }
+      viewState.pendingEventQueue = null
+    }
 
     // Immediately destroy native side of wrapper, instead of waiting for Java GC.
     if (previousEventEmitterWrapper != eventEmitter && previousEventEmitterWrapper != null) {
       previousEventEmitterWrapper.destroy()
     }
-
-    val pendingEventQueue = viewState.pendingEventQueue
-    if (pendingEventQueue != null) {
-      // Invoke pending event queued to the view state
-      for (viewEvent in pendingEventQueue) {
-        viewEvent.dispatch(eventEmitter)
-      }
-      viewState.pendingEventQueue = null
-    }
   }
 
   @UiThread
@@ -1190,57 +1186,6 @@ internal constructor(
     }
   }
 
-  @AnyThread
-  public fun enqueuePendingEvent(
-      reactTag: Int,
-      eventName: String,
-      canCoalesceEvent: Boolean,
-      params: WritableMap?,
-      @EventCategoryDef eventCategory: Int,
-  ): Unit {
-    enqueuePendingEvent(
-        reactTag,
-        eventName,
-        canCoalesceEvent,
-        params,
-        eventCategory,
-        SystemClock.uptimeMillis(),
-    )
-  }
-
-  @AnyThread
-  public fun enqueuePendingEvent(
-      reactTag: Int,
-      eventName: String,
-      canCoalesceEvent: Boolean,
-      params: WritableMap?,
-      @EventCategoryDef eventCategory: Int,
-      eventTimestamp: Long,
-  ): Unit {
-    // When the surface stopped we will reset the view state map. We are not going to enqueue
-    // pending events as they are not expected to be dispatched anyways.
-    val viewState = registryGet(reactTag)
-
-    if (viewState == null) {
-      // Cannot queue event without view state. Do nothing here.
-      return
-    }
-
-    val viewEvent =
-        PendingViewEvent(eventName, params, eventCategory, canCoalesceEvent, eventTimestamp)
-    UiThreadUtil.runOnUiThread {
-      val eventEmitter = viewState.eventEmitter
-      if (eventEmitter != null) {
-        viewEvent.dispatch(eventEmitter)
-      } else {
-        val queue =
-            viewState.pendingEventQueue
-                ?: LinkedList<PendingViewEvent>().also { viewState.pendingEventQueue = it }
-        queue.add(viewEvent)
-      }
-    }
-  }
-
   @AnyThread
   internal fun dispatchEvent(
       reactTag: Int,
@@ -1252,31 +1197,43 @@ internal constructor(
   ) {
     val viewState = registryGet(reactTag)
     if (viewState == null) {
-      // This can happen if the view has disappeared from the screen (because of async events)
       FLog.i(TAG, "Unable to invoke event: %s for reactTag: %d", eventName, reactTag)
       return
     }
 
-    val eventEmitter = viewState.eventEmitter
-    if (eventEmitter == null) {
-      // The view is pre-allocated and created. However, it hasn't been mounted yet. We will have
-      // access to the event emitter later when the view is mounted. For now just save the event
-      // in the view state and trigger it later.
-      enqueuePendingEvent(
-          reactTag,
-          eventName,
-          canCoalesceEvent,
-          params,
-          eventCategory,
-          eventTimestamp,
-      )
-      return
+    var emitter = viewState.eventEmitter
+    if (emitter == null) {
+      synchronized(viewState) {
+        val emitterUnderLock = viewState.eventEmitter
+        if (emitterUnderLock != null) {
+          emitter = emitterUnderLock
+        } else {
+          // The view is pre-allocated and created. However, it hasn't been mounted yet. We will
+          // have access to the event emitter later when the view is mounted. For now just save the
+          // event in the view state and trigger it later.
+          val queue =
+              viewState.pendingEventQueue
+                  ?: LinkedList<PendingViewEvent>().also { viewState.pendingEventQueue = it }
+          queue.add(
+              PendingViewEvent(eventName, params, eventCategory, canCoalesceEvent, eventTimestamp)
+          )
+          return
+        }
+      }
     }
 
+    if (viewState.pendingEventQueue != null) {
+      // We have an emitter and also a pending event queue - we must lock
+      // and wait for the pending event queue to be cleared.
+      synchronized<Unit>(viewState) {}
+      assert(viewState.pendingEventQueue == null)
+    }
+
+    checkNotNull(emitter)
     if (canCoalesceEvent) {
-      eventEmitter.dispatchUnique(eventName, params, eventTimestamp)
+      emitter.dispatchUnique(eventName, params, eventTimestamp)
     } else {
-      eventEmitter.dispatch(eventName, params, eventCategory, eventTimestamp)
+      emitter.dispatch(eventName, params, eventCategory, eventTimestamp)
     }
   }
 
@@ -1304,9 +1261,8 @@ internal constructor(
   ) {
     var currentProps: ReactStylesDiffMap? = null
     var stateWrapper: StateWrapper? = null
-    var eventEmitter: EventEmitterWrapper? = null
-
-    @ThreadConfined(ThreadConfined.UI) var pendingEventQueue: Queue<PendingViewEvent>? = null
+    @Volatile var eventEmitter: EventEmitterWrapper? = null
+    @Volatile var pendingEventQueue: Queue<PendingViewEvent>? = null
 
     override fun toString(): String {
       val isLayoutOnly = viewManager == null