appium-webdriveragent 16.12.5 → 16.12.6

package/CHANGELOG.md

@@ -1,3 +1,9 @@
+## [16.12.6](https://github.com/appium/WebDriverAgent/compare/v16.12.5...v16.12.6) (2026-09-09)
+
+### Bug Fixes
+
+* rescale gesture coordinates for compatibility-mode window mismatches ([#1249](https://github.com/appium/WebDriverAgent/issues/1249)) ([25fcd95](https://github.com/appium/WebDriverAgent/commit/25fcd9558314c367c755b047cd0db0949654e90b))
+
 ## [16.12.5](https://github.com/appium/WebDriverAgent/compare/v16.12.4...v16.12.5) (2026-09-07)
 
 ### Bug Fixes

package/WebDriverAgentLib/Categories/XCUIElement+FBForceTouch.m

@@ -11,6 +11,7 @@
 #if !TARGET_OS_TV
 
 #import "FBErrorBuilder.h"
+#import "FBMathUtils.h"
 #import "XCUICoordinate.h"
 #import "XCUIDevice.h"
 
@@ -36,8 +37,10 @@
   } else {
     CGVector offset = CGVectorMake(relativeCoordinate.CGPointValue.x,
                                    relativeCoordinate.CGPointValue.y);
-    XCUICoordinate *hitPoint = [[self coordinateWithNormalizedOffset:CGVectorMake(0, 0)]
-                                coordinateWithOffset:offset];
+    XCUICoordinate *hitPoint = FBCoordinateWithAnchorOffset(self, CGVectorMake(0, 0), offset, error);
+    if (nil == hitPoint) {
+      return NO;
+    }
     if (nil == pressure || nil == duration) {
       [hitPoint forcePress];
     } else {

package/WebDriverAgentLib/Categories/XCUIElement+FBPickerWheel.m

@@ -25,8 +25,9 @@ static const NSTimeInterval VALUE_CHANGE_TIMEOUT = 2;
 {
   id<FBXCElementSnapshot> snapshot = [self fb_standardSnapshot];
   NSString *previousValue = snapshot.value;
-  XCUICoordinate *startCoord = [self coordinateWithNormalizedOffset:CGVectorMake(0.5, 0.5)];
-  XCUICoordinate *endCoord = [startCoord coordinateWithOffset:CGVectorMake(0.0, relativeHeightOffset * snapshot.frame.size.height)];
+  // Stay in normalized offsets end-to-end: XCTest never rescales a composed raw
+  // coordinateWithOffset: for compatibility-mode windows (appium/appium#16185).
+  XCUICoordinate *endCoord = [self coordinateWithNormalizedOffset:CGVectorMake(0.5, 0.5 + relativeHeightOffset)];
   // If picker value is reflected in its accessiblity id
   // then fetching of the next snapshot may fail with StaleElementReferenceError
   // because we bound elements by their accessbility ids by default.

package/WebDriverAgentLib/Categories/XCUIElement+FBScrolling.m

@@ -16,6 +16,8 @@
 #import "FBXCElementSnapshotWrapper.h"
 #import "FBXCElementSnapshotWrapper+Helpers.h"
 #import "XCUIElement+FBCaching.h"
+#import "XCUIElement+FBResolve.h"
+#import "XCUIElement+FBUID.h"
 #import "XCUIApplication.h"
 #import "XCUICoordinate.h"
 #import "XCUIElement+FBIsVisible.h"
@@ -35,15 +37,37 @@ const CGFloat FBScrollTouchProportion = 0.75f;
 
 @interface FBXCElementSnapshotWrapper (FBScrolling)
 
-- (void)fb_scrollUpByNormalizedDistance:(CGFloat)distance inApplication:(XCUIApplication *)application;
-- (void)fb_scrollDownByNormalizedDistance:(CGFloat)distance inApplication:(XCUIApplication *)application;
-- (void)fb_scrollLeftByNormalizedDistance:(CGFloat)distance inApplication:(XCUIApplication *)application;
-- (void)fb_scrollRightByNormalizedDistance:(CGFloat)distance inApplication:(XCUIApplication *)application;
-- (BOOL)fb_scrollByNormalizedVector:(CGVector)normalizedScrollVector inApplication:(XCUIApplication *)application;
-- (BOOL)fb_scrollByVector:(CGVector)vector inApplication:(XCUIApplication *)application error:(NSError **)error;
+- (BOOL)fb_scrollUpByNormalizedDistance:(CGFloat)distance anchorElement:(XCUIElement *)anchorElement;
+- (BOOL)fb_scrollDownByNormalizedDistance:(CGFloat)distance anchorElement:(XCUIElement *)anchorElement;
+- (BOOL)fb_scrollLeftByNormalizedDistance:(CGFloat)distance anchorElement:(XCUIElement *)anchorElement;
+- (BOOL)fb_scrollRightByNormalizedDistance:(CGFloat)distance anchorElement:(XCUIElement *)anchorElement;
+- (BOOL)fb_scrollByNormalizedVector:(CGVector)normalizedScrollVector anchorElement:(XCUIElement *)anchorElement;
+- (BOOL)fb_scrollByVector:(CGVector)vector anchorElement:(XCUIElement *)anchorElement error:(NSError **)error;
 
 @end
 
+/**
+ Resolves a live element for the given snapshot, so gesture coordinates can be anchored
+ to it (its frame gets rescaled by XCTest for compatibility-mode windows; a raw
+ XCUIApplication anchor never does - see appium/appium#16185). Returns nil, rather than
+ falling back to the application, if the snapshot can no longer be located: anchoring to
+ the application would silently reproduce the very bug this is fixing.
+ */
+static XCUIElement *FBLiveElementForSnapshot(id<FBXCElementSnapshot> snapshot, XCUIApplication *application)
+{
+  NSString *uid = [FBXCElementSnapshotWrapper wdUIDWithSnapshot:snapshot];
+  if (nil == uid) {
+    return nil;
+  }
+  XCUIElement *result;
+  @autoreleasepool {
+    NSPredicate *predicate = [NSPredicate predicateWithFormat:@"%K = %@", FBStringify(FBXCElementSnapshotWrapper, fb_uid), uid];
+    result = [[application.fb_query descendantsMatchingType:XCUIElementTypeAny] matchingPredicate:predicate].allElementsBoundByIndex.firstObject;
+  }
+  result.fb_isResolvedNatively = @NO;
+  return result;
+}
+
 @implementation XCUIElement (FBScrolling)
 
 - (BOOL)fb_nativeScrollToVisibleWithError:(NSError **)error
@@ -61,28 +85,28 @@ const CGFloat FBScrollTouchProportion = 0.75f;
 {
   id<FBXCElementSnapshot> snapshot = [self fb_customSnapshot];
   [[FBXCElementSnapshotWrapper ensureWrapped:snapshot] fb_scrollUpByNormalizedDistance:distance
-                                                                         inApplication:self.application];
+                                                                         anchorElement:self];
 }
 
 - (void)fb_scrollDownByNormalizedDistance:(CGFloat)distance
 {
   id<FBXCElementSnapshot> snapshot = [self fb_customSnapshot];
   [[FBXCElementSnapshotWrapper ensureWrapped:snapshot] fb_scrollDownByNormalizedDistance:distance
-                                                                           inApplication:self.application];
+                                                                           anchorElement:self];
 }
 
 - (void)fb_scrollLeftByNormalizedDistance:(CGFloat)distance
 {
   id<FBXCElementSnapshot> snapshot = [self fb_customSnapshot];
   [[FBXCElementSnapshotWrapper ensureWrapped:snapshot] fb_scrollLeftByNormalizedDistance:distance
-                                                                           inApplication:self.application];
+                                                                           anchorElement:self];
 }
 
 - (void)fb_scrollRightByNormalizedDistance:(CGFloat)distance
 {
   id<FBXCElementSnapshot> snapshot = [self fb_customSnapshot];
   [[FBXCElementSnapshotWrapper ensureWrapped:snapshot] fb_scrollRightByNormalizedDistance:distance
-                                                                            inApplication:self.application];
+                                                                            anchorElement:self];
 }
 
 - (BOOL)fb_scrollToVisibleWithError:(NSError **)error
