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

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

@@ -9,6 +9,9 @@
 #import "FBFailureProofTestCase.h"
 
 #import "FBLogger.h"
+#import "XCTIssue.h"
+#import "XCTSourceCodeContext.h"
+#import "XCTSourceCodeLocation.h"
 
 @implementation FBFailureProofTestCase
 
@@ -45,6 +48,8 @@
 /**
  Override 'recordFailureWithDescription' to not stop by failures.
  */
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-implementations"
 - (void)recordFailureWithDescription:(NSString *)description
                               inFile:(NSString *)filePath
                               atLine:(NSUInteger)lineNumber
@@ -52,6 +57,7 @@
 {
   [self _enqueueFailureWithDescription:description inFile:filePath atLine:lineNumber expected:expected];
 }
+#pragma clang diagnostic pop
 
 /**
  Private XCTestCase method used to block and tunnel failure messages

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

@@ -25,8 +25,10 @@ const CGFloat FBMaxCompressionQuality = 1.0f;
 @interface FBImageProcessor ()
 
 @property (nonatomic) NSData *nextImage;
+@property (nonatomic) NSMutableArray<void (^)(NSData *)> *pendingCompletionHandlers;
 @property (nonatomic, readonly) NSLock *nextImageLock;
 @property (nonatomic, readonly) dispatch_queue_t scalingQueue;
+@property (atomic, assign) BOOL isScalingScheduled;
 
 @end
 
@@ -37,7 +39,9 @@ const CGFloat FBMaxCompressionQuality = 1.0f;
   self = [super init];
   if (self) {
     _nextImageLock = [[NSLock alloc] init];
+    _pendingCompletionHandlers = [NSMutableArray array];
     _scalingQueue = dispatch_queue_create("image.scaling.queue", NULL);
+    _isScalingScheduled = NO;
   }
   return self;
 }
@@ -51,34 +55,50 @@ const CGFloat FBMaxCompressionQuality = 1.0f;
     [FBLogger verboseLog:@"Discarding screenshot"];
   }
   self.nextImage = image;
+  [self.pendingCompletionHandlers addObject:[completionHandler copy]];
+  BOOL shouldSchedule = !self.isScalingScheduled;
+  if (shouldSchedule) {
+    self.isScalingScheduled = YES;
+  }
   [self.nextImageLock unlock];
+  if (!shouldSchedule) {
+    return;
+  }
 
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wcompletion-handler"
   dispatch_async(self.scalingQueue, ^{
-    [self.nextImageLock lock];
-    NSData *nextImageData = self.nextImage;
-    self.nextImage = nil;
-    [self.nextImageLock unlock];
-    if (nextImageData == nil) {
-      return;
-    }
+    while (YES) {
+      @autoreleasepool {
+        [self.nextImageLock lock];
+        NSData *nextImageData = self.nextImage;
+        self.nextImage = nil;
+        NSArray<void (^)(NSData *)> *handlers = [self.pendingCompletionHandlers copy];
+        [self.pendingCompletionHandlers removeAllObjects];
+        if (nextImageData == nil) {
+          self.isScalingScheduled = NO;
+          [self.nextImageLock unlock];
+          return;
+        }
+        [self.nextImageLock unlock];
 
-    // We do not want this value to be too high because then we get images larger in size than original ones
-    // Although, we also don't want to lose too much of the quality on recompression
-    CGFloat recompressionQuality = MAX(0.9,
-                                       MIN(FBMaxCompressionQuality, FBConfiguration.mjpegServerScreenshotQuality / 100.0));
-    NSData *thumbnailData = [self.class fixedImageDataWithImageData:nextImageData
-                                                      scalingFactor:scalingFactor
-                                                                uti:UTTypeJPEG
-                                                 compressionQuality:recompressionQuality
-    // iOS always returns screnshots in portrait orientation, but puts the real value into the metadata
-    // Use it with care. See https://github.com/appium/WebDriverAgent/pull/812
-                                                     fixOrientation:FBConfiguration.mjpegShouldFixOrientation
-                                                 desiredOrientation:nil];
-    completionHandler(thumbnailData ?: nextImageData);
+        // We do not want this value to be too high because then we get images larger in size than original ones
+        // Although, we also don't want to lose too much of the quality on recompression
+        CGFloat recompressionQuality = MAX(0.9,
+                                           MIN(FBMaxCompressionQuality, (double)FBConfiguration.sharedInstance.mjpegServerScreenshotQuality / 100.0));
+        NSData *thumbnailData = [self.class fixedImageDataWithImageData:nextImageData
+                                                          scalingFactor:scalingFactor
+                                                                    uti:UTTypeJPEG
+                                                     compressionQuality:recompressionQuality
+        // iOS always returns screenshots in portrait orientation, but puts the real value into the metadata
+        // Use it with care. See https://github.com/appium/WebDriverAgent/pull/812
+                                                         fixOrientation:FBConfiguration.sharedInstance.mjpegShouldFixOrientation
+                                                     desiredOrientation:nil];
+        NSData *processedImageData = thumbnailData ?: nextImageData;
+        for (void (^handler)(NSData *) in handlers) {
+          handler(processedImageData);
+        }
+      }
+    }
   });
-#pragma clang diagnostic pop
 }
 
 + (nullable NSData *)fixedImageDataWithImageData:(NSData *)imageData
@@ -89,8 +109,12 @@ const CGFloat FBMaxCompressionQuality = 1.0f;
                               desiredOrientation:(nullable NSNumber *)orientation
 {
   scalingFactor = MAX(FBMinScalingFactor, MIN(FBMaxScalingFactor, scalingFactor));
-  BOOL usesScaling = scalingFactor > 0.0 && scalingFactor < FBMaxScalingFactor;
   @autoreleasepool {
+#if TARGET_OS_WATCH
+    // UIGraphicsImageRenderer is unavailable and the watch screen doesn't rotate, so skip both.
+    return [uti conformsToType:UTTypePNG] ? FBToPngData(imageData) : FBToJpegData(imageData, compressionQuality);
+#else
+    BOOL usesScaling = scalingFactor > 0.0 && scalingFactor < FBMaxScalingFactor;
     if (!usesScaling && !fixOrientation) {
       return [uti conformsToType:UTTypePNG] ? FBToPngData(imageData) : FBToJpegData(imageData, compressionQuality);
     }
@@ -137,6 +161,7 @@ const CGFloat FBMaxCompressionQuality = 1.0f;
                                          actions:^(UIGraphicsImageRendererContext * _Nonnull rendererContext) {
         [uiImage drawInRect:CGRectMake(0, 0, scaledSize.width, scaledSize.height)];
       }];
+#endif
   }
 }
 
@@ -147,14 +172,14 @@ const CGFloat FBMaxCompressionQuality = 1.0f;
                                    error:(NSError **)error
 {
   NSNumber *orientation = nil;
-#if !TARGET_OS_TV
-  if (FBConfiguration.screenshotOrientation == UIInterfaceOrientationPortrait) {
+#if !TARGET_OS_TV && !TARGET_OS_WATCH
+  if (FBConfiguration.sharedInstance.screenshotOrientation == UIInterfaceOrientationPortrait) {
     orientation = @(UIImageOrientationUp);
-  } else if (FBConfiguration.screenshotOrientation == UIInterfaceOrientationPortraitUpsideDown) {
+  } else if (FBConfiguration.sharedInstance.screenshotOrientation == UIInterfaceOrientationPortraitUpsideDown) {
     orientation = @(UIImageOrientationDown);
-  } else if (FBConfiguration.screenshotOrientation == UIInterfaceOrientationLandscapeLeft) {
+  } else if (FBConfiguration.sharedInstance.screenshotOrientation == UIInterfaceOrientationLandscapeLeft) {
     orientation = @(UIImageOrientationRight);
-  } else if (FBConfiguration.screenshotOrientation == UIInterfaceOrientationLandscapeRight) {
+  } else if (FBConfiguration.sharedInstance.screenshotOrientation == UIInterfaceOrientationLandscapeRight) {
     orientation = @(UIImageOrientationLeft);
   }
 #endif

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

@@ -27,7 +27,7 @@
 
 + (void)verboseLog:(NSString *)message
 {
-  if (!FBConfiguration.verboseLoggingEnabled) {
+  if (!FBConfiguration.sharedInstance.verboseLoggingEnabled) {
     return;
   }
   [self log:message];
@@ -35,7 +35,7 @@
 
 + (void)verboseLogFmt:(NSString *)format, ...
 {
-  if (!FBConfiguration.verboseLoggingEnabled) {
+  if (!FBConfiguration.sharedInstance.verboseLoggingEnabled) {
     return;
   }
   va_list args;

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

@@ -42,12 +42,21 @@
   typeof(arg) arg = wda_weak_##arg \
   _Pragma("clang diagnostic pop")
 
+/*! Current OS version as a dotted string, e.g. "17.4". UIDevice.systemVersion is unavailable on
+    watchOS, so this is sourced from NSProcessInfo, which works identically on every platform. */
+NS_INLINE NSString *FBSystemVersion(void) {
+  NSOperatingSystemVersion v = NSProcessInfo.processInfo.operatingSystemVersion;
+  return 0 == v.patchVersion
+    ? [NSString stringWithFormat:@"%ld.%ld", (long)v.majorVersion, (long)v.minorVersion]
+    : [NSString stringWithFormat:@"%ld.%ld.%ld", (long)v.majorVersion, (long)v.minorVersion, (long)v.patchVersion];
+}
+
 /*! Returns YES if current system version satisfies the given codition */
