@mentra/bluetooth-sdk 0.1.4 → 0.1.6

package/README.md

@@ -91,7 +91,7 @@ Android apps should request the permissions required by the features they use:
 }
 ```
 
-Some Android 12+ devices still require Location permission and Location services before BLE scan callbacks are delivered.
+Some Android 12+ devices require Location permission and Location services before BLE scan callbacks are delivered.
 
 iOS apps should include usage descriptions:
 
@@ -114,13 +114,8 @@ Use `scan()` when your app needs to show a picker. It calls `onResults` every ti
 ```ts
 import BluetoothSdk, {
   DeviceModels,
-  isReadyGlassesConnectionStatus,
 } from '@mentra/bluetooth-sdk'
 
-const removeGlassesListener = BluetoothSdk.onGlassesStatus((status) => {
-  console.log('Glasses status changed', status)
-})
-
 const devices = await BluetoothSdk.scan(DeviceModels.MentraLive, {
   timeoutMs: 10_000,
   onResults: (nextDevices) => {
@@ -128,36 +123,46 @@ const devices = await BluetoothSdk.scan(DeviceModels.MentraLive, {
   },
 })
 
-const device = devices[0]
+const device = await chooseDevice(devices)
 if (!device) {
-  throw new Error('No Mentra Live glasses found')
+  throw new Error('No Mentra Live glasses selected')
 }
 
 await BluetoothSdk.connect(device)
+await BluetoothSdk.requestVersionInfo()
+```
 
-const glasses = await BluetoothSdk.getGlassesStatus()
-if (isReadyGlassesConnectionStatus(glasses.connection)) {
-  await BluetoothSdk.displayText('Hello from Mentra', 0, 0, 24)
-}
+In multi-device environments, present an explicit picker instead of
+auto-connecting to the first nearby device.
 
-removeGlassesListener()
-```
+Mentra Live does not have a display. Use display commands only after gating by
+model capability.
+
+Use `Device.id` as the stable app-facing key for scan rows, selected devices,
+and persisted default devices. Do not parse it for model, name, or address
+information; use the typed `model`, `name`, `address`, and `rssi` fields
+instead. Android commonly uses a Bluetooth address when available, iOS commonly
+uses a CoreBluetooth identifier when available, and the SDK falls back to
+`model:name` when no platform identifier is available.
+
+`Device.rssi` is optional. A device can appear in scan results before the
+platform reports RSSI, so picker UI should handle `undefined` and avoid
+reordering rows just because RSSI metadata arrives later.
 
 ## React Hooks
 
 React Native apps can import optional lifecycle helpers from the `react`
-subpath. The hooks use the same SDK types and still leave commands such as
-`requestPhoto()`, `startStream()`, and `setMicState()` on the root
-`BluetoothSdk` object.
+subpath for common lifecycle plumbing. Use the root `BluetoothSdk` object for
+commands such as `requestPhoto()`, `startStream()`, and `setMicState()`.
 
 ```tsx
 import {Button, Text, View} from 'react-native'
 import {DeviceModels} from '@mentra/bluetooth-sdk'
-import {useBluetoothEvent, useGlassesConnection} from '@mentra/bluetooth-sdk/react'
+import {useBluetoothEvent, useMentraBluetooth} from '@mentra/bluetooth-sdk/react'
 
 export function DeviceScreen() {
-  const glasses = useGlassesConnection({
-    scanModel: DeviceModels.MentraLive,
+  const mentra = useMentraBluetooth({
+    defaultModel: DeviceModels.MentraLive,
     scanTimeoutMs: 10_000,
   })
 
@@ -167,12 +172,12 @@ export function DeviceScreen() {
 
   return (
     <View>
-      <Text>{glasses.connected ? 'Connected' : 'Disconnected'}</Text>
-      <Button disabled={glasses.busy} title="Scan" onPress={() => glasses.scan.startScan()} />
-      {glasses.scan.devices.map((device) => (
-        <Button key={device.id} title={device.name} onPress={() => glasses.connect(device)} />
+      <Text>{mentra.glasses.connected ? 'Connected' : 'Disconnected'}</Text>
+      <Button disabled={mentra.busy} title="Scan" onPress={() => mentra.scan.start()} />
+      {mentra.scan.devices.map((device) => (
+        <Button key={device.id} title={device.name} onPress={() => mentra.connect(device)} />
       ))}
-      <Button disabled={!glasses.connected} title="Disconnect" onPress={glasses.disconnect} />
+      <Button disabled={!mentra.glasses.connected} title="Disconnect" onPress={mentra.disconnect} />
     </View>
   )
 }
@@ -180,10 +185,13 @@ export function DeviceScreen() {
 
 The hooks do not request Android permissions or choose a persistence package for
 you. Ask for permissions in your app before calling scan/connect actions, and
-pass a `defaultDeviceStorage` adapter to `useGlassesConnection` if you want a
+pass a `defaultDeviceStorage` adapter to `useMentraBluetooth` if you want a
 default device to survive app restarts.
 
-React Native status exposes `GlassesStatus.connection` as a discriminated union:
+Use `useMentraBluetooth()` as the React status API for connection, battery,
+Wi-Fi, hotspot, scan, and SDK runtime state.
+
+The React hook exposes `glasses.connection` as a discriminated union:
 
 ```ts
 type GlassesConnectionStatus =
@@ -198,7 +206,7 @@ Use `connection.state` for link progress. `fullyBooted` only exists when `state
 
 ## Default Device
 
-`connectDefault()` connects to the default glasses target currently stored in the SDK. Apps that want this target to survive app restarts should persist the scanned `Device` in app storage and restore it with `setDefaultDevice()` before calling `connectDefault()`.
+`connectDefault()` connects to the default glasses target stored in SDK state. Apps that want this target to survive app restarts should persist the scanned `Device` in app storage and restore it with `setDefaultDevice()` before calling `connectDefault()`.
 
 ```ts
 const savedDevice = await loadSavedDeviceFromYourAppStorage()
@@ -231,7 +239,7 @@ await BluetoothSdk.setGalleryMode('auto')
 await BluetoothSdk.setGalleryMode('manual')
 
 await BluetoothSdk.setPreferredMic('auto')
-await BluetoothSdk.setMicState(true, true, false)
+await BluetoothSdk.setMicState(true)
 await BluetoothSdk.setOwnAppAudioPlaying(false)
 
 await BluetoothSdk.rgbLedControl(
@@ -245,6 +253,8 @@ await BluetoothSdk.rgbLedControl(
 )
 ```
 
+`setMicState(true)` defaults to continuous microphone PCM from the glasses. VAD means Voice Activity Detection; pass `false` as the third argument only when your app intentionally wants VAD-gated microphone events.
+
 ## Photo Upload
 
 ```ts
@@ -285,27 +295,36 @@ Use `rtmp://` or `rtmps://` for RTMP, `srt://` for SRT, and `http://` or `https:
 
 ## Events
 
-```ts
-const subscriptions = [
-  BluetoothSdk.addListener('button_press', (event) => console.log(event)),
-  BluetoothSdk.addListener('touch_event', (event) => console.log(event)),
-  BluetoothSdk.addListener('photo_response', (event) => console.log(event)),
-  BluetoothSdk.addListener('stream_status', (event) => console.log(event)),
-  BluetoothSdk.addListener('mic_pcm', (event) => console.log(event.pcm)),
-]
-
-subscriptions.forEach((subscription) => subscription.remove())
+React Native components should use `useBluetoothEvent()` for hardware events:
+
+```tsx
+import {useBluetoothEvent} from '@mentra/bluetooth-sdk/react'
+
+export function HardwareEventLogger() {
+  useBluetoothEvent('button_press', (event) => console.log(event))
+  useBluetoothEvent('touch_event', (event) => console.log(event))
+  useBluetoothEvent('photo_response', (event) => console.log(event))
+  useBluetoothEvent('stream_status', (event) => console.log(event))
+  useBluetoothEvent('mic_pcm', (event) => {
+    console.log(event.sampleRate, event.bitsPerSample, event.channels, event.encoding)
+    console.log(event.pcm)
+  })
+
+  return null
+}
 ```
 
+For non-React modules, `BluetoothSdk.addListener(...)` is the low-level subscription API. Keep the returned subscription and call `remove()` when the listener is no longer needed.
+
 Common event names include `button_press`, `touch_event`, `head_up`, `battery_status`, `wifi_status_change`, `hotspot_status_change`, `photo_response`, `gallery_status`, `stream_status`, `keep_alive_ack`, `mic_pcm`, `mic_lc3`, `local_transcription`, `rgb_led_control_response`, `audio_connected`, `audio_disconnected`, and `log`.
 
-React Native event payload fields use camelCase. For example, `touch_event` includes `gestureName`, `photo_response` success includes `uploadUrl`, and `gallery_status` includes `hasContent` and `cameraBusy`.
+React Native event payload fields use camelCase. For example, `touch_event` includes `gestureName`, `photo_response` success includes `uploadUrl`, and `gallery_status` includes `hasContent` and `cameraBusy`. `mic_pcm` includes `sampleRate`, `bitsPerSample`, `channels`, `encoding`, and `vadGated`; `mic_lc3` includes `sampleRate`, `channels`, `encoding`, `frameDurationMs`, `frameSizeBytes`, `bitrate`, `packetizedFromGlasses`, and `vadGated`.
 
-Only the documented root import is supported for partner apps. Package subpaths or symbols with a leading underscore are private implementation details and can change without notice.
+Only documented imports are supported for app developers. Undocumented package subpaths or symbols with a leading underscore can change without notice.
 
 ## Local SDK Development
 
-For normal app development, install the published JavaScript package. For SDK development before a package release, install a local checkout and point Metro/native resolution at the same path:
+For normal app development, install the JavaScript package from npm. For SDK source development or release testing, install a local checkout and point Metro/native resolution at the same path:
 
 ```sh
 bun add --no-save /path/to/MentraOS/mobile/modules/bluetooth-sdk

package/android/src/main/java/com/mentra/bluetoothsdk/BluetoothSdkModule.kt

@@ -9,12 +9,20 @@ class BluetoothSdkModule : Module() {
     private var deviceManager: DeviceManager? = null
     private val sdkListener =
             object : MentraBluetoothSdkListener {
-                override fun onGlassesStatusChanged(status: GlassesStatusUpdate) {
-                    sendEvent("glasses_status", status.toMap())
+                override fun onGlassesChanged(glasses: GlassesRuntimeState) {
+                    sendEvent(
+                            "glasses_status",
+                            sdk?.getRawGlassesStatus()?.toMap()
+                                    ?: GlassesStatus.fromMap(DeviceStore.store.getCategory("glasses")).toMap()
+                    )
                 }
 
-                override fun onBluetoothStatusChanged(status: BluetoothStatusUpdate) {
-                    sendEvent("bluetooth_status", status.toMap())
+                override fun onSdkStateChanged(sdkState: PhoneSdkRuntimeState) {
+                    sendEvent(
+                            "bluetooth_status",
+                            sdk?.getRawBluetoothStatus()?.toMap()
+                                    ?: DeviceStore.store.getCategory(ObservableStore.BLUETOOTH_CATEGORY)
+                    )
                 }
 
                 override fun onDeviceDiscovered(device: Device) {
@@ -31,7 +39,7 @@ class BluetoothSdkModule : Module() {
 
                 override fun onScanStopped(reason: ScanStopReason) {
                     if (reason == ScanStopReason.COMPLETED) {
-                        val status = sdk?.getBluetoothStatus()
+                        val status = sdk?.getRawBluetoothStatus()
                         val deviceModel =
                                 status?.pendingWearable?.takeIf { it.isNotBlank() }
                                         ?: status?.defaultWearable
@@ -97,12 +105,12 @@ class BluetoothSdkModule : Module() {
                     sendEvent("keep_alive_ack", event.values)
                 }
 
-                override fun onMicPcm(frame: ByteArray) {
-                    sendEvent("mic_pcm", mapOf("pcm" to frame))
+                override fun onMicPcm(event: MicPcmEvent) {
+                    sendEvent("mic_pcm", event.toMap())
                 }
 
-                override fun onMicLc3(frame: ByteArray) {
-                    sendEvent("mic_lc3", mapOf("lc3" to frame))
+                override fun onMicLc3(event: MicLc3Event) {
+                    sendEvent("mic_lc3", event.toMap())
                 }
 
                 override fun onLocalTranscription(event: LocalTranscriptionEvent) {
@@ -196,12 +204,12 @@ class BluetoothSdkModule : Module() {
         // MARK: - Observable Store Functions
 
         Function("getGlassesStatus") {
-            sdk?.getGlassesStatus()?.toMap()
+            sdk?.getRawGlassesStatus()?.toMap()
                     ?: GlassesStatus.fromMap(DeviceStore.store.getCategory("glasses")).toMap()
         }
 
         Function("getBluetoothStatus") {
-            sdk?.getBluetoothStatus()?.toMap() ?: DeviceStore.store.getCategory(ObservableStore.BLUETOOTH_CATEGORY)
+            sdk?.getRawBluetoothStatus()?.toMap() ?: DeviceStore.store.getCategory(ObservableStore.BLUETOOTH_CATEGORY)
         }
 
         Function("getDefaultDevice") { sdk?.getDefaultDevice()?.toMap() }
@@ -418,7 +426,7 @@ class BluetoothSdkModule : Module() {
             sdk?.setMicState(
                     enabled = enabled,
                     useGlassesMic = useGlassesMic ?: true,
-                    bypassVad = bypassVad ?: false,
+                    bypassVad = bypassVad ?: true,
                     sendTranscript = sendTranscript ?: false,
                     sendLc3Data = sendLc3Data ?: false,
             )

package/android/src/main/java/com/mentra/bluetoothsdk/Bridge.kt

@@ -24,6 +24,11 @@ public class Bridge private constructor() {
 
     companion object {
         private const val TAG = "Bridge"
+        private const val MIC_SAMPLE_RATE = 16_000
+        private const val PCM_BITS_PER_SAMPLE = 16
+        private const val MIC_CHANNELS = 1
+        private const val LC3_FRAME_DURATION_MS = 10
+        private const val DEFAULT_LC3_FRAME_SIZE_BYTES = 60
 
         @Volatile private var instance: Bridge? = null
 
@@ -134,26 +139,47 @@ public class Bridge private constructor() {
 
         @JvmStatic
         fun sendMicPcm(data: ByteArray) {
-            // val base64String = Base64.encodeToString(data, Base64.NO_WRAP)
-            // val body = HashMap<String, Any>()
-            // body["base64"] = base64String
-            // sendTypedMessage("mic_pcm", body as Map<String, Any>)
-            val body = HashMap<String, Any>()
-            body["pcm"] = data
+            val body = micPcmEventBody(data)
             sendTypedMessage("mic_pcm", body as Map<String, Any>)
         }
         
         @JvmStatic
         fun sendMicLc3(data: ByteArray) {
-            // val base64String = Base64.encodeToString(data, Base64.NO_WRAP)
-            // val body = HashMap<String, Any>()
-            // body["base64"] = base64String
-            // sendTypedMessage("mic_lc3", body as Map<String, Any>)
-            val body = HashMap<String, Any>()
-            body["lc3"] = data
+            val body = micLc3EventBody(data)
             sendTypedMessage("mic_lc3", body as Map<String, Any>)
         }
 
+        private fun micPcmEventBody(data: ByteArray): HashMap<String, Any> {
+            val body = HashMap<String, Any>()
+            body["pcm"] = data
+            body["sampleRate"] = MIC_SAMPLE_RATE
+            body["bitsPerSample"] = PCM_BITS_PER_SAMPLE
+            body["channels"] = MIC_CHANNELS
+            body["encoding"] = "pcm_s16le"
+            body["vadGated"] = isVadGated()
+            return body
+        }
+
+        private fun micLc3EventBody(data: ByteArray): HashMap<String, Any> {
+            val frameSizeBytes =
+                    (DeviceStore.store.get("bluetooth", "lc3_frame_size") as? Number)?.toInt()
+                            ?: DEFAULT_LC3_FRAME_SIZE_BYTES
+            val body = HashMap<String, Any>()
+            body["lc3"] = data
+            body["sampleRate"] = MIC_SAMPLE_RATE
+            body["channels"] = MIC_CHANNELS
+            body["encoding"] = "lc3"
+            body["frameDurationMs"] = LC3_FRAME_DURATION_MS
+            body["frameSizeBytes"] = frameSizeBytes
+            body["bitrate"] = frameSizeBytes * 8 * (1000 / LC3_FRAME_DURATION_MS)
+            body["packetizedFromGlasses"] = false
+            body["vadGated"] = isVadGated()
+            return body
+        }
+
+        private fun isVadGated(): Boolean =
+                !((DeviceStore.store.get("bluetooth", "bypass_vad") as? Boolean) ?: true)
+
         /** Save a setting */
         @JvmStatic
         fun saveSetting(key: String, value: Any) {

package/android/src/main/java/com/mentra/bluetoothsdk/DeviceStore.kt

@@ -137,7 +137,8 @@ object DeviceStore {
         store.set("bluetooth", "should_send_pcm", false)
         store.set("bluetooth", "should_send_lc3", false)
         store.set("bluetooth", "should_send_transcript", false)
-        store.set("bluetooth", "bypass_vad", false)
+        store.set("bluetooth", "bypass_vad", true)
+        store.set("bluetooth", "use_native_dashboard", false)
     }
 
     fun get(category: String, key: String): Any? {

package/android/src/main/java/com/mentra/bluetoothsdk/MentraBluetoothSdk.kt

@@ -4,10 +4,10 @@ import android.bluetooth.BluetoothManager
 import android.content.Context
 import android.os.Handler
 import android.os.Looper
-import com.mentra.bluetoothsdk.utils.ConnTypes
 import com.mentra.bluetoothsdk.utils.ControllerTypes
 import com.mentra.bluetoothsdk.utils.PhoneAudioMonitor
 import java.util.Collections
+import java.util.concurrent.atomic.AtomicBoolean
 
 class MentraBluetoothSdk private constructor(
     context: Context,
@@ -34,6 +34,7 @@ class MentraBluetoothSdk private constructor(
 
     companion object {
         private val DEFAULT_DEVICE_KEYS = setOf("default_wearable", "device_name", "device_address")
+        private val SCAN_STATE_KEYS = setOf("searching", "searchingController", "searchResults")
         private const val DEFAULT_SCAN_TIMEOUT_MS = 15_000L
 
         @JvmStatic
@@ -58,10 +59,22 @@ class MentraBluetoothSdk private constructor(
         listeners.remove(listener)
     }
 
-    fun getGlassesStatus(): GlassesStatus =
+    fun getState(): MentraBluetoothState =
+        MentraBluetoothState.from(getRawGlassesStatus(), getRawBluetoothStatus())
+
+    fun getGlasses(): GlassesRuntimeState =
+        getState().glasses
+
+    fun getSdkState(): PhoneSdkRuntimeState =
+        getState().sdk
+
+    fun getScanState(): BluetoothScanState =
+        getState().scan
+
+    internal fun getRawGlassesStatus(): GlassesStatus =
         GlassesStatus.fromMap(DeviceStore.store.getCategory("glasses"))
 
-    fun getBluetoothStatus(): BluetoothStatus =
+    internal fun getRawBluetoothStatus(): BluetoothStatus =
         BluetoothStatus.fromMap(DeviceStore.store.getCategory(ObservableStore.BLUETOOTH_CATEGORY))
 
     fun getDefaultDevice(): Device? = currentDefaultDevice()
@@ -144,7 +157,7 @@ class MentraBluetoothSdk private constructor(
         val latestResults = mutableListOf<Device>()
         lateinit var timeoutRunnable: Runnable
         lateinit var session: ScanSession
-        var finished = false
+        val finished = AtomicBoolean(false)
 
         fun emitResults(devices: List<Device>) {
             latestResults.clear()
@@ -154,16 +167,13 @@ class MentraBluetoothSdk private constructor(
 
         val scanListener =
             object : MentraBluetoothSdkCallback() {
-                override fun onBluetoothStatusChanged(status: BluetoothStatusUpdate) {
-                    status.searchResults?.let { results ->
-                        emitResults(results.filter { it.model == model })
-                    }
+                override fun onScanChanged(scan: BluetoothScanState) {
+                    emitResults(scan.devices.filter { it.model == model })
                 }
-        }
+            }
 
         fun finish(reason: ScanStopReason) {
-            if (finished) return
-            finished = true
+            if (!finished.compareAndSet(false, true)) return
             removeListener(scanListener)
             mainHandler.removeCallbacks(timeoutRunnable)
             session.markStopped()
@@ -178,7 +188,7 @@ class MentraBluetoothSdk private constructor(
         try {
             emitResults(emptyList())
             startScan(model)
-            emitResults(getBluetoothStatus().searchResults.filter { it.model == model })
+            emitResults(getRawBluetoothStatus().searchResults.filter { it.model == model })
             mainHandler.postDelayed(timeoutRunnable, normalizedTimeoutMs)
             return session
         } catch (error: Throwable) {
@@ -339,7 +349,7 @@ class MentraBluetoothSdk private constructor(
     fun setMicState(
         enabled: Boolean,
         useGlassesMic: Boolean = true,
-        bypassVad: Boolean = false,
+        bypassVad: Boolean = true,
         sendTranscript: Boolean = false,
         sendLc3Data: Boolean = false,
     ) {
@@ -483,13 +493,22 @@ class MentraBluetoothSdk private constructor(
 
     private fun dispatchStoreUpdate(category: String, changes: Map<String, Any>) {
         when (ObservableStore.normalizeCategory(category)) {
-            "glasses" ->
+            "glasses" -> {
+                val state = getState()
                 dispatchToListeners {
-                    it.onGlassesStatusChanged(GlassesStatusUpdate.fromMap(glassesStatusChanges(changes)))
+                    it.onStateChanged(state)
+                    it.onGlassesChanged(state.glasses)
                 }
+            }
             ObservableStore.BLUETOOTH_CATEGORY -> {
+                val state = getState()
+                val scanChanged = changes.keys.any { it in SCAN_STATE_KEYS }
                 dispatchToListeners {
-                    it.onBluetoothStatusChanged(BluetoothStatusUpdate.fromMap(changes))
+                    it.onStateChanged(state)
+                    it.onSdkStateChanged(state.sdk)
+                    if (scanChanged) {
+                        it.onScanChanged(state.scan)
+                    }
                 }
                 if (!suppressDefaultDeviceEvents && changes.keys.any { it in DEFAULT_DEVICE_KEYS }) {
                     dispatchDefaultDeviceChanged()
@@ -499,37 +518,6 @@ class MentraBluetoothSdk private constructor(
         }
     }
 
-    private fun glassesStatusChanges(changes: Map<String, Any>): Map<String, Any> {
-        var merged = changes
-
-        if (changes.keys.any { it in setOf("wifiConnected", "wifiSsid", "wifiLocalIp") }) {
-            merged =
-                merged +
-                    mapOf(
-                        "wifiConnected" to ((DeviceStore.get("glasses", "wifiConnected") as? Boolean) ?: false),
-                        "wifiSsid" to ((DeviceStore.get("glasses", "wifiSsid") as? String) ?: ""),
-                        "wifiLocalIp" to ((DeviceStore.get("glasses", "wifiLocalIp") as? String) ?: ""),
-                    )
-        }
-
-        if (changes.keys.any { it in setOf("connected", "fullyBooted", "connectionState") }) {
-            merged =
-                merged +
-                    mapOf(
-                        "connected" to ((DeviceStore.get("glasses", "connected") as? Boolean) ?: false),
-                        "fullyBooted" to ((DeviceStore.get("glasses", "fullyBooted") as? Boolean) ?: false),
-                        "connectionState" to ((DeviceStore.get("glasses", "connectionState") as? String) ?: ConnTypes.DISCONNECTED),
-                    )
-        }
-
-        if (changes.containsKey("signalStrengthUpdatedAt") && !changes.containsKey("signalStrength")) {
-            val signalStrength = (DeviceStore.get("glasses", "signalStrength") as? Number)?.toInt() ?: -1
-            merged = merged + ("signalStrength" to signalStrength)
-        }
-
-        return merged
-    }
-
     private fun dispatchDefaultDeviceChanged() {
         val defaultDevice = currentDefaultDevice()
         dispatchToListeners { it.onDefaultDeviceChanged(defaultDevice) }
@@ -634,11 +622,17 @@ class MentraBluetoothSdk private constructor(
             "photo_response" -> dispatchToListeners { it.onPhotoResponse(PhotoResponseEvent(data)) }
             "stream_status" -> dispatchToListeners { it.onStreamStatus(StreamStatusEvent(data)) }
             "keep_alive_ack" -> dispatchToListeners { it.onKeepAliveAck(KeepAliveAckEvent(data)) }
-            "mic_pcm" -> (data["pcm"] as? ByteArray)?.let { frame ->
-                dispatchToListeners { it.onMicPcm(frame) }
+            "mic_pcm" -> {
+                val event = MicPcmEvent(data)
+                if (event.pcm.isNotEmpty()) {
+                    dispatchToListeners { it.onMicPcm(event) }
+                }
             }
-            "mic_lc3" -> (data["lc3"] as? ByteArray)?.let { frame ->
-                dispatchToListeners { it.onMicLc3(frame) }
+            "mic_lc3" -> {
+                val event = MicLc3Event(data)
+                if (event.lc3.isNotEmpty()) {
+                    dispatchToListeners { it.onMicLc3(event) }
+                }
             }
             "local_transcription" ->
                 dispatchToListeners {

package/android/src/main/java/com/mentra/bluetoothsdk/audio/AudioModels.kt

@@ -0,0 +1,125 @@
+package com.mentra.bluetoothsdk
+
+enum class MicPreference(val value: String) {
+    AUTO("auto"),
+    PHONE("phone"),
+    GLASSES("glasses"),
+    BLUETOOTH("bluetooth"),
+}
+
+data class MicPcmEvent(
+    val pcm: ByteArray,
+    val sampleRate: Int,
+    val bitsPerSample: Int,
+    val channels: Int,
+    val encoding: String,
+    val vadGated: Boolean,
+) {
+    constructor(values: Map<String, Any>) : this(
+        pcm = values["pcm"] as? ByteArray ?: ByteArray(0),
+        sampleRate = numberValue(values, "sampleRate") ?: SAMPLE_RATE,
+        bitsPerSample = numberValue(values, "bitsPerSample") ?: BITS_PER_SAMPLE,
+        channels = numberValue(values, "channels") ?: CHANNELS,
+        encoding = stringValue(values, "encoding") ?: ENCODING,
+        vadGated = boolValue(values, "vadGated") ?: false,
+    )
+
+    fun toMap(): Map<String, Any> =
+        mapOf(
+            "type" to "mic_pcm",
+            "pcm" to pcm,
+            "sampleRate" to sampleRate,
+            "bitsPerSample" to bitsPerSample,
+            "channels" to channels,
+            "encoding" to encoding,
+            "vadGated" to vadGated,
+        )
+
+    companion object {
+        const val SAMPLE_RATE = 16_000
+        const val BITS_PER_SAMPLE = 16
+        const val CHANNELS = 1
+        const val ENCODING = "pcm_s16le"
+    }
+}
+
+data class MicLc3Event(
+    val lc3: ByteArray,
+    val sampleRate: Int,
+    val channels: Int,
+    val encoding: String,
+    val frameDurationMs: Int,
+    val frameSizeBytes: Int,
+    val bitrate: Int,
+    val packetizedFromGlasses: Boolean,
+    val vadGated: Boolean,
+) {
+    constructor(values: Map<String, Any>) : this(
+        lc3 = values["lc3"] as? ByteArray ?: ByteArray(0),
+        sampleRate = numberValue(values, "sampleRate") ?: SAMPLE_RATE,
+        channels = numberValue(values, "channels") ?: CHANNELS,
+        encoding = stringValue(values, "encoding") ?: ENCODING,
+        frameDurationMs = numberValue(values, "frameDurationMs") ?: FRAME_DURATION_MS,
+        frameSizeBytes = numberValue(values, "frameSizeBytes") ?: DEFAULT_FRAME_SIZE_BYTES,
+        bitrate = numberValue(values, "bitrate") ?: DEFAULT_BITRATE,
+        packetizedFromGlasses = boolValue(values, "packetizedFromGlasses") ?: false,
+        vadGated = boolValue(values, "vadGated") ?: false,
+    )
+
+    fun toMap(): Map<String, Any> =
+        mapOf(
+            "type" to "mic_lc3",
+            "lc3" to lc3,
+            "sampleRate" to sampleRate,
+            "channels" to channels,
+            "encoding" to encoding,
+            "frameDurationMs" to frameDurationMs,
+            "frameSizeBytes" to frameSizeBytes,
+            "bitrate" to bitrate,
+            "packetizedFromGlasses" to packetizedFromGlasses,
+            "vadGated" to vadGated,
+        )
+
+    companion object {
+        const val SAMPLE_RATE = 16_000
+        const val CHANNELS = 1
+        const val ENCODING = "lc3"
+        const val FRAME_DURATION_MS = 10
+        const val DEFAULT_FRAME_SIZE_BYTES = 60
+        const val DEFAULT_BITRATE = DEFAULT_FRAME_SIZE_BYTES * 8 * (1000 / FRAME_DURATION_MS)
+    }
+}
+
+data class LocalTranscriptionEvent(
+    val text: String,
+    val isFinal: Boolean,
+    val values: Map<String, Any>,
+)
+
+data class GlassesMediaVolumeGetResult(
+    val level: Int?,
+    val statusCode: Int?,
+    val values: Map<String, Any>,
+) {
+    companion object {
+        fun fromMap(values: Map<String, Any>): GlassesMediaVolumeGetResult =
+            GlassesMediaVolumeGetResult(
+                level = numberValue(values, "level"),
+                statusCode = (values["statusCode"] as? Number)?.toInt(),
+                values = values,
+            )
+    }
+}
+
+data class GlassesMediaVolumeSetResult(
+    val statusCode: Int?,
+    val values: Map<String, Any>,
+) {
+    companion object {
+        fun fromMap(values: Map<String, Any>): GlassesMediaVolumeSetResult =
+            GlassesMediaVolumeSetResult(
+                statusCode = (values["statusCode"] as? Number)?.toInt(),
+                values = values,
+            )
+    }
+}