节点函数

说明

节点模块函数主要是跟节点操作相关联
该模块没有模块前缀，可以直接调用函数
建议获取节点后进行锁定节点后，在进行查找,防止部分使用parent或者child函数问题

getNodeInfo 获取节点集合

timeout 超时时间，单位毫秒
@return {array} 节点对象集合**

1
function main() {
2
    let nodes = text("aaa").getNodeInfo(0)
3
    if (nodes){
4
        logd(JSON.stringify(nodes))
5
        for (let i = 0; i < nodes.length; i++) {
6
            logd(JSON.stringify(nodes[i]))
7
            logd(nodes[i].text)
8
            logd(nodes[i].bounds.top)
9
            logd(nodes[i].bounds.centerX())
10
        }
11
    }
12
}
13

14
main();

getOneNodeInfo 获取单节点

timeout 超时时间，单位毫秒
@return {NodeInfo} 节点对象

1
function main() {
2
    let node = text("aaa").getOneNodeInfo(0);
3
    if (node){
4
        logd(JSON.stringify(node));
5
        logd(node.text)
6
        logd(node.bounds.top)
7
        logd(node.bounds.centerX())
8
    }
9
}
10

11
main();

以下是选择器函数

xpath 选择

xpath选择器，xpath技术请看 : https://www.jianshu.com/p/c205334122b3 和 https://www.runoob.com/xpath/xpath-syntax.html
xpath使用请到idea的节点面板查看xpath属性以及测试xpath功能
@param value 例如 //node[@value=‘易点云测’] 代表选取文本等于易点云测的节点

1
function main() {
2
    //获取选择器对象
3
    var selector = xpath("//node[@value='易点云测']");
4
    let n = selector.getNodeInfo(1000);
5
    logd(JSON.stringify(n))
6
}
7

8
main();

id id 属性全匹配

id 属性全匹配

1
function main() {
2
    //开始再这里编写代码了！！
3
    logd("检查自动化环境...")
4
    //如果自动化服务正常
5
    if (!autoServiceStart(3)) {
6
        logd("自动化服务启动失败，无法执行脚本")
7
        exit();
8
        return;
9
    }
10
    logd("开始执行脚本...")
11
    // 先释放老的数据
12
    releaseNode();
13
    // 锁定新的节点数据
14
    lockNode();
15
    // 进入查找状态
16
    // 按照 id 查找
17
    let nd = id("设置").getOneNodeInfo(1000)
18
    if (nd) {
19
        console.log("id 查找  节点信息 {}  ", JSON.stringify(nd))
20
        // 如果找到了 就点击
21
        let c = clickPoint(nd.bounds.centerX(), nd.bounds.centerY());
22
        logd("点他: {}", c)
23
    } else {
24
        console.log("id 未查找  节点信息  ")
25
    }
26
    // 按照 正则表达式匹配
27
    nd = idMatch(".*置.*").getNodeInfo(1000)
28
    if (nd) {
29
        console.log("idMatch 查找  节点信息 {}  ", JSON.stringify(nd))
30
    } else {
31
        console.log("idMatch 未查找  节点信息  ")
32
    }
33
    // 先释放老的数据
34
    releaseNode();
35
}
36

37
function autoServiceStart(time) {
38
    for (let i = 0; i < time; i++) {
39
        if (isServiceOk()) {
40
            return true;
41
        }
42
        let started = startEnv();
43
        logd("第" + (i + 1) + "次启动服务结果: " + started);
44
        if (isServiceOk()) {
45
            return true;
46
        }
47
    }
48
    return isServiceOk();
49
}
50

51
main()

idMatch id 属性正则匹配

id 属性正则匹配

1
function main() {
2
    //开始再这里编写代码了！！
3
    logd("检查自动化环境...")
4
    //如果自动化服务正常
5
    if (!autoServiceStart(3)) {
6
        logd("自动化服务启动失败，无法执行脚本")
7
        exit();
8
        return;
9
    }
10
    logd("开始执行脚本...")
11
    // 先释放老的数据
12
    releaseNode();
13
    // 锁定新的节点数据
14
    lockNode();
15
    // 进入查找状态
16
    // 按照 id 查找
17
    let nd = id("设置").getOneNodeInfo(1000)
18
    if (nd) {
19
        console.log("id 查找  节点信息 {}  ", JSON.stringify(nd))
20
        // 如果找到了 就点击
21
        let c = clickPoint(nd.bounds.centerX(), nd.bounds.centerY());
22
        logd("点他: {}", c)
23
    } else {
24
        console.log("id 未查找  节点信息  ")
25
    }
26
    // 按照 正则表达式匹配
27
    nd = idMatch(".*置.*").getNodeInfo(1000)
28
    if (nd) {
29
        console.log("idMatch 查找  节点信息 {}  ", JSON.stringify(nd))
30
    } else {
31
        console.log("idMatch 未查找  节点信息  ")
32
    }
33
    // 先释放老的数据
34
    releaseNode();
35
}
36

37
function autoServiceStart(time) {
38
    for (let i = 0; i < time; i++) {
39
        if (isServiceOk()) {
40
            return true;
41
        }
42
        let started = startEnv();
43
        logd("第" + (i + 1) + "次启动服务结果: " + started);
44
        if (isServiceOk()) {
45
            return true;
46
        }
47
    }
48
    return isServiceOk();
49
}
50

51
main()

key key属性全匹配

key 属性全匹配

1
function main() {
2
    //开始再这里编写代码了！！
3
    logd("检查自动化环境...")
4
    //如果自动化服务正常
5
    if (!autoServiceStart(3)) {
6
        logd("自动化服务启动失败，无法执行脚本")
7
        exit();
8
        return;
9
    }
10
    logd("开始执行脚本...")
11
    // 先释放老的数据
12
    releaseNode();
13
    // 锁定新的节点数据
14
    lockNode();
15
    // 进入查找状态
16
    // key
17
    let nd = key("设置").getOneNodeInfo(1000)
18
    if (nd) {
19
        console.log("key 查找  节点信息 {}  ", JSON.stringify(nd))
20
        // 如果找到了 就点击
21
        let c = clickPoint(nd.bounds.centerX(), nd.bounds.centerY());
22
        logd("点他: {}", c)
23
    } else {
24
        console.log("key 未查找  节点信息  ")
25
    }
26
    // 按照 正则表达式匹配
27
    nd = keyMatch(".*置.*").getNodeInfo(1000)
28
    if (nd) {
29
        console.log("keyMatch 查找  节点信息 {}  ", JSON.stringify(nd))
30
    } else {
31
        console.log("keyMatch 未查找  节点信息  ")
32
    }
33
    // 先释放老的数据
34
    releaseNode();
35
}
36

37
function autoServiceStart(time) {
38
    for (let i = 0; i < time; i++) {
39
        if (isServiceOk()) {
40
            return true;
41
        }
42
        let started = startEnv();
43
        logd("第" + (i + 1) + "次启动服务结果: " + started);
44
        if (isServiceOk()) {
45
            return true;
46
        }
47
    }
48
    return isServiceOk();
49
}
50

51
main()

keyMatch key

key 属性正则匹配