-#define SYSTEM_VERSION_EQUAL_TO(v)                  ([[[UIDevice currentDevice] systemVersion] compare:v options:NSNumericSearch] == NSOrderedSame)
-#define SYSTEM_VERSION_GREATER_THAN(v)              ([[[UIDevice currentDevice] systemVersion] compare:v options:NSNumericSearch] == NSOrderedDescending)
-#define SYSTEM_VERSION_GREATER_THAN_OR_EQUAL_TO(v)  ([[[UIDevice currentDevice] systemVersion] compare:v options:NSNumericSearch] != NSOrderedAscending)
-#define SYSTEM_VERSION_LESS_THAN(v)                 ([[[UIDevice currentDevice] systemVersion] compare:v options:NSNumericSearch] == NSOrderedAscending)
-#define SYSTEM_VERSION_LESS_THAN_OR_EQUAL_TO(v)     ([[[UIDevice currentDevice] systemVersion] compare:v options:NSNumericSearch] != NSOrderedDescending)
+#define SYSTEM_VERSION_EQUAL_TO(v)                  ([FBSystemVersion() compare:v options:NSNumericSearch] == NSOrderedSame)
+#define SYSTEM_VERSION_GREATER_THAN(v)              ([FBSystemVersion() compare:v options:NSNumericSearch] == NSOrderedDescending)
+#define SYSTEM_VERSION_GREATER_THAN_OR_EQUAL_TO(v)  ([FBSystemVersion() compare:v options:NSNumericSearch] != NSOrderedAscending)
+#define SYSTEM_VERSION_LESS_THAN(v)                 ([FBSystemVersion() compare:v options:NSNumericSearch] == NSOrderedAscending)
+#define SYSTEM_VERSION_LESS_THAN_OR_EQUAL_TO(v)     ([FBSystemVersion() compare:v options:NSNumericSearch] != NSOrderedDescending)
 
 /*! Converts the given number of milliseconds into seconds */
 #define FBMillisToSeconds(ms) ((ms) / 1000.0)

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

