1074 lines
43 KiB
Python
1074 lines
43 KiB
Python
"""
|
||
Android Device Implementation
|
||
Concrete implementation of AbstractDevice for Android devices.
|
||
"""
|
||
import logging
|
||
import os
|
||
import re
|
||
import subprocess
|
||
import sys
|
||
import time
|
||
from typing import Optional, Dict, Any, List
|
||
from ...core.abstract_device import AbstractDevice
|
||
from ...exceptions import FATAL_EXCEPTIONS
|
||
|
||
# Lazy import flag - adapters will be imported in __init__
|
||
_adapters_imported = False
|
||
|
||
ANDROID_LAUNCHER_PACKAGES = {"app.lawnchair"}
|
||
ANDROID_APP_STORE_PACKAGES = {"com.android.vending"}
|
||
|
||
class AndroidDevice(AbstractDevice):
|
||
"""
|
||
Android 设备的具体实现
|
||
|
||
继承自 AbstractDevice，实现所有 Android 特定的设备操作。
|
||
"""
|
||
|
||
def __init__(self, device_serial=None, is_emulator=False, output_dir=None,
|
||
app_path=None, cv_mode=False, grant_perm=False, telnet_auth_token=None,
|
||
enable_accessibility_hard=False, humanoid=None, ignore_ad=False,
|
||
mumu_manager_path=None, mumu_vm_index=2, **kwargs):
|
||
"""
|
||
初始化 Android 设备连接
|
||
|
||
:param device_serial: 目标设备的序列号
|
||
:param is_emulator: 是否是模拟器
|
||
:param output_dir: 输出目录
|
||
:param app_path: APK 文件路径（被测应用）
|
||
:param cv_mode: 是否启用 CV 模式
|
||
:param grant_perm: 是否自动授予权限
|
||
:param telnet_auth_token: Telnet 认证令牌
|
||
:param enable_accessibility_hard: 是否强制启用辅助功能
|
||
:param humanoid: Humanoid 服务地址
|
||
:param ignore_ad: 是否忽略广告
|
||
:param mumu_manager_path: MuMuManager.exe 路径（用于模拟器底层截图回退）
|
||
:param mumu_vm_index: MuMu 虚拟机索引（默认 2）
|
||
"""
|
||
super().__init__(output_dir=output_dir)
|
||
|
||
# 内部管理的 App 对象
|
||
self._app = None
|
||
self.package_name = app_path # Reusing app_path argument as package_name for compatibility if passed positionally, but better explicitly rename in init
|
||
|
||
if app_path:
|
||
from .android_app import AndroidApp
|
||
self._app = AndroidApp(package_name=app_path, output_dir=output_dir)
|
||
|
||
# 设备标识
|
||
if device_serial is None:
|
||
from .utils import get_available_devices
|
||
all_devices = get_available_devices()
|
||
if len(all_devices) == 0:
|
||
self.logger.warning("ERROR: No device connected.")
|
||
sys.exit(-1)
|
||
device_serial = all_devices[0]
|
||
|
||
if "emulator" in device_serial and not is_emulator:
|
||
self.logger.warning("Seems like you are using an emulator. If so, please add is_emulator option.")
|
||
|
||
self.serial = device_serial
|
||
self.is_emulator = is_emulator
|
||
self.cv_mode = cv_mode
|
||
self.grant_perm = grant_perm
|
||
self.enable_accessibility_hard = enable_accessibility_hard
|
||
self.humanoid = humanoid
|
||
self.ignore_ad = ignore_ad
|
||
self.mumu_manager_path = mumu_manager_path
|
||
self.mumu_vm_index = mumu_vm_index
|
||
|
||
# 设备信息缓存
|
||
self.model_number = None
|
||
self.sdk_version = None
|
||
self.release_version = None
|
||
self._used_ports = []
|
||
|
||
# CV 模式相关缓存
|
||
self.last_screenshot_hash = None
|
||
self.last_views = None
|
||
self.views_cache = {} # Cache for view trees: {hash: views}
|
||
self._accessibility_fail_count = 0 # 连续获取views失败的计数
|
||
|
||
# 状态缓存（用于优化连续事件的状态获取）
|
||
self._last_state = None
|
||
|
||
# 延迟导入适配器以避免循环依赖
|
||
from .adapters.adb import ADB
|
||
from .adapters.telnet import TelnetConsole
|
||
from .adapters.droidbot_app import DroidBotAppConn
|
||
from .adapters.minicap import Minicap
|
||
from .adapters.logcat import Logcat
|
||
from .adapters.user_input_monitor import UserInputMonitor
|
||
from .adapters.process_monitor import ProcessMonitor
|
||
from .adapters.droidbot_ime import DroidBotIme
|
||
|
||
# 初始化适配器
|
||
self.adb = ADB(device=self)
|
||
self.telnet = TelnetConsole(device=self, auth_token=telnet_auth_token)
|
||
self.droidbot_app = DroidBotAppConn(device=self)
|
||
self.minicap = Minicap(device=self)
|
||
self.logcat = Logcat(device=self)
|
||
self.user_input_monitor = UserInputMonitor(device=self)
|
||
self.process_monitor = ProcessMonitor(device=self)
|
||
self.droidbot_ime = DroidBotIme(device=self)
|
||
|
||
# 适配器启用状态
|
||
self.adapters = {
|
||
self.adb: True,
|
||
self.telnet: False,
|
||
self.droidbot_app: True,
|
||
self.minicap: True,
|
||
self.logcat: True,
|
||
self.user_input_monitor: True,
|
||
self.process_monitor: True,
|
||
self.droidbot_ime: True
|
||
}
|
||
|
||
# 模拟器不支持 minicap
|
||
if self.is_emulator:
|
||
self.logger.info("disable minicap on emulator")
|
||
self.adapters[self.minicap] = False
|
||
|
||
# SDK >= 32 不支持 minicap
|
||
if self.get_sdk_version() >= 32:
|
||
self.logger.info("disable minicap on sdk >= 32")
|
||
self.adapters[self.minicap] = False
|
||
|
||
# CV 模式预初始化
|
||
if self.cv_mode:
|
||
self.logger.info("CV模式已启用，正在预初始化OmniParser模型...")
|
||
try:
|
||
from DroidBot.cv import cv
|
||
model_manager = cv.get_model_manager()
|
||
self.logger.info("OmniParser模型预初始化完成")
|
||
except FATAL_EXCEPTIONS:
|
||
raise
|
||
except Exception as e:
|
||
self.logger.error(f"预初始化OmniParser模型失败: {e}")
|
||
raise # CV模式初始化失败是致命的
|
||
|
||
# ==================== 平台信息 ====================
|
||
|
||
def get_platform_name(self) -> str:
|
||
return "android"
|
||
|
||
@property
|
||
def captured_traffic_dir(self) -> str:
|
||
"""
|
||
获取捕获的流量日志存储目录
|
||
"""
|
||
return "/sdcard/Download/PCAPdroid/traffic/"
|
||
|
||
|
||
# ==================== 连接管理 ====================
|
||
|
||
def set_up(self) -> None:
|
||
"""设置设备连接"""
|
||
self.wait_for_device()
|
||
|
||
|
||
# Explicitly set up adapters that require it
|
||
if self.adapters.get(self.droidbot_app):
|
||
self.droidbot_app.set_up()
|
||
if self.adapters.get(self.minicap):
|
||
self.minicap.set_up()
|
||
if self.adapters.get(self.droidbot_ime):
|
||
self.droidbot_ime.set_up()
|
||
|
||
def connect(self) -> bool:
|
||
"""连接到设备"""
|
||
for adapter in self.adapters:
|
||
if self.adapters[adapter]:
|
||
adapter.connect()
|
||
|
||
self.get_sdk_version()
|
||
self.get_release_version()
|
||
self.get_display_info()
|
||
|
||
self.unlock()
|
||
self.check_connectivity()
|
||
self.connected = True
|
||
|
||
# Populating activities dynamically
|
||
if self._app:
|
||
self._app.populate_activities(self)
|
||
|
||
return True
|
||
|
||
def disconnect(self) -> None:
|
||
"""断开设备连接"""
|
||
self.connected = False
|
||
for adapter in self.adapters:
|
||
if self.adapters[adapter]:
|
||
adapter.disconnect()
|
||
|
||
# if self.output_dir is not None:
|
||
# temp_dir = os.path.join(self.output_dir, "temp")
|
||
# if os.path.exists(temp_dir):
|
||
# import shutil
|
||
# shutil.rmtree(temp_dir)
|
||
|
||
def tear_down(self) -> None:
|
||
"""清理资源"""
|
||
# Explicitly tear down adapters that require it
|
||
if self.adapters.get(self.droidbot_app):
|
||
self.droidbot_app.tear_down()
|
||
if self.adapters.get(self.minicap):
|
||
self.minicap.tear_down()
|
||
if self.adapters.get(self.droidbot_ime):
|
||
self.droidbot_ime.tear_down()
|
||
|
||
def check_connectivity(self) -> bool:
|
||
"""检查连接状态"""
|
||
all_connected = True
|
||
for adapter in self.adapters:
|
||
adapter_name = adapter.__class__.__name__
|
||
adapter_enabled = self.adapters[adapter]
|
||
if not adapter_enabled:
|
||
print("[CONNECTION] %s is not enabled." % adapter_name)
|
||
else:
|
||
if adapter.check_connectivity():
|
||
print("[CONNECTION] %s is enabled and connected." % adapter_name)
|
||
else:
|
||
print("[CONNECTION] %s is enabled but not connected." % adapter_name)
|
||
all_connected = False
|
||
return all_connected
|
||
|
||
def wait_for_device(self) -> None:
|
||
"""等待设备启动完成"""
|
||
self.logger.info("waiting for device")
|
||
self.adb.run_cmd(["wait-for-device"])
|
||
|
||
# ==================== 状态获取 ====================
|
||
def check_network(self, host: str = "8.8.8.8") -> bool:
|
||
"""
|
||
通过 ADB Ping 检查安卓设备内部网络是否通畅
|
||
"""
|
||
err_msg = self.adb.run_cmd(['shell', 'ping', '-c', '1', '-W', '2', host])
|
||
if "1 received" in err_msg.lower() :
|
||
return True
|
||
else:
|
||
return False
|
||
|
||
def get_current_state(self) -> 'AndroidDeviceState':
|
||
"""获取当前设备状态"""
|
||
self.logger.debug("getting current device state...")
|
||
current_state = None
|
||
try:
|
||
from datetime import datetime
|
||
tag = datetime.now().strftime("%Y-%m-%d_%H%M%S")
|
||
views = self.get_views()
|
||
foreground_activity = self.get_top_activity_name()
|
||
activity_stack = self.get_current_activity_stack(top_activity=foreground_activity)
|
||
# background_services = self.get_service_names()
|
||
background_services = []
|
||
screenshot_path = self.take_screenshot(tag=tag)
|
||
|
||
from .android_device_state import AndroidDeviceState
|
||
current_state = AndroidDeviceState(
|
||
self,
|
||
views=views,
|
||
foreground_activity=foreground_activity,
|
||
activity_stack=activity_stack,
|
||
background_services=background_services,
|
||
tag=tag,
|
||
screenshot_path=screenshot_path
|
||
)
|
||
except FATAL_EXCEPTIONS:
|
||
raise
|
||
except Exception as e:
|
||
self.logger.error("exception in get_current_state: %s" % e)
|
||
import traceback
|
||
traceback.print_exc()
|
||
return None
|
||
|
||
if not current_state:
|
||
self.logger.warning("Failed to get current state!")
|
||
return current_state
|
||
|
||
def get_display_info(self, refresh: bool = False) -> Dict[str, Any]:
|
||
"""获取显示信息"""
|
||
if self.display_info is None or refresh:
|
||
self.display_info = self.adb.get_display_info()
|
||
return self.display_info
|
||
|
||
# ==================== 屏幕操作 ====================
|
||
|
||
def take_screenshot(self, path: str = None, tag: str = None) -> str:
|
||
"""截取屏幕"""
|
||
if self.output_dir is None and path is None:
|
||
return None
|
||
|
||
if tag is None:
|
||
from datetime import datetime
|
||
tag = datetime.now().strftime("%Y-%m-%d_%H%M%S")
|
||
|
||
if path is not None:
|
||
local_image_path = path
|
||
else:
|
||
local_image_dir = os.path.join(self.output_dir, "states")
|
||
if not os.path.exists(local_image_dir):
|
||
os.makedirs(local_image_dir)
|
||
|
||
ext = ".jpg" if (self.adapters[self.minicap] and self.minicap.last_screen) else ".png"
|
||
local_image_path = os.path.join(local_image_dir, "screen_%s%s" % (tag, ext))
|
||
|
||
# Ensure parent directory exists
|
||
parent_dir = os.path.dirname(local_image_path)
|
||
if parent_dir and not os.path.exists(parent_dir):
|
||
os.makedirs(parent_dir)
|
||
|
||
if self.adapters[self.minicap] and self.minicap.last_screen:
|
||
with open(local_image_path, 'wb') as f:
|
||
f.write(self.minicap.last_screen)
|
||
return local_image_path
|
||
else:
|
||
remote_image_path = "/sdcard/screen_%s.png" % tag
|
||
try:
|
||
self.adb.shell_grep("screencap -p %s" % remote_image_path)
|
||
self.pull_file(remote_image_path, local_image_path)
|
||
self.adb.shell("rm %s" % remote_image_path)
|
||
|
||
# 检查截图是否为空（部分应用限制截图会导致生成0KB的文件）
|
||
if os.path.exists(local_image_path) and os.path.getsize(local_image_path) == 0:
|
||
self.logger.warning("截图文件为0KB，可能被应用限制，尝试使用MuMu模拟器底层截图...")
|
||
import time
|
||
import glob
|
||
import shutil
|
||
|
||
start_time = time.time()
|
||
if not self.mumu_manager_path or not os.path.exists(self.mumu_manager_path):
|
||
self.logger.error("MuMuManager.exe 路径未配置或不存在，无法使用底层截图")
|
||
else:
|
||
mumu_cmd = f'"{self.mumu_manager_path}" control -v {self.mumu_vm_index} tool func -n screenshot'
|
||
subprocess.run(mumu_cmd, shell=True, check=False)
|
||
|
||
# 等待截图文件生成
|
||
time.sleep(1.5)
|
||
|
||
mumu_screenshot_dir = os.path.join(
|
||
os.path.expanduser("~"),
|
||
"Documents", "MuMu共享文件夹", "Screenshots"
|
||
)
|
||
if os.path.exists(mumu_screenshot_dir):
|
||
files = glob.glob(os.path.join(mumu_screenshot_dir, "MuMu-*.png"))
|
||
# 找到命令执行时间之后生成的最新文件（给2秒容错）
|
||
recent_files = [f for f in files if os.path.getmtime(f) >= start_time - 2]
|
||
if recent_files:
|
||
newest_file = max(recent_files, key=os.path.getmtime)
|
||
shutil.move(newest_file, local_image_path)
|
||
self.logger.info(f"成功使用MuMu模拟器底层截图覆盖空文件: {newest_file} -> {local_image_path}")
|
||
else:
|
||
self.logger.error("未找到最近生成的MuMu底层截图文件")
|
||
else:
|
||
self.logger.error(f"MuMu截图目录不存在: {mumu_screenshot_dir}")
|
||
|
||
except FATAL_EXCEPTIONS:
|
||
raise
|
||
except Exception as e:
|
||
self.logger.error(f"Failed to take screenshot: {e}")
|
||
return None
|
||
return local_image_path
|
||
|
||
def unlock(self) -> None:
|
||
"""解锁屏幕"""
|
||
self.adb.unlock()
|
||
|
||
# ==================== 事件发送 ====================
|
||
|
||
def send_event(self, event) -> bool:
|
||
"""发送输入事件"""
|
||
event.send(self)
|
||
return True
|
||
|
||
def view_touch(self, x: int, y: int) -> None:
|
||
"""触摸指定坐标"""
|
||
self.adb.touch(x, y)
|
||
|
||
def view_long_touch(self, x: int, y: int, duration: int = 2000) -> None:
|
||
"""长按指定坐标"""
|
||
self.adb.long_touch(x, y, duration)
|
||
|
||
def view_drag(self, start_xy: tuple, end_xy: tuple, duration: int) -> None:
|
||
"""拖拽操作"""
|
||
self.adb.drag(start_xy, end_xy, duration)
|
||
|
||
def view_set_text(self, text: str) -> None:
|
||
"""设置文本"""
|
||
if self.droidbot_ime.connected:
|
||
self.droidbot_ime.input_text(text=text, mode=0)
|
||
else:
|
||
self.logger.warning("`adb shell input text` doesn't support setting text, appending instead.")
|
||
self.adb.type(text)
|
||
|
||
|
||
def key_press(self, key_code: str) -> None:
|
||
"""按键操作"""
|
||
self.adb.press(key_code)
|
||
|
||
# ==================== 应用管理 ====================
|
||
|
||
@property
|
||
def app_identifier(self) -> str:
|
||
"""获取被测应用的唯一标识符（package_name）"""
|
||
if self._app:
|
||
return self._app.package_name
|
||
return ""
|
||
|
||
def is_foreground(self) -> bool:
|
||
"""检查被测应用是否在前台"""
|
||
if not self._app:
|
||
return True # 没有指定应用时，总是返回 True
|
||
current_package = self.get_current_package()
|
||
return current_package == self._app.package_name
|
||
|
||
def get_redirect_target_info(self) -> Optional[Dict[str, Optional[str]]]:
|
||
"""
|
||
获取应用离开前台后的目标包名及分类
|
||
|
||
:return:
|
||
{
|
||
"target": 跳转目标包名或 None,
|
||
"type": "app_store" | "launcher" | "other"
|
||
}
|
||
"""
|
||
if not self._app:
|
||
return None
|
||
|
||
current_package = self.get_current_package()
|
||
if current_package in ANDROID_APP_STORE_PACKAGES:
|
||
target_type = "app_store"
|
||
elif current_package in ANDROID_LAUNCHER_PACKAGES or current_package is None:
|
||
target_type = "launcher"
|
||
else:
|
||
target_type = "other"
|
||
|
||
return {
|
||
"target": current_package,
|
||
"type": target_type
|
||
}
|
||
|
||
def pull_back_to_app(self) -> bool:
|
||
"""将被测应用拉回前台"""
|
||
if not self._app:
|
||
return True # 没有指定应用时，无需拉回
|
||
|
||
package_name = self._app.package_name
|
||
current_package = self.get_current_package() # 内部已经有重试机制
|
||
|
||
if current_package == package_name:
|
||
return True
|
||
|
||
if current_package is None:
|
||
self.logger.error(f"【Pull Back】多次尝试后仍无法获取当前包名，判定为系统异常，返回失败")
|
||
return False
|
||
|
||
self.logger.info(f"【Pull Back】检测到当前处于 {current_package}，正在拉回 {package_name}...")
|
||
|
||
max_retries = 3
|
||
for retry_count in range(1, max_retries + 1):
|
||
self.logger.info(f"【Pull Back】尝试第 {retry_count}/{max_retries} 次拉回...")
|
||
try:
|
||
self.adb.shell("input keyevent 4")
|
||
time.sleep(0.5)
|
||
monkey_cmd = f"monkey -p {package_name} -c android.intent.category.LAUNCHER 1 > /dev/null 2>&1"
|
||
self.adb.shell_grep(monkey_cmd)
|
||
|
||
max_wait_time = 10
|
||
check_interval = 0.5
|
||
elapsed_time = 0
|
||
while elapsed_time < max_wait_time:
|
||
time.sleep(check_interval)
|
||
elapsed_time += check_interval
|
||
verify_package = self.get_current_package()
|
||
if verify_package == package_name:
|
||
self.logger.info(f"【Pull Back】第 {retry_count} 次尝试成功 (耗时 {elapsed_time:.1f}s)")
|
||
return True
|
||
|
||
self.logger.warning(f"【Pull Back】第 {retry_count} 次尝试失败，当前包名: {verify_package}")
|
||
except FATAL_EXCEPTIONS:
|
||
raise
|
||
except Exception as e:
|
||
self.logger.error(f"【Pull Back】第 {retry_count} 次尝试发生异常: {e}")
|
||
return False
|
||
self.logger.warning(f"【Pull Back】{max_retries} 次尝试都失败")
|
||
return False
|
||
|
||
def start_app(self) -> bool:
|
||
"""启动被测应用"""
|
||
if not self._app:
|
||
self.logger.warning("No app specified, cannot start")
|
||
return False
|
||
|
||
try:
|
||
# 优先尝试使用 monkey 启动，因为它不需要知道主 Activity
|
||
# -p 包名
|
||
# -c android.intent.category.LAUNCHER 模拟点击桌面图标启动
|
||
# 1 表示随机产生一个事件，这里其实就是触发启动
|
||
cmd = f"monkey -p {self._app.package_name} -c android.intent.category.LAUNCHER 1"
|
||
self.adb.shell(cmd)
|
||
time.sleep(15)
|
||
|
||
# 检测是否为游戏应用（通过检查是否加载了 libunity.so）
|
||
self._check_and_enable_cv_mode_if_game()
|
||
|
||
return True
|
||
except FATAL_EXCEPTIONS:
|
||
raise
|
||
except Exception as e:
|
||
self.logger.error(f"Failed to start app via monkey: {e}")
|
||
return False
|
||
|
||
def _check_and_enable_cv_mode_if_game(self):
|
||
"""
|
||
检测应用是否为游戏（通过检查是否加载了 libunity.so 或 Activity 名称包含 unity）。
|
||
如果是游戏，则自动启用 CV 模式。
|
||
"""
|
||
if not self._app:
|
||
return
|
||
|
||
try:
|
||
package_name = self._app.package_name
|
||
|
||
# 1. 检查 Activity 名称是否包含 unity 关键字
|
||
top_activity = self.get_top_activity_name()
|
||
if top_activity and 'unity' in top_activity.lower():
|
||
self.logger.info(f"Detected game app (activity name contains 'unity': {top_activity}), enabling CV mode")
|
||
self.cv_mode = True
|
||
return
|
||
|
||
# 2. 获取应用进程 PID（使用 shell_grep 支持管道符）
|
||
pid_cmd = f"ps -ef | grep {package_name}"
|
||
pid_output = self.adb.shell_grep(pid_cmd)
|
||
|
||
if not pid_output:
|
||
self.logger.debug(f"Could not find process for package: {package_name}")
|
||
return
|
||
|
||
# 解析 PID（ps -ef 输出格式中 PID 是第二列）
|
||
pid = None
|
||
for line in pid_output.strip().split('\n'):
|
||
if package_name in line and 'grep' not in line:
|
||
parts = line.split()
|
||
if len(parts) >= 2:
|
||
try:
|
||
pid = parts[1]
|
||
break
|
||
except (IndexError, ValueError):
|
||
continue
|
||
|
||
if not pid:
|
||
self.logger.debug(f"Could not parse PID for package: {package_name}")
|
||
return
|
||
|
||
self.logger.debug(f"Found PID {pid} for package {package_name}")
|
||
|
||
# 3. 检查 /proc/pid/maps 中是否包含 libunity.so（使用 shell_grep 支持管道符）
|
||
maps_cmd = f"su 0 cat /proc/{pid}/maps | grep libunity.so"
|
||
maps_output = self.adb.shell_grep(maps_cmd)
|
||
|
||
if maps_output and 'libunity.so' in maps_output:
|
||
self.logger.info(f"Detected game app (libunity.so found in process maps), enabling CV mode")
|
||
self.cv_mode = True
|
||
else:
|
||
self.logger.info(f"No libunity.so found, not a Unity game")
|
||
|
||
except FATAL_EXCEPTIONS:
|
||
raise
|
||
except Exception as e:
|
||
self.logger.debug(f"Failed to check if app is a game: {e}")
|
||
|
||
|
||
def install_app(self) -> bool:
|
||
"""安装被测应用 (We assume app is already installed)"""
|
||
self.logger.info("Skipping install_app: Package-only mode assumes app is installed.")
|
||
return True
|
||
|
||
def uninstall_app(self) -> bool:
|
||
"""卸载被测应用 (We do not uninstall in Package-only mode to preserve environment)"""
|
||
self.logger.info("Skipping uninstall_app: Package-only mode preserves app.")
|
||
return True
|
||
|
||
# ==================== Android 特定方法 ====================
|
||
|
||
def get_traffic_domains(self, remote_dir: str) -> Optional[str]:
|
||
"""
|
||
获取最新的流量域名日志文件内容。
|
||
对应 TrafficMonitor 的需求。
|
||
"""
|
||
try:
|
||
# 1. ls -t to find latest file
|
||
# Note: We use shell directly to use wildcard expansion and ls options
|
||
cmd_find_latest = ["shell", "ls", "-t", os.path.join(remote_dir, "*.txt")]
|
||
latest_file_path_out = self.adb.run_cmd(cmd_find_latest)
|
||
|
||
if not latest_file_path_out:
|
||
return None
|
||
|
||
# Parse first line (ls -t output)
|
||
latest_file = latest_file_path_out.split('\n')[0].strip()
|
||
if not latest_file:
|
||
return None
|
||
|
||
# 2. tail -n 500
|
||
cmd_read = ["shell", "cat", latest_file]
|
||
content = self.adb.run_cmd(cmd_read)
|
||
return content
|
||
except Exception as e:
|
||
self.logger.error(f"Failed to get traffic domains: {e}")
|
||
return None
|
||
|
||
def is_traffic_capture_running(self) -> bool:
|
||
"""通过通知栏检查 PCAPDroid 是否正在运行"""
|
||
try:
|
||
output = self.adb.run_cmd([
|
||
"shell", "dumpsys", "notification", "--noredact"
|
||
])
|
||
if "com.emanuelef.remote_capture" in output and "Capture running" in output:
|
||
return True
|
||
return False
|
||
except Exception:
|
||
return False
|
||
|
||
def restart_traffic_capture(self, package_name: str) -> None:
|
||
"""重启 PCAPDroid 抓包"""
|
||
try:
|
||
cmd = [
|
||
"shell", "am", "start", "-n",
|
||
"com.emanuelef.remote_capture/com.emanuelef.remote_capture.activities.CaptureCtrl",
|
||
"-e", "action", "start",
|
||
"-e", "pcap_dump_mode", "pcap_file",
|
||
"-e", "app_filter", package_name,
|
||
"-e", "root_capture", "true" if self.is_emulator else "false",
|
||
]
|
||
self.adb.run_cmd(cmd)
|
||
time.sleep(5)
|
||
except Exception as e:
|
||
self.logger.error(f"Failed to restart traffic capture: {e}")
|
||
|
||
def get_model_number(self) -> str:
|
||
"""获取设备型号"""
|
||
if self.model_number is None:
|
||
self.model_number = self.adb.get_model_number()
|
||
return self.model_number
|
||
|
||
def get_sdk_version(self) -> int:
|
||
"""获取 SDK 版本"""
|
||
if self.sdk_version is None:
|
||
self.sdk_version = self.adb.get_sdk_version()
|
||
return self.sdk_version
|
||
|
||
def get_release_version(self) -> str:
|
||
"""获取 Android 版本"""
|
||
if self.release_version is None:
|
||
self.release_version = self.adb.get_release_version()
|
||
return self.release_version
|
||
|
||
|
||
def get_top_activity_name(self) -> Optional[str]:
|
||
"""获取当前 Activity"""
|
||
try:
|
||
output = self.adb.shell("dumpsys activity activities")
|
||
resumed_re = re.compile(r'mResumedActivity: ActivityRecord\{[a-f0-9]+\s+\S+\s+([^ ]+)\s+t(\d+)\}')
|
||
m = resumed_re.search(output)
|
||
if m:
|
||
return m.group(1)
|
||
|
||
focused_re = re.compile(r'mFocusedActivity: ActivityRecord\{[a-f0-9]+\s+\S+\s+([^ ]+)\s+t(\d+)\}')
|
||
m = focused_re.search(output)
|
||
if m:
|
||
return m.group(1)
|
||
|
||
activity_line_re = re.compile(r'\*\s*Hist\s*#\d+:\s*ActivityRecord\{[^ ]+\s*[^ ]+\s*([^ ]+)\s*t(\d+)}')
|
||
m = activity_line_re.search(output)
|
||
if m:
|
||
return m.group(1)
|
||
except FATAL_EXCEPTIONS:
|
||
raise
|
||
except Exception as e:
|
||
self.logger.error(f"Error getting top activity name: {e}")
|
||
return None
|
||
return None
|
||
|
||
def get_current_package(self) -> Optional[str]:
|
||
"""
|
||
获取当前前台包名
|
||
失败时自动透明重试（最多3次，每次间隔0.5秒）
|
||
|
||
:return: 包名或 None
|
||
"""
|
||
max_attempts = 3
|
||
retry_delay = 0.5 # 秒
|
||
|
||
for attempt in range(max_attempts):
|
||
try:
|
||
# 方法1: 通过 dumpsys window 获取 mFocusedApp (最准确)
|
||
app_out = self.adb.shell_grep("dumpsys window | grep mFocusedApp")
|
||
if app_out:
|
||
# findall 取最后一个非 null 的匹配（dumpsys 会输出多行历史）
|
||
matches = re.findall(r'mFocusedApp=ActivityRecord\{[a-f0-9]+\s+\S+\s+([^/]+)/', app_out)
|
||
if matches:
|
||
pkg_name = matches[-1]
|
||
if attempt > 0:
|
||
self.logger.debug(f"【Package】第 {attempt + 1} 次尝试通过 mFocusedApp 获取到: {pkg_name}")
|
||
return pkg_name
|
||
# 方法2: 通过 dumpsys window 获取焦点窗口
|
||
focus_out = self.adb.shell_grep("dumpsys window | grep mCurrentFocus")
|
||
if focus_out:
|
||
matches = re.findall(r'Window\{[a-f0-9]+\s+\S+\s+([^/]+)/', focus_out)
|
||
if matches:
|
||
pkg_name = matches[-1]
|
||
if attempt > 0:
|
||
self.logger.debug(f"【Package】第 {attempt + 1} 次尝试通过 mCurrentFocus 获取到: {pkg_name}")
|
||
return pkg_name
|
||
# 方法3: 通过 dumpsys activity 获取 resumed activity
|
||
resumed_out = self.adb.shell_grep("dumpsys activity activities | grep mResumedActivity")
|
||
if resumed_out:
|
||
matches = re.findall(r'\{[a-f0-9]+\s+\S+\s+([^/]+)/', resumed_out)
|
||
if matches:
|
||
pkg_name = matches[-1]
|
||
if attempt > 0:
|
||
self.logger.debug(f"【Package】第 {attempt + 1} 次尝试通过 mResumedActivity 获取到: {pkg_name}")
|
||
return pkg_name
|
||
|
||
# 三种方法都没获取到，且还有重试机会
|
||
if attempt < max_attempts - 1:
|
||
self.logger.debug(f"【Package】第 {attempt + 1}/{max_attempts} 次尝试未获取到包名，{retry_delay}秒后重试...")
|
||
time.sleep(retry_delay)
|
||
except Exception as e:
|
||
if attempt < max_attempts - 1:
|
||
self.logger.debug(f"【Package】第 {attempt + 1}/{max_attempts} 次尝试异常: {e}，{retry_delay}秒后重试...")
|
||
time.sleep(retry_delay)
|
||
else:
|
||
self.logger.error(f"【Package】最终尝试异常: {e}")
|
||
if isinstance(e, FATAL_EXCEPTIONS):
|
||
raise
|
||
return None
|
||
|
||
self.logger.warning(f"【Package】{max_attempts} 次尝试后仍无法获取包名")
|
||
return None
|
||
|
||
def get_current_activity_stack(self, top_activity: Optional[str] = None) -> List[str]:
|
||
"""获取当前 Activity 栈"""
|
||
task_to_activities = self.get_task_activities()
|
||
if top_activity is None:
|
||
top_activity = self.get_top_activity_name()
|
||
if top_activity:
|
||
for task_id in task_to_activities:
|
||
activities = task_to_activities[task_id]
|
||
if len(activities) > 0 and activities[0] == top_activity:
|
||
return activities
|
||
self.logger.warning("Unable to get current activity stack.")
|
||
return [top_activity]
|
||
else:
|
||
return []
|
||
|
||
def get_task_activities(self) -> Dict[str, List[str]]:
|
||
"""获取任务和对应的 Activity"""
|
||
task_to_activities = {}
|
||
lines = self.adb.shell("dumpsys activity activities").splitlines()
|
||
activity_line_re = re.compile(r'\*\s*Hist\s*#\d+:\s*ActivityRecord\{[^ ]+\s*[^ ]+\s*([^ ]+)\s*t(\d+)}')
|
||
|
||
for line in lines:
|
||
line = line.strip()
|
||
task_match = re.match(r'^\s*Task\s*id\s*#(\d+)|^\s*Task\{\w+\s*#(\d+)', line)
|
||
if task_match:
|
||
task_id = task_match.group(1) or task_match.group(2)
|
||
task_to_activities[task_id] = []
|
||
elif re.match(r'\*\s*Hist\s*#', line):
|
||
m = activity_line_re.match(line)
|
||
if m:
|
||
activity = m.group(1)
|
||
task_id = m.group(2)
|
||
if task_id not in task_to_activities:
|
||
task_to_activities[task_id] = []
|
||
task_to_activities[task_id].append(activity)
|
||
|
||
return task_to_activities
|
||
|
||
def get_service_names(self) -> List[str]:
|
||
"""获取运行中的服务"""
|
||
services = []
|
||
dat = self.adb.shell('dumpsys activity services')
|
||
lines = dat.splitlines()
|
||
service_re = re.compile(r'^.+ServiceRecord{.+ ([A-Za-z0-9_.]+)/([A-Za-z0-9_.]+)')
|
||
|
||
for line in lines:
|
||
m = service_re.search(line)
|
||
if m:
|
||
package = m.group(1)
|
||
service = m.group(2)
|
||
services.append("%s/%s" % (package, service))
|
||
return services
|
||
|
||
def get_views(self) -> Optional[List[Dict[str, Any]]]:
|
||
"""获取当前界面视图"""
|
||
if self.cv_mode:
|
||
return self._get_views_cv_mode()
|
||
|
||
if self.droidbot_app and self.adapters[self.droidbot_app]:
|
||
views = self.droidbot_app.get_views()
|
||
if views:
|
||
self._accessibility_fail_count = 0
|
||
return views
|
||
else:
|
||
self._accessibility_fail_count += 1
|
||
self.logger.warning(f"Failed to get views using Accessibility. (consecutive failures: {self._accessibility_fail_count})")
|
||
if self._accessibility_fail_count >= 5:
|
||
self.logger.warning("Accessibility failed 5 times consecutively, switching to CV mode.")
|
||
self.cv_mode = True
|
||
self._accessibility_fail_count = 0
|
||
return self._get_views_cv_mode()
|
||
|
||
self.logger.warning("failed to get current views!")
|
||
return None
|
||
|
||
def _get_views_cv_mode(self) -> Optional[List[Dict[str, Any]]]:
|
||
"""CV 模式获取视图 - 使用统一的 ViewDict 格式"""
|
||
try:
|
||
from .adapters import cv
|
||
from datetime import datetime
|
||
|
||
tag = datetime.now().strftime("%Y-%m-%d_%H%M%S")
|
||
temp_dir = os.path.join(self.output_dir, "temp") if self.output_dir else "/tmp"
|
||
if not os.path.exists(temp_dir):
|
||
os.makedirs(temp_dir)
|
||
|
||
local_image_path = os.path.join(temp_dir, "cv_screen_%s.png" % tag)
|
||
remote_image_path = "/sdcard/cv_screen_%s.png" % tag
|
||
try:
|
||
self.adb.shell_grep("screencap -p %s" % remote_image_path)
|
||
except FATAL_EXCEPTIONS:
|
||
raise
|
||
except Exception as e:
|
||
self.logger.error(f"Failed to take screenshot: {e}")
|
||
return None
|
||
|
||
self.pull_file(remote_image_path, local_image_path)
|
||
self.adb.shell("rm %s" % remote_image_path)
|
||
|
||
img = cv.load_image_from_path(local_image_path)
|
||
current_screenshot_hash = cv.calculate_dhash(img)
|
||
|
||
# 检查缓存（仅使用模糊匹配）
|
||
# 针对动态 UI 场景（如游戏），遍历缓存寻找相似度高的历史界面
|
||
# 即使 Hash 不同（微小变动），只要相似度高（>90%）也视为命中
|
||
|
||
best_match_views = None
|
||
max_distance = len(current_screenshot_hash) * 4
|
||
|
||
# 遍历缓存进行模糊匹配
|
||
for cached_hash in self.views_cache:
|
||
hamming_distance = cv.dhash_hamming_distance(current_screenshot_hash, cached_hash)
|
||
similarity = 1.0 - (hamming_distance / max_distance)
|
||
|
||
# 只要找到满足条件（>90%）的缓存，立即返回（贪婪策略）
|
||
# 假设缓存中的界面都是“不同”的，一旦相似度极高，说明就是同一个界面
|
||
if similarity > 0.88:
|
||
best_match_views = self.views_cache[cached_hash]
|
||
break # Found a match, stop searching
|
||
|
||
if best_match_views:
|
||
self.logger.info(f"View cache hit! Similarity: {similarity:.2f}")
|
||
self.last_screenshot_hash = current_screenshot_hash
|
||
self.last_views = best_match_views
|
||
try:
|
||
os.remove(local_image_path)
|
||
except:
|
||
pass
|
||
return best_match_views
|
||
|
||
# find_views 现在直接返回 List[ViewDict] 格式
|
||
cv_views = cv.find_views(img)
|
||
|
||
# 构建根视图
|
||
display_info = self.get_display_info()
|
||
width = display_info.get('width', 1080)
|
||
height = display_info.get('height', 1920)
|
||
|
||
root_view = {
|
||
"class_name": "CVViewRoot",
|
||
"bounds": [[0, 0], [width, height]],
|
||
"enabled": True,
|
||
"visible": True,
|
||
"clickable": False,
|
||
"scrollable": False,
|
||
"editable": False,
|
||
"temp_id": 0,
|
||
"children": [],
|
||
"text": "",
|
||
"source": "cv",
|
||
"resource_id": "",
|
||
"view_str": "cv_root",
|
||
}
|
||
|
||
# 重新分配 temp_id 并设置父子关系
|
||
views = [root_view]
|
||
for idx, view in enumerate(cv_views):
|
||
view["temp_id"] = idx + 1
|
||
view["parent"] = 0
|
||
views.append(view)
|
||
|
||
root_view["children"] = list(range(1, len(views)))
|
||
|
||
self.last_screenshot_hash = current_screenshot_hash
|
||
self.last_views = views
|
||
|
||
# 更新缓存
|
||
self.views_cache[current_screenshot_hash] = views
|
||
# 限制缓存大小 (LRU)
|
||
if len(self.views_cache) > 50:
|
||
self.views_cache.pop(next(iter(self.views_cache)))
|
||
|
||
try:
|
||
os.remove(local_image_path)
|
||
except:
|
||
pass
|
||
|
||
return views
|
||
except Exception as e:
|
||
self.logger.error(f"Failed to get views using CV mode: {e}")
|
||
return None
|
||
|
||
|
||
def send_intent(self, intent) -> str:
|
||
"""发送 Intent"""
|
||
assert self.adb is not None
|
||
assert intent is not None
|
||
if hasattr(intent, 'get_cmd'):
|
||
cmd = intent.get_cmd()
|
||
else:
|
||
cmd = intent
|
||
return self.adb.shell(cmd)
|
||
|
||
def push_file(self, local_file: str, remote_dir: str = "/sdcard/") -> None:
|
||
"""推送文件到设备"""
|
||
if not os.path.exists(local_file):
|
||
self.logger.warning("push_file file does not exist: %s" % local_file)
|
||
self.adb.run_cmd(["push", local_file, remote_dir])
|
||
|
||
def pull_file(self, remote_file: str, local_file: str) -> None:
|
||
"""从设备拉取文件"""
|
||
self.adb.run_cmd(["pull", remote_file, local_file])
|
||
|
||
def get_random_port(self) -> int:
|
||
"""获取随机端口"""
|
||
import socket
|
||
temp_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
|
||
temp_sock.bind(("", 0))
|
||
port = temp_sock.getsockname()[1]
|
||
temp_sock.close()
|
||
if port in self._used_ports:
|
||
return self.get_random_port()
|
||
self._used_ports.append(port)
|
||
return port
|
||
|
||
def get_app_pid(self, app) -> Optional[int]:
|
||
"""获取应用 PID"""
|
||
if hasattr(app, 'get_package_name'):
|
||
package = app.get_package_name()
|
||
else:
|
||
package = app
|
||
|
||
name2pid = {}
|
||
ps_out = self.adb.shell(["ps"])
|
||
ps_out_lines = ps_out.splitlines()
|
||
|
||
if len(ps_out_lines) > 0:
|
||
ps_out_head = ps_out_lines[0].split()
|
||
if len(ps_out_head) >= 2 and ps_out_head[1] != "PID":
|
||
self.logger.warning("ps command output format error: %s" % ps_out_head)
|
||
|
||
for ps_out_line in ps_out_lines[1:]:
|
||
segs = ps_out_line.split()
|
||
if len(segs) < 4:
|
||
continue
|
||
try:
|
||
pid = int(segs[1])
|
||
name = segs[-1]
|
||
name2pid[name] = pid
|
||
except:
|
||
continue
|
||
|
||
if package in name2pid:
|
||
return name2pid[package]
|
||
|
||
possible_pids = [name2pid[name] for name in name2pid if name.startswith(package)]
|
||
if len(possible_pids) > 0:
|
||
return min(possible_pids)
|
||
|
||
return None
|
||
|
||
# ==================== 性能分析实现 ====================
|
||
def run_initial_setup(self) -> bool:
|
||
from DroidBot.guiagent_bridge import GuiAgentBridge
|
||
|
||
bridge = GuiAgentBridge(device=self, app=self.package_name)
|
||
current_state = self.get_current_state()
|
||
return bridge.handle_with_guiagent("game_initial", {"state": current_state})
|
||
|
||
def start_profiling(self, trace_file: str, sampling: Optional[int] = None) -> bool:
|
||
"""
|
||
Android特定的profiling实现
|
||
|
||
:param trace_file: 跟踪文件路径
|
||
:param sampling: 采样间隔(可选)
|
||
:return: 是否成功启动
|
||
"""
|
||
if not self._app:
|
||
return False
|
||
|
||
pid = self.get_app_pid(self._app)
|
||
if pid is None:
|
||
self.logger.warning("Cannot start profiling: app PID not found")
|
||
return False
|
||
|
||
try:
|
||
if sampling is not None:
|
||
self.adb.shell(["am", "profile", "start", "--sampling", str(sampling), str(pid), trace_file])
|
||
else:
|
||
self.adb.shell(["am", "profile", "start", str(pid), trace_file])
|
||
self.logger.info(f"Profiling started for PID {pid}")
|
||
return True
|
||
except FATAL_EXCEPTIONS:
|
||
raise
|
||
except Exception as e:
|
||
self.logger.error(f"Failed to start profiling: {e}")
|
||
return False
|
||
|
||
def stop_profiling(self, trace_file: str, output_path: str) -> bool:
|
||
"""
|
||
Android特定的profiling停止实现
|
||
|
||
:param trace_file: 跟踪文件路径
|
||
:param output_path: 输出路径
|
||
:return: 是否成功停止
|
||
"""
|
||
if not self._app:
|
||
return False
|
||
|
||
pid = self.get_app_pid(self._app)
|
||
if pid is None:
|
||
self.logger.warning("Cannot stop profiling: app PID not found")
|
||
return False
|
||
|
||
try:
|
||
self.adb.shell(["am", "profile", "stop", str(pid)])
|
||
|
||
# Wait for trace file to be written
|
||
import time
|
||
time.sleep(2)
|
||
|
||
# Pull trace file
|
||
if output_path and os.path.exists(os.path.dirname(output_path)):
|
||
self.pull_file(trace_file, output_path)
|
||
self.logger.info(f"Profiling trace saved to {output_path}")
|
||
|
||
return True
|
||
except FATAL_EXCEPTIONS:
|
||
raise
|
||
except Exception as e:
|
||
self.logger.error(f"Failed to stop profiling: {e}")
|
||
return False
|
||
|