react-native-tvos 0.75.3-0 → 0.76.0-0

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

@@ -0,0 +1,191 @@
+/*
+ * 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.BlurMaskFilter
+import android.graphics.Canvas
+import android.graphics.Color
+import android.graphics.ColorFilter
+import android.graphics.Paint
+import android.graphics.Path
+import android.graphics.RectF
+import android.graphics.drawable.Drawable
+import androidx.annotation.RequiresApi
+import com.facebook.react.uimanager.FilterHelper
+import com.facebook.react.uimanager.PixelUtil.dpToPx
+import com.facebook.react.uimanager.PixelUtil.pxToDp
+import com.facebook.react.uimanager.style.BorderInsets
+import com.facebook.react.uimanager.style.BorderRadiusStyle
+import com.facebook.react.uimanager.style.ComputedBorderRadius
+import com.facebook.react.uimanager.style.CornerRadii
+import kotlin.math.roundToInt
+
+internal const val MIN_INSET_BOX_SHADOW_SDK_VERSION = 29
+
+// "the resulting shadow must approximate {...} a Gaussian blur with a standard deviation equal
+// to half the blur radius"
+// https://www.w3.org/TR/css-backgrounds-3/#shadow-blur
+private const val BLUR_RADIUS_SIGMA_SCALE = 0.5f
+
+private val ZERO_RADII = floatArrayOf(0f, 0f, 0f, 0f, 0f, 0f, 0f, 0f)
+
+/** Draws an inner box-shadow https://www.w3.org/TR/css-backgrounds-3/#shadow-shape */
+@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,
+) : 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
+        if (blurRadius > 0) {
+          maskFilter =
+              BlurMaskFilter(
+                  FilterHelper.sigmaToRadius(blurRadius * BLUR_RADIUS_SIGMA_SCALE),
+                  BlurMaskFilter.Blur.NORMAL)
+        }
+      }
+
+  override fun setAlpha(alpha: Int) {
+    shadowPaint.alpha = (((alpha / 255f) * (Color.alpha(shadowColor) / 255f)) * 255f).roundToInt()
+    invalidateSelf()
+  }
+
+  override fun setColorFilter(colorFilter: ColorFilter?) {
+    shadowPaint.colorFilter = colorFilter
+    invalidateSelf()
+  }
+
+  override fun getOpacity(): Int =
+      ((shadowPaint.alpha / 255f) / (Color.alpha(shadowColor) / 255f) * 255f).roundToInt()
+
+  override fun draw(canvas: Canvas) {
+    val computedBorderRadii = computeBorderRadii()
+    val computedBorderInsets = computeBorderInsets()
+
+    val paddingBoxRect =
+        RectF(
+            bounds.left + (computedBorderInsets?.left ?: 0f),
+            bounds.top + (computedBorderInsets?.top ?: 0f),
+            bounds.right - (computedBorderInsets?.right ?: 0f),
+            bounds.bottom - (computedBorderInsets?.bottom ?: 0f))
+    val paddingBoxRadii =
+        computedBorderRadii?.let {
+          floatArrayOf(
+              innerRadius(it.topLeft.horizontal, computedBorderInsets?.left),
+              innerRadius(it.topLeft.vertical, computedBorderInsets?.top),
+              innerRadius(it.topRight.horizontal, computedBorderInsets?.right),
+              innerRadius(it.topRight.vertical, computedBorderInsets?.top),
+              innerRadius(it.bottomRight.horizontal, computedBorderInsets?.right),
+              innerRadius(it.bottomRight.vertical, computedBorderInsets?.bottom),
+              innerRadius(it.bottomLeft.horizontal, computedBorderInsets?.left),
+              innerRadius(it.bottomLeft.vertical, computedBorderInsets?.bottom))
+        }
+
+    val x = offsetX.dpToPx()
+    val y = offsetY.dpToPx()
+    val spreadExtent = spread.dpToPx()
+    val innerRect =
+        RectF(paddingBoxRect).apply {
+          inset(spreadExtent, spreadExtent)
+          offset(x, y)
+        }
+
+    // Graciously stolen from Blink
+    // 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(innerRect).apply {
+          inset(-blurExtent, -blurExtent)
+          if (spreadExtent < 0) {
+            inset(spreadExtent, spreadExtent)
+          }
+          union(RectF(this).apply { offset(-x, -y) })
+        }
+
+    canvas.save().let { saveCount ->
+      if (paddingBoxRadii != null) {
+        canvas.clipPath(
+            Path().apply { addRoundRect(paddingBoxRect, paddingBoxRadii, Path.Direction.CW) })
+
+        val innerRadii =
+            paddingBoxRadii.map { adjustRadiusForSpread(it, -spreadExtent) }.toFloatArray()
+
+        canvas.drawDoubleRoundRect(outerRect, ZERO_RADII, innerRect, innerRadii, shadowPaint)
+      } else {
+        canvas.clipRect(paddingBoxRect)
+        canvas.drawDoubleRoundRect(outerRect, ZERO_RADII, innerRect, ZERO_RADII, shadowPaint)
+      }
+
+      canvas.restoreToCount(saveCount)
+    }
+  }
+
+  private fun computeBorderRadii(): ComputedBorderRadius? {
+    val resolvedBorderRadii =
+        borderRadius?.resolve(
+            layoutDirection,
+            context,
+            bounds.width().toFloat().pxToDp(),
+            bounds.height().toFloat().pxToDp())
+
+    return if (resolvedBorderRadii?.hasRoundedBorders() == true) {
+      ComputedBorderRadius(
+          topLeft =
+              CornerRadii(
+                  resolvedBorderRadii.topLeft.horizontal.dpToPx(),
+                  resolvedBorderRadii.topLeft.vertical.dpToPx()),
+          topRight =
+              CornerRadii(
+                  resolvedBorderRadii.topRight.horizontal.dpToPx(),
+                  resolvedBorderRadii.topRight.vertical.dpToPx()),
+          bottomLeft =
+              CornerRadii(
+                  resolvedBorderRadii.bottomLeft.horizontal.dpToPx(),
+                  resolvedBorderRadii.bottomLeft.vertical.dpToPx()),
+          bottomRight =
+              CornerRadii(
+                  resolvedBorderRadii.bottomRight.horizontal.dpToPx(),
+                  resolvedBorderRadii.bottomRight.vertical.dpToPx()),
+      )
+    } else {
+      null
+    }
+  }
+
+  private fun computeBorderInsets(): RectF? =
+      borderInsets?.resolve(layoutDirection, context)?.let {
+        RectF(it.left.dpToPx(), it.top.dpToPx(), it.right.dpToPx(), it.bottom.dpToPx())
+      }
+
+  private fun innerRadius(radius: Float, borderInset: Float?): Float =
+      (radius - (borderInset ?: 0f)).coerceAtLeast(0f)
+}

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

