AiBote 2022 新研发的自动化框架，支持 Android 和 Windows 系统。速度非常快

Ai-Bot 基于流行的 Node.js 和 JavaScript 语言 的一款新自动化框架，支持 Windows 和 Android 自动化。

1、Windows xpath 元素定位算法支持 支持 Windows 应用、.NET、WPF、Qt、Java 和 Electron 客户端程序 和 ie、edge chrome 浏览器

2、Android 支持原生 APP 和 H5 界面，元素定位 速度是 appium 十倍，无线远程自动化操作多台安卓设备

3、基于 opencv 图色算法，支持找图和多点找色，1080*2340 全分辨率找图 50MS 以内

4、内置免费 OCR 人工智能技术，无限制获取图片文字和找字功能。

5、框架协议开源，除官方 node.js SDK 外，用户可自行封装其他语言。目前有 Android 端 第三方用户使用 python 封装的 AiBot.py 模块

6、界面开发基于 chromium 内核，可使用 html、ccs 等 web 前端语言开发界面。

7、框架免费开源、支持打包 exe 和界面开发

基础视频教程：https://www.bilibili.com/video/BV1vt4y137TH?spm_id_from=333.999.0.0
界面开发教程：https://www.bilibili.com/video/BV1fP411G734?spm_id_from=333.999.0.0

Aibote RPA 官方网址:http://www.ai-bot.net/
交流 QQ 群：818820872

下面是开发文档和通信协议：

AndoridBot开发手册

主函数示例

const AndroidBot = require('AndroidBot');//引用AndroidBot模块

//初始化AndroidBot对象，设置服务端监听端口，手机端默认连接端口16678
AndroidBot.registerMain(main, 16678);
/**用作代码提示，main函数会被多次调用，不能使用全局变量
* @param {AndroidBot} androidBot
*/
async function main(androidBot){
    await androidBot.setImplicitTimeout(3000);//设置找图色隐式等待时间
	let point = await androidBot.findColor("#0e76b1");//查找指定颜色值坐标点
    console.log(point);
}

等待超时

await androidBot.sleep(3000);
//显示等待
//参数一 整型，等待时间，单位毫秒

await androidBot.setImplicitTimeout(waitMs, intervalMs = 5);
//隐式等待
//参数一 整型，等待时间，单位毫秒
//参数二 整型，心跳间隔，单位毫秒。可选参数，默认5毫秒

图片与颜色

await androidBot.saveScreenshot(savePath, options = {});
//截图保存
//参数一 字符串类型，保存图片路径。建议存放在手机 /storage/emulated/0/Android/data/com.aibot.client/files/ 目录下
//参数二 JSON类型，可选参数{{region:[left:number, top:number, right:number, bottom:number], threshold:[thresholdType:number, thresh:number, maxval:number]}} options 
//region截图区域 [10, 20, 100, 200], 默认全屏
//threshold二值化图片, thresholdType算法类型：
//                                            0   THRESH_BINARY算法，当前点值大于阈值thresh时，取最大值maxva，否则设置为0
//                                            1   THRESH_BINARY_INV算法，当前点值大于阈值thresh时，设置为0，否则设置为最大值maxva
//                                            2   THRESH_TOZERO算法，当前点值大于阈值thresh时，不改变，否则设置为0
//                                            3   THRESH_TOZERO_INV算法，当前点值大于阈值thresh时，设置为0，否则不改变
//                                            4   THRESH_TRUNC算法，当前点值大于阈值thresh时，设置为阈值thresh，否则不改变
//                                            5   ADAPTIVE_THRESH_MEAN_C算法，自适应阈值
//                                            6   ADAPTIVE_THRESH_GAUSSIAN_C算法，自适应阈值
//                                            thresh阈值，maxval最大值，threshold默认保存原图。thresh和maxval同为255时灰度处理
//成功返回false，失败返回true

await androidBot.getColor(x, y);
//获取颜色值
//参数一 整型，横坐标
//参数二 整型，纵坐标
//成功返回#开头的颜色值，失败返回null

await androidBot.findImage(imagePath, options = {});
//找图1
//参数一 字符串，小图片路径（手机）
//参数二 JSON类型，可选参数，{{region:[left:number, top:number, right:number, bottom:number], sim:number, threshold:[thresholdType:number, thresh:number, maxval:number]}} options
//region 指定区域找图 [10, 20, 100, 200]，region默认全屏
//sim浮点型 图片相似度 0.0-1.0，sim默认1。该值不宜设置太低，否则查找速度会非常慢
//threshold二值化图片, thresholdType算法类型：
//                                            0   THRESH_BINARY算法，当前点值大于阈值thresh时，取最大值maxva，否则设置为0
//                                            1   THRESH_BINARY_INV算法，当前点值大于阈值thresh时，设置为0，否则设置为最大值maxva
//                                            2   THRESH_TOZERO算法，当前点值大于阈值thresh时，不改变，否则设置为0
//                                            3   THRESH_TOZERO_INV算法，当前点值大于阈值thresh时，设置为0，否则不改变
//                                            4   THRESH_TRUNC算法，当前点值大于阈值thresh时，设置为阈值thresh，否则不改变
//                                            5   ADAPTIVE_THRESH_MEAN_C算法，自适应阈值
//                                            6   ADAPTIVE_THRESH_GAUSSIAN_C算法，自适应阈值
//                                            thresh阈值，maxval最大值，threshold默认保存原图。thresh和maxval同为255时灰度处理
//成功返回{x:number, y:number} 失败返回null
//相似度低，导致查找速度慢，应当使用 matchTemplate 函数查找

await androidBot.matchTemplate(imagePath, options = {});
//找图2
//参数一 字符串，小图片路径（手机）
//参数二 JSON类型，可选参数，{{region:[left:number, top:number, right:number, bottom:number], sim:number, threshold:[thresholdType:number, thresh:number, maxval:number]}} options
//region 指定区域找图 [10, 20, 100, 200]，region默认全屏
//sim浮点型 图片相似度 0.0-1.0，sim默认0.95
//threshold二值化图片, thresholdType算法类型：
//                                            0   THRESH_BINARY算法，当前点值大于阈值thresh时，取最大值maxva，否则设置为0
//                                            1   THRESH_BINARY_INV算法，当前点值大于阈值thresh时，设置为0，否则设置为最大值maxva
//                                            2   THRESH_TOZERO算法，当前点值大于阈值thresh时，不改变，否则设置为0
//                                            3   THRESH_TOZERO_INV算法，当前点值大于阈值thresh时，设置为0，否则不改变
//                                            4   THRESH_TRUNC算法，当前点值大于阈值thresh时，设置为阈值thresh，否则不改变
//                                            5   ADAPTIVE_THRESH_MEAN_C算法，自适应阈值
//                                            6   ADAPTIVE_THRESH_GAUSSIAN_C算法，自适应阈值
//                                            thresh阈值，maxval最大值，threshold默认保存原图。thresh和maxval同为255时灰度处理
//multi 找图数量，默认为1,找单个图片坐标
//成功返回，单个坐标点 [{x:number, y:number}]，多坐标点图[{x1:number, y1:number}, {x2:number, y2:number}...] 失败返回null
//纯黑色小图，应当使用 findImage 函数查找

await androidBot.findAnimation(frameRate, options = {});
//找动态图
//参数一 整型，前后两张图相隔的时间，单位毫秒
//参数二 JSON类型，可选参数，{{region:[left:number, top:number, right:number, bottom:number]}} options
//region 指定区域找图 [10, 20, 100, 200]，region默认全屏
//成功返回，单个坐标点 [{x:number, y:number}]，多坐标点图[{x1:number, y1:number}, {x2:number, y2:number}...] 失败返回null

await androidBot.findColor(mainColor, options = {});
//找色
//参数一 字符串，#开头的色值
//参数二 JSON类型，可选参数，{{subColors:[[offsetX:number, offsetY:number, strSubColor:string], ...], region:[left:number, top:number, right:number, bottom:numbe], sim:number}} options
//subColors 相对于mainColor 的子色值，[[offsetX, offsetY, "#FFFFFF"], ...]，subColors默认为null
//region 指定区域找图 [10, 20, 100, 200]，region默认全屏
//sim相似度0.0-1.0，sim默认为1
//成功返回{x:number, y:number} 失败返回null

await androidBot.compareColor(mainX, mainY, mainColor, options = {});
//比色
//参数一 整型，主颜色所在的X坐标
//参数二 整型，主颜色所在的Y坐标
//参数三 字符串，#开头的色值
//参数四 JSON类型，可选参数，{{subColors:[[offsetX:number, offsetY:number, strSubColor:string], ...], region:[left:number, top:number, right:number, bottom:number], sim:number}} options
//subColors 相对于mainColor 的子色值，[[offsetX, offsetY, "#FFFFFF"], ...]，subColors默认为null
//region 指定区域找图 [10, 20, 100, 200]，region默认全屏
//sim相似度0.0-1.0，sim默认为1
//成功返回true 失败返回 false

OCR系统

await androidBot.findWords(ocrServer, words, options = {})
//找字
//参数一 字符串类型，ocr服务地址 ocr.ai-bot.net
//参数二 字符串类型，要查找的文字
//参数三 JSON类型，可选参数 {region:[left:number, top:number, right:number, bottom:number], scale:number}} options
//region 指定区域 [10, 20, 100, 200]，region默认全屏
//scale浮点型 图片缩放率, 默认为 1.0 原大小。大于1.0放大，小于1.0缩小，不能为负数。仅在区域识别有效
//成功功返回数组[{x:number, y:number}, ...]，文字所在的坐标点， 失败返回null

await androidBot.getWords(ocrServer, options = {})
//获取屏幕文字
//参数一 字符串类型，ocr服务地址 ocr.ai-bot.net
//参数二 JSON类型，可选参数 {region:[left:number, top:number, right:number, bottom:number], scale:number}} options
//region 指定区域 [10, 20, 100, 200]，region默认全屏
//scale浮点型 图片缩放率, 默认为 1.0 原大小。大于1.0放大，小于1.0缩小，不能为负数。仅在区域识别有效
//成功返回手机上的文字, 失败返回null

点击手势

await androidBot.click(x, y);
//点击坐标
//参数一 整型，横坐标
//参数二 整型，纵坐标
//成功返回true 失败返回false

