621 lines
23 KiB
Python
621 lines
23 KiB
Python
"""gui_core - gui_app / web_gui / webgui_launcher 共享后端。
|
||
|
||
历史巨型文件(1594 行)已部分拆出到 ``gui.gui_core_pkg``:
|
||
- adb / wifi_adb / config / run_params
|
||
|
||
本文件保留 Runner 巨型类(1164 行,13 个实例方法 + self 状态),
|
||
其他符号通过 from-import 暴露,外部 from gui.gui_core import X 兼容。
|
||
"""
|
||
from __future__ import annotations
|
||
|
||
import json
|
||
import os
|
||
import queue
|
||
import re
|
||
import shutil
|
||
import subprocess
|
||
import sys
|
||
import threading
|
||
import time
|
||
from dataclasses import dataclass
|
||
from typing import Optional
|
||
|
||
from douyin.core import path_config
|
||
from gui.process_pause import resume_process_tree, suspend_process_tree
|
||
|
||
# 从子包 re-export 顶层符号(保持兼容)
|
||
from gui.gui_core_pkg import (
|
||
CONFIG_PATH,
|
||
RunParams,
|
||
auto_connect_wifi_adb,
|
||
connect_wifi_adb,
|
||
disconnect_wifi_adb,
|
||
enable_wifi_adb,
|
||
find_adb_executable,
|
||
get_connected_wifi_devices,
|
||
get_device_ip,
|
||
is_device_wifi_connected,
|
||
list_adb_devices,
|
||
read_config,
|
||
resolve_adb_device,
|
||
write_config,
|
||
)
|
||
|
||
|
||
class Runner:
|
||
def __init__(self, on_line):
|
||
self._proc: Optional[subprocess.Popen] = None
|
||
self._on_line = on_line
|
||
self._reader_thread: Optional[threading.Thread] = None
|
||
self._lock = threading.Lock()
|
||
self._log: list[str] = []
|
||
self._log_capacity: int = 4000
|
||
|
||
# 统计相关
|
||
self._start_ts: Optional[float] = None
|
||
self._last_log_ts: Optional[float] = None
|
||
self._exit_code: Optional[int] = None
|
||
self._pid: Optional[int] = None
|
||
self._paused: bool = False
|
||
self._counters: dict[str, int] = {}
|
||
self._fudai_last: dict[str, object] = {
|
||
"content": "",
|
||
"countdown": "",
|
||
"participants": None,
|
||
"copies": None,
|
||
"prize_value_yuan": None,
|
||
"updated_ts": None,
|
||
}
|
||
self._events: list[dict] = []
|
||
self._events_cap: int = 5000
|
||
self._wins: list[dict] = []
|
||
self._wins_cap: int = 200
|
||
# 唯一计数去重集合(用于展示“唯一成功次数”口径)
|
||
self._unique_keys_seen: set[str] = set()
|
||
self._unique_keys_open: set[str] = set()
|
||
self._unique_keys_attend: set[str] = set()
|
||
# 当前直播间位置(从日志中解析),用于按直播间去重统计
|
||
self._current_room_pos: int | None = None
|
||
# 按直播间去重集合(优先使用 room_pos;若不可用则回退到 content/prize/countdown key)
|
||
self._fudai_seen_room_pos: set[int] = set()
|
||
self._fudai_open_room_pos: set[int] = set()
|
||
self._fudai_attend_ok_room_pos: set[int] = set()
|
||
self._fudai_attend_fail_room_pos: set[int] = set()
|
||
|
||
# 已记录福袋识别的跟踪(避免同一个直播间同一个福袋重复记录识别次数)
|
||
self._recorded_fudai_seen: set[tuple[str, str]] = (
|
||
set()
|
||
) # (room_title, fudai_content)
|
||
|
||
def is_running(self) -> bool:
|
||
return self._proc is not None and self._proc.poll() is None
|
||
|
||
def is_paused(self) -> bool:
|
||
with self._lock:
|
||
return bool(self._paused and self._proc is not None and self._proc.poll() is None)
|
||
|
||
def _append_log_line(self, line: str) -> None:
|
||
if line is None:
|
||
return
|
||
with self._lock:
|
||
self._log.append(line)
|
||
cap = self._log_capacity
|
||
if cap > 0 and len(self._log) > cap:
|
||
del self._log[: len(self._log) - cap]
|
||
|
||
def _emit_line(self, line: str) -> None:
|
||
self._append_log_line(line)
|
||
self._on_line(line)
|
||
|
||
def _inc(self, key: str, n: int = 1) -> None:
|
||
with self._lock:
|
||
self._counters[key] = int(self._counters.get(key, 0)) + int(n)
|
||
|
||
def _record_event(self, typ: str, meta: Optional[dict] = None) -> None:
|
||
ev = {
|
||
"ts": time.time(),
|
||
"type": str(typ),
|
||
"meta": meta or {},
|
||
}
|
||
with self._lock:
|
||
self._events.append(ev)
|
||
if len(self._events) > self._events_cap:
|
||
self._events = self._events[-self._events_cap :]
|
||
|
||
def _make_unique_key(self) -> str:
|
||
"""根据当前 snapshot 生成一个尽可能稳定的唯一键(用于去重)。
|
||
|
||
使用 content/prize_value/countdown 三元组,如果不可用则返回空字符串。
|
||
"""
|
||
try:
|
||
with self._lock:
|
||
content = self._fudai_last.get("content") or ""
|
||
prize = str(self._fudai_last.get("prize_value_yuan") or "")
|
||
countdown = str(self._fudai_last.get("countdown") or "")
|
||
key = f"{content}|{prize}|{countdown}"
|
||
return key
|
||
except Exception:
|
||
return ""
|
||
|
||
def _record_win(self) -> None:
|
||
item = {
|
||
"ts": time.time(),
|
||
**self._snapshot_fudai(),
|
||
}
|
||
with self._lock:
|
||
self._wins.append(item)
|
||
if len(self._wins) > self._wins_cap:
|
||
self._wins = self._wins[-self._wins_cap :]
|
||
|
||
def _snapshot_fudai(self) -> dict:
|
||
with self._lock:
|
||
return {
|
||
"content": self._fudai_last.get("content") or "",
|
||
"countdown": self._fudai_last.get("countdown") or "",
|
||
"participants": self._fudai_last.get("participants"),
|
||
"copies": self._fudai_last.get("copies"),
|
||
"prize_value_yuan": self._fudai_last.get("prize_value_yuan"),
|
||
}
|
||
|
||
def _update_stats_from_line(self, line: str) -> None:
|
||
"""委托到 gui/gui_core_pkg/stats_log_parser.update_stats_from_line。"""
|
||
from gui.gui_core_pkg.stats_log_parser import update_stats_from_line
|
||
update_stats_from_line(self, line)
|
||
|
||
def get_stats(self) -> dict:
|
||
with self._lock:
|
||
running = self._proc is not None and self._proc.poll() is None
|
||
pid = self._pid
|
||
start_ts = self._start_ts
|
||
last_log_ts = self._last_log_ts
|
||
exit_code = self._exit_code
|
||
paused = bool(self._paused and self._proc is not None and self._proc.poll() is None)
|
||
counters = dict(self._counters)
|
||
fudai_last = dict(self._fudai_last)
|
||
wins = list(self._wins[-20:]) # 只返回最近20条
|
||
events = list(self._events[-1000:]) # 返回最近1000条事件用于统计
|
||
|
||
now = time.time()
|
||
uptime = 0
|
||
if start_ts and start_ts > 0:
|
||
uptime = int(max(0, now - start_ts))
|
||
|
||
return {
|
||
"running": bool(running),
|
||
"paused": paused,
|
||
"pid": pid,
|
||
"start_ts": start_ts,
|
||
"last_log_ts": last_log_ts,
|
||
"exit_code": exit_code,
|
||
"uptime_seconds": uptime,
|
||
"counters": counters,
|
||
"fudai_last": fudai_last,
|
||
"wins": wins,
|
||
"events": events,
|
||
}
|
||
|
||
def start(self, params: RunParams) -> None:
|
||
if self.is_running():
|
||
raise RuntimeError("已经在运行")
|
||
|
||
# 如果 wait_minutes=0,表示无限循环模式
|
||
wait_minutes_arg = str(params.wait_minutes) if params.wait_minutes > 0 else "0"
|
||
run_cli_cmd = path_config.get_run_cli_command()
|
||
run_cli_path = run_cli_cmd[-1] if run_cli_cmd else path_config.get_run_cli_path()
|
||
if not os.path.exists(run_cli_path):
|
||
raise FileNotFoundError(
|
||
f"未找到 run_cli 启动文件。\n"
|
||
f"预期路径: {run_cli_path}\n"
|
||
f"请确保 run_cli.py 位于源码项目,或 run_cli.exe 位于安装目录。"
|
||
)
|
||
cmd = [
|
||
*run_cli_cmd,
|
||
"--y-pianyi",
|
||
str(params.y_pianyi),
|
||
"--wait-minutes",
|
||
wait_minutes_arg,
|
||
]
|
||
if params.device_id:
|
||
cmd += ["--device-id", params.device_id]
|
||
if params.needswitch:
|
||
cmd.append("--needswitch")
|
||
|
||
cmd += ["--min-prize-value-yuan", str(params.min_prize_value_yuan)]
|
||
|
||
# 这些参数是新增可调节项:倒计时太短跳过、参与人数范围
|
||
cmd += [
|
||
"--skip-if-countdown-gt-seconds",
|
||
str(int(params.skip_if_countdown_gt_seconds or 900)),
|
||
]
|
||
if params.reset_after_swipes_enabled:
|
||
cmd.append("--reset-after-swipes-enabled")
|
||
cmd += ["--reset-after-swipes", str(int(params.reset_after_swipes or 10))]
|
||
else:
|
||
cmd.append("--reset-after-swipes-disabled")
|
||
if int(params.min_participants or 0) > 0:
|
||
cmd += ["--min-participants", str(int(params.min_participants))]
|
||
if int(params.max_participants or 0) > 0:
|
||
cmd += ["--max-participants", str(int(params.max_participants))]
|
||
|
||
if params.auto_join_fansclub:
|
||
cmd.append("--auto-join-fansclub")
|
||
if params.fansclub_fail_action:
|
||
cmd += ["--fansclub-fail-action", params.fansclub_fail_action]
|
||
|
||
# 高价值直播间回访
|
||
if params.high_value_room_revisit_enabled:
|
||
cmd.append("--high-value-room-revisit-enabled")
|
||
else:
|
||
cmd.append("--high-value-room-revisit-disabled")
|
||
if params.high_value_room_revisit_only_current_run:
|
||
cmd.append("--high-value-room-revisit-only-current-run")
|
||
if params.high_value_room_revisit_min_interval_seconds != 300:
|
||
cmd += [
|
||
"--high-value-room-revisit-min-interval-seconds",
|
||
str(params.high_value_room_revisit_min_interval_seconds),
|
||
]
|
||
if params.high_value_room_revisit_max_per_run != 5:
|
||
cmd += [
|
||
"--high-value-room-revisit-max-per-run",
|
||
str(params.high_value_room_revisit_max_per_run),
|
||
]
|
||
if params.high_value_room_revisit_min_prize_value > 0:
|
||
cmd += [
|
||
"--high-value-room-revisit-min-prize-value",
|
||
str(params.high_value_room_revisit_min_prize_value),
|
||
]
|
||
if params.high_value_room_revisit_max_age_days != 30:
|
||
cmd += [
|
||
"--high-value-room-revisit-max-age-days",
|
||
str(params.high_value_room_revisit_max_age_days),
|
||
]
|
||
|
||
# 预约回退校验
|
||
if params.reservation_back_verify_enabled:
|
||
cmd.append("--reservation-back-verify-enabled")
|
||
else:
|
||
cmd.append("--reservation-back-verify-disabled")
|
||
if params.reservation_back_swipe_delay > 0:
|
||
cmd += [
|
||
"--reservation-back-swipe-delay",
|
||
str(params.reservation_back_swipe_delay),
|
||
]
|
||
|
||
# 找福袋最大尝试次数
|
||
if params.fudai_find_max_attempts > 0:
|
||
cmd += ["--fudai-find-max-attempts", str(params.fudai_find_max_attempts)]
|
||
|
||
# OCR模式1开关
|
||
if params.enable_ocr_mode1:
|
||
cmd.append("--enable-ocr-mode1")
|
||
else:
|
||
cmd.append("--disable-ocr-mode1")
|
||
|
||
# 福袋模板匹配开关
|
||
if params.fudai_template_match_enabled:
|
||
cmd.append("--fudai-template-enabled")
|
||
else:
|
||
cmd.append("--fudai-template-disabled")
|
||
|
||
# 添加福袋模板匹配阈值参数
|
||
cmd.extend(
|
||
["--fudai-template-threshold", str(params.fudai_template_match_threshold)]
|
||
)
|
||
|
||
# 启用/禁用 达到连续未找到福袋阈值时按返回键回退
|
||
if getattr(params, "enable_back_on_misses", True):
|
||
cmd.append("--enable-back-on-misses")
|
||
else:
|
||
cmd.append("--disable-back-on-misses")
|
||
# 确保从 GUI 启动时传递回退方式(若启用返回键回退,则将 reset action 设为 back)
|
||
try:
|
||
if getattr(params, "enable_back_on_misses", False):
|
||
cmd += ["--reset-after-swipes-action", "back"]
|
||
except Exception:
|
||
pass
|
||
|
||
# 只养号模式:如果启用则传递到 run_cli.py
|
||
try:
|
||
if getattr(params, "yanghao_only", False):
|
||
cmd.append("--yanghao-only")
|
||
# 若指定时长,传给 --yanghao-seconds
|
||
if int(getattr(params, "yanghao_seconds", 0) or 0) > 0:
|
||
cmd += ["--yanghao-seconds", str(int(params.yanghao_seconds))]
|
||
except Exception:
|
||
# 忽略,保证兼容旧参数集合
|
||
pass
|
||
|
||
# 继承当前环境,并确保 adb 在 PATH(即使用户没手动刷新 PATH)
|
||
env = os.environ.copy()
|
||
env.setdefault("PYTHONIOENCODING", "utf-8")
|
||
|
||
adb_exe = find_adb_executable()
|
||
if adb_exe:
|
||
adb_dir = os.path.dirname(adb_exe)
|
||
env["PATH"] = adb_dir + os.pathsep + env.get("PATH", "")
|
||
env["ADB_EXECUTABLE"] = adb_exe
|
||
else:
|
||
self._emit_line(
|
||
"[警告] 未找到 adb.exe:请安装 platform-tools 或将 adb 加入 PATH"
|
||
)
|
||
|
||
# Resolve the device before spawning run_cli so background runs never block
|
||
# on the interactive select_device() prompt.
|
||
try:
|
||
resolved_device_id = resolve_adb_device(adb_exe, params.device_id)
|
||
try:
|
||
i = cmd.index("--device-id")
|
||
if i + 1 < len(cmd):
|
||
cmd[i + 1] = resolved_device_id
|
||
except ValueError:
|
||
cmd += ["--device-id", resolved_device_id]
|
||
except Exception as e:
|
||
self._emit_line(f"[错误] 设备选择失败: {e}")
|
||
raise
|
||
|
||
# 进入直播间坐标模式:从最新配置读取,避免扩展 RunParams 字段影响现有调用方
|
||
try:
|
||
cfg_now = read_config() or {}
|
||
reenter_mode = str(
|
||
cfg_now.get("reenter_live_entry_mode", "follow_list") or "follow_list"
|
||
).strip().lower()
|
||
if reenter_mode in ("follow_list", "screen_center"):
|
||
cmd += ["--reenter-live-entry-mode", reenter_mode]
|
||
except Exception:
|
||
pass
|
||
|
||
try:
|
||
p = subprocess.Popen(
|
||
cmd,
|
||
stdout=subprocess.PIPE,
|
||
stderr=subprocess.STDOUT,
|
||
text=True,
|
||
encoding="utf-8",
|
||
errors="replace",
|
||
env=env,
|
||
cwd=path_config.PROJECT_ROOT,
|
||
)
|
||
except FileNotFoundError as e:
|
||
raise RuntimeError(
|
||
f"无法启动进程:找不到 run_cli 启动文件\n"
|
||
f"run_cli路径: {run_cli_path}\n"
|
||
f"原始错误: {e}"
|
||
) from e
|
||
except Exception as e:
|
||
raise RuntimeError(
|
||
f"启动进程失败:{e}\n"
|
||
f"命令: {' '.join(cmd)}\n"
|
||
f"工作目录: {path_config.PROJECT_ROOT}"
|
||
) from e
|
||
|
||
with self._lock:
|
||
self._proc = p
|
||
self._pid = p.pid
|
||
self._paused = False
|
||
self._start_ts = time.time()
|
||
self._exit_code = None
|
||
self._last_log_ts = time.time()
|
||
self._counters = {}
|
||
self._fudai_last = {
|
||
"content": "",
|
||
"countdown": "",
|
||
"participants": None,
|
||
"copies": None,
|
||
"prize_value_yuan": None,
|
||
"updated_ts": None,
|
||
}
|
||
self._events = []
|
||
self._wins = []
|
||
self._log = []
|
||
|
||
def _reader():
|
||
assert self._proc is not None
|
||
out = self._proc.stdout
|
||
if out is None:
|
||
return
|
||
try:
|
||
# 读取所有输出
|
||
has_output = False
|
||
for line in out:
|
||
has_output = True
|
||
cleaned_line = line.rstrip("\n")
|
||
self._emit_line(cleaned_line)
|
||
try:
|
||
self._update_stats_from_line(cleaned_line)
|
||
except Exception:
|
||
pass
|
||
|
||
# 等待进程结束
|
||
rc = self._proc.wait()
|
||
with self._lock:
|
||
self._exit_code = rc
|
||
self._paused = False
|
||
|
||
# 如果进程立即退出且没有输出,说明可能有问题
|
||
if not has_output and rc != 0:
|
||
self._emit_line(f"[警告] 进程立即退出,退出码={rc},没有输出")
|
||
self._emit_line(
|
||
"[提示] 可能的原因:run_cli.py启动失败、导入错误或配置错误"
|
||
)
|
||
else:
|
||
self._emit_line(f"[进程结束] exit_code={rc}")
|
||
except Exception as e:
|
||
# 读取输出时出错
|
||
try:
|
||
self._emit_line(f"[错误] 读取进程输出失败: {e}")
|
||
rc = self._proc.poll()
|
||
if rc is not None:
|
||
with self._lock:
|
||
self._exit_code = rc
|
||
self._paused = False
|
||
self._emit_line(f"[进程结束] exit_code={rc}")
|
||
except Exception:
|
||
pass
|
||
|
||
self._reader_thread = threading.Thread(target=_reader, daemon=True)
|
||
self._reader_thread.start()
|
||
|
||
# (已移除) 测试养号启动器
|
||
|
||
# (已移除) 测试评论启动器
|
||
|
||
def send_back_key(self, device_id: str) -> bool:
|
||
"""手动发送返回键到指定设备。
|
||
|
||
Args:
|
||
device_id: 设备ID,如果为空则仅在单设备在线时自动使用该设备
|
||
|
||
Returns:
|
||
True if successful, False otherwise
|
||
"""
|
||
try:
|
||
adb_exe = find_adb_executable()
|
||
if not adb_exe:
|
||
self._emit_line("[错误] 未找到 adb.exe")
|
||
return False
|
||
|
||
if not device_id or device_id.strip() == "":
|
||
try:
|
||
device_id = resolve_adb_device(adb_exe)
|
||
except Exception as e:
|
||
self._emit_line(f"[错误] 设备选择失败: {e}")
|
||
return False
|
||
|
||
# 发送返回键 (keyevent 4)
|
||
cmd = [adb_exe, "-s", device_id, "shell", "input", "keyevent", "4"]
|
||
proc = subprocess.run(
|
||
cmd,
|
||
capture_output=True,
|
||
text=True,
|
||
encoding="utf-8",
|
||
errors="replace",
|
||
timeout=5.0,
|
||
check=False,
|
||
)
|
||
|
||
if proc.returncode == 0:
|
||
self._emit_line(f"[手动操作] 已发送返回键到设备: {device_id}")
|
||
return True
|
||
else:
|
||
error_msg = proc.stderr or proc.stdout or "未知错误"
|
||
self._emit_line(f"[错误] 发送返回键失败: {error_msg}")
|
||
return False
|
||
except subprocess.TimeoutExpired:
|
||
self._emit_line("[错误] 发送返回键超时")
|
||
return False
|
||
except Exception as e:
|
||
self._emit_line(f"[错误] 发送返回键异常: {str(e)}")
|
||
return False
|
||
|
||
def pause(self) -> bool:
|
||
with self._lock:
|
||
proc = self._proc
|
||
pid = self._pid or (proc.pid if proc is not None else None)
|
||
already_paused = self._paused
|
||
if proc is None or proc.poll() is not None or not pid:
|
||
self._emit_line("[暂停] 当前没有正在运行的进程")
|
||
with self._lock:
|
||
self._paused = False
|
||
return False
|
||
if already_paused:
|
||
self._emit_line("[暂停] 当前已经是暂停状态")
|
||
return True
|
||
try:
|
||
suspend_process_tree(int(pid))
|
||
with self._lock:
|
||
self._paused = True
|
||
self._emit_line("[暂停] 已暂停运行进程")
|
||
return True
|
||
except Exception as e:
|
||
self._emit_line(f"[暂停] 暂停失败: {e}")
|
||
return False
|
||
|
||
def resume(self) -> bool:
|
||
with self._lock:
|
||
proc = self._proc
|
||
pid = self._pid or (proc.pid if proc is not None else None)
|
||
already_paused = self._paused
|
||
if proc is None or proc.poll() is not None or not pid:
|
||
self._emit_line("[继续] 当前没有可恢复的运行进程")
|
||
with self._lock:
|
||
self._paused = False
|
||
return False
|
||
if not already_paused:
|
||
self._emit_line("[继续] 当前不在暂停状态")
|
||
return True
|
||
try:
|
||
resume_process_tree(int(pid))
|
||
with self._lock:
|
||
self._paused = False
|
||
self._emit_line("[继续] 已恢复运行进程")
|
||
return True
|
||
except Exception as e:
|
||
self._emit_line(f"[继续] 恢复失败: {e}")
|
||
return False
|
||
|
||
def stop(self) -> None:
|
||
if not self.is_running():
|
||
return
|
||
assert self._proc is not None
|
||
if self.is_paused():
|
||
self.resume()
|
||
self._emit_line("[停止] 正在终止进程...")
|
||
self._proc.terminate()
|
||
try:
|
||
self._proc.wait(timeout=5)
|
||
except subprocess.TimeoutExpired:
|
||
self._emit_line("[停止] 进程未退出,强制结束...")
|
||
self._proc.kill()
|
||
|
||
def force_stop(self) -> None:
|
||
"""更强硬的停止:直接杀掉已记录的 PID 及其子进程(主要针对 Windows 下残留进程)。"""
|
||
with self._lock:
|
||
pid = self._pid
|
||
proc = self._proc
|
||
if not pid and not proc:
|
||
self._emit_line("[停止] 当前无记录中的运行进程")
|
||
return
|
||
|
||
self._emit_line(f"[停止] 强制终止进程 (pid={pid}) ...")
|
||
|
||
if self.is_paused() and pid:
|
||
try:
|
||
resume_process_tree(int(pid))
|
||
except Exception:
|
||
pass
|
||
|
||
# 先尝试通过 Popen 对象 kill
|
||
try:
|
||
if proc is not None and proc.poll() is None:
|
||
proc.kill()
|
||
except Exception:
|
||
pass
|
||
|
||
# 再通过系统命令清理可能残留的子进程
|
||
if pid:
|
||
try:
|
||
if os.name == "nt":
|
||
# Windows:使用 taskkill 结束进程树
|
||
subprocess.run(
|
||
["taskkill", "/PID", str(pid), "/T", "/F"],
|
||
stdout=subprocess.DEVNULL,
|
||
stderr=subprocess.DEVNULL,
|
||
check=False,
|
||
)
|
||
else:
|
||
# 类 Unix:尝试向进程组发送 SIGKILL
|
||
import signal
|
||
|
||
try:
|
||
os.kill(pid, signal.SIGKILL)
|
||
except AttributeError:
|
||
# 如果SIGKILL不存在,使用SIGTERM
|
||
os.kill(pid, signal.SIGTERM)
|
||
except Exception:
|
||
pass
|
||
|
||
with self._lock:
|
||
self._proc = None
|
||
self._pid = None
|
||
self._paused = False
|