refactor: 重构底层代码，抽离conn，调整消息处理器并创建传输层接口。

feature: 支持mqtt非桥接版本。

main/xiaozhi-server/core/components/adapters/asr_adapter.py

@@ -0,0 +1,76 @@
+from typing import Any, Dict
+from core.components.component_manager import Component, ComponentType, ComponentFactory
+from core.utils import asr
+from core.utils.modules_initialize import initialize_asr
+from config.logger import setup_logging
+
+logger = setup_logging()
+
+
+class ASRAdapter(Component):
+    """ASR组件适配器：将现有ASR组件包装为新的组件接口"""
+    
+    def __init__(self, config: Dict[str, Any]):
+        super().__init__(ComponentType.ASR, config)
+        self._asr_instance = None
+        self._delete_audio = config.get("delete_audio", True)
+    
+    async def _do_initialize(self, context: Any) -> None:
+        """初始化ASR组件"""
+        try:
+            # 获取ASR配置
+            selected_module = self.config.get("selected_module", {}).get("ASR")
+            if not selected_module:
+                raise ValueError("未配置ASR模块")
+            
+            # 创建ASR实例
+            self._asr_instance = initialize_asr(self.config)
+            
+            # 注册资源以便清理
+            self.add_resource(self._asr_instance)
+            
+            # 打开音频通道
+            if hasattr(self._asr_instance, 'open_audio_channels'):
+                await self._asr_instance.open_audio_channels(context)
+            
+            logger.info(f"ASR组件初始化完成: {selected_module}")
+            
+        except Exception as e:
+            logger.error(f"ASR组件初始化失败: {e}")
+            raise
+    
+    async def _do_cleanup(self) -> None:
+        """清理ASR组件"""
+        if self._asr_instance:
+            try:
+                # 关闭ASR实例
+                if hasattr(self._asr_instance, 'close'):
+                    await self._asr_instance.close()
+                
+                # 清理音频文件
+                if hasattr(self._asr_instance, 'cleanup_audio_files'):
+                    self._asr_instance.cleanup_audio_files()
+                
+                logger.info("ASR组件清理完成")
+                
+            except Exception as e:
+                logger.error(f"ASR组件清理失败: {e}")
+            finally:
+                self._asr_instance = None
+    
+    @property
+    def asr_instance(self):
+        """获取ASR实例"""
+        return self._asr_instance
+
+
+class ASRFactory(ComponentFactory):
+    """ASR组件工厂"""
+    
+    def create(self, config: Dict[str, Any]) -> Component:
+        return ASRAdapter(config)
+    
+    def get_component_type(self) -> ComponentType:
+        return ComponentType.ASR
+
+

main/xiaozhi-server/core/components/adapters/intent_adapter.py

@@ -0,0 +1,85 @@
+from typing import Any, Dict
+from core.components.component_manager import Component, ComponentType, ComponentFactory
+from core.utils import intent
+from config.logger import setup_logging
+
+logger = setup_logging()
+
+
+class IntentAdapter(Component):
+    """Intent组件适配器：将现有Intent组件包装为新的组件接口"""
+    
+    def __init__(self, config: Dict[str, Any]):
+        super().__init__(ComponentType.INTENT, config)
+        self._intent_instance = None
+    
+    async def _do_initialize(self, context: Any) -> None:
+        """初始化Intent组件"""
+        try:
+            # 获取Intent配置
+            selected_module = self.config.get("selected_module", {}).get("Intent")
+            if not selected_module:
+                raise ValueError("未配置Intent模块")
+            
+            # 获取Intent类型
+            intent_type = (
+                selected_module
+                if "type" not in self.config["Intent"][selected_module]
+                else self.config["Intent"][selected_module]["type"]
+            )
+            
+            # 创建Intent实例
+            self._intent_instance = intent.create_instance(
+                intent_type,
+                self.config["Intent"][selected_module],
+            )
+            
+            # 注册资源以便清理
+            self.add_resource(self._intent_instance)
+            
+            # 设置LLM（如果需要）
+            if intent_type in ["intent_llm", "function_call"]:
+                llm_component = context.components.get('llm')
+                if llm_component and hasattr(llm_component, 'llm_instance'):
+                    if hasattr(self._intent_instance, 'set_llm'):
+                        self._intent_instance.set_llm(llm_component.llm_instance)
+            
+            logger.info(f"Intent组件初始化完成: {intent_type}")
+            
+        except Exception as e:
+            logger.error(f"Intent组件初始化失败: {e}")
+            raise
+    
+    async def _do_cleanup(self) -> None:
+        """清理Intent组件"""
+        if self._intent_instance:
+            try:
+                # 关闭Intent实例
+                if hasattr(self._intent_instance, 'close'):
+                    await self._intent_instance.close()
+                elif hasattr(self._intent_instance, 'cleanup'):
+                    await self._intent_instance.cleanup()
+                
+                logger.info("Intent组件清理完成")
+                
+            except Exception as e:
+                logger.error(f"Intent组件清理失败: {e}")
+            finally:
+                self._intent_instance = None
+    
+    @property
+    def intent_instance(self):
+        """获取Intent实例"""
+        return self._intent_instance
+
+
+class IntentFactory(ComponentFactory):
+    """Intent组件工厂"""
+    
+    def create(self, config: Dict[str, Any]) -> Component:
+        return IntentAdapter(config)
+    
+    def get_component_type(self) -> ComponentType:
+        return ComponentType.INTENT
+
+

