1 前言
在 Android自动化测试框架uiautomator2详解 中，介绍了 uiautomator2 框架的环境配置、元素定位工具以及常用接口。
本文对 uiautomator2 框架进一步封装，用户只需要重写模板类（Template）的 first() 和 circle_body() 方法，并配置 app.cfg 文件，即可实现各种测试挂机需求。
本文使用到的主要 python 模块如下：
- uiautomator2：Android 手机 UI 自动化控制器
- aircv：图片匹配
- configparser：配置文件解析器
- subprocess：子进程管理，本文主要用于获取 adb 命令的返回结果（check_output方法）
- os：系统管理，本文主要用于创建目录（mkdir 方法）、文件路径管理（path）和执行 adb 命令（system 方法）
2 项目结构
- phone.py：封装了对手机的操作，包括：连接设备、获取手机信息（分辨率、虚拟 display id）、解锁、打开应用、点击、长按、输入文本、滑动、截手机屏、截虚拟屏、旋转、点击匹配的图片等动作
- template.py：封装了一个测试模板，用户的只需要继承 Template 类，并重写 first 方法(初始状态)、circle_body 方法（循环体），即可实现各种复杂的挂机任务
- matcher：图片匹配器，在当前手机界面匹配目标图片，并返回匹配到的中心位置
- app.cfg：应用包名和控件标识（resourceId、text 等）配置
- parser：应用配置解析器，用于解析 app.cfg 文件
- img：存放用户截图
- log：存放日志
- test.py：用户挂机任务类，此类继承了 Template 类
项目路径见→Android 自动化测试项目
3 安装环境
install.py
import os
# https://pypi.douban.com/simple # 豆瓣镜像
# https://pypi.tuna.tsinghua.edu.cn/simple # 清华镜像
mirror = " -i https://pypi.douban.com/simple"
os.system("python -m pip install --upgrade pip" + mirror) # 更新 pip
os.system("pip install --pre -U uiautomator2" + mirror) # 安装 uiautomator2
os.system("python -m uiautomator2 init") # 安装 atx-agent 至手机
os.system("pip install weditor" + mirror) # 安装 weditor
os.system("pip install aircv" + mirror) # 安装 aircv
os.system("pip install opencv-python" + mirror) # 安装 cv2
运行此文件，即可安装所需的模块。 若运行时报错，可以参考→Android自动化测试框架uiautomator2详解
4 自动化测试
1）手机类（Phone）
Phone 类封装了对手机的操作，包括：连接设备、解锁、打开应用、点击、长按、输入文本、滑动、截屏、旋转等动作。
phone.py
import os
import re
import shutil
import subprocess as sp
import threading
import time
from time import sleep
import uiautomator2 as u2
from base.parser import Parser
from base.matcher import Matcher
# 手机类（封装了对手机的操作）
class Phone:
# 初始化（connect：连接类型，wait_time：操作之间的等待时间, clear：是否清空 img 和 log 目录）
def __init__(self, connect_type="usb", wait_time=1, clear=False):
print("Phone 初始化...")
global d, w_time, parser, matcher, screen_shot_path, log_path
d = self.get_device(connect_type)
self.get_phone_model()
self.get_phone_size()
self.get_vs_display_id()
w_time = wait_time
parser = Parser(d, self.size)
matcher = Matcher()
screen_shot_path = os.path.abspath(os.path.abspath(os.path.dirname(__file__)) + "\\..\\img") + "\\"
log_path = os.path.abspath(os.path.abspath(os.path.dirname(__file__)) + "\\..\\log") + "\\"
self.clear_img_log(clear)
# 获取设备（connect_type：连接类型）
def get_device(self, connect_type="usb"):
print("获取设备...")
if connect_type == "usb":
device = self.connect_by_usb() # 通过 usb 连接设备
elif connect_type == "wifi":
device = self.connect_by_wifi() # 通过 wifi 连接设备
return device
# 通过 usb 连接设备（程序运行期间需要保持有线连接）
def connect_by_usb(self):
rst = sp.check_output('adb devices')
id = re.findall("[A-Z0-9]{16}", str(rst))[0]
print("通过 usb 连接设备，id：", id)
device = u2.connect_usb(id)
return device
# 通过 wifi 连接设备（程序启动时需要有线连接，运行后可以断开数据线）
def connect_by_wifi(self):
rst = sp.check_output('adb shell \"ip addr | grep global\"')
ip = re.findall("\d+.\d+.\d+.\d+", str(rst))[0]
print("通过 wifi 连接设备，ip：", ip)
try:
device = u2.connect(ip)
except:
device = u2.connect(ip + ":5555")
return device
# 获取手机型号
def get_phone_model(self):
rst = sp.check_output('adb shell getprop ro.product.model')
self.model = re.findall("\w+-\w+", str(rst))[0]
print("手机型号：", self.model)
# 获取手机分辨率
def get_phone_size(self):
rst = sp.check_output('adb shell wm size')
str_size = re.findall("\d+", str(rst))
x = eval(str_size[0])
y = eval(str_size[1])
self.size = (x, y)
print("手机分辨率：", self.size)
# 获取 visual display id
def get_vs_display_id(self):
rst = sp.check_output('adb shell dumpsys activity activities')
displays = re.findall("Display #\d+", str(rst))
vs_id = -1
for e in displays:
id = eval(re.findall("\d+", e)[0])
if id > 0:
vs_id = id
break
self.vs_display_id = vs_id
print("visual display id：", self.vs_display_id)
# 解锁（password：解锁密码）
def unlock(self, password=""):
print("解锁...")
d.screen_on() # 亮屏
sleep(2)
self.swipe("up") # 向上滑动
edt_password = parser.get_element("system", "edt_password")
sleep(1)
if edt_password.exists:
if not password == "":
for i in password:
key = parser.get_element_item_num("system", "key", i)
sleep(0.1)
if key.exists:
key.click()
sleep(0.3)
sleep(w_time)
# 锁屏
def lock(self):
print("锁屏...")
d.screen_off() # 息屏
# d.press("power") # 按电源键
sleep(w_time)
# 打开指定应用（app_name：应用名）
def start_app(self, app_name):
print("打开应用，app_name：", app_name, "...")
package_name = parser.get_package(app_name)
sleep(1)
d.app_start(package_name)
sleep(w_time)
# 关闭指定应用（app_name：应用名）
def stop_app(self, app_name):
print("关闭应用，app_name：", app_name, "...")
package_name = parser.get_package(app_name)
sleep(1)
d.app_stop(package_name)
sleep(w_time)
# 关闭所有应用
def stop_all_app(self):
print("关闭所有应用...")
d.app_stop_all()
sleep(w_time)
# 清除所有应用
def clear_all_app(self):
print("清除所有应用...")
d.press("recent")
sleep(w_time)
btn_clear = parser.get_element("launcher", "btn_clear")
sleep(1)
if btn_clear.exists: # 清除按钮存在
btn_clear.click() # 清除所有 app
else: # 清除按钮不存在
print("没有打开的应用")
d.press("home") # 返回桌面
sleep(w_time)
# 截手机屏（clear：是否清空 img 目录）
def screen_shot(self, clear=False):
print("截手机屏...")
time_str = time.strftime('%Y-%m-%d_%H-%M-%S', time.localtime()) # 获取当前时间
path = screen_shot_path + time_str + ".png"
d.screenshot(path)
sleep(w_time)
# 截虚拟屏（clear：是否清空 img 目录）
def screen_shot_vs(self, clear=False):
if self.vs_display_id > 0:
print("截虚拟屏...")
time_str = time.strftime('%Y-%m-%d_%H-%M-%S', time.localtime()) # 获取当前时间
path = screen_shot_path + time_str + "_vs.png"
os.system("adb shell screencap -d " + str(self.vs_display_id) + " -p /sdcard/1.png")
os.system("adb pull /sdcard/1.png " + path)
sleep(w_time)
else:
print("虚拟屏不存在")
# 转屏
def rotate(self):
orientation = d.orientation
print("转屏，当前方向：", orientation)
if orientation == "natural":
d.set_orientation("left") # 向左转为横屏（left 可以简写为 l）
elif orientation == "left":
d.set_orientation("natural") # 转为竖屏（nutural 可以简写为 n）
sleep(w_time)
# 按键 key = {"back", "home", "recent", "power", "volume_up", "volume_down", "volume_mute", "enter",...}
def press(self, key):
print("按键：" + key)
d.press(key)
sleep(w_time)
# 单击控件(app_name：应用名，item：控件名，index：同名控件中的编号，type：控件标识符的类型)
def click(self, app_name, item, index=0, type="id"):
print("单击控件，app_name：", app_name, "，item：", item, "，index：", index, "，type：", type)
element = parser.get_element(app_name, item, type)
sleep(1)
if element[index].exists:
element[index].click()
sleep(w_time)
# 通过坐标单击控件(app_name：应用名，item：控件名，relative：相对坐标)
def click_coord(self, app_name, item, relative="left_top"):
print("通过坐标单击控件，app_name：", app_name, "，item：", item, "，relative：", relative)
x, y = parser.get_coord(app_name, item, relative)
sleep(1)
d.click(x, y)
sleep(w_time)
# 通过图标单击控件（target: 目标图片, threshold: 可信阈值）
def click_icon(self, target, threshold = 0.6):
print("通过图标单击控件，target：", target, "，threshold：", threshold)
pos = matcher.get_coord(target, threshold)
if pos == None:
print("控件不存在")
else:
sleep(1)
d.click(pos[0], pos[1])
sleep(w_time)
# 长按控件(app_name：应用名，item：控件名，index：同名控件中的编号，type：控件标识符的类型)
def long_click(self, app_name, item, index=0, type="id"):
print("长按控件，app_name：", app_name, "，item：", item + "，index：", index, "，type：", type)
element = parser.get_element(app_name, item, type)
sleep(1)
if element.exists:
element[index].long_click()
sleep(w_time)
# 输入文本(text：待输入的文本)
def set_text(self, text):
print("输入文本，text：", text)
d.set_fastinput_ime(True) # 打开输入法
d.send_keys(text)
d.set_fastinput_ime(False) # 关闭输入法
sleep(w_time)
# 输入文本(app_name：应用名，item：控件名，text：待输入的文本，type：控件标识符的类型)
def set_text(self, app_name, item, text, type="id"):
print("输入文本，app_name：", app_name, "，item：", item, "，text：", text, "，type：", type)
element = parser.get_element(app_name, item, type)
sleep(1)
if element.exists:
element.set_text(text)
sleep(w_time)
# 获取文本(app_name：应用名，item：控件名，type：控件标识符的类型)
def get_text(self, app_name, item, type):
print("获取文本，app_name：", app_name, "，item：", item, "，type：", type)
element = parser.get_element(app_name, item, type)
sleep(1)
text = ""
if element.exists:
text = element.get_text()
return text
# 清空文本(app_name：应用名，item：控件名，type：控件标识符的类型)
def clear_text(self, app_name, item, type):
print("获取文本，app_name：", app_name, "，item：", item, "，type：", type)
element = parser.get_element(app_name, item, type)
sleep(1)
if element.exists:
element.clear_text()
sleep(w_time)
# 滑动屏幕
def swipe(self, direction):
print("滑动屏幕，direction：" + direction)
(width, hight) = d.window_size()
width_d = width / 6
hight_d = hight / 6
if direction == "up": # 上滑
d.swipe(width / 2, hight - hight_d, width / 2, hight_d)
elif direction == "down": # 下滑
d.swipe(width / 2, hight_d, width / 2, hight - hight_d)
elif direction == "left": # 左滑
d.swipe(width - width_d, hight / 2, width_d, hight / 2)
else: # 右滑
d.swipe(width_d, hight / 2, width - width_d, hight / 2)
sleep(w_time)
# 将 pc 端文件 push 到 phone 端指定文件夹，若此文件夹不存在，会自动创建
def push(self, pc_file_path, phone_dir_path="/sdcard/000/"):
# pc_file_path = "..\\img\\" + pc_file_path
print("push，pc_file_path：", pc_file_path, "，phone_dir_path", phone_dir_path)
d.push(pc_file_path, phone_dir_path)
sleep(w_time)
# 将 phone 端的文件 pull 到 pc 端指定文件夹，若此文件夹不存在，会自动创建
def pull(self, phone_file_path, pc_dir_path="..\\img\\"):
print("pull，phone_file_path：", phone_file_path, "，pc_dir_path", pc_dir_path)
if not os.path.exists(pc_dir_path):
os.mkdir(pc_dir_path)
pc_dir_path += phone_file_path.split("/")[-1]
d.pull(phone_file_path, pc_dir_path)
sleep(w_time)
# 打印日志
def log(self):
time_str = time.strftime('%Y-%m-%d__%H-%M-%S', time.localtime()) # 获取当前时间
print("记录日志，结束时间：", time_str)
path = log_path + time_str + ".txt"
threading.Thread(target=self.log_temp(path)).start()
def log_temp(self, path):
os.system("adb logcat > " + path)
# 清空 img 和 log 目录
def clear_img_log(self, clear):
if clear and os.path.exists(screen_shot_path):
shutil.rmtree(screen_shot_path) # 清空 img 目录
if not os.path.exists(screen_shot_path):
os.mkdir(screen_shot_path) # 创建 img 目录
if clear and os.path.exists(log_path):
shutil.rmtree(log_path) # 清空 log 目录
if not os.path.exists(log_path):
os.mkdir(log_path) # 创建 log 目录
2）配置文件
app.cfg
# app 配置文件
# 系统控件
[system]
package = "com.android.systemui"
edt_password = "com.android.systemui:id/fixedPinEntry" # 输入密码框
key = "com.android.systemui:id/key"
pos_capsule = (100, 16)
# 启动控件
[launcher]
package = "com.huawei.android.launcher"
btn_clear = "com.huawei.android.launcher:id/clear_all_recents_image_button" # 清除所有应用按钮
# 备忘录
[note]
package = "com.huawei.notepad"
btn_new = "com.huawei.notepad:id/fab_add" # 新建按钮
edt_text = "com.huawei.notepad:id/editor_view" # 编辑框
# 图库
[photos]
package = "com.android.gallery3d"
# QQ
[qq]
package = "com.tencent.mobileqq"
btn_login = "com.tencent.mobileqq:id/login" # 登录按钮
img_icon = "com.tencent.mobileqq:id/icon" # 最近联系人头像
edt_input = "com.tencent.mobileqq:id/input" # 消息编辑框
btn_send = "com.tencent.mobileqq:id/fun_btn" # 发送按钮
btn_send_my = "com.tencent.mobileqq:id/imy" # “我的电脑”中发送按钮
# 微信
[wechat]
package = "com.tencent.mm"
# 腾讯视频
[tencent_video]
package = "com.tencent.qqlive"
注意：QQ 中“我的电脑”界面【发送】按钮的 id（imy）与联系人聊天界面的【发送】按钮的 id（fun_btn）不一样。
3）应用配置解析器（Parser）
Parser 类用于根据 app.cfg 文件中的 key 值，获取其 value 值，并定位到控件（获取控件句柄）。
parser.py
from configparser import ConfigParser
import os
# 应用解析器
class Parser:
# 初始化（device 为设备句柄, size 为手机分辨率）
def __init__(self, device, size):
print("应用解析器初始化...")
global d, conf, phone_size
d = device
phone_size = size
conf = ConfigParser()
path = os.path.abspath(os.path.abspath(os.path.dirname(__file__)) + "\\..\\config\\app.cfg")
conf.read(path, encoding='utf-8')
# 解析包名（app_name：应用名）
def get_package(self, app_name):
print("解析包名，app_name：", app_name)
conf_value = conf.get(app_name, "package")
package_name = eval(conf_value)
if package_name == "":
print("应用不存在，app_name：", app_name)
return package_name
# 解析元素（app_name：应用名，item：控件标识，type：控件标识类型）
def get_element(self, app_name, item, type="id"):
print("解析元素，app_name：", app_name, "，item：", item, "，type：", type)
conf_value = conf.get(app_name, item)
value = eval(conf_value)
element = d(resourceId="None")
if type == "id":
element = d(resourceId=value)
elif type == "text":
element = d(text=value)
if not element.exists:
print("元素不存在，item：", item)
return element
# 解析同类元素（app_name：应用名，item + num：控件标识，type：控件标识类型）
def get_element_item_num(self, app_name, item, num, type="id"):
print("解析元素，app_name：", app_name, "，item_num：", item + num, "，type：", type)
conf_value = conf.get(app_name, item)
value = eval(conf_value) + num
if type == "id":
element = d(resourceId=value)
elif type == "text":
element = d(text=value)
if not element.exists:
print("元素不存在，item：", item)
return element
# 解析元素（app_name：应用名，item + num：控件标识，type：控件标识类型）
def get_coord(self, app_name, item, relative = "left_top"):
print("解析元素坐标，app_name：", app_name, "，item_num：", item, "，relative：", relative)
conf_value = conf.get(app_name, item)
rela_x, rela_y = eval(conf_value)
print("相对坐标：(", rela_x, ", ", rela_y, ")")
abs_x = rela_x
abs_y = rela_y
if relative == "left_top":
abs_x = rela_x
abs_y = rela_y
elif relative == "right_top":
abs_x = phone_size[0] + rela_x
abs_y = rela_y
elif relative == "left_bottom":
abs_x = rela_x
abs_y = phone_size[1] + rela_y
elif relative == "right_bottom":
abs_x = phone_size[0] + rela_x
abs_y = phone_size[1] + rela_y
print("绝对坐标：(", abs_x, ", ", abs_y, ")")
return abs_x, abs_y
4）图片匹配器（Matcher）
图片匹配器（Matcher）用于在当前手机界面匹配目标图片，并返回匹配到的中心位置。
matcher.py
import aircv as ac
import os
# 图片匹配器
class Matcher:
# 初始化
def __init__(self):
print("图片匹配器初始化...")
global path
path = os.path.abspath(os.path.abspath(os.path.dirname(__file__)) + "\\..\\match") + "\\"
# 获取控件坐标（target: 目标图片, threshold: 可信阈值）
def get_coord(self, target, threshold = 0.6):
os.system("adb shell screencap -p /sdcard/bg.png")
os.system("adb pull /sdcard/bg.png " + path)
imsrc = ac.imread(path + "bg.png")
imobj = ac.imread(path + target + ".png")
res = ac.find_template(imsrc, imobj, threshold = threshold)
if res == None:
print("图片匹配失败")
return None
else:
pos_f = res['result']
pos = (int(pos_f[0]), int(pos_f[1]))
print("图片匹配成功，res：", res)
return pos
5）模板类（Template）
模板类（Template）为测试类（MyTest）提供模板，所有测试类都继承模板类，测试类只需重写 first 和 circle_body 方法，即可实现各种复杂的挂机任务。
template.py
from base.phone import Phone
from time import sleep
# 模板类（为测试类提供模板，所有测试类都继承此类，测试类只需重写 first 和 circle_body 方法）
class Template:
def __init__(self, connect_type="usb", wait_time=1, log=False):
print("Template 初始化...")
self.phone = Phone(connect_type, wait_time)
self.log = log
# 设置测试初始状态
def first(self):
print("设置测试初始状态...")
# 设置循环体
def circle_body(self):
print("设置循环体...")
# 开始循环
def loop(self, max_times=1000000000):
print("开始循环...")
i = 1;
while i <= max_times:
print("********************", i, "********************")
# try:
self.circle_body()
# except BaseException:
# if self.log:
# self.phone.log()
# raise Exception("循环异常...")
i = i + 1
sleep(3)
# 主调用方法
def main(self):
self.first()
self.loop()
6）测试类(MyTest)
用户需要挂机的具体任务，可以写在此类中，每个任务建一个测试文件，如 qq_test.py（QQ测试任务）、notepad_test.py（备忘录测试任务），各个测试类中都继承了 Template 类，并重写其 first() 方法和 circle_body() 方法。
test.py
from base.template import Template
# 测试类（类名不要以 Test 开头）
class MyTest(Template):
def __init__(self):
print("Test 初始化...")
super().__init__(connect_type="usb", wait_time=2, log=True)
self.phone.unlock("123456") # 解锁
# 设置测试初始状态
def first(self):
print("执行测试初始状态...")
self.phone.start_app("note") # 打开备忘录
self.phone.start_app("photos") # 打开图库
self.phone.clear_all_app() # 清除所有打开的应用
# 设置循环体
def circle_body(self):
print("执行循环体...")
self.phone.start_app("qq") # 打开 QQ
self.phone.click("qq", "img_icon", 0) # 点击最近联系人中第1个
self.phone.set_text("qq", "edt_input", "我正在做自动化测试，请忽略此消息") # 编辑消息
self.phone.click("qq", "btn_send_my") # 点击发送，这里是给【我的电脑】发送，请将【我的电脑】置顶
self.phone.stop_app("qq") # 关闭 QQ
if __name__ == '__main__':
test = MyTest()
test.main()
声明：本文转自Android 自动化测试项目