PointerEvents: Refactor JSPointerDispatcher to share logic for UP/DOWN for secondary pointers

Summary:
Changelog: [Internal] -  Refactor JSPointerDispatcher to group secondary actions (pointer_up, pointer_down) to use same logic and emit non-direct events

This diff re-arranges some code and re-uses some logic for different MotionEvent types.

Specifically, before our code for handling a motionEvent looked like
```
func onMotionEvent(event) {
    if (event is HOVER_MOVE) {
        handleHoverEvent(event)
    }
    if (event is ACTION_DOWN) {
       // logic for dispatching down, enter, over
    }
    if (event is ACTION_POINTER_DOWN) { // this represents any secondary pointer going down
       // logic for dispatching down
    }
    if (event is ACTION_MOVE) {
       // logic for dispatching touch move
    }
    if (event is ACTION_UP) {
       // logic for dispatching up, out, leave
    }
    if (event is ACTION_POINTER_UP) { // this represents any secondary pointer going up
       // logic for dispatching up
    }
   ....
}
```

now, we've refactored it to be like:
```
func onMotionEvent(event) {
    if (event is HOVER_MOVE) { // Still keep this as separate because it does some special things. Will refactor in follow-up diff
        handleHoverEvent(event)
    }

    switch() {
         case ACTION_DOWN or ACTION_POINTER_DOWN:
             // do same logic
         break;
         case ACTION_UP or ACTION_POINTER_UP:
             // do same logic
         break;
         case ACTION_MOVE:
             // do same logic, we will want to converge this logic with HOVER_MOVE, todo in a follow-up
         break;
         ...
    }
   ....
}
```
This refactor adds the functionality of `enter, over, out, leave` to secondary pointer events in which they weren't fired before.

Reviewed By: vincentriemer

Differential Revision: D39142820

fbshipit-source-id: 8b89db6dc22f24583f8c14dbb8392d4dc8ff6e4d

Author: Luna Wei

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

@@ -74,224 +74,204 @@ public void onChildEndedNativeGesture() {
     mChildHandlingNativeGesture = -1;
   }
 
