appium-webdriveragent 16.14.0 → 16.14.1

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+## [16.14.1](https://github.com/appium/WebDriverAgent/compare/v16.14.0...v16.14.1) (2026-10-07)
+
+### Bug Fixes
+
+* report geometry for the selected display ([#1291](https://github.com/appium/WebDriverAgent/issues/1291)) ([43fa6da](https://github.com/appium/WebDriverAgent/commit/43fa6da647fb8adca21fdbd106d8f73d782d6717))
+* skip accessibility idle checks for WebKit services ([#1293](https://github.com/appium/WebDriverAgent/issues/1293)) ([9d06611](https://github.com/appium/WebDriverAgent/commit/9d06611d1f5d342fd16458f707dca3f3e3ec00fc))
+
 ## [16.14.0](https://github.com/appium/WebDriverAgent/compare/v16.13.6...v16.14.0) (2026-10-04)
 
 ### Features

package/WebDriverAgentLib/Categories/XCAXClient_iOS+FBSnapshotReqParams.m

@@ -109,6 +109,14 @@ static id swizzledRequestSnapshotForElement(id self, SEL _cmd, id element, id at
     return original_requestSnapshotForElement(self, _cmd, element, attributes, parameters, error);
   }
 
+  // Remote WKWebView elements belong to a WebKit service, not the host app.
+  // Sending the idle-check AX action to WebContent can crash it (#1290).
+  // Read process metadata only: resolving UI attributes here can reenter
+  // snapshotting. Leave these services on the original snapshot path.
+  if ([application.bundleID hasPrefix:@"com.apple.WebKit."]) {
+    return original_requestSnapshotForElement(self, _cmd, element, attributes, parameters, error);
+  }
+
   NSNumber *pidKey = @(pid);
   @synchronized (unresponsiveApplicationPidsLock) {
     NSDate *markedUnresponsiveAt = unresponsiveApplicationPids[pidKey];

package/WebDriverAgentLib/Commands/FBCustomCommands.m

@@ -34,6 +34,7 @@
 #import "XCUIElement.h"
 #import "XCUIElement+FBIsVisible.h"
 #import "XCUIElementQuery.h"
+#import "XCUIScreen.h"
 #import "FBUnattachedAppLauncher.h"
 
 @implementation FBCustomCommands
@@ -162,17 +163,41 @@
 
 + (id<FBResponsePayload>)handleGetScreen:(FBRouteRequest *)request
 {
+  NSError *error = nil;
+  XCUIScreen *screen = [FBScreen currentScreenWithError:&error];
+  if (nil == screen) {
+    return FBResponseWithStatus([FBCommandStatus invalidArgumentErrorWithMessage:error.localizedDescription
+                                                                     traceback:nil]);
+  }
   XCUIApplication *app = XCUIApplication.fb_systemApplication;
-
-  XCUIElement *mainStatusBar = app.statusBars.allElementsBoundByIndex.firstObject;
-  CGSize statusBarSize = (nil == mainStatusBar) ? CGSizeZero : mainStatusBar.frame.size;
-
-#if TARGET_OS_TV || TARGET_OS_WATCH
-  CGSize screenSize = app.frame.size;
-#else
-  CGSize screenSize = FBAdjustDimensionsForApplication(app.wdFrame.size, app.interfaceOrientation);
+  CGSize screenSize = CGSizeMake(CGRectGetWidth(screen.bounds) / screen.scale,
+                                 CGRectGetHeight(screen.bounds) / screen.scale);
+#if !TARGET_OS_TV && !TARGET_OS_WATCH
+  XCUIApplication *activeApp = request.session ? request.session.activeApplication : XCUIApplication.fb_activeApplication;
+  screenSize = FBAdjustDimensionsForApplication(screenSize, activeApp.interfaceOrientation);
 #endif
 
+  // SpringBoard can expose hidden status bars belonging to other displays, and
+  // Duo also exposes full-screen containers for its side-mounted status UI.
+  // Only a visible horizontal bar at the top of this display can be subtracted
+  // from a rectangular viewport.
+  CGSize statusBarSize = CGSizeZero;
+  for (XCUIElement *statusBar in app.statusBars.allElementsBoundByIndex) {
+    // Resolve the element before reading its screen: displayID can be zero on
+    // an unresolved query result even when the bar belongs to the main screen.
+    CGRect frame = statusBar.frame;
+    if (statusBar.screen.displayID != screen.displayID || !statusBar.fb_isVisible) {
+      continue;
+    }
+    if (fabs(CGRectGetMinY(frame)) <= 1 && fabs(CGRectGetMinX(frame)) <= 1
+        && fabs(CGRectGetWidth(frame) - screenSize.width) <= 1
+        && CGRectGetHeight(frame) > 0 && CGRectGetHeight(frame) < screenSize.height
+        && CGRectGetHeight(frame) < CGRectGetWidth(frame)) {
+      statusBarSize = frame.size;
+      break;
+    }
+  }
+
   return FBResponseWithObject(
                               @{
     @"screenSize":@{@"width": @(screenSize.width),
@@ -181,8 +206,8 @@
     @"statusBarSize": @{@"width": @(statusBarSize.width),
                         @"height": @(statusBarSize.height),
     },
-    @"displayId": @([FBScreen displayID]),
-    @"scale": @([FBScreen scale]),
+    @"displayId": @(screen.displayID),
+    @"scale": @(screen.scale),
   });
 }
 

package/WebDriverAgentLib/Info.plist

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

package/WebDriverAgentTests/IntegrationApp/Classes/ViewController.m

@@ -9,6 +9,10 @@
 #import "ViewController.h"
 #import "FBCoordinateProbeViewController.h"
 
+#if !TARGET_OS_TV
+#import <WebKit/WebKit.h>
+#endif
+
 @interface ViewController ()
 @property (weak, nonatomic) IBOutlet UILabel *orentationLabel;
 @property (weak, nonatomic) IBOutlet UIButton *button;
@@ -19,6 +23,17 @@
 - (void)viewDidLoad
 {
   [super viewDidLoad];
+
+#if !TARGET_OS_TV
+  if ([NSProcessInfo.processInfo.arguments containsObject:@"--webview-fixture"]) {
+    WKWebView *webView = [[WKWebView alloc] initWithFrame:self.view.bounds];
+    webView.autoresizingMask = UIViewAutoresizingFlexibleWidth
+      | UIViewAutoresizingFlexibleHeight;
+    [self.view addSubview:webView];
+    [webView loadHTMLString:@"<!doctype html><html><body>"
+      "<p>WebContent snapshot fixture</p></body></html>" baseURL:nil];
+  }
+#endif
   
   UIAccessibilityCustomAction *action1 =
   [[UIAccessibilityCustomAction alloc] initWithName:@"Custom Action 1"

package/WebDriverAgentTests/IntegrationTests/FBConfigurationTests.m

@@ -12,6 +12,9 @@
 #import "FBConfiguration.h"
 #import "FBRuntimeUtils.h"
 #import "FBTestMacros.h"
+#import "FBXCAccessibilityElement.h"
+#import "FBXCAXClientProxy.h"
+#import "XCUIApplication.h"
 #import "XCUIElement.h"
 #import "XCUIElement+FBIsVisible.h"
 
@@ -68,4 +71,53 @@
   }
 }
 
+- (void)testAccessibilityDeadlineAllowsResponsiveNativeAppSnapshots
+{
+  [self launchApplication];
+  NSTimeInterval previousDeadline = FBConfiguration.sharedInstance.accessibilityDeadline;
+  @try {
+    FBConfiguration.sharedInstance.accessibilityDeadline = 3;
+    NSError *error = nil;
+    XCTAssertNotNil([self.testedApplication snapshotWithError:&error]);
+    XCTAssertNil(error);
+  } @finally {
+    FBConfiguration.sharedInstance.accessibilityDeadline = previousDeadline;
+    [self.testedApplication terminate];
+  }
+}
+
+- (void)testAccessibilityDeadlineAllowsWebContentSnapshots
+{
+  NSTimeInterval previousDeadline = FBConfiguration.sharedInstance.accessibilityDeadline;
+  @try {
+    // Resolve the remote AX element before enabling the guard so the test
+    // exercises a WebContent-owned snapshot, not just the host app's tree.
+    FBConfiguration.sharedInstance.accessibilityDeadline = 0;
+    self.testedApplication.launchArguments = @[@"--webview-fixture"];
+    [self.testedApplication launch];
+    XCUIElement *text = self.testedApplication.webViews.staticTexts[
+      @"WebContent snapshot fixture"];
+    XCTAssertTrue([text waitForExistenceWithTimeout:15]);
+    NSError *error = nil;
+    id<FBXCElementSnapshot> initial = [text snapshotWithError:&error];
+    XCTAssertNotNil(initial);
+    XCTAssertNil(error);
+    id<FBXCAccessibilityElement> element = initial.accessibilityElement;
+    XCTAssertNotEqual(element.processIdentifier, self.testedApplication.processID);
+
+    FBConfiguration.sharedInstance.accessibilityDeadline = 3;
+    for (NSUInteger i = 0; i < 3; i++) {
+      error = nil;
+      id<FBXCElementSnapshot> snapshot = [FBXCAXClientProxy.sharedClient
+        snapshotForElement:element attributes:@[] inDepth:YES error:&error];
+      XCTAssertNotNil(snapshot);
+      XCTAssertNil(error);
+    }
+    XCTAssertTrue(text.exists);
+  } @finally {
+    FBConfiguration.sharedInstance.accessibilityDeadline = previousDeadline;
+    [self.testedApplication terminate];
+  }
+}
+
 @end

package/WebDriverAgentTests/IntegrationTests/FBScreenTests.m

@@ -11,11 +11,23 @@
 #import "FBIntegrationTestCase.h"
 #import "FBConfiguration.h"
 #import "FBScreen.h"
+#import "FBRunLoopSpinner.h"
+#import "XCUIDevice+FBRotation.h"
+#import "XCUIDevice+FBHinge.h"
+#import "XCUIElement.h"
 #import "FBActiveAppDetectionPoint.h"
 #import "FBExceptions.h"
 #import "FBScreenRecordingRequest.h"
 #import "FBScreenshot.h"
 #import "XCUIScreen.h"
+#import "FBCustomCommands.h"
+#import "FBRouteRequest.h"
+#import "FBResponsePayload.h"
+#import "RouteResponse.h"
+
+@interface FBCustomCommands (FBScreenInfoTesting)
++ (id<FBResponsePayload>)handleGetScreen:(FBRouteRequest *)request;
+@end
 
 @interface FBScreen (FBLookupTesting)
 + (nullable XCUIScreen *)screenWithDisplayID:(long long)displayID device:(id)device error:(NSError **)error;
@@ -299,4 +311,134 @@
   XCTAssertTrue([FBScreen scale] >= 2);
 }
 
+- (NSDictionary *)screenInfoResponse
+{
+  FBRouteRequest *request = [FBRouteRequest routeRequestWithURL:[NSURL URLWithString:@"http://localhost:8100/wda/screen"]
+                                                  parameters:@{}
+                                                   arguments:@{}];
+  RouteResponse *response = [RouteResponse new];
+  [[FBCustomCommands handleGetScreen:request] dispatchWithResponse:response];
+  return [NSJSONSerialization JSONObjectWithData:response.responseData options:0 error:nil][@"value"];
+}
+
+- (void)testScreenInfoFollowsDisplaySelection
+{
+  for (NSDictionary *screen in [FBScreen screensWithError:nil]) {
+    FBConfiguration.sharedInstance.currentDisplayId = screen[@"displayId"];
+    NSDictionary *info = [self screenInfoResponse];
+    XCTAssertNil(info[@"error"]);
+    XCTAssertEqualObjects(info[@"displayId"], screen[@"displayId"]);
+    XCTAssertEqualObjects(info[@"scale"], screen[@"scale"]);
+    double width = [info[@"screenSize"][@"width"] doubleValue];
+    double height = [info[@"screenSize"][@"height"] doubleValue];
+    double scale = [screen[@"scale"] doubleValue];
+    double expectedWidth = [screen[@"bounds"][@"width"] doubleValue] / scale;
+    double expectedHeight = [screen[@"bounds"][@"height"] doubleValue] / scale;
+    XCTAssertEqualWithAccuracy(MIN(width, height), MIN(expectedWidth, expectedHeight), 0.01);
+    XCTAssertEqualWithAccuracy(MAX(width, height), MAX(expectedWidth, expectedHeight), 0.01);
+    double barHeight = [info[@"statusBarSize"][@"height"] doubleValue];
+    XCTAssertGreaterThanOrEqual(barHeight, 0);
+    XCTAssertLessThan(barHeight, height);
+    if (barHeight > 0) {
+      XCTAssertEqualWithAccuracy([info[@"statusBarSize"][@"width"] doubleValue], width, 1);
+    }
+  }
+  // tearDown restores the default display even when an assertion fails.
+}
+
+- (void)testScreenInfoFollowsDisplayReset
+{
+  // Exercise reset independently of the display-selection assertions.
+  FBConfiguration.sharedInstance.currentDisplayId = @([self unknownDisplayID]);
+  FBConfiguration.sharedInstance.currentDisplayId = nil;
+  XCTAssertEqualObjects([self screenInfoResponse][@"displayId"], @([FBScreen displayID]));
+}
+
+- (void)testScreenInfoRejectsUnavailableDisplay
+{
+  FBConfiguration.sharedInstance.currentDisplayId = @([self unknownDisplayID]);
+  NSDictionary *info = [self screenInfoResponse];
+  XCTAssertEqualObjects(info[@"error"], @"invalid argument");
+  XCTAssertTrue([info[@"message"] containsString:@"Available display ids"]);
+}
+
+- (void)testScreenInfoInBothLandscapeOrientations
+{
+  XCTSkipIf(XCUIDevice.sharedDevice.fb_canAttemptSimulatedHingeAngleInjection,
+            @"Foldable orientations are covered by testScreenInfoAcrossFoldStates");
+  XCUIElement *window = self.testedApplication.windows.firstMatch;
+  (void)window.frame;
+  XCTSkipIf(window.screen.displayID != XCUIScreen.mainScreen.displayID,
+            @"Requires the fixture on the main display");
+  [self addTeardownBlock:^{
+    [[XCUIDevice sharedDevice] fb_setDeviceInterfaceOrientation:UIDeviceOrientationPortrait];
+  }];
+  BOOL expectsVisibleBar = UIDevice.currentDevice.userInterfaceIdiom == UIUserInterfaceIdiomPad;
+  for (NSNumber *orientation in @[@(UIDeviceOrientationLandscapeLeft), @(UIDeviceOrientationLandscapeRight)]) {
+    XCTAssertTrue([[XCUIDevice sharedDevice] fb_setDeviceInterfaceOrientation:orientation.integerValue]);
+    __block NSDictionary *info = nil;
+    // iPad keeps its top status bar in landscape. Wait for rotation to finish
+    // rather than accepting a transient zero crop as a successful result.
+    XCTAssertTrue([[[FBRunLoopSpinner new] timeout:5] spinUntilTrue:^BOOL {
+      info = [self screenInfoResponse];
+      double width = [info[@"screenSize"][@"width"] doubleValue];
+      double height = [info[@"screenSize"][@"height"] doubleValue];
+      double barWidth = [info[@"statusBarSize"][@"width"] doubleValue];
+      double barHeight = [info[@"statusBarSize"][@"height"] doubleValue];
+      if (nil != info[@"error"] || width <= height || height <= 0) {
+        return NO;
+      }
+      if (barHeight == 0) {
+        return !expectsVisibleBar && barWidth == 0;
+      }
+      return barHeight > 0 && barHeight < height && fabs(barWidth - width) <= 1;
+    }], @"Unexpected landscape screen metadata: %@", info);
+  }
+}
+
+- (void)testScreenInfoAcrossFoldStates
+{
+  XCUIDevice *device = XCUIDevice.sharedDevice;
+  XCTSkipIf(!device.fb_canAttemptSimulatedHingeAngleInjection, @"Requires a foldable simulator");
+  NSError *error = nil;
+  NSNumber *originalAngle = [device fb_getSimulatedHingeAngle:&error];
+  XCTAssertNotNil(originalAngle, @"%@", error);
+  [self addTeardownBlock:^{
+    if (nil != originalAngle) {
+      [device fb_setSimulatedHingeAngle:originalAngle.doubleValue error:nil];
+    }
+  }];
+  for (NSNumber *angle in @[@0, @90, @180, @0]) {
+    [self.testedApplication terminate];
+    XCTAssertTrue([device fb_setSimulatedHingeAngle:angle.doubleValue error:&error], @"%@", error);
+    [self launchApplication];
+    XCUIElement *window = self.testedApplication.windows.firstMatch;
+    CGRect frame = window.frame;
+    FBConfiguration.sharedInstance.currentDisplayId = @(window.screen.displayID);
+    __block NSDictionary *info = nil;
+    XCTAssertTrue([[[FBRunLoopSpinner new] timeout:5] spinUntilTrue:^BOOL {
+      info = [self screenInfoResponse];
+      double width = [info[@"screenSize"][@"width"] doubleValue];
+      double height = [info[@"screenSize"][@"height"] doubleValue];
+      double barHeight = [info[@"statusBarSize"][@"height"] doubleValue];
+      return nil == info[@"error"] && fabs(width - frame.size.width) <= 1
+        && fabs(height - frame.size.height) <= 1
+        && barHeight >= 0 && barHeight < height
+        && (barHeight == 0 || fabs([info[@"statusBarSize"][@"width"] doubleValue] - width) <= 1)
+        && (angle.doubleValue == 0 || barHeight == 0);
+    }], @"Unexpected screen metadata at hinge angle %@: %@", angle, info);
+  }
+}
+
+- (void)testScreenInfoIncludesTopStatusBarOnSingleDisplay
+{
+  XCTSkipIf([FBScreen screensWithError:nil].count != 1, @"Requires a single-display device");
+  // The integration fixture uses the ordinary visible portrait status bar.
+  // An unresolved XCUIElement has displayID == 0; it must not be filtered out.
+  NSDictionary *info = [self screenInfoResponse];
+  XCTAssertGreaterThan([info[@"statusBarSize"][@"height"] doubleValue], 0);
+  XCTAssertEqualWithAccuracy([info[@"statusBarSize"][@"width"] doubleValue],
+                            [info[@"screenSize"][@"width"] doubleValue], 1);
+}
+
 @end

package/package.json

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