appium-webdriveragent 3.9.2 → 3.12.0

package/WebDriverAgentLib/Categories/XCUIElement+FBIsVisible.m

@@ -13,11 +13,13 @@
 #import "FBElementUtils.h"
 #import "FBMathUtils.h"
 #import "FBActiveAppDetectionPoint.h"
+#import "FBSession.h"
 #import "FBXCodeCompatibility.h"
 #import "XCAccessibilityElement+FBComparison.h"
 #import "XCElementSnapshot+FBHelpers.h"
 #import "XCElementSnapshot+FBHitPoint.h"
 #import "XCUIElement+FBUtilities.h"
+#import "XCUIElement+FBUID.h"
 #import "XCTestPrivateSymbols.h"
 
 @implementation XCUIElement (FBIsVisible)
@@ -32,35 +34,46 @@
 
 @implementation XCElementSnapshot (FBIsVisible)
 
-static NSMutableDictionary<NSNumber *, NSMutableDictionary<NSString *, NSNumber *> *> *fb_generationsCache;
-
-+ (void)load
+- (NSString *)fb_uniqId
 {
-  fb_generationsCache = [NSMutableDictionary dictionary];
+  return self.fb_uid ?: [NSString stringWithFormat:@"%p", (void *)self];
 }
 
 - (nullable NSNumber *)fb_cachedVisibilityValue
 {
-  NSNumber* generationObj = [NSNumber numberWithUnsignedLongLong:self.generation];
-  NSDictionary<NSString *, NSNumber *> *result = [fb_generationsCache objectForKey:generationObj];
+  NSMutableDictionary *cache = FBSession.activeSession.elementsVisibilityCache;
+  if (nil == cache) {
+    return nil;
+  }
+
+  NSDictionary<NSString *, NSNumber *> *result = [cache objectForKey:@(self.generation)];
   if (nil == result) {
     // There is no need to keep the cached data for the previous generations
-    [fb_generationsCache removeAllObjects];
-    [fb_generationsCache setObject:[NSMutableDictionary dictionary] forKey:generationObj];
+    [cache removeAllObjects];
+    [cache setObject:[NSMutableDictionary dictionary] forKey:@(self.generation)];
     return nil;
   }
-  return [result objectForKey:[NSString stringWithFormat:@"%p", (void *)self]];
+  return [result objectForKey:self.fb_uniqId];
 }
 
