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

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

@@ -9,7 +9,8 @@
 #import "FBElementCommands.h"
 
 #import "FBConfiguration.h"
-#import "FBKeyboard.h"
+#import "FBScreen.h"
+#import "XCUIScreen.h"
 #import "FBRoute.h"
 #import "FBRouteRequest.h"
 #import "FBRunLoopSpinner.h"
@@ -22,6 +23,7 @@
 #import "FBRuntimeUtils.h"
 #import "NSPredicate+FBFormat.h"
 #import "XCTestPrivateSymbols.h"
+#import "XCUIApplication+FBTouchAction.h"
 #import "XCUICoordinate.h"
 #import "XCUIDevice.h"
 #import "XCUIElement+FBIsVisible.h"
@@ -370,10 +372,14 @@
   if (nil == endCoordinate) {
     return FBResponseWithStatus([FBCommandStatus invalidElementStateErrorWithMessage:error.description traceback:nil]);
   }
-  [startCoordinate pressForDuration:[request.arguments[@"pressDuration"] doubleValue]
-               thenDragToCoordinate:endCoordinate
-                       withVelocity:[request.arguments[@"velocity"] doubleValue]
-                thenHoldForDuration:[request.arguments[@"holdDuration"] doubleValue]];
+  if (![application fb_pressAtCoordinate:startCoordinate
+                             forDuration:[request.arguments[@"pressDuration"] doubleValue]
+                    thenDragToCoordinate:endCoordinate
+                            withVelocity:[request.arguments[@"velocity"] doubleValue]
+                     thenHoldForDuration:[request.arguments[@"holdDuration"] doubleValue]
+                                   error:&error]) {
+    return FBResponseWithStatus([FBCommandStatus invalidElementStateErrorWithMessage:error.description traceback:nil]);
+  }
   return FBResponseWithOK();
 }
 
@@ -456,7 +462,17 @@
     return FBResponseWithStatus([FBCommandStatus invalidElementStateErrorWithMessage:error.description traceback:nil]);
   }
   NSTimeInterval duration = [request.arguments[@"duration"] doubleValue];
-  [startCoordinate pressForDuration:duration thenDragToCoordinate:endCoordinate];
+  XCUIApplication *application = [target isKindOfClass:XCUIApplication.class]
+    ? (XCUIApplication *)target
+    : target.application;
+  if (![application fb_pressAtCoordinate:startCoordinate
+                             forDuration:duration
+                    thenDragToCoordinate:endCoordinate
+                            withVelocity:XCUIGestureVelocityDefault
+                     thenHoldForDuration:0
+                                   error:&error]) {
+    return FBResponseWithStatus([FBCommandStatus invalidElementStateErrorWithMessage:error.description traceback:nil]);
+  }
   return FBResponseWithOK();
 }
 
@@ -539,6 +555,13 @@
   NSString *textToType = [request.arguments[@"value"] componentsJoinedByString:@""];
   NSUInteger frequency = [request.arguments[@"frequency"] unsignedIntegerValue] ?: FBConfiguration.sharedInstance.maxTypingFrequency;
   NSError *error;
