react-native-gesture-handler 1.10.3 → 2.2.0

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

@@ -0,0 +1,97 @@
+package com.swmansion.gesturehandler
+
+import android.content.Context
+import android.os.Handler
+import android.os.SystemClock
+import android.view.MotionEvent
+
+class LongPressGestureHandler(context: Context) : GestureHandler<LongPressGestureHandler>() {
+  var minDurationMs = DEFAULT_MIN_DURATION_MS
+  val duration: Int
+    get() = (previousTime - startTime).toInt()
+  private val defaultMaxDistSq: Float
+  private var maxDistSq: Float
+  private var startX = 0f
+  private var startY = 0f
+  private var startTime: Long = 0
+  private var previousTime: Long = 0
+  private var handler: Handler? = null
+
+  init {
+    setShouldCancelWhenOutside(true)
+    defaultMaxDistSq = DEFAULT_MAX_DIST_DP * context.resources.displayMetrics.density
+    maxDistSq = defaultMaxDistSq
+  }
+
+  override fun resetConfig() {
+    super.resetConfig()
+    minDurationMs = DEFAULT_MIN_DURATION_MS
+    maxDistSq = defaultMaxDistSq
+  }
+
+  fun setMaxDist(maxDist: Float): LongPressGestureHandler {
+    maxDistSq = maxDist * maxDist
+    return this
+  }
+
+  override fun onHandle(event: MotionEvent) {
+    if (state == STATE_UNDETERMINED) {
+      previousTime = SystemClock.uptimeMillis()
+      startTime = previousTime
+      begin()
+      startX = event.rawX
+      startY = event.rawY
+      handler = Handler()
+      if (minDurationMs > 0) {
+        handler!!.postDelayed({ activate() }, minDurationMs)
+      } else if (minDurationMs == 0L) {
+        activate()
+      }
+    }
+    if (event.actionMasked == MotionEvent.ACTION_UP) {
+      handler?.let {
+        it.removeCallbacksAndMessages(null)
+        handler = null
+      }
+      if (state == STATE_ACTIVE) {
+        end()
+      } else {
+        fail()
+      }
+    } else {
+      // calculate distance from start
+      val deltaX = event.rawX - startX
+      val deltaY = event.rawY - startY
+      val distSq = deltaX * deltaX + deltaY * deltaY
+      if (distSq > maxDistSq) {
+        if (state == STATE_ACTIVE) {
+          cancel()
+        } else {
+          fail()
+        }
+      }
+    }
+  }
+
+  override fun onStateChange(newState: Int, previousState: Int) {
+    handler?.let {
+      it.removeCallbacksAndMessages(null)
+      handler = null
+    }
+  }
+
+  override fun dispatchStateChange(newState: Int, prevState: Int) {
+    previousTime = SystemClock.uptimeMillis()
+    super.dispatchStateChange(newState, prevState)
+  }
+
+  override fun dispatchHandlerUpdate(event: MotionEvent) {
+    previousTime = SystemClock.uptimeMillis()
+    super.dispatchHandlerUpdate(event)
+  }
+
+  companion object {
+    private const val DEFAULT_MIN_DURATION_MS: Long = 500
+    private const val DEFAULT_MAX_DIST_DP = 10f
+  }
+}

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

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

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

