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

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

@@ -11,6 +11,7 @@ import android.animation.Animator
 import android.animation.ValueAnimator
 import android.content.Context
 import android.graphics.Point
+import android.graphics.Rect
 import android.os.Build
 import android.view.View
 import android.view.ViewGroup
@@ -19,7 +20,6 @@ import androidx.annotation.RequiresApi
 import androidx.core.view.ViewCompat.FocusDirection
 import androidx.core.view.ViewCompat.FocusRealDirection
 import com.facebook.common.logging.FLog
-import com.facebook.react.animated.NativeAnimatedModule
 import com.facebook.react.bridge.ReactContext
 import com.facebook.react.bridge.WritableMap
 import com.facebook.react.bridge.WritableNativeMap
@@ -32,6 +32,7 @@ import com.facebook.react.uimanager.StateWrapper
 import com.facebook.react.uimanager.UIManagerHelper
 import com.facebook.react.uimanager.common.UIManagerType
 import com.facebook.react.uimanager.common.ViewUtil
+import com.facebook.react.views.view.ReactViewGroup
 import java.lang.ref.WeakReference
 import java.util.concurrent.CopyOnWriteArrayList
 import kotlin.math.abs
@@ -54,6 +55,7 @@ public object ReactScrollViewHelper {
   public const val SNAP_ALIGNMENT_START: Int = 1
   public const val SNAP_ALIGNMENT_CENTER: Int = 2
   public const val SNAP_ALIGNMENT_END: Int = 3
+  public const val SNAP_ALIGNMENT_ITEM: Int = 4
 
   // Support global native listeners for scroll events
   private val scrollListeners = CopyOnWriteArrayList<WeakReference<ScrollListener>>()
@@ -134,7 +136,7 @@ public object ReactScrollViewHelper {
     // if there's a crash initiated from JS and we tap on a ScrollView
     // around teardown of RN, this will cause a NPE. We can safely ignore
     // this since the crash is usually a red herring.
-    val eventDispatcher = UIManagerHelper.getEventDispatcherForReactTag(reactContext, scrollView.id)
+    val eventDispatcher = UIManagerHelper.getEventDispatcher(reactContext)
     if (eventDispatcher != null) {
       eventDispatcher.dispatchEvent(
           ScrollEvent.obtain(
@@ -157,17 +159,11 @@ public object ReactScrollViewHelper {
     }
   }
 
-  // TODO: Remove this once C++ animation driver is complete
   @JvmStatic
   @JvmName("notifyUserDrivenScrollEnded_internal")
   internal fun notifyUserDrivenScrollEnded(scrollView: ViewGroup) {
     val reactContext = scrollView.context as? ReactContext
-    if (reactContext != null) {
-      val nativeAnimated = reactContext.getNativeModule(NativeAnimatedModule::class.java)
-      if (nativeAnimated != null) {
-        nativeAnimated.userDrivenScrollEnded(scrollView.id)
-      }
-    }
+    reactContext?.scrollEndedListeners?.notifyScrollEnded(scrollView)
   }
 
   /** This is only for Java listeners. onLayout events emitted to JS are handled elsewhere. */
@@ -209,6 +205,8 @@ public object ReactScrollViewHelper {
       SNAP_ALIGNMENT_CENTER
     } else if ("end" == alignment) {
       SNAP_ALIGNMENT_END
+    } else if ("item".equals(alignment, ignoreCase = true)) {
+      SNAP_ALIGNMENT_ITEM
     } else {
       FLog.w(ReactConstants.TAG, "wrong snap alignment value: $alignment")
       SNAP_ALIGNMENT_DISABLED
@@ -569,6 +567,70 @@ public object ReactScrollViewHelper {
     return host.findViewById(nextFocusableViewId)
   }
 
+  /**
+   * Walks up the view hierarchy from the focused view to find a ReactViewGroup with
+   * scrollSnapAlign set. Returns a Pair of (snapTarget, alignment) or null if not found.
+   *
+   * Shared by [ReactScrollView] and [ReactHorizontalScrollView].
+   */
+  @JvmStatic
+  public fun findScrollSnapAlign(focused: View, scrollView: ViewGroup): Pair<View, String>? {
+    var view: View? = focused
+    var snapTarget: View? = null
+    var alignment: String? = null
+    while (view != null && view !== scrollView) {
+      if (view is ReactViewGroup) {
+        val snap = view.scrollSnapAlign
+        if (snap != null) {
+          alignment = snap
+          snapTarget = view
+        }
+      }
+      val parent = view.parent
+      view = if (parent is View) parent else null
+    }
+    return if (alignment != null && snapTarget != null) Pair(snapTarget, alignment) else null
+  }
+
+  /**
+   * Computes the target scroll offset for scroll-snap based on the focused view's position,
+   * alignment, snap interval, scroll padding, and maximum scroll range.
+   *
+   * Returns the clamped target offset, or null if the alignment is unknown.
+   *
+   * Shared by [ReactScrollView] and [ReactHorizontalScrollView].
+   *
+   * @param focusedStart the start coordinate of the snap target in scroll view coordinates
+   * @param focusedEnd the end coordinate of the snap target in scroll view coordinates
+   * @param viewportSize the visible viewport size on the scroll axis
+   * @param alignment the scrollSnapAlign value ("start", "center", or "end")
+   * @param snapInterval the snap interval (0 if not set)
+   * @param snapToItemPadding the snap-to-item padding value
+   * @param maxScrollOffset the maximum scroll offset for clamping
+   */
+  @JvmStatic
+  public fun computeScrollSnapOffset(
+      focusedStart: Int,
+      focusedEnd: Int,
+      viewportSize: Int,
+      alignment: String,
+      snapInterval: Int,
+      snapToItemPadding: Int,
+      maxScrollOffset: Int,
+  ): Int? {
+    val focusedCenter = (focusedStart + focusedEnd) / 2
+    var targetOffset = when (alignment) {
+      "start" -> focusedStart - snapToItemPadding
+      "center" -> focusedCenter - (viewportSize / 2) + (snapToItemPadding / 2)
+      "end" -> focusedEnd - viewportSize + snapToItemPadding
+      else -> return null
+    }
+    if (snapInterval > 0) {
+      targetOffset = (Math.floor(targetOffset.toDouble() / snapInterval) * snapInterval).toInt()
+    }
+    return Math.max(0, Math.min(targetOffset, maxScrollOffset))
+  }
+
   @JvmStatic
   public fun resolveAbsoluteDirection(
       @FocusRealDirection direction: Int,

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

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

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

@@ -9,7 +9,6 @@ package com.facebook.react.views.scroll
 
 import android.graphics.Rect
 import android.view.ViewGroup
-import android.view.ViewTreeObserver
 import com.facebook.common.logging.FLog
 import com.facebook.react.common.build.ReactBuildConfig
 import com.facebook.react.internal.featureflags.ReactNativeFeatureFlags
@@ -48,21 +47,10 @@ internal fun rectsOverlap(rect1: Rect, rect2: Rect): Boolean {
 
 internal abstract class VirtualViewContainerState {
   protected val prerenderRatio: Double = ReactNativeFeatureFlags.virtualViewPrerenderRatio()
-  protected val hysteresisRatio: Double = ReactNativeFeatureFlags.virtualViewHysteresisRatio()
   protected abstract val virtualViews: MutableCollection<VirtualView>
   protected val emptyRect: Rect = Rect()
   protected val visibleRect: Rect = Rect()
   protected val prerenderRect: Rect = Rect()
-  protected val hysteresisRect: Rect = Rect()
-  protected val onWindowFocusChangeListener =
-      if (ReactNativeFeatureFlags.enableVirtualViewWindowFocusDetection()) {
-        ViewTreeObserver.OnWindowFocusChangeListener {
-          debugLog("onWindowFocusChanged")
-          updateModes()
-        }
-      } else {
-        null
-      }
   protected val scrollView: ViewGroup
 
   companion object {
@@ -78,15 +66,6 @@ internal abstract class VirtualViewContainerState {
 
   constructor(scrollView: ViewGroup) {
     this.scrollView = scrollView
-    if (onWindowFocusChangeListener != null) {
-      scrollView.viewTreeObserver.addOnWindowFocusChangeListener(onWindowFocusChangeListener)
-    }
-  }
-
-  fun cleanup() {
-    if (onWindowFocusChangeListener != null) {
-      scrollView.viewTreeObserver.removeOnWindowFocusChangeListener(onWindowFocusChangeListener)
-    }
   }
 
   open fun onChange(virtualView: VirtualView) {
@@ -111,10 +90,7 @@ internal abstract class VirtualViewContainerState {
     updateModes()
   }
 
-  /**
-   * Refreshes the coordinates for the Rects this class cares about (visibleRect, prerenderRect,
-   * hysteresisRect)
-   */
+  /** Refreshes the coordinates for the Rects this class cares about (visibleRect, prerenderRect) */
   protected fun updateRects() {
     scrollView.getDrawingRect(visibleRect)
 
@@ -126,7 +102,6 @@ internal abstract class VirtualViewContainerState {
       // should set the other rects here in case scrollview is suddenly empty after the other rects
       // are non-empty
       prerenderRect.set(visibleRect)
-      hysteresisRect.set(prerenderRect)
       return
     }
 
@@ -136,17 +111,9 @@ internal abstract class VirtualViewContainerState {
         (-prerenderRect.height() * prerenderRatio).toInt(),
     )
 
-    hysteresisRect.set(prerenderRect)
-    hysteresisRect.inset(
-        (-visibleRect.width() * hysteresisRatio).toInt(),
-        (-visibleRect.height() * hysteresisRatio).toInt(),
-    )
-
     debugLog(
         "updateRects",
-        {
-          "visibleRect ${visibleRect.toString()} prerenderRect ${prerenderRect.toString()} hysteresisRect ${hysteresisRect.toString()}"
-        },
+        { "visibleRect ${visibleRect.toString()} prerenderRect ${prerenderRect.toString()}" },
     )
   }
 

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

@@ -33,52 +33,29 @@ internal class VirtualViewContainerStateClassic(scrollView: ViewGroup) :
         (-prerenderRect.height() * prerenderRatio).toInt(),
     )
 
-    if (hysteresisRatio > 0.0) {
-      hysteresisRect.set(prerenderRect)
-      hysteresisRect.inset(
-          (-visibleRect.width() * hysteresisRatio).toInt(),
-          (-visibleRect.height() * hysteresisRatio).toInt(),
-      )
-    }
-
     val virtualViewsIt =
         if (virtualView != null) listOf(virtualView) else virtualViews.toMutableSet()
     virtualViewsIt.forEach { vv ->
       val rect = vv.containerRelativeRect
 
-      var mode: VirtualViewMode? = VirtualViewMode.Hidden
+      var mode: VirtualViewMode = VirtualViewMode.Hidden
       var thresholdRect = emptyRect
       when {
         rectsOverlap(rect, visibleRect) -> {
           thresholdRect = visibleRect
-          if (onWindowFocusChangeListener != null) {
-            if (scrollView.hasWindowFocus()) {
-              mode = VirtualViewMode.Visible
-            } else {
-              mode = VirtualViewMode.Prerender
-            }
-          } else {
-            mode = VirtualViewMode.Visible
-          }
+          mode = VirtualViewMode.Visible
         }
         rectsOverlap(rect, prerenderRect) -> {
           mode = VirtualViewMode.Prerender
           thresholdRect = prerenderRect
         }
-        (hysteresisRatio > 0.0 && rectsOverlap(rect, hysteresisRect)) -> {
-          mode = null
-        }
       }
 
-      if (mode != null) {
-        vv.onModeChange(mode, thresholdRect)
-        debugLog(
-            "updateModes",
-            {
-              "virtualView=${vv.virtualViewID} mode=$mode  rect=$rect thresholdRect=$thresholdRect"
-            },
-        )
-      }
+      vv.onModeChange(mode, thresholdRect)
+      debugLog(
+          "updateModes",
+          { "virtualView=${vv.virtualViewID} mode=$mode  rect=$rect thresholdRect=$thresholdRect" },
+      )
     }
   }
 }

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

@@ -24,8 +24,8 @@ internal class VirtualViewContainerStateExperimental(scrollView: ViewGroup) :
       }
   override val virtualViews = IntervalTree(horizontal)
 
-  // set of all VirtualViews that are in hysteresis, prerender, or visible range
-  var HPV: MutableSet<String> = mutableSetOf()
+  // set of all VirtualViews that are in prerender or visible ranges
+  var PV: MutableSet<String> = mutableSetOf()
   // set of all VirtualViews that are in prerender (not in viewport)
   var P: MutableSet<String> = mutableSetOf()
   // set of all VirtualViews that are in viewport
@@ -51,7 +51,7 @@ internal class VirtualViewContainerStateExperimental(scrollView: ViewGroup) :
 
   override fun remove(virtualView: VirtualView) {
     super.remove(virtualView)
-    HPV.remove(virtualView.virtualViewID)
+    PV.remove(virtualView.virtualViewID)
     P.remove(virtualView.virtualViewID)
     V.remove(virtualView.virtualViewID)
   }
@@ -63,57 +63,38 @@ internal class VirtualViewContainerStateExperimental(scrollView: ViewGroup) :
   private fun updateMode(virtualView: VirtualView) {
     val rect = virtualView.containerRelativeRect
 
-    var mode: VirtualViewMode? = VirtualViewMode.Hidden
+    var mode: VirtualViewMode = VirtualViewMode.Hidden
     var thresholdRect = emptyRect
     when {
       rectsOverlap(rect, visibleRect) -> {
         thresholdRect = visibleRect
-        if (onWindowFocusChangeListener != null) {
-          if (scrollView.hasWindowFocus()) {
-            mode = VirtualViewMode.Visible
-          } else {
-            mode = VirtualViewMode.Prerender
-          }
-        } else {
-          mode = VirtualViewMode.Visible
-        }
+        mode = VirtualViewMode.Visible
       }
       rectsOverlap(rect, prerenderRect) -> {
         mode = VirtualViewMode.Prerender
         thresholdRect = prerenderRect
       }
-      (hysteresisRatio > 0.0 && rectsOverlap(rect, hysteresisRect)) -> {
-        mode = null
-      }
     }
 
-    if (mode != null) {
-      virtualView.onModeChange(mode, thresholdRect)
-    }
+    virtualView.onModeChange(mode, thresholdRect)
 
     // move the virtualView into the correct set(s)
-    when {
-      mode == VirtualViewMode.Visible -> {
-        HPV.add(virtualView.virtualViewID)
+    when (mode) {
+      VirtualViewMode.Visible -> {
+        PV.add(virtualView.virtualViewID)
         P.remove(virtualView.virtualViewID)
         V.add(virtualView.virtualViewID)
       }
 
-      mode == VirtualViewMode.Prerender -> {
-        HPV.add(virtualView.virtualViewID)
+      VirtualViewMode.Prerender -> {
+        PV.add(virtualView.virtualViewID)
         P.add(virtualView.virtualViewID)
         V.remove(virtualView.virtualViewID)
       }
 
-      mode == VirtualViewMode.Hidden -> {
+      VirtualViewMode.Hidden -> {
         // remove from all sets
-        HPV.remove(virtualView.virtualViewID)
-        P.remove(virtualView.virtualViewID)
-        V.remove(virtualView.virtualViewID)
-      }
-
-      else -> { // hysteresis
-        HPV.add(virtualView.virtualViewID)
+        PV.remove(virtualView.virtualViewID)
         P.remove(virtualView.virtualViewID)
         V.remove(virtualView.virtualViewID)
       }
@@ -125,27 +106,25 @@ internal class VirtualViewContainerStateExperimental(scrollView: ViewGroup) :
    * n), where m = size of the prerender window in terms of index
    */
   private fun updateModesAll() {
-    // collect V', PV', HPV' sets
+    // collect V' and PV' sets
     val VPrime = virtualViews.query(visibleRect)
     val PVPrime = virtualViews.query(prerenderRect)
-    val HPVPrime = virtualViews.query(hysteresisRect)
 
-    debugLog("updateModes", { "V: ${V}, P: ${P}, HPV: ${HPV}" })
+    debugLog("updateModes", { "V: ${V}, P: ${P}, PV: ${PV}" })
 
     /** Perform utility set differences: */
     // P'=PV'-V'
     val PPrime = PVPrime.minus(VPrime)
 
-    debugLog("updateModes", { "V': ${VPrime}, P': ${PPrime}, HPV': ${HPVPrime}" })
+    debugLog("updateModes", { "V': ${VPrime}, P': ${PPrime}, PV': ${PVPrime}" })
 
     /** Get useful set differences */
     // V'-V - update to visible
     val toVisible = VPrime.minus(V)
     // P'-P - update to prerender
     val toPrerender = PPrime.minus(P)
-    // ignore H' - we don't care about VVs in hysteresis
-    // HPV-HPV' - update to hidden
-    val toHidden = HPV.minus(HPVPrime)
+    // PV-PV' - update to hidden
+    val toHidden = PV.minus(PVPrime)
 
     debugLog("updateModes", { "toV: ${toVisible}, toP: ${toPrerender}, toH: ${toHidden}" })
 
@@ -160,10 +139,10 @@ internal class VirtualViewContainerStateExperimental(scrollView: ViewGroup) :
       virtualViews.getVirtualView(vvID)?.onModeChange(VirtualViewMode.Hidden, emptyRect)
     }
 
-    /** update old sets - V, P, and HPV */
+    /** update old sets - V, P, and PV */
     V = VPrime
     P = PPrime.toMutableSet()
-    HPV = HPVPrime.toMutableSet()
+    PV = PVPrime.toMutableSet()
   }
 }