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

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

@@ -1,8 +1,8 @@
 package com.swmansion.gesturehandler.core
 
 interface GestureHandlerInteractionController {
-  fun shouldWaitForHandlerFailure(handler: GestureHandler<*>, otherHandler: GestureHandler<*>): Boolean
-  fun shouldRequireHandlerToWaitForFailure(handler: GestureHandler<*>, otherHandler: GestureHandler<*>): Boolean
-  fun shouldRecognizeSimultaneously(handler: GestureHandler<*>, otherHandler: GestureHandler<*>): Boolean
-  fun shouldHandlerBeCancelledBy(handler: GestureHandler<*>, otherHandler: GestureHandler<*>): Boolean
+  fun shouldWaitForHandlerFailure(handler: GestureHandler, otherHandler: GestureHandler): Boolean
+  fun shouldRequireHandlerToWaitForFailure(handler: GestureHandler, otherHandler: GestureHandler): Boolean
+  fun shouldRecognizeSimultaneously(handler: GestureHandler, otherHandler: GestureHandler): Boolean
+  fun shouldHandlerBeCancelledBy(handler: GestureHandler, otherHandler: GestureHandler): Boolean
 }

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

@@ -6,6 +6,7 @@ import android.view.MotionEvent
 import android.view.View
 import android.view.ViewGroup
 import android.widget.EditText
