def init():
result = run_script(CMD_GET_TCPIP)
if result != "5555":
run_script(CMD_TCPIP)
time.sleep(2)
connect()
if result:
connect()
def get_property(name=None):
infos = run_script(
adb_path + " -s " + name +
" shell getprop | grep 'ro.build.version.release]\|ro.build.version.sdk]\|ro.product.manufacturer]\|ro.product.model\|ro.build.display.id]' | awk -F'[][]' -v n=2 '{ print $(2*n) }'"
)
infos = infos.rstrip().split('\n')
return infos
def main(wf):
arg = wf.args[0].strip()
apps = run_script(CMD_LIST_APPS)
apps = apps.rstrip().split('\n')
for app in apps:
if arg is '' or arg in app:
wf.add_item(title=app, uid=app, arg=app, valid=True)
wf.send_feedback()
def connect():
result = run_script(CMD_ADB_CONNECT.format(ip.split("/")[0]))
if "connected to" in result:
it = Item(title=result.strip().split("connected to ")[1],
subtitle=os.getenv("full_info"),
mask=ip.split("/")[1])
wifiDevices = []
wifiDevices.append(it)
run_in_background("update_wifi_history", [
'/usr/bin/python',
wf.workflowfile('scripts/update_wifi_history.py'), 'add',
pickle.dumps(wifiDevices)
])
print("Executed: " + result)
def main(wf):
try:
result = run_script(CMD_DUMP_STACK)
stackData = result.split("\n")
log.debug(stackData)
if stackData:
activityList = []
for index in range(len(stackData)):
data = stackData[index].strip()
if index % 2 == 0:
start = data.find(" u0 ") + 4
activityData = data[start:data.find(" ", start)]
packageName = activityData.split("/")[0]
activityName = activityData.split("/")[1]
if activityName.startswith("."):
activityName = packageName + activityName
activityList.append(
Activity(name=activityName, package=packageName))
else:
activityList[-1] = activityList[-1].setAffinity(
stackData[index].strip()[13:])
for item in activityList:
if mod == "first_app" and item.package != activityList[
0].package:
continue
elif mod == "first_stack" and item.affinity != activityList[
0].affinity:
continue
simpleName = item.name.split('.')[-1]
it = wf.add_item(title=item.name,
subtitle='Affinity: ' + item.affinity,
autocomplete=simpleName,
match=simpleName,
arg=item.name,
copytext=item.name,
valid=True)
it.add_modifier("cmd", subtitle="Package: " + item.package)
wf.send_feedback()
except:
log.debug("Error")
import os
import sys
from toolchain import run_script
from commands import CMD_GET_POINTER_LOCATION
from commands import CMD_SET_POINTER_LOCATION
isOff = (os.getenv("function") == "debug_off")
try:
result = run_script(CMD_GET_POINTER_LOCATION)
isOn = (result == '1') or isOff
sys.stderr.write("Pointer location is " + ("OFF", "ON")[isOn])
shell_cmd = CMD_SET_POINTER_LOCATION.format(("1", "0")[isOn])
run_script(shell_cmd)
print("Pointer location is " + ("ON", "OFF")[isOn])
except:
print("Failed to toggle pointer location")
import os
from toolchain import run_script
adb_path = os.getenv('adb_path')
ip = os.getenv('ip')
if ip and ip[-5:] != ":5555":
ip = ip + ":5555"
shell_cmd = '{0} connect {1}'.format(adb_path, ip)
try:
result = run_script(shell_cmd)
print("Executed: adb connect " + ip)
except:
print("Failed to execute: adb connect " + ip)
import os
import sys
from toolchain import run_script
from commands import CMD_GET_GPU_OVERDRAW
from commands import CMD_SET_GPU_OVERDRAW
isOff = (os.getenv("function") == "debug_off")
try:
result = run_script(CMD_GET_GPU_OVERDRAW)
isOn = (result == 'show') or isOff
sys.stderr.write("GPU overdraw is " + ("OFF", "ON")[isOn])
shell_cmd = CMD_SET_GPU_OVERDRAW.format(("show", "false")[isOn])
run_script(shell_cmd)
print("GPU overdraw is " + ("ON", "OFF")[isOn])
except:
print("Failed to toggle GPU overdraw")
def list_devices(args):
arg = args[0] if args else ''
devices = run_script(adb_path + " devices -l | sed -n '1!p' | tr -s ' '")
devices = devices.rstrip().split('\n')
items, wifiDevices = get_device_items(arg, devices)
if wifiDevices:
run_in_background("update_wifi_history", [
'/usr/bin/python',
wf.workflowfile('scripts/update_wifi_history.py'), 'add',
pickle.dumps(wifiDevices)
])
log.error("Save history wifi devices : count : {0}".format(
len(wifiDevices)))
for item in items:
name = item.get('serial')
log.debug(arg + " " + name)
if arg == '' or arg.lower() in name.lower():
it = wf.add_item(title=item.title,
uid=item.title,
autocomplete=('', item.autocomplete)[item.valid],
valid=item.valid,
arg=item.arg,
subtitle=item.subtitle)
it.setvar('status', item.get("status"))
it.setvar('full_info', item.subtitle)
if item.valid:
it.setvar('device_api', item.get('device_api'))
it.setvar("serial", name)
it.setvar('name', item.get('name'))
if item.subtitle and not re.match(regexIp + ":5555", name):
cmd_ip = adb_path + ' -s ' + name + " shell ip -f inet addr show wlan0 | grep inet | tr -s ' ' | awk '{print $2}'"
ip = run_script(cmd_ip)
if '/' in ip and re.match(regexIp, ip.split('/')[0]):
it.setvar("ip", ip.strip('\n'))
it.add_modifier("cmd", subtitle=ip)
if item.get("build_number"):
it.add_modifier("alt", subtitle=item.get("build_number"))
# last func
if name.startswith("emulator-"):
name = hashlib.md5(item.subtitle).hexdigest()
it.setvar("his_tag", name)
lastFuncs = wf.cached_data('last_func:' + name, max_age=0)
if lastFuncs and len(lastFuncs) > 0:
log.debug(lastFuncs)
last_func = lastFuncs[len(lastFuncs) - 1]
mod = it.add_modifier(
"ctrl", subtitle="run last command {}".format(last_func))
mod.setvar("last_func", last_func)
mod = it.add_modifier("fn",
subtitle="show command history",
arg="cmd_history")
mod.setvar("function", "cmd_history")
# CONNECT
if arg and ("connect ".startswith(arg.lower())
or re.match(regexConnect, arg)):
localIpWithMask = run_script(
'ifconfig | grep -A 1 "en" | grep broadcast | cut -d " " -f 2,4 | tr "\\n" " "'
)
localIp = localIpWithMask.split(" ")[0]
rawMask = localIpWithMask.split(" ")[1].count("f") * 4
targetIp = arg[8:]
if localIp:
history = wf.stored_data("wifi_history")
counter = 0
valid = True if re.match("^" + regexIp + "(:|:5|:55|:555|:5555)?$",
targetIp) else False
if valid:
subtitle = "adb connect " + targetIp if targetIp else ''
it = wf.add_item(title="Connect over WiFi",
valid=valid,
arg="adb_connect",
subtitle=subtitle)
m = it.add_modifier('cmd',
subtitle="Remove all connection histories",
arg='adb_connect_remove')
m.setvar('extra', "all")
it.setvar("ip", targetIp.strip('\n'))
if history:
historyWifiDevices = pickle.loads(history)
currentDevices = []
for item in items:
currentDevices.append(item.title.strip())
for historyWifiDevice in historyWifiDevices:
if not historyWifiDevice.title in currentDevices:
deviceIp = historyWifiDevice.title.split(":")[0]
same_network = False
if hasattr(historyWifiDevice,
'mask') and historyWifiDevice.mask:
same_network = ipaddress.ip_network(
u'%s/%d' % (localIp, rawMask),
False) == ipaddress.ip_network(
u'%s/%s' %
(deviceIp, historyWifiDevice.mask), False)
else:
same_network = ipaddress.ip_network(
u'%s/%d' % (localIp, rawMask),
False) == ipaddress.ip_network(
u'%s/%d' % (deviceIp, rawMask), False)
if not same_network:
continue
if arg and historyWifiDevice.title.find(
targetIp) == -1:
continue
log.debug("history item title " +
historyWifiDevice.title)
title = "Connect over WiFi"
if historyWifiDevice.subtitle:
title = "Connect " + historyWifiDevice.subtitle.split(
'- ', 1)[1].split(', ', 1)[0] + " over WiFi"
it = wf.add_item(
title=title,
valid=True,
arg="adb_connect",
autocomplete="connect " + historyWifiDevice.title,
subtitle=historyWifiDevice.title,
uid=(historyWifiDevice.title, "")[valid])
it.setvar("ip", historyWifiDevice.title)
it.add_modifier(
'cmd',
'Remove connection history with {0}'.format(
historyWifiDevice.title),
arg='adb_connect_remove')
it.add_modifier('alt', historyWifiDevice.subtitle)
counter += 1
if not valid and counter == 0:
if (not targetIp or re.match(regexIpInput, targetIp)):
subtitle = "adb connect " + targetIp if targetIp else ''
if not targetIp:
it = wf.add_item(title="Connect over WiFi",
valid=False,
arg="adb_connect",
autocomplete="connect ",
subtitle=subtitle)
else:
it = wf.add_item(title="Connect over WiFi",
valid=False,
arg="adb_connect",
subtitle=subtitle)
# DISCONNECT
if wifiDevices:
log.debug(wifiDevices[0].title)
if arg and ("disconnect ".startswith(arg.lower())
or re.match("^disconnect .*", arg)):
targetIp = arg[11:]
if wifiDevices:
for wifiDevice in wifiDevices:
it = wf.add_item(title="Disconnect from WiFi",
uid=wifiDevice.title,
valid=True,
arg="adb_disconnect",
autocomplete="disconnect ",
subtitle=wifiDevice.title)
ip = wifiDevice.title
if "[OFFLINE]" in ip:
ip = ip.split(" ")[0]
it.setvar("ip", ip)
elif targetIp:
it = wf.add_item(title="Disconnect from WiFi",
uid="adb_disconnect",
valid=True,
arg="adb_disconnect",
autocomplete="disconnect ",
subtitle="adb disconnect " + targetIp)
it.setvar("ip", targetIp)
if arg and ("restart".startswith(arg.lower()) or "kill-server".startswith(
arg.lower()) or "start-server".startswith(arg.lower())) or (
len(items) == 0 and
(len(arg) == 0 or
(not arg.lower().startswith("connect")
and not arg.lower().startswith("disconnect")))):
wf.add_item(title="Restart adb",
valid=True,
arg="restart_adb",
uid="restart_adb")
import os
import sys
from toolchain import run_script
from commands import CMD_CUSTOM_COMMAND
cmd = os.getenv('cmd')
try:
run_script(CMD_CUSTOM_COMMAND.format(cmd))
print("Executed: " + cmd)
except:
print("Failed to execute: adb " + cmd)
import os
from toolchain import run_script
from commands import CMD_SHOW_APK_PATH
from commands import CMD_PULL_APK_TO_DESKTOP
package = os.getenv('package')
prettyVersion = os.getenv('pretty_version')
try:
result = run_script(CMD_SHOW_APK_PATH.format(package))
if result and result.startswith("package:"):
path = result[8:].strip()
run_script(CMD_PULL_APK_TO_DESKTOP.format(path, package,
prettyVersion))
print("Apk extracted to desktop")
else:
print("Failed to extract apk")
except:
print("Failed to extract apk")
import os
from toolchain import run_script
from commands import CMD_CLEAR_DATA
package = os.getenv('package')
try:
run_script(CMD_CLEAR_DATA.format(package))
print("Data clear " + package + " succeed")
except:
print("Data clear " + package + " failed")
import os
from toolchain import run_script
from commands import CMD_APP_INFO
package = os.getenv('package')
try:
run_script(CMD_APP_INFO.format(package))
print("App info of " + package + " shown")
except:
print("Failed to show app info of " + package)
def main(wf):
shell_cmd = CMD_DUMP_PACKAGE.format(packName)
result = None
infos= None
versionName = ""
enabled = True
# Package info
try:
result = run_script(shell_cmd)
except subprocess.CalledProcessError as e:
log.debug(e)
if result:
result = result[result.rfind("enabled="):]
infos = result.rstrip().split('\n')
log.debug(infos)
versionName = infos[1].strip()[12:]
versionCode = infos[2].strip()[12:]
it = wf.add_item(title=packName,
subtitle="{0}({1})".format(versionName, versionCode),
valid=False,
copytext=packName,
icon=ICON_INFO)
if infos:
appInfo = infos[0].strip()
enabled = (appInfo[appInfo.find("enabled=") + 8] != '2')
log.debug("enabled ? {0}".format(enabled))
# App info
title = "App info"
wf.add_item(title=title,
subtitle="Open app info page",
arg="app_info",
valid=True)
if (infos and enabled):
# Force stop
title = "Force stop"
wf.add_item(title=title,
arg="force_stop",
valid=True)
if (infos and len(infos) > 3 and enabled):
# Start app
title = "Start application"
wf.add_item(title=title,
arg="start_app",
valid=True)
# Clear data
title = "Clear app data"
wf.add_item(title=title,
arg="clear_app_data",
valid=True)
# Uninstall
title = "Uninstall app"
it = wf.add_item(title=title,
arg="uninstall_app",
subtitle="`cmd` to keep data and cache",
valid=True)
mod = it.add_modifier("cmd", subtitle="keep the data and cache directories")
mod.setvar("mod", "keep_data")
if infos:
# Disable/Enable app
title = ("Enable app", "Disable app")[enabled]
it = wf.add_item(title=title,
arg="dis_enable_app",
valid=True)
it.setvar("enabled", enabled)
# Get apk file
title = "Extract apk file"
it = wf.add_item(title=title,
arg="extract_apk",
valid=True)
if versionName:
it.setvar("pretty_version", versionName)
wf.send_feedback()
import os
from toolchain import run_script
from commands import CMD_UNINSTALL_APP
package = os.getenv('package')
param = ""
if os.getenv('mod') == "keep_data":
param = "-k"
try:
run_script(CMD_UNINSTALL_APP.format(param, package))
print("Uninstall app " + package + " succeed")
except:
print("Uninstall app " + package + " failed")
import os
from toolchain import run_script
from commands import CMD_GET_SHOW_TAPS
from commands import CMD_SET_SHOW_TAPS
isOff = (os.getenv("function") == "debug_off")
try:
result = run_script(CMD_GET_SHOW_TAPS)
isOn = (result[-1:] == '1') or isOff
shell_cmd = CMD_SET_SHOW_TAPS.format(("1", "0")[isOn])
run_script(shell_cmd)
print("Show taps is " + ("ON", "OFF")[isOn])
except:
print("Failed to toggle show taps")
import os
from toolchain import run_script
adb_path = os.getenv('adb_path')
response = run_script('{0} kill-server && {1} start-server'.format(adb_path, adb_path))
if 'daemon started successfully' in response:
print('adb successfully restarted')
else:
print('Failed to restart adb')
import os
from toolchain import run_script
from commands import CMD_DISABLE_APP
package = os.getenv('package')
enabled = os.getenv('enabled')
try:
run_script(CMD_DISABLE_APP.format(("enable", "disable")[enabled=='1'], package))
print(("Enable", "Disable")[enabled=='1'] + " app " + package + " succeed")
except:
print(("Enable", "Disable")[enabled=='1'] + " app " + package + " failed")
import os
from toolchain import run_script
from commands import CMD_LAUNCH_APP
package = os.getenv('package')
try:
run_script(CMD_LAUNCH_APP.format(package))
print("Launch app " + package + " succeed")
except:
print("Launch app " + package + " failed")
import os
from toolchain import run_script
from commands import CMD_GET_DEBUG_LAYOUT
from commands import CMD_SET_DEBUG_LAYOUT
isOff = (os.getenv("function") == "debug_off")
try:
result = run_script(CMD_GET_DEBUG_LAYOUT)
isOn = ('off', 'on')[result.lower() != 'on' and not isOff]
shell_cmd = CMD_SET_DEBUG_LAYOUT.format(isOn)
result = run_script(shell_cmd)
print("Debug layout is " + isOn)
except:
print("Failed to toggle debug layout")
from toolchain import run_script
from commands import CMD_DEMO_MODE_STATUS
from commands import CMD_DEMO_MODE_EXIT
from commands import CMD_DEMO_MODE_DISABLE
from commands import CMD_DEMO_MODE_ENABLE
from commands import CMD_DEMO_MODE_ENTER
from commands import CMD_DEMO_MODE_CLOCK
from commands import CMD_DEMO_MODE_BATTERY
from commands import CMD_DEMO_MODE_MOBILE
from commands import CMD_DEMO_MODE_WIFI
from commands import CMD_DEMO_MODE_NOTIFICATION
import sys
try:
result = run_script(CMD_DEMO_MODE_STATUS)
if result == 'null\n' or int(result) != 0:
sys.stderr.write("Turn demo mode off")
run_script(CMD_DEMO_MODE_EXIT)
run_script(CMD_DEMO_MODE_DISABLE)
else:
sys.stderr.write("Turn demo mode on")
run_script(CMD_DEMO_MODE_ENABLE)
run_script(CMD_DEMO_MODE_ENTER)
run_script(CMD_DEMO_MODE_CLOCK)
run_script(CMD_DEMO_MODE_BATTERY)
run_script(CMD_DEMO_MODE_MOBILE)
run_script(CMD_DEMO_MODE_WIFI)
import os
from toolchain import run_script
from commands import CMD_FORCE_STOP
package = os.getenv('package')
try:
run_script(CMD_FORCE_STOP.format(package))
print("Force stop " + package + " succeed")
except:
print("Force stop " + package + " failed")
import os
from toolchain import run_script
from commands import CMD_REBOOT
# `function` could be `adb_reboot:bootloader`
cmd = os.getenv('function')[11:]
shell_cmd = CMD_REBOOT.format(cmd)
try:
run_script(shell_cmd)
print("Reboot device succeed")
except:
print("Reboot device failed")
optionArg = ""
if options:
for option in options:
if option and option.strip():
optionArg = optionArg + " -" + option
try:
if apkFiles:
totalFiles = len(apkFiles)
installResults = 0
sys.stderr.write("Step 1 {0}\n".format(totalFiles))
for apkFile in apkFiles:
sys.stderr.write("Step 2" + "\n")
if not apkFile:
continue
result = run_script(
CMD_INSTALL_APP.format(optionArg,
(pipes.quote(apkFile),
apkFile)[apkFile.startswith('\"')
or apkFile.startswith("\'")]))
if "Failure [" not in result and "Error:" not in result:
installResults = installResults + 1
sys.stderr.write(result + "\n")
if installResults == totalFiles:
print("Install app succeed")
else:
print("Install app failed, {0}/{1} failed".format(
totalFiles - installResults, totalFiles))
except:
print("Install app failed")
def main(wf):
arg = wf.args[0].strip()
log.debug(arg)
addAll = False
if arg == '':
addAll = True
itemCount = 0
wf.setvar("function", "keyevent")
# Back
title = "Back"
if addAll or wordMatch(arg, title):
it = wf.add_item(title=title,
uid="KEYCODE_BACK",
arg="KEYCODE_BACK",
valid=True)
it.setvar('mod', 'none')
m = it.add_modifier('cmd', 'Long press ' + arg)
m.setvar('mod', 'cmd')
itemCount += 1
# Home
title = "Home"
if addAll or wordMatch(arg, title):
it = wf.add_item(title=title,
uid="KEYCODE_HOME",
arg="KEYCODE_HOME",
valid=True)
it.setvar('mod', 'none')
m = it.add_modifier('cmd', 'Long press ' + arg)
m.setvar('mod', 'cmd')
itemCount += 1
# APP SWITCH
title = "App switch"
if addAll or wordMatch(arg, title + " recent"):
it = wf.add_item(title=title,
uid="KEYCODE_APP_SWITCH",
arg="KEYCODE_APP_SWITCH",
valid=True)
it.setvar('mod', 'none')
m = it.add_modifier('cmd', 'Long press ' + arg)
m.setvar('mod', 'cmd')
itemCount += 1
# REBOOT SYSTEM
title = "Power"
if addAll or wordMatch(arg, title):
it = wf.add_item(title=title,
uid="KEYCODE_POWER",
arg="KEYCODE_POWER",
valid=True)
it.setvar('mod', 'none')
m = it.add_modifier('cmd', 'Long press ' + arg)
m.setvar('mod', 'cmd')
itemCount += 1
# STATUS BAR
title = "Status bar"
if addAll or wordMatch(arg, title):
it = wf.add_item(title=title,
uid="STATUS_BAR",
arg="STATUS_BAR",
subtitle="Toggle status bar menu",
valid=True)
it.setvar("function", "STATUS_BAR")
itemCount += 1
# KEYBOARD
title = "Hide keyboard"
result = run_script(CMD_CHECK_KEYBOARD)
if (addAll or wordMatch(arg, title)) and "true" in result:
it = wf.add_item(title=title,
uid="KEYCODE_ESCAPE",
arg="KEYCODE_ESCAPE",
valid=True)
it.setvar('mod', 'none')
itemCount += 1
# OTHER KEYEVENTS
if re.match("keycode_\w*", arg.lower()):
it = wf.add_item(title="Other keyevents",
subtitle="input keyevent " + arg.upper(),
arg=arg.upper(),
valid=True)
it.setvar('mod', 'none')
m = it.add_modifier('cmd', 'Long press ' + arg.upper())
m.setvar('mod', 'cmd')
itemCount += 1
# INPUT TEXT
if itemCount == 0:
log.debug("arg :" + arg)
it = wf.add_item(title="Input as text",
subtitle="input text " + arg,
arg=arg,
valid=True)
it.setvar("function", "text")
wf.send_feedback()
from toolchain import run_script
from commands import CMD_CURRENT_FOCUS
from commands import CMD_CALL_STATUSBAR
from commands import CMD_INPUT
cmd = os.getenv('function')
text = os.getenv('key')
mod = os.getenv('mod')
if cmd == "text":
text = pipes.quote(text.replace(" ", "%s"))
shell_cmd = ""
if cmd == "STATUS_BAR":
result = run_script(CMD_CURRENT_FOCUS)
expanded = "StatusBar" in result
shell_cmd = CMD_CALL_STATUSBAR.format(("1", "2")[expanded])
elif cmd == "KEYBOARD":
shell_cmd = CMD_INPUT.format(cmd, mod, text)
else:
shell_cmd = CMD_INPUT.format(cmd, ("", "--longpress")[mod == "cmd"], text)
try:
run_script(shell_cmd)
print("Executed: " + cmd)
except:
print("Failed to execute: adb " + cmd)
import os
import sys
from toolchain import run_script
from commands import CMD_GET_GPU_PROFILE
from commands import CMD_SET_GPU_PROFILE
isOff = (os.getenv("function") == "debug_off")
try:
result = run_script(CMD_GET_GPU_PROFILE)
isOn = (result == 'visual_bars') or isOff
sys.stderr.write("GPU profile is " + ("OFF", "ON")[isOn])
shell_cmd = CMD_SET_GPU_PROFILE.format(("visual_bars", "false")[isOn])
run_script(shell_cmd)
print("GPU profile is " + ("ON", "OFF")[isOn])
except:
print("Failed to toggle GPU profile")
from commands import CMD_SCREENCAP
from commands import CMD_PULL_TEMP_TO_DESKTOP
from commands import CMD_RM_TEMP
datetime = os.getenv('time')
mod = os.getenv('function')[11:]
shell_cmd_1 = CMD_SCREENCAP.format(datetime)
shell_cmd_2 = CMD_PULL_TEMP_TO_DESKTOP.format(
datetime, ("/tmp/", "~/Desktop/")[mod == "to_desktop"])
shell_cmd_3 = CMD_RM_TEMP.format(datetime)
import sys
sys.stderr.write("\n {} \n".format(mod))
try:
run_script(shell_cmd_1)
run_script(shell_cmd_2)
run_script(shell_cmd_3)
local_path = ""
if mod and mod == "to_desktop":
local_path = "~/Desktop/screenshot_{0}.jpg".format(datetime)
else:
local_path = "/tmp/screenshot_{0}.jpg".format(datetime)
if mod and mod == "to_clipboard":
if call_script(['which', 'osascript']) == 0:
shell_cmd_4 = "osascript -e 'on run args' -e 'set thisFile to item 1 of args' -e 'set the clipboard to (read thisFile as JPEG picture)' -e return -e end {0}".format(
local_path)
run_script(shell_cmd_4)
elif call_script(['which', 'xclip']) == 0:
