react-native-tvos 0.78.0-0rc4 → 0.79.0-0

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

@@ -8,22 +8,15 @@
 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.Layout;
-import android.text.Spannable;
-import android.text.Spanned;
 import android.text.TextUtils;
-import android.text.style.AbsoluteSizeSpan;
-import android.text.style.ClickableSpan;
 import android.view.View;
 import android.view.ViewGroup;
 import android.view.accessibility.AccessibilityEvent;
 import android.widget.EditText;
-import android.widget.TextView;
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 import androidx.core.view.ViewCompat;
@@ -44,12 +37,10 @@ import com.facebook.react.bridge.ReadableMapKeySetIterator;
 import com.facebook.react.bridge.ReadableType;
 import com.facebook.react.bridge.UIManager;
 import com.facebook.react.bridge.WritableMap;
-import com.facebook.react.uimanager.ReactAccessibilityDelegate.AccessibilityRole;
 import com.facebook.react.uimanager.common.ViewUtil;
 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;
 
@@ -59,15 +50,25 @@ import java.util.List;
  */
 public class ReactAccessibilityDelegate extends ExploreByTouchHelper {
 
-  private static final String TAG = "ReactAccessibilityDelegate";
   public static final String TOP_ACCESSIBILITY_ACTION_EVENT = "topAccessibilityAction";
+  public static final HashMap<String, Integer> sActionIdMap = new HashMap<>();
+
+  private static final String TAG = "ReactAccessibilityDelegate";
   private static int sCounter = 0x3f000000;
   private static final int TIMEOUT_SEND_ACCESSIBILITY_EVENT = 200;
   private static final int SEND_EVENT = 1;
   private static final String delimiter = ", ";
   private static final int delimiterLength = delimiter.length();
+  // State constants for states which have analogs in AccessibilityNodeInfo
+  private static final String STATE_DISABLED = "disabled";
+  private static final String STATE_SELECTED = "selected";
+  private static final String STATE_CHECKED = "checked";
 
-  public static final HashMap<String, Integer> sActionIdMap = new HashMap<>();
+  private final View mView;
+  private Handler mHandler;
+  private final HashMap<Integer, String> mAccessibilityActionsMap;
+
+  @Nullable View mAccessibilityLabelledBy;
 
   static {
     sActionIdMap.put("activate", AccessibilityActionCompat.ACTION_CLICK.getId());
@@ -79,375 +80,96 @@ public class ReactAccessibilityDelegate extends ExploreByTouchHelper {
     sActionIdMap.put("accessibilityFocus", AccessibilityActionCompat.ACTION_ACCESSIBILITY_FOCUS.getId());
   }
 
-  private final View mView;
-  private final AccessibilityLinks mAccessibilityLinks;
+  public ReactAccessibilityDelegate(
+      final View view, boolean originalFocus, int originalImportantForAccessibility) {
+    super(view);
+    mView = view;
+    mAccessibilityActionsMap = new HashMap<Integer, String>();
+    mHandler =
+        new Handler() {
+          @Override
+          public void handleMessage(Message msg) {
+            View host = (View) msg.obj;
+            host.sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_SELECTED);
+          }
+        };
 
-  private Handler mHandler;
+    // 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);
+  }
 
-  /**
-   * Schedule a command for sending an accessibility event. </br> Note: A command is used to ensure
-   * that accessibility events are sent at most one in a given time frame to save system resources
-   * while the progress changes quickly.
-   */
-  private void scheduleAccessibilityEventSender(View host) {
-    if (mHandler.hasMessages(SEND_EVENT, host)) {
-      mHandler.removeMessages(SEND_EVENT, host);
+  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.
+    if (!ViewCompat.hasAccessibilityDelegate(view)
+        && (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
+            || view.getTag(R.id.accessibility_collection_item) != null
+            || view.getTag(R.id.accessibility_links) != null
+            || view.getTag(R.id.role) != null)) {
+      ViewCompat.setAccessibilityDelegate(
+          view,
+          new ReactAccessibilityDelegate(view, originalFocus, originalImportantForAccessibility));
     }
-    Message msg = mHandler.obtainMessage(SEND_EVENT, host);
-    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;
+  // 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));
+  }
 
-    public static @Nullable Role fromValue(@Nullable String value) {
-      for (Role role : Role.values()) {
-        if (role.name().equalsIgnoreCase(value)) {
-          return role;
-        }
+  // The View this delegate is attached to
+  protected View getHostView() {
+    return mView;
+  }
+
+  @Override
+  public void onInitializeAccessibilityNodeInfo(View host, AccessibilityNodeInfoCompat info) {
+    super.onInitializeAccessibilityNodeInfo(host, info);
+    if (host.getTag(R.id.accessibility_state_expanded) != null) {
+      final boolean accessibilityStateExpanded =
+          (boolean) host.getTag(R.id.accessibility_state_expanded);
+      info.addAction(
+          accessibilityStateExpanded
+              ? AccessibilityNodeInfoCompat.ACTION_COLLAPSE
+              : AccessibilityNodeInfoCompat.ACTION_EXPAND);
+    }
+    final AccessibilityRole accessibilityRole = AccessibilityRole.fromViewTag(host);
+    final String accessibilityHint = (String) host.getTag(R.id.accessibility_hint);
+    if (accessibilityRole != null) {
+      setRole(info, accessibilityRole, host.getContext());
+    }
+
+    if (accessibilityHint != null) {
+      info.setTooltipText(accessibilityHint);
+    }
+
+    final Object accessibilityLabelledBy = host.getTag(R.id.labelled_by);
+    if (accessibilityLabelledBy != null) {
+      mAccessibilityLabelledBy =
+          ReactFindViewUtil.findView(host.getRootView(), (String) accessibilityLabelledBy);
+      if (mAccessibilityLabelledBy != null) {
+        info.setLabeledBy(mAccessibilityLabelledBy);
       }
-      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:
-   *
-   * <p>https://github.com/google/talkback/blob/master/utils/src/main/java/Role.java
-   */
-  public enum AccessibilityRole {
-    NONE,
-    BUTTON,
-    DROPDOWNLIST,
-    TOGGLEBUTTON,
-    LINK,
-    SEARCH,
-    IMAGE,
-    IMAGEBUTTON,
-    KEYBOARDKEY,
-    TEXT,
-    ADJUSTABLE,
-    SUMMARY,
-    HEADER,
-    ALERT,
-    CHECKBOX,
-    COMBOBOX,
-    MENU,
-    MENUBAR,
-    MENUITEM,
-    PROGRESSBAR,
-    RADIO,
-    RADIOGROUP,
-    SCROLLBAR,
-    SPINBUTTON,
-    SWITCH,
-    TAB,
-    TABLIST,
-    TIMER,
-    LIST,
-    GRID,
-    PAGER,
-    SCROLLVIEW,
-    HORIZONTALSCROLLVIEW,
-    VIEWGROUP,
-    WEBVIEW,
-    DRAWERLAYOUT,
-    SLIDINGDRAWER,
-    ICONMENU,
-    TOOLBAR;
-
-    public static String getValue(AccessibilityRole role) {
-      switch (role) {
-        case BUTTON:
-          return "android.widget.Button";
-        case DROPDOWNLIST:
-          return "android.widget.Spinner";
-        case TOGGLEBUTTON:
-          return "android.widget.ToggleButton";
-        case SEARCH:
-          return "android.widget.EditText";
-        case IMAGE:
-          return "android.widget.ImageView";
-        case IMAGEBUTTON:
-          return "android.widget.ImageButton";
-        case KEYBOARDKEY:
-          return "android.inputmethodservice.Keyboard$Key";
-        case TEXT:
-          return "android.widget.TextView";
-        case ADJUSTABLE:
-          return "android.widget.SeekBar";
-        case CHECKBOX:
-          return "android.widget.CheckBox";
-        case RADIO:
-          return "android.widget.RadioButton";
-        case SPINBUTTON:
-          return "android.widget.SpinButton";
-        case SWITCH:
-          return "android.widget.Switch";
-        case LIST:
-          return "android.widget.AbsListView";
-        case GRID:
-          return "android.widget.GridView";
-        case SCROLLVIEW:
-          return "android.widget.ScrollView";
-        case HORIZONTALSCROLLVIEW:
-          return "android.widget.HorizontalScrollView";
-        case PAGER:
-          return "androidx.viewpager.widget.ViewPager";
-        case DRAWERLAYOUT:
-          return "androidx.drawerlayout.widget.DrawerLayout";
-        case SLIDINGDRAWER:
-          return "android.widget.SlidingDrawer";
-        case ICONMENU:
-          return "com.android.internal.view.menu.IconMenuView";
-        case VIEWGROUP:
-          return "android.view.ViewGroup";
-        case WEBVIEW:
-          return "android.webkit.WebView";
-        case NONE:
-        case LINK:
-        case SUMMARY:
-        case HEADER:
-        case ALERT:
-        case COMBOBOX:
-        case MENU:
-        case MENUBAR:
-        case MENUITEM:
-        case PROGRESSBAR:
-        case RADIOGROUP:
-        case SCROLLBAR:
-        case TAB:
-        case TABLIST:
-        case TIMER:
-        case TOOLBAR:
-          return "android.view.View";
-        default:
-          throw new IllegalArgumentException("Invalid accessibility role value: " + role);
-      }
-    }
-
-    public static AccessibilityRole fromValue(@Nullable String value) {
-      if (value == null) {
-        return NONE;
-      }
-
-      for (AccessibilityRole role : AccessibilityRole.values()) {
-        if (role.name().equalsIgnoreCase(value)) {
-          return role;
-        }
-      }
-      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;
-
-  // State constants for states which have analogs in AccessibilityNodeInfo
-
-  private static final String STATE_DISABLED = "disabled";
-  private static final String STATE_SELECTED = "selected";
-  private static final String STATE_CHECKED = "checked";
-
-  public ReactAccessibilityDelegate(
-      final View view, boolean originalFocus, int originalImportantForAccessibility) {
-    super(view);
-    mView = view;
-    mAccessibilityActionsMap = new HashMap<Integer, String>();
-    mHandler =
-        new Handler() {
-          @Override
-          public void handleMessage(Message msg) {
-            View host = (View) msg.obj;
-            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;
-
-  @Override
-  public void onInitializeAccessibilityNodeInfo(View host, AccessibilityNodeInfoCompat info) {
-    super.onInitializeAccessibilityNodeInfo(host, info);
-    if (host.getTag(R.id.accessibility_state_expanded) != null) {
-      final boolean accessibilityStateExpanded =
-          (boolean) host.getTag(R.id.accessibility_state_expanded);
-      info.addAction(
-          accessibilityStateExpanded
-              ? AccessibilityNodeInfoCompat.ACTION_COLLAPSE
-              : AccessibilityNodeInfoCompat.ACTION_EXPAND);
-    }
-    final AccessibilityRole accessibilityRole = AccessibilityRole.fromViewTag(host);
-    final String accessibilityHint = (String) host.getTag(R.id.accessibility_hint);
-    if (accessibilityRole != null) {
-      setRole(info, accessibilityRole, host.getContext());
-    }
-
-    if (accessibilityHint != null) {
-      info.setTooltipText(accessibilityHint);
-    }
-
-    final Object accessibilityLabelledBy = host.getTag(R.id.labelled_by);
-    if (accessibilityLabelledBy != null) {
-      mAccessibilityLabelledBy =
-          ReactFindViewUtil.findView(host.getRootView(), (String) accessibilityLabelledBy);
-      if (mAccessibilityLabelledBy != null) {
-        info.setLabeledBy(mAccessibilityLabelledBy);
-      }
-    }
-
-    // state is changeable.
-    final ReadableMap accessibilityState = (ReadableMap) host.getTag(R.id.accessibility_state);
-    if (accessibilityState != null) {
-      setState(info, accessibilityState, host.getContext());
-    }
-    final ReadableArray accessibilityActions =
-        (ReadableArray) host.getTag(R.id.accessibility_actions);
+    // state is changeable.
+    final ReadableMap accessibilityState = (ReadableMap) host.getTag(R.id.accessibility_state);
+    if (accessibilityState != null) {
+      setState(info, accessibilityState, host.getContext());
+    }
+    final ReadableArray accessibilityActions =
+        (ReadableArray) host.getTag(R.id.accessibility_actions);
 
     final ReadableMap accessibilityCollectionItem =
         (ReadableMap) host.getTag(R.id.accessibility_collection_item);
@@ -622,7 +344,6 @@ public class ReactAccessibilityDelegate extends ExploreByTouchHelper {
       final AccessibilityRole accessibilityRole =
           (AccessibilityRole) host.getTag(R.id.accessibility_role);
       final ReadableMap accessibilityValue = (ReadableMap) host.getTag(R.id.accessibility_value);
-
       if (accessibilityRole == AccessibilityRole.ADJUSTABLE
           && (action == AccessibilityActionCompat.ACTION_SCROLL_FORWARD.getId()
               || action == AccessibilityActionCompat.ACTION_SCROLL_BACKWARD.getId())) {
@@ -631,18 +352,29 @@ public class ReactAccessibilityDelegate extends ExploreByTouchHelper {
         }
         return super.performAccessibilityAction(host, action, args);
       }
-
       // When checking the accessibility focus action, we don't want to intercept the native event
       // otherwise it would intercept the change of focus
       if (action == AccessibilityActionCompat.ACTION_ACCESSIBILITY_FOCUS.getId()) {
         return super.performAccessibilityAction(host, action, args);
       }
-
       return true;
     }
     return super.performAccessibilityAction(host, action, args);
   }
 
+  /**
+   * Schedule a command for sending an accessibility event. </br> Note: A command is used to ensure
+   * that accessibility events are sent at most one in a given time frame to save system resources
+   * while the progress changes quickly.
+   */
+  private void scheduleAccessibilityEventSender(View host) {
+    if (mHandler.hasMessages(SEND_EVENT, host)) {
+      mHandler.removeMessages(SEND_EVENT, host);
+    }
+    Message msg = mHandler.obtainMessage(SEND_EVENT, host);
+    mHandler.sendMessageDelayed(msg, TIMEOUT_SEND_ACCESSIBILITY_EVENT);
+  }
+
   private static void setState(
       AccessibilityNodeInfoCompat info, ReadableMap accessibilityState, Context context) {
     final ReadableMapKeySetIterator i = accessibilityState.keySetIterator();
@@ -661,10 +393,7 @@ public class ReactAccessibilityDelegate extends ExploreByTouchHelper {
     }
   }
 
-  /** Strings for setting the Role Description in english */
-
   // TODO: Eventually support for other languages on talkback
-
   public static void setRole(
       AccessibilityNodeInfoCompat nodeInfo, AccessibilityRole role, final Context context) {
     if (role == null) {
@@ -716,173 +445,20 @@ public class ReactAccessibilityDelegate extends ExploreByTouchHelper {
     }
   }
 
-  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.
-    if (!ViewCompat.hasAccessibilityDelegate(view)
-        && (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
-            || view.getTag(R.id.accessibility_collection_item) != null
-            || view.getTag(R.id.accessibility_links) != null
-            || view.getTag(R.id.role) != 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;
+    return INVALID_ID;
   }
 
   @Override
-  protected void getVisibleVirtualViews(List<Integer> virtualViewIds) {
-    if (mAccessibilityLinks == null) {
-      return;
-    }
-
-    for (int i = 0; i < mAccessibilityLinks.size(); i++) {
-      virtualViewIds.add(i);
-    }
-  }
+  protected void getVisibleVirtualViews(List<Integer> virtualViewIds) {}
 
   @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;
-    }
-
-    // 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(bounds);
-    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());
-    }
-
-    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();
-    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 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);
-  }
+    node.setContentDescription("");
+    node.setBoundsInParent(new Rect(0, 0, 1, 1));
+  }
 
   @Override
   protected boolean onPerformActionForVirtualView(
@@ -890,97 +466,17 @@ public class ReactAccessibilityDelegate extends ExploreByTouchHelper {
     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;
   }
 
+  // This exists so classes that extend this can properly call super's impl of this method while
+  // still being able to override it properly for this class
+  public @Nullable AccessibilityNodeProviderCompat superGetAccessibilityNodeProvider(View host) {
+    return super.getAccessibilityNodeProvider(host);
+  }
+
   /**
    * Determines if the supplied {@link View} and {@link AccessibilityNodeInfoCompat} has any
    * children which are not independently accessibility focusable and also have a spoken
@@ -1224,11 +720,8 @@ public class ReactAccessibilityDelegate extends ExploreByTouchHelper {
         return talkbackSegments;
       }
 
-      // EditText
+      // TextView
       if (hasNodeText) {
-        // skipped status checks above for EditText
-
-        // description
         talkbackSegments.append(nodeText);
         return talkbackSegments;
       }
@@ -1271,4 +764,285 @@ public class ReactAccessibilityDelegate extends ExploreByTouchHelper {
     }
     return builder.toString();
   }
+
+  /**
+   * 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:
+   *
+   * <p>https://github.com/google/talkback/blob/master/utils/src/main/java/Role.java
+   */
+  public enum AccessibilityRole {
+    NONE,
+    BUTTON,
+    DROPDOWNLIST,
+    TOGGLEBUTTON,
+    LINK,
+    SEARCH,
+    IMAGE,
+    IMAGEBUTTON,
+    KEYBOARDKEY,
+    TEXT,
+    ADJUSTABLE,
+    SUMMARY,
+    HEADER,
+    ALERT,
+    CHECKBOX,
+    COMBOBOX,
+    MENU,
+    MENUBAR,
+    MENUITEM,
+    PROGRESSBAR,
+    RADIO,
+    RADIOGROUP,
+    SCROLLBAR,
+    SPINBUTTON,
+    SWITCH,
+    TAB,
+    TABLIST,
+    TIMER,
+    LIST,
+    GRID,
+    PAGER,
+    SCROLLVIEW,
+    HORIZONTALSCROLLVIEW,
+    VIEWGROUP,
+    WEBVIEW,
+    DRAWERLAYOUT,
+    SLIDINGDRAWER,
+    ICONMENU,
+    TOOLBAR;
+
+    public static String getValue(AccessibilityRole role) {
+      switch (role) {
+        case BUTTON:
+          return "android.widget.Button";
+        case DROPDOWNLIST:
+          return "android.widget.Spinner";
+        case TOGGLEBUTTON:
+          return "android.widget.ToggleButton";
+        case SEARCH:
+          return "android.widget.EditText";
+        case IMAGE:
+          return "android.widget.ImageView";
+        case IMAGEBUTTON:
+          return "android.widget.ImageButton";
+        case KEYBOARDKEY:
+          return "android.inputmethodservice.Keyboard$Key";
+        case TEXT:
+          return "android.widget.TextView";
+        case ADJUSTABLE:
+          return "android.widget.SeekBar";
+        case CHECKBOX:
+          return "android.widget.CheckBox";
+        case RADIO:
+          return "android.widget.RadioButton";
+        case SPINBUTTON:
+          return "android.widget.SpinButton";
+        case SWITCH:
+          return "android.widget.Switch";
+        case LIST:
+          return "android.widget.AbsListView";
+        case GRID:
+          return "android.widget.GridView";
+        case SCROLLVIEW:
+          return "android.widget.ScrollView";
+        case HORIZONTALSCROLLVIEW:
+          return "android.widget.HorizontalScrollView";
+        case PAGER:
+          return "androidx.viewpager.widget.ViewPager";
+        case DRAWERLAYOUT:
+          return "androidx.drawerlayout.widget.DrawerLayout";
+        case SLIDINGDRAWER:
+          return "android.widget.SlidingDrawer";
+        case ICONMENU:
+          return "com.android.internal.view.menu.IconMenuView";
+        case VIEWGROUP:
+          return "android.view.ViewGroup";
+        case WEBVIEW:
+          return "android.webkit.WebView";
+        case NONE:
+        case LINK:
+        case SUMMARY:
+        case HEADER:
+        case ALERT:
+        case COMBOBOX:
+        case MENU:
+        case MENUBAR:
+        case MENUITEM:
+        case PROGRESSBAR:
+        case RADIOGROUP:
+        case SCROLLBAR:
+        case TAB:
+        case TABLIST:
+        case TIMER:
+        case TOOLBAR:
+          return "android.view.View";
+        default:
+          throw new IllegalArgumentException("Invalid accessibility role value: " + role);
+      }
+    }
+
+    public static AccessibilityRole fromValue(@Nullable String value) {
+      if (value == null) {
+        return NONE;
+      }
+
+      for (AccessibilityRole role : AccessibilityRole.values()) {
+        if (role.name().equalsIgnoreCase(value)) {
+          return role;
+        }
+      }
+      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);
+      }
+    }
+  }
 }