main/xiaozhi-server/core/components/adapters/llm_adapter.py

@@ -0,0 +1,78 @@
+from typing import Any, Dict
+from core.components.component_manager import Component, ComponentType, ComponentFactory
+from core.utils import llm
+from config.logger import setup_logging
+
+logger = setup_logging()
+
+
+class LLMAdapter(Component):
+    """LLM组件适配器：将现有LLM组件包装为新的组件接口"""
+    
+    def __init__(self, config: Dict[str, Any]):
+        super().__init__(ComponentType.LLM, config)
+        self._llm_instance = None
+    
+    async def _do_initialize(self, context: Any) -> None:
+        """初始化LLM组件"""
+        try:
+            # 获取LLM配置
+            selected_module = self.config.get("selected_module", {}).get("LLM")
+            if not selected_module:
+                raise ValueError("未配置LLM模块")
+            
+            # 获取LLM类型
+            llm_type = (
+                selected_module
+                if "type" not in self.config["LLM"][selected_module]
+                else self.config["LLM"][selected_module]["type"]
+            )
+            
+            # 创建LLM实例
+            self._llm_instance = llm.create_instance(
+                llm_type,
+                self.config["LLM"][selected_module],
+            )
+            
+            # 注册资源以便清理
+            self.add_resource(self._llm_instance)
+            
+            logger.info(f"LLM组件初始化完成: {llm_type}")
+            
+        except Exception as e:
+            logger.error(f"LLM组件初始化失败: {e}")
+            raise
+    
+    async def _do_cleanup(self) -> None:
+        """清理LLM组件"""
+        if self._llm_instance:
+            try:
+                # 关闭LLM实例
+                if hasattr(self._llm_instance, 'close'):
+                    await self._llm_instance.close()
+                elif hasattr(self._llm_instance, 'cleanup'):
+                    await self._llm_instance.cleanup()
+                
+                logger.info("LLM组件清理完成")
+                
+            except Exception as e:
+                logger.error(f"LLM组件清理失败: {e}")
+            finally:
+                self._llm_instance = None
+    
+    @property
+    def llm_instance(self):
+        """获取LLM实例"""
+        return self._llm_instance
+
+
+class LLMFactory(ComponentFactory):
+    """LLM组件工厂"""
+    
+    def create(self, config: Dict[str, Any]) -> Component:
+        return LLMAdapter(config)
+    
+    def get_component_type(self) -> ComponentType:
+        return ComponentType.LLM
+
+

main/xiaozhi-server/core/components/adapters/memory_adapter.py

