@glassly/bluetooth-sdk 0.1.0-dev.26

package/src/ota-transport/index.ts

@@ -0,0 +1,116 @@
+// This public adapter is the package-owned boundary over its native implementation.
+// eslint-disable-next-line no-restricted-imports
+import LocalNetwork from "../_private/LocalNetworkModule"
+// eslint-disable-next-line no-restricted-imports
+import OtaServer from "../ota-server"
+
+export type OtaTransportSubscription = {remove(): void}
+
+export type OtaLocalNetworkConnection = {
+  connected: boolean
+  ssid: string
+  localAddress?: string
+}
+
+export type OtaLocalNetworkLostEvent = {ssid: string}
+
+export type OtaLocalNetworkResponse = {
+  status: number
+  headers: Record<string, string>
+  bodyBase64: string
+}
+
+export type OtaLocalNetworkDownloadResult = {
+  statusCode: number
+  bytesWritten: number
+  headers: Record<string, string>
+}
+
+export type OtaLocalNetworkDownloadProgress = {
+  requestId: string
+  bytesWritten: number
+  contentLength: number
+  statusCode?: number
+  headers?: Record<string, string>
+}
+
+export type OtaArtifactDownloadProgress = {
+  destination: string
+  bytesWritten: number
+  contentLength: number
+}
+
+export type OtaServerResult = {
+  baseUrl: string
+  host: string
+  manifestUrl: string
+  port: number
+}
+
+/**
+ * Scoped networking for traffic that must stay on a Mentra Live hotspot while
+ * the phone's default route remains on cellular or another Wi-Fi network.
+ *
+ * The module is optional because iOS uses its system Wi-Fi join flow instead.
+ */
+export const otaLocalNetwork = Object.freeze({
+  isAvailable: (): boolean => LocalNetwork != null,
+  connect: async (ssid: string, password: string): Promise<OtaLocalNetworkConnection> => {
+    if (!LocalNetwork) throw new Error("Scoped local networking is not available in this native build")
+    return LocalNetwork.connect(ssid, password)
+  },
+  request: async (
+    requestId: string,
+    url: string,
+    method: string,
+    headers: Record<string, string>,
+    body: string | null,
+    timeoutMs: number,
+  ): Promise<OtaLocalNetworkResponse> => {
+    if (!LocalNetwork) throw new Error("Scoped local networking is not available in this native build")
+    return LocalNetwork.request(requestId, url, method, headers, body, timeoutMs)
+  },
+  download: async (
+    requestId: string,
+    url: string,
+    destination: string,
+    headers: Record<string, string>,
+    connectionTimeoutMs: number,
+    readTimeoutMs: number,
+  ): Promise<OtaLocalNetworkDownloadResult> => {
+    if (!LocalNetwork) throw new Error("Scoped local networking is not available in this native build")
+    return LocalNetwork.download(requestId, url, destination, headers, connectionTimeoutMs, readTimeoutMs)
+  },
+  cancel: async (requestId: string): Promise<void> => {
+    if (!LocalNetwork) return
+    await LocalNetwork.cancel(requestId)
+  },
+  disconnect: async (): Promise<void> => {
+    if (!LocalNetwork) return
+    await LocalNetwork.disconnect()
+  },
+  onDownloadProgress: (listener: (event: OtaLocalNetworkDownloadProgress) => void): OtaTransportSubscription => {
+    if (!LocalNetwork) return {remove() {}}
+    return LocalNetwork.addListener("downloadProgress", listener)
+  },
+  onNetworkLost: (listener: (event: OtaLocalNetworkLostEvent) => void): OtaTransportSubscription => {
+    if (!LocalNetwork) return {remove() {}}
+    return LocalNetwork.addListener("networkLost", listener)
+  },
+})
+
+/** Native HTTP server and artifact downloader used by the Engine OTA coordinator. */
+export const otaServer = Object.freeze({
+  start: (
+    manifestJson: string,
+    artifactPaths: Record<string, string>,
+    host?: string | null,
+  ): Promise<OtaServerResult> => OtaServer.startOtaServer(manifestJson, artifactPaths, host),
+  stop: (): Promise<void> => OtaServer.stopOtaServer(),
+  waitForWifiAddress: (gateway: string, timeoutMs: number): Promise<string> =>
+    OtaServer.waitForWifiAddress(gateway, timeoutMs),
+  downloadArtifact: (source: string, destination: string): Promise<{statusCode: number; bytesWritten: number}> =>
+    OtaServer.downloadArtifact(source, destination),
+  onArtifactDownloadProgress: (listener: (event: OtaArtifactDownloadProgress) => void): OtaTransportSubscription =>
+    OtaServer.addListener("artifactDownloadProgress", listener),
+})

package/src/photo-receiver/PhotoReceiver.types.ts

@@ -0,0 +1,20 @@
+export type PhotoReceiverUploadEvent = {
+  byteCount: number
+  fileUri: string
+  requestId?: string | null
+}
+
+export type PhotoReceiverStatusEvent = {
+  message: string
+}
+
+export type PhotoReceiverResult = {
+  host: string
+  port: number
+  uploadUrl: string
+}
+
+export type PhotoReceiverModuleEvents = {
+  photoUpload: (event: PhotoReceiverUploadEvent) => void
+  receiverStatus: (event: PhotoReceiverStatusEvent) => void
+}

