react-native-tvos 0.79.2-0 → 0.80.0-0

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

@@ -15,8 +15,8 @@ import com.facebook.react.bridge.LifecycleEventListener;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.UiThreadUtil;
 import com.facebook.react.common.MapBuilder;
+import com.facebook.react.common.annotations.internal.InteropLegacyArchitecture;
 import com.facebook.react.modules.core.ReactChoreographer;
-import com.facebook.react.uimanager.common.UIManagerType;
 import com.facebook.systrace.Systrace;
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -56,6 +56,7 @@ import java.util.concurrent.atomic.AtomicInteger;
  * 0x0000ffff00000000 COALESCING_KEY_MASK = 0xffff000000000000
  */
 @Nullsafe(Nullsafe.Mode.LOCAL)
+@InteropLegacyArchitecture
 public class EventDispatcherImpl implements EventDispatcher, LifecycleEventListener {
 
   private static final Comparator<Event> EVENT_COMPARATOR =
@@ -100,14 +101,14 @@ public class EventDispatcherImpl implements EventDispatcher, LifecycleEventListe
 
   private Event[] mEventsToDispatch = new Event[16];
   private int mEventsToDispatchSize = 0;
-  private volatile ReactEventEmitter mReactEventEmitter;
+  private final EventEmitterImpl mReactEventEmitter;
   private short mNextEventTypeId = 0;
   private volatile boolean mHasDispatchScheduled = false;
 
   public EventDispatcherImpl(ReactApplicationContext reactContext) {
     mReactContext = reactContext;
     mReactContext.addLifecycleEventListener(this);
-    mReactEventEmitter = new ReactEventEmitter(mReactContext);
+    mReactEventEmitter = new EventEmitterImpl(mReactContext);
   }
 
   /** Sends the given Event to JS, coalescing eligible events if JS is backed up. */
@@ -120,8 +121,7 @@ public class EventDispatcherImpl implements EventDispatcher, LifecycleEventListe
 
     synchronized (mEventsStagingLock) {
       mEventStaging.add(event);
-      Systrace.startAsyncFlow(
-          Systrace.TRACE_TAG_REACT_JAVA_BRIDGE, event.getEventName(), event.getUniqueID());
+      Systrace.startAsyncFlow(Systrace.TRACE_TAG_REACT, event.getEventName(), event.getUniqueID());
     }
     maybePostFrameCallbackFromNonUI();
   }
@@ -131,16 +131,7 @@ public class EventDispatcherImpl implements EventDispatcher, LifecycleEventListe
   }
 
   private void maybePostFrameCallbackFromNonUI() {
-    if (mReactEventEmitter != null) {
-      // If the host activity is paused, the frame callback may not be currently
-      // posted. Ensure that it is so that this event gets delivered promptly.
-      mCurrentFrameCallback.maybePostFromNonUI();
-    } else {
-      // No JS application has started yet, or resumed. This can happen when a ReactRootView is
-      // added to view hierarchy, but ReactContext creation has not completed yet. In this case, any
-      // touch event dispatch will hit this codepath, and we simply queue them so that they
-      // are dispatched once ReactContext creation completes and JS app is running.
-    }
+    mCurrentFrameCallback.maybePostFromNonUI();
   }
 
   /** Add a listener to this EventDispatcher. */
@@ -176,14 +167,10 @@ public class EventDispatcherImpl implements EventDispatcher, LifecycleEventListe
     stopFrameCallback();
   }
 
+  @Override
+  @Deprecated
   public void onCatalystInstanceDestroyed() {
-    UiThreadUtil.runOnUiThread(
-        new Runnable() {
-          @Override
-          public void run() {
-            stopFrameCallback();
-          }
-        });
+    UiThreadUtil.runOnUiThread(this::stopFrameCallback);
   }
 
   private void stopFrameCallback() {
@@ -261,19 +248,6 @@ public class EventDispatcherImpl implements EventDispatcher, LifecycleEventListe
         | (((long) coalescingKey) & 0xffff) << 48;
   }
 
