react-native-gesture-handler 1.10.3 → 2.2.0

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

@@ -0,0 +1,125 @@
+package com.swmansion.gesturehandler
+
+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/lib/src/main/java/com/swmansion/gesturehandler/RotationGestureHandler.kt

@@ -0,0 +1,81 @@
+package com.swmansion.gesturehandler
+
+import android.view.MotionEvent
+import com.swmansion.gesturehandler.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
+
+  val anchorX: Float
+    get() = rotationGestureDetector?.anchorX ?: Float.NaN
+  val anchorY: Float
+    get() = rotationGestureDetector?.anchorY ?: Float.NaN
+
+  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) {
+    if (state == STATE_UNDETERMINED) {
+      resetProgress()
+      rotationGestureDetector = RotationGestureDetector(gestureListener)
+      begin()
+    }
+    rotationGestureDetector?.onTouchEvent(event)
+    if (event.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
+    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
+  }
+}

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

@@ -0,0 +1,167 @@
+package com.swmansion.gesturehandler
+
+import android.os.Handler
+import android.view.MotionEvent
+import com.swmansion.gesturehandler.GestureUtils.getLastPointerX
+import com.swmansion.gesturehandler.GestureUtils.getLastPointerY
+import kotlin.math.abs
+
+class TapGestureHandler : GestureHandler<TapGestureHandler>() {
+  private var maxDeltaX = MAX_VALUE_IGNORE
+  private var maxDeltaY = MAX_VALUE_IGNORE
+  private var maxDistSq = MAX_VALUE_IGNORE
+  private var maxDurationMs = DEFAULT_MAX_DURATION_MS
+  private var maxDelayMs = DEFAULT_MAX_DELAY_MS
+  private var numberOfTaps = DEFAULT_NUMBER_OF_TAPS
+  private var minNumberOfPointers = DEFAULT_MIN_NUMBER_OF_POINTERS
+  private var currentMaxNumberOfPointers = 1
+  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 handler: Handler? = null
+  private var tapsSoFar = 0
+  private val failDelayed = Runnable { fail() }
+
+  init {
+    setShouldCancelWhenOutside(true)
+  }
+
+  override fun resetConfig() {
+    super.resetConfig()
+    maxDeltaX = MAX_VALUE_IGNORE
+    maxDeltaY = MAX_VALUE_IGNORE
+    maxDistSq = MAX_VALUE_IGNORE
+    maxDurationMs = DEFAULT_MAX_DURATION_MS
+    maxDelayMs = DEFAULT_MAX_DELAY_MS
+    numberOfTaps = DEFAULT_NUMBER_OF_TAPS
+    minNumberOfPointers = DEFAULT_MIN_NUMBER_OF_POINTERS
+  }
+
+  fun setNumberOfTaps(numberOfTaps: Int) = apply {
+    this.numberOfTaps = numberOfTaps
+  }
+
+  fun setMaxDelayMs(maxDelayMs: Long) = apply {
+    this.maxDelayMs = maxDelayMs
+  }
+
+  fun setMaxDurationMs(maxDurationMs: Long) = apply {
+    this.maxDurationMs = maxDurationMs
+  }
+
+  fun setMaxDx(deltaX: Float) = apply {
+    maxDeltaX = deltaX
+  }
+
+  fun setMaxDy(deltaY: Float) = apply {
+    maxDeltaY = deltaY
+  }
+
+  fun setMaxDist(maxDist: Float) = apply {
+    maxDistSq = maxDist * maxDist
+  }
+
+  fun setMinNumberOfPointers(minNumberOfPointers: Int) = apply {
+    this.minNumberOfPointers = minNumberOfPointers
+  }
+
+  private fun startTap() {
+    if (handler == null) {
+      handler = Handler() // TODO: lazy init (handle else branch correctly)
+    } else {
+      handler!!.removeCallbacksAndMessages(null)
+    }
+    handler!!.postDelayed(failDelayed, maxDurationMs)
+  }
+
+  private fun endTap() {
+    if (handler == null) {
+      handler = Handler()
+    } else {
+      handler!!.removeCallbacksAndMessages(null)
+    }
+    if (++tapsSoFar == numberOfTaps && currentMaxNumberOfPointers >= minNumberOfPointers) {
+      activate()
+    } else {
+      handler!!.postDelayed(failDelayed, maxDelayMs)
+    }
+  }
+
+  private fun shouldFail(): Boolean {
+    val dx = lastX - startX + offsetX
+    if (maxDeltaX != MAX_VALUE_IGNORE && abs(dx) > maxDeltaX) {
+      return true
+    }
+    val dy = lastY - startY + offsetY
+    if (maxDeltaY != MAX_VALUE_IGNORE && abs(dy) > maxDeltaY) {
+      return true
+    }
+    val dist = dy * dy + dx * dx
+    return maxDistSq != MAX_VALUE_IGNORE && dist > maxDistSq
+  }
+
+  override fun onHandle(event: MotionEvent) {
+    val state = state
+    val action = event.actionMasked
+    if (state == STATE_UNDETERMINED) {
+      offsetX = 0f
+      offsetY = 0f
+      startX = event.rawX
+      startY = event.rawY
+    }
+    if (action == MotionEvent.ACTION_POINTER_UP || action == MotionEvent.ACTION_POINTER_DOWN) {
+      offsetX += lastX - startX
+      offsetY += lastY - startY
+      lastX = getLastPointerX(event, true)
+      lastY = getLastPointerY(event, true)
+      startX = lastX
+      startY = lastY
+    } else {
+      lastX = getLastPointerX(event, true)
+      lastY = getLastPointerY(event, true)
+    }
+    if (currentMaxNumberOfPointers < event.pointerCount) {
+      currentMaxNumberOfPointers = event.pointerCount
+    }
+    if (shouldFail()) {
+      fail()
+    } else if (state == STATE_UNDETERMINED) {
+      if (action == MotionEvent.ACTION_DOWN) {
+        begin()
+      }
+      startTap()
+    } else if (state == STATE_BEGAN) {
+      if (action == MotionEvent.ACTION_UP) {
+        endTap()
+      } else if (action == MotionEvent.ACTION_DOWN) {
+        startTap()
+      }
+    }
+  }
+
+  override fun activate(force: Boolean) {
+    super.activate(force)
+    end()
+  }
+
+  override fun onCancel() {
+    handler?.removeCallbacksAndMessages(null)
+  }
+
+  override fun onReset() {
+    tapsSoFar = 0
+    currentMaxNumberOfPointers = 0
+    handler?.removeCallbacksAndMessages(null)
+  }
+
+  companion object {
+    private const val MAX_VALUE_IGNORE = Float.MIN_VALUE
+    private const val DEFAULT_MAX_DURATION_MS: Long = 500
+    private const val DEFAULT_MAX_DELAY_MS: Long = 200
+    private const val DEFAULT_NUMBER_OF_TAPS = 1
+    private const val DEFAULT_MIN_NUMBER_OF_POINTERS = 1
+  }
+}

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

@@ -0,0 +1,10 @@
+package com.swmansion.gesturehandler
+
+import android.view.View
+import android.view.ViewGroup
+
+interface ViewConfigurationHelper {
+  fun getPointerEventsConfigForView(view: View): PointerEventsConfig
+  fun getChildInDrawingOrderAtIndex(parent: ViewGroup, index: Int): View
+  fun isViewClippingChildren(view: ViewGroup): Boolean
+}