@mentra/bluetooth-sdk 0.1.18 → 0.1.20

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

@@ -67,6 +67,7 @@ class MentraBluetoothSdk private constructor(
         private val SCAN_STATE_KEYS = setOf("searching", "searchingController", "searchResults")
         private const val DEFAULT_SCAN_TIMEOUT_MS = 15_000L
         private const val DEFAULT_REQUEST_TIMEOUT_MS = 15_000L
+        private const val WIFI_SCAN_TIMEOUT_MS = 20_000L
         private const val VIDEO_UPLOAD_STOP_TIMEOUT_MS = 10 * 60 * 1000L
         private const val STREAM_START_TIMEOUT_MS = 30_000L
         private const val STREAM_STOP_TIMEOUT_MS = 15_000L
@@ -476,6 +477,12 @@ class MentraBluetoothSdk private constructor(
         DeviceStore.apply(ObservableStore.BLUETOOTH_CATEGORY, "voice_activity_detection_enabled", enabled)
     }
 
+    @Deprecated(
+        message =
+            "Sticky action-button photo presets are deprecated. Prefer per-request " +
+                "requestPhoto(...) options (e.g. mode=TEXT for AE ÷3, or explicit per-shot fields). " +
+                "This method still works but will be removed in a future release.",
+    )
     fun setPhotoCaptureDefaults(settings: PhotoCaptureDefaults): SettingsAckEvent =
         performSettingsCommand(
             setting = "button_photo",
@@ -533,6 +540,12 @@ class MentraBluetoothSdk private constructor(
         performSettingsCommand(
             setting = "button_video_recording",
             updateStore = { _ ->
+                DeviceStore.set(
+                    ObservableStore.BLUETOOTH_CATEGORY,
+                    "button_video_settings",
+                    mapOf("width" to defaults.width, "height" to defaults.height, "fps" to defaults.fps),
+                )
+                // Keep legacy cache keys readable for older internal callers during migration.
                 DeviceStore.set(ObservableStore.BLUETOOTH_CATEGORY, "button_video_width", defaults.width)
                 DeviceStore.set(ObservableStore.BLUETOOTH_CATEGORY, "button_video_height", defaults.height)
                 DeviceStore.set(ObservableStore.BLUETOOTH_CATEGORY, "button_video_fps", defaults.fps)
@@ -633,35 +646,35 @@ class MentraBluetoothSdk private constructor(
     fun requestWifiScan(): List<WifiScanResult> {
         val pending = PendingResponse<List<WifiScanResult>>("WiFi scan request")
         val request = PendingWifiScan(pending)
-        synchronized(oneShotLock) {
-            if (pendingWifiScan != null) {
-                throw BluetoothSdkException(
-                    "request_in_flight",
-                    "A WiFi scan is already waiting for a glasses response.",
-                )
+        val existing =
+            synchronized(oneShotLock) {
+                pendingWifiScan ?: run {
+                    pendingWifiScan = request
+                    null
+                }
             }
-            pendingWifiScan = request
+        if (existing != null) {
+            // Join the in-flight scan instead of failing with request_in_flight;
+            // the scan screen auto-starts a scan on mount and can be pushed twice.
+            return existing.pending.await(WIFI_SCAN_TIMEOUT_MS)
         }
         try {
             deviceManager.requestWifiScan()
-            return pending.await()
-        } catch (error: BluetoothSdkException) {
-            if (error.code == "request_timeout") {
-                val fallbackResults =
-                    synchronized(oneShotLock) {
-                        if (request.latestResults.isNotEmpty()) {
-                            if (pendingWifiScan === request) {
-                                pendingWifiScan = null
-                            }
-                            request.latestResults
-                        } else {
-                            emptyList()
-                        }
-                    }
+            // The glasses wait up to 15s for scan-results broadcasts before sending
+            // scan_complete, so give them longer than that before falling back.
+            return pending.await(WIFI_SCAN_TIMEOUT_MS)
+        } catch (error: Throwable) {
+            if (error is BluetoothSdkException && error.code == "request_timeout") {
+                val fallbackResults = synchronized(oneShotLock) { request.latestResults }
                 if (fallbackResults.isNotEmpty()) {
+                    // Resolve so callers joined on the same scan get the fallback too.
+                    pending.resolve(fallbackResults)
                     return fallbackResults
                 }
             }
+            // Fail joined callers immediately instead of letting them run out their
+            // own timeout.
+            pending.reject(error)
             throw error
         } finally {
             synchronized(oneShotLock) {

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

@@ -57,7 +57,7 @@ internal object OtaManifestChecker {
         return try {
             val status = connection.responseCode
             if (status !in 200..299) {
-                throw BluetoothSdkException("ota_manifest_request_failed", "OTA manifest request failed with HTTP $status.")
+                throw BluetoothSdkException("ota_manifest_request_failed", "OTA manifest request failed with HTTP $status for $otaVersionUrl.")
             }
             JSONObject(connection.inputStream.bufferedReader().use { it.readText() })
         } finally {

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

@@ -167,6 +167,17 @@ data class CameraFovResult(
     }
 }
 
+enum class PhotoMode(val value: String) {
+    PHOTO("photo"),
+    TEXT("text");
+
+    companion object {
+        @JvmStatic
+        fun fromValue(value: String?): PhotoMode =
+            values().firstOrNull { it.value == value } ?: PHOTO
+    }
+}
+
 data class PhotoRequest @JvmOverloads constructor(
     val requestId: String = generatedCameraRequestId("photo"),
     val size: PhotoSize,
@@ -188,6 +199,7 @@ data class PhotoRequest @JvmOverloads constructor(
     val ispDigitalGain: Int? = null,
     val ispAnalogGain: String? = null,
     val resetCaptureTuning: Boolean? = null,
+    val mode: PhotoMode = PhotoMode.PHOTO,
 ) {
     companion object {
         /** Mirrors iOS `BluetoothSdkModule` defaults for keys omitted from the JS bridge. */
@@ -225,6 +237,7 @@ data class PhotoRequest @JvmOverloads constructor(
                 compress = PhotoCompression.fromValue(stringValue(values, "compress") ?: "none"),
                 save = boolValue(values, "save", "saveToGallery") ?: false,
                 sound = boolValue(values, "sound") ?: true,
+                mode = PhotoMode.fromValue(stringValue(values, "mode")),
                 exposureTimeNs = exposureTimeNs,
                 iso = iso,
                 aeExposureDivisor = aeDivisor,

package/android/src/main/java/com/mentra/bluetoothsdk/sgcs/G1.kt

@@ -2841,7 +2841,7 @@ class G1 : SGCManager() {
     private fun chunkTextForTransmission(text: String?): List<ByteArray> {
         // Handle empty or whitespace-only text by sending at least a space
         // This ensures the display gets updated/cleared properly
-        val textToSend = if (text == null || text.trim().isEmpty()) " " else text
+        val textToSend = if (text == null || text.trim().isEmpty()) " " else sanitizeG1DisplayText(text)
         val textBytes = textToSend.toByteArray(StandardCharsets.UTF_8)
         val totalChunks = Math.ceil(textBytes.size.toDouble() / MAX_CHUNK_SIZE).toInt()
 

package/android/src/main/java/com/mentra/bluetoothsdk/sgcs/G1TextSanitizer.kt

@@ -0,0 +1,38 @@
+package com.mentra.bluetoothsdk.sgcs
+
+import java.text.Normalizer
+
+private val G1_COMBINING_MARKS = Regex("\\p{M}+")
+
+/**
+ * Converts text to the base Latin glyphs available in the Even Realities G1 firmware.
+ *
+ * G1 does not ship glyphs for combining diacritics. Normalize at the device boundary so
+ * miniapps can retain the real text everywhere else and newer glasses receive it unchanged.
+ */
+internal fun sanitizeG1DisplayText(text: String): String {
+    val expanded = buildString(text.length) {
+        text.forEach { character ->
+            when (character) {
+                'Đ', 'Ð' -> append('D')
+                'đ', 'ð' -> append('d')
+                'Ł' -> append('L')
+                'ł' -> append('l')
+                'Ø' -> append('O')
+                'ø' -> append('o')
+                'Æ' -> append("AE")
+                'æ' -> append("ae")
+                'Œ' -> append("OE")
+                'œ' -> append("oe")
+                'ẞ' -> append("SS")
+                'ß' -> append("ss")
+                'Þ' -> append("TH")
+                'þ' -> append("th")
+                else -> append(character)
+            }
+        }
+    }
+
+    return Normalizer.normalize(expanded, Normalizer.Form.NFD)
+        .replace(G1_COMBINING_MARKS, "")
+}