await androidBot.doubleClick(x, y);
//双击坐标
//参数一 整型，横坐标
//参数二 整型，纵坐标
//成功返回true 失败返回false

await androidBot.longClick(x, y, duration);
//长按坐标
//参数一 整型，横坐标
//参数二 整型，纵坐标
//参数三 整型，长按时长，单位毫秒 
//成功返回true 失败返回false

await androidBot.swipe(startX, startY, endX, endY, duration);
//滑动坐标
//参数一 整型，起始横坐标
//参数二 整型，起始纵坐标 
//参数三 整型，结束横坐标
//参数四 整型，结束纵坐标
//参数五 整型，滑动时长，单位毫秒 
//成功返回true 失败返回false

await androidBot.dispatchGesture(gesturePath, duration);
//执行手势
//参数一 JSON类型，手势路径 {[[x:number, y:number], [x1:number, y1:number]...]}
//参数二 整型，手势时长，单位毫秒 
//成功返回true 失败返回false

发送文本

await androidBot.sendKeys(text);
//参数一 字符串类型，发送的文本，需要打开aibote输入法
//成功返回true 失败返回false

发送按键

await androidBot.back();
//成功返回true 失败返回false

await androidBot.home();
//成功返回true 失败返回false

await androidBot.recents();
//成功返回true 失败返回false

await androidBot.sendVk(keyCode);
//参数一 整型，发送按键值，需要打开aibote输入法。例如：回车：66 
//按键对照表 https://blog.csdn.net/yaoyaozaiye/article/details/122826340
//成功返回true 失败返回false

启动APP

await androidBot.startApp(name);
//参数一 字符串类型，包名或者app名称
//成功返回true 失败返回false

屏幕大小

await androidBot.getWindowSize();
//成功返回{width:number, height:number}

图片大小

await androidBot.getImageSize(imagePath);
//参数一 字符串类型，图片路径
//成功返回{width:number, height:number}

获取安卓ID

await androidBot.getAndroidId();
//成功返回安卓手机ID

URL请求

await androidBot.urlRequest(url, requestType, contentType = "null", postData = "null")
//参数一 字符串类型，请求的地址，http:// 或者 https://开头
//参数二 字符串类型，请求类型，GET或者POST
//参数三 字符串类型，可选参数，用作POST 内容类型
//参数四 字符串类型，可选参数，用作POST 提交的数据
//返回请求数据内容

Toast消息提示

await androidBot.showToast(text)
//参数一 字符串类型，Toast提示的内容
//成功返回true 失败返回false

验证码系统

await androidBot.getCaptcha(filePath, username, password, softId, codeType, lenMin = 0);
//识别验证码
//参数一 字符串类型，图片文件路径
//参数二 字符串类型，用户名
//参数三 字符串类型，密码
//参数四 字符串类型，软件ID
//参数四 字符串类型，图片类型 参考https://www.chaojiying.com/price.html
//参数五 字符串类型，最小位数 默认0为不启用,图片类型为可变位长时可启用这个参数
//返回JSON类型{{err_no:number, err_str:string, pic_id:string, pic_str:string, md5:string}}
//err_no,(数值) 返回代码  为0 表示正常，错误代码 参考https://www.chaojiying.com/api-23.html
//err_str,(字符串) 中文描述的返回信息 
//pic_id,(字符串) 图片标识号，或图片id号
//pic_str,(字符串) 识别出的结果
//md5,(字符串) md5校验值,用来校验此条数据返回是否真实有效

await androidBot.errorCaptcha(username, password, softId, picId);
//识别报错返分
//参数一 字符串类型，用户名
//参数二 字符串类型，密码
//参数三 字符串类型，软件ID
//参数四 字符串类型，图片ID 对应 getCaptcha返回值的pic_id 字段
//返回JSON类型{{err_no:number, err_str:string}}
//err_no,(数值) 返回代码
//err_str,(字符串) 中文描述的返回信息

await androidBot.scoreCaptcha(username, password);
//查询验证码剩余题分
//参数一 字符串类型，用户名
//参数二 字符串类型，密码
//返回JSON类型{{err_no:number, err_str:string, tifen:string, tifen_lock:string}}
//err_no,(数值) 返回代码
//err_str,(字符串) 中文描述的返回信息
//tifen,(数值) 题分
//tifen_lock,(数值) 锁定题分

元素操作

await androidBot.getElementRect(xpath);
//获取位置
//参数一 字符串类型，元素路径
//成功返回{left:number, top:number, right:number, bottom:number}，失败返回null

await androidBot.getElementDescription(xpath);
//获取元素描述
//参数一 字符串类型，元素路径
//成功返回元素描述内容，失败返回null

await androidBot.getElementText(xpath);
//获取文本
//参数一 字符串类型，元素路径
//成功返回元素内容，失败返回null

await androidBot.setElementText(xpath, text);
//设置文本
//参数一 字符串类型，元素路径
//参数一 字符串类型，设置的文本
//成功返回true 失败返回false

await androidBot.clickElement(xpath);
//击元素
//参数一 字符串类型，元素路径
//成功返回true 失败返回false

await androidBot.scrollElement(xpath, direction);
//滚动元素
//参数一 字符串类型，元素路径
//参数二 整型，0 向前滑动， 1 向后滑动
//成功返回true 失败返回false

await androidBot.existsElement(xpath);
//判断元素是否存在
//参数一 字符串类型，元素路径
//成功返回true 失败返回false

await androidBot.isSelectedElement(xpath);
//判断元素是否选中
//参数一 字符串类型，元素路径
//成功返回true 失败返回false

文件传输

await androidBot.pushFile("d:\\1.png", "/storage/emulated/0/1.png");
//上传文件到手机
//参数一 字符串类型，电脑文件路径
//参数二 字符串类型，安卓文件保存路径, 安卓外部存储根目录 /storage/emulated/0/
//媒体文件会自动更新至相册
//成功返回true 失败返回false

await androidBot.pullFile("/storage/emulated/0/1.png", "d:\\1.png");
//拉取文件到电脑
//参数一 字符串类型，安卓文件路径, 安卓外部存储根目录 /storage/emulated/0/
//参数二 字符串类型，电脑文件保存路径

Intent跳转

await androidBot.openUri("alipayqr://platformapi/startapp?saId=10000007");
//跳转uri
//参数一 字符串类型，跳转链接
//成功返回true，失败返回 false

await androidBot.callPhone("10086");
//拨打电话
//参数一 字符串类型，拨打的电话号码
//成功返回true，失败返回 false

await androidBot.sendMsg("10086", "123")
//发送短信
//参数一 字符串类型，发送的电话号码
//参数二 字符串类型，短信内容
//成功返回true，失败返回 false

获取包名/窗口

await androidBot.getActivity();
//成功返回当前activity

await androidBot.getPackage();
//成功返回当前package

安卓剪切板

await androidBot.setClipboardText(text);
//设置剪切板内容
//参数一 字符串型，设置的文本
//成功返回true 失败返回 false

await androidBot.getClipboardText();
//获取剪切板内容，需要打开aibote输入法。
//成功返回剪切板文本，失败返回null

python 使用方法说明

下载安装

pip install AiBot.py

编写脚本

# 1. 导入 AiBotMain 类
from AiBot import AiBotMain

# 2. 自定义一个脚本类，继承 AiBotMain
class CustomScript(AiBotMain):
    # 3. 设置等待参数
    # 3.1 设置等待时间
    wait_timeout = 3
    # 3.2 设置重试间隔时长
    interval_timeout = 0.1

    # 4. 重写方法，编写脚本
    # 注意：此方法是脚本执行入口
    def script_main(self):
        # 5. API 演示
        # 注意：Python 端支持的 api 与 Nodejs 基本相同
        # 此处仅演示部分 api，更多 api 请自行查阅 上面 Nodejs 文档

        # 截图
        self.save_screenshot("xxx.png")
        # 获取坐标点颜色
        self.get_color((100, 100))
        # 查找图片
        self.find_image("xxx.png")
        # 点击坐标
        self.click((100, 100))
        # 滑动
        self.swipe((100, 100), (200, 200), 3)

教程中仅演示部分 api，更多 api 请自行查阅 Nodejs文档。

调用 execute 方法启动脚本

from AiBot import AiBotMain

class CustomScript(AiBotMain):

    def script_main(self):
        self.show_toast("启动成功")


if __name__ == '__main__':
    # 注意：此处监听的端口号，必须和手机端的脚本端口号一致；
    # 监听 16678 号端口
    CustomScript.execute(16678)

AndoridBot开源协议

Aibote安卓云端自动化框架，采用云端服务模式构建。由安卓手机客户端主动连接服务器/电脑服务端程序，
服务端应采用多线程TCP协议和多个安卓设备通信。构架模式决定了自动化代码部署在云端，能有效防止脚本被第三方恶意破解。
结合Aibote远程投屏技术，可直接连接远程用户设备做自动化机器人编写，完美解决远程自动化测试需求。独家图色定位算法，
50毫秒以内的速度遍历查找2340*1080分辨率的设备。为了让更多人体验到我们产品，我们决议在此公布框架协议，
希望有更多开发者能完善并封装成各种计算机语言。

发送命令协议格式：len/len/len...\ndata
//len：函数名和参数的(字节)长度，统一为十进制 字符串类型
//data：函数名和参数数据 类型为 字符串或字节类型(string/byte) 

接收命令协议格式：len/data
//len：返回数据包的(字节)长度
//data：返回的数据，类型为字符串或字节类型(string/byte) 

协议示例：
//截图保存
sendData("saveScreenshot", "/storage/emulated/0/Android/data/com.aibot.client/files/1.png", 80, 150, 30, 30, 0, 127, 255);
// 参数一：函数名称
// 参数二：保存的图片路径（手机）
// 参数三：矩形左上角x坐标
// 参数四：矩形左上角y坐标
// 参数五：矩形右下角x坐标
// 参数六：矩形右下角y坐标
// 参数七：二值化算法类型
// 参数八：二值化阈值
// 参数九：二值化最大值
发送数据包：14/61/2/3/2/2/1/3/3\nsaveScreenshot/storage/emulated/0/Android/data/com.aibot.client/files/1.png8015030300127255
返回数据包："false"或者 "true"

