react-native-tvos 0.71.13-1 → 0.72.4-0

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

@@ -16,10 +16,13 @@ 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;
@@ -41,6 +44,8 @@ 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;
@@ -59,6 +64,8 @@ public class ReactAccessibilityDelegate extends ExploreByTouchHelper {
   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();
 
   public static final HashMap<String, Integer> sActionIdMap = new HashMap<>();
 
@@ -67,6 +74,8 @@ public class ReactAccessibilityDelegate extends ExploreByTouchHelper {
     sActionIdMap.put("longpress", AccessibilityActionCompat.ACTION_LONG_CLICK.getId());
     sActionIdMap.put("increment", AccessibilityActionCompat.ACTION_SCROLL_FORWARD.getId());
     sActionIdMap.put("decrement", AccessibilityActionCompat.ACTION_SCROLL_BACKWARD.getId());
+    sActionIdMap.put("expand", AccessibilityActionCompat.ACTION_EXPAND.getId());
+    sActionIdMap.put("collapse", AccessibilityActionCompat.ACTION_COLLAPSE.getId());
   }
 
   private final View mView;
@@ -96,6 +105,7 @@ public class ReactAccessibilityDelegate extends ExploreByTouchHelper {
   public enum AccessibilityRole {
     NONE,
     BUTTON,
+    DROPDOWNLIST,
     TOGGLEBUTTON,
     LINK,
     SEARCH,
@@ -123,12 +133,22 @@ public class ReactAccessibilityDelegate extends ExploreByTouchHelper {
     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:
@@ -136,7 +156,7 @@ public class ReactAccessibilityDelegate extends ExploreByTouchHelper {
         case IMAGE:
           return "android.widget.ImageView";
         case IMAGEBUTTON:
-          return "android.widget.ImageButon";
+          return "android.widget.ImageButton";
         case KEYBOARDKEY:
           return "android.inputmethodservice.Keyboard$Key";
         case TEXT:
@@ -155,6 +175,22 @@ public class ReactAccessibilityDelegate extends ExploreByTouchHelper {
           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:
@@ -223,6 +259,14 @@ public class ReactAccessibilityDelegate extends ExploreByTouchHelper {
   @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) host.getTag(R.id.accessibility_role);
     final String accessibilityHint = (String) host.getTag(R.id.accessibility_hint);
@@ -319,6 +363,17 @@ public class ReactAccessibilityDelegate extends ExploreByTouchHelper {
     if (testId != null) {
       info.setViewIdResourceName(testId);
     }
+    boolean missingContentDescription = TextUtils.isEmpty(info.getContentDescription());
+    boolean missingText = TextUtils.isEmpty(info.getText());
+    boolean missingTextAndDescription = missingContentDescription && missingText;
+    boolean hasContentToAnnounce =
+        accessibilityActions != null
+            || accessibilityState != null
+            || accessibilityLabelledBy != null
+            || accessibilityRole != null;
+    if (missingTextAndDescription && hasContentToAnnounce) {
+      info.setContentDescription(getTalkbackDescription(host, info));
+    }
   }
 
   @Override
@@ -353,6 +408,12 @@ public class ReactAccessibilityDelegate extends ExploreByTouchHelper {
 
   @Override
   public boolean performAccessibilityAction(View host, int action, Bundle args) {
+    if (action == AccessibilityNodeInfoCompat.ACTION_COLLAPSE) {
+      host.setTag(R.id.accessibility_state_expanded, false);
+    }
+    if (action == AccessibilityNodeInfoCompat.ACTION_EXPAND) {
+      host.setTag(R.id.accessibility_state_expanded, true);
+    }
     if (mAccessibilityActionsMap.containsKey(action)) {
       final WritableMap event = Arguments.createMap();
       event.putString("actionName", mAccessibilityActionsMap.get(action));
@@ -360,7 +421,8 @@ public class ReactAccessibilityDelegate extends ExploreByTouchHelper {
       if (reactContext.hasActiveReactInstance()) {
         final int reactTag = host.getId();
         final int surfaceId = UIManagerHelper.getSurfaceId(reactContext);
-        UIManager uiManager = UIManagerHelper.getUIManager(reactContext, reactTag);
+        UIManager uiManager =
+            UIManagerHelper.getUIManager(reactContext, ViewUtil.getUIManagerType(reactTag));
         if (uiManager != null) {
           uiManager
               .<EventDispatcher>getEventDispatcher()
@@ -724,4 +786,295 @@ public class ReactAccessibilityDelegate extends ExploreByTouchHelper {
 
     return null;
   }
+
+  /**
+   * Determines if the supplied {@link View} and {@link AccessibilityNodeInfoCompat} has any
+   * children which are not independently accessibility focusable and also have a spoken
+   * description.
+   *
+   * <p>NOTE: Accessibility services will include these children's descriptions in the closest
+   * focusable ancestor.
+   *
+   * @param view The {@link View} to evaluate
+   * @param node The {@link AccessibilityNodeInfoCompat} to evaluate
+   * @return {@code true} if it has any non-actionable speaking descendants within its subtree
+   */
+  public static boolean hasNonActionableSpeakingDescendants(
+      @Nullable AccessibilityNodeInfoCompat node, @Nullable View view) {
+
+    if (node == null || view == null || !(view instanceof ViewGroup)) {
+      return false;
+    }
+
+    final ViewGroup viewGroup = (ViewGroup) view;
+    for (int i = 0, count = viewGroup.getChildCount(); i < count; i++) {
+      final View childView = viewGroup.getChildAt(i);
+
+      if (childView == null) {
+        continue;
+      }
+
+      final AccessibilityNodeInfoCompat childNode = AccessibilityNodeInfoCompat.obtain();
+      try {
+        ViewCompat.onInitializeAccessibilityNodeInfo(childView, childNode);
+
+        if (!childNode.isVisibleToUser()) {
+          continue;
+        }
+
+        if (isAccessibilityFocusable(childNode, childView)) {
+          continue;
+        }
+
+        if (isSpeakingNode(childNode, childView)) {
+          return true;
+        }
+      } finally {
+        if (childNode != null) {
+          childNode.recycle();
+        }
+      }
+    }
+
+    return false;
+  }
+
+  /**
+   * Returns whether the node has valid RangeInfo.
+   *
+   * @param node The node to check.
+   * @return Whether the node has valid RangeInfo.
+   */
+  public static boolean hasValidRangeInfo(@Nullable AccessibilityNodeInfoCompat node) {
+    if (node == null) {
+      return false;
+    }
+
+    @Nullable final RangeInfoCompat rangeInfo = node.getRangeInfo();
+    if (rangeInfo == null) {
+      return false;
+    }
+
+    final float maxProgress = rangeInfo.getMax();
+    final float minProgress = rangeInfo.getMin();
+    final float currentProgress = rangeInfo.getCurrent();
+    final float diffProgress = maxProgress - minProgress;
+    return (diffProgress > 0.0f)
+        && (currentProgress >= minProgress)
+        && (currentProgress <= maxProgress);
+  }
+
+  /**
+   * Returns whether the specified node has state description.
+   *
+   * @param node The node to check.
+   * @return {@code true} if the node has state description.
+   */
+  private static boolean hasStateDescription(@Nullable AccessibilityNodeInfoCompat node) {
+    return node != null
+        && (!TextUtils.isEmpty(node.getStateDescription())
+            || node.isCheckable()
+            || hasValidRangeInfo(node));
+  }
+
+  /**
+   * Returns whether the supplied {@link View} and {@link AccessibilityNodeInfoCompat} would produce
+   * spoken feedback if it were accessibility focused. NOTE: not all speaking nodes are focusable.
+   *
+   * @param view The {@link View} to evaluate
+   * @param node The {@link AccessibilityNodeInfoCompat} to evaluate
+   * @return {@code true} if it meets the criterion for producing spoken feedback
+   */
+  public static boolean isSpeakingNode(
+      @Nullable AccessibilityNodeInfoCompat node, @Nullable View view) {
+    if (node == null || view == null) {
+      return false;
+    }
+
+    final int important = ViewCompat.getImportantForAccessibility(view);
+    if (important == ViewCompat.IMPORTANT_FOR_ACCESSIBILITY_NO_HIDE_DESCENDANTS
+        || (important == ViewCompat.IMPORTANT_FOR_ACCESSIBILITY_NO && node.getChildCount() <= 0)) {
+      return false;
+    }
+
+    return hasText(node)
+        || hasStateDescription(node)
+        || node.isCheckable()
+        || hasNonActionableSpeakingDescendants(node, view);
+  }
+
+  public static boolean hasText(@Nullable AccessibilityNodeInfoCompat node) {
+    return node != null
+        && node.getCollectionInfo() == null
+        && (!TextUtils.isEmpty(node.getText())
+            || !TextUtils.isEmpty(node.getContentDescription())
+            || !TextUtils.isEmpty(node.getHintText()));
+  }
+
+  /**
+   * Determines if the provided {@link View} and {@link AccessibilityNodeInfoCompat} meet the
+   * criteria for gaining accessibility focus.
+   *
+   * <p>Note: this is evaluating general focusability by accessibility services, and does not mean
+   * this view will be guaranteed to be focused by specific services such as Talkback. For Talkback
+   * focusability, see {@link #isTalkbackFocusable(View)}
+   *
+   * @param view The {@link View} to evaluate
+   * @param node The {@link AccessibilityNodeInfoCompat} to evaluate
+   * @return {@code true} if it is possible to gain accessibility focus
+   */
+  public static boolean isAccessibilityFocusable(
+      @Nullable AccessibilityNodeInfoCompat node, @Nullable View view) {
+    if (node == null || view == null) {
+      return false;
+    }
+
+    // Never focus invisible nodes.
+    if (!node.isVisibleToUser()) {
+      return false;
+    }
+
+    // Always focus "actionable" nodes.
+    return node.isScreenReaderFocusable() || isActionableForAccessibility(node);
+  }
+
+  /**
+   * Returns whether a node is actionable. That is, the node supports one of {@link
+   * AccessibilityNodeInfoCompat#isClickable()}, {@link AccessibilityNodeInfoCompat#isFocusable()},
+   * or {@link AccessibilityNodeInfoCompat#isLongClickable()}.
+   *
+   * @param node The {@link AccessibilityNodeInfoCompat} to evaluate
+   * @return {@code true} if node is actionable.
+   */
+  public static boolean isActionableForAccessibility(@Nullable AccessibilityNodeInfoCompat node) {
+    if (node == null) {
+      return false;
+    }
+
+    if (node.isClickable() || node.isLongClickable() || node.isFocusable()) {
+      return true;
+    }
+
+    final List actionList = node.getActionList();
+    return actionList.contains(AccessibilityNodeInfoCompat.ACTION_CLICK)
+        || actionList.contains(AccessibilityNodeInfoCompat.ACTION_LONG_CLICK)
+        || actionList.contains(AccessibilityNodeInfoCompat.ACTION_FOCUS);
+  }
+
+  /**
+   * Returns a cached instance if such is available otherwise a new one.
+   *
+   * @param view The {@link View} to derive the AccessibilityNodeInfo properties from.
+   * @return {@link FlipperObject} containing the properties.
+   */
+  @Nullable
+  public static AccessibilityNodeInfoCompat createNodeInfoFromView(View view) {
+    if (view == null) {
+      return null;
+    }
+
+    final AccessibilityNodeInfoCompat nodeInfo = AccessibilityNodeInfoCompat.obtain();
+
+    // For some unknown reason, Android seems to occasionally throw a NPE from
+    // onInitializeAccessibilityNodeInfo.
+    try {
+      ViewCompat.onInitializeAccessibilityNodeInfo(view, nodeInfo);
+    } catch (NullPointerException e) {
+      if (nodeInfo != null) {
+        nodeInfo.recycle();
+      }
+      return null;
+    }
+
+    return nodeInfo;
+  }
+
+  /**
+   * Creates the text that Google's TalkBack screen reader will read aloud for a given {@link View}.
+   * This may be any combination of the {@link View}'s {@code text}, {@code contentDescription}, and
+   * the {@code text} and {@code contentDescription} of any ancestor {@link View}.
+   *
+   * <p>This description is generally ported over from Google's TalkBack screen reader, and this
+   * should be kept up to date with their implementation (as much as necessary). Details can be seen
+   * in their source code here:
+   *
+   * <p>https://github.com/google/talkback/compositor/src/main/res/raw/compositor.json - search for
+   * "get_description_for_tree", "append_description_for_tree", "description_for_tree_nodes"
+   *
+   * @param view The {@link View} to evaluate.
+   * @param info The default {@link AccessibilityNodeInfoCompat}.
+   * @return {@code String} representing what talkback will say when a {@link View} is focused.
+   */
+  @Nullable
+  public static CharSequence getTalkbackDescription(
+      View view, @Nullable AccessibilityNodeInfoCompat info) {
+    final AccessibilityNodeInfoCompat node =
+        info == null ? createNodeInfoFromView(view) : AccessibilityNodeInfoCompat.obtain(info);
+
+    if (node == null) {
+      return null;
+    }
+    try {
+      final CharSequence contentDescription = node.getContentDescription();
+      final CharSequence nodeText = node.getText();
+
+      final boolean hasNodeText = !TextUtils.isEmpty(nodeText);
+      final boolean isEditText = view instanceof EditText;
+
+      StringBuilder talkbackSegments = new StringBuilder();
+
+      // EditText's prioritize their own text content over a contentDescription so skip this
+      if (!TextUtils.isEmpty(contentDescription) && (!isEditText || !hasNodeText)) {
+        // next add content description
+        talkbackSegments.append(contentDescription);
+        return talkbackSegments;
+      }
+
+      // EditText
+      if (hasNodeText) {
+        // skipped status checks above for EditText
+
+        // description
+        talkbackSegments.append(nodeText);
+        return talkbackSegments;
+      }
+
+      // If there are child views and no contentDescription the text of all non-focusable children,
+      // comma separated, becomes the description.
+      if (view instanceof ViewGroup) {
+        final StringBuilder concatChildDescription = new StringBuilder();
+        final ViewGroup viewGroup = (ViewGroup) view;
+
+        for (int i = 0, count = viewGroup.getChildCount(); i < count; i++) {
+          final View child = viewGroup.getChildAt(i);
+
+          final AccessibilityNodeInfoCompat childNodeInfo = AccessibilityNodeInfoCompat.obtain();
+          ViewCompat.onInitializeAccessibilityNodeInfo(child, childNodeInfo);
+
+          if (isSpeakingNode(childNodeInfo, child)
+              && !isAccessibilityFocusable(childNodeInfo, child)) {
+            CharSequence childNodeDescription = getTalkbackDescription(child, null);
+            if (!TextUtils.isEmpty(childNodeDescription)) {
+              concatChildDescription.append(childNodeDescription + delimiter);
+            }
+          }
+          childNodeInfo.recycle();
+        }
+
+        return removeFinalDelimiter(concatChildDescription);
+      }
+
+      return null;
+    } finally {
+      node.recycle();
+    }
+  }
+
+  private static String removeFinalDelimiter(StringBuilder builder) {
+    int end = builder.length();
+    if (end > 0) {
+      builder.delete(end - delimiterLength, end);
+    }
+    return builder.toString();
+  }
 }

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

@@ -47,10 +47,18 @@ public class Spacing {
    * Spacing type that represents all directions (left, top, right, bottom). E.g. {@code margin}.
    */
   public static final int ALL = 8;
+  /** Spacing type that represents block directions (top, bottom). E.g. {@code marginBlock}. */
+  public static final int BLOCK = 9;
+  /** Spacing type that represents the block end direction (bottom). E.g. {@code marginBlockEnd}. */
+  public static final int BLOCK_END = 10;
+  /**
+   * Spacing type that represents the block start direction (top). E.g. {@code marginBlockStart}.
+   */
+  public static final int BLOCK_START = 11;
 
   private static final int[] sFlagsMap = {
     1, /*LEFT*/ 2, /*TOP*/ 4, /*RIGHT*/ 8, /*BOTTOM*/ 16, /*START*/ 32, /*END*/ 64, /*HORIZONTAL*/
-    128, /*VERTICAL*/ 256, /*ALL*/
+    128, /*VERTICAL*/ 256, /*ALL*/ 512, /*BLOCK*/ 1024, /*BLOCK_END*/ 2048, /*BLOCK_START*/
   };
 
   private final float[] mSpacing;
@@ -96,7 +104,8 @@ public class Spacing {
       mHasAliasesSet =
           (mValueFlags & sFlagsMap[ALL]) != 0
               || (mValueFlags & sFlagsMap[VERTICAL]) != 0
-              || (mValueFlags & sFlagsMap[HORIZONTAL]) != 0;
+              || (mValueFlags & sFlagsMap[HORIZONTAL]) != 0
+              || (mValueFlags & sFlagsMap[BLOCK]) != 0;
 
       return true;
     }
@@ -111,7 +120,13 @@ public class Spacing {
    */
   public float get(int spacingType) {
     float defaultValue =
-        (spacingType == START || spacingType == END ? YogaConstants.UNDEFINED : mDefaultValue);
+        (spacingType == START
+                || spacingType == END
+                || spacingType == BLOCK
+                || spacingType == BLOCK_END
+                || spacingType == BLOCK_START
+            ? YogaConstants.UNDEFINED
+            : mDefaultValue);
 
     if (mValueFlags == 0) {
       return defaultValue;
@@ -174,6 +189,9 @@ public class Spacing {
       YogaConstants.UNDEFINED,
       YogaConstants.UNDEFINED,
       YogaConstants.UNDEFINED,
+      YogaConstants.UNDEFINED,
+      YogaConstants.UNDEFINED,
+      YogaConstants.UNDEFINED,
     };
   }
 }

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

@@ -50,6 +50,7 @@ public class ThemedReactContext extends ReactContext {
     if (reactApplicationContext.hasCatalystInstance()) {
       initializeWithInstance(reactApplicationContext.getCatalystInstance());
     }
+    initializeInteropModules(reactApplicationContext);
     mReactApplicationContext = reactApplicationContext;
     mModuleName = moduleName;
     mSurfaceId = surfaceId;

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

@@ -17,9 +17,9 @@ import android.view.MotionEvent;
 import android.view.View;
 import android.view.ViewGroup;
 import androidx.annotation.Nullable;
-import com.facebook.react.bridge.JSApplicationIllegalArgumentException;
+import com.facebook.common.logging.FLog;
 import com.facebook.react.bridge.UiThreadUtil;
-import com.facebook.react.config.ReactFeatureFlags;
+import com.facebook.react.common.ReactConstants;
 import com.facebook.react.touch.ReactHitSlopView;
 import com.facebook.react.uimanager.common.ViewUtil;
 import java.util.ArrayList;
@@ -140,7 +140,7 @@ public class TouchTargetHelper {
         pathAccumulator = pathAccumulator.subList(firstReactAncestor, pathAccumulator.size());
       }
 
-      int targetTag = getTouchTargetForView(reactTargetView, eventX, eventY);
+      int targetTag = getTouchTargetForView(reactTargetView, viewCoords[0], viewCoords[1]);
       if (targetTag != reactTargetView.getId()) {
         pathAccumulator.add(0, new ViewTarget(targetTag, (View) null));
       }
@@ -192,7 +192,6 @@ public class TouchTargetHelper {
           // If the touch point is outside of the overflowinset for the view, we can safely ignore
           // it.
           if (ViewUtil.getUIManagerType(view.getId()) == FABRIC
-              && ReactFeatureFlags.useOverflowInset
               && !isTouchPointInViewWithOverflowInset(eventCoords[0], eventCoords[1], view)) {
             return null;
           }
@@ -368,7 +367,10 @@ public class TouchTargetHelper {
 
       return null;
 
-    } else if (pointerEvents == PointerEvents.AUTO) {
+    } else {
+      if (pointerEvents != PointerEvents.AUTO) {
+        FLog.w(ReactConstants.TAG, "Unknown pointer event type: " + pointerEvents.toString());
+      }
       // Either this view or one of its children is the target
       if (view instanceof ReactCompoundViewGroup
           && isTouchPointInView(eventCoords[0], eventCoords[1], view)
@@ -389,18 +391,14 @@ public class TouchTargetHelper {
         pathAccumulator.add(new ViewTarget(view.getId(), view));
       }
       return result;
-
-    } else {
-      throw new JSApplicationIllegalArgumentException(
-          "Unknown pointer event type: " + pointerEvents.toString());
     }
   }
 
-  private static int getTouchTargetForView(View targetView, float eventX, float eventY) {
+  private static int getTouchTargetForView(View targetView, float viewX, float viewY) {
     if (targetView instanceof ReactCompoundView) {
       // Use coordinates relative to the view, which have been already computed by
       // {@link #findTouchTargetView()}.
-      return ((ReactCompoundView) targetView).reactTagForTouch(eventX, eventY);
+      return ((ReactCompoundView) targetView).reactTagForTouch(viewX, viewY);
     }
     return targetView.getId();
   }

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

@@ -7,10 +7,11 @@
 
 package com.facebook.react.uimanager;
 
-import com.facebook.react.bridge.JSApplicationIllegalArgumentException;
+import com.facebook.common.logging.FLog;
 import com.facebook.react.bridge.ReadableArray;
 import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.bridge.ReadableType;
+import com.facebook.react.common.ReactConstants;
 
 /**
  * Class providing helper methods for converting transformation list (as accepted by 'transform'
@@ -100,8 +101,7 @@ public class TransformHelper {
       } else if ("skewY".equals(transformType)) {
         MatrixMathHelper.applySkewY(helperMatrix, convertToRadians(transform, transformType));
       } else {
-        throw new JSApplicationIllegalArgumentException(
-            "Unsupported transform type: " + transformType);
+        FLog.w(ReactConstants.TAG, "Unsupported transform type: " + transformType);
       }
 
       MatrixMathHelper.multiplyInto(result, result, helperMatrix);

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

@@ -170,6 +170,15 @@ public class UIImplementation {
     mOperationsQueue.enqueueRemoveRootView(rootViewTag);
   }
 
+  /**
+   * Return root view num
+   *
+   * @return The num of root view
+   */
+  private int getRootViewNum() {
+    return mOperationsQueue.getNativeViewHierarchyManager().getRootViewNum();
+  }
+
   /** Unregisters a root node with a given tag from the shadow node registry */
   public void removeRootShadowNode(int rootViewTag) {
     synchronized (uiImplementationThreadLock) {
@@ -292,7 +301,7 @@ public class UIImplementation {
    * Invoked when there is a mutation in a node tree.
    *
    * @param tag react tag of the node we want to manage
-   * @param indicesToRemove ordered (asc) list of indicies at which view should be removed
+   * @param indicesToRemove ordered (asc) list of indices at which view should be removed
    * @param viewsToAdd ordered (asc based on mIndex property) list of tag-index pairs that represent
    *     a view which should be added at the specified index
    * @param tagsToDelete list of tags corresponding to views that should be removed
@@ -599,6 +608,12 @@ public class UIImplementation {
 
   /** Invoked at the end of the transaction to commit any updates to the node hierarchy. */
   public void dispatchViewUpdates(int batchId) {
+    if (getRootViewNum() <= 0) {
+      // If there are no RootViews registered, there will be no View updates to dispatch.
+      // This is a hack to prevent this from being called when Fabric is used everywhere.
+      // This should no longer be necessary in Bridgeless Mode.
+      return;
+    }
     SystraceMessage.beginSection(
             Systrace.TRACE_TAG_REACT_JAVA_BRIDGE, "UIImplementation.dispatchViewUpdates")
         .arg("batchId", batchId)