react-native-tvos 0.84.1-0 → 0.85.0-0

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

@@ -10,6 +10,7 @@ package com.facebook.react.views.scroll;
 import static com.facebook.react.views.scroll.ReactScrollViewHelper.SNAP_ALIGNMENT_CENTER;
 import static com.facebook.react.views.scroll.ReactScrollViewHelper.SNAP_ALIGNMENT_DISABLED;
 import static com.facebook.react.views.scroll.ReactScrollViewHelper.SNAP_ALIGNMENT_END;
+import static com.facebook.react.views.scroll.ReactScrollViewHelper.SNAP_ALIGNMENT_ITEM;
 import static com.facebook.react.views.scroll.ReactScrollViewHelper.SNAP_ALIGNMENT_START;
 import static com.facebook.react.views.scroll.ReactScrollViewHelper.findNextFocusableView;
 
@@ -38,6 +39,7 @@ import androidx.core.view.ViewCompat.FocusDirection;
 import com.facebook.common.logging.FLog;
 import com.facebook.infer.annotation.Assertions;
 import com.facebook.infer.annotation.Nullsafe;
+import com.facebook.react.views.common.UiModeUtils;
 import com.facebook.react.R;
 import com.facebook.react.common.ReactConstants;
 import com.facebook.react.common.build.ReactBuildConfig;
@@ -136,6 +138,10 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
   private int mFadingEdgeLengthStart = 0;
   private int mFadingEdgeLengthEnd = 0;
   private boolean mEmittedOverScrollSinceScrollBegin = false;
+  private boolean mScrollsChildToFocus = true;
+  private int mSnapToItemPadding;
+  private boolean mScrollAnimationEnabled = true;
+  private boolean mBlockScrollDelta = false;
 
   public ReactHorizontalScrollView(Context context) {
     this(context, null);
@@ -199,6 +205,7 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
     mMaintainVisibleContentPositionHelper = null;
     mFadingEdgeLengthStart = 0;
     mFadingEdgeLengthEnd = 0;
+    mScrollsChildToFocus = true;
   }
 
   /* package */ void recycleView() {
@@ -247,9 +254,21 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
     return mScrollEnabled && super.canScrollHorizontally(direction);
   }
 