//获取色值
sendData("getColor", 100, 200);
// 参数一：函数名称
// 参数二：x坐标
// 参数三：y坐标
数据包：8/3/3\ngetColor100200
返回数据包："false"或者 "true"

//找图
sendData("findImage", "/storage/emulated/0/Android/data/com.aibot.client/files/1.png", 0, 0, 0, 0, 0.95, 0, 0, 0);
// 参数一：函数名称
// 参数二：保存的图片路径（手机）
// 参数三：矩形左上角x坐标
// 参数四：矩形左上角y坐标
// 参数五：矩形右下角x坐标
// 参数六：矩形右下角y坐标
// 参数七：相似度
// 参数八：二值化算法类型
// 参数九：二值化阈值
// 参数十：二值化最大值
数据包：9/61/1/1/1/1/4/1/1/1\nfindImage/storage/emulated/0/Android/data/com.aibot.client/files/1.png00000.95000
返回数据包：成功"x|y" 失败"-1.0|-1.0"

//找图2
sendData("matchTemplate", "/storage/emulated/0/Android/data/com.aibot.client/files/1.png", 0, 0, 0, 0, 0.95, 0, 0, 1);
// 参数一：函数名称
// 参数二：保存的图片路径（手机）
// 参数三：矩形左上角x坐标
// 参数四：矩形左上角y坐标
// 参数五：矩形右下角x坐标
// 参数六：矩形右下角y坐标
// 参数七：相似度
// 参数八：二值化阈值
// 参数九：二值化最大值
// 参数十：多个坐标点
数据包：13/61/1/1/1/1/4/1/1/1\nmatchTemplate/storage/emulated/0/Android/data/com.aibot.client/files/1.png00000.95001
返回数据包：单坐标点成功"x|y"  多坐标点成功 "x1|y1/x2|y2..."  失败"-1.0|-1.0"

//找动态图
sendData("findAnimation", 100, 0, 0, 0, 0);
// 参数一：函数名称
// 参数二：前后两张图相隔的时间，单位毫秒
// 参数三：矩形左上角x坐标
// 参数四：矩形左上角y坐标
// 参数五：矩形右下角x坐标
// 参数六：矩形右下角y坐标
数据包：13/3/0/0/0/0\nfindAnimation1000000
返回数据包：单坐标点成功"x|y"  多坐标点成功 "x1|y1/x2|y2..."  失败"-1.0|-1.0"

//找色
sendData("findColor", "#e8f2f8", "1020#e7f0f7", 0, 0, 0, 0, 1);
// 参数一：函数名称
// 参数二：主颜色值
// 参数三：相对偏移的颜色点，以 "x坐标+y坐标+色值" 字符串形式
// 参数四：矩形左上角x坐标
// 参数五：矩形左上角y坐标
// 参数六：矩形右下角x坐标
// 参数七：矩形右下角y坐标
// 参数八：相似度
数据包：9/7/11/1/1/1/1/1\nfindColor#e8f2f81020#e7f0f700001
返回数据包：成功"x|y" 失败"-1.0|-1.0"

//比色
sendData("compareColor", 100, 200, "#e8f2f8", "1020#e7f0f7", 0, 0, 0, 0, 1);
// 参数一：函数名称
// 参数二：主颜色值所在的X坐标
// 参数三：主颜色值所在的Y坐标
// 参数四：主颜色值
// 参数五：相对偏移的颜色点，以 "x坐标+y坐标+色值" 字符串形式
// 参数六：矩形左上角x坐标
// 参数七：矩形左上角y坐标
// 参数八：矩形右下角x坐标
// 参数九：矩形右下角y坐标
// 参数十：相似度
数据包：12/3/3/7/11/1/1/1/1/1\ncompareColor100200#e8f2f81020#e7f0f700001
返回数据包："false"或者 "true"

//点击坐标
sendData("click", 200, 500);
// 参数一：函数名称
// 参数二：x坐标
// 参数三：y坐标
数据包：5/3/3\nclick200500
返回数据包："false"或者 "true"

//双击坐标
sendData("doubleClick", 200, 500);
// 参数一：函数名称
// 参数二：x坐标
// 参数三：y坐标
数据包：11/3/3\ndoubleClick200500
返回数据包："false"或者 "true"

//长按坐标
sendData("longClick", 10, 20, 3000);
// 参数一：函数名称
// 参数二：x坐标
// 参数三：y坐标
// 参数四：长按持续时间
数据包：9/2/2/4\nlongClick10203000
返回数据包："false"或者 "true"

//滑动坐标
sendData("swipe", 10, 10, 200, 200, 1000);
// 参数一：函数名称
// 参数二：开始x坐标
// 参数三：开始y坐标
// 参数四：结束x坐标
// 参数五：结束y坐标
// 参数六：滑动耗时
数据包：5/2/2/3/3/4\nswipe10102002001000
返回数据包："false"或者 "true"

//执行手势
sendData("dispatchGesture", "1000/1558\n100/100\n799/800\n234/89", 3000);
// 参数一：函数名称
// 参数二：执行手势坐标位， 以"/"分割横纵坐标 "\n"分割坐标点。注意：末尾坐标点没有\n结束
// 参数三：手势耗时
数据包：15/35/4\ndispatchGesture1000/1558\n100/100\n799/800\n234/893000
返回数据包："false"或者 "true"

//发送文本
sendData("sendKeys", "aibot");
// 参数一：函数名称
// 参数二：文本内容
数据包：8/5\nsendKeysaibot
返回数据包："false"或者 "true"

//返回
sendData("back");
// 参数一：函数名称
数据包：4\nback
返回数据包："false"或者 "true"

//home
sendData("home");
// 参数一：函数名称
数据包：4\nhome
返回数据包："false"或者 "true"

//最近任务列表
sendData("recents");
// 参数一：函数名称
数据包：7\nrecents
返回数据包："false"或者 "true"

//发送按键
sendData("sendVk", 187);
// 参数一：函数名称
// 参数二：虚拟键值 按键对照表 https://blog.csdn.net/yaoyaozaiye/article/details/122826340
数据包：6/3\nsendVk187
返回数据包："false"或者 "true"

//启动App
sendData("startApp", "QQ");
// 参数一：函数名称
// 参数二：启动APP的名称或者包名
数据包：8/2\nstartAppQQ
返回数据包："false"或者 "true"

//屏幕大小
sendData("getWindowSize");
数据包：13\ngetWindowSize
返回数据包："width|height"

//图片大小
sendData("getImageSize", "/storage/emulated/0/Android/data/com.aibot.client/files/1.png");
数据包：12/61\nsaveScreenshot/storage/emulated/0/Android/data/com.aibot.client/files/1.png
返回数据包："width|height"

//获取安卓ID
sendData("getAndroidId");
数据包：12\ngetAndroidId
返回数据包："1f73c8f2f3b2f108"

//ocr
sendData("ocr", "127.0.0.1", 0, 0, 0, 0, 1.0);
数据包：3/9/1/1/1/1\3\nocr127.0.0.100001.0
返回数据包：[[[7.0, 18.0], [61.0, 18.0], [61.0, 38.0], [7.0, 38.0]], ('办公自动化', 0.8806074261665344)][[[4.0, 94.0], [49.0, 94.0], [49.0, 118.0], [4.0, 118.0]], ('rpa', 0.978314220905304)]

//URL请求
sendData("urlRequest", "http://www.baidu.com", "GET", "null", "null");
数据包：10/20/3/4/4\nurlRequesthttp://www.baidu.comGETnullnull
返回数据包：返回请求数据内容

//Toast消息提示
sendData("showToast", "rpa");
数据包：9/2\nshowToastrpa
返回数据包："false"或者 "true"

//识别验证码
sendData("getCaptcha", "/storage/emulated/0/Android/data/com.aibot.client/files/1.png", "username", "password", "123456", "1004", "0");
数据包：10/61/8/8/6/4/1\n/storage/emulated/0/Android/data/com.aibot.client/files/1.pngusernamepassword12345610040
返回数据包："{"err_no":0,"err_str":"OK","pic_id":"9160109360600112681","pic_str":"8vka","md5":"35d5c7f6f53223fbdc5b72783db0c2c0"}"

//识别报错返分
sendData("errorCaptcha", "username", "password", "123456", "9160109360600112681");
数据包：12/8/8/6/19\nerrorCaptchausernamepassword1234569160109360600112681
返回数据包："{"err_no":0,"err_str":"OK"}"

//查询验证码剩余题分
sendData("scoreCaptcha", "username", "password");
数据包：12/8/8\nscoreCaptchausernamepassword
返回数据包："{"err_no":0,"err_str":"OK","tifen":821690,"tifen_lock":0}"

//获取元素位置
sendData("getElementRect", "com.aibot.client/com.aibot.client:id=inputServer");
数据包：14/48\ngetElementRectcom.aibot.client/com.aibot.client:id=inputServer
返回数据包："239|628|989|764"

//获取元素描述内容
sendData("getElementDescription", "com.aibot.client/com.aibot.client:id=inputServer");
数据包：21/48\ngetElementDescriptioncom.aibot.client/com.aibot.client:id=inputServer
返回数据包："192.168.2.7"

//获取元素文本
sendData("getElementText", "com.aibot.client/com.aibot.client:id=inputServer");
数据包：14/48\ngetElementTextcom.aibot.client/com.aibot.client:id=inputServer
返回数据包："192.168.2.7"

//设置元素文本
sendData("setElementText", "com.aibot.client/com.aibot.client:id=inputServer", "rpa");
数据包：14/48/3\nsetElementTextcom.aibot.client/com.aibot.client:id=inputServerrpa
返回数据包："false"或者 "true"

//点击元素
sendData("clickElement", "com.aibot.client/com.aibot.client:id=inputServer");
数据包：12/48\nclickElementcom.aibot.client/com.aibot.client:id=inputServer
返回数据包："false"或者 "true"

//滚动元素
sendData("scrollElement", "com.aibot.client/com.aibot.client:id=inputServer", 0);
数据包：13/48/1\nclickElementcom.aibot.client/com.aibot.client:id=inputServer0
返回数据包："false"或者 "true"

//判断元素是否存在
sendData("existsElement", "com.aibot.client/com.aibot.client:id=inputServer");
数据包：13/48\nexistsElementcom.aibot.client/com.aibot.client:id=inputServer
返回数据包："false"或者 "true"

