@mentra/bluetooth-sdk 0.1.5 → 0.1.6

package/android/src/main/java/com/mentra/bluetoothsdk/status/RuntimeState.kt

@@ -0,0 +1,199 @@
+package com.mentra.bluetoothsdk
+
+data class MentraBluetoothState(
+    val glasses: GlassesRuntimeState,
+    val sdk: PhoneSdkRuntimeState,
+    val scan: BluetoothScanState,
+) {
+    internal companion object {
+        fun from(
+            glassesStatus: GlassesStatus,
+            bluetoothStatus: BluetoothStatus,
+        ): MentraBluetoothState =
+            MentraBluetoothState(
+                glasses = GlassesRuntimeState.from(glassesStatus),
+                sdk = PhoneSdkRuntimeState.from(bluetoothStatus),
+                scan = BluetoothScanState.from(bluetoothStatus),
+            )
+    }
+}
+
+data class GlassesBatteryState(
+    val charging: Boolean,
+    val level: Int?,
+)
+
+data class ConnectedGlassesInfo(
+    val appVersion: String?,
+    val bluetoothName: String?,
+    val buildNumber: String?,
+    val color: String?,
+    val deviceModel: DeviceModel?,
+    val firmwareVersion: String?,
+    val serialNumber: String?,
+    val style: String?,
+)
+
+enum class FirmwareSource {
+    APP,
+    BES,
+    FIRMWARE,
+    MTK,
+    UNKNOWN,
+}
+
+data class FirmwareInfo(
+    val appVersion: String?,
+    val buildNumber: String?,
+    val source: FirmwareSource,
+    val version: String?,
+)
+
+data class SignalState(
+    val strengthDbm: Int?,
+    val updatedAt: Long?,
+)
+
+sealed interface GlassesRuntimeState {
+    val connected: Boolean
+    val connection: GlassesConnectionState
+    val ready: Boolean
+
+    data class Disconnected(
+        override val connection: GlassesConnectionState = GlassesConnectionState.DISCONNECTED,
+    ) : GlassesRuntimeState {
+        override val connected: Boolean = false
+        override val ready: Boolean = false
+    }
+
+    data class Connected(
+        val battery: GlassesBatteryState,
+        override val connection: GlassesConnectionState,
+        val device: ConnectedGlassesInfo,
+        val firmware: FirmwareInfo,
+        val hotspot: HotspotStatus,
+        override val ready: Boolean,
+        val signal: SignalState,
+        val wifi: WifiStatus,
+    ) : GlassesRuntimeState {
+        override val connected: Boolean = true
+    }
+
+    companion object {
+        internal fun from(status: GlassesStatus): GlassesRuntimeState {
+            if (!status.connected && status.connectionState != GlassesConnectionState.CONNECTED) {
+                return Disconnected(connection = status.connectionState)
+            }
+            return Connected(
+                battery = batteryState(status),
+                connection = GlassesConnectionState.CONNECTED,
+                device = connectedGlassesInfo(status),
+                firmware = firmwareInfo(status),
+                hotspot = status.hotspot,
+                ready = status.fullyBooted,
+                signal = SignalState(
+                    strengthDbm = status.signalStrength.takeUnless { it == -1 },
+                    updatedAt = status.signalStrengthUpdatedAt.takeUnless { it <= 0L },
+                ),
+                wifi = status.wifi,
+            )
+        }
+
+        private fun batteryState(status: GlassesStatus): GlassesBatteryState =
+            GlassesBatteryState(
+                charging = status.charging,
+                level = status.batteryLevel.takeUnless { it < 0 },
+            )
+
+        private fun connectedGlassesInfo(status: GlassesStatus): ConnectedGlassesInfo =
+            ConnectedGlassesInfo(
+                appVersion = status.appVersion.nonBlank(),
+                bluetoothName = status.bluetoothName.nonBlank(),
+                buildNumber = status.buildNumber.nonBlank(),
+                color = status.color.nonBlank(),
+                deviceModel = status.deviceModel.takeIf { it.isNotBlank() }?.let(DeviceModel::fromDeviceType),
+                firmwareVersion = status.firmwareVersion.nonBlank(),
+                serialNumber = status.serialNumber.nonBlank(),
+                style = status.style.nonBlank(),
+            )
+
+        private fun firmwareInfo(status: GlassesStatus): FirmwareInfo {
+            val sources =
+                listOf(
+                    status.firmwareVersion to FirmwareSource.FIRMWARE,
+                    status.besFirmwareVersion to FirmwareSource.BES,
+                    status.mtkFirmwareVersion to FirmwareSource.MTK,
+                    status.appVersion to FirmwareSource.APP,
+                )
+            val match = sources.firstOrNull { (version, _) -> version.isNotBlank() }
+            return FirmwareInfo(
+                appVersion = status.appVersion.nonBlank(),
+                buildNumber = status.buildNumber.nonBlank(),
+                source = match?.second ?: FirmwareSource.UNKNOWN,
+                version = match?.first?.nonBlank(),
+            )
+        }
+    }
+}
+
+enum class MicMode(val value: String) {
+    PHONE("phone"),
+    GLASSES("glasses"),
+    BLUETOOTH_CLASSIC("bluetoothClassic"),
+    BLUETOOTH("bluetooth");
+
+    internal companion object {
+        fun fromValue(value: String?): MicMode? =
+            values().firstOrNull { it.value == value }
+    }
+}
+
+data class GalleryModeState(
+    val desired: GalleryMode,
+)
+
+data class PhoneSdkRuntimeState(
+    val currentMic: MicMode?,
+    val defaultDevice: Device?,
+    val galleryMode: GalleryModeState,
+    val lastLog: List<String>,
+    val micRanking: List<MicMode>,
+    val otherBluetoothConnected: Boolean,
+    val searching: Boolean,
+    val searchingController: Boolean,
+    val systemMicUnavailable: Boolean,
+    val wifiScanResults: List<WifiScanResult>,
+) {
+    internal companion object {
+        fun from(status: BluetoothStatus): PhoneSdkRuntimeState =
+            PhoneSdkRuntimeState(
+                currentMic = MicMode.fromValue(status.currentMic),
+                defaultDevice = status.defaultDevice,
+                galleryMode = GalleryModeState(if (status.galleryModeAuto) GalleryMode.AUTO else GalleryMode.MANUAL),
+                lastLog = status.lastLog,
+                micRanking = status.micRanking.mapNotNull { MicMode.fromValue(it) },
+                otherBluetoothConnected = status.otherBtConnected,
+                searching = status.searching,
+                searchingController = status.searchingController,
+                systemMicUnavailable = status.systemMicUnavailable,
+                wifiScanResults = status.wifiScanResults,
+            )
+    }
+}
+
+data class BluetoothScanState(
+    val active: Boolean,
+    val devices: List<Device>,
+    val searchingController: Boolean,
+) {
+    internal companion object {
+        fun from(status: BluetoothStatus): BluetoothScanState =
+            BluetoothScanState(
+                active = status.searching,
+                devices = status.searchResults,
+                searchingController = status.searchingController,
+            )
+    }
+}
+
+private fun String.nonBlank(): String? = takeIf { it.isNotBlank() }

package/android/src/main/java/com/mentra/bluetoothsdk/status/WifiHotspotStatus.kt

@@ -0,0 +1,173 @@
+package com.mentra.bluetoothsdk
+
+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")
+}