@mentra/bluetooth-sdk 0.1.5 → 0.1.7

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) {
@@ -298,8 +308,12 @@ class MentraBluetoothSdk private constructor(
         DeviceStore.apply(ObservableStore.BLUETOOTH_CATEGORY, "screen_disabled", disabled)
     }
 
-    fun setGalleryMode(mode: GalleryMode) {
-        DeviceStore.apply(ObservableStore.BLUETOOTH_CATEGORY, "galleryModeAuto", mode == GalleryMode.AUTO)
+    fun setGalleryModeEnabled(enabled: Boolean) {
+        DeviceStore.apply(ObservableStore.BLUETOOTH_CATEGORY, "gallery_mode", enabled)
+    }
+
+    fun setVoiceActivityDetectionEnabled(enabled: Boolean) {
+        DeviceStore.apply(ObservableStore.BLUETOOTH_CATEGORY, "voice_activity_detection_enabled", enabled)
     }
 
     fun setButtonPhotoSettings(size: ButtonPhotoSize) {
@@ -310,14 +324,14 @@ class MentraBluetoothSdk private constructor(
         setButtonPhotoSettings(size = settings.size)
     }
 
-    fun setButtonVideoRecordingSettings(width: Int, height: Int, frameRate: Int) {
+    fun setButtonVideoRecordingSettings(width: Int, height: Int, fps: Int) {
         DeviceStore.apply(ObservableStore.BLUETOOTH_CATEGORY, "button_video_width", width)
         DeviceStore.apply(ObservableStore.BLUETOOTH_CATEGORY, "button_video_height", height)
-        DeviceStore.apply(ObservableStore.BLUETOOTH_CATEGORY, "button_video_fps", frameRate)
+        DeviceStore.apply(ObservableStore.BLUETOOTH_CATEGORY, "button_video_fps", fps)
     }
 
     fun setButtonVideoRecordingSettings(settings: ButtonVideoRecordingSettings) {
-        setButtonVideoRecordingSettings(width = settings.width, height = settings.height, frameRate = settings.frameRate)
+        setButtonVideoRecordingSettings(width = settings.width, height = settings.height, fps = settings.fps)
     }
 
     fun setButtonCameraLed(enabled: Boolean) {
@@ -332,14 +346,13 @@ class MentraBluetoothSdk private constructor(
         DeviceStore.apply(
             ObservableStore.BLUETOOTH_CATEGORY,
             "camera_fov",
-            mapOf("fov" to fov.fov, "roiPosition" to fov.roiPosition),
+            mapOf("fov" to fov.fov, "roi_position" to fov.roiPosition),
         )
     }
 
     fun setMicState(
         enabled: Boolean,
         useGlassesMic: Boolean = true,
-        bypassVad: Boolean = true,
         sendTranscript: Boolean = false,
         sendLc3Data: Boolean = false,
     ) {
@@ -353,7 +366,6 @@ class MentraBluetoothSdk private constructor(
         applyMicState(
             sendPcmData = enabled,
             sendTranscript = enabled && sendTranscript,
-            bypassVad = bypassVad,
             sendLc3Data = enabled && sendLc3Data,
         )
     }
@@ -361,13 +373,11 @@ class MentraBluetoothSdk private constructor(
     private fun applyMicState(
         sendPcmData: Boolean,
         sendTranscript: Boolean,
-        bypassVad: Boolean,
         sendLc3Data: Boolean,
     ) {
         DeviceStore.apply(ObservableStore.BLUETOOTH_CATEGORY, "should_send_pcm", sendPcmData)
         DeviceStore.apply(ObservableStore.BLUETOOTH_CATEGORY, "should_send_lc3", sendLc3Data)
         DeviceStore.apply(ObservableStore.BLUETOOTH_CATEGORY, "should_send_transcript", sendTranscript)
-        DeviceStore.apply(ObservableStore.BLUETOOTH_CATEGORY, "bypass_vad", bypassVad)
         deviceManager.setMicState()
     }
 
@@ -404,6 +414,9 @@ class MentraBluetoothSdk private constructor(
     }
 
     fun requestPhoto(request: PhotoRequest) {
+        Bridge.log(
+            "NATIVE: PHOTO PIPELINE [3b/6] MentraBluetoothSdk.requestPhoto requestId=${request.requestId} appId=${request.appId}"
+        )
         deviceManager.requestPhoto(
             request.requestId,
             request.appId,
@@ -411,7 +424,9 @@ class MentraBluetoothSdk private constructor(
             request.webhookUrl,
             request.authToken,
             request.compress.value,
+            request.flash,
             request.sound,
+            request.exposureTimeNs,
         )
     }
 
@@ -483,13 +498,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 +523,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) }
@@ -617,6 +610,25 @@ class MentraBluetoothSdk private constructor(
                 }
             }
             "head_up" -> dispatchToListeners { it.onHeadUpChanged(data["up"] as? Boolean ?: false) }
+            "voice_activity_detection_status" ->
+                dispatchToListeners {
+                    it.onVoiceActivityDetectionStatus(
+                        VoiceActivityDetectionStatusEvent(
+                            voiceActivityDetectionEnabled =
+                                data["voiceActivityDetectionEnabled"] as? Boolean ?: true,
+                            values = data,
+                        )
+                    )
+                }
+            "speaking_status" ->
+                dispatchToListeners {
+                    it.onSpeakingStatus(
+                        SpeakingStatusEvent(
+                            speaking = data["speaking"] as? Boolean ?: false,
+                            values = data,
+                        )
+                    )
+                }
             "battery_status" ->
                 dispatchToListeners {
                     it.onBatteryStatus(

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 voiceActivityDetectionEnabled: 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,
+        voiceActivityDetectionEnabled = boolValue(values, "voiceActivityDetectionEnabled") ?: true,
+    )
+
+    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,
+            "voiceActivityDetectionEnabled" to voiceActivityDetectionEnabled,
+        )
+
+    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 voiceActivityDetectionEnabled: 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,
+        voiceActivityDetectionEnabled = boolValue(values, "voiceActivityDetectionEnabled") ?: true,
+    )
+
+    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,
+            "voiceActivityDetectionEnabled" to voiceActivityDetectionEnabled,
+        )
+
+    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,
+            )
+    }
+}

