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

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

@@ -8,8 +8,11 @@
 
 #import "FBSessionCommands.h"
 
+#if TARGET_OS_WATCH
+@import WatchKit;
+#endif
+
 #import "FBCapabilities.h"
-#import "FBClassChainQueryParser.h"
 #import "FBConfiguration.h"
 #import "FBExceptions.h"
 #import "FBLogger.h"
@@ -17,8 +20,9 @@
 #import "FBRouteRequest.h"
 #import "FBSession.h"
 #import "FBSettings.h"
+#import "FBSettingsHandler.h"
 #import "FBRuntimeUtils.h"
-#import "FBActiveAppDetectionPoint.h"
+#import "FBXCAXClientProxy.h"
 #import "FBXCodeCompatibility.h"
 #import "XCUIApplication+FBHelpers.h"
 #import "XCUIApplication+FBQuiescence.h"
@@ -44,8 +48,8 @@
     [[FBRoute POST:@"/wda/apps/state"] respondWithTarget:self action:@selector(handleSessionAppState:)],
     [[FBRoute GET:@"/wda/apps/list"] respondWithTarget:self action:@selector(handleGetActiveAppsList:)],
     [[FBRoute GET:@""] respondWithTarget:self action:@selector(handleGetActiveSession:)],
-    [[FBRoute DELETE:@""] respondWithTarget:self action:@selector(handleDeleteSession:)],
-    [[FBRoute GET:@"/status"].withoutSession respondWithTarget:self action:@selector(handleGetStatus:)],
+    [[FBRoute DELETE:@""].standalone respondWithTarget:self action:@selector(handleDeleteSession:)],
+    [[FBRoute GET:@"/status"].withoutSession.standalone respondWithTarget:self action:@selector(handleGetStatus:)],
 
     // Health check might modify simulator state so it should only be called in-between testing sessions
     [[FBRoute GET:@"/wda/healthcheck"].withoutSession respondWithTarget:self action:@selector(handleGetHealthCheck:)],