1
function main() {
2
    //开始再这里编写代码了！！
3
    logd("检查自动化环境...")
4
    //如果自动化服务正常
5
    if (!autoServiceStart(3)) {
6
        logd("自动化服务启动失败，无法执行脚本")
7
        exit();
8
        return;
9
    }
10
    logd("开始执行脚本...")
11
    // 先释放老的数据
12
    releaseNode();
13
    // 锁定新的节点数据
14
    lockNode();
15
    // 进入查找状态
16
    let nd = keyMatch("设置").getOneNodeInfo(1000)
17
    if (nd) {
18
        console.log("key 查找  节点信息 {}  ", JSON.stringify(nd))
19
        // 如果找到了 就点击
20
        let c = clickPoint(nd.bounds.centerX(), nd.bounds.centerY());
21
        logd("点他: {}", c)
22
    } else {
23
        console.log("keyMatch 未查找  节点信息  ")
24
    }
25
    // 按照 正则表达式匹配
26
    nd = keyMatch(".*置.*").getNodeInfo(1000)
27
    if (nd) {
28
        console.log("keyMatch 查找  节点信息 {}  ", JSON.stringify(nd))
29
    } else {
30
        console.log("keyMatch 未查找  节点信息  ")
31
    }
32
    // 先释放老的数据
33
    releaseNode();
34
}
35

36
function autoServiceStart(time) {
37
    for (let i = 0; i < time; i++) {
38
        if (isServiceOk()) {
39
            return true;
40
        }
41
        let started = startEnv();
42
        logd("第" + (i + 1) + "次启动服务结果: " + started);
43
        if (isServiceOk()) {
44
            return true;
45
        }
46
    }
47
    return isServiceOk();
48
}
49

50
main()

type type属性全匹配

type 属性全匹配

1
function main() {
2
    //开始再这里编写代码了！！
3
    logd("检查自动化环境...")
4
    //如果自动化服务正常
5
    if (!autoServiceStart(3)) {
6
        logd("自动化服务启动失败，无法执行脚本")
7
        exit();
8
        return;
9
    }
10
    logd("开始执行脚本...")
11
    // 先释放老的数据
12
    releaseNode();
13
    // 锁定新的节点数据
14
    lockNode();
15
    // 进入查找状态
16
    // 按照 type 查找
17
    let nd = type("Item").getOneNodeInfo(1000)
18
    if (nd) {
19
        console.log("type 查找  节点信息 {}  ", JSON.stringify(nd))
20
        // 如果找到了 就点击
21
        let c = clickPoint(nd.bounds.centerX(), nd.bounds.centerY());
22
        logd("点他: {}", c)
23
    } else {
24
        console.log("label 未查找  节点信息  ")
25
    }
26
    // 按照 type 正则表达式匹配
27
    nd = typeMatch(".*Item.*").getNodeInfo(1000)
28
    if (nd) {
29
        console.log("typeMatch 查找  节点信息 {}  ", JSON.stringify(nd))
30
    } else {
31
        console.log("typeMatch 未查找  节点信息  ")
32
    }
33
    // 先释放老的数据
34
    releaseNode();
35
}
36

37
function autoServiceStart(time) {
38
    for (let i = 0; i < time; i++) {
39
        if (isServiceOk()) {
40
            return true;
41
        }
42
        let started = startEnv();
43
        logd("第" + (i + 1) + "次启动服务结果: " + started);
44
        if (isServiceOk()) {
45
            return true;
46
        }
47
    }
48
    return isServiceOk();
49
}
50

51
main()

typeMatch type属性正则匹配

type 属性正则匹配

1
function main() {
2
    //开始再这里编写代码了！！
3
    logd("检查自动化环境...")
4
    //如果自动化服务正常
5
    if (!autoServiceStart(3)) {
6
        logd("自动化服务启动失败，无法执行脚本")
7
        exit();
8
        return;
9
    }
10
    logd("开始执行脚本...")
11
    // 先释放老的数据
12
    releaseNode();
13
    // 锁定新的节点数据
14
    lockNode();
15
    // 进入查找状态
16
    // 按照 type 查找
17
    let nd = type("Item").getOneNodeInfo(1000)
18
    if (nd) {
19
        console.log("type 查找  节点信息 {}  ", JSON.stringify(nd))
20
        // 如果找到了 就点击
21
        let c = clickPoint(nd.bounds.centerX(), nd.bounds.centerY());
22
        logd("点他: {}", c)
23
    } else {
24
        console.log("label 未查找  节点信息  ")
25
    }
26
    // 按照 type 正则表达式匹配
27
    nd = typeMatch(".*Item.*").getNodeInfo(1000)
28
    if (nd) {
29
        console.log("typeMatch 查找  节点信息 {}  ", JSON.stringify(nd))
30
    } else {
31
        console.log("ltypeMatch 未查找  节点信息  ")
32
    }
33
    // 先释放老的数据
34
    releaseNode();
35
}
36

37
function autoServiceStart(time) {
38
    for (let i = 0; i < time; i++) {
39
        if (isServiceOk()) {
40
            return true;
41
        }
42
        let started = startEnv();
43
        logd("第" + (i + 1) + "次启动服务结果: " + started);
44
        if (isServiceOk()) {
45
            return true;
46
        }
47
    }
48
    return isServiceOk();
49
}
50

51
main()

hint hint 属性全匹配

hint 属性全匹配

1
function main() {
2
    //开始再这里编写代码了！！
3
    logd("检查自动化环境...")
4
    //如果自动化服务正常
5
    if (!autoServiceStart(3)) {
6
        logd("自动化服务启动失败，无法执行脚本")
7
        exit();
8
        return;
9
    }
10
    logd("开始执行脚本...")
11
    // 先释放老的数据
12
    releaseNode();
13
    // 锁定新的节点数据
14
    lockNode();
15
    // 进入查找状态
16
    let nd = hint("123").getOneNodeInfo(1000)
17
    if (nd) {
18
        console.log("value 查找  节点信息 {}  ", JSON.stringify(nd))
19
        // 如果找到了 就点击
20
        let c = clickPoint(nd.bounds.centerX(), nd.bounds.centerY());
21
        logd("点他: {}", c)
22
    } else {
23
        console.log("value 未查找  节点信息  ")
24
    }
25
    nd = textMatch(".*123.*").getNodeInfo(1000)
26
    if (nd) {
27
        console.log("textMatch 查找  节点信息 {}  ", JSON.stringify(nd))
28
    } else {
29
        console.log("textMatch 未查找  节点信息  ")
30
    }
31
    // 先释放老的数据
32
    releaseNode();
33
}
34

35
function autoServiceStart(time) {
36
    for (let i = 0; i < time; i++) {
37
        if (isServiceOk()) {
38
            return true;
39
        }
40
        let started = startEnv();
41
        logd("第" + (i + 1) + "次启动服务结果: " + started);
42
        if (isServiceOk()) {
43
            return true;
44
        }
45
    }
46
    return isServiceOk();
47
}
48

49
main()

hintMatch hint 属性正则匹配

hint 属性正则匹配