-- (BOOL)fb_cacheVisibilityWithValue:(BOOL)isVisible forAncestors:(nullable NSArray<XCElementSnapshot *> *)ancestors
+- (BOOL)fb_cacheVisibilityWithValue:(BOOL)isVisible
+                       forAncestors:(nullable NSArray<XCElementSnapshot *> *)ancestors
 {
-  NSMutableDictionary<NSString *, NSNumber *> *destination = [fb_generationsCache objectForKey:@(self.generation)];
+  NSMutableDictionary *cache = FBSession.activeSession.elementsVisibilityCache;
+  if (nil == cache) {
+    return isVisible;
+  }
+  NSMutableDictionary<NSString *, NSNumber *> *destination = [cache objectForKey:@(self.generation)];
+  if (nil == destination) {
+    return isVisible;
+  }
+
   NSNumber *visibleObj = [NSNumber numberWithBool:isVisible];
-  [destination setObject:visibleObj forKey:[NSString stringWithFormat:@"%p", (void *)self]];
+  [destination setObject:visibleObj forKey:self.fb_uniqId];
   if (isVisible && nil != ancestors) {
     // if an element is visible then all its ancestors must be visible as well
     for (XCElementSnapshot *ancestor in ancestors) {
-      NSString *ancestorId = [NSString stringWithFormat:@"%p", (void *)ancestor];
+      NSString *ancestorId = ancestor.fb_uniqId;
       if (nil == [destination objectForKey:ancestorId]) {
         [destination setObject:visibleObj forKey:ancestorId];
       }
@@ -69,7 +82,8 @@ static NSMutableDictionary<NSNumber *, NSMutableDictionary<NSString *, NSNumber
   return isVisible;
 }
 
-- (CGRect)fb_frameInContainer:(XCElementSnapshot *)container hierarchyIntersection:(nullable NSValue *)intersectionRectange
+- (CGRect)fb_frameInContainer:(XCElementSnapshot *)container
+        hierarchyIntersection:(nullable NSValue *)intersectionRectange
 {
   CGRect currentRectangle = nil == intersectionRectange ? self.frame : [intersectionRectange CGRectValue];
   XCElementSnapshot *parent = self.parent;

package/WebDriverAgentLib/Categories/XCUIElement+FBResolve.h

@@ -0,0 +1,37 @@
+/**
+ * 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. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#import <XCTest/XCTest.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface XCUIElement (FBResolve)
+
+/*! This property is always true unless the element gets resolved by its internal UUID (e.g. results of an xpath query) */
+@property (nullable, nonatomic) NSNumber *fb_isResolvedNatively;
+
+/**
+ Returns element instance based on query by element's UUID rather than any other attributes, which
+ might be a subject of change during the application life cycle. The UUID is calculated based on the PID
+ of the application to which this particular element belongs and the identifier of the underlying AXElement
+ instance. That usually guarantees the same element is always going to be matched in scope of the parent
+ application independently of its current attribute values.
+ Example: We have an element X with value Y. Our locator looks like 'value == Y'. Normally, if the element's
+ value is changed to Z and we try to reuse this cached instance of it then a StaleElement error is thrown.
+ Although, if the cached element instance is the one returned by this API call then the same element
+ is going to be matched and no staleness exception will be thrown.
+
+ @return Either the same element instance if `fb_isResolvedNatively` was set to NO (usually the cache for elements
+ matched by xpath locators) or the stable instance of the self element based on the query by element's UUID.
+ */
+- (XCUIElement *)fb_stableInstance;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/WebDriverAgentLib/Categories/XCUIElement+FBResolve.m

@@ -0,0 +1,51 @@
+/**
+ * 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. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+#import "XCUIElement+FBResolve.h"
+
+#import <objc/runtime.h>
+
+#import "XCUIElement.h"
+#import "FBXCodeCompatibility.h"
+#import "XCUIElement+FBUID.h"
+
+@implementation XCUIElement (FBResolve)
+
+static char XCUIELEMENT_IS_RESOLVED_NATIVELY_KEY;
+
+@dynamic fb_isResolvedNatively;
+
+- (void)setFb_isResolvedNatively:(NSNumber *)isResolvedNatively
+{
+  objc_setAssociatedObject(self, &XCUIELEMENT_IS_RESOLVED_NATIVELY_KEY, isResolvedNatively, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
+}
+
+- (NSNumber *)fb_isResolvedNatively
+{
+  NSNumber *result = objc_getAssociatedObject(self, &XCUIELEMENT_IS_RESOLVED_NATIVELY_KEY);
+  return nil == result ? @YES : result;
+}
+
+- (XCUIElement *)fb_stableInstance
+{
+  if (![self.fb_isResolvedNatively boolValue]) {
+    return self;
+  }
+
+  XCUIElementQuery *query = [self isKindOfClass:XCUIApplication.class]
+    ? self.application.fb_query
+    : [self.application.fb_query descendantsMatchingType:XCUIElementTypeAny];
+  XCElementSnapshot *cachedSnapshot = self.fb_cachedSnapshot;
+  NSString *uid = nil == cachedSnapshot ? self.fb_uid : cachedSnapshot.fb_uid;
+  return nil == uid
+    ? self
+    : [query matchingPredicate:[NSPredicate predicateWithFormat:@"%K = %@", FBStringify(XCUIElement, wdUID), uid]].fb_firstMatch;
+}
+
+@end

package/WebDriverAgentLib/Categories/XCUIElement+FBUtilities.m

@@ -35,6 +35,7 @@
 #import "XCUIElementQuery+FBHelpers.h"
 #import "XCUIElement+FBUID.h"
 #import "XCUIScreen.h"
+#import "XCUIElement+FBResolve.h"
 
 #define DEFAULT_AX_TIMEOUT 60.
 
@@ -113,7 +114,7 @@
   if (nil == snapshotWithAttributes) {
     [FBLogger logFmt:@"Cannot take a snapshot with attribute(s) %@ of '%@' after %.2f seconds",
      attributeNames, snapshot.fb_description, axTimeout];
-    [FBLogger logFmt:@"This timeout could be customized via '%@' setting", CUSTOM_SNAPSHOT_TIMEOUT];
+    [FBLogger logFmt:@"This timeout could be customized via '%@' setting", FB_SETTING_CUSTOM_SNAPSHOT_TIMEOUT];
     [FBLogger logFmt:@"Internal error: %@", error.localizedDescription];
     [FBLogger logFmt:@"Falling back to the default snapshotting mechanism for the element '%@' (some attribute values, like visibility or accessibility might not be precise though)", snapshot.fb_description];
     snapshotWithAttributes = self.lastSnapshot;
@@ -159,6 +160,7 @@
   query = [query matchingPredicate:[NSPredicate predicateWithFormat:@"%K IN %@", FBStringify(XCUIElement, wdUID), sortedIds]];
   if (1 == snapshots.count) {
     XCUIElement *result = query.fb_firstMatch;
+    result.fb_isResolvedNatively = @NO;
     return result ? @[result] : @[];
   }
   // Rely here on the fact, that XPath always returns query results in the same
@@ -176,7 +178,11 @@
   //    }
   //    return NSOrderedSame;
   //  }];
-  return query.fb_allMatches;
+  NSArray<XCUIElement *> *result = query.fb_allMatches;
+  for (XCUIElement *el in result) {
+    el.fb_isResolvedNatively = @NO;
+  }
+  return result;
 }
 
 - (void)fb_waitUntilStable

package/WebDriverAgentLib/Commands/FBElementCommands.m

@@ -38,6 +38,7 @@
 #import "XCUIElement+FBUtilities.h"
 #import "XCUIElement+FBWebDriverAttributes.h"
 #import "XCUIElement+FBTVFocuse.h"
+#import "XCUIElement+FBResolve.h"
 #import "FBElementTypeTransformer.h"
 #import "XCUIElement.h"
 #import "XCUIElementQuery.h"
@@ -258,7 +259,8 @@
   XCUIElement *focusedElement = request.session.activeApplication.fb_focusedElement;
   if (focusedElement != nil) {
     FBElementCache *elementCache = request.session.elementCache;
-    NSString *focusedUUID = [elementCache storeElement:focusedElement];
+    BOOL useNativeCachingStrategy = request.session.useNativeCachingStrategy;
+    NSString *focusedUUID = [elementCache storeElement:(useNativeCachingStrategy ? focusedElement : focusedElement.fb_stableInstance)];
     if (focusedUUID && [focusedUUID isEqualToString:(id)request.parameters[@"uuid"]]) {
       isFocused = YES;
     }

package/WebDriverAgentLib/Commands/FBOrientationCommands.m

@@ -40,9 +40,13 @@ const struct FBWDOrientationValues FBWDOrientationValues = {
   return
   @[
     [[FBRoute GET:@"/orientation"] respondWithTarget:self action:@selector(handleGetOrientation:)],
+    [[FBRoute GET:@"/orientation"].withoutSession respondWithTarget:self action:@selector(handleGetOrientation:)],
     [[FBRoute POST:@"/orientation"] respondWithTarget:self action:@selector(handleSetOrientation:)],
+    [[FBRoute POST:@"/orientation"].withoutSession respondWithTarget:self action:@selector(handleSetOrientation:)],
     [[FBRoute GET:@"/rotation"] respondWithTarget:self action:@selector(handleGetRotation:)],
+    [[FBRoute GET:@"/rotation"].withoutSession respondWithTarget:self action:@selector(handleGetRotation:)],
     [[FBRoute POST:@"/rotation"] respondWithTarget:self action:@selector(handleSetRotation:)],
+    [[FBRoute POST:@"/rotation"].withoutSession respondWithTarget:self action:@selector(handleSetRotation:)],
   ];
 }
 
@@ -51,15 +55,15 @@ const struct FBWDOrientationValues FBWDOrientationValues = {
 
 + (id<FBResponsePayload>)handleGetOrientation:(FBRouteRequest *)request
 {
-  FBSession *session = request.session;
-  NSString *orientation = [self.class interfaceOrientationForApplication:session.activeApplication];
+  FBApplication *application = request.session.activeApplication ?: FBApplication.fb_activeApplication;
+  NSString *orientation = [self.class interfaceOrientationForApplication:application];
   return FBResponseWithObject([[self _wdOrientationsMapping] objectForKey:orientation]);
 }
 
 + (id<FBResponsePayload>)handleSetOrientation:(FBRouteRequest *)request
 {
-  FBSession *session = request.session;
-  if ([self.class setDeviceOrientation:request.arguments[@"orientation"] forApplication:session.activeApplication]) {
+  FBApplication *application = request.session.activeApplication ?: FBApplication.fb_activeApplication;
+  if ([self.class setDeviceOrientation:request.arguments[@"orientation"] forApplication:application]) {
     return FBResponseWithOK();
   }
 
@@ -69,7 +73,8 @@ const struct FBWDOrientationValues FBWDOrientationValues = {
 + (id<FBResponsePayload>)handleGetRotation:(FBRouteRequest *)request
 {
   XCUIDevice *device = [XCUIDevice sharedDevice];
-  UIInterfaceOrientation orientation = request.session.activeApplication.interfaceOrientation;
+  FBApplication *application = request.session.activeApplication ?: FBApplication.fb_activeApplication;
+  UIInterfaceOrientation orientation = application.interfaceOrientation;
   return FBResponseWithObject(device.fb_rotationMapping[@(orientation)]);
 }
 
@@ -88,14 +93,20 @@ const struct FBWDOrientationValues FBWDOrientationValues = {
   };
   NSArray<NSDictionary *> *supportedRotations = XCUIDevice.sharedDevice.fb_rotationMapping.allValues;
   if (![supportedRotations containsObject:rotation]) {
-    NSString *errMessage = [NSString stringWithFormat:@"%@ rotation is not supported. Only the following values are supported: %@", rotation, supportedRotations];
+    NSString *errMessage = [
+      NSString stringWithFormat:@"%@ rotation is not supported. Only the following values are supported: %@",
+      rotation, supportedRotations
+    ];
     return FBResponseWithStatus([FBCommandStatus invalidArgumentErrorWithMessage:errMessage
                                                                        traceback:nil]);
   }
 
-  FBApplication *app = request.session.activeApplication;
-  if (![self.class setDeviceRotation:request.arguments forApplication:app]) {
-    NSString *errMessage = [NSString stringWithFormat:@"The current rotation cannot be set to %@. Make sure the %@ application supports it", rotation, app.bundleID];
+  FBApplication *application = request.session.activeApplication ?: FBApplication.fb_activeApplication;
+  if (![self.class setDeviceRotation:request.arguments forApplication:application]) {
+    NSString *errMessage = [
+      NSString stringWithFormat:@"The current rotation cannot be set to %@. Make sure the %@ application supports it",
+      rotation, application.bundleID
+    ];
     return FBResponseWithStatus([FBCommandStatus invalidElementStateErrorWithMessage:errMessage
                                                                            traceback:nil]);
   }

package/WebDriverAgentLib/Commands/FBSessionCommands.m

@@ -10,6 +10,7 @@
 #import "FBSessionCommands.h"
 
 #import "FBApplication.h"
+#import "FBCapabilities.h"
 #import "FBConfiguration.h"
 #import "FBLogger.h"
 #import "FBProtocolHelpers.h"
@@ -74,72 +75,91 @@
 
 + (id<FBResponsePayload>)handleCreateSession:(FBRouteRequest *)request
 {
-  NSDictionary<NSString *, id> *requirements;
+  if (nil != FBSession.activeSession) {
+    [FBSession.activeSession kill];
+  }
+
+  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 == (requirements = FBParseCapabilities((NSDictionary *)request.arguments[@"capabilities"], &error))) {
+  if (nil == (capabilities = FBParseCapabilities((NSDictionary *)request.arguments[@"capabilities"], &error))) {
     return FBResponseWithStatus([FBCommandStatus sessionNotCreatedError:error.description traceback:nil]);
   }
-  [FBConfiguration setShouldUseTestManagerForVisibilityDetection:[requirements[@"shouldUseTestManagerForVisibilityDetection"] boolValue]];
-  if (requirements[USE_COMPACT_RESPONSES]) {
-    [FBConfiguration setShouldUseCompactResponses:[requirements[USE_COMPACT_RESPONSES] boolValue]];
+  [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 = requirements[ELEMENT_RESPONSE_ATTRIBUTES];
+  NSString *elementResponseAttributes = capabilities[FB_SETTING_ELEMENT_RESPONSE_ATTRIBUTES];
   if (elementResponseAttributes) {
     [FBConfiguration setElementResponseAttributes:elementResponseAttributes];
   }
-  if (requirements[@"maxTypingFrequency"]) {
-    [FBConfiguration setMaxTypingFrequency:[requirements[@"maxTypingFrequency"] unsignedIntegerValue]];
+  if (capabilities[FB_CAP_MAX_TYPING_FREQUNCY]) {
+    [FBConfiguration setMaxTypingFrequency:[capabilities[FB_CAP_MAX_TYPING_FREQUNCY] unsignedIntegerValue]];
   }
-  if (requirements[@"shouldUseSingletonTestManager"]) {
-    [FBConfiguration setShouldUseSingletonTestManager:[requirements[@"shouldUseSingletonTestManager"] boolValue]];
+  if (capabilities[FB_CAP_USE_SINGLETON_TEST_MANAGER]) {
+    [FBConfiguration setShouldUseSingletonTestManager:[capabilities[FB_CAP_USE_SINGLETON_TEST_MANAGER] boolValue]];
   }
-  if (requirements[@"disableAutomaticScreenshots"]) {
-    if ([requirements[@"disableAutomaticScreenshots"] boolValue]) {
+  if (capabilities[FB_CAP_DISABLE_AUTOMATIC_SCREENSHOTS]) {
+    if ([capabilities[FB_CAP_DISABLE_AUTOMATIC_SCREENSHOTS] boolValue]) {
       [FBConfiguration disableScreenshots];
     } else {
       [FBConfiguration enableScreenshots];
     }
   }
-  if (requirements[@"shouldTerminateApp"]) {
-    [FBConfiguration setShouldTerminateApp:[requirements[@"shouldTerminateApp"] boolValue]];
+  if (capabilities[FB_CAP_SHOULD_TERMINATE_APP]) {
+    [FBConfiguration setShouldTerminateApp:[capabilities[FB_CAP_SHOULD_TERMINATE_APP] boolValue]];
   }
-  NSNumber *delay = requirements[@"eventloopIdleDelaySec"];
+  NSNumber *delay = capabilities[FB_CAP_EVENT_LOOP_IDLE_DELAY_SEC];
   if ([delay doubleValue] > 0.0) {
     [XCUIApplicationProcessDelay setEventLoopHasIdledDelay:[delay doubleValue]];
   } else {
     [XCUIApplicationProcessDelay disableEventLoopDelay];
   }
 
-  if (nil != requirements[WAIT_FOR_IDLE_TIMEOUT]) {
-    FBConfiguration.waitForIdleTimeout = [requirements[WAIT_FOR_IDLE_TIMEOUT] doubleValue];
+  if (nil != capabilities[FB_SETTING_WAIT_FOR_IDLE_TIMEOUT]) {
+    FBConfiguration.waitForIdleTimeout = [capabilities[FB_SETTING_WAIT_FOR_IDLE_TIMEOUT] doubleValue];
   }
 
-  NSString *bundleID = requirements[@"bundleId"];
+  NSString *bundleID = capabilities[FB_CAP_BUNDLE_ID];
   FBApplication *app = nil;
   if (bundleID != nil) {
-    app = [[FBApplication alloc] initPrivateWithPath:requirements[@"app"]
-                                            bundleID:bundleID];
-    app.fb_shouldWaitForQuiescence = nil == requirements[@"shouldWaitForQuiescence"]
-                                             || [requirements[@"shouldWaitForQuiescence"] boolValue];
-    app.launchArguments = (NSArray<NSString *> *)requirements[@"arguments"] ?: @[];
-    app.launchEnvironment = (NSDictionary <NSString *, NSString *> *)requirements[@"environment"] ?: @{};
-    [app launch];
-    if (app.processID == 0) {
-      return FBResponseWithStatus([FBCommandStatus sessionNotCreatedError:[NSString stringWithFormat:@"Failed to launch %@ application", bundleID] traceback:nil]);
+    app = [[FBApplication alloc] initWithBundleIdentifier:bundleID];
+    BOOL forceAppLaunch = YES;
+    if (nil != capabilities[FB_CAP_FORCE_APP_LAUNCH]) {
+      forceAppLaunch = [capabilities[FB_CAP_FORCE_APP_LAUNCH] boolValue];
+    }
+    NSUInteger appState = [app fb_state];
+    BOOL isAppRunning = appState >= 2;
+    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] ?: @{};
+      [app launch];
+      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 < 4 && !forceAppLaunch) {
+      [app fb_activate];
     }
   }
 
-  if (requirements[DEFAULT_ALERT_ACTION]) {
+  if (capabilities[FB_SETTING_DEFAULT_ALERT_ACTION]) {
     [FBSession initWithApplication:app
-                defaultAlertAction:(id)requirements[DEFAULT_ALERT_ACTION]];
+                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];
+  }
+
   return FBResponseWithObject(FBSessionCommands.sessionInformation);
 }
 
@@ -214,7 +234,7 @@
           @"name" : [[UIDevice currentDevice] systemName],
           @"version" : [[UIDevice currentDevice] systemVersion],
           @"sdkVersion": FBSDKVersion() ?: @"unknown",
-          @"testmanagerdVersion": @([XCUIApplication fb_testmanagerdVersion]),
+          @"testmanagerdVersion": @(FBTestmanagerdVersion()),
         },
       @"ios" :
         @{
@@ -240,29 +260,29 @@
 {
   return FBResponseWithObject(
     @{
-      USE_COMPACT_RESPONSES: @([FBConfiguration shouldUseCompactResponses]),
-      ELEMENT_RESPONSE_ATTRIBUTES: [FBConfiguration elementResponseAttributes],
-      MJPEG_SERVER_SCREENSHOT_QUALITY: @([FBConfiguration mjpegServerScreenshotQuality]),
-      MJPEG_SERVER_FRAMERATE: @([FBConfiguration mjpegServerFramerate]),
-      MJPEG_SCALING_FACTOR: @([FBConfiguration mjpegScalingFactor]),
-      SCREENSHOT_QUALITY: @([FBConfiguration screenshotQuality]),
-      KEYBOARD_AUTOCORRECTION: @([FBConfiguration keyboardAutocorrection]),
-      KEYBOARD_PREDICTION: @([FBConfiguration keyboardPrediction]),
-      CUSTOM_SNAPSHOT_TIMEOUT: @([FBConfiguration customSnapshotTimeout]),
-      SNAPSHOT_MAX_DEPTH: @([FBConfiguration snapshotMaxDepth]),
-      USE_FIRST_MATCH: @([FBConfiguration useFirstMatch]),
-      WAIT_FOR_IDLE_TIMEOUT: @([FBConfiguration waitForIdleTimeout]),
-      ANIMATION_COOL_OFF_TIMEOUT: @([FBConfiguration animationCoolOffTimeout]),
-      BOUND_ELEMENTS_BY_INDEX: @([FBConfiguration boundElementsByIndex]),
-      REDUCE_MOTION: @([FBConfiguration reduceMotionEnabled]),
-      DEFAULT_ACTIVE_APPLICATION: request.session.defaultActiveApplication,
-      ACTIVE_APP_DETECTION_POINT: FBActiveAppDetectionPoint.sharedInstance.stringCoordinates,
-      INCLUDE_NON_MODAL_ELEMENTS: @([FBConfiguration includeNonModalElements]),
-      ACCEPT_ALERT_BUTTON_SELECTOR: FBConfiguration.acceptAlertButtonSelector,
-      DISMISS_ALERT_BUTTON_SELECTOR: FBConfiguration.dismissAlertButtonSelector,
-      DEFAULT_ALERT_ACTION: request.session.defaultAlertAction ?: @"",
+      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_SCREENSHOT_QUALITY: @([FBConfiguration screenshotQuality]),
+      FB_SETTING_KEYBOARD_AUTOCORRECTION: @([FBConfiguration keyboardAutocorrection]),
+      FB_SETTING_KEYBOARD_PREDICTION: @([FBConfiguration keyboardPrediction]),
+      FB_SETTING_CUSTOM_SNAPSHOT_TIMEOUT: @([FBConfiguration customSnapshotTimeout]),
+      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_DEFAULT_ALERT_ACTION: request.session.defaultAlertAction ?: @"",
 #if !TARGET_OS_TV
-      SCREENSHOT_ORIENTATION: [FBConfiguration humanReadableScreenshotOrientation],
+      FB_SETTING_SCREENSHOT_ORIENTATION: [FBConfiguration humanReadableScreenshotOrientation],
 #endif
     }
   );
@@ -274,86 +294,86 @@
 {
   NSDictionary* settings = request.arguments[@"settings"];
 
-  if (nil != [settings objectForKey:USE_COMPACT_RESPONSES]) {
-    [FBConfiguration setShouldUseCompactResponses:[[settings objectForKey:USE_COMPACT_RESPONSES] boolValue]];
+  if (nil != [settings objectForKey:FB_SETTING_USE_COMPACT_RESPONSES]) {
+    [FBConfiguration setShouldUseCompactResponses:[[settings objectForKey:FB_SETTING_USE_COMPACT_RESPONSES] boolValue]];
   }
-  if (nil != [settings objectForKey:ELEMENT_RESPONSE_ATTRIBUTES]) {
-    [FBConfiguration setElementResponseAttributes:(NSString *)[settings objectForKey:ELEMENT_RESPONSE_ATTRIBUTES]];
+  if (nil != [settings objectForKey:FB_SETTING_ELEMENT_RESPONSE_ATTRIBUTES]) {
+    [FBConfiguration setElementResponseAttributes:(NSString *)[settings objectForKey:FB_SETTING_ELEMENT_RESPONSE_ATTRIBUTES]];
   }
-  if (nil != [settings objectForKey:MJPEG_SERVER_SCREENSHOT_QUALITY]) {
-    [FBConfiguration setMjpegServerScreenshotQuality:[[settings objectForKey:MJPEG_SERVER_SCREENSHOT_QUALITY] unsignedIntegerValue]];
+  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:MJPEG_SERVER_FRAMERATE]) {
-    [FBConfiguration setMjpegServerFramerate:[[settings objectForKey:MJPEG_SERVER_FRAMERATE] unsignedIntegerValue]];
+  if (nil != [settings objectForKey:FB_SETTING_MJPEG_SERVER_FRAMERATE]) {
+    [FBConfiguration setMjpegServerFramerate:[[settings objectForKey:FB_SETTING_MJPEG_SERVER_FRAMERATE] unsignedIntegerValue]];
   }
-  if (nil != [settings objectForKey:SCREENSHOT_QUALITY]) {
-    [FBConfiguration setScreenshotQuality:[[settings objectForKey:SCREENSHOT_QUALITY] unsignedIntegerValue]];
+  if (nil != [settings objectForKey:FB_SETTING_SCREENSHOT_QUALITY]) {
+    [FBConfiguration setScreenshotQuality:[[settings objectForKey:FB_SETTING_SCREENSHOT_QUALITY] unsignedIntegerValue]];
   }
-  if (nil != [settings objectForKey:MJPEG_SCALING_FACTOR]) {
-    [FBConfiguration setMjpegScalingFactor:[[settings objectForKey:MJPEG_SCALING_FACTOR] unsignedIntegerValue]];
+  if (nil != [settings objectForKey:FB_SETTING_MJPEG_SCALING_FACTOR]) {
+    [FBConfiguration setMjpegScalingFactor:[[settings objectForKey:FB_SETTING_MJPEG_SCALING_FACTOR] unsignedIntegerValue]];
   }
-  if (nil != [settings objectForKey:KEYBOARD_AUTOCORRECTION]) {
-    [FBConfiguration setKeyboardAutocorrection:[[settings objectForKey:KEYBOARD_AUTOCORRECTION] boolValue]];
+  if (nil != [settings objectForKey:FB_SETTING_KEYBOARD_AUTOCORRECTION]) {
+    [FBConfiguration setKeyboardAutocorrection:[[settings objectForKey:FB_SETTING_KEYBOARD_AUTOCORRECTION] boolValue]];
   }
-  if (nil != [settings objectForKey:KEYBOARD_PREDICTION]) {
-    [FBConfiguration setKeyboardPrediction:[[settings objectForKey:KEYBOARD_PREDICTION] boolValue]];
+  if (nil != [settings objectForKey:FB_SETTING_KEYBOARD_PREDICTION]) {
+    [FBConfiguration setKeyboardPrediction:[[settings objectForKey:FB_SETTING_KEYBOARD_PREDICTION] boolValue]];
   }
   // SNAPSHOT_TIMEOUT setting is deprecated. Please use CUSTOM_SNAPSHOT_TIMEOUT instead
-  if (nil != [settings objectForKey:SNAPSHOT_TIMEOUT]) {
-    [FBConfiguration setCustomSnapshotTimeout:[[settings objectForKey:SNAPSHOT_TIMEOUT] doubleValue]];
+  if (nil != [settings objectForKey:FB_SETTING_SNAPSHOT_TIMEOUT]) {
+    [FBConfiguration setCustomSnapshotTimeout:[[settings objectForKey:FB_SETTING_SNAPSHOT_TIMEOUT] doubleValue]];
   }
-  if (nil != [settings objectForKey:CUSTOM_SNAPSHOT_TIMEOUT]) {
-    [FBConfiguration setCustomSnapshotTimeout:[[settings objectForKey:CUSTOM_SNAPSHOT_TIMEOUT] doubleValue]];
+  if (nil != [settings objectForKey:FB_SETTING_CUSTOM_SNAPSHOT_TIMEOUT]) {
+    [FBConfiguration setCustomSnapshotTimeout:[[settings objectForKey:FB_SETTING_CUSTOM_SNAPSHOT_TIMEOUT] doubleValue]];
   }
-  if (nil != [settings objectForKey:SNAPSHOT_MAX_DEPTH]) {
-    [FBConfiguration setSnapshotMaxDepth:[[settings objectForKey:SNAPSHOT_MAX_DEPTH] intValue]];
+  if (nil != [settings objectForKey:FB_SETTING_SNAPSHOT_MAX_DEPTH]) {
+    [FBConfiguration setSnapshotMaxDepth:[[settings objectForKey:FB_SETTING_SNAPSHOT_MAX_DEPTH] intValue]];
   }
-  if (nil != [settings objectForKey:USE_FIRST_MATCH]) {
-    [FBConfiguration setUseFirstMatch:[[settings objectForKey:USE_FIRST_MATCH] boolValue]];
+  if (nil != [settings objectForKey:FB_SETTING_USE_FIRST_MATCH]) {
+    [FBConfiguration setUseFirstMatch:[[settings objectForKey:FB_SETTING_USE_FIRST_MATCH] boolValue]];
   }
-  if (nil != [settings objectForKey:BOUND_ELEMENTS_BY_INDEX]) {
-    [FBConfiguration setBoundElementsByIndex:[[settings objectForKey:BOUND_ELEMENTS_BY_INDEX] boolValue]];
+  if (nil != [settings objectForKey:FB_SETTING_BOUND_ELEMENTS_BY_INDEX]) {
+    [FBConfiguration setBoundElementsByIndex:[[settings objectForKey:FB_SETTING_BOUND_ELEMENTS_BY_INDEX] boolValue]];
   }
-  if (nil != [settings objectForKey:REDUCE_MOTION]) {
-    [FBConfiguration setReduceMotionEnabled:[[settings objectForKey:REDUCE_MOTION] boolValue]];
+  if (nil != [settings objectForKey:FB_SETTING_REDUCE_MOTION]) {
+    [FBConfiguration setReduceMotionEnabled:[[settings objectForKey:FB_SETTING_REDUCE_MOTION] boolValue]];
   }
-  if (nil != [settings objectForKey:DEFAULT_ACTIVE_APPLICATION]) {
-    request.session.defaultActiveApplication = (NSString *)[settings objectForKey:DEFAULT_ACTIVE_APPLICATION];
+  if (nil != [settings objectForKey:FB_SETTING_DEFAULT_ACTIVE_APPLICATION]) {
+    request.session.defaultActiveApplication = (NSString *)[settings objectForKey:FB_SETTING_DEFAULT_ACTIVE_APPLICATION];
   }
-  if (nil != [settings objectForKey:ACTIVE_APP_DETECTION_POINT]) {
+  if (nil != [settings objectForKey:FB_SETTING_ACTIVE_APP_DETECTION_POINT]) {
     NSError *error;
-    if (![FBActiveAppDetectionPoint.sharedInstance setCoordinatesWithString:(NSString *)[settings objectForKey:ACTIVE_APP_DETECTION_POINT]
+    if (![FBActiveAppDetectionPoint.sharedInstance setCoordinatesWithString:(NSString *)[settings objectForKey:FB_SETTING_ACTIVE_APP_DETECTION_POINT]
                                                                       error:&error]) {
       return FBResponseWithStatus([FBCommandStatus invalidArgumentErrorWithMessage:error.description traceback:nil]);
     }
   }
-  if (nil != [settings objectForKey:INCLUDE_NON_MODAL_ELEMENTS]) {
+  if (nil != [settings objectForKey:FB_SETTING_INCLUDE_NON_MODAL_ELEMENTS]) {
     if ([XCUIElement fb_supportsNonModalElementsInclusion]) {
-      [FBConfiguration setIncludeNonModalElements:[[settings objectForKey:INCLUDE_NON_MODAL_ELEMENTS] boolValue]];
+      [FBConfiguration setIncludeNonModalElements:[[settings objectForKey:FB_SETTING_INCLUDE_NON_MODAL_ELEMENTS] boolValue]];
     } else {
-      [FBLogger logFmt:@"'%@' settings value cannot be assigned, because non modal elements inclusion is not supported by the current iOS SDK", INCLUDE_NON_MODAL_ELEMENTS];
+      [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];
     }
   }
-  if (nil != [settings objectForKey:ACCEPT_ALERT_BUTTON_SELECTOR]) {
-    [FBConfiguration setAcceptAlertButtonSelector:(NSString *)[settings objectForKey:ACCEPT_ALERT_BUTTON_SELECTOR]];
+  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:DISMISS_ALERT_BUTTON_SELECTOR]) {
-    [FBConfiguration setDismissAlertButtonSelector:(NSString *)[settings objectForKey:DISMISS_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:WAIT_FOR_IDLE_TIMEOUT]) {
-    [FBConfiguration setWaitForIdleTimeout:[[settings objectForKey:WAIT_FOR_IDLE_TIMEOUT] doubleValue]];
+  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:ANIMATION_COOL_OFF_TIMEOUT]) {
-    [FBConfiguration setAnimationCoolOffTimeout:[[settings objectForKey:ANIMATION_COOL_OFF_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:DEFAULT_ALERT_ACTION] isKindOfClass:NSString.class]) {
-    request.session.defaultAlertAction = [settings[DEFAULT_ALERT_ACTION] lowercaseString];
+  if ([[settings objectForKey:FB_SETTING_DEFAULT_ALERT_ACTION] isKindOfClass:NSString.class]) {
+    request.session.defaultAlertAction = [settings[FB_SETTING_DEFAULT_ALERT_ACTION] lowercaseString];
   }
 
 #if !TARGET_OS_TV
-  if (nil != [settings objectForKey:SCREENSHOT_ORIENTATION]) {
+  if (nil != [settings objectForKey:FB_SETTING_SCREENSHOT_ORIENTATION]) {
     NSError *error;
-    if (![FBConfiguration setScreenshotOrientation:(NSString *)[settings objectForKey:SCREENSHOT_ORIENTATION]
+    if (![FBConfiguration setScreenshotOrientation:(NSString *)[settings objectForKey:FB_SETTING_SCREENSHOT_ORIENTATION]
                                              error:&error]) {
       return FBResponseWithStatus([FBCommandStatus invalidArgumentErrorWithMessage:error.description traceback:nil]);
     }

package/WebDriverAgentLib/FBApplication.m

@@ -149,7 +149,7 @@ static const NSTimeInterval APP_STATE_CHANGE_TIMEOUT = 5.0;
   if ([FBXCAXClientProxy.sharedClient hasProcessTracker]) {
     return (FBApplication *)[FBXCAXClientProxy.sharedClient monitoredApplicationWithProcessIdentifier:processID];
   }
-  return  [super applicationWithPID:processID];
+  return [super applicationWithPID:processID];
 }
 
 - (void)launch