react-native-tvos 0.72.6-0 → 0.73.0-0

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

@@ -7,6 +7,7 @@
 
 package com.facebook.react.uimanager;
 
+import android.graphics.Rect;
 import android.view.MotionEvent;
 import android.view.View;
 import android.view.ViewGroup;
@@ -34,12 +35,14 @@ import java.util.Set;
  * and also dispatch the appropriate event to JS
  */
 public class JSPointerDispatcher {
+  private static final int UNSELECTED_VIEW_TAG = -1;
   private static final int UNSET_POINTER_ID = -1;
   private static final float ONMOVE_EPSILON = 0.1f;
   private static final String TAG = "POINTER EVENTS";
 
   private Map<Integer, List<ViewTarget>> mLastHitPathByPointerId;
   private Map<Integer, float[]> mLastEventCoordinatesByPointerId;
+  private Map<Integer, List<ViewTarget>> mCurrentlyDownPointerIdsToHitPath;
   private Set<Integer> mHoveringPointerIds = new HashSet<>();
 
   private int mChildHandlingNativeGesture = -1;
@@ -48,10 +51,13 @@ public class JSPointerDispatcher {
   private int mLastButtonState = 0;
   private final ViewGroup mRootViewGroup;
 
+  private static final int[] sRootScreenCoords = {0, 0};
+
   // Set globally for hover interactions, referenced for coalescing hover events
 
   public JSPointerDispatcher(ViewGroup viewGroup) {
     mRootViewGroup = viewGroup;
+    mCurrentlyDownPointerIdsToHitPath = new HashMap<>();
   }
 
   public void onChildStartedNativeGesture(
@@ -63,15 +69,56 @@ public class JSPointerDispatcher {
       return;
     }
 
-    dispatchCancelEvent(motionEvent, eventDispatcher);
+    MotionEvent motionInRoot = convertMotionToRootFrame(childView, motionEvent);
+    motionInRoot.setAction(MotionEvent.ACTION_CANCEL);
+    handleMotionEvent(motionInRoot, eventDispatcher, false);
+
     mChildHandlingNativeGesture = childView.getId();
   }
 
+  private MotionEvent convertMotionToRootFrame(View childView, MotionEvent childMotion) {
+    MotionEvent motionInRoot = MotionEvent.obtain(childMotion);
+
+    int[] location = new int[2];
+    mRootViewGroup.getLocationOnScreen(location);
+    float screenX = childMotion.getRawX();
+    float screenY = childMotion.getRawY();
+    float clientX = screenX - location[0];
+    float clientY = screenY - location[1];
+    motionInRoot.setLocation(clientX, clientY);
+
+    return motionInRoot;
+  }
+
   public void onChildEndedNativeGesture() {
     // There should be only one child gesture at any given time. We can safely turn off the flag.
     mChildHandlingNativeGesture = -1;
   }
 
+  // returns the section of the hit path shared by both lists, or an empty list if there's no such
+  // section
+  private static List<ViewTarget> findHitPathIntersection(
+      final List<ViewTarget> hitsA, final List<ViewTarget> hitsB) {
+    if (hitsA.isEmpty()) {
+      return new ArrayList<>();
+    }
+    if (hitsB.isEmpty()) {
+      return new ArrayList<>();
+    }
+
+    Set<ViewTarget> inA = new HashSet<>(hitsA);
+
+    List<ViewTarget> intersection = new ArrayList<>();
+
+    for (final ViewTarget vt : hitsB) {
+      if (inA.contains(vt)) {
+        intersection.add(vt);
+      }
+    }
+
+    return intersection;
+  }
+
   private void onUp(
       int activeTargetTag,
       PointerEventState eventState,
@@ -112,6 +159,18 @@ public class JSPointerDispatcher {
           eventDispatcher);
     }
 
+    List<ViewTarget> hitPathDown = mCurrentlyDownPointerIdsToHitPath.remove(activePointerId);
+    if (hitPathDown != null
+        && isAnyoneListeningForBubblingEvent(activeHitPath, EVENT.CLICK, EVENT.CLICK_CAPTURE)) {
+      List<ViewTarget> hitPathForClick = findHitPathIntersection(hitPathDown, activeHitPath);
+      if (!hitPathForClick.isEmpty()) {
+        final ViewTarget clickTarget = hitPathForClick.get(0);
+        eventDispatcher.dispatchEvent(
+            PointerEvent.obtain(
+                PointerEventHelper.CLICK, clickTarget.getViewId(), eventState, motionEvent));
+      }
+    }
+
     if (motionEvent.getActionMasked() == MotionEvent.ACTION_UP) {
       mPrimaryPointerId = UNSET_POINTER_ID;
     }
@@ -160,6 +219,12 @@ public class JSPointerDispatcher {
           eventDispatcher);
     }
 
+    // store some information if we might need to emit a click later on
+    if (isAnyoneListeningForBubblingEvent(activeHitPath, EVENT.CLICK, EVENT.CLICK_CAPTURE)) {
+      mCurrentlyDownPointerIdsToHitPath.put(
+          eventState.getActivePointerId(), new ArrayList<>(activeHitPath));
+    }
+
     boolean listeningForDown =
         isAnyoneListeningForBubblingEvent(activeHitPath, EVENT.DOWN, EVENT.DOWN_CAPTURE);
     if (listeningForDown) {
@@ -169,10 +234,21 @@ public class JSPointerDispatcher {
     }
   }
 
+  private float[] eventCoordsToScreenCoords(float[] eventCoords) {
+    float[] screenCoords = new float[2];
+    mRootViewGroup.getLocationOnScreen(sRootScreenCoords);
+
+    screenCoords[0] = eventCoords[0] + sRootScreenCoords[0];
+    screenCoords[1] = eventCoords[1] + sRootScreenCoords[1];
+
+    return screenCoords;
+  }
+
   private PointerEventState createEventState(int activePointerId, MotionEvent motionEvent) {
     Map<Integer, float[]> offsetByPointerId = new HashMap<Integer, float[]>();
     Map<Integer, List<ViewTarget>> hitPathByPointerId = new HashMap<Integer, List<ViewTarget>>();
     Map<Integer, float[]> eventCoordinatesByPointerId = new HashMap<Integer, float[]>();
+    Map<Integer, float[]> screenCoordinatesByPointerId = new HashMap<Integer, float[]>();
     for (int index = 0; index < motionEvent.getPointerCount(); index++) {
       float[] offsetCoordinates = new float[2];
       float[] eventCoordinates = new float[] {motionEvent.getX(index), motionEvent.getY(index)};
@@ -184,6 +260,7 @@ public class JSPointerDispatcher {
       offsetByPointerId.put(pointerId, offsetCoordinates);
       hitPathByPointerId.put(pointerId, hitPath);
       eventCoordinatesByPointerId.put(pointerId, eventCoordinates);
+      screenCoordinatesByPointerId.put(pointerId, eventCoordsToScreenCoords(eventCoordinates));
     }
 
     int surfaceId = UIManagerHelper.getSurfaceId(mRootViewGroup);
@@ -196,6 +273,7 @@ public class JSPointerDispatcher {
         offsetByPointerId,
         hitPathByPointerId,
         eventCoordinatesByPointerId,
+        screenCoordinatesByPointerId,
         mHoveringPointerIds); // Creates a copy of hovering pointer ids, as they may be updated
   }
 
@@ -228,6 +306,7 @@ public class JSPointerDispatcher {
     // 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
     int activeTargetTag;
+    View activeTargetView;
 
     List<ViewTarget> activeHitPath;
     if (isExitFromRoot) {
@@ -238,7 +317,9 @@ public class JSPointerDispatcher {
       if (lastHitPath == null || lastHitPath.isEmpty()) {
         return;
       }
-      activeTargetTag = lastHitPath.get(lastHitPath.size() - 1).getViewId();
+      ViewTarget activeTarget = lastHitPath.get(lastHitPath.size() - 1);
+      activeTargetTag = activeTarget.getViewId();
+      activeTargetView = activeTarget.getView();
 
       // Explicitly make the hit path for this cursor empty
       activeHitPath = new ArrayList<>();
@@ -248,9 +329,13 @@ public class JSPointerDispatcher {
       if (activeHitPath == null || activeHitPath.isEmpty()) {
         return;
       }
-      activeTargetTag = activeHitPath.get(0).getViewId();
+      ViewTarget activeTarget = activeHitPath.get(0);
+      activeTargetTag = activeTarget.getViewId();
+      activeTargetView = activeTarget.getView();
     }
 
+    handleHitStateDivergence(activeTargetTag, eventState, motionEvent, eventDispatcher);
+
     // Dispatch pointer events from the MotionEvents. When we want to ignore an event, we need to
     // exit early so we don't record anything about this MotionEvent.
     switch (action) {
@@ -282,7 +367,8 @@ public class JSPointerDispatcher {
         onUp(activeTargetTag, eventState, motionEvent, eventDispatcher);
         break;
       case MotionEvent.ACTION_CANCEL:
-        dispatchCancelEvent(eventState, motionEvent, eventDispatcher);
+        dispatchCancelEventForTarget(activeTargetView, eventState, motionEvent, eventDispatcher);
+        handleHitStateDivergence(UNSELECTED_VIEW_TAG, eventState, motionEvent, eventDispatcher);
         break;
       case MotionEvent.ACTION_HOVER_ENTER:
         // Ignore these events as enters will be calculated from HOVER_MOVE
@@ -302,9 +388,10 @@ public class JSPointerDispatcher {
         return;
     }
 
-    // Caching the event state so we have a new "last"
-    mLastHitPathByPointerId = eventState.getHitPathByPointerId();
-    mLastEventCoordinatesByPointerId = eventState.getEventCoordinatesByPointerId();
+    // Update "previous" pointer coordinates and button state
+    Map<Integer, float[]> nextEventCoordinatesByPointerId =
+        new HashMap<>(eventState.getEventCoordinatesByPointerId());
+    mLastEventCoordinatesByPointerId = nextEventCoordinatesByPointerId;
     mLastButtonState = motionEvent.getButtonState();
 
     // Clean up any stale pointerIds
@@ -358,7 +445,7 @@ public class JSPointerDispatcher {
     return dispatchableViewTargets;
   }
 
-  private void dispatchEventForViewTargets(
+  private static void dispatchEventForViewTargets(
       String eventName,
       PointerEventState eventState,
       MotionEvent motionEvent,
@@ -371,20 +458,23 @@ public class JSPointerDispatcher {
     }
   }
 
-  private boolean qualifiedMove(float[] eventCoordinates, float[] lastEventCoordinates) {
+  private static boolean qualifiedMove(float[] eventCoordinates, float[] lastEventCoordinates) {
     return (Math.abs(lastEventCoordinates[0] - eventCoordinates[0]) > ONMOVE_EPSILON
         || Math.abs(lastEventCoordinates[1] - eventCoordinates[1]) > ONMOVE_EPSILON);
   }
 
-  private void onMove(
+  // Determines which views are being entered and exited based on comparison between the previous
+  // hit path and the current hit path, and dispatches out/over/leave/enter events.
+  private void handleHitStateDivergence(
       int targetTag,
       PointerEventState eventState,
       MotionEvent motionEvent,
       EventDispatcher eventDispatcher) {
-
     int activePointerId = eventState.getActivePointerId();
-    List<ViewTarget> activeHitPath = eventState.getHitPathByPointerId().get(activePointerId);
-
+    List<ViewTarget> activeHitPath =
+        targetTag != UNSELECTED_VIEW_TAG
+            ? eventState.getHitPathByPointerId().get(activePointerId)
+            : new ArrayList<ViewTarget>();
     List<ViewTarget> lastHitPath =
         mLastHitPathByPointerId != null && mLastHitPathByPointerId.containsKey(activePointerId)
             ? mLastHitPathByPointerId.get(activePointerId)
@@ -480,6 +570,23 @@ public class JSPointerDispatcher {
       }
     }
 
+    Map<Integer, List<TouchTargetHelper.ViewTarget>> nextHitPathByPointerId =
+        new HashMap<>(eventState.getHitPathByPointerId());
+
+    if (targetTag == UNSELECTED_VIEW_TAG) {
+      nextHitPathByPointerId.remove(activePointerId);
+    }
+    mLastHitPathByPointerId = nextHitPathByPointerId;
+  }
+
+  private void onMove(
+      int targetTag,
+      PointerEventState eventState,
+      MotionEvent motionEvent,
+      EventDispatcher eventDispatcher) {
+    int activePointerId = eventState.getActivePointerId();
+    List<ViewTarget> activeHitPath = eventState.getHitPathByPointerId().get(activePointerId);
+
     boolean listeningToMove =
         isAnyoneListeningForBubblingEvent(activeHitPath, EVENT.MOVE, EVENT.MOVE_CAPTURE);
     if (listeningToMove) {
@@ -493,19 +600,11 @@ public class JSPointerDispatcher {
     }
   }
 
-  private void dispatchCancelEvent(MotionEvent motionEvent, EventDispatcher eventDispatcher) {
-    Assertions.assertCondition(
-        mChildHandlingNativeGesture == -1,
-        "Expected to not have already sent a cancel for this gesture");
-
-    int activeIndex = motionEvent.getActionIndex();
-    int activePointerId = motionEvent.getPointerId(activeIndex);
-    PointerEventState eventState = createEventState(activePointerId, motionEvent);
-    dispatchCancelEvent(eventState, motionEvent, eventDispatcher);
-  }
-
-  private void dispatchCancelEvent(
-      PointerEventState eventState, MotionEvent motionEvent, EventDispatcher eventDispatcher) {
+  private void dispatchCancelEventForTarget(
+      View targetView,
+      PointerEventState eventState,
+      MotionEvent motionEvent,
+      EventDispatcher eventDispatcher) {
     // This means the gesture has already ended, via some other CANCEL or UP event. This is not
     // expected to happen very often as it would mean some child View has decided to intercept the
     // touch stream and start a native gesture only upon receiving the UP/CANCEL event.
@@ -516,38 +615,76 @@ public class JSPointerDispatcher {
     int activePointerId = eventState.getActivePointerId();
     List<ViewTarget> activeHitPath = eventState.getHitPathByPointerId().get(activePointerId);
 
-    if (!activeHitPath.isEmpty()) {
+    if (!activeHitPath.isEmpty() && targetView != null) {
       boolean listeningForCancel =
           isAnyoneListeningForBubblingEvent(activeHitPath, EVENT.CANCEL, EVENT.CANCEL_CAPTURE);
       if (listeningForCancel) {
         int targetTag = activeHitPath.get(0).getViewId();
+
+        // cancel events need to report client coordinates of (0, 0) and offset coordinates relative
+        // to the root view
+        int[] childOffset = getChildOffsetRelativeToRoot(targetView);
+        PointerEventState normalizedEventState =
+            normalizeToRoot(eventState, childOffset[0], childOffset[1]);
         Assertions.assertNotNull(eventDispatcher)
             .dispatchEvent(
                 PointerEvent.obtain(
-                    PointerEventHelper.POINTER_CANCEL, targetTag, eventState, motionEvent));
+                    PointerEventHelper.POINTER_CANCEL,
+                    targetTag,
+                    normalizedEventState,
+                    motionEvent));
       }
 
-      // TODO(luwe) - Need to fire pointer out here as well:
-      // https://w3c.github.io/pointerevents/#dfn-suppress-a-pointer-event-stream
-      List<ViewTarget> leaveViewTargets =
-          filterByShouldDispatch(activeHitPath, EVENT.LEAVE, EVENT.LEAVE_CAPTURE, false);
-
-      // dispatch from target -> root
-      dispatchEventForViewTargets(
-          PointerEventHelper.POINTER_LEAVE,
-          eventState,
-          motionEvent,
-          leaveViewTargets,
-          eventDispatcher);
-
       incrementCoalescingKey();
-      mHoveringPointerIds.remove(mPrimaryPointerId);
-      mHoveringPointerIds.remove(activePointerId);
       mPrimaryPointerId = UNSET_POINTER_ID;
     }
   }
 
-  private void debugPrintHitPath(List<ViewTarget> hitPath) {
+  // 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};
+  }
+
+  // Returns a copy of `original` with coordinates zeroed relative to the provided root coordinates.
+  // In particular,
+  // - the event (client) coordinates will all be set to 0
+  // - the offset coordinates will be set to the root coordinates
+  private PointerEventState normalizeToRoot(PointerEventState original, float rootX, float rootY) {
+    Map<Integer, float[]> newOffsets = new HashMap<>(original.getOffsetByPointerId());
+    Map<Integer, float[]> newEventCoords = new HashMap<>(original.getEventCoordinatesByPointerId());
+    Map<Integer, float[]> newScreenCoords =
+        new HashMap<>(original.getScreenCoordinatesByPointerId());
+
+    float[] rootOffset = {rootX, rootY};
+    for (Map.Entry<Integer, float[]> offsetEntry : newOffsets.entrySet()) {
+      offsetEntry.setValue(rootOffset);
+    }
+
+    float[] zeroOffset = {0, 0};
+    for (Map.Entry<Integer, float[]> eventCoordsEntry : newEventCoords.entrySet()) {
+      eventCoordsEntry.setValue(zeroOffset);
+    }
+
+    float[] screenCoords = eventCoordsToScreenCoords(rootOffset);
+    for (Map.Entry<Integer, float[]> screenCoordsEntry : newScreenCoords.entrySet()) {
+      screenCoordsEntry.setValue(screenCoords);
+    }
+
+    return new PointerEventState(
+        original.getPrimaryPointerId(),
+        original.getActivePointerId(),
+        original.getLastButtonState(),
+        original.getSurfaceId(),
+        newOffsets,
+        new HashMap<>(original.getHitPathByPointerId()),
+        newEventCoords,
+        newScreenCoords,
+        new HashSet<>(original.getHoveringPointerIds()));
+  }
+
+  private static void debugPrintHitPath(List<ViewTarget> hitPath) {
     StringBuilder builder = new StringBuilder("hitPath: ");
     for (ViewTarget viewTarget : hitPath) {
       builder.append(String.format("%d, ", viewTarget.getViewId()));

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

@@ -860,12 +860,7 @@ public class NativeViewHierarchyManager {
               + commandId);
     }
     ViewManager viewManager = resolveViewManager(reactTag);
-    ViewManagerDelegate delegate = viewManager.getDelegate();
-    if (delegate != null) {
-      delegate.receiveCommand(view, commandId, args);
-    } else {
-      viewManager.receiveCommand(view, commandId, args);
-    }
+    viewManager.receiveCommand(view, commandId, args);
   }
 
   /**
@@ -950,7 +945,7 @@ public class NativeViewHierarchyManager {
   public void sendAccessibilityEvent(int tag, int eventType) {
     View view = mTagsToViews.get(tag);
     if (view == null) {
-      throw new JSApplicationIllegalArgumentException("Could not find view with tag " + tag);
+      throw new RetryableMountingLayerException("Could not find view with tag " + tag);
     }
     view.sendAccessibilityEvent(eventType);
   }

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

@@ -96,6 +96,87 @@ public class ReactAccessibilityDelegate extends ExploreByTouchHelper {
     mHandler.sendMessageDelayed(msg, TIMEOUT_SEND_ACCESSIBILITY_EVENT);
   }
 
+  /**
+   * An ARIA Role representable by View's `role` prop. Ordinals should be kept in sync with
+   * `facebook::react::Role`.
+   */
+  public enum Role {
+    ALERT,
+    ALERTDIALOG,
+    APPLICATION,
+    ARTICLE,
+    BANNER,
+    BUTTON,
+    CELL,
+    CHECKBOX,
+    COLUMNHEADER,
+    COMBOBOX,
+    COMPLEMENTARY,
+    CONTENTINFO,
+    DEFINITION,
+    DIALOG,
+    DIRECTORY,
+    DOCUMENT,
+    FEED,
+    FIGURE,
+    FORM,
+    GRID,
+    GROUP,
+    HEADING,
+    IMG,
+    LINK,
+    LIST,
+    LISTITEM,
+    LOG,
+    MAIN,
+    MARQUEE,
+    MATH,
+    MENU,
+    MENUBAR,
+    MENUITEM,
+    METER,
+    NAVIGATION,
+    NONE,
+    NOTE,
+    OPTION,
+    PRESENTATION,
+    PROGRESSBAR,
+    RADIO,
+    RADIOGROUP,
+    REGION,
+    ROW,
+    ROWGROUP,
+    ROWHEADER,
+    SCROLLBAR,
+    SEARCHBOX,
+    SEPARATOR,
+    SLIDER,
+    SPINBUTTON,
+    STATUS,
+    SUMMARY,
+    SWITCH,
+    TAB,
+    TABLE,
+    TABLIST,
+    TABPANEL,
+    TERM,
+    TIMER,
+    TOOLBAR,
+    TOOLTIP,
+    TREE,
+    TREEGRID,
+    TREEITEM;
+
+    public static @Nullable Role fromValue(@Nullable String value) {
+      for (Role role : Role.values()) {
+        if (role.name().equalsIgnoreCase(value)) {
+          return role;
+        }
+      }
+      return null;
+    }
+  }
+
   /**
    * These roles are defined by Google's TalkBack screen reader, and this list should be kept up to
    * date with their implementation. Details can be seen in their source code here:
@@ -214,6 +295,10 @@ public class ReactAccessibilityDelegate extends ExploreByTouchHelper {
     }
 
     public static AccessibilityRole fromValue(@Nullable String value) {
+      if (value == null) {
+        return NONE;
+      }
+
       for (AccessibilityRole role : AccessibilityRole.values()) {
         if (role.name().equalsIgnoreCase(value)) {
           return role;
@@ -221,6 +306,75 @@ public class ReactAccessibilityDelegate extends ExploreByTouchHelper {
       }
       throw new IllegalArgumentException("Invalid accessibility role value: " + value);
     }
+
+    public static @Nullable AccessibilityRole fromRole(Role role) {
+      switch (role) {
+        case ALERT:
+          return AccessibilityRole.ALERT;
+        case BUTTON:
+          return AccessibilityRole.BUTTON;
+        case CHECKBOX:
+          return AccessibilityRole.CHECKBOX;
+        case COMBOBOX:
+          return AccessibilityRole.COMBOBOX;
+        case GRID:
+          return AccessibilityRole.GRID;
+        case HEADING:
+          return AccessibilityRole.HEADER;
+        case IMG:
+          return AccessibilityRole.IMAGE;
+        case LINK:
+          return AccessibilityRole.LINK;
+        case LIST:
+          return AccessibilityRole.LIST;
+        case MENU:
+          return AccessibilityRole.MENU;
+        case MENUBAR:
+          return AccessibilityRole.MENUBAR;
+        case MENUITEM:
+          return AccessibilityRole.MENUITEM;
+        case NONE:
+          return AccessibilityRole.NONE;
+        case PROGRESSBAR:
+          return AccessibilityRole.PROGRESSBAR;
+        case RADIO:
+          return AccessibilityRole.RADIO;
+        case RADIOGROUP:
+          return AccessibilityRole.RADIOGROUP;
+        case SCROLLBAR:
+          return AccessibilityRole.SCROLLBAR;
+        case SEARCHBOX:
+          return AccessibilityRole.SEARCH;
+        case SLIDER:
+          return AccessibilityRole.ADJUSTABLE;
+        case SPINBUTTON:
+          return AccessibilityRole.SPINBUTTON;
+        case SUMMARY:
+          return AccessibilityRole.SUMMARY;
+        case SWITCH:
+          return AccessibilityRole.SWITCH;
+        case TAB:
+          return AccessibilityRole.TAB;
+        case TABLIST:
+          return AccessibilityRole.TABLIST;
+        case TIMER:
+          return AccessibilityRole.TIMER;
+        case TOOLBAR:
+          return AccessibilityRole.TOOLBAR;
+        default:
+          // No mapping from ARIA role to AccessibilityRole
+          return null;
+      }
+    }
+
+    public static @Nullable AccessibilityRole fromViewTag(View view) {
+      Role role = (Role) view.getTag(R.id.role);
+      if (role != null) {
+        return AccessibilityRole.fromRole(role);
+      } else {
+        return (AccessibilityRole) view.getTag(R.id.accessibility_role);
+      }
+    }
   }
 
   private final HashMap<Integer, String> mAccessibilityActionsMap;
@@ -267,8 +421,7 @@ public class ReactAccessibilityDelegate extends ExploreByTouchHelper {
               ? AccessibilityNodeInfoCompat.ACTION_COLLAPSE
               : AccessibilityNodeInfoCompat.ACTION_EXPAND);
     }
-    final AccessibilityRole accessibilityRole =
-        (AccessibilityRole) host.getTag(R.id.accessibility_role);
+    final AccessibilityRole accessibilityRole = AccessibilityRole.fromViewTag(host);
     final String accessibilityHint = (String) host.getTag(R.id.accessibility_hint);
     if (accessibilityRole != null) {
       setRole(info, accessibilityRole, host.getContext());
@@ -477,7 +630,7 @@ public class ReactAccessibilityDelegate extends ExploreByTouchHelper {
         info.setCheckable(true);
         info.setChecked(boolValue);
         if (info.getClassName().equals(AccessibilityRole.getValue(AccessibilityRole.SWITCH))) {
-          info.setText(
+          info.setStateDescription(
               context.getString(
                   boolValue ? R.string.state_on_description : R.string.state_off_description));
         }
@@ -551,7 +704,8 @@ public class ReactAccessibilityDelegate extends ExploreByTouchHelper {
             || view.getTag(R.id.accessibility_actions) != null
             || view.getTag(R.id.react_test_id) != null
             || view.getTag(R.id.accessibility_collection_item) != null
-            || view.getTag(R.id.accessibility_links) != null)) {
+            || view.getTag(R.id.accessibility_links) != null
+            || view.getTag(R.id.role) != null)) {
       ViewCompat.setAccessibilityDelegate(
           view,
           new ReactAccessibilityDelegate(view, originalFocus, originalImportantForAccessibility));
@@ -636,9 +790,18 @@ public class ReactAccessibilityDelegate extends ExploreByTouchHelper {
       return;
     }
 
+    // NOTE: The span may not actually have visible bounds within its parent,
+    // due to line limits, etc.
+    final Rect bounds = getBoundsInParent(accessibleTextSpan);
+    if (bounds == 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.setBoundsInParent(bounds);
     node.setRoleDescription(mView.getResources().getString(R.string.link_description));
     node.setClassName(AccessibilityRole.getValue(AccessibilityRole.BUTTON));
   }
@@ -655,10 +818,19 @@ public class ReactAccessibilityDelegate extends ExploreByTouchHelper {
       return new Rect(0, 0, textView.getWidth(), textView.getHeight());
     }
 
-    Rect rootRect = new Rect();
-
     double startOffset = accessibleLink.start;
     double endOffset = accessibleLink.end;
+
+    // Ensure the link hasn't been ellipsized away; in such cases,
+    // getPrimaryHorizontal will crash (and the link isn't rendered anyway).
+    int startOffsetLineNumber = textViewLayout.getLineForOffset((int) startOffset);
+    int lineEndOffset = textViewLayout.getLineEnd(startOffsetLineNumber);
+    if (startOffset > lineEndOffset) {
+      return null;
+    }
+
+    Rect rootRect = new Rect();
+
     double startXCoordinates = textViewLayout.getPrimaryHorizontal((int) startOffset);
 
     final Paint paint = new Paint();
@@ -668,7 +840,6 @@ public class ReactAccessibilityDelegate extends ExploreByTouchHelper {
     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);

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

@@ -123,9 +123,9 @@ public interface ReactShadowNode<T extends ReactShadowNode> {
    */
   void onCollectExtraUpdates(UIViewOperationQueue uiViewOperationQueue);
 
-  /** @return true if layout (position or dimensions) changed, false otherwise. */
+  /* package */ boolean dispatchUpdatesWillChangeLayout(float absoluteX, float absoluteY);
 
-  /* package */ boolean dispatchUpdates(
+  /* package */ void dispatchUpdates(
       float absoluteX,
       float absoluteY,
       UIViewOperationQueue uiViewOperationQueue,