import subprocess import threading from datetime import datetime, timedelta import os import sys import warnings # PaddleOCR 3.x 会在初始化/导入时进行模型源连通性检查;在国内网络环境下容易卡住。 # 这里提前设置环境变量,避免启动耗时/卡死。 os.environ.setdefault("DISABLE_MODEL_SOURCE_CHECK", "True") # 额外抑制 paddle/oneDNN/glog 的冗余信息(INFO/WARNING) os.environ.setdefault("GLOG_minloglevel", "2") os.environ.setdefault("OMP_NUM_THREADS", "1") # 抑制 PyTorch DataLoader 的 pin_memory 警告(当没有 GPU 时,EasyOCR 会触发此警告) warnings.filterwarnings("ignore", message=".*pin_memory.*", category=UserWarning) warnings.filterwarnings("ignore", message=".*accelerator.*", category=UserWarning) import time as time_module # alias for existing code that uses `time` name time = time_module from PIL import Image, ImageFilter # type: ignore[import] from PIL import UnidentifiedImageError # type: ignore[import] import numpy as np # type: ignore[import] import logging import re import random import xml.etree.ElementTree as ET import shlex import contextlib import base64 from typing import Tuple, Optional, Any # Pillow 版本兼容:使用 Image.Resampling 或回退到 Image 常量 try: _RESAMPLE = Image.Resampling except Exception: _RESAMPLE = Image # 外部完整版 fudai 逻辑所在的工作树路径,用于镜像 screenshot 给那边使用。 # 这些常量与文件 IO 辅助函数已抽离到 io_utils.py,此处仅为向后兼容重新导出。 from douyin.core.io_utils import ( _EXTERNAL_DOUYIN_FUDAI_DIR, _EXTERNAL_AXF_SCREENSHOT, _verify_png_integrity, _safe_replace_file, _ensure_parent_dir, _mirror_screenshot_to_external, ) # 模块级 logger:原代码用 print 输出 OCR 初始化 / 截图 / 滑动 / 调试日志,统一走 logging。 # 保留消息中已有的 [OCR] / [截图] / [Underlying] / [警告] / [错误] 前缀,避免改变历史搜索习惯。 # 设备选择交互(含 input())的 CLI 输出仍用 print,因为用户需要在 stdout 看到提示。 _LOGGER = logging.getLogger("douyin.core.underlying_operations") def _uo_log(msg: str, level: str = "INFO") -> None: """统一底层操作日志出口;失败兜底 stdout。""" try: lv = str(level or "INFO").upper() if lv == "ERROR": _LOGGER.error(str(msg)) elif lv == "WARNING": _LOGGER.warning(str(msg)) elif lv == "DEBUG": _LOGGER.debug(str(msg)) else: _LOGGER.info(str(msg)) except Exception: try: print(str(msg)) except Exception: pass # 已搬到子包 douyin.core.underlying_operations_pkg 的 6 个方法实现 from douyin.core.underlying_operations_pkg import ( _adb_path as _impl_adb_path, _find_pic_path as _impl_find_pic_path, _parse_bounds as _impl_parse_bounds, _pick_adbkeyboard_ime as _impl_pick_adbkeyboard_ime, check_countdown as _impl_check_countdown, extract_ocr_content as _impl_extract_ocr_content, _adb_args as _impl_adb_args, save_reward_pic as _impl_save_reward_pic, set_clipboard_text as _impl_set_clipboard_text, _swipe_with_sendevent_improved as _impl_swipe_sendevent_improved, select_device as _impl_select_device, analyse_pic_digits as _impl_analyse_pic_digits, ) class underlying_operations: """底层操作类""" def __init__(self): # 关闭文档方向/矫正等重型前处理:我们的截图是手机UI,不是扫描文档。 # 支持延迟初始化(测试流程/只做点击时不需要 OCR)。 self.ocr: Any = None self.ocr_type = None # 'easyocr' 或 'paddleocr' # 用于存储OCR区域的坐标信息(key为picname,value为(left, top, right, bottom)) self._ocr_coords_cache: dict[str, tuple[int, int, int, int]] = {} # 线程安全锁 self._ocr_lock = threading.RLock() # 保护 OCR 初始化 self._ocr_coords_lock = threading.Lock() # 保护坐标缓存 # 默认使用CPU模式(删除GPU检测) self._gpu_available = False if not str(os.environ.get("SKIP_OCR_INIT", "")).strip(): # 统一通过 operations.ocr_operations 的工厂函数初始化(避免与 OCRProcessor 重复定义) # 优先 PaddleOCR v4-mobile(实测精度+速度均胜 EasyOCR),失败回退 EasyOCR try: from operations.ocr_operations import _build_paddle, _build_easyocr # noqa: WPS433 except Exception: _build_paddle = None _build_easyocr = None try: if _build_paddle is None: raise ImportError("ocr_operations._build_paddle 不可用") self.ocr = _build_paddle() self.ocr_type = "paddleocr" _uo_log("[OCR] 使用 PaddleOCR v4-mobile(CPU模式)") except Exception as e: _uo_log(f"[OCR] PaddleOCR 初始化失败: {e},回退到 EasyOCR") try: if _build_easyocr is None: raise ImportError("ocr_operations._build_easyocr 不可用") self.ocr = _build_easyocr() self.ocr_type = "easyocr" _uo_log("[OCR] 使用 EasyOCR(CPU模式,回退引擎)") except Exception as e2: _uo_log(f"[OCR] 所有 OCR 引擎初始化失败: {e2}") self.ocr = None self.ocr_type = None # 注释掉全局日志禁用,以便查看详细的计时日志 # logging.disable(logging.DEBUG) # logging.disable(logging.WARNING) # 用于短期内记录 get_screenshot 调用来源(用于精确定位高频调用) try: import collections self._screenshot_call_cache = collections.deque(maxlen=1000) except Exception: self._screenshot_call_cache = [] # 日志文件路径(JSON Lines 格式) try: from douyin.core import path_config self._screenshot_log_path = os.path.join( path_config.get_logs_dir(), "screenshot_calls.jsonl" ) except Exception: # path_config 不可用时退化到 dirname(保留旧行为兼容) self._screenshot_log_path = os.path.join( os.path.dirname(__file__), "logs", "screenshot_calls.jsonl" ) @staticmethod def _adb() -> str: adb = str(os.environ.get("ADB_EXECUTABLE", "adb") or "adb") # 始终加引号,避免路径带空格 / 版本混用 if adb.startswith('"') and adb.endswith('"'): return adb return f'"{adb}"' @staticmethod def _adb_path() -> str: return _impl_adb_path() def _adb_args(self, device_id: str, *args: object) -> list[str]: return _impl_adb_args(device_id, *args) @staticmethod def _split_shell_cmd(shell_cmd: str) -> list[str]: return shlex.split(str(shell_cmd or ""), posix=(os.name != "nt")) def _ensure_ocr(self): """OCR 引擎延迟初始化(与 __init__ 同优先级:Paddle 优先,EasyOCR 兜底) 加锁防止多线程并发触发重复初始化(main 在 ff8de2c 修复 #7 并发安全问题时引入 _ocr_lock)。 """ if self.ocr is not None: return with self._ocr_lock: # 双检:拿到锁后再确认一次 if self.ocr is not None: return try: from operations.ocr_operations import _build_paddle, _build_easyocr # noqa: WPS433 except Exception: _build_paddle = None _build_easyocr = None try: if _build_paddle is None: raise ImportError("ocr_operations._build_paddle 不可用") self.ocr = _build_paddle() self.ocr_type = "paddleocr" _uo_log("[OCR] 延迟初始化:使用 PaddleOCR v4-mobile(CPU模式)") return except Exception as e: _uo_log(f"[OCR] 延迟初始化 PaddleOCR 失败: {e},回退 EasyOCR") try: if _build_easyocr is None: raise ImportError("ocr_operations._build_easyocr 不可用") self.ocr = _build_easyocr() self.ocr_type = "easyocr" _uo_log("[OCR] 延迟初始化:使用 EasyOCR(CPU模式,回退)") except Exception as e: _uo_log(f"[OCR] 延迟初始化失败: {e}") self.ocr = None self.ocr_type = None def select_device(self): return _impl_select_device() def _find_pic_path(self, picname: str, for_reading: bool = True): return _impl_find_pic_path(picname, for_reading) def get_screenshot(self, device_id, path="pic", use_service: bool = False): """截图(支持后台服务模式) 参数: device_id: 设备ID path: 路径(默认"pic") use_service: 是否使用后台截图服务(默认False,强制使用直接截图) 返回: 是否成功获取截图 """ start_ts = time_module.time() # Diagnostic: record pre-call info including caller stack (top frames) try: import inspect, json, threading frames = [] for fr in inspect.stack()[1:9]: frame_info = { "file": os.path.relpath(fr.filename, os.path.dirname(__file__)), "line": fr.lineno, "function": fr.function, } frames.append(frame_info) pre_record = { "ts": datetime.now().isoformat(), "device_id": device_id, "use_service": bool(use_service), "path": path, "phase": "start", "thread": threading.get_ident(), "stack": frames, } # cache in memory try: if hasattr(self, "_screenshot_call_cache"): try: self._screenshot_call_cache.append(pre_record) except Exception: pass except Exception: pass # append JSON line to log file try: log_dir = os.path.join(os.path.dirname(__file__), "logs") os.makedirs(log_dir, exist_ok=True) with open(self._screenshot_log_path, "a", encoding="utf-8") as _lf: _lf.write(json.dumps(pre_record, ensure_ascii=False) + "\n") except Exception: pass except Exception: pass service_success = False # 如果启用服务模式,使用后台截图服务;若服务不可用或返回 False,则回退到直接截图 if use_service: try: from operations.screenshot_service import ScreenshotService service = ScreenshotService.get_instance() # 诊断:检查服务是否在运行 service_running = getattr(service, "_running", False) if not service_running: logging.debug( "[截图] 后台服务未运行,尝试启动 device=%s", device_id ) try: service.start(device_id, interval=1.5) # 等待一小段时间让服务完成第一次截图 time_module.sleep(0.2) except Exception as start_err: logging.warning( "[截图] 启动后台服务失败: %s,将使用直接截图", start_err ) try: if service.get_screenshot(device_id, force=False): dur = (time_module.time() - start_ts) * 1000.0 logging.info( "[截图] 使用后台服务耗时(ms)=%.1f device=%s", dur, device_id ) # 写结束记录 try: import json, threading end_record = { "ts": datetime.now().isoformat(), "device_id": device_id, "use_service": True, "path": path, "phase": "end", "result": True, "duration_ms": dur, "thread": threading.get_ident(), } try: if hasattr(self, "_screenshot_call_cache"): self._screenshot_call_cache.append(end_record) except Exception: pass try: with open( self._screenshot_log_path, "a", encoding="utf-8" ) as _lf: _lf.write( json.dumps(end_record, ensure_ascii=False) + "\n" ) except Exception: pass except Exception: pass # do not return here; let final return at function end service_success = True else: timetag = datetime.now().strftime("%H:%M:%S") logging.info( "[%s] [截图操作] 后台服务未提供有效截图,回退到直接截图", timetag, ) # 不 return,这里继续走直接截图逻辑 except Exception as e: timetag = datetime.now().strftime("%H:%M:%S") logging.warning( "[%s] [截图操作] 调用后台服务异常,回退到直接截图: %s", timetag, e, ) service_success = False except ImportError as e: timetag = datetime.now().strftime("%H:%M:%S") logging.warning( "[%s] [截图操作] 无法导入截图服务模块,回退到直接截图: %s", timetag, e, ) service_success = False except Exception as e: timetag = datetime.now().strftime("%H:%M:%S") logging.warning( "[%s] [截图操作] 服务模式不可用,回退到直接截图: %s", timetag, e ) service_success = False # 原有的直接截图逻辑(保持向后兼容),测量其耗时 try: # If result already set by service branch, skip direct call if service_success: final_result = True else: final_result = self._get_screenshot_direct(device_id, path) except Exception: final_result = False dur = (time_module.time() - start_ts) * 1000.0 logging.info( "[截图] 总耗时(ms)=%.1f use_service=%s result=%s", dur, bool(use_service), final_result, ) # 写结束记录(包含持续时长与结果) try: import json, threading end_record = { "ts": datetime.now().isoformat(), "device_id": device_id, "use_service": bool(use_service), "path": path, "phase": "end", "result": bool(final_result), "duration_ms": dur, "thread": threading.get_ident(), } try: if hasattr(self, "_screenshot_call_cache"): self._screenshot_call_cache.append(end_record) except Exception: pass try: with open(self._screenshot_log_path, "a", encoding="utf-8") as _lf: _lf.write(json.dumps(end_record, ensure_ascii=False) + "\n") except Exception: pass except Exception: pass return bool(final_result) def _get_screenshot_direct(self, device_id, path="pic"): """直接截图(不使用服务模式)。 实现已抽到 underlying_operations_pkg.screenshot_direct.capture_screenshot_direct。 """ from douyin.core.underlying_operations_pkg.screenshot_direct import ( capture_screenshot_direct, ) return capture_screenshot_direct(self, device_id, path) def get_current_hour(self): """获取当前的时间小时数""" time_hour = datetime.now().strftime("%H") _uo_log("当前时间{}点".format(time_hour)) return int(time_hour) def click_confirm(self, device_id): """点击确认键""" subprocess.run( self._adb_args(device_id, "shell", "input", "keyevent", "66"), stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, check=False, ) _uo_log("点击确认键") def click_back(self, device_id): """点击返回键""" subprocess.run( self._adb_args(device_id, "shell", "input", "keyevent", "4"), stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, check=False, ) _uo_log("点击返回键") # 电量检测方法已删除 def get_device_resolution(self, device_id): """获取设备分辨率""" resolution_info = subprocess.run( self._adb_args(device_id, "shell", "wm", "size"), stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, text=True, encoding="utf-8", errors="replace", check=False, ) resolution_info_string = resolution_info.stdout or "" match = re.search(r"Physical size: (\d+)x(\d+)", resolution_info_string) if match: width = int(match.group(1)) height = int(match.group(2)) _uo_log("设备分辨率为:{}*{}".format(width, height)) return width, height else: raise ValueError("Could not find resolution in adb output") def save_reward_pic(self, device_id): return _impl_save_reward_pic(device_id) def cut_pic(self, left_up=(0, 63), right_down=(1080, 1620), target="", name=""): """裁剪图片,获取需要的区域小图片方便识别。""" from douyin.core.underlying_operations_pkg.image_ops import ( cut_pic as _impl, ) return _impl(self, left_up, right_down, target, name) def analyse_pic_word( self, picname, change_color=0, pic_path=None, return_confidence=False ): """对指定图片运行 OCR 并返回拼接后的文本结果。 参数: picname: 用于分类和调试的图片名(如"福袋内容") change_color: 颜色处理模式,0=保留彩色(推荐),1/2=二值化等 pic_path: 可选的图片路径,未提供时通过 `_find_pic_path` 查找 return_confidence: 是否返回置信度信息(默认False,保持向后兼容) """ from douyin.core.underlying_operations_pkg.ocr_pipeline import ( analyse_pic_word as _impl, ) return _impl(self, picname, change_color, pic_path, return_confidence) def analyse_pic_digits(self, picname, change_color=1, pic_path=None): return _impl_analyse_pic_digits(self, picname, change_color, pic_path) def extract_ocr_content(self, content=None, return_confidence: bool = False): return _impl_extract_ocr_content(content, return_confidence) def delay(self, seconds: float = 1): time_module.sleep(seconds) def random_delay(self, min_seconds=1, max_seconds=100): """等待随机的时长""" random_wait_seconds = random.randint(min_seconds, max_seconds) _uo_log("随机等待{}秒.".format(random_wait_seconds)) self.delay(random_wait_seconds) def check_countdown(self, last_time: str = "") -> tuple: return _impl_check_countdown(last_time) def swipe( self, device_id, left_up_x=0, left_up_y=0, right_down_x=1080, right_down_y=1500, steps=300, ): """划动屏幕 参数说明: - left_up_x, left_up_y: 滑动起始位置(手指按下位置) - right_down_x, right_down_y: 滑动结束位置(手指抬起位置) - steps: 滑动持续时间(毫秒),数值越大滑动越慢,默认300ms(已优化,比之前的200ms更快) 执行命令:adb shell input swipe """ # 注意:adb input swipe 的参数顺序是:start_x start_y end_x end_y duration_ms # 这里 left_up_x/y 是起始位置,right_down_x/y 是结束位置 cmd = self._adb_args( device_id, "shell", "input", "swipe", int(left_up_x), int(left_up_y), int(right_down_x), int(right_down_y), int(steps), ) try: # 使用 subprocess 执行命令,捕获错误输出 result = subprocess.run( cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=5.0, text=True, encoding="utf-8", errors="replace", check=False, ) # 检查是否有权限错误 stderr_text = result.stderr if result.stderr else "" has_permission_error = result.returncode != 0 and ( "SecurityException" in stderr_text or "INJECT_EVENTS" in stderr_text or "Injecting to another application" in stderr_text ) if has_permission_error: # 尝试使用 uiautomator(如果可用,某些设备可能支持) try: self._swipe_with_uiautomator( device_id, left_up_x, left_up_y, right_down_x, right_down_y ) return except Exception: pass # 记录错误但不抛出异常,避免中断主流程 error_msg = stderr_text.strip() if stderr_text else "权限不足" _uo_log(f"[警告] 滑动操作失败: {error_msg}") _uo_log("[提示] 设备不允许 ADB 输入注入,可能的解决方案:") _uo_log( " 1. 在设备开发者选项中启用'USB调试(安全设置)'或'允许模拟点击'" ) _uo_log(" 2. 使用已 root 的设备") _uo_log(" 3. 某些设备需要在设置中手动授权 ADB 输入权限") # 不抛出异常,让程序继续运行(可能只是滑动失败,其他功能仍可用) except subprocess.TimeoutExpired: _uo_log("[警告] 滑动操作超时") except Exception as e: # 降级重试一次,保持旧逻辑的宽容行为。 try: subprocess.run( cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, check=False, ) except Exception: _uo_log(f"[警告] 滑动操作失败: {type(e).__name__}: {e}") def _swipe_with_sendevent(self, device_id, x1, y1, x2, y2, steps): """使用 sendevent 方法滑动(需要 root 权限)""" # 获取触摸设备路径 result = subprocess.run( self._adb_args(device_id, "shell", "getevent", "-p"), stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, text=True, encoding="utf-8", errors="replace", check=False, ) if "ABS_MT" not in result.stdout or "event" not in result.stdout.lower(): raise FileNotFoundError("无法找到触摸设备") # 简化实现:直接使用 input 命令的替代参数 # 注意:sendevent 需要 root 权限,这里只是尝试 raise PermissionError("sendevent 需要 root 权限,暂不支持") def _swipe_with_uiautomator(self, device_id, x1, y1, x2, y2): """使用 uiautomator 滑动(如果可用) 注意:uiautomator 在某些设备上可能也需要权限,但可以尝试作为备选方案。 """ # 使用 uiautomator swipe 命令 # 注意:uiautomator 命令格式可能因 Android 版本而异 # Android 5.0+: uiautomator swipe [steps] result = subprocess.run( self._adb_args( device_id, "shell", "uiautomator", "swipe", int(x1), int(y1), int(x2), int(y2) ), stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=5.0, check=False, ) if result.returncode != 0: raise RuntimeError( f"uiautomator swipe 失败: {result.stderr.decode('utf-8', errors='ignore')}" ) def _swipe_with_sendevent_improved(self, device_id, x1, y1, x2, y2, steps=50): return _impl_swipe_sendevent_improved(device_id, x1, y1, x2, y2, steps) def click(self, device_id, x=500, y=500, log: bool = True): """点击坐标位置 参数: device_id: 设备ID x, y: 屏幕坐标 log: 是否打印底层日志(默认为 True)。在需要安静点击的场景(如养号)传 False。 """ try: if log: _uo_log(f"[Underlying] click: device_id={device_id} coord=({x},{y})") except Exception: pass subprocess.run( self._adb_args(device_id, "shell", "input", "tap", int(x), int(y)), stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, check=False, ) def long_press( self, device_id: str, x: int, y: int, duration_ms: int = 900 ) -> None: """长按某个坐标(通过 swipe x y x y duration 模拟)。""" d = int(duration_ms or 900) if d < 300: d = 300 if d > 2000: d = 2000 subprocess.run( self._adb_args( device_id, "shell", "input", "swipe", int(x), int(y), int(x), int(y), d ), stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, check=False, ) def _run_adb_shell( self, device_id: str, shell_cmd: str, timeout_seconds: float = 3.0 ) -> bool: """运行 adb shell 命令,成功返回 True。""" try: r = subprocess.run( self._adb_args(device_id, "shell", *self._split_shell_cmd(shell_cmd)), stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, timeout=timeout_seconds, check=False, ) return r.returncode == 0 except Exception: return False def _run_adb_shell_capture( self, device_id: str, shell_cmd: str, timeout_seconds: float = 3.0 ) -> Tuple[bool, str]: """运行 adb shell 命令并捕获输出,返回 (ok, stdout)。""" try: r = subprocess.run( self._adb_args(device_id, "shell", *self._split_shell_cmd(shell_cmd)), stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, timeout=timeout_seconds, text=True, encoding="utf-8", errors="ignore", check=False, ) return (r.returncode == 0), (r.stdout or "") except Exception: return False, "" def get_top_package(self, device_id: str) -> str: """尝试返回当前处于前台的包名(如 com.ss.android.ugc.aweme)。 失败返回空字符串。实现采用 dumpsys 输出的多种字段进行解析,兼容不同 Android 版本。 """ try: ok, out = self._run_adb_shell_capture( device_id, "dumpsys window windows", timeout_seconds=4.0 ) if ok and out: for ln in (out or "").splitlines(): if ( "mCurrentFocus" in ln or "mFocusedApp" in ln or "mFocusedWindow" in ln ): m = re.search(r"([A-Za-z0-9_\.]+)\/", ln) if m: return m.group(1) # 兜底尝试:activity 栈里的 resumed activity ok2, out2 = self._run_adb_shell_capture( device_id, "dumpsys activity activities", timeout_seconds=4.0 ) if ok2 and out2: for ln in (out2 or "").splitlines(): if "mResumedActivity" in ln or "ResumedActivity" in ln: m = re.search(r"([A-Za-z0-9_\.]+)\/", ln) if m: return m.group(1) except Exception: pass return "" # 抖音常见包名(从主到 lite/极速版/海外版),launch_package 默认按此顺序尝试 DOUYIN_PACKAGES = ( "com.ss.android.ugc.aweme", # 抖音正式版 "com.ss.android.ugc.aweme.lite", # 抖音极速版 "com.zhiliaoapp.musically", # TikTok(兼容) ) def launch_package( self, device_id: str, package_name: str = "", timeout_seconds: float = 5.0, ) -> Tuple[bool, str]: """通过包名启动应用。 策略:先用 `monkey -p -c android.intent.category.LAUNCHER 1` 启动主 launcher activity, 失败时回退到 `am start -n /.`(按抖音常用 activity 列表尝试)。 参数: device_id: ADB 设备 ID package_name: 要启动的包名;留空则按 DOUYIN_PACKAGES 顺序尝试 timeout_seconds: 单次 adb shell 命令超时 返回: (success, used_package) — used_package 为实际成功启动的包名(失败返回 "") """ candidates = ( [package_name] if package_name else list(self.DOUYIN_PACKAGES) ) for pkg in candidates: pkg = (pkg or "").strip() if not pkg: continue # 1) monkey 主入口 cmd = f"monkey -p {pkg} -c android.intent.category.LAUNCHER 1" ok, out = self._run_adb_shell_capture( device_id, cmd, timeout_seconds=timeout_seconds ) # monkey 失败时输出会包含 "No activities found" 或 "monkey aborted" if ok and "No activities found" not in (out or "") and "aborted" not in ( out or "" ).lower(): return True, pkg # 2) am start 主入口兜底 for activity in ( ".main.MainActivity", ".splash.SplashActivity", ".main.homepage.MainActivity", ): am_cmd = f"am start -n {pkg}/{activity}" if self._run_adb_shell( device_id, am_cmd, timeout_seconds=timeout_seconds ): return True, pkg return False, "" def is_douyin_foreground(self, device_id: str) -> bool: """便捷判断:当前前台是否是抖音相关包。""" top_pkg = self.get_top_package(device_id) or "" return bool(top_pkg) and ( "aweme" in top_pkg or "douyin" in top_pkg or "com.ss.android.ugc" in top_pkg ) def set_clipboard_text(self, device_id: str, text: str) -> bool: return _impl_set_clipboard_text(device_id, text) def paste_from_clipboard(self, device_id: str) -> bool: """尝试触发“粘贴”操作(需要输入框已获得焦点)。""" # KEYCODE_PASTE=279(部分机型/系统可能不支持,但无副作用) return self._run_adb_shell(device_id, "input keyevent 279", timeout_seconds=2.0) def input_text(self, device_id: str, text: str) -> bool: """使用 adb input text 输入(对中文可能不稳定,仅兜底)。""" t = str(text or "") if not t: return False # 空格用 %s,避免被 shell 分词 t = t.replace(" ", "%s") # 完整转义所有 shell 特殊字符 for ch in ['&', '<', '>', '|', ';', '$', '`', "'", '"', '\\', '(', ')', '{', '}', '[', ']', '!', '#', '*', '?']: t = t.replace(ch, '\\' + ch) try: return ( subprocess.run( self._adb_args(device_id, "shell", "input", "text", t), stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, timeout=5.0, check=False, ).returncode == 0 ) except Exception: return False def paste_text(self, device_id: str, text: str) -> bool: """优先走剪贴板粘贴,其次兜底 input text。""" if self.set_clipboard_text(device_id, text): self.paste_from_clipboard(device_id) return True return self.input_text(device_id, text) # ===== ADBKeyboard (可选) ===== def get_current_ime(self, device_id: str) -> str: ok, out = self._run_adb_shell_capture( device_id, "settings get secure default_input_method", timeout_seconds=2.0 ) if not ok: return "" return (out or "").strip() def list_imes(self, device_id: str) -> list[str]: # 部分 ROM 会限制 `ime` shell 命令(报 WRITE_SECURE_SETTINGS),这里优先用 settings 查询。 ok, out = self._run_adb_shell_capture( device_id, "settings get secure enabled_input_methods", timeout_seconds=2.5 ) if ok and out: raw = (out or "").strip() # 形如:a/.A:b/.B:c/.C parts = [p.strip() for p in raw.split(":") if p.strip()] if parts: return parts ok2, out2 = self._run_adb_shell_capture( device_id, "ime list -s", timeout_seconds=2.5 ) if not ok2: # 最后兜底:至少把当前默认输入法返回,避免上层无法判断 cur = self.get_current_ime(device_id) return [cur] if cur else [] lines = [ln.strip() for ln in (out2 or "").splitlines() if ln.strip()] return lines @staticmethod # type: ignore[misc] def _pick_adbkeyboard_ime(imes: list[str]) -> str: return _impl_pick_adbkeyboard_ime(imes) def ensure_adbkeyboard_ime( self, device_id: str, preferred_ime: str = "com.android.adbkeyboard/.AdbIME" ) -> Tuple[bool, str, str]: """确保 ADBKeyboard 输入法处于激活状态。 返回 (ok, prev_ime, adb_ime)。ok=False 表示设备未安装/未启用 ADBKeyboard。 """ prev = self.get_current_ime(device_id) # 如果当前已经是 ADBKeyboard,就不用再尝试切换(很多 ROM 禁止 ime set) if "adbkeyboard" in str(prev).lower() or "adbime" in str(prev).lower(): return True, prev, prev imes = self.list_imes(device_id) adb_ime = "" pref = str(preferred_ime or "").strip() if pref and pref in imes: adb_ime = pref else: adb_ime = self._pick_adbkeyboard_ime(imes) if not adb_ime: return False, prev, "" if prev != adb_ime: if not self.try_set_ime(device_id, adb_ime): return False, prev, adb_ime return True, prev, adb_ime def restore_ime(self, device_id: str, prev_ime: str) -> bool: ime = str(prev_ime or "").strip() if not ime: return False return self.try_set_ime(device_id, ime) def try_set_ime(self, device_id: str, ime_id: str) -> bool: ime = str(ime_id or "").strip() if not ime: return False # 1) 优先走 ime(某些 ROM 会失败) self._run_adb_shell(device_id, f"ime enable {shlex.quote(ime)}", timeout_seconds=2.5) if self._run_adb_shell(device_id, f"ime set {shlex.quote(ime)}", timeout_seconds=2.5): return True # 2) 退化:尝试 settings put(通常也会被 ROM 限制,但试一下无害) if self._run_adb_shell( device_id, f"settings put secure default_input_method {shlex.quote(ime)}", timeout_seconds=2.5, ): cur = self.get_current_ime(device_id) return cur == ime return False def _adbkeyboard_broadcast(self, device_id: str, action: str, msg: str) -> bool: act = str(action or "").strip() if not act: return False # 使用 shlex.quote 转义消息,防止 shell 注入 safe_msg = shlex.quote(str(msg or "")) try: return ( subprocess.run( self._adb_args( device_id, "shell", "am", "broadcast", "-a", act, "--es", "msg", safe_msg ), stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, timeout=3.0, check=False, ).returncode == 0 ) except Exception: return False def _adbkeyboard_broadcast_int( self, device_id: str, action: str, key: str, value: int ) -> bool: act = str(action or "").strip() k = str(key or "").strip() if not act or not k: return False try: v = int(value) except Exception: return False # 使用 shlex.quote 转义 key,防止 shell 注入 safe_k = shlex.quote(k) try: return ( subprocess.run( self._adb_args( device_id, "shell", "am", "broadcast", "-a", act, "--ei", safe_k, v ), stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, timeout=3.0, check=False, ).returncode == 0 ) except Exception: return False def keyevent(self, device_id: str, keycode: int) -> bool: try: code = int(keycode) except Exception: return False return self._run_adb_shell( device_id, f"input keyevent {code}", timeout_seconds=2.0 ) def adbkeyboard_editor_action(self, device_id: str, action_code: int = 4) -> bool: """使用 ADBKeyBoard 触发 editor action。 常用:IME_ACTION_SEND=4, IME_ACTION_DONE=6。 仅当当前输入法是 ADBKeyBoard 时更可靠。 """ return self._adbkeyboard_broadcast_int( device_id, "ADB_EDITOR_CODE", "code", int(action_code) ) def confirm_from_keyboard(self, device_id: str) -> bool: """在输入框中用“键盘确认/发送”提交。 优先:ADBKeyBoard editor action SEND(4) 兜底:KEYCODE_ENTER(66) """ cur = "" try: cur = self.get_current_ime(device_id) except Exception: cur = "" if "adbkeyboard" in str(cur).lower() or "adbime" in str(cur).lower(): if self.adbkeyboard_editor_action(device_id, 4): return True return self.keyevent(device_id, 66) def input_text_adbkeyboard( self, device_id: str, text: str, ime_id: str = "com.android.adbkeyboard/.AdbIME", restore_prev: bool = True, ) -> bool: """使用 ADBKeyboard 输入文本(更适合中文)。 要求:手机已安装并启用 ADBKeyboard。若不可用返回 False。 """ t = str(text or "") if not t: return False ok, prev, adb_ime = self.ensure_adbkeyboard_ime(device_id, preferred_ime=ime_id) if not ok: return False success = False try: # 优先 b64(兼容中文/特殊字符),其次纯文本 b64 = base64.b64encode(t.encode("utf-8")).decode("ascii") if self._adbkeyboard_broadcast(device_id, "ADB_INPUT_B64", b64): success = True elif self._adbkeyboard_broadcast(device_id, "ADB_INPUT_TEXT", t): success = True # 给 IME 一点时间把文本真正“打进”输入框 time_module.sleep(0.35) return success finally: # 尝试恢复原输入法,避免影响手动使用 if restore_prev and prev and prev != adb_ime: # 再稍等一下,避免过早切回导致输入丢失 time_module.sleep(0.25) self.restore_ime(device_id, prev) def paste_text_at( self, device_id: str, x: int, y: int, text: str, ensure_focus: bool = True ) -> bool: """最简单的“粘贴到输入框”方法。 流程:点击输入框获取焦点 -> 设置剪贴板 -> 发送 KEYCODE_PASTE(279)。 若剪贴板不可用则退化为 `adb shell input text`(中文可能不稳定)。 """ t = str(text or "").strip() if not t: return False # 先确保输入框获得焦点 try: if ensure_focus: try: _uo_log( f"[Underlying] paste_text_at: clicking to focus device_id={device_id} coord=({x},{y})" ) except Exception: pass self.click(device_id, int(x), int(y)) time_module.sleep(0.2) # 有些输入框第一次点不进,补一次轻点 try: _uo_log( f"[Underlying] paste_text_at: clicking again to ensure focus device_id={device_id} coord=({x},{y})" ) except Exception: pass self.click(device_id, int(x), int(y)) time_module.sleep(0.15) except Exception: pass # 0) 优先:ADBKeyboard(如果已安装/可用) # 说明:这一步不依赖剪贴板/粘贴菜单,通常对中文更稳定 try: ok_adbkb = False try: ok_adbkb = bool( self.input_text_adbkeyboard(device_id, t, restore_prev=False) ) except Exception: ok_adbkb = False try: _uo_log( f"[Underlying] paste_text_at: input_text_adbkeyboard -> {ok_adbkb}" ) except Exception: pass if ok_adbkb: return True except Exception: pass # 1) 优先:剪贴板 + 粘贴键 ok_clip = False try: ok_clip = bool(self.set_clipboard_text(device_id, t)) except Exception: ok_clip = False try: _uo_log(f"[Underlying] paste_text_at: set_clipboard_text -> {ok_clip}") except Exception: pass if ok_clip: # 给系统一点时间刷新剪贴板 time_module.sleep(0.15) ok_paste = False try: ok_paste = bool(self.paste_from_clipboard(device_id)) except Exception: ok_paste = False try: _uo_log(f"[Underlying] paste_text_at: paste_from_clipboard -> {ok_paste}") except Exception: pass if ok_paste: return True # 2) 兜底:adb input text(中文可能不稳定) try: _uo_log( f"[Underlying] paste_text_at: falling back to input_text for device_id={device_id}" ) except Exception: pass return self.input_text(device_id, t) def _uiautomator_dump(self, device_id: str, local_path: str) -> bool: """拉取当前界面 UI 树到本地 xml(失败返回 False)。""" try: remote = "/sdcard/window_dump.xml" subprocess.run( self._adb_args(device_id, "shell", "uiautomator", "dump", remote), stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, timeout=2, check=False, ) subprocess.run( [self._adb_path(), "-s", str(device_id), "pull", remote, str(local_path)], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, timeout=2, check=False, ) return os.path.exists(local_path) except subprocess.TimeoutExpired: return False except Exception: return False @staticmethod def _parse_bounds(bounds: str): return _impl_parse_bounds(bounds) def tap_by_text( self, device_id: str, text: str, contains: bool = True, timeout_seconds: float = 2.0, ) -> bool: """通过 uiautomator dump 按 text/content-desc 点击(命中即点并返回 True)。 适用于:\"推荐\"、\"直播\"、\"点击进入直播间\" 等。 """ if not text: return False try: from douyin.core import path_config local_path = path_config.get_window_dump_path() except Exception: from douyin.core import path_config local_path = path_config.get_window_dump_path() start = time_module.time() while True: if self._uiautomator_dump(device_id, local_path): try: tree = ET.parse(local_path) root = tree.getroot() except Exception: root = None if root is not None: target = str(text) for node in root.iter(): t = node.attrib.get("text", "") d = node.attrib.get("content-desc", "") hit = False if contains: if (target in t) or (target in d): hit = True else: if (target == t) or (target == d): hit = True if not hit: continue b = node.attrib.get("bounds", "") parsed = self._parse_bounds(b) if not parsed: continue x1, y1, x2, y2 = parsed cx = int((x1 + x2) / 2) cy = int((y1 + y2) / 2) self.click(device_id, cx, cy) return True if time_module.time() - start >= timeout_seconds: return False time_module.sleep(0.2) def tap_close_icon( self, device_id: str, screen_width: int = 1080, timeout_seconds: float = 2.0 ) -> bool: """尝试点击直播间顶部的关闭(X)按钮。 逻辑:从 uiautomator dump 里找顶部(较小 y)的可点击小图标,优先命中 content-desc/text 含“关闭/退出/返回”。 如果没有文字,就在顶部区域按“最像关闭”的位置进行启发式选择。 """ try: from douyin.core import path_config local_path = path_config.get_window_dump_path() except Exception: from douyin.core import path_config local_path = path_config.get_window_dump_path() start = time_module.time() def _score(node_attrib: dict, bounds_tuple) -> int: x1, y1, x2, y2 = bounds_tuple w = x2 - x1 h = y2 - y1 if y2 > 420: return -9999 if w < 50 or h < 50 or w > 260 or h > 260: return -9999 t = (node_attrib.get("text", "") or "").strip() d = (node_attrib.get("content-desc", "") or "").strip() s = t + " " + d score = 0 # 明确关闭/退出优先 for kw in ("关闭", "退出", "返回", "close", "Close"): if kw in s: score += 200 # 排除一些常见非关闭按钮 for bad in ("分享", "更多", "菜单", "礼物", "榜", "关注", "评论"): if bad in s: score -= 120 # 顶部更靠上更像 score += max(0, 120 - y1) # 更接近正方形的小图标更像 score -= abs(w - h) # 默认更偏右上角(如果你的关闭在左边,也能被“更靠上/更像图标”拉回来) cx = (x1 + x2) / 2 if screen_width > 0: score += int((cx / screen_width) * 40) return score while True: if self._uiautomator_dump(device_id, local_path): try: root = ET.parse(local_path).getroot() except Exception: root = None best = None best_score = -999999 if root is not None: for node in root.iter(): attrib = getattr(node, "attrib", {}) or {} # clickable 属性可能是 'true'/'false' if str(attrib.get("clickable", "")).lower() != "true": continue if str(attrib.get("enabled", "true")).lower() == "false": continue b = attrib.get("bounds", "") parsed = self._parse_bounds(b) if not parsed: continue sc = _score(attrib, parsed) if sc > best_score: best_score = sc best = parsed if best and best_score > -1000: x1, y1, x2, y2 = best cx = int((x1 + x2) / 2) cy = int((y1 + y2) / 2) self.click(device_id, cx, cy) return True if time_module.time() - start >= timeout_seconds: return False time_module.sleep(0.2)