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

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

@@ -0,0 +1,168 @@
+package com.swmansion.gesturehandler.core
+
+import android.os.Handler
+import android.os.Looper
+import android.view.MotionEvent
+import com.swmansion.gesturehandler.core.GestureUtils.getLastPointerX
+import com.swmansion.gesturehandler.core.GestureUtils.getLastPointerY
+import kotlin.math.abs
+
+class TapGestureHandler : GestureHandler<TapGestureHandler>() {
+  private var maxDeltaX = MAX_VALUE_IGNORE
+  private var maxDeltaY = MAX_VALUE_IGNORE
+  private var maxDistSq = MAX_VALUE_IGNORE
+  private var maxDurationMs = DEFAULT_MAX_DURATION_MS
+  private var maxDelayMs = DEFAULT_MAX_DELAY_MS
+  private var numberOfTaps = DEFAULT_NUMBER_OF_TAPS
+  private var minNumberOfPointers = DEFAULT_MIN_NUMBER_OF_POINTERS
+  private var currentMaxNumberOfPointers = 1
+  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 handler: Handler? = null
+  private var tapsSoFar = 0
+  private val failDelayed = Runnable { fail() }
+
+  init {
+    setShouldCancelWhenOutside(true)
+  }
+
+  override fun resetConfig() {
+    super.resetConfig()
+    maxDeltaX = MAX_VALUE_IGNORE
+    maxDeltaY = MAX_VALUE_IGNORE
+    maxDistSq = 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
+  }
+
+  private fun startTap() {
+    if (handler == null) {
+      handler = Handler(Looper.getMainLooper()) // TODO: lazy init (handle else branch correctly)
+    } else {
+      handler!!.removeCallbacksAndMessages(null)
+    }
+    handler!!.postDelayed(failDelayed, maxDurationMs)
+  }
+
+  private fun endTap() {
+    if (handler == null) {
+      handler = Handler(Looper.getMainLooper())
+    } else {
+      handler!!.removeCallbacksAndMessages(null)
+    }
+    if (++tapsSoFar == numberOfTaps && currentMaxNumberOfPointers >= minNumberOfPointers) {
+      activate()
+    } else {
+      handler!!.postDelayed(failDelayed, maxDelayMs)
+    }
+  }
+
+  private fun shouldFail(): Boolean {
+    val dx = lastX - startX + offsetX
+    if (maxDeltaX != MAX_VALUE_IGNORE && abs(dx) > maxDeltaX) {
+      return true
+    }
+    val dy = lastY - startY + offsetY
+    if (maxDeltaY != MAX_VALUE_IGNORE && abs(dy) > maxDeltaY) {
+      return true
+    }
+    val dist = dy * dy + dx * dx
+    return maxDistSq != MAX_VALUE_IGNORE && dist > maxDistSq
+  }
+
+  override fun onHandle(event: MotionEvent, sourceEvent: MotionEvent) {
+    val state = state
+    val action = sourceEvent.actionMasked
+    if (state == STATE_UNDETERMINED) {
+      offsetX = 0f
+      offsetY = 0f
+      startX = getLastPointerX(sourceEvent, true)
+      startY = getLastPointerY(sourceEvent, true)
+    }
+    if (action == MotionEvent.ACTION_POINTER_UP || action == MotionEvent.ACTION_POINTER_DOWN) {
+      offsetX += lastX - startX
+      offsetY += lastY - startY
+      lastX = getLastPointerX(sourceEvent, true)
+      lastY = getLastPointerY(sourceEvent, true)
+      startX = lastX
+      startY = lastY
+    } else {
+      lastX = getLastPointerX(sourceEvent, true)
+      lastY = getLastPointerY(sourceEvent, true)
+    }
+    if (currentMaxNumberOfPointers < sourceEvent.pointerCount) {
+      currentMaxNumberOfPointers = sourceEvent.pointerCount
+    }
+    if (shouldFail()) {
+      fail()
+    } else if (state == STATE_UNDETERMINED) {
+      if (action == MotionEvent.ACTION_DOWN) {
+        begin()
+      }
+      startTap()
+    } else if (state == STATE_BEGAN) {
+      if (action == MotionEvent.ACTION_UP) {
+        endTap()
+      } else if (action == MotionEvent.ACTION_DOWN) {
+        startTap()
+      }
+    }
+  }
+
+  override fun activate(force: Boolean) {
+    super.activate(force)
+    end()
+  }
+
+  override fun onCancel() {
+    handler?.removeCallbacksAndMessages(null)
+  }
+
+  override fun onReset() {
+    tapsSoFar = 0
+    currentMaxNumberOfPointers = 0
+    handler?.removeCallbacksAndMessages(null)
+  }
+
+  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
+  }
+}

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

