appium-webdriveragent 16.2.2 → 16.3.0

package/WebDriverAgentLib/Commands/FBSessionCommands.m

@@ -8,6 +8,10 @@
 
 #import "FBSessionCommands.h"
 
+#if TARGET_OS_WATCH
+@import WatchKit;
+#endif
+
 #import "FBCapabilities.h"
 #import "FBConfiguration.h"
 #import "FBExceptions.h"
@@ -189,6 +193,16 @@
     [buildInfo setObject:version forKey:@"version"];
   }
 
+#if TARGET_OS_WATCH
+  NSString *osName = @"watchOS";
+  NSString *osVersion = WKInterfaceDevice.currentDevice.systemVersion;
+  NSString *deviceKind = @"watch";
+#else
+  NSString *osName = [[UIDevice currentDevice] systemName];
+  NSString *osVersion = [[UIDevice currentDevice] systemVersion];
+  NSString *deviceKind = [self.class deviceNameByUserInterfaceIdiom:[UIDevice currentDevice].userInterfaceIdiom];
+#endif
+
   return FBResponseWithObject(
     @{
       @"ready" : @YES,
@@ -196,20 +210,20 @@
       @"state" : @"success",
       @"os" :
         @{
-          @"name" : [[UIDevice currentDevice] systemName],
-          @"version" : [[UIDevice currentDevice] systemVersion],
+          @"name" : osName,
+          @"version" : osVersion,
           @"sdkVersion": FBSDKVersion() ?: @"unknown",
           @"testmanagerdVersion": @(FBTestmanagerdVersion()),
         },
       @"ios" :
         @{
-#if TARGET_OS_SIMULATOR
-          @"simulatorVersion" : [[UIDevice currentDevice] systemVersion],
+#if TARGET_OS_SIMULATOR && !TARGET_OS_WATCH
+          @"simulatorVersion" : osVersion,
 #endif
           @"ip" : [XCUIDevice sharedDevice].fb_wifiIPAddress ?: [NSNull null]
         },
       @"build" : buildInfo.copy,
-      @"device": [self.class deviceNameByUserInterfaceIdiom:[UIDevice currentDevice].userInterfaceIdiom]
+      @"device": deviceKind
     }
   );
 }
@@ -431,6 +445,7 @@
   };
 }
 
+#if !TARGET_OS_WATCH
 /*
  Return the device kind as lower case
 */
@@ -447,14 +462,23 @@
   return @"Unknown";
 
 }
+#endif
 
 + (NSDictionary *)currentCapabilities
 {
+#if TARGET_OS_WATCH
+  return
+  @{
+    @"device": @"watch",
+    @"sdkVersion": WKInterfaceDevice.currentDevice.systemVersion
+  };
+#else
   return
   @{
     @"device": [self.class deviceNameByUserInterfaceIdiom:[UIDevice currentDevice].userInterfaceIdiom],
     @"sdkVersion": [[UIDevice currentDevice] systemVersion]
   };
+#endif
 }
 
 +(nullable id<FBResponsePayload>)openDeepLink:(NSString *)initialUrl

package/WebDriverAgentLib/Info.plist

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

package/WebDriverAgentLib/Routing/FBTCPSocket.h

@@ -6,10 +6,56 @@
  * LICENSE file in the root directory of this source tree.
  */
 
+// TARGET_OS_WATCH must be defined before the #if below runs, or (on some older Xcode/SDK
+// toolchains) it silently evaluates as undefined/false here despite being true for the rest of
+// the translation unit - which desyncs this file's declarations from FBTCPSocket.m's own
+// #if TARGET_OS_WATCH branch.
+#import <TargetConditionals.h>
+
+#if TARGET_OS_WATCH
+@import Foundation;
+// A textual import, not `@import Network;` - older Xcode/watchOS SDK combinations (verified:
+// Xcode 15.4/watchOS 10.5) fail to expose nw_listener_t/nw_connection_t and friends through the
+// Network module map on watchOS, even though the underlying API has existed since watchOS 5.0.
+#import <Network/Network.h>
+#else
 #import "GCDAsyncSocket.h"
+#endif
 
 NS_ASSUME_NONNULL_BEGIN
 
