@react-native-oh-tpl/react-native-gesture-handler 2.12.1-0.0.1

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

@@ -0,0 +1,47 @@
+package com.swmansion.gesturehandler.core
+
+import android.view.MotionEvent
+
+object GestureUtils {
+  fun getLastPointerX(event: MotionEvent, averageTouches: Boolean): Float {
+    val excludeIndex = if (event.actionMasked == MotionEvent.ACTION_POINTER_UP) event.actionIndex else -1
+    return if (averageTouches) {
+      var sum = 0f
+      var count = 0
+      for (i in 0 until event.pointerCount) {
+        if (i != excludeIndex) {
+          sum += event.getX(i)
+          count++
+        }
+      }
+      sum / count
+    } else {
+      var lastPointerIdx = event.pointerCount - 1
+      if (lastPointerIdx == excludeIndex) {
+        lastPointerIdx--
+      }
+      event.getX(lastPointerIdx)
+    }
+  }
+
+  fun getLastPointerY(event: MotionEvent, averageTouches: Boolean): Float {
+    val excludeIndex = if (event.actionMasked == MotionEvent.ACTION_POINTER_UP) event.actionIndex else -1
+    return if (averageTouches) {
+      var sum = 0f
+      var count = 0
+      for (i in 0 until event.pointerCount) {
+        if (i != excludeIndex) {
+          sum += event.getY(i)
+          count++
+        }
+      }
+      sum / count
+    } else {
+      var lastPointerIdx = event.pointerCount - 1
+      if (lastPointerIdx == excludeIndex) {
+        lastPointerIdx -= 1
+      }
+      event.getY(lastPointerIdx)
+    }
+  }
+}

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

@@ -0,0 +1,120 @@
+package com.swmansion.gesturehandler.core
+
+import android.os.Handler
+import android.os.Looper
+import android.view.MotionEvent
+import android.view.View
+import android.view.ViewGroup
+import com.swmansion.gesturehandler.react.RNViewConfigurationHelper
+
+class HoverGestureHandler : GestureHandler<HoverGestureHandler>() {
+  private var handler: Handler? = null
+  private var finishRunnable = Runnable { finish() }
+
+  private infix fun isAncestorOf(other: GestureHandler<*>): Boolean {
+    var current: View? = other.view
+
+    while (current != null) {
+      if (current == this.view) {
+        return true
+      }
+
+      current = current.parent as? View
+    }
+
+    return false
+  }
+
+  private fun isViewDisplayedOverAnother(view: View, other: View, rootView: View = view.rootView): Boolean? {
+    // traverse the tree starting on the root view, to see which view will be drawn first
+    if (rootView == other) {
+      return true
+    }
+
+    if (rootView == view) {
+      return false
+    }
+
+    if (rootView is ViewGroup) {
+      for (i in 0 until rootView.childCount) {
+        val child = viewConfigHelper.getChildInDrawingOrderAtIndex(rootView, i)
+        return isViewDisplayedOverAnother(view, other, child) ?: continue
+      }
+    }
+
+    return null
+  }
+
+  override fun shouldBeCancelledBy(handler: GestureHandler<*>): Boolean {
+    if (handler is HoverGestureHandler && !(handler isAncestorOf this)) {
+      return isViewDisplayedOverAnother(handler.view!!, this.view!!)!!
+    }
+
+    return super.shouldBeCancelledBy(handler)
+  }
+
+  override fun shouldRequireToWaitForFailure(handler: GestureHandler<*>): Boolean {
+    if (handler is HoverGestureHandler) {
+      if (!(this isAncestorOf handler) && !(handler isAncestorOf this)) {
+        isViewDisplayedOverAnother(this.view!!, handler.view!!)?.let {
+          return it
+        }
+      }
+    }
+
+    return super.shouldRequireToWaitForFailure(handler)
+  }
+
+  override fun shouldRecognizeSimultaneously(handler: GestureHandler<*>): Boolean {
+    if (handler is HoverGestureHandler && (this isAncestorOf handler || handler isAncestorOf this)) {
+      return true
+    }
+
+    return super.shouldRecognizeSimultaneously(handler)
+  }
+
+  override fun onHandle(event: MotionEvent, sourceEvent: MotionEvent) {
+    if (event.action == MotionEvent.ACTION_DOWN) {
+      handler?.removeCallbacksAndMessages(null)
+      handler = null
+    } else if (event.action == MotionEvent.ACTION_UP) {
+      if (!isWithinBounds) {
+        finish()
+      }
+    }
+  }
+
+  override fun onHandleHover(event: MotionEvent, sourceEvent: MotionEvent) {
+    when {
+      event.action == MotionEvent.ACTION_HOVER_EXIT -> {
+        if (handler == null) {
+          handler = Handler(Looper.getMainLooper())
+        }
+
+        handler!!.postDelayed(finishRunnable, 4)
+      }
+
+      !isWithinBounds -> {
+        finish()
+      }
+
+      this.state == STATE_UNDETERMINED &&
+        (event.action == MotionEvent.ACTION_HOVER_MOVE || event.action == MotionEvent.ACTION_HOVER_ENTER) -> {
+        begin()
+        activate()
+      }
+    }
+  }
+
+  private fun finish() {
+    when (this.state) {
+      STATE_UNDETERMINED -> cancel()
+      STATE_BEGAN -> fail()
+      STATE_ACTIVE -> end()
+    }
+  }
+
+  companion object {
+    private val viewConfigHelper = RNViewConfigurationHelper()
+  }
+}

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

