react-native-tvos 0.79.3-0 → 0.80.0-0

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/annotations/ReactPropGroup.kt

@@ -0,0 +1,86 @@
+/*
+ * 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.annotations
+
+/**
+ * Use this annotation to annotate group of properties of native views that should be exposed to JS.
+ * This annotation should only be used for setter methods of subclasses of
+ * [com.facebook.react.uimanager.ViewManager]. It's a batched version of [ReactProp] annotation
+ * (please see documentation of [ReactProp] for more details about how this annotation can be used).
+ *
+ * This annotation is meant to be used for a group of similar properties. That's why it support only
+ * a set of properties of the same type. A good example is supporting "border", where we have 7
+ * variations of that property ("borderLeft", "borderHorizontal", etc.) and very similar code for
+ * handling each of those.
+ *
+ * Each annotated method should return `void` and take exactly three arguments: first being a view
+ * instance to be updated, second should be of type int and will represent index in the group of the
+ * property being updated. Last, third argument represent the value that should be set.
+ *
+ * Currently only `int`, `float`, `double` and [String] value types are supported.
+ *
+ * In case when property has been removed from the corresponding react component annotated setter
+ * will be called and default value will be provided as a value parameter. Default value can be
+ * customize using [defaultInt] or [defaultFloat] in the case when property is of one of primitive
+ * types. In case when [String] is the property type `null` value will be provided as a default.
+ */
+@Retention(AnnotationRetention.RUNTIME)
+@Target(
+    AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER)
+public annotation class ReactPropGroup(
+
+    /**
+     * Array of names of properties exposed to JS that will be updated using setter method annotated
+     * with the given instance of `ReactPropGroup` annotation
+     */
+    public val names: Array<String>,
+    /**
+     * Type of property that will be send to JS. In most of the cases `customType` should not be set
+     * in which case default type will be send to JS based on the type of value argument from the
+     * setter method (e.g. for `int`, `float` default is "number"). Custom type may be used when
+     * additional processing of the value needs to be done in JS before sending it over the bridge.
+     * A good example of that would be backgroundColor property, which is expressed as a `String` in
+     * JS, but we use `processColor` JS module to convert it to `int` before sending over the
+     * bridge.
+     */
+    public val customType: String = USE_DEFAULT_TYPE,
+    /**
+     * Default value for property of type `float`. This value will be provided to property setter
+     * method annotated with [ReactPropGroup] if property with a given name gets removed from the
+     * component description in JS
+     */
+    public val defaultFloat: Float = 0.0f,
+    /**
+     * Default value for property of type `double`. This value will be provided to property setter
+     * method annotated with [ReactPropGroup] if property with a given name gets removed from the
+     * component description in JS
+     */
+    public val defaultDouble: Double = 0.0,
+    /**
+     * Default value for property of type `int`. This value will be provided to property setter
+     * method annotated with [ReactPropGroup] if property with a given name gets removed from the
+     * component description in JS
+     */
+    public val defaultInt: Int = 0,
+    /**
+     * Default value for property of type `long`. This value will be provided to property setter
+     * method annotated with [ReactProp] if property with a given name gets removed from the
+     * component description in JS
+     */
+    public val defaultLong: Long = 0L
+) {
+  public companion object {
+    // Used as a default value for "customType" property as "null" is not allowed. Moreover, when
+    // this
+    // const is used in annotation declaration compiler will actually create a copy of it, so
+    // comparing it using "==" with this filed doesn't work either. We need to compare using
+    // "equals"
+    // which means that this value needs to be unique.
+    public const val USE_DEFAULT_TYPE: String = "__default_type__"
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/annotations/ReactPropertyHolder.kt

@@ -0,0 +1,15 @@
+/*
+ * 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.annotations
+
+import java.lang.annotation.Inherited
+
+@Inherited
+@Retention(AnnotationRetention.BINARY)
+@Target(AnnotationTarget.CLASS)
+public annotation class ReactPropertyHolder

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/common/UIManagerType.kt

@@ -11,11 +11,15 @@ import androidx.annotation.IntDef
 import com.facebook.react.common.annotations.DeprecatedInNewArchitecture
 
 @Retention(AnnotationRetention.SOURCE)
-@IntDef(UIManagerType.DEFAULT, UIManagerType.FABRIC)
+@Suppress("DEPRECATION")
+@IntDef(UIManagerType.DEFAULT, UIManagerType.LEGACY, UIManagerType.FABRIC)
 @DeprecatedInNewArchitecture
 public annotation class UIManagerType {
   public companion object {
+    @Deprecated(
+        "UIManagerType.DEFAULT will be deleted in the next release of React Native. Use [LEGACY] instead.")
     public const val DEFAULT: Int = 1
+    public const val LEGACY: Int = 1
     public const val FABRIC: Int = 2
   }
 }

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/common/ViewUtil.kt

@@ -25,7 +25,7 @@ public object ViewUtil {
       if (viewTag % 2 == 0) {
         UIManagerType.FABRIC
       } else {
-        UIManagerType.DEFAULT
+        UIManagerType.LEGACY
       }
 
   /**
@@ -55,8 +55,8 @@ public object ViewUtil {
     // by RN and is essentially a random number.
     // At some point it would be great to pass the SurfaceContext here instead.
     @UIManagerType
-    val uiManagerType = if (surfaceId == -1) UIManagerType.DEFAULT else UIManagerType.FABRIC
-    if (uiManagerType == UIManagerType.DEFAULT && !isRootTag(viewTag)) {
+    val uiManagerType = if (surfaceId == -1) UIManagerType.LEGACY else UIManagerType.FABRIC
+    if (uiManagerType == UIManagerType.LEGACY && !isRootTag(viewTag)) {
       // TODO (T123064648): Some events for Fabric still didn't have the surfaceId set, so if it's
       // not a React RootView, double check if the tag belongs to Fabric.
       if (viewTag % 2 == 0) {

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/debug/NotThreadSafeViewHierarchyUpdateDebugListener.kt

@@ -7,6 +7,8 @@
 
 package com.facebook.react.uimanager.debug
 
+import com.facebook.react.common.annotations.internal.LegacyArchitecture
+
 /**
  * A listener that is notified about view hierarchy update events. This listener should only be used
  * for debug purposes and should not affect application state.
@@ -16,6 +18,7 @@ package com.facebook.react.uimanager.debug
  */
 @Deprecated(
     "NotThreadSafeViewHierarchyUpdateDebugListener will be deleted in the new architecture.")
+@LegacyArchitecture
 internal interface NotThreadSafeViewHierarchyUpdateDebugListener {
   /** Called when `UIManagerModule` enqueues a UI batch to be dispatched to the main thread. */
   fun onViewHierarchyUpdateEnqueued()

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/drawable/BackgroundDrawable.kt

@@ -122,6 +122,7 @@ internal class BackgroundDrawable(
       }
     }
 
+    backgroundPaint.alpha = 255
     if (backgroundImageLayers != null && backgroundImageLayers?.isNotEmpty() == true) {
       backgroundPaint.setShader(getBackgroundImageShader())
       if (computedBorderRadius?.isUniform() == true && borderRadius?.hasRoundedBorders() == true) {
@@ -137,6 +138,7 @@ internal class BackgroundDrawable(
       }
       backgroundPaint.setShader(null)
     }
+    backgroundPaint.alpha = Color.alpha(backgroundColor)
     canvas.restore()
   }
 
@@ -153,7 +155,7 @@ internal class BackgroundDrawable(
     backgroundImageLayers?.let { layers ->
       var compositeShader: Shader? = null
       for (backgroundImageLayer in layers) {
-        val currentShader = backgroundImageLayer.getShader(bounds) ?: continue
+        val currentShader = backgroundImageLayer.getShader(bounds)
 
         compositeShader =
             if (compositeShader == null) {

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/drawable/BorderDrawable.kt

@@ -490,6 +490,14 @@ internal class BorderDrawable(
       colorRight: Int,
       colorBottom: Int
   ): Int {
+    // If any of the border colors are translucent then we can't use the fast path.
+    if (Color.alpha(colorLeft) < 255 ||
+        Color.alpha(colorTop) < 255 ||
+        Color.alpha(colorRight) < 255 ||
+        Color.alpha(colorBottom) < 255) {
+      return 0
+    }
+
     val andSmear =
         ((if (borderLeft > 0) colorLeft else ALL_BITS_SET) and
             (if (borderTop > 0) colorTop else ALL_BITS_SET) and
@@ -1053,7 +1061,7 @@ internal class BorderDrawable(
    * Multiplies the color with the given alpha.
    *
    * @param color color to be multiplied
-   * @param alpha value between 0 and 255
+   * @param rawAlpha value between 0 and 255
    * @return multiplied color
    */
   private fun multiplyColorAlpha(color: Int, rawAlpha: Int): Int {

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/drawable/InsetBoxShadowDrawable.kt

@@ -109,7 +109,11 @@ internal class InsetBoxShadowDrawable(
     val spreadExtent = spread.dpToPx()
     val innerRect =
         RectF(paddingBoxRect).apply {
-          inset(spreadExtent, spreadExtent)
+          if (2 * spreadExtent > paddingBoxRect.width()) {
+            setEmpty()
+          } else {
+            inset(spreadExtent, spreadExtent)
+          }
           offset(x, y)
         }
 
@@ -117,12 +121,10 @@ internal class InsetBoxShadowDrawable(
     // https://source.chromium.org/chromium/chromium/src/+/main:third_party/blink/renderer/core/paint/box_painter_base.cc;l=338;drc=0a301506035e13015ea5c8dd39164d0d5954fa60
     val blurExtent = FilterHelper.sigmaToRadius(blurRadius)
     val outerRect =
-        RectF(paddingBoxRect).apply {
+        RectF(innerRect).apply {
+          set(paddingBoxRect)
           inset(-blurExtent, -blurExtent)
-          if (spreadExtent < 0) {
-            inset(spreadExtent, spreadExtent)
-          }
-          union(RectF(this).apply { offset(-x, -y) })
+          union(RectF(innerRect))
         }
 
     canvas.save().let { saveCount ->

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/drawable/OutlineDrawable.kt

@@ -154,8 +154,8 @@ internal class OutlineDrawable(
     }
   }
 
-  private fun calculateRadius(radius: Float, outlineWidth: Float) =
-      if (radius != 0f) radius + outlineWidth * 0.5f else 0f
+  private fun calculateRadius(radius: Float, outlineWidth: Float, outlineOffset: Float) =
+      if (radius != 0f) radius + (outlineWidth * 0.5f) + outlineOffset else 0f
 
   private fun drawRectangularOutline(canvas: Canvas) {
     pathForOutline.addRect(tempRectForOutline, Path.Direction.CW)
@@ -173,14 +173,14 @@ internal class OutlineDrawable(
     pathForOutline.addRoundRect(
         tempRectForOutline,
         floatArrayOf(
-            calculateRadius(topLeftRadius.horizontal, outlineWidth),
-            calculateRadius(topLeftRadius.vertical, outlineWidth),
-            calculateRadius(topRightRadius.horizontal, outlineWidth),
-            calculateRadius(topRightRadius.vertical, outlineWidth),
-            calculateRadius(bottomRightRadius.horizontal, outlineWidth),
-            calculateRadius(bottomRightRadius.vertical, outlineWidth),
-            calculateRadius(bottomLeftRadius.horizontal, outlineWidth),
-            calculateRadius(bottomLeftRadius.vertical, outlineWidth),
+            calculateRadius(topLeftRadius.horizontal, outlineWidth, outlineOffset),
+            calculateRadius(topLeftRadius.vertical, outlineWidth, outlineOffset),
+            calculateRadius(topRightRadius.horizontal, outlineWidth, outlineOffset),
+            calculateRadius(topRightRadius.vertical, outlineWidth, outlineOffset),
+            calculateRadius(bottomRightRadius.horizontal, outlineWidth, outlineOffset),
+            calculateRadius(bottomRightRadius.vertical, outlineWidth, outlineOffset),
+            calculateRadius(bottomLeftRadius.horizontal, outlineWidth, outlineOffset),
+            calculateRadius(bottomLeftRadius.vertical, outlineWidth, outlineOffset),
         ),
         Path.Direction.CW)
 

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

@@ -13,11 +13,11 @@ import com.facebook.common.logging.FLog
  * 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.
  */
-internal class BlackHoleEventDispatcher private constructor() : EventDispatcher {
+internal object BlackHoleEventDispatcher : EventDispatcher {
   override fun dispatchEvent(event: Event<*>) {
     FLog.d(
         "BlackHoleEventDispatcher",
-        "Trying to emit event to JS, but the React instance isn't ready. Event: ${event.eventName}")
+        "Trying to emit event to JS, but the React instance isn't ready. Event: ${event.getEventName()}")
   }
 
   override fun dispatchAllEvents(): Unit = Unit
@@ -31,20 +31,6 @@ internal class BlackHoleEventDispatcher private constructor() : EventDispatcher
   override fun removeBatchEventDispatchedListener(listener: BatchEventDispatchedListener): Unit =
       Unit
 
-  @Deprecated("Deprecated in Java")
-  @Suppress("DEPRECATION")
-  override fun registerEventEmitter(uiManagerType: Int, eventEmitter: RCTEventEmitter): Unit = Unit
-
-  override fun registerEventEmitter(uiManagerType: Int, eventEmitter: RCTModernEventEmitter): Unit =
-      Unit
-
-  override fun unregisterEventEmitter(uiManagerType: Int): Unit = Unit
-
+  @Deprecated("Private API, should only be used when the concrete implementation is known.")
   override fun onCatalystInstanceDestroyed(): Unit = Unit
-
-  companion object {
-    private val eventDispatcher: EventDispatcher = BlackHoleEventDispatcher()
-
-    @JvmStatic fun get(): EventDispatcher = eventDispatcher
-  }
 }

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/events/BlurEvent.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 BlurEvent(surfaceId: Int, viewId: Int) :
-  Event<BlurEvent>(surfaceId, viewId) {
+/** Represents a View losing focus */
+internal class BlurEvent(surfaceId: Int, viewId: Int) : Event<BlurEvent>(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 = "topBlur"
+  internal companion object {
+    internal const val EVENT_NAME: String = "topBlur"
   }
 }

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

@@ -0,0 +1,206 @@
+/*
+ * 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.
+ */
+
+@file:Suppress("DEPRECATION")
+
+package com.facebook.react.uimanager.events
+
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.common.SystemClock.uptimeMillis
+
+/**
+ * A UI event that can be dispatched to JS.
+ *
+ * For dispatching events `getEventData` should be used. Once event object is passed to the
+ * EventDispatcher it should no longer be used as EventDispatcher may decide to recycle that object
+ * (by calling [dispose]).
+ *
+ * If you need advanced customizations and overriding only `getEventData` doesn't work for you, you
+ * must override both `dispatch` and `dispatchModern`. Both of these will be deleted in the distant
+ * future and it is highly recommended to use only `getEventData`.
+ *
+ * Old, pre-Fabric Events only used viewTag as the identifier, but Fabric needs surfaceId as well as
+ * viewTag. You may use [UIManagerHelper.getSurfaceId] on a Fabric-managed View to get the
+ * surfaceId. Fabric will work without surfaceId - making [Event] backwards-compatible - but Events
+ * without SurfaceId are slightly slower to propagate.
+ */
+public abstract class Event<T : Event<T>> {
+  public var isInitialized: Boolean = false
+    private set
+
+  /** @return the surfaceId for the view that generated this event */
+  public var surfaceId: Int = 0
+    private set
+
+  /** @return the view id for the view that generated this event */
+  public var viewTag: Int = 0
+    private set
+
+  /**
+   * @return the time at which the event happened in the [android.os.SystemClock.uptimeMillis] base.
+   */
+  public var timestampMs: Long = 0
+    private set
+
+  /** @return The unique id of this event. */
+  public val uniqueID: Int = uniqueIdCounter++
+  private var eventAnimationDriverMatchSpecCached: EventAnimationDriverMatchSpec? = null
+
+  protected constructor()
+
+  @Deprecated("Use constructor with explicit surfaceId instead")
+  protected constructor(viewTag: Int) {
+    init(viewTag)
+  }
+
+  protected constructor(surfaceId: Int, viewTag: Int) {
+    init(surfaceId, viewTag)
+  }
+
+  @Deprecated("Use version with explicit surfaceId instead")
+  protected fun init(viewTag: Int) {
+    init(-1, viewTag)
+  }
+
+  /**
+   * This method needs to be called before event is sent to event dispatcher. Event timestamps can
+   * optionally be dated/backdated to a custom time: for example, touch events should be dated with
+   * the system event time.
+   */
+  protected fun init(surfaceId: Int, viewTag: Int, timestampMs: Long) {
+    this.surfaceId = surfaceId
+    this.viewTag = viewTag
+    this.timestampMs = timestampMs
+    this.isInitialized = true
+  }
+
+  protected fun init(surfaceId: Int, viewTag: Int) {
+    init(surfaceId, viewTag, uptimeMillis())
+  }
+
+  /** @return false if this Event can *never* be coalesced */
+  public open fun canCoalesce(): Boolean = true
+
+  /**
+   * Given two events, coalesce them into a single event that will be sent to JS instead of two
+   * separate events. By default, just chooses the one the is more recent, or `this` if timestamps
+   * are the same.
+   *
+   * Two events will only ever try to be coalesced if they have the same event name, view id, and
+   * coalescing key.
+   */
+  public open fun coalesce(otherEvent: Event<T>?): Event<T>? =
+      if (timestampMs >= otherEvent?.timestampMs ?: 0) this else otherEvent
+
+  /**
+   * @return a key used to determine which other events of this type this event can be coalesced
+   *   with. For example, touch move events should only be coalesced within a single gesture so a
+   *   coalescing key there would be the unique gesture id.
+   */
+  public open fun getCoalescingKey(): Short = 0
+
+  /**
+   * Called when the EventDispatcher is done with an event, either because it was dispatched or
+   * because it was coalesced with another Event.
+   */
+  public open fun onDispose(): Unit = Unit
+
+  public fun dispose() {
+    this.isInitialized = false
+    onDispose()
+  }
+
+  /** @return the name of this event as registered in JS */
+  public abstract fun getEventName(): String
+
+  /** Property added for backward compatibility with property accessors */
+  @get:JvmName("internal_getEventNameCompat")
+  public val eventName: String
+    get() = getEventName()
+
+  public open val eventAnimationDriverMatchSpec: EventAnimationDriverMatchSpec?
+    get() {
+      if (eventAnimationDriverMatchSpecCached == null) {
+        eventAnimationDriverMatchSpecCached =
+            object : EventAnimationDriverMatchSpec {
+              override fun match(viewTagRhs: Int, eventNameRhs: String): Boolean {
+                return viewTag == viewTagRhs && eventName == eventNameRhs
+              }
+            }
+      }
+      return eventAnimationDriverMatchSpecCached
+    }
+
+  /**
+   * Dispatch this event to JS using the given event emitter. Compatible with old and new renderer.
+   * Instead of using this or dispatchModern, it is recommended that you simply override
+   * `getEventData`.
+   */
+  @Deprecated("Prefer to override getEventData instead")
+  public open fun dispatch(rctEventEmitter: RCTEventEmitter) {
+    rctEventEmitter.receiveEvent(viewTag, eventName, getEventData())
+  }
+
+  /** Can be overridden by classes when no custom logic for dispatching is needed. */
+  protected open fun getEventData(): WritableMap? = null
+
+  /**
+   * NOTE: This is a transitional method that allows accessing event data from outside the
+   * sublcasses, but inside the package.
+   */
+  internal fun internal_getEventData(): WritableMap? = getEventData()
+
+  protected open fun getEventCategory(): Int = EventCategoryDef.UNSPECIFIED
+
+  /**
+   * NOTE: This is a transitional method that allows accessing event category from outside the
+   * sublcasses, but inside the package.
+   */
+  internal fun internal_getEventCategory(): Int = getEventCategory()
+
+  protected open fun experimental_isSynchronous(): Boolean = false
+
+  /**
+   * NOTE: This is a transitional method that allows accessing event category from outside the
+   * sublcasses, but inside the package.
+   */
+  internal fun internal_experimental_isSynchronous(): Boolean = experimental_isSynchronous()
+
+  /**
+   * Dispatch this event to JS using a V2 EventEmitter. If surfaceId is not -1 and `getEventData` is
+   * non-null, this will use the RCTModernEventEmitter API. Otherwise, it falls back to the
+   * old-style dispatch function. For Event classes that need to do something different, this method
+   * can always be overridden entirely, but it is not recommended.
+   *
+   * This method additionally allows C++ to coalesce events and detect continuous ones for
+   * concurrent mode (Fabric only).
+   *
+   * @see .dispatch
+   */
+  public open fun dispatchModern(rctEventEmitter: RCTModernEventEmitter) {
+    if (surfaceId != -1) {
+      rctEventEmitter.receiveEvent(
+          surfaceId,
+          viewTag,
+          eventName,
+          canCoalesce(),
+          getCoalescingKey().toInt(),
+          getEventData(),
+          getEventCategory())
+    } else {
+      dispatch(rctEventEmitter)
+    }
+  }
+
+  public fun interface EventAnimationDriverMatchSpec {
+    public fun match(viewTagRhs: Int, eventNameRhs: String): Boolean
+  }
+
+  private companion object {
+    private var uniqueIdCounter = 0
+  }
+}

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

@@ -22,25 +22,25 @@ import androidx.annotation.IntDef
             EventCategoryDef.DISCRETE,
             EventCategoryDef.CONTINUOUS])
 @Retention(AnnotationRetention.SOURCE)
-public annotation class EventCategoryDef {
-  public companion object {
+internal annotation class EventCategoryDef {
+  companion object {
     /** Start of a continuous event. To be used with touchStart. */
-    public const val CONTINUOUS_START: Int = 0
+    const val CONTINUOUS_START: Int = 0
 
     /** End of a continuous event. To be used with touchEnd. */
-    public const val CONTINUOUS_END: Int = 1
+    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
+    const val UNSPECIFIED: Int = 2
 
     /** Forces discrete type for the event. Regardless if continuous event is ongoing. */
-    public const val DISCRETE: Int = 3
+    const val DISCRETE: Int = 3
 
     /** Forces continuous type for the event. Regardless if continuous event isn't ongoing. */
-    public const val CONTINUOUS: Int = 4
+    const val CONTINUOUS: Int = 4
   }
 }

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

@@ -7,8 +7,6 @@
 
 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<*>)
@@ -25,16 +23,6 @@ public interface EventDispatcher {
 
   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)
-
+  @Deprecated("Private API, should only be used when the concrete implementation is known.")
   public fun onCatalystInstanceDestroyed()
 }