-  public void registerEventEmitter(@UIManagerType int uiManagerType, RCTEventEmitter eventEmitter) {
-    mReactEventEmitter.register(uiManagerType, eventEmitter);
-  }
-
-  public void registerEventEmitter(
-      @UIManagerType int uiManagerType, RCTModernEventEmitter eventEmitter) {
-    mReactEventEmitter.register(uiManagerType, eventEmitter);
-  }
-
-  public void unregisterEventEmitter(@UIManagerType int uiManagerType) {
-    mReactEventEmitter.unregister(uiManagerType);
-  }
-
   private class ScheduleDispatchFrameCallback implements Choreographer.FrameCallback {
     private volatile boolean mIsPosted = false;
     private boolean mShouldStop = false;
@@ -288,20 +262,20 @@ public class EventDispatcherImpl implements EventDispatcher, LifecycleEventListe
         post();
       }
 
-      Systrace.beginSection(Systrace.TRACE_TAG_REACT_JAVA_BRIDGE, "ScheduleDispatchFrameCallback");
+      Systrace.beginSection(Systrace.TRACE_TAG_REACT, "ScheduleDispatchFrameCallback");
       try {
         moveStagedEventsToDispatchQueue();
 
         if (!mHasDispatchScheduled) {
           mHasDispatchScheduled = true;
           Systrace.startAsyncFlow(
-              Systrace.TRACE_TAG_REACT_JAVA_BRIDGE,
+              Systrace.TRACE_TAG_REACT,
               "ScheduleDispatchFrameCallback",
               mHasDispatchScheduledCount.get());
           mReactContext.runOnJSQueueThread(mDispatchEventsRunnable);
         }
       } finally {
-        Systrace.endSection(Systrace.TRACE_TAG_REACT_JAVA_BRIDGE);
+        Systrace.endSection(Systrace.TRACE_TAG_REACT);
       }
     }
 
@@ -345,14 +319,13 @@ public class EventDispatcherImpl implements EventDispatcher, LifecycleEventListe
 
     @Override
     public void run() {
-      Systrace.beginSection(Systrace.TRACE_TAG_REACT_JAVA_BRIDGE, "DispatchEventsRunnable");
+      Systrace.beginSection(Systrace.TRACE_TAG_REACT, "DispatchEventsRunnable");
       try {
         Systrace.endAsyncFlow(
-            Systrace.TRACE_TAG_REACT_JAVA_BRIDGE,
+            Systrace.TRACE_TAG_REACT,
             "ScheduleDispatchFrameCallback",
             mHasDispatchScheduledCount.getAndIncrement());
         mHasDispatchScheduled = false;
-        Assertions.assertNotNull(mReactEventEmitter);
         synchronized (mEventsToDispatchLock) {
           if (mEventsToDispatchSize > 0) {
             // We avoid allocating an array and iterator, and "sorting" if we don't need to.
@@ -367,7 +340,7 @@ public class EventDispatcherImpl implements EventDispatcher, LifecycleEventListe
                 continue;
               }
               Systrace.endAsyncFlow(
-                  Systrace.TRACE_TAG_REACT_JAVA_BRIDGE, event.getEventName(), event.getUniqueID());
+                  Systrace.TRACE_TAG_REACT, event.getEventName(), event.getUniqueID());
 
               event.dispatchModern(mReactEventEmitter);
               event.dispose();
@@ -380,7 +353,7 @@ public class EventDispatcherImpl implements EventDispatcher, LifecycleEventListe
           listener.onBatchEventDispatched();
         }
       } finally {
-        Systrace.endSection(Systrace.TRACE_TAG_REACT_JAVA_BRIDGE);
+        Systrace.endSection(Systrace.TRACE_TAG_REACT);
       }
     }
   }

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

@@ -12,12 +12,12 @@ package com.facebook.react.uimanager.events
  * first-class API for accessing the [EventDispatcher] from the
  * [com.facebook.react.bridge.UIManager].
  */
-public fun interface EventDispatcherProvider {
+internal 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
+  fun getEventDispatcher(): EventDispatcher
 }

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/events/{ReactEventEmitter.kt → EventEmitterImpl.kt}

