react-native-tvos 0.79.2-0 → 0.80.0-0

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

@@ -346,11 +346,16 @@ public object BackgroundStyleApplicator {
 
   @JvmStatic
   public fun clipToPaddingBox(view: View, canvas: Canvas): Unit {
-    // The canvas may be scrolled, so we need to offset
     if (ReactNativeFeatureFlags.enableNewBackgroundAndBorderDrawables()) {
       val drawingRect = Rect()
       view.getDrawingRect(drawingRect)
-      val composite = ensureCompositeBackgroundDrawable(view)
+
+      val composite = getCompositeBackgroundDrawable(view)
+      if (composite == null) {
+        canvas.clipRect(drawingRect)
+        return
+      }
+
       val paddingBoxRect = RectF()
 
       val computedBorderInsets =

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

@@ -12,6 +12,7 @@ import android.graphics.Paint;
 import android.os.Build;
 import android.text.TextUtils;
 import android.view.View;
+import android.view.ViewGroup;
 import android.view.ViewParent;
 import android.view.accessibility.AccessibilityEvent;
 import androidx.annotation.ColorInt;
@@ -28,6 +29,7 @@ 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;
@@ -282,9 +284,64 @@ public abstract class BaseViewManager<T extends View, C extends LayoutShadowNode
   @ReactProp(name = ViewProps.NATIVE_ID)
   public void setNativeId(@NonNull T view, @Nullable String nativeId) {
     view.setTag(R.id.view_tag_native_id, nativeId);
+
+    /*
+     * If we change the nativeId we need to notify the relevant accessibility parent to update the
+     * focusing order.
+     */
+    if (view.getTag(R.id.accessibility_order_parent) != null) {
+      ViewGroup accessibilityParent = (ViewGroup) view.getTag(R.id.accessibility_order_parent);
+
+      ReactAxOrderHelper.unsetAccessibilityOrder(accessibilityParent);
+      accessibilityParent.setTag(R.id.accessibility_order_dirty, true);
+
+      accessibilityParent.notifySubtreeAccessibilityStateChanged(
+          accessibilityParent, accessibilityParent, AccessibilityEvent.CONTENT_CHANGE_TYPE_SUBTREE);
+    }
+
     ReactFindViewUtil.notifyViewRendered(view);
   }
 
+  @ReactProp(name = ViewProps.ACCESSIBILITY_ORDER)
+  public void setAccessibilityOrder(@NonNull T view, @Nullable ReadableArray nativeIds) {
+    if (!ReactNativeFeatureFlags.enableAccessibilityOrder()) {
+      return;
+    }
+
+    view.setTag(R.id.accessibility_order, nativeIds);
+    view.setTag(R.id.accessibility_order_dirty, true);
+
+    if (view instanceof ViewGroup) {
+      ((ViewGroup) view)
+          .setOnHierarchyChangeListener(
+              new ViewGroup.OnHierarchyChangeListener() {
+                @Override
+                public void onChildViewAdded(View parent, View child) {
+                  view.setTag(R.id.accessibility_order_dirty, true);
+
+                  // We also want to listen to changes on the hierarchy of nested ViewGroups
+                  if (child instanceof ViewGroup) {
+                    ViewGroup childGroup = (ViewGroup) child;
+                    childGroup.setOnHierarchyChangeListener(this);
+                    for (int i = 0; i < childGroup.getChildCount(); i++) {
+                      onChildViewAdded(childGroup, childGroup.getChildAt(i));
+                    }
+                  }
+                }
+
+                @Override
+                public void onChildViewRemoved(View parent, View child) {
+                  view.setTag(R.id.accessibility_order_dirty, true);
+                }
+              });
+    }
+
+    ReactAxOrderHelper.unsetAccessibilityOrder(view);
+    ((ViewGroup) view)
+        .notifySubtreeAccessibilityStateChanged(
+            view, view, AccessibilityEvent.CONTENT_CHANGE_TYPE_SUBTREE);
+  }
+
   @ReactProp(name = ViewProps.ACCESSIBILITY_LABELLED_BY)
   public void setAccessibilityLabelledBy(@NonNull T view, @Nullable Dynamic nativeId) {
     if (nativeId.isNull()) {
@@ -456,6 +513,13 @@ public abstract class BaseViewManager<T extends View, C extends LayoutShadowNode
     }
   }
 
+  @ReactProp(name = ViewProps.SCREEN_READER_FOCUSABLE)
+  public void setScreenReaderFocusable(@NonNull T view, boolean screenReaderFocusable) {
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+      view.setScreenReaderFocusable(screenReaderFocusable);
+    }
+  }
+
   @ReactProp(name = ViewProps.ROLE)
   public void setRole(@NonNull T view, @Nullable String role) {
     if (role == null) {

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

@@ -46,8 +46,7 @@ public abstract class BaseViewManagerDelegate<
           mViewManager.setAccessibilityValue(view, value as ReadableMap?)
 
       ViewProps.BACKGROUND_COLOR ->
-          mViewManager.setBackgroundColor(
-              view, if (value == null) 0 else ColorPropConverter.getColor(value, view.context))
+          mViewManager.setBackgroundColor(view, ColorPropConverter.getColor(value, view.context, 0))
 
       ViewProps.BORDER_RADIUS ->
           mViewManager.setBorderRadius(
@@ -78,19 +77,22 @@ public abstract class BaseViewManagerDelegate<
       ViewProps.MIX_BLEND_MODE -> mViewManager.setMixBlendMode(view, value as String?)
 
       ViewProps.SHADOW_COLOR ->
-          mViewManager.setShadowColor(
-              view, if (value == null) 0 else ColorPropConverter.getColor(value, view.context))
+          mViewManager.setShadowColor(view, ColorPropConverter.getColor(value, view.context, 0))
 
       ViewProps.IMPORTANT_FOR_ACCESSIBILITY ->
           mViewManager.setImportantForAccessibility(view, value as String?)
 
+      ViewProps.SCREEN_READER_FOCUSABLE ->
+          mViewManager.setScreenReaderFocusable(view, value as Boolean? ?: false)
+
       ViewProps.ROLE -> mViewManager.setRole(view, value as String?)
       ViewProps.NATIVE_ID -> mViewManager.setNativeId(view, value as String?)
       ViewProps.ACCESSIBILITY_LABELLED_BY -> {
         val dynamicFromObject: Dynamic = DynamicFromObject(value)
         mViewManager.setAccessibilityLabelledBy(view, dynamicFromObject)
       }
-
+      ViewProps.ACCESSIBILITY_ORDER ->
+          mViewManager.setAccessibilityOrder(view, value as ReadableArray?)
       ViewProps.OPACITY -> mViewManager.setOpacity(view, (value as Double?)?.toFloat() ?: 1.0f)
 
       ViewProps.OUTLINE_COLOR -> mViewManager.setOutlineColor(view, value as Int?)

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

@@ -17,7 +17,7 @@ import com.facebook.react.R
 @TargetApi(29)
 internal object BlendModeHelper {
 
-  /** @see https://www.w3.org/TR/compositing-1/#mix-blend-mode */
+  /** @see <a href="https://www.w3.org/TR/compositing-1/#mix-blend-mode">mix-blend-mode</a> */
   @JvmStatic
   fun parseMixBlendMode(mixBlendMode: String?): BlendMode? {
     if (mixBlendMode == null || Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {

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

@@ -12,5 +12,5 @@ import com.facebook.proguard.annotations.DoNotStripAny
 @DoNotStripAny
 internal interface ComponentNameResolver {
   /* returns a list of all the component names that are registered in React Native. */
-  val componentNames: Array<String>?
+  val componentNames: Array<String>
 }

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

@@ -8,9 +8,11 @@
 package com.facebook.react.uimanager;
 
 import android.graphics.Rect;
+import android.view.Choreographer;
 import android.view.MotionEvent;
 import android.view.View;
 import android.view.ViewGroup;
+import androidx.annotation.Nullable;
 import com.facebook.common.logging.FLog;
 import com.facebook.infer.annotation.Assertions;
 import com.facebook.react.common.ReactConstants;
@@ -44,12 +46,14 @@ public class JSPointerDispatcher {
   private Map<Integer, List<ViewTarget>> mLastHitPathByPointerId;
   private Map<Integer, float[]> mLastEventCoordinatesByPointerId;
   private Map<Integer, List<ViewTarget>> mCurrentlyDownPointerIdsToHitPath;
-  private Set<Integer> mHoveringPointerIds = new HashSet<>();
+  private final Set<Integer> mHoveringPointerIds = new HashSet<>();
 
   private int mChildHandlingNativeGesture = UNSET_CHILD_VIEW_ID;
   private int mPrimaryPointerId = UNSET_POINTER_ID;
   private int mCoalescingKey = 0;
   private int mLastButtonState = 0;
+  private volatile long mLastActionDownEventTime = 0;
+  private boolean mRunHoverExitNextFrame = true;
   private final ViewGroup mRootViewGroup;
 
   private static final int[] sRootScreenCoords = {0, 0};
@@ -62,7 +66,7 @@ public class JSPointerDispatcher {
   }
 
   public void onChildStartedNativeGesture(
-      View childView, MotionEvent motionEvent, EventDispatcher eventDispatcher) {
+      @Nullable View childView, MotionEvent motionEvent, EventDispatcher eventDispatcher) {
     if (mChildHandlingNativeGesture != UNSET_CHILD_VIEW_ID || childView == null) {
       // This means we previously had another child start handling this native gesture and now a
       // different native parent of that child has decided to intercept the touch stream and handle
@@ -285,9 +289,54 @@ public class JSPointerDispatcher {
       return;
     }
 
+    /**
+     * Android does not provide a consistent mechanism for determining if a MotionEvent is outside
+     * the bounds of a view. It fires ACTION_HOVER_EXIT in two cases:
+     *
+     * <ol>
+     *   <li>If the cursor leaves the bounds of the view
+     *   <li>If the user presses a button
+     * </ol>
+     *
+     * <p>Some OS will fire ACTION_HOVER_EXIT on the frame before the cursor leaves the bounds of
+     * the view, while others will fire it on the frame after the cursor leaves the bounds of the
+     * view, so using bounds is not sufficient. Some OS will include the button state in the
+     * ACTION_HOVER_EXIT event while others will not, so using button state is not sufficient.
+     * Instead, we must wait for both the ACTION_HOVER_EXIT and ACTION_DOWN events to fire, and then
+     * compare their event times to determine if the ACTION_HOVER_EXIT event was triggered by the
+     * cursor leaving the bounds of the view or by a button press. If no ACTION_DOWN event has fired
+     * by the next frame, we know that the cursor has left the bounds of the root view.
+     *
+     * <p>As ACTION_DOWN fires after ACTION_HOVER_EXIT, we need to wait until the next frame to make
+     * this determination. We do this by posting a frame callback to the choreographer and
+     * re-running this method on the next frame should timestamps between the two events not align.
+     */
+    if (isCapture
+        && mRunHoverExitNextFrame
+        && motionEvent.getActionMasked() == MotionEvent.ACTION_HOVER_EXIT) {
+      mRunHoverExitNextFrame = false;
+      Choreographer.getInstance()
+          .postFrameCallback(
+              new Choreographer.FrameCallback() {
+                @Override
+                public void doFrame(long frameTimeNanos) {
+                  if (mLastActionDownEventTime != motionEvent.getEventTime()) {
+                    handleMotionEventHelper(motionEvent, eventDispatcher, isCapture);
+                  }
+                  mRunHoverExitNextFrame = true;
+                }
+              });
+    } else {
+      handleMotionEventHelper(motionEvent, eventDispatcher, isCapture);
+    }
+  }
+
+  private void handleMotionEventHelper(
+      MotionEvent motionEvent, EventDispatcher eventDispatcher, boolean isCapture) {
     int action = motionEvent.getActionMasked();
     int activePointerId = motionEvent.getPointerId(motionEvent.getActionIndex());
     if (action == MotionEvent.ACTION_DOWN) {
+      mLastActionDownEventTime = motionEvent.getEventTime();
       mPrimaryPointerId = motionEvent.getPointerId(0);
     } else if (action == MotionEvent.ACTION_HOVER_MOVE) {
       mHoveringPointerIds.add(activePointerId);
@@ -296,13 +345,16 @@ public class JSPointerDispatcher {
     PointerEventState eventState = createEventState(activePointerId, motionEvent);
 
     // We've empirically determined that when we get a ACTION_HOVER_EXIT from the root view on the
-    // `onInterceptHoverEvent`, this means we've exited the root view.
-    // This logic may be wrong but reasoning about the dispatch sequence for HOVER_ENTER/HOVER_EXIT
-    // doesn't follow the capture/bubbling sequence like other MotionEvents. See:
+    // `onInterceptHoverEvent`, this means we've exited the root view. This logic may be wrong but
+    // reasoning about the dispatch sequence for HOVER_ENTER/HOVER_EXIT doesn't follow the
+    // capture/bubbling sequence like other MotionEvents.
+    //
+    // The choreographer logic above is a hack to try to work around this, but it's not perfect.
+    //
+    // For more information, see:
     // https://developer.android.com/reference/android/view/MotionEvent#ACTION_HOVER_ENTER
     // https://suragch.medium.com/how-touch-events-are-delivered-in-android-eee3b607b038
-    boolean isExitFromRoot =
-        isCapture && motionEvent.getActionMasked() == MotionEvent.ACTION_HOVER_EXIT;
+    boolean isExitFromRoot = isCapture && action == MotionEvent.ACTION_HOVER_EXIT;
 
     // Calculate the targetTag, with special handling for when we exit the root view. In that case,
     // we use the root viewId of the last event

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

@@ -8,9 +8,16 @@
 package com.facebook.react.uimanager
 
 import android.view.View
+import com.facebook.react.common.annotations.internal.LegacyArchitecture
+import com.facebook.react.common.annotations.internal.LegacyArchitectureLogger
 import com.facebook.yoga.YogaDirection
 
+@LegacyArchitecture
 internal object LayoutDirectionUtil {
+  init {
+    LegacyArchitectureLogger.assertLegacyArchitecture("LayoutDirectionUtil")
+  }
+
   @JvmStatic
   fun toAndroidFromYoga(direction: YogaDirection): Int =
       when (direction) {

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

@@ -12,6 +12,9 @@ import com.facebook.common.logging.FLog;
 import com.facebook.react.bridge.Dynamic;
 import com.facebook.react.bridge.ReadableType;
 import com.facebook.react.common.ReactConstants;
+import com.facebook.react.common.annotations.internal.LegacyArchitecture;
+import com.facebook.react.common.annotations.internal.LegacyArchitectureLogLevel;
+import com.facebook.react.common.annotations.internal.LegacyArchitectureLogger;
 import com.facebook.react.modules.i18nmanager.I18nUtil;
 import com.facebook.react.uimanager.annotations.ReactProp;
 import com.facebook.react.uimanager.annotations.ReactPropGroup;
@@ -34,7 +37,12 @@ import com.facebook.yoga.YogaWrap;
  * may or may not be embedded in a parent text. There are better solutions that should probably be
  * explored, namely using the VirtualText class in JS and setting the correct set of validAttributes
  */
+@LegacyArchitecture
 public class LayoutShadowNode extends ReactShadowNodeImpl {
+  static {
+    LegacyArchitectureLogger.assertLegacyArchitecture(
+        "LayoutShadowNode", LegacyArchitectureLogLevel.WARNING);
+  }
 
   /** A Mutable version of com.facebook.yoga.YogaValue */
   private static class MutableYogaValue {

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

@@ -11,7 +11,6 @@ import com.facebook.common.logging.FLog
 import com.facebook.react.bridge.Dynamic
 import com.facebook.react.bridge.ReadableType
 import com.facebook.react.common.ReactConstants
-import com.facebook.react.uimanager.style.CornerRadii
 import java.lang.NumberFormatException
 
 public enum class LengthPercentageType {
@@ -37,7 +36,7 @@ public data class LengthPercentage(
         }
         ReadableType.String -> {
           val s = dynamic.asString()
-          if (s.endsWith("%")) {
+          if (s != null && s.endsWith("%")) {
             try {
               val value = s.substring(0, s.length - 1).toFloat()
               if (value >= 0f) {
@@ -62,14 +61,6 @@ public data class LengthPercentage(
     }
   }
 
-  public fun resolve(width: Float, height: Float): CornerRadii {
-    if (type == LengthPercentageType.PERCENT) {
-      return CornerRadii((value / 100) * width, (value / 100) * height)
-    }
-
-    return CornerRadii(value, value)
-  }
-
   public fun resolve(referenceLength: Float): Float {
     if (type == LengthPercentageType.PERCENT) {
       return (value / 100) * referenceLength

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

@@ -7,10 +7,12 @@
 
 package com.facebook.react.uimanager
 
+import com.facebook.react.common.annotations.internal.LegacyArchitecture
+
 // Common conditionals:
 //   - `kind == PARENT` checks whether the node can host children in the native tree.
 //   - `kind != NONE` checks whether the node appears in the native tree.
-
+@LegacyArchitecture
 internal enum class NativeKind {
   // Node is in the native hierarchy and the HierarchyOptimizer should assume it can host children
   // (e.g. because it's a ViewGroup). Note that it's okay if the node doesn't support children. When

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

@@ -26,6 +26,9 @@ import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.bridge.RetryableMountingLayerException;
 import com.facebook.react.bridge.SoftAssertions;
 import com.facebook.react.bridge.UiThreadUtil;
+import com.facebook.react.common.annotations.internal.LegacyArchitecture;
+import com.facebook.react.common.annotations.internal.LegacyArchitectureLogLevel;
+import com.facebook.react.common.annotations.internal.LegacyArchitectureLogger;
 import com.facebook.react.common.build.ReactBuildConfig;
 import com.facebook.react.touch.JSResponderHandler;
 import com.facebook.react.uimanager.layoutanimation.LayoutAnimationController;
@@ -64,8 +67,14 @@ import javax.annotation.concurrent.NotThreadSafe;
  * <p>TODO(5483031): Only dispatch updates when shadow views have changed
  */
 @NotThreadSafe
+@LegacyArchitecture
 public class NativeViewHierarchyManager {
 
+  static {
+    LegacyArchitectureLogger.assertLegacyArchitecture(
+        "NativeViewHierarchyManager", LegacyArchitectureLogLevel.WARNING);
+  }
+
   private static final String TAG = NativeViewHierarchyManager.class.getSimpleName();
   private final boolean DEBUG_MODE = ReactBuildConfig.DEBUG && false;
 
@@ -170,7 +179,7 @@ public class NativeViewHierarchyManager {
     }
     UiThreadUtil.assertOnUiThread();
     SystraceMessage.beginSection(
-            Systrace.TRACE_TAG_REACT_VIEW, "NativeViewHierarchyManager_updateLayout")
+            Systrace.TRACE_TAG_REACT, "NativeViewHierarchyManager_updateLayout")
         .arg("parentTag", parentTag)
         .arg("tag", tag)
         .flush();
@@ -233,7 +242,7 @@ public class NativeViewHierarchyManager {
         updateLayout(viewToUpdate, x, y, width, height);
       }
     } finally {
-      Systrace.endSection(Systrace.TRACE_TAG_REACT_VIEW);
+      Systrace.endSection(Systrace.TRACE_TAG_REACT);
     }
   }
 
@@ -277,8 +286,7 @@ public class NativeViewHierarchyManager {
           (initialProps != null ? initialProps.toString() : "<null>"));
     }
     UiThreadUtil.assertOnUiThread();
-    SystraceMessage.beginSection(
-            Systrace.TRACE_TAG_REACT_VIEW, "NativeViewHierarchyManager_createView")
+    SystraceMessage.beginSection(Systrace.TRACE_TAG_REACT, "NativeViewHierarchyManager_createView")
         .arg("tag", tag)
         .arg("className", className)
         .flush();
@@ -290,7 +298,7 @@ public class NativeViewHierarchyManager {
       mTagsToViews.put(tag, view);
       mTagsToViewManagers.put(tag, viewManager);
     } finally {
-      Systrace.endSection(Systrace.TRACE_TAG_REACT_VIEW);
+      Systrace.endSection(Systrace.TRACE_TAG_REACT);
     }
   }
 

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

@@ -13,6 +13,9 @@ import com.facebook.common.logging.FLog;
 import com.facebook.infer.annotation.Assertions;
 import com.facebook.react.bridge.ReadableArray;
 import com.facebook.react.bridge.ReadableMapKeySetIterator;
+import com.facebook.react.common.annotations.internal.LegacyArchitecture;
+import com.facebook.react.common.annotations.internal.LegacyArchitectureLogLevel;
+import com.facebook.react.common.annotations.internal.LegacyArchitectureLogger;
 
 /**
  * Class responsible for optimizing the native view hierarchy while still respecting the final UI
@@ -45,8 +48,14 @@ import com.facebook.react.bridge.ReadableMapKeySetIterator;
  * manageChildren calls for various parent views may be issued to the native view hierarchy
  * depending on where the views being added/removed are attached in the optimized hierarchy
  */
+@LegacyArchitecture
 public class NativeViewHierarchyOptimizer {
 
+  static {
+    LegacyArchitectureLogger.assertLegacyArchitecture(
+        "NativeViewHierarchyOptimizer", LegacyArchitectureLogLevel.WARNING);
+  }
+
   private static final String TAG = "NativeViewHierarchyOptimizer";
 
   private static class NodeIndexPair {
@@ -453,9 +462,9 @@ public class NativeViewHierarchyOptimizer {
       return false;
     }
 
-    ReadableMapKeySetIterator keyIterator = props.mBackingMap.keySetIterator();
+    ReadableMapKeySetIterator keyIterator = props.internal_backingMap().keySetIterator();
     while (keyIterator.hasNextKey()) {
-      if (!ViewProps.isLayoutOnly(props.mBackingMap, keyIterator.nextKey())) {
+      if (!ViewProps.isLayoutOnly(props.internal_backingMap(), keyIterator.nextKey())) {
         return false;
       }
     }

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

@@ -7,9 +7,20 @@
 
 package com.facebook.react.uimanager
 
+import com.facebook.react.common.annotations.internal.LegacyArchitecture
+import com.facebook.react.common.annotations.internal.LegacyArchitectureLogger
+
 /**
  * Exception thrown when a class tries to access a native view by a tag that has no native view
  * associated with it.
  */
+@LegacyArchitecture
 internal class NoSuchNativeViewException(detailMessage: String) :
-    IllegalViewOperationException(detailMessage)
+    IllegalViewOperationException(detailMessage) {
+
+  private companion object {
+    init {
+      LegacyArchitectureLogger.assertLegacyArchitecture("NoSuchNativeViewException")
+    }
+  }
+}

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

@@ -0,0 +1,93 @@
+/*
+ * 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.uimanager
+
+import androidx.core.util.Pools.SynchronizedPool
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.common.annotations.VisibleForTesting
+import com.facebook.react.common.annotations.internal.LegacyArchitecture
+import com.facebook.react.common.annotations.internal.LegacyArchitectureLogLevel
+import com.facebook.react.common.annotations.internal.LegacyArchitectureLogger
+import com.facebook.react.uimanager.PixelUtil.toDIPFromPixel
+import com.facebook.react.uimanager.events.Event
+
+/** Event used to notify JS component about changes of its position or dimensions. */
+@LegacyArchitecture
+public class OnLayoutEvent private constructor() : Event<OnLayoutEvent>() {
+  @VisibleForTesting internal var x: Int = 0
+  @VisibleForTesting internal var y: Int = 0
+  @VisibleForTesting internal var width: Int = 0
+  @VisibleForTesting internal var height: Int = 0
+
+  override fun onDispose() {
+    EVENTS_POOL.release(this)
+  }
+
+  protected fun init(surfaceId: Int, viewTag: Int, x: Int, y: Int, width: Int, height: Int) {
+    super.init(surfaceId, viewTag)
+    this.x = x
+    this.y = y
+    this.width = width
+    this.height = height
+  }
+
+  override fun getEventName(): String = "topLayout"
+
+  override fun getEventData(): WritableMap {
+    val layout =
+        Arguments.createMap().apply {
+          putDouble("x", toDIPFromPixel(x.toFloat()).toDouble())
+          putDouble("y", toDIPFromPixel(y.toFloat()).toDouble())
+          putDouble("width", toDIPFromPixel(width.toFloat()).toDouble())
+          putDouble("height", toDIPFromPixel(height.toFloat()).toDouble())
+        }
+
+    val event =
+        Arguments.createMap().apply {
+          putMap("layout", layout)
+          putInt("target", viewTag)
+        }
+
+    return event
+  }
+
+  public companion object {
+    init {
+      LegacyArchitectureLogger.assertLegacyArchitecture(
+          "OnLayoutEvent", LegacyArchitectureLogLevel.WARNING)
+    }
+
+    private val EVENTS_POOL: SynchronizedPool<OnLayoutEvent> = SynchronizedPool<OnLayoutEvent>(20)
+
+    @Deprecated(
+        "Use `obtain(surfaceId, viewTag, x, y, width, height)` instead.",
+        ReplaceWith("obtain(surfaceId, viewTag, x, y, width, height)"))
+    @JvmStatic
+    public fun obtain(viewTag: Int, x: Int, y: Int, width: Int, height: Int): OnLayoutEvent {
+      return obtain(-1, viewTag, x, y, width, height)
+    }
+
+    @JvmStatic
+    public fun obtain(
+        surfaceId: Int,
+        viewTag: Int,
+        x: Int,
+        y: Int,
+        width: Int,
+        height: Int
+    ): OnLayoutEvent {
+      var event: OnLayoutEvent? = EVENTS_POOL.acquire()
+      if (event == null) {
+        event = OnLayoutEvent()
+      }
+      event.init(surfaceId, viewTag, x, y, width, height)
+      return event
+    }
+  }
+}

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

@@ -63,7 +63,7 @@ public object PixelUtil {
     return value / DisplayMetricsHolder.getWindowDisplayMetrics().density
   }
 
-  /** @return [float] that represents the density of the display metrics for device screen. */
+  /** @return [Float] that represents the density of the display metrics for device screen. */
   @JvmStatic
   public fun getDisplayMetricDensity(): Float =
       DisplayMetricsHolder.getWindowDisplayMetrics().density

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

@@ -108,6 +108,8 @@ public class ReactAccessibilityDelegate extends ExploreByTouchHelper {
     // problems, so leave it alone.
     if (!ViewCompat.hasAccessibilityDelegate(view)
         && (view.getTag(R.id.accessibility_role) != null
+            || view.getTag(R.id.accessibility_order) != null
+            || view.getTag(R.id.accessibility_order_parent) != null
             || view.getTag(R.id.accessibility_state) != null
             || view.getTag(R.id.accessibility_actions) != null
             || view.getTag(R.id.react_test_id) != null
@@ -136,6 +138,19 @@ public class ReactAccessibilityDelegate extends ExploreByTouchHelper {
   @Override
   public void onInitializeAccessibilityNodeInfo(View host, AccessibilityNodeInfoCompat info) {
     super.onInitializeAccessibilityNodeInfo(host, info);
+
+    if (host.getTag(R.id.accessibility_order_dirty) != null) {
+      boolean isAxOrderDirty = (boolean) host.getTag(R.id.accessibility_order_dirty);
+      if (isAxOrderDirty) {
+        ReactAxOrderHelper.setCustomAccessibilityFocusOrder(host);
+        host.setTag(R.id.accessibility_order_dirty, false);
+      }
+    }
+
+    if (host.getTag(R.id.accessibility_order_flow_to) != null) {
+      ReactAxOrderHelper.applyFlowToTraversal(host, info);
+    }
+
     if (host.getTag(R.id.accessibility_state_expanded) != null) {
       final boolean accessibilityStateExpanded =
           (boolean) host.getTag(R.id.accessibility_state_expanded);
@@ -329,7 +344,7 @@ public class ReactAccessibilityDelegate extends ExploreByTouchHelper {
                 }
 
                 @Override
-                protected WritableMap getEventData() {
+                public WritableMap getEventData() {
                   return event;
                 }
               });