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

package/ReactAndroid/src/main/java/com/facebook/react/shell/MainReactPackage.kt

@@ -15,6 +15,7 @@ import com.facebook.react.bridge.ModuleSpec
 import com.facebook.react.bridge.NativeModule
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.common.ClassFinder
+import com.facebook.react.common.annotations.UnstableReactNativeAPI
 import com.facebook.react.internal.featureflags.ReactNativeFeatureFlags
 import com.facebook.react.module.annotations.ReactModule
 import com.facebook.react.module.annotations.ReactModuleList
@@ -52,12 +53,13 @@ import com.facebook.react.views.progressbar.ReactProgressBarViewManager
 import com.facebook.react.views.safeareaview.ReactSafeAreaViewManager
 import com.facebook.react.views.scroll.ReactHorizontalScrollContainerViewManager
 import com.facebook.react.views.scroll.ReactHorizontalScrollViewManager
+import com.facebook.react.views.scroll.ReactNestedScrollViewManager
 import com.facebook.react.views.scroll.ReactScrollViewManager
 import com.facebook.react.views.swiperefresh.SwipeRefreshLayoutManager
 import com.facebook.react.views.switchview.ReactSwitchManager
 import com.facebook.react.views.text.PreparedLayoutTextViewManager
 import com.facebook.react.views.text.ReactTextViewManager
-import com.facebook.react.views.text.frescosupport.FrescoBasedReactTextInlineImageViewManager
+import com.facebook.react.views.text.SelectableTextViewManager
 import com.facebook.react.views.textinput.ReactTextInputManager
 import com.facebook.react.views.unimplementedview.ReactUnimplementedViewManager
 import com.facebook.react.views.view.ReactViewManager
@@ -96,6 +98,7 @@ import com.facebook.react.views.view.ReactViewManager
             WebSocketModule::class,
         ]
 )
+@OptIn(UnstableReactNativeAPI::class)
 public class MainReactPackage
 @JvmOverloads
 constructor(private val config: MainPackageConfig? = null) :
@@ -139,17 +142,18 @@ constructor(private val config: MainPackageConfig? = null) :
           ReactHorizontalScrollViewManager(),
           ReactHorizontalScrollContainerViewManager(),
           ReactProgressBarViewManager(),
-          ReactScrollViewManager(),
+          if (ReactNativeFeatureFlags.useNestedScrollViewAndroid()) ReactNestedScrollViewManager()
+          else ReactScrollViewManager(),
           ReactSwitchManager(),
           ReactSafeAreaViewManager(),
           SwipeRefreshLayoutManager(),
           // Native equivalents
-          FrescoBasedReactTextInlineImageViewManager(),
           ReactImageManager(),
           ReactModalHostManager(),
           ReactTextInputManager(),
           if (ReactNativeFeatureFlags.enablePreparedTextLayout()) PreparedLayoutTextViewManager()
           else ReactTextViewManager(),
+          SelectableTextViewManager(),
           ReactViewManager(),
           ReactUnimplementedViewManager(),
       )
@@ -173,12 +177,14 @@ constructor(private val config: MainPackageConfig? = null) :
           ReactSafeAreaViewManager.REACT_CLASS to
               ModuleSpec.viewManagerSpec { ReactSafeAreaViewManager() },
           ReactScrollViewManager.REACT_CLASS to
-              ModuleSpec.viewManagerSpec { ReactScrollViewManager() },
+              ModuleSpec.viewManagerSpec {
+                if (ReactNativeFeatureFlags.useNestedScrollViewAndroid())
+                    ReactNestedScrollViewManager()
+                else ReactScrollViewManager()
+              },
           ReactSwitchManager.REACT_CLASS to ModuleSpec.viewManagerSpec { ReactSwitchManager() },
           SwipeRefreshLayoutManager.REACT_CLASS to
               ModuleSpec.viewManagerSpec { SwipeRefreshLayoutManager() },
-          FrescoBasedReactTextInlineImageViewManager.REACT_CLASS to
-              ModuleSpec.viewManagerSpec { FrescoBasedReactTextInlineImageViewManager() },
           ReactImageManager.REACT_CLASS to ModuleSpec.viewManagerSpec { ReactImageManager() },
           ReactModalHostManager.REACT_CLASS to
               ModuleSpec.viewManagerSpec { ReactModalHostManager() },