@@ -176,30 +200,52 @@ const CGFloat FBScrollTouchProportion = 0.75f;
     }
   }
 
+  // The scroll view's own identity is stable across scroll steps, so it only needs
+  // to be resolved to a live element once, up front; its frame does not, since it can
+  // change across scroll steps (rotation, keyboard, dynamic layout).
+  XCUIElement *scrollViewElement = FBLiveElementForSnapshot(scrollView, self.application);
+  if (nil == scrollViewElement) {
+    return
+    [[[FBErrorBuilder builder]
+      withDescriptionFormat:@"Failed to resolve a live element for the scrollable parent of '%@'", self.description]
+     buildError:error];
+  }
+
   const NSUInteger maxScrollCount = 25;
   NSUInteger scrollCount = 0;
-  FBXCElementSnapshotWrapper *scrollViewWrapped = [FBXCElementSnapshotWrapper ensureWrapped:scrollView];
+  FBXCElementSnapshotWrapper *scrollViewWrapped;
   // Scrolling till cell is visible and get current value of frames
   while (![self fb_isEquivalentElementSnapshotVisible:prescrollSnapshot] && scrollCount < maxScrollCount) {
+    BOOL didScroll;
     @autoreleasepool {
+      // Re-snapshotting the scroll view every step keeps its frame from drifting too far
+      // out of sync with the live anchor element's frame used to resolve touch points.
+      scrollViewWrapped = [FBXCElementSnapshotWrapper ensureWrapped:[scrollViewElement fb_customSnapshot]];
       if (targetCellIndex < visibleCellIndex) {
-        scrollDirection == FBXCUIElementScrollDirectionVertical ?
+        didScroll = scrollDirection == FBXCUIElementScrollDirectionVertical ?
           [scrollViewWrapped fb_scrollUpByNormalizedDistance:normalizedScrollDistance
-                                               inApplication:self.application] :
+                                                anchorElement:scrollViewElement] :
           [scrollViewWrapped fb_scrollLeftByNormalizedDistance:normalizedScrollDistance
-                                                 inApplication:self.application];
+                                                  anchorElement:scrollViewElement];
       }
       else {
-        scrollDirection == FBXCUIElementScrollDirectionVertical ?
+        didScroll = scrollDirection == FBXCUIElementScrollDirectionVertical ?
           [scrollViewWrapped fb_scrollDownByNormalizedDistance:normalizedScrollDistance
-                                                 inApplication:self.application] :
+                                                  anchorElement:scrollViewElement] :
           [scrollViewWrapped fb_scrollRightByNormalizedDistance:normalizedScrollDistance
-                                                  inApplication:self.application];
+                                                   anchorElement:scrollViewElement];
       }
       scrollCount++;
       // Wait for scroll animation
       [self fb_waitUntilStableWithTimeout:FBConfiguration.sharedInstance.animationCoolOffTimeout];
     }
