Improve interop touches by using UIScrollView-like strategy

compose/ui/ui-uikit/src/uikitMain/objc/CMPUIKitUtils/CMPUIKitUtils/CMPGestureRecognizer.h

@@ -9,21 +9,24 @@
 #import <UIKit/UIGestureRecognizerSubclass.h>
 
 NS_ASSUME_NONNULL_BEGIN
-
+ 
 @protocol CMPGestureRecognizerHandler <NSObject>
-
+ 
 - (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent * _Nullable)event;
 - (void)touchesMoved:(NSSet<UITouch *> *)touches withEvent:(UIEvent * _Nullable)event;
 - (void)touchesEnded:(NSSet<UITouch *> *)touches withEvent:(UIEvent * _Nullable)event;
 - (void)touchesCancelled:(NSSet<UITouch *> *)touches withEvent:(UIEvent * _Nullable)event;
-- (BOOL)shouldRecognizeSimultaneously:(UIGestureRecognizer *)first withOther:(UIGestureRecognizer *)second;
+- (void)onFailure;
 
 @end
 
 @interface CMPGestureRecognizer : UIGestureRecognizer <UIGestureRecognizerDelegate>
 
 @property (weak, nonatomic) id <CMPGestureRecognizerHandler> handler;
 
+- (void)cancelFailure;
+- (void)scheduleFailure;
+
 @end
 
 NS_ASSUME_NONNULL_END

compose/ui/ui-uikit/src/uikitMain/objc/CMPUIKitUtils/CMPUIKitUtils/CMPGestureRecognizer.m

@@ -7,82 +7,110 @@
 
 #import "CMPGestureRecognizer.h"
 
