react-native-gesture-handler 3.0.0-beta.4 → 3.0.0-beta.5

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

@@ -28,7 +28,6 @@ class RNGestureHandlerModule(reactContext: ReactApplicationContext?) :
   @DoNotStrip
   @Suppress("unused")
   private var mHybridData: HybridData = initHybrid()
-  private var isReanimatedAvailable = false
   private var uiRuntimeDecorated = false
   private val registry: RNGestureHandlerRegistry
     get() = registries[moduleId]!!
@@ -61,16 +60,10 @@ class RNGestureHandlerModule(reactContext: ReactApplicationContext?) :
   }
 
   @ReactMethod
-  override fun createGestureHandler(handlerName: String, handlerTagDouble: Double, config: ReadableMap): Boolean {
-    if (isReanimatedAvailable && !uiRuntimeDecorated) {
-      uiRuntimeDecorated = decorateUIRuntime()
-    }
-
+  override fun createGestureHandler(handlerName: String, handlerTagDouble: Double, config: ReadableMap) {
     val handlerTag = handlerTagDouble.toInt()
 
     createGestureHandlerHelper<GestureHandler>(handlerName, handlerTag, config)
-
-    return true
   }
 
   @ReactMethod
@@ -125,8 +118,12 @@ class RNGestureHandlerModule(reactContext: ReactApplicationContext?) :
   override fun flushOperations() = Unit
 
   @ReactMethod
-  override fun setReanimatedAvailable(isAvailable: Boolean) {
-    isReanimatedAvailable = isAvailable
+  override fun installUIRuntimeBindings(): Boolean {
+    if (!uiRuntimeDecorated) {
+      uiRuntimeDecorated = decorateUIRuntime()
+    }
+
+    return uiRuntimeDecorated
   }
 
   @DoNotStrip

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

@@ -11,10 +11,72 @@ class RNGestureHandlerRegistry : GestureHandlerRegistry {
   private val handlers = SparseArray<GestureHandler>()
   private val attachedTo = SparseArray<Int?>()
   private val handlersForView = SparseArray<ArrayList<GestureHandler>>()
+  private val observers = mutableMapOf<Int, MutableMap<Any, (GestureHandler) -> Unit>>()
 
-  @Synchronized
   fun registerHandler(handler: GestureHandler) {
-    handlers.put(handler.tag, handler)
+    val hasObservers = synchronized(this) {
+      handlers.put(handler.tag, handler)
+      observers[handler.tag]?.isNotEmpty() == true
+    }
+
+    if (!hasObservers) {
+      return
+    }
+
+    // `createGestureHandler` runs on the JS thread, but observer callbacks read detector
+    // view state (childCount, getChildAt) and may attach native handlers, so they must run
+    // on the UI thread. Re-resolve the observer list on the UI thread so a cancellation that
+    // happens between this post and `notify` running (e.g. detector detach) actually prevents
+    // the callback.
+    val notify = {
+      val callbacks = synchronized(this) {
+        observers[handler.tag]?.values?.toList().orEmpty()
+      }
+      for (callback in callbacks) {
+        callback(handler)
+      }
+    }
+
+    if (UiThreadUtil.isOnUiThread()) {
+      notify()
+    } else {
+      UiThreadUtil.runOnUiThread(notify)
+    }
+  }
+
+  // Invokes `block` every time a handler with `tag` is registered, and synchronously once now if
+  // the handler already exists. The observation persists until explicitly cancelled: the registry
+  // holds both `owner` and `block` strongly, so callers MUST call `cancelObservation` or
+  // `cancelAllObservationsForOwner` when the owner is going away (typically in detach / dispose
+  // paths) to avoid leaking the owner. Observing the same tag twice with the same `owner` replaces
+  // the previous block.
+  fun observeHandler(tag: Int, owner: Any, block: (GestureHandler) -> Unit) {
+    val existing = synchronized(this) {
+      observers.getOrPut(tag) { mutableMapOf() }[owner] = block
+      handlers[tag]
+    }
+    existing?.let { block(it) }
+  }
+
+  @Synchronized
+  fun cancelObservation(tag: Int, owner: Any) {
+    val observersForTag = observers[tag] ?: return
+    observersForTag.remove(owner)
+    if (observersForTag.isEmpty()) {
+      observers.remove(tag)
+    }
+  }
+
+  @Synchronized
+  fun cancelAllObservationsForOwner(owner: Any) {
+    val iterator = observers.entries.iterator()
+    while (iterator.hasNext()) {
+      val entry = iterator.next()
+      entry.value.remove(owner)
+      if (entry.value.isEmpty()) {
+        iterator.remove()
+      }
+    }
   }
 
   @Synchronized

package/apple/RNGestureHandler.mm

@@ -254,6 +254,43 @@ static NSHashTable<RNGestureHandler *> *allGestureHandlers;
   return [view isKindOfClass:[RCTParagraphComponentView class]];
 }
 
+/**
+ * Recursively searches the view subtree rooted at `view` for any descendant whose
+ * `touchEventEmitterAtPoint:` returns an emitter tag matching `virtualViewTag`.
+ * `point` must be in `view`'s coordinate space.
+ *
+ * Most Fabric views inherit a base `touchEventEmitterAtPoint:` that returns their own emitter
+ * (tag == their own reactTag). Views that render multiple logical children — like
+ * `RCTParagraphComponentView` for inline text spans — override the method to return
+ * per-child emitters, making them distinguishable by tag. This helper exploits that
+ * property without hardcoding any specific view class.
+ */
+- (BOOL)isVirtualViewTag:(NSNumber *)virtualViewTag touchedAtPoint:(CGPoint)point inView:(RNGHUIView *)view
+{
+  if (!CGRectContainsPoint(view.bounds, point)) {
+    return NO;
+  }
+
+  if ([view respondsToSelector:@selector(touchEventEmitterAtPoint:)]) {
+    auto emitter = [(id<RCTTouchableComponentViewProtocol>)view touchEventEmitterAtPoint:point];
+    if (emitter) {
+      auto eventTarget = emitter->getEventTarget();
+      if (eventTarget != nullptr && eventTarget->getTag() == [virtualViewTag intValue]) {
+        return YES;
+      }
+    }
+  }
+
+  for (RNGHUIView *subview in view.subviews) {
+    CGPoint pointInSubview = [view convertPoint:point toView:subview];
+    if ([self isVirtualViewTag:virtualViewTag touchedAtPoint:pointInSubview inView:subview]) {
+      return YES;
+    }
+  }
+
+  return NO;
+}
+
 - (void)bindToView:(RNGHUIView *)view
 {
   self.recognizer.delegate = self;
@@ -753,6 +790,11 @@ static NSHashTable<RNGestureHandler *> *allGestureHandlers;
 
 - (BOOL)containsPointInView
 {
+  if (_actionType == RNGestureHandlerActionTypeVirtualDetector && _virtualViewTag != nil) {
+    CGPoint point = [_recognizer locationInView:_recognizer.view];
+    return [self isVirtualViewTag:_virtualViewTag touchedAtPoint:point inView:_recognizer.view];
+  }
+
   RNGHUIView *viewToHitTest = _recognizer.view;
 
   if (_shouldCancelWhenOutside && [self usesNativeOrVirtualDetector] && [_recognizer.view.subviews count] > 0) {
@@ -767,6 +809,11 @@ static NSHashTable<RNGestureHandler *> *allGestureHandlers;
 
 - (BOOL)wantsToHandleEventsAtPoint:(CGPoint)point
 {
+  if (_actionType == RNGestureHandlerActionTypeVirtualDetector && _virtualViewTag != nil) {
+    // point is in _recognizer.view (detector) coordinate space; search the whole subtree
+    return [self isVirtualViewTag:_virtualViewTag touchedAtPoint:point inView:_recognizer.view];
+  }
+
   RNGHUIView *viewToHitTest = _recognizer.view;
 
   if ([self usesNativeOrVirtualDetector] && [_recognizer.view.subviews count] > 0) {
@@ -774,20 +821,6 @@ static NSHashTable<RNGestureHandler *> *allGestureHandlers;
     point = [_recognizer.view convertPoint:point toView:viewToHitTest];
   }
 
-  if (_actionType == RNGestureHandlerActionTypeVirtualDetector && _virtualViewTag != nil) {
-    // In this case, logic detector is attached to the DetectorView, which has a single subview representing
-    // the actual target view in the RN hierarchy
-    if ([viewToHitTest respondsToSelector:@selector(touchEventEmitterAtPoint:)]) {
-      // If the view has touchEventEmitterAtPoint: method, it can be used to determine the viewtag
-      // of the view under the touch point
-      facebook::react::SharedTouchEventEmitter eventEmitter =
-          [(id<RCTTouchableComponentViewProtocol>)viewToHitTest touchEventEmitterAtPoint:point];
-      auto viewUnderTouch = eventEmitter->getEventTarget()->getTag();
-
-      return viewUnderTouch == [_virtualViewTag intValue];
-    }
-  }
-
   CGRect hitFrame = RNGHHitSlopInsetRect(viewToHitTest.bounds, _hitSlop);
   return CGRectContainsPoint(hitFrame, point);
 }
@@ -810,19 +843,9 @@ static NSHashTable<RNGestureHandler *> *allGestureHandlers;
 
   // Logic detector has a virtual view tag set only if the real hierarchy was folded into a single View
   if (_actionType == RNGestureHandlerActionTypeVirtualDetector && _virtualViewTag != nil) {
-    // In this case, logic detector is attached to the DetectorView, which has a single subview representing
-    // the actual target view in the RN hierarchy
-    RNGHUIView *view = _recognizer.view.subviews[0];
-    if ([view respondsToSelector:@selector(touchEventEmitterAtPoint:)]) {
-      // If the view has touchEventEmitterAtPoint: method, it can be used to determine the viewtag
-      // of the view under the touch point
-      facebook::react::SharedTouchEventEmitter eventEmitter =
-          [(id<RCTTouchableComponentViewProtocol>)view touchEventEmitterAtPoint:[_recognizer locationInView:view]];
-      auto viewUnderTouch = eventEmitter->getEventTarget()->getTag();
-
-      if (viewUnderTouch != [_virtualViewTag intValue]) {
-        return NO;
-      }
+    CGPoint point = [_recognizer locationInView:_recognizer.view];
+    if (![self isVirtualViewTag:_virtualViewTag touchedAtPoint:point inView:_recognizer.view]) {
+      return NO;
     }
   }
 

package/apple/RNGestureHandlerButton.h

@@ -27,8 +27,10 @@
 @property (nonatomic) BOOL userEnabled;
 @property (nonatomic, assign) RNGestureHandlerPointerEvents pointerEvents;
 
-@property (nonatomic, assign) NSInteger pressAndHoldAnimationDuration;
-@property (nonatomic, assign) NSInteger tapAnimationDuration;
+@property (nonatomic, assign) NSInteger tapAnimationInDuration;
+@property (nonatomic, assign) NSInteger tapAnimationOutDuration;
+@property (nonatomic, assign) NSInteger longPressDuration;
+@property (nonatomic, assign) NSInteger longPressAnimationOutDuration;
 @property (nonatomic, assign) CGFloat activeOpacity;
 @property (nonatomic, assign) CGFloat defaultOpacity;
 @property (nonatomic, assign) CGFloat activeScale;

package/apple/RNGestureHandlerButton.mm

@@ -49,7 +49,7 @@
   dispatch_block_t _pendingPressOutBlock;
 }
 
-@synthesize pressAndHoldAnimationDuration = _pressAndHoldAnimationDuration;
+@synthesize longPressAnimationOutDuration = _longPressAnimationOutDuration;
 
 - (void)commonInit
 {
@@ -57,8 +57,10 @@
   _hitTestEdgeInsets = UIEdgeInsetsZero;
   _userEnabled = YES;
   _pointerEvents = RNGestureHandlerPointerEventsAuto;
-  _pressAndHoldAnimationDuration = -1;
-  _tapAnimationDuration = 100;
+  _tapAnimationInDuration = 50;
+  _tapAnimationOutDuration = 100;
+  _longPressDuration = -1;
+  _longPressAnimationOutDuration = -1;
   _activeOpacity = 1.0;
   _defaultOpacity = 1.0;
   _activeScale = 1.0;
@@ -145,6 +147,10 @@
   [super viewWillMoveToWindow:newWindow];
   if (newWindow == nil) {
     [self cancelPendingPressOutAnimation];
+    [self applyStartAnimationState];
+    _isTouchInsideBounds = NO;
+    _suppressSuperControlActionDispatch = NO;
+    _pressInTimestamp = 0;
   }
 }
 #else
@@ -153,13 +159,17 @@
   [super willMoveToWindow:newWindow];
   if (newWindow == nil) {
     [self cancelPendingPressOutAnimation];
+    [self applyStartAnimationState];
+    _isTouchInsideBounds = NO;
+    _suppressSuperControlActionDispatch = NO;
+    _pressInTimestamp = 0;
   }
 }
 #endif
 
-- (NSInteger)pressAndHoldAnimationDuration
+- (NSInteger)longPressAnimationOutDuration
 {
-  return _pressAndHoldAnimationDuration < 0 ? _tapAnimationDuration : _pressAndHoldAnimationDuration;
+  return _longPressAnimationOutDuration < 0 ? _tapAnimationOutDuration : _longPressAnimationOutDuration;
 }
 
 - (void)setUnderlayColor:(RNGHColor *)underlayColor
@@ -193,8 +203,13 @@
 
 - (void)animateUnderlayToOpacity:(float)toOpacity duration:(NSTimeInterval)durationMs
 {
-  _underlayLayer.opacity =
-      _underlayLayer.presentationLayer ? [_underlayLayer.presentationLayer opacity] : _underlayLayer.opacity;
+  // Only sync the model from the presentation layer when an animation is actually
+  // in flight.
+  CALayer *presentation = _underlayLayer.presentationLayer;
+  BOOL hasInFlightAnimation = presentation != nil && _underlayLayer.animationKeys.count > 0;
+  if (hasInFlightAnimation) {
+    _underlayLayer.opacity = presentation.opacity;
+  }
   [_underlayLayer removeAllAnimations];
 
   // CABasicAnimation with duration 0 resolves to the current CATransaction's
@@ -256,19 +271,60 @@ static CATransform3D RNGHCenterScaleTransform(NSRect bounds, CGFloat scale)
 #endif
 }
 
+// Duration of a single frame at the current screen's max refresh rate, in ms.
+- (NSTimeInterval)minFrameDurationMs
+{
+#if !TARGET_OS_OSX
+  UIScreen *screen = self.window.screen ?: UIScreen.mainScreen;
+  NSInteger maxFps = screen.maximumFramesPerSecond;
+#else
+  NSScreen *screen = self.window.screen ?: NSScreen.mainScreen;
+  NSInteger maxFps = 60;
+  if (@available(macOS 12.0, *)) {
+    maxFps = screen.maximumFramesPerSecond;
+  }
+#endif
+  return maxFps > 0 ? 1000.0 / (NSTimeInterval)maxFps : 1000.0 / 60.0;
+}
+
 - (void)animateTarget:(RNGHUIView *)target
             toOpacity:(CGFloat)opacity
                 scale:(CGFloat)scale
              duration:(NSTimeInterval)durationMs
 {
-  target.layer.transform =
-      target.layer.presentationLayer ? target.layer.presentationLayer.transform : target.layer.transform;
-  NSTimeInterval duration = durationMs / 1000.0;
+  CALayer *layer = target.layer;
+  CALayer *presentation = layer.presentationLayer;
+  NSTimeInterval snapThresholdMs = [self minFrameDurationMs];
+
+  // Only snap to the presentation layer when an animation is in flight,
+  // that's the only case where it tells us something the model layer doesn't.
+  BOOL hasInFlightAnimation = presentation != nil && layer.animationKeys.count > 0;
+  if (hasInFlightAnimation) {
+    layer.transform = presentation.transform;
+  }
 
 #if !TARGET_OS_OSX
-  target.alpha = target.layer.presentationLayer ? target.layer.presentationLayer.opacity : target.alpha;
-  [target.layer removeAllAnimations];
+  if (hasInFlightAnimation) {
+    target.alpha = presentation.opacity;
+  }
+  [layer removeAllAnimations];
+
+  // Sub-frame durations: snap with implicit actions disabled instead of
+  // routing through UIView.animate. Same rationale as animateUnderlayToOpacity.
+  if (durationMs < snapThresholdMs) {
+    [CATransaction begin];
+    [CATransaction setDisableActions:YES];
+    if (_activeOpacity != 1.0 || _defaultOpacity != 1.0) {
+      target.alpha = opacity;
+    }
+    if (_activeScale != 1.0 || _defaultScale != 1.0) {
+      layer.transform = CATransform3DMakeScale(scale, scale, 1.0);
+    }
+    [CATransaction commit];
+    return;
+  }
 
+  NSTimeInterval duration = durationMs / 1000.0;
   [UIView animateWithDuration:duration
                         delay:0
                       options:UIViewAnimationOptionCurveEaseInOut
@@ -283,9 +339,25 @@ static CATransform3D RNGHCenterScaleTransform(NSRect bounds, CGFloat scale)
                    completion:nil];
 #else
   target.wantsLayer = YES;
-  target.alphaValue = target.layer.presentationLayer ? target.layer.presentationLayer.opacity : target.alphaValue;
-  [target.layer removeAllAnimations];
+  if (hasInFlightAnimation) {
+    target.alphaValue = presentation.opacity;
+  }
+  [layer removeAllAnimations];
 
+  if (durationMs < snapThresholdMs) {
+    [CATransaction begin];
+    [CATransaction setDisableActions:YES];
+    if (_activeOpacity != 1.0 || _defaultOpacity != 1.0) {
+      target.alphaValue = opacity;
+    }
+    if (_activeScale != 1.0 || _defaultScale != 1.0) {
+      layer.transform = RNGHCenterScaleTransform(target.bounds, scale);
+    }
+    [CATransaction commit];
+    return;
+  }
+
+  NSTimeInterval duration = durationMs / 1000.0;
   [NSAnimationContext
       runAnimationGroup:^(NSAnimationContext *context) {
         context.allowsImplicitAnimation = YES;
@@ -310,9 +382,9 @@ static CATransform3D RNGHCenterScaleTransform(NSRect bounds, CGFloat scale)
   }
   _pressInTimestamp = CACurrentMediaTime();
   RNGHUIView *target = self.animationTarget ?: self;
-  [self animateTarget:target toOpacity:_activeOpacity scale:_activeScale duration:self.pressAndHoldAnimationDuration];
+  [self animateTarget:target toOpacity:_activeOpacity scale:_activeScale duration:_tapAnimationInDuration];
   if (_activeUnderlayOpacity != _defaultUnderlayOpacity) {
-    [self animateUnderlayToOpacity:_activeUnderlayOpacity duration:self.pressAndHoldAnimationDuration];
+    [self animateUnderlayToOpacity:_activeUnderlayOpacity duration:_tapAnimationInDuration];
   }
 }
 
@@ -323,17 +395,24 @@ static CATransform3D RNGHCenterScaleTransform(NSRect bounds, CGFloat scale)
   }
 
   NSTimeInterval elapsed = (CACurrentMediaTime() - _pressInTimestamp) * 1000.0;
-  NSInteger pressAndHoldAnimationDuration = self.pressAndHoldAnimationDuration;
 
-  if (elapsed >= pressAndHoldAnimationDuration) {
-    // Press-in animation fully finished, animate out in pressAndHoldAnimationDuration
+  if (_longPressDuration >= 0 && elapsed >= _longPressDuration) {
+    // Long-press release - use the configured long-press out duration.
+    NSInteger longPressOut = self.longPressAnimationOutDuration;
+    RNGHUIView *target = self.animationTarget ?: self;
+    [self animateTarget:target toOpacity:_defaultOpacity scale:_defaultScale duration:longPressOut];
+    if (_activeUnderlayOpacity != _defaultUnderlayOpacity) {
+      [self animateUnderlayToOpacity:_defaultUnderlayOpacity duration:longPressOut];
+    }
+  } else if (elapsed >= _tapAnimationInDuration) {
+    // Press-in animation fully finished - release with the configured out duration.
     RNGHUIView *target = self.animationTarget ?: self;
-    [self animateTarget:target toOpacity:_defaultOpacity scale:_defaultScale duration:pressAndHoldAnimationDuration];
+    [self animateTarget:target toOpacity:_defaultOpacity scale:_defaultScale duration:_tapAnimationOutDuration];
     if (_activeUnderlayOpacity != _defaultUnderlayOpacity) {
-      [self animateUnderlayToOpacity:_defaultUnderlayOpacity duration:pressAndHoldAnimationDuration];
+      [self animateUnderlayToOpacity:_defaultUnderlayOpacity duration:_tapAnimationOutDuration];
     }
-    // elapsed * 2 to ensure there is at least half of the minDuration left for the animation to play
-  } else if (elapsed * 2 >= _tapAnimationDuration) {
+    // elapsed * 2 to ensure there is at least half of the tapAnimationOutDuration left for the animation to play
+  } else if (elapsed * 2 >= _tapAnimationOutDuration) {
     // Past minimum but press-in animation still playing, animate out in elapsed time
     RNGHUIView *target = self.animationTarget ?: self;
     [self animateTarget:target toOpacity:_defaultOpacity scale:_defaultScale duration:elapsed];
@@ -341,8 +420,8 @@ static CATransform3D RNGHCenterScaleTransform(NSRect bounds, CGFloat scale)
       [self animateUnderlayToOpacity:_defaultUnderlayOpacity duration:elapsed];
     }
   } else {
-    // Before minimum duration, finish press-in in remaining time then animate out in minDuration
-    NSTimeInterval remaining = _tapAnimationDuration - elapsed;
+    // Before minimum duration, finish press-in in remaining time then animate out in tapAnimationOutDuration.
+    NSTimeInterval remaining = _tapAnimationInDuration - elapsed;
 
     RNGHUIView *target = self.animationTarget ?: self;
     [self animateTarget:target toOpacity:_activeOpacity scale:_activeScale duration:remaining];
@@ -359,10 +438,10 @@ static CATransform3D RNGHCenterScaleTransform(NSRect bounds, CGFloat scale)
         [strongSelf animateTarget:target
                         toOpacity:strongSelf->_defaultOpacity
                             scale:strongSelf->_defaultScale
-                         duration:strongSelf->_tapAnimationDuration];
+                         duration:strongSelf->_tapAnimationOutDuration];
         if (strongSelf->_activeUnderlayOpacity != strongSelf->_defaultUnderlayOpacity) {
           [strongSelf animateUnderlayToOpacity:strongSelf->_defaultUnderlayOpacity
-                                      duration:strongSelf->_tapAnimationDuration];
+                                      duration:strongSelf->_tapAnimationOutDuration];
         }
       }
     });