@@ -0,0 +1,100 @@
+package com.swmansion.gesturehandler.core
+
+import android.content.Context
+import android.os.Handler
+import android.os.Looper
+import android.os.SystemClock
+import android.view.MotionEvent
+
+class LongPressGestureHandler(context: Context) : GestureHandler<LongPressGestureHandler>() {
+  var minDurationMs = DEFAULT_MIN_DURATION_MS
+  val duration: Int
+    get() = (previousTime - startTime).toInt()
+  private val defaultMaxDistSq: Float
+  private var maxDistSq: Float
+  private var startX = 0f
+  private var startY = 0f
+  private var startTime: Long = 0
+  private var previousTime: Long = 0
+  private var handler: Handler? = null
+
+  init {
+    setShouldCancelWhenOutside(true)
+
+    val defaultMaxDist = DEFAULT_MAX_DIST_DP * context.resources.displayMetrics.density
+    defaultMaxDistSq = defaultMaxDist * defaultMaxDist
+    maxDistSq = defaultMaxDistSq
+  }
+
+  override fun resetConfig() {
+    super.resetConfig()
+    minDurationMs = DEFAULT_MIN_DURATION_MS
+    maxDistSq = defaultMaxDistSq
+  }
+
+  fun setMaxDist(maxDist: Float): LongPressGestureHandler {
+    maxDistSq = maxDist * maxDist
+    return this
+  }
+
+  override fun onHandle(event: MotionEvent, sourceEvent: MotionEvent) {
+    if (state == STATE_UNDETERMINED) {
+      previousTime = SystemClock.uptimeMillis()
+      startTime = previousTime
+      begin()
+      startX = sourceEvent.rawX
+      startY = sourceEvent.rawY
+      handler = Handler(Looper.getMainLooper())
+      if (minDurationMs > 0) {
+        handler!!.postDelayed({ activate() }, minDurationMs)
+      } else if (minDurationMs == 0L) {
+        activate()
+      }
+    }
+    if (sourceEvent.actionMasked == MotionEvent.ACTION_UP) {
+      handler?.let {
+        it.removeCallbacksAndMessages(null)
+        handler = null
+      }
+      if (state == STATE_ACTIVE) {
+        end()
+      } else {
+        fail()
+      }
+    } else {
+      // calculate distance from start
+      val deltaX = sourceEvent.rawX - startX
+      val deltaY = sourceEvent.rawY - startY
+      val distSq = deltaX * deltaX + deltaY * deltaY
+      if (distSq > maxDistSq) {
+        if (state == STATE_ACTIVE) {
+          cancel()
+        } else {
+          fail()
+        }
+      }
+    }
+  }
+
+  override fun onStateChange(newState: Int, previousState: Int) {
+    handler?.let {
+      it.removeCallbacksAndMessages(null)
+      handler = null
+    }
+  }
+
+  override fun dispatchStateChange(newState: Int, prevState: Int) {
+    previousTime = SystemClock.uptimeMillis()
+    super.dispatchStateChange(newState, prevState)
+  }
+
+  override fun dispatchHandlerUpdate(event: MotionEvent) {
+    previousTime = SystemClock.uptimeMillis()
+    super.dispatchHandlerUpdate(event)
+  }
+
+  companion object {
+    private const val DEFAULT_MIN_DURATION_MS: Long = 500
+    private const val DEFAULT_MAX_DIST_DP = 10f
+  }
+}

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

