react-native-tvos 0.77.1-0 → 0.78.0-0

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/events/EventDispatcherListener.kt

@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+package com.facebook.react.uimanager.events
+
+/** Interface used to intercept events dispatched by [EventDispatcher] */
+public fun interface EventDispatcherListener {
+  /**
+   * Called on every time an event is dispatched using [EventDispatcher.dispatchEvent]. Will be
+   * called from the same thread that the event is being dispatched from.
+   *
+   * @param event Event that was dispatched
+   */
+  public fun onEventDispatch(event: Event<*>)
+}

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/events/EventDispatcherProvider.kt

@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+package com.facebook.react.uimanager.events
+
+/**
+ * An interface that can be implemented by a [com.facebook.react.bridge.ReactContext] to provide a
+ * first-class API for accessing the [EventDispatcher] from the
+ * [com.facebook.react.bridge.UIManager].
+ */
+public fun interface EventDispatcherProvider {
+  /**
+   * This should always return an [EventDispatcher], even if the instance doesn't exist; in that
+   * case it should return the empty [BlackHoleEventDispatcher].
+   *
+   * @return An [EventDispatcher] to emit events to JS.
+   */
+  public fun getEventDispatcher(): EventDispatcher
+}

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/events/FabricEventDispatcher.kt

@@ -0,0 +1,241 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+package com.facebook.react.uimanager.events
+
+import android.os.Handler
+import android.view.Choreographer
+import com.facebook.react.bridge.LifecycleEventListener
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactNoCrashSoftException
+import com.facebook.react.bridge.ReactSoftExceptionLogger
+import com.facebook.react.bridge.UIManager
+import com.facebook.react.bridge.UiThreadUtil
+import com.facebook.react.internal.featureflags.ReactNativeFeatureFlags
+import com.facebook.react.modules.core.ReactChoreographer
+import com.facebook.react.uimanager.UIManagerHelper
+import com.facebook.react.uimanager.common.UIManagerType
+import com.facebook.systrace.Systrace
+import java.util.concurrent.CopyOnWriteArrayList
+import kotlin.concurrent.Volatile
+
+/**
+ * A singleton class that overrides [EventDispatcher] with no-op methods, to be used by callers that
+ * expect an EventDispatcher when the instance doesn't exist.
+ */
+public open class FabricEventDispatcher(reactContext: ReactApplicationContext) :
+    EventDispatcher, LifecycleEventListener {
+  private val reactEventEmitter: ReactEventEmitter
+  private val reactContext: ReactApplicationContext = reactContext
+  private val listeners = CopyOnWriteArrayList<EventDispatcherListener>()
+  private val postEventDispatchListeners = CopyOnWriteArrayList<BatchEventDispatchedListener>()
+  private val currentFrameCallback: ScheduleDispatchFrameCallback = ScheduleDispatchFrameCallback()
+
+  private var isDispatchScheduled = false
+  private val dispatchEventsRunnable = Runnable {
+    isDispatchScheduled = false
+    Systrace.beginSection(Systrace.TRACE_TAG_REACT_JAVA_BRIDGE, "BatchEventDispatchedListeners")
+    try {
+      for (listener in postEventDispatchListeners) {
+        listener.onBatchEventDispatched()
+      }
+    } finally {
+      Systrace.endSection(Systrace.TRACE_TAG_REACT_JAVA_BRIDGE)
+    }
+  }
+
+  init {
+    this.reactContext.addLifecycleEventListener(this)
+    reactEventEmitter = ReactEventEmitter(this.reactContext)
+  }
+
+  public override fun dispatchEvent(event: Event<*>) {
+    for (listener in listeners) {
+      listener.onEventDispatch(event)
+    }
+    if (event.experimental_isSynchronous()) {
+      dispatchSynchronous(event)
+    } else {
+      event.dispatchModern(reactEventEmitter)
+    }
+
+    event.dispose()
+    scheduleDispatchOfBatchedEvents()
+  }
+
+  private fun dispatchSynchronous(event: Event<*>) {
+    Systrace.beginSection(
+        Systrace.TRACE_TAG_REACT_JAVA_BRIDGE,
+        "FabricEventDispatcher.dispatchSynchronous('" + event.eventName + "')")
+    try {
+      val fabricUIManager: UIManager? =
+          UIManagerHelper.getUIManager(reactContext, UIManagerType.FABRIC)
+      @Suppress("DEPRECATION")
+      if (fabricUIManager is SynchronousEventReceiver) {
+        @Suppress("DEPRECATION")
+        (fabricUIManager as SynchronousEventReceiver).receiveEvent(
+            event.surfaceId,
+            event.viewTag,
+            event.eventName,
+            event.canCoalesce(),
+            event.eventData,
+            event.eventCategory,
+            true)
+      } else {
+        ReactSoftExceptionLogger.logSoftException(
+            "FabricEventDispatcher",
+            ReactNoCrashSoftException(
+                "Fabric UIManager expected to implement SynchronousEventReceiver."))
+      }
+    } finally {
+      Systrace.endSection(Systrace.TRACE_TAG_REACT_JAVA_BRIDGE)
+    }
+  }
+
+  public override fun dispatchAllEvents() {
+    scheduleDispatchOfBatchedEvents()
+  }
+
+  private fun scheduleDispatchOfBatchedEvents() {
+    if (ReactNativeFeatureFlags.useOptimizedEventBatchingOnAndroid()) {
+      if (!isDispatchScheduled) {
+        isDispatchScheduled = true
+        uiThreadHandler.postAtFrontOfQueue(dispatchEventsRunnable)
+      }
+    } else {
+      currentFrameCallback.maybeScheduleDispatchOfBatchedEvents()
+    }
+  }
+
+  /** Add a listener to this EventDispatcher. */
+  public override fun addListener(listener: EventDispatcherListener) {
+    listeners.add(listener)
+  }
+
+  /** Remove a listener from this EventDispatcher. */
+  public override fun removeListener(listener: EventDispatcherListener) {
+    listeners.remove(listener)
+  }
+
+  public override fun addBatchEventDispatchedListener(listener: BatchEventDispatchedListener) {
+    postEventDispatchListeners.add(listener)
+  }
+
+  public override fun removeBatchEventDispatchedListener(listener: BatchEventDispatchedListener) {
+    postEventDispatchListeners.remove(listener)
+  }
+
+  public override fun onHostResume() {
+    scheduleDispatchOfBatchedEvents()
+    if (!ReactNativeFeatureFlags.useOptimizedEventBatchingOnAndroid()) {
+      currentFrameCallback.resume()
+    }
+  }
+
+  public override fun onHostPause() {
+    cancelDispatchOfBatchedEvents()
+  }
+
+  public override fun onHostDestroy() {
+    cancelDispatchOfBatchedEvents()
+  }
+
+  public override fun onCatalystInstanceDestroyed() {
+    UiThreadUtil.runOnUiThread(Runnable { cancelDispatchOfBatchedEvents() })
+  }
+
+  private fun cancelDispatchOfBatchedEvents() {
+    UiThreadUtil.assertOnUiThread()
+    if (ReactNativeFeatureFlags.useOptimizedEventBatchingOnAndroid()) {
+      isDispatchScheduled = false
+      uiThreadHandler.removeCallbacks(dispatchEventsRunnable)
+    } else {
+      currentFrameCallback.stop()
+    }
+  }
+
+  @Deprecated("Use the modern version with RCTModernEventEmitter")
+  @Suppress("DEPRECATION")
+  public override fun registerEventEmitter(
+      @UIManagerType uiManagerType: Int,
+      eventEmitter: RCTEventEmitter
+  ) {
+    reactEventEmitter.register(uiManagerType, eventEmitter)
+  }
+
+  public override fun registerEventEmitter(
+      @UIManagerType uiManagerType: Int,
+      eventEmitter: RCTModernEventEmitter
+  ) {
+    reactEventEmitter.register(uiManagerType, eventEmitter)
+  }
+
+  public override fun unregisterEventEmitter(@UIManagerType uiManagerType: Int) {
+    reactEventEmitter.unregister(uiManagerType)
+  }
+
+  private inner class ScheduleDispatchFrameCallback : Choreographer.FrameCallback {
+    @Volatile private var isFrameCallbackDispatchScheduled = false
+    private var shouldStop = false
+
+    override fun doFrame(frameTimeNanos: Long) {
+      UiThreadUtil.assertOnUiThread()
+
+      if (shouldStop) {
+        isFrameCallbackDispatchScheduled = false
+      } else {
+        dispatchBatchedEvents()
+      }
+
+      Systrace.beginSection(Systrace.TRACE_TAG_REACT_JAVA_BRIDGE, "BatchEventDispatchedListeners")
+      try {
+        for (listener in postEventDispatchListeners) {
+          listener.onBatchEventDispatched()
+        }
+      } finally {
+        Systrace.endSection(Systrace.TRACE_TAG_REACT_JAVA_BRIDGE)
+      }
+    }
+
+    public fun stop() {
+      shouldStop = true
+    }
+
+    public fun resume() {
+      shouldStop = false
+    }
+
+    public fun maybeDispatchBatchedEvents() {
+      if (!isFrameCallbackDispatchScheduled) {
+        isFrameCallbackDispatchScheduled = true
+        dispatchBatchedEvents()
+      }
+    }
+
+    private fun dispatchBatchedEvents() {
+      ReactChoreographer.getInstance()
+          .postFrameCallback(ReactChoreographer.CallbackType.TIMERS_EVENTS, currentFrameCallback)
+    }
+
+    public fun maybeScheduleDispatchOfBatchedEvents() {
+      if (isFrameCallbackDispatchScheduled) {
+        return
+      }
+
+      // We should only hit this slow path when we receive events while the host activity is paused.
+      if (reactContext.isOnUiQueueThread()) {
+        maybeDispatchBatchedEvents()
+      } else {
+        reactContext.runOnUiQueueThread(Runnable { maybeDispatchBatchedEvents() })
+      }
+    }
+  }
+
+  private companion object {
+    private val uiThreadHandler: Handler = UiThreadUtil.getUiThreadHandler()
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/events/PointerEventHelper.kt

@@ -0,0 +1,193 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+package com.facebook.react.uimanager.events
+
+import android.view.InputDevice
+import android.view.MotionEvent
+import android.view.View
+import com.facebook.react.R
+
+/** Class responsible for generating catalyst touch events based on android [MotionEvent]. */
+public object PointerEventHelper {
+  public const val POINTER_TYPE_TOUCH: String = "touch"
+  public const val POINTER_TYPE_PEN: String = "pen"
+  public const val POINTER_TYPE_MOUSE: String = "mouse"
+  public const val POINTER_TYPE_UNKNOWN: String = ""
+  internal const val X_FLAG_SUPPORTS_HOVER = 0x01000000
+
+  public const val POINTER_CANCEL: String = "topPointerCancel"
+  public const val POINTER_DOWN: String = "topPointerDown"
+  public const val POINTER_ENTER: String = "topPointerEnter"
+  public const val POINTER_LEAVE: String = "topPointerLeave"
+  public const val POINTER_MOVE: String = "topPointerMove"
+  public const val POINTER_UP: String = "topPointerUp"
+  public const val POINTER_OVER: String = "topPointerOver"
+  public const val POINTER_OUT: String = "topPointerOut"
+  public const val CLICK: String = "topClick"
+
+  public enum class EVENT {
+    CANCEL,
+    CANCEL_CAPTURE,
+    CLICK,
+    CLICK_CAPTURE,
+    DOWN,
+    DOWN_CAPTURE,
+    ENTER,
+    ENTER_CAPTURE,
+    LEAVE,
+    LEAVE_CAPTURE,
+    MOVE,
+    MOVE_CAPTURE,
+    UP,
+    UP_CAPTURE,
+    OUT,
+    OUT_CAPTURE,
+    OVER,
+    OVER_CAPTURE,
+  }
+
+  // https://w3c.github.io/pointerevents/#the-buttons-property
+  @JvmStatic
+  public fun getButtons(eventName: String?, pointerType: String, buttonState: Int): Int {
+    if (isExitEvent(eventName)) {
+      return 0
+    }
+    if (POINTER_TYPE_TOUCH == pointerType) {
+      return 1
+    }
+    return buttonState
+  }
+
+  // https://w3c.github.io/pointerevents/#the-button-property
+  @JvmStatic
+  public fun getButtonChange(
+      pointerType: String,
+      lastButtonState: Int,
+      currentButtonState: Int
+  ): Int {
+    // Always return 0 for touch
+    if (POINTER_TYPE_TOUCH == pointerType) {
+      return 0
+    }
+
+    val changedMask = currentButtonState xor lastButtonState
+    if (changedMask == 0) {
+      return -1
+    }
+
+    return when (changedMask) {
+      MotionEvent.BUTTON_PRIMARY -> 0
+      MotionEvent.BUTTON_TERTIARY -> 1
+      MotionEvent.BUTTON_SECONDARY -> 2
+      MotionEvent.BUTTON_BACK -> 3
+      MotionEvent.BUTTON_FORWARD -> 4
+      else -> -1
+    }
+  }
+
+  @JvmStatic
+  public fun getW3CPointerType(toolType: Int): String {
+    // https://www.w3.org/TR/pointerevents3/#dom-pointerevent-pointertype
+    return when (toolType) {
+      MotionEvent.TOOL_TYPE_FINGER -> POINTER_TYPE_TOUCH
+      MotionEvent.TOOL_TYPE_STYLUS -> POINTER_TYPE_PEN
+      MotionEvent.TOOL_TYPE_MOUSE -> POINTER_TYPE_MOUSE
+      else -> POINTER_TYPE_UNKNOWN
+    }
+  }
+
+  @JvmStatic
+  public fun isListening(view: View?, event: EVENT): Boolean {
+    if (view == null) {
+      return true
+    }
+
+    return when (event) {
+      EVENT.DOWN,
+      EVENT.DOWN_CAPTURE,
+      EVENT.UP,
+      EVENT.UP_CAPTURE,
+      EVENT.CANCEL,
+      EVENT.CANCEL_CAPTURE,
+      EVENT.CLICK,
+      EVENT.CLICK_CAPTURE -> true
+      else -> {
+        val pointerEvents = view.getTag(R.id.pointer_events) as? Int
+        (pointerEvents != null) && (pointerEvents and (1 shl event.ordinal)) != 0
+      }
+    }
+  }
+
+  @JvmStatic
+  public fun getEventCategory(pointerEventType: String?): Int {
+    if (pointerEventType == null) {
+      return EventCategoryDef.UNSPECIFIED
+    }
+    return when (pointerEventType) {
+      POINTER_DOWN,
+      POINTER_CANCEL,
+      POINTER_UP -> EventCategoryDef.DISCRETE
+      POINTER_MOVE,
+      POINTER_ENTER,
+      POINTER_LEAVE,
+      POINTER_OVER,
+      POINTER_OUT -> EventCategoryDef.CONTINUOUS
+      else -> EventCategoryDef.UNSPECIFIED
+    }
+  }
+
+  public fun supportsHover(motionEvent: MotionEvent): Boolean {
+    // A flag has been set on the MotionEvent to indicate it supports hover
+    // See D36958947 on justifications for this.
+    // TODO(luwe): Leverage previous events to determine if MotionEvent
+    //  is from an input device that supports hover
+    val supportsHoverFlag = (motionEvent.flags and X_FLAG_SUPPORTS_HOVER) != 0
+    if (supportsHoverFlag) {
+      return true
+    }
+
+    return motionEvent.isFromSource(InputDevice.SOURCE_MOUSE)
+  }
+
+  public fun isExitEvent(eventName: String?): Boolean {
+    return when (eventName) {
+      POINTER_UP,
+      POINTER_LEAVE,
+      POINTER_OUT -> true
+      else -> false
+    }
+  }
+
+  // https://w3c.github.io/pointerevents/#dom-pointerevent-pressure
+  @JvmStatic
+  public fun getPressure(buttonState: Int, eventName: String?): Double {
+    if (isExitEvent(eventName)) {
+      return 0.0
+    }
+
+    // Assume  we don't support pressure on our platform for now
+    //  For hardware and platforms that do not support pressure,
+    //  the value MUST be 0.5 when in the active buttons state
+    //  and 0 otherwise.
+    val inActiveButtonState = buttonState != 0
+    return if (inActiveButtonState) 0.5 else 0.0
+  }
+
+  @JvmStatic
+  public fun isBubblingEvent(eventName: String?): Boolean {
+    return when (eventName) {
+      POINTER_UP,
+      POINTER_DOWN,
+      POINTER_OVER,
+      POINTER_OUT,
+      POINTER_MOVE,
+      POINTER_CANCEL -> true
+      else -> false
+    }
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/events/RCTEventEmitter.kt

@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+package com.facebook.react.uimanager.events
+
+import com.facebook.proguard.annotations.DoNotStripAny
+import com.facebook.react.bridge.JavaScriptModule
+import com.facebook.react.bridge.WritableArray
+import com.facebook.react.bridge.WritableMap
+
+/**
+ * Paper JS interface to emit events from native to JS.
+ *
+ * Deprecated in favor of [RCTModernEventEmitter], which works with both the old and new renderer.
+ */
+@DoNotStripAny
+@Deprecated("Use [RCTModernEventEmitter] instead")
+public interface RCTEventEmitter : JavaScriptModule {
+  /**
+   * @param targetTag react tag of the view that receives the event
+   * @param eventName name of event
+   * @param params event params
+   */
+  @Deprecated("Use [RCTModernEventEmitter.receiveEvent] instead")
+  public fun receiveEvent(targetTag: Int, eventName: String, params: WritableMap?)
+
+  /**
+   * Receive and process touches
+   *
+   * @param eventName JS event name
+   * @param touches active pointers data
+   * @param changedIndices indices of changed pointers
+   */
+  @Deprecated("Dispatch the TouchEvent using [EventDispatcher] instead")
+  public fun receiveTouches(
+      eventName: String,
+      touches: WritableArray,
+      changedIndices: WritableArray
+  )
+}

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/events/RCTModernEventEmitter.kt

@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+package com.facebook.react.uimanager.events
+
+import com.facebook.react.bridge.WritableMap
+
+/**
+ * This is a transitional replacement for [RCTEventEmitter] that works with Fabric and non-Fabric
+ * renderers. [RCTEventEmitter] works with Fabric as well, but there are negative perf implications
+ * and it should be avoided.
+ *
+ * This interface will *also* be deleted in the distant future and be replaced with a new interface
+ * that doesn't need the old `receiveEvent` method at all. But for the foreseeable future, this is
+ * the recommended interface to use for EventEmitters.
+ */
+@Suppress("DEPRECATION")
+public interface RCTModernEventEmitter : RCTEventEmitter {
+  public fun receiveEvent(surfaceId: Int, targetTag: Int, eventName: String, params: WritableMap?)
+
+  public fun receiveEvent(
+      surfaceId: Int,
+      targetTag: Int,
+      eventName: String,
+      canCoalesceEvent: Boolean,
+      customCoalesceKey: Int,
+      params: WritableMap?,
+      @EventCategoryDef category: Int
+  )
+
+  @Deprecated("Dispatch the TouchEvent using [EventDispatcher] instead")
+  public fun receiveTouches(event: TouchEvent)
+}

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/events/ReactEventEmitter.kt

@@ -0,0 +1,130 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+// RCTEventEmitter usage throughout:
+@file:Suppress("DEPRECATION")
+
+package com.facebook.react.uimanager.events
+
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactNoCrashSoftException
+import com.facebook.react.bridge.ReactSoftExceptionLogger.logSoftException
+import com.facebook.react.bridge.WritableArray
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.common.UIManagerType
+import com.facebook.react.uimanager.common.ViewUtil.getUIManagerType
+
+internal class ReactEventEmitter(private val reactContext: ReactApplicationContext) :
+    RCTModernEventEmitter {
+  /** Corresponds to [com.facebook.react.fabric.events.FabricEventEmitter] */
+  private var fabricEventEmitter: RCTModernEventEmitter? = null
+
+  /** Corresponds to (Paper) EventEmitter, which is a JS interface */
+  private var defaultEventEmitter: RCTEventEmitter? = null
+
+  fun register(@UIManagerType uiManagerType: Int, eventEmitter: RCTModernEventEmitter?) {
+    check(uiManagerType == UIManagerType.FABRIC)
+    fabricEventEmitter = eventEmitter
+  }
+
+  fun register(@UIManagerType uiManagerType: Int, eventEmitter: RCTEventEmitter?) {
+    check(uiManagerType == UIManagerType.DEFAULT)
+    defaultEventEmitter = eventEmitter
+  }
+
+  fun unregister(@UIManagerType uiManagerType: Int) {
+    if (uiManagerType == UIManagerType.DEFAULT) {
+      defaultEventEmitter = null
+    } else {
+      fabricEventEmitter = null
+    }
+  }
+
+  @Deprecated("Please use RCTModernEventEmitter")
+  override fun receiveEvent(targetTag: Int, eventName: String, params: WritableMap?) {
+    receiveEvent(-1, targetTag, eventName, params)
+  }
+
+  override fun receiveEvent(
+      surfaceId: Int,
+      targetTag: Int,
+      eventName: String,
+      params: WritableMap?
+  ) {
+    // We assume this event can't be coalesced. `customCoalesceKey` has no meaning in Fabric.
+    receiveEvent(surfaceId, targetTag, eventName, false, 0, params, EventCategoryDef.UNSPECIFIED)
+  }
+
+  @Deprecated("Please use RCTModernEventEmitter")
+  override fun receiveTouches(
+      eventName: String,
+      touches: WritableArray,
+      changedIndices: WritableArray
+  ) {
+    /*
+     * This method should be unused by default processing pipeline, but leaving it here to make sure
+     * that any custom code using it in legacy renderer is compatible
+     */
+    check(touches.size() > 0)
+
+    val reactTag = touches.getMap(0)?.getInt(TouchesHelper.TARGET_KEY) ?: 0
+    @UIManagerType val uiManagerType = getUIManagerType(reactTag)
+    if (uiManagerType == UIManagerType.DEFAULT) {
+      ensureDefaultEventEmitter()?.receiveTouches(eventName, touches, changedIndices)
+    }
+  }
+
+  @Deprecated("Please use RCTModernEventEmitter")
+  override fun receiveTouches(event: TouchEvent) {
+    @UIManagerType val uiManagerType = getUIManagerType(event.viewTag, event.surfaceId)
+    if (uiManagerType == UIManagerType.FABRIC) {
+      fabricEventEmitter?.let { TouchesHelper.sendTouchEvent(it, event) }
+    } else if (uiManagerType == UIManagerType.DEFAULT) {
+      ensureDefaultEventEmitter()?.let { TouchesHelper.sendTouchesLegacy(it, event) }
+    }
+  }
+
+  /**
+   * Get default/Paper event emitter. Callers should have verified that this is not an event for a
+   * View managed by Fabric
+   */
+  private fun ensureDefaultEventEmitter(): RCTEventEmitter? {
+    if (defaultEventEmitter == null) {
+      if (reactContext.hasActiveReactInstance()) {
+        defaultEventEmitter = reactContext.getJSModule(RCTEventEmitter::class.java)
+      } else {
+        logSoftException(
+            TAG,
+            ReactNoCrashSoftException(
+                "Cannot get RCTEventEmitter from Context, no active Catalyst instance!"))
+      }
+    }
+    return defaultEventEmitter
+  }
+
+  override fun receiveEvent(
+      surfaceId: Int,
+      targetTag: Int,
+      eventName: String,
+      canCoalesceEvent: Boolean,
+      customCoalesceKey: Int,
+      params: WritableMap?,
+      @EventCategoryDef category: Int
+  ) {
+    @UIManagerType val uiManagerType = getUIManagerType(targetTag, surfaceId)
+    if (uiManagerType == UIManagerType.FABRIC) {
+      fabricEventEmitter?.receiveEvent(
+          surfaceId, targetTag, eventName, canCoalesceEvent, customCoalesceKey, params, category)
+    } else if (uiManagerType == UIManagerType.DEFAULT) {
+      ensureDefaultEventEmitter()?.receiveEvent(targetTag, eventName, params)
+    }
+  }
+
+  companion object {
+    private const val TAG = "ReactEventEmitter"
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/events/TouchEvent.kt

@@ -126,7 +126,7 @@ public class TouchEvent private constructor() : Event<TouchEvent>() {
     }
   }
 
-  protected override fun getEventCategory(): Int {
+  public override fun getEventCategory(): Int {
     val type = touchEventType ?: return EventCategoryDef.UNSPECIFIED
     return when (type) {
       TouchEventType.START -> EventCategoryDef.CONTINUOUS_START