@@ -86,140 +90,38 @@
 
 + (id<FBResponsePayload>)handleCreateSession:(FBRouteRequest *)request
 {
-  if (nil != FBSession.activeSession) {
-    [FBSession.activeSession kill];
-  }
+  [FBSession killActiveSessionAndWaitForTeardown];
 
   NSDictionary<NSString *, id> *capabilities;
-  NSError *error;
-  if (![request.arguments[@"capabilities"] isKindOfClass:NSDictionary.class]) {
-    return FBResponseWithStatus([FBCommandStatus sessionNotCreatedError:@"'capabilities' is mandatory to create a new session"
-                                                              traceback:nil]);
-  }
-  if (nil == (capabilities = FBParseCapabilities((NSDictionary *)request.arguments[@"capabilities"], &error))) {
-    return FBResponseWithStatus([FBCommandStatus sessionNotCreatedError:error.localizedDescription traceback:nil]);
+  id<FBResponsePayload> errorResponse = [self capabilitiesFromCreateSessionRequest:request
+                                                                    capabilitiesOut:&capabilities];
+  if (nil != errorResponse) {
+    return errorResponse;
   }
 
-  [FBConfiguration resetSessionSettings];
-  [FBConfiguration setShouldUseTestManagerForVisibilityDetection:[capabilities[FB_CAP_USE_TEST_MANAGER_FOR_VISIBLITY_DETECTION] boolValue]];
-  if (capabilities[FB_SETTING_USE_COMPACT_RESPONSES]) {
-    [FBConfiguration setShouldUseCompactResponses:[capabilities[FB_SETTING_USE_COMPACT_RESPONSES] boolValue]];
-  }
-  NSString *elementResponseAttributes = capabilities[FB_SETTING_ELEMENT_RESPONSE_ATTRIBUTES];
-  if (elementResponseAttributes) {
-    [FBConfiguration setElementResponseAttributes:elementResponseAttributes];
-  }
-  if (capabilities[FB_CAP_MAX_TYPING_FREQUENCY]) {
-    [FBConfiguration setMaxTypingFrequency:[capabilities[FB_CAP_MAX_TYPING_FREQUENCY] unsignedIntegerValue]];
-  }
-  if (capabilities[FB_CAP_USE_SINGLETON_TEST_MANAGER]) {
-    [FBConfiguration setShouldUseSingletonTestManager:[capabilities[FB_CAP_USE_SINGLETON_TEST_MANAGER] boolValue]];
-  }
-  if (capabilities[FB_CAP_DISABLE_AUTOMATIC_SCREENSHOTS]) {
-    if ([capabilities[FB_CAP_DISABLE_AUTOMATIC_SCREENSHOTS] boolValue]) {
-      [FBConfiguration disableScreenshots];
-    } else {
-      [FBConfiguration enableScreenshots];
-    }
-  }
-  if (capabilities[FB_CAP_SHOULD_TERMINATE_APP]) {
-    [FBConfiguration setShouldTerminateApp:[capabilities[FB_CAP_SHOULD_TERMINATE_APP] boolValue]];
-  }
-  NSNumber *delay = capabilities[FB_CAP_EVENT_LOOP_IDLE_DELAY_SEC];
-  if ([delay doubleValue] > 0.0) {
-    [XCUIApplicationProcessDelay setEventLoopHasIdledDelay:[delay doubleValue]];
-  } else {
-    [XCUIApplicationProcessDelay disableEventLoopDelay];
-  }
-
-  if (nil != capabilities[FB_SETTING_WAIT_FOR_IDLE_TIMEOUT]) {
-    FBConfiguration.waitForIdleTimeout = [capabilities[FB_SETTING_WAIT_FOR_IDLE_TIMEOUT] doubleValue];
-  }
-
-  if (nil == capabilities[FB_CAP_FORCE_SIMULATOR_SOFTWARE_KEYBOARD_PRESENCE] ||
-      [capabilities[FB_CAP_FORCE_SIMULATOR_SOFTWARE_KEYBOARD_PRESENCE] boolValue]) {
-    [FBConfiguration forceSimulatorSoftwareKeyboardPresence];
-  }
+  [self applyConfigurationFromCapabilities:capabilities];
 
   NSString *bundleID = capabilities[FB_CAP_BUNDLE_ID];
   NSString *initialUrl = capabilities[FB_CAP_INITIAL_URL];
   XCUIApplication *app = nil;
-  if (bundleID != nil) {
-    app = [[XCUIApplication alloc] initWithBundleIdentifier:bundleID];
-    BOOL forceAppLaunch = YES;
-    if (nil != capabilities[FB_CAP_FORCE_APP_LAUNCH]) {
-      forceAppLaunch = [capabilities[FB_CAP_FORCE_APP_LAUNCH] boolValue];
-    }
-    XCUIApplicationState appState = app.state;
-    BOOL isAppRunning = appState >= XCUIApplicationStateRunningBackground;
-    if (!isAppRunning || (isAppRunning && forceAppLaunch)) {
-      app.fb_shouldWaitForQuiescence = nil == capabilities[FB_CAP_SHOULD_WAIT_FOR_QUIESCENCE]
-        || [capabilities[FB_CAP_SHOULD_WAIT_FOR_QUIESCENCE] boolValue];
-      app.launchArguments = (NSArray<NSString *> *)capabilities[FB_CAP_ARGUMENTS] ?: @[];
-      app.launchEnvironment = (NSDictionary <NSString *, NSString *> *)capabilities[FB_CAP_ENVIRNOMENT] ?: @{};
-      if (nil != initialUrl) {
-        if (app.running) {
-          [app terminate];
-        }
-        id<FBResponsePayload> errorResponse = [self openDeepLink:initialUrl
-                                                 withApplication:bundleID
-                                                         timeout:capabilities[FB_CAP_APP_LAUNCH_STATE_TIMEOUT_SEC]];
-        if (nil != errorResponse) {
-          return errorResponse;
-        }
-      } else {
-        NSTimeInterval defaultTimeout = _XCTApplicationStateTimeout();
-        if (nil != capabilities[FB_CAP_APP_LAUNCH_STATE_TIMEOUT_SEC]) {
-          _XCTSetApplicationStateTimeout([capabilities[FB_CAP_APP_LAUNCH_STATE_TIMEOUT_SEC] doubleValue]);
-        }
-        @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 (!app.running) {
-        NSString *errorMsg = [NSString stringWithFormat:@"Cannot launch %@ application. Make sure the correct bundle identifier has been provided in capabilities and check the device log for possible crash report occurrences", bundleID];
-        return FBResponseWithStatus([FBCommandStatus sessionNotCreatedError:errorMsg
-                                                                  traceback:nil]);
-      }
-    } else if (appState == XCUIApplicationStateRunningBackground && !forceAppLaunch) {
-      if (nil != initialUrl) {
-        id<FBResponsePayload> errorResponse = [self openDeepLink:initialUrl
-                                                 withApplication:bundleID
-                                                         timeout:nil];
-        if (nil != errorResponse) {
-          return errorResponse;
-        }
-      } else {
-        [app activate];
-      }
-    }
+  errorResponse = [self prepareApplicationForSessionWithBundleID:bundleID
+                                                      initialUrl:initialUrl
+                                                    capabilities:capabilities
+                                                     application:&app];
+  if (nil != errorResponse) {
+    return errorResponse;
   }
 
   if (nil != initialUrl && nil == bundleID) {
-    id<FBResponsePayload> errorResponse = [self openDeepLink:initialUrl
-                                             withApplication:nil
-                                                     timeout:capabilities[FB_CAP_APP_LAUNCH_STATE_TIMEOUT_SEC]];
+    errorResponse = [self openDeepLink:initialUrl
+                       withApplication:nil
+                               timeout:capabilities[FB_CAP_APP_LAUNCH_STATE_TIMEOUT_SEC]];
     if (nil != errorResponse) {
       return errorResponse;
     }
   }
 
-  if (capabilities[FB_SETTING_DEFAULT_ALERT_ACTION]) {
-    [FBSession initWithApplication:app
-                defaultAlertAction:(id)capabilities[FB_SETTING_DEFAULT_ALERT_ACTION]];
-  } else {
-    [FBSession initWithApplication:app];
-  }
-
-  if (nil != capabilities[FB_CAP_USE_NATIVE_CACHING_STRATEGY]) {
-    FBSession.activeSession.useNativeCachingStrategy = [capabilities[FB_CAP_USE_NATIVE_CACHING_STRATEGY] boolValue];
-  }
+  [self initializeSessionWithApplication:app capabilities:capabilities];
 
   return FBResponseWithObject(FBSessionCommands.sessionInformation);
 }
@@ -290,6 +192,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,
@@ -297,20 +209,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
     }
   );
 }
