npm - @react-native-oh-tpl/react-native-gesture-handler - Versions diffs - 2.12.1-0.0.1 → 2.12.6-1 - Mend

@react-native-oh-tpl/react-native-gesture-handler 2.12.1-0.0.1 → 2.12.6-1

Files changed (918) hide show

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

@@ -1,168 +0,0 @@
-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 DELETED Viewed

@@ -1,10 +0,0 @@
-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 DELETED Viewed

@@ -1,16 +0,0 @@
-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 DELETED Viewed

@@ -1,423 +0,0 @@
-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 DELETED Viewed

@@ -1,15 +0,0 @@
-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")
-  }
-}