@@ -0,0 +1,129 @@
+package com.swmansion.gesturehandler
+
+import android.os.SystemClock
+import android.view.MotionEvent
+import android.view.View
+import android.view.ViewGroup
+import com.swmansion.gesturehandler.react.RNGestureHandlerButtonViewManager
+
+class NativeViewGestureHandler : GestureHandler<NativeViewGestureHandler>() {
+  private var shouldActivateOnStart = false
+  private var disallowInterruption = false
+
+  init {
+    setShouldCancelWhenOutside(true)
+  }
+
+  override fun resetConfig() {
+    super.resetConfig()
+    shouldActivateOnStart = false
+    disallowInterruption = false
+  }
+
+  fun setShouldActivateOnStart(shouldActivateOnStart: Boolean) = apply {
+    this.shouldActivateOnStart = shouldActivateOnStart
+  }
+
+  /**
+   * Set this to `true` when wrapping native components that are supposed to be an exclusive
+   * target for a touch stream. Like for example switch or slider component which when activated
+   * aren't supposed to be cancelled by scrollview or other container that may also handle touches.
+   */
+  fun setDisallowInterruption(disallowInterruption: Boolean) = apply {
+    this.disallowInterruption = disallowInterruption
+  }
+
+  override fun shouldRecognizeSimultaneously(handler: GestureHandler<*>): Boolean {
+    if (handler is NativeViewGestureHandler) {
+      // Special case when the peer handler is also an instance of NativeViewGestureHandler:
+      // For the `disallowInterruption` to work correctly we need to check the property when
+      // accessed as a peer, because simultaneous recognizers can be set on either side of the
+      // connection.
+      val nativeWrapper = handler
+      if (nativeWrapper.state == STATE_ACTIVE && nativeWrapper.disallowInterruption) {
+        // other handler is active and it disallows interruption, we don't want to get into its way
+        return false
+      }
+    }
+    val canBeInterrupted = !disallowInterruption
+    val otherState = handler.state
+    return if (state == STATE_ACTIVE && otherState == STATE_ACTIVE && canBeInterrupted) {
+      // if both handlers are active and the current handler can be interrupted it we return `false`
+      // as it means the other handler has turned active and returning `true` would prevent it from
+      // interrupting the current handler
+      false
+    } else state == STATE_ACTIVE && canBeInterrupted
+    // otherwise we can only return `true` if already in an active state
+  }
+
+  override fun shouldBeCancelledBy(handler: GestureHandler<*>): Boolean {
+    return !disallowInterruption
+  }
+
+  private fun canStart(): Boolean {
+    val view = view
+    if (view is StateChangeHook) {
+      return view.canStart()
+    }
+
+    return true
+  }
+
+  private fun afterGestureEnd() {
+    val view = view
+    if (view is StateChangeHook) {
+      view.afterGestureEnd()
+    }
+  }
+
+  override fun onHandle(event: MotionEvent) {
+    val view = view!!
+    if (event.actionMasked == MotionEvent.ACTION_UP) {
+      view.onTouchEvent(event)
+      if ((state == STATE_UNDETERMINED || state == STATE_BEGAN) && view.isPressed) {
+        activate()
+      }
+      end()
+      afterGestureEnd()
+    } else if (state == STATE_UNDETERMINED || state == STATE_BEGAN) {
+      when {
+        shouldActivateOnStart -> {
+          tryIntercept(view, event)
+          view.onTouchEvent(event)
+          activate()
+        }
+        tryIntercept(view, event) -> {
+          view.onTouchEvent(event)
+          activate()
+        }
+        state != STATE_BEGAN -> {
+          if (canStart()) {
+            begin()
+          } else {
+            cancel()
+          }
+        }
+      }
+    } else if (state == STATE_ACTIVE) {
+      view.onTouchEvent(event)
+    }
+  }
+
+  override fun onCancel() {
+    val time = SystemClock.uptimeMillis()
+    val event = MotionEvent.obtain(time, time, MotionEvent.ACTION_CANCEL, 0f, 0f, 0).apply {
+      action =  MotionEvent.ACTION_CANCEL
+    }
+    view!!.onTouchEvent(event)
+  }
+
+  companion object {
+    private fun tryIntercept(view: View, event: MotionEvent) =
+      view is ViewGroup && view.onInterceptTouchEvent(event)
+  }
+
+  interface StateChangeHook {
+    fun canStart(): Boolean
+    fun afterGestureEnd()
+  }
+}

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