+#if TARGET_OS_IOS
+  NSTimeInterval keyboardWait = FBConfiguration.sharedInstance.keyboardWaitTimeout;
+  if (keyboardWait > 0) {
+    XCUIApplication *application = request.session.activeApplication ?: XCUIApplication.fb_activeApplication;
+    FBWaitForHittableKey(application, keyboardWait);
+  }
+#endif
   if (!FBTypeText(textToType, frequency, &error)) {
     return FBResponseWithStatus([FBCommandStatus invalidElementStateErrorWithMessage:error.description
                                                                            traceback:nil]);
@@ -683,7 +706,34 @@ static const NSInteger DEFAULT_MAX_PICKER_ATTEMPTS = 25;
                                                   element:(XCUIElement *)element
                                                     error:(NSError **)error
 {
-  return FBCoordinateWithAnchorOffset(element, CGVectorMake(0, 0), offset, error);
+  if (element.elementType != XCUIElementTypeApplication) {
+    return FBCoordinateWithAnchorOffset(element, CGVectorMake(0, 0), offset, error);
+  }
+  XCUIScreen *screen = [FBScreen currentScreenWithError:error];
+  if (nil == screen) {
+    return nil;
+  }
+  if (screen.displayID == XCUIScreen.mainScreen.displayID) {
+    return FBCoordinateWithAnchorOffset(element, CGVectorMake(0, 0), offset, error);
+  }
+  // Application-root coordinates are rotated using the main display on Duo.
+  // A window coordinate keeps XCTest's display affinity and rotation intact.
+  // It is only a coordinate anchor, not a hit-test boundary. Preserve edge and
+  // outside offsets just as on the main display; XCTest handles their delivery.
+  CGPoint point = CGPointMake(offset.dx, offset.dy);
+  for (XCUIElement *window in [element childrenMatchingType:XCUIElementTypeWindow].allElementsBoundByIndex) {
+    // Resolve the window before reading its display affinity: an unresolved
+    // element may report displayID == 0.
+    (void)window.frame;
+    CGRect frame = window.wdFrame;
+    if (window.screen.displayID == screen.displayID && !CGRectIsEmpty(frame)) {
+      return FBCoordinateWithAnchorOffset(window, CGVectorMake(0, 0),
+        CGVectorMake(point.x - frame.origin.x, point.y - frame.origin.y), error);
+    }
+  }
+  [[[FBErrorBuilder builder] withDescriptionFormat:@"No non-empty application window on display %lld is available as a coordinate anchor", screen.displayID]
+    buildError:error];
+  return nil;
 }
 
 /**

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

@@ -131,7 +131,8 @@
   [request.session launchApplicationWithBundleId:(id)request.arguments[@"bundleId"]
                          shouldWaitForQuiescence:request.arguments[@"shouldWaitForQuiescence"]
                                        arguments:request.arguments[@"arguments"]
-                                     environment:request.arguments[@"environment"]];
+                                     environment:request.arguments[@"environment"]
+                          asApplicationUnderTest:[request.arguments[@"asAppUnderTest"] boolValue]];
   return FBResponseWithOK();
 }
 
@@ -410,7 +411,7 @@
   if (nil != initialUrl) {
     return [self openDeepLink:initialUrl withApplication:bundleID timeout:nil];
   }
-  [app activate];
+  [app fb_activate];
   return nil;
 }
 

package/drivers/ios/WebDriverAgent/WebDriverAgentLib/Info.plist

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

package/drivers/ios/WebDriverAgent/WebDriverAgentLib/Routing/FBHTTPServer.m

@@ -13,6 +13,7 @@
 #import "FBLogger.h"
 #import "FBResponsePayload.h"
 #import "FBTCPSocket.h"
+#import "FBSession.h"
 
 static NSData *FBCRLFCRLFData(void)
 {
@@ -131,10 +132,6 @@ static BOOL FBParseContentLength(NSString *value, NSUInteger *outLength)
 // standalone or not (except DELETE /session itself - see -dispatchMethod:). See
 // -abandonPendingRequestsForSessionID:. Guarded by @synchronized(self.pendingSessionRequests).
 @property (nonatomic, strong) NSMutableDictionary<NSString *, NSMutableSet<FBPendingRequest *> *> *pendingSessionRequests;
-// Already-abandoned sessions mapped to the response they were abandoned with, so a request parsed
-// after that point is answered at once instead of queueing for a session that is gone. Kept for
-// the server's lifetime; ids are UUIDs. Guarded by @synchronized(self.pendingSessionRequests).
-@property (nonatomic, strong) NSMutableDictionary<NSString *, RouteResponse *> *abandonedSessionResponses;
 // When each connection started waiting for its current request. The reaper closes connections
 // whose entry outlives FBIncompleteRequestTimeout; idle keep-alive connections have no entry and
 // are exempt. Guarded by @synchronized(self.connectionBuffers).
@@ -163,7 +160,6 @@ static const int64_t FBStaleConnectionSweepIntervalSec = 10;
     _connectionsAwaitingResponse = [NSMutableSet set];
     _standaloneWaiters = [NSMutableDictionary dictionary];
     _pendingSessionRequests = [NSMutableDictionary dictionary];
-    _abandonedSessionResponses = [NSMutableDictionary dictionary];
     _incompleteRequestStarts = [NSMapTable mapTableWithKeyOptions:(NSPointerFunctionsOptions)(NSMapTableObjectPointerPersonality | NSMapTableStrongMemory)
                                                      valueOptions:(NSPointerFunctionsOptions)NSMapTableStrongMemory];
   }
@@ -340,12 +336,28 @@ static const int64_t FBStaleConnectionSweepIntervalSec = 10;
 
 - (void)didClientDisconnect:(nw_connection_t)client
 {
-  @synchronized (self.connectionBuffers) {
-    [self.connectionBuffers removeObjectForKey:client];
-    [self.pendingRequestHeaders removeObjectForKey:client];
-    [self.connectionsAwaitingResponse removeObject:client];
-    [self.incompleteRequestStarts removeObjectForKey:client];
-  }
+  // EOF must follow every receive already queued for this client. Otherwise it can
+  // remove the buffer before those bytes have even been appended and parsed.
+  __weak typeof(self) weakSelf = self;
+  dispatch_async(self.bufferProcessingQueue, ^{
+    __strong typeof(weakSelf) strongSelf = weakSelf;
+    if (nil == strongSelf) {
+      nw_connection_cancel(client);
+      return;
+    }
+    BOOL isAwaitingResponse;
+    @synchronized (strongSelf.connectionBuffers) {
+      isAwaitingResponse = [strongSelf.connectionsAwaitingResponse containsObject:client];
+      [strongSelf.connectionBuffers removeObjectForKey:client];
+      [strongSelf.pendingRequestHeaders removeObjectForKey:client];
+      [strongSelf.incompleteRequestStarts removeObjectForKey:client];
+    }
+    // A client that only stopped sending may still read the response to its in-flight request, so
+    // that response's send completion closes the connection instead (it finds no buffer left).
+    if (!isAwaitingResponse) {
+      nw_connection_cancel(client);
+    }
+  });
 }
 
 - (void)client:(nw_connection_t)client didReceiveData:(NSData *)data
@@ -723,9 +735,15 @@ static const int64_t FBStaleConnectionSweepIntervalSec = 10;
 - (nullable RouteResponse *)trackPendingRequest:(FBPendingRequest *)pendingRequest forSessionID:(NSString *)sessionID
 {
   @synchronized (self.pendingSessionRequests) {
-    RouteResponse *abandonedResponse = self.abandonedSessionResponses[sessionID];
-    if (nil != abandonedResponse) {
-      return abandonedResponse;
+    // Checking the current session under this lock closes the admission/teardown
+    // race without retaining a tombstone and a full response for every past UUID.
+    // -kill clears the active session before posting its abandonment notification.
+    if (nil == [FBSession sessionWithIdentifier:sessionID]) {
+      RouteResponse *response = [RouteResponse new];
+      [FBResponseWithStatus([FBCommandStatus noSuchDriverErrorWithMessage:@"Session does not exist"
+                                                               traceback:nil]) dispatchWithResponse:response];
+      [self applyDefaultHeadersToResponse:response];
+      return response;
     }
     NSMutableSet<FBPendingRequest *> *pendingRequests = self.pendingSessionRequests[sessionID];
     if (nil == pendingRequests) {
@@ -760,8 +778,6 @@ static const int64_t FBStaleConnectionSweepIntervalSec = 10;
   @synchronized (self.pendingSessionRequests) {
     pendingRequests = [self.pendingSessionRequests[sessionID] copy];
     [self.pendingSessionRequests removeObjectForKey:sessionID];
-    // Recorded before the lock is dropped, so requests admitted from here on are rejected.
-    self.abandonedSessionResponses[sessionID] = response;
   }
   for (FBPendingRequest *pendingRequest in pendingRequests) {
     [self writeResponse:response toClient:pendingRequest.client];
@@ -881,14 +897,21 @@ static const int64_t FBStaleConnectionSweepIntervalSec = 10;
         if (nil == queuedSelf) {
           return;
         }
+        BOOL isDisconnected;
         @synchronized (queuedSelf.connectionBuffers) {
           [queuedSelf.connectionsAwaitingResponse removeObject:client];
+          isDisconnected = nil == [queuedSelf.connectionBuffers objectForKey:client];
           // Mid-request connections get their window from when parsing could resume, not from the
           // previous request. Absent entries stay absent, so idle keep-alives remain exempt.
           if (nil != [queuedSelf.incompleteRequestStarts objectForKey:client]) {
             [queuedSelf.incompleteRequestStarts setObject:[NSDate date] forKey:client];
           }
         }
+        if (isDisconnected) {
+          // The peer stopped sending while this request was in flight - see -didClientDisconnect:.
+          [queuedSelf closeClient:client];
+          return;
+        }
         [queuedSelf processBufferForClient:client];
       });
     }];

package/drivers/ios/WebDriverAgent/WebDriverAgentLib/Routing/FBScreenRecordingRequest.m

@@ -9,6 +9,7 @@
 #import "FBScreenRecordingRequest.h"
 
 #import "FBErrorBuilder.h"
+#import "FBScreen.h"
 #import "XCUIScreen.h"
 
 @implementation FBScreenRecordingRequest
@@ -56,6 +57,10 @@
 
 - (id)toNativeRequestWithError:(NSError **)error
 {
+  XCUIScreen *screen = [FBScreen currentScreenWithError:error];
+  if (nil == screen) {
+    return nil;
+  }
   Class screenRecordingRequestClass = NSClassFromString(@"XCTScreenRecordingRequest");
   if (nil == screenRecordingRequestClass) {
     [[[FBErrorBuilder builder]
@@ -80,8 +85,8 @@
   NSMethodSignature *screenRecordingRequestContructorSignature = [screenRecordingRequestAllocated methodSignatureForSelector:screenRecordingRequestConstructorSelector];
   NSInvocation *screenRecordingRequestInitInvocation = [NSInvocation invocationWithMethodSignature:screenRecordingRequestContructorSignature];
   [screenRecordingRequestInitInvocation setSelector:screenRecordingRequestConstructorSelector];
-  long long mainScreenId = XCUIScreen.mainScreen.displayID;
-  [screenRecordingRequestInitInvocation setArgument:&mainScreenId atIndex:2];
+  long long screenId = screen.displayID;
+  [screenRecordingRequestInitInvocation setArgument:&screenId atIndex:2];
   CGRect fullScreenRect = CGRectNull;
   [screenRecordingRequestInitInvocation setArgument:&fullScreenRect atIndex:3];
   [screenRecordingRequestInitInvocation setArgument:&videoEncoding atIndex:4];

package/drivers/ios/WebDriverAgent/WebDriverAgentLib/Routing/FBSession.h

@@ -107,6 +107,28 @@ extern NSString* const FBSessionWasKilledNotification;
                                          arguments:(nullable NSArray<NSString *> *)arguments
                                        environment:(nullable NSDictionary <NSString *, NSString *> *)environment;
 
+/**
+ Launch an application with given bundle identifier in scope of current session
+ and optionally make it the application under test of this session.
+
+ @param bundleIdentifier Valid bundle identifier of the application to be launched
+ @param shouldWaitForQuiescence whether to wait for quiescence on application startup.
+ If not provided then the setting of the current application under test is inherited.
+ If there is no application under test yet then quiescence is only awaited if asApplicationUnderTest is YES
+ @param arguments The optional array of application command line arguments. The arguments are going to be applied if the application was not running before.
+ @param environment The optional dictionary of environment variables for the application, which is going to be executed. The environment variables are going to be applied if the application was not running before.
+ @param asApplicationUnderTest If YES then the launched application replaces the current application under test
+ of the session (if any), the same way as if it was launched on session startup: other applications launched later
+ inherit its quiescence setting, system alerts over it are respected, its unexpected termination is reported as a crash
+ and it gets terminated on session deletion if shouldTerminateApp is enabled
+ @return The application instance
+ */
+- (XCUIApplication *)launchApplicationWithBundleId:(NSString *)bundleIdentifier
+                           shouldWaitForQuiescence:(nullable NSNumber *)shouldWaitForQuiescence
+                                         arguments:(nullable NSArray<NSString *> *)arguments
+                                       environment:(nullable NSDictionary <NSString *, NSString *> *)environment
+                            asApplicationUnderTest:(BOOL)asApplicationUnderTest;
+
 /**
  Activate an application with given bundle identifier in scope of current session.
  !This method is only available since Xcode9 SDK

package/drivers/ios/WebDriverAgent/WebDriverAgentLib/Routing/FBSession.m

@@ -24,6 +24,7 @@
 #import "FBXCTestDaemonsProxy.h"
 #import "XCUIApplication+FBQuiescence.h"
 #import "XCUIElement.h"
+#import "XCUIElement+FBUtilities.h"
 
 /*!
  The intial value for the default application property.
@@ -43,13 +44,14 @@ static const NSTimeInterval FB_KILL_WAIT_TIMEOUT_SEC = 35.;
 NSString *const FBSessionWasKilledNotification = @"FBSessionWasKilledNotification";
 
 @interface FBSession ()
-@property (nullable, nonatomic) XCUIApplication *testedApplication;
+// Atomic, since /wda/apps/launch may replace it while a concurrent DELETE /session reads it in -kill
+@property (nullable, atomic) 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;
+- (BOOL)fb_isApplicationSameAsSystemApp:(XCUIApplication *)application timeout:(NSTimeInterval)timeout;
 - (void)fb_terminateTestedApplicationWithTimeout:(NSTimeInterval)timeout generation:(NSUInteger)generation;
 @end
 
@@ -332,7 +334,7 @@ static NSUInteger _committedTerminationCount = 0;
     if (nil != self.testedApplication
         && FBConfiguration.sharedInstance.shouldTerminateApp
         && self.testedApplication.running
-        && ![self fb_isTestedApplicationSameAsSystemAppWithTimeout:FB_IS_SYSTEM_APP_CHECK_TIMEOUT_SEC]) {
+        && ![self fb_isApplicationSameAsSystemApp:self.testedApplication timeout: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:generation: - so it's safe to
       // report this teardown as finished as soon as this returns.
@@ -387,10 +389,42 @@ static NSUInteger _committedTerminationCount = 0;
                                          arguments:(nullable NSArray<NSString *> *)arguments
                                        environment:(nullable NSDictionary <NSString *, NSString *> *)environment
 {
+  return [self launchApplicationWithBundleId:bundleIdentifier
+                     shouldWaitForQuiescence:shouldWaitForQuiescence
+                                   arguments:arguments
+                                 environment:environment
+                      asApplicationUnderTest:NO];
+}
+
+- (XCUIApplication *)launchApplicationWithBundleId:(NSString *)bundleIdentifier
+                           shouldWaitForQuiescence:(nullable NSNumber *)shouldWaitForQuiescence
+                                         arguments:(nullable NSArray<NSString *> *)arguments
+                                       environment:(nullable NSDictionary <NSString *, NSString *> *)environment
+                            asApplicationUnderTest:(BOOL)asApplicationUnderTest
+{
+  NSCondition *condition = self.class.teardownCondition;
+  NSUInteger generation = 0;
+  BOOL shouldTerminateApp = NO;
+  if (asApplicationUnderTest) {
+    [condition lock];
+    BOOL isActive = self == _activeSession;
+    generation = _sessionGeneration;
+    shouldTerminateApp = FBConfiguration.sharedInstance.shouldTerminateApp;
+    [condition unlock];
+    if (!isActive) {
+      @throw [NSException exceptionWithName:FBSessionDoesNotExistException
+                                    reason:@"Session does not exist"
+                                  userInfo:nil];
+    }
+  }
+
   XCUIApplication *app = [self makeApplicationWithBundleId:bundleIdentifier];
   if (nil == shouldWaitForQuiescence) {
-    // Iherit the quiescence check setting from the main app under test by default
-    app.fb_shouldWaitForQuiescence = nil != self.testedApplication && self.shouldAppsWaitForQuiescence;
+    // Iherit the quiescence check setting from the main app under test by default.
+    // The first app under test of the session waits for quiescence, as it would on session startup
+    app.fb_shouldWaitForQuiescence = nil == self.testedApplication
+      ? asApplicationUnderTest
+      : self.shouldAppsWaitForQuiescence;
   } else {
     app.fb_shouldWaitForQuiescence = [shouldWaitForQuiescence boolValue];
   }
@@ -399,7 +433,39 @@ static NSUInteger _committedTerminationCount = 0;
     app.launchEnvironment = environment ?: @{};
     [app launch];
   } else {
-    [app activate];
+    [app fb_activate];
+  }
+  if (asApplicationUnderTest) {
+    BOOL waitForQuiescence = app.fb_shouldWaitForQuiescence;
+    // A DELETE can finish while launch/activate is still waiting for XCTest.
+    // Publish the AUT under the same lock that -kill uses to clear the session.
+    [condition lock];
+    BOOL isActive = self == _activeSession && generation == _sessionGeneration;
+    if (isActive) {
+      self.testedApplication = app;
+      self.shouldAppsWaitForQuiescence = waitForQuiescence;
+    }
+    [condition unlock];
+    if (!isActive) {
+      // The HTTP request may already have been abandoned, but its handler keeps
+      // running. Clean up only while this launch still owns the generation;
+      // a replacement session may already be using the same bundle identifier.
+      if (shouldTerminateApp
+          && ![self fb_isApplicationSameAsSystemApp:app timeout:FB_IS_SYSTEM_APP_CHECK_TIMEOUT_SEC]
+          && [self.class beginTerminationForGeneration:generation]) {
+        @try {
+          [app terminate];
+        } @catch (NSException *e) {
+          [FBLogger logFmt:@"%@", e.description];
+        } @finally {
+          [self.class endTermination];
+        }
+      }
+      @throw [NSException exceptionWithName:FBSessionDoesNotExistException
+                                    reason:@"Session was deleted during application launch"
+                                  userInfo:nil];
+    }
+    [FBLogger logFmt:@"The application '%@' is set as the application under test", bundleIdentifier];
   }
   if ([app fb_isSameAppAs:self.testedApplication]) {
     self.isTestedApplicationExpectedToRun = YES;
@@ -410,7 +476,7 @@ static NSUInteger _committedTerminationCount = 0;
 - (XCUIApplication *)activateApplicationWithBundleId:(NSString *)bundleIdentifier
 {
   XCUIApplication *app = [self makeApplicationWithBundleId:bundleIdentifier];
-  [app activate];
+  [app fb_activate];
   return app;
 }
 
@@ -440,9 +506,9 @@ static NSUInteger _committedTerminationCount = 0;
 }
 
 // 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
+// up after `timeout`, assuming the supplied app IS the system app - safer, since it means skipping
 // termination rather than risking terminating springboard.
-- (BOOL)fb_isTestedApplicationSameAsSystemAppWithTimeout:(NSTimeInterval)timeout
+- (BOOL)fb_isApplicationSameAsSystemApp:(XCUIApplication *)application timeout:(NSTimeInterval)timeout
 {
   __block XCUIApplication *systemApp = nil;
   __block NSException *caughtException = nil;
@@ -451,7 +517,7 @@ static NSUInteger _committedTerminationCount = 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;
+      systemApp = [[application class] fb_systemApplication];
     } @catch (NSException *e) {
       caughtException = e;
     }
@@ -459,10 +525,10 @@ static NSUInteger _committedTerminationCount = 0;
   });
   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];
+    [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], application.bundleID];
     return YES;
   }
-  return [self.testedApplication fb_isSameAppAs:systemApp];
+  return [application fb_isSameAppAs:systemApp];
 }
 
 // -terminate hard-asserts off-main, but -kill can now run on a background queue. Dispatching to

package/drivers/ios/WebDriverAgent/WebDriverAgentLib/Routing/FBTCPSocket.h

@@ -36,7 +36,11 @@ NS_ASSUME_NONNULL_BEGIN
 - (void)client:(nw_connection_t)client didReceiveData:(NSData *)data;
 
 /**
- The callback which is fired when TCP client disconnects
+ The callback which is fired when TCP client disconnects or finishes sending
+
+ A connection that failed is cancelled by the socket. One whose peer only finished sending stays
+ writable (the peer may be awaiting a response), and the delegate must cancel it once it has
+ nothing left to send - an uncancelled connection keeps its socket open.
 
  @param client The actual disconnected client
  */

package/drivers/ios/WebDriverAgent/WebDriverAgentLib/Routing/FBTCPSocket.m

@@ -137,6 +137,8 @@
     } else if (nw_connection_state_failed == state || nw_connection_state_cancelled == state) {
       __strong typeof(weakSelf) strongSelf = weakSelf;
       [strongSelf handleDisconnectForConnection:connection];
+      // A failed connection keeps its socket until cancelled (a no-op once cancelled).
+      nw_connection_cancel(connection);
     }
   });
   nw_connection_start(connection);