@@ -190,6 +196,8 @@ constructor(private val config: MainPackageConfig? = null) :
                     PreparedLayoutTextViewManager()
                 else ReactTextViewManager()
               },
+          SelectableTextViewManager.REACT_CLASS to
+              ModuleSpec.viewManagerSpec { SelectableTextViewManager() },
           ReactViewManager.REACT_CLASS to ModuleSpec.viewManagerSpec { ReactViewManager() },
           ReactUnimplementedViewManager.REACT_CLASS to
               ModuleSpec.viewManagerSpec { ReactUnimplementedViewManager() },

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/BackgroundStyleApplicator.kt

@@ -20,6 +20,7 @@ import android.os.Build
 import android.view.View
 import android.widget.ImageView
 import androidx.annotation.ColorInt
+import androidx.core.graphics.withClip
 import com.facebook.react.bridge.ReadableArray
 import com.facebook.react.common.annotations.UnstableReactNativeAPI
 import com.facebook.react.internal.featureflags.ReactNativeFeatureFlags
@@ -574,36 +575,49 @@ public object BackgroundStyleApplicator {
       paddingBoxPath: Path,
       drawContent: () -> Unit,
   ) {
-    // Save the layer for Porter-Duff compositing
-    val saveCount = canvas.saveLayer(0f, 0f, view.width.toFloat(), view.height.toFloat(), null)
-
-    // Draw the content first
-    drawContent()
-
-    val maskPaint = Paint(Paint.ANTI_ALIAS_FLAG)
-    maskPaint.style = Paint.Style.FILL
+    // Clip to the view's own bounds before saveLayer. On API <= 28 hardware-accelerated canvases,
+    // the window boundary is tracked by the GPU scissor but not reflected in the canvas clip stack.
+    // Without an explicit software clip, saveLayer may allocate a buffer with uninitialized pixels
+    // beyond the GPU scissor. Adding clipRect in the view's local coordinate space forces HWUI to
+    // include it in the clip stack, ensuring saveLayer properly constrains its buffer. This clip is
+    // stable across parent transform animations since it's in the view's own coordinate space.
+    canvas.withClip(0, 0, view.width, view.height) {
+      // Save the layer for Porter-Duff compositing
+      val saveCount = canvas.saveLayer(0f, 0f, view.width.toFloat(), view.height.toFloat(), null)
+
+      // Draw the content first
+      drawContent()
+
+      val maskPaint = Paint(Paint.ANTI_ALIAS_FLAG)
+      maskPaint.style = Paint.Style.FILL
+
+      // Transparent pixels with INVERSE_WINDING only works on API 28
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+        maskPaint.xfermode = PorterDuffXfermode(PorterDuff.Mode.DST_IN)
+        maskPaint.color = Color.TRANSPARENT
+        paddingBoxPath.setFillType(Path.FillType.INVERSE_WINDING)
+        canvas.drawPath(paddingBoxPath, maskPaint)
+      } else {
+        // API < 28: Use a nested saveLayer with DST_IN compositing to mask content to the
+        // padding box path. EVEN_ODD fill + DST_OUT has rendering bugs on API 24's hardware
+        // renderer, so we avoid that technique. Instead, draw the mask shape into a separate
+        // layer; when restored with DST_IN, content is preserved only where the mask is opaque.
+        val dstInPaint = Paint()
+        dstInPaint.xfermode = PorterDuffXfermode(PorterDuff.Mode.DST_IN)
+        val maskSave =
+            canvas.saveLayer(0f, 0f, view.width.toFloat(), view.height.toFloat(), dstInPaint)
+        // Clear the layer to ensure it starts fully transparent. On API 24, saveLayer may not
+        // initialize the buffer to transparent, causing DST_IN to see non-zero alpha everywhere.
+        canvas.drawColor(Color.TRANSPARENT, PorterDuff.Mode.CLEAR)
+        maskPaint.xfermode = null
+        maskPaint.color = Color.BLACK
+        canvas.drawPath(paddingBoxPath, maskPaint)
+        canvas.restoreToCount(maskSave)
+      }
 
-    // Transparent pixels with INVERSE_WINDING only works on API 28
-    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
-      maskPaint.xfermode = PorterDuffXfermode(PorterDuff.Mode.DST_IN)
-      maskPaint.color = Color.TRANSPARENT
-      paddingBoxPath.setFillType(Path.FillType.INVERSE_WINDING)
-      canvas.drawPath(paddingBoxPath, maskPaint)
-    } else {
-      // Create an inverse path: outer rect minus the rounded rect (using even-odd fill rule)
-      val inversePath = Path()
-      inversePath.addRect(0f, 0f, view.width.toFloat(), view.height.toFloat(), Path.Direction.CW)
-      inversePath.addPath(paddingBoxPath)
-      inversePath.setFillType(Path.FillType.EVEN_ODD)
-
-      // Use DST_OUT to remove content where the mask is drawn (outside the rounded rect)
-      maskPaint.xfermode = PorterDuffXfermode(PorterDuff.Mode.DST_OUT)
-      maskPaint.color = Color.BLACK
-      canvas.drawPath(inversePath, maskPaint)
+      // Restore the layer
+      canvas.restoreToCount(saveCount)
     }
