修改设备端对接

talkingq-url/implementations/aliyun_asr.py

@@ -1,4 +1,5 @@
 import asyncio
+import threading
 from dashscope.audio.asr import TranslationRecognizerChat
 from dashscope.audio.asr import TranscriptionResult
 from dashscope.audio.asr import TranslationRecognizerCallback
@@ -10,15 +11,18 @@ from utils.logger import session_logger
 
 
 class GummyCallback(TranslationRecognizerCallback):
-    def __init__(self, device_id, session_id):
+    def __init__(self, device_id, session_id, asr_instance=None):
         self.device_id = device_id
         self.session_id = session_id
+        self.asr_instance = asr_instance
         self.transcript = ""
         self.transcript_event = asyncio.Event()
         self.received_result = False
         self.error_message = None
         self.is_closed = False
         self.session_end = False
+        self.reconnect_event = threading.Event()
+        self.is_rate_limit_error = False
 
     def on_open(self) -> None:
         session_logger.info(self.device_id, self.session_id, "Gummy ASR连接建立成功")
@@ -50,9 +54,22 @@ class GummyCallback(TranslationRecognizerCallback):
 
     def on_error(self, result) -> None:
         self.error_message = str(result)
-        session_logger.error(
-            self.device_id, self.session_id, f"Gummy ASR错误: {self.error_message}"
-        )
+        error_str = str(result).lower()
+        self.is_rate_limit_error = "throttling" in error_str or "rate limit" in error_str
+        
+        if self.is_rate_limit_error:
+            session_logger.warning(
+                self.device_id,
+                self.session_id,
+                f"Gummy ASR限流错误，触发重连信号: {self.error_message}"
+            )
+            self.reconnect_event.set()
+            if self.asr_instance:
+                self.asr_instance.need_reconnect = True
+        else:
+            session_logger.error(
+                self.device_id, self.session_id, f"Gummy ASR错误: {self.error_message}"
+            )
         self.transcript_event.set()
 
     def on_close(self) -> None:
@@ -74,8 +91,11 @@ class AliyunASR(ASR, BaseService):
         self.audio_buffer = bytearray()
         self.translator = None
         self.callback = None
-        self.buffer_size = 3200  # 约100ms的音频，按16000采样率计算
-        self.max_end_silence = 2000  # 设为2000ms，允许更长的停顿
+        self.buffer_size = 3200
+        self.max_end_silence = 2000
+        self.max_retries = 3
+        self.retry_delay = 1.0
+        self.need_reconnect = False
 
     async def connect(self):
         try:
@@ -86,9 +106,8 @@ class AliyunASR(ASR, BaseService):
                 return
 
             self.transcript = ""
-            self.audio_buffer = bytearray()
 
-            self.callback = GummyCallback(self.device_id, self.session_id)
+            self.callback = GummyCallback(self.device_id, self.session_id, self)
 
             self.translator = TranslationRecognizerChat(
                 model="gummy-chat-v1",
@@ -106,20 +125,79 @@ class AliyunASR(ASR, BaseService):
             self.translator.start()
             self.callback.transcript_event.clear()
             self.connected = True
+            self.need_reconnect = False
 
         except Exception as e:
             session_logger.error(
                 self.device_id, self.session_id, f"建立Gummy ASR连接失败: {str(e)}"
             )
-            self.connected = False
-            if self.translator:
-                try:
-                    self.translator.stop()
-                except:
-                    pass
-                self.translator = None
+            await self._cleanup_connection()
+
+    async def _cleanup_connection(self):
+        if self.translator:
+            try:
+                self.translator.stop()
+            except:
+                pass
+            self.translator = None
+        self.callback = None
+        self.connected = False
+
+    async def _handle_reconnect(self):
+        if not self.need_reconnect:
+            return True
+        
+        session_logger.warning(
+            self.device_id,
+            self.session_id,
+            "检测到限流错误，准备重连..."
+        )
+        
+        await self._cleanup_connection()
+        
+        current_delay = self.retry_delay
+        for attempt in range(self.max_retries):
+            session_logger.info(
+                self.device_id,
+                self.session_id,
+                f"重连尝试 {attempt + 1}/{self.max_retries}，等待{current_delay}秒"
+            )
+            await asyncio.sleep(current_delay)
+            
+            try:
+                await self.connect()
+                if self.connected:
+                    session_logger.info(
+                        self.device_id,
+                        self.session_id,
+                        "重连成功"
+                    )
+                    return True
+            except Exception as e:
+                session_logger.error(
+                    self.device_id,
+                    self.session_id,
+                    f"重连失败: {str(e)}"
+                )
+            
+            current_delay *= 2
+            self.retry_delay = current_delay
+        
+        session_logger.error(
+            self.device_id,
+            self.session_id,
+            "重连失败，已达到最大重试次数"
+        )
+        self.need_reconnect = False
+        return False
 
     async def send_audio(self, audio_data: bytes):
+        if self.need_reconnect:
+            reconnected = await self._handle_reconnect()
+            if not reconnected:
+                session_logger.error(self.device_id, self.session_id, "Gummy ASR重连失败，无法发送音频")
+                return
+
         if not self.connected or not self.translator:
             session_logger.error(self.device_id, self.session_id, "Gummy ASR连接未建立")
             return
@@ -128,6 +206,19 @@ class AliyunASR(ASR, BaseService):
             self.audio_buffer.extend(audio_data)
 
             while len(self.audio_buffer) >= self.buffer_size:
+                if self.need_reconnect:
+                    session_logger.info(
+                        self.device_id,
+                        self.session_id,
+                        "检测到限流错误，暂停发送音频，准备重连"
+                    )
+                    reconnected = await self._handle_reconnect()
+                    if not reconnected:
+                        return
+                    if not self.connected or not self.translator:
+                        return
+                    continue
+
                 chunk = bytes(self.audio_buffer[: self.buffer_size])
                 self.audio_buffer = self.audio_buffer[self.buffer_size :]