package/android/src/main/java/com/mentra/bluetoothsdk/camera/CameraModels.kt

@@ -0,0 +1,209 @@
+package com.mentra.bluetoothsdk
+
+enum class PhotoSize(val value: String) {
+    SMALL("small"),
+    MEDIUM("medium"),
+    LARGE("large"),
+    FULL("full");
+
+    companion object {
+        @JvmStatic
+        fun fromValue(value: String?): PhotoSize =
+            values().firstOrNull { it.value == value } ?: MEDIUM
+    }
+}
+
+enum class ButtonPhotoSize(val value: String) {
+    SMALL("small"),
+    MEDIUM("medium"),
+    LARGE("large");
+
+    companion object {
+        @JvmStatic
+        fun fromValue(value: String?): ButtonPhotoSize =
+            values().firstOrNull { it.value == value } ?: MEDIUM
+    }
+}
+
+enum class PhotoCompression(val value: String) {
+    NONE("none"),
+    MEDIUM("medium"),
+    HEAVY("heavy");
+
+    companion object {
+        @JvmStatic
+        fun fromValue(value: String?): PhotoCompression =
+            values().firstOrNull { it.value == value } ?: NONE
+    }
+}
+
+data class ButtonPhotoSettings(
+    val size: ButtonPhotoSize,
+)
+
+data class ButtonVideoRecordingSettings(
+    val width: Int,
+    val height: Int,
+    val fps: Int,
+)
+
+enum class CameraFov(val fov: Int, val roiPosition: Int) {
+    STANDARD(118, 0),
+    WIDE(118, 0),
+}
+
+data class PhotoRequest @JvmOverloads constructor(
+    val requestId: String,
+    val appId: String,
+    val size: PhotoSize,
+    val webhookUrl: String,
+    val authToken: String? = null,
+    val compress: PhotoCompression = PhotoCompression.MEDIUM,
+    val flash: Boolean = true,
+    val sound: Boolean = true,
+    /** Sensor exposure time for this capture only (ns), or null for auto exposure */
+    val exposureTimeNs: Double? = null,
+) {
+    companion object {
+        /** Mirrors iOS `BluetoothSdkModule` defaults for keys omitted from the JS bridge. */
+        @JvmStatic
+        fun fromMap(values: Map<String, Any>): PhotoRequest {
+            val rawExp = values["exposureTimeNs"] ?: values["exposure_time_ns"]
+            val exposureTimeNs: Double? =
+                when (rawExp) {
+                    is Number -> rawExp.toDouble().takeIf { it.isFinite() && it > 0 }
+                    else -> null
+                }
+            return PhotoRequest(
+                requestId = stringValue(values, "requestId", "request_id").orEmpty(),
+                appId = stringValue(values, "appId", "app_id").orEmpty(),
+                size = PhotoSize.fromValue(stringValue(values, "size") ?: "medium"),
+                webhookUrl = stringValue(values, "webhookUrl", "webhook_url").orEmpty(),
+                authToken = stringValue(values, "authToken", "auth_token")?.takeIf { it.isNotBlank() },
+                compress = PhotoCompression.fromValue(stringValue(values, "compress") ?: "none"),
+                flash = boolValue(values, "flash") ?: true,
+                sound = boolValue(values, "sound") ?: true,
+                exposureTimeNs = exposureTimeNs,
+            )
+        }
+    }
+}
+
+enum class RgbLedAction(val value: String) {
+    ON("on"),
+    OFF("off");
+
+    companion object {
+        @JvmStatic
+        fun fromValue(value: String?): RgbLedAction =
+            values().firstOrNull { it.value == value } ?: OFF
+    }
+}
+
+enum class RgbLedColor(val value: String) {
+    RED("red"),
+    GREEN("green"),
+    BLUE("blue"),
+    ORANGE("orange"),
+    WHITE("white");
+
+    companion object {
+        @JvmStatic
+        fun fromValue(value: String?): RgbLedColor? =
+            values().firstOrNull { it.value == value }
+    }
+}
+
+data class RgbLedRequest @JvmOverloads constructor(
+    val requestId: String,
+    val packageName: String?,
+    val action: RgbLedAction,
+    val color: RgbLedColor?,
+    val onDurationMs: Int,
+    val offDurationMs: Int,
+    val count: Int,
+)
+
+data class VideoRecordingRequest(
+    val requestId: String,
+    val save: Boolean,
+    val sound: Boolean,
+)
+
+data class GalleryStatusEvent(
+    val values: Map<String, Any>,
+)
+
+sealed interface PhotoResponse {
+    val state: String
+    val requestId: String
+    val timestamp: Long
+
+    fun toMap(): Map<String, Any> =
+        when (this) {
+            is Success -> mapOf(
+                "state" to state,
+                "requestId" to requestId,
+                "uploadUrl" to uploadUrl,
+                "timestamp" to timestamp,
+            )
+
+            is Error -> mutableMapOf<String, Any>(
+                "state" to state,
+                "requestId" to requestId,
+                "timestamp" to timestamp,
+                "errorMessage" to errorMessage,
+            ).apply {
+                if (!errorCode.isNullOrBlank()) {
+                    this["errorCode"] = errorCode
+                }
+            }
+        }
+
+    fun toEventMap(): Map<String, Any> = toMap() + mapOf("type" to "photo_response")
+
+    data class Success(
+        override val requestId: String,
+        val uploadUrl: String,
+        override val timestamp: Long,
+    ) : PhotoResponse {
+        override val state: String = "success"
+    }
+
+    data class Error(
+        override val requestId: String,
+        val errorCode: String?,
+        val errorMessage: String,
+        override val timestamp: Long,
+    ) : PhotoResponse {
+        override val state: String = "error"
+    }
+
+    companion object {
+        fun fromMap(values: Map<String, Any>): PhotoResponse {
+            val requestId = stringValue(values, "requestId").orEmpty()
+            val timestamp = longValue(values, "timestamp") ?: System.currentTimeMillis()
+            val state = stringValue(values, "state")?.lowercase()
+            return if (state == "success") {
+                val uploadUrl = stringValue(values, "uploadUrl").orEmpty()
+                Success(requestId = requestId, uploadUrl = uploadUrl, timestamp = timestamp)
+            } else {
+                Error(
+                    requestId = requestId,
+                    errorCode = stringValue(values, "errorCode"),
+                    errorMessage = stringValue(values, "errorMessage") ?: "Unknown photo error",
+                    timestamp = timestamp,
+                )
+            }
+        }
+    }
+}
+
+data class PhotoResponseEvent(
+    val response: PhotoResponse,
+) {
+    constructor(values: Map<String, Any>) : this(PhotoResponse.fromMap(values))
+
+    val requestId: String get() = response.requestId
+    val values: Map<String, Any> get() = response.toEventMap()
+}