@@ -15,35 +15,31 @@ 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.common.annotations.internal.InteropLegacyArchitecture
 import com.facebook.react.uimanager.common.UIManagerType
 import com.facebook.react.uimanager.common.ViewUtil.getUIManagerType
 
-internal class ReactEventEmitter(private val reactContext: ReactApplicationContext) :
-    RCTModernEventEmitter {
+/**
+ * This class handles event emitting across the legacy and Fabric event emitting mechanisms. Based
+ * on the surfaceId and targetTag, it will route the event to the appropriate event emitter. It
+ * shims the RCTModernEventEmitter API for legacy Paper events.
+ *
+ * This class is constructed both by Paper's EventDispatcherImpl and the FabricEventDispatcher.
+ */
+@InteropLegacyArchitecture
+internal class EventEmitterImpl(
+    private val reactContext: ReactApplicationContext,
+) : RCTModernEventEmitter {
+  /** Corresponds to (Paper) EventEmitter, which is a JS interface */
+  private var legacyEventEmitter: RCTEventEmitter? = null
+
   /** 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)
+  fun registerFabricEventEmitter(eventEmitter: RCTModernEventEmitter?) {
     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)
@@ -59,32 +55,21 @@ internal class ReactEventEmitter(private val reactContext: ReactApplicationConte
     receiveEvent(surfaceId, targetTag, eventName, false, 0, params, EventCategoryDef.UNSPECIFIED)
   }
 
-  @Deprecated("Please use RCTModernEventEmitter")
+  /*
+   * This method should be unused by Fabric event processing pipeline, but leaving it here to make sure
+   * that any custom code using it in legacy renderer is compatible
+   */
+  @Deprecated("Dispatch the TouchEvent using [EventDispatcher] instead")
   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) }
+    if (uiManagerType == UIManagerType.LEGACY) {
+      ensureLegacyEventEmitter()?.receiveTouches(eventName, touches, changedIndices)
     }
   }
 
@@ -92,18 +77,18 @@ internal class ReactEventEmitter(private val reactContext: ReactApplicationConte
    * 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) {
+  private fun ensureLegacyEventEmitter(): RCTEventEmitter? {
+    if (legacyEventEmitter == null) {
       if (reactContext.hasActiveReactInstance()) {
-        defaultEventEmitter = reactContext.getJSModule(RCTEventEmitter::class.java)
+        legacyEventEmitter = reactContext.getJSModule(RCTEventEmitter::class.java)
       } else {
         logSoftException(
             TAG,
             ReactNoCrashSoftException(
-                "Cannot get RCTEventEmitter from Context, no active Catalyst instance!"))
+                "Cannot get RCTEventEmitter without active Catalyst instance!"))
       }
     }
-    return defaultEventEmitter
+    return legacyEventEmitter
   }
 
   override fun receiveEvent(
@@ -117,10 +102,17 @@ internal class ReactEventEmitter(private val reactContext: ReactApplicationConte
   ) {
     @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)
+      val fabricEventEmitter = fabricEventEmitter
+      if (fabricEventEmitter == null) {
+        logSoftException(
+            TAG,
+            ReactNoCrashSoftException("No fabricEventEmitter registered, cannot dispatch event"))
+      } else {
+        fabricEventEmitter.receiveEvent(
+            surfaceId, targetTag, eventName, canCoalesceEvent, customCoalesceKey, params, category)
+      }
+    } else if (uiManagerType == UIManagerType.LEGACY) {
+      ensureLegacyEventEmitter()?.receiveEvent(targetTag, eventName, params)
     }
   }
 

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

@@ -12,7 +12,6 @@ import android.view.Choreographer
 import com.facebook.react.bridge.LifecycleEventListener
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReactSoftExceptionLogger
-import com.facebook.react.bridge.UIManager
 import com.facebook.react.bridge.UiThreadUtil
 import com.facebook.react.common.annotations.UnstableReactNativeAPI
 import com.facebook.react.internal.featureflags.ReactNativeFeatureFlags
@@ -28,41 +27,46 @@ private const val TAG = "FabricEventDispatcher"
 /**
  * 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.
+ *
+ * While this class is Fabric-specific, it lives in the uimanager.events package to allow access to
+ * Event internals.
  */
