@glassly/bluetooth-sdk 0.1.0-dev.26

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,
+  }
+}

package/src/react/useGlassesConnection.ts

@@ -0,0 +1,202 @@
+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/types/index.ts

@@ -0,0 +1,12 @@
+export {
+  isBusyGlassesConnectionStatus,
+  isConnectedGlassesConnectionStatus,
+  isReadyGlassesConnectionStatus,
+} from "../BluetoothSdk.types"
+
+export type {
+  ConnectedGlassesConnectionStatus,
+  GlassesConnectionStatus,
+  SpeakerEnrollProgressEvent,
+  SpeakerEnrollResultEvent,
+} from "../BluetoothSdk.types"