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

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

@@ -11,18 +11,22 @@ import android.content.Context;
 import android.view.View;
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
+import com.facebook.common.logging.FLog;
 import com.facebook.react.bridge.BaseJavaModule;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReadableArray;
 import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.common.mapbuffer.MapBuffer;
+import com.facebook.react.config.ReactFeatureFlags;
 import com.facebook.react.touch.JSResponderHandler;
 import com.facebook.react.touch.ReactInterceptingViewGroup;
 import com.facebook.react.uimanager.annotations.ReactProp;
 import com.facebook.react.uimanager.annotations.ReactPropGroup;
 import com.facebook.react.uimanager.annotations.ReactPropertyHolder;
 import com.facebook.yoga.YogaMeasureMode;
+import java.util.HashMap;
 import java.util.Map;
+import java.util.Stack;
 
 /**
  * Class responsible for knowing how to create and update catalyst Views of a given type. It is also
@@ -33,6 +37,40 @@ import java.util.Map;
 public abstract class ViewManager<T extends View, C extends ReactShadowNode>
     extends BaseJavaModule {
 
+  private static String NAME = ViewManager.class.getSimpleName();
+
+  /**
+   * For View recycling: we store a Stack of unused, dead Views. This is null by default, and when
+   * null signals that View Recycling is disabled. `enableViewRecycling` must be explicitly called
+   * in a concrete constructor to enable View Recycling per ViewManager.
+   */
+  @Nullable private HashMap<Integer, Stack<T>> mRecyclableViews = null;
+
+  private int mRecyclableViewsBufferSize = 1024;
+
+  /** Call in constructor of concrete ViewManager class to enable. */
+  protected void setupViewRecycling() {
+    if (ReactFeatureFlags.enableViewRecycling) {
+      mRecyclableViews = new HashMap<>();
+    }
+  }
+
+  /** Call in constructor of concrete ViewManager class to enable. */
+  protected void setupViewRecycling(int bufferSize) {
+    mRecyclableViewsBufferSize = bufferSize;
+    setupViewRecycling();
+  }
+
+  private @Nullable Stack<T> getRecyclableViewStack(int surfaceId) {
+    if (mRecyclableViews == null) {
+      return null;
+    }
+    if (!mRecyclableViews.containsKey(surfaceId)) {
+      mRecyclableViews.put(surfaceId, new Stack<T>());
+    }
+    return mRecyclableViews.get(surfaceId);
+  }
+
   /**
    * For the vast majority of ViewManagers, you will not need to override this. Only override this
    * if you really know what you're doing and have a very unique use-case.
@@ -137,7 +175,13 @@ public abstract class ViewManager<T extends View, C extends ReactShadowNode>
       @NonNull ThemedReactContext reactContext,
       @Nullable ReactStylesDiffMap initialProps,
       @Nullable StateWrapper stateWrapper) {
-    T view = createViewInstance(reactContext);
+    T view = null;
+    @Nullable Stack<T> recyclableViews = getRecyclableViewStack(reactContext.getSurfaceId());
+    if (recyclableViews != null && !recyclableViews.empty()) {
+      view = recycleView(reactContext, recyclableViews.pop());
+    } else {
+      view = createViewInstance(reactContext);
+    }
     view.setId(reactTag);
     addEventEmitters(reactContext, view);
     if (initialProps != null) {
@@ -157,7 +201,49 @@ public abstract class ViewManager<T extends View, C extends ReactShadowNode>
    * Called when view is detached from view hierarchy and allows for some additional cleanup by the
    * {@link ViewManager} subclass.
    */