-public open class FabricEventDispatcher(reactContext: ReactApplicationContext) :
-    EventDispatcher, LifecycleEventListener {
-  private val reactEventEmitter: ReactEventEmitter
-  private val reactContext: ReactApplicationContext = reactContext
+internal class FabricEventDispatcher(
+    private val reactContext: ReactApplicationContext,
+    fabricEventEmitter: RCTModernEventEmitter
+) : EventDispatcher, LifecycleEventListener {
+  // TODO: Remove EventEmitterImpl indirection when new Fabric is fully rolled out
+  private val eventEmitter = EventEmitterImpl(reactContext)
   private val listeners = CopyOnWriteArrayList<EventDispatcherListener>()
   private val postEventDispatchListeners = CopyOnWriteArrayList<BatchEventDispatchedListener>()
-  private val currentFrameCallback: ScheduleDispatchFrameCallback = ScheduleDispatchFrameCallback()
+  private val currentFrameCallback = ScheduleDispatchFrameCallback()
 
   private var isDispatchScheduled = false
   private val dispatchEventsRunnable = Runnable {
     isDispatchScheduled = false
-    Systrace.beginSection(Systrace.TRACE_TAG_REACT_JAVA_BRIDGE, "BatchEventDispatchedListeners")
+    Systrace.beginSection(Systrace.TRACE_TAG_REACT, "BatchEventDispatchedListeners")
     try {
       for (listener in postEventDispatchListeners) {
         listener.onBatchEventDispatched()
       }
     } finally {
-      Systrace.endSection(Systrace.TRACE_TAG_REACT_JAVA_BRIDGE)
+      Systrace.endSection(Systrace.TRACE_TAG_REACT)
     }
   }
 
   init {
-    this.reactContext.addLifecycleEventListener(this)
-    reactEventEmitter = ReactEventEmitter(this.reactContext)
+    reactContext.addLifecycleEventListener(this)
+    eventEmitter.registerFabricEventEmitter(fabricEventEmitter)
   }
 
   public override fun dispatchEvent(event: Event<*>) {
     for (listener in listeners) {
       listener.onEventDispatch(event)
     }
-    if (event.experimental_isSynchronous()) {
+    if (event.internal_experimental_isSynchronous()) {
       dispatchSynchronous(event)
     } else {
-      event.dispatchModern(reactEventEmitter)
+      event.dispatchModern(eventEmitter)
     }
 
     event.dispose()
@@ -71,20 +75,19 @@ public open class FabricEventDispatcher(reactContext: ReactApplicationContext) :
 
   private fun dispatchSynchronous(event: Event<*>) {
     Systrace.beginSection(
-        Systrace.TRACE_TAG_REACT_JAVA_BRIDGE,
-        "FabricEventDispatcher.dispatchSynchronous('" + event.eventName + "')")
+        Systrace.TRACE_TAG_REACT,
+        "FabricEventDispatcher.dispatchSynchronous('" + event.getEventName() + "')")
     try {
-      val fabricUIManager: UIManager? =
-          UIManagerHelper.getUIManager(reactContext, UIManagerType.FABRIC)
+      val fabricUIManager = UIManagerHelper.getUIManager(reactContext, UIManagerType.FABRIC)
       @OptIn(UnstableReactNativeAPI::class)
       if (fabricUIManager is SynchronousEventReceiver) {
         (fabricUIManager as SynchronousEventReceiver).receiveEvent(
             event.surfaceId,
             event.viewTag,
-            event.eventName,
+            event.getEventName(),
             event.canCoalesce(),
-            event.eventData,
-            event.eventCategory,
+            event.internal_getEventData(),
+            event.internal_getEventCategory(),
             true)
       } else {
         ReactSoftExceptionLogger.logSoftException(
@@ -93,7 +96,7 @@ public open class FabricEventDispatcher(reactContext: ReactApplicationContext) :
                 "Fabric UIManager expected to implement SynchronousEventReceiver."))
       }
     } finally {
-      Systrace.endSection(Systrace.TRACE_TAG_REACT_JAVA_BRIDGE)
+      Systrace.endSection(Systrace.TRACE_TAG_REACT)
     }
   }
 
@@ -145,8 +148,15 @@ public open class FabricEventDispatcher(reactContext: ReactApplicationContext) :
     cancelDispatchOfBatchedEvents()
   }
 
+  public fun invalidate() {
+    eventEmitter.registerFabricEventEmitter(null)
+
+    UiThreadUtil.runOnUiThread { cancelDispatchOfBatchedEvents() }
+  }
+
+  @Deprecated("Private API, should only be used when the concrete implementation is known.")
   public override fun onCatalystInstanceDestroyed() {
-    UiThreadUtil.runOnUiThread(Runnable { cancelDispatchOfBatchedEvents() })
+    invalidate()
   }
 
   private fun cancelDispatchOfBatchedEvents() {
@@ -159,26 +169,6 @@ public open class FabricEventDispatcher(reactContext: ReactApplicationContext) :
     }
   }
 
