@react-native-oh-tpl/react-native-gesture-handler 2.12.1-0.0.1

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

@@ -0,0 +1,322 @@
+package com.swmansion.gesturehandler.core
+
+import android.content.Context
+import android.os.Handler
+import android.os.Looper
+import android.view.MotionEvent
+import android.view.VelocityTracker
+import android.view.ViewConfiguration
+import com.swmansion.gesturehandler.core.GestureUtils.getLastPointerX
+import com.swmansion.gesturehandler.core.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
+  private var activateAfterLongPress = DEFAULT_ACTIVATE_AFTER_LONG_PRESS
+  private val activateDelayed = Runnable { activate() }
+  private var handler: Handler? = null
+
+  /**
+   * 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
+    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
+  }
+
+  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
+    val dy = lastY - startY + offsetY
+
+    if (activateAfterLongPress > 0 && dx * dx + dy * dy > defaultMinDistSq) {
+      handler?.removeCallbacksAndMessages(null)
+      return true
+    }
+    if (failOffsetXStart != MAX_VALUE_IGNORE && dx < failOffsetXStart) {
+      return true
+    }
+    if (failOffsetXEnd != MIN_VALUE_IGNORE && dx > failOffsetXEnd) {
+      return true
+    }
+    if (failOffsetYStart != MAX_VALUE_IGNORE && dy < failOffsetYStart) {
+      return true
+    }
+    return failOffsetYEnd != MIN_VALUE_IGNORE && dy > failOffsetYEnd
+  }
+
+  override fun onHandle(event: MotionEvent, sourceEvent: MotionEvent) {
+    val state = state
+    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(sourceEvent, averageTouches)
+      lastY = getLastPointerY(sourceEvent, averageTouches)
+      startX = lastX
+      startY = lastY
+    } else {
+      lastX = getLastPointerX(sourceEvent, averageTouches)
+      lastY = getLastPointerY(sourceEvent, averageTouches)
+    }
+    if (state == STATE_UNDETERMINED && sourceEvent.pointerCount >= minPointers) {
+      resetProgress()
+      offsetX = 0f
+      offsetY = 0f
+      velocityX = 0f
+      velocityY = 0f
+      velocityTracker = VelocityTracker.obtain()
+      addVelocityMovement(velocityTracker, sourceEvent)
+      begin()
+
+      if (activateAfterLongPress > 0) {
+        if (handler == null) {
+          handler = Handler(Looper.getMainLooper())
+        }
+        handler!!.postDelayed(activateDelayed, activateAfterLongPress)
+      }
+    } else if (velocityTracker != null) {
+      addVelocityMovement(velocityTracker, sourceEvent)
+      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 && 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) {
+      // 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 onCancel() {
+    handler?.removeCallbacksAndMessages(null)
+  }
+
+  override fun onReset() {
+    handler?.removeCallbacksAndMessages(null)
+    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
+    private const val DEFAULT_ACTIVATE_AFTER_LONG_PRESS = 0L
+
+    /**
+     * 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/src/main/java/com/swmansion/gesturehandler/core/PinchGestureHandler.kt

@@ -0,0 +1,103 @@
+package com.swmansion.gesturehandler.core
+
+import android.graphics.PointF
+import android.view.MotionEvent
+import android.view.ViewConfiguration
+import kotlin.math.abs
+
+class PinchGestureHandler : GestureHandler<PinchGestureHandler>() {
+  var scale = 0.0
+    private set
+  var velocity = 0.0
+    private set
+  var focalPointX: Float = Float.NaN
+    private set
+  var focalPointY: Float = Float.NaN
+    private set
+
+  private var scaleGestureDetector: ScaleGestureDetector? = null
+  private var startingSpan = 0f
+  private var spanSlop = 0f
+  private val gestureListener: ScaleGestureDetector.OnScaleGestureListener = object :
+    ScaleGestureDetector.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, sourceEvent: MotionEvent) {
+    if (state == STATE_UNDETERMINED) {
+      val context = view!!.context
+      resetProgress()
+      scaleGestureDetector = ScaleGestureDetector(context, gestureListener)
+      val configuration = ViewConfiguration.get(context)
+      spanSlop = configuration.scaledTouchSlop.toFloat()
+
+      // set the focal point to the position of the first pointer as NaN causes the event not to arrive
+      this.focalPointX = event.x
+      this.focalPointY = event.y
+
+      begin()
+    }
+    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 (sourceEvent.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
+    focalPointX = Float.NaN
+    focalPointY = Float.NaN
+    resetProgress()
+  }
+
+  override fun resetProgress() {
+    velocity = 0.0
+    scale = 1.0
+  }
+}

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

@@ -0,0 +1,23 @@
+package com.swmansion.gesturehandler.core
+
+enum class PointerEventsConfig {
+  /**
+   * Neither the container nor its children receive events.
+   */
+  NONE,
+
+  /**
+   * Container doesn't get events but all of its children do.
+   */
+  BOX_NONE,
+
+  /**
+   * Container gets events but none of its children do.
+   */
+  BOX_ONLY,
+
+  /**
+   * Container and all of its children receive touch events (like pointerEvents is unspecified).
+   */
+  AUTO
+}

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