@@ -9,6 +9,10 @@
 #import <UIKit/UIKit.h>
 
 @class XCUIApplication;
+@class XCUICoordinate;
+@class XCUIElement;
+
+NS_ASSUME_NONNULL_BEGIN
 
 extern CGFloat FBDefaultFrameFuzzyThreshold;
 
@@ -30,7 +34,56 @@ BOOL FBSizeFuzzyEqualToSize(CGSize size1, CGSize size2, CGFloat threshold);
 /*! Returns whether rect are equal within given threshold */
 BOOL FBRectFuzzyEqualToRect(CGRect rect1, CGRect rect2, CGFloat threshold);
 
-#if !TARGET_OS_TV
+#if !TARGET_OS_TV && !TARGET_OS_WATCH
 /*! Inverts size if necessary to match current screen orientation */
 CGSize FBAdjustDimensionsForApplication(CGSize actualSize, UIInterfaceOrientation orientation);
 #endif
+
+#if !TARGET_OS_TV
+/*!
+ Builds a coordinate for the given element from a raw points offset measured from a
+ normalized anchor point within the element's own frame - e.g. (0, 0) for an offset
+ relative to the top-left corner, (0.5, 0.5) for one relative to the center, as W3C
+ actions use. The offset is normalized against the element's wdFrame (the same
+ WDA-reported coordinate space pointsOffset itself is measured in) instead of being
+ passed through as a raw points offset, which XCTest never rescales for
+ compatibility-mode windows (see appium/appium#16185).
+
+ @param element the element to anchor the coordinate to
+ @param anchorOffset normalized offset of the anchor point within the element's wdFrame
+ @param pointsOffset raw points offset from the anchor point, in wdFrame's coordinate space
+ @param error populated if the element's frame is empty (not visible on the screen)
+ @return the resulting coordinate, or nil if the element's frame is empty
+ */
+XCUICoordinate * _Nullable FBCoordinateWithAnchorOffset(XCUIElement *element,
+                                                         CGVector anchorOffset,
+                                                         CGVector pointsOffset,
+                                                         NSError **error);
+#endif
+
+/*!
+ Computes the normalized (0.0-1.0) start/end offsets of a scroll drag gesture whose
+ touch-down/up points fall within scrollingFrame, expressed relative to anchorFrame -
+ the coordinate space the resulting offsets get resolved against (e.g. via
+ -[XCUIElement coordinateWithNormalizedOffset:]). scrollingFrame and anchorFrame are
+ usually the same rect, but scrollingFrame may be clipped to a visible sub-region, and/or
+ the two may come from frame sources XCTest doesn't keep in sync (see appium/appium#16185)
+ - passing mismatched frames here reproduces that bug rather than fixing it.
+
+ @param scrollingFrame the (possibly clipped) frame to compute the touch-down/up points within
+ @param anchorFrame the frame startOffset/endOffset get normalized against
+ @param proportion normalized touch-down position within scrollingFrame, e.g. from
+        -fb_normalizedHitPointOffsetForScrollingVector:
+ @param vector the scroll vector, in scrollingFrame's coordinate space
+ @param startOffset populated with the normalized start offset; untouched if NO is returned
+ @param endOffset populated with the normalized end offset; untouched if NO is returned
+ @return NO if either frame is empty
+ */
+BOOL FBScrollGestureOffsets(CGRect scrollingFrame,
+                            CGRect anchorFrame,
+                            CGVector proportion,
+                            CGVector vector,
+                            CGVector *startOffset,
+                            CGVector *endOffset);
+
+NS_ASSUME_NONNULL_END

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

