react-native-gesture-handler 2.6.2 → 2.7.0

package/android/build.gradle

@@ -212,14 +212,6 @@ dependencies {
 }
 
 if (isNewArchitectureEnabled()) {
-    react {
-        reactNativeDir = rootProject.file(findNodeModulePath(rootProject.rootDir, "react-native") ?: "../node_modules/react-native/")
-        jsRootDir = file("../src/fabric/")
-        codegenDir = rootProject.file(findNodeModulePath(rootProject.rootDir, "react-native-codegen") ?: "../node_modules/react-native-codegen/")
-        libraryName = "rngesturehandler"
-        codegenJavaPackageName = "com.swmansion.gesturehandler"
-    }
-
     // Resolves "LOCAL_SRC_FILES points to a missing file, Check that libfb.so exists or that its path is correct".
     tasks.whenTaskAdded { task ->
         if (task.name.contains("configureCMakeDebug")) {

package/android/gradle.properties

@@ -16,4 +16,4 @@ org.gradle.jvmargs=-Xmx2048m -XX:MaxPermSize=512m -XX:+HeapDumpOnOutOfMemoryErro
 # This option should only be used with decoupled projects. More details, visit
 # http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects
 # org.gradle.parallel=true
-RNGH_kotlinVersion=1.5.20
+RNGH_kotlinVersion=1.6.21

package/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)
       }
     }
   }

package/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()
     }
   }
 
@@ -585,11 +589,11 @@ open class GestureHandler<ConcreteGestureHandlerT : GestureHandler<ConcreteGestu
     var top = 0f
     var right = view!!.width.toFloat()
     var bottom = view.height.toFloat()
-    if (hitSlop != null) {
-      val padLeft = hitSlop!![HIT_SLOP_LEFT_IDX]
-      val padTop = hitSlop!![HIT_SLOP_TOP_IDX]
-      val padRight = hitSlop!![HIT_SLOP_RIGHT_IDX]
-      val padBottom = hitSlop!![HIT_SLOP_BOTTOM_IDX]
+    hitSlop?.let { hitSlop ->
+      val padLeft = hitSlop[HIT_SLOP_LEFT_IDX]
+      val padTop = hitSlop[HIT_SLOP_TOP_IDX]
+      val padRight = hitSlop[HIT_SLOP_RIGHT_IDX]
+      val padBottom = hitSlop[HIT_SLOP_BOTTOM_IDX]
       if (hitSlopSet(padLeft)) {
         left -= padLeft
       }
@@ -602,8 +606,8 @@ open class GestureHandler<ConcreteGestureHandlerT : GestureHandler<ConcreteGestu
       if (hitSlopSet(padBottom)) {
         bottom += padBottom
       }
-      val width = hitSlop!![HIT_SLOP_WIDTH_IDX]
-      val height = hitSlop!![HIT_SLOP_HEIGHT_IDX]
+      val width = hitSlop[HIT_SLOP_WIDTH_IDX]
+      val height = hitSlop[HIT_SLOP_HEIGHT_IDX]
       if (hitSlopSet(width)) {
         if (!hitSlopSet(padLeft)) {
           left = right - width
@@ -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

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

@@ -242,7 +242,7 @@ class GestureHandlerOrchestrator(
     }
   }
 
-  private fun deliverEventToGestureHandler(handler: GestureHandler<*>, event: MotionEvent) {
+  private fun deliverEventToGestureHandler(handler: GestureHandler<*>, sourceEvent: MotionEvent) {
     if (!isViewAttachedUnderWrapper(handler.view)) {
       handler.cancel()
       return
@@ -250,18 +250,9 @@ class GestureHandlerOrchestrator(
     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,

package/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)
     }
   }
 }

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

@@ -37,13 +37,13 @@ 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)
@@ -51,7 +51,7 @@ class LongPressGestureHandler(context: Context) : GestureHandler<LongPressGestur
         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) {

package/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()
     }

package/android/lib/src/main/java/com/swmansion/gesturehandler/NativeViewGestureHandler.kt

@@ -75,7 +75,7 @@ class NativeViewGestureHandler : GestureHandler<NativeViewGestureHandler>() {
     }
   }
 
