react-native 0.68.2 → 0.69.0-rc.2

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

@@ -8,19 +8,27 @@
 package com.facebook.react.uimanager;
 
 import android.content.Context;
+import android.graphics.Paint;
+import android.graphics.Rect;
 import android.os.Bundle;
 import android.os.Handler;
 import android.os.Message;
-import android.text.SpannableString;
-import android.text.style.URLSpan;
+import android.text.Layout;
+import android.text.Spannable;
+import android.text.Spanned;
+import android.text.style.AbsoluteSizeSpan;
+import android.text.style.ClickableSpan;
 import android.view.View;
 import android.view.accessibility.AccessibilityEvent;
+import android.widget.TextView;
+import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
-import androidx.core.view.AccessibilityDelegateCompat;
 import androidx.core.view.ViewCompat;
 import androidx.core.view.accessibility.AccessibilityNodeInfoCompat;
 import androidx.core.view.accessibility.AccessibilityNodeInfoCompat.AccessibilityActionCompat;
 import androidx.core.view.accessibility.AccessibilityNodeInfoCompat.RangeInfoCompat;
+import androidx.core.view.accessibility.AccessibilityNodeProviderCompat;
+import androidx.customview.widget.ExploreByTouchHelper;
 import com.facebook.react.R;
 import com.facebook.react.bridge.Arguments;
 import com.facebook.react.bridge.Dynamic;
@@ -36,13 +44,15 @@ import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.uimanager.events.Event;
 import com.facebook.react.uimanager.events.EventDispatcher;
 import com.facebook.react.uimanager.util.ReactFindViewUtil;
+import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.List;
 
 /**
  * Utility class that handles the addition of a "role" for accessibility to either a View or
  * AccessibilityNodeInfo.
  */