+    // The `error` out-param must not be written from inside the autorelease pool above.
+    if (!didScroll) {
+      return
+      [[[FBErrorBuilder builder]
+        withDescriptionFormat:@"Failed to scroll '%@': its frame is empty", self.description]
+       buildError:error];
+    }
   }
 
   if (scrollCount >= maxScrollCount) {
@@ -215,12 +261,13 @@ const CGFloat FBScrollTouchProportion = 0.75f;
   FBXCElementSnapshotWrapper *targetCellSnapshotWrapped = [FBXCElementSnapshotWrapper ensureWrapped:[self fb_customSnapshot]];
   targetCellSnapshot = [targetCellSnapshotWrapped fb_parentCellSnapshot];
   CGRect visibleFrame = [FBXCElementSnapshotWrapper ensureWrapped:targetCellSnapshot].fb_visibleFrame;
-  
+
   CGVector scrollVector = CGVectorMake(visibleFrame.size.width - targetCellSnapshot.frame.size.width,
                                        visibleFrame.size.height - targetCellSnapshot.frame.size.height
                                        );
+  scrollViewWrapped = [FBXCElementSnapshotWrapper ensureWrapped:[scrollViewElement fb_customSnapshot]];
   return [scrollViewWrapped fb_scrollByVector:scrollVector
-                                inApplication:self.application
+                                anchorElement:scrollViewElement
                                         error:error];
 }
 
@@ -254,42 +301,42 @@ const CGFloat FBScrollTouchProportion = 0.75f;
   return self.visibleFrame;
 }
 
-- (void)fb_scrollUpByNormalizedDistance:(CGFloat)distance
-                          inApplication:(XCUIApplication *)application
+- (BOOL)fb_scrollUpByNormalizedDistance:(CGFloat)distance
+                           anchorElement:(XCUIElement *)anchorElement
 {
-  [self fb_scrollByNormalizedVector:CGVectorMake(0.0, distance) inApplication:application];
+  return [self fb_scrollByNormalizedVector:CGVectorMake(0.0, distance) anchorElement:anchorElement];
 }
 
-- (void)fb_scrollDownByNormalizedDistance:(CGFloat)distance
-                            inApplication:(XCUIApplication *)application
+- (BOOL)fb_scrollDownByNormalizedDistance:(CGFloat)distance
+                             anchorElement:(XCUIElement *)anchorElement
 {
-  [self fb_scrollByNormalizedVector:CGVectorMake(0.0, -distance) inApplication:application];
+  return [self fb_scrollByNormalizedVector:CGVectorMake(0.0, -distance) anchorElement:anchorElement];
 }
 
-- (void)fb_scrollLeftByNormalizedDistance:(CGFloat)distance
-                            inApplication:(XCUIApplication *)application
+- (BOOL)fb_scrollLeftByNormalizedDistance:(CGFloat)distance
+                             anchorElement:(XCUIElement *)anchorElement
 {
-  [self fb_scrollByNormalizedVector:CGVectorMake(distance, 0.0) inApplication:application];
+  return [self fb_scrollByNormalizedVector:CGVectorMake(distance, 0.0) anchorElement:anchorElement];
 }
 
-- (void)fb_scrollRightByNormalizedDistance:(CGFloat)distance
-                             inApplication:(XCUIApplication *)application
+- (BOOL)fb_scrollRightByNormalizedDistance:(CGFloat)distance
+                              anchorElement:(XCUIElement *)anchorElement
 {
-  [self fb_scrollByNormalizedVector:CGVectorMake(-distance, 0.0) inApplication:application];
+  return [self fb_scrollByNormalizedVector:CGVectorMake(-distance, 0.0) anchorElement:anchorElement];
 }
 
 - (BOOL)fb_scrollByNormalizedVector:(CGVector)normalizedScrollVector
-                      inApplication:(XCUIApplication *)application
+                       anchorElement:(XCUIElement *)anchorElement
 {
   CGVector scrollVector = CGVectorMake(CGRectGetWidth(self.scrollingFrame) * normalizedScrollVector.dx,
                                        CGRectGetHeight(self.scrollingFrame) * normalizedScrollVector.dy
                                        );
-  return [self fb_scrollByVector:scrollVector inApplication:application error:nil];
+  return [self fb_scrollByVector:scrollVector anchorElement:anchorElement error:nil];
 }
 
 - (BOOL)fb_scrollByVector:(CGVector)vector
