Make FlingHandler use velocity as the activation metric.

android/src/main/java/com/swmansion/gesturehandler/core/FlingGestureHandler.kt

@@ -4,17 +4,15 @@ import android.os.Handler
 import android.os.Looper
 import android.view.MotionEvent
 import android.view.VelocityTracker
-import kotlin.math.abs
 import kotlin.math.hypot
 
 class FlingGestureHandler : GestureHandler<FlingGestureHandler>() {
   var numberOfPointersRequired = DEFAULT_NUMBER_OF_TOUCHES_REQUIRED
   var direction = DEFAULT_DIRECTION
 
   private val maxDurationMs = DEFAULT_MAX_DURATION_MS
-  private val minAcceptableDelta = DEFAULT_MIN_ACCEPTABLE_DELTA
-  private var startX = 0f
-  private var startY = 0f
+  private val minVelocity = DEFAULT_MIN_ACCEPTABLE_DELTA
+  private val minDirectionAlignment = DEFAULT_MIN_DIRECTION_ALIGNMENT
   private var handler: Handler? = null
   private var maxNumberOfPointersSimultaneously = 0
   private val failDelayed = Runnable { fail() }
@@ -26,8 +24,6 @@ class FlingGestureHandler : GestureHandler<FlingGestureHandler>() {
   }
 
   private fun startFling(event: MotionEvent) {
-    startX = event.rawX
-    startY = event.rawY
     begin()
     maxNumberOfPointersSimultaneously = 1
     if (handler == null) {
@@ -41,15 +37,10 @@ class FlingGestureHandler : GestureHandler<FlingGestureHandler>() {
   private fun tryEndFling(event: MotionEvent): Boolean {
     data class SimpleVector(val x: Double, val y: Double)
 
-    fun toSafeNumber(unsafe: Double): Double {
-      return if (unsafe.isFinite())
-        unsafe
-      else
-        0.0
-    }
+    fun toSafeNumber(unsafe: Double): Double = if (unsafe.isFinite()) unsafe else 0.0
 
     fun toUnitVector(vec: SimpleVector): SimpleVector {
-      val magnitude = abs(vec.x + vec.y)
+      val magnitude = hypot(vec.x, vec.y)
       // toSafeNumber protects against division by zero
       return SimpleVector(
         toSafeNumber(vec.x / magnitude),
@@ -67,12 +58,13 @@ class FlingGestureHandler : GestureHandler<FlingGestureHandler>() {
       return unitA.x * unitB.x + unitA.y * unitB.y
     }
 
-    val directionVector = SimpleVector(
-      (if (direction and DIRECTION_LEFT != 0) -1.0 else 0.0) +
-        (if (direction and DIRECTION_RIGHT != 0) 1.0 else 0.0),
-      (if (direction and DIRECTION_UP != 0) -1.0 else 0.0) +
-        (if (direction and DIRECTION_DOWN != 0) 1.0 else 0.0),
-    )
+    fun compareAlignment(
+      vec: SimpleVector,
+      directionVec: SimpleVector,
+      direction: Int
+    ): Boolean =
+      compareSimilarity(vec, directionVec) > minDirectionAlignment &&
+        (this.direction and direction != 0)
 
     val velocityTracker = VelocityTracker.obtain()
     addVelocityMovement(velocityTracker, event)
@@ -83,13 +75,19 @@ class FlingGestureHandler : GestureHandler<FlingGestureHandler>() {
       velocityTracker.yVelocity.toDouble()
     )
 
+    val alignmentList = arrayOf(
+      compareAlignment(velocityVector, SimpleVector(-1.0, 0.0), DIRECTION_LEFT),
+      compareAlignment(velocityVector, SimpleVector(1.0, 0.0), DIRECTION_RIGHT),
+      compareAlignment(velocityVector, SimpleVector(0.0, -1.0), DIRECTION_UP),
+      compareAlignment(velocityVector, SimpleVector(0.0, 1.0), DIRECTION_DOWN)
+    )
+
     velocityTracker.recycle()
 
-    // hypot may be overkill for this simple function, dot product may be sufficient
     val totalVelocity = hypot(velocityVector.x, velocityVector.y)
 
-    val isAligned = compareSimilarity(directionVector, velocityVector) > 0.75
-    val isFast = totalVelocity > this.minAcceptableDelta
+    val isAligned = alignmentList.reduce { any, element -> any or element }
+    val isFast = totalVelocity > this.minVelocity
 
     return if (
       maxNumberOfPointersSimultaneously == numberOfPointersRequired &&
@@ -154,6 +152,7 @@ class FlingGestureHandler : GestureHandler<FlingGestureHandler>() {
   companion object {
     private const val DEFAULT_MAX_DURATION_MS: Long = 800
     private const val DEFAULT_MIN_ACCEPTABLE_DELTA: Long = 2000
+    private const val DEFAULT_MIN_DIRECTION_ALIGNMENT: Double = 0.75
     private const val DEFAULT_DIRECTION = DIRECTION_RIGHT
     private const val DEFAULT_NUMBER_OF_TOUCHES_REQUIRED = 1
   }

src/web/handlers/FlingGestureHandler.ts

@@ -5,23 +5,28 @@ import { AdaptedEvent, Config } from '../interfaces';
 import GestureHandler from './GestureHandler';
 
 const DEFAULT_MAX_DURATION_MS = 800;
-const DEFAULT_MIN_ACCEPTABLE_DELTA = 400;
+const DEFAULT_MIN_VELOCITY = 400;
+const DEFAULT_MIN_DIRECTION_ALIGNMENT = 0.75;
 const DEFAULT_DIRECTION = Direction.RIGHT;
 const DEFAULT_NUMBER_OF_TOUCHES_REQUIRED = 1;
 
 export default class FlingGestureHandler extends GestureHandler {
   private numberOfPointersRequired = DEFAULT_NUMBER_OF_TOUCHES_REQUIRED;
   private direction = DEFAULT_DIRECTION;
+  private shouldCancelWhenOutside = false;
 
   private maxDurationMs = DEFAULT_MAX_DURATION_MS;
-  private minAcceptableDelta = DEFAULT_MIN_ACCEPTABLE_DELTA;
+  private minVelocity = DEFAULT_MIN_VELOCITY;
+  private minDirectionAlignment = DEFAULT_MIN_DIRECTION_ALIGNMENT;
   private delayTimeout!: number;
 
   private maxNumberOfPointersSimultaneously = 0;
   private keyPointer = NaN;
 
   public init(ref: number, propsRef: React.RefObject<unknown>): void {
     super.init(ref, propsRef);
+
+    this.setShouldCancelWhenOutside(this.shouldCancelWhenOutside);
   }
 
   public updateGestureConfig({ enabled = true, ...props }: Config): void {
@@ -52,7 +57,7 @@ export default class FlingGestureHandler extends GestureHandler {
     };
 
     const toUnitVector = (vec: SimpleVector): SimpleVector => {
-      const magnitude = Math.abs(vec.x + vec.y);
+      const magnitude = Math.hypot(vec.x, vec.y);
       // division by 0 may occur here
       return {
         x: toSafeNumber(vec.x / magnitude),
@@ -70,29 +75,34 @@ export default class FlingGestureHandler extends GestureHandler {
       return unitA.x * unitB.x + unitA.y * unitB.y;
     };
 
-    const directionVector: SimpleVector = {
-      x:
-        (this.direction & Direction.LEFT ? -1 : 0) +
-        (this.direction & Direction.RIGHT ? 1 : 0),
-      y:
-        (this.direction & Direction.UP ? -1 : 0) +
-        (this.direction & Direction.DOWN ? 1 : 0),
+    const compareAlignment = (
+      vec: SimpleVector,
+      directionVec: SimpleVector,
+      direction: number
+    ): boolean => {
+      return !!(
+        compareSimilarity(vec, directionVec) > this.minDirectionAlignment &&
+        this.direction & direction
+      );
     };
 
     const velocityVector: SimpleVector = {
       x: this.tracker.getVelocityX(this.keyPointer),
       y: this.tracker.getVelocityY(this.keyPointer),
     };
 
-    // hypot may be overkill for this simple function, simple addition would be sufficient
+    // list of alignments to all activated directions
+    const alignmentList = [
+      compareAlignment(velocityVector, { x: -1, y: 0 }, Direction.LEFT),
+      compareAlignment(velocityVector, { x: 1, y: 0 }, Direction.RIGHT),
+      compareAlignment(velocityVector, { x: 0, y: -1 }, Direction.UP),
+      compareAlignment(velocityVector, { x: 0, y: 1 }, Direction.DOWN),
+    ];
+
     const totalVelocity = Math.hypot(velocityVector.x, velocityVector.y);
 
-    const movementAlignment = compareSimilarity(
-      directionVector,
-      velocityVector
-    );
-    const isAligned = movementAlignment > 0.75;
-    const isFast = totalVelocity > this.minAcceptableDelta;
+    const isAligned = alignmentList.reduce((any, element) => any || element);
+    const isFast = totalVelocity > this.minVelocity;
 
     if (
       this.maxNumberOfPointersSimultaneously ===