@mentra/engine 0.1.0-beta.0

package/src/services/NotificationsEmitter.ts

@@ -0,0 +1,48 @@
+/**
+ * Engine notifications emitter — the engine→host alert channel behind
+ * `engine.notifications`. Engine-detected conditions the host should surface
+ * (miniapp crashloop, version-incompatible miniapp, persistent connection loss)
+ * are pushed here; the facade fans them out to host subscribers.
+ *
+ * A plain listener set (not Node's EventEmitter) to avoid the `events` typings
+ * gap in engine's standalone build.
+ */
+export type IslandNotificationKind =
+  | "miniapp_crashloop"
+  | "version_incompatible"
+  | "missing_speech_model"
+  | "connection_failed_persistent"
+
+export interface IslandNotification {
+  kind: IslandNotificationKind
+  /** The miniapp this concerns, when applicable. */
+  packageName?: string
+  /** Epoch millis when raised. */
+  timestamp: number
+  /** Human-readable summary the host can show. */
+  reason: string
+  /** Kind-specific extras (versions, attempt counts, …). */
+  metadata?: Record<string, unknown>
+}
+
+const listeners = new Set<(n: IslandNotification) => void>()
+
+export const islandNotifications = {
+  /** Raise a notification to all host subscribers. */
+  emit(notification: IslandNotification): void {
+    for (const l of listeners) {
+      try {
+        l(notification)
+      } catch (err) {
+        console.warn(`islandNotifications: listener threw: ${(err as Error)?.message ?? err}`)
+      }
+    }
+  },
+  /** Subscribe to engine notifications; returns an unsubscribe. */
+  subscribe(cb: (n: IslandNotification) => void): () => void {
+    listeners.add(cb)
+    return () => {
+      listeners.delete(cb)
+    }
+  },
+}

package/src/services/OfflineSpeechModelService.ts

