appium-webdriveragent 16.1.2 → 16.1.3

package/WebDriverAgentLib/FBAlert.m

@@ -9,21 +9,26 @@
 #import "FBAlert.h"
 
 #import "FBConfiguration.h"
-#import "FBErrorBuilder.h"
+#import "FBExceptions.h"
 #import "FBLogger.h"
 #import "FBXCElementSnapshotWrapper+Helpers.h"
 #import "FBXCodeCompatibility.h"
 #import "XCUIApplication.h"
 #import "XCUIApplication+FBAlert.h"
+#import "XCUIApplication+FBHelpers.h"
 #import "XCUIElement+FBClassChain.h"
 #import "XCUIElement+FBTyping.h"
+#import "XCUIElement+FBUID.h"
 #import "XCUIElement+FBUtilities.h"
 #import "XCUIElement+FBWebDriverAttributes.h"
 
 
 @interface FBAlert ()
 @property (nonatomic, strong) XCUIApplication *application;
-@property (nonatomic, strong, nullable) XCUIElement *element;
+@property (nonatomic, nullable) XCUIElement *cachedAlertElement;
+@property (nonatomic) BOOL hasCachedAlertElement;
+@property (nonatomic, nullable) id<FBXCElementSnapshot> cachedAlertSnapshot;
+@property (nonatomic) BOOL hasCachedAlertSnapshot;
 @end
 
 @implementation FBAlert
@@ -35,32 +40,81 @@
   return alert;
 }
 
