react-native 0.69.0-rc.6 → 0.70.0-rc.0

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

@@ -17,8 +17,10 @@ import com.facebook.react.uimanager.TouchTargetHelper.ViewTarget;
 import com.facebook.react.uimanager.events.EventDispatcher;
 import com.facebook.react.uimanager.events.PointerEvent;
 import com.facebook.react.uimanager.events.PointerEventHelper;
+import com.facebook.react.uimanager.events.PointerEventHelper.EVENT;
 import com.facebook.react.uimanager.events.TouchEvent;
 import com.facebook.react.uimanager.events.TouchEventCoalescingKeyHelper;
+import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 
@@ -37,7 +39,7 @@ public class JSPointerDispatcher {
   private final TouchEventCoalescingKeyHelper mTouchEventCoalescingKeyHelper =
       new TouchEventCoalescingKeyHelper();
 
-  private static final float ONMOVE_EPSILON = 1f;
+  private static final float ONMOVE_EPSILON = 0.1f;
 
   // Set globally for hover interactions, referenced for coalescing hover events
   private long mHoverInteractionKey = TouchEvent.UNSET;
@@ -70,8 +72,7 @@ public class JSPointerDispatcher {
   }
 
   public void handleMotionEvent(MotionEvent motionEvent, EventDispatcher eventDispatcher) {
-    boolean supportsHover =
-        PointerEventHelper.supportsHover(motionEvent.getToolType(motionEvent.getActionIndex()));
+    boolean supportsHover = PointerEventHelper.supportsHover(motionEvent);
 
     int surfaceId = UIManagerHelper.getSurfaceId(mRootViewGroup);
     int action = motionEvent.getActionMasked();
@@ -82,7 +83,9 @@ public class JSPointerDispatcher {
     if (hitPath.isEmpty()) {
       return;
     }
-    int targetTag = hitPath.get(0).getViewId();
+
+    TouchTargetHelper.ViewTarget activeViewTarget = hitPath.get(0);
+    int activeTargetTag = activeViewTarget.getViewId();
 
     if (supportsHover) {
       if (action == MotionEvent.ACTION_HOVER_MOVE) {
@@ -107,15 +110,30 @@ public class JSPointerDispatcher {
       mTouchEventCoalescingKeyHelper.addCoalescingKey(mDownStartTime);
 
       if (!supportsHover) {
-        // Enter root -> child
-        for (int i = hitPath.size(); i-- > 0; ) {
-          int tag = hitPath.get(i).getViewId();
-          eventDispatcher.dispatchEvent(
-              PointerEvent.obtain(PointerEventHelper.POINTER_ENTER, surfaceId, tag, motionEvent));
-        }
+        List<ViewTarget> enterViewTargets =
+            filterByShouldDispatch(hitPath, EVENT.ENTER, EVENT.ENTER_CAPTURE, false);
+
+        // Dispatch root -> target, we need to reverse order of enterViewTargets
+        Collections.reverse(enterViewTargets);
+        dispatchEventForViewTargets(
+            PointerEventHelper.POINTER_ENTER,
+            enterViewTargets,
+            eventDispatcher,
+            surfaceId,
+            motionEvent);
+      }
+
+      boolean listeningForDown =
+          isAnyoneListeningForBubblingEvent(hitPath, EVENT.DOWN, EVENT.DOWN_CAPTURE);
+      if (listeningForDown) {
+        eventDispatcher.dispatchEvent(
+            PointerEvent.obtain(
+                PointerEventHelper.POINTER_DOWN,
+                surfaceId,
+                activeTargetTag,
+                motionEvent,
+                mTargetCoordinates));
       }
-      eventDispatcher.dispatchEvent(
-          PointerEvent.obtain(PointerEventHelper.POINTER_DOWN, surfaceId, targetTag, motionEvent));
 
       return;
     }
@@ -129,25 +147,56 @@ public class JSPointerDispatcher {
     // New pointer goes down, this can only happen after ACTION_DOWN is sent for the first pointer
     if (action == MotionEvent.ACTION_POINTER_DOWN) {
       mTouchEventCoalescingKeyHelper.incrementCoalescingKey(mDownStartTime);
-      eventDispatcher.dispatchEvent(
-          PointerEvent.obtain(PointerEventHelper.POINTER_DOWN, surfaceId, targetTag, motionEvent));
+
+      boolean listeningForDown =
+          isAnyoneListeningForBubblingEvent(hitPath, EVENT.DOWN, EVENT.DOWN_CAPTURE);
+      if (listeningForDown) {
+        eventDispatcher.dispatchEvent(
+            PointerEvent.obtain(
+                PointerEventHelper.POINTER_DOWN,
+                surfaceId,
+                activeTargetTag,
+                motionEvent,
+                mTargetCoordinates));
+      }
 
       return;
     }
 
     if (action == MotionEvent.ACTION_MOVE) {
       int coalescingKey = mTouchEventCoalescingKeyHelper.getCoalescingKey(mDownStartTime);
-      eventDispatcher.dispatchEvent(
-          PointerEvent.obtain(
-              PointerEventHelper.POINTER_MOVE, surfaceId, targetTag, motionEvent, coalescingKey));
+
+      boolean listeningForMove =
+          isAnyoneListeningForBubblingEvent(hitPath, EVENT.MOVE, EVENT.MOVE_CAPTURE);
+      if (listeningForMove) {
+        eventDispatcher.dispatchEvent(
+            PointerEvent.obtain(
+                PointerEventHelper.POINTER_MOVE,
+                surfaceId,
+                activeTargetTag,
+                motionEvent,
+                mTargetCoordinates,
+                coalescingKey));
+      }
+
       return;
     }
 
     // Exactly one of the pointers goes up, not the last one
     if (action == MotionEvent.ACTION_POINTER_UP) {
       mTouchEventCoalescingKeyHelper.incrementCoalescingKey(mDownStartTime);
-      eventDispatcher.dispatchEvent(
-          PointerEvent.obtain(PointerEventHelper.POINTER_UP, surfaceId, targetTag, motionEvent));
+
+      boolean listeningForUp =
+          isAnyoneListeningForBubblingEvent(hitPath, EVENT.UP, EVENT.UP_CAPTURE);
+      if (listeningForUp) {
+        eventDispatcher.dispatchEvent(
+            PointerEvent.obtain(
+                PointerEventHelper.POINTER_UP,
+                surfaceId,
+                activeTargetTag,
+                motionEvent,
+                mTargetCoordinates));
+      }
 
       return;
     }
@@ -159,16 +208,29 @@ public class JSPointerDispatcher {
       mTouchEventCoalescingKeyHelper.removeCoalescingKey(mDownStartTime);
       mDownStartTime = TouchEvent.UNSET;
 
-      eventDispatcher.dispatchEvent(
-          PointerEvent.obtain(PointerEventHelper.POINTER_UP, surfaceId, targetTag, motionEvent));
+      boolean listeningForUp =
+          isAnyoneListeningForBubblingEvent(hitPath, EVENT.UP, EVENT.UP_CAPTURE);
+      if (listeningForUp) {
+        eventDispatcher.dispatchEvent(
+            PointerEvent.obtain(
+                PointerEventHelper.POINTER_UP,
+                surfaceId,
+                activeTargetTag,
+                motionEvent,
+                mTargetCoordinates));
+      }
 
       if (!supportsHover) {
-        // Leave child -> root
-        for (int i = 0; i < hitPath.size(); i++) {
-          int tag = hitPath.get(i).getViewId();
-          eventDispatcher.dispatchEvent(
-              PointerEvent.obtain(PointerEventHelper.POINTER_LEAVE, surfaceId, tag, motionEvent));
-        }
+        List<ViewTarget> leaveViewTargets =
+            filterByShouldDispatch(hitPath, EVENT.LEAVE, EVENT.LEAVE_CAPTURE, false);
+
+        // target -> root
+        dispatchEventForViewTargets(
+            PointerEventHelper.POINTER_LEAVE,
+            leaveViewTargets,
+            eventDispatcher,
+            surfaceId,
+            motionEvent);
       }
       return;
     }
@@ -183,15 +245,69 @@ public class JSPointerDispatcher {
         "Warning : Motion Event was ignored. Action="
             + action
             + " Target="
-            + targetTag
+            + activeTargetTag
             + " Supports Hover="
             + supportsHover);
   }
 
-  private int findTargetTagAndSetCoordinates(MotionEvent ev) {
-    // This method updates `mTargetCoordinates` with coordinates for the motion event.
-    return TouchTargetHelper.findTargetTagAndCoordinatesForTouch(
-        ev.getX(), ev.getY(), mRootViewGroup, mTargetCoordinates, null);
+  private static boolean isAnyoneListeningForBubblingEvent(
+      List<ViewTarget> hitPath, EVENT event, EVENT captureEvent) {
+    for (ViewTarget viewTarget : hitPath) {
+      if (PointerEventHelper.isListening(viewTarget.getView(), event)
+          || PointerEventHelper.isListening(viewTarget.getView(), captureEvent)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Returns list of view targets that we should be dispatching events from
+   *
+   * @param viewTargets, ordered from target -> root
+   * @param bubble, name of event that bubbles. Should only ever be enter or leave
+   * @param capture, name of event that captures. Should only ever be enter or leave
+   * @param forceDispatch, if true, all viewTargets should dispatch
+   * @return list of viewTargets filtered from target -> root
+   */
+  private static List<ViewTarget> filterByShouldDispatch(
+      List<ViewTarget> viewTargets, EVENT bubble, EVENT capture, boolean forceDispatch) {
+
+    List<ViewTarget> dispatchableViewTargets = new ArrayList<>(viewTargets);
+    if (forceDispatch) {
+      return dispatchableViewTargets;
+    }
+
+    boolean ancestorListening = false;
+
+    // Start to filter which viewTargets may not need to dispatch an event
+    for (int i = viewTargets.size() - 1; i >= 0; i--) {
+      ViewTarget viewTarget = viewTargets.get(i);
+      View view = viewTarget.getView();
+
+      if (!ancestorListening
+          && !PointerEventHelper.isListening(view, capture)
+          && !PointerEventHelper.isListening(view, bubble)) {
+        dispatchableViewTargets.remove(i);
+      } else if (!ancestorListening && PointerEventHelper.isListening(view, capture)) {
+        ancestorListening = true;
+      }
+    }
+    return dispatchableViewTargets;
+  }
+
+  private void dispatchEventForViewTargets(
+      String eventName,
+      List<ViewTarget> viewTargets,
+      EventDispatcher dispatcher,
+      int surfaceId,
+      MotionEvent motionEvent) {
+
+    for (ViewTarget viewTarget : viewTargets) {
+      int viewId = viewTarget.getViewId();
+      dispatcher.dispatchEvent(
+          PointerEvent.obtain(eventName, surfaceId, viewId, motionEvent, mTargetCoordinates));
+    }
   }
 
   // called on hover_move motion events only
@@ -245,54 +361,86 @@ public class JSPointerDispatcher {
     // hitState is list ordered from inner child -> parent tag
     // Traverse hitState back-to-front to find the first divergence with mLastHitState
     // FIXME: this may generate incorrect events when view collapsing changes the hierarchy
-    int firstDivergentIndex = 0;
-    while (firstDivergentIndex < Math.min(hitPath.size(), mLastHitPath.size())
+    boolean nonDivergentListeningToEnter = false;
+    boolean nonDivergentListeningToLeave = false;
+    int firstDivergentIndexFromBack = 0;
+    while (firstDivergentIndexFromBack < Math.min(hitPath.size(), mLastHitPath.size())
         && hitPath
-            .get(hitPath.size() - 1 - firstDivergentIndex)
-            .equals(mLastHitPath.get(mLastHitPath.size() - 1 - firstDivergentIndex))) {
-      firstDivergentIndex++;
+            .get(hitPath.size() - 1 - firstDivergentIndexFromBack)
+            .equals(mLastHitPath.get(mLastHitPath.size() - 1 - firstDivergentIndexFromBack))) {
+
+      // Track if any non-diverging views are listening to enter/leave
+      View nonDivergentViewTargetView =
+          hitPath.get(hitPath.size() - 1 - firstDivergentIndexFromBack).getView();
+      if (!nonDivergentListeningToEnter
+          && PointerEventHelper.isListening(nonDivergentViewTargetView, EVENT.ENTER_CAPTURE)) {
+        nonDivergentListeningToEnter = true;
+      }
+      if (!nonDivergentListeningToLeave
+          && PointerEventHelper.isListening(nonDivergentViewTargetView, EVENT.LEAVE_CAPTURE)) {
+        nonDivergentListeningToLeave = true;
+      }
+
+      firstDivergentIndexFromBack++;
     }
 
-    boolean hasDiverged = firstDivergentIndex < Math.max(hitPath.size(), mLastHitPath.size());
+    boolean hasDiverged =
+        firstDivergentIndexFromBack < Math.max(hitPath.size(), mLastHitPath.size());
 
-    // Fire all relevant enter events
     if (hasDiverged) {
       // If something has changed in either enter/exit, let's start a new coalescing key
       mTouchEventCoalescingKeyHelper.incrementCoalescingKey(mHoverInteractionKey);
 
-      List<ViewTarget> enterViewTargets = hitPath.subList(0, hitPath.size() - firstDivergentIndex);
+      // target -> root
+      List<ViewTarget> enterViewTargets =
+          filterByShouldDispatch(
+              hitPath.subList(0, hitPath.size() - firstDivergentIndexFromBack),
+              EVENT.ENTER,
+              EVENT.ENTER_CAPTURE,
+              nonDivergentListeningToEnter);
+
       if (enterViewTargets.size() > 0) {
-        // root -> child
-        for (int i = enterViewTargets.size(); i-- > 0; ) {
-          eventDispatcher.dispatchEvent(
-              PointerEvent.obtain(
-                  PointerEventHelper.POINTER_ENTER,
-                  surfaceId,
-                  enterViewTargets.get(i).getViewId(),
-                  motionEvent));
-        }
+        // We want to iterate these from root -> target so we need to reverse
+        Collections.reverse(enterViewTargets);
+        dispatchEventForViewTargets(
+            PointerEventHelper.POINTER_ENTER,
+            enterViewTargets,
+            eventDispatcher,
+            surfaceId,
+            motionEvent);
       }
 
-      // Fire all relevant exit events
-      List<ViewTarget> exitViewTargets =
-          mLastHitPath.subList(0, mLastHitPath.size() - firstDivergentIndex);
-      if (exitViewTargets.size() > 0) {
-        // child -> root
-        for (ViewTarget exitViewTarget : exitViewTargets) {
-          eventDispatcher.dispatchEvent(
-              PointerEvent.obtain(
-                  PointerEventHelper.POINTER_LEAVE,
-                  surfaceId,
-                  exitViewTarget.getViewId(),
-                  motionEvent));
-        }
+      // target -> root
+      List<ViewTarget> leaveViewTargets =
+          filterByShouldDispatch(
+              mLastHitPath.subList(0, mLastHitPath.size() - firstDivergentIndexFromBack),
+              EVENT.LEAVE,
+              EVENT.LEAVE_CAPTURE,
+              nonDivergentListeningToLeave);
+      if (leaveViewTargets.size() > 0) {
+        // We want to dispatch from target -> root, so no need to reverse
+        dispatchEventForViewTargets(
+            PointerEventHelper.POINTER_LEAVE,
+            leaveViewTargets,
+            eventDispatcher,
+            surfaceId,
+            motionEvent);
       }
     }
 
     int coalescingKey = mTouchEventCoalescingKeyHelper.getCoalescingKey(mHoverInteractionKey);
-    eventDispatcher.dispatchEvent(
-        PointerEvent.obtain(
-            PointerEventHelper.POINTER_MOVE, surfaceId, targetTag, motionEvent, coalescingKey));
+    boolean listeningToMove =
+        isAnyoneListeningForBubblingEvent(hitPath, EVENT.MOVE, EVENT.MOVE_CAPTURE);
+    if (listeningToMove) {
+      eventDispatcher.dispatchEvent(
+          PointerEvent.obtain(
+              PointerEventHelper.POINTER_MOVE,
+              surfaceId,
+              targetTag,
+              motionEvent,
+              mTargetCoordinates,
+              coalescingKey));
+    }
 
     mLastHitPath = hitPath;
     mLastEventCoordinates[0] = x;
@@ -311,21 +459,33 @@ public class JSPointerDispatcher {
     int surfaceId = UIManagerHelper.getSurfaceId(mRootViewGroup);
 
     if (!hitPath.isEmpty()) {
-      int targetTag = hitPath.get(0).getViewId();
-      // Question: Does cancel fire on all in hit path?
-      Assertions.assertNotNull(eventDispatcher)
-          .dispatchEvent(
-              PointerEvent.obtain(
-                  PointerEventHelper.POINTER_CANCEL, surfaceId, targetTag, motionEvent));
-
-      for (ViewTarget viewTarget : hitPath) {
-        eventDispatcher.dispatchEvent(
-            PointerEvent.obtain(
-                PointerEventHelper.POINTER_LEAVE, surfaceId, viewTarget.getViewId(), motionEvent));
+      boolean listeningForCancel =
+          isAnyoneListeningForBubblingEvent(hitPath, EVENT.CANCEL, EVENT.CANCEL_CAPTURE);
+      if (listeningForCancel) {
+        int targetTag = hitPath.get(0).getViewId();
+        Assertions.assertNotNull(eventDispatcher)
+            .dispatchEvent(
+                PointerEvent.obtain(
+                    PointerEventHelper.POINTER_CANCEL,
+                    surfaceId,
+                    targetTag,
+                    motionEvent,
+                    mTargetCoordinates));
       }
-    }
 
-    mTouchEventCoalescingKeyHelper.removeCoalescingKey(mDownStartTime);
-    mDownStartTime = TouchEvent.UNSET;
+      List<ViewTarget> leaveViewTargets =
+          filterByShouldDispatch(hitPath, EVENT.LEAVE, EVENT.LEAVE_CAPTURE, false);
+
+      // dispatch from target -> root
+      dispatchEventForViewTargets(
+          PointerEventHelper.POINTER_LEAVE,
+          leaveViewTargets,
+          eventDispatcher,
+          surfaceId,
+          motionEvent);
+
+      mTouchEventCoalescingKeyHelper.removeCoalescingKey(mDownStartTime);
+      mDownStartTime = TouchEvent.UNSET;
+    }
   }
 }

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

@@ -122,6 +122,7 @@ public class ReactAccessibilityDelegate extends ExploreByTouchHelper {
     TABLIST,
     TIMER,
     LIST,
+    GRID,
     TOOLBAR;
 
     public static String getValue(AccessibilityRole role) {
@@ -152,6 +153,8 @@ public class ReactAccessibilityDelegate extends ExploreByTouchHelper {
           return "android.widget.Switch";
         case LIST:
           return "android.widget.AbsListView";
+        case GRID:
+          return "android.widget.GridView";
         case NONE:
         case LINK:
         case SUMMARY:
@@ -242,6 +245,22 @@ public class ReactAccessibilityDelegate extends ExploreByTouchHelper {
     }
     final ReadableArray accessibilityActions =
         (ReadableArray) host.getTag(R.id.accessibility_actions);
+
+    final ReadableMap accessibilityCollectionItem =
+        (ReadableMap) host.getTag(R.id.accessibility_collection_item);
+    if (accessibilityCollectionItem != null) {
+      int rowIndex = accessibilityCollectionItem.getInt("rowIndex");
+      int columnIndex = accessibilityCollectionItem.getInt("columnIndex");
+      int rowSpan = accessibilityCollectionItem.getInt("rowSpan");
+      int columnSpan = accessibilityCollectionItem.getInt("columnSpan");
+      boolean heading = accessibilityCollectionItem.getBoolean("heading");
+
+      AccessibilityNodeInfoCompat.CollectionItemInfoCompat collectionItemCompat =
+          AccessibilityNodeInfoCompat.CollectionItemInfoCompat.obtain(
+              rowIndex, rowSpan, columnIndex, columnSpan, heading);
+      info.setCollectionItemInfo(collectionItemCompat);
+    }
+
     if (accessibilityActions != null) {
       for (int i = 0; i < accessibilityActions.size(); i++) {
         final ReadableMap action = accessibilityActions.getMap(i);
@@ -466,6 +485,7 @@ public class ReactAccessibilityDelegate extends ExploreByTouchHelper {
             || 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)) {
       ViewCompat.setAccessibilityDelegate(
           view,

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

@@ -192,7 +192,7 @@ 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.doesUseOverflowInset()
+              && ReactFeatureFlags.useOverflowInset
               && !isTouchPointInViewWithOverflowInset(eventCoords[0], eventCoords[1], view)) {
             return null;
           }

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

@@ -21,6 +21,7 @@ import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.bridge.UiThreadUtil;
 import com.facebook.react.bridge.WritableArray;
 import com.facebook.react.common.ReactConstants;
+import com.facebook.react.common.build.ReactBuildConfig;
 import com.facebook.react.modules.i18nmanager.I18nUtil;
 import com.facebook.react.uimanager.debug.NotThreadSafeViewHierarchyUpdateDebugListener;
 import com.facebook.react.uimanager.events.EventDispatcher;
@@ -742,13 +743,23 @@ public class UIImplementation {
   @Deprecated
   public void dispatchViewManagerCommand(
       int reactTag, int commandId, @Nullable ReadableArray commandArgs) {
-    assertViewExists(reactTag, "dispatchViewManagerCommand: " + commandId);
+    boolean viewExists =
+        checkOrAssertViewExists(reactTag, "dispatchViewManagerCommand: " + commandId);
+    if (!viewExists) {
+      return;
+    }
+
     mOperationsQueue.enqueueDispatchCommand(reactTag, commandId, commandArgs);
   }
 
   public void dispatchViewManagerCommand(
       int reactTag, String commandId, @Nullable ReadableArray commandArgs) {
-    assertViewExists(reactTag, "dispatchViewManagerCommand: " + commandId);
+    boolean viewExists =
+        checkOrAssertViewExists(reactTag, "dispatchViewManagerCommand: " + commandId);
+    if (!viewExists) {
+      return;
+    }
+
     mOperationsQueue.enqueueDispatchCommand(reactTag, commandId, commandArgs);
   }
 
@@ -763,7 +774,11 @@ public class UIImplementation {
    *     no arguments if the menu is dismissed
    */
   public void showPopupMenu(int reactTag, ReadableArray items, Callback error, Callback success) {
-    assertViewExists(reactTag, "showPopupMenu");
+    boolean viewExists = checkOrAssertViewExists(reactTag, "showPopupMenu");
+    if (!viewExists) {
+      return;
+    }
+
     mOperationsQueue.enqueueShowPopupMenu(reactTag, items, error, success);
   }
 
@@ -867,15 +882,30 @@ public class UIImplementation {
     outputBuffer[3] = node.getScreenHeight();
   }
 
-  private void assertViewExists(int reactTag, String operationNameForExceptionMessage) {
-    if (mShadowNodeRegistry.getNode(reactTag) == null) {
-      throw new IllegalViewOperationException(
-          "Unable to execute operation "
-              + operationNameForExceptionMessage
-              + " on view with "
-              + "tag: "
-              + reactTag
-              + ", since the view does not exists");
+  /**
+   * Returns whether a view identified by the tag exists. In debug mode, this will throw whenever
+   * the view doesn't exist. In production, it'll log a warning. Callers should use this and just
+   * return if the view doesn't exist to avoid crashing.
+   */
+  private boolean checkOrAssertViewExists(int reactTag, String operationNameForExceptionMessage) {
+    boolean viewExists = mShadowNodeRegistry.getNode(reactTag) != null;
+    if (viewExists) {
+      return true;
+    }
+
+    String message =
+        "Unable to execute operation "
+            + operationNameForExceptionMessage
+            + " on view with "
+            + "tag: "
+            + reactTag
+            + ", since the view does not exist";
+
+    if (ReactBuildConfig.DEBUG) {
+      throw new IllegalViewOperationException(message);
+    } else {
+      FLog.w(ReactConstants.TAG, message);
+      return false;
     }
   }
 

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

@@ -207,6 +207,7 @@ public class UIManagerModule extends ReactContextBaseJavaModule
   @Override
   public void initialize() {
     getReactApplicationContext().registerComponentCallbacks(mMemoryTrimCallback);
+    getReactApplicationContext().registerComponentCallbacks(mViewManagerRegistry);
     mEventDispatcher.registerEventEmitter(
         DEFAULT, getReactApplicationContext().getJSModule(RCTEventEmitter.class));
   }
@@ -234,6 +235,7 @@ public class UIManagerModule extends ReactContextBaseJavaModule
 
     ReactApplicationContext reactApplicationContext = getReactApplicationContext();
     reactApplicationContext.unregisterComponentCallbacks(mMemoryTrimCallback);
+    reactApplicationContext.unregisterComponentCallbacks(mViewManagerRegistry);
     YogaNodePool.get().clear();
     ViewManagerPropertyUpdater.clear();
   }

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

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

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

@@ -12,6 +12,7 @@ import static com.facebook.systrace.Systrace.TRACE_TAG_REACT_JAVA_BRIDGE;
 import androidx.annotation.Nullable;
 import com.facebook.react.common.MapBuilder;
 import com.facebook.systrace.SystraceMessage;
+import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 
@@ -33,7 +34,7 @@ import java.util.Map;
    */
   /* package */ static Map<String, Object> createConstants(ViewManagerResolver resolver) {
     Map<String, Object> constants = UIManagerModuleConstants.getConstants();
-    constants.put("ViewManagerNames", resolver.getViewManagerNames());
+    constants.put("ViewManagerNames", new ArrayList<>(resolver.getViewManagerNames()));
     constants.put("LazyViewManagersEnabled", true);
     return constants;
   }