-  public void onDropViewInstance(@NonNull T view) {}
+  public void onDropViewInstance(@NonNull T view) {
+    // Some legacy components will return an Activity here instead of a ThemedReactContext
+    Context viewContext = view.getContext();
+    if (viewContext == null) {
+      // Who knows! Anything is possible. Checking instanceof on null is an NPE,
+      // So this is not redundant.
+      FLog.e(NAME, "onDropViewInstance: view [" + view.getId() + "] has a null context");
+      return;
+    }
+    if (!(viewContext instanceof ThemedReactContext)) {
+      FLog.e(
+          NAME,
+          "onDropViewInstance: view ["
+              + view.getId()
+              + "] has a context that is not a ThemedReactContext: "
+              + viewContext);
+      return;
+    }
+
+    // View recycling
+    ThemedReactContext themedReactContext = (ThemedReactContext) viewContext;
+    int surfaceId = themedReactContext.getSurfaceId();
+    @Nullable Stack<T> recyclableViews = getRecyclableViewStack(surfaceId);
+
+    // Any max buffer size <0 results in an infinite buffer size
+    if (recyclableViews != null
+        && (mRecyclableViewsBufferSize < 0
+            || recyclableViews.size() < mRecyclableViewsBufferSize)) {
+      recyclableViews.push(prepareToRecycleView(themedReactContext, view));
+    }
+  }
+
+  /**
+   * Called when a View is removed from the hierachy. This should be used to reset any properties.
+   */
+  protected T prepareToRecycleView(@NonNull ThemedReactContext reactContext, @NonNull T view) {
+    return view;
+  }
+
+  /** Called when a View is going to be reused. */
+  protected T recycleView(@NonNull ThemedReactContext reactContext, @NonNull T view) {
+    return view;
+  }
 
   /**
    * Subclasses can override this method to install custom event emitters on the given View. You
@@ -285,7 +371,7 @@ public abstract class ViewManager<T extends View, C extends ReactShadowNode>
    * this component type.
    */
   public @Nullable Object updateState(
-      @NonNull T view, ReactStylesDiffMap props, @Nullable StateWrapper stateWrapper) {
+      @NonNull T view, ReactStylesDiffMap props, StateWrapper stateWrapper) {
     return null;
   }
 
@@ -370,4 +456,24 @@ public abstract class ViewManager<T extends View, C extends ReactShadowNode>
    * components support setting padding, the default implementation of this method does nothing.
    */
   public void setPadding(T view, int left, int top, int right, int bottom) {}
+
+  /**
+   * Lifecycle method: called when a surface is stopped. Currently only used for View Recycling
+   * cleanup. There is no corresponding startSurface lifecycle event for ViewManagers because we
+   * currently only need this for recycling cleanup. Only called in Fabric.
+   */
+  public void onSurfaceStopped(int surfaceId) {
+    if (mRecyclableViews != null) {
+      mRecyclableViews.remove(surfaceId);
+    }
+  }
+
+  /** With even slight memory pressure, we immediately evict all recyclable Views. */
+  /* package */ void trimMemory() {
+    // Wipe out all existing recyclable Views, but do not disable View Recycling entirely.
+    // We only take any action if View Recycling is already enabled.
+    if (mRecyclableViews != null) {
+      mRecyclableViews = new HashMap<>();
+    }
+  }
 }

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

@@ -7,7 +7,10 @@
 
 package com.facebook.react.uimanager;
 
+import android.content.ComponentCallbacks2;
+import android.content.res.Configuration;
 import androidx.annotation.Nullable;
+import com.facebook.react.bridge.UiThreadUtil;
 import com.facebook.react.common.MapBuilder;
 import java.util.List;
 import java.util.Map;
@@ -16,7 +19,7 @@ import java.util.Map;
  * Class that stores the mapping between native view name used in JS and the corresponding instance
  * of {@link ViewManager}.
  */