@@ -0,0 +1,96 @@
+from typing import Any, Dict
+from core.components.component_manager import Component, ComponentType, ComponentFactory
+from core.utils import memory
+from config.logger import setup_logging
+
+logger = setup_logging()
+
+
+class MemoryAdapter(Component):
+    """Memory组件适配器：将现有Memory组件包装为新的组件接口"""
+    
+    def __init__(self, config: Dict[str, Any]):
+        super().__init__(ComponentType.MEMORY, config)
+        self._memory_instance = None
+    
+    async def _do_initialize(self, context: Any) -> None:
+        """初始化Memory组件"""
+        try:
+            # 获取Memory配置
+            selected_module = self.config.get("selected_module", {}).get("Memory")
+            if not selected_module:
+                raise ValueError("未配置Memory模块")
+            
+            # 获取Memory类型
+            memory_type = (
+                selected_module
+                if "type" not in self.config["Memory"][selected_module]
+                else self.config["Memory"][selected_module]["type"]
+            )
+            
+            # 创建Memory实例
+            self._memory_instance = memory.create_instance(
+                memory_type,
+                self.config["Memory"][selected_module],
+                self.config.get("summaryMemory", None),
+            )
+            
+            # 注册资源以便清理
+            self.add_resource(self._memory_instance)
+            
+            # 初始化记忆模块
+            if hasattr(self._memory_instance, 'init_memory'):
+                # 需要LLM实例来初始化记忆
+                llm_component = context.components.get('llm')
+                if llm_component and hasattr(llm_component, 'llm_instance'):
+                    self._memory_instance.init_memory(
+                        role_id=context.device_id,
+                        llm=llm_component.llm_instance,
+                        summary_memory=self.config.get("summaryMemory", None),
+                        save_to_file=not self.config.get("read_config_from_api", False),
+                    )
+            
+            logger.info(f"Memory组件初始化完成: {memory_type}")
+            
+        except Exception as e:
+            logger.error(f"Memory组件初始化失败: {e}")
+            raise
+    
+    async def _do_cleanup(self) -> None:
+        """清理Memory组件"""
+        if self._memory_instance:
+            try:
+                # 保存记忆
+                if hasattr(self._memory_instance, 'save_memory'):
+                    # 这里需要获取对话历史，暂时跳过
+                    pass
+                
+                # 关闭Memory实例
+                if hasattr(self._memory_instance, 'close'):
+                    await self._memory_instance.close()
+                elif hasattr(self._memory_instance, 'cleanup'):
+                    await self._memory_instance.cleanup()
+                
+                logger.info("Memory组件清理完成")
+                
+            except Exception as e:
+                logger.error(f"Memory组件清理失败: {e}")
+            finally:
+                self._memory_instance = None
+    
+    @property
+    def memory_instance(self):
+        """获取Memory实例"""
+        return self._memory_instance
+
+
+class MemoryFactory(ComponentFactory):
+    """Memory组件工厂"""
+    
+    def create(self, config: Dict[str, Any]) -> Component:
+        return MemoryAdapter(config)
+    
+    def get_component_type(self) -> ComponentType:
+        return ComponentType.MEMORY
+
+

main/xiaozhi-server/core/components/adapters/tts_adapter.py