-public class ReactAccessibilityDelegate extends AccessibilityDelegateCompat {
+public class ReactAccessibilityDelegate extends ExploreByTouchHelper {
 
   private static final String TAG = "ReactAccessibilityDelegate";
   public static final String TOP_ACCESSIBILITY_ACTION_EVENT = "topAccessibilityAction";
@@ -59,6 +69,9 @@ public class ReactAccessibilityDelegate extends AccessibilityDelegateCompat {
     sActionIdMap.put("decrement", AccessibilityActionCompat.ACTION_SCROLL_BACKWARD.getId());
   }
 
+  private final View mView;
+  private final AccessibilityLinks mAccessibilityLinks;
+
   private Handler mHandler;
 
   /**
@@ -179,8 +192,10 @@ public class ReactAccessibilityDelegate extends AccessibilityDelegateCompat {
   private static final String STATE_SELECTED = "selected";
   private static final String STATE_CHECKED = "checked";
 
-  public ReactAccessibilityDelegate() {
-    super();
+  public ReactAccessibilityDelegate(
+      final View view, boolean originalFocus, int originalImportantForAccessibility) {
+    super(view);
+    mView = view;
     mAccessibilityActionsMap = new HashMap<Integer, String>();
     mHandler =
         new Handler() {
@@ -190,6 +205,14 @@ public class ReactAccessibilityDelegate extends AccessibilityDelegateCompat {
             host.sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_SELECTED);
           }
         };
+
+    // We need to reset these two properties, as ExploreByTouchHelper sets focusable to "true" and
+    // importantForAccessibility to "Yes" (if it is Auto). If we don't reset these it would force
+    // every element that has this delegate attached to be focusable, and not allow for
+    // announcement coalescing.
+    mView.setFocusable(originalFocus);
+    ViewCompat.setImportantForAccessibility(mView, originalImportantForAccessibility);
+    mAccessibilityLinks = (AccessibilityLinks) mView.getTag(R.id.accessibility_links);
   }
 
   @Nullable View mAccessibilityLabelledBy;
@@ -388,18 +411,6 @@ public class ReactAccessibilityDelegate extends AccessibilityDelegateCompat {
     nodeInfo.setClassName(AccessibilityRole.getValue(role));
     if (role.equals(AccessibilityRole.LINK)) {
       nodeInfo.setRoleDescription(context.getString(R.string.link_description));
-
-      if (nodeInfo.getContentDescription() != null) {
-        SpannableString spannable = new SpannableString(nodeInfo.getContentDescription());
-        spannable.setSpan(new URLSpan(""), 0, spannable.length(), 0);
-        nodeInfo.setContentDescription(spannable);
-      }
-
-      if (nodeInfo.getText() != null) {
-        SpannableString spannable = new SpannableString(nodeInfo.getText());
-        spannable.setSpan(new URLSpan(""), 0, spannable.length(), 0);
-        nodeInfo.setText(spannable);
-      }
     } else if (role.equals(AccessibilityRole.IMAGE)) {
       nodeInfo.setRoleDescription(context.getString(R.string.image_description));
     } else if (role.equals(AccessibilityRole.IMAGEBUTTON)) {
@@ -445,7 +456,8 @@ public class ReactAccessibilityDelegate extends AccessibilityDelegateCompat {
     }
   }
 
-  public static void setDelegate(final View view) {
+  public static void setDelegate(
+      final View view, boolean originalFocus, int originalImportantForAccessibility) {
     // if a view already has an accessibility delegate, replacing it could cause
     // problems,
     // so leave it alone.
@@ -453,8 +465,240 @@ public class ReactAccessibilityDelegate extends AccessibilityDelegateCompat {
         && (view.getTag(R.id.accessibility_role) != null
             || view.getTag(R.id.accessibility_state) != null
             || view.getTag(R.id.accessibility_actions) != null
-            || view.getTag(R.id.react_test_id) != null)) {
-      ViewCompat.setAccessibilityDelegate(view, new ReactAccessibilityDelegate());
+            || view.getTag(R.id.react_test_id) != null
+            || view.getTag(R.id.accessibility_links) != null)) {
+      ViewCompat.setAccessibilityDelegate(
+          view,
+          new ReactAccessibilityDelegate(view, originalFocus, originalImportantForAccessibility));
+    }
+  }
+
+  // Explicitly re-set the delegate, even if one has already been set.
+  public static void resetDelegate(
+      final View view, boolean originalFocus, int originalImportantForAccessibility) {
+    ViewCompat.setAccessibilityDelegate(
+        view,
+        new ReactAccessibilityDelegate(view, originalFocus, originalImportantForAccessibility));
+  }
+
+  @Override
+  protected int getVirtualViewAt(float x, float y) {
+    if (mAccessibilityLinks == null
+        || mAccessibilityLinks.size() == 0
+        || !(mView instanceof TextView)) {
+      return INVALID_ID;
+    }
+
+    TextView textView = (TextView) mView;
+    if (!(textView.getText() instanceof Spanned)) {
+      return INVALID_ID;
+    }
+
+    Layout layout = textView.getLayout();
+    if (layout == null) {
+      return INVALID_ID;
+    }
+
+    x -= textView.getTotalPaddingLeft();
+    y -= textView.getTotalPaddingTop();
+    x += textView.getScrollX();
+    y += textView.getScrollY();
+
+    int line = layout.getLineForVertical((int) y);
+    int charOffset = layout.getOffsetForHorizontal(line, x);
+
+    ClickableSpan clickableSpan = getFirstSpan(charOffset, charOffset, ClickableSpan.class);
+    if (clickableSpan == null) {
+      return INVALID_ID;
+    }
+
+    Spanned spanned = (Spanned) textView.getText();
+    int start = spanned.getSpanStart(clickableSpan);
+    int end = spanned.getSpanEnd(clickableSpan);
+
+    final AccessibilityLinks.AccessibleLink link = mAccessibilityLinks.getLinkBySpanPos(start, end);
+    return link != null ? link.id : INVALID_ID;
+  }
+
+  @Override
+  protected void getVisibleVirtualViews(List<Integer> virtualViewIds) {
+    if (mAccessibilityLinks == null) {
+      return;
+    }
+
+    for (int i = 0; i < mAccessibilityLinks.size(); i++) {
+      virtualViewIds.add(i);
+    }
+  }
+
+  @Override
+  protected void onPopulateNodeForVirtualView(
+      int virtualViewId, @NonNull AccessibilityNodeInfoCompat node) {
+    // If we get an invalid virtualViewId for some reason (which is known to happen in API 19 and
+    // below), return an "empty" node to prevent from crashing. This will never be presented to
+    // the user, as Talkback filters out nodes with no content to announce.
+    if (mAccessibilityLinks == null) {
+      node.setContentDescription("");
+      node.setBoundsInParent(new Rect(0, 0, 1, 1));
+      return;
+    }
+
+    final AccessibilityLinks.AccessibleLink accessibleTextSpan =
+        mAccessibilityLinks.getLinkById(virtualViewId);
+    if (accessibleTextSpan == null) {
+      node.setContentDescription("");
+      node.setBoundsInParent(new Rect(0, 0, 1, 1));
+      return;
+    }
+
+    node.setContentDescription(accessibleTextSpan.description);
+    node.addAction(AccessibilityNodeInfoCompat.ACTION_CLICK);
+    node.setBoundsInParent(getBoundsInParent(accessibleTextSpan));
+    node.setRoleDescription(mView.getResources().getString(R.string.link_description));
+    node.setClassName(AccessibilityRole.getValue(AccessibilityRole.BUTTON));
+  }
+
+  private Rect getBoundsInParent(AccessibilityLinks.AccessibleLink accessibleLink) {
+    // This view is not a text view, so return the entire views bounds.
+    if (!(mView instanceof TextView)) {
+      return new Rect(0, 0, mView.getWidth(), mView.getHeight());
     }
+
+    TextView textView = (TextView) mView;
+    Layout textViewLayout = textView.getLayout();
+    if (textViewLayout == null) {
+      return new Rect(0, 0, textView.getWidth(), textView.getHeight());
+    }
+
+    Rect rootRect = new Rect();
+
+    double startOffset = accessibleLink.start;
+    double endOffset = accessibleLink.end;
+    double startXCoordinates = textViewLayout.getPrimaryHorizontal((int) startOffset);
+
+    final Paint paint = new Paint();
+    AbsoluteSizeSpan sizeSpan =
+        getFirstSpan(accessibleLink.start, accessibleLink.end, AbsoluteSizeSpan.class);
+    float textSize = sizeSpan != null ? sizeSpan.getSize() : textView.getTextSize();
+    paint.setTextSize(textSize);
+    int textWidth = (int) Math.ceil(paint.measureText(accessibleLink.description));
+
+    int startOffsetLineNumber = textViewLayout.getLineForOffset((int) startOffset);
+    int endOffsetLineNumber = textViewLayout.getLineForOffset((int) endOffset);
+    boolean isMultiline = startOffsetLineNumber != endOffsetLineNumber;
+    textViewLayout.getLineBounds(startOffsetLineNumber, rootRect);
+
+    int verticalOffset = textView.getScrollY() + textView.getTotalPaddingTop();
+    rootRect.top += verticalOffset;
+    rootRect.bottom += verticalOffset;
+    rootRect.left += startXCoordinates + textView.getTotalPaddingLeft() - textView.getScrollX();
+
+    // The bounds for multi-line strings should *only* include the first line. This is because for
+    // API 25 and below, Talkback's click is triggered at the center point of these bounds, and if
+    // that center point is outside the spannable, it will click on something else. There is no
+    // harm in not outlining the wrapped part of the string, as the text for the whole string will
+    // be read regardless of the bounding box.
+    if (isMultiline) {
+      return new Rect(rootRect.left, rootRect.top, rootRect.right, rootRect.bottom);
+    }
+
+    return new Rect(rootRect.left, rootRect.top, rootRect.left + textWidth, rootRect.bottom);
+  }
+
+  @Override
+  protected boolean onPerformActionForVirtualView(
+      int virtualViewId, int action, @Nullable Bundle arguments) {
+    return false;
+  }
+
+  protected @Nullable <T> T getFirstSpan(int start, int end, Class<T> classType) {
+    if (!(mView instanceof TextView) || !(((TextView) mView).getText() instanceof Spanned)) {
+      return null;
+    }
+
+    Spanned spanned = (Spanned) ((TextView) mView).getText();
+    T[] spans = spanned.getSpans(start, end, classType);
+    return spans.length > 0 ? spans[0] : null;
+  }
+
+  public static class AccessibilityLinks {
+    private final List<AccessibleLink> mLinks;
+
+    public AccessibilityLinks(ClickableSpan[] spans, Spannable text) {
+      ArrayList<AccessibleLink> links = new ArrayList<>();
+      for (int i = 0; i < spans.length; i++) {
+        ClickableSpan span = spans[i];
+        int start = text.getSpanStart(span);
+        int end = text.getSpanEnd(span);
+        // zero length spans, and out of range spans should not be included.
+        if (start == end || start < 0 || end < 0 || start > text.length() || end > text.length()) {
+          continue;
+        }
+
+        final AccessibleLink link = new AccessibleLink();
+        link.description = text.subSequence(start, end).toString();
+        link.start = start;
+        link.end = end;
+
+        // ID is the reverse of what is expected, since the ClickableSpans are returned in reverse
+        // order due to being added in reverse order. If we don't do this, focus will move to the
+        // last link first and move backwards.
+        //
+        // If this approach becomes unreliable, we should instead look at their start position and
+        // order them manually.
+        link.id = spans.length - 1 - i;
+        links.add(link);
+      }
+      mLinks = links;
+    }
+
+    @Nullable
+    public AccessibleLink getLinkById(int id) {
+      for (AccessibleLink link : mLinks) {
+        if (link.id == id) {
+          return link;
+        }
+      }
+
+      return null;
+    }
+
+    @Nullable
+    public AccessibleLink getLinkBySpanPos(int start, int end) {
+      for (AccessibleLink link : mLinks) {
+        if (link.start == start && link.end == end) {
+          return link;
+        }
+      }
+
+      return null;
+    }
+
+    public int size() {
+      return mLinks.size();
+    }
+
+    private static class AccessibleLink {
+      public String description;
+      public int start;
+      public int end;
+      public int id;
+    }
+  }
+
+  @Override
+  public @Nullable AccessibilityNodeProviderCompat getAccessibilityNodeProvider(View host) {
+    // Only set a NodeProvider if we have virtual views, otherwise just return null here so that
+    // we fall back to the View class's default behavior. If we don't do this, then Views with
+    // no virtual children will fall back to using ExploreByTouchHelper's onPopulateNodeForHost
+    // method to populate their AccessibilityNodeInfo, which defaults to doing nothing, so no
+    // AccessibilityNodeInfo will be created. Alternatively, we could override
+    // onPopulateNodeForHost instead, and have it create an AccessibilityNodeInfo for the host
+    // but this is what the default View class does by itself, so we may as well defer to it.
+    if (mAccessibilityLinks != null) {
+      return super.getAccessibilityNodeProvider(host);
+    }
+
+    return null;
   }
 }

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

@@ -65,11 +65,6 @@ public interface ReactRoot {
   @Nullable
   String getSurfaceID();
 
-  /**
-   * This API is likely to change once the fix of T78832286 is confirmed TODO: T78832286 revisit
-   * this API
-   *
-   * @return an {@link AtomicInteger} that represents the state of the ReactRoot object. WARNING:
-   */
+  /** @return an {@link AtomicInteger} that represents the state of the ReactRoot object. */
   AtomicInteger getState();
 }

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

@@ -25,7 +25,7 @@ public interface StateWrapper {
    * <p>Unstable API - DO NOT USE.
    */
   @Nullable
-  ReadableMapBuffer getStatDataMapBuffer();
+  ReadableMapBuffer getStateDataMapBuffer();
 
   /**
    * Get a ReadableNativeMap object from the C++ layer, which is a K/V map of string keys to values.

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

@@ -25,6 +25,7 @@ import com.facebook.react.uimanager.common.ViewUtil;
 import java.util.ArrayList;
 import java.util.EnumSet;
 import java.util.List;
+import java.util.Objects;
 
 /**
  * Class responsible for identifying which react view should handle a given {@link MotionEvent}. It
@@ -109,11 +110,12 @@ public class TouchTargetHelper {
    * @param eventY the Y screen coordinate of the touch location
    * @param viewGroup the container view to traverse
    * @param viewCoords an out parameter that will return the X,Y value in the target view
-   * @return If a target was found, returns a path through the view tree of all react tags that are
-   *     a container for the touch target, ordered from target to root (last element)
+   * @return If a target was found, returns a {@link Lis<ViewTarget>} containing the path through
+   *     the view tree of all react tags and views that are a container for the touch target,
+   *     ordered from target to root (last element)
    */
   @SuppressLint("ResourceType")
-  public static List<Integer> findTargetPathAndCoordinatesForTouch(
+  public static List<ViewTarget> findTargetPathAndCoordinatesForTouch(
       float eventX, float eventY, ViewGroup viewGroup, float[] viewCoords) {
     UiThreadUtil.assertOnUiThread();
 
@@ -121,7 +123,7 @@ public class TouchTargetHelper {
     viewCoords[0] = eventX;
     viewCoords[1] = eventY;
 
-    List<Integer> pathAccumulator = new ArrayList<>();
+    List<ViewTarget> pathAccumulator = new ArrayList<>();
     View targetView = findTouchTargetViewWithPointerEvents(viewCoords, viewGroup, pathAccumulator);
 
     if (targetView != null) {
@@ -140,7 +142,7 @@ public class TouchTargetHelper {
 
       int targetTag = getTouchTargetForView(reactTargetView, eventX, eventY);
       if (targetTag != reactTargetView.getId()) {
-        pathAccumulator.add(0, targetTag);
+        pathAccumulator.add(0, new ViewTarget(targetTag, (View) null));
       }
     }
 
@@ -178,7 +180,7 @@ public class TouchTargetHelper {
       float[] eventCoords,
       View view,
       EnumSet<TouchTargetReturnType> allowReturnTouchTargetTypes,
-      List<Integer> pathAccumulator) {
+      List<ViewTarget> pathAccumulator) {
     // We prefer returning a child, so we check for a child that can handle the touch first
     if (allowReturnTouchTargetTypes.contains(TouchTargetReturnType.CHILD)
         && view instanceof ViewGroup) {
@@ -303,7 +305,7 @@ public class TouchTargetHelper {
    * its descendants are the touch target.
    */
   private static @Nullable View findTouchTargetViewWithPointerEvents(
-      float eventCoords[], View view, @Nullable List<Integer> pathAccumulator) {
+      float eventCoords[], View view, @Nullable List<ViewTarget> pathAccumulator) {
     PointerEvents pointerEvents =
         view instanceof ReactPointerEventsView
             ? ((ReactPointerEventsView) view).getPointerEvents()
@@ -330,7 +332,7 @@ public class TouchTargetHelper {
           findTouchTargetView(
               eventCoords, view, EnumSet.of(TouchTargetReturnType.SELF), pathAccumulator);
       if (targetView != null && pathAccumulator != null) {
-        pathAccumulator.add(view.getId());
+        pathAccumulator.add(new ViewTarget(view.getId(), view));
       }
       return targetView;
 
@@ -341,7 +343,7 @@ public class TouchTargetHelper {
               eventCoords, view, EnumSet.of(TouchTargetReturnType.CHILD), pathAccumulator);
       if (targetView != null) {
         if (pathAccumulator != null) {
-          pathAccumulator.add(view.getId());
+          pathAccumulator.add(new ViewTarget(view.getId(), view));
         }
         return targetView;
       }
@@ -358,7 +360,7 @@ public class TouchTargetHelper {
         // make sure we exclude the View itself because of the PointerEvents.BOX_NONE
         if (reactTag != view.getId()) {
           if (pathAccumulator != null) {
-            pathAccumulator.add(view.getId());
+            pathAccumulator.add(new ViewTarget(view.getId(), view));
           }
           return view;
         }
@@ -372,7 +374,7 @@ public class TouchTargetHelper {
           && isTouchPointInView(eventCoords[0], eventCoords[1], view)
           && ((ReactCompoundViewGroup) view).interceptsTouchEvent(eventCoords[0], eventCoords[1])) {
         if (pathAccumulator != null) {
-          pathAccumulator.add(view.getId());
+          pathAccumulator.add(new ViewTarget(view.getId(), view));
         }
         return view;
       }
@@ -384,7 +386,7 @@ public class TouchTargetHelper {
               EnumSet.of(TouchTargetReturnType.SELF, TouchTargetReturnType.CHILD),
               pathAccumulator);
       if (result != null && pathAccumulator != null) {
-        pathAccumulator.add(view.getId());
+        pathAccumulator.add(new ViewTarget(view.getId(), view));
       }
       return result;
 
@@ -402,4 +404,47 @@ public class TouchTargetHelper {
     }
     return targetView.getId();
   }
+
+  public static class ViewTarget {
+    private final int mViewId;
+    private final @Nullable View mView;
+
+    private ViewTarget(int viewId, @Nullable View view) {
+      mViewId = viewId;
+      mView = view;
+    }
+
+    public int getViewId() {
+      return mViewId;
+    }
+
+    @Nullable
+    public View getView() {
+      return mView;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+      // If the object is compared with itself then return true
+      if (o == this) {
+        return true;
+      }
+
+      // Check if o is an instance of ViewTarget. Note that "null instanceof ViewTarget" also
+      // returns false.
+      if (!(o instanceof ViewTarget)) {
+        return false;
+      }
+
+      ViewTarget other = (ViewTarget) o;
+      // We only need to compare view id, as we assume the same view id will always map to the same
+      // view. TargetView is not mutable so this should be safe.
+      return other.getViewId() == mViewId;
+    }
+
+    @Override
+    public int hashCode() {
+      return Objects.hashCode(mViewId);
+    }
+  }
 }

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

@@ -40,7 +40,6 @@ import com.facebook.react.bridge.UiThreadUtil;
 import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.common.MapBuilder;
 import com.facebook.react.common.ReactConstants;
-import com.facebook.react.config.ReactFeatureFlags;
 import com.facebook.react.module.annotations.ReactModule;
 import com.facebook.react.uimanager.common.ViewUtil;
 import com.facebook.react.uimanager.debug.NotThreadSafeViewHierarchyUpdateDebugListener;
@@ -288,16 +287,6 @@ public class UIManagerModule extends ReactContextBaseJavaModule
   @Deprecated
   @Override
   public void preInitializeViewManagers(List<String> viewManagerNames) {
-    if (ReactFeatureFlags.enableExperimentalStaticViewConfigs) {
-      for (String viewManagerName : viewManagerNames) {
-        mUIImplementation.resolveViewManager(viewManagerName);
-      }
-      // When Static view configs are enabled it is not necessary to pre-compute the constants for
-      // viewManagers, although the pre-initialization of viewManager objects is still necessary
-      // for performance reasons.
-      return;
-    }
-
     Map<String, WritableMap> constantsMap = new ArrayMap<>();
     for (String viewManagerName : viewManagerNames) {
       WritableMap constants = computeConstantsForViewManager(viewManagerName);

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

@@ -59,9 +59,9 @@ import java.util.Map;
     return MapBuilder.builder()
         .put("topContentSizeChange", MapBuilder.of(rn, "onContentSizeChange"))
         .put("topLayout", MapBuilder.of(rn, "onLayout"))
-        .put("topPointerEnter", MapBuilder.of(rn, "pointerenter"))
-        .put("topPointerLeave", MapBuilder.of(rn, "pointerleave"))
-        .put("topPointerMove", MapBuilder.of(rn, "pointermove"))
+        .put("topPointerEnter", MapBuilder.of(rn, "onPointerEnter"))
+        .put("topPointerLeave", MapBuilder.of(rn, "onPointerLeave"))
+        .put("topPointerMove", MapBuilder.of(rn, "onPointerMove"))
         .put("topLoadingError", MapBuilder.of(rn, "onLoadingError"))
         .put("topLoadingFinish", MapBuilder.of(rn, "onLoadingFinish"))
         .put("topLoadingStart", MapBuilder.of(rn, "onLoadingStart"))

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

@@ -15,6 +15,7 @@ import com.facebook.react.bridge.BaseJavaModule;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReadableArray;
 import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.common.mapbuffer.MapBuffer;
 import com.facebook.react.touch.JSResponderHandler;
 import com.facebook.react.touch.ReactInterceptingViewGroup;
 import com.facebook.react.uimanager.annotations.ReactProp;
@@ -323,6 +324,47 @@ public abstract class ViewManager<T extends View, C extends ReactShadowNode>
     return 0;
   }
 
+  /**
+   * THIS MEASURE METHOD IS EXPERIMENTAL, MOST LIKELY YOU ARE LOOKING TO USE THE OTHER OVERLOAD
+   * INSTEAD: {@link #measure(Context, ReadableMap, ReadableMap, ReadableMap, float,
+   * YogaMeasureMode, float, YogaMeasureMode, float[])}
+   *
+   * <p>Subclasses can override this method to implement custom measure functions for the
+   * ViewManager
+   *
+   * @param context {@link com.facebook.react.bridge.ReactContext} used for the view.
+   * @param localData {@link MapBuffer} containing "local data" defined in C++
+   * @param props {@link MapBuffer} containing JS props
+   * @param state {@link MapBuffer} containing state defined in C++
+   * @param width width of the view (usually zero)
+   * @param widthMode widthMode used during calculation of layout
+   * @param height height of the view (usually zero)
+   * @param heightMode widthMode used during calculation of layout
+   * @param attachmentsPositions {@link int[]} array containing 2x times the amount of attachments
+   *     of the view. An attachment represents the position of an inline view that needs to be
+   *     rendered inside a component and it requires the content of the parent view in order to be
+   *     positioned. This array is meant to be used by the platform to RETURN the position of each
+   *     attachment, as a result of the calculation of layout. (e.g. this array is used to measure
+   *     inlineViews that are rendered inside Text components). On most of the components this array
+   *     will be contain a null value.
+   *     <p>Even values will represent the TOP of each attachment, Odd values represent the LEFT of
+   *     each attachment.
+   * @return result of calculation of layout for the arguments received as a parameter.
+   */
+  public long measure(
+      Context context,
+      MapBuffer localData,
+      MapBuffer props,
+      // TODO(T114731225): review whether state parameter is needed
+      @Nullable MapBuffer state,
+      float width,
+      YogaMeasureMode widthMode,
+      float height,
+      YogaMeasureMode heightMode,
+      @Nullable float[] attachmentsPositions) {
+    return 0;
+  }
+
   /**
    * Subclasses can override this method to set padding for the given View in Fabric. Since not all
    * components support setting padding, the default implementation of this method does nothing.

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/annotations/BUCK

@@ -5,7 +5,10 @@ rn_android_library(
     srcs = glob(["*.java"]),
     autoglob = False,
     is_androidx = True,
-    labels = ["supermodule:xplat/default/public.react_native.infra"],
+    labels = [
+        "pfh:ReactNative_CommonInfrastructurePlaceholder",
+        "supermodule:xplat/default/public.react_native.infra",
+    ],
     required_for_source_only_abi = True,
     visibility = [
         "PUBLIC",

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/common/BUCK

@@ -5,7 +5,10 @@ rn_android_library(
     srcs = glob(["*.java"]),
     autoglob = False,
     is_androidx = True,
-    labels = ["supermodule:xplat/default/public.react_native.infra"],
+    labels = [
+        "pfh:ReactNative_CommonInfrastructurePlaceholder",
+        "supermodule:xplat/default/public.react_native.infra",
+    ],
     provided_deps = [
         react_native_dep("third-party/android/androidx:annotation"),
         react_native_dep("third-party/android/androidx:core"),

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/events/LockFreeEventDispatcherImpl.java

@@ -125,7 +125,8 @@ public class LockFreeEventDispatcherImpl implements EventDispatcher, LifecycleEv
 
   @Override
   public void onHostResume() {
-    maybePostFrameCallbackFromNonUI();
+    UiThreadUtil.assertOnUiThread();
+    mCurrentFrameCallback.resume();
   }
 
   @Override
@@ -183,6 +184,11 @@ public class LockFreeEventDispatcherImpl implements EventDispatcher, LifecycleEv
       driveEventBeats();
     }
 
+    public void resume() {
+      mShouldStop = false;
+      maybePost();
+    }
+
     public void stop() {
       mShouldStop = true;
     }