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

package/ReactAndroid/src/main/java/com/facebook/react/views/scroll/ReactHorizontalScrollViewManager.java

@@ -9,15 +9,12 @@ package com.facebook.react.views.scroll;
 
 import android.graphics.Color;
 import android.view.View;
-import androidx.annotation.ColorInt;
 import androidx.annotation.Nullable;
 import androidx.core.view.ViewCompat;
 import com.facebook.infer.annotation.Nullsafe;
-import com.facebook.react.modules.i18nmanager.I18nUtil;
 import com.facebook.react.bridge.ReadableArray;
 import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.bridge.RetryableMountingLayerException;
-import com.facebook.react.internal.featureflags.ReactNativeFeatureFlags;
 import com.facebook.react.module.annotations.ReactModule;
 import com.facebook.react.uimanager.BackgroundStyleApplicator;
 import com.facebook.react.uimanager.LengthPercentage;
@@ -86,7 +83,6 @@ public class ReactHorizontalScrollViewManager extends ViewGroupManager<ReactHori
   @ReactProp(name = "scrollEnabled", defaultBoolean = true)
   public void setScrollEnabled(ReactHorizontalScrollView view, boolean value) {
     view.setScrollEnabled(value);
-    
     /*Set focusable to match whether scroll is enabled. This improves keyboarding
     experience by not making scrollview to scroll when scroll enabled is to false.*/
     view.setFocusable(value);
@@ -102,11 +98,6 @@ public class ReactHorizontalScrollViewManager extends ViewGroupManager<ReactHori
     view.setDecelerationRate(decelerationRate);
   }
 
-  @ReactProp(name = "enableSyncOnScroll")
-  public void setEnableSyncOnScroll(ReactHorizontalScrollView view, boolean enableSyncOnScroll) {
-    view.setEnableSyncOnScroll(enableSyncOnScroll);
-  }
-
   @ReactProp(name = "disableIntervalMomentum")
   public void setDisableIntervalMomentum(
       ReactHorizontalScrollView view, boolean disableIntervalMomentum) {
@@ -216,37 +207,11 @@ public class ReactHorizontalScrollViewManager extends ViewGroupManager<ReactHori
   }
 
   @Override
