appium-webdriveragent 16.7.2 → 16.8.0

package/WebDriverAgentLib/Routing/FBSession.m

@@ -34,12 +34,23 @@ NSString *const FBDefaultApplicationAuto = @"auto";
 
 NSString *const FB_SAFARI_BUNDLE_ID = @"com.apple.mobilesafari";
 
+// FBXCAXClientProxy's shared accessibility channel can be stuck servicing another request.
+static const NSTimeInterval FB_IS_SYSTEM_APP_CHECK_TIMEOUT_SEC = 5.;
+// -terminate hard-asserts off the main thread, which may itself be busy - see -fb_terminate...:.
+static const NSTimeInterval FB_APP_TERMINATE_TIMEOUT_SEC = 5.;
+// How long a -kill caller that lost the race below waits for the winner's teardown to finish.
+static const NSTimeInterval FB_KILL_WAIT_TIMEOUT_SEC = 35.;
+NSString *const FBSessionWasKilledNotification = @"FBSessionWasKilledNotification";
+
 @interface FBSession ()
 @property (nullable, nonatomic) XCUIApplication *testedApplication;
 @property (nonatomic) BOOL isTestedApplicationExpectedToRun;
 @property (nonatomic) BOOL shouldAppsWaitForQuiescence;
 @property (nonatomic, nullable) FBAlertsMonitor *alertsMonitor;
 @property (nonatomic, readwrite) NSMutableDictionary<NSNumber *, NSMutableDictionary<NSString *, NSNumber *> *> *elementsVisibilityCache;
+
+- (BOOL)fb_isTestedApplicationSameAsSystemAppWithTimeout:(NSTimeInterval)timeout;
+- (void)fb_terminateTestedApplicationWithTimeout:(NSTimeInterval)timeout;
 @end
 
 @interface FBSession (FBAlertsMonitorDelegate)
@@ -90,17 +101,54 @@ NSString *const FB_SAFARI_BUNDLE_ID = @"com.apple.mobilesafari";
 @implementation FBSession
 
 static FBSession *_activeSession = nil;
+// Class-level, not per-instance: a caller that finds _activeSession already nil (a concurrent
+// -kill beat it there) still needs to know whether that -kill's teardown is done, since it cleared
+// the pointer before running it. See +waitForActiveTeardownWithTimeout:.
+static BOOL _isTeardownInProgress = NO;
+
++ (NSCondition *)teardownCondition
+{
+  static NSCondition *condition;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    condition = [NSCondition new];
+  });
+  return condition;
+}
+
+// Waits (bounded) for any -kill teardown currently in progress to finish.
++ (void)waitForActiveTeardownWithTimeout:(NSTimeInterval)timeout
+{
+  NSCondition *condition = self.teardownCondition;
+  [condition lock];
+  NSDate *deadline = [NSDate dateWithTimeIntervalSinceNow:timeout];
+  while (_isTeardownInProgress && [condition waitUntilDate:deadline]) {
+  }
+  [condition unlock];
+}
 
 + (instancetype)activeSession
 {
   return _activeSession;
 }
 
