@depup/react-native 0.86.2-depup.0 → 0.87.0-depup.0

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

@@ -1,736 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and 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;
-
-import android.graphics.Rect;
-import android.view.MotionEvent;
-import android.view.View;
-import android.view.ViewGroup;
-import androidx.annotation.Nullable;
-import com.facebook.common.logging.FLog;
-import com.facebook.infer.annotation.Assertions;
-import com.facebook.react.common.ReactConstants;
-import com.facebook.react.internal.featureflags.ReactNativeFeatureFlags;
-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.PointerEvent.PointerEventState;
-import com.facebook.react.uimanager.events.PointerEventHelper;
-import com.facebook.react.uimanager.events.PointerEventHelper.EVENT;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-
-/**
- * JSPointerDispatcher handles dispatching pointer events to JS from RootViews. If you implement
- * RootView you need to call handleMotionEvent from onTouchEvent, onInterceptTouchEvent,
- * onHoverEvent, onInterceptHoverEvent. It will correctly find the right view to handle the touch
- * and also dispatch the appropriate event to JS
- */
-public class JSPointerDispatcher {
-  private static final int UNSELECTED_VIEW_TAG = -1;
-  private static final int UNSET_POINTER_ID = -1;
-  private static final int UNSET_CHILD_VIEW_ID = -1;
-  private static final float ONMOVE_EPSILON = 0.1f;
-  private static final String TAG = "PointerEvents";
-
-  private Map<Integer, List<ViewTarget>> mLastHitPathByPointerId;
-  private Map<Integer, float[]> mLastEventCoordinatesByPointerId;
-  private Map<Integer, List<ViewTarget>> mCurrentlyDownPointerIdsToHitPath;
-  private final Set<Integer> mHoveringPointerIds = new HashSet<>();
-
-  private int mChildHandlingNativeGesture = UNSET_CHILD_VIEW_ID;
-  private int mPrimaryPointerId = UNSET_POINTER_ID;
-  private int mCoalescingKey = 0;
-  private int mLastButtonState = 0;
-  private final ViewGroup mRootViewGroup;
-
-  private static final int[] sRootScreenCoords = {0, 0};
-  private static final Rect sChildCoords = new Rect(0, 0, 1, 1);
-
-  public JSPointerDispatcher(ViewGroup viewGroup) {
-    mRootViewGroup = viewGroup;
-    mCurrentlyDownPointerIdsToHitPath = new HashMap<>();
-  }
-
-  public void onChildStartedNativeGesture(
-      @Nullable View childView, MotionEvent motionEvent, EventDispatcher eventDispatcher) {
-    if (mChildHandlingNativeGesture != UNSET_CHILD_VIEW_ID || childView == null) {
-      // This means we previously had another child start handling this native gesture and now a
-      // different native parent of that child has decided to intercept the touch stream and handle
-      // the gesture itself. Example where this can happen: HorizontalScrollView in a ScrollView.
-      return;
-    }
-
-    MotionEvent motionInRoot = convertMotionToRootFrame(childView, motionEvent);
-    motionInRoot.setAction(MotionEvent.ACTION_CANCEL);
-    handleMotionEvent(motionInRoot, eventDispatcher, false);
-
-    mChildHandlingNativeGesture = childView.getId();
-  }
-
-  private MotionEvent convertMotionToRootFrame(View childView, MotionEvent childMotion) {
-    MotionEvent motionInRoot = MotionEvent.obtain(childMotion);
-
-    int[] location = new int[2];
-    mRootViewGroup.getLocationOnScreen(location);
-    float screenX = childMotion.getRawX();
-    float screenY = childMotion.getRawY();
-    float clientX = screenX - location[0];
-    float clientY = screenY - location[1];
-    motionInRoot.setLocation(clientX, clientY);
-
-    return motionInRoot;
-  }
-
-  public void onChildEndedNativeGesture() {
-    // There should be only one child gesture at any given time. We can safely turn off the flag.
-    mChildHandlingNativeGesture = UNSET_CHILD_VIEW_ID;
-  }
-
-  // returns the section of the hit path shared by both lists, or an empty list if there's no such
-  // section
-  private static List<ViewTarget> findHitPathIntersection(
-      final List<ViewTarget> hitsA, final List<ViewTarget> hitsB) {
-    if (hitsA.isEmpty()) {
-      return new ArrayList<>();
-    }
-    if (hitsB.isEmpty()) {
-      return new ArrayList<>();
-    }
-
-    Set<ViewTarget> inA = new HashSet<>(hitsA);
-
-    List<ViewTarget> intersection = new ArrayList<>();
-
-    for (final ViewTarget vt : hitsB) {
-      if (inA.contains(vt)) {
-        intersection.add(vt);
-      }
-    }
-
-    return intersection;
-  }
-
-  private void onUp(
-      int activeTargetTag,
-      PointerEventState eventState,
-      MotionEvent motionEvent,
-      EventDispatcher eventDispatcher) {
-
-    int activePointerId = eventState.getActivePointerId();
-    List<ViewTarget> activeHitPath = eventState.getHitPathByPointerId().get(activePointerId);
-
-    boolean listeningForUp =
-        isAnyoneListeningForBubblingEvent(activeHitPath, EVENT.UP, EVENT.UP_CAPTURE);
-    if (listeningForUp) {
-      List<Integer> activeHitPathViewIds =
-          ReactNativeFeatureFlags.cxxNativeAnimatedEnabled()
-              ? eventState.getHitPathViewIdsForActivePointer()
-              : null;
-      eventDispatcher.dispatchEvent(
-          PointerEvent.obtain(
-              PointerEventHelper.POINTER_UP,
-              activeTargetTag,
-              eventState,
-              motionEvent,
-              activeHitPathViewIds));
-    }
-
-    boolean supportsHover = mHoveringPointerIds.contains(activePointerId);
-
-    if (!supportsHover) {
-      boolean listeningForOut =
-          isAnyoneListeningForBubblingEvent(activeHitPath, EVENT.OUT, EVENT.OUT_CAPTURE);
-      if (listeningForOut) {
-        eventDispatcher.dispatchEvent(
-            PointerEvent.obtain(
-                PointerEventHelper.POINTER_OUT, activeTargetTag, eventState, motionEvent));
-      }
-
-      List<ViewTarget> leaveViewTargets =
-          filterByShouldDispatch(activeHitPath, EVENT.LEAVE, EVENT.LEAVE_CAPTURE, false);
-
-      // target -> root
-      dispatchEventForViewTargets(
-          PointerEventHelper.POINTER_LEAVE,
-          eventState,
-          motionEvent,
-          leaveViewTargets,
-          eventDispatcher);
-    }
-
-    List<ViewTarget> hitPathDown = mCurrentlyDownPointerIdsToHitPath.remove(activePointerId);
-    if (hitPathDown != null
-        && isAnyoneListeningForBubblingEvent(activeHitPath, EVENT.CLICK, EVENT.CLICK_CAPTURE)) {
-      List<ViewTarget> hitPathForClick = findHitPathIntersection(hitPathDown, activeHitPath);
-      if (!hitPathForClick.isEmpty()) {
-        final ViewTarget clickTarget = hitPathForClick.get(0);
-        eventDispatcher.dispatchEvent(
-            PointerEvent.obtain(
-                PointerEventHelper.CLICK, clickTarget.getViewId(), eventState, motionEvent));
-      }
-    }
-
-    if (motionEvent.getActionMasked() == MotionEvent.ACTION_UP) {
-      mPrimaryPointerId = UNSET_POINTER_ID;
-    }
-    mHoveringPointerIds.remove(activePointerId);
-  }
-
-  private void incrementCoalescingKey() {
-    mCoalescingKey = (mCoalescingKey + 1) % Integer.MAX_VALUE;
-  }
-
-  private short getCoalescingKey() {
-    return ((short) (0xffff & mCoalescingKey));
-  }
-
-  private void onDown(
-      int activeTargetTag,
-      PointerEventState eventState,
-      MotionEvent motionEvent,
-      EventDispatcher eventDispatcher) {
-
-    List<ViewTarget> activeHitPath =
-        eventState.getHitPathByPointerId().get(eventState.getActivePointerId());
-
-    incrementCoalescingKey();
-    boolean supportsHover = mHoveringPointerIds.contains(eventState.getActivePointerId());
-    if (!supportsHover) {
-      // Indirect OVER event dispatches before ENTER
-      boolean listeningForOver =
-          isAnyoneListeningForBubblingEvent(activeHitPath, EVENT.OVER, EVENT.OVER_CAPTURE);
-      if (listeningForOver) {
-        eventDispatcher.dispatchEvent(
-            PointerEvent.obtain(
-                PointerEventHelper.POINTER_OVER, activeTargetTag, eventState, motionEvent));
-      }
-
-      List<ViewTarget> enterViewTargets =
-          filterByShouldDispatch(activeHitPath, EVENT.ENTER, EVENT.ENTER_CAPTURE, false);
-
-      // Dispatch root -> target, we need to reverse order of enterViewTargets
-      Collections.reverse(enterViewTargets);
-      dispatchEventForViewTargets(
-          PointerEventHelper.POINTER_ENTER,
-          eventState,
-          motionEvent,
-          enterViewTargets,
-          eventDispatcher);
-    }
-
-    // store some information if we might need to emit a click later on
-    if (isAnyoneListeningForBubblingEvent(activeHitPath, EVENT.CLICK, EVENT.CLICK_CAPTURE)) {
-      mCurrentlyDownPointerIdsToHitPath.put(
-          eventState.getActivePointerId(), new ArrayList<>(activeHitPath));
-    }
-
-    boolean listeningForDown =
-        isAnyoneListeningForBubblingEvent(activeHitPath, EVENT.DOWN, EVENT.DOWN_CAPTURE);
-    if (listeningForDown) {
-      List<Integer> activeHitPathViewIds =
-          ReactNativeFeatureFlags.cxxNativeAnimatedEnabled()
-              ? eventState.getHitPathViewIdsForActivePointer()
-              : null;
-      eventDispatcher.dispatchEvent(
-          PointerEvent.obtain(
-              PointerEventHelper.POINTER_DOWN,
-              activeTargetTag,
-              eventState,
-              motionEvent,
-              activeHitPathViewIds));
-    }
-  }
-
-  private float[] eventCoordsToScreenCoords(float[] eventCoords) {
-    float[] screenCoords = new float[2];
-    mRootViewGroup.getLocationOnScreen(sRootScreenCoords);
-
-    screenCoords[0] = eventCoords[0] + sRootScreenCoords[0];
-    screenCoords[1] = eventCoords[1] + sRootScreenCoords[1];
-
-    return screenCoords;
-  }
-
-  private PointerEventState createEventState(int activePointerId, MotionEvent motionEvent) {
-    Map<Integer, float[]> offsetByPointerId = new HashMap<Integer, float[]>();
-    Map<Integer, List<ViewTarget>> hitPathByPointerId = new HashMap<Integer, List<ViewTarget>>();
-    Map<Integer, float[]> eventCoordinatesByPointerId = new HashMap<Integer, float[]>();
-    Map<Integer, float[]> screenCoordinatesByPointerId = new HashMap<Integer, float[]>();
-    for (int index = 0; index < motionEvent.getPointerCount(); index++) {
-      float[] offsetCoordinates = new float[2];
-      float[] eventCoordinates = new float[] {motionEvent.getX(index), motionEvent.getY(index)};
-      List<ViewTarget> hitPath =
-          TouchTargetHelper.findTargetPathAndCoordinatesForTouch(
-              eventCoordinates[0], eventCoordinates[1], mRootViewGroup, offsetCoordinates);
-
-      int pointerId = motionEvent.getPointerId(index);
-      offsetByPointerId.put(pointerId, offsetCoordinates);
-      hitPathByPointerId.put(pointerId, hitPath);
-      eventCoordinatesByPointerId.put(pointerId, eventCoordinates);
-      screenCoordinatesByPointerId.put(pointerId, eventCoordsToScreenCoords(eventCoordinates));
-    }
-
-    int surfaceId = UIManagerHelper.getSurfaceId(mRootViewGroup);
-
-    return new PointerEventState(
-        mPrimaryPointerId,
-        activePointerId,
-        mLastButtonState,
-        surfaceId,
-        offsetByPointerId,
-        hitPathByPointerId,
-        eventCoordinatesByPointerId,
-        screenCoordinatesByPointerId,
-        mHoveringPointerIds); // Creates a copy of hovering pointer ids, as they may be updated
-  }
-
-  public void handleMotionEvent(
-      MotionEvent motionEvent, EventDispatcher eventDispatcher, boolean isCapture) {
-    // Don't fire any pointer events if child view is handling native gesture
-    if (mChildHandlingNativeGesture != UNSET_CHILD_VIEW_ID) {
-      return;
-    }
-
-    int action = motionEvent.getActionMasked();
-
-    // On stylus or mouse input, Android will systematically dispatch ACTION_HOVER_EXIT
-    // before ACTION_DOWN (button press), even if the pointer has not moved and is still
-    // hovering over the same view.
-    //
-    // This leads to onPointerLeave being triggered incorrectly.
-    //
-    // To mitigate this, we suppress ACTION_HOVER_EXIT events that occur
-    // while a button is pressed (i.e., buttonState != 0).
-    //
-    // This workaround is effective on Quest devices, however, it may not behave consistently on the
-    // Android emulator, something we’ll revisit if it becomes an issue in open source.
-    if (action == MotionEvent.ACTION_HOVER_EXIT && motionEvent.getButtonState() != 0) {
-      return;
-    }
-
-    int activePointerId = motionEvent.getPointerId(motionEvent.getActionIndex());
-    if (action == MotionEvent.ACTION_DOWN) {
-      mPrimaryPointerId = motionEvent.getPointerId(0);
-    } else if (action == MotionEvent.ACTION_HOVER_MOVE) {
-      mHoveringPointerIds.add(activePointerId);
-    }
-
-    PointerEventState eventState = createEventState(activePointerId, motionEvent);
-
-    // We've empirically determined that when we get a ACTION_HOVER_EXIT from the root view on the
-    // `onInterceptHoverEvent`, this means we've exited the root view. This logic may be wrong but
-    // reasoning about the dispatch sequence for HOVER_ENTER/HOVER_EXIT doesn't follow the
-    // capture/bubbling sequence like other MotionEvents.
-    //
-    // For more information, see:
-    // https://developer.android.com/reference/android/view/MotionEvent#ACTION_HOVER_ENTER
-    // https://suragch.medium.com/how-touch-events-are-delivered-in-android-eee3b607b038
-    boolean isExitFromRoot = isCapture && action == MotionEvent.ACTION_HOVER_EXIT;
-
-    // Calculate the targetTag, with special handling for when we exit the root view. In that case,
-    // we use the root viewId of the last event
-    int activeTargetTag;
-    View activeTargetView;
-
-    List<ViewTarget> activeHitPath;
-    if (isExitFromRoot) {
-      List<ViewTarget> lastHitPath =
-          mLastHitPathByPointerId != null
-              ? mLastHitPathByPointerId.get(eventState.getActivePointerId())
-              : null;
-      if (lastHitPath == null || lastHitPath.isEmpty()) {
-        return;
-      }
-      ViewTarget activeTarget = lastHitPath.get(lastHitPath.size() - 1);
-      activeTargetTag = activeTarget.getViewId();
-      activeTargetView = activeTarget.getView();
-
-      // Explicitly make the hit path for this cursor empty
-      activeHitPath = new ArrayList<>();
-      eventState.getHitPathByPointerId().put(activePointerId, activeHitPath);
-    } else {
-      activeHitPath = eventState.getHitPathByPointerId().get(activePointerId);
-      if (activeHitPath == null || activeHitPath.isEmpty()) {
-        return;
-      }
-      ViewTarget activeTarget = activeHitPath.get(0);
-      activeTargetTag = activeTarget.getViewId();
-      activeTargetView = activeTarget.getView();
-    }
-
-    handleHitStateDivergence(activeTargetTag, eventState, motionEvent, eventDispatcher);
-
-    // Dispatch pointer events from the MotionEvents. When we want to ignore an event, we need to
-    // exit early so we don't record anything about this MotionEvent.
-    switch (action) {
-      case MotionEvent.ACTION_DOWN:
-      case MotionEvent.ACTION_POINTER_DOWN:
-        onDown(activeTargetTag, eventState, motionEvent, eventDispatcher);
-        break;
-      case MotionEvent.ACTION_HOVER_MOVE:
-        // TODO(luwe) - converge this with ACTION_MOVE
-        // If we don't move enough, ignore this event.
-        float[] eventCoordinates = eventState.getEventCoordinatesByPointerId().get(activePointerId);
-        float[] lastEventCoordinates =
-            mLastEventCoordinatesByPointerId != null
-                    && mLastEventCoordinatesByPointerId.containsKey(activePointerId)
-                ? mLastEventCoordinatesByPointerId.get(activePointerId)
-                : new float[] {0, 0};
-        if (!qualifiedMove(eventCoordinates, lastEventCoordinates)) {
-          return;
-        }
-
-        onMove(activeTargetTag, eventState, motionEvent, eventDispatcher);
-        break;
-      case MotionEvent.ACTION_MOVE:
-        onMove(activeTargetTag, eventState, motionEvent, eventDispatcher);
-        break;
-      case MotionEvent.ACTION_UP:
-      case MotionEvent.ACTION_POINTER_UP:
-        incrementCoalescingKey();
-        onUp(activeTargetTag, eventState, motionEvent, eventDispatcher);
-        break;
-      case MotionEvent.ACTION_CANCEL:
-        dispatchCancelEventForTarget(activeTargetView, eventState, motionEvent, eventDispatcher);
-        handleHitStateDivergence(UNSELECTED_VIEW_TAG, eventState, motionEvent, eventDispatcher);
-        break;
-      case MotionEvent.ACTION_HOVER_ENTER:
-        // Ignore these events as enters will be calculated from HOVER_MOVE
-        return;
-      case MotionEvent.ACTION_HOVER_EXIT:
-        // For root exits, we need to update our stored eventState to reflect this exit because we
-        // won't receive future HOVER_MOVE events when cursor is outside root view
-        if (isExitFromRoot) {
-          // We've set the hit path for this pointer to be empty to calculate all exits
-          onMove(activeTargetTag, eventState, motionEvent, eventDispatcher);
-        }
-        break;
-      default:
-        FLog.w(
-            ReactConstants.TAG,
-            "Motion Event was ignored. Action=" + action + " Target=" + activeTargetTag);
-        return;
-    }
-
-    // Update "previous" pointer coordinates and button state
-    Map<Integer, float[]> nextEventCoordinatesByPointerId =
-        new HashMap<>(eventState.getEventCoordinatesByPointerId());
-    mLastEventCoordinatesByPointerId = nextEventCoordinatesByPointerId;
-    mLastButtonState = motionEvent.getButtonState();
-
-    // Clean up any stale pointerIds
-    Set<Integer> allPointerIds = mLastEventCoordinatesByPointerId.keySet();
-    mHoveringPointerIds.retainAll(allPointerIds);
-  }
-
-  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 static void dispatchEventForViewTargets(
-      String eventName,
-      PointerEventState eventState,
-      MotionEvent motionEvent,
-      List<ViewTarget> viewTargets,
-      EventDispatcher dispatcher) {
-
-    for (ViewTarget viewTarget : viewTargets) {
-      int viewId = viewTarget.getViewId();
-      dispatcher.dispatchEvent(PointerEvent.obtain(eventName, viewId, eventState, motionEvent));
-    }
-  }
-
-  private static boolean qualifiedMove(float[] eventCoordinates, float[] lastEventCoordinates) {
-    return (Math.abs(lastEventCoordinates[0] - eventCoordinates[0]) > ONMOVE_EPSILON
-        || Math.abs(lastEventCoordinates[1] - eventCoordinates[1]) > ONMOVE_EPSILON);
-  }
-
-  // Determines which views are being entered and exited based on comparison between the previous
-  // hit path and the current hit path, and dispatches out/over/leave/enter events.
-  private void handleHitStateDivergence(
-      int targetTag,
-      PointerEventState eventState,
-      MotionEvent motionEvent,
-      EventDispatcher eventDispatcher) {
-    int activePointerId = eventState.getActivePointerId();
-    List<ViewTarget> activeHitPath =
-        targetTag != UNSELECTED_VIEW_TAG
-            ? eventState.getHitPathByPointerId().get(activePointerId)
-            : new ArrayList<ViewTarget>();
-    List<ViewTarget> lastHitPath =
-        mLastHitPathByPointerId != null && mLastHitPathByPointerId.containsKey(activePointerId)
-            ? mLastHitPathByPointerId.get(activePointerId)
-            : new ArrayList<ViewTarget>();
-
-    // hitState is list ordered from inner child -> parent tag
-    // Traverse hitState back-to-front to find the first divergence with lastHitPath
-    // FIXME: this may generate incorrect events when view collapsing changes the hierarchy
-    boolean nonDivergentListeningToEnter = false;
-    boolean nonDivergentListeningToLeave = false;
-    int firstDivergentIndexFromBack = 0;
-    while (firstDivergentIndexFromBack < Math.min(activeHitPath.size(), lastHitPath.size())
-        && activeHitPath
-            .get(activeHitPath.size() - 1 - firstDivergentIndexFromBack)
-            .equals(lastHitPath.get(lastHitPath.size() - 1 - firstDivergentIndexFromBack))) {
-
-      // Track if any non-diverging views are listening to enter/leave
-      View nonDivergentViewTargetView =
-          activeHitPath.get(activeHitPath.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 =
-        firstDivergentIndexFromBack < Math.max(activeHitPath.size(), lastHitPath.size());
-
-    if (hasDiverged) {
-      // If something has changed in either enter/exit, let's start a new coalescing key
-      incrementCoalescingKey();
-
-      // Out, Leave events
-      if (lastHitPath.size() > 0) {
-        int lastTargetTag = lastHitPath.get(0).getViewId();
-        boolean listeningForOut =
-            isAnyoneListeningForBubblingEvent(lastHitPath, EVENT.OUT, EVENT.OUT_CAPTURE);
-        if (listeningForOut) {
-          eventDispatcher.dispatchEvent(
-              PointerEvent.obtain(
-                  PointerEventHelper.POINTER_OUT, lastTargetTag, eventState, motionEvent));
-        }
-
-        // target -> root
-        List<ViewTarget> leaveViewTargets =
-            filterByShouldDispatch(
-                lastHitPath.subList(0, lastHitPath.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,
-              eventState,
-              motionEvent,
-              leaveViewTargets,
-              eventDispatcher);
-        }
-      }
-
-      boolean listeningForOver =
-          isAnyoneListeningForBubblingEvent(activeHitPath, EVENT.OVER, EVENT.OVER_CAPTURE);
-      if (listeningForOver) {
-        eventDispatcher.dispatchEvent(
-            PointerEvent.obtain(
-                PointerEventHelper.POINTER_OVER, targetTag, eventState, motionEvent));
-      }
-
-      // target -> root
-      List<ViewTarget> enterViewTargets =
-          filterByShouldDispatch(
-              activeHitPath.subList(0, activeHitPath.size() - firstDivergentIndexFromBack),
-              EVENT.ENTER,
-              EVENT.ENTER_CAPTURE,
-              nonDivergentListeningToEnter);
-
-      if (enterViewTargets.size() > 0) {
-        // We want to iterate these from root -> target so we need to reverse
-        Collections.reverse(enterViewTargets);
-        dispatchEventForViewTargets(
-            PointerEventHelper.POINTER_ENTER,
-            eventState,
-            motionEvent,
-            enterViewTargets,
-            eventDispatcher);
-      }
-    }
-
-    Map<Integer, List<TouchTargetHelper.ViewTarget>> nextHitPathByPointerId =
-        new HashMap<>(eventState.getHitPathByPointerId());
-
-    if (targetTag == UNSELECTED_VIEW_TAG) {
-      nextHitPathByPointerId.remove(activePointerId);
-    }
-    mLastHitPathByPointerId = nextHitPathByPointerId;
-  }
-
-  private void onMove(
-      int targetTag,
-      PointerEventState eventState,
-      MotionEvent motionEvent,
-      EventDispatcher eventDispatcher) {
-    int activePointerId = eventState.getActivePointerId();
-    List<ViewTarget> activeHitPath = eventState.getHitPathByPointerId().get(activePointerId);
-
-    boolean listeningToMove =
-        isAnyoneListeningForBubblingEvent(activeHitPath, EVENT.MOVE, EVENT.MOVE_CAPTURE);
-    if (listeningToMove) {
-      eventDispatcher.dispatchEvent(
-          PointerEvent.obtain(
-              PointerEventHelper.POINTER_MOVE,
-              targetTag,
-              eventState,
-              motionEvent,
-              getCoalescingKey()));
-    }
-  }
-
-  private void dispatchCancelEventForTarget(
-      View targetView,
-      PointerEventState eventState,
-      MotionEvent motionEvent,
-      EventDispatcher eventDispatcher) {
-    // This means the gesture has already ended, via some other CANCEL or UP event. This is not
-    // expected to happen very often as it would mean some child View has decided to intercept the
-    // touch stream and start a native gesture only upon receiving the UP/CANCEL event.
-    Assertions.assertCondition(
-        mChildHandlingNativeGesture == UNSET_CHILD_VIEW_ID,
-        "Expected to not have already sent a cancel for this gesture");
-
-    int activePointerId = eventState.getActivePointerId();
-    List<ViewTarget> activeHitPath = eventState.getHitPathByPointerId().get(activePointerId);
-
-    if (!activeHitPath.isEmpty() && targetView != null) {
-      boolean listeningForCancel =
-          isAnyoneListeningForBubblingEvent(activeHitPath, EVENT.CANCEL, EVENT.CANCEL_CAPTURE);
-      if (listeningForCancel) {
-        int targetTag = activeHitPath.get(0).getViewId();
-
-        // cancel events need to report client coordinates of (0, 0) and offset coordinates relative
-        // to the root view
-        Rect childOffset = getChildOffsetRelativeToRoot(targetView);
-        PointerEventState normalizedEventState =
-            normalizeToRoot(eventState, childOffset.left, childOffset.top);
-        Assertions.assertNotNull(eventDispatcher)
-            .dispatchEvent(
-                PointerEvent.obtain(
-                    PointerEventHelper.POINTER_CANCEL,
-                    targetTag,
-                    normalizedEventState,
-                    motionEvent));
-      }
-
-      incrementCoalescingKey();
-      mPrimaryPointerId = UNSET_POINTER_ID;
-    }
-  }
-
-  // returns child (0, 0) relative to root coordinate system
-  private Rect getChildOffsetRelativeToRoot(View childView) {
-    sChildCoords.set(0, 0, 1, 1);
-    if (childView.getRootView() != mRootViewGroup.getRootView()) {
-      // NOTE: if we are here it means the target view has been reparented, so we can't call
-      // mRootViewGroup.offsetDescendantRectToMyCoords because an exception will be thrown.
-      // We still return (0, 0) to ensure the cancel event is dispatched.
-      return sChildCoords;
-    }
-    mRootViewGroup.offsetDescendantRectToMyCoords(childView, sChildCoords);
-    return sChildCoords;
-  }
-
-  // Returns a copy of `original` with coordinates zeroed relative to the provided root coordinates.
-  // In particular,
-  // - the event (client) coordinates will all be set to 0
-  // - the offset coordinates will be set to the root coordinates
-  private PointerEventState normalizeToRoot(PointerEventState original, float rootX, float rootY) {
-    Map<Integer, float[]> newOffsets = new HashMap<>(original.getOffsetByPointerId());
-    Map<Integer, float[]> newEventCoords = new HashMap<>(original.getEventCoordinatesByPointerId());
-    Map<Integer, float[]> newScreenCoords =
-        new HashMap<>(original.getScreenCoordinatesByPointerId());
-
-    float[] rootOffset = {rootX, rootY};
-    for (Map.Entry<Integer, float[]> offsetEntry : newOffsets.entrySet()) {
-      offsetEntry.setValue(rootOffset);
-    }
-
-    float[] zeroOffset = {0, 0};
-    for (Map.Entry<Integer, float[]> eventCoordsEntry : newEventCoords.entrySet()) {
-      eventCoordsEntry.setValue(zeroOffset);
-    }
-
-    float[] screenCoords = eventCoordsToScreenCoords(rootOffset);
-    for (Map.Entry<Integer, float[]> screenCoordsEntry : newScreenCoords.entrySet()) {
-      screenCoordsEntry.setValue(screenCoords);
-    }
-
-    return new PointerEventState(
-        original.getPrimaryPointerId(),
-        original.getActivePointerId(),
-        original.getLastButtonState(),
-        original.getSurfaceId(),
-        newOffsets,
-        new HashMap<>(original.getHitPathByPointerId()),
-        newEventCoords,
-        newScreenCoords,
-        new HashSet<>(original.getHoveringPointerIds()));
-  }
-
-  private static void debugPrintHitPath(List<ViewTarget> hitPath) {
-    StringBuilder builder = new StringBuilder("hitPath: ");
-    for (ViewTarget viewTarget : hitPath) {
-      builder.append(String.format("%d, ", viewTarget.getViewId()));
-    }
-
-    FLog.d(TAG, builder.toString());
-  }
-}