appium-webdriveragent 16.10.0 → 16.11.1

package/CHANGELOG.md

@@ -1,3 +1,15 @@
+## [16.11.1](https://github.com/appium/WebDriverAgent/compare/v16.11.0...v16.11.1) (2026-08-29)
+
+### Bug Fixes
+
+* build of FBMjpegServer ([#1239](https://github.com/appium/WebDriverAgent/issues/1239)) ([a3b8650](https://github.com/appium/WebDriverAgent/commit/a3b8650670b9b30c5fc0cd5aa4834a6774d4a828))
+
+## [16.11.0](https://github.com/appium/WebDriverAgent/compare/v16.10.0...v16.11.0) (2026-08-29)
+
+### Features
+
+* expose AXTimeout and XCTest XPC request timeout wrappers  ([#1233](https://github.com/appium/WebDriverAgent/issues/1233)) ([d5c8571](https://github.com/appium/WebDriverAgent/commit/d5c85718c32bc495a0f73518d3e40eee624b3582))
+
 ## [16.10.0](https://github.com/appium/WebDriverAgent/compare/v16.9.4...v16.10.0) (2026-08-29)
 
 ### Features

package/PrivateHeaders/XCTest/CDStructures.h

@@ -2,4 +2,6 @@
 #pragma clang diagnostic ignored "-Wreserved-identifier"
 int _XCTSetApplicationStateTimeout(double timeout);
 double _XCTApplicationStateTimeout(void);
+void _XCTSetXPCRequestTimeout(double timeout);
+double _XCTXPCRequestTimeout(void);
 #pragma clang diagnostic pop

package/WebDriverAgent.xcodeproj/project.pbxproj

@@ -1158,6 +1158,7 @@
 		EE3A18661CDE734B00DE4205 /* FBKeyboard.h in Headers */ = {isa = PBXBuildFile; fileRef = EE3A18641CDE734B00DE4205 /* FBKeyboard.h */; settings = {ATTRIBUTES = (Public, ); }; };
 		EE3A18671CDE734B00DE4205 /* FBKeyboard.m in Sources */ = {isa = PBXBuildFile; fileRef = EE3A18651CDE734B00DE4205 /* FBKeyboard.m */; };
 		EE3F8CFE1D08AA17006F02CE /* FBRunLoopSpinnerTests.m in Sources */ = {isa = PBXBuildFile; fileRef = EE3F8CFD1D08AA17006F02CE /* FBRunLoopSpinnerTests.m */; };
+		A09D847635CA4C155583B967 /* FBXCAXClientProxyTests.m in Sources */ = {isa = PBXBuildFile; fileRef = 6231A764C3FAAB29B87CD987 /* FBXCAXClientProxyTests.m */; };
 		EE3F8D001D08B05F006F02CE /* FBElementTypeTransformerTests.m in Sources */ = {isa = PBXBuildFile; fileRef = EE3F8CFF1D08B05F006F02CE /* FBElementTypeTransformerTests.m */; };
 		EE5095E51EBCC9090028E2FE /* FBTypingTest.m in Sources */ = {isa = PBXBuildFile; fileRef = AD76723F1D6B826F00610457 /* FBTypingTest.m */; };
 		EE5095EB1EBCC9090028E2FE /* XCElementSnapshotHitPointTests.m in Sources */ = {isa = PBXBuildFile; fileRef = EE006EB21EBA1C7B006900A4 /* XCElementSnapshotHitPointTests.m */; };
@@ -1827,6 +1828,7 @@
 		EE3A18641CDE734B00DE4205 /* FBKeyboard.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = FBKeyboard.h; path = WebDriverAgentLib/Utilities/FBKeyboard.h; sourceTree = SOURCE_ROOT; };
 		EE3A18651CDE734B00DE4205 /* FBKeyboard.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; name = FBKeyboard.m; path = WebDriverAgentLib/Utilities/FBKeyboard.m; sourceTree = SOURCE_ROOT; };
 		EE3F8CFD1D08AA17006F02CE /* FBRunLoopSpinnerTests.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = FBRunLoopSpinnerTests.m; sourceTree = "<group>"; };
+		6231A764C3FAAB29B87CD987 /* FBXCAXClientProxyTests.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = FBXCAXClientProxyTests.m; sourceTree = "<group>"; };
 		EE3F8CFF1D08B05F006F02CE /* FBElementTypeTransformerTests.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = FBElementTypeTransformerTests.m; sourceTree = "<group>"; };
 		EE5095FE1EBCC9090028E2FE /* IntegrationTests_2.xctest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = IntegrationTests_2.xctest; sourceTree = BUILT_PRODUCTS_DIR; };
 		EE55B3221D1D5388003AAAEC /* FBTableDataSource.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = FBTableDataSource.h; sourceTree = "<group>"; };
@@ -2683,6 +2685,7 @@
 				ADEF63AE1D09DEBE0070A7E3 /* FBRuntimeUtilsTests.m */,
 				714801D01FA9D9FA00DC5997 /* FBSDKVersionTests.m */,
 				EE6A89251D0B19E60083E92B /* FBSessionTests.m */,
+				6231A764C3FAAB29B87CD987 /* FBXCAXClientProxyTests.m */,
 				716E0BD01E917F260087A825 /* FBXMLSafeStringTests.m */,
 				712A0C841DA3E459007D02E5 /* FBXPathTests.m */,
 				EE9B76581CF7987300275851 /* Info.plist */,
@@ -4802,6 +4805,7 @@
 			files = (
 				713352FD26CEF31D00523CBC /* FBLRUCacheTests.m in Sources */,
 				EE3F8CFE1D08AA17006F02CE /* FBRunLoopSpinnerTests.m in Sources */,
+				A09D847635CA4C155583B967 /* FBXCAXClientProxyTests.m in Sources */,
 				714801D11FA9D9FA00DC5997 /* FBSDKVersionTests.m in Sources */,
 				EE3F8D001D08B05F006F02CE /* FBElementTypeTransformerTests.m in Sources */,
 				13FFF2F2287DBEE600E561E4 /* XCElementSnapshotDouble.m in Sources */,

package/WebDriverAgentLib/Categories/XCUIApplicationProcess+FBQuiescence.m

@@ -10,11 +10,11 @@
 
 #import <objc/runtime.h>
 
-#import "CDStructures.h"
 #import "FBConfiguration.h"
 #import "FBExceptions.h"
 #import "FBLogger.h"
 #import "FBSettings.h"
+#import "FBXCAXClientProxy.h"
 
 static void (*original_waitForQuiescenceIncludingAnimationsIdle)(id, SEL, BOOL);
 static void (*original_waitForQuiescenceIncludingAnimationsIdlePreEvent)(id, SEL, BOOL, BOOL);
@@ -29,15 +29,11 @@ static void swizzledWaitForQuiescenceIncludingAnimationsIdle(id self, SEL _cmd,
   }
 
   NSTimeInterval desiredTimeout = FBConfiguration.sharedInstance.waitForIdleTimeout;
-  NSTimeInterval previousTimeout = _XCTApplicationStateTimeout();
-  _XCTSetApplicationStateTimeout(desiredTimeout);
   [FBLogger logFmt:@"Waiting up to %@s until %@ is in idle state (%@ animations)",
    @(desiredTimeout), bundleId, includingAnimations ? @"including" : @"excluding"];
-  @try {
+  [FBXCAXClientProxy withApplicationStateTimeout:desiredTimeout do:^{
     original_waitForQuiescenceIncludingAnimationsIdle(self, _cmd, includingAnimations);
-  } @finally {
-    _XCTSetApplicationStateTimeout(previousTimeout);
-  }
+  }];
 }
 
 static void swizzledWaitForQuiescenceIncludingAnimationsIdlePreEvent(id self, SEL _cmd, BOOL includingAnimations, BOOL isPreEvent)
@@ -50,15 +46,11 @@ static void swizzledWaitForQuiescenceIncludingAnimationsIdlePreEvent(id self, SE
   }
 
   NSTimeInterval desiredTimeout = FBConfiguration.sharedInstance.waitForIdleTimeout;
-  NSTimeInterval previousTimeout = _XCTApplicationStateTimeout();
-  _XCTSetApplicationStateTimeout(desiredTimeout);
   [FBLogger logFmt:@"Waiting up to %@s until %@ is in idle state (%@ animations)",
    @(desiredTimeout), bundleId, includingAnimations ? @"including" : @"excluding"];
-  @try {
+  [FBXCAXClientProxy withApplicationStateTimeout:desiredTimeout do:^{
     original_waitForQuiescenceIncludingAnimationsIdlePreEvent(self, _cmd, includingAnimations, isPreEvent);
-  } @finally {
-    _XCTSetApplicationStateTimeout(previousTimeout);
-  }
+  }];
 }
 
 @implementation XCUIApplicationProcess (FBQuiescence)

package/WebDriverAgentLib/Commands/FBSessionCommands.m

@@ -22,6 +22,7 @@
 #import "FBSettings.h"
 #import "FBSettingsHandler.h"
 #import "FBRuntimeUtils.h"
+#import "FBXCAXClientProxy.h"
 #import "FBXCodeCompatibility.h"
 #import "XCUIApplication+FBHelpers.h"
 #import "XCUIApplication+FBQuiescence.h"
@@ -376,18 +377,22 @@
       return errorResponse;
     }
   } else {
-    NSTimeInterval defaultTimeout = _XCTApplicationStateTimeout();
+    __block id<FBResponsePayload> launchErrorResponse;
+    void (^launchBlock)(void) = ^{
+      @try {
+        [app launch];
+      } @catch (NSException *e) {
+        launchErrorResponse = FBResponseWithStatus([FBCommandStatus sessionNotCreatedError:e.reason traceback:nil]);
+      }
+    };
     if (nil != capabilities[FB_CAP_APP_LAUNCH_STATE_TIMEOUT_SEC]) {
-      _XCTSetApplicationStateTimeout([capabilities[FB_CAP_APP_LAUNCH_STATE_TIMEOUT_SEC] doubleValue]);
+      [FBXCAXClientProxy withApplicationStateTimeout:[capabilities[FB_CAP_APP_LAUNCH_STATE_TIMEOUT_SEC] doubleValue]
+                                                   do:launchBlock];
+    } else {
+      launchBlock();
     }
-    @try {
-      [app launch];
-    } @catch (NSException *e) {
-      return FBResponseWithStatus([FBCommandStatus sessionNotCreatedError:e.reason traceback:nil]);
-    } @finally {
-      if (nil != capabilities[FB_CAP_APP_LAUNCH_STATE_TIMEOUT_SEC]) {
-        _XCTSetApplicationStateTimeout(defaultTimeout);
-      }
+    if (nil != launchErrorResponse) {
+      return launchErrorResponse;
     }
   }
 
@@ -486,12 +491,9 @@
                               withApplication:(nullable NSString *)bundleID
                                       timeout:(nullable NSNumber *)timeout
 {
-  NSError *openError;
-  NSTimeInterval defaultTimeout = _XCTApplicationStateTimeout();
-  if (nil != timeout) {
-    _XCTSetApplicationStateTimeout([timeout doubleValue]);
-  }
-  @try {
+  __block id<FBResponsePayload> response;
+  void (^openBlock)(void) = ^{
+    NSError *openError;
     BOOL result = nil == bundleID
       ? [XCUIDevice.sharedDevice fb_openUrl:initialUrl
                                       error:&openError]
@@ -499,16 +501,18 @@
                             withApplication:(id)bundleID
                                       error:&openError];
     if (result) {
-      return nil;
+      return;
     }
     NSString *errorMsg = [NSString stringWithFormat:@"Cannot open the URL %@ with the %@ application. Original error: %@",
                           initialUrl, bundleID ?: @"default", openError.localizedDescription];
-    return FBResponseWithStatus([FBCommandStatus sessionNotCreatedError:errorMsg traceback:nil]);
-  } @finally {
-    if (nil != timeout) {
-      _XCTSetApplicationStateTimeout(defaultTimeout);
-    }
+    response = FBResponseWithStatus([FBCommandStatus sessionNotCreatedError:errorMsg traceback:nil]);
+  };
+  if (nil != timeout) {
+    [FBXCAXClientProxy withApplicationStateTimeout:[timeout doubleValue] do:openBlock];
+  } else {
+    openBlock();
   }
+  return response;
 }
 
 @end

package/WebDriverAgentLib/Info.plist

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

package/WebDriverAgentLib/Utilities/FBMjpegServer.m

@@ -165,7 +165,7 @@ static NSUInteger FBNormalizedMjpegFramerate(NSUInteger framerate)
         continue;
       }
       [self.pendingFrameCounts setObject:@(pendingFrames + 1) forKey:client];
-      [self.socket writeData:chunk toClient:client completion:^{
+      [self.socket writeData:chunk toClient:client completion:^(BOOL didSucceed) {
         __strong typeof(weakSelf) strongSelf = weakSelf;
         if (nil == strongSelf) {
           return;

package/WebDriverAgentLib/Utilities/FBXCAXClientProxy.h

@@ -22,8 +22,6 @@ NS_ASSUME_NONNULL_BEGIN
 
 + (instancetype)sharedClient;
 
-- (BOOL)setAXTimeout:(NSTimeInterval)timeout error:(NSError **)error;
-
 - (nullable id<FBXCElementSnapshot>)snapshotForElement:(id<FBXCAccessibilityElement>)element
                                             attributes:(nullable NSArray<NSString *> *)attributes
                                                inDepth:(BOOL)inDepth
@@ -53,6 +51,121 @@ NS_ASSUME_NONNULL_BEGIN
 
 - (nullable XCUIApplication *)monitoredApplicationWithProcessIdentifier:(int)pid;
 
+/**
+ Runs `block` synchronously with AXTimeout (the "AXTimeout" property of
+ XCAXClient_iOS/XCUIAccessibilityInterface, backed by the private `_XCTAXIPCTimeout`
+ global) temporarily set to `timeout`, restoring the previous value once `block`
+ returns (even if it throws). Bounds how long a single accessibility (AX) request
+ issued by this process is allowed to wait for a reply from the AX server. Every
+ AX-backed call funneled through this proxy - systemApplication, activeApplications,
+ snapshotForElement:..., attributesForElement:... - is an in-process call into
+ XCAXClient_iOS and is bounded by this single, process-wide value; there is no
+ per-call override. Defaults to 60 seconds.
+
+ These XCAXClient_iOS calls are themselves wrapped in
+ `+[XCTFuture futureWithTimeout:description:block:]`, but that wrapper's own timeout
+ is `_XCTAXClientWrapperTimeout()` - AXTimeout plus a fixed 5-second margin, not
+ +withXPCRequestTimeout:do:'s `_XCTXPCRequestTimeout`. That margin exists so the AX
+ layer's own timeout has a chance to fire and produce a clean error before XCTFuture's
+ wrapper would cut if off anyway; it is not independently tunable. AXTimeout is
+ therefore the only knob that matters for every call this proxy wraps.
+
+ Important: this only bounds how long the CALLING thread waits for a reply. The AX
+ server itself is not told to cancel the request when this timeout elapses - the
+ request keeps running/queued on the AX side regardless of whether this process gave
+ up waiting on it. All AX requests from this process share one serial channel to the
+ AX server, so if the target app's UI is genuinely unresponsive, lowering this value
+ does not reduce the amount of queued work or make the server itself more responsive -
+ it only makes each individual caller give up sooner, while requests already abandoned
+ by their callers keep occupying the channel and can still delay whatever is queued
+ behind them by their original, un-shortened duration.
+
+ The whole scope is serialized behind a dedicated lock, so overlapping calls from
+ different threads nest/queue instead of racing to restore the global.
+
+ If installing `timeout` fails, `block` is not run, this returns NO, and `error` (if
+ given) is populated with the underlying failure. A failure while restoring the
+ previous value is logged and reported via `error` independently of the return value,
+ which always reflects `block`'s completion, sampled immediately after it returns and
+ before the restore attempt.
+ */
+- (BOOL)withAXTimeout:(NSTimeInterval)timeout do:(void (^)(void))block error:(NSError **)error;
+
+/**
+ Runs `block` synchronously with the XCTest automation-session XPC request timeout
+ (the private `_XCTXPCRequestTimeout`/`_XCTSetXPCRequestTimeout` globals) temporarily
+ set to `timeout`, restoring the previous value once `block` returns (even if it
+ throws). Defaults to 30 seconds.
+
+ This does NOT bound anything else in this proxy - despite the similar shape, it is
+ not the XCTest-level analog of -withAXTimeout:do: for the calls above. AXTimeout and
+ the XPC request timeout gate two structurally different, non-nested call paths:
+ XCAXClient_iOS (what this proxy wraps) makes its AX-server round trips in-process,
+ bounded solely by AXTimeout (see -withAXTimeout:do:); XCTRunnerAutomationSession -
+ a separate class WDA does not go through here - makes its calls over a real
+ NSXPCConnection (`remoteObjectProxyWithErrorHandler:`) to another process, bounded by
+ this timeout instead. `-[XCTRunnerAutomationSession matchesForQuery:error:]` (the
+ primitive behind XCUIElementQuery/most element-finding lookups) and that class's own,
+ identically-named `attributesForElement:attributes:error:` are the calls this timeout
+ actually bounds - not -[XCAXClient_iOS attributesForElement:attributes:error:] above.
+
+ `futureWithTimeout:description:block:` is a synchronous wait wrapper: it starts the
+ real (asynchronous) XPC request and blocks the calling thread until either the reply
+ arrives or this timeout elapses, then returns either way - but elapsing the timeout
+ does NOT cancel the underlying XPC request. It keeps running to completion on the
+ same serial channel regardless of whether anyone is still waiting on it.
+
+ Practical consequence: all XPC-bounded requests from this process share one queue to
+ the automation session. If the target app's main thread/run loop is genuinely stuck,
+ lowering this timeout does not shrink the backlog or make the target more responsive
+ - it only makes the CALLER give up sooner. A request issued right after an earlier
+ one "times out" still has to wait behind that earlier request's real completion (which
+ keeps consuming the channel in the background), so it can take just as long, or longer,
+ to be serviced - repeatedly retrying after a timeout adds more queued work rather than
+ freeing up the channel, and can never be used to reliably bound end-to-end latency
+ while the target is unresponsive.
+
+ A class-level method: it only touches the XPC request timeout global, never the AX
+ client, so calling it does not trigger AX subsystem initialization. The scope is
+ serialized behind a dedicated lock, so overlapping calls nest/queue instead of racing
+ to restore the global. The returned completion result is sampled immediately after
+ `block` returns and before the previous value is restored.
+
+ Returns YES if `block` returned within `timeout`, NO otherwise.
+ */
++ (BOOL)withXPCRequestTimeout:(NSTimeInterval)timeout do:(void (^)(void))block;
+
+/**
+ Runs `block` synchronously with the XCTest application-state timeout (the private
+ `_XCTApplicationStateTimeout`/`_XCTSetApplicationStateTimeout` globals) temporarily
+ set to `timeout`, restoring the previous value once `block` returns (even if it
+ throws). Defaults to 60 seconds, though it may be pre-seeded once from a
+ NSUserDefaults override the first time it is read, before any of this process's own
+ +withApplicationStateTimeout:do: calls run.
+
+ Unlike AXTimeout/the XPC request timeout above, this one is not scoped to a single
+ request/response round trip - it bounds `[XCTWaiter waitForExpectations:timeout:]`
+ inside `-[XCUIApplicationProcess waitForQuiescenceIncludingAnimationsIdle:...]`,
+ which WDA's own XCUIApplicationProcess+FBQuiescence.m swizzle already targets for the
+ per-tap pre/post-event quiescence wait. That wait is gated by a *compound OR*
+ expectation over two independently-notified flags - `eventLoopHasIdled` and (when
+ requested) `animationsHaveFinished` - so it can return as soon as either one changes,
+ not necessarily both; this timeout only bounds how long that race is allowed to run
+ before giving up on both. The same global also bounds XCTest's app-launch/foreground
+ state-transition waits (see -[FBSessionCommands launchApplication:...],
+ +[FBSessionCommands openDeepLink:withApplication:timeout:]), which are a different,
+ non-quiescence consumer of this same timeout.
+
+ A class-level method: it only touches the application-state timeout global, never the
+ AX client, so calling it does not trigger AX subsystem initialization. The scope is
+ serialized behind a dedicated lock, so overlapping calls nest/queue instead of racing
+ to restore the global. The returned completion result is sampled immediately after
+ `block` returns and before the previous value is restored.
+
+ Returns YES if `block` returned within `timeout`, NO otherwise.
+ */
++ (BOOL)withApplicationStateTimeout:(NSTimeInterval)timeout do:(void (^)(void))block;
+
 @end
 
 NS_ASSUME_NONNULL_END

package/WebDriverAgentLib/Utilities/FBXCAXClientProxy.m

@@ -8,6 +8,7 @@
 
 #import "FBXCAXClientProxy.h"
 
+#import "CDStructures.h"
 #import "FBXCAccessibilityElement.h"
 #import "FBLogger.h"
 #import "FBMacros.h"
@@ -17,6 +18,39 @@
 
 static id FBAXClient = nil;
 
+// Guards -withAXTimeout:do:'s save/set/restore of the process-wide AXTimeout global.
+static NSRecursiveLock *FBAXTimeoutLock(void)
+{
+  static NSRecursiveLock *lock;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    lock = [NSRecursiveLock new];
+  });
+  return lock;
+}
+
+// Guards +withXPCRequestTimeout:do:'s save/set/restore of the process-wide XPC request timeout global.
+static NSRecursiveLock *FBXPCRequestTimeoutLock(void)
+{
+  static NSRecursiveLock *lock;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    lock = [NSRecursiveLock new];
+  });
+  return lock;
+}
+
+// Guards +withApplicationStateTimeout:do:'s save/set/restore of the process-wide application-state timeout global.
+static NSRecursiveLock *FBApplicationStateTimeoutLock(void)
+{
+  static NSRecursiveLock *lock;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    lock = [NSRecursiveLock new];
+  });
+  return lock;
+}
+
 @interface FBXCAXClientProxy ()
 
 @property (nonatomic) NSMutableDictionary<NSNumber *, XCUIApplication *> *appsCache;
