@flexem/chat-box 1.0.0

package/miniprogram_dist/utils/audio.js

@@ -0,0 +1,860 @@
+/**
+ * 音频工具模块
+ * 处理语音播放（TTS）和录音
+ */
+
+// 音频播放器实例
+let innerAudioContext = null;
+
+// 当前播放状态
+let currentPlayingId = null;
+let onPlayStateChange = null;
+let currentSegmentPlayer = null;  // 当前正在播放的片段播放器（用于分段播放）
+let currentPlayState = null;      // 当前的 playState 对象引用（用于停止时标记）
+
+// 流式播放队列相关
+let streamingId = null;            // 当前流式播放的消息 ID
+let lastPlayedLength = 0;          // 上次已处理的文本长度
+let isStreamingMode = false;       // 是否处于流式播放模式
+let streamingComplete = false;     // 流式输出是否已完成
+
+// 双队列机制：文本队列 -> TTS合成 -> 音频队列 -> 播放
+let textQueue = [];                // 待合成的文本片段队列
+let audioQueue = [];               // 已合成的音频队列（按顺序）
+let isSynthesizing = false;        // 是否正在合成
+let isPlayingAudio = false;        // 是否正在播放音频
+let currentSegmentIndex = 0;       // 当前处理的片段序号（用于保证顺序）
+
+// 分段配置
+const SEGMENT_MIN_LENGTH = 30;     // 最小分段长度（增大以减少分段数量）
+const SEGMENT_DELIMITERS = ['。', '！', '？', '；', '\n', '.', '!', '?', ';'];  // 分段符号
+
+/**
+ * 初始化音频播放器
+ */
+function initAudioPlayer() {
+  if (innerAudioContext) {
+    return innerAudioContext;
+  }
+
+  innerAudioContext = wx.createInnerAudioContext();
+
+  innerAudioContext.onPlay(() => {
+    console.log('音频开始播放');
+    if (onPlayStateChange) {
+      onPlayStateChange({ playing: true, id: currentPlayingId });
+    }
+  });
+
+  innerAudioContext.onPause(() => {
+    console.log('音频暂停');
+    if (onPlayStateChange) {
+      onPlayStateChange({ playing: false, id: currentPlayingId });
+    }
+  });
+
+  innerAudioContext.onStop(() => {
+    console.log('音频停止');
+    if (onPlayStateChange) {
+      onPlayStateChange({ playing: false, id: currentPlayingId });
+    }
+    currentPlayingId = null;
+  });
+
+  innerAudioContext.onEnded(() => {
+    console.log('音频播放结束');
+    // 流式模式下，播放完当前段后继续播放队列中的下一段
+    if (isStreamingMode && streamingId) {
+      isPlayingAudio = false;
+      playNextAudio();
+    } else {
+      if (onPlayStateChange) {
+        onPlayStateChange({ playing: false, id: currentPlayingId });
+      }
+      currentPlayingId = null;
+    }
+  });
+
+  innerAudioContext.onError((err) => {
+    console.error('音频播放错误', err);
+    if (onPlayStateChange) {
+      onPlayStateChange({ playing: false, id: currentPlayingId, error: err });
+    }
+    currentPlayingId = null;
+    // 流式模式下出错也要继续尝试播放下一段
+    if (isStreamingMode && streamingId) {
+      isPlayingAudio = false;
+      playNextAudio();
+    }
+  });
+
+  return innerAudioContext;
+}
+
+/**
+ * 设置播放状态回调
+ */
+function setPlayStateCallback(callback) {
+  onPlayStateChange = callback;
+}
+
+/**
+ * 播放音频
+ * @param {string} src - 音频地址
+ * @param {string} id - 消息ID（用于标识当前播放的消息）
+ */
+function play(src, id) {
+  const player = initAudioPlayer();
+
+  // 如果正在播放同一个，则暂停
+  if (currentPlayingId === id && !player.paused) {
+    player.pause();
+    return;
+  }
+
+  // 如果正在播放其他的，先停止
+  if (currentPlayingId && currentPlayingId !== id) {
+    player.stop();
+  }
+
+  currentPlayingId = id;
+  player.src = src;
+  player.play();
+}
+
+/**
+ * 暂停播放
+ */
+function pause() {
+  if (innerAudioContext) {
+    innerAudioContext.pause();
+  }
+}
+
+/**
+ * 停止播放
+ */
+function stop() {
+  // 停止分段播放的片段播放器
+  if (currentSegmentPlayer) {
+    try {
+      currentSegmentPlayer.stop();
+      currentSegmentPlayer.destroy();
+    } catch (e) {
+      console.log('[Audio] 停止片段播放器时出错', e);
+    }
+    currentSegmentPlayer = null;
+  }
+
+  // 标记当前的 playState 为已停止
+  if (currentPlayState) {
+    currentPlayState.stopped = true;
+    currentPlayState = null;
+  }
+
+  // 停止全局播放器
+  if (innerAudioContext) {
+    innerAudioContext.stop();
+  }
+  currentPlayingId = null;
+  // 停止流式播放
+  stopStreamingPlay();
+}
+
+/**
+ * 获取当前播放ID
+ */
+function getCurrentPlayingId() {
+  return currentPlayingId;
+}
+
+/**
+ * 是否正在播放
+ */
+function isPlaying() {
+  return innerAudioContext && !innerAudioContext.paused && currentPlayingId;
+}
+
+/**
+ * 销毁播放器
+ */
+function destroy() {
+  if (innerAudioContext) {
+    innerAudioContext.destroy();
+    innerAudioContext = null;
+  }
+  currentPlayingId = null;
+  onPlayStateChange = null;
+  stopStreamingPlay();
+}
+
+/**
+ * 清理文本，移除 Markdown 格式和特殊字符
+ * @param {string} text - 原始文本
+ * @returns {string} - 清理后的纯文本
+ */
+function cleanTextForTTS(text) {
+  if (!text) return '';
+
+  let cleaned = text;
+
+  // 移除代码块（```...```）
+  cleaned = cleaned.replace(/```[\s\S]*?```/g, '');
+
+  // 移除行内代码（`...`）
+  cleaned = cleaned.replace(/`[^`]+`/g, '');
+
+  // 移除链接，保留链接文本 [text](url) -> text
+  cleaned = cleaned.replace(/\[([^\]]+)\]\([^\)]+\)/g, '$1');
+
+  // 移除图片 ![alt](url)
+  cleaned = cleaned.replace(/!\[([^\]]*)\]\([^\)]+\)/g, '');
+
+  // 移除标题标记 (# ## ### 等)
+  cleaned = cleaned.replace(/^#{1,6}\s+/gm, '');
+
+  // 移除粗体和斜体标记 (**text** *text*)
+  cleaned = cleaned.replace(/\*\*([^\*]+)\*\*/g, '$1');
+  cleaned = cleaned.replace(/\*([^\*]+)\*/g, '$1');
+
+  // 移除删除线 (~~text~~)
+  cleaned = cleaned.replace(/~~([^~]+)~~/g, '$1');
+
+  // 移除引用标记 (> )
+  cleaned = cleaned.replace(/^>\s+/gm, '');
+
+  // 移除列表标记 (- * 1. 等)
+  cleaned = cleaned.replace(/^[\s]*[-*+]\s+/gm, '');
+  cleaned = cleaned.replace(/^[\s]*\d+\.\s+/gm, '');
+
+  // 移除水平分隔线
+  cleaned = cleaned.replace(/^[\s]*[-*_]{3,}[\s]*$/gm, '');
+
+  // 移除 HTML 标签
+  cleaned = cleaned.replace(/<[^>]+>/g, '');
+
+  // 移除 URL
+  cleaned = cleaned.replace(/https?:\/\/[^\s]+/g, '');
+
+  // 移除特殊标点符号（TTS 可能不支持）
+  cleaned = cleaned.replace(/[【】「」『』〖〗《》〈〉]/g, '');
+
+  // 将英文括号替换为空格（避免 TTS 问题）
+  cleaned = cleaned.replace(/[()]/g, ' ');
+
+  // 移除多余的空白字符
+  cleaned = cleaned.replace(/\s+/g, ' ');
+
+  // 移除首尾空格
+  cleaned = cleaned.trim();
+
+  return cleaned;
+}
+
+/**
+ * 文字转语音（使用微信同声传译插件）
+ * @param {Object} options - 配置选项
+ * @param {string} options.content - 要转换的文字
+ * @param {Function} options.onSuccess - 成功回调，返回音频地址
+ * @param {Function} options.onError - 失败回调
+ */
+function textToSpeech(options) {
+  const { content, onSuccess, onError } = options;
+
+  console.log('[TTS] 原始内容长度:', content ? content.length : 0);
+
+  if (!content) {
+    if (onError) {
+      onError({ message: '内容为空' });
+    }
+    return;
+  }
+
+  // 清理文本，移除 Markdown 格式
+  const cleanedContent = cleanTextForTTS(content);
+
+  console.log('[TTS] 清理后内容长度:', cleanedContent ? cleanedContent.length : 0);
+  console.log('[TTS] 清理后内容预览:', cleanedContent ? cleanedContent.substring(0, 200) : '');
+
+  if (!cleanedContent) {
+    if (onError) {
+      onError({ message: '内容为空' });
+    }
+    return;
+  }
+
+  try {
+    // 尝试获取微信同声传译插件
+    const plugin = requirePlugin('WechatSI');
+    if (!plugin || !plugin.textToSpeech) {
+      if (onError) {
+        onError({ message: '未配置语音合成插件' });
+      }
+      return;
+    }
+
+    // 限制长度为 150 字符（更保守的限制，避免服务器错误）
+    const finalContent = cleanedContent.substring(0, 150);
+
+    console.log('[TTS] 最终发送内容长度:', finalContent.length);
+    console.log('[TTS] 最终发送内容:', finalContent);
+
+    plugin.textToSpeech({
+      lang: 'zh_CN',
+      content: finalContent,
+      success: (res) => {
+        console.log('[TTS] 成功', res);
+        if (onSuccess) {
+          onSuccess({ src: res.filename });
+        }
+      },
+      fail: (err) => {
+        console.error('[TTS] 失败', err);
+        console.error('[TTS] 失败时的内容:', finalContent);
+        if (onError) {
+          onError(err);
+        }
+      }
+    });
+  } catch (e) {
+    console.error('[TTS] 异常', e);
+    if (onError) {
+      onError({ message: '语音合成失败' });
+    }
+  }
+}
+
+/**
+ * 播放文字（先转语音再播放）
+ * 支持长文本分段连续播放：边播放边合成下一段
+ * @param {string} content - 要播放的文字
+ * @param {string} id - 消息ID
+ * @param {Object} callbacks - 回调函数
+ * @param {Function} callbacks.onSynthesizing - 开始合成回调
+ * @param {Function} callbacks.onSynthesized - 合成完成回调（首段合成完成时触发）
+ * @param {Function} callbacks.onError - 错误回调
+ */
+function playText(content, id, callbacks = {}) {
+  // 如果正在播放同一个，则停止
+  if (currentPlayingId === id && isPlaying()) {
+    stop();
+    return;
+  }
+
+  // 停止之前的播放
+  stop();
+
+  // 清理文本
+  const cleanedContent = cleanTextForTTS(content);
+  if (!cleanedContent) {
+    if (callbacks.onError) {
+      callbacks.onError({ message: '内容为空' });
+    }
+    return;
+  }
+
+  // 分段配置
+  const SEGMENT_LENGTH = 150;
+
+  // 将文本按句子边界分段，每段不超过 SEGMENT_LENGTH 字符
+  const segments = splitTextIntoSegments(cleanedContent, SEGMENT_LENGTH);
+  const totalSegments = segments.length;
+
+  if (totalSegments === 0) {
+    if (callbacks.onError) {
+      callbacks.onError({ message: '内容为空' });
+    }
+    return;
+  }
+
+  console.log('[TTS] 文本分段数:', totalSegments);
+  segments.forEach((seg, idx) => {
+    console.log('[TTS] 片段', idx, '长度:', seg.length);
+  });
+
+  // 通知开始合成
+  if (callbacks.onSynthesizing) {
+    callbacks.onSynthesizing();
+  }
+
+  // 初始化分段播放状态
+  const playState = {
+    id: id,
+    segments: segments,
+    totalSegments: totalSegments,
+    audioSegments: [], // 已合成的音频片段 { index, src }
+    synthesizingIdx: 0, // 下一个要合成的片段索引
+    playingIdx: 0, // 下一个要播放的片段索引
+    isPlayingSegment: false,
+    firstSynthesized: false,
+    stopped: false
+  };
+
+  currentPlayingId = id;
+  currentPlayState = playState;  // 保存引用，用于 stop() 时标记
+
+  // 合成下一个片段
+  function synthesizeNext() {
+    if (playState.stopped || playState.synthesizingIdx >= playState.totalSegments) {
+      return; // 已停止或全部合成完成
+    }
+
+    const idx = playState.synthesizingIdx;
+    const segmentText = playState.segments[idx];
+    playState.synthesizingIdx++;
+
+    console.log('[TTS] 开始合成片段', idx, ':', segmentText.substring(0, 30) + '...');
+
+    textToSpeechRaw({
+      content: segmentText,
+      onSuccess: (res) => {
+        if (playState.stopped) return;
+
+        console.log('[TTS] 片段', idx, '合成成功');
+        playState.audioSegments.push({ index: idx, src: res.src });
+        // 按索引排序
+        playState.audioSegments.sort((a, b) => a.index - b.index);
+
+        // 首段合成完成时通知
+        if (!playState.firstSynthesized && idx === 0) {
+          playState.firstSynthesized = true;
+          if (callbacks.onSynthesized) {
+            callbacks.onSynthesized();
+          }
+        }
+
+        // 继续合成下一段（预加载）
+        if (playState.synthesizingIdx < playState.totalSegments) {
+          synthesizeNext();
+        }
+
+        // 尝试播放
+        tryPlayNext();
+      },
+      onError: (err) => {
+        if (playState.stopped) return;
+
+        console.error('[TTS] 片段', idx, '合成失败', err);
+        // 标记该片段失败，增加 playingIdx 跳过
+        playState.playingIdx++;
+
+        // 继续合成下一段
+        if (playState.synthesizingIdx < playState.totalSegments) {
+          synthesizeNext();
+        }
+        // 尝试播放下一段
+        tryPlayNext();
+      }
+    });
+  }
+
+  // 尝试播放下一个片段
+  function tryPlayNext() {
+    if (playState.stopped) return;
+
+    if (playState.isPlayingSegment) {
+      console.log('[TTS] 正在播放中，跳过');
+      return; // 正在播放中
+    }
+
+    if (currentPlayingId !== playState.id) {
+      console.log('[TTS] ID 不匹配，停止');
+      return; // 已停止或切换到其他消息
+    }
+
+    // 检查是否全部播放完成
+    if (playState.playingIdx >= playState.totalSegments) {
+      console.log('[TTS] 全部播放完成');
+      currentPlayingId = null;
+      if (onPlayStateChange) {
+        onPlayStateChange({ playing: false, id: playState.id });
+      }
+      return;
+    }
+
+    // 查找下一个要播放的片段
+    const audioIdx = playState.audioSegments.findIndex(a => a.index === playState.playingIdx);
+    if (audioIdx === -1) {
+      console.log('[TTS] 片段', playState.playingIdx, '还未合成完成，等待');
+      return;
+    }
+
+    // 取出并播放
+    const audio = playState.audioSegments.splice(audioIdx, 1)[0];
+    playState.isPlayingSegment = true;
+    const currentIdx = playState.playingIdx;
+    playState.playingIdx++;
+
+    console.log('[TTS] 开始播放片段', currentIdx, ', 剩余待播放:', playState.totalSegments - playState.playingIdx);
+
+    // 创建新的播放器实例避免事件冲突
+    const segmentPlayer = wx.createInnerAudioContext();
+    currentSegmentPlayer = segmentPlayer;  // 保存引用，用于 stop() 时停止
+
+    segmentPlayer.onEnded(() => {
+      console.log('[TTS] 片段', currentIdx, '播放结束');
+      playState.isPlayingSegment = false;
+      currentSegmentPlayer = null;  // 清除引用
+      segmentPlayer.destroy();
+      // 继续播放下一段
+      tryPlayNext();
+    });
+
+    segmentPlayer.onError((err) => {
+      console.error('[TTS] 片段', currentIdx, '播放错误', err);
+      playState.isPlayingSegment = false;
+      currentSegmentPlayer = null;  // 清除引用
+      segmentPlayer.destroy();
+      // 继续播放下一段
+      tryPlayNext();
+    });
+
+    segmentPlayer.src = audio.src;
+    segmentPlayer.play();
+  }
+
+  // 开始合成第一段和第二段（预加载）
+  synthesizeNext();
+  if (totalSegments > 1) {
+    synthesizeNext();
+  }
+}
+
+/**
+ * 将文本按句子边界分段
+ * @param {string} text - 清理后的文本
+ * @param {number} maxLength - 每段最大长度
+ * @returns {string[]} - 分段后的文本数组
+ */
+function splitTextIntoSegments(text, maxLength) {
+  const segments = [];
+  let remaining = text;
+
+  // 句子分隔符
+  const delimiters = ['。', '！', '？', '；', '\n', '.', '!', '?', ';'];
+
+  while (remaining.length > 0) {
+    if (remaining.length <= maxLength) {
+      segments.push(remaining);
+      break;
+    }
+
+    // 在 maxLength 范围内查找最后一个分隔符
+    let splitPos = -1;
+    const searchRange = remaining.substring(0, maxLength);
+
+    for (const delimiter of delimiters) {
+      const lastPos = searchRange.lastIndexOf(delimiter);
+      if (lastPos > splitPos) {
+        splitPos = lastPos;
+      }
+    }
+
+    if (splitPos === -1 || splitPos < maxLength / 2) {
+      // 没找到合适的分隔符，或者分隔符太靠前，直接按长度截断
+      splitPos = maxLength - 1;
+    }
+
+    // 包含分隔符
+    segments.push(remaining.substring(0, splitPos + 1).trim());
+    remaining = remaining.substring(splitPos + 1).trim();
+  }
+
+  return segments.filter(s => s.length > 0);
+}
+
+/**
+ * 内部 TTS 函数（不做文本清理，直接调用插件）
+ */
+function textToSpeechRaw(options) {
+  const { content, onSuccess, onError } = options;
+
+  if (!content) {
+    if (onError) {
+      onError({ message: '内容为空' });
+    }
+    return;
+  }
+
+  try {
+    const plugin = requirePlugin('WechatSI');
+    if (!plugin || !plugin.textToSpeech) {
+      if (onError) {
+        onError({ message: '未配置语音合成插件' });
+      }
+      return;
+    }
+
+    plugin.textToSpeech({
+      lang: 'zh_CN',
+      content: content,
+      success: (res) => {
+        if (onSuccess) {
+          onSuccess({ src: res.filename });
+        }
+      },
+      fail: (err) => {
+        if (onError) {
+          onError(err);
+        }
+      }
+    });
+  } catch (e) {
+    if (onError) {
+      onError({ message: '语音合成失败' });
+    }
+  }
+}
+
+// ==================== 流式播放功能 ====================
+
+/**
+ * 开始流式播放
+ * @param {string} id - 消息ID
+ */
+function startStreamingPlay(id) {
+  console.log('开始流式播放, id:', id);
+  // 如果已经在播放其他消息，先停止
+  if (streamingId && streamingId !== id) {
+    stopStreamingPlay();
+  }
+
+  streamingId = id;
+  textQueue = [];
+  audioQueue = [];
+  lastPlayedLength = 0;
+  isStreamingMode = true;
+  isSynthesizing = false;
+  isPlayingAudio = false;
+  streamingComplete = false;
+  currentPlayingId = id;
+  currentSegmentIndex = 0;
+  nextPlayIndex = 0;  // 重置播放索引
+
+  // 通知播放状态
+  if (onPlayStateChange) {
+    onPlayStateChange({ playing: true, id: id });
+  }
+}
+
+/**
+ * 停止流式播放
+ */
+function stopStreamingPlay() {
+  console.log('停止流式播放');
+  textQueue = [];
+  audioQueue = [];
+  streamingId = null;
+  lastPlayedLength = 0;
+  isStreamingMode = false;
+  isSynthesizing = false;
+  isPlayingAudio = false;
+  streamingComplete = false;
+  currentSegmentIndex = 0;
+  nextPlayIndex = 0;  // 重置播放索引
+}
+
+/**
+ * 更新流式内容（推送新的文本内容）
+ * @param {string} id - 消息ID
+ * @param {string} fullContent - 完整的文本内容
+ */
+function updateStreamingContent(id, fullContent) {
+  // 检查是否是当前流式播放的消息
+  if (!isStreamingMode || streamingId !== id) {
+    return;
+  }
+
+  if (!fullContent || fullContent.length <= lastPlayedLength) {
+    return;
+  }
+
+  // 获取新增的内容
+  const newContent = fullContent.substring(lastPlayedLength);
+
+  // 查找分段点
+  let segmentEnd = -1;
+  for (const delimiter of SEGMENT_DELIMITERS) {
+    const idx = newContent.indexOf(delimiter);
+    if (idx !== -1 && idx >= SEGMENT_MIN_LENGTH - 1) {
+      if (segmentEnd === -1 || idx < segmentEnd) {
+        segmentEnd = idx + 1; // 包含分隔符
+      }
+    }
+  }
+
+  // 如果找到分段点，将这一段加入队列
+  if (segmentEnd > 0) {
+    const segment = newContent.substring(0, segmentEnd).trim();
+    if (segment) {
+      const index = currentSegmentIndex++;
+      console.log('添加语音片段到队列, index:', index, 'text:', segment.substring(0, 20) + '...');
+      textQueue.push({ index, text: segment });
+      lastPlayedLength += segmentEnd;
+
+      // 触发合成流水线
+      processSynthesisQueue();
+    }
+  }
+}
+
+/**
+ * 完成流式输出（处理剩余内容）
+ * @param {string} id - 消息ID
+ * @param {string} fullContent - 完整的文本内容
+ */
+function finishStreamingContent(id, fullContent) {
+  console.log('流式输出完成, id:', id);
+
+  // 检查是否是当前流式播放的消息
+  if (!isStreamingMode || streamingId !== id) {
+    return;
+  }
+
+  streamingComplete = true;
+
+  // 将剩余内容加入队列
+  if (fullContent && fullContent.length > lastPlayedLength) {
+    const remaining = fullContent.substring(lastPlayedLength).trim();
+    if (remaining) {
+      const index = currentSegmentIndex++;
+      console.log('添加剩余内容到队列, index:', index);
+      textQueue.push({ index, text: remaining });
+      lastPlayedLength = fullContent.length;
+    }
+  }
+
+  // 触发合成流水线
+  processSynthesisQueue();
+}
+
+/**
+ * 处理合成队列 - 将文本转换为音频
+ * 支持并行合成多个片段，但保证按顺序播放
+ */
+function processSynthesisQueue() {
+  if (!isStreamingMode) {
+    return;
+  }
+
+  // 如果正在合成，等待当前合成完成
+  if (isSynthesizing) {
+    return;
+  }
+
+  // 如果文本队列为空，检查是否需要结束
+  if (textQueue.length === 0) {
+    // 尝试播放已合成的音频
+    playNextAudio();
+    return;
+  }
+
+  // 取出下一个待合成的文本
+  const item = textQueue.shift();
+  isSynthesizing = true;
+
+  console.log('开始合成语音, index:', item.index);
+
+  // 转换为语音
+  textToSpeech({
+    content: item.text,
+    onSuccess: (res) => {
+      if (!isStreamingMode) {
+        return; // 已停止，忽略结果
+      }
+
+      console.log('语音合成完成, index:', item.index);
+      // 将合成结果加入音频队列（保持顺序）
+      audioQueue.push({ index: item.index, src: res.src });
+      // 按 index 排序，确保顺序
+      audioQueue.sort((a, b) => a.index - b.index);
+
+      isSynthesizing = false;
+
+      // 继续合成下一个
+      processSynthesisQueue();
+
+      // 尝试播放
+      playNextAudio();
+    },
+    onError: (err) => {
+      console.error('语音合成失败, index:', item.index, err);
+      isSynthesizing = false;
+
+      // 继续合成下一个
+      processSynthesisQueue();
+    }
+  });
+}
+
+/**
+ * 播放下一个音频
+ * 按顺序从音频队列中取出并播放
+ */
+let nextPlayIndex = 0; // 下一个应该播放的 index
+
+function playNextAudio() {
+  if (!isStreamingMode) {
+    return;
+  }
+
+  // 如果正在播放，等待播放完成
+  if (isPlayingAudio) {
+    return;
+  }
+
+  // 查找下一个应该播放的音频（按 index 顺序）
+  const audioIndex = audioQueue.findIndex(a => a.index === nextPlayIndex);
+
+  if (audioIndex === -1) {
+    // 下一个音频还没合成完成，等待
+    // 检查是否全部完成
+    if (streamingComplete && textQueue.length === 0 && audioQueue.length === 0 && !isSynthesizing) {
+      console.log('流式播放全部完成');
+      const id = streamingId;
+      stopStreamingPlay();
+      if (onPlayStateChange) {
+        onPlayStateChange({ playing: false, id: id });
+      }
+    }
+    return;
+  }
+
+  // 取出音频并播放
+  const audio = audioQueue.splice(audioIndex, 1)[0];
+  isPlayingAudio = true;
+  nextPlayIndex++;
+
+  console.log('播放语音片段, index:', audio.index);
+
+  const player = initAudioPlayer();
+  player.src = audio.src;
+  player.play();
+  // onEnded 回调会设置 isPlayingAudio = false 并调用 playNextAudio
+}
+
+/**
+ * 是否正在流式播放
+ */
+function isStreamingPlaying() {
+  return isStreamingMode && streamingId;
+}
+
+module.exports = {
+  initAudioPlayer,
+  setPlayStateCallback,
+  play,
+  pause,
+  stop,
+  getCurrentPlayingId,
+  isPlaying,
+  destroy,
+  textToSpeech,
+  playText,
+  // 流式播放相关
+  startStreamingPlay,
+  stopStreamingPlay,
+  updateStreamingContent,
+  finishStreamingContent,
+  isStreamingPlaying
+};