@mentra/bluetooth-sdk 0.1.4 → 0.1.6

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

@@ -1,1725 +0,0 @@
-package com.mentra.bluetoothsdk
-
-import com.mentra.bluetoothsdk.utils.ControllerTypes
-import com.mentra.bluetoothsdk.utils.ConnTypes
-import com.mentra.bluetoothsdk.utils.DeviceTypes
-
-data class MentraBluetoothSdkConfig(
-    val deliverCallbacksOnMainThread: Boolean = true,
-)
-
-class BluetoothException(
-    val code: String,
-    message: String,
-    cause: Throwable? = null,
-) : IllegalStateException(message, cause)
-
-enum class DeviceModel(val deviceType: String) {
-    G1(DeviceTypes.G1),
-    G2(DeviceTypes.G2),
-    MENTRA_LIVE(DeviceTypes.LIVE),
-    MENTRA_NEX(DeviceTypes.NEX),
-    MACH1(DeviceTypes.MACH1),
-    Z100(DeviceTypes.Z100),
-    FRAME(DeviceTypes.FRAME),
-    SIMULATED(DeviceTypes.SIMULATED),
-    R1(ControllerTypes.R1);
-
-    companion object {
-        @JvmStatic
-        fun fromDeviceType(deviceType: String?): DeviceModel =
-            values().firstOrNull { it.deviceType == deviceType } ?: MENTRA_LIVE
-    }
-}
-
-data class Device(
-    val model: DeviceModel,
-    val name: String,
-    val address: String? = null,
-    val rssi: Int? = null,
-    val id: String = address?.takeIf { it.isNotBlank() } ?: "${model.deviceType}:$name",
-) {
-    internal fun toMap(): Map<String, Any> =
-        buildMap {
-            put("id", id)
-            put("model", model.deviceType)
-            put("name", name)
-            address?.takeIf { it.isNotBlank() }?.let {
-                put("address", it)
-            }
-            rssi?.let { put("rssi", it) }
-        }
-
-    companion object {
-        internal fun fromMap(values: Map<String, Any>): Device? {
-            val model = stringValue(values, "model") ?: return null
-            val name = stringValue(values, "name") ?: return null
-            val address = stringValue(values, "address")?.takeIf { it.isNotBlank() }
-            val rssi = numberValue(values, "rssi")
-            val id = stringValue(values, "id")?.takeIf { it.isNotBlank() } ?: address ?: "${model}:$name"
-            return Device(
-                model = DeviceModel.fromDeviceType(model),
-                name = name,
-                address = address,
-                rssi = rssi,
-                id = id,
-            )
-        }
-    }
-}
-
-data class ConnectOptions(
-    val saveAsDefault: Boolean = true,
-    val cancelExistingConnectionAttempt: Boolean = true,
-)
-
-data class WifiScanResult(
-    val ssid: String,
-    val requiresPassword: Boolean,
-    val signalStrength: Int,
-    val frequency: Int? = null,
-) {
-    internal fun toMap(): Map<String, Any> {
-        val map =
-            mutableMapOf<String, Any>(
-                "ssid" to ssid,
-                "requiresPassword" to requiresPassword,
-                "signalStrength" to signalStrength,
-            )
-        frequency?.let { map["frequency"] = it }
-        return map
-    }
-
-    companion object {
-        internal fun fromMap(values: Map<String, Any>): WifiScanResult =
-            WifiScanResult(
-                ssid = stringValue(values, "ssid") ?: "",
-                requiresPassword = boolValue(values, "requiresPassword") ?: false,
-                signalStrength = numberValue(values, "signalStrength") ?: -1,
-                frequency = numberValue(values, "frequency"),
-            )
-    }
-}
-
-data class GlassesStatus(
-    val fullyBooted: Boolean,
-    val connected: Boolean,
-    val micEnabled: Boolean,
-    val connectionState: GlassesConnectionState,
-    val bluetoothClassicConnected: Boolean,
-    val signalStrength: Int,
-    val signalStrengthUpdatedAt: Long,
-    val deviceModel: String,
-    val androidVersion: String,
-    val firmwareVersion: String,
-    val besFirmwareVersion: String,
-    val mtkFirmwareVersion: String,
-    val bluetoothMacAddress: String,
-    val leftMacAddress: String,
-    val rightMacAddress: String,
-    val macAddress: String,
-    val buildNumber: String,
-    val otaVersionUrl: String,
-    val appVersion: String,
-    val bluetoothName: String,
-    val serialNumber: String,
-    val style: String,
-    val color: String,
-    val wifi: WifiStatus,
-    val batteryLevel: Int,
-    val charging: Boolean,
-    val caseBatteryLevel: Int,
-    val caseCharging: Boolean,
-    val caseOpen: Boolean,
-    val caseRemoved: Boolean,
-    val hotspot: HotspotStatus,
-    val headUp: Boolean,
-    val controllerConnected: Boolean,
-    val controllerFullyBooted: Boolean,
-    val controllerMacAddress: String,
-    val controllerBatteryLevel: Int,
-    val controllerSignalStrength: Int,
-    val ringSignalStrength: Int,
-) {
-    internal fun toMap(): Map<String, Any> =
-        mapOf(
-            "connection" to connectionState.toStatusMap(connected, fullyBooted),
-            "micEnabled" to micEnabled,
-            "bluetoothClassicConnected" to bluetoothClassicConnected,
-            "signalStrength" to signalStrength,
-            "signalStrengthUpdatedAt" to signalStrengthUpdatedAt,
-            "deviceModel" to deviceModel,
-            "androidVersion" to androidVersion,
-            "firmwareVersion" to firmwareVersion,
-            "besFirmwareVersion" to besFirmwareVersion,
-            "mtkFirmwareVersion" to mtkFirmwareVersion,
-            "bluetoothMacAddress" to bluetoothMacAddress,
-            "leftMacAddress" to leftMacAddress,
-            "rightMacAddress" to rightMacAddress,
-            "macAddress" to macAddress,
-            "buildNumber" to buildNumber,
-            "otaVersionUrl" to otaVersionUrl,
-            "appVersion" to appVersion,
-            "bluetoothName" to bluetoothName,
-            "serialNumber" to serialNumber,
-            "style" to style,
-            "color" to color,
-            "wifi" to wifi.toMap(),
-            "batteryLevel" to batteryLevel,
-            "charging" to charging,
-            "caseBatteryLevel" to caseBatteryLevel,
-            "caseCharging" to caseCharging,
-            "caseOpen" to caseOpen,
-            "caseRemoved" to caseRemoved,
-            "hotspot" to hotspot.toMap(),
-            "headUp" to headUp,
-            "controllerConnected" to controllerConnected,
-            "controllerFullyBooted" to controllerFullyBooted,
-            "controllerMacAddress" to controllerMacAddress,
-            "controllerBatteryLevel" to controllerBatteryLevel,
-            "controllerSignalStrength" to controllerSignalStrength,
-            "ringSignalStrength" to ringSignalStrength,
-        )
-
-    companion object {
-        internal fun fromMap(values: Map<String, Any>): GlassesStatus =
-            GlassesStatus(
-                fullyBooted = boolValue(values, "fullyBooted") ?: false,
-                connected = boolValue(values, "connected") ?: false,
-                micEnabled = boolValue(values, "micEnabled") ?: false,
-                connectionState = GlassesConnectionState.fromValue(stringValue(values, "connectionState")),
-                bluetoothClassicConnected = boolValue(values, "bluetoothClassicConnected") ?: false,
-                signalStrength = numberValue(values, "signalStrength") ?: -1,
-                signalStrengthUpdatedAt = longValue(values, "signalStrengthUpdatedAt") ?: 0L,
-                deviceModel = stringValue(values, "deviceModel") ?: "",
-                androidVersion = stringValue(values, "androidVersion") ?: "",
-                firmwareVersion = stringValue(values, "firmwareVersion") ?: "",
-                besFirmwareVersion = stringValue(values, "besFirmwareVersion") ?: "",
-                mtkFirmwareVersion = stringValue(values, "mtkFirmwareVersion") ?: "",
-                bluetoothMacAddress = stringValue(values, "bluetoothMacAddress") ?: "",
-                leftMacAddress = stringValue(values, "leftMacAddress") ?: "",
-                rightMacAddress = stringValue(values, "rightMacAddress") ?: "",
-                macAddress = stringValue(values, "macAddress") ?: "",
-                buildNumber = stringValue(values, "buildNumber") ?: "",
-                otaVersionUrl = stringValue(values, "otaVersionUrl") ?: "",
-                appVersion = stringValue(values, "appVersion") ?: "",
-                bluetoothName = stringValue(values, "bluetoothName") ?: "",
-                serialNumber = stringValue(values, "serialNumber") ?: "",
-                style = stringValue(values, "style") ?: "",
-                color = stringValue(values, "color") ?: "",
-                wifi = WifiStatus.fromStoreMap(values) ?: WifiStatus.Disconnected,
-                batteryLevel = numberValue(values, "batteryLevel") ?: -1,
-                charging = boolValue(values, "charging") ?: false,
-                caseBatteryLevel = numberValue(values, "caseBatteryLevel") ?: -1,
-                caseCharging = boolValue(values, "caseCharging") ?: false,
-                caseOpen = boolValue(values, "caseOpen") ?: true,
-                caseRemoved = boolValue(values, "caseRemoved") ?: true,
-                hotspot = HotspotStatus.fromStoreMap(values) ?: HotspotStatus.Disabled,
-                headUp = boolValue(values, "headUp") ?: false,
-                controllerConnected = boolValue(values, "controllerConnected") ?: false,
-                controllerFullyBooted = boolValue(values, "controllerFullyBooted") ?: false,
-                controllerMacAddress = stringValue(values, "controllerMacAddress") ?: "",
-                controllerBatteryLevel = numberValue(values, "controllerBatteryLevel") ?: -1,
-                controllerSignalStrength = numberValue(values, "controllerSignalStrength") ?: -1,
-                ringSignalStrength = numberValue(values, "ringSignalStrength") ?: -1,
-            )
-    }
-}
-
-data class BluetoothStatus(
-    val searching: Boolean,
-    val searchingController: Boolean,
-    val systemMicUnavailable: Boolean,
-    val micEnabled: Boolean,
-    val currentMic: String,
-    val micRanking: List<String>,
-    /**
-     * Nearby glasses in stable discovery order. Existing entries keep their array position as
-     * details refresh; new glasses append at the end, and removals should not reorder remaining
-     * entries.
-     */
-    val searchResults: List<Device>,
-    val wifiScanResults: List<WifiScanResult>,
-    val lastLog: List<String>,
-    val otherBtConnected: Boolean,
-    val defaultWearable: String,
-    val pendingWearable: String,
-    val deviceName: String,
-    val deviceAddress: String,
-    val defaultController: String,
-    val pendingController: String,
-    val controllerDeviceName: String,
-    val screenDisabled: Boolean,
-    val preferredMic: String,
-    val sensingEnabled: Boolean,
-    val powerSavingMode: Boolean,
-    val brightness: Int,
-    val autoBrightness: Boolean,
-    val dashboardHeight: Int,
-    val dashboardDepth: Int,
-    val headUpAngle: Int,
-    val contextualDashboard: Boolean,
-    val galleryModeAuto: Boolean,
-    val buttonPhotoSize: ButtonPhotoSize,
-    val buttonCameraLed: Boolean,
-    val buttonMaxRecordingTime: Int,
-    val buttonVideoWidth: Int,
-    val buttonVideoHeight: Int,
-    val buttonVideoFrameRate: Int,
-    val shouldSendPcm: Boolean,
-    val shouldSendLc3: Boolean,
-    val shouldSendTranscript: Boolean,
-    val bypassVad: Boolean,
-    val offlineCaptionsRunning: Boolean,
-    val localSttFallbackActive: Boolean,
-    val shouldSendBootingMessage: Boolean,
-) {
-    val defaultDevice: Device?
-        get() =
-            defaultWearable.takeIf { it.isNotBlank() }?.let {
-                Device(
-                    model = DeviceModel.fromDeviceType(it),
-                    name = deviceName,
-                    address = deviceAddress.takeIf(String::isNotBlank),
-                )
-            }
-
-    internal fun toMap(): Map<String, Any> =
-        mapOf(
-            "searching" to searching,
-            "searchingController" to searchingController,
-            "systemMicUnavailable" to systemMicUnavailable,
-            "micEnabled" to micEnabled,
-            "currentMic" to currentMic,
-            "micRanking" to micRanking,
-            "searchResults" to searchResults.map(Device::toMap),
-            "wifiScanResults" to wifiScanResults.map { it.toMap() },
-            "lastLog" to lastLog,
-            "otherBtConnected" to otherBtConnected,
-            "default_wearable" to defaultWearable,
-            "pending_wearable" to pendingWearable,
-            "device_name" to deviceName,
-            "device_address" to deviceAddress,
-            "default_controller" to defaultController,
-            "pending_controller" to pendingController,
-            "controller_device_name" to controllerDeviceName,
-            "screen_disabled" to screenDisabled,
-            "preferred_mic" to preferredMic,
-            "sensing_enabled" to sensingEnabled,
-            "power_saving_mode" to powerSavingMode,
-            "brightness" to brightness,
-            "auto_brightness" to autoBrightness,
-            "dashboard_height" to dashboardHeight,
-            "dashboard_depth" to dashboardDepth,
-            "head_up_angle" to headUpAngle,
-            "contextual_dashboard" to contextualDashboard,
-            "galleryModeAuto" to galleryModeAuto,
-            "button_photo_size" to buttonPhotoSize.value,
-            "button_camera_led" to buttonCameraLed,
-            "button_max_recording_time" to buttonMaxRecordingTime,
-            "button_video_width" to buttonVideoWidth,
-            "button_video_height" to buttonVideoHeight,
-            "button_video_fps" to buttonVideoFrameRate,
-            "should_send_pcm" to shouldSendPcm,
-            "should_send_lc3" to shouldSendLc3,
-            "should_send_transcript" to shouldSendTranscript,
-            "bypass_vad" to bypassVad,
-            "offline_captions_running" to offlineCaptionsRunning,
-            "local_stt_fallback_active" to localSttFallbackActive,
-            "shouldSendBootingMessage" to shouldSendBootingMessage,
-        )
-
-    companion object {
-        internal fun fromMap(values: Map<String, Any>): BluetoothStatus =
-            BluetoothStatus(
-                searching = boolValue(values, "searching") ?: false,
-                searchingController = boolValue(values, "searchingController") ?: false,
-                systemMicUnavailable = boolValue(values, "systemMicUnavailable") ?: false,
-                micEnabled = boolValue(values, "micEnabled") ?: false,
-                currentMic = stringValue(values, "currentMic") ?: "",
-                micRanking = stringListValue(values, "micRanking"),
-                searchResults =
-                    mapListValue(values, "searchResults").mapNotNull(Device::fromMap),
-                wifiScanResults =
-                    mapListValue(values, "wifiScanResults").map(WifiScanResult::fromMap),
-                lastLog = stringListValue(values, "lastLog"),
-                otherBtConnected = boolValue(values, "otherBtConnected") ?: false,
-                defaultWearable = stringValue(values, "default_wearable") ?: "",
-                pendingWearable = stringValue(values, "pending_wearable") ?: "",
-                deviceName = stringValue(values, "device_name") ?: "",
-                deviceAddress = stringValue(values, "device_address") ?: "",
-                defaultController = stringValue(values, "default_controller") ?: "",
-                pendingController = stringValue(values, "pending_controller") ?: "",
-                controllerDeviceName = stringValue(values, "controller_device_name") ?: "",
-                screenDisabled = boolValue(values, "screen_disabled") ?: false,
-                preferredMic = stringValue(values, "preferred_mic") ?: "auto",
-                sensingEnabled = boolValue(values, "sensing_enabled") ?: true,
-                powerSavingMode = boolValue(values, "power_saving_mode") ?: false,
-                brightness = numberValue(values, "brightness") ?: 50,
-                autoBrightness = boolValue(values, "auto_brightness") ?: true,
-                dashboardHeight = numberValue(values, "dashboard_height") ?: 4,
-                dashboardDepth = numberValue(values, "dashboard_depth") ?: 2,
-                headUpAngle = numberValue(values, "head_up_angle") ?: 30,
-                contextualDashboard = boolValue(values, "contextual_dashboard") ?: true,
-                galleryModeAuto = boolValue(values, "galleryModeAuto") ?: true,
-                buttonPhotoSize = ButtonPhotoSize.fromValue(stringValue(values, "button_photo_size")),
-                buttonCameraLed = boolValue(values, "button_camera_led") ?: true,
-                buttonMaxRecordingTime = numberValue(values, "button_max_recording_time") ?: 10,
-                buttonVideoWidth = numberValue(values, "button_video_width") ?: 1280,
-                buttonVideoHeight = numberValue(values, "button_video_height") ?: 720,
-                buttonVideoFrameRate = numberValue(values, "button_video_fps") ?: 30,
-                shouldSendPcm = boolValue(values, "should_send_pcm") ?: false,
-                shouldSendLc3 = boolValue(values, "should_send_lc3") ?: false,
-                shouldSendTranscript = boolValue(values, "should_send_transcript") ?: false,
-                bypassVad = boolValue(values, "bypass_vad") ?: false,
-                offlineCaptionsRunning = boolValue(values, "offline_captions_running") ?: false,
-                localSttFallbackActive = boolValue(values, "local_stt_fallback_active") ?: false,
-                shouldSendBootingMessage = boolValue(values, "shouldSendBootingMessage") ?: true,
-            )
-    }
-}
-
-data class GlassesStatusUpdate(
-    val fullyBooted: Boolean? = null,
-    val connected: Boolean? = null,
-    val micEnabled: Boolean? = null,
-    val connectionState: GlassesConnectionState? = null,
-    val bluetoothClassicConnected: Boolean? = null,
-    val signalStrength: Int? = null,
-    val signalStrengthUpdatedAt: Long? = null,
-    val deviceModel: String? = null,
-    val androidVersion: String? = null,
-    val firmwareVersion: String? = null,
-    val besFirmwareVersion: String? = null,
-    val mtkFirmwareVersion: String? = null,
-    val bluetoothMacAddress: String? = null,
-    val leftMacAddress: String? = null,
-    val rightMacAddress: String? = null,
-    val macAddress: String? = null,
-    val buildNumber: String? = null,
-    val otaVersionUrl: String? = null,
-    val appVersion: String? = null,
-    val bluetoothName: String? = null,
-    val serialNumber: String? = null,
-    val style: String? = null,
-    val color: String? = null,
-    val wifi: WifiStatus? = null,
-    val batteryLevel: Int? = null,
-    val charging: Boolean? = null,
-    val caseBatteryLevel: Int? = null,
-    val caseCharging: Boolean? = null,
-    val caseOpen: Boolean? = null,
-    val caseRemoved: Boolean? = null,
-    val hotspot: HotspotStatus? = null,
-    val headUp: Boolean? = null,
-    val controllerConnected: Boolean? = null,
-    val controllerFullyBooted: Boolean? = null,
-    val controllerMacAddress: String? = null,
-    val controllerBatteryLevel: Int? = null,
-    val controllerSignalStrength: Int? = null,
-    val ringSignalStrength: Int? = null,
-) {
-    internal fun toMap(): Map<String, Any> =
-        buildMap {
-            if (fullyBooted != null || connected != null || connectionState != null) {
-                val state =
-                    connectionState
-                        ?: if (connected == true || fullyBooted == true) {
-                            GlassesConnectionState.CONNECTED
-                        } else {
-                            GlassesConnectionState.DISCONNECTED
-                        }
-                put("connection", state.toStatusMap(connected == true, fullyBooted == true))
-            }
-            putIfNotNull("micEnabled", micEnabled)
-            putIfNotNull("bluetoothClassicConnected", bluetoothClassicConnected)
-            putIfNotNull("signalStrength", signalStrength)
-            putIfNotNull("signalStrengthUpdatedAt", signalStrengthUpdatedAt)
-            putIfNotNull("deviceModel", deviceModel)
-            putIfNotNull("androidVersion", androidVersion)
-            putIfNotNull("firmwareVersion", firmwareVersion)
-            putIfNotNull("besFirmwareVersion", besFirmwareVersion)
-            putIfNotNull("mtkFirmwareVersion", mtkFirmwareVersion)
-            putIfNotNull("bluetoothMacAddress", bluetoothMacAddress)
-            putIfNotNull("leftMacAddress", leftMacAddress)
-            putIfNotNull("rightMacAddress", rightMacAddress)
-            putIfNotNull("macAddress", macAddress)
-            putIfNotNull("buildNumber", buildNumber)
-            putIfNotNull("otaVersionUrl", otaVersionUrl)
-            putIfNotNull("appVersion", appVersion)
-            putIfNotNull("bluetoothName", bluetoothName)
-            putIfNotNull("serialNumber", serialNumber)
-            putIfNotNull("style", style)
-            putIfNotNull("color", color)
-            wifi?.let {
-                put("wifi", it.toMap())
-            }
-            putIfNotNull("batteryLevel", batteryLevel)
-            putIfNotNull("charging", charging)
-            putIfNotNull("caseBatteryLevel", caseBatteryLevel)
-            putIfNotNull("caseCharging", caseCharging)
-            putIfNotNull("caseOpen", caseOpen)
-            putIfNotNull("caseRemoved", caseRemoved)
-            hotspot?.let {
-                put("hotspot", it.toMap())
-            }
-            putIfNotNull("headUp", headUp)
-            putIfNotNull("controllerConnected", controllerConnected)
-            putIfNotNull("controllerFullyBooted", controllerFullyBooted)
-            putIfNotNull("controllerMacAddress", controllerMacAddress)
-            putIfNotNull("controllerBatteryLevel", controllerBatteryLevel)
-            putIfNotNull("controllerSignalStrength", controllerSignalStrength)
-            putIfNotNull("ringSignalStrength", ringSignalStrength)
-        }
-
-    companion object {
-        internal fun fromMap(values: Map<String, Any>): GlassesStatusUpdate =
-            GlassesStatusUpdate(
-                fullyBooted = optionalBoolValue(values, "fullyBooted"),
-                connected = optionalBoolValue(values, "connected"),
-                micEnabled = optionalBoolValue(values, "micEnabled"),
-                connectionState = GlassesConnectionState.optionalFromValue(optionalStringValue(values, "connectionState")),
-                bluetoothClassicConnected = optionalBoolValue(values, "bluetoothClassicConnected"),
-                signalStrength = optionalNumberValue(values, "signalStrength"),
-                signalStrengthUpdatedAt = optionalLongValue(values, "signalStrengthUpdatedAt"),
-                deviceModel = optionalStringValue(values, "deviceModel"),
-                androidVersion = optionalStringValue(values, "androidVersion"),
-                firmwareVersion = optionalStringValue(values, "firmwareVersion"),
-                besFirmwareVersion = optionalStringValue(values, "besFirmwareVersion"),
-                mtkFirmwareVersion = optionalStringValue(values, "mtkFirmwareVersion"),
-                bluetoothMacAddress = optionalStringValue(values, "bluetoothMacAddress"),
-                leftMacAddress = optionalStringValue(values, "leftMacAddress"),
-                rightMacAddress = optionalStringValue(values, "rightMacAddress"),
-                macAddress = optionalStringValue(values, "macAddress"),
-                buildNumber = optionalStringValue(values, "buildNumber"),
-                otaVersionUrl = optionalStringValue(values, "otaVersionUrl"),
-                appVersion = optionalStringValue(values, "appVersion"),
-                bluetoothName = optionalStringValue(values, "bluetoothName"),
-                serialNumber = optionalStringValue(values, "serialNumber"),
-                style = optionalStringValue(values, "style"),
-                color = optionalStringValue(values, "color"),
-                wifi =
-                    if (hasAnyKey(values, "wifi")) {
-                        WifiStatus.fromMap(values)
-                    } else if (hasAnyKey(values, "wifiConnected", "wifiSsid", "wifiLocalIp")) {
-                        WifiStatus.fromStoreMap(values)
-                    } else {
-                        null
-                    },
-                batteryLevel = optionalNumberValue(values, "batteryLevel"),
-                charging = optionalBoolValue(values, "charging"),
-                caseBatteryLevel = optionalNumberValue(values, "caseBatteryLevel"),
-                caseCharging = optionalBoolValue(values, "caseCharging"),
-                caseOpen = optionalBoolValue(values, "caseOpen"),
-                caseRemoved = optionalBoolValue(values, "caseRemoved"),
-                hotspot =
-                    if (hasAnyKey(values, "hotspot")) {
-                        HotspotStatus.fromMap(values)
-                    } else if (hasAnyKey(values, "hotspotEnabled", "hotspotSsid", "hotspotPassword", "hotspotGatewayIp")) {
-                        HotspotStatus.fromStoreMap(values)
-                    } else {
-                        null
-                    },
-                headUp = optionalBoolValue(values, "headUp"),
-                controllerConnected = optionalBoolValue(values, "controllerConnected"),
-                controllerFullyBooted = optionalBoolValue(values, "controllerFullyBooted"),
-                controllerMacAddress = optionalStringValue(values, "controllerMacAddress"),
-                controllerBatteryLevel = optionalNumberValue(values, "controllerBatteryLevel"),
-                controllerSignalStrength = optionalNumberValue(values, "controllerSignalStrength"),
-                ringSignalStrength = optionalNumberValue(values, "ringSignalStrength"),
-            )
-    }
-}
-
-data class BluetoothStatusUpdate(
-    val searching: Boolean? = null,
-    val searchingController: Boolean? = null,
-    val systemMicUnavailable: Boolean? = null,
-    val micEnabled: Boolean? = null,
-    val currentMic: String? = null,
-    val micRanking: List<String>? = null,
-    /**
-     * Nearby glasses in stable discovery order when included in an update. Existing entries keep
-     * their array position as details refresh; new glasses append at the end, and removals should
-     * not reorder remaining entries.
-     */
-    val searchResults: List<Device>? = null,
-    val wifiScanResults: List<WifiScanResult>? = null,
-    val lastLog: List<String>? = null,
-    val otherBtConnected: Boolean? = null,
-    val defaultWearable: String? = null,
-    val pendingWearable: String? = null,
-    val deviceName: String? = null,
-    val deviceAddress: String? = null,
-    val defaultController: String? = null,
-    val pendingController: String? = null,
-    val controllerDeviceName: String? = null,
-    val screenDisabled: Boolean? = null,
-    val preferredMic: String? = null,
-    val sensingEnabled: Boolean? = null,
-    val powerSavingMode: Boolean? = null,
-    val brightness: Int? = null,
-    val autoBrightness: Boolean? = null,
-    val dashboardHeight: Int? = null,
-    val dashboardDepth: Int? = null,
-    val headUpAngle: Int? = null,
-    val contextualDashboard: Boolean? = null,
-    val galleryModeAuto: Boolean? = null,
-    val buttonPhotoSize: ButtonPhotoSize? = null,
-    val buttonCameraLed: Boolean? = null,
-    val buttonMaxRecordingTime: Int? = null,
-    val buttonVideoWidth: Int? = null,
-    val buttonVideoHeight: Int? = null,
-    val buttonVideoFrameRate: Int? = null,
-    val shouldSendPcm: Boolean? = null,
-    val shouldSendLc3: Boolean? = null,
-    val shouldSendTranscript: Boolean? = null,
-    val bypassVad: Boolean? = null,
-    val offlineCaptionsRunning: Boolean? = null,
-    val localSttFallbackActive: Boolean? = null,
-    val shouldSendBootingMessage: Boolean? = null,
-) {
-    internal fun toMap(): Map<String, Any> =
-        buildMap {
-            putIfNotNull("searching", searching)
-            putIfNotNull("searchingController", searchingController)
-            putIfNotNull("systemMicUnavailable", systemMicUnavailable)
-            putIfNotNull("micEnabled", micEnabled)
-            putIfNotNull("currentMic", currentMic)
-            putIfNotNull("micRanking", micRanking)
-            searchResults?.let { put("searchResults", it.map(Device::toMap)) }
-            wifiScanResults?.let { put("wifiScanResults", it.map(WifiScanResult::toMap)) }
-            putIfNotNull("lastLog", lastLog)
-            putIfNotNull("otherBtConnected", otherBtConnected)
-            putIfNotNull("default_wearable", defaultWearable)
-            putIfNotNull("pending_wearable", pendingWearable)
-            putIfNotNull("device_name", deviceName)
-            putIfNotNull("device_address", deviceAddress)
-            putIfNotNull("default_controller", defaultController)
-            putIfNotNull("pending_controller", pendingController)
-            putIfNotNull("controller_device_name", controllerDeviceName)
-            putIfNotNull("screen_disabled", screenDisabled)
-            putIfNotNull("preferred_mic", preferredMic)
-            putIfNotNull("sensing_enabled", sensingEnabled)
-            putIfNotNull("power_saving_mode", powerSavingMode)
-            putIfNotNull("brightness", brightness)
-            putIfNotNull("auto_brightness", autoBrightness)
-            putIfNotNull("dashboard_height", dashboardHeight)
-            putIfNotNull("dashboard_depth", dashboardDepth)
-            putIfNotNull("head_up_angle", headUpAngle)
-            putIfNotNull("contextual_dashboard", contextualDashboard)
-            putIfNotNull("galleryModeAuto", galleryModeAuto)
-            buttonPhotoSize?.let { put("button_photo_size", it.value) }
-            putIfNotNull("button_camera_led", buttonCameraLed)
-            putIfNotNull("button_max_recording_time", buttonMaxRecordingTime)
-            putIfNotNull("button_video_width", buttonVideoWidth)
-            putIfNotNull("button_video_height", buttonVideoHeight)
-            putIfNotNull("button_video_fps", buttonVideoFrameRate)
-            putIfNotNull("should_send_pcm", shouldSendPcm)
-            putIfNotNull("should_send_lc3", shouldSendLc3)
-            putIfNotNull("should_send_transcript", shouldSendTranscript)
-            putIfNotNull("bypass_vad", bypassVad)
-            putIfNotNull("offline_captions_running", offlineCaptionsRunning)
-            putIfNotNull("local_stt_fallback_active", localSttFallbackActive)
-            putIfNotNull("shouldSendBootingMessage", shouldSendBootingMessage)
-        }
-
-    companion object {
-        internal fun fromMap(values: Map<String, Any>): BluetoothStatusUpdate =
-            BluetoothStatusUpdate(
-                searching = optionalBoolValue(values, "searching"),
-                searchingController = optionalBoolValue(values, "searchingController"),
-                systemMicUnavailable = optionalBoolValue(values, "systemMicUnavailable"),
-                micEnabled = optionalBoolValue(values, "micEnabled"),
-                currentMic = optionalStringValue(values, "currentMic"),
-                micRanking = optionalStringListValue(values, "micRanking"),
-                searchResults =
-                    optionalMapListValue(values, "searchResults")
-                        ?.mapNotNull(Device::fromMap),
-                wifiScanResults =
-                    optionalMapListValue(values, "wifiScanResults")
-                        ?.map(WifiScanResult::fromMap),
-                lastLog = optionalStringListValue(values, "lastLog"),
-                otherBtConnected = optionalBoolValue(values, "otherBtConnected"),
-                defaultWearable = optionalStringValue(values, "default_wearable"),
-                pendingWearable = optionalStringValue(values, "pending_wearable"),
-                deviceName = optionalStringValue(values, "device_name"),
-                deviceAddress = optionalStringValue(values, "device_address"),
-                defaultController = optionalStringValue(values, "default_controller"),
-                pendingController = optionalStringValue(values, "pending_controller"),
-                controllerDeviceName = optionalStringValue(values, "controller_device_name"),
-                screenDisabled = optionalBoolValue(values, "screen_disabled"),
-                preferredMic = optionalStringValue(values, "preferred_mic"),
-                sensingEnabled = optionalBoolValue(values, "sensing_enabled"),
-                powerSavingMode = optionalBoolValue(values, "power_saving_mode"),
-                brightness = optionalNumberValue(values, "brightness"),
-                autoBrightness = optionalBoolValue(values, "auto_brightness"),
-                dashboardHeight = optionalNumberValue(values, "dashboard_height"),
-                dashboardDepth = optionalNumberValue(values, "dashboard_depth"),
-                headUpAngle = optionalNumberValue(values, "head_up_angle"),
-                contextualDashboard = optionalBoolValue(values, "contextual_dashboard"),
-                galleryModeAuto = optionalBoolValue(values, "galleryModeAuto"),
-                buttonPhotoSize =
-                    optionalStringValue(values, "button_photo_size")?.let(ButtonPhotoSize::fromValue),
-                buttonCameraLed = optionalBoolValue(values, "button_camera_led"),
-                buttonMaxRecordingTime = optionalNumberValue(values, "button_max_recording_time"),
-                buttonVideoWidth = optionalNumberValue(values, "button_video_width"),
-                buttonVideoHeight = optionalNumberValue(values, "button_video_height"),
-                buttonVideoFrameRate = optionalNumberValue(values, "button_video_fps"),
-                shouldSendPcm = optionalBoolValue(values, "should_send_pcm"),
-                shouldSendLc3 = optionalBoolValue(values, "should_send_lc3"),
-                shouldSendTranscript = optionalBoolValue(values, "should_send_transcript"),
-                bypassVad = optionalBoolValue(values, "bypass_vad"),
-                offlineCaptionsRunning = optionalBoolValue(values, "offline_captions_running"),
-                localSttFallbackActive = optionalBoolValue(values, "local_stt_fallback_active"),
-                shouldSendBootingMessage = optionalBoolValue(values, "shouldSendBootingMessage"),
-            )
-    }
-}
-
-data class DisplayTextRequest(
-    val text: String,
-    val x: Int = 0,
-    val y: Int = 0,
-    val size: Int = 24,
-) {
-    fun toMap(): Map<String, Any> =
-        mapOf(
-            "text" to text,
-            "x" to x,
-            "y" to y,
-            "size" to size,
-        )
-}
-
-internal data class DisplayEventRequest(
-    val values: Map<String, Any>,
-) {
-    fun toMap(): Map<String, Any> = values
-}
-
-data class DashboardPositionRequest(
-    val height: Int,
-    val depth: Int,
-)
-
-internal data class DashboardMenuItem(
-    val title: String,
-    val packageName: String,
-    val values: Map<String, Any> = emptyMap(),
-) {
-    fun toMap(): Map<String, Any> =
-        values + mapOf(
-            "title" to title,
-            "packageName" to packageName,
-        )
-}
-
-enum class GalleryMode {
-    AUTO,
-    MANUAL,
-}
-
-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 frameRate: Int,
-)
-
-enum class CameraFov(val fov: Int, val roiPosition: Int) {
-    STANDARD(118, 0),
-    WIDE(118, 0),
-}
-
-enum class MicPreference(val value: String) {
-    AUTO("auto"),
-    PHONE("phone"),
-    GLASSES("glasses"),
-    BLUETOOTH("bluetooth"),
-}
-
-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 sound: Boolean = true,
-)
-
-data class StreamVideoConfig @JvmOverloads constructor(
-    val width: Int? = null,
-    val height: Int? = null,
-    val bitrate: Int? = null,
-    val frameRate: Int? = null,
-) {
-    fun toMap(): Map<String, Any> =
-        listOfNotNull(
-            width?.let { "width" to it },
-            height?.let { "height" to it },
-            bitrate?.let { "bitrate" to it },
-            frameRate?.let { "frameRate" to it },
-        ).toMap()
-
-    companion object {
-        @JvmStatic
-        fun fromMap(values: Map<String, Any>?): StreamVideoConfig? {
-            values ?: return null
-            return StreamVideoConfig(
-                width = numberValue(values, "width"),
-                height = numberValue(values, "height"),
-                bitrate = numberValue(values, "bitrate"),
-                frameRate = numberValue(values, "frameRate"),
-            )
-        }
-    }
-}
-
-data class StreamAudioConfig @JvmOverloads constructor(
-    val bitrate: Int? = null,
-    val sampleRate: Int? = null,
-    val echoCancellation: Boolean? = null,
-    val noiseSuppression: Boolean? = null,
-) {
-    fun toMap(): Map<String, Any> =
-        listOfNotNull(
-            bitrate?.let { "bitrate" to it },
-            sampleRate?.let { "sampleRate" to it },
-            echoCancellation?.let { "echoCancellation" to it },
-            noiseSuppression?.let { "noiseSuppression" to it },
-        ).toMap()
-
-    companion object {
-        @JvmStatic
-        fun fromMap(values: Map<String, Any>?): StreamAudioConfig? {
-            values ?: return null
-            return StreamAudioConfig(
-                bitrate = numberValue(values, "bitrate"),
-                sampleRate = numberValue(values, "sampleRate"),
-                echoCancellation = values["echoCancellation"] as? Boolean,
-                noiseSuppression = values["noiseSuppression"] as? Boolean,
-            )
-        }
-    }
-}
-
-data class StreamRequest @JvmOverloads constructor(
-    val streamUrl: String,
-    val streamId: String = "",
-    val keepAlive: Boolean = true,
-    val keepAliveIntervalSeconds: Int = 15,
-    val sound: Boolean = true,
-    val video: StreamVideoConfig? = null,
-    val audio: StreamAudioConfig? = null,
-    val extraValues: Map<String, Any> = emptyMap(),
-) {
-    fun toMap(): Map<String, Any> {
-        val values = extraValues.toMutableMap()
-        values["type"] = "start_stream"
-        values["streamUrl"] = streamUrl
-        values["streamId"] = streamId
-        values["keepAlive"] = keepAlive
-        values["keepAliveIntervalSeconds"] = keepAliveIntervalSeconds
-        // The camera light is a privacy indicator and cannot be disabled by SDK callers.
-        values["flash"] = true
-        values["sound"] = sound
-        video?.toMap()?.takeIf { it.isNotEmpty() }?.let { values["video"] = it }
-        audio?.toMap()?.takeIf { it.isNotEmpty() }?.let { values["audio"] = it }
-        return values
-    }
-
-    companion object {
-        @JvmStatic
-        fun fromMap(values: Map<String, Any>): StreamRequest =
-            StreamRequest(
-                streamUrl =
-                    (values["streamUrl"] ?: values["rtmpUrl"] ?: values["srtUrl"] ?: values["whipUrl"]) as? String
-                        ?: "",
-                streamId = values["streamId"] as? String ?: "",
-                keepAlive = values["keepAlive"] as? Boolean ?: true,
-                keepAliveIntervalSeconds = (values["keepAliveIntervalSeconds"] as? Number)?.toInt() ?: 15,
-                sound = values["sound"] as? Boolean ?: true,
-                video = StreamVideoConfig.fromMap(stringMapValue(values["video"])),
-                audio = StreamAudioConfig.fromMap(stringMapValue(values["audio"])),
-                extraValues = values,
-            )
-    }
-}
-
-data class StreamKeepAliveRequest @JvmOverloads constructor(
-    val streamId: String,
-    val ackId: String,
-    val extraValues: Map<String, Any> = emptyMap(),
-) {
-    fun toMap(): Map<String, Any> {
-        val values = extraValues.toMutableMap()
-        values["type"] = "keep_stream_alive"
-        values["streamId"] = streamId
-        values["ackId"] = ackId
-        return values
-    }
-
-    companion object {
-        @JvmStatic
-        fun fromMap(values: Map<String, Any>): StreamKeepAliveRequest =
-            StreamKeepAliveRequest(
-                streamId = values["streamId"] as? String ?: "",
-                ackId = values["ackId"] as? String ?: "",
-                extraValues = values,
-            )
-    }
-}
-
-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 ButtonPressEvent(
-    val buttonId: String,
-    val pressType: String,
-    val timestamp: Long? = null,
-)
-
-data class TouchEvent(
-    val values: Map<String, Any>,
-) {
-    val deviceModel: String? get() = stringValue(values, "deviceModel")
-    val gestureName: String? get() = stringValue(values, "gestureName")
-    val timestamp: Long? get() = longValue(values, "timestamp")
-    val isSwipe: Boolean get() = gestureName?.contains("swipe", ignoreCase = true) == true
-}
-
-data class SwipeEvent(
-    val values: Map<String, Any>,
-) {
-    val deviceModel: String? get() = stringValue(values, "deviceModel")
-    val gestureName: String? get() = stringValue(values, "gestureName")
-    val timestamp: Long? get() = longValue(values, "timestamp")
-}
-
-data class BatteryStatusEvent(
-    val level: Int?,
-    val charging: Boolean?,
-    val values: Map<String, Any>,
-)
-
-sealed interface WifiStatus {
-    val state: String
-
-    fun toMap(): Map<String, Any> =
-        when (this) {
-            is Connected -> {
-                val values =
-                    mutableMapOf<String, Any>(
-                        "state" to state,
-                        "ssid" to ssid,
-                    )
-                localIp?.let { values["localIp"] = it }
-                values
-            }
-            Disconnected -> mapOf("state" to state)
-        }
-
-    fun toEventMap(): Map<String, Any> =
-        toMap() + mapOf("type" to "wifi_status_change")
-
-    object Disconnected : WifiStatus {
-        override val state: String = "disconnected"
-    }
-
-    data class Connected(
-        val ssid: String,
-        val localIp: String?,
-    ) : WifiStatus {
-        override val state: String = "connected"
-    }
-
-    companion object {
-        internal fun fromMap(values: Map<String, Any>): WifiStatus? {
-            val wifiValues = (values["wifi"] as? Map<*, *>)?.stringKeyedMap() ?: values
-            return when (stringValue(wifiValues, "state")?.lowercase()) {
-                "connected" -> connectedFrom(wifiValues)
-                "disconnected" -> Disconnected
-                else -> null
-            }
-        }
-
-        internal fun fromStoreMap(values: Map<String, Any>): WifiStatus? {
-            val connected = boolValue(values, "wifiConnected") ?: return null
-            return fromStoreFields(
-                connected = connected,
-                ssid = stringValue(values, "wifiSsid"),
-                localIp = stringValue(values, "wifiLocalIp"),
-            )
-        }
-
-        internal fun fromStoreFields(connected: Boolean, ssid: String?, localIp: String?): WifiStatus? {
-            if (!connected) return Disconnected
-            val nonEmptySsid = ssid?.trim()?.takeIf { it.isNotEmpty() }
-            val nonEmptyLocalIp = localIp?.trim()?.takeIf { it.isNotEmpty() }
-            return nonEmptySsid?.let { Connected(it, nonEmptyLocalIp) }
-        }
-
-        private fun connectedFrom(values: Map<String, Any>): WifiStatus? =
-            fromStoreFields(
-                connected = true,
-                ssid = stringValue(values, "ssid"),
-                localIp = stringValue(values, "localIp"),
-            )
-    }
-}
-
-data class WifiStatusEvent(
-    val status: WifiStatus,
-) {
-    internal constructor(values: Map<String, Any>) : this(WifiStatus.fromMap(values) ?: WifiStatus.Disconnected)
-    internal constructor(connected: Boolean, ssid: String?, localIp: String?) : this(
-        WifiStatus.fromStoreFields(connected, ssid, localIp) ?: WifiStatus.Disconnected
-    )
-
-    val values: Map<String, Any> get() = status.toEventMap()
-}
-
-sealed interface HotspotStatus {
-    val state: String
-
-    fun toMap(): Map<String, Any> =
-        when (this) {
-            is Enabled ->
-                mapOf(
-                    "state" to state,
-                    "ssid" to ssid,
-                    "password" to password,
-                    "localIp" to localIp,
-                )
-            Disabled -> mapOf("state" to state)
-        }
-
-    fun toEventMap(): Map<String, Any> =
-        toMap() + mapOf("type" to "hotspot_status_change")
-
-    object Disabled : HotspotStatus {
-        override val state: String = "disabled"
-    }
-
-    data class Enabled(
-        val ssid: String,
-        val password: String,
-        val localIp: String,
-    ) : HotspotStatus {
-        override val state: String = "enabled"
-    }
-
-    companion object {
-        internal fun fromMap(values: Map<String, Any>): HotspotStatus? {
-            val hotspotValues = (values["hotspot"] as? Map<*, *>)?.stringKeyedMap() ?: values
-            return when (stringValue(hotspotValues, "state")?.lowercase()) {
-                "enabled" -> enabledFrom(hotspotValues)
-                "disabled" -> Disabled
-                else -> null
-            }
-        }
-
-        internal fun fromStoreMap(values: Map<String, Any>): HotspotStatus? {
-            val enabled = boolValue(values, "hotspotEnabled") ?: return null
-            return fromStoreFields(
-                enabled = enabled,
-                ssid = stringValue(values, "hotspotSsid"),
-                password = stringValue(values, "hotspotPassword"),
-                localIp = stringValue(values, "hotspotGatewayIp"),
-            )
-        }
-
-        internal fun fromStoreFields(
-            enabled: Boolean,
-            ssid: String?,
-            password: String?,
-            localIp: String?,
-        ): HotspotStatus? {
-            if (!enabled) return Disabled
-            val nonEmptySsid = ssid?.trim()?.takeIf { it.isNotEmpty() }
-            val nonEmptyPassword = password?.trim()?.takeIf { it.isNotEmpty() }
-            val nonEmptyLocalIp = localIp?.trim()?.takeIf { it.isNotEmpty() }
-            return if (nonEmptySsid != null && nonEmptyPassword != null && nonEmptyLocalIp != null) {
-                Enabled(nonEmptySsid, nonEmptyPassword, nonEmptyLocalIp)
-            } else {
-                null
-            }
-        }
-
-        private fun enabledFrom(values: Map<String, Any>): HotspotStatus? =
-            fromStoreFields(
-                enabled = true,
-                ssid = stringValue(values, "ssid"),
-                password = stringValue(values, "password"),
-                localIp = stringValue(values, "localIp"),
-            )
-    }
-}
-
-data class HotspotStatusEvent(
-    val status: HotspotStatus,
-) {
-    internal constructor(values: Map<String, Any>) : this(HotspotStatus.fromMap(values) ?: HotspotStatus.Disabled)
-    internal constructor(enabled: Boolean, ssid: String?, password: String?, localIp: String?) : this(
-        HotspotStatus.fromStoreFields(enabled, ssid, password, localIp) ?: HotspotStatus.Disabled
-    )
-
-    val values: Map<String, Any> get() = status.toEventMap()
-}
-
-data class HotspotErrorEvent(
-    val values: Map<String, Any>,
-) {
-    val message: String? get() = stringValue(values, "errorMessage")
-    val timestamp: Long? get() = longValue(values, "timestamp")
-}
-
-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()
-}
-
-enum class StreamState(val value: String) {
-    INITIALIZING("initializing"),
-    STREAMING("streaming"),
-    STOPPING("stopping"),
-    STOPPED("stopped"),
-    RECONNECTING("reconnecting"),
-    RECONNECTED("reconnected"),
-    RECONNECT_FAILED("reconnect_failed"),
-    ERROR("error");
-
-    companion object {
-        @JvmStatic
-        fun fromValue(value: String?): StreamState? =
-            when (value?.lowercase()) {
-                "initializing", "starting", "connecting" -> INITIALIZING
-                "streaming", "streaming_started", "active" -> STREAMING
-                "stopping" -> STOPPING
-                "stopped", "not_streaming", "disconnected", "timeout" -> STOPPED
-                "reconnecting" -> RECONNECTING
-                "reconnected" -> RECONNECTED
-                "reconnect_failed" -> RECONNECT_FAILED
-                "error", "error_not_streaming" -> ERROR
-                else -> null
-            }
-    }
-}
-
-enum class StreamStatusKind(val value: String) {
-    LIFECYCLE("lifecycle"),
-    RECONNECT("reconnect"),
-    ERROR("error"),
-    SNAPSHOT("snapshot"),
-}
-
-sealed interface StreamStatus {
-    val kind: StreamStatusKind
-    val state: StreamState
-    val streamId: String?
-    val timestamp: Long?
-
-    fun toMap(): Map<String, Any> {
-        val values = mutableMapOf<String, Any>(
-            "kind" to kind.value,
-            "status" to state.value,
-        )
-        streamId?.takeIf { it.isNotBlank() }?.let { values["streamId"] = it }
-        timestamp?.let { values["timestamp"] = it }
-
-        when (this) {
-            is Lifecycle -> Unit
-            is Reconnecting -> {
-                values["attempt"] = attempt
-                values["maxAttempts"] = maxAttempts
-                values["reason"] = reason
-            }
-            is Reconnected -> values["attempt"] = attempt
-            is ReconnectFailed -> values["maxAttempts"] = maxAttempts
-            is Error -> values["errorDetails"] = errorDetails
-            is Snapshot -> {
-                values["streaming"] = streaming
-                values["reconnecting"] = reconnecting
-                attempt?.let { values["attempt"] = it }
-            }
-        }
-
-        return values
-    }
-
-    fun toEventMap(): Map<String, Any> = toMap() + mapOf("type" to "stream_status")
-
-    data class Lifecycle(
-        override val state: StreamState,
-        override val streamId: String?,
-        override val timestamp: Long?,
-    ) : StreamStatus {
-        override val kind: StreamStatusKind = StreamStatusKind.LIFECYCLE
-    }
-
-    data class Reconnecting(
-        override val streamId: String?,
-        val attempt: Int,
-        val maxAttempts: Int,
-        val reason: String,
-        override val timestamp: Long?,
-    ) : StreamStatus {
-        override val kind: StreamStatusKind = StreamStatusKind.RECONNECT
-        override val state: StreamState = StreamState.RECONNECTING
-    }
-
-    data class Reconnected(
-        override val streamId: String?,
-        val attempt: Int,
-        override val timestamp: Long?,
-    ) : StreamStatus {
-        override val kind: StreamStatusKind = StreamStatusKind.RECONNECT
-        override val state: StreamState = StreamState.RECONNECTED
-    }
-
-    data class ReconnectFailed(
-        override val streamId: String?,
-        val maxAttempts: Int,
-        override val timestamp: Long?,
-    ) : StreamStatus {
-        override val kind: StreamStatusKind = StreamStatusKind.RECONNECT
-        override val state: StreamState = StreamState.RECONNECT_FAILED
-    }
-
-    data class Error(
-        override val streamId: String?,
-        val errorDetails: String,
-        override val timestamp: Long?,
-    ) : StreamStatus {
-        override val kind: StreamStatusKind = StreamStatusKind.ERROR
-        override val state: StreamState = StreamState.ERROR
-    }
-
-    data class Snapshot(
-        override val state: StreamState,
-        val streaming: Boolean,
-        val reconnecting: Boolean,
-        override val streamId: String?,
-        val attempt: Int?,
-        override val timestamp: Long?,
-    ) : StreamStatus {
-        override val kind: StreamStatusKind = StreamStatusKind.SNAPSHOT
-    }
-
-    companion object {
-        @JvmStatic
-        fun fromMap(values: Map<String, Any>): StreamStatus {
-            val rawState = stringValue(values, "status")
-            val streaming = boolValue(values, "streaming")
-            val reconnecting = boolValue(values, "reconnecting") ?: false
-            val streamId = stringValue(values, "streamId")
-            val timestamp = longValue(values, "timestamp")
-            val attempt = numberValue(values, "attempt")
-            val maxAttempts = numberValue(values, "maxAttempts") ?: 0
-
-            if (streaming != null || hasAnyKey(values, "reconnecting")) {
-                return Snapshot(
-                    state = when {
-                        reconnecting -> StreamState.RECONNECTING
-                        streaming == true -> StreamState.STREAMING
-                        else -> StreamState.STOPPED
-                    },
-                    streaming = streaming == true,
-                    reconnecting = reconnecting,
-                    streamId = streamId,
-                    attempt = attempt,
-                    timestamp = timestamp,
-                )
-            }
-
-            val state = StreamState.fromValue(rawState)
-                ?: return Error(
-                    streamId = streamId,
-                    errorDetails = rawState?.let { "Unknown stream status: $it" } ?: "Missing stream status",
-                    timestamp = timestamp,
-                )
-
-            return when (state) {
-                StreamState.RECONNECTING -> Reconnecting(
-                    streamId = streamId,
-                    attempt = attempt ?: 0,
-                    maxAttempts = maxAttempts,
-                    reason = stringValue(values, "reason") ?: "",
-                    timestamp = timestamp,
-                )
-                StreamState.RECONNECTED -> Reconnected(
-                    streamId = streamId,
-                    attempt = attempt ?: 0,
-                    timestamp = timestamp,
-                )
-                StreamState.RECONNECT_FAILED -> ReconnectFailed(
-                    streamId = streamId,
-                    maxAttempts = maxAttempts,
-                    timestamp = timestamp,
-                )
-                StreamState.ERROR -> Error(
-                    streamId = streamId,
-                    errorDetails = stringValue(values, "errorDetails")
-                        ?: if (rawState == "error_not_streaming") "not_streaming" else "Unknown stream error",
-                    timestamp = timestamp,
-                )
-                else -> Lifecycle(
-                    state = state,
-                    streamId = streamId,
-                    timestamp = timestamp,
-                )
-            }
-        }
-    }
-}
-
-data class StreamStatusEvent(
-    val status: StreamStatus,
-) {
-    constructor(values: Map<String, Any>) : this(StreamStatus.fromMap(values))
-
-    val state: StreamState get() = status.state
-    val streamId: String? get() = status.streamId
-    val values: Map<String, Any> get() = status.toEventMap()
-}
-
-data class KeepAliveAckEvent(
-    val streamId: String,
-    val ackId: String,
-    val timestamp: Long?,
-) {
-    constructor(values: Map<String, Any>) : this(
-        streamId = stringValue(values, "streamId").orEmpty(),
-        ackId = stringValue(values, "ackId").orEmpty(),
-        timestamp = longValue(values, "timestamp"),
-    )
-
-    val values: Map<String, Any>
-        get() = buildMap {
-            put("type", "keep_alive_ack")
-            put("streamId", streamId)
-            put("ackId", ackId)
-            timestamp?.let { put("timestamp", it) }
-        }
-}
-
-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,
-            )
-    }
-}
-
-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,
-) {
-    @Volatile
-    private var stopped = false
-
-    fun stop() {
-        if (stopped) return
-        stopped = true
-        stopAction()
-    }
-
-    internal fun markStopped() {
-        stopped = true
-    }
-}
-
-interface MentraBluetoothSdkListener {
-    fun onGlassesStatusChanged(status: GlassesStatusUpdate) {}
-    fun onBluetoothStatusChanged(status: BluetoothStatusUpdate) {}
-    fun onDeviceDiscovered(device: Device) {}
-    fun onScanStopped(reason: ScanStopReason) {}
-    fun onButtonPress(event: ButtonPressEvent) {}
-    fun onTouch(event: TouchEvent) {}
-    fun onSwipe(event: SwipeEvent) {}
-    fun onHeadUpChanged(headUp: Boolean) {}
-    fun onBatteryStatus(event: BatteryStatusEvent) {}
-    fun onWifiStatusChanged(event: WifiStatusEvent) {}
-    fun onHotspotStatusChanged(event: HotspotStatusEvent) {}
-    fun onHotspotError(event: HotspotErrorEvent) {}
-    fun onGalleryStatus(event: GalleryStatusEvent) {}
-    fun onPhotoResponse(event: PhotoResponseEvent) {}
-    fun onStreamStatus(event: StreamStatusEvent) {}
-    fun onKeepAliveAck(event: KeepAliveAckEvent) {}
-    fun onMicPcm(frame: ByteArray) {}
-    fun onMicLc3(frame: ByteArray) {}
-    fun onLocalTranscription(event: LocalTranscriptionEvent) {}
-    fun onDefaultDeviceChanged(device: Device?) {}
-    fun onLog(message: String) {}
-    fun onError(error: BluetoothError) {}
-    fun onRawEvent(eventName: String, values: Map<String, Any>) {}
-}
-
-abstract class MentraBluetoothSdkCallback : MentraBluetoothSdkListener
-
-private fun numberValue(
-    values: Map<String, Any>,
-    vararg keys: String,
-): Int? =
-    keys.firstNotNullOfOrNull { key ->
-        (values[key] as? Number)?.toInt()
-    }
-
-private fun stringValue(
-    values: Map<String, Any>,
-    vararg keys: String,
-): String? =
-    keys.firstNotNullOfOrNull { key ->
-        values[key]?.let { it as? String }
-    }
-
-private fun boolValue(
-    values: Map<String, Any>,
-    vararg keys: String,
-): Boolean? =
-    keys.firstNotNullOfOrNull { key ->
-        values[key] as? Boolean
-    }
-
-private fun longValue(
-    values: Map<String, Any>,
-    vararg keys: String,
-): Long? =
-    keys.firstNotNullOfOrNull { key ->
-        (values[key] as? Number)?.toLong()
-    }
-
-private fun hasAnyKey(
-    values: Map<String, Any>,
-    vararg keys: String,
-): Boolean = keys.any(values::containsKey)
-
-private fun Map<*, *>.stringKeyedMap(): Map<String, Any> =
-    entries.mapNotNull { (key, value) ->
-        val stringKey = key as? String ?: return@mapNotNull null
-        val anyValue = value ?: return@mapNotNull null
-        stringKey to anyValue
-    }.toMap()
-
-private fun optionalNumberValue(
-    values: Map<String, Any>,
-    vararg keys: String,
-): Int? =
-    if (hasAnyKey(values, *keys)) {
-        numberValue(values, *keys)
-    } else {
-        null
-    }
-
-private fun optionalLongValue(
-    values: Map<String, Any>,
-    vararg keys: String,
-): Long? =
-    if (hasAnyKey(values, *keys)) {
-        longValue(values, *keys)
-    } else {
-        null
-    }
-
-private fun optionalStringValue(
-    values: Map<String, Any>,
-    vararg keys: String,
-): String? =
-    if (hasAnyKey(values, *keys)) {
-        stringValue(values, *keys) ?: ""
-    } else {
-        null
-    }
-
-private fun optionalBoolValue(
-    values: Map<String, Any>,
-    vararg keys: String,
-): Boolean? =
-    if (hasAnyKey(values, *keys)) {
-        boolValue(values, *keys) ?: false
-    } else {
-        null
-    }
-
-private fun stringListValue(
-    values: Map<String, Any>,
-    key: String,
-): List<String> = (values[key] as? List<*>)?.mapNotNull { it as? String } ?: emptyList()
-
-private fun optionalStringListValue(
-    values: Map<String, Any>,
-    key: String,
-): List<String>? =
-    if (values.containsKey(key)) {
-        stringListValue(values, key)
-    } else {
-        null
-    }
-
-private fun mapListValue(
-    values: Map<String, Any>,
-    key: String,
-): List<Map<String, Any>> =
-    (values[key] as? List<*>)?.mapNotNull(::stringMapValue) ?: emptyList()
-
-private fun optionalMapListValue(
-    values: Map<String, Any>,
-    key: String,
-): List<Map<String, Any>>? =
-    if (values.containsKey(key)) {
-        mapListValue(values, key)
-    } else {
-        null
-    }
-
-private fun stringMapValue(value: Any?): Map<String, Any>? =
-    (value as? Map<*, *>)?.entries?.mapNotNull { (key, mapValue) ->
-        val stringKey = key as? String ?: return@mapNotNull null
-        val nonNullValue = mapValue ?: return@mapNotNull null
-        stringKey to nonNullValue
-    }?.toMap()
-
-private fun MutableMap<String, Any>.putIfNotNull(
-    key: String,
-    value: Any?,
-) {
-    if (value != null) {
-        put(key, value)
-    }
-}