//判断元素是否选中
sendData("isSelectedElement", "com.aibot.client/com.aibot.client:id=inputServer");
数据包：17/48\nisSelectedElementcom.aibot.client/com.aibot.client:id=inputServer
返回数据包："false"或者 "true"

//上传文件
sendData("pushFile", "/storage/emulated/0/1.png", fileData);
//fileData 文件字节数据
数据包：8/25/655423\npushFile/storage/emulated/0/1.pngfileData
返回数据包："false"或者 "true"

//拉取文件
sendData("pullFile", "/storage/emulated/0/1.png");
数据包：8/25\npullFile/storage/emulated/0/1.png
返回数据包：文件字节数据

//跳转uri
sendData("openUri", "alipayqr://platformapi/startapp?saId=10000007");
数据包：7/45\nopenUrialipayqr://platformapi/startapp?saId=10000007
返回数据包："false"或者 "true"

//拨打电话
sendData("callPhone", "10086");
数据包：9/5\ncallPhone10086
返回数据包："false"或者 "true"

//发送短信
sendData("sendMsg", "10086", "123");
数据包：7/5/3\nsendMsg10086123
返回数据包："false"或者 "true"

//获取活动窗口(activity)
sendData("getActivity");
数据包：11\ngetActivity
返回数据包：".MainActivity"

//获取活动包名(package)
sendData("getPackage");
数据包：10\ngetPackage
返回数据包："com.aibot.client"

//设置剪切板文本
sendData("setClipboardText", "aibote");
数据包：16/6\nsetClipboardTextaibote
返回数据包："false"或者 "true"

//获取剪切板文本
sendData("getClipboardText");
数据包：16\ngetClipboardText
返回数据包："aibote"

BrowserBot开发手册

主函数示例

const {BrowserBot, By, Key} = require('BrowserBot');//引用BrowserBot模块

async function main(){
    //构建BrowserBot对象
    let browserBot = await BrowserBot.build("chrome", "103.0.5060.134");
    //设置隐式等待
    await browserBot.setImplicitTimeout(5000);
    
    await browserBot.openUrl("https://www.baidu.com");
    await browserBot.sendKeys('//*[@id="kw"]', "aibote", Key.ENTER);
    await browserBot.sleep(5000);
    //退出BrowserBot
    await browserBot.quit();
}

main();

构建BrowserBot

await BrowserBot.build(browserName, version, browserPath = null, startArgs = [], switchArgs =[]);
//参数一 字符串型，浏览器名称 "edge"、"chrome"和"ie" 参数为ie时，浏览器缩放调整到100%，internet选项-->安全-->启用保护模式 统一去除勾选
//参数二 字符串型，浏览器版本号, ie浏览器可忽略此参数
//参数三 字符串型，可选参数，浏览器路径, ie浏览器可忽略此参数
//参数四 字符串数组 型，可选参数，启动参数, ie浏览器可忽略此参数
//        无头模式：["headless"]
//        设置UA:["user-agent='UA'"]
//        设置代理:["proxy-server=127.0.0.1:888"]
//        用户数据目录:["--user-data-dir=C:\\Users\\电脑用户名\\AppData\\Local\\Google\\Chrome\\User Data"] 共享登陆账号需要设置此字段
//参数五 字符串数组 型，可选参数，控制其他开关选项, ie浏览器可忽略此参数
//返回 BrowserBot 对象

退出浏览器

await browserBot.quit();

等待超时

await browserBot.sleep(3000);
//显示等待
//参数一 整型，等待时间，单位毫秒

await browserBot.setImplicitTimeout(5000);
//隐式等待
//参数一 整型，等待时间，单位毫秒

await browserBot.wait(condition, timeout = null, message = null, pollTimeout = null);
//显性等待
//参数一 WebElementCondition类型，等待条件，一般配合 until 使用
//参数二 整型，可选参数，等待超时
//参数三 字符串型，可选参数，等待时间时使用的消息
//参数四 整型，可选参数，每隔多久检查一次

页面和导航

await browserBot.openUrl('http://www.ai-bot.net');
//参数一 字符串型，打开指定URL，http://或者 https://开头

await browserBot.to('https://www.baidu.com');
//参数一 字符串型，跳转指定url ，http://或者 https://开头

await browserBot.back();
//后退

await browserBot.forward();
//前进

await browserBot.refresh();
//刷新

await browserBot.getCurrentUrl();
//获取URL

await browserBot.getCurrenTitle();
//获取页面标题

await browserBot.getPageSource();
//获取页面源码

元素操作

await browserBot.clickElement(xpath);
//点击元素
//参数一 字符串型，元素路径
//成功返回true 失败返回false

await browserBot.sendKeys(xpath, text, key);
//发送文本
//参数一 字符串型，元素路径
//参数一 字符串型，发送的文本
//参数三 Key类型，可选参数，发送的键值。文本输入完毕后，可同回车 Key.ENTER 一起发送，默认为Key.NULL
//成功返回true 失败返回false

await browserBot.clearElement(xpath);
//清除元素值
//参数一 字符串型，元素路径
//成功返回true 失败返回false

await browserBot.submitElement(xpath);
//提交表单
//参数一 字符串型，元素路径
//成功返回true 失败返回false

await browserBot.getElementText(xpath);
//获取文本
//参数一 字符串型，元素路径
//返回元素文本内容，一般指元素innerText属性的值
//成功返回true 失败返回null

await browserBot.getElementAttribute(xpath, attributeName);
//获取属性值
//参数一 字符串型，元素路径
//参数二 字符串型，指定的属性名
//返回元素属性值，失败返回null

await browserBot.getElementRect(xpath);
//获取矩形位置
//参数一 字符串型，元素路径
//返回 {x: number, y: number, width: number, height: number}，失败返回null

await browserBot.isDisplayed(xpath);
//判断该元素是否可见
//参数一 字符串型，元素路径
//返回true 或 false

await browserBot.isEnabled(xpath);
//判断该元素是启用
//参数一 字符串型，元素路径
//返回true 或 false

await browserBot.isSelected(xpath);
//判断该元素是选中
//参数一 字符串型，元素路径
//返回true 或 false

IFrame

await browserBot.switchIframeByElement(xpath);
//通过元素路径切换iframe
//参数一 字符串型，元素路径
//成功返回true 失败返回false

await browserBot.switchIframeByIndex(index);
//通过索引切换iframe
//参数一 整型，索引

await browserBot.switchParentFrame();
//切换到父iframe

await browserBot.switchDefaultFrame();
//切换到顶层默认框架

窗口操作

await browserBot.getWindowHandle();
//获取当前窗口句柄
//返回窗口句柄

await browserBot.getAllWindowHandles();
//获取所有窗口句柄
//返回窗口句柄数组

await browserBot.switchWindow(nameOrHandle);
//切换选项卡或窗口
//参数一 字符串型， 窗口句柄 或 名称

await browserBot.switchNewWindow(typeHint = 'tab');
//创建新窗口或选项卡 并切换
//参数一 字符串型，可选参数，'tab'选项卡 'window'窗口, 默认选项卡

await browserBot.closeWindow();
//关闭当前窗口或选项卡

await browserBot.getWindowRect();
//获取窗口位置
//返回 {x: number, y: number, width: number, height: number}

await browserBot.setWindowRect(rect);
//设置窗口位置
//参数一 {x: number, y: number, width: number, height: number} 类型，窗口位置

await browserBot.getWindowSize();
//获取窗口大小
//返回 {width: number, height: number}

await browserBot.setWindowSize(size);
//设置窗口大小
//参数一 {width: number, height: number} 类型， 窗口大小

await browserBot.getWindowPos();
//获取窗口左上角位置
//返回 {x: number, y: number}

await browserBot.setWindowPos(point);
//设置窗口左上角位置
//参数一 {x: number, y: number} 类型， 左上角坐标点

await browserBot.maximize();
//最大化窗口

await browserBot.minimize();
//最小化窗口

鼠标键盘动作

await browserBot.sendKeysByAction(varArgs);
//发送文本,也可以是键值
//参数一 字符串 或 Key类型

await browserBot.leftClick(xpath);
//左键点击元素，点击之前鼠标会先移到目标位置
//参数一 字符串型，元素路径
//成功返回true 失败返回false

await browserBot.rightClick(xpath);
//右键点击元素，点击之前鼠标会先移到目标位置
//参数一 字符串型，元素路径
//成功返回true 失败返回false

await browserBot.doubleClick(xpath);
//左键双击元素，点击之前鼠标会先移到目标位置
//参数一 字符串型，元素路径
//成功返回true 失败返回false

await browserBot.dragAndDrop(fromXpath, toLocation);
//拖放元素，按下左键从参数一(元素)中间位置，移动到参数二(元素或坐标) 并释放左键
//参数一 字符串型，元素路径
//参数二 字符串或{x:number, y:number} 类型， 元素路径 或 坐标
//成功返回true 失败返回false

await browserBot.keyDown(key);
//按下指定键值
//参数一 Key类型，要按下的键值

await browserBot.keyUp(key);
//释放指定键值
//参数一 Key类型，要释放的键值

await browserBot.move(toLocation);
//移动鼠标
//参数一 字符串或{x:number, y:number} 类型，元素路径 或 坐标
//成功返回true 失败返回false

await browserBot.pause(duration);
//暂停动作
//参数一 整型，暂停的时间，单位毫秒

await browserBot.press(action);
//按下鼠标
//参数一 Button 类型，可选参数，左键Button.LEFT 中键Button.MIDDLE 右键Button.RIGHT

await browserBot.release(action);
//释放鼠标
//参数一 Button 类型，可选参数，左键Button.LEFT 中键Button.MIDDLE 右键Button.RIGHT

await browserBot.clear();
//释放所有键、指针并清除内部状态。

await browserBot.getActionObject();
//获取动作对象
//返回 Actions，动作指令可以组合使用，必须以.perform();结尾

截图

await browserBot.takeScreenshot(xpath = null, scroll = false);
//参数一 字符串型，可选参数，元素路径。 如果指定元素路径，则截取元素图片。默认截取全屏
//参数二 布尔型，可选参数，截图之前是否将元素滚动到视图中。true 滚动，false不滚动，默认不滚动， 仅适用于 元素截图
//返回字符串 base-64 编码。 PNG 格式，失败返回null