@@ -38,9 +72,80 @@ static id FBAXClient = nil;
   return instance;
 }
 
-- (BOOL)setAXTimeout:(NSTimeInterval)timeout error:(NSError **)error
+- (BOOL)withAXTimeout:(NSTimeInterval)timeout do:(void (^)(void))block error:(NSError **)error
+{
+  NSRecursiveLock *lock = FBAXTimeoutLock();
+  [lock lock];
+  @try {
+    NSTimeInterval previousTimeout = [FBAXClient AXTimeout];
+    NSError *setError;
+    if (![FBAXClient _setAXTimeout:timeout error:&setError]) {
+      [FBLogger logFmt:@"Failed to set AXTimeout to %@: %@", @(timeout), setError];
+      if (nil != error) {
+        *error = setError;
+      }
+      return NO;
+    }
+    NSTimeInterval startTime = NSProcessInfo.processInfo.systemUptime;
+    BOOL completedInTime = NO;
+    @try {
+      block();
+      completedInTime = (NSProcessInfo.processInfo.systemUptime - startTime) < timeout;
+    } @finally {
+      NSError *restoreError;
+      if (![FBAXClient _setAXTimeout:previousTimeout error:&restoreError]) {
+        [FBLogger logFmt:@"Failed to restore AXTimeout to %@: %@", @(previousTimeout), restoreError];
+        if (nil != error) {
+          *error = restoreError;
+        }
+      }
+    }
+    return completedInTime;
+  } @finally {
+    [lock unlock];
+  }
+}
+
++ (BOOL)withXPCRequestTimeout:(NSTimeInterval)timeout do:(void (^)(void))block
+{
+  NSRecursiveLock *lock = FBXPCRequestTimeoutLock();
+  [lock lock];
+  @try {
+    NSTimeInterval previousTimeout = _XCTXPCRequestTimeout();
+    _XCTSetXPCRequestTimeout(timeout);
+    NSTimeInterval startTime = NSProcessInfo.processInfo.systemUptime;
+    BOOL completedInTime = NO;
+    @try {
+      block();
+      completedInTime = (NSProcessInfo.processInfo.systemUptime - startTime) < timeout;
+    } @finally {
+      _XCTSetXPCRequestTimeout(previousTimeout);
+    }
+    return completedInTime;
+  } @finally {
+    [lock unlock];
+  }
+}
+
++ (BOOL)withApplicationStateTimeout:(NSTimeInterval)timeout do:(void (^)(void))block
 {
-  return [FBAXClient _setAXTimeout:timeout error:error];
+  NSRecursiveLock *lock = FBApplicationStateTimeoutLock();
+  [lock lock];
+  @try {
+    NSTimeInterval previousTimeout = _XCTApplicationStateTimeout();
+    _XCTSetApplicationStateTimeout(timeout);
+    NSTimeInterval startTime = NSProcessInfo.processInfo.systemUptime;
+    BOOL completedInTime = NO;
+    @try {
+      block();
+      completedInTime = (NSProcessInfo.processInfo.systemUptime - startTime) < timeout;
+    } @finally {
+      _XCTSetApplicationStateTimeout(previousTimeout);
+    }
+    return completedInTime;
+  } @finally {
+    [lock unlock];
+  }
 }
 
 - (id<FBXCElementSnapshot>)snapshotForElement:(id<FBXCAccessibilityElement>)element