-  @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
@@ -192,13 +182,13 @@ public open class FabricEventDispatcher(reactContext: ReactApplicationContext) :
         dispatchBatchedEvents()
       }
 
-      Systrace.beginSection(Systrace.TRACE_TAG_REACT_JAVA_BRIDGE, "BatchEventDispatchedListeners")
+      Systrace.beginSection(Systrace.TRACE_TAG_REACT, "BatchEventDispatchedListeners")
       try {
         for (listener in postEventDispatchListeners) {
           listener.onBatchEventDispatched()
         }
       } finally {
-        Systrace.endSection(Systrace.TRACE_TAG_REACT_JAVA_BRIDGE)
+        Systrace.endSection(Systrace.TRACE_TAG_REACT)
       }
     }
 

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

@@ -1,16 +1,27 @@
+/*
+ * 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.Arguments
 import com.facebook.react.bridge.WritableMap
 
-public class FocusEvent(surfaceId: Int, viewId: Int) :
-  Event<FocusEvent>(surfaceId, viewId) {
+/** Represents a View gaining focus */
+internal class FocusEvent(surfaceId: Int, viewId: Int) : Event<FocusEvent>(surfaceId, viewId) {
 
   override fun getEventName(): String = EVENT_NAME
 
-  override fun getEventData(): WritableMap = Arguments.createMap()
+  override fun canCoalesce(): Boolean = false
+
+  protected override fun getEventData(): WritableMap {
+    return Arguments.createMap().apply { putInt("target", viewTag) }
+  }
 
-  private companion object {
-    private const val EVENT_NAME: String = "topFocus"
+  internal companion object {
+    internal const val EVENT_NAME: String = "topFocus"
   }
 }

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

@@ -13,24 +13,24 @@ 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 {
+internal object PointerEventHelper {
+  const val POINTER_TYPE_TOUCH: String = "touch"
+  const val POINTER_TYPE_PEN: String = "pen"
+  const val POINTER_TYPE_MOUSE: String = "mouse"
+  const val POINTER_TYPE_UNKNOWN: String = ""
+  const val X_FLAG_SUPPORTS_HOVER = 0x01000000
+
+  const val POINTER_CANCEL: String = "topPointerCancel"
+  const val POINTER_DOWN: String = "topPointerDown"
+  const val POINTER_ENTER: String = "topPointerEnter"
+  const val POINTER_LEAVE: String = "topPointerLeave"
+  const val POINTER_MOVE: String = "topPointerMove"
+  const val POINTER_UP: String = "topPointerUp"
+  const val POINTER_OVER: String = "topPointerOver"
+  const val POINTER_OUT: String = "topPointerOut"
+  const val CLICK: String = "topClick"
+
+  enum class EVENT {
     CANCEL,
     CANCEL_CAPTURE,
     CLICK,
@@ -53,7 +53,7 @@ public object PointerEventHelper {
 
   // https://w3c.github.io/pointerevents/#the-buttons-property
   @JvmStatic
-  public fun getButtons(eventName: String?, pointerType: String, buttonState: Int): Int {
+  fun getButtons(eventName: String?, pointerType: String, buttonState: Int): Int {
     if (isExitEvent(eventName)) {
       return 0
     }
@@ -65,11 +65,7 @@ public object PointerEventHelper {
 
   // https://w3c.github.io/pointerevents/#the-button-property
   @JvmStatic
-  public fun getButtonChange(
-      pointerType: String,
-      lastButtonState: Int,
-      currentButtonState: Int
-  ): Int {
+  fun getButtonChange(pointerType: String, lastButtonState: Int, currentButtonState: Int): Int {
     // Always return 0 for touch
     if (POINTER_TYPE_TOUCH == pointerType) {
       return 0
@@ -91,7 +87,7 @@ public object PointerEventHelper {
   }
 
   @JvmStatic
-  public fun getW3CPointerType(toolType: Int): String {
+  fun getW3CPointerType(toolType: Int): String {
     // https://www.w3.org/TR/pointerevents3/#dom-pointerevent-pointertype
     return when (toolType) {
       MotionEvent.TOOL_TYPE_FINGER -> POINTER_TYPE_TOUCH
@@ -102,7 +98,7 @@ public object PointerEventHelper {
   }
 
   @JvmStatic
-  public fun isListening(view: View?, event: EVENT): Boolean {
+  fun isListening(view: View?, event: EVENT): Boolean {
     if (view == null) {
       return true
     }
@@ -124,7 +120,7 @@ public object PointerEventHelper {
   }
 
   @JvmStatic
-  public fun getEventCategory(pointerEventType: String?): Int {
+  fun getEventCategory(pointerEventType: String?): Int {
     if (pointerEventType == null) {
       return EventCategoryDef.UNSPECIFIED
     }
@@ -141,7 +137,7 @@ public object PointerEventHelper {
     }
   }
 
-  public fun supportsHover(motionEvent: MotionEvent): Boolean {
+  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
@@ -154,7 +150,7 @@ public object PointerEventHelper {
     return motionEvent.isFromSource(InputDevice.SOURCE_MOUSE)
   }
 
-  public fun isExitEvent(eventName: String?): Boolean {
+  fun isExitEvent(eventName: String?): Boolean {
     return when (eventName) {
       POINTER_UP,
       POINTER_LEAVE,
@@ -165,7 +161,7 @@ public object PointerEventHelper {
 
   // https://w3c.github.io/pointerevents/#dom-pointerevent-pressure
   @JvmStatic
-  public fun getPressure(buttonState: Int, eventName: String?): Double {
+  fun getPressure(buttonState: Int, eventName: String?): Double {
     if (isExitEvent(eventName)) {
       return 0.0
     }
@@ -179,7 +175,7 @@ public object PointerEventHelper {
   }
 
   @JvmStatic
-  public fun isBubblingEvent(eventName: String?): Boolean {
+  fun isBubblingEvent(eventName: String?): Boolean {
     return when (eventName) {
       POINTER_UP,
       POINTER_DOWN,

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

@@ -11,6 +11,7 @@ import com.facebook.proguard.annotations.DoNotStripAny
 import com.facebook.react.bridge.JavaScriptModule
 import com.facebook.react.bridge.WritableArray
 import com.facebook.react.bridge.WritableMap
+import com.facebook.react.common.annotations.internal.InteropLegacyArchitecture
 
 /**
  * Paper JS interface to emit events from native to JS.
@@ -18,6 +19,7 @@ import com.facebook.react.bridge.WritableMap
  * Deprecated in favor of [RCTModernEventEmitter], which works with both the old and new renderer.
  */
 @DoNotStripAny
+@InteropLegacyArchitecture
 @Deprecated("Use [RCTModernEventEmitter] instead")
 public interface RCTEventEmitter : JavaScriptModule {
   /**

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

@@ -31,7 +31,4 @@ public interface RCTModernEventEmitter : RCTEventEmitter {
       params: WritableMap?,
       @EventCategoryDef category: Int
   )
-
-  @Deprecated("Dispatch the TouchEvent using [EventDispatcher] instead")
-  public fun receiveTouches(event: TouchEvent)
 }