@devicelab/maestro-runner-darwin-arm64 1.1.29 → 1.1.30

package/drivers/ios/WebDriverAgent/WebDriverAgentLib/Categories/XCUIElement+FBFind.m

@@ -120,14 +120,27 @@
 - (NSArray<XCUIElement *> *)fb_descendantsMatchingIdentifier:(NSString *)accessibilityId
                                  shouldReturnAfterFirstMatch:(BOOL)shouldReturnAfterFirstMatch
 {
-  NSPredicate *predicate = [NSPredicate predicateWithBlock:^BOOL(id<FBXCElementSnapshot> snapshot,
-                                                                 NSDictionary<NSString *,id> * _Nullable bindings) {
-    @autoreleasepool {
-      return [[FBXCElementSnapshotWrapper wdNameWithSnapshot:snapshot] isEqualToString:accessibilityId];
+  // Standard snapshot attributes let XCTest evaluate a structured predicate
+  // without WDA's per-snapshot block callback, while preserving wdName semantics.
+  // Local benchmarks showed lower end-to-end lookup latency; see measurements
+  // and regression checks in https://github.com/appium/WebDriverAgent/pull/1286.
+  NSPredicate *predicate = [NSPredicate predicateWithFormat:
+    @"(identifier != nil AND identifier != '' AND identifier == %@) OR "
+     "((identifier == nil OR identifier == '') AND label != nil AND label != '' AND label == %@)",
+    accessibilityId, accessibilityId];
+  XCUIElementQuery *query = [[self.fb_query descendantsMatchingType:XCUIElementTypeAny]
+    matchingPredicate:predicate];
+  NSMutableArray<XCUIElement *> *result = [NSMutableArray arrayWithArray:
+    [self.class fb_extractMatchingElementsFromQuery:query
+                       shouldReturnAfterFirstMatch:shouldReturnAfterFirstMatch]];
+  id<FBXCElementSnapshot> cachedSnapshot = [self fb_cachedSnapshotWithQuery:query];
+  if ([predicate evaluateWithObject:cachedSnapshot]) {
+    if (shouldReturnAfterFirstMatch || result.count == 0) {
+      return @[self];
     }
-  }];
-  return [self fb_descendantsMatchingPredicate:predicate
-                   shouldReturnAfterFirstMatch:shouldReturnAfterFirstMatch];
+    [result insertObject:self atIndex:0];
+  }
+  return result.copy;
 }
 
 @end

package/drivers/ios/WebDriverAgent/WebDriverAgentLib/Categories/XCUIElement+FBScrolling.m

@@ -9,7 +9,9 @@
 #import "XCUIElement+FBScrolling.h"
 
 #import "FBErrorBuilder.h"
+#import "FBExceptions.h"
 #import "FBLogger.h"
+#import "FBScreen.h"
 #import "FBMacros.h"
 #import "FBMathUtils.h"
 #import "FBXCodeCompatibility.h"
@@ -20,6 +22,7 @@
 #import "XCUIElement+FBUID.h"
 #import "XCUIApplication.h"
 #import "XCUICoordinate.h"
+#import "XCUIScreen.h"
 #import "XCUIElement+FBIsVisible.h"
 #import "XCUIElement+FBVisibleFrame.h"
 #import "XCUIElement.h"
@@ -35,14 +38,40 @@ const CGFloat FBScrollTouchProportion = 0.75f;
 
 #if !TARGET_OS_TV
 
+static void FBValidateScreenForScrolling(void)
+{
+  NSError *error = nil;
+  XCUIScreen *screen = [FBScreen currentScreenWithError:&error];
+  if (nil == screen) {
+    // Match active-app detection: never continue on a different coordinate space
+    // when the selected display is unavailable, including for void scroll APIs.
+    @throw [NSException exceptionWithName:FBInvalidArgumentException
+                                  reason:error.localizedDescription
+                                userInfo:nil];
+  }
+}
+
+static CGRect FBScrollFrameInApplication(CGRect frame, XCUIScreen *screen,
+                                        XCUIApplication *application)
+{
+#if !TARGET_OS_WATCH
+  // XCTest's visibleFrame is in portrait screen coordinates on both main and
+  // secondary displays. The live anchor's frame uses the app's orientation.
+  CGSize size = CGSizeMake(CGRectGetWidth(screen.bounds) / screen.scale,
+                           CGRectGetHeight(screen.bounds) / screen.scale);
+  frame = FBRectFromPortraitCoordinates(frame, size, application.interfaceOrientation);
+#endif
+  return frame;
+}
+
 @interface FBXCElementSnapshotWrapper (FBScrolling)
 
 - (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;
+- (BOOL)fb_scrollByNormalizedVector:(CGVector)normalizedScrollVector anchorElement:(XCUIElement *)anchorElement error:(NSError **)error;
+- (BOOL)fb_scrollByVector:(CGVector)vector inFrame:(CGRect)frame anchorElement:(XCUIElement *)anchorElement velocity:(CGFloat)velocity error:(NSError **)error;
 
 @end
 
@@ -126,6 +155,9 @@ static XCUIElement *FBLiveElementForSnapshot(id<FBXCElementSnapshot> snapshot, X
                                        scrollDirection:(FBXCUIElementScrollDirection)scrollDirection
                                                  error:(NSError **)error
 {
+  if (nil == [FBScreen currentScreenWithError:error]) {
+    return NO;
+  }
   FBXCElementSnapshotWrapper *prescrollSnapshot = [FBXCElementSnapshotWrapper ensureWrapped:[self fb_customSnapshot]];
 
   if (prescrollSnapshot.isWDVisible) {
@@ -202,7 +234,7 @@ static XCUIElement *FBLiveElementForSnapshot(id<FBXCElementSnapshot> snapshot, X
 
   // 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).
+  // change across scroll steps (keyboard or dynamic layout).
   XCUIElement *scrollViewElement = FBLiveElementForSnapshot(scrollView, self.application);
   if (nil == scrollViewElement) {
     return
@@ -217,34 +249,27 @@ static XCUIElement *FBLiveElementForSnapshot(id<FBXCElementSnapshot> snapshot, X
   // Scrolling till cell is visible and get current value of frames
   while (![self fb_isEquivalentElementSnapshotVisible:prescrollSnapshot] && scrollCount < maxScrollCount) {
     BOOL didScroll;
+    __strong NSError *scrollError = nil;
     @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) {
-        didScroll = scrollDirection == FBXCUIElementScrollDirectionVertical ?
-          [scrollViewWrapped fb_scrollUpByNormalizedDistance:normalizedScrollDistance
-                                                anchorElement:scrollViewElement] :
-          [scrollViewWrapped fb_scrollLeftByNormalizedDistance:normalizedScrollDistance
-                                                  anchorElement:scrollViewElement];
-      }
-      else {
-        didScroll = scrollDirection == FBXCUIElementScrollDirectionVertical ?
-          [scrollViewWrapped fb_scrollDownByNormalizedDistance:normalizedScrollDistance
-                                                  anchorElement:scrollViewElement] :
-          [scrollViewWrapped fb_scrollRightByNormalizedDistance:normalizedScrollDistance
-                                                   anchorElement:scrollViewElement];
-      }
+      CGFloat distance = targetCellIndex < visibleCellIndex ? normalizedScrollDistance : -normalizedScrollDistance;
+      CGVector vector = scrollDirection == FBXCUIElementScrollDirectionVertical
+        ? CGVectorMake(0, distance) : CGVectorMake(distance, 0);
+      NSError *stepError = nil;
+      didScroll = [scrollViewWrapped fb_scrollByNormalizedVector:vector
+                                                   anchorElement:scrollViewElement
+                                                           error:&stepError];
+      scrollError = stepError;
       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 (error) {
+        *error = scrollError;
+      }
+      return NO;
     }
   }
 
@@ -260,14 +285,39 @@ static XCUIElement *FBLiveElementForSnapshot(id<FBXCElementSnapshot> snapshot, X
   // Trying fb_cachedSnapshot first
   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
-                                       );
+  XCUIScreen *screen = [FBScreen currentScreenWithError:error];
+  if (nil == screen) {
+    return NO;
+  }
+  CGRect visibleFrame = FBScrollFrameInApplication(
+    [FBXCElementSnapshotWrapper ensureWrapped:targetCellSnapshot].fb_visibleFrame, screen, self.application);
+
+  CGRect targetFrame = targetCellSnapshot.frame;
+  // A cell can be clipped at the leading edge after a drag. Move back toward
+  // that edge instead of always scrolling down/right and hiding it further.
+  CGVector scrollVector = CGVectorMake(
+    CGRectGetMinX(visibleFrame) > CGRectGetMinX(targetFrame)
+      ? CGRectGetMinX(visibleFrame) - CGRectGetMinX(targetFrame)
+      : CGRectGetMaxX(visibleFrame) - CGRectGetMaxX(targetFrame),
+    CGRectGetMinY(visibleFrame) > CGRectGetMinY(targetFrame)
+      ? CGRectGetMinY(visibleFrame) - CGRectGetMinY(targetFrame)
+      : CGRectGetMaxY(visibleFrame) - CGRectGetMaxY(targetFrame));
+  // UIKit consumes the start of a drag before recognizing a pan. Include that
+  // margin so a small clipped edge is actually moved into view.
+  if (fabs(scrollVector.dx) > 1) {
+    scrollVector.dx += copysign(FBFuzzyPointThreshold, scrollVector.dx);
+  }
+  if (fabs(scrollVector.dy) > 1) {
+    scrollVector.dy += copysign(FBFuzzyPointThreshold, scrollVector.dy);
+  }
+  // Short fast corrections can turn into a flick and overshoot the target.
+  CGFloat velocity = MIN(FBTouchVelocity, MAX(fabs(scrollVector.dx), fabs(scrollVector.dy)) / FBTouchEventDelay);
   scrollViewWrapped = [FBXCElementSnapshotWrapper ensureWrapped:[scrollViewElement fb_customSnapshot]];
+  CGRect scrollingFrame = FBScrollFrameInApplication(scrollViewWrapped.visibleFrame, screen, self.application);
   return [scrollViewWrapped fb_scrollByVector:scrollVector
+                                       inFrame:scrollingFrame
                                 anchorElement:scrollViewElement
+                                     velocity:velocity
                                         error:error];
 }
 
@@ -296,64 +346,73 @@ static XCUIElement *FBLiveElementForSnapshot(id<FBXCElementSnapshot> snapshot, X
 
 @implementation FBXCElementSnapshotWrapper (FBScrolling)
 
-- (CGRect)scrollingFrame
-{
-  return self.visibleFrame;
-}
-
 - (BOOL)fb_scrollUpByNormalizedDistance:(CGFloat)distance
                            anchorElement:(XCUIElement *)anchorElement
 {
-  return [self fb_scrollByNormalizedVector:CGVectorMake(0.0, distance) anchorElement:anchorElement];
+  FBValidateScreenForScrolling();
+  return [self fb_scrollByNormalizedVector:CGVectorMake(0.0, distance) anchorElement:anchorElement error:nil];
 }
 
 - (BOOL)fb_scrollDownByNormalizedDistance:(CGFloat)distance
                              anchorElement:(XCUIElement *)anchorElement
 {
-  return [self fb_scrollByNormalizedVector:CGVectorMake(0.0, -distance) anchorElement:anchorElement];
+  FBValidateScreenForScrolling();
+  return [self fb_scrollByNormalizedVector:CGVectorMake(0.0, -distance) anchorElement:anchorElement error:nil];
 }
 
 - (BOOL)fb_scrollLeftByNormalizedDistance:(CGFloat)distance
                              anchorElement:(XCUIElement *)anchorElement
 {
-  return [self fb_scrollByNormalizedVector:CGVectorMake(distance, 0.0) anchorElement:anchorElement];
+  FBValidateScreenForScrolling();
+  return [self fb_scrollByNormalizedVector:CGVectorMake(distance, 0.0) anchorElement:anchorElement error:nil];
 }
 
 - (BOOL)fb_scrollRightByNormalizedDistance:(CGFloat)distance
                               anchorElement:(XCUIElement *)anchorElement
 {
-  return [self fb_scrollByNormalizedVector:CGVectorMake(-distance, 0.0) anchorElement:anchorElement];
+  FBValidateScreenForScrolling();
+  return [self fb_scrollByNormalizedVector:CGVectorMake(-distance, 0.0) anchorElement:anchorElement error:nil];
 }
 
 - (BOOL)fb_scrollByNormalizedVector:(CGVector)normalizedScrollVector
                        anchorElement:(XCUIElement *)anchorElement
+                               error:(NSError **)error
 {
-  CGVector scrollVector = CGVectorMake(CGRectGetWidth(self.scrollingFrame) * normalizedScrollVector.dx,
-                                       CGRectGetHeight(self.scrollingFrame) * normalizedScrollVector.dy
+  XCUIScreen *screen = [FBScreen currentScreenWithError:error];
+  if (nil == screen) {
+    return NO;
+  }
+  CGRect frame = FBScrollFrameInApplication(self.visibleFrame, screen, anchorElement.application);
+  CGVector scrollVector = CGVectorMake(CGRectGetWidth(frame) * normalizedScrollVector.dx,
+                                       CGRectGetHeight(frame) * normalizedScrollVector.dy
                                        );
-  return [self fb_scrollByVector:scrollVector anchorElement:anchorElement error:nil];
+  return [self fb_scrollByVector:scrollVector inFrame:frame anchorElement:anchorElement velocity:FBTouchVelocity error:error];
 }
 
 - (BOOL)fb_scrollByVector:(CGVector)vector
+                     inFrame:(CGRect)frame
              anchorElement:(XCUIElement *)anchorElement
+                  velocity:(CGFloat)velocity
                      error:(NSError **)error
 {
-  CGVector scrollBoundingVector = CGVectorMake(
-                                               CGRectGetWidth(self.scrollingFrame) * FBScrollTouchProportion,
-                                               CGRectGetHeight(self.scrollingFrame) * FBScrollTouchProportion
-                                               );
-  scrollBoundingVector.dx = (CGFloat)floor(copysign(scrollBoundingVector.dx, vector.dx));
-  scrollBoundingVector.dy = (CGFloat)floor(copysign(scrollBoundingVector.dy, vector.dy));
-
+  // Keep the vector and clipped frame in the same coordinate space throughout
+  // this multi-drag gesture. Rotation or folding during a gesture is unsupported.
   NSInteger preciseScrollAttemptsCount = 20;
   CGVector CGZeroVector = CGVectorMake(0, 0);
   BOOL shouldFinishScrolling = NO;
   while (!shouldFinishScrolling) {
+    CGVector scrollBoundingVector = CGVectorMake(
+      (CGFloat)floor(copysign(CGRectGetWidth(frame) * FBScrollTouchProportion, vector.dx)),
+      (CGFloat)floor(copysign(CGRectGetHeight(frame) * FBScrollTouchProportion, vector.dy)));
     CGVector scrollVector = CGVectorMake(fabs(vector.dx) > fabs(scrollBoundingVector.dx) ? scrollBoundingVector.dx : vector.dx,
                                          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 anchorElement:anchorElement error:error]){
+    if (![self fb_scrollAncestorScrollViewByVectorWithinScrollViewFrame:scrollVector
+                                                               inFrame:frame
+                                                         anchorElement:anchorElement
+                                                              velocity:velocity
+                                                                 error:error]) {
       return NO;
     }
   }
@@ -370,10 +429,11 @@ static XCUIElement *FBLiveElementForSnapshot(id<FBXCElementSnapshot> snapshot, X
 }
 
 - (BOOL)fb_scrollAncestorScrollViewByVectorWithinScrollViewFrame:(CGVector)vector
+                                                               inFrame:(CGRect)scrollingFrame
                                                      anchorElement:(XCUIElement *)anchorElement
+                                                          velocity:(CGFloat)velocity
                                                              error:(NSError **)error
 {
-  CGRect scrollingFrame = self.scrollingFrame;
   // wdFrame matches scrollingFrame's coordinate space; raw .frame can be pre-scaled or
   // dimension-swapped and drift out of sync with it (appium/appium#16185).
   CGRect anchorFrame = anchorElement.wdFrame;
@@ -395,7 +455,7 @@ static XCUIElement *FBLiveElementForSnapshot(id<FBXCElementSnapshot> snapshot, X
 
   [startCoordinate pressForDuration:FBTouchEventDelay
                thenDragToCoordinate:endCoordinate
-                       withVelocity:FBTouchVelocity
+                       withVelocity:velocity
                 thenHoldForDuration:FBTouchEventDelay];
   return YES;
 }

package/drivers/ios/WebDriverAgent/WebDriverAgentLib/Categories/XCUIElement+FBTyping.h

@@ -21,6 +21,13 @@ NS_ASSUME_NONNULL_BEGIN
  */
 BOOL FBTypeText(NSString *text, NSUInteger typingSpeed, NSError **error);
 
+#if TARGET_OS_IOS
+/**
+ Waits up to `timeout` seconds for a hittable key. A miss does not fail the caller.
+ */
+void FBWaitForHittableKey(XCUIApplication * _Nullable application, NSTimeInterval timeout);
+#endif
+
 @interface XCUIElement (FBTyping)
 
 /**

package/drivers/ios/WebDriverAgent/WebDriverAgentLib/Categories/XCUIElement+FBTyping.m

@@ -10,6 +10,7 @@
 
 #import "FBConfiguration.h"
 #import "FBErrorBuilder.h"
+#import "FBKeyboard.h"
 #import "FBXCElementSnapshotWrapper.h"
 #import "FBXCElementSnapshotWrapper+Helpers.h"
 #import "FBXCodeCompatibility.h"
@@ -39,6 +40,19 @@ BOOL FBTypeText(NSString *text, NSUInteger typingSpeed, NSError **error)
   return [FBXCTestDaemonsProxy synthesizeEventWithRecord:eventRecord error:error];
 }
 
+#if TARGET_OS_IOS
+void FBWaitForHittableKey(XCUIApplication *application, NSTimeInterval timeout)
+{
+  if (nil == application) {
+    return;
+  }
+  NSError *visibilityError = nil;
+  [FBKeyboard waitUntilVisibleForApplication:application
+                                    timeout:timeout
+                                      error:&visibilityError];
+}
+#endif
+
 @interface NSString (FBRepeat)
 
 - (NSString *)fb_repeatTimes:(NSUInteger)times;
@@ -139,6 +153,12 @@ BOOL FBTypeText(NSString *text, NSUInteger typingSpeed, NSError **error)
   // partial workaround (keystrokes still don't always land - a known limitation).
   [self typeText:text];
   return YES;
+#elif TARGET_OS_IOS
+  NSTimeInterval keyboardWait = FBConfiguration.sharedInstance.keyboardWaitTimeout;
+  if (keyboardWait > 0) {
+    FBWaitForHittableKey(self.application, keyboardWait);
+  }
+  return FBTypeText(text, frequency, error);
 #else
   return FBTypeText(text, frequency, error);
 #endif

package/drivers/ios/WebDriverAgent/WebDriverAgentLib/Categories/XCUIElement+FBUtilities.m

@@ -141,18 +141,21 @@
     return;
   }
 
-  NSTimeInterval previousTimeout = FBConfiguration.sharedInstance.waitForIdleTimeout;
-  BOOL previousQuiescence = self.application.fb_shouldWaitForQuiescence;
-  FBConfiguration.sharedInstance.waitForIdleTimeout = timeout;
-  if (!previousQuiescence) {
-    self.application.fb_shouldWaitForQuiescence = YES;
-  }
-  [[[self.application applicationImpl] currentProcess]
-   fb_waitForQuiescenceIncludingAnimationsIdle:YES];
-  if (previousQuiescence != self.application.fb_shouldWaitForQuiescence) {
-    self.application.fb_shouldWaitForQuiescence = previousQuiescence;
+  XCUIApplication *application = self.application;
+  // Recursive synchronization also covers nested stability checks on this thread.
+  @synchronized (FBConfiguration.sharedInstance) {
+    NSTimeInterval previousTimeout = FBConfiguration.sharedInstance.waitForIdleTimeout;
+    BOOL previousQuiescence = application.fb_shouldWaitForQuiescence;
+    @try {
+      FBConfiguration.sharedInstance.waitForIdleTimeout = timeout;
+      application.fb_shouldWaitForQuiescence = YES;
+      [[[application applicationImpl] currentProcess]
+        fb_waitForQuiescenceIncludingAnimationsIdle:YES];
+    } @finally {
+      application.fb_shouldWaitForQuiescence = previousQuiescence;
+      FBConfiguration.sharedInstance.waitForIdleTimeout = previousTimeout;
+    }
   }
-  FBConfiguration.sharedInstance.waitForIdleTimeout = previousTimeout;
 }
 
 - (void)fb_raiseStaleElementExceptionWithError:(NSError *)error __attribute__((noreturn))

package/drivers/ios/WebDriverAgent/WebDriverAgentLib/Commands/FBCustomCommands.m

@@ -29,10 +29,12 @@
 #import "XCUIApplication.h"
 #import "XCUIApplication+FBHelpers.h"
 #import "XCUIDevice+FBHelpers.h"
+#import "XCUIDevice+FBHinge.h"
 #import "XCUIDevice+FBVoiceOver.h"
 #import "XCUIElement.h"
 #import "XCUIElement+FBIsVisible.h"
 #import "XCUIElementQuery.h"
+#import "XCUIScreen.h"
 #import "FBUnattachedAppLauncher.h"
 
 @implementation FBCustomCommands
@@ -65,6 +67,8 @@
     [[FBRoute GET:@"/wda/batteryInfo"] respondWithTarget:self action:@selector(handleGetBatteryInfo:)],
 #endif
     [[FBRoute POST:@"/wda/pressButton"] respondWithTarget:self action:@selector(handlePressButtonCommand:)],
+    [[FBRoute GET:@"/wda/pressableButtons"] respondWithTarget:self action:@selector(handleGetPressableButtons:)],
+    [[FBRoute GET:@"/wda/pressableButtons"].withoutSession respondWithTarget:self action:@selector(handleGetPressableButtons:)],
 #if TARGET_OS_WATCH
     [[FBRoute POST:@"/wda/rotateDigitalCrown"] respondWithTarget:self action:@selector(handleRotateDigitalCrownCommand:)],
     [[FBRoute POST:@"/wda/performHandGesture"] respondWithTarget:self action:@selector(handlePerformHandGestureCommand:)],
@@ -74,6 +78,10 @@
     [[FBRoute POST:@"/wda/expectNotification"] respondWithTarget:self action:@selector(handleExpectNotification:)],
     [[FBRoute POST:@"/wda/siri/activate"] respondWithTarget:self action:@selector(handleActivateSiri:)],
     [[FBRoute POST:@"/wda/apps/launchUnattached"].withoutSession respondWithTarget:self action:@selector(handleLaunchUnattachedApp:)],
+    [[FBRoute GET:@"/wda/device/hingeAngle"] respondWithTarget:self action:@selector(handleGetSimulatedHingeAngle:)],
+    [[FBRoute GET:@"/wda/device/hingeAngle"].withoutSession respondWithTarget:self action:@selector(handleGetSimulatedHingeAngle:)],
+    [[FBRoute POST:@"/wda/device/hingeAngle"] respondWithTarget:self action:@selector(handleSetSimulatedHingeAngle:)],
+    [[FBRoute POST:@"/wda/device/hingeAngle"].withoutSession respondWithTarget:self action:@selector(handleSetSimulatedHingeAngle:)],
     [[FBRoute GET:@"/wda/device/info"] respondWithTarget:self action:@selector(handleGetDeviceInfo:)],
     [[FBRoute POST:@"/wda/resetAppAuth"] respondWithTarget:self action:@selector(handleResetAppAuth:)],
     [[FBRoute GET:@"/wda/device/info"].withoutSession respondWithTarget:self action:@selector(handleGetDeviceInfo:)],
@@ -157,17 +165,48 @@
 
 + (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;
+  UIInterfaceOrientation orientation = activeApp.interfaceOrientation;
+  // Screen bounds describe the panel's native orientation. Some physical iPads
+  // expose landscape-native bounds even while the application is in portrait.
+  // Normalize the full screen separately from compatibility-mode app frames.
+  if (UIInterfaceOrientationIsPortrait(orientation) && screenSize.width > screenSize.height) {
+    screenSize = CGSizeMake(screenSize.height, screenSize.width);
+  }
+  screenSize = FBAdjustDimensionsForApplication(screenSize, orientation);
 #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),
@@ -176,8 +215,8 @@
     @"statusBarSize": @{@"width": @(statusBarSize.width),
                         @"height": @(statusBarSize.height),
     },
-    @"displayId": @([FBScreen displayID]),
-    @"scale": @([FBScreen scale]),
+    @"displayId": @(screen.displayID),
+    @"scale": @(screen.scale),
   });
 }
 
@@ -315,6 +354,12 @@
   return FBResponseWithOK();
 }
 
++ (id<FBResponsePayload>)handleGetPressableButtons:(FBRouteRequest *)request
+{
+  NSArray *xctestButtonNames = [FBAvailableButtonNames().allKeys sortedArrayUsingSelector:@selector(compare:)];
+  return FBResponseWithObject(@{@"xctest": xctestButtonNames});
+}
+
 #if TARGET_OS_WATCH
 + (id<FBResponsePayload>)handleRotateDigitalCrownCommand:(FBRouteRequest *)request
 {
@@ -777,4 +822,35 @@
   return FBResponseWithObject(result);
 }
 
++ (id<FBResponsePayload>)handleGetSimulatedHingeAngle:(FBRouteRequest *)request
+{
+  if (!XCUIDevice.sharedDevice.fb_supportsHingeAngleReading) {
+    return FBResponseWithStatus([FBCommandStatus unsupportedOperationErrorWithMessage:
+      @"Hinge angle reading is unavailable on this device" traceback:nil]);
+  }
+  NSError *error;
+  NSNumber *angle = [XCUIDevice.sharedDevice fb_getSimulatedHingeAngle:&error];
+  return nil == angle ? FBResponseWithUnknownError(error) : FBResponseWithObject(angle);
+}
+
++ (id<FBResponsePayload>)handleSetSimulatedHingeAngle:(FBRouteRequest *)request
+{
+  id angle = request.arguments[@"angle"];
+  if (![angle isKindOfClass:NSNumber.class]
+      || CFGetTypeID((__bridge CFTypeRef)angle) == CFBooleanGetTypeID()
+      || !isfinite([angle doubleValue]) || [angle doubleValue] < 0 || [angle doubleValue] > 180) {
+    return FBResponseWithStatus([FBCommandStatus invalidArgumentErrorWithMessage:
+      @"'angle' must be a finite number between 0 and 180 degrees" traceback:nil]);
+  }
+  if (!XCUIDevice.sharedDevice.fb_canAttemptSimulatedHingeAngleInjection) {
+    return FBResponseWithStatus([FBCommandStatus unsupportedOperationErrorWithMessage:
+      @"Setting a simulated hinge angle requires a compatible foldable device" traceback:nil]);
+  }
+  NSError *error;
+  if (![XCUIDevice.sharedDevice fb_setSimulatedHingeAngle:[angle doubleValue] error:&error]) {
+    return FBResponseWithUnknownError(error);
+  }
+  return FBResponseWithOK();
+}
+
 @end