412 lines
14 KiB
JavaScript
412 lines
14 KiB
JavaScript
import { Capacitor } from '@capacitor/core'
|
|
|
|
// Platform-abstracted speech-to-text for voice task capture.
|
|
// Native: @capacitor-community/speech-recognition — uses the OS recognizer
|
|
// (on-device where the platform supports it, e.g. iOS dictation models).
|
|
// Web: Web Speech API (Chrome/Safari) — mainly for development.
|
|
//
|
|
// Callbacks:
|
|
// onPartial(text) — live transcript of the utterance in progress
|
|
// onSegment(text) — a finalized utterance (silence/pause boundary)
|
|
// onStateChange(bool) — listening started/stopped
|
|
// onError(code) — 'denied' | 'error'
|
|
//
|
|
// Neither OS gives unlimited continuous listening: Android's recognizer ends on
|
|
// silence and iOS sessions have a practical duration limit. This service runs a
|
|
// restart loop — each recognizer stop commits the buffered utterance as a
|
|
// segment and immediately starts a new session while active. The utterance
|
|
// boundary doubles as the task boundary.
|
|
|
|
const SILENCE_COMMIT_MS = 2200
|
|
const RESTART_DELAY_MS = 250
|
|
// Defense-in-depth: some Android OEM recognizers can die (e.g. after a speech
|
|
// timeout error) without emitting any event at all, which would otherwise
|
|
// leave the mic looking "still listening" forever with nothing restarting it.
|
|
// If no native event of any kind has arrived in this long, assume the session
|
|
// is dead and force a restart even with no pending partial text.
|
|
const HEARTBEAT_TIMEOUT_MS = 6000
|
|
// Native recognizers accept a limited vocabulary hint list; keep it small so
|
|
// the common names/labels actually get weighted rather than diluted.
|
|
const MAX_CONTEXTUAL_STRINGS = 100
|
|
// A known Android build of the plugin never resolved stop()'s promise on
|
|
// success — any `await`ed native call here hanging silently would otherwise
|
|
// wedge the whole restart loop (and the mic would look stuck "listening"
|
|
// forever). Cap every native await so a broken plugin promise can't do that.
|
|
const NATIVE_CALL_TIMEOUT_MS = 1500
|
|
// Android forwards both the interim AND the true final transcript (from
|
|
// onResults) through the same partialResults event, with the final one
|
|
// typically landing a couple hundred ms after the session is reported
|
|
// "stopped" — and no flag distinguishes them. The final result is usually
|
|
// MORE accurate than the last interim (it benefits from the full-utterance
|
|
// language model rather than a streaming guess), which matters most exactly
|
|
// on names — the same uncertainty behind "Moutaz" being misheard as
|
|
// "Models". So rather than committing immediately and discarding the late
|
|
// final as noise, wait this long after a session ends for it to arrive and
|
|
// supersede the interim before actually committing.
|
|
const FINAL_RESULT_GRACE_MS = 450
|
|
// Safety net for a final result arriving even later than the grace window
|
|
// (or a duplicate slipping through some other path) — still not committed as
|
|
// a second task if it looks like the same utterance.
|
|
const DUPLICATE_GUARD_MS = 3000
|
|
// Below this fraction of shared words, two transcripts are treated as
|
|
// different utterances rather than a re-delivery of the same one.
|
|
const DUPLICATE_WORD_OVERLAP = 0.6
|
|
|
|
const withTimeout = (promise, ms) =>
|
|
Promise.race([promise, new Promise(resolve => setTimeout(resolve, ms))])
|
|
|
|
const normalizeForDupeCheck = text =>
|
|
text
|
|
.trim()
|
|
.toLowerCase()
|
|
.replace(/[.,!?]/g, '')
|
|
|
|
// Word-overlap rather than exact/prefix match: names are exactly the words
|
|
// ASR is least confident about (the same uncertainty behind "Moutaz" heard as
|
|
// "Models"), so the final transcript commonly comes back with a different
|
|
// word around a name than the interim partial that already got committed.
|
|
// Requiring every character to match would miss that; requiring most of the
|
|
// same words to match still catches it as the same utterance.
|
|
const wordOverlapRatio = (a, b) => {
|
|
const wordsA = new Set(a.split(/\s+/).filter(Boolean))
|
|
const wordsB = new Set(b.split(/\s+/).filter(Boolean))
|
|
if (wordsA.size === 0 || wordsB.size === 0) return 0
|
|
let shared = 0
|
|
for (const word of wordsA) {
|
|
if (wordsB.has(word)) shared++
|
|
}
|
|
return shared / Math.max(wordsA.size, wordsB.size)
|
|
}
|
|
|
|
class VoiceInputService {
|
|
constructor() {
|
|
this._active = false
|
|
this._callbacks = null
|
|
this._partial = ''
|
|
this._lastSpeechAt = 0
|
|
this._lastNativeEventAt = 0
|
|
this._silenceTimer = null
|
|
this._restarting = false
|
|
this._restartPromise = null
|
|
this._webRecognition = null
|
|
this._contextualStrings = []
|
|
this._lastCommittedText = ''
|
|
this._lastCommittedAt = 0
|
|
this._awaitingFinal = false
|
|
this._resolveAwaitingFinal = null
|
|
}
|
|
|
|
_startOptions() {
|
|
return {
|
|
language: 'en-US',
|
|
maxResults: 1,
|
|
partialResults: true,
|
|
popup: false,
|
|
contextualStrings: this._contextualStrings,
|
|
}
|
|
}
|
|
|
|
get isNative() {
|
|
return Capacitor.isNativePlatform()
|
|
}
|
|
|
|
async isSupported() {
|
|
if (this.isNative) {
|
|
try {
|
|
const { SpeechRecognition } =
|
|
await import('@capacitor-community/speech-recognition')
|
|
const { available } = await SpeechRecognition.available()
|
|
return !!available
|
|
} catch {
|
|
return false
|
|
}
|
|
}
|
|
return (
|
|
typeof window !== 'undefined' &&
|
|
!!(window.SpeechRecognition || window.webkitSpeechRecognition)
|
|
)
|
|
}
|
|
|
|
async requestPermission() {
|
|
if (!this.isNative) {
|
|
// Web prompts for the microphone on first start()
|
|
return 'granted'
|
|
}
|
|
try {
|
|
const { SpeechRecognition } =
|
|
await import('@capacitor-community/speech-recognition')
|
|
const current = await SpeechRecognition.checkPermissions()
|
|
if (current.speechRecognition === 'granted') return 'granted'
|
|
const res = await SpeechRecognition.requestPermissions()
|
|
return res.speechRecognition === 'granted' ? 'granted' : 'denied'
|
|
} catch {
|
|
return 'denied'
|
|
}
|
|
}
|
|
|
|
// vocabulary: circle member names + label names, used to bias native
|
|
// recognition toward the words that matter most for task capture (iOS
|
|
// contextualStrings / Android 13+ EXTRA_BIASING_STRINGS). Without this, an
|
|
// unfamiliar name like "Moutaz" can get auto-corrected to a dictionary word.
|
|
async start(callbacks, vocabulary = []) {
|
|
if (this._active) return
|
|
this._callbacks = callbacks
|
|
this._active = true
|
|
this._partial = ''
|
|
this._lastSpeechAt = Date.now()
|
|
this._lastNativeEventAt = Date.now()
|
|
this._contextualStrings = [...new Set(vocabulary.filter(Boolean))].slice(
|
|
0,
|
|
MAX_CONTEXTUAL_STRINGS,
|
|
)
|
|
|
|
if (this.isNative) {
|
|
await this._startNative()
|
|
// Web finalizes utterances itself via isFinal results; only the native
|
|
// path needs a silence watchdog to force utterance boundaries.
|
|
this._silenceTimer = setInterval(() => this._checkSilence(), 500)
|
|
} else {
|
|
this._startWeb()
|
|
}
|
|
this._callbacks?.onStateChange?.(true)
|
|
}
|
|
|
|
async stop() {
|
|
if (!this._active) return
|
|
this._active = false
|
|
if (this._silenceTimer) {
|
|
clearInterval(this._silenceTimer)
|
|
this._silenceTimer = null
|
|
}
|
|
// Let any in-flight restart (triggered by a native "stopped" event or the
|
|
// heartbeat) finish tearing down first, so it doesn't resurrect a session
|
|
// right after the user asked to stop.
|
|
if (this._restartPromise) {
|
|
await this._restartPromise
|
|
}
|
|
if (this.isNative) {
|
|
let SpeechRecognition
|
|
try {
|
|
;({ SpeechRecognition } =
|
|
await import('@capacitor-community/speech-recognition'))
|
|
await withTimeout(SpeechRecognition.stop(), NATIVE_CALL_TIMEOUT_MS)
|
|
} catch {
|
|
// recognizer may already be stopped
|
|
}
|
|
// Wait for a possible late-arriving final result while listeners are
|
|
// still attached — removing them first would mean it's never heard.
|
|
// Always runs, even if the native stop() call above failed, so we
|
|
// never skip committing whatever was captured.
|
|
await this._finalizeSegment()
|
|
try {
|
|
await withTimeout(
|
|
SpeechRecognition?.removeAllListeners(),
|
|
NATIVE_CALL_TIMEOUT_MS,
|
|
)
|
|
} catch {
|
|
// non-fatal
|
|
}
|
|
} else if (this._webRecognition) {
|
|
const rec = this._webRecognition
|
|
this._webRecognition = null
|
|
try {
|
|
rec.stop()
|
|
} catch {
|
|
// already stopped
|
|
}
|
|
this._commitPartial()
|
|
} else {
|
|
this._commitPartial()
|
|
}
|
|
this._callbacks?.onStateChange?.(false)
|
|
}
|
|
|
|
// Called when a session has ended (or is being torn down for restart) and
|
|
// whatever's in `_partial` is ready to become a task — except Android's
|
|
// true final transcript, if there is one, is usually still in flight and
|
|
// hasn't replaced it yet. Give it a brief window to land first.
|
|
async _finalizeSegment() {
|
|
if (this._partial.trim() && this.isNative) {
|
|
this._awaitingFinal = true
|
|
await new Promise(resolve => {
|
|
this._resolveAwaitingFinal = resolve
|
|
setTimeout(resolve, FINAL_RESULT_GRACE_MS)
|
|
})
|
|
this._awaitingFinal = false
|
|
this._resolveAwaitingFinal = null
|
|
}
|
|
this._commitPartial()
|
|
}
|
|
|
|
_commitPartial() {
|
|
const text = this._partial.trim()
|
|
this._partial = ''
|
|
this._callbacks?.onPartial?.('')
|
|
if (text) {
|
|
this._lastCommittedText = normalizeForDupeCheck(text)
|
|
this._lastCommittedAt = Date.now()
|
|
this._callbacks?.onSegment?.(text)
|
|
}
|
|
}
|
|
|
|
// True if `text` looks like a re-delivery of what we just committed (exact
|
|
// match, or one is a prefix of the other — covers the final result being a
|
|
// trimmed/extended variant of the last partial we already committed on).
|
|
_isEchoOfLastCommit(text) {
|
|
if (!this._lastCommittedText) return false
|
|
if (Date.now() - this._lastCommittedAt > DUPLICATE_GUARD_MS) return false
|
|
const a = normalizeForDupeCheck(text)
|
|
const b = this._lastCommittedText
|
|
if (a === b || a.startsWith(b) || b.startsWith(a)) return true
|
|
return wordOverlapRatio(a, b) >= DUPLICATE_WORD_OVERLAP
|
|
}
|
|
|
|
_checkSilence() {
|
|
if (!this._active || this._restarting) return
|
|
const now = Date.now()
|
|
if (this._partial.trim() && now - this._lastSpeechAt > SILENCE_COMMIT_MS) {
|
|
// A pause means the utterance (= task) is complete: cycle the recognizer
|
|
// so the buffer commits and a fresh session begins.
|
|
this._restartNative()
|
|
return
|
|
}
|
|
if (now - this._lastNativeEventAt > HEARTBEAT_TIMEOUT_MS) {
|
|
// No native event of any kind for too long — the recognizer likely
|
|
// died silently (seen on some Android devices/OEMs). Force a restart
|
|
// so the mic doesn't sit "listening" forever with nothing happening.
|
|
this._restartNative()
|
|
}
|
|
}
|
|
|
|
async _startNative() {
|
|
const { SpeechRecognition } =
|
|
await import('@capacitor-community/speech-recognition')
|
|
await SpeechRecognition.removeAllListeners()
|
|
|
|
await SpeechRecognition.addListener('partialResults', ({ matches }) => {
|
|
this._lastNativeEventAt = Date.now()
|
|
const text = matches?.[0] || ''
|
|
if (!text) return
|
|
|
|
if (this._awaitingFinal) {
|
|
// This is the true final result we were waiting for — it's usually
|
|
// more accurate than the interim it's replacing, so use it and stop
|
|
// waiting out the rest of the grace window.
|
|
this._partial = text
|
|
this._callbacks?.onPartial?.(text)
|
|
this._resolveAwaitingFinal?.()
|
|
return
|
|
}
|
|
|
|
if (this._isEchoOfLastCommit(text)) {
|
|
// Arrived even later than the grace window (or some other stray
|
|
// delivery) — still don't let it look like a fresh spoken segment.
|
|
return
|
|
}
|
|
|
|
this._partial = text
|
|
this._lastSpeechAt = Date.now()
|
|
this._callbacks?.onPartial?.(text)
|
|
})
|
|
|
|
await SpeechRecognition.addListener('listeningState', ({ status }) => {
|
|
this._lastNativeEventAt = Date.now()
|
|
if (status === 'stopped' && this._active && !this._restarting) {
|
|
// OS ended the session on its own (silence on Android, session limit
|
|
// on iOS) — commit and start over.
|
|
this._restartNative()
|
|
}
|
|
})
|
|
|
|
// With partialResults the transcript arrives via listeners; the promise's
|
|
// resolution/rejection timing differs per platform, so don't rely on it.
|
|
SpeechRecognition.start(this._startOptions()).catch(() => {
|
|
if (this._active && !this._restarting) {
|
|
this._restartNative()
|
|
}
|
|
})
|
|
}
|
|
|
|
_restartNative() {
|
|
if (this._restarting) return this._restartPromise
|
|
this._restarting = true
|
|
this._restartPromise = this._doRestartNative().finally(() => {
|
|
this._restarting = false
|
|
this._restartPromise = null
|
|
})
|
|
return this._restartPromise
|
|
}
|
|
|
|
async _doRestartNative() {
|
|
const { SpeechRecognition } =
|
|
await import('@capacitor-community/speech-recognition')
|
|
try {
|
|
await withTimeout(SpeechRecognition.stop(), NATIVE_CALL_TIMEOUT_MS)
|
|
} catch {
|
|
// already stopped
|
|
}
|
|
await this._finalizeSegment()
|
|
// Let the OS recognizer tear down before starting a new session
|
|
await new Promise(r => setTimeout(r, RESTART_DELAY_MS))
|
|
if (this._active) {
|
|
SpeechRecognition.start(this._startOptions()).catch(() => {})
|
|
this._lastSpeechAt = Date.now()
|
|
this._lastNativeEventAt = Date.now()
|
|
}
|
|
}
|
|
|
|
_startWeb() {
|
|
const SR = window.SpeechRecognition || window.webkitSpeechRecognition
|
|
const rec = new SR()
|
|
rec.continuous = true
|
|
rec.interimResults = true
|
|
rec.lang = 'en-US'
|
|
|
|
rec.onresult = event => {
|
|
let interim = ''
|
|
for (let i = event.resultIndex; i < event.results.length; i++) {
|
|
const res = event.results[i]
|
|
if (res.isFinal) {
|
|
this._partial = ''
|
|
this._callbacks?.onPartial?.('')
|
|
const text = res[0].transcript.trim()
|
|
if (text) this._callbacks?.onSegment?.(text)
|
|
} else {
|
|
interim += res[0].transcript
|
|
}
|
|
}
|
|
if (interim) {
|
|
this._partial = interim
|
|
this._lastSpeechAt = Date.now()
|
|
this._callbacks?.onPartial?.(interim)
|
|
}
|
|
}
|
|
|
|
rec.onend = () => {
|
|
if (this._active && this._webRecognition === rec) {
|
|
try {
|
|
rec.start()
|
|
} catch {
|
|
// restart can race with teardown
|
|
}
|
|
}
|
|
}
|
|
|
|
rec.onerror = e => {
|
|
if (e.error === 'not-allowed' || e.error === 'service-not-allowed') {
|
|
this._callbacks?.onError?.('denied')
|
|
this.stop()
|
|
}
|
|
}
|
|
|
|
this._webRecognition = rec
|
|
try {
|
|
rec.start()
|
|
} catch {
|
|
this._callbacks?.onError?.('error')
|
|
}
|
|
}
|
|
}
|
|
|
|
export const voiceInputService = new VoiceInputService()
|