react-native-gesture-handler 2.4.0 → 2.5.0

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 \

package/android/src/paper/java/com/facebook/react/viewmanagers/RNGestureHandlerButtonManagerDelegate.java

@@ -1,11 +1,11 @@
 /**
-* This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
-*
-* Do not edit this file as changes may cause incorrect behavior and will be lost
-* once the code is regenerated.
-*
-* @generated by codegen project: GeneratePropsJavaDelegate.js
-*/
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GeneratePropsJavaDelegate.js
+ */
 
 package com.facebook.react.viewmanagers;
 
@@ -23,7 +23,7 @@ public class RNGestureHandlerButtonManagerDelegate<T extends View, U extends Bas
   public void setProperty(T view, String propName, @Nullable Object value) {
     switch (propName) {
       case "exclusive":
-        mViewManager.setExclusive(view, value == null ? false : (boolean) value);
+        mViewManager.setExclusive(view, value == null ? true : (boolean) value);
         break;
       case "foreground":
         mViewManager.setForeground(view, value == null ? false : (boolean) value);
@@ -32,7 +32,7 @@ public class RNGestureHandlerButtonManagerDelegate<T extends View, U extends Bas
         mViewManager.setBorderless(view, value == null ? false : (boolean) value);
         break;
       case "enabled":
-        mViewManager.setEnabled(view, value == null ? false : (boolean) value);
+        mViewManager.setEnabled(view, value == null ? true : (boolean) value);
         break;
       case "rippleColor":
         mViewManager.setRippleColor(view, ColorPropConverter.getColor(value, view.getContext()));
@@ -40,6 +40,9 @@ public class RNGestureHandlerButtonManagerDelegate<T extends View, U extends Bas
       case "rippleRadius":
         mViewManager.setRippleRadius(view, value == null ? 0 : ((Double) value).intValue());
         break;
+      case "touchSoundDisabled":
+        mViewManager.setTouchSoundDisabled(view, value == null ? false : (boolean) value);
+        break;
       default:
         super.setProperty(view, propName, value);
     }

package/android/src/paper/java/com/facebook/react/viewmanagers/RNGestureHandlerButtonManagerInterface.java

@@ -19,4 +19,5 @@ public interface RNGestureHandlerButtonManagerInterface<T extends View> {
   void setEnabled(T view, boolean value);
   void setRippleColor(T view, @Nullable Integer value);
   void setRippleRadius(T view, int value);
+  void setTouchSoundDisabled(T view, boolean value);
 }

package/ios/Handlers/RNFlingHandler.m

@@ -8,38 +8,54 @@
 
 @implementation RNBetterSwipeGestureRecognizer {
   __weak RNGestureHandler* _gestureHandler;
+  CGPoint _lastPoint; // location of the most recently updated touch, relative to the view
+  bool _hasBegan; // whether the `BEGAN` event has been sent
 }
 
 - (id)initWithGestureHandler:(RNGestureHandler *)gestureHandler
 {
   if ((self = [super initWithTarget:gestureHandler action:@selector(handleGesture:)])) {
     _gestureHandler = gestureHandler;
+    _lastPoint = CGPointZero;
+    _hasBegan = NO;
   }
   return self;
 }
 
 - (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
 {
+  _lastPoint = [[[touches allObjects] objectAtIndex:0] locationInView:_gestureHandler.recognizer.view];
   [_gestureHandler reset];
-  [self triggerAction];
   [super touchesBegan:touches withEvent:event];
+
+  // self.numberOfTouches doesn't work for this because in case than one finger is required,
+  // when holding one finger on the screen and tapping with the second one, numberOfTouches is equal
+  // to 2 only for the first tap but 1 for all the following ones
+  if (!_hasBegan) {
+    [self triggerAction];
+    _hasBegan = YES;
+  }
+
   [_gestureHandler.pointerTracker touchesBegan:touches withEvent:event];
 }
 
 - (void)touchesMoved:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
 {
+  _lastPoint = [[[touches allObjects] objectAtIndex:0] locationInView:_gestureHandler.recognizer.view];
   [super touchesMoved:touches withEvent:event];
   [_gestureHandler.pointerTracker touchesMoved:touches withEvent:event];
 }
 
 - (void)touchesEnded:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
 {
+  _lastPoint = [[[touches allObjects] objectAtIndex:0] locationInView:_gestureHandler.recognizer.view];
   [super touchesEnded:touches withEvent:event];
   [_gestureHandler.pointerTracker touchesEnded:touches withEvent:event];
 }
 
 - (void)touchesCancelled:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
 {
+  _lastPoint = [[[touches allObjects] objectAtIndex:0] locationInView:_gestureHandler.recognizer.view];
   [super touchesCancelled:touches withEvent:event];
   [_gestureHandler.pointerTracker touchesCancelled:touches withEvent:event];
 }
@@ -53,9 +69,17 @@
 {
   [self triggerAction];
   [_gestureHandler.pointerTracker reset];
+  _hasBegan = NO;
   [super reset];
 }
 
+- (CGPoint)getLastLocation {
+  // I think keeping the location of only one touch is enough since it would be used to determine the direction
+  // of the movement, and if it's wrong the recognizer fails anyway.
+  // In case the location of all touches is required, touch events are the way to go
+  return _lastPoint;
+}
+
 @end
 
 @implementation RNFlingGestureHandler
@@ -104,5 +128,23 @@
     return shouldBegin;
 }
 
+- (RNGestureHandlerEventExtraData *)eventExtraData:(id)_recognizer
+{
+    // For some weird reason [recognizer locationInView:recognizer.view.window] returns (0, 0).
+    // To calculate the correct absolute position, first calculate the absolute position of the
+    // view inside the root view controller (https://stackoverflow.com/a/7448573) and then
+    // add the relative touch position to it.
+    
+    RNBetterSwipeGestureRecognizer *recognizer = (RNBetterSwipeGestureRecognizer *)_recognizer;
+    
+    CGPoint viewAbsolutePosition = [recognizer.view convertPoint:recognizer.view.bounds.origin toView:[UIApplication sharedApplication].keyWindow.rootViewController.view];
+    CGPoint locationInView = [recognizer getLastLocation];
+    
+    return [RNGestureHandlerEventExtraData
+            forPosition:locationInView
+            withAbsolutePosition:CGPointMake(viewAbsolutePosition.x + locationInView.x, viewAbsolutePosition.y + locationInView.y)
+            withNumberOfTouches:recognizer.numberOfTouches];
+}
+
 @end
 

package/ios/Handlers/{RNNativeViewHandler.m → RNNativeViewHandler.mm}

@@ -11,9 +11,14 @@
 #import <UIKit/UIGestureRecognizerSubclass.h>
 
 #import <React/RCTConvert.h>
-#import <React/RCTScrollView.h>
 #import <React/UIView+React.h>
 
+#ifdef RN_FABRIC_ENABLED
+#import <React/RCTScrollViewComponentView.h>
+#else
+#import <React/RCTScrollView.h>
+#endif // RN_FABRIC_ENABLED
+
 #pragma mark RNDummyGestureRecognizer
 
 @implementation RNDummyGestureRecognizer {
@@ -101,6 +106,12 @@
     // We can restore default scrollview behaviour to delay touches to scrollview's children
     // because gesture handler system can handle cancellation of scroll recognizer when JS responder
     // is set
+#ifdef RN_FABRIC_ENABLED
+    if ([view isKindOfClass:[RCTScrollViewComponentView class]]) {
+        UIScrollView *scrollView = ((RCTScrollViewComponentView *)view).scrollView;
+        scrollView.delaysContentTouches = YES;
+    }
+#else
     if ([view isKindOfClass:[RCTScrollView class]]) {
         // This part of the code is coupled with RN implementation of ScrollView native wrapper and
         // we expect for RCTScrollView component to contain a subclass of UIScrollview as the only
@@ -108,6 +119,7 @@
         UIScrollView *scrollView = [view.subviews objectAtIndex:0];
         scrollView.delaysContentTouches = YES;
     }
+#endif // RN_FABRIC_ENABLED
 }
 
 - (void)handleTouchDown:(UIView *)sender forEvent:(UIEvent *)event

package/ios/Handlers/RNPanHandler.m

@@ -24,6 +24,7 @@
 @property (nonatomic) CGFloat activeOffsetYEnd;
 @property (nonatomic) CGFloat failOffsetYStart;
 @property (nonatomic) CGFloat failOffsetYEnd;
+@property (nonatomic) CGFloat activateAfterLongPress;
 
 
 - (id)initWithGestureHandler:(RNGestureHandler*)gestureHandler;
@@ -53,6 +54,7 @@
     _activeOffsetYEnd = NAN;
     _failOffsetYStart = NAN;
     _failOffsetYEnd = NAN;
+    _activateAfterLongPress = NAN;
     _hasCustomActivationCriteria = NO;
 #if !TARGET_OS_TV
     _realMinimumNumberOfTouches = self.minimumNumberOfTouches;
@@ -71,6 +73,13 @@
   _realMinimumNumberOfTouches = minimumNumberOfTouches;
 }
 
