@amazon-devices/react-native-gesture-handler 2.0.1758683737 → 4.0.0

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

@@ -0,0 +1,103 @@
+package com.swmansion.gesturehandler.core
+
+import android.view.MotionEvent
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReadableMap
+import kotlin.math.PI
+import kotlin.math.abs
+import kotlin.math.atan
+import kotlin.math.cos
+import kotlin.math.round
+import kotlin.math.sin
+import kotlin.math.tan
+
+data class StylusData(
+  val tiltX: Double = 0.0,
+  val tiltY: Double = 0.0,
+  val altitudeAngle: Double = 0.0,
+  val azimuthAngle: Double = 0.0,
+  val pressure: Double = -1.0,
+) {
+  fun toReadableMap(): ReadableMap {
+    val stylusDataObject = Arguments.createMap().apply {
+      putDouble("tiltX", tiltX)
+      putDouble("tiltY", tiltY)
+      putDouble("altitudeAngle", altitudeAngle)
+      putDouble("azimuthAngle", azimuthAngle)
+      putDouble("pressure", pressure)
+    }
+
+    val readableStylusData: ReadableMap = stylusDataObject
+
+    return readableStylusData
+  }
+
+  companion object {
+    // Source: https://w3c.github.io/pointerevents/#converting-between-tiltx-tilty-and-altitudeangle-azimuthangle
+    private fun spherical2tilt(altitudeAngle: Double, azimuthAngle: Double): Pair<Double, Double> {
+      val eps = 0.000000001
+      val radToDeg = 180 / PI
+
+      var tiltXrad = 0.0
+      var tiltYrad = 0.0
+
+      if (altitudeAngle < eps) {
+        // the pen is in the X-Y plane
+        if (azimuthAngle < eps || abs(azimuthAngle - 2 * PI) < eps) {
+          // pen is on positive X axis
+          tiltXrad = PI / 2
+        }
+        if (abs(azimuthAngle - PI / 2) < eps) {
+          // pen is on positive Y axis
+          tiltYrad = PI / 2
+        }
+        if (abs(azimuthAngle - PI) < eps) {
+          // pen is on negative X axis
+          tiltXrad = -PI / 2
+        }
+        if (abs(azimuthAngle - (3 * PI) / 2) < eps) {
+          // pen is on negative Y axis
+          tiltYrad = -PI / 2
+        }
+        if (azimuthAngle > eps && abs(azimuthAngle - PI / 2) < eps) {
+          tiltXrad = PI / 2
+          tiltYrad = PI / 2
+        }
+        if (abs(azimuthAngle - PI / 2) > eps && abs(azimuthAngle - PI) < eps) {
+          tiltXrad = -PI / 2
+          tiltYrad = PI / 2
+        }
+        if (abs(azimuthAngle - PI) > eps && abs(azimuthAngle - (3 * PI) / 2) < eps) {
+          tiltXrad = -PI / 2
+          tiltYrad = -PI / 2
+        }
+        if (abs(azimuthAngle - (3 * PI) / 2) > eps && abs(azimuthAngle - 2 * PI) < eps) {
+          tiltXrad = PI / 2
+          tiltYrad = -PI / 2
+        }
+      } else {
+        val tanAlt = tan(altitudeAngle)
+
+        tiltXrad = atan(cos(azimuthAngle) / tanAlt)
+        tiltYrad = atan(sin(azimuthAngle) / tanAlt)
+      }
+
+      val tiltX = round(tiltXrad * radToDeg)
+      val tiltY = round(tiltYrad * radToDeg)
+
+      return Pair(tiltX, tiltY)
+    }
+
+    fun fromEvent(event: MotionEvent): StylusData {
+      // On web and iOS 0 degrees means that stylus is parallel to the surface. On android this value will be PI / 2.
+      val altitudeAngle = (PI / 2) - event.getAxisValue(MotionEvent.AXIS_TILT).toDouble()
+      val pressure = event.getPressure(0).toDouble()
+      val orientation = event.getOrientation(0).toDouble()
+      // To get azimuth angle, we need to use orientation property (https://developer.android.com/develop/ui/compose/touch-input/stylus-input/advanced-stylus-features#orientation).
+      val azimuthAngle = (orientation + PI / 2).mod(2 * PI)
+      val tilts = spherical2tilt(altitudeAngle, azimuthAngle)
+
+      return StylusData(tilts.first, tilts.second, altitudeAngle, azimuthAngle, pressure)
+    }
+  }
+}

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

@@ -1,16 +1,20 @@
 package com.swmansion.gesturehandler.core
 
+import android.content.Context
 import android.os.Handler
 import android.os.Looper
 import android.view.MotionEvent
+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.TapGestureHandlerEventDataBuilder
 import kotlin.math.abs
 
