react-native-tvos 0.74.5-0 → 0.75.2-0

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

@@ -34,6 +34,7 @@ import java.lang.ref.WeakReference;
 @Nullsafe(Nullsafe.Mode.LOCAL)
 class MaintainVisibleScrollPositionHelper<ScrollViewT extends ViewGroup & HasSmoothScroll>
     implements UIManagerListener {
+
   private final ScrollViewT mScrollView;
   private final boolean mHorizontal;
   private @Nullable Config mConfig;
@@ -42,6 +43,7 @@ class MaintainVisibleScrollPositionHelper<ScrollViewT extends ViewGroup & HasSmo
   private boolean mListening = false;
 
   public static class Config {
+
     public final int minIndexForVisible;
     public final @Nullable Integer autoScrollToTopThreshold;
 
@@ -116,7 +118,7 @@ class MaintainVisibleScrollPositionHelper<ScrollViewT extends ViewGroup & HasSmo
       int deltaX = newFrame.left - mPrevFirstVisibleFrame.left;
       if (deltaX != 0) {
         int scrollX = mScrollView.getScrollX();
-        mScrollView.scrollTo(scrollX + deltaX, mScrollView.getScrollY());
+        mScrollView.scrollToPreservingMomentum(scrollX + deltaX, mScrollView.getScrollY());
         mPrevFirstVisibleFrame = newFrame;
         if (mConfig.autoScrollToTopThreshold != null
             && scrollX <= mConfig.autoScrollToTopThreshold) {
@@ -127,7 +129,7 @@ class MaintainVisibleScrollPositionHelper<ScrollViewT extends ViewGroup & HasSmo
       int deltaY = newFrame.top - mPrevFirstVisibleFrame.top;
       if (deltaY != 0) {
         int scrollY = mScrollView.getScrollY();
-        mScrollView.scrollTo(mScrollView.getScrollX(), scrollY + deltaY);
+        mScrollView.scrollToPreservingMomentum(mScrollView.getScrollX(), scrollY + deltaY);
         mPrevFirstVisibleFrame = newFrame;
         if (mConfig.autoScrollToTopThreshold != null
             && scrollY <= mConfig.autoScrollToTopThreshold) {
@@ -160,7 +162,12 @@ class MaintainVisibleScrollPositionHelper<ScrollViewT extends ViewGroup & HasSmo
     int currentScroll = mHorizontal ? mScrollView.getScrollX() : mScrollView.getScrollY();
     for (int i = mConfig.minIndexForVisible; i < contentView.getChildCount(); i++) {
       View child = contentView.getChildAt(i);
-      float position = mHorizontal ? child.getX() : child.getY();
+
+      // Compute the position of the end of the child
+      float position =
+          mHorizontal ? child.getX() + child.getWidth() : child.getY() + child.getHeight();
+
+      // If the child is partially visible or this is the last child, select it as the anchor.
       if (position > currentScroll || i == contentView.getChildCount() - 1) {
         mFirstVisibleView = new WeakReference<>(child);
         Rect frame = new Rect();

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

@@ -11,6 +11,7 @@ import android.content.Context;
 import android.widget.HorizontalScrollView;
 import androidx.core.view.ViewCompat;
 import com.facebook.infer.annotation.Nullsafe;
+import com.facebook.react.internal.featureflags.ReactNativeFeatureFlags;
 import com.facebook.react.modules.i18nmanager.I18nUtil;
 import com.facebook.react.views.view.ReactViewGroup;
 
@@ -34,6 +35,14 @@ public class ReactHorizontalScrollContainerView extends ReactViewGroup {
             : ViewCompat.LAYOUT_DIRECTION_LTR;
   }
 
+  @Override
+  public int getLayoutDirection() {
+    if (ReactNativeFeatureFlags.setAndroidLayoutDirection()) {
+      return super.getLayoutDirection();
+    }
+    return mLayoutDirection;
+  }
+
   @Override
   public void setRemoveClippedSubviews(boolean removeClippedSubviews) {
     // Clipping doesn't work well for horizontal scroll views in RTL mode - in both
@@ -41,7 +50,7 @@ public class ReactHorizontalScrollContainerView extends ReactViewGroup {
     // is TextInputs being blurred immediately after being focused. So, for now,
     // it's easier to just disable this for these specific RTL views.
     // TODO T86027499: support `setRemoveClippedSubviews` in RTL mode
-    if (mLayoutDirection == LAYOUT_DIRECTION_RTL) {
+    if (getLayoutDirection() == LAYOUT_DIRECTION_RTL) {
       super.setRemoveClippedSubviews(false);
       return;
     }
@@ -51,31 +60,16 @@ public class ReactHorizontalScrollContainerView extends ReactViewGroup {
 
   @Override
   protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
-    // This is to fix the overflowing (scaled) item being cropped
-    final HorizontalScrollView parent = (HorizontalScrollView) getParent();
-    parent.setClipChildren(false);
-    this.setClipChildren(false);
-
-    if (mLayoutDirection == LAYOUT_DIRECTION_RTL) {
+    if (getLayoutDirection() == LAYOUT_DIRECTION_RTL) {
       // When the layout direction is RTL, we expect Yoga to give us a layout
       // that extends off the screen to the left so we re-center it with left=0
       int newLeft = 0;
       int width = right - left;
       int newRight = newLeft + width;
-      setLeftTopRightBottom(newLeft, top, newRight, bottom);
-
-      // Fix the ScrollX position when using RTL language accounting for the case when new
-      // data is appended to the "end" (left) of the view (e.g. after fetching additional items)
-      final int offsetX = this.getMeasuredWidth() - mLastWidth + parent.getScrollX();
-
-      // Call with the present values in order to re-layout if necessary
-      parent.scrollTo(offsetX, parent.getScrollY());
-      mLastWidth = this.getMeasuredWidth();
-
-      // Use the listener to adjust the scrollposition if new data was appended
-      if (rtlListener != null) {
-        rtlListener.onLayout();
-      }
+      setLeft(newLeft);
+      setTop(top);
+      setRight(newRight);
+      setBottom(bottom);
     }
   }
   public int getLastWidth() {

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

@@ -0,0 +1,28 @@
+/*
+ * 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.module.annotations.ReactModule
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.views.view.ReactClippingViewManager
+
+/** View manager for {@link ReactHorizontalScrollContainerView} components. */
+@ReactModule(name = ReactHorizontalScrollContainerViewManager.REACT_CLASS)
+public class ReactHorizontalScrollContainerViewManager :
+    ReactClippingViewManager<ReactHorizontalScrollContainerView>() {
+
+  override public fun getName(): String = REACT_CLASS
+
+  override public fun createViewInstance(
+      context: ThemedReactContext
+  ): ReactHorizontalScrollContainerView = ReactHorizontalScrollContainerView(context)
+
+  public companion object {
+    public const val REACT_CLASS: String = "AndroidHorizontalScrollContentView"
+  }
+}

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

@@ -32,8 +32,10 @@ import androidx.annotation.Nullable;
 import androidx.core.view.ViewCompat;
 import com.facebook.common.logging.FLog;
 import com.facebook.infer.annotation.Assertions;
+import com.facebook.infer.annotation.Nullsafe;
 import com.facebook.react.common.ReactConstants;
 import com.facebook.react.common.build.ReactBuildConfig;
+import com.facebook.react.internal.featureflags.ReactNativeFeatureFlags;
 import com.facebook.react.modules.i18nmanager.I18nUtil;
 import com.facebook.react.uimanager.MeasureSpecAssertions;
 import com.facebook.react.uimanager.PointerEvents;
@@ -55,6 +57,7 @@ import java.util.ArrayList;
 import java.util.List;
 
 /** Similar to {@link ReactScrollView} but only supports horizontal scrolling. */
+@Nullsafe(Nullsafe.Mode.LOCAL)
 public class ReactHorizontalScrollView extends HorizontalScrollView
     implements ReactClippingViewGroup,
         ViewGroup.OnHierarchyChangeListener,
@@ -81,7 +84,6 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
   private final OnScrollDispatchHelper mOnScrollDispatchHelper = new OnScrollDispatchHelper();
   private final @Nullable OverScroller mScroller;
   private final VelocityHelper mVelocityHelper = new VelocityHelper();
-  private final Rect mRect = new Rect();
   private final Rect mOverflowInset = new Rect();
 
   private boolean mActivelyScrolling;
@@ -92,6 +94,8 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
   private @Nullable Runnable mPostTouchRunnable;
   private boolean mRemoveClippedSubviews;
   private boolean mScrollEnabled = true;
+  private boolean mPreventReentry = false;
+  private boolean mEnableSyncOnScroll = false;
   private boolean mSendMomentumEvents;
   private @Nullable FpsListener mFpsListener = null;
   private @Nullable String mScrollPerfTag;
@@ -107,7 +111,7 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
   private boolean mPagedArrowScrolling = false;
   private int pendingContentOffsetX = UNSET_CONTENT_OFFSET;
   private int pendingContentOffsetY = UNSET_CONTENT_OFFSET;
-  private StateWrapper mStateWrapper = null;
+  private @Nullable StateWrapper mStateWrapper = null;
   private final ReactScrollViewScrollState mReactScrollViewScrollState;
   private final ValueAnimator DEFAULT_FLING_ANIMATOR = ObjectAnimator.ofInt(this, "scrollX", 0, 0);
   private PointerEvents mPointerEvents = PointerEvents.AUTO;
@@ -139,6 +143,8 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
                 : ViewCompat.LAYOUT_DIRECTION_LTR);
 
     setOnHierarchyChangeListener(this);
+    setClipChildren(false);
+    mReactBackgroundManager.setOverflow(ViewProps.SCROLL);
   }
 
   public boolean getScrollEnabled() {
@@ -175,8 +181,8 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
         } else {
           FLog.w(
               TAG,
-              "Failed to cast mScroller field in HorizontalScrollView (probably due to OEM changes to AOSP)! "
-                  + "This app will exhibit the bounce-back scrolling bug :(");
+              "Failed to cast mScroller field in HorizontalScrollView (probably due to OEM changes"
+                  + " to AOSP)! This app will exhibit the bounce-back scrolling bug :(");
           scroller = null;
         }
       } catch (IllegalAccessException e) {
@@ -219,6 +225,10 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
     mScrollEnabled = scrollEnabled;
   }
 
+  public void setEnableSyncOnScroll(boolean enableSyncOnScroll) {
+    mEnableSyncOnScroll = enableSyncOnScroll;
+  }
+
   public void setPagingEnabled(boolean pagingEnabled) {
     mPagingEnabled = pagingEnabled;
   }
@@ -241,7 +251,7 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
     mSnapInterval = snapInterval;
   }
 
-  public void setSnapOffsets(List<Integer> snapOffsets) {
+  public void setSnapOffsets(@Nullable List<Integer> snapOffsets) {
     mSnapOffsets = snapOffsets;
   }
 
@@ -261,9 +271,9 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
     awakenScrollBars();
   }
 
-  public void setOverflow(String overflow) {
+  public void setOverflow(@Nullable String overflow) {
     mOverflow = overflow;
-    invalidate();
+    mReactBackgroundManager.setOverflow(overflow == null ? ViewProps.SCROLL : overflow);
   }
 
   public void setMaintainVisibleContentPosition(
@@ -296,21 +306,8 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
   }
 
   @Override
-  protected void onDraw(Canvas canvas) {
-    if (DEBUG_MODE) {
-      FLog.i(TAG, "onDraw[%d]", getId());
-    }
-
-    getDrawingRect(mRect);
-
-    switch (mOverflow) {
-      case ViewProps.VISIBLE:
-        break;
-      default:
-        canvas.clipRect(mRect);
-        break;
-    }
-
+  public void onDraw(Canvas canvas) {
+    mReactBackgroundManager.maybeClipToPaddingBox(canvas);
     super.onDraw(canvas);
   }
 
@@ -477,11 +474,16 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
       if (mRemoveClippedSubviews) {
         updateClippingRect();
       }
-
+      if (mPreventReentry) {
+        return;
+      }
+      mPreventReentry = true;
       ReactScrollViewHelper.updateStateOnScrollChanged(
           this,
           mOnScrollDispatchHelper.getXFlingVelocity(),
-          mOnScrollDispatchHelper.getYFlingVelocity());
+          mOnScrollDispatchHelper.getYFlingVelocity(),
+          mEnableSyncOnScroll);
+      mPreventReentry = false;
     }
   }
 
@@ -648,13 +650,13 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
   }
 
   @Override
-  public boolean dispatchGenericPointerEvent(MotionEvent ev) {
-    // We do not dispatch the pointer event if its children are not supposed to receive it
+  public boolean dispatchGenericMotionEvent(MotionEvent ev) {
+    // We do not dispatch the motion event if its children are not supposed to receive it
     if (!PointerEvents.canChildrenBeTouchTarget(mPointerEvents)) {
       return false;
     }
 
-    return super.dispatchGenericPointerEvent(ev);
+    return super.dispatchGenericMotionEvent(ev);
   }
 
   @Override
@@ -835,8 +837,10 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
   }
 
   @Override
-  public void onChildViewRemoved(View parent, View child) {
-    mContentView.removeOnLayoutChangeListener(this);
+  public @Nullable void onChildViewRemoved(View parent, View child) {
+    if (mContentView != null) {
+      mContentView.removeOnLayoutChangeListener(this);
+    }
     mContentView = null;
   }
 
@@ -1060,7 +1064,10 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
     int firstOffset = 0;
     int lastOffset = maximumOffset;
     int width = getWidth() - ViewCompat.getPaddingStart(this) - ViewCompat.getPaddingEnd(this);
-    int layoutDirection = getReactScrollViewScrollState().getLayoutDirection();
+    int layoutDirection =
+        ReactNativeFeatureFlags.setAndroidLayoutDirection()
+            ? getLayoutDirection()
+            : mReactScrollViewScrollState.getLayoutDirection();
 
     // offsets are from the right edge in RTL layouts
     if (layoutDirection == LAYOUT_DIRECTION_RTL) {
@@ -1331,6 +1338,13 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
     setPendingContentOffsets(x, y);
   }
 
+  /** Scrolls to a new position preserving any momentum scrolling animation. */
+  @Override
+  public void scrollToPreservingMomentum(int x, int y) {
+    scrollTo(x, y);
+    recreateFlingAnimation(x, Integer.MAX_VALUE);
+  }
+
   private boolean isContentReady() {
     View child = getContentView();
     return child != null && child.getWidth() != 0 && child.getHeight() != 0;
@@ -1377,31 +1391,32 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
     // does not shift layout. If `maintainVisibleContentPosition` is enabled, we try to adjust
     // position so that the viewport keeps the same insets to previously visible views. TODO: MVCP
     // does not work in RTL.
-    if (mReactScrollViewScrollState.getLayoutDirection() == LAYOUT_DIRECTION_RTL) {
+    int layoutDirection =
+        ReactNativeFeatureFlags.setAndroidLayoutDirection()
+            ? v.getLayoutDirection()
+            : mReactScrollViewScrollState.getLayoutDirection();
+    if (layoutDirection == LAYOUT_DIRECTION_RTL) {
       adjustPositionForContentChangeRTL(left, right, oldLeft, oldRight);
     } else if (mMaintainVisibleContentPositionHelper != null) {
       mMaintainVisibleContentPositionHelper.updateScrollPosition();
     }
   }
 
-  private void adjustPositionForContentChangeRTL(int left, int right, int oldLeft, int oldRight) {
-    // If we have any pending custon flings (e.g. from aninmated `scrollTo`, or flinging to a snap
-    // point), finish them, commiting the final `scrollX`.
+  /**
+   * If we are in the middle of a fling animation from the user removing their finger (OverScroller
+   * is in `FLING_MODE`), recreate the existing fling animation since it was calculated against
+   * outdated scroll offsets.
+   */
+  private void recreateFlingAnimation(int scrollX, int maxX) {
+    // If we have any pending custom flings (e.g. from animated `scrollTo`, or flinging to a snap
+    // point), cancel them.
     // TODO: Can we be more graceful (like OverScroller flings)?
     if (getFlingAnimator().isRunning()) {
-      getFlingAnimator().end();
+      getFlingAnimator().cancel();
     }
 
-    int distanceToRightEdge = oldRight - getScrollX();
-    int newWidth = right - left;
-    int scrollX = newWidth - distanceToRightEdge;
-    scrollTo(scrollX, getScrollY());
-
-    // If we are in the middle of a fling animation from the user removing their finger
-    // (OverScroller is in `FLING_MODE`), we must cancel and recreate the existing fling animation
-    // since it was calculated against outdated scroll offsets.
     if (mScroller != null && !mScroller.isFinished()) {
-      // Calculate the veliocity and position of the fling animation at the time of this layout
+      // Calculate the velocity and position of the fling animation at the time of this layout
       // event, which may be later than the last ScrollView tick. These values are not commited to
       // the underlying ScrollView, which will recalculate positions on its next tick.
       int scrollerXBeforeTick = mScroller.getCurrX();
@@ -1420,14 +1435,29 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
         float direction = Math.signum(mScroller.getFinalX() - mScroller.getStartX());
         float flingVelocityX = mScroller.getCurrVelocity() * direction;
 
-        mScroller.fling(
-            scrollX, getScrollY(), (int) flingVelocityX, 0, 0, newWidth - getWidth(), 0, 0);
+        mScroller.fling(scrollX, getScrollY(), (int) flingVelocityX, 0, 0, maxX, 0, 0);
       } else {
         scrollTo(scrollX + (mScroller.getCurrX() - scrollerXBeforeTick), getScrollY());
       }
     }
   }
 
+  private void adjustPositionForContentChangeRTL(int left, int right, int oldLeft, int oldRight) {
+    // If we have any pending custom flings (e.g. from animated `scrollTo`, or flinging to a snap
+    // point), finish them, committing the final `scrollX`.
+    // TODO: Can we be more graceful (like OverScroller flings)?
+    if (getFlingAnimator().isRunning()) {
+      getFlingAnimator().end();
+    }
+
+    int distanceToRightEdge = oldRight - getScrollX();
+    int newWidth = right - left;
+    int scrollX = newWidth - distanceToRightEdge;
+    scrollTo(scrollX, getScrollY());
+
+    recreateFlingAnimation(scrollX, newWidth - getWidth());
+  }
+
   @Nullable
   public StateWrapper getStateWrapper() {
     return mStateWrapper;

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

@@ -11,6 +11,7 @@ import android.graphics.Color;
 import android.view.View;
 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;
@@ -37,6 +38,7 @@ import java.util.List;
  * <p>Note that {@link ReactScrollView} and {@link ReactHorizontalScrollView} are exposed to JS as a
  * single ScrollView component, configured via the {@code horizontal} boolean property.
  */
+@Nullsafe(Nullsafe.Mode.LOCAL)
 @ReactModule(name = ReactHorizontalScrollViewManager.REACT_CLASS)
 public class ReactHorizontalScrollViewManager extends ViewGroupManager<ReactHorizontalScrollView>
     implements ReactScrollViewCommandHelper.ScrollCommandHandler<ReactHorizontalScrollView> {
@@ -68,7 +70,7 @@ public class ReactHorizontalScrollViewManager extends ViewGroupManager<ReactHori
   }
 
   @Override
-  public Object updateState(
+  public @Nullable Object updateState(
       ReactHorizontalScrollView view, ReactStylesDiffMap props, StateWrapper stateWrapper) {
     view.setStateWrapper(stateWrapper);
     return null;
@@ -93,6 +95,11 @@ 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) {
@@ -380,4 +387,9 @@ public class ReactHorizontalScrollViewManager extends ViewGroupManager<ReactHori
   public void setScrollEventThrottle(ReactHorizontalScrollView view, int scrollEventThrottle) {
     view.setScrollEventThrottle(scrollEventThrottle);
   }
+
+  @ReactProp(name = "horizontal")
+  public void setHorizontal(ReactHorizontalScrollView view, boolean horizontal) {
+    // Do Nothing: Align with static ViewConfigs
+  }
 }

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

@@ -33,6 +33,7 @@ import androidx.annotation.Nullable;
 import androidx.core.view.ViewCompat;
 import com.facebook.common.logging.FLog;
 import com.facebook.infer.annotation.Assertions;
+import com.facebook.infer.annotation.Nullsafe;
 import com.facebook.react.R;
 import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.common.ReactConstants;
@@ -62,6 +63,7 @@ import java.util.List;
  * <p>ReactScrollView only supports vertical scrolling. For horizontal scrolling, use {@link
  * ReactHorizontalScrollView}.
  */
+@Nullsafe(Nullsafe.Mode.LOCAL)
 public class ReactScrollView extends ScrollView
     implements ReactClippingViewGroup,
         ViewGroup.OnHierarchyChangeListener,
@@ -81,7 +83,6 @@ public class ReactScrollView extends ScrollView
   private final OnScrollDispatchHelper mOnScrollDispatchHelper = new OnScrollDispatchHelper();
   private final @Nullable OverScroller mScroller;
   private final VelocityHelper mVelocityHelper = new VelocityHelper();
-  private final Rect mRect = new Rect(); // for reuse to avoid allocation
   private final Rect mTempRect = new Rect();
   private final Rect mOverflowInset = new Rect();
 
@@ -93,9 +94,11 @@ 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;
@@ -109,7 +112,7 @@ public class ReactScrollView extends ScrollView
   private @Nullable ReadableMap mCurrentContentOffset = null;
   private int pendingContentOffsetX = UNSET_CONTENT_OFFSET;
   private int pendingContentOffsetY = UNSET_CONTENT_OFFSET;
-  private StateWrapper mStateWrapper = null;
+  private @Nullable StateWrapper mStateWrapper = null;
   private final ReactScrollViewScrollState mReactScrollViewScrollState =
       new ReactScrollViewScrollState(ViewCompat.LAYOUT_DIRECTION_LTR);
   private final ValueAnimator DEFAULT_FLING_ANIMATOR = ObjectAnimator.ofInt(this, "scrollY", 0, 0);
@@ -131,6 +134,8 @@ public class ReactScrollView extends ScrollView
     mScroller = getOverScrollerFromParent();
     setOnHierarchyChangeListener(this);
     setScrollBarStyle(SCROLLBARS_OUTSIDE_OVERLAY);
+    setClipChildren(false);
+    mReactBackgroundManager.setOverflow(ViewProps.SCROLL);
 
     ViewCompat.setAccessibilityDelegate(this, new ReactScrollViewAccessibilityDelegate());
   }
@@ -200,6 +205,10 @@ public class ReactScrollView extends ScrollView
     mScrollPerfTag = scrollPerfTag;
   }
 
+  public void setEnableSyncOnScroll(boolean enableSyncOnScroll) {
+    mEnableSyncOnScroll = enableSyncOnScroll;
+  }
+
   public void setScrollEnabled(boolean scrollEnabled) {
     mScrollEnabled = scrollEnabled;
   }
@@ -230,7 +239,7 @@ public class ReactScrollView extends ScrollView
     mSnapInterval = snapInterval;
   }
 
-  public void setSnapOffsets(List<Integer> snapOffsets) {
+  public void setSnapOffsets(@Nullable List<Integer> snapOffsets) {
     mSnapOffsets = snapOffsets;
   }
 
@@ -250,9 +259,9 @@ public class ReactScrollView extends ScrollView
     awakenScrollBars();
   }
 
-  public void setOverflow(String overflow) {
+  public void setOverflow(@Nullable String overflow) {
     mOverflow = overflow;
-    invalidate();
+    mReactBackgroundManager.setOverflow(overflow == null ? ViewProps.SCROLL : overflow);
   }
 
   public void setMaintainVisibleContentPosition(
@@ -395,11 +404,16 @@ public class ReactScrollView extends ScrollView
       if (mRemoveClippedSubviews) {
         updateClippingRect();
       }
-
+      if (mPreventReentry) {
+        return;
+      }
+      mPreventReentry = true;
       ReactScrollViewHelper.updateStateOnScrollChanged(
           this,
           mOnScrollDispatchHelper.getXFlingVelocity(),
-          mOnScrollDispatchHelper.getYFlingVelocity());
+          mOnScrollDispatchHelper.getYFlingVelocity(),
+          mEnableSyncOnScroll);
+      mPreventReentry = false;
     }
   }
 
@@ -471,13 +485,13 @@ public class ReactScrollView extends ScrollView
   }
 
   @Override
-  public boolean dispatchGenericPointerEvent(MotionEvent ev) {
-    // We do not dispatch the pointer event if its children are not supposed to receive it
+  public boolean dispatchGenericMotionEvent(MotionEvent ev) {
+    // We do not dispatch the motion event if its children are not supposed to receive it
     if (!PointerEvents.canChildrenBeTouchTarget(mPointerEvents)) {
       return false;
     }
 
-    return super.dispatchGenericPointerEvent(ev);
+    return super.dispatchGenericMotionEvent(ev);
   }
 
   @Override
@@ -611,7 +625,7 @@ public class ReactScrollView extends ScrollView
   }
 
   private int getMaxScrollY() {
-    int contentHeight = mContentView.getHeight();
+    int contentHeight = mContentView == null ? 0 : mContentView.getHeight();
     int viewportHeight = getHeight() - getPaddingBottom() - getPaddingTop();
     return Math.max(0, contentHeight - viewportHeight);
   }
@@ -634,15 +648,16 @@ public class ReactScrollView extends ScrollView
         mEndBackground.draw(canvas);
       }
     }
-    getDrawingRect(mRect);
-
-    if (!ViewProps.VISIBLE.equals(mOverflow)) {
-      canvas.clipRect(mRect);
-    }
 
     super.draw(canvas);
   }
 
+  @Override
+  public void onDraw(Canvas canvas) {
+    mReactBackgroundManager.maybeClipToPaddingBox(canvas);
+    super.onDraw(canvas);
+  }
+
   /**
    * This handles any sort of scrolling that may occur after a touch is finished. This may be
    * momentum scrolling (fling) or because you have pagingEnabled on the scroll view. Because we
@@ -1098,6 +1113,53 @@ public class ReactScrollView extends ScrollView
     setPendingContentOffsets(x, y);
   }
 
+  /**
+   * If we are in the middle of a fling animation from the user removing their finger (OverScroller
+   * is in `FLING_MODE`), recreate the existing fling animation since it was calculated against
+   * outdated scroll offsets.
+   */
+  private void recreateFlingAnimation(int scrollY) {
+    // If we have any pending custom flings (e.g. from animated `scrollTo`, or flinging to a snap
+    // point), cancel them.
+    // TODO: Can we be more graceful (like OverScroller flings)?
+    if (getFlingAnimator().isRunning()) {
+      getFlingAnimator().cancel();
+    }
+
+    if (mScroller != null && !mScroller.isFinished()) {
+      // Calculate the velocity and position of the fling animation at the time of this layout
+      // event, which may be later than the last ScrollView tick. These values are not committed to
+      // the underlying ScrollView, which will recalculate positions on its next tick.
+      int scrollerYBeforeTick = mScroller.getCurrY();
+      boolean hasMoreTicks = mScroller.computeScrollOffset();
+
+      // Stop the existing animation at the current state of the scroller. We will then recreate
+      // it starting at the adjusted y offset.
+      mScroller.forceFinished(true);
+
+      if (hasMoreTicks) {
+        // OverScroller.getCurrVelocity() returns an absolute value of the velocity a current fling
+        // animation (only FLING_MODE animations). We derive direction along the Y axis from the
+        // start and end of the, animation assuming ScrollView never fires horizontal fling
+        // animations.
+        // TODO: This does not fully handle overscroll.
+        float direction = Math.signum(mScroller.getFinalY() - mScroller.getStartY());
+        float flingVelocityY = mScroller.getCurrVelocity() * direction;
+
+        mScroller.fling(getScrollX(), scrollY, 0, (int) flingVelocityY, 0, 0, 0, Integer.MAX_VALUE);
+      } else {
+        scrollTo(getScrollX(), scrollY + (mScroller.getCurrX() - scrollerYBeforeTick));
+      }
+    }
+  }
+
+  /** Scrolls to a new position preserving any momentum scrolling animation. */
+  @Override
+  public void scrollToPreservingMomentum(int x, int y) {
+    scrollTo(x, y);
+    recreateFlingAnimation(y);
+  }
+
   private boolean isContentReady() {
     View child = getContentView();
     return child != null && child.getWidth() != 0 && child.getHeight() != 0;
@@ -1196,7 +1258,8 @@ public class ReactScrollView extends ScrollView
 
     Assertions.assertCondition(
         count <= 1,
-        "React Native ScrollView should not have more than one child, it should have exactly 1 child; a content View");
+        "React Native ScrollView should not have more than one child, it should have exactly 1"
+            + " child; a content View");
 
     if (count > 0) {
       for (int i = 0; i < count; i++) {