alert/prompt弹窗

await browserBot.getAlertObject();
//获取alert/prompt弹窗对象
//成功返回AlertPromise对象，失败程序报错try...catch...处理返回失败

await browserBot.acceptAlert(alertObject);
//点击确定按钮
//参数一 AlertPromise 类型，alert弹窗对象

await browserBot.dismissAlert(alertObject);
//点击取消按钮
//参数一 AlertPromise 类型，alert弹窗对象

await browserBot.sendKeysAlert(alertObject, text);
//设置弹窗(prompt)输入框内容
//参数一 AlertPromise 类型，alert弹窗对象
//参数二 字符串型，输入的文本

await browserBot.getTextAlert(alertObject);
//获取弹窗内容
//参数一 AlertPromise 类型，alert弹窗对象
//返回弹窗内容

注入JavaScript

await browserBot.executeScript(script);
//执行JavaScript 代码
//参数一 字符串 或 Function 类型，JavaScript注入代码
//返回 JavaScript代码中return 的值

await browserBot.executeAsyncScript(script);
//异步执行JavaScript 代码
//参数一 字符串 或 Function 类型，JavaScript注入代码
//返回 JavaScript代码中return 的值

cookie操作

await browserBot.getCookie(name);
//获取指定名称的cookie
//参数一 字符串 类型，指定的名称
//返回 {name: string, value: string, path?: string | undefined, domain?: string | undefined, secure?: boolean | undefined, httpOnly?: boolean | undefined, expiry?: number | undefined}

await browserBot.getCookies();
//获取所有cookie
//返回 {name: string, value: string, path?: string | undefined, domain?: string | undefined, secure?: boolean | undefined, httpOnly?: boolean | undefined, expiry?: number | undefined} 数组

await browserBot.addCookie(spec);
//添加cookie
//参数一 {name: string, value: string, path?: string | undefined, domain?: string | undefined, secure?: boolean | undefined, httpOnly?: boolean | undefined, expiry?: number|Date | undefined} 类型

await browserBot.deleteCookie(name);
//删除指定名称的cookie
//参数一 字符串型，指定的名称

await browserBot.deleteCookies();
//删除所有cookie

浏览器驱动

let bDriver = await browserBot.getBrowserDriver();
//获取浏览器驱动

关闭浏览器

await bDriver.quit();
//退出

等待超时

await bDriver.manage().setTimeouts({implicit: 5000});
//隐式等待，设置5秒

查找元素

await bDriver.findElement(locator: Locator);
//查找单个元素
//locator，查找元素的方式有
//By.className、By.css、By.id、By.linkText、By.name、By.xpath、By.partialLinkText、By.js
//成功返回元素对象，失败程序终止。封装try...catch...处理返回失败
//示例，通过By.id 查找元素
	let element = await bDriver.findElement(By.id("kw"));
//By.js 基于JavaScript的定位方式，参数可以是字符串也可以是js函数，如果是函数 ， 则返回 return 的值。无论是字符表达式还是js函数，结果必须是元素或元素列表

await bDriver.findElements(locator: Locator);
//查找元素数组

元素方法

await element.click();
//点击元素

await element.sendKeys("Aibote");
//参数一 字符串型，设置元素的值,也可以发送键值
//示例：
	await element.sendKeys("Aibote", Key.ENTER);//输入Aibote 并且回车

await element.clear();
//清除元素值

await element.submit();
//提交表单

await element.getText();
//获取innerText值

await element.getAttribute("attributeName");
//获取元素指定属性值
//参数一 字符串型，指定属性名
//成功返回对应属性的值

await element.getRect();
//获取元素矩形位置
//成功返回元素矩形位置 {height: number, width: number, x: number, y: number}

await element.isDisplayed();
//判断该元素是否可见

await element.isEnabled();
//判断该元素是启用

await element.isSelected();
//判断该元素是选中

await element.findElement(locator);
//查找此元素后代元素

await element.findElements(locator);
//查找此元素后代元素数组

IFrame

await bDriver.switchTo().frame(iframe);
//切换到指定iframe

await bDriver.switchTo().frame(1);
//通过索引号切换iframe

await bDriver.switchTo().parentFrame();
//切换到当前iframe的 父iframe

await bDriver.switchTo().defaultContent();
//切换到最顶层默认框架

鼠标键盘指令

await bDriver.actions().sendKeys("Aibote").perform();
//发送文本,也可以是键值

await bDriver.actions().click(element).perform();
//左键点击元素，点击之前鼠标先移到目标中心位置

await bDriver.actions().contextClick(element).perform();
//右键点击元素，点击之前鼠标先移到目标中心位置

await bDriver.actions().doubleClick(element).perform();
//左键双击元素，点击之前鼠标先移到目标中心位置

await bDriver.actions().dragAndDrop(element, destLocation).perform();
//按下左键从参数一(元素)中间位置，移动到参数二(元素或坐标) 并释放左键

await bDriver.actions().keyDown(Key.ENTER).perform();
//按下指定键值

await bDriver.actions().keyUp(Key.ENTER).perform();
//释放指定键值

await bDriver.actions().move(options).perform();
//移动鼠标， options 参数可以是坐标{x: 100, y:100}或者元素

await bDriver.actions().pause(3000).perform();
//暂停执行动作，等待3秒

await bDriver.actions().press(0).perform();
//在鼠标当前位置按下按钮， 左键0 中键1 右键2

await bDriver.actions().release(0).perform();
//在鼠标当前位置释放按钮， 左键0 中键1 右键2

await bDriver.actions().clear().perform();
//释放所有键、指针并清除内部状态。
//必须调用perform() 执行动作序列，以上指令可以组合使用

页面和导航

await bDriver.get('http://www.ai-bot.net/');
//打开指定URL，http://或者 https://开头

await bDriver.navigate().back();
//后退

await bDriver.navigate().forward();
//前进

await bDriver.navigate().refresh();
//刷新

await bDriver.navigate().to(url);
//跳转指定url ，http://或者 https://开头

await bDriver.getCurrentUrl();
//获取当前URL

await bDriver.getTitle();
//获取当前页面标题

await bDriver.getPageSource();
//获取当前页面源码

选项卡(含窗口)

await bDriver.getWindowHandle();
//获取当前窗口句柄，此处窗口句柄与我们WindowsBot窗口句柄不是同一个概念

await bDriver.getAllWindowHandles();
//获取所有窗口句柄
//返回窗口句柄数组，此处窗口句柄与我们WindowsBot窗口句柄不是同一个概念

await bDriver.switchTo().window(handle);
//切换到指令选项卡或窗口

await bDriver.switchTo().newWindow('tab');
//创建新选项卡并切换

await bDriver.switchTo().newWindow('window');
//创建新窗口卡并切换

await bDriver.close();
//关闭当前窗口/选项卡

窗口操作

await bDriver.manage().window().getRect();
//获取窗口大小
//成功返回{height: number, width: number, x: number, y: number}

await bDriver.manage().window().setRect({x: 0, y: 0, width:100, height:100});
//设置窗口和位置大小，可以单独指定x y或者 width, height

await bDriver.manage().window().maximize();
//最大化窗口

await bDriver.manage().window().minimize();
//最小化窗口

截图

await element.takeScreenshot(scroll = false);
//元素截图
//参数一 布尔类型，可以选参数，截图之前是否将元素滚动到视图中。默认为false。
//成功返回字符串 base-64 编码。 PNG 格式

await bDriver.takeScreenshot();
//全屏截图
//成功返回字符串 base-64 编码。 PNG 格式

警告框操作

await bDriver.wait(until.alertIsPresent());
//等待警告框显示

let alert = await bDriver.switchTo().alert();
//切换弹窗警告框
//成功返回警告框操作对象，失败程序报错try...catch...处理返回失败

await alert.accept();
//点击确定按钮

await alert.dismiss();
//点击取消按钮

await alert.sendKeys("Aibote是一款优秀的RPA框架");
//设置弹窗(prompt)输入框内容

await alert.getText();
//获取弹窗文本

注入JavaScript

await bDriver.executeScript(script);
//参数一 可以是字符串 也可以是js 函数
//如果是函数 ， 则返回 return 的值。返回值解析规则：
//HTML 元素，该值将解析为WebElement
//Null 和 undefined 返回值将解析为 null
//布尔值、数字和字符串将按原样解析
//函数将解析为它们的字符串表示
//对于数组和对象，每个成员项都会按照上面的规则进行转换
//示例：
await bDriver.executeScript(function(){return 'Aibote'}); //function
await bDriver.executeScript("alert('Aibote是一款非常优秀的RPA')");//string

await bDriver.executeAsyncScript(script);
//异步注入

cookie操作

await bDriver.manage().getCookie("name")
//获取指定name的cookie

await bDriver.manage().getCookies()
//获取所有cookie

await bDriver.manage().addCookie(spec);
//添加cookie
//代码示例：
		await bDriver.manage().addCookie({name: 'foo', value: 'bar'});
//除name、value 还有domain、expiry、httpOnly、path、secure属性

await bDriver.manage().deleteCookie("name");
//删除指定name的cookie

await bDriver.manage().deleteAllCookies()
//删除所有cookie

WindowsBot开发手册

主函数示例

const {WindowsBot} = require('WindowsBot');//引用WindowsBot模块

async function mian(){
    //WindowsDriver 服务端口，默认19999
    let windowsBot = await WindowsBot.build(19999);
    let hwnd = await windowsBot.findWindow(null, "运行");
    let words = await windowsBot.getWords(hwnd, "ocr.ai-bot.net");
    console.log(words);
}

mian();

构建WindowsBot

await WindowsBot.build(port = 19999);
//参数一 整型，服务端口，可选参数，默认19999
//返回 WindowsBot 对象

等待超时

await windowsBot.sleep(3000);
//显示等待
//参数一 整型，等待时间，单位毫秒

await windowsBot.setImplicitTimeout(waitMs, intervalMs = 5);
//隐式等待
//参数一 整型，等待时间，单位毫秒
//参数二 整型，心跳间隔，单位毫秒。可选参数，默认5毫秒

查找句柄

await windowsBot.findWindow(className, windowNmae);
//查找窗口句柄
//参数一 字符串型，窗口类名
//参数二 字符串型，窗口名
//成功返回窗口句柄，失败返回null

