@mentra/bluetooth-sdk 0.1.3 → 0.1.5

package/src/react/useGlassesConnection.ts

@@ -0,0 +1,209 @@
+import {useEffect, useRef, useState} from "react"
+
+import BluetoothSdk from "../index"
+import type {ConnectOptions, Device, DeviceModel} from "../BluetoothSdk.types"
+
+import {useBluetoothScan, type BluetoothScanHookResult} from "./useBluetoothScan"
+import {useBluetoothStatus, type BluetoothStatusHookResult} from "./useBluetoothStatus"
+
+export type DefaultDeviceStorage = {
+  load: () => Promise<Device | null>
+  save: (device: Device | null) => Promise<void>
+}
+
+export type GlassesConnectionAction =
+  | "idle"
+  | "scanning"
+  | "connecting"
+  | "disconnecting"
+  | "forgetting"
+
+export type UseGlassesConnectionOptions = {
+  autoConnectDefault?: boolean
+  defaultDeviceStorage?: DefaultDeviceStorage
+  onError?: (error: unknown) => void
+  scanModel?: DeviceModel
+  scanTimeoutMs?: number
+}
+
+export type GlassesConnectionHookResult = BluetoothStatusHookResult & {
+  action: GlassesConnectionAction
+  busy: boolean
+  clearDefaultDevice: () => Promise<void>
+  connect: (device?: Device, options?: ConnectOptions) => Promise<void>
+  connectDefault: (options?: ConnectOptions) => Promise<void>
+  defaultDevice: Device | null
+  disconnect: () => Promise<void>
+  forget: () => Promise<void>
+  scan: BluetoothScanHookResult
+  setDefaultDevice: (device: Device | null) => Promise<void>
+}
+
+export function useGlassesConnection(
+  options: UseGlassesConnectionOptions = {},
+): GlassesConnectionHookResult {
+  const status = useBluetoothStatus({onError: options.onError})
+  const scan = useBluetoothScan({
+    model: options.scanModel,
+    onError: options.onError,
+    timeoutMs: options.scanTimeoutMs,
+  })
+  const [action, setAction] = useState<GlassesConnectionAction>("idle")
+  const [defaultDevice, setDefaultDeviceState] = useState<Device | null>(null)
+  const [operationError, setOperationError] = useState<unknown | null>(null)
+  const autoConnectAttemptedRef = useRef(false)
+  const defaultDeviceStorageRef = useRef(options.defaultDeviceStorage)
+  const onErrorRef = useRef(options.onError)
+
+  useEffect(() => {
+    defaultDeviceStorageRef.current = options.defaultDeviceStorage
+    onErrorRef.current = options.onError
+  }, [options.defaultDeviceStorage, options.onError])
+
+  useEffect(() => {
+    let mounted = true
+
+    const loadDefaultDevice = async () => {
+      try {
+        const [nativeDefaultDevice, storedDefaultDevice] = await Promise.all([
+          BluetoothSdk.getDefaultDevice(),
+          defaultDeviceStorageRef.current?.load() ?? Promise.resolve(null),
+        ])
+        if (!mounted) {
+          return
+        }
+        const nextDefaultDevice = storedDefaultDevice ?? nativeDefaultDevice
+        if (nextDefaultDevice) {
+          await BluetoothSdk.setDefaultDevice(nextDefaultDevice)
+        }
+        if (mounted) {
+          setDefaultDeviceState(nextDefaultDevice)
+          setOperationError(null)
+        }
+      } catch (nextError) {
+        if (!mounted) {
+          return
+        }
+        setOperationError(nextError)
+        onErrorRef.current?.(nextError)
+      }
+    }
+
+    void loadDefaultDevice()
+
+    return () => {
+      mounted = false
+    }
+  }, [])
+
+  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
+    }
+
+    autoConnectAttemptedRef.current = true
+    void connectDefault().catch(() => undefined)
+  }, [defaultDevice, options.autoConnectDefault, status.connected])
+
+  async function runConnectionAction<T>(
+    nextAction: Exclude<GlassesConnectionAction, "idle" | "scanning">,
+    operation: () => Promise<T>,
+  ): Promise<T> {
+    setAction(nextAction)
+    setOperationError(null)
+    try {
+      const result = await operation()
+      setOperationError(null)
+      return result
+    } catch (nextError) {
+      setOperationError(nextError)
+      onErrorRef.current?.(nextError)
+      throw nextError
+    } finally {
+      setAction("idle")
+    }
+  }
+
+  async function setDefaultDevice(device: Device | null) {
+    await runConnectionAction("connecting", async () => {
+      await BluetoothSdk.setDefaultDevice(device)
+      await defaultDeviceStorageRef.current?.save(device)
+      setDefaultDeviceState(device)
+    })
+  }
+
+  async function clearDefaultDevice() {
+    await runConnectionAction("forgetting", async () => {
+      await BluetoothSdk.clearDefaultDevice()
+      await defaultDeviceStorageRef.current?.save(null)
+      setDefaultDeviceState(null)
+      scan.selectDevice(null)
+    })
+  }
+
+  async function connect(device?: Device, connectOptions?: ConnectOptions) {
+    await runConnectionAction("connecting", async () => {
+      const targetDevice = device ?? scan.selectedDevice
+      if (targetDevice) {
+        await BluetoothSdk.connect(targetDevice, connectOptions)
+        if (connectOptions?.saveAsDefault !== false) {
+          await defaultDeviceStorageRef.current?.save(targetDevice)
+          setDefaultDeviceState(targetDevice)
+        }
+        return
+      }
+      await BluetoothSdk.connectDefault(connectOptions)
+    })
+  }
+
+  async function connectDefault(connectOptions?: ConnectOptions) {
+    await runConnectionAction("connecting", async () => {
+      await BluetoothSdk.connectDefault(connectOptions)
+    })
+  }
+
+  async function disconnect() {
+    await runConnectionAction("disconnecting", async () => {
+      await BluetoothSdk.disconnect()
+    })
+  }
+
+  async function forget() {
+    await runConnectionAction("forgetting", async () => {
+      await BluetoothSdk.forget()
+      scan.clearResults()
+    })
+  }
+
+  const busy = action !== "idle" || scan.scanning || status.loading
+
+  return {
+    ...status,
+    action: scan.scanning ? "scanning" : action,
+    busy,
+    clearDefaultDevice,
+    connect,
+    connectDefault,
+    defaultDevice,
+    disconnect,
+    error: operationError ?? scan.error ?? status.error,
+    forget,
+    scan,
+    setDefaultDevice,
+  }
+}

