iOSAutomationAgent

PrivateHeaders/XCTest/XCUIElementQuery.h

@@ -46,6 +46,6 @@
 - (id)_debugInfoWithIndent:(id *)arg1;
 - (id)_derivedExpressedIdentifiers;
 - (unsigned long long)_derivedExpressedType;
-- (id)initWithInputQuery:(id)arg1 queryDescription:(id)arg2 filter:(CDUnknownBlockType)arg3;
+- (id)initWithInputQuery:(id)arg1 queryDescription:(id)arg2 filter:(CDUnknownBlockType /*4 args ?*/)arg3;
 
 @end

WebDriverAgentLib/Categories/XCUIElement+CBXCoordinateGestures.h

@@ -0,0 +1,32 @@
+
+#import "XCUIElement+FBTap.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface XCUIElement (CBXCoordinateGestures)
+
+/**
+ */
+- (BOOL)cbx_tapAtCoordinate:(CGPoint)point withError:(NSError **)error;
+
+/**
+ */
+- (BOOL)cbx_twoFingerTapAtCoordinate:(CGPoint)point withError:(NSError **)error;
+
+/**
+ */
+- (BOOL)cbx_pinchAtCoordinate:(CGPoint)point
+                        scale:(double)scale
+                     velocity:(double)velocity
+                    withError:(NSError * _Nullable __autoreleasing *)error;
+
+/**
+ */
+- (BOOL)cbx_rotateAtCoordinate:(CGPoint)point
+                       radians:(double)radians
+                      velocity:(double)velocity
+                     withError:(NSError * _Nullable __autoreleasing *)error;
+
+@end
+
+NS_ASSUME_NONNULL_END

WebDriverAgentLib/Categories/XCUIElement+CBXCoordinateGestures.m

