xiaoyuan-assistant 0.5.45

package/src/voice/localReceivedTTS.js

@@ -0,0 +1,106 @@
+const DB_NAME = 'xiaoyuan-tts-cache'
+const DB_VERSION = 1
+const STORE_NAME = 'audio'
+const CACHE_PREFIX = 'received-command::'
+
+const BUILTIN_RECEIVED_COMMAND_AUDIO = Object.freeze({
+  'zh-CN-XiaoyiNeural': new URL('../assets/received-command.zh-CN-XiaoyiNeural.mp3', import.meta.url).href,
+  'zh-CN-XiaoxiaoNeural': new URL('../assets/received-command.zh-CN-XiaoxiaoNeural.mp3', import.meta.url).href
+})
+
+function isBrowser() {
+  return typeof window !== 'undefined' && typeof indexedDB !== 'undefined'
+}
+
+function openDB() {
+  if (!isBrowser()) return Promise.reject(new Error('IndexedDB 不可用'))
+  return new Promise((resolve, reject) => {
+    const request = indexedDB.open(DB_NAME, DB_VERSION)
+    request.onupgradeneeded = () => {
+      const db = request.result
+      if (!db.objectStoreNames.contains(STORE_NAME)) {
+        db.createObjectStore(STORE_NAME, { keyPath: 'key' })
+      }
+    }
+    request.onsuccess = () => resolve(request.result)
+    request.onerror = () => reject(request.error || new Error('打开 TTS 本地缓存失败'))
+  })
+}
+
+function normalizeVoice(voice = '') {
+  return String(voice || '').trim() || 'default'
+}
+
+function makeKey(voice = '') {
+  return `${CACHE_PREFIX}${normalizeVoice(voice)}`
+}
+
+export async function getReceivedCommandAudio(voice) {
+  if (!isBrowser()) return null
+
+  const normalized = normalizeVoice(voice)
+  const builtinUrl = BUILTIN_RECEIVED_COMMAND_AUDIO[normalized]
+  if (builtinUrl) {
+    try {
+      const response = await fetch(builtinUrl, { cache: 'force-cache' })
+      if (response.ok) {
+        const blob = await response.blob()
+        if (blob.size) return blob
+      }
+    } catch (_) {
+      // 内置资源读取失败时继续走 IndexedDB / 首次网络 TTS 逻辑。
+    }
+  }
+
+  const db = await openDB()
+  return await new Promise((resolve, reject) => {
+    const tx = db.transaction(STORE_NAME, 'readonly')
+    const request = tx.objectStore(STORE_NAME).get(makeKey(voice))
+    request.onsuccess = () => resolve(request.result?.blob || null)
+    request.onerror = () => reject(request.error || new Error('读取 TTS 本地缓存失败'))
+    tx.oncomplete = () => db.close()
+    tx.onerror = () => {
+      try { db.close() } catch (_) {}
+      reject(tx.error || new Error('读取 TTS 本地缓存失败'))
+    }
+  })
+}
+
+export async function saveReceivedCommandAudio(voice, blob) {
+  if (!isBrowser() || !(blob instanceof Blob) || !blob.size) return false
+  const db = await openDB()
+  return await new Promise((resolve, reject) => {
+    const tx = db.transaction(STORE_NAME, 'readwrite')
+    tx.objectStore(STORE_NAME).put({
+      key: makeKey(voice),
+      voice: normalizeVoice(voice),
+      blob,
+      updatedAt: Date.now()
+    })
+    tx.oncomplete = () => {
+      db.close()
+      resolve(true)
+    }
+    tx.onerror = () => {
+      try { db.close() } catch (_) {}
+      reject(tx.error || new Error('保存 TTS 本地缓存失败'))
+    }
+  })
+}
+
+export async function removeReceivedCommandAudio(voice) {
+  if (!isBrowser()) return false
+  const db = await openDB()
+  return await new Promise((resolve, reject) => {
+    const tx = db.transaction(STORE_NAME, 'readwrite')
+    tx.objectStore(STORE_NAME).delete(makeKey(voice))
+    tx.oncomplete = () => {
+      db.close()
+      resolve(true)
+    }
+    tx.onerror = () => {
+      try { db.close() } catch (_) {}
+      reject(tx.error || new Error('删除 TTS 本地缓存失败'))
+    }
+  })
+}

package/src/voice/speech.js