package/src/react/useMentraBluetooth.ts

@@ -0,0 +1,307 @@
+import {useState} from "react"
+
+import BluetoothSdk from "../index"
+import {
+  DeviceModels,
+  createDisconnectedGlassesStatus,
+  isConnectedGlassesConnectionStatus,
+  isReadyGlassesConnectionStatus,
+} from "../BluetoothSdk.types"
+import type {
+  ConnectOptions,
+  Device,
+  DeviceModel,
+  GalleryMode,
+  GlassesConnectionStatus,
+  HotspotStatus,
+  PublicBluetoothStatus,
+  PublicGlassesStatus,
+  MicMode,
+  WifiSearchResult,
+  WifiStatus,
+} from "../BluetoothSdk.types"
+
+import {
+  useGlassesConnection,
+  type DefaultDeviceStorage,
+  type GlassesConnectionHookResult,
+} from "./useGlassesConnection"
+
+export type BatteryState = {
+  charging: boolean
+  level: number | null
+}
+
+export type ConnectedGlassesInfo = {
+  appVersion?: string
+  bluetoothName?: string
+  buildNumber?: string
+  color?: string
+  deviceModel?: string
+  firmwareVersion?: string
+  serialNumber?: string
+  style?: string
+}
+
+export type FirmwareInfo = {
+  appVersion?: string
+  buildNumber?: string
+  source:
+    | "app"
+    | "bes"
+    | "device"
+    | "firmware"
+    | "left"
+    | "mtk"
+    | "right"
+    | "unknown"
+  version: string | null
+}
+
+export type SignalState = {
+  strengthDbm: number | null
+  updatedAt: number | null
+}
+
+export type GlassesRuntimeState =
+  | {
+      connected: false
+      connection: Exclude<GlassesConnectionStatus, {state: "connected"}>
+      ready: false
+    }
+  | {
+      battery: BatteryState
+      connected: true
+      connection: Extract<GlassesConnectionStatus, {state: "connected"}>
+      device: ConnectedGlassesInfo
+      firmware: FirmwareInfo
+      hotspot: HotspotStatus
+      ready: boolean
+      signal: SignalState
+      wifi: WifiStatus
+    }
+
+export type GalleryModeState = {
+  applying: boolean
+  desired: GalleryMode
+  error: unknown | null
+}
+
+export type PhoneSdkRuntimeState = {
+  currentMic: MicMode | null
+  defaultDevice: Device | null
+  galleryMode: GalleryModeState
+  lastLog: string[]
+  micRanking: MicMode[]
+  otherBluetoothConnected: boolean
+  searching: boolean
+  searchingController: boolean
+  systemMicUnavailable: boolean
+  wifiScanResults: WifiSearchResult[]
+}
+
+export type ScanController = {
+  active: boolean
+  clear: () => void
+  devices: Device[]
+  error: unknown | null
+  model: DeviceModel
+  selectedDevice: Device | null
+  selectDevice: (device: Device | null) => void
+  setModel: (model: DeviceModel) => void
+  start: (model?: DeviceModel) => Promise<Device[]>
+  stop: () => Promise<void>
+}
+
+export type UseMentraBluetoothOptions = {
+  autoConnectDefault?: boolean
+  defaultDeviceStorage?: DefaultDeviceStorage
+  defaultModel?: DeviceModel
+  onError?: (error: unknown) => void
+  scanTimeoutMs?: number
+}
+
+export type MentraBluetoothSession = {
+  busy: boolean
+  clearDefaultDevice: () => Promise<void>
+  connect: (device?: Device, options?: ConnectOptions) => Promise<void>
+  connectDefault: (options?: ConnectOptions) => Promise<void>
+  defaultDevice: Device | null
+  disconnect: () => Promise<void>
+  error: unknown | null
+  glasses: GlassesRuntimeState
+  refresh: () => Promise<void>
+  scan: ScanController
+  sdk: PhoneSdkRuntimeState
+  setDefaultDevice: (device: Device | null) => Promise<void>
+  setGalleryMode: (mode: GalleryMode) => Promise<void>
+}
+
+function stringValue(value: unknown): string | undefined {
+  return typeof value === "string" && value.length > 0 ? value : undefined
+}
+
+function numberValue(value: unknown): number | null {
+  return typeof value === "number" && Number.isFinite(value) ? value : null
+}
+
+function firmwareInfo(status: Partial<PublicGlassesStatus>): FirmwareInfo {
+  const firmwareSources = [
+    ["firmwareVersion", "firmware"],
+    ["deviceFirmwareVersion", "device"],
+    ["rightFirmwareVersion", "right"],
+    ["leftFirmwareVersion", "left"],
+    ["besFirmwareVersion", "bes"],
+    ["mtkFirmwareVersion", "mtk"],
+    ["appVersion", "app"],
+  ] as const
+
+  for (const [key, source] of firmwareSources) {
+    const value = stringValue((status as Record<string, unknown>)[key])
+    if (value) {
+      return {
+        appVersion: stringValue(status.appVersion),
+        buildNumber: stringValue(status.buildNumber),
+        source,
+        version: value,
+      }
+    }
+  }
+
+  return {
+    appVersion: stringValue(status.appVersion),
+    buildNumber: stringValue(status.buildNumber),
+    source: "unknown",
+    version: null,
+  }
+}
+
+function batteryState(status: Partial<PublicGlassesStatus>): BatteryState {
+  const level = typeof status.batteryLevel === "number" && status.batteryLevel >= 0 ? status.batteryLevel : null
+  return {
+    charging: status.charging ?? false,
+    level,
+  }
+}
+
+function connectedGlassesInfo(status: Partial<PublicGlassesStatus>): ConnectedGlassesInfo {
+  return {
+    appVersion: stringValue(status.appVersion),
+    bluetoothName: stringValue(status.bluetoothName),
+    buildNumber: stringValue(status.buildNumber),
+    color: stringValue(status.color),
+    deviceModel: stringValue(status.deviceModel),
+    firmwareVersion: stringValue(status.firmwareVersion),
+    serialNumber: stringValue(status.serialNumber),
+    style: stringValue(status.style),
+  }
+}
+
+function runtimeGlassesState(status: Partial<PublicGlassesStatus>): GlassesRuntimeState {
+  const connection = status.connection ?? createDisconnectedGlassesStatus().connection ?? {state: "disconnected"}
+
+  if (!isConnectedGlassesConnectionStatus(connection)) {
+    return {
+      connected: false,
+      connection,
+      ready: false,
+    }
+  }
+
+  return {
+    battery: batteryState(status),
+    connected: true,
+    connection,
+    device: connectedGlassesInfo(status),
+    firmware: firmwareInfo(status),
+    hotspot: status.hotspot ?? {state: "disabled"},
+    ready: isReadyGlassesConnectionStatus(connection),
+    signal: {
+      strengthDbm: numberValue((status as Record<string, unknown>).signalStrength),
+      updatedAt: numberValue((status as Record<string, unknown>).signalStrengthUpdatedAt),
+    },
+    wifi: status.wifi ?? {state: "disconnected"},
+  }
+}
+
+function phoneSdkState(
+  status: Partial<PublicBluetoothStatus>,
+  defaultDevice: Device | null,
+  galleryMode: GalleryModeState,
+): PhoneSdkRuntimeState {
+  return {
+    currentMic: status.currentMic || null,
+    defaultDevice,
+    galleryMode,
+    lastLog: status.lastLog ?? [],
+    micRanking: status.micRanking ?? [],
+    otherBluetoothConnected: status.otherBtConnected ?? false,
+    searching: status.searching ?? false,
+    searchingController: status.searchingController ?? false,
+    systemMicUnavailable: status.systemMicUnavailable ?? false,
+    wifiScanResults: status.wifiScanResults ?? [],
+  }
+}
+
+function scanController(connection: GlassesConnectionHookResult): ScanController {
+  return {
+    active: connection.scan.scanning,
+    clear: connection.scan.clearResults,
+    devices: connection.scan.devices,
+    error: connection.scan.error,
+    model: connection.scan.model,
+    selectedDevice: connection.scan.selectedDevice,
+    selectDevice: connection.scan.selectDevice,
+    setModel: connection.scan.setModel,
+    start: connection.scan.startScan,
+    stop: connection.scan.stopScan,
+  }
+}
+
+export function useMentraBluetooth(options: UseMentraBluetoothOptions = {}): MentraBluetoothSession {
+  const connection = useGlassesConnection({
+    autoConnectDefault: options.autoConnectDefault,
+    defaultDeviceStorage: options.defaultDeviceStorage,
+    onError: options.onError,
+    scanModel: options.defaultModel ?? DeviceModels.MentraLive,
+    scanTimeoutMs: options.scanTimeoutMs,
+  })
+  const [galleryModeApplying, setGalleryModeApplying] = useState(false)
+  const [galleryModeError, setGalleryModeError] = useState<unknown | null>(null)
+
+  async function setGalleryMode(mode: GalleryMode) {
+    setGalleryModeApplying(true)
+    setGalleryModeError(null)
+    try {
+      await BluetoothSdk.setGalleryMode(mode)
+    } catch (error) {
+      setGalleryModeError(error)
+      options.onError?.(error)
+      throw error
+    } finally {
+      setGalleryModeApplying(false)
+    }
+  }
+
+  const galleryMode: GalleryModeState = {
+    applying: galleryModeApplying,
+    desired: connection.bluetoothStatus.galleryModeAuto === false ? "manual" : "auto",
+    error: galleryModeError,
+  }
+
+  return {
+    busy: connection.busy || galleryModeApplying,
+    clearDefaultDevice: connection.clearDefaultDevice,
+    connect: connection.connect,
+    connectDefault: connection.connectDefault,
+    defaultDevice: connection.defaultDevice,
+    disconnect: connection.disconnect,
+    error: galleryModeError ?? connection.error,
+    glasses: runtimeGlassesState(connection.glassesStatus),
+    refresh: connection.refresh,
+    scan: scanController(connection),
+    sdk: phoneSdkState(connection.bluetoothStatus, connection.defaultDevice, galleryMode),
+    setDefaultDevice: connection.setDefaultDevice,
+    setGalleryMode,
+  }
+}