+import com.swmansion.gesturehandler.react.RNGestureHandlerRootHelper
 import java.util.*
 
 class GestureHandlerOrchestrator(
@@ -19,13 +20,17 @@ class GestureHandlerOrchestrator(
    * traversing view hierarchy and looking for gesture handlers.
    */
   var minimumAlphaForTraversal = DEFAULT_MIN_ALPHA_FOR_TRAVERSAL
+  private val gestureHandlers = arrayListOf<GestureHandler>()
+  private val awaitingHandlers = arrayListOf<GestureHandler>()
+  private val preparedHandlers = arrayListOf<GestureHandler>()
+
+  // In `onHandlerStateChange` method we iterate through `awaitingHandlers`, but calling `tryActivate` may modify this list.
+  // To avoid `ConcurrentModificationException` we iterate through copy. There is one more problem though - if handler was
+  // removed from `awaitingHandlers`, it was still present in copy of original list. This hashset helps us identify which handlers
+  // are really inside `awaitingHandlers`.
+  // `contains` method on HashSet has O(1) complexity, so calling it inside for loop won't result in O(n^2) (contrary to ArrayList)
+  private val awaitingHandlersTags = HashSet<Int>()
 
-  private val gestureHandlers = arrayOfNulls<GestureHandler<*>?>(SIMULTANEOUS_GESTURE_HANDLER_LIMIT)
-  private val awaitingHandlers = arrayOfNulls<GestureHandler<*>?>(SIMULTANEOUS_GESTURE_HANDLER_LIMIT)
-  private val preparedHandlers = arrayOfNulls<GestureHandler<*>?>(SIMULTANEOUS_GESTURE_HANDLER_LIMIT)
-  private val handlersToCancel = arrayOfNulls<GestureHandler<*>?>(SIMULTANEOUS_GESTURE_HANDLER_LIMIT)
-  private var gestureHandlersCount = 0
-  private var awaitingHandlersCount = 0
   private var isHandlingTouch = false
   private var handlingChangeSemaphore = 0
   private var finishedHandlersCleanupScheduled = false
@@ -37,7 +42,10 @@ class GestureHandlerOrchestrator(
   fun onTouchEvent(event: MotionEvent): Boolean {
     isHandlingTouch = true
     val action = event.actionMasked
-    if (action == MotionEvent.ACTION_DOWN || action == MotionEvent.ACTION_POINTER_DOWN || action == MotionEvent.ACTION_HOVER_MOVE) {
+    if (action == MotionEvent.ACTION_DOWN ||
+      action == MotionEvent.ACTION_POINTER_DOWN ||
+      action == MotionEvent.ACTION_HOVER_MOVE
+    ) {
       extractGestureHandlers(event)
     } else if (action == MotionEvent.ACTION_CANCEL) {
       cancelAll()
@@ -60,23 +68,9 @@ class GestureHandlerOrchestrator(
     }
   }
 
-  private inline fun compactHandlersIf(handlers: Array<GestureHandler<*>?>, count: Int, predicate: (handler: GestureHandler<*>?) -> Boolean): Int {
-    var out = 0
-    for (i in 0 until count) {
-      if (predicate(handlers[i])) {
-        handlers[out++] = handlers[i]
-      }
-    }
-    return out
-  }
-
   private fun cleanupFinishedHandlers() {
-    var shouldCleanEmptyCells = false
-    for (i in gestureHandlersCount - 1 downTo 0) {
-      val handler = gestureHandlers[i]!!
+    for (handler in gestureHandlers.asReversed()) {
       if (isFinished(handler.state) && !handler.isAwaiting) {
-        gestureHandlers[i] = null
-        shouldCleanEmptyCells = true
         handler.reset()
         handler.apply {
           isActive = false
@@ -85,25 +79,32 @@ class GestureHandlerOrchestrator(
         }
       }
     }
-    if (shouldCleanEmptyCells) {
-      gestureHandlersCount = compactHandlersIf(gestureHandlers, gestureHandlersCount) { handler ->
-        handler != null
-      }
-    }
+
+    gestureHandlers.removeAll { isFinished(it.state) && !it.isAwaiting }
+
     finishedHandlersCleanupScheduled = false
   }
 
-  private fun hasOtherHandlerToWaitFor(handler: GestureHandler<*>): Boolean {
-    for (i in 0 until gestureHandlersCount) {
-      val otherHandler = gestureHandlers[i]!!
-      if (!isFinished(otherHandler.state) && shouldHandlerWaitForOther(handler, otherHandler)) {
-        return true
-      }
-    }
-    return false
+  private fun hasOtherHandlerToWaitFor(handler: GestureHandler) =
+    gestureHandlers.any { !isFinished(it.state) && shouldHandlerWaitForOther(handler, it) }
+
+  private fun shouldBeCancelledByFinishedHandler(handler: GestureHandler) =
+    gestureHandlers.any { shouldHandlerWaitForOther(handler, it) && it.state == GestureHandler.STATE_END }
+
+  private fun shouldBeCancelledByActiveHandler(handler: GestureHandler) = gestureHandlers.any {
+    handler.hasCommonPointers(it) &&
+      it.state == GestureHandler.STATE_ACTIVE &&
+      !canRunSimultaneously(handler, it) &&
+      handler.isDescendantOf(it)
   }
 
-  private fun tryActivate(handler: GestureHandler<*>) {
+  private fun tryActivate(handler: GestureHandler) {
+    // If we are waiting for a gesture that has successfully finished, we should cancel handler
+    if (shouldBeCancelledByFinishedHandler(handler) || shouldBeCancelledByActiveHandler(handler)) {
+      handler.cancel()
+      return
+    }
+
     // see if there is anyone else who we need to wait for
     if (hasOtherHandlerToWaitFor(handler)) {
       addAwaitingHandler(handler)
@@ -115,37 +116,49 @@ class GestureHandlerOrchestrator(
   }
 
   private fun cleanupAwaitingHandlers() {
-    awaitingHandlersCount = compactHandlersIf(awaitingHandlers, awaitingHandlersCount) { handler ->
-      handler!!.isAwaiting
+    val awaitingHandlersCopy = awaitingHandlers.toList()
+
+    for (handler in awaitingHandlersCopy) {
+      if (!handler.isAwaiting) {
+        awaitingHandlers.remove(handler)
+        awaitingHandlersTags.remove(handler.tag)
+      }
     }
   }
 
   /*package*/
-  fun onHandlerStateChange(handler: GestureHandler<*>, newState: Int, prevState: Int) {
+  fun onHandlerStateChange(handler: GestureHandler, newState: Int, prevState: Int) {
     handlingChangeSemaphore += 1
     if (isFinished(newState)) {
+      // We have to loop through copy in order to avoid modifying collection
+      // while iterating over its elements
+      val currentlyAwaitingHandlers = awaitingHandlers.toList()
+
       // if there were handlers awaiting completion of this handler, we can trigger active state
-      for (i in 0 until awaitingHandlersCount) {
-        val otherHandler = awaitingHandlers[i]
-        if (shouldHandlerWaitForOther(otherHandler!!, handler)) {
-          if (newState == GestureHandler.STATE_END) {
-            // gesture has ended, we need to kill the awaiting handler
-            otherHandler.cancel()
-            if (otherHandler.state == GestureHandler.STATE_END) {
-              // Handle edge case, where discrete gestures end immediately after activation thus
-              // their state is set to END and when the gesture they are waiting for activates they
-              // should be cancelled, however `cancel` was never sent as gestures were already in the END state.
-              // Send synthetic BEGAN -> CANCELLED to properly handle JS logic
-              otherHandler.dispatchStateChange(
-                GestureHandler.STATE_CANCELLED,
-                GestureHandler.STATE_BEGAN
-              )
-            }
-            otherHandler.isAwaiting = false
-          } else {
-            // gesture has failed recognition, we may try activating
-            tryActivate(otherHandler)
+      for (otherHandler in currentlyAwaitingHandlers) {
+        if (!shouldHandlerWaitForOther(otherHandler, handler) ||
+          !awaitingHandlersTags.contains(otherHandler.tag)
+        ) {
+          continue
+        }
+
+        if (newState == GestureHandler.STATE_END) {
+          // gesture has ended, we need to kill the awaiting handler
+          otherHandler.cancel()
+          if (otherHandler.state == GestureHandler.STATE_END) {
+            // Handle edge case, where discrete gestures end immediately after activation thus
+            // their state is set to END and when the gesture they are waiting for activates they
+            // should be cancelled, however `cancel` was never sent as gestures were already in the END state.
+            // Send synthetic BEGAN -> CANCELLED to properly handle JS logic
+            otherHandler.dispatchStateChange(
+              GestureHandler.STATE_CANCELLED,
+              GestureHandler.STATE_BEGAN,
+            )
           }
+          otherHandler.isAwaiting = false
+        } else {
+          // gesture has failed recognition, we may try activating
+          tryActivate(otherHandler)
         }
       }
       cleanupAwaitingHandlers()
@@ -155,7 +168,9 @@ class GestureHandlerOrchestrator(
     } else if (prevState == GestureHandler.STATE_ACTIVE || prevState == GestureHandler.STATE_END) {
       if (handler.isActive) {
         handler.dispatchStateChange(newState, prevState)
-      } else if (prevState == GestureHandler.STATE_ACTIVE && (newState == GestureHandler.STATE_CANCELLED || newState == GestureHandler.STATE_FAILED)) {
+      } else if (prevState == GestureHandler.STATE_ACTIVE &&
+        (newState == GestureHandler.STATE_CANCELLED || newState == GestureHandler.STATE_FAILED)
+      ) {
         // Handle edge case where handler awaiting for another one tries to activate but finishes
         // before the other would not send state change event upon ending. Note that we only want
         // to do this if the newState is either CANCELLED or FAILED, if it is END we still want to
@@ -163,7 +178,9 @@ class GestureHandlerOrchestrator(
         // makeActive method.
         handler.dispatchStateChange(newState, GestureHandler.STATE_BEGAN)
       }
-    } else if (prevState != GestureHandler.STATE_UNDETERMINED || newState != GestureHandler.STATE_CANCELLED) {
+    } else if (prevState != GestureHandler.STATE_UNDETERMINED ||
+      newState != GestureHandler.STATE_CANCELLED
+    ) {
       // If handler is changing state from UNDETERMINED to CANCELLED, the state change event shouldn't
       // be sent. Handler hasn't yet began so it may not be initialized which results in crashes.
       // If it doesn't crash, there may be some weird behavior on JS side, as `onFinalize` will be
@@ -174,7 +191,7 @@ class GestureHandlerOrchestrator(
     scheduleFinishedHandlersCleanup()
   }
 
-  private fun makeActive(handler: GestureHandler<*>) {
+  private fun makeActive(handler: GestureHandler) {
     val currentState = handler.state
     with(handler) {
       isAwaiting = false
@@ -182,31 +199,36 @@ class GestureHandlerOrchestrator(
       shouldResetProgress = true
       activationIndex = this@GestureHandlerOrchestrator.activationIndex++
     }
-    var toCancelCount = 0
-    // Cancel all handlers that are required to be cancel upon current handler's activation
-    for (i in 0 until gestureHandlersCount) {
-      val otherHandler = gestureHandlers[i]!!
+
+    for (otherHandler in gestureHandlers.asReversed()) {
       if (shouldHandlerBeCancelledBy(otherHandler, handler)) {
-        handlersToCancel[toCancelCount++] = otherHandler
+        otherHandler.cancel()
       }
     }
-    for (i in toCancelCount - 1 downTo 0) {
-      handlersToCancel[i]!!.cancel()
-    }
 
     // Clear all awaiting handlers waiting for the current handler to fail
-    for (i in awaitingHandlersCount - 1 downTo 0) {
-      val otherHandler = awaitingHandlers[i]!!
+    for (otherHandler in awaitingHandlers.asReversed()) {
       if (shouldHandlerBeCancelledBy(otherHandler, handler)) {
-        otherHandler.cancel()
         otherHandler.isAwaiting = false
       }
     }
     cleanupAwaitingHandlers()
 
-    // Dispatch state change event if handler is no longer in the active state we should also
-    // trigger END state change and UNDETERMINED state change if necessary
+    // At this point the waiting handler is allowed to activate, so we need to send BEGAN -> ACTIVE event
+    // as it wasn't sent before. If handler has finished recognizing the gesture before it was allowed to
+    // activate, we also need to send ACTIVE -> END and END -> UNDETERMINED events, as it was blocked from
+    // sending events while waiting.
+    // There is one catch though - if the handler failed or was cancelled while waiting, relevant event has
+    // already been sent. The following chain would result in artificially activating that handler after the
+    // failure logic was ran and we don't want to do that.
+    if (currentState == GestureHandler.STATE_FAILED ||
+      currentState == GestureHandler.STATE_CANCELLED
+    ) {
+      return
+    }
+
     handler.dispatchStateChange(GestureHandler.STATE_ACTIVE, GestureHandler.STATE_BEGAN)
+
     if (currentState != GestureHandler.STATE_ACTIVE) {
       handler.dispatchStateChange(GestureHandler.STATE_END, GestureHandler.STATE_ACTIVE)
       if (currentState != GestureHandler.STATE_END) {
@@ -218,41 +240,45 @@ class GestureHandlerOrchestrator(
   private fun deliverEventToGestureHandlers(event: MotionEvent) {
     // Copy handlers to "prepared handlers" array, because the list of active handlers can change
     // as a result of state updates
-    val handlersCount = gestureHandlersCount
+    preparedHandlers.clear()
+    preparedHandlers.addAll(gestureHandlers)
 
-    gestureHandlers.copyInto(preparedHandlers, 0, 0, handlersCount)
     // We want to deliver events to active handlers first in order of their activation (handlers
     // that activated first will first get event delivered). Otherwise we deliver events in the
     // order in which handlers has been added ("most direct" children goes first). Therefore we rely
     // on Arrays.sort providing a stable sort (as children are registered in order in which they
     // should be tested)
-    preparedHandlers.sortWith(handlersComparator, 0, handlersCount)
-    for (i in 0 until handlersCount) {
-      deliverEventToGestureHandler(preparedHandlers[i]!!, event)
+    preparedHandlers.sortWith(handlersComparator)
+
+    for (handler in preparedHandlers) {
+      deliverEventToGestureHandler(handler, event)
     }
   }
 
   private fun cancelAll() {
-    for (i in awaitingHandlersCount - 1 downTo 0) {
-      awaitingHandlers[i]!!.cancel()
+    // We need `toList` as `awaitingHandlers` can be modified by `cancel`:
+    // `onHandlerStateChange` -> `tryActivate` -> `addAwaitingHandler`
+    for (handler in awaitingHandlers.asReversed().toList()) {
+      handler.cancel()
     }
+
     // Copy handlers to "prepared handlers" array, because the list of active handlers can change
     // as a result of state updates
-    val handlersCount = gestureHandlersCount
-    for (i in 0 until handlersCount) {
-      preparedHandlers[i] = gestureHandlers[i]
-    }
-    for (i in handlersCount - 1 downTo 0) {
-      preparedHandlers[i]!!.cancel()
+    preparedHandlers.clear()
+    preparedHandlers.addAll(gestureHandlers)
+
+    for (handler in gestureHandlers.asReversed()) {
+      handler.cancel()
     }
   }
 
-  private fun deliverEventToGestureHandler(handler: GestureHandler<*>, sourceEvent: MotionEvent) {
+  private fun deliverEventToGestureHandler(handler: GestureHandler, sourceEvent: MotionEvent) {
     if (!isViewAttachedUnderWrapper(handler.view)) {
       handler.cancel()
       return
     }
-    if (!handler.wantEvents()) {
+
+    if (!handler.wantsEvent(sourceEvent)) {
       return
     }
 
@@ -260,7 +286,7 @@ class GestureHandlerOrchestrator(
     val event = transformEventToViewCoords(handler.view, MotionEvent.obtain(sourceEvent))
 
     // Touch events are sent before the handler itself has a chance to process them,
-    // mainly because `onTouchesUp` shoul be send befor gesture finishes. This means that
+    // mainly because `onTouchesUp` should be send before gesture finishes. This means that
     // the first `onTouchesDown` event is sent before a gesture begins, activation in
     // callback for this event causes problems because the handler doesn't have a chance
     // to initialize itself with starting values of pointer (in pan this causes translation
@@ -268,7 +294,7 @@ class GestureHandlerOrchestrator(
     // the first `onTouchesDown` event after the handler processes it and changes state
     // to `BEGAN`.
     if (handler.needsPointerData && handler.state != 0) {
-      handler.updatePointerData(event)
+      handler.updatePointerData(event, sourceEvent)
     }
 
     if (!handler.isAwaiting || action != MotionEvent.ACTION_MOVE) {
@@ -290,12 +316,15 @@ class GestureHandlerOrchestrator(
       }
 
       if (handler.needsPointerData && isFirstEvent) {
-        handler.updatePointerData(event)
+        handler.updatePointerData(event, sourceEvent)
       }
 
       // if event was of type UP or POINTER_UP we request handler to stop tracking now that
       // the event has been dispatched
-      if (action == MotionEvent.ACTION_UP || action == MotionEvent.ACTION_POINTER_UP || action == MotionEvent.ACTION_HOVER_EXIT) {
+      if (action == MotionEvent.ACTION_UP ||
+        action == MotionEvent.ACTION_POINTER_UP ||
+        action == MotionEvent.ACTION_HOVER_EXIT
+      ) {
         val pointerId = event.getPointerId(event.actionIndex)
         handler.stopTrackingPointer(pointerId)
       }
@@ -325,7 +354,7 @@ class GestureHandlerOrchestrator(
     return parent === wrapperView
   }
 
-  fun isAnyHandlerActive() = gestureHandlers.any { it?.state == GestureHandler.STATE_ACTIVE }
+  fun isAnyHandlerActive() = gestureHandlers.any { it.state == GestureHandler.STATE_ACTIVE }
 
   /**
    * Transforms an event in the coordinates of wrapperView into the coordinate space of the received view.
@@ -398,28 +427,26 @@ class GestureHandlerOrchestrator(
     return point
   }
 
-  private fun addAwaitingHandler(handler: GestureHandler<*>) {
-    for (i in 0 until awaitingHandlersCount) {
-      if (awaitingHandlers[i] === handler) {
-        return
-      }
+  private fun addAwaitingHandler(handler: GestureHandler) {
+    if (awaitingHandlers.contains(handler)) {
+      return
     }
-    check(awaitingHandlersCount < awaitingHandlers.size) { "Too many recognizers" }
-    awaitingHandlers[awaitingHandlersCount++] = handler
+
+    awaitingHandlers.add(handler)
+    awaitingHandlersTags.add(handler.tag)
+
     with(handler) {
       isAwaiting = true
       activationIndex = this@GestureHandlerOrchestrator.activationIndex++
     }
   }
 
-  private fun recordHandlerIfNotPresent(handler: GestureHandler<*>, view: View) {
-    for (i in 0 until gestureHandlersCount) {
-      if (gestureHandlers[i] === handler) {
-        return
-      }
+  private fun recordHandlerIfNotPresent(handler: GestureHandler, view: View) {
+    if (gestureHandlers.contains(handler)) {
+      return
     }
-    check(gestureHandlersCount < gestureHandlers.size) { "Too many recognizers" }
-    gestureHandlers[gestureHandlersCount++] = handler
+
+    gestureHandlers.add(handler)
     handler.isActive = false
     handler.isAwaiting = false
     handler.activationIndex = Int.MAX_VALUE
@@ -436,7 +463,10 @@ class GestureHandlerOrchestrator(
     val left = localXY[0] + view.left
     val top = localXY[1] + view.top
 
-    return left < 0f || left + view.width > parent.width || top < 0f || top + view.height > parent.height
+    return left < 0f ||
+      left + view.width > parent.width ||
+      top < 0f ||
+      top + view.height > parent.height
   }
 
   private fun extractAncestorHandlers(view: View, coords: FloatArray, pointerId: Int): Boolean {
@@ -466,7 +496,30 @@ class GestureHandlerOrchestrator(
     return found
   }
 
-  private fun recordViewHandlersForPointer(view: View, coords: FloatArray, pointerId: Int, event: MotionEvent): Boolean {
+  // We don't want to extract gestures other than hover when processing hover events.
+  // There's only one exception - RootViewGestureHandler. TalkBack uses hover events,
+  // so we need to pass them into RootViewGestureHandler, otherwise press and hold
+  // gesture stops working correctly (see https://github.com/software-mansion/react-native-gesture-handler/issues/3407)
+  private fun shouldHandlerSkipHoverEvents(handler: GestureHandler, action: Int): Boolean {
+    val shouldSkipHoverEvents =
+      handler !is HoverGestureHandler &&
+        handler !is RNGestureHandlerRootHelper.RootViewGestureHandler
+
+    return shouldSkipHoverEvents &&
+      action in
+      listOf(
+        MotionEvent.ACTION_HOVER_EXIT,
+        MotionEvent.ACTION_HOVER_ENTER,
+        MotionEvent.ACTION_HOVER_MOVE,
+      )
+  }
+
+  private fun recordViewHandlersForPointer(
+    view: View,
+    coords: FloatArray,
+    pointerId: Int,
+    event: MotionEvent,
+  ): Boolean {
     var found = false
     handlerRegistry.getHandlersForView(view)?.let {
       synchronized(it) {
@@ -476,8 +529,7 @@ class GestureHandlerOrchestrator(
             continue
           }
 
-          // we don't want to extract gestures other than hover when processing hover events
-          if (event.action in listOf(MotionEvent.ACTION_HOVER_EXIT, MotionEvent.ACTION_HOVER_ENTER, MotionEvent.ACTION_HOVER_MOVE) && handler !is HoverGestureHandler) {
+          if (shouldHandlerSkipHoverEvents(handler, event.action)) {
             continue
           }
 
@@ -490,8 +542,10 @@ class GestureHandlerOrchestrator(
 
     // if the pointer is inside the view but it overflows its parent, handlers attached to the parent
     // might not have been extracted (pointer might be in a child, but may be outside parent)
-    if (coords[0] in 0f..view.width.toFloat() && coords[1] in 0f..view.height.toFloat() &&
-      isViewOverflowingParent(view) && extractAncestorHandlers(view, coords, pointerId)
+    if (coords[0] in 0f..view.width.toFloat() &&
+      coords[1] in 0f..view.height.toFloat() &&
+      isViewOverflowingParent(view) &&
+      extractAncestorHandlers(view, coords, pointerId)
     ) {
       found = true
     }
@@ -508,7 +562,12 @@ class GestureHandlerOrchestrator(
     extractGestureHandlers(wrapperView, tempCoords, pointerId, event)
   }
 
-  private fun extractGestureHandlers(viewGroup: ViewGroup, coords: FloatArray, pointerId: Int, event: MotionEvent): Boolean {
+  private fun extractGestureHandlers(
+    viewGroup: ViewGroup,
+    coords: FloatArray,
+    pointerId: Int,
+    event: MotionEvent,
+  ): Boolean {
     val childrenCount = viewGroup.childCount
     for (i in childrenCount - 1 downTo 0) {
       val child = viewConfigHelper.getChildInDrawingOrderAtIndex(viewGroup, i)
@@ -573,22 +632,23 @@ class GestureHandlerOrchestrator(
         // Either this view or one of its children is the target
         val found = if (view is ViewGroup) {
           extractGestureHandlers(view, coords, pointerId, event)
-        } else false
+        } else {
+          false
+        }
 
         (
           recordViewHandlersForPointer(view, coords, pointerId, event) ||
-            found || shouldHandlerlessViewBecomeTouchTarget(view, coords)
+            found ||
+            shouldHandlerlessViewBecomeTouchTarget(view, coords)
           )
       }
     }
 
-  private fun canReceiveEvents(view: View) =
-    view.visibility == View.VISIBLE && view.alpha >= minimumAlphaForTraversal
+  private fun canReceiveEvents(view: View) = view.visibility == View.VISIBLE && view.alpha >= minimumAlphaForTraversal
 
   // if view is not a view group it is clipping, otherwise we check for `getClipChildren` flag to
   // be turned on and also confirm with the ViewConfigHelper implementation
-  private fun isClipping(view: View) =
-    view !is ViewGroup || viewConfigHelper.isViewClippingChildren(view)
+  private fun isClipping(view: View) = view !is ViewGroup || viewConfigHelper.isViewClippingChildren(view)
 
   fun activateNativeHandlersForView(view: View) {
     handlerRegistry.getHandlersForView(view)?.forEach {
@@ -608,7 +668,6 @@ class GestureHandlerOrchestrator(
   companion object {
     // The limit doesn't necessarily need to exists, it was just simpler to implement it that way
     // it is also more allocation-wise efficient to have a fixed limit
-    private const val SIMULTANEOUS_GESTURE_HANDLER_LIMIT = 20
 
     // Be default fully transparent views can receive touch
     private const val DEFAULT_MIN_ALPHA_FOR_TRAVERSAL = 0f
@@ -616,7 +675,7 @@ class GestureHandlerOrchestrator(
     private val matrixTransformCoords = FloatArray(2)
     private val inverseMatrix = Matrix()
     private val tempCoords = FloatArray(2)
-    private val handlersComparator = Comparator<GestureHandler<*>?> { a, b ->
+    private val handlersComparator = Comparator<GestureHandler> { a, b ->
       return@Comparator if (a.isActive && b.isActive || a.isAwaiting && b.isAwaiting) {
         // both A and B are either active or awaiting activation, in which case we prefer one that
         // has activated (or turned into "awaiting" state) earlier
@@ -670,17 +729,17 @@ class GestureHandlerOrchestrator(
     private fun isTransformedTouchPointInView(x: Float, y: Float, child: View) =
       x in 0f..child.width.toFloat() && y in 0f..child.height.toFloat()
 
-    private fun shouldHandlerWaitForOther(handler: GestureHandler<*>, other: GestureHandler<*>): Boolean {
-      return handler !== other && (
-        handler.shouldWaitForHandlerFailure(other) ||
-          other.shouldRequireToWaitForFailure(handler)
-        )
-    }
+    private fun shouldHandlerWaitForOther(handler: GestureHandler, other: GestureHandler): Boolean =
+      handler !== other &&
+        (
+          handler.shouldWaitForHandlerFailure(other) ||
+            other.shouldRequireToWaitForFailure(handler)
+          )
 
-    private fun canRunSimultaneously(a: GestureHandler<*>, b: GestureHandler<*>) =
+    private fun canRunSimultaneously(a: GestureHandler, b: GestureHandler) =
       a === b || a.shouldRecognizeSimultaneously(b) || b.shouldRecognizeSimultaneously(a)
 
-    private fun shouldHandlerBeCancelledBy(handler: GestureHandler<*>, other: GestureHandler<*>): Boolean {
+    private fun shouldHandlerBeCancelledBy(handler: GestureHandler, other: GestureHandler): Boolean {
       if (!handler.hasCommonPointers(other)) {
         // if two handlers share no common pointer one can never trigger cancel for the other
         return false
@@ -696,12 +755,13 @@ class GestureHandlerOrchestrator(
         // in every other case as long as the handler is about to be activated or already in active
         // state, we delegate the decision to the implementation of GestureHandler#shouldBeCancelledBy
         handler.shouldBeCancelledBy(other)
-      } else true
+      } else {
+        true
+      }
     }
 
-    private fun isFinished(state: Int) =
-      state == GestureHandler.STATE_CANCELLED ||
-        state == GestureHandler.STATE_FAILED ||
-        state == GestureHandler.STATE_END
+    private fun isFinished(state: Int) = state == GestureHandler.STATE_CANCELLED ||
+      state == GestureHandler.STATE_FAILED ||
+      state == GestureHandler.STATE_END
   }
 }

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

@@ -4,5 +4,5 @@ import android.view.View
 import java.util.*
 
 interface GestureHandlerRegistry {
-  fun getHandlersForView(view: View): ArrayList<GestureHandler<*>>?
+  fun getHandlersForView(view: View): ArrayList<GestureHandler>?
 }

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

@@ -1,10 +1,15 @@
 package com.swmansion.gesturehandler.core
 
 import android.view.MotionEvent
+import kotlin.math.cos
 
 object GestureUtils {
   fun getLastPointerX(event: MotionEvent, averageTouches: Boolean): Float {
-    val excludeIndex = if (event.actionMasked == MotionEvent.ACTION_POINTER_UP) event.actionIndex else -1
+    val excludeIndex = if (event.actionMasked == MotionEvent.ACTION_POINTER_UP) {
+      event.actionIndex
+    } else {
+      -1
+    }
     return if (averageTouches) {
       var sum = 0f
       var count = 0
@@ -25,7 +30,13 @@ object GestureUtils {
   }
 
   fun getLastPointerY(event: MotionEvent, averageTouches: Boolean): Float {
-    val excludeIndex = if (event.actionMasked == MotionEvent.ACTION_POINTER_UP) event.actionIndex else -1
+    val excludeIndex = if (event.actionMasked ==
+      MotionEvent.ACTION_POINTER_UP
+    ) {
+      event.actionIndex
+    } else {
+      -1
+    }
     return if (averageTouches) {
       var sum = 0f
       var count = 0
@@ -44,4 +55,6 @@ object GestureUtils {
       event.getY(lastPointerIdx)
     }
   }
+
+  fun coneToDeviation(angle: Double): Double = cos(Math.toRadians(angle / 2.0))
 }