package/WebDriverAgentTests/UnitTests/FBXCAXClientProxyTests.m

@@ -0,0 +1,90 @@
+/**
+ * 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 <XCTest/XCTest.h>
+
+#import "CDStructures.h"
+#import "FBXCAXClientProxy.h"
+
+@interface FBXCAXClientProxyTests : XCTestCase
+@end
+
+@implementation FBXCAXClientProxyTests
+
+- (void)testApplicationStateTimeoutSetsValueDuringBlockAndRestoresAfter
+{
+  double original = _XCTApplicationStateTimeout();
+  __block double observed = -1;
+  BOOL completed = [FBXCAXClientProxy withApplicationStateTimeout:12.5 do:^{
+    observed = _XCTApplicationStateTimeout();
+  }];
+  XCTAssertTrue(completed);
+  XCTAssertEqual(observed, 12.5);
+  XCTAssertEqual(_XCTApplicationStateTimeout(), original);
+}
+
+- (void)testApplicationStateTimeoutNestedCallsRestoreCorrectly
+{
+  double original = _XCTApplicationStateTimeout();
+  [FBXCAXClientProxy withApplicationStateTimeout:20 do:^{
+    XCTAssertEqual(_XCTApplicationStateTimeout(), 20);
+    [FBXCAXClientProxy withApplicationStateTimeout:5 do:^{
+      XCTAssertEqual(_XCTApplicationStateTimeout(), 5);
+    }];
+    XCTAssertEqual(_XCTApplicationStateTimeout(), 20);
+  }];
+  XCTAssertEqual(_XCTApplicationStateTimeout(), original);
+}
+
+- (void)testApplicationStateTimeoutOverlappingCallsRestoreOriginalValue
+{
+  double original = _XCTApplicationStateTimeout();
+  NSInteger iterations = 50;
+  dispatch_group_t group = dispatch_group_create();
+  dispatch_queue_t queue = dispatch_get_global_queue(QOS_CLASS_DEFAULT, 0);
+  for (NSInteger i = 0; i < iterations; i++) {
+    dispatch_group_async(group, queue, ^{
+      [FBXCAXClientProxy withApplicationStateTimeout:10 + (double)i do:^{
+        usleep(500);
+      }];
+    });
+  }
+  dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
+  XCTAssertEqual(_XCTApplicationStateTimeout(), original);
+}
+
+- (void)testXPCRequestTimeoutSetsValueDuringBlockAndRestoresAfter
+{
+  double original = _XCTXPCRequestTimeout();
+  __block double observed = -1;
+  BOOL completed = [FBXCAXClientProxy withXPCRequestTimeout:7.5 do:^{
+    observed = _XCTXPCRequestTimeout();
+  }];
+  XCTAssertTrue(completed);
+  XCTAssertEqual(observed, 7.5);
+  XCTAssertEqual(_XCTXPCRequestTimeout(), original);
+}
+
+- (void)testXPCRequestTimeoutOverlappingCallsRestoreOriginalValue
+{
+  double original = _XCTXPCRequestTimeout();
+  NSInteger iterations = 50;
+  dispatch_group_t group = dispatch_group_create();
+  dispatch_queue_t queue = dispatch_get_global_queue(QOS_CLASS_DEFAULT, 0);
+  for (NSInteger i = 0; i < iterations; i++) {
+    dispatch_group_async(group, queue, ^{
+      [FBXCAXClientProxy withXPCRequestTimeout:10 + (double)i do:^{
+        usleep(500);
+      }];
+    });
+  }
+  dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
+  XCTAssertEqual(_XCTXPCRequestTimeout(), original);
+}
+
+@end

package/package.json

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