@@ -0,0 +1,10 @@
+package com.swmansion.gesturehandler.core
+
+import android.view.View
+import android.view.ViewGroup
+
+interface ViewConfigurationHelper {
+  fun getPointerEventsConfigForView(view: View): PointerEventsConfig
+  fun getChildInDrawingOrderAtIndex(parent: ViewGroup, index: Int): View
+  fun isViewClippingChildren(view: ViewGroup): Boolean
+}

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

@@ -0,0 +1,16 @@
+package com.swmansion.gesturehandler.react
+
+import android.content.Context
+import android.view.accessibility.AccessibilityManager
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.facebook.react.uimanager.UIManagerModule
+
+val ReactContext.deviceEventEmitter: DeviceEventManagerModule.RCTDeviceEventEmitter
+  get() = this.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+
+val ReactContext.UIManager: UIManagerModule
+  get() = this.getNativeModule(UIManagerModule::class.java)!!
+
+fun Context.isScreenReaderOn() =
+  (getSystemService(Context.ACCESSIBILITY_SERVICE) as AccessibilityManager).isTouchExplorationEnabled

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

@@ -0,0 +1,423 @@
+package com.swmansion.gesturehandler.react
+
+import android.annotation.SuppressLint
+import android.annotation.TargetApi
+import android.content.Context
+import android.content.res.ColorStateList
+import android.graphics.Color
+import android.graphics.drawable.Drawable
+import android.graphics.drawable.LayerDrawable
+import android.graphics.drawable.PaintDrawable
+import android.graphics.drawable.RippleDrawable
+import android.graphics.drawable.ShapeDrawable
+import android.graphics.drawable.shapes.RectShape
+import android.os.Build
+import android.util.TypedValue
+import android.view.KeyEvent
+import android.view.MotionEvent
+import android.view.View
+import android.view.View.OnClickListener
+import android.view.ViewGroup
+import android.view.ViewParent
+import androidx.core.view.children
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.uimanager.PixelUtil
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.ViewGroupManager
+import com.facebook.react.uimanager.ViewManagerDelegate
+import com.facebook.react.uimanager.ViewProps
+import com.facebook.react.uimanager.annotations.ReactProp
+import com.facebook.react.viewmanagers.RNGestureHandlerButtonManagerDelegate
+import com.facebook.react.viewmanagers.RNGestureHandlerButtonManagerInterface
+import com.swmansion.gesturehandler.core.NativeViewGestureHandler
+import com.swmansion.gesturehandler.react.RNGestureHandlerButtonViewManager.ButtonViewGroup
+
+@ReactModule(name = RNGestureHandlerButtonViewManager.REACT_CLASS)
+class RNGestureHandlerButtonViewManager : ViewGroupManager<ButtonViewGroup>(), RNGestureHandlerButtonManagerInterface<ButtonViewGroup> {
+  private val mDelegate: ViewManagerDelegate<ButtonViewGroup>
+
+  init {
+    mDelegate = RNGestureHandlerButtonManagerDelegate<ButtonViewGroup, RNGestureHandlerButtonViewManager>(this)
+  }
+
+  override fun getName() = REACT_CLASS
+
+  public override fun createViewInstance(context: ThemedReactContext) = ButtonViewGroup(context)
+
+  @TargetApi(Build.VERSION_CODES.M)
+  @ReactProp(name = "foreground")
+  override fun setForeground(view: ButtonViewGroup, useDrawableOnForeground: Boolean) {
+    view.useDrawableOnForeground = useDrawableOnForeground
+  }
+
+  @ReactProp(name = "borderless")
+  override fun setBorderless(view: ButtonViewGroup, useBorderlessDrawable: Boolean) {
+    view.useBorderlessDrawable = useBorderlessDrawable
+  }
+
+  @ReactProp(name = "enabled")
+  override fun setEnabled(view: ButtonViewGroup, enabled: Boolean) {
+    view.isEnabled = enabled
+  }
+
+  @ReactProp(name = ViewProps.BORDER_RADIUS)
+  override fun setBorderRadius(view: ButtonViewGroup, borderRadius: Float) {
+    view.borderRadius = borderRadius
+  }
+
+  @ReactProp(name = "rippleColor")
+  override fun setRippleColor(view: ButtonViewGroup, rippleColor: Int?) {
+    view.rippleColor = rippleColor
+  }
+
+  @ReactProp(name = "rippleRadius")
+  override fun setRippleRadius(view: ButtonViewGroup, rippleRadius: Int) {
+    view.rippleRadius = rippleRadius
+  }
+
+  @ReactProp(name = "exclusive")
+  override fun setExclusive(view: ButtonViewGroup, exclusive: Boolean) {
+    view.exclusive = exclusive
+  }
+
+  @ReactProp(name = "touchSoundDisabled")
+  override fun setTouchSoundDisabled(view: ButtonViewGroup, touchSoundDisabled: Boolean) {
+    view.isSoundEffectsEnabled = !touchSoundDisabled
+  }
+
+  override fun onAfterUpdateTransaction(view: ButtonViewGroup) {
+    view.updateBackground()
+  }
+
+  override fun getDelegate(): ViewManagerDelegate<ButtonViewGroup>? {
+    return mDelegate
+  }
+
+  class ButtonViewGroup(context: Context?) :
+    ViewGroup(context),
+    NativeViewGestureHandler.NativeViewGestureHandlerHook {
+    // Using object because of handling null representing no value set.
+    var rippleColor: Int? = null
+      set(color) = withBackgroundUpdate {
+        field = color
+      }
+
+    var rippleRadius: Int? = null
+      set(radius) = withBackgroundUpdate {
+        field = radius
+      }
+    var useDrawableOnForeground = false
+      set(useForeground) = withBackgroundUpdate {
+        field = useForeground
+      }
+    var useBorderlessDrawable = false
+    var borderRadius = 0f
+      set(radius) = withBackgroundUpdate {
+        field = radius * resources.displayMetrics.density
+      }
+    var exclusive = true
+
+    private var _backgroundColor = Color.TRANSPARENT
+    private var needBackgroundUpdate = false
+    private var lastEventTime = -1L
+    private var lastAction = -1
+    private var receivedKeyEvent = false
+
+    var isTouched = false
+
+    init {
+      // we attach empty click listener to trigger tap sounds (see View#performClick())
+      setOnClickListener(dummyClickListener)
+      isClickable = true
+      isFocusable = true
+      needBackgroundUpdate = true
+      clipChildren = false
+    }
+
+    private inline fun withBackgroundUpdate(block: () -> Unit) {
+      block()
+      needBackgroundUpdate = true
+    }
+
+    override fun setBackgroundColor(color: Int) = withBackgroundUpdate {
+      _backgroundColor = color
+    }
+
+    override fun onInterceptTouchEvent(ev: MotionEvent): Boolean {
+      if (super.onInterceptTouchEvent(ev)) {
+        return true
+      }
+      // We call `onTouchEvent` and wait until button changes state to `pressed`, if it's pressed
+      // we return true so that the gesture handler can activate.
+      onTouchEvent(ev)
+      return isPressed
+    }
+
+    /**
+     * Buttons in RN are wrapped in NativeViewGestureHandler which manages
+     * calling onTouchEvent after activation of the handler. Problem is, in order to verify that
+     * underlying button implementation is interested in receiving touches we have to call onTouchEvent
+     * and check if button is pressed.
+     *
+     * This leads to invoking onTouchEvent twice which isn't idempotent in View - it calls OnClickListener
+     * and plays sound effect if OnClickListener was set.
+     *
+     * To mitigate this behavior we use lastEventTime and lastAction variables to check that we already handled
+     * the event in [onInterceptTouchEvent]. We assume here that different events
+     * will have different event times or actions.
+     * Events with same event time can occur on some devices for different actions.
+     * (e.g. move and up in one gesture; move and cancel)
+     *
+     * Reference:
+     * [com.swmansion.gesturehandler.NativeViewGestureHandler.onHandle]  */
+    @SuppressLint("ClickableViewAccessibility")
+    override fun onTouchEvent(event: MotionEvent): Boolean {
+      if (event.action == MotionEvent.ACTION_CANCEL) {
+        tryFreeingResponder()
+        return super.onTouchEvent(event)
+      }
+
+      val eventTime = event.eventTime
+      val action = event.action
+      // always true when lastEventTime or lastAction have default value (-1)
+      if (lastEventTime != eventTime || lastAction != action) {
+        lastEventTime = eventTime
+        lastAction = action
+        return super.onTouchEvent(event)
+      }
+      return false
+    }
+
+    private fun updateBackgroundColor(backgroundColor: Int, borderRadius: Float, selectable: Drawable?) {
+      val colorDrawable = PaintDrawable(backgroundColor)
+
+      if (borderRadius != 0f) {
+        colorDrawable.setCornerRadius(borderRadius)
+      }
+
+      val layerDrawable = LayerDrawable(if (selectable != null) arrayOf(colorDrawable, selectable) else arrayOf(colorDrawable))
+      background = layerDrawable
+    }
+
+    fun updateBackground() {
+      if (!needBackgroundUpdate) {
+        return
+      }
+      needBackgroundUpdate = false
+
+      if (_backgroundColor == Color.TRANSPARENT) {
+        // reset background
+        background = null
+      }
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+        // reset foreground
+        foreground = null
+      }
+
+      val selectable = createSelectableDrawable()
+
+      if (borderRadius != 0f) {
+        // Radius-connected lines below ought to be considered
+        // as a temporary solution. It do not allow to set
+        // different radius on each corner. However, I suppose it's fairly
+        // fine for button-related use cases.
+        // Therefore it might be used as long as:
+        // 1. ReactViewManager is not a generic class with a possibility to handle another ViewGroup
+        // 2. There's no way to force native behavior of ReactViewGroup's superclass's onTouchEvent
+        if (selectable is RippleDrawable) {
+          val mask = PaintDrawable(Color.WHITE)
+          mask.setCornerRadius(borderRadius)
+          selectable.setDrawableByLayerId(android.R.id.mask, mask)
+        }
+      }
+
+      if (useDrawableOnForeground && Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+        foreground = selectable
+        if (_backgroundColor != Color.TRANSPARENT) {
+          updateBackgroundColor(_backgroundColor, borderRadius, null)
+        }
+      } else if (_backgroundColor == Color.TRANSPARENT && rippleColor == null) {
+        background = selectable
+      } else {
+        updateBackgroundColor(_backgroundColor, borderRadius, selectable)
+      }
+    }
+
+    private fun createSelectableDrawable(): Drawable? {
+      // don't create ripple drawable at all when it's not supposed to be visible
+      if (rippleColor == Color.TRANSPARENT) {
+        return null
+      }
+
+      val states = arrayOf(intArrayOf(android.R.attr.state_enabled))
+      val rippleRadius = rippleRadius
+      val colorStateList = if (rippleColor != null) {
+        val colors = intArrayOf(rippleColor!!)
+        ColorStateList(states, colors)
+      } else {
+        // if rippleColor is null, reapply the default color
+        context.theme.resolveAttribute(android.R.attr.colorControlHighlight, resolveOutValue, true)
+        val colors = intArrayOf(resolveOutValue.data)
+        ColorStateList(states, colors)
+      }
+
+      val drawable = RippleDrawable(
+        colorStateList,
+        null,
+        if (useBorderlessDrawable) null else ShapeDrawable(RectShape())
+      )
+
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M && rippleRadius != null) {
+        drawable.radius = PixelUtil.toPixelFromDIP(rippleRadius.toFloat()).toInt()
+      }
+
+      return drawable
+    }
+
+    override fun onLayout(changed: Boolean, l: Int, t: Int, r: Int, b: Int) {
+      // No-op
+    }
+
+    override fun drawableHotspotChanged(x: Float, y: Float) {
+      if (touchResponder == null || touchResponder === this) {
+        super.drawableHotspotChanged(x, y)
+      }
+    }
+
+    override fun canBegin(): Boolean {
+      val isResponder = tryGrabbingResponder()
+      if (isResponder) {
+        isTouched = true
+      }
+      return isResponder
+    }
+
+    override fun afterGestureEnd(event: MotionEvent) {
+      tryFreeingResponder()
+      isTouched = false
+    }
+
+    private fun tryFreeingResponder() {
+      if (touchResponder === this) {
+        touchResponder = null
+        soundResponder = this
+      }
+    }
+
+    private fun tryGrabbingResponder(): Boolean {
+      if (isChildTouched()) {
+        return false
+      }
+
+      if (touchResponder == null) {
+        touchResponder = this
+        return true
+      }
+      return if (exclusive) {
+        touchResponder === this
+      } else {
+        !(touchResponder?.exclusive ?: false)
+      }
+    }
+
+    private fun isChildTouched(children: Sequence<View> = this.children): Boolean {
+      for (child in children) {
+        if (child is ButtonViewGroup && (child.isTouched || child.isPressed)) {
+          return true
+        } else if (child is ViewGroup) {
+          if (isChildTouched(child.children)) {
+            return true
+          }
+        }
+      }
+
+      return false
+    }
+
+    override fun onKeyUp(keyCode: Int, event: KeyEvent?): Boolean {
+      receivedKeyEvent = true
+      return super.onKeyUp(keyCode, event)
+    }
+
+    override fun performClick(): Boolean {
+      // don't preform click when a child button is pressed (mainly to prevent sound effect of
+      // a parent button from playing)
+      return if (!isChildTouched()) {
+
+        if (context.isScreenReaderOn()) {
+          findGestureHandlerRootView()?.activateNativeHandlers(this)
+        } else if (receivedKeyEvent) {
+          findGestureHandlerRootView()?.activateNativeHandlers(this)
+          receivedKeyEvent = false
+        }
+
+        if (soundResponder === this) {
+          tryFreeingResponder()
+          soundResponder = null
+          super.performClick()
+        } else {
+          false
+        }
+      } else {
+        false
+      }
+    }
+
+    override fun setPressed(pressed: Boolean) {
+      // there is a possibility of this method being called before NativeViewGestureHandler has
+      // opportunity to call canStart, in that case we need to grab responder in case the gesture
+      // will activate
+      // when canStart is called eventually, tryGrabbingResponder will return true if the button
+      // already is a responder
+      if (pressed) {
+        if (tryGrabbingResponder()) {
+          soundResponder = this
+        }
+      }
+      // button can be pressed alongside other button if both are non-exclusive and it doesn't have
+      // any pressed children (to prevent pressing the parent when children is pressed).
+      val canBePressedAlongsideOther = !exclusive && touchResponder?.exclusive != true && !isChildTouched()
+
+      if (!pressed || touchResponder === this || canBePressedAlongsideOther) {
+        // we set pressed state only for current responder or any non-exclusive button when responder
+        // is null or non-exclusive, assuming it doesn't have pressed children
+        isTouched = pressed
+        super.setPressed(pressed)
+      }
+      if (!pressed && touchResponder === this) {
+        // if the responder is no longer pressed we release button responder
+        isTouched = false
+      }
+    }
+
+    override fun dispatchDrawableHotspotChanged(x: Float, y: Float) {
+      // No-op
+      // by default Viewgroup would pass hotspot change events
+    }
+
+    private fun findGestureHandlerRootView(): RNGestureHandlerRootView? {
+      var parent: ViewParent? = this.parent
+      var gestureHandlerRootView: RNGestureHandlerRootView? = null
+
+      while (parent != null) {
+        if (parent is RNGestureHandlerRootView) {
+          gestureHandlerRootView = parent
+        }
+        parent = parent.parent
+      }
+
+      return gestureHandlerRootView
+    }
+
+    companion object {
+      var resolveOutValue = TypedValue()
+      var touchResponder: ButtonViewGroup? = null
+      var soundResponder: ButtonViewGroup? = null
+      var dummyClickListener = OnClickListener { }
+    }
+  }
+
+  companion object {
+    const val REACT_CLASS = "RNGestureHandlerButton"
+  }
+}

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

@@ -0,0 +1,15 @@
+package com.swmansion.gesturehandler.react
+
+import android.content.Context
+import android.util.AttributeSet
+import com.facebook.react.ReactRootView
+
+@Deprecated(message = "Use <GestureHandlerRootView /> component instead. Check gesture handler installation instructions in documentation for more information.")
+class RNGestureHandlerEnabledRootView : ReactRootView {
+  constructor(context: Context?) : super(context) {}
+  constructor(context: Context?, attrs: AttributeSet?) : super(context, attrs) {}
+
+  init {
+    throw UnsupportedOperationException("Your application is configured to use RNGestureHandlerEnabledRootView which is no longer supported. You can see how to migrate to <GestureHandlerRootView /> here: https://docs.swmansion.com/react-native-gesture-handler/docs/guides/migrating-off-rnghenabledroot")
+  }
+}