+  @Override
+  public void computeScroll() {
+    if (UiModeUtils.isTVDevice(getContext())
+        && !mScrollAnimationEnabled
+        && mScroller != null
+        && !mScroller.isFinished()) {
+      mScroller.forceFinished(true);
+      return;
+    }
+    super.computeScroll();
+  }
+
   @Override
   protected int computeScrollDeltaToGetChildRectOnScreen(Rect rect) {
-    if (!mScrollEnabled) {
+    if (!mScrollEnabled || mBlockScrollDelta) {
       return 0;
     }
     return super.computeScrollDeltaToGetChildRectOnScreen(rect);
@@ -332,6 +351,10 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
     mPagingEnabled = pagingEnabled;
   }
 
+  public void setScrollsChildToFocus(boolean scrollsChildToFocus) {
+    mScrollsChildToFocus = scrollsChildToFocus;
+  }
+
   public void setDecelerationRate(float decelerationRate) {
     getReactScrollViewScrollState().setDecelerationRate(decelerationRate);
 
@@ -388,6 +411,14 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
     invalidate();
   }
 
+  public void setSnapToItemPadding(int snapToItemPadding) {
+    mSnapToItemPadding = snapToItemPadding;
+  }
+
+  public void setScrollAnimationEnabled(boolean scrollAnimationEnabled) {
+    mScrollAnimationEnabled = scrollAnimationEnabled;
+  }
+
   @Override
   protected float getLeftFadingEdgeStrength() {
     float max = Math.max(mFadingEdgeLengthStart, mFadingEdgeLengthEnd);
@@ -462,6 +493,14 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
     return mOverflowInset;
   }
 
+  @Override
+  public boolean getClipToPadding() {
+    if (ReactNativeFeatureFlags.syncAndroidClipToPaddingWithOverflow()) {
+      return mOverflow != Overflow.VISIBLE;
+    }
+    return super.getClipToPadding();
+  }
+
   @Override
   public void onDraw(Canvas canvas) {
     if (mOverflow != Overflow.VISIBLE) {
@@ -544,6 +583,40 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
     }
   }
 
+  /**
+   * Attempts to scroll-snap to the focused child based on snapToAlignment/scrollSnapAlign.
+   * Returns true if snap scrolling was performed, false otherwise.
+   */
+  private boolean tryScrollSnapToChild(View focused) {
+    if (mSnapToAlignment != SNAP_ALIGNMENT_ITEM) {
+      return false;
+    }
+
+    kotlin.Pair<View, String> result = ReactScrollViewHelper.findScrollSnapAlign(focused, this);
+    if (result == null) {
+      return false;
+    }
+
+    View snapTarget = result.getFirst();
+    String alignment = result.getSecond();
+
+    Rect rect = new Rect();
+    snapTarget.getDrawingRect(rect);
+    offsetDescendantRectToMyCoords(snapTarget, rect);
+
+    int viewportWidth = getWidth() - getPaddingLeft() - getPaddingRight();
+    int maxScrollX = Math.max(0, computeHorizontalScrollRange() - getWidth());
+
+    Integer targetOffset = ReactScrollViewHelper.computeScrollSnapOffset(
+        rect.left, rect.right, viewportWidth, alignment, mSnapInterval, mSnapToItemPadding, maxScrollX);
+    if (targetOffset == null) {
+      return false;
+    }
+
+    reactSmoothScrollTo(targetOffset, getScrollY());
+    return true;
+  }
+
   /**
    * Since ReactHorizontalScrollView handles layout changes on JS side, it does not call
    * super.onlayout due to which mIsLayoutDirty flag in HorizontalScrollView remains true and
@@ -553,8 +626,12 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
    */
   @Override
   public void requestChildFocus(View child, View focused) {
-    if (focused != null && !mPagingEnabled) {
-      scrollToChild(focused);
+    if (focused != null && mScrollsChildToFocus) {
+      if (!tryScrollSnapToChild(focused)) {
+        if (!mPagingEnabled) {
+          scrollToChild(focused);
+        }
+      }
     }
     requestChildFocusWithoutScroll(child, focused);
   }
@@ -565,7 +642,19 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
    * unblocks such customization.
    */
   protected void requestChildFocusWithoutScroll(View child, View focused) {
+    // Temporarily block HorizontalScrollView's internal scrollToChild from running
+    // during super.requestChildFocus — we've already handled scrolling in requestChildFocus.
+    mBlockScrollDelta = true;
     super.requestChildFocus(child, focused);
+    mBlockScrollDelta = false;
+  }
+
+  @Override
+  public boolean requestChildRectangleOnScreen(View child, Rect rectangle, boolean immediate) {
+    if (!mScrollsChildToFocus) {
+      return false;
+    }
+    return super.requestChildRectangleOnScreen(child, rectangle, immediate);
   }
 
   @Override
@@ -773,21 +862,42 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
   public boolean arrowScroll(int direction) {
     boolean handled = false;
 
-    if (mPagingEnabled) {
+    if (!mScrollAnimationEnabled) {
+      // When scroll animation is disabled, find the next focusable and request focus directly.
+      // This must come before the mPagingEnabled check because snapToInterval on Android
+      // auto-enables paging, and the paging branch uses smoothScrollToNextPage which
+      // scrolls by full page width instead of by snap interval.
+      // requestChildFocus → tryScrollSnapToChild/scrollToChild handles instant scrolling.
+      View currentFocused = findFocus();
+      View nextFocused = FocusFinder.getInstance().findNextFocus(this, currentFocused, direction);
+      if (nextFocused != null && nextFocused != currentFocused && nextFocused != this) {
+        nextFocused.requestFocus(direction);
+        handled = true;
+      }
+    } else if (mPagingEnabled) {
       mPagedArrowScrolling = true;
 
       if (getChildCount() > 0) {
         View currentFocused = findFocus();
         View nextFocused = FocusFinder.getInstance().findNextFocus(this, currentFocused, direction);
         View rootChild = getContentView();
-        if (isDescendantOf(rootChild, nextFocused)) {
-          if (!isScrolledInView(nextFocused) && !isMostlyScrolledInView(nextFocused)) {
-            smoothScrollToNextPage(direction);
+        if (rootChild != null && nextFocused != null && isDescendantOf(rootChild, nextFocused)) {
+          if (mSnapToAlignment == SNAP_ALIGNMENT_ITEM) {
+            // When snapToAlignment is "item", don't use smoothScrollToNextPage (which scrolls
+            // by full page width and ignores snapToItemPadding). Instead just request focus —
+            // requestChildFocus → tryScrollSnapToChild handles scrolling with correct padding.
+            nextFocused.requestFocus();
+          } else {
+            if (!isScrolledInView(nextFocused) && !isMostlyScrolledInView(nextFocused)) {
+              smoothScrollToNextPage(direction);
+            }
+            nextFocused.requestFocus();
           }
-          nextFocused.requestFocus();
           handled = true;
         } else {
-          smoothScrollToNextPage(direction);
+          if (mSnapToAlignment != SNAP_ALIGNMENT_ITEM) {
+            smoothScrollToNextPage(direction);
+          }
           handled = true;
         }
       }
@@ -837,6 +947,11 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
 
   @Override
   public boolean dispatchGenericMotionEvent(MotionEvent ev) {
+    // Ignore generic motion events (joystick, mouse wheel, trackpad) if scrolling is disabled
+    if (!mScrollEnabled) {
+      return false;
+    }
+
     // We do not dispatch the motion event if its children are not supposed to receive it
     if (!PointerEvents.canChildrenBeTouchTarget(mPointerEvents)) {
       return false;
@@ -853,7 +968,7 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
             && (mPagingEnabled
                 || mSnapInterval != 0
                 || mSnapOffsets != null
-                || mSnapToAlignment != SNAP_ALIGNMENT_DISABLED)) {
+                || (mSnapToAlignment != SNAP_ALIGNMENT_DISABLED && mSnapToAlignment != SNAP_ALIGNMENT_ITEM))) {
           // Cancel any pending runnable and reschedule
           if (mPostTouchRunnable != null) {
             removeCallbacks(mPostTouchRunnable);
@@ -976,9 +1091,6 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
     if (mMaintainVisibleContentPositionHelper != null) {
       mMaintainVisibleContentPositionHelper.stop();
     }
-    if (mVirtualViewContainerState != null) {
-      mVirtualViewContainerState.cleanup();
-    }
   }
 
   @Override
@@ -1313,7 +1425,7 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
     }
 
     // pagingEnabled only allows snapping one interval at a time
-    if (mSnapInterval == 0 && mSnapOffsets == null && mSnapToAlignment == SNAP_ALIGNMENT_DISABLED) {
+    if (mSnapInterval == 0 && mSnapOffsets == null && (mSnapToAlignment == SNAP_ALIGNMENT_DISABLED || mSnapToAlignment == SNAP_ALIGNMENT_ITEM)) {
       smoothScrollAndSnap(velocityX);
       return;
     }
@@ -1357,7 +1469,7 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
           }
         }
       }
-    } else if (mSnapToAlignment != SNAP_ALIGNMENT_DISABLED) {
+    } else if (mSnapToAlignment != SNAP_ALIGNMENT_DISABLED && mSnapToAlignment != SNAP_ALIGNMENT_ITEM) {
       if (mSnapInterval > 0) {
         double ratio = (double) targetOffset / mSnapInterval;
         smallerOffset =
@@ -1584,7 +1696,11 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
    * scroll view and state. Calling raw `smoothScrollTo` doesn't update state.
    */
   public void reactSmoothScrollTo(int x, int y) {
-    ReactScrollViewHelper.smoothScrollTo(this, x, y);
+    if (mScrollAnimationEnabled || !UiModeUtils.isTVDevice(getContext())) {
+      ReactScrollViewHelper.smoothScrollTo(this, x, y);
+    } else {
+      scrollTo(x, y);
+    }
     setPendingContentOffsets(x, y);
   }
 

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

@@ -120,6 +120,11 @@ constructor(private val fpsListener: FpsListener? = null) :
     view.setDisableIntervalMomentum(disableIntervalMomentum)
   }
 
+  @ReactProp(name = "scrollsChildToFocus", defaultBoolean = true)
+  public fun setScrollsChildToFocus(view: ReactHorizontalScrollView, scrollsChildToFocus: Boolean) {
+    view.setScrollsChildToFocus(scrollsChildToFocus)
+  }
+
   @ReactProp(name = "snapToInterval")
   public fun setSnapToInterval(view: ReactHorizontalScrollView, snapToInterval: Float) {
     // snapToInterval needs to be exposed as a float because of the Javascript interface.
@@ -157,6 +162,18 @@ constructor(private val fpsListener: FpsListener? = null) :
     view.setSnapToEnd(snapToEnd)
   }
 
+  @ReactProp(name = "snapToItemPadding")
+  public fun setSnapToItemPadding(view: ReactHorizontalScrollView, value: Float) {
+    val density = getDisplayMetricDensity()
+    val px = (value * density).toInt()
+    view.setSnapToItemPadding(px)
+  }
+
+  @ReactProp(name = "scrollAnimationEnabled", defaultBoolean = true)
+  public fun setScrollAnimationEnabled(view: ReactHorizontalScrollView, value: Boolean) {
+    view.setScrollAnimationEnabled(value)
+  }
+
   @ReactProp(name = ReactClippingViewGroupHelper.PROP_REMOVE_CLIPPED_SUBVIEWS)
   public fun setRemoveClippedSubviews(
       view: ReactHorizontalScrollView,