-
-    // Restore the layer
-    canvas.restoreToCount(saveCount)
   }
 
   /**

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/BaseViewManager.java

@@ -16,7 +16,6 @@ import android.view.View.OnFocusChangeListener;
 import android.view.ViewGroup;
 import android.view.ViewParent;
 import android.view.accessibility.AccessibilityEvent;
-import android.widget.TextView;
 import androidx.annotation.ColorInt;
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
@@ -31,7 +30,6 @@ import com.facebook.react.bridge.ReadableMapKeySetIterator;
 import com.facebook.react.bridge.ReadableType;
 import com.facebook.react.common.MapBuilder;
 import com.facebook.react.common.ReactConstants;
-import com.facebook.react.internal.featureflags.ReactNativeFeatureFlags;
 import com.facebook.react.uimanager.ReactAccessibilityDelegate.AccessibilityRole;
 import com.facebook.react.uimanager.ReactAccessibilityDelegate.Role;
 import com.facebook.react.uimanager.annotations.ReactProp;
@@ -81,6 +79,7 @@ public abstract class BaseViewManager<T extends View, C extends LayoutShadowNode
     // Reset tags
     view.setTag(null);
     view.setTag(R.id.pointer_events, null);
+    view.setTag(R.id.important_for_interaction, null);
     view.setTag(R.id.react_test_id, null);
     view.setTag(R.id.view_tag_native_id, null);
     view.setTag(R.id.labelled_by, null);
@@ -152,13 +151,8 @@ public abstract class BaseViewManager<T extends View, C extends LayoutShadowNode
 
     // NOTE: setClickable MUST be called AFTER setOnClickListener because
     // the latter has the side effect of setting isClickable=true on some views!
-    if (ReactNativeFeatureFlags.shouldResetOnClickListenerWhenRecyclingView()) {
-      view.setOnClickListener(null);
-    }
-    if (ReactNativeFeatureFlags.shouldResetClickableWhenRecyclingView()) {
-      view.setClickable(
-          ReactNativeFeatureFlags.shouldSetIsClickableByDefault() && !(view instanceof TextView));
-    }
+    view.setOnClickListener(null);
+    view.setClickable(false);
     view.setFocusable(false);
     view.setFocusableInTouchMode(false);
 
@@ -397,15 +391,7 @@ public abstract class BaseViewManager<T extends View, C extends LayoutShadowNode
     }
     view.setTag(R.id.accessibility_state, accessibilityState);
     if (accessibilityState.hasKey("disabled")) {
-      if (ReactNativeFeatureFlags.shouldSetEnabledBasedOnAccessibilityState()) {
-        // New behavior: properly set enabled state for both true and false
-        view.setEnabled(!accessibilityState.getBoolean("disabled"));
-      } else {
-        // Old behavior: only set enabled(true) when disabled=false
-        if (!accessibilityState.getBoolean("disabled")) {
-          view.setEnabled(true);
-        }
-      }
+      view.setEnabled(!accessibilityState.getBoolean("disabled"));
     }
 
     // For states which don't have corresponding methods in
@@ -688,7 +674,6 @@ public abstract class BaseViewManager<T extends View, C extends LayoutShadowNode
   @Override
   protected void onAfterUpdateTransaction(@NonNull T view) {
     super.onAfterUpdateTransaction(view);
-    configureClickableState(view);
     updateViewAccessibility(view);
 
     Boolean invalidateTransform = (Boolean) view.getTag(R.id.invalidate_transform);
@@ -1028,48 +1013,23 @@ public abstract class BaseViewManager<T extends View, C extends LayoutShadowNode
 
   // Please add new props to BaseViewManagerDelegate as well!
 
-  private static <T extends View> void configureClickableState(@NonNull T view) {
-    if (!ReactNativeFeatureFlags.shouldSetIsClickableByDefault()) {
-      return;
-    }
-
-    boolean shouldBeClickable;
-    if (view instanceof ReactPointerEventsView) {
-      shouldBeClickable =
-          PointerEvents.canBeTouchTarget(((ReactPointerEventsView) view).getPointerEvents());
-    } else if (view instanceof TextView) {
-      shouldBeClickable = view.hasOnClickListeners();
-    } else {
-      shouldBeClickable = true;
-    }
-
-    // NOTE: In Android O+, setClickable(true) has the side effect of setting focusable=true.
-    // We need to preserve the original focusable state to respect the focusable prop.
-    boolean wasFocusable = view.isFocusable();
-    boolean wasFocusableInTouchMode = view.isFocusableInTouchMode();
-
-    view.setClickable(shouldBeClickable);
-    view.setFocusable(wasFocusable);
-    view.setFocusableInTouchMode(wasFocusableInTouchMode);
-  }
-
   /**
    * A helper class to keep track of the original focus change listener if one is set. This is
    * especially helpful for views that are recycled so we can retain and restore the original
    * listener upon recycling (onDropViewInstance).
    */
