@amazon-devices/react-native-gesture-handler 2.0.9000000000 → 4.0.0-rn-83

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

@@ -6,10 +6,13 @@ import android.os.Looper
 import android.view.MotionEvent
 import android.view.VelocityTracker
 import android.view.ViewConfiguration
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.uimanager.PixelUtil
 import com.swmansion.gesturehandler.core.GestureUtils.getLastPointerX
 import com.swmansion.gesturehandler.core.GestureUtils.getLastPointerY
+import com.swmansion.gesturehandler.react.eventbuilders.PanGestureHandlerEventDataBuilder
 
-class PanGestureHandler(context: Context?) : GestureHandler<PanGestureHandler>() {
+class PanGestureHandler(context: Context?) : GestureHandler() {
   var velocityX = 0f
     private set
   var velocityY = 0f
@@ -19,8 +22,8 @@ class PanGestureHandler(context: Context?) : GestureHandler<PanGestureHandler>()
   val translationY: Float
     get() = lastY - startY + offsetY
 
-  private val defaultMinDistSq: Float
-  private var minDistSq = MAX_VALUE_IGNORE
+  private val defaultMinDist: Float
+  private var minDist = MAX_VALUE_IGNORE
   private var activeOffsetXStart = MIN_VALUE_IGNORE
   private var activeOffsetXEnd = MAX_VALUE_IGNORE
   private var failOffsetXStart = MAX_VALUE_IGNORE
@@ -29,9 +32,13 @@ class PanGestureHandler(context: Context?) : GestureHandler<PanGestureHandler>()
   private var activeOffsetYEnd = MAX_VALUE_IGNORE
   private var failOffsetYStart = MAX_VALUE_IGNORE
   private var failOffsetYEnd = MIN_VALUE_IGNORE
+
+  /**
+   * in pixels per second
+   */
   private var minVelocityX = MIN_VALUE_IGNORE
   private var minVelocityY = MIN_VALUE_IGNORE
-  private var minVelocitySq = MIN_VALUE_IGNORE
+  private var minVelocity = MIN_VALUE_IGNORE
   private var minPointers = DEFAULT_MIN_POINTERS
   private var maxPointers = DEFAULT_MAX_POINTERS
   private var startX = 0f
@@ -45,6 +52,8 @@ class PanGestureHandler(context: Context?) : GestureHandler<PanGestureHandler>()
   private var activateAfterLongPress = DEFAULT_ACTIVATE_AFTER_LONG_PRESS
   private val activateDelayed = Runnable { activate() }
   private var handler: Handler? = null
+  var stylusData: StylusData = StylusData()
+    private set
 
   /**
    * On Android when there are multiple pointers on the screen pan gestures most often just consider
@@ -60,96 +69,28 @@ class PanGestureHandler(context: Context?) : GestureHandler<PanGestureHandler>()
    */
   init {
     val vc = ViewConfiguration.get(context!!)
-    val touchSlop = vc.scaledTouchSlop
-    defaultMinDistSq = (touchSlop * touchSlop).toFloat()
-    minDistSq = defaultMinDistSq
+    defaultMinDist = vc.scaledTouchSlop.toFloat()
+    minDist = defaultMinDist
   }
 
   override fun resetConfig() {
     super.resetConfig()
-    activeOffsetXStart = MIN_VALUE_IGNORE
-    activeOffsetXEnd = MAX_VALUE_IGNORE
-    failOffsetXStart = MAX_VALUE_IGNORE
-    failOffsetXEnd = MIN_VALUE_IGNORE
-    activeOffsetYStart = MIN_VALUE_IGNORE
-    activeOffsetYEnd = MAX_VALUE_IGNORE
-    failOffsetYStart = MAX_VALUE_IGNORE
-    failOffsetYEnd = MIN_VALUE_IGNORE
-    minVelocityX = MIN_VALUE_IGNORE
-    minVelocityY = MIN_VALUE_IGNORE
-    minVelocitySq = MIN_VALUE_IGNORE
-    minDistSq = defaultMinDistSq
+    activeOffsetXStart = DEFAULT_ACTIVE_OFFSET_X_START
+    activeOffsetXEnd = DEFAULT_ACTIVE_OFFSET_X_END
+    failOffsetXStart = DEFAULT_FAIL_OFFSET_X_START
+    failOffsetXEnd = DEFAULT_FAIL_OFFSET_X_END
+    activeOffsetYStart = DEFAULT_ACTIVE_OFFSET_Y_START
+    activeOffsetYEnd = DEFAULT_ACTIVE_OFFSET_Y_END
+    failOffsetYStart = DEFAULT_FAIL_OFFSET_Y_START
+    failOffsetYEnd = DEFAULT_FAIL_OFFSET_Y_END
+    minVelocityX = DEFAULT_MIN_VELOCITY_X
+    minVelocityY = DEFAULT_MIN_VELOCITY_Y
+    minVelocity = DEFAULT_MIN_VELOCITY
+    minDist = defaultMinDist
     minPointers = DEFAULT_MIN_POINTERS
     maxPointers = DEFAULT_MAX_POINTERS
     activateAfterLongPress = DEFAULT_ACTIVATE_AFTER_LONG_PRESS
-    averageTouches = false
-  }
-
-  fun setActiveOffsetXStart(activeOffsetXStart: Float) = apply {
-    this.activeOffsetXStart = activeOffsetXStart
-  }
-
-  fun setActiveOffsetXEnd(activeOffsetXEnd: Float) = apply {
-    this.activeOffsetXEnd = activeOffsetXEnd
-  }
-
-  fun setFailOffsetXStart(failOffsetXStart: Float) = apply {
-    this.failOffsetXStart = failOffsetXStart
-  }
-
-  fun setFailOffsetXEnd(failOffsetXEnd: Float) = apply {
-    this.failOffsetXEnd = failOffsetXEnd
-  }
-
-  fun setActiveOffsetYStart(activeOffsetYStart: Float) = apply {
-    this.activeOffsetYStart = activeOffsetYStart
-  }
-
-  fun setActiveOffsetYEnd(activeOffsetYEnd: Float) = apply {
-    this.activeOffsetYEnd = activeOffsetYEnd
-  }
-
-  fun setFailOffsetYStart(failOffsetYStart: Float) = apply {
-    this.failOffsetYStart = failOffsetYStart
-  }
-
-  fun setFailOffsetYEnd(failOffsetYEnd: Float) = apply {
-    this.failOffsetYEnd = failOffsetYEnd
-  }
-
-  fun setMinDist(minDist: Float) = apply {
-    minDistSq = minDist * minDist
-  }
-
-  fun setMinPointers(minPointers: Int) = apply {
-    this.minPointers = minPointers
-  }
-
-  fun setMaxPointers(maxPointers: Int) = apply {
-    this.maxPointers = maxPointers
-  }
-
-  fun setAverageTouches(averageTouches: Boolean) = apply {
-    this.averageTouches = averageTouches
-  }
-
-  fun setActivateAfterLongPress(time: Long) = apply {
-    this.activateAfterLongPress = time
-  }
-
-  /**
-   * @param minVelocity in pixels per second
-   */
-  fun setMinVelocity(minVelocity: Float) = apply {
-    minVelocitySq = minVelocity * minVelocity
-  }
-
-  fun setMinVelocityX(minVelocityX: Float) = apply {
-    this.minVelocityX = minVelocityX
-  }
-
-  fun setMinVelocityY(minVelocityY: Float) = apply {
-    this.minVelocityY = minVelocityY
+    averageTouches = DEFAULT_AVERAGE_TOUCHES
   }
 
   private fun shouldActivate(): Boolean {
@@ -168,7 +109,7 @@ class PanGestureHandler(context: Context?) : GestureHandler<PanGestureHandler>()
       return true
     }
     val distSq = dx * dx + dy * dy
-    if (minDistSq != MIN_VALUE_IGNORE && distSq >= minDistSq) {
+    if (minDist != MIN_VALUE_IGNORE && distSq >= minDist * minDist) {
       return true
     }
     val vx = velocityX
@@ -184,14 +125,14 @@ class PanGestureHandler(context: Context?) : GestureHandler<PanGestureHandler>()
       return true
     }
     val velocitySq = vx * vx + vy * vy
-    return minVelocitySq != MIN_VALUE_IGNORE && velocitySq >= minVelocitySq
+    return minVelocity != MIN_VALUE_IGNORE && velocitySq >= minVelocity * minVelocity
   }
 
   private fun shouldFail(): Boolean {
     val dx = lastX - startX + offsetX
     val dy = lastY - startY + offsetY
 
-    if (activateAfterLongPress > 0 && dx * dx + dy * dy > defaultMinDistSq) {
+    if (activateAfterLongPress > 0 && dx * dx + dy * dy > defaultMinDist * defaultMinDist) {
       handler?.removeCallbacksAndMessages(null)
       return true
     }
@@ -208,6 +149,14 @@ class PanGestureHandler(context: Context?) : GestureHandler<PanGestureHandler>()
   }
 
   override fun onHandle(event: MotionEvent, sourceEvent: MotionEvent) {
+    if (!shouldActivateWithMouse(sourceEvent)) {
+      return
+    }
+
+    if (event.getToolType(0) == MotionEvent.TOOL_TYPE_STYLUS) {
+      stylusData = StylusData.fromEvent(event)
+    }
+
     val state = state
     val action = sourceEvent.actionMasked
     if (action == MotionEvent.ACTION_POINTER_UP || action == MotionEvent.ACTION_POINTER_DOWN) {
@@ -246,20 +195,25 @@ class PanGestureHandler(context: Context?) : GestureHandler<PanGestureHandler>()
       velocityX = velocityTracker!!.xVelocity
       velocityY = velocityTracker!!.yVelocity
     }
-    if (action == MotionEvent.ACTION_UP) {
+    if (action == MotionEvent.ACTION_UP || action == MotionEvent.ACTION_BUTTON_RELEASE) {
       if (state == STATE_ACTIVE) {
         end()
       } else {
         fail()
       }
-    } else if (action == MotionEvent.ACTION_POINTER_DOWN && sourceEvent.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 && sourceEvent.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.
@@ -291,6 +245,8 @@ class PanGestureHandler(context: Context?) : GestureHandler<PanGestureHandler>()
       it.recycle()
       velocityTracker = null
     }
+
+    stylusData = StylusData()
   }
 
   override fun resetProgress() {
@@ -298,12 +254,163 @@ class PanGestureHandler(context: Context?) : GestureHandler<PanGestureHandler>()
     startY = lastY
   }
 
+  class Factory : GestureHandler.Factory<PanGestureHandler>() {
+    override val type = PanGestureHandler::class.java
+    override val name = "PanGestureHandler"
+
+    override fun create(context: Context?): PanGestureHandler = PanGestureHandler(context)
+
+    override fun setConfig(handler: PanGestureHandler, config: ReadableMap) {
+      super.setConfig(handler, config)
+      var hasCustomActivationCriteria = false
+      if (config.hasKey(KEY_ACTIVE_OFFSET_X_START)) {
+        handler.activeOffsetXStart =
+          PixelUtil.toPixelFromDIP(
+            config.getDouble(
+              KEY_ACTIVE_OFFSET_X_START,
+            ),
+          )
+        hasCustomActivationCriteria = true
+      }
+      if (config.hasKey(KEY_ACTIVE_OFFSET_X_END)) {
+        handler.activeOffsetXEnd =
+          PixelUtil.toPixelFromDIP(
+            config.getDouble(
+              KEY_ACTIVE_OFFSET_X_END,
+            ),
+          )
+        hasCustomActivationCriteria = true
+      }
+      if (config.hasKey(KEY_FAIL_OFFSET_RANGE_X_START)) {
+        handler.failOffsetXStart =
+          PixelUtil.toPixelFromDIP(
+            config.getDouble(
+              KEY_FAIL_OFFSET_RANGE_X_START,
+            ),
+          )
+        hasCustomActivationCriteria = true
+      }
+      if (config.hasKey(KEY_FAIL_OFFSET_RANGE_X_END)) {
+        handler.failOffsetXEnd =
+          PixelUtil.toPixelFromDIP(
+            config.getDouble(
+              KEY_FAIL_OFFSET_RANGE_X_END,
+            ),
+          )
+        hasCustomActivationCriteria = true
+      }
+      if (config.hasKey(KEY_ACTIVE_OFFSET_Y_START)) {
+        handler.activeOffsetYStart =
+          PixelUtil.toPixelFromDIP(
+            config.getDouble(
+              KEY_ACTIVE_OFFSET_Y_START,
+            ),
+          )
+        hasCustomActivationCriteria = true
+      }
+      if (config.hasKey(KEY_ACTIVE_OFFSET_Y_END)) {
+        handler.activeOffsetYEnd =
+          PixelUtil.toPixelFromDIP(
+            config.getDouble(
+              KEY_ACTIVE_OFFSET_Y_END,
+            ),
+          )
+        hasCustomActivationCriteria = true
+      }
+      if (config.hasKey(KEY_FAIL_OFFSET_RANGE_Y_START)) {
+        handler.failOffsetYStart =
+          PixelUtil.toPixelFromDIP(
+            config.getDouble(
+              KEY_FAIL_OFFSET_RANGE_Y_START,
+            ),
+          )
+        hasCustomActivationCriteria = true
+      }
+      if (config.hasKey(KEY_FAIL_OFFSET_RANGE_Y_END)) {
+        handler.failOffsetYEnd =
+          PixelUtil.toPixelFromDIP(
+            config.getDouble(
+              KEY_FAIL_OFFSET_RANGE_Y_END,
+            ),
+          )
+        hasCustomActivationCriteria = true
+      }
+      if (config.hasKey(KEY_MIN_VELOCITY)) {
+        // This value is actually in DPs/ms, but we can use the same function as for converting
+        // from DPs to pixels as the unit we're converting is in the numerator
+        handler.minVelocity = PixelUtil.toPixelFromDIP(config.getDouble(KEY_MIN_VELOCITY))
+        hasCustomActivationCriteria = true
+      }
+      if (config.hasKey(KEY_MIN_VELOCITY_X)) {
+        handler.minVelocityX = PixelUtil.toPixelFromDIP(config.getDouble(KEY_MIN_VELOCITY_X))
+        hasCustomActivationCriteria = true
+      }
+      if (config.hasKey(KEY_MIN_VELOCITY_Y)) {
+        handler.minVelocityY = PixelUtil.toPixelFromDIP(config.getDouble(KEY_MIN_VELOCITY_Y))
+        hasCustomActivationCriteria = true
+      }
+
+      // PanGestureHandler sets minDist by default, if there are custom criteria specified we want
+      // to reset that setting and use provided criteria instead.
+      if (config.hasKey(KEY_MIN_DIST)) {
+        handler.minDist = PixelUtil.toPixelFromDIP(config.getDouble(KEY_MIN_DIST))
+      } else if (hasCustomActivationCriteria) {
+        handler.minDist = Float.MAX_VALUE
+      }
+      if (config.hasKey(KEY_MIN_POINTERS)) {
+        handler.minPointers = config.getInt(KEY_MIN_POINTERS)
+      }
+      if (config.hasKey(KEY_MAX_POINTERS)) {
+        handler.maxPointers = config.getInt(KEY_MAX_POINTERS)
+      }
+      if (config.hasKey(KEY_AVG_TOUCHES)) {
+        handler.averageTouches = config.getBoolean(KEY_AVG_TOUCHES)
+      }
+      if (config.hasKey(KEY_ACTIVATE_AFTER_LONG_PRESS)) {
+        handler.activateAfterLongPress = config.getInt(KEY_ACTIVATE_AFTER_LONG_PRESS).toLong()
+      }
+    }
+
+    override fun createEventBuilder(handler: PanGestureHandler) = PanGestureHandlerEventDataBuilder(handler)
+
+    companion object {
+      private const val KEY_ACTIVE_OFFSET_X_START = "activeOffsetXStart"
+      private const val KEY_ACTIVE_OFFSET_X_END = "activeOffsetXEnd"
+      private const val KEY_FAIL_OFFSET_RANGE_X_START = "failOffsetXStart"
+      private const val KEY_FAIL_OFFSET_RANGE_X_END = "failOffsetXEnd"
+      private const val KEY_ACTIVE_OFFSET_Y_START = "activeOffsetYStart"
+      private const val KEY_ACTIVE_OFFSET_Y_END = "activeOffsetYEnd"
+      private const val KEY_FAIL_OFFSET_RANGE_Y_START = "failOffsetYStart"
+      private const val KEY_FAIL_OFFSET_RANGE_Y_END = "failOffsetYEnd"
+      private const val KEY_MIN_DIST = "minDist"
+      private const val KEY_MIN_VELOCITY = "minVelocity"
+      private const val KEY_MIN_VELOCITY_X = "minVelocityX"
+      private const val KEY_MIN_VELOCITY_Y = "minVelocityY"
+      private const val KEY_MIN_POINTERS = "minPointers"
+      private const val KEY_MAX_POINTERS = "maxPointers"
+      private const val KEY_AVG_TOUCHES = "avgTouches"
+      private const val KEY_ACTIVATE_AFTER_LONG_PRESS = "activateAfterLongPress"
+    }
+  }
+
   companion object {
     private const val MIN_VALUE_IGNORE = Float.MAX_VALUE
     private const val MAX_VALUE_IGNORE = Float.MIN_VALUE
     private const val DEFAULT_MIN_POINTERS = 1
     private const val DEFAULT_MAX_POINTERS = 10
     private const val DEFAULT_ACTIVATE_AFTER_LONG_PRESS = 0L
+    private const val DEFAULT_AVERAGE_TOUCHES = false
+    private const val DEFAULT_ACTIVE_OFFSET_X_START = MIN_VALUE_IGNORE
+    private const val DEFAULT_ACTIVE_OFFSET_X_END = MAX_VALUE_IGNORE
+    private const val DEFAULT_FAIL_OFFSET_X_START = MAX_VALUE_IGNORE
+    private const val DEFAULT_FAIL_OFFSET_X_END = MIN_VALUE_IGNORE
+    private const val DEFAULT_ACTIVE_OFFSET_Y_START = MIN_VALUE_IGNORE
+    private const val DEFAULT_ACTIVE_OFFSET_Y_END = MAX_VALUE_IGNORE
+    private const val DEFAULT_FAIL_OFFSET_Y_START = MAX_VALUE_IGNORE
+    private const val DEFAULT_FAIL_OFFSET_Y_END = MIN_VALUE_IGNORE
+    private const val DEFAULT_MIN_VELOCITY_X = MIN_VALUE_IGNORE
+    private const val DEFAULT_MIN_VELOCITY_Y = MIN_VALUE_IGNORE
+    private const val DEFAULT_MIN_VELOCITY = MIN_VALUE_IGNORE
 
     /**
      * This method adds movement to {@class VelocityTracker} first resetting offset of the event so

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

@@ -1,11 +1,13 @@
 package com.swmansion.gesturehandler.core
 
+import android.content.Context
 import android.graphics.PointF
 import android.view.MotionEvent
 import android.view.ViewConfiguration
+import com.swmansion.gesturehandler.react.eventbuilders.PinchGestureHandlerEventDataBuilder
 import kotlin.math.abs
 
-class PinchGestureHandler : GestureHandler<PinchGestureHandler>() {
+class PinchGestureHandler : GestureHandler() {
   var scale = 0.0
     private set
   var velocity = 0.0
@@ -23,7 +25,8 @@ class PinchGestureHandler : GestureHandler<PinchGestureHandler>() {
     override fun onScale(detector: ScaleGestureDetector): Boolean {
       val prevScaleFactor: Double = scale
       scale *= detector.scaleFactor.toDouble()
-      val delta = detector.timeDelta
+      val delta = detector.timeDeltaSeconds
+
       if (delta > 0) {
         velocity = (scale - prevScaleFactor) / delta
       }
@@ -35,10 +38,6 @@ class PinchGestureHandler : GestureHandler<PinchGestureHandler>() {
       return true
     }
 
-    init {
-      setShouldCancelWhenOutside(false)
-    }
-
     override fun onScaleBegin(detector: ScaleGestureDetector): Boolean {
       startingSpan = detector.currentSpan
       return true
@@ -70,14 +69,13 @@ class PinchGestureHandler : GestureHandler<PinchGestureHandler>() {
       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 (sourceEvent.actionMasked == MotionEvent.ACTION_UP) {
-      fail()
+
+    if (sourceEvent.actionMasked == MotionEvent.ACTION_UP) {
+      if (state == STATE_ACTIVE) {
+        end()
+      } else {
+        fail()
+      }
     }
   }
 
@@ -100,4 +98,13 @@ class PinchGestureHandler : GestureHandler<PinchGestureHandler>() {
     velocity = 0.0
     scale = 1.0
   }
+
+  class Factory : GestureHandler.Factory<PinchGestureHandler>() {
+    override val type = PinchGestureHandler::class.java
+    override val name = "PinchGestureHandler"
+
+    override fun create(context: Context?): PinchGestureHandler = PinchGestureHandler()
+
+    override fun createEventBuilder(handler: PinchGestureHandler) = PinchGestureHandlerEventDataBuilder(handler)
+  }
 }

package/android/src/main/java/com/swmansion/gesturehandler/core/PointerEventsConfig.kt

@@ -19,5 +19,5 @@ enum class PointerEventsConfig {
   /**
    * Container and all of its children receive touch events (like pointerEvents is unspecified).
    */
-  AUTO
+  AUTO,
 }

package/android/src/main/java/com/swmansion/gesturehandler/core/RotationGestureDetector.kt

@@ -57,6 +57,14 @@ class RotationGestureDetector(private val gestureListener: OnRotationGestureList
     currentTime = event.eventTime
     val firstPointerIndex = event.findPointerIndex(pointerIds[0])
     val secondPointerIndex = event.findPointerIndex(pointerIds[1])
+
+    if (
+      firstPointerIndex == MotionEvent.INVALID_POINTER_ID ||
+      secondPointerIndex == MotionEvent.INVALID_POINTER_ID
+    ) {
+      return
+    }
+
     val firstPtX = event.getX(firstPointerIndex)
     val firstPtY = event.getY(firstPointerIndex)
     val secondPtX = event.getX(secondPointerIndex)
@@ -68,9 +76,14 @@ class RotationGestureDetector(private val gestureListener: OnRotationGestureList
 
     // Angle diff should be positive when rotating in clockwise direction
     val angle = -atan2(vectorY.toDouble(), vectorX.toDouble())
+
+    tryUnpause(angle)
+
     rotation = if (previousAngle.isNaN()) {
       0.0
-    } else previousAngle - angle
+    } else {
+      previousAngle - angle
+    }
 
     previousAngle = angle
     if (rotation > Math.PI) {
@@ -85,8 +98,29 @@ class RotationGestureDetector(private val gestureListener: OnRotationGestureList
     }
   }
 
+  /**
+   * Gesture pauses when second Pointer lifts
+   *
+   * Then Detector waits for a new second Pointer to arrive to continue Handling
+   * (last Pointer Lifting finishes the Gesture)
+   *
+   * @see tryPause
+   * @see tryUnpause
+   */
+  private var isPaused = false
+  private fun tryPause() {
+    if (isPaused) return
+    isPaused = true
+  }
+  private fun tryUnpause(eventAngle: Double) {
+    if (!isPaused) return
+    previousAngle = eventAngle
+    isPaused = false
+  }
+
   private fun finish() {
     if (isInProgress) {
+      isPaused = false
       isInProgress = false
       gestureListener?.onRotationEnd(this)
     }
@@ -99,23 +133,33 @@ class RotationGestureDetector(private val gestureListener: OnRotationGestureList
         pointerIds[0] = event.getPointerId(event.actionIndex)
         pointerIds[1] = MotionEvent.INVALID_POINTER_ID
       }
-      MotionEvent.ACTION_POINTER_DOWN -> if (!isInProgress) {
-        pointerIds[1] = event.getPointerId(event.actionIndex)
-        isInProgress = true
-        previousTime = event.eventTime
-        previousAngle = Double.NaN
-        updateCurrent(event)
-        gestureListener?.onRotationBegin(this)
+      MotionEvent.ACTION_POINTER_DOWN -> {
+        if (!isInProgress || isPaused) {
+          pointerIds[1] = event.getPointerId(event.actionIndex)
+          updateCurrent(event)
+        }
+        if (!isInProgress) {
+          isInProgress = true
+          previousTime = event.eventTime
+          previousAngle = Double.NaN
+          gestureListener?.onRotationBegin(this)
+        }
       }
       MotionEvent.ACTION_MOVE -> if (isInProgress) {
         updateCurrent(event)
-        gestureListener?.onRotation(this)
+        if (!isPaused) {
+          gestureListener?.onRotation(this)
+        }
       }
       MotionEvent.ACTION_POINTER_UP -> if (isInProgress) {
         val pointerId = event.getPointerId(event.actionIndex)
-        if (pointerId == pointerIds[0] || pointerId == pointerIds[1]) {
-          // One of the key pointer has been lifted up, we have to end the gesture
-          finish()
+        if (pointerId == pointerIds[0]) {
+          pointerIds[0] = pointerIds[1]
+          pointerIds[1] = MotionEvent.INVALID_POINTER_ID
+          tryPause()
+        } else if (pointerId == pointerIds[1]) {
+          pointerIds[1] = MotionEvent.INVALID_POINTER_ID
+          tryPause()
         }
       }
       MotionEvent.ACTION_UP -> finish()

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

@@ -1,11 +1,13 @@
 package com.swmansion.gesturehandler.core
 
+import android.content.Context
 import android.graphics.PointF
 import android.view.MotionEvent
 import com.swmansion.gesturehandler.core.RotationGestureDetector.OnRotationGestureListener
+import com.swmansion.gesturehandler.react.eventbuilders.RotationGestureHandlerEventDataBuilder
 import kotlin.math.abs
 
-class RotationGestureHandler : GestureHandler<RotationGestureHandler>() {
+class RotationGestureHandler : GestureHandler() {
   private var rotationGestureDetector: RotationGestureDetector? = null
   var rotation = 0.0
     private set
@@ -16,10 +18,6 @@ class RotationGestureHandler : GestureHandler<RotationGestureHandler>() {
   var anchorY: Float = Float.NaN
     private set
 
-  init {
-    setShouldCancelWhenOutside(false)
-  }
-
   private val gestureListener: OnRotationGestureListener = object : OnRotationGestureListener {
     override fun onRotation(detector: RotationGestureDetector): Boolean {
       val prevRotation: Double = rotation
@@ -87,6 +85,15 @@ class RotationGestureHandler : GestureHandler<RotationGestureHandler>() {
     rotation = 0.0
   }
 
+  class Factory : GestureHandler.Factory<RotationGestureHandler>() {
+    override val type = RotationGestureHandler::class.java
+    override val name = "RotationGestureHandler"
+
+    override fun create(context: Context?): RotationGestureHandler = RotationGestureHandler()
+
+    override fun createEventBuilder(handler: RotationGestureHandler) = RotationGestureHandlerEventDataBuilder(handler)
+  }
+
   companion object {
     private const val ROTATION_RECOGNITION_THRESHOLD = Math.PI / 36.0 // 5 deg in radians
   }

package/android/src/main/java/com/swmansion/gesturehandler/core/ScaleGestureDetector.java

@@ -547,6 +547,16 @@ public class ScaleGestureDetector {
         return mCurrTime - mPrevTime;
     }
 
+    /**
+     * Return the time difference in seconds between the previous
+     * accepted scaling event and the current scaling event.
+     *
+     * @return Time difference since the last scaling event in seconds.
+     */
+    public double getTimeDeltaSeconds() {
+        return (double)this.getTimeDelta() / 1000;
+    }
+
     /**
      * Return the event time of the current event being processed.
      *