@@ -0,0 +1,329 @@
+export class SpeechService {
+  constructor(options = {}) {
+    this.lang = options.lang || 'zh-CN'
+    this.voice = options.voice || null
+    this.rate = options.rate ?? 1
+    this.pitch = options.pitch ?? 1
+    this.volume = options.volume ?? 1
+    this.recognition = null
+    this.listening = false
+    this.onInterim = options.onInterim || (() => {})
+    this.onFinal = options.onFinal || (() => {})
+    this.onError = options.onError || (() => {})
+    this.onEnd = options.onEnd || (() => {})
+    this.ttsProvider = options.ttsProvider || null
+  }
+
+  async unlockTTS() {
+    return await this.ttsProvider?.unlock?.()
+  }
+
+  supported() {
+    return typeof window !== 'undefined' && !!(
+      window.SpeechRecognition ||
+      window.webkitSpeechRecognition
+    )
+  }
+
+  async requestMicrophonePermission() {
+    if (typeof navigator === 'undefined' || !navigator.mediaDevices?.getUserMedia) {
+      return true
+    }
+
+    const stream = await navigator.mediaDevices.getUserMedia({ audio: true })
+    for (const track of stream.getTracks()) track.stop()
+    return true
+  }
+
+  createRecognition({ continuous = false } = {}) {
+    const Recognition = window.SpeechRecognition || window.webkitSpeechRecognition
+    if (!Recognition) throw new Error('当前浏览器不支持 Web Speech Recognition')
+
+    const recognition = new Recognition()
+    recognition.lang = this.lang
+    recognition.continuous = continuous
+    recognition.interimResults = true
+    recognition.maxAlternatives = 1
+    return recognition
+  }
+
+  async speakReceivedPromptAsync() {
+    // 固定“收到指令，请您稍等”只负责异步播放，不参与主业务流程门禁。
+    // 即使本地语音正在加载/播放，manager.run 也可以立即继续执行。
+    if (this.ttsProvider?.speakReceivedCommandAsync) {
+      try {
+        return await this.ttsProvider.speakReceivedCommandAsync()
+      } catch (error) {
+        this.onError?.(error?.message || '固定前置提示音播放失败')
+        return false
+      }
+    }
+
+    // 兼容没有专用 provider 的版本：异步触发，不等待。
+    void this.speak('收到指令，请您稍等。', { providerOnly: false }).catch(() => {})
+    return true
+  }
+
+  async speak(text, options = {}) {
+    const providerOnly = options?.providerOnly === true
+    const waitForEnd = options?.waitForEnd === true
+    const value = String(text || '').trim()
+    if (!value) return false
+
+    const isReceivedPrompt = value.replace(/[，。！？、,.!?\s]/g, '') === '收到指令请您稍等'
+
+    if (this.ttsProvider?.speak) {
+      try {
+        const spoken = await this.ttsProvider.speak(value, { waitForEnd })
+        if (spoken !== false) return true
+        // 前置提示音本地资源失败时，直接进入浏览器 TTS 兜底；
+        // 不允许再回退到网络 TTS，确保“收到指令”不会因为网络波动丢播。
+        if (isReceivedPrompt) return await this.speakWithBrowser(value, { waitForEnd })
+        if (providerOnly) {
+          throw new Error('第三方 TTS 未成功播放音频')
+        }
+      } catch (error) {
+        // providerOnly=true 仍允许浏览器 TTS 作为兼容兜底。
+        // 只有明确要求“绝不兜底”的场景才可在这里抛错；当前小园执行前门禁需要兼容旧浏览器，
+        // 因此默认继续走浏览器 speechSynthesis。
+        this.onError?.(error?.message || '第三方语音播报失败，正在切换为浏览器语音')
+      }
+    } else if (providerOnly && !this.canUseBrowserTTS()) {
+      throw new Error('TTS Provider 未配置，且当前浏览器不支持内置语音播报')
+    }
+
+    return await this.speakWithBrowser(value, { waitForEnd })
+  }
+
+  canUseBrowserTTS() {
+    return typeof window !== 'undefined' &&
+      'speechSynthesis' in window &&
+      typeof SpeechSynthesisUtterance !== 'undefined'
+  }
+
+  async speakWithBrowser(text, options = {}) {
+    const waitForEnd = options?.waitForEnd === true
+    if (!this.canUseBrowserTTS()) return false
+
+    return await new Promise((resolve) => {
+      const synth = window.speechSynthesis
+      let started = false
+      let settled = false
+      let fallbackTimer = null
+
+      const finish = (value) => {
+        if (settled) return
+        settled = true
+        if (fallbackTimer) window.clearTimeout(fallbackTimer)
+        resolve(value)
+      }
+
+      try {
+        synth.cancel()
+        try { synth.resume() } catch (_) {}
+
+        const utterance = new SpeechSynthesisUtterance(String(text))
+        utterance.lang = this.lang
+        utterance.rate = this.rate
+        utterance.pitch = this.pitch
+        utterance.volume = this.volume
+        if (this.voice) utterance.voice = this.voice
+
+        // 对小园的执行门禁来说，“真正开始播放”就是 onstart。
+        utterance.onstart = () => {
+          started = true
+          if (!waitForEnd) finish(true)
+        }
+
+        utterance.onend = () => {
+          // waitForEnd=true 用于 AI 分析结果：必须等整段语音播报完，才能进入下一步。
+          if (waitForEnd) {
+            finish(started || true)
+            return
+          }
+          // 某些浏览器没有稳定触发 onstart，但已经完成了播报。
+          // 这种情况下也允许放行，避免工作流永久卡住。
+          if (!started) finish(true)
+        }
+
+        utterance.onerror = () => finish(false)
+
+        synth.speak(utterance)
+
+        window.setTimeout(() => {
+          try { synth.resume() } catch (_) {}
+        }, 50)
+
+        // 浏览器偶发不触发 onstart/onend；这里仅作为最后兜底。
+        fallbackTimer = window.setTimeout(() => finish(true), Math.max(1200, String(text).length * 120))
+      } catch (_) {
+        finish(false)
+      }
+    })
+  }
+
+  stopSpeaking() {
+    try { this.ttsProvider?.stop?.() } catch (_) {}
+    if (typeof window !== 'undefined' && 'speechSynthesis' in window) {
+      window.speechSynthesis.cancel()
+    }
+  }
+
+  listenOnce() {
+    return new Promise(async (resolve, reject) => {
+      if (!this.supported()) {
+        reject(new Error('当前浏览器不支持语音识别'))
+        return
+      }
+
+      try {
+        await this.requestMicrophonePermission()
+      } catch (error) {
+        const reason = error?.name || error?.message || error
+        reject(new Error(`麦克风权限不可用：${reason}`))
+        return
+      }
+
+      const recognition = this.createRecognition({ continuous: false })
+      let finalText = ''
+      let settled = false
+
+      const finish = (error = null) => {
+        if (settled) return
+        settled = true
+        this.listening = false
+        this.recognition = null
+        this.onEnd()
+        if (error) reject(error)
+        else resolve(finalText.trim())
+      }
+
+      recognition.onstart = () => {
+        this.listening = true
+      }
+
+      recognition.onresult = (event) => {
+        let interim = ''
+        for (let i = event.resultIndex; i < event.results.length; i += 1) {
+          const part = event.results[i][0]?.transcript || ''
+          if (event.results[i].isFinal) {
+            finalText += part
+            this.onFinal(part)
+          } else {
+            interim += part
+          }
+        }
+        this.onInterim(interim)
+
+        // 已得到 final 文本就尽快结束本轮，减少“说完以后还要等很久”的感觉。
+        if (finalText.trim()) {
+          window.setTimeout(() => {
+            try { recognition.stop() } catch (_) {}
+          }, 80)
+        }
+      }
+
+      recognition.onerror = (event) => {
+        const code = event?.error || 'unknown'
+        // no-speech 更像“没有听到”，不是系统故障。
+        if (code === 'no-speech') {
+          finish(new Error('没有听到您的声音，请再说一次。'))
+          return
+        }
+        if (code === 'not-allowed' || code === 'service-not-allowed') {
+          finish(new Error('麦克风权限被拒绝，请允许当前页面使用麦克风后再试。'))
+          return
+        }
+        if (code === 'audio-capture') {
+          finish(new Error('没有检测到可用麦克风，请检查麦克风设备。'))
+          return
+        }
+        if (code === 'network') {
+          finish(new Error('语音识别网络异常，请检查网络后再试。'))
+          return
+        }
+        finish(new Error(`语音识别失败：${code}`))
+      }
+
+      recognition.onend = () => {
+        finish()
+      }
+
+      try {
+        recognition.start()
+        this.recognition = recognition
+        this.listening = true
+      } catch (error) {
+        finish(error instanceof Error ? error : new Error('语音识别启动失败'))
+      }
+    })
+  }
+
+  startWakeWordListener({ wakeWord = '你好小园', onWake, onError }) {
+    if (!this.supported()) return { stop: () => {}, pause: () => {}, resume: () => {} }
+
+    const recognition = this.createRecognition({ continuous: true })
+    let buffer = ''
+    let stopped = false
+    let paused = false
+    let restarting = false
+
+    const normalizedWakeWord = wakeWord.replace(/[，。！？、,.!?\s]/g, '')
+
+    const restart = () => {
+      if (stopped || paused || restarting) return
+      restarting = true
+      window.setTimeout(() => {
+        restarting = false
+        if (stopped) return
+        try { recognition.start() } catch (_) {}
+      }, 300)
+    }
+
+    recognition.onresult = (event) => {
+      let text = ''
+      for (let i = event.resultIndex; i < event.results.length; i += 1) {
+        text += event.results[i][0]?.transcript || ''
+      }
+      buffer = `${buffer}${text}`.replace(/\s+/g, '')
+      const normalized = buffer.replace(/[，。！？、,.!?]/g, '')
+      if (normalized.includes(normalizedWakeWord)) {
+        buffer = ''
+        onWake?.()
+      } else if (buffer.length > 80) {
+        buffer = buffer.slice(-80)
+      }
+    }
+
+    recognition.onerror = (event) => {
+      const code = event?.error || 'unknown'
+      // 唤醒监听失败不连续弹错误消息，避免屏幕不断出现“语音识别失败”。
+      if (code !== 'no-speech') onError?.(code)
+      restart()
+    }
+
+    recognition.onend = restart
+
+    const controller = {
+      stop() {
+        stopped = true
+        recognition.onend = null
+        try { recognition.stop() } catch (_) {}
+        buffer = ''
+      },
+      pause() {
+        paused = true
+        try { recognition.stop() } catch (_) {}
+      },
+      resume() {
+        if (stopped) return
+        paused = false
+        try { recognition.start() } catch (_) {}
+      },
+      recognition
+    }
+
+    try { recognition.start() } catch (_) {}
+    return controller
+  }
+}