@mentra/bluetooth-sdk 0.1.4 → 0.1.6

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

@@ -0,0 +1,187 @@
+package com.mentra.bluetoothsdk
+
+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),
+}
+
+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,
+)
+
+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/events/BluetoothEvents.kt

@@ -0,0 +1,60 @@
+package com.mentra.bluetoothsdk
+
+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>,
+)
+
+interface MentraBluetoothSdkListener {
+    fun onStateChanged(state: MentraBluetoothState) {}
+    fun onGlassesChanged(glasses: GlassesRuntimeState) {}
+    fun onSdkStateChanged(sdk: PhoneSdkRuntimeState) {}
+    fun onScanChanged(scan: BluetoothScanState) {}
+    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(event: MicPcmEvent) {}
+    fun onMicLc3(event: MicLc3Event) {}
+    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

package/android/src/main/java/com/mentra/bluetoothsdk/internal/MapParsing.kt

@@ -0,0 +1,132 @@
+package com.mentra.bluetoothsdk
+
+internal fun numberValue(
+    values: Map<String, Any>,
+    vararg keys: String,
+): Int? =
+    keys.firstNotNullOfOrNull { key ->
+        (values[key] as? Number)?.toInt()
+    }
+
+internal fun stringValue(
+    values: Map<String, Any>,
+    vararg keys: String,
+): String? =
+    keys.firstNotNullOfOrNull { key ->
+        values[key]?.let { it as? String }
+    }
+
+internal fun boolValue(
+    values: Map<String, Any>,
+    vararg keys: String,
+): Boolean? =
+    keys.firstNotNullOfOrNull { key ->
+        values[key] as? Boolean
+    }
+
+internal fun longValue(
+    values: Map<String, Any>,
+    vararg keys: String,
+): Long? =
+    keys.firstNotNullOfOrNull { key ->
+        (values[key] as? Number)?.toLong()
+    }
+
+internal fun hasAnyKey(
+    values: Map<String, Any>,
+    vararg keys: String,
+): Boolean = keys.any(values::containsKey)
+
+internal 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()
+
+internal fun optionalNumberValue(
+    values: Map<String, Any>,
+    vararg keys: String,
+): Int? =
+    if (hasAnyKey(values, *keys)) {
+        numberValue(values, *keys)
+    } else {
+        null
+    }
+
+internal fun optionalLongValue(
+    values: Map<String, Any>,
+    vararg keys: String,
+): Long? =
+    if (hasAnyKey(values, *keys)) {
+        longValue(values, *keys)
+    } else {
+        null
+    }
+
+internal fun optionalStringValue(
+    values: Map<String, Any>,
+    vararg keys: String,
+): String? =
+    if (hasAnyKey(values, *keys)) {
+        stringValue(values, *keys)
+    } else {
+        null
+    }
+
+internal fun optionalBoolValue(
+    values: Map<String, Any>,
+    vararg keys: String,
+): Boolean? =
+    if (hasAnyKey(values, *keys)) {
+        boolValue(values, *keys)
+    } else {
+        null
+    }
+
+internal fun stringListValue(
+    values: Map<String, Any>,
+    key: String,
+): List<String> = (values[key] as? List<*>)?.mapNotNull { it as? String } ?: emptyList()
+
+internal fun optionalStringListValue(
+    values: Map<String, Any>,
+    key: String,
+): List<String>? =
+    if (values.containsKey(key)) {
+        stringListValue(values, key)
+    } else {
+        null
+    }
+
+internal fun mapListValue(
+    values: Map<String, Any>,
+    key: String,
+): List<Map<String, Any>> =
+    (values[key] as? List<*>)?.mapNotNull(::stringMapValue) ?: emptyList()
+
+internal fun optionalMapListValue(
+    values: Map<String, Any>,
+    key: String,
+): List<Map<String, Any>>? =
+    if (values.containsKey(key)) {
+        mapListValue(values, key)
+    } else {
+        null
+    }
+
+internal 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()
+
+internal fun MutableMap<String, Any>.putIfNotNull(
+    key: String,
+    value: Any?,
+) {
+    if (value != null) {
+        put(key, value)
+    }
+}

package/android/src/main/java/com/mentra/bluetoothsdk/requests/DisplayRequests.kt

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