@@ -0,0 +1,121 @@
+
+#import "XCUIElement+CBXCoordinateGestures.h"
+#import "FBMathUtils.h"
+#import "XCUIElement+FBUtilities.h"
+#import "XCElementSnapshot-Hitpoint.h"
+#import "XCEventGenerator.h"
+#import "XCSynthesizedEventRecord.h"
+#import "FBLogger.h"
+
+// Determined by the width of a two-finger touch.
+static float const CBX_FINGER_WIDTH = 78.0f /* Adding some buffer */ + 2.0f;
+static float const CBX_HALF_FINGER = CBX_FINGER_WIDTH / 2.0f;
+
+@implementation XCUIElement (CBXCoordinateGestures)
+
+- (BOOL)cbx_tapAtCoordinate:(CGPoint)point withError:(NSError **)error {
+    return [self tapAtCoordinate:point withError:error];
+}
+
+- (BOOL)cbx_twoFingerTapAtCoordinate:(CGPoint)point withError:(NSError * _Nullable __autoreleasing *)error {
+    return [self generateEvent:^(XCEventGenerator *eventGenerator, XCEventGeneratorHandler handlerBlock) {
+        CGPoint hitPoint = FBInvertPointForApplication(point, self.application.frame.size, self.application.interfaceOrientation);
+
+        /*
+         The theory is that we should provide a rect just large enough to fit two fingers but
+         centered around the desired point.
+         */
+        CGRect twoFingerTapRect = CGRectMake(hitPoint.x - CBX_HALF_FINGER,
+                                             hitPoint.y - CBX_HALF_FINGER,
+                                             CBX_FINGER_WIDTH,
+                                             CBX_FINGER_WIDTH);
+
+        SEL tapper = @selector(twoFingerTapInRect:orientation:handler:);
+        if ([eventGenerator respondsToSelector:tapper]) {
+            [eventGenerator twoFingerTapInRect:twoFingerTapRect
+                                   orientation:self.interfaceOrientation
+                                       handler:handlerBlock];
+        } else {
+            //If we're here, we need to pick two points to touch.
+            //TODO: something more intelligent.
+            CGPoint one, two;
+            one = CGPointMake(point.x - CBX_HALF_FINGER, point.y);
+            two = CGPointMake(point.x + CBX_HALF_FINGER, point.y);
+            NSValue *p1 = [NSValue valueWithCGPoint:one],
+                    *p2 = [NSValue valueWithCGPoint:two];
+            [FBLogger logFmt:@"'%@' unavailable, manually tapping %@ and %@",
+                             NSStringFromSelector(tapper),
+                             p1,
+                             p2];
+            [eventGenerator tapAtTouchLocations:@[p1, p2]
+                                   numberOfTaps:1
+                                    orientation:self.interfaceOrientation
+                                        handler:handlerBlock];
+        }
+    } error:error];
+}
+
+- (BOOL)cbx_pinchAtCoordinate:(CGPoint)point
+                        scale:(double)scale
+                     velocity:(double)velocity
+                    withError:(NSError * _Nullable __autoreleasing *)error {
+    return [self generateEvent:^(XCEventGenerator *eventGenerator, XCEventGeneratorHandler handlerBlock) {
+        CGPoint hitPoint = FBInvertPointForApplication(point,
+                                                       self.application.frame.size,
+                                                       self.application.interfaceOrientation);
+        /*
+            TODO: The theory here is that we want a localized rect around the desired point.
+            The question is... how big should the rect be?
+            Current working theory: should fit at least two fingers
+         */
+        CGRect twoFingerTapRect = CGRectMake(hitPoint.x - CBX_HALF_FINGER,
+                                             hitPoint.y - CBX_HALF_FINGER,
+                                             CBX_FINGER_WIDTH,
+                                             CBX_FINGER_WIDTH);
+
+        SEL pincher = @selector(pinchInRect:withScale:velocity:orientation:handler:);
+        if ([eventGenerator respondsToSelector:pincher]) {
+            [eventGenerator pinchInRect:twoFingerTapRect
+                              withScale:scale
+                               velocity:velocity
+                            orientation:self.interfaceOrientation
+                                handler:handlerBlock];
+        } else {
+            [FBLogger logFmt:@"Error: Unable to synthesize event, XCEventGenerator does not respond to %@", NSStringFromSelector(pincher)];
+        }
+    } error:error];
+}
+
+- (BOOL)cbx_rotateAtCoordinate:(CGPoint)point
+                       radians:(double)radians
+                      velocity:(double)velocity
+                     withError:(NSError * _Nullable __autoreleasing *)error {
+    return [self generateEvent:^(XCEventGenerator *eventGenerator, XCEventGeneratorHandler handlerBlock) {
+        CGPoint hitPoint = FBInvertPointForApplication(point,
+                                                       self.application.frame.size,
+                                                       self.application.interfaceOrientation);
+        /*
+         TODO: The theory here is that we want a localized rect around the desired point.
+         The question is... how big should the rect be?
+         Current working theory: should fit at least two fingers
+         */
+        CGRect twoFingerRect = CGRectMake(hitPoint.x - CBX_HALF_FINGER,
+                                          hitPoint.y - CBX_HALF_FINGER,
+                                          CBX_FINGER_WIDTH,
+                                          CBX_FINGER_WIDTH);
+
+        //TODO: I am assuming the second param is radians, based on  -[XCUIElement rotate:withVelocity:]
+        SEL rotater = @selector(rotateInRect:withRotation:velocity:orientation:handler:);
+        if ([eventGenerator respondsToSelector:rotater]) {
+            [eventGenerator rotateInRect:twoFingerRect
+                            withRotation:radians
+                                velocity:velocity
+                             orientation:self.interfaceOrientation
+                                 handler:handlerBlock];
+        } else {
+            [FBLogger logFmt:@"Error: Unable to synthesize event, XCEventGenerator does not respond to %@", NSStringFromSelector(rotater)];
+        }
+    } error:error];
+}
+
+@end

WebDriverAgentLib/Categories/XCUIElement+FBTap.h

@@ -8,9 +8,12 @@
  */
 
 #import <WebDriverAgentLib/XCUIElement.h>
+#import "XCEventGenerator.h"
 
 NS_ASSUME_NONNULL_BEGIN
 
+typedef void(^eventGenerationBlock)(XCEventGenerator *eventGenerator, XCEventGeneratorHandler handlerBlock);
+
 @interface XCUIElement (FBTap)
 
 /**
@@ -21,6 +24,14 @@ NS_ASSUME_NONNULL_BEGIN
 */
 - (BOOL)fb_tapWithError:(NSError **)error;
 