-            inApplication:(XCUIApplication *)application
-                    error:(NSError **)error
+             anchorElement:(XCUIElement *)anchorElement
+                     error:(NSError **)error
 {
   CGVector scrollBoundingVector = CGVectorMake(
                                                CGRectGetWidth(self.scrollingFrame) * FBScrollTouchProportion,
@@ -306,29 +353,49 @@ const CGFloat FBScrollTouchProportion = 0.75f;
                                          fabs(vector.dy) > fabs(scrollBoundingVector.dy) ? scrollBoundingVector.dy : vector.dy);
     vector = CGVectorMake(vector.dx - scrollVector.dx, vector.dy - scrollVector.dy);
     shouldFinishScrolling = FBVectorFuzzyEqualToVector(vector, CGZeroVector, 1) || --preciseScrollAttemptsCount <= 0;
-    if (![self fb_scrollAncestorScrollViewByVectorWithinScrollViewFrame:scrollVector inApplication:application error:error]){
+    if (![self fb_scrollAncestorScrollViewByVectorWithinScrollViewFrame:scrollVector anchorElement:anchorElement error:error]){
       return NO;
     }
   }
   return YES;
 }
 
-- (CGVector)fb_hitPointOffsetForScrollingVector:(CGVector)scrollingVector
+// Normalized (0.0-1.0) touch-down offset within the scrolling frame, for the given
+// scroll vector's direction.
+- (CGVector)fb_normalizedHitPointOffsetForScrollingVector:(CGVector)scrollingVector
 {
-  CGFloat x = CGRectGetMinX(self.scrollingFrame) + CGRectGetWidth(self.scrollingFrame) * (scrollingVector.dx < 0.0f ? FBScrollTouchProportion : (1 - FBScrollTouchProportion));
-  CGFloat y = CGRectGetMinY(self.scrollingFrame) + CGRectGetHeight(self.scrollingFrame) * (scrollingVector.dy < 0.0f ? FBScrollTouchProportion : (1 - FBScrollTouchProportion));
-  return CGVectorMake((CGFloat)floor(x), (CGFloat)floor(y));
+  CGFloat x = scrollingVector.dx < 0.0f ? FBScrollTouchProportion : (1 - FBScrollTouchProportion);
+  CGFloat y = scrollingVector.dy < 0.0f ? FBScrollTouchProportion : (1 - FBScrollTouchProportion);
+  return CGVectorMake(x, y);
 }
 
 - (BOOL)fb_scrollAncestorScrollViewByVectorWithinScrollViewFrame:(CGVector)vector
