@mentra/bluetooth-sdk 0.1.3 → 0.1.5

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

@@ -0,0 +1,24 @@
+export {
+  useBluetoothEvent,
+  type UseBluetoothEventOptions,
+} from "./useBluetoothEvent"
+export {
+  useBluetoothScan,
+  type BluetoothScanDedupe,
+  type BluetoothScanHookResult,
+  type UseBluetoothScanOptions,
+} from "./useBluetoothScan"
+export type {DefaultDeviceStorage} from "./useGlassesConnection"
+export {
+  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/useBluetoothEvent.ts

@@ -0,0 +1,38 @@
+import {useEffect, useRef} from "react"
+
+import BluetoothSdk from "../index"
+import type {
+  BluetoothSdkEventListener,
+  BluetoothSdkEventName,
+} from "../BluetoothSdk.types"
+
+export type UseBluetoothEventOptions = {
+  enabled?: boolean
+}
+
+export function useBluetoothEvent<EventName extends BluetoothSdkEventName>(
+  eventName: EventName,
+  listener: BluetoothSdkEventListener<EventName>,
+  options: UseBluetoothEventOptions = {},
+): void {
+  const enabled = options.enabled ?? true
+  const listenerRef = useRef(listener)
+
+  useEffect(() => {
+    listenerRef.current = listener
+  }, [listener])
+
+  useEffect(() => {
+    if (!enabled) {
+      return undefined
+    }
+
+    const subscription = BluetoothSdk.addListener(eventName, (event) => {
+      listenerRef.current(event)
+    })
+
+    return () => {
+      subscription.remove()
+    }
+  }, [enabled, eventName])
+}

package/src/react/useBluetoothScan.ts

@@ -0,0 +1,173 @@
+import {useEffect, useRef, useState} from "react"
+
+import BluetoothSdk, {DeviceModels} from "../index"
+import type {Device, DeviceModel} from "../BluetoothSdk.types"
+
+export type BluetoothScanDedupe = "id" | "name" | ((device: Device) => string)
+
+export type UseBluetoothScanOptions = {
+  dedupe?: BluetoothScanDedupe
+  model?: DeviceModel
+  onError?: (error: unknown) => void
+  timeoutMs?: number
+}
+
+export type BluetoothScanHookResult = {
+  clearResults: () => void
+  devices: Device[]
+  error: unknown | null
+  model: DeviceModel
+  scanning: boolean
+  selectedDevice: Device | null
+  selectDevice: (device: Device | null) => void
+  setModel: (model: DeviceModel) => void
+  startScan: (model?: DeviceModel) => Promise<Device[]>
+  stopScan: () => Promise<void>
+}
+
+function dedupeKey(device: Device, dedupe: BluetoothScanDedupe): string {
+  if (typeof dedupe === "function") {
+    return dedupe(device)
+  }
+  if (dedupe === "name") {
+    return `${device.model}:${device.name}`
+  }
+  return device.id
+}
+
+function dedupeDevices(devices: Device[], dedupe: BluetoothScanDedupe): Device[] {
+  const seen = new Set<string>()
+  const nextDevices: Device[] = []
+
+  devices.forEach((device) => {
+    const key = dedupeKey(device, dedupe)
+    if (seen.has(key)) {
+      return
+    }
+    seen.add(key)
+    nextDevices.push(device)
+  })
+
+  return nextDevices
+}
+
+function hasDevice(devices: Device[], selectedDevice: Device | null, dedupe: BluetoothScanDedupe): boolean {
+  if (!selectedDevice) {
+    return true
+  }
+  const selectedKey = dedupeKey(selectedDevice, dedupe)
+  return devices.some((device) => dedupeKey(device, dedupe) === selectedKey)
+}
+
+export function useBluetoothScan(options: UseBluetoothScanOptions = {}): BluetoothScanHookResult {
+  const [devices, setDevices] = useState<Device[]>([])
+  const [error, setError] = useState<unknown | null>(null)
+  const [model, setModelState] = useState<DeviceModel>(options.model ?? DeviceModels.MentraLive)
+  const [scanning, setScanning] = useState(false)
+  const [selectedDevice, selectDevice] = useState<Device | null>(null)
+  const activeScanRef = useRef(0)
+  const dedupeRef = useRef<BluetoothScanDedupe>(options.dedupe ?? "id")
+  const onErrorRef = useRef(options.onError)
+  const scanningRef = useRef(false)
+  const timeoutMsRef = useRef(options.timeoutMs)
+
+  useEffect(() => {
+    dedupeRef.current = options.dedupe ?? "id"
+    onErrorRef.current = options.onError
+    timeoutMsRef.current = options.timeoutMs
+  }, [options.dedupe, options.onError, options.timeoutMs])
+
+  useEffect(() => {
+    scanningRef.current = scanning
+  }, [scanning])
+
+  useEffect(() => {
+    if (!hasDevice(devices, selectedDevice, dedupeRef.current)) {
+      selectDevice(null)
+    }
+  }, [devices, selectedDevice])
+
+  useEffect(() => {
+    return () => {
+      if (!scanningRef.current) {
+        return
+      }
+      activeScanRef.current += 1
+      void BluetoothSdk.stopScan().catch(() => undefined)
+    }
+  }, [])
+
+  function clearResults() {
+    setDevices([])
+    selectDevice(null)
+  }
+
+  function setModel(nextModel: DeviceModel) {
+    setModelState(nextModel)
+    clearResults()
+  }
+
+  async function startScan(nextModel?: DeviceModel): Promise<Device[]> {
+    const scanId = activeScanRef.current + 1
+    activeScanRef.current = scanId
+    const scanModel = nextModel ?? model
+    if (nextModel && nextModel !== model) {
+      setModelState(nextModel)
+    }
+
+    setError(null)
+    setScanning(true)
+    scanningRef.current = true
+    setDevices([])
+    selectDevice(null)
+
+    try {
+      const nextDevices = await BluetoothSdk.scan(scanModel, {
+        ...(timeoutMsRef.current == null ? {} : {timeoutMs: timeoutMsRef.current}),
+        onResults: (results) => {
+          if (activeScanRef.current !== scanId) {
+            return
+          }
+          setDevices(dedupeDevices(results, dedupeRef.current))
+        },
+      })
+      const finalDevices = dedupeDevices(nextDevices, dedupeRef.current)
+      if (activeScanRef.current === scanId) {
+        setDevices(finalDevices)
+        setError(null)
+      }
+      return finalDevices
+    } catch (nextError) {
+      if (activeScanRef.current === scanId) {
+        setError(nextError)
+        onErrorRef.current?.(nextError)
+      }
+      throw nextError
+    } finally {
+      if (activeScanRef.current === scanId) {
+        setScanning(false)
+        scanningRef.current = false
+      }
+    }
+  }
+
+  async function stopScan() {
+    activeScanRef.current += 1
+    setScanning(false)
+    scanningRef.current = false
+    await BluetoothSdk.stopScan()
+  }
+
+  return {
+    clearResults,
+    devices,
+    error,
+    model,
+    scanning,
+    selectedDevice,
+    selectDevice,
+    setModel,
+    startScan,
+    stopScan,
+  }
+}

package/src/react/useBluetoothStatus.ts

@@ -0,0 +1,180 @@
+import {useEffect, useRef, useState} from "react"
+
+import BluetoothSdk from "../_private/BluetoothSdkModule"
+import {
+  createDisconnectedGlassesStatus,
+  isConnectedGlassesConnectionStatus,
+  isReadyGlassesConnectionStatus,
+} from "../BluetoothSdk.types"
+import type {
+  BatteryStatusEvent,
+  HotspotStatus,
+  HotspotStatusChangeEvent,
+  PublicBluetoothStatus,
+  PublicGlassesStatus,
+  WifiStatus,
+  WifiStatusChangeEvent,
+} from "../BluetoothSdk.types"
+
+export type UseBluetoothStatusOptions = {
+  enabled?: boolean
+  onError?: (error: unknown) => void
+}
+
+export type BluetoothStatusHookResult = {
+  bluetoothStatus: Partial<PublicBluetoothStatus>
+  connected: boolean
+  error: unknown | null
+  glassesStatus: Partial<PublicGlassesStatus>
+  loading: boolean
+  ready: boolean
+  refresh: () => Promise<void>
+}
+
+function wifiStatusFromEvent(event: WifiStatusChangeEvent): WifiStatus {
+  switch (event.state) {
+    case "connected":
+      return {state: "connected", ssid: event.ssid, localIp: event.localIp}
+    case "disconnected":
+      return {state: "disconnected"}
+  }
+}
+
+function hotspotStatusFromEvent(event: HotspotStatusChangeEvent): HotspotStatus {
+  if (event.state === "enabled") {
+    return {
+      state: "enabled",
+      ssid: event.ssid,
+      password: event.password,
+      localIp: event.localIp,
+    }
+  }
+  return {state: event.state}
+}
+
+function mergeGlassesStatus(
+  current: Partial<PublicGlassesStatus>,
+  changed: Partial<PublicGlassesStatus>,
+): Partial<PublicGlassesStatus> {
+  if (changed.connection?.state === "disconnected") {
+    return {...createDisconnectedGlassesStatus(), ...changed}
+  }
+  return {...current, ...changed}
+}
+
+export function useBluetoothStatus(options: UseBluetoothStatusOptions = {}): BluetoothStatusHookResult {
+  const enabled = options.enabled ?? true
+  const onErrorRef = useRef(options.onError)
+  const [bluetoothStatus, setBluetoothStatus] = useState<Partial<PublicBluetoothStatus>>({})
+  const [error, setError] = useState<unknown | null>(null)
+  const [glassesStatus, setGlassesStatus] = useState<Partial<PublicGlassesStatus>>(() =>
+    createDisconnectedGlassesStatus(),
+  )
+  const [loading, setLoading] = useState(enabled)
+
+  useEffect(() => {
+    onErrorRef.current = options.onError
+  }, [options.onError])
+
+  async function refresh() {
+    setLoading(true)
+    try {
+      const [nextGlassesStatus, nextBluetoothStatus] = await Promise.all([
+        BluetoothSdk.getGlassesStatus(),
+        BluetoothSdk.getBluetoothStatus(),
+      ])
+      setGlassesStatus(nextGlassesStatus)
+      setBluetoothStatus(nextBluetoothStatus)
+      setError(null)
+    } catch (nextError) {
+      setError(nextError)
+      onErrorRef.current?.(nextError)
+    } finally {
+      setLoading(false)
+    }
+  }
+
+  useEffect(() => {
+    if (!enabled) {
+      setLoading(false)
+      return undefined
+    }
+
+    let mounted = true
+
+    const loadInitialStatus = async () => {
+      setLoading(true)
+      try {
+        const [nextGlassesStatus, nextBluetoothStatus] = await Promise.all([
+          BluetoothSdk.getGlassesStatus(),
+          BluetoothSdk.getBluetoothStatus(),
+        ])
+        if (!mounted) {
+          return
+        }
+        setGlassesStatus(nextGlassesStatus)
+        setBluetoothStatus(nextBluetoothStatus)
+        setError(null)
+      } catch (nextError) {
+        if (!mounted) {
+          return
+        }
+        setError(nextError)
+        onErrorRef.current?.(nextError)
+      } finally {
+        if (mounted) {
+          setLoading(false)
+        }
+      }
+    }
+
+    void loadInitialStatus()
+
+    const removeGlasses = BluetoothSdk.onGlassesStatus((changed) => {
+      setGlassesStatus((current) => mergeGlassesStatus(current, changed))
+    })
+    const removeBluetooth = BluetoothSdk.onBluetoothStatus((changed) => {
+      setBluetoothStatus((current) => ({...current, ...changed}))
+    })
+    const batterySubscription = BluetoothSdk.addListener("battery_status", (event: BatteryStatusEvent) => {
+      setGlassesStatus((current) => ({
+        ...current,
+        batteryLevel: event.level,
+        charging: event.charging,
+      }))
+    })
+    const wifiSubscription = BluetoothSdk.addListener("wifi_status_change", (event) => {
+      setGlassesStatus((current) => ({...current, wifi: wifiStatusFromEvent(event)}))
+    })
+    const hotspotSubscription = BluetoothSdk.addListener("hotspot_status_change", (event) => {
+      setGlassesStatus((current) => ({...current, hotspot: hotspotStatusFromEvent(event)}))
+    })
+    const hotspotErrorSubscription = BluetoothSdk.addListener("hotspot_error", () => {
+      setGlassesStatus((current) => ({...current, hotspot: {state: "disabled"}}))
+    })
+
+    return () => {
+      mounted = false
+      removeGlasses()
+      removeBluetooth()
+      batterySubscription.remove()
+      wifiSubscription.remove()
+      hotspotSubscription.remove()
+      hotspotErrorSubscription.remove()
+    }
+  }, [enabled])
+
+  const connection = glassesStatus.connection
+  const connected = connection ? isConnectedGlassesConnectionStatus(connection) : false
+  const ready = connection ? isReadyGlassesConnectionStatus(connection) : false
+
+  return {
+    bluetoothStatus,
+    connected,
+    error,
+    glassesStatus,
+    loading,
+    ready,
+    refresh,
+  }
+}