-  public void scrollTo(final ReactHorizontalScrollView scrollView, final ReactScrollViewCommandHelper.ScrollToCommandData data ) {
+  public void scrollTo(
+      ReactHorizontalScrollView scrollView, ReactScrollViewCommandHelper.ScrollToCommandData data) {
     scrollView.abortAnimation();
-    boolean isRTL = I18nUtil.getInstance().isRTL(scrollView.getContext());
-
-    int destX = data.mDestX;
-
-    if (isRTL && scrollView.getChildAt(0) instanceof ReactHorizontalScrollContainerView) {
-      final ReactHorizontalScrollContainerView child = (ReactHorizontalScrollContainerView) scrollView.getChildAt(0);
-
-      // correct the x offset destination, as on android the scrollOffset is not adjusted to RTL
-      // i.e. the right-most part of the view will be a positive index and the left-most negative
-      destX = child.getWidth() - scrollView.getWidth() - destX;
-
-      // If the scrollContainerView is in RTL mode, fix the current scroll position in
-      // reaction to layout changes - need to listen for layout change events (e.g. because of
-      // fetching new data) and update the scroll position accordingly as soon as it's available
-      child.setListener(new ReactHorizontalScrollContainerView.Listener() {
-        @Override
-        public void onLayout() {
-          int destX = child.getWidth() - child.getLastWidth() + scrollView.getScrollX();
-
-          if (data.mAnimated) {
-            scrollView.smoothScrollTo(destX, data.mDestY);
-          } else {
-            scrollView.scrollTo(destX, data.mDestY);
-          }
-        }
-      });
-    }
     if (data.mAnimated) {
-      scrollView.reactSmoothScrollTo(destX, data.mDestY);
+      scrollView.reactSmoothScrollTo(data.mDestX, data.mDestY);
     } else {
       scrollView.scrollTo(data.mDestX, data.mDestY);
     }
@@ -295,36 +260,20 @@ public class ReactHorizontalScrollViewManager extends ViewGroupManager<ReactHori
       },
       defaultFloat = Float.NaN)
   public void setBorderRadius(ReactHorizontalScrollView view, int index, float borderRadius) {
-    if (ReactNativeFeatureFlags.enableBackgroundStyleApplicator()) {
-      @Nullable
-      LengthPercentage radius =
-          Float.isNaN(borderRadius)
-              ? null
-              : new LengthPercentage(borderRadius, LengthPercentageType.POINT);
-      BackgroundStyleApplicator.setBorderRadius(view, BorderRadiusProp.values()[index], radius);
-    } else {
-      if (!Float.isNaN(borderRadius)) {
-        borderRadius = PixelUtil.toPixelFromDIP(borderRadius);
-      }
-
-      if (index == 0) {
-        view.setBorderRadius(borderRadius);
-      } else {
-        view.setBorderRadius(borderRadius, index - 1);
-      }
-    }
+    @Nullable
+    LengthPercentage radius =
+        Float.isNaN(borderRadius)
+            ? null
+            : new LengthPercentage(borderRadius, LengthPercentageType.POINT);
+    BackgroundStyleApplicator.setBorderRadius(view, BorderRadiusProp.values()[index], radius);
   }
 
   @ReactProp(name = "borderStyle")
   public void setBorderStyle(ReactHorizontalScrollView view, @Nullable String borderStyle) {
-    if (ReactNativeFeatureFlags.enableBackgroundStyleApplicator()) {
-      @Nullable
-      BorderStyle parsedBorderStyle =
-          borderStyle == null ? null : BorderStyle.fromString(borderStyle);
-      BackgroundStyleApplicator.setBorderStyle(view, parsedBorderStyle);
-    } else {
-      view.setBorderStyle(borderStyle);
-    }
+    @Nullable
+    BorderStyle parsedBorderStyle =
+        borderStyle == null ? null : BorderStyle.fromString(borderStyle);
+    BackgroundStyleApplicator.setBorderStyle(view, parsedBorderStyle);
   }
 
   @ReactPropGroup(
@@ -337,14 +286,7 @@ public class ReactHorizontalScrollViewManager extends ViewGroupManager<ReactHori
       },
       defaultFloat = Float.NaN)
   public void setBorderWidth(ReactHorizontalScrollView view, int index, float width) {
-    if (ReactNativeFeatureFlags.enableBackgroundStyleApplicator()) {
-      BackgroundStyleApplicator.setBorderWidth(view, LogicalEdge.values()[index], width);
-    } else {
-      if (!Float.isNaN(width)) {
-        width = PixelUtil.toPixelFromDIP(width);
-      }
-      view.setBorderWidth(SPACING_TYPES[index], width);
-    }
+    BackgroundStyleApplicator.setBorderWidth(view, LogicalEdge.values()[index], width);
   }
 
   @ReactPropGroup(
@@ -357,11 +299,7 @@ public class ReactHorizontalScrollViewManager extends ViewGroupManager<ReactHori
       },
       customType = "Color")
   public void setBorderColor(ReactHorizontalScrollView view, int index, @Nullable Integer color) {
-    if (ReactNativeFeatureFlags.enableBackgroundStyleApplicator()) {
-      BackgroundStyleApplicator.setBorderColor(view, LogicalEdge.ALL, color);
-    } else {
-      view.setBorderColor(SPACING_TYPES[index], color);
-    }
+    BackgroundStyleApplicator.setBorderColor(view, LogicalEdge.ALL, color);
   }
 
   @ReactProp(name = "overflow")
@@ -420,20 +358,4 @@ public class ReactHorizontalScrollViewManager extends ViewGroupManager<ReactHori
   public void setHorizontal(ReactHorizontalScrollView view, boolean horizontal) {
     // Do Nothing: Align with static ViewConfigs
   }