-@implementation CMPGestureRecognizer
+@implementation CMPGestureRecognizer {
+    dispatch_block_t _scheduledFailureBlock;
+}
 
 - (instancetype)init {
     self = [super init];
 
-    if (self) {
-        self.cancelsTouchesInView = false;
+    if (self) {        
         self.delegate = self;
+        [self addTarget:self action:@selector(handleStateChange)];
     }
 
     return self;
 }
 
-- (BOOL)gestureRecognizer:(UIGestureRecognizer *)gestureRecognizer shouldRecognizeSimultaneouslyWithGestureRecognizer:(UIGestureRecognizer *)otherGestureRecognizer {
-    id <CMPGestureRecognizerHandler> handler = self.handler;
+- (void)handleStateChange {
+    switch (self.state) {
+        case UIGestureRecognizerStateBegan:
+            NSLog(@"state = Began");
+            break;
+
+        case UIGestureRecognizerStateChanged:
+            NSLog(@"state = Changed");
+            break;
+
+        case UIGestureRecognizerStateEnded:
+            [self cancelFailure];
+            break;
+
+        case UIGestureRecognizerStateCancelled:
+            [self cancelFailure];
+            break;
+
+        default:
+            break;
+    }
+}
+
+- (BOOL)shouldRecognizeSimultaneouslyWithGestureRecognizer:(UIGestureRecognizer *)otherGestureRecognizer {
+    UIView *view = self.view;
+    UIView *otherView = otherGestureRecognizer.view;
 
-    if (handler) {
-        return [handler shouldRecognizeSimultaneously:gestureRecognizer withOther:otherGestureRecognizer];
-    } else {
+    if (view == nil || otherView == nil) {
         return NO;
     }
+
+    if ([otherView isDescendantOfView:view]) {
+        return NO;
+    } else {
+        return YES;
+    }
 }
 
-- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event {
-    [self.handler touchesBegan:touches withEvent:event];
+- (BOOL)shouldRequireFailureOfGestureRecognizer:(UIGestureRecognizer *)otherGestureRecognizer {
+    return NO;
+}
+
+- (BOOL)shouldBeRequiredToFailByGestureRecognizer:(UIGestureRecognizer *)otherGestureRecognizer {
+    return YES;
+}
+
+- (void)cancelFailure {
+    if (_scheduledFailureBlock) {
+        dispatch_block_cancel(_scheduledFailureBlock);
+        _scheduledFailureBlock = NULL;
+    }
+}
+
+- (void)fail {
+    [self.handler onFailure];
+}
+
+- (void)scheduleFailure {
+    __weak typeof(self) weakSelf = self;
+    dispatch_block_t dispatchBlock = dispatch_block_create(0, ^{
+        [weakSelf fail];
+    });
 
-    if (self.state == UIGestureRecognizerStatePossible) {
-        self.state = UIGestureRecognizerStateBegan;
+    if (_scheduledFailureBlock) {
+        dispatch_block_cancel(_scheduledFailureBlock);
     }
+    _scheduledFailureBlock = dispatchBlock;
+
+    // Calculate the delay time in dispatch_time_t
+    dispatch_time_t delay = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(0.15 * NSEC_PER_SEC));
+
+    // Schedule the block to be executed after the delay on the main queue
+    dispatch_after(delay, dispatch_get_main_queue(), dispatchBlock);
+}
+
+- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event {
+    [self.handler touchesBegan:touches withEvent:event];
 }
 
 - (void)touchesMoved:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event {
     [self.handler touchesMoved:touches withEvent:event];
-
-    switch (self.state) {
-        case UIGestureRecognizerStateBegan:
-        case UIGestureRecognizerStateChanged:
-            self.state = UIGestureRecognizerStateChanged;
-            break;
-        default:
-            break;
-    }
 }
 
 - (void)touchesEnded:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event {
     [self.handler touchesEnded:touches withEvent:event];
-
-    switch (self.state) {
-        case UIGestureRecognizerStateBegan:
-        case UIGestureRecognizerStateChanged:
-            if (self.numberOfTouches == 0) {
-                self.state = UIGestureRecognizerStateEnded;
-            } else {
-                self.state = UIGestureRecognizerStateChanged;
-            }
-            break;
-        default:
-            break;
-    }
 }
 
 - (void)touchesCancelled:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event {
     [self.handler touchesCancelled:touches withEvent:event];
-
-    switch (self.state) {
-        case UIGestureRecognizerStateBegan:
-        case UIGestureRecognizerStateChanged:
-            if (self.numberOfTouches == 0) {
-                self.state = UIGestureRecognizerStateCancelled;
-            } else {
-                self.state = UIGestureRecognizerStateChanged;
-            }
-            break;
-        default:
-            break;
-    }
 }
 
 @end

compose/ui/ui/src/uikitMain/kotlin/androidx/compose/ui/scene/ComposeSceneMediator.uikit.kt

@@ -87,6 +87,7 @@ import platform.CoreGraphics.CGRect
 import platform.CoreGraphics.CGRectMake
 import platform.CoreGraphics.CGRectZero
 import platform.CoreGraphics.CGSize
+import platform.QuartzCore.CACurrentMediaTime
 import platform.QuartzCore.CATransaction
 import platform.UIKit.NSLayoutConstraint
 import platform.UIKit.UIEvent
@@ -367,29 +368,41 @@ internal class ComposeSceneMediator(
      * @param event the [UIEvent] associated with the touches
      * @param phase the [CupertinoTouchesPhase] of the touches
      */
-    private fun onTouchesEvent(view: UIView, touches: Set<*>, event: UIEvent, phase: CupertinoTouchesPhase) {
+    private fun onTouchesEvent(view: UIView, touches: Set<*>, event: UIEvent?, phase: CupertinoTouchesPhase) {
         val pointers = touches.map {
             val touch = it as UITouch
             val id = touch.hashCode().toLong()
             val position = touch.offsetInView(view, density.density)
             ComposeScenePointer(
                 id = PointerId(id),
                 position = position,
-                pressed = touch.isPressed,
+                pressed = when (phase) {
+                    // When CMPGestureRecognizer is failed, all tracked touches are sent immediately
+                    // as CANCELLED. In this case, we should not consider the touch as pressed
+                    // despite them being on the screen. This is the last event for Compose in a
+                    // given gesture sequence and should be treated as such.
+                    CupertinoTouchesPhase.CANCELLED -> false
+                    else -> touch.isPressed
+                },
                 type = PointerType.Touch,
                 pressure = touch.force.toFloat(),
-                historical = event.historicalChangesForTouch(
+                historical = event?.historicalChangesForTouch(
                     touch,
                     view,
                     density.density
-                )
+                ) ?: emptyList()
             )
-        } ?: emptyList()
+        }
+
+        // If the touches were cancelled due to gesture failure, the timestamp is not available,
+        // because no actual event with touch updates happened. We just use the current time in
+        // this case.
+        val timestamp = event?.timestamp ?: CACurrentMediaTime()
 
         scene.sendPointerEvent(
             eventType = phase.toPointerEventType(),
             pointers = pointers,
-            timeMillis = (event.timestamp * 1e3).toLong(),
+            timeMillis = (timestamp * 1e3).toLong(),
             nativeEvent = event
         )
     }