+/**
+ CBX Additions
+ */
+- (BOOL)tapAtCoordinate:(CGPoint)point withError:(NSError * _Nullable __autoreleasing *)error;
+
+//TODO: Move this somewhere more general
+- (BOOL)generateEvent:(eventGenerationBlock)eventBlock error:(NSError * _Nullable __autoreleasing *)error;
+
 @end
 
 NS_ASSUME_NONNULL_END

WebDriverAgentLib/Categories/XCUIElement+FBTap.m

@@ -19,33 +19,48 @@
 
 @implementation XCUIElement (FBTap)
 
+typedef void(^eventGenerationBlock)(XCEventGenerator *eventGenerator, XCEventGeneratorHandler handlerBlock);
+
+- (BOOL)generateEvent:(eventGenerationBlock)eventBlock error:(NSError * _Nullable __autoreleasing *)error {
+    [self fb_waitUntilFrameIsStable];
+    __block BOOL didSucceed;
+    [FBRunLoopSpinner spinUntilCompletion:^(void(^completion)()){
+        XCEventGeneratorHandler handlerBlock = ^(XCSynthesizedEventRecord *record, NSError *commandError) {
+            if (commandError) {
+                [FBLogger logFmt:@"Failed to perform tap: %@", commandError];
+            }
+            if (error) {
+                *error = commandError;
+            }
+            didSucceed = (commandError == nil);
+            completion();
+        };
+        eventBlock([XCEventGenerator sharedGenerator], handlerBlock);
+    }];
+    return didSucceed;
+}
+
+- (BOOL)tapAtCoordinate:(CGPoint)point withError:(NSError * _Nullable __autoreleasing *)error {
+    return [self generateEvent:^(XCEventGenerator *eventGenerator, XCEventGeneratorHandler handlerBlock) {
+        CGPoint hitPoint = FBInvertPointForApplication(point, self.application.frame.size, self.application.interfaceOrientation);
+        if ([eventGenerator respondsToSelector:@selector(tapAtTouchLocations:numberOfTaps:orientation:handler:)]) {
+            [eventGenerator tapAtTouchLocations:@[[NSValue valueWithCGPoint:hitPoint]]
+                                   numberOfTaps:1
+                                    orientation:self.interfaceOrientation
+                                        handler:handlerBlock];
+        } else {
+            [eventGenerator tapAtPoint:hitPoint
+                           orientation:self.interfaceOrientation
+                               handler:handlerBlock];
+        }
+    } error:error];
+}
+
 - (BOOL)fb_tapWithError:(NSError **)error
 {
-  [self fb_waitUntilFrameIsStable];
-  __block BOOL didSucceed;
-  [FBRunLoopSpinner spinUntilCompletion:^(void(^completion)()){
     NSValue *hitpointValue = self.lastSnapshot.suggestedHitpoints.firstObject;
     CGPoint hitPoint = hitpointValue ? hitpointValue.CGPointValue : [self coordinateWithNormalizedOffset:CGVectorMake(0.5, 0.5)].screenPoint;
-    hitPoint = FBInvertPointForApplication(hitPoint, self.application.frame.size, self.application.interfaceOrientation);
-    XCEventGeneratorHandler handlerBlock = ^(XCSynthesizedEventRecord *record, NSError *commandError) {
-      if (commandError) {
-        [FBLogger logFmt:@"Failed to perform tap: %@", commandError];
-      }
-      if (error) {
-        *error = commandError;
-      }
-      didSucceed = (commandError == nil);
-      completion();
-    };
-    XCEventGenerator *eventGenerator = [XCEventGenerator sharedGenerator];
-    if ([eventGenerator respondsToSelector:@selector(tapAtTouchLocations:numberOfTaps:orientation:handler:)]) {
-      [eventGenerator tapAtTouchLocations:@[[NSValue valueWithCGPoint:hitPoint]] numberOfTaps:1 orientation:self.interfaceOrientation handler:handlerBlock];
-    }
-    else {
-      [eventGenerator tapAtPoint:hitPoint orientation:self.interfaceOrientation handler:handlerBlock];
-    }
-  }];
-  return didSucceed;
+    return [self tapAtCoordinate:hitPoint withError:error];
 }
 
 @end

