def installQuirkClass(cls):
cls.package_name = 'com.ugen.playquirk'
apk_path = cls.R('res/app/quirk.apk')
if cls.package_name not in current_device().list_app():
install_android_app(current_device().adb, apk_path)
start_app(cls.package_name)
time.sleep(30)
def __init__(self, addr=DEFAULT_ADDR):
try:
port = int(addr.rsplit(":", 1)[-1])
except ValueError:
raise ValueError(
'Argument `addr` should be a string-like format. e.g. "ws://192.168.1.2:5003". Got {}'
.format(repr(addr)))
if not current_device():
connect_device("Android:///")
if device_platform() == 'Android':
local_port, _ = current_device().adb.setup_forward(
'tcp:{}'.format(port))
ip = 'localhost'
port = local_port
elif device_platform() == 'IOS':
# Note: ios is now support for now.
# ip = device.get_ip_address()
# use iproxy first
ip = 'localhost'
local_port, _ = current_device().instruct_helper.setup_proxy(port)
port = local_port
else:
import socket
ip = socket.gethostbyname(socket.gethostname())
self.conn = WebSocketClient('ws://{}:{}'.format(ip, port))
self.c = RpcClient(self.conn)
self.c.connect()
hierarchy = FrozenUIHierarchy(Dumper(self.c))
screen = AirtestScreen()
inputs = AirtestInput()
super(CocosJsPocoAgent, self).__init__(hierarchy, inputs, screen, None)
def init_app(plat, package_name, app_path, sleep_time):
dev = None
if plat.lower().find('android') >= 0:
if not current_device():
if plat.lower().find('sim') >= 0:
dev = connect_device(
'Android:///127.0.0.1:{}?cap_method=JAVACAP&ori_method=ADBORI'
.format(SD.SIM_PORT))
else:
dev = connect_device('Android:///')
wake()
install_android_app(current_device().adb, app_path)
stop_app(package_name)
start_app(package_name)
sleep(sleep_time / 1.5)
elif plat == 'PC_editor':
w = Windows()
dev = UnityEditorWindow()
w.keyevent('^P') # Ctrl+P运行
sleep(sleep_time / 2)
dev.stop_app = w.app # 用于获取进程id，结束进程用
elif plat == 'PC_win':
w = Windows()
w.start_app(app_path)
sleep(sleep_time)
w.connect(process=w.app.process)
dev = connect_device("Windows:///?class_name=UnityWndClass")
dev.stop_app = w.app
# elif plat == 'iOS':
# pass
# elif plat == 'MAC_editor':
# pass
return dev
def __init__(self, addr=DEFAULT_ADDR):
# init airtest env
try:
# new version
from airtest.core.api import connect_device, device as current_device
if not current_device():
connect_device("Android:///")
except ImportError:
# old version
from airtest.cli.runner import device as current_device
from airtest.core.main import set_serialno
if not current_device():
set_serialno()
# cocos games poco sdk listens on Android localhost:5003
localport = addr.split(":")[-1]
current_device().adb.forward("tcp:%s" % localport, "tcp:5003", False)
self.conn = WebSocketClient(addr)
self.c = RpcClient(self.conn)
self.c.DEBUG = False
self.c.run(backend=True)
self.c.wait_connected()
hierarchy = FreezedUIHierarchy(Dumper(self.c))
screen = AirtestScreen()
input = AirtestInput()
super(CocosJsPocoAgent, self).__init__(hierarchy, input, screen, None)
def applyMotionEvents(self, events):
if device_platform() != 'Android':
raise NotImplementedError
# Android minitouch only, currently
from airtest.core.android.minitouch import DownEvent, MoveEvent, UpEvent, SleepEvent
mes = []
for e in events:
t = e[0]
if t == 'd':
contact = e[2]
x, y = e[1]
pos = self.get_target_pos(x, y)
me = DownEvent(pos, contact)
elif t == 'm':
contact = e[2]
x, y = e[1]
pos = self.get_target_pos(x, y)
me = MoveEvent(pos, contact)
elif t == 'u':
contact = e[1]
me = UpEvent(contact)
elif t == 's':
how_long = e[1]
me = SleepEvent(how_long)
else:
raise ValueError('Unknown event type {}'.format(repr(t)))
mes.append(me)
current_device().minitouch.perform(mes, interval=0)
def __init__(self, addr=DEFAULT_ADDR, unity_editor=False):
if not unity_editor:
# init airtest env
try:
# new version
from airtest.core.api import connect_device, device as current_device
if not current_device():
connect_device("Android:///")
except ImportError:
# old version
from airtest.cli.runner import device as current_device
from airtest.core.main import set_serialno
if not current_device():
set_serialno()
# unity games poco sdk listens on Android localhost:5001
current_device().adb.forward("tcp:%s" % addr[1], "tcp:5001", False)
self.conn = TcpClient(addr)
self.c = RpcClient(self.conn)
self.c.DEBUG = False
self.c.run(backend=True)
self.c.wait_connected()
hierarchy = FreezedUIHierarchy(Dumper(self.c), UnityAttributor(self.c))
if unity_editor:
screen = UnityScreen(self.c)
else:
screen = AirtestScreen()
input = AirtestInput()
super(UnityPocoAgent, self).__init__(hierarchy, input, screen, None)
def setUp(self):
if not current_device():
connect_device('Android:///')
self.package_name = 'com.google.android.calculator'
apk_path = self.R('res/app/com.google.android.calculator.apk')
install_android_app(current_device().adb, apk_path)
start_app(self.package_name)
def setUp(self):
if not current_device():
connect_device('Android:///')
self.package_name = 'com.ugen.playquirk'
apk_path = self.R('res/app/quirk.apk')
install_android_app(current_device().adb, apk_path)
start_app(self.package_name)
time.sleep(30)
def _get_touch_resolution(self):
"""
get real time resolution on device if full screen
or window size if running in window mode
"""
if device_platform() == 'Android':
if self.use_render_resolution:
return current_device().get_render_resolution()
w, h = current_device().get_current_resolution()
return 0, 0, w, h
def __init__(self, device=None, **kwargs):
device = device or current_device()
if not device or device.__class__.__name__ != 'IOS':
raise RuntimeError('Please call `connect_device` to connect an iOS device first')
agent = iosPocoAgent(device)
super(iosPoco, self).__init__(agent, **kwargs)
def __init__(self, port=DEFAULT_PORT, device=None, **kwargs):
self.device = device or current_device()
if not self.device:
self.device = connect_device("Android:///")
platform_name = device_platform(self.device)
if platform_name == 'Android':
# always forward for android device to avoid network unreachable
local_port, _ = self.device.adb.setup_forward(
'tcp:{}'.format(port))
ip = self.device.adb.host or 'localhost'
port = local_port
elif platform_name == 'IOS':
# ip = device.get_ip_address()
# use iproxy first
ip = 'localhost'
local_port, _ = self.device.instruct_helper.setup_proxy(port)
port = local_port
else:
try:
ip = self.device.get_ip_address()
except AttributeError:
try:
ip = socket.gethostbyname(socket.gethostname())
except socket.gaierror:
# 某些特殊情况下会出现这个error，无法正确获取本机ip地址
ip = 'localhost'
agent = StdPocoAgent((ip, port))
super(StdPoco, self).__init__(agent, **kwargs)
def __init__(self, port, device=None):
self.device = device or current_device()
if not self.device:
self.device = connect_device("Android:///")
platform_name = device_platform(self.device)
if platform_name == 'Android':
local_port, _ = self.device.adb.setup_forward(
'tcp:{}'.format(port))
ip = self.device.adb.host or 'localhost'
port = local_port
elif platform_name == 'IOS':
# Note: ios is now support for now.
# ip = device.get_ip_address()
# use iproxy first
ip = 'localhost'
local_port, _ = self.device.instruct_helper.setup_proxy(port)
port = local_port
else:
ip = self.device.get_ip_address()
# transport
self.conn = WebSocketClient('ws://{}:{}'.format(ip, port))
self.c = RpcClient(self.conn)
self.c.connect()
hierarchy = FrozenUIHierarchy(Dumper(self.c))
screen = AirtestScreen()
inputs = AirtestInput()
super(CocosJsPocoAgent, self).__init__(hierarchy, inputs, screen, None)
def setUpClass(cls):
super(AndroidAppCase, cls).setUpClass()
if not current_device():
connect_device('Android:///')
dev = current_device()
meta_info_emitter = cls.get_result_emitter('metaInfo')
if device_platform() == 'Android':
meta_info_emitter.snapshot_device_info(dev.serialno,
dev.adb.get_device_info())
cls.poco = AndroidUiautomationPoco(screenshot_each_action=False)
action_tracker = ActionTracker(cls.poco)
cls.register_addon(action_tracker)
cls.site_capturer = SiteCaptor(cls.poco)
cls.register_addon(cls.site_capturer)
def __init__(self,
addr=DEFAULT_ADDR,
unity_editor=False,
connect_default_device=True):
# init airtest env
try:
# new version
from airtest.core.api import connect_device, device as current_device
from airtest.core.helper import device_platform
if unity_editor and not current_device():
connect_device(
"Windows:///?class_name=UnityWndClass&title_re=Unity.*")
game_window = current_device().app.top_window().child_window(
title="UnityEditor.GameView")
current_device()._top_window = game_window.wrapper_object()
current_device().focus_rect = (0, 40, 0, 0)
if connect_default_device and not current_device():
# currently only connect to Android as default
# can apply auto detection in the future
connect_device("Android:///")
if device_platform() == "Android":
# always forward port for Android
# unity games poco sdk listens on Android localhost:5001
current_device().adb.forward("tcp:%s" % addr[1], "tcp:5001",
False)
except ImportError:
# old version, 逐渐废弃
from airtest.cli.runner import device as current_device
from airtest.core.main import set_serialno
if not current_device():
set_serialno()
# unity games poco sdk listens on Android localhost:5001
current_device().adb.forward("tcp:%s" % addr[1], "tcp:5001", False)
self.conn = TcpClient(addr)
self.c = RpcClient(self.conn)
self.c.DEBUG = False
self.c.wait_connected()
hierarchy = FrozenUIHierarchy(Dumper(self.c), UnityAttributor(self.c))
screen = UnityScreen(self.c)
input = AirtestInput()
super(UnityPocoAgent, self).__init__(hierarchy, input, screen, None)
def __init__(self,
addr=DEFAULT_ADDR,
ue4_editor=False,
connect_default_device=True,
device=None,
**options):
if 'action_interval' not in options:
options['action_interval'] = 0.5
if ue4_editor:
dev = UE4EditorWindow()
else:
dev = device or current_device()
if dev is None and connect_default_device and not current_device():
dev = connect_device("Android:///")
super(UE4Poco, self).__init__(addr[1], dev, **options)
def __init__(self, port=DEFAULT_PORT, device=None, **kwargs):
device = device or current_device()
if not device:
raise RuntimeError(
'Please call `connect_device` first. see airtest.core.api.connect_device to get '
'more infomation')
ip = device.get_ip_address()
agent = StdPocoAgent((ip, port))
super(StdPoco, self).__init__(agent, **kwargs)
def __init__(self,
addr=DEFAULT_ADDR,
unity_editor=False,
connect_default_device=True,
device=None,
**options):
if 'action_interval' not in options:
options['action_interval'] = 0.5
if unity_editor:
dev = UnityEditorWindow()
else:
dev = device or current_device()
if dev is None and connect_default_device and not current_device():
# currently only connect to Android as default
# can apply auto detection in the future
dev = connect_device("Android:///")
super(UnityPoco, self).__init__(addr[1], dev, **options)
def _get_touch_resolution(self):
"""
get real time resolution on device if full screen
or window size if running in window mode
"""
if device_platform() == 'Windows':
if self.surface is None:
raise RuntimeError(
'Please initialize AirtestInput with surface object, '
'when running test suites on windows as target device.')
return self.surface.getPortSize()
else:
display_info = current_device().display_info
w, h = display_info["width"], display_info["height"]
if display_info["orientation"] in (1, 3):
return h, w
else:
return w, h
def __init__(self, port=DEFAULT_PORT, device=None, **kwargs):
device = device or current_device()
if not device:
raise RuntimeError(
'Please call `connect_device` first. see airtest.core.api.connect_device to get '
'more infomation')
# always forward for android device to avoid network unreachable
if device_platform() == 'Android':
local_port, _ = device.adb.setup_forward('tcp:{}'.format(port))
ip = 'localhost'
port = local_port
else:
import socket
ip = socket.gethostbyname(socket.gethostname())
# Note: ios is not support for now.
agent = StdPocoAgent((ip, port))
super(StdPoco, self).__init__(agent, **kwargs)
def init_app(plat=SD.PLAT, package_name=SD.PACKAGE_NAME, app_path=SD.APP_PATH[SD.PLAT], sleep_time=SD.SLEEP_TIME,
serialno=SD.SERIALNO):
dev = None
if plat == 'android':
if SD.USE_ATX_SERVER2:
atx_server2 = AtxServer2()
device_info = atx_server2.get_usable_device_info()
SD.UDID = device_info['udid']
serialno = device_info['source']['remoteConnectAddress']
if serialno and serialno.strip() != '':
if re.search(r'127.0.0.1:\d+', serialno):
logger.debug('模拟器用JAVACAP和ADBORI')
dev = connect_device(f'Android:///{serialno}?cap_method=JAVACAP&ori_method=ADBORI')
else:
logger.debug(f'指定连接serialno: {serialno}')
dev = connect_device(f'Android:///{serialno}')
else:
dev = connect_device('Android:///')
wake()
install_android_app(current_device().adb, app_path)
stop_app(package_name)
logger.debug(f'启动app:{package_name}')
start_app(package_name)
sleep(sleep_time / 1.5)
elif plat == 'pc_editor':
w = Windows()
dev = UnityEditorWindow()
w.keyevent('^P') # Ctrl+P运行
sleep(sleep_time / 2)
dev.stop_app = w.app # 用于获取进程id，结束进程用
elif plat == 'pc_win':
w = Windows()
w.start_app(app_path)
sleep(sleep_time)
w.connect(process=w.app.process)
dev = connect_device("Windows:///?class_name=UnityWndClass")
dev.stop_app = w.app
# elif plat == 'ios':
# pass
# elif plat == 'mac_editor':
# pass
return dev
def __init__(self,
game_name,
phone_name="",
on_connect=None,
on_close=None):
"""address is (host, port) tuple"""
self.game_name = game_name
self.info = Information()
self.phone_name = phone_name
self.on_connect = on_connect
self.on_close = on_close
self.sock = None
self.buf = b""
self.prot = SimpleProtocolFilter()
self.device = None or current_device()
if not self.device and self.phone_name != None:
self.device = connect_device("Android:///" + self.phone_name)
self.platform_name = device_platform(self.device)
self.connect_phone()
self.address = (self.ip, self.port)
def __init__(self, port=DEFAULT_PORT, device=None, **kwargs):
device = device or current_device()
ip = socket.gethostbyname(socket.gethostname())
if not device:
import warnings
warnings.warn(
"no airtest device connected, please connect_device first")
elif device_platform(device) == 'Android':
# always forward for android device to avoid network unreachable
local_port, _ = device.adb.setup_forward('tcp:{}'.format(port))
ip = device.adb.host or 'localhost'
port = local_port
elif device_platform(device) == 'IOS':
# ip = device.get_ip_address()
# use iproxy first
ip = 'localhost'
local_port, _ = device.instruct_helper.setup_proxy(port)
port = local_port
agent = StdPocoAgent((ip, port))
super(StdPoco, self).__init__(agent, **kwargs)
def __init__(self,
addr=DEFAULT_ADDR,
unity_editor=False,
connect_default_device=True,
**options):
if 'action_interval' not in options:
options['action_interval'] = 0.5
dev = None
if unity_editor:
dev = connect_device(
"Windows:///?class_name=UnityWndClass&title_re=Unity.*")
game_window = dev.app.top_window().child_window(
title="UnityEditor.GameView")
dev._top_window = game_window.wrapper_object()
dev.focus_rect = (0, 40, 0, 0)
if connect_default_device and not current_device():
# currently only connect to Android as default
# can apply auto detection in the future
dev = connect_device("Android:///")
super(UnityPoco, self).__init__(addr[1], dev, **options)
def _get_touch_resolution(self):
"""
get real time resolution on device if full screen
or window size if running in window mode
"""
return current_device().get_current_resolution()
def setUp(self):
if not current_device():
connect_device('Android:///')
apk_path = self.R('res/app/com.sogou.androidtool.apk')
install_android_app(current_device().adb, apk_path)
def getPortSize(self):
disp = current_device().display_info
if disp['orientation'] in (1, 3):
return [disp['height'], disp['width']]
else:
return [disp['width'], disp['height']]
def setUpClass(cls):
super(CalculatorCase, cls).setUpClass()
cls.package_name = 'com.google.android.calculator'
apk_path = cls.R('res/app/com.google.android.calculator.apk')
install_android_app(current_device().adb, apk_path)
start_app(cls.package_name)
def setUpClass(cls):
super(Case, cls).setUpClass()
if not current_device():
connect_device('Android:///')
def __init__(self, device=None, using_proxy=True, **options):
if not device:
try:
# new version
from airtest.core.api import connect_device, device as current_device
if not current_device():
connect_device("Android:///")
except ImportError:
# old version
from airtest.cli.runner import device as current_device
from airtest.core.main import set_serialno
if not current_device():
set_serialno()
self.android = current_device()
else:
self.android = device
self.adb_client = self.android.adb
if using_proxy:
self.device_ip = self.adb_client.host or "127.0.0.1"
else:
if new_airtest_api:
self.device_ip = self.adb_client.get_ip_address()
else:
self.device_ip = get_ip_address(self.adb_client)
# save current top activity (@nullable)
current_top_activity_package = self.android.get_top_activity_name()
if current_top_activity_package is not None:
current_top_activity_package = current_top_activity_package.split(
'/')[0]
# install ime
self.ime = YosemiteIme(self.adb_client)
self.ime.start()
# install
self._instrument_proc = None
self._install_service()
# forward
if using_proxy:
p0, _ = self.adb_client.setup_forward("tcp:10080")
p1, _ = self.adb_client.setup_forward("tcp:10081")
else:
p0 = 10080
p1 = 10081
# start
if self._is_running('com.github.uiautomator'):
warnings.warn(
'{} should not run together with "uiautomator". "uiautomator" will be killed.'
.format(self.__class__.__name__))
self.adb_client.shell(
['am', 'force-stop', 'com.github.uiautomator'])
ready = self._start_instrument(p0)
if not ready:
# 启动失败则需要卸载再重启，instrument的奇怪之处
uninstall(self.adb_client, PocoServicePackage)
self._install_service()
ready = self._start_instrument(p0)
if current_top_activity_package is not None:
current_top_activity2 = self.android.get_top_activity_name()
if current_top_activity2 is None or current_top_activity_package not in current_top_activity2:
self.android.start_app(current_top_activity_package,
activity=True)
if not ready:
raise RuntimeError("unable to launch AndroidUiautomationPoco")
endpoint = "http://{}:{}".format(self.device_ip, p1)
agent = AndroidPocoAgent(endpoint, self.ime)
super(AndroidUiautomationPoco, self).__init__(agent, **options)
def __init__(self,
device=None,
using_proxy=True,
force_restart=False,
use_airtest_input=False,
**options):
# 加这个参数为了不在最新的pocounit方案中每步都截图
self.screenshot_each_action = True
if options.get('screenshot_each_action') is False:
self.screenshot_each_action = False
self.device = device or current_device()
if not self.device:
self.device = connect_device("Android:///")
self.adb_client = self.device.adb
if using_proxy:
self.device_ip = self.adb_client.host or "127.0.0.1"
else:
self.device_ip = self.device.get_ip_address()
# save current top activity (@nullable)
current_top_activity_package = self.device.get_top_activity_name()
if current_top_activity_package is not None:
current_top_activity_package = current_top_activity_package.split(
'/')[0]
# install ime
self.ime = YosemiteIme(self.adb_client)
self.ime.start()
# install
self._instrument_proc = None
self._install_service()
# forward
if using_proxy:
p0, _ = self.adb_client.setup_forward("tcp:10080")
p1, _ = self.adb_client.setup_forward("tcp:10081")
else:
p0 = 10080
p1 = 10081
# start
if self._is_running('com.github.uiautomator'):
warnings.warn(
'{} should not run together with "uiautomator". "uiautomator" will be killed.'
.format(self.__class__.__name__))
self.adb_client.shell(
['am', 'force-stop', 'com.github.uiautomator'])
ready = self._start_instrument(p0, force_restart=force_restart)
if not ready:
# 启动失败则需要卸载再重启，instrument的奇怪之处
uninstall(self.adb_client, PocoServicePackage)
self._install_service()
ready = self._start_instrument(p0)
if current_top_activity_package is not None:
current_top_activity2 = self.device.get_top_activity_name()
if current_top_activity2 is None or current_top_activity_package not in current_top_activity2:
self.device.start_app(current_top_activity_package,
activity=True)
if not ready:
raise RuntimeError("unable to launch AndroidUiautomationPoco")
endpoint = "http://{}:{}".format(self.device_ip, p1)
agent = AndroidPocoAgent(endpoint, self.ime, use_airtest_input)
super(AndroidUiautomationPoco, self).__init__(agent, **options)
