expo-dev-menu 2.2.0 → 3.0.0

package/vendored/react-native-gesture-handler/android/devmenu/com/swmansion/gesturehandler/LongPressGestureHandler.kt

@@ -1,97 +0,0 @@
-package devmenu.com.swmansion.gesturehandler
-
-import android.content.Context
-import android.os.Handler
-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)
-    defaultMaxDistSq = DEFAULT_MAX_DIST_DP * context.resources.displayMetrics.density
-    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) {
-    if (state == STATE_UNDETERMINED) {
-      previousTime = SystemClock.uptimeMillis()
-      startTime = previousTime
-      begin()
-      startX = event.rawX
-      startY = event.rawY
-      handler = Handler()
-      if (minDurationMs > 0) {
-        handler!!.postDelayed({ activate() }, minDurationMs)
-      } else if (minDurationMs == 0L) {
-        activate()
-      }
-    }
-    if (event.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 = event.rawX - startX
-      val deltaY = event.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/vendored/react-native-gesture-handler/android/devmenu/com/swmansion/gesturehandler/ManualGestureHandler.kt

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

package/vendored/react-native-gesture-handler/android/devmenu/com/swmansion/gesturehandler/NativeViewGestureHandler.kt

@@ -1,129 +0,0 @@
-package devmenu.com.swmansion.gesturehandler
-
-import android.os.SystemClock
-import android.view.MotionEvent
-import android.view.View
-import android.view.ViewGroup
-import devmenu.com.swmansion.gesturehandler.react.RNGestureHandlerButtonViewManager
-
-class NativeViewGestureHandler : GestureHandler<NativeViewGestureHandler>() {
-  private var shouldActivateOnStart = false
-  private var disallowInterruption = false
-
-  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 (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.
-      val nativeWrapper = handler
-      if (nativeWrapper.state == STATE_ACTIVE && nativeWrapper.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
-    // otherwise we can only return `true` if already in an active state
-  }
-
-  override fun shouldBeCancelledBy(handler: GestureHandler<*>): Boolean {
-    return !disallowInterruption
-  }
-
-  private fun canStart(): Boolean {
-    val view = view
-    if (view is StateChangeHook) {
-      return view.canStart()
-    }
-
-    return true
-  }
-
-  private fun afterGestureEnd() {
-    val view = view
-    if (view is StateChangeHook) {
-      view.afterGestureEnd()
-    }
-  }
-
-  override fun onHandle(event: MotionEvent) {
-    val view = view!!
-    if (event.actionMasked == MotionEvent.ACTION_UP) {
-      view.onTouchEvent(event)
-      if ((state == STATE_UNDETERMINED || state == STATE_BEGAN) && view.isPressed) {
-        activate()
-      }
-      end()
-      afterGestureEnd()
-    } else if (state == STATE_UNDETERMINED || state == STATE_BEGAN) {
-      when {
-        shouldActivateOnStart -> {
-          tryIntercept(view, event)
-          view.onTouchEvent(event)
-          activate()
-        }
-        tryIntercept(view, event) -> {
-          view.onTouchEvent(event)
-          activate()
-        }
-        state != STATE_BEGAN -> {
-          if (canStart()) {
-            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)
-  }
-
-  companion object {
-    private fun tryIntercept(view: View, event: MotionEvent) =
-      view is ViewGroup && view.onInterceptTouchEvent(event)
-  }
-
-  interface StateChangeHook {
-    fun canStart(): Boolean
-    fun afterGestureEnd()
-  }
-}

package/vendored/react-native-gesture-handler/android/devmenu/com/swmansion/gesturehandler/OnTouchEventListener.kt

@@ -1,9 +0,0 @@
-package devmenu.com.swmansion.gesturehandler
-
-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)
-}

package/vendored/react-native-gesture-handler/android/devmenu/com/swmansion/gesturehandler/PanGestureHandler.kt

@@ -1,289 +0,0 @@
-package devmenu.com.swmansion.gesturehandler
-
-import android.content.Context
-import android.view.MotionEvent
-import android.view.VelocityTracker
-import android.view.ViewConfiguration
-import devmenu.com.swmansion.gesturehandler.GestureUtils.getLastPointerX
-import devmenu.com.swmansion.gesturehandler.GestureUtils.getLastPointerY
-
-class PanGestureHandler(context: Context?) : GestureHandler<PanGestureHandler>() {
-  var velocityX = 0f
-    private set
-  var velocityY = 0f
-    private set
-  val translationX: Float
-    get() = lastX - startX + offsetX
-  val translationY: Float
-    get() = lastY - startY + offsetY
-
-  private val defaultMinDistSq: Float
-  private var minDistSq = MAX_VALUE_IGNORE
-  private var activeOffsetXStart = MIN_VALUE_IGNORE
-  private var activeOffsetXEnd = MAX_VALUE_IGNORE
-  private var failOffsetXStart = MAX_VALUE_IGNORE
-  private var failOffsetXEnd = MIN_VALUE_IGNORE
-  private var activeOffsetYStart = MIN_VALUE_IGNORE
-  private var activeOffsetYEnd = MAX_VALUE_IGNORE
-  private var failOffsetYStart = MAX_VALUE_IGNORE
-  private var failOffsetYEnd = MIN_VALUE_IGNORE
-  private var minVelocityX = MIN_VALUE_IGNORE
-  private var minVelocityY = MIN_VALUE_IGNORE
-  private var minVelocitySq = MIN_VALUE_IGNORE
-  private var minPointers = DEFAULT_MIN_POINTERS
-  private var maxPointers = DEFAULT_MAX_POINTERS
-  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 velocityTracker: VelocityTracker? = null
-  private var averageTouches = false
-
-  /**
-   * On Android when there are multiple pointers on the screen pan gestures most often just consider
-   * the last placed pointer. The behaviour on iOS is quite different where the x and y component
-   * of the pan pointer is calculated as an average out of all the pointers placed on the screen.
-   *
-   * This behaviour can be customized on android by setting averageTouches property of the handler
-   * object. This could be useful in particular for the usecases when we attach other handlers that
-   * recognizes multi-finger gestures such as rotation. In that case when we only rely on the last
-   * placed finger it is easier for the gesture handler to trigger when we do a rotation gesture
-   * because each finger when treated separately will travel some distance, whereas the average
-   * position of all the fingers will remain still while doing a rotation gesture.
-   */
-  init {
-    val vc = ViewConfiguration.get(context!!)
-    val touchSlop = vc.scaledTouchSlop
-    defaultMinDistSq = (touchSlop * touchSlop).toFloat()
-    minDistSq = defaultMinDistSq
-  }
-
-  override fun resetConfig() {
-    super.resetConfig()
-    activeOffsetXStart = MIN_VALUE_IGNORE
-    activeOffsetXEnd = MAX_VALUE_IGNORE
-    failOffsetXStart = MAX_VALUE_IGNORE
-    failOffsetXEnd = MIN_VALUE_IGNORE
-    activeOffsetYStart = MIN_VALUE_IGNORE
-    activeOffsetYEnd = MAX_VALUE_IGNORE
-    failOffsetYStart = MAX_VALUE_IGNORE
-    failOffsetYEnd = MIN_VALUE_IGNORE
-    minVelocityX = MIN_VALUE_IGNORE
-    minVelocityY = MIN_VALUE_IGNORE
-    minVelocitySq = MIN_VALUE_IGNORE
-    minDistSq = defaultMinDistSq
-    minPointers = DEFAULT_MIN_POINTERS
-    maxPointers = DEFAULT_MAX_POINTERS
-    averageTouches = false
-  }
-
-  fun setActiveOffsetXStart(activeOffsetXStart: Float) = apply {
-    this.activeOffsetXStart = activeOffsetXStart
-  }
-
-  fun setActiveOffsetXEnd(activeOffsetXEnd: Float) = apply {
-    this.activeOffsetXEnd = activeOffsetXEnd
-  }
-
-  fun setFailOffsetXStart(failOffsetXStart: Float) = apply {
-    this.failOffsetXStart = failOffsetXStart
-  }
-
-  fun setFailOffsetXEnd(failOffsetXEnd: Float) = apply {
-    this.failOffsetXEnd = failOffsetXEnd
-  }
-
-  fun setActiveOffsetYStart(activeOffsetYStart: Float) = apply {
-    this.activeOffsetYStart = activeOffsetYStart
-  }
-
-  fun setActiveOffsetYEnd(activeOffsetYEnd: Float) = apply {
-    this.activeOffsetYEnd = activeOffsetYEnd
-  }
-
-  fun setFailOffsetYStart(failOffsetYStart: Float) = apply {
-    this.failOffsetYStart = failOffsetYStart
-  }
-
-  fun setFailOffsetYEnd(failOffsetYEnd: Float) = apply {
-    this.failOffsetYEnd = failOffsetYEnd
-  }
-
-  fun setMinDist(minDist: Float) = apply {
-    minDistSq = minDist * minDist
-  }
-
-  fun setMinPointers(minPointers: Int) = apply {
-    this.minPointers = minPointers
-  }
-
-  fun setMaxPointers(maxPointers: Int) = apply {
-    this.maxPointers = maxPointers
-  }
-
-  fun setAverageTouches(averageTouches: Boolean) = apply {
-    this.averageTouches = averageTouches
-  }
-
-  /**
-   * @param minVelocity in pixels per second
-   */
-  fun setMinVelocity(minVelocity: Float) = apply {
-    minVelocitySq = minVelocity * minVelocity
-  }
-
-  fun setMinVelocityX(minVelocityX: Float) = apply {
-    this.minVelocityX = minVelocityX
-  }
-
-  fun setMinVelocityY(minVelocityY: Float) = apply {
-    this.minVelocityY = minVelocityY
-  }
-
-  private fun shouldActivate(): Boolean {
-    val dx = lastX - startX + offsetX
-    if (activeOffsetXStart != MIN_VALUE_IGNORE && dx < activeOffsetXStart) {
-      return true
-    }
-    if (activeOffsetXEnd != MAX_VALUE_IGNORE && dx > activeOffsetXEnd) {
-      return true
-    }
-    val dy = lastY - startY + offsetY
-    if (activeOffsetYStart != MIN_VALUE_IGNORE && dy < activeOffsetYStart) {
-      return true
-    }
-    if (activeOffsetYEnd != MAX_VALUE_IGNORE && dy > activeOffsetYEnd) {
-      return true
-    }
-    val distSq = dx * dx + dy * dy
-    if (minDistSq != MIN_VALUE_IGNORE && distSq >= minDistSq) {
-      return true
-    }
-    val vx = velocityX
-    if (minVelocityX != MIN_VALUE_IGNORE &&
-      (minVelocityX < 0 && vx <= minVelocityX || minVelocityX in 0.0f..vx)) {
-      return true
-    }
-    val vy = velocityY
-    if (minVelocityY != MIN_VALUE_IGNORE &&
-      (minVelocityY < 0 && vx <= minVelocityY || minVelocityY in 0.0f..vx)) {
-      return true
-    }
-    val velocitySq = vx * vx + vy * vy
-    return minVelocitySq != MIN_VALUE_IGNORE && velocitySq >= minVelocitySq
-  }
-
-  private fun shouldFail(): Boolean {
-    val dx = lastX - startX + offsetX
-    if (failOffsetXStart != MAX_VALUE_IGNORE && dx < failOffsetXStart) {
-      return true
-    }
-    if (failOffsetXEnd != MIN_VALUE_IGNORE && dx > failOffsetXEnd) {
-      return true
-    }
-    val dy = lastY - startY + offsetY
-    if (failOffsetYStart != MAX_VALUE_IGNORE && dy < failOffsetYStart) {
-      return true
-    }
-    return failOffsetYEnd != MIN_VALUE_IGNORE && dy > failOffsetYEnd
-  }
-
-  override fun onHandle(event: MotionEvent) {
-    val state = state
-    val action = event.actionMasked
-    if (action == MotionEvent.ACTION_POINTER_UP || action == MotionEvent.ACTION_POINTER_DOWN) {
-      // update offset if new pointer gets added or removed
-      offsetX += lastX - startX
-      offsetY += lastY - startY
-
-      // reset starting point
-      lastX = getLastPointerX(event, averageTouches)
-      lastY = getLastPointerY(event, averageTouches)
-      startX = lastX
-      startY = lastY
-    } else {
-      lastX = getLastPointerX(event, averageTouches)
-      lastY = getLastPointerY(event, averageTouches)
-    }
-    if (state == STATE_UNDETERMINED && event.pointerCount >= minPointers) {
-      startX = lastX
-      startY = lastY
-      offsetX = 0f
-      offsetY = 0f
-      velocityX = 0f
-      velocityY = 0f
-      velocityTracker = VelocityTracker.obtain()
-      addVelocityMovement(velocityTracker, event)
-      begin()
-    } else if (velocityTracker != null) {
-      addVelocityMovement(velocityTracker, event)
-      velocityTracker!!.computeCurrentVelocity(1000)
-      velocityX = velocityTracker!!.xVelocity
-      velocityY = velocityTracker!!.yVelocity
-    }
-    if (action == MotionEvent.ACTION_UP) {
-      if (state == STATE_ACTIVE) {
-        end()
-      } else {
-        fail()
-      }
-    } else if (action == MotionEvent.ACTION_POINTER_DOWN && event.pointerCount > maxPointers) {
-      // When new finger is placed down (POINTER_DOWN) we check if MAX_POINTERS is not exceeded
-      if (state == STATE_ACTIVE) {
-        cancel()
-      } else {
-        fail()
-      }
-    } else if (action == MotionEvent.ACTION_POINTER_UP && state == STATE_ACTIVE && event.pointerCount < minPointers) {
-      // When finger is lifted up (POINTER_UP) and the number of pointers falls below MIN_POINTERS
-      // threshold, we only want to take an action when the handler has already activated. Otherwise
-      // we can still expect more fingers to be placed on screen and fulfill MIN_POINTERS criteria.
-      fail()
-    } else if (state == STATE_BEGAN) {
-      if (shouldFail()) {
-        fail()
-      } else if (shouldActivate()) {
-        activate()
-      }
-    }
-  }
-
-  override fun activate(force: Boolean) {
-    // reset starting point if the handler has not yet activated
-    if (state != STATE_ACTIVE) {
-      startX = lastX
-      startY = lastY
-    }
-    super.activate(force)
-  }
-
-  override fun onReset() {
-    velocityTracker?.let {
-      it.recycle()
-      velocityTracker = null
-    }
-  }
-
-  companion object {
-    private const val MIN_VALUE_IGNORE = Float.MAX_VALUE
-    private const val MAX_VALUE_IGNORE = Float.MIN_VALUE
-    private const val DEFAULT_MIN_POINTERS = 1
-    private const val DEFAULT_MAX_POINTERS = 10
-
-    /**
-     * This method adds movement to {@class VelocityTracker} first resetting offset of the event so
-     * that the velocity is calculated based on the absolute position of touch pointers. This is
-     * because if the underlying view moves along with the finger using relative x/y coords yields
-     * incorrect results.
-     */
-    private fun addVelocityMovement(tracker: VelocityTracker?, event: MotionEvent) {
-      val offsetX = event.rawX - event.x
-      val offsetY = event.rawY - event.y
-      event.offsetLocation(offsetX, offsetY)
-      tracker!!.addMovement(event)
-      event.offsetLocation(-offsetX, -offsetY)
-    }
-  }
-}

package/vendored/react-native-gesture-handler/android/devmenu/com/swmansion/gesturehandler/PinchGestureHandler.kt

@@ -1,88 +0,0 @@
-package devmenu.com.swmansion.gesturehandler
-
-import android.view.MotionEvent
-import android.view.ScaleGestureDetector
-import android.view.ScaleGestureDetector.OnScaleGestureListener
-import android.view.ViewConfiguration
-import kotlin.math.abs
-
-class PinchGestureHandler : GestureHandler<PinchGestureHandler>() {
-  var scale = 0.0
-    private set
-  var velocity = 0.0
-    private set
-  val focalPointX: Float
-    get() = scaleGestureDetector?.focusX ?: Float.NaN
-  val focalPointY: Float
-    get() = scaleGestureDetector?.focusY ?: Float.NaN
-
-  private var scaleGestureDetector: ScaleGestureDetector? = null
-  private var startingSpan = 0f
-  private var spanSlop = 0f
-  private val gestureListener: OnScaleGestureListener = object : OnScaleGestureListener {
-    override fun onScale(detector: ScaleGestureDetector): Boolean {
-      val prevScaleFactor: Double = scale
-      scale *= detector.scaleFactor.toDouble()
-      val delta = detector.timeDelta
-      if (delta > 0) {
-        velocity = (scale - prevScaleFactor) / delta
-      }
-      if (abs(startingSpan - detector.currentSpan) >= spanSlop
-        && state == STATE_BEGAN) {
-        activate()
-      }
-      return true
-    }
-
-    init {
-      setShouldCancelWhenOutside(false)
-    }
-
-    override fun onScaleBegin(detector: ScaleGestureDetector): Boolean {
-      startingSpan = detector.currentSpan
-      return true
-    }
-
-    override fun onScaleEnd(detector: ScaleGestureDetector) {
-      // ScaleGestureDetector thinks that when fingers are 27mm away that's a sufficiently good
-      // reason to trigger this method giving us no other choice but to ignore it completely.
-    }
-  }
-
-  override fun onHandle(event: MotionEvent) {
-    if (state == STATE_UNDETERMINED) {
-      val context = view!!.context
-      velocity = 0.0
-      scale = 1.0
-      scaleGestureDetector = ScaleGestureDetector(context, gestureListener)
-      val configuration = ViewConfiguration.get(context)
-      spanSlop = configuration.scaledTouchSlop.toFloat()
-      begin()
-    }
-    scaleGestureDetector?.onTouchEvent(event)
-    var activePointers = event.pointerCount
-    if (event.actionMasked == MotionEvent.ACTION_POINTER_UP) {
-      activePointers -= 1
-    }
-    if (state == STATE_ACTIVE && activePointers < 2) {
-      end()
-    } else if (event.actionMasked == MotionEvent.ACTION_UP) {
-      fail()
-    }
-  }
-
-  override fun activate(force: Boolean) {
-    // reset scale if the handler has not yet activated
-    if (state != STATE_ACTIVE) {
-      velocity = 0.0
-      scale = 1.0
-    }
-    super.activate(force)
-  }
-
-  override fun onReset() {
-    scaleGestureDetector = null
-    velocity = 0.0
-    scale = 1.0
-  }
-}

package/vendored/react-native-gesture-handler/android/devmenu/com/swmansion/gesturehandler/PointerEventsConfig.kt

@@ -1,23 +0,0 @@
-package devmenu.com.swmansion.gesturehandler
-
-enum class PointerEventsConfig {
-  /**
-   * Neither the container nor its children receive events.
-   */
-  NONE,
-
-  /**
-   * Container doesn't get events but all of its children do.
-   */
-  BOX_NONE,
-
-  /**
-   * Container gets events but none of its children do.
-   */
-  BOX_ONLY,
-
-  /**
-   * Container and all of its children receive touch events (like pointerEvents is unspecified).
-   */
-  AUTO
-}