@react-native-oh-tpl/react-native-gesture-handler 2.12.1-0.0.1 → 2.12.6-1

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

@@ -1,322 +0,0 @@
-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

@@ -1,103 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,125 +0,0 @@
-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

@@ -1,93 +0,0 @@
-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
-  }
-}