1
function main() {
2
    //开始再这里编写代码了！！
3
    logd("检查自动化环境...")
4
    //如果自动化服务正常
5
    if (!autoServiceStart(3)) {
6
        logd("自动化服务启动失败，无法执行脚本")
7
        exit();
8
        return;
9
    }
10
    logd("开始执行脚本...")
11
    // 先释放老的数据
12
    releaseNode();
13
    // 锁定新的节点数据
14
    lockNode();
15
    // 进入查找状态
16
    let nd = hintMatch("123").getOneNodeInfo(1000)
17
    if (nd) {
18
        console.log(" 查找  节点信息 {}  ", JSON.stringify(nd))
19
        // 如果找到了 就点击
20
        let c = clickPoint(nd.bounds.centerX(), nd.bounds.centerY());
21
        logd("点他: {}", c)
22
    } else {
23
        console.log(" 未查找  节点信息  ")
24
    }
25
    nd = textMatch(".*123.*").getNodeInfo(1000)
26
    if (nd) {
27
        console.log("textMatch 查找  节点信息 {}  ", JSON.stringify(nd))
28
    } else {
29
        console.log("textMatch 未查找  节点信息  ")
30
    }
31
    // 先释放老的数据
32
    releaseNode();
33
}
34
function autoServiceStart(time) {
35
    for (let i = 0; i < time; i++) {
36
        if (isServiceOk()) {
37
            return true;
38
        }
39
        let started = startEnv();
40
        logd("第" + (i + 1) + "次启动服务结果: " + started);
41
        if (isServiceOk()) {
42
            return true;
43
        }
44
    }
45
    return isServiceOk();
46
}
47

48
main()

text text 属性全匹配

text 属性全匹配

1
function main() {
2
    //开始再这里编写代码了！！
3
    logd("检查自动化环境...")
4
    //如果自动化服务正常
5
    if (!autoServiceStart(3)) {
6
        logd("自动化服务启动失败，无法执行脚本")
7
        exit();
8
        return;
9
    }
10
    logd("开始执行脚本...")
11
    // 先释放老的数据
12
    releaseNode();
13
    // 锁定新的节点数据
14
    lockNode();
15
    // 进入查找状态
16
    let nd = text("123").getOneNodeInfo(1000)
17
    if (nd) {
18
        console.log("value 查找  节点信息 {}  ", JSON.stringify(nd))
19
        // 如果找到了 就点击
20
        let c = clickPoint(nd.bounds.centerX(), nd.bounds.centerY());
21
        logd("点他: {}", c)
22
    } else {
23
        console.log("value 未查找  节点信息  ")
24
    }
25
    nd = textMatch(".*123.*").getNodeInfo(1000)
26
    if (nd) {
27
        console.log("textMatch 查找  节点信息 {}  ", JSON.stringify(nd))
28
    } else {
29
        console.log("textMatch 未查找  节点信息  ")
30
    }
31
    // 先释放老的数据
32
    releaseNode();
33
}
34

35
function autoServiceStart(time) {
36
    for (let i = 0; i < time; i++) {
37
        if (isServiceOk()) {
38
            return true;
39
        }
40
        let started = startEnv();
41
        logd("第" + (i + 1) + "次启动服务结果: " + started);
42
        if (isServiceOk()) {
43
            return true;
44
        }
45
    }
46
    return isServiceOk();
47
}
48

49
main()

textMatch text 属性正则匹配

text 属性正则匹配

1
function main() {
2
    //开始再这里编写代码了！！
3
    logd("检查自动化环境...")
4
    //如果自动化服务正常
5
    if (!autoServiceStart(3)) {
6
        logd("自动化服务启动失败，无法执行脚本")
7
        exit();
8
        return;
9
    }
10
    logd("开始执行脚本...")
11
    // 先释放老的数据
12
    releaseNode();
13
    // 锁定新的节点数据
14
    lockNode();
15
    // 进入查找状态
16
    let nd = text("123").getOneNodeInfo(1000)
17
    if (nd) {
18
        console.log(" 查找  节点信息 {}  ", JSON.stringify(nd))
19
        // 如果找到了 就点击
20
        let c = clickPoint(nd.bounds.centerX(), nd.bounds.centerY());
21
        logd("点他: {}", c)
22
    } else {
23
        console.log(" 未查找  节点信息  ")
24
    }
25
    nd = textMatch(".*123.*").getNodeInfo(1000)
26
    if (nd) {
27
        console.log("textMatch 查找  节点信息 {}  ", JSON.stringify(nd))
28
    } else {
29
        console.log("textMatch 未查找  节点信息  ")
30
    }
31
    // 先释放老的数据
32
    releaseNode();
33
}
34
function autoServiceStart(time) {
35
    for (let i = 0; i < time; i++) {
36
        if (isServiceOk()) {
37
            return true;
38
        }
39
        let started = startEnv();
40
        logd("第" + (i + 1) + "次启动服务结果: " + started);
41
        if (isServiceOk()) {
42
            return true;
43
        }
44
    }
45
    return isServiceOk();
46
}
47

48
main()

hostWindowId hostWindowId 属性全匹配

hostWindowId 属性全匹配

1
function main() {
2
    //开始再这里编写代码了！！
3
    logd("检查自动化环境...")
4
    //如果自动化服务正常
5
    if (!autoServiceStart(3)) {
6
        logd("自动化服务启动失败，无法执行脚本")
7
        exit();
8
        return;
9
    }
10
    logd("开始执行脚本...")
11
    // 先释放老的数据
12
    releaseNode();
13
    // 锁定新的节点数据
14
    lockNode();
15
    // 进入查找状态
16
    let nd = hostWindowId("123").getOneNodeInfo(1000)
17
    if (nd) {
18
        console.log("value 查找  节点信息 {}  ", JSON.stringify(nd))
19
        // 如果找到了 就点击
20
        let c = clickPoint(nd.bounds.centerX(), nd.bounds.centerY());
21
        logd("点他: {}", c)
22
    } else {
23
        console.log("value 未查找  节点信息  ")
24
    }
25
    nd = hostWindowIdMatch(".*123.*").getNodeInfo(1000)
26
    if (nd) {
27
        console.log("hostWindowIdMatch 查找  节点信息 {}  ", JSON.stringify(nd))
28
    } else {
29
        console.log("hostWindowIdMatch 未查找  节点信息  ")
30
    }
31
    // 先释放老的数据
32
    releaseNode();
33
}
34

35
function autoServiceStart(time) {
36
    for (let i = 0; i < time; i++) {
37
        if (isServiceOk()) {
38
            return true;
39
        }
40
        let started = startEnv();
41
        logd("第" + (i + 1) + "次启动服务结果: " + started);
42
        if (isServiceOk()) {
43
            return true;
44
        }
45
    }
46
    return isServiceOk();
47
}
48

49
main()

hostWindowIdMatch hostWindowId

hostWindowId 属性正则匹配

1
function main() {
2
    //开始再这里编写代码了！！
3
    logd("检查自动化环境...")
4
    //如果自动化服务正常
5
    if (!autoServiceStart(3)) {
6
        logd("自动化服务启动失败，无法执行脚本")
7
        exit();
8
        return;
9
    }
10
    logd("开始执行脚本...")
11
    // 先释放老的数据
12
    releaseNode();
13
    // 锁定新的节点数据
14
    lockNode();
15
    // 进入查找状态
16
    let nd = hostWindowId("123").getOneNodeInfo(1000)
17
    if (nd) {
18
        console.log(" 查找  节点信息 {}  ", JSON.stringify(nd))
19
        // 如果找到了 就点击
20
        let c = clickPoint(nd.bounds.centerX(), nd.bounds.centerY());
21
        logd("点他: {}", c)
22
    } else {
23
        console.log(" 未查找  节点信息  ")
24
    }
25
    nd = hostWindowIdMatch(".*123.*").getNodeInfo(1000)
26
    if (nd) {
27
        console.log("textMatch 查找  节点信息 {}  ", JSON.stringify(nd))
28
    } else {
29
        console.log("textMatch 未查找  节点信息  ")
30
    }
31
    // 先释放老的数据
32
    releaseNode();
33
}
34
function autoServiceStart(time) {
35
    for (let i = 0; i < time; i++) {
36
        if (isServiceOk()) {
37
            return true;
38
        }
39
        let started = startEnv();
40
        logd("第" + (i + 1) + "次启动服务结果: " + started);
41
        if (isServiceOk()) {
42
            return true;
43
        }
44
    }
45
    return isServiceOk();
46
}
47