-  private class BaseVMFocusChangeListener<V extends View> implements OnFocusChangeListener {
+  private static class BaseVMFocusChangeListener implements OnFocusChangeListener {
     private @Nullable OnFocusChangeListener mOriginalFocusChangeListener;
 
     public BaseVMFocusChangeListener(@Nullable OnFocusChangeListener originalFocusChangeListener) {
       mOriginalFocusChangeListener = originalFocusChangeListener;
     }
 
-    public void attach(T view) {
+    public void attach(View view) {
       view.setOnFocusChangeListener(this);
     }
 
-    public void detach(T view) {
+    public void detach(View view) {
       view.setOnFocusChangeListener(mOriginalFocusChangeListener);
     }
 
@@ -1085,8 +1045,7 @@ public abstract class BaseViewManager<T extends View, C extends LayoutShadowNode
       if (view.getContext() instanceof ThemedReactContext) {
         ThemedReactContext themedReactContext = (ThemedReactContext) view.getContext();
         @Nullable
-        EventDispatcher eventDispatcher =
-            UIManagerHelper.getEventDispatcherForReactTag(themedReactContext, view.getId());
+        EventDispatcher eventDispatcher = UIManagerHelper.getEventDispatcher(themedReactContext);
         if (eventDispatcher != null) {
           if (hasFocus) {
             eventDispatcher.dispatchEvent(new FocusEvent(surfaceId, view.getId()));

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/DisplayMetricsHolder.kt

@@ -7,6 +7,7 @@
 
 package com.facebook.react.uimanager
 
+import android.annotation.SuppressLint
 import android.app.Activity
 import android.content.Context
 import android.util.DisplayMetrics
@@ -61,19 +62,21 @@ public object DisplayMetricsHolder {
   }
 
   @JvmStatic
-  @Suppress("DEPRECATION")
+  @SuppressLint("DeprecatedMethod") // for Andriod Lint
+  @Suppress("DEPRECATION") // for Kotlin compiler
   public fun initDisplayMetrics(context: Context) {
     val displayMetrics = context.resources.displayMetrics
     windowDisplayMetrics = displayMetrics
     val screenDisplayMetrics = DisplayMetrics()
     screenDisplayMetrics.setTo(displayMetrics)
-    val wm = context.getSystemService(Context.WINDOW_SERVICE) as WindowManager
-    // Get the real display metrics if we are using API level 17 or higher.
-    // The real metrics include system decor elements (e.g. soft menu bar).
-    //
-    // See:
-    // http://developer.android.com/reference/android/view/Display.html#getRealMetrics(android.util.DisplayMetrics)
-    wm.defaultDisplay.getRealMetrics(screenDisplayMetrics)
+    try {
+      val wm = context.getSystemService(Context.WINDOW_SERVICE) as WindowManager
+      // getRealMetrics includes system decor (e.g. nav bar) excluded from resource metrics.
+      wm.defaultDisplay.getRealMetrics(screenDisplayMetrics)
+    } catch (_: Exception) {
+      // Non-visual contexts (e.g. Application) may throw on API 30+.
+      // Falls back to resource display metrics copied via setTo() above.
+    }
     // Preserve fontScale from the configuration because getRealMetrics() returns
     // physical display metrics without the system font scale setting.
     // This is needed for proper text scaling when fontScale < 1.0

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/GuardedFrameCallback.kt

@@ -14,12 +14,29 @@ import com.facebook.react.bridge.ReactContext
 /**
  * Abstract base for a Choreographer FrameCallback that should have any RuntimeExceptions it throws
  * handled by the [JSExceptionHandler] registered if the app is in dev mode.
+ *
+ * @property exceptionHandler The handler for RuntimeExceptions thrown during frame callbacks.
+ * @constructor Creates a GuardedFrameCallback with the specified exception handler.
  */
 public abstract class GuardedFrameCallback
 protected constructor(private val exceptionHandler: JSExceptionHandler) :
     Choreographer.FrameCallback {
+  /**
+   * Creates a GuardedFrameCallback using the exception handler from the provided ReactContext.
+   *
+   * @param reactContext The React context whose exception handler will be used.
+   */
   protected constructor(reactContext: ReactContext) : this(reactContext.exceptionHandler)
 
+  /**
+   * Choreographer frame callback implementation that guards [doFrameGuarded] with exception
+   * handling.
+   *
+   * Wraps calls to [doFrameGuarded] in a try-catch block. Any RuntimeExceptions thrown are caught
+   * and passed to the exception handler instead of crashing the app.
+   *
+   * @param frameTimeNanos The time in nanoseconds when the frame started being rendered.
+   */
   public override fun doFrame(frameTimeNanos: Long) {
     try {
       doFrameGuarded(frameTimeNanos)

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/JSPointerDispatcher.java

@@ -55,8 +55,7 @@ public class JSPointerDispatcher {
   private final ViewGroup mRootViewGroup;
 
   private static final int[] sRootScreenCoords = {0, 0};
-
-  // Set globally for hover interactions, referenced for coalescing hover events
+  private static final Rect sChildCoords = new Rect(0, 0, 1, 1);
 
   public JSPointerDispatcher(ViewGroup viewGroup) {
     mRootViewGroup = viewGroup;
@@ -659,9 +658,9 @@ public class JSPointerDispatcher {
 
         // cancel events need to report client coordinates of (0, 0) and offset coordinates relative
         // to the root view
-        int[] childOffset = getChildOffsetRelativeToRoot(targetView);
+        Rect childOffset = getChildOffsetRelativeToRoot(targetView);
         PointerEventState normalizedEventState =
-            normalizeToRoot(eventState, childOffset[0], childOffset[1]);
+            normalizeToRoot(eventState, childOffset.left, childOffset.top);
         Assertions.assertNotNull(eventDispatcher)
             .dispatchEvent(
                 PointerEvent.obtain(
@@ -677,10 +676,16 @@ public class JSPointerDispatcher {
   }
 
   // returns child (0, 0) relative to root coordinate system
-  private int[] getChildOffsetRelativeToRoot(View childView) {
-    Rect childCoords = new Rect(0, 0, 1, 1);
-    mRootViewGroup.offsetDescendantRectToMyCoords(childView, childCoords);
-    return new int[] {childCoords.top, childCoords.left};
+  private Rect getChildOffsetRelativeToRoot(View childView) {
+    sChildCoords.set(0, 0, 1, 1);
+    if (childView.getRootView() != mRootViewGroup.getRootView()) {
+      // NOTE: if we are here it means the target view has been reparented, so we can't call
+      // mRootViewGroup.offsetDescendantRectToMyCoords because an exception will be thrown.
+      // We still return (0, 0) to ensure the cancel event is dispatched.
+      return sChildCoords;
+    }
+    mRootViewGroup.offsetDescendantRectToMyCoords(childView, sChildCoords);
+    return sChildCoords;
   }
 
   // Returns a copy of `original` with coordinates zeroed relative to the provided root coordinates.