@@ -0,0 +1,11 @@
+package com.swmansion.gesturehandler.core
+
+import android.view.MotionEvent
+
+class ManualGestureHandler : GestureHandler<ManualGestureHandler>() {
+  override fun onHandle(event: MotionEvent, sourceEvent: MotionEvent) {
+    if (state == STATE_UNDETERMINED) {
+      begin()
+    }
+  }
+}

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

@@ -0,0 +1,257 @@
+package com.swmansion.gesturehandler.core
+
+import android.os.SystemClock
+import android.view.MotionEvent
+import android.view.View
+import android.view.ViewConfiguration
+import android.view.ViewGroup
+import android.widget.ScrollView
+import com.facebook.react.views.scroll.ReactScrollView
+import com.facebook.react.views.swiperefresh.ReactSwipeRefreshLayout
+import com.facebook.react.views.textinput.ReactEditText
+
+class NativeViewGestureHandler : GestureHandler<NativeViewGestureHandler>() {
+  private var shouldActivateOnStart = false
+  var disallowInterruption = false
+    private set
+
+  private var hook: NativeViewGestureHandlerHook = defaultHook
+
+  init {
+    setShouldCancelWhenOutside(true)
+  }
+
+  override fun resetConfig() {
+    super.resetConfig()
+    shouldActivateOnStart = false
+    disallowInterruption = false
+  }
+
+  fun setShouldActivateOnStart(shouldActivateOnStart: Boolean) = apply {
+    this.shouldActivateOnStart = shouldActivateOnStart
+  }
+
+  /**
+   * Set this to `true` when wrapping native components that are supposed to be an exclusive
+   * target for a touch stream. Like for example switch or slider component which when activated
+   * aren't supposed to be cancelled by scrollview or other container that may also handle touches.
+   */
+  fun setDisallowInterruption(disallowInterruption: Boolean) = apply {
+    this.disallowInterruption = disallowInterruption
+  }
+
+  override fun shouldRecognizeSimultaneously(handler: GestureHandler<*>): Boolean {
+    // if the gesture is marked by user as simultaneous with other or the hook return true
+    if (super.shouldRecognizeSimultaneously(handler) || hook.shouldRecognizeSimultaneously(handler)) {
+      return true
+    }
+
+    if (handler is NativeViewGestureHandler) {
+      // Special case when the peer handler is also an instance of NativeViewGestureHandler:
+      // For the `disallowInterruption` to work correctly we need to check the property when
+      // accessed as a peer, because simultaneous recognizers can be set on either side of the
+      // connection.
+      if (handler.state == STATE_ACTIVE && handler.disallowInterruption) {
+        // other handler is active and it disallows interruption, we don't want to get into its way
+        return false
+      }
+    }
+    val canBeInterrupted = !disallowInterruption
+    val otherState = handler.state
+    return if (state == STATE_ACTIVE && otherState == STATE_ACTIVE && canBeInterrupted) {
+      // if both handlers are active and the current handler can be interrupted it we return `false`
+      // as it means the other handler has turned active and returning `true` would prevent it from
+      // interrupting the current handler
+      false
+    } else state == STATE_ACTIVE && canBeInterrupted && (!hook.shouldCancelRootViewGestureHandlerIfNecessary() || handler.tag > 0)
+    // otherwise we can only return `true` if already in an active state
+  }
+
+  override fun shouldBeCancelledBy(handler: GestureHandler<*>): Boolean {
+    return !disallowInterruption
+  }
+
+  override fun onPrepare() {
+    when (val view = view) {
+      is NativeViewGestureHandlerHook -> this.hook = view
+      is ReactEditText -> this.hook = EditTextHook(this, view)
+      is ReactSwipeRefreshLayout -> this.hook = SwipeRefreshLayoutHook(this, view)
+      is ReactScrollView -> this.hook = ScrollViewHook()
+    }
+  }
+
+  override fun onHandle(event: MotionEvent, sourceEvent: MotionEvent) {
+    val view = view!!
+    if (event.actionMasked == MotionEvent.ACTION_UP) {
+      view.onTouchEvent(event)
+      if ((state == STATE_UNDETERMINED || state == STATE_BEGAN) && view.isPressed) {
+        activate()
+      }
+      end()
+      hook.afterGestureEnd(event)
+    } else if (state == STATE_UNDETERMINED || state == STATE_BEGAN) {
+      when {
+        shouldActivateOnStart -> {
+          tryIntercept(view, event)
+          view.onTouchEvent(event)
+          activate()
+        }
+        tryIntercept(view, event) -> {
+          view.onTouchEvent(event)
+          activate()
+        }
+        hook.wantsToHandleEventBeforeActivation() -> {
+          hook.handleEventBeforeActivation(event)
+        }
+        state != STATE_BEGAN -> {
+          if (hook.canBegin()) {
+            begin()
+          } else {
+            cancel()
+          }
+        }
+      }
+    } else if (state == STATE_ACTIVE) {
+      view.onTouchEvent(event)
+    }
+  }
+
+  override fun onCancel() {
+    val time = SystemClock.uptimeMillis()
+    val event = MotionEvent.obtain(time, time, MotionEvent.ACTION_CANCEL, 0f, 0f, 0).apply {
+      action = MotionEvent.ACTION_CANCEL
+    }
+    view!!.onTouchEvent(event)
+    event.recycle()
+  }
+
+  override fun onReset() {
+    this.hook = defaultHook
+  }
+
+  companion object {
+    private fun tryIntercept(view: View, event: MotionEvent) =
+      view is ViewGroup && view.onInterceptTouchEvent(event)
+
+    private val defaultHook = object : NativeViewGestureHandlerHook {}
+  }
+
+  interface NativeViewGestureHandlerHook {
+    /**
+     * Called when gesture is in the UNDETERMINED state, shouldActivateOnStart is set to false,
+     * and both tryIntercept and wantsToHandleEventBeforeActivation returned false.
+     *
+     * @return Boolean value signalling whether the handler can transition to the BEGAN state. If false
+     * the gesture will be cancelled.
+     */
+    fun canBegin() = true
+
+    /**
+     * Called after the gesture transitions to the END state.
+     */
+    fun afterGestureEnd(event: MotionEvent) = Unit
+
+    /**
+     * @return Boolean value signalling whether the gesture can be recognized simultaneously with
+     * other (handler). Returning false doesn't necessarily prevent it from happening.
+     */
+    fun shouldRecognizeSimultaneously(handler: GestureHandler<*>) = false
+
+    /**
+     * shouldActivateOnStart and tryIntercept have priority over this method
+     *
+     * @return Boolean value signalling if the hook wants to handle events passed to the handler
+     * before it activates (after that the events are passed to the underlying view).
+     */
+    fun wantsToHandleEventBeforeActivation() = false
+
+    /**
+     * Will be called with events if wantsToHandleEventBeforeActivation returns true.
+     */
+    fun handleEventBeforeActivation(event: MotionEvent) = Unit
+
+    /**
+     * @return Boolean value indicating whether the RootViewGestureHandler should be cancelled
+     * by this one.
+     */
+    fun shouldCancelRootViewGestureHandlerIfNecessary() = false
+  }
+
+  private class EditTextHook(
+    private val handler: NativeViewGestureHandler,
+    private val editText: ReactEditText
+  ) : NativeViewGestureHandlerHook {
+    private var startX = 0f
+    private var startY = 0f
+    private var touchSlopSquared: Int
+
+    init {
+      val vc = ViewConfiguration.get(editText.context)
+      touchSlopSquared = vc.scaledTouchSlop * vc.scaledTouchSlop
+    }
+
+    override fun afterGestureEnd(event: MotionEvent) {
+      if ((event.x - startX) * (event.x - startX) + (event.y - startY) * (event.y - startY) < touchSlopSquared) {
+        editText.requestFocusFromJS()
+      }
+    }
+
+    // recognize alongside every handler besides RootViewGestureHandler, which is a private inner class
+    // of RNGestureHandlerRootHelper so no explicit type checks, but its tag is always negative
+    // also if other handler is NativeViewGestureHandler then don't override the default implementation
+    override fun shouldRecognizeSimultaneously(handler: GestureHandler<*>) =
+      handler.tag > 0 && handler !is NativeViewGestureHandler
+
+    override fun wantsToHandleEventBeforeActivation() = true
+
+    override fun handleEventBeforeActivation(event: MotionEvent) {
+      handler.activate()
+      editText.onTouchEvent(event)
+
+      startX = event.x
+      startY = event.y
+    }
+
+    override fun shouldCancelRootViewGestureHandlerIfNecessary() = true
+  }
+
+  private class SwipeRefreshLayoutHook(
+    private val handler: NativeViewGestureHandler,
+    private val swipeRefreshLayout: ReactSwipeRefreshLayout
+  ) : NativeViewGestureHandlerHook {
+    override fun wantsToHandleEventBeforeActivation() = true
+
+    override fun handleEventBeforeActivation(event: MotionEvent) {
+      // RefreshControl from GH is set up in a way that ScrollView wrapped with it should wait for
+      // it to fail. This way the RefreshControl is not canceled by the scroll handler.
+      // The problem with this approach is that the RefreshControl handler stays active all the time
+      // preventing scroll from activating.
+      // This is a workaround to prevent it from happening.
+
+      // First get the ScrollView under the RefreshControl, if there is none, return.
+      val scroll = swipeRefreshLayout.getChildAt(0) as? ScrollView ?: return
+
+      // Then find the first NativeViewGestureHandler attached to it
+      val scrollHandler = handler.orchestrator
+        ?.getHandlersForView(scroll)
+        ?.first {
+          it is NativeViewGestureHandler
+        }
+
+      // If handler was found, it's active and the ScrollView is not at the top, fail the RefreshControl
+      if (scrollHandler != null && scrollHandler.state == STATE_ACTIVE && scroll.scrollY > 0) {
+        handler.fail()
+      }
+
+      // The drawback is that the smooth transition from scrolling to refreshing in a single swipe
+      // is impossible this way and two swipes are required:
+      // - one to go back to top
+      // - one to actually refresh
+      // oh well  ¯\_(ツ)_/¯
+    }
+  }
+
+  private class ScrollViewHook : NativeViewGestureHandlerHook {
+    override fun shouldCancelRootViewGestureHandlerIfNecessary() = true
+  }
+}

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

@@ -0,0 +1,9 @@
+package com.swmansion.gesturehandler.core
+
+import android.view.MotionEvent
+
+interface OnTouchEventListener {
+  fun <T : GestureHandler<T>> onHandlerUpdate(handler: T, event: MotionEvent)
+  fun <T : GestureHandler<T>> onStateChange(handler: T, newState: Int, oldState: Int)
+  fun <T : GestureHandler<T>> onTouchEvent(handler: T)
+}