WebDriverAgentLib/Commands/CBXCommands/CBXCommands.h

@@ -0,0 +1,16 @@
+
+#import <Foundation/Foundation.h>
+
+#import <WebDriverAgentLib/FBCommandHandler.h>
+#import "FBApplication.h"
+#import "FBRouteRequest.h"
+#import "FBSession.h"
+#import "FBApplication.h"
+#import "XCUIDevice.h"
+#import "XCUIDevice+FBHealthCheck.h"
+
+#import "CBXMacros.h"
+
+@interface CBXCommands : NSObject/* Do not implement FBCommandHandler */
++ (XCUICoordinate *)tapCoordinateForX:(CGFloat)x y:(CGFloat)y;
+@end

WebDriverAgentLib/Commands/CBXCommands/CBXCommands.m

@@ -0,0 +1,67 @@
+
+#import "XCUICoordinate.h"
+#import "XCTestDriver.h"
+#import "XCUIElement.h"
+#import "XCUIApplication.h"
+#import "XCUIElementQuery.h"
+#import "XCElementSnapshot.h"
+
+#import "CBXCommands.h"
+#import "CBXCoordinate.h"
+
+#import "FBRunLoopSpinner.h"
+#import "FBElementCache.h"
+
+@implementation CBXCommands
+
++ (XCUIElement *)elementFromSpecifiers:(NSDictionary *)specifiers {
+    XCUIElement *element;
+    if ([specifiers hasKey:@"uuid"]) {
+        FBElementCache *elementCache = [FBSession activeSessionCache];
+        element = [elementCache elementForUUID:specifiers[@"uuid"]];
+    } else if ([specifiers hasKey:@"coordinate"]) {
+        CBXCoordinate *coord = [CBXCoordinate withJSON:specifiers[@"coordinate"]];
+        element = [CBXCommands elementAtPoint:coord.cgpoint error:nil];
+    }
+    return element;
+}
+
++ (XCUICoordinate *)tapCoordinateForX:(CGFloat)x y:(CGFloat)y {
+    if ([FBSession activeSession]) {
+        XCUICoordinate *appCoordinate = [[XCUICoordinate alloc] initWithElement:[FBSession activeSession].application
+                                                               normalizedOffset:CGVectorMake(0, 0)];
+        XCUICoordinate *tapCoordinate = [[XCUICoordinate alloc] initWithCoordinate:appCoordinate
+                                                                      pointsOffset:CGVectorMake(x, y)];
+
+        return tapCoordinate;
+    }
+    NSLog(@"WARN: Requested tap coordinate when active session is nil!");
+    return nil;
+}
+
++ (XCUIElement *)elementAtPoint:(CGPoint)point error:(NSError *__autoreleasing *)error  {
+    __block XCUIElement *element = nil;
+    __block XCAccessibilityElement *accEl = nil;
+    __block NSError *outer;
+    [FBRunLoopSpinner spinUntilCompletion:^(void (^ _Nonnull completion)()) {
+        [[XCTestDriver sharedTestDriver].managerProxy _XCT_requestElementAtPoint:point
+                                                                           reply:^(XCAccessibilityElement *axEl,
+                                                                                   NSError *inner) {
+                outer = inner;
+                accEl = axEl;
+                completion();
+        }];
+    }];
+    XCElementSnapshot *snap = [[FBSession activeSession].application lastSnapshot];
+    XCElementSnapshot *elSnap = [snap elementSnapshotMatchingAccessibilityElement:accEl];
+    XCUIElementQuery *appQuery = [[FBSession activeSession].application.query descendantsMatchingType:elSnap.elementType];
+    element = [appQuery _elementMatchingAccessibilityElementOfSnapshot:elSnap];
+
+    //TODO: this can cause failures if no element found. Is it safe?
+    [element resolve];
+    if (error) {
+        *error = outer;
+    }
+    return element;
+}
+@end

WebDriverAgentLib/Commands/CBXCommands/CBXGestureCommands.h

@@ -0,0 +1,6 @@
+
+#import "CBXCommands.h"
+
+@interface CBXGestureCommands : CBXCommands<FBCommandHandler>
++ (BOOL)handleTouch:(NSDictionary *)specifiers options:(NSDictionary *)options;
+@end