48
main()

description description 属性全匹配

description 属性全匹配

1
function main() {
2
    //开始再这里编写代码了！！
3
    logd("检查自动化环境...")
4
    //如果自动化服务正常
5
    if (!autoServiceStart(3)) {
6
        logd("自动化服务启动失败，无法执行脚本")
7
        exit();
8
        return;
9
    }
10
    logd("开始执行脚本...")
11
    // 先释放老的数据
12
    releaseNode();
13
    // 锁定新的节点数据
14
    lockNode();
15
    // 进入查找状态
16
    let nd = description("123").getOneNodeInfo(1000)
17
    if (nd) {
18
        console.log("value 查找  节点信息 {}  ", JSON.stringify(nd))
19
        // 如果找到了 就点击
20
        let c = clickPoint(nd.bounds.centerX(), nd.bounds.centerY());
21
        logd("点他: {}", c)
22
    } else {
23
        console.log("value 未查找  节点信息  ")
24
    }
25
    // 先释放老的数据
26
    releaseNode();
27
}
28

29
function autoServiceStart(time) {
30
    for (let i = 0; i < time; i++) {
31
        if (isServiceOk()) {
32
            return true;
33
        }
34
        let started = startEnv();
35
        logd("第" + (i + 1) + "次启动服务结果: " + started);
36
        if (isServiceOk()) {
37
            return true;
38
        }
39
    }
40
    return isServiceOk();
41
}
42

43
main()

descriptionMatch description

description 属性正则匹配

1
function main() {
2
    //开始再这里编写代码了！！
3
    logd("检查自动化环境...")
4
    //如果自动化服务正常
5
    if (!autoServiceStart(3)) {
6
        logd("自动化服务启动失败，无法执行脚本")
7
        exit();
8
        return;
9
    }
10
    logd("开始执行脚本...")
11
    // 先释放老的数据
12
    releaseNode();
13
    // 锁定新的节点数据
14
    lockNode();
15
    // 进入查找状态
16
    let nd = description("123").getOneNodeInfo(1000)
17
    if (nd) {
18
        console.log(" 查找  节点信息 {}  ", JSON.stringify(nd))
19
        // 如果找到了 就点击
20
        let c = clickPoint(nd.bounds.centerX(), nd.bounds.centerY());
21
        logd("点他: {}", c)
22
    } else {
23
        console.log(" 未查找  节点信息  ")
24
    }
25
    nd = descriptionMatch(".*123.*").getNodeInfo(1000)
26
    if (nd) {
27
        console.log("descriptionMatch 查找  节点信息 {}  ", JSON.stringify(nd))
28
    } else {
29
        console.log("descriptionMatch 未查找  节点信息  ")
30
    }
31
    // 先释放老的数据
32
    releaseNode();
33
}
34
function autoServiceStart(time) {
35
    for (let i = 0; i < time; i++) {
36
        if (isServiceOk()) {
37
            return true;
38
        }
39
        let started = startEnv();
40
        logd("第" + (i + 1) + "次启动服务结果: " + started);
41
        if (isServiceOk()) {
42
            return true;
43
        }
44
    }
45
    return isServiceOk();
46
}
47

48
main()

bundleName bundleName 属性全匹配

bundleName 属性全匹配

1
function main() {
2
    //开始再这里编写代码了！！
3
    logd("检查自动化环境...")
4
    //如果自动化服务正常
5
    if (!autoServiceStart(3)) {
6
        logd("自动化服务启动失败，无法执行脚本")
7
        exit();
8
        return;
9
    }
10
    logd("开始执行脚本...")
11
    // 先释放老的数据
12
    releaseNode();
13
    // 锁定新的节点数据
14
    lockNode();
15
    // 进入查找状态
16
    let nd = bundleName("123").getOneNodeInfo(1000)
17
    if (nd) {
18
        console.log("value 查找  节点信息 {}  ", JSON.stringify(nd))
19
        // 如果找到了 就点击
20
        let c = clickPoint(nd.bounds.centerX(), nd.bounds.centerY());
21
        logd("点他: {}", c)
22
    } else {
23
        console.log("value 未查找  节点信息  ")
24
    }
25
    // 先释放老的数据
26
    releaseNode();
27
}
28

29
function autoServiceStart(time) {
30
    for (let i = 0; i < time; i++) {
31
        if (isServiceOk()) {
32
            return true;
33
        }
34
        let started = startEnv();
35
        logd("第" + (i + 1) + "次启动服务结果: " + started);
36
        if (isServiceOk()) {
37
            return true;
38
        }
39
    }
40
    return isServiceOk();
41
}
42

43
main()

bundleNameMatch bundleName

bundleName 属性正则匹配

1
function main() {
2
    //开始再这里编写代码了！！
3
    logd("检查自动化环境...")
4
    //如果自动化服务正常
5
    if (!autoServiceStart(3)) {
6
        logd("自动化服务启动失败，无法执行脚本")
7
        exit();
8
        return;
9
    }
10
    logd("开始执行脚本...")
11
    // 先释放老的数据
12
    releaseNode();
13
    // 锁定新的节点数据
14
    lockNode();
15
    // 进入查找状态
16
    let nd = bundleName("123").getOneNodeInfo(1000)
17
    if (nd) {
18
        console.log(" 查找  节点信息 {}  ", JSON.stringify(nd))
19
        // 如果找到了 就点击
20
        let c = clickPoint(nd.bounds.centerX(), nd.bounds.centerY());
21
        logd("点他: {}", c)
22
    } else {
23
        console.log(" 未查找  节点信息  ")
24
    }
25
    nd = bundleNameMatch(".*123.*").getNodeInfo(1000)
26
    if (nd) {
27
        console.log("bundleNameMatch 查找  节点信息 {}  ", JSON.stringify(nd))
28
    } else {
29
        console.log("bundleNameMatch 未查找  节点信息  ")
30
    }
31
    // 先释放老的数据
32
    releaseNode();
33
}
34
function autoServiceStart(time) {
35
    for (let i = 0; i < time; i++) {
36
        if (isServiceOk()) {
37
            return true;
38
        }
39
        let started = startEnv();
40
        logd("第" + (i + 1) + "次启动服务结果: " + started);
41
        if (isServiceOk()) {
42
            return true;
43
        }
44
    }
45
    return isServiceOk();
46
}
47

48
main()

pagePath pagePath 属性全匹配

pagePath 属性全匹配

