Files
archived-orca/mobile/src/platform/native-speech.ts

193 lines
6.6 KiB
TypeScript

import {
BRIDGE_SPEECH_FAILURES,
speechParamsSchema,
type BridgeSpeechFailure,
type BridgeSpeechRead,
type DictationEnginePreference
} from '../mobile-web-shell/bridge/bridge-speech-verbs'
// The shell side of native.speech.act. The recognizer itself lives in the native audio module; this keeps its events between the page's polls.
export type NativeSpeechEngine = {
readonly availability: (
locale: string
) => Promise<{ status: 'ready' | 'needs-download' | 'unsupported'; locale: string | null }>
readonly start: (
locale: string
) => Promise<{ started: true; locale: string } | { started: false; reason: string }>
readonly finish: () => Promise<string>
readonly cancel: () => void
readonly readPreference: () => Promise<DictationEnginePreference>
readonly onText: (handler: (text: Omit<BridgeSpeechRead, 'failure'>) => void) => void
readonly onError: (handler: (code: string) => void) => void
}
export type NativeSpeechServer = {
readonly serve: (params: unknown) => Promise<unknown>
// This phone promises audio never reaches the computer; only a page whose recognizer is armed may open the mic. Older pages stream to the computer and are refused.
readonly mayCapture: () => Promise<boolean>
readonly dispose: () => void
}
// armed: native's start resolved. Text before then may be a cancelled session's last words, so it's dropped;
// an error then is kept, because a recognizer that died while starting must not leave the page recording into nothing.
type Session = {
text: Omit<BridgeSpeechRead, 'failure'>
failure: BridgeSpeechFailure | null
armed: boolean
}
// The recognizer is one per phone, so its live session is per engine; each server holds only its own.
type EngineState = { live: Session | null }
const engineStates = new WeakMap<NativeSpeechEngine, EngineState>()
// A slow speech service is not an unsupported phone: callers ask again rather than remember it.
export function isSpeechBusyError(error: unknown): boolean {
return typeof error === 'object' && error !== null && 'code' in error && error.code === 'busy'
}
// A newer engine's code the shipped page does not know still means "use the computer".
function failureOf(code: string): BridgeSpeechFailure {
return BRIDGE_SPEECH_FAILURES.find((known) => known === code) ?? 'failed'
}
function engineState(engine: NativeSpeechEngine): EngineState {
const known = engineStates.get(engine)
if (known !== undefined) {
return known
}
const state: EngineState = { live: null }
engineStates.set(engine, state)
// Subscribed once per engine for the app's life, so no page session can miss or double an event.
engine.onText((text) => {
if (state.live?.armed === true && text.revision > state.live.text.revision) {
state.live.text = text
}
})
engine.onError((code) => {
if (state.live !== null) {
state.live.failure ??= failureOf(code)
}
})
return state
}
export function createNativeSpeechServer(engine: NativeSpeechEngine): NativeSpeechServer {
const shared = engineState(engine)
let session: Session | null = null
// Another page's start takes the recognizer; this session is then over.
function owned(): Session | null {
return session !== null && session === shared.live ? session : null
}
function endSession(): void {
if (owned() !== null) {
shared.live = null
engine.cancel()
}
session = null
}
async function status(locale: string): Promise<unknown> {
// Answer the preference even when the recognizer can't say, so This phone never falls to the computer.
// A slow service is reported as busy, never unsupported, so the page asks again on its next dictation.
const [preference, available] = await Promise.all([
engine.readPreference(),
engine
.availability(locale)
.catch((error: unknown) => (isSpeechBusyError(error) ? ('busy' as const) : null))
])
if (available === 'busy' || available === null) {
return { status: available ?? 'unsupported', locale: null, preference }
}
return { status: available.status, locale: available.locale, preference }
}
async function start(locale: string): Promise<unknown> {
endSession()
// Claim before the await so a cancel or another page's start meanwhile is seen; events count only once native's start resolves.
const claimed: Session = {
text: { revision: 0, committed: '', tentative: '' },
failure: null,
armed: false
}
session = claimed
shared.live = claimed
const started = await engine
.start(locale)
.catch(() => ({ started: false as const, reason: 'failed' }))
const kept = session === claimed && shared.live === claimed
// Cancelled while arming: stop what native armed, unless another page's start already replaced it.
if (started.started && !kept && (shared.live === null || shared.live === claimed)) {
engine.cancel()
}
if (!started.started || !kept) {
if (shared.live === claimed) {
shared.live = null
}
if (session === claimed) {
session = null
}
return {
started: false,
locale: null,
reason: started.started ? 'busy' : failureOf(started.reason)
}
}
claimed.armed = true
return { started: true, locale: started.locale, reason: null }
}
function read(): unknown {
const live = owned()
// No session here means it was lost or taken; the page falls back to the computer.
if (live === null) {
return { revision: 0, committed: '', tentative: '', failure: 'failed' }
}
return { ...live.text, failure: live.failure }
}
async function finish(): Promise<unknown> {
const live = owned()
if (live === null) {
return { text: null, failure: 'failed' }
}
try {
const text = await engine.finish()
return live.failure === null ? { text, failure: null } : { text: null, failure: live.failure }
} catch {
return { text: null, failure: live.failure ?? 'failed' }
} finally {
if (shared.live === live) {
shared.live = null
}
if (session === live) {
session = null
}
}
}
return {
serve: async (params) => {
const call = speechParamsSchema.parse(params)
switch (call.action) {
case 'status':
return status(call.locale)
case 'start':
return start(call.locale)
case 'read':
return read()
case 'finish':
return finish()
case 'cancel':
endSession()
return {}
}
},
mayCapture: async () => owned() !== null || (await engine.readPreference()) !== 'phone',
dispose: endSession
}
}