package/apple/RNGestureHandlerButtonComponentView.mm

@@ -323,8 +323,10 @@ static RNGestureHandlerPointerEvents RCTPointerEventsToEnum(facebook::react::Poi
   }
 
   _buttonView.userEnabled = newProps.enabled;
-  _buttonView.pressAndHoldAnimationDuration = newProps.pressAndHoldAnimationDuration;
-  _buttonView.tapAnimationDuration = newProps.tapAnimationDuration > 0 ? newProps.tapAnimationDuration : 0;
+  _buttonView.tapAnimationInDuration = newProps.tapAnimationInDuration > 0 ? newProps.tapAnimationInDuration : 0;
+  _buttonView.tapAnimationOutDuration = newProps.tapAnimationOutDuration > 0 ? newProps.tapAnimationOutDuration : 0;
+  _buttonView.longPressDuration = newProps.longPressDuration;
+  _buttonView.longPressAnimationOutDuration = newProps.longPressAnimationOutDuration;
   _buttonView.activeOpacity = newProps.activeOpacity;
   _buttonView.defaultOpacity = newProps.defaultOpacity;
   _buttonView.activeScale = newProps.activeScale;
@@ -358,6 +360,19 @@ static RNGestureHandlerPointerEvents RCTPointerEventsToEnum(facebook::react::Poi
   }
 
   [super updateProps:props oldProps:oldProps];
+
+#if !TARGET_OS_TV && !TARGET_OS_OSX
+  // super's updateProps sets self.accessibilityIdentifier from testID via the
+  // standard Fabric mechanism. However, setAccessibilityProps already forwards
+  // testID to _buttonView.accessibilityIdentifier (the actual button element).
+  // Having the identifier on both views causes testing frameworks (e.g. Detox)
+  // to report multiple matches for the same testID. Clear it from the wrapper so
+  // only _buttonView carries the identifier.
+  if (!newProps.testId.empty()) {
+    self.accessibilityIdentifier = nil;
+  }
+#endif
+
   if (shouldApplyStartAnimationState) {
     [_buttonView applyStartAnimationState];
   }