@mentra/bluetooth-sdk 0.1.4 → 0.1.6

package/ios/Source/sgcs/G2.swift

@@ -1062,6 +1062,8 @@ class G2: NSObject, SGCManager {
     private var rightAuthenticated: Bool = false
     private var isDisconnecting = false
     private var pairingTimeoutTimer: DispatchWorkItem?
+    private var useEvenDashboard = true
+    private var dashboardShowing = 0
 
     /// Device search
     var DEVICE_SEARCH_ID = "NOT_SET"
@@ -1598,11 +1600,11 @@ class G2: NSObject, SGCManager {
     func sendTextWall(_ text: String) {
         // Bridge.log("G2: sendTextWall(\(text.prefix(50))...)")
 
-        // ignore events while the dashboard is open:
-        // let isHeadUp = DeviceStore.shared.get("glasses", "headUp") as? Bool ?? false
-        // if isHeadUp {
-        //     return
-        // }
+        // ignore events while the ER dashboard is open:
+        let useNativeDashboard = DeviceStore.shared.get("bluetooth", "use_native_dashboard") as? Bool ?? false
+        if useNativeDashboard && dashboardShowing > 0 {
+            return
+        }
 
         if text.isEmpty {
             clearDisplay()
@@ -2191,8 +2193,24 @@ class G2: NSObject, SGCManager {
         return bmp
     }
 
+    /// Bring the Even Realities dashboard (the OS-level home/idle screen) to
+    /// the foreground by tearing down whatever EvenHub page we currently own.
+    /// The glasses fall back to the dashboard automatically when no page is up.
     func showDashboard() {
-        // G2 doesn't have a native dashboard concept via EvenHub
+        Bridge.log("G2: showDashboard")
+        dashboardShowing += 2
+        let msg = EvenHubProto.shutdownMessage()
+        sendEvenHubCommand(msg)
+        pageCreated = false
+        pageHasTextContainer = false
+        currentTextContent = ""
+        currentBitmapBase64 = ""
+        DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) { [weak self] in
+            guard let self = self else { return }
+            // activate the dashboard by setting dept to the current setting:
+            let currentDepth = DeviceStore.shared.get("bluetooth", "dashboard_depth") as? Int ?? 0
+            self.setDashboardDepthOnly(currentDepth)
+        }
     }
 
     func setDashboardPosition(_ height: Int, _ depth: Int) {
@@ -2302,21 +2320,33 @@ class G2: NSObject, SGCManager {
         sendEvenHubCommand(toSend)
     }
 
+    func restartMic() {
+        // if already enabled, set to disabled, then send enabled after 500ms:
+        DeviceStore.shared.apply("glasses", "micEnabled", true)
+        let msg = EvenHubProto.audioControlMessage(enable: false)
+        sendEvenHubCommand(msg)
+        DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) { [weak self] in
+            guard let self = self else { return }
+            let useNativeDashboard = DeviceStore.shared.get("bluetooth", "use_native_dashboard") as? Bool ?? false
+            Bridge.log("G2: setMicEnabled - useNativeDashboard=\(useNativeDashboard), dashboardShowing=\(dashboardShowing)")
+            if useNativeDashboard && dashboardShowing > 0 {
+                return
+            }
+            if (!pageCreated || !pageHasTextContainer) {
+                DeviceManager.shared.sendCurrentState()// should re-create the page if needed
+            }
+            let msg = EvenHubProto.audioControlMessage(enable: true)
+            self.sendEvenHubCommand(msg)
+        }
+    }
+
     // MARK: - SGCManager: Audio Control
 
     func setMicEnabled(_ enabled: Bool) {
         Bridge.log("G2: setMicEnabled(\(enabled))")
         let currentEnabled = DeviceStore.shared.get("glasses", "micEnabled") as? Bool ?? false
         if currentEnabled && enabled {
-            // if already enabled, set to disabled, then send enabled after 500ms:
-            DeviceStore.shared.apply("glasses", "micEnabled", true)
-            let msg = EvenHubProto.audioControlMessage(enable: false)
-            sendEvenHubCommand(msg)
-            DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) { [weak self] in
-                guard let self = self else { return }
-                let msg = EvenHubProto.audioControlMessage(enable: true)
-                self.sendEvenHubCommand(msg)
-            }
+            restartMic()
             return
         }
 
@@ -2505,7 +2535,8 @@ class G2: NSObject, SGCManager {
         // }
 
         // connectController("1B:08:26:8E:0E:E6")
-        connectController()
+        // connectController()
+        showDashboard()
     }
 
     func dbg2() {
@@ -2532,6 +2563,8 @@ class G2: NSObject, SGCManager {
         // // update the text
         // Bridge.log("G2: sendTextWall() - updating text container")
         // updateText("test2")
+        let currentDepth = DeviceStore.shared.get("bluetooth", "dashboard_depth") as? Int ?? 0
+        setDashboardDepthOnly(currentDepth)
     }
 
     // MARK: - SGCManager: Device Control
@@ -3021,15 +3054,22 @@ class G2: NSObject, SGCManager {
             if eventType == .doubleClick {
                 // trigger dashboard:
                 let isHeadUp = DeviceStore.shared.get("glasses", "headUp") as? Bool ?? false
-                // toggle head up:
-                DeviceStore.shared.apply("glasses", "headUp", !isHeadUp)
-                if isHeadUp {
-                    // Bridge.log("G2: going back to home, clearing display")
-                    // clear the display after a delay:
-                    DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
-                        self.clearDisplay()
-                    }
+
+                let useNativeDashboard = DeviceStore.shared.get("bluetooth", "use_native_dashboard") as? Bool ?? false
+                if useNativeDashboard {
+                    showDashboard()
+                } else {
+                    // toggle head up:
+                    DeviceStore.shared.apply("glasses", "headUp", !isHeadUp)
                 }
+
+                // if isHeadUp {
+                //     // Bridge.log("G2: going back to home, clearing display")
+                //     // clear the display after a delay:
+                //     DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
+                //         self.clearDisplay()
+                //     }
+                // }
                 // sendDashboardCommand(DashboardCommand.trigger)
 
                 // toggle head up:
@@ -3373,18 +3413,39 @@ class G2: NSObject, SGCManager {
         // if we got 08011A00 that means we closed the dashboard, which means the mic is probably dead,
         // so we need to revive it:
         if data == Data([0x08, 0x01, 0x1A, 0x00]) {
-            Bridge.log("G2: gesture_ctrl response: dashboard closed")
-            // re-send mic on / update mic state:
-            DeviceStore.shared.apply("glasses", "micEnabled", false)
-            DeviceManager.shared.updateMicState() // should set the mic back on if it should be on
-            //     // let isHeadUp = DeviceStore.shared.get("glasses", "headUp") as? Bool ?? false
-
-            //     // toggle head up:
-            //     DeviceStore.shared.apply("glasses", "headUp", false)
-            //     // send the current state to the glasses
-            //     DeviceManager.shared.sendCurrentState()
-            // reset the text container (different from clearDisplay())
-            sendTextWall(" ")
+            Bridge.log("G2: dashboard closed / shutdown - dashboardShowing=\(dashboardShowing)")
+            let useNativeDashboard = DeviceStore.shared.get("bluetooth", "use_native_dashboard") as? Bool ?? false
+            if !useNativeDashboard {
+                // make sure the container exists:
+                DeviceManager.shared.sendCurrentState()
+                // re-send mic on / if it's enabled:
+                let micEnabled = DeviceStore.shared.get("glasses", "micEnabled") as? Bool ?? false
+                if micEnabled {
+                    restartMic()
+                }
+                // reset the text container (different from clearDisplay())
+                // sendTextWall(" ")
+                // createPageWithText(" ")
+            } else {
+                // if we aren't trying to show the dashboard
+                // then we need to turn the mic back on and display the mentra main page:
+                if dashboardShowing <= 1 {
+                    dashboardShowing = 0
+                    // make sure the container exists:
+                    DeviceManager.shared.sendCurrentState()
+                    // set the mic back on if it should be on
+                    let micEnabled = DeviceStore.shared.get("glasses", "micEnabled") as? Bool ?? false
+                    if micEnabled {
+                        restartMic()
+                    }
+                    return
+                }
+                // do nothing this time since we just closed the dashboard
+                dashboardShowing -= 1
+                if (dashboardShowing < 0) {
+                    dashboardShowing = 0
+                }
+            }
         }
 
         // if we got 08011097012200 that means we selected a menu item:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mentra/bluetooth-sdk",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "SDK for communicating with smart glasses",
   "main": "build/index.js",
   "react-native": "src/index.ts",

package/src/BluetoothSdk.types.ts

@@ -295,11 +295,24 @@ export type WsBinEvent = {
 export type MicPcmEvent = {
   type: "mic_pcm"
   pcm: ArrayBuffer
+  sampleRate: 16000
+  bitsPerSample: 16
+  channels: 1
+  encoding: "pcm_s16le"
+  vadGated: boolean
 }
 
 export type MicLc3Event = {
   type: "mic_lc3"
   lc3: ArrayBuffer
+  sampleRate: 16000
+  channels: 1
+  encoding: "lc3"
+  frameDurationMs: 10
+  frameSizeBytes: number
+  bitrate: number
+  packetizedFromGlasses: boolean
+  vadGated: boolean
 }
 
 export type StreamStatusLifecycleState = "initializing" | "streaming" | "stopping" | "stopped"
@@ -381,7 +394,7 @@ export type OtaUpdateAvailableEvent = {
   cache_ready?: boolean
 }
 
-/** @deprecated Glasses no longer emit ota_progress; use {@link OtaStatusEvent} and legacy store mapping. */
+/** @deprecated Glasses no longer emit ota_progress; use {@link OtaStatusEvent} and status-store mapping. */
 export type OtaProgressEvent = {
   type: "ota_progress"
   stage?: OtaStage
@@ -491,8 +504,6 @@ export type PublicBluetoothStatus = Pick<
 >
 
 export type BluetoothSdkEventMap = {
-  glasses_status: Partial<PublicGlassesStatus>
-  bluetooth_status: Partial<PublicBluetoothStatus>
   log: LogEvent
   device_discovered: Device
   default_device_changed: {device?: Device}
@@ -540,8 +551,6 @@ export interface BluetoothSdkPublicModule {
     listener: BluetoothSdkEventListener<EventName>,
   ): BluetoothSdkSubscription
 
-  getGlassesStatus(): Promise<PublicGlassesStatus>
-  getBluetoothStatus(): Promise<PublicBluetoothStatus>
   getDefaultDevice(): Promise<Device | null>
   setDefaultDevice(device: Device | null): Promise<void>
   clearDefaultDevice(): Promise<void>
@@ -614,8 +623,6 @@ export interface BluetoothSdkPublicModule {
   ): Promise<void>
 
   requestVersionInfo(): Promise<void>
-  onGlassesStatus(callback: (changed: Partial<PublicGlassesStatus>) => void): () => void
-  onBluetoothStatus(callback: (changed: Partial<PublicBluetoothStatus>) => void): () => void
 }
 
 // OTA update status types
@@ -711,10 +718,20 @@ export interface CoreSettings {
 }
 
 export interface Device {
+  /**
+   * Stable app-facing key for this scan result, within the limits of the
+   * platform identifier available to the SDK. Do not parse this value; use the
+   * typed model, name, address, and rssi fields instead.
+   */
   id: string
   model: DeviceModel
   name: string
+  /** Platform address/identifier when available: Android Bluetooth address, iOS CoreBluetooth identifier. */
   address?: string
+  /**
+   * Optional scan signal strength. It may be undefined at first discovery and
+   * appear in a later scan update when the platform reports RSSI metadata.
+   */
   rssi?: number
 }
 

package/src/_internal.ts

@@ -1,7 +1,7 @@
 /**
  * MentraOS-only compatibility entrypoint.
  *
- * Partner apps should import from `@mentra/bluetooth-sdk`. This file is not a
+ * Apps should import from `@mentra/bluetooth-sdk`. This file is not a
  * package export; MentraOS resolves it through its local
  * `@mentra/bluetooth-sdk-internal` alias while the app is migrated onto the
  * public SDK surface.

package/src/_private/BluetoothSdkModule.ts

@@ -20,6 +20,7 @@ import {
   ObservableStoreCategory,
   PhotoCompression,
   PhotoSize,
+  PublicBluetoothStatus,
   RgbLedAction,
   RgbLedColor,
   ScanModelOptions,
@@ -33,17 +34,18 @@ import {
  *
  * This file intentionally lives under `_private` so the package root can expose
  * a small SDK surface while MentraOS uses its monorepo-only internal alias
- * during migration.
+ * during migration. Raw status getters/listeners stay here so React hooks can
+ * shape native store snapshots before app code sees them.
  */
 
 type GlassesListener = (changed: Partial<GlassesStatus>) => void
-type BluetoothStatusListener = (changed: Partial<BluetoothStatus>) => void
+type BluetoothStatusListener = (changed: Partial<PublicBluetoothStatus>) => void
 type MaybePromise<T> = T | Promise<T>
 
 declare class BluetoothSdkNativeModule extends NativeModule<BluetoothSdkModuleEvents> {
   // Observable Store Functions (native)
   getGlassesStatus(): Promise<GlassesStatus>
-  getBluetoothStatus(): Promise<BluetoothStatus>
+  getBluetoothStatus(): Promise<PublicBluetoothStatus>
   getDefaultDevice(): Promise<Device | null>
   update(category: ObservableStoreCategory, values: object): Promise<void>
 
@@ -194,7 +196,7 @@ const CAMERA_FOV_SETTINGS: Record<CameraFov, CameraFovSetting> = {
   wide: {fov: 118, roiPosition: 0},
 }
 
-function searchResultsForModel(status: Partial<BluetoothStatus>, model: DeviceModel): Device[] {
+function searchResultsForModel(status: Partial<PublicBluetoothStatus>, model: DeviceModel): Device[] {
   return status.searchResults?.filter((device) => device.model === model) ?? []
 }
 
@@ -388,7 +390,7 @@ NativeBluetoothSdkModule.setMicState = function (
     nativeSetMicState(
       enabled,
       useGlassesMic ?? true,
-      bypassVad ?? false,
+      bypassVad ?? true,
       sendTranscript ?? false,
       sendLc3Data ?? false,
     ),
@@ -464,6 +466,9 @@ NativeBluetoothSdkModule.scan = async function (
     }
 
     const handleBluetoothStatus = (status: Partial<BluetoothStatus>) => {
+      if (!Array.isArray(status.searchResults)) {
+        return
+      }
       emitResults(searchResultsForModel(status, scanOptions.model))
     }
 

package/src/index.ts

@@ -1,10 +1,101 @@
-import {BluetoothSdk} from "./_private/BluetoothSdkModule"
+import PrivateBluetoothSdkModule from "./_private/BluetoothSdkModule"
+import type {
+  BluetoothSdkEventListener,
+  BluetoothSdkEventName,
+  BluetoothSdkPublicModule,
+} from "./BluetoothSdk.types"
+
+const PUBLIC_EVENT_NAMES = new Set<BluetoothSdkEventName>([
+  "log",
+  "device_discovered",
+  "default_device_changed",
+  "glasses_not_ready",
+  "button_press",
+  "touch_event",
+  "head_up",
+  "vad_status",
+  "battery_status",
+  "local_transcription",
+  "wifi_status_change",
+  "hotspot_status_change",
+  "hotspot_error",
+  "photo_response",
+  "gallery_status",
+  "compatible_glasses_search_stop",
+  "swipe_volume_status",
+  "switch_status",
+  "rgb_led_control_response",
+  "pair_failure",
+  "audio_pairing_needed",
+  "audio_connected",
+  "audio_disconnected",
+  "mic_pcm",
+  "mic_lc3",
+  "stream_status",
+  "keep_alive_ack",
+])
+
+const addListener: BluetoothSdkPublicModule["addListener"] = (eventName, listener) => {
+  if (!PUBLIC_EVENT_NAMES.has(eventName)) {
+    throw new Error(
+      `Unsupported BluetoothSdk event "${eventName}". Use @mentra/bluetooth-sdk/react for status state.`,
+    )
+  }
+  return PrivateBluetoothSdkModule.addListener(
+    eventName,
+    listener as BluetoothSdkEventListener<BluetoothSdkEventName>,
+  )
+}
+
+export const BluetoothSdk: BluetoothSdkPublicModule = Object.freeze({
+  addListener,
+  getDefaultDevice: PrivateBluetoothSdkModule.getDefaultDevice.bind(PrivateBluetoothSdkModule),
+  setDefaultDevice: PrivateBluetoothSdkModule.setDefaultDevice.bind(PrivateBluetoothSdkModule),
+  clearDefaultDevice: PrivateBluetoothSdkModule.clearDefaultDevice.bind(PrivateBluetoothSdkModule),
+  startScan: PrivateBluetoothSdkModule.startScan.bind(PrivateBluetoothSdkModule),
+  stopScan: PrivateBluetoothSdkModule.stopScan.bind(PrivateBluetoothSdkModule),
+  scan: PrivateBluetoothSdkModule.scan.bind(PrivateBluetoothSdkModule) as BluetoothSdkPublicModule["scan"],
+  connect: PrivateBluetoothSdkModule.connect.bind(PrivateBluetoothSdkModule),
+  connectDefault: PrivateBluetoothSdkModule.connectDefault.bind(PrivateBluetoothSdkModule),
+  cancelConnectionAttempt: PrivateBluetoothSdkModule.cancelConnectionAttempt.bind(PrivateBluetoothSdkModule),
+  disconnect: PrivateBluetoothSdkModule.disconnect.bind(PrivateBluetoothSdkModule),
+  forget: PrivateBluetoothSdkModule.forget.bind(PrivateBluetoothSdkModule),
+  displayText: PrivateBluetoothSdkModule.displayText.bind(PrivateBluetoothSdkModule),
+  clearDisplay: PrivateBluetoothSdkModule.clearDisplay.bind(PrivateBluetoothSdkModule),
+  showDashboard: PrivateBluetoothSdkModule.showDashboard.bind(PrivateBluetoothSdkModule),
+  setDashboardPosition: PrivateBluetoothSdkModule.setDashboardPosition.bind(PrivateBluetoothSdkModule),
+  setHeadUpAngle: PrivateBluetoothSdkModule.setHeadUpAngle.bind(PrivateBluetoothSdkModule),
+  setScreenDisabled: PrivateBluetoothSdkModule.setScreenDisabled.bind(PrivateBluetoothSdkModule),
+  requestWifiScan: PrivateBluetoothSdkModule.requestWifiScan.bind(PrivateBluetoothSdkModule),
+  sendWifiCredentials: PrivateBluetoothSdkModule.sendWifiCredentials.bind(PrivateBluetoothSdkModule),
+  forgetWifiNetwork: PrivateBluetoothSdkModule.forgetWifiNetwork.bind(PrivateBluetoothSdkModule),
+  setHotspotState: PrivateBluetoothSdkModule.setHotspotState.bind(PrivateBluetoothSdkModule),
+  setGalleryMode: PrivateBluetoothSdkModule.setGalleryMode.bind(PrivateBluetoothSdkModule),
+  setButtonPhotoSettings: PrivateBluetoothSdkModule.setButtonPhotoSettings.bind(PrivateBluetoothSdkModule),
+  setButtonVideoRecordingSettings: PrivateBluetoothSdkModule.setButtonVideoRecordingSettings.bind(PrivateBluetoothSdkModule),
+  setButtonCameraLed: PrivateBluetoothSdkModule.setButtonCameraLed.bind(PrivateBluetoothSdkModule),
+  setButtonMaxRecordingTime: PrivateBluetoothSdkModule.setButtonMaxRecordingTime.bind(PrivateBluetoothSdkModule),
+  setCameraFov: PrivateBluetoothSdkModule.setCameraFov.bind(PrivateBluetoothSdkModule),
+  queryGalleryStatus: PrivateBluetoothSdkModule.queryGalleryStatus.bind(PrivateBluetoothSdkModule),
+  requestPhoto: PrivateBluetoothSdkModule.requestPhoto.bind(PrivateBluetoothSdkModule),
+  startVideoRecording: PrivateBluetoothSdkModule.startVideoRecording.bind(PrivateBluetoothSdkModule),
+  stopVideoRecording: PrivateBluetoothSdkModule.stopVideoRecording.bind(PrivateBluetoothSdkModule),
+  startStream: PrivateBluetoothSdkModule.startStream.bind(PrivateBluetoothSdkModule),
+  stopStream: PrivateBluetoothSdkModule.stopStream.bind(PrivateBluetoothSdkModule),
+  keepStreamAlive: PrivateBluetoothSdkModule.keepStreamAlive.bind(PrivateBluetoothSdkModule),
+  setMicState: PrivateBluetoothSdkModule.setMicState.bind(PrivateBluetoothSdkModule),
+  setPreferredMic: PrivateBluetoothSdkModule.setPreferredMic.bind(PrivateBluetoothSdkModule),
+  setOwnAppAudioPlaying: PrivateBluetoothSdkModule.setOwnAppAudioPlaying.bind(PrivateBluetoothSdkModule),
+  getGlassesMediaVolume: PrivateBluetoothSdkModule.getGlassesMediaVolume.bind(PrivateBluetoothSdkModule),
+  setGlassesMediaVolume: PrivateBluetoothSdkModule.setGlassesMediaVolume.bind(PrivateBluetoothSdkModule),
+  rgbLedControl: PrivateBluetoothSdkModule.rgbLedControl.bind(PrivateBluetoothSdkModule),
+  requestVersionInfo: PrivateBluetoothSdkModule.requestVersionInfo.bind(PrivateBluetoothSdkModule),
+})
 
 export default BluetoothSdk
 
 export {
   DeviceModels,
-  createDisconnectedGlassesStatus,
   isBusyGlassesConnectionStatus,
   isConnectedGlassesConnectionStatus,
   isConnectedWifiStatus,
@@ -54,8 +145,6 @@ export type {
   PhotoCompression,
   PhotoResponseEvent,
   PhotoSize,
-  PublicBluetoothStatus as BluetoothStatus,
-  PublicGlassesStatus as GlassesStatus,
   RgbLedAction,
   RgbLedColor,
   RgbLedControlResponseEvent,

package/src/react/index.ts

@@ -8,15 +8,17 @@ export {
   type BluetoothScanHookResult,
   type UseBluetoothScanOptions,
 } from "./useBluetoothScan"
+export type {DefaultDeviceStorage} from "./useGlassesConnection"
 export {
-  useBluetoothStatus,
-  type BluetoothStatusHookResult,
-  type UseBluetoothStatusOptions,
-} from "./useBluetoothStatus"
-export {
-  useGlassesConnection,
-  type DefaultDeviceStorage,
-  type GlassesConnectionAction,
-  type GlassesConnectionHookResult,
-  type UseGlassesConnectionOptions,
-} from "./useGlassesConnection"
+  useMentraBluetooth,
+  type BatteryState,
+  type ConnectedGlassesInfo,
+  type FirmwareInfo,
+  type GalleryModeState,
+  type GlassesRuntimeState,
+  type MentraBluetoothSession,
+  type PhoneSdkRuntimeState,
+  type ScanController,
+  type SignalState,
+  type UseMentraBluetoothOptions,
+} from "./useMentraBluetooth"

package/src/react/useBluetoothStatus.ts

@@ -1,6 +1,6 @@
 import {useEffect, useRef, useState} from "react"
 
-import BluetoothSdk from "../index"
+import BluetoothSdk from "../_private/BluetoothSdkModule"
 import {
   createDisconnectedGlassesStatus,
   isConnectedGlassesConnectionStatus,

package/src/react/useGlassesConnection.ts

@@ -96,6 +96,21 @@ export function useGlassesConnection(
     }
   }, [])
 
+  useEffect(() => {
+    const subscription = BluetoothSdk.addListener("default_device_changed", (event) => {
+      const nextDefaultDevice = event.device ?? null
+      setDefaultDeviceState(nextDefaultDevice)
+      void defaultDeviceStorageRef.current?.save(nextDefaultDevice).catch((nextError) => {
+        setOperationError(nextError)
+        onErrorRef.current?.(nextError)
+      })
+    })
+
+    return () => {
+      subscription.remove()
+    }
+  }, [])
+
   useEffect(() => {
     if (!options.autoConnectDefault || autoConnectAttemptedRef.current || status.connected || !defaultDevice) {
       return