@@ -0,0 +1,159 @@
+/*
+ * 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.BlurMaskFilter
+import android.graphics.Canvas
+import android.graphics.Color
+import android.graphics.ColorFilter
+import android.graphics.Paint
+import android.graphics.Path
+import android.graphics.RectF
+import android.graphics.drawable.Drawable
+import androidx.annotation.RequiresApi
+import com.facebook.react.uimanager.FilterHelper
+import com.facebook.react.uimanager.PixelUtil.dpToPx
+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 kotlin.math.roundToInt
+
+internal const val MIN_OUTSET_BOX_SHADOW_SDK_VERSION = 28
+
+// "the resulting shadow must approximate {...} a Gaussian blur with a standard deviation equal
+// to half the blur radius"
+// https://www.w3.org/TR/css-backgrounds-3/#shadow-blur
+private const val BLUR_RADIUS_SIGMA_SCALE = 0.5f
+
+/** Draws an outer box-shadow https://www.w3.org/TR/css-backgrounds-3/#shadow-shape */
+@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,
+) : Drawable() {
+  public var borderRadius = borderRadius
+    set(value) {
+      if (value != field) {
+        field = value
+        invalidateSelf()
+      }
+    }
+
+  private val shadowPaint =
+      Paint().apply {
+        color = shadowColor
+        if (blurRadius > 0) {
+          maskFilter =
+              BlurMaskFilter(
+                  FilterHelper.sigmaToRadius(blurRadius * BLUR_RADIUS_SIGMA_SCALE),
+                  BlurMaskFilter.Blur.NORMAL)
+        }
+      }
+
+  override fun setAlpha(alpha: Int) {
+    shadowPaint.alpha = (((alpha / 255f) * (Color.alpha(shadowColor) / 255f)) * 255f).roundToInt()
+    invalidateSelf()
+  }
+
+  override fun setColorFilter(colorFilter: ColorFilter?) {
+    shadowPaint.colorFilter = colorFilter
+    invalidateSelf()
+  }
+
+  override fun getOpacity(): Int =
+      ((shadowPaint.alpha / 255f) / (Color.alpha(shadowColor) / 255f) * 255f).roundToInt()
+
+  override fun draw(canvas: Canvas) {
+    val resolutionWidth = bounds.width().toFloat().pxToDp()
+    val resolutionHeight = bounds.height().toFloat().pxToDp()
+    val computedBorderRadii =
+        borderRadius?.resolve(layoutDirection, context, resolutionWidth, resolutionHeight)?.let {
+          ComputedBorderRadius(
+              topLeft = CornerRadii(it.topLeft.horizontal.dpToPx(), it.topLeft.vertical.dpToPx()),
+              topRight =
+                  CornerRadii(it.topRight.horizontal.dpToPx(), it.topRight.vertical.dpToPx()),
+              bottomLeft =
+                  CornerRadii(it.bottomLeft.horizontal.dpToPx(), it.bottomLeft.vertical.dpToPx()),
+              bottomRight =
+                  CornerRadii(it.bottomRight.horizontal.dpToPx(), it.bottomRight.vertical.dpToPx()),
+          )
+        }
+
+    val spreadExtent = spread.dpToPx()
+    val shadowRect =
+        RectF(bounds).apply {
+          inset(-spreadExtent, -spreadExtent)
+          offset(offsetX.dpToPx(), offsetY.dpToPx())
+        }
+
+    canvas.save().let { saveCount ->
+      if (computedBorderRadii?.hasRoundedBorders() == true) {
+        drawShadowRoundRect(canvas, shadowRect, spreadExtent, computedBorderRadii)
+      } else {
+        drawShadowRect(canvas, shadowRect)
+      }
+      canvas.restoreToCount(saveCount)
+    }
+  }
+
+  private fun drawShadowRoundRect(
+      canvas: Canvas,
+      shadowRect: RectF,
+      spreadExtent: Float,
+      computedBorderRadii: ComputedBorderRadius
+  ) {
+    // We inset the clip slightly, to avoid Skia artifacts with antialiased
+    // clipping. This inset is only visible when no background is present.
+    // https://neugierig.org/software/chromium/notes/2010/07/clipping.html
+    val subpixelInsetBounds = RectF(bounds).apply { inset(0.4f, 0.4f) }
+    canvas.clipOutPath(
+        Path().apply {
+          addRoundRect(
+              subpixelInsetBounds,
+              floatArrayOf(
+                  computedBorderRadii.topLeft.horizontal,
+                  computedBorderRadii.topLeft.vertical,
+                  computedBorderRadii.topRight.horizontal,
+                  computedBorderRadii.topRight.vertical,
+                  computedBorderRadii.bottomRight.horizontal,
+                  computedBorderRadii.bottomRight.vertical,
+                  computedBorderRadii.bottomLeft.horizontal,
+                  computedBorderRadii.bottomLeft.vertical),
+              Path.Direction.CW)
+        })
+
+    canvas.drawPath(
+        Path().apply {
+          addRoundRect(
+              shadowRect,
+              floatArrayOf(
+                  adjustRadiusForSpread(computedBorderRadii.topLeft.horizontal, spreadExtent),
+                  adjustRadiusForSpread(computedBorderRadii.topLeft.vertical, spreadExtent),
+                  adjustRadiusForSpread(computedBorderRadii.topRight.horizontal, spreadExtent),
+                  adjustRadiusForSpread(computedBorderRadii.topRight.vertical, spreadExtent),
+                  adjustRadiusForSpread(computedBorderRadii.bottomRight.horizontal, spreadExtent),
+                  adjustRadiusForSpread(computedBorderRadii.bottomRight.vertical, spreadExtent),
+                  adjustRadiusForSpread(computedBorderRadii.bottomLeft.horizontal, spreadExtent),
+                  adjustRadiusForSpread(computedBorderRadii.bottomLeft.vertical, spreadExtent)),
+              Path.Direction.CW)
+        },
+        shadowPaint)
+  }
+
+  private fun drawShadowRect(canvas: Canvas, shadowRect: RectF) {
+    canvas.clipOutRect(bounds)
+    canvas.drawRect(shadowRect, shadowPaint)
+  }
+}

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