+#if TARGET_OS_WATCH
+
+// watchOS forbids BSD sockets, so this is backed by Network.framework instead of GCDAsyncSocket -
+// hence a differently-shaped, push-style delegate protocol.
+@protocol FBTCPSocketDelegate <NSObject>
+
+/**
+ The callback which is fired on new TCP client connection
+
+ @param newClient The newly connected client
+ */
+- (void)didClientConnect:(nw_connection_t)newClient;
+
+/**
+ The callback which is fired when the TCP server receives data from a connected client
+
+ @param client The client, which sent the data
+ @param data The received data
+*/
+- (void)client:(nw_connection_t)client didReceiveData:(NSData *)data;
+
+/**
+ The callback which is fired when TCP client disconnects
+
+ @param client The actual disconnected client
+ */
+- (void)didClientDisconnect:(nw_connection_t)client;
+
+@end
+
+#else
+
 @protocol FBTCPSocketDelegate
 
 /**
@@ -35,6 +81,8 @@ NS_ASSUME_NONNULL_BEGIN
 
 @end
 
+#endif
+
 
 @interface FBTCPSocket : NSObject
 
@@ -64,6 +112,28 @@ NS_ASSUME_NONNULL_BEGIN
  Stops the socket if it is running
  */
 - (void)stop;
+
+#if TARGET_OS_WATCH
+/**
+ Writes data to the given connected client
+
+ @param data The data to send
+ @param client The destination client, as received via -didClientConnect: or -client:didReceiveData:
+ */
+- (void)writeData:(NSData *)data toClient:(nw_connection_t)client;
+
+/**
+ Like -writeData:toClient:, but invokes completion once the send actually goes out. Use this
+ before cancelling the connection - nw_connection_send is async, so cancelling right away can
+ drop the write before it's sent.
+
+ @param data The data to send
+ @param client The destination client
+ @param completion Called once the send attempt finishes
+ */
+- (void)writeData:(NSData *)data toClient:(nw_connection_t)client completion:(nullable void (^)(void))completion;
+#endif
+
 @end
 
 NS_ASSUME_NONNULL_END

package/WebDriverAgentLib/Routing/FBTCPSocket.m

@@ -8,6 +8,203 @@
 
 #import "FBTCPSocket.h"
 