@@ -0,0 +1,90 @@
+from typing import Any, Dict
+from core.components.component_manager import Component, ComponentType, ComponentFactory
+from core.utils import tts
+from config.logger import setup_logging
+
+logger = setup_logging()
+
+
+class TTSAdapter(Component):
+    """TTS组件适配器：将现有TTS组件包装为新的组件接口"""
+    
+    def __init__(self, config: Dict[str, Any]):
+        super().__init__(ComponentType.TTS, config)
+        self._tts_instance = None
+        self._delete_audio = config.get("delete_audio", True)
+    
+    async def _do_initialize(self, context: Any) -> None:
+        """初始化TTS组件"""
+        try:
+            # 获取TTS配置
+            selected_module = self.config.get("selected_module", {}).get("TTS")
+            if not selected_module:
+                raise ValueError("未配置TTS模块")
+            
+            # 获取TTS类型
+            tts_type = (
+                selected_module
+                if "type" not in self.config["TTS"][selected_module]
+                else self.config["TTS"][selected_module]["type"]
+            )
+            
+            # 创建TTS实例
+            self._tts_instance = tts.create_instance(
+                tts_type,
+                self.config["TTS"][selected_module],
+                str(self._delete_audio).lower() in ("true", "1", "yes"),
+            )
+            
+            # 注册资源以便清理
+            self.add_resource(self._tts_instance)
+            
+            # 打开音频通道
+            if hasattr(self._tts_instance, 'open_audio_channels'):
+                await self._tts_instance.open_audio_channels(context)
+            
+            # 设置兼容属性（用于向后兼容）
+            if hasattr(context, 'tts'):
+                context.tts = self._tts_instance
+            
+            logger.info(f"TTS组件初始化完成: {tts_type}")
+            
+        except Exception as e:
+            logger.error(f"TTS组件初始化失败: {e}")
+            raise
+    
+    async def _do_cleanup(self) -> None:
+        """清理TTS组件"""
+        if self._tts_instance:
+            try:
+                # 关闭TTS实例
+                if hasattr(self._tts_instance, 'close'):
+                    await self._tts_instance.close()
+                
+                # 清理音频文件
+                if hasattr(self._tts_instance, 'cleanup_audio_files'):
+                    self._tts_instance.cleanup_audio_files()
+                
+                logger.info("TTS组件清理完成")
+                
+            except Exception as e:
+                logger.error(f"TTS组件清理失败: {e}")
+            finally:
+                self._tts_instance = None
+    
+    @property
+    def tts_instance(self):
+        """获取TTS实例"""
+        return self._tts_instance
+
+
+class TTSFactory(ComponentFactory):
+    """TTS组件工厂"""
+    
+    def create(self, config: Dict[str, Any]) -> Component:
+        return TTSAdapter(config)
+    
+    def get_component_type(self) -> ComponentType:
+        return ComponentType.TTS
+
+

main/xiaozhi-server/core/components/adapters/vad_adapter.py

@@ -0,0 +1,78 @@
+from typing import Any, Dict
+from core.components.component_manager import Component, ComponentType, ComponentFactory
+from core.utils import vad
+from config.logger import setup_logging
+
+logger = setup_logging()
+
+
+class VADAdapter(Component):
+    """VAD组件适配器：将现有VAD组件包装为新的组件接口"""
+    
+    def __init__(self, config: Dict[str, Any]):
+        super().__init__(ComponentType.VAD, config)
+        self._vad_instance = None
+    
+    async def _do_initialize(self, context: Any) -> None:
+        """初始化VAD组件"""
+        try:
+            # 获取VAD配置
+            selected_module = self.config.get("selected_module", {}).get("VAD")
+            if not selected_module:
+                raise ValueError("未配置VAD模块")
+            
+            # 获取VAD类型
+            vad_type = (
+                selected_module
+                if "type" not in self.config["VAD"][selected_module]
+                else self.config["VAD"][selected_module]["type"]
+            )
+            
+            # 创建VAD实例
+            self._vad_instance = vad.create_instance(
+                vad_type,
+                self.config["VAD"][selected_module],
+            )
+            
+            # 注册资源以便清理
+            self.add_resource(self._vad_instance)
+            
+            logger.info(f"VAD组件初始化完成: {vad_type}")
+            
+        except Exception as e:
+            logger.error(f"VAD组件初始化失败: {e}")
+            raise
+    
+    async def _do_cleanup(self) -> None:
+        """清理VAD组件"""
+        if self._vad_instance:
+            try:
+                # 关闭VAD实例
+                if hasattr(self._vad_instance, 'close'):
+                    await self._vad_instance.close()
+                elif hasattr(self._vad_instance, 'cleanup'):
+                    await self._vad_instance.cleanup()
+                
+                logger.info("VAD组件清理完成")
+                
+            except Exception as e:
+                logger.error(f"VAD组件清理失败: {e}")
+            finally:
+                self._vad_instance = None
+    
+    @property
+    def vad_instance(self):
+        """获取VAD实例"""
+        return self._vad_instance
+
+
+class VADFactory(ComponentFactory):
+    """VAD组件工厂"""
+    
+    def create(self, config: Dict[str, Any]) -> Component:
+        return VADAdapter(config)
+    
+    def get_component_type(self) -> ComponentType:
+        return ComponentType.VAD
+
+