Transform entire MotionEvent instead of single pointer only (#2156)

## Description

Gesture Handler on Android intercepts events via the
`GestureHandlerRootView`, which means that we need to transform the
touch coordinated by ourselves to check if it's inside the view.
Similarly, we need to transform the event when dispatching it to one of
the gesture handlers in order to correctly calculate the changes and
send touch events.

The current method works well until there is more than one pointer at
once on the screen. When there is more than one pointer, only the first
one will be correctly transformed, while others will simply be moved by
the offset calculated when transforming the first pointer.

This PR changes the logic when delivering events to gesture handlers -
the whole event is transformed, and handlers receive both events -
transformed and untransformed one. This way things like touch events and
`NativeViewGestureHandler` which rely on the location in the coordinate
space of the view keep working, and other gestures get to work in the
coordinate space of the root view.

Fixes
#2138.

## Test plan

Tested on the Example app.

Author: j-piasecki

android/lib/src/main/java/com/swmansion/gesturehandler/FlingGestureHandler.kt

@@ -63,19 +63,19 @@ class FlingGestureHandler : GestureHandler<FlingGestureHandler>() {
     }
   }
 
-  override fun onHandle(event: MotionEvent) {
+  override fun onHandle(event: MotionEvent, sourceEvent: MotionEvent) {
     val state = state
     if (state == STATE_UNDETERMINED) {
-      startFling(event)
+      startFling(sourceEvent)
     }
     if (state == STATE_BEGAN) {
-      tryEndFling(event)
-      if (event.pointerCount > maxNumberOfPointersSimultaneously) {
-        maxNumberOfPointersSimultaneously = event.pointerCount
+      tryEndFling(sourceEvent)
+      if (sourceEvent.pointerCount > maxNumberOfPointersSimultaneously) {
+        maxNumberOfPointersSimultaneously = sourceEvent.pointerCount
       }
-      val action = event.actionMasked
+      val action = sourceEvent.actionMasked
       if (action == MotionEvent.ACTION_UP) {
-        endFling(event)
+        endFling(sourceEvent)
       }
     }
   }

android/lib/src/main/java/com/swmansion/gesturehandler/GestureHandler.kt

@@ -3,6 +3,7 @@ package com.swmansion.gesturehandler
 import android.app.Activity
 import android.content.Context
 import android.content.ContextWrapper
+import android.graphics.PointF
 import android.graphics.Rect
 import android.view.MotionEvent
 import android.view.MotionEvent.PointerCoords
@@ -325,7 +326,7 @@ open class GestureHandler<ConcreteGestureHandlerT : GestureHandler<ConcreteGestu
     while handling event: $event
   """.trimIndent(), e) {}
 
-  fun handle(origEvent: MotionEvent) {
+  fun handle(transformedEvent: MotionEvent, sourceEvent: MotionEvent) {
     if (!isEnabled
       || state == STATE_CANCELLED
       || state == STATE_FAILED
@@ -335,20 +336,20 @@ open class GestureHandler<ConcreteGestureHandlerT : GestureHandler<ConcreteGestu
     }
 
     // a workaround for https://github.com/software-mansion/react-native-gesture-handler/issues/1188
-    val event = if (BuildConfig.DEBUG) {
-      adaptEvent(origEvent)
+    val (adaptedTransformedEvent, adaptedSourceEvent) = if (BuildConfig.DEBUG) {
+      arrayOf(adaptEvent(transformedEvent), adaptEvent(sourceEvent))
     } else {
       try {
-        adaptEvent(origEvent)
+        arrayOf(adaptEvent(transformedEvent), adaptEvent(sourceEvent))
       } catch (e: AdaptEventException) {
         fail()
         return
       }
     }
 
-    x = event.x
-    y = event.y
-    numberOfPointers = event.pointerCount
+    x = adaptedTransformedEvent.x
+    y = adaptedTransformedEvent.y
+    numberOfPointers = adaptedTransformedEvent.pointerCount
     isWithinBounds = isWithinBounds(view, x, y)
     if (shouldCancelWhenOutside && !isWithinBounds) {
       if (state == STATE_ACTIVE) {
@@ -358,13 +359,16 @@ open class GestureHandler<ConcreteGestureHandlerT : GestureHandler<ConcreteGestu
       }
       return
     }
-    lastAbsolutePositionX = GestureUtils.getLastPointerX(event, true)
-    lastAbsolutePositionY = GestureUtils.getLastPointerY(event, true)
-    lastEventOffsetX = event.rawX - event.x
-    lastEventOffsetY = event.rawY - event.y
-    onHandle(event)
-    if (event != origEvent) {
-      event.recycle()
+    lastAbsolutePositionX = GestureUtils.getLastPointerX(adaptedTransformedEvent, true)
+    lastAbsolutePositionY = GestureUtils.getLastPointerY(adaptedTransformedEvent, true)
+    lastEventOffsetX = adaptedTransformedEvent.rawX - adaptedTransformedEvent.x
+    lastEventOffsetY = adaptedTransformedEvent.rawY - adaptedTransformedEvent.y
+    onHandle(adaptedTransformedEvent, adaptedSourceEvent)
+    if (adaptedTransformedEvent != transformedEvent) {
+      adaptedTransformedEvent.recycle()
+    }
+    if (adaptedSourceEvent != sourceEvent) {
+      adaptedSourceEvent.recycle()
     }
   }
 
@@ -659,13 +663,29 @@ open class GestureHandler<ConcreteGestureHandlerT : GestureHandler<ConcreteGestu
   // if the handler is waiting for failure of other one)
   open fun resetProgress() {}
 
-  protected open fun onHandle(event: MotionEvent) {
+  protected open fun onHandle(event: MotionEvent, sourceEvent: MotionEvent) {
     moveToState(STATE_FAILED)
   }
 
   protected open fun onStateChange(newState: Int, previousState: Int) {}
   protected open fun onReset() {}
   protected open fun onCancel() {}
+
+  /**
+   * Transforms a point in the coordinate space of the wrapperView (GestureHandlerRootView) to
+   * coordinate space of the view the gesture is attached to.
+   *
+   * If the gesture handler is not currently attached to a view, it will return (NaN, NaN).
+   *
+   * This method modifies and transforms the received point.
+   */
+  protected fun transformPoint(point: PointF): PointF {
+    return orchestrator?.transformPointToViewCoords(this.view, point) ?: run {
+      point.x = Float.NaN
+      point.y = Float.NaN
+      point
+    }
+  }
   fun reset() {
     view = null
     orchestrator = null
@@ -689,14 +709,14 @@ open class GestureHandler<ConcreteGestureHandlerT : GestureHandler<ConcreteGestu
   }
 
   val lastRelativePositionX: Float
-    get() = lastAbsolutePositionX - lastEventOffsetX
+    get() = lastAbsolutePositionX
   val lastRelativePositionY: Float
-    get() = lastAbsolutePositionY - lastEventOffsetY
+    get() = lastAbsolutePositionY
 
   val lastPositionInWindowX: Float
-    get() = lastAbsolutePositionX - windowOffset[0]
+    get() = lastAbsolutePositionX + lastEventOffsetX - windowOffset[0]
   val lastPositionInWindowY: Float
-    get() = lastAbsolutePositionY - windowOffset[1]
+    get() = lastAbsolutePositionY + lastEventOffsetY - windowOffset[1]
 
   companion object {
     const val STATE_UNDETERMINED = 0

android/lib/src/main/java/com/swmansion/gesturehandler/GestureHandlerOrchestrator.kt

@@ -242,26 +242,17 @@ class GestureHandlerOrchestrator(
     }
   }
 
-  private fun deliverEventToGestureHandler(handler: GestureHandler<*>, event: MotionEvent) {
+  private fun deliverEventToGestureHandler(handler: GestureHandler<*>, sourceEvent: MotionEvent) {
     if (!isViewAttachedUnderWrapper(handler.view)) {
       handler.cancel()
       return
     }
     if (!handler.wantEvents()) {
       return
     }
-    val action = event.actionMasked
-    val coords = tempCoords
-    extractCoordsForView(handler.view, event, coords)
-    val oldX = event.x
-    val oldY = event.y
-    // TODO: we may consider scaling events if necessary using MotionEvent.transform
-    // for now the events are only offset to the top left corner of the view but if
-    // view or any ot the parents is scaled the other pointers position will not reflect
-    // their actual place in the view. On the other hand not scaling seems like a better
-    // approach when we want to use pointer coordinates to calculate velocity or distance
-    // for pinch so I don't know yet if we should transform or not...
-    event.setLocation(coords[0], coords[1])
+
+    val action = sourceEvent.actionMasked
+    val event = transformEventToViewCoords(handler.view, MotionEvent.obtain(sourceEvent))
 
     // Touch events are sent before the handler itself has a chance to process them,
     // mainly because `onTouchesUp` shoul be send befor gesture finishes. This means that
@@ -277,7 +268,7 @@ class GestureHandlerOrchestrator(
 
     if (!handler.isAwaiting || action != MotionEvent.ACTION_MOVE) {
       val isFirstEvent = handler.state == 0
-      handler.handle(event)
+      handler.handle(event, sourceEvent)
       if (handler.isActive) {
         // After handler is done waiting for other one to fail its progress should be
         // reset, otherwise there may be a visible jump in values sent by the handler.
@@ -305,7 +296,7 @@ class GestureHandlerOrchestrator(
       }
     }
 
-    event.setLocation(oldX, oldY)
+    event.recycle()
   }
 
   /**
@@ -329,19 +320,75 @@ class GestureHandlerOrchestrator(
     return parent === wrapperView
   }
 
-  private fun extractCoordsForView(view: View?, event: MotionEvent, outputCoords: FloatArray) {
-    if (view === wrapperView) {
-      outputCoords[0] = event.x
-      outputCoords[1] = event.y
-      return
+  /**
+   * Transforms an event in the coordinates of wrapperView into the coordinate space of the received view.
+   *
+   * This modifies and returns the same event as it receives
+   *
+   * @param view - view to which coordinate space the event should be transformed
+   * @param event - event to transform
+   */
+  fun transformEventToViewCoords(view: View?, event: MotionEvent): MotionEvent {
+    if (view == null) {
+      return event
     }
-    require(!(view == null || view.parent !is ViewGroup)) { "Parent is null? View is no longer in the tree" }
-    val parent = view.parent as ViewGroup
-    extractCoordsForView(parent, event, outputCoords)
-    val childPoint = tempPoint
-    transformTouchPointToViewCoords(outputCoords[0], outputCoords[1], parent, view, childPoint)
-    outputCoords[0] = childPoint.x
-    outputCoords[1] = childPoint.y
+
+    val parent = view.parent as? ViewGroup
+    // Events are passed down to the orchestrator by the wrapperView, so they are already in the
+    // relevant coordinate space. We want to stop traversing the tree when we reach it.
+    if (parent != wrapperView) {
+      transformEventToViewCoords(parent, event)
+    }
+
+    if (parent != null) {
+      val localX = event.x + parent.scrollX - view.left
+      val localY = event.y + parent.scrollY - view.top
+      event.setLocation(localX, localY)
+    }
+
+    if (!view.matrix.isIdentity) {
+      view.matrix.invert(inverseMatrix)
+      event.transform(inverseMatrix)
+    }
+
+    return event
+  }
+
+  /**
+   * Transforms a point in the coordinates of wrapperView into the coordinate space of the received view.
+   *
+   * This modifies and returns the same point as it receives
+   *
+   * @param view - view to which coordinate space the point should be transformed
+   * @param point - point to transform
+   */
+  fun transformPointToViewCoords(view: View?, point: PointF): PointF {
+    if (view == null) {
+      return point
+    }
+
+    val parent = view.parent as? ViewGroup
+    // Events are passed down to the orchestrator by the wrapperView, so they are already in the
+    // relevant coordinate space. We want to stop traversing the tree when we reach it.
+    if (parent != wrapperView) {
+      transformPointToViewCoords(parent, point)
+    }
+
+    if (parent != null) {
+      point.x += parent.scrollX - view.left
+      point.y += parent.scrollY - view.top
+    }
+
+    if (!view.matrix.isIdentity) {
+      view.matrix.invert(inverseMatrix)
+      tempCoords[0] = point.x
+      tempCoords[1] = point.y
+      inverseMatrix.mapPoints(tempCoords)
+      point.x = tempCoords[0]
+      point.y = tempCoords[1]
+    }
+
+    return point
   }
 
   private fun addAwaitingHandler(handler: GestureHandler<*>) {
@@ -451,7 +498,7 @@ class GestureHandlerOrchestrator(
       val child = viewConfigHelper.getChildInDrawingOrderAtIndex(viewGroup, i)
       if (canReceiveEvents(child)) {
         val childPoint = tempPoint
-        transformTouchPointToViewCoords(coords[0], coords[1], viewGroup, child, childPoint)
+        transformPointToChildViewCoords(coords[0], coords[1], viewGroup, child, childPoint)
         val restoreX = coords[0]
         val restoreY = coords[1]
         coords[0] = childPoint.x
@@ -564,7 +611,7 @@ class GestureHandlerOrchestrator(
       return isLeafOrTransparent && isTransformedTouchPointInView(coords[0], coords[1], view)
     }
 
-    private fun transformTouchPointToViewCoords(
+    private fun transformPointToChildViewCoords(
       x: Float,
       y: Float,
       parent: ViewGroup,

android/lib/src/main/java/com/swmansion/gesturehandler/GestureUtils.kt

@@ -4,14 +4,13 @@ import android.view.MotionEvent
 
 object GestureUtils {
   fun getLastPointerX(event: MotionEvent, averageTouches: Boolean): Float {
-    val offset = event.rawX - event.x
     val excludeIndex = if (event.actionMasked == MotionEvent.ACTION_POINTER_UP) event.actionIndex else -1
     return if (averageTouches) {
       var sum = 0f
       var count = 0
       for (i in 0 until event.pointerCount) {
         if (i != excludeIndex) {
-          sum += event.getX(i) + offset
+          sum += event.getX(i)
           count++
         }
       }
@@ -21,19 +20,18 @@ object GestureUtils {
       if (lastPointerIdx == excludeIndex) {
         lastPointerIdx--
       }
-      event.getX(lastPointerIdx) + offset
+      event.getX(lastPointerIdx)
     }
   }
 
   fun getLastPointerY(event: MotionEvent, averageTouches: Boolean): Float {
-    val offset = event.rawY - event.y
     val excludeIndex = if (event.actionMasked == MotionEvent.ACTION_POINTER_UP) event.actionIndex else -1
     return if (averageTouches) {
       var sum = 0f
       var count = 0
       for (i in 0 until event.pointerCount) {
         if (i != excludeIndex) {
-          sum += event.getY(i) + offset
+          sum += event.getY(i)
           count++
         }
       }
@@ -43,7 +41,7 @@ object GestureUtils {
       if (lastPointerIdx == excludeIndex) {
         lastPointerIdx -= 1
       }
-      event.getY(lastPointerIdx) + offset
+      event.getY(lastPointerIdx)
     }
   }
 }

android/lib/src/main/java/com/swmansion/gesturehandler/LongPressGestureHandler.kt

@@ -37,21 +37,21 @@ class LongPressGestureHandler(context: Context) : GestureHandler<LongPressGestur
     return this
   }
 
-  override fun onHandle(event: MotionEvent) {
+  override fun onHandle(event: MotionEvent, sourceEvent: MotionEvent) {
     if (state == STATE_UNDETERMINED) {
       previousTime = SystemClock.uptimeMillis()
       startTime = previousTime
       begin()
-      startX = event.rawX
-      startY = event.rawY
+      startX = sourceEvent.rawX
+      startY = sourceEvent.rawY
       handler = Handler(Looper.getMainLooper())
       if (minDurationMs > 0) {
         handler!!.postDelayed({ activate() }, minDurationMs)
       } else if (minDurationMs == 0L) {
         activate()
       }
     }
-    if (event.actionMasked == MotionEvent.ACTION_UP) {
+    if (sourceEvent.actionMasked == MotionEvent.ACTION_UP) {
       handler?.let {
         it.removeCallbacksAndMessages(null)
         handler = null
@@ -63,8 +63,8 @@ class LongPressGestureHandler(context: Context) : GestureHandler<LongPressGestur
       }
     } else {
       // calculate distance from start
-      val deltaX = event.rawX - startX
-      val deltaY = event.rawY - startY
+      val deltaX = sourceEvent.rawX - startX
+      val deltaY = sourceEvent.rawY - startY
       val distSq = deltaX * deltaX + deltaY * deltaY
       if (distSq > maxDistSq) {
         if (state == STATE_ACTIVE) {

android/lib/src/main/java/com/swmansion/gesturehandler/ManualGestureHandler.kt

@@ -3,7 +3,7 @@ package com.swmansion.gesturehandler
 import android.view.MotionEvent
 
 class ManualGestureHandler : GestureHandler<ManualGestureHandler>() {
-  override fun onHandle(event: MotionEvent) {
+  override fun onHandle(event: MotionEvent, sourceEvent: MotionEvent) {
     if (state == STATE_UNDETERMINED) {
       begin()
     }