-public final class ViewManagerRegistry {
+public final class ViewManagerRegistry implements ComponentCallbacks2 {
 
   private final Map<String, ViewManager> mViewManagers;
   private final @Nullable ViewManagerResolver mViewManagerResolver;
@@ -91,4 +94,51 @@ public final class ViewManagerRegistry {
     }
     return null;
   }
+
+  /** Send lifecycle signal to all ViewManagers that StopSurface has been called. */
+  public void onSurfaceStopped(final int surfaceId) {
+    Runnable runnable =
+        new Runnable() {
+          @Override
+          public void run() {
+            for (Map.Entry<String, ViewManager> entry : mViewManagers.entrySet()) {
+              entry.getValue().onSurfaceStopped(surfaceId);
+            }
+          }
+        };
+    if (UiThreadUtil.isOnUiThread()) {
+      runnable.run();
+    } else {
+      UiThreadUtil.runOnUiThread(runnable);
+    }
+  }
+
+  /** ComponentCallbacks2 method. */
+  @Override
+  public void onTrimMemory(int level) {
+    Runnable runnable =
+        new Runnable() {
+          @Override
+          public void run() {
+            for (Map.Entry<String, ViewManager> entry : mViewManagers.entrySet()) {
+              entry.getValue().trimMemory();
+            }
+          }
+        };
+    if (UiThreadUtil.isOnUiThread()) {
+      runnable.run();
+    } else {
+      UiThreadUtil.runOnUiThread(runnable);
+    }
+  }
+
+  /** ComponentCallbacks2 method. */
+  @Override
+  public void onConfigurationChanged(Configuration newConfig) {}
+
+  /** ComponentCallbacks2 method. */
+  @Override
+  public void onLowMemory() {
+    this.onTrimMemory(0);
+  }
 }

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

@@ -7,7 +7,7 @@
 
 package com.facebook.react.uimanager;
 
-import java.util.List;
+import java.util.Collection;
 import javax.annotation.Nullable;
 
 /** Enables lazy discovery of a specific {@link ViewManager} by its name. */
@@ -22,5 +22,5 @@ public interface ViewManagerResolver {
   /**
    * Provides a list of view manager names to register in JS as {@code UIManager.ViewManagerName}
    */
-  List<String> getViewManagerNames();
+  Collection<String> getViewManagerNames();
 }

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