package/android/src/main/java/com/mentra/bluetoothsdk/connection/ConnectionModels.kt

@@ -0,0 +1,78 @@
+package com.mentra.bluetoothsdk
+
+import com.mentra.bluetoothsdk.utils.ConnTypes
+import java.util.concurrent.atomic.AtomicBoolean
+
+enum class GlassesConnectionState(val value: String) {
+    DISCONNECTED(ConnTypes.DISCONNECTED),
+    SCANNING(ConnTypes.SCANNING),
+    CONNECTING(ConnTypes.CONNECTING),
+    BONDING(ConnTypes.BONDING),
+    CONNECTED(ConnTypes.CONNECTED);
+
+    val isConnected: Boolean
+        get() = this == CONNECTED
+
+    val isBusy: Boolean
+        get() = this == SCANNING || this == CONNECTING || this == BONDING
+
+    internal fun toStatusMap(
+        connected: Boolean,
+        fullyBooted: Boolean,
+    ): Map<String, Any> =
+        when {
+            this == CONNECTED || connected || fullyBooted ->
+                mapOf("state" to "connected", "fullyBooted" to fullyBooted)
+            this == SCANNING -> mapOf("state" to "scanning")
+            this == CONNECTING -> mapOf("state" to "connecting")
+            this == BONDING -> mapOf("state" to "bonding")
+            else -> mapOf("state" to "disconnected")
+        }
+
+    companion object {
+        @JvmStatic
+        fun fromValue(value: String?): GlassesConnectionState =
+            optionalFromValue(value) ?: DISCONNECTED
+
+        internal fun optionalFromValue(value: String?): GlassesConnectionState? {
+            val normalized = value?.trim()?.takeIf { it.isNotEmpty() } ?: return null
+            return values().firstOrNull { it.value.equals(normalized, ignoreCase = true) }
+        }
+    }
+}
+
+data class BluetoothError(
+    val code: String,
+    val message: String,
+    val cause: Throwable? = null,
+)
+
+enum class ScanStopReason {
+    COMPLETED,
+    CANCELLED,
+    ERROR,
+}
+
+interface ScanCallback {
+    fun onResults(devices: List<Device>) {}
+    fun onComplete(devices: List<Device>) {}
+    fun onError(error: BluetoothError) {}
+}
+
+abstract class MentraBluetoothScanCallback : ScanCallback
+
+class ScanSession internal constructor(
+    private val stopAction: () -> Unit,
+) {
+    private val stopped = AtomicBoolean(false)
+
+    fun stop() {
+        if (stopped.compareAndSet(false, true)) {
+            stopAction()
+        }
+    }
+
+    internal fun markStopped() {
+        stopped.set(true)
+    }
+}

package/android/src/main/java/com/mentra/bluetoothsdk/controllers/ControllerManager.kt

@@ -22,7 +22,8 @@ abstract class ControllerManager {
         authToken: String?,
         compress: String?,
         flash: Boolean,
-        sound: Boolean
+        sound: Boolean,
+        exposureTimeNs: Long?,
     )
     abstract fun startStream(message: Map<String, Any>)
     abstract fun stopStream()
@@ -132,8 +133,8 @@ abstract class ControllerManager {
     val micEnabled: Boolean
         get() = DeviceStore.get("glasses", "micEnabled") as? Boolean ?: false
 
-    val vadEnabled: Boolean
-        get() = DeviceStore.get("glasses", "vadEnabled") as? Boolean ?: false
+    val voiceActivityDetectionEnabled: Boolean
+        get() = DeviceStore.get("glasses", "voiceActivityDetectionEnabled") as? Boolean ?: true
 
     val batteryLevel: Int
         get() = DeviceStore.get("glasses", "batteryLevel") as? Int ?: -1