@devicelab/maestro-runner-darwin-arm64 1.1.25 → 1.1.28

package/drivers/ios/WebDriverAgent/WebDriverAgentLib/Utilities/FBPasteboard.m

@@ -11,6 +11,7 @@
 #import <mach/mach_time.h>
 #import "FBAlert.h"
 #import "FBErrorBuilder.h"
+#import "FBExceptions.h"
 #import "FBMacros.h"
 #import "XCUIApplication+FBHelpers.h"
 #import "XCUIApplication+FBAlert.h"
@@ -19,7 +20,7 @@
 // Must not be less than FB_MONTORING_INTERVAL in FBAlertsMonitor
 #define ALERT_CHECK_INTERVAL_SEC 2
 
-#if !TARGET_OS_TV
+#if !TARGET_OS_TV && !TARGET_OS_WATCH
 @implementation FBPasteboard
 
 + (BOOL)setData:(NSData *)data forType:(NSString *)type error:(NSError **)error
@@ -100,10 +101,13 @@
       break;
     }
 
-    XCUIElement *alertElement = XCUIApplication.fb_systemApplication.fb_alertElement;
-    if (nil != alertElement) {
-      FBAlert *alert = [FBAlert alertWithElement:alertElement];
-      [alert acceptWithError:nil];
+    @try {
+      [[FBAlert alertWithApplication:XCUIApplication.fb_systemApplication] accept];
+    } @catch (NSException *e) {
+      if (![e.name isEqualToString:FBAlertNotPresentException]) {
+        @throw e;
+      }
+      // No alert is present on this tick - expected on most iterations of this poll loop
     }
     uint64_t timeElapsed = clock_gettime_nsec_np(CLOCK_MONOTONIC_RAW) - timeStarted;
     if (timeElapsed / NSEC_PER_SEC > timeout) {

package/drivers/ios/WebDriverAgent/WebDriverAgentLib/Utilities/FBScreen.h

@@ -12,6 +12,16 @@ NS_ASSUME_NONNULL_BEGIN
 
 @interface FBScreen : NSObject
 
+/**
+ Information about all displays available to the device
+ */
++ (nullable NSArray<NSDictionary<NSString *, id> *> *)screensWithError:(NSError **)error;
+
+/**
+ The identifier of the main device's display
+ */
++ (long long)displayID;
+
 /**
  The scale factor of the main device's screen
  */

package/drivers/ios/WebDriverAgent/WebDriverAgentLib/Utilities/FBScreen.m

@@ -9,10 +9,42 @@
 #import "FBScreen.h"
 #import "XCUIElement+FBIsVisible.h"
 #import "FBXCodeCompatibility.h"
+#import "XCUIDevice.h"
 #import "XCUIScreen.h"
 
 @implementation FBScreen
 
++ (nullable NSArray<NSDictionary<NSString *, id> *> *)screensWithError:(NSError **)error
+{
+  NSArray<XCUIScreen *> *screens = [XCUIDevice.sharedDevice screensOrError:error];
+  if (nil == screens) {
+    return nil;
+  }
+
+  NSMutableArray<NSDictionary<NSString *, id> *> *result = [NSMutableArray arrayWithCapacity:screens.count];
+  for (XCUIScreen *screen in screens) {
+    CGRect bounds = screen.bounds;
+    [result addObject:@{
+      @"displayId": @(screen.displayID),
+      @"isMain": @(screen.isMainScreen),
+      @"scale": @(screen.scale),
+      @"bounds": @{
+        @"x": @(bounds.origin.x),
+        @"y": @(bounds.origin.y),
+        @"width": @(bounds.size.width),
+        @"height": @(bounds.size.height),
+      },
+      @"traits": @(screen.traits),
+    }];
+  }
+  return result.copy;
+}
+
++ (long long)displayID
+{
+  return XCUIScreen.mainScreen.displayID;
+}
+
 + (double)scale
 {
   return [XCUIScreen.mainScreen scale];

package/drivers/ios/WebDriverAgent/WebDriverAgentLib/Utilities/FBScreenshot.m

@@ -17,7 +17,7 @@
 #import "FBMacros.h"
 #import "FBXCodeCompatibility.h"
 #import "FBXCTestDaemonsProxy.h"
-#import "XCTestManager_ManagerInterface-Protocol.h"
+#import "XCTMessagingChannel_RunnerToDaemon-Protocol.h"
 #import "XCUIScreen.h"
 
 static const NSTimeInterval SCREENSHOT_TIMEOUT = 20.;
@@ -95,7 +95,7 @@ NSString *formatTimeInterval(NSTimeInterval interval) {
                                          timeout:(NSTimeInterval)timeout
                                            error:(NSError **)error
 {
-  id<XCTestManager_ManagerInterface> proxy = [FBXCTestDaemonsProxy testRunnerProxy];
+  id<XCTMessagingChannel_RunnerToDaemon> proxy = [FBXCTestDaemonsProxy testRunnerProxy];
   __block NSData *screenshotData = nil;
   __block NSError *innerError = nil;
   dispatch_semaphore_t sem = dispatch_semaphore_create(0);
@@ -126,7 +126,7 @@ NSString *formatTimeInterval(NSTimeInterval interval) {
         withDescription:timeoutMsg]
        buildError:error];
     }
-  };
+  }
   if (nil != error && nil != innerError) {
     *error = innerError;
   }

package/drivers/ios/WebDriverAgent/WebDriverAgentLib/Utilities/FBSettings.h

@@ -22,12 +22,13 @@ extern NSString* const FB_SETTING_SCREENSHOT_QUALITY;
 extern NSString* const FB_SETTING_KEYBOARD_AUTOCORRECTION;
 extern NSString* const FB_SETTING_KEYBOARD_PREDICTION;
 extern NSString* const FB_SETTING_SNAPSHOT_MAX_DEPTH;
+extern NSString* const FB_SETTING_SNAPSHOT_MAX_CHILDREN;
+extern NSString* const FB_SETTING_ACCESSIBILITY_DEADLINE;
 extern NSString* const FB_SETTING_USE_FIRST_MATCH;
 extern NSString* const FB_SETTING_BOUND_ELEMENTS_BY_INDEX;
 extern NSString* const FB_SETTING_REDUCE_MOTION;
 extern NSString* const FB_SETTING_DEFAULT_ACTIVE_APPLICATION;
 extern NSString* const FB_SETTING_ACTIVE_APP_DETECTION_POINT;
-extern NSString* const FB_SETTING_INCLUDE_NON_MODAL_ELEMENTS;
 extern NSString* const FB_SETTING_DEFAULT_ALERT_ACTION;
 extern NSString* const FB_SETTING_ACCEPT_ALERT_BUTTON_SELECTOR;
 extern NSString* const FB_SETTING_DISMISS_ALERT_BUTTON_SELECTOR;
@@ -41,6 +42,7 @@ extern NSString* const FB_SETTING_LIMIT_XPATH_CONTEXT_SCOPE;
 extern NSString* const FB_SETTING_AUTO_CLICK_ALERT_SELECTOR;
 extern NSString *const FB_SETTING_INCLUDE_HITTABLE_IN_PAGE_SOURCE;
 extern NSString *const FB_SETTING_INCLUDE_NATIVE_FRAME_IN_PAGE_SOURCE;
+extern NSString *const FB_SETTING_INCLUDE_NATIVE_ACCESSIBILITY_ELEMENT_IN_PAGE_SOURCE;
 extern NSString *const FB_SETTING_INCLUDE_MIN_MAX_VALUE_IN_PAGE_SOURCE;
 extern NSString *const FB_SETTING_INCLUDE_CUSTOM_ACTIONS_IN_PAGE_SOURCE;
 extern NSString *const FB_SETTING_ENFORCE_CUSTOM_SNAPSHOTS;

package/drivers/ios/WebDriverAgent/WebDriverAgentLib/Utilities/FBSettings.m

@@ -18,12 +18,13 @@ NSString* const FB_SETTING_SCREENSHOT_QUALITY = @"screenshotQuality";
 NSString* const FB_SETTING_KEYBOARD_AUTOCORRECTION = @"keyboardAutocorrection";
 NSString* const FB_SETTING_KEYBOARD_PREDICTION = @"keyboardPrediction";
 NSString* const FB_SETTING_SNAPSHOT_MAX_DEPTH = @"snapshotMaxDepth";
+NSString* const FB_SETTING_SNAPSHOT_MAX_CHILDREN = @"snapshotMaxChildren";
+NSString* const FB_SETTING_ACCESSIBILITY_DEADLINE = @"accessibilityDeadline";
 NSString* const FB_SETTING_USE_FIRST_MATCH = @"useFirstMatch";
 NSString* const FB_SETTING_BOUND_ELEMENTS_BY_INDEX = @"boundElementsByIndex";
 NSString* const FB_SETTING_REDUCE_MOTION = @"reduceMotion";
 NSString* const FB_SETTING_DEFAULT_ACTIVE_APPLICATION = @"defaultActiveApplication";
 NSString* const FB_SETTING_ACTIVE_APP_DETECTION_POINT = @"activeAppDetectionPoint";
-NSString* const FB_SETTING_INCLUDE_NON_MODAL_ELEMENTS = @"includeNonModalElements";
 NSString* const FB_SETTING_DEFAULT_ALERT_ACTION = @"defaultAlertAction";
 NSString* const FB_SETTING_ACCEPT_ALERT_BUTTON_SELECTOR = @"acceptAlertButtonSelector";
 NSString* const FB_SETTING_DISMISS_ALERT_BUTTON_SELECTOR = @"dismissAlertButtonSelector";
@@ -37,6 +38,7 @@ NSString* const FB_SETTING_LIMIT_XPATH_CONTEXT_SCOPE = @"limitXPathContextScope"
 NSString* const FB_SETTING_AUTO_CLICK_ALERT_SELECTOR = @"autoClickAlertSelector";
 NSString* const FB_SETTING_INCLUDE_HITTABLE_IN_PAGE_SOURCE = @"includeHittableInPageSource";
 NSString* const FB_SETTING_INCLUDE_NATIVE_FRAME_IN_PAGE_SOURCE = @"includeNativeFrameInPageSource";
+NSString* const FB_SETTING_INCLUDE_NATIVE_ACCESSIBILITY_ELEMENT_IN_PAGE_SOURCE = @"includeNativeAccessibilityElementInPageSource";
 NSString* const FB_SETTING_INCLUDE_MIN_MAX_VALUE_IN_PAGE_SOURCE = @"includeMinMaxValueInPageSource";
 NSString* const FB_SETTING_INCLUDE_CUSTOM_ACTIONS_IN_PAGE_SOURCE = @"includeCustomActionsInPageSource";
 NSString* const FB_SETTING_ENFORCE_CUSTOM_SNAPSHOTS = @"enforceCustomSnapshots";

package/drivers/ios/WebDriverAgent/WebDriverAgentLib/Utilities/FBSettingsHandler.h

@@ -0,0 +1,35 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <Foundation/Foundation.h>
+
+@class FBCommandStatus;
+@class FBSession;
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface FBSettingsHandler : NSObject
+
+/**
+ * Applies the given settings dictionary to FBConfiguration and the active session.
+ * JSON null values are normalized to nil. Nil is applied only for settings that
+ * support clearing (e.g. alert action and selectors); other keys are skipped so
+ * null does not get coerced to NO/0. Unknown keys are skipped.
+ *
+ * @return nil on success, or an FBCommandStatus describing the validation error.
+ */
++ (nullable FBCommandStatus *)applySettings:(NSDictionary *)settings toSession:(FBSession *)session;
+
+/**
+ * Returns the current values for all known settings.
+ */
++ (NSDictionary *)currentSettingsForSession:(FBSession *)session;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/drivers/ios/WebDriverAgent/WebDriverAgentLib/Utilities/FBSettingsHandler.m

@@ -0,0 +1,374 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "FBSettingsHandler.h"
+
+#import "FBActiveAppDetectionPoint.h"
+#import "FBClassChainQueryParser.h"
+#import "FBCommandStatus.h"
+#import "FBConfiguration.h"
+#import "FBSession.h"
+#import "FBSettings.h"
+
+typedef FBCommandStatus * _Nullable (^FBSettingApplyBlock)(FBSession *session, id value);
+typedef id _Nonnull (^FBSettingGetBlock)(FBSession *session);
+
+static id FBNormalizedSettingValue(id value)
+{
+  return value == NSNull.null ? nil : value;
+}
+
+static NSSet<NSString *> *FBNilClearableSettingKeys(void)
+{
+  static NSSet<NSString *> *keys;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    keys = [NSSet setWithObjects:
+      FB_SETTING_DEFAULT_ALERT_ACTION,
+      FB_SETTING_ACCEPT_ALERT_BUTTON_SELECTOR,
+      FB_SETTING_DISMISS_ALERT_BUTTON_SELECTOR,
+      FB_SETTING_AUTO_CLICK_ALERT_SELECTOR,
+      nil];
+  });
+  return keys;
+}
+
+@implementation FBSettingsHandler
+
++ (NSDictionary<NSString *, FBSettingApplyBlock> *)settersMap
+{
+  static NSDictionary<NSString *, FBSettingApplyBlock> *settersMap;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    NSMutableDictionary<NSString *, FBSettingApplyBlock> *map = [NSMutableDictionary dictionary];
+    map[FB_SETTING_USE_COMPACT_RESPONSES] = ^FBCommandStatus *(FBSession *session, id value) {
+      FBConfiguration.sharedInstance.shouldUseCompactResponses = [value boolValue];
+      return nil;
+    };
+    map[FB_SETTING_ELEMENT_RESPONSE_ATTRIBUTES] = ^FBCommandStatus *(FBSession *session, id value) {
+      FBConfiguration.sharedInstance.elementResponseAttributes = (NSString *)value;
+      return nil;
+    };
+    map[FB_SETTING_MJPEG_SERVER_SCREENSHOT_QUALITY] = ^FBCommandStatus *(FBSession *session, id value) {
+      FBConfiguration.sharedInstance.mjpegServerScreenshotQuality = [value unsignedIntegerValue];
+      return nil;
+    };
+    map[FB_SETTING_MJPEG_SERVER_FRAMERATE] = ^FBCommandStatus *(FBSession *session, id value) {
+      FBConfiguration.sharedInstance.mjpegServerFramerate = [value unsignedIntegerValue];
+      return nil;
+    };
+    map[FB_SETTING_SCREENSHOT_QUALITY] = ^FBCommandStatus *(FBSession *session, id value) {
+      FBConfiguration.sharedInstance.screenshotQuality = [value unsignedIntegerValue];
+      return nil;
+    };
+    map[FB_SETTING_MJPEG_SCALING_FACTOR] = ^FBCommandStatus *(FBSession *session, id value) {
+      FBConfiguration.sharedInstance.mjpegScalingFactor = [value floatValue];
+      return nil;
+    };
+    map[FB_SETTING_MJPEG_FIX_ORIENTATION] = ^FBCommandStatus *(FBSession *session, id value) {
+      FBConfiguration.sharedInstance.mjpegShouldFixOrientation = [value boolValue];
+      return nil;
+    };
+    map[FB_SETTING_KEYBOARD_AUTOCORRECTION] = ^FBCommandStatus *(FBSession *session, id value) {
+      FBConfiguration.sharedInstance.keyboardAutocorrection = [value boolValue]
+        ? FBConfigurationKeyboardPreferenceEnabled
+        : FBConfigurationKeyboardPreferenceDisabled;
+      return nil;
+    };
+    map[FB_SETTING_KEYBOARD_PREDICTION] = ^FBCommandStatus *(FBSession *session, id value) {
+      FBConfiguration.sharedInstance.keyboardPrediction = [value boolValue]
+        ? FBConfigurationKeyboardPreferenceEnabled
+        : FBConfigurationKeyboardPreferenceDisabled;
+      return nil;
+    };
+    map[FB_SETTING_RESPECT_SYSTEM_ALERTS] = ^FBCommandStatus *(FBSession *session, id value) {
+      FBConfiguration.sharedInstance.shouldRespectSystemAlerts = [value boolValue];
+      return nil;
+    };
+    map[FB_SETTING_SNAPSHOT_MAX_DEPTH] = ^FBCommandStatus *(FBSession *session, id value) {
+      FBConfiguration.sharedInstance.snapshotMaxDepth = [value intValue];
+      return nil;
+    };
+    map[FB_SETTING_SNAPSHOT_MAX_CHILDREN] = ^FBCommandStatus *(FBSession *session, id value) {
+      FBConfiguration.sharedInstance.snapshotMaxChildren = [value intValue];
+      return nil;
+    };
+    map[FB_SETTING_USE_FIRST_MATCH] = ^FBCommandStatus *(FBSession *session, id value) {
+      FBConfiguration.sharedInstance.useFirstMatch = [value boolValue];
+      return nil;
+    };
+    map[FB_SETTING_BOUND_ELEMENTS_BY_INDEX] = ^FBCommandStatus *(FBSession *session, id value) {
+      FBConfiguration.sharedInstance.boundElementsByIndex = [value boolValue];
+      return nil;
+    };
+    map[FB_SETTING_REDUCE_MOTION] = ^FBCommandStatus *(FBSession *session, id value) {
+      FBConfiguration.sharedInstance.reduceMotionEnabled = [value boolValue];
+      return nil;
+    };
+    map[FB_SETTING_DEFAULT_ACTIVE_APPLICATION] = ^FBCommandStatus *(FBSession *session, id value) {
+      session.defaultActiveApplication = (NSString *)value;
+      return nil;
+    };
+    map[FB_SETTING_ACTIVE_APP_DETECTION_POINT] = ^FBCommandStatus *(FBSession *session, id value) {
+      NSError *error;
+      if (![FBActiveAppDetectionPoint.sharedInstance setCoordinatesWithString:(NSString *)value
+                                                                        error:&error]) {
+        return [FBCommandStatus invalidArgumentErrorWithMessage:error.localizedDescription
+                                                      traceback:nil];
+      }
+      return nil;
+    };
+    map[FB_SETTING_ACCEPT_ALERT_BUTTON_SELECTOR] = ^FBCommandStatus *(FBSession *session, id value) {
+      FBConfiguration.sharedInstance.acceptAlertButtonSelector = (NSString *)value;
+      return nil;
+    };
+    map[FB_SETTING_DISMISS_ALERT_BUTTON_SELECTOR] = ^FBCommandStatus *(FBSession *session, id value) {
+      FBConfiguration.sharedInstance.dismissAlertButtonSelector = (NSString *)value;
+      return nil;
+    };
+    map[FB_SETTING_AUTO_CLICK_ALERT_SELECTOR] = ^FBCommandStatus *(FBSession *session, id value) {
+      return [self configureAutoClickAlertWithSelector:(NSString *)value forSession:session];
+    };
+    map[FB_SETTING_WAIT_FOR_IDLE_TIMEOUT] = ^FBCommandStatus *(FBSession *session, id value) {
+      FBConfiguration.sharedInstance.waitForIdleTimeout = [value doubleValue];
+      return nil;
+    };
+    map[FB_SETTING_ANIMATION_COOL_OFF_TIMEOUT] = ^FBCommandStatus *(FBSession *session, id value) {
+      FBConfiguration.sharedInstance.animationCoolOffTimeout = [value doubleValue];
+      return nil;
+    };
+    map[FB_SETTING_ACCESSIBILITY_DEADLINE] = ^FBCommandStatus *(FBSession *session, id value) {
+      FBConfiguration.sharedInstance.accessibilityDeadline = [value doubleValue];
+      return nil;
+    };
+    map[FB_SETTING_DEFAULT_ALERT_ACTION] = ^FBCommandStatus *(FBSession *session, id value) {
+      if (nil == value) {
+        session.defaultAlertAction = nil;
+      } else if ([value isKindOfClass:NSString.class]) {
+        session.defaultAlertAction = [(NSString *)value lowercaseString];
+      }
+      return nil;
+    };
+    map[FB_SETTING_MAX_TYPING_FREQUENCY] = ^FBCommandStatus *(FBSession *session, id value) {
+      FBConfiguration.sharedInstance.maxTypingFrequency = [value unsignedIntegerValue];
+      return nil;
+    };
+    map[FB_SETTING_USE_CLEAR_TEXT_SHORTCUT] = ^FBCommandStatus *(FBSession *session, id value) {
+      FBConfiguration.sharedInstance.useClearTextShortcut = [value boolValue];
+      return nil;
+    };
+    map[FB_SETTING_INCLUDE_HITTABLE_IN_PAGE_SOURCE] = ^FBCommandStatus *(FBSession *session, id value) {
+      FBConfiguration.sharedInstance.includeHittableInPageSource = [value boolValue];
+      return nil;
+    };
+    map[FB_SETTING_INCLUDE_NATIVE_FRAME_IN_PAGE_SOURCE] = ^FBCommandStatus *(FBSession *session, id value) {
+      FBConfiguration.sharedInstance.includeNativeFrameInPageSource = [value boolValue];
+      return nil;
+    };
+    map[FB_SETTING_INCLUDE_NATIVE_ACCESSIBILITY_ELEMENT_IN_PAGE_SOURCE] = ^FBCommandStatus *(FBSession *session, id value) {
+      FBConfiguration.sharedInstance.includeNativeAccessibilityElementInPageSource = [value boolValue];
+      return nil;
+    };
+    map[FB_SETTING_INCLUDE_MIN_MAX_VALUE_IN_PAGE_SOURCE] = ^FBCommandStatus *(FBSession *session, id value) {
+      FBConfiguration.sharedInstance.includeMinMaxValueInPageSource = [value boolValue];
+      return nil;
+    };
+    map[FB_SETTING_INCLUDE_CUSTOM_ACTIONS_IN_PAGE_SOURCE] = ^FBCommandStatus *(FBSession *session, id value) {
+      FBConfiguration.sharedInstance.includeCustomActionsInPageSource = [value boolValue];
+      return nil;
+    };
+    map[FB_SETTING_ENFORCE_CUSTOM_SNAPSHOTS] = ^FBCommandStatus *(FBSession *session, id value) {
+      FBConfiguration.sharedInstance.enforceCustomSnapshots = [value boolValue];
+      return nil;
+    };
+    map[FB_SETTING_LIMIT_XPATH_CONTEXT_SCOPE] = ^FBCommandStatus *(FBSession *session, id value) {
+      FBConfiguration.sharedInstance.limitXpathContextScope = [value boolValue];
+      return nil;
+    };
+#if !TARGET_OS_TV && !TARGET_OS_WATCH
+    map[FB_SETTING_SCREENSHOT_ORIENTATION] = ^FBCommandStatus *(FBSession *session, id value) {
+      NSError *error;
+      if (![FBConfiguration.sharedInstance setScreenshotOrientation:(NSString *)value error:&error]) {
+        return [FBCommandStatus invalidArgumentErrorWithMessage:error.localizedDescription
+                                                      traceback:nil];
+      }
+      return nil;
+    };
+#endif
+    settersMap = map.copy;
+  });
+  return settersMap;
+}
+
++ (NSDictionary<NSString *, FBSettingGetBlock> *)gettersMap
+{
+  static NSDictionary<NSString *, FBSettingGetBlock> *gettersMap;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    NSMutableDictionary<NSString *, FBSettingGetBlock> *map = [NSMutableDictionary dictionary];
+    map[FB_SETTING_USE_COMPACT_RESPONSES] = ^id(FBSession *session) {
+      return @(FBConfiguration.sharedInstance.shouldUseCompactResponses);
+    };
+    map[FB_SETTING_ELEMENT_RESPONSE_ATTRIBUTES] = ^id(FBSession *session) {
+      return FBConfiguration.sharedInstance.elementResponseAttributes;
+    };
+    map[FB_SETTING_MJPEG_SERVER_SCREENSHOT_QUALITY] = ^id(FBSession *session) {
+      return @(FBConfiguration.sharedInstance.mjpegServerScreenshotQuality);
+    };
+    map[FB_SETTING_MJPEG_SERVER_FRAMERATE] = ^id(FBSession *session) {
+      return @(FBConfiguration.sharedInstance.mjpegServerFramerate);
+    };
+    map[FB_SETTING_MJPEG_SCALING_FACTOR] = ^id(FBSession *session) {
+      return @(FBConfiguration.sharedInstance.mjpegScalingFactor);
+    };
+    map[FB_SETTING_MJPEG_FIX_ORIENTATION] = ^id(FBSession *session) {
+      return @(FBConfiguration.sharedInstance.mjpegShouldFixOrientation);
+    };
+    map[FB_SETTING_SCREENSHOT_QUALITY] = ^id(FBSession *session) {
+      return @(FBConfiguration.sharedInstance.screenshotQuality);
+    };
+    map[FB_SETTING_KEYBOARD_AUTOCORRECTION] = ^id(FBSession *session) {
+      return @(FBConfiguration.sharedInstance.keyboardAutocorrection);
+    };
+    map[FB_SETTING_KEYBOARD_PREDICTION] = ^id(FBSession *session) {
+      return @(FBConfiguration.sharedInstance.keyboardPrediction);
+    };
+    map[FB_SETTING_SNAPSHOT_MAX_DEPTH] = ^id(FBSession *session) {
+      return @(FBConfiguration.sharedInstance.snapshotMaxDepth);
+    };
+    map[FB_SETTING_SNAPSHOT_MAX_CHILDREN] = ^id(FBSession *session) {
+      return @(FBConfiguration.sharedInstance.snapshotMaxChildren);
+    };
+    map[FB_SETTING_USE_FIRST_MATCH] = ^id(FBSession *session) {
+      return @(FBConfiguration.sharedInstance.useFirstMatch);
+    };
+    map[FB_SETTING_WAIT_FOR_IDLE_TIMEOUT] = ^id(FBSession *session) {
+      return @(FBConfiguration.sharedInstance.waitForIdleTimeout);
+    };
+    map[FB_SETTING_ANIMATION_COOL_OFF_TIMEOUT] = ^id(FBSession *session) {
+      return @(FBConfiguration.sharedInstance.animationCoolOffTimeout);
+    };
+    map[FB_SETTING_ACCESSIBILITY_DEADLINE] = ^id(FBSession *session) {
+      return @(FBConfiguration.sharedInstance.accessibilityDeadline);
+    };
+    map[FB_SETTING_BOUND_ELEMENTS_BY_INDEX] = ^id(FBSession *session) {
+      return @(FBConfiguration.sharedInstance.boundElementsByIndex);
+    };
+    map[FB_SETTING_REDUCE_MOTION] = ^id(FBSession *session) {
+      return @(FBConfiguration.sharedInstance.reduceMotionEnabled);
+    };
+    map[FB_SETTING_DEFAULT_ACTIVE_APPLICATION] = ^id(FBSession *session) {
+      return session.defaultActiveApplication;
+    };
+    map[FB_SETTING_ACTIVE_APP_DETECTION_POINT] = ^id(FBSession *session) {
+      return FBActiveAppDetectionPoint.sharedInstance.stringCoordinates;
+    };
+    map[FB_SETTING_ACCEPT_ALERT_BUTTON_SELECTOR] = ^id(FBSession *session) {
+      return FBConfiguration.sharedInstance.acceptAlertButtonSelector;
+    };
+    map[FB_SETTING_DISMISS_ALERT_BUTTON_SELECTOR] = ^id(FBSession *session) {
+      return FBConfiguration.sharedInstance.dismissAlertButtonSelector;
+    };
+    map[FB_SETTING_AUTO_CLICK_ALERT_SELECTOR] = ^id(FBSession *session) {
+      return FBConfiguration.sharedInstance.autoClickAlertSelector;
+    };
+    map[FB_SETTING_DEFAULT_ALERT_ACTION] = ^id(FBSession *session) {
+      return session.defaultAlertAction ?: @"";
+    };
+    map[FB_SETTING_MAX_TYPING_FREQUENCY] = ^id(FBSession *session) {
+      return @(FBConfiguration.sharedInstance.maxTypingFrequency);
+    };
+    map[FB_SETTING_RESPECT_SYSTEM_ALERTS] = ^id(FBSession *session) {
+      return @(FBConfiguration.sharedInstance.shouldRespectSystemAlerts);
+    };
+    map[FB_SETTING_USE_CLEAR_TEXT_SHORTCUT] = ^id(FBSession *session) {
+      return @(FBConfiguration.sharedInstance.useClearTextShortcut);
+    };
+    map[FB_SETTING_INCLUDE_HITTABLE_IN_PAGE_SOURCE] = ^id(FBSession *session) {
+      return @(FBConfiguration.sharedInstance.includeHittableInPageSource);
+    };
+    map[FB_SETTING_INCLUDE_NATIVE_FRAME_IN_PAGE_SOURCE] = ^id(FBSession *session) {
+      return @(FBConfiguration.sharedInstance.includeNativeFrameInPageSource);
+    };
+    map[FB_SETTING_INCLUDE_NATIVE_ACCESSIBILITY_ELEMENT_IN_PAGE_SOURCE] = ^id(FBSession *session) {
+      return @(FBConfiguration.sharedInstance.includeNativeAccessibilityElementInPageSource);
+    };
+    map[FB_SETTING_INCLUDE_MIN_MAX_VALUE_IN_PAGE_SOURCE] = ^id(FBSession *session) {
+      return @(FBConfiguration.sharedInstance.includeMinMaxValueInPageSource);
+    };
+    map[FB_SETTING_INCLUDE_CUSTOM_ACTIONS_IN_PAGE_SOURCE] = ^id(FBSession *session) {
+      return @(FBConfiguration.sharedInstance.includeCustomActionsInPageSource);
+    };
+    map[FB_SETTING_ENFORCE_CUSTOM_SNAPSHOTS] = ^id(FBSession *session) {
+      return @(FBConfiguration.sharedInstance.enforceCustomSnapshots);
+    };
+    map[FB_SETTING_LIMIT_XPATH_CONTEXT_SCOPE] = ^id(FBSession *session) {
+      return @(FBConfiguration.sharedInstance.limitXpathContextScope);
+    };
+#if !TARGET_OS_TV && !TARGET_OS_WATCH
+    map[FB_SETTING_SCREENSHOT_ORIENTATION] = ^id(FBSession *session) {
+      return FBConfiguration.sharedInstance.humanReadableScreenshotOrientation;
+    };
+#endif
+    gettersMap = map.copy;
+  });
+  return gettersMap;
+}
+
++ (NSDictionary *)currentSettingsForSession:(FBSession *)session
+{
+  NSDictionary<NSString *, FBSettingGetBlock> *gettersMap = [self gettersMap];
+  NSMutableDictionary *settings = [NSMutableDictionary dictionaryWithCapacity:gettersMap.count];
+  for (NSString *key in gettersMap) {
+    settings[key] = gettersMap[key](session);
+  }
+  return settings.copy;
+}
+
++ (nullable FBCommandStatus *)applySettings:(NSDictionary *)settings toSession:(FBSession *)session
+{
+  NSDictionary<NSString *, FBSettingApplyBlock> *settersMap = [self settersMap];
+  NSSet<NSString *> *nilClearableKeys = FBNilClearableSettingKeys();
+  for (NSString *key in settings) {
+    FBSettingApplyBlock handler = settersMap[key];
+    if (nil == handler) {
+      continue;
+    }
+    id value = FBNormalizedSettingValue(settings[key]);
+    if (nil == value && ![nilClearableKeys containsObject:key]) {
+      continue;
+    }
+    FBCommandStatus *status = handler(session, value);
+    if (status.hasError) {
+      return status;
+    }
+  }
+  return nil;
+}
+
++ (FBCommandStatus *)configureAutoClickAlertWithSelector:(NSString *)selector
+                                              forSession:(FBSession *)session
+{
+  if (0 == [selector length]) {
+    FBConfiguration.sharedInstance.autoClickAlertSelector = selector;
+    [session disableAlertsMonitor];
+    return [FBCommandStatus ok];
+  }
+
+  NSError *error;
+  FBClassChain *parsedChain = [FBClassChainQueryParser parseQuery:selector error:&error];
+  if (nil == parsedChain) {
+    return [FBCommandStatus invalidSelectorErrorWithMessage:error.localizedDescription
+                                                  traceback:nil];
+  }
+  FBConfiguration.sharedInstance.autoClickAlertSelector = selector;
+  [session enableAlertsMonitor];
+  return [FBCommandStatus ok];
+}
+
+@end

