Extend TTS registry functionality and integrate default system configurations: implement prioritization logic, language preference handling, and fallback mechanisms in `TTSConfigRegistry`; refactor service factory and lifespan management to support dynamic TTS selection and initialization.

src/VoiceDialogue/api/core/__init__.py

@@ -1,13 +1,13 @@
 from .config import AppConfig, TTSConfigInitializer
 from .lifespan import lifespan, LifespanManager
-from .service_factories import ServiceFactories, get_service_definitions
+from .service_factories import ServiceFactories, get_core_voice_service_definitions
 from .service_manager import ServiceManager, ServiceDefinition
 
 __all__ = [
     'ServiceManager',
     'ServiceDefinition',
     'ServiceFactories',
-    'get_service_definitions',
+    'get_core_voice_service_definitions',
     'AppConfig',
     'TTSConfigInitializer',
     'lifespan',

src/VoiceDialogue/api/core/lifespan.py

@@ -6,7 +6,7 @@ from fastapi import FastAPI
 
 from utils import get_system_language
 from .config import TTSConfigInitializer
-from .service_factories import get_service_definitions
+from .service_factories import get_core_voice_service_definitions
 from .service_manager import ServiceManager
 
 logger = logging.getLogger(__name__)
@@ -34,7 +34,7 @@ class LifespanManager:
             self._update_app_state(tts_config)
 
             # 获取服务定义
-            service_definitions = get_service_definitions(system_language)
+            service_definitions = get_core_voice_service_definitions(system_language)
 
             # 启动所有服务
             await self._start_all_services(service_definitions)

src/VoiceDialogue/api/core/service_factories.py

@@ -1,7 +1,7 @@
 from typing import Any
 
 from services.audio import EchoCancellingAudioCapture, TTSAudioGenerator, AudioStreamPlayer
-from services.audio.audio_generator import BaseTTSConfig
+from services.audio.audio_generator import BaseTTSConfig, tts_config_registry
 from services.core.constants import (
     transcribed_text_queue, text_input_queue, audio_output_queue,
     audio_frames_queue, user_voice_queue
@@ -47,12 +47,15 @@ class ServiceFactories:
         )
 
     @staticmethod
-    def create_tts_audio_generator(tts_speaker_config: BaseTTSConfig) -> TTSAudioGenerator:
+    def create_tts_audio_generator(tts_config: BaseTTSConfig = None) -> TTSAudioGenerator:
         """创建TTS音频生成服务"""
+        if tts_config is None:
+            tts_config = tts_config_registry.get_default_config_for_system()
+
         return TTSAudioGenerator(
             text_input_queue=text_input_queue,
             audio_output_queue=audio_output_queue,
-            tts_config=tts_speaker_config
+            tts_config=tts_config
         )
 
     @staticmethod
@@ -60,39 +63,31 @@ class ServiceFactories:
         """创建音频播放服务"""
         return AudioStreamPlayer(audio_playing_queue=audio_output_queue)
 
-    @staticmethod
-    def create_tts_config_loader() -> Any:
-        """创建TTS配置加载器的虚拟服务"""
-
-        class TTSConfigLoader:
-            def __init__(self):
-                self.is_ready = False
-                self._running = False
-
-            def start(self):
-                self._running = True
-                self.is_ready = True
-
-            def stop(self):
-                self._running = False
-
-            def is_alive(self):
-                return self._running
-
-        return TTSConfigLoader()
-
-
-def get_service_definitions(system_language: str) -> list:
-    """获取服务定义配置"""
 
+def get_core_voice_service_definitions(system_language: str, tts_config: BaseTTSConfig = None) -> list:
+    """
+    获取核心语音对话服务定义配置
+    
+    这些服务构成完整的语音对话处理流水线：
+    1. 音频捕获 -> 2. 语音监控 -> 3. 语音识别 -> 4. 文本生成 -> 5. 语音合成 -> 6. 音频播放
+    
+    Args:
+        system_language: 系统默认语言
+        tts_config: TTS配置，如果为None则使用默认配置
+    
+    Returns:
+        list: 服务定义列表
+    """
     return [
-        ServiceDefinition(
-            name="tts_config_loader",
-            factory=ServiceFactories.create_tts_config_loader,
-            required=False,
-            startup_timeout=10
-        ),
-
+        # # 音频捕获服务（最底层服务）
+        # ServiceDefinition(
+        #     name="audio_capture",
+        #     factory=ServiceFactories.create_audio_capture,
+        #     dependencies=[],
+        #     health_check=lambda service: hasattr(service, 'is_ready') and service.is_ready
+        # ),
+
+        # 语音状态监控服务
         ServiceDefinition(
             name="speech_monitor",
             factory=ServiceFactories.create_speech_monitor,
@@ -100,21 +95,45 @@ def get_service_definitions(system_language: str) -> list:
             health_check=lambda service: hasattr(service, 'is_ready') and service.is_ready
         ),
 
+        # ASR语音识别服务
         ServiceDefinition(
             name="asr_worker",
             factory=lambda: ServiceFactories.create_asr_worker(system_language),
             dependencies=["speech_monitor"]
         ),
 
+        # LLM文本生成服务
         ServiceDefinition(
             name="llm_generator",
             factory=ServiceFactories.create_llm_generator,
-            dependencies=["asr_worker"]
+            dependencies=["asr_worker"],
+            startup_timeout=60  # LLM服务启动较慢，增加超时时间
+        ),
+
+        # TTS音频生成服务
+        ServiceDefinition(
+            name="tts_audio_generator",
+            factory=lambda: ServiceFactories.create_tts_audio_generator(tts_config),
+            dependencies=["llm_generator"],
+            startup_timeout=45  # TTS模型加载较慢
         ),
 
+        # 音频播放服务（最终输出服务）
         ServiceDefinition(
             name="audio_player",
             factory=ServiceFactories.create_audio_player,
-            dependencies=["llm_generator"]
+            dependencies=["tts_audio_generator"]
         )
     ]
+
+
+def get_service_health_checkers() -> dict:
+    """获取服务健康检查器映射"""
+    return {
+        "audio_capture": lambda service: hasattr(service, 'is_ready') and service.is_ready,
+        "speech_monitor": lambda service: hasattr(service, 'is_ready') and service.is_ready,
+        "asr_worker": lambda service: hasattr(service, 'is_ready') and service.is_ready,
+        "llm_generator": lambda service: hasattr(service, 'is_ready') and service.is_ready,
+        "tts_audio_generator": lambda service: hasattr(service, 'is_ready') and service.is_ready,
+        "audio_player": lambda service: hasattr(service, 'is_ready') and service.is_ready,
+    }

src/VoiceDialogue/services/audio/audio_generator/models/base.py

@@ -1,3 +1,4 @@
+import logging
 import typing
 from abc import ABC, abstractmethod
 from enum import Enum
@@ -5,13 +6,13 @@ from pathlib import Path
 
 from pydantic import BaseModel
 
+logger = logging.getLogger(__name__)
+
 
 class TTSConfigType(Enum):
     """TTS引擎类型枚举"""
     MOYOYO = 'moyoyo'
-    EDGE_TTS = 'edge_tts'
-    BARK = 'bark'
-    # 可以添加更多TTS引擎
+    KOKORO = 'kokoro'
 
 
 class VoiceModelStatus(Enum):
@@ -57,6 +58,10 @@ class TTSConfigRegistry:
 
     def __init__(self):
         self._configs: dict[str, BaseTTSConfig] = {}
+        self._priority_order = {
+            TTSConfigType.KOKORO: 1,
+            TTSConfigType.MOYOYO: 2,
+        }
 
     def register_config(self, config: BaseTTSConfig):
         """注册TTS配置"""
@@ -77,6 +82,188 @@ class TTSConfigRegistry:
         """获取所有配置"""
         return list(self._configs.values())
 
+    def get_default_config(self, user_language: typing.Optional[typing.Literal['zh', 'en']] = None) -> typing.Optional[
+        BaseTTSConfig]:
+        """
+        获取默认的TTS配置
+        
+        选择逻辑：
+        1. 根据用户语言偏好选择对应的语音类型（中文/非中文）
+        2. 优先选择已下载完整的模型
+        3. 按照预定义的优先级顺序选择TTS类型
+        4. 在同类型中优先选择匹配语言的语音
+        5. 如果都没有完整模型，返回优先级最高且语言匹配的配置
+        
+        Args:
+            user_language: 用户语言偏好，'zh'为中文，'en'为英文，None则自动检测系统语言
+            
+        Returns:
+            BaseTTSConfig: 默认配置，如果没有任何配置则返回None
+        """
+        try:
+            # 如果没有指定用户语言，则自动检测系统语言
+            if user_language is None:
+                try:
+                    from utils.system import get_system_language
+                    user_language = get_system_language()
+                    logger.info(f"自动检测到系统语言: {user_language}")
+                except ImportError:
+                    logger.warning("无法导入系统语言检测模块，使用默认语言 'zh'")
+                    user_language = 'zh'
+                except Exception as e:
+                    logger.warning(f"系统语言检测失败: {e}，使用默认语言 'zh'")
+                    user_language = 'zh'
+
+            all_configs = self.get_all_configs()
+
+            if not all_configs:
+                logger.warning("没有找到任何TTS配置")
+                return None
+
+            # 确定语音偏好：中文系统偏好中文语音，非中文系统偏好非中文语音
+            prefer_chinese_voice = (user_language == 'zh')
+            logger.info(f"用户语言: {user_language}, 语音偏好: {'中文语音' if prefer_chinese_voice else '非中文语音'}")
+
+            # 首先尝试找到已完整下载且语言匹配的配置
+            complete_configs = [config for config in all_configs if config.is_model_complete()]
+
+            if complete_configs:
+                # 按语言偏好和优先级排序已完整的配置
+                selected_config = self._select_config_by_priority_and_language(complete_configs, prefer_chinese_voice)
+                logger.info(
+                    f"选择已完整的默认TTS配置: {selected_config.tts_type.value}:{selected_config.character_name} "
+                    f"(语音类型: {'中文' if selected_config.is_chinese_voice else '非中文'})")
+                return selected_config
+
+            # 如果没有完整的配置，选择优先级最高且语言匹配的配置
+            logger.warning("没有找到完整下载的TTS模型，选择优先级最高且语言匹配的配置")
+            fallback_config = self._select_config_by_priority_and_language(all_configs, prefer_chinese_voice)
+            logger.info(f"使用备选默认TTS配置: {fallback_config.tts_type.value}:{fallback_config.character_name} "
+                        f"(语音类型: {'中文' if fallback_config.is_chinese_voice else '非中文'})")
+            return fallback_config
+
+        except Exception as e:
+            logger.error(f"获取默认TTS配置时发生错误: {e}", exc_info=True)
+            return None
+
+    def _select_config_by_priority_and_language(
+            self,
+            configs: list[BaseTTSConfig],
+            prefer_chinese_voice: bool
+    ) -> BaseTTSConfig:
+        """
+        按优先级和语言偏好选择配置
+        
+        Args:
+            configs: 配置列表
+            prefer_chinese_voice: 是否偏好中文语音
+            
+        Returns:
+            BaseTTSConfig: 选中的配置
+        """
+        if not configs:
+            raise ValueError("配置列表不能为空")
+
+        # 按优先级和语言偏好排序
+        def sort_key(config: BaseTTSConfig):
+            # 优先级权重（数字越小优先级越高）
+            priority = self._priority_order.get(config.tts_type, 999)
+
+            # 语言匹配加分
+            # 如果偏好中文语音且配置是中文语音，或者偏好非中文语音且配置是非中文语音，则加分
+            language_match = (prefer_chinese_voice == config.is_chinese_voice)
+            language_bonus = 0 if language_match else 1
+
+            # 角色名称作为最后的排序条件
+            return (priority, language_bonus, config.character_name)
+
+        sorted_configs = sorted(configs, key=sort_key)
+        return sorted_configs[0]
+
+    def get_recommended_configs(self, max_count: int = 3,
+                                user_language: typing.Optional[typing.Literal['zh', 'en']] = None) -> list[
+        BaseTTSConfig]:
+        """
+        获取推荐的TTS配置列表
+        
+        Args:
+            max_count: 最大返回数量
+            user_language: 用户语言偏好，'zh'为中文，'en'为英文，None则自动检测系统语言
+            
+        Returns:
+            list[BaseTTSConfig]: 推荐配置列表
+        """
+        try:
+            # 如果没有指定用户语言，则自动检测系统语言
+            if user_language is None:
+                try:
+                    from utils.system import get_system_language
+                    user_language = get_system_language()
+                except (ImportError, Exception):
+                    user_language = 'zh'
+
+            all_configs = self.get_all_configs()
+
+            if not all_configs:
+                return []
+
+            prefer_chinese_voice = (user_language == 'zh')
+
+            # 优先返回已完整下载的配置
+            complete_configs = [config for config in all_configs if config.is_model_complete()]
+
+            if complete_configs:
+                sorted_configs = sorted(complete_configs,
+                                        key=lambda c: (self._priority_order.get(c.tts_type, 999),
+                                                       0 if (prefer_chinese_voice == c.is_chinese_voice) else 1,
+                                                       c.character_name))
+                return sorted_configs[:max_count]
+
+            # 如果没有完整配置，返回按优先级和语言偏好排序的配置
+            sorted_configs = sorted(all_configs,
+                                    key=lambda c: (self._priority_order.get(c.tts_type, 999),
+                                                   0 if (prefer_chinese_voice == c.is_chinese_voice) else 1,
+                                                   c.character_name))
+            return sorted_configs[:max_count]
+
+        except Exception as e:
+            logger.error(f"获取推荐TTS配置时发生错误: {e}", exc_info=True)
+            return []
+
+    def get_default_config_for_system(self) -> typing.Optional[BaseTTSConfig]:
+        """
+        为系统首次启动获取默认TTS配置
+        
+        专门用于系统首次启动时的场景，会自动检测系统语言并选择最合适的默认配置
+        
+        Returns:
+            BaseTTSConfig: 系统默认配置
+        """
+        try:
+            from utils.system import get_system_language
+            system_language = get_system_language()
+            logger.info(f"系统首次启动，检测到系统语言: {system_language}")
+
+            default_config = self.get_default_config(user_language=system_language)
+
+            if default_config:
+                logger.info(
+                    f"为系统首次启动选择默认TTS配置: {default_config.tts_type.value}:{default_config.character_name}")
+                # 记录配置详情，方便调试
+                logger.debug(f"默认配置详情: 语音类型={'中文' if default_config.is_chinese_voice else '非中文'}, "
+                             f"模型完整性={'完整' if default_config.is_model_complete() else '未完整'}")
+            else:
+                logger.error("无法为系统首次启动选择默认TTS配置")
+
+            return default_config
+
+        except ImportError:
+            logger.warning("无法导入系统语言检测模块，使用中文作为默认语言")
+            return self.get_default_config(user_language='zh')
+        except Exception as e:
+            logger.error(f"为系统首次启动获取默认配置时发生错误: {e}", exc_info=True)
+            return self.get_default_config(user_language='zh')
+
 
 # 全局TTS注册表实例
 tts_config_registry = TTSConfigRegistry()