+#if TARGET_OS_WATCH
+
+@interface FBTCPSocket()
+@property (readonly, nonatomic) dispatch_queue_t socketQueue;
+@property (nullable, nonatomic) nw_listener_t listener;
+@property (readonly, nonatomic) NSMutableArray<nw_connection_t> *connectedClients;
+@property (readonly, nonatomic) uint16_t port;
+@end
+
+
+@implementation FBTCPSocket
+
+- (instancetype)initWithPort:(uint16_t)port
+{
+  if ((self = [super init])) {
+    _socketQueue = dispatch_queue_create("socketQueue", NULL);
+    _connectedClients = [[NSMutableArray alloc] initWithCapacity:1];
+    _port = port;
+    _delegate = nil;
+  }
+  return self;
+}
+
+- (BOOL)startWithError:(NSError **)error
+{
+  nw_parameters_t parameters = nw_parameters_create_secure_tcp(NW_PARAMETERS_DISABLE_PROTOCOL,
+                                                                NW_PARAMETERS_DEFAULT_CONFIGURATION);
+  NSString *portString = [NSString stringWithFormat:@"%u", (unsigned int)self.port];
+  // portString is always valid UTF8; -UTF8String is just declared nullable in general.
+  const char * _Nonnull portCString = (const char * _Nonnull)portString.UTF8String;
+  nw_listener_t listener = nw_listener_create_with_port(portCString, parameters);
+  if (nil == listener) {
+    if (error) {
+      *error = [NSError errorWithDomain:@"FBTCPSocket"
+                                    code:1
+                                userInfo:@{NSLocalizedDescriptionKey: @"Failed to create the TCP listener"}];
+    }
+    return NO;
+  }
+  self.listener = listener;
+
+  __weak typeof(self) weakSelf = self;
+  nw_listener_set_queue(listener, self.socketQueue);
+  nw_listener_set_new_connection_handler(listener, ^(nw_connection_t connection) {
+    [weakSelf acceptConnection:connection];
+  });
+
+  dispatch_semaphore_t startupSemaphore = dispatch_semaphore_create(0);
+  __block NSError *startupError = nil;
+  nw_listener_set_state_changed_handler(listener, ^(nw_listener_state_t state, nw_error_t nwError) {
+    // if/else, not switch: -Wswitch-enum, -Wswitch-default, and -Wcovered-switch-default can't
+    // all be satisfied by one switch statement at once.
+    if (nw_listener_state_ready == state) {
+      dispatch_semaphore_signal(startupSemaphore);
+    } else if (nw_listener_state_failed == state || nw_listener_state_cancelled == state) {
+      // NSLocalizedDescriptionKey must be a string, not the underlying NSError itself, or
+      // -[NSError localizedDescription] crashes trying to treat it as one.
+      NSError *underlyingError = nwError ? (NSError *)CFBridgingRelease(nw_error_copy_cf_error(nwError)) : nil;
+      NSMutableDictionary<NSString *, id> *userInfo = [NSMutableDictionary dictionary];
+      userInfo[NSLocalizedDescriptionKey] = underlyingError.localizedDescription ?: @"The TCP listener failed to start";
+      if (underlyingError) {
+        userInfo[NSUnderlyingErrorKey] = underlyingError;
+      }
+      startupError = [NSError errorWithDomain:@"FBTCPSocket" code:2 userInfo:userInfo];
+      dispatch_semaphore_signal(startupSemaphore);
+    }
+  });
+  nw_listener_start(listener);
+  BOOL didStartInTime = 0 == dispatch_semaphore_wait(startupSemaphore, dispatch_time(DISPATCH_TIME_NOW, (int64_t)(5 * NSEC_PER_SEC)));
+  if (!didStartInTime) {
+    startupError = [NSError errorWithDomain:@"FBTCPSocket"
+                                        code:3
+                                    userInfo:@{NSLocalizedDescriptionKey: @"Timed out while starting the TCP listener"}];
+  }
+  if (nil != startupError) {
+    if (error) {
+      *error = startupError;
+    }
+    self.listener = nil;
+    return NO;
+  }
+  return YES;
+}
+
+- (void)acceptConnection:(nw_connection_t)connection
+{
+  @synchronized (self.connectedClients) {
+    [self.connectedClients addObject:connection];
+  }
+
+  __weak typeof(self) weakSelf = self;
+  nw_connection_set_queue(connection, self.socketQueue);
+  nw_connection_set_state_changed_handler(connection, ^(nw_connection_state_t state, nw_error_t connectionError) {
+    // Same reasoning as the listener state handler above.
+    if (nw_connection_state_ready == state) {
+      __strong typeof(weakSelf) strongSelf = weakSelf;
+      if (nil == strongSelf) {
+        return;
+      }
+      id<FBTCPSocketDelegate> delegate = strongSelf.delegate;
+      if (nil != delegate) {
+        [delegate didClientConnect:connection];
+      }
+      [strongSelf scheduleReceiveForConnection:connection];
+    } else if (nw_connection_state_failed == state || nw_connection_state_cancelled == state) {
+      [weakSelf handleDisconnectForConnection:connection];
+    }
+  });
+  nw_connection_start(connection);
+}
+
+- (void)scheduleReceiveForConnection:(nw_connection_t)connection
+{
+  __weak typeof(self) weakSelf = self;
+  nw_connection_receive(connection, 1, UINT32_MAX, ^(dispatch_data_t  _Nullable content,
+                                                       nw_content_context_t  _Nullable context,
+                                                       bool isComplete,
+                                                       nw_error_t  _Nullable receiveError) {
+    __strong typeof(weakSelf) strongSelf = weakSelf;
+    if (nil == strongSelf) {
+      return;
+    }
+    if (nil != content) {
+      dispatch_data_t nonnullContent = (dispatch_data_t _Nonnull)content;
+      __block NSData *data = nil;
+      dispatch_data_apply(nonnullContent, ^bool(dispatch_data_t  _Nonnull region, size_t offset, const void * _Nonnull buffer, size_t size) {
+        NSMutableData *accumulated = [(data ?: [NSData data]) mutableCopy];
+        [accumulated appendBytes:buffer length:size];
+        data = accumulated.copy;
+        return true;
+      });
+      if (data.length > 0) {
+        id<FBTCPSocketDelegate> delegate = strongSelf.delegate;
+        if (nil != delegate) {
+          [delegate client:connection didReceiveData:data];
+        }
+      }
+    }
+    if (nil != receiveError || (isComplete && nil == content)) {
+      [strongSelf handleDisconnectForConnection:connection];
+      return;
+    }
+    [strongSelf scheduleReceiveForConnection:connection];
+  });
+}
+
+- (void)handleDisconnectForConnection:(nw_connection_t)connection
+{
+  BOOL wasConnected;
+  @synchronized (self.connectedClients) {
+    wasConnected = [self.connectedClients containsObject:connection];
+    [self.connectedClients removeObject:connection];
+  }
+  if (wasConnected) {
+    id<FBTCPSocketDelegate> delegate = self.delegate;
+    if (nil != delegate) {
+      [delegate didClientDisconnect:connection];
+    }
+  }
+}
+
+- (void)writeData:(NSData *)data toClient:(nw_connection_t)client
+{
+  [self writeData:data toClient:client completion:nil];
+}
+
+- (void)writeData:(NSData *)data toClient:(nw_connection_t)client completion:(nullable void (^)(void))completion
+{
+  dispatch_data_t dispatchData = dispatch_data_create(data.bytes, data.length, self.socketQueue, DISPATCH_DATA_DESTRUCTOR_DEFAULT);
+  nw_connection_send(client, dispatchData, NW_CONNECTION_DEFAULT_STREAM_CONTEXT, false, ^(nw_error_t  _Nullable sendError) {
+    if (completion) {
+      completion();
+    }
+  });
+}
+
+- (void)stop
+{
+  @synchronized (self.connectedClients) {
+    NSArray<nw_connection_t> *clients = self.connectedClients.copy;
+    [self.connectedClients removeAllObjects];
+    for (nw_connection_t client in clients) {
+      nw_connection_cancel(client);
+    }
+  }
+
+  self.delegate = nil;
+  nw_listener_t listener = self.listener;
+  if (nil != listener) {
+    nw_listener_cancel((nw_listener_t _Nonnull)listener);
+    self.listener = nil;
+  }
+}
+
+@end
+
+#else
 
 @interface FBTCPSocket()
 @property (readonly, nonatomic) dispatch_queue_t socketQueue;
