appium-webdriveragent 4.7.0 → 4.8.2

package/WebDriverAgentLib/Categories/XCUIElement+FBCaching.m

@@ -11,6 +11,7 @@
 
 #import <objc/runtime.h>
 
+#import "FBXCElementSnapshotWrapper+Helpers.h"
 #import "XCUIElement+FBWebDriverAttributes.h"
 #import "XCUIElement+FBUtilities.h"
 #import "XCUIElement+FBUID.h"
@@ -46,8 +47,8 @@ static char XCUIELEMENT_CACHE_ID_KEY;
   if ([self isKindOfClass:XCUIApplication.class]) {
     uid = self.fb_uid;
   } else {
-    XCElementSnapshot *snapshot = self.fb_cachedSnapshot ?: self.fb_takeSnapshot;
-    uid = snapshot.wdUID;
+    id<FBXCElementSnapshot> snapshot = self.fb_cachedSnapshot ?: self.fb_takeSnapshot;
+    uid = [FBXCElementSnapshotWrapper ensureWrapped:snapshot].wdUID;
   }
 
   objc_setAssociatedObject(self, &XCUIELEMENT_CACHE_ID_KEY, uid, OBJC_ASSOCIATION_RETAIN_NONATOMIC);

package/WebDriverAgentLib/Categories/XCUIElement+FBFind.m

@@ -12,10 +12,8 @@
 
 #import "FBMacros.h"
 #import "FBElementTypeTransformer.h"
-#import "FBPredicate.h"
 #import "NSPredicate+FBFormat.h"
-#import "XCElementSnapshot.h"
-#import "XCElementSnapshot+FBHelpers.h"
+#import "FBXCElementSnapshotWrapper+Helpers.h"
 #import "FBXCodeCompatibility.h"
 #import "XCUIElement+FBCaching.h"
 #import "XCUIElement+FBUtilities.h"
@@ -37,7 +35,7 @@
   return matchedElement ? @[matchedElement] : @[];
 }
 
-- (XCElementSnapshot *)fb_cachedSnapshotWithQuery:(XCUIElementQuery *)query
+- (id<FBXCElementSnapshot>)fb_cachedSnapshotWithQuery:(XCUIElementQuery *)query
 {
   return [self isKindOfClass:XCUIApplication.class] ? query.rootElementSnapshot : self.fb_cachedSnapshot;
 }
@@ -51,7 +49,7 @@
   XCUIElementQuery *query = [self.fb_query descendantsMatchingType:type];
   NSMutableArray *result = [NSMutableArray array];
   [result addObjectsFromArray:[self.class fb_extractMatchingElementsFromQuery:query shouldReturnAfterFirstMatch:shouldReturnAfterFirstMatch]];