@@ -0,0 +1,168 @@
+// import NetInfo from "@react-native-community/netinfo"
+
+import STTModelManager from "./STTModelManager"
+import TTSModelManager from "./TTSModelManager"
+
+export type DownloadStage = "idle" | "downloading" | "extracting" | "complete" | "failed"
+
+export interface DownloadStatus {
+  kind: "stt" | "tts"
+  languageCode: string
+  stage: DownloadStage
+  /** 0–100, only meaningful while stage is "downloading" or "extracting". */
+  percent: number
+}
+
+type StatusListener = (status: DownloadStatus | null) => void
+
+class OfflineSpeechModelService {
+  private static instance: OfflineSpeechModelService
+  private started = false
+  private sttPromise: Promise<void> | null = null
+  private ttsPromise: Promise<void> | null = null
+
+  private currentStatus: DownloadStatus | null = null
+  private listeners = new Set<StatusListener>()
+
+  private constructor() {}
+
+  static getInstance(): OfflineSpeechModelService {
+    if (!OfflineSpeechModelService.instance) {
+      OfflineSpeechModelService.instance = new OfflineSpeechModelService()
+    }
+    return OfflineSpeechModelService.instance
+  }
+
+  startBackgroundDownloads(): void {
+    if (this.started) return
+    this.started = true
+
+    // Wi-Fi gate (currently disabled — uncomment to skip background downloads on cellular):
+    // NetInfo.fetch().then((state) => {
+    //   if (state.type !== "wifi") {
+    //     console.log("OFFLINE_MODELS: skipping background download — not on Wi-Fi")
+    //     return
+    //   }
+    //   void this.ensureDefaultModels().catch((error) => {
+    //     console.warn("OFFLINE_MODELS: background model setup failed:", error)
+    //   })
+    // })
+
+    void this.ensureDefaultModels().catch((error) => {
+      console.warn("OFFLINE_MODELS: background model setup failed:", error)
+    })
+  }
+
+  /** Subscribe to background-download status changes. Fires immediately with current status. */
+  subscribe(listener: StatusListener): () => void {
+    this.listeners.add(listener)
+    listener(this.currentStatus)
+    return () => {
+      this.listeners.delete(listener)
+    }
+  }
+
+  getStatus(): DownloadStatus | null {
+    return this.currentStatus
+  }
+
+  private setStatus(status: DownloadStatus | null): void {
+    this.currentStatus = status
+    for (const listener of this.listeners) {
+      try {
+        listener(status)
+      } catch (e) {
+        console.warn("OFFLINE_MODELS: status listener threw:", e)
+      }
+    }
+  }
+
+  async ensureDefaultModels(): Promise<void> {
+    // Sequence STT then TTS so the home-screen banner shows one coherent
+    // progress at a time. STT first because it's the primary use case.
+    try {
+      await this.ensureSttModel()
+    } catch (error) {
+      console.warn("OFFLINE_MODELS: STT model setup failed:", error)
+    }
+    try {
+      await this.ensureTtsModel()
+    } catch (error) {
+      console.warn("OFFLINE_MODELS: TTS model setup failed:", error)
+    }
+  }
+
+  async ensureSttModel(): Promise<void> {
+    if (this.sttPromise) return this.sttPromise
+    this.sttPromise = this.ensureSttModelInner().finally(() => {
+      this.sttPromise = null
+    })
+    return this.sttPromise
+  }
+
+  async ensureTtsModel(): Promise<void> {
+    if (this.ttsPromise) return this.ttsPromise
+    this.ttsPromise = this.ensureTtsModelInner().finally(() => {
+      this.ttsPromise = null
+    })
+    return this.ttsPromise
+  }
+
+  private async ensureSttModelInner(): Promise<void> {
+    const preferred = await STTModelManager.getCurrentLanguageFromPreferences()
+    const code = preferred || STTModelManager.getCurrentLanguage()
+
+    if (await STTModelManager.isModelAvailable(code)) {
+      await STTModelManager.activateLanguage(code)
+      console.log(`OFFLINE_MODELS: STT model ready: ${code}`)
+      return
+    }
+
+    console.log(`OFFLINE_MODELS: downloading STT model in background: ${code}`)
+    this.setStatus({kind: "stt", languageCode: code, stage: "downloading", percent: 0})
+    try {
+      await STTModelManager.downloadModel(
+        code,
+        (p) => this.setStatus({kind: "stt", languageCode: code, stage: "downloading", percent: p.percentage}),
+        (p) => this.setStatus({kind: "stt", languageCode: code, stage: "extracting", percent: p.percentage}),
+      )
+      await STTModelManager.activateLanguage(code)
+      this.setStatus({kind: "stt", languageCode: code, stage: "complete", percent: 100})
+      console.log(`OFFLINE_MODELS: STT model downloaded: ${code}`)
+    } catch (error) {
+      this.setStatus({kind: "stt", languageCode: code, stage: "failed", percent: 0})
+      throw error
+    }
+  }
+
+  private async ensureTtsModelInner(): Promise<void> {
+    const preferred = await TTSModelManager.getCurrentLanguageFromPreferences()
+    const code = preferred || TTSModelManager.getCurrentLanguage()
+
+    if (await TTSModelManager.isModelAvailable(code)) {
+      await TTSModelManager.activateLanguage(code)
+      console.log(`OFFLINE_MODELS: TTS model ready: ${code}`)
+      return
+    }
+
+    console.log(`OFFLINE_MODELS: downloading TTS model in background: ${code}`)
+    this.setStatus({kind: "tts", languageCode: code, stage: "downloading", percent: 0})
+    try {
+      await TTSModelManager.downloadModel(
+        code,
+        (p) => this.setStatus({kind: "tts", languageCode: code, stage: "downloading", percent: p.percentage}),
+        (p) => this.setStatus({kind: "tts", languageCode: code, stage: "extracting", percent: p.percentage}),
+      )
+      await TTSModelManager.activateLanguage(code)
+      this.setStatus({kind: "tts", languageCode: code, stage: "complete", percent: 100})
+      console.log(`OFFLINE_MODELS: TTS model downloaded: ${code}`)
+    } catch (error) {
+      this.setStatus({kind: "tts", languageCode: code, stage: "failed", percent: 0})
+      throw error
+    }
+  }
+}
+
+const offlineSpeechModelService = OfflineSpeechModelService.getInstance()
+export {OfflineSpeechModelService}
+export default offlineSpeechModelService