@mentra/bluetooth-sdk 0.1.0 → 0.1.2

package/src/BluetoothSdkModule.ts

@@ -1,15 +1,23 @@
 import {NativeModule, requireNativeModule} from "expo"
 
 import {
-  ConnectOptions,
+  BluetoothSettingsUpdate,
   BluetoothSdkModuleEvents,
   BluetoothStatus,
-  DeviceScanRequest,
-  GalleryMode,
+  ButtonPhotoSize,
+  CameraFov,
+  CameraFovSetting,
+  ConnectFirstOptions,
+  ConnectOptions,
+  DashboardMenuItem,
   Device,
+  DeviceModel,
+  GalleryMode,
   GlassesMediaVolumeGetResult,
   GlassesMediaVolumeSetResult,
   GlassesStatus,
+  MicPreference,
+  ObservableStoreCategory,
   PhotoCompression,
   PhotoSize,
   RgbLedAction,
@@ -27,11 +35,11 @@ declare class BluetoothSdkModule extends NativeModule<BluetoothSdkModuleEvents>
   getGlassesStatus(): Promise<GlassesStatus>
   getBluetoothStatus(): Promise<BluetoothStatus>
   getDefaultDevice(): Promise<Device | null>
-  update(category: string, values: Record<string, any>): Promise<void>
+  update(category: ObservableStoreCategory, values: object): Promise<void>
 
   // Display Commands
-  displayEvent(params: Record<string, any>): Promise<void>
-  displayText(params: Record<string, any>): Promise<void>
+  displayEvent(params: Record<string, unknown>): Promise<void>
+  displayText(text: string, x?: number, y?: number, size?: number): Promise<void>
   clearDisplay(): Promise<void>
 
   // Connection Commands
@@ -40,7 +48,8 @@ declare class BluetoothSdkModule extends NativeModule<BluetoothSdkModuleEvents>
   connectDefaultWithOptions(options: Required<ConnectOptions>): Promise<void>
   setDefaultDevice(device: Device | null): Promise<void>
   clearDefaultDevice(): Promise<void>
-  startScan(params: DeviceScanRequest): Promise<void>
+  startScan(model: DeviceModel): Promise<void>
+  connectFirst(model: DeviceModel, options?: ConnectFirstOptions): Promise<Device>
   connect(device: Device, options?: ConnectOptions): Promise<void>
   connectWithOptions(device: Device, options: Required<ConnectOptions>): Promise<void>
   cancelConnectionAttempt(): Promise<void>
@@ -51,6 +60,12 @@ declare class BluetoothSdkModule extends NativeModule<BluetoothSdkModuleEvents>
   forget(): Promise<void>
   forgetController(): Promise<void>
   showDashboard(): Promise<void>
+  setBrightness(level: number, autoMode?: boolean | null): Promise<void>
+  setAutoBrightness(enabled: boolean): Promise<void>
+  setDashboardPosition(height: number, depth: number): Promise<void>
+  setDashboardMenu(items: DashboardMenuItem[]): Promise<void>
+  setHeadUpAngle(angleDegrees: number): Promise<void>
+  setScreenDisabled(disabled: boolean): Promise<void>
   ping(): Promise<void>
   dbg1(): Promise<void>
   dbg2(): Promise<void>
@@ -68,6 +83,11 @@ declare class BluetoothSdkModule extends NativeModule<BluetoothSdkModuleEvents>
 
   // Gallery Commands
   setGalleryMode(mode: GalleryMode): Promise<void>
+  setButtonPhotoSettings(size: ButtonPhotoSize): Promise<void>
+  setButtonVideoRecordingSettings(width: number, height: number, fps: number): Promise<void>
+  setButtonCameraLed(enabled: boolean): Promise<void>
+  setButtonMaxRecordingTime(minutes: number): Promise<void>
+  setCameraFov(fov: CameraFov): Promise<void>
   queryGalleryStatus(): Promise<void>
   photoRequest(
     requestId: string,
@@ -97,7 +117,14 @@ declare class BluetoothSdkModule extends NativeModule<BluetoothSdkModuleEvents>
   keepStreamAlive(params: StreamKeepAliveRequest): Promise<void>
 
   // Microphone Commands
-  setMicState(sendPcmData: boolean, sendTranscript: boolean, bypassVad: boolean): Promise<void>
+  setMicState(
+    enabled: boolean,
+    useGlassesMic?: boolean,
+    bypassVad?: boolean,
+    sendTranscript?: boolean,
+    sendLc3Data?: boolean,
+  ): Promise<void>
+  setPreferredMic(preferredMic: MicPreference): Promise<void>
   restartTranscriber(): Promise<void>
 
   // Audio Playback Monitoring
@@ -130,7 +157,7 @@ declare class BluetoothSdkModule extends NativeModule<BluetoothSdkModuleEvents>
 
   // Helper methods for type-safe observable store access
   updateGlasses(values: Partial<GlassesStatus>): Promise<void>
-  updateBluetoothSettings(values: Record<string, any>): Promise<void>
+  updateBluetoothSettings(values: BluetoothSettingsUpdate): Promise<void>
   onGlassesStatus(callback: GlassesListener): () => void
   onBluetoothStatus(callback: BluetoothStatusListener): () => void
 
@@ -147,7 +174,26 @@ const DEFAULT_CONNECT_OPTIONS: Required<ConnectOptions> = {
   cancelExistingConnectionAttempt: true,
 }
 
-function adaptConnectionStatusToNative(connection: GlassesStatus["connection"]): Record<string, any> {
+const DEFAULT_CONNECT_FIRST_TIMEOUT_MS = 15_000
+
+const CAMERA_FOV_SETTINGS: Record<CameraFov, CameraFovSetting> = {
+  standard: {fov: 118, roi_position: 0},
+  wide: {fov: 118, roi_position: 0},
+}
+
+function findSearchResult(status: Partial<BluetoothStatus>, model: DeviceModel): Device | null {
+  return status.searchResults?.find((device) => device.model === model) ?? null
+}
+
+function dashboardMenuItemToNative(item: DashboardMenuItem): Record<string, unknown> {
+  return {
+    ...(item.values ?? {}),
+    title: item.title,
+    packageName: item.packageName,
+  }
+}
+
+function adaptConnectionStatusToNative(connection: GlassesStatus["connection"]): Record<string, unknown> {
   switch (connection.state) {
     case "connected":
       return {connectionState: "CONNECTED", connected: true, fullyBooted: connection.fullyBooted}
@@ -162,9 +208,9 @@ function adaptConnectionStatusToNative(connection: GlassesStatus["connection"]):
   }
 }
 
-function adaptGlassesUpdateToNative(values: Partial<GlassesStatus>): Record<string, any> {
+function adaptGlassesUpdateToNative(values: Partial<GlassesStatus>): Record<string, unknown> {
   const {wifi, hotspot, connection, ...rest} = values
-  let update: Record<string, any> = {...rest}
+  let update: Record<string, unknown> = {...rest}
   if (connection) {
     update = {
       ...update,
@@ -226,14 +272,109 @@ NativeBluetoothSdkModule.getDefaultDevice = function () {
   return Promise.resolve(nativeGetDefaultDevice())
 }
 
+const nativeSetMicState = NativeBluetoothSdkModule.setMicState.bind(NativeBluetoothSdkModule) as (
+  enabled: boolean,
+  useGlassesMic: boolean,
+  bypassVad: boolean,
+  sendTranscript: boolean,
+  sendLc3Data: boolean,
+) => MaybePromise<void>
+
+const nativeDisplayText = NativeBluetoothSdkModule.displayText.bind(NativeBluetoothSdkModule) as (
+  text: string,
+  x: number,
+  y: number,
+  size: number,
+) => MaybePromise<void>
+
 NativeBluetoothSdkModule.updateGlasses = function (values: Partial<GlassesStatus>) {
   return this.update("glasses", adaptGlassesUpdateToNative(values))
 }
 
-NativeBluetoothSdkModule.updateBluetoothSettings = function (values: Record<string, any>) {
+NativeBluetoothSdkModule.updateBluetoothSettings = function (values: BluetoothSettingsUpdate) {
   return this.update("bluetooth", values)
 }
 
+NativeBluetoothSdkModule.displayText = function (text: string, x?: number, y?: number, size?: number) {
+  return Promise.resolve(nativeDisplayText(text, x ?? 0, y ?? 0, size ?? 24))
+}
+
+NativeBluetoothSdkModule.setBrightness = function (level: number, autoMode?: boolean | null) {
+  return this.updateBluetoothSettings({
+    ...(autoMode == null ? {} : {auto_brightness: autoMode}),
+    brightness: level,
+  })
+}
+
+NativeBluetoothSdkModule.setAutoBrightness = function (enabled: boolean) {
+  return this.updateBluetoothSettings({auto_brightness: enabled})
+}
+
+NativeBluetoothSdkModule.setDashboardPosition = function (height: number, depth: number) {
+  return this.updateBluetoothSettings({
+    dashboard_height: height,
+    dashboard_depth: depth,
+  })
+}
+
+NativeBluetoothSdkModule.setDashboardMenu = function (items: DashboardMenuItem[]) {
+  return this.updateBluetoothSettings({menu_apps: items.map(dashboardMenuItemToNative)})
+}
+
+NativeBluetoothSdkModule.setHeadUpAngle = function (angleDegrees: number) {
+  return this.updateBluetoothSettings({head_up_angle: angleDegrees})
+}
+
+NativeBluetoothSdkModule.setScreenDisabled = function (disabled: boolean) {
+  return this.updateBluetoothSettings({screen_disabled: disabled})
+}
+
+NativeBluetoothSdkModule.setButtonPhotoSettings = function (size: ButtonPhotoSize) {
+  return this.updateBluetoothSettings({button_photo_size: size})
+}
+
+NativeBluetoothSdkModule.setButtonVideoRecordingSettings = function (width: number, height: number, fps: number) {
+  return this.updateBluetoothSettings({
+    button_video_width: width,
+    button_video_height: height,
+    button_video_fps: fps,
+  })
+}
+
+NativeBluetoothSdkModule.setButtonCameraLed = function (enabled: boolean) {
+  return this.updateBluetoothSettings({button_camera_led: enabled})
+}
+
+NativeBluetoothSdkModule.setButtonMaxRecordingTime = function (minutes: number) {
+  return this.updateBluetoothSettings({button_max_recording_time: minutes})
+}
+
+NativeBluetoothSdkModule.setCameraFov = function (fov: CameraFov) {
+  return this.updateBluetoothSettings({camera_fov: CAMERA_FOV_SETTINGS[fov]})
+}
+
+NativeBluetoothSdkModule.setMicState = function (
+  enabled: boolean,
+  useGlassesMic?: boolean,
+  bypassVad?: boolean,
+  sendTranscript?: boolean,
+  sendLc3Data?: boolean,
+) {
+  return Promise.resolve(
+    nativeSetMicState(
+      enabled,
+      useGlassesMic ?? true,
+      bypassVad ?? false,
+      sendTranscript ?? false,
+      sendLc3Data ?? false,
+    ),
+  )
+}
+
+NativeBluetoothSdkModule.setPreferredMic = function (preferredMic: MicPreference) {
+  return this.updateBluetoothSettings({preferred_mic: preferredMic})
+}
+
 NativeBluetoothSdkModule.onGlassesStatus = function (callback: GlassesListener) {
   const subscription = this.addListener("glasses_status", callback)
   return () => subscription.remove()
@@ -256,4 +397,57 @@ NativeBluetoothSdkModule.connect = function (device: Device, options?: ConnectOp
   return this.connectWithOptions(device, {...DEFAULT_CONNECT_OPTIONS, ...options})
 }
 
+NativeBluetoothSdkModule.connectFirst = async function (model: DeviceModel, options?: ConnectFirstOptions) {
+  const {timeoutMs = DEFAULT_CONNECT_FIRST_TIMEOUT_MS, ...connectOptions} = options ?? {}
+
+  const device = await new Promise<Device>((resolve, reject) => {
+    let timeout: ReturnType<typeof setTimeout> | null = null
+    let removeBluetoothListener = () => {}
+    let settled = false
+
+    const cleanup = () => {
+      if (timeout) {
+        clearTimeout(timeout)
+      }
+      removeBluetoothListener()
+    }
+
+    const settle = (error: Error | null, result?: Device) => {
+      if (settled) {
+        return
+      }
+      settled = true
+      cleanup()
+      if (error) {
+        reject(error)
+      } else if (result) {
+        resolve(result)
+      }
+    }
+
+    const handleBluetoothStatus = (status: Partial<BluetoothStatus>) => {
+      const result = findSearchResult(status, model)
+      if (result) {
+        settle(null, result)
+      }
+    }
+
+    removeBluetoothListener = this.onBluetoothStatus(handleBluetoothStatus)
+
+    if (Number.isFinite(timeoutMs) && timeoutMs > 0) {
+      timeout = setTimeout(() => {
+        settle(new Error(`Timed out after ${timeoutMs}ms while scanning for ${model}.`))
+      }, timeoutMs)
+    }
+
+    Promise.resolve(this.startScan(model))
+      .then(() => this.getBluetoothStatus())
+      .then(handleBluetoothStatus)
+      .catch((error) => settle(error instanceof Error ? error : new Error(String(error))))
+  })
+
+  await this.connect(device, connectOptions)
+  return device
+}
+
 export default NativeBluetoothSdkModule