@@ -0,0 +1,9 @@
+package com.swmansion.gesturehandler
+
+import android.view.MotionEvent
+
+interface OnTouchEventListener {
+  fun <T : GestureHandler<T>> onHandlerUpdate(handler: T, event: MotionEvent)
+  fun <T : GestureHandler<T>> onStateChange(handler: T, newState: Int, oldState: Int)
+  fun <T : GestureHandler<T>> onTouchEvent(handler: T)
+}

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

@@ -0,0 +1,292 @@
+package com.swmansion.gesturehandler
+
+import android.content.Context
+import android.view.MotionEvent
+import android.view.VelocityTracker
+import android.view.ViewConfiguration
+import com.swmansion.gesturehandler.GestureUtils.getLastPointerX
+import com.swmansion.gesturehandler.GestureUtils.getLastPointerY
+
+class PanGestureHandler(context: Context?) : GestureHandler<PanGestureHandler>() {
+  var velocityX = 0f
+    private set
+  var velocityY = 0f
+    private set
+  val translationX: Float
+    get() = lastX - startX + offsetX
+  val translationY: Float
+    get() = lastY - startY + offsetY
+
+  private val defaultMinDistSq: Float
+  private var minDistSq = MAX_VALUE_IGNORE
+  private var activeOffsetXStart = MIN_VALUE_IGNORE
+  private var activeOffsetXEnd = MAX_VALUE_IGNORE
+  private var failOffsetXStart = MAX_VALUE_IGNORE
+  private var failOffsetXEnd = MIN_VALUE_IGNORE
+  private var activeOffsetYStart = MIN_VALUE_IGNORE
+  private var activeOffsetYEnd = MAX_VALUE_IGNORE
+  private var failOffsetYStart = MAX_VALUE_IGNORE
+  private var failOffsetYEnd = MIN_VALUE_IGNORE
+  private var minVelocityX = MIN_VALUE_IGNORE
+  private var minVelocityY = MIN_VALUE_IGNORE
+  private var minVelocitySq = MIN_VALUE_IGNORE
+  private var minPointers = DEFAULT_MIN_POINTERS
+  private var maxPointers = DEFAULT_MAX_POINTERS
+  private var startX = 0f
+  private var startY = 0f
+  private var offsetX = 0f
+  private var offsetY = 0f
+  private var lastX = 0f
+  private var lastY = 0f
+  private var velocityTracker: VelocityTracker? = null
+  private var averageTouches = false
+
+  /**
+   * On Android when there are multiple pointers on the screen pan gestures most often just consider
+   * the last placed pointer. The behaviour on iOS is quite different where the x and y component
+   * of the pan pointer is calculated as an average out of all the pointers placed on the screen.
+   *
+   * This behaviour can be customized on android by setting averageTouches property of the handler
+   * object. This could be useful in particular for the usecases when we attach other handlers that
+   * recognizes multi-finger gestures such as rotation. In that case when we only rely on the last
+   * placed finger it is easier for the gesture handler to trigger when we do a rotation gesture
+   * because each finger when treated separately will travel some distance, whereas the average
+   * position of all the fingers will remain still while doing a rotation gesture.
+   */
+  init {
+    val vc = ViewConfiguration.get(context)
+    val touchSlop = vc.scaledTouchSlop
+    defaultMinDistSq = (touchSlop * touchSlop).toFloat()
+    minDistSq = defaultMinDistSq
+  }
+
+  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
+    minPointers = DEFAULT_MIN_POINTERS
+    maxPointers = DEFAULT_MAX_POINTERS
+    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
+  }
+
+  /**
+   * @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
+  }
+
+  private fun shouldActivate(): Boolean {
+    val dx = lastX - startX + offsetX
+    if (activeOffsetXStart != MIN_VALUE_IGNORE && dx < activeOffsetXStart) {
+      return true
+    }
+    if (activeOffsetXEnd != MAX_VALUE_IGNORE && dx > activeOffsetXEnd) {
+      return true
+    }
+    val dy = lastY - startY + offsetY
+    if (activeOffsetYStart != MIN_VALUE_IGNORE && dy < activeOffsetYStart) {
+      return true
+    }
+    if (activeOffsetYEnd != MAX_VALUE_IGNORE && dy > activeOffsetYEnd) {
+      return true
+    }
+    val distSq = dx * dx + dy * dy
+    if (minDistSq != MIN_VALUE_IGNORE && distSq >= minDistSq) {
+      return true
+    }
+    val vx = velocityX
+    if (minVelocityX != MIN_VALUE_IGNORE &&
+      (minVelocityX < 0 && vx <= minVelocityX || minVelocityX in 0.0f..vx)) {
+      return true
+    }
+    val vy = velocityY
+    if (minVelocityY != MIN_VALUE_IGNORE &&
+      (minVelocityY < 0 && vx <= minVelocityY || minVelocityY in 0.0f..vx)) {
+      return true
+    }
+    val velocitySq = vx * vx + vy * vy
+    return minVelocitySq != MIN_VALUE_IGNORE && velocitySq >= minVelocitySq
+  }
+
+  private fun shouldFail(): Boolean {
+    val dx = lastX - startX + offsetX
+    if (failOffsetXStart != MAX_VALUE_IGNORE && dx < failOffsetXStart) {
+      return true
+    }
+    if (failOffsetXEnd != MIN_VALUE_IGNORE && dx > failOffsetXEnd) {
+      return true
+    }
+    val dy = lastY - startY + offsetY
+    if (failOffsetYStart != MAX_VALUE_IGNORE && dy < failOffsetYStart) {
+      return true
+    }
+    return failOffsetYEnd != MIN_VALUE_IGNORE && dy > failOffsetYEnd
+  }
+
+  override fun onHandle(event: MotionEvent) {
+    val state = state
+    val action = event.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)
+      startX = lastX
+      startY = lastY
+    } else {
+      lastX = getLastPointerX(event, averageTouches)
+      lastY = getLastPointerY(event, averageTouches)
+    }
+    if (state == STATE_UNDETERMINED && event.pointerCount >= minPointers) {
+      resetProgress()
+      offsetX = 0f
+      offsetY = 0f
+      velocityX = 0f
+      velocityY = 0f
+      velocityTracker = VelocityTracker.obtain()
+      addVelocityMovement(velocityTracker, event)
+      begin()
+    } else if (velocityTracker != null) {
+      addVelocityMovement(velocityTracker, event)
+      velocityTracker!!.computeCurrentVelocity(1000)
+      velocityX = velocityTracker!!.xVelocity
+      velocityY = velocityTracker!!.yVelocity
+    }
+    if (action == MotionEvent.ACTION_UP) {
+      if (state == STATE_ACTIVE) {
+        end()
+      } else {
+        fail()
+      }
+    } else if (action == MotionEvent.ACTION_POINTER_DOWN && event.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) {
+      // 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.
+      fail()
+    } else if (state == STATE_BEGAN) {
+      if (shouldFail()) {
+        fail()
+      } else if (shouldActivate()) {
+        activate()
+      }
+    }
+  }
+
+  override fun activate(force: Boolean) {
+    // reset starting point if the handler has not yet activated
+    if (state != STATE_ACTIVE) {
+      resetProgress()
+    }
+    super.activate(force)
+  }
+
+  override fun onReset() {
+    velocityTracker?.let {
+      it.recycle()
+      velocityTracker = null
+    }
+  }
+
+  override fun resetProgress() {
+    startX = lastX
+    startY = lastY
+  }
+
+  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
+
+    /**
+     * This method adds movement to {@class VelocityTracker} first resetting offset of the event so
+     * that the velocity is calculated based on the absolute position of touch pointers. This is
+     * because if the underlying view moves along with the finger using relative x/y coords yields
+     * incorrect results.
+     */
+    private fun addVelocityMovement(tracker: VelocityTracker?, event: MotionEvent) {
+      val offsetX = event.rawX - event.x
+      val offsetY = event.rawY - event.y
+      event.offsetLocation(offsetX, offsetY)
+      tracker!!.addMovement(event)
+      event.offsetLocation(-offsetX, -offsetY)
+    }
+  }
+}

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