1
function main() {
2
    //开始再这里编写代码了！！
3
    logd("检查自动化环境...")
4
    //如果自动化服务正常
5
    if (!autoServiceStart(3)) {
6
        logd("自动化服务启动失败，无法执行脚本")
7
        exit();
8
        return;
9
    }
10
    logd("开始执行脚本...")
11
    // 先释放老的数据
12
    releaseNode();
13
    // 锁定新的节点数据
14
    lockNode();
15
    // 进入查找状态
16
    let nd = pagePath("123").getOneNodeInfo(1000)
17
    if (nd) {
18
        console.log("value 查找  节点信息 {}  ", JSON.stringify(nd))
19
        // 如果找到了 就点击
20
        let c = clickPoint(nd.bounds.centerX(), nd.bounds.centerY());
21
        logd("点他: {}", c)
22
    } else {
23
        console.log("value 未查找  节点信息  ")
24
    }
25
    // 先释放老的数据
26
    releaseNode();
27
}
28

29
function autoServiceStart(time) {
30
    for (let i = 0; i < time; i++) {
31
        if (isServiceOk()) {
32
            return true;
33
        }
34
        let started = startEnv();
35
        logd("第" + (i + 1) + "次启动服务结果: " + started);
36
        if (isServiceOk()) {
37
            return true;
38
        }
39
    }
40
    return isServiceOk();
41
}
42

43
main()

pagePathMatch pagePath

pagePath 属性正则匹配

1
function main() {
2
    //开始再这里编写代码了！！
3
    logd("检查自动化环境...")
4
    //如果自动化服务正常
5
    if (!autoServiceStart(3)) {
6
        logd("自动化服务启动失败，无法执行脚本")
7
        exit();
8
        return;
9
    }
10
    logd("开始执行脚本...")
11
    // 先释放老的数据
12
    releaseNode();
13
    // 锁定新的节点数据
14
    lockNode();
15
    // 进入查找状态
16
    let nd = pagePath("123").getOneNodeInfo(1000)
17
    if (nd) {
18
        console.log(" 查找  节点信息 {}  ", JSON.stringify(nd))
19
        // 如果找到了 就点击
20
        let c = clickPoint(nd.bounds.centerX(), nd.bounds.centerY());
21
        logd("点他: {}", c)
22
    } else {
23
        console.log(" 未查找  节点信息  ")
24
    }
25
    nd = pagePathMatch(".*123.*").getNodeInfo(1000)
26
    if (nd) {
27
        console.log("pagePathMatch 查找  节点信息 {}  ", JSON.stringify(nd))
28
    } else {
29
        console.log("pagePathMatch 未查找  节点信息  ")
30
    }
31
    // 先释放老的数据
32
    releaseNode();
33
}
34
function autoServiceStart(time) {
35
    for (let i = 0; i < time; i++) {
36
        if (isServiceOk()) {
37
            return true;
38
        }
39
        let started = startEnv();
40
        logd("第" + (i + 1) + "次启动服务结果: " + started);
41
        if (isServiceOk()) {
42
            return true;
43
        }
44
    }
45
    return isServiceOk();
46
}
47

48
main()

longClickable longClickable 属性全匹配

longClickable 属性全匹配

1
function main() {
2
    //开始再这里编写代码了！！
3
    logd("检查自动化环境...")
4
    //如果自动化服务正常
5
    if (!autoServiceStart(3)) {
6
        logd("自动化服务启动失败，无法执行脚本")
7
        exit();
8
        return;
9
    }
10
    logd("开始执行脚本...")
11
    // 先释放老的数据
12
    releaseNode();
13
    // 锁定新的节点数据
14
    lockNode();
15
    // 进入查找状态
16
    // 按照 longClickable  查找
17
    let nd = longClickable(true).getOneNodeInfo(1000)
18
    if (nd) {
19
        console.log(" 查找  节点信息 {}  ", JSON.stringify(nd))
20
        // 如果找到了 就点击
21
        let c = clickPoint(nd.bounds.centerX(), nd.bounds.centerY());
22
        logd("点他: {}", c)
23
    } else {
24
        console.log(" 未查找  节点信息  ")
25
    }
26
    // 先释放老的数据
27
    releaseNode();
28
}
29

30
function autoServiceStart(time) {
31
    for (let i = 0; i < time; i++) {
32
        if (isServiceOk()) {
33
            return true;
34
        }
35
        let started = startEnv();
36
        logd("第" + (i + 1) + "次启动服务结果: " + started);
37
        if (isServiceOk()) {
38
            return true;
39
        }
40
    }
41
    return isServiceOk();
42
}
43

44
main()

enable enable属性全匹配

enable 属性全匹配

1
function main() {
2
    //开始再这里编写代码了！！
3
    logd("检查自动化环境...")
4
    //如果自动化服务正常
5
    if (!autoServiceStart(3)) {
6
        logd("自动化服务启动失败，无法执行脚本")
7
        exit();
8
        return;
9
    }
10
    logd("开始执行脚本...")
11
    // 先释放老的数据
12
    releaseNode();
13
    // 锁定新的节点数据
14
    lockNode();
15
    // 进入查找状态
16
    // 按照 enable  查找
17
    let nd = enable(true).getOneNodeInfo(1000)
18
    if (nd) {
19
        console.log(" 查找  节点信息 {}  ", JSON.stringify(nd))
20
        // 如果找到了 就点击
21
        let c = clickPoint(nd.bounds.centerX(), nd.bounds.centerY());
22
        logd("点他: {}", c)
23
    } else {
24
        console.log(" 未查找  节点信息  ")
25
    }
26
    // 先释放老的数据
27
    releaseNode();
28
}
29

30
function autoServiceStart(time) {
31
    for (let i = 0; i < time; i++) {
32
        if (isServiceOk()) {
33
            return true;
34
        }
35
        let started = startEnv();
36
        logd("第" + (i + 1) + "次启动服务结果: " + started);
37
        if (isServiceOk()) {
38
            return true;
39
        }
40
    }
41
    return isServiceOk();
42
}
43

44
main()

visible visible属性全匹配

visible 属性全匹配

1
function main() {
2
    //开始再这里编写代码了！！
3
    logd("检查自动化环境...")
4
    //如果自动化服务正常
5
    if (!autoServiceStart(3)) {
6
        logd("自动化服务启动失败，无法执行脚本")
7
        exit();
8
        return;
9
    }
10
    logd("开始执行脚本...")
11
    // 先释放老的数据
12
    releaseNode();
13
    // 锁定新的节点数据
14
    lockNode();
15
    // 进入查找状态
16
    // 按照 visible  查找
17
    let nd = visible(true).getOneNodeInfo(1000)
18
    if (nd) {
19
        console.log(" 查找  节点信息 {}  ", JSON.stringify(nd))
20
        // 如果找到了 就点击
21
        let c = clickPoint(nd.bounds.centerX(), nd.bounds.centerY());
22
        logd("点他: {}", c)
23
    } else {
24
        console.log(" 未查找  节点信息  ")
25
    }
26
    // 先释放老的数据
27
    releaseNode();
28
}
29

30
function autoServiceStart(time) {
31
    for (let i = 0; i < time; i++) {
32
        if (isServiceOk()) {
33
            return true;
34
        }
35
        let started = startEnv();
36
        logd("第" + (i + 1) + "次启动服务结果: " + started);
37
        if (isServiceOk()) {
38
            return true;
39
        }
40
    }
41
    return isServiceOk();
42
}
43

44
main()

zIndex zIndex 属性全匹配