await windowsBot.findWindows(className, windowNmae);
//查找窗口句柄数组
//参数一 字符串型，窗口类名
//参数二 字符串型，窗口名
//成功返回窗口句柄数组，失败返回null

await windowsBot.findSubWindow(curHwnd, className, windowNmae);
//查找子窗口句柄
//参数一 字符串/整 型，当前窗口句柄
//参数二 字符串型，窗口类名
//参数三 字符串型，窗口名
//成功返回窗口句柄，失败返回null

await windowsBot.findParentWindow(curHwnd);
//查找父窗口句柄
//参数一 字符串/整 型，当前窗口句柄
//成功返回窗口句柄，失败返回null

显示/隐藏窗口

await windowsBot.showWindow(hwnd, isShow);
//参数一 字符串/整 型，窗口句柄
//参数二 布尔型，显示窗口 true， 隐藏窗口 false
//成功返回true，失败返回false

鼠标键盘

await windowsBot.moveMouse(hwnd, x, y, mode = false);
//移动鼠标
//参数一 字符串/整 型，窗口句柄
//参数二 整型，横坐标
//参数三 整型，纵坐标
//参数四 布尔型，操作模式，后台 true，前台 false。默认前台操作
//总是返回true

await windowsBot.rollMouse(hwnd, x, y, dwData, mode = false);
//滚动鼠标
//参数一 字符串/整 型，窗口句柄
//参数二 整型，横坐标
//参数三 整型，纵坐标
//参数四 整型，鼠标滚动次数,负数下滚鼠标,正数上滚鼠标
//参数五 布尔型，操作模式，后台 true，前台 false。默认前台操作
//总是返回true

await windowsBot.clickMouse(hwnd, x, y, msg, mode = false);
//鼠标点击
//参数一 字符串/整 型，窗口句柄
//参数二 整型，横坐标
//参数三 整型，纵坐标
//参数四 整型，点击类型，单击左键:1 单击右键:2 按下左键:3 弹起左键:4 按下右键:5 弹起右键:6 双击左键:7 双击右键:8
//参数五 布尔型，操作模式，后台 true，前台 false。默认前台操作
//总是返回true

await windowsBot.sendKeys(text);
//输入文本
//参数一 字符串型，输入的文本
//总是返回true

await windowsBot.sendVk(bVk, msg);
//输入虚拟键值(VK)
//参数一 整型，VK键值
//参数二 整型，输入类型，按下弹起:1 按下:2 弹起:3
//总是返回true

图色操作

await windowsBot.saveScreenshot(hwnd, savePath, options = {});
//截图保存
//参数一 字符串/整 型，窗口句柄
//参数二 字符串类型，保存图片路径。
//参数三 JSON类型，可选参数{{region:[left:number, top:number, right:number, bottom:number], threshold:[thresholdType:number, thresh:number, maxval:number]}} options 
//region截图区域 [10, 20, 100, 200], 默认 hwnd对应的窗口
//threshold二值化图片, thresholdType算法类型：
//                                            0   THRESH_BINARY算法，当前点值大于阈值thresh时，取最大值maxva，否则设置为0
//                                            1   THRESH_BINARY_INV算法，当前点值大于阈值thresh时，设置为0，否则设置为最大值maxva
//                                            2   THRESH_TOZERO算法，当前点值大于阈值thresh时，不改变，否则设置为0
//                                            3   THRESH_TOZERO_INV算法，当前点值大于阈值thresh时，设置为0，否则不改变
//                                            4   THRESH_TRUNC算法，当前点值大于阈值thresh时，设置为阈值thresh，否则不改变
//                                            5   ADAPTIVE_THRESH_MEAN_C算法，自适应阈值
//                                            6   ADAPTIVE_THRESH_GAUSSIAN_C算法，自适应阈值
//                                            thresh阈值，maxval最大值，threshold默认保存原图。thresh和maxval同为255时灰度处理
//成功返回false，失败返回true

await windowsBot.getColor(hwnd, x, y);
//获取指定坐标点的色值
//参数一 字符串/整 型，窗口句柄
//参数二 整型，横坐标
//参数三 整型，纵坐标
//成功返回#开头的颜色值，失败返回null

await windowsBot.findImage(hwnd, imagePath, options = {});
//找图
//参数一 字符串/整 型，窗口句柄
//参数二 字符串，小图片路径
//参数三 JSON类型，可选参数，{{region:[left:number, top:number, right:number, bottom:number], sim:number, threshold:[thresholdType:number, thresh:number, maxval:number]}} options
//region 指定区域找图 [10, 20, 100, 200]，region默认 hwnd对应的窗口
//sim浮点型 图片相似度 0.0-1.0，sim默认0.95
//threshold二值化图片, thresholdType算法类型：
//                                            0   THRESH_BINARY算法，当前点值大于阈值thresh时，取最大值maxva，否则设置为0
//                                            1   THRESH_BINARY_INV算法，当前点值大于阈值thresh时，设置为0，否则设置为最大值maxva
//                                            2   THRESH_TOZERO算法，当前点值大于阈值thresh时，不改变，否则设置为0
//                                            3   THRESH_TOZERO_INV算法，当前点值大于阈值thresh时，设置为0，否则不改变
//                                            4   THRESH_TRUNC算法，当前点值大于阈值thresh时，设置为阈值thresh，否则不改变
//                                            5   ADAPTIVE_THRESH_MEAN_C算法，自适应阈值
//                                            6   ADAPTIVE_THRESH_GAUSSIAN_C算法，自适应阈值
//                                            thresh阈值，maxval最大值，threshold默认保存原图。thresh和maxval同为255时灰度处理
//multi 找图数量，默认为1,找单个图片坐标
//成功返回，单个坐标点 [{x:number, y:number}]，多坐标点图[{x1:number, y1:number}, {x2:number, y2:number}...] 失败返回null

await windowsBot.findAnimation(hwnd, frameRate, options = {});
//找动态图
//参数一 字符串/整 型，窗口句柄
//参数二 整型，前后两张图相隔的时间，单位毫秒
//参数三 JSON类型，可选参数，{{region:[left:number, top:number, right:number, bottom:number]}} options
//region 指定区域找图 [10, 20, 100, 200]，region默认 hwnd对应的窗口
//成功返回，单个坐标点 [{x:number, y:number}]，多坐标点图[{x1:number, y1:number}, {x2:number, y2:number}...] 失败返回null

await windowsBot.findColor(hwnd, mainColor, options = {});
//查找指定色值的坐标点
//参数一 字符串/整 型，窗口句柄
//参数二 字符串，#开头的色值
//参数三 JSON类型，可选参数，{{subColors:[[offsetX:number, offsetY:number, strSubColor:string], ...], region:[left:number, top:number, right:number, bottom:numbe], sim:number}} options
//subColors 相对于mainColor 的子色值，[[offsetX, offsetY, "#FFFFFF"], ...]，subColors默认为null
//region 指定区域找图 [10, 20, 100, 200]，region默认 hwnd对应的窗口
//sim相似度0.0-1.0，sim默认为1
//成功返回{x:number, y:number} 失败返回null

await windowsBot.compareColor(hwnd, mainX, mainY, mainColor, options = {});
//比较指定坐标点的颜色值
//参数一 字符串/整 型，窗口句柄
//参数二 整型，主颜色所在的X坐标
//参数三 整型，主颜色所在的Y坐标
//参数四 字符串，#开头的色值
//参数五 JSON类型，可选参数，{{subColors:[[offsetX:number, offsetY:number, strSubColor:string], ...], region:[left:number, top:number, right:number, bottom:number], sim:number}} options
//subColors 相对于mainColor 的子色值，[[offsetX, offsetY, "#FFFFFF"], ...]，subColors默认为null
//region 指定区域找图 [10, 20, 100, 200]，region默认 hwnd对应的窗口
//sim相似度0.0-1.0，sim默认为1
//成功返回true 失败返回 false

OCR系统

await windowsBot.findWords(hwnd, ocrServer, words, options = {})
//找字
//参数一 字符串/整 型，窗口句柄
//参数二 字符串类型，ocr服务地址 ocr.ai-bot.net
//参数三 字符串类型，要查找的文字
//参数四 JSON类型，可选参数 {region:[left:number, top:number, right:number, bottom:number], scale:number}} options
//region 指定区域 [10, 20, 100, 200]，region默认 hwnd对应的窗口
//scale浮点型 图片缩放率, 默认为 1.0 原大小。大于1.0放大，小于1.0缩小，不能为负数。仅在区域识别有效
//成功功返回数组[{x:number, y:number}, ...]，文字所在的坐标点， 失败返回null

await windowsBot.getWords(hwnd, ocrServer, options = {})
//获取屏幕文字
//参数一 字符串/整 型，窗口句柄
//参数二 字符串类型，ocr服务地址 ocr.ai-bot.net
//参数三 JSON类型，可选参数 {region:[left:number, top:number, right:number, bottom:number], scale:number}} options
//region 指定区域 [10, 20, 100, 200]，region默认 hwnd对应的窗口
//scale浮点型 图片缩放率, 默认为 1.0 原大小。大于1.0放大，小于1.0缩小，不能为负数。仅在区域识别有效
//成功返回手机上的文字, 失败返回null

元素操作

await windowsBot.getElementName(hwnd, xpath);
//获取元素名称
//参数一 字符串/整 型，窗口句柄
//参数二 字符串型，元素路径
//成功返回元素名称，失败返回null

await windowsBot.getElementValue(hwnd, xpath);
//获取元素文本
//参数一 字符串/整 型，窗口句柄
//参数二 字符串型，元素路径
//成功返回元素文本，失败返回null

await windowsBot.getElementRect(hwnd, xpath);
//获取元素矩形大小
//参数一 字符串/整 型，窗口句柄
//参数二 字符串型，元素路径
//成功返回{left:number, top:number, right:number, bottom:number}，失败返回null

await windowsBot.getElementWindow(hwnd, xpath);
//获取元素窗口句柄
//参数一 字符串/整 型，窗口句柄
//参数二 字符串型，元素路径
//成功返回窗口句柄，失败返回null

await windowsBot.clickElement(hwnd, xpath, msg);
//点击元素
//参数一 字符串/整 型，窗口句柄
//参数二 字符串型，元素路径
//参数三 整型，点击类型，单击左键:1 单击右键:2 按下左键:3 弹起左键:4 按下右键:5 弹起右键:6 双击左键:7 双击右键:8
//成功返回true 失败返回 false