-  XCElementSnapshot *cachedSnapshot = [self fb_cachedSnapshotWithQuery:query];
+  id<FBXCElementSnapshot> cachedSnapshot = [self fb_cachedSnapshotWithQuery:query];
   if (type == XCUIElementTypeAny || cachedSnapshot.elementType == type) {
     if (shouldReturnAfterFirstMatch || result.count == 0) {
       return @[self];
@@ -73,7 +71,9 @@
   return elements;
 }
 
-- (void)descendantsWithProperty:(NSString *)property value:(NSString *)value partial:(BOOL)partialSearch results:(NSMutableArray<XCUIElement *> *)results
+- (void)descendantsWithProperty:(NSString *)property value:(NSString *)value
+                        partial:(BOOL)partialSearch
+                        results:(NSMutableArray<XCUIElement *> *)results
 {
   if (partialSearch) {
     NSString *text = [self fb_valueForWDAttributeName:property];
@@ -88,12 +88,12 @@
   }
 
   property = [FBElementUtils wdAttributeNameForAttributeName:property];
-  value = [value stringByReplacingOccurrencesOfString:@"'" withString:@"\\'"];
-  NSString *operation = partialSearch ?
-  [NSString stringWithFormat:@"%@ like '*%@*'", property, value] :
-  [NSString stringWithFormat:@"%@ == '%@'", property, value];
-
-  NSPredicate *predicate = [FBPredicate predicateWithFormat:operation];
+  NSPredicate *predicate = [NSPredicate predicateWithBlock:^BOOL(id<FBXCElementSnapshot> snapshot,
+                                                                 NSDictionary<NSString *,id> * _Nullable bindings) {
+    FBXCElementSnapshotWrapper *wrappedSnapshot = [FBXCElementSnapshotWrapper ensureWrapped:snapshot];
+    NSString *propertyValue = [NSString stringWithFormat:@"%@", [wrappedSnapshot fb_valueForWDAttributeName:property]];
+    return partialSearch ? [value containsString:propertyValue] : [value isEqualToString:propertyValue];
+  }];
   XCUIElementQuery *query = [[self.fb_query descendantsMatchingType:XCUIElementTypeAny] matchingPredicate:predicate];
   NSArray *childElements = query.fb_allMatches;
   [results addObjectsFromArray:childElements];
@@ -105,12 +105,12 @@
 - (NSArray<XCUIElement *> *)fb_descendantsMatchingPredicate:(NSPredicate *)predicate
                                 shouldReturnAfterFirstMatch:(BOOL)shouldReturnAfterFirstMatch
 {
-  NSPredicate *formattedPredicate = [NSPredicate fb_formatSearchPredicate:predicate];
+  NSPredicate *formattedPredicate = [NSPredicate fb_snapshotBlockPredicateWithPredicate:predicate];
   XCUIElementQuery *query = [[self.fb_query descendantsMatchingType:XCUIElementTypeAny] matchingPredicate:formattedPredicate];
   NSMutableArray<XCUIElement *> *result = [NSMutableArray array];
   [result addObjectsFromArray:[self.class fb_extractMatchingElementsFromQuery:query
                                                   shouldReturnAfterFirstMatch:shouldReturnAfterFirstMatch]];
-  XCElementSnapshot *cachedSnapshot = [self fb_cachedSnapshotWithQuery:query];
+  id<FBXCElementSnapshot> cachedSnapshot = [self fb_cachedSnapshotWithQuery:query];
   // Include self element into predicate search
   if ([formattedPredicate evaluateWithObject:cachedSnapshot]) {
     if (shouldReturnAfterFirstMatch || result.count == 0) {
@@ -129,16 +129,16 @@
 {
   // XPath will try to match elements only class name, so requesting elements by XCUIElementTypeAny will not work. We should use '*' instead.
   xpathQuery = [xpathQuery stringByReplacingOccurrencesOfString:@"XCUIElementTypeAny" withString:@"*"];
-  NSArray<XCElementSnapshot *> *matchingSnapshots = [FBXPath matchesWithRootElement:self forQuery:xpathQuery];
+  NSArray<id<FBXCElementSnapshot>> *matchingSnapshots = [FBXPath matchesWithRootElement:self forQuery:xpathQuery];
   if (0 == [matchingSnapshots count]) {
     return @[];
   }
   if (shouldReturnAfterFirstMatch) {
-    XCElementSnapshot *snapshot = matchingSnapshots.firstObject;
+    id<FBXCElementSnapshot> snapshot = matchingSnapshots.firstObject;
     matchingSnapshots = @[snapshot];
   }
   return [self fb_filterDescendantsWithSnapshots:matchingSnapshots
-                                         selfUID:self.lastSnapshot.wdUID
+                                         selfUID:[FBXCElementSnapshotWrapper ensureWrapped:self.lastSnapshot].wdUID
                                     onlyChildren:NO];
 }
 
@@ -148,7 +148,11 @@
 - (NSArray<XCUIElement *> *)fb_descendantsMatchingIdentifier:(NSString *)accessibilityId
                                  shouldReturnAfterFirstMatch:(BOOL)shouldReturnAfterFirstMatch
 {
-  NSPredicate *predicate = [FBPredicate predicateWithFormat:@"name == %@", accessibilityId];
+  NSPredicate *predicate = [NSPredicate predicateWithBlock:^BOOL(id<FBXCElementSnapshot> snapshot,
+                                                                 NSDictionary<NSString *,id> * _Nullable bindings) {
+    FBXCElementSnapshotWrapper *wrappedSnapshot = [FBXCElementSnapshotWrapper ensureWrapped:snapshot];
+    return [wrappedSnapshot.wdName isEqualToString:accessibilityId];
+  }];
   return [self fb_descendantsMatchingPredicate:predicate
                    shouldReturnAfterFirstMatch:shouldReturnAfterFirstMatch];
 }

package/WebDriverAgentLib/Categories/XCUIElement+FBIsVisible.h

@@ -7,8 +7,7 @@
  * of patent rights can be found in the PATENTS file in the same directory.
  */
 
-#import <WebDriverAgentLib/XCElementSnapshot.h>
-#import <WebDriverAgentLib/XCUIElement.h>
+#import "FBXCElementSnapshotWrapper.h"
 
 NS_ASSUME_NONNULL_BEGIN
 
@@ -20,7 +19,7 @@ NS_ASSUME_NONNULL_BEGIN
 @end
 
 
-@interface XCElementSnapshot (FBIsVisible)
+@interface FBXCElementSnapshotWrapper (FBIsVisible)
 
 /*! Whether or not the element is visible */
 @property (atomic, readonly) BOOL fb_isVisible;

package/WebDriverAgentLib/Categories/XCUIElement+FBIsVisible.m

@@ -14,10 +14,9 @@
 #import "FBMathUtils.h"
 #import "FBActiveAppDetectionPoint.h"
 #import "FBSession.h"
+#import "FBXCAccessibilityElement.h"
 #import "FBXCodeCompatibility.h"
-#import "XCAccessibilityElement+FBComparison.h"
-#import "XCElementSnapshot+FBHelpers.h"
-#import "XCElementSnapshot+FBHitPoint.h"
+#import "FBXCElementSnapshotWrapper+Helpers.h"
 #import "XCUIElement+FBUtilities.h"
 #import "XCUIElement+FBUID.h"
 #import "XCTestPrivateSymbols.h"
@@ -26,13 +25,14 @@
 
 - (BOOL)fb_isVisible
 {
-  return [self fb_snapshotWithAttributes:@[FB_XCAXAIsVisibleAttributeName]
-                                maxDepth:@1].fb_isVisible;
+  id<FBXCElementSnapshot> snapshot = [self fb_snapshotWithAttributes:@[FB_XCAXAIsVisibleAttributeName]
+                                                            maxDepth:@1];
+  return [FBXCElementSnapshotWrapper ensureWrapped:snapshot].fb_isVisible;
 }
 
 @end
 
-@implementation XCElementSnapshot (FBIsVisible)
+@implementation FBXCElementSnapshotWrapper (FBIsVisible)
 
 - (NSString *)fb_uniqId
 {
@@ -57,7 +57,7 @@
 }
 
 - (BOOL)fb_cacheVisibilityWithValue:(BOOL)isVisible
-                       forAncestors:(nullable NSArray<XCElementSnapshot *> *)ancestors
+                       forAncestors:(nullable NSArray<id<FBXCElementSnapshot>> *)ancestors
 {
   NSMutableDictionary *cache = FBSession.activeSession.elementsVisibilityCache;
   if (nil == cache) {
@@ -72,8 +72,8 @@
   [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 = ancestor.fb_uniqId;
+    for (id<FBXCElementSnapshot> ancestor in ancestors) {
+      NSString *ancestorId = [FBXCElementSnapshotWrapper ensureWrapped:ancestor].fb_uniqId;
       if (nil == [destination objectForKey:ancestorId]) {
         [destination setObject:visibleObj forKey:ancestorId];
       }
@@ -82,17 +82,17 @@
   return isVisible;
 }
 
-- (CGRect)fb_frameInContainer:(XCElementSnapshot *)container
+- (CGRect)fb_frameInContainer:(id<FBXCElementSnapshot>)container
         hierarchyIntersection:(nullable NSValue *)intersectionRectange
 {
   CGRect currentRectangle = nil == intersectionRectange ? self.frame : [intersectionRectange CGRectValue];
-  XCElementSnapshot *parent = self.parent;
+  id<FBXCElementSnapshot> parent = self.parent;
   CGRect parentFrame = parent.frame;
   CGRect containerFrame = container.frame;
   if (CGSizeEqualToSize(parentFrame.size, CGSizeZero) &&
       CGPointEqualToPoint(parentFrame.origin, CGPointZero)) {
     // Special case (or XCTest bug). Shift the origin and return immediately after shift
-    XCElementSnapshot *nextParent = parent.parent;
+    id<FBXCElementSnapshot> nextParent = parent.parent;
     BOOL isGrandparent = YES;
     while (nextParent && nextParent != container) {
       CGRect nextParentFrame = nextParent.frame;
@@ -133,18 +133,19 @@
   if (CGRectIsEmpty(intersectionWithParent) || parent == container) {
     return intersectionWithParent;
   }
-  return [parent fb_frameInContainer:container hierarchyIntersection:[NSValue valueWithCGRect:intersectionWithParent]];
+  return [[FBXCElementSnapshotWrapper ensureWrapped:parent] fb_frameInContainer:container
+                                                          hierarchyIntersection:[NSValue valueWithCGRect:intersectionWithParent]];
 }
 
 - (BOOL)fb_hasAnyVisibleLeafs
 {
-  NSArray<XCElementSnapshot *> *children = self.children;
+  NSArray<id<FBXCElementSnapshot>> *children = self.children;
   if (0 == children.count) {
     return self.fb_isVisible;
   }
 
-  for (XCElementSnapshot *child in children) {
-    if (child.fb_hasAnyVisibleLeafs) {
+  for (id<FBXCElementSnapshot> child in children) {
+    if ([FBXCElementSnapshotWrapper ensureWrapped:child].fb_hasAnyVisibleLeafs) {
       return YES;
     }
   }
@@ -169,13 +170,13 @@
     return [self fb_cacheVisibilityWithValue:NO forAncestors:nil];
   }
 
-  NSArray<XCElementSnapshot *> *ancestors = self.fb_ancestors;
+  NSArray<id<FBXCElementSnapshot>> *ancestors = self.fb_ancestors;
   if ([FBConfiguration shouldUseTestManagerForVisibilityDetection]) {
     BOOL visibleAttrValue = [(NSNumber *)[self fb_attributeValue:FB_XCAXAIsVisibleAttributeName] boolValue];
     return [self fb_cacheVisibilityWithValue:visibleAttrValue forAncestors:ancestors];
   }
 
-  XCElementSnapshot *parentWindow = ancestors.count > 1 ? [ancestors objectAtIndex:ancestors.count - 2] : nil;
+  id<FBXCElementSnapshot> parentWindow = ancestors.count > 1 ? [ancestors objectAtIndex:ancestors.count - 2] : nil;
   CGRect visibleRect = selfFrame;
   if (nil != parentWindow) {
     visibleRect = [self fb_frameInContainer:parentWindow hierarchyIntersection:nil];
@@ -186,7 +187,7 @@
   CGPoint midPoint = CGPointMake(visibleRect.origin.x + visibleRect.size.width / 2,
                                  visibleRect.origin.y + visibleRect.size.height / 2);
 #if !TARGET_OS_TV // TV has no orientation, so it does not need to coordinate
-  XCElementSnapshot *appElement = ancestors.count > 0 ? [ancestors lastObject] : self;
+  id<FBXCElementSnapshot> appElement = ancestors.count > 0 ? [ancestors lastObject] : self;
   CGRect appFrame = appElement.frame;
   CGRect windowFrame = nil == parentWindow ? selfFrame : parentWindow.frame;
   if ((appFrame.size.height > appFrame.size.width && windowFrame.size.height < windowFrame.size.width) ||
@@ -197,22 +198,23 @@
     midPoint = FBInvertPointForApplication(midPoint, appFrame.size, FBApplication.fb_activeApplication.interfaceOrientation);
   }
 #endif
-  XCAccessibilityElement *hitElement = [FBActiveAppDetectionPoint axElementWithPoint:midPoint];
+  id<FBXCAccessibilityElement> hitElement = [FBActiveAppDetectionPoint axElementWithPoint:midPoint];
   if (nil != hitElement) {
-    if ([self.accessibilityElement fb_isEqualToElement:hitElement]) {
+    if (FBIsAXElementEqualToOther(self.accessibilityElement, hitElement)) {
       return [self fb_cacheVisibilityWithValue:YES forAncestors:ancestors];
     }
-    for (XCElementSnapshot *ancestor in ancestors) {
-      if ([hitElement fb_isEqualToElement:ancestor.accessibilityElement]) {
+    for (id<FBXCElementSnapshot> ancestor in ancestors) {
+      if (FBIsAXElementEqualToOther(hitElement, ancestor.accessibilityElement)) {
         return [self fb_cacheVisibilityWithValue:YES forAncestors:ancestors];
       }
     }
   }
   if (self.children.count > 0) {
     if (nil != hitElement) {
-      for (XCElementSnapshot *descendant in self._allDescendants) {
-        if ([hitElement fb_isEqualToElement:descendant.accessibilityElement]) {
-          return [self fb_cacheVisibilityWithValue:YES forAncestors:descendant.fb_ancestors];
+      for (id<FBXCElementSnapshot> descendant in self._allDescendants) {
+        if (FBIsAXElementEqualToOther(hitElement, descendant.accessibilityElement)) {
+          return [self fb_cacheVisibilityWithValue:YES
+                                      forAncestors:[FBXCElementSnapshotWrapper ensureWrapped:descendant].fb_ancestors];
         }
       }
     }

package/WebDriverAgentLib/Categories/XCUIElement+FBPickerWheel.m

@@ -10,6 +10,7 @@
 #import "XCUIElement+FBPickerWheel.h"
 
 #import "FBRunLoopSpinner.h"
+#import "FBXCElementSnapshot.h"
 #import "FBXCodeCompatibility.h"
 #import "XCUIApplication+FBTouchAction.h"
 #import "XCUICoordinate.h"
@@ -23,7 +24,7 @@ static const NSTimeInterval VALUE_CHANGE_TIMEOUT = 2;
 
 - (BOOL)fb_scrollWithOffset:(CGFloat)relativeHeightOffset error:(NSError **)error
 {
-  XCElementSnapshot *snapshot = self.fb_isResolvedFromCache.boolValue
+  id<FBXCElementSnapshot> snapshot = self.fb_isResolvedFromCache.boolValue
     ? self.lastSnapshot
     : self.fb_takeSnapshot;
   NSString *previousValue = snapshot.value;

package/WebDriverAgentLib/Categories/XCUIElement+FBResolve.m

@@ -41,11 +41,15 @@ static char XCUIELEMENT_IS_RESOLVED_NATIVELY_KEY;
   XCUIElementQuery *query = [self isKindOfClass:XCUIApplication.class]
     ? self.application.fb_query
     : [self.application.fb_query descendantsMatchingType:XCUIElementTypeAny];
-  XCElementSnapshot *cachedSnapshot = self.fb_cachedSnapshot;
+  FBXCElementSnapshotWrapper *cachedSnapshot = [FBXCElementSnapshotWrapper ensureWrapped: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;
+  if (nil == uid) {
+    return self;
+  }
+  NSPredicate *predicate = [NSPredicate predicateWithBlock:^BOOL(id<FBXCElementSnapshot> snapshot, NSDictionary *bindings) {
+    return [[FBXCElementSnapshotWrapper ensureWrapped:snapshot].fb_uid isEqualToString:uid];
+  }];
+  return (XCUIElement *)[query matchingPredicate:predicate].fb_firstMatch;
 }
 
 @end

package/WebDriverAgentLib/Categories/XCUIElement+FBScrolling.m

@@ -13,12 +13,11 @@
 #import "FBLogger.h"
 #import "FBMacros.h"
 #import "FBMathUtils.h"
-#import "FBPredicate.h"
 #import "FBXCodeCompatibility.h"
+#import "FBXCElementSnapshotWrapper.h"
+#import "FBXCElementSnapshotWrapper+Helpers.h"
 #import "XCUIApplication+FBTouchAction.h"
 #import "XCUIElement+FBCaching.h"
-#import "XCElementSnapshot+FBHelpers.h"
-#import "XCElementSnapshot.h"
 #import "XCUIApplication.h"
 #import "XCUICoordinate.h"
 #import "XCUICoordinate+FBFix.h"
@@ -34,7 +33,7 @@ const CGFloat FBScrollTouchProportion = 0.75f;
 
 #if !TARGET_OS_TV
 
-@interface XCElementSnapshot (FBScrolling)
+@interface FBXCElementSnapshotWrapper (FBScrolling)
 
 - (void)fb_scrollUpByNormalizedDistance:(CGFloat)distance inApplication:(XCUIApplication *)application;
 - (void)fb_scrollDownByNormalizedDistance:(CGFloat)distance inApplication:(XCUIApplication *)application;
@@ -49,7 +48,7 @@ const CGFloat FBScrollTouchProportion = 0.75f;
 
 - (BOOL)fb_nativeScrollToVisibleWithError:(NSError **)error
 {
-  XCElementSnapshot *snapshot = self.fb_isResolvedFromCache.boolValue
+  id<FBXCElementSnapshot> snapshot = self.fb_isResolvedFromCache.boolValue
     ? self.lastSnapshot
     : self.fb_takeSnapshot;
   return nil != [self _hitPointByAttemptingToScrollToVisibleSnapshot:snapshot
@@ -58,34 +57,38 @@ const CGFloat FBScrollTouchProportion = 0.75f;
 
 - (void)fb_scrollUpByNormalizedDistance:(CGFloat)distance
 {
-  XCElementSnapshot *snapshot = self.fb_isResolvedFromCache.boolValue
+  id<FBXCElementSnapshot> snapshot = self.fb_isResolvedFromCache.boolValue
     ? self.lastSnapshot
     : self.fb_takeSnapshot;
-  [snapshot fb_scrollUpByNormalizedDistance:distance inApplication:self.application];
+  [[FBXCElementSnapshotWrapper ensureWrapped:snapshot] fb_scrollUpByNormalizedDistance:distance
+                                                                         inApplication:self.application];
 }
 
 - (void)fb_scrollDownByNormalizedDistance:(CGFloat)distance
 {
-  XCElementSnapshot *snapshot = self.fb_isResolvedFromCache.boolValue
+  id<FBXCElementSnapshot> snapshot = self.fb_isResolvedFromCache.boolValue
     ? self.lastSnapshot
     : self.fb_takeSnapshot;
-  [snapshot fb_scrollDownByNormalizedDistance:distance inApplication:self.application];
+  [[FBXCElementSnapshotWrapper ensureWrapped:snapshot] fb_scrollDownByNormalizedDistance:distance
+                                                                           inApplication:self.application];
 }
 
 - (void)fb_scrollLeftByNormalizedDistance:(CGFloat)distance
 {
-  XCElementSnapshot *snapshot = self.fb_isResolvedFromCache.boolValue
+  id<FBXCElementSnapshot> snapshot = self.fb_isResolvedFromCache.boolValue
     ? self.lastSnapshot
     : self.fb_takeSnapshot;
-  [snapshot fb_scrollLeftByNormalizedDistance:distance inApplication:self.application];
+  [[FBXCElementSnapshotWrapper ensureWrapped:snapshot] fb_scrollLeftByNormalizedDistance:distance
+                                                                           inApplication:self.application];
 }
 
 - (void)fb_scrollRightByNormalizedDistance:(CGFloat)distance
 {
-  XCElementSnapshot *snapshot = self.fb_isResolvedFromCache.boolValue
+  id<FBXCElementSnapshot> snapshot = self.fb_isResolvedFromCache.boolValue
     ? self.lastSnapshot
     : self.fb_takeSnapshot;
-  [snapshot fb_scrollRightByNormalizedDistance:distance inApplication:self.application];
+  [[FBXCElementSnapshotWrapper ensureWrapped:snapshot] fb_scrollRightByNormalizedDistance:distance
+                                                                            inApplication:self.application];
 }
 
 - (BOOL)fb_scrollToVisibleWithError:(NSError **)error
@@ -100,9 +103,11 @@ const CGFloat FBScrollTouchProportion = 0.75f;
                                                         error:error];
 }
 
-- (BOOL)fb_scrollToVisibleWithNormalizedScrollDistance:(CGFloat)normalizedScrollDistance scrollDirection:(FBXCUIElementScrollDirection)scrollDirection error:(NSError **)error
+- (BOOL)fb_scrollToVisibleWithNormalizedScrollDistance:(CGFloat)normalizedScrollDistance
+                                       scrollDirection:(FBXCUIElementScrollDirection)scrollDirection
+                                                 error:(NSError **)error
 {
-  XCElementSnapshot *prescrollSnapshot = [self fb_takeSnapshot];
+  FBXCElementSnapshotWrapper *prescrollSnapshot = [FBXCElementSnapshotWrapper ensureWrapped:[self fb_takeSnapshot]];
   if (prescrollSnapshot.isWDVisible) {
     return YES;
   }
@@ -118,23 +123,30 @@ const CGFloat FBScrollTouchProportion = 0.75f;
     ];
   });
 
-  __block NSArray<XCElementSnapshot *> *cellSnapshots, *visibleCellSnapshots;
-  XCElementSnapshot *scrollView = [prescrollSnapshot fb_parentMatchingOneOfTypes:acceptedParents
-      filter:^(XCElementSnapshot *snapshot) {
-
-         if (![snapshot isWDVisible]) {
-           return NO;
-         }
-
-         cellSnapshots = [snapshot fb_descendantsCellSnapshots];
+  __block NSArray<id<FBXCElementSnapshot>> *cellSnapshots;
+  __block NSMutableArray<id<FBXCElementSnapshot>> *visibleCellSnapshots = [NSMutableArray new];
+  id<FBXCElementSnapshot> scrollView = [prescrollSnapshot fb_parentMatchingOneOfTypes:acceptedParents
+      filter:^(id<FBXCElementSnapshot> snapshot) {
+    FBXCElementSnapshotWrapper *wrappedSnapshot = [FBXCElementSnapshotWrapper ensureWrapped:snapshot];
+    
+    if (![wrappedSnapshot isWDVisible]) {
+      return NO;
+    }
 
-         visibleCellSnapshots = [cellSnapshots filteredArrayUsingPredicate:[FBPredicate predicateWithFormat:@"%K == YES", FBStringify(XCUIElement, fb_isVisible)]];
+    cellSnapshots = [wrappedSnapshot fb_descendantsCellSnapshots];
+    
+    for (id<FBXCElementSnapshot> cellSnapshot in cellSnapshots) {
+      FBXCElementSnapshotWrapper *wrappedCellSnapshot = [FBXCElementSnapshotWrapper ensureWrapped:cellSnapshot];
+      if (wrappedCellSnapshot.wdVisible) {
+        [visibleCellSnapshots addObject:cellSnapshot];
+      }
+    }
 
-         if (visibleCellSnapshots.count > 1) {
-           return YES;
-         }
-         return NO;
-      }];
+    if (visibleCellSnapshots.count > 1) {
+      return YES;
+    }
+    return NO;
+  }];
 
   if (scrollView == nil) {
     return
@@ -143,20 +155,21 @@ const CGFloat FBScrollTouchProportion = 0.75f;
      buildError:error];
   }
 
-  XCElementSnapshot *targetCellSnapshot = [prescrollSnapshot fb_parentCellSnapshot];
-  XCElementSnapshot *lastSnapshot = visibleCellSnapshots.lastObject;
+  id<FBXCElementSnapshot> targetCellSnapshot = [prescrollSnapshot fb_parentCellSnapshot];
+  id<FBXCElementSnapshot> lastSnapshot = visibleCellSnapshots.lastObject;
   // Can't just do indexOfObject, because targetCellSnapshot may represent the same object represented by a member of cellSnapshots, yet be a different object
   // than that member. This reflects the fact that targetCellSnapshot came out of self.fb_parentCellSnapshot, not out of cellSnapshots directly.
   // If the result is NSNotFound, we'll just proceed by scrolling downward/rightward, since NSNotFound will always be larger than the current index.
-  NSUInteger targetCellIndex = [cellSnapshots indexOfObjectPassingTest:^BOOL(XCElementSnapshot *_Nonnull obj, NSUInteger idx, BOOL *_Nonnull stop) {
+  NSUInteger targetCellIndex = [cellSnapshots indexOfObjectPassingTest:^BOOL(id<FBXCElementSnapshot> _Nonnull obj,
+                                                                             NSUInteger idx, BOOL *_Nonnull stop) {
     return [obj _matchesElement:targetCellSnapshot];
   }];
   NSUInteger visibleCellIndex = [cellSnapshots indexOfObject:lastSnapshot];
 
   if (scrollDirection == FBXCUIElementScrollDirectionUnknown) {
     // Try to determine the scroll direction by determining the vector between the first and last visible cells
-    XCElementSnapshot *firstVisibleCell = visibleCellSnapshots.firstObject;
-    XCElementSnapshot *lastVisibleCell = visibleCellSnapshots.lastObject;
+    id<FBXCElementSnapshot> firstVisibleCell = visibleCellSnapshots.firstObject;
+    id<FBXCElementSnapshot> lastVisibleCell = visibleCellSnapshots.lastObject;
     CGVector cellGrowthVector = CGVectorMake(firstVisibleCell.frame.origin.x - lastVisibleCell.frame.origin.x,
                                              firstVisibleCell.frame.origin.y - lastVisibleCell.frame.origin.y
                                              );
@@ -169,17 +182,22 @@ const CGFloat FBScrollTouchProportion = 0.75f;
 
   const NSUInteger maxScrollCount = 25;
   NSUInteger scrollCount = 0;
+  FBXCElementSnapshotWrapper *scrollViewWrapped = [FBXCElementSnapshotWrapper ensureWrapped:scrollView];
   // Scrolling till cell is visible and get current value of frames
   while (![self fb_isEquivalentElementSnapshotVisible:prescrollSnapshot] && scrollCount < maxScrollCount) {
     if (targetCellIndex < visibleCellIndex) {
       scrollDirection == FBXCUIElementScrollDirectionVertical ?
-        [scrollView fb_scrollUpByNormalizedDistance:normalizedScrollDistance inApplication:self.application] :
-        [scrollView fb_scrollLeftByNormalizedDistance:normalizedScrollDistance inApplication:self.application];
+        [scrollViewWrapped fb_scrollUpByNormalizedDistance:normalizedScrollDistance
+                                             inApplication:self.application] :
+        [scrollViewWrapped fb_scrollLeftByNormalizedDistance:normalizedScrollDistance
+                                               inApplication:self.application];
     }
     else {
       scrollDirection == FBXCUIElementScrollDirectionVertical ?
-        [scrollView fb_scrollDownByNormalizedDistance:normalizedScrollDistance inApplication:self.application] :
-        [scrollView fb_scrollRightByNormalizedDistance:normalizedScrollDistance inApplication:self.application];
+        [scrollViewWrapped fb_scrollDownByNormalizedDistance:normalizedScrollDistance
+                                               inApplication:self.application] :
+        [scrollViewWrapped fb_scrollRightByNormalizedDistance:normalizedScrollDistance
+                                                inApplication:self.application];
     }
     scrollCount++;
     // Wait for scroll animation
@@ -196,28 +214,32 @@ const CGFloat FBScrollTouchProportion = 0.75f;
   // Cell is now visible, but it might be only partialy visible, scrolling till whole frame is visible.
   // Sometimes, attempting to grab the parent snapshot of the target cell after scrolling is complete causes a stale element reference exception.
   // Trying fb_cachedSnapshot first
-  targetCellSnapshot = [([self fb_cachedSnapshot] ?: [self fb_takeSnapshot]) fb_parentCellSnapshot];
-  CGRect visibleFrame = targetCellSnapshot.fb_visibleFrameWithFallback;
+  FBXCElementSnapshotWrapper *targetCellSnapshotWrapped = [FBXCElementSnapshotWrapper ensureWrapped:([self fb_cachedSnapshot] ?: [self fb_takeSnapshot])];
+  targetCellSnapshot = [targetCellSnapshotWrapped fb_parentCellSnapshot];
+  CGRect visibleFrame = [FBXCElementSnapshotWrapper ensureWrapped:targetCellSnapshot].fb_visibleFrameWithFallback;
   
   CGVector scrollVector = CGVectorMake(visibleFrame.size.width - targetCellSnapshot.frame.size.width,
                                        visibleFrame.size.height - targetCellSnapshot.frame.size.height
                                        );
-  if (![scrollView fb_scrollByVector:scrollVector inApplication:self.application error:error]) {
-    return NO;
-  }
-  return YES;
+  return [scrollViewWrapped fb_scrollByVector:scrollVector
+                                inApplication:self.application
+                                        error:error];
 }
 
-- (BOOL)fb_isEquivalentElementSnapshotVisible:(XCElementSnapshot *)snapshot
+- (BOOL)fb_isEquivalentElementSnapshotVisible:(id<FBXCElementSnapshot>)snapshot
 {
-  if (snapshot.isWDVisible) {
+  FBXCElementSnapshotWrapper *wrappedSnapshot = [FBXCElementSnapshotWrapper ensureWrapped:snapshot];
+  
+  if (wrappedSnapshot.isWDVisible) {
     return YES;
   }
 
-  XCElementSnapshot *appSnapshot = [self.application fb_takeSnapshot];
-  for (XCElementSnapshot *elementSnapshot in appSnapshot._allDescendants.copy) {
+  id<FBXCElementSnapshot> appSnapshot = [self.application fb_takeSnapshot];
+  for (id<FBXCElementSnapshot> elementSnapshot in appSnapshot._allDescendants.copy) {
+    FBXCElementSnapshotWrapper *wrappedElementSnapshot = [FBXCElementSnapshotWrapper ensureWrapped:elementSnapshot];
     // We are comparing pre-scroll snapshot so frames are irrelevant.
-    if ([snapshot fb_framelessFuzzyMatchesElement:elementSnapshot] && elementSnapshot.isWDVisible) {
+    if ([wrappedSnapshot fb_framelessFuzzyMatchesElement:elementSnapshot]
+        && wrappedElementSnapshot.isWDVisible) {
       return YES;
     }
   }
@@ -227,7 +249,7 @@ const CGFloat FBScrollTouchProportion = 0.75f;
 @end
 
 
-@implementation XCElementSnapshot (FBScrolling)
+@implementation FBXCElementSnapshotWrapper (FBScrolling)
 
 - (CGRect)scrollingFrame
 {

package/WebDriverAgentLib/Categories/XCUIElement+FBTyping.m

@@ -13,7 +13,8 @@
 #import "FBErrorBuilder.h"
 #import "FBKeyboard.h"
 #import "NSString+FBVisualLength.h"
-#import "XCElementSnapshot+FBHelpers.h"
+#import "FBXCElementSnapshotWrapper.h"
+#import "FBXCElementSnapshotWrapper+Helpers.h"
 #import "XCUIElement+FBCaching.h"
 #import "XCUIElement+FBTap.h"
 #import "XCUIElement+FBUtilities.h"
@@ -39,19 +40,19 @@
 @end
 
 
-@interface XCElementSnapshot (FBKeyboardFocus)
+@interface FBXCElementSnapshotWrapper (FBKeyboardFocus)
 
 - (BOOL)fb_hasKeyboardFocus;
 
 @end
 
-@implementation XCElementSnapshot (FBKeyboardFocus)
+@implementation FBXCElementSnapshotWrapper (FBKeyboardFocus)
 
 - (BOOL)fb_hasKeyboardFocus
 {
   // https://developer.apple.com/documentation/xctest/xcuielement/1500968-typetext?language=objc
   // > The element or a descendant must have keyboard focus; otherwise an error is raised.
-  return self.hasKeyboardFocus || [self descendantsByFilteringWithBlock:^BOOL(XCElementSnapshot *snapshot) {
+  return self.hasKeyboardFocus || [self descendantsByFilteringWithBlock:^BOOL(id<FBXCElementSnapshot> snapshot) {
     return snapshot.hasKeyboardFocus;
   }].count > 0;
 }
@@ -61,7 +62,7 @@
 
 @implementation XCUIElement (FBTyping)
 
-- (void)fb_prepareForTextInputWithSnapshot:(XCElementSnapshot *)snapshot
+- (void)fb_prepareForTextInputWithSnapshot:(FBXCElementSnapshotWrapper *)snapshot
 {
   if (snapshot.fb_hasKeyboardFocus) {
     return;
@@ -92,10 +93,10 @@
           frequency:(NSUInteger)frequency
               error:(NSError **)error
 {
-  XCElementSnapshot *snapshot = self.fb_isResolvedFromCache.boolValue
+  id<FBXCElementSnapshot> snapshot = self.fb_isResolvedFromCache.boolValue
     ? self.lastSnapshot
     : self.fb_takeSnapshot;
-  [self fb_prepareForTextInputWithSnapshot:snapshot];
+  [self fb_prepareForTextInputWithSnapshot:[FBXCElementSnapshotWrapper ensureWrapped:snapshot]];
   if (shouldClear && ![self fb_clearTextWithSnapshot:self.lastSnapshot
                                shouldPrepareForInput:NO
                                                error:error]) {
@@ -106,15 +107,15 @@
 
 - (BOOL)fb_clearTextWithError:(NSError **)error
 {
-  XCElementSnapshot *snapshot = self.fb_isResolvedFromCache.boolValue
+  id<FBXCElementSnapshot> snapshot = self.fb_isResolvedFromCache.boolValue
     ? self.lastSnapshot
     : self.fb_takeSnapshot;
-  return [self fb_clearTextWithSnapshot:snapshot
+  return [self fb_clearTextWithSnapshot:[FBXCElementSnapshotWrapper ensureWrapped:snapshot]
                   shouldPrepareForInput:YES
                                   error:error];
 }
 
-- (BOOL)fb_clearTextWithSnapshot:(XCElementSnapshot *)snapshot
+- (BOOL)fb_clearTextWithSnapshot:(FBXCElementSnapshotWrapper *)snapshot
            shouldPrepareForInput:(BOOL)shouldPrepareForInput
                            error:(NSError **)error
 {