def kernel_version():
client = AdbClient(host="127.0.0.1", port=5037)
device = client.device(options.device)
result = device.shell("uname -r")
#result = result.encode('ascii','ignore')
logging.info(" kernel_version() : result is %s", result)
result = result.split(".")
ver = result[0] + '.' + result[1]
ver = float(ver)
offset_selinux = []
# case kernel version is <= 3.10
if ver <= 3.10:
offset_to_comm = 0x288
offset_to_parent = 0xe0
offset_selinux.append(0xC0A77548)
offset_selinux.append(0xC0A7754C)
offset_selinux.append(0xC0A77550)
ps_cmd = "ps"
# case kernel version is > 3.10 et <=3.18
elif ver > 3.10 and ver <= 3.18:
offset_to_comm = 0x444
offset_to_parent = 0xe0
offset_selinux.append(0xC0C4F288)
offset_selinux.append(0xC0C4F28C)
offset_selinux.append(0XC0C4F280)
ps_cmd = "ps -A"
else:
logging.info("Sorry. Android kernel version %s not supported yet", ver)
raise NotImplementedError(
"Sorry. Android kernel version %s not supported yet", ver)
return ver, offset_to_comm, offset_to_parent, offset_selinux, ps_cmd
def main():
try:
from adb.client import Client as AdbClient
import sys
if len(sys.argv) < 3:
print(
"Error: Syntax: Python logger.py filename [cache clear (Y/N)]")
apps = [
"com.android.chrome", "com.yandex.browser", "com.microsoft.emmx",
"org.mozilla.firefox"
]
client = AdbClient(host="127.0.0.1", port=5037)
devices = client.devices()
isCacheClear = sys.argv[2]
for device in devices:
if isCacheClear == 'Y':
for app in apps:
clearAppFromCache(app, device)
clearLog(device)
saving_log = save_log(sys.argv[1])
time = 30
for i in apps:
open_app(i, time)
saving_log.wait()
except Exception as e:
print("Error in main!")
def __init__(self, interval=0):
super(Clicking, self).__init__()
self.interval = interval
self.client = AdbClient(host="127.0.0.1", port=5037)
self.device = self.client.devices()[0]
self.x, self.y = None, None
def __init__(self):
client = AdbClient(host="127.0.0.1", port=5037)
devices = client.devices()
if len(devices) <= 0:
raise ValueError("No device connected")
self.device = client.device(str(devices[0].get_serial_no()))
self.settings = Settings("config.cfg")
self.adbscreen = ADBScreen(self.device)
def adb_connect(self):
try:
client = AdbClient(host="127.0.0.1", port=5037)
self.adb_device = client.devices()[0]
except Exception as e:
self.adb_device = ""
self.err = str(e)
return self.adb_device
def __init__(self):
# Default is "127.0.0.1" and 5037
client = AdbClient(host="127.0.0.1", port=5037)
self.device = client.device("ZY2239Q9MP")
self.GREEN = '\033[92m'
self.BLUE = '\033[94m'
self.YELLOW = '\033[93m'
self.RED = '\033[91m'
self.ENDC = '\033[0m'
def setConfig(cfg):
global config_dict, movementCount, client, device
config_dict = cfg
print(config_dict)
movementCount = random.choice(
range(config_dict["movement"]["stepsMin"],
config_dict["movement"]["stepsMax"], 1))
client = AdbClient(host=config_dict["device"]["host"],
port=config_dict["device"]["port"])
device = client.device(config_dict["device"]["name"])
def check_process_is_running(process):
client = AdbClient(host="127.0.0.1", port=5037)
device = client.device("emulator-5554")
ps = device.shell("ps")
if process in ps:
logging.debug("[+] OK. %s is running" %(process))
else:
logging.debug("[+] NOK. It seems like %s is not running..." %(process))
logging.debug("[+] Android_Emuroot stopped")
exit(1)
def get_devices():
adb = subprocess.Popen(
['adb', '-P', str(config['adb_port']), 'start-server'],
stdout=subprocess.DEVNULL,
stderr=subprocess.DEVNULL)
client = AdbClient(host="127.0.0.1", port=config['adb_port'])
print(client)
devs = []
for d in client.devices():
devs.append(AndroidDevice(d))
return devs
def __init__(self, init=False):
client = AdbClient(host="127.0.0.1", port=5037)
devices = client.devices()
if len(devices) <= 0:
raise ValueError("No device connected")
self.device = client.device(str(devices[0].get_serial_no()))
self.settings = Settings("config.cfg", init=init)
self.adbscreen = ADBScreen(self.device)
self.ENDC = '\033[0m'
self.WARNING = '\033[93m'
self.BLUE = '\033[94m'
self.RED = '\033[91m'
pytesseract.pytesseract.tesseract_cmd = self.settings.tesseract_dir
def __init__(self, adb_ip, adb_port, config):
"""
Starts the connection with the adb server.
"""
try:
self.__adb = AdbClient(host=adb_ip, port=adb_port)
self.__adb.devices()
except Exception:
with colored(colors.RED):
print "adb server isn't running, opening."
subprocess.Popen([config.get("adb", "adb_location"), "start-server"])
self.__config = config
def screenshot(deviceAddress='ce031713383080fa0c',
destFolder='screenshot',
imageName="ADBScreenshot.png"):
client = AdbClient(host="127.0.0.1", port=5037)
device = client.device(deviceAddress)
result = device.screencap()
try:
with open(destFolder + "/" + imageName, "wb") as fp:
fp.write(result)
except FileNotFoundError:
print("could not file file or folder")
def __init__(self, ini_name,init = False):
#Loading config.cfg
cparser = configparser.ConfigParser()
dirname = os.path.dirname(__file__)
ini_file = Path(os.path.join(dirname, "..\conf\\"+ini_name))
if ini_file.is_file():
cparser.read(ini_file)
else:
raise ValueError("Config file name not valid")
self.language = "DE"
#loads the config information
try:
self.language = cparser.get("custom", "language")
self.speed_multi = cparser.getfloat("custom", "speed_multi")
self.selected_raid = cparser.get("custom", "selected_raid")
self.round_robin_raids = eval(cparser.get("custom", "round_robin_raids"), {}, {})
self.round_robin = cparser.getboolean("custom", "round_robin")
self.tesseract_dir = cparser.get("custom", "tesseract_directory")
self.rounds = cparser.getint("custom", "rounds")
self.rounds_per_raid = cparser.getint("custom", "rounds_per_raid")
self.debug = cparser.getboolean("custom", "debug")
self.autodetect_buttons = cparser.get("screen", "autodeteckt_buttons")
self.taps_resultscreen = cparser.getint("custom", "taps_resultscreen")
self.auto_remove_pkmn = cparser.getboolean("custom", "auto_remove_pkmn")
except Exception as e:
raise ValueError("Couldn´t read config file")
try:
with open(os.path.join(dirname, '../conf/languages.json')) as json_file:
data = json.load(json_file)
self.language_pack = data[self.language]
except Exception:
raise ValueError("Language not found. Check your config file and update the languages.json")
client = AdbClient(host="127.0.0.1", port=5037)
devices = client.devices()
if len(devices) <= 0:
raise ValueError("No device connected")
adbscreen = ADBScreen(client.device(str(devices[0].get_serial_no())))
if not init:
try:
with open(os.path.join(dirname, '../conf/screens/'+str(adbscreen.get_model_name()+".json"))) as json_file:
data = json.load(json_file)
self.screen = data
except Exception:
raise ValueError("Screenconfig not found. Start the python script with the --init argument to create a config.")
self.check_screen_values()
def get(self):
from adb.client import Client as AdbClient
client = AdbClient()
devices = client.devices()
ret = {"success": True, "devices": []}
if not devices:
self.write({"success": False})
return
for device in devices:
data = {}
data["serial"] = device.serial
data["status"] = device.get_state()
if device.shell("getprop ro.arch").strip() == "x86":
data["emulator"] = True
else:
data["emulator"] = False
ret["devices"].append(data)
self.write(ret)
def get(self):
from uiautomator2.__main__ import _init_with_serial
from uiautomator2.version import __apk_version__, __atx_agent_version__
print("start...")
from adb.client import Client as AdbClient
client = AdbClient()
devices = client.devices()
for d in devices:
print(d.serial)
if not devices:
self.write({
"success": False,
"serial": "",
"deviceId": "",
})
return
for d in devices:
serial = d.get_serial_no()
if d.get_state() != 'device':
print("Skip invalid device: %s %s", serial, d.get_state())
continue
print("Init device %s", serial)
# todo:初始化代码优化
try:
device = _AndroidDevice(serial)
except BaseException:
_init_with_serial(serial=serial,
apk_version=__apk_version__,
agent_version=__atx_agent_version__,
server=None,
reinstall=False)
device = _AndroidDevice(serial)
# serial = device._d.wlan_ip + ":7912"
id = str(uuid.uuid4())
cached_devices[id] = device
socket_url = device._d._host + ":" + str(device._d._port)
self.write({
"success": True,
"serial": serial,
"deviceId": id,
"socket_url": socket_url
})
return
def kernel_version():
client = AdbClient(host="127.0.0.1", port=5037)
device = client.device("emulator-5554")
result = device.shell("uname -r")
result = result.encode('ascii','ignore')
logging.debug(" kernel_version() : result is %s", result)
result = result.split('.')
ver = result[0]+'.'+result[1]
ver = float(ver)
# case kernel version is <= 3.10
if ver <= 3.10 :
offset_to_comm = 0x288
offset_to_parent = 0xe0
# case kernel version is > 3.10 et <=3.18
elif ver > 3.10 and ver <= 3.18 :
offset_to_comm = 0x444
offset_to_parent = 0xe0
else :
logging.debug("Sorry. Android kernel version %s not supported yet", ver)
raise NotImplementedError("Sorry. Android kernel version %s not supported yet", ver)
return ver,offset_to_comm,offset_to_parent