-  public void handleMotionEvent(MotionEvent motionEvent, EventDispatcher eventDispatcher) {
-    int action = motionEvent.getActionMasked();
-
-    // Ignore hover enter/exit because we determine this ourselves
-    if (action == MotionEvent.ACTION_HOVER_EXIT || action == MotionEvent.ACTION_HOVER_ENTER) {
-      return;
+  private void onUp(
+      int activeTargetTag,
+      List<ViewTarget> hitPath,
+      int surfaceId,
+      MotionEvent motionEvent,
+      EventDispatcher eventDispatcher) {
+    if (motionEvent.getActionMasked() == MotionEvent.ACTION_UP) {
+      // End of a "down" coalescing key
+      mTouchEventCoalescingKeyHelper.removeCoalescingKey(mDownStartTime);
+      mDownStartTime = TouchEvent.UNSET;
+    } else {
+      mTouchEventCoalescingKeyHelper.incrementCoalescingKey(mDownStartTime);
     }
 
     boolean supportsHover = PointerEventHelper.supportsHover(motionEvent);
-    int surfaceId = UIManagerHelper.getSurfaceId(mRootViewGroup);
-
-    // Only relevant for POINTER_UP/POINTER_DOWN actions, otherwise 0
-    int actionIndex = motionEvent.getActionIndex();
-
-    List<ViewTarget> hitPath =
-        TouchTargetHelper.findTargetPathAndCoordinatesForTouch(
-            motionEvent.getX(actionIndex),
-            motionEvent.getY(actionIndex),
-            mRootViewGroup,
-            mTargetCoordinates);
-
-    if (hitPath.isEmpty()) {
-      return;
-    }
-
-    TouchTargetHelper.ViewTarget activeViewTarget = hitPath.get(0);
-    int activeTargetTag = activeViewTarget.getViewId();
-
-    if (action == MotionEvent.ACTION_HOVER_MOVE) {
-      handleHoverEvent(motionEvent, eventDispatcher, surfaceId, hitPath);
-      return;
+    boolean listeningForUp = isAnyoneListeningForBubblingEvent(hitPath, EVENT.UP, EVENT.UP_CAPTURE);
+    if (listeningForUp) {
+      eventDispatcher.dispatchEvent(
+          PointerEvent.obtain(
+              PointerEventHelper.POINTER_UP,
+              surfaceId,
+              activeTargetTag,
+              motionEvent,
+              mTargetCoordinates,
+              mPrimaryPointerId));
     }
 
-    // First down pointer
-    if (action == MotionEvent.ACTION_DOWN) {
-      mPrimaryPointerId = motionEvent.getPointerId(actionIndex);
-
-      // Start a "down" coalescing key
-      mDownStartTime = motionEvent.getEventTime();
-      mTouchEventCoalescingKeyHelper.addCoalescingKey(mDownStartTime);
-
-      if (!supportsHover) {
-        // Indirect OVER event dispatches before ENTER
-        boolean listeningForOver =
-            isAnyoneListeningForBubblingEvent(hitPath, EVENT.OVER, EVENT.OVER_CAPTURE);
-        if (listeningForOver) {
-          eventDispatcher.dispatchEvent(
-              PointerEvent.obtain(
-                  PointerEventHelper.POINTER_OVER,
-                  surfaceId,
-                  activeTargetTag,
-                  motionEvent,
-                  mTargetCoordinates,
-                  mPrimaryPointerId));
-        }
-
-        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) {
+    if (!supportsHover) {
+      boolean listeningForOut =
+          isAnyoneListeningForBubblingEvent(hitPath, EVENT.OUT, EVENT.OUT_CAPTURE);
+      if (listeningForOut) {
         eventDispatcher.dispatchEvent(
             PointerEvent.obtain(
-                PointerEventHelper.POINTER_DOWN,
+                PointerEventHelper.POINTER_OUT,
                 surfaceId,
                 activeTargetTag,
                 motionEvent,
                 mTargetCoordinates,
                 mPrimaryPointerId));
       }
 
-      return;
+      List<ViewTarget> leaveViewTargets =
+          filterByShouldDispatch(hitPath, EVENT.LEAVE, EVENT.LEAVE_CAPTURE, false);
+
+      // target -> root
+      dispatchEventForViewTargets(
+          PointerEventHelper.POINTER_LEAVE,
+          leaveViewTargets,
+          eventDispatcher,
+          surfaceId,
+          motionEvent);
     }
 
-    // If the touch was intercepted by a child, we've already sent a cancel event to JS for this
-    // gesture, so we shouldn't send any more pointer events related to it.
-    if (mChildHandlingNativeGesture != -1) {
-      return;
+    if (motionEvent.getActionMasked() == MotionEvent.ACTION_UP) {
+      mPrimaryPointerId = UNSET_POINTER_ID;
     }
+    return;
+  }
 
-    // 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);
+  private void onDown(
+      int activeTargetTag,
+      List<ViewTarget> hitPath,
+      int surfaceId,
+      MotionEvent motionEvent,
+      EventDispatcher eventDispatcher) {
 
-      // TODO(luwe) We need to fire indirect over,enter events for secondary pointers
+    if (motionEvent.getActionMasked() == MotionEvent.ACTION_DOWN) {
+      mPrimaryPointerId = motionEvent.getPointerId(0);
+      mDownStartTime = motionEvent.getEventTime();
+      mTouchEventCoalescingKeyHelper.addCoalescingKey(mDownStartTime);
+    } else {
+      mTouchEventCoalescingKeyHelper.incrementCoalescingKey(mDownStartTime);
+    }
 
-      boolean listeningForDown =
-          isAnyoneListeningForBubblingEvent(hitPath, EVENT.DOWN, EVENT.DOWN_CAPTURE);
-      if (listeningForDown) {
+    boolean supportsHover = PointerEventHelper.supportsHover(motionEvent);
+    if (!supportsHover) {
+      // Indirect OVER event dispatches before ENTER
+      boolean listeningForOver =
+          isAnyoneListeningForBubblingEvent(hitPath, EVENT.OVER, EVENT.OVER_CAPTURE);
+      if (listeningForOver) {
         eventDispatcher.dispatchEvent(
             PointerEvent.obtain(
-                PointerEventHelper.POINTER_DOWN,
+                PointerEventHelper.POINTER_OVER,
                 surfaceId,
                 activeTargetTag,
                 motionEvent,
                 mTargetCoordinates,
                 mPrimaryPointerId));
       }
 
-      return;
+      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);
     }
 
-    if (action == MotionEvent.ACTION_MOVE) {
-      int coalescingKey = mTouchEventCoalescingKeyHelper.getCoalescingKey(mDownStartTime);
+    boolean listeningForDown =
+        isAnyoneListeningForBubblingEvent(hitPath, EVENT.DOWN, EVENT.DOWN_CAPTURE);
+    if (listeningForDown) {
+      eventDispatcher.dispatchEvent(
+          PointerEvent.obtain(
+              PointerEventHelper.POINTER_DOWN,
+              surfaceId,
+              activeTargetTag,
+              motionEvent,
+              mTargetCoordinates,
+              mPrimaryPointerId));
+    }
+  }
 
-      boolean listeningForMove =
-          isAnyoneListeningForBubblingEvent(hitPath, EVENT.MOVE, EVENT.MOVE_CAPTURE);
-      if (listeningForMove) {
-        eventDispatcher.dispatchEvent(
-            PointerEvent.obtain(
-                PointerEventHelper.POINTER_MOVE,
-                surfaceId,
-                activeTargetTag,
-                motionEvent,
-                mTargetCoordinates,
-                coalescingKey,
-                mPrimaryPointerId));
-      }
+  public void handleMotionEvent(MotionEvent motionEvent, EventDispatcher eventDispatcher) {
+    int action = motionEvent.getActionMasked();
 
+    // Ignore hover enter/exit because we determine this ourselves
+    if (action == MotionEvent.ACTION_HOVER_EXIT || action == MotionEvent.ACTION_HOVER_ENTER) {
       return;
     }
 
-    // Exactly one of the pointers goes up, not the last one
-    if (action == MotionEvent.ACTION_POINTER_UP) {
-      mTouchEventCoalescingKeyHelper.incrementCoalescingKey(mDownStartTime);
+    boolean supportsHover = PointerEventHelper.supportsHover(motionEvent);
+    int surfaceId = UIManagerHelper.getSurfaceId(mRootViewGroup);
 
-      // TODO(luwe) We need to fire indirect out,leave events for secondary pointers
+    // Only relevant for POINTER_UP/POINTER_DOWN actions, otherwise 0
+    int actionIndex = motionEvent.getActionIndex();
 
-      boolean listeningForUp =
-          isAnyoneListeningForBubblingEvent(hitPath, EVENT.UP, EVENT.UP_CAPTURE);
-      if (listeningForUp) {
-        eventDispatcher.dispatchEvent(
-            PointerEvent.obtain(
-                PointerEventHelper.POINTER_UP,
-                surfaceId,
-                activeTargetTag,
-                motionEvent,
-                mTargetCoordinates,
-                mPrimaryPointerId));
-      }
+    List<ViewTarget> hitPath =
+        TouchTargetHelper.findTargetPathAndCoordinatesForTouch(
+            motionEvent.getX(actionIndex),
+            motionEvent.getY(actionIndex),
+            mRootViewGroup,
+            mTargetCoordinates);
 
+    if (hitPath.isEmpty()) {
       return;
     }
 
-    // Last pointer comes up
-    if (action == MotionEvent.ACTION_UP) {
+    TouchTargetHelper.ViewTarget activeViewTarget = hitPath.get(0);
+    int activeTargetTag = activeViewTarget.getViewId();
 
-      // End of a "down" coalescing key
-      mTouchEventCoalescingKeyHelper.removeCoalescingKey(mDownStartTime);
-      mDownStartTime = TouchEvent.UNSET;
+    if (action == MotionEvent.ACTION_HOVER_MOVE) {
+      onMove(motionEvent, eventDispatcher, surfaceId, hitPath);
+      return;
+    }
 
-      boolean listeningForUp =
-          isAnyoneListeningForBubblingEvent(hitPath, EVENT.UP, EVENT.UP_CAPTURE);
-      if (listeningForUp) {
-        eventDispatcher.dispatchEvent(
-            PointerEvent.obtain(
-                PointerEventHelper.POINTER_UP,
-                surfaceId,
-                activeTargetTag,
-                motionEvent,
-                mTargetCoordinates,
-                mPrimaryPointerId));
-      }
+    // TODO(luwe) - Update this to properly handle native gesture handling for non-hover move events
+    // If the touch was intercepted by a child, we've already sent a cancel event to JS for this
+    // gesture, so we shouldn't send any more pointer events related to it.
+    if (mChildHandlingNativeGesture != -1) {
+      return;
+    }
 
-      if (!supportsHover) {
-        boolean listeningForOut =
-            isAnyoneListeningForBubblingEvent(hitPath, EVENT.OUT, EVENT.OUT_CAPTURE);
-        if (listeningForOut) {
+    switch (action) {
+      case MotionEvent.ACTION_DOWN:
+      case MotionEvent.ACTION_POINTER_DOWN:
+        onDown(activeTargetTag, hitPath, surfaceId, motionEvent, eventDispatcher);
+        break;
+      case MotionEvent.ACTION_MOVE:
+        // TODO(luwe) - converge this with ACTION_HOVER_MOVE
+        int coalescingKey = mTouchEventCoalescingKeyHelper.getCoalescingKey(mDownStartTime);
+
+        boolean listeningForMove =
+            isAnyoneListeningForBubblingEvent(hitPath, EVENT.MOVE, EVENT.MOVE_CAPTURE);
+        if (listeningForMove) {
           eventDispatcher.dispatchEvent(
               PointerEvent.obtain(
-                  PointerEventHelper.POINTER_OUT,
+                  PointerEventHelper.POINTER_MOVE,
                   surfaceId,
                   activeTargetTag,
                   motionEvent,
                   mTargetCoordinates,
+                  coalescingKey,
                   mPrimaryPointerId));
         }
-
-        List<ViewTarget> leaveViewTargets =
-            filterByShouldDispatch(hitPath, EVENT.LEAVE, EVENT.LEAVE_CAPTURE, false);
-
-        // target -> root
-        dispatchEventForViewTargets(
-            PointerEventHelper.POINTER_LEAVE,
-            leaveViewTargets,
-            eventDispatcher,
-            surfaceId,
-            motionEvent);
-      }
-
-      mPrimaryPointerId = UNSET_POINTER_ID;
-      return;
+        break;
+      case MotionEvent.ACTION_UP:
+      case MotionEvent.ACTION_POINTER_UP:
+        onUp(activeTargetTag, hitPath, surfaceId, motionEvent, eventDispatcher);
+        break;
+      case MotionEvent.ACTION_CANCEL:
+        dispatchCancelEvent(hitPath, motionEvent, eventDispatcher);
+        break;
+      default:
+        FLog.w(
+            ReactConstants.TAG,
+            "Warning : Motion Event was ignored. Action="
+                + action
+                + " Target="
+                + activeTargetTag
+                + " Supports Hover="
+                + supportsHover);
+        return;
     }
-
-    if (action == MotionEvent.ACTION_CANCEL) {
-      dispatchCancelEvent(hitPath, motionEvent, eventDispatcher);
-      return;
-    }
-
-    FLog.w(
-        ReactConstants.TAG,
-        "Warning : Motion Event was ignored. Action="
-            + action
-            + " Target="
-            + activeTargetTag
-            + " Supports Hover="
-            + supportsHover);
   }
 
   private static boolean isAnyoneListeningForBubblingEvent(
@@ -356,7 +336,7 @@ private void dispatchEventForViewTargets(
   }
 
   // called on hover_move motion events only
-  private void handleHoverEvent(
+  private void onMove(
       MotionEvent motionEvent,
       EventDispatcher eventDispatcher,
       int surfaceId,