react-native 0.66.0-rc.4 → 0.67.0-rc.1

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

@@ -17,7 +17,9 @@ import androidx.annotation.Nullable;
 import com.facebook.react.bridge.JSApplicationIllegalArgumentException;
 import com.facebook.react.bridge.UiThreadUtil;
 import com.facebook.react.touch.ReactHitSlopView;
+import java.util.ArrayList;
 import java.util.EnumSet;
+import java.util.List;
 
 /**
  * Class responsible for identifying which react view should handle a given {@link MotionEvent}. It
@@ -81,7 +83,7 @@ public class TouchTargetHelper {
     // Store eventCoords in array so that they are modified to be relative to the targetView found.
     viewCoords[0] = eventX;
     viewCoords[1] = eventY;
-    View nativeTargetView = findTouchTargetViewWithPointerEvents(viewCoords, viewGroup);
+    View nativeTargetView = findTouchTargetViewWithPointerEvents(viewCoords, viewGroup, null);
     if (nativeTargetView != null) {
       View reactTargetView = findClosestReactAncestor(nativeTargetView);
       if (reactTargetView != null) {
@@ -94,6 +96,39 @@ public class TouchTargetHelper {
     return targetTag;
   }
 
+  /**
+   * Find touch event target view within the provided container given the coordinates provided via
+   * {@link MotionEvent}.
+   *
+   * @param eventX the X screen coordinate of the touch location
+   * @param eventY the Y screen coordinate of the touch location
+   * @param viewGroup the container view to traverse
+   * @param viewCoords an out parameter that will return the X,Y value in the target view
+   * @return If a target was found, returns a path through the view tree of all react tags that are
+   *     a container for the touch target, ordered from target to root (last element)
+   */
+  public static List<Integer> findTargetPathAndCoordinatesForTouch(
+      float eventX, float eventY, ViewGroup viewGroup, float[] viewCoords) {
+    UiThreadUtil.assertOnUiThread();
+
+    // Store eventCoords in array so that they are modified to be relative to the targetView found.
+    viewCoords[0] = eventX;
+    viewCoords[1] = eventY;
+
+    List<Integer> pathAccumulator = new ArrayList<>();
+    View targetView = findTouchTargetViewWithPointerEvents(viewCoords, viewGroup, pathAccumulator);
+
+    if (targetView != null) {
+      View reactTargetView = findClosestReactAncestor(targetView);
+      int targetTag = getTouchTargetForView(reactTargetView, viewCoords[0], viewCoords[1]);
+      if (targetTag != pathAccumulator.get(0)) {
+        pathAccumulator.add(0, targetTag);
+      }
+    }
+
+    return pathAccumulator;
+  }
+
   private static View findClosestReactAncestor(View view) {
     while (view != null && view.getId() <= 0) {
       view = (View) view.getParent();
@@ -121,7 +156,10 @@ public class TouchTargetHelper {
    * relative to the targetView found.
    */
   private static View findTouchTargetView(
-      float[] eventCoords, View view, EnumSet<TouchTargetReturnType> allowReturnTouchTargetTypes) {
+      float[] eventCoords,
+      View view,
+      EnumSet<TouchTargetReturnType> allowReturnTouchTargetTypes,
+      List<Integer> pathAccumulator) {
     // We prefer returning a child, so we check for a child that can handle the touch first
     if (allowReturnTouchTargetTypes.contains(TouchTargetReturnType.CHILD)
         && view instanceof ViewGroup) {
@@ -143,8 +181,7 @@ public class TouchTargetHelper {
         float restoreY = eventCoords[1];
         eventCoords[0] = childPoint.x;
         eventCoords[1] = childPoint.y;
-        View targetView = findTouchTargetViewWithPointerEvents(eventCoords, child);
-
+        View targetView = findTouchTargetViewWithPointerEvents(eventCoords, child, pathAccumulator);
         if (targetView != null) {
           // We don't allow touches on views that are outside the bounds of an `overflow: hidden`
           // View
@@ -158,6 +195,9 @@ public class TouchTargetHelper {
           }
           if (inOverflowBounds) {
             return targetView;
+          } else if (pathAccumulator != null) {
+            // Not a hit, reset the path found so far
+            pathAccumulator.clear();
           }
         }
         eventCoords[0] = restoreX;
@@ -224,7 +264,7 @@ public class TouchTargetHelper {
    * its descendants are the touch target.
    */
   private static @Nullable View findTouchTargetViewWithPointerEvents(
-      float eventCoords[], View view) {
+      float eventCoords[], View view, @Nullable List<Integer> pathAccumulator) {
     PointerEvents pointerEvents =
         view instanceof ReactPointerEventsView
             ? ((ReactPointerEventsView) view).getPointerEvents()
@@ -247,13 +287,23 @@ public class TouchTargetHelper {
 
     } else if (pointerEvents == PointerEvents.BOX_ONLY) {
       // This view may be the target, its children don't matter
-      return findTouchTargetView(eventCoords, view, EnumSet.of(TouchTargetReturnType.SELF));
+      View targetView =
+          findTouchTargetView(
+              eventCoords, view, EnumSet.of(TouchTargetReturnType.SELF), pathAccumulator);
+      if (targetView != null && pathAccumulator != null) {
+        pathAccumulator.add(view.getId());
+      }
+      return targetView;
 
     } else if (pointerEvents == PointerEvents.BOX_NONE) {
       // This view can't be the target, but its children might.
       View targetView =
-          findTouchTargetView(eventCoords, view, EnumSet.of(TouchTargetReturnType.CHILD));
+          findTouchTargetView(
+              eventCoords, view, EnumSet.of(TouchTargetReturnType.CHILD), pathAccumulator);
       if (targetView != null) {
+        if (pathAccumulator != null) {
+          pathAccumulator.add(view.getId());
+        }
         return targetView;
       }
 
@@ -266,8 +316,11 @@ public class TouchTargetHelper {
       if (view instanceof ReactCompoundView
           && isTouchPointInView(eventCoords[0], eventCoords[1], view)) {
         int reactTag = ((ReactCompoundView) view).reactTagForTouch(eventCoords[0], eventCoords[1]);
+        // make sure we exclude the View itself because of the PointerEvents.BOX_NONE
         if (reactTag != view.getId()) {
-          // make sure we exclude the View itself because of the PointerEvents.BOX_NONE
+          if (pathAccumulator != null) {
+            pathAccumulator.add(view.getId());
+          }
           return view;
         }
       }
@@ -279,10 +332,22 @@ public class TouchTargetHelper {
       if (view instanceof ReactCompoundViewGroup
           && isTouchPointInView(eventCoords[0], eventCoords[1], view)
           && ((ReactCompoundViewGroup) view).interceptsTouchEvent(eventCoords[0], eventCoords[1])) {
+        if (pathAccumulator != null) {
+          pathAccumulator.add(view.getId());
+        }
         return view;
       }
-      return findTouchTargetView(
-          eventCoords, view, EnumSet.of(TouchTargetReturnType.SELF, TouchTargetReturnType.CHILD));
+
+      View result =
+          findTouchTargetView(
+              eventCoords,
+              view,
+              EnumSet.of(TouchTargetReturnType.SELF, TouchTargetReturnType.CHILD),
+              pathAccumulator);
+      if (result != null && pathAccumulator != null) {
+        pathAccumulator.add(view.getId());
+      }
+      return result;
 
     } else {
       throw new JSApplicationIllegalArgumentException(

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

@@ -40,15 +40,6 @@ public abstract class Event<T extends Event> {
   private long mTimestampMs;
   private int mUniqueID = sUniqueID++;
 
-  // Android native Event times use 'uptimeMillis', and historically we've used `uptimeMillis`
-  // throughout this Event class as the coalescing key for events, and for other purposes.
-  // To get an accurate(ish) absolute UNIX time for the event, we store the initial clock time here.
-  // uptimeMillis can then be added to this to get an accurate UNIX time.
-  // However, we still default to uptimeMillis: you must explicitly request UNIX time if you want
-  // that; see `getUnixTimestampMs`.
-  public static final long sInitialClockTimeUnixOffset =
-      SystemClock.currentTimeMillis() - SystemClock.uptimeMillis();
-
   protected Event() {}
 
   @Deprecated
@@ -65,8 +56,16 @@ public abstract class Event<T extends Event> {
     init(-1, viewTag);
   }
 
-  /** This method needs to be called before event is sent to event dispatcher. */
   protected void init(int surfaceId, int viewTag) {
+    init(surfaceId, viewTag, SystemClock.uptimeMillis());
+  }
+
+  /**
+   * This method needs to be called before event is sent to event dispatcher. Event timestamps can
+   * optionally be dated/backdated to a custom time: for example, touch events should be dated with
+   * the system event time.
+   */
+  protected void init(int surfaceId, int viewTag, long timestampMs) {
     mSurfaceId = surfaceId;
     mViewTag = viewTag;
 
@@ -82,9 +81,7 @@ public abstract class Event<T extends Event> {
     // At some point it would be great to pass the SurfaceContext here instead.
     mUIManagerType = (surfaceId == -1 ? UIManagerType.DEFAULT : UIManagerType.FABRIC);
 
-    // This is a *relative* time. See `getUnixTimestampMs`.
-    mTimestampMs = SystemClock.uptimeMillis();
-
+    mTimestampMs = timestampMs;
     mInitialized = true;
   }
 
@@ -106,11 +103,6 @@ public abstract class Event<T extends Event> {
     return mTimestampMs;
   }
 
-  /** @return the time at which the event happened as a UNIX timestamp, in milliseconds. */
-  public final long getUnixTimestampMs() {
-    return sInitialClockTimeUnixOffset + mTimestampMs;
-  }
-
   /** @return false if this Event can *never* be coalesced */
   public boolean canCoalesce() {
     return true;
@@ -174,7 +166,7 @@ public abstract class Event<T extends Event> {
     WritableMap eventData = getEventData();
     if (eventData == null) {
       throw new IllegalViewOperationException(
-          "Event: you must return a valid, non-null value from `getEventData`, or override `dispatch` and `disatchModern`. Event: "
+          "Event: you must return a valid, non-null value from `getEventData`, or override `dispatch` and `dispatchModern`. Event: "
               + getEventName());
     }
     rctEventEmitter.receiveEvent(getViewTag(), getEventName(), eventData);
@@ -190,18 +182,22 @@ public abstract class Event<T extends Event> {
     return null;
   }
 
+  @EventCategoryDef
+  protected int getEventCategory() {
+    return EventCategoryDef.UNSPECIFIED;
+  }
+
   /**
    * Dispatch this event to JS using a V2 EventEmitter. If surfaceId is not -1 and `getEventData` is
    * non-null, this will use the RCTModernEventEmitter API. Otherwise, it falls back to the
    * old-style dispatch function. For Event classes that need to do something different, this method
    * can always be overridden entirely, but it is not recommended.
    */
-  @Deprecated
   public void dispatchModern(RCTModernEventEmitter rctEventEmitter) {
     if (getSurfaceId() != -1) {
       WritableMap eventData = getEventData();
       if (eventData != null) {
-        rctEventEmitter.receiveEvent(getSurfaceId(), getViewTag(), getEventName(), getEventData());
+        rctEventEmitter.receiveEvent(getSurfaceId(), getViewTag(), getEventName(), eventData);
         return;
       }
     }
@@ -224,7 +220,8 @@ public abstract class Event<T extends Event> {
             getEventName(),
             canCoalesce(),
             getCoalescingKey(),
-            getEventData());
+            eventData,
+            getEventCategory());
         return;
       }
     }

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

@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+package com.facebook.react.uimanager.events;
+
+import static com.facebook.react.uimanager.events.EventCategoryDef.CONTINUOUS;
+import static com.facebook.react.uimanager.events.EventCategoryDef.CONTINUOUS_END;
+import static com.facebook.react.uimanager.events.EventCategoryDef.CONTINUOUS_START;
+import static com.facebook.react.uimanager.events.EventCategoryDef.DISCRETE;
+import static com.facebook.react.uimanager.events.EventCategoryDef.UNSPECIFIED;
+
+import androidx.annotation.IntDef;
+
+/**
+ * Java specific declaration of the `RawEvent::Category` enum. Keep in sync with
+ * `renderer/core/RawEvent.h`.
+ */
+@IntDef(value = {CONTINUOUS_START, CONTINUOUS_END, UNSPECIFIED, DISCRETE, CONTINUOUS})
+public @interface EventCategoryDef {
+  /** Start of a continuous event. To be used with touchStart. */
+  int CONTINUOUS_START = 0;
+
+  /** End of a continuous event. To be used with touchEnd. */
+  int CONTINUOUS_END = 1;
+
+  /**
+   * Priority for this event will be determined from other events in the queue. If it is triggered
+   * by continuous event, its priority will be default. If it is not triggered by continuous event,
+   * its priority will be discrete.
+   */
+  int UNSPECIFIED = 2;
+
+  /** Forces discrete type for the event. Regardless if continuous event is ongoing. */
+  int DISCRETE = 3;
+
+  /** Forces continuous type for the event. Regardless if continuous event isn't ongoing. */
+  int CONTINUOUS = 4;
+}

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

@@ -13,6 +13,7 @@ import com.facebook.react.bridge.LifecycleEventListener;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.UiThreadUtil;
 import com.facebook.react.common.MapBuilder;
+import com.facebook.react.config.ReactFeatureFlags;
 import com.facebook.react.modules.core.ChoreographerCompat;
 import com.facebook.react.modules.core.ReactChoreographer;
 import com.facebook.react.uimanager.common.UIManagerType;
@@ -366,7 +367,12 @@ public class EventDispatcherImpl implements EventDispatcher, LifecycleEventListe
               }
               Systrace.endAsyncFlow(
                   Systrace.TRACE_TAG_REACT_JAVA_BRIDGE, event.getEventName(), event.getUniqueID());
-              event.dispatchModern(mReactEventEmitter);
+
+              if (ReactFeatureFlags.useDispatchUniqueForCoalescableEvents) {
+                event.dispatchModernV2(mReactEventEmitter);
+              } else {
+                event.dispatchModern(mReactEventEmitter);
+              }
               event.dispose();
             }
             clearEventsToDispatch();

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

@@ -52,7 +52,7 @@ import java.util.concurrent.CopyOnWriteArrayList;
  */
 public class LockFreeEventDispatcherImpl implements EventDispatcher, LifecycleEventListener {
 
-  private final boolean DEBUG_MODE = true && ReactBuildConfig.DEBUG;
+  private final boolean DEBUG_MODE = ReactBuildConfig.DEBUG;
   private final String TAG = LockFreeEventDispatcherImpl.class.getSimpleName();
 
   private final ReactApplicationContext mReactContext;
@@ -77,7 +77,7 @@ public class LockFreeEventDispatcherImpl implements EventDispatcher, LifecycleEv
     Assertions.assertNotNull(mReactEventEmitter);
 
     if (DEBUG_MODE) {
-      FLog.d(TAG, "dispatchEvent: " + event.toString());
+      FLog.v(TAG, "dispatchEvent: " + event.toString());
     }
 
     for (EventDispatcherListener listener : mListeners) {

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

@@ -27,5 +27,12 @@ public interface RCTEventEmitter extends JavaScriptModule {
   @Deprecated
   void receiveEvent(int targetTag, String eventName, @Nullable WritableMap event);
 
+  /**
+   * Receive and process touches
+   *
+   * @param eventName JS event name
+   * @param touches active pointers data
+   * @param changedIndices indices of changed pointers
+   */
   void receiveTouches(String eventName, WritableArray touches, WritableArray changedIndices);
 }

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

@@ -28,5 +28,6 @@ public interface RCTModernEventEmitter extends RCTEventEmitter {
       String eventName,
       boolean canCoalesceEvent,
       int customCoalesceKey,
-      @Nullable WritableMap event);
+      @Nullable WritableMap event,
+      @EventCategoryDef int category);
 }

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

@@ -61,15 +61,10 @@ public class ReactEventEmitter implements RCTModernEventEmitter {
 
   @Override
   public void receiveEvent(
-      int surfaceId,
-      int targetTag,
-      String eventName,
-      boolean canCoalesceEvent,
-      int customCoalesceKey,
-      @Nullable WritableMap event) {
+      int surfaceId, int targetTag, String eventName, @Nullable WritableMap event) {
     // The two additional params here, `canCoalesceEvent` and `customCoalesceKey`, have no
     // meaning outside of Fabric.
-    receiveEvent(surfaceId, targetTag, eventName, event);
+    receiveEvent(surfaceId, targetTag, eventName, false, 0, event, EventCategoryDef.UNSPECIFIED);
   }
 
   @Override
@@ -120,10 +115,23 @@ public class ReactEventEmitter implements RCTModernEventEmitter {
 
   @Override
   public void receiveEvent(
-      int surfaceId, int targetReactTag, String eventName, @Nullable WritableMap event) {
+      int surfaceId,
+      int targetReactTag,
+      String eventName,
+      boolean canCoalesceEvent,
+      int customCoalesceKey,
+      @Nullable WritableMap event,
+      @EventCategoryDef int category) {
     @UIManagerType int uiManagerType = ViewUtil.getUIManagerType(targetReactTag);
     if (uiManagerType == UIManagerType.FABRIC && mFabricEventEmitter != null) {
-      mFabricEventEmitter.receiveEvent(surfaceId, targetReactTag, eventName, event);
+      mFabricEventEmitter.receiveEvent(
+          surfaceId,
+          targetReactTag,
+          eventName,
+          canCoalesceEvent,
+          customCoalesceKey,
+          event,
+          category);
     } else if (uiManagerType == UIManagerType.DEFAULT && getEventEmitter(targetReactTag) != null) {
       mRCTEventEmitter.receiveEvent(targetReactTag, eventName, event);
     } else {

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

@@ -13,6 +13,7 @@ import androidx.core.util.Pools;
 import com.facebook.infer.annotation.Assertions;
 import com.facebook.react.bridge.ReactSoftExceptionLogger;
 import com.facebook.react.bridge.SoftAssertions;
+import com.facebook.react.config.ReactFeatureFlags;
 
 /**
  * An event representing the start, end or movement of a touch. Corresponds to a single {@link
@@ -96,7 +97,7 @@ public class TouchEvent extends Event<TouchEvent> {
       float viewX,
       float viewY,
       TouchEventCoalescingKeyHelper touchEventCoalescingKeyHelper) {
-    super.init(surfaceId, viewTag);
+    super.init(surfaceId, viewTag, motionEventToCopy.getEventTime());
 
     SoftAssertions.assertCondition(
         gestureStartTime != UNSET, "Gesture start time must be initialized");
@@ -188,17 +189,47 @@ public class TouchEvent extends Event<TouchEvent> {
               "Cannot dispatch a TouchEvent that has no MotionEvent; the TouchEvent has been recycled"));
       return;
     }
-    TouchesHelper.sendTouchEvent(
-        rctEventEmitter,
-        Assertions.assertNotNull(mTouchEventType),
-        getSurfaceId(),
-        getViewTag(),
-        this);
+
+    TouchesHelper.sendTouchEvent(rctEventEmitter, this);
   }
 
   @Override
   public void dispatchModern(RCTModernEventEmitter rctEventEmitter) {
-    dispatch(rctEventEmitter);
+    if (ReactFeatureFlags.useUpdatedTouchPreprocessing) {
+      TouchesHelper.sendTouchEventModern(rctEventEmitter, this, /* useDispatchV2 */ false);
+    } else {
+      dispatch(rctEventEmitter);
+    }
+  }
+
+  @Override
+  public void dispatchModernV2(RCTModernEventEmitter rctEventEmitter) {
+    if (ReactFeatureFlags.useUpdatedTouchPreprocessing) {
+      TouchesHelper.sendTouchEventModern(rctEventEmitter, this, /* useDispatchV2 */ true);
+    } else {
+      dispatch(rctEventEmitter);
+    }
+  }
+
+  @Override
+  protected int getEventCategory() {
+    TouchEventType type = mTouchEventType;
+    if (type == null) {
+      return EventCategoryDef.UNSPECIFIED;
+    }
+
+    switch (type) {
+      case START:
+        return EventCategoryDef.CONTINUOUS_START;
+      case END:
+      case CANCEL:
+        return EventCategoryDef.CONTINUOUS_END;
+      case MOVE:
+        return EventCategoryDef.CONTINUOUS;
+    }
+
+    // Something something smart compiler...
+    return super.getEventCategory();
   }
 
   public MotionEvent getMotionEvent() {
@@ -210,6 +241,10 @@ public class TouchEvent extends Event<TouchEvent> {
     return mMotionEvent != null;
   }
 
+  public TouchEventType getTouchEventType() {
+    return Assertions.assertNotNull(mTouchEventType);
+  }
+
   public float getViewX() {
     return mViewX;
   }

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

@@ -9,23 +9,22 @@ package com.facebook.react.uimanager.events;
 
 /** Touch event types that JS module RCTEventEmitter can understand */
 public enum TouchEventType {
-  START,
-  END,
-  MOVE,
-  CANCEL;
+  START("topTouchStart"),
+  END("topTouchEnd"),
+  MOVE("topTouchMove"),
+  CANCEL("topTouchCancel");
+
+  private final String mJsName;
+
+  TouchEventType(String jsName) {
+    mJsName = jsName;
+  }
+
+  public String getJsName() {
+    return mJsName;
+  }
 
   public static String getJSEventName(TouchEventType type) {
-    switch (type) {
-      case START:
-        return "topTouchStart";
-      case END:
-        return "topTouchEnd";
-      case MOVE:
-        return "topTouchMove";
-      case CANCEL:
-        return "topTouchCancel";
-      default:
-        throw new IllegalArgumentException("Unexpected type " + type);
-    }
+    return type.getJsName();
   }
 }