-
-  @ReactProp(name = ViewProps.BOX_SHADOW, customType = "BoxShadow")
-  public void setBoxShadow(ReactHorizontalScrollView view, @Nullable ReadableArray shadows) {
-    if (ReactNativeFeatureFlags.enableBackgroundStyleApplicator()) {
-      BackgroundStyleApplicator.setBoxShadow(view, shadows);
-    }
-  }
-
-  @Override
-  public void setBackgroundColor(ReactHorizontalScrollView view, @ColorInt int backgroundColor) {
-    if (ReactNativeFeatureFlags.enableBackgroundStyleApplicator()) {
-      BackgroundStyleApplicator.setBackgroundColor(view, backgroundColor);
-    } else {
-      super.setBackgroundColor(view, backgroundColor);
-    }
-  }
 }

package/ReactAndroid/src/main/java/com/facebook/react/views/scroll/ReactScrollView.java

@@ -39,7 +39,6 @@ import com.facebook.react.animated.NativeAnimatedModule;
 import com.facebook.react.bridge.ReactContext;
 import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.common.ReactConstants;
-import com.facebook.react.internal.featureflags.ReactNativeFeatureFlags;
 import com.facebook.react.uimanager.BackgroundStyleApplicator;
 import com.facebook.react.uimanager.LengthPercentage;
 import com.facebook.react.uimanager.LengthPercentageType;
@@ -50,7 +49,6 @@ import com.facebook.react.uimanager.ReactClippingViewGroup;
 import com.facebook.react.uimanager.ReactClippingViewGroupHelper;
 import com.facebook.react.uimanager.ReactOverflowViewWithInset;
 import com.facebook.react.uimanager.StateWrapper;
-import com.facebook.react.uimanager.ViewProps;
 import com.facebook.react.uimanager.events.NativeGestureUtil;
 import com.facebook.react.uimanager.style.BorderRadiusProp;
 import com.facebook.react.uimanager.style.BorderStyle;
@@ -62,7 +60,7 @@ import com.facebook.react.views.scroll.ReactScrollViewHelper.HasScrollState;
 import com.facebook.react.views.scroll.ReactScrollViewHelper.HasSmoothScroll;
 import com.facebook.react.views.scroll.ReactScrollViewHelper.HasStateWrapper;
 import com.facebook.react.views.scroll.ReactScrollViewHelper.ReactScrollViewScrollState;
-import com.facebook.react.views.view.ReactViewBackgroundManager;
+import com.facebook.systrace.Systrace;
 import java.lang.reflect.Field;
 import java.util.List;
 
@@ -104,11 +102,9 @@ public class ReactScrollView extends ScrollView
   private @Nullable Runnable mPostTouchRunnable;
   private boolean mRemoveClippedSubviews;
   private boolean mScrollEnabled = true;
-  private boolean mPreventReentry = false;
   private boolean mSendMomentumEvents;
   private @Nullable FpsListener mFpsListener = null;
   private @Nullable String mScrollPerfTag;
-  private boolean mEnableSyncOnScroll = false;
   private @Nullable Drawable mEndBackground;
   private int mEndFillColor = Color.TRANSPARENT;
   private boolean mDisableIntervalMomentum = false;
@@ -118,13 +114,12 @@ public class ReactScrollView extends ScrollView
   private boolean mSnapToEnd = true;
   private int mSnapToAlignment = SNAP_ALIGNMENT_DISABLED;
   private @Nullable View mContentView;
-  private ReactViewBackgroundManager mReactBackgroundManager;
   private @Nullable ReadableMap mCurrentContentOffset = null;
   private int pendingContentOffsetX = UNSET_CONTENT_OFFSET;
   private int pendingContentOffsetY = UNSET_CONTENT_OFFSET;
   private @Nullable StateWrapper mStateWrapper = null;
   private final ReactScrollViewScrollState mReactScrollViewScrollState =
-      new ReactScrollViewScrollState(ViewCompat.LAYOUT_DIRECTION_LTR);
+      new ReactScrollViewScrollState();
   private final ValueAnimator DEFAULT_FLING_ANIMATOR = ObjectAnimator.ofInt(this, "scrollY", 0, 0);
   private PointerEvents mPointerEvents = PointerEvents.AUTO;
   private long mLastScrollDispatchTime = 0;
