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

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

@@ -82,7 +82,7 @@ constructor(private val fpsListener: FpsListener? = null) :
 
   @ReactProp(name = "scrollEnabled", defaultBoolean = true)
   public fun setScrollEnabled(view: ReactScrollView, value: Boolean) {
-    view.setScrollEnabled(value)
+    view.scrollEnabled = value
 
     // Set focusable to match whether scroll is enabled. This improves keyboarding
     // experience by not making scrollview a tab stop when you cannot interact with it.
@@ -113,13 +113,13 @@ constructor(private val fpsListener: FpsListener? = null) :
   public fun setSnapToInterval(view: ReactScrollView, snapToInterval: Float) {
     // snapToInterval needs to be exposed as a float because of the Javascript interface.
     val density = getDisplayMetricDensity()
-    view.setSnapInterval((snapToInterval * density).toInt())
+    view.snapInterval = (snapToInterval * density).toInt()
   }
 
   @ReactProp(name = "snapToOffsets")
   public fun setSnapToOffsets(view: ReactScrollView, snapToOffsets: ReadableArray?) {
     if (snapToOffsets == null || snapToOffsets.size() == 0) {
-      view.setSnapOffsets(null)
+      view.snapOffsets = null
       return
     }
 
@@ -128,34 +128,34 @@ constructor(private val fpsListener: FpsListener? = null) :
     for (i in 0 until snapToOffsets.size()) {
       offsets.add((snapToOffsets.getDouble(i) * density).toInt())
     }
-    view.setSnapOffsets(offsets)
+    view.snapOffsets = offsets
   }
 
   @ReactProp(name = "snapToAlignment")
   public fun setSnapToAlignment(view: ReactScrollView, alignment: String?) {
-    view.setSnapToAlignment(parseSnapToAlignment(alignment))
+    view.snapToAlignment = parseSnapToAlignment(alignment)
   }
 
   @ReactProp(name = "snapToStart")
   public fun setSnapToStart(view: ReactScrollView, snapToStart: Boolean) {
-    view.setSnapToStart(snapToStart)
+    view.snapToStart = snapToStart
   }
 
   @ReactProp(name = "snapToEnd")
   public fun setSnapToEnd(view: ReactScrollView, snapToEnd: Boolean) {
-    view.setSnapToEnd(snapToEnd)
+    view.snapToEnd = snapToEnd
   }
 
   @ReactProp(name = "snapToItemPadding")
   public fun setSnapToItemPadding(view: ReactScrollView, value: Float) {
     val density = getDisplayMetricDensity()
     val px = (value * density).toInt()
-    view.setSnapToItemPadding(px)
+    view.snapToItemPadding = px
   }
 
   @ReactProp(name = "scrollAnimationEnabled", defaultBoolean = true)
   public fun setScrollAnimationEnabled(view: ReactScrollView, value: Boolean) {
-    view.setScrollAnimationEnabled(value)
+    view.scrollAnimationEnabled = value
   }
 
   @ReactProp(name = ReactClippingViewGroupHelper.PROP_REMOVE_CLIPPED_SUBVIEWS)
@@ -347,8 +347,8 @@ constructor(private val fpsListener: FpsListener? = null) :
   public fun setFadingEdgeLength(view: ReactScrollView, value: Dynamic) {
     when (value.type) {
       ReadableType.Number -> {
-        view.setFadingEdgeLengthStart(value.asInt())
-        view.setFadingEdgeLengthEnd(value.asInt())
+        view.fadingEdgeLengthStart = value.asInt()
+        view.fadingEdgeLengthEnd = value.asInt()
       }
       ReadableType.Map -> {
         value.asMap()?.let { map ->
@@ -360,8 +360,8 @@ constructor(private val fpsListener: FpsListener? = null) :
           if (map.hasKey("end") && map.getInt("end") > 0) {
             end = map.getInt("end")
           }
-          view.setFadingEdgeLengthStart(start)
-          view.setFadingEdgeLengthEnd(end)
+          view.fadingEdgeLengthStart = start
+          view.fadingEdgeLengthEnd = end
         }
       }
       else -> {
@@ -400,7 +400,7 @@ constructor(private val fpsListener: FpsListener? = null) :
       props: ReactStylesDiffMap,
       stateWrapper: StateWrapper,
   ): Any? {
-    view.setStateWrapper(stateWrapper)
+    view.stateWrapper = stateWrapper
     if (
         ReactNativeFeatureFlags.enableViewCulling() ||
             ReactNativeFeatureFlags.useTraitHiddenOnAndroid()

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

@@ -9,14 +9,12 @@ package com.facebook.react.views.scroll
 
 import android.graphics.Rect
 import android.view.ViewGroup
-import com.facebook.common.logging.FLog
-import com.facebook.react.common.build.ReactBuildConfig
 import com.facebook.react.internal.featureflags.ReactNativeFeatureFlags
 import com.facebook.react.views.virtual.VirtualViewMode
 import java.util.*
 
 internal interface VirtualViewContainer {
-  public val virtualViewContainerState: VirtualViewContainerState
+  val virtualViewContainerState: VirtualViewContainerState
 }
 
 public interface VirtualView {
@@ -45,7 +43,17 @@ internal fun rectsOverlap(rect1: Rect, rect2: Rect): Boolean {
   return true
 }
 
-internal abstract class VirtualViewContainerState {
+/**
+ * Manages the state and visibility tracking of virtual views within a scroll container.
+ *
+ * Virtual views are lightweight representations of off-screen content that can transition between
+ * rendering modes (e.g., visible, prerendered, hidden) based on their position relative to the
+ * scroll viewport. Subclasses implement the specific strategy for tracking and updating these
+ * views.
+ *
+ * Use [create] to obtain an instance appropriate for the current feature flag configuration.
+ */
+public abstract class VirtualViewContainerState {
   protected val prerenderRatio: Double = ReactNativeFeatureFlags.virtualViewPrerenderRatio()
   protected abstract val virtualViews: MutableCollection<VirtualView>
   protected val emptyRect: Rect = Rect()
@@ -53,9 +61,9 @@ internal abstract class VirtualViewContainerState {
   protected val prerenderRect: Rect = Rect()
   protected val scrollView: ViewGroup
 
-  companion object {
+  public companion object {
     @JvmStatic
-    fun create(scrollView: ViewGroup): VirtualViewContainerState {
+    public fun create(scrollView: ViewGroup): VirtualViewContainerState {
       return if (ReactNativeFeatureFlags.enableVirtualViewContainerStateExperimental()) {
         VirtualViewContainerStateExperimental(scrollView)
       } else {
@@ -64,29 +72,23 @@ internal abstract class VirtualViewContainerState {
     }
   }
 
-  constructor(scrollView: ViewGroup) {
+  public constructor(scrollView: ViewGroup) {
     this.scrollView = scrollView
   }
 
-  open fun onChange(virtualView: VirtualView) {
-    if (virtualViews.add(virtualView)) {
-      debugLog("add", { "virtualViewID=${virtualView.virtualViewID}" })
-    } else {
-      debugLog("update", { "virtualViewID=${virtualView.virtualViewID}" })
-    }
+  public open fun onChange(virtualView: VirtualView) {
+    virtualViews.add(virtualView)
     updateModes(virtualView)
   }
 
-  open fun remove(virtualView: VirtualView) {
+  public open fun remove(virtualView: VirtualView) {
     assert(virtualViews.remove(virtualView)) {
       "Attempting to remove non-existent VirtualView: ${virtualView.virtualViewID}"
     }
-    debugLog("remove", { "virtualViewID=${virtualView.virtualViewID}" })
   }
 
   // Called on ScrollView onLayout or onScroll
-  fun updateState() {
-    debugLog("updateState")
+  public fun updateState() {
     updateModes()
   }
 
@@ -98,7 +100,6 @@ internal abstract class VirtualViewContainerState {
     // intentionally goes but curently ScrollView and v1 Fling use this check to determine if
     // "content ready"
     if (visibleRect.isEmpty()) {
-      debugLog("updateRects", { "scrollView visibleRect is empty" })
       // should set the other rects here in case scrollview is suddenly empty after the other rects
       // are non-empty
       prerenderRect.set(visibleRect)
@@ -110,22 +111,7 @@ internal abstract class VirtualViewContainerState {
         (-prerenderRect.width() * prerenderRatio).toInt(),
         (-prerenderRect.height() * prerenderRatio).toInt(),
     )
-
-    debugLog(
-        "updateRects",
-        { "visibleRect ${visibleRect.toString()} prerenderRect ${prerenderRect.toString()}" },
-    )
   }
 
   protected abstract fun updateModes(virtualView: VirtualView? = null)
 }
-
-private const val DEBUG_TAG: String = "VirtualViewContainerState"
-internal val IS_DEBUG_BUILD =
-    ReactBuildConfig.DEBUG || ReactBuildConfig.IS_INTERNAL_BUILD || ReactBuildConfig.ENABLE_PERFETTO
-
-private inline fun debugLog(subtag: String, block: () -> String = { "" }) {
-  if (IS_DEBUG_BUILD && ReactNativeFeatureFlags.enableVirtualViewDebugFeatures()) {
-    FLog.d("$DEBUG_TAG:$subtag", block())
-  }
-}

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

@@ -9,7 +9,7 @@ package com.facebook.react.views.scroll
 
 import android.view.ViewGroup
 import com.facebook.common.logging.FLog
-import com.facebook.react.internal.featureflags.ReactNativeFeatureFlags
+import com.facebook.react.common.build.ReactBuildConfig
 import com.facebook.react.views.virtual.VirtualViewMode
 
 internal class VirtualViewContainerStateClassic(scrollView: ViewGroup) :
@@ -58,12 +58,14 @@ internal class VirtualViewContainerStateClassic(scrollView: ViewGroup) :
       )
     }
   }
-}
 
-private const val DEBUG_TAG: String = "VirtualViewContainerStateClassic"
+  internal companion object {
+    private val ENABLE_DEBUG_LOGS = ReactBuildConfig.DEBUG && false
 
-private inline fun debugLog(subtag: String, block: () -> String = { "" }) {
-  if (IS_DEBUG_BUILD && ReactNativeFeatureFlags.enableVirtualViewDebugFeatures()) {
-    FLog.d("$DEBUG_TAG:$subtag", block())
+    internal inline fun debugLog(subtag: String, block: () -> String = { "" }) {
+      if (ENABLE_DEBUG_LOGS) {
+        FLog.d("VirtualViewContainerStateClassic:$subtag", block())
+      }
+    }
   }
 }

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

@@ -10,7 +10,7 @@ package com.facebook.react.views.scroll
 import android.graphics.Rect
 import android.view.ViewGroup
 import com.facebook.common.logging.FLog
-import com.facebook.react.internal.featureflags.ReactNativeFeatureFlags
+import com.facebook.react.common.build.ReactBuildConfig
 import com.facebook.react.views.virtual.VirtualViewMode
 
 internal class VirtualViewContainerStateExperimental(scrollView: ViewGroup) :
@@ -503,10 +503,10 @@ internal class IntervalTree(private val horizontal: Boolean) : MutableCollection
   }
 }
 
-private const val DEBUG_TAG: String = "VirtualViewContainerStateExperimental"
+private val ENABLE_DEBUG_LOGS = ReactBuildConfig.DEBUG && false
 
 private inline fun debugLog(subtag: String, block: () -> String = { "" }) {
-  if (IS_DEBUG_BUILD && ReactNativeFeatureFlags.enableVirtualViewDebugFeatures()) {
-    FLog.d("$DEBUG_TAG:$subtag", block())
+  if (ENABLE_DEBUG_LOGS) {
+    FLog.d("VirtualViewContainerStateExperimental:$subtag", block())
   }
 }

package/ReactAndroid/src/main/java/com/facebook/react/views/scroll/generate-nested-scroll-view.js

@@ -11,8 +11,8 @@
  */
 
 /**
- * Generates ReactNestedScrollView.java and ReactNestedScrollViewManager.kt from
- * ReactScrollView.java and ReactScrollViewManager.kt respectively.
+ * Generates ReactNestedScrollView.kt and ReactNestedScrollViewManager.kt from
+ * ReactScrollView.kt and ReactScrollViewManager.kt respectively.
  *
  * This script creates variants that use NestedScrollView instead of ScrollView
  * for experimentation purposes.
@@ -101,17 +101,17 @@ function replaceCopyrightHeader(content, sourceFile) {
 }
 
 /**
- * Transform ReactScrollView.java to ReactNestedScrollView.java
+ * Transform ReactScrollView.kt to ReactNestedScrollView.kt
  */
 function transformScrollView(content) {
-  // Replace import
+  // Replace import (Kotlin imports have no semicolons)
   content = content.replace(
-    'import android.widget.ScrollView;',
-    'import androidx.core.widget.NestedScrollView;',
+    'import android.widget.ScrollView',
+    'import androidx.core.widget.NestedScrollView',
   );
 
   // Replace standalone ScrollView with NestedScrollView (not when part of another word)
-  // This handles: "extends ScrollView", "ScrollView.class", etc.
+  // This handles: ": ScrollView(context)", "ScrollView::class.java", etc.
   // But NOT: ReactScrollView, NestedScrollView, ScrollViewHelper, etc.
   content = content.replace(
     /(?<![A-Za-z])ScrollView(?!Helper|Manager|CommandHelper|Interface|Accessible|Accessibility)/g,
@@ -121,21 +121,14 @@ function transformScrollView(content) {
   // Replace ReactScrollView with ReactNestedScrollView
   content = replaceClassNames(content);
 
-  // Fix visibility differences between ScrollView and NestedScrollView:
-  // NestedScrollView.onAttachedToWindow() is public, not protected
-  content = content.replace(
-    'protected void onAttachedToWindow()',
-    'public void onAttachedToWindow()',
-  );
-
-  // Make the class package-private (remove public) to keep it internal
+  // Make the class internal to keep it out of the public API
   content = content.replace(
-    'public class ReactNestedScrollView',
-    'class ReactNestedScrollView',
+    'public open class ReactNestedScrollView',
+    'internal open class ReactNestedScrollView',
   );
 
   // Remove original copyright header and add generated header
-  content = replaceCopyrightHeader(content, 'ReactScrollView.java');
+  content = replaceCopyrightHeader(content, 'ReactScrollView.kt');
 
   return content;
 }
@@ -246,8 +239,8 @@ function main() {
 
   const filesToGenerate = [
     {
-      source: path.join(sourceDir, 'ReactScrollView.java'),
-      output: path.join(sourceDir, 'ReactNestedScrollView.java'),
+      source: path.join(sourceDir, 'ReactScrollView.kt'),
+      output: path.join(sourceDir, 'ReactNestedScrollView.kt'),
       transform: transformScrollView,
     },
     {

package/ReactAndroid/src/main/java/com/facebook/react/views/swiperefresh/ReactSwipeRefreshLayout.kt

@@ -12,13 +12,14 @@ import android.view.ViewConfiguration
 import android.view.ViewGroup
 import androidx.swiperefreshlayout.widget.SwipeRefreshLayout
 import com.facebook.react.bridge.ReactContext
+import com.facebook.react.uimanager.HasChildPressedStateDelay
 import com.facebook.react.uimanager.PixelUtil
 import com.facebook.react.uimanager.events.NativeGestureUtil
 import kotlin.math.abs
 
 /** Basic extension of [SwipeRefreshLayout] with ReactNative-specific functionality. */
 public open class ReactSwipeRefreshLayout(reactContext: ReactContext) :
-    SwipeRefreshLayout(reactContext) {
+    SwipeRefreshLayout(reactContext), HasChildPressedStateDelay {
 
   private var didLayout: Boolean = false
   private var refreshing: Boolean = false
@@ -28,6 +29,8 @@ public open class ReactSwipeRefreshLayout(reactContext: ReactContext) :
   private var intercepted: Boolean = false
   private var nativeGestureStarted: Boolean = false
 
+  override var hasChildPressedStateDelay: Boolean? = null
+
   public override fun setRefreshing(refreshing: Boolean) {
     this.refreshing = refreshing
 
@@ -79,6 +82,9 @@ public open class ReactSwipeRefreshLayout(reactContext: ReactContext) :
     parent?.requestDisallowInterceptTouchEvent(disallowIntercept)
   }
 
+  override fun shouldDelayChildPressedState(): Boolean =
+      hasChildPressedStateDelay ?: super.shouldDelayChildPressedState()
+
   public override fun onInterceptTouchEvent(ev: MotionEvent): Boolean {
     if (shouldInterceptTouchEvent(ev) && super.onInterceptTouchEvent(ev)) {
       NativeGestureUtil.notifyNativeGestureStarted(this, ev)

package/ReactAndroid/src/main/java/com/facebook/react/views/text/MutableSpannableLayout.kt

@@ -0,0 +1,107 @@
+/*
+ * 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.text
+
+import android.text.Layout
+import android.text.SpannableString
+import android.text.Spanned
+import com.facebook.react.common.annotations.UnstableReactNativeAPI
+import com.facebook.react.views.text.internal.span.StatefulSpan
+
+/**
+ * A delegating [Layout] subclass that clones the spannable text from [delegate] and replaces all
+ * [StatefulSpan] instances with fresh clones. This gives each [PreparedLayoutTextView] independent
+ * mutable span state (e.g. particle animation, dismiss state) even when the underlying [Layout] is
+ * shared from a cache.
+ *
+ * The mutable [Spannable] can be useful for spans which affect display, but do not alter existing
+ * layout calculations.
+ *
+ * Line metrics are delegated to [delegate] so no expensive [StaticLayout] rebuild is needed.
+ * [Layout.getText] is final and returns `mText` set by the protected constructor, so the cloned
+ * [SpannableString] is passed there directly.
+ */
+internal class MutableSpannableLayout
+private constructor(
+    private val delegate: Layout,
+    clonedText: SpannableString,
+) :
+    Layout(
+        clonedText,
+        delegate.paint,
+        delegate.width,
+        delegate.alignment,
+        delegate.spacingMultiplier,
+        delegate.spacingAdd,
+    ) {
+
+  companion object {
+    /** Returns a [MutableSpannableLayout] if [layout] contains stateful spans, else null. */
+    @OptIn(UnstableReactNativeAPI::class)
+    fun createIfNeeded(layout: Layout): MutableSpannableLayout? {
+      val spanned = layout.text as? Spanned ?: return null
+      val statefulSpans = spanned.getSpans(0, spanned.length, StatefulSpan::class.java)
+      if (statefulSpans.isEmpty()) {
+        return null
+      }
+
+      val cloned = SpannableString(spanned)
+      for (oldSpan in statefulSpans) {
+        val start = cloned.getSpanStart(oldSpan)
+        val end = cloned.getSpanEnd(oldSpan)
+        val flags = cloned.getSpanFlags(oldSpan)
+        cloned.removeSpan(oldSpan)
+        cloned.setSpan(oldSpan.clone(), start, end, flags)
+      }
+      return MutableSpannableLayout(layout, cloned)
+    }
+  }
+
+  // --- 10 abstract methods — delegate to original ---
+
+  override fun getLineCount(): Int = delegate.lineCount
+
+  override fun getLineTop(line: Int): Int = delegate.getLineTop(line)
+
+  override fun getLineDescent(line: Int): Int = delegate.getLineDescent(line)
+
+  override fun getLineStart(line: Int): Int = delegate.getLineStart(line)
+
+  override fun getLineContainsTab(line: Int): Boolean = delegate.getLineContainsTab(line)
+
+  override fun getLineDirections(line: Int): Directions = delegate.getLineDirections(line)
+
+  override fun getTopPadding(): Int = delegate.topPadding
+
+  override fun getBottomPadding(): Int = delegate.bottomPadding
+
+  override fun getEllipsisStart(line: Int): Int = delegate.getEllipsisStart(line)
+
+  override fun getEllipsisCount(line: Int): Int = delegate.getEllipsisCount(line)
+
+  override fun getParagraphDirection(line: Int): Int = delegate.getParagraphDirection(line)
+
+  // --- Non-abstract overrides for performance/correctness ---
+  // StaticLayout overrides these with optimized implementations. Delegating
+  // ensures we get the original's fast paths rather than Layout's base
+  // implementations that recompute from scratch.
+
+  override fun getEllipsizedWidth(): Int = delegate.ellipsizedWidth
+
+  override fun getLineMax(line: Int): Float = delegate.getLineMax(line)
+
+  override fun getLineWidth(line: Int): Float = delegate.getLineWidth(line)
+
+  override fun getLineLeft(line: Int): Float = delegate.getLineLeft(line)
+
+  override fun getLineRight(line: Int): Float = delegate.getLineRight(line)
+
+  // Only called by the framework on API 33+
+  @android.annotation.SuppressLint("NewApi")
+  override fun isFallbackLineSpacingEnabled(): Boolean = delegate.isFallbackLineSpacingEnabled
+}