class Mobile():
"""
"""
def __init__(self, android_serial = None):
# logger.info("Importing Android library")
# print "Importing Android library"
# clm.message("Importing Android library")
self.adb = ADB(android_serial)
self.device = Device(android_serial)
self.test_helper = TestHelper(android_serial)
def set_serial(self, android_serial):
"""
Set device serial
"""
self.adb = ADB(android_serial)
self.device = Device(android_serial)
self.test_helper = TestHelper(android_serial)
def get_info(self):
"""
Retrieve the device info
"""
return self.device.info
#Key Event Actions of the device
"""
Turn on/off screen
"""
def turn_on_screen(self):
"""
Turn on screen
"""
self.device.screen.on()
def turn_off_screen(self):
"""
Turn off screen
"""
self.device.screen.off()
def wakeup_the_device(self):
"""
wakeup the device
"""
self.device.wakeup()
"""
Press hard/soft key
"""
def press_key(self, *key):
"""
press *key* keycode
"""
self.device.press(*key)
def press_home(self):
"""
press home key
"""
self.device.press.home()
def press_back(self):
"""
press back key
"""
self.device.press.back()
def press_left(self):
"""
press left key
"""
self.device.pres.left()
def press_right(self):
"""
press right key
"""
self.device.press.right()
def press_up(self):
"""
press up key
"""
self.device.press.up()
def press_down(self):
"""
press down key
"""
self.device.press.down()
def press_center(self):
"""
press center key
"""
self.device.press.center()
def press_menu(self):
"""
press menu key
"""
self.device.press.menu()
def press_search(self):
"""
press search key
"""
self.device.press.search()
def press_enter(self):
"""
press enter key
"""
self.device.press.enter()
def press_delete(self):
"""
press delete key
"""
self.device.press.delete()
def press_recent(self):
"""
press recent key
"""
self.device.press.recent()
def press_volume_up(self):
"""
press volume up key
"""
self.device.press.volume_up()
def press_volume_down(self):
"""
press volume down key
"""
self.device.press.volume_down()
def press_camera(self):
"""
press camera key
"""
self.device.press.camera()
def press_power(self):
"""
press power key
"""
self.device.press.power()
#Gesture interaction of the device
def click(self, x, y):
"""
click (x, y) on screen
"""
self.device.click(x, y)
def swipe(self, sx, sy, ex, ey, steps=10):
"""
swipe from (sx, sy) to (ex, ey) with steps
"""
self.device.swipe(sx, sy, ex, ey, steps)
# Swipe from the center of the ui object to its edge
def swipe_left(self, obj, steps=10):
"""
swipe the *obj* from center to left
"""
obj.swipe.left(steps=steps)
def swipe_right(self, obj, steps=10):
"""
swipe the *obj* from center to right
"""
obj.swipe.right(steps=steps)
def swipe_top(self, obj, steps=10):
"""
swipe the *obj* from center to top
"""
obj.swipe.top(steps=steps)
def swipe_bottom(self, obj, steps=10):
"""
swipe the *obj* from center to bottom
"""
obj.swipe.bottom(steps=steps)
def drag(self,sx, sy, ex, ey, steps=10):
"""
drag from (sx, sy) to (ex, ey) with steps
"""
self.device.drag(sx, sy, ex, ey, steps)
#Wait until the specific ui object appears or gone
# wait until the ui object appears
def wait_for_exists(self, timeout=0, *args, **attribute):
"""
true means the object which has *attribute* exist
false means the object does not exist
in the given timeout
"""
return self.device(**attribute).wait.exists(timeout=timeout)
# wait until the ui object gone
def wait_until_gone(self, timeout=0, *args, **attribute):
"""
true means the object which has *attribute* disappear
false means the object exist
in the given timeout
"""
return self.device(**attribute).wait.gone(timeout=timeout)
def wait_for_object_exists(self, obj, timeout=0):
"""
true means the object exist
false means the object does not exist
in the given timeout
"""
return obj.wait.exists(timeout=timeout)
# wait until the ui object gone
def wait_until_object_gone(self, obj, timeout=0):
"""
true means the object disappear
false means the object exist
in the given timeout
"""
return obj.wait.gone(timeout=timeout)
# Perform fling on the specific ui object(scrollable)
def fling_forward_horizontally(self, obj):
"""
return whether the object can be fling or not
"""
return obj.fling.horiz.forward()
def fling_backward_horizontally(self, obj):
"""
return whether the object can be fling or not
"""
return obj.fling.horiz.backward()
def fling_forward_vertically(self, obj):
"""
return whether the object can be fling or not
"""
return obj.fling.vert.forward()
def fling_backward_vertically(self, obj):
"""
return whether the object can be fling or not
"""
return obj.fling.vert.backward()
# Perform scroll on the specific ui object(scrollable)
def scroll_to_beginning_vertically(self, obj, steps=10):
"""
"""
return obj.scroll.vert.toBeginning(steps=steps)
def scroll_forward_horizontally(self, obj, steps=10):
"""
return whether the object can be fling or not
"""
return obj.scroll.horiz.forward(steps=steps)
def scroll_backward_horizontally(self, obj, steps=10):
"""
return whether the object can be fling or not
"""
return obj.scroll.horiz.backward(steps=steps)
def scroll_to_horizontally(self, obj, *args,**attribute):
"""
return whether the object can be fling or not
"""
return obj.scroll.horiz.to(**attribute)
def scroll_forward_vertically(self, obj, steps=10):
"""
return whether the object can be fling or not
"""
return obj.scroll.vert.forward(steps=steps)
def scroll_backward_vertically(self, obj, steps=10):
"""
return whether the object can be fling or not
"""
return obj.scroll.vert.backward(steps=steps)
def scroll_to_vertically(self, obj, *args, **attribute):
"""
return whether the object can be fling or not
"""
msg = ''
for key, value in attribute.iteritems():
msg += ' %s=%s ' % (key, value)
print msg
# print 'args:' + args[0]
return obj.scroll.vert.to(**attribute)
#Screen Actions of the device
def screenshot(self, scale=None, quality=None):
"""
Take a screenshot of device and log in the report with timestamp
"""
output_dir = BuiltIn().get_variable_value('${OUTPUTDIR}')
ts = time.time()
st = datetime.datetime.fromtimestamp(ts).strftime('%Y%m%d%H%M%S')
screenshot_path = '%s%s%s.png' % (output_dir, os.sep, st)
self.device.screenshot(screenshot_path, scale, quality)
logger.info('\n<a href="%s">%s</a><br><img src="%s">' % (screenshot_path, st, screenshot_path), html=True)
#Watcher
# def register_click_watcher(self, watcher_name, attributes, *condition_list):
# """
# The watcher click on the object which has the attributes when conditions match
# """
# print type(attributes)
# watcher = self.device.watcher(watcher_name)
# for condition in condition_list:
# watcher.when(**condition)
# watcher.click(**attributes)
# self.device.watchers.run()
# print 'register watcher:%s' % watcher_name
# return
def __unicode_to_dict(self, a_unicode):
a_dict = dict()
dict_item_count = a_unicode.count('=')
for count in range(dict_item_count):
equal_sign_position = a_unicode.find('=')
comma_position = a_unicode.find(',')
a_key = a_unicode[0:equal_sign_position]
if comma_position == -1:
a_value = a_unicode[equal_sign_position + 1:]
else:
a_value = a_unicode[equal_sign_position + 1:comma_position]
a_unicode = a_unicode[comma_position + 1:]
a_dict[a_key] = a_value
return a_dict
def register_click_watcher(self, watcher_name, attributes, *condition_list):
"""
The watcher click on the object which has the *attributes* when conditions match
"""
watcher = self.device.watcher(watcher_name)
for condition in condition_list:
watcher.when(**self.__unicode_to_dict(condition))
watcher.click(**self.__unicode_to_dict(attributes))
self.device.watchers.run()
def register_press_watcher(self, watcher_name, press_keys, *condition_list):
"""
The watcher perform *press_keys* action sequentially when conditions match
"""
def unicode_to_list(a_unicode):
a_list = list()
comma_count = a_unicode.count(',')
for count in range(comma_count + 1):
comma_position = a_unicode.find(',')
if comma_position == -1:
a_list.append(str(a_unicode))
else:
a_list.append(a_unicode[0:comma_position])
a_unicode = a_unicode[comma_position + 1:]
return a_list
watcher = self.device.watcher(watcher_name)
for condition in condition_list:
watcher.when(**self.__unicode_to_dict(condition))
watcher.press(*unicode_to_list(press_keys))
self.device.watchers.run()
def remove_watchers(self, watcher_name = None):
"""
remove watcher with *watcher_name* or remove all watchers
"""
if watcher_name == None:
self.device.watchers.remove()
else:
self.device.watchers.remove(watcher_name)
def list_all_watchers(self):
"""
return the watcher list
"""
return self.device.watchers
#Selector
def get_object(self, *args, **attribute):
"""
get the ui object with attribute *attribute*
"""
msg = ''
for key, value in attribute.iteritems():
msg += ' %s=%s ' % (key, value)
print msg
return self.device(*args, **attribute)
def get_info_of_object(self, obj):
"""
return info dictionary of the *obj*
The info example:
{
u'contentDescription': u'',
u'checked': False,
u'scrollable': True,
u'text': u'',
u'packageName': u'com.android.launcher',
u'selected': False,
u'enabled': True,
u'bounds':
{
u'top': 231,
u'left': 0,
u'right': 1080,
u'bottom': 1776
},
u'className': u'android.view.View',
u'focusable': False,
u'focused': False,
u'clickable': False,
u'checkable': False,
u'chileCount': 1,
u'longClickable': False,
u'visibleBounds':
{
u'top': 231,
u'left': 0,
u'right': 1080,
u'bottom': 1776
}
}
"""
return obj.info
def click_on(self, *args, **attribute):
"""
click on the object with *attribute*
"""
self.device(**attribute).click()
def long_click_on(self, *args, **attribute):
"""
click on the object with *attribute*
"""
self.device(**attribute).long_click()
def call(self, obj, method, *args, **attribute):
func = getattr(obj, method)
return func(**attribute)
def set_text(self, text, *args, **attribute):
"""
set *text* to the Component which has the *attribute*
"""
self.device(**attribute).set_text(text)
def clear_text(self, *args, **attributes):
"""
Clear text of the component with *attributes*
"""
while True:
target = self.device(**attributes)
text = target.info['text']
target.clear_text()
remain_text = target.info['text']
if text == '' or remain_text == text:
break
# Other feature
def sleep(self, time):
"""
sleep(no action) for *time* (in millisecond)
"""
target = 'wait for %s' % str(time)
self.device(text=target).wait.exists(timeout=time)
def install(self, apk_path):
self.adb.cmd('install "%s"' % apk_path)
def uninstall(self, package_name):
self.adb.cmd('uninstall %s' % package_name)
def type(self, text):
"""
Type *text* at current focused component
"""
self.test_helper.send_set_text_cmd(text)
def foo(self):
pass
# logger.info('\nGot arg %s %s' % (output_dir, st), also_console=True)
# clm = CommandLineWriter()
# output some messages on console
# clm.message(' ')
# clm.message(u'中文')
# clm.message(u'2----------2')
def test(self):
pass
def __init__(self, serialno=None, **kwargs):
"""Initial AndroidDevice
Args:
serialno: string specify which device
Returns:
AndroidDevice object
Raises:
EnvironmentError
"""
self.__display = None
serialno = serialno or getenv('ATX_ADB_SERIALNO', None)
self._host = kwargs.get('host', getenv('ATX_ADB_HOST', '127.0.0.1'))
self._port = kwargs.get('port', getenv('ATX_ADB_PORT', 5037, type=int))
self._adb = adb.Adb(serialno, self._host, self._port)
serialno = self._adb.device_serial()
kwargs['adb_server_host'] = kwargs.pop('host', self._host)
kwargs['adb_server_port'] = kwargs.pop('port', self._port)
UiaDevice.__init__(self, serialno, **kwargs)
DeviceMixin.__init__(self)
self._randid = base.id_generator(5)
self._serial = serialno
self._uiauto = super(AndroidDevice, self)
self.screen_rotation = None
self.screenshot_method = consts.SCREENSHOT_METHOD_AUTO
self.last_screenshot = None
def set_serial(self, android_serial):
"""
Set device serial
"""
self.adb = ADB(android_serial)
self.device = Device(android_serial)
self.test_helper = TestHelper(android_serial)
def __init__(self, seral=None):
self.serial = os.environ[ANDROID_SERIAL] if os.environ.has_key(ANDROID_SERIAL) else None
self.working_dir_path = WORKING_DIR_PATH
self.report_dir_path = REPORT_DIR_PATH
self.right_dir_path = WORKING_DIR_PATH
self._internal_storage_dir = DEFAULT_DEVICE_INTERNAL_STORAGE
self.d = Device(self.serial)
def __init__(self, android_serial = None):
# logger.info("Importing Android library")
# print "Importing Android library"
# clm.message("Importing Android library")
self.adb = ADB(android_serial)
self.device = Device(android_serial)
self.test_helper = TestHelper(android_serial)
def __init__(self, environment, monitor_serial):
self.monitor_serial = monitor_serial
self.specifying_monitor = '-s {}'.format(self.monitor_serial)
self.device = Device(self.monitor_serial)
self.build_location ="mon_test\Apps\monitor_build\dev-dell-release-SINK-0.0.3143.7736342\system"
self.build_version = self.get_build_version()
self.monitor_name = self.get_monitor_name_by_ui()
self.find_command = " | findstr" if platform.platform() == "Windows" else "| grep"
print 'Monitor:init - orientation=%s' % self.device.orientation
def __init__(self):
'''
create device instance.
'''
self.serial = os.environ[ANDROID_SERIAL] if os.environ.has_key(ANDROID_SERIAL) else None
self.working_dir_path = WORKING_DIR_PATH
self.report_dir_path = REPORT_DIR_PATH
self.right_dir_path = RIGHT_DIR_PATH
self.d = Device(self.serial)
self.d.screenshot = self.screenshot_common
def __init__(self, serial=None):
"""
"""
logger.info("<p>Device=%s>" % serial, html=True)
print "<p>Device=%s>" % serial
self._result = ""
self.starttime = 0
self.d = Device(serial)
self.adb = Adb(serial)
self.debug = "True"
class Monitor():
def __init__(self):
self.serial = self._get_serial()
self.automation_handle = Device(self.serial)
self.name = self._get_monitor_name()
def _get_serial(self):
output = subprocess.check_output(["adb", "devices"])
starting_time = time.time()
while "offline" in output and time.time() < starting_time + 20:
subprocess.check_output(["adb", "kill-server"])
time.sleep(1)
subprocess.check_output(["adb", "start-server"])
time.sleep(5)
output = subprocess.check_output(["adb", "devices"])
serial = output.rsplit("\n")[1].rsplit("\t")[0].strip()
print "Device serial: %s" % serial
return serial
def _get_monitor_name(self):
output = subprocess.check_output(["adb", "shell", "dumpsys", "|", "findstr", "wifiP2pDevice=Device"], shell=True)
start_index = output.rfind('Device: ', 0)
start_index = start_index + 8
end_index = output.rfind("\n", 0)
name = output[start_index : end_index].strip()
return name
def is_mac_address(self, address):
boo = False
boo = self.automation_handle.exists(description='VideoView ' + address)
return boo
def reboot(self):
checkBootComp = subprocess.check_output('adb {} shell getprop sys.boot_completed'.format(self.serial))
print('start rebbot monitor')
os.system('adb {} reboot'.format(self.serial))
self.is_boot_completed(checkBootComp)
print('reboot monitor completed')
def is_boot_completed(self , bootCompCmd):
screenUp = '-1'
while screenUp != bootCompCmd:
time.sleep(1)
try:
screenUp = subprocess.check_output('adb {} shell getprop sys.boot_completed'.format(self.serial))
except Exception:
print('waiting for monitor' )
print('Screen up and fully loaded')
return True
def __init__(self, deviceserial):
'''
Constructor
'''
#sndLog = CLS("test", "test")
self.osType = sys.platform
self.mstrInfo = {}
#self.devSerials = self.instAdb.device_serial()
self.mstrDevice = Device(deviceserial)
self.mstrInfo = self.mstrDevice.info
def __init__(self,sn,app):
self.dev_sn = sn
self.device = Device(self.dev_sn)
self.dev_displayHeight = self.device.info['displayHeight']
self.dev_displayWidth = self.device.info['displayWidth']
self.icon_x = self.dev_displayWidth * 12 / 100
self.icon_y = self.dev_displayHeight * 52 / 100
self.is_app_settings_done = False
if len(app) > 0 and app[0] != '':
self.app_name = app[0]
if len(app) > 1 and app[1] != '':
self.app_path = app[1]
self.app_package_name = self.get_package_name()
self.install_app()
if len(app) > 2 and app[2] != '':
self.app_package_name = app[2]
else:
self.app_package_name = os.popen("adb -s %s shell pm list package | grep -i %s | awk -F ':' '{print$2}'"%(self.dev_sn,self.app_name)).read().strip("\r\n")
self.set_app_settings_done_flag()
self.clean_result()
self.load_resource()
def set_serial(self, serial):
"""Specify given *serial* device to perform test.
or export ANDROID_SERIAL=CXFS42343 if you have many devices connected but you don't use this
interface
When you need to use multiple devices, do not use this keyword to switch between devices in test execution.
And set the serial to each library.
Using different library name when importing this library according to
http://robotframework.googlecode.com/hg/doc/userguide/RobotFrameworkUserGuide.html?r=2.8.5.
Examples:
| Setting | Value | Value | Value |
| Library | UiTestLib | WITH NAME | Mobile1 |
| Library | UiTestLib | WITH NAME | Mobile2 |
And set the serial to each library.
| Test Case | Action | Argument |
| Multiple Devices | Mobile1.Set Serial | device_1's serial |
| | Mobile2.Set Serial | device_2's serial |
"""
self.d = Device(serial)
self.adb = Adb(serial)
def set_serial(self, android_serial):
"""
Specify given *android_serial* device to perform test.
You do not have to specify the device when there is only one device connects to the computer.
When you need to use multiple devices, do not use this keyword to switch between devices in test execution.
Using different library name when importing this library according to http://robotframework.googlecode.com/hg/doc/userguide/RobotFrameworkUserGuide.html?r=2.8.4#setting-custom-name-to-test-library.
| ==Setting== | ==Value== | ==Value== | ==Value== |
| Library | Mobile | WITH NAME | Mobile1 |
| Library | Mobile | WITH NAME | Mobile2 |
And set the serial to each library.
| Test Case | Action | Argument |
| Multiple Devices | Mobile1.Set Serial | device_1's serial |
| | Mobile2.Set Serial | device_2's serial |
"""
self.adb = ADB(android_serial)
self.device = Device(android_serial)
self.test_helper = TestHelper(self.adb)
from uiautomator import Device
from Repo import *
import time
from zservice import ZDevice
class TIMZoneAddFriends:
def __init__(self):
self.repo = Repo()
def action(self, d, z, args):
if (args["time_delay"]):
time.sleep(int(args["time_delay"]))
def getPluginClass():
return TIMZoneAddFriends
if __name__ == "__main__":
clazz = getPluginClass()
o = clazz()
d = Device("HT57FSK00089")
# material=u'有空聊聊吗'
z = ZDevice("HT57FSK00089")
# d.server.adb.cmd("shell", "ime set com.zunyun.qk/.ZImeService").wait()
args = {"repo_number_cate_id": "43", "repo_material_cate_id": "36", "add_count": "9",
"time_delay": "3"}; # cate_id是仓库号，length是数量
o.action(d, z, args)
d(className="android.view.View", description="删除 按钮").click()
z.input(name)
z.sleep(1)
d(text="完成").click()
break
z.sleep(2)
# d( text="返回", resourceId="com.tencent.tim:id/ivTitleBtnLeft" ).click( )
z.toast("TIM修改昵称(关键词)模块已完成")
if (args["time_delay"]):
time.sleep(int(args["time_delay"]))
def getPluginClass():
return TIMUpdateName
if __name__ == "__main__":
import sys
reload(sys)
sys.setdefaultencoding('utf8')
clazz = getPluginClass()
o = clazz()
d = Device("HT54VSK01061")
z = ZDevice("HT54VSK01061")
z.server.install()
d.server.adb.cmd("shell", "ime set com.zunyun.qk/.ZImeService").wait()
# args = {"repo_name_id": "211", "repo_key_word": "212", "repo_cate_wx_id": "118","repo_cate_qq_id":"132"}
args = {"repo_name_id": "211", "repo_key_word": "212", "time_delay": "3"}
o.action(d, z, args)
number_of_repeats = 1
start_ts = datetime.datetime.now()
start_ts_pst = str(
datetime.datetime.now(
pytz.timezone('US/Pacific')).strftime('"%m-%d-%y %H:%M:%S.%f"'))
print('test start: %s ' % start_ts_pst)
# print('serial: %s' % firstserial)
# print('number of repeats: %s' %number_of_repeats)
repeats = number_of_repeats # args.number_of_repeats
serial = firstserial # args.serial
try:
d = Device(serial)
print("Script Open Ajustes---------")
demo(d, serial)
print("Script Change wifi status---------")
wifi(d, serial, "ON")
# time.sleep(5)
except Exception as ex:
print(ex)
finally:
#stf_dev.release_device()
stop_ts = datetime.datetime.now()
stop_ts_pst = str(
datetime.datetime.now(pytz.timezone('US/Pacific')).strftime(
def get_phone_obj(self):
phone_serialNum = self.get_conf_value('phoneSerial')
return Device(phone_serialNum)
logger.setLevel(logging.DEBUG)
consolehandler = logging.StreamHandler()
consolehandler.setLevel(logging.DEBUG)
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
consolehandler.setFormatter(formatter)
logger.addHandler(consolehandler)
#package_pattern = re.compile(r'.*apk')
register_pattern = re.compile(r'.*(Regis|REGIS|Sign|SIGN).*')
fline_pattern = re.compile(r'(.*?).json')
dev = Device(series)
for fline in filelist:
if fline_pattern.match(fline) or re.search('(.py|data)', fline):
continue
#fmatch = package_pattern.match(fline)
#if not fmatch:
# continue
os.popen('adb devices')
before = appName()
os.popen('adb -s ' + series +' install ' + appdir + fline)
after = appName()
applist = after - before
if len(applist) != 1:
logger.info(fline)
logger.info(applist)
logger.info('error! not a single app selected!')
class Cases(unittest.TestCase):
def setUp(self):
self._driver = atx.connect()
self._device = Device()
def test_click(self):
self._driver.click(540, 1650)
self._driver.delay(2)
self._driver.press.home()
# self._driver.press("home")
self._driver.delay(1)
self._driver(description="Apps").click()
self._driver.delay(1)
self._driver.press.back()
# self._driver.press("back")
self._driver(text="Settings").long_click()
def test_press(self):
"""press:
home, back, left, right, up, down,
center, menu, search, enter, delete(or del),
recent, volume_up, volume_down, camera, power
"""
self._driver.press.volume_down()
self._driver.delay(1)
self._driver.press.volume_down()
self._driver.delay(1)
self._driver.press.volume_up()
self._driver.delay(1)
def test_screen(self):
self._device.screen.off()
self._driver.delay(2)
self._device.screen.on()
self._driver.delay(2)
self._device.sleep()
self._driver.delay(2)
self._device.wakeup()
def test_image(self):
self._driver.start_app("com.android.calculator2")
self._driver.delay(2)
if self._driver.exists("1.jpg"):
self._driver.click_image("1.jpg")
self._driver.delay(1)
else:
print "Not find image"
self._driver.screenshot("ttt.png")
self._driver.stop_app("com.android.calculator2")
def test_wait(self):
if self._driver(text="1").wait.exists(timeout=10000):
print "find it"
if self._driver(text="1").wait.gone(timeout=10000):
print "it gone"
def test_child(self):
self._driver(className="android.view.ViewGroup").child(
text="Phone").click()
self._driver.delay(1)
self._driver.press("home")
self._driver.delay(1)
self._driver(text="Phone").click()
self._driver.delay(1)
self._driver.press("back")
def test_instance(self):
# count, instance
# count = self._driver(className="android.widget.TextView").count
# print count
# self._driver(className="android.widget.TextView", instance=7).click()
# self._driver.press.home()
# self._driver.delay(1)
# self._driver(className="android.widget.TextView")[7].click()
# 计算器遍历
objs = self._driver(className="android.widget.Button")
for obj in objs:
obj.click()
def test_set_text(self):
# self._driver(resourceId="com.android.messaging:id/recipient_text_view").set_text("10086")
# self._driver.delay(1)
# self._driver.press.enter()
# self._driver(resourceId="com.android.messaging:id/recipient_text_view").clear_text()
# self._driver.delay(1)
# self._driver.type("10086", enter=False)
self._driver(resourceId="com.android.messaging:id/compose_message_text"
).long_click()
def test_drag(self):
self._driver(text="Settings").drag.to(950, 1000)
self._driver.delay(1)
self._driver(text="Settings").swipe.left(steps=100)
def test_swipe(self):
self._driver.swipe(1000, 1000, 500, 1000, steps=50)
self._driver.delay(1)
self._driver.swipe(500, 1000, 1000, 1000, steps=10)
def test_scroll(self):
self._driver(scrollable=True).scroll.to(text="Google")
print "find it"
def test_pinch(self):
# com.google.android.apps.photos:id/list_photo_tile_view
self._driver(
resourceId="com.google.android.apps.photos:id/list_photo_tile_view"
).pinch.Out()
self._driver.delay(1)
self._driver(
resourceId=
"com.google.android.apps.photos:id/photo_hashtag_fragment_container"
).pinch.In()
def test_cmd(self):
dev = self._driver.adb_cmd("devices")
mem = self._driver.adb_shell("dumpsys meminfo")
print dev
print mem
def test_relative(self):
self._driver(text="Cellular data").right(
className="android.widget.Switch").click()
#! /usr/bin/env python
# -*- coding: utf-8 -*-
import sys
import os
from uiautomator import Device
from common import *
def accept_device_admin_install(self):
d(resourceId="com.android.vending:id/positive_button").click()
if __name__ == '__main__':
d = Device()
# Press the HOME button to start the test from the home screen
d.press.home()
accept_device_admin_install(d)
class AdbDevice(object):
hiddenService = 'com.fuhu.settingshelper/.SettingsHelperService'
LIST_SYSTEM = 'system'
LIST_ALL = 'all'
LIST_3RD_PARTY = '3rd'
LIST_RECENT = 'recent'
orientation = ['natural', 'left', 'upsidedown', 'right']
def __init__(self, serialno=None):
self.lock = threading.Semaphore()
self.cmd = AdbCmd(serialno)
self.serialno = serialno
def connect(self):
self.d = Device(self.serialno)
self.d.orientation # notify to connect
# self.d, self.serialno = ViewClient.connectToDeviceOrExit(serialno=self.serialno)
# self.vc = ViewClient(self.d, self.serialno, compresseddump=False, ignoreuiautomatorkilled=True, autodump=False)
def startActivity(self, component):
component = component.replace('$', '\$')
self.cmd.shell(['am', 'start', '-n', component, '--activity-clear-task'])
def isConnected(self):
if self.__getDevices(self.serialno):
return True
else:
return False
def listPackages(self):
return self.cmd.shell(['pm', 'list', 'package'], output=True)
def reboot(self):
self.cmd.reboot()
def dump(self, compressed=False):
return self.d.dump(compressed=compressed).encode('utf-8')
@staticmethod
def retrieveSelector(point, selectors):
shortestDistance = 500000
result = None
for selector in selectors:
print selector.className
bounds = selector.info['bounds']
if bounds['right'] >= point[0] >= bounds['left'] and bounds['top'] >= point[1] >= bounds['bottom']:
return selector
for selector in selectors:
bounds = selector.info['bounds']
distance = (((bounds['left'] + bounds['top']) / 2 - point[0]) ** 2 + (
(bounds['left'] + bounds['bottom']) / 2 - point[1]) ** 2) ** 0.5
if shortestDistance > distance:
shortestDistance = distance
result = selector
return result
def checkSamePoint(self, point, info, isLongClick=False):
if not self.isScreenOn():
self.powerBtn()
if self.isLocked():
self.unlock()
if len(info) == 2:
if self.d.info['currentPackageName'] == info['packageName']:
self.cmd.shell(['input', 'tap', str(point[0]), str(point[1])])
return {'answer': True, 'reason': 'it is the navigation bar'}
else:
return {'answer': False, 'reason': 'unknown view'}
if info['content-desc'] != '':
uiObject = self.d(description=info['content-desc'])
if self.__checkIncludePoint(uiObject, point):
self.cmd.shell(['input', 'tap', str(point[0]), str(point[1])])
else:
uiObject.click()
return {'answer': True, 'reason': 'find by description'}
if info['text'] != '':
uiObject = self.d(text=info['text'])
if self.__checkIncludePoint(uiObject, point):
self.cmd.shell(['input', 'tap', str(point[0]), str(point[1])])
else:
uiObject.click()
return {'answer': True, 'reason': 'find by text'}
currentViewMap = self.getTouchViewInfo(point)
if currentViewMap:
if currentViewMap['package'] == info['package']:
if currentViewMap['class'] == info['class']:
self.d.click(point[0], point[1])
return {'answer': True, 'reason': 'Find the similar view'}
else:
return {'answer': False, 'reason': 'the view doesn\'t be found.'}
else:
return {'answer': False, 'reason': 'In the wrong page'}
else:
return {'answer': False, 'reason': 'the view can\'t be found.'}
@staticmethod
def __checkIncludePoint(uiObject, point):
bounds = uiObject.info['visibleBounds']
result, _ = AdbDevice._parseRange(point,
(int(bounds['top']), int(bounds['left'])),
(int(bounds['right']), int(bounds['bottom'])))
return result
@staticmethod
def removeKey(d, keys):
r = dict(d)
for k in keys:
if r.has_key(k):
del r[k]
return r
def __getDevices(self, serial):
outputRE = re.compile(serial)
devices = outputRE.findall(AdbCmd.devices())
if len(devices) > 0:
return devices[0]
def getTouchViewInfo(self, point, compressed=False):
smallestArea = sys.maxint
result = None
root = ET.fromstring(self.dump(compressed=compressed))
for node in root.iter('node'):
print node.get('bounds')
bounds = re.match('\[(?P<x1>[\d]+),(?P<y1>[\d]+)\]\[(?P<x2>[\d]+),(?P<y2>[\d]+)\]', node.get('bounds'))
if bounds:
isInclude, area = AdbDevice._parseRange(point,
(int(bounds.group('x1')), int(bounds.group('y1'))),
(int(bounds.group('x2')), int(bounds.group('y2'))))
if isInclude:
if area <= smallestArea:
smallestArea = area
result = node
if result is not None:
return result.attrib
elif point[1] > self.d.info['displayHeight']:
p = {'packageName': self.d.info['currentPackageName'], 'type': 'Navigation Bar'}
return p
@staticmethod
def getBoundsCenter(bounds):
bounds = re.match('\[(?P<x1>[\d]+),(?P<y1>[\d]+)\]\[(?P<x2>[\d]+),(?P<y2>[\d]+)\]', bounds)
x = (int(bounds.group('x2')) + int(bounds.group('x1'))) / 2
y = (int(bounds.group('y2')) + int(bounds.group('y1'))) / 2
return x, y
@staticmethod
def _parseRange(point, point1, point2):
if point1[0] <= point[0] <= point2[0] and point1[1] <= point[1] <= point2[1]:
area = (point2[0] - point1[0]) * (point2[1] - point1[1])
return True, area
else:
return False, None
def viewFilter(self, view):
if view.getClass() == self.viewClass:
return True
else:
return False
def screenOn(self, status):
if status == True:
self.d.screen.on()
else:
self.d.screen.off()
def clearLog(self):
self.cmd.shell(['logcat', '-c'])
def longClick(self, x, y, duration):
if y <= self.d.info['displayHeight']:
self.d.swipe(x, y, x, y, steps=duration / 10)
else:
self.cmd.shell(['input', 'tap', str(x), str(y)])
def click(self, x, y):
if y <= self.d.info['displayHeight']:
self.d.click(x, y)
else:
self.cmd.shell(['input', 'tap', str(x), str(y)])
def drag(self, x, y, duration):
self.d.drag(x[0], x[1], y[0], y[1], steps=duration / 10)
def swipe(self, x, y, duration):
self.cmd.shell(['input', 'swipe', str(x[0]), str(x[1]), str(y[0]), str(y[1]), str(duration)])
def type(self, text):
translate = re.sub(r'([#\(\)\&\*\'\\\"\~\`\|\<\>?\;])', r'\\\1', text)
self.cmd.shell(['input', 'text', translate])
# self.d(className="android.widget.EditText").set_text(text)
def hideKeyboard(self):
if self.isKeyboardShown():
self.backBtn()
def unlock(self):
if self.isLocked():
self.menuBtn()
def isLocked(self):
lockScreenRE = re.compile('mShowingLockscreen=(true|false)')
m = lockScreenRE.search(self.cmd.dumpsys(['window', 'policy']))
if m is not None:
return m.group(1) == 'true'
def isScreenOn(self):
screenOnRE = re.compile('mScreenOnFully=(true|false)')
m = screenOnRE.search(self.cmd.dumpsys(['window', 'policy']))
if m is not None:
return m.group(1) == 'true'
def powerBtn(self):
self.cmd.inputKeyevnt('POWER')
def backBtn(self):
self.cmd.inputKeyevnt('BACK')
def homeBtn(self):
self.cmd.inputKeyevnt('HOME')
def menuBtn(self):
self.cmd.inputKeyevnt('MENU')
# def rotate(self, orient):
# if orient == 'auto':
# self.d.freeze_rotation(False)
# elif orient == '0':
# self.d.orientation = 'n'
# elif orient == '90':
# self.d.orientation = 'l'
# elif orient == '180':
# self.d.freeze_rotation(True)
# self._setScreenOrient(2)
# elif orient == '270':
# self.d.orientation = 'r'
def rotate(self, orient):
self.d.freeze_rotation(True)
index = self.orientation.index(self.d.orientation)
if orient == 'left':
index -= 1
if index < 0:
self._setScreenOrient(len(self.orientation) - 1)
else:
self._setScreenOrient(index)
elif orient == 'right':
index += 1
if index >= len(self.orientation):
self._setScreenOrient(0)
else:
self._setScreenOrient(index)
def volumeUp(self):
self.cmd.inputKeyevnt('VOLUME_UP')
def volumeDown(self):
self.cmd.inputKeyevnt('VOLUME_DOWN')
# def _setAutoRotate(self, status):
# if status:
# self.cmd.shell(['content', 'insert', '--uri', 'content://settings/system', '--bind', 'name:s:accelerometer_rotation',
# '--bind', 'value:i:1'])
# time.sleep(1)
# self.cmd.shell(['content', 'insert', '--uri', 'content://settings/system', '--bind', 'name:s:accelerometer_rotation',
# '--bind', 'value:i:1'])
#
# else:
# self.cmd.shell(['content', 'insert', '--uri', 'content://settings/system', '--bind', 'name:s:accelerometer_rotation',
# '--bind', 'value:i:0'])
# time.sleep(1)
# self.cmd.shell(['content', 'insert', '--uri', 'content://settings/system', '--bind', 'name:s:accelerometer_rotation',
# '--bind', 'value:i:0'])
def _setScreenOrient(self, orient):
self.cmd.shell(['content', 'insert', '--uri', 'content://settings/system', '--bind', 'name:s:user_rotation',
'--bind', 'value:i:' + str(orient)])
def resetPackage(self, package):
self.cmd.shell(['pm', 'clear', package])
def takeSnapshot(self, path):
'''
screen capture in png format
:param path: saved file path
:return: None
'''
p1 = self.cmd.popen(['screencap', '-p'], stdout=PIPE)
p = Popen(['perl', '-pe', 's/\x0D\x0D\x0A/\x0A/g'], stdin=p1.stdout, stdout=PIPE)
out, error = p.communicate()
ba = QByteArray.fromRawData(out)
img = QImage.fromData(ba, 'PNG')
orient = self.getCurrDisplay()['orientation']
if orient == 1:
img = img.transformed(QMatrix().rotate(-90))
elif orient == 2:
img = img.transformed(QMatrix().rotate(-180))
elif orient == 3:
img = img.transformed(QMatrix().rotate(-270))
img.save(path, 'PNG')
def getCurrDisplay(self):
output = self.cmd.dumpsys(['display'])
match = re.search('mCurrentOrientation=(?P<orientation>[\d])[\w\d\s\(\),-=]+'
+ 'mCurrentDisplayRect=Rect\(0, 0 - (?P<width>[\d]+),\s+(?P<height>[\d]+)', output)
if match:
width = int(match.group('width'))
height = int(match.group('height'))
orientation = int(match.group('orientation'))
mode = 'landscape' if width > height else 'portrait'
return {'width': width, 'height': height, 'orientation': orientation, 'mode': mode}
def getRealDisplay(self):
output = self.cmd.dumpsys(['display'])
match = re.search('real\s(?P<width>[\d]+)\sx\s(?P<height>[\d]+)', output)
return {'width': int(match.group('width')), 'height': int(match.group('height'))}
def getProp(self, propType=None):
if propType:
return self.cmd.getProp(propType)
else:
return self.cmd.getProp(propType)
def uninstall(self, package):
self.cmd.uninstall(package)
def install(self, name):
self.cmd.install(name)
def close(self):
pass
def checkConnected(self):
return self.d.checkConnected()
def extractComponentName(self, packageName):
if packageName == 'com.google.android.youtube':
return 'com.google.android.youtube/.app.honeycomb.Shell$HomeActivity'
output = self.cmd.dumpsys(['package', packageName])
try:
if os.name == 'nt':
splitOutput = output.split('\r\r\n')
else:
splitOutput = output.split('\r\n')
num = splitOutput.index(next(x for x in splitOutput if x.find('android.intent.action.MAIN:') != -1))
if num != -1:
print splitOutput[num + 1]
return splitOutput[num + 1].split()[1]
else:
return None
except:
return None
def screenTimeout(self):
timeout = self.cmd.getSettings(['system', 'screen_off_timeout'])
return long(timeout) / 1000
def setScreenTimeout(self, value):
self.cmd.putSettings(['system', 'screen_off_timeout', value])
def isNfcOn(self):
match = re.search('mState=(on|off)', self.cmd.dumpsys(['nfc']))
if match:
if match.group(1) == 'on':
return True
else:
return False
else:
return False
def isAirPlaneModeOn(self):
match = re.search('(0|1)', self.cmd.getSettings(['global', 'airplane_mode_on']))
if match:
if match.group(1) == '1':
return True
else:
return False
def isInstallUnknownSources(self):
match = re.search('(0|1)', self.cmd.getSettings(['global', 'install_non_market_apps']))
if match:
if match.group(1) == '1':
return True
else:
return False
def isKeyboardShown(self):
output = self.cmd.dumpsys(['input_method'])
result = re.search('mInputShown=(true|false)', output)
if result.group(1) == 'true':
return True
else:
return False
def isWifiOn(self):
match = re.search('(0|1)', self.cmd.getSettings(['global', 'wifi_on']))
if match:
if match.group(1) == '1':
return True
else:
return False
def isBtOn(self):
match = re.search('(0|1)', self.cmd.getSettings(['global', 'bluetooth_on']))
if match:
if match.group(1) == '1':
return True
else:
return False
def isNoKeepActivityOn(self):
match = re.search('(0|1)', self.cmd.getSettings(['global', 'always_finish_activities']))
if match:
if match.group(1) == '1':
return True
else:
return False
def isDataRoamingOn(self):
match = re.search('(0|1)', self.cmd.getSettings(['global', 'data_roaming']))
if match:
if match.group(1) == '1':
return True
else:
return False
def isAutoRotateOn(self):
match = re.search('(0|1)', self.cmd.getSettings(['system', 'accelerometer_rotation']))
if match:
if match.group(1) == '1':
return True
else:
return False
def isGpsOn(self):
state = self.cmd.getSettings(['secure', 'location_providers_allowed'])
if state == 'none':
return False
else:
return True
def isAutoBrightnessOn(self):
match = re.search('(0|1)', self.cmd.getSettings(['system', 'screen_brightness_mode']))
if match:
if match.group(1) == '1':
return True
else:
return False
def isVibrateWhenRingOn(self):
match = re.search('(0|1)', self.cmd.getSettings(['system', 'vibrate_when_ringing']))
if match:
if match.group(1) == '1':
return True
else:
return False
else:
return False
def isWindowAniOn(self):
match = re.search('(0.0|1.0)', self.cmd.getSettings(['global', 'window_animation_scale']))
if match:
if match.group(1) == '0.0':
return True
else:
return False
else:
return False
def isTransitionAnuOn(self):
match = re.search('(0.0|1.0)', self.cmd.getSettings(['global', 'transition_animation_scale']))
if match:
if match.group(1) == '0.0':
return True
else:
return False
else:
return False
def isDurationAniOn(self):
match = re.search('(0.0|1.0)', self.cmd.getSettings(['global', 'animator_duration_scale']))
if match:
if match.group(1) == '0.0':
return True
else:
return False
else:
return False
def enableWifi(self, state):
if state:
self.cmd.shell(['am', 'startservice', '--ez', 'wifi', 'true', '-n',
self.hiddenService])
else:
self.cmd.shell(['am', 'startservice', '--ez', 'wifi', 'false', '-n',
self.hiddenService])
def enableBluetooth(self, state):
if state:
self.cmd.shell(['am', 'startservice', '--ez', 'bt', 'true', '-n',
self.hiddenService])
else:
self.cmd.shell(['am', 'startservice', '--ez', 'bt', 'false', '-n',
self.hiddenService])
def enableInstallUnknownSources(self, state):
if state:
self.cmd.putSettings(['global', 'install_non_market_apps', '1'])
else:
self.cmd.putSettings(['global', 'install_non_market_apps', '0'])
def enableNfc(self, state):
if state:
self.cmd.shell(['service', 'call', 'nfc', '6'])
else:
self.cmd.shell(['service', 'call', 'nfc', '5'])
def enableNoKeepActivity(self, state):
if state:
self.cmd.putSettings(['global', 'always_finish_activities', '1'])
else:
self.cmd.putSettings(['global', 'always_finish_activities', '0'])
def enableDataRoaming(self, state):
if state:
self.cmd.putSettings(['global', 'data_roaming', '1'])
else:
self.cmd.putSettings(['global', 'data_roaming', '0'])
def enableAutoRotate(self, state):
if state:
self.cmd.putSettings(['system', 'accelerometer_rotation', '1'])
else:
self.cmd.putSettings(['system', 'accelerometer_rotation', '0'])
def enableGps(self, state):
if state:
self.cmd.putSettings(['secure', 'location_providers_allowed', 'gps,network'])
else:
self.cmd.putSettings(['secure', 'location_providers_allowed', 'none'])
def enableAutoBrightness(self, state):
if state:
self.cmd.putSettings(['system', 'screen_brightness_mode', '1'])
else:
self.cmd.putSettings(['system', 'screen_brightness_mode', '0'])
def enableVibrateRinging(self, state):
if state:
self.cmd.putSettings(['system', 'vibrate_when_ringing', '1'])
else:
self.cmd.putSettings(['system', 'vibrate_when_ringing', '0'])
def enableVibrateWhenRing(self, state):
if state:
self.cmd.putSettings(['system', 'vibrate_when_ringing', '1'])
else:
self.cmd.putSettings(['system', 'vibrate_when_ringing', '0'])
def enableWindowAnimator(self, state):
if state:
self.cmd.putSettings(['global', 'window_animation_scale', '1.0'])
else:
self.cmd.putSettings(['global', 'window_animation_scale', '0.0'])
def enableTransitionAnimator(self, state):
if state:
self.cmd.putSettings(['global', 'transition_animation_scale', '1.0'])
else:
self.cmd.putSettings(['global', 'transition_animation_scale', '0.0'])
def enableDurationAnimation(self, state):
if state:
self.cmd.putSettings(['global', 'animator_duration_scale', '1.0'])
else:
self.cmd.putSettings(['global', 'animator_duration_scale', '0.0'])
def enableAirplaneMode(self, state):
if state:
self.cmd.putSettings(['global', 'airplane_mode_on', '1'])
self.cmd.shell(['am', 'broadcast', '-a', 'android.intent.action.AIRPLANE_MODE', '--ez', 'state', 'true'])
else:
self.cmd.putSettings(['global', 'airplane_mode_on', '0'])
self.cmd.shell(['am', 'broadcast', '-a', 'android.intent.action.AIRPLANE_MODE', '--ez', 'state', 'false'])
def requestPackage(self, t):
result = None
if t == self.LIST_ALL:
result = self.cmd.shell(['pm', 'list', 'packages'], output=True)
elif t == self.LIST_SYSTEM:
result = self.cmd.shell(['pm', 'list', 'packages', '-s'], output=True)
elif t == self.LIST_3RD_PARTY:
result = self.cmd.shell(['pm', 'list', 'packages', '-3'], output=True)
if result:
packages = result.split('\r\n')
packages.remove('')
packages.sort()
return packages
def getSerialNumber(self):
return self.serialno
self.uninstallApp("com.github.uiautomator")
self.pushFile("jar\\" + jarFile, "/data/local/tmp/" + jarFile)
if self.sn == None:
cmd = "adb shell uiautomator runtest " + jarFile + " --nohup -c com.power.test.testCase#" + testCase
else:
cmd = "adb -s %s " % self.sn + "shell uiautomator runtest " + jarFile + " --nohup -c com.power.test.testCase#" + testCase
print(cmd)
subprocess.Popen(cmd,
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
time.sleep(2)
def clickWatcher(self, *args, **keyargs):
watcherName = str(*args)
d.watcher(watcherName).when(**keyargs).click(**keyargs)
return watcherName
# print(d.watchers)
# print(d.watchers.triggered)
def removeWatcher(self, name):
d.watcher(name).remove()
print(d.watchers)
if __name__ == "__main__":
# Common().clickWatcher("CON",text="继续")
# Common().clickByText("123")
print(Device().watchers)
Common().removeWatcher("TEST")
"""
Keeps Android from falling asleep (warm!)
by tapping every five seconds
Usage:
python warm.py [adb device id]
"""
import sys
import os
import time
from uiautomator import Device
DEVICE_NAME = sys.argv[1]
d = Device(DEVICE_NAME)
d.wakeup()
os.system("adb shell content insert --uri content://settings/system --bind name:s:user_rotation --bind value:i:0")
while True:
d.click(100, 100)
time.sleep(5)
if response.status_code == 200:
data = response.text
numbers = json.loads(data)
return numbers
else:
return []
def getPluginClass():
return QQEmailReply
if __name__ == "__main__":
clazz = getPluginClass()
o = clazz()
d = Device("37f7b82f")
z = ZDevice("37f7b82f")
d.server.adb.cmd("shell",
"ime set com.zunyun.qk/.ZImeService").communicate()
args = {
"repo_material_cateId": "382",
"time_delay": "3",
'random_code': "不乱码",
'domain': "http://192.168.1.108:8888"
}
# Str = d.info # 获取屏幕大小等信息
# height = int( Str["displayHeight"] )
# width = int( Str["displayWidth"] )
# o.input(z,height,"扎广泛的烦恼")
o.action(d, z, args)
# if d( descriptionContains="Re").exists:
z.heartbeat()
if (args["time_delay"]):
z.sleep(int(args["time_delay"]))
def getPluginClass():
return WeiXinSentMoments
if __name__ == "__main__":
import sys
reload(sys)
sys.setdefaultencoding('utf8')
clazz = getPluginClass()
o = clazz()
d = Device("HT4A1SK02114")
z = ZDevice("HT4A1SK02114")
z.server.install()
d.server.adb.cmd("shell", "ime set com.zunyun.qk/.ZImeService").communicate()
args = {"repo_material_id": "257","run_time": "1","time_delay": "3"} #cate_id是仓库号，length是数量
o.action(d,z, args)
import GlobalConfig
# Serial id of DUT
deviceId = GlobalConfig.MasterDeviceId
# Dynamically import the specified model folder and files
UnitModule = Utils.loadDeviceSpecificModule()
Config = UnitModule.Config2()
Config.Browser['text'] = "Chromium"
logger = Logger.Logger('Engineering_Browser', deviceId, GlobalConfig.LogPath)
OS_version = GlobalConfig.MasterAndroidVersion
# setUp(self):
input = Device(deviceId)
unitUD = UnitModule.UnitUD(input, deviceId, logger)
browserUD = UnitModule.BrowserUD(input, deviceId, logger)
# ==================================================================================#
"""
| **Objective** : Visit AT&T website & clear cache
| **Related Bug/Story Id** : ETGA-290
| **Test Type** : Engineering
| **Test Area(s)** : Browser
| **Required Accessories** : None
#coding=utf-8 #from uiautomator import device as d from uiautomator import Device import unittest import os import time import commands import random deviceId = '43adc807' d = Device(deviceId) screen_x = 2560 screen_y = 1440 TEST_CYCLE = 500 launcher_p = 'com.lvr.launcher' local_video_p = 'com.lvr.player' game_center_p = 'com.lvr.gamecenter' gallery_p = 'com.lvr.gallery' settings_p = 'com.lvr.settings' super_lvr_p = 'com.lvr.superlvrpro' # pass_through_p = 'com.lvr.passthrough' launcher_a = launcher_p + '/com.lvr.launcher.VRLauncherActivity --es pkgName com.lvr.wizzard' local_video_a = local_video_p + '/com.lvr.player.activity.LocalVideoLoadActivity' game_center_a = game_center_p + '/com.lvr.gamecenter.activity.GameCenterMainActivity' gallery_a = gallery_p + '/com.lvr.gallery.LvrGalleryActivity' settings_a = settings_p + '/com.lvr.settings.SettingsActivity --es pkgName com.lvr.wizzard' super_lvr_a = super_lvr_p + '/com.lvr.superlvrpro.vr.VRChannelActivity'
# -*- coding: utf-8 -*-
'''
Created on 2014/3/31
@author: YuMing
'''
from uiautomator import Device
import time
import datetime
import os
if __name__ == '__main__':
print 'start'
# output_dir = 'C'
# ts = time.time()
# st = datetime.datetime.fromtimestamp(ts).strftime('%Y%m%d%H%M%S')
# screenshot_path = '%s%s%s' % (output_dir, os.sep, st)
# print screenshot_path
d = Device('0489902425228ab9')
d.orientation = "upsidedown"
# print len(d(descriptionContains='Sync'))
print 'end'
def qianEnterExit(self):
dev = Device(self.Id)
try:
for temp6 in range(1000):
print('%sqianEnterExit' % (temp6 + 1))
dev(text='相机').click()
time.sleep(2)
dev(resourceId=
'com.freeme.camera:id/camera_toggle_button'
).click()
time.sleep(2)
dev.screenshot(
r'%s/screenshot/%sqianEnterExit.png'
% (self.Id, (temp6 + 1)))
time.sleep(1)
os.system(
'adb shell input keyevent BACK')
os.system(
'adb shell input keyevent BACK')
os.system(
'adb shell input keyevent HOME')
time.sleep(1)
except Exception, e:
print('error', e)
dev.screenshot(
r'%s/error/errorqianEnterExit.png' %
(self.Id))
os.system('adb shell input keyevent BACK')
os.system('adb shell input keyevent BACK')
os.system('adb shell input keyevent HOME')
# 前后摄切换
def FrontRear(self):
dev = Device(self.Id)
try:
dev(text='相机').click()
time.sleep(2)
for temp6 in range(1000):
print('%sFrontRear' %
(temp6 + 1))
dev(resourceId=
"com.freeme.camera:id/camera_toggle_button"
).click()
time.sleep(2)
dev(resourceId=
"com.freeme.camera:id/camera_toggle_button"
).click()
time.sleep(2)
dev.screenshot(
r'%s/screenshot/%sFrontRear.png'
% (self.Id, (temp6 + 1)))
time.sleep(1.5)
except Exception, e:
print('error', e)
dev.screenshot(
r'%s/error/errorFrontRear.png'
% (self.Id))
os.system(
'adb shell input keyevent BACK'
)
os.system(
'adb shell input keyevent BACK'
)
os.system(
'adb shell input keyevent HOME'
)
def uiandroid():
from uiautomator import Device
d = Device('192.168.1.100:5555')
print(d.info)
if d( text='启用该功能' ).exists:
#返回到功能界面，继续进行下一个功能的关闭
d.click( 30, 72 )
z.sleep( 1 )
elif d(text='启用该功能').exists:
d.click( 30, 72 )
z.sleep( 1 )
else:continue
def getPluginClass():
return WeiXinCloseUnnecessary2
if __name__ == "__main__":
import sys
reload( sys )
sys.setdefaultencoding( 'utf8' )
clazz = getPluginClass( )
o = clazz( )
d = Device( "HT54VSK00608" ) # INNZL7YDLFPBNFN7
z = ZDevice( "HT54VSK00608" )
# z.server.install()
d.server.adb.cmd( "shell", "ime set com.zunyun.qk/.ZImeService" ).communicate( )
'dingdingdingdingdindigdingdingdingdingdingdingdingdingdingdingdingdignin'
repo = Repo( )
# repo.RegisterAccount('', 'gemb1225', '13045537833', '109')
args = {"repo_information_id": "189", "repo_material_id": "167"} # cate_id是仓库号，发中文问题
saveCate = args['repo_information_id']
o.action( d, z, args )
def connect(self):
self.d = Device(self.serialno)
self.d.orientation # notify to connect
def main():
keepBeforeRecord = False
restartEmul = False
reinstallApp = True
test = False ####for debug
paral = False
train = True ####half and half
#model.save("keras_mode.h5")
#port='5554'
#cmd="/home/yu/adt-bundle-linux-x86_64-20140702/sdk/platform-tools/adb -s emulator-"+port+" logcat -d"
#logText=commands.getstatusoutput(cmd)
#################
batch_size = 30
init_step = 5
############inital
apkList = []
for folderName in os.listdir(
"/SPACE/reforce-project/dataset/train/unfinished"):
sourceCodePath = "/SPACE/reforce-project/dataset/train/unfinished/" + folderName + "/bin/"
source = "/SPACE/reforce-project/dataset/train/unfinished/" + folderName
destination = "/SPACE/reforce-project/dataset/train/finished/" + folderName
apkFile, coverageEm, packageName, activityName = ENV.compileApkEmma(
sourceCodePath, commands, os)
apkList.append((apkFile, coverageEm, packageName, activityName,
sourceCodePath, source, destination))
port = '5554'
#d = Device('emulator-'+port)
#time.sleep(4)
address = '.'
'''
packageName="bander.notepad"
activityName="bander.notepad.NoteList"
apkName="notepad_debug.apk"
'''
##############agent
###word embeding
word2VecModel = Word2Vec.load('yumodel').wv
wordVectorLen = 400 #this is yumodel's len size
neighborLen = 10 #this is neighbor list's length
word2Idx, wordEmbeddings = DQNAgent.build_embed(word2VecModel,
wordVectorLen)
###############start app
#cmd="/home/yu/adt-bundle-linux-x86_64-20140702/sdk/platform-tools/adb -s emulator-"+port+" shell am start -S -n "+packageName+"/"+activityName
#commands.getstatusoutput(cmd)
#avaiableAnotherList=["com.android.documentsui"]
##############
apkCount = 0
#agent = DQNAgent.DQNAgentClass( wordEmbeddings, neighborLen)############need to modification
matrixDict = {}
for apkItem in apkList:
if not train: #test
shutil.copyfile("./model/keras_model_half.h5",
"./model/keras_model.h5")
crashID = 0
eventNum = [0]
importantButton = []
for iteTime in range(0, 1):
countReward = 0
#psutil.virtual_memory()
'''
outputFile = open("./testRecords/trainRecord"+str(iteTime)+".txt", 'a')
outputFile.write("memory: "+str(psutil.virtual_memory())+"\n")
outputFile.write("#####################"+"\n")
outputFile.close()
'''
gc.collect()
'''
outputFile = open("./testRecords/trainRecord"+str(iteTime)+".txt", 'a')
outputFile.write("memory: "+str(psutil.virtual_memory())+"\n")
outputFile.write("#####################"+"\n")
#outputFile.write(str(objgraph.show_growth())+"\n")
outputFile.close()
'''
agent = DQNAgent.DQNAgentClass(
wordEmbeddings, neighborLen,
matrixDict) ############need to modification
recordMiddleList = []
#simiarMap={}
agent.memory = {} ###### brent's suggestion
############################3
resultId = 0
lastResultId = -1000 #### check the same page
############generate a record root in every apk
recordDoc = Document()
recordRoot = recordDoc.createElement("recdrodRoot")
###test
if keepBeforeRecord:
doc = minidom.parse(address + '/middleResults/record.xml')
recordRoot = doc.documentElement
###test end
doc_write = Document()
doc_write.appendChild(recordRoot)
with codecs.open(address + "/middleResults/record.xml", "wb",
"utf-8") as out:
doc_write.writexml(out)
out.close()
if restartEmul:
ENV.restartAndroidEumlator(
port, commands) # for the text close
'''
outputFile = open("./testRecords/trainRecord"+str(iteTime)+".txt", 'a')
outputFile.write("memory: "+str(psutil.virtual_memory())+"\n")
outputFile.write("#####################"+"\n")
outputFile.close()
'''
cmd = "/home/yu/adt-bundle-linux-x86_64-20140702/sdk/platform-tools/adb shell dumpsys window displays | grep 'init'"
tupleLine = commands.getstatusoutput(cmd)
while (True):
try:
heightAndWeight = tupleLine[1].strip().split(" ")[0].split(
"=")[1]
height = int(heightAndWeight.split("x")[1])
weight = int(heightAndWeight.split("x")[0])
break
except:
print("waitForEmu")
continue
####################install apk
apkName = apkItem[0]
coverageEm = apkItem[1]
packageName = apkItem[2]
activityName = apkItem[3]
sourceCodePath = apkItem[4]
source = apkItem[5]
destination = apkItem[6]
recordNameCrash = source.rsplit("/", 1)[1]
d = Device('emulator-' + port)
if reinstallApp:
cmd = "/home/yu/adt-bundle-linux-x86_64-20140702/sdk/platform-tools/adb -s emulator-" + port + " uninstall " + packageName
commands.getstatusoutput(cmd)
cmd = "/home/yu/adt-bundle-linux-x86_64-20140702/sdk/platform-tools/adb -s emulator-" + port + " install " + apkName
commands.getstatusoutput(cmd)
specChar = False
actionIndex = None
feature = None
lastFeature = None
lastActionIndex = None
appCloseTag = False
lastFeatureTuple = None
crashTag = False
logHistory = ""
######################################coverage data
lineCoverage = 0
methodCoverage = 0
classCoverage = 0
coverageData = [lineCoverage, methodCoverage,
classCoverage] #class is not the activity coverage
####################clean sdcard
ENV.cleanSd(commands, port)
start = time.time()
apkCount += 1
lastEventInRecord = None
lastSimilarEleList = []
restartTag = False
finishTag = [1]
crashedIntentStr = "init"
coverageRecord = []
for iterCount in range(10000):
coverageRecord.append(coverageData[0])
print(matrixDict)
#menuTag=False
#adb -s emulator-5556 shell rm -r sdcard/*
print("apkCount:" + str(apkCount))
####################3every apk only train 2 hours
end = time.time()
if end - start > 1200: #1200:
break
print("iterCount:" + str(iterCount))
print("currentReward" + str(countReward))
if not iterCount == 0: #it is the first time
##################clean
cmd = "/home/yu/adt-bundle-linux-x86_64-20140702/sdk/platform-tools/adb -s emulator-" + port + " logcat -c"
commands.getstatusoutput(cmd)
#ENV.step(actionIndex, d, feature, commands, address, port, apkName, packageName, activityName,specChar, eventNum)
try:
#run
ENV.step(actionIndex, d, feature, commands, address,
port, apkName, packageName, activityName,
specChar, eventNum)
except:
d.press.back()
eventNum[0] = eventNum[0] + 1
print("except to click back")
'''
if len(crashedIntentStr)>3:
print("bingo")
'''
#send a random intent
intentIter = False
selectedStr = ""
if iterCount % 10 == 0:
selectedStr = ""
#cmd="python /SPACE/stoat/Stoat-master/Stoat/trigger/tester.py -s emulator-5554 -f "+apkName+" -p random " + "-c "+crashedIntentStr
cmd = "python /home/yu/workspace2/rf-android/trigger/tester.py -s emulator-5554 -f " + apkName + " -p random " + "-c " + crashedIntentStr
intent = commands.getstatusoutput(cmd)
intentStr = intent[1]
if "tagAAA" in intentStr:
a = intentStr.index("tagAAA")
b = intentStr.index("endAAA")
selectedStr = intentStr[a + 7:b]
print(intentStr)
'''
outputFile = open("./trainResult/"+recordNameCrash+"_intent_"+".txt", 'a')
outputFile.write("intentStr: "+intentStr+"\n")
outputFile.write("crashedIntentStr: "+str(crashedIntentStr)+"\n")
outputFile.close()
'''
intentIter = True
#################check crash
cmd = "/home/yu/adt-bundle-linux-x86_64-20140702/sdk/platform-tools/adb -s emulator-" + port + " logcat -d"
logText = commands.getstatusoutput(cmd)
logText = logText[1]
if "FATAL" in logText or "fatal" in logText:
if intentIter and selectedStr:
crashedIntentStr += selectedStr + "***"
#logText=
crashID += 1
ENV.writeCrash(logText, recordNameCrash, crashID,
eventNum)
logBoolean, newLogAdd, specOut = ENV.checkBefore(
logText, logHistory)
if specOut == True and specChar == False:
specChar = True
if not logBoolean:
crashTag = True
#ENV.writeCrash(logText,iterCount)
logHistory += newLogAdd
eventNum[0] = eventNum[0] + 1
className = ENV.restartApp(port, commands,
packageName,
activityName)
print("catch a crash and restart app")
else:
crashTag = False
className = ENV.restartApp(port, commands,
packageName,
activityName)
eventNum[0] = eventNum[0] + 1
print("catch a crash and restart app")
else:
crashTag = False
cmd = "/home/yu/adt-bundle-linux-x86_64-20140702/sdk/platform-tools/adb -s emulator-" + port + " shell dumpsys window windows | grep -E 'mFocusedApp'"
tupleLine = commands.getstatusoutput(cmd)
className = str(tupleLine).split(" ")[-2]
if not packageName in tupleLine[
1] and not "com.android" in tupleLine[
1] or "com.android.launcher" in tupleLine[1]:
appCloseTag = True
className = ENV.restartApp(port, commands, packageName,
activityName)
restartTag = True
eventNum[0] = eventNum[0] + 1
else:
appCloseTag = False
root_Result, notEmpty, loading = ENV.dumpTrans(
d, address, minidom, os, Trans, packageName, className,
commands, port)
if notEmpty == False:
if loading == 1:
for iterTimes in range(0, 20):
if notEmpty == False: ####may be dump at a middle page
time.sleep(0.4)
root_Result, notEmpty, loading = ENV.dumpTrans(
d, address, minidom, os, Trans,
packageName, className, commands, port)
print(
"dumped a empty and loading page, so repeat dump"
+ str(iterTimes))
else:
break
else:
#permitOtherApp="anypackageisok"
#otherRoot_Result, notEmpty, loading=ENV.dumpTrans(d, address, minidom, os, Trans, permitOtherApp, className, commands, port)
ENV.expOtherApp(
d, height,
weight) ####just random find one to click
eventNum[0] = eventNum[0] + 10
for iterTimes in range(0, 5):
cmd = "/home/yu/adt-bundle-linux-x86_64-20140702/sdk/platform-tools/adb -s emulator-" + port + " shell dumpsys window windows | grep -E 'mFocusedApp'"
tupleLine = commands.getstatusoutput(cmd)
if not packageName in tupleLine[1]:
print(iterTimes)
d.press.back()
d.wait.update()
time.sleep(0.5)
else:
className = str(tupleLine).split(" ")[-2]
break
if iterTimes == 4:
print("restart")
className = ENV.restartApp(
port, commands, packageName, activityName)
eventNum[0] = eventNum[0] + 1
restartTag = True
break
root_Result, notEmpty, loading = ENV.dumpTrans(
d, address, minidom, os, Trans, packageName,
className, commands, port)
##########################remove
os.remove(address + '/middleResults/result.xml')
#Similar.findComplement(recordRoot,root_Result,sameEvent, similarEventList)
#######################compare similarity
sameEvent, similarEventList, sameResultListMiddle, similarResultListMiddle = Similar.getSimilar(
recordRoot, root_Result)
######################extract feature
feature = Feature.FeatureClass(root_Result,
sameResultListMiddle,
similarResultListMiddle,
sameEvent, similarEventList)
featureStepNum = len(feature.runableList)
textFeatue = Feature2Digit.textFeature2Digit(
feature, word2Idx) ####just encode to the word ID
sameFeature, similarFeature = Feature2Digit.sameFeatureExtract(
feature)
#neighborFeatureList=Similar.findNeighbor(recordRoot,root_Result,sameEvent, similarEventList, featureStepNum)
neighborFeatureList = Similar.findNeighborCount(
recordRoot, sameEvent, featureStepNum, neighborLen)
###########################
featureTuple = (
textFeatue, sameFeature, similarFeature,
neighborFeatureList
) #########generate feature for machine learning input
######################run model
#actionIndex, timeCost=agent.actMatrix(featureTuple, iterCount, test)
if np.random.rand() <= 0.2:
test = True
actionIndex, timeCost = agent.act(featureTuple, iterCount,
test)
if test:
break
#actionIndex=np.argmax(action)
#actionIndex=3
print("actionIndex: " + str(actionIndex))
##########################recordRoot
if sameEvent and sameEvent.getAttribute("id") == lastResultId:
sameBefore = True
else:
sameBefore = False
#Similar.addToRecordRoot(recordRoot, root_Result,resultId,feature,featureStepNum,actionIndex,sameEvent, similarEventList)
####
lastEventInRecord, lastSimilarEleList, lastResultId, transferChanged, resultEventRecord = Similar.addToRecordRoot(
recordRoot, root_Result, resultId, feature, featureStepNum,
actionIndex, sameEvent, similarEventList,
lastEventInRecord, restartTag, lastSimilarEleList)
############################record into file
doc_write = Document()
doc_write.appendChild(recordRoot)
'''
with codecs.open(address+"/middleResults/record.xml","wb","utf-8") as out:
doc_write.writexml(out)
out.close()
'''
############################################
########################add page ID
resultId += 1
##################run
#className=ENV.step(actionIndex, d, feature, commands, address, port)
##################memorize and update model, this part can be implemented parallel with run
if iterCount == 0: #it is the first time
lastFeature = feature
lastActionIndex = actionIndex
else:
####################updateLast FeatureTuple
#lastNeighborFeatureList=Similar.findNeighborCount(recordRoot,lastResultEventRecord, lastFeatureStepNum, neighborLen)
#lastFeatureTuple=(lastFeatureTuple[0],lastFeatureTuple[1],lastFeatureTuple[2],lastNeighborFeatureList)
#######333test reward
'''
lastSimArray=np.array(lastFeatureTuple[2])[:,0]
if lastSimArray[lastActionIndex]==0:
reward=5
else:
reward=-2
'''
##################################
#reward=Similar.computeRewardSimilar(feature)not good
#test reward
#reward=
#ENV.computeRewardCoverage(commands, port, sourceCodePath, coverageData)
reward = ENV.computeRewardCoverage(commands, port,
sourceCodePath,
coverageData)
'''
if reward==5:
importStr=Similar.checkImportant(lastFeatureTuple, lastActionIndex, lastFeature)
'''
'''
if crashTag:#######good catch
#reward=10
reward=5
'''
countReward += reward
if not transferChanged:
agent.memorize(lastFeatureTuple, lastActionIndex,
reward, featureTuple)
testLastTuple = (lastFeatureTuple, lastActionIndex,
reward, featureTuple)
#################train DQN
if iterCount > 0:
if paral:
while True:
if finishTag[0] == 1:
finishTag = [0]
break
t = threading.Thread(
target=func,
args=(batch_size,
len(lastFeature.runableList),
Feature2Digit, word2VecModel,
word2Idx, testLastTuple,
recordMiddleList, agent, finishTag,
sameBefore, iterCount, iteTime,
recordNameCrash))
t.start()
else:
func(batch_size, len(lastFeature.runableList),
Feature2Digit, word2VecModel, word2Idx,
testLastTuple, recordMiddleList, agent,
finishTag, sameBefore, iterCount, iteTime,
recordNameCrash)
else:
print("transferChanged")
#t.isAlive()
#agent.replay(batch_size, len(lastFeature.runableList),Feature2Digit,word2VecModel,word2Idx, testLastTuple, recordMiddleList)
lastFeature = feature
lastFeatureTuple = featureTuple
lastActionIndex = actionIndex
#lastResultEventRecord=resultEventRecord
#lastFeatureStepNum=featureStepNum
###
while True:
if finishTag[0] == 1:
finishTag = [0]
break
#del agent
#gc.collect()
dest = shutil.move(source, destination) # for the test
className='android.widget.LinearLayout',
index=1).child(
className='android.widget.TextView',
index=0)
if obj1.exists: # 实现精准滑动后有的能显示第０列的电话号码，有的显示不出来
i = 0
continue
else:
i = 1
continue
def getPluginClass():
return WXAddresslistDepost
if __name__ == "__main__":
import sys
reload(sys)
sys.setdefaultencoding('utf8')
clazz = getPluginClass()
o = clazz()
d = Device("5959d2f3")
z = ZDevice("5959d2f3")
z.server.install()
d.server.adb.cmd("shell",
"ime set com.zunyun.qk/.ZImeService").communicate()
args = {"time_delay": "3"} #cate_id是仓库号，length是数量
o.action(d, z, args)
# if d( text="重选" ).exists:
# d( text="重选" ).click( )
# d( index=0, className="com.tencent.widget.GridView",
# resourceId="com.tencent.tim:id/photo_list_gv" ).child( index=0,
# className="android.widget.RelativeLayout" ).click( )
# d( text='确定', resourceId='com.tencent.tim:id/name' ).click( )
# while d( text='正在识别' ).exists:
# time.sleep( 2 )
z.sleep(2)
while d(text="完成").exists:
d(text="完成").click()
def getPluginClass():
return TIMUPdateCard
if __name__ == "__main__":
import sys
reload(sys)
sys.setdefaultencoding("utf-8")
clazz = getPluginClass()
o = clazz()
d = Device("HT524SK00685")
# material=u'有空聊聊吗'
z = ZDevice("HT524SK00685")
d.server.adb.cmd("shell", "ime set com.zunyun.qk/.ZImeService").wait()
args = {}
o.action(d, z, args)
from uiautomator import device as d from uiautomator import Device sn1 = "STS0119301000456" d = Device(sn1) # d.sleep() d(text="时钟").click()
def setUp(self):
self._driver = atx.connect()
self._device = Device()
else:
z.toast("星币不够或等级不够")
return
z.toast( "模块完成" )
if (args["time_delay"]):
time.sleep(int(args["time_delay"]))
def getPluginClass():
return MMC_YixinExchange
if __name__ == "__main__":
# global args
import sys
reload(sys)
sys.setdefaultencoding("utf-8")
clazz = getPluginClass()
o = clazz()
d = Device("d99e4b99")
z = ZDevice("d99e4b99")
args = {"time_delay":"3","moneyExchange":"26星币"} #cate_id是仓库号，length是数量
o.action( d, z, args )
if (args["time_delay"]):
z.sleep(int(args["time_delay"]))
def getPluginClass():
return MobilqqLogin
if __name__ == "__main__":
import sys
reload(sys)
sys.setdefaultencoding('utf8')
clazz = getPluginClass()
o = clazz()
d = Device("cda0ae8d")
z = ZDevice("cda0ae8d")
d.server.adb.cmd("shell",
"ime set com.zunyun.qk/.ZImeService").communicate()
args = {
"repo_cate_id": "132",
"time_limit": "120",
"time_limit1": "120",
"time_delay": "3"
}
#cate_id是仓库号，length是数量
# z.server.install( )
o.action(d, z, args)
# z.server.install()
# z.generate_serial( "com.tencent.mobileqq" )
# coding=utf-8
import time
from uiautomator import Device
from temp import Manager as man
import os
from src.utils.sourceData import myJson
from utils.utils import read_device, read_devices, adb_call
from utils.ui import adb_ui_call, adb_ui_wifi, adb_ui_calculator, adb_ui_voice_message
from utils.utils import make_call
dev = Device()
operations = ['+', '−', '×', '÷']
def goHome():
dev.press.home()
time.sleep(1)
def myClick(button):
if (button.count != 0):
button.click()
time.sleep(1)
def myLongClick(button):
if (button.count != 0):
button.long_click()
time.sleep(1)
if args["time_delay"]:
z.sleep(int(args["time_delay"]))
def getPluginClass():
return MobilqqLogin
if __name__ == "__main__":
import sys
reload(sys)
sys.setdefaultencoding('utf8')
clazz = getPluginClass()
o = clazz()
d = Device("cc0e9474")
z = ZDevice("cc0e9474")
d.server.adb.cmd("shell",
"ime set com.zunyun.qk/.ZImeService").communicate()
args = {
"repo_cate_id": "374",
"time_limit": "2",
"time_delay": "3"
}
#cate_id是仓库号，length是数量
# z.server.install()
o.action(d, z, args)
# serial = d.server.adb.device_serial()
# type = 'qqmail'
# slot = Slot(serial, type)
# slot.clear("1")
__author__ = "Neil"
__time__ = "2018/6/1 21:17"
from uiautomator import Device
import time
d = Device('192.168.181.101:5555',
adb_server_host='localhost',
adb_server_port=5037)
d.dump("hierarchy.xml")
def clickText(arr):
for each in arr:
d(text=each).click()
time.sleep(1.5)
d.press.back()
time.sleep(0.5)
items = [
"校园网络", "场馆预约", "图书馆", "成绩查询", "课外研学", "校车助手", "校历查询", "权益服务", "空教室",
"跑操助手", "教务通知"
]
clickText(items)
d.swipe(89, 1000, 89, 500)
items = ["课表助手", "实验助手", "考试助手", "人文讲座", "校园活动"]
clickText(items)
if (args["time_delay"]):
time.sleep(int(args["time_delay"]))
def getPluginClass():
return TIMCollectData16
if __name__ == "__main__":
import sys
reload(sys)
sys.setdefaultencoding("utf-8")
clazz = getPluginClass()
o = clazz()
d = Device("25424f9")
z = ZDevice("25424f9")
d.server.adb.cmd("shell",
"ime set com.zunyun.qk/.ZImeService").communicate()
args = {
"repo_cate_id": "349",
"time_delay": "3"
}
#cate_id是仓库号，length是数量
# o.action(d, args)
if d(text='验证手机号码').exists: # 检查到尚未 启用通讯录
if d(text=' +null').exists:
d(text=' +null').click()
d(text='中国').click()
o.Bind(d, z) # 未开启通讯录的，现绑定通讯录
class AndroidDevice(object):
'''
wrapper for android uiautomator(pip install uiautomator) and image comparision(pip install imglib)
to provide android device event inject and ui object inspect and image comparison.
'''
def __init__(self):
self.serial = configer.env[ANDROID_SERIAL] if configer.env.has_key(ANDROID_SERIAL) else None
self.d = Device(self.serial)
def __getattr__(self, method):
'''
forward method to uiautomator device if method support by uiautomator.
'''
if hasattr(self.d, method):
def wrapper(*args, **kwargs):
return getattr(self.d, method)(*args, **kwargs)
return wrapper
raise AttributeError(method)
def serial(self):
'''device serial number from $ANDROID_SERIAL '''
return self.serial
def info(self):
'''retrieve the device info'''
return self.d.info
def sleep(self, seconds):
time.sleep(seconds)
return self
#device event inject
def start_activity(self, **kwargs):
'''launch application from android shell am start: component, flag
// from adb docs:
//<INTENT> specifications include these flags:
// [-a <ACTION>] [-d <DATA_URI>] [-t <MIME_TYPE>]
// [-c <CATEGORY> [-c <CATEGORY>] ...]
// [-e|--es <EXTRA_KEY> <EXTRA_STRING_VALUE> ...]
// [--esn <EXTRA_KEY> ...]
// [--ez <EXTRA_KEY> <EXTRA_BOOLEAN_VALUE> ...]
// [-e|--ei <EXTRA_KEY> <EXTRA_INT_VALUE> ...]
// [-n <COMPONENT>] [-f <FLAGS>]
// [<URI>]
'''
#d.server.adb.cmd('shell','am', 'start', '-a', 'android.intent.action.DIAL','tel:13581739891').communicate()
#sys.stderr.write(str(kwargs))
keys = kwargs.keys()
shellcmd = ['shell', 'am', 'start']
if 'component' in keys:
shellcmd.append('-n')
shellcmd.append(kwargs['component'])
if 'action' in keys:
shellcmd.append('-a')
shellcmd.append(kwargs['action'])
if 'data' in keys:
shellcmd.append('-d')
shellcmd.append(kwargs['data'])
if 'mimetype' in keys:
shellcmd.append('-t')
shellcmd.append(kwargs['mimetype'])
if 'categories' in keys:
for category in kwargs['categories']:
shellcmd.append('-c')
shellcmd.append(category)
if 'extras' in keys:
for extra_key, extra_value in kwargs['extras'].items():
str_value = ''
arg = ''
if isinstance(extra_value, types.IntType):
str_value = str(extra_value)
arg = '--ei'
elif isinstance(extra_value, types.BooleanType):
str_value = str(extra_value)
arg = '--ez'
else:
str_value = str(extra_value)
arg = '--es'
shellcmd.append(arg)
shellcmd.append(extra_key)
shellcmd.append(str_value)
if 'flags' in keys:
shellcmd.append('-f')
shellcmd.append(str(kwargs['flags']))
if 'uri' in keys:
shellcmd.append(kwargs['uri'])
#sys.stderr.write(str(shellcmd))
self.d.server.adb.cmd(*shellcmd).communicate()
return self
def instrument(self, **kwargs):
keys = kwargs.keys()
shellcmd = ['shell', 'am', 'instrument', '-w', '-r']
pkgname = kwargs.pop('packagename')
for k, v in kwargs.items():
if k and v:
shellcmd.append('-e')
shellcmd.append(k)
shellcmd.append(str(v))
shellcmd.append(pkgname)
result = self.d.server.adb.cmd(*shellcmd).communicate()
return result
def TODOinstallPackage(self, **kwargs):
pass
def TODOremovePackage(self, **kwargs):
pass
def press(self, keyname, waittime=1):
#hard, soft key: home,back,up,down,right,left,center,menu,power or ANDROID_KEYEVENT
self.d.press(keyname)
time.sleep(waittime)
return self
def click(self, x, y, waittime=1):
self.d.click(x, y)
time.sleep(waittime)
return self
def click_image(self, imagename, waittime=1, threshold=0.01):
'''
if the wanted image found on current screen click it.
if the wanted image not found raise exception and set test to be failure.
'''
expect_image_path = os.path.join(configer['right_dir_path'], imagename)
assert os.path.exists(expect_image_path), 'the local expected image %s not found!' % imagename
current_image_path = os.path.join(configer['report_dir_path'], imagename)
self.d.screenshot(current_image_path)
assert os.path.exists(current_image_path), 'fetch current screen shot image %s failed!' % imagename
pos = getMatchedCenterOffset(expect_image_path, current_image_path, threshold)
assert pos, 'Fail Reason: The wanted image \'%s\' not found on screen!' % imagename
self.d.click(pos[0], pos[1])
time.sleep(waittime)
return self
def swipe(self, sx, sy, ex, ey, steps=100, waittime=1):
self.d.swipe(sx, sy, ex, ey, steps)
time.sleep(waittime)
return self
def drag(self, sx, sy, ex, ey, steps=100, waittime=1):
self.d.drag(sx, sy, ex, ey, steps)
time.sleep(waittime)
return self
#inspect
def exists(self, **kwargs):
'''
if the expected component exists on current screen layout return true else return false.
'''
return self.d.exists(**kwargs)
#device snapshot
def screenshot(self, filename, waittime=1):
path = os.path.join(configer['report_dir_path'], filename)
self.d.screenshot(path)
return self
def expect(self, imagename, interval=2, timeout=4, threshold=0.01, msg=''):
'''
if the expected image found on current screen return self
else raise exception. set test to be failure.
'''
expect_image_path = os.path.join(configer['right_dir_path'], imagename)
assert os.path.exists(expect_image_path)
current_image_path = os.path.join(configer['report_dir_path'], imagename)
begin = time.time()
while (time.time() - begin < timeout):
self.d.screenshot(current_image_path)
if isMatch(expect_image_path , current_image_path , threshold):
return self
time.sleep(interval)
name, ext = os.path.splitext(os.path.basename(imagename))
shutil.copyfile(expect_image_path, os.path.join(configer['report_dir_path'], '%s%s%s' % (name, '_expect', ext)))
reason = msg if not msg else 'Fail Reason: Image \'%s\' not found on screen!' % imagename
assert False, reason
def find(self, imagename, interval=2, timeout=4, threshold=0.01):
'''
if the expected image found on current screen return true else return false
'''
expect_image_path = os.path.join(configer['right_dir_path'], imagename)
assert os.path.exists(expect_image_path)
current_image_path = os.path.join(configer['report_dir_path'], imagename)
begin = time.time()
isExists = False
while (time.time() - begin < timeout):
time.sleep(interval)
self.d.screenshot(current_image_path)
isExists = isMatch(expect_image_path , current_image_path , threshold)
if not isExists:
time.sleep(interval)
continue
return isExists
def __init__(self):
self.serial = configer.env[ANDROID_SERIAL] if configer.env.has_key(ANDROID_SERIAL) else None
self.d = Device(self.serial)
from uiautomator import Device
import utility.common as u
def enable_developer_setting(self, name):
checkbox = self(className="android.widget.ListView",resourceId="android:id/list").\
child_by_text(name,className="android.widget.LinearLayout").\
child(className="android.widget.CheckBox")
if checkbox.checked == False:
print (name + " is not enabled, enabling it")
checkbox.click()
else:
print(name + " enabled")
def ChangeDeveloper_settings(self):
package = 'com.android.settings'
activity = '.DevelopmentSettings'
component_name = package + '/' + activity
u.start_activity(self,component_name)
self.wait.update()
enable_developer_setting(self,u'Stay awake')
enable_developer_setting(self,u'Allow mock locations')
if __name__ == '__main__':
d = Device()
d.wakeup()
# Press the HOME button to start the test from the home screen
d.press.home()
ChangeDeveloper_settings(d)
# Press the HOME button to start the test from the home screen
# d.press.home()
def proactive(self):
dev = Device(self.Id)
try:
dev(text='相机').click()
time.sleep(2)
dev(resourceId='com.freeme.camera:id/camera_toggle_button'
).click()
time.sleep(2)
for temp6 in range(1000):
print('%sproactive' % (temp6 + 1))
dev(resourceId='com.freeme.camera:id/shutter_button'
).click()
time.sleep(1.5)
dev.screenshot(r'%s/screenshot/%sproactive.png' %
(self.Id, (temp6 + 1)))
time.sleep(1)
except Exception, e:
print('error', e)
dev.screenshot(r'%s/error/errorproactive.png')
os.system('adb shell input keyevent BACK')
os.system('adb shell input keyevent BACK')
os.system('adb shell input keyevent HOME')
#虚化拍照切换
def xuhuaqiehuanpaizhao(self):
dev = Device(self.Id)
try:
dev(text='相机').click()
time.sleep(2)
for temp6 in range(1000):
print('%sxuhuaqiehuanpaizhao' % (temp6 + 1))
dev(resourceId=
'com.freeme.camera:id/freeme_bv_button').click(
)
time.sleep(1.5)
dev(resourceId=
'com.freeme.camera:id/freeme_bv_button').click(
)
time.sleep(1.5)
dev.screenshot(
r'%s/screenshot/%sxuhuaqiehuanpaizhao.png' %
(self.Id, (temp6 + 1)))
time.sleep(1)
except Exception, e:
print('error', e)
dev.screenshot(
r'%s/error/errorxuhuaqiehuanpaizhao.png')
dev.press.BACK()
os.system('adb shell input keyevent BACK')
os.system('adb shell input keyevent BACK')
os.system('adb shell input keyevent HOME')
#虚化拍照
def xuhuapaizhao(self):
dev = Device(self.Id)
try:
dev(text='相机').click()
time.sleep(2)
dev(resourceId=
'com.freeme.camera:id/freeme_bv_button'
).click()
time.sleep(2)
for temp6 in range(1000):
print('%sxuhuapaizhao' % (temp6 + 1))
dev(resourceId=
'com.freeme.camera:id/shutter_button'
).click()
time.sleep(1.5)
dev.screenshot(
r'%s/screenshot/%sxuhuapaizhao.png' %
(self.Id, (temp6 + 1)))
time.sleep(1)
except Exception, e:
print('error', e)
dev.screenshot(
r'%s/error/errorxuhuapaizhao.png')
dev.press.BACK()
os.system('adb shell input keyevent BACK')
os.system('adb shell input keyevent BACK')
os.system('adb shell input keyevent HOME')
class ModelInfo():
'''
classdocs
'''
def __init__(self, deviceserial):
'''
Constructor
'''
#sndLog = CLS("test", "test")
self.osType = sys.platform
self.mstrInfo = {}
#self.devSerials = self.instAdb.device_serial()
self.mstrDevice = Device(deviceserial)
self.mstrInfo = self.mstrDevice.info
'''
DEVICE Infoamtions
{ u'displayRotation': 0,
u'displaySizeDpY': 640,
u'displaySizeDpX': 360,
u'currentPackageName': u'com.android.launcher',
u'productName': u'takju',
u'displayWidth': 720,
u'sdkInt': 18,
u'displayHeight': 1184,
u'naturalOrientation': True
}
'''
def getCurrntProductInfo(self):
return self.mstrInfo
def getProductNmae(self):
return self.mstrInfo['productName']
def getCurrntPkg(self):
return self.mstrInfo['currentPackageName']
def getSDKInt(self):
return self.mstrInfo['sdkInt']
def getRotation(self):
return self.mstrInfo['displayRotation']
def getNaturalOri(self):
return self.mstrInfo['naturalOrientation']
def getDisplayState(self):
return self.mstrDevice.screen
def setReflash(self):
pass
#define Key activity
def setDevScrnOn(self):
self.mstrDevice.screen.on()
def setMstDevScrnOff(self):
self.mstrDevice.screen.off()
def setWakeup(self):
self.mstrDevice.wakeup()
def setSleep(self):
self.mstrDevice.sleep()
#Hard key Soft key
def pressHome(self):
return self.mstrDevice.press.home()
def pressBack(self):
return self.mstrDevice.press.back()
######################################################################
def pressLeft(self):
return self.mstrDevice.press.left()
def pressRight(self):
return self.mstrDevice.press.right()
def pressUp(self):
return self.mstrDevice.press.up()
def pressDown(self):
return self.mstrDevice.press.down()
def pressCenter(self):
return self.mstrDevice.press.center()
######################################################################
def pressMenu(self):
return self.mstrDevice.press.menu()
def pressSearch(self):
return self.mstrDevice.press.search()
def pressEnter(self):
return self.mstrDevice.press.enter()
def pressDelete(self):
return self.mstrDevice.press.delete() # or del
def pressRecent(self):
return self.mstrDevice.press.recent()
def pressVol_Up(self):
return self.mstrDevice.press.volume_up()
def pressVol_Down(self):
return self.mstrDevice.press.volume_down()
def pressVol_Mute(self):
return self.mstrDevice.press.volume_mute()
def pressPower(self):
return self.mstrDevice.press.power()
def clik(self, x, y):
return self.mstrDevice.click(x, y)
def longClik(self,x, y):
'''
Description:
param:
x, y : start first point x, y
return : Boolean
'''
return self.mstrDevice.long_click(x, y)
def swipe(self, sx, sy, ex, ey, steps=10):
'''
Description:
param:
sx, xy : start first x, y
ex, ey : move to x, y
return : Boolean
'''
return self.mstrDevice.swipe(sx, sy, ex, ey, steps)
def drage(self,sx, sy, ex, ey, steps=10):
'''
Description:
param:
sx, xy : start first x, y
ex, ey : move to x, y
return : Boolean
'''
return self.mstrDevice.drag(sx, sy, ex, ey, steps)
#screen action of the device
def setOrientation(self,scrAct='natural', choiceDevice='mstr'):
'''
Description
param
d.orientation = 'l' or 'left'
d.orientation = 'r' or 'right'
d.orientation = 'n' or 'natural'
return : None
'''
self.mstrDevice.orientation = scrAct
def setFreezeRotation(self,condition=False,choiceDevice='mstr'):
'''
param:
condition : False un-freeze rotation
return : None
'''
self.mstrDevice.freeze_rotation(condition)
def takeScreenShot(self, choiceDevice = 'mstr'):
'''
Description:
take screenshot and save to local file 'home.png' can work until android 4.2
param
image name
'''
def dumpWindowHeirarchy(self,filename='./log/hierachy.xml'):
return self.mstrDevice.dump(filename)
def dumpWindowHeirarchyStream(self):
return self.mstrDevice.dump()
def notification(self):
'''
Open notification, can not work until android 4.3
return : Boolean
'''
return self.mstrDevice.open.Notification()
def quickSettings(self):
'''
open quick settins, can not work until android 4.3
return : Boolean
'''
return self.mstrDevice.open.quick_settings()
def waitidle(self):
'''
wait for current window to idle
return : None
'''
self.mstrDevice.wait.idle()
def waitWindowUpdate(self):
'''
wait until window upate event occurs
return : Boolean
'''
self.mstrDevice.wait.update()
def getCurrentActivityInfo(self, text):
'''
INFOMATION:
{ u'contentDescription': u'',
u'checked': False,
u'scrollable': False,
u'text': u'Settings',
u'packageName': u'com.android.launcher',
u'selected': False,
u'enabled': True,
u'bounds': {u'top': 385,
u'right': 360,
u'bottom': 585,
u'left': 200},
u'className': u'android.widget.TextView',
u'focused': False,
u'focusable': True,
u'clickable': True,
u'chileCount': 0,
u'longClickable': True,
u'visibleBounds': {u'top': 385,
u'right': 360,
u'bottom': 585,
u'left': 200},
u'checkable': False
}
'''
return self.mstrDevice(text).info
def uiObjExist(self,text):
'''
ture if exists, else False
'''
return self.mstrDevice.exists(text)
def watcher(self):
pass
def handler(self):
pass
def selector(self):
pass
def __del__(self):
pass
d.swipe(width / 2, height * 6 / 7, width / 2, height / 7)
z.sleep(2)
if ending == 1: #结束条件
return
if d(textContains='位联系人').exists:
ending = 1
i = 1
continue
if (args["time_delay"]):
z.sleep(int(args["time_delay"]))
def getPluginClass():
return WeiXinAddressList
if __name__ == "__main__":
import sys
reload(sys)
sys.setdefaultencoding('utf8')
clazz = getPluginClass()
o = clazz()
d = Device("HT4A4SK00901")
z = ZDevice("HT4A4SK00901")
z.server.install()
d.server.adb.cmd("shell", "ime set com.zunyun.qk/.ZImeService").communicate()
args = {"repo_material_id": "39",'EndIndex':'10','gender':"女","time_delay": "3"} #cate_id是仓库号，length是数量
o.action(d,z, args)
class UiTestLib(object):
"""Ui Test Lib
"""
def __init__(self, serial=None):
"""
"""
logger.info("<p>Device=%s>" % serial, html=True)
print "<p>Device=%s>" % serial
self._result = ""
self.starttime = 0
self.d = Device(serial)
self.adb = Adb(serial)
self.debug = "True"
def set_debugable(flag):
self.debug = flag
def set_serial(self, serial):
"""Specify given *serial* device to perform test.
or export ANDROID_SERIAL=CXFS42343 if you have many devices connected but you don't use this
interface
When you need to use multiple devices, do not use this keyword to switch between devices in test execution.
And set the serial to each library.
Using different library name when importing this library according to
http://robotframework.googlecode.com/hg/doc/userguide/RobotFrameworkUserGuide.html?r=2.8.5.
Examples:
| Setting | Value | Value | Value |
| Library | UiTestLib | WITH NAME | Mobile1 |
| Library | UiTestLib | WITH NAME | Mobile2 |
And set the serial to each library.
| Test Case | Action | Argument |
| Multiple Devices | Mobile1.Set Serial | device_1's serial |
| | Mobile2.Set Serial | device_2's serial |
"""
self.d = Device(serial)
self.adb = Adb(serial)
def logmsg(self, msg):
if self.debug == "True":
print msg
def exe_adb_command(self, cmd):
""" Execute adb *cmd*
Examples:
| Exe Adb Command | shell getprop |
"""
return self.adb.cmd(cmd).wait()
def exe_adb_and_result(self, cmd):
"""Execute adb *cmd* and return lines of the command"""
lproc = self.adb.cmd(cmd)
lproc.poll()
lines = lproc.stdout.readlines()
return lines
def get_device_info(self):
"""Get Device information
return info dictionary
"""
return self.d.info
def light_screen(self):
"""Light screen by wakeup.
Examples:
| Action |
|Light screen|
Use `Light screen` to light screen.
"""
self.d.wakeup()
self._result = self.d.press.home()
def open_application(self, appname):
"""Open application by it name `appname`.
Example:
| Action | Argument |
| Open application | "com.android.settings/com.android.settings.Settings" |
"""
appname = "shell am start -n " + appname
print "Open Application:", appname
self._result = self.exe_adb_command(appname)
def click_text(self, text, instance=0):
"""Click text label on screen
instance=0 is default, change when you needed.
Example:
| Action | Argument | Argument |
| Click Text | text | instance |
"""
return self.d(text=text, instance=instance).click.wait()
def long_click_text(self, text, instance=0):
"""
Long Click text label on screen, *text* and *instance=0*
Example:
| Action | Argument | Argument |
| Long Click Text | text | instance |
"""
return self.d(text=text, instance=instance).long_click()
def long_click_ui(self, **selectors):
"""
Long Click on **selectors**
Selector supports below parameters. Refer to UiSelector java doc for detailed information.
text, textContains, textMatches, textStartsWith
className, classNameMatches
description, descriptionContains, descriptionMatches, descriptionStartsWith
checkable, checked, clickable, longClickable
scrollable, enabled,focusable, focused, selected
packageName, packageNameMatches
resourceId, resourceIdMatches
index, instance
Example:
| Action | Argument | Argument | Argument |
| Long Click UI | text=XXXX | className=XXX.xxxx | resourceId=xxxxxx |
"""
return self.d(**selectors).long_click()
def text_display_on_screen_contains(self, text):
"""Verify text display on screen
Example:
| Action | Argument |
|Text display on screen is| text |
"""
if self.d(text=text).exists:
self._result = True
return True
else:
self._result = False
return False
def object_display_on_screen(self, obj, timeout=5000):
""" Verify *obj* UiObject display on screen
return to self._result
Example:
| Action | Argument |
|Object display on screen | obj |
"""
if obj.wait.exists(timeout):
self._result = True
return True
else:
self._result = False
return False
def assert_expectation(self, expect, actual):
"""
Assert Expectation and actual value
Example:
| Action | args | args |
| Assert Expectation | 324324 | ${actual} |
"""
if str(expect) != str(actual):
raise AssertionError("Actual result is = %s, but expectation is: %s" % (str(actual), str(expect)))
def assert_true(self, condition):
"""
Assert True of *condition
Example:
|Assert True | condition |
"""
if str(condition) != "True": # because only string from robotframework
raise AssertionError("Result is = %s" % str(condition))
def assert_result_true(self):
"""
Assert True of *self._result
Example:
|Assert True |
"""
if self._result != True:
raise AssertionError("Result is = %s" % str(self._result))
def wait_for_ui_exists(self, timeout, **selectors):
"""
Return True if
Selector is to identify specific ui object in current window.
# To seleted the object ,text is 'Clock' and its className is 'android.widget.TextView'
wait_for_ui_exists(text='Clock', className='android.widget.TextView')
Selector supports below parameters. Refer to UiSelector java doc for detailed information.
text, textContains, textMatches, textStartsWith
className, classNameMatches
description, descriptionContains, descriptionMatches, descriptionStartsWith
checkable, checked, clickable, longClickable
scrollable, enabled,focusable, focused, selected
packageName, packageNameMatches
resourceId, resourceIdMatches
index, instance
Examples:
| Action | Argument | Argument | Argument | Argument |
|Wait For UI Exists | timeout | text=XXXX | className=XXX.xxxx | resourceId=xxxxxx |
"""
self._result = self.d(**selectors).wait.exists(timeout=int(timeout))
return self._result
def wait_and_click(self, timeout, **selectors):
"""Wait for uiselector and click"""
if self.d(**selectors).wait.exists(timeout=int(timeout)):
self.d(**selectors).click()
def assert_ui_exists(self, **selectors):
"""
Assert UiObject appear on the screen
Examples:
| Action | Argument | Argument | Argument | Argument |
|Assert UI Exists | timeout | text=XXXX | className=XXX.xxxx | resourceId=xxxxxx |
"""
if not self.d(**selectors).wait.exists():
raise AssertionError("UiObject does not exists %s" % selectors.items())
def result_should_be(self, expected):
"""Verifies that the current result is `expected`.
Example:
| Action | Argument |
| Open application | com.android.settings/com.android.settings.Settings |
| Result Should Be | 0 |
"""
print ("result is: %s\n", self._result)
print ("ex is: %s\n", expected)
if str(self._result) != expected:
raise AssertionError("%s != %s" % (self._result, expected))
def click_at_coordinates(self, x, y):
""" Click at (x,y) coordinates.
Example:
| Action | Argument | Argument |
| Click At Corrdinates | x | y |
"""
return self.d.click(int(x), int(y))
def long_click_at_coordinates(self, x, y):
"""
# long click (x, y) on screen
"""
return self.d.long_click(int(x), int(y))
def swipe(self, sx, sy, ex, ey, steps=20):
"""
Swipe from (sx,sy) to (ex,ey)
"""
return self.d.swipe(int(sx), int(sy), int(ex), int(ex), int(steps))
def drag(self, sx, sy, ex, ey, steps=20):
"""
Drag from (sx,sy) to (ex,ey)
"""
return self.d.drag(int(sx), int(sy), int(ex), int(ex), int(steps))
def freeze_rotation(self, rotation=True):
"""
Freeze rotation,
*rotation*, True is default,
"""
return self.d.freeze_rotation(rotation)
def set_rotation(self, rotation):
"""
# retrieve orientation,
# it should be "natural" or "left" or "right" or "upsidedown"
Example:
| Action | Argument |
| Set Rotation | nature |
| Set Rotation | left |
| Set Rotation | right |
| Set Rotation | upsidedown |
"""
orientation = self.d.orientation
if rotation == "nature":
self.d.orientation = "n" # or "natural"
elif rotation == "left":
self.d.orientation = "l" # or "left"
elif rotation == "right":
self.d.orientation = "r" # or "right"
elif rotation == "upsidedown":
self.d.orientation = "upsidedown" # or "upsidedown"
else:
self.d.rotation = "n"
def take_screenshot(self, scale=None, quality=None):
"""
Take a screenshot of device and log in the report with timestamp, scale for screenshot size and quality for screenshot quality
default scale=1.0 quality=100
Example:
| Action | Argument | Argument |
| Take Screenshot | 0.5 | 80 |
"""
output_dir = BuiltIn().get_variable_value("${OUTPUTDIR}")
ts = time.time()
st = datetime.datetime.fromtimestamp(ts).strftime("%Y%m%d%H%M%S")
screenshot_path = "%s%s%s.png" % (output_dir, os.sep, st)
screenshot_name = "%s%s.png" % (os.sep, st)
self.d.screenshot(screenshot_path, scale, quality)
logger.info('\n<a href="%s">%s</a><br><img src="%s">' % (screenshot_path, st, screenshot_name), html=True)
def open_notification(self):
"""
Open notification of the phone
"""
self.d.open.notification()
def wait_window_update(self):
"""
wait for window update
"""
return self.d.wait.update()
def wait_window_idle(self):
"""
wait for window idle
"""
return self.d.wait.idle()
def remove_watchers(self):
"""
Remove UI watchers
"""
self.d.watchers.remove()
def get_device(self):
"""
Get device object, you can do any command using this
"""
return self.d
def click_id(self, id, instance=0):
"""
Click *id* with *instance*=0
"""
return self.d(resourceId=id, instance=instance).click.wait()
def long_click_id(self, id, instance=0):
"""
Long click *id* with *instance*=0
"""
return self.d(resourceId=id, instance=0).long_click()
def click_description(self, description, instance=0):
"""
Click *description* with *instance*=0
"""
return self.d(description=description, instance=instance).long_click()
def click_class(self, className, instance=0):
"""
Click *className* with *instance*=0
"""
return self.d(className=className, instance=instance).long_click()
def type_text(self, textStr, **selectors):
"""
type text on selectors
like text=EditName
"""
self.d(**selectors).set_text(textStr)
def press_key(self, key):
""" Press Key of following value
home
back
left
right
up
down
center
menu
search
enter
delete(or del)
recent(recent apps)
volume_up
volume_down
volume_mute
camera
power
Examples:
| Action | Argument |
| Press Key | home |
| Press Key | back |
| Press Key | left |
| Press Key | right |
| Press Key | recent |
| Press Key | volume_up |
| Press Key | camera |
"""
if key.isdigit():
return self.d.press(int(key))
return self.d.press(key)
def phone_sleep(self, timeout):
"""
android device sleep with timeout in ms, don't use for executor sleep,
"""
return self.d.wait(int(timeout))
def execute_command(self, cmd, block_parent_process=True):
"""
Execute shell *cmd* command, with block_parent_process = True
If block_parent_process = False, kill_command is needed to terminal the child process
Example:
| Execute Command | ping -c 5 127.0.0.1 |
"""
if str(block_parent_process) == str(True):
return subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE).communicate()
else:
return subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
def kill_command(self, process, timeout=0):
""" Kill child *process* in timeout seconds
Some bugs after process teminated
"""
time.sleep(float(timeout))
process.terminate()
def wait_for_logcat(self, log, timeout=30):
""" Wait log exists in given timeout, return True if have, otherwise will return False
log is your want to search, log can be a regular expression
time in seconds, default value is 30 seconds
Example:
| Wait For Logcat | .*ActivityManager.*cmp=com.sonyericsson.album/com.sonyericsson.album.Main.* |
"""
start = time.time()
while (time.time() - start) < int(timeout):
log_proc = self.adb.cmd("logcat -d -v time")
returncode = log_proc.poll()
lines = log_proc.stdout.readlines()
for line in lines:
rlt = re.search(log, line.rstrip())
if rlt is not None:
print rlt.group(0)
self._result = True
return True
time.sleep(2) # sleep 2s to wait
self._result = False
return False
def clear_logcat(self):
"""
Clear logcat, it's often used before you want to use *wait_for_logcat()*
"""
print "Clear logcat before test"
return self.exe_adb_command("logcat -c")
def click_object(self, obj):
""" Click UiObject *obj*
Exmaple:
| ${result} | Get UI Object | text=XXX | className=xxxx |
| Click Object | ${result} |
"""
obj.click()
def click_ui(self, **selectors):
"""
Click selector
click_selector(text="Home", resourceId = "android:id/title")
for **selector, please refer *get_ui_object()*
Selector supports below parameters. Refer to UiSelector java doc for detailed information.
text, textContains, textMatches, textStartsWith
className, classNameMatches
description, descriptionContains, descriptionMatches, descriptionStartsWith
checkable, checked, clickable, longClickable
scrollable, enabled,focusable, focused, selected
packageName, packageNameMatches
resourceId, resourceIdMatches
index, instance
Operation for a UiObjects:
click, clear_text, drag(obj).to(**selector), gesture, exists, set_text, long_click
pinch.In(percent=100, steps=10), pinch.Out(percent=100, steps=100),.swipe.right(),
.swipe.left(steps=10),.swipe("right", steps=20),.wait.gone(),.wait.exists()
"""
print "selectors:", selectors
return self.d(**selectors).click()
def get_ui_object(self, **selectors):
"""
Get UI object with *selectors*
you can do anything on UiObject, like click(), long_click(),wait.exists(timeout)
examples: get_ui_object(text="Home", resourceId = "android:id/title")
Selector supports below parameters. Refer to UiSelector java doc for detailed information.
text, textContains, textMatches, textStartsWith
className, classNameMatches
description, descriptionContains, descriptionMatches, descriptionStartsWith
checkable, checked, clickable, longClickable
scrollable, enabled,focusable, focused, selected
packageName, packageNameMatches
resourceId, resourceIdMatches
index, instance
Operation for a UiObjects:
click, clear_text, drag(obj).to(**selector), gesture, exists, set_text, long_click
pinch.In(percent=100, steps=10), pinch.Out(percent=100, steps=100),.swipe.right(),
.swipe.left(steps=10),.swipe("right", steps=20),.wait.gone(),.wait.exists()
Exmaple:
| ${result} | Get UI Object | text=XXX | className=xxxx |
"""
self._result = self.d(**selectors)
return self._result
def wait_for_object_exists(self, obj, timeout=0):
"""
Wait for UiObject *obj* exists in *timeout*= 0
Example:
| ${result} | Get UI Object | text=XXX | className=xxxx |
| Wait For Object Exists | ${result} | timeout |
"""
self._result = obj.wait.exists(timeout=int(timeout))
return self._result
def wait_for_ui_gone(self, timeout=0, **selectors):
"""
Wait for UiObject *obj* gone in *timeout*= 0
Example:
| ${result} | Get UI Object | text=XXX | className=xxxx |
| Wait For Object Gone | ${result} | timeout |
"""
self._result = self.d(**selectors).wait.gone(timeout=int(timeout))
return self._result
def get_key_value(self, key, dictionary):
"""
Get key value of dictionary
"""
return dictionary(key)
def get_tts(self, input_text, delete_file=False, **args):
"""
Get TTS voice mp3 from Google
get_tts(input_text='tunnel snakes rule apparently', args = {'language':'en','output':'outputto.mp3'})
Robot Framework:
Examples:
| Action | Argument | Argument | Argument | Argument |
| UiTestLib.Get TTS | Hello world | False | output=ooo.mp3 | language=en |
"""
print "Get text to speech: ", input_text
downloaded = False
if str(delete_file) == "True":
if os.path.exists(args["output"]):
os.remove(args["output"])
if os.path.exists(args["output"]):
if os.path.getsize(args["output"]) <= 0:
os.remove(args["output"])
if args["output"] is not None:
if not os.path.exists(args["output"]):
print "Generating mp3 file......", args["output"]
downloaded = GoogleTTS.audio_extract(input_text, args)
else:
print "Have same local file"
downloaded = True
if not downloaded:
print "Downloaded TTS from Google failed, trying to download from local FTP..."
mp3file = open(args["output"], "w")
mp3url = "ftp://cnbjlx9548/atautomation/Test-Content/Croft/" + args["output"]
try:
resp = urllib2.urlopen(mp3url, timeout=40)
mp3file.write(resp.read())
time.sleep(0.05)
except Exception, e:
print e
return False
mp3file.close()
return True
class test(object):
dev_sn = ""
dev_displayHeight = 0
dev_displayWidth = 0
icon_x = 0
icon_y = 0
app_name = ""
app_path = ""
app_package_name = ""
class_name = ""
result = ""
install_time = ""
device = Device();
DIR_VERT, DIR_HORIZ ,DIR_NONE = range(3)
SWIPE_DIR_UP, SWIPE_DIR_DOWN, SWIPE_DIR_LEFT, SWIPE_DIR_RIGHT = range(4)
def __init__(self,sn,app):
self.dev_sn = sn
self.device = Device(self.dev_sn)
self.dev_displayHeight = self.device.info['displayHeight']
self.dev_displayWidth = self.device.info['displayWidth']
self.icon_x = self.dev_displayWidth * 12 / 100
self.icon_y = self.dev_displayHeight * 52 / 100
self.is_app_settings_done = False
if len(app) > 0 and app[0] != '':
self.app_name = app[0]
if len(app) > 1 and app[1] != '':
self.app_path = app[1]
self.app_package_name = self.get_package_name()
self.install_app()
if len(app) > 2 and app[2] != '':
self.app_package_name = app[2]
else:
self.app_package_name = os.popen("adb -s %s shell pm list package | grep -i %s | awk -F ':' '{print$2}'"%(self.dev_sn,self.app_name)).read().strip("\r\n")
self.set_app_settings_done_flag()
self.clean_result()
self.load_resource()
def get_package_name(self):
p = re.compile(r"package: name=\'([\w+.]*)\'")
s = os.popen("./aapt dump badging %s | grep -i package"%(self.app_path)).read()
package_name = re.findall(p,s)
return ''.join(package_name)
def icon_click(self):
os.system("adb -s %s shell input tap %s %s"%(self.dev_sn,self.icon_x,self.icon_y))
def my_func_name(self):
return inspect.stack()[1][3]
def logout(self,function_name,log):
print ">>> (%s) [%s.%s] :"%(self.app_name, self.__class__.__name__, function_name)+log
def is_AppBench_root_page(self):
if self.device(text="AppBench").exists and self.device(text="Tutorial").exists:
return True
else:
return False
def wait_for_fps_result(self):
self.logout(self.my_func_name(),"...")
while True:
if self.is_AppBench_root_page() == False:
if self.device(text="AppBench").exists:
return True
else:
continue
else:
return False
def swipe_vert(self,swipe_times,direction):
if direction == self.SWIPE_DIR_UP:
src_x = self.dev_displayWidth / 2
src_y = self.dev_displayHeight * 4 / 5
des_x = self.dev_displayWidth / 2
des_y = self.dev_displayHeight * 1 / 5
elif direction == self.SWIPE_DIR_DOWN:
src_x = self.dev_displayWidth / 2
src_y = self.dev_displayHeight * 1 / 5
des_x = self.dev_displayWidth / 2
des_y = self.dev_displayHeight * 4 / 5
else:
self.logout(self.my_func_name(),"direction is error...")
return False
for i in range(swipe_times):
self.device.swipe(src_x,src_y,des_x,des_y,steps=20)
return True
def swipe_horiz(self,swipe_times,direction):
if direction == self.SWIPE_DIR_RIGHT:
src_x = self.dev_displayWidth * 1 / 5
src_y = self.dev_displayHeight / 3
des_x = self.dev_displayWidth * 4 / 5
des_y = self.dev_displayHeight / 2
elif direction == self.SWIPE_DIR_LEFT:
src_x = self.dev_displayWidth * 4 / 5
src_y = self.dev_displayHeight / 3
des_x = self.dev_displayWidth * 1 / 5
des_y = self.dev_displayHeight / 3
else:
self.logout(self.my_func_name(),"direction is error...")
return False
for i in range(swipe_times):
self.device.swipe(src_x,src_y,des_x,des_y,steps=20)
return True
def set_app_settings_done_flag(self):
if "1" in os.popen("adb -s %s shell ls /data/data/%s | grep -c shared_prefs"%(self.dev_sn,self.app_package_name)).read():
self.is_app_settings_done = True
else:
self.is_app_settings_done = False
def back_to_AppBench_root_page(self):
for i in range(10):
if self.is_AppBench_root_page() == True:
break
else:
self.device.press.back()
time.sleep(1)
def locate(self,option_name,direction):
if direction == self.DIR_VERT:
self.device(scrollable=True).scroll.vert.to(text=option_name)
self.device(text=option_name).click.wait()
elif direction == self.DIR_HORIZ:
self.device(scrollable=True).scroll.horiz.to(text=option_name)
self.device(text=option_name).click.wait()
else:
self.device(text=option_name).click.wait()
def start_native_agent(self):
self.logout(self.my_func_name(),"...")
cmds = ["cp /sdcard/appbench/native_agent /data/local/tmp/",
"chmod 777 /data/local/tmp/native_agent",
"cp /sdcard/appbench/perf /data/local/tmp/",
"chmod 777 /data/local/tmp/perf",
"cp /sdcard/appbench/screencap /data/local/tmp/",
"chmod 777 /data/local/tmp/screencap",
"/data/local/tmp/native_agent > agent_log.txt &"
]
if "0" in os.popen("adb -s %s shell ps | grep -c native_agent"%self.dev_sn).read():
self.logout(self.my_func_name(),"start native_agent now")
for cmd in cmds:
os.system("adb -s %s shell "%self.dev_sn+cmd)
else:
self.logout(self.my_func_name(),"native_agent is running")
def load_resource(self):
self.logout(self.my_func_name(),"...")
def install_app(self):
if "1" in os.popen("adb -s %s shell ls /data/data | grep -c "%self.dev_sn+self.app_package_name).read():
self.logout(self.my_func_name(),"%s app has been installed."%self.app_name)
else:
self.logout(self.my_func_name(),"app %s is installing now."%self.app_name)
time_start = time.time()
os.system("adb -s %s install "%self.dev_sn+self.app_path)
time_end = time.time()
self.install_time = time_end - time_start
def launch_app(self,app_name):
self.logout(self.my_func_name(),"...")
if self.device.screen == "off":
os.system("adb -s %s shell input keyevent 82"%self.dev_sn)
else:
os.system("adb -s %s shell input keyevent 26"%self.dev_sn)
time.sleep(3)
os.system("adb -s %s shell input keyevent 82"%self.dev_sn)
time.sleep(3)
self.device.press.home()
self.device(description='Apps').click.wait()
self.locate("Apps",self.DIR_NONE)
self.locate(app_name,self.DIR_HORIZ)
def select_test_mode(self):
self.logout(self.my_func_name(),"...")
def start_app_from_AppBench(self):
self.logout(self.my_func_name(),"...")
self.back_to_AppBench_root_page()
self.locate(self.app_package_name,self.DIR_VERT)
self.locate("Measure",self.DIR_NONE)
time.sleep(1)
if "0" in os.popen("adb -s %s shell ps | grep -c native_agent"%self.dev_sn).read():
return False
return True
def do_app_settings(self):
self.logout(self.my_func_name(),"...")
def measure(self):
self.logout(self.my_func_name(),"...")
def clean_result(self):
self.logout(self.my_func_name(),"...")
os.system("adb -s %s shell rm -rf /sdcard/appbench/%s"%(self.dev_sn,self.app_package_name))
time.sleep(3)
def collect_result(self):
self.logout(self.my_func_name(),"...")
def stop_app(self):
self.logout(self.my_func_name(),"...")
os.system("adb -s %s shell am force-stop %s"%(self.dev_sn,self.app_package_name))
def stop_appbench(self):
self.logout(self.my_func_name(),"...")
os.system("adb -s %s shell am force-stop com.intel.appbench"%self.dev_sn)
def exec_test(self):
self.logout(self.my_func_name(),"...")
class Mobile():
def __init__(self):
pass
def set_serial(self, android_serial):
"""
Specify given *android_serial* device to perform test.
You do not have to specify the device when there is only one device connects to the computer.
When you need to use multiple devices, do not use this keyword to switch between devices in test execution.
Using different library name when importing this library according to http://robotframework.googlecode.com/hg/doc/userguide/RobotFrameworkUserGuide.html?r=2.8.4#setting-custom-name-to-test-library.
| ==Setting== | ==Value== | ==Value== | ==Value== |
| Library | Mobile | WITH NAME | Mobile1 |
| Library | Mobile | WITH NAME | Mobile2 |
And set the serial to each library.
| Test Case | Action | Argument |
| Multiple Devices | Mobile1.Set Serial | device_1's serial |
| | Mobile2.Set Serial | device_2's serial |
"""
self.adb = ADB(android_serial)
self.device = Device(android_serial)
self.test_helper = TestHelper(self.adb)
def get_device_info(self):
"""
Retrieve the device info.
The keyword will return a dictionary.
You can log the information by using the log dictionary keyword in build in Collections library(http://robotframework.googlecode.com/hg/doc/libraries/Collections.html?r=2.8.4).
Example:
| ${device_info} | Get Device Info |
| Log Dictionary | ${device_info} |
=>
Dictionary size is 9 and it contains following items:\n
currentPackageName: com.android.keyguard\n
displayHeight: 1776\n
displayRotation: 0\n
displaySizeDpX: 360\n
displaySizeDpY: 640\n
displayWidth: 1080\n
naturalOrientation: True\n
productName: hammerhead\n
sdkInt: 19\n
Or get specific information of the device by giving the key.
| ${device_info} | Get Device Info | | |
| ${product_name} | Get From Dictionary | ${device_info} | productName |
=>
${product_name} = hammerhead
"""
return self.device.info
#Key Event Actions of the device
"""
Turn on/off screen
"""
def turn_on_screen(self):
"""
Turn on screen
"""
self.device.screen.on()
def turn_off_screen(self):
"""
Turn off screen
"""
self.device.screen.off()
"""
Press hard/soft key
"""
def press_key(self, *keys):
"""
Press *key* keycode.
You can find all keycode in http://developer.android.com/reference/android/view/KeyEvent.html
"""
#not tested
self.device.press(*keys)
def press_home(self):
"""
Press home key
"""
self.device.press.home()
def press_back(self):
"""
Press back key
"""
self.device.press.back()
def press_left(self):
"""
Press left key
"""
self.device.pres.left()
def press_right(self):
"""
Press right key
"""
self.device.press.right()
def press_up(self):
"""
Press up key
"""
self.device.press.up()
def press_down(self):
"""
Press down key
"""
self.device.press.down()
def press_center(self):
"""
Press center key
"""
self.device.press.center()
def press_menu(self):
"""
Press menu key
"""
self.device.press.menu()
def press_search(self):
"""
Press search key
"""
self.device.press.search()
def press_enter(self):
"""
Press enter key
"""
self.device.press.enter()
def press_delete(self):
"""
Press delete key
"""
self.device.press.delete()
def press_recent(self):
"""
Press recent key
"""
self.device.press.recent()
def press_volume_up(self):
"""
Press volume up key
"""
self.device.press.volume_up()
def press_volume_down(self):
"""
Press volume down key
"""
self.device.press.volume_down()
def press_camera(self):
"""
Press camera key
"""
self.device.press.camera()
def press_power(self):
"""
Press power key
"""
self.device.press.power()
#Gesture interaction of the device
def click_at_coordinates(self, x, y):
"""
Click at (x,y) coordinates.
"""
self.device.click(x, y)
def swipe_by_coordinates(self, sx, sy, ex, ey, steps=10):
"""
Swipe from (sx, sy) to (ex, ey) with *steps* .
Example:
| Swipe By Coordinates | 540 | 1340 | 940 | 1340 | | # Swipe from (540, 1340) to (940, 100) with default steps 10 |
| Swipe By Coordinates | 540 | 1340 | 940 | 1340 | 100 | # Swipe from (540, 1340) to (940, 100) with steps 100 |
"""
self.device.swipe(sx, sy, ex, ey, steps)
# Swipe from the center of the ui object to its edge
def swipe_left(self, steps=10, *args, **selectors):
"""
Swipe the UI object with *selectors* from center to left.
Example:
| Swipe Left | description=Home screen 3 | | # swipe the UI object left |
| Swipe Left | 5 | description=Home screen 3 | # swipe the UI object left with steps=5 |
See `introduction` for details about identified UI object.
"""
self.device(**selectors).swipe.left(steps=steps)
def swipe_right(self, steps=10, *args, **selectors):
"""
Swipe the UI object with *selectors* from center to right
See `Swipe Left` for more details.
"""
self.device(**selectors).swipe.right(steps=steps)
def swipe_top(self, steps=10, *args, **selectors):
"""
Swipe the UI object with *selectors* from center to top
See `Swipe Left` for more details.
"""
self.device(**selectors).swipe.up(steps=steps)
def swipe_bottom(self, steps=10, *args, **selectors):
"""
Swipe the UI object with *selectors* from center to bottom
See `Swipe Left` for more details.
"""
self.device(**selectors).swipe.down(steps=steps)
def object_swipe_left(self, obj, steps=10):
"""
Swipe the *obj* from center to left
Example:
| ${object} | Get Object | description=Home screen 3 | # Get the UI object |
| Object Swipe Left | ${object} | | # Swipe the UI object left |
| Object Swipe Left | ${object} | 5 | # Swipe the UI object left with steps=5 |
| Object Swipe Left | ${object} | steps=5 | # Swipe the UI object left with steps=5 |
See `introduction` for details about identified UI object.
"""
obj.swipe.left(steps=steps)
def object_swipe_right(self, obj, steps=10):
"""
Swipe the *obj* from center to right
See `Object Swipe Left` for more details.
"""
obj.swipe.right(steps=steps)
def object_swipe_top(self, obj, steps=10):
"""
Swipe the *obj* from center to top
See `Object Swipe Left` for more details.
"""
obj.swipe.up(steps=steps)
def object_swipe_bottom(self, obj, steps=10):
"""
Swipe the *obj* from center to bottom
See `Object Swipe Left` for more details.
"""
obj.swipe.down(steps=steps)
def drag_by_coordinates(self,sx, sy, ex, ey, steps=10):
"""
Drag from (sx, sy) to (ex, ey) with steps
See `Swipe By Coordinates` also.
"""
self.device.drag(sx, sy, ex, ey, steps)
#Wait until the specific ui object appears or gone
# wait until the ui object appears
def wait_for_exists(self, timeout=0, *args, **selectors):
"""
true means the object which has *selectors* exist
false means the object does not exist
in the given timeout
"""
return self.device(**selectors).wait.exists(timeout=timeout)
# wait until the ui object gone
def wait_until_gone(self, timeout=0, *args, **selectors):
"""
true means the object which has *selectors* disappear
false means the object exist
in the given timeout
"""
return self.device(**selectors).wait.gone(timeout=timeout)
def wait_for_object_exists(self, obj, timeout=0):
"""
true means the object exist
false means the object does not exist
in the given timeout
"""
return obj.wait.exists(timeout=timeout)
# wait until the ui object gone
def wait_until_object_gone(self, obj, timeout=0):
"""
true means the object disappear
false means the object exist
in the given timeout
"""
return obj.wait.gone(timeout=timeout)
# Perform fling on the specific ui object(scrollable)
def fling_forward_horizontally(self, *args, **selectors):
"""
return whether the object can be fling or not
"""
return self.device(**selectors).fling.horiz.forward()
def fling_backward_horizontally(self, *args, **selectors):
"""
return whether the object can be fling or not
"""
return self.device(**selectors).fling.horiz.backward()
def fling_forward_vertically(self, *args, **selectors):
"""
return whether the object can be fling or not
"""
return self.device(**selectors).fling.vert.forward()
def fling_backward_vertically(self, *args, **selectors):
"""
return whether the object can be fling or not
"""
return self.device(**selectors).fling.vert.backward()
# Perform scroll on the specific ui object(scrollable)
def scroll_to_beginning_vertically(self, steps=10, **selectors):
"""
"""
return self.device(**selectors).scroll.vert.toBeginning(steps=steps)
def scroll_to_end_vertically(self, steps=10, **selectors):
"""
"""
return self.device(**selectors).scroll.vert.toEnd(steps=steps)
def scroll_object_to_beginning_vertically(self, obj, steps=10):
"""
"""
return obj.scroll.vert.toBeginning(steps=steps)
def scroll_object_to_end_vertically(self, obj, steps=10):
"""
"""
return obj.scroll.vert.toEnd(steps=steps)
def scroll_forward_horizontally(self, obj, steps=10):
"""
return whether the object can be scroll or not
"""
return obj.scroll.horiz.forward(steps=steps)
def scroll_backward_horizontally(self, obj, steps=10):
"""
return whether the object can be scroll or not
"""
return obj.scroll.horiz.backward(steps=steps)
def scroll_to_horizontally(self, obj, *args,**selectors):
"""
return whether the object can be scroll or not
"""
return obj.scroll.horiz.to(**selectors)
def scroll_forward_vertically(self, obj, steps=10):
"""
return whether the object can be scroll or not
"""
return obj.scroll.vert.forward(steps=steps)
def scroll_backward_vertically(self, obj, steps=10):
"""
return whether the object can be scroll or not
"""
return obj.scroll.vert.backward(steps=steps)
def scroll_to_vertically(self, obj, *args, **selectors):
"""
return whether the object exists or not
"""
return obj.scroll.vert.to(**selectors)
#Screen Actions of the device
def get_screen_orientation(self):
"""
Get the screen orientation.
Possible result: natural, left, right, upsidedown
See for more details: https://github.com/xiaocong/uiautomator#screen-actions-of-the-device
"""
return self.device.orientation
def set_screen_orientation(self, orientation):
"""
Set the screen orientation.
Input *orientation* : natural or n, left or l, right or r, upsidedown (support android version above 4.3)
The keyword will unfreeze the screen rotation first.
See for more details: https://github.com/xiaocong/uiautomator#screen-actions-of-the-device
Example:
| Set Screen Orientation | n | # Set orientation to natural |
| Set Screen Orientation | natural | # Do the same thing |
"""
self.device.orientation = orientation
def freeze_screen_rotation(self):
"""
Freeze the screen auto rotation
"""
self.device.freeze_rotation()
def unfreeze_screen_rotation(self):
"""
Un-Freeze the screen auto rotation
"""
self.device.freeze_rotation(False)
def screenshot(self, scale=None, quality=None):
"""
Take a screenshot of device and log in the report with timestamp, scale for screenshot size and quality for screenshot quality
default scale=1.0 quality=100
"""
output_dir = BuiltIn().get_variable_value('${OUTPUTDIR}')
ts = time.time()
st = datetime.datetime.fromtimestamp(ts).strftime('%Y%m%d%H%M%S')
screenshot_path = '%s%s%s.png' % (output_dir, os.sep, st)
self.device.screenshot(screenshot_path, scale, quality)
logger.info('\n<a href="%s">%s</a><br><img src="%s">' % (screenshot_path, st, screenshot_path), html=True)
#Watcher
# def register_click_watcher(self, watcher_name, selectors, *condition_list):
# """
# The watcher click on the object which has the selectors when conditions match
# """
# print type(selectors)
# watcher = self.device.watcher(watcher_name)
# for condition in condition_list:
# watcher.when(**condition)
# watcher.click(**selectors)
# self.device.watchers.run()
# print 'register watcher:%s' % watcher_name
# return
def __unicode_to_dict(self, a_unicode):
a_dict = dict()
dict_item_count = a_unicode.count('=')
for count in range(dict_item_count):
equal_sign_position = a_unicode.find('=')
comma_position = a_unicode.find(',')
a_key = a_unicode[0:equal_sign_position]
if comma_position == -1:
a_value = a_unicode[equal_sign_position + 1:]
else:
a_value = a_unicode[equal_sign_position + 1:comma_position]
a_unicode = a_unicode[comma_position + 1:]
a_dict[a_key] = a_value
return a_dict
def register_click_watcher(self, watcher_name, selectors, *condition_list):
"""
The watcher click on the object which has the *selectors* when conditions match
"""
watcher = self.device.watcher(watcher_name)
for condition in condition_list:
watcher.when(**self.__unicode_to_dict(condition))
watcher.click(**self.__unicode_to_dict(selectors))
self.device.watchers.run()
def register_press_watcher(self, watcher_name, press_keys, *condition_list):
"""
The watcher perform *press_keys* action sequentially when conditions match
"""
def unicode_to_list(a_unicode):
a_list = list()
comma_count = a_unicode.count(',')
for count in range(comma_count + 1):
comma_position = a_unicode.find(',')
if comma_position == -1:
a_list.append(str(a_unicode))
else:
a_list.append(a_unicode[0:comma_position])
a_unicode = a_unicode[comma_position + 1:]
return a_list
watcher = self.device.watcher(watcher_name)
for condition in condition_list:
watcher.when(**self.__unicode_to_dict(condition))
watcher.press(*unicode_to_list(press_keys))
self.device.watchers.run()
def remove_watchers(self, watcher_name = None):
"""
Remove watcher with *watcher_name* or remove all watchers
"""
if watcher_name == None:
self.device.watchers.remove()
else:
self.device.watchers.remove(watcher_name)
def list_all_watchers(self):
"""
Return the watcher list
"""
return self.device.watchers
#Selector
def get_object(self, *args, **selectors):
"""
Get the UI object with selectors *selectors*
See `introduction` for details about identified UI object.
"""
return self.device(*args, **selectors)
def get_count(self, *args, **selectors):
"""
Return the count of UI object with *selectors*
Example:
| ${count} | Get Count | text=Accessibility | # Get the count of UI object text=Accessibility |
| ${accessibility_text} | Get Object | text=Accessibility | # These two keywords combination |
| ${count} | Get Count Of Object | ${accessibility_text} | # do the same thing. |
"""
obj = self.get_object(**selectors)
return self.get_count_of_object(obj)
def get_count_of_object(self, obj):
"""
Return the count of given UI object
See `Get Count` for more details.
"""
return len(obj)
def get_info_of_object(self, obj, selector=None):
"""
return info dictionary of the *obj*
The info example:
{
u'contentDescription': u'',
u'checked': False,
u'scrollable': True,
u'text': u'',
u'packageName': u'com.android.launcher',
u'selected': False,
u'enabled': True,
u'bounds':
{
u'top': 231,
u'left': 0,
u'right': 1080,
u'bottom': 1776
},
u'className': u'android.view.View',
u'focusable': False,
u'focused': False,
u'clickable': False,
u'checkable': False,
u'chileCount': 1,
u'longClickable': False,
u'visibleBounds':
{
u'top': 231,
u'left': 0,
u'right': 1080,
u'bottom': 1776
}
}
"""
if selector:
return obj.info.get(selector)
else:
return obj.info
def click(self, *args, **selectors):
"""
click on the UI object with *selectors*
"""
self.device(**selectors).click()
def long_click(self, *args, **selectors):
"""
click on the UI object with *selectors*
"""
self.device(**selectors).long_click()
def call(self, obj, method, *args, **selectors):
"""
This keyword can use object method from original python uiautomator
See more details from https://github.com/xiaocong/uiautomator
Example:
| ${accessibility_text} | Get Object | text=Accessibility | # Get the UI object |
| Call | ${accessibility_text} | click | # Call the method of the UI object 'click' |
"""
func = getattr(obj, method)
return func(**selectors)
def set_text(self, input_text, *args, **selectors):
"""
Set *input_text* to the UI object with *selectors*
"""
self.device(**selectors).set_text(input_text)
# Other feature
def clear_text(self, *args, **selectors):
"""
Clear text of the UI object with *selectors*
"""
while True:
target = self.device(**selectors)
text = target.info['text']
target.clear_text()
remain_text = target.info['text']
if text == '' or remain_text == text:
break
def open_notification(self):
"""
open notification
Built in support for Android 4.3 (API level 18)
Using swipe action as a workaround for API level lower than 18
"""
sdk_version = self.device.info['sdkInt']
if sdk_version < 18:
height = self.device.info['displayHeight']
self.device.swipe(1, 1, 1, height - 1, 1)
else:
self.device.open.notification()
def open_quick_settings(self):
"""
open quick settings
Work for Android 4.3 above (API level 18)
"""
self.device.open.quick_settings()
def sleep(self, time):
"""
Sleep(no action) for *time* (in millisecond)
"""
target = 'wait for %s' % str(time)
self.device(text=target).wait.exists(timeout=time)
def install(self, apk_path):
"""
Install apk to the device
"""
self.adb.cmd('install "%s"' % apk_path)
def uninstall(self, package_name):
"""
Uninstall the APP with *package_name*
"""
self.adb.cmd('uninstall %s' % package_name)
def execute_adb_command(self, cmd):
"""
Execute adb *cmd*
"""
return self.adb.cmd(cmd)
def execute_adb_shell_command(self,cmd):
"""
Execute adb shell *cmd*
"""
return self.adb.shell_cmd(cmd)
def type(self, input_text, **selectors):
"""
Type *text* at current focused UI object
"""
self.test_helper.send_set_text_cmd(input_text)
def start_test_agent(self):
"""
[Test Agent]
Start Test Agent Service
"""
cmd = 'am start edu.ntut.csie.sslab1321.testagent/edu.ntut.csie.sslab1321.testagent.DummyActivity'
self.adb.shell_cmd(cmd)
def stop_test_agent(self):
"""
[Test Agent]
Stop Test Agent Service
"""
cmd = 'am broadcast -a testagent -e action STOP_TESTAGENT'
self.adb.shell_cmd(cmd)
def connect_to_wifi(self, ssid, password):
"""
[Test Agent]
Connect to *ssid* with *password*
"""
cmd = 'adb shell am start edu.ntut.csie.sslab1321.testagent/edu.ntut.csie.sslab1321.testagent.DummyActivity'
cmd = 'adb shell am broadcast -a testagent -e action CONNECT_TO_WIFI -e ssid WEP -e password 12345'
cmd = 'am broadcast -a testagent -e action CONNECT_TO_WIFI -e ssid %s -e password %s' % (ssid, password)
self.adb.shell_cmd(cmd)
def clear_connected_wifi(self):
"""
[Test Agent]
Clear all existed Wi-Fi connection
"""
cmd = 'am broadcast -a testagent -e action CLEAR_CONNECTED_WIFIS'
self.adb.shell_cmd(cmd)
def foo(self):
pass
# logger.info('\nGot arg %s %s' % (output_dir, st), also_console=True)
# clm = CommandLineWriter()
# output some messages on console
# clm.message(' ')
# clm.message(u'中文')
# clm.message(u'2----------2')
def test(self):
pass
class AndroidDevice(object):
'''
wrapper for android uiautomator-server binding(pip install uiautomator).
provide android device event inject, ui object inspect and image comparison.
'''
def __init__(self, seral=None):
'''
create device instance.
'''
self.serial = os.environ[ANDROID_SERIAL] if os.environ.has_key(ANDROID_SERIAL) else None
self.working_dir_path = WORKING_DIR_PATH
self.report_dir_path = REPORT_DIR_PATH
self.right_dir_path = WORKING_DIR_PATH
self._internal_storage_dir = DEFAULT_DEVICE_INTERNAL_STORAGE
self.d = Device(self.serial)
#try:
# if int(self.d.info['sdkInt']) <= 17:
# self.d.screenshot = self.screenshot_common
#except:
# pass
def set_internal_storage_dir(self, path):
self._internal_storage_dir = path
def __getattr__(self, attr):
'''
forward method/attrbuite to uiautomator device if method support by uiautomator.
'''
if hasattr(self.d, attr):
if attr == 'screenshot':
return self.screenshot_common
m = getattr(self.d, attr)
if inspect.ismethod(m):
def wrapper(*args, **kwargs):
return m(*args, **kwargs)
return wrapper
else:
return m
raise AttributeError(attr)
def __call__(self, *args, **kwargs):
'''
selector support:
d(text="Settings").click()
'''
return self.d(*args, **kwargs)
@property
def orientation(self):
return self.d.orientation
@orientation.setter
def orientation(self, v):
self.d.orientation = v
def serial(self):
'''
device serial number from $ANDROID_SERIAL
'''
return self.serial
def sleep(self, sec):
time.sleep(sec)
#device event inject
def start_activity(self, **intent_params):
'''
Starts an Activity on the device by sending an Intent which constructed from the specified parameters.
The params of Intent supported from adb docs:
<INTENT> specifications include these flags:
[-a <ACTION>] [-d <DATA_URI>] [-t <MIME_TYPE>]
[-c <CATEGORY> [-c <CATEGORY>] ...]
[-e|--es <EXTRA_KEY> <EXTRA_STRING_VALUE> ...]
[--esn <EXTRA_KEY> ...]
[--ez <EXTRA_KEY> <EXTRA_BOOLEAN_VALUE> ...]
[-e|--ei <EXTRA_KEY> <EXTRA_INT_VALUE> ...]
[-n <COMPONENT>] [-f <FLAGS>]
[<URI>]
@type intent_params: dictionary
@param intent_params: the properties of an Intent.
property support: component/action/data/mimetype/categories/extras/flags/uri
@rtype: AndroidDevice
@return: a instance of AndroidDevice.
'''
#d.server.adb.cmd('shell','am', 'start', '-a', 'android.intent.action.DIAL','tel:13581739891').communicate()
#sys.stderr.write(str(intent_params))
keys = intent_params.keys()
shellcmd = ['shell', 'am', 'start']
if 'component' in keys:
shellcmd.append('-n')
shellcmd.append(intent_params['component'])
if 'action' in keys:
shellcmd.append('-a')
shellcmd.append(intent_params['action'])
if 'data' in keys:
shellcmd.append('-d')
shellcmd.append(intent_params['data'])
if 'mimetype' in keys:
shellcmd.append('-t')
shellcmd.append(intent_params['mimetype'])
if 'categories' in keys:
for category in intent_params['categories']:
shellcmd.append('-c')
shellcmd.append(category)
if 'extras' in keys:
for extra_key, extra_value in intent_params['extras'].items():
str_value = ''
arg = ''
if isinstance(extra_value, types.IntType):
str_value = str(extra_value)
arg = '--ei'
elif isinstance(extra_value, types.BooleanType):
str_value = str(extra_value)
arg = '--ez'
else:
str_value = str(extra_value)
arg = '--es'
shellcmd.append(arg)
shellcmd.append(extra_key)
shellcmd.append(str_value)
if 'flags' in keys:
shellcmd.append('-f')
shellcmd.append(str(intent_params['flags']))
if 'uri' in keys:
shellcmd.append(intent_params['uri'])
if 'package' in keys:
shellcmd.append(intent_params['package'])
#sys.stderr.write(str(shellcmd))
self.d.server.adb.cmd(*shellcmd).communicate()
return self
def instrument(self, **kwargs):
'''
Run the specified package with instrumentation and return the output it generates.
Use this to run a test package using InstrumentationTestRunner.
Typically this target <COMPONENT> is the form <TEST_PACKAGE>/<RUNNER_CLASS>.
Options are:
-w: wait for instrumentation to finish before returning. Required for test runners.
-r: print raw results (otherwise decode REPORT_KEY_STREAMRESULT).
Use with [-e perf true] to generate raw output for performance measurements.
-e <NAME> <VALUE>: set argument <NAME> to <VALUE>.
For test runners a common form is [-e <testrunner_flag> <value>[,<value>...]].
-p <FILE>: write profiling data to <FILE>
--user <USER_ID> | current: Specify user instrumentation runs in; current user if not specified.
--no-window-animation: turn off window animations will running.
@type intent_params: dictionary
@param intent_params: the properties of an instrumentation testing.
property support: packagename, <NAME> to <VALUE>.
@rtype: AndroidDevice
@return: a instance of AndroidDevice.
'''
keys = kwargs.keys()
shellcmd = ['shell', 'am', 'instrument', '-w', '-r']
pkgname = kwargs.pop('packagename')
for k, v in kwargs.items():
if k and v:
shellcmd.append('-e')
shellcmd.append(k)
shellcmd.append(str(v))
shellcmd.append(pkgname)
result = self.d.server.adb.cmd(*shellcmd).communicate()
return result
def click(self, *args, **kwargs):
'''
example:
click(x,y)
Click the screen location specified by x and y.
Format: (x,y) the screen location specified by x and y.
x The horizontal position of the touch in actual device pixels, starting from the left of the screen in its current orientation.
y The vertical position of the touch in actual device pixels, starting from the top of the screen in its current orientation.
click('phone_app.png', rotation=90)
Perform a click event on the center point on the expected screen region.
If the screen region want to click not found in the current screen snapshot will do nothing
rotation: 0, 90, 180, 270
'''
if args:
if isinstance(args[0], types.IntType):
self.__click_point(*args, **kwargs)
return self
if isinstance(args[0], types.StringType):
self.__click_image(*args, **kwargs)
return self
def __click_point(self, x, y, waittime=1):
'''
click x,y
'''
self.d.click(x, y)
time.sleep(waittime)
def __click_image(self, imagename, waittime=1, threshold=0.01, rotation=0):
'''
if the wanted image found on current screen click it.
if the wanted image not found raise exception and set test to be failure.
'''
expect_image_path = None
current_image_path = None
if os.path.isabs(imagename):
expect_image_path = imagename
current_image_path = join(self.report_dir_path, os.path.basenme(imagename))
else:
expect_image_path = join(self.right_dir_path, imagename)
current_image_path = join(self.report_dir_path, imagename)
assert os.path.exists(expect_image_path), 'the local expected image %s not found!' % expect_image_path
self.d.screenshot(current_image_path)
assert os.path.exists(current_image_path), 'fetch current screen shot image %s failed!' % imagename
pos = getMatchedCenterOffset(subPath=expect_image_path, srcPath=current_image_path, threshold=0.01, rotation=rotation)
if not pos:
reason = 'Fail Reason: The wanted image \'%s\' not found on screen!' % imagename
raise ExpectException(expect_image_path, current_image_path, reason)
self.d.click(pos[0], pos[1])
time.sleep(waittime)
def screenshot_common(self, filename):
'''
if SK version <= 16
Capture the screenshot via adb and store it in the specified location.
'''
png = os.path.basename(filename)
if self.serial:
shell('adb -s %s shell screencap %s%s' % (self.serial, self._internal_storage_dir, png))
shell('adb -s %s pull %s%s %s' % (self.serial, self._internal_storage_dir, png, filename))
else:
shell('adb shell screencap %s%s' % (self._internal_storage_dir, png))
shell('adb pull %s%s %s' % (self._internal_storage_dir, png, filename))
return True
#inspect
def exists(self, **kwargs):
'''
if the expected component exists on current screen layout return true else return false.
'''
return self.d.exists(**kwargs)
def expect(self, imagename, interval=2, timeout=4, threshold=0.01, msg=''):
'''
if the expected image found on current screen return self
else raise exception. set test to be failure.
'''
expect_image_path = None
current_image_path = None
if os.path.isabs(imagename):
expect_image_path = imagename
current_image_path = join(self.report_dir_path, os.path.basenme(imagename))
else:
expect_image_path = join(self.right_dir_path, imagename)
current_image_path = join(self.report_dir_path, imagename)
assert os.path.exists(expect_image_path), 'the local expected image %s not found!' % expect_image_path
begin = time.time()
while (time.time() - begin < timeout):
self.d.screenshot(current_image_path)
if isMatch(expect_image_path , current_image_path , threshold):
return self
time.sleep(interval)
reason = msg if msg else 'Fail Reason: Image \'%s\' not found on screen!' % imagename
raise ExpectException(expect_image_path, current_image_path, reason)
def find(self, imagename, interval=2, timeout=4, threshold=0.01):
'''
if the expected image found on current screen return true else return false
'''
expect_image_path = None
current_image_path = None
if os.path.isabs(imagename):
expect_image_path = imagename
current_image_path = join(self.report_dir_path, os.path.basenme(imagename))
else:
expect_image_path = join(self.right_dir_path, imagename)
current_image_path = join(self.report_dir_path, imagename)
assert os.path.exists(expect_image_path), 'the local expected image %s not found!' % expect_image_path
begin = time.time()
isExists = False
while (time.time() - begin < timeout):
time.sleep(interval)
self.d.screenshot(current_image_path)
isExists = isMatch(expect_image_path , current_image_path , threshold)
if not isExists:
time.sleep(interval)
continue
return isExists
def TODOinstallPackage(self, **kwargs):
pass
def TODOremovePackage(self, **kwargs):
pass
def connect(self):
self.d = Device(self.serialno)
def getPluginClass():
return MMCQQNearbyPeopleSendText
if __name__ == "__main__":
# global args
import sys
reload(sys)
sys.setdefaultencoding("utf-8")
clazz = getPluginClass()
o = clazz()
d = Device("HT54WSK00081")
z = ZDevice("HT54WSK00081")
args = {
"time_delay": "3",
"set_timeStart": "0",
"set_timeEnd": "0",
"startTime": "0",
"endTime": "8",
"textnum": "20",
"gender": "男",
"selectTime": "1小时",
"repo_material_id": "39"
} #cate_id是仓库号，length是数量
o.action(d, z, args)
def hold_call(callee):
d=Device(callee.id,adb_server_host='127.0.0.1',adb_server_port=5037)
print "finding the button"
d(resourceId='com.asus.asusincallui:id/holdButton').click()
d.screenshot('incall.png')
print "pressed the button"
def __init__(self, serial_no):
self.serial = serial_no
Device.__init__(self, serial_no)
def __init__(self):
self.serial = self._get_serial()
self.automation_handle = Device(self.serial)
self.name = self._get_monitor_name()
def __init__(self, **kwargs):
adb_step.__init__(self, **kwargs)
# replacing old uidevice available in testlib/external with standard
# uiautomator device class
self.uidevice = Device(serial=self.serial)
class Monitor:
def __init__(self, environment, monitor_serial):
self.monitor_serial = monitor_serial
self.specifying_monitor = '-s {}'.format(self.monitor_serial)
self.device = Device(self.monitor_serial)
self.build_location ="mon_test\Apps\monitor_build\dev-dell-release-SINK-0.0.3143.7736342\system"
self.build_version = self.get_build_version()
self.monitor_name = self.get_monitor_name_by_ui()
self.find_command = " | findstr" if platform.platform() == "Windows" else "| grep"
print 'Monitor:init - orientation=%s' % self.device.orientation
def auto_approve_connection(self):
print('changing to auto aprrove in monitor : {}'.format(self.monitor_name))
self.device(resourceId="com.screenovate.dell.monitorserver:id/settings").click()
self.device(resourceId="com.screenovate.dell.monitorserver:id/security_settings").click()
self.device(text="Auto Approve").click()
self.device(resourceId="android:id/button1").click()
def approve_connection(self):
os.system('adb -s {} shell am broadcast -a com.screenovate.sink.action.ACCEPT_PAIR'.format(self.monitor_serial))
def decline_connection(self):
os.system('adb -s {} shell am broadcast -a com.screenovate.sink.action.DECLINE_PAIR'.format(self.monitor_serial))
def start_intent_of_approve(self):
os.system('adb -s {} shell am broadcast -a com.screenovate.intent.action.P2P_DIALOG_REQUEST'.format(self.monitor_serial))
def get_screen_size(self):
size = "adb -s {} shell wm size".format(self.monitor_serial)
output = subprocess.check_output([s for s in size.split()])
return output.split(':')[1].strip()
def install_build(self):
os.system("adb -s {} root".format(self.monitor_serial))
os.system("adb -s {} wait-for-device remount".format(self.monitor_serial))
time.sleep(6)
commandToExecute = ("adb -s {} push {} /system/".format(self.monitor_serial, self.build_location))
os.system(commandToExecute)
time.sleep(1)
self.reboot_mon()
def reboot_mon(self):
checkBootComp = 'adb {} shell getprop sys.boot_completed'.format(self.specifying_monitor)
output = subprocess.check_output([c for c in checkBootComp.split()])
print('start rebbot monitor')
os.system('adb {} reboot'.format(self.specifying_monitor))
self.is_boot_completed(output)
print('reboot monitor completed')
def is_boot_completed(self, bootCompCmd):
output = '-1'
while output != bootCompCmd:
time.sleep(1)
try:
screenUp = 'adb {} shell getprop sys.boot_completed'.format(self.specifying_monitor)
output = subprocess.check_output([s for s in screenUp.split()])
except Exception:
print('waiting for monitor')
print('Screen up and fully loaded')
return True
def do_factory_reset(self):
checkBootComp = 'adb {} shell getprop sys.boot_completed'.format(self.specifying_monitor)
output = subprocess.check_output([c for c in checkBootComp.split()])
print('Start doing reboot to the monitor')
self.device(resourceId="com.screenovate.dell.monitorserver:id/settings").click()
self.device(resourceId="com.screenovate.dell.monitorserver:id/reset").click()
self.device(resourceId="com.screenovate.dell.monitorserver:id/reset_ok").click()
print('Start doing factory rest...')
os.system("adb {} logcat".format(self.specifying_monitor))
self.is_boot_completed(output)
def set_wifi_channel(self, channel):
print('Setting wifi channel to {} '.format(channel))
self.device(resourceId="com.screenovate.dell.monitorserver:id/settings").click()
self.device(resourceId="com.screenovate.dell.monitorserver:id/set_wifi_channel").click()
auto_is_checked = self.device(resourceId="com.screenovate.dell.monitorserver:id/channel_auto_checkbox").info['checked']
channel_24_is_checked = self.device(resourceId="com.screenovate.dell.monitorserver:id/channel_auto24_checkbox").info['checked']
channel_5_is_checked = self.device(resourceId="com.screenovate.dell.monitorserver:id/channel_auto5_checkbox").info['checked']
if auto_is_checked or channel_5_is_checked or channel_24_is_checked:
self.device(resourceId="com.screenovate.dell.monitorserver:id/show_advanced").click()
self.device(resourceId="com.screenovate.dell.monitorserver:id/channel_custom_checkbox").click()
self.device(text=channel, className="android.widget.TextView").click()
self.device(resourceId="com.screenovate.dell.monitorserver:id/channel_ok").click()
def get_build_version(self):
build_name = self.build_location
return build_name[build_name.find('K-') + 2:build_name.find("/sys")]
def check_build_version(self):
print('checking version of the build')
build_version = 'adb {} shell dumpsys package com.screenovate.dell.monitorserver'.format(
self.specifying_monitor)
output = subprocess.check_output([b for b in build_version.split()])
return ("versionName={}".format(self.build_version) in output)
def get_monitor_name_by_adb(self):
dumpsys = "adb shell dumpsys | {} wifiP2pDevice=Device".format(self.find_command)
output = subprocess.check_output([c for c in dumpsys.split()])
start_index = output.rfind('Device: ', 0)
start_index = start_index + 8
end_index = output.rfind("\n", 0)
name = output[start_index: end_index].strip()
return name
def verify_nothing_connected(self):
print('verifying nothing connected')
if self.device.exists(resourceId="com.screenovate.dell.monitorserver:id/video_view"):
print('some device connected to monitor , stsrt rebooting monitor')
self.reboot_mon()
print('no device currently connected to monitor')
def get_monitor_name_by_ui(self):
self.verify_nothing_connected()
print("get name from " + self.monitor_serial)
self.monitor_name = self.device(resourceId="com.screenovate.dell.monitorserver:id/ssid").info[
"text"]
return self.monitor_name
def screen_on(self):
print("turning monitor screen on")
os.system("adb {} shell input keyevent 82".format(self.specifying_monitor))
def take_screenshot_test(self):
self.device.screenshot("pictures-test/monitor.png")