zIndex 属性全匹配

1
function main() {
2
    //开始再这里编写代码了！！
3
    logd("检查自动化环境...")
4
    //如果自动化服务正常
5
    if (!autoServiceStart(3)) {
6
        logd("自动化服务启动失败，无法执行脚本")
7
        exit();
8
        return;
9
    }
10
    logd("开始执行脚本...")
11
    // 先释放老的数据
12
    releaseNode();
13
    // 锁定新的节点数据
14
    lockNode();
15
    // 进入查找状态
16
    // 按照 zIndex  查找
17
    let nd = zIndex(1).getOneNodeInfo(1000)
18
    if (nd) {
19
        console.log(" 查找 节点信息 {}  ", JSON.stringify(nd))
20
        // 如果找到了 就点击
21
        let c = clickPoint(nd.bounds.centerX(), nd.bounds.centerY());
22
        logd("点他: {}", c)
23
    } else {
24
        console.log(" 未查找  节点信息  ")
25
    }
26
    // 先释放老的数据
27
    releaseNode();
28
}
29

30
function autoServiceStart(time) {
31
    for (let i = 0; i < time; i++) {
32
        if (isServiceOk()) {
33
            return true;
34
        }
35
        let started = startEnv();
36
        logd("第" + (i + 1) + "次启动服务结果: " + started);
37
        if (isServiceOk()) {
38
            return true;
39
        }
40
    }
41
    return isServiceOk();
42
}
43

44
main()

index index属性全匹配

index 属性全匹配

1
function main() {
2
    //开始再这里编写代码了！！
3
    logd("检查自动化环境...")
4
    //如果自动化服务正常
5
    if (!autoServiceStart(3)) {
6
        logd("自动化服务启动失败，无法执行脚本")
7
        exit();
8
        return;
9
    }
10
    logd("开始执行脚本...")
11
    // 先释放老的数据
12
    releaseNode();
13
    // 锁定新的节点数据
14
    lockNode();
15
    // 进入查找状态
16
    // 按照 index  查找
17
    let nd = index(1).getOneNodeInfo(1000)
18
    if (nd) {
19
        console.log(" 查找 节点信息 {}  ", JSON.stringify(nd))
20
        // 如果找到了 就点击
21
        let c = clickPoint(nd.bounds.centerX(), nd.bounds.centerY());
22
        logd("点他: {}", c)
23
    } else {
24
        console.log(" 未查找  节点信息  ")
25
    }
26
    // 先释放老的数据
27
    releaseNode();
28
}
29

30
function autoServiceStart(time) {
31
    for (let i = 0; i < time; i++) {
32
        if (isServiceOk()) {
33
            return true;
34
        }
35
        let started = startEnv();
36
        logd("第" + (i + 1) + "次启动服务结果: " + started);
37
        if (isServiceOk()) {
38
            return true;
39
        }
40
    }
41
    return isServiceOk();
42
}
43

44
main()

depth depth 属性全匹配

depth 属性全匹配

1
function main() {
2
    //开始再这里编写代码了！！
3
    logd("检查自动化环境...")
4
    //如果自动化服务正常
5
    if (!autoServiceStart(3)) {
6
        logd("自动化服务启动失败，无法执行脚本")
7
        exit();
8
        return;
9
    }
10
    logd("开始执行脚本...")
11
    // 先释放老的数据
12
    releaseNode();
13
    // 锁定新的节点数据
14
    lockNode();
15
    // 进入查找状态
16
    // 按照 depth  查找
17
    let nd = depth(1).getOneNodeInfo(1000)
18
    if (nd) {
19
        console.log(" 查找 节点信息 {}  ", JSON.stringify(nd))
20
        // 如果找到了 就点击
21
        let c = clickPoint(nd.bounds.centerX(), nd.bounds.centerY());
22
        logd("点他: {}", c)
23
    } else {
24
        console.log(" 未查找  节点信息  ")
25
    }
26
    // 先释放老的数据
27
    releaseNode();
28
}
29

30
function autoServiceStart(time) {
31
    for (let i = 0; i < time; i++) {
32
        if (isServiceOk()) {
33
            return true;
34
        }
35
        let started = startEnv();
36
        logd("第" + (i + 1) + "次启动服务结果: " + started);
37
        if (isServiceOk()) {
38
            return true;
39
        }
40
    }
41
    return isServiceOk();
42
}
43

44
main()

focused focused 属性全匹配

focused 属性全匹配

1
function main() {
2
    //开始再这里编写代码了！！
3
    logd("检查自动化环境...")
4
    //如果自动化服务正常
5
    if (!autoServiceStart(3)) {
6
        logd("自动化服务启动失败，无法执行脚本")
7
        exit();
8
        return;
9
    }
10
    logd("开始执行脚本...")
11
    // 先释放老的数据
12
    releaseNode();
13
    // 锁定新的节点数据
14
    lockNode();
15
    // 进入查找状态
16
    let nd = focused(true).getOneNodeInfo(1000)
17
    if (nd) {
18
        console.log(" 查找 节点信息 {}  ", JSON.stringify(nd))
19
        // 如果找到了 就点击
20
        let c = clickPoint(nd.bounds.centerX(), nd.bounds.centerY());
21
        logd("点他: {}", c)
22
    } else {
23
        console.log(" 未查找  节点信息  ")
24
    }
25
    // 先释放老的数据
26
    releaseNode();
27
}
28

29
function autoServiceStart(time) {
30
    for (let i = 0; i < time; i++) {
31
        if (isServiceOk()) {
32
            return true;
33
        }
34
        let started = startEnv();
35
        logd("第" + (i + 1) + "次启动服务结果: " + started);
36
        if (isServiceOk()) {
37
            return true;
38
        }
39
    }
40
    return isServiceOk();
41
}
42

43
main()

enabled enabled 属性全匹配

enabled 属性全匹配

1
function main() {
2
    //开始再这里编写代码了！！
3
    logd("检查自动化环境...")
4
    //如果自动化服务正常
5
    if (!autoServiceStart(3)) {
6
        logd("自动化服务启动失败，无法执行脚本")
7
        exit();
8
        return;
9
    }
10
    logd("开始执行脚本...")
11
    // 先释放老的数据
12
    releaseNode();
13
    // 锁定新的节点数据
14
    lockNode();
15
    // 进入查找状态
16
    let nd = enabled(true).getOneNodeInfo(1000)
17
    if (nd) {
18
        console.log(" 查找 节点信息 {}  ", JSON.stringify(nd))
19
        // 如果找到了 就点击
20
        let c = clickPoint(nd.bounds.centerX(), nd.bounds.centerY());
21
        logd("点他: {}", c)
22
    } else {
23
        console.log(" 未查找  节点信息  ")
24
    }
25
    // 先释放老的数据
26
    releaseNode();
27
}
28

29
function autoServiceStart(time) {
30
    for (let i = 0; i < time; i++) {
31
        if (isServiceOk()) {
32
            return true;
33
        }
34
        let started = startEnv();
35
        logd("第" + (i + 1) + "次启动服务结果: " + started);
36
        if (isServiceOk()) {
37
            return true;
38
        }
39
    }
40
    return isServiceOk();
41
}
42

43
main()

selected selected 属性全匹配

selected 属性全匹配