@@ -167,7 +169,14 @@
         }
       }
     }
-    if (nil != receiveError || (isComplete && nil == content)) {
+    if (nil != receiveError) {
+      [strongSelf handleDisconnectForConnection:connection];
+      nw_connection_cancel(connection);
+      return;
+    }
+    if (isComplete && nil == content) {
+      // The peer is done sending but may still be reading - a half-closed client awaits its
+      // response - so the delegate cancels the connection once it has nothing left to send.
       [strongSelf handleDisconnectForConnection:connection];
       return;
     }

package/drivers/ios/WebDriverAgent/WebDriverAgentLib/Routing/FBWebServer.m

@@ -133,6 +133,9 @@ static NSString *const FBServerURLEndMarker = @"<-ServerURLHere";
   self.mjpegServer = [[FBMjpegServer alloc] init];
   self.screenshotsBroadcaster = [[FBTCPSocket alloc]
                                  initWithPort:(uint16_t)FBConfiguration.sharedInstance.mjpegServerPort];
+  // Bind to the same address as the HTTP server when USE_IP is set.
+  // nil (the default) keeps listening on all interfaces.
+  self.screenshotsBroadcaster.interface = FBConfiguration.sharedInstance.bindingIPAddress;
   self.mjpegServer.socket = self.screenshotsBroadcaster;
   self.screenshotsBroadcaster.delegate = self.mjpegServer;
   NSError *error;
@@ -265,7 +268,7 @@ static NSString *const FBServerURLEndMarker = @"<-ServerURLHere";
 
 - (void)registerServerKeyRouteHandlers
 {
-  [self.server get:@"/health" withBlock:^(RouteRequest *request, RouteResponse *response) {
+  [self.server handleMethod:@"GET" withPath:@"/health" standalone:YES block:^(RouteRequest *request, RouteResponse *response) {
     [response respondWithString:@"<!DOCTYPE html><html><title>Health Check</title><body><p>I-AM-ALIVE</p></body></html>"];
   }];
 

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

@@ -24,14 +24,14 @@ NS_ASSUME_NONNULL_BEGIN
  * Calculates the accessbility element which is located at the given screen coordinates
  *
  * @param point The screen coordinates
- * @returns The retrieved accessbility element or nil if it cannot be detected
+ * @returns The retrieved accessbility element or nil if it cannot be detected or a secondary display is selected
  */
 + (nullable id<FBXCAccessibilityElement>)axElementWithPoint:(CGPoint)point;
 
 /**
  * Retrieves the accessbility element for the current screen point
  *
- * @returns The retrieved accessbility element or nil if it cannot be detected
+ * @returns The retrieved accessbility element or nil if it cannot be detected or a secondary display is selected
  */
 - (nullable id<FBXCAccessibilityElement>)axElement;
 

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

@@ -13,6 +13,10 @@
 #endif
 
 #import "FBErrorBuilder.h"
+#import "FBScreen.h"
+#import "FBConfiguration.h"
+#import "FBExceptions.h"
+#import "XCUIScreen.h"
 #import "FBLogger.h"
 #import "FBXCTestDaemonsProxy.h"
 #import "XCTMessagingChannel_RunnerToDaemon-Protocol.h"
@@ -45,6 +49,22 @@
 
 + (id<FBXCAccessibilityElement>)axElementWithPoint:(CGPoint)point
 {
+  if (nil != FBConfiguration.sharedInstance.currentDisplayId) {
+    NSError *error;
+    XCUIScreen *screen = [FBScreen currentScreenWithError:&error];
+    if (nil == screen) {
+      @throw [NSException exceptionWithName:FBInvalidArgumentException
+                                    reason:error.localizedDescription
+                                  userInfo:nil];
+    }
+    // XCTest's point lookup has no display parameter and always hits the main
+    // display. On Duo this can select the outer SpringBoard while the app is
+    // foreground on the inner display. Let callers use their active-app fallback
+    // instead of treating an element from a different display as authoritative.
+    if (screen.displayID != XCUIScreen.mainScreen.displayID) {
+      return nil;
+    }
+  }
   __block id<FBXCAccessibilityElement> onScreenElement = nil;
   id<XCTMessagingChannel_RunnerToDaemon> proxy = [FBXCTestDaemonsProxy testRunnerProxy];
   dispatch_semaphore_t sem = dispatch_semaphore_create(0);

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

@@ -60,6 +60,8 @@ typedef NS_ENUM(NSInteger, FBConfigurationKeyboardPreference) {
 
 /*! The maximum typing frequency for all typing activities */
 @property (atomic, assign) NSUInteger maxTypingFrequency;
+/*! Seconds to wait for a hittable key before typing on iOS. 0 disables the wait. */
+@property (atomic, assign) NSTimeInterval keyboardWaitTimeout;
 @property (atomic, readonly) NSUInteger defaultTypingFrequency;
 
 /*! Use singleton test manager proxy */
@@ -368,6 +370,12 @@ typedef NS_ENUM(NSInteger, FBConfigurationKeyboardPreference) {
  */
 @property (atomic, assign) BOOL enforceCustomSnapshots;
 
+/**
+ * The identifier of the display targeted by screenshots, MJPEG, and new screen recordings.
+ * nil means the main display. Reset to nil for each new session.
+ */
+@property (atomic, copy, nullable) NSNumber *currentDisplayId;
+
 @end
 
 NS_ASSUME_NONNULL_END

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

@@ -343,6 +343,7 @@ static NSString *const axSettingsClassName = @"AXSettings";
   self.shouldUseCompactResponses = YES;
   self.elementResponseAttributes = @"type,label";
   self.maxTypingFrequencyOverride = @(self.defaultTypingFrequency);
+  self.keyboardWaitTimeout = 0;
   self.screenshotQuality = 3;
   self.useFirstMatch = NO;
   self.boundElementsByIndex = NO;
@@ -357,6 +358,7 @@ static NSString *const axSettingsClassName = @"AXSettings";
   FBSetCustomParameterForElementSnapshot(FBSnapshotMaxChildrenKey, @INT_MAX);
   self.useClearTextShortcut = YES;
   self.limitXpathContextScope = YES;
+  self.currentDisplayId = nil;
 #if !TARGET_OS_TV && !TARGET_OS_WATCH
   self.screenshotOrientationStorage = UIInterfaceOrientationUnknown;
 #endif