react-native-tvos 0.77.0-0rc5 → 0.78.0-0

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

@@ -5,10 +5,10 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-package com.facebook.react.uimanager.events;
+package com.facebook.react.uimanager.events
 
-public interface BatchEventDispatchedListener {
+public fun interface BatchEventDispatchedListener {
 
   /** Called after a batch of low priority events has been dispatched. */
-  void onBatchEventDispatched();
+  public fun onBatchEventDispatched()
 }

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

@@ -0,0 +1,46 @@
+/*
+ * 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 androidx.annotation.IntDef
+
+/**
+ * Kotlin/Java specific declaration of the `RawEvent::Category` enum. Keep in sync with
+ * `renderer/core/RawEvent.h`.
+ */
+@IntDef(
+    value =
+        [
+            EventCategoryDef.CONTINUOUS_START,
+            EventCategoryDef.CONTINUOUS_END,
+            EventCategoryDef.UNSPECIFIED,
+            EventCategoryDef.DISCRETE,
+            EventCategoryDef.CONTINUOUS])
+@Retention(AnnotationRetention.SOURCE)
+public annotation class EventCategoryDef {
+  public companion object {
+    /** Start of a continuous event. To be used with touchStart. */
+    public const val CONTINUOUS_START: Int = 0
+
+    /** End of a continuous event. To be used with touchEnd. */
+    public const val CONTINUOUS_END: Int = 1
+
+    /**
+     * Priority for this event will be determined from other events in the queue. If it is triggered
+     * by continuous event, its priority will be default. If it is not triggered by continuous
+     * event, its priority will be discrete.
+     */
+    public const val UNSPECIFIED: Int = 2
+
+    /** Forces discrete type for the event. Regardless if continuous event is ongoing. */
+    public const val DISCRETE: Int = 3
+
+    /** Forces continuous type for the event. Regardless if continuous event isn't ongoing. */
+    public const val CONTINUOUS: Int = 4
+  }
+}

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

@@ -0,0 +1,40 @@
+/*
+ * 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.uimanager.common.UIManagerType
+
+public interface EventDispatcher {
+  /** Sends the given Event to JS, coalescing eligible events if JS is backed up. */
+  public fun dispatchEvent(event: Event<*>)
+
+  public fun dispatchAllEvents()
+
+  /** Add a listener to this EventDispatcher. */
+  public fun addListener(listener: EventDispatcherListener)
+
+  /** Remove a listener from this EventDispatcher. */
+  public fun removeListener(listener: EventDispatcherListener)
+
+  public fun addBatchEventDispatchedListener(listener: BatchEventDispatchedListener)
+
+  public fun removeBatchEventDispatchedListener(listener: BatchEventDispatchedListener)
+
+  @Deprecated("Use the modern version with RCTModernEventEmitter")
+  @Suppress("DEPRECATION")
+  public fun registerEventEmitter(@UIManagerType uiManagerType: Int, eventEmitter: RCTEventEmitter)
+
+  public fun registerEventEmitter(
+      @UIManagerType uiManagerType: Int,
+      eventEmitter: RCTModernEventEmitter
+  )
+
+  public fun unregisterEventEmitter(@UIManagerType uiManagerType: Int)
+
+  public fun onCatalystInstanceDestroyed()
+}

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

@@ -15,7 +15,6 @@ 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.internal.featureflags.ReactNativeFeatureFlags;
 import com.facebook.react.modules.core.ReactChoreographer;
 import com.facebook.react.uimanager.common.UIManagerType;
 import com.facebook.systrace.Systrace;
@@ -318,11 +317,8 @@ public class EventDispatcherImpl implements EventDispatcher, LifecycleEventListe
     }
 
     private void post() {
-      if (!ReactNativeFeatureFlags.enableFabricRendererExclusively()) {
-        ReactChoreographer.getInstance()
-            .postFrameCallback(
-                ReactChoreographer.CallbackType.TIMERS_EVENTS, mCurrentFrameCallback);
-      }
+      ReactChoreographer.getInstance()
+          .postFrameCallback(ReactChoreographer.CallbackType.TIMERS_EVENTS, mCurrentFrameCallback);
     }
 
     public void maybePostFromNonUI() {

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)
+}