await windowsBot.setElementFocus(hwnd, xpath);
//设置元素作为焦点
//参数一 字符串/整 型，窗口句柄
//参数二 字符串型，元素路径
//成功返回true 失败返回 false

await windowsBot.setElementValue(hwnd, xpath, value);
//设置元素文本
//参数一 字符串/整 型，窗口句柄
//参数二 字符串型，元素路径
//参数三 字符串型，要设置的内容
//成功返回true 失败返回 false

await windowsBot.setElementScroll(hwnd, xpath, horizontalPercent, verticalPercent);
//滚动元素
//参数一 字符串/整 型，窗口句柄
//参数二 字符串型，元素路径
//参数三 整型，水平百分比 -1不滚动
//参数四 整型，垂直百分比 -1不滚动
//成功返回true 失败返回 false

await windowsBot.closeWindow(hwnd, xpath);
//关闭窗口
//参数一 字符串/整 型，窗口句柄
//参数二 字符串型，元素路径
//成功返回true 失败返回 false

await windowsBot.setWindowState(hwnd, xpath, state);
//设置窗口状态
//参数一 字符串/整 型，窗口句柄
//参数二 字符串型，元素路径
//参数三 整型，0正常 1最大化 2 最小化
//成功返回true 失败返回 false

系统剪切板

await windowsBot.setClipboardText(text);
//设置剪切板内容
//参数一 字符串型，设置的文本
//成功返回true 失败返回 false

await windowsBot.getClipboardText();
//获取剪切板内容
//返回剪切板文本

启动进程

await windowsBot.startProcess(commandLine, showWindow = true, isWait = false);
//参数一 字符串型，启动命令行
//参数二 布尔型，是否显示窗口。可选参数,默认显示窗口
//参数三 布尔型，是否等待程序结束。可选参数,默认不等待
//成功返回true,失败返回false

指定url下载文件

await windowsBot.downloadFile(url, filePath, isWait);
//参数一 字符串型，文件地址
//参数二 字符串型，文件保存的路径
//参数三 布尔型，是否等待.为true时,等待下载完成
//总是返回true

Excel文档

await windowsBot.openExcel(excelPath);
//打开excel文档
//参数一 字符串，excle路径
//成功返回excel对象，失败返回null

await windowsBot.openExcelSheet(excelObject, sheetName);
//打开excel表格
//参数一 对象，excel对象
//参数二 字符串，表名
//成功返回sheet对象，失败返回null

await windowsBot.saveExcel(excelObject);
//保存excel文档
//参数一 对象，excel对象
//成功返回true，失败返回false

await windowsBot.writeExcelNum(sheetObject, row, col, value);
//写入数字到excel表格
//参数一 对象，sheet对象
//参数二 整型，行
//参数三 整型，列
//参数四 数字型，写入的值
//成功返回true，失败返回false

await windowsBot.writeExcelStr(sheetObject, row, col, strValue);
//写入字串到excel表格
//参数一 对象，sheet对象
//参数二 整型，行
//参数三 整型，列
//参数四 字符串，写入的值
//成功返回true，失败返回false

await windowsBot.readExcelNum(sheetObject, row, col);
//读取excel表格数字
//参数一 对象，sheet对象
//参数二 整型，行
//参数三 整型，列
//返回读取到的数字

await windowsBot.readExcelStr(sheetObject, row, col);
//读取excel表格字串
//参数一 对象，sheet对象
//参数二 整型，行
//参数三 整型，列
//返回读取到的字符

验证码系统

await windowsBot.getCaptcha(filePath, username, password, softId, codeType, lenMin = 0);
//识别验证码
//参数一 字符串类型，图片文件路径
//参数二 字符串类型，用户名
//参数三 字符串类型，密码
//参数四 字符串类型，软件ID
//参数四 字符串类型，图片类型 参考https://www.chaojiying.com/price.html
//参数五 字符串类型，最小位数 默认0为不启用,图片类型为可变位长时可启用这个参数
//返回JSON类型{{err_no:number, err_str:string, pic_id:string, pic_str:string, md5:string}}
//err_no,(数值) 返回代码  为0 表示正常，错误代码 参考https://www.chaojiying.com/api-23.html
//err_str,(字符串) 中文描述的返回信息 
//pic_id,(字符串) 图片标识号，或图片id号
//pic_str,(字符串) 识别出的结果
//md5,(字符串) md5校验值,用来校验此条数据返回是否真实有效

await windowsBot.errorCaptcha(username, password, softId, picId);
//识别报错返分
//参数一 字符串类型，用户名
//参数二 字符串类型，密码
//参数三 字符串类型，软件ID
//参数四 字符串类型，图片ID 对应 getCaptcha返回值的pic_id 字段
//返回JSON类型{{err_no:number, err_str:string}}
//err_no,(数值) 返回代码
//err_str,(字符串) 中文描述的返回信息

await windowsBot.scoreCaptcha(username, password);
//查询验证码剩余题分
//参数一 字符串类型，用户名
//参数二 字符串类型，密码
//返回JSON类型{{err_no:number, err_str:string, tifen:string, tifen_lock:string}}
//err_no,(数值) 返回代码
//err_str,(字符串) 中文描述的返回信息
//tifen,(数值) 题分
//tifen_lock,(数值) 锁定题分

WindowsBot开源协议

Aibote Windows自动化框架，由node.js客户端连接 WindowsDriver.exe服务端程序，采用TCP协议传输命令。
全国领先xpath元素定位算法，一键拾取控件元素、图色 坐标等属性。与安卓端代码统一书写格式，降低用户学习成本。
独家图色定位算法，50毫秒以内的速度遍历查找1920*1080分辨率的设备。为了让更多人体验到我们产品，
我们决议在此公布框架协议，希望有更多开发者能完善并封装成各种计算机语言。

发送命令协议格式：len/len/len...\ndata
//len：函数名和参数的(字符串)长度，统一为十进制 字符串类型
//data：函数名和参数数据 类型为 字符串或字节类型(string/byte) 

接收命令协议格式：len/data
//len：返回数据包的(字符串)长度
//data：返回的数据，类型为字符串或字节类型(string/byte) 

协议示例：
//查找句柄
sendData("findWindow", "className", "windowNmae");
// 参数一：函数名称
// 参数二：窗口类名
// 参数三：窗口名
发送数据包：10/9/10\nfindWindowclassNamewindowNmae
返回数据包：成功"65862"，失败 "null"

//查找句柄数组
sendData("findWindows", "className", "windowNmae");
// 参数一：函数名称
// 参数二：窗口类名
// 参数三：窗口名
发送数据包：11/9/10\nfindWindowsclassNamewindowNmae
返回数据包：成功返回多个句柄"65862|65863|65864"，失败 "null"

//查找子句柄
sendData("findSubWindow", 65862, "className", "windowNmae");
// 参数一：函数名称
// 参数二：当前窗口句柄
// 参数三：窗口类名
// 参数四：窗口名
发送数据包：13/5/9/10\nfindSubWindow65862classNamewindowNmae
返回数据包：成功"460538"，失败 "null"

//查找父句柄
sendData("findParentWindow", 460538);
// 参数一：函数名称
// 参数二：当前窗口句柄
发送数据包：16/6/\nfindParentWindow460538
返回数据包：成功"65862"，失败 "null"

//显示/隐藏窗口
sendData("showWindow", 65862, true);
// 参数一：函数名称
// 参数二：窗口句柄
// 参数三：显示窗口 true， 隐藏窗口 false
发送数据包：10/5/4\nshowWindow65862true
返回数据包："false"或者 "true"

//移动鼠标
sendData("moveMouse", 65862, 100, 100, false);
// 参数一：函数名称
// 参数二：窗口句柄
// 参数三：x坐标
// 参数四：y坐标
// 参数五：操作模式
发送数据包：9/5/3/3/5\nmoveMouse65862100100false
返回数据包："true"

//滚动鼠标
sendData("rollMouse", 65862, 100, 100, 10, false);
// 参数一：函数名称
// 参数二：窗口句柄
// 参数三：x坐标
// 参数四：y坐标
// 参数五：鼠标滚动次数,负数下滚鼠标,正数上滚鼠标
// 参数六：操作模式
发送数据包：9/5/3/3/2/5\nrollMouse658621001002false
返回数据包："true"

//点击鼠标
sendData("clickMouse", 65862, 100, 100, 1, false);
// 参数一：函数名称
// 参数二：窗口句柄
// 参数三：x坐标
// 参数四：y坐标
// 参数五：点击类型，单击左键:1 单击右键:2 按下左键:3 弹起左键:4 按下右键:5 弹起右键:6 双击左键:7 双击右键:8
// 参数六：操作模式
发送数据包：9/5/3/3/1/5\nclickMouse658621001001false
返回数据包："true"

//发送文本
sendData("sendKeys", "rpa");
// 参数一：函数名称
// 参数二：输入的文本
发送数据包：8/3\nsendKeysrpa
返回数据包："true"

//输入虚拟键值(VK)
sendData("sendVk", 13, 1);
// 参数一：函数名称
// 参数二：虚拟键值 回车对应 VK键值 13
// 参数三：输入类型，按下弹起:1 按下:2 弹起:3
发送数据包：6/2/1\nsendVk131
返回数据包："true"

//截图保存
sendData("saveScreenshot", 65862, "d:/1.png", 80, 150, 30, 30, 0, 127, 255);
// 参数一：函数名称
// 参数二：窗口句柄
// 参数三：保存的图片路径（手机）
// 参数四：矩形左上角x坐标
// 参数五：矩形左上角y坐标
// 参数六：矩形右下角x坐标
// 参数七：矩形右下角y坐标
// 参数八：二值化算法类型
// 参数九：二值化阈值
// 参数十：二值化最大值
发送数据包：14/5/8/2/3/2/2/1/3/3\nsaveScreenshot65862d:/1.png8015030300127255
返回数据包："false"或者 "true"

//获取色值
sendData("getColor", 65862, 100, 200);
// 参数一：函数名称
// 参数二：窗口句柄
// 参数三：x坐标
// 参数四：y坐标
数据包：8/5/3/3\ngetColor65862100200
返回数据包："false"或者 "true"