-+ (void)markSessionActive:(FBSession *)session
++ (void)killActiveSessionAndWaitForTeardown
 {
-  if (_activeSession) {
-    [_activeSession kill];
+  FBSession *session = _activeSession;
+  if (nil != session) {
+    // Runs the real teardown synchronously if this call wins the race in -kill, or waits for
+    // whoever did to finish if it lost - either way, blocks until torn down.
+    [session kill];
+  } else {
+    // _activeSession is already nil, but a concurrent -kill (e.g. from DELETE /session) may still
+    // be mid-teardown - wait for it, so we don't launch a replacement app too early.
+    [self waitForActiveTeardownWithTimeout:FB_KILL_WAIT_TIMEOUT_SEC];
   }
+}
+
++ (void)markSessionActive:(FBSession *)session
+{
+  [self killActiveSessionAndWaitForTeardown];
   _activeSession = session;
 }
 
@@ -169,33 +217,58 @@ static FBSession *_activeSession = nil;
 
 - (void)kill
 {
-  if (nil == _activeSession) {
+  // DELETE /session and session creation can now run concurrently, so a session already
+  // superseded by a newer one can still reach here via a stale reference. Check-and-clear must be
+  // atomic, else a belated -kill could null out the new session's pointer instead of its own.
+  BOOL wasActive;
+  @synchronized (self.class) {
+    wasActive = (self == _activeSession);
+    if (wasActive) {
+      _activeSession = nil;
+    }
+  }
+  if (!wasActive) {
+    // Someone else is already tearing this session down - wait for that to finish (bounded), so
+    // we don't act as if it's gone (e.g. launch a new app) while its -terminate is still in flight.
+    [self.class waitForActiveTeardownWithTimeout:FB_KILL_WAIT_TIMEOUT_SEC];
     return;
   }
 
-  [self disableAlertsMonitor];
+  NSCondition *teardownCondition = self.class.teardownCondition;
+  [teardownCondition lock];
+  _isTeardownInProgress = YES;
+  [teardownCondition unlock];
+
+  @try {
+    // Posted before teardown so pending HTTP requests for this session can stop waiting sooner.
+    [NSNotificationCenter.defaultCenter postNotificationName:FBSessionWasKilledNotification object:self];
 
-  FBScreenRecordingPromise *activeScreenRecording = FBScreenRecordingContainer.sharedInstance.screenRecordingPromise;
-  if (nil != activeScreenRecording) {
-    NSError *error;
-    if (![FBXCTestDaemonsProxy stopScreenRecordingWithUUID:activeScreenRecording.identifier error:&error]) {
-      [FBLogger logFmt:@"%@", error];
+    [self disableAlertsMonitor];
+
+    FBScreenRecordingPromise *activeScreenRecording = FBScreenRecordingContainer.sharedInstance.screenRecordingPromise;
+    if (nil != activeScreenRecording) {
+      NSError *error;
+      if (![FBXCTestDaemonsProxy stopScreenRecordingWithUUID:activeScreenRecording.identifier error:&error]) {
+        [FBLogger logFmt:@"%@", error];
+      }
+      [FBScreenRecordingContainer.sharedInstance reset];
     }
-    [FBScreenRecordingContainer.sharedInstance reset];
-  }
 
-  if (nil != self.testedApplication
-      && FBConfiguration.sharedInstance.shouldTerminateApp
-      && self.testedApplication.running
-      && ![self.testedApplication fb_isSameAppAs:XCUIApplication.fb_systemApplication]) {
-    @try {
-      [self.testedApplication terminate];
-    } @catch (NSException *e) {
-      [FBLogger logFmt:@"%@", e.description];
+    if (nil != self.testedApplication
+        && FBConfiguration.sharedInstance.shouldTerminateApp
+        && self.testedApplication.running
+        && ![self fb_isTestedApplicationSameAsSystemAppWithTimeout:FB_IS_SYSTEM_APP_CHECK_TIMEOUT_SEC]) {
+      // Blocks until the app is either actually terminated or durably given up on (never left
+      // pending) - see -fb_terminateTestedApplicationWithTimeout: - so it's safe to report this
+      // teardown as finished as soon as this returns.
+      [self fb_terminateTestedApplicationWithTimeout:FB_APP_TERMINATE_TIMEOUT_SEC];
     }
+  } @finally {
+    [teardownCondition lock];
+    _isTeardownInProgress = NO;
+    [teardownCondition broadcast];
+    [teardownCondition unlock];
   }
-
-  _activeSession = nil;
 }
 
 - (XCUIApplication *)activeApplication
@@ -290,4 +363,62 @@ static FBSession *_activeSession = nil;
     : [[XCUIApplication alloc] initWithBundleIdentifier:bundleIdentifier];
 }
 
+// Has no async variant and can block on the shared accessibility channel. Run off-thread and give
+// up after `timeout`, assuming the tested app IS the system app - safer, since it means skipping
+// termination rather than risking terminating springboard.
+- (BOOL)fb_isTestedApplicationSameAsSystemAppWithTimeout:(NSTimeInterval)timeout
+{
+  __block XCUIApplication *systemApp = nil;
+  __block NSException *caughtException = nil;
+  dispatch_semaphore_t sem = dispatch_semaphore_create(0);
+  dispatch_async(dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0), ^{
+    // Undocumented private API; guard in case it hard-asserts off-main like -terminate does on
+    // some Xcode/iOS version - uncaught, that would crash the whole process.
+    @try {
+      systemApp = XCUIApplication.fb_systemApplication;
+    } @catch (NSException *e) {
+      caughtException = e;
+    }
+    dispatch_semaphore_signal(sem);
+  });
+  int64_t timeoutNs = (int64_t)(timeout * NSEC_PER_SEC);
+  if (0 != dispatch_semaphore_wait(sem, dispatch_time(DISPATCH_TIME_NOW, timeoutNs)) || nil != caughtException) {
+    [FBLogger logFmt:@"Could not determine the system application within %@ seconds%@; assuming '%@' might be it and skipping its termination", @(timeout), nil == caughtException ? @"" : [NSString stringWithFormat:@" (%@)", caughtException.description], self.testedApplication.bundleID];
+    return YES;
+  }
+  return [self.testedApplication fb_isSameAppAs:systemApp];
+}
+
+// -terminate hard-asserts off-main, but -kill can now run on a background queue. Dispatching to
+// main and waiting indefinitely could hang just as long as main is stuck, so give up after
+// `timeout` - but a "given up on" call must never still terminate whatever's running by the time
+// main gets to it (e.g. a replacement session's app), so cancellation and the actual terminate
+// call share a lock: whichever gets there first - the dispatched block, or the timeout - wins.
+- (void)fb_terminateTestedApplicationWithTimeout:(NSTimeInterval)timeout
+{
+  XCUIApplication *application = self.testedApplication;
+  NSObject *lock = [NSObject new];
+  __block BOOL isAllowedToTerminate = YES;
+  dispatch_semaphore_t sem = dispatch_semaphore_create(0);
+  dispatch_async(dispatch_get_main_queue(), ^{
+    @synchronized (lock) {
+      if (isAllowedToTerminate) {
+        @try {
+          [application terminate];
+        } @catch (NSException *e) {
+          [FBLogger logFmt:@"%@", e.description];
+        }
+      }
+    }
+    dispatch_semaphore_signal(sem);
+  });
+  int64_t timeoutNs = (int64_t)(timeout * NSEC_PER_SEC);
+  if (0 != dispatch_semaphore_wait(sem, dispatch_time(DISPATCH_TIME_NOW, timeoutNs))) {
+    @synchronized (lock) {
+      isAllowedToTerminate = NO;
+    }
+    [FBLogger logFmt:@"Could not terminate '%@' within %@ seconds; giving up on it rather than risk terminating a possible replacement session's app later", application.bundleID, @(timeout)];
+  }
+}
+
 @end

package/WebDriverAgentLib/Routing/FBTCPSocket.m

@@ -135,7 +135,8 @@
       }
       [strongSelf scheduleReceiveForConnection:connection];
     } else if (nw_connection_state_failed == state || nw_connection_state_cancelled == state) {
-      [weakSelf handleDisconnectForConnection:connection];
+      __strong typeof(weakSelf) strongSelf = weakSelf;
+      [strongSelf handleDisconnectForConnection:connection];
     }
   });
   nw_connection_start(connection);