-  override fun onHandle(event: MotionEvent) {
+  override fun onHandle(event: MotionEvent, sourceEvent: MotionEvent) {
     val view = view!!
     if (event.actionMasked == MotionEvent.ACTION_UP) {
       view.onTouchEvent(event)

package/android/lib/src/main/java/com/swmansion/gesturehandler/PanGestureHandler.kt

@@ -205,31 +205,31 @@ class PanGestureHandler(context: Context?) : GestureHandler<PanGestureHandler>()
     return failOffsetYEnd != MIN_VALUE_IGNORE && dy > failOffsetYEnd
   }
 
-  override fun onHandle(event: MotionEvent) {
+  override fun onHandle(event: MotionEvent, sourceEvent: MotionEvent) {
     val state = state
-    val action = event.actionMasked
+    val action = sourceEvent.actionMasked
     if (action == MotionEvent.ACTION_POINTER_UP || action == MotionEvent.ACTION_POINTER_DOWN) {
       // update offset if new pointer gets added or removed
       offsetX += lastX - startX
       offsetY += lastY - startY
 
       // reset starting point
-      lastX = getLastPointerX(event, averageTouches)
-      lastY = getLastPointerY(event, averageTouches)
+      lastX = getLastPointerX(sourceEvent, averageTouches)
+      lastY = getLastPointerY(sourceEvent, averageTouches)
       startX = lastX
       startY = lastY
     } else {
-      lastX = getLastPointerX(event, averageTouches)
-      lastY = getLastPointerY(event, averageTouches)
+      lastX = getLastPointerX(sourceEvent, averageTouches)
+      lastY = getLastPointerY(sourceEvent, averageTouches)
     }
-    if (state == STATE_UNDETERMINED && event.pointerCount >= minPointers) {
+    if (state == STATE_UNDETERMINED && sourceEvent.pointerCount >= minPointers) {
       resetProgress()
       offsetX = 0f
       offsetY = 0f
       velocityX = 0f
       velocityY = 0f
       velocityTracker = VelocityTracker.obtain()
-      addVelocityMovement(velocityTracker, event)
+      addVelocityMovement(velocityTracker, sourceEvent)
       begin()
 
       if (activateAfterLongPress > 0) {
@@ -239,7 +239,7 @@ class PanGestureHandler(context: Context?) : GestureHandler<PanGestureHandler>()
         handler!!.postDelayed(activateDelayed, activateAfterLongPress)
       }
     } else if (velocityTracker != null) {
-      addVelocityMovement(velocityTracker, event)
+      addVelocityMovement(velocityTracker, sourceEvent)
       velocityTracker!!.computeCurrentVelocity(1000)
       velocityX = velocityTracker!!.xVelocity
       velocityY = velocityTracker!!.yVelocity
@@ -250,14 +250,14 @@ class PanGestureHandler(context: Context?) : GestureHandler<PanGestureHandler>()
       } else {
         fail()
       }
-    } else if (action == MotionEvent.ACTION_POINTER_DOWN && event.pointerCount > maxPointers) {
+    } else if (action == MotionEvent.ACTION_POINTER_DOWN && sourceEvent.pointerCount > maxPointers) {
       // When new finger is placed down (POINTER_DOWN) we check if MAX_POINTERS is not exceeded
       if (state == STATE_ACTIVE) {
         cancel()
       } else {
         fail()
       }
-    } else if (action == MotionEvent.ACTION_POINTER_UP && state == STATE_ACTIVE && event.pointerCount < minPointers) {
+    } else if (action == MotionEvent.ACTION_POINTER_UP && state == STATE_ACTIVE && sourceEvent.pointerCount < minPointers) {
       // When finger is lifted up (POINTER_UP) and the number of pointers falls below MIN_POINTERS
       // threshold, we only want to take an action when the handler has already activated. Otherwise
       // we can still expect more fingers to be placed on screen and fulfill MIN_POINTERS criteria.

package/android/lib/src/main/java/com/swmansion/gesturehandler/PinchGestureHandler.kt

@@ -1,5 +1,6 @@
 package com.swmansion.gesturehandler
 
+import android.graphics.PointF
 import android.view.MotionEvent
 import android.view.ViewConfiguration
 import kotlin.math.abs
@@ -9,10 +10,10 @@ class PinchGestureHandler : GestureHandler<PinchGestureHandler>() {
     private set
   var velocity = 0.0
     private set
-  val focalPointX: Float
-    get() = scaleGestureDetector?.focusX ?: Float.NaN
-  val focalPointY: Float
-    get() = scaleGestureDetector?.focusY ?: Float.NaN
+  var focalPointX: Float = Float.NaN
+    private set
+  var focalPointY: Float = Float.NaN
+    private set
 
   private var scaleGestureDetector: ScaleGestureDetector? = null
   private var startingSpan = 0f
@@ -47,7 +48,7 @@ class PinchGestureHandler : GestureHandler<PinchGestureHandler>() {
     }
   }
 
-  override fun onHandle(event: MotionEvent) {
+  override fun onHandle(event: MotionEvent, sourceEvent: MotionEvent) {
     if (state == STATE_UNDETERMINED) {
       val context = view!!.context
       resetProgress()
@@ -56,14 +57,19 @@ class PinchGestureHandler : GestureHandler<PinchGestureHandler>() {
       spanSlop = configuration.scaledTouchSlop.toFloat()
       begin()
     }
-    scaleGestureDetector?.onTouchEvent(event)
-    var activePointers = event.pointerCount
-    if (event.actionMasked == MotionEvent.ACTION_POINTER_UP) {
+    scaleGestureDetector?.onTouchEvent(sourceEvent)
+    scaleGestureDetector?.let {
+      val point = transformPoint(PointF(it.focusX, it.focusY))
+      this.focalPointX = point.x
+      this.focalPointY = point.y
+    }
+    var activePointers = sourceEvent.pointerCount
+    if (sourceEvent.actionMasked == MotionEvent.ACTION_POINTER_UP) {
       activePointers -= 1
     }
     if (state == STATE_ACTIVE && activePointers < 2) {
       end()
-    } else if (event.actionMasked == MotionEvent.ACTION_UP) {
+    } else if (sourceEvent.actionMasked == MotionEvent.ACTION_UP) {
       fail()
     }
   }
@@ -78,6 +84,8 @@ class PinchGestureHandler : GestureHandler<PinchGestureHandler>() {
 
   override fun onReset() {
     scaleGestureDetector = null
+    focalPointX = Float.NaN
+    focalPointY = Float.NaN
     resetProgress()
   }
 

package/android/lib/src/main/java/com/swmansion/gesturehandler/RotationGestureHandler.kt

@@ -1,5 +1,6 @@
 package com.swmansion.gesturehandler
 
+import android.graphics.PointF
 import android.view.MotionEvent
 import com.swmansion.gesturehandler.RotationGestureDetector.OnRotationGestureListener
 import kotlin.math.abs
@@ -10,11 +11,10 @@ class RotationGestureHandler : GestureHandler<RotationGestureHandler>() {
     private set
   var velocity = 0.0
     private set
-
-  val anchorX: Float
-    get() = rotationGestureDetector?.anchorX ?: Float.NaN
-  val anchorY: Float
-    get() = rotationGestureDetector?.anchorY ?: Float.NaN
+  var anchorX: Float = Float.NaN
+    private set
+  var anchorY: Float = Float.NaN
+    private set
 
   init {
     setShouldCancelWhenOutside(false)
@@ -41,14 +41,19 @@ class RotationGestureHandler : GestureHandler<RotationGestureHandler>() {
     }
   }
 
-  override fun onHandle(event: MotionEvent) {
+  override fun onHandle(event: MotionEvent, sourceEvent: MotionEvent) {
     if (state == STATE_UNDETERMINED) {
       resetProgress()
       rotationGestureDetector = RotationGestureDetector(gestureListener)
       begin()
     }
-    rotationGestureDetector?.onTouchEvent(event)
-    if (event.actionMasked == MotionEvent.ACTION_UP) {
+    rotationGestureDetector?.onTouchEvent(sourceEvent)
+    rotationGestureDetector?.let {
+      val point = transformPoint(PointF(it.anchorX, it.anchorY))
+      anchorX = point.x
+      anchorY = point.y
+    }
+    if (sourceEvent.actionMasked == MotionEvent.ACTION_UP) {
       if (state == STATE_ACTIVE) {
         end()
       } else {
@@ -67,6 +72,8 @@ class RotationGestureHandler : GestureHandler<RotationGestureHandler>() {
 
   override fun onReset() {
     rotationGestureDetector = null
+    anchorX = Float.NaN
+    anchorY = Float.NaN
     resetProgress()
   }