//找图
sendData("findImage", 65862, "d:/1.png", 0, 0, 0, 0, 0.95, 0, 0, 1);
// 参数一：函数名称
// 参数二：窗口句柄
// 参数三：保存的图片路径（手机）
// 参数四：矩形左上角x坐标
// 参数五：矩形左上角y坐标
// 参数六：矩形右下角x坐标
// 参数七：矩形右下角y坐标
// 参数八：相似度
// 参数九：二值化阈值
// 参数十：二值化最大值
// 参数十一：多个坐标点
数据包：9/5/8/1/1/1/1/4/1/1/1\nfindImage65862d:/1.png00000.95001
返回数据包：单坐标点成功"x|y"  多坐标点成功 "x1|y1/x2|y2..."  失败"-1.0|-1.0"

//找动态图
sendData("findAnimation", 65862, 100, 0, 0, 0, 0);
// 参数一：函数名称
// 参数二：窗口句柄
// 参数三：前后两张图相隔的时间，单位毫秒
// 参数四：矩形左上角x坐标
// 参数五：矩形左上角y坐标
// 参数六：矩形右下角x坐标
// 参数七：矩形右下角y坐标
数据包：13/5/3/0/0/0/0\nfindAnimation658621000000
返回数据包：单坐标点成功"x|y"  多坐标点成功 "x1|y1/x2|y2..."  失败"-1.0|-1.0"

//找色
sendData("findColor", 65862, "#e8f2f8", "1020#e7f0f7", 0, 0, 0, 0, 1);
// 参数一：函数名称
// 参数二：窗口句柄
// 参数三：主颜色值
// 参数四：相对偏移的颜色点，以 "x坐标+y坐标+色值" 字符串形式
// 参数五：矩形左上角x坐标
// 参数六：矩形左上角y坐标
// 参数七：矩形右下角x坐标
// 参数八：矩形右下角y坐标
// 参数九：相似度
数据包：9/5/7/11/1/1/1/1/1\nfindColor65862#e8f2f81020#e7f0f700001
返回数据包：成功"x|y" 失败"-1.0|-1.0"

//比色
sendData("compareColor", 65862, 100, 200, "#e8f2f8", "1020#e7f0f7", 0, 0, 0, 0, 1);
// 参数一：函数名称
// 参数二：窗口句柄
// 参数三：主颜色值所在的X坐标
// 参数四：主颜色值所在的Y坐标
// 参数五：主颜色值
// 参数六：相对偏移的颜色点，以 "x坐标+y坐标+色值" 字符串形式
// 参数七：矩形左上角x坐标
// 参数八：矩形左上角y坐标
// 参数九：矩形右下角x坐标
// 参数十：矩形右下角y坐标
// 参数十一：相似度
数据包：12/5/3/3/7/11/1/1/1/1/1\ncompareColor65862100200#e8f2f81020#e7f0f700001
返回数据包："false"或者 "true"

//ocr
sendData("ocr", 65862, "127.0.0.1", 0, 0, 0, 0, 1.0);
数据包：3/5/9/1/1/1/1\3\nocr65862127.0.0.100001.0
返回数据包：[[[7.0, 18.0], [61.0, 18.0], [61.0, 38.0], [7.0, 38.0]], ('办公自动化', 0.8806074261665344)][[[4.0, 94.0], [49.0, 94.0], [49.0, 118.0], [4.0, 118.0]], ('rpa', 0.978314220905304)]

//获取指定元素名称
sendData("getElementName", 65862, "Window/Text");
数据包：14/5/11\ngetElementName65862Window/Text
返回数据包："aibote is pure code RPA"

//获取指定元素文本
sendData("getElementValue", 65862, "Window/Edit");
数据包：15/5/11\ngetElementValue65862Window/Edit
返回数据包："aibote RPA"

//获取指定元素矩形大小
sendData("getElementRect", 65862, "Window/Button");
数据包：14/5/13\ngetElementRect65862Window/Button
返回数据包："239|628|989|764"

//获取指定元素窗口句柄
sendData("getElementWindow", 65862, "Window/Button");
数据包：16/5/13\ngetElementWindow65862Window/Button
返回数据包："460538"

//点击元素
sendData("clickElement", 65862, "Window/Button", 1);
数据包：12/5/13/1\nclickElement65862Window/Button1
返回数据包："false"或者 "true"

//设置指定元素作为焦点
sendData("setElementFocus", 65862, "Window/Button");
数据包：15/5/13\nsetElementFocus65862Window/Button
返回数据包："false"或者 "true"

//设置元素文本
sendData("setElementValue", 65862, "Window/Button", "rpa");
数据包：15/5/13/3\nsetElementValue65862Window/Buttonrpa
返回数据包："false"或者 "true"

//滚动元素
sendData("setElementScroll", 65862, "Window", -1, 0.1);
数据包：16/5/6/2/3\nsetElementScroll65862Window-10.1
返回数据包："false"或者 "true"

//关闭窗口
sendData("closeWindow", 65862, "Window");
数据包：11/5/6\ncloseWindow65862Window
返回数据包："false"或者 "true"

//设置窗口状态
sendData("setWindowState", 65862, "Window", 2);
数据包：14/5/6/1\nsetWindowState65862Window2 
返回数据包："false"或者 "true"

//设置剪切板文本
sendData("setClipboardText", "rpa");
数据包：16/3\nsetClipboardTextrpa
返回数据包："false"或者 "true"

//获取剪切板文本
sendData("getClipboardText");
数据包：16\ngetClipboardText
返回数据包："rpa"

//启动指定程序
sendData("startProcess", "cmd", true, false);
数据包：12/3/4/5\nstartProcesscmdtruefalse
返回数据包："false"或者 "true"

//指定url下载文件
sendData("downloadFile", "http://www.gogo.com/rpa.rar", "d:/rpa.rar", true);
数据包：12/27/10/4\ndownloadFilehttp://www.gogo.com/rpa.rard:/rpa.rartrue
返回数据包："true"

//打开excle
sendData("openExcel", "D:/rpa.xlsx");
数据包：9/11\nopenExcelD:/rpa.xlsx
返回数据包："null"或者 {"book":"088173SDFU13","path":"D:/rpa.xlsx"}

//打开excel表格
sendData("openExcelSheet", "088173SDFU13", "D:/rpa.xlsx", "sheet1");
数据包：14/12/11/6\nopenExcelSheet088173SDFU13D:/rpa.xlsxsheet1
返回数据包："null"或者 "A123HHI123F132"

//保存excel
sendData("saveExcel", "088173SDFU13", "D:/rpa.xlsx");
数据包：9/12/11\nsaveExcel088173SDFU13D:/rpa.xlsx
返回数据包："false"或者 "true"

//写入数字到表格
sendData("writeExcelNum", "A123HHI123F132", 0, 0, 123);
数据包：13/14/1/1/3\nwriteExcelNumA123HHI123F13200123
返回数据包："false"或者 "true"

//写入字符串到表格
sendData("writeExcelStr", "A123HHI123F132", 0, 0, "rpa");
数据包：13/14/1/1/3\nwriteExcelStrA123HHI123F13200rpa
返回数据包："false"或者 "true"

//读取excel表格数字
sendData("readExcelNum", "A123HHI123F132", 0, 0);
数据包：12/14/1/1\nreadExcelNumA123HHI123F13200
返回数据包：123

//读取excel表格字串
sendData("readExcelStr", "A123HHI123F132", 0, 0);
数据包：12/14/1/1\nreadExcelStrA123HHI123F13200
返回数据包："rpa"

界面开发手册

AiboteScriptUI底层基于chromium内核，可使用html、ccs等语言开发界面。另外我们底层添加四个函数用于实现脚本执行和传参。
启动AiboteScriptUI.exe程序会自动附加当前目录下index.html文件，界面开发工作主要在这个文件

界面宽高

SetAiboteSize(width, height);
//AiboteScriptUI 宽高 由document.body.offsetHeight 和 document.body.offsetWidth决定
//此函数脚本作者不可见，内部自动执行。脚本作者需要设定页面 body 宽高

启动脚本

StartScript("../testAibote.js", true);
//参数一 字符串型。要启动脚本的路径，空格分隔脚本参数。 脚本可通过 let args = process.argv.splice(2); 接收参数
//参数二 布尔类型。是否显示控制台日志，true 显示控制台日志
//返回值 脚本进程ID

停止脚本

StopScript(processId);
//参数一 数字型。脚本进程ID
//成功返回true 失败返回false

输出日志

PrintAiboteLog();
//当StartScript第二个参数为 false 时有效，可以使用 setInterval 循环输出，输出10000字节时，会自动清空内容
//返回脚本输出内容

拾取元素工具

Android 工具位置，Aibote/Aibote.exe->菜单项->脚本工具
Windows 工具位置，Aibote/WindowsTool.exe

Android 元素拾取工具，需要在手机端，勾选连接工具端选项

Windows 元素拾取工具，按下CTRL键，暂停拾取。如拾取菜单项崩溃，可以先拾取窗口最大化最小框再去操作菜单项

使用方法：
1、点击按钮 单击手机投屏/windows 窗口，拾取元素和颜色信息。

2、点击按钮 在手机投屏/windows 窗口滑动矩形大小，拾取元素和图片信息。截图前输入图片名称。Android端，图片保存在手机/storage/emulated/0/Android/data/com.aibot.client/files/
（根目录：/storage/emulated/0/）。Windows端，图片保存在指定路径目录，如果图片名称不包含路径，则默认保存在Aibote/Picture/windows

3、二值化阈值和最大值在0-255之间，阈值和最大值都为255时灰度化处理

4、BINARY算法，当前点值大于阈值thresh时，取最大值maxva，否则设置为0

5、BINARY_INV算法，当前点值大于阈值thresh时，设置为0，否则设置为最大值maxva

6、TOZERO算法，当前点值大于阈值thresh时，不改变，否则设置为0

7、TOZERO_INV算法，当前点值大于阈值thresh时，设置为0，否则不改变

8、TRUNC算法，当前点值大于阈值thresh时，设置为阈值thresh，否则不改变

9、ADAPTIVE_THRESH_MEAN_C算法，自适应阈值

10、ADAPTIVE_THRESH_GAUSSIAN_C算法，自适应阈值