-+ (instancetype)alertWithElement:(XCUIElement *)element
+// Resolved (and, if found, snapshotted) at most once per instance and then
+// reused for every subsequent call - see FBAlert.h. This is what makes an
+// isPresent check followed by an action (the FBAlertsMonitor/FBSession
+// auto-accept flow) act on the exact same alert it just observed, instead of
+// re-resolving against a UI that may have changed in between.
+- (nullable XCUIElement *)alertElement
 {
-  FBAlert *alert = [FBAlert new];
-  alert.element = element;
-  alert.application = element.application;
-  return alert;
+  if (!self.hasCachedAlertElement) {
+    id<FBXCElementSnapshot> snapshot = nil;
+    self.cachedAlertElement = [self alertElementFromApplication:&snapshot];
+    self.hasCachedAlertElement = YES;
+    if (nil != snapshot) {
+      self.cachedAlertSnapshot = snapshot;
+      self.hasCachedAlertSnapshot = YES;
+    }
+  }
+  return self.cachedAlertElement;
+}
+
+// The alert element's own subtree snapshot, taken once. All read-only
+// accessors (text, buttonLabels) and all element lookups (buttons, input
+// fields) work off this single snapshot in memory - only tapping/typing into
+// a specific already-located element pays for one more, narrowly targeted
+// accessibility round trip (see XCUIApplication.fb_elementForSnapshot:underElement:).
+// fb_cachedSnapshot is tried before fb_customSnapshot: it can reconstruct
+// the element's snapshot from the detection query's already-fetched
+// rootElementSnapshot without a further round trip (verified empirically -
+// see XCUIApplication+FBAlert.m).
+- (nullable id<FBXCElementSnapshot>)alertSnapshot
+{
+  if (!self.hasCachedAlertSnapshot) {
+    XCUIElement *alertElement = self.alertElement;
+    self.cachedAlertSnapshot = nil == alertElement
+      ? nil
+      : (alertElement.lastSnapshot ?: alertElement.fb_cachedSnapshot ?: [alertElement fb_customSnapshot]);
+    self.hasCachedAlertSnapshot = YES;
+  }
+  return self.cachedAlertSnapshot;
 }
 
 - (BOOL)isPresent
 {
-  @try {
-    if (nil == self.alertElement) {
-      return NO;
+  return nil != self.alertElement;
+}
+
++ (NSArray<id<FBXCElementSnapshot>> *)fb_buttonSnapshotsInSnapshot:(id<FBXCElementSnapshot>)snapshot
+{
+  NSMutableArray<id<FBXCElementSnapshot>> *buttons = [NSMutableArray array];
+  [snapshot enumerateDescendantsUsingBlock:^(id<FBXCElementSnapshot> descendant) {
+    if (descendant.elementType == XCUIElementTypeButton) {
+      [buttons addObject:descendant];
     }
-    [self.alertElement fb_customSnapshot];
-    return YES;
-  } @catch (NSException *) {
-    return NO;
-  }
+  }];
+  return buttons.copy;
+}
+
+- (void)fb_raiseNotPresentException __attribute__((noreturn))
+{
+  @throw [NSException exceptionWithName:FBAlertNotPresentException
+                                  reason:@"No alert is open"
+                                userInfo:nil];
 }
 
-- (BOOL)notPresentWithError:(NSError **)error
+- (void)fb_raiseActionFailedExceptionWithReason:(NSString *)reason __attribute__((noreturn))
 {
-  return [[[FBErrorBuilder builder]
-           withDescriptionFormat:@"No alert is open"]
-          buildError:error];
+  @throw [NSException exceptionWithName:FBAlertActionFailedException
+                                  reason:reason
+                                userInfo:nil];
+}
+
+- (void)fb_raiseSetTextFailedExceptionWithReason:(NSString *)reason __attribute__((noreturn))
+{
+  @throw [NSException exceptionWithName:FBAlertSetTextFailedException
+                                  reason:reason
+                                userInfo:nil];
 }
 
 + (BOOL)isSafariWebAlertWithSnapshot:(id<FBXCElementSnapshot>)snapshot
@@ -76,19 +130,19 @@
 
 - (NSString *)text
 {
-  if (!self.isPresent) {
+  id<FBXCElementSnapshot> snapshot = self.alertSnapshot;
+  if (nil == snapshot) {
     return nil;
   }
 
   NSMutableArray<NSString *> *resultText = [NSMutableArray array];
-  id<FBXCElementSnapshot> snapshot = self.alertElement.lastSnapshot ?: [self.alertElement fb_customSnapshot];
   BOOL isSafariAlert = [self.class isSafariWebAlertWithSnapshot:snapshot];
   [snapshot enumerateDescendantsUsingBlock:^(id<FBXCElementSnapshot> descendant) {
     XCUIElementType elementType = descendant.elementType;
     if (!(elementType == XCUIElementTypeTextView || elementType == XCUIElementTypeStaticText)) {
       return;
     }
-    
+
     FBXCElementSnapshotWrapper *descendantWrapper = [FBXCElementSnapshotWrapper ensureWrapped:descendant];
     if (elementType == XCUIElementTypeStaticText
         && nil != [descendantWrapper fb_parentMatchingType:XCUIElementTypeButton]) {
@@ -112,39 +166,47 @@
   return [resultText componentsJoinedByString:@"\n"];
 }
 
-- (BOOL)typeText:(NSString *)text error:(NSError **)error
+- (void)typeText:(NSString *)text
 {
-  if (!self.isPresent) {
-    return [self notPresentWithError:error];
+  XCUIElement *alertElement = self.alertElement;
+  id<FBXCElementSnapshot> alertSnapshot = self.alertSnapshot;
+  if (nil == alertElement || nil == alertSnapshot) {
+    [self fb_raiseNotPresentException];
   }
 
-  NSPredicate *textCollectorPredicate = [NSPredicate predicateWithFormat:@"elementType IN {%lu,%lu}",
-                                         XCUIElementTypeTextField, XCUIElementTypeSecureTextField];
-  NSArray<XCUIElement *> *dstFields = [[self.alertElement descendantsMatchingType:XCUIElementTypeAny]
-                                       matchingPredicate:textCollectorPredicate].allElementsBoundByIndex;
-  if (dstFields.count > 1) {
-    return [[[FBErrorBuilder builder]
-      withDescriptionFormat:@"The alert contains more than one input field"]
-     buildError:error];
+  NSMutableArray<id<FBXCElementSnapshot>> *dstFieldSnapshots = [NSMutableArray array];
+  [alertSnapshot enumerateDescendantsUsingBlock:^(id<FBXCElementSnapshot> descendant) {
+    XCUIElementType elementType = descendant.elementType;
+    if (elementType == XCUIElementTypeTextField || elementType == XCUIElementTypeSecureTextField) {
+      [dstFieldSnapshots addObject:descendant];
+    }
+  }];
+  if (dstFieldSnapshots.count > 1) {
+    [self fb_raiseSetTextFailedExceptionWithReason:@"The alert contains more than one input field"];
   }
-  if (0 == dstFields.count) {
-    return [[[FBErrorBuilder builder]
-             withDescriptionFormat:@"The alert contains no input fields"]
-            buildError:error];
+  id<FBXCElementSnapshot> dstFieldSnapshot = dstFieldSnapshots.firstObject;
+  if (nil == dstFieldSnapshot) {
+    [self fb_raiseSetTextFailedExceptionWithReason:@"The alert contains no input fields"];
+  }
+  XCUIElement *dstField = [XCUIApplication fb_elementForSnapshot:dstFieldSnapshot
+                                                      underElement:alertElement];
+  if (nil == dstField) {
+    [self fb_raiseSetTextFailedExceptionWithReason:@"Failed to resolve the input field element"];
+  }
+  NSError *error;
+  if (![dstField fb_typeText:text shouldClear:YES error:&error]) {
+    [self fb_raiseSetTextFailedExceptionWithReason:error.description];
   }
-  return [dstFields.firstObject fb_typeText:text
-                                shouldClear:YES
-                                      error:error];
 }
 
 - (NSArray *)buttonLabels
 {
-  if (!self.isPresent) {
+  id<FBXCElementSnapshot> alertSnapshot = self.alertSnapshot;
+  if (nil == alertSnapshot) {
     return nil;
   }
 
   NSMutableArray<NSString *> *labels = [NSMutableArray array];
-  id<FBXCElementSnapshot> alertSnapshot = self.alertElement.lastSnapshot ?: [self.alertElement fb_customSnapshot];
   [alertSnapshot enumerateDescendantsUsingBlock:^(id<FBXCElementSnapshot> descendant) {
     if (descendant.elementType != XCUIElementTypeButton) {
       return;
@@ -157,19 +219,20 @@
   return labels.copy;
 }
 
-- (BOOL)acceptWithError:(NSError **)error
+- (void)accept
 {
-  if (!self.isPresent) {
-    return [self notPresentWithError:error];
+  XCUIElement *alertElement = self.alertElement;
+  id<FBXCElementSnapshot> alertSnapshot = self.alertSnapshot;
+  if (nil == alertElement || nil == alertSnapshot) {
+    [self fb_raiseNotPresentException];
   }
 
-  id<FBXCElementSnapshot> alertSnapshot = self.alertElement.lastSnapshot ?: [self.alertElement fb_customSnapshot];
   XCUIElement *acceptButton = nil;
   if (FBConfiguration.acceptAlertButtonSelector.length) {
     NSString *errorReason = nil;
     @try {
-      acceptButton = [[self.alertElement fb_descendantsMatchingClassChain:FBConfiguration.acceptAlertButtonSelector
-                                         shouldReturnAfterFirstMatch:YES] firstObject];
+      acceptButton = [[alertElement fb_descendantsMatchingClassChain:FBConfiguration.acceptAlertButtonSelector
+                                           shouldReturnAfterFirstMatch:YES] firstObject];
     } @catch (NSException *ex) {
       errorReason = ex.reason;
     }
@@ -183,34 +246,50 @@
    }
   }
   if (nil == acceptButton) {
-    NSArray<XCUIElement *> *buttons = [self.alertElement.fb_query
-                                       descendantsMatchingType:XCUIElementTypeButton].allElementsBoundByIndex;
-    acceptButton = (alertSnapshot.elementType == XCUIElementTypeAlert || [self.class isSafariWebAlertWithSnapshot:alertSnapshot])
-      ? buttons.lastObject
-      : buttons.firstObject;
+    // buttonSnapshotsInSnapshot's tree-order walk doesn't always match a
+    // live query's ordering: on the system location-permission alert (iOS
+    // 17.5, confirmed via manual testing), that mismatch put a
+    // non-dismissing "Precise: On/Off" toggle first, so accept/dismiss
+    // silently tapped the wrong control and left the alert on screen. Not
+    // reproduced on iOS 18+, so keep the cheaper snapshot walk there and
+    // only pay for a live query below iOS 18.
+    if (@available(iOS 18.0, *)) {
+      NSArray<id<FBXCElementSnapshot>> *buttonSnapshots = [self.class fb_buttonSnapshotsInSnapshot:alertSnapshot];
+      id<FBXCElementSnapshot> chosenSnapshot = (alertSnapshot.elementType == XCUIElementTypeAlert || [self.class isSafariWebAlertWithSnapshot:alertSnapshot])
+        ? buttonSnapshots.lastObject
+        : buttonSnapshots.firstObject;
+      if (nil != chosenSnapshot) {
+        acceptButton = [XCUIApplication fb_elementForSnapshot:chosenSnapshot underElement:alertElement];
+      }
+    } else {
+      NSArray<XCUIElement *> *buttons = [alertElement.fb_query
+                                         descendantsMatchingType:XCUIElementTypeButton].allElementsBoundByIndex;
+      acceptButton = (alertSnapshot.elementType == XCUIElementTypeAlert || [self.class isSafariWebAlertWithSnapshot:alertSnapshot])
+        ? buttons.lastObject
+        : buttons.firstObject;
+    }
   }
   if (nil == acceptButton) {
-    return [[[FBErrorBuilder builder]
-        withDescriptionFormat:@"Failed to find accept button for alert: %@", self.alertElement]
-       buildError:error];
+    [self fb_raiseActionFailedExceptionWithReason:
+     [NSString stringWithFormat:@"Failed to find accept button for alert: %@", alertElement]];
   }
   [acceptButton tap];
-  return YES;
 }
 
-- (BOOL)dismissWithError:(NSError **)error
+- (void)dismiss
 {
-  if (!self.isPresent) {
-    return [self notPresentWithError:error];
+  XCUIElement *alertElement = self.alertElement;
+  id<FBXCElementSnapshot> alertSnapshot = self.alertSnapshot;
+  if (nil == alertElement || nil == alertSnapshot) {
+    [self fb_raiseNotPresentException];
   }
 
-  id<FBXCElementSnapshot> alertSnapshot = self.alertElement.lastSnapshot ?: [self.alertElement fb_customSnapshot];
   XCUIElement *dismissButton = nil;
   if (FBConfiguration.dismissAlertButtonSelector.length) {
     NSString *errorReason = nil;
     @try {
-      dismissButton = [[self.alertElement fb_descendantsMatchingClassChain:FBConfiguration.dismissAlertButtonSelector
-                                          shouldReturnAfterFirstMatch:YES] firstObject];
+      dismissButton = [[alertElement fb_descendantsMatchingClassChain:FBConfiguration.dismissAlertButtonSelector
+                                            shouldReturnAfterFirstMatch:YES] firstObject];
     } @catch (NSException *ex) {
       errorReason = ex.reason;
     }
@@ -224,54 +303,141 @@
     }
   }
   if (nil == dismissButton) {
-    NSArray<XCUIElement *> *buttons = [self.alertElement.fb_query
-                                       descendantsMatchingType:XCUIElementTypeButton].allElementsBoundByIndex;
-    dismissButton = (alertSnapshot.elementType == XCUIElementTypeAlert || [self.class isSafariWebAlertWithSnapshot:alertSnapshot])
-      ? buttons.firstObject
-      : buttons.lastObject;
+    // See the matching comment in accept.
+    if (@available(iOS 18.0, *)) {
+      NSArray<id<FBXCElementSnapshot>> *buttonSnapshots = [self.class fb_buttonSnapshotsInSnapshot:alertSnapshot];
+      id<FBXCElementSnapshot> chosenSnapshot = (alertSnapshot.elementType == XCUIElementTypeAlert || [self.class isSafariWebAlertWithSnapshot:alertSnapshot])
+        ? buttonSnapshots.firstObject
+        : buttonSnapshots.lastObject;
+      if (nil != chosenSnapshot) {
+        dismissButton = [XCUIApplication fb_elementForSnapshot:chosenSnapshot underElement:alertElement];
+      }
+    } else {
+      NSArray<XCUIElement *> *buttons = [alertElement.fb_query
+                                         descendantsMatchingType:XCUIElementTypeButton].allElementsBoundByIndex;
+      dismissButton = (alertSnapshot.elementType == XCUIElementTypeAlert || [self.class isSafariWebAlertWithSnapshot:alertSnapshot])
+        ? buttons.firstObject
+        : buttons.lastObject;
+    }
   }
 
   if (nil == dismissButton) {
-    return [[[FBErrorBuilder builder]
-        withDescriptionFormat:@"Failed to find dismiss button for alert: %@", self.alertElement]
-            buildError:error];
+    [self fb_raiseActionFailedExceptionWithReason:
+     [NSString stringWithFormat:@"Failed to find dismiss button for alert: %@", alertElement]];
   }
   [dismissButton tap];
-  return YES;
 }
 
-- (BOOL)clickAlertButton:(NSString *)label error:(NSError **)error
+- (void)clickAlertButton:(NSString *)label
 {
-  if (!self.isPresent) {
-    return [self notPresentWithError:error];
+  XCUIElement *alertElement = self.alertElement;
+  id<FBXCElementSnapshot> alertSnapshot = self.alertSnapshot;
+  if (nil == alertElement || nil == alertSnapshot) {
+    [self fb_raiseNotPresentException];
   }
 
-  NSPredicate *predicate = [NSPredicate predicateWithFormat:@"label == %@", label];
-  XCUIElement *requestedButton = [[self.alertElement descendantsMatchingType:XCUIElementTypeButton]
-                                  matchingPredicate:predicate].allElementsBoundByIndex.firstObject;
+  __block id<FBXCElementSnapshot> matchedSnapshot = nil;
+  [alertSnapshot enumerateDescendantsUsingBlock:^(id<FBXCElementSnapshot> descendant) {
+    if (nil != matchedSnapshot || descendant.elementType != XCUIElementTypeButton) {
+      return;
+    }
+    NSString *btnLabel = [FBXCElementSnapshotWrapper ensureWrapped:descendant].wdLabel;
+    if (nil != btnLabel && [btnLabel isEqualToString:label]) {
+      matchedSnapshot = descendant;
+    }
+  }];
+  XCUIElement *requestedButton = nil == matchedSnapshot
+    ? nil
+    : [XCUIApplication fb_elementForSnapshot:matchedSnapshot underElement:alertElement];
   if (!requestedButton) {
-    return [[[FBErrorBuilder builder]
-             withDescriptionFormat:@"Failed to find button with label '%@' for alert: %@", label, self.alertElement]
-            buildError:error];
+    [self fb_raiseActionFailedExceptionWithReason:
+     [NSString stringWithFormat:@"Failed to find button with label '%@' for alert: %@", label, alertElement]];
   }
   [requestedButton tap];
-  return YES;
 }
 
-- (XCUIElement *)alertElement
+- (void)clickElementMatchingClassChain:(NSString *)classChain
+{
+  XCUIElement *alertElement = self.alertElement;
+  if (nil == alertElement) {
+    [self fb_raiseNotPresentException];
+  }
+
+  // For a Safari web alert, alertElement is the containing scrollView, not
+  // the alert's own div (see fb_alertElementWithSnapshot:), so a classChain
+  // query from it could also match unrelated page content. Constrain
+  // matches to descendants of alertSnapshot by uid when available.
+  NSSet<NSString *> *alertSnapshotUids = nil;
+  id<FBXCElementSnapshot> alertSnapshot = self.alertSnapshot;
+  if (nil != alertSnapshot) {
+    NSMutableSet<NSString *> *uids = [NSMutableSet set];
+    NSString *rootUid = [FBXCElementSnapshotWrapper wdUIDWithSnapshot:alertSnapshot];
+    if (nil != rootUid) {
+      [uids addObject:rootUid];
+    }
+    [alertSnapshot enumerateDescendantsUsingBlock:^(id<FBXCElementSnapshot> descendant) {
+      NSString *uid = [FBXCElementSnapshotWrapper wdUIDWithSnapshot:descendant];
+      if (nil != uid) {
+        [uids addObject:uid];
+      }
+    }];
+    alertSnapshotUids = uids;
+  }
+
+  NSArray<XCUIElement *> *matches = nil;
+  @try {
+    matches = [alertElement fb_descendantsMatchingClassChain:classChain
+                                  shouldReturnAfterFirstMatch:NO];
+  } @catch (NSException *ex) {
+    [self fb_raiseActionFailedExceptionWithReason:
+     [NSString stringWithFormat:@"Failed to match class chain selector '%@' for alert: %@. Original error: %@", classChain, alertElement, ex.reason]];
+  }
+  XCUIElement *matchedElement = nil;
+  for (XCUIElement *match in matches) {
+    if (nil == alertSnapshotUids || [alertSnapshotUids containsObject:match.fb_uid]) {
+      matchedElement = match;
+      break;
+    }
+  }
+  if (nil == matchedElement) {
+    [self fb_raiseActionFailedExceptionWithReason:
+     [NSString stringWithFormat:@"Failed to find any element matching class chain selector '%@' for alert: %@", classChain, alertElement]];
+  }
+  [matchedElement tap];
+}
+
+// Single source of truth for alert detection: checks each candidate
+// application (systemApp, then self.application if different, then the iOS
+// 18+ limited access prompt app) via targeted, predicate-filtered live
+// queries (see XCUIApplication.fb_alertElementWithSnapshot:) instead of
+// snapshotting and walking the whole application tree - the cost stays
+// proportional to the number of alert-shaped elements rather than the
+// size/depth of the app, which matters a lot for deeply nested view
+// hierarchies. Only ever invoked once per instance, by the alertElement
+// getter above, which caches both the element and (if one comes back) the
+// snapshot obtained as a side effect of resolving it.
+- (nullable XCUIElement *)alertElementFromApplication:(id<FBXCElementSnapshot> _Nullable *)snapshotOut
 {
-  if (nil == self.element) {
+  @try {
     XCUIApplication *systemApp = XCUIApplication.fb_systemApplication;
-    if ([systemApp fb_isSameAppAs:self.application]) {
-      self.element = systemApp.fb_alertElement;
-    } else {
-      self.element = systemApp.fb_alertElement ?: self.application.fb_alertElement;
+    NSMutableArray<XCUIApplication *> *candidates = [NSMutableArray arrayWithObject:systemApp];
+    if (![systemApp fb_isSameAppAs:self.application]) {
+      [candidates addObject:self.application];
     }
-    if (nil == self.element) {
-      self.element = [XCUIApplication fb_limitedAccessPromptAlertElement];
+    XCUIApplication *promptApp = XCUIApplication.fb_limitedAccessPromptApplication;
+    if (nil != promptApp) {
+      [candidates addObject:promptApp];
     }
+    for (XCUIApplication *candidate in candidates) {
+      XCUIElement *element = [candidate fb_alertElementWithSnapshot:snapshotOut];
+      if (nil != element) {
+        return element;
+      }
+    }
+  } @catch (NSException *) {
+    return nil;
   }
-  return self.element;
+  return nil;
 }
 
 @end

package/WebDriverAgentLib/Info.plist

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

package/WebDriverAgentLib/Routing/FBExceptionHandler.m

@@ -28,9 +28,13 @@
     commandStatus = [FBCommandStatus invalidArgumentErrorWithMessage:exception.reason
                                                            traceback:traceback];
   } else if ([exception.name isEqualToString:FBApplicationCrashedException]
-             || [exception.name isEqualToString:FBApplicationDeadlockDetectedException]) {
+             || [exception.name isEqualToString:FBApplicationDeadlockDetectedException]
+             || [exception.name isEqualToString:FBAlertActionFailedException]) {
     commandStatus = [FBCommandStatus invalidElementStateErrorWithMessage:exception.reason
                                                                traceback:traceback];
+  } else if ([exception.name isEqualToString:FBAlertSetTextFailedException]) {
+    commandStatus = [FBCommandStatus unsupportedOperationErrorWithMessage:exception.reason
+                                                                traceback:traceback];
   } else if ([exception.name isEqualToString:FBInvalidXPathException]
              || [exception.name isEqualToString:FBClassChainQueryParseException]) {
     commandStatus = [FBCommandStatus invalidSelectorErrorWithMessage:exception.reason
@@ -47,6 +51,9 @@
   } else if ([exception.name isEqualToString:FBSessionCreationException]) {
     commandStatus = [FBCommandStatus sessionNotCreatedError:exception.reason
                                                   traceback:traceback];
+  } else if ([exception.name isEqualToString:FBAlertNotPresentException]) {
+    commandStatus = [FBCommandStatus noAlertOpenErrorWithMessage:exception.reason
+                                                       traceback:traceback];
   } else {
     commandStatus = [FBCommandStatus unknownErrorWithMessage:exception.reason
                                                    traceback:traceback];

package/WebDriverAgentLib/Routing/FBExceptions.h

@@ -57,4 +57,13 @@ extern NSString *const FBApplicationMissingException;
 /*! Exception used to notify about WDA incompatibility with the current platform version */
 extern NSString *const FBIncompatibleWdaException;
 
+/*! Exception used to notify that no alert is currently present */
+extern NSString *const FBAlertNotPresentException;
+
+/*! Exception used to notify that an alert action (e.g. finding a button to tap) could not complete, although the alert itself is present */
+extern NSString *const FBAlertActionFailedException;
+
+/*! Exception used to notify that typing text into an alert failed (e.g. no or multiple input fields) */
+extern NSString *const FBAlertSetTextFailedException;
+
 NS_ASSUME_NONNULL_END

package/WebDriverAgentLib/Routing/FBExceptions.m

@@ -22,3 +22,6 @@ NSString *const FBClassChainQueryParseException = @"FBClassChainQueryParseExcept
 NSString *const FBApplicationCrashedException = @"FBApplicationCrashedException";
 NSString *const FBApplicationMissingException = @"FBApplicationMissingException";
 NSString *const FBIncompatibleWdaException = @"FBIncompatibleWdaException";
+NSString *const FBAlertNotPresentException = @"FBAlertNotPresentException";
+NSString *const FBAlertActionFailedException = @"FBAlertActionFailedException";
+NSString *const FBAlertSetTextFailedException = @"FBAlertSetTextFailedException";

package/WebDriverAgentLib/Routing/FBSession.m

@@ -24,7 +24,6 @@
 #import "FBXCTestDaemonsProxy.h"
 #import "XCUIApplication+FBQuiescence.h"
 #import "XCUIElement.h"
-#import "XCUIElement+FBClassChain.h"
 
 /*!
  The intial value for the default application property.
@@ -56,14 +55,10 @@ NSString *const FB_SAFARI_BUNDLE_ID = @"com.apple.mobilesafari";
   NSString *autoClickAlertSelector = FBConfiguration.autoClickAlertSelector;
   if ([autoClickAlertSelector length] > 0) {
     @try {
-      NSArray<XCUIElement*> *matches = [alert.alertElement fb_descendantsMatchingClassChain:autoClickAlertSelector
-                                                                shouldReturnAfterFirstMatch:YES];
-      if (matches.count > 0) {
-          [[matches objectAtIndex:0] tap];
-      }
+      [alert clickElementMatchingClassChain:autoClickAlertSelector];
     } @catch (NSException *e) {
       [FBLogger logFmt:@"Could not click at the alert element '%@'. Original error: %@",
-       autoClickAlertSelector, e.description];
+        autoClickAlertSelector, e.reason];
     }
     // This setting has priority over other settings if enabled
     return;
@@ -73,14 +68,17 @@ NSString *const FB_SAFARI_BUNDLE_ID = @"com.apple.mobilesafari";
     return;
   }
 
-  NSError *error;
   if ([self.defaultAlertAction isEqualToString:@"accept"]) {
-    if (![alert acceptWithError:&error]) {
-      [FBLogger logFmt:@"Cannot accept the alert. Original error: %@", error.description];
+    @try {
+      [alert accept];
+    } @catch (NSException *e) {
+      [FBLogger logFmt:@"Cannot accept the alert. Original error: %@", e.reason];
     }
   } else if ([self.defaultAlertAction isEqualToString:@"dismiss"]) {
-    if (![alert dismissWithError:&error]) {
-      [FBLogger logFmt:@"Cannot dismiss the alert. Original error: %@", error.description];
+    @try {
+      [alert dismiss];
+    } @catch (NSException *e) {
+      [FBLogger logFmt:@"Cannot dismiss the alert. Original error: %@", e.reason];
     }
   } else {
     [FBLogger logFmt:@"'%@' default alert action is unsupported", self.defaultAlertAction];
@@ -213,7 +211,7 @@ static FBSession *_activeSession = nil;
     XCUIApplicationState testedAppState = self.testedApplication.state;
     if (testedAppState >= XCUIApplicationStateRunningForeground) {
       NSPredicate *searchPredicate = [NSPredicate predicateWithFormat:@"%K == %@ OR %K IN {%@, %@}",
-                                      @"elementType", @(XCUIElementTypeAlert), 
+                                      @"elementType", @(XCUIElementTypeAlert),
                                       // To look for `SBTransientOverlayWindow` elements. See https://github.com/appium/WebDriverAgent/pull/946
                                       @"identifier", @"SBTransientOverlayWindow",
                                       // To look for 'criticalAlertSetting' elements https://developer.apple.com/documentation/usernotifications/unnotificationsettings/criticalalertsetting

package/WebDriverAgentLib/Utilities/FBAlertsMonitor.m

@@ -52,26 +52,28 @@ static const NSTimeInterval FB_MONTORING_INTERVAL = 2.0;
     NSArray<XCUIApplication *> *activeApps = XCUIApplication.fb_activeApplications;
     BOOL didDetectAlert = NO;
     for (XCUIApplication *activeApp in activeApps) {
-      XCUIElement *alertElement = nil;
       @try {
-        alertElement = activeApp.fb_alertElement;
-        if (nil != alertElement) {
-          [delegate didDetectAlert:[FBAlert alertWithElement:alertElement]];
+        FBAlert *alert = [FBAlert alertWithApplication:activeApp];
+        if (alert.isPresent) {
+          [delegate didDetectAlert:alert];
+          didDetectAlert = YES;
         }
       } @catch (NSException *e) {
         [FBLogger logFmt:@"Got an unexpected exception while monitoring alerts: %@\n%@", e.reason, e.callStackSymbols];
       }
-      if (nil != alertElement) {
-        didDetectAlert = YES;
+      if (didDetectAlert) {
         break;
       }
     }
 
     if (!didDetectAlert) {
       @try {
-        XCUIElement *alertElement = [XCUIApplication fb_limitedAccessPromptAlertElement];
-        if (nil != alertElement) {
-          [delegate didDetectAlert:[FBAlert alertWithElement:alertElement]];
+        XCUIApplication *promptApp = XCUIApplication.fb_limitedAccessPromptApplication;
+        if (nil != promptApp) {
+          FBAlert *alert = [FBAlert alertWithApplication:promptApp];
+          if (alert.isPresent) {
+            [delegate didDetectAlert:alert];
+          }
         }
       } @catch (NSException *e) {
         [FBLogger logFmt:@"Got an unexpected exception while monitoring alerts: %@\n%@", e.reason, e.callStackSymbols];