UiAutomator源码学习（3）-- UiObject

UiAutomator是由谷歌在Android4.1版本发布时推出的一款用Java编写的UI自动化测试框架。
基于Accessibility服务，该工具提供了对外开放的的api，可以使用这些api对安卓应用进行一系列的自动化测试操作。例如：打开app、点击、滑动、键盘输入、长按以及常用的断言等一系列模拟ui操作。

UiAutomator是Android自动化测试框架，其最大的特点就是可以跨进程操作，基本用法：

device = UiDevice.getInstance(getInstrumentation());
 device.pressHome();

    // Bring up the default launcher by searching for a UI component
    // that matches the content description for the launcher button.
 UiObject allAppsButton = device
            .findObject(new UiSelector().description("Apps"));

    // Perform a click on the button to load the launcher.
 allAppsButton.clickAndWaitForNewWindow();

UiDevice提供了很多操作的接口，在上一章介绍过。本章介绍UIObject和UiSelector
UiObject代表了Android应用中定义的任意的View控件，可以根据UiSelector属性在运行时找到匹配的视图，可以对应不同的view。由此可以看出UIObject是视图对象，UiSelector是获取视图对象的匹配规则。
看在UiDevice中的findObject方法：

  /**
     * Returns a UiObject which represents a view that matches the specified selector criteria.
     *
     * @param selector
     * @return UiObject object
     */
    public UiObject findObject(UiSelector selector) {
        return new UiObject(this, selector);
    }

这个findObject方法返回了一个 UIObject对象，看UIObject的构造函数：

 /**
     * Package-private constructor. Used by {@link UiDevice#findObject(UiSelector)} to construct a
     * UiObject.
     */
    UiObject(UiDevice device, UiSelector selector) {
        mDevice = device;
        mUiSelecto

这是一个包内可见的构造函数，所以如果我们想自己new UIObject，就会提示

'UiObject(androidx.test.uiautomator.UiDevice, androidx.test.uiautomator.UiSelector)' is not public in 'androidx.test.uiautomator.UiObject'. Cannot be accessed from outside package

所以我们只能用UiDevice通过UiSelector去查找界面中的UIObject。在UIObject这个类中我们也可以看到有获取UIObject属性的方法，如：

 /**
     * Retrieves the <code>className</code> property of the UI element.
     *
     * @return class name of the current node represented by this UiObject
     * @throws UiObjectNotFoundException if no match was found
     * @since API Level 18
     */
    public String getClassName() throws UiObjectNotFoundException {
        Tracer.trace();
        AccessibilityNodeInfo node = findAccessibilityNodeInfo(mConfig.getWaitForSelectorTimeout());
        if(node == null) {
            throw new UiObjectNotFoundException(mUiSelector.toString());
        }
        String retVal = safeStringReturn(node.getClassName());
        Log.d(LOG_TAG, String.format("getClassName() = %s", retVal));
        return retVal;
    }

       AccessibilityNodeInfo node = findAccessibilityNodeInfo(mConfig.getWaitForSelectorTimeout());
方法里调用的是QueryController中的方法findAccessibilityNodeInfo(getSelector());

 在这个方法中有一个同步的代码块查找根节点：

 synchronized (mLock) {
            AccessibilityNodeInfo rootNode = getRootNode();
            if (rootNode == null) {
                Log.e(LOG_TAG, "Cannot proceed when root node is null. Aborted search");
                return null;
            }
            // Copy so that we don't modify the original's sub selectors
            UiSelector uiSelector = new UiSelector(selector);
            return translateCompoundSelector(uiSelector, rootNode, isCounting);
        }

这里是UiAutomator得到节点的核心方法。

getRootNode()最终调用的是UiAutomation的getRootInActiveWindow方法（与AccessibilityService交互）来获取根节点rootNode。根节点获取之后，通过递归

translateCompoundSelector遍历 子节点。

 /**
     * 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;
    }

遍历的条件是selector.hasContainerSelector()，UiSelector稍后会详细的解读。

在UiObject中，还有对对象的操作方法，如click swipe等.这些方法调用的和UiDevice中的方法一样，都是

getAutomatorBridge().getInteractionController().clickNoSync(x, y);如果不一样可能也是多了一些超时参数之类的重载方法。
所以之后的流程可以参考上篇 UiDevice的解读，这里不再复述。
UiDevice： https://www.cnblogs.com/yuan1225/p/13254235.html