package/WebDriverAgentLib/Routing/FBWebServer.m

@@ -13,8 +13,10 @@
 #import "FBTCPSocket.h"
 
 #import "FBCommandHandler.h"
+#import "FBCommandStatus.h"
 #import "FBErrorBuilder.h"
 #import "FBExceptionHandler.h"
+#import "FBResponsePayload.h"
 #import "FBRouteRequest.h"
 #import "FBRuntimeUtils.h"
 #import "FBSession.h"
@@ -80,6 +82,11 @@ static NSString *const FBServerURLEndMarker = @"<-ServerURLHere";
   [self.server setDefaultHeader:@"Access-Control-Allow-Origin" value:@"*"];
   [self.server setDefaultHeader:@"Access-Control-Allow-Headers" value:@"Content-Type, X-Requested-With"];
 
+  [NSNotificationCenter.defaultCenter addObserver:self
+                                          selector:@selector(sessionWasKilled:)
+                                              name:FBSessionWasKilledNotification
+                                            object:nil];
+
   [self registerRouteHandlers:[self.class collectCommandHandlerClasses]];
   [self registerServerKeyRouteHandlers];
 
@@ -167,8 +174,26 @@ static NSString *const FBServerURLEndMarker = @"<-ServerURLHere";
   }
 }
 
