Refactor ASR routes and services: implement instance creation tracking with background task support, enhance `get_supported_languages` with current ASR language, and clean up unused schemas and routes for simplified management.

src/VoiceDialogue/api/core/lifespan.py

@@ -43,7 +43,8 @@ class LifespanManager:
             self._update_app_state({
                 "service_manager": self.service_manager,
                 "system_running": True,
-                "system_language": system_language
+                "system_language": system_language,
+                "current_asr_language": system_language,
             })
 
             # 记录启动信息

src/VoiceDialogue/api/core/service_factories.py

@@ -135,6 +135,15 @@ def get_audio_capture_service_definition() -> ServiceDefinition:
     )
 
 
+def get_asr_worker_service_definition(language: str) -> ServiceDefinition:
+    """获取ASR服务定义"""
+    return ServiceDefinition(
+        name="asr_worker",
+        factory=lambda: ServiceFactories.create_asr_worker(language),
+        dependencies=[]
+    )
+
+
 def get_service_health_checkers() -> dict:
     """获取服务健康检查器映射"""
     return {

src/VoiceDialogue/api/routes/asr_routes.py

@@ -1,19 +1,27 @@
 import logging
 
-from fastapi import APIRouter, HTTPException
+from fastapi import APIRouter, HTTPException, Request, BackgroundTasks
 
 from services.speech.asr import asr_manager
+from ..core.service_factories import get_asr_worker_service_definition
 from ..schemas.asr_schemas import (
-    SupportedLanguagesResponse, ASRInstanceRequest, ASRInstanceResponse, LanguageMappingRequest,
-    LanguageMappingResponse, ASRValidationRequest, ASRValidationResponse, CleanupResponse
+    SupportedLanguagesResponse, ASRInstanceRequest, ASRInstanceResponse
 )
 
 logger = logging.getLogger(__name__)
 router = APIRouter()
 
+_asr_creation_status = {
+    "status": "idle",  # idle, creating, completed, failed
+    "current_language": None,
+    "current_asr_type": None,
+    "instance_id": None,
+    "message": None
+}
+
 
 @router.get("/languages", response_model=SupportedLanguagesResponse, summary="获取支持的识别语言")
-async def get_supported_languages():
+async def get_supported_languages(fastapi_request: Request):
     """
     获取系统支持的语音识别语言列表，包括语言映射和可用引擎
     """
@@ -21,11 +29,13 @@ async def get_supported_languages():
         available_languages = asr_manager.get_available_languages()
         language_mappings = asr_manager._language_to_asr_mapping
         asr_engines = list(asr_manager.list_registered_asr().keys())
+        current_asr_language = getattr(fastapi_request.state, "current_asr_language", None)
 
         return SupportedLanguagesResponse(
             languages=available_languages,
             language_mappings=language_mappings,
-            asr_engines=asr_engines
+            asr_engines=asr_engines,
+            current_asr_language=current_asr_language
         )
     except Exception as e:
         logger.error(f"获取支持语言列表失败: {e}", exc_info=True)
@@ -33,161 +43,118 @@ async def get_supported_languages():
 
 
 @router.post("/instance/create", response_model=ASRInstanceResponse, summary="创建ASR实例")
-async def create_asr_instance(request: ASRInstanceRequest):
+async def create_asr_instance(
+        request: ASRInstanceRequest,
+        fastapi_request: Request,
+        background_tasks: BackgroundTasks
+):
     """
     根据指定语言创建新的ASR实例
     """
     try:
-        # 获取最优的ASR引擎
-        asr_type = asr_manager._get_asr_type_for_language(request.language)
+        # 检查是否正在创建实例
+        if _asr_creation_status["status"] == "creating":
+            return ASRInstanceResponse(
+                success=False,
+                message="ASR实例正在创建中，请稍后重试",
+                language=request.language,
+                asr_type=None,
+                instance_id=None
+            )
+
+        # 检查当前语言是否已存在且相同
+        current_asr_language = getattr(fastapi_request.state, "current_asr_language", None)
+        if current_asr_language and current_asr_language == request.language:
+            asr_type = asr_manager._get_asr_type_for_language(request.language)
+            return ASRInstanceResponse(
+                success=True,
+                message=f"ASR实例已存在，语言: {request.language}",
+                language=request.language,
+                asr_type=asr_type,
+                instance_id=f"{asr_type}_{request.language}"
+            )
+
+        # 更新状态为创建中
+        _asr_creation_status["status"] = "creating"
+        _asr_creation_status["current_language"] = request.language
+        _asr_creation_status["message"] = "正在创建ASR实例..."
+
+        # 在后台执行创建任务
+        background_tasks.add_task(
+            _create_asr_instance_background,
+            request,
+            fastapi_request
+        )
 
-        # 创建实例
-        instance = asr_manager.create_asr(request.language)
+        # 获取预计使用的ASR类型
+        asr_type = asr_manager._get_asr_type_for_language(request.language)
 
         return ASRInstanceResponse(
             success=True,
-            message=f"成功创建ASR实例",
+            message="ASR实例创建请求已提交，正在后台创建...",
             language=request.language,
             asr_type=asr_type,
             instance_id=f"{asr_type}_{request.language}"
         )
+
     except ValueError as e:
         logger.warning(f"创建ASR实例失败 - 参数错误: {e}")
+        _asr_creation_status["status"] = "failed"
+        _asr_creation_status["message"] = str(e)
         raise HTTPException(status_code=400, detail=str(e))
     except Exception as e:
         logger.error(f"创建ASR实例失败: {e}", exc_info=True)
+        _asr_creation_status["status"] = "failed"
+        _asr_creation_status["message"] = str(e)
         raise HTTPException(status_code=500, detail=f"创建ASR实例失败: {str(e)}")
 
 
-@router.post("/instance/get-or-create", response_model=ASRInstanceResponse, summary="获取或创建ASR实例")
-async def get_or_create_asr_instance(request: ASRInstanceRequest):
+async def _create_asr_instance_background(request: ASRInstanceRequest, fastapi_request: Request):
     """
-    获取现有的ASR实例，如果不存在则创建新实例（单例模式）
+    后台创建ASR实例的实际逻辑
     """
     try:
+        logger.info(f"开始创建ASR实例，语言: {request.language}")
+
         # 获取最优的ASR引擎
         asr_type = asr_manager._get_asr_type_for_language(request.language)
+        _asr_creation_status["current_asr_type"] = asr_type
 
-        # 获取或创建实例
-        instance = asr_manager.get_or_create_asr(request.language)
+        # 获取服务管理器
+        service_manager = getattr(fastapi_request.app.state, "service_manager", None)
+        if not service_manager:
+            raise RuntimeError("服务管理器未初始化")
 
-        return ASRInstanceResponse(
-            success=True,
-            message=f"成功获取ASR实例",
-            language=request.language,
-            asr_type=asr_type,
-            instance_id=f"{asr_type}_{request.language}"
-        )
-    except ValueError as e:
-        logger.warning(f"获取ASR实例失败 - 参数错误: {e}")
-        raise HTTPException(status_code=400, detail=str(e))
-    except Exception as e:
-        logger.error(f"获取ASR实例失败: {e}", exc_info=True)
-        raise HTTPException(status_code=500, detail=f"获取ASR实例失败: {str(e)}")
+        # 检查是否需要重新创建服务
+        current_asr_language = getattr(fastapi_request.state, "current_asr_language", None)
+        if current_asr_language and current_asr_language != request.language:
+            logger.info(f"请求语言({request.language})与当前语言({current_asr_language})不同，需要重新创建服务")
 
+            # 停止现有的ASR服务
+            if service_manager.is_service_running("asr_worker"):
+                service_manager._stop_single_service("asr_worker")
+                logger.info("已停止现有ASR服务")
 
-@router.post("/mapping", response_model=LanguageMappingResponse, summary="配置语言映射")
-async def set_language_mapping(request: LanguageMappingRequest):
-    """
-    设置特定语言使用的ASR引擎
-    """
-    try:
-        asr_manager.set_language_mapping(request.language, request.asr_type)
+        # 启动新的ASR服务
+        asr_worker_def = get_asr_worker_service_definition(request.language)
+        success = service_manager.start_service(asr_worker_def)
+        if not success:
+            raise RuntimeError("ASR服务启动失败")
 
-        return LanguageMappingResponse(
-            success=True,
-            message=f"成功设置语言映射: {request.language} -> {request.asr_type}",
-            updated_mapping=asr_manager._language_to_asr_mapping.copy()
-        )
-    except ValueError as e:
-        logger.warning(f"设置语言映射失败 - 参数错误: {e}")
-        raise HTTPException(status_code=400, detail=str(e))
-    except Exception as e:
-        logger.error(f"设置语言映射失败: {e}", exc_info=True)
-        raise HTTPException(status_code=500, detail=f"设置语言映射失败: {str(e)}")
+        # 更新请求状态中的当前语言
+        fastapi_request.state.current_asr_language = request.language
 
+        # 生成实例ID
+        instance_id = f"{asr_type}_{request.language}"
+        _asr_creation_status["instance_id"] = instance_id
 
-@router.post("/validate", response_model=ASRValidationResponse, summary="验证语言支持")
-async def validate_language_support(request: ASRValidationRequest):
-    """
-    验证指定语言是否被支持，并返回相关信息
-    """
-    try:
-        is_supported = asr_manager.validate_language_support(request.language)
-        optimal_asr = asr_manager.get_optimal_asr_for_language(request.language)
-
-        # 查找支持该语言的所有ASR引擎
-        available_asrs = []
-        supported_langs = asr_manager.get_supported_languages()
-        for asr_key, languages in supported_langs.items():
-            if request.language in languages:
-                available_asrs.append(asr_key)
-
-        return ASRValidationResponse(
-            language=request.language,
-            is_supported=is_supported,
-            optimal_asr=optimal_asr,
-            available_asrs=available_asrs
-        )
-    except Exception as e:
-        logger.error(f"验证语言支持失败: {e}", exc_info=True)
-        raise HTTPException(status_code=500, detail=f"验证语言支持失败: {str(e)}")
-
-
-@router.get("/validate/{language}", response_model=ASRValidationResponse, summary="验证语言支持(GET)")
-async def validate_language_support_get(language: str):
-    """
-    通过GET方法验证指定语言是否被支持
-    """
-    request = ASRValidationRequest(language=language)
-    return await validate_language_support(request)
-
-
-@router.delete("/cleanup", response_model=CleanupResponse, summary="清理ASR实例")
-async def cleanup_asr_instances():
-    """
-    清理所有活动的ASR实例，释放资源
-    """
-    try:
-        # 记录清理前的实例数量
-        stats = asr_manager.get_asr_statistics()
-        instances_count = stats['active_instances_count']
-
-        # 执行清理
-        asr_manager.cleanup()
-
-        return CleanupResponse(
-            success=True,
-            message="成功清理所有ASR实例",
-            cleared_instances_count=instances_count
-        )
-    except Exception as e:
-        logger.error(f"清理ASR实例失败: {e}", exc_info=True)
-        raise HTTPException(status_code=500, detail=f"清理ASR实例失败: {str(e)}")
+        # 更新状态为完成
+        _asr_creation_status["status"] = "completed"
+        _asr_creation_status["message"] = f"成功创建ASR实例: {instance_id}"
 
+        logger.info(f"ASR实例创建成功: {instance_id}")
 
-@router.get("/health", summary="ASR服务健康检查")
-async def asr_health_check():
-    """
-    ASR服务的健康检查接口
-    """
-    try:
-        stats = asr_manager.get_asr_statistics()
-
-        # 检查是否有已注册的ASR引擎
-        is_healthy = stats['registered_asr_count'] > 0
-
-        return {
-            "healthy": is_healthy,
-            "message": "ASR服务正常" if is_healthy else "没有可用的ASR引擎",
-            "registered_engines": stats['registered_asr_count'],
-            "active_instances": stats['active_instances_count'],
-            "supported_languages": len(stats['supported_languages'])
-        }
     except Exception as e:
-        logger.error(f"ASR健康检查失败: {e}", exc_info=True)
-        return {
-            "healthy": False,
-            "message": f"ASR服务异常: {str(e)}",
-            "error": str(e)
-        }
+        logger.error(f"后台创建ASR实例失败: {e}", exc_info=True)
+        _asr_creation_status["status"] = "failed"
+        _asr_creation_status["message"] = str(e)

src/VoiceDialogue/api/schemas/asr_schemas.py

@@ -1,30 +1,16 @@
 from typing import Literal, List, Dict, Optional
+
 from pydantic import BaseModel, Field
 
 
 class SupportedLanguagesResponse(BaseModel):
     """支持的语言响应模式"""
     languages: List[str] = Field(..., description="支持的语言列表")
+    current_asr_language: str = Field(..., description="当前使用的ASR语言")
     language_mappings: Dict[str, str] = Field(..., description="语言到ASR引擎的映射")
     asr_engines: List[str] = Field(..., description="可用的ASR引擎列表")
 
 
-class ASRRegistryResponse(BaseModel):
-    """ASR注册表响应模式"""
-    registered_asr_types: List[str] = Field(..., description="已注册的ASR类型")
-    supported_languages_by_engine: Dict[str, List[str]] = Field(..., description="各引擎支持的语言")
-    total_registered_count: int = Field(..., description="注册的ASR引擎总数")
-
-
-class ASRStatisticsResponse(BaseModel):
-    """ASR统计信息响应模式"""
-    registered_asr_count: int = Field(..., description="已注册的ASR引擎数量")
-    active_instances_count: int = Field(..., description="活动实例数量")
-    supported_languages: List[str] = Field(..., description="支持的语言列表")
-    language_mappings: Dict[str, str] = Field(..., description="语言映射配置")
-    registered_asr_types: List[str] = Field(..., description="已注册的ASR类型")
-
-
 class ASRInstanceRequest(BaseModel):
     """ASR实例请求模式"""
     language: Literal["zh", "en", "auto"] = Field(..., description="目标语言")
@@ -37,36 +23,3 @@ class ASRInstanceResponse(BaseModel):
     language: str = Field(..., description="语言类型")
     asr_type: str = Field(..., description="使用的ASR引擎类型")
     instance_id: Optional[str] = Field(None, description="实例标识符")
-
-
-class LanguageMappingRequest(BaseModel):
-    """语言映射配置请求模式"""
-    language: str = Field(..., description="语言代码")
-    asr_type: str = Field(..., description="ASR引擎类型")
-
-
-class LanguageMappingResponse(BaseModel):
-    """语言映射配置响应模式"""
-    success: bool = Field(..., description="操作是否成功")
-    message: str = Field(..., description="操作结果消息")
-    updated_mapping: Dict[str, str] = Field(..., description="更新后的映射关系")
-
-
-class ASRValidationRequest(BaseModel):
-    """ASR语言验证请求模式"""
-    language: str = Field(..., description="要验证的语言代码")
-
-
-class ASRValidationResponse(BaseModel):
-    """ASR语言验证响应模式"""
-    language: str = Field(..., description="语言代码")
-    is_supported: bool = Field(..., description="是否支持")
-    optimal_asr: Optional[str] = Field(None, description="最优ASR引擎")
-    available_asrs: List[str] = Field(default_factory=list, description="支持该语言的ASR引擎列表")
-
-
-class CleanupResponse(BaseModel):
-    """清理操作响应模式"""
-    success: bool = Field(..., description="清理是否成功")
-    message: str = Field(..., description="清理结果消息")
-    cleared_instances_count: int = Field(..., description="清理的实例数量")