+- (void)activateAfterLongPress
+{
+  self.state = UIGestureRecognizerStateBegan;
+  // Send event in ACTIVE state because UIGestureRecognizerStateBegan is mapped to RNGestureHandlerStateBegan
+  [_gestureHandler handleGesture:self inState:RNGestureHandlerStateActive];
+}
+
 - (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
 {
   if ([self numberOfTouches] == 0) {
@@ -89,6 +98,10 @@
   [super touchesBegan:touches withEvent:event];
   [self triggerAction];
   [_gestureHandler.pointerTracker touchesBegan:touches withEvent:event];
+    
+  if (!isnan(_activateAfterLongPress)) {
+    [self performSelector:@selector(activateAfterLongPress) withObject:nil afterDelay:_activateAfterLongPress];
+  }
 }
 
 - (void)touchesMoved:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
@@ -140,6 +153,7 @@
 {
   [self triggerAction];
   [_gestureHandler.pointerTracker reset];
+  [NSObject cancelPreviousPerformRequestsWithTarget:self selector:@selector(activateAfterLongPress) object:nil];
   self.enabled = YES;
   [super reset];
 }
@@ -155,6 +169,12 @@
 - (BOOL)shouldFailUnderCustomCriteria
 {
   CGPoint trans = [self translationInView:self.view.window];
+  // Apple docs say that 10 units is the default allowable movement for UILongPressGestureRecognizer
+  if (!isnan(_activateAfterLongPress) && trans.x * trans.x + trans.y * trans.y > 100) {
+    [NSObject cancelPreviousPerformRequestsWithTarget:self selector:@selector(activateAfterLongPress) object:nil];
+    return YES;
+  }
+    
   if (!isnan(_failOffsetXStart) && trans.x < _failOffsetXStart) {
     return YES;
   }
@@ -242,6 +262,7 @@
 #endif
   recognizer.minDistSq = NAN;
   recognizer.minVelocitySq = NAN;
+  recognizer.activateAfterLongPress = NAN;
 }
 
 - (void)configure:(NSDictionary *)config
@@ -283,6 +304,12 @@
     CGFloat velocity = [RCTConvert CGFloat:prop];
     recognizer.minVelocitySq = velocity * velocity;
   }
+    
+  prop = config[@"activateAfterLongPress"];
+  if (prop != nil) {
+    recognizer.activateAfterLongPress = [RCTConvert CGFloat:prop] / 1000.0;
+    recognizer.minDistSq = MAX(100, recognizer.minDistSq);
+  }
   [recognizer updateHasCustomActivationCriteria];
 }
 

