/**
* A compoundSelector encapsulate both Regular and Pattern selectors. The formats follows:
*
* <p>regular_selector = By[attributes... CHILD=By[attributes... CHILD=By[....]]] <br>
* pattern_selector = ...CONTAINER=By[..] PATTERN=By[instance=x PATTERN=[regular_selector] <br>
* compound_selector = [regular_selector [pattern_selector]]
*
* <p>regular_selectors are the most common form of selectors and the search for them is
* straightforward. On the other hand pattern_selectors requires search to be performed as in
* regular_selector but where regular_selector search returns immediately upon a successful match,
* the search for pattern_selector continues until the requested matched _instance_ of that
* pattern is matched.
*
* <p>Counting UI objects requires using pattern_selectors. The counting search is the same as a
* pattern_search however we're not looking to match an instance of the pattern but rather
* continuously walking the accessibility node hierarchy while counting matched patterns, until
* the end of the tree.
*
* <p>If both present, order of parsing begins with CONTAINER followed by PATTERN then the top
* most selector is processed as regular_selector within the context of the previous CONTAINER and
* its PATTERN information. If neither is present then the top selector is directly treated as
* regular_selector. So the presence of a CONTAINER and PATTERN within a selector simply dictates
* that the selector matching will be constraint to the sub tree node where the CONTAINER and its
* child PATTERN have identified.
*
* @param selector
* @param fromNode
* @param isCounting
* @return AccessibilityNodeInfo
*/
private AccessibilityNodeInfo translateCompoundSelector(
UiSelector selector, AccessibilityNodeInfo fromNode, boolean isCounting) {
// Start translating compound selectors by translating the regular_selector first
// The regular_selector is then used as a container for any optional pattern_selectors
// that may or may not be specified.
if (selector.hasContainerSelector())
// nested pattern selectors
if (selector.getContainerSelector().hasContainerSelector()) {
fromNode = translateCompoundSelector(selector.getContainerSelector(), fromNode, false);
initializeNewSearch();
} else fromNode = translateReqularSelector(selector.getContainerSelector(), fromNode);
else fromNode = translateReqularSelector(selector, fromNode);
if (fromNode == null) {
if (DEBUG) Log.d(LOG_TAG, "Container selector not found: " + selector.dumpToString(false));
return null;
}
if (selector.hasPatternSelector()) {
fromNode = translatePatternSelector(selector.getPatternSelector(), fromNode, isCounting);
if (isCounting) {
Log.i(LOG_TAG, String.format("Counted %d instances of: %s", mPatternCounter, selector));
return null;
} else {
if (fromNode == null) {
if (DEBUG) Log.d(LOG_TAG, "Pattern selector not found: " + selector.dumpToString(false));
return null;
}
}
}
// translate any additions to the selector that may have been added by tests
// with getChild(By selector) after a container and pattern selectors
if (selector.hasContainerSelector() || selector.hasPatternSelector()) {
if (selector.hasChildSelector() || selector.hasParentSelector())
fromNode = translateReqularSelector(selector, fromNode);
}
if (fromNode == null) {
if (DEBUG) Log.d(LOG_TAG, "Object Not Found for selector " + selector);
return null;
}
Log.i(LOG_TAG, String.format("Matched selector: %s <<==>> [%s]", selector, fromNode));
return fromNode;
}