@@ -139,13 +134,11 @@ public class ReactScrollView extends ScrollView
   public ReactScrollView(Context context, @Nullable FpsListener fpsListener) {
     super(context);
     mFpsListener = fpsListener;
-    mReactBackgroundManager = new ReactViewBackgroundManager(this);
 
     mScroller = getOverScrollerFromParent();
     setOnHierarchyChangeListener(this);
     setScrollBarStyle(SCROLLBARS_OUTSIDE_OVERLAY);
     setClipChildren(false);
-    mReactBackgroundManager.setOverflow(ViewProps.SCROLL);
 
     ViewCompat.setAccessibilityDelegate(this, new ReactScrollViewAccessibilityDelegate());
   }
@@ -215,10 +208,6 @@ public class ReactScrollView extends ScrollView
     mScrollPerfTag = scrollPerfTag;
   }
 
-  public void setEnableSyncOnScroll(boolean enableSyncOnScroll) {
-    mEnableSyncOnScroll = enableSyncOnScroll;
-  }
-
   public void setScrollEnabled(boolean scrollEnabled) {
     mScrollEnabled = scrollEnabled;
   }
@@ -277,7 +266,6 @@ public class ReactScrollView extends ScrollView
       mOverflow = parsedOverflow == null ? Overflow.SCROLL : parsedOverflow;
     }
 
-    mReactBackgroundManager.setOverflow(overflow == null ? ViewProps.SCROLL : overflow);
     invalidate();
   }
 
@@ -412,34 +400,25 @@ public class ReactScrollView extends ScrollView
     }
   }
 
-  @Override
-  protected int computeScrollDeltaToGetChildRectOnScreen(Rect rect) {
-    if (!mScrollEnabled) {
-      return 0;
-    }
-    return super.computeScrollDeltaToGetChildRectOnScreen(rect);
-  }
-
   @Override
   protected void onScrollChanged(int x, int y, int oldX, int oldY) {
-    super.onScrollChanged(x, y, oldX, oldY);
+    Systrace.beginSection(Systrace.TRACE_TAG_REACT_JAVA_BRIDGE, "ReactScrollView.onScrollChanged");
+    try {
+      super.onScrollChanged(x, y, oldX, oldY);
 
-    mActivelyScrolling = true;
+      mActivelyScrolling = true;
 
-    if (mOnScrollDispatchHelper.onScrollChanged(x, y)) {
-      if (mRemoveClippedSubviews) {
-        updateClippingRect();
-      }
-      if (mPreventReentry) {
-        return;
+      if (mOnScrollDispatchHelper.onScrollChanged(x, y)) {
+        if (mRemoveClippedSubviews) {
+          updateClippingRect();
+        }
+        ReactScrollViewHelper.updateStateOnScrollChanged(
+            this,
+            mOnScrollDispatchHelper.getXFlingVelocity(),
+            mOnScrollDispatchHelper.getYFlingVelocity());
       }
-      mPreventReentry = true;
-      ReactScrollViewHelper.updateStateOnScrollChanged(
-          this,
-          mOnScrollDispatchHelper.getXFlingVelocity(),
-          mOnScrollDispatchHelper.getYFlingVelocity(),
-          mEnableSyncOnScroll);
-      mPreventReentry = false;
+    } finally {
+      Systrace.endSection(Systrace.TRACE_TAG_REACT_JAVA_BRIDGE);
     }
   }
 
@@ -551,12 +530,18 @@ public class ReactScrollView extends ScrollView
       return;
     }
 
-    Assertions.assertNotNull(mClippingRect);
+    Systrace.beginSection(
+        Systrace.TRACE_TAG_REACT_JAVA_BRIDGE, "ReactScrollView.updateClippingRect");
+    try {
+      Assertions.assertNotNull(mClippingRect);
 
-    ReactClippingViewGroupHelper.calculateClippingRect(this, mClippingRect);
-    View contentView = getContentView();
-    if (contentView instanceof ReactClippingViewGroup) {
-      ((ReactClippingViewGroup) contentView).updateClippingRect();
+      ReactClippingViewGroupHelper.calculateClippingRect(this, mClippingRect);
+      View contentView = getContentView();
+      if (contentView instanceof ReactClippingViewGroup) {
+        ((ReactClippingViewGroup) contentView).updateClippingRect();
+      }
+    } finally {
+      Systrace.endSection(Systrace.TRACE_TAG_REACT_JAVA_BRIDGE);
     }
   }
 
@@ -680,12 +665,8 @@ public class ReactScrollView extends ScrollView
 
   @Override
   public void onDraw(Canvas canvas) {
-    if (ReactNativeFeatureFlags.enableBackgroundStyleApplicator()) {
-      if (mOverflow != Overflow.VISIBLE) {
-        BackgroundStyleApplicator.clipToPaddingBox(this, canvas);
-      }
-    } else {
-      mReactBackgroundManager.maybeClipToPaddingBox(canvas);
+    if (mOverflow != Overflow.VISIBLE) {
+      BackgroundStyleApplicator.clipToPaddingBox(this, canvas);
     }
     super.onDraw(canvas);
   }
@@ -1253,32 +1234,22 @@ public class ReactScrollView extends ScrollView
         scrollTo(getScrollX(), maxScrollY);
       }
     }