@@ -95,3 +292,5 @@
 }
 
 @end
+
+#endif

package/WebDriverAgentLib/Routing/FBWebServer.m

@@ -8,17 +8,21 @@
 
 #import "FBWebServer.h"
 
+#if TARGET_OS_WATCH
+#import "FBWatchHTTPServer.h"
+#else
 #import "RoutingConnection.h"
 #import "RoutingHTTPServer.h"
+#import "FBMjpegServer.h"
+#import "FBTCPSocket.h"
+#endif
 
 #import "FBCommandHandler.h"
 #import "FBErrorBuilder.h"
 #import "FBExceptionHandler.h"
-#import "FBMjpegServer.h"
 #import "FBRouteRequest.h"
 #import "FBRuntimeUtils.h"
 #import "FBSession.h"
-#import "FBTCPSocket.h"
 #import "FBUnknownCommands.h"
 #import "FBConfiguration.h"
 #import "FBLogger.h"
@@ -28,6 +32,7 @@
 static NSString *const FBServerURLBeginMarker = @"ServerURLHere->";
 static NSString *const FBServerURLEndMarker = @"<-ServerURLHere";
 
+#if !TARGET_OS_WATCH
 @interface FBHTTPConnection : RoutingConnection
 @end
 
@@ -45,21 +50,28 @@ static NSString *const FBServerURLEndMarker = @"<-ServerURLHere";
 }
 
 @end
+#endif
 
 
 @interface FBWebServer ()
 @property (nonatomic, strong) FBExceptionHandler *exceptionHandler;
+#if TARGET_OS_WATCH
+@property (nonatomic, strong) FBWatchHTTPServer *server;
+#else
 @property (nonatomic, strong) RoutingHTTPServer *server;
-@property (atomic, assign) BOOL keepAlive;
 @property (nonatomic, nullable) FBTCPSocket *screenshotsBroadcaster;
 @property (nonatomic, nullable, strong) FBMjpegServer *mjpegServer;
+#endif
+@property (atomic, assign) BOOL keepAlive;
 @end
 
 @implementation FBWebServer
 
 - (void)dealloc
 {
+#if !TARGET_OS_WATCH
   [self stopScreenshotsBroadcaster];
+#endif
 }
 
 + (NSArray<Class<FBCommandHandler>> *)collectCommandHandlerClasses
@@ -84,7 +96,9 @@ static NSString *const FBServerURLEndMarker = @"<-ServerURLHere";
   if (![self startHTTPServer]) {
     return;
   }
+#if !TARGET_OS_WATCH
   [self initScreenshotsBroadcaster];
+#endif
 
   self.keepAlive = YES;
   NSRunLoop *runLoop = [NSRunLoop mainRunLoop];