@@ -325,196 +237,199 @@
 
 + (id<FBResponsePayload>)handleGetSettings:(FBRouteRequest *)request
 {
-  return FBResponseWithObject(
-    @{
-      FB_SETTING_USE_COMPACT_RESPONSES: @([FBConfiguration shouldUseCompactResponses]),
-      FB_SETTING_ELEMENT_RESPONSE_ATTRIBUTES: [FBConfiguration elementResponseAttributes],
-      FB_SETTING_MJPEG_SERVER_SCREENSHOT_QUALITY: @([FBConfiguration mjpegServerScreenshotQuality]),
-      FB_SETTING_MJPEG_SERVER_FRAMERATE: @([FBConfiguration mjpegServerFramerate]),
-      FB_SETTING_MJPEG_SCALING_FACTOR: @([FBConfiguration mjpegScalingFactor]),
-      FB_SETTING_MJPEG_FIX_ORIENTATION: @([FBConfiguration mjpegShouldFixOrientation]),
-      FB_SETTING_SCREENSHOT_QUALITY: @([FBConfiguration screenshotQuality]),
-      FB_SETTING_KEYBOARD_AUTOCORRECTION: @([FBConfiguration keyboardAutocorrection]),
-      FB_SETTING_KEYBOARD_PREDICTION: @([FBConfiguration keyboardPrediction]),
-      FB_SETTING_SNAPSHOT_MAX_DEPTH: @([FBConfiguration snapshotMaxDepth]),
-      FB_SETTING_USE_FIRST_MATCH: @([FBConfiguration useFirstMatch]),
-      FB_SETTING_WAIT_FOR_IDLE_TIMEOUT: @([FBConfiguration waitForIdleTimeout]),
-      FB_SETTING_ANIMATION_COOL_OFF_TIMEOUT: @([FBConfiguration animationCoolOffTimeout]),
-      FB_SETTING_BOUND_ELEMENTS_BY_INDEX: @([FBConfiguration boundElementsByIndex]),
-      FB_SETTING_REDUCE_MOTION: @([FBConfiguration reduceMotionEnabled]),
-      FB_SETTING_DEFAULT_ACTIVE_APPLICATION: request.session.defaultActiveApplication,
-      FB_SETTING_ACTIVE_APP_DETECTION_POINT: FBActiveAppDetectionPoint.sharedInstance.stringCoordinates,
-      FB_SETTING_INCLUDE_NON_MODAL_ELEMENTS: @([FBConfiguration includeNonModalElements]),
-      FB_SETTING_ACCEPT_ALERT_BUTTON_SELECTOR: FBConfiguration.acceptAlertButtonSelector,
-      FB_SETTING_DISMISS_ALERT_BUTTON_SELECTOR: FBConfiguration.dismissAlertButtonSelector,
-      FB_SETTING_AUTO_CLICK_ALERT_SELECTOR: FBConfiguration.autoClickAlertSelector,
-      FB_SETTING_DEFAULT_ALERT_ACTION: request.session.defaultAlertAction ?: @"",
-      FB_SETTING_MAX_TYPING_FREQUENCY: @([FBConfiguration maxTypingFrequency]),
-      FB_SETTING_RESPECT_SYSTEM_ALERTS: @([FBConfiguration shouldRespectSystemAlerts]),
-      FB_SETTING_USE_CLEAR_TEXT_SHORTCUT: @([FBConfiguration useClearTextShortcut]),
-      FB_SETTING_INCLUDE_HITTABLE_IN_PAGE_SOURCE: @([FBConfiguration includeHittableInPageSource]),
-      FB_SETTING_INCLUDE_NATIVE_FRAME_IN_PAGE_SOURCE: @([FBConfiguration includeNativeFrameInPageSource]),
-      FB_SETTING_INCLUDE_MIN_MAX_VALUE_IN_PAGE_SOURCE: @([FBConfiguration includeMinMaxValueInPageSource]),
-      FB_SETTING_INCLUDE_CUSTOM_ACTIONS_IN_PAGE_SOURCE: @([FBConfiguration includeCustomActionsInPageSource]),
-      FB_SETTING_ENFORCE_CUSTOM_SNAPSHOTS: @([FBConfiguration enforceCustomSnapshots]),
-      FB_SETTING_LIMIT_XPATH_CONTEXT_SCOPE: @([FBConfiguration limitXpathContextScope]),
-#if !TARGET_OS_TV
-      FB_SETTING_SCREENSHOT_ORIENTATION: [FBConfiguration humanReadableScreenshotOrientation],
-#endif
-    }
-  );
+  return FBResponseWithObject([FBSettingsHandler currentSettingsForSession:request.session]);
 }
 