+- (void)sessionWasKilled:(NSNotification *)notification
+{
+  FBSession *session = notification.object;
+  if (![session isKindOfClass:FBSession.class]) {
+    return;
+  }
+  // Same "invalid session id" shape a still-queued request would eventually get anyway, once
+  // -routeQueue drains and FBRoute.decorateRequest: finds the session gone - just delivered now
+  // instead of after however long the request would otherwise have been stuck waiting.
+  NSString *message = [NSString stringWithFormat:@"Session %@ was deleted while this request was still pending", session.identifier];
+  id<FBResponsePayload> payload = FBResponseWithStatus([FBCommandStatus noSuchDriverErrorWithMessage:message
+                                                                                            traceback:nil]);
+  RouteResponse *response = [RouteResponse new];
+  [payload dispatchWithResponse:response];
+  [self.server abandonPendingRequestsForSessionID:session.identifier withResponse:response];
+}
+
 - (void)stopServing
 {
+  [NSNotificationCenter.defaultCenter removeObserver:self name:FBSessionWasKilledNotification object:nil];
   [FBSession.activeSession kill];
   [self stopScreenshotsBroadcaster];
   if (self.server.isRunning) {
@@ -208,7 +233,7 @@ static NSString *const FBServerURLEndMarker = @"<-ServerURLHere";
   for (Class<FBCommandHandler> commandHandler in commandHandlerClasses) {
     NSArray *routes = [commandHandler routes];
     for (FBRoute *route in routes) {
-      [self.server handleMethod:route.verb withPath:route.path block:^(RouteRequest *request, RouteResponse *response) {
+      [self.server handleMethod:route.verb withPath:route.path standalone:route.isStandalone block:^(RouteRequest *request, RouteResponse *response) {
         __strong typeof(weakSelf) strongSelf = weakSelf;
         if (nil == strongSelf) {
           return;

package/WebDriverAgentLib/Routing/RouteResponse.m

@@ -9,7 +9,7 @@
 #import "RouteResponse.h"
 
 @interface RouteResponse ()
-@property (nonatomic, copy) NSMutableDictionary<NSString *, NSString *> *mutableHeaders;
+@property (nonatomic, strong) NSMutableDictionary<NSString *, NSString *> *mutableHeaders;
 @end
 
 @implementation RouteResponse

package/WebDriverAgentLib/Utilities/FBConfiguration.h

@@ -234,6 +234,17 @@ typedef NS_ENUM(NSInteger, FBConfigurationKeyboardPreference) {
  */
 @property (atomic, assign) NSTimeInterval animationCoolOffTimeout;
 
+/**
+ * Maximum time to wait for the frontmost application to confirm its main run loop
+ * is responsive before an accessibility snapshot request (element attribute
+ * lookups, active app detection, etc). XCTest has no bounded timeout of its own
+ * here, so a frozen app could otherwise block WDA forever (#1210); past this
+ * timeout the request is aborted with an error instead.
+ * Set to zero or negative to disable, restoring unbounded behavior. Disabled (0)
+ * by default.
+ */
+@property (atomic, assign) NSTimeInterval accessibilityDeadline;
+
 /**
  Custom class chain locator for accept alert button location.
  This might be useful if the default buttons detection algorithm fails to determine alert buttons properly

package/WebDriverAgentLib/Utilities/FBConfiguration.m

@@ -124,17 +124,14 @@ static NSString *const axSettingsClassName = @"AXSettings";
 {
   // 'WebDriverAgent --port 8080' can be passed via the arguments to the process
   NSRange rangeFromArguments = [self.class bindingPortRangeFromArguments];
-  if (rangeFromArguments.location != NSNotFound) {
-    return rangeFromArguments;
+  if (rangeFromArguments.location == NSNotFound) {
+    // Existence of USE_PORT in the environment implies the port range is managed by the launching process.
+    NSString *usePort = NSProcessInfo.processInfo.environment[@"USE_PORT"];
+    rangeFromArguments = usePort.length > 0
+      ? NSMakeRange((NSUInteger)usePort.integerValue, 1)
+      : NSMakeRange(DefaultStartingPort, DefaultPortRange);
   }
-
-  // Existence of USE_PORT in the environment implies the port range is managed by the launching process.
-  if (NSProcessInfo.processInfo.environment[@"USE_PORT"] &&
-      [NSProcessInfo.processInfo.environment[@"USE_PORT"] length] > 0) {
-    return NSMakeRange([NSProcessInfo.processInfo.environment[@"USE_PORT"] integerValue] , 1);
-  }
-
-  return NSMakeRange(DefaultStartingPort, DefaultPortRange);
+  return rangeFromArguments;
 }
 
 - (NSString *)bindingIPAddress
@@ -354,6 +351,7 @@ static NSString *const axSettingsClassName = @"AXSettings";
   self.autoClickAlertSelector = @"";
   self.waitForIdleTimeout = 10.;
   self.animationCoolOffTimeout = 2.;
+  self.accessibilityDeadline = 0.;
   // 50 should be enough for the majority of the cases. The performance is acceptable for values up to 100.
   FBSetCustomParameterForElementSnapshot(FBSnapshotMaxDepthKey, @50);
   FBSetCustomParameterForElementSnapshot(FBSnapshotMaxChildrenKey, @INT_MAX);

package/WebDriverAgentLib/Utilities/FBSettings.h

@@ -23,6 +23,7 @@ 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;

package/WebDriverAgentLib/Utilities/FBSettings.m

@@ -19,6 +19,7 @@ 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";

package/WebDriverAgentLib/Utilities/FBSettingsHandler.m

@@ -142,6 +142,10 @@ static NSSet<NSString *> *FBNilClearableSettingKeys(void)
       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;
@@ -249,6 +253,9 @@ static NSSet<NSString *> *FBNilClearableSettingKeys(void)
     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);
     };

package/WebDriverAgentLib/Utilities/FBXCAXClientProxy.h

@@ -38,6 +38,15 @@ NS_ASSUME_NONNULL_BEGIN
 - (void)notifyWhenNoAnimationsAreActiveForApplication:(XCUIApplication *)application
                                                 reply:(void (^)(void))reply;
 
+/**
+ Wraps the private -[XCAXClient_iOS notifyWhenEventLoopIsIdleForApplication:reply:],
+ used to check run loop responsiveness before a snapshot request (#1210).
+ `reply` may fire more than once per call; `error` is non-nil only if monitoring
+ itself could not be started.
+ */
+- (void)notifyWhenEventLoopIsIdleForApplication:(XCUIApplication *)application
+                                           reply:(void (^)(id _Nullable result, NSError * _Nullable error))reply;
+
 - (nullable NSDictionary *)attributesForElement:(id<FBXCAccessibilityElement>)element
                                      attributes:(NSArray *)attributes
                                           error:(NSError**)error;

package/WebDriverAgentLib/Utilities/FBXCAXClientProxy.m

@@ -81,6 +81,12 @@ static id FBAXClient = nil;
   [FBAXClient notifyWhenNoAnimationsAreActiveForApplication:application reply:reply];
 }
 
+- (void)notifyWhenEventLoopIsIdleForApplication:(XCUIApplication *)application
+                                           reply:(void (^)(id _Nullable result, NSError * _Nullable error))reply
+{
+  [FBAXClient notifyWhenEventLoopIsIdleForApplication:application reply:reply];
+}
+
 - (NSDictionary *)attributesForElement:(id<FBXCAccessibilityElement>)element
                             attributes:(NSArray *)attributes
                                  error:(NSError**)error;
@@ -92,28 +98,30 @@ static id FBAXClient = nil;
 
 - (XCUIApplication *)monitoredApplicationWithProcessIdentifier:(int)pid
 {
-  NSMutableSet *terminatedAppIds = [NSMutableSet set];
-  for (NSNumber *appPid in self.appsCache) {
-    if (![self.appsCache[appPid] running]) {
-      [terminatedAppIds addObject:appPid];
+  @synchronized (self) {
+    NSMutableSet *terminatedAppIds = [NSMutableSet set];
+    for (NSNumber *appPid in self.appsCache) {
+      if (![self.appsCache[appPid] running]) {
+        [terminatedAppIds addObject:appPid];
+      }
+    }
+    for (NSNumber *appPid in terminatedAppIds) {
+      [self.appsCache removeObjectForKey:appPid];
     }
-  }
-  for (NSNumber *appPid in terminatedAppIds) {
-    [self.appsCache removeObjectForKey:appPid];
-  }
 
-  XCUIApplication *result = [self.appsCache objectForKey:@(pid)];
-  if (nil != result) {
-    return result;
-  }
+    XCUIApplication *result = [self.appsCache objectForKey:@(pid)];
+    if (nil != result) {
+      return result;
+    }
 
-  XCUIApplication *app = [[FBAXClient applicationProcessTracker]
-                          monitoredApplicationWithProcessIdentifier:pid];
-  if (nil == app) {
-    return nil;
+    XCUIApplication *app = [[FBAXClient applicationProcessTracker]
+                            monitoredApplicationWithProcessIdentifier:pid];
+    if (nil == app) {
+      return nil;
+    }
+    [self.appsCache setObject:app forKey:@(pid)];
+    return app;
   }
-  [self.appsCache setObject:app forKey:@(pid)];
-  return app;
 }
 
 @end

package/WebDriverAgentLib/Utilities/FBXCTestDaemonsProxy.m

@@ -23,6 +23,7 @@
 #import "XCUIDevice.h"
 
 #define LAUNCH_APP_TIMEOUT_SEC 300
+#define STOP_SCREEN_RECORDING_TIMEOUT_SEC 20
 
 static void (*originalLaunchAppMethod)(id, SEL, NSString*, NSString*, NSArray*, NSDictionary*, void (^)(_Bool, NSError *));
 
@@ -342,14 +343,16 @@ static void swizzledLaunchApp(id self, SEL _cmd, NSString *path, NSString *bundl
   }
 
   __block NSError *innerError = nil;
-  [FBRunLoopSpinner spinUntilCompletion:^(void(^completion)(void)){
-    [session stopScreenRecordingWithUUID:uuid withReply:^(NSError *invokeError) {
-      if (nil != invokeError) {
-        innerError = invokeError;
-      }
-      completion();
-    }];
+  dispatch_semaphore_t sem = dispatch_semaphore_create(0);
+  [session stopScreenRecordingWithUUID:uuid withReply:^(NSError *invokeError) {
+    innerError = invokeError;
+    dispatch_semaphore_signal(sem);
   }];
+  int64_t timeoutNs = (int64_t)(STOP_SCREEN_RECORDING_TIMEOUT_SEC * NSEC_PER_SEC);
+  if (0 != dispatch_semaphore_wait(sem, dispatch_time(DISPATCH_TIME_NOW, timeoutNs)) && nil == innerError) {
+    NSString *message = [NSString stringWithFormat:@"Did not receive a reply to stop screen recording within %d seconds", STOP_SCREEN_RECORDING_TIMEOUT_SEC];
+    innerError = [[[FBErrorBuilder builder] withDescription:message] build];
+  }
   if (nil != innerError && error) {
     *error = innerError;
   }

package/WebDriverAgentLib/Utilities/FBXCodeCompatibility.m

@@ -77,32 +77,53 @@
 
 @end
 
+#define TESTMANAGERD_VERSION_TIMEOUT_SEC 20
+
 NSInteger FBTestmanagerdVersion(void)
 {
-  static dispatch_once_t getTestmanagerdVersion;
-  static NSInteger testmanagerdVersion;
-  dispatch_once(&getTestmanagerdVersion, ^{
+  // Not dispatch_once: that would permanently cache the timeout fallback below if the first call's
+  // reply merely arrived late. -1 means "not yet determined"; a timeout isn't cached, so it retries.
+  static NSInteger cachedVersion = -1;
+  static dispatch_queue_t syncQueue;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    syncQueue = dispatch_queue_create("com.facebook.wda.testmanagerdVersion", DISPATCH_QUEUE_SERIAL);
+  });
+
+  __block NSInteger result;
+  dispatch_sync(syncQueue, ^{
+    if (cachedVersion >= 0) {
+      result = cachedVersion;
+      return;
+    }
+
     id<XCTMessagingChannel_RunnerToDaemon> proxy = [FBXCTestDaemonsProxy testRunnerProxy];
     if ([(NSObject *)proxy respondsToSelector:@selector(_XCT_exchangeProtocolVersion:reply:)]) {
       id<FBXCTestManagerLegacyProtocolVersionExchanging> legacyProxy = (id<FBXCTestManagerLegacyProtocolVersionExchanging>)proxy;
-      [FBRunLoopSpinner spinUntilCompletion:^(void(^completion)(void)){
-        [legacyProxy _XCT_exchangeProtocolVersion:testmanagerdVersion reply:^(unsigned long long code) {
-          testmanagerdVersion = (NSInteger) code;
-          completion();
-        }];
+      __block NSInteger receivedVersion = -1;
+      dispatch_semaphore_t sem = dispatch_semaphore_create(0);
+      [legacyProxy _XCT_exchangeProtocolVersion:0 reply:^(unsigned long long code) {
+        receivedVersion = (NSInteger) code;
+        dispatch_semaphore_signal(sem);
       }];
+      int64_t timeoutNs = (int64_t)(TESTMANAGERD_VERSION_TIMEOUT_SEC * NSEC_PER_SEC);
+      if (0 != dispatch_semaphore_wait(sem, dispatch_time(DISPATCH_TIME_NOW, timeoutNs))) {
+        // Assume newest/full-featured on timeout, but don't cache it - retry on the next call.
+        [FBLogger logFmt:@"Did not receive a testmanagerd protocol version reply within %d seconds; assuming the newest/full-featured protocol", TESTMANAGERD_VERSION_TIMEOUT_SEC];
+        result = 0xFFFF;
+        return;
+      }
+      result = receivedVersion;
     } else {
-      // Modern testmanagerd (Xcode 15+) has already negotiated named XCTCapabilities by the time
-      // a daemon session exists, instead of a single scalar protocol version. There is no direct
-      // integer equivalent to report here (this value is diagnostic-only, surfaced via the
-      // 'testmanagerdVersion' session capability), so keep reporting the existing "assume
-      // newest/full-featured" sentinel, while confirming capabilities did negotiate successfully.
+      // Modern testmanagerd (Xcode 15+) negotiates named XCTCapabilities instead of a scalar
+      // version; there's no direct integer equivalent, so just confirm capabilities negotiated.
       XCTCapabilities *capabilities = [XCTRunnerDaemonSession sharedSession].remoteInterfaceCapabilities;
       if (nil == capabilities) {
         [FBLogger log:@"Could not retrieve testmanagerd capabilities"];
       }
-      testmanagerdVersion = 0xFFFF;
+      result = 0xFFFF;
     }
+    cachedVersion = result;
   });
-  return testmanagerdVersion;
+  return result;
 }

package/WebDriverAgentTests/IntegrationApp/Classes/ViewController.m

@@ -38,9 +38,10 @@
 
 - (IBAction)deadlockApp:(id)sender
 {
-  dispatch_sync(dispatch_get_main_queue(), ^{
-    // This will never execute
-  });
+  // A self dispatch_sync would trip the OS watchdog and get the process
+  // killed outright. Sleeping instead simulates an app that stops answering
+  // accessibility requests while staying alive, per #1210.
+  [NSThread sleepForTimeInterval:20.0];
 }
 
 - (IBAction)didTapButton:(UIButton *)button

package/WebDriverAgentTests/IntegrationApp/Resources/Base.lproj/Main.storyboard

@@ -38,7 +38,6 @@
                                 <state key="normal" title="Deadlock app"/>
                                 <connections>
                                     <action selector="deadlockApp:" destination="BYZ-38-t0r" eventType="touchUpInside" id="53X-DJ-KNY"/>
-                                    <action selector="showAlert:" destination="BYZ-38-t0r" eventType="touchUpInside" id="FEN-VX-MMc"/>
                                 </connections>
                             </button>
                             <button opaque="NO" contentMode="scaleToFill" contentHorizontalAlignment="center" contentVerticalAlignment="center" buttonType="system" lineBreakMode="middleTruncation" translatesAutoresizingMaskIntoConstraints="NO" id="M2N-Yn-ytb">

package/WebDriverAgentTests/IntegrationTests/FBConfigurationTests.m

@@ -11,6 +11,9 @@
 
 #import "FBConfiguration.h"
 #import "FBRuntimeUtils.h"
+#import "FBTestMacros.h"
+#import "XCUIElement.h"
+#import "XCUIElement+FBIsVisible.h"
 
 @interface FBConfigurationTests : FBIntegrationTestCase
 
@@ -35,4 +38,35 @@
   XCTAssertEqual(FBConfiguration.sharedInstance.reduceMotionEnabled, defaultReduceMotionEnabled);
 }
 
+- (void)testAccessibilityDeadlineAbortsSnapshotRequestForDeadlockedApp
+{
+  if (nil != NSProcessInfo.processInfo.environment[@"CI"]) {
+    XCTSkip(@"Deliberately freezes the app for several seconds, too slow/flaky for CI");
+  }
+
+  NSTimeInterval previousDeadline = FBConfiguration.sharedInstance.accessibilityDeadline;
+  // Also bounds any snapshot-based wait -tap itself may perform once the app is stuck.
+  FBConfiguration.sharedInstance.accessibilityDeadline = 3.0;
+  @try {
+    XCUIElement *deadlockButton = self.testedApplication.buttons[@"Deadlock app"];
+    FBAssertWaitTillBecomesTrue(deadlockButton.fb_isVisible);
+    // Freezes the app's main thread for 20s - see -[ViewController deadlockApp:].
+    [deadlockButton tap];
+
+    NSError *error;
+    NSDate *start = [NSDate date];
+    id snapshot = [self.testedApplication snapshotWithError:&error];
+    NSTimeInterval elapsed = -start.timeIntervalSinceNow;
+
+    XCTAssertNil(snapshot);
+    XCTAssertNotNil(error);
+    // Should abort close to accessibilityDeadline (plus XCTest's own internal
+    // retries), not hang indefinitely waiting for the frozen app (#1210).
+    XCTAssertLessThan(elapsed, 20.0);
+  } @finally {
+    FBConfiguration.sharedInstance.accessibilityDeadline = previousDeadline;
+    [self.testedApplication terminate];
+  }
+}
+
 @end

package/package.json

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