@@ -94,22 +108,30 @@ static NSString *const FBServerURLEndMarker = @"<-ServerURLHere";
 
 - (BOOL)startHTTPServer
 {
+#if TARGET_OS_WATCH
+  self.server = [[FBWatchHTTPServer alloc] init];
+#else
   self.server = [[RoutingHTTPServer alloc] init];
+#endif
   [self.server setRouteQueue:dispatch_get_main_queue()];
   [self.server setDefaultHeader:@"Server" value:@"WebDriverAgent/1.0"];
   [self.server setDefaultHeader:@"Access-Control-Allow-Origin" value:@"*"];
   [self.server setDefaultHeader:@"Access-Control-Allow-Headers" value:@"Content-Type, X-Requested-With"];
+#if !TARGET_OS_WATCH
   [self.server setConnectionClass:[FBHTTPConnection self]];
+#endif
 
   [self registerRouteHandlers:[self.class collectCommandHandlerClasses]];
   [self registerServerKeyRouteHandlers];
 
   NSRange serverPortRange = FBConfiguration.sharedInstance.bindingPortRange;
   NSString *bindingIP = FBConfiguration.sharedInstance.bindingIPAddress;
+#if !TARGET_OS_WATCH
   if (bindingIP != nil) {
     [self.server setInterface:bindingIP];
     [FBLogger logFmt:@"Using custom binding IP address: %@", bindingIP];
   }
+#endif
 
   NSError *error;
   BOOL serverStarted = NO;
@@ -141,6 +163,7 @@ static NSString *const FBServerURLEndMarker = @"<-ServerURLHere";
   return YES;
 }
 
+#if !TARGET_OS_WATCH
 - (void)initScreenshotsBroadcaster
 {
   [self readMjpegSettingsFromEnv];
@@ -186,11 +209,14 @@ static NSString *const FBServerURLEndMarker = @"<-ServerURLHere";
     FBConfiguration.sharedInstance.mjpegServerScreenshotQuality = [screenshotQuality integerValue];
   }
 }
+#endif
 
 - (void)stopServing
 {
   [FBSession.activeSession kill];
+#if !TARGET_OS_WATCH
   [self stopScreenshotsBroadcaster];
+#endif
   if (self.server.isRunning) {
     [self.server stop:NO];
   }
@@ -199,7 +225,11 @@ static NSString *const FBServerURLEndMarker = @"<-ServerURLHere";
   self.keepAlive = NO;
 }
 
+#if TARGET_OS_WATCH
+- (BOOL)attemptToStartServer:(FBWatchHTTPServer *)server onPort:(NSInteger)port withError:(NSError **)error
+#else
 - (BOOL)attemptToStartServer:(RoutingHTTPServer *)server onPort:(NSInteger)port withError:(NSError **)error
+#endif
 {
   server.port = (UInt16)port;
   NSError *innerError = nil;

package/WebDriverAgentLib/Routing/WatchOS/FBWatchHTTPServer.h

@@ -0,0 +1,68 @@
+/**
+ * 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.
+ */
+
+// RoutingHTTPServer/CocoaHTTPServer need BSD sockets (via GCDAsyncSocket), which watchOS
+// forbids - see FBTCPSocket.h/.m. This is a minimal HTTP/1.1 server on top of the watchOS
+// FBTCPSocket, mirroring just enough of RoutingHTTPServer's API for FBWebServer.m to swap
+// servers with a single #if TARGET_OS_WATCH.
+//
+// No chunked encoding, range requests, or pipelining - just request line + headers +
+// Content-Length body, and ":param" path matching like RoutingHTTPServer.m.
+
+@import Foundation;
+
+#import "RouteRequest.h"
+#import "RouteResponse.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface FBWatchHTTPServer : NSObject
+
+/*! The port the server is (or will be) listening on */
+@property (nonatomic) uint16_t port;
+
+/*! Whether the server is currently listening for connections */
+@property (nonatomic, readonly) BOOL isRunning;
+
+/**
+ Sets the dispatch queue on which route blocks are invoked. Pass NULL to invoke them
+ synchronously on the socket's own queue.
+ */
+- (void)setRouteQueue:(nullable dispatch_queue_t)queue;
+
+/**
+ Sets a header which is added to every response, unless overridden by the route itself.
+ */
+- (void)setDefaultHeader:(NSString *)field value:(NSString *)value;
+
+/**
+ Registers a route handler for the given HTTP method and path pattern (":param" segments are
+ captured into the request's `params`, matching RoutingHTTPServer's convention).
+ */
+- (void)handleMethod:(NSString *)method
+            withPath:(NSString *)path
+               block:(void (^)(RouteRequest *request, RouteResponse *response))block;
+
+/**
+ Convenience for -handleMethod:@"GET" withPath:path block:block.
+ */
+- (void)get:(NSString *)path withBlock:(void (^)(RouteRequest *request, RouteResponse *response))block;
+
+/**
+ Starts listening on `port`.
+ */
+- (BOOL)start:(NSError **)error;
+
+/**
+ Stops listening and disconnects all clients.
+ */
+- (void)stop:(BOOL)immediately;
+
+@end
+
+NS_ASSUME_NONNULL_END