@@ -0,0 +1,57 @@
+/*
+ * 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.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.
+ */
+public class BlackHoleEventDispatcher private constructor() : EventDispatcher {
+  public override fun dispatchEvent(event: Event<*>) {
+    FLog.d(
+        "BlackHoleEventDispatcher",
+        "Trying to emit event to JS, but the React instance isn't ready. Event: ${event.eventName}")
+  }
+
+  public override fun dispatchAllEvents(): Unit = Unit
+
+  public override fun addListener(listener: EventDispatcherListener): Unit = Unit
+
+  public override fun removeListener(listener: EventDispatcherListener): Unit = Unit
+
+  public override fun addBatchEventDispatchedListener(
+      listener: BatchEventDispatchedListener
+  ): Unit = Unit
+
+  public override fun removeBatchEventDispatchedListener(
+      listener: BatchEventDispatchedListener
+  ): Unit = Unit
+
+  @Suppress("DEPRECATION")
+  public override fun registerEventEmitter(
+      uiManagerType: Int,
+      eventEmitter: RCTEventEmitter
+  ): Unit = Unit
+
+  public override fun registerEventEmitter(
+      uiManagerType: Int,
+      eventEmitter: RCTModernEventEmitter
+  ): Unit = Unit
+
+  public override fun unregisterEventEmitter(uiManagerType: Int): Unit = Unit
+
+  public override fun onCatalystInstanceDestroyed(): Unit = Unit
+
+  public companion object {
+    private val eventDispatcher: EventDispatcher = BlackHoleEventDispatcher()
+
+    public @JvmStatic fun get(): EventDispatcher = eventDispatcher
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/events/ContentSizeChangeEvent.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.
+ */
+
+@file:Suppress("DEPRECATION")
+
+package com.facebook.react.uimanager.events
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.PixelUtil.toDIPFromPixel
+
+/** Event dispatched when total width or height of a view's children changes. */
+@Deprecated("Please define your own event for custom components")
+public class ContentSizeChangeEvent(
+    surfaceId: Int,
+    viewTag: Int,
+    private val width: Int,
+    private val height: Int
+) : Event<ContentSizeChangeEvent>(surfaceId, viewTag) {
+  @Deprecated(
+      "Please specify surfaceId explicitly in the constructor.",
+      ReplaceWith("constructor(surfaceId, viewTag, width, height)"))
+  public constructor(viewTag: Int, width: Int, height: Int) : this(-1, viewTag, width, height)
+
+  public override fun getEventName(): String = "topContentSizeChange"
+
+  protected override fun getEventData(): WritableMap {
+    val res = Arguments.createMap()
+    res.putDouble("width", toDIPFromPixel(width.toFloat()).toDouble())
+    res.putDouble("height", toDIPFromPixel(height.toFloat()).toDouble())
+    return res
+  }
+}

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

@@ -15,7 +15,7 @@ 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.config.ReactFeatureFlags;
+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,7 +318,7 @@ public class EventDispatcherImpl implements EventDispatcher, LifecycleEventListe
     }
 
     private void post() {
-      if (!ReactFeatureFlags.enableFabricRendererExclusively) {
+      if (!ReactNativeFeatureFlags.enableFabricRendererExclusively()) {
         ReactChoreographer.getInstance()
             .postFrameCallback(
                 ReactChoreographer.CallbackType.TIMERS_EVENTS, mCurrentFrameCallback);

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

@@ -7,6 +7,7 @@
 
 package com.facebook.react.uimanager.events;
 
+import android.os.Handler;
 import android.view.Choreographer;
 import com.facebook.infer.annotation.Nullsafe;
 import com.facebook.react.bridge.LifecycleEventListener;
@@ -15,6 +16,7 @@ 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;
@@ -27,6 +29,8 @@ import java.util.concurrent.CopyOnWriteArrayList;
  */
 @Nullsafe(Nullsafe.Mode.LOCAL)
 public class FabricEventDispatcher implements EventDispatcher, LifecycleEventListener {
+  private static final Handler uiThreadHandler = UiThreadUtil.getUiThreadHandler();
+
   private final ReactEventEmitter mReactEventEmitter;
   private final ReactApplicationContext mReactContext;
   private final CopyOnWriteArrayList<EventDispatcherListener> mListeners =
@@ -36,6 +40,25 @@ public class FabricEventDispatcher implements EventDispatcher, LifecycleEventLis
   private final FabricEventDispatcher.ScheduleDispatchFrameCallback mCurrentFrameCallback =
       new FabricEventDispatcher.ScheduleDispatchFrameCallback();
 
+  private boolean mIsDispatchScheduled = false;
+  private final Runnable mDispatchEventsRunnable =
+      new Runnable() {
+        @Override
+        public void run() {
+          mIsDispatchScheduled = false;
+
+          Systrace.beginSection(
+              Systrace.TRACE_TAG_REACT_JAVA_BRIDGE, "BatchEventDispatchedListeners");
+          try {
+            for (BatchEventDispatchedListener listener : mPostEventDispatchListeners) {
+              listener.onBatchEventDispatched();
+            }
+          } finally {
+            Systrace.endSection(Systrace.TRACE_TAG_REACT_JAVA_BRIDGE);
+          }
+        }
+      };
+
   public FabricEventDispatcher(ReactApplicationContext reactContext) {
     mReactContext = reactContext;
     mReactContext.addLifecycleEventListener(this);
@@ -54,7 +77,7 @@ public class FabricEventDispatcher implements EventDispatcher, LifecycleEventLis
     }
 
     event.dispose();
-    maybePostFrameCallbackFromNonUI();
+    scheduleDispatchOfBatchedEvents();
   }
 
   private void dispatchSynchronous(Event event) {
@@ -85,19 +108,17 @@ public class FabricEventDispatcher implements EventDispatcher, LifecycleEventLis
   }
 
   public void dispatchAllEvents() {
-    maybePostFrameCallbackFromNonUI();
+    scheduleDispatchOfBatchedEvents();
   }
 
-  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();
+  private void scheduleDispatchOfBatchedEvents() {
+    if (ReactNativeFeatureFlags.useOptimizedEventBatchingOnAndroid()) {
+      if (!mIsDispatchScheduled) {
+        mIsDispatchScheduled = true;
+        uiThreadHandler.postAtFrontOfQueue(mDispatchEventsRunnable);
+      }
     } 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.maybeScheduleDispatchOfBatchedEvents();
     }
   }
 
@@ -121,17 +142,17 @@ public class FabricEventDispatcher implements EventDispatcher, LifecycleEventLis
 
   @Override
   public void onHostResume() {
-    maybePostFrameCallbackFromNonUI();
+    scheduleDispatchOfBatchedEvents();
   }
 
   @Override
   public void onHostPause() {
-    stopFrameCallback();
+    cancelDispatchOfBatchedEvents();
   }
 
   @Override
   public void onHostDestroy() {
-    stopFrameCallback();
+    cancelDispatchOfBatchedEvents();
   }
 
   public void onCatalystInstanceDestroyed() {
@@ -139,14 +160,19 @@ public class FabricEventDispatcher implements EventDispatcher, LifecycleEventLis
         new Runnable() {
           @Override
           public void run() {
-            stopFrameCallback();
+            cancelDispatchOfBatchedEvents();
           }
         });
   }
 
-  private void stopFrameCallback() {
+  private void cancelDispatchOfBatchedEvents() {
     UiThreadUtil.assertOnUiThread();
-    mCurrentFrameCallback.stop();
+    if (ReactNativeFeatureFlags.useOptimizedEventBatchingOnAndroid()) {
+      mIsDispatchScheduled = false;
+      uiThreadHandler.removeCallbacks(mDispatchEventsRunnable);
+    } else {
+      mCurrentFrameCallback.stop();
+    }
   }
 
   public void registerEventEmitter(@UIManagerType int uiManagerType, RCTEventEmitter eventEmitter) {
@@ -163,7 +189,7 @@ public class FabricEventDispatcher implements EventDispatcher, LifecycleEventLis
   }
 
   private class ScheduleDispatchFrameCallback implements Choreographer.FrameCallback {
-    private volatile boolean mIsPosted = false;
+    private volatile boolean mIsDispatchScheduled = false;
     private boolean mShouldStop = false;
 
     @Override
@@ -171,9 +197,9 @@ public class FabricEventDispatcher implements EventDispatcher, LifecycleEventLis
       UiThreadUtil.assertOnUiThread();
 
       if (mShouldStop) {
-        mIsPosted = false;
+        mIsDispatchScheduled = false;
       } else {
-        post();
+        dispatchBatchedEvents();
       }
 
       Systrace.beginSection(Systrace.TRACE_TAG_REACT_JAVA_BRIDGE, "BatchEventDispatchedListeners");
@@ -190,32 +216,32 @@ public class FabricEventDispatcher implements EventDispatcher, LifecycleEventLis
       mShouldStop = true;
     }
 
-    public void maybePost() {
-      if (!mIsPosted) {
-        mIsPosted = true;
-        post();
+    public void maybeDispatchBatchedEvents() {
+      if (!mIsDispatchScheduled) {
+        mIsDispatchScheduled = true;
+        dispatchBatchedEvents();
       }
     }
 
-    private void post() {
+    private void dispatchBatchedEvents() {
       ReactChoreographer.getInstance()
           .postFrameCallback(ReactChoreographer.CallbackType.TIMERS_EVENTS, mCurrentFrameCallback);
     }
 
-    public void maybePostFromNonUI() {
-      if (mIsPosted) {
+    public void maybeScheduleDispatchOfBatchedEvents() {
+      if (mIsDispatchScheduled) {
         return;
       }
 
       // We should only hit this slow path when we receive events while the host activity is paused.
       if (mReactContext.isOnUiQueueThread()) {
-        maybePost();
+        maybeDispatchBatchedEvents();
       } else {
         mReactContext.runOnUiQueueThread(
             new Runnable() {
               @Override
               public void run() {
-                maybePost();
+                maybeDispatchBatchedEvents();
               }
             });
       }