tv_show_v1/application/kodi_free_time_thread.py

import threading
import time
from datetime import datetime, time as dtime
from utils.logger_config import logger
from application.kodi_thread import _kodi_thread
from application.kodi_alive_thread import start_kodi_alive_check, stop_kodi_alive_check


class KodiFreeTimeThreadSingleton:
    """Kodi空闲时间播放线程单例类，每5分钟循环播放视频ID 0"""
    
    _instance = None
    _lock = threading.Lock()
    
    def __new__(cls):
        if cls._instance is None:
            with cls._lock:
                if cls._instance is None:
                    cls._instance = super(KodiFreeTimeThreadSingleton, cls).__new__(cls)
        return cls._instance
    
    def __init__(self):
        # 避免重复初始化
        if hasattr(self, '_initialized'):
            return
        
        self._initialized = True
        self.thread = None
        self.is_running = False
        self._should_stop = False
        
        # 配置参数
        self.video_id = 0
        self.interval_seconds = 5 * 60  # 5分钟 = 300秒
        
        # 初始化状态：根据当前时间决定初始状态
        # 这个标志位是最终决定是否播放的开关
        # 它会受两个因素影响：1. 时间段变化自动触发 2. 用户手动控制
        self.is_playing_enabled = self._is_in_time_range()
        
        # 记录上一次的时间段状态，用于检测时间边缘变化
        self.last_in_range = self._is_in_time_range()
        
        # 启动工作线程
        self._start_worker_thread()
    
    def _is_in_time_range(self) -> bool:
        """检查当前时间是否在允许播放的时间段内 (07:30 - 18:00)"""
        now = datetime.now().time()
        start_time = dtime(7, 30)
        end_time = dtime(18, 0)
        
        return start_time <= now <= end_time
    
    def manual_start(self):
        """手动开启播放（临时启动）"""
        self.is_playing_enabled = True
        logger.info("Kodi闲时播放已手动开启")
        # 确保线程运行
        self._start_worker_thread()
        
    def manual_stop(self):
        """手动停止播放（临时停止）"""
        self.is_playing_enabled = False
        logger.info("Kodi闲时播放已手动关闭")

    def _start_worker_thread(self):
        """启动工作线程"""
        if self.thread is None or not self.thread.is_alive():
            self.is_running = True
            self._should_stop = False
            self.thread = threading.Thread(target=self._worker_loop, daemon=True)
            self.thread.start()
            logger.info("Kodi空闲时间播放线程已启动")
    
    def _worker_loop(self):
        """工作线程主循环"""
        logger.info("Kodi空闲时间播放线程开始运行，每5分钟播放视频ID 0（循环模式）")
        
        try:
            # 确保Kodi线程的manager已初始化
            _kodi_thread._initialize_manager()
            
            while self.is_running and not self._should_stop:
                try:
                    # 1. 自动时间控制逻辑：检测时间段边缘变化
                    current_in_range = self._is_in_time_range()
                    
                    if current_in_range != self.last_in_range:
                        if current_in_range:
                            # 刚刚进入时间段，自动开启
                            logger.info("进入闲时播放时间段(07:30)，自动开启播放开关")
                            self.is_playing_enabled = True
                        else:
                            # 刚刚离开时间段，自动关闭
                            logger.info("离开闲时播放时间段(18:00)，自动关闭播放开关")
                            self.is_playing_enabled = False
                        
                        self.last_in_range = current_in_range
                    
                    # 2. 执行播放逻辑（由 is_playing_enabled 决定，无论是由时间自动设置的还是手动设置的）
                    if self.is_playing_enabled:
                        # 调用播放方法，循环播放视频ID 0
                        logger.info(f"触发空闲时间播放：视频ID={self.video_id}，循环模式=True")
                        success = _kodi_thread._play_sync_by_video_id(self.video_id, loop=True)
                        
                        if success:
                            logger.info(f"空闲时间播放启动成功：视频ID={self.video_id}")
                        else:
                            logger.warning(f"空闲时间播放启动失败：视频ID={self.video_id}")
                    else:
                        logger.info("当前播放开关为关闭状态(手动停止或不在时间段内)，跳过本次播放")
                    
                    # 等待5分钟后再次触发
                    wait_time = self.interval_seconds
                    
                    # 如果当前未启用播放，缩短检查间隔以便更快响应时间变化或手动开启
                    if not self.is_playing_enabled:
                        wait_time = 60
                        
                    logger.info(f"等待 {wait_time} 秒后再次触发/检查")
                    
                    # 分段等待，以便能够响应停止信号
                    waited = 0
                    while waited < wait_time and not self._should_stop:
                        # 检查是否有手动状态变更，如果有且需要立即响应（例如从未播放变播放），这里其实是等待下一轮循环
                        # 但由于wait_time不长，或者用户操作会触发manual_start，下一轮自然会执行
                        sleep_interval = min(1.0, wait_time - waited)
                        time.sleep(sleep_interval)
                        waited += sleep_interval
                    
                    if self._should_stop:
                        logger.info("收到停止信号，退出循环")
                        break
                        
                except Exception as e:
                    logger.error(f"工作线程循环异常: {e}")
                    time.sleep(1)
                    
        except Exception as e:
            logger.error(f"工作线程异常: {e}")
        finally:
            self.is_running = False
            logger.info("Kodi空闲时间播放线程结束")
    
    def stop(self):
        """停止线程"""
        self._should_stop = True
        self.is_running = False
        logger.info("停止Kodi空闲时间播放线程")


# 全局单例实例
_kodi_free_time_thread = KodiFreeTimeThreadSingleton()


def start_kodi_free_time_play() -> bool:
    """
    手动开启Kodi空闲时间播放（临时启动）
    
    即使不在时间段内，也会强制开始播放
    
    Returns:
        bool: 操作是否成功
    """
    # 开启闲时播放的同时，关闭心跳检测
    _kodi_free_time_thread.manual_start()
    start_kodi_alive_check()
    return True


def stop_kodi_free_time_play() -> bool:
    """
    手动停止Kodi空闲时间播放（临时停止）
    
    即使在时间段内，也会强制停止播放
    
    Returns:
        bool: 操作是否成功
    """
    # 停止闲时播放的同时，重新开启心跳检测
    _kodi_free_time_thread.manual_stop()
    stop_kodi_alive_check()
    return True


def is_free_time_play_running() -> bool:
    """
    检查空闲时间播放功能当前是否处于启用状态
    
    Returns:
        bool: 当前是否启用
    """
    return _kodi_free_time_thread.is_playing_enabled


def get_free_time_play_status() -> dict:
    """
    获取空闲时间播放的状态
    
    Returns:
        dict: 状态信息
    """
    return {
        "is_running": _kodi_free_time_thread.is_playing_enabled,
        "enabled": _kodi_free_time_thread.is_playing_enabled,
        "is_thread_alive": _kodi_free_time_thread.is_running,
        "video_id": _kodi_free_time_thread.video_id
    }