def get_cpu(self, package_name, by_pid=False): try: logger.info('try to get cpu information') if by_pid: pid = self.get_pid(package_name) cmd = '{} shell "top -b -n 1 -q -o %CPU -o RES -p {}"'.format( self.adb_command, pid) p = command_execute(cmd) lines = self.output(p) cpu, rss = 0, 0 if lines: cpu, rss = lines[0].strip().split(" ") return cpu, rss cmd = '{} shell "top -n 1 | grep {} "'.format( self.adb_command, package_name[:15]) p = command_execute(cmd) lines = self.output(p) # lines = Utils.deal_with_python_version(lines) cpu = rss = 0 for line in lines: if package_name in line and f'{package_name}:' not in line: temp = re.findall( r'.* (\w+)% .* S (\w+) (\w+) .* {}'.format( package_name), line) cpu = temp[0][0] rss = temp[0][2] break cpu = int(cpu) if cpu != '' else 0 rss = int(rss) if rss != '' else 0 return cpu, rss except Exception as e: logger.error(e) return 0, 0
def wakeup_screen(self): try: cmd = '{} shell input keyevent 26'.format(self.adb_command) command_execute(cmd) return True except Exception as e: logger.error(e) logger.error(traceback.format_exc())
def get_flow_data_tcp(self, uid): tcp_rcv = \ command_execute("{} shell cat proc/uid_stat/{}/tcp_rcv".format(self.adb_command, uid)).read().split()[ 0] tcp_snd = \ command_execute("{} shell cat proc/uid_stat/{}/tcp_snd".format(self.adb_command, uid)).read().split()[ 0] return tcp_rcv, tcp_snd
def unlock_screen(self): try: cmd = '{} shell input swipe 100 1000 100 20'.format( self.adb_command) command_execute(cmd) return True except Exception as e: logger.error(e) logger.error(traceback.format_exc())
def get_process(self, package_name): if self.system is "Windows": pid_command = command_execute('{} shell "ps| grep {}"$'.format( self.adb_command, package_name)).stdout.readlines() else: pid_command = command_execute('{} shell "ps| grep -w {}"'.format( self.adb_command, package_name)).stdout.readlines() return deal_with_python_version(pid_command)
def get_uid(self, pid): result = command_execute("{} shell cat /proc/{}/status".format( self.adb_command, pid)).stdout.readlines() result = deal_with_python_version(result) for i in result: if 'uid' in i.lower(): return i.split()[1]
def check_screen_locked(self, times=1): """ adb shell dumpsys window policy | grep isStatusBarKeyguard 确认是否有锁 adb shell dumpsys window policy | grep ScreenOn 是否亮屏 """ try: if times >= 10: return False logger.info('({}) <尝试{}> 检查设备是否锁屏'.format(self.device_name, times)) window_policy = command_execute( '{} shell dumpsys window policy'.format( self.adb_command)).stdout.read() window_policy = deal_with_python_version(window_policy) locked_status = re.findall(r'isStatusBarKeyguard=(\w+)', window_policy)[0] bright_status = re.findall(r'mScreenOnFully=(\w+)', window_policy)[0] if locked_status == 'false' and bright_status == 'true': logger.info('({}) 设备是正常开锁状态!'.format(self.device_name)) return True elif bright_status == 'false': logger.info('({}) 设备锁屏!'.format(self.device_name)) self.wakeup_screen() time.sleep(1) self.unlock_screen() time.sleep(1) return self.check_screen_locked(times=times + 1) except Exception as e: logger.error(e) logger.error(traceback.format_exc()) return self.check_screen_locked(times=times + 1)
def install_package(self, local_package_path, package_name, force_install=False): logger.info('({}) 开始安装包 : {}'.format(self.device_name, local_package_path)) try: if not os.path.exists(local_package_path): raise LocalPackageNotFoundException if force_install: cmd = '{} install -r {} > install_log.log'.format( self.adb_command, local_package_path) else: cmd = '{} install {} > install_log.log'.format( self.adb_command, local_package_path) p = command_execute(cmd) result = self.output(p) logger.info('({}) {}'.format(self.device_name, result)) if self.check_package_installed(package_name): # for r in result: # if 'Success' in r: # logger.info('({}) 安装 {} 成功'.format(self.device_name, local_package_path)) # return True return True logger.error('({}) 安装 {} 失败'.format(self.device_name, local_package_path)) return False except Exception as e: logger.error('({}) 安装 {} 失败'.format(self.device_name, local_package_path)) logger.error(e) return e
def get_battery_level(self): result = command_execute('{} shell dumpsys battery'.format( self.adb_command)).stdout.readlines() result = deal_with_python_version(result) for r in result: if 'level' in r: return int(r.split(':')[1]) return 0
def clear_package_cache_data(self, package_name): try: logger.info('try to clear cache data information') cmd = '{} shell pm clear {}'.format(self.adb_command, package_name) lines = command_execute(cmd) return lines except Exception as e: logger.error(e)
def run_performance(self, performance_command): try: cmd = '{}'.format(performance_command) p = command_execute(cmd) return p except Exception as e: logger.error(e) logger.error(traceback.format_exc())
def run_monkey(self, monkey_command): try: cmd = '{} {}'.format(self.adb_command, monkey_command) p = command_execute(cmd) return p except Exception as e: logger.error(e) logger.error(traceback.format_exc())
def set_system_default_input(self, key): try: if key: logger.info('try to set system default input to qjp') key_of_qjp = key cmd = '{} shell ime enable {}'.format(self.adb_command, key_of_qjp) p = command_execute(cmd) logger.info(self.output(p)) time.sleep(5) cmd = '{} shell ime set {}'.format(self.adb_command, key_of_qjp) p = command_execute(cmd) logger.info(self.output(p)) time.sleep(5) return True except Exception as e: logger.error(e)
def get_crash_dump_log(self): try: cmd = '{} shell cat /sdcard/MonkeyLog/crash-dump.log'.format( self.adb_command) p = command_execute(cmd) return self.output(p) except Exception as e: logger.error(e) logger.error(traceback.format_exc())
def reset_bug_report_log(self): try: logger.info('reset battery stats log now...') cmd = '{} shell dumpsys batterystats --reset'.format( self.adb_command) p = command_execute(cmd) return self.output(p) except Exception as e: logger.error(e) logger.error(traceback.format_exc())
def disconnect(self, retry_times=10): times = 1 while times < retry_times: logger.info(f'({self.device_name}): 设备尝试断开中 {times}') cmd = f"{self.adb_tool.command_path} disconnect {self.device_name}" p = command_execute(cmd) results = self.adb_tool.output(p) if not self.check_connect(): logger.info(f'({self.device_name}): 设备已断开') break time.sleep(1) times += 1
def remove_file(self, file_name): logger.info('({}) 开始删除文件 <{}>'.format(self.device_name, file_name)) if file_name in ['/', '/sdcard' ] or not file_name.startswith('/sdcard/'): logger.error('({}) 文件名类型不对,无法删除!'.format(self.device_name)) return False cmd = '{} shell rm -rf {}'.format(self.adb_command, file_name) p = command_execute(cmd) r = self.output(p) if len(r) > 0: logger.info(r) return True
def get_bug_report_log(self, log_path): try: cmd = '{} shell bugreport > "{}"'.format(self.adb_command, log_path) p = command_execute(cmd) while p.poll() is None: time.sleep(1) # for file_name in os.listdir("./"): # if file_name.startswith('bugreport-') and file_name.endswith('.zip'): # return file_name return log_path except Exception as e: logger.error(e) logger.error(traceback.format_exc())
def connect(self, retry_times: int = 10): connect_device(f"Android:///{self.device_name}") times = 1 while times < retry_times: if self.check_connect(): logger.info(f'({self.device_name}): 连接设备成功') self.device_model = self.adb_tool.get_device_model() return True else: logger.error(f"({self.device_name}): 连接失败 {results}") logger.info(f'({self.device_name}): 尝试连接设备:[{self.device_name}] <{times}>') cmd = f'{self.adb_tool.command_path} connect {self.device_name}' p = command_execute(cmd) results = self.adb_tool.output(p) time.sleep(1) times += 1 return False
def get_installed_packages(self, show_table=False): try: cmd = '{} shell pm list packages'.format(self.adb_command) p = command_execute(cmd) package_list = self.output(p) if show_table: logger.info('({}) 获取所有的已安装的包'.format(self.device_name)) table_packages = prettytable.PrettyTable() table_packages.field_names = ["id", "package name"] for i, package in enumerate(package_list): row = [i, package] table_packages.add_row(row) logger.info('({}) \n {}'.format(self.device_name, table_packages)) return package_list except Exception as e: logger.error(e) return e
def get_package_version(self, package_name): logger.info('({}) 获取 安装包 版本信息'.format(self.device_name)) if self.check_package_installed(package_name): cmd = '{} shell "dumpsys package {} | grep versionName"'.format( self.adb_command, package_name) p = command_execute(cmd) r = self.output(p) if len(r) > 0: temp = r[0].split('=') if len(temp) > 0: version = temp[1].strip() logger.info('({}) 版本是 [{}] '.format( self.device_name, version)) return version return '' else: logger.info('({}) {} 没有安装!'.format(self.device_name, package_name)) return None
def start_activity(self, package_name, activity_name): try: activity_name = '{}/{}'.format(package_name, activity_name) logger.info('({}) 启动 activity : {}'.format(self.device_name, activity_name)) cmd = '{} shell am start -W -n {}'.format(self.adb_command, activity_name) p = command_execute(cmd) result = self.output(p) logger.info(result) time.sleep(10) current_activity = self.get_current_activity() if current_activity == activity_name: logger.info('({}) activity 已经启动成功'.format(self.device_name)) return True return result except Exception as e: logger.error(e) logger.error(traceback.format_exc())
def get_memory_info(self, package_name): try: logger.info('try to get memory information') cmd = '{} shell dumpsys meminfo {}'.format(self.adb_command, package_name) p = command_execute(cmd) lines = self.output(p) # lines = Utils.deal_with_python_version(lines) heap_size, heap_alloc = 0, 0 for line in lines: if 'Native Heap' in line: temp = line.split() if len(temp) == 9: heap_size = temp[-3] heap_alloc = temp[-2] break heap_size = int(heap_size) if heap_size != '' else 0 heap_alloc = int(heap_alloc) if heap_alloc != '' else 0 return heap_size, heap_alloc except Exception as e: logger.error(e) return 0, 0
def get_device_list(self): try: cmd = '{} devices'.format(self.command_path) p = command_execute(cmd) result = self.output(p) devices = [] if len(result) > 0 and result[0].startswith('List'): for line in result[1:]: if line in ['\n'] or 'un' in line: continue try: device = line.strip().replace('\t', '').split('device')[0] except Exception as e: device = None logger.error(e) if device not in [None, '\n', '\t']: devices.append(device) return devices except Exception as e: logger.info(e) logger.info(traceback.format_exc()) return []
def uninstall_package(self, package_name): logger.info('({}) 开始卸载 :{}'.format(self.device_name, package_name)) try: if self.check_package_installed(package_name): cmd = '{} uninstall {}'.format(self.adb_command, package_name) p = command_execute(cmd) result = self.output(p) logger.info('({}) {}'.format(self.device_name, result)) for r in result: if 'Success' in r: logger.info('({}) 卸载 {} 成功'.format( self.device_name, package_name)) return True logger.error('({}) 卸载 {} 失败 : '.format(self.device_name, package_name)) return False else: logger.info('({}) 设备没有安装 {}, 不需要卸载'.format( self.device_name, package_name)) return True except Exception as e: logger.error('({}) 卸载 {} 失败 : '.format(self.device_name, package_name)) return e
def pull_file(self, source, target): logger.info('({}) 将文件 {} 下载到 {}'.format(self.device_name, source, target)) cmd = '{} pull {} {}'.format(self.adb_command, source, target) p = command_execute(cmd) return self.output(p)
def connect_remote_device(self, remote_device_id): cmd = '{} connect {}'.format(self.adb_command, remote_device_id) p = command_execute(cmd) return self.output(p)
def get_current_application(self): return command_execute( '{} shell "dumpsys window w | grep mCurrentFocus"'.format( self.adb_command))
def get_device_model(self): cmd = '{} shell getprop ro.product.model'.format(self.adb_command) p = command_execute(cmd) r = self.output(p) return r
def get_adb_version(self): cmd = '{} version'.format(self.adb_command) p = command_execute(cmd) return self.output(p)