@@ -0,0 +1,90 @@
+package com.swmansion.gesturehandler
+
+import android.view.MotionEvent
+import android.view.ScaleGestureDetector
+import android.view.ScaleGestureDetector.OnScaleGestureListener
+import android.view.ViewConfiguration
+import kotlin.math.abs
+
+class PinchGestureHandler : GestureHandler<PinchGestureHandler>() {
+  var scale = 0.0
+    private set
+  var velocity = 0.0
+    private set
+  val focalPointX: Float
+    get() = scaleGestureDetector?.focusX ?: Float.NaN
+  val focalPointY: Float
+    get() = scaleGestureDetector?.focusY ?: Float.NaN
+
+  private var scaleGestureDetector: ScaleGestureDetector? = null
+  private var startingSpan = 0f
+  private var spanSlop = 0f
+  private val gestureListener: OnScaleGestureListener = object : OnScaleGestureListener {
+    override fun onScale(detector: ScaleGestureDetector): Boolean {
+      val prevScaleFactor: Double = scale
+      scale *= detector.scaleFactor.toDouble()
+      val delta = detector.timeDelta
+      if (delta > 0) {
+        velocity = (scale - prevScaleFactor) / delta
+      }
+      if (abs(startingSpan - detector.currentSpan) >= spanSlop
+        && state == STATE_BEGAN) {
+        activate()
+      }
+      return true
+    }
+
+    init {
+      setShouldCancelWhenOutside(false)
+    }
+
+    override fun onScaleBegin(detector: ScaleGestureDetector): Boolean {
+      startingSpan = detector.currentSpan
+      return true
+    }
+
+    override fun onScaleEnd(detector: ScaleGestureDetector) {
+      // ScaleGestureDetector thinks that when fingers are 27mm away that's a sufficiently good
+      // reason to trigger this method giving us no other choice but to ignore it completely.
+    }
+  }
+
+  override fun onHandle(event: MotionEvent) {
+    if (state == STATE_UNDETERMINED) {
+      val context = view!!.context
+      resetProgress()
+      scaleGestureDetector = ScaleGestureDetector(context, gestureListener)
+      val configuration = ViewConfiguration.get(context)
+      spanSlop = configuration.scaledTouchSlop.toFloat()
+      begin()
+    }
+    scaleGestureDetector?.onTouchEvent(event)
+    var activePointers = event.pointerCount
+    if (event.actionMasked == MotionEvent.ACTION_POINTER_UP) {
+      activePointers -= 1
+    }
+    if (state == STATE_ACTIVE && activePointers < 2) {
+      end()
+    } else if (event.actionMasked == MotionEvent.ACTION_UP) {
+      fail()
+    }
+  }
+
+  override fun activate(force: Boolean) {
+    // reset scale if the handler has not yet activated
+    if (state != STATE_ACTIVE) {
+      resetProgress()
+    }
+    super.activate(force)
+  }
+
+  override fun onReset() {
+    scaleGestureDetector = null
+    resetProgress()
+  }
+
+  override fun resetProgress() {
+    velocity = 0.0
+    scale = 1.0
+  }
+}

package/android/lib/src/main/java/com/swmansion/gesturehandler/{PointerEventsConfig.java → PointerEventsConfig.kt}

@@ -1,7 +1,6 @@
-package com.swmansion.gesturehandler;
-
-public enum PointerEventsConfig {
+package com.swmansion.gesturehandler
 
+enum class PointerEventsConfig {
   /**
    * Neither the container nor its children receive events.
    */
@@ -20,6 +19,5 @@ public enum PointerEventsConfig {
   /**
    * Container and all of its children receive touch events (like pointerEvents is unspecified).
    */
-  AUTO,
-  ;
+  AUTO
 }