1
function main() {
2
    //开始再这里编写代码了！！
3
    logd("检查自动化环境...")
4
    //如果自动化服务正常
5
    if (!autoServiceStart(3)) {
6
        logd("自动化服务启动失败，无法执行脚本")
7
        exit();
8
        return;
9
    }
10
    logd("开始执行脚本...")
11
    // 先释放老的数据
12
    releaseNode();
13
    // 锁定新的节点数据
14
    lockNode();
15
    // 进入查找状态
16
    // 按照 selected  查找
17
    let nd = selected(true).getOneNodeInfo(1000)
18
    if (nd) {
19
        console.log(" 查找 节点信息 {}  ", JSON.stringify(nd))
20
        // 如果找到了 就点击
21
        let c = clickPoint(nd.bounds.centerX(), nd.bounds.centerY());
22
        logd("点他: {}", c)
23
    } else {
24
        console.log(" 未查找  节点信息  ")
25
    }
26
    // 先释放老的数据
27
    releaseNode();
28
}
29
function autoServiceStart(time) {
30
    for (let i = 0; i < time; i++) {
31
        if (isServiceOk()) {
32
            return true;
33
        }
34
        let started = startEnv();
35
        logd("第" + (i + 1) + "次启动服务结果: " + started);
36
        if (isServiceOk()) {
37
            return true;
38
        }
39
    }
40
    return isServiceOk();
41
}
42
main()

checkable checkable 属性全匹配

checkable 属性全匹配

1
function main() {
2
    //开始再这里编写代码了！！
3
    logd("检查自动化环境...")
4
    //如果自动化服务正常
5
    if (!autoServiceStart(3)) {
6
        logd("自动化服务启动失败，无法执行脚本")
7
        exit();
8
        return;
9
    }
10
    logd("开始执行脚本...")
11
    // 先释放老的数据
12
    releaseNode();
13
    // 锁定新的节点数据
14
    lockNode();
15
    // 进入查找状态
16
    // 按照 checkable  查找
17
    let nd = checkable(true).getOneNodeInfo(1000)
18
    if (nd) {
19
        console.log(" 查找 节点信息 {}  ", JSON.stringify(nd))
20
        // 如果找到了 就点击
21
        let c = clickPoint(nd.bounds.centerX(), nd.bounds.centerY());
22
        logd("点他: {}", c)
23
    } else {
24
        console.log(" 未查找  节点信息  ")
25
    }
26
    // 先释放老的数据
27
    releaseNode();
28
}
29
function autoServiceStart(time) {
30
    for (let i = 0; i < time; i++) {
31
        if (isServiceOk()) {
32
            return true;
33
        }
34
        let started = startEnv();
35
        logd("第" + (i + 1) + "次启动服务结果: " + started);
36
        if (isServiceOk()) {
37
            return true;
38
        }
39
    }
40
    return isServiceOk();
41
}
42
main()

checked checked 属性全匹配

checked 属性全匹配

1
function main() {
2
    //开始再这里编写代码了！！
3
    logd("检查自动化环境...")
4
    //如果自动化服务正常
5
    if (!autoServiceStart(3)) {
6
        logd("自动化服务启动失败，无法执行脚本")
7
        exit();
8
        return;
9
    }
10
    logd("开始执行脚本...")
11
    // 先释放老的数据
12
    releaseNode();
13
    // 锁定新的节点数据
14
    lockNode();
15
    // 进入查找状态
16
    // 按照 checked  查找
17
    let nd = checked(true).getOneNodeInfo(1000)
18
    if (nd) {
19
        console.log(" 查找 节点信息 {}  ", JSON.stringify(nd))
20
        // 如果找到了 就点击
21
        let c = clickPoint(nd.bounds.centerX(), nd.bounds.centerY());
22
        logd("点他: {}", c)
23
    } else {
24
        console.log(" 未查找  节点信息  ")
25
    }
26
    // 先释放老的数据
27
    releaseNode();
28
}
29
function autoServiceStart(time) {
30
    for (let i = 0; i < time; i++) {
31
        if (isServiceOk()) {
32
            return true;
33
        }
34
        let started = startEnv();
35
        logd("第" + (i + 1) + "次启动服务结果: " + started);
36
        if (isServiceOk()) {
37
            return true;
38
        }
39
    }
40
    return isServiceOk();
41
}
42
main()

childcount childcount属性全匹配

childcount 属性全匹配

1
function main() {
2
    //开始再这里编写代码了！！
3
    logd("检查自动化环境...")
4
    //如果自动化服务正常
5
    if (!autoServiceStart(3)) {
6
        logd("自动化服务启动失败，无法执行脚本")
7
        exit();
8
        return;
9
    }
10
    logd("开始执行脚本...")
11
    // 先释放老的数据
12
    releaseNode();
13
    // 锁定新的节点数据
14
    lockNode();
15
    // 进入查找状态
16
    // 按照 childCount  查找
17
    let nd = childCount(2).getOneNodeInfo(1000)
18
    if (nd) {
19
        console.log(" 查找  节点信息 {}  ", JSON.stringify(nd))
20
        // 如果找到了 就点击
21
        let c = clickPoint(nd.bounds.centerX(), nd.bounds.centerY());
22
        logd("点他: {}", c)
23
    } else {
24
        console.log(" 未查找  节点信息  ")
25
    }
26
    // 先释放老的数据
27
    releaseNode();
28
}
29

30
function autoServiceStart(time) {
31
    for (let i = 0; i < time; i++) {
32
        if (isServiceOk()) {
33
            return true;
34
        }
35
        let started = startEnv();
36
        logd("第" + (i + 1) + "次启动服务结果: " + started);
37
        if (isServiceOk()) {
38
            return true;
39
        }
40
    }
41
    return isServiceOk();
42
}
43

44
main()

bounds bounds属性范围匹配

bounds 属性范围匹配

1
function main() {
2
    //开始再这里编写代码了！！
3
    logd("检查自动化环境...")
4
    //如果自动化服务正常
5
    if (!autoServiceStart(3)) {
6
        logd("自动化服务启动失败，无法执行脚本")
7
        exit();
8
        return;
9
    }
10
    logd("开始执行脚本...")
11
    // 先释放老的数据
12
    releaseNode();
13
    // 锁定新的节点数据
14
    lockNode();
15
    // 进入查找状态
16
    // 按照 bounds  查找
17
    let nd = bounds(100, 100, 300, 300).getOneNodeInfo(1000)
18
    if (nd) {
19
        console.log(" 查找  节点信息 {}  ", JSON.stringify(nd))
20
        // 如果找到了 就点击
21
        let c = clickPoint(nd.bounds.centerX(), nd.bounds.centerY());
22
        logd("点他: {}", c)
23
    } else {
24
        console.log(" 未查找  节点信息  ")
25
    }
26
    // 先释放老的数据
27
    releaseNode();
28
}
29

30
function autoServiceStart(time) {
31
    for (let i = 0; i < time; i++) {
32
        if (isServiceOk()) {
33
            return true;
34
        }
35
        let started = startEnv();
36
        logd("第" + (i + 1) + "次启动服务结果: " + started);
37
        if (isServiceOk()) {
38
            return true;
39
        }
40
    }
41
    return isServiceOk();
42
}
43

44
main()

点击节点

clickCenter 点击节点中心点

点击节点中心点
@return {bool} true 成功，false 失败

