Files
douyi_guaji_main/gui/gui_app.py
T
CodexandClaude Sonnet 4.5 b1fa6af9ce fix(gui): 修复启动后 GUI 卡死约 1.2 秒
delayed_refresh_preview 在 mainloop 启动 300ms 后同步加载大图(PIL
Image.open + load + convert),阻塞主线程。改为:
1. 延迟到 3 秒后再触发预览(GUI 已完全初始化)
2. 图片加载放到后台线程,完成后通过 root.after 回主线程更新

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>
2026-05-23 21:58:50 +08:00

5477 lines
215 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 json
import logging
import os
import queue
import re
import sys
import threading
import warnings
from datetime import datetime
from typing import Any, Callable
# 确保项目根目录在 Python 路径中(支持直接运行 gui/gui_app.py)
_script_dir = os.path.dirname(os.path.abspath(__file__))
_project_root = os.path.dirname(_script_dir)
if _project_root not in sys.path:
sys.path.insert(0, _project_root)
from PIL import Image, ImageTk # type: ignore[import]
# 抽离:ADB/配置/参数结构体到 gui_core.py(便于后续模块化)
from gui.gui_core import (
RunParams,
Runner,
find_adb_executable,
list_adb_devices,
enable_wifi_adb,
connect_wifi_adb,
disconnect_wifi_adb,
get_device_ip,
auto_connect_wifi_adb,
is_device_wifi_connected,
get_connected_wifi_devices,
read_config,
write_config,
)
from gui.gui_core_pkg import (
DiscoveredDevice,
clear_last_wifi_target,
discover_adb_devices,
get_last_wifi_target,
get_local_subnet,
pick_best_match,
set_last_wifi_target,
)
from gui.gui_core_pkg.wifi_adb_scan import verify_adb_target, query_device_model
from douyin.core.path_config import get_logs_dir
from gui.components.mapping_table import create_mapping_tab
# 导入日志颜色配置模块
try:
from gui.components.log_color_config import (
get_color_config,
apply_operation_color,
get_operation_type,
)
except ImportError:
# 如果模块不存在,使用空函数作为回退
def get_color_config(theme: str = "litera"):
return {}
def apply_operation_color(*args, **kwargs):
pass
def get_operation_type(line: str) -> str | None:
return None
# 抑制 PyTorch DataLoader 的 pin_memory 警告(当没有 GPU 时,EasyOCR 会触发此警告)
warnings.filterwarnings("ignore", message=".*pin_memory.*", category=UserWarning)
warnings.filterwarnings("ignore", message=".*accelerator.*", category=UserWarning)
# 模块级 logger:内部"日志写入失败 / pump_logs 异常"等错误统一走 logging
_LOGGER = logging.getLogger("gui.gui_app")
def format_gui_log_line(line: str) -> str:
"""将完整日志行转换为 GUI 显示用的精简版本。
实际实现位于 gui.components.log_viewer,此处仅作 re-export,
失败时回退到原始字符串。
"""
try:
from gui.components.log_viewer import format_gui_log_line as _impl
return _impl(line)
except Exception:
return (line or "").rstrip("\n")
def main():
# 主题优先级:使用 config 中的 gui.theme(若有),否则使用默认明亮主题 'litera'
cfg_theme = "darkly"
try:
cfg_theme = read_config().get("gui", {}).get("theme", "litera") or "litera"
except Exception:
cfg_theme = "litera"
# ttkbootstrap 优先(更美观);没装则回退到原生 tkinter
try:
import ttkbootstrap as tb
from ttkbootstrap.scrolled import ScrolledText
import tkinter as tk
from tkinter import ttk
from ttkbootstrap.constants import LEFT, RIGHT, BOTH, X, Y
# 使用 config 中指定的主题名
root = tb.Window(themename=cfg_theme)
except Exception:
import tkinter as tk
from tkinter import ttk
from tkinter.constants import LEFT, RIGHT, BOTH, X, Y # type: ignore[assignment]
from tkinter.scrolledtext import ScrolledText
root = tk.Tk()
# 常量兜底:部分主题常量未提供时使用字符串
BOTTOM = "bottom"
# W 常量在部分导入路径中可能不存在,兜底为 'w'(grid sticky 使用)
W = "w"
root.title("抖音福袋挂机 - 可视化控制台")
root.geometry("1400x900") # 增大窗口尺寸,提供更多空间
q: queue.Queue[str] = queue.Queue()
# 线程安全的日志文件写入器(已抽到 gui/components/log_writer)
from gui.components.log_writer import ThreadSafeLogWriter
log_writer = ThreadSafeLogWriter()
# 日志格式化已移至模块级别函数 format_gui_log_line()
def on_line(line: str):
"""处理日志行:GUI 显示用精简版本,文件写入用完整版本"""
# GUI 显示:使用精简后的版本
try:
display_line = format_gui_log_line(line)
except Exception:
display_line = line
q.put(display_line)
# 文件:写入完整日志行(不做精简处理)
try:
log_writer.write(line)
except Exception:
pass # 文件写入失败不应影响GUI显示
runner = Runner(on_line=on_line)
# 顶部:设备选择 + Y偏移(其余运行参数放到左侧分组,避免重复)
top = ttk.Frame(root)
top.pack(fill=X, padx=12, pady=10)
adb_exe = find_adb_executable()
devices = list_adb_devices(adb_exe)
device_var = tk.StringVar(value=(devices[0] if devices else ""))
ttk.Label(top, text="设备:").pack(side=LEFT)
device_combo = ttk.Combobox(top, textvariable=device_var, values=devices, width=28)
device_combo.pack(side=LEFT, padx=(0, 10))
def refresh_devices():
nonlocal adb_exe
adb_exe = find_adb_executable()
devs = list_adb_devices(adb_exe)
device_combo["values"] = devs
if devs and not device_var.get():
device_var.set(devs[0])
if not adb_exe:
on_line("[设备] 未找到 adb.exe(请确认已安装 platform-tools)")
elif not devs:
on_line("[设备] adb 可用,但未发现 device 状态设备(可能未授权/未连接)")
def save_logging_config():
"""保存日志配置到配置文件"""
try:
# 读取当前配置
cfg = read_config()
# 更新日志相关配置
if "logging" not in cfg:
cfg["logging"] = {}
cfg["logging"]["log_format_mode"] = logging_format_mode_var.get()
cfg["logging"]["beautify_output"] = bool(logging_beautify_var.get())
cfg["logging"]["color_output"] = bool(logging_color_var.get())
cfg["logging"]["show_timestamps"] = bool(logging_show_timestamps_var.get())
cfg["logging"]["use_dated_logs"] = bool(logging_use_dated_logs_var.get())
cfg["logging"]["debug_detail_level"] = logging_debug_level_var.get()
cfg["logging"]["error_detail_level"] = logging_error_level_var.get()
cfg["logging"]["action_log_format"] = logging_action_format_var.get()
cfg["logging"]["enable_monitor"] = bool(logging_enable_monitor_var.get())
cfg["logging"]["keep_days"] = int(logging_keep_days_var.get())
cfg["logging"]["compress_logs"] = bool(logging_compress_logs_var.get())
cfg["logging"]["max_total_size_gb"] = float(
logging_max_total_size_gb_var.get()
)
cfg["logging"]["compress_after_days"] = int(
logging_compress_after_days_var.get()
)
cfg["logging"]["monitor_warning_mb"] = float(
logging_monitor_warning_mb_var.get()
)
cfg["logging"]["monitor_critical_mb"] = float(
logging_monitor_critical_mb_var.get()
)
cfg["logging"]["performance_tracking"] = {
"enabled": bool(logging_performance_enabled_var.get()),
"track_function_calls": bool(logging_track_functions_var.get()),
}
cfg["log_unified_enabled"] = bool(log_unified_enabled_var.get())
cfg["log_unified_path"] = str(log_unified_path_var.get() or "logs/unified.log")
# 更新GUI主题
if "gui" not in cfg:
cfg["gui"] = {}
cfg["gui"]["theme"] = gui_theme_var.get()
cfg["gui"]["realtime_status"] = {
"refresh_interval_ms": int(
gui_realtime_refresh_interval_ms_var.get() or 1000
),
"tail_items": int(gui_realtime_tail_items_var.get() or 50),
}
# 保存配置
write_config(cfg)
on_line("[配置] 日志配置已保存")
except Exception as e:
on_line(f"[配置] 保存日志配置失败:{e}")
refresh_devices_btn = ttk.Button(top, text="刷新设备", command=refresh_devices)
refresh_devices_btn.pack(side=LEFT, padx=(0, 8))
# 一键扫描局域网 ADB 设备并自动连接(同 WiFi 下设备已开 5555 / 已授权时无需 USB)
scan_connect_btn = ttk.Button(top, text="扫描 WiFi")
scan_connect_btn.pack(side=LEFT, padx=(0, 20))
_scan_busy = {"flag": False}
def _try_reconnect_last_wifi():
"""启动时若 adb devices 为空且配置里有 last_wifi_target,后台尝试重连。
策略:
1. 已经有可用设备:不打扰
2. 上次记录的 target 现在 verify_adb_target 成功 → 选中
3. verify 失败 → 自动扫描子网 + pick_best_match 智能匹配
4. 匹配上 → 选中,更新 last_wifi_target;匹配不上 → 日志提示
"""
last = {}
try:
last = get_last_wifi_target()
except Exception:
return
if not isinstance(last, dict) or not last.get("target"):
return
target = str(last.get("target"))
model = str(last.get("model") or "")
# 已经有设备时不打扰
try:
existing = list_adb_devices(adb_exe)
except Exception:
existing = []
if target in existing:
device_var.set(target)
on_line(f"[启动] WiFi 设备已在线: {target}" + (f" ({model})" if model else ""))
return
if existing:
on_line(
f"[启动] 当前已有设备 {existing[0]},上次 WiFi 目标 {target} 不抢占"
)
return
on_line(f"[启动] 尝试重连上次的 WiFi 设备: {target} ...")
def worker():
# 先直连
state, msg = "failed", ""
try:
state, msg = verify_adb_target(adb_exe, target)
except Exception as e:
msg = str(e)
if state == "connected":
def render_ok():
refresh_devices()
device_var.set(target)
on_line(
f"[启动] 自动重连成功: {target}"
+ (f" ({model})" if model else "")
)
root.after(0, render_ok)
return
if state == "unauthorized":
def render_unauth():
on_line(
f"[启动] 上次设备 {target} 未授权,请在手机上确认 ADB 调试"
)
root.after(0, render_unauth)
return
# state == "failed" → 不可达。换网了?自动扫一下,看能不能在新网段找到
def notify_scan_start():
on_line(
f"[启动] {target} 不可达,自动扫描局域网寻找匹配设备..."
)
root.after(0, notify_scan_start)
try:
# 如果上次记的端口非 5555,扫描时把它一起带上(覆盖 Android 11+ 随机端口)
last_port_int = 5555
if ":" in target:
try:
last_port_int = int(target.rsplit(":", 1)[1])
except ValueError:
pass
scan_ports = [5555] if last_port_int == 5555 else [5555, last_port_int]
devs = discover_adb_devices(adb_exe, ports=scan_ports)
except Exception as e:
def render_scan_err():
on_line(f"[启动] 自动扫描失败: {e}")
root.after(0, render_scan_err)
return
best = pick_best_match(devs, last)
def render_scan_done():
if best is None:
if devs:
targets_str = ", ".join(
f"{d.target}({d.adb_state})" for d in devs[:5]
)
on_line(
f"[启动] 扫描发现 {len(devs)} 台候选但无明确匹配: "
f"{targets_str}。请点'扫描 WiFi'手选"
)
else:
on_line(
f"[启动] 上次设备 {target} 不可达,扫描也未发现其它设备。"
f"请检查手机和电脑是否在同一 WiFi"
)
return
refresh_devices()
device_var.set(best.target)
# 更新记忆
try:
set_last_wifi_target(best.target, best.model or model)
except Exception:
pass
if best.target == target:
on_line(
f"[启动] 自动重连成功(扫描确认): {best.target}"
+ (f" ({best.model})" if best.model else "")
)
else:
on_line(
f"[启动] 上次目标 {target} 已变 → 智能匹配到 {best.target}"
+ (f" ({best.model})" if best.model else "")
+ "(已更新记忆)"
)
root.after(0, render_scan_done)
threading.Thread(target=worker, daemon=True).start()
# 启动时延迟一点,等界面创建完成再尝试重连
root.after(300, _try_reconnect_last_wifi)
def _on_scan_one_click():
"""主窗口"扫描 WiFi"按钮:后台扫描 → 按结果数智能处理。
- 0 个:日志提示
- 1 个 connected:自动设为当前设备并刷新
- 1 个 unauthorized:提示需要手机端授权
- 多个:弹简单的列表对话框让用户选
"""
if _scan_busy["flag"]:
on_line("[扫描] 上次扫描尚未完成,请稍候")
return
_scan_busy["flag"] = True
scan_connect_btn.config(state="disabled", text="扫描中...")
on_line("[扫描] 开始扫描局域网 ADB 设备...")
def worker():
try:
devs = discover_adb_devices(
adb_exe,
on_phase=lambda msg: on_line(f"[扫描] {msg}"),
)
except Exception as e:
on_line(f"[扫描] 异常: {e}")
devs = []
def render():
_scan_busy["flag"] = False
scan_connect_btn.config(state="normal", text="扫描 WiFi")
_handle_scan_result(devs)
try:
root.after(0, render)
except Exception:
pass
threading.Thread(target=worker, daemon=True).start()
def _handle_scan_result(devs):
if not devs:
on_line("[扫描] 未发现开放 5555 端口的设备(同 WiFi 下设备需先启用 ADB 调试)")
return
connected = [d for d in devs if d.adb_state == "connected"]
unauthorized = [d for d in devs if d.adb_state == "unauthorized"]
failed = [d for d in devs if d.adb_state == "failed"]
if len(connected) == 1 and not unauthorized:
d = connected[0]
refresh_devices()
device_var.set(d.target)
# 记住,下次启动自动重连
try:
set_last_wifi_target(d.target, d.model or "")
except Exception:
pass
on_line(
f"[扫描] 自动连接成功: {d.target}"
+ (f" ({d.model})" if d.model else "")
+ "(已记住,下次 GUI 启动会自动重连)"
)
return
if len(connected) == 0 and len(unauthorized) >= 1:
targets = ", ".join(d.target for d in unauthorized)
on_line(
f"[扫描] 发现 {len(unauthorized)} 个未授权设备: {targets}。"
f"请在手机上确认 ADB 调试授权(勾选'始终允许这台电脑调试'),然后再点'扫描 WiFi'"
)
return
if len(connected) == 0 and len(unauthorized) == 0 and failed:
# 端口开放但 adb connect 失败:通常是 adb 服务异常 / 设备处于诡异状态。
# 把 adb 真实返回拼出来,让用户看到根因,而不是误导地说"请授权"。
for d in failed:
msg = (d.message or "").strip().replace("\n", " | ")
on_line(f"[扫描] {d.target} 连接失败 (state=failed): {msg or '未知错误'}")
on_line(
"[扫描] 提示:可在终端跑 `adb kill-server && adb connect <ip:port>` 看真实输出,"
"或检查是否多个 adb 进程冲突"
)
return
# 多个候选 → 弹出选择对话框
_open_scan_pick_dialog(devs)
def _open_scan_pick_dialog(devs):
"""简化版选择对话框:扫描结果已就绪,让用户从列表挑一个使用。"""
pick_dlg = tk.Toplevel(root)
pick_dlg.title(f"扫描发现 {len(devs)} 台设备 - 请选择")
pick_dlg.geometry("680x320")
pick_dlg.transient(root)
ttk.Label(
pick_dlg,
text="扫描发现多台设备,请选中一个作为当前设备:",
font=("Arial", 9),
).pack(anchor=W, padx=10, pady=(10, 4))
cols = ("target", "state", "model", "message")
tree = ttk.Treeview(pick_dlg, columns=cols, show="headings", height=8)
tree.heading("target", text="IP:Port")
tree.heading("state", text="状态")
tree.heading("model", text="设备型号")
tree.heading("message", text="adb 返回")
tree.column("target", width=140, anchor=W)
tree.column("state", width=90, anchor=W)
tree.column("model", width=120, anchor=W)
tree.column("message", width=200, anchor=W)
tree.pack(fill=BOTH, expand=True, padx=10, pady=(0, 8))
for d in devs:
msg = (d.message or "").strip().replace("\n", " | ")
tree.insert(
"", "end",
values=(d.target, d.adb_state, d.model or "-", msg[:200]),
)
bottom = ttk.Frame(pick_dlg)
bottom.pack(fill=X, padx=10, pady=(0, 10))
def use_selected():
sel = tree.selection()
if not sel:
on_line("[扫描] 请先在列表中选中一个设备")
return
values = tree.item(sel[0])["values"]
target = str(values[0])
state = str(values[1])
model = str(values[2] or "").strip()
if model == "-":
model = ""
if state == "unauthorized":
on_line(
f"[扫描] {target} 未授权,请在手机上确认 ADB 调试授权后重试"
)
return
if state == "failed":
# 选中的就是失败项时,把对应的 message 拿出来给用户看真实根因
fail_msg = ""
for d in devs:
if d.target == target:
fail_msg = (d.message or "").strip().replace("\n", " | ")
break
on_line(
f"[扫描] {target} adb 连接失败: {fail_msg or '未知错误'}"
)
return
if state != "connected":
on_line(f"[扫描] {target} 当前状态={state},无法直接使用")
return
refresh_devices()
device_var.set(target)
try:
set_last_wifi_target(target, model)
except Exception:
pass
on_line(
f"[扫描] 已设为当前设备: {target}(已记住,下次 GUI 启动会自动重连)"
)
pick_dlg.destroy()
ttk.Button(bottom, text="使用选中", command=use_selected).pack(side=LEFT)
ttk.Button(bottom, text="关闭", command=pick_dlg.destroy).pack(side=RIGHT)
scan_connect_btn.config(command=_on_scan_one_click)
# WiFi ADB 功能
def open_scan_dialog(parent, adb_exe_local, ip_var, on_line_local, refresh_cb):
"""打开"扫描局域网"对话框:自动推子网或手动输入 → 后台扫描 → 列表展示。"""
scan_dlg = tk.Toplevel(parent)
scan_dlg.title("扫描局域网 ADB 设备")
scan_dlg.geometry("640x440")
scan_dlg.minsize(520, 360)
scan_dlg.transient(parent)
# 顶部:子网输入 + 自动推按钮 + 开始扫描
top_frame = ttk.LabelFrame(scan_dlg, text="扫描范围", padding=10)
top_frame.pack(fill=X, padx=10, pady=10)
ttk.Label(top_frame, text="子网/范围:").grid(row=0, column=0, sticky=W)
subnet_var = tk.StringVar(value=get_local_subnet() or "")
subnet_entry = ttk.Entry(top_frame, textvariable=subnet_var, width=32)
subnet_entry.grid(row=0, column=1, padx=(6, 6), sticky="we")
top_frame.grid_columnconfigure(1, weight=1)
def auto_fill():
sub = get_local_subnet()
if sub:
subnet_var.set(sub)
on_line_local(f"[扫描] 自动推导子网: {sub}")
else:
on_line_local("[扫描] 无法推导本机子网,请手动输入")
ttk.Button(top_frame, text="自动推", command=auto_fill).grid(
row=0, column=2, padx=(0, 6)
)
scan_btn = ttk.Button(top_frame, text="开始扫描")
scan_btn.grid(row=0, column=3)
# 第二行:端口规格
ttk.Label(top_frame, text="端口:").grid(row=1, column=0, sticky=W, pady=(6, 0))
scan_port_var = tk.StringVar(value="5555")
ttk.Entry(top_frame, textvariable=scan_port_var, width=32).grid(
row=1, column=1, columnspan=3, padx=(6, 0), pady=(6, 0), sticky="we"
)
ttk.Label(
top_frame,
text="子网示例: 192.168.5.0/24 | 192.168.5.1-100 | 192.168.5.5",
font=("Arial", 8),
foreground="gray",
).grid(row=2, column=0, columnspan=4, sticky=W, pady=(4, 0))
ttk.Label(
top_frame,
text="端口示例: 5555 | 5555,5556 | 37000-40000 (Android 11+ 无线调试随机端口在 37000-44999)",
font=("Arial", 8),
foreground="gray",
).grid(row=3, column=0, columnspan=4, sticky=W, pady=(2, 0))
# 中间:进度条 + 状态
progress_frame = ttk.Frame(scan_dlg)
progress_frame.pack(fill=X, padx=10)
progress_var = tk.DoubleVar(value=0.0)
progress_bar = ttk.Progressbar(
progress_frame, mode="determinate", variable=progress_var, maximum=100
)
progress_bar.pack(fill=X, pady=(0, 4))
status_var = tk.StringVar(value="待扫描")
ttk.Label(progress_frame, textvariable=status_var, font=("Arial", 9)).pack(
anchor=W
)
# 列表:IP / 状态 / 型号 / 备注
list_frame = ttk.LabelFrame(scan_dlg, text="发现的设备", padding=10)
list_frame.pack(fill=BOTH, expand=True, padx=10, pady=(8, 0))
cols = ("target", "state", "model", "message")
tree = ttk.Treeview(
list_frame, columns=cols, show="headings", height=8
)
tree.heading("target", text="IP:Port")
tree.heading("state", text="状态")
tree.heading("model", text="设备型号")
tree.heading("message", text="adb connect 输出")
tree.column("target", width=140, anchor=W)
tree.column("state", width=80, anchor=W)
tree.column("model", width=100, anchor=W)
tree.column("message", width=240, anchor=W)
tree.pack(side=LEFT, fill=BOTH, expand=True)
sb = ttk.Scrollbar(list_frame, orient="vertical", command=tree.yview)
sb.pack(side=LEFT, fill="y")
tree.configure(yscrollcommand=sb.set)
# 底部按钮
bottom_frame = ttk.Frame(scan_dlg)
bottom_frame.pack(fill=X, padx=10, pady=10)
def use_selected():
sel = tree.selection()
if not sel:
on_line_local("[扫描] 请先在列表中选中一个设备")
return
item = tree.item(sel[0])
target = item["values"][0]
state = item["values"][1]
if state == "unauthorized":
on_line_local(
f"[扫描] {target} 未授权,请先在手机上确认 ADB 调试授权再选"
)
return
# 把 IP 部分填回主对话框
ip_part = str(target).split(":")[0]
ip_var.set(ip_part)
on_line_local(f"[扫描] 已选中 {target},可在主对话框点'连接'或它已在 adb devices 中")
try:
refresh_cb()
except Exception:
pass
scan_dlg.destroy()
use_btn = ttk.Button(
bottom_frame, text="使用选中设备", command=use_selected, state="disabled"
)
use_btn.pack(side=LEFT)
ttk.Button(bottom_frame, text="关闭", command=scan_dlg.destroy).pack(
side=RIGHT
)
def on_select(_event=None):
sel = tree.selection()
use_btn.config(state="normal" if sel else "disabled")
tree.bind("<<TreeviewSelect>>", on_select)
# 扫描线程
scanning = {"flag": False}
def do_scan():
if scanning["flag"]:
on_line_local("[扫描] 上次扫描尚未完成,请稍候")
return
spec = subnet_var.get().strip()
if not spec:
on_line_local("[扫描] 请输入子网/IP 范围")
return
scanning["flag"] = True
scan_btn.config(state="disabled")
tree.delete(*tree.get_children())
progress_var.set(0)
def on_progress(done, total):
try:
pct = (done * 100.0) / max(total, 1)
progress_var.set(pct)
status_var.set(f"端口扫描 {done}/{total}")
scan_dlg.update_idletasks()
except Exception:
pass
def on_phase(text):
try:
status_var.set(text)
scan_dlg.update_idletasks()
except Exception:
pass
def worker():
try:
from gui.gui_core_pkg import parse_port_spec
port_list = parse_port_spec(scan_port_var.get().strip())
devs = discover_adb_devices(
adb_exe_local,
subnet_spec=spec,
ports=port_list,
on_progress=on_progress,
on_phase=on_phase,
)
except Exception as e:
on_line_local(f"[扫描] 异常: {e}")
devs = []
# 回主线程更新 UI
def render():
for d in devs:
tree.insert(
"",
"end",
values=(d.target, d.adb_state, d.model, d.message[:120]),
)
if devs:
status_var.set(f"扫描完成,发现 {len(devs)} 台设备")
on_line_local(
f"[扫描] 完成:{len(devs)} 台候选 — "
+ ", ".join(f"{d.target}({d.adb_state})" for d in devs[:5])
)
else:
status_var.set("扫描完成,未发现设备")
on_line_local("[扫描] 未发现开放 5555 的设备")
progress_var.set(100)
scan_btn.config(state="normal")
scanning["flag"] = False
try:
scan_dlg.after(0, render)
except Exception:
pass
threading.Thread(target=worker, daemon=True).start()
scan_btn.config(command=do_scan)
def open_wifi_adb_dialog():
"""打开WiFi ADB设置对话框"""
dialog = tk.Toplevel(root)
dialog.title("WiFi ADB 设置")
dialog.geometry("500x450")
# 允许用户调整对话框大小,避免窗口内容被裁剪
dialog.resizable(True, True)
dialog.minsize(420, 320)
# 获取设备列表并分类
current_devices = list_adb_devices(adb_exe)
wifi_devices = get_connected_wifi_devices(adb_exe)
usb_devices = [d for d in current_devices if d not in wifi_devices]
# 创建设备选择区域
device_frame = ttk.LabelFrame(dialog, text="设备选择", padding=10)
device_frame.pack(fill=X, padx=10, pady=10)
# 使内部 grid 列随窗口宽度伸缩
device_frame.grid_columnconfigure(0, weight=3)
device_frame.grid_columnconfigure(1, weight=1)
# USB设备选择
ttk.Label(device_frame, text="USB设备(用于首次启用):").grid(
row=0, column=0, sticky=W, pady=(0, 5)
)
usb_device_var = tk.StringVar(value=(usb_devices[0] if usb_devices else ""))
usb_combo = ttk.Combobox(
device_frame,
textvariable=usb_device_var,
values=usb_devices,
width=25,
state="readonly" if not usb_devices else "normal",
)
usb_combo.grid(row=1, column=0, padx=(0, 10), pady=(0, 10), sticky="we")
# 显示USB设备状态
usb_status_text = (
f"检测到 {len(usb_devices)} 个USB设备"
if usb_devices
else "未检测到USB设备,请确保设备已连接并授权"
)
usb_status_label = ttk.Label(
device_frame,
text=usb_status_text,
font=("Arial", 8),
foreground="red" if not usb_devices else "green",
)
usb_status_label.grid(row=2, column=0, sticky=W, pady=(0, 10))
# WiFi设备选择
ttk.Label(device_frame, text="WiFi设备(已连接):").grid(
row=0, column=1, sticky=W, pady=(0, 5)
)
wifi_device_var = tk.StringVar(value=(wifi_devices[0] if wifi_devices else ""))
wifi_combo = ttk.Combobox(
device_frame,
textvariable=wifi_device_var,
values=wifi_devices,
width=25,
state="readonly" if not wifi_devices else "normal",
)
wifi_combo.grid(row=1, column=1, pady=(0, 10), sticky="we")
# 显示WiFi设备状态
wifi_status_text = (
f"已连接 {len(wifi_devices)} 个WiFi设备"
if wifi_devices
else "无WiFi设备连接"
)
wifi_status_label = ttk.Label(
device_frame,
text=wifi_status_text,
font=("Arial", 8),
foreground="blue" if wifi_devices else "gray",
)
wifi_status_label.grid(row=2, column=1, sticky=W, pady=(0, 10))
# IP地址输入区域
ip_frame = ttk.LabelFrame(dialog, text="连接信息", padding=10)
ip_frame.pack(fill=X, padx=10, pady=(0, 10))
# 使 IP/端口 输入框随窗口宽度伸缩
ip_frame.grid_columnconfigure(0, weight=3)
ip_frame.grid_columnconfigure(1, weight=1)
ttk.Label(ip_frame, text="设备IP地址:").grid(
row=0, column=0, sticky=W, pady=(0, 5)
)
ip_var = tk.StringVar()
ip_entry = ttk.Entry(ip_frame, textvariable=ip_var, width=25)
ip_entry.grid(row=1, column=0, padx=(0, 10), pady=(0, 10), sticky="we")
ttk.Label(ip_frame, text="端口(默认5555):").grid(
row=0, column=1, sticky=W, pady=(0, 5)
)
port_var = tk.StringVar(value="5555")
port_entry = ttk.Entry(ip_frame, textvariable=port_var, width=25)
port_entry.grid(row=1, column=1, pady=(0, 10), sticky="we")
# 按钮区域
button_frame = ttk.Frame(dialog)
button_frame.pack(fill=X, padx=10, pady=10)
def enable_wifi():
device_id = usb_device_var.get()
if not device_id:
on_line("[WiFi ADB] 请先选择USB设备")
return
success, msg = enable_wifi_adb(adb_exe, device_id)
on_line(f"[WiFi ADB] {msg}")
if success:
# 尝试获取IP地址
ip_success, ip_msg = get_device_ip(adb_exe, device_id)
if ip_success:
ip_var.set(ip_msg)
on_line(f"[WiFi ADB] 设备IP地址: {ip_msg}")
def connect_wifi():
ip = ip_var.get().strip()
port = port_var.get().strip() or "5555"
if not ip:
on_line("[WiFi ADB] 请输入IP地址")
return
success, msg = connect_wifi_adb(adb_exe, ip, port)
on_line(f"[WiFi ADB] {msg}")
if success:
# 记住,下次启动自动重连
target = ip if ":" in ip else f"{ip}:{port}"
model = ""
try:
model = query_device_model(adb_exe, target)
except Exception:
pass
try:
set_last_wifi_target(target, model)
on_line(
f"[WiFi ADB] 已记住 {target}"
+ (f" ({model})" if model else "")
+ ",下次 GUI 启动会自动重连"
)
except Exception:
pass
# 刷新设备列表
refresh_devices()
# 重新打开对话框以显示新的WiFi设备
dialog.destroy()
open_wifi_adb_dialog()
def disconnect_wifi():
device_id = wifi_device_var.get()
if not device_id:
on_line("[WiFi ADB] 请先选择WiFi设备")
return
# 从设备ID中提取IP地址
ip_match = re.search(r"(\d+\.\d+\.\d+\.\d+)", device_id)
if not ip_match:
on_line("[WiFi ADB] 无法从设备ID中提取IP地址")
return
ip = ip_match.group(1)
success, msg = disconnect_wifi_adb(adb_exe, ip, "5555")
on_line(f"[WiFi ADB] {msg}")
if success:
# 如果断开的就是上次记住的设备,清掉记录避免下次启动徒劳重试
try:
last = get_last_wifi_target()
last_target = str(last.get("target") or "")
if last_target.startswith(ip):
clear_last_wifi_target()
on_line(
f"[WiFi ADB] 已清除上次设备记录 {last_target}"
)
except Exception:
pass
# 刷新设备列表
refresh_devices()
# 重新打开对话框以更新设备列表
dialog.destroy()
open_wifi_adb_dialog()
def auto_connect_wifi():
device_id = usb_device_var.get()
if not device_id:
on_line("[WiFi ADB] 请先选择USB设备")
return
# 显示进度
on_line("[WiFi ADB] 开始自动连接...")
# 创建进度对话框
progress_dialog = tk.Toplevel(dialog)
progress_dialog.title("自动连接中...")
progress_dialog.geometry("300x120")
progress_dialog.resizable(False, False)
ttk.Label(progress_dialog, text="正在自动连接WiFi ADB,请稍候...").pack(
pady=10
)
ttk.Label(progress_dialog, text="设备将会重启,请等待重启完成").pack(
pady=(0, 10)
)
progress_bar = ttk.Progressbar(progress_dialog, mode="indeterminate")
progress_bar.pack(fill=X, padx=20, pady=(0, 20))
progress_bar.start()
def do_auto_connect():
try:
success, msg = auto_connect_wifi_adb(adb_exe, device_id)
progress_dialog.destroy()
on_line(f"[WiFi ADB] {msg}")
if success:
# 刷新设备列表
refresh_devices()
# 尝试获取并显示IP
ip_success, ip_msg = get_device_ip(adb_exe, device_id)
if ip_success:
ip_var.set(ip_msg)
# 记住目标设备
target = (
ip_msg if ":" in ip_msg else f"{ip_msg}:5555"
)
model = ""
try:
model = query_device_model(adb_exe, target)
except Exception:
pass
try:
set_last_wifi_target(target, model)
on_line(
f"[WiFi ADB] 已记住 {target}"
+ (f" ({model})" if model else "")
+ ",下次 GUI 启动会自动重连"
)
except Exception:
pass
# 重新打开对话框以显示新的WiFi设备
dialog.destroy()
open_wifi_adb_dialog()
except Exception as e:
progress_dialog.destroy()
on_line(f"[WiFi ADB] 自动连接异常: {str(e)}")
# 在后台线程中执行自动连接
threading.Thread(target=do_auto_connect, daemon=True).start()
# 放大/恢复窗口支持(当系统边框无法调整窗口时提供备用按钮)
is_maximized = False
original_geometry = None
def toggle_maximize():
nonlocal is_maximized, original_geometry
try:
if not is_maximized:
original_geometry = dialog.geometry()
dialog.update_idletasks()
w = int(dialog.winfo_screenwidth() * 0.8)
h = int(dialog.winfo_screenheight() * 0.8)
dialog.geometry(f"{w}x{h}")
is_maximized = True
else:
if original_geometry:
dialog.geometry(original_geometry)
is_maximized = False
except Exception as e:
on_line(f"[WiFi ADB] 切换窗口大小失败: {e}")
def refresh_device_lists():
"""刷新设备列表"""
nonlocal usb_devices, wifi_devices
current_devices = list_adb_devices(adb_exe)
wifi_devices = get_connected_wifi_devices(adb_exe)
usb_devices = [d for d in current_devices if d not in wifi_devices]
# 更新USB设备下拉框
usb_combo["values"] = usb_devices
usb_combo["state"] = "readonly" if not usb_devices else "normal"
if usb_devices:
usb_device_var.set(usb_devices[0])
else:
usb_device_var.set("")
# 更新WiFi设备下拉框
wifi_combo["values"] = wifi_devices
wifi_combo["state"] = "readonly" if not wifi_devices else "normal"
if wifi_devices:
wifi_device_var.set(wifi_devices[0])
else:
wifi_device_var.set("")
# 更新状态标签
usb_status_text = (
f"检测到 {len(usb_devices)} 个USB设备"
if usb_devices
else "未检测到USB设备,请确保设备已连接并授权"
)
usb_status_label.config(
text=usb_status_text, foreground="red" if not usb_devices else "green"
)
wifi_status_text = (
f"已连接 {len(wifi_devices)} 个WiFi设备"
if wifi_devices
else "无WiFi设备连接"
)
wifi_status_label.config(
text=wifi_status_text, foreground="blue" if wifi_devices else "gray"
)
on_line("[WiFi ADB] 设备列表已刷新")
# USB设备操作按钮
usb_button_frame = ttk.Frame(button_frame)
usb_button_frame.pack(fill=X, pady=(0, 10))
ttk.Label(usb_button_frame, text="USB设备操作:").pack(anchor=W)
usb_buttons_frame = ttk.Frame(usb_button_frame)
usb_buttons_frame.pack(fill=X, pady=(5, 0))
ttk.Button(usb_buttons_frame, text="自动连接", command=auto_connect_wifi).pack(
side=LEFT, padx=(0, 10)
)
ttk.Button(usb_buttons_frame, text="启用WiFi ADB", command=enable_wifi).pack(
side=LEFT, padx=(0, 10)
)
ttk.Button(usb_buttons_frame, text="连接", command=connect_wifi).pack(
side=LEFT, padx=(0, 10)
)
ttk.Button(
usb_buttons_frame, text="刷新设备", command=refresh_device_lists
).pack(side=LEFT)
# 如果窗口无法通过边框调整,提供放大/恢复按钮作为备用
ttk.Button(usb_buttons_frame, text="放大/恢复", command=toggle_maximize).pack(
side=LEFT, padx=(8, 0)
)
# WiFi设备操作按钮
wifi_button_frame = ttk.Frame(button_frame)
wifi_button_frame.pack(fill=X, pady=(10, 0))
ttk.Label(wifi_button_frame, text="WiFi设备操作:").pack(anchor=W)
wifi_buttons_frame = ttk.Frame(wifi_button_frame)
wifi_buttons_frame.pack(fill=X, pady=(5, 0))
ttk.Button(wifi_buttons_frame, text="断开连接", command=disconnect_wifi).pack(
side=LEFT
)
ttk.Button(
wifi_buttons_frame,
text="扫描局域网",
command=lambda: open_scan_dialog(
dialog, adb_exe, ip_var, on_line, refresh_device_lists
),
).pack(side=LEFT, padx=(10, 0))
# 说明文本
info_text = """重要说明:
• Android系统安全要求:首次启用WiFi ADB必须通过USB连接
• 工作流程:USB连接 → 启用WiFi ADB → 设备重启 → WiFi连接
• 设置完成后,设备会出现在"WiFi设备"列表中,无需再次USB连接
• 设备重启后WiFi ADB模式会保持,可直接通过WiFi连接使用
使用方法:
1. 连接Android设备到电脑(USB)
2. 点击"刷新设备"确保设备被检测到
3. 选择USB设备,点击"自动连接"或手动操作
4. 等待设备重启后即可通过WiFi使用"""
info_label = ttk.Label(
dialog, text=info_text, justify=LEFT, font=("Arial", 9), wraplength=460
)
info_label.pack(pady=(10, 0), padx=20, anchor="w")
wifi_adb_btn = ttk.Button(top, text="WiFi ADB", command=open_wifi_adb_dialog)
wifi_adb_btn.pack(side=LEFT, padx=(0, 20))
# 配置区(提前读取配置,供后续使用)
cfg = read_config()
y_var = tk.IntVar(value=int(cfg.get("y_pianyi", 0) or 0))
ttk.Label(top, text="Y偏移:").pack(side=LEFT)
ttk.Spinbox(top, from_=-200, to=200, textvariable=y_var, width=6).pack(
side=LEFT, padx=(0, 12)
)
# 连续无福袋退出阈值变量(提前声明,实际声明在下方唯一位置以便与配置同步)
# (变量将在后面统一声明,避免重复创建 IntVar 导致绑定不一致)
# 启用返回键回退开关变量(提前声明)
enable_back_on_misses_var = tk.BooleanVar(
value=bool(cfg.get("enable_back_on_misses", True))
)
swipe_down_back_enabled_var = tk.BooleanVar(
value=bool(cfg.get("swipe_down_back_enabled", False))
)
swipe_down_back_count_var = tk.IntVar(
value=int(cfg.get("swipe_down_back_count", 3) or 3)
)
# 中部:左侧配置(使用Notebook标签页)+ 右侧日志/预览(支持拖拽调整宽度)
mid = ttk.PanedWindow(root, orient="horizontal")
mid.pack(fill=BOTH, expand=True, padx=12, pady=(0, 12))
left_wrap = ttk.Frame(mid)
right = ttk.Frame(mid)
mid.add(left_wrap, weight=0) # 左侧配置区域
mid.add(right, weight=1) # 右侧日志/预览区域
# 右侧为日志/预览区域(保持原样)
# right_notebook previously added here; mapping tab will attach to the left notebook
# 左侧使用Notebook标签页组织配置
left_notebook = ttk.Notebook(left_wrap)
left_notebook.pack(fill=BOTH, expand=True)
# 左侧 Notebook 中不再添加映射表页(已移至右侧)
needswitch_var = tk.BooleanVar(value=bool(cfg.get("needswitch", True)))
infinite_loop_var = tk.BooleanVar(
value=bool(cfg.get("infinite_loop_enabled", False))
)
wait_minutes_var = tk.IntVar(value=int(cfg.get("wait_minutes", 5) or 5))
min_value_var = tk.DoubleVar(value=float(cfg.get("min_prize_value_yuan", 0) or 0))
min_participants_var = tk.IntVar(value=int(cfg.get("min_participants", 0) or 0))
max_participants_var = tk.IntVar(value=int(cfg.get("max_participants", 0) or 0))
skip_gt_seconds_var = tk.IntVar(
value=int(cfg.get("skip_if_countdown_gt_seconds", 900) or 900)
)
reset_after_swipes_enabled_var = tk.BooleanVar(
value=bool(cfg.get("reset_after_swipes_enabled", False))
)
reset_after_swipes_var = tk.IntVar(
value=int(cfg.get("reset_after_swipes", 10) or 10)
)
reset_after_swipes_action_var = tk.StringVar(
value=str(cfg.get("reset_after_swipes_action", "swipe") or "swipe")
)
enable_back_on_misses_var = tk.BooleanVar(
value=bool(cfg.get("enable_back_on_misses", True))
)
# 流式后台截图开关(默认启用)
streaming_enabled_var = tk.BooleanVar(
value=bool(cfg.get("enable_streaming_screenshot", True))
)
# 按需求:删除"自动养号/随机等待/轻微扰动/定时休息"等设置,仅保留"推荐页养号(爱心/收藏/评论)"配置。
auto_join_var = tk.BooleanVar(value=bool(cfg.get("auto_join_fansclub", False)))
fansclub_action_var = tk.StringVar(
value=str(cfg.get("fansclub_fail_action", "stay") or "stay").lower()
)
fansclub_click_delay_var = tk.DoubleVar(
value=float(cfg.get("fansclub_click_delay", 0.6) or 0.6)
)
fansclub_auto_wait_var = tk.DoubleVar(
value=float(cfg.get("fansclub_auto_join_wait_seconds", 5.0) or 5.0)
)
fansclub_manual_wait_var = tk.DoubleVar(
value=float(cfg.get("fansclub_manual_wait_seconds", 3.0) or 3.0)
)
# Web端新增配置变量 - 高价值预约相关
high_value_fudai_enabled_var = tk.BooleanVar(
value=bool(cfg.get("high_value_fudai_enabled", False))
)
high_value_fudai_threshold_yuan_var = tk.DoubleVar(
value=float(cfg.get("high_value_fudai_threshold_yuan", 1000) or 1000)
)
high_value_fudai_join_ahead_seconds_var = tk.IntVar(
value=int(cfg.get("high_value_fudai_join_ahead_seconds", 300) or 300)
)
high_value_fudai_max_swipe_back_var = tk.IntVar(
value=int(cfg.get("high_value_fudai_max_swipe_back", 60) or 60)
)
high_value_fudai_max_reservations_var = tk.IntVar(
value=int(cfg.get("high_value_fudai_max_reservations", 5) or 5)
)
high_value_fudai_after_action_var = tk.StringVar(
value=str(cfg.get("high_value_fudai_after_action", "continue") or "continue")
)
high_value_fudai_poll_before_seconds_var = tk.DoubleVar(
value=float(cfg.get("high_value_fudai_poll_before_seconds", 10.0) or 10.0)
)
high_value_room_revisit_enabled_var = tk.BooleanVar(
value=bool(cfg.get("high_value_room_revisit_enabled", True))
)
high_value_room_revisit_only_current_run_var = tk.BooleanVar(
value=bool(cfg.get("high_value_room_revisit_only_current_run", False))
)
high_value_room_revisit_min_interval_seconds_var = tk.IntVar(
value=int(cfg.get("high_value_room_revisit_min_interval_seconds", 300))
)
high_value_room_revisit_max_per_run_var = tk.IntVar(
value=int(cfg.get("high_value_room_revisit_max_per_run", 5))
)
high_value_room_revisit_min_prize_value_var = tk.DoubleVar(
value=float(cfg.get("high_value_room_revisit_min_prize_value", 0.0))
)
high_value_room_revisit_max_age_days_var = tk.IntVar(
value=int(cfg.get("high_value_room_revisit_max_age_days", 30))
)
reservation_back_verify_enabled_var = tk.BooleanVar(
value=bool(cfg.get("reservation_back_verify_enabled", True))
)
reservation_back_swipe_delay_var = tk.DoubleVar(
value=float(cfg.get("reservation_back_swipe_delay", 0) or 0)
)
reservation_back_verify_wait_seconds_var = tk.DoubleVar(
value=float(cfg.get("reservation_back_verify_wait_seconds", 5.0) or 5.0)
)
fudai_find_max_attempts_var = tk.IntVar(
value=int(cfg.get("fudai_find_max_attempts", 0) or 0)
)
fudai_icon_retry_delay_seconds_var = tk.DoubleVar(
value=float(cfg.get("fudai_icon_retry_delay_seconds", 0.6) or 0.6)
)
fudai_icon_max_wait_seconds_var = tk.DoubleVar(
value=float(cfg.get("fudai_icon_max_wait_seconds", 5.0) or 5.0)
)
fudai_disable_content_recognition_var = tk.BooleanVar(
value=bool(cfg.get("fudai_disable_content_recognition", False))
)
fudai_disable_task_recognition_var = tk.BooleanVar(
value=bool(cfg.get("fudai_disable_task_recognition", False))
)
fudai_exit_after_misses_var = tk.IntVar(
value=int(cfg.get("fudai_exit_after_misses", 30) or 30)
)
fudai_click_wait_seconds_var = tk.DoubleVar(
value=float(cfg.get("fudai_click_wait_seconds", 1.0) or 1.0)
)
switch_room_wait_after_stage_diag_seconds_var = tk.DoubleVar(
value=float(cfg.get("switch_room_wait_after_stage_diag_seconds", 7.0) or 7.0)
)
live_room_match_threshold_var = tk.DoubleVar(
value=float(cfg.get("live_room_match_threshold", 0.8) or 0.8)
)
# 滑动速度(毫秒)
swipe_duration_ms_var = tk.IntVar(
value=int(cfg.get("swipe_duration_ms", 600) or 600)
)
# 滑动坐标配置
swipe_up_start_y_var = tk.IntVar(
value=int(cfg.get("swipe_up_start_y", 1200) or 1200)
)
swipe_up_end_y_var = tk.IntVar(value=int(cfg.get("swipe_up_end_y", 600) or 600))
# 推荐页养号:爱心/收藏/评论(基于图标模板匹配 + 坐标点击)
yg_enabled_var = tk.BooleanVar(value=bool(cfg.get("yanghao_enabled", True)))
yg_actions_enabled_var = tk.BooleanVar(
value=bool(cfg.get("yanghao_enable_actions", True))
)
yg_only_var = tk.BooleanVar(value=bool(cfg.get("yanghao_only", False)))
yg_recommend_duration_var = tk.IntVar(
value=int(cfg.get("yanghao_recommend_duration_seconds", 60) or 60)
)
yg_recommend_interval_var = tk.IntVar(
value=int(cfg.get("yanghao_recommend_interval_seconds", 0) or 0)
)
yg_like_prob_var = tk.DoubleVar(
value=float(cfg.get("yanghao_like_prob", 0.0) or 0.0)
)
yg_fav_prob_var = tk.DoubleVar(value=float(cfg.get("yanghao_fav_prob", 0.0) or 0.0))
yg_comment_prob_var = tk.DoubleVar(
value=float(cfg.get("yanghao_comment_prob", 0.0) or 0.0)
)
yg_dwell_on_action_min_var = tk.DoubleVar(
value=float(cfg.get("yanghao_dwell_on_action_min_seconds", 5) or 5)
)
yg_dwell_on_action_max_var = tk.DoubleVar(
value=float(cfg.get("yanghao_dwell_on_action_max_seconds", 30) or 30)
)
yg_icon_roi_size_var = tk.IntVar(
value=int(cfg.get("yanghao_icon_roi_size", 240) or 240)
)
yg_icon_match_threshold_var = tk.DoubleVar(
value=float(cfg.get("yanghao_icon_match_threshold", 0.72) or 0.72)
)
yg_step_screenshot_var = tk.BooleanVar(
value=bool(cfg.get("yanghao_step_screenshot", False))
)
yg_like_roi_offset_x_var = tk.IntVar(
value=int(cfg.get("yanghao_like_roi_offset_x", 0) or 0)
)
yg_like_roi_offset_y_var = tk.IntVar(
value=int(cfg.get("yanghao_like_roi_offset_y", 0) or 0)
)
yg_fav_roi_offset_x_var = tk.IntVar(
value=int(cfg.get("yanghao_fav_roi_offset_x", 0) or 0)
)
yg_fav_roi_offset_y_var = tk.IntVar(
value=int(cfg.get("yanghao_fav_roi_offset_y", 0) or 0)
)
yg_like_icon_x_var = tk.IntVar(value=int(cfg.get("yanghao_like_icon_x", 0) or 0))
yg_like_icon_y_var = tk.IntVar(value=int(cfg.get("yanghao_like_icon_y", 0) or 0))
yg_fav_icon_x_var = tk.IntVar(value=int(cfg.get("yanghao_fav_icon_x", 0) or 0))
yg_fav_icon_y_var = tk.IntVar(value=int(cfg.get("yanghao_fav_icon_y", 0) or 0))
yg_like_template_path_var = tk.StringVar(
value=str(
cfg.get("yanghao_like_template_path", "assets/like.png")
or "assets/like.png"
)
)
yg_fav_template_path_var = tk.StringVar(
value=str(
cfg.get("yanghao_fav_template_path", "assets/fav.png") or "assets/fav.png"
)
)
yg_like_icon_x_var = tk.IntVar(value=int(cfg.get("yanghao_like_icon_x", 0) or 0))
yg_like_icon_y_var = tk.IntVar(value=int(cfg.get("yanghao_like_icon_y", 0) or 0))
yg_fav_icon_x_var = tk.IntVar(value=int(cfg.get("yanghao_fav_icon_x", 0) or 0))
yg_fav_icon_y_var = tk.IntVar(value=int(cfg.get("yanghao_fav_icon_y", 0) or 0))
yg_after_dwell_direction_var = tk.StringVar(
value=str(cfg.get("yanghao_after_dwell_swipe_direction", "up") or "up")
)
yg_after_dwell_distance_var = tk.IntVar(
value=int(cfg.get("yanghao_after_dwell_swipe_distance_px", 900) or 900)
)
yg_comment_btn_x_var = tk.IntVar(
value=int(cfg.get("yanghao_comment_btn_x", 0) or 0)
)
yg_comment_btn_y_var = tk.IntVar(
value=int(cfg.get("yanghao_comment_btn_y", 0) or 0)
)
yg_comment_input_x_var = tk.IntVar(
value=int(cfg.get("yanghao_comment_input_x", 0) or 0)
)
yg_comment_input_y_var = tk.IntVar(
value=int(cfg.get("yanghao_comment_input_y", 0) or 0)
)
yg_comment_send_x_var = tk.IntVar(
value=int(cfg.get("yanghao_comment_send_x", 0) or 0)
)
yg_comment_send_y_var = tk.IntVar(
value=int(cfg.get("yanghao_comment_send_y", 0) or 0)
)
yg_comment_close_x_var = tk.IntVar(
value=int(cfg.get("yanghao_comment_close_x", 0) or 0)
)
yg_comment_close_y_var = tk.IntVar(
value=int(cfg.get("yanghao_comment_close_y", 0) or 0)
)
fudai_quiet_hours_enabled_var = tk.BooleanVar(
value=bool(cfg.get("fudai_quiet_hours_enabled", True))
)
fudai_quiet_start_hour_var = tk.IntVar(
value=int(cfg.get("fudai_quiet_start_hour", 2) or 2)
)
fudai_quiet_end_hour_var = tk.IntVar(
value=int(cfg.get("fudai_quiet_end_hour", 7) or 7)
)
# 阶段诊断时间参数(用于调试)
stage_diag_max_time_var = tk.DoubleVar(
value=float(cfg.get("stage_diag_max_time", 10.0) or 10.0)
)
stage_diag_max_step_time_var = tk.DoubleVar(
value=float(cfg.get("stage_diag_max_step_time", 2.0) or 2.0)
)
stage_diag_verbose_var = tk.BooleanVar(
value=bool(cfg.get("logging", {}).get("stage_diag_verbose", True))
)
enable_ocr_mode1_var = tk.BooleanVar(value=bool(cfg.get("enable_ocr_mode1", False)))
# 福袋模板匹配开关和阈值
fudai_template_match_enabled_var = tk.BooleanVar(
value=bool(cfg.get("fudai_template_match_enabled", False))
)
fudai_template_match_threshold_var = tk.DoubleVar(
value=float(cfg.get("fudai_template_match_threshold", 0.7) or 0.7)
)
# 福袋详情页模板匹配阈值(0.0~1.0,默认0.7)
fudai_detail_template_threshold_var = tk.DoubleVar(
value=float(cfg.get("fudai_detail_template_threshold", 0.7) or 0.7)
)
# 开奖页面红色占比阈值(0.0~1.0,默认0.9)
lucky_draw_red_ratio_threshold_var = tk.DoubleVar(
value=float(cfg.get("lucky_draw_red_ratio_threshold", 0.9) or 0.9)
)
# 优惠券模板匹配阈值(0.0~1.0,默认0.75)
coupon_template_match_threshold_var = tk.DoubleVar(
value=float(cfg.get("coupon_template_match_threshold", 0.75) or 0.75)
)
# 参与按钮红色占比阈值(0.0~1.0,默认0.25)
attend_button_red_ratio_threshold_var = tk.DoubleVar(
value=float(cfg.get("attend_button_red_ratio_threshold", 0.25) or 0.25)
)
# 粉丝团加入红色占比阈值(0.0~1.0,默认0.25)
fansclub_join_red_ratio_threshold_var = tk.DoubleVar(
value=float(cfg.get("fansclub_join_red_ratio_threshold", 0.25) or 0.25)
)
# 购物红包背景红色占比阈值(0.0~1.0,默认0.15)
shopping_redpacket_red_ratio_threshold_var = tk.DoubleVar(
value=float(cfg.get("shopping_redpacket_red_ratio_threshold", 0.15) or 0.15)
)
# 调试图像开关 & 清理相关变量
debug_captures_enabled_var = tk.BooleanVar(
value=bool(
cfg.get("debug_captures", {}).get("enabled", False)
if isinstance(cfg.get("debug_captures"), dict)
else False
)
)
# 调试图像清理相关变量
debug_captures_auto_cleanup_var = tk.BooleanVar(
value=bool(
cfg.get("debug_captures", {}).get("auto_cleanup", True)
if isinstance(cfg.get("debug_captures"), dict)
else True
)
)
debug_captures_keep_days_var = tk.IntVar(
value=int(
cfg.get("debug_captures", {}).get("keep_days", 7)
if isinstance(cfg.get("debug_captures"), dict)
else 7
)
)
debug_captures_max_files_var = tk.IntVar(
value=int(
cfg.get("debug_captures", {}).get("max_files", 2000)
if isinstance(cfg.get("debug_captures"), dict)
else 2000
)
)
debug_captures_async_save_var = tk.BooleanVar(
value=bool(
cfg.get("debug_captures", {}).get("async_save", True)
if isinstance(cfg.get("debug_captures"), dict)
else True
)
)
debug_captures_log_on_complete_var = tk.BooleanVar(
value=bool(
cfg.get("debug_captures", {}).get("log_on_complete", False)
if isinstance(cfg.get("debug_captures"), dict)
else False
)
)
# 异步保存计数显示变量
debug_async_success_var = tk.IntVar(value=0)
debug_async_failure_var = tk.IntVar(value=0)
# 日志配置变量
logging_beautify_var = tk.BooleanVar(
value=bool(cfg.get("logging", {}).get("beautify_output", True))
)
logging_color_var = tk.BooleanVar(
value=bool(cfg.get("logging", {}).get("color_output", True))
)
logging_show_timestamps_var = tk.BooleanVar(
value=bool(cfg.get("logging", {}).get("show_timestamps", True))
)
logging_use_dated_logs_var = tk.BooleanVar(
value=bool(cfg.get("logging", {}).get("use_dated_logs", True))
)
logging_enable_monitor_var = tk.BooleanVar(
value=bool(cfg.get("logging", {}).get("enable_monitor", True))
)
log_unified_enabled_var = tk.BooleanVar(
value=bool(cfg.get("log_unified_enabled", True))
)
log_unified_path_var = tk.StringVar(
value=str(cfg.get("log_unified_path", "logs/unified.log") or "logs/unified.log")
)
logging_keep_days_var = tk.IntVar(
value=int(cfg.get("logging", {}).get("keep_days", 30) or 30)
)
logging_compress_logs_var = tk.BooleanVar(
value=bool(cfg.get("logging", {}).get("compress_logs", True))
)
logging_max_total_size_gb_var = tk.DoubleVar(
value=float(cfg.get("logging", {}).get("max_total_size_gb", 10.0) or 10.0)
)
logging_compress_after_days_var = tk.IntVar(
value=int(cfg.get("logging", {}).get("compress_after_days", 7) or 7)
)
logging_performance_enabled_var = tk.BooleanVar(
value=bool(
cfg.get("logging", {}).get("performance_tracking", {}).get("enabled", True)
)
)
logging_track_functions_var = tk.BooleanVar(
value=bool(
cfg.get("logging", {})
.get("performance_tracking", {})
.get("track_function_calls", True)
)
)
logging_debug_level_var = tk.StringVar(
value=str(cfg.get("logging", {}).get("debug_detail_level", "normal"))
)
logging_error_level_var = tk.StringVar(
value=str(cfg.get("logging", {}).get("error_detail_level", "full"))
)
logging_action_format_var = tk.StringVar(
value=str(cfg.get("logging", {}).get("action_log_format", "concise"))
)
logging_format_mode_var = tk.StringVar(
value=str(cfg.get("logging", {}).get("log_format_mode", "simple"))
)
logging_monitor_warning_mb_var = tk.DoubleVar(
value=float(cfg.get("logging", {}).get("monitor_warning_mb", 500.0) or 500.0)
)
logging_monitor_critical_mb_var = tk.DoubleVar(
value=float(cfg.get("logging", {}).get("monitor_critical_mb", 2000.0) or 2000.0)
)
# GUI 主题变量
gui_theme_var = tk.StringVar(
value=str(cfg.get("gui", {}).get("theme", "litera") or "litera")
)
gui_realtime_refresh_interval_ms_var = tk.IntVar(
value=int(
cfg.get("gui", {})
.get("realtime_status", {})
.get("refresh_interval_ms", 1000)
or 1000
)
)
gui_realtime_tail_items_var = tk.IntVar(
value=int(
cfg.get("gui", {}).get("realtime_status", {}).get("tail_items", 50) or 50
)
)
# 倒计时小于阈值参数
skip_lt_seconds_var = tk.IntVar(
value=int(cfg.get("skip_if_countdown_lt_seconds", 10) or 10)
)
# 创建左侧配置标签页
# 标签页1:运行设置
run_tab = ttk.Frame(left_notebook)
left_notebook.add(run_tab, text="运行设置")
run_box = ttk.LabelFrame(run_tab, text="基本运行参数")
run_box.pack(fill=X, padx=10, pady=(10, 10))
r0 = ttk.Frame(run_box)
r0.pack(fill=X, padx=10, pady=(10, 6))
ttk.Checkbutton(r0, text="允许切换直播间", variable=needswitch_var).pack(side=LEFT)
r1 = ttk.Frame(run_box)
r1.pack(fill=X, padx=10, pady=(0, 10))
ttk.Checkbutton(r1, text="无限循环模式", variable=infinite_loop_var).pack(side=LEFT)
ttk.Label(r1, text="运行时长(分钟):").pack(side=LEFT, padx=(10, 0))
wait_minutes_spinbox = ttk.Spinbox(
r1, from_=1, to=60, textvariable=wait_minutes_var, width=6
)
wait_minutes_spinbox.pack(side=LEFT, padx=(0, 12))
# 根据无限循环开关状态,启用/禁用运行时长输入框
def update_wait_minutes_state(*args):
if infinite_loop_var.get():
wait_minutes_spinbox.config(state="disabled")
else:
wait_minutes_spinbox.config(state="normal")
infinite_loop_var.trace("w", update_wait_minutes_state)
update_wait_minutes_state() # 初始化状态
ttk.Label(r1, text="倒计时大于(秒)时不参与(高价值可预约):").pack(side=LEFT)
ttk.Spinbox(r1, from_=0, to=3600, textvariable=skip_gt_seconds_var, width=6).pack(
side=LEFT
)
r2 = ttk.Frame(run_box)
r2.pack(fill=X, padx=10, pady=(0, 6))
ttk.Checkbutton(
r2, text="切换N次后回到第一个", variable=reset_after_swipes_enabled_var
).pack(side=LEFT)
ttk.Label(r2, text="次数:").pack(side=LEFT, padx=(10, 0))
ttk.Spinbox(
r2, from_=1, to=9999, textvariable=reset_after_swipes_var, width=6
).pack(side=LEFT)
ttk.Label(r2, text="(触发后会向上回退)").pack(side=LEFT, padx=(6, 0))
# r2_5: 滑动重置回退方式(与滑动重置配置放在一起)
r2_5 = ttk.Frame(run_box)
r2_5.pack(fill=X, padx=10, pady=(0, 10))
ttk.Label(r2_5, text="滑动重置回退方式:").pack(side=LEFT)
ttk.Combobox(
r2_5,
values=["swipe", "back"],
textvariable=reset_after_swipes_action_var,
state="readonly",
width=8,
).pack(side=LEFT, padx=(6, 0))
ttk.Label(r2_5, text="(滑动次数重置时的回退方法)").pack(side=LEFT, padx=(6, 0))
# r3: 启用返回键回退(单独一行)
r3 = ttk.Frame(run_box)
r3.pack(fill=X, padx=10, pady=(0, 6))
ttk.Checkbutton(
r3,
text="启用返回键回退",
variable=enable_back_on_misses_var,
).pack(side=LEFT)
r3b = ttk.Frame(run_box)
r3b.pack(fill=X, padx=10, pady=(0, 6))
ttk.Checkbutton(
r3b,
text="启用下滑回退直播间",
variable=swipe_down_back_enabled_var,
).pack(side=LEFT)
ttk.Label(r3b, text="次数:").pack(side=LEFT, padx=(10, 0))
ttk.Spinbox(
r3b, from_=1, to=9999, textvariable=swipe_down_back_count_var, width=6
).pack(side=LEFT)
# r4: 连续无福袋退出阈值(放在启用回退下一行,便于查看)
r4 = ttk.Frame(run_box)
r4.pack(fill=X, padx=10, pady=(0, 10))
ttk.Label(r4, text="连续无福袋退出阈值:").pack(side=LEFT)
ttk.Spinbox(
r4, from_=1, to=99999, textvariable=fudai_exit_after_misses_var, width=6
).pack(side=LEFT, padx=(6, 12))
# 标签页2:筛选设置
filter_tab = ttk.Frame(left_notebook)
left_notebook.add(filter_tab, text="筛选设置")
cfg_box = ttk.LabelFrame(filter_tab, text="福袋筛选条件")
cfg_box.pack(fill=X, padx=10, pady=(10, 10))
row = ttk.Frame(cfg_box)
row.pack(fill=X, padx=10, pady=(10, 8))
ttk.Label(row, text="最低价值(元):").pack(side=LEFT)
ttk.Spinbox(
row,
from_=0,
to=99999,
increment=0.01,
format="%.2f",
textvariable=min_value_var,
width=10,
).pack(side=LEFT)
rowp = ttk.Frame(cfg_box)
rowp.pack(fill=X, padx=10, pady=(0, 8))
ttk.Label(rowp, text="参与人数范围:").pack(side=LEFT)
ttk.Spinbox(
rowp,
from_=0,
to=99999999,
increment=1,
textvariable=min_participants_var,
width=10,
).pack(side=LEFT)
ttk.Label(rowp, text=" ~ ").pack(side=LEFT)
ttk.Spinbox(
rowp,
from_=0,
to=99999999,
increment=1,
textvariable=max_participants_var,
width=10,
).pack(side=LEFT)
ttk.Label(rowp, text="(填0表示不限制)").pack(side=LEFT)
row2 = ttk.Frame(cfg_box)
row2.pack(fill=X, padx=10, pady=(0, 8))
ttk.Label(row2, text="倒计时小于(秒)时不参与:").pack(side=LEFT)
ttk.Spinbox(
row2, from_=0, to=300, increment=1, textvariable=skip_lt_seconds_var, width=6
).pack(side=LEFT)
ttk.Label(row2, text="(剩余时间太短,不参与)").pack(side=LEFT, padx=(6, 0))
row3 = ttk.Frame(cfg_box)
row3.pack(fill=X, padx=10, pady=(0, 8))
ttk.Checkbutton(
row3, text="自动加入粉丝团(谨慎:可能消耗钻石)", variable=auto_join_var
).pack(side=LEFT)
row4 = ttk.Frame(cfg_box)
row4.pack(fill=X, padx=10, pady=(0, 10))
ttk.Label(row4, text="粉丝团失败策略:").pack(side=LEFT)
ttk.Combobox(
row4,
textvariable=fansclub_action_var,
values=["stay", "switch"],
width=10,
state="readonly",
).pack(side=LEFT)
ttk.Label(row4, text="(stay=停留,switch=切换直播间)").pack(
side=LEFT, padx=(6, 0)
)
# 粉丝团等待/点击延迟设置
row4b = ttk.Frame(cfg_box)
row4b.pack(fill=X, padx=10, pady=(0, 8))
ttk.Label(row4b, text="粉丝团点击延迟(s):").pack(side=LEFT)
ttk.Spinbox(
row4b,
from_=0.1,
to=5.0,
increment=0.1,
textvariable=fansclub_click_delay_var,
width=6,
).pack(side=LEFT, padx=(6, 12))
ttk.Label(row4b, text="自动加入等待(s):").pack(side=LEFT)
ttk.Spinbox(
row4b,
from_=0.5,
to=10.0,
increment=0.5,
textvariable=fansclub_auto_wait_var,
width=6,
).pack(side=LEFT, padx=(6, 12))
ttk.Label(row4b, text="手动加入等待(s):").pack(side=LEFT)
ttk.Spinbox(
row4b,
from_=0.5,
to=10.0,
increment=0.5,
textvariable=fansclub_manual_wait_var,
width=6,
).pack(side=LEFT, padx=(6, 0))
# 标签页3:高价值预约
reservation_tab_left = ttk.Frame(left_notebook)
left_notebook.add(reservation_tab_left, text="高价值预约")
reservation_box = ttk.LabelFrame(reservation_tab_left, text="高价值福袋预约参与")
reservation_box.pack(fill=X, padx=10, pady=(10, 10))
# 预约启用开关
res_r0 = ttk.Frame(reservation_box)
res_r0.pack(fill=X, padx=10, pady=(10, 8))
ttk.Checkbutton(
res_r0, text="启用预约(价值≥阈值)", variable=high_value_fudai_enabled_var
).pack(side=LEFT)
# 价值阈值和提前参与时间
res_r1 = ttk.Frame(reservation_box)
res_r1.pack(fill=X, padx=10, pady=(0, 8))
ttk.Label(res_r1, text="价值阈值(元):").pack(side=LEFT)
ttk.Spinbox(
res_r1,
from_=0,
to=99999,
increment=100,
textvariable=high_value_fudai_threshold_yuan_var,
width=10,
).pack(side=LEFT)
ttk.Label(res_r1, text="提前参与(秒):").pack(side=LEFT, padx=(20, 0))
ttk.Spinbox(
res_r1,
from_=5,
to=900,
increment=10,
textvariable=high_value_fudai_join_ahead_seconds_var,
width=8,
).pack(side=LEFT)
# 最多回退次数
res_r2 = ttk.Frame(reservation_box)
res_r2.pack(fill=X, padx=10, pady=(0, 8))
ttk.Label(res_r2, text="最多回退直播间次数:").pack(side=LEFT)
ttk.Spinbox(
res_r2,
from_=0,
to=300,
increment=5,
textvariable=high_value_fudai_max_swipe_back_var,
width=8,
).pack(side=LEFT)
ttk.Label(res_r2, text="(0=不限制)").pack(side=LEFT, padx=(6, 0))
# 最多记录数量和完成后策略
res_r3 = ttk.Frame(reservation_box)
res_r3.pack(fill=X, padx=10, pady=(0, 8))
ttk.Label(res_r3, text="最多记录数量:").pack(side=LEFT)
ttk.Spinbox(
res_r3,
from_=1,
to=50,
increment=1,
textvariable=high_value_fudai_max_reservations_var,
width=6,
).pack(side=LEFT)
ttk.Label(res_r3, text="完成后策略:").pack(side=LEFT, padx=(20, 0))
ttk.Combobox(
res_r3,
textvariable=high_value_fudai_after_action_var,
values=["continue", "stay"],
width=10,
state="readonly",
).pack(side=LEFT)
ttk.Label(res_r3, text="(stay=停留,continue=继续)").pack(side=LEFT, padx=(6, 0))
# 高价值房间回访
res_r4 = ttk.Frame(reservation_box)
res_r4.pack(fill=X, padx=10, pady=(0, 8))
ttk.Checkbutton(
res_r4, text="启用高价值房间回访", variable=high_value_room_revisit_enabled_var
).pack(side=LEFT)
ttk.Checkbutton(
res_r4, text="仅当前运行", variable=high_value_room_revisit_only_current_run_var
).pack(side=LEFT, padx=(20, 0))
# 高价值房间回访详细参数
res_r4a = ttk.Frame(reservation_box)
res_r4a.pack(fill=X, padx=10, pady=(0, 8))
ttk.Label(res_r4a, text="重访最小间隔(秒):").pack(side=LEFT)
ttk.Spinbox(
res_r4a,
from_=60,
to=3600,
textvariable=high_value_room_revisit_min_interval_seconds_var,
width=8,
).pack(side=LEFT, padx=(0, 20))
ttk.Label(res_r4a, text="每次运行最大次数:").pack(side=LEFT)
ttk.Spinbox(
res_r4a,
from_=1,
to=20,
textvariable=high_value_room_revisit_max_per_run_var,
width=5,
).pack(side=LEFT, padx=(0, 20))
res_r4b = ttk.Frame(reservation_box)
res_r4b.pack(fill=X, padx=10, pady=(0, 8))
ttk.Label(res_r4b, text="最低奖品价值(元):").pack(side=LEFT)
ttk.Spinbox(
res_r4b,
from_=0.0,
to=10000.0,
textvariable=high_value_room_revisit_min_prize_value_var,
width=8,
).pack(side=LEFT, padx=(0, 20))
ttk.Label(res_r4b, text="最大年龄(天):").pack(side=LEFT)
ttk.Spinbox(
res_r4b,
from_=1,
to=365,
textvariable=high_value_room_revisit_max_age_days_var,
width=5,
).pack(side=LEFT, padx=(0, 20))
# 开奖前轮询时间
res_r4b = ttk.Frame(reservation_box)
res_r4b.pack(fill=X, padx=10, pady=(0, 8))
ttk.Label(res_r4b, text="开奖前轮询时间(秒):").pack(side=LEFT)
ttk.Spinbox(
res_r4b,
from_=0.0,
to=60.0,
increment=1.0,
textvariable=high_value_fudai_poll_before_seconds_var,
width=6,
).pack(side=LEFT)
ttk.Label(res_r4b, text="(开奖前N秒开始轮询预约)").pack(side=LEFT, padx=(6, 0))
# 预约回退校验
res_r5 = ttk.Frame(reservation_box)
res_r5.pack(fill=X, padx=10, pady=(0, 8))
ttk.Checkbutton(
res_r5, text="预约回退校验", variable=reservation_back_verify_enabled_var
).pack(side=LEFT)
# 回退滑延迟和校验等待时间
res_r6 = ttk.Frame(reservation_box)
res_r6.pack(fill=X, padx=10, pady=(0, 10))
ttk.Label(res_r6, text="回退滑延迟(秒):").pack(side=LEFT)
ttk.Spinbox(
res_r6,
from_=0.0,
to=10.0,
increment=0.1,
textvariable=reservation_back_swipe_delay_var,
width=8,
).pack(side=LEFT)
ttk.Label(res_r6, text="校验等待时间(秒):").pack(side=LEFT, padx=(20, 0))
ttk.Spinbox(
res_r6,
from_=0.1,
to=10.0,
increment=0.1,
textvariable=reservation_back_verify_wait_seconds_var,
width=8,
).pack(side=LEFT)
# 养号设置标签(后续代码)
yanghao_tab = ttk.Frame(left_notebook)
left_notebook.add(yanghao_tab, text="养号设置")
yg_box = ttk.LabelFrame(yanghao_tab, text="推荐页养号(爱心/收藏/评论)")
yg_box.pack(fill=X, padx=10, pady=(10, 10))
yg_switch = ttk.Frame(yg_box)
yg_switch.pack(fill=X, padx=10, pady=(10, 6))
ttk.Checkbutton(
yg_switch, text="养号总开关(关闭则跳过推荐页养号)", variable=yg_enabled_var
).pack(side=LEFT)
ttk.Checkbutton(
yg_switch,
text="启用养号动作(爱心/收藏/评论)",
variable=yg_actions_enabled_var,
).pack(side=LEFT, padx=(10, 0))
ttk.Checkbutton(
yg_switch,
text="只养号(仅执行推荐页养号,跳过抽奖/参与)",
variable=yg_only_var,
).pack(side=LEFT, padx=(10, 0))
yg0 = ttk.Frame(yg_box)
yg0.pack(fill=X, padx=10, pady=(0, 8))
ttk.Checkbutton(
yg0,
text="逐步截图(调试用,生成 pic/*/latest.png)",
variable=yg_step_screenshot_var,
).pack(side=LEFT)
yg_time = ttk.Frame(yg_box)
yg_time.pack(fill=X, padx=10, pady=(0, 8))
ttk.Label(yg_time, text="养号时长(秒):").pack(side=LEFT)
ttk.Spinbox(
yg_time,
from_=1,
to=3600,
increment=5,
textvariable=yg_recommend_duration_var,
width=8,
).pack(side=LEFT)
ttk.Label(yg_time, text="养号间隔(秒):").pack(side=LEFT, padx=(12, 0))
ttk.Spinbox(
yg_time,
from_=0,
to=3600,
increment=10,
textvariable=yg_recommend_interval_var,
width=8,
).pack(side=LEFT)
ttk.Label(yg_time, text="(0=每次触发都执行)").pack(side=LEFT, padx=(6, 0))
yg1 = ttk.Frame(yg_box)
yg1.pack(fill=X, padx=10, pady=(0, 8))
ttk.Label(yg1, text="爱心概率:").pack(side=LEFT)
ttk.Spinbox(
yg1, from_=0.0, to=1.0, increment=0.05, textvariable=yg_like_prob_var, width=6
).pack(side=LEFT)
ttk.Label(yg1, text="收藏概率:").pack(side=LEFT, padx=(10, 0))
ttk.Spinbox(
yg1, from_=0.0, to=1.0, increment=0.05, textvariable=yg_fav_prob_var, width=6
).pack(side=LEFT)
ttk.Label(yg1, text="评论概率:").pack(side=LEFT, padx=(10, 0))
ttk.Spinbox(
yg1,
from_=0.0,
to=1.0,
increment=0.05,
textvariable=yg_comment_prob_var,
width=6,
).pack(side=LEFT)
ttk.Label(yg1, text="(0~1)").pack(side=LEFT, padx=(6, 0))
yg1b = ttk.Frame(yg_box)
yg1b.pack(fill=X, padx=10, pady=(0, 8))
ttk.Label(yg1b, text="检测动作后停留(秒):").pack(side=LEFT)
ttk.Spinbox(
yg1b,
from_=0.0,
to=120.0,
increment=1.0,
textvariable=yg_dwell_on_action_min_var,
width=6,
).pack(side=LEFT)
ttk.Label(yg1b, text="~").pack(side=LEFT, padx=(6, 6))
ttk.Spinbox(
yg1b,
from_=0.0,
to=120.0,
increment=1.0,
textvariable=yg_dwell_on_action_max_var,
width=6,
).pack(side=LEFT)
ttk.Label(yg1b, text="(随机范围)").pack(side=LEFT, padx=(6, 0))
yg2 = ttk.Frame(yg_box)
yg2.pack(fill=X, padx=10, pady=(0, 8))
ttk.Label(yg2, text="图标ROI大小(px):").pack(side=LEFT)
ttk.Spinbox(
yg2, from_=80, to=600, increment=10, textvariable=yg_icon_roi_size_var, width=6
).pack(side=LEFT)
ttk.Label(yg2, text="匹配阈值:").pack(side=LEFT, padx=(10, 0))
ttk.Spinbox(
yg2,
from_=0.0,
to=1.0,
increment=0.01,
textvariable=yg_icon_match_threshold_var,
width=6,
).pack(side=LEFT)
yg_texts = ttk.Frame(yg_box)
yg_texts.pack(fill=BOTH, expand=True, padx=10, pady=(0, 10))
ttk.Label(yg_texts, text="评论文案库(每行一条):").pack(anchor="w")
yg_comment_texts = ScrolledText(yg_texts, height=4)
yg_comment_texts.pack(fill=X, pady=(0, 6))
yg_kw = ttk.Frame(yg_texts)
yg_kw.pack(fill=BOTH, expand=True)
ttk.Label(yg_kw, text="爱心关键词(每行一条):").pack(anchor="w")
yg_like_keywords_text = ScrolledText(yg_kw, height=3)
yg_like_keywords_text.pack(fill=X, pady=(0, 6))
ttk.Label(yg_kw, text="收藏关键词(每行一条):").pack(anchor="w")
yg_fav_keywords_text = ScrolledText(yg_kw, height=3)
yg_fav_keywords_text.pack(fill=X)
quiet_box = ttk.LabelFrame(yanghao_tab, text="定时禁抢(仅养号)")
quiet_box.pack(fill=X, padx=10, pady=(0, 10))
quiet_r0 = ttk.Frame(quiet_box)
quiet_r0.pack(fill=X, padx=10, pady=(10, 6))
ttk.Checkbutton(
quiet_r0, text="启用定时禁抢", variable=fudai_quiet_hours_enabled_var
).pack(side=LEFT)
quiet_r1 = ttk.Frame(quiet_box)
quiet_r1.pack(fill=X, padx=10, pady=(0, 10))
ttk.Label(quiet_r1, text="开始小时:").pack(side=LEFT)
ttk.Spinbox(
quiet_r1, from_=0, to=23, textvariable=fudai_quiet_start_hour_var, width=6
).pack(side=LEFT)
ttk.Label(quiet_r1, text="结束小时:").pack(side=LEFT, padx=(12, 0))
ttk.Spinbox(
quiet_r1, from_=0, to=23, textvariable=fudai_quiet_end_hour_var, width=6
).pack(side=LEFT)
# 标签页5:调试参数
debug_tab = ttk.Frame(left_notebook)
# 为调试参数标签页添加滚动条
debug_canvas = tk.Canvas(debug_tab, highlightthickness=0)
debug_scrollbar = ttk.Scrollbar(
debug_tab, orient="vertical", command=debug_canvas.yview
)
debug_scrollable_frame = ttk.Frame(debug_canvas)
debug_scrollable_frame.bind(
"<Configure>",
lambda e: debug_canvas.configure(scrollregion=debug_canvas.bbox("all")),
)
debug_canvas.create_window((0, 0), window=debug_scrollable_frame, anchor="nw")
debug_canvas.configure(yscrollcommand=debug_scrollbar.set)
# 鼠标滚轮支持
def _on_mousewheel(event):
debug_canvas.yview_scroll(int(-1 * (event.delta / 120)), "units")
def _on_shift_mousewheel(event):
debug_canvas.xview_scroll(int(-1 * (event.delta / 120)), "units")
debug_canvas.bind_all("<MouseWheel>", _on_mousewheel)
debug_canvas.bind_all("<Shift-MouseWheel>", _on_shift_mousewheel)
debug_canvas.pack(side="left", fill="both", expand=True)
debug_scrollbar.pack(side="right", fill="y")
left_notebook.add(debug_tab, text="调试参数")
# 使用scrollable_frame作为容器
debug_container = debug_scrollable_frame
# 调试图像
debug_captures_box = ttk.LabelFrame(debug_container, text="调试图像")
debug_captures_box.pack(fill=X, padx=10, pady=(10, 10))
debug_r0 = ttk.Frame(debug_captures_box)
debug_r0.pack(fill=X, padx=10, pady=(10, 8))
ttk.Checkbutton(
debug_r0,
text="保存调试图像(OCR / 像素 / 模板等)",
variable=debug_captures_enabled_var,
).pack(side=LEFT)
ttk.Checkbutton(
debug_r0,
text="异步保存调试图像(默认启用)",
variable=debug_captures_async_save_var,
).pack(side=LEFT, padx=(10, 0))
ttk.Checkbutton(
debug_r0,
text="保存完成后记录日志(显示路径)",
variable=debug_captures_log_on_complete_var,
).pack(side=LEFT, padx=(10, 0))
# 异步保存计数显示与重置
debug_counts_frame = ttk.Frame(debug_r0)
debug_counts_frame.pack(side=LEFT, padx=(10, 0))
ttk.Label(debug_counts_frame, text="异步保存:").pack(side=LEFT)
ttk.Label(
debug_counts_frame, textvariable=debug_async_success_var, foreground="green"
).pack(side=LEFT, padx=(4, 8))
ttk.Label(debug_counts_frame, text="/").pack(side=LEFT)
ttk.Label(
debug_counts_frame, textvariable=debug_async_failure_var, foreground="red"
).pack(side=LEFT, padx=(4, 8))
def on_reset_async_counters():
try:
from douyin.handlers import douyin_screenshot_manager
douyin_screenshot_manager.reset_async_save_counters()
debug_async_success_var.set(0)
debug_async_failure_var.set(0)
except Exception:
pass
ttk.Button(
debug_counts_frame, text="重置", command=on_reset_async_counters, width=6
).pack(side=LEFT, padx=(6, 0))
# 周期性更新计数器(2秒)
def _update_async_counters():
try:
from douyin.handlers import douyin_screenshot_manager
s, f = douyin_screenshot_manager.get_async_save_counters()
debug_async_success_var.set(s)
debug_async_failure_var.set(f)
except Exception:
pass
try:
debug_r0.after(2000, _update_async_counters)
except Exception:
pass
# 启动更新循环
try:
_update_async_counters()
except Exception:
pass
debug_cleanup_box = ttk.LabelFrame(debug_container, text="调试图像清理")
debug_cleanup_box.pack(fill=X, padx=10, pady=(0, 10))
debug_r1 = ttk.Frame(debug_cleanup_box)
debug_r1.pack(fill=X, padx=10, pady=(10, 8))
ttk.Checkbutton(
debug_r1, text="启用自动清理调试图像", variable=debug_captures_auto_cleanup_var
).pack(side=LEFT)
debug_r2 = ttk.Frame(debug_cleanup_box)
debug_r2.pack(fill=X, padx=10, pady=(0, 8))
ttk.Label(debug_r2, text="保留天数:").pack(side=LEFT)
ttk.Spinbox(
debug_r2,
from_=1,
to=30,
increment=1,
textvariable=debug_captures_keep_days_var,
width=6,
).pack(side=LEFT)
ttk.Label(debug_r2, text="最大文件数量:").pack(side=LEFT, padx=(20, 0))
ttk.Spinbox(
debug_r2,
from_=100,
to=10000,
increment=100,
textvariable=debug_captures_max_files_var,
width=8,
).pack(side=LEFT)
ttk.Label(debug_r2, text="(超过此数量自动清理)").pack(side=LEFT, padx=(6, 0))
# 找福袋参数
fudai_find_box = ttk.LabelFrame(debug_container, text="找福袋参数")
fudai_find_box.pack(fill=X, padx=10, pady=(0, 10))
row4 = ttk.Frame(fudai_find_box)
row4.pack(fill=X, padx=10, pady=(10, 8))
ttk.Label(row4, text="找福袋最大尝试次数:").pack(side=LEFT)
ttk.Spinbox(
row4,
from_=0,
to=50,
increment=1,
textvariable=fudai_find_max_attempts_var,
width=6,
).pack(side=LEFT)
ttk.Label(row4, text="(0=使用默认值)").pack(side=LEFT, padx=(6, 0))
row4b = ttk.Frame(fudai_find_box)
row4b.pack(fill=X, padx=10, pady=(0, 8))
ttk.Label(row4b, text="找福袋重试间隔(秒):").pack(side=LEFT)
ttk.Spinbox(
row4b,
from_=0.1,
to=3.0,
increment=0.1,
textvariable=fudai_icon_retry_delay_seconds_var,
width=6,
).pack(side=LEFT)
ttk.Label(row4b, text=" 最大等待时间(秒):").pack(side=LEFT, padx=(10, 0))
ttk.Spinbox(
row4b,
from_=0.0,
to=30.0,
increment=0.5,
textvariable=fudai_icon_max_wait_seconds_var,
width=6,
).pack(side=LEFT)
ttk.Label(row4b, text="(实际识别常见 4-6 秒)").pack(side=LEFT, padx=(6, 0))
row4d = ttk.Frame(fudai_find_box)
row4d.pack(fill=X, padx=10, pady=(0, 8))
ttk.Label(row4d, text="点击福袋后等待时间(秒):").pack(side=LEFT)
ttk.Spinbox(
row4d,
from_=0.5,
to=10.0,
increment=0.1,
textvariable=fudai_click_wait_seconds_var,
width=6,
).pack(side=LEFT)
ttk.Label(row4d, text="(等待福袋详情页加载,默认1.0秒)").pack(
side=LEFT, padx=(6, 0)
)
row4c = ttk.Frame(fudai_find_box)
row4c.pack(fill=X, padx=10, pady=(0, 8))
ttk.Checkbutton(
row4c,
text="禁用福袋内容OCR识别",
variable=fudai_disable_content_recognition_var,
onvalue=True,
offvalue=False,
).pack(side=LEFT)
ttk.Label(row4c, text="(仅影响 content OCR,不改其它识别模块)").pack(
side=LEFT, padx=(6, 0)
)
# 任务列表 OCR 开关
ttk.Checkbutton(
row4c,
text="禁用福袋任务列表OCR识别",
variable=fudai_disable_task_recognition_var,
onvalue=True,
offvalue=False,
).pack(side=LEFT, padx=(12, 0))
row4e = ttk.Frame(fudai_find_box)
row4e.pack(fill=X, padx=10, pady=(0, 8))
ttk.Label(row4e, text="切换直播间后等待时间(秒):").pack(side=LEFT)
ttk.Spinbox(
row4e,
from_=0.0,
to=30.0,
increment=0.5,
textvariable=switch_room_wait_after_stage_diag_seconds_var,
width=6,
).pack(side=LEFT)
ttk.Label(row4e, text="(阶段检测后等待福袋加载,默认7.0秒)").pack(
side=LEFT, padx=(6, 0)
)
row4c = ttk.Frame(fudai_find_box)
row4c.pack(fill=X, padx=10, pady=(0, 10))
ttk.Label(row4c, text="直播间检测阈值(白色像素比例):").pack(side=LEFT)
ttk.Spinbox(
row4c,
from_=0.0,
to=1.0,
increment=0.01,
textvariable=live_room_match_threshold_var,
width=6,
).pack(side=LEFT)
ttk.Label(
row4c, text="(0.0~1.0,默认0.8,多边形区域白色像素比例>=此值判定为在直播间)"
).pack(side=LEFT, padx=(6, 0))
# 鼠标配置
mouse_config_box = ttk.LabelFrame(debug_container, text="鼠标配置")
mouse_config_box.pack(fill=X, padx=10, pady=(0, 10))
mouse_r1 = ttk.Frame(mouse_config_box)
mouse_r1.pack(fill=X, padx=10, pady=(10, 8))
ttk.Label(mouse_r1, text="滑动速度(毫秒):").pack(side=LEFT)
ttk.Spinbox(
mouse_r1,
from_=100,
to=2000,
increment=50,
textvariable=swipe_duration_ms_var,
width=6,
).pack(side=LEFT)
ttk.Label(mouse_r1, text="(滑动持续时间,默认600ms,值越大滑动越慢)").pack(
side=LEFT, padx=(6, 0)
)
mouse_r2 = ttk.Frame(mouse_config_box)
mouse_r2.pack(fill=X, padx=10, pady=(0, 10))
ttk.Label(mouse_r2, text="上滑起始Y坐标:").pack(side=LEFT)
ttk.Spinbox(
mouse_r2,
from_=400,
to=2000,
increment=50,
textvariable=swipe_up_start_y_var,
width=6,
).pack(side=LEFT)
ttk.Label(mouse_r2, text="结束Y坐标:").pack(side=LEFT, padx=(10, 0))
ttk.Spinbox(
mouse_r2,
from_=200,
to=1800,
increment=50,
textvariable=swipe_up_end_y_var,
width=6,
).pack(side=LEFT)
ttk.Label(mouse_r2, text="(基准1080x2400,默认1200→600,距离600px)").pack(
side=LEFT, padx=(6, 0)
)
# 阶段诊断时间参数(用于调试)
diag_time_box = ttk.LabelFrame(debug_container, text="阶段诊断时间参数")
diag_time_box.pack(fill=X, padx=10, pady=(0, 10))
diag_time_r1 = ttk.Frame(diag_time_box)
diag_time_r1.pack(fill=X, padx=10, pady=(10, 6))
ttk.Label(diag_time_r1, text="最大诊断时间(秒):").pack(side=LEFT)
ttk.Spinbox(
diag_time_r1,
from_=1.0,
to=60.0,
increment=1.0,
textvariable=stage_diag_max_time_var,
width=8,
).pack(side=LEFT)
ttk.Label(diag_time_r1, text="每步最大耗时(秒):").pack(side=LEFT, padx=(12, 0))
ttk.Spinbox(
diag_time_r1,
from_=0.5,
to=30.0,
increment=0.5,
textvariable=stage_diag_max_step_time_var,
width=8,
).pack(side=LEFT)
ttk.Label(diag_time_r1, text="(用于调试,延长检测时间)").pack(
side=LEFT, padx=(6, 0)
)
diag_time_r2 = ttk.Frame(diag_time_box)
diag_time_r2.pack(fill=X, padx=10, pady=(0, 6))
ttk.Checkbutton(
diag_time_r2, text="详细阶段诊断日志", variable=stage_diag_verbose_var
).pack(side=LEFT)
ttk.Checkbutton(
diag_time_r2, text="启用OCR模式1(二值化)", variable=enable_ocr_mode1_var
).pack(side=LEFT, padx=(20, 0))
diag_time_r2b = ttk.Frame(diag_time_box)
diag_time_r2b.pack(fill=X, padx=10, pady=(0, 6))
ttk.Checkbutton(
diag_time_r2b,
text="启用福袋模板匹配",
variable=fudai_template_match_enabled_var,
).pack(side=LEFT)
diag_time_r3 = ttk.Frame(diag_time_box)
diag_time_r3.pack(fill=X, padx=10, pady=(0, 10))
ttk.Label(diag_time_r3, text="福袋模板匹配阈值:").pack(side=LEFT)
ttk.Spinbox(
diag_time_r3,
from_=0.0,
to=1.0,
increment=0.01,
textvariable=fudai_template_match_threshold_var,
width=8,
).pack(side=LEFT)
ttk.Label(diag_time_r3, text="(0.0-1.0,彩色匹配)").pack(side=LEFT, padx=(6, 0))
diag_time_r3b = ttk.Frame(diag_time_box)
diag_time_r3b.pack(fill=X, padx=10, pady=(0, 10))
ttk.Label(diag_time_r3b, text="福袋详情页模板匹配阈值:").pack(side=LEFT)
ttk.Spinbox(
diag_time_r3b,
from_=0.0,
to=1.0,
increment=0.01,
textvariable=fudai_detail_template_threshold_var,
width=8,
).pack(side=LEFT)
ttk.Label(
diag_time_r3b, text="(0.0-1.0,默认0.7,区域(398,894)-(658,1179))"
).pack(side=LEFT, padx=(6, 0))
diag_time_r4 = ttk.Frame(diag_time_box)
diag_time_r4.pack(fill=X, padx=10, pady=(0, 10))
ttk.Label(diag_time_r4, text="开奖页红色占比阈值:").pack(side=LEFT)
ttk.Spinbox(
diag_time_r4,
from_=0.0,
to=1.0,
increment=0.01,
textvariable=lucky_draw_red_ratio_threshold_var,
width=8,
).pack(side=LEFT)
ttk.Label(diag_time_r4, text="(默认0.90,≥此占比判定开奖页)").pack(
side=LEFT, padx=(6, 0)
)
# 更多模板匹配阈值
diag_time_r5 = ttk.Frame(diag_time_box)
diag_time_r5.pack(fill=X, padx=10, pady=(0, 6))
ttk.Label(diag_time_r5, text="优惠券模板匹配阈值:").pack(side=LEFT)
ttk.Spinbox(
diag_time_r5,
from_=0.0,
to=1.0,
increment=0.01,
textvariable=coupon_template_match_threshold_var,
width=8,
).pack(side=LEFT)
ttk.Label(diag_time_r5, text="(默认0.75,用于检测优惠券弹窗)").pack(
side=LEFT, padx=(6, 0)
)
# 像素检测阈值
pixel_detect_box = ttk.LabelFrame(debug_container, text="像素检测阈值")
pixel_detect_box.pack(fill=X, padx=10, pady=(0, 10))
pixel_r1 = ttk.Frame(pixel_detect_box)
pixel_r1.pack(fill=X, padx=10, pady=(10, 6))
ttk.Label(pixel_r1, text="参与按钮红色占比阈值:").pack(side=LEFT)
ttk.Spinbox(
pixel_r1,
from_=0.0,
to=1.0,
increment=0.01,
textvariable=attend_button_red_ratio_threshold_var,
width=8,
).pack(side=LEFT)
ttk.Label(pixel_r1, text="(默认0.25,用于检测参与按钮)").pack(
side=LEFT, padx=(6, 0)
)
pixel_r2 = ttk.Frame(pixel_detect_box)
pixel_r2.pack(fill=X, padx=10, pady=(0, 10))
ttk.Label(pixel_r2, text="粉丝团加入红色占比阈值:").pack(side=LEFT)
ttk.Spinbox(
pixel_r2,
from_=0.0,
to=1.0,
increment=0.01,
textvariable=fansclub_join_red_ratio_threshold_var,
width=8,
).pack(side=LEFT)
ttk.Label(pixel_r2, text="(默认0.25,用于检测粉丝团加入按钮)").pack(
side=LEFT, padx=(6, 0)
)
pixel_r3 = ttk.Frame(pixel_detect_box)
pixel_r3.pack(fill=X, padx=10, pady=(0, 10))
ttk.Label(pixel_r3, text="购物红包背景红色占比阈值:").pack(side=LEFT)
ttk.Spinbox(
pixel_r3,
from_=0.0,
to=1.0,
increment=0.01,
textvariable=shopping_redpacket_red_ratio_threshold_var,
width=8,
).pack(side=LEFT)
ttk.Label(pixel_r3, text="(默认0.15,用于检测购物红包弹窗背景)").pack(
side=LEFT, padx=(6, 0)
)
# 标签页5:日志配置
logging_tab = ttk.Frame(left_notebook)
left_notebook.add(logging_tab, text="日志配置")
# 日志配置容器
logging_container = ttk.Frame(logging_tab)
logging_container.pack(fill=BOTH, expand=True, padx=10, pady=10)
# 日志格式设置
log_format_box = ttk.LabelFrame(logging_container, text="日志格式")
log_format_box.pack(fill=X, pady=(0, 10))
# 日志格式模式
log_format_r1 = ttk.Frame(log_format_box)
log_format_r1.pack(fill=X, padx=10, pady=(10, 6))
ttk.Label(log_format_r1, text="日志格式模式:").pack(side=LEFT)
ttk.Combobox(
log_format_r1,
values=["simple", "detailed"],
textvariable=logging_format_mode_var,
state="readonly",
width=12,
).pack(side=LEFT, padx=(0, 20))
ttk.Label(log_format_r1, text="(simple=简洁模式,detailed=详细模式用于debug)").pack(
side=LEFT, padx=(6, 0)
)
# 日志美化选项
log_format_r2 = ttk.Frame(log_format_box)
log_format_r2.pack(fill=X, padx=10, pady=(0, 10))
ttk.Checkbutton(
log_format_r2,
text="启用日志美化",
variable=logging_beautify_var,
).pack(side=LEFT)
ttk.Checkbutton(
log_format_r2,
text="启用颜色显示",
variable=logging_color_var,
).pack(side=LEFT, padx=(20, 0))
ttk.Checkbutton(
log_format_r2,
text="显示时间戳",
variable=logging_show_timestamps_var,
).pack(side=LEFT, padx=(20, 0))
# 日志详细程度设置
log_detail_box = ttk.LabelFrame(logging_container, text="日志详细程度")
log_detail_box.pack(fill=X, pady=(0, 10))
log_detail_r1 = ttk.Frame(log_detail_box)
log_detail_r1.pack(fill=X, padx=10, pady=(10, 6))
ttk.Label(log_detail_r1, text="调试日志详细程度:").pack(side=LEFT)
ttk.Combobox(
log_detail_r1,
values=["normal", "detailed", "minimal"],
textvariable=logging_debug_level_var,
state="readonly",
width=12,
).pack(side=LEFT, padx=(0, 20))
ttk.Label(log_detail_r1, text="错误日志详细程度:").pack(side=LEFT)
ttk.Combobox(
log_detail_r1,
values=["full", "basic", "minimal"],
textvariable=logging_error_level_var,
state="readonly",
width=12,
).pack(side=LEFT)
log_detail_r2 = ttk.Frame(log_detail_box)
log_detail_r2.pack(fill=X, padx=10, pady=(0, 10))
ttk.Label(log_detail_r2, text="行为日志格式:").pack(side=LEFT)
ttk.Combobox(
log_detail_r2,
values=["concise", "detailed", "minimal"],
textvariable=logging_action_format_var,
state="readonly",
width=12,
).pack(side=LEFT, padx=(0, 20))
ttk.Checkbutton(
log_detail_r2,
text="启用日志监控(超限告警/触发清理)",
variable=logging_enable_monitor_var,
).pack(side=LEFT, padx=(20, 0))
log_detail_r3 = ttk.Frame(log_detail_box)
log_detail_r3.pack(fill=X, padx=10, pady=(0, 10))
ttk.Checkbutton(
log_detail_r3,
text="按日期拆分日志",
variable=logging_use_dated_logs_var,
).pack(side=LEFT)
ttk.Checkbutton(
log_detail_r3,
text="写入统一日志",
variable=log_unified_enabled_var,
).pack(side=LEFT, padx=(20, 0))
ttk.Label(log_detail_r3, text="统一日志路径:").pack(side=LEFT, padx=(20, 0))
ttk.Entry(log_detail_r3, textvariable=log_unified_path_var, width=28).pack(
side=LEFT, padx=(6, 0)
)
# 日志管理设置
log_manage_box = ttk.LabelFrame(logging_container, text="日志管理")
log_manage_box.pack(fill=X, pady=(0, 10))
log_manage_r1 = ttk.Frame(log_manage_box)
log_manage_r1.pack(fill=X, padx=10, pady=(10, 6))
ttk.Checkbutton(
log_manage_r1,
text="压缩旧日志",
variable=logging_compress_logs_var,
).pack(side=LEFT)
ttk.Label(log_manage_r1, text="保留天数:").pack(side=LEFT, padx=(20, 0))
ttk.Spinbox(
log_manage_r1,
from_=1,
to=365,
increment=1,
textvariable=logging_keep_days_var,
width=6,
).pack(side=LEFT, padx=(6, 16))
ttk.Label(log_manage_r1, text="总量上限(GB):").pack(side=LEFT)
ttk.Spinbox(
log_manage_r1,
from_=0.1,
to=100.0,
increment=0.1,
textvariable=logging_max_total_size_gb_var,
width=8,
).pack(side=LEFT, padx=(6, 16))
ttk.Label(log_manage_r1, text="压缩阈值(天):").pack(side=LEFT)
ttk.Spinbox(
log_manage_r1,
from_=0,
to=365,
increment=1,
textvariable=logging_compress_after_days_var,
width=6,
).pack(side=LEFT, padx=(6, 0))
log_manage_r2 = ttk.Frame(log_manage_box)
log_manage_r2.pack(fill=X, padx=10, pady=(0, 10))
ttk.Label(log_manage_r2, text="日志总大小警告阈值(MB):").pack(side=LEFT)
ttk.Spinbox(
log_manage_r2,
from_=50,
to=20000,
increment=50,
textvariable=logging_monitor_warning_mb_var,
width=8,
).pack(side=LEFT, padx=(6, 16))
ttk.Label(log_manage_r2, text="严重阈值(MB):").pack(side=LEFT)
ttk.Spinbox(
log_manage_r2,
from_=100,
to=100000,
increment=100,
textvariable=logging_monitor_critical_mb_var,
width=8,
).pack(side=LEFT, padx=(6, 0))
# 性能追踪设置
perf_box = ttk.LabelFrame(logging_container, text="性能追踪")
perf_box.pack(fill=X, pady=(0, 10))
perf_r1 = ttk.Frame(perf_box)
perf_r1.pack(fill=X, padx=10, pady=(10, 10))
ttk.Checkbutton(
perf_r1,
text="启用性能追踪",
variable=logging_performance_enabled_var,
).pack(side=LEFT)
ttk.Checkbutton(
perf_r1,
text="追踪函数调用",
variable=logging_track_functions_var,
).pack(side=LEFT, padx=(20, 0))
ttk.Checkbutton(
perf_r1,
text="流式后台截图(加速但可能导致并发读取)",
variable=streaming_enabled_var,
).pack(side=LEFT, padx=(20, 0))
# 界面主题选择
theme_box = ttk.LabelFrame(logging_container, text="界面设置")
theme_box.pack(fill=X, pady=(0, 10))
theme_r1 = ttk.Frame(theme_box)
theme_r1.pack(fill=X, padx=10, pady=(10, 10))
ttk.Label(theme_r1, text="界面主题:").pack(side=LEFT)
ttk.Combobox(
theme_r1,
values=["litera", "flatly", "journal", "minty", "cosmo", "darkly"],
textvariable=gui_theme_var,
state="readonly",
width=12,
).pack(side=LEFT, padx=(6, 0))
ttk.Label(theme_r1, text="(更改后请保存并重启以完全应用主题)").pack(
side=LEFT, padx=(12, 0)
)
theme_r2 = ttk.Frame(theme_box)
theme_r2.pack(fill=X, padx=10, pady=(0, 10))
ttk.Label(theme_r2, text="实时状态刷新(ms):").pack(side=LEFT)
ttk.Spinbox(
theme_r2,
from_=200,
to=10000,
increment=100,
textvariable=gui_realtime_refresh_interval_ms_var,
width=8,
).pack(side=LEFT, padx=(6, 20))
ttk.Label(theme_r2, text="实时状态条数:").pack(side=LEFT)
ttk.Spinbox(
theme_r2,
from_=10,
to=500,
increment=10,
textvariable=gui_realtime_tail_items_var,
width=8,
).pack(side=LEFT, padx=(6, 0))
# 保存配置按钮
save_config_frame = ttk.Frame(logging_container)
save_config_frame.pack(fill=X, pady=(10, 0))
ttk.Button(
save_config_frame,
text="保存日志配置",
command=save_logging_config,
).pack(side=LEFT, padx=(10, 0))
# 标签页6:调试参数
debug_tab = ttk.Frame(left_notebook)
# 标签页7:关键词
keywords_tab = ttk.Frame(left_notebook)
left_notebook.add(keywords_tab, text="关键词")
kw_box = ttk.LabelFrame(keywords_tab, text="关键词(每行一个)")
kw_box.pack(fill=BOTH, expand=True, padx=10, pady=(10, 10))
ttk.Label(kw_box, text="想要 contains_want(白名单,空=不限制)").pack(
anchor="w", padx=10, pady=(10, 4)
)
want_text = ScrolledText(kw_box, height=6)
want_text.pack(fill=X, padx=10, pady=(0, 10))
ttk.Label(kw_box, text="不想要 contains_not_want(黑名单)").pack(
anchor="w", padx=10, pady=(0, 4)
)
not_want_text = ScrolledText(kw_box, height=8)
not_want_text.pack(fill=X, padx=10, pady=(0, 10))
def load_config_to_ui():
nonlocal cfg
cfg = read_config()
needswitch_var.set(bool(cfg.get("needswitch", True)))
infinite_loop_var.set(bool(cfg.get("infinite_loop_enabled", False)))
wait_minutes_var.set(int(cfg.get("wait_minutes", 5) or 5))
yg_enabled_var.set(bool(cfg.get("yanghao_enabled", True)))
yg_actions_enabled_var.set(bool(cfg.get("yanghao_enable_actions", True)))
yg_only_var.set(bool(cfg.get("yanghao_only", False)))
yg_recommend_duration_var.set(
int(cfg.get("yanghao_recommend_duration_seconds", 60) or 60)
)
yg_recommend_interval_var.set(
int(cfg.get("yanghao_recommend_interval_seconds", 0) or 0)
)
min_value_var.set(float(cfg.get("min_prize_value_yuan", 0) or 0))
min_participants_var.set(int(cfg.get("min_participants", 0) or 0))
max_participants_var.set(int(cfg.get("max_participants", 0) or 0))
skip_gt_seconds_var.set(
int(cfg.get("skip_if_countdown_gt_seconds", 900) or 900)
)
reset_after_swipes_enabled_var.set(
bool(cfg.get("reset_after_swipes_enabled", False))
)
reset_after_swipes_var.set(int(cfg.get("reset_after_swipes", 10) or 10))
reset_after_swipes_action_var.set(
str(cfg.get("reset_after_swipes_action", "swipe") or "swipe")
)
enable_back_on_misses_var.set(bool(cfg.get("enable_back_on_misses", True)))
swipe_down_back_enabled_var.set(
bool(cfg.get("swipe_down_back_enabled", False))
)
swipe_down_back_count_var.set(int(cfg.get("swipe_down_back_count", 3) or 3))
auto_join_var.set(bool(cfg.get("auto_join_fansclub", False)))
fansclub_action_var.set(
str(cfg.get("fansclub_fail_action", "stay") or "stay").lower()
)
streaming_enabled_var.set(bool(cfg.get("enable_streaming_screenshot", True)))
lucky_draw_red_ratio_threshold_var.set(
float(cfg.get("lucky_draw_red_ratio_threshold", 0.9) or 0.9)
)
y_var.set(int(cfg.get("y_pianyi", 0) or 0))
# Web端新增配置 - 高价值预约相关
high_value_fudai_enabled_var.set(
bool(cfg.get("high_value_fudai_enabled", False))
)
high_value_fudai_threshold_yuan_var.set(
float(cfg.get("high_value_fudai_threshold_yuan", 1000) or 1000)
)
high_value_fudai_join_ahead_seconds_var.set(
int(cfg.get("high_value_fudai_join_ahead_seconds", 300) or 300)
)
high_value_fudai_max_swipe_back_var.set(
int(cfg.get("high_value_fudai_max_swipe_back", 60) or 60)
)
high_value_fudai_max_reservations_var.set(
int(cfg.get("high_value_fudai_max_reservations", 5) or 5)
)
high_value_fudai_after_action_var.set(
str(cfg.get("high_value_fudai_after_action", "continue") or "continue")
)
high_value_fudai_poll_before_seconds_var.set(
float(cfg.get("high_value_fudai_poll_before_seconds", 10.0) or 10.0)
)
high_value_room_revisit_enabled_var.set(
bool(cfg.get("high_value_room_revisit_enabled", True))
)
high_value_room_revisit_only_current_run_var.set(
bool(cfg.get("high_value_room_revisit_only_current_run", False))
)
high_value_room_revisit_min_interval_seconds_var.set(
int(cfg.get("high_value_room_revisit_min_interval_seconds", 300))
)
high_value_room_revisit_max_per_run_var.set(
int(cfg.get("high_value_room_revisit_max_per_run", 5))
)
high_value_room_revisit_min_prize_value_var.set(
float(cfg.get("high_value_room_revisit_min_prize_value", 0.0))
)
high_value_room_revisit_max_age_days_var.set(
int(cfg.get("high_value_room_revisit_max_age_days", 30))
)
reservation_back_verify_enabled_var.set(
bool(cfg.get("reservation_back_verify_enabled", True))
)
reservation_back_swipe_delay_var.set(
float(cfg.get("reservation_back_swipe_delay", 0) or 0)
)
reservation_back_verify_wait_seconds_var.set(
float(cfg.get("reservation_back_verify_wait_seconds", 5.0) or 5.0)
)
fudai_find_max_attempts_var.set(int(cfg.get("fudai_find_max_attempts", 0) or 0))
fudai_icon_retry_delay_seconds_var.set(
float(cfg.get("fudai_icon_retry_delay_seconds", 0.6) or 0.6)
)
fudai_icon_max_wait_seconds_var.set(
float(cfg.get("fudai_icon_max_wait_seconds", 5.0) or 5.0)
)
fudai_click_wait_seconds_var.set(
float(cfg.get("fudai_click_wait_seconds", 1.0) or 1.0)
)
fudai_disable_content_recognition_var.set(
bool(cfg.get("fudai_disable_content_recognition", False))
)
fudai_disable_task_recognition_var.set(
bool(cfg.get("fudai_disable_task_recognition", False))
)
try:
fudai_exit_after_misses_var.set(
int(cfg.get("fudai_exit_after_misses", 30) or 30)
)
except Exception:
fudai_exit_after_misses_var.set(30)
try:
enable_back_on_misses_var.set(bool(cfg.get("enable_back_on_misses", True)))
except Exception:
enable_back_on_misses_var.set(True)
try:
reset_after_swipes_action_var.set(
str(cfg.get("reset_after_swipes_action", "swipe"))
)
except Exception:
reset_after_swipes_action_var.set("swipe")
switch_room_wait_after_stage_diag_seconds_var.set(
float(cfg.get("switch_room_wait_after_stage_diag_seconds", 7.0) or 7.0)
)
# GUI 主题
try:
gui_theme_var.set(
str(cfg.get("gui", {}).get("theme", "litera") or "litera")
)
except Exception:
gui_theme_var.set("litera")
live_room_match_threshold_var.set(
float(cfg.get("live_room_match_threshold", 0.8) or 0.8)
)
swipe_duration_ms_var.set(int(cfg.get("swipe_duration_ms", 600) or 600))
swipe_up_start_y_var.set(int(cfg.get("swipe_up_start_y", 1200) or 1200))
swipe_up_end_y_var.set(int(cfg.get("swipe_up_end_y", 600) or 600))
fudai_quiet_hours_enabled_var.set(
bool(cfg.get("fudai_quiet_hours_enabled", True))
)
fudai_quiet_start_hour_var.set(int(cfg.get("fudai_quiet_start_hour", 2) or 2))
fudai_quiet_end_hour_var.set(int(cfg.get("fudai_quiet_end_hour", 7) or 7))
stage_diag_max_time_var.set(float(cfg.get("stage_diag_max_time", 10.0) or 10.0))
stage_diag_max_step_time_var.set(
float(cfg.get("stage_diag_max_step_time", 2.0) or 2.0)
)
stage_diag_verbose_var.set(
bool(cfg.get("logging", {}).get("stage_diag_verbose", True))
)
enable_ocr_mode1_var.set(bool(cfg.get("enable_ocr_mode1", False)))
fudai_template_match_enabled_var.set(
bool(cfg.get("fudai_template_match_enabled", False))
)
fudai_template_match_threshold_var.set(
float(cfg.get("fudai_template_match_threshold", 0.7) or 0.7)
)
fudai_detail_template_threshold_var.set(
float(cfg.get("fudai_detail_template_threshold", 0.7) or 0.7)
)
coupon_template_match_threshold_var.set(
float(cfg.get("coupon_template_match_threshold", 0.75) or 0.75)
)
attend_button_red_ratio_threshold_var.set(
float(cfg.get("attend_button_red_ratio_threshold", 0.25) or 0.25)
)
fansclub_join_red_ratio_threshold_var.set(
float(cfg.get("fansclub_join_red_ratio_threshold", 0.25) or 0.25)
)
shopping_redpacket_red_ratio_threshold_var.set(
float(cfg.get("shopping_redpacket_red_ratio_threshold", 0.15) or 0.15)
)
# 粉丝团等待/点击延迟配置
fansclub_click_delay_var.set(float(cfg.get("fansclub_click_delay", 0.6) or 0.6))
fansclub_auto_wait_var.set(
float(cfg.get("fansclub_auto_join_wait_seconds", 5.0) or 5.0)
)
fansclub_manual_wait_var.set(
float(cfg.get("fansclub_manual_wait_seconds", 3.0) or 3.0)
)
skip_lt_seconds_var.set(int(cfg.get("skip_if_countdown_lt_seconds", 10) or 10))
# 调试图像清理配置
debug_captures_config = cfg.get("debug_captures", {})
if isinstance(debug_captures_config, dict):
debug_captures_enabled_var.set(
bool(debug_captures_config.get("enabled", False))
)
debug_captures_auto_cleanup_var.set(
bool(debug_captures_config.get("auto_cleanup", True))
)
debug_captures_keep_days_var.set(
int(debug_captures_config.get("keep_days", 7) or 7)
)
debug_captures_max_files_var.set(
int(debug_captures_config.get("max_files", 2000) or 2000)
)
debug_captures_async_save_var.set(
bool(debug_captures_config.get("async_save", True))
)
debug_captures_log_on_complete_var.set(
bool(debug_captures_config.get("log_on_complete", False))
)
else:
debug_captures_auto_cleanup_var.set(True)
debug_captures_keep_days_var.set(7)
debug_captures_max_files_var.set(2000)
# 日志配置(load_config_to_ui 需要覆盖 UI 变量,避免“保存后再加载不生效”)
logging_config = cfg.get("logging", {})
if isinstance(logging_config, dict):
logging_beautify_var.set(bool(logging_config.get("beautify_output", True)))
logging_color_var.set(bool(logging_config.get("color_output", True)))
logging_show_timestamps_var.set(
bool(logging_config.get("show_timestamps", True))
)
logging_use_dated_logs_var.set(
bool(logging_config.get("use_dated_logs", True))
)
logging_enable_monitor_var.set(
bool(logging_config.get("enable_monitor", True))
)
log_unified_enabled_var.set(bool(cfg.get("log_unified_enabled", True)))
log_unified_path_var.set(
str(cfg.get("log_unified_path", "logs/unified.log") or "logs/unified.log")
)
logging_keep_days_var.set(int(logging_config.get("keep_days", 30) or 30))
logging_compress_logs_var.set(
bool(logging_config.get("compress_logs", True))
)
logging_max_total_size_gb_var.set(
float(logging_config.get("max_total_size_gb", 10.0) or 10.0)
)
logging_compress_after_days_var.set(
int(logging_config.get("compress_after_days", 7) or 7)
)
logging_debug_level_var.set(
str(logging_config.get("debug_detail_level", "normal") or "normal")
)
logging_error_level_var.set(
str(logging_config.get("error_detail_level", "full") or "full")
)
logging_action_format_var.set(
str(logging_config.get("action_log_format", "concise") or "concise")
)
logging_format_mode_var.set(
str(logging_config.get("log_format_mode", "simple") or "simple")
)
perf_cfg = logging_config.get("performance_tracking", {})
if isinstance(perf_cfg, dict):
logging_performance_enabled_var.set(bool(perf_cfg.get("enabled", True)))
logging_track_functions_var.set(
bool(perf_cfg.get("track_function_calls", True))
)
logging_monitor_warning_mb_var.set(
float(logging_config.get("monitor_warning_mb", 500.0) or 500.0)
)
logging_monitor_critical_mb_var.set(
float(logging_config.get("monitor_critical_mb", 2000.0) or 2000.0)
)
yg_like_prob_var.set(float(cfg.get("yanghao_like_prob", 0.0) or 0.0))
yg_fav_prob_var.set(float(cfg.get("yanghao_fav_prob", 0.0) or 0.0))
yg_comment_prob_var.set(float(cfg.get("yanghao_comment_prob", 0.0) or 0.0))
yg_dwell_on_action_min_var.set(
float(cfg.get("yanghao_dwell_on_action_min_seconds", 5) or 5)
)
yg_dwell_on_action_max_var.set(
float(cfg.get("yanghao_dwell_on_action_max_seconds", 30) or 30)
)
yg_icon_roi_size_var.set(int(cfg.get("yanghao_icon_roi_size", 240) or 240))
yg_icon_match_threshold_var.set(
float(cfg.get("yanghao_icon_match_threshold", 0.72) or 0.72)
)
yg_step_screenshot_var.set(bool(cfg.get("yanghao_step_screenshot", False)))
yg_like_roi_offset_x_var.set(int(cfg.get("yanghao_like_roi_offset_x", 0) or 0))
yg_like_roi_offset_y_var.set(int(cfg.get("yanghao_like_roi_offset_y", 0) or 0))
yg_fav_roi_offset_x_var.set(int(cfg.get("yanghao_fav_roi_offset_x", 0) or 0))
yg_fav_roi_offset_y_var.set(int(cfg.get("yanghao_fav_roi_offset_y", 0) or 0))
yg_like_icon_x_var.set(int(cfg.get("yanghao_like_icon_x", 0) or 0))
yg_like_icon_y_var.set(int(cfg.get("yanghao_like_icon_y", 0) or 0))
yg_fav_icon_x_var.set(int(cfg.get("yanghao_fav_icon_x", 0) or 0))
yg_fav_icon_y_var.set(int(cfg.get("yanghao_fav_icon_y", 0) or 0))
yg_like_template_path_var.set(
str(
cfg.get("yanghao_like_template_path", "assets/like.png")
or "assets/like.png"
)
)
yg_fav_template_path_var.set(
str(
cfg.get("yanghao_fav_template_path", "assets/fav.png")
or "assets/fav.png"
)
)
yg_after_dwell_direction_var.set(
str(cfg.get("yanghao_after_dwell_swipe_direction", "up") or "up")
)
yg_after_dwell_distance_var.set(
int(cfg.get("yanghao_after_dwell_swipe_distance_px", 900) or 900)
)
yg_comment_btn_x_var.set(int(cfg.get("yanghao_comment_btn_x", 0) or 0))
yg_comment_btn_y_var.set(int(cfg.get("yanghao_comment_btn_y", 0) or 0))
yg_comment_input_x_var.set(int(cfg.get("yanghao_comment_input_x", 0) or 0))
yg_comment_input_y_var.set(int(cfg.get("yanghao_comment_input_y", 0) or 0))
yg_comment_send_x_var.set(int(cfg.get("yanghao_comment_send_x", 0) or 0))
yg_comment_send_y_var.set(int(cfg.get("yanghao_comment_send_y", 0) or 0))
yg_comment_close_x_var.set(int(cfg.get("yanghao_comment_close_x", 0) or 0))
yg_comment_close_y_var.set(int(cfg.get("yanghao_comment_close_y", 0) or 0))
# 仅保留黑名单 contains_not_want
want = cfg.get("contains_want", []) or []
not_want = cfg.get("contains_not_want", []) or []
yg_comment_texts_list = cfg.get("yanghao_comment_texts", []) or []
yg_like_keywords_list = cfg.get("yanghao_like_keywords", []) or []
yg_fav_keywords_list = cfg.get("yanghao_fav_keywords", []) or []
want_text.delete("1.0", "end")
want_text.insert("1.0", "\n".join(want))
not_want_text.delete("1.0", "end")
not_want_text.insert("1.0", "\n".join(not_want))
yg_comment_texts.delete("1.0", "end")
yg_comment_texts.insert("1.0", "\n".join(yg_comment_texts_list))
yg_like_keywords_text.delete("1.0", "end")
yg_like_keywords_text.insert("1.0", "\n".join(yg_like_keywords_list))
yg_fav_keywords_text.delete("1.0", "end")
yg_fav_keywords_text.insert("1.0", "\n".join(yg_fav_keywords_list))
def save_ui_to_config():
want_lines = [
x.strip() for x in want_text.get("1.0", "end").splitlines() if x.strip()
]
not_want_lines = [
x.strip() for x in not_want_text.get("1.0", "end").splitlines() if x.strip()
]
yg_comment_text_lines = [
x.strip()
for x in yg_comment_texts.get("1.0", "end").splitlines()
if x.strip()
]
yg_like_kw_lines = [
x.strip()
for x in yg_like_keywords_text.get("1.0", "end").splitlines()
if x.strip()
]
yg_fav_kw_lines = [
x.strip()
for x in yg_fav_keywords_text.get("1.0", "end").splitlines()
if x.strip()
]
cfg2 = read_config()
cfg2["needswitch"] = bool(needswitch_var.get())
cfg2["infinite_loop_enabled"] = bool(infinite_loop_var.get())
cfg2["wait_minutes"] = int(wait_minutes_var.get() or 5)
cfg2["y_pianyi"] = int(y_var.get() or 0)
cfg2["contains_want"] = want_lines
cfg2["contains_not_want"] = not_want_lines
cfg2["min_prize_value_yuan"] = float(min_value_var.get() or 0)
cfg2["min_participants"] = int(min_participants_var.get() or 0)
cfg2["max_participants"] = int(max_participants_var.get() or 0)
cfg2["skip_if_countdown_gt_seconds"] = int(skip_gt_seconds_var.get() or 900)
cfg2["reset_after_swipes_enabled"] = bool(reset_after_swipes_enabled_var.get())
cfg2["reset_after_swipes"] = int(reset_after_swipes_var.get() or 10)
cfg2["auto_join_fansclub"] = bool(auto_join_var.get())
cfg2["fansclub_fail_action"] = str(fansclub_action_var.get() or "stay").lower()
cfg2["lucky_draw_red_ratio_threshold"] = float(
lucky_draw_red_ratio_threshold_var.get() or 0.9
)
# Web端新增配置 - 高价值预约相关
cfg2["high_value_fudai_enabled"] = bool(high_value_fudai_enabled_var.get())
cfg2["high_value_fudai_threshold_yuan"] = float(
high_value_fudai_threshold_yuan_var.get() or 1000
)
cfg2["high_value_fudai_join_ahead_seconds"] = int(
high_value_fudai_join_ahead_seconds_var.get() or 300
)
cfg2["high_value_fudai_max_swipe_back"] = int(
high_value_fudai_max_swipe_back_var.get() or 60
)
cfg2["high_value_fudai_max_reservations"] = int(
high_value_fudai_max_reservations_var.get() or 5
)
cfg2["high_value_fudai_after_action"] = str(
high_value_fudai_after_action_var.get() or "continue"
).lower()
cfg2["high_value_fudai_poll_before_seconds"] = float(
high_value_fudai_poll_before_seconds_var.get() or 10.0
)
cfg2["high_value_room_revisit_enabled"] = bool(
high_value_room_revisit_enabled_var.get()
)
cfg2["high_value_room_revisit_only_current_run"] = bool(
high_value_room_revisit_only_current_run_var.get()
)
cfg2["high_value_room_revisit_min_interval_seconds"] = int(
high_value_room_revisit_min_interval_seconds_var.get()
)
cfg2["high_value_room_revisit_max_per_run"] = int(
high_value_room_revisit_max_per_run_var.get()
)
cfg2["high_value_room_revisit_min_prize_value"] = float(
high_value_room_revisit_min_prize_value_var.get()
)
cfg2["high_value_room_revisit_max_age_days"] = int(
high_value_room_revisit_max_age_days_var.get()
)
cfg2["reservation_back_verify_enabled"] = bool(
reservation_back_verify_enabled_var.get()
)
cfg2["reservation_back_swipe_delay"] = float(
reservation_back_swipe_delay_var.get() or 0
)
cfg2["reservation_back_verify_wait_seconds"] = float(
reservation_back_verify_wait_seconds_var.get() or 5.0
)
cfg2["fudai_find_max_attempts"] = int(fudai_find_max_attempts_var.get() or 0)
cfg2["fudai_icon_retry_delay_seconds"] = float(
fudai_icon_retry_delay_seconds_var.get() or 0.6
)
cfg2["fudai_icon_max_wait_seconds"] = float(
fudai_icon_max_wait_seconds_var.get() or 5.0
)
cfg2["fudai_click_wait_seconds"] = float(
fudai_click_wait_seconds_var.get() or 2.0
)
cfg2["fudai_exit_after_misses"] = int(fudai_exit_after_misses_var.get() or 30)
cfg2["enable_back_on_misses"] = bool(enable_back_on_misses_var.get())
cfg2["swipe_down_back_enabled"] = bool(swipe_down_back_enabled_var.get())
cfg2["swipe_down_back_count"] = int(swipe_down_back_count_var.get() or 3)
cfg2["reset_after_swipes_action"] = str(
reset_after_swipes_action_var.get() or "swipe"
)
cfg2["fudai_disable_content_recognition"] = bool(
fudai_disable_content_recognition_var.get()
)
cfg2["fudai_disable_task_recognition"] = bool(
fudai_disable_task_recognition_var.get()
)
cfg2["switch_room_wait_after_stage_diag_seconds"] = float(
switch_room_wait_after_stage_diag_seconds_var.get() or 7.0
)
cfg2["live_room_match_threshold"] = float(
live_room_match_threshold_var.get() or 0.8
)
cfg2["swipe_duration_ms"] = int(swipe_duration_ms_var.get() or 600)
cfg2["swipe_up_start_y"] = int(swipe_up_start_y_var.get() or 1200)
cfg2["swipe_up_end_y"] = int(swipe_up_end_y_var.get() or 600)
cfg2["fudai_quiet_hours_enabled"] = bool(fudai_quiet_hours_enabled_var.get())
cfg2["fudai_quiet_start_hour"] = int(fudai_quiet_start_hour_var.get() or 0)
cfg2["fudai_quiet_end_hour"] = int(fudai_quiet_end_hour_var.get() or 0)
cfg2["stage_diag_max_time"] = float(stage_diag_max_time_var.get() or 10.0)
cfg2["stage_diag_max_step_time"] = float(
stage_diag_max_step_time_var.get() or 2.0
)
cfg2["enable_ocr_mode1"] = bool(cfg.get("enable_ocr_mode1", False))
cfg2["fudai_template_match_enabled"] = bool(
fudai_template_match_enabled_var.get()
)
cfg2["fudai_template_match_threshold"] = float(
fudai_template_match_threshold_var.get() or 0.7
)
cfg2["fudai_detail_template_threshold"] = float(
fudai_detail_template_threshold_var.get() or 0.7
)
cfg2["coupon_template_match_threshold"] = float(
coupon_template_match_threshold_var.get() or 0.75
)
cfg2["attend_button_red_ratio_threshold"] = float(
attend_button_red_ratio_threshold_var.get() or 0.25
)
cfg2["fansclub_join_red_ratio_threshold"] = float(
fansclub_join_red_ratio_threshold_var.get() or 0.25
)
cfg2["shopping_redpacket_red_ratio_threshold"] = float(
shopping_redpacket_red_ratio_threshold_var.get() or 0.15
)
# 粉丝团等待/点击延迟配置
cfg2["fansclub_click_delay"] = float(fansclub_click_delay_var.get() or 0.6)
cfg2["fansclub_auto_join_wait_seconds"] = float(
fansclub_auto_wait_var.get() or 5.0
)
cfg2["fansclub_manual_wait_seconds"] = float(
fansclub_manual_wait_var.get() or 3.0
)
cfg2["skip_if_countdown_lt_seconds"] = int(skip_lt_seconds_var.get() or 10)
# 调试图像清理配置
if "debug_captures" not in cfg2 or not isinstance(cfg2["debug_captures"], dict):
cfg2["debug_captures"] = {}
cfg2["debug_captures"]["enabled"] = bool(debug_captures_enabled_var.get())
cfg2["debug_captures"]["auto_cleanup"] = bool(
debug_captures_auto_cleanup_var.get()
)
cfg2["debug_captures"]["keep_days"] = int(
debug_captures_keep_days_var.get() or 7
)
cfg2["debug_captures"]["max_files"] = int(
debug_captures_max_files_var.get() or 2000
)
cfg2["debug_captures"]["async_save"] = bool(debug_captures_async_save_var.get())
cfg2["debug_captures"]["log_on_complete"] = bool(
debug_captures_log_on_complete_var.get()
)
# 日志配置
if "logging" not in cfg2 or not isinstance(cfg2["logging"], dict):
cfg2["logging"] = {}
cfg2["logging"]["beautify_output"] = bool(logging_beautify_var.get())
cfg2["logging"]["color_output"] = bool(logging_color_var.get())
cfg2["logging"]["show_timestamps"] = bool(logging_show_timestamps_var.get())
cfg2["logging"]["use_dated_logs"] = bool(logging_use_dated_logs_var.get())
cfg2["logging"]["enable_monitor"] = bool(logging_enable_monitor_var.get())
cfg2["logging"]["keep_days"] = int(logging_keep_days_var.get() or 30)
cfg2["logging"]["compress_logs"] = bool(logging_compress_logs_var.get())
cfg2["logging"]["max_total_size_gb"] = float(
logging_max_total_size_gb_var.get() or 10.0
)
cfg2["logging"]["compress_after_days"] = int(
logging_compress_after_days_var.get() or 7
)
cfg2["logging"]["debug_detail_level"] = str(
logging_debug_level_var.get() or "normal"
)
cfg2["logging"]["error_detail_level"] = str(
logging_error_level_var.get() or "full"
)
cfg2["logging"]["action_log_format"] = str(
logging_action_format_var.get() or "concise"
)
cfg2["logging"]["log_format_mode"] = str(
logging_format_mode_var.get() or "simple"
)
cfg2["logging"]["stage_diag_verbose"] = bool(stage_diag_verbose_var.get())
cfg2["logging"]["monitor_warning_mb"] = float(
logging_monitor_warning_mb_var.get() or 500.0
)
cfg2["logging"]["monitor_critical_mb"] = float(
logging_monitor_critical_mb_var.get() or 2000.0
)
# 性能追踪配置
if "performance_tracking" not in cfg2["logging"] or not isinstance(
cfg2["logging"]["performance_tracking"], dict
):
cfg2["logging"]["performance_tracking"] = {}
cfg2["logging"]["performance_tracking"]["enabled"] = bool(
logging_performance_enabled_var.get()
)
cfg2["logging"]["performance_tracking"]["track_function_calls"] = bool(
logging_track_functions_var.get()
)
cfg2["log_unified_enabled"] = bool(log_unified_enabled_var.get())
cfg2["log_unified_path"] = str(log_unified_path_var.get() or "logs/unified.log")
cfg2["yanghao_enabled"] = bool(yg_enabled_var.get())
cfg2["yanghao_enable_actions"] = bool(yg_actions_enabled_var.get())
cfg2["yanghao_only"] = bool(yg_only_var.get())
cfg2["yanghao_recommend_duration_seconds"] = int(
yg_recommend_duration_var.get() or 60
)
cfg2["yanghao_recommend_interval_seconds"] = int(
yg_recommend_interval_var.get() or 0
)
cfg2["yanghao_like_prob"] = float(yg_like_prob_var.get() or 0.0)
cfg2["yanghao_fav_prob"] = float(yg_fav_prob_var.get() or 0.0)
cfg2["yanghao_comment_prob"] = float(yg_comment_prob_var.get() or 0.0)
cfg2["yanghao_dwell_on_action_min_seconds"] = float(
yg_dwell_on_action_min_var.get() or 5
)
cfg2["yanghao_dwell_on_action_max_seconds"] = float(
yg_dwell_on_action_max_var.get() or 30
)
cfg2["yanghao_icon_roi_size"] = int(yg_icon_roi_size_var.get() or 240)
cfg2["yanghao_icon_match_threshold"] = float(
yg_icon_match_threshold_var.get() or 0.72
)
cfg2["yanghao_step_screenshot"] = bool(yg_step_screenshot_var.get())
cfg2["yanghao_like_roi_offset_x"] = int(yg_like_roi_offset_x_var.get() or 0)
cfg2["yanghao_like_roi_offset_y"] = int(yg_like_roi_offset_y_var.get() or 0)
cfg2["yanghao_fav_roi_offset_x"] = int(yg_fav_roi_offset_x_var.get() or 0)
cfg2["yanghao_fav_roi_offset_y"] = int(yg_fav_roi_offset_y_var.get() or 0)
cfg2["yanghao_like_icon_x"] = int(yg_like_icon_x_var.get() or 0)
cfg2["yanghao_like_icon_y"] = int(yg_like_icon_y_var.get() or 0)
cfg2["yanghao_fav_icon_x"] = int(yg_fav_icon_x_var.get() or 0)
cfg2["yanghao_fav_icon_y"] = int(yg_fav_icon_y_var.get() or 0)
cfg2["yanghao_like_template_path"] = str(
yg_like_template_path_var.get() or "assets/like.png"
)
cfg2["yanghao_fav_template_path"] = str(
yg_fav_template_path_var.get() or "assets/fav.png"
)
cfg2["yanghao_after_dwell_swipe_direction"] = str(
yg_after_dwell_direction_var.get() or "up"
)
cfg2["yanghao_after_dwell_swipe_distance_px"] = int(
yg_after_dwell_distance_var.get() or 900
)
cfg2["yanghao_comment_btn_x"] = int(yg_comment_btn_x_var.get() or 0)
cfg2["yanghao_comment_btn_y"] = int(yg_comment_btn_y_var.get() or 0)
cfg2["yanghao_comment_input_x"] = int(yg_comment_input_x_var.get() or 0)
cfg2["yanghao_comment_input_y"] = int(yg_comment_input_y_var.get() or 0)
cfg2["yanghao_comment_send_x"] = int(yg_comment_send_x_var.get() or 0)
cfg2["yanghao_comment_send_y"] = int(yg_comment_send_y_var.get() or 0)
cfg2["yanghao_comment_close_x"] = int(yg_comment_close_x_var.get() or 0)
cfg2["yanghao_comment_close_y"] = int(yg_comment_close_y_var.get() or 0)
cfg2["yanghao_comment_texts"] = yg_comment_text_lines
cfg2["yanghao_like_keywords"] = yg_like_kw_lines
cfg2["yanghao_fav_keywords"] = yg_fav_kw_lines
# 流式后台截图配置
cfg2["enable_streaming_screenshot"] = bool(streaming_enabled_var.get())
# GUI 配置
if "gui" not in cfg2 or not isinstance(cfg2["gui"], dict):
cfg2["gui"] = {}
cfg2["gui"]["theme"] = str(gui_theme_var.get() or "litera")
cfg2["gui"]["realtime_status"] = {
"refresh_interval_ms": int(
gui_realtime_refresh_interval_ms_var.get() or 1000
),
"tail_items": int(gui_realtime_tail_items_var.get() or 50),
}
write_config(cfg2)
on_line("[配置] 已保存到 config.json")
# 如果用户关闭了流式后台截图,尝试停止正在运行的服务实例以立即生效
try:
from operations.screenshot_service import ScreenshotService
if not bool(cfg2.get("enable_streaming_screenshot", True)):
try:
ScreenshotService.get_instance().stop()
on_line("[截图服务] 已停止后台流式截图(配置更新)")
except Exception:
on_line("[截图服务] 停止后台截图服务失败(请重启程序以确保生效)")
except Exception:
# ignore if service module not available
pass
load_config_to_ui()
# 顶部常驻按钮区域(与设备选择同一行,不随左侧滚动)
top_btns = ttk.Frame(top)
top_btns.pack(side=RIGHT, padx=(20, 0))
ttk.Button(top_btns, text="保存配置", command=save_ui_to_config).pack(
side=LEFT, padx=(0, 8)
)
# 截图+OCR 按钮也放在顶部,方便随时使用
# 具体回调在后文定义,这里先占位,通过 lambda 延迟绑定
screenshot_button_var = {"command": None}
def _bind_screenshot_button(btn):
# 在 do_screenshot 定义后调用,将真正的 command 绑定到按钮
screenshot_button_var["button"] = btn
screenshot_btn = ttk.Button(top_btns, text="截图+OCR")
screenshot_btn.pack(side=LEFT, padx=(0, 8))
_bind_screenshot_button(screenshot_btn)
# OCR区域配置:定义所有需要识别的区域(坐标基于1080x2400基准)
OCR_REGIONS = [
# (区域名称, (x1, y1, x2, y2), 描述)
("福袋内容", (389, 1273, 1000, 1534), "福袋内容详情"),
("福袋倒计时", (390, 1470, 980, 1580), "福袋倒计时"),
("福袋价值", (390, 1440, 1000, 1580), "奖品价值/价格"),
("抽奖结果", (380, 660, 720, 755), "抽奖结果弹窗"),
("推荐页标签栏", (400, 140, 900, 200), "推荐/关注/直播标签"),
("推荐页标签栏快速检测", (400, 140, 900, 200), "推荐页快速检测"),
("参与按钮", (306, 2030, 780, 2110), "参与福袋抽奖按钮"),
("无奖励确认", (340, 1195, 740, 1355), "无奖励确认弹窗"),
("奖励通知确认", (370, 1350, 680, 1440), "奖励通知确认"),
("订单确认", (370, 120, 700, 220), "订单确认页面"),
("关注列表标签", (658, 147, 765, 194), "关注列表标签"),
("直播列表标签", (400, 140, 900, 200), "直播列表标签"),
("直播广场", (400, 140, 900, 200), "直播广场标题"),
("直播间标题_中", (400, 140, 900, 200), "直播间标题中部"),
("诊断优惠券标题", (60, 1260, 1020, 1480), "优惠券弹窗标题"),
("诊断优惠券按钮", (400, 1600, 680, 1700), "优惠券按钮"),
("诊断购物红包", (400, 1400, 900, 1600), "购物红包弹窗"),
]
# 截图按钮
def do_screenshot():
device_id = device_var.get().strip()
if not device_id:
on_line("[截图] 请先选择设备")
return
# 在后台线程中执行截图和OCR识别,避免阻塞GUI
def screenshot_thread():
try:
from douyin.core.underlying_operations import underlying_operations
# 使用模块级别导入的 Image 与 os,避免重复导入导致 Pylance 警告
# 使用 root.after 在主线程中更新日志
def log_msg(msg: str) -> Callable[[], None]:
def wrapper() -> None:
on_line(msg)
return wrapper
root.after(0, log_msg("[截图] 正在截图...")) # type: ignore[arg-type]
ops = underlying_operations()
result = ops.get_screenshot(device_id, use_service=False)
if not result:
root.after(0, log_msg("[截图] 截图失败")) # type: ignore[arg-type]
return
root.after(0, log_msg("[截图] 截图成功,已保存到 pic/screenshot.png")) # type: ignore[arg-type]
# 读取截图以获取实际尺寸
try:
from douyin.core.path_config import get_screenshot_path
screenshot_path = get_screenshot_path()
except Exception:
# 回退到旧路径(向后兼容)
from douyin.core import path_config
screenshot_path = path_config.get_screenshot_path()
if not os.path.exists(screenshot_path):
root.after(0, log_msg("[OCR] 截图文件不存在")) # type: ignore[arg-type]
return
try:
img = Image.open(screenshot_path)
img.load() # Force load to catch truncated files early
img_width, img_height = img.size
# 计算缩放比例(基于1080x2400基准)
scale_x = img_width / 1080.0
scale_y = img_height / 2400.0
except (OSError, IOError, SyntaxError) as e:
# Handle truncated image files
root.after(0, log_msg(f"图片文件损坏或截断: {e}")) # type: ignore[arg-type]
return
except Exception as e:
root.after(0, log_msg(f"[OCR] 读取截图失败: {e}")) # type: ignore[arg-type]
return
# 获取Y偏移
y_offset = int(y_var.get() or 0)
# 执行所有OCR区域的识别
ocr_results = []
total_regions = len(OCR_REGIONS)
root.after(0, log_msg(f"[OCR] 开始识别 {total_regions} 个区域...")) # type: ignore[arg-type]
for idx, (region_name, (x1, y1, x2, y2), desc) in enumerate(
OCR_REGIONS, 1
):
try:
# 缩放坐标到实际截图尺寸
actual_x1 = int(x1 * scale_x)
actual_y1 = int(y1 * scale_y) + y_offset
actual_x2 = int(x2 * scale_x)
actual_y2 = int(y2 * scale_y) + y_offset
# 确保坐标在图片范围内
actual_x1 = max(0, min(actual_x1, img_width))
actual_y1 = max(0, min(actual_y1, img_height))
actual_x2 = max(0, min(actual_x2, img_width))
actual_y2 = max(0, min(actual_y2, img_height))
if actual_x1 >= actual_x2 or actual_y1 >= actual_y2:
root.after(0, log_msg(f"[OCR] {region_name}: 坐标无效,跳过")) # type: ignore[arg-type]
continue
# 截取区域
cut_result = ops.cut_pic(
(actual_x1, actual_y1),
(actual_x2, actual_y2),
"",
region_name,
)
if not cut_result:
root.after(0, log_msg(f"[OCR] {region_name}: 截图失败")) # type: ignore[arg-type]
ocr_results.append((region_name, desc, "", "截图失败"))
continue
# OCR识别(先尝试模式0,如果为空再尝试模式1)
text_result = ""
ocr_mode = 0
for mode in [0, 1]:
try:
text = str(
ops.analyse_pic_word(region_name, mode) or ""
).strip()
if text:
text_result = text
ocr_mode = mode
break
except Exception:
continue
ocr_results.append(
(region_name, desc, text_result, f"模式{ocr_mode}")
)
status_msg = f"[OCR] ({idx}/{total_regions}) {region_name}: {text_result[:50] if text_result else '(空)'}"
root.after(0, log_msg(status_msg)) # type: ignore[arg-type]
except Exception as e:
error_msg = f"[OCR] {region_name}: 异常 - {e}"
root.after(0, log_msg(error_msg)) # type: ignore[arg-type]
ocr_results.append((region_name, desc, "", f"异常: {e}"))
# 更新OCR结果标签页
def update_ocr_wrapper() -> None:
update_ocr_results(ocr_results)
root.after(0, update_ocr_wrapper) # type: ignore[arg-type]
root.after(0, log_msg(f"[OCR] 完成!共识别 {len(ocr_results)} 个区域")) # type: ignore[arg-type]
# 刷新截图预览(如果当前显示的是 screenshot.png)
def refresh_if_screenshot() -> None:
if image_var.get() == "screenshot.png":
refresh_preview()
root.after(0, refresh_if_screenshot) # type: ignore[arg-type]
except Exception as e:
import traceback
error_detail = traceback.format_exc()
root.after(0, log_msg(f"[截图] 截图异常: {e}\n{error_detail}")) # type: ignore[arg-type]
thread = threading.Thread(target=screenshot_thread, daemon=True)
thread.start()
# 将顶部“截图+OCR”按钮的回调绑定到 do_screenshot
try:
btn = screenshot_button_var.get("button")
if btn is not None:
btn.configure(command=do_screenshot)
except Exception:
pass
# 右侧:操作按钮区域(先创建,放在底部)
actions = ttk.Frame(right)
# 右侧:Notebook(日志 / 截图预览 / 统计信息 / 预约队列 / 高价值房间)
notebook = ttk.Notebook(right)
# 实时状态工具栏(固定在 Notebook 上方,始终可见)
show_actions_var = tk.BooleanVar(value=True)
show_screenshot_var = tk.BooleanVar(value=False)
auto_scroll_var = tk.BooleanVar(value=True)
realtime_tools = ttk.Frame(right)
realtime_tools.pack(fill=X, padx=8, pady=(4, 0))
ttk.Checkbutton(realtime_tools, text="显示动作流", variable=show_actions_var).pack(
side=LEFT, padx=(0, 8)
)
ttk.Checkbutton(realtime_tools, text="显示截图", variable=show_screenshot_var).pack(
side=LEFT, padx=(0, 8)
)
ttk.Checkbutton(realtime_tools, text="自动滚动", variable=auto_scroll_var).pack(
side=LEFT, padx=(0, 8)
)
# forward-declare handler to satisfy linters; real function defined later
_open_realtime_viewer_impl = None
realtime_view_btn = ttk.Button(
realtime_tools,
text="实时查看",
width=10,
command=lambda: (
_open_realtime_viewer_impl()
if callable(_open_realtime_viewer_impl)
else None
),
)
realtime_view_btn.pack(side=LEFT, padx=(8, 0))
log_tab = ttk.Frame(notebook)
preview_tab = ttk.Frame(notebook)
stats_tab = ttk.Frame(notebook)
reservation_tab = ttk.Frame(notebook)
high_value_tab = ttk.Frame(notebook)
actions_log_tab = ttk.Frame(notebook)
realtime_tab = ttk.Frame(notebook)
ocr_results_tab = ttk.Frame(notebook)
win_record_tab = ttk.Frame(notebook)
notebook.add(log_tab, text="运行日志")
notebook.add(preview_tab, text="截图预览")
notebook.add(stats_tab, text="统计信息")
notebook.add(reservation_tab, text="预约队列")
notebook.add(high_value_tab, text="高价值房间")
notebook.add(actions_log_tab, text="行为日志")
notebook.add(realtime_tab, text="实时状态")
notebook.add(ocr_results_tab, text="OCR结果")
notebook.add(win_record_tab, text="中奖记录")
# 使用模块化组件创建映射表并加入 Notebook
mapping_tab = create_mapping_tab(root, notebook, cfg)
notebook.add(mapping_tab, text="映射表")
# 日志区
log_box = ttk.Frame(log_tab)
log_box.pack(fill=BOTH, expand=True)
# ========== 实时状态 Tab(显示最近动作 + 耗时) ==========
try:
realtime_frame = ttk.Frame(realtime_tab)
realtime_frame.pack(fill=BOTH, expand=True, padx=8, pady=8)
# 截图预览区域(根据选项显示/隐藏)
image_label = ttk.Label(realtime_frame)
image_label.pack(fill=X)
realtime_text = ScrolledText(realtime_frame, height=14)
realtime_text.pack(fill=BOTH, expand=True)
realtime_text.configure(state="disabled")
# re 已在模块顶部导入,避免重复导入
realtime_after_id = None
def tail_read_file(path: str, max_bytes: int = 64 * 1024) -> list[str]:
"""从文件尾部读取最多 max_bytes,并返回按行分割的字符串列表(按文件顺序)。"""
try:
if not os.path.exists(path):
return []
with open(path, "rb") as f:
f.seek(0, os.SEEK_END)
file_size = f.tell()
seek_from = max(0, file_size - max_bytes)
f.seek(seek_from)
data = f.read()
text = data.decode(errors="ignore")
# splitlines 保留不含尾部换行的处理
return text.splitlines()
except Exception:
return []
def parse_action_duration(line: str) -> tuple[str, str] | None:
"""从一行日志提取 (action, duration),未找到返回 None。
支持 ms / s 两种单位(实际 actions.log 写 `耗时=10.00ms`)。
"""
if "耗时" not in line:
return None
idx = line.find("耗时")
tail = line[idx:] # 在"耗时"之后搜,避免把前缀里的数字当成耗时
num = r"([0-9]+(?:\.[0-9]+)?)"
# 优先 ms(必须先于 s 匹配,否则 \s*s 会先吃掉 "10ms" 的 m)
m_ms = re.search(r"耗时[:=]?\s*" + num + r"\s*ms", tail)
m_s = re.search(r"耗时[:=]?\s*" + num + r"\s*s(?![a-zA-Z])", tail)
if m_ms:
dur = m_ms.group(1) + "ms"
elif m_s:
dur = m_s.group(1) + "s"
else:
m2 = re.search(num + r"\s*ms", tail)
if m2:
dur = m2.group(1) + "ms"
else:
m3 = re.search(num + r"\s*s(?![a-zA-Z])", tail)
if m3:
dur = m3.group(1) + "s"
else:
return None
# 动作名取耗时之前的文本片段,最多保留 60 字符
action = line[:idx].strip()
if not action:
# 兜底:取整行前 60 字符
action = line.strip()[:60]
if len(action) > 60:
action = action[:57] + "..."
return (action, dur)
def refresh_realtime_tab():
nonlocal realtime_after_id
cfg = read_config()
gui_cfg = cfg.get("gui", {}).get("realtime_status", {})
refresh_ms = int(gui_cfg.get("refresh_interval_ms", 1000))
tail_items = int(gui_cfg.get("tail_items", 50))
path = os.path.join(get_logs_dir(), "actions.log")
lines = tail_read_file(path)
parsed: list[tuple[str, str]] = []
# 从文件末尾向前解析,保持原始顺序输出最近项
for line in reversed(lines):
try:
out = parse_action_duration(line)
if out:
parsed.append(out)
if len(parsed) >= tail_items:
break
except Exception:
continue
parsed = list(reversed(parsed))
# 更新截图(若选中)
if show_screenshot_var.get():
try:
try:
from douyin.core.path_config import get_screenshot_path
screenshot_path = get_screenshot_path()
except Exception:
from douyin.core import path_config
screenshot_path = path_config.get_screenshot_path()
if os.path.exists(screenshot_path):
img = Image.open(screenshot_path)
# 缩放以适应宽度(保持纵横比),最大宽度 420
max_w = 420
w, h = img.size
if w > max_w:
nw = max_w
nh = int(h * (nw / w))
img = img.resize((nw, nh), Image.LANCZOS)
tk_img = ImageTk.PhotoImage(img)
image_label.configure(image=tk_img)
image_label.image = tk_img
image_label.pack(fill=X)
else:
image_label.configure(image="")
image_label.image = None
image_label.pack_forget()
except Exception:
image_label.configure(image="")
image_label.image = None
image_label.pack_forget()
else:
image_label.configure(image="")
image_label.image = None
image_label.pack_forget()
# 更新动作流文本(若选中)
if show_actions_var.get():
realtime_text.configure(state="normal")
realtime_text.delete("1.0", "end")
if not parsed:
realtime_text.insert("1.0", "暂无动作日志(仅显示包含“耗时”的行)")
else:
for action, dur in parsed:
realtime_text.insert("end", f"{action} {dur}\n")
# 自动滚动
if auto_scroll_var.get():
try:
realtime_text.see("end")
except Exception:
try:
realtime_text.yview_moveto(1.0)
except Exception:
pass
realtime_text.configure(state="disabled")
else:
# 隐藏文本内容但保留控件
realtime_text.configure(state="normal")
realtime_text.delete("1.0", "end")
realtime_text.configure(state="disabled")
# 安排下一次刷新
try:
realtime_after_id = root.after(refresh_ms, refresh_realtime_tab)
except Exception:
realtime_after_id = None
# 启动刷新(仅在 Tab 被创建时启动)
try:
refresh_realtime_tab()
except Exception:
pass
except Exception:
pass
# --------- 实时查看弹窗(紧凑视图) ---------
def _open_realtime_viewer_impl():
"""委托到 gui/components/realtime_viewer.open_realtime_viewer。"""
from gui.components.realtime_viewer import open_realtime_viewer
open_realtime_viewer(root)
# 搜索工具栏
log_search_frame = ttk.Frame(log_box)
log_search_frame.pack(fill=X, padx=10, pady=(10, 5))
# 关键字筛选(与行为日志一致)
log_filter_var = tk.StringVar(value="")
ttk.Label(log_search_frame, text="筛选:").pack(side=LEFT)
ttk.Entry(log_search_frame, textvariable=log_filter_var, width=16).pack(
side=LEFT, padx=(0, 8)
)
log_search_var = tk.StringVar(value="")
log_search_entry = ttk.Entry(
log_search_frame, textvariable=log_search_var, width=20
)
def refresh_run_log():
"""从内存中读取最近若干运行日志并在界面中刷新(行为上与行为日志一致)"""
try:
tail_n = 1000
# 读取 runner 内存日志(线程安全)
with runner._lock:
total = len(runner._log)
cand = runner._log[-tail_n:] if tail_n > 0 else runner._log[:]
# 应用筛选关键词
kw = log_filter_var.get().strip()
if kw:
cand = [ln for ln in cand if kw in (ln or "")]
# 保存滚动位置
try:
scroll_pos = log_text.yview()[0]
except Exception:
scroll_pos = 1.0
log_text.delete("1.0", "end")
if cand:
try:
current_theme = str(gui_theme_var.get() or "litera")
except Exception:
current_theme = "litera"
for i, line in enumerate(cand):
start_pos = log_text.index("end-1c")
if i > 0:
log_text.insert("end", "\n")
log_text.insert("end", line)
end_pos = log_text.index("end")
try:
op_type = get_operation_type(line)
if op_type:
apply_operation_color(
log_text, start_pos, end_pos, line, current_theme
)
except Exception:
pass
else:
log_text.insert("1.0", "暂无匹配的运行日志")
try:
log_text.yview_moveto(scroll_pos)
except Exception:
pass
except Exception as e:
try:
log_text.delete("1.0", "end")
log_text.insert("1.0", f"刷新运行日志失败:{e}")
except Exception:
pass
log_search_matches = [] # 存储所有匹配的位置
log_current_match_index = -1 # 当前匹配的索引
def _generic_search_widget(
widget, search_var, matches_list, current_index, direction=1
):
"""通用的文本控件搜索函数:在 widget 中根据 search_var 搜索并高亮。
- widget: 文本控件(ScrolledText)
- search_var: tk.StringVar (包含搜索词)
- matches_list: 可变列表,用来保存匹配区间 (start_index, end_index)
- current_index: 当前匹配的索引(整数),返回更新后的索引
- direction: 1 为下一个,-1 为上一个
"""
search_text = search_var.get().strip()
if not search_text:
try:
widget.tag_remove("search_highlight", "1.0", "end")
widget.tag_remove("search_current", "1.0", "end")
except Exception:
pass
matches_list.clear()
return -1
content = widget.get("1.0", "end-1c")
if not content:
return -1
try:
widget.tag_remove("search_highlight", "1.0", "end")
widget.tag_remove("search_current", "1.0", "end")
except Exception:
pass
try:
widget.tag_config("search_highlight", background="yellow")
widget.tag_config("search_current", background="orange")
except Exception:
pass
matches_list.clear()
start_pos = 0
search_text_lower = search_text.lower()
content_lower = content.lower()
while True:
pos = content_lower.find(search_text_lower, start_pos)
if pos == -1:
break
line_start = content[:pos].rfind("\n") + 1
line_num = content[:pos].count("\n") + 1
col_num = pos - line_start
start_index = f"{line_num}.{col_num}"
end_index = f"{line_num}.{col_num + len(search_text)}"
matches_list.append((start_index, end_index))
start_pos = pos + 1
if not matches_list:
return -1
for s, e in matches_list:
try:
widget.tag_add("search_highlight", s, e)
except Exception:
pass
if direction == 1:
current_index = (current_index + 1) % len(matches_list)
else:
current_index = (current_index - 1) % len(matches_list)
try:
s, e = matches_list[current_index]
widget.tag_add("search_current", s, e)
widget.see(s)
widget.mark_set("insert", s)
except Exception:
pass
return current_index
def search_in_log_text(direction=1):
"""在运行日志中搜索文本(调用通用搜索实现)"""
nonlocal log_search_matches, log_current_match_index
log_current_match_index = _generic_search_widget(
log_text,
log_search_var,
log_search_matches,
log_current_match_index,
direction,
)
def search_next_in_log():
"""搜索下一个"""
search_in_log_text(1)
def search_prev_in_log():
"""搜索上一个"""
search_in_log_text(-1)
def clear_search_in_log():
"""清除搜索高亮"""
nonlocal log_search_matches, log_current_match_index
log_search_var.set("")
log_text.tag_remove("search_highlight", "1.0", "end")
log_text.tag_remove("search_current", "1.0", "end")
log_search_matches = []
log_current_match_index = -1
# 绑定回车键搜索
def on_log_search_entry_key(event):
if event.keysym == "Return":
search_next_in_log()
log_search_entry.bind("<KeyPress>", on_log_search_entry_key)
# 将 刷新 放在筛选后面,搜索区域与行为日志一致(带分隔条)
ttk.Button(log_search_frame, text="刷新", command=refresh_run_log).pack(
side=LEFT, padx=(0, 8)
)
ttk.Separator(log_search_frame, orient="vertical").pack(
side=LEFT, fill=Y, padx=5, pady=3
)
ttk.Label(log_search_frame, text="搜索:").pack(side=LEFT)
# 把搜索输入框放在分隔符后
log_search_entry.pack(side=LEFT, padx=(0, 5))
ttk.Button(log_search_frame, text="搜索", command=search_next_in_log).pack(
side=LEFT, padx=(0, 2)
)
ttk.Button(log_search_frame, text="上一个", command=search_prev_in_log).pack(
side=LEFT, padx=(0, 2)
)
ttk.Button(log_search_frame, text="下一个", command=search_next_in_log).pack(
side=LEFT, padx=(0, 2)
)
ttk.Button(log_search_frame, text="清除", command=clear_search_in_log).pack(
side=LEFT, padx=(0, 5)
)
log_text = ScrolledText(log_box)
try:
log_text.configure(font=("Consolas", 10))
except Exception:
pass
log_text.pack(fill=BOTH, expand=True, padx=10, pady=(0, 10))
# 配置日志颜色标签(如果支持颜色)
try:
# 根据主题调整日志颜色(明亮主题使用深色文字/蓝色系)
light_themes = {"litera", "flatly", "journal", "minty", "cosmo"}
try:
current_theme = str(gui_theme_var.get() or "litera")
except Exception:
current_theme = "litera"
if current_theme in light_themes:
# 明亮主题 - 使用更适合人眼观看的颜色组合
log_text.configure(
background="#FFFFFF", foreground="#2C2C2C", insertbackground="#2C2C2C"
)
log_text.tag_configure("log_timestamp", foreground="#8B8B8B") # 柔和的灰色
log_text.tag_configure(
"log_info", foreground="#1E88E5"
) # 明亮的蓝色,易于阅读
log_text.tag_configure(
"log_warning", foreground="#F57C00"
) # 橙色,警告色但不过于刺眼
log_text.tag_configure(
"log_error", foreground="#D32F2F"
) # 深红色,醒目但不刺眼
log_text.tag_configure(
"log_critical", foreground="#B71C1C", font=("Consolas", 10, "bold")
) # 加粗深红色
log_text.tag_configure(
"log_performance", foreground="#388E3C"
) # 深绿色,性能指标
log_text.tag_configure("log_module", foreground="#7B1FA2") # 紫色,模块标识
else:
# 暗色主题 - 优化对比度和可读性
log_text.configure(
background="#1E1E1E", foreground="#E0E0E0", insertbackground="#FFFFFF"
)
log_text.tag_configure(
"log_timestamp", foreground="#A0A0A0"
) # 浅灰色时间戳
log_text.tag_configure("log_info", foreground="#64B5F6") # 亮蓝色,信息级
log_text.tag_configure(
"log_warning", foreground="#FFB74D"
) # 金色警告,暗色背景下醒目
log_text.tag_configure(
"log_error", foreground="#EF5350"
) # 亮红色,错误突出
log_text.tag_configure(
"log_critical", foreground="#F44336", font=("Consolas", 10, "bold")
) # 加粗亮红色
log_text.tag_configure(
"log_performance", foreground="#81C784"
) # 亮绿色,性能数据
log_text.tag_configure(
"log_module", foreground="#BA68C8"
) # 亮紫色,模块标识
# 配置操作类型颜色标签(使用模块化配置)
try:
color_config = get_color_config(current_theme)
for op_type, colors in color_config.items():
tag_name = f"op_{op_type}"
log_text.tag_configure(
tag_name,
foreground=colors["foreground"],
background=colors["background"],
)
except Exception:
pass # 忽略操作类型颜色配置失败
except Exception:
pass # 忽略标签配置失败
# 截图预览
preview_top = ttk.Frame(preview_tab)
preview_top.pack(fill=X, padx=10, pady=10)
try:
from douyin.core.path_config import get_pic_dir
images_dir = get_pic_dir()
except Exception:
# 回退到旧路径(向后兼容)
from douyin.core import path_config
images_dir = path_config.get_pic_dir()
def scan_image_files():
"""扫描pic文件夹及其子文件夹中的所有图片文件"""
image_files = []
if os.path.exists(images_dir):
for root, dirs, files in os.walk(images_dir):
for file in files:
if file.lower().endswith(
(".png", ".jpg", ".jpeg", ".bmp", ".webp", ".gif")
):
# 获取相对路径
rel_path = os.path.relpath(
os.path.join(root, file), str(images_dir)
)
# 统一使用正斜杠(Windows和Unix都支持)
rel_path = rel_path.replace("\\", "/")
image_files.append(rel_path)
# 按文件名排序
image_files.sort(key=lambda x: x.lower())
return image_files
image_var = tk.StringVar(value="")
ttk.Label(preview_top, text="选择图片:").pack(side=LEFT)
# 允许手工输入子路径(例如 start/latest.png),方便查看逐步截图
image_combo = ttk.Combobox(
preview_top, textvariable=image_var, width=30, state="normal"
)
image_combo.pack(side=LEFT, padx=(0, 10))
def update_image_list(refresh_after=True):
"""更新图片列表"""
new_list = scan_image_files()
image_combo["values"] = new_list
current_value = image_var.get()
# 如果当前值不在新列表中,或列表为空,选择第一个
if new_list:
if not current_value or current_value not in new_list:
image_var.set(new_list[0])
else:
image_var.set("")
on_line(f"[预览] 扫描到 {len(new_list)} 个图片文件")
# 如果当前有选择的图片,刷新预览(如果refresh_after为True且refresh_preview已定义)
if refresh_after and image_var.get():
try:
refresh_preview()
except NameError:
# refresh_preview还没定义,忽略
pass
# 先定义refresh_preview函数(即使它引用了后面的变量,函数定义本身是延迟执行的)
def refresh_preview():
name = image_var.get().strip()
if not name:
preview_status.set("请选择图片")
image_label.configure(image="")
_img_ref["photo"] = None
return
# 处理相对路径(将正斜杠转换为系统路径分隔符)
name_normalized = name.replace("/", os.sep)
path = os.path.join(images_dir, name_normalized)
_load_and_fit_image(path)
update_image_list(refresh_after=False) # 初始化时扫描一次,但不刷新预览
preview_status = tk.StringVar(value="")
ttk.Label(preview_top, textvariable=preview_status).pack(side=RIGHT)
preview_body = ttk.Frame(preview_tab)
preview_body.pack(fill=BOTH, expand=True, padx=10, pady=(0, 10))
image_label = ttk.Label(preview_body)
image_label.pack(fill=BOTH, expand=True)
_img_ref: dict[str, Any] = {"photo": None} # 防止 PhotoImage 被回收
def _load_and_fit_image(img_path: str) -> None:
if not os.path.exists(img_path):
preview_status.set(f"未找到:{os.path.basename(img_path)}")
image_label.configure(image="")
_img_ref["photo"] = None
return
try:
img = Image.open(img_path)
img.load() # Force load to catch truncated files early
img = img.convert("RGB")
except (OSError, IOError, SyntaxError) as e:
# Handle truncated image files
preview_status.set(f"图片加载失败:{str(e)[:50]}")
image_label.configure(image="")
_img_ref["photo"] = None
return
except Exception as e:
preview_status.set(f"图片加载错误:{str(e)[:50]}")
image_label.configure(image="")
_img_ref["photo"] = None
return
# 获取预览区域的实际尺寸(如果窗口还未初始化,使用默认值)
try:
preview_body.update_idletasks() # 强制更新布局
w = preview_body.winfo_width()
h = preview_body.winfo_height()
# 如果尺寸无效(窗口未初始化),使用默认值
if w <= 1 or h <= 1:
w, h = 900, 520
except Exception:
w, h = 900, 520
max_w = max(300, w - 20)
max_h = max(200, h - 20)
try:
resample = Image.Resampling.LANCZOS
except AttributeError:
# Fallback for older Pillow versions: LANCZOS constant value is 1
resample = 1 # type: ignore[assignment]
img.thumbnail((max_w, max_h), resample)
photo: ImageTk.PhotoImage = ImageTk.PhotoImage(img)
_img_ref["photo"] = photo # type: ignore[assignment]
image_label.configure(image=photo)
preview_status.set(f"{os.path.basename(img_path)} {img.width}x{img.height}")
ttk.Button(
preview_top,
text="刷新列表",
command=lambda: update_image_list(refresh_after=True),
).pack(side=LEFT, padx=(0, 5))
ttk.Button(preview_top, text="刷新预览", command=refresh_preview).pack(side=LEFT)
# 绑定选择变化事件,自动刷新预览(在 refresh_preview 函数定义之后)
def on_image_selected(*args):
"""当用户选择图片时自动刷新预览"""
try:
refresh_preview()
except Exception:
pass # 忽略错误,避免影响其他功能
image_var.trace("w", on_image_selected) # 监听变量变化
image_combo.bind(
"<<ComboboxSelected>>", lambda e: refresh_preview()
) # 监听下拉选择
def open_pic_folder():
try:
os.makedirs(images_dir, exist_ok=True)
os.startfile(images_dir) # type: ignore[attr-defined]
except Exception as e:
on_line(f"[预览] 打开图片目录失败:{e}")
ttk.Button(preview_top, text="打开pic目录", command=open_pic_folder).pack(
side=LEFT, padx=(10, 0)
)
status_var = tk.StringVar(value="就绪")
def get_params() -> RunParams:
# 如果启用无限循环,设置 wait_minutes=0
wait_minutes_value = (
0 if infinite_loop_var.get() else int(wait_minutes_var.get() or 5)
)
return RunParams(
device_id=device_var.get().strip(),
y_pianyi=int(y_var.get()),
needswitch=bool(needswitch_var.get()),
wait_minutes=wait_minutes_value,
skip_if_countdown_gt_seconds=int(skip_gt_seconds_var.get() or 900),
reset_after_swipes_enabled=bool(reset_after_swipes_enabled_var.get()),
reset_after_swipes=int(reset_after_swipes_var.get() or 10),
min_prize_value_yuan=float(min_value_var.get() or 0),
min_participants=int(min_participants_var.get() or 0),
max_participants=int(max_participants_var.get() or 0),
auto_join_fansclub=bool(auto_join_var.get()),
fansclub_fail_action=str(fansclub_action_var.get() or "stay").lower(),
# Web端新增参数
high_value_room_revisit_enabled=bool(
high_value_room_revisit_enabled_var.get()
),
high_value_room_revisit_only_current_run=bool(
high_value_room_revisit_only_current_run_var.get()
),
high_value_room_revisit_min_interval_seconds=int(
high_value_room_revisit_min_interval_seconds_var.get()
),
high_value_room_revisit_max_per_run=int(
high_value_room_revisit_max_per_run_var.get()
),
high_value_room_revisit_min_prize_value=float(
high_value_room_revisit_min_prize_value_var.get()
),
high_value_room_revisit_max_age_days=int(
high_value_room_revisit_max_age_days_var.get()
),
high_value_fudai_poll_before_seconds=float(
high_value_fudai_poll_before_seconds_var.get() or 10.0
),
reservation_back_verify_enabled=bool(
reservation_back_verify_enabled_var.get()
),
reservation_back_swipe_delay=float(
reservation_back_swipe_delay_var.get() or 1.0
),
fudai_find_max_attempts=int(fudai_find_max_attempts_var.get() or 5),
enable_ocr_mode1=bool(enable_ocr_mode1_var.get()),
fudai_template_match_enabled=bool(fudai_template_match_enabled_var.get()),
fudai_template_match_threshold=float(
fudai_template_match_threshold_var.get() or 0.7
),
# 只养号模式与养号时长
yanghao_only=bool(yg_only_var.get()),
yanghao_seconds=int(yg_recommend_duration_var.get() or 0),
enable_back_on_misses=bool(enable_back_on_misses_var.get()),
)
def start_run():
if runner.is_running():
on_line("[运行] 已在运行中")
return
save_ui_to_config()
params = get_params()
wait_display = "∞" if params.wait_minutes == 0 else f"{params.wait_minutes}m"
on_line(
f"[运行] 启动:device={params.device_id or '(auto)'} y={params.y_pianyi} "
f"needswitch={params.needswitch} wait={wait_display} "
f"skip_gt={params.skip_if_countdown_gt_seconds}s reset_after_enabled={params.reset_after_swipes_enabled} reset_after={params.reset_after_swipes} "
f"value>={params.min_prize_value_yuan} participants=[{params.min_participants},{params.max_participants}] "
f"high_value_revisit={params.high_value_room_revisit_enabled} reservation_verify={params.reservation_back_verify_enabled} "
f"fudai_find_max={params.fudai_find_max_attempts} yanghao=recommend_flow_only"
)
status_var.set("运行中")
try:
runner.start(params)
except Exception as e:
status_var.set("启动失败")
on_line(f"[错误] {e}")
def stop_run():
runner.stop()
status_var.set("已停止")
# 先打包 actions 到底部(不 expand,固定在底部)
actions.pack(fill=X, pady=(10, 0), padx=12, side="bottom")
# 然后打包 notebook 填充剩余空间(在 actions 之上)
notebook.pack(fill=BOTH, expand=True)
ttk.Button(actions, text="开始运行", command=start_run).pack(side=LEFT, padx=(0, 8))
ttk.Button(actions, text="停止", command=stop_run).pack(side=LEFT, padx=(0, 4))
def force_stop_run():
"""强制终止后台进程(包括可能残留的子进程)。"""
runner.force_stop()
status_var.set("已停止(强制)")
ttk.Button(actions, text="强制停止", command=force_stop_run).pack(
side=LEFT, padx=(0, 8)
)
# (已移除:测试养号/测试评论 按钮与相关UI)
def send_back_key():
dev = device_var.get().strip()
try:
runner.send_back_key(dev)
except Exception as e:
on_line(f"[错误] 发送返回键失败: {e}")
ttk.Button(actions, text="发送返回键", command=send_back_key).pack(
side=LEFT, padx=(0, 8)
)
ttk.Label(actions, textvariable=status_var).pack(side=RIGHT)
def pump_logs():
changed = False
try:
# 获取当前主题(用于颜色配置)
try:
current_theme = str(gui_theme_var.get() or "litera")
except Exception:
current_theme = "litera"
while True:
line = q.get_nowait()
# 运行日志关键字筛选(与行为日志一致)
try:
kw = log_filter_var.get().strip()
if kw and kw not in line:
continue
except Exception:
pass
try:
# 插入日志行并应用颜色标签
start_pos = log_text.index("end-1c")
# 插入文本
log_text.insert("end", line + "\n")
end_pos = log_text.index("end-1c")
# 优先级1: 先检查操作类型颜色(更具体)
op_type_applied = False
try:
op_type = get_operation_type(line)
if op_type:
apply_operation_color(
log_text, start_pos, end_pos, line, current_theme
)
op_type_applied = True
except Exception:
pass # 忽略操作类型颜色应用失败
# 优先级2: 再检查日志级别标签(作为补充,如果操作类型未匹配)
# 只有在没有操作类型颜色时才应用级别标签
if not op_type_applied:
try:
tag = None
if "[INFO]" in line:
tag = "log_info"
elif "[WARNING]" in line:
tag = "log_warning"
elif "[ERROR]" in line:
tag = "log_error"
elif "[CRITICAL]" in line:
tag = "log_critical"
elif "elapsed_seconds=" in line or "耗时" in line:
tag = "log_performance"
elif re.search(r"\[[\w\.]+\]", line):
tag = "log_module"
if tag:
log_text.tag_add(tag, start_pos, end_pos)
except Exception:
pass # 忽略级别标签应用失败
# 不再自动滚动到底部,让用户自由控制滚动位置
changed = True
except Exception as e:
# 如果插入日志失败,至少记录到 logger(调试用)
_LOGGER.error("[GUI日志错误] 无法插入日志: %s", e)
except queue.Empty:
pass
except Exception as e:
# 捕获其他异常,确保日志循环不会中断
_LOGGER.error("[GUI日志错误] pump_logs异常: %s", e)
try:
if changed and not runner.is_running() and status_var.get() == "运行中":
status_var.set("已结束")
except Exception:
pass
# 确保递归调用始终执行,即使前面出现异常
try:
root.after(100, pump_logs) # type: ignore[arg-type]
except Exception as e:
# 如果 root 已被销毁,停止日志循环
_LOGGER.warning("[GUI日志错误] 无法调度下次日志更新: %s", e)
# 统计信息显示
stats_top = ttk.Frame(stats_tab)
stats_top.pack(fill=X, padx=10, pady=(10, 0))
stats_text = ScrolledText(stats_tab)
stats_text.pack(fill=BOTH, expand=True, padx=10, pady=10)
try:
stats_text.configure(font=("Consolas", 10))
except Exception:
pass
def refresh_stats():
"""委托给 gui/components/stats_formatter.format_stats(纯字符串构建)。"""
try:
from gui.components.stats_formatter import format_stats
stats = runner.get_stats()
stats_text.delete("1.0", "end")
stats_text.insert("1.0", "\n".join(format_stats(stats)))
except Exception as e:
import traceback
stats_text.delete("1.0", "end")
error_detail = traceback.format_exc()
stats_text.insert(
"1.0", f"刷新统计信息失败:{e}\n\n详细信息:\n{error_detail}"
)
ttk.Button(stats_top, text="刷新", command=refresh_stats).pack(side=LEFT)
# 预约队列显示
reservation_top = ttk.Frame(reservation_tab)
reservation_top.pack(fill=X, padx=10, pady=(10, 0))
reservation_text = ScrolledText(reservation_tab)
reservation_text.pack(fill=BOTH, expand=True, padx=10, pady=10)
try:
reservation_text.configure(font=("Consolas", 10))
except Exception:
pass
def refresh_reservations():
try:
from douyin.core.path_config import get_reservations_path
path = get_reservations_path()
except Exception:
# 回退到旧路径(向后兼容)
from douyin.core import path_config
path = path_config.get_reservations_path()
try:
if os.path.exists(path):
with open(path, "r", encoding="utf-8") as f:
data = json.load(f)
reservation_text.delete("1.0", "end")
updated_ts = (
float(data.get("updated_ts", 0.0) or 0.0)
if isinstance(data, dict)
else 0.0
)
room_pos = (
int(data.get("room_pos", 0) or 0) if isinstance(data, dict) else 0
)
reason = (
str(data.get("reason", "") or "") if isinstance(data, dict) else ""
)
current_title = (
str(data.get("current_room_title", "") or "")
if isinstance(data, dict)
else ""
)
current_title_raw = (
str(data.get("current_room_title_raw", "") or "")
if isinstance(data, dict)
else ""
)
reservations = (
data.get("reservations", []) if isinstance(data, dict) else []
)
# 基本信息(中文,更详细)
lines = []
lines.append("=" * 60)
lines.append("【预约队列总览】")
lines.append("=" * 60)
if updated_ts > 0:
try:
updated_dt = datetime.fromtimestamp(updated_ts)
updated_str = updated_dt.strftime("%Y年%m月%d日 %H:%M:%S")
# 计算距离现在的时间
now_dt = datetime.now()
time_diff = now_dt - updated_dt
if time_diff.total_seconds() < 60:
time_ago = f"{int(time_diff.total_seconds())}秒前"
elif time_diff.total_seconds() < 3600:
time_ago = f"{int(time_diff.total_seconds() // 60)}分钟前"
elif time_diff.total_seconds() < 86400:
time_ago = f"{int(time_diff.total_seconds() // 3600)}小时前"
else:
time_ago = f"{int(time_diff.total_seconds() // 86400)}天前"
lines.append(f"最后更新时间:{updated_str} ({time_ago})")
except Exception:
updated_str = str(updated_ts)
lines.append(f"最后更新时间:{updated_str}")
else:
lines.append("最后更新时间:暂无数据")
lines.append(
f"当前所在直播间位置:第 {room_pos + 1} 个直播间(索引:{room_pos})"
)
lines.append(f"当前直播间名称(清洗后):{current_title or '未知'}")
lines.append(f"当前直播间名称(原始):{current_title_raw or '未知'}")
lines.append(f"预约队列总数:{len(reservations)} 条")
if reason:
reason_map = {
"record_reservation": "记录新预约",
"update_reservation": "更新预约信息",
"remove_expired": "移除过期预约",
"sort_reservations": "重新排序预约",
}
reason_text = reason_map.get(reason, reason)
lines.append(f"最近更新原因:{reason_text}")
lines.append("")
# 统计信息
if reservations:
now_ts = datetime.now().timestamp()
total_value = 0.0
valid_future_times = []
expired_count = 0
upcoming_count = 0
for item in reservations:
try:
val = float(item.get("prize_value_yuan") or 0.0)
total_value += val
except Exception:
pass
ft = float(item.get("future_ts") or 0.0)
if ft > 0:
valid_future_times.append(ft)
remain_sec = ft - now_ts
if remain_sec <= 0:
expired_count += 1
elif remain_sec <= 300: # 5分钟内
upcoming_count += 1
lines.append("【统计信息】")
lines.append(f"预约总价值:{total_value:.2f} 元")
if len(reservations) > 0:
avg_value = total_value / len(reservations)
lines.append(f"平均价值:{avg_value:.2f} 元")
if valid_future_times:
earliest_ts = min(valid_future_times)
latest_ts = max(valid_future_times)
try:
earliest_str = datetime.fromtimestamp(earliest_ts).strftime(
"%Y-%m-%d %H:%M:%S"
)
latest_str = datetime.fromtimestamp(latest_ts).strftime(
"%Y-%m-%d %H:%M:%S"
)
lines.append(f"最早开奖时间:{earliest_str}")
lines.append(f"最晚开奖时间:{latest_str}")
except Exception:
pass
if expired_count > 0:
lines.append(f"⚠️ 已过期预约:{expired_count} 条")
if upcoming_count > 0:
lines.append(f"⏰ 即将开奖(5分钟内):{upcoming_count} 条")
lines.append("")
lines.append("=" * 60)
lines.append("【预约明细列表】(按预计开奖时间从早到晚排序)")
lines.append("=" * 60)
lines.append("")
for idx, item in enumerate(reservations, start=1):
try:
val = float(item.get("prize_value_yuan") or 0.0)
except Exception:
val = 0.0
content = str(item.get("content") or "")
ft = float(item.get("future_ts") or 0.0)
ft_str = str(item.get("future_str") or "")
pos_seen = int(item.get("pos_seen") or 0)
room_title = str(item.get("room_title") or "")
room_title_raw = str(item.get("room_title_raw") or "")
created_ts = float(item.get("created_ts") or 0.0)
# 计算剩余时间(更详细)
now_ts = datetime.now().timestamp()
remain_sec = ft - now_ts if ft > 0 else 0
if ft <= 0:
remain_str = "❌ 开奖时间无效"
status_icon = "❌"
elif remain_sec <= 0:
remain_str = "⏰ 已到开奖时间"
status_icon = "⏰"
elif remain_sec <= 60:
remain_str = f"🔥 即将开奖({int(remain_sec)}秒后)"
status_icon = "🔥"
elif remain_sec <= 300:
remain_str = f"⏰ 即将开奖({int(remain_sec // 60)}分{int(remain_sec % 60)}秒后)"
status_icon = "⏰"
elif remain_sec <= 3600:
remain_str = f"⏳ {int(remain_sec // 60)}分{int(remain_sec % 60)}秒后开奖"
status_icon = "⏳"
elif remain_sec <= 86400:
hours = int(remain_sec // 3600)
minutes = int((remain_sec % 3600) // 60)
remain_str = f"⏳ {hours}小时{minutes}分钟后开奖"
status_icon = "⏳"
else:
days = int(remain_sec // 86400)
hours = int((remain_sec % 86400) // 3600)
remain_str = f"📅 {days}天{hours}小时后开奖"
status_icon = "📅"
# 记录时间(更详细)
if created_ts > 0:
try:
created_dt = datetime.fromtimestamp(created_ts)
created_str = created_dt.strftime(
"%Y年%m月%d日 %H:%M:%S"
)
# 计算距离现在的时间
time_diff = datetime.now() - created_dt
if time_diff.total_seconds() < 3600:
time_ago = f"{int(time_diff.total_seconds() // 60)}分钟前记录"
elif time_diff.total_seconds() < 86400:
time_ago = f"{int(time_diff.total_seconds() // 3600)}小时前记录"
else:
time_ago = f"{int(time_diff.total_seconds() // 86400)}天前记录"
created_str_full = f"{created_str} ({time_ago})"
except Exception:
created_str_full = str(created_ts)
else:
created_str_full = "未知"
# 格式化显示
lines.append(
"┌─ 预约 #"
+ str(idx)
+ " ─────────────────────────────────────────────"
)
lines.append(f"│ 状态:{status_icon} {remain_str}")
lines.append("│")
lines.append(f"│ 💰 奖品价值:{val:.2f} 元")
lines.append(f"│ 📦 奖品内容:{content or '(无描述)'}")
lines.append("│")
lines.append(f"│ ⏰ 预计开奖时间:{ft_str or '未知'}")
if ft > 0:
try:
ft_dt = datetime.fromtimestamp(ft)
ft_str_detailed = ft_dt.strftime(
"%Y年%m月%d日 %H:%M:%S"
)
if ft_str_detailed != ft_str:
lines.append(f"│ 详细时间:{ft_str_detailed}")
except Exception:
pass
lines.append("│")
lines.append(
f"│ 📍 发现时直播间位置:第 {pos_seen + 1} 个直播间(索引:{pos_seen})"
)
lines.append(
f"│ 🏠 直播间名称(清洗后):{room_title or '未知'}"
)
lines.append(
f"│ 🏠 直播间名称(原始):{room_title_raw or '未知'}"
)
lines.append("│")
lines.append(f"│ 📝 记录时间:{created_str_full}")
lines.append(f"└{'─' * 58}")
lines.append("")
else:
lines.append("【预约明细列表】")
lines.append("")
lines.append("暂无预约记录。")
lines.append("")
lines.append(
"提示:当检测到高价值福袋时,系统会自动将其加入预约队列。"
)
reservation_text.insert("1.0", "\n".join(lines))
else:
reservation_text.delete("1.0", "end")
reservation_text.insert("1.0", "暂无预约队列数据")
except Exception as e:
reservation_text.delete("1.0", "end")
reservation_text.insert("1.0", f"读取预约队列失败:{e}")
ttk.Button(reservation_top, text="刷新", command=refresh_reservations).pack(
side=LEFT
)
# 高价值房间显示
high_value_top = ttk.Frame(high_value_tab)
high_value_top.pack(fill=X, padx=10, pady=(10, 0))
high_value_text = ScrolledText(high_value_tab)
high_value_text.pack(fill=BOTH, expand=True, padx=10, pady=10)
try:
high_value_text.configure(font=("Consolas", 10))
except Exception:
pass
def refresh_high_value_rooms():
try:
from douyin.core.path_config import get_high_value_rooms_path
path = get_high_value_rooms_path()
except Exception:
# 回退到旧路径(向后兼容)
from douyin.core import path_config
path = path_config.get_high_value_rooms_path()
try:
if os.path.exists(path):
with open(path, "r", encoding="utf-8") as f:
data = json.load(f)
high_value_text.delete("1.0", "end")
high_value_text.insert(
"1.0", json.dumps(data, ensure_ascii=False, indent=2)
)
else:
high_value_text.delete("1.0", "end")
high_value_text.insert("1.0", "暂无高价值房间数据")
except Exception as e:
high_value_text.delete("1.0", "end")
high_value_text.insert("1.0", f"读取高价值房间失败:{e}")
ttk.Button(high_value_top, text="刷新", command=refresh_high_value_rooms).pack(
side=LEFT
)
# 行为日志显示(点击/识别/耗时)
actions_log_top = ttk.Frame(actions_log_tab)
actions_log_top.pack(fill=X, padx=10, pady=(10, 0))
actions_log_text = ScrolledText(actions_log_tab)
actions_log_text.pack(fill=BOTH, expand=True, padx=10, pady=10)
try:
actions_log_text.configure(font=("Consolas", 10))
except Exception:
pass
# 配置行为日志颜色标签(使用统一的颜色配置模块)
def configure_actions_log_colors():
"""根据当前主题配置行为日志的颜色标签"""
try:
# 获取当前主题
try:
current_theme = str(gui_theme_var.get() or "litera")
except Exception:
current_theme = "litera"
# 获取颜色配置
color_config = get_color_config(current_theme)
# 根据主题设置背景和前景色
light_themes = {"litera", "flatly", "journal", "minty", "cosmo"}
is_light = current_theme.lower() in light_themes
if is_light:
actions_log_text.configure(
background="#FFFFFF",
foreground="#2C2C2C",
insertbackground="#2C2C2C",
)
else:
actions_log_text.configure(
background="#1E1E1E",
foreground="#E0E0E0",
insertbackground="#FFFFFF",
)
# 为所有操作类型配置标签
for op_type, colors in color_config.items():
tag_name = f"op_{op_type}"
try:
actions_log_text.tag_configure(
tag_name,
foreground=colors["foreground"],
background=colors["background"],
)
except Exception:
pass # 忽略标签配置失败
except Exception:
pass # 忽略颜色配置失败
# 初始配置
configure_actions_log_colors()
actions_filter_var = tk.StringVar(value="")
def refresh_actions_log():
"""读取 logs/actions.log 的尾部若干行,在 GUI 中展示关键行为日志(支持简单关键字筛选)。"""
# 使用统一的路径配置
try:
from douyin.core.path_config import get_actions_log_path
path = get_actions_log_path()
except Exception:
# 回退到旧路径(向后兼容)
# 修正路径:GUI应该读取根目录的logs/actions.log
from douyin.core import path_config
path = path_config.get_actions_log_path()
try:
if os.path.exists(path):
# 仿照 web_gui 的实现:只读最后一小段,避免文件巨大
size = os.path.getsize(path)
if size == 0:
actions_log_text.delete("1.0", "end")
actions_log_text.insert("1.0", "行为日志文件为空")
return
read_bytes = min(size, 65536)
with open(path, "rb") as f:
if read_bytes < size:
f.seek(-read_bytes, os.SEEK_END)
data = f.read()
# 尝试多种编码方式
try:
# 先尝试 utf-8-sig(带BOM)
text = data.decode("utf-8-sig", errors="replace")
except Exception:
try:
# 再尝试 utf-8
text = data.decode("utf-8", errors="replace")
except Exception:
# 最后尝试 gbk(Windows常见编码)
text = data.decode("gbk", errors="replace")
lines = text.splitlines()
# 只取最近 300 行
tail = lines[-300:]
# 关键字筛选:若填写了筛选词,只保留包含该关键字的行
kw = actions_filter_var.get().strip()
if kw:
tail = [ln for ln in tail if kw in ln]
# 保存当前滚动位置,避免刷新时自动置顶
try:
scroll_position = actions_log_text.yview()[
0
] # 获取当前滚动位置(顶部可见位置的比例)
except Exception:
scroll_position = 0.0
actions_log_text.delete("1.0", "end")
if tail:
# 获取当前主题(用于颜色配置)
try:
current_theme = str(gui_theme_var.get() or "litera")
except Exception:
current_theme = "litera"
# 逐行插入并应用颜色标签
for i, line in enumerate(tail):
start_pos = actions_log_text.index("end-1c")
# 插入行内容
if i > 0:
actions_log_text.insert("end", "\n")
actions_log_text.insert("end", line)
# 使用统一的颜色配置模块应用颜色
end_pos = actions_log_text.index("end")
try:
apply_operation_color(
actions_log_text,
start_pos,
end_pos,
line,
current_theme,
)
except Exception:
pass # 忽略颜色应用失败
else:
actions_log_text.insert("1.0", "暂无匹配的行为日志")
# 恢复之前的滚动位置,避免自动置顶
try:
actions_log_text.yview_moveto(scroll_position)
except Exception:
pass
else:
actions_log_text.delete("1.0", "end")
actions_log_text.insert(
"1.0", "暂无行为日志(logs/actions.log 不存在)"
)
except Exception as e:
actions_log_text.delete("1.0", "end")
actions_log_text.insert("1.0", f"读取行为日志失败:{e}")
ttk.Label(actions_log_top, text="关键字筛选:").pack(side=LEFT)
ttk.Entry(actions_log_top, textvariable=actions_filter_var, width=16).pack(
side=LEFT, padx=(0, 8)
)
ttk.Button(actions_log_top, text="刷新", command=refresh_actions_log).pack(
side=LEFT, padx=(0, 10)
)
# 行为日志搜索功能
ttk.Separator(actions_log_top, orient="vertical").pack(
side=LEFT, fill=Y, padx=5, pady=3
)
ttk.Label(actions_log_top, text="搜索:").pack(side=LEFT)
actions_search_var = tk.StringVar(value="")
actions_search_entry = ttk.Entry(
actions_log_top, textvariable=actions_search_var, width=20
)
actions_search_entry.pack(side=LEFT, padx=(0, 5))
actions_search_matches = []
actions_current_match_index = -1
def search_in_actions_log(direction=1):
"""在行为日志中搜索文本(使用通用搜索实现)"""
nonlocal actions_search_matches, actions_current_match_index
actions_current_match_index = _generic_search_widget(
actions_log_text,
actions_search_var,
actions_search_matches,
actions_current_match_index,
direction,
)
def search_next_in_actions():
search_in_actions_log(1)
def search_prev_in_actions():
search_in_actions_log(-1)
def clear_search_in_actions():
nonlocal actions_search_matches, actions_current_match_index
actions_search_var.set("")
actions_log_text.tag_remove("search_highlight", "1.0", "end")
actions_log_text.tag_remove("search_current", "1.0", "end")
actions_search_matches = []
actions_current_match_index = -1
def on_actions_search_entry_key(event):
if event.keysym == "Return":
search_next_in_actions()
actions_search_entry.bind("<KeyPress>", on_actions_search_entry_key)
ttk.Button(actions_log_top, text="搜索", command=search_next_in_actions).pack(
side=LEFT, padx=(0, 2)
)
ttk.Button(actions_log_top, text="上一个", command=search_prev_in_actions).pack(
side=LEFT, padx=(0, 2)
)
ttk.Button(actions_log_top, text="下一个", command=search_next_in_actions).pack(
side=LEFT, padx=(0, 2)
)
ttk.Button(actions_log_top, text="清除", command=clear_search_in_actions).pack(
side=LEFT
)
# OCR结果显示
ocr_results_top = ttk.Frame(ocr_results_tab)
ocr_results_top.pack(fill=X, padx=10, pady=(10, 0))
ocr_results_text = ScrolledText(ocr_results_tab)
ocr_results_text.pack(fill=BOTH, expand=True, padx=10, pady=10)
try:
ocr_results_text.configure(font=("Consolas", 10))
except Exception:
pass
def update_ocr_results(results):
"""更新OCR结果标签页的显示"""
try:
lines = []
lines.append("=" * 80)
lines.append("OCR识别结果(基于最新截图)")
lines.append("=" * 80)
lines.append("")
if not results:
lines.append('暂无OCR结果,请先点击"截图+OCR"按钮')
else:
# 按区域名称分组显示
for region_name, desc, text_result, status in results:
lines.append(f"【{region_name}】{desc}")
lines.append(f" 状态: {status}")
if text_result:
# 如果文本较长,分行显示
if len(text_result) > 100:
lines.append(f" 识别文本: {text_result[:100]}...")
lines.append(f" (完整文本: {text_result})")
else:
lines.append(f" 识别文本: {text_result}")
else:
lines.append(" 识别文本: (空)")
lines.append("")
ocr_results_text.delete("1.0", "end")
ocr_results_text.insert("1.0", "\n".join(lines))
ocr_results_text.see("1.0")
except Exception as e:
ocr_results_text.delete("1.0", "end")
ocr_results_text.insert("1.0", f"更新OCR结果失败:{e}")
ttk.Button(
ocr_results_top, text="刷新", command=lambda: update_ocr_results([])
).pack(side=LEFT)
ttk.Label(ocr_results_top, text='(点击"截图+OCR"按钮自动更新)').pack(
side=LEFT, padx=(10, 0)
)
# 中奖记录显示
win_record_top = ttk.Frame(win_record_tab)
win_record_top.pack(fill=X, padx=10, pady=(10, 0))
win_record_left = ttk.Frame(win_record_tab)
win_record_left.pack(side=LEFT, fill=BOTH, expand=True, padx=(10, 5), pady=10)
win_record_right = ttk.Frame(win_record_tab)
win_record_right.pack(
side=RIGHT, fill=BOTH, expand=False, padx=(5, 10), pady=10, ipadx=10
)
# 左侧:中奖截图列表
win_list_label = ttk.Label(win_record_left, text="中奖截图列表:")
win_list_label.pack(anchor="w", padx=(0, 10), pady=(0, 5))
win_list_frame = ttk.Frame(win_record_left)
win_list_frame.pack(fill=BOTH, expand=True)
win_list_scrollbar = ttk.Scrollbar(win_list_frame)
win_list_scrollbar.pack(side=RIGHT, fill=Y)
win_listbox = tk.Listbox(
win_list_frame, yscrollcommand=win_list_scrollbar.set, font=("Consolas", 9)
)
win_listbox.pack(side=LEFT, fill=BOTH, expand=True)
win_list_scrollbar.config(command=win_listbox.yview)
# 存储文件路径映射(索引 -> 文件路径)
_win_file_paths: dict[int, str] = {}
# 右侧:截图预览
win_preview_label = ttk.Label(win_record_right, text="截图预览:")
win_preview_label.pack(anchor="w", pady=(0, 5))
win_preview_frame = ttk.Frame(win_record_right)
win_preview_frame.pack(fill=BOTH, expand=True)
win_image_label = ttk.Label(win_preview_frame)
win_image_label.pack(fill=BOTH, expand=True)
_win_img_ref: dict[str, Any] = {"photo": None}
def scan_win_images():
"""扫描中奖截图目录"""
try:
from douyin.core.path_config import get_pic_dir
pic_dir = get_pic_dir()
except Exception:
from douyin.core import path_config
pic_dir = path_config.get_pic_dir()
prize_dir = os.path.join(pic_dir, "lottery_prize_captures")
win_images = []
if os.path.exists(prize_dir):
for file in os.listdir(prize_dir):
if file.lower().endswith((".png", ".jpg", ".jpeg")):
file_path = os.path.join(prize_dir, file)
# 获取文件修改时间
try:
mtime = os.path.getmtime(file_path)
win_images.append((file, file_path, mtime))
except Exception:
win_images.append((file, file_path, 0))
# 按时间倒序排序(最新的在前)
win_images.sort(key=lambda x: x[2], reverse=True)
return win_images
def refresh_win_record():
"""刷新中奖记录列表"""
try:
win_images = scan_win_images()
win_listbox.delete(0, tk.END)
_win_file_paths.clear()
for idx, (file, file_path, mtime) in enumerate(win_images):
# 格式化显示:文件名 + 时间
try:
dt = datetime.fromtimestamp(mtime)
time_str = dt.strftime("%Y-%m-%d %H:%M:%S")
display_text = f"{file} ({time_str})"
except Exception:
display_text = file
win_listbox.insert(tk.END, display_text)
# 存储文件路径映射
_win_file_paths[idx] = file_path
if win_images:
on_line(f"[中奖记录] 扫描到 {len(win_images)} 张中奖截图")
else:
on_line("[中奖记录] 暂无中奖截图")
except Exception as e:
on_line(f"[中奖记录] 刷新失败:{e}")
def on_win_list_select(event):
"""当选择中奖截图时,显示预览"""
try:
selection = win_listbox.curselection()
if not selection:
return
index = selection[0]
# 从映射中获取文件路径
if index in _win_file_paths:
file_path = _win_file_paths[index]
_load_win_image(file_path)
except Exception as e:
on_line(f"[中奖记录] 预览失败:{e}")
def _load_win_image(img_path: str):
"""加载并显示中奖截图"""
if not os.path.exists(img_path):
win_image_label.configure(image="")
_win_img_ref["photo"] = None
return
try:
img = Image.open(img_path)
img.load()
img = img.convert("RGB")
except Exception as e:
on_line(f"[中奖记录] 图片加载失败:{e}")
return
# 获取预览区域尺寸
try:
win_preview_frame.update_idletasks()
w = win_preview_frame.winfo_width()
h = win_preview_frame.winfo_height()
if w <= 1 or h <= 1:
w, h = 400, 600
except Exception:
w, h = 400, 600
max_w = max(200, w - 20)
max_h = max(300, h - 20)
try:
resample = Image.Resampling.LANCZOS
except AttributeError:
resample = 1
img.thumbnail((max_w, max_h), resample)
photo = ImageTk.PhotoImage(img)
_win_img_ref["photo"] = photo
win_image_label.configure(image=photo)
win_listbox.bind("<<ListboxSelect>>", on_win_list_select)
ttk.Button(win_record_top, text="刷新列表", command=refresh_win_record).pack(
side=LEFT, padx=(0, 10)
)
def open_win_folder():
"""打开中奖截图目录"""
try:
from douyin.core.path_config import get_pic_dir
pic_dir = get_pic_dir()
except Exception:
from douyin.core import path_config
pic_dir = path_config.get_pic_dir()
prize_dir = os.path.join(pic_dir, "lottery_prize_captures")
os.makedirs(prize_dir, exist_ok=True)
try:
os.startfile(prize_dir) # type: ignore[attr-defined]
except Exception as e:
on_line(f"[中奖记录] 打开目录失败:{e}")
ttk.Button(win_record_top, text="打开目录", command=open_win_folder).pack(side=LEFT)
ttk.Button(
win_record_top,
text="实时查看",
command=(
lambda: (
_open_realtime_viewer_impl()
if callable(_open_realtime_viewer_impl)
else None
)
),
).pack(side=LEFT, padx=(8, 0))
# 误识别记录管理
false_positive_frame = ttk.LabelFrame(win_record_right, text="误识别记录管理")
false_positive_frame.pack(fill=X, pady=(10, 0))
false_positive_text = ScrolledText(false_positive_frame, height=6)
false_positive_text.pack(fill=X, padx=10, pady=10)
def load_false_positives():
"""加载误识别记录"""
try:
from douyin.core.path_config import get_pic_dir
pic_dir = get_pic_dir()
except Exception:
from douyin.core import path_config
pic_dir = path_config.get_pic_dir()
false_positive_file = os.path.join(
pic_dir, "lottery_prize_captures", "false_positives.json"
)
if not os.path.exists(false_positive_file):
false_positive_text.delete("1.0", "end")
false_positive_text.insert("1.0", "暂无误识别记录")
return
try:
with open(false_positive_file, "r", encoding="utf-8") as f:
data = json.load(f)
false_positives = data.get("false_positives", [])
false_positive_text.delete("1.0", "end")
if false_positives:
false_positive_text.insert("1.0", "\n".join(false_positives))
else:
false_positive_text.insert("1.0", "暂无误识别记录")
except Exception as e:
false_positive_text.delete("1.0", "end")
false_positive_text.insert("1.0", f"加载失败:{e}")
def save_false_positives():
"""保存误识别记录"""
try:
from douyin.core.path_config import get_pic_dir
pic_dir = get_pic_dir()
except Exception:
from douyin.core import path_config
pic_dir = path_config.get_pic_dir()
false_positive_file = os.path.join(
pic_dir, "lottery_prize_captures", "false_positives.json"
)
os.makedirs(os.path.dirname(false_positive_file), exist_ok=True)
content = false_positive_text.get("1.0", "end-1c")
lines = [line.strip() for line in content.splitlines() if line.strip()]
try:
with open(false_positive_file, "w", encoding="utf-8") as f:
json.dump({"false_positives": lines}, f, ensure_ascii=False, indent=2)
on_line(f"[中奖记录] 已保存 {len(lines)} 条误识别记录")
except Exception as e:
on_line(f"[中奖记录] 保存失败:{e}")
false_positive_btn_frame = ttk.Frame(false_positive_frame)
false_positive_btn_frame.pack(fill=X, padx=10, pady=(0, 10))
ttk.Button(
false_positive_btn_frame, text="刷新", command=load_false_positives
).pack(side=LEFT, padx=(0, 5))
ttk.Button(
false_positive_btn_frame, text="保存", command=save_false_positives
).pack(side=LEFT)
load_false_positives()
pump_logs()
def delayed_refresh_preview() -> None:
if image_var.get():
_async_refresh_preview()
def _async_refresh_preview() -> None:
"""后台加载图片预览,避免阻塞主线程导致 GUI 卡顿。"""
name = image_var.get().strip()
if not name:
return
name_normalized = name.replace("/", os.sep)
path = os.path.join(images_dir, name_normalized)
if not os.path.exists(path):
return
def _worker():
try:
img = Image.open(path)
img.load()
img = img.convert("RGB")
except Exception:
return
def _apply():
try:
preview_body.update_idletasks()
w = preview_body.winfo_width()
h = preview_body.winfo_height()
if w <= 1 or h <= 1:
w, h = 900, 520
max_w = max(300, w - 20)
max_h = max(200, h - 20)
try:
resample = Image.Resampling.LANCZOS
except AttributeError:
resample = 1
img.thumbnail((max_w, max_h), resample)
photo = ImageTk.PhotoImage(img)
_img_ref["photo"] = photo
image_label.configure(image=photo)
preview_status.set(
f"{os.path.basename(path)} {img.width}x{img.height}"
)
except Exception:
pass
try:
root.after(0, _apply)
except Exception:
pass
threading.Thread(target=_worker, daemon=True).start()
root.after(3000, delayed_refresh_preview) # type: ignore[arg-type]
root.after(500, refresh_stats) # type: ignore[arg-type]
root.after(500, refresh_reservations) # type: ignore[arg-type]
root.after(500, refresh_high_value_rooms) # type: ignore[arg-type]
root.after(500, refresh_actions_log) # type: ignore[arg-type]
root.after(500, refresh_win_record) # type: ignore[arg-type]
# 定期刷新行为日志(每2秒)
def auto_refresh_actions_log() -> None:
refresh_actions_log()
root.after(2000, auto_refresh_actions_log) # type: ignore[arg-type]
# 定期刷新预约队列(每5秒)
def auto_refresh_reservations() -> None:
refresh_reservations()
root.after(5000, auto_refresh_reservations) # type: ignore[arg-type]
root.after(2000, auto_refresh_actions_log) # type: ignore[arg-type]
root.after(5000, auto_refresh_reservations) # type: ignore[arg-type]
# 定期刷新统计信息(每3秒)
def auto_refresh_stats() -> None:
if runner.is_running():
refresh_stats()
root.after(3000, auto_refresh_stats) # type: ignore[arg-type]
auto_refresh_stats()
def on_close():
try:
runner.stop()
except Exception:
pass
root.destroy()
root.protocol("WM_DELETE_WINDOW", on_close)
refresh_devices()
root.mainloop()
if __name__ == "__main__":
try:
from douyin.core.version import print_version_banner
print_version_banner("gui_app")
except Exception:
pass
main()