react-native-tvos 0.86.0-2 → 0.87.0-0

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

@@ -0,0 +1,1729 @@
+/*
+ * 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 android.animation.ObjectAnimator
+import android.animation.ValueAnimator
+import android.content.Context
+import android.graphics.Canvas
+import android.graphics.Color
+import android.graphics.Point
+import android.graphics.Rect
+import android.graphics.drawable.Drawable
+import android.os.Build
+import android.view.FocusFinder
+import android.view.KeyEvent
+import android.view.MotionEvent
+import android.view.View
+import android.view.ViewGroup
+import android.view.ViewParent
+import android.view.accessibility.AccessibilityNodeInfo
+import android.widget.HorizontalScrollView
+import android.widget.OverScroller
+import androidx.core.graphics.drawable.toDrawable
+import androidx.core.view.ViewCompat
+import androidx.core.view.ViewCompat.FocusDirection
+import androidx.core.view.isEmpty
+import androidx.core.view.isNotEmpty
+import com.facebook.common.logging.FLog
+import com.facebook.react.R
+import com.facebook.react.common.ReactConstants
+import com.facebook.react.common.build.ReactBuildConfig
+import com.facebook.react.internal.featureflags.ReactNativeFeatureFlags
+import com.facebook.react.uimanager.BackgroundStyleApplicator
+import com.facebook.react.uimanager.HasChildPressedStateDelay
+import com.facebook.react.uimanager.LengthPercentage
+import com.facebook.react.uimanager.LengthPercentageType
+import com.facebook.react.uimanager.MeasureSpecAssertions
+import com.facebook.react.uimanager.PixelUtil
+import com.facebook.react.uimanager.PointerEvents
+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.events.NativeGestureUtil
+import com.facebook.react.uimanager.style.BorderRadiusProp
+import com.facebook.react.uimanager.style.BorderStyle
+import com.facebook.react.uimanager.style.LogicalEdge
+import com.facebook.react.uimanager.style.Overflow
+import com.facebook.react.views.common.UiModeUtils
+import com.facebook.react.views.scroll.ReactScrollViewHelper.HasFlingAnimator
+import com.facebook.react.views.scroll.ReactScrollViewHelper.HasScrollEventThrottle
+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.scroll.ReactScrollViewHelper.SNAP_ALIGNMENT_CENTER
+import com.facebook.react.views.scroll.ReactScrollViewHelper.SNAP_ALIGNMENT_DISABLED
+import com.facebook.react.views.scroll.ReactScrollViewHelper.SNAP_ALIGNMENT_END
+import com.facebook.react.views.scroll.ReactScrollViewHelper.SNAP_ALIGNMENT_ITEM
+import com.facebook.react.views.scroll.ReactScrollViewHelper.SNAP_ALIGNMENT_START
+import com.facebook.react.views.scroll.ReactScrollViewHelper.findNextFocusableView
+import com.facebook.systrace.Systrace
+import kotlin.math.abs
+import kotlin.math.ceil
+import kotlin.math.floor
+import kotlin.math.max
+import kotlin.math.round
+import kotlin.math.sign
+
+/** Similar to [ReactScrollView] but only supports horizontal scrolling. */
+public open class ReactHorizontalScrollView
+@JvmOverloads
+constructor(context: Context, private val fpsListener: FpsListener? = null) :
+    HorizontalScrollView(context),
+    ReactClippingViewGroup,
+    ViewGroup.OnHierarchyChangeListener,
+    View.OnLayoutChangeListener,
+    ReactAccessibleScrollView,
+    ReactOverflowViewWithInset,
+    HasScrollState,
+    HasStateWrapper,
+    HasFlingAnimator,
+    HasScrollEventThrottle,
+    HasSmoothScroll,
+    VirtualViewContainer,
+    HasChildPressedStateDelay {
+
+  private companion object {
+    private val DEBUG_MODE = false && ReactBuildConfig.DEBUG
+    private val TAG = ReactHorizontalScrollView::class.java.simpleName
+
+    private const val NO_SCROLL_POSITION = Int.MIN_VALUE
+    private const val UNSET_CONTENT_OFFSET = -1
+
+    private var scrollerField: java.lang.reflect.Field? = null
+    private var triedToGetScrollerField = false
+
+    private fun findDeepestScrollViewForMotionEvent(
+        view: View,
+        ev: MotionEvent,
+    ): HorizontalScrollView? = findDeepestScrollViewForMotionEvent(view, ev, true)
+
+    private fun findDeepestScrollViewForMotionEvent(
+        view: View?,
+        ev: MotionEvent,
+        skipInitialView: Boolean,
+    ): HorizontalScrollView? {
+      if (view == null) return null
+
+      val rectOnScreen = Rect()
+      view.getGlobalVisibleRect(rectOnScreen)
+      if (!rectOnScreen.contains(ev.rawX.toInt(), ev.rawY.toInt())) {
+        return null
+      }
+
+      if (
+          !skipInitialView &&
+              view is HorizontalScrollView &&
+              ViewCompat.isNestedScrollingEnabled(view) &&
+              (view is ReactHorizontalScrollView && view.scrollEnabled)
+      ) {
+        return view
+      }
+
+      if (view is ViewGroup) {
+        for (i in 0 until view.childCount) {
+          val foundScrollView = findDeepestScrollViewForMotionEvent(view.getChildAt(i), ev, false)
+          if (foundScrollView != null) {
+            return foundScrollView
+          }
+        }
+      }
+
+      return null
+    }
+  }
+
+  private var scrollXAfterMeasure = NO_SCROLL_POSITION
+
+  private val onScrollDispatchHelper = OnScrollDispatchHelper()
+  private val scroller: OverScroller? = getOverScrollerFromParent()
+  private val velocityHelper = VelocityHelper()
+  private val tempRect = Rect()
+  private val defaultFlingAnimator: ValueAnimator = ObjectAnimator.ofInt(this, "scrollX", 0, 0)
+
+  // Backing fields for interface properties with custom logic
+  private var _overflowInset = Rect()
+  private var _virtualViewContainerState: VirtualViewContainerState? = null
+  private var _removeClippedSubviews = false
+  private var _reactScrollViewScrollState = ReactScrollViewScrollState()
+
+  // Private state
+  private var activelyScrolling = false
+  private var clippingRect: Rect? = null
+  private var _overflow: Overflow =
+      if (ReactNativeFeatureFlags.enablePropsUpdateReconciliationAndroid()) Overflow.VISIBLE
+      else Overflow.SCROLL
+  private var dragging = false
+  private var pagingEnabled = false
+  private var postTouchRunnable: Runnable? = null
+  private var sendMomentumEvents = false
+  private var scrollPerfTag: String? = null
+  private var endBackground: Drawable? = null
+  private var endFillColor = Color.TRANSPARENT
+  private var disableIntervalMomentum = false
+  internal var snapInterval = 0
+  internal var snapOffsets: List<Int>? = null
+  internal var snapToStart = true
+  internal var snapToEnd = true
+  internal var snapToAlignment = SNAP_ALIGNMENT_DISABLED
+  private var pagedArrowScrolling = false
+  private var pendingContentOffsetX = UNSET_CONTENT_OFFSET
+  private var pendingContentOffsetY = UNSET_CONTENT_OFFSET
+  public open var pointerEvents: PointerEvents = PointerEvents.AUTO
+  private var contentView: View? = null
+  private var maintainVisibleContentPositionHelper:
+      MaintainVisibleScrollPositionHelper<ReactHorizontalScrollView>? =
+      null
+  public open var fadingEdgeLengthStart: Int = 0
+    set(value) {
+      field = value
+      invalidate()
+    }
+
+  public open var fadingEdgeLengthEnd: Int = 0
+    set(value) {
+      field = value
+      invalidate()
+    }
+
+  private var emittedOverScrollSinceScrollBegin = false
+  private var scrollsChildToFocus = true
+  internal var snapToItemPadding: Int = 0
+  internal var scrollAnimationEnabled: Boolean = true
+  private var blockScrollDelta: Boolean = false
+
+  // Interface property overrides
+  override var scrollEnabled: Boolean = true
+  override var stateWrapper: StateWrapper? = null
+  override var scrollEventThrottle: Int = 0
+  override var lastScrollDispatchTime: Long = 0L
+  override var hasChildPressedStateDelay: Boolean? = null
+
+  override val virtualViewContainerState: VirtualViewContainerState
+    get() =
+        _virtualViewContainerState
+            ?: VirtualViewContainerState.create(this).also { _virtualViewContainerState = it }
+
+  override val overflowInset: Rect
+    get() = _overflowInset
+
+  override val overflow: String?
+    get() =
+        when (_overflow) {
+          Overflow.HIDDEN -> "hidden"
+          Overflow.SCROLL -> "scroll"
+          Overflow.VISIBLE -> "visible"
+        }
+
+  override var removeClippedSubviews: Boolean
+    get() = _removeClippedSubviews
+    set(value) {
+      if (ReactNativeFeatureFlags.disableSubviewClippingAndroid()) return
+      if (value && clippingRect == null) clippingRect = Rect()
+      _removeClippedSubviews = value
+      updateClippingRect()
+    }
+
+  override var reactScrollViewScrollState: ReactScrollViewScrollState
+    get() = _reactScrollViewScrollState
+    set(value) {
+      _reactScrollViewScrollState = value
+      if (
+          ReactNativeFeatureFlags.enableViewCulling() ||
+              ReactNativeFeatureFlags.useTraitHiddenOnAndroid()
+      ) {
+        val scrollPosition = value.lastStateUpdateScroll
+        restoreScrollTo(scrollPosition.x, scrollPosition.y)
+      }
+    }
+
+  init {
+    ViewCompat.setAccessibilityDelegate(this, ReactScrollViewAccessibilityDelegate())
+    setOnHierarchyChangeListener(this)
+    setClipChildren(false)
+    initView()
+  }
+
+  /**
+   * Set all default values here as opposed to in the constructor or field defaults. It is important
+   * that these properties are set during the constructor, but also on-demand whenever an existing
+   * ReactHorizontalScrollView is recycled.
+   */
+  private fun initView() {
+    _overflowInset = Rect()
+    _virtualViewContainerState = null
+    activelyScrolling = false
+    clippingRect = null
+    _overflow =
+        if (ReactNativeFeatureFlags.enablePropsUpdateReconciliationAndroid()) Overflow.VISIBLE
+        else Overflow.SCROLL
+    dragging = false
+    pagingEnabled = false
+    postTouchRunnable = null
+    _removeClippedSubviews = false
+    scrollEnabled = true
+    sendMomentumEvents = false
+    scrollPerfTag = null
+    endBackground = null
+    endFillColor = Color.TRANSPARENT
+    disableIntervalMomentum = false
+    snapInterval = 0
+    snapOffsets = null
+    snapToStart = true
+    snapToEnd = true
+    snapToAlignment = SNAP_ALIGNMENT_DISABLED
+    pagedArrowScrolling = false
+    pendingContentOffsetX = UNSET_CONTENT_OFFSET
+    pendingContentOffsetY = UNSET_CONTENT_OFFSET
+    stateWrapper = null
+    _reactScrollViewScrollState = ReactScrollViewScrollState()
+    pointerEvents = PointerEvents.AUTO
+    lastScrollDispatchTime = 0
+    scrollEventThrottle = 0
+    contentView = null
+    maintainVisibleContentPositionHelper = null
+    fadingEdgeLengthStart = 0
+    fadingEdgeLengthEnd = 0
+    emittedOverScrollSinceScrollBegin = false
+    scrollsChildToFocus = true
+    snapToItemPadding = 0
+    scrollAnimationEnabled = true
+    blockScrollDelta = false
+  }
+
+  internal fun recycleView() {
+    initView()
+    if (parent != null) {
+      (parent as ViewGroup).removeView(this)
+    }
+    updateView()
+  }
+
+  private fun updateView() {}
+
+  override fun onInitializeAccessibilityNodeInfo(info: AccessibilityNodeInfo) {
+    super.onInitializeAccessibilityNodeInfo(info)
+    val testId = getTag(R.id.react_test_id) as? String
+    if (testId != null) {
+      info.viewIdResourceName = testId
+    }
+  }
+
+  override fun canScrollHorizontally(direction: Int): Boolean {
+    return scrollEnabled && super.canScrollHorizontally(direction)
+  }
+
+  override fun computeScroll() {
+    val s = scroller
+    if (UiModeUtils.isTVDevice(context) &&
+        !scrollAnimationEnabled &&
+        s != null &&
+        !s.isFinished) {
+      // Jump instantly to the target position instead of animating.
+      scrollTo(s.finalX, s.finalY)
+      s.forceFinished(true)
+      return
+    }
+    super.computeScroll()
+  }
+
+  override fun computeScrollDeltaToGetChildRectOnScreen(rect: Rect): Int {
+    if (!scrollEnabled || blockScrollDelta) {
+      return 0
+    }
+    return super.computeScrollDeltaToGetChildRectOnScreen(rect)
+  }
+
+  private fun getOverScrollerFromParent(): OverScroller? {
+    if (!triedToGetScrollerField) {
+      triedToGetScrollerField = true
+      try {
+        scrollerField = HorizontalScrollView::class.java.getDeclaredField("mScroller")
+        scrollerField?.isAccessible = true
+      } catch (e: NoSuchFieldException) {
+        FLog.w(
+            TAG,
+            "Failed to get mScroller field for HorizontalScrollView! " +
+                "This app will exhibit the bounce-back scrolling bug :(",
+        )
+      }
+    }
+
+    val field = scrollerField ?: return null
+    return try {
+      val scrollerValue = field.get(this)
+      if (scrollerValue is OverScroller) {
+        scrollerValue
+      } 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 :(",
+        )
+        null
+      }
+    } catch (e: IllegalAccessException) {
+      throw RuntimeException("Failed to get mScroller from HorizontalScrollView!", e)
+    }
+  }
+
+  public open fun setScrollPerfTag(scrollPerfTag: String?) {
+    this.scrollPerfTag = scrollPerfTag
+  }
+
+  public open fun setDisableIntervalMomentum(disableIntervalMomentum: Boolean) {
+    this.disableIntervalMomentum = disableIntervalMomentum
+  }
+
+  public open fun setSendMomentumEvents(sendMomentumEvents: Boolean) {
+    this.sendMomentumEvents = sendMomentumEvents
+  }
+
+  public open fun setPagingEnabled(pagingEnabled: Boolean) {
+    this.pagingEnabled = pagingEnabled
+  }
+
+  public open fun setScrollsChildToFocus(scrollsChildToFocus: Boolean) {
+    this.scrollsChildToFocus = scrollsChildToFocus
+  }
+
+  public open fun setDecelerationRate(decelerationRate: Float) {
+    reactScrollViewScrollState.decelerationRate = decelerationRate
+    scroller?.setFriction(1.0f - decelerationRate)
+  }
+
+  public open fun abortAnimation() {
+    if (scroller != null && !scroller.isFinished) {
+      scroller.abortAnimation()
+    }
+  }
+
+  public open fun flashScrollIndicators() {
+    awakenScrollBars()
+  }
+
+  override fun getLeftFadingEdgeStrength(): Float {
+    val max = max(fadingEdgeLengthStart.toFloat(), fadingEdgeLengthEnd.toFloat())
+    val value =
+        if (layoutDirection == LAYOUT_DIRECTION_RTL) fadingEdgeLengthEnd else fadingEdgeLengthStart
+    return value / max
+  }
+
+  override fun getRightFadingEdgeStrength(): Float {
+    val max = max(fadingEdgeLengthStart.toFloat(), fadingEdgeLengthEnd.toFloat())
+    val value =
+        if (layoutDirection == LAYOUT_DIRECTION_RTL) fadingEdgeLengthStart else fadingEdgeLengthEnd
+    return value / max
+  }
+
+  public open fun setOverflow(overflow: String?) {
+    _overflow =
+        if (overflow == null) {
+          Overflow.SCROLL
+        } else {
+          Overflow.fromString(overflow)
+              ?: if (ReactNativeFeatureFlags.enablePropsUpdateReconciliationAndroid())
+                  Overflow.VISIBLE
+              else Overflow.SCROLL
+        }
+    invalidate()
+  }
+
+  internal open fun setMaintainVisibleContentPosition(
+      config: MaintainVisibleScrollPositionHelper.Config?
+  ) {
+    if (config != null && maintainVisibleContentPositionHelper == null) {
+      val helper = MaintainVisibleScrollPositionHelper(this, true)
+      maintainVisibleContentPositionHelper = helper
+      helper.start()
+    } else if (config == null) {
+      maintainVisibleContentPositionHelper?.stop()
+      maintainVisibleContentPositionHelper = null
+    }
+    maintainVisibleContentPositionHelper?.let { it.config = config }
+  }
+
+  override fun setOverflowInset(left: Int, top: Int, right: Int, bottom: Int) {
+    _overflowInset.set(left, top, right, bottom)
+  }
+
+  public override fun onDraw(canvas: Canvas) {
+    if (_overflow != Overflow.VISIBLE) {
+      BackgroundStyleApplicator.clipToPaddingBox(this, canvas)
+    }
+    super.onDraw(canvas)
+  }
+
+  override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
+    MeasureSpecAssertions.assertExplicitMeasureSpec(widthMeasureSpec, heightMeasureSpec)
+
+    val measuredWidth = MeasureSpec.getSize(widthMeasureSpec)
+    val measuredHeight = MeasureSpec.getSize(heightMeasureSpec)
+
+    if (DEBUG_MODE) {
+      FLog.i(
+          TAG,
+          "onMeasure[%d] measured width: %d measured height: %d",
+          id,
+          measuredWidth,
+          measuredHeight,
+      )
+    }
+
+    val measuredHeightChanged = getMeasuredHeight() != measuredHeight
+
+    setMeasuredDimension(measuredWidth, measuredHeight)
+
+    // See how `scrollXAfterMeasure` is used in `onLayout`, and why we only enable the
+    // hack if the height has changed.
+    if (measuredHeightChanged && scroller != null) {
+      scrollXAfterMeasure = scroller.currX
+    }
+  }
+
+  override fun onLayout(changed: Boolean, l: Int, t: Int, r: Int, b: Int) {
+    if (DEBUG_MODE) {
+      FLog.i(TAG, "onLayout[%d] l %d t %d r %d b %d", id, l, t, r, b)
+    }
+
+    // Has the scrollX changed between the last onMeasure and this layout?
+    // If so, cancel the animation.
+    // Essentially, if the height changes (due to keyboard popping up, for instance) the
+    // underlying View.layout method will in some cases scroll to an incorrect X position -
+    // see also the hacks in `fling`. The order of layout is called in the order of: onMeasure,
+    // layout, onLayout.
+    // We cannot override `layout` but we can detect the sequence of events between onMeasure
+    // and onLayout.
+    if (
+        scrollXAfterMeasure != NO_SCROLL_POSITION &&
+            scroller != null &&
+            scrollXAfterMeasure != scroller.finalX &&
+            !scroller.isFinished
+    ) {
+      if (DEBUG_MODE) {
+        FLog.i(
+            TAG,
+            "onLayout[%d] scroll hack enabled: reset to previous scrollX position of %d",
+            id,
+            scrollXAfterMeasure,
+        )
+      }
+      scroller.startScroll(scrollXAfterMeasure, scroller.finalY, 0, 0)
+      scroller.forceFinished(true)
+      scrollXAfterMeasure = NO_SCROLL_POSITION
+    }
+
+    // Apply pending contentOffset in case it was set before the view was laid out.
+    if (isContentReady()) {
+      val scrollToX =
+          if (pendingContentOffsetX != UNSET_CONTENT_OFFSET) pendingContentOffsetX else scrollX
+      val scrollToY =
+          if (pendingContentOffsetY != UNSET_CONTENT_OFFSET) pendingContentOffsetY else scrollY
+      scrollTo(scrollToX, scrollToY)
+    }
+
+    ReactScrollViewHelper.emitLayoutEvent(this)
+    _virtualViewContainerState?.updateState()
+  }
+
+  /**
+   * Attempts to scroll-snap to the focused child based on snapToAlignment/scrollSnapAlign or
+   * scrollSnapOffset. Returns true if snap scrolling was performed, false otherwise.
+   */
+  private fun tryScrollSnapToChild(focused: View): Boolean {
+    if (snapToAlignment != SNAP_ALIGNMENT_ITEM) {
+      return false
+    }
+
+    val result = ReactScrollViewHelper.findScrollSnap(focused, this) ?: return false
+    val snapTarget = result.first
+    val alignment = result.second
+    val snapOffset = result.third
+
+    val rect = Rect()
+    snapTarget.getDrawingRect(rect)
+    offsetDescendantRectToMyCoords(snapTarget, rect)
+
+    val maxScrollX = max(0, computeHorizontalScrollRange() - width)
+
+    if (snapOffset != null) {
+      val targetOffset =
+          ReactScrollViewHelper.computeScrollSnapTargetForOffset(
+              rect.left, snapOffset, snapInterval, maxScrollX)
+      reactSmoothScrollTo(targetOffset, scrollY)
+      return true
+    }
+
+    val viewportWidth = width - paddingLeft - paddingRight
+
+    val targetOffset =
+        ReactScrollViewHelper.computeScrollSnapOffset(
+            rect.left,
+            rect.right,
+            viewportWidth,
+            alignment ?: return false,
+            snapInterval,
+            snapToItemPadding,
+            maxScrollX,
+        ) ?: return false
+
+    reactSmoothScrollTo(targetOffset, scrollY)
+    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
+   * prevents scrolling to child when requestChildFocus is called. Overriding this method and
+   * scrolling to child without checking any layout dirty flag. This will fix focus navigation issue
+   * for KeyEvents which are not handled in HorizontalScrollView, for example: KEYCODE_TAB.
+   */
+  override fun requestChildFocus(child: View, focused: View?) {
+    if (focused != null && scrollsChildToFocus) {
+      if (!tryScrollSnapToChild(focused)) {
+        if (!pagingEnabled) {
+          scrollToChild(focused)
+        }
+      }
+    }
+    requestChildFocusWithoutScroll(child, focused)
+  }
+
+  /**
+   * In rare cases where an app overrides the built-in ReactScrollView by overriding it, and also
+   * needs to customize scroll into view on focus behaviors, this protected method can be used to
+   * unblock such customization.
+   */
+  protected open fun requestChildFocusWithoutScroll(child: View, focused: View?) {
+    // Temporarily block HorizontalScrollView's internal scrollToChild from running during
+    // super.requestChildFocus — we've already handled scrolling in requestChildFocus.
+    blockScrollDelta = true
+    super.requestChildFocus(child, focused)
+    blockScrollDelta = false
+  }
+
+  override fun requestChildRectangleOnScreen(
+      child: View,
+      rectangle: Rect,
+      immediate: Boolean,
+  ): Boolean {
+    if (!scrollsChildToFocus) return false
+    return super.requestChildRectangleOnScreen(child, rectangle, immediate)
+  }
+
+  override fun addFocusables(views: ArrayList<View>, direction: Int, focusableMode: Int) {
+    if (pagingEnabled && !pagedArrowScrolling) {
+      // Only add elements within the current page to list of focusables
+      val candidateViews = ArrayList<View>()
+      super.addFocusables(candidateViews, direction, focusableMode)
+      for (candidate in candidateViews) {
+        // We must also include the currently focused in the focusables list or focus search will
+        // always return the first element within the focusables list
+        if (
+            isScrolledInView(candidate) ||
+                isPartiallyScrolledInView(candidate) ||
+                candidate.isFocused
+        ) {
+          views.add(candidate)
+        }
+      }
+    } else {
+      super.addFocusables(views, direction, focusableMode)
+    }
+  }
+
+  /** Calculates the x delta required to scroll the given descendent into view */
+  private fun getScrollDelta(descendent: View): Int {
+    descendent.getDrawingRect(tempRect)
+    offsetDescendantRectToMyCoords(descendent, tempRect)
+    return computeScrollDeltaToGetChildRectOnScreen(tempRect)
+  }
+
+  /** Returns whether the given descendent is scrolled fully in view */
+  private fun isScrolledInView(descendent: View): Boolean {
+    return getScrollDelta(descendent) == 0
+  }
+
+  override fun isPartiallyScrolledInView(view: View): Boolean {
+    val scrollDelta = getScrollDelta(view)
+    view.getDrawingRect(tempRect)
+    return scrollDelta != 0 && abs(scrollDelta) < tempRect.width()
+  }
+
+  /** Returns whether the given descendent is "mostly" (>50%) scrolled in view */
+  private fun isMostlyScrolledInView(descendent: View): Boolean {
+    val scrollDelta = getScrollDelta(descendent)
+    descendent.getDrawingRect(tempRect)
+    return scrollDelta != 0 && abs(scrollDelta) < (tempRect.width() / 2)
+  }
+
+  private fun scrollToChild(child: View) {
+    val scrollDelta = getScrollDelta(child)
+    if (scrollDelta != 0) {
+      scrollBy(scrollDelta, 0)
+    }
+  }
+
+  override fun onScrollChanged(x: Int, y: Int, oldX: Int, oldY: Int) {
+    if (DEBUG_MODE) {
+      FLog.i(TAG, "onScrollChanged[%d] x %d y %d oldx %d oldy %d", id, x, y, oldX, oldY)
+    }
+
+    Systrace.beginSection(Systrace.TRACE_TAG_REACT, "ReactHorizontalScrollView.onScrollChanged")
+    try {
+      super.onScrollChanged(x, y, oldX, oldY)
+      activelyScrolling = true
+      if (onScrollDispatchHelper.onScrollChanged(x, y)) {
+        if (_removeClippedSubviews) {
+          updateClippingRect()
+        }
+        ReactScrollViewHelper.updateStateOnScrollChanged(
+            this,
+            onScrollDispatchHelper.xFlingVelocity,
+            onScrollDispatchHelper.yFlingVelocity,
+        )
+        _virtualViewContainerState?.updateState()
+      }
+    } finally {
+      Systrace.endSection(Systrace.TRACE_TAG_REACT)
+    }
+  }
+
+  override fun shouldDelayChildPressedState(): Boolean =
+      hasChildPressedStateDelay ?: super.shouldDelayChildPressedState()
+
+  override fun onInterceptTouchEvent(ev: MotionEvent): Boolean {
+    if (!scrollEnabled) return false
+
+    if (
+        ev.action == MotionEvent.ACTION_DOWN &&
+            findDeepestScrollViewForMotionEvent(this, ev) != null
+    ) {
+      return false
+    }
+
+    // We intercept the touch event if the children are not supposed to receive it.
+    if (!PointerEvents.canChildrenBeTouchTarget(pointerEvents)) return true
+
+    try {
+      if (super.onInterceptTouchEvent(ev)) {
+        handleInterceptedTouchEvent(ev)
+        return true
+      }
+    } catch (e: IllegalArgumentException) {
+      // Log and ignore the error. This seems to be a bug in the android SDK and
+      // this is the commonly accepted workaround.
+      // https://tinyurl.com/mw6qkod (Stack Overflow)
+      FLog.w(ReactConstants.TAG, "Error intercepting touch event.", e)
+    }
+
+    return false
+  }
+
+  protected open fun handleInterceptedTouchEvent(ev: MotionEvent) {
+    if (!ReactNativeFeatureFlags.shouldTriggerResponderTransferOnScrollAndroid()) {
+      NativeGestureUtil.notifyNativeGestureStarted(this, ev)
+    }
+    ReactScrollViewHelper.emitScrollBeginDragEvent(this)
+    dragging = true
+    emittedOverScrollSinceScrollBegin = false
+    enableFpsListener()
+    getFlingAnimator().cancel()
+  }
+
+  override fun pageScroll(direction: Int): Boolean {
+    val handled = super.pageScroll(direction)
+    if (pagingEnabled && handled) {
+      handlePostTouchScrolling(0, 0)
+    }
+    return handled
+  }
+
+  private fun isDescendantOf(parent: View?, view: View?): Boolean {
+    if (view == null || parent == null) return false
+    var p: ViewParent? = view.parent
+    while (p != null && p.parent != null) {
+      if (p === parent) return true
+      p = p.parent
+    }
+    return false
+  }
+
+  override fun arrowScroll(direction: Int): Boolean {
+    var handled = false
+
+    if (snapToAlignment == SNAP_ALIGNMENT_ITEM) {
+      // When snapToAlignment is "item", find the next focusable and request focus directly.
+      // This avoids super.arrowScroll() which starts its own scroll animation that conflicts
+      // with tryScrollSnapToChild's snap scrolling — requestChildFocus → tryScrollSnapToChild
+      // handles scrolling.
+      val currentFocused = findFocus()
+      val nextFocused = FocusFinder.getInstance().findNextFocus(this, currentFocused, direction)
+      if (nextFocused != null && nextFocused !== currentFocused && nextFocused !== this) {
+        nextFocused.requestFocus(direction)
+        handled = true
+      }
+    } else if (pagingEnabled) {
+      pagedArrowScrolling = true
+
+      if (isNotEmpty()) {
+        val currentFocused = findFocus()
+        val nextFocused = FocusFinder.getInstance().findNextFocus(this, currentFocused, direction)
+        val rootChild = getContentView()
+        if (nextFocused != null && isDescendantOf(rootChild, nextFocused)) {
+          if (snapToAlignment == SNAP_ALIGNMENT_ITEM) {
+            // When snapToAlignment is "item", don't use smoothScrollToNextPage (which scrolls
+            // by full page width and ignores snapToItemPadding). Just request focus —
+            // requestChildFocus → tryScrollSnapToChild handles scrolling with correct padding.
+            nextFocused.requestFocus()
+          } else {
+            if (!isScrolledInView(nextFocused) && !isMostlyScrolledInView(nextFocused)) {
+              smoothScrollToNextPage(direction)
+            }
+            nextFocused.requestFocus()
+          }
+          handled = true
+        } else {
+          if (snapToAlignment != SNAP_ALIGNMENT_ITEM) {
+            smoothScrollToNextPage(direction)
+          }
+          handled = true
+        }
+      }
+
+      pagedArrowScrolling = false
+    } else {
+      handled = super.arrowScroll(direction)
+    }
+
+    return handled
+  }
+
+  override fun onTouchEvent(ev: MotionEvent): Boolean {
+    if (!scrollEnabled) return false
+
+    // We do not accept the touch event if this view is not supposed to receive it.
+    if (!PointerEvents.canBeTouchTarget(pointerEvents)) return false
+
+    velocityHelper.calculateVelocity(ev)
+    val action = ev.actionMasked
+    if (action == MotionEvent.ACTION_UP && dragging) {
+      ReactScrollViewHelper.updateFabricScrollState(this)
+
+      val velocityX = velocityHelper.xVelocity
+      val velocityY = velocityHelper.yVelocity
+      ReactScrollViewHelper.emitScrollEndDragEvent(this, velocityX, velocityY)
+      if (!ReactNativeFeatureFlags.shouldTriggerResponderTransferOnScrollAndroid()) {
+        NativeGestureUtil.notifyNativeGestureEnded(this, ev)
+      }
+      dragging = false
+      // After the touch finishes, we may need to do some scrolling afterwards either as a result
+      // of a fling or because we need to page align the content
+      handlePostTouchScrolling(Math.round(velocityX), Math.round(velocityY))
+    }
+
+    if (action == MotionEvent.ACTION_DOWN) {
+      cancelPostTouchScrolling()
+    }
+
+    return try {
+      super.onTouchEvent(ev)
+    } catch (e: IllegalArgumentException) {
+      // Log and ignore the error. This seems to be a bug in the android SDK and
+      // this is the commonly accepted workaround.
+      // https://tinyurl.com/mw6qkod (Stack Overflow)
+      FLog.w(ReactConstants.TAG, "Error handling touch event.", e)
+      false
+    }
+  }
+
+  override fun dispatchGenericMotionEvent(ev: MotionEvent): Boolean {
+    // Ignore generic motion events (joystick, mouse wheel, trackpad) if scrolling is disabled
+    if (!scrollEnabled) return false
+
+    // We do not dispatch the motion event if its children are not supposed to receive it
+    if (!PointerEvents.canChildrenBeTouchTarget(pointerEvents)) return false
+
+    // Handle ACTION_SCROLL events (mouse wheel, trackpad, joystick)
+    if (ev.actionMasked == MotionEvent.ACTION_SCROLL) {
+      val hScroll = ev.getAxisValue(MotionEvent.AXIS_HSCROLL)
+      if (hScroll != 0f) {
+        // Perform the scroll
+        enableFpsListener()
+        val result = super.dispatchGenericMotionEvent(ev)
+        // Schedule snap alignment to run after scrolling stops
+        if (
+            result &&
+                (pagingEnabled ||
+                    snapInterval != 0 ||
+                    snapOffsets != null ||
+                    (snapToAlignment != SNAP_ALIGNMENT_DISABLED &&
+                        snapToAlignment != SNAP_ALIGNMENT_ITEM))
+        ) {
+          // Cancel any pending post-touch runnable and reschedule
+          if (postTouchRunnable != null) {
+            removeCallbacks(postTouchRunnable)
+            postTouchRunnable = null
+          }
+          postTouchRunnable = Runnable {
+            postTouchRunnable = null
+            // +1/-1 velocity if scrolling right or left. This is to ensure that the
+            // next/previous page is picked rather than sliding backwards to the current page
+            var velocityX = hScroll.sign.toInt()
+            if (disableIntervalMomentum) {
+              velocityX = 0
+            }
+            flingAndSnap(velocityX)
+            handlePostTouchScrolling(velocityX, 0)
+          }
+          postOnAnimationDelayed(postTouchRunnable, ReactScrollViewHelper.MOMENTUM_DELAY)
+        } else {
+          handlePostTouchScrolling(0, 0)
+        }
+        return result
+      }
+    }
+
+    return super.dispatchGenericMotionEvent(ev)
+  }
+
+  override fun executeKeyEvent(event: KeyEvent): Boolean {
+    val eventKeyCode = event.keyCode
+    if (
+        !scrollEnabled &&
+            (eventKeyCode == KeyEvent.KEYCODE_DPAD_LEFT ||
+                eventKeyCode == KeyEvent.KEYCODE_DPAD_RIGHT)
+    ) {
+      return false
+    }
+    return super.executeKeyEvent(event)
+  }
+
+  override fun fling(velocityX: Int) {
+    if (DEBUG_MODE) {
+      FLog.i(TAG, "fling[%d] velocityX %d", id, velocityX)
+    }
+
+    // Workaround.
+    // On Android P if a ScrollView is inverted, we will get a wrong sign for
+    // velocityX (see https://issuetracker.google.com/issues/112385925).
+    // At the same time, onScrollDispatchHelper tracks the correct velocity direction.
+    //
+    // Hence, we can use the absolute value from whatever the OS gives
+    // us and use the sign of what onScrollDispatchHelper has tracked.
+    val correctedVelocityX =
+        if (Build.VERSION.SDK_INT == Build.VERSION_CODES.P) {
+          (abs(velocityX) * onScrollDispatchHelper.xFlingVelocity.sign).toInt()
+        } else {
+          velocityX
+        }
+
+    if (pagingEnabled) {
+      flingAndSnap(correctedVelocityX)
+    } else if (scroller != null) {
+      // FB SCROLLVIEW CHANGE
+
+      // We provide our own version of fling that uses a different call to the standard OverScroller
+      // which takes into account the possibility of adding new content while the ScrollView is
+      // animating. Because we give essentially no max X for the fling, the fling will continue as
+      // long as there is content. See onOverScrolled() to see the second part of this change which
+      // properly aborts the scroller animation when we get to the bottom of the ScrollView content.
+
+      val scrollWindowWidth = width - paddingStart - paddingEnd
+
+      scroller.fling(
+          scrollX, // startX
+          scrollY, // startY
+          correctedVelocityX, // velocityX
+          0, // velocityY
+          0, // minX
+          Int.MAX_VALUE, // maxX
+          0, // minY
+          0, // maxY
+          scrollWindowWidth / 2, // overX
+          0, // overY
+      )
+
+      postInvalidateOnAnimation()
+
+      // END FB SCROLLVIEW CHANGE
+    } else {
+      super.fling(correctedVelocityX)
+    }
+    handlePostTouchScrolling(correctedVelocityX, 0)
+  }
+
+  override fun onSizeChanged(w: Int, h: Int, oldw: Int, oldh: Int) {
+    super.onSizeChanged(w, h, oldw, oldh)
+    if (_removeClippedSubviews) {
+      updateClippingRect()
+    }
+    _virtualViewContainerState?.updateState()
+  }
+
+  override fun onAttachedToWindow() {
+    super.onAttachedToWindow()
+    if (_removeClippedSubviews) {
+      updateClippingRect()
+    }
+    maintainVisibleContentPositionHelper?.start()
+  }
+
+  override fun onDetachedFromWindow() {
+    super.onDetachedFromWindow()
+    maintainVisibleContentPositionHelper?.stop()
+  }
+
+  override fun focusSearch(focused: View, @FocusDirection direction: Int): View? {
+    val nextFocus = super.focusSearch(focused, direction)
+
+    if (ReactNativeFeatureFlags.enableCustomFocusSearchOnClippedElementsAndroid()) {
+      // If we can find the next focus and it is a child of this view, return it, else it means we
+      // are leaving the scroll view and we should try to find a clipped element
+      if (nextFocus != null && findViewById<View>(nextFocus.id) != null) {
+        return nextFocus
+      }
+      val nextFocusableView = findNextFocusableView(this, focused, direction)
+      if (nextFocusableView != null) {
+        return nextFocusableView
+      }
+    }
+
+    return nextFocus
+  }
+
+  override fun updateClippingRect() {
+    updateClippingRect(null)
+  }
+
+  override fun updateClippingRect(excludedViews: Set<Int>?) {
+    if (!_removeClippedSubviews) return
+
+    Systrace.beginSection(Systrace.TRACE_TAG_REACT, "ReactHorizontalScrollView.updateClippingRect")
+    try {
+      val rect = checkNotNull(clippingRect)
+      ReactClippingViewGroupHelper.calculateClippingRect(this, rect)
+      val cv = getContentView()
+      if (cv is ReactClippingViewGroup) {
+        cv.updateClippingRect(excludedViews)
+      }
+    } finally {
+      Systrace.endSection(Systrace.TRACE_TAG_REACT)
+    }
+  }
+
+  override fun getClippingRect(outClippingRect: Rect) {
+    outClippingRect.set(checkNotNull(clippingRect))
+  }
+
+  override fun getChildVisibleRect(child: View, r: Rect, offset: android.graphics.Point?): Boolean {
+    return super.getChildVisibleRect(child, r, offset)
+  }
+
+  private fun getSnapInterval(): Int = if (snapInterval != 0) snapInterval else width
+
+  private fun getContentView(): View? = getChildAt(0)
+
+  public open fun setEndFillColor(color: Int) {
+    if (color != endFillColor) {
+      endFillColor = color
+      endBackground = endFillColor.toDrawable()
+    }
+  }
+
+  override fun onOverScrolled(scrollX: Int, scrollY: Int, clampedX: Boolean, clampedY: Boolean) {
+    if (DEBUG_MODE) {
+      FLog.i(
+          TAG,
+          "onOverScrolled[%d] scrollX %d scrollY %d clampedX %b clampedY %b",
+          id,
+          scrollX,
+          scrollY,
+          clampedX,
+          clampedY,
+      )
+    }
+
+    @Suppress("NAME_SHADOWING") var scrollX = scrollX
+
+    if (scroller != null) {
+      // FB SCROLLVIEW CHANGE
+
+      // This is part two of the reimplementation of fling to fix the bounce-back bug. See fling()
+      // for more information.
+
+      if (!scroller.isFinished && scroller.currX != scroller.finalX) {
+        val scrollRange = max(computeHorizontalScrollRange() - width, 0)
+        if (scrollX >= scrollRange) {
+          scroller.abortAnimation()
+          scrollX = scrollRange
+        }
+      }
+
+      // END FB SCROLLVIEW CHANGE
+    }
+
+    if (
+        ReactNativeFeatureFlags.shouldTriggerResponderTransferOnScrollAndroid() &&
+            clampedX &&
+            !emittedOverScrollSinceScrollBegin
+    ) {
+      ReactScrollViewHelper.emitScrollEvent(this, 0f, 0f)
+      emittedOverScrollSinceScrollBegin = true
+    }
+
+    super.onOverScrolled(scrollX, scrollY, clampedX, clampedY)
+  }
+
+  override fun onChildViewAdded(parent: View, child: View) {
+    contentView = child
+    child.addOnLayoutChangeListener(this)
+  }
+
+  override fun onChildViewRemoved(parent: View, child: View) {
+    contentView?.removeOnLayoutChangeListener(this)
+    contentView = null
+  }
+
+  private fun enableFpsListener() {
+    if (isScrollPerfLoggingEnabled()) {
+      val listener = fpsListener ?: return
+      val perfTag = scrollPerfTag.takeUnless { it.isNullOrEmpty() } ?: return
+      listener.enable(perfTag)
+    }
+  }
+
+  private fun disableFpsListener() {
+    if (isScrollPerfLoggingEnabled()) {
+      val listener = fpsListener ?: return
+      val perfTag = scrollPerfTag.takeUnless { it.isNullOrEmpty() } ?: return
+      listener.disable(perfTag)
+    }
+  }
+
+  private fun isScrollPerfLoggingEnabled(): Boolean {
+    return fpsListener != null && !scrollPerfTag.isNullOrEmpty()
+  }
+
+  override fun draw(canvas: Canvas) {
+    if (endFillColor != Color.TRANSPARENT) {
+      val content = getContentView()
+      val bg = endBackground
+      if (bg != null && content != null && content.right < width) {
+        bg.setBounds(content.right, 0, width, height)
+        bg.draw(canvas)
+      }
+    }
+    super.draw(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
+   * don't get any events from Android about this lifecycle, we do all our detection by creating a
+   * runnable that checks if we scrolled in the last frame and if so assumes we are still scrolling.
+   */
+  private fun handlePostTouchScrolling(velocityX: Int, velocityY: Int) {
+    if (DEBUG_MODE) {
+      FLog.i(
+          TAG,
+          "handlePostTouchScrolling[%d] velocityX %d velocityY %d",
+          id,
+          velocityX,
+          velocityY,
+      )
+    }
+
+    // Check if we are already handling this which may occur if this is called by both the touch up
+    // and a fling call
+    if (postTouchRunnable != null) return
+
+    if (sendMomentumEvents) {
+      ReactScrollViewHelper.emitScrollMomentumBeginEvent(this, velocityX, velocityY)
+    }
+
+    activelyScrolling = false
+    postTouchRunnable =
+        object : Runnable {
+          private var snappingToPage = false
+          private var stableFrames = 0
+
+          override fun run() {
+            if (activelyScrolling) {
+              // We are still scrolling.
+              activelyScrolling = false
+              stableFrames = 0
+              this@ReactHorizontalScrollView.postOnAnimationDelayed(
+                  this,
+                  ReactScrollViewHelper.MOMENTUM_DELAY,
+              )
+            } else {
+              // There has not been a scroll update since the last time this Runnable executed.
+              ReactScrollViewHelper.updateFabricScrollState(this@ReactHorizontalScrollView)
+
+              // We keep checking for updates until the ScrollView has "stabilized" and hasn't
+              // scrolled for N consecutive frames. This number is arbitrary: big enough to catch
+              // a number of race conditions, but small enough to not cause perf regressions, etc.
+              // In anecdotal testing, it seemed like a decent number.
+              // Without this check, sometimes this Runnable stops executing too soon - it will
+              // fire before the first scroll event of an animated scroll/fling, and stop
+              // immediately.
+              stableFrames++
+
+              if (stableFrames >= 3) {
+                postTouchRunnable = null
+                if (sendMomentumEvents) {
+                  ReactScrollViewHelper.emitScrollMomentumEndEvent(this@ReactHorizontalScrollView)
+                }
+                // Kotlin name is notifyUserDrivenScrollEnded; the _internal suffix is
+                // only a @JvmName alias for Java callers.
+                ReactScrollViewHelper.notifyUserDrivenScrollEnded(this@ReactHorizontalScrollView)
+                disableFpsListener()
+              } else {
+                if (pagingEnabled && !snappingToPage) {
+                  // If we have pagingEnabled and we have not snapped to the page
+                  // we need to cause that scroll by asking for it
+                  snappingToPage = true
+                  flingAndSnap(0)
+                }
+                // The scrollview has not "stabilized" so we just post to check again a frame later
+                this@ReactHorizontalScrollView.postOnAnimationDelayed(
+                    this,
+                    ReactScrollViewHelper.MOMENTUM_DELAY,
+                )
+              }
+            }
+          }
+        }
+    postOnAnimationDelayed(postTouchRunnable, ReactScrollViewHelper.MOMENTUM_DELAY)
+  }
+
+  private fun cancelPostTouchScrolling() {
+    if (postTouchRunnable != null) {
+      removeCallbacks(postTouchRunnable)
+      postTouchRunnable = null
+      getFlingAnimator().cancel()
+    }
+  }
+
+  private fun predictFinalScrollPosition(velocityX: Int): Int {
+    // predict where a fling would end up so we can scroll to the nearest snap offset
+    val maximumOffset = max(0, computeHorizontalScrollRange() - width)
+    // TODO(T106335409): Existing prediction still uses overscroller. Consider change this to use
+    // fling animator instead.
+    return if (getFlingAnimator() === defaultFlingAnimator) {
+      ReactScrollViewHelper.predictFinalScrollPosition(this, velocityX, 0, maximumOffset, 0).x
+    } else {
+      ReactScrollViewHelper.getNextFlingStartValue(
+          this,
+          scrollX,
+          reactScrollViewScrollState.finalAnimatedPositionScroll.x,
+          velocityX,
+      ) + getFlingExtrapolatedDistance(velocityX)
+    }
+  }
+
+  /**
+   * This will smooth scroll us to the nearest snap offset point. It currently just looks at where
+   * the content is and slides to the nearest point. It is intended to be run after we are done
+   * scrolling, and handling any momentum scrolling.
+   */
+  private fun smoothScrollAndSnap(velocity: Int) {
+    if (DEBUG_MODE) {
+      FLog.i(TAG, "smoothScrollAndSnap[%d] velocity %d", id, velocity)
+    }
+
+    val interval = getSnapInterval().toDouble()
+    val currentOffset =
+        ReactScrollViewHelper.getNextFlingStartValue(
+                this,
+                scrollX,
+                reactScrollViewScrollState.finalAnimatedPositionScroll.x,
+                velocity,
+            )
+            .toDouble()
+    val targetOffset = predictFinalScrollPosition(velocity).toDouble()
+
+    var previousPage = floor(currentOffset / interval).toInt()
+    var nextPage = ceil(currentOffset / interval).toInt()
+    var currentPage = round(currentOffset / interval).toInt()
+    val targetPage = round(targetOffset / interval).toInt()
+
+    if (velocity > 0 && nextPage == previousPage) {
+      nextPage++
+    } else if (velocity < 0 && previousPage == nextPage) {
+      previousPage--
+    }
+
+    if (velocity > 0 && currentPage < nextPage && targetPage > previousPage) {
+      currentPage = nextPage
+    } else if (velocity < 0 && currentPage > previousPage && targetPage < nextPage) {
+      currentPage = previousPage
+    }
+
+    val finalTargetOffset = currentPage * interval
+    if (finalTargetOffset != currentOffset) {
+      activelyScrolling = true
+      reactSmoothScrollTo(finalTargetOffset.toInt(), scrollY)
+    }
+  }
+
+  private fun flingAndSnap(velocityX: Int) {
+    if (DEBUG_MODE) {
+      FLog.i(TAG, "smoothScrollAndSnap[%d] velocityX %d", id, velocityX)
+    }
+
+    if (isEmpty()) return
+
+    // pagingEnabled only allows snapping one interval at a time
+    if (snapInterval == 0 &&
+        snapOffsets == null &&
+        (snapToAlignment == SNAP_ALIGNMENT_DISABLED || snapToAlignment == SNAP_ALIGNMENT_ITEM)) {
+      smoothScrollAndSnap(velocityX)
+      return
+    }
+
+    @Suppress("NAME_SHADOWING") var velocityX = velocityX
+    val hasCustomizedFlingAnimator = getFlingAnimator() !== defaultFlingAnimator
+    val maximumOffset = max(0, computeHorizontalScrollRange() - width)
+    var targetOffset = predictFinalScrollPosition(velocityX)
+    if (disableIntervalMomentum) {
+      targetOffset = scrollX
+    }
+
+    var smallerOffset = 0
+    var largerOffset = maximumOffset
+    var firstOffset = 0
+    var lastOffset = maximumOffset
+    val viewportWidth = width - paddingStart - paddingEnd
+
+    // offsets are from the right edge in RTL layouts
+    if (layoutDirection == LAYOUT_DIRECTION_RTL) {
+      targetOffset = maximumOffset - targetOffset
+      velocityX = -velocityX
+    }
+
+    // get the nearest snap points to the target offset
+    val offsets = snapOffsets
+    if (!offsets.isNullOrEmpty()) {
+      firstOffset = offsets[0]
+      lastOffset = offsets[offsets.size - 1]
+
+      for (i in offsets.indices) {
+        val offset = offsets[i]
+        if (offset <= targetOffset) {
+          if (targetOffset - offset < targetOffset - smallerOffset) {
+            smallerOffset = offset
+          }
+        }
+        if (offset >= targetOffset) {
+          if (offset - targetOffset < largerOffset - targetOffset) {
+            largerOffset = offset
+          }
+        }
+      }
+    } else if (snapToAlignment != SNAP_ALIGNMENT_DISABLED && snapToAlignment != SNAP_ALIGNMENT_ITEM) {
+      if (snapInterval > 0) {
+        val ratio = targetOffset.toDouble() / snapInterval
+        smallerOffset =
+            max(
+                getItemStartOffset(
+                    snapToAlignment,
+                    (floor(ratio) * snapInterval).toInt(),
+                    snapInterval,
+                    viewportWidth,
+                ),
+                0,
+            )
+        largerOffset =
+            kotlin.math.min(
+                getItemStartOffset(
+                    snapToAlignment,
+                    (ceil(ratio) * snapInterval).toInt(),
+                    snapInterval,
+                    viewportWidth,
+                ),
+                maximumOffset,
+            )
+      } else {
+        val cv = getContentView() as? ViewGroup ?: return
+        var smallerChildOffset = largerOffset
+        var largerChildOffset = smallerOffset
+        for (i in 0 until cv.childCount) {
+          val item = cv.getChildAt(i)
+          val itemStartOffset =
+              getItemStartOffset(snapToAlignment, item.left, item.width, viewportWidth)
+          if (itemStartOffset <= targetOffset) {
+            if (targetOffset - itemStartOffset < targetOffset - smallerOffset) {
+              smallerOffset = itemStartOffset
+            }
+          }
+          if (itemStartOffset >= targetOffset) {
+            if (itemStartOffset - targetOffset < largerOffset - targetOffset) {
+              largerOffset = itemStartOffset
+            }
+          }
+          smallerChildOffset = kotlin.math.min(smallerChildOffset, itemStartOffset)
+          largerChildOffset = max(largerChildOffset, itemStartOffset)
+        }
+
+        // For Recycler ViewGroup, the maximumOffset can be much larger than the total heights of
+        // items in the layout. In this case snapping is not possible beyond the currently rendered
+        // children.
+        smallerOffset = max(smallerOffset, smallerChildOffset)
+        largerOffset = kotlin.math.min(largerOffset, largerChildOffset)
+      }
+    } else {
+      val interval = getSnapInterval().toDouble()
+      val ratio = targetOffset.toDouble() / interval
+      smallerOffset = (floor(ratio) * interval).toInt()
+      largerOffset = kotlin.math.min((ceil(ratio) * interval).toInt(), maximumOffset)
+    }
+
+    // Calculate the nearest offset
+    val nearestOffset =
+        if (abs(targetOffset - smallerOffset) < abs(largerOffset - targetOffset)) smallerOffset
+        else largerOffset
+
+    // if scrolling after the last snap offset and snapping to the
+    // end of the list is disabled, then we allow free scrolling
+    var currentOffset = scrollX
+    if (layoutDirection == LAYOUT_DIRECTION_RTL) {
+      currentOffset = maximumOffset - currentOffset
+    }
+    if (!snapToEnd && targetOffset >= lastOffset) {
+      if (currentOffset >= lastOffset) {
+        // free scrolling
+      } else {
+        // snap to end
+        targetOffset = lastOffset
+      }
+    } else if (!snapToStart && targetOffset <= firstOffset) {
+      if (currentOffset <= firstOffset) {
+        // free scrolling
+      } else {
+        // snap to beginning
+        targetOffset = firstOffset
+      }
+    } else if (velocityX > 0) {
+      if (!hasCustomizedFlingAnimator) {
+        // The default animator requires boost on initial velocity as when snapping velocity can
+        // feel sluggish for slow swipes
+        velocityX += ((largerOffset - targetOffset) * 10.0).toInt()
+      }
+      targetOffset = largerOffset
+    } else if (velocityX < 0) {
+      if (!hasCustomizedFlingAnimator) {
+        // The default animator requires boost on initial velocity as when snapping velocity can
+        // feel sluggish for slow swipes
+        velocityX -= ((targetOffset - smallerOffset) * 10.0).toInt()
+      }
+      targetOffset = smallerOffset
+    } else {
+      targetOffset = nearestOffset
+    }
+
+    // Make sure the new offset isn't out of bounds
+    targetOffset = kotlin.math.min(max(0, targetOffset), maximumOffset)
+
+    if (layoutDirection == LAYOUT_DIRECTION_RTL) {
+      targetOffset = maximumOffset - targetOffset
+      velocityX = -velocityX
+    }
+
+    if (hasCustomizedFlingAnimator || scroller == null) {
+      reactSmoothScrollTo(targetOffset, scrollY)
+    } else {
+      // smoothScrollTo will always scroll over 250ms which is often *waaay*
+      // too short and will cause the scrolling to feel almost instant
+      // try to manually interact with OverScroller instead
+      // if velocity is 0 however, fling() won't work, so we want to use smoothScrollTo
+      activelyScrolling = true
+
+      scroller.fling(
+          scrollX, // startX
+          scrollY, // startY
+          // velocity = 0 doesn't work with fling() so we pretend there's a reasonable
+          // initial velocity going on when a touch is released without any movement
+          if (velocityX != 0) velocityX else targetOffset - scrollX, // velocityX
+          0, // velocityY
+          // setting both minX and maxX to the same value will guarantee that we scroll to it
+          // but using the standard fling-style easing rather than smoothScrollTo's 250ms animation
+          targetOffset, // minX
+          targetOffset, // maxX
+          0, // minY
+          0, // maxY
+          // we only want to allow overscrolling if the final offset is at the very edge of the view
+          if (targetOffset == 0 || targetOffset == maximumOffset) viewportWidth / 2 else 0, // overX
+          0, // overY
+      )
+
+      postInvalidateOnAnimation()
+    }
+  }
+
+  private fun getItemStartOffset(
+      snapToAlignment: Int,
+      itemStartPosition: Int,
+      itemWidth: Int,
+      viewPortWidth: Int,
+  ): Int =
+      when (snapToAlignment) {
+        SNAP_ALIGNMENT_CENTER -> itemStartPosition - (viewPortWidth - itemWidth) / 2
+        SNAP_ALIGNMENT_START -> itemStartPosition
+        SNAP_ALIGNMENT_END -> itemStartPosition - (viewPortWidth - itemWidth)
+        else ->
+            throw IllegalStateException("Invalid SnapToAlignment value: ${this.snapToAlignment}")
+      }
+
+  private fun smoothScrollToNextPage(direction: Int) {
+    if (DEBUG_MODE) {
+      FLog.i(TAG, "smoothScrollToNextPage[%d] direction %d", id, direction)
+    }
+
+    val w = width
+    val currentX = scrollX
+
+    var page = currentX / w
+    if (currentX % w != 0) {
+      page++
+    }
+
+    if (direction == View.FOCUS_LEFT) {
+      page -= 1
+    } else {
+      page += 1
+    }
+
+    if (page < 0) {
+      page = 0
+    }
+
+    reactSmoothScrollTo(page * w, scrollY)
+    handlePostTouchScrolling(0, 0)
+  }
+
+  override fun setBackgroundColor(color: Int) {
+    BackgroundStyleApplicator.setBackgroundColor(this, color)
+  }
+
+  public open fun setBorderWidth(position: Int, width: Float) {
+    BackgroundStyleApplicator.setBorderWidth(
+        this,
+        LogicalEdge.entries[position],
+        PixelUtil.toDIPFromPixel(width),
+    )
+  }
+
+  public open fun setBorderColor(position: Int, color: Int?) {
+    BackgroundStyleApplicator.setBorderColor(this, LogicalEdge.entries[position], color)
+  }
+
+  public open fun setBorderRadius(borderRadius: Float) {
+    setBorderRadius(borderRadius, BorderRadiusProp.BORDER_RADIUS.ordinal)
+  }
+
+  public open fun setBorderRadius(borderRadius: Float, position: Int) {
+    val radius =
+        if (borderRadius.isNaN()) null
+        else LengthPercentage(PixelUtil.toDIPFromPixel(borderRadius), LengthPercentageType.POINT)
+    BackgroundStyleApplicator.setBorderRadius(this, BorderRadiusProp.entries[position], radius)
+  }
+
+  public open fun setBorderStyle(style: String?) {
+    BackgroundStyleApplicator.setBorderStyle(
+        this,
+        if (style == null) null else BorderStyle.fromString(style),
+    )
+  }
+
+  /**
+   * Calls `smoothScrollTo` and updates state.
+   *
+   * `smoothScrollTo` changes `contentOffset` and we need to keep `contentOffset` in sync between
+   * scroll view and state. Calling raw `smoothScrollTo` doesn't update state.
+   */
+  override fun reactSmoothScrollTo(x: Int, y: Int) {
+    if (scrollAnimationEnabled || !UiModeUtils.isTVDevice(context)) {
+      ReactScrollViewHelper.smoothScrollTo(this, x, y)
+    } else {
+      scrollTo(x, y)
+    }
+    setPendingContentOffsets(x, y)
+  }
+
+  /**
+   * Calls `super.scrollTo` and updates state.
+   *
+   * `super.scrollTo` changes `contentOffset` and we need to keep `contentOffset` in sync between
+   * scroll view and state.
+   *
+   * Note that while we can override scrollTo, we *cannot* override `smoothScrollTo` because it is
+   * final. See `reactSmoothScrollTo`.
+   */
+  override fun scrollTo(x: Int, y: Int) {
+    if (DEBUG_MODE) {
+      FLog.i(TAG, "scrollTo[%d] x %d y %d", id, x, y)
+    }
+
+    super.scrollTo(x, y)
+    ReactScrollViewHelper.updateFabricScrollState(this)
+    setPendingContentOffsets(x, y)
+  }
+
+  /** Scrolls to a new position preserving any momentum scrolling animation. */
+  override fun scrollToPreservingMomentum(x: Int, y: Int) {
+    scrollTo(x, y)
+    recreateFlingAnimation(x, Int.MAX_VALUE)
+  }
+
+  protected open fun restoreScrollTo(x: Int, y: Int) {
+    scrollTo(x, y)
+  }
+
+  private fun isContentReady(): Boolean {
+    val child = getContentView()
+    return child != null && child.width != 0 && child.height != 0
+  }
+
+  private fun setPendingContentOffsets(x: Int, y: Int) {
+    if (DEBUG_MODE) {
+      FLog.i(TAG, "setPendingContentOffsets[%d] x %d y %d", id, x, y)
+    }
+
+    if (isContentReady()) {
+      pendingContentOffsetX = UNSET_CONTENT_OFFSET
+      pendingContentOffsetY = UNSET_CONTENT_OFFSET
+    } else {
+      pendingContentOffsetX = x
+      pendingContentOffsetY = y
+    }
+  }
+
+  override fun onLayoutChange(
+      v: View,
+      left: Int,
+      top: Int,
+      right: Int,
+      bottom: Int,
+      oldLeft: Int,
+      oldTop: Int,
+      oldRight: Int,
+      oldBottom: Int,
+  ) {
+    if (contentView == null) return
+
+    // Adjust the scroll position to follow new content. In RTL, this means we keep a constant
+    // offset from the right edge instead of the left edge, so content added to the end of the flow
+    // 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 (v.layoutDirection == LAYOUT_DIRECTION_RTL) {
+      adjustPositionForContentChangeRTL(left, right, oldLeft, oldRight)
+    }
+    ReactScrollViewHelper.emitLayoutChangeEvent(this)
+  }
+
+  /**
+   * 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 fun recreateFlingAnimation(scrollX: Int, maxX: Int) {
+    // 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 (scroller != null && !scroller.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.
+      val scrollerXBeforeTick = scroller.currX
+      val hasMoreTicks = scroller.computeScrollOffset()
+
+      // Stop the existing animation at the current state of the scroller. We will then recreate
+      // it starting at the adjusted x offset.
+      scroller.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 X axis from the
+        // start and end of the animation, assuming HorizontalScrollView never fires vertical fling
+        // animations.
+        // TODO: This does not fully handle overscroll.
+        val direction = (scroller.finalX - scroller.startX).toFloat().sign
+        val flingVelocityX = scroller.currVelocity * direction
+
+        scroller.fling(scrollX, scrollY, flingVelocityX.toInt(), 0, 0, maxX, 0, 0)
+      } else {
+        scrollTo(scrollX + (scroller.currX - scrollerXBeforeTick), scrollY)
+      }
+    }
+  }
+
+  private fun adjustPositionForContentChangeRTL(
+      left: Int,
+      right: Int,
+      oldLeft: Int,
+      oldRight: Int,
+  ) {
+    // 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()
+    }
+
+    val distanceToRightEdge = oldRight - scrollX
+    val newWidth = right - left
+    val newScrollX = newWidth - distanceToRightEdge
+    scrollTo(newScrollX, scrollY)
+
+    recreateFlingAnimation(newScrollX, newWidth - width)
+  }
+
+  override fun startFlingAnimator(start: Int, end: Int) {
+    // Always cancel existing animator before starting the new one. `smoothScrollTo` contains some
+    // logic that, if called multiple times in a short amount of time, will treat all calls as part
+    // of the same animation and will not lengthen the duration of the animation. This means that,
+    // for example, if the user is scrolling rapidly, multiple pages could be considered part of one
+    // animation, causing some page animations to be animated very rapidly - looking like they're
+    // not animated at all.
+    defaultFlingAnimator.cancel()
+
+    // Update the fling animator with new values
+    val duration = ReactScrollViewHelper.getDefaultScrollAnimationDuration(context)
+    defaultFlingAnimator.setDuration(duration.toLong()).setIntValues(start, end)
+
+    // Start the animator
+    defaultFlingAnimator.start()
+
+    if (sendMomentumEvents) {
+      val xVelocity = if (duration > 0) (end - start) / duration else 0
+      ReactScrollViewHelper.emitScrollMomentumBeginEvent(this, xVelocity, 0)
+      ReactScrollViewHelper.dispatchMomentumEndOnAnimationEnd(this)
+    }
+  }
+
+  override fun getFlingAnimator(): ValueAnimator = defaultFlingAnimator
+
+  override fun getFlingExtrapolatedDistance(velocity: Int): Int =
+      ReactScrollViewHelper.predictFinalScrollPosition(
+              this,
+              velocity,
+              0,
+              max(0, computeHorizontalScrollRange() - width),
+              0,
+          )
+          .x
+}