-class TapGestureHandler : GestureHandler<TapGestureHandler>() {
+class TapGestureHandler : GestureHandler() {
   private var maxDeltaX = MAX_VALUE_IGNORE
   private var maxDeltaY = MAX_VALUE_IGNORE
-  private var maxDistSq = MAX_VALUE_IGNORE
+  private var maxDist = MAX_VALUE_IGNORE
   private var maxDurationMs = DEFAULT_MAX_DURATION_MS
   private var maxDelayMs = DEFAULT_MAX_DELAY_MS
   private var numberOfTaps = DEFAULT_NUMBER_OF_TAPS
@@ -27,46 +31,19 @@ class TapGestureHandler : GestureHandler<TapGestureHandler>() {
   private val failDelayed = Runnable { fail() }
 
   init {
-    setShouldCancelWhenOutside(true)
+    shouldCancelWhenOutside = true
   }
 
   override fun resetConfig() {
     super.resetConfig()
     maxDeltaX = MAX_VALUE_IGNORE
     maxDeltaY = MAX_VALUE_IGNORE
-    maxDistSq = MAX_VALUE_IGNORE
+    maxDist = 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
+    shouldCancelWhenOutside = DEFAULT_SHOULD_CANCEL_WHEN_OUTSIDE
   }
 
   private fun startTap() {
@@ -101,10 +78,14 @@ class TapGestureHandler : GestureHandler<TapGestureHandler>() {
       return true
     }
     val dist = dy * dy + dx * dx
-    return maxDistSq != MAX_VALUE_IGNORE && dist > maxDistSq
+    return maxDist != MAX_VALUE_IGNORE && dist > maxDist * maxDist
   }
 
   override fun onHandle(event: MotionEvent, sourceEvent: MotionEvent) {
+    if (!shouldActivateWithMouse(sourceEvent)) {
+      return
+    }
+
     val state = state
     val action = sourceEvent.actionMasked
     if (state == STATE_UNDETERMINED) {
@@ -130,14 +111,14 @@ class TapGestureHandler : GestureHandler<TapGestureHandler>() {
     if (shouldFail()) {
       fail()
     } else if (state == STATE_UNDETERMINED) {
-      if (action == MotionEvent.ACTION_DOWN) {
+      if (action == MotionEvent.ACTION_DOWN || action == MotionEvent.ACTION_BUTTON_PRESS) {
         begin()
       }
       startTap()
     } else if (state == STATE_BEGAN) {
-      if (action == MotionEvent.ACTION_UP) {
+      if (action == MotionEvent.ACTION_UP || action == MotionEvent.ACTION_BUTTON_RELEASE) {
         endTap()
-      } else if (action == MotionEvent.ACTION_DOWN) {
+      } else if (action == MotionEvent.ACTION_DOWN || action == MotionEvent.ACTION_BUTTON_PRESS) {
         startTap()
       }
     }
@@ -158,11 +139,56 @@ class TapGestureHandler : GestureHandler<TapGestureHandler>() {
     handler?.removeCallbacksAndMessages(null)
   }
 
+  class Factory : GestureHandler.Factory<TapGestureHandler>() {
+    override val type = TapGestureHandler::class.java
+    override val name = "TapGestureHandler"
+
+    override fun create(context: Context?): TapGestureHandler = TapGestureHandler()
+
+    override fun setConfig(handler: TapGestureHandler, config: ReadableMap) {
+      super.setConfig(handler, config)
+      if (config.hasKey(KEY_NUMBER_OF_TAPS)) {
+        handler.numberOfTaps = config.getInt(KEY_NUMBER_OF_TAPS)
+      }
+      if (config.hasKey(KEY_MAX_DURATION_MS)) {
+        handler.maxDurationMs = config.getInt(KEY_MAX_DURATION_MS).toLong()
+      }
+      if (config.hasKey(KEY_MAX_DELAY_MS)) {
+        handler.maxDelayMs = config.getInt(KEY_MAX_DELAY_MS).toLong()
+      }
+      if (config.hasKey(KEY_MAX_DELTA_X)) {
+        handler.maxDeltaX = PixelUtil.toPixelFromDIP(config.getDouble(KEY_MAX_DELTA_X))
+      }
+      if (config.hasKey(KEY_MAX_DELTA_Y)) {
+        handler.maxDeltaY = PixelUtil.toPixelFromDIP(config.getDouble(KEY_MAX_DELTA_Y))
+      }
+      if (config.hasKey(KEY_MAX_DIST)) {
+        handler.maxDist = PixelUtil.toPixelFromDIP(config.getDouble(KEY_MAX_DIST))
+      }
+      if (config.hasKey(KEY_MIN_POINTERS)) {
+        handler.minNumberOfPointers = config.getInt(KEY_MIN_POINTERS)
+      }
+    }
+
+    override fun createEventBuilder(handler: TapGestureHandler) = TapGestureHandlerEventDataBuilder(handler)
+
+    companion object {
+      private const val KEY_NUMBER_OF_TAPS = "numberOfTaps"
+      private const val KEY_MAX_DURATION_MS = "maxDurationMs"
+      private const val KEY_MAX_DELAY_MS = "maxDelayMs"
+      private const val KEY_MAX_DELTA_X = "maxDeltaX"
+      private const val KEY_MAX_DELTA_Y = "maxDeltaY"
+      private const val KEY_MAX_DIST = "maxDist"
+      private const val KEY_MIN_POINTERS = "minPointers"
+    }
+  }
+
   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
+    private const val DEFAULT_SHOULD_CANCEL_WHEN_OUTSIDE = true
   }
 }

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

@@ -0,0 +1,61 @@
+package com.swmansion.gesturehandler.core
+
+import android.view.VelocityTracker
+import com.swmansion.gesturehandler.core.GestureHandler.Companion.DIRECTION_DOWN
+import com.swmansion.gesturehandler.core.GestureHandler.Companion.DIRECTION_LEFT
+import com.swmansion.gesturehandler.core.GestureHandler.Companion.DIRECTION_RIGHT
+import com.swmansion.gesturehandler.core.GestureHandler.Companion.DIRECTION_UP
+import kotlin.math.hypot
+
+class Vector(val x: Double, val y: Double) {
+  private val unitX: Double
+  private val unitY: Double
+  val magnitude = hypot(x, y)
+
+  init {
+    val isMagnitudeSufficient = magnitude > MINIMAL_RECOGNIZABLE_MAGNITUDE
+
+    unitX = if (isMagnitudeSufficient) x / magnitude else 0.0
+    unitY = if (isMagnitudeSufficient) y / magnitude else 0.0
+  }
+
+  private fun computeSimilarity(vector: Vector): Double = unitX * vector.unitX + unitY * vector.unitY
+
+  fun isSimilar(vector: Vector, threshold: Double): Boolean = computeSimilarity(vector) > threshold
+
+  companion object {
+    private val VECTOR_LEFT: Vector = Vector(-1.0, 0.0)
+    private val VECTOR_RIGHT: Vector = Vector(1.0, 0.0)
+    private val VECTOR_UP: Vector = Vector(0.0, -1.0)
+    private val VECTOR_DOWN: Vector = Vector(0.0, 1.0)
+
+    private val VECTOR_RIGHT_UP: Vector = Vector(1.0, -1.0)
+    private val VECTOR_RIGHT_DOWN: Vector = Vector(1.0, 1.0)
+    private val VECTOR_LEFT_UP: Vector = Vector(-1.0, -1.0)
+    private val VECTOR_LEFT_DOWN: Vector = Vector(-1.0, 1.0)
+
+    private val VECTOR_ZERO: Vector = Vector(0.0, 0.0)
+    private const val MINIMAL_RECOGNIZABLE_MAGNITUDE = 0.1
+
+    fun fromDirection(direction: Int): Vector = when (direction) {
+      DIRECTION_LEFT -> VECTOR_LEFT
+      DIRECTION_RIGHT -> VECTOR_RIGHT
+      DIRECTION_UP -> VECTOR_UP
+      DIRECTION_DOWN -> VECTOR_DOWN
+      DiagonalDirections.DIRECTION_RIGHT_UP -> VECTOR_RIGHT_UP
+      DiagonalDirections.DIRECTION_RIGHT_DOWN -> VECTOR_RIGHT_DOWN
+      DiagonalDirections.DIRECTION_LEFT_UP -> VECTOR_LEFT_UP
+      DiagonalDirections.DIRECTION_LEFT_DOWN -> VECTOR_LEFT_DOWN
+      else -> VECTOR_ZERO
+    }
+
+    fun fromVelocity(tracker: VelocityTracker): Vector {
+      tracker.computeCurrentVelocity(1000)
+
+      val velocityX = tracker.xVelocity.toDouble()
+      val velocityY = tracker.yVelocity.toDouble()
+
+      return Vector(velocityX, velocityY)
+    }
+  }
+}

package/android/src/main/java/com/swmansion/gesturehandler/react/Extensions.kt

@@ -13,4 +13,4 @@ val ReactContext.UIManager: UIManagerModule
   get() = this.getNativeModule(UIManagerModule::class.java)!!
 
 fun Context.isScreenReaderOn() =
-  (getSystemService(Context.ACCESSIBILITY_SERVICE) as AccessibilityManager).isEnabled
+  (getSystemService(Context.ACCESSIBILITY_SERVICE) as AccessibilityManager).isTouchExplorationEnabled