package/src/photo-receiver/PhotoReceiverModule.ts

@@ -0,0 +1,11 @@
+import {NativeModule, requireNativeModule} from "expo"
+
+import type {PhotoReceiverModuleEvents, PhotoReceiverResult} from "./PhotoReceiver.types"
+
+declare class PhotoReceiverModule extends NativeModule<PhotoReceiverModuleEvents> {
+  isSupported(): Promise<boolean>
+  startPhotoReceiver(): Promise<PhotoReceiverResult>
+  stopPhotoReceiver(): Promise<void>
+}
+
+export default requireNativeModule<PhotoReceiverModule>("PhotoReceiver")

package/src/photo-receiver/PhotoReceiverModule.web.ts

@@ -0,0 +1,17 @@
+import {NativeModule, registerWebModule} from "expo"
+
+import type {PhotoReceiverModuleEvents, PhotoReceiverResult} from "./PhotoReceiver.types"
+
+class PhotoReceiverModule extends NativeModule<PhotoReceiverModuleEvents> {
+  async isSupported(): Promise<boolean> {
+    return false
+  }
+
+  async startPhotoReceiver(): Promise<PhotoReceiverResult> {
+    throw new Error("The photo receiver is only available in native apps.")
+  }
+
+  async stopPhotoReceiver(): Promise<void> {}
+}
+
+export default registerWebModule(PhotoReceiverModule, "PhotoReceiver")

package/src/photo-receiver/index.ts

@@ -0,0 +1,2 @@
+export {default} from "./PhotoReceiverModule"
+export * from "./PhotoReceiver.types"

package/src/react/index.ts

@@ -0,0 +1,21 @@
+export {useBluetoothEvent, type UseBluetoothEventOptions} from "./useBluetoothEvent"
+export {
+  useBluetoothScan,
+  type BluetoothScanDedupe,
+  type BluetoothScanHookResult,
+  type UseBluetoothScanOptions,
+} from "./useBluetoothScan"
+export type {DefaultDeviceStorage} from "./useGlassesConnection"
+export {
+  useBluetooth,
+  type BatteryState,
+  type ConnectedGlassesInfo,
+  type FirmwareInfo,
+  type GalleryModeState,
+  type GlassesRuntimeState,
+  type BluetoothSession,
+  type PhoneSdkRuntimeState,
+  type ScanController,
+  type SignalState,
+  type UseBluetoothOptions,
+} from "./useBluetooth"

package/src/react/useBluetooth.ts

@@ -0,0 +1,309 @@
+import {useState} from "react"
+
+import BluetoothSdk from "../index"
+import {
+  DEFAULT_VOICE_ACTIVITY_DETECTION_ENABLED,
+  DeviceModels,
+  createDisconnectedGlassesStatus,
+  isConnectedGlassesConnectionStatus,
+  isReadyGlassesConnectionStatus,
+} from "../BluetoothSdk.types"
+import type {
+  ConnectOptions,
+  Device,
+  DeviceModel,
+  GlassesConnectionStatus,
+  HotspotStatus,
+  PublicBluetoothStatus,
+  PublicGlassesStatus,
+  MicMode,
+  SettingsAckSuccessEvent,
+  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
+      voiceActivityDetectionEnabled: boolean
+      wifi: WifiStatus
+    }
+
+export type GalleryModeState = {
+  applying: boolean
+  enabled: boolean
+  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 UseBluetoothOptions = {
+  autoConnectDefault?: boolean
+  defaultDeviceStorage?: DefaultDeviceStorage
+  defaultModel?: DeviceModel
+  onError?: (error: unknown) => void
+  scanTimeoutMs?: number
+}
+
+export type BluetoothSession = {
+  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>
+  setGalleryModeEnabled: (enabled: boolean) => Promise<SettingsAckSuccessEvent>
+  setVoiceActivityDetectionEnabled: (enabled: boolean) => 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),
+    },
+    voiceActivityDetectionEnabled: status.voiceActivityDetectionEnabled ?? DEFAULT_VOICE_ACTIVITY_DETECTION_ENABLED,
+    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 useBluetooth(options: UseBluetoothOptions = {}): BluetoothSession {
+  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 setGalleryModeEnabled(enabled: boolean): Promise<SettingsAckSuccessEvent> {
+    setGalleryModeApplying(true)
+    setGalleryModeError(null)
+    try {
+      return await BluetoothSdk.setGalleryModeEnabled(enabled)
+    } catch (error) {
+      setGalleryModeError(error)
+      options.onError?.(error)
+      throw error
+    } finally {
+      setGalleryModeApplying(false)
+    }
+  }
+
+  async function setVoiceActivityDetectionEnabled(enabled: boolean) {
+    try {
+      await BluetoothSdk.setVoiceActivityDetectionEnabled(enabled)
+    } catch (error) {
+      options.onError?.(error)
+      throw error
+    }
+  }
+
+  const galleryMode: GalleryModeState = {
+    applying: galleryModeApplying,
+    enabled: connection.bluetoothStatus.galleryModeEnabled !== false,
+    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,
+    setGalleryModeEnabled,
+    setVoiceActivityDetectionEnabled,
+  }
+}

package/src/react/useBluetoothEvent.ts

@@ -0,0 +1,35 @@
+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])
+}