- Updated `config.json` to include new settings for `enable_ocr_mode1` and `fudai_template_match_threshold`. - Refactored `douyin_detection.py` to implement template matching for 福袋 detection, replacing the previous pixel-based method. - Improved error handling and logging for template matching operations. - Added GUI options for enabling OCR mode and adjusting template matching threshold. - Enhanced command-line interface to support new OCR and template matching parameters.
1641 lines
70 KiB
Python
1641 lines
70 KiB
Python
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
|
||
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
|
||
import time as time_module
|
||
|
||
# 外部完整版 fudai 逻辑所在的工作树路径,用于镜像 screenshot 给那边使用
|
||
_EXTERNAL_AXF_SCREENSHOT = r"C:\Users\12742\.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 _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 = None
|
||
self.ocr_type = None # 'easyocr' 或 'paddleocr'
|
||
if not str(os.environ.get("SKIP_OCR_INIT", "")).strip():
|
||
# 优先使用EasyOCR(更快),如果失败则回退到PaddleOCR
|
||
# 首先尝试EasyOCR
|
||
try:
|
||
devnull = open(os.devnull, "w")
|
||
with contextlib.redirect_stdout(devnull), contextlib.redirect_stderr(devnull):
|
||
import easyocr
|
||
# 只加载中文和英文,加快初始化速度
|
||
self.ocr = easyocr.Reader(['ch_sim', 'en'], gpu=False, verbose=False)
|
||
self.ocr_type = 'easyocr'
|
||
print("[OCR] 使用 EasyOCR(快速模式)")
|
||
try:
|
||
devnull.close()
|
||
except Exception:
|
||
pass
|
||
except Exception as e:
|
||
# EasyOCR初始化失败,回退到PaddleOCR
|
||
try:
|
||
devnull.close()
|
||
except Exception:
|
||
pass
|
||
try:
|
||
devnull = open(os.devnull, "w")
|
||
with contextlib.redirect_stdout(devnull), contextlib.redirect_stderr(devnull):
|
||
from paddleocr import PaddleOCR
|
||
self.ocr = PaddleOCR(
|
||
lang="ch",
|
||
ocr_version="PP-OCRv4",
|
||
use_doc_orientation_classify=False,
|
||
use_doc_unwarping=False,
|
||
use_textline_orientation=False,
|
||
)
|
||
self.ocr_type = 'paddleocr'
|
||
print("[OCR] EasyOCR不可用,使用 PaddleOCR(备选方案)")
|
||
print(f"[OCR] 提示:安装EasyOCR可提升速度,运行: pip install easyocr")
|
||
try:
|
||
devnull.close()
|
||
except Exception:
|
||
pass
|
||
except Exception:
|
||
# 若静默初始化失败,保留 None 并允许后续按需初始化,避免阻塞启动。
|
||
try:
|
||
devnull.close()
|
||
except Exception:
|
||
pass
|
||
self.ocr = None
|
||
self.ocr_type = None
|
||
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
|
||
# 优先尝试EasyOCR
|
||
try:
|
||
devnull = open(os.devnull, "w")
|
||
with contextlib.redirect_stdout(devnull), contextlib.redirect_stderr(devnull):
|
||
import easyocr
|
||
self.ocr = easyocr.Reader(['ch_sim', 'en'], gpu=False, verbose=False)
|
||
self.ocr_type = 'easyocr'
|
||
print("[OCR] 延迟初始化:使用 EasyOCR(快速模式)")
|
||
try:
|
||
devnull.close()
|
||
except Exception:
|
||
pass
|
||
except Exception:
|
||
# EasyOCR失败,回退到PaddleOCR
|
||
try:
|
||
devnull.close()
|
||
except Exception:
|
||
pass
|
||
try:
|
||
devnull = open(os.devnull, "w")
|
||
with contextlib.redirect_stdout(devnull), contextlib.redirect_stderr(devnull):
|
||
from paddleocr import PaddleOCR
|
||
self.ocr = PaddleOCR(
|
||
lang="ch",
|
||
ocr_version="PP-OCRv4",
|
||
use_doc_orientation_classify=False,
|
||
use_doc_unwarping=False,
|
||
use_textline_orientation=False,
|
||
)
|
||
self.ocr_type = 'paddleocr'
|
||
print("[OCR] 延迟初始化:使用 PaddleOCR(备选方案)")
|
||
try:
|
||
devnull.close()
|
||
except Exception:
|
||
pass
|
||
except Exception:
|
||
try:
|
||
devnull.close()
|
||
except Exception:
|
||
pass
|
||
self.ocr = None
|
||
self.ocr_type = None
|
||
|
||
def select_device(self):
|
||
"""选择需要连接的设备"""
|
||
string = subprocess.Popen(f'{self._adb()} devices', shell=True, stdout=subprocess.PIPE)
|
||
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)
|
||
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
|
||
"""
|
||
base_dir = os.path.dirname(__file__)
|
||
pic_base = os.path.join(base_dir, 'pic')
|
||
|
||
# 运行时必需文件始终在根目录(不需要移动)
|
||
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图片文件:优先查找新位置(ocr/),然后查找旧位置(根目录)
|
||
if for_reading:
|
||
# 读取:先查新位置,再查旧位置(向后兼容)
|
||
new_path = os.path.join(pic_base, 'ocr', f'{picname}.png')
|
||
if os.path.exists(new_path):
|
||
return new_path
|
||
old_path = os.path.join(pic_base, f'{picname}.png')
|
||
if os.path.exists(old_path):
|
||
return old_path
|
||
return None
|
||
else:
|
||
# 写入:使用新位置,确保目录存在
|
||
ocr_dir = os.path.join(pic_base, 'ocr')
|
||
os.makedirs(ocr_dir, exist_ok=True)
|
||
return os.path.join(ocr_dir, f'{picname}.png')
|
||
|
||
def get_screenshot(self, device_id, path='pic'):
|
||
"""截图3个adb命令需要2S左右的时间"""
|
||
if path == 'pic':
|
||
out_dir = os.path.join(os.path.dirname(__file__), 'pic')
|
||
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)
|
||
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):
|
||
out_dir = os.path.join(os.path.dirname(__file__), 'pic')
|
||
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}")
|
||
|
||
pic.crop((left, top, right, bottom)).save(cut_pic_path)
|
||
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
|
||
|
||
pic.crop((left, top, right, bottom)).save(cut_pic_path)
|
||
return True
|
||
|
||
except (SyntaxError, IOError, OSError, FileNotFoundError, ValueError) as e:
|
||
# 最后一次尝试失败,打印错误信息
|
||
if attempt == max_retries - 1:
|
||
error_msg = f"[错误] 裁剪图片失败 (尝试 {max_retries} 次): {e}"
|
||
print(error_msg)
|
||
print(f" 源文件: {pic1_path}")
|
||
print(f" 目标文件: {cut_pic_path if 'cut_pic_path' in locals() else 'N/A'}")
|
||
# 不抛出异常,返回 False 让调用者处理
|
||
return False
|
||
# 继续重试
|
||
continue
|
||
except Exception as e:
|
||
# 其他未知异常
|
||
if attempt == max_retries - 1:
|
||
print(f"[错误] 裁剪图片时发生未知错误: {e}")
|
||
return False
|
||
continue
|
||
|
||
return False
|
||
|
||
def analyse_pic_word(self, picname='', change_color=0):
|
||
"""识别图像中的文字, change_color=1或2为不同的二值化模式,其他不做处理
|
||
|
||
性能优化:
|
||
- 添加文件存在性检查,避免打开不存在的文件
|
||
- 优化图片加载和预处理流程
|
||
"""
|
||
self._ensure_ocr()
|
||
if self.ocr is None:
|
||
return ''
|
||
|
||
if picname == '':
|
||
# cut.png 始终在根目录
|
||
path = os.path.dirname(__file__) + '/pic'
|
||
pic_path = path + '/cut.png'
|
||
else:
|
||
# 使用新的路径查找方法(支持新旧位置)
|
||
pic_path = self._find_pic_path(picname, for_reading=True)
|
||
if not pic_path:
|
||
return ''
|
||
|
||
# 检查文件是否存在
|
||
if not os.path.exists(pic_path):
|
||
return ''
|
||
|
||
try:
|
||
img = Image.open(pic_path)
|
||
# 检查图片是否有效
|
||
img.verify()
|
||
img = Image.open(pic_path) # 重新打开,因为verify后需要重新打开
|
||
except (IOError, OSError, Image.UnidentifiedImageError) as e:
|
||
return ''
|
||
|
||
# 福袋内容/倒计时属于手机 UI 字体,强二值化容易把细节打没,默认保持彩色。
|
||
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')
|
||
|
||
# 性能优化:先用原尺寸跑一次 OCR;只有识别为空时才放大重试。
|
||
w, h = img.size
|
||
# 优化:对于很小的图片,直接放大,避免浪费一次OCR调用
|
||
# 提高阈值:对于UI文字(如"直播广场"),即使是172x58这样稍大的尺寸也需要放大
|
||
if max(w, h) < 200:
|
||
try:
|
||
scale = max(2, 300 // max(w, h, 1)) # 至少放大到300像素,提高小文字识别率
|
||
img = img.resize((w * scale, h * scale), Image.BICUBIC)
|
||
w, h = img.size
|
||
except Exception:
|
||
pass
|
||
|
||
# 识别精度优化:增强图片预处理
|
||
# 1. 使用增强锐化(UnsharpMask效果更好)
|
||
from PIL import ImageEnhance
|
||
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 # 小图片增强25%对比度
|
||
img_enhanced = enhancer.enhance(contrast_factor)
|
||
img1 = img_enhanced
|
||
except Exception:
|
||
# 如果增强失败,回退到原来的锐化
|
||
img1 = img.filter(ImageFilter.SHARPEN)
|
||
|
||
img_np = np.array(img1)
|
||
|
||
# 根据OCR类型调用不同的识别方法
|
||
# 如果没有设置ocr_type,默认使用PaddleOCR格式(向后兼容)
|
||
if getattr(self, 'ocr_type', None) == 'easyocr':
|
||
# EasyOCR: readtext返回格式为 [(bbox, text, confidence), ...]
|
||
result = self.ocr.readtext(img_np)
|
||
text = self.extract_ocr_content(result)
|
||
else:
|
||
# PaddleOCR: ocr返回格式为 [[...]] 或 [...]
|
||
result = self.ocr.ocr(img_np)
|
||
if result == [None]:
|
||
return ''
|
||
text = self.extract_ocr_content(result)
|
||
|
||
# 如果识别为空且图片较小,尝试放大重试(精度优化:使用更好的放大算法和增强处理)
|
||
img2 = None
|
||
text2 = None
|
||
if (not text) and max(w, h) <= 1200:
|
||
try:
|
||
# 使用LANCZOS重采样算法(更高质量的放大)
|
||
img2 = img.resize((w * 2, h * 2), Image.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_enhanced = enhancer.enhance(1.2) # 放大后增强20%对比度
|
||
img2 = img2_enhanced
|
||
except Exception:
|
||
img2 = img2.filter(ImageFilter.SHARPEN)
|
||
|
||
if getattr(self, 'ocr_type', None) == 'easyocr':
|
||
result2 = self.ocr.readtext(np.array(img2))
|
||
text2 = self.extract_ocr_content(result2)
|
||
if text2:
|
||
text = text2
|
||
result = result2
|
||
else:
|
||
result2 = self.ocr.ocr(np.array(img2))
|
||
if result2 != [None]:
|
||
text2 = self.extract_ocr_content(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
|
||
|
||
# 如果OCR识别成功(返回非空文本),保存一份图片到ocr文件夹(与cut_pic保存的图片区分开)
|
||
if text and text.strip() and picname:
|
||
try:
|
||
# 使用_find_pic_path获取ocr文件夹路径(写入模式)
|
||
base_dir = os.path.dirname(__file__)
|
||
pic_base = os.path.join(base_dir, 'pic')
|
||
ocr_dir = os.path.join(pic_base, 'ocr')
|
||
os.makedirs(ocr_dir, exist_ok=True)
|
||
|
||
# 保存文件名:{picname}_success.png,与cut_pic保存的{picname}.png区分开
|
||
success_path = os.path.join(ocr_dir, f'{picname}_success.png')
|
||
|
||
# 保存识别成功时的图片(使用预处理后的图片,即实际用于OCR的图片)
|
||
try:
|
||
# 如果使用了放大后的图片且识别成功,保存放大后的图片
|
||
if img2 is not None and text2 and text2.strip():
|
||
img_to_save = img2
|
||
else:
|
||
# 否则保存预处理后的图片(img1)
|
||
img_to_save = img1
|
||
img_to_save.save(success_path)
|
||
except Exception:
|
||
# 如果保存预处理后的图片失败,保存原始图片
|
||
try:
|
||
img.save(success_path)
|
||
except Exception:
|
||
pass
|
||
except Exception:
|
||
# 保存失败不影响OCR识别结果
|
||
pass
|
||
|
||
return text
|
||
|
||
def extract_ocr_content(self, content=[]):
|
||
"""对OCR识别到的内容进行取值和拼接,变成完整的一段内容"""
|
||
ocr_result = content
|
||
|
||
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 ""
|
||
|
||
# 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
|
||
|
||
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]))
|
||
return ''.join([t[2] for t in extracted_items])
|
||
|
||
def delay(self, seconds=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) -> int | None:
|
||
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=200):
|
||
"""划动屏幕"""
|
||
os.system("{} -s {} shell input swipe {} {} {} {} {}".format(self._adb(), device_id, left_up_x, left_up_y, right_down_x, right_down_y, steps))
|
||
|
||
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
|
||
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
|
||
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
|
||
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
|
||
|
||
local_path = os.path.join(os.path.dirname(__file__), "pic", "window_dump.xml")
|
||
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 含“关闭/退出/返回”。
|
||
如果没有文字,就在顶部区域按“最像关闭”的位置进行启发式选择。
|
||
"""
|
||
local_path = os.path.join(os.path.dirname(__file__), "pic", "window_dump.xml")
|
||
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)
|
||
|