@@ -146,6 +146,8 @@ public class ViewProps {
   public static final String Z_INDEX = "zIndex";
   public static final String RENDER_TO_HARDWARE_TEXTURE = "renderToHardwareTextureAndroid";
   public static final String ACCESSIBILITY_LABEL = "accessibilityLabel";
+  public static final String ACCESSIBILITY_COLLECTION = "accessibilityCollection";
+  public static final String ACCESSIBILITY_COLLECTION_ITEM = "accessibilityCollectionItem";
   public static final String ACCESSIBILITY_HINT = "accessibilityHint";
   public static final String ACCESSIBILITY_LIVE_REGION = "accessibilityLiveRegion";
   public static final String ACCESSIBILITY_ROLE = "accessibilityRole";

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

@@ -9,6 +9,7 @@ rn_android_library(
         "pfh:ReactNative_CommonInfrastructurePlaceholder",
         "supermodule:xplat/default/public.react_native.infra",
     ],
+    language = "JAVA",
     required_for_source_only_abi = True,
     visibility = [
         "PUBLIC",

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

@@ -9,6 +9,7 @@ rn_android_library(
         "pfh:ReactNative_CommonInfrastructurePlaceholder",
         "supermodule:xplat/default/public.react_native.infra",
     ],
+    language = "JAVA",
     provided_deps = [
         react_native_dep("third-party/android/androidx:annotation"),
         react_native_dep("third-party/android/androidx:core"),

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

@@ -12,6 +12,7 @@ import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.common.SystemClock;
 import com.facebook.react.uimanager.IllegalViewOperationException;
 import com.facebook.react.uimanager.common.UIManagerType;
+import com.facebook.react.uimanager.common.ViewUtil;
 
 /**
  * A UI event that can be dispatched to JS.
@@ -72,14 +73,22 @@ public abstract class Event<T extends Event> {
     // We infer UIManagerType. Even though it's not passed in explicitly, we have a
     // contract that Fabric events *always* have a SurfaceId passed in, and non-Fabric events
     // NEVER have a SurfaceId passed in (the default/placeholder of -1 is passed in instead).
+    //
     // Why does this matter?
     // Events can be sent to Views that are part of the View hierarchy *but not directly managed
     // by React Native*. For example, embedded custom hierachies, Litho hierachies, etc.
-    // In those cases it's important to konw that the Event should be sent to the Fabric or
+    // In those cases it's important to know that the Event should be sent to the Fabric or
     // non-Fabric UIManager, and we cannot use the ViewTag for inference since it's not controlled
     // by RN and is essentially a random number.
     // At some point it would be great to pass the SurfaceContext here instead.
-    mUIManagerType = (surfaceId == -1 ? UIManagerType.DEFAULT : UIManagerType.FABRIC);
+    @UIManagerType
+    int uiManagerType = (surfaceId == -1 ? UIManagerType.DEFAULT : UIManagerType.FABRIC);
+    if (uiManagerType == UIManagerType.DEFAULT && !ViewUtil.isRootTag(viewTag)) {
+      // TODO (T123064648): Some events for Fabric still didn't have the surfaceId set, so if it's
+      // not a React RootView, double check if the tag belongs to Fabric.
+      uiManagerType = ViewUtil.getUIManagerType(viewTag);
+    }
+    mUIManagerType = uiManagerType;
 
     mTimestampMs = timestampMs;
     mInitialized = true;

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

@@ -14,6 +14,7 @@ import com.facebook.infer.annotation.Assertions;
 import com.facebook.react.bridge.Arguments;
 import com.facebook.react.bridge.ReactSoftExceptionLogger;
 import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.uimanager.PixelUtil;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
@@ -26,12 +27,22 @@ public class PointerEvent extends Event<PointerEvent> {
   private static final int UNSET_COALESCING_KEY = -1;
 
   public static PointerEvent obtain(
-      String eventName, int surfaceId, int viewTag, MotionEvent motionEventToCopy) {
+      String eventName,
+      int surfaceId,
+      int viewTag,
+      MotionEvent motionEventToCopy,
+      float[] offsetCoords) {
     PointerEvent event = EVENTS_POOL.acquire();
     if (event == null) {
       event = new PointerEvent();
     }
-    event.init(eventName, surfaceId, viewTag, Assertions.assertNotNull(motionEventToCopy), 0);
+    event.init(
+        eventName,
+        surfaceId,
+        viewTag,
+        Assertions.assertNotNull(motionEventToCopy),
+        offsetCoords,
+        0);
     return event;
   }
 
@@ -40,30 +51,43 @@ public class PointerEvent extends Event<PointerEvent> {
       int surfaceId,
       int viewTag,
       MotionEvent motionEventToCopy,
+      float[] offsetCoords,
       int coalescingKey) {
     PointerEvent event = EVENTS_POOL.acquire();
     if (event == null) {
       event = new PointerEvent();
     }
     event.init(
-        eventName, surfaceId, viewTag, Assertions.assertNotNull(motionEventToCopy), coalescingKey);
+        eventName,
+        surfaceId,
+        viewTag,
+        Assertions.assertNotNull(motionEventToCopy),
+        offsetCoords,
+        coalescingKey);
     return event;
   }
 
   private @Nullable MotionEvent mMotionEvent;
   private @Nullable String mEventName;
   private int mCoalescingKey = UNSET_COALESCING_KEY;
+  private float mOffsetX;
+  private float mOffsetY;
+  private @Nullable List<WritableMap> mPointersEventData;
 
   private void init(
       String eventName,
       int surfaceId,
       int viewTag,
       MotionEvent motionEventToCopy,
+      float[] offsetCoords,
       int coalescingKey) {
+
     super.init(surfaceId, viewTag, motionEventToCopy.getEventTime());
     mEventName = eventName;
     mMotionEvent = MotionEvent.obtain(motionEventToCopy);
     mCoalescingKey = coalescingKey;
+    mOffsetX = offsetCoords[0];
+    mOffsetY = offsetCoords[1];
   }
 
   private PointerEvent() {}
@@ -75,12 +99,33 @@ public class PointerEvent extends Event<PointerEvent> {
 
   @Override
   public void dispatch(RCTEventEmitter rctEventEmitter) {
-    // Skip legacy stuff for now?
+    if (mMotionEvent == null) {
+      ReactSoftExceptionLogger.logSoftException(
+          TAG,
+          new IllegalStateException(
+              "Cannot dispatch a Pointer that has no MotionEvent; the PointerEvehas been recycled"));
+      return;
+    }
+    if (mPointersEventData == null) {
+      mPointersEventData = createPointersEventData();
+    }
+
+    if (mPointersEventData == null) {
+      // No relevant MotionEvent to dispatch
+      return;
+    }
+
+    boolean shouldCopy = mPointersEventData.size() > 1;
+    for (WritableMap pointerEventData : mPointersEventData) {
+      WritableMap eventData = shouldCopy ? pointerEventData.copy() : pointerEventData;
+      rctEventEmitter.receiveEvent(this.getViewTag(), mEventName, eventData);
+    }
     return;
   }
 
   @Override
   public void onDispose() {
+    mPointersEventData = null;
     MotionEvent motionEvent = mMotionEvent;
     mMotionEvent = null;
     if (motionEvent != null) {
@@ -107,13 +152,13 @@ public class PointerEvent extends Event<PointerEvent> {
     ArrayList<WritableMap> pointerEvents = new ArrayList<>();
 
     for (int index = 0; index < motionEvent.getPointerCount(); index++) {
-      pointerEvents.add(this.createPointerEvent(index));
+      pointerEvents.add(this.createPointerEventData(index));
     }
 
     return pointerEvents;
   }
 
-  private WritableMap createPointerEvent(int index) {
+  private WritableMap createPointerEventData(int index) {
     WritableMap pointerEvent = Arguments.createMap();
 
     pointerEvent.putDouble("pointerId", mMotionEvent.getPointerId(index));
@@ -126,46 +171,57 @@ public class PointerEvent extends Event<PointerEvent> {
     pointerEvent.putDouble("clientX", mMotionEvent.getX(index));
     pointerEvent.putDouble("clientY", mMotionEvent.getY(index));
 
+    // Offset refers to upper left edge of the target view
+    pointerEvent.putDouble("offsetX", PixelUtil.toDIPFromPixel(mOffsetX));
+    pointerEvent.putDouble("offsetY", PixelUtil.toDIPFromPixel(mOffsetY));
+
     pointerEvent.putInt("target", this.getViewTag());
     pointerEvent.putDouble("timestamp", this.getTimestampMs());
     return pointerEvent;
   }
 
-  @Override
-  public void dispatchModern(RCTModernEventEmitter rctEventEmitter) {
-    if (mMotionEvent == null) {
-      ReactSoftExceptionLogger.logSoftException(
-          TAG,
-          new IllegalStateException(
-              "Cannot dispatch a Pointer that has no MotionEvent; the PointerEvehas been recycled"));
-      return;
-    }
-
-    List<WritableMap> relevantPointerEventData = null;
-
+  private List<WritableMap> createPointersEventData() {
     int activePointerIndex = mMotionEvent.getActionIndex();
+    List<WritableMap> pointersEventData = null;
     switch (mEventName) {
         // Cases where all pointer info is relevant
       case PointerEventHelper.POINTER_MOVE:
       case PointerEventHelper.POINTER_CANCEL:
-        relevantPointerEventData = createPointerEvents();
+        pointersEventData = createPointerEvents();
         break;
         // Cases where only the "active" pointer info is relevant
       case PointerEventHelper.POINTER_ENTER:
       case PointerEventHelper.POINTER_DOWN:
       case PointerEventHelper.POINTER_UP:
       case PointerEventHelper.POINTER_LEAVE:
-        relevantPointerEventData = Arrays.asList(createPointerEvent(activePointerIndex));
+        pointersEventData = Arrays.asList(createPointerEventData(activePointerIndex));
         break;
     }
 
-    if (relevantPointerEventData == null) {
+    return pointersEventData;
+  }
+
+  @Override
+  public void dispatchModern(RCTModernEventEmitter rctEventEmitter) {
+    if (mMotionEvent == null) {
+      ReactSoftExceptionLogger.logSoftException(
+          TAG,
+          new IllegalStateException(
+              "Cannot dispatch a Pointer that has no MotionEvent; the PointerEvehas been recycled"));
+      return;
+    }
+
+    if (mPointersEventData == null) {
+      mPointersEventData = createPointersEventData();
+    }
+
+    if (mPointersEventData == null) {
       // No relevant MotionEvent to dispatch
       return;
     }
 
-    boolean shouldCopy = relevantPointerEventData.size() > 1;
-    for (WritableMap pointerEventData : relevantPointerEventData) {
+    boolean shouldCopy = mPointersEventData.size() > 1;
+    for (WritableMap pointerEventData : mPointersEventData) {
       WritableMap eventData = shouldCopy ? pointerEventData.copy() : pointerEventData;
       rctEventEmitter.receiveEvent(
           this.getSurfaceId(),

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

@@ -8,6 +8,11 @@
 package com.facebook.react.uimanager.events;
 
 import android.view.MotionEvent;
+import android.view.View;
+import androidx.annotation.Nullable;
+import com.facebook.common.logging.FLog;
+import com.facebook.react.R;
+import com.facebook.react.common.ReactConstants;
 
 /** Class responsible for generating catalyst touch events based on android {@link MotionEvent}. */
 public class PointerEventHelper {
@@ -17,13 +22,51 @@ public class PointerEventHelper {
   public static final String POINTER_TYPE_MOUSE = "mouse";
   public static final String POINTER_TYPE_UNKNOWN = "";
 
+  private static final int X_FLAG_SUPPORTS_HOVER = 0x01000000;
+
+  public static enum EVENT {
+    CANCEL,
+    CANCEL_CAPTURE,
+    DOWN,
+    DOWN_CAPTURE,
+    ENTER,
+    ENTER_CAPTURE,
+    LEAVE,
+    LEAVE_CAPTURE,
+    MOVE,
+    MOVE_CAPTURE,
+    UP,
+    UP_CAPTURE,
+  };
+
   public static final String POINTER_CANCEL = "topPointerCancel";
   public static final String POINTER_DOWN = "topPointerDown";
-  public static final String POINTER_ENTER = "topPointerEnter2";
-  public static final String POINTER_LEAVE = "topPointerLeave2";
-  public static final String POINTER_MOVE = "topPointerMove2";
+  public static final String POINTER_ENTER = "topPointerEnter";
+  public static final String POINTER_LEAVE = "topPointerLeave";
+  public static final String POINTER_MOVE = "topPointerMove";
   public static final String POINTER_UP = "topPointerUp";
 
+  /** We don't dispatch capture events from native; that's currently handled by JS. */
+  public static @Nullable String getDispatchableEventName(EVENT event) {
+    switch (event) {
+      case LEAVE:
+        return PointerEventHelper.POINTER_LEAVE;
+      case DOWN:
+        return PointerEventHelper.POINTER_DOWN;
+      case MOVE:
+        return PointerEventHelper.POINTER_MOVE;
+      case ENTER:
+        return PointerEventHelper.POINTER_ENTER;
+      case CANCEL:
+        return PointerEventHelper.POINTER_CANCEL;
+      case UP:
+        return PointerEventHelper.POINTER_UP;
+      default:
+        FLog.e(ReactConstants.TAG, "No dispatchable event name for type: " + event);
+        return null;
+    }
+  }
+
   public static String getW3CPointerType(final int toolType) {
     // https://www.w3.org/TR/pointerevents3/#dom-pointerevent-pointertype
     switch (toolType) {
@@ -39,6 +82,50 @@ public class PointerEventHelper {
     return POINTER_TYPE_UNKNOWN;
   }
 
+  public static boolean isListening(@Nullable View view, EVENT event) {
+    if (view == null) {
+      return false;
+    }
+
+    Object value = null;
+    switch (event) {
+      case DOWN:
+      case DOWN_CAPTURE:
+      case UP:
+      case UP_CAPTURE:
+      case CANCEL:
+      case CANCEL_CAPTURE:
+        return true;
+      case ENTER:
+        value = view.getTag(R.id.pointer_enter);
+        break;
+      case ENTER_CAPTURE:
+        value = view.getTag(R.id.pointer_enter_capture);
+        break;
+      case LEAVE:
+        value = view.getTag(R.id.pointer_leave);
+        break;
+      case LEAVE_CAPTURE:
+        value = view.getTag(R.id.pointer_leave_capture);
+        break;
+      case MOVE:
+        value = view.getTag(R.id.pointer_move);
+        break;
+      case MOVE_CAPTURE:
+        value = view.getTag(R.id.pointer_move_capture);
+        break;
+    }
+
+    if (value == null) {
+      return false;
+    }
+
+    if (value instanceof Boolean) {
+      return (Boolean) value;
+    }
+    return false;
+  }
+
   public static int getEventCategory(String pointerEventType) {
     if (pointerEventType == null) {
       return EventCategoryDef.UNSPECIFIED;
@@ -59,7 +146,17 @@ public class PointerEventHelper {
     return EventCategoryDef.UNSPECIFIED;
   }
 
-  public static boolean supportsHover(final int toolType) {
+  public static boolean supportsHover(MotionEvent motionEvent) {
+    // A flag has been set on the MotionEvent to indicate it supports hover
+    // See D36958947 on justifications for this.
+    // TODO(luwe): Leverage previous events to determine if MotionEvent
+    //  is from an input device that supports hover
+    boolean supportsHoverFlag = (motionEvent.getFlags() & X_FLAG_SUPPORTS_HOVER) != 0;
+    if (supportsHoverFlag) {
+      return true;
+    }
+
+    int toolType = motionEvent.getToolType(motionEvent.getActionIndex());
     String pointerType = getW3CPointerType(toolType);
 
     if (pointerType.equals(POINTER_TYPE_MOUSE)) {

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

@@ -86,7 +86,7 @@ public class ReactEventEmitter implements RCTModernEventEmitter {
   @Override
   public void receiveTouches(TouchEvent event) {
     int reactTag = event.getViewTag();
-    @UIManagerType int uiManagerType = ViewUtil.getUIManagerType(reactTag);
+    @UIManagerType int uiManagerType = event.getUIManagerType();
     if (uiManagerType == UIManagerType.FABRIC && mFabricEventEmitter != null) {
       mFabricEventEmitter.receiveTouches(event);
     } else if (uiManagerType == UIManagerType.DEFAULT && getEventEmitter(reactTag) != null) {

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

@@ -9,6 +9,7 @@ rn_android_library(
         "pfh:ReactNative_CommonInfrastructurePlaceholder",
         "supermodule:xplat/default/public.react_native.infra",
     ],
+    language = "JAVA",
     visibility = [
         "PUBLIC",
     ],

package/ReactAndroid/src/main/java/com/facebook/react/util/BUCK

@@ -8,6 +8,7 @@ rn_android_library(
         "pfh:ReactNative_CommonInfrastructurePlaceholder",
         "supermodule:xplat/default/public.react_native.infra",
     ],
+    language = "JAVA",
     visibility = [
         "PUBLIC",
     ],