package/drivers/ios/WebDriverAgent/WebDriverAgentLib/Utilities/FBTVNavigationTracker-Private.h

@@ -7,6 +7,7 @@
  */
 
 #import <Foundation/Foundation.h>
+#import "FBXCElementSnapshot.h"
 
 #if TARGET_OS_TV
 
@@ -22,6 +23,15 @@
 
 - (FBTVDirection)horizontalDirectionWithItem:(FBTVNavigationItem *)item andDelta:(CGFloat)delta;
 - (FBTVDirection)verticalDirectionWithItem:(FBTVNavigationItem *)item andDelta:(CGFloat)delta;
+- (FBTVDirection)directionWithItem:(FBTVNavigationItem *)item
+                              delta:(CGFloat)delta
+                  positiveDirection:(FBTVDirection)positiveDirection
+                  negativeDirection:(FBTVDirection)negativeDirection;
+
+// Exposed for testing: the pure direction-math core of `-pollFocusState:`,
+// parameterized on the already-resolved focused element's snapshot so tests
+// can supply a fake one instead of a live query result.
+- (FBTVDirection)directionTowardsTargetFromFocusedElementSnapshot:(id<FBXCElementSnapshot>)focusedSnapshot;
 @end
 
 #endif

package/drivers/ios/WebDriverAgent/WebDriverAgentLib/Utilities/FBTVNavigationTracker.h