@@ -8,7 +8,11 @@
 
 #import "FBMathUtils.h"
 
+#import "FBErrorBuilder.h"
 #import "FBMacros.h"
+#import "XCUICoordinate.h"
+#import "XCUIElement.h"
+#import "XCUIElement+FBWebDriverAttributes.h"
 
 CGFloat FBDefaultFrameFuzzyThreshold = 2.0;
 
@@ -44,14 +48,14 @@ BOOL FBRectFuzzyEqualToRect(CGRect rect1, CGRect rect2, CGFloat threshold)
   FBSizeFuzzyEqualToSize(rect1.size, rect2.size, threshold);
 }
 
-#if !TARGET_OS_TV
+#if !TARGET_OS_TV && !TARGET_OS_WATCH
 
 CGSize FBAdjustDimensionsForApplication(CGSize actualSize, UIInterfaceOrientation orientation)
 {
   if (orientation == UIInterfaceOrientationLandscapeLeft || orientation == UIInterfaceOrientationLandscapeRight) {
     /*
      There is an XCTest bug that application.frame property returns exchanged dimensions for landscape mode.
-     This verification is just to make sure the bug is still there (since height is never greater than width in landscape) 
+     This verification is just to make sure the bug is still there (since height is never greater than width in landscape)
      and to make it still working properly after XCTest itself starts to respect landscape mode.
      */
     if (actualSize.height > actualSize.width) {
@@ -61,3 +65,45 @@ CGSize FBAdjustDimensionsForApplication(CGSize actualSize, UIInterfaceOrientatio
   return actualSize;
 }
 #endif
+
+#if !TARGET_OS_TV
+XCUICoordinate *FBCoordinateWithAnchorOffset(XCUIElement *element,
+                                              CGVector anchorOffset,
+                                              CGVector pointsOffset,
+                                              NSError **error)
+{
+  // wdFrame matches the coordinate space pointsOffset was measured in; element.frame alone
+  // can already be pre-scaled for a compatibility-mode window mismatch, double-applying it.
+  CGRect frame = element.wdFrame;
+  if (CGRectIsEmpty(frame)) {
+    [[[FBErrorBuilder builder]
+      withDescriptionFormat:@"The element '%@' is not visible on the screen and thus is not interactable", element.description]
+     buildError:error];
+    return nil;
+  }
+  CGVector normalizedOffset = CGVectorMake(anchorOffset.dx + pointsOffset.dx / frame.size.width,
+                                           anchorOffset.dy + pointsOffset.dy / frame.size.height);
+  return [element coordinateWithNormalizedOffset:normalizedOffset];
+}
+#endif
+
+BOOL FBScrollGestureOffsets(CGRect scrollingFrame,
+                            CGRect anchorFrame,
+                            CGVector proportion,
+                            CGVector vector,
+                            CGVector *startOffset,
+                            CGVector *endOffset)
+{
+  if (CGRectIsEmpty(scrollingFrame) || CGRectIsEmpty(anchorFrame)) {
+    return NO;
+  }
+
+  CGPoint startPoint = CGPointMake((CGFloat)floor(scrollingFrame.origin.x + scrollingFrame.size.width * proportion.dx),
+                                   (CGFloat)floor(scrollingFrame.origin.y + scrollingFrame.size.height * proportion.dy));
+  CGPoint endPoint = CGPointMake((CGFloat)floor(startPoint.x + vector.dx), (CGFloat)floor(startPoint.y + vector.dy));
+  *startOffset = CGVectorMake((startPoint.x - anchorFrame.origin.x) / anchorFrame.size.width,
+                              (startPoint.y - anchorFrame.origin.y) / anchorFrame.size.height);
+  *endOffset = CGVectorMake((endPoint.x - anchorFrame.origin.x) / anchorFrame.size.width,
+                            (endPoint.y - anchorFrame.origin.y) / anchorFrame.size.height);
+  return YES;
+}

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

@@ -19,6 +19,18 @@ NS_ASSUME_NONNULL_BEGIN
  */
 - (instancetype)init;
 
+/**
+ The socket that owns this instance as its delegate. Clients are bare nw_connection_t values
+ with no write method of their own, so frame writes are routed through
+ -[FBTCPSocket writeData:toClient:]. Must be set before streaming starts.
+ */
+@property (nonatomic, weak, nullable) FBTCPSocket *socket;
+
+/**
+ Stops screenshot broadcasting and prevents future scheduling.
+ */
+- (void)stopStreaming;
+
 @end
 
 NS_ASSUME_NONNULL_END

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

@@ -11,7 +11,8 @@
 #import <mach/mach_time.h>
 @import UniformTypeIdentifiers;
 
-#import "GCDAsyncSocket.h"
+// Textual import, not `@import Network;` - see the comment in FBTCPSocket.h.
+#import <Network/Network.h>
 #import "FBConfiguration.h"
 #import "FBLogger.h"
 #import "FBScreenshot.h"
@@ -21,17 +22,34 @@
 
 static const NSUInteger MAX_FPS = 60;
 static const NSTimeInterval FRAME_TIMEOUT = 1.;
+// nw_connection_send buffers without backpressure, so a client that stops reading would retain
+// every generated frame. Frames past this cap are dropped instead of queued.
+static const NSUInteger MAX_PENDING_FRAMES_PER_CLIENT = 4;
+static const NSTimeInterval FAILURE_BACKOFF_MIN = 1.0;
+static const NSTimeInterval FAILURE_BACKOFF_MAX = 10.0;
 
 static NSString *const SERVER_NAME = @"WDA MJPEG Server";
 static const char *QUEUE_NAME = "JPEG Screenshots Provider Queue";
 
+static NSUInteger FBNormalizedMjpegFramerate(NSUInteger framerate)
+{
+  return (0 == framerate || framerate > MAX_FPS) ? MAX_FPS : framerate;
+}
+
 
 @interface FBMjpegServer()
 
 @property (nonatomic, readonly) dispatch_queue_t backgroundQueue;
-@property (nonatomic, readonly) NSMutableArray<GCDAsyncSocket *> *listeningClients;
+@property (nonatomic, readonly) NSMutableArray<nw_connection_t> *listeningClients;
 @property (nonatomic, readonly) FBImageProcessor *imageProcessor;
 @property (nonatomic, readonly) long long mainScreenID;
+@property (nonatomic, assign) NSUInteger consecutiveScreenshotFailures;
+@property (atomic, assign) BOOL isStreaming;
+@property (nonatomic, assign) NSUInteger sentFramesCount;
+@property (nonatomic, assign) NSUInteger sentBytesCount;
+@property (nonatomic, assign) NSUInteger droppedFramesCount;
+// Frames submitted but not sent yet, per client. Guarded by @synchronized (self.listeningClients).
+@property (nonatomic, readonly) NSMapTable<id, NSNumber *> *pendingFrameCounts;
 
 @end
 
@@ -41,38 +59,52 @@ static const char *QUEUE_NAME = "JPEG Screenshots Provider Queue";
 - (instancetype)init
 {
   if ((self = [super init])) {
+    _consecutiveScreenshotFailures = 0;
+    _isStreaming = YES;
+    _sentFramesCount = 0;
+    _sentBytesCount = 0;
     _listeningClients = [NSMutableArray array];
+    _pendingFrameCounts = [NSMapTable mapTableWithKeyOptions:(NSPointerFunctionsOptions)(NSMapTableObjectPointerPersonality | NSMapTableStrongMemory)
+                                                valueOptions:(NSPointerFunctionsOptions)NSMapTableStrongMemory];
+    _imageProcessor = [[FBImageProcessor alloc] init];
+    _mainScreenID = [XCUIScreen.mainScreen displayID];
     dispatch_queue_attr_t queueAttributes = dispatch_queue_attr_make_with_qos_class(DISPATCH_QUEUE_SERIAL, QOS_CLASS_UTILITY, 0);
     _backgroundQueue = dispatch_queue_create(QUEUE_NAME, queueAttributes);
+    __weak typeof(self) weakSelf = self;
     dispatch_async(_backgroundQueue, ^{
-      [self streamScreenshot];
+      [weakSelf streamScreenshot];
     });
-    _imageProcessor = [[FBImageProcessor alloc] init];
-    _mainScreenID = [XCUIScreen.mainScreen displayID];
   }
   return self;
 }
 
 - (void)scheduleNextScreenshotWithInterval:(uint64_t)timerInterval timeStarted:(uint64_t)timeStarted
 {
+  if (!self.isStreaming) {
+    return;
+  }
   uint64_t timeElapsed = clock_gettime_nsec_np(CLOCK_MONOTONIC_RAW) - timeStarted;
-  int64_t nextTickDelta = timerInterval - timeElapsed;
+  int64_t nextTickDelta = (int64_t)timerInterval - (int64_t)timeElapsed;
+  __weak typeof(self) weakSelf = self;
   if (nextTickDelta > 0) {
     dispatch_after(dispatch_time(DISPATCH_TIME_NOW, nextTickDelta), self.backgroundQueue, ^{
-      [self streamScreenshot];
+      [weakSelf streamScreenshot];
     });
   } else {
     // Try to do our best to keep the FPS at a decent level
     dispatch_async(self.backgroundQueue, ^{
-      [self streamScreenshot];
+      [weakSelf streamScreenshot];
     });
   }
 }
 
 - (void)streamScreenshot
 {
-  NSUInteger framerate = FBConfiguration.mjpegServerFramerate;
-  uint64_t timerInterval = (uint64_t)(1.0 / ((0 == framerate || framerate > MAX_FPS) ? MAX_FPS : framerate) * NSEC_PER_SEC);
+  if (!self.isStreaming) {
+    return;
+  }
+  NSUInteger framerate = FBNormalizedMjpegFramerate(FBConfiguration.sharedInstance.mjpegServerFramerate);
+  uint64_t timerInterval = (uint64_t)(1.0 / (double)framerate * NSEC_PER_SEC);
   uint64_t timeStarted = clock_gettime_nsec_np(CLOCK_MONOTONIC_RAW);
   @synchronized (self.listeningClients) {
     if (0 == self.listeningClients.count) {
@@ -83,7 +115,7 @@ static const char *QUEUE_NAME = "JPEG Screenshots Provider Queue";
 
   NSError *error;
   CGFloat compressionQuality = MAX(FBMinCompressionQuality,
-                                   MIN(FBMaxCompressionQuality, FBConfiguration.mjpegServerScreenshotQuality / 100.0));
+                                   MIN(FBMaxCompressionQuality, (double)FBConfiguration.sharedInstance.mjpegServerScreenshotQuality / 100.0));
   NSData *screenshotData = [FBScreenshot takeInOriginalResolutionWithScreenID:self.mainScreenID
                                                            compressionQuality:compressionQuality
                                                                           uti:UTTypeJPEG
@@ -91,40 +123,83 @@ static const char *QUEUE_NAME = "JPEG Screenshots Provider Queue";
                                                                         error:&error];
   if (nil == screenshotData) {
     [FBLogger logFmt:@"%@", error.description];
-    [self scheduleNextScreenshotWithInterval:timerInterval timeStarted:timeStarted];
+    self.consecutiveScreenshotFailures++;
+    NSTimeInterval backoffSeconds = MIN(FAILURE_BACKOFF_MAX,
+                                        FAILURE_BACKOFF_MIN * (1 << MIN(self.consecutiveScreenshotFailures, 4)));
+    uint64_t backoffInterval = (uint64_t)(backoffSeconds * NSEC_PER_SEC);
+    [self scheduleNextScreenshotWithInterval:backoffInterval timeStarted:timeStarted];
     return;
   }
 
-  CGFloat scalingFactor = FBConfiguration.mjpegScalingFactor / 100.0;
+  self.consecutiveScreenshotFailures = 0;
+
+  CGFloat scalingFactor = FBConfiguration.sharedInstance.mjpegScalingFactor / 100.0;
+  __weak typeof(self) weakSelf = self;
   [self.imageProcessor submitImageData:screenshotData
                          scalingFactor:scalingFactor
                      completionHandler:^(NSData * _Nonnull scaled) {
-    [self sendScreenshot:scaled];
+    [weakSelf sendScreenshot:scaled];
   }];
 
   [self scheduleNextScreenshotWithInterval:timerInterval timeStarted:timeStarted];
 }
 
 - (void)sendScreenshot:(NSData *)screenshotData {
+  if (!self.isStreaming) {
+    return;
+  }
   NSString *chunkHeader = [NSString stringWithFormat:@"--BoundaryString\r\nContent-type: image/jpeg\r\nContent-Length: %@\r\n\r\n", @(screenshotData.length)];
   NSMutableData *chunk = [[chunkHeader dataUsingEncoding:NSUTF8StringEncoding] mutableCopy];
   [chunk appendData:screenshotData];
   [chunk appendData:(id)[@"\r\n\r\n" dataUsingEncoding:NSUTF8StringEncoding]];
   @synchronized (self.listeningClients) {
-    for (GCDAsyncSocket *client in self.listeningClients) {
-      [client writeData:chunk withTimeout:-1 tag:0];
+    if (!self.isStreaming || 0 == self.listeningClients.count) {
+      return;
+    }
+    NSUInteger clientCount = self.listeningClients.count;
+    __weak typeof(self) weakSelf = self;
+    for (nw_connection_t client in self.listeningClients) {
+      NSUInteger pendingFrames = [self.pendingFrameCounts objectForKey:client].unsignedIntegerValue;
+      if (pendingFrames >= MAX_PENDING_FRAMES_PER_CLIENT) {
+        self.droppedFramesCount++;
+        continue;
+      }
+      [self.pendingFrameCounts setObject:@(pendingFrames + 1) forKey:client];
+      [self.socket writeData:chunk toClient:client completion:^(BOOL didSucceed) {
+        __strong typeof(weakSelf) strongSelf = weakSelf;
+        if (nil == strongSelf) {
+          return;
+        }
+        @synchronized (strongSelf.listeningClients) {
+          NSUInteger stillPending = [strongSelf.pendingFrameCounts objectForKey:client].unsignedIntegerValue;
+          if (stillPending > 1) {
+            [strongSelf.pendingFrameCounts setObject:@(stillPending - 1) forKey:client];
+          } else {
+            [strongSelf.pendingFrameCounts removeObjectForKey:client];
+          }
+        }
+      }];
+    }
+    self.sentFramesCount++;
+    self.sentBytesCount += chunk.length * clientCount;
+    NSUInteger framerate = FBNormalizedMjpegFramerate(FBConfiguration.sharedInstance.mjpegServerFramerate);
+    if (0 == self.sentFramesCount % framerate) {
+      [FBLogger verboseLog:[NSString stringWithFormat:@"MJPEG stats: clients=%@ sentFrames=%@ sentBytes=%@ droppedFrames=%@",
+                            @(clientCount),
+                            @(self.sentFramesCount),
+                            @(self.sentBytesCount),
+                            @(self.droppedFramesCount)]];
     }
   }
 }
 
-- (void)didClientConnect:(GCDAsyncSocket *)newClient
+- (void)didClientConnect:(nw_connection_t)newClient
 {
-  [FBLogger logFmt:@"Got screenshots broadcast client connection at %@:%d", newClient.connectedHost, newClient.connectedPort];
-  // Start broadcast only after there is any data from the client
-  [newClient readDataWithTimeout:-1 tag:0];
+  [FBLogger log:@"Got screenshots broadcast client connection"];
+  // FBTCPSocket already schedules the receive that -client:didReceiveData: relies on below.
 }
 
-- (void)didClientSendData:(GCDAsyncSocket *)client
+- (void)client:(nw_connection_t)client didReceiveData:(NSData *)data
 {
   @synchronized (self.listeningClients) {
     if ([self.listeningClients containsObject:client]) {
@@ -132,20 +207,40 @@ static const char *QUEUE_NAME = "JPEG Screenshots Provider Queue";
     }
   }
 
-  [FBLogger logFmt:@"Starting screenshots broadcast for the client at %@:%d", client.connectedHost, client.connectedPort];
+  [FBLogger log:@"Starting screenshots broadcast for the client"];
   NSString *streamHeader = [NSString stringWithFormat:@"HTTP/1.0 200 OK\r\nServer: %@\r\nConnection: close\r\nMax-Age: 0\r\nExpires: 0\r\nCache-Control: no-cache, private\r\nPragma: no-cache\r\nContent-Type: multipart/x-mixed-replace; boundary=--BoundaryString\r\n\r\n", SERVER_NAME];
-  [client writeData:(id)[streamHeader dataUsingEncoding:NSUTF8StringEncoding] withTimeout:-1 tag:0];
+  [self.socket writeData:(id)[streamHeader dataUsingEncoding:NSUTF8StringEncoding] toClient:client];
   @synchronized (self.listeningClients) {
     [self.listeningClients addObject:client];
   }
 }
 
-- (void)didClientDisconnect:(GCDAsyncSocket *)client
+- (void)didClientDisconnect:(nw_connection_t)client
 {
   @synchronized (self.listeningClients) {
     [self.listeningClients removeObject:client];
+    [self.pendingFrameCounts removeObjectForKey:client];
   }
   [FBLogger log:@"Disconnected a client from screenshots broadcast"];
 }
 
+- (void)stopStreaming
+{
+  self.isStreaming = NO;
+  @synchronized (self.listeningClients) {
+    NSArray<nw_connection_t> *clients = self.listeningClients.copy;
+    [self.listeningClients removeAllObjects];
+    [self.pendingFrameCounts removeAllObjects];
+    for (nw_connection_t client in clients) {
+      nw_connection_cancel(client);
+    }
+  }
+}
+
+- (void)dealloc
+{
+  [self stopStreaming];
+  [FBLogger verboseLog:@"FBMjpegServer deallocated"];
+}
+
 @end

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

@@ -10,7 +10,7 @@
 
 NS_ASSUME_NONNULL_BEGIN
 
-#if !TARGET_OS_TV
+#if !TARGET_OS_TV && !TARGET_OS_WATCH
 @interface FBPasteboard : NSObject
 
 /**