react-native-tvos 0.76.6-0 → 0.77.0-0

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

@@ -18,6 +18,7 @@ import android.graphics.Outline;
 import android.graphics.Paint;
 import android.graphics.Path;
 import android.graphics.PathEffect;
+import android.graphics.PixelFormat;
 import android.graphics.PointF;
 import android.graphics.PorterDuff;
 import android.graphics.Rect;
@@ -189,7 +190,15 @@ public class CSSBackgroundDrawable extends Drawable {
 
   @Override
   public int getOpacity() {
-    return (Color.alpha(mColor) * mAlpha) >> 8;
+    int alpha = (Color.alpha(mColor) * mAlpha) >> 8;
+    switch (alpha) {
+      case 255:
+        return PixelFormat.OPAQUE;
+      case 0:
+        return PixelFormat.TRANSPARENT;
+      default:
+        return PixelFormat.TRANSLUCENT;
+    }
   }
 
   /* Android's elevation implementation requires this to be implemented to know where to draw the shadow. */
@@ -327,13 +336,6 @@ public class CSSBackgroundDrawable extends Drawable {
     return Math.max(computedRadius - borderWidth, 0);
   }
 
-  // TODO: This API is unsafe and should be removed when
-  // BackgroundStyleApplicator is rolled out
-  @Deprecated(forRemoval = true, since = "0.76.0")
-  public ComputedBorderRadius getComputedBorderRadius() {
-    return mComputedBorderRadius;
-  }
-
   public void setColor(int color) {
     mColor = color;
     invalidateSelf();
@@ -392,7 +394,7 @@ public class CSSBackgroundDrawable extends Drawable {
     canvas.clipPath(Preconditions.checkNotNull(mOuterClipPathForBorderRadius), Region.Op.INTERSECT);
 
     // Draws the View without its border first (with background color fill)
-    int useColor = ColorUtils.setAlphaComponent(mColor, getOpacity());
+    int useColor = ColorUtils.setAlphaComponent(mColor, (Color.alpha(mColor) * mAlpha) >> 8);
     if (Color.alpha(useColor) != 0) {
       mPaint.setColor(useColor);
       mPaint.setStyle(Paint.Style.FILL);

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

@@ -7,10 +7,17 @@
 
 package com.facebook.react.uimanager.drawable
 
+import android.content.Context
+import android.graphics.Outline
+import android.graphics.Path
+import android.graphics.RectF
 import android.graphics.drawable.Drawable
 import android.graphics.drawable.LayerDrawable
+import android.os.Build
 import com.facebook.react.common.annotations.UnstableReactNativeAPI
+import com.facebook.react.internal.featureflags.ReactNativeFeatureFlags
 import com.facebook.react.uimanager.style.BorderInsets
+import com.facebook.react.uimanager.style.BorderRadiusStyle
 
 /**
  * CompositeBackgroundDrawable can overlay multiple different layers, shadows, and native effects
@@ -18,6 +25,7 @@ import com.facebook.react.uimanager.style.BorderInsets
  */
 @OptIn(UnstableReactNativeAPI::class)
 internal class CompositeBackgroundDrawable(
+    private val context: Context,
     /**
      * Any non-react-managed background already part of the view, like one set as Android style on a
      * TextInput
@@ -25,7 +33,7 @@ internal class CompositeBackgroundDrawable(
     public val originalBackground: Drawable? = null,
 
     /** Non-inset box shadows */
-    public val outerShadows: List<Drawable> = emptyList(),
+    outerShadows: LayerDrawable? = null,
 
     /**
      * CSS background layer and border rendering
@@ -35,51 +43,219 @@ internal class CompositeBackgroundDrawable(
      */
     public val cssBackground: CSSBackgroundDrawable? = null,
 
+    /** Background rendering Layer */
+    background: BackgroundDrawable? = null,
+
+    /** Border rendering Layer */
+    border: BorderDrawable? = null,
+
     /** TouchableNativeFeeback set selection background, like "SelectableBackground" */
-    public val feedbackUnderlay: Drawable? = null,
+    feedbackUnderlay: Drawable? = null,
 
     /** Inset box-shadows */
-    public val innerShadows: List<Drawable> = emptyList(),
-) :
-    LayerDrawable(
-        listOfNotNull(
-                originalBackground,
-                // z-ordering of user-provided shadow-list is opposite direction of LayerDrawable
-                // z-ordering
-                // https://drafts.csswg.org/css-backgrounds/#shadow-layers
-                *outerShadows.asReversed().toTypedArray(),
-                cssBackground,
-                feedbackUnderlay,
-                *innerShadows.asReversed().toTypedArray())
-            .toTypedArray()) {
+    innerShadows: LayerDrawable? = null,
+
+    /** Outline */
+    outline: OutlineDrawable? = null,
+) : LayerDrawable(emptyArray()) {
+  public var outerShadows: LayerDrawable? = outerShadows
+    private set
+
+  public var background: BackgroundDrawable? = background
+    private set
+
+  public var border: BorderDrawable? = border
+    private set
+
+  public var feedbackUnderlay: Drawable? = feedbackUnderlay
+    private set
+
+  public var innerShadows: LayerDrawable? = innerShadows
+    private set
+
+  public var outline: OutlineDrawable? = outline
+    private set
 
   // Holder value for currently set insets
   public var borderInsets: BorderInsets? = null
 
+  // Holder value for currently set border radius
+  public var borderRadius: BorderRadiusStyle? = null
+
   init {
     // We want to overlay drawables, instead of placing future drawables within the content area of
     // previous ones. E.g. an EditText style may set padding on a TextInput, but we don't want to
     // constrain background color to the area inside of the padding.
     setPaddingMode(LayerDrawable.PADDING_MODE_STACK)
+
+    addLayer(originalBackground, ORIGINAL_BACKGROUND_ID)
+    addLayer(outerShadows, OUTER_SHADOWS_ID)
+    addLayer(cssBackground, CSS_BACKGROUND_ID)
+    addLayer(background, BACKGROUND_ID)
+    addLayer(border, BORDER_ID)
+    addLayer(feedbackUnderlay, FEEDBACK_UNDERLAY_ID)
+    addLayer(innerShadows, INNER_SHADOWS_ID)
+    addLayer(outline, OUTLINE_ID)
   }
 
   public fun withNewCssBackground(
       cssBackground: CSSBackgroundDrawable?
   ): CompositeBackgroundDrawable {
     return CompositeBackgroundDrawable(
-        originalBackground, outerShadows, cssBackground, feedbackUnderlay, innerShadows)
+            context,
+            originalBackground,
+            outerShadows,
+            cssBackground,
+            background,
+            border,
+            feedbackUnderlay,
+            innerShadows,
+            outline)
+        .also { composite ->
+          composite.borderInsets = this.borderInsets
+          composite.borderRadius = this.borderRadius
+        }
   }
 
-  public fun withNewShadows(
-      outerShadows: List<Drawable>,
-      innerShadows: List<Drawable>
-  ): CompositeBackgroundDrawable {
-    return CompositeBackgroundDrawable(
-        originalBackground, outerShadows, cssBackground, feedbackUnderlay, innerShadows)
+  public fun withNewOuterShadow(outerShadows: LayerDrawable?): CompositeBackgroundDrawable =
+      withNewLayer(outerShadows, OUTER_SHADOWS_ID, this::outerShadows::set)
+
+  public fun withNewBackground(background: BackgroundDrawable?): CompositeBackgroundDrawable =
+      withNewLayer(background, BACKGROUND_ID, this::background::set)
+
+  public fun withNewBorder(border: BorderDrawable?): CompositeBackgroundDrawable =
+      withNewLayer(border, BORDER_ID, this::border::set)
+
+  public fun withNewFeedbackUnderlay(newUnderlay: Drawable?): CompositeBackgroundDrawable =
+      withNewLayer(newUnderlay, FEEDBACK_UNDERLAY_ID, this::feedbackUnderlay::set)
+
+  public fun withNewInnerShadow(innerShadows: LayerDrawable?): CompositeBackgroundDrawable =
+      withNewLayer(innerShadows, INNER_SHADOWS_ID, this::innerShadows::set)
+
+  public fun withNewOutline(outline: OutlineDrawable?): CompositeBackgroundDrawable =
+      withNewLayer(outline, OUTLINE_ID, this::outline::set)
+
+  /** @return true if the layer was updated, false if it was not */
+  private fun updateLayer(layer: Drawable?, id: Int): Boolean {
+    if (layer == null) {
+      return findDrawableByLayerId(id) == null
+    }
+
+    if (findDrawableByLayerId(id) == null) {
+      insertNewLayer(layer, id)
+    } else {
+      setDrawableByLayerId(id, layer)
+    }
+    invalidateSelf()
+    return true
+  }
+
+  private fun insertNewLayer(layer: Drawable?, id: Int) {
+    layer ?: return
+
+    if (numberOfLayers == 0) {
+      addLayer(layer, id)
+      return
+    }
+
+    for (i in 0..<numberOfLayers) {
+      if (id < getId(i)) {
+        val tempDrawable: Drawable = getDrawable(i)
+        val tempId = getId(i)
+        setDrawable(i, layer)
+        setId(i, id)
+        insertNewLayer(tempDrawable, tempId)
+        return
+      } else if (i == numberOfLayers - 1) {
+        addLayer(layer, id)
+        return
+      }
+    }
+  }
+
+  private fun addLayer(layer: Drawable?, id: Int) {
+    if (layer == null) {
+      return
+    }
+
+    addLayer(layer)
+    layer.callback = this
+    setId(numberOfLayers - 1, id)
+    invalidateSelf()
   }
 
-  public fun withNewFeedbackUnderlay(newUnderlay: Drawable?): CompositeBackgroundDrawable {
+  /* Android's elevation implementation requires this to be implemented to know where to draw the
+  elevation shadow. */
+  override fun getOutline(outline: Outline) {
+    if (borderRadius?.hasRoundedBorders() == true) {
+      val pathForOutline = Path()
+
+      val computedBorderRadius =
+          borderRadius?.resolve(
+              layoutDirection, context, bounds.width().toFloat(), bounds.height().toFloat())
+
+      val computedBorderInsets = borderInsets?.resolve(layoutDirection, context)
+
+      computedBorderRadius?.let {
+        pathForOutline.addRoundRect(
+            RectF(bounds),
+            floatArrayOf(
+                it.topLeft.horizontal + (computedBorderInsets?.left ?: 0f),
+                it.topLeft.vertical + (computedBorderInsets?.top ?: 0f),
+                it.topRight.horizontal + (computedBorderInsets?.right ?: 0f),
+                it.topRight.vertical + (computedBorderInsets?.top ?: 0f),
+                it.bottomRight.horizontal + (computedBorderInsets?.right ?: 0f),
+                it.bottomRight.vertical + (computedBorderInsets?.bottom ?: 0f),
+                it.bottomLeft.horizontal + (computedBorderInsets?.left ?: 0f),
+                it.bottomLeft.vertical) + (computedBorderInsets?.bottom ?: 0f),
+            Path.Direction.CW)
+      }
+
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+        outline.setPath(pathForOutline)
+      } else {
+        @Suppress("DEPRECATION") outline.setConvexPath(pathForOutline)
+      }
+    } else {
+      outline.setRect(bounds)
+    }
+  }
+
+  private fun <T> withNewLayer(
+      newLayer: T,
+      id: Int,
+      setNewLayer: (T) -> Unit,
+  ): CompositeBackgroundDrawable where T : Drawable? {
+    setNewLayer(newLayer)
+    if (ReactNativeFeatureFlags.enableNewBackgroundAndBorderDrawables()) {
+      if (updateLayer(newLayer, id)) {
+        return this
+      }
+    }
     return CompositeBackgroundDrawable(
-        originalBackground, outerShadows, cssBackground, newUnderlay, innerShadows)
+            context,
+            originalBackground,
+            outerShadows,
+            cssBackground,
+            background,
+            border,
+            feedbackUnderlay,
+            innerShadows,
+            outline)
+        .also { composite ->
+          composite.borderInsets = this.borderInsets
+          composite.borderRadius = this.borderRadius
+        }
+  }
+
+  private companion object {
+    private const val ORIGINAL_BACKGROUND_ID: Int = 0
+    private const val OUTER_SHADOWS_ID: Int = 1
+    private const val CSS_BACKGROUND_ID: Int = 2
+    private const val BACKGROUND_ID: Int = 3
+    private const val BORDER_ID: Int = 4
+    private const val FEEDBACK_UNDERLAY_ID: Int = 5
+    private const val INNER_SHADOWS_ID: Int = 6
+    private const val OUTLINE_ID: Int = 7
   }
 }

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

@@ -14,6 +14,7 @@ import android.graphics.Color
 import android.graphics.ColorFilter
 import android.graphics.Paint
 import android.graphics.Path
+import android.graphics.PixelFormat
 import android.graphics.RectF
 import android.graphics.drawable.Drawable
 import androidx.annotation.RequiresApi
@@ -39,30 +40,18 @@ private val ZERO_RADII = floatArrayOf(0f, 0f, 0f, 0f, 0f, 0f, 0f, 0f)
 @RequiresApi(MIN_INSET_BOX_SHADOW_SDK_VERSION)
 internal class InsetBoxShadowDrawable(
     private val context: Context,
-    borderRadius: BorderRadiusStyle? = null,
-    borderInsets: BorderInsets? = null,
     private val shadowColor: Int,
     private val offsetX: Float,
     private val offsetY: Float,
     private val blurRadius: Float,
     private val spread: Float,
+    /*
+     * We assume borderRadius & borderInsets to be shared across multiple drawables
+     * therefore user should invalidate this drawable when changing either of them
+     */
+    var borderInsets: BorderInsets? = null,
+    var borderRadius: BorderRadiusStyle? = null,
 ) : Drawable() {
-  public var borderRadius = borderRadius
-    set(value) {
-      if (value != field) {
-        field = value
-        invalidateSelf()
-      }
-    }
-
-  public var borderInsets = borderInsets
-    set(value) {
-      if (value != field) {
-        field = value
-        invalidateSelf()
-      }
-    }
-
   private val shadowPaint =
       Paint().apply {
         color = shadowColor
@@ -84,8 +73,15 @@ internal class InsetBoxShadowDrawable(
     invalidateSelf()
   }
 
-  override fun getOpacity(): Int =
-      ((shadowPaint.alpha / 255f) / (Color.alpha(shadowColor) / 255f) * 255f).roundToInt()
+  @Deprecated("Deprecated in Java")
+  override fun getOpacity(): Int {
+    val alpha = shadowPaint.alpha
+    return when (alpha) {
+      255 -> PixelFormat.OPAQUE
+      in 1..254 -> PixelFormat.TRANSLUCENT
+      else -> PixelFormat.TRANSPARENT
+    }
+  }
 
   override fun draw(canvas: Canvas) {
     val computedBorderRadii = computeBorderRadii()

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

@@ -0,0 +1,189 @@
+/*
+ * 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.drawable
+
+import android.content.Context
+import android.graphics.Canvas
+import android.graphics.Color
+import android.graphics.ColorFilter
+import android.graphics.DashPathEffect
+import android.graphics.Paint
+import android.graphics.Path
+import android.graphics.PathEffect
+import android.graphics.PixelFormat
+import android.graphics.RectF
+import android.graphics.drawable.Drawable
+import com.facebook.react.uimanager.PixelUtil.pxToDp
+import com.facebook.react.uimanager.style.BorderRadiusStyle
+import com.facebook.react.uimanager.style.ComputedBorderRadius
+import com.facebook.react.uimanager.style.CornerRadii
+import com.facebook.react.uimanager.style.OutlineStyle
+import kotlin.math.roundToInt
+
+/** Draws outline https://drafts.csswg.org/css-ui/#outline */
+internal class OutlineDrawable(
+    private val context: Context,
+    /*
+     * We assume borderRadius to be shared across multiple drawables
+     * therefore we should manually invalidate this drawable when changing it
+     */
+    var borderRadius: BorderRadiusStyle? = null,
+    outlineColor: Int,
+    outlineOffset: Float,
+    outlineStyle: OutlineStyle,
+    outlineWidth: Float,
+) : Drawable() {
+  /**
+   * There is a small gap between the edges of adjacent paths, such as between its Border and its
+   * Outline. The smallest amount (found to be 0.8f) is used to shrink outline's path, overlapping
+   * them and closing the visible gap.
+   */
+  private val gapBetweenPaths = 0.8f
+
+  public var outlineOffset: Float = outlineOffset
+    set(value) {
+      if (value != field) {
+        field = value
+        invalidateSelf()
+      }
+    }
+
+  public var outlineStyle: OutlineStyle = outlineStyle
+    set(value) {
+      if (value != field) {
+        field = value
+        outlinePaint.pathEffect = getPathEffect(value, outlineWidth)
+        invalidateSelf()
+      }
+    }
+
+  public var outlineColor: Int = outlineColor
+    set(value) {
+      if (value != field) {
+        field = value
+        outlinePaint.color = value
+        invalidateSelf()
+      }
+    }
+
+  public var outlineWidth: Float = outlineWidth
+    set(value) {
+      if (value != field) {
+        field = value
+        outlinePaint.strokeWidth = value
+        outlinePaint.pathEffect = getPathEffect(outlineStyle, value)
+        invalidateSelf()
+      }
+    }
+
+  private val outlinePaint: Paint =
+      Paint().apply {
+        style = Paint.Style.STROKE
+        color = outlineColor
+        strokeWidth = outlineWidth
+        pathEffect = getPathEffect(outlineStyle, outlineWidth)
+      }
+
+  private var computedBorderRadius: ComputedBorderRadius? = null
+  private var tempRectForOutline = RectF()
+
+  private val pathForOutline = Path()
+
+  override fun setAlpha(alpha: Int) {
+    outlinePaint.alpha = (((alpha / 255f) * (Color.alpha(outlineColor) / 255f)) * 255f).roundToInt()
+    invalidateSelf()
+  }
+
+  override fun setColorFilter(colorFilter: ColorFilter?) {
+    outlinePaint.colorFilter = colorFilter
+    invalidateSelf()
+  }
+
+  @Deprecated("Deprecated in Java")
+  override fun getOpacity(): Int {
+    val alpha = outlinePaint.alpha
+    return when (alpha) {
+      255 -> PixelFormat.OPAQUE
+      in 1..254 -> PixelFormat.TRANSLUCENT
+      else -> PixelFormat.TRANSPARENT
+    }
+  }
+
+  override fun draw(canvas: Canvas) {
+    if (outlineWidth == 0f) {
+      return
+    }
+
+    pathForOutline.reset()
+
+    computedBorderRadius =
+        borderRadius?.resolve(
+            layoutDirection, context, bounds.width().pxToDp(), bounds.height().pxToDp())
+
+    updateOutlineRect()
+    if (computedBorderRadius != null && computedBorderRadius?.hasRoundedBorders() == true) {
+      drawRoundedOutline(canvas)
+    } else {
+      drawRectangularOutline(canvas)
+    }
+  }
+
+  private fun updateOutlineRect() {
+    tempRectForOutline.set(bounds)
+
+    tempRectForOutline.top -= outlineWidth * 0.5f + outlineOffset - gapBetweenPaths
+    tempRectForOutline.bottom += outlineWidth * 0.5f + outlineOffset - gapBetweenPaths
+    tempRectForOutline.left -= outlineWidth * 0.5f + outlineOffset - gapBetweenPaths
+    tempRectForOutline.right += outlineWidth * 0.5f + outlineOffset - gapBetweenPaths
+  }
+
+  private fun getPathEffect(style: OutlineStyle, outlineWidth: Float): PathEffect? {
+    return when (style) {
+      OutlineStyle.SOLID -> null
+      OutlineStyle.DASHED ->
+          DashPathEffect(
+              floatArrayOf(outlineWidth * 3, outlineWidth * 3, outlineWidth * 3, outlineWidth * 3),
+              0f)
+      OutlineStyle.DOTTED ->
+          DashPathEffect(floatArrayOf(outlineWidth, outlineWidth, outlineWidth, outlineWidth), 0f)
+    }
+  }
+
+  private fun calculateRadius(radius: Float, outlineWidth: Float) =
+      if (radius != 0f) radius + outlineWidth * 0.5f else 0f
+
+  private fun drawRectangularOutline(canvas: Canvas) {
+    pathForOutline.addRect(tempRectForOutline, Path.Direction.CW)
+
+    canvas.drawPath(pathForOutline, outlinePaint)
+  }
+
+  private fun drawRoundedOutline(canvas: Canvas) {
+    val topLeftRadius = computedBorderRadius?.topLeft?.toPixelFromDIP() ?: CornerRadii(0f, 0f)
+    val topRightRadius = computedBorderRadius?.topRight?.toPixelFromDIP() ?: CornerRadii(0f, 0f)
+    val bottomLeftRadius = computedBorderRadius?.bottomLeft?.toPixelFromDIP() ?: CornerRadii(0f, 0f)
+    val bottomRightRadius =
+        computedBorderRadius?.bottomRight?.toPixelFromDIP() ?: CornerRadii(0f, 0f)
+
+    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),
+        ),
+        Path.Direction.CW)
+
+    canvas.drawPath(pathForOutline, outlinePaint)
+  }
+}

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

@@ -14,6 +14,7 @@ import android.graphics.Color
 import android.graphics.ColorFilter
 import android.graphics.Paint
 import android.graphics.Path
+import android.graphics.PixelFormat
 import android.graphics.RectF
 import android.graphics.drawable.Drawable
 import androidx.annotation.RequiresApi
@@ -36,21 +37,17 @@ private const val BLUR_RADIUS_SIGMA_SCALE = 0.5f
 @RequiresApi(MIN_OUTSET_BOX_SHADOW_SDK_VERSION)
 internal class OutsetBoxShadowDrawable(
     private val context: Context,
-    borderRadius: BorderRadiusStyle? = null,
     private val shadowColor: Int,
     private val offsetX: Float,
     private val offsetY: Float,
     private val blurRadius: Float,
     private val spread: Float,
+    /*
+     * We assume borderRadius to be shared across multiple drawables
+     * therefore we should manually invalidate this drawable when changing it
+     */
+    var borderRadius: BorderRadiusStyle? = null,
 ) : Drawable() {
-  public var borderRadius = borderRadius
-    set(value) {
-      if (value != field) {
-        field = value
-        invalidateSelf()
-      }
-    }
-
   private val shadowPaint =
       Paint().apply {
         color = shadowColor
@@ -72,8 +69,15 @@ internal class OutsetBoxShadowDrawable(
     invalidateSelf()
   }
 
-  override fun getOpacity(): Int =
-      ((shadowPaint.alpha / 255f) / (Color.alpha(shadowColor) / 255f) * 255f).roundToInt()
+  @Deprecated("Deprecated in Java")
+  override fun getOpacity(): Int {
+    val alpha = shadowPaint.alpha
+    return when (alpha) {
+      255 -> PixelFormat.OPAQUE
+      in 1..254 -> PixelFormat.TRANSLUCENT
+      else -> PixelFormat.TRANSPARENT
+    }
+  }
 
   override fun draw(canvas: Canvas) {
     val resolutionWidth = bounds.width().toFloat().pxToDp()

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

@@ -34,6 +34,7 @@ public class BlackHoleEventDispatcher private constructor() : EventDispatcher {
       listener: BatchEventDispatchedListener
   ): Unit = Unit
 
+  @Deprecated("Deprecated in Java")
   @Suppress("DEPRECATION")
   public override fun registerEventEmitter(
       uiManagerType: Int,

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

@@ -143,6 +143,9 @@ public class FabricEventDispatcher implements EventDispatcher, LifecycleEventLis
   @Override
   public void onHostResume() {
     scheduleDispatchOfBatchedEvents();
+    if (!ReactNativeFeatureFlags.useOptimizedEventBatchingOnAndroid()) {
+      mCurrentFrameCallback.resume();
+    }
   }
 
   @Override
@@ -216,6 +219,10 @@ public class FabricEventDispatcher implements EventDispatcher, LifecycleEventLis
       mShouldStop = true;
     }
 
+    public void resume() {
+      mShouldStop = false;
+    }
+
     public void maybeDispatchBatchedEvents() {
       if (!mIsDispatchScheduled) {
         mIsDispatchScheduled = true;

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

@@ -278,12 +278,12 @@ public class PointerEvent extends Event<PointerEvent> {
     int activePointerIndex = mMotionEvent.getActionIndex();
     List<WritableMap> pointersEventData = null;
     switch (mEventName) {
-        // Cases where all pointer info is relevant
+      // Cases where all pointer info is relevant
       case PointerEventHelper.POINTER_MOVE:
       case PointerEventHelper.POINTER_CANCEL:
         pointersEventData = createW3CPointerEvents();
         break;
-        // Cases where only the "active" pointer info is relevant
+      // Cases where only the "active" pointer info is relevant
       case PointerEventHelper.POINTER_ENTER:
       case PointerEventHelper.POINTER_DOWN:
       case PointerEventHelper.POINTER_UP:

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

@@ -110,6 +110,7 @@ public class TouchEvent private constructor() : Event<TouchEvent>() {
 
   override fun getCoalescingKey(): Short = coalescingKey
 
+  @Deprecated("Deprecated in Java")
   override fun dispatch(rctEventEmitter: RCTEventEmitter) {
     if (verifyMotionEvent()) {
       TouchesHelper.sendTouchesLegacy(rctEventEmitter, this)