-                                                   inApplication:(XCUIApplication *)application
-                                                           error:(NSError **)error
+                                                     anchorElement:(XCUIElement *)anchorElement
+                                                             error:(NSError **)error
 {
-  CGVector hitpointOffset = [self fb_hitPointOffsetForScrollingVector:vector];
+  CGRect scrollingFrame = self.scrollingFrame;
+  CGRect anchorFrame = anchorElement.frame;
+  if (CGRectIsEmpty(scrollingFrame) || CGRectIsEmpty(anchorFrame)) {
+    return [[[FBErrorBuilder builder]
+             withDescriptionFormat:@"Cannot compute a scroll gesture for '%@': its frame is empty", self.fb_description]
+            buildError:error];
+  }
 
-  XCUICoordinate *appCoordinate = [[XCUICoordinate alloc] initWithElement:application normalizedOffset:CGVectorMake(0.0, 0.0)];
-  XCUICoordinate *startCoordinate = [[XCUICoordinate alloc] initWithCoordinate:appCoordinate pointsOffset:hitpointOffset];
-  XCUICoordinate *endCoordinate = [[XCUICoordinate alloc] initWithCoordinate:startCoordinate pointsOffset:vector];
+  // Compute the touch-down/up points within the (possibly clipped) scrolling frame as
+  // before, then express them as fractions of the anchor element's own frame instead of
+  // raw points, which XCTest never rescales for compatibility-mode windows
+  // (appium/appium#16185). When scrollingFrame == anchorFrame this resolves to the exact
+  // same absolute point as before; it only differs once XCTest itself rescales anchorFrame.
+  CGVector proportion = [self fb_normalizedHitPointOffsetForScrollingVector:vector];
+  CGPoint startPoint = CGPointMake((CGFloat)floor(scrollingFrame.origin.x + scrollingFrame.size.width * proportion.dx),
+                                   (CGFloat)floor(scrollingFrame.origin.y + scrollingFrame.size.height * proportion.dy));
+  CGPoint endPoint = CGPointMake((CGFloat)floor(startPoint.x + vector.dx), (CGFloat)floor(startPoint.y + vector.dy));
+  CGVector startOffset = CGVectorMake((startPoint.x - anchorFrame.origin.x) / anchorFrame.size.width,
+                                      (startPoint.y - anchorFrame.origin.y) / anchorFrame.size.height);
+  CGVector endOffset = CGVectorMake((endPoint.x - anchorFrame.origin.x) / anchorFrame.size.width,
+                                    (endPoint.y - anchorFrame.origin.y) / anchorFrame.size.height);
+  XCUICoordinate *startCoordinate = [anchorElement coordinateWithNormalizedOffset:startOffset];
+  XCUICoordinate *endCoordinate = [anchorElement coordinateWithNormalizedOffset:endOffset];
 
   if (FBPointFuzzyEqualToPoint(startCoordinate.screenPoint, endCoordinate.screenPoint, FBFuzzyPointThreshold)) {
     return YES;

package/WebDriverAgentLib/Commands/FBElementCommands.m

@@ -353,14 +353,23 @@
 + (id<FBResponsePayload>)handlePressAndDragCoordinateWithVelocity:(FBRouteRequest *)request
 {
   XCUIApplication *application = request.session.activeApplication;
+  NSError *error;
   CGVector startOffset = CGVectorMake((CGFloat)[request.arguments[@"fromX"] doubleValue],
                                      (CGFloat)[request.arguments[@"fromY"] doubleValue]);
   XCUICoordinate *startCoordinate = [self.class gestureCoordinateWithOffset:startOffset
-                                                                    element:application];
+                                                                    element:application
+                                                                      error:&error];
+  if (nil == startCoordinate) {
+    return FBResponseWithStatus([FBCommandStatus invalidElementStateErrorWithMessage:error.description traceback:nil]);
+  }
   CGVector endOffset = CGVectorMake((CGFloat)[request.arguments[@"toX"] doubleValue],
                                     (CGFloat)[request.arguments[@"toY"] doubleValue]);
   XCUICoordinate *endCoordinate = [self.class gestureCoordinateWithOffset:endOffset
-                                                                  element:application];
+                                                                  element:application
+                                                                    error:&error];
+  if (nil == endCoordinate) {
+    return FBResponseWithStatus([FBCommandStatus invalidElementStateErrorWithMessage:error.description traceback:nil]);
+  }
   [startCoordinate pressForDuration:[request.arguments[@"pressDuration"] doubleValue]
                thenDragToCoordinate:endCoordinate
                        withVelocity:[request.arguments[@"velocity"] doubleValue]
@@ -433,12 +442,19 @@
 + (id<FBResponsePayload>)handleDrag:(FBRouteRequest *)request
 {
   XCUIElement *target = [self targetFromRequest:request];
+  NSError *error;
   CGVector startOffset = CGVectorMake([request.arguments[@"fromX"] doubleValue],
                                       [request.arguments[@"fromY"] doubleValue]);
-  XCUICoordinate *startCoordinate = [self.class gestureCoordinateWithOffset:startOffset element:target];
+  XCUICoordinate *startCoordinate = [self.class gestureCoordinateWithOffset:startOffset element:target error:&error];
+  if (nil == startCoordinate) {
+    return FBResponseWithStatus([FBCommandStatus invalidElementStateErrorWithMessage:error.description traceback:nil]);
+  }
   CGVector endOffset = CGVectorMake([request.arguments[@"toX"] doubleValue],
                                     [request.arguments[@"toY"] doubleValue]);
-  XCUICoordinate *endCoordinate = [self.class gestureCoordinateWithOffset:endOffset element:target];
+  XCUICoordinate *endCoordinate = [self.class gestureCoordinateWithOffset:endOffset element:target error:&error];
+  if (nil == endCoordinate) {
+    return FBResponseWithStatus([FBCommandStatus invalidElementStateErrorWithMessage:error.description traceback:nil]);
+  }
   NSTimeInterval duration = [request.arguments[@"duration"] doubleValue];
   [startCoordinate pressForDuration:duration thenDragToCoordinate:endCoordinate];
   return FBResponseWithOK();
@@ -659,12 +675,15 @@ static const NSInteger DEFAULT_MAX_PICKER_ATTEMPTS = 25;
 
  @param offset absolute screen offset for the given application
  @param element the element instance to perform the gesture on
- @return translated gesture coordinates ready to be passed to XCUICoordinate methods
+ @param error Error instance if any
+ @return translated gesture coordinates ready to be passed to XCUICoordinate methods, or
+ nil if the element is not visible on the screen
  */
-+ (XCUICoordinate *)gestureCoordinateWithOffset:(CGVector)offset
-                                        element:(XCUIElement *)element
++ (nullable XCUICoordinate *)gestureCoordinateWithOffset:(CGVector)offset
+                                                  element:(XCUIElement *)element
+                                                    error:(NSError **)error
 {
-  return [[element coordinateWithNormalizedOffset:CGVectorMake(0, 0)] coordinateWithOffset:offset];
+  return FBCoordinateWithAnchorOffset(element, CGVectorMake(0, 0), offset, error);
 }
 
 /**
@@ -688,7 +707,8 @@ static const NSInteger DEFAULT_MAX_PICKER_ATTEMPTS = 25;
     return nil;
   }
   return [self gestureCoordinateWithOffset:CGVectorMake(x.doubleValue, y.doubleValue)
-                                   element:[self targetFromRequest:request]];
+                                   element:[self targetFromRequest:request]
+                                     error:error];
 }
 
 /**

package/WebDriverAgentLib/Info.plist

@@ -15,11 +15,11 @@
     <key>CFBundlePackageType</key>
     <string>FMWK</string>
     <key>CFBundleShortVersionString</key>
-    <string>16.12.5</string>
+    <string>16.12.6</string>
     <key>CFBundleSignature</key>
     <string>????</string>
     <key>CFBundleVersion</key>
-    <string>16.12.5</string>
+    <string>16.12.6</string>
     <key>NSPrincipalClass</key>
     <string/>
   </dict>

package/WebDriverAgentLib/Utilities/FBBaseActionsSynthesizer.m

@@ -74,9 +74,9 @@
     return [element coordinateWithNormalizedOffset:CGVectorMake(0.5, 0.5)];
   }
 
-  CGVector offset = CGVectorMake(positionOffset.CGPointValue.x, positionOffset.CGPointValue.y);
   // TODO: Shall we throw an exception if hitPoint is out of the element frame?
-  return [[element coordinateWithNormalizedOffset:CGVectorMake(0, 0)] coordinateWithOffset:offset];
+  CGVector offset = CGVectorMake(positionOffset.CGPointValue.x, positionOffset.CGPointValue.y);
+  return FBCoordinateWithAnchorOffset((XCUIElement *)element, CGVectorMake(0, 0), offset, error);
 }
 
 @end

package/WebDriverAgentLib/Utilities/FBMathUtils.h

@@ -9,6 +9,10 @@
 #import <UIKit/UIKit.h>
 
 @class XCUIApplication;
+@class XCUICoordinate;
+@class XCUIElement;
+
+NS_ASSUME_NONNULL_BEGIN
 
 extern CGFloat FBDefaultFrameFuzzyThreshold;
 
@@ -34,3 +38,27 @@ BOOL FBRectFuzzyEqualToRect(CGRect rect1, CGRect rect2, CGFloat threshold);
 /*! Inverts size if necessary to match current screen orientation */
 CGSize FBAdjustDimensionsForApplication(CGSize actualSize, UIInterfaceOrientation orientation);
 #endif
+
+#if !TARGET_OS_TV
+/*!
+ Builds a coordinate for the given element from a raw points offset measured from a
+ normalized anchor point within the element's own frame - e.g. (0, 0) for an offset
+ relative to the top-left corner, (0.5, 0.5) for one relative to the center, as W3C
+ actions use. The offset is normalized against the element's wdFrame (the same
+ WDA-reported coordinate space pointsOffset itself is measured in) instead of being
+ passed through as a raw points offset, which XCTest never rescales for
+ compatibility-mode windows (see appium/appium#16185).
+
+ @param element the element to anchor the coordinate to
+ @param anchorOffset normalized offset of the anchor point within the element's wdFrame
+ @param pointsOffset raw points offset from the anchor point, in wdFrame's coordinate space
+ @param error populated if the element's frame is empty (not visible on the screen)
+ @return the resulting coordinate, or nil if the element's frame is empty
+ */
+XCUICoordinate * _Nullable FBCoordinateWithAnchorOffset(XCUIElement *element,
+                                                         CGVector anchorOffset,
+                                                         CGVector pointsOffset,
+                                                         NSError **error);
+#endif
+
+NS_ASSUME_NONNULL_END

package/WebDriverAgentLib/Utilities/FBMathUtils.m

@@ -8,7 +8,11 @@
 
 #import "FBMathUtils.h"
 
+#import "FBErrorBuilder.h"
 #import "FBMacros.h"
+#import "XCUICoordinate.h"
+#import "XCUIElement.h"
+#import "XCUIElement+FBWebDriverAttributes.h"
 
 CGFloat FBDefaultFrameFuzzyThreshold = 2.0;
 
@@ -51,7 +55,7 @@ CGSize FBAdjustDimensionsForApplication(CGSize actualSize, UIInterfaceOrientatio
   if (orientation == UIInterfaceOrientationLandscapeLeft || orientation == UIInterfaceOrientationLandscapeRight) {
     /*
      There is an XCTest bug that application.frame property returns exchanged dimensions for landscape mode.
-     This verification is just to make sure the bug is still there (since height is never greater than width in landscape) 
+     This verification is just to make sure the bug is still there (since height is never greater than width in landscape)
      and to make it still working properly after XCTest itself starts to respect landscape mode.
      */
     if (actualSize.height > actualSize.width) {
@@ -61,3 +65,24 @@ CGSize FBAdjustDimensionsForApplication(CGSize actualSize, UIInterfaceOrientatio
   return actualSize;
 }
 #endif
+
+#if !TARGET_OS_TV
+XCUICoordinate *FBCoordinateWithAnchorOffset(XCUIElement *element,
+                                              CGVector anchorOffset,
+                                              CGVector pointsOffset,
+                                              NSError **error)
+{
+  // wdFrame matches the coordinate space pointsOffset was measured in; element.frame alone
+  // can already be pre-scaled for a compatibility-mode window mismatch, double-applying it.
+  CGRect frame = element.wdFrame;
+  if (CGRectIsEmpty(frame)) {
+    [[[FBErrorBuilder builder]
+      withDescriptionFormat:@"The element '%@' is not visible on the screen and thus is not interactable", element.description]
+     buildError:error];
+    return nil;
+  }
+  CGVector normalizedOffset = CGVectorMake(anchorOffset.dx + pointsOffset.dx / frame.size.width,
+                                           anchorOffset.dy + pointsOffset.dy / frame.size.height);
+  return [element coordinateWithNormalizedOffset:normalizedOffset];
+}
+#endif

package/WebDriverAgentLib/Utilities/FBW3CActionsSynthesizer.m

@@ -162,7 +162,7 @@ static NSString *const FB_KEY_ACTIONS = @"actions";
     return [super hitpointWithElement:element positionOffset:positionOffset error:error];
   }
 
-  // An offset relative to the element is defined
+  // An offset relative to the element is defined.
   if (CGRectIsEmpty(element.frame)) {
     [FBLogger log:self.application.fb_descriptionRepresentation];
     NSString *description = [NSString stringWithFormat:@"The element '%@' is not visible on the screen and thus is not interactable",
@@ -174,9 +174,9 @@ static NSString *const FB_KEY_ACTIONS = @"actions";
   }
 
   // W3C standard requires that relative element coordinates start at the center of the element's rectangle
-  CGVector offset = CGVectorMake(positionOffset.CGPointValue.x, positionOffset.CGPointValue.y);
   // TODO: Shall we throw an exception if hitPoint is out of the element frame?
-  return [[element coordinateWithNormalizedOffset:CGVectorMake(0.5, 0.5)] coordinateWithOffset:offset];
+  CGVector offset = CGVectorMake(positionOffset.CGPointValue.x, positionOffset.CGPointValue.y);
+  return FBCoordinateWithAnchorOffset((XCUIElement *)element, CGVectorMake(0.5, 0.5), offset, error);
 }
 
 @end

package/WebDriverAgentTests/IntegrationApp/Classes/TouchableView.m

@@ -78,9 +78,15 @@
 {
   if (touch)
   {
+    CGPoint location = [touch locationInView:self];
+    // Exposes the last touch-down location, in this view's own bounds coordinate
+    // space, for tests to assert on regardless of any window-level scaling.
+    self.isAccessibilityElement = YES;
+    self.accessibilityValue = [NSString stringWithFormat:@"%.2f,%.2f", location.x, location.y];
+
     TouchSpotView *newView = [[TouchSpotView alloc] init];
     newView.bounds = CGRectMake(0, 0, 1, 1);
-    newView.center = [touch locationInView:self];
+    newView.center = location;
     [self addSubview:newView];
     [UIView animateWithDuration:0.2 animations:^{
       newView.bounds = CGRectMake(0, 0, 100, 100);

package/WebDriverAgentTests/IntegrationTests/FBElementSwipingTests.m

@@ -93,10 +93,10 @@
 - (void)setUp
 {
   [super setUp];
-  static dispatch_once_t onceToken;
-  dispatch_once(&onceToken, ^{
-    [self openScrollView];
-  });
+  // Each test (and retry) must start at row zero, not at the previous test's
+  // scroll offset. A velocity-based swipe need not undo an earlier swipe.
+  [self resetOrientation];
+  [self openScrollView];
 }
 
 - (void)testSwipeUp

package/WebDriverAgentTests/IntegrationTests/FBIntegrationAppTests.m

@@ -47,10 +47,19 @@
   NSUInteger count = 0;
   for (NSNumber *orientation in orientations) {
     [self rotateTo:orientation.integerValue];
+    // XCTest can report idle before the rotation animation finishes. Re-read
+    // the geometry until the controls have reached their on-screen layout.
+    FBAssertWaitTillBecomesTrue(
+      CGRectContainsRect(self.testedApplication.frame, canvas.frame)
+      && CGRectContainsRect(self.testedApplication.frame, taps.frame)
+      && CGRectContainsRect(self.testedApplication.frame, touches.frame));
     CGRect screen = self.testedApplication.frame;
-    XCTAssertTrue(CGRectContainsRect(screen, canvas.frame));
-    XCTAssertTrue(CGRectContainsRect(screen, taps.frame));
-    XCTAssertTrue(CGRectContainsRect(screen, touches.frame));
+    XCTAssertTrue(CGRectContainsRect(screen, canvas.frame), @"Screen: %@; canvas: %@",
+                  NSStringFromCGRect(screen), NSStringFromCGRect(canvas.frame));
+    XCTAssertTrue(CGRectContainsRect(screen, taps.frame), @"Screen: %@; taps: %@",
+                  NSStringFromCGRect(screen), NSStringFromCGRect(taps.frame));
+    XCTAssertTrue(CGRectContainsRect(screen, touches.frame), @"Screen: %@; touches: %@",
+                  NSStringFromCGRect(screen), NSStringFromCGRect(touches.frame));
     XCTAssertGreaterThan(CGRectGetHeight(canvas.frame), 0);
     [canvas tap];
     NSString *expectedTaps = [NSString stringWithFormat:@"%lu", (unsigned long)++count];

package/WebDriverAgentTests/IntegrationTests/FBIntegrationTestCase.h

@@ -91,4 +91,11 @@ extern NSArray<NSString *> *const FBMainViewButtonLabels;
  */
 - (void)resetOrientation;
 
+/**
+ appium/appium#16185: skips the current test unless the app's window size actually
+ differs from SpringBoard's, e.g. an iPhone-only app on iPad (built with
+ TARGETED_DEVICE_FAMILY=1).
+ */
+- (void)skipUnlessWindowSizeMismatchesDevice;
+
 @end

package/WebDriverAgentTests/IntegrationTests/FBIntegrationTestCase.m

@@ -163,4 +163,14 @@ NSArray<NSString *> *const FBMainViewButtonLabels = @[
   FBAssertWaitTillBecomesTrue(self.testedApplication.alerts.count == 0);
 }
 
+- (void)skipUnlessWindowSizeMismatchesDevice
+{
+  CGSize appSize = self.testedApplication.frame.size;
+  CGSize deviceSize = self.springboard.frame.size;
+  if (fabs(appSize.width - deviceSize.width) < 1 && fabs(appSize.height - deviceSize.height) < 1) {
+    XCTSkip(@"App window size matches SpringBoard's on this build/device, so it does not "
+            "reproduce the compatibility-mode mismatch from appium/appium#16185");
+  }
+}
+
 @end

package/WebDriverAgentTests/IntegrationTests/FBTapTest.m

@@ -11,9 +11,13 @@
 #import "FBIntegrationTestCase.h"
 
 #import "FBElementCache.h"
+#import "FBMathUtils.h"
 #import "FBTestMacros.h"
+#import "XCUIApplication+FBTouchAction.h"
+#import "XCUICoordinate.h"
 #import "XCUIDevice+FBRotation.h"
 #import "XCUIElement+FBIsVisible.h"
+#import "XCUIElement+FBWebDriverAttributes.h"
 
 @interface FBTapTest : FBIntegrationTestCase
 @end
@@ -100,4 +104,83 @@
   [self verifyTapByCoordinatesWithOrientation:UIDeviceOrientationPortraitUpsideDown];
 }
 
+// Element-less absolute offsets are never rescaled by XCTest's XCUICoordinate (verified by
+// disassembling XCUIAutomation.framework), so this still fails under a window-size mismatch.
+- (void)testTapAtElementRectCenterUnderWindowSizeMismatch
+{
+  [self skipUnlessWindowSizeMismatchesDevice];
+
+  XCUIElement *dstButton = self.testedApplication.buttons[FBShowAlertButtonName];
+  CGRect rect = dstButton.wdFrame;
+  CGPoint center = CGPointMake(CGRectGetMidX(rect), CGRectGetMidY(rect));
+
+  // Mirrors FBBaseActionsSynthesizer's hitpointWithElement:positionOffset:
+  // for an absolute (x, y) offset, as used by touch/perform and W3C actions.
+  XCUICoordinate *appOrigin = [self.testedApplication coordinateWithNormalizedOffset:CGVectorMake(0, 0)];
+  XCUICoordinate *tapPoint = [appOrigin coordinateWithOffset:CGVectorMake(center.x, center.y)];
+  [tapPoint tap];
+
+  XCTExpectFailureInBlock(@"element-less absolute offsets are never rescaled by XCTest for a "
+                           "compatibility-mode window (appium/appium#16185); starts failing "
+                           "loudly here the moment XCTest fixes this itself", ^{
+    FBAssertWaitTillBecomesTrue(self.testedApplication.alerts.count > 0);
+  });
+}
+
+@end
+
+// The Touch page's touchable view records each touch-down's location, in its own bounds
+// coordinate space, as its accessibility value - a ground truth unaffected by any
+// window-level scaling, letting these tests assert on exact landing position rather than
+// just on whether a tap happened to land inside some (possibly large) target.
+@interface FBElementOffsetTapTest : FBIntegrationTestCase
+@end
+
+@implementation FBElementOffsetTapTest
+
+- (void)setUp
+{
+  [super setUp];
+  [self launchApplication];
+  [self goToTouchPage];
+}
+
+- (CGPoint)lastTouchLocationOf:(XCUIElement *)touchable
+{
+  NSString *value = touchable.value;
+  NSArray<NSString *> *components = [value componentsSeparatedByString:@","];
+  return CGPointMake(components.firstObject.doubleValue, components.lastObject.doubleValue);
+}
+
+// FBW3CActionsSynthesizer normalizes element-relative offsets against the element's own
+// frame, so this keeps landing at the intended point under a window-size mismatch
+// (appium/appium#16185), unlike an element-less absolute offset.
+- (void)testTapWithElementOffsetUnderWindowSizeMismatch
+{
+  [self skipUnlessWindowSizeMismatchesDevice];
+
+  XCUIElement *touchable = self.testedApplication.otherElements[@"touchableView"];
+  CGSize size = touchable.wdFrame.size;
+  CGVector offset = CGVectorMake(size.width / 4, -size.height / 4);
+  CGPoint expectedLocation = CGPointMake(size.width / 2 + offset.dx, size.height / 2 + offset.dy);
+
+  NSArray<NSDictionary<NSString *, id> *> *gesture =
+  @[@{
+      @"type": @"pointer",
+      @"id": @"finger1",
+      @"parameters": @{@"pointerType": @"touch"},
+      @"actions": @[
+          @{@"type": @"pointerMove", @"duration": @0, @"origin": touchable, @"x": @(offset.dx), @"y": @(offset.dy)},
+          @{@"type": @"pointerDown"},
+          @{@"type": @"pause", @"duration": @50},
+          @{@"type": @"pointerUp"},
+          ],
+      },
+    ];
+  NSError *error;
+  XCTAssertTrue([self.testedApplication fb_performW3CActions:gesture elementCache:nil error:&error]);
+
+  FBAssertWaitTillBecomesTrue(FBPointFuzzyEqualToPoint([self lastTouchLocationOf:touchable], expectedLocation, 5.0));
+}
+
 @end

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "appium-webdriveragent",
-  "version": "16.12.5",
+  "version": "16.12.6",
   "description": "Package bundling WebDriverAgent",
   "keywords": [
     "Appium",