package/ios/RNGestureHandler.h

@@ -65,6 +65,7 @@ if (value != nil) { recognizer.prop = [RCTConvert type:value]; }\
 - (void)resetConfig NS_REQUIRES_SUPER;
 - (void)configure:(nullable NSDictionary *)config NS_REQUIRES_SUPER;
 - (void)handleGesture:(nonnull id)recognizer;
+- (void)handleGesture:(nonnull id)recognizer inState:(RNGestureHandlerState)state;
 - (BOOL)containsPointInView;
 - (RNGestureHandlerState)state;
 - (nullable RNGestureHandlerEventExtraData *)eventExtraData:(nonnull id)recognizer;

package/ios/RNGestureHandler.m

@@ -203,6 +203,12 @@ static NSHashTable<RNGestureHandler *> *allGestureHandlers;
     }
     
     _state = [self recognizerState];
+    [self handleGesture:recognizer inState:_state];
+}
+
+- (void)handleGesture:(UIGestureRecognizer *)recognizer inState:(RNGestureHandlerState)state
+{
+    _state = state;
     RNGestureHandlerEventExtraData *eventData = [self eventExtraData:recognizer];
     [self sendEventsInState:self.state forViewWithTag:recognizer.view.reactTag withExtraData:eventData];
 }
@@ -212,6 +218,11 @@ static NSHashTable<RNGestureHandler *> *allGestureHandlers;
             withExtraData:(RNGestureHandlerEventExtraData *)extraData
 {
     if (state != _lastState) {
+        // don't send change events from END to FAILED or CANCELLED, this may happen when gesture is ended in `onTouchesUp` callback
+        if (_lastState == RNGestureHandlerStateEnd && (state == RNGestureHandlerStateFailed || state == RNGestureHandlerStateCancelled)) {
+            return;
+        }
+        
         if (state == RNGestureHandlerStateActive) {
             // Generate a unique coalescing-key each time the gesture-handler becomes active. All events will have
             // the same coalescing-key allowing RCTEventDispatcher to coalesce RNGestureHandlerEvents when events are
@@ -219,7 +230,7 @@ static NSHashTable<RNGestureHandler *> *allGestureHandlers;
             static uint16_t nextEventCoalescingKey = 0;
             self->_eventCoalescingKey = nextEventCoalescingKey++;
 
-        } else if (state == RNGestureHandlerStateEnd && _lastState != RNGestureHandlerStateActive) {
+        } else if (state == RNGestureHandlerStateEnd && _lastState != RNGestureHandlerStateActive && !_manualActivation) {
             id event = [[RNGestureHandlerStateChange alloc] initWithReactTag:reactTag
                                                                   handlerTag:_tag
                                                                        state:RNGestureHandlerStateActive
@@ -390,14 +401,21 @@ shouldRecognizeSimultaneouslyWithGestureRecognizer:(UIGestureRecognizer *)otherG
     if (_recognizer.state == UIGestureRecognizerStateBegan && _recognizer.state == UIGestureRecognizerStatePossible) {
         return YES;
     }
-    if ([_simultaneousHandlers count]) {
-        RNGestureHandler *handler = [RNGestureHandler findGestureHandlerByRecognizer:otherGestureRecognizer];
-        if (handler != nil) {
+    
+    RNGestureHandler *handler = [RNGestureHandler findGestureHandlerByRecognizer:otherGestureRecognizer];
+    if (handler != nil) {
+        if ([_simultaneousHandlers count]) {
             for (NSNumber *handlerTag in _simultaneousHandlers) {
                 if ([handler.tag isEqual:handlerTag]) {
                     return YES;
                 }
             }
+        } else if (handler->_simultaneousHandlers) {
+            for (NSNumber *handlerTag in handler->_simultaneousHandlers) {
+                if ([self.tag isEqual:handlerTag]) {
+                    return YES;
+                }
+            }
         }
     }
     return NO;

package/ios/RNGestureHandlerManager.mm

@@ -4,7 +4,6 @@
 #import <React/RCTViewManager.h>
 #import <React/RCTComponent.h>
 #import <React/RCTRootView.h>
-#import <React/RCTTouchHandler.h>
 #import <React/RCTUIManager.h>
 #import <React/RCTEventDispatcher.h>
 
@@ -22,6 +21,9 @@
 
 #ifdef RN_FABRIC_ENABLED
 #import <React/RCTViewComponentView.h>
+#import <React/RCTSurfaceTouchHandler.h>
+#else
+#import <React/RCTTouchHandler.h>
 #endif // RN_FABRIC_ENABLED
 
 #import "Handlers/RNPanHandler.h"
@@ -211,8 +213,14 @@
     // Once the upstream fix lands the line below along with this comment can be removed
     if ([gestureRecognizer.view isKindOfClass:[UIScrollView class]]) return;
 
+#ifdef RN_FABRIC_ENABLED
+    RCTSurfaceTouchHandler *touchHandler = [viewWithTouchHandler performSelector:@selector(touchHandler)];
+#else
     RCTTouchHandler *touchHandler = [viewWithTouchHandler performSelector:@selector(touchHandler)];
-    [touchHandler cancel];
+#endif
+    [touchHandler setEnabled:NO];
+    [touchHandler setEnabled:YES];
+
 }
 
 #pragma mark Events