+
+    ReactScrollViewHelper.emitLayoutChangeEvent(this);
   }
 
   @Override
   public void setBackgroundColor(int color) {
-    if (ReactNativeFeatureFlags.enableBackgroundStyleApplicator()) {
-      BackgroundStyleApplicator.setBackgroundColor(this, color);
-    } else {
-      mReactBackgroundManager.setBackgroundColor(color);
-    }
+    BackgroundStyleApplicator.setBackgroundColor(this, color);
   }
 
   public void setBorderWidth(int position, float width) {
-    if (ReactNativeFeatureFlags.enableBackgroundStyleApplicator()) {
-      BackgroundStyleApplicator.setBorderWidth(
-          this, LogicalEdge.values()[position], PixelUtil.toDIPFromPixel(width));
-    } else {
-      mReactBackgroundManager.setBorderWidth(position, width);
-    }
+    BackgroundStyleApplicator.setBorderWidth(
+        this, LogicalEdge.values()[position], PixelUtil.toDIPFromPixel(width));
   }
 
   public void setBorderColor(int position, @Nullable Integer color) {
-    if (ReactNativeFeatureFlags.enableBackgroundStyleApplicator()) {
-      BackgroundStyleApplicator.setBorderColor(this, LogicalEdge.values()[position], color);
-    } else {
-      mReactBackgroundManager.setBorderColor(position, color);
-    }
+    BackgroundStyleApplicator.setBorderColor(this, LogicalEdge.values()[position], color);
   }
 
   public void setBorderRadius(float borderRadius) {
@@ -1286,26 +1257,18 @@ public class ReactScrollView extends ScrollView
   }
 
   public void setBorderRadius(float borderRadius, int position) {
-    if (ReactNativeFeatureFlags.enableBackgroundStyleApplicator()) {
-      @Nullable
-      LengthPercentage radius =
-          Float.isNaN(borderRadius)
-              ? null
-              : new LengthPercentage(
-                  PixelUtil.toDIPFromPixel(borderRadius), LengthPercentageType.POINT);
-      BackgroundStyleApplicator.setBorderRadius(this, BorderRadiusProp.values()[position], radius);
-    } else {
-      mReactBackgroundManager.setBorderRadius(borderRadius, position);
-    }
+    @Nullable
+    LengthPercentage radius =
+        Float.isNaN(borderRadius)
+            ? null
+            : new LengthPercentage(
+                PixelUtil.toDIPFromPixel(borderRadius), LengthPercentageType.POINT);
+    BackgroundStyleApplicator.setBorderRadius(this, BorderRadiusProp.values()[position], radius);
   }
 
   public void setBorderStyle(@Nullable String style) {
-    if (ReactNativeFeatureFlags.enableBackgroundStyleApplicator()) {
-      BackgroundStyleApplicator.setBorderStyle(
-          this, style == null ? null : BorderStyle.fromString(style));
-    } else {
-      mReactBackgroundManager.setBorderStyle(style);
-    }
+    BackgroundStyleApplicator.setBorderStyle(
+        this, style == null ? null : BorderStyle.fromString(style));
   }
 
   /**

package/ReactAndroid/src/main/java/com/facebook/react/views/scroll/ReactScrollViewCommandHelper.kt

@@ -0,0 +1,101 @@
+/*
+ * 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.views.scroll
+
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.uimanager.PixelUtil
+
+public class ReactScrollViewCommandHelper {
+
+  public companion object {
+    public const val COMMAND_SCROLL_TO: Int = 1
+    public const val COMMAND_SCROLL_TO_END: Int = 2
+    public const val COMMAND_FLASH_SCROLL_INDICATORS: Int = 3
+
+    @JvmStatic
+    public fun getCommandsMap(): Map<String, Int> =
+        hashMapOf(
+            "scrollTo" to COMMAND_SCROLL_TO,
+            "scrollToEnd" to COMMAND_SCROLL_TO_END,
+            "flashScrollIndicators" to COMMAND_FLASH_SCROLL_INDICATORS)
+
+    @JvmStatic
+    public fun <T> receiveCommand(
+        viewManager: ScrollCommandHandler<T>,
+        scrollView: T,
+        commandType: Int,
+        args: ReadableArray?
+    ) {
+      checkNotNull(viewManager)
+      checkNotNull(scrollView)
+      when (commandType) {
+        COMMAND_SCROLL_TO -> scrollTo(viewManager, scrollView, checkNotNull(args))
+        COMMAND_SCROLL_TO_END -> scrollToEnd(viewManager, scrollView, checkNotNull(args))
+        COMMAND_FLASH_SCROLL_INDICATORS -> viewManager.flashScrollIndicators(scrollView)
+        else ->
+            throw IllegalArgumentException(
+                "Unsupported command $commandType received by ${viewManager::class.java.simpleName}.")
+      }
+    }
+
+    @JvmStatic
+    public fun <T> receiveCommand(
+        viewManager: ScrollCommandHandler<T>,
+        scrollView: T,
+        commandType: String,
+        args: ReadableArray?
+    ) {
+      checkNotNull(viewManager)
+      checkNotNull(scrollView)
+      when (commandType) {
+        "scrollTo" -> scrollTo(viewManager, scrollView, checkNotNull(args))
+        "scrollToEnd" -> scrollToEnd(viewManager, scrollView, checkNotNull(args))
+        "flashScrollIndicators" -> viewManager.flashScrollIndicators(scrollView)
+        else ->
+            throw IllegalArgumentException(
+                "Unsupported command $commandType received by ${viewManager::class.java.simpleName}.")
+      }
+    }
+
+    private fun <T> scrollTo(
+        viewManager: ScrollCommandHandler<T>,
+        scrollView: T,
+        args: ReadableArray
+    ) {
+      val destX = Math.round(PixelUtil.toPixelFromDIP(args.getDouble(0)))
+      val destY = Math.round(PixelUtil.toPixelFromDIP(args.getDouble(1)))
+      val animated = args.getBoolean(2)
+      viewManager.scrollTo(scrollView, ScrollToCommandData(destX, destY, animated))
+    }
+
+    private fun <T> scrollToEnd(
+        viewManager: ScrollCommandHandler<T>,
+        scrollView: T,
+        args: ReadableArray
+    ) {
+      val animated = args.getBoolean(0)
+      viewManager.scrollToEnd(scrollView, ScrollToEndCommandData(animated))
+    }
+  }
+
+  public interface ScrollCommandHandler<T> {
+    public fun scrollTo(scrollView: T, data: ScrollToCommandData)
+
+    public fun scrollToEnd(scrollView: T, data: ScrollToEndCommandData)
+
+    public fun flashScrollIndicators(scrollView: T)
+  }
+
+  public class ScrollToCommandData(
+      @JvmField public val mDestX: Int,
+      @JvmField public val mDestY: Int,
+      @JvmField public val mAnimated: Boolean
+  )
+
+  public class ScrollToEndCommandData(@JvmField public val mAnimated: Boolean)
+}

package/ReactAndroid/src/main/java/com/facebook/react/views/scroll/ReactScrollViewHelper.kt

@@ -19,7 +19,6 @@ import com.facebook.react.bridge.ReactContext
 import com.facebook.react.bridge.WritableMap
 import com.facebook.react.bridge.WritableNativeMap
 import com.facebook.react.common.ReactConstants
-import com.facebook.react.internal.featureflags.ReactNativeFeatureFlags
 import com.facebook.react.uimanager.PixelUtil.toDIPFromPixel
 import com.facebook.react.uimanager.StateWrapper
 import com.facebook.react.uimanager.UIManagerHelper
@@ -30,8 +29,9 @@ import java.util.concurrent.CopyOnWriteArrayList
 
 /** Helper class that deals with emitting Scroll Events. */
 public object ReactScrollViewHelper {
-  private val TAG = ReactHorizontalScrollView::class.java.simpleName
+  private val TAG = ReactScrollView::class.java.simpleName
   private val DEBUG_MODE = false // ReactBuildConfig.DEBUG
+
   private const val CONTENT_OFFSET_LEFT = "contentOffsetLeft"
   private const val CONTENT_OFFSET_TOP = "contentOffsetTop"
   private const val SCROLL_AWAY_PADDING_TOP = "scrollAwayPaddingTop"
@@ -47,6 +47,7 @@ public object ReactScrollViewHelper {
 
   // Support global native listeners for scroll events
   private val scrollListeners = CopyOnWriteArrayList<WeakReference<ScrollListener>>()
+  private val layoutChangeListeners = CopyOnWriteArrayList<WeakReference<LayoutChangeListener>>()
 
   // If all else fails, this is the hardcoded value in OverScroller.java, in AOSP.
   // The default is defined here (as of this diff):
@@ -102,7 +103,6 @@ public object ReactScrollViewHelper {
       scrollEventType: ScrollEventType,
       xVelocity: Float,
       yVelocity: Float,
-      experimental_isSynchronous: Boolean = false,
   ) where T : HasScrollEventThrottle?, T : ViewGroup {
     val now = System.currentTimeMillis()
     // Throttle the scroll event if scrollEventThrottle is set to be equal or more than 17 ms.
@@ -137,8 +137,7 @@ public object ReactScrollViewHelper {
               contentView.width,
               contentView.height,
               scrollView.width,
-              scrollView.height,
-              experimental_isSynchronous))
+              scrollView.height))
       scrollView.lastScrollDispatchTime = now
     }
   }