@@ -0,0 +1,125 @@
+package com.swmansion.gesturehandler.core
+
+import android.view.MotionEvent
+import kotlin.math.atan2
+
+class RotationGestureDetector(private val gestureListener: OnRotationGestureListener?) {
+  interface OnRotationGestureListener {
+    fun onRotation(detector: RotationGestureDetector): Boolean
+    fun onRotationBegin(detector: RotationGestureDetector): Boolean
+    fun onRotationEnd(detector: RotationGestureDetector)
+  }
+
+  private var currentTime = 0L
+  private var previousTime = 0L
+  private var previousAngle = 0.0
+
+  /**
+   * Returns rotation in radians since the previous rotation event.
+   *
+   * @return current rotation step in radians.
+   */
+  var rotation = 0.0
+    private set
+
+  /**
+   * Returns X coordinate of the rotation anchor point relative to the view that the provided motion
+   * event coordinates (usually relative to the view event was sent to).
+   *
+   * @return X coordinate of the rotation anchor point
+   */
+  var anchorX = 0f
+    private set
+
+  /**
+   * Returns Y coordinate of the rotation anchor point relative to the view that the provided motion
+   * event coordinates (usually relative to the view event was sent to).
+   *
+   * @return Y coordinate of the rotation anchor point
+   */
+  var anchorY = 0f
+    private set
+
+  /**
+   * Return the time difference in milliseconds between the previous
+   * accepted rotation event and the current rotation event.
+   *
+   * @return Time difference since the last rotation event in milliseconds.
+   */
+  val timeDelta: Long
+    get() = currentTime - previousTime
+
+  private var isInProgress = false
+  private val pointerIds = IntArray(2)
+
+  private fun updateCurrent(event: MotionEvent) {
+    previousTime = currentTime
+    currentTime = event.eventTime
+    val firstPointerIndex = event.findPointerIndex(pointerIds[0])
+    val secondPointerIndex = event.findPointerIndex(pointerIds[1])
+    val firstPtX = event.getX(firstPointerIndex)
+    val firstPtY = event.getY(firstPointerIndex)
+    val secondPtX = event.getX(secondPointerIndex)
+    val secondPtY = event.getY(secondPointerIndex)
+    val vectorX = secondPtX - firstPtX
+    val vectorY = secondPtY - firstPtY
+    anchorX = (firstPtX + secondPtX) * 0.5f
+    anchorY = (firstPtY + secondPtY) * 0.5f
+
+    // Angle diff should be positive when rotating in clockwise direction
+    val angle = -atan2(vectorY.toDouble(), vectorX.toDouble())
+    rotation = if (previousAngle.isNaN()) {
+      0.0
+    } else previousAngle - angle
+
+    previousAngle = angle
+    if (rotation > Math.PI) {
+      rotation -= Math.PI
+    } else if (rotation < -Math.PI) {
+      rotation += Math.PI
+    }
+    if (rotation > Math.PI / 2.0) {
+      rotation -= Math.PI
+    } else if (rotation < -Math.PI / 2.0) {
+      rotation += Math.PI
+    }
+  }
+
+  private fun finish() {
+    if (isInProgress) {
+      isInProgress = false
+      gestureListener?.onRotationEnd(this)
+    }
+  }
+
+  fun onTouchEvent(event: MotionEvent): Boolean {
+    when (event.actionMasked) {
+      MotionEvent.ACTION_DOWN -> {
+        isInProgress = false
+        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_MOVE -> if (isInProgress) {
+        updateCurrent(event)
+        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()
+        }
+      }
+      MotionEvent.ACTION_UP -> finish()
+    }
+    return true
+  }
+}

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

@@ -0,0 +1,93 @@
+package com.swmansion.gesturehandler.core
+
+import android.graphics.PointF
+import android.view.MotionEvent
+import com.swmansion.gesturehandler.core.RotationGestureDetector.OnRotationGestureListener
+import kotlin.math.abs
+
+class RotationGestureHandler : GestureHandler<RotationGestureHandler>() {
+  private var rotationGestureDetector: RotationGestureDetector? = null
+  var rotation = 0.0
+    private set
+  var velocity = 0.0
+    private set
+  var anchorX: Float = Float.NaN
+    private set
+  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
+      rotation += detector.rotation
+      val delta = detector.timeDelta
+      if (delta > 0) {
+        velocity = (rotation - prevRotation) / delta
+      }
+      if (abs(rotation) >= ROTATION_RECOGNITION_THRESHOLD && state == STATE_BEGAN) {
+        activate()
+      }
+      return true
+    }
+
+    override fun onRotationBegin(detector: RotationGestureDetector) = true
+
+    override fun onRotationEnd(detector: RotationGestureDetector) {
+      end()
+    }
+  }
+
+  override fun onHandle(event: MotionEvent, sourceEvent: MotionEvent) {
+    if (state == STATE_UNDETERMINED) {
+      resetProgress()
+      rotationGestureDetector = RotationGestureDetector(gestureListener)
+
+      // set the anchor to the position of the first pointer as NaN causes the event not to arrive
+      this.anchorX = event.x
+      this.anchorY = event.y
+
+      begin()
+    }
+    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 {
+        fail()
+      }
+    }
+  }
+
+  override fun activate(force: Boolean) {
+    // reset rotation if the handler has not yet activated
+    if (state != STATE_ACTIVE) {
+      resetProgress()
+    }
+    super.activate(force)
+  }
+
+  override fun onReset() {
+    rotationGestureDetector = null
+    anchorX = Float.NaN
+    anchorY = Float.NaN
+    resetProgress()
+  }
+
+  override fun resetProgress() {
+    velocity = 0.0
+    rotation = 0.0
+  }
+
+  companion object {
+    private const val ROTATION_RECOGNITION_THRESHOLD = Math.PI / 36.0 // 5 deg in radians
+  }
+}