def connect(deviceid):
try:
cnx = initmysql()
cursor = mysqlCursor(cnx)
query = execQuery(
cursor,
"SELECT port,name FROM lords.devices where id=" + str(deviceid))
field_name = [field[0] for field in query.description]
result_set = query.fetchone()
if result_set != None:
row = dict(zip(field_name, result_set))
portNo = int(row['port'])
emulatorname = row['name']
else:
portNo = 5037
print("name ", emulatorname)
adb = Client(host='127.0.0.1', port=portNo)
devices = adb.devices()
if len(devices) == 0:
print('no device attached')
quit()
device = adb.device(emulatorname)
return device
except ():
quit()
def tryConnect(self) -> bool:
if self.connected and self.getDeviceSerialNo() is not None:
return True
self._changeConnectedState(False)
self.checkingConnectionChange(True)
adb = AdbClient(host="127.0.0.1", port=5037)
devices = adb.devices()
if len(devices) == 0:
logger.debug(
"No device attached. Restarting adb-server and retrying...")
check_call(["adb", "kill-server"], stdout=DEVNULL, stderr=STDOUT)
check_call(["adb", "start-server"], stdout=DEVNULL, stderr=STDOUT)
else:
self._client = adb
try:
self.my_device = devices[0]
self._changeConnectedState(True)
logger.info(f"Connected to device {self._host}:{self._port}")
except RuntimeError:
self._changeConnectedState(True)
logger.info("Unable to connect to device")
self.checkingConnectionChange(False)
return self.connected
def start_server(self):
"""
Start ADB server
"""
try:
_adb_kill_server()
_adb_start_server()
client = AdbClient(host=self._host, port=self._port)
if (self._serial or "") == "":
devices = client.devices()
if len(devices) == 1:
self.device = devices[0]
elif len(devices) > 1:
raise DeviceNotProvidedException()
else:
raise DeviceNotFoundException()
else:
self.device = client.device(self._serial)
self.state = ADBServerState.OPENED
logger.debug("ADB server started successfully.")
except Exception as ex:
_adb_kill_server()
logger.debug("ADB server has failed to start.")
self.state = ADBServerState.CLOSED
raise ex
class adb():
def __init__(self, path: str) -> None:
self.path = path ##
self.adb_exe = '{}\\platform-tools\\adb.exe'.format(self.path)
def connect_to_BS(self, ip: str, port: int) -> None:
'''
待測試 => 重開機直接執行
'''
self.client = AdbClient(host="127.0.0.1", port=5037)
try:
self.client.remote_connect(ip, port)
except:
subprocess.Popen('{} start-server'.format(self.adb_exe), stdout=subprocess.PIPE).stdout.read()
print('Connect success!')
def list_devices(self) -> None:
devices = self.client.devices()
print('List of devices attached:')
for device in devices:
print(' {}'.format(device.serial))
def tap(self, device, x: str, y: str) -> None:
device.shell('input tap {} {}'.format(x, y))
def get_device(self, serial: str):
return self.client.device(serial)
def screencap(self, device):
image_bytes = device.screencap()
img = cv2.imdecode(np.frombuffer(image_bytes, dtype='uint8'), cv2.IMREAD_COLOR)
return img
def check_device_exist(udid):
client = AdbClient(host="127.0.0.1", port=5037)
devices = client.devices()
for device in devices:
if device.get_serial_no() == udid:
return udid
return None
class Adb:
def __init__(self, host='127.0.0.1', port=5037):
self.client = PPADBClient(host, port)
def connect_to_device(self, host='127.0.0.1', port=5555):
adb_path = resource_path(FilePaths.ADB_EXE_PATH.value)
cmd = build_command(adb_path, 'connect', "{}:{}".format(host, port))
ret = subprocess.check_output(cmd,
shell=True,
stderr=subprocess.PIPE,
encoding="utf-8",
timeout=2)
return self.get_device(host, port)
def get_client_devices(self):
return self.client.devices()
def get_device(self, host='127.0.0.1', port=5555):
device = self.client.device('{}:{}'.format(host, port))
try:
if device is None:
self.connect_to_device(host, port)
device = self.client.device('{}:{}'.format(host, port))
except Exception as e:
traceback.print_exc()
return None
return device
def connect():
adb = Client(host="127.0.0.1", port=5037)
devices = adb.devices()
if len(devices) == 0:
print("No device found!")
quit(1)
return devices[0]
def __init__(self):
self.log = MyLogger('ADB', LOG_LEVEL=logging.INFO)
client = Client(host='127.0.0.1', port=5037)
self.log.debug(client.version())
devices = client.devices()
if len(devices) == 0:
self.log.debug("no devices")
quit()
self.device = devices[0]
self.log.debug(f'updating info for {self.device}')
number = 5
touch_id = 0
lines = self.device.shell('getevent -p').split("\n")
for line in lines:
if "/dev/input" in line:
number = line[-1]
if "Touch" in line:
touch_id = number
self.touch = f"sendevent /dev/input/event{number}"
if "max" in line and "ABS" in line and number == touch_id:
values = line.split(', ')
for value in values:
if "max" in value:
self.max = int(value[4:])
self.log.debug(f"found max: {self.max}")
class SSMAndroidDevices:
"""
AndroidDevices class
this is collection of devices found by adb executable
"""
def __init__(self, host: object, port: int) -> object:
self.client = AdbClient(host, port)
self.devices = self.client.devices()
if self.devices.__len__() <= 0:
logging.critical("There are no devices connected")
self.num_of_device = 0
exit()
else:
logging.info("There are " + self.devices.__len__().__str__() +
" devices connected")
self.num_of_device = self.devices.__len__()
return
def print_devices(self):
for device in self.devices:
print("Serial: " + device.serial)
# print("State: " + device.serial.get_state)
print(device.get_serial_no())
print(device.get_device_path())
print(device.get_state())
# below require package name
# print(device.get_meminfo())
print(device.get_top_activities())
print(" ")
for activity in device.get_top_activities():
print(activity.activity)
print(activity.package)
print(activity.pid)
print(" ")
return
def connect_device():
adb = Client(host='127.0.0.1',port=5037)
devices = adb.devices()
if len(devices) == 0:
print("No Devices Attached")
quit()
return devices[0]
def transfer_all(logger: Logger):
music_path = Path.cwd().parents[0] / "music"
playlists_path = Path.cwd().parents[0] / "playlists"
# Default is "127.0.0.1" and 5037
client = AdbClient(host="127.0.0.1", port=5037)
if len(client.devices()) == 0:
logger.info("No phone connected! Can't copy files.")
return
devices: List[Device] = client.devices()
device = devices[0]
transferred_count = 0
all_music: List[Path] = []
for dirname, dirnames, filenames in os.walk(music_path):
for filename in filenames:
all_music.append(Path(os.path.join(dirname, filename)))
for file in all_music:
file_name = file.name
file_parent = file.parents[0].name
if file.suffix == ".jpg":
android_path = f"/storage/emulated/0/Music/music/{file_parent}/folder{file.suffix}"
else:
android_path = f"/storage/emulated/0/Music/music/{file_parent}/{file_name}"
exists = "No such file or directory" not in device.shell(
f"ls \"{android_path}\"")
if not exists:
device.push(file, android_path)
transferred_count += 1
all_playlists: List[Path] = []
for dirname, dirnames, filenames in os.walk(playlists_path):
for filename in filenames:
all_playlists.append(Path(os.path.join(dirname, filename)))
for file in all_playlists:
file_name = file.name
android_path = f"/storage/emulated/0/Music/playlists/{file_name}"
device.push(file, android_path)
transferred_count += 1
logger.info(f"Copied {transferred_count} files to your Android!")
async def main(argv):
tasks = []
config = Object()
config.width = 1
config.height = 1
client = AdbClient(host="127.0.0.1", port=5037)
devices = client.devices()
if len(devices) == 0:
print("no device detected!")
exit(1)
return
elif len(devices) == 1:
device = devices[0]
else:
# print("multiple device detected, chose one")
index = 0
for device in devices:
print(f"{index}: {device.serial}")
index = int(
input("multiple device detected, chose one (index number): "))
device = devices[index]
config.device = device
if argv[1].endswith(".yaml") or argv[1].endswith(".yml"):
config_text = open(argv[1]).read()
argv = argv[1:]
else:
config_text = open("android_clicker.yaml").read()
config_data = yaml.safe_load(config_text)
print(config_data)
if "screen" in config_data:
screen = config_data["screen"]
screen_cap = device.screencap()
if len(screen_cap) != 0:
img = cv2.imdecode(np.frombuffer(screen_cap, np.uint8),
cv2.IMREAD_COLOR)
sp = img.shape
height = sp[0]
width = sp[1]
print(f'screen width: {width:d}, height: {height:d}')
if "width" in screen:
config.width = width / int(screen["width"])
if "height" in screen:
config.height = height / int(screen["height"])
available_motions = argv[1:]
if "motions" in config_data:
motions = config_data["motions"]
if len(available_motions) != 0:
motions = filter(
lambda m: "name" in m and m["name"] in available_motions,
motions)
for motion in motions:
task = asyncio.create_task(loop(motion, device, config))
tasks.append(task)
for task in tasks:
await task
def __init__(self):
client = AdbClient(host="127.0.0.1", port=5037)
devices = client.devices()
if len(devices) == 0:
raise Exception('There is no ADB devices')
self.device = devices[0]
self.app_name = 'com.firsttouchgames.smp'
def initDevice():
os.system('taskkill /f /im %s' % 'cmd.exe')
os.system('taskkill /f /im %s' % 'adb.exe')
os.system("adb kill-server")
os.system("adb start-server")
global client
client = AdbClient(host="127.0.0.1", port=5037)
global device
device = client.devices()[0]
def startInjection():
codes = scrapeCodes()
client = AdbClient()
device = None
if len(codes) > 0:
if len(client.devices()) == 1:
device = client.devices()[0]
if device is not None:
box_input_location = getLocationFromBackground(
image_location="mobbox.png", update_background=True, device=device)
inv_input_location = getLocationFromBackground(
image_location="invitebox.png")
remove_input_location = None
codes_entered = 0
if box_input_location is not None and inv_input_location is not None:
for code in codes:
print("Currently entered {} codes".format(codes_entered))
# select the box & input text
device.input_tap(*box_input_location)
device.input_text(code)
time.sleep(1)
# select the invite location
device.input_tap(0, 0)
device.input_tap(*inv_input_location)
time.sleep(1)
# (get remove input location if not set &) remove the input.
if remove_input_location is None:
remove_input_location = getLocationFromBackground(
"removeinput.png",
update_background=True,
device=device)
device.input_tap(*remove_input_location)
time.sleep(0.2)
device.input_tap(0, 0)
time.sleep(0.2)
codes_entered += 1
def get_device_udid(number: int):
client = AdbClient(host="127.0.0.1", port=5037)
devices = client.devices()
if len(devices) > number:
return devices[number].get_serial_no()
else:
new_number = number - (number // len(devices)) * len(devices)
logger.log_warn(
f'You choose device number {number + 1} but there are only {len(devices)} connected. '
f'Will use device number {new_number + 1} instead',
jump_line=True)
return devices[new_number].get_serial_no()
def init():
os.system('adb devices -l')
adb = Client(host='127.0.0.1', port=5037)
devices = adb.devices()
if len(devices) == 0:
print('no devices found')
quit()
device = devices[0]
return device
def check_device():
global current_device
adb = Client(host='127.0.0.1', port=5037)
devices = adb.devices()
if len(devices) == 0:
print('no device attached')
print('exit')
quit()
else:
current_device = devices[0]
print(f"device found {current_device.serial} ")
create_folder(folder)
start()
def get_devices():
for attempt in range(2):
try:
client = AdbClient(host="127.0.0.1", port=5037)
client.version() # a random call to check if adb server is up
except Exception as err:
eprint(str(err))
eprint("⚡ Starting ADB server...")
subprocess.run(["adb", "start-server"])
devices = client.devices()
if len(devices) == 0:
eprint("⚠️ no devices connected!")
return devices
class ADBControl:
def __init__(self, config):
self._adb_server_host = config.get("adb_server_host", "127.0.0.1")
self._adb_server_port = config.get("adb_server_port", 5037)
self._adb_device_number = config.get("adb_device_number", 0)
self._client = AdbClient(host=self._adb_server_host,
port=self._adb_server_port)
self._device = self._client.devices()[self._adb_device_number]
def _adb_shell(self, command):
self._device.shell(command)
def take_photo(self):
self._adb_shell("input keyevent KEYCODE_CAMERA")
def get_device(proxy_port):
client = AdbClient(host="localhost", port=5037)
if client.remote_connect("backend", proxy_port):
device = client.devices()[0]
print("Using device : %s" % device.serial)
waiting = True
while waiting:
try:
whoami = device.shell('whoami')
# This will always be root on an eng build
if 'root' not in whoami:
print("Unlikely this will work... : %s" % whoami)
else:
waiting = False
except Exception as e:
print("Hit exception waiting, will retry in 1 second... ", e)
time.sleep(1)
return device
class AdbManager(Thread):
def __init__(self):
super().__init__()
self.adb_client = AdbClient(host="127.0.0.1", port=5037)
self.logcats = []
self.start()
def get_current_devices(self):
devices = self.adb_client.devices()
return devices
def get_logcat(self, device, callback=None):
logcat_manager = LogcatManager(device, callback)
logcat_manager.start()
self.logcats.append(logcat_manager)
def stop_logcat(self, item):
logcat_manager = self.logcats[item]
logcat_manager.stop_logcat()
self.logcats.remove(logcat_manager)
def get_installed_packages(self, device):
installed_packages = list(
map(lambda x: x.replace("package:", ""),
device.shell("cmd package list packages -3").split("\n")))
return installed_packages
def execute(self, device, command):
device.shell("su -c '{}'".format(command), handler=self._print)
@staticmethod
def _print(connection):
while True:
data = connection.read(1024)
if not data:
break
print(data.decode('utf-8'))
connection.close()
def main():
logging.info('before adb')
adb = Client(host='127.0.0.1', port=5037)
devices = adb.devices()
logging.info('after adb')
if len(devices) == 0:
print('no device attached')
quit()
device = devices[0]
logging.info('before adb swipe')
device.shell('input touchscreen swipe 500 500 500 500 10')
logging.info('after adb swipe')
logging.info('before adb swipe2')
device.shell('input touchscreen swipe 200 200 200 200 10')
logging.info('after adb swipe2')
logging.info('before touch')
def main():
client = AdbClient()
devices = client.devices()
if len(devices) > 0:
device = devices[0]
viewer = Viewer(device)
if not viewer.turn_on():
error('hierarchy viewer turn on fail!')
activities = viewer.list_activities()
for activity in activities:
print(activity.hashcode, activity.name)
widget = viewer.dump_widgets(activity)
if widget is not None:
# print(str(widget))
filepath = activity.name + '_' + widget.name
viewer.capture_widget(activity.hashcode, widget, filepath)
print('write file ', filepath)
viewer.turn_off()
####################
# IMPORTS
####################
from ppadb.client import Client
import numpy as np
import TextPositions
####################
# SETTING UP
####################
adb = Client(host='127.0.0.1', port=5037)
devices = adb.devices()
device = devices[0]
####################
# MAIN
####################
def PrintText(text,start_x,start_y,font_size=80):
x_off = 0
y_off = 0
for c in range(len(text)):
if x_off + (TextPositions.text_positions[text[c]]['Size'][0]*font_size) > 800:
x_off = 0
y_off += (1*font_size)
for elm in TextPositions.text_positions[text[c]]["Vectors"]:
for i in range(len(elm)):
x1 = start_x + (elm[i-1][0]*font_size) + x_off
y1 = start_y - (elm[i-1][1]*font_size) + y_off
x2 = start_x + (elm[i ][0]*font_size) + x_off
y2 = start_y - (elm[i ][1]*font_size) + y_off
dist = numpy.linalg.norm(np.array([x1,y1]) - np.array([x2,y2]))
from ppadb.client import Client as AdbClient
import time
# Default is "127.0.0.1" and 5037
client = AdbClient(host="127.0.0.1", port=5037)
device = client.devices()[0]
# Launch whatsapp using adb
device.shell("am start -n com.whatsapp/com.whatsapp.Main")
position = 670
count = 0
for i in range(8):
print(i + 1)
while (position <= 2250):
# Press new message
device.shell("input touchscreen tap 1000 2200")
for _ in range(i):
# Scroll the screen by screen height amount (or a little less).
# Scrolling i times because i number of screens have already been done.
device.shell("input touchscreen swipe 500 2200 500 200 2000")
# Tuning left.
# Select chat
device.shell(f"input touchscreen tap 500 {position}")
# Position for next chat
position += 170
class ADBConnect(object):
def __init__(self, args):
self._args = args
self._useadb = args.use_adb
self._client = None
if self._useadb:
try:
from ppadb.client import Client as AdbClient
except ImportError:
try:
from adb.client import Client as AdbClient
except ImportError:
pass
self.check_adblib = 'adb.client' in sys.modules or 'ppadb.client' in sys.modules
if not self.check_adblib:
logger.warning("Could not find pure-python-adb library. If you are not using ADB you can ignore this")
self._useadb = False
else:
self._client = AdbClient(
host=self._args.adb_server_ip, port=self._args.adb_server_port)
def check_adb_status(self, adb):
if not self._useadb:
return None
try:
if self._client.device(adb) is not None:
self._client.device(adb).shell('echo checkadb')
return True
except RuntimeError:
logger.exception('MADmin: Exception occurred while checking adb status ({}).', adb)
return None
def return_adb_devices(self):
if not self._useadb:
return []
try:
return self._client.devices()
except Exception as e:
logger.exception('MADmin: Exception occurred while getting adb clients: {}.', e)
return []
def send_shell_command(self, adb, origin, command):
origin_logger = get_origin_logger(logger, origin=origin)
try:
device = self._client.device(adb)
if device is not None:
origin_logger.info('MADmin: Using ADB shell command')
device.shell(command)
return True
except Exception as e:
origin_logger.exception('MADmin: Exception occurred while sending shell command: {}.', e)
return False
def make_screenshot(self, adb, origin, extenstion):
origin_logger = get_origin_logger(logger, origin=origin)
try:
device = self._client.device(adb)
if device is not None:
origin_logger.info('MADmin: Using ADB')
result = device.screencap()
# TODO: adjust with devicesettings
with open(os.path.join(self._args.temp_path, 'screenshot_%s.png' % str(origin)), "wb") as fp:
fp.write(result)
if extenstion == "jpg":
pngtojpg(os.path.join(self._args.temp_path, 'screenshot_%s.png' % str(origin)))
return True
except Exception as e:
origin_logger.exception('MADmin: Exception occurred while making screenshot: {}.', e)
return False
def make_screenclick(self, adb, origin, position_x, position_y):
origin_logger = get_origin_logger(logger, origin=origin)
try:
device = self._client.device(adb)
if device is not None:
device.shell("input tap " + str(position_x) + " " + str(position_y))
origin_logger.info('MADMin ADB Click x:{} y:{}', position_x, position_y)
time.sleep(1)
return True
except Exception as e:
origin_logger.exception('MADmin: Exception occurred while making screenclick: {}.', e)
return False
def make_screenswipe(self, adb, origin, position_x, position_y, swipe_x, swipe_y):
origin_logger = get_origin_logger(logger, origin=origin)
try:
device = self._client.device(adb)
if device is not None:
device.shell("input swipe " + str(position_x) + " " +
str(position_y) + " " + str(swipe_x) + " " + str(swipe_y) + " 100")
origin_logger.info('MADMin ADB Swipe x:{} y:{} xe:{} ye:{}', position_x, position_y, swipe_x, swipe_y)
time.sleep(1)
return True
except Exception as e:
origin_logger.exception('MADmin: Exception occurred while making screenswipe: {}.', e)
return False
def push_file(self, adb, origin, filename):
origin_logger = get_origin_logger(logger, origin=origin)
try:
device = self._client.device(adb)
if device is not None:
device.shell("adb push " + str(filename) + " /sdcard/Download")
origin_logger.info('MADMin ADB Push File {}', filename)
time.sleep(1)
return True
except Exception as e:
origin_logger.exception('MADmin: Exception occurred while pushing file: {}.', e)
return False
def testDump(self, window):
client = AdbClient(host="127.0.0.1", port=5037)
dev = client.devices()
dev2 = client.device("YT910815C7")
self.outText.delete('1.0', END)
self.outText.insert(END, dev2.shell("echo test2"))
class FireTV:
"""Represents an Amazon Fire TV device."""
def __init__(self,
host,
port=5555,
adb_server_ip="127.0.0.1",
adb_server_port=5037):
"""Initialize FireTV object.
:param host: Host in format <address>:port.
:param adbkey: The path to the "adbkey" file
:param adb_server_ip: the IP address for the ADB server
:param adb_server_port: the port for the ADB server
"""
self.host = host
self.port = port
self.adb_server_port = adb_server_port
self.adb_server_ip = adb_server_ip
# keep track of whether the ADB connection is intact
self._available = False
# use a lock to make sure that ADB commands don't overlap
self._adb_lock = threading.Lock()
# the attributes used for sending ADB commands; filled in in `self.connect()`
self._adb = None # python-adb
self._adb_client = None # pure-python-adb
self._adb_device = None # pure-python-adb && adb_shell
# pure-python-adb
self.adb_shell = self._adb_shell_pure_python_adb
self.adb_streaming_shell = self._adb_streaming_shell_pure_python_adb
# establish the ADB connection
self.connect()
# ======================================================================= #
# #
# ADB methods #
# #
# ======================================================================= #
def _adb_shell_adb_shell(self, cmd):
if not self.available:
return None
if self._adb_lock.acquire(**LOCK_KWARGS):
try:
return self._adb_device.shell(cmd)
finally:
self._adb_lock.release()
def _adb_shell_python_adb(self, cmd):
if not self.available:
return None
if self._adb_lock.acquire(**LOCK_KWARGS):
try:
return self._adb.Shell(cmd)
finally:
self._adb_lock.release()
def _adb_shell_pure_python_adb(self, cmd):
if not self._available:
return None
if self._adb_lock.acquire(**LOCK_KWARGS):
try:
return self._adb_device.shell(cmd)
finally:
self._adb_lock.release()
def _adb_streaming_shell_adb_shell(self, cmd):
if not self.available:
return []
if self._adb_lock.acquire(**LOCK_KWARGS):
try:
return self._adb_device.shell(cmd)
finally:
self._adb_lock.release()
def _adb_streaming_shell_python_adb(self, cmd):
if not self.available:
return []
if self._adb_lock.acquire(**LOCK_KWARGS):
try:
return self._adb.StreamingShell(cmd)
finally:
self._adb_lock.release()
def _adb_streaming_shell_pure_python_adb(self, cmd):
if not self._available:
return None
# this is not yet implemented
if self._adb_lock.acquire(**LOCK_KWARGS):
try:
return []
finally:
self._adb_lock.release()
def _dump(self, service, grep=None):
"""Perform a service dump.
:param service: Service to dump.
:param grep: Grep for this string.
:returns: Dump, optionally grepped.
"""
if grep:
return self.adb_shell('dumpsys {0} | grep "{1}"'.format(
service, grep))
return self.adb_shell('dumpsys {0}'.format(service))
def _dump_has(self, service, grep, search):
"""Check if a dump has particular content.
:param service: Service to dump.
:param grep: Grep for this string.
:param search: Check for this substring.
:returns: Found or not.
"""
dump_grep = self._dump(service, grep=grep)
if not dump_grep:
return False
return dump_grep.strip().find(search) > -1
def _key(self, key):
"""Send a key event to device.
:param key: Key constant.
"""
self.adb_shell('input keyevent {0}'.format(key))
def _keyboard(self, literal):
"""Send text to device
:param key: text string to send.
"""
self.adb_shell(f'input text "{literal}"')
def _ps(self, search=''):
"""Perform a ps command with optional filtering.
:param search: Check for this substring.
:returns: List of matching fields
"""
if not self.available:
return
result = []
ps = self.adb_streaming_shell('ps')
try:
for bad_line in ps:
# The splitting of the StreamingShell doesn't always work
# this is to ensure that we get only one line
for line in bad_line.splitlines():
if search in line:
result.append(line.strip().rsplit(' ', 1)[-1])
return result
except InvalidChecksumError as e:
print(e)
self.connect()
raise IOError
def _send_intent(self, pkg, intent, count=1):
cmd = 'monkey -p {} -c {} {}; echo $?'.format(pkg, intent, count)
logging.debug("Sending an intent %s to %s (count: %s)", intent, pkg,
count)
# adb shell outputs in weird format, so we cut it into lines,
# separate the retcode and return info to the user
res = self.adb_shell(cmd)
if res is None:
return {}
res = res.strip().split("\r\n")
retcode = res[-1]
output = "\n".join(res[:-1])
return {"retcode": retcode, "output": output}
def connect(self, always_log_errors=True):
"""Connect to an Amazon Fire TV device.
Will attempt to establish ADB connection to the given host.
Failure sets state to UNKNOWN and disables sending actions.
:returns: True if successful, False otherwise
"""
self._adb_lock.acquire(**LOCK_KWARGS)
try:
# pure-python-adb
try:
self._adb_client = AdbClient()
self._adb_client.remote_connect(self.host, self.port)
print(self._adb_client.devices())
self._adb_device = self._adb_client.device(
f"{self.host}:{self.port}")
self._available = bool(self._adb_device)
except:
traceback.print_exc()
self._available = False
finally:
return self._available
finally:
self._adb_lock.release()
# ======================================================================= #
# #
# Home Assistant Update #
# #
# ======================================================================= #
def update(self, get_running_apps=True):
"""Get the state of the device, the current app, and the running apps.
:param get_running_apps: whether or not to get the ``running_apps`` property
:return state: the state of the device
:return current_app: the current app
:return running_apps: the running apps
"""
# The `screen_on`, `awake`, `wake_lock_size`, `current_app`, and `running_apps` properties.
screen_on, awake, wake_lock_size, _current_app, running_apps = self.get_properties(
get_running_apps=get_running_apps, lazy=True)
# Check if device is off.
if not screen_on:
state = STATE_OFF
current_app = None
running_apps = None
# Check if screen saver is on.
elif not awake:
state = STATE_IDLE
current_app = None
running_apps = None
else:
# Get the current app.
if isinstance(_current_app, dict) and 'package' in _current_app:
current_app = _current_app['package']
else:
current_app = None
# Get the running apps.
if running_apps is None and current_app:
running_apps = [current_app]
# Get the state.
# TODO: determine the state differently based on the `current_app`.
if current_app in [PACKAGE_LAUNCHER, PACKAGE_SETTINGS]:
state = STATE_STANDBY
# Amazon Video
elif current_app == AMAZON_VIDEO:
if wake_lock_size == 5:
state = STATE_PLAYING
else:
# wake_lock_size == 2
state = STATE_PAUSED
# Netflix
elif current_app == NETFLIX:
if wake_lock_size > 3:
state = STATE_PLAYING
else:
state = STATE_PAUSED
# Check if `wake_lock_size` is 1 (device is playing).
elif wake_lock_size == 1:
state = STATE_PLAYING
# Otherwise, device is paused.
else:
state = STATE_PAUSED
return state, current_app, running_apps
# ======================================================================= #
# #
# App methods #
# #
# ======================================================================= #
def app_state(self, app):
"""Informs if application is running."""
if not self.available or not self.screen_on:
return STATE_OFF
if self.current_app["package"] == app:
return STATE_ON
return STATE_OFF
def launch_app(self, app):
"""Launch an app."""
return self._send_intent(app, INTENT_LAUNCH)
def stop_app(self, app):
"""Stop an app."""
return self.adb_shell("am force-stop {0}".format(app))
# ======================================================================= #
# #
# properties #
# #
# ======================================================================= #
@property
def state(self):
"""Compute and return the device state.
:returns: Device state.
"""
# Check if device is disconnected.
if not self.available:
return STATE_UNKNOWN
# Check if device is off.
if not self.screen_on:
return STATE_OFF
# Check if screen saver is on.
if not self.awake:
return STATE_IDLE
# Check if the launcher is active.
if self.launcher or self.settings:
return STATE_STANDBY
# Check for a wake lock (device is playing).
if self.wake_lock:
return STATE_PLAYING
# Otherwise, device is paused.
return STATE_PAUSED
@property
def available(self):
"""Check whether the ADB connection is intact."""
if USE_ADB_SHELL:
# adb_shell
if not self._adb_device:
return False
return self._adb_device.available
if not self.adb_server_ip:
# python-adb
return bool(self._adb)
# pure-python-adb
try:
# make sure the server is available
adb_devices = self._adb_client.devices()
# make sure the device is available
try:
# case 1: the device is currently available
if any(
[self.host in dev.get_serial_no() for dev in adb_devices]):
if not self._available:
self._available = True
return True
# case 2: the device is not currently available
if self._available:
logging.error('ADB server is not connected to the device.')
self._available = False
return False
except RuntimeError:
if self._available:
logging.error(
'ADB device is unavailable; encountered an error when searching for device.'
)
self._available = False
return False
except RuntimeError:
if self._available:
logging.error('ADB server is unavailable.')
self._available = False
return False
@property
def running_apps(self):
"""Return a list of running user applications."""
ps = self.adb_shell(RUNNING_APPS_CMD)
if ps:
return [
line.strip().rsplit(' ', 1)[-1] for line in ps.splitlines()
if line.strip()
]
return []
@property
def current_app(self):
"""Return the current app."""
current_focus = self.adb_shell(CURRENT_APP_CMD)
if current_focus is None:
return None
current_focus = current_focus.replace("\r", "")
matches = WINDOW_REGEX.search(current_focus)
# case 1: current app was successfully found
if matches:
(pkg, activity) = matches.group("package", "activity")
return {"package": pkg, "activity": activity}
# case 2: current app could not be found
logging.warning("Couldn't get current app, reply was %s",
current_focus)
return None
@property
def screen_on(self):
"""Check if the screen is on."""
return self.adb_shell(SCREEN_ON_CMD + SUCCESS1_FAILURE0) == '1'
@property
def awake(self):
"""Check if the device is awake (screensaver is not running)."""
return self.adb_shell(AWAKE_CMD + SUCCESS1_FAILURE0) == '1'
@property
def wake_lock(self):
"""Check for wake locks (device is playing)."""
return self.adb_shell(WAKE_LOCK_CMD + SUCCESS1_FAILURE0) == '1'
@property
def wake_lock_size(self):
"""Get the size of the current wake lock."""
output = self.adb_shell(WAKE_LOCK_SIZE_CMD)
if not output:
return None
return int(output.split("=")[1].strip())
@property
def launcher(self):
"""Check if the active application is the Amazon TV launcher."""
return self.current_app["package"] == PACKAGE_LAUNCHER
@property
def settings(self):
"""Check if the active application is the Amazon menu."""
return self.current_app["package"] == PACKAGE_SETTINGS
def get_properties(self, get_running_apps=True, lazy=False):
"""Get the ``screen_on``, ``awake``, ``wake_lock_size``, ``current_app``, and ``running_apps`` properties."""
if get_running_apps:
output = self.adb_shell(SCREEN_ON_CMD +
(SUCCESS1 if lazy else SUCCESS1_FAILURE0) +
" && " + AWAKE_CMD +
(SUCCESS1 if lazy else SUCCESS1_FAILURE0) +
" && " + WAKE_LOCK_SIZE_CMD + " && " +
CURRENT_APP_CMD + " && " +
RUNNING_APPS_CMD)
else:
output = self.adb_shell(SCREEN_ON_CMD +
(SUCCESS1 if lazy else SUCCESS1_FAILURE0) +
" && " + AWAKE_CMD +
(SUCCESS1 if lazy else SUCCESS1_FAILURE0) +
" && " + WAKE_LOCK_SIZE_CMD + " && " +
CURRENT_APP_CMD)
# ADB command was unsuccessful
if output is None:
return None, None, None, None, None
# `screen_on` property
if not output:
return False, False, -1, None, None
screen_on = output[0] == '1'
# `awake` property
if len(output) < 2:
return screen_on, False, -1, None, None
awake = output[1] == '1'
lines = output.strip().splitlines()
# `wake_lock_size` property
if len(lines[0]) < 3:
return screen_on, awake, -1, None, None
wake_lock_size = int(lines[0].split("=")[1].strip())
# `current_app` property
if len(lines) < 2:
return screen_on, awake, wake_lock_size, None, None
matches = WINDOW_REGEX.search(lines[1])
if matches:
# case 1: current app was successfully found
(pkg, activity) = matches.group("package", "activity")
current_app = {"package": pkg, "activity": activity}
else:
# case 2: current app could not be found
current_app = None
# `running_apps` property
if not get_running_apps or len(lines) < 3:
return screen_on, awake, wake_lock_size, current_app, None
running_apps = [
line.strip().rsplit(' ', 1)[-1] for line in lines[2:]
if line.strip()
]
return screen_on, awake, wake_lock_size, current_app, running_apps
# ======================================================================= #
# #
# turn on/off methods #
# #
# ======================================================================= #
def turn_on(self):
"""Send power action if device is off."""
self.adb_shell(SCREEN_ON_CMD +
" || (input keyevent {0} && input keyevent {1})".format(
POWER, HOME))
def turn_off(self):
"""Send power action if device is not off."""
self.adb_shell(SCREEN_ON_CMD + " && input keyevent {0}".format(SLEEP))
# ======================================================================= #
# #
# "key" methods: basic commands #
# #
# ======================================================================= #
def backspace(self):
"""Send backspace action."""
self._key(DELETE)
def search(self):
"""Send search action."""
self._key(SEARCH)
def info(self):
"""Send info action."""
self._key(INFO)
def power(self):
"""Send power action."""
self._key(POWER)
def sleep(self):
"""Send sleep action."""
self._key(SLEEP)
def home(self):
"""Send home action."""
self._key(HOME)
def up(self):
"""Send up action."""
self._key(UP)
def down(self):
"""Send down action."""
self._key(DOWN)
def left(self):
"""Send left action."""
self._key(LEFT)
def right(self):
"""Send right action."""
self._key(RIGHT)
def enter(self):
"""Send enter action."""
self._key(ENTER)
def back(self):
"""Send back action."""
self._key(BACK)
def menu(self):
"""Send menu action."""
self._key(MENU)
def volume_up(self):
"""Send volume up action."""
self._key(VOLUME_UP)
def volume_down(self):
"""Send volume down action."""
self._key(VOLUME_DOWN)
def grave(self):
"""Send backtick action."""
self._key(GRAVE)
def settings(self):
"""Send settings action."""
self._key(SETTINGS)
def backslash(self):
"""Send backslash action."""
self._key(BACKSLASH)
# ======================================================================= #
# #
# "key" methods: media commands #
# #
# ======================================================================= #
def media_play_pause(self):
"""Send media play/pause action."""
self._key(PLAY_PAUSE)
def media_play(self):
"""Send media play action."""
self._key(PLAY)
def media_pause(self):
"""Send media pause action."""
self._key(PAUSE)
def media_next(self):
"""Send media next action (results in fast-forward)."""
self._key(NEXT)
def media_previous(self):
"""Send media previous action (results in rewind)."""
self._key(PREVIOUS)
def media_fast_forward(self):
"""Send media fast forward action."""
self._key(FAST_FORWARD)
def media_rewind(self):
"""Send media rewind action."""
self._key(REWIND)
def media_skip_backwards(self):
"""Send media skip backward action."""
self._key(SKIP_BACKWARD)
# ======================================================================= #
# #
# "key" methods: key commands #
# #
# ======================================================================= #
def keyboard(self, literal):
"""Send keyboard literal keypress."""
self._keyboard(literal)
# Necessary libraries
from ppadb.client import Client as AdbClient
import numpy as np
import cv2
import time
#Phone connection using ADB
client = AdbClient(host='127.0.0.1', port=5037)
phones = client.devices()
phone = phones[0]
#Infinite loop to the code keep running
while (1):
# Take the phone screenshoot
image = phone.screencap()
with open('screenshot.png', 'wb') as fb:
fb.write(image)
# Return a numpy array of size (1280,720,3) with the screenshoot info in RGB
img = cv2.imread('screenshot.png')
# We know that in this row you can always find the black blocks of the game
row = 900
# A black pixel is [0 0 0] in RGB
# BlackPixels is a numpy array with the number of black pixels in the X axis (max of 720 pixels)
BlackPixels = np.array([])
# Determine how many black pixels there are
for pix, RGB in enumerate(img[row]):
