/**
* Used by the {@link #translateCompoundSelector(UiSelector, AccessibilityNodeInfo, boolean)} to
* translate the pattern_selector portion. It has the following format:
*
* <p>pattern_selector = ... PATTERN=By[instance=x PATTERN=[regular_selector]]<br>
*
* <p>pattern_selectors requires search to be performed as 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 encountered.
*
* <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 patterns until the end of
* the tree.
*
* @param subSelector
* @param fromNode
* @param isCounting
* @return null of node is not found or if counting mode is true. See {@link
* #translateCompoundSelector(UiSelector, AccessibilityNodeInfo, boolean)}
*/
private AccessibilityNodeInfo translatePatternSelector(
UiSelector subSelector, AccessibilityNodeInfo fromNode, boolean isCounting) {
if (subSelector.hasPatternSelector()) {
// Since pattern_selectors are also the type of selectors used when counting,
// we check if this is a counting run or an indexing run
if (isCounting)
// since we're counting, we reset the indexer so to terminates the search when
// the end of tree is reached. The count will be in mPatternCount
mPatternIndexer = -1;
else
// terminates the search once we match the pattern's instance
mPatternIndexer = subSelector.getInstance();
// A pattern is wrapped in a PATTERN[instance=x PATTERN[the_pattern]]
subSelector = subSelector.getPatternSelector();
if (subSelector == null) {
Log.e(LOG_TAG, "Pattern portion of the selector is null or not defined");
return null; // there is an implementation fault
}
// save the current indent level as parent indent before pattern searches
// begin under the current tree position.
mLogParentIndent = ++mLogIndent;
return findNodePatternRecursive(subSelector, fromNode, 0, subSelector);
}
Log.e(LOG_TAG, "Selector must have a pattern selector defined"); // implementation fault?
return null;
}
/**
* 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;
}