Files
douyin_guaji-main/Underlying_Operations.py
T
Your Name efe6e2252f feat: Add logging and error handling enhancements
- Introduced new logging modules for action tracking, error logging, and performance tracking to improve observability.
- Added functions for retrieving debug and error log paths in `path_config.py`.
- Updated various components to utilize the new logging system, enhancing error handling and performance diagnostics.
- Implemented a GUI component for viewing error logs, improving user experience in monitoring application issues.
- Cleaned up unnecessary blank lines and improved code readability across multiple files.
2025-12-29 20:48:09 +08:00

2718 lines
107 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
import subprocess
from datetime import datetime, timedelta
import os
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
from PIL import Image, ImageFilter
from PIL import UnidentifiedImageError
import numpy as np
import logging
import re
import random
import xml.etree.ElementTree as ET
import shlex
import contextlib
import base64
from typing import Tuple, Optional, Any
import time as time_module
# Pillow 版本兼容:使用 Image.Resampling 或回退到 Image 常量
try:
_RESAMPLE = Image.Resampling
except Exception:
_RESAMPLE = Image
# 外部完整版 fudai 逻辑所在的工作树路径,用于镜像 screenshot 给那边使用
# 使用环境变量或默认路径,避免硬编码用户路径
_EXTERNAL_AXF_SCREENSHOT = os.path.join(
os.environ.get(
"EXTERNAL_DOUYIN_FUDAI_DIR",
os.path.join(
os.path.expanduser("~"),
".cursor",
"worktrees",
"douyin_guaji-main",
"axf"
)
),
"pic",
"screenshot.png"
)
def _safe_replace_file(tmp_file: str, out_file: str, max_retries: int = 5) -> bool:
"""安全地替换文件,处理Windows文件锁定问题。
使用多种策略和重试机制来处理文件被占用的情况:
1. 直接使用 os.replace (原子操作)
2. 先删除目标文件再重命名
3. 重命名旧文件为备份,再重命名新文件
4. 使用 shutil.move
5. 直接复制文件内容
Args:
tmp_file: 临时文件路径
out_file: 目标文件路径
max_retries: 最大重试次数
Returns:
True if successful, False otherwise
"""
import shutil
if not os.path.exists(tmp_file):
return False
for attempt in range(max_retries):
try:
# 方法1: 直接使用 os.replace (原子操作,最可靠)
os.replace(tmp_file, out_file)
return True
except (OSError, PermissionError) as e:
# 在Windows上,文件锁定错误通常是 OSError 或 PermissionError
if attempt < max_retries - 1:
# 等待时间逐渐增加,让文件句柄有时间释放
wait_time = (
0.05 * (attempt + 1) * (attempt + 1)
) # 0.05, 0.2, 0.45, 0.8, 1.25秒
time_module.sleep(wait_time)
try:
# 方法2: 先尝试删除目标文件,再重命名
if os.path.exists(out_file):
try:
os.remove(out_file)
except (OSError, PermissionError):
# 如果删除失败,尝试重命名旧文件为备份
try:
old_backup = out_file + ".old"
if os.path.exists(old_backup):
try:
os.remove(old_backup)
except Exception:
pass
os.rename(out_file, old_backup)
except Exception:
pass
# 现在尝试重命名临时文件
os.rename(tmp_file, out_file)
return True
except (OSError, PermissionError):
# 方法3: 使用 shutil.move
try:
if os.path.exists(out_file):
try:
os.remove(out_file)
except (OSError, PermissionError):
try:
old_backup = out_file + ".old"
if os.path.exists(old_backup):
os.remove(old_backup)
os.rename(out_file, old_backup)
except Exception:
pass
shutil.move(tmp_file, out_file)
return True
except Exception:
# 方法4: 直接复制文件内容(最后的手段)
if attempt == max_retries - 2: # 倒数第二次尝试
try:
with open(tmp_file, "rb") as src, open(
out_file, "wb"
) as dst:
# 分块读取,避免大文件占用内存
while True:
chunk = src.read(8192)
if not chunk:
break
dst.write(chunk)
# 复制成功后删除临时文件
try:
os.remove(tmp_file)
except Exception:
pass
return True
except Exception:
pass
continue
else:
# 最后一次尝试:直接复制内容
try:
with open(tmp_file, "rb") as src, open(out_file, "wb") as dst:
while True:
chunk = src.read(8192)
if not chunk:
break
dst.write(chunk)
# 复制成功后尝试删除临时文件
try:
os.remove(tmp_file)
except Exception:
pass
return True
except Exception:
return False
except Exception as e:
# 其他未知异常,记录但不中断
if attempt == max_retries - 1:
return False
time_module.sleep(0.1 * (attempt + 1))
continue
return False
def _ensure_parent_dir(path: str) -> None:
"""Ensure the parent directory for `path` exists."""
try:
parent = os.path.dirname(path)
if parent:
os.makedirs(parent, exist_ok=True)
except Exception:
# 不应因目录创建失败阻塞主流程,记录以便排查
logging.exception("无法创建父目录: %s", path)
def _mirror_screenshot_to_external(src_file: str) -> None:
"""将当前项目下的 screenshot.png 同步一份到外部 axf 目录,便于完整版代码复用。
若外部目录/路径不存在或复制失败,会静默忽略,不影响主流程。
"""
try:
external_path = _EXTERNAL_AXF_SCREENSHOT
if not external_path:
return
external_dir = os.path.dirname(external_path)
if not external_dir:
return
os.makedirs(external_dir, exist_ok=True)
if not os.path.exists(src_file):
return
tmp = external_path + ".tmp"
import shutil
shutil.copyfile(src_file, tmp)
_safe_replace_file(tmp, external_path)
except Exception:
# 任何错误都不应该影响截图主流程
pass
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]] = {}
# 默认使用CPU模式(删除GPU检测)
self._gpu_available = False
if not str(os.environ.get("SKIP_OCR_INIT", "")).strip():
# 优先使用EasyOCR(更快),如果失败则回退到PaddleOCR
# 首先尝试EasyOCR
devnull = None
try:
# 在Windows上,避免使用stderr重定向,可能会导致"lost sys.stderr"问题
# 改为直接静默导入和初始化
import easyocr # type: ignore[import-untyped] # pyright: ignore[reportMissingImports]
# 只加载中文和英文,加快初始化速度
# 自动检测GPU可用性,如果可用则启用GPU加速
# 临时重定向输出以减少初始化时的噪音
import io
from contextlib import redirect_stdout, redirect_stderr
fake_stdout = io.StringIO()
fake_stderr = io.StringIO()
with redirect_stdout(fake_stdout), redirect_stderr(fake_stderr):
self.ocr = easyocr.Reader(
["ch_sim", "en"], gpu=False, verbose=False
)
self.ocr_type = "easyocr"
gpu_status = "CPU模式"
print(f"[OCR] 使用 EasyOCR({gpu_status})")
except Exception as e:
# EasyOCR初始化失败,回退到PaddleOCR
print(f"[OCR] EasyOCR初始化失败: {e},回退到PaddleOCR")
try:
if devnull is not None:
try:
devnull.close()
except Exception:
pass
except Exception:
pass
try:
devnull = open(os.devnull, "w")
with contextlib.redirect_stdout(
devnull
), contextlib.redirect_stderr(devnull):
from paddleocr import PaddleOCR
# PaddleOCR的GPU支持需要paddlepaddle-gpu版本
use_gpu = False
try:
import paddle
if (
paddle.device.is_compiled_with_cuda()
and paddle.device.get_device()
):
use_gpu = False
except Exception:
pass
self.ocr = PaddleOCR(
lang="ch",
ocr_version="PP-OCRv4",
use_angle_cls=False,
use_gpu=use_gpu,
use_doc_orientation_classify=False,
use_doc_unwarping=False,
use_textline_orientation=False,
)
self.ocr_type = "paddleocr"
gpu_status = "GPU加速" if use_gpu else "CPU模式"
print(f"[OCR] EasyOCR不可用,使用 PaddleOCR({gpu_status})")
print(
f"[OCR] 提示:安装EasyOCR可提升速度,运行: pip install easyocr"
)
except Exception:
# 若静默初始化失败,保留 None 并允许后续按需初始化,避免阻塞启动。
try:
if devnull is not None:
try:
devnull.close()
except Exception:
pass
except Exception:
pass
self.ocr = None
self.ocr_type = None
finally:
try:
if devnull is not None:
devnull.close()
except Exception:
pass
logging.disable(logging.DEBUG)
logging.disable(logging.WARNING)
@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:
"""返回可用于 subprocess(list_args) 的 adb 路径(不带外层引号)。"""
adb = str(os.environ.get("ADB_EXECUTABLE", "adb") or "adb")
if adb.startswith('"') and adb.endswith('"'):
adb = adb[1:-1]
return adb
def _ensure_ocr(self):
if self.ocr is not None:
return
# 默认使用CPU模式(延迟初始化时)
# 优先尝试EasyOCR
try:
# 在Windows上,避免使用stderr重定向,可能会导致"lost sys.stderr"问题
import easyocr # type: ignore[import-untyped]
# 临时重定向输出以减少初始化时的噪音
import io
from contextlib import redirect_stdout, redirect_stderr
fake_stdout = io.StringIO()
fake_stderr = io.StringIO()
with redirect_stdout(fake_stdout), redirect_stderr(fake_stderr):
self.ocr = easyocr.Reader(
["ch_sim", "en"], gpu=False, verbose=False
)
self.ocr_type = "easyocr"
gpu_status = "GPU加速" if False else "CPU模式"
print(f"[OCR] 延迟初始化:使用 EasyOCR({gpu_status})")
except Exception as e:
# EasyOCR失败,回退到PaddleOCR
print(f"[OCR] 延迟初始化EasyOCR失败: {e},回退到PaddleOCR")
devnull = None
try:
devnull = open(os.devnull, "w")
with contextlib.redirect_stdout(devnull), contextlib.redirect_stderr(
devnull
):
from paddleocr import PaddleOCR
# PaddleOCR的GPU支持需要paddlepaddle-gpu版本
use_gpu = False
try:
import paddle
if (
paddle.device.is_compiled_with_cuda()
and paddle.device.get_device()
):
use_gpu = False
except Exception:
pass
self.ocr = PaddleOCR(
lang="ch",
ocr_version="PP-OCRv4",
use_angle_cls=False,
use_gpu=use_gpu,
use_doc_orientation_classify=False,
use_doc_unwarping=False,
use_textline_orientation=False,
)
self.ocr_type = "paddleocr"
gpu_status = "GPU加速" if use_gpu else "CPU模式"
print(f"[OCR] 延迟初始化:使用 PaddleOCR({gpu_status})")
except Exception:
self.ocr = None
self.ocr_type = None
finally:
try:
if devnull is not None:
devnull.close()
except Exception:
pass
def select_device(self):
"""选择需要连接的设备"""
string = subprocess.Popen(
f"{self._adb()} devices", shell=True, stdout=subprocess.PIPE
)
assert string.stdout is not None
totalstring = string.stdout.read()
totalstring = totalstring.decode("utf-8")
# print(totalstring)
pattern = r"(\b(?:[0-9]{1,3}(?:\.[0-9]{1,3}){3}(?::[0-9]+)?|[A-Za-z0-9]{8,})\b)\s*device\b"
devicelist = re.findall(pattern, totalstring)
# devicelist = re.compile(r'(\w*)\s*device\b').findall(totalstring)
devicenum = len(devicelist)
if devicenum == 0:
print("当前无设备连接电脑,请检查设备连接情况!")
return False
elif devicenum == 1:
print("当前有一台设备连接,编号:%s." % devicelist[0])
return devicelist[0]
else:
print("当前存在多台设备连接! 输入数字选择对应设备:")
dictdevice = {}
for i in range(devicenum):
string = subprocess.Popen(
"%s -s %s shell getprop ro.product.device"
% (self._adb(), devicelist[i]),
shell=True,
stdout=subprocess.PIPE,
)
assert string.stdout is not None
modestring = string.stdout.read().strip() # 去除掉自动生成的回车
print("%s:%s---%s" % (i + 1, devicelist[i], modestring))
dictdevice[i + 1] = devicelist[i]
num = input()
num = int(num)
while not num in dictdevice.keys():
print("输入不正确,请重新输入:")
num = input()
num = int(num)
return dictdevice[num]
def _find_pic_path(self, picname: str, for_reading: bool = True) -> Optional[str]:
"""查找图片路径,支持新旧位置(向后兼容),并按分类组织
Args:
picname: 图片名称(不含扩展名),如 '直播广场', '福袋内容'
for_reading: True=读取(支持新旧位置),False=写入(使用新位置+分类目录)
Returns:
图片的完整路径,如果找不到且for_reading=True则返回None
"""
try:
import path_config
pic_base = path_config.get_pic_dir()
except Exception:
import path_config
pic_base = path_config.get_pic_dir()
# 运行时必需文件始终在根目录(不需要移动)
runtime_files = {"screenshot", "cut"}
if picname in runtime_files:
path = os.path.join(pic_base, f"{picname}.png")
return path if (os.path.exists(path) or not for_reading) else None
# OCR图片文件:按分类组织到子目录
try:
from douyin.handlers import douyin_screenshot_manager
category = douyin_screenshot_manager.get_category_for_picname(picname)
except Exception:
category = "others"
if for_reading:
# 读取:先查分类目录,再查旧位置(向后兼容)
# 1. 新位置(分类目录)
category_path = os.path.join(pic_base, "ocr", category, f"{picname}.png")
if os.path.exists(category_path):
return category_path
# 2. 旧位置(ocr根目录)
old_ocr_path = os.path.join(pic_base, "ocr", f"{picname}.png")
if os.path.exists(old_ocr_path):
return old_ocr_path
# 3. 更旧的位置(pic根目录)
old_root_path = os.path.join(pic_base, f"{picname}.png")
if os.path.exists(old_root_path):
return old_root_path
return None
else:
# 写入:使用分类目录,确保目录存在
category_dir = os.path.join(pic_base, "ocr", category)
os.makedirs(category_dir, exist_ok=True)
return os.path.join(category_dir, f"{picname}.png")
def get_screenshot(self, device_id, path="pic"):
"""截图3个adb命令需要2S左右的时间"""
if path == "pic":
try:
import path_config
out_dir = path_config.get_pic_dir()
except Exception:
import path_config
out_dir = path_config.get_pic_dir()
else:
out_dir = os.path.join(os.path.dirname(__file__), "target_pic")
if not os.path.exists(out_dir):
os.makedirs(out_dir)
# 统一输出到固定文件名,兼容现有 cut_pic()/后续流程
out_file = os.path.join(out_dir, "screenshot.png")
tmp_file = out_file + ".tmp"
timetag = datetime.now().strftime("%H:%M:%S")
adb = self._adb_path()
def _valid_png(path0: str) -> bool:
try:
if not os.path.exists(path0):
return False
sz = os.path.getsize(path0)
# PNG 通常远大于 1KB;0 字节/极小文件大概率是 adb 输出异常/中断
return sz >= 1024
except Exception:
return False
# 优先走 exec-out:只需 1 次 adb 调用;不在手机端落盘,减少 I/O 与卡顿
# 为避免被并发读取到“半写入文件”,写入 tmp 后再原子替换。
for _ in range(2):
try:
try:
if os.path.exists(tmp_file):
os.remove(tmp_file)
except Exception:
pass
with open(tmp_file, "wb") as f:
subprocess.run(
[adb, "-s", device_id, "exec-out", "screencap", "-p"],
stdout=f,
stderr=subprocess.DEVNULL,
check=True,
timeout=10, # 添加10秒超时,避免无限等待
)
if _valid_png(tmp_file):
# 使用安全的文件替换函数
if _safe_replace_file(tmp_file, out_file):
_mirror_screenshot_to_external(out_file)
print(f"[{timetag}] [截图] ✓ 获取屏幕截图成功")
return True
else:
# 如果替换失败,但临时文件有效,仍然返回成功
# 后续代码可以读取临时文件或重试
print(f"[截图] 文件替换失败,但截图已保存到临时文件,将重试")
# 不立即返回,继续尝试回退方案
except subprocess.TimeoutExpired:
# 超时异常,记录并继续重试
print(f"[截图] exec-out 超时,尝试重试或回退方案")
try:
if os.path.exists(tmp_file):
os.remove(tmp_file)
except Exception:
pass
except Exception as e:
# 继续回退/重试
print(f"[截图] exec-out 异常:{e}")
try:
if os.path.exists(tmp_file):
os.remove(tmp_file)
except Exception:
pass
# 回退方案:老式 shell screencap + pull(兼容极少数不支持 exec-out 的环境)
try:
subprocess.run(
[
adb,
"-s",
device_id,
"shell",
"screencap",
"-p",
"/sdcard/DCIM/screenshot.png",
],
stdout=subprocess.DEVNULL,
stderr=subprocess.DEVNULL,
check=True,
timeout=10, # 添加超时
)
subprocess.run(
[adb, "-s", device_id, "pull", "/sdcard/DCIM/screenshot.png", tmp_file],
stdout=subprocess.DEVNULL,
stderr=subprocess.DEVNULL,
check=True,
timeout=10, # 添加超时
)
if _valid_png(tmp_file):
# 使用安全的文件替换函数
if _safe_replace_file(tmp_file, out_file):
_mirror_screenshot_to_external(out_file)
print("{} 获取屏幕截图".format(timetag))
return True
else:
# 如果替换失败,尝试最后一次:直接复制内容
try:
import shutil
# 如果目标文件存在且被占用,尝试读取临时文件内容并写入
if os.path.exists(tmp_file):
# 尝试直接覆盖写入(如果文件被占用,这会失败,但至少尝试了)
try:
with open(tmp_file, "rb") as src, open(
out_file, "wb"
) as dst:
dst.write(src.read())
_mirror_screenshot_to_external(out_file)
print(
f"[{timetag}] [截图] ✓ 获取屏幕截图成功(通过直接写入)"
)
return True
except (OSError, PermissionError) as e:
# 如果还是失败,尝试将临时文件重命名为目标文件
try:
# 如果目标文件存在,尝试重命名为备份
if os.path.exists(out_file):
backup_name = out_file + ".backup"
try:
if os.path.exists(backup_name):
os.remove(backup_name)
os.rename(out_file, backup_name)
except Exception:
pass
# 尝试重命名临时文件为目标文件
os.rename(tmp_file, out_file)
_mirror_screenshot_to_external(out_file)
print(
"{} 获取屏幕截图(通过重命名临时文件)".format(
timetag
)
)
return True
except Exception:
# 最后兜底:返回True,让调用者知道临时文件存在
print(
f"[截图] 文件替换失败({e}),但截图已保存到临时文件 {tmp_file}"
)
return True
except Exception:
print(f"[截图] 文件替换失败,但截图已保存到临时文件 {tmp_file}")
return True
# 文件异常则继续进入更深回退
except Exception:
# 再次回退:尝试用 screenshot1.png 覆盖 screenshot.png
try:
subprocess.run(
[
adb,
"-s",
device_id,
"shell",
"screencap",
"-p",
"/sdcard/DCIM/screenshot1.png",
],
stdout=subprocess.DEVNULL,
stderr=subprocess.DEVNULL,
check=True,
)
subprocess.run(
[
adb,
"-s",
device_id,
"shell",
"mv",
"/sdcard/DCIM/screenshot1.png",
"/sdcard/DCIM/screenshot.png",
],
stdout=subprocess.DEVNULL,
stderr=subprocess.DEVNULL,
check=True,
)
return self.get_screenshot(device_id, path)
except Exception:
return False
def get_current_hour(self):
"""获取当前的时间小时数"""
time_hour = datetime.now().strftime("%H")
print("当前时间{}点".format(time_hour))
return int(time_hour)
def click_confirm(self, device_id):
"""点击确认键"""
os.system("%s -s %s shell input keyevent 66" % (self._adb(), device_id))
print("点击确认键")
def click_back(self, device_id):
"""点击返回键"""
os.system("%s -s %s shell input keyevent 4" % (self._adb(), device_id))
print("点击返回键")
# 电量检测方法已删除
def get_device_resolution(self, device_id):
"""获取设备分辨率"""
resolution_info = subprocess.Popen(
"%s -s %s shell wm size" % (self._adb(), device_id),
shell=True,
stdout=subprocess.PIPE,
)
assert resolution_info.stdout is not None
resolution_info_string = resolution_info.stdout.read()
resolution_info_string = bytes.decode(resolution_info_string)
match = re.search(r"Physical size: (\d+)x(\d+)", resolution_info_string)
if match:
width = int(match.group(1))
height = int(match.group(2))
print("设备分辨率为:{}*{}".format(width, height))
return width, height
else:
raise ValueError("Could not find resolution in adb output")
def save_reward_pic(self, device_id):
try:
import path_config
out_dir = path_config.get_pic_dir()
except Exception:
import path_config
out_dir = path_config.get_pic_dir()
if not os.path.exists(out_dir):
os.makedirs(out_dir)
timepic = datetime.now().strftime("%Y-%m-%d-%H-%M-%S")
out_file = os.path.join(out_dir, f"{timepic}.png")
adb = self._adb_path()
# 同样优先使用 exec-out,减少手机端 I/O
try:
with open(out_file, "wb") as f:
subprocess.run(
[adb, "-s", device_id, "exec-out", "screencap", "-p"],
stdout=f,
stderr=subprocess.DEVNULL,
check=True,
)
print("中奖了,点击领奖,保存中奖图片{}.png".format(timepic))
return
except Exception:
pass
# 回退:shell screencap + pull
try:
subprocess.run(
[
adb,
"-s",
device_id,
"shell",
"screencap",
"-p",
"/sdcard/DCIM/screenshot.png",
],
stdout=subprocess.DEVNULL,
stderr=subprocess.DEVNULL,
check=True,
)
subprocess.run(
[adb, "-s", device_id, "pull", "/sdcard/DCIM/screenshot.png", out_file],
stdout=subprocess.DEVNULL,
stderr=subprocess.DEVNULL,
check=True,
)
subprocess.run(
[adb, "-s", device_id, "shell", "rm", "/sdcard/DCIM/screenshot.png"],
stdout=subprocess.DEVNULL,
stderr=subprocess.DEVNULL,
check=False,
)
print("中奖了,点击领奖,保存中奖图片{}.png".format(timepic))
except Exception:
# 保存失败不打断主流程
print("保存中奖截图失败")
def cut_pic(self, left_up=(0, 63), right_down=(1080, 1620), target="", name=""):
"""裁剪图片,获取需要的区域小图片方便识别
添加了错误处理:
- 检查文件是否存在
- 验证图片完整性
- 重试机制(如果文件损坏)
- 异常处理避免程序崩溃
"""
max_retries = 3
retry_delay = 0.1
for attempt in range(max_retries):
try:
if target == "" or target == False:
path = os.path.dirname(__file__) + "/pic"
pic1_path = path + "/screenshot.png"
# 检查文件是否存在
if not os.path.exists(pic1_path):
if attempt < max_retries - 1:
time_module.sleep(retry_delay * (attempt + 1))
continue
raise FileNotFoundError(f"截图文件不存在: {pic1_path}")
# 验证文件大小(至少应该有一些内容)
if os.path.getsize(pic1_path) < 100:
if attempt < max_retries - 1:
time_module.sleep(retry_delay * (attempt + 1))
continue
raise ValueError(f"截图文件太小,可能损坏: {pic1_path}")
# 尝试打开并验证图片
try:
pic = Image.open(pic1_path)
# 验证图片完整性(通过访问尺寸属性)
_ = pic.size
# 确保图片已加载
pic.load()
except (SyntaxError, IOError, OSError) as e:
# 图片损坏,重试或返回False
if attempt < max_retries - 1:
print(
f"[警告] 图片文件可能损坏,重试中 ({attempt + 1}/{max_retries}): {e}"
)
time_module.sleep(retry_delay * (attempt + 1))
continue
# 最后一次尝试失败,让外层异常处理
raise
if name == "":
cut_pic_path = path + "/cut.png"
else:
# 使用新的路径查找方法(写入到新位置ocr/)
cut_pic_path = self._find_pic_path(name, for_reading=False)
# 验证裁剪坐标有效性
width, height = pic.size
left, top = left_up
right, bottom = right_down
if (
left < 0
or top < 0
or right > width
or bottom > height
or left >= right
or top >= bottom
):
raise ValueError(
f"裁剪坐标无效: left_up={left_up}, right_down={right_down}, image_size={pic.size}"
)
cropped_img = pic.crop((left, top, right, bottom))
assert cut_pic_path is not None
try:
_ensure_parent_dir(cut_pic_path)
cropped_img.save(cut_pic_path)
except Exception:
logging.exception("保存裁剪图片失败: %s", cut_pic_path)
# 存储坐标信息供analyse_pic_word使用
if name:
try:
self._ocr_coords_cache[name] = (left, top, right, bottom)
except Exception:
pass
# 双截图记录:保存实时操作截图
try:
from douyin.handlers import douyin_screenshot_manager
douyin_screenshot_manager.save_latest_attempt(
cropped_img, operation_type="cut_pic"
)
# 保存调试图像(完整截图+区域标注)
pic_rgb = pic.convert("RGB")
debug_path = douyin_screenshot_manager.save_debug_image(
pic_rgb,
operation_type="cut_pic",
picname=name if name else "cut",
step="before_ocr",
coords=(left, top, right, bottom),
extra_info={
"source": "screenshot.png",
"size": f"{right-left}x{bottom-top}",
},
)
if debug_path:
try:
logging.info(f"[调试图像] cut_pic保存: {debug_path}")
except Exception:
pass
except Exception:
pass
return True
else:
path_target = os.path.dirname(__file__) + "/pic/" + target
pic1_path = path_target + "/screenshot.png"
# 检查文件是否存在
if not os.path.exists(pic1_path):
if attempt < max_retries - 1:
time_module.sleep(retry_delay * (attempt + 1))
continue
raise FileNotFoundError(f"截图文件不存在: {pic1_path}")
# 验证文件大小
if os.path.getsize(pic1_path) < 100:
if attempt < max_retries - 1:
time_module.sleep(retry_delay * (attempt + 1))
continue
raise ValueError(f"截图文件太小,可能损坏: {pic1_path}")
# 尝试打开并验证图片
try:
pic = Image.open(pic1_path)
_ = pic.size
pic.load()
except (SyntaxError, IOError, OSError) as e:
# 图片损坏,重试或返回False
if attempt < max_retries - 1:
print(
f"[警告] 图片文件可能损坏,重试中 ({attempt + 1}/{max_retries}): {e}"
)
time_module.sleep(retry_delay * (attempt + 1))
continue
# 最后一次尝试失败,让外层异常处理
raise
if name == "":
cut_pic_path = path_target + "/cut.png"
else:
cut_pic_path = path_target + "/" + name + ".png"
# 验证裁剪坐标有效性
width, height = pic.size
left, top = left_up
right, bottom = right_down
if (
left < 0
or top < 0
or right > width
or bottom > height
or left >= right
or top >= bottom
):
error_msg = f"裁剪坐标无效: left_up={left_up}, right_down={right_down}, image_size={pic.size}"
if attempt == max_retries - 1:
print(f"[错误] {error_msg}")
return False
continue
assert cut_pic_path is not None
cropped_img = pic.crop((left, top, right, bottom))
try:
_ensure_parent_dir(cut_pic_path)
cropped_img.save(cut_pic_path)
except Exception:
logging.exception("保存裁剪图片失败: %s", cut_pic_path)
return False
# 存储坐标信息供analyse_pic_word使用
if name:
try:
self._ocr_coords_cache[name] = (left, top, right, bottom)
except Exception:
pass
# 保存调试图像(完整截图+区域标注)
try:
from douyin.handlers import douyin_screenshot_manager
pic_rgb = pic.convert("RGB")
debug_path = douyin_screenshot_manager.save_debug_image(
pic_rgb,
operation_type="cut_pic",
picname=name if name else "cut",
step="before_ocr",
coords=(left, top, right, bottom),
extra_info={
"source": target + "/screenshot.png",
"size": f"{right-left}x{bottom-top}",
},
)
if debug_path:
try:
logging.info(f"[调试图像] cut_pic保存: {debug_path}")
except Exception:
pass
except Exception:
pass
return True
except (SyntaxError, IOError, OSError, FileNotFoundError, ValueError) as e:
# 裁剪或读取图片时发生错误,最后一次尝试失败则记录并返回 False
if attempt == max_retries - 1:
error_msg = f"[错误] 裁剪图片失败 (尝试 {max_retries} 次): {e}"
print(error_msg)
print(f" 源文件: {locals().get('pic1_path', 'N/A')}")
print(f" 目标文件: {locals().get('cut_pic_path', 'N/A')}")
return False
# 否则继续重试
continue
def analyse_pic_word(self, picname, change_color=0, pic_path=None):
"""对指定图片运行 OCR 并返回拼接后的文本结果。
参数:
picname: 用于分类和调试的图片名(如"福袋内容")
change_color: 颜色处理模式,0=保留彩色,1/2=二值化等
pic_path: 可选的图片路径,未提供时通过 `_find_pic_path` 查找
返回:
识别到的文本(字符串),识别失败返回空字符串
"""
if not pic_path:
try:
pic_path = self._find_pic_path(picname)
except Exception:
pic_path = None
if not pic_path or not os.path.exists(pic_path):
return ""
img = None # Initialize img to avoid unbound variable
try:
img = Image.open(pic_path)
img.verify()
img = Image.open(pic_path)
except (IOError, OSError, UnidentifiedImageError):
return ""
if img is None:
return ""
if change_color in (1, 2):
img = img.convert("L")
if change_color == 1:
img = img.point(lambda x: 0 if x < 128 else 255)
else:
img = img.point(lambda x: 0 if x < 180 else 255)
img = img.convert("RGB")
else:
img = img.convert("RGB")
w, h = img.size
if max(w, h) < 200:
try:
scale = max(2, 300 // max(w, h, 1))
img = img.resize((w * scale, h * scale), _RESAMPLE.BICUBIC)
w, h = img.size
except Exception:
pass
from PIL import ImageEnhance
# Initialize img1 to avoid unbound variable
img1 = img
try:
img_sharpened = img.filter(
ImageFilter.UnsharpMask(radius=1, percent=150, threshold=3)
)
enhancer = ImageEnhance.Contrast(img_sharpened)
contrast_factor = 1.25 if max(w, h) < 300 else 1.15
img1 = enhancer.enhance(contrast_factor)
except Exception:
try:
img1 = img.filter(ImageFilter.SHARPEN)
except Exception:
img1 = img # Fallback to original image
# 保存预处理后的调试图像(OCR前)- 使用完整截图
try:
from douyin.handlers import douyin_screenshot_manager
import path_config
# 尝试获取OCR区域坐标
ocr_coords = None
try:
ocr_coords = self._ocr_coords_cache.get(picname)
except Exception:
pass
# 加载完整截图
full_screenshot = None
try:
screenshot_path = path_config.get_screenshot_path()
if os.path.exists(screenshot_path):
full_screenshot = Image.open(screenshot_path)
full_screenshot.load()
full_screenshot = full_screenshot.convert("RGB")
except Exception:
pass
# 如果成功加载完整截图,使用完整截图;否则使用预处理图像
debug_image = full_screenshot if full_screenshot is not None else img1
debug_path = douyin_screenshot_manager.save_debug_image(
debug_image,
operation_type="ocr",
picname=picname,
step="preprocessed",
coords=ocr_coords,
extra_info={
"mode": change_color,
"size": f"{w}x{h}",
"source": pic_path if pic_path else picname,
"has_full_screenshot": full_screenshot is not None,
"has_coords": ocr_coords is not None,
},
)
if debug_path:
try:
logging.info(f"[调试图像] OCR预处理保存: {debug_path}")
except Exception:
pass
except Exception:
pass
img_np = np.array(img1)
# 用于收集置信度信息
ocr_confidence_info = None
if getattr(self, "ocr_type", None) == "easyocr":
result = self.ocr.readtext(img_np)
extract_result = self.extract_ocr_content(result, return_confidence=True)
if isinstance(extract_result, tuple):
text, ocr_confidence_info = extract_result
else:
text = extract_result
else:
result = self.ocr.ocr(img_np)
if result == [None]:
return ""
extract_result = self.extract_ocr_content(result, return_confidence=True)
if isinstance(extract_result, tuple):
text, ocr_confidence_info = extract_result
else:
text = extract_result
# Initialize variables to avoid unbound variable issues
img1 = img # img1 is used later, initialize from img
img2 = None
text2 = None
# 禁用二次OCR识别(用户要求:没有GPU,不需要二次OCR)
# 如果第一次识别失败,直接返回空结果,避免耗时3-4秒的二次识别
# if (not text) and max(w, h) <= 1200:
# try:
# img2 = img.resize((w * 2, h * 2), _RESAMPLE.LANCZOS)
# try:
# from PIL import ImageEnhance
#
# img2_sharpened = img2.filter(
# ImageFilter.UnsharpMask(radius=1.5, percent=180, threshold=3)
# )
# enhancer = ImageEnhance.Contrast(img2_sharpened)
# img2 = enhancer.enhance(1.2)
# except Exception:
# img2 = img2.filter(ImageFilter.SHARPEN)
#
# if getattr(self, "ocr_type", None) == "easyocr":
# result2 = self.ocr.readtext(np.array(img2))
# extract_result2 = self.extract_ocr_content(result2, return_confidence=True)
# if isinstance(extract_result2, tuple):
# text2, ocr_confidence_info = extract_result2
# else:
# text2 = extract_result2
# if text2:
# text = text2
# result = result2
# else:
# result2 = self.ocr.ocr(np.array(img2))
# if result2 != [None]:
# extract_result2 = self.extract_ocr_content(result2, return_confidence=True)
# if isinstance(extract_result2, tuple):
# text2, ocr_confidence_info = extract_result2
# else:
# text2 = extract_result2
# if text2:
# text = text2
# result = result2
# except Exception:
# pass
if picname in ("福袋内容", "福袋倒计时") and not text:
try:
if isinstance(result, list) and result and isinstance(result[0], dict):
print(
f"OCR调试({picname}): result[0] keys={list(result[0].keys())}"
)
else:
print(f"OCR调试({picname}): result type={type(result)}")
except Exception:
pass
try:
from douyin.handlers import douyin_screenshot_manager
# Ensure img1 is defined before use
if "img1" not in locals():
img1 = img
img_for_attempt = (
img2 if (img2 is not None and text2 and text2.strip()) else img1
)
douyin_screenshot_manager.save_latest_attempt(
img_for_attempt, operation_type="ocr"
)
# 保存OCR结果后的调试图像(带OCR文本结果和置信度)- 使用完整截图
ocr_result_preview = (
(text or text2 or "").strip()[:50] if (text or text2) else ""
)
extra_info_dict = {
"mode": change_color,
"text_len": len(text or text2 or ""),
"text_preview": ocr_result_preview,
"used_img2": bool(img2 is not None and text2 and text2.strip()),
}
# 添加置信度信息
if ocr_confidence_info:
extra_info_dict["avg_confidence"] = round(
ocr_confidence_info.get("avg_confidence", 0.0), 4
)
extra_info_dict["min_confidence"] = round(
ocr_confidence_info.get("min_confidence", 0.0), 4
)
extra_info_dict["max_confidence"] = round(
ocr_confidence_info.get("max_confidence", 0.0), 4
)
extra_info_dict["confidence_items"] = ocr_confidence_info.get(
"item_count", 0
)
# 尝试获取OCR区域坐标
ocr_coords = None
try:
ocr_coords = self._ocr_coords_cache.get(picname)
except Exception:
pass
# 加载完整截图
full_screenshot = None
try:
import path_config
screenshot_path = path_config.get_screenshot_path()
if os.path.exists(screenshot_path):
full_screenshot = Image.open(screenshot_path)
full_screenshot.load()
full_screenshot = full_screenshot.convert("RGB")
except Exception:
pass
# 如果成功加载完整截图,使用完整截图;否则使用预处理图像
debug_image = full_screenshot if full_screenshot is not None else img_for_attempt
extra_info_dict["has_full_screenshot"] = full_screenshot is not None
extra_info_dict["has_coords"] = ocr_coords is not None
debug_path = douyin_screenshot_manager.save_debug_image(
debug_image,
operation_type="ocr",
picname=picname,
step="after_ocr",
coords=ocr_coords,
extra_info=extra_info_dict,
)
# 记录OCR置信度到日志
if ocr_confidence_info and ocr_confidence_info.get("item_count", 0) > 0:
try:
logging.info(
f"[OCR置信度] {picname}: "
f"平均={ocr_confidence_info.get('avg_confidence', 0.0):.4f}, "
f"最小={ocr_confidence_info.get('min_confidence', 0.0):.4f}, "
f"最大={ocr_confidence_info.get('max_confidence', 0.0):.4f}, "
f"项目数={ocr_confidence_info.get('item_count', 0)}"
)
except Exception:
pass
if debug_path:
try:
logging.info(
f"[调试图像] OCR结果保存: {debug_path}, 文本: {ocr_result_preview}"
)
except Exception:
pass
except Exception:
pass
if text and text.strip() and picname:
try:
try:
from douyin.handlers import douyin_screenshot_manager
category = douyin_screenshot_manager.get_category_for_picname(
picname
)
except Exception:
category = "others"
base_dir = os.path.dirname(__file__)
pic_base = os.path.join(base_dir, "pic")
category_dir = os.path.join(pic_base, "ocr", category)
os.makedirs(category_dir, exist_ok=True)
success_path = os.path.join(category_dir, f"{picname}_success.png")
try:
# Ensure img1 is defined before use
if "img1" not in locals():
img1 = img
if img2 is not None and text2 and text2.strip():
img_to_save = img2
else:
img_to_save = img1
try:
from douyin.handlers import douyin_screenshot_manager
douyin_screenshot_manager.save_last_success(
img_to_save, operation_type="ocr"
)
except Exception:
pass
img_to_save.save(success_path)
except Exception:
try:
if img is not None:
img.save(success_path)
except Exception:
pass
except Exception:
pass
return text
def analyse_pic_digits(self, picname, change_color=1, pic_path=None):
"""轻量数字OCR识别函数,专门用于识别数字(0-9)。
相比analyse_pic_word,这个函数:
1. 使用二值化预处理(change_color=1),更适合数字识别
2. 只提取数字字符,忽略其他字符
3. 使用更轻量的OCR配置(如果支持)
参数:
picname: 用于分类和调试的图片名(如"福袋价值")
change_color: 颜色处理模式,默认1=二值化(更适合数字)
pic_path: 可选的图片路径,未提供时通过 `_find_pic_path` 查找
返回:
识别到的数字文本(字符串),识别失败返回空字符串
"""
if not pic_path:
try:
pic_path = self._find_pic_path(picname)
except Exception:
pic_path = None
if not pic_path or not os.path.exists(pic_path):
return ""
img = None
try:
img = Image.open(pic_path)
img.verify()
img = Image.open(pic_path)
except (IOError, OSError, UnidentifiedImageError):
return ""
if img is None:
return ""
# 数字识别更适合使用二值化处理
img = img.convert("L")
if change_color == 1:
img = img.point(lambda x: 0 if x < 128 else 255)
elif change_color == 2:
img = img.point(lambda x: 0 if x < 180 else 255)
img = img.convert("RGB")
w, h = img.size
# 数字识别需要更高的分辨率
if max(w, h) < 200:
try:
scale = max(2, 400 // max(w, h, 1))
img = img.resize((w * scale, h * scale), _RESAMPLE.BICUBIC)
w, h = img.size
except Exception:
pass
# 锐化处理,提高数字识别准确率
from PIL import ImageEnhance
img1 = img
try:
img_sharpened = img.filter(
ImageFilter.UnsharpMask(radius=1, percent=200, threshold=3)
)
enhancer = ImageEnhance.Contrast(img_sharpened)
img1 = enhancer.enhance(1.3) # 更高的对比度
except Exception:
try:
img1 = img.filter(ImageFilter.SHARPEN)
except Exception:
img1 = img # Fallback to original image
# 保存预处理后的调试图像(OCR前)- 使用完整截图
try:
from douyin.handlers import douyin_screenshot_manager
import path_config
# 尝试获取OCR区域坐标
ocr_coords = None
try:
ocr_coords = self._ocr_coords_cache.get(picname)
except Exception:
pass
# 加载完整截图
full_screenshot = None
try:
screenshot_path = path_config.get_screenshot_path()
if os.path.exists(screenshot_path):
full_screenshot = Image.open(screenshot_path)
full_screenshot.load()
full_screenshot = full_screenshot.convert("RGB")
except Exception:
pass
# 如果成功加载完整截图,使用完整截图;否则使用预处理图像
debug_image = full_screenshot if full_screenshot is not None else img1
debug_path = douyin_screenshot_manager.save_debug_image(
debug_image,
operation_type="ocr",
picname=picname,
step="preprocessed",
coords=ocr_coords,
extra_info={
"mode": change_color,
"size": f"{w}x{h}",
"source": pic_path if pic_path else picname,
"has_full_screenshot": full_screenshot is not None,
"has_coords": ocr_coords is not None,
"type": "digits",
},
)
if debug_path:
try:
logging.info(f"[调试图像] OCR数字预处理保存: {debug_path}")
except Exception:
pass
except Exception:
pass
img_np = np.array(img1)
# 使用OCR识别(与analyse_pic_word相同的OCR引擎)
ocr_confidence_info = None
if getattr(self, "ocr_type", None) == "easyocr":
result = self.ocr.readtext(img_np)
extract_result = self.extract_ocr_content(result, return_confidence=True)
if isinstance(extract_result, tuple):
text, ocr_confidence_info = extract_result
else:
text = extract_result
else:
result = self.ocr.ocr(img_np)
if result == [None]:
return ""
extract_result = self.extract_ocr_content(result, return_confidence=True)
if isinstance(extract_result, tuple):
text, ocr_confidence_info = extract_result
else:
text = extract_result
# 保存OCR结果后的调试图像(带OCR文本结果和置信度)- 使用完整截图
try:
from douyin.handlers import douyin_screenshot_manager
import path_config
# 尝试获取OCR区域坐标
ocr_coords = None
try:
ocr_coords = self._ocr_coords_cache.get(picname)
except Exception:
pass
# 加载完整截图
full_screenshot = None
try:
screenshot_path = path_config.get_screenshot_path()
if os.path.exists(screenshot_path):
full_screenshot = Image.open(screenshot_path)
full_screenshot.load()
full_screenshot = full_screenshot.convert("RGB")
except Exception:
pass
# 如果成功加载完整截图,使用完整截图;否则使用预处理图像
debug_image = full_screenshot if full_screenshot is not None else img1
# 准备额外信息
digits_result = ""
if text:
digits_result = "".join(ch for ch in str(text) if ch.isdigit())
extra_info_dict = {
"mode": change_color,
"text_len": len(text or ""),
"digits": digits_result,
"type": "digits",
}
# 添加置信度信息
if ocr_confidence_info:
extra_info_dict["avg_confidence"] = round(
ocr_confidence_info.get("avg_confidence", 0.0), 4
)
extra_info_dict["min_confidence"] = round(
ocr_confidence_info.get("min_confidence", 0.0), 4
)
extra_info_dict["max_confidence"] = round(
ocr_confidence_info.get("max_confidence", 0.0), 4
)
extra_info_dict["confidence_items"] = ocr_confidence_info.get(
"item_count", 0
)
extra_info_dict["has_full_screenshot"] = full_screenshot is not None
extra_info_dict["has_coords"] = ocr_coords is not None
debug_path = douyin_screenshot_manager.save_debug_image(
debug_image,
operation_type="ocr",
picname=picname,
step="after_ocr",
coords=ocr_coords,
extra_info=extra_info_dict,
)
# 记录OCR置信度到日志
if ocr_confidence_info and ocr_confidence_info.get("item_count", 0) > 0:
try:
logging.info(
f"[OCR置信度] {picname}: "
f"平均={ocr_confidence_info.get('avg_confidence', 0.0):.4f}, "
f"最小={ocr_confidence_info.get('min_confidence', 0.0):.4f}, "
f"最大={ocr_confidence_info.get('max_confidence', 0.0):.4f}, "
f"项目数={ocr_confidence_info.get('item_count', 0)}"
)
except Exception:
pass
if debug_path:
try:
logging.info(
f"[调试图像] OCR数字结果保存: {debug_path}, 数字: {digits_result}"
)
except Exception:
pass
except Exception:
pass
# 只提取数字字符,并进行智能过滤
if text:
# 提取所有数字字符
digits = "".join(ch for ch in str(text) if ch.isdigit())
# 智能过滤:如果识别到的数字太多(可能是识别到了文件名或坐标),
# 尝试提取合理的数字段
if len(digits) > 10:
# 对于价值:通常不超过6位数字(999999元以内)
# 对于倒计时:通常是1-2位数字
# 尝试提取最后几个数字(通常是实际值)
# 或者提取最短的连续数字段
import re
# 提取所有连续的数字段
digit_segments = re.findall(r"\d+", str(text))
if digit_segments:
# 对于价值,选择最大的合理数字段(不超过6位)
# 对于倒计时,选择1-2位的数字段
# 这里先返回所有数字,让调用方处理
# 但优先选择较短的段(1-6位)
reasonable_segments = [
s for s in digit_segments if 1 <= len(s) <= 6
]
if reasonable_segments:
# 如果有多段,优先选择较短的(倒计时)或较长的(价值)
# 这里返回最长的合理段(通常是价值)
return max(reasonable_segments, key=len)
else:
# 如果没有合理段,返回最短的段
return (
min(digit_segments, key=len)
if digit_segments
else digits[:6]
)
return digits
return ""
def extract_ocr_content(self, content=[], return_confidence=False):
"""对OCR识别到的内容进行取值和拼接,变成完整的一段内容
参数:
content: OCR识别结果
return_confidence: 是否返回置信度信息(默认False,保持向后兼容)
返回:
如果return_confidence=False: 返回文本字符串
如果return_confidence=True: 返回(text, confidence_info)元组,其中confidence_info是置信度信息字典
"""
ocr_result = content
# 用于收集置信度信息
confidence_scores = []
confidence_info = {
"avg_confidence": 0.0,
"min_confidence": 1.0,
"max_confidence": 0.0,
"item_count": 0,
}
def _extract_text_and_confidence_from_item(item):
"""提取文本和置信度"""
text = ""
confidence = None
# 兼容EasyOCR格式:[(bbox, text, confidence), ...] -> (bbox, text, confidence)
if isinstance(item, (list, tuple)) and len(item) >= 2:
# EasyOCR格式:item = (bbox, text, confidence),text在索引1,confidence在索引2
if len(item) >= 3:
confidence = item[2]
if isinstance(item[1], str):
text = item[1]
return text, confidence
# 兼容旧格式:[box, (text, score)]
second = item[1]
if isinstance(second, (list, tuple)) and len(second) >= 1:
if isinstance(second[0], str):
return second[0]
if isinstance(second, dict):
for key in ("text", "rec_text", "transcription"):
val = second.get(key)
if isinstance(val, str) and val:
return val
if isinstance(second, str):
return second
# 兼容新格式:dict / 对象
if isinstance(item, dict):
# 常见:rec_texts 为字符串列表
for list_key in ("rec_texts", "texts", "text_list"):
vals = item.get(list_key)
if isinstance(vals, list) and vals:
vals = [v for v in vals if isinstance(v, str) and v]
if vals:
return "".join(vals)
for key in ("text", "rec_text", "transcription"):
val = item.get(key)
if isinstance(val, str) and val:
return val
for attr in ("text", "rec_text", "transcription"):
val = getattr(item, attr, None)
if isinstance(val, str) and val:
return val
# 对象属性里也可能是列表
for list_attr in ("rec_texts", "texts", "text_list"):
vals = getattr(item, list_attr, None)
if isinstance(vals, list) and vals:
vals = [v for v in vals if isinstance(v, str) and v]
if vals:
return "".join(vals)
return ""
# PaddleOCR 可能返回 [[...]] 或 [...]
items = ocr_result
if (
isinstance(ocr_result, list)
and len(ocr_result) == 1
and isinstance(ocr_result[0], list)
):
items = ocr_result[0]
def _extract_xy_from_item(item):
"""尽力从 OCR item 中提取用于排序的 (y, x)。无法提取则返回 None。"""
try:
if isinstance(item, (list, tuple)) and len(item) >= 1:
box = item[0]
# EasyOCR格式:bbox = [[x1,y1], [x2,y2], [x3,y3], [x4,y4]]
# PaddleOCR格式:box 为 4 点坐标列表
if isinstance(box, (list, tuple)) and box:
xs = []
ys = []
for p in box:
if isinstance(p, (list, tuple)) and len(p) >= 2:
xs.append(float(p[0]))
ys.append(float(p[1]))
if xs and ys:
return (min(ys), min(xs))
except Exception:
return None
return None
def _extract_text_from_item(item):
"""提取文本(原始逻辑,保持向后兼容)"""
# 兼容EasyOCR格式:[(bbox, text, confidence), ...] -> (bbox, text, confidence)
if isinstance(item, (list, tuple)) and len(item) >= 2:
# EasyOCR格式:item = (bbox, text, confidence),text在索引1
if isinstance(item[1], str):
return item[1]
# 兼容旧格式:[box, (text, score)]
second = item[1]
if isinstance(second, (list, tuple)) and len(second) >= 1:
if isinstance(second[0], str):
return second[0]
if isinstance(second, dict):
for key in ("text", "rec_text", "transcription"):
val = second.get(key)
if isinstance(val, str) and val:
return val
if isinstance(second, str):
return second
# 兼容新格式:dict / 对象
if isinstance(item, dict):
# 常见:rec_texts 为字符串列表
for list_key in ("rec_texts", "texts", "text_list"):
vals = item.get(list_key)
if isinstance(vals, list) and vals:
vals = [v for v in vals if isinstance(v, str) and v]
if vals:
return "".join(vals)
for key in ("text", "rec_text", "transcription"):
val = item.get(key)
if isinstance(val, str) and val:
return val
for attr in ("text", "rec_text", "transcription"):
val = getattr(item, attr, None)
if isinstance(val, str) and val:
return val
# 对象属性里也可能是列表
for list_attr in ("rec_texts", "texts", "text_list"):
vals = getattr(item, list_attr, None)
if isinstance(vals, list) and vals:
vals = [v for v in vals if isinstance(v, str) and v]
if vals:
return "".join(vals)
return ""
extracted_items = []
if isinstance(items, list):
for idx, item in enumerate(items):
text = _extract_text_from_item(item)
if not text:
continue
xy = _extract_xy_from_item(item)
if xy is None:
# 无坐标信息:保持原相对顺序
extracted_items.append((1e18, float(idx), text))
else:
y, x = xy
extracted_items.append((float(y), float(x), text))
# 按从上到下、从左到右排序;解决同一行多个框的乱序拼接(例如倒计时两段数字)
extracted_items.sort(key=lambda t: (t[0], t[1]))
# 如果不需要返回置信度,直接返回文本(保持向后兼容)
if not return_confidence:
return "".join([t[2] for t in extracted_items])
# 如果需要返回置信度,提取置信度信息
if return_confidence:
for item in items:
confidence = None
# EasyOCR格式:[(bbox, text, confidence), ...]
if isinstance(item, (list, tuple)) and len(item) >= 3:
confidence = item[2]
# PaddleOCR格式:[box, (text, score)]
elif isinstance(item, (list, tuple)) and len(item) >= 2:
second = item[1]
if isinstance(second, (list, tuple)) and len(second) >= 2:
confidence = second[1]
elif isinstance(second, dict):
confidence = second.get("confidence") or second.get("score")
if confidence is not None:
try:
conf_float = float(confidence)
confidence_scores.append(conf_float)
confidence_info["min_confidence"] = min(
confidence_info["min_confidence"], conf_float
)
confidence_info["max_confidence"] = max(
confidence_info["max_confidence"], conf_float
)
except (ValueError, TypeError):
pass
if confidence_scores:
confidence_info["avg_confidence"] = sum(confidence_scores) / len(
confidence_scores
)
confidence_info["item_count"] = len(confidence_scores)
else:
confidence_info["min_confidence"] = 0.0
return "".join([t[2] for t in extracted_items]), confidence_info
return "".join([t[2] for t in extracted_items])
def delay(self, seconds: float = 1):
time.sleep(seconds)
def random_delay(self, min_seconds=1, max_seconds=100):
"""等待随机的时长"""
random_wait_seconds = random.randint(min_seconds, max_seconds)
print("随机等待{}秒.".format(random_wait_seconds))
self.delay(random_wait_seconds)
def check_countdown(self, last_time=""):
"""对倒计时时间进行转化,返回 (剩余秒数, 预计开奖时间戳)。
兼容 OCR 常见格式与误识别:
- 11:37 / 11:37 / 11:37后开奖
- 1分23秒 / 23秒
- 1137 / 934 / 31
- 字符混淆:O->0, l/I->1, S->5 等
"""
def _norm(s: str) -> str:
t = str(s or "")
t = re.sub(r"\s+", "", t)
t = t.replace(":", ":")
# 常见 OCR 混淆纠正
trans = str.maketrans(
{
"O": "0",
"o": "0",
"Q": "0",
"D": "0",
"I": "1",
"l": "1",
"|": "1",
"!": "1",
"S": "5",
"s": "5",
"B": "8",
"G": "6",
"Z": "2",
}
)
t = t.translate(trans)
return t
def _parse_seconds(text: str) -> Optional[int]:
t = _norm(text)
if not t:
return None
# 1) mm:ss(允许 ss 为 1 位)
m = re.search(r"(\d{1,2})[:](\d{1,2})", t)
if m:
mm = int(m.group(1))
ss = int(m.group(2))
# 若秒数 >= 60,优先尝试交换(OCR 容易把分秒顺序颠倒)
if ss >= 60 and mm < 60:
mm, ss = ss, mm
# 兜底:仍不合法则做进位
if ss >= 60:
mm += ss // 60
ss = ss % 60
return max(0, mm * 60 + ss)
# 2) 中文:x分y秒 / y秒
m = re.search(r"(\d{1,2})分(\d{1,2})秒", t)
if m:
mm = int(m.group(1))
ss = int(m.group(2))
if ss >= 60:
mm += ss // 60
ss = ss % 60
return max(0, mm * 60 + ss)
m = re.search(r"(\d{1,3})秒", t)
if m:
return max(0, int(m.group(1)))
# 3) 纯数字:1137(=11:37) / 934(=9:34) / 31(=31秒)
digits = "".join(ch for ch in t if ch.isdigit())
if not digits:
return None
if len(digits) == 4:
a = int(digits[:2])
b = int(digits[2:])
# 两种解释:a:b 或 b:a。
# 默认按“前两位=分、后两位=秒”,只有在明显异常(>15分钟)或秒不合法时才交换。
if b < 60:
total1 = a * 60 + b
else:
total1 = None
if a < 60:
total2 = b * 60 + a
else:
total2 = None
if total1 is not None and total1 <= 900:
return total1
if total2 is not None and total2 <= 900:
return total2
# 若一个明显异常而另一个更合理(<=900),交换
if total1 is not None and total2 is not None:
if total1 > 900 and total2 <= 900:
return total2
if total2 > 900 and total1 <= 900:
return total1
# 兜底:谁能解析就用谁;都不行则做进位
if total1 is not None:
return total1
if total2 is not None:
return total2
mm, ss = a, b
mm += ss // 60
ss = ss % 60
return mm * 60 + ss
if len(digits) == 3:
mm = int(digits[0])
ss = int(digits[1:])
if ss >= 60:
# 例如 159 可能是 15:09(OCR 丢 0)
mm2 = int(digits[:2])
ss2 = int(digits[2])
if ss2 < 60:
return mm2 * 60 + ss2
mm += ss // 60
ss = ss % 60
return mm * 60 + ss
if len(digits) == 2:
return int(digits) # 直接当秒(更符合“临近开奖”场景)
if len(digits) == 1:
return int(digits)
# 太长:取最后4位(OCR 常把别的数字也识别进来)
tail = digits[-4:]
a = int(tail[:2])
b = int(tail[2:])
if b >= 60 and a < 60:
a, b = b, a
if b >= 60:
a += b // 60
b = b % 60
return a * 60 + b
try:
total_seconds = _parse_seconds(last_time)
if total_seconds is None:
print("时间格式异常")
return False
print("剩余总秒数:", total_seconds)
# 超过 15 分钟基本是误识别:按 14分50秒处理,避免卡死等待
if total_seconds > 900:
total_seconds = 890
now = datetime.now()
print("当前时间:", now.strftime("%Y-%m-%d %H:%M:%S"))
future_time = now + timedelta(seconds=int(total_seconds))
future_timestamp = future_time.timestamp()
future_datetime = datetime.fromtimestamp(future_timestamp)
formatted_future_time = future_datetime.strftime("%Y-%m-%d %H:%M:%S")
print("预计开奖时间:", formatted_future_time)
return int(total_seconds), future_timestamp
except Exception:
print("输入的字符串不是有效的时间格式")
return False
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 <start_x> <start_y> <end_x> <end_y> <duration_ms>
"""
import subprocess
adb_cmd = self._adb()
# 注意:adb input swipe 的参数顺序是:start_x start_y end_x end_y duration_ms
# 这里 left_up_x/y 是起始位置,right_down_x/y 是结束位置
cmd = f"{adb_cmd} -s {device_id} shell input swipe {left_up_x} {left_up_y} {right_down_x} {right_down_y} {steps}"
try:
# 使用 subprocess 执行命令,捕获错误输出
result = subprocess.run(
cmd,
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
timeout=5.0,
text=True,
)
# 检查是否有权限错误
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 "权限不足"
print(f"[警告] 滑动操作失败: {error_msg}")
print(f"[提示] 设备不允许 ADB 输入注入,可能的解决方案:")
print(
f" 1. 在设备开发者选项中启用'USB调试(安全设置)'或'允许模拟点击'"
)
print(f" 2. 使用已 root 的设备")
print(f" 3. 某些设备需要在设置中手动授权 ADB 输入权限")
# 不抛出异常,让程序继续运行(可能只是滑动失败,其他功能仍可用)
except subprocess.TimeoutExpired:
print("[警告] 滑动操作超时")
except Exception as e:
# 降级到原来的 os.system 方法
try:
os.system(cmd)
except Exception:
print(f"[警告] 滑动操作失败: {type(e).__name__}: {e}")
def _swipe_with_sendevent(self, device_id, x1, y1, x2, y2, steps):
"""使用 sendevent 方法滑动(需要 root 权限)"""
import subprocess
import time
# 获取触摸设备路径
result = subprocess.run(
f"{self._adb()} -s {device_id} shell getevent -p | grep -A 5 ABS_MT",
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.DEVNULL,
text=True,
)
if "event" not in result.stdout.lower():
raise Exception("无法找到触摸设备")
# 简化实现:直接使用 input 命令的替代参数
# 注意:sendevent 需要 root 权限,这里只是尝试
raise Exception("sendevent 需要 root 权限,暂不支持")
def _swipe_with_uiautomator(self, device_id, x1, y1, x2, y2):
"""使用 uiautomator 滑动(如果可用)
注意:uiautomator 在某些设备上可能也需要权限,但可以尝试作为备选方案。
"""
import subprocess
# 使用 uiautomator swipe 命令
# 注意:uiautomator 命令格式可能因 Android 版本而异
# Android 5.0+: uiautomator swipe <x1> <y1> <x2> <y2> [steps]
cmd = (
f"{self._adb()} -s {device_id} shell uiautomator swipe {x1} {y1} {x2} {y2}"
)
result = subprocess.run(
cmd,
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
timeout=5.0,
)
if result.returncode != 0:
raise Exception(
f"uiautomator swipe 失败: {result.stderr.decode('utf-8', errors='ignore')}"
)
def _swipe_with_sendevent_improved(self, device_id, x1, y1, x2, y2, steps=50):
"""使用 sendevent 方法滑动(需要 root 权限)
这是更底层的触摸事件模拟方式,通过直接向 /dev/input/eventX 写入事件。
优点:绕过部分权限检查
缺点:需要 root 权限,实现复杂,不同设备的事件格式可能不同
"""
import subprocess
import time
# 获取触摸设备路径(通常是 /dev/input/eventX)
result = subprocess.run(
f"{self._adb()} -s {device_id} shell getevent -p 2>/dev/null | grep -A 10 ABS_MT",
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.DEVNULL,
text=True,
timeout=3.0,
)
# 解析设备路径(简化版,实际需要更复杂的解析)
# 这里只是示例,完整实现需要:
# 1. 解析 getevent -p 输出找到触摸设备
# 2. 计算触摸事件的坐标范围(ABS_MT_POSITION_X/Y 的 min/max)
# 3. 将屏幕坐标转换为设备坐标
# 4. 发送 DOWN -> MOVE -> UP 事件序列
if "event" not in result.stdout.lower():
raise Exception("无法找到触摸设备(需要 root 权限)")
# 注意:完整的 sendevent 实现非常复杂,需要:
# - 设备特定的坐标转换
# - 正确的事件序列(SYN_REPORT 等)
# - 不同 Android 版本的事件格式可能不同
raise Exception("sendevent 需要 root 权限且实现复杂,暂不支持完整实现")
def click(self, device_id, x=500, y=500):
"""点击坐标位置"""
os.system("{} -s {} shell input tap {} {}".format(self._adb(), device_id, x, y))
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
os.system(
f"{self._adb()} -s {device_id} shell input swipe {int(x)} {int(y)} {int(x)} {int(y)} {d}"
)
def _run_adb_shell(
self, device_id: str, shell_cmd: str, timeout_seconds: float = 3.0
) -> bool:
"""运行 adb shell 命令,成功返回 True。"""
try:
r = subprocess.run(
f"{self._adb()} -s {device_id} shell {shell_cmd}",
shell=True,
stdout=subprocess.DEVNULL,
stderr=subprocess.DEVNULL,
timeout=timeout_seconds,
)
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(
f"{self._adb()} -s {device_id} shell {shell_cmd}",
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.DEVNULL,
timeout=timeout_seconds,
text=True,
encoding="utf-8",
errors="ignore",
)
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 ""
@staticmethod # type: ignore[misc]
def _escape_shell_double_quotes(text: str) -> str:
return str(text).replace("\\", "\\\\").replace('"', '\\"')
def set_clipboard_text(self, device_id: str, text: str) -> bool:
"""设置设备剪贴板文本(尽量支持中文)。
优先:Android 10+ 的 `cmd clipboard set`。
兜底:Clipper(若设备装了 clipper app)。
"""
t = str(text or "").strip()
if not t:
return False
# 1) cmd clipboard set "..."
esc = self._escape_shell_double_quotes(t)
if self._run_adb_shell(
device_id, f'cmd clipboard set "{esc}"', timeout_seconds=3.0
):
return True
# 2) Clipper broadcast: am broadcast -a clipper.set -e text "..."
if self._run_adb_shell(
device_id,
f'am broadcast -a clipper.set -e text "{esc}"',
timeout_seconds=3.0,
):
return True
return False
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")
# 仅做最小转义,避免破坏中文
t = (
t.replace("&", "\\&")
.replace("<", "\\<")
.replace(">", "\\>")
.replace("|", "\\|")
)
return self._run_adb_shell(
device_id,
f'input text "{self._escape_shell_double_quotes(t)}"',
timeout_seconds=5.0,
)
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:
# 兼容不同包名/组件名写法,优先匹配常见的 AdbIME
for cand in imes or []:
s = str(cand).strip()
ls = s.lower()
if "adbkeyboard" in ls and "adbime" in ls:
return s
for cand in imes or []:
s = str(cand).strip()
ls = s.lower()
if "adbkeyboard" in ls or "adbime" in ls:
return s
return ""
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 {ime}", timeout_seconds=2.5)
if self._run_adb_shell(device_id, f"ime set {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
esc = self._escape_shell_double_quotes(str(msg or ""))
# 这里不依赖 broadcast 的返回文本,只要命令成功执行就认为 ok
return self._run_adb_shell(
device_id, f'am broadcast -a {act} --es msg "{esc}"', timeout_seconds=3.0
)
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
return self._run_adb_shell(
device_id, f"am broadcast -a {act} --ei {k} {v}", timeout_seconds=3.0
)
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.sleep(0.35)
return success
finally:
# 尝试恢复原输入法,避免影响手动使用
if restore_prev and prev and prev != adb_ime:
# 再稍等一下,避免过早切回导致输入丢失
time.sleep(0.25)
self.restore_ime(device_id, prev)
def paste_text_at(self, device_id: str, x: int, y: int, text: str) -> bool:
"""最简单的“粘贴到输入框”方法。
流程:点击输入框获取焦点 -> 设置剪贴板 -> 发送 KEYCODE_PASTE(279)。
若剪贴板不可用则退化为 `adb shell input text`(中文可能不稳定)。
"""
t = str(text or "").strip()
if not t:
return False
# 先确保输入框获得焦点
try:
self.click(device_id, int(x), int(y))
time.sleep(0.2)
# 有些输入框第一次点不进,补一次轻点
self.click(device_id, int(x), int(y))
time.sleep(0.15)
except Exception:
pass
# 0) 优先:ADBKeyboard(如果已安装/可用)
# 说明:这一步不依赖剪贴板/粘贴菜单,通常对中文更稳定
try:
if self.input_text_adbkeyboard(device_id, t, restore_prev=False):
return True
except Exception:
pass
# 1) 优先:剪贴板 + 粘贴键
if self.set_clipboard_text(device_id, t):
# 给系统一点时间刷新剪贴板
time.sleep(0.15)
if self.paste_from_clipboard(device_id):
return True
# 2) 兜底:adb input text(中文可能不稳定)
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(
f"{self._adb()} -s {device_id} shell uiautomator dump {remote}",
shell=True,
stdout=subprocess.DEVNULL,
stderr=subprocess.DEVNULL,
timeout=2,
)
subprocess.run(
f'{self._adb()} -s {device_id} pull {remote} "{local_path}"',
shell=True,
stdout=subprocess.DEVNULL,
stderr=subprocess.DEVNULL,
timeout=2,
)
return os.path.exists(local_path)
except subprocess.TimeoutExpired:
return False
except Exception:
return False
@staticmethod # type: ignore[misc]
def _parse_bounds(bounds: str):
m = re.match(r"\[(\d+),(\d+)\]\[(\d+),(\d+)\]", str(bounds or ""))
if not m:
return None
x1, y1, x2, y2 = map(int, m.groups())
return x1, y1, x2, y2
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:
import path_config
local_path = path_config.get_window_dump_path()
except Exception:
import path_config
local_path = path_config.get_window_dump_path()
start = time.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.time() - start >= timeout_seconds:
return False
time.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:
import path_config
local_path = path_config.get_window_dump_path()
except Exception:
import path_config
local_path = path_config.get_window_dump_path()
start = time.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.time() - start >= timeout_seconds:
return False
time.sleep(0.2)