-// TODO if we get lots more settings, handling them with a series of if-statements will be unwieldy
-// and this should be refactored
 + (id<FBResponsePayload>)handleSetSettings:(FBRouteRequest *)request
 {
-  NSDictionary* settings = request.arguments[@"settings"];
-
-  if (nil != [settings objectForKey:FB_SETTING_USE_COMPACT_RESPONSES]) {
-    [FBConfiguration setShouldUseCompactResponses:[[settings objectForKey:FB_SETTING_USE_COMPACT_RESPONSES] boolValue]];
-  }
-  if (nil != [settings objectForKey:FB_SETTING_ELEMENT_RESPONSE_ATTRIBUTES]) {
-    [FBConfiguration setElementResponseAttributes:(NSString *)[settings objectForKey:FB_SETTING_ELEMENT_RESPONSE_ATTRIBUTES]];
-  }
-  if (nil != [settings objectForKey:FB_SETTING_MJPEG_SERVER_SCREENSHOT_QUALITY]) {
-    [FBConfiguration setMjpegServerScreenshotQuality:[[settings objectForKey:FB_SETTING_MJPEG_SERVER_SCREENSHOT_QUALITY] unsignedIntegerValue]];
-  }
-  if (nil != [settings objectForKey:FB_SETTING_MJPEG_SERVER_FRAMERATE]) {
-    [FBConfiguration setMjpegServerFramerate:[[settings objectForKey:FB_SETTING_MJPEG_SERVER_FRAMERATE] unsignedIntegerValue]];
-  }
-  if (nil != [settings objectForKey:FB_SETTING_SCREENSHOT_QUALITY]) {
-    [FBConfiguration setScreenshotQuality:[[settings objectForKey:FB_SETTING_SCREENSHOT_QUALITY] unsignedIntegerValue]];
+  id settingsArgument = request.arguments[@"settings"];
+  if (nil != settingsArgument && ![settingsArgument isKindOfClass:NSDictionary.class]) {
+    return FBResponseWithStatus([FBCommandStatus invalidArgumentErrorWithMessage:@"settings must be a dictionary"
+                                                                       traceback:nil]);
   }
-  if (nil != [settings objectForKey:FB_SETTING_MJPEG_SCALING_FACTOR]) {
-    [FBConfiguration setMjpegScalingFactor:[[settings objectForKey:FB_SETTING_MJPEG_SCALING_FACTOR] floatValue]];
+  NSDictionary *settings = settingsArgument ?: @{};
+  FBCommandStatus *status = [FBSettingsHandler applySettings:settings
+                                                   toSession:request.session];
+  if (status.hasError) {
+    return FBResponseWithStatus(status);
   }
-  if (nil != [settings objectForKey:FB_SETTING_MJPEG_FIX_ORIENTATION]) {
-    [FBConfiguration setMjpegShouldFixOrientation:[[settings objectForKey:FB_SETTING_MJPEG_FIX_ORIENTATION] boolValue]];
-  }
-  if (nil != [settings objectForKey:FB_SETTING_KEYBOARD_AUTOCORRECTION]) {
-    [FBConfiguration setKeyboardAutocorrection:[[settings objectForKey:FB_SETTING_KEYBOARD_AUTOCORRECTION] boolValue]];
-  }
-  if (nil != [settings objectForKey:FB_SETTING_KEYBOARD_PREDICTION]) {
-    [FBConfiguration setKeyboardPrediction:[[settings objectForKey:FB_SETTING_KEYBOARD_PREDICTION] boolValue]];
-  }
-  if (nil != [settings objectForKey:FB_SETTING_RESPECT_SYSTEM_ALERTS]) {
-    [FBConfiguration setShouldRespectSystemAlerts:[[settings objectForKey:FB_SETTING_RESPECT_SYSTEM_ALERTS] boolValue]];
-  }
-  if (nil != [settings objectForKey:FB_SETTING_SNAPSHOT_MAX_DEPTH]) {
-    [FBConfiguration setSnapshotMaxDepth:[[settings objectForKey:FB_SETTING_SNAPSHOT_MAX_DEPTH] intValue]];
+  return [self handleGetSettings:request];
+}
+
+
+#pragma mark - Session Creation Helpers
+
++ (nullable id<FBResponsePayload>)capabilitiesFromCreateSessionRequest:(FBRouteRequest *)request
+                                                         capabilitiesOut:(NSDictionary<NSString *, id> *_Nonnull *_Nonnull)capabilitiesOut
+{
+  if (![request.arguments[@"capabilities"] isKindOfClass:NSDictionary.class]) {
+    return FBResponseWithStatus([FBCommandStatus sessionNotCreatedError:@"'capabilities' is mandatory to create a new session"
+                                                              traceback:nil]);
   }
-  if (nil != [settings objectForKey:FB_SETTING_USE_FIRST_MATCH]) {
-    [FBConfiguration setUseFirstMatch:[[settings objectForKey:FB_SETTING_USE_FIRST_MATCH] boolValue]];
+  NSError *error;
+  NSDictionary<NSString *, id> *capabilities = FBParseCapabilities((NSDictionary *)request.arguments[@"capabilities"], &error);
+  if (nil == capabilities) {
+    return FBResponseWithStatus([FBCommandStatus sessionNotCreatedError:error.localizedDescription traceback:nil]);
   }
-  if (nil != [settings objectForKey:FB_SETTING_BOUND_ELEMENTS_BY_INDEX]) {
-    [FBConfiguration setBoundElementsByIndex:[[settings objectForKey:FB_SETTING_BOUND_ELEMENTS_BY_INDEX] boolValue]];
+  *capabilitiesOut = capabilities;
+  return nil;
+}
+
++ (void)applyConfigurationFromCapabilities:(NSDictionary<NSString *, id> *)capabilities
+{
+  [FBConfiguration.sharedInstance resetSessionSettings];
+  if (capabilities[FB_SETTING_USE_COMPACT_RESPONSES]) {
+    FBConfiguration.sharedInstance.shouldUseCompactResponses = [capabilities[FB_SETTING_USE_COMPACT_RESPONSES] boolValue];
   }
-  if (nil != [settings objectForKey:FB_SETTING_REDUCE_MOTION]) {
-    [FBConfiguration setReduceMotionEnabled:[[settings objectForKey:FB_SETTING_REDUCE_MOTION] boolValue]];
+  NSString *elementResponseAttributes = capabilities[FB_SETTING_ELEMENT_RESPONSE_ATTRIBUTES];
+  if (elementResponseAttributes) {
+    FBConfiguration.sharedInstance.elementResponseAttributes = elementResponseAttributes;
   }
-  if (nil != [settings objectForKey:FB_SETTING_DEFAULT_ACTIVE_APPLICATION]) {
-    request.session.defaultActiveApplication = (NSString *)[settings objectForKey:FB_SETTING_DEFAULT_ACTIVE_APPLICATION];
+  if (capabilities[FB_CAP_MAX_TYPING_FREQUENCY]) {
+    FBConfiguration.sharedInstance.maxTypingFrequency = [capabilities[FB_CAP_MAX_TYPING_FREQUENCY] unsignedIntegerValue];
   }
-  if (nil != [settings objectForKey:FB_SETTING_ACTIVE_APP_DETECTION_POINT]) {
-    NSError *error;
-    if (![FBActiveAppDetectionPoint.sharedInstance setCoordinatesWithString:(NSString *)[settings objectForKey:FB_SETTING_ACTIVE_APP_DETECTION_POINT]
-                                                                      error:&error]) {
-      return FBResponseWithStatus([FBCommandStatus invalidArgumentErrorWithMessage:error.localizedDescription
-                                                                         traceback:nil]);
-    }
+  if (capabilities[FB_CAP_USE_SINGLETON_TEST_MANAGER]) {
+    FBConfiguration.sharedInstance.shouldUseSingletonTestManager = [capabilities[FB_CAP_USE_SINGLETON_TEST_MANAGER] boolValue];
   }
-  if (nil != [settings objectForKey:FB_SETTING_INCLUDE_NON_MODAL_ELEMENTS]) {
-    if ([XCUIElement fb_supportsNonModalElementsInclusion]) {
-      [FBConfiguration setIncludeNonModalElements:[[settings objectForKey:FB_SETTING_INCLUDE_NON_MODAL_ELEMENTS] boolValue]];
+  if (capabilities[FB_CAP_DISABLE_AUTOMATIC_SCREENSHOTS]) {
+    if ([capabilities[FB_CAP_DISABLE_AUTOMATIC_SCREENSHOTS] boolValue]) {
+      [FBConfiguration.sharedInstance disableScreenshots];
     } else {
-      [FBLogger logFmt:@"'%@' settings value cannot be assigned, because non modal elements inclusion is not supported by the current iOS SDK", FB_SETTING_INCLUDE_NON_MODAL_ELEMENTS];
+      [FBConfiguration.sharedInstance enableScreenshots];
     }
   }
-  if (nil != [settings objectForKey:FB_SETTING_ACCEPT_ALERT_BUTTON_SELECTOR]) {
-    [FBConfiguration setAcceptAlertButtonSelector:(NSString *)[settings objectForKey:FB_SETTING_ACCEPT_ALERT_BUTTON_SELECTOR]];
-  }
-  if (nil != [settings objectForKey:FB_SETTING_DISMISS_ALERT_BUTTON_SELECTOR]) {
-    [FBConfiguration setDismissAlertButtonSelector:(NSString *)[settings objectForKey:FB_SETTING_DISMISS_ALERT_BUTTON_SELECTOR]];
-  }
-  if (nil != [settings objectForKey:FB_SETTING_AUTO_CLICK_ALERT_SELECTOR]) {
-    FBCommandStatus *status = [self.class configureAutoClickAlertWithSelector:settings[FB_SETTING_AUTO_CLICK_ALERT_SELECTOR]
-                                                                   forSession:request.session];
-    if (status.hasError) {
-      return FBResponseWithStatus(status);
-    }
-  }
-  if (nil != [settings objectForKey:FB_SETTING_WAIT_FOR_IDLE_TIMEOUT]) {
-    [FBConfiguration setWaitForIdleTimeout:[[settings objectForKey:FB_SETTING_WAIT_FOR_IDLE_TIMEOUT] doubleValue]];
-  }
-  if (nil != [settings objectForKey:FB_SETTING_ANIMATION_COOL_OFF_TIMEOUT]) {
-    [FBConfiguration setAnimationCoolOffTimeout:[[settings objectForKey:FB_SETTING_ANIMATION_COOL_OFF_TIMEOUT] doubleValue]];
-  }
-  if ([[settings objectForKey:FB_SETTING_DEFAULT_ALERT_ACTION] isKindOfClass:NSString.class]) {
-    request.session.defaultAlertAction = [settings[FB_SETTING_DEFAULT_ALERT_ACTION] lowercaseString];
-  }
-  if (nil != [settings objectForKey:FB_SETTING_MAX_TYPING_FREQUENCY]) {
-    [FBConfiguration setMaxTypingFrequency:[[settings objectForKey:FB_SETTING_MAX_TYPING_FREQUENCY] unsignedIntegerValue]];
-  }
-  if (nil != [settings objectForKey:FB_SETTING_USE_CLEAR_TEXT_SHORTCUT]) {
-    [FBConfiguration setUseClearTextShortcut:[[settings objectForKey:FB_SETTING_USE_CLEAR_TEXT_SHORTCUT] boolValue]];
-  }
-  if (nil != [settings objectForKey:FB_SETTING_INCLUDE_HITTABLE_IN_PAGE_SOURCE]) {
-    [FBConfiguration setIncludeHittableInPageSource:[[settings objectForKey:FB_SETTING_INCLUDE_HITTABLE_IN_PAGE_SOURCE] boolValue]];
-  }
-  if (nil != [settings objectForKey:FB_SETTING_INCLUDE_NATIVE_FRAME_IN_PAGE_SOURCE]) {
-    [FBConfiguration setIncludeNativeFrameInPageSource:[[settings objectForKey:FB_SETTING_INCLUDE_NATIVE_FRAME_IN_PAGE_SOURCE] boolValue]];
+  if (capabilities[FB_CAP_SHOULD_TERMINATE_APP]) {
+    FBConfiguration.sharedInstance.shouldTerminateApp = [capabilities[FB_CAP_SHOULD_TERMINATE_APP] boolValue];
   }
-  if (nil != [settings objectForKey:FB_SETTING_INCLUDE_MIN_MAX_VALUE_IN_PAGE_SOURCE]) {
-    [FBConfiguration setIncludeMinMaxValueInPageSource:[[settings objectForKey:FB_SETTING_INCLUDE_MIN_MAX_VALUE_IN_PAGE_SOURCE] boolValue]];
+  NSNumber *delay = capabilities[FB_CAP_EVENT_LOOP_IDLE_DELAY_SEC];
+  if ([delay doubleValue] > 0.0) {
+    [XCUIApplicationProcessDelay setEventLoopHasIdledDelay:[delay doubleValue]];
+  } else {
+    [XCUIApplicationProcessDelay disableEventLoopDelay];
   }
-  if (nil != [settings objectForKey:FB_SETTING_INCLUDE_CUSTOM_ACTIONS_IN_PAGE_SOURCE]) {
-    [FBConfiguration setIncludeCustomActionsInPageSource:[[settings objectForKey:FB_SETTING_INCLUDE_CUSTOM_ACTIONS_IN_PAGE_SOURCE] boolValue]];
+  if (nil != capabilities[FB_SETTING_WAIT_FOR_IDLE_TIMEOUT]) {
+    FBConfiguration.sharedInstance.waitForIdleTimeout = [capabilities[FB_SETTING_WAIT_FOR_IDLE_TIMEOUT] doubleValue];
   }
-  if (nil != [settings objectForKey:FB_SETTING_ENFORCE_CUSTOM_SNAPSHOTS]) {
-    [FBConfiguration setEnforceCustomSnapshots:[[settings objectForKey:FB_SETTING_ENFORCE_CUSTOM_SNAPSHOTS] boolValue]];
+  if (nil != capabilities[FB_SETTING_ACCESSIBILITY_DEADLINE]) {
+    FBConfiguration.sharedInstance.accessibilityDeadline = [capabilities[FB_SETTING_ACCESSIBILITY_DEADLINE] doubleValue];
   }
-  if (nil != [settings objectForKey:FB_SETTING_LIMIT_XPATH_CONTEXT_SCOPE]) {
-    [FBConfiguration setLimitXpathContextScope:[[settings objectForKey:FB_SETTING_LIMIT_XPATH_CONTEXT_SCOPE] boolValue]];
+  if (nil == capabilities[FB_CAP_FORCE_SIMULATOR_SOFTWARE_KEYBOARD_PRESENCE] ||
+      [capabilities[FB_CAP_FORCE_SIMULATOR_SOFTWARE_KEYBOARD_PRESENCE] boolValue]) {
+    [FBConfiguration.sharedInstance forceSimulatorSoftwareKeyboardPresence];
   }
+}
 
-#if !TARGET_OS_TV
-  if (nil != [settings objectForKey:FB_SETTING_SCREENSHOT_ORIENTATION]) {
-    NSError *error;
-    if (![FBConfiguration setScreenshotOrientation:(NSString *)[settings objectForKey:FB_SETTING_SCREENSHOT_ORIENTATION]
-                                             error:&error]) {
-      return FBResponseWithStatus([FBCommandStatus invalidArgumentErrorWithMessage:error.localizedDescription
-                                                                         traceback:nil]);
++ (nullable id<FBResponsePayload>)prepareApplicationForSessionWithBundleID:(nullable NSString *)bundleID
+                                                                initialUrl:(nullable NSString *)initialUrl
+                                                            capabilities:(NSDictionary<NSString *, id> *)capabilities
+                                                             application:(XCUIApplication *_Nullable *_Nonnull)applicationOut
+{
+  if (nil == bundleID) {
+    *applicationOut = nil;
+    return nil;
+  }
+
+  XCUIApplication *app = [[XCUIApplication alloc] initWithBundleIdentifier:(NSString * _Nonnull)bundleID];
+  BOOL forceAppLaunch = nil == capabilities[FB_CAP_FORCE_APP_LAUNCH]
+    || [capabilities[FB_CAP_FORCE_APP_LAUNCH] boolValue];
+  XCUIApplicationState appState = app.state;
+  BOOL isAppRunning = appState >= XCUIApplicationStateRunningBackground;
+
+  if (!isAppRunning || (isAppRunning && forceAppLaunch)) {
+    id<FBResponsePayload> errorResponse = [self launchApplication:app
+                                                         bundleID:bundleID
+                                                       initialUrl:initialUrl
+                                                     capabilities:capabilities];
+    if (nil != errorResponse) {
+      return errorResponse;
+    }
+  } else if (appState == XCUIApplicationStateRunningBackground && !forceAppLaunch) {
+    id<FBResponsePayload> errorResponse = [self activateBackgroundApplication:app
+                                                                     bundleID:bundleID
+                                                                   initialUrl:initialUrl];
+    if (nil != errorResponse) {
+      return errorResponse;
     }
   }
-#endif
 
-  return [self handleGetSettings:request];
+  *applicationOut = app;
+  return nil;
 }
 
++ (nullable id<FBResponsePayload>)launchApplication:(XCUIApplication *)app
+                                           bundleID:(NSString *)bundleID
+                                         initialUrl:(nullable NSString *)initialUrl
+                                       capabilities:(NSDictionary<NSString *, id> *)capabilities
+{
+  app.fb_shouldWaitForQuiescence = nil == capabilities[FB_CAP_SHOULD_WAIT_FOR_QUIESCENCE]
+    || [capabilities[FB_CAP_SHOULD_WAIT_FOR_QUIESCENCE] boolValue];
+  app.launchArguments = (NSArray<NSString *> *)capabilities[FB_CAP_ARGUMENTS] ?: @[];
+  app.launchEnvironment = (NSDictionary<NSString *, NSString *> *)capabilities[FB_CAP_ENVIRNOMENT] ?: @{};
+
+  if (nil != initialUrl) {
+    if (app.running) {
+      [app terminate];
+    }
+    id<FBResponsePayload> errorResponse = [self openDeepLink:initialUrl
+                                               withApplication:bundleID
+                                                       timeout:capabilities[FB_CAP_APP_LAUNCH_STATE_TIMEOUT_SEC]];
+    if (nil != errorResponse) {
+      return errorResponse;
+    }
+  } else {
+    __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]) {
+      [FBXCAXClientProxy withApplicationStateTimeout:[capabilities[FB_CAP_APP_LAUNCH_STATE_TIMEOUT_SEC] doubleValue]
+                                                   do:launchBlock];
+    } else {
+      launchBlock();
+    }
+    if (nil != launchErrorResponse) {
+      return launchErrorResponse;
+    }
+  }
 
-#pragma mark - Helpers
+  if (!app.running) {
+    NSString *errorMsg = [NSString stringWithFormat:@"Cannot launch %@ application. Make sure the correct bundle identifier has been provided in capabilities and check the device log for possible crash report occurrences", bundleID];
+    return FBResponseWithStatus([FBCommandStatus sessionNotCreatedError:errorMsg traceback:nil]);
+  }
+  return nil;
+}
 
-+ (FBCommandStatus *)configureAutoClickAlertWithSelector:(NSString *)selector
-                                              forSession:(FBSession *)session
++ (nullable id<FBResponsePayload>)activateBackgroundApplication:(XCUIApplication *)app
+                                                       bundleID:(NSString *)bundleID
+                                                     initialUrl:(nullable NSString *)initialUrl
 {
-  if (0 == [selector length]) {
-    [FBConfiguration setAutoClickAlertSelector:selector];
-    [session disableAlertsMonitor];
-    return [FBCommandStatus ok];
+  if (nil != initialUrl) {
+    return [self openDeepLink:initialUrl withApplication:bundleID timeout:nil];
   }
+  [app activate];
+  return nil;
+}
 
-  NSError *error;
-  FBClassChain *parsedChain = [FBClassChainQueryParser parseQuery:selector error:&error];
-  if (nil == parsedChain) {
-    return [FBCommandStatus invalidSelectorErrorWithMessage:error.localizedDescription
-                                                  traceback:nil];
-  }
-  [FBConfiguration setAutoClickAlertSelector:selector];
-  [session enableAlertsMonitor];
-  return [FBCommandStatus ok];
++ (void)initializeSessionWithApplication:(nullable XCUIApplication *)app
+                          capabilities:(NSDictionary<NSString *, id> *)capabilities
+{
+  if (capabilities[FB_SETTING_DEFAULT_ALERT_ACTION]) {
+    [FBSession initWithApplication:app
+                defaultAlertAction:(id)capabilities[FB_SETTING_DEFAULT_ALERT_ACTION]];
+  } else {
+    [FBSession initWithApplication:app];
+  }
+  if (nil != capabilities[FB_CAP_USE_NATIVE_CACHING_STRATEGY]) {
+    FBSession.activeSession.useNativeCachingStrategy = [capabilities[FB_CAP_USE_NATIVE_CACHING_STRATEGY] boolValue];
+  }
 }
 
+#pragma mark - Helpers
+
 + (NSString *)buildTimestamp
 {
   return [NSString stringWithFormat:@"%@ %@",
@@ -536,6 +451,7 @@
   };
 }
 
+#if !TARGET_OS_WATCH
 /*
  Return the device kind as lower case
 */
@@ -552,26 +468,32 @@
   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
                               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]
@@ -579,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