@@ -22,6 +22,19 @@ typedef NS_ENUM(NSUInteger, FBTVDirection) {
   FBTVDirectionNone   = 4
 };
 
+/**
+ Represents where the tracked target element currently stands with respect
+ to keyboard/remote focus, as of the last `-pollFocusState:` call.
+ */
+typedef NS_ENUM(NSUInteger, FBTVFocusState) {
+  // The target element currently has focus
+  FBTVFocusStateFocused,
+  // The target element could not be located in the accessibility tree anymore
+  FBTVFocusStateGone,
+  // The target element exists, but does not have focus yet
+  FBTVFocusStatePending,
+};
+
 NS_ASSUME_NONNULL_BEGIN
 
 @interface FBTVNavigationItem : NSObject
@@ -38,12 +51,24 @@ NS_ASSUME_NONNULL_BEGIN
 + (instancetype)trackerWithTargetElement: (XCUIElement *) targetElement;
 
 /**
- Determine the correct direction to move the focus to the tracked target
- element from the currently focused one
+ Determines whether the tracked target element currently has focus, whether
+ it still exists, and - if neither - which direction the focus should move
+ to get closer to it. Each of these is resolved with the cheapest available
+ accessibility round trip for what it's checking: `hasFocus`/`exists` are
+ single already-known-element checks, and the currently focused element (if
+ any) is found via a targeted `hasFocus == true` query rather than a whole-app
+ snapshot walk, whose cost scales with total app size/depth instead of with
+ the (typically 0-1) number of matches.
 
- @return FBTVDirection to move the focus to
+ @param direction Always reset to `FBTVDirectionNone` first, then set to the
+   suggested direction to move the focus to when the return value is
+   `FBTVFocusStatePending`. It is left as `FBTVDirectionNone` when the return
+   value is `FBTVFocusStateFocused`/`FBTVFocusStateGone`, or when the
+   currently focused element could not be determined yet - in the latter
+   case the caller should just retry on the next iteration.
+ @return The current focus state of the tracked target element
  */
-- (FBTVDirection)directionToFocusedElement;
+- (FBTVFocusState)pollFocusState:(FBTVDirection *)direction;
 
 @end