@@ -151,6 +150,13 @@ public object ReactScrollViewHelper {
     }
   }
 
+  @JvmStatic
+  public fun emitLayoutChangeEvent(scrollView: ViewGroup) {
+    for (listener in layoutChangeListeners) {
+      listener.get()?.onLayoutChange(scrollView)
+    }
+  }
+
   @JvmStatic
   public fun parseOverScrollMode(jsOverScrollMode: String?): Int {
     return if (jsOverScrollMode == null || jsOverScrollMode == AUTO) {
@@ -214,6 +220,16 @@ public object ReactScrollViewHelper {
     scrollListeners.remove(WeakReference(listener))
   }
 
+  @JvmStatic
+  public fun addLayoutChangeListener(listener: LayoutChangeListener) {
+    layoutChangeListeners.add(WeakReference(listener))
+  }
+
+  @JvmStatic
+  public fun removeLayoutChangeListener(listener: LayoutChangeListener) {
+    layoutChangeListeners.remove(WeakReference(listener))
+  }
+
   /**
    * Scroll the given view to the location (x, y), with provided initial velocity. This method works
    * by calculate the "would be" initial velocity with internal friction to move to the point (x,
@@ -246,9 +262,6 @@ public object ReactScrollViewHelper {
     if (scrollY != y) {
       scrollView.startFlingAnimator(scrollY, y)
     }
-    if (ReactNativeFeatureFlags.fixIncorrectScrollViewStateUpdateOnAndroid()) {
-      updateFabricScrollState<T>(scrollView, x, y)
-    }
   }
 
   /** Get current position or position after current animation finishes, if any. */
@@ -318,25 +331,9 @@ public object ReactScrollViewHelper {
     val scrollPos = scrollState.lastStateUpdateScroll
     val scrollX = scrollPos.x
     val scrollY = scrollPos.y
-    val layoutDirection = scrollState.layoutDirection
-    val fabricScrollX =
-        if (layoutDirection == View.LAYOUT_DIRECTION_RTL) {
-          // getScrollX returns offset from left even when layout direction is RTL.
-          // The following line calculates offset from right.
-          val child = scrollView.getChildAt(0)
-          val contentWidth = child?.width ?: 0
-          -(contentWidth - scrollX - scrollView.width)
-        } else {
-          scrollX
-        }
     if (DEBUG_MODE) {
       FLog.i(
-          TAG,
-          "updateFabricScrollState[%d] scrollX %d scrollY %d fabricScrollX %d",
-          scrollView.id,
-          scrollX,
-          scrollY,
-          fabricScrollX)
+          TAG, "updateFabricScrollState[%d] scrollX %d scrollY %d", scrollView.id, scrollX, scrollY)
     }
     val stateWrapper = scrollView.stateWrapper
     if (stateWrapper != null) {
@@ -359,29 +356,13 @@ public object ReactScrollViewHelper {
   T : HasScrollEventThrottle?,
   T : HasScrollState?,
   T : HasStateWrapper?,
-  T : ViewGroup {
-    updateStateOnScrollChanged(scrollView, xVelocity, yVelocity, false)
-  }
-
-  @JvmStatic
-  public fun <T> updateStateOnScrollChanged(
-      scrollView: T,
-      xVelocity: Float,
-      yVelocity: Float,
-      experimental_synchronous: Boolean,
-  ) where
-  T : HasFlingAnimator?,
-  T : HasScrollEventThrottle?,
-  T : HasScrollState?,
-  T : HasStateWrapper?,
   T : ViewGroup {
     // Race an UpdateState with every onScroll. This makes it more likely that, in Fabric,
     // when JS processes the scroll event, the C++ ShadowNode representation will have a
     // "more correct" scroll position. It will frequently be /incorrect/ but this decreases
     // the error as much as possible.
     updateFabricScrollState(scrollView, scrollView.scrollX, scrollView.scrollY)
-    emitScrollEvent(
-        scrollView, ScrollEventType.SCROLL, xVelocity, yVelocity, experimental_synchronous)
+    emitScrollEvent(scrollView, xVelocity, yVelocity)
   }
 
   public fun <T> registerFlingAnimator(scrollView: T) where
@@ -484,6 +465,10 @@ public object ReactScrollViewHelper {
     public fun onLayout(scrollView: ViewGroup?)
   }
 
+  public interface LayoutChangeListener {
+    public fun onLayoutChange(scrollView: ViewGroup)
+  }
+
   public interface HasStateWrapper {
     public val stateWrapper: StateWrapper?
   }
@@ -506,13 +491,7 @@ public object ReactScrollViewHelper {
     }
   }
 
-  public class ReactScrollViewScrollState(
-      /**
-       * Get the layout direction. Can be either scrollView.LAYOUT_DIRECTION_RTL (1) or
-       * scrollView.LAYOUT_DIRECTION_LTR (0). If the value is -1, it means unknown layout.
-       */
-      public val layoutDirection: Int
-  ) {
+  public class ReactScrollViewScrollState() {
 
     /** Get the position after current animation is finished */
     public val finalAnimatedPositionScroll: Point = Point()