1
function main() {
2
    let node = text("地图").getOneNodeInfo(10000)
3
    logd(JSON.stringify(node))
4
    if (node) {
5
        logd(node.clickCenter())
6
    }
7

8
}
9

10
main()

clickRandom 随机点击节点

随机点击节点的坐标
@return {bool} true 成功，false 失败

1
function main() {
2
    let node = text("地图").getOneNodeInfo(10000)
3
    logd(JSON.stringify(node))
4
    if (node) {
5
        logd(node.clickRandom())
6
    }
7

8
}
9

10
main()

多属性级联查询

1
function main() {
2
    //开始再这里编写代码了！！
3
    logd("检查自动化环境...")
4
    //如果自动化服务正常
5
    if (!autoServiceStart(3)) {
6
        logd("自动化服务启动失败，无法执行脚本")
7
        exit();
8
        return;
9
    }
10
    logd("开始执行脚本...")
11
    // 先释放老的数据
12
    releaseNode();
13
    // 锁定新的节点数据
14
    lockNode();
15
    // 进入查找状态
16
    // 按照 级联模式  查找
17
    let nd = textMatch(".*1.*").enabled(true).bounds(100, 100, 300, 300).getOneNodeInfo(1000)
18
    if (nd) {
19
        console.log(" 查找  节点信息 {}  ", JSON.stringify(nd))
20
        // 如果找到了 就点击
21
        let c = clickPoint(nd.bounds.centerX(), nd.bounds.centerY());
22
        logd("点他: {}", c)
23
    } else {
24
        console.log(" 未查找  节点信息  ")
25
    }
26
    // 先释放老的数据
27
    releaseNode();
28
}
29

30
function autoServiceStart(time) {
31
    for (let i = 0; i < time; i++) {
32
        if (isServiceOk()) {
33
            return true;
34
        }
35
        let started = startEnv();
36
        logd("第" + (i + 1) + "次启动服务结果: " + started);
37
        if (isServiceOk()) {
38
            return true;
39
        }
40
    }
41
    return isServiceOk();
42
}
43

44
main()

以下是节点的级联操作

级联获取一个子节点操作 getOneNodeInfo

通过选择器获取第一个节点信息
@param timeout 等待时间，单位是毫秒, 如果是0，代表不等待
@return NodeInfo 对象或者null

1
function main() {
2
    //获取选择器对象
3
    var node =type("Text").getOneNodeInfo(10000);
4
    if (node) {
5
        //获取其中一个子节点
6
        node = node.getOneNodeInfo(text("广告"), 10000);
7
        if (!node) {
8
            toast("无子节点");
9
            return;
10
        }
11
        var x = node.click();
12
        logd(x);
13
    } else {
14
        toast("无节点");
15
    }
16
}
17

18
main();

级联获取多个子节点操作 getNodeInfo

获取节点信息
@param timeout 等待时间，单位是毫秒, 如果是0，代表不等待
@return NodeInfo 节点信息集合

1
function main() {
2
    //获取选择器对象
3
    //选择 节点 type=Text 的节点，
4
    var node = type("Text").getOneNodeInfo(10000);
5
    if (node) {
6
        //获取所有子节点
7
        node = node.getNodeInfo(text("广告").type("Text"), 10000);
8
        if (!node) {
9
            toast("无子节点");
10
            return;
11
        }
12
        var x = node[0].click();
13
        logd(x);
14
    } else {
15
        toast("无节点");
16
    }
17
}
18

19
main();

parent 查询节点的父级

查询节点的父级
@return {NodeInfo} 节点对象

1
function main() {
2
    // 进入查找状态
3
    let nd = textMatch(".*1.*").getOneNodeInfo(1000)
4
    if (nd) {
5
        console.log(" 查找  节点信息 {}  ", JSON.stringify(nd))
6
        let parent = nd.parent()
7
        console.log(" 查找 parent {}  ", JSON.stringify(parent))
8
    } else {
9
        console.log(" 未查找  节点信息  ")
10
    }
11
// 先释放老的数据
12
    releaseNode();
13
}
14

15

16
main()

child 取得单个子节点

取得单个子节点
@param index – 子节点索引
@return {NodeInfo} NodeInfo 对象或者null

1
function main() {
2
    // 进入查找状态
3
    let nd = textMatch(".*1.*").getOneNodeInfo(1000)
4
    if (nd) {
5
        console.log(" 查找  节点信息 {}  ", JSON.stringify(nd))
6
        let child1 = nd.child(0)
7
        console.log(" 查找 child {}  ", JSON.stringify(child1))
8
    } else {
9
        console.log(" 未查找  节点信息  ")
10
    }
11
// 先释放老的数据
12
    releaseNode();
13
}
14

15

16
main()

allChildren 取得所有子节点

取得所有子节点
@return {array} NodeInfo 节点集合

1
function main() {
2
    // 进入查找状态
3
    let nd = textMatch(".*1.*").getOneNodeInfo(1000)
4
    if (nd) {
5
        console.log(" 查找  节点信息 {}  ", JSON.stringify(nd))
6
        let allChildren = nd.allChildren()
7
        console.log(" 查找 allChildren {}  ", JSON.stringify(allChildren))
8
    } else {
9
        console.log(" 未查找  节点信息  ")
10
    }
11
// 先释放老的数据
12
    releaseNode();
13
}
14

15

16
main()

siblings 取得所有兄弟节点

当前节点的所有兄弟节点
@return {array} NodeInfo 节点集合

1
function main() {
2
    // 进入查找状态
3
    let nd = labelMatch(".*1.*").getOneNodeInfo(1000)
4
    if (nd) {
5
        console.log(" 查找  节点信息 {}  ", JSON.stringify(nd))
6
        let siblings = nd.siblings()
7
        console.log(" 查找 siblings {}  ", JSON.stringify(siblings))
8
    } else {
9
        console.log(" 未查找  节点信息  ")
10
    }
11
// 先释放老的数据
12
    releaseNode();
13
}
14

15
main()

previousSiblings 取得前面的兄弟节点

在当前节点前面的兄弟节点
支持版本: EC 鸿蒙Next 1.0.0+
@return {array} NodeInfo 节点集合

1
function main() {
2
    // 进入查找状态
3
    let nd = textMatch(".*1.*").getOneNodeInfo(1000)
4
    if (nd) {
5
        console.log(" 查找  节点信息 {}  ", JSON.stringify(nd))
6
        let previousSiblings = nd.previousSiblings()
7
        console.log(" 查找 previousSiblings {}  ", JSON.stringify(previousSiblings))
8
    } else {
9
        console.log(" 未查找  节点信息  ")
10
    }
11
// 先释放老的数据
12
    releaseNode();
13
}
14

15
main()

nextSiblings 取得后面的兄弟节点

在当前节点后面的兄弟节点
@return {array} NodeInfo 节点集合

1
function main() {
2
    // 进入查找状态
3
    let nd = textMatch(".*1.*").getOneNodeInfo(1000)
4
    if (nd) {
5
        console.log(" 查找  节点信息 {}  ", JSON.stringify(nd))
6
        let nextSiblings = nd.nextSiblings()
7
        console.log(" 查找 nextSiblings {}  ", JSON.stringify(nextSiblings))
8
    } else {
9
        console.log(" 未查找  节点信息  ")
10
    }
11
// 先释放老的数据
12
    releaseNode();
13
}
14

15
main()