Files
douyi_guaji_main/douyin/core/douyin_fudai.py
T
Your Name 0b5f150691 Refactor and clean up code across multiple scripts
- Removed trailing whitespace and ensured files end with a single newline in cleanup_unused_files.py.
- Added fix_trailing_whitespace.py to batch remove trailing whitespace from Python files.
- Updated install_dependencies.py to improve dependency installation prompts.
- Cleaned up pick_coords.py by removing unnecessary whitespace and improving code readability.
- Enhanced region_selector.py by disabling specific pylint checks for better compatibility with third-party libraries.
- Improved WPS流程图生成工具.py by cleaning up whitespace and enhancing readability.
- Updated __init__.py in typings to remove unnecessary lines.
- Modified app.js to adjust default configuration values and clean up unused code.
2026-01-02 23:57:03 +08:00

3335 lines
159 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.
"""
本地完整版 douyin_fudai(模块化调度器)
======================================
目标:
- 不再依赖外部 axf 目录;
- 保持 `from douyin_fudai import fudai_analyse` 导入方式不变;
- 将核心逻辑拆分到各子模块,仅在此做"组装 + 调度"。
"""
from __future__ import annotations
from typing import Any, List, Tuple, Optional
import os
import time
import logging
from Underlying_Operations import underlying_operations
from douyin.stage import douyin_stage
from douyin.detection import douyin_detection
from douyin.fudai import douyin_fudai_detail
from douyin.fudai import douyin_fudai_core
from douyin.core import douyin_flow_control
from douyin.other import douyin_live_room
from douyin.reservation import douyin_reservation_logic
from douyin.utils import douyin_config
from douyin.logging import douyin_logging_wrapper
from douyin.handlers import douyin_screenshot_handler
from douyin.utils import douyin_helpers
from douyin.handlers import douyin_popup_handler
from douyin.handlers import douyin_swipe_handler
from douyin.reservation import douyin_reservation_handler
from douyin.stage import douyin_stage_handler
class fudai_analyse:
"""福袋抽奖相关操作类(本地模块化实现,保留原有属性与入口)。"""
# 类常量:魔法数字提取
MAX_BACK_CLICKS_TO_RECOMMEND = 10 # 返回推荐页面的最大返回键点击次数
BACK_KEY_CLICK_DELAY = 1.0 # 返回键点击后的延迟(秒)
PAGE_STABLE_DELAY = 2.0 # 页面稳定等待时间(秒)
FOLLOW_TAB_CLICK_DELAY = 2.0 # 点击关注标签后的延迟(秒)
ENTER_LIVE_CLICK_DELAY = 0.6 # 点击进入直播间的延迟(秒)
ENTER_LIVE_FINAL_DELAY = 2.0 # 进入直播间后的最终等待时间(秒)
def __init__(self) -> None:
# 设备与分辨率
self.device_id: str = "" # 设备ID,需要在运行时设置
self.y_pianyi: int = 0
self.resolution_ratio_x: int = 1080
self.resolution_ratio_y: int = 2400
# 滑动次数计数器(用于滑动次数重置功能)
self._swipe_times: int = 0
# 运行配置(只保留与你当前需求直接相关的主流程字段,细节统一放在各子模块内部)
self.operation = underlying_operations()
self.config_path = "config/config.json"
# 日志相关字段:完全独立的日志系统(不依赖原始代码)
try:
from datetime import datetime
self._run_id = datetime.now().strftime("%Y%m%d%H%M%S")
except Exception:
self._run_id = str(int(time.time()))
self._log_seq = 0
self._log_kv_orig = None
# 使用增强版本(通过日志包装器)
self._log_kv = lambda *args, **kwargs: douyin_logging_wrapper.LoggingWrapper.enhanced_log_kv(
self, *args, **kwargs
)
# 用于跟踪上一个日志标签,以便检测阶段变化并添加分隔符
self._last_log_tag = None
# 预定义可在运行中动态创建的属性,避免 access-before-definition / attribute-defined-outside-init 警告
self._std_logger = None # type: ignore[assignment]
# 初始化统一日志系统和traceId
# 确保日志系统已配置(在实例化之前)
try:
from douyin.logging import douyin_logging
# 检查 _logging_configured 标志是否存在
if not getattr(douyin_logging, "_logging_configured", False):
douyin_logging.configure_logging()
except Exception:
pass
try:
from unified_logger import MDC, get_unified_logger
# 为当前实例设置traceId
MDC.set_trace_id(f"run_{self._run_id}")
self._std_logger = get_unified_logger("douyin.fudai")
except ImportError:
# 如果unified_logger不可用,使用标准logging
self._std_logger = logging.getLogger("douyin.fudai")
# 确保根 logger 有 handlers
root_logger = logging.getLogger()
if not root_logger.handlers:
try:
from douyin.logging import douyin_logging
douyin_logging.configure_logging()
except Exception:
pass
self._forced_reservation_detail = None
self._forced_reservation_fudai_x = None
# 进入直播间后诊断与阶段流转所需的一些状态
self._last_diag_stage: str = "INIT"
self._last_diag_seen: str = "-"
self._last_diag_ts: float = 0.0
# 30分钟超时相关:记录最后一次成功参与福袋的时间
self._last_successful_attend_ts: float = 0.0
self._no_attend_timeout_minutes: float = (
30.0 # 30分钟没有参与成功则返回推荐页面(可通过config.json配置)
)
self._run_start_ts: float = (
time.time()
) # 记录运行开始时间,用于从未成功参与时的超时检查
self.last_fudai_x: int = 0 # 上次检测到的福袋图标X坐标(用于优化搜索)
# 与配置相关的核心字段(只初始化最关键的几项,其余保持默认)
self.contains_not_want: list[str] = []
self.contains_want: list[str] = []
self.min_prize_value_yuan: float = 0.0
self.min_participants: int = 0
self.max_participants: int = 0
self.skip_if_countdown_gt_seconds: int = 900
self.skip_if_countdown_lt_seconds: int = 0 # 倒计时小于该秒数则不参与
self.no_fudai_watchdog_enabled: bool = False
# 福袋图标检测节流相关默认值
# 实际识别到福袋一般需要 4–6 秒,这里取中间值 5 秒作为默认上限,具体值可在 GUI / config.json 中调整
# 注意:已改为使用时间限制(fudai_icon_max_wait_seconds),不再使用尝试次数限制
self.fudai_icon_retry_delay_seconds: float = 0.6
self.fudai_icon_max_wait_seconds: float = 5.0
# 点击福袋图标后等待详情页加载的时间(秒)
self.fudai_click_wait_seconds: float = 1.0
# 切换直播间后等待阶段诊断的时间(秒)
self.switch_room_wait_after_stage_diag_seconds: float = 7.0
# 滑动速度(毫秒),影响滑动持续时间,值越大滑动越慢
self.swipe_duration_ms: int = 600
# fudai_find_max_attempts 已废弃,保留仅为兼容性,实际不再使用
self.fudai_find_max_attempts: int = 10
# 优化查找器相关配置
self.fudai_finder_optimized_enabled: bool = True # 默认启用优化查找器
self.fudai_click_verify_enabled: bool = True # 点击后验证是否成功打开详情页
self.fudai_find_max_retries: int = 3 # 最大重试次数
self.screenshot_diagnose_min_interval_seconds: float = 8.0
# 开奖页面检测红色占比阈值(0.0~1.0)
self.lucky_draw_red_ratio_threshold: float = 0.9
# 优惠券模板匹配阈值(0.0~1.0,默认0.75)
self.coupon_template_match_threshold: float = 0.75
# 参与按钮红色占比阈值(0.0~1.0,默认0.25)
self.attend_button_red_ratio_threshold: float = 0.25
# 粉丝团加入红色占比阈值(0.0~1.0,默认0.25)
self.fansclub_join_red_ratio_threshold: float = 0.25
# 直播间检测阈值(模板匹配阈值,0.0~1.0,默认0.8)
self.live_room_match_threshold: float = 0.8
# 福袋模板匹配开关(默认关闭)
self.fudai_template_match_enabled: bool = False
# 福袋模板匹配阈值(0.0~1.0,默认0.7)
self.fudai_template_match_threshold: float = 0.7
# —— 高价值福袋 / 预约相关配置(从原 fudai1 精简迁移) ——
# 是否启用“高价值福袋预约参与”
self.high_value_fudai_enabled: bool = False
# 高价值阈值(元)
self.high_value_fudai_threshold_yuan: float = 500.0
# 提前参与秒数:开奖前 N 秒回到该直播间并参与
self.high_value_fudai_join_ahead_seconds: int = 120
# 从当前位置最多回滑多少次以回到预约直播间
self.high_value_fudai_max_swipe_back: int = 35
# 同时记录的最大预约数量
self.high_value_fudai_max_reservations: int = 3
# 完成某个预约福袋后的动作:stay=停留当前直播间;continue=继续执行抢福袋
self.high_value_fudai_after_action: str = "continue"
self.high_value_fudai_after_stay_seconds: int = 120
# 高价值直播间"回访"相关(当前仅保留配置,不在本地版强制启用复杂逻辑)
self.high_value_room_revisit_enabled: bool = False
self.high_value_room_revisit_only_current_run: bool = False
# 粉丝团相关配置
self.auto_join_fansclub: bool = False # 是否自动加入粉丝团
self.fansclub_fail_action: str = (
"stay" # 粉丝团失败策略:stay=停留,switch=切换
)
# 预约回退相关
self.reservation_back_verify_enabled: bool = True # 默认启用回退校验
# 未做回退校验时的快速回滑延迟(秒)
self.reservation_back_swipe_delay: float = 0.6
# 预约抢占最小价值:低于该价值的预约不会抢占当前任务(元)
self.reservation_preempt_min_value_yuan: float = 0.0
# 在预计开奖前多少秒开始积极轮询结果
self.poll_before_open_seconds: int = 10
# 滑动次数重置相关
self.reset_after_swipes_enabled: bool = False # 由 Web/CLI 显式开关
self.reset_after_swipes: int = 10 # 达到阈值次数后回退,需启用开关后生效
# 意外返回桌面自救相关
self.desktop_icon_x: int = 153 # 桌面图标 X 坐标(默认值)
self.desktop_icon_y: int = 260 # 桌面图标 Y 坐标(默认值)
self.yanghao_fallback_live_x: int = 540 # 养号备用直播按钮 X 坐标
self.yanghao_fallback_live_y: int = 2000 # 养号备用直播按钮 Y 坐标
self.yanghao_fallback_enter_live_x: int = 540 # 养号备用进入直播间 X 坐标
self.yanghao_fallback_enter_live_y: int = 1200 # 养号备用进入直播间 Y 坐标
# —— 预约运行时状态(单次运行内有效) ——
# 高价值福袋预约队列
self.reservations: list[dict[str, Any]] = []
# 标记是否是第一次运行 run_once_basic(用于刷新预约队列)
self._first_run_once_basic: bool = True
# 当前"直播间位置"计数:上划 +1,下滑 -1(仅在本次连续切换过程中有效)
self.room_pos: int = 0
# 回退到预约直播间后,在该时间戳前不允许上划离开
self.reservation_focus_until_ts: float = 0.0
# 当前是否还有"完成某个预约后的后续动作"待执行
self.reservation_after_action_pending: bool = False
# 达到"无福袋切换阈值"后,是否在处理完预约后回到列表第一个直播间
self.reset_to_list_after_reservations: bool = False
# 队列满时是否已回退到最早开奖的预约直播间等待
self.queue_full_waiting_at_earliest: bool = False
# 预约队列状态文件(供 WebGUI / 其他进程查看)
self._reservations_state_path: str = os.path.join(
os.path.dirname(__file__), "state", "reservations.json"
)
# 运行时直播间标题和位置映射表(用于回退校验)
# 格式:{room_pos: (room_title, room_title_raw)}
self._room_pos_to_title_map: dict[int, tuple[str, str]] = {}
# 运行时状态标志(避免在外部定义属性的警告)
self.needswitch: bool | None = (
None # 是否允许切换直播间,将从配置文件加载,默认 True
)
self._waiting_for_lottery_result: bool = False # 是否正在等待开奖结果
self._reservation_back_direct_attend: bool = False # 预约回退后直接参与标志
self._force_attend_after_reservation_back: bool = False # 强制参与标志
self._skip_stage_diagnosis_and_find_fudai: bool = False # 跳过阶段诊断标志
self._just_switched_room: bool = False # 是否刚刚切换了直播间
self._last_fudai_detail_tuple: Optional[Tuple[Any, ...]] = (
None # 上次读取的福袋详情
)
self._current_fudai_future_ts: float = 0.0 # 当前福袋的开奖时间戳
self._fudai_detail_first_read: bool = False # 是否第一次读取福袋详情
self._fudai_detail_consecutive_failures: int = 0 # 连续失败次数
self._detail_closed_by_attend: bool = False # 详情页是否由参与操作关闭
self._lottery_result_expected_ts: float = 0.0 # 开奖结果预期时间戳
# 初次加载配置
self.load_config()
# ===== 兼容原始脚本的一些简单封装方法 =====
def _find_room_pos_by_title(
self, target_title: str, target_title_raw: str = ""
) -> int | None:
"""根据直播间标题在运行时映射表中查找对应的位置。
返回:
如果找到匹配的位置,返回位置值;否则返回 None
"""
return douyin_reservation_handler.ReservationHandler.find_room_pos_by_title(
self, target_title, target_title_raw
)
def _record_room_title_and_pos(self) -> None:
"""记录当前直播间的标题和位置到运行时映射表。
用于预约回退校验时验证位置信息。
"""
douyin_reservation_handler.ReservationHandler.record_room_title_and_pos(self)
def click(self, x: int, y: int) -> None:
"""兼容原版 fudai_analyse.click:转发到底层 operation.click。"""
douyin_helpers.HelperFunctions.click(self, x, y)
def load_config(self) -> None:
"""从 config.json 加载与福袋筛选/节流相关的关键参数(精简版)。"""
douyin_config.ConfigManager.load_config_from_file(self) # type: ignore[attr-defined]
# ========== 兼容旧入口:主循环 ==========
def fudai_choujiang(
self,
device_id: str = "",
y_pianyi: int = 0,
needswitch: bool = False,
wait_minutes: int = 15,
) -> None:
"""兼容原 fudai1.fudai_choujiang 的主入口(当前实现为精简版:仅基础抢福袋)。"""
# DEBUG: 记录函数入口
try:
self._log_kv(
"DEBUG",
"entered fudai_choujiang",
device_id=device_id,
wait_minutes=wait_minutes,
)
except Exception:
print(
f"[DEBUG] entered fudai_choujiang device_id={device_id} wait_minutes={wait_minutes}"
)
self.device_id = device_id or self.device_id
self.y_pianyi = int(y_pianyi or 0)
# 保存是否允许切换直播间的配置,供后续所有逻辑统一使用
try:
self.needswitch = bool(needswitch)
except Exception:
# 兜底:若赋值失败,则保持原有行为(默认允许切换)
self.needswitch = True
# 尝试获取设备分辨率;若设备未连接则重试数次再回退到默认分辨率
resolved = False
if self.device_id:
for attempt in range(5):
try:
rx, ry = self.operation.get_device_resolution(self.device_id)
self.resolution_ratio_x = int(rx or 1080)
self.resolution_ratio_y = int(ry or 2400)
resolved = True
break
except Exception as e:
try:
self._log_kv(
"截图",
"获取分辨率失败,重试中",
attempt=attempt + 1,
error=str(e),
)
except Exception:
print(
f"[DEBUG] get_device_resolution attempt {attempt+1} failed: {e}"
)
time.sleep(1.0)
if not resolved:
# 回退到默认分辨率
try:
self._log_kv("截图", "使用默认分辨率回退", width=1080, height=2400)
except Exception:
pass
self.resolution_ratio_x, self.resolution_ratio_y = 1080, 2400
# 记录运行开始
from datetime import datetime
start_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f")[:-3]
try:
actions_log_path = os.path.join(
os.path.dirname(__file__), "logs", "actions.log"
)
log_dir = os.path.dirname(actions_log_path)
if log_dir:
os.makedirs(log_dir, exist_ok=True)
with open(
actions_log_path, "a", encoding="utf-8-sig", errors="replace"
) as f:
f.write("=" * 80 + "\n")
f.write(f"{start_time} - [GUI] - [运行] 程序开始运行\n")
f.flush()
except Exception:
pass
# 捕获并记录未被捕获的异常以便排查立即退出问题
try:
# 原有后续逻辑继续...
pass
except Exception as top_exc:
try:
self._log_kv(
"ERROR", "fudai_choujiang top-level exception", error=str(top_exc)
)
except Exception:
import traceback
traceback.print_exc()
raise
# 暂时禁用流式截图,使用直接截图模式
self._log_kv("截图服务", "暂时禁用流式截图,使用直接截图模式")
self._log_kv(
"启动",
"fudai_choujiang 开始执行(基础版,仅抢当前直播间福袋,不含预约/高价值房间)",
分辨率=f"{self.resolution_ratio_x}x{self.resolution_ratio_y}",
needswitch=int(bool(self.needswitch)),
wait_minutes=int(wait_minutes),
)
# 基础循环:在限定时间内反复执行单轮逻辑
# 如果 wait_minutes <= 0,则无限循环运行
if wait_minutes and wait_minutes > 0:
end_ts = time.time() + int(wait_minutes) * 60
while time.time() < end_ts:
try:
self.run_once_basic()
except Exception as exc:
# 捕获异常,记录日志,但继续循环
try:
self._log_kv(
"循环",
"run_once_basic 异常",
error=str(exc),
error_type=type(exc).__name__,
)
except Exception:
pass
# 异常后稍作延迟再继续
try:
self.operation.delay(2.0)
except Exception:
time.sleep(2.0)
continue
# 为避免过于频繁截图,增加少量间隔
try:
self.operation.delay(1.0)
except Exception:
time.sleep(1.0)
# 记录运行结束(定时模式)
try:
from datetime import datetime
end_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f")[:-3]
actions_log_path = os.path.join(
os.path.dirname(__file__), "logs", "actions.log"
)
log_dir = os.path.dirname(actions_log_path)
if log_dir:
os.makedirs(log_dir, exist_ok=True)
with open(
actions_log_path, "a", encoding="utf-8-sig", errors="replace"
) as f:
f.write("=" * 80 + "\n")
f.write(f"{end_time} - [GUI] - [运行] 程序运行结束(时间到)\n")
f.flush()
except Exception:
pass
else:
# 无限循环模式(wait_minutes <= 0)
self._log_kv("循环", "进入无限循环模式(wait_minutes <= 0)")
while True:
try:
self.run_once_basic()
except KeyboardInterrupt:
# 允许 Ctrl+C 退出
self._log_kv("循环", "收到中断信号,退出循环")
# 记录运行结束
try:
from datetime import datetime
end_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f")[:-3]
actions_log_path = os.path.join(
os.path.dirname(__file__), "logs", "actions.log"
)
log_dir = os.path.dirname(actions_log_path)
if log_dir:
os.makedirs(log_dir, exist_ok=True)
with open(
actions_log_path,
"a",
encoding="utf-8-sig",
errors="replace",
) as f:
f.write("=" * 80 + "\n")
f.write(
f"{end_time} - [GUI] - [运行] 程序运行结束(中断退出)\n"
)
f.flush()
except Exception:
pass
raise
except Exception as exc:
# 捕获异常,记录日志,但继续循环
try:
self._log_kv(
"循环",
"run_once_basic 异常",
error=str(exc),
error_type=type(exc).__name__,
)
except Exception:
pass
# 异常后稍作延迟再继续
try:
self.operation.delay(2.0)
except Exception:
time.sleep(2.0)
continue
# 为避免过于频繁截图,增加少量间隔
try:
self.operation.delay(1.0)
except Exception:
time.sleep(1.0)
# ========== 阶段诊断 ==========
def _diagnose_stage_from_current_screen(
self, force_screenshot: bool = False
) -> Tuple[str, str]:
"""封装到子模块的阶段诊断入口。
参数:
force_screenshot: 是否强制重新截图(默认False,优先使用缓存)
"""
return douyin_stage_handler.StageHandler.diagnose_stage_from_current_screen(
self
)
# ========== 截图 / 裁剪 / 图标检测(供阶段诊断等调用) ==========
def cut_pic(
self,
x_top: int = 1,
y_top: int = 1,
x_bottom: int = 2,
y_bottom: int = 2,
target: str = "",
cut_pic_name: str = "",
y_pianyi: int = 0,
) -> None:
"""裁剪图片:保持与原 fudai1.cut_pic 相同的坐标语义(1080x2400 基准)。"""
douyin_screenshot_handler.ScreenshotHandler.cut_pic(
self, x_top, y_top, x_bottom, y_bottom, target, cut_pic_name, y_pianyi
)
def _read_pixel_stage_state(
self, return_details: bool = False
) -> dict | tuple[dict, dict]:
"""读取像素阶段状态(用于阶段诊断)。
参数:
return_details: 是否返回每个检测步骤的详细信息(包括分数)
返回:
dict: 检测结果(return_details=False时)
tuple[dict, dict]: (检测结果, 详细信息)(return_details=True时)
"""
return douyin_helpers.HelperFunctions.read_pixel_stage_state(
self, return_details
)
def _scale_from_base(self, base_x: int, base_y: int) -> tuple[int, int]:
"""将以 1080x2400 为基准的坐标缩放到当前设备分辨率并应用 y 偏移。
返回 (scaled_x, scaled_y)
"""
return douyin_screenshot_handler.ScreenshotHandler.scale_from_base(
self, base_x, base_y
)
def _save_step_screenshot(self, label: str) -> None:
"""保存当前截图到 `pic/steps/` 目录,文件名包含 run_id 与序号,供调试与回放使用。"""
douyin_screenshot_handler.ScreenshotHandler.save_step_screenshot(self, label)
def _check_in_live_room_by_icon(
self,
) -> Tuple[bool, float]: # pyright: ignore[reportAttributeAccessIssue]
"""通过右上角关闭/心形图标进行直播间图形识别(轻量模板匹配版)。
返回:
(detected, score) 其中 score 为匹配得分(0.0~1.0,来自 TM_CCOEFF_NORMED)。
"""
return douyin_stage_handler.StageHandler.check_in_live_room_by_icon(self)
def check_in_fudai_detail(self) -> bool:
"""判断当前是否处于福袋详情页:委托给 douyin_detection.check_in_fudai_detail。"""
try:
return bool(douyin_detection.check_in_fudai_detail(self))
except Exception as exc:
try:
self._log_kv("检测", "check_in_fudai_detail 异常", error=str(exc))
except Exception:
pass
return False
def _enhanced_log_kv(self, *args, **fields):
"""增强的日志记录方法:始终输出到 stdout(供 GUI 捕获),同时可选输出到标准 logging"""
douyin_logging_wrapper.LoggingWrapper.enhanced_log_kv(self, *args, **fields)
# 供像素/检测模块记录子步骤耗时使用
def _log_step_time(
self, step_name: str, start_time: float, extra_info: dict | None = None
) -> None:
"""记录某个子步骤的耗时(供检测模块调用,减少日志噪音)。"""
douyin_logging_wrapper.LoggingWrapper.log_step_time(
self, step_name, start_time, extra_info
)
# ========== 弹窗 / 人机校验 ==========
def _check_coupon_popup(self) -> bool:
"""购物券 / 新客专享券 等底部营销弹窗(仅在详情链路外的"看门狗"中使用)。"""
return douyin_popup_handler.PopupHandler.check_coupon_popup(self)
def _check_shopping_redpacket_popup(self) -> bool:
"""购物红包中央弹窗。"""
return douyin_popup_handler.PopupHandler.check_shopping_redpacket_popup(self)
# ========== 主循环骨架(基础抢福袋 + 简化预约抢占) ==========
def run_once_basic(self) -> None: # type: ignore[complexity]
"""单轮基础抢福袋流程(包含简化版高价值福袋预约回退)。
注意:此方法复杂度较高,已通过模块化重构将部分逻辑拆分到子模块。
"""
from douyin.reservation import (
douyin_reservation_logic,
) # 确保在函数作用域内可用
start_time = time.time()
# 0. 如果正在等待开奖,检查高价值预约是否需要抢占,否则只检测开奖结果
if getattr(self, "_waiting_for_lottery_result", False):
try:
# 检查是否有高价值预约需要处理(除非遇到高价值预约,否则应该等待福袋开奖)
should_preempt = False
try:
if getattr(self, "high_value_fudai_enabled", False) and getattr(
self, "reservations", None
):
reservations = self.reservations
if reservations and len(reservations) > 0:
# 检查是否有预约需要立即处理
from douyin.reservation import douyin_reservation_logic
reservation_focus_until_ts_ref = [0.0]
reservation_after_action_pending_ref = [False]
room_pos_ref = [getattr(self, "room_pos", 0) or 0]
# 检查是否有预约需要抢占
preempted = douyin_reservation_logic.process_reservation_attend_window(
self,
reservations,
room_pos_ref[0],
reservation_focus_until_ts_ref,
reservation_after_action_pending_ref,
float(
getattr(self, "reservation_back_swipe_delay_s", 0.5)
or 0.5
),
lambda: self.swipe_down_back_from_live(),
lambda item: self._seek_reservation_room(item),
lambda: (
douyin_reservation_logic._sort_reservations_inplace(
self.reservations
)
if self.reservations
else None
),
lambda: None, # write_state_callback
)
if preempted:
# 有高价值预约需要处理,清除等待开奖标志,中断等待
self._waiting_for_lottery_result = False
should_preempt = True
self._log_kv(
"参与",
"等待开奖期间检测到高价值预约需要处理,中断等待",
)
except Exception as exc:
self._log_kv("参与", "检查高价值预约时出错", error=str(exc))
if should_preempt:
# 被高价值预约抢占,继续执行后续逻辑处理预约
pass
else:
# 没有预约抢占,继续等待开奖
# 直接用预计开奖时间减去当前时间计算剩余秒数,加上6秒延迟修正
future_ts = getattr(self, "_lottery_result_expected_ts", 0.0) or 0.0
current_ts = time.time()
remain_seconds = max(
0, future_ts - current_ts + 6.0
) # 加上6秒延迟,修正倒计时误差
# 开奖时间 + 1秒缓冲后开始检测开奖结果(提前4秒:从+5秒改为+1秒)
check_start_ts = future_ts + 1.0
# 超时时间:如果超过开奖时间10秒还没检测到结果,清除等待标志(福袋开奖后10秒会自动关闭)
timeout_ts = future_ts + 10.0
if current_ts >= timeout_ts:
# 超过超时时间,清除等待标志,避免卡死
self._waiting_for_lottery_result = False
timeout_seconds = int(current_ts - future_ts)
self._log_kv(
"参与",
f"等待开奖超时(超过开奖时间{timeout_seconds}秒),清除等待标志,继续执行其他操作",
超时秒数=timeout_seconds,
)
# 继续执行后续逻辑,不返回
elif current_ts >= check_start_ts:
# 已经超过开奖时间+缓冲时间,直接点击"我知道了"按钮(多次点击,确保关闭弹窗)
# 计算已过开奖时间的秒数
passed_seconds = int(current_ts - future_ts)
self._log_kv(
"参与",
f"等待开奖结果中,OCR未识别到结果(已过开奖时间{passed_seconds}秒),开始直接点击",
已过开奖时间秒数=passed_seconds,
)
# 按钮位置基于1080x2400:532, 1322
rx = int(getattr(self, "resolution_ratio_x", 1080) or 1080)
ry = int(getattr(self, "resolution_ratio_y", 2400) or 2400)
btn_x = int(532 * rx // 1080)
btn_y = int(1322 * ry // 2400)
# 直接点击已被禁用 —— 改为仅使用 OCR 模式识别与处理结果
self._log_kv(
"参与",
"直接点击已禁用,改为OCR识别处理开奖结果",
)
try:
self.operation.get_screenshot(self.device_id)
except Exception:
pass
result = self._check_lottery_result_by_ocr()
if result:
self._waiting_for_lottery_result = False
self._log_kv("参与", "等待期间检测到开奖结果,开始处理")
self._handle_lottery_result_by_ocr(result)
elapsed = time.time() - start_time
self._log_kv(
"流程",
"run_once_basic完成(等待开奖期间处理结果)",
elapsed_seconds=round(elapsed, 2),
)
return
# 未识别到则清除等待标志并继续(不执行点击)
self._waiting_for_lottery_result = False
self._log_kv(
"参与",
"等待开奖期间:未识别到开奖结果(点击已禁用),清除等待标志",
)
# 切换下一个直播间
try:
needswitch = bool(getattr(self, "needswitch", True))
except Exception:
needswitch = True
if needswitch:
self._log_kv(
"开奖结果", "处理完开奖结果,切换直播间找新福袋"
)
self.swipe_up_to_next_live()
elapsed = time.time() - start_time
self._log_kv(
"流程",
"run_once_basic完成(等待开奖期间处理结果)",
elapsed_seconds=round(elapsed, 2),
)
return
else:
# 还未到开奖时间,短暂等待后继续检测
wait_s = min(2.0, remain_seconds)
remain_seconds_int = int(remain_seconds)
# 在日志消息中显示倒计时
self._log_kv(
"参与",
f"等待开奖中,剩余{remain_seconds_int}秒",
剩余秒数=remain_seconds_int,
)
self.operation.delay(wait_s)
elapsed = time.time() - start_time
self._log_kv(
"流程",
f"run_once_basic完成(等待开奖中,剩余{remain_seconds_int}秒)",
elapsed_seconds=round(elapsed, 2),
)
return # 返回,不执行其他操作
except Exception as exc:
self._log_kv("参与", "等待开奖检测时出错", error=str(exc))
# 出错时清除等待标志,避免卡死
self._waiting_for_lottery_result = False
# 0. 检查30分钟超时:如果30分钟没有成功参与福袋,则返回推荐页面并重新进入直播间
try:
last_attend_ts = float(
getattr(self, "_last_successful_attend_ts", 0.0) or 0.0
)
timeout_minutes = float(
getattr(self, "_no_attend_timeout_minutes", 30.0) or 30.0
)
current_ts = time.time()
run_start_ts = float(
getattr(self, "_run_start_ts", current_ts) or current_ts
)
# 如果从未成功参与过,且运行时间超过30分钟,则触发超时
# 如果成功参与过,检查距离最后一次成功参与是否超过30分钟
if last_attend_ts > 0:
elapsed_minutes = (current_ts - last_attend_ts) / 60.0
if elapsed_minutes >= timeout_minutes:
try:
self._log_kv(
"超时",
"30分钟未参与成功福袋,返回推荐页面重新进入直播间",
last_attend_minutes_ago=round(elapsed_minutes, 1),
)
except Exception:
pass
# 返回推荐页面并重新进入直播间
self._return_to_recommend_and_reenter_live()
# 重置最后成功参与时间,避免立即再次触发
try:
self._last_successful_attend_ts = current_ts
except Exception:
pass
elapsed = time.time() - start_time
self._log_kv(
"流程",
"run_once_basic完成(30分钟超时处理)",
elapsed_seconds=round(elapsed, 2),
)
return
else:
# 从未成功参与过,检查运行时间
elapsed_minutes = (current_ts - run_start_ts) / 60.0
if elapsed_minutes >= timeout_minutes:
try:
self._log_kv(
"超时",
f"运行{round(elapsed_minutes, 1)}分钟仍未参与成功福袋,返回推荐页面重新进入直播间",
run_minutes=round(elapsed_minutes, 1),
)
except Exception:
pass
# 返回推荐页面并重新进入直播间
self._return_to_recommend_and_reenter_live()
# 重置运行开始时间(在成功重新进入直播间后重置,避免立即再次触发)
# 注意:重置逻辑已移至 _return_to_recommend_and_reenter_live() 方法中
elapsed = time.time() - start_time
self._log_kv(
"流程",
"run_once_basic完成(30分钟超时处理)",
elapsed_seconds=round(elapsed, 2),
)
return
except Exception as exc:
try:
self._log_kv("超时", "检查30分钟超时时出错", error=str(exc))
except Exception:
pass
# 0.1. 若启用高价值预约:先处理"是否需要回退到预约直播间"
try:
# 每次开始运行时丢弃旧的预约队列,不加载状态文件
try:
# 如果是第一次运行,清空预约队列,不加载状态文件
is_first_run = getattr(self, "_first_run_once_basic", True)
# 记录清空前的队列状态(用于调试)
old_reservations_count = 0
try:
old_reservations_count = (
len(self.reservations)
if hasattr(self, "reservations") and self.reservations
else 0
)
except Exception:
pass
if is_first_run:
try:
self._log_kv(
"预约",
"[预约] 第一次运行:丢弃旧的预约队列,不加载状态文件",
old_reservations_count=old_reservations_count,
)
except Exception:
pass
# 清空预约队列(强制清空,确保每次启动时队列为空)
try:
# 先记录清空前的状态
before_clear = (
len(self.reservations)
if hasattr(self, "reservations") and self.reservations
else 0
)
self.reservations = []
after_clear = (
len(self.reservations)
if hasattr(self, "reservations")
else 0
)
# 同时清空状态文件,确保外部查看时也是空的
try:
state_path = getattr(self, "_reservations_state_path", None)
if state_path:
# 写入空队列到状态文件
from douyin.reservation.douyin_reservation import (
write_reservations_state,
)
write_reservations_state(
state_path=state_path,
reservations=[],
room_pos=0,
current_room_title="",
current_room_title_raw="",
reason="startup_clear",
)
try:
self._log_kv(
"预约",
"[预约] 已清空预约队列并更新状态文件",
before_clear=before_clear,
after_clear=after_clear,
)
except Exception:
pass
except Exception as exc:
try:
self._log_kv(
"预约",
"[预约] 清空状态文件时出错",
error=str(exc),
error_type=type(exc).__name__,
)
except Exception:
pass
except Exception as exc:
# 如果清空失败,尝试直接设置
try:
if hasattr(self, "reservations"):
self.reservations = []
self._log_kv(
"预约",
"[预约] 清空预约队列时出错,已尝试直接设置",
error=str(exc),
error_type=type(exc).__name__,
)
except Exception:
pass
# 标记已运行过
try:
self._first_run_once_basic = False
except Exception:
pass
else:
# 如果不是第一次运行,也记录日志(用于调试)
try:
current_count = (
len(self.reservations)
if hasattr(self, "reservations") and self.reservations
else 0
)
self._log_kv(
"预约",
"[预约] 非第一次运行,保持当前预约队列",
reservations_count=current_count,
is_first_run=False,
)
except Exception:
pass
# 不再从状态文件加载预约数据,每次启动时都从空队列开始
# 已移除从状态文件加载预约数据的逻辑,每次启动时预约队列为空
except Exception as exc:
try:
self._log_kv(
"预约",
"[预约] 初始化预约队列时出错",
error=str(exc),
error_type=type(exc).__name__,
)
except Exception:
pass
high_value_enabled = getattr(self, "high_value_fudai_enabled", False)
reservations_list = getattr(self, "reservations", None)
reservations_count = len(reservations_list) if reservations_list else 0
# 添加详细的调试日志,确认预约回退逻辑的触发条件
try:
# 输出预约队列的详细信息
reservations_detail = []
if reservations_list:
for idx, r in enumerate(reservations_list[:3]): # 只显示前3个
try:
ft = float(r.get("future_ts") or 0)
from datetime import datetime
ft_str = (
datetime.fromtimestamp(ft).strftime("%Y-%m-%d %H:%M:%S")
if ft > 0
else "无效"
)
reservations_detail.append(
{
"index": idx,
"future_ts": int(ft) if ft > 0 else 0,
"future_str": ft_str,
"value": float(r.get("prize_value_yuan", 0)),
"pos_seen": int(r.get("pos_seen", 0)),
}
)
except Exception:
pass
self._log_kv(
"预约",
"[预约] run_once_basic:检查预约回退触发条件",
high_value_enabled=high_value_enabled,
reservations_count=reservations_count,
reservations_is_none=(reservations_list is None),
will_check_reservations=bool(
high_value_enabled and reservations_list
),
reservations_detail=reservations_detail,
)
except Exception:
pass
# 如果预约功能未启用,输出日志
if not high_value_enabled:
try:
self._log_kv(
"预约",
"[预约] 预约功能未启用(high_value_fudai_enabled=False),跳过预约回退检查",
)
except Exception:
pass
# 如果预约队列为空,输出日志
elif not reservations_list or reservations_count == 0:
try:
self._log_kv(
"预约",
"[预约] 预约队列为空,跳过预约回退检查",
reservations_is_none=(reservations_list is None),
reservations_count=reservations_count,
)
except Exception:
pass
if high_value_enabled and reservations_list:
def _swipe_down_once() -> None:
self.swipe_down_back_from_live()
def _sort_reservations() -> None:
douyin_reservation_logic._sort_reservations_inplace(self.reservations) # type: ignore[attr-defined]
def _write_state() -> None:
# 将预约队列写入状态文件,供外部查看(格式与 douyin_fudai_core.py 一致)
try:
import json
os.makedirs(
os.path.dirname(self._reservations_state_path),
exist_ok=True,
)
# 格式化预约队列数据(与 douyin_reservation.py 格式一致)
items = []
for r in self.reservations or []:
try:
ft = float(r.get("future_ts") or 0)
except Exception:
ft = 0.0
try:
ft_str = (
datetime.fromtimestamp(ft).strftime(
"%Y-%m-%d %H:%M:%S"
)
if ft
else ""
)
except Exception:
ft_str = str(r.get("future_str", ""))
items.append(
{
"prize_value_yuan": float(
r.get("prize_value_yuan") or 0
),
"content": str(r.get("content") or ""),
"future_ts": ft,
"future_str": ft_str,
"pos_seen": int(r.get("pos_seen") or 0),
"room_title": str(r.get("room_title", "") or ""),
"room_title_raw": str(
r.get("room_title_raw", "") or ""
),
"created_ts": float(r.get("created_ts") or 0),
}
)
# 获取当前直播间标题(用于状态文件)
current_title = str(
getattr(self, "current_room_title", "") or ""
)
current_title_raw = str(
getattr(self, "current_room_title_raw", "") or ""
)
# 写入完整的状态数据
data = {
"updated_ts": time.time(),
"reason": "process_reservation",
"room_pos": int(getattr(self, "room_pos", 0) or 0),
"current_room_title": current_title,
"current_room_title_raw": current_title_raw,
"reservations": items,
}
with open(
self._reservations_state_path, "w", encoding="utf-8"
) as f:
json.dump(data, f, ensure_ascii=False, indent=2)
except Exception as exc:
try:
self._log_kv(
"预约",
"写入预约队列状态文件失败",
error=str(exc),
error_type=type(exc).__name__,
)
except Exception:
pass
focus_ref = [float(self.reservation_focus_until_ts or 0.0)]
after_action_ref = [
bool(self.reservation_after_action_pending or False)
]
def _seek_reservation_room(item: dict) -> bool:
try:
return bool(self._seek_reservation_room(item))
except Exception:
return False
# 检查队列是否已满且需要等待
max_reservations = int(
getattr(self, "high_value_fudai_max_reservations", 3) or 3
)
if (
len(self.reservations) >= max_reservations
and not self.queue_full_waiting_at_earliest
):
# 队列已满,回退到最早开奖的预约直播间等待
waiting = (
douyin_reservation_logic.handle_queue_full_wait_at_earliest(
analyser=self,
reservations=self.reservations,
room_pos=int(getattr(self, "room_pos", 0) or 0),
reservation_focus_until_ts_ref=focus_ref,
reservation_back_swipe_delay_s=float(
self.reservation_back_swipe_delay or 0.6
),
swipe_down_back_callback=_swipe_down_once,
seek_reservation_room_callback=_seek_reservation_room,
sort_reservations_callback=_sort_reservations,
write_state_callback=_write_state,
)
)
if waiting:
self.queue_full_waiting_at_earliest = True
if focus_ref:
self.reservation_focus_until_ts = float(focus_ref[0] or 0.0)
# 已回退到最早开奖的预约直播间,本轮结束
# 注意:_reservation_back_direct_attend 标志已在 handle_queue_full_wait_at_earliest 中设置
elapsed = time.time() - start_time
self._log_kv(
"流程",
"run_once_basic完成(预约队列满等待)",
elapsed_seconds=round(elapsed, 2),
)
return
# 如果正在等待开奖,跳过预约回退检查
if getattr(self, "_waiting_for_lottery_result", False):
try:
self._log_kv(
"预约",
"[预约] 正在等待开奖,跳过预约回退检查",
waiting_for_lottery=True,
)
except Exception:
pass
# 跳过预约回退检查,让流程继续执行到阶段诊断后检查开奖结果
# 不在这里 return,让流程继续
# 如果已经在队列满等待状态,且设置了直接参与标志,立即执行参与,不再循环检查
elif self.queue_full_waiting_at_earliest:
reservation_direct_attend = getattr(
self, "_reservation_back_direct_attend", False
)
if reservation_direct_attend:
try:
self._log_kv(
"预约",
"[预约] 队列满等待状态,已设置直接参与标志,立即执行参与(不再循环检查)",
reservation_direct_attend=reservation_direct_attend,
)
except Exception:
pass
# 立即执行参与,不再循环检查预约回退
# 先进行阶段诊断,然后根据阶段执行参与
try:
self.operation.get_screenshot(self.device_id)
except Exception:
pass
from douyin.stage import douyin_stage
result = douyin_stage.diagnose_stage_from_current_screen(self)
if result is None:
stage, _ = (
"IN_LIVE_ROOM",
"阶段诊断返回 None,默认判定为在直播间",
)
else:
stage, _ = result
if stage == "FUDai_DETAIL":
# 在福袋详情页,直接参与
try:
self._log_kv(
"预约",
"[预约] 检测到福袋详情页,立即执行直接参与",
stage=stage,
)
except Exception:
pass
self._reservation_back_direct_attend = False # 清除标志
self._force_attend_after_reservation_back = (
True # 设置强制参与标志
)
self._handle_reservation_direct_attend()
elif stage == "IN_LIVE_ROOM":
# 在直播间,查找福袋并打开详情页
try:
self._log_kv(
"预约",
"[预约] 检测到直播间,查找福袋并打开详情页后执行直接参与",
stage=stage,
)
except Exception:
pass
# 查找福袋并打开详情页
from douyin.core import douyin_flow_control
room_pos_ref = [int(getattr(self, "room_pos", 0) or 0)]
original_max_wait = getattr(
self, "fudai_icon_max_wait_seconds", None
)
try:
wait_seconds_for_find = float(
getattr(
self,
"switch_room_wait_after_stage_diag_seconds",
7.0,
)
or 7.0
)
self.fudai_icon_max_wait_seconds = wait_seconds_for_find
self._log_kv(
"预约",
"[预约] 开始查找福袋并打开详情页(使用 switch_room_wait_after_stage_diag_seconds)",
room_pos=room_pos_ref[0],
max_wait_seconds=wait_seconds_for_find,
)
except Exception:
pass
found = douyin_flow_control.find_and_open_fudai_detail(
self, room_pos_ref
)
# 恢复原始配置
try:
if original_max_wait is not None:
self.fudai_icon_max_wait_seconds = original_max_wait
elif hasattr(self, "fudai_icon_max_wait_seconds"):
delattr(self, "fudai_icon_max_wait_seconds")
except Exception:
pass
if found:
# 成功打开详情页,直接参与
try:
self._log_kv(
"预约",
"[预约] 成功打开详情页,立即执行直接参与",
)
except Exception:
pass
self._reservation_back_direct_attend = False # 清除标志
self._force_attend_after_reservation_back = (
True # 设置强制参与标志
)
self._handle_reservation_direct_attend()
else:
# 查找福袋失败,保留标志,下一轮继续尝试
try:
self._reservation_back_direct_attend = (
True # 恢复标志
)
self._log_kv(
"预约",
"[预约] 预约回退后查找福袋失败,保留直接参与标志,下一轮继续尝试",
flag_restored=True,
)
except Exception:
pass
else:
# 其他阶段,保留标志,下一轮继续尝试
try:
self._reservation_back_direct_attend = True # 恢复标志
self._log_kv(
"预约",
"[预约] 检测到其他阶段,保留直接参与标志,下一轮继续尝试",
stage=stage,
flag_restored=True,
)
except Exception:
pass
elapsed = time.time() - start_time
self._log_kv(
"流程",
"run_once_basic完成(预约回退直接参与)",
elapsed_seconds=round(elapsed, 2),
)
return
# 检查是否所有预约已完成,需要重置到第一个直播间
if self.queue_full_waiting_at_earliest and not self.reservations:
try:
self._log_kv(
"预约",
"[预约] 所有预约已完成,重置到第一个直播间",
)
except Exception:
pass
self.queue_full_waiting_at_earliest = False
self.reservation_focus_until_ts = 0.0
# 回退到第一个直播间:需要回退 room_pos 次
try:
current_pos = int(getattr(self, "room_pos", 0) or 0)
back_times = abs(current_pos)
# 防止无限循环:最大回退次数限制为100
if back_times > 100:
back_times = 100
if back_times > 0:
for i in range(back_times):
_swipe_down_once()
self.operation.delay(0.6)
self.room_pos = 0
if hasattr(self, "_swipe_times"):
self._swipe_times = 0
try:
self._log_kv(
"预约",
"[预约] 已回退到第一个直播间",
back_times=back_times,
)
except Exception:
pass
except Exception:
pass
return
# 单间模式(needswitch=False)下不启用预约回退逻辑
# 因为单间模式不会切换直播间,不需要回退,预约会在当前直播间自动识别和参与
try:
needswitch_cfg = bool(getattr(self, "needswitch", True))
except Exception:
needswitch_cfg = True
# 添加详细的调试日志,确认 needswitch 的值和预约信息
try:
# 输出第一个预约的详细信息
first_reservation_info = {}
if self.reservations and len(self.reservations) > 0:
first_r = self.reservations[0]
try:
ft = float(first_r.get("future_ts") or 0)
from datetime import datetime
import time as time_module
now_ts = time_module.time()
ft_str = (
datetime.fromtimestamp(ft).strftime("%Y-%m-%d %H:%M:%S")
if ft > 0
else "无效"
)
remain_seconds = int(ft - now_ts) if ft > 0 else 0
first_reservation_info = {
"future_ts": int(ft) if ft > 0 else 0,
"future_str": ft_str,
"value": float(first_r.get("prize_value_yuan", 0)),
"pos_seen": int(first_r.get("pos_seen", 0)),
"remain_seconds": remain_seconds,
"current_room_pos": int(
getattr(self, "room_pos", 0) or 0
),
}
except Exception:
pass
self._log_kv(
"预约",
"[预约] run_once_basic:检查预约回退条件",
needswitch_cfg=needswitch_cfg,
reservations_count=(
len(self.reservations) if self.reservations else 0
),
first_reservation=first_reservation_info,
)
except Exception:
pass
if needswitch_cfg:
# 多间模式:需要回退到预约直播间
try:
self._log_kv(
"预约",
"[预约] 多间模式:开始调用 process_reservation_attend_window",
reservations_count=(
len(self.reservations) if self.reservations else 0
),
room_pos=int(getattr(self, "room_pos", 0) or 0),
)
except Exception:
pass
preempted = (
douyin_reservation_logic.process_reservation_attend_window(
analyser=self,
reservations=self.reservations,
room_pos=int(getattr(self, "room_pos", 0) or 0),
reservation_focus_until_ts_ref=focus_ref,
reservation_after_action_pending_ref=after_action_ref,
reservation_back_swipe_delay_s=float(
self.reservation_back_swipe_delay or 0.6
),
swipe_down_back_callback=_swipe_down_once,
seek_reservation_room_callback=_seek_reservation_room,
sort_reservations_callback=_sort_reservations,
write_state_callback=_write_state,
)
)
try:
self._log_kv(
"预约",
"[预约] process_reservation_attend_window 返回结果",
preempted=preempted,
focus_until=(
int(focus_ref[0])
if focus_ref and focus_ref[0] > 0
else 0
),
)
except Exception:
pass
# 同步回写 ref 值
if focus_ref:
self.reservation_focus_until_ts = float(focus_ref[0] or 0.0)
if after_action_ref:
self.reservation_after_action_pending = bool(
after_action_ref[0]
)
if preempted:
# 已触发预约回退,设置标志:下一轮直接参与,跳过详情识别
try:
self._reservation_back_direct_attend = True
self._log_kv(
"预约",
"[预约] 预约回退成功,设置直接参与标志(跳过详情识别)",
flag_set=True,
next_round_will_check="下一轮将检查此标志并直接参与",
)
except Exception:
pass
elapsed = time.time() - start_time
self._log_kv(
"流程",
"run_once_basic完成(预约回退)",
elapsed_seconds=round(elapsed, 2),
)
return
else:
# 单间模式:不需要回退,预约会在当前直播间自动识别和参与
# 只需要清理过期的预约
try:
self._log_kv(
"预约",
"[预约] 单间模式(needswitch=False):不执行预约回退,预约会在当前直播间自动识别和参与",
reservations_count=(
len(self.reservations) if self.reservations else 0
),
)
except Exception:
pass
try:
from douyin.reservation import douyin_reservation_logic
douyin_reservation_logic.cleanup_expired_reservations(
self, self.reservations, _write_state
)
except Exception as exc:
try:
self._log_kv(
"预约",
"[预约] 单间模式下清理过期预约时出错",
error=str(exc),
)
except Exception:
pass
except Exception:
pass
# 0.5. 检查是否需要跳过阶段检测,直接查找福袋(点击参与抽奖后)
skip_stage_diagnosis = getattr(
self, "_skip_stage_diagnosis_and_find_fudai", False
)
if skip_stage_diagnosis:
try:
self._skip_stage_diagnosis_and_find_fudai = False # 清除标志
self._log_kv("流程", "点击参与抽奖后,跳过阶段检测,直接查找福袋")
except Exception:
pass
# 直接查找福袋,跳过阶段检测
self._handle_live_room_has_or_not_fudai()
elapsed = time.time() - start_time
self._log_kv(
"流程",
"run_once_basic完成(跳过阶段检测)",
elapsed_seconds=round(elapsed, 2),
)
return
# 1. 截图 + 阶段诊断
screenshot_start = time.time()
max_screenshot_retries = 3
ok = False
for retry in range(max_screenshot_retries):
ok = self.operation.get_screenshot(self.device_id, use_service=False)
if ok:
break
if retry < max_screenshot_retries - 1:
self._log_kv(
"截图",
f"截图失败,重试中 ({retry + 1}/{max_screenshot_retries})",
retry=retry + 1,
max_retries=max_screenshot_retries,
)
try:
self.operation.delay(1.0) # 等待1秒后重试
except Exception:
time.sleep(1.0)
screenshot_elapsed = time.time() - screenshot_start
if not ok:
elapsed = time.time() - start_time
self._log_kv(
"截图",
"获取截图失败(多次重试后仍失败)",
ok=0,
retries=max_screenshot_retries,
elapsed_seconds=round(elapsed, 2),
screenshot_elapsed_seconds=round(screenshot_elapsed, 2),
suggestion="检查设备连接状态和ADB服务",
)
return
stage, seen = self._diagnose_stage_from_current_screen()
self._last_diag_stage = stage
self._last_diag_seen = seen
self._last_diag_ts = time.time()
# 简洁输出阶段诊断结果(不额外添加分隔符,避免日志噪音)
elapsed = time.time() - start_time
self._log_kv(
"截图",
"截图+阶段诊断",
stage=stage,
seen=seen,
elapsed_seconds=round(elapsed, 2),
screenshot_elapsed_seconds=round(screenshot_elapsed, 2),
)
# 1.5. 检测是否意外返回桌面(不在抖音前台),若是则尝试恢复
try:
top_pkg = ""
try:
top_pkg = self.operation.get_top_package(self.device_id) or ""
self._log_kv("自救", "桌面检测:获取前台包名", top_pkg=top_pkg)
except Exception as exc:
top_pkg = ""
self._log_kv("自救", "桌面检测:获取前台包名失败", error=str(exc))
# 如果获取到包名且不是抖音相关包,说明可能在桌面或其他应用
is_douyin_pkg = top_pkg and (
"aweme" in top_pkg
or "douyin" in top_pkg
or "com.ss.android.ugc" in top_pkg
)
if top_pkg and not is_douyin_pkg:
self._log_kv(
"自救",
"桌面检测:检测到不在抖音前台",
top_pkg=top_pkg,
is_douyin=False,
)
try:
self._log_kv(
"自救",
"发现前台包不在抖音,尝试恢复进入直播间",
top_pkg=top_pkg,
)
# 直接点击桌面图标的预设坐标
try:
self.click(int(self.desktop_icon_x), int(self.desktop_icon_y))
except Exception:
# 退化为默认硬编码位置
self.click(153, 260)
self.operation.delay(2)
# 点击直播与进入直播间的备用坐标
try:
lx = int(self.yanghao_fallback_live_x)
ly = int(self.yanghao_fallback_live_y)
self._log_kv("自救", "点击直播按钮", x=lx, y=ly)
self.click(lx, ly)
self.operation.delay(1.5)
except Exception:
pass
try:
ex = int(self.yanghao_fallback_enter_live_x)
ey = int(self.yanghao_fallback_enter_live_y)
self._log_kv("自救", "点击进入直播间", x=ex, y=ey, 次数=2)
self.click(ex, ey)
self.operation.delay(0.6)
self.click(ex, ey)
self.operation.delay(2.0)
except Exception:
pass
# 自救完成后,不在这里结束本轮流程,而是立即重新执行一次主流程:
# 重新截图 + 阶段诊断 + 查找福袋,使流程与正常进入直播间路径保持一致
try:
self._log_kv(
"流程",
"run_once_basic:自救完成,立即重新执行一次主流程",
)
except Exception:
pass
# 为避免递归过深,仅在当前检测到不在抖音前台的场景下递归一次;
# 自救完成后前台包名应为抖音,下一次 run_once_basic 将不会再次进入自救分支。
try:
self.operation.delay(0.5)
except Exception:
time.sleep(0.5)
self.run_once_basic()
return
except Exception as e:
try:
self._log_kv(
"自救",
"恢复失败",
error=str(e),
error_type=type(e).__name__,
)
except Exception:
pass
except Exception as exc:
# 桌面检测本身出错,记录日志
try:
self._log_kv(
"自救",
"桌面检测异常",
error=str(exc),
error_type=type(exc).__name__,
)
except Exception:
pass
# 2. 诊断后分支(弹窗检测已合并到阶段诊断中)
# 处理弹窗阶段
if stage == "COUPON_POPUP":
# 优惠券弹窗:按返回键关闭
self._log_kv("弹窗处理", "检测到优惠券弹窗,按返回键关闭")
try:
self.operation.click_back(self.device_id)
self.operation.delay(0.5)
self._log_kv("弹窗处理", "已按返回键关闭优惠券弹窗")
except Exception as e:
self._log_kv("弹窗处理", "按返回键关闭优惠券弹窗失败", error=str(e))
elapsed = time.time() - start_time
self._log_kv(
"流程",
"run_once_basic完成(处理优惠券弹窗)",
elapsed_seconds=round(elapsed, 2),
)
return
elif stage == "SHOPPING_REDPACKET_POPUP":
# 购物红包弹窗:点击关闭按钮
self._log_kv("弹窗处理", "检测到购物红包弹窗,点击关闭按钮")
try:
close_x = int(530 * self.resolution_ratio_x // 1080)
close_y = int(1647 * self.resolution_ratio_y // 2400)
self.operation.click(self.device_id, close_x, close_y)
self.operation.delay(0.5)
self._log_kv("弹窗处理", "已点击购物红包关闭按钮", x=close_x, y=close_y)
except Exception as e:
self._log_kv("弹窗处理", "点击购物红包关闭按钮失败", error=str(e))
elapsed = time.time() - start_time
self._log_kv(
"流程",
"run_once_basic完成(处理购物红包弹窗)",
elapsed_seconds=round(elapsed, 2),
)
return
elif stage == "FANSCLUB_JOIN":
# 粉丝团加入阶段:先点击参与按钮,再点击两次预设位置,最后关闭详情页
self._log_kv("粉丝团处理", "检测到粉丝团加入按钮,开始处理")
try:
# 第一步:先点击参与按钮(基于截图优化坐标:OCR区域(306,2030)-(780,2110),区域中心(543, 2070))
attend_x = int(543 * self.resolution_ratio_x // 1080)
attend_y = int(2070 * self.resolution_ratio_y // 2400)
self.operation.click(self.device_id, attend_x, attend_y)
self._log_kv(
"粉丝团处理",
"先点击参与按钮",
x=attend_x,
y=attend_y,
base_x=543,
base_y=2070,
region="(306,2030)-(780,2110)",
)
self.operation.delay(0.5) # 等待参与按钮响应
# 第二步:点击两次预设位置(527, 567)
preset_x = int(527 * self.resolution_ratio_x // 1080)
preset_y = int(567 * self.resolution_ratio_y // 2400)
# 第一次点击预设位置
self.operation.click(self.device_id, preset_x, preset_y)
self._log_kv(
"粉丝团处理",
"第一次点击预设位置",
x=preset_x,
y=preset_y,
base_x=527,
base_y=567,
)
self.operation.delay(0.5) # 短暂等待后立即第二次点击
# 第二次点击预设位置
self.operation.click(self.device_id, preset_x, preset_y)
self._log_kv(
"粉丝团处理",
"第二次点击预设位置",
x=preset_x,
y=preset_y,
base_x=527,
base_y=567,
)
self.operation.delay(1.0) # 等待点击完成
# 第三步:关闭详情页(点击详情页旁边位置)
close_x = int(500 * self.resolution_ratio_x // 1080)
close_y = int(470 * self.resolution_ratio_y // 2400)
self.operation.click(self.device_id, close_x, close_y)
self._log_kv(
"粉丝团处理",
"关闭详情页",
x=close_x,
y=close_y,
base_x=500,
base_y=470,
)
self.operation.delay(1.0) # 等待关闭完成
except Exception as exc:
self._log_kv("粉丝团处理", "处理粉丝团加入失败", error=str(exc))
# 如果启用了自动加入,等待页面加载后再次点击(如果需要)
if getattr(self, "auto_join_fansclub", False):
self._log_kv("粉丝团处理", "已启用自动加入粉丝团,等待页面加载")
self.operation.delay(1.0)
# 再次诊断阶段,看是否还在粉丝团加入页
try:
stage_after, _ = self._diagnose_stage_from_current_screen()
if stage_after == "FANSCLUB_JOIN":
# 仍在粉丝团加入页,再次点击(连续点击两次)
# 使用预设位置坐标(527, 567)
preset_x = int(527 * self.resolution_ratio_x // 1080)
preset_y = int(567 * self.resolution_ratio_y // 2400)
self.operation.click(self.device_id, preset_x, preset_y)
self._log_kv(
"粉丝团处理",
"仍在粉丝团加入页,再次第一次点击",
x=preset_x,
y=preset_y,
base_x=527,
base_y=567,
)
self.operation.delay(0.5)
self.operation.click(self.device_id, preset_x, preset_y)
self._log_kv(
"粉丝团处理",
"仍在粉丝团加入页,再次第二次点击",
x=preset_x,
y=preset_y,
base_x=527,
base_y=567,
)
self.operation.delay(2.0)
# 加入粉丝团成功后,点击 (527, 567) 返回直播间
try:
return_x = int(527 * self.resolution_ratio_x // 1080)
return_y = int(567 * self.resolution_ratio_y // 2400)
self.operation.click(self.device_id, return_x, return_y)
self._log_kv(
"粉丝团处理",
"加入粉丝团成功后,点击返回直播间",
x=return_x,
y=return_y,
base_x=527,
base_y=567,
)
self.operation.delay(1.0) # 等待返回完成
except Exception as exc:
self._log_kv(
"粉丝团处理", "点击返回直播间失败", error=str(exc)
)
except Exception:
pass
else:
self._log_kv(
"粉丝团处理",
"未启用自动加入粉丝团,等待手动确认",
wait_seconds=15,
)
self.operation.delay(15.0)
# 未启用自动加入时,也需要在等待后点击返回
# 加入粉丝团成功后,点击 (527, 567) 返回直播间
try:
return_x = int(527 * self.resolution_ratio_x // 1080)
return_y = int(567 * self.resolution_ratio_y // 2400)
self.operation.click(self.device_id, return_x, return_y)
self._log_kv(
"粉丝团处理",
"加入粉丝团成功后,点击返回直播间",
x=return_x,
y=return_y,
base_x=527,
base_y=567,
)
self.operation.delay(1.0) # 等待返回完成
except Exception as exc:
self._log_kv("粉丝团处理", "点击返回直播间失败", error=str(exc))
# 延迟后返回,让主循环继续处理
self.operation.delay(0.5)
# 如果失败,根据配置决定是否切换直播间
fansclub_fail_action = getattr(self, "fansclub_fail_action", "stay")
if fansclub_fail_action == "switch":
self._log_kv("粉丝团处理", "粉丝团失败策略为switch,切换直播间")
try:
self.swipe_up_to_next_live()
except Exception:
pass
elapsed = time.time() - start_time
self._log_kv(
"流程",
"run_once_basic完成(处理粉丝团)",
elapsed_seconds=round(elapsed, 2),
)
return
elif stage == "FUDai_DETAIL":
# 已经在详情页:检查是否是预约回退后的直接参与
reservation_direct_attend = getattr(
self, "_reservation_back_direct_attend", False
)
try:
self._log_kv(
"预约",
"[预约] 检测到福袋详情页,检查预约回退直接参与标志",
stage=stage,
reservation_direct_attend=reservation_direct_attend,
)
except Exception:
pass
if reservation_direct_attend:
# 先检查预约是否过期
expired = False
try:
if self.reservations and len(self.reservations) > 0:
first_reservation = self.reservations[0]
future_ts = float(
first_reservation.get("future_ts", 0.0) or 0.0
)
if future_ts > 0:
now_ts = time.time()
poll_before = float(
getattr(
self, "high_value_fudai_poll_before_seconds", 10.0
)
or 10.0
)
expired_threshold = future_ts + max(0.0, poll_before)
if now_ts > expired_threshold:
expired = True
from datetime import datetime
future_str = (
datetime.fromtimestamp(future_ts).strftime(
"%Y-%m-%d %H:%M:%S"
)
if future_ts > 0
else "无效"
)
expired_seconds = int(now_ts - expired_threshold)
self._log_kv(
"预约",
"[预约] 预约回退后直接参与:福袋已过期,清除标志",
future_ts=int(future_ts),
future_str=future_str,
expired_seconds=expired_seconds,
)
# 清除相关标志
self._reservation_back_direct_attend = False
self._force_attend_after_reservation_back = False
self.queue_full_waiting_at_earliest = False
# 清理过期预约
from douyin.reservation import douyin_reservation_logic
douyin_reservation_logic.cleanup_expired_reservations(
analyser=self,
reservations=self.reservations,
write_state_callback=lambda: None,
)
except Exception:
pass
if not expired:
# 预约回退后直接参与:使用正常流程,但设置强制参与标志
try:
self._reservation_back_direct_attend = False # 清除标志
# 设置强制参与标志,让 basic_join_decision 跳过倒计时检查
self._force_attend_after_reservation_back = True
self._log_kv(
"预约",
"[预约] 预约回退后直接参与:使用正常流程,设置强制参与标志",
flag_cleared=True,
force_attend=True,
)
except Exception:
pass
# 使用正常流程处理
self._handle_reservation_direct_attend()
else:
# 已过期,执行正常流程
self._handle_in_fudai_detail()
elapsed = time.time() - start_time
self._log_kv(
"流程",
"run_once_basic完成(预约回退直接参与)",
elapsed_seconds=round(elapsed, 2),
)
else:
# 正常流程:读详情并决定是否参与
try:
self._log_kv(
"预约",
"[预约] 预约回退直接参与标志为False,执行正常流程",
reservation_direct_attend=reservation_direct_attend,
)
except Exception:
pass
self._handle_in_fudai_detail()
elapsed = time.time() - start_time
self._log_kv(
"流程",
"run_once_basic完成(处理福袋详情)",
elapsed_seconds=round(elapsed, 2),
)
elif stage in ("IN_LIVE_ROOM", "LIVE_OR_UNKNOWN"):
# 在直播间:检查是否是预约回退后的直接参与
reservation_direct_attend = getattr(
self, "_reservation_back_direct_attend", False
)
try:
self._log_kv(
"预约",
"[预约] 检测到直播间,检查预约回退直接参与标志",
stage=stage,
reservation_direct_attend=reservation_direct_attend,
)
except Exception:
pass
if reservation_direct_attend:
# 先检查预约是否过期
expired = False
try:
if self.reservations and len(self.reservations) > 0:
first_reservation = self.reservations[0]
future_ts = float(
first_reservation.get("future_ts", 0.0) or 0.0
)
if future_ts > 0:
now_ts = time.time()
poll_before = float(
getattr(
self, "high_value_fudai_poll_before_seconds", 10.0
)
or 10.0
)
expired_threshold = future_ts + max(0.0, poll_before)
if now_ts > expired_threshold:
expired = True
from datetime import datetime
future_str = (
datetime.fromtimestamp(future_ts).strftime(
"%Y-%m-%d %H:%M:%S"
)
if future_ts > 0
else "无效"
)
expired_seconds = int(now_ts - expired_threshold)
self._log_kv(
"预约",
"[预约] 预约回退后直接参与:福袋已过期,清除标志",
future_ts=int(future_ts),
future_str=future_str,
expired_seconds=expired_seconds,
)
# 清除相关标志
self._reservation_back_direct_attend = False
self._force_attend_after_reservation_back = False
self.queue_full_waiting_at_earliest = False
# 清理过期预约
from douyin.reservation import douyin_reservation_logic
douyin_reservation_logic.cleanup_expired_reservations(
analyser=self,
reservations=self.reservations,
write_state_callback=lambda: None,
)
except Exception:
pass
if not expired:
# 预约回退后直接参与:查找福袋并打开详情页,然后直接参与
try:
self._reservation_back_direct_attend = False # 清除标志
# 设置强制参与标志,让 basic_join_decision 跳过倒计时检查
self._force_attend_after_reservation_back = True
self._log_kv(
"预约",
"[预约] 预约回退后直接参与:查找福袋并打开详情页,设置强制参与标志",
flag_cleared=True,
force_attend=True,
stage=stage,
)
except Exception:
pass
# 回退后等待页面加载和查找福袋都使用 switch_room_wait_after_stage_diag_seconds 参数
try:
wait_seconds = float(
getattr(self, "switch_room_wait_after_stage_diag_seconds", 7.0)
or 7.0
)
self._log_kv(
"预约",
"[预约] 预约回退后等待页面加载(使用 switch_room_wait_after_stage_diag_seconds)",
wait_seconds=wait_seconds,
)
self.operation.delay(wait_seconds)
except Exception:
try:
time.sleep(7.0)
except Exception:
pass
# 查找福袋并打开详情页(使用 switch_room_wait_after_stage_diag_seconds 作为最大等待时间)
from douyin.core import douyin_flow_control
room_pos_ref = [int(getattr(self, "room_pos", 0) or 0)]
# 临时设置 fudai_icon_max_wait_seconds 为 switch_room_wait_after_stage_diag_seconds
original_max_wait = None
try:
original_max_wait = getattr(
self, "fudai_icon_max_wait_seconds", None
)
wait_seconds_for_find = float(
getattr(self, "switch_room_wait_after_stage_diag_seconds", 7.0)
or 7.0
)
self.fudai_icon_max_wait_seconds = wait_seconds_for_find
self._log_kv(
"预约",
"[预约] 开始查找福袋并打开详情页(使用 switch_room_wait_after_stage_diag_seconds)",
room_pos=room_pos_ref[0],
max_wait_seconds=wait_seconds_for_find,
)
except Exception:
pass
found = douyin_flow_control.find_and_open_fudai_detail(
self, room_pos_ref
)
# 恢复原始配置
try:
if original_max_wait is not None:
self.fudai_icon_max_wait_seconds = original_max_wait
elif hasattr(self, "fudai_icon_max_wait_seconds"):
delattr(self, "fudai_icon_max_wait_seconds")
except Exception:
pass
try:
self._log_kv(
"预约",
"[预约] 查找福袋结果",
found=found,
room_pos=room_pos_ref[0],
)
except Exception:
pass
if found:
# 成功打开详情页,直接参与
try:
self._log_kv(
"预约",
"[预约] 成功打开详情页,开始直接参与",
)
except Exception:
pass
self._handle_reservation_direct_attend()
else:
# 查找福袋失败,保留标志,下一轮继续尝试
try:
self._reservation_back_direct_attend = True # 恢复标志
self._log_kv(
"预约",
"[预约] 预约回退后查找福袋失败,保留直接参与标志,下一轮继续尝试",
flag_restored=True,
)
except Exception:
pass
elapsed = time.time() - start_time
self._log_kv(
"流程",
"run_once_basic完成(预约回退直接参与)",
elapsed_seconds=round(elapsed, 2),
)
return
# 在直播间:如果刚刚切换了直播间,等待福袋加载
just_switched = getattr(self, "_just_switched_room", False)
if just_switched:
try:
self._just_switched_room = False # 清除标志
wait_seconds = float(
getattr(self, "switch_room_wait_after_stage_diag_seconds", 7.0)
or 7.0
)
if wait_seconds > 0:
self._log_kv(
"流程",
"切换直播间后,阶段检测完成,等待福袋加载",
wait_seconds=wait_seconds,
)
self.operation.delay(wait_seconds)
except Exception as e:
try:
self._just_switched_room = False # 确保清除标志
self._log_kv("流程", "等待福袋加载时出错", error=str(e))
except Exception:
pass
# 在直播间:寻找福袋图标并尝试点开
self._handle_live_room_has_or_not_fudai()
elapsed = time.time() - start_time
self._log_kv(
"流程",
"run_once_basic完成(处理直播间)",
elapsed_seconds=round(elapsed, 2),
)
elif stage in ("RECOMMEND_PAGE", "FOLLOW_LIST", "LIVE_LIST"):
# 处理推荐/关注/直播列表页:回到直播间或切换
if stage == "RECOMMEND_PAGE":
# 识别到推荐页面:直接点击进入直播页,然后点击进入直播间
self._log_kv(
"流程",
"检测到推荐页面,点击进入直播页并进入直播间",
stage=stage,
seen=seen,
)
try:
# 直接点击 (718, 169) 进入直播页 - 基于1080x2400分辨率
live_tab_x = int(718 * self.resolution_ratio_x // 1080)
live_tab_y = int(169 * self.resolution_ratio_y // 2400)
self.operation.click(self.device_id, live_tab_x, live_tab_y)
self._log_kv("流程", "点击进入直播页", x=live_tab_x, y=live_tab_y)
self.operation.delay(self.FOLLOW_TAB_CLICK_DELAY)
# 点击进入直播间的位置 (103, 382),连点两次
enter_live_x = int(103 * self.resolution_ratio_x // 1080)
enter_live_y = int(382 * self.resolution_ratio_y // 2400)
self.operation.click(self.device_id, enter_live_x, enter_live_y)
self.operation.delay(self.ENTER_LIVE_CLICK_DELAY)
self.operation.click(self.device_id, enter_live_x, enter_live_y)
self._log_kv(
"流程",
"点击进入直播间位置",
x=enter_live_x,
y=enter_live_y,
次数=2,
)
self.operation.delay(self.ENTER_LIVE_FINAL_DELAY)
except Exception as e:
self._log_kv("流程", "处理推荐页面时出错", error=str(e))
# 如果出错,尝试回退
try:
self.operation.click_back(self.device_id)
self.operation.delay(1.0)
except Exception:
pass
else:
# 其他列表页:使用原有逻辑
douyin_live_room.reflash_zhibo(self)
elif stage == "FUDai_RESULT":
# 抽奖结果弹窗:处理开奖结果(使用OCR识别,不使用阶段诊断)
# 清除等待开奖标志
self._waiting_for_lottery_result = False
self._log_kv("开奖结果", "检测到抽奖结果弹窗,使用OCR识别处理")
# 直接OCR识别并处理
result = self._check_lottery_result_by_ocr()
if result:
self._handle_lottery_result_by_ocr(result)
else:
# OCR识别失败,使用返回键关闭
try:
self.operation.click_back(self.device_id)
self.operation.delay(0.5)
self.swipe_up_to_next_live()
except Exception:
pass
elapsed = time.time() - start_time
self._log_kv(
"流程",
"run_once_basic完成(处理开奖结果)",
elapsed_seconds=round(elapsed, 2),
)
return
elif stage in ("LIVE_CLOSED",):
# 直播结束:下滑/切下一个
self._log_kv("阶段", "当前直播已结束,尝试切换下一个")
self.swipe_up_to_next_live()
elapsed = time.time() - start_time
self._log_kv(
"流程",
"run_once_basic完成(直播结束)",
elapsed_seconds=round(elapsed, 2),
)
else:
# 未识别出特殊阶段:尽量保持原地,交给上层循环
elapsed = time.time() - start_time
self._log_kv(
"阶段",
"未匹配到特定阶段",
stage=stage,
elapsed_seconds=round(elapsed, 2),
)
def _check_lottery_result_by_ocr(self) -> Optional[str]:
"""通过OCR识别开奖结果按钮区域,返回识别到的文本类型。"""
return douyin_helpers.HelperFunctions.check_lottery_result_by_ocr(self)
def _handle_lottery_result_by_ocr(self, result_type: str) -> None:
"""根据OCR识别结果处理开奖结果。
参数:
result_type: "我知道了" 或 "立即领取奖品"
"""
douyin_helpers.HelperFunctions.handle_lottery_result_by_ocr(self, result_type)
def _shot_and_diagnose(
self, tag: str, msg: str, device_id: str, diagnose: bool = True
) -> None:
"""截图并执行阶段诊断(兼容旧版调用方式)。
Args:
tag: 日志标签
msg: 日志消息
device_id: 设备ID
diagnose: 是否执行阶段诊断(默认True)
"""
douyin_helpers.HelperFunctions.shot_and_diagnose(
self, tag, msg, device_id, diagnose
)
# ========== 基础动作封装 ==========
def swipe_up_to_next_live(self) -> None:
"""上滑切换直播间(简单版封装)。
注意:如果处于预约锁定期内(reservation_focus_until_ts > 当前时间),
则不允许上划离开预约直播间,直接返回。
"""
douyin_swipe_handler.SwipeHandler.swipe_up_to_next_live(self)
def _return_to_recommend_and_reenter_live(self) -> None:
"""返回推荐页面并重新进入直播间。
通过多次点击返回键返回到推荐页面,然后点击关注标签并进入直播间。
"""
douyin_swipe_handler.SwipeHandler.return_to_recommend_and_reenter_live(self)
def swipe_down_back_from_live(self) -> None:
"""上划回退到上一个直播间(供预约/无福袋逻辑使用)。"""
douyin_swipe_handler.SwipeHandler.swipe_down_back_from_live(self)
def _maybe_reset_after_swipes(self) -> int:
"""达到切换阈值后,在当前直播间页面回退到第一个直播间。
返回:
重置后的滑动次数(通常为0)
"""
return douyin_swipe_handler.SwipeHandler.maybe_reset_after_swipes(self)
def _seek_reservation_room(self, item: dict[str, Any]) -> bool:
"""根据预约记录里的 pos_seen 与当前 room_pos 进行回退,靠近目标直播间。
说明:
- 使用 high_value_fudai_max_swipe_back 约束最大回退次数;
- 如果启用了回退校验,会进行详细校验(直播间名、福袋详情匹配)。
"""
return douyin_reservation_handler.ReservationHandler.seek_reservation_room(
self, item
)
# ========== 福袋相关 ==========
def _handle_reservation_direct_attend(self) -> None:
"""预约回退后直接参与:直接使用预约记录中的详情,跳过OCR识别。"""
douyin_reservation_handler.ReservationHandler.handle_reservation_direct_attend(
self
)
def _handle_in_fudai_detail(self) -> None:
"""已经在福袋详情页:只跑详情识别 + 是否参与的基础逻辑。"""
start_time = time.time()
# 注意:点击参与抽奖后会自动关闭详情页,下次循环会跳过阶段检测直接查找福袋
# 检查是否是第二次打开福袋详情(已经读取过详情)
# 如果是第二次打开,直接点击参与,不需要验证,使用第一次的倒计时
is_second_open = getattr(self, "_fudai_detail_first_read", False)
if is_second_open:
# 第二次打开:直接点击参与,不进行验证,使用第一次的倒计时
try:
self._log_kv(
"流程",
"_handle_in_fudai_detail:第二次打开,直接点击参与,跳过验证和内容识别",
)
except Exception:
pass
# 获取第一次读取的详情数据
detail = getattr(self, "_last_fudai_detail_tuple", None)
if detail is None or not isinstance(detail, tuple) or len(detail) < 6:
# 如果没有保存的详情数据,需要重新读取(兜底逻辑)
try:
self._log_kv(
"流程",
"_handle_in_fudai_detail:未找到第一次读取的详情数据,重新读取",
)
except Exception:
pass
detail = douyin_fudai_detail.read_fudai_detail_with_retries(
self,
fudai_x=0,
read_once_callback=douyin_fudai_detail.read_fudai_detail_once,
close_detail_callback=douyin_fudai_detail.close_fudai_detail,
ensure_open_callback=douyin_fudai_detail.ensure_fudai_detail_open,
)
# 重新读取后,更新保存的详情数据
if detail and isinstance(detail, tuple) and len(detail) >= 6:
self._last_fudai_detail_tuple = detail
else:
# 使用第一次保存的详情数据,设置当前福袋的倒计时信息
try:
detail: Optional[Tuple[Any, ...]] = getattr(
self, "_last_fudai_detail_tuple", None
)
if (
detail is not None
and isinstance(detail, tuple)
and len(detail) >= 6
):
# 类型检查:detail 已经通过 isinstance 检查,可以安全地索引
detail_values = detail
countdown_tuple: Any = detail_values[5] # type: ignore[index]
if (
isinstance(countdown_tuple, (tuple, list))
and len(countdown_tuple) >= 2
):
future_ts = float(countdown_tuple[1] or 0.0)
if future_ts > 0:
# 设置当前福袋的 future_ts,供 attend_choujiang 使用
self._current_fudai_future_ts = future_ts
self._log_kv(
"参与",
"第二次打开:使用第一次的倒计时信息",
future_ts=int(future_ts),
remain_seconds=int(future_ts - time.time()),
)
except Exception as e:
self._log_kv(
"参与",
"第二次打开:设置倒计时信息时出错",
error=str(e),
)
# 直接调用参与函数,不进行验证
try:
attend_result = douyin_fudai_core.attend_choujiang(self)
if attend_result:
self._log_kv(
"参与",
"第二次打开:直接点击参与成功",
result="参与成功",
)
else:
self._log_kv(
"参与",
"第二次打开:直接点击参与失败",
result="参与失败",
)
# 清除第一次读取标志,下次打开新福袋时重新识别
try:
self._fudai_detail_first_read = False
self._last_fudai_detail_tuple = None
except Exception:
pass
elapsed = time.time() - start_time
self._log_kv(
"流程",
"_handle_in_fudai_detail完成(第二次打开直接参与)",
elapsed_seconds=round(elapsed, 2),
attend_result=attend_result,
)
return
except Exception as e:
self._log_kv("参与", "第二次打开:直接点击参与异常", error=str(e))
# 异常时继续正常流程
else:
# 第一次打开:完整读取详情(包括内容、倒计时、价值)
detail = douyin_fudai_detail.read_fudai_detail_with_retries(
self,
fudai_x=0,
read_once_callback=douyin_fudai_detail.read_fudai_detail_once,
close_detail_callback=douyin_fudai_detail.close_fudai_detail,
ensure_open_callback=douyin_fudai_detail.ensure_fudai_detail_open,
)
# 在第一次打开时立即进行筛选检查,如果不符合要求则直接跳过
# 注意:这里只检查筛选条件,不执行参与操作
if detail and isinstance(detail, tuple) and len(detail) >= 6:
# 先进行数据验证
is_valid = True
try:
is_valid, reason = douyin_fudai_detail.validate_fudai_detail(
detail, self
)
if not is_valid:
try:
self._log_kv(
"流程",
"_handle_in_fudai_detail:第一次打开时数据验证失败,跳过",
validation_reason=reason,
)
except Exception:
pass
# 关闭详情页并返回
try:
douyin_fudai_detail.close_fudai_detail(self)
except Exception:
pass
elapsed = time.time() - start_time
self._log_kv(
"流程",
"_handle_in_fudai_detail完成(数据验证失败)",
elapsed_seconds=round(elapsed, 2),
)
return
except Exception:
pass
# 执行筛选检查(不执行参与操作,只检查是否符合筛选条件)
try:
skip, skip_reason = douyin_fudai_core.should_skip_fudai_by_config(
self, detail
)
if skip:
# 检查是否是高价值福袋,如果是则记录预约或立即参与
try:
# 提取价值信息
prize_value_yuan = 0.0
countdown_tuple = None
if isinstance(detail, tuple) and len(detail) >= 6:
detail_values = detail
prize_value_yuan = float(detail_values[4] or 0.0)
countdown_tuple = detail_values[5]
# 检查是否启用高价值预约
high_value_enabled = bool(
getattr(self, "high_value_fudai_enabled", False)
)
high_value_threshold = float(
getattr(self, "high_value_fudai_threshold_yuan", 500.0)
or 500.0
)
# 检查价值是否达到高价值阈值
is_high_value = (
high_value_enabled
and prize_value_yuan > 0
and prize_value_yuan >= high_value_threshold
and isinstance(countdown_tuple, (tuple, list))
and len(countdown_tuple) >= 2
and float(countdown_tuple[1] or 0.0) > 0.0
)
# 如果被倒计时过滤筛掉(倒计时大于阈值),但价值达到高价值阈值
# 需要检查剩余秒数是否在"预约参与阈值"内,如果在阈值内则立即参与,否则记录预约
if is_high_value and skip_reason.startswith(
"countdown_gt_"
):
# 计算剩余秒数
remain_seconds = None
if (
isinstance(countdown_tuple, (tuple, list))
and len(countdown_tuple) >= 2
):
try:
now = time.time()
cd_start = float(countdown_tuple[0] or 0.0)
cd_end = float(countdown_tuple[1] or 0.0)
if cd_start > 0 and cd_end > cd_start:
remain_seconds = float(cd_end - now)
except Exception:
pass
# 获取"预约参与阈值"配置
join_ahead_seconds = int(
getattr(
self, "high_value_fudai_join_ahead_seconds", 120
)
or 120
)
# 如果剩余秒数在"预约参与阈值"内,立即参与而不是预约
if (
remain_seconds is not None
and remain_seconds <= join_ahead_seconds
):
try:
self._log_kv(
"流程",
"_handle_in_fudai_detail:倒计时大于阈值,但剩余秒数在预约参与阈值内,立即参与",
reason=skip_reason,
value_yuan=prize_value_yuan,
threshold=high_value_threshold,
remain_seconds=int(remain_seconds),
join_ahead_threshold=join_ahead_seconds,
)
except Exception:
pass
# 不关闭详情,继续走立即参与逻辑(保存详情数据,标记为已读取)
skip = False
else:
# 剩余秒数大于"预约参与阈值",记录预约
try:
self._log_kv(
"流程",
"_handle_in_fudai_detail:倒计时大于阈值,但价值达到高价值阈值,记录预约",
reason=skip_reason,
value_yuan=prize_value_yuan,
threshold=high_value_threshold,
remain_seconds=(
int(remain_seconds)
if remain_seconds is not None
else None
),
join_ahead_threshold=join_ahead_seconds,
)
except Exception:
pass
# 调用 basic_join_decision 来记录预约
# 注意:basic_join_decision 内部已经关闭详情并切换直播间,不需要再次关闭
try:
douyin_fudai_core.basic_join_decision(
self, detail
)
except Exception as e:
try:
self._log_kv(
"流程",
"_handle_in_fudai_detail:记录预约时出错",
error=str(e),
)
except Exception:
pass
elapsed = time.time() - start_time
self._log_kv(
"流程",
"_handle_in_fudai_detail完成(记录预约)",
elapsed_seconds=round(elapsed, 2),
)
return
except Exception as e:
# 高价值检查异常,记录日志但继续流程
try:
self._log_kv(
"流程",
"_handle_in_fudai_detail:高价值检查异常",
error=str(e),
)
except Exception:
pass
# 如果不是高价值福袋,或者不是倒计时原因,筛选不通过,直接跳过
if skip:
try:
self._log_kv(
"流程",
"_handle_in_fudai_detail:第一次打开时筛选不通过,直接跳过",
skip_reason=skip_reason,
)
except Exception:
pass
# 关闭详情页
try:
douyin_fudai_detail.close_fudai_detail(self)
except Exception:
pass
# 如果允许切换直播间,筛选不通过直接切换直播间
try:
needswitch = bool(getattr(self, "needswitch", True))
except Exception:
needswitch = True
if needswitch:
try:
self._log_kv(
"流程",
"_handle_in_fudai_detail:筛选不通过后切换直播间",
skip_reason=skip_reason,
)
except Exception:
pass
try:
# 优先使用封装好的上滑切房方法
if hasattr(self, "swipe_up_to_next_live"):
self.swipe_up_to_next_live()
else:
# 兜底:直接调用底层 swipe(基于 1080x2400 基准坐标)
try:
rx = int(
getattr(
self, "resolution_ratio_x", 1080
)
or 1080
)
ry = int(
getattr(
self, "resolution_ratio_y", 2400
)
or 2400
)
except Exception:
rx, ry = 1080, 2400
start_x = 540 * rx // 1080
start_y = 1700 * ry // 2400
end_x = 540 * rx // 1080
end_y = 700 * ry // 2400
# 直接使用 ADB 内部滑动命令
try:
import subprocess
if hasattr(self.operation, "_adb"):
adb_cmd = self.operation._adb()
else:
import os
adb_cmd = (
os.environ.get(
"ADB_EXECUTABLE", "adb"
)
or "adb"
)
if not adb_cmd.startswith(
'"'
) and not adb_cmd.endswith('"'):
adb_cmd = f'"{adb_cmd}"'
cmd = f"{adb_cmd} -s {self.device_id} shell input swipe {start_x} {start_y} {end_x} {end_y} 300"
subprocess.run(
cmd,
shell=True,
timeout=5.0,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
)
except Exception:
# 回退到 operation.swipe
self.operation.swipe(
self.device_id,
start_x,
start_y,
end_x,
end_y,
300,
)
except Exception:
pass
elapsed = time.time() - start_time
self._log_kv(
"流程",
"_handle_in_fudai_detail完成(筛选不通过)",
elapsed_seconds=round(elapsed, 2),
)
return
except Exception as e:
# 筛选检查异常,记录日志但继续流程
try:
self._log_kv(
"流程",
"_handle_in_fudai_detail:筛选检查异常",
error=str(e),
)
except Exception:
pass
# 筛选通过,保存详情数据并标记为已读取
try:
self._last_fudai_detail_tuple = detail
self._fudai_detail_first_read = True
except Exception:
pass
else:
# 详情数据无效,不保存,不标记为已读取
try:
self._log_kv(
"流程",
"_handle_in_fudai_detail:第一次打开时详情数据无效,跳过",
)
except Exception:
pass
return
# 检查是否是优惠券弹窗、观看任务或识别错误:如果检测到,应该直接跳过,不继续处理
try:
last_status = getattr(self, "_last_fudai_detail_status", "")
if last_status == "coupon_popup":
try:
self._log_kv(
"流程",
"_handle_in_fudai_detail:检测到优惠券弹窗,已关闭,跳过后续处理",
)
except Exception:
pass
elapsed = time.time() - start_time
self._log_kv(
"流程",
"_handle_in_fudai_detail完成(优惠券弹窗)",
elapsed_seconds=round(elapsed, 2),
)
return
elif last_status == "watch_task":
try:
self._log_kv(
"流程",
"_handle_in_fudai_detail:检测到'观看X分钟'任务,已在OCR阶段跳过,无需后续处理",
)
except Exception:
pass
elapsed = time.time() - start_time
self._log_kv(
"流程",
"_handle_in_fudai_detail完成(观看任务)",
elapsed_seconds=round(elapsed, 2),
)
return
elif last_status == "validation_failed":
try:
self._log_kv(
"流程",
"_handle_in_fudai_detail:福袋详情数据验证失败,识别出错,跳过后续处理",
)
except Exception:
pass
elapsed = time.time() - start_time
self._log_kv(
"流程",
"_handle_in_fudai_detail完成(验证失败)",
elapsed_seconds=round(elapsed, 2),
)
return
elif last_status == "error":
# 检查是否是任务数量为0的错误
try:
last_extra = getattr(self, "_last_fudai_detail_extra", {})
if (
isinstance(last_extra, dict)
and last_extra.get("reason") == "task_count_zero"
):
# 记录连续失败次数
consecutive_failures = (
getattr(self, "_fudai_detail_consecutive_failures", 0) or 0
)
consecutive_failures += 1
try:
self._fudai_detail_consecutive_failures = (
consecutive_failures
)
except Exception:
pass
# 如果连续失败3次,强制关闭详情页并切换直播间,避免卡死
if consecutive_failures >= 3:
try:
self._log_kv(
"流程",
"_handle_in_fudai_detail:连续3次识别到任务数量为0,强制关闭详情页并切换直播间,避免卡死",
consecutive_failures=consecutive_failures,
)
except Exception:
pass
# 强制关闭详情页
try:
douyin_fudai_detail.close_fudai_detail(self)
self.operation.delay(0.5)
except Exception:
pass
# 切换直播间
try:
needswitch = bool(getattr(self, "needswitch", True))
except Exception:
needswitch = True
if needswitch:
try:
if hasattr(self, "swipe_up_to_next_live"):
self.swipe_up_to_next_live()
else:
rx = int(
getattr(self, "resolution_ratio_x", 1080)
or 1080
)
ry = int(
getattr(self, "resolution_ratio_y", 2400)
or 2400
)
start_x = 540 * rx // 1080
start_y = 1700 * ry // 2400
end_x = 540 * rx // 1080
end_y = 700 * ry // 2400
# 直接使用 ADB 内部滑动命令
try:
import subprocess
if hasattr(self.operation, "_adb"):
adb_cmd = self.operation._adb()
else:
import os
adb_cmd = (
os.environ.get(
"ADB_EXECUTABLE", "adb"
)
or "adb"
)
if not adb_cmd.startswith(
'"'
) and not adb_cmd.endswith('"'):
adb_cmd = f'"{adb_cmd}"'
cmd = f"{adb_cmd} -s {self.device_id} shell input swipe {start_x} {start_y} {end_x} {end_y} 300"
subprocess.run(
cmd,
shell=True,
timeout=5.0,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
)
except Exception:
# 回退到 operation.swipe
self.operation.swipe(
self.device_id,
start_x,
start_y,
end_x,
end_y,
300,
)
self.operation.delay(0.5)
except Exception:
pass
# 重置失败计数
try:
self._fudai_detail_consecutive_failures = 0
except Exception:
pass
elapsed = time.time() - start_time
self._log_kv(
"流程",
"_handle_in_fudai_detail完成(连续失败)",
elapsed_seconds=round(elapsed, 2),
)
return
else:
try:
self._log_kv(
"流程",
"_handle_in_fudai_detail:检测到任务数量为0,跳过后续处理",
consecutive_failures=consecutive_failures,
)
except Exception:
pass
elapsed = time.time() - start_time
self._log_kv(
"流程",
"_handle_in_fudai_detail完成(任务数量为0)",
elapsed_seconds=round(elapsed, 2),
)
return
except Exception:
pass
except Exception:
pass
# 如果成功读取,重置失败计数
try:
self._fudai_detail_consecutive_failures = 0
except Exception:
pass
# 额外验证:使用验证函数检查数据合理性
try:
# 使用已导入的模块,避免重复导入导致作用域问题
if detail is None:
try:
self._log_kv("福袋详情", "详情数据为 None,跳过验证")
except Exception:
pass
else:
is_valid, reason = douyin_fudai_detail.validate_fudai_detail(
detail, self
)
if not is_valid:
try:
self._log_kv(
"流程",
"_handle_in_fudai_detail:福袋详情数据验证失败,识别出错",
validation_reason=reason,
)
except Exception:
pass
douyin_fudai_detail.close_fudai_detail(self)
elapsed = time.time() - start_time
self._log_kv(
"流程",
"_handle_in_fudai_detail完成(验证失败)",
elapsed_seconds=round(elapsed, 2),
)
return
except Exception:
pass
# 兜底检查:如果价值为0且内容为空,也可能是优惠券弹窗或识别错误
try:
if isinstance(detail, tuple) and len(detail) >= 5:
content = str(detail[0] or "")
prize_value_yuan = float(detail[4] or 0.0)
if not content and prize_value_yuan == 0.0:
try:
self._log_kv(
"流程",
"_handle_in_fudai_detail:检测到无效详情(可能是优惠券弹窗或识别错误),跳过后续处理",
content=content,
prize_value_yuan=prize_value_yuan,
)
except Exception:
pass
elapsed = time.time() - start_time
self._log_kv(
"流程",
"_handle_in_fudai_detail完成(无效详情)",
elapsed_seconds=round(elapsed, 2),
)
return
except Exception:
pass
# 记录参与前的状态
attend_before_ts = getattr(self, "_last_successful_attend_ts", 0.0) or 0.0
# 记录当前福袋的 future_ts,供 attend_choujiang 使用
try:
if isinstance(detail, tuple) and len(detail) >= 6:
countdown_tuple = detail[5]
if (
isinstance(countdown_tuple, (tuple, list))
and len(countdown_tuple) >= 2
):
future_ts = float(countdown_tuple[1] or 0.0)
if future_ts > 0:
self._current_fudai_future_ts = future_ts
except Exception:
pass
# 重置详情关闭标志
try:
self._detail_closed_by_attend = False
except Exception:
pass
# 执行参与决策
if detail is None:
try:
self._log_kv("参与", "详情数据为 None,无法执行参与决策")
except Exception:
pass
elapsed = time.time() - start_time
self._log_kv(
"流程",
"_handle_in_fudai_detail完成(详情为None)",
elapsed_seconds=round(elapsed, 2),
)
return
join_result = douyin_fudai_core.basic_join_decision(self, detail)
# 检查是否参与成功:如果 _last_successful_attend_ts 刚刚更新,说明参与成功
attend_after_ts = getattr(self, "_last_successful_attend_ts", 0.0) or 0.0
if join_result and attend_after_ts > attend_before_ts:
# 参与成功,设置等待开奖标志,停止其他行为
try:
# 从 detail 中提取倒计时信息
countdown_tuple = None
remain_seconds = 0
future_timestamp = 0.0
if isinstance(detail, tuple) and len(detail) >= 6:
countdown_tuple = detail[5]
if isinstance(countdown_tuple, tuple) and len(countdown_tuple) >= 2:
# countdown_tuple[0] 是 countdown_start(开始时间戳)
# countdown_tuple[1] 是 countdown_end(结束时间戳/开奖时间戳)
future_timestamp = float(countdown_tuple[1] or 0.0)
# 计算剩余秒数:结束时间戳 - 当前时间
current_time = time.time()
if future_timestamp > current_time:
remain_seconds = int(future_timestamp - current_time)
if remain_seconds > 0:
# 设置等待开奖标志和预期开奖时间
# 直接保存开奖时间戳,等待时直接用 future_timestamp - time.time() 计算剩余秒数
# 提前13秒,修正倒计时误差
self._waiting_for_lottery_result = True
self._lottery_result_expected_ts = (
future_timestamp - 13.0
) # 提前13秒,修正倒计时误差
self._log_kv(
"参与",
"参与成功,设置等待开奖标志,停止其他行为",
remain_seconds=remain_seconds,
future_ts=int(future_timestamp),
)
# 检查是否是预约福袋,如果是,清除锁定期并从预约队列中移除已完成的预约
try:
if getattr(self, "reservation_after_action_pending", False):
# 这是预约福袋,参与成功后需要清除锁定期和移除预约
try:
self._log_kv(
"预约",
"[预约] 参与成功,清除锁定期并移除预约",
future_ts=int(future_timestamp),
)
except Exception:
pass
# 清除锁定期
self.reservation_focus_until_ts = 0.0
self.reservation_after_action_pending = False
# 从预约队列中移除已完成的预约(匹配 future_ts,允许5秒误差)
if hasattr(self, "reservations") and self.reservations:
from douyin.reservation import douyin_reservation_logic
reservations_to_remove = []
for idx, r in enumerate(self.reservations):
try:
r_ft = float(r.get("future_ts") or 0.0)
if (
r_ft > 0
and abs(r_ft - future_timestamp) < 5.0
):
reservations_to_remove.append(idx)
except Exception:
continue
# 从后往前删除,避免索引变化
for idx in reversed(reservations_to_remove):
try:
removed = self.reservations.pop(idx)
try:
self._log_kv(
"预约",
"[预约] 已从队列中移除已完成的预约",
future_ts=int(
removed.get("future_ts", 0)
),
content=str(removed.get("content", ""))[
:50
],
)
except Exception:
pass
except Exception:
pass
# 重新排序预约队列
if self.reservations:
try:
douyin_reservation_logic._sort_reservations_inplace(
self.reservations
)
except Exception:
pass
except Exception as e:
try:
self._log_kv(
"预约",
"[预约] 清除锁定期和移除预约时出错",
error=str(e),
)
except Exception:
pass
# 关闭详情页,返回直播间等待开奖
# 检查 attend_choujiang 是否已经关闭了详情,如果已关闭就不应该再点击返回键
detail_already_closed = getattr(
self, "_detail_closed_by_attend", False
)
if not detail_already_closed:
try:
self.operation.click_back(self.device_id)
self.operation.delay(1.0)
self._log_kv("参与", "已关闭详情页,返回直播间等待开奖")
except Exception:
pass
else:
try:
self._log_kv(
"参与",
"详情页已由 attend_choujiang 关闭,跳过返回键点击",
)
except Exception:
pass
# 清除第一次读取标志,下次打开新福袋时重新识别
try:
self._fudai_detail_first_read = False
self._last_fudai_detail_tuple = None
except Exception:
pass
# 清除第一次读取标志,下次打开新福袋时重新识别
try:
self._fudai_detail_first_read = False
self._last_fudai_detail_tuple = None
except Exception:
pass
# 返回,让主循环只检测开奖结果,不执行其他操作
return
else:
self._log_kv("参与", "参与成功但无法获取倒计时,跳过等待")
except Exception as e:
self._log_kv("参与", "设置等待开奖标志时出错", error=str(e))
def _handle_live_room_has_or_not_fudai(self) -> None:
"""在直播间:寻找福袋图标;有则点开详情,无则交给 flow_control 决定"继续找/切换/养号"."""
start_time = time.time()
# 先检查是否已经在福袋详情页(可能阶段诊断没有正确识别)
# 如果已验证过详情页但任务数为0,说明详情页正在加载,不应该再次查找福袋
try:
already_verified = bool(
getattr(self, "_fudai_detail_verified", False) or False
)
if already_verified:
try:
self._log_kv(
"流程",
"_handle_live_room_has_or_not_fudai:已验证过详情页,直接处理详情,不查找福袋",
)
except Exception:
pass
# 直接调用详情处理逻辑,不查找福袋
self._handle_in_fudai_detail()
elapsed = time.time() - start_time
self._log_kv(
"流程",
"_handle_live_room_has_or_not_fudai完成(已验证详情页)",
elapsed_seconds=round(elapsed, 2),
)
return
except Exception:
pass
# 检查是否在锁定期内,且时间窗口未到,避免重复打开福袋详情
try:
import time as time_module
now_ts = time_module.time()
focus_until = float(getattr(self, "reservation_focus_until_ts", 0.0) or 0.0)
queue_full_waiting = bool(
getattr(self, "queue_full_waiting_at_earliest", False) or False
)
if focus_until > 0 and now_ts < focus_until and queue_full_waiting:
# 在锁定期内,且队列满等待中,检查时间窗口
if self.reservations and len(self.reservations) > 0:
earliest = self.reservations[0]
try:
ft = float(earliest.get("future_ts") or 0.0)
if ft > 0:
join_ahead = float(
getattr(
self, "high_value_fudai_join_ahead_seconds", 120
)
or 120
)
# poll_before = float(
# getattr(self, "poll_before_open_seconds", 10.0) or 10.0
# ) # 未使用,注释掉
time_window_start_ts = ft - join_ahead
# 如果时间窗口未到,避免重复打开福袋详情
if now_ts < time_window_start_ts:
try:
self._log_kv(
"预约",
"[预约] 锁定期内时间窗口未到,避免重复打开福袋详情",
focus_until=int(focus_until),
now_ts=int(now_ts),
time_window_start=int(time_window_start_ts),
remain_seconds=int(
time_window_start_ts - now_ts
),
)
except Exception:
pass
elapsed = time.time() - start_time
self._log_kv(
"流程",
"_handle_live_room_has_or_not_fudai完成(锁定期内时间窗口未到)",
elapsed_seconds=round(elapsed, 2),
)
return
except Exception:
pass
except Exception:
pass
room_pos_ref: List[int] = [0]
opened = douyin_flow_control.find_and_open_fudai_detail(self, room_pos_ref)
if not opened:
# 无福袋,交给 flow_control 的“无福袋处理”逻辑
# 根据配置决定是否允许切换直播间(needswitch=False 时只等待不切房)
try:
needswitch_cfg = bool(getattr(self, "needswitch", True))
except Exception:
needswitch_cfg = True
wait_times_ref = [0]
swipe_times_ref = [0]
reservation_focus_until_ts_ref = [0.0]
reset_to_list_after_reservations_ref = [False]
douyin_flow_control.handle_no_fudai_situation(
self,
x=0,
swipe_times=0,
wait_times_ref=wait_times_ref,
needswitch=needswitch_cfg,
reservation_focus_until_ts=0.0,
reservations=[],
room_pos=room_pos_ref[0],
post_switch_delay_s=1.5,
swipe_up_switch_callback=self.swipe_up_to_next_live,
swipe_down_back_callback=lambda: None,
sort_reservations_callback=lambda: None,
clear_reservations_callback=lambda: None,
write_state_callback=lambda: None,
back_to_list_callback=lambda: None,
into_list_callback=lambda: None,
reservation_focus_until_ts_ref=reservation_focus_until_ts_ref,
reset_to_list_after_reservations_ref=reset_to_list_after_reservations_ref,
swipe_times_ref=swipe_times_ref,
)
elapsed = time.time() - start_time
self._log_kv(
"流程",
"_handle_live_room_has_or_not_fudai完成(无福袋)",
elapsed_seconds=round(elapsed, 2),
)
return
# 成功打开详情:调用同一套详情处理逻辑
self._handle_in_fudai_detail()
elapsed = time.time() - start_time
self._log_kv(
"流程",
"_handle_live_room_has_or_not_fudai完成(成功打开详情)",
elapsed_seconds=round(elapsed, 2),
)