tv_show_v1/application/kodi_free_time_thread.py

import threading
import time
from utils.logger_config import logger
from application.kodi_thread import _kodi_thread


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秒
        
        # 启动工作线程
        self._start_worker_thread()
    
    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:
                    # 调用播放方法，循环播放视频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}")
                    
                    # 等待5分钟后再次触发
                    logger.info(f"等待 {self.interval_seconds} 秒后再次触发播放")
                    
                    # 分段等待，以便能够响应停止信号
                    waited = 0
                    while waited < self.interval_seconds and not self._should_stop:
                        sleep_interval = min(1.0, self.interval_seconds - 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空闲时间播放
    
    启动后，线程会每5分钟自动循环播放视频ID 0
    
    Returns:
        bool: 启动是否成功
    """
    if not _kodi_free_time_thread.is_running:
        _kodi_free_time_thread._start_worker_thread()
    return _kodi_free_time_thread.is_running


def stop_kodi_free_time_play() -> bool:
    """
    停止Kodi空闲时间播放
    
    Returns:
        bool: 停止是否成功
    """
    _kodi_free_time_thread.stop()
    return True


def is_free_time_play_running() -> bool:
    """
    检查空闲时间播放线程是否正在运行
    
    Returns:
        bool: 线程是否正在运行
    """
    return _kodi_free_time_thread.is_running