react-native-gesture-handler 2.4.2 → 2.5.0

package/README.md

@@ -24,7 +24,7 @@ Check out our dedicated documentation page for info about this library, API refe
 If you want to play with the API but don't feel like trying it on a real app, you can run the example project. Clone the repo, go to the `example` folder and run:
 
 ```bash
-  yarn install
+yarn install
 ```
 
 If you are running on ios, run `pod install` in the ios folder
@@ -44,7 +44,8 @@ You will need to have an Android or iOS device or emulator connected as well as
 | <1.1.0  | 0.50.0+              |
 
 It may be possible to use newer versions of react-native-gesture-handler on React Native with version <= 0.59 by reverse Jetifying.
-Read more on that here https://github.com/mikehardy/jetifier#to-reverse-jetify--convert-node_modules-dependencies-to-support-libraries
+Read more on that here <https://github.com/mikehardy/jetifier#to-reverse-jetify--convert-node_modules-dependencies-to-support-libraries>
+
 ## License
 
 Gesture handler library is licensed under [The MIT License](LICENSE).

package/android/lib/src/main/java/com/swmansion/gesturehandler/GestureHandler.kt

@@ -172,8 +172,12 @@ open class GestureHandler<ConcreteGestureHandlerT : GestureHandler<ConcreteGestu
       windowOffset[0] = 0
       windowOffset[1] = 0
     }
+
+    onPrepare()
   }
 
+  protected open fun onPrepare() {}
+
   private fun getWindow(context: Context?): Window? {
     if (context == null) return null
     if (context is Activity) return context.window
@@ -253,9 +257,9 @@ open class GestureHandler<ConcreteGestureHandlerT : GestureHandler<ConcreteGestu
     }
     initPointerProps(trackedPointersIDsCount)
     var count = 0
-    val oldX = event.x
-    val oldY = event.y
-    event.setLocation(event.rawX, event.rawY)
+    val deltaX = event.rawX - event.x
+    val deltaY = event.rawY - event.y
+    event.offsetLocation(deltaX, deltaY)
     var index = 0
     val size = event.pointerCount
     while (index < size) {
@@ -298,8 +302,8 @@ open class GestureHandler<ConcreteGestureHandlerT : GestureHandler<ConcreteGestu
     } catch (e: IllegalArgumentException) {
       throw AdaptEventException(this, event, e)
     }
-    event.setLocation(oldX, oldY)
-    result.setLocation(oldX, oldY)
+    event.offsetLocation(-deltaX, -deltaY)
+    result.offsetLocation(-deltaX, -deltaY)
     return result
   }
 

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

@@ -475,7 +475,12 @@ class GestureHandlerOrchestrator(
       PointerEventsConfig.BOX_NONE -> {
         // This view can't be the target, but its children might
         if (view is ViewGroup) {
-          extractGestureHandlers(view, coords, pointerId)
+          extractGestureHandlers(view, coords, pointerId).also { found ->
+            // A child view is handling touch, also extract handlers attached to this view
+            if (found) {
+              recordViewHandlersForPointer(view, coords, pointerId)
+            }
+          }
         } else false
       }
       PointerEventsConfig.AUTO -> {

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

@@ -3,13 +3,16 @@ package com.swmansion.gesturehandler
 import android.os.SystemClock
 import android.view.MotionEvent
 import android.view.View
+import android.view.ViewConfiguration
 import android.view.ViewGroup
-import com.swmansion.gesturehandler.react.RNGestureHandlerButtonViewManager
+import com.facebook.react.views.textinput.ReactEditText
 
 class NativeViewGestureHandler : GestureHandler<NativeViewGestureHandler>() {
   private var shouldActivateOnStart = false
   private var disallowInterruption = false
 
+  private var hook: NativeViewGestureHandlerHook = defaultHook
+
   init {
     setShouldCancelWhenOutside(true)
   }
@@ -34,13 +37,17 @@ class NativeViewGestureHandler : GestureHandler<NativeViewGestureHandler>() {
   }
 
   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.
-      val nativeWrapper = handler
-      if (nativeWrapper.state == STATE_ACTIVE && nativeWrapper.disallowInterruption) {
+      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
       }
@@ -52,7 +59,7 @@ class NativeViewGestureHandler : GestureHandler<NativeViewGestureHandler>() {
       // 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
+    } else state == STATE_ACTIVE && canBeInterrupted && (!hook.shouldCancelRootViewGestureHandlerIfNecessary() || handler.tag > 0)
     // otherwise we can only return `true` if already in an active state
   }
 
@@ -60,19 +67,10 @@ class NativeViewGestureHandler : GestureHandler<NativeViewGestureHandler>() {
     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 onPrepare() {
+    when (val view = view) {
+      is NativeViewGestureHandlerHook -> this.hook = view
+      is ReactEditText -> this.hook = EditTextHook(this, view)
     }
   }
 
@@ -84,7 +82,7 @@ class NativeViewGestureHandler : GestureHandler<NativeViewGestureHandler>() {
         activate()
       }
       end()
-      afterGestureEnd()
+      hook.afterGestureEnd(event)
     } else if (state == STATE_UNDETERMINED || state == STATE_BEGAN) {
       when {
         shouldActivateOnStart -> {
@@ -96,8 +94,11 @@ class NativeViewGestureHandler : GestureHandler<NativeViewGestureHandler>() {
           view.onTouchEvent(event)
           activate()
         }
+        hook.wantsToHandleEventBeforeActivation() -> {
+          hook.handleEventBeforeActivation(event)
+        }
         state != STATE_BEGAN -> {
-          if (canStart()) {
+          if (hook.canBegin()) {
             begin()
           } else {
             cancel()
@@ -117,13 +118,93 @@ class NativeViewGestureHandler : GestureHandler<NativeViewGestureHandler>() {
     view!!.onTouchEvent(event)
   }
 
+  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 StateChangeHook {
-    fun canStart(): Boolean
-    fun afterGestureEnd()
+  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
   }
 }

package/android/lib/src/main/java/com/swmansion/gesturehandler/PanGestureHandler.kt

@@ -1,6 +1,7 @@
 package com.swmansion.gesturehandler
 
 import android.content.Context
+import android.os.Handler
 import android.view.MotionEvent
 import android.view.VelocityTracker
 import android.view.ViewConfiguration
@@ -40,6 +41,9 @@ class PanGestureHandler(context: Context?) : GestureHandler<PanGestureHandler>()
   private var lastY = 0f
   private var velocityTracker: VelocityTracker? = null
   private var averageTouches = false
+  private var activateAfterLongPress = DEFAULT_ACTIVATE_AFTER_LONG_PRESS
+  private val activateDelayed = Runnable { activate() }
+  private var handler: Handler? = null
 
   /**
    * On Android when there are multiple pointers on the screen pan gestures most often just consider
@@ -54,7 +58,7 @@ class PanGestureHandler(context: Context?) : GestureHandler<PanGestureHandler>()
    * position of all the fingers will remain still while doing a rotation gesture.
    */
   init {
-    val vc = ViewConfiguration.get(context)
+    val vc = ViewConfiguration.get(context!!)
     val touchSlop = vc.scaledTouchSlop
     defaultMinDistSq = (touchSlop * touchSlop).toFloat()
     minDistSq = defaultMinDistSq
@@ -76,6 +80,7 @@ class PanGestureHandler(context: Context?) : GestureHandler<PanGestureHandler>()
     minDistSq = defaultMinDistSq
     minPointers = DEFAULT_MIN_POINTERS
     maxPointers = DEFAULT_MAX_POINTERS
+    activateAfterLongPress = DEFAULT_ACTIVATE_AFTER_LONG_PRESS
     averageTouches = false
   }
 
@@ -127,6 +132,10 @@ class PanGestureHandler(context: Context?) : GestureHandler<PanGestureHandler>()
     this.averageTouches = averageTouches
   }
 
+  fun setActivateAfterLongPress(time: Long) = apply {
+    this.activateAfterLongPress = time
+  }
+
   /**
    * @param minVelocity in pixels per second
    */
@@ -177,13 +186,18 @@ class PanGestureHandler(context: Context?) : GestureHandler<PanGestureHandler>()
 
   private fun shouldFail(): Boolean {
     val dx = lastX - startX + offsetX
+    val dy = lastY - startY + offsetY
+
+    if (activateAfterLongPress > 0 && dx * dx + dy * dy > defaultMinDistSq) {
+      handler?.removeCallbacksAndMessages(null)
+      return true
+    }
     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
     }
@@ -216,6 +230,13 @@ class PanGestureHandler(context: Context?) : GestureHandler<PanGestureHandler>()
       velocityTracker = VelocityTracker.obtain()
       addVelocityMovement(velocityTracker, event)
       begin()
+
+      if (activateAfterLongPress > 0) {
+        if (handler == null) {
+          handler = Handler()
+        }
+        handler!!.postDelayed(activateDelayed, activateAfterLongPress)
+      }
     } else if (velocityTracker != null) {
       addVelocityMovement(velocityTracker, event)
       velocityTracker!!.computeCurrentVelocity(1000)
@@ -257,7 +278,12 @@ class PanGestureHandler(context: Context?) : GestureHandler<PanGestureHandler>()
     super.activate(force)
   }
 
+  override fun onCancel() {
+    handler?.removeCallbacksAndMessages(null)
+  }
+
   override fun onReset() {
+    handler?.removeCallbacksAndMessages(null)
     velocityTracker?.let {
       it.recycle()
       velocityTracker = null
@@ -274,6 +300,7 @@ class PanGestureHandler(context: Context?) : GestureHandler<PanGestureHandler>()
     private const val MAX_VALUE_IGNORE = Float.MIN_VALUE
     private const val DEFAULT_MIN_POINTERS = 1
     private const val DEFAULT_MAX_POINTERS = 10
+    private const val DEFAULT_ACTIVATE_AFTER_LONG_PRESS = 0L
 
     /**
      * This method adds movement to {@class VelocityTracker} first resetting offset of the event so

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

@@ -9,6 +9,8 @@ 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.MotionEvent
@@ -16,7 +18,6 @@ import android.view.View
 import android.view.View.OnClickListener
 import android.view.ViewGroup
 import androidx.core.view.children
-import com.facebook.react.bridge.SoftAssertions
 import com.facebook.react.module.annotations.ReactModule
 import com.facebook.react.uimanager.PixelUtil
 import com.facebook.react.uimanager.ThemedReactContext
@@ -77,6 +78,11 @@ class RNGestureHandlerButtonViewManager : ViewGroupManager<ButtonViewGroup>(), R
     view.exclusive = exclusive
   }
 
+  @ReactProp(name = "touchSoundDisabled")
+  override fun setTouchSoundDisabled(view: ButtonViewGroup, touchSoundDisabled: Boolean) {
+    view.isSoundEffectsEnabled = !touchSoundDisabled
+  }
+
   override fun onAfterUpdateTransaction(view: ButtonViewGroup) {
     view.updateBackground()
   }
@@ -86,7 +92,7 @@ class RNGestureHandlerButtonViewManager : ViewGroupManager<ButtonViewGroup>(), R
   }
 
   class ButtonViewGroup(context: Context?) : ViewGroup(context),
-    NativeViewGestureHandler.StateChangeHook {
+    NativeViewGestureHandler.NativeViewGestureHandlerHook {
     // Using object because of handling null representing no value set.
     var rippleColor: Int? = null
       set(color) = withBackgroundUpdate {
@@ -132,30 +138,6 @@ class RNGestureHandlerButtonViewManager : ViewGroupManager<ButtonViewGroup>(), R
       _backgroundColor = color
     }
 
-    private fun applyRippleEffectWhenNeeded(selectable: Drawable): Drawable {
-      val rippleColor = rippleColor
-      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP && selectable is RippleDrawable) {
-        val states = arrayOf(intArrayOf(android.R.attr.state_enabled))
-        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)
-        }
-
-        selectable.setColor(colorStateList)
-      }
-
-      val rippleRadius = rippleRadius
-      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M && rippleRadius != null && selectable is RippleDrawable) {
-        selectable.radius = PixelUtil.toPixelFromDIP(rippleRadius.toFloat()).toInt()
-      }
-      return selectable
-    }
-
     override fun onInterceptTouchEvent(ev: MotionEvent): Boolean {
       if (super.onInterceptTouchEvent(ev)) {
         return true
@@ -210,49 +192,74 @@ class RNGestureHandlerButtonViewManager : ViewGroupManager<ButtonViewGroup>(), R
         // 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 (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP && 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 = applyRippleEffectWhenNeeded(createSelectableDrawable())
+        foreground = selectable
         if (_backgroundColor != Color.TRANSPARENT) {
           setBackgroundColor(_backgroundColor)
         }
       } else if (_backgroundColor == Color.TRANSPARENT && rippleColor == null) {
-        background = createSelectableDrawable()
+        background = selectable
       } else {
         val colorDrawable = PaintDrawable(_backgroundColor)
-        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
           colorDrawable.setCornerRadius(borderRadius)
-          if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP
-            && selectable is RippleDrawable) {
-            val mask = PaintDrawable(Color.WHITE)
-            mask.setCornerRadius(borderRadius)
-            selectable.setDrawableByLayerId(android.R.id.mask, mask)
-          }
         }
-        applyRippleEffectWhenNeeded(selectable)
+
         val layerDrawable = LayerDrawable(arrayOf(colorDrawable, selectable))
         background = layerDrawable
       }
     }
 
     private fun createSelectableDrawable(): Drawable {
-      val version = Build.VERSION.SDK_INT
-      val identifier = if (useBorderlessDrawable && version >= 21) SELECTABLE_ITEM_BACKGROUND_BORDERLESS else SELECTABLE_ITEM_BACKGROUND
-      val attrID = getAttrId(context, identifier)
-      context.theme.resolveAttribute(attrID, resolveOutValue, true)
-      return if (version >= 21) {
-        resources.getDrawable(resolveOutValue.resourceId, context.theme)
-      } else {
+      // TODO: remove once support for RN 0.63 is dropped, since 0.64 minSdkVersion is 21
+      if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) {
+        context.theme.resolveAttribute(android.R.attr.selectableItemBackground, resolveOutValue, true)
         @Suppress("Deprecation")
-        resources.getDrawable(resolveOutValue.resourceId)
+        return resources.getDrawable(resolveOutValue.resourceId)
+      }
+
+      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) {
@@ -265,7 +272,7 @@ class RNGestureHandlerButtonViewManager : ViewGroupManager<ButtonViewGroup>(), R
       }
     }
 
-    override fun canStart(): Boolean {
+    override fun canBegin(): Boolean {
       val isResponder = tryGrabbingResponder()
       if (isResponder) {
         isTouched = true
@@ -273,11 +280,6 @@ class RNGestureHandlerButtonViewManager : ViewGroupManager<ButtonViewGroup>(), R
       return isResponder
     }
 
-    override fun afterGestureEnd() {
-      tryFreeingResponder()
-      isTouched = false
-    }
-
     private fun tryGrabbingResponder(): Boolean {
       if (isChildTouched()) {
         return false
@@ -294,24 +296,30 @@ class RNGestureHandlerButtonViewManager : ViewGroupManager<ButtonViewGroup>(), R
       }
     }
 
-    private fun tryFreeingResponder() {
-      if (responder === this) {
-        responder = null
-      }
-    }
-
     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) {
-          return isChildTouched(child.children)
+          if (isChildTouched(child.children)) {
+            return true
+          }
         }
       }
 
       return false
     }
 
+    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()) {
+        super.performClick()
+      } 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
@@ -329,12 +337,13 @@ class RNGestureHandlerButtonViewManager : ViewGroupManager<ButtonViewGroup>(), R
       if (!pressed || responder === 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
-        super.setPressed(pressed)
         isTouched = pressed
+        super.setPressed(pressed)
       }
       if (!pressed && responder === this) {
         // if the responder is no longer pressed we release button responder
         responder = null
+        isTouched = false
       }
     }
 
@@ -344,28 +353,9 @@ class RNGestureHandlerButtonViewManager : ViewGroupManager<ButtonViewGroup>(), R
     }
 
     companion object {
-      const val SELECTABLE_ITEM_BACKGROUND = "selectableItemBackground"
-      const val SELECTABLE_ITEM_BACKGROUND_BORDERLESS = "selectableItemBackgroundBorderless"
-
       var resolveOutValue = TypedValue()
       var responder: ButtonViewGroup? = null
       var dummyClickListener = OnClickListener { }
-
-      @TargetApi(Build.VERSION_CODES.LOLLIPOP)
-      private fun getAttrId(context: Context, attr: String): Int {
-        SoftAssertions.assertNotNull(attr)
-        return when (attr) {
-          SELECTABLE_ITEM_BACKGROUND -> {
-            android.R.attr.selectableItemBackground
-          }
-          SELECTABLE_ITEM_BACKGROUND_BORDERLESS -> {
-            android.R.attr.selectableItemBackgroundBorderless
-          }
-          else -> {
-            context.resources.getIdentifier(attr, "attr", "android")
-          }
-        }
-      }
     }
   }
 

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

@@ -224,6 +224,9 @@ class RNGestureHandlerModule(reactContext: ReactApplicationContext?)
       if (config.hasKey(KEY_PAN_AVG_TOUCHES)) {
         handler.setAverageTouches(config.getBoolean(KEY_PAN_AVG_TOUCHES))
       }
+      if (config.hasKey(KEY_PAN_ACTIVATE_AFTER_LONG_PRESS)) {
+        handler.setActivateAfterLongPress(config.getInt(KEY_PAN_ACTIVATE_AFTER_LONG_PRESS).toLong())
+      }
     }
 
     override fun extractEventData(handler: PanGestureHandler, eventData: WritableMap) {
@@ -656,6 +659,7 @@ class RNGestureHandlerModule(reactContext: ReactApplicationContext?)
     private const val KEY_PAN_MIN_POINTERS = "minPointers"
     private const val KEY_PAN_MAX_POINTERS = "maxPointers"
     private const val KEY_PAN_AVG_TOUCHES = "avgTouches"
+    private const val KEY_PAN_ACTIVATE_AFTER_LONG_PRESS = "activateAfterLongPress"
     private const val KEY_NUMBER_OF_POINTERS = "numberOfPointers"
     private const val KEY_DIRECTION = "direction"
 

package/android/src/main/jni/Android.mk

@@ -28,7 +28,7 @@ LOCAL_EXPORT_C_INCLUDES := $(LOCAL_PATH) $(GENERATED_SRC_DIR)/codegen/jni
 LOCAL_SHARED_LIBRARIES := libjsi \
     libfbjni \
     libglog \
-    libfolly_json \
+    libfolly_runtime \
     libyoga \
     libreact_nativemodule_core \
     libturbomodulejsijni \
@@ -36,7 +36,6 @@ LOCAL_SHARED_LIBRARIES := libjsi \
     libreact_render_core \
     libreact_render_graphics \
     libfabricjni \
-    libfolly_futures \
     libreact_debug \
     libreact_render_componentregistry \
     libreact_render_debug \