@mentra/bluetooth-sdk 0.1.4 → 0.1.5

package/ios/Source/MentraBluetoothSDK.swift

@@ -159,8 +159,10 @@ public enum DeviceModel: String {
 public struct Device: Identifiable, Equatable, CustomStringConvertible {
     public let model: DeviceModel
     public let name: String
+    /// CoreBluetooth identifier when available.
     public let identifier: String?
     public let rssi: Int?
+    /// Stable app-facing scan-result key. Do not parse; use typed fields instead.
     public let id: String
 
     public init(
@@ -527,7 +529,7 @@ public struct BluetoothStatus: CustomStringConvertible {
     public var shouldSendPcm: Bool { boolValue(values, "should_send_pcm") ?? false }
     public var shouldSendLc3: Bool { boolValue(values, "should_send_lc3") ?? false }
     public var shouldSendTranscript: Bool { boolValue(values, "should_send_transcript") ?? false }
-    public var bypassVad: Bool { boolValue(values, "bypass_vad") ?? false }
+    public var bypassVad: Bool { boolValue(values, "bypass_vad") ?? true }
     public var offlineCaptionsRunning: Bool { boolValue(values, "offline_captions_running") ?? false }
     public var localSttFallbackActive: Bool { boolValue(values, "local_stt_fallback_active") ?? false }
     public var shouldSendBootingMessage: Bool { boolValue(values, "shouldSendBootingMessage") ?? true }
@@ -1912,6 +1914,109 @@ public struct LocalTranscriptionEvent: CustomStringConvertible {
     }
 }
 
+public struct MicPcmEvent: CustomStringConvertible {
+    public static let sampleRate = 16_000
+    public static let bitsPerSample = 16
+    public static let channels = 1
+    public static let encoding = "pcm_s16le"
+
+    public let pcm: Data
+    public let sampleRate: Int
+    public let bitsPerSample: Int
+    public let channels: Int
+    public let encoding: String
+    public let vadGated: Bool
+    public let values: [String: Any]
+
+    public init(values: [String: Any]) {
+        let pcm = values["pcm"] as? Data ?? Data()
+        let sampleRate = intValue(values["sampleRate"]) ?? Self.sampleRate
+        let bitsPerSample = intValue(values["bitsPerSample"]) ?? Self.bitsPerSample
+        let channels = intValue(values["channels"]) ?? Self.channels
+        let encoding = values["encoding"] as? String ?? Self.encoding
+        let vadGated = boolValue(values, "vadGated") ?? false
+
+        var normalized = values
+        normalized["type"] = "mic_pcm"
+        normalized["pcm"] = pcm
+        normalized["sampleRate"] = sampleRate
+        normalized["bitsPerSample"] = bitsPerSample
+        normalized["channels"] = channels
+        normalized["encoding"] = encoding
+        normalized["vadGated"] = vadGated
+
+        self.pcm = pcm
+        self.sampleRate = sampleRate
+        self.bitsPerSample = bitsPerSample
+        self.channels = channels
+        self.encoding = encoding
+        self.vadGated = vadGated
+        self.values = normalized
+    }
+
+    public var description: String {
+        "MicPcmEvent(bytes: \(pcm.count), sampleRate: \(sampleRate), bitsPerSample: \(bitsPerSample), channels: \(channels), encoding: \(encoding), vadGated: \(vadGated))"
+    }
+}
+
+public struct MicLc3Event: CustomStringConvertible {
+    public static let sampleRate = 16_000
+    public static let channels = 1
+    public static let encoding = "lc3"
+    public static let frameDurationMs = 10
+    public static let defaultFrameSizeBytes = 60
+
+    public let lc3: Data
+    public let sampleRate: Int
+    public let channels: Int
+    public let encoding: String
+    public let frameDurationMs: Int
+    public let frameSizeBytes: Int
+    public let bitrate: Int
+    public let packetizedFromGlasses: Bool
+    public let vadGated: Bool
+    public let values: [String: Any]
+
+    public init(values: [String: Any]) {
+        let lc3 = values["lc3"] as? Data ?? Data()
+        let sampleRate = intValue(values["sampleRate"]) ?? Self.sampleRate
+        let channels = intValue(values["channels"]) ?? Self.channels
+        let encoding = values["encoding"] as? String ?? Self.encoding
+        let frameDurationMs = intValue(values["frameDurationMs"]) ?? Self.frameDurationMs
+        let frameSizeBytes = intValue(values["frameSizeBytes"]) ?? Self.defaultFrameSizeBytes
+        let bitrate = intValue(values["bitrate"]) ?? frameSizeBytes * 8 * (1000 / frameDurationMs)
+        let packetizedFromGlasses = boolValue(values, "packetizedFromGlasses") ?? false
+        let vadGated = boolValue(values, "vadGated") ?? false
+
+        var normalized = values
+        normalized["type"] = "mic_lc3"
+        normalized["lc3"] = lc3
+        normalized["sampleRate"] = sampleRate
+        normalized["channels"] = channels
+        normalized["encoding"] = encoding
+        normalized["frameDurationMs"] = frameDurationMs
+        normalized["frameSizeBytes"] = frameSizeBytes
+        normalized["bitrate"] = bitrate
+        normalized["packetizedFromGlasses"] = packetizedFromGlasses
+        normalized["vadGated"] = vadGated
+
+        self.lc3 = lc3
+        self.sampleRate = sampleRate
+        self.channels = channels
+        self.encoding = encoding
+        self.frameDurationMs = frameDurationMs
+        self.frameSizeBytes = frameSizeBytes
+        self.bitrate = bitrate
+        self.packetizedFromGlasses = packetizedFromGlasses
+        self.vadGated = vadGated
+        self.values = normalized
+    }
+
+    public var description: String {
+        "MicLc3Event(bytes: \(lc3.count), sampleRate: \(sampleRate), channels: \(channels), frameDurationMs: \(frameDurationMs), frameSizeBytes: \(frameSizeBytes), bitrate: \(bitrate), packetizedFromGlasses: \(packetizedFromGlasses), vadGated: \(vadGated))"
+    }
+}
+
 public struct GlassesMediaVolumeGetResult: CustomStringConvertible {
     public let level: Int?
     public let statusCode: Int?
@@ -1989,8 +2094,8 @@ public protocol MentraBluetoothSDKDelegate: AnyObject {
     func mentraBluetoothSDK(_ sdk: MentraBluetoothSDK, didDiscover device: Device)
     func mentraBluetoothSDK(_ sdk: MentraBluetoothSDK, didStopScan reason: ScanStopReason)
     func mentraBluetoothSDK(_ sdk: MentraBluetoothSDK, didReceive event: BluetoothEvent)
-    func mentraBluetoothSDK(_ sdk: MentraBluetoothSDK, didReceiveMicPcm frame: Data)
-    func mentraBluetoothSDK(_ sdk: MentraBluetoothSDK, didReceiveMicLc3 frame: Data)
+    func mentraBluetoothSDK(_ sdk: MentraBluetoothSDK, didReceiveMicPcm event: MicPcmEvent)
+    func mentraBluetoothSDK(_ sdk: MentraBluetoothSDK, didReceiveMicLc3 event: MicLc3Event)
     func mentraBluetoothSDK(_ sdk: MentraBluetoothSDK, didChangeDefaultDevice device: Device?)
     func mentraBluetoothSDK(_ sdk: MentraBluetoothSDK, didLog message: String)
     func mentraBluetoothSDK(_ sdk: MentraBluetoothSDK, didFail error: BluetoothError)
@@ -2003,8 +2108,8 @@ public extension MentraBluetoothSDKDelegate {
     func mentraBluetoothSDK(_: MentraBluetoothSDK, didDiscover _: Device) {}
     func mentraBluetoothSDK(_: MentraBluetoothSDK, didStopScan _: ScanStopReason) {}
     func mentraBluetoothSDK(_: MentraBluetoothSDK, didReceive _: BluetoothEvent) {}
-    func mentraBluetoothSDK(_: MentraBluetoothSDK, didReceiveMicPcm _: Data) {}
-    func mentraBluetoothSDK(_: MentraBluetoothSDK, didReceiveMicLc3 _: Data) {}
+    func mentraBluetoothSDK(_: MentraBluetoothSDK, didReceiveMicPcm _: MicPcmEvent) {}
+    func mentraBluetoothSDK(_: MentraBluetoothSDK, didReceiveMicLc3 _: MicLc3Event) {}
     func mentraBluetoothSDK(_: MentraBluetoothSDK, didChangeDefaultDevice _: Device?) {}
     func mentraBluetoothSDK(_: MentraBluetoothSDK, didLog _: String) {}
     func mentraBluetoothSDK(_: MentraBluetoothSDK, didFail _: BluetoothError) {}
@@ -2298,7 +2403,7 @@ public final class MentraBluetoothSDK {
     public func setMicState(
         enabled: Bool,
         useGlassesMic: Bool = true,
-        bypassVad: Bool = false,
+        bypassVad: Bool = true,
         sendTranscript: Bool = false,
         sendLc3Data: Bool = false
     ) {
@@ -2567,12 +2672,14 @@ public final class MentraBluetoothSDK {
         case "touch_event":
             delegate?.mentraBluetoothSDK(self, didReceive: .touch(TouchEvent(values: data)))
         case "mic_pcm":
-            if let frame = data["pcm"] as? Data {
-                delegate?.mentraBluetoothSDK(self, didReceiveMicPcm: frame)
+            let event = MicPcmEvent(values: data)
+            if !event.pcm.isEmpty {
+                delegate?.mentraBluetoothSDK(self, didReceiveMicPcm: event)
             }
         case "mic_lc3":
-            if let frame = data["lc3"] as? Data {
-                delegate?.mentraBluetoothSDK(self, didReceiveMicLc3: frame)
+            let event = MicLc3Event(values: data)
+            if !event.lc3.isEmpty {
+                delegate?.mentraBluetoothSDK(self, didReceiveMicLc3: event)
             }
         case "local_transcription":
             let event = LocalTranscriptionEvent(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mentra/bluetooth-sdk",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "SDK for communicating with smart glasses",
   "main": "build/index.js",
   "react-native": "src/index.ts",

package/src/BluetoothSdk.types.ts

@@ -295,11 +295,24 @@ export type WsBinEvent = {
 export type MicPcmEvent = {
   type: "mic_pcm"
   pcm: ArrayBuffer
+  sampleRate: 16000
+  bitsPerSample: 16
+  channels: 1
+  encoding: "pcm_s16le"
+  vadGated: boolean
 }
 
 export type MicLc3Event = {
   type: "mic_lc3"
   lc3: ArrayBuffer
+  sampleRate: 16000
+  channels: 1
+  encoding: "lc3"
+  frameDurationMs: 10
+  frameSizeBytes: number
+  bitrate: number
+  packetizedFromGlasses: boolean
+  vadGated: boolean
 }
 
 export type StreamStatusLifecycleState = "initializing" | "streaming" | "stopping" | "stopped"
@@ -381,7 +394,7 @@ export type OtaUpdateAvailableEvent = {
   cache_ready?: boolean
 }
 
-/** @deprecated Glasses no longer emit ota_progress; use {@link OtaStatusEvent} and legacy store mapping. */
+/** @deprecated Glasses no longer emit ota_progress; use {@link OtaStatusEvent} and status-store mapping. */
 export type OtaProgressEvent = {
   type: "ota_progress"
   stage?: OtaStage
@@ -491,8 +504,6 @@ export type PublicBluetoothStatus = Pick<
 >
 
 export type BluetoothSdkEventMap = {
-  glasses_status: Partial<PublicGlassesStatus>
-  bluetooth_status: Partial<PublicBluetoothStatus>
   log: LogEvent
   device_discovered: Device
   default_device_changed: {device?: Device}
@@ -540,8 +551,6 @@ export interface BluetoothSdkPublicModule {
     listener: BluetoothSdkEventListener<EventName>,
   ): BluetoothSdkSubscription
 
-  getGlassesStatus(): Promise<PublicGlassesStatus>
-  getBluetoothStatus(): Promise<PublicBluetoothStatus>
   getDefaultDevice(): Promise<Device | null>
   setDefaultDevice(device: Device | null): Promise<void>
   clearDefaultDevice(): Promise<void>
@@ -614,8 +623,6 @@ export interface BluetoothSdkPublicModule {
   ): Promise<void>
 
   requestVersionInfo(): Promise<void>
-  onGlassesStatus(callback: (changed: Partial<PublicGlassesStatus>) => void): () => void
-  onBluetoothStatus(callback: (changed: Partial<PublicBluetoothStatus>) => void): () => void
 }
 
 // OTA update status types
@@ -711,9 +718,15 @@ export interface CoreSettings {
 }
 
 export interface Device {
+  /**
+   * Stable app-facing key for this scan result, within the limits of the
+   * platform identifier available to the SDK. Do not parse this value; use the
+   * typed model, name, address, and rssi fields instead.
+   */
   id: string
   model: DeviceModel
   name: string
+  /** Platform address/identifier when available: Android Bluetooth address, iOS CoreBluetooth identifier. */
   address?: string
   rssi?: number
 }

package/src/_internal.ts

@@ -1,7 +1,7 @@
 /**
  * MentraOS-only compatibility entrypoint.
  *
- * Partner apps should import from `@mentra/bluetooth-sdk`. This file is not a
+ * Apps should import from `@mentra/bluetooth-sdk`. This file is not a
  * package export; MentraOS resolves it through its local
  * `@mentra/bluetooth-sdk-internal` alias while the app is migrated onto the
  * public SDK surface.

package/src/_private/BluetoothSdkModule.ts

@@ -20,6 +20,7 @@ import {
   ObservableStoreCategory,
   PhotoCompression,
   PhotoSize,
+  PublicBluetoothStatus,
   RgbLedAction,
   RgbLedColor,
   ScanModelOptions,
@@ -33,17 +34,18 @@ import {
  *
  * This file intentionally lives under `_private` so the package root can expose
  * a small SDK surface while MentraOS uses its monorepo-only internal alias
- * during migration.
+ * during migration. Raw status getters/listeners stay here so React hooks can
+ * shape native store snapshots before app code sees them.
  */
 
 type GlassesListener = (changed: Partial<GlassesStatus>) => void
-type BluetoothStatusListener = (changed: Partial<BluetoothStatus>) => void
+type BluetoothStatusListener = (changed: Partial<PublicBluetoothStatus>) => void
 type MaybePromise<T> = T | Promise<T>
 
 declare class BluetoothSdkNativeModule extends NativeModule<BluetoothSdkModuleEvents> {
   // Observable Store Functions (native)
   getGlassesStatus(): Promise<GlassesStatus>
-  getBluetoothStatus(): Promise<BluetoothStatus>
+  getBluetoothStatus(): Promise<PublicBluetoothStatus>
   getDefaultDevice(): Promise<Device | null>
   update(category: ObservableStoreCategory, values: object): Promise<void>
 
@@ -194,7 +196,7 @@ const CAMERA_FOV_SETTINGS: Record<CameraFov, CameraFovSetting> = {
   wide: {fov: 118, roiPosition: 0},
 }
 
-function searchResultsForModel(status: Partial<BluetoothStatus>, model: DeviceModel): Device[] {
+function searchResultsForModel(status: Partial<PublicBluetoothStatus>, model: DeviceModel): Device[] {
   return status.searchResults?.filter((device) => device.model === model) ?? []
 }
 
@@ -388,7 +390,7 @@ NativeBluetoothSdkModule.setMicState = function (
     nativeSetMicState(
       enabled,
       useGlassesMic ?? true,
-      bypassVad ?? false,
+      bypassVad ?? true,
       sendTranscript ?? false,
       sendLc3Data ?? false,
     ),

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

@@ -8,15 +8,17 @@ export {
   type BluetoothScanHookResult,
   type UseBluetoothScanOptions,
 } from "./useBluetoothScan"
+export type {DefaultDeviceStorage} from "./useGlassesConnection"
 export {
-  useBluetoothStatus,
-  type BluetoothStatusHookResult,
-  type UseBluetoothStatusOptions,
-} from "./useBluetoothStatus"
-export {
-  useGlassesConnection,
-  type DefaultDeviceStorage,
-  type GlassesConnectionAction,
-  type GlassesConnectionHookResult,
-  type UseGlassesConnectionOptions,
-} from "./useGlassesConnection"
+  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/useBluetoothStatus.ts

@@ -1,6 +1,6 @@
 import {useEffect, useRef, useState} from "react"
 
-import BluetoothSdk from "../index"
+import BluetoothSdk from "../_private/BluetoothSdkModule"
 import {
   createDisconnectedGlassesStatus,
   isConnectedGlassesConnectionStatus,

package/src/react/useGlassesConnection.ts

@@ -96,6 +96,21 @@ export function useGlassesConnection(
     }
   }, [])
 
+  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