@mentra/bluetooth-sdk 3.2.1-dev.314 → 3.3.0-beta.942

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

@@ -29,6 +29,10 @@ internal class ClassicAudioConnectionTracker(
     val connected: Boolean
         get() = connectedProfiles.isNotEmpty()
 
+    /** BLE may already be gone when the user explicitly disconnects Classic audio. */
+    @Synchronized
+    fun targetForDisconnect(): String? = targetAddress
+
     @Synchronized
     fun setTarget(address: String) {
         val normalizedAddress = address.normalizedBluetoothAddress()

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

@@ -0,0 +1,70 @@
+package com.mentra.bluetoothsdk.sgcs
+
+import android.bluetooth.BluetoothDevice
+import android.os.Handler
+import android.os.ParcelUuid
+
+/** One bounded SDP discovery; a BLE bond alone does not populate Android's Classic UUID cache. */
+internal class ClassicAudioServiceDiscovery(
+    private val handler: Handler,
+    private val timeoutMs: Long,
+    private val log: (String) -> Unit,
+) {
+    private class Pending(val device: BluetoothDevice, val ready: () -> Unit) {
+        lateinit var timeout: Runnable
+    }
+    private var pending: Pending? = null
+
+    fun connectWhenDiscovered(device: BluetoothDevice, ready: () -> Unit) {
+        if (hasAudioSink(device)) {
+            cancel()
+            ready()
+            return
+        }
+        if (pending?.device?.address == device.address) return
+        cancel()
+        val request = Pending(device, ready)
+        request.timeout = Runnable {
+            if (pending === request) {
+                cancel()
+                log("SDP timed out for ${device.address}; Classic audio remains disconnected")
+            }
+        }
+        pending = request
+        handler.postDelayed(request.timeout, timeoutMs)
+        try {
+            log("Refreshing Classic service UUIDs for ${device.address}")
+            if (!device.fetchUuidsWithSdp()) {
+                cancel()
+                log("SDP request rejected for ${device.address}; Classic audio remains disconnected")
+            }
+        } catch (error: Exception) {
+            cancel()
+            log("SDP request failed for ${device.address}: ${error.message}")
+        }
+    }
+
+    /** ACTION_UUID is a completion hint. Read the current OS cache, not a stale intent payload. */
+    fun onUuids(device: BluetoothDevice) {
+        val request = pending ?: return
+        if (device.address != request.device.address) return
+        if (hasAudioSink(request.device)) {
+            cancel()
+            log("Discovered A2DP Sink UUID for ${device.address}")
+            request.ready()
+        } else {
+            // Bonding can announce cached UUIDs before SDP finishes. Keep the original deadline.
+            log("UUID event without A2DP Sink for ${device.address}; waiting for SDP within the existing deadline")
+        }
+    }
+
+    fun cancel() {
+        pending?.let { handler.removeCallbacks(it.timeout) }
+        pending = null
+    }
+
+    companion object {
+        private val AUDIO_SINK = ParcelUuid.fromString("0000110b-0000-1000-8000-00805f9b34fb")
+        fun hasAudioSink(device: BluetoothDevice): Boolean = device.uuids?.contains(AUDIO_SINK) == true
+    }
+}

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

@@ -1370,8 +1370,8 @@ class G1 : SGCManager() {
         context!!.registerReceiver(bondingReceiver, filter)
         isBondingReceiverRegistered = true
 
-        preferredG1DeviceId = DeviceStore.get("bluetooth", "device_name") as String?
-
+        // Keep the target supplied by connectById. device_name still belongs to
+        // the previous pairing until DeviceManager promotes the ready device.
         if (!bluetoothAdapter!!.isEnabled()) {
             return
         }

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

@@ -2,37 +2,16 @@ package com.mentra.bluetoothsdk.sgcs
 
 import java.text.Normalizer
 
-private val G1_COMBINING_MARKS = Regex("\\p{M}+")
+// Embedded G1 1.5.6 Latin glyphs. See notes/g1-character-support.md.
+private const val G1_LATIN_GLYPHS = "ÀÂÇÈÉÊËÎÏÔÙÛÜàçèéêëîïôùûüÿŸÄäÖößẞâÁáÍíÑñúÓóÚⁱIJijŠšŽžÃÅÆÌÐÒÕØÝÞãåæìðòõøýþĄąĆćČčĎďĘęĚěĞğŁłŃńŇňŘřŚśŞşŤťŮůŹźŻżĂăıȘșȚțǖǘǚǜǎǐǒǔŐőŰű"
+private val G1_LATIN_CLUSTERS = Regex("\\p{IsLatin}\\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, "")
+/** Preserves mapped Latin glyphs and falls back only for unmapped Latin clusters. */
+internal fun sanitizeG1DisplayText(text: String): String = G1_LATIN_CLUSTERS.replace(text) { match ->
+  val composed = Normalizer.normalize(match.value, Normalizer.Form.NFC)
+  if (composed.length == 1 && (composed[0] in ' '..'~' || composed[0] in G1_LATIN_GLYPHS)) {
+    composed
+  } else {
+    sanitizeLatinDisplayText(match.value, preserveOtherScripts = true)
+  }
 }

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

@@ -1,5 +1,6 @@
 package com.mentra.bluetoothsdk.sgcs
 
+import com.mentra.bluetoothsdk.utils.G2Text
 import com.mentra.bluetoothsdk.PhotoRequest
 import android.bluetooth.BluetoothAdapter
 import android.bluetooth.BluetoothGatt
@@ -1363,17 +1364,18 @@ class G2 : SGCManager() {
     // Map device names to serial numbers (populated from manufacturer data during scan)
     private val deviceNameToSerialNumber = mutableMapOf<String, String>()
 
-    // Saved addresses for reconnection
+    // Scope each side's address to the selected serial. Legacy global addresses have
+    // no trustworthy owner, so the first connection after upgrading learns them by scan.
     private var leftGlassAddress: String?
         get() =
             context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
-                .getString(KEY_LEFT_ADDRESS, null)
+                .getString("$KEY_LEFT_ADDRESS:$DEVICE_SEARCH_ID", null)
         set(value) {
             context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
                 .edit()
                 .apply {
-                    if (value != null) putString(KEY_LEFT_ADDRESS, value)
-                    else remove(KEY_LEFT_ADDRESS)
+                    if (value != null) putString("$KEY_LEFT_ADDRESS:$DEVICE_SEARCH_ID", value)
+                    else remove("$KEY_LEFT_ADDRESS:$DEVICE_SEARCH_ID")
                 }
                 .apply()
         }
@@ -1381,13 +1383,13 @@ class G2 : SGCManager() {
     private var rightGlassAddress: String?
         get() =
             context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
-                .getString(KEY_RIGHT_ADDRESS, null)
+                .getString("$KEY_RIGHT_ADDRESS:$DEVICE_SEARCH_ID", null)
         set(value) {
             context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
                 .edit()
                 .apply {
-                    if (value != null) putString(KEY_RIGHT_ADDRESS, value)
-                    else remove(KEY_RIGHT_ADDRESS)
+                    if (value != null) putString("$KEY_RIGHT_ADDRESS:$DEVICE_SEARCH_ID", value)
+                    else remove("$KEY_RIGHT_ADDRESS:$DEVICE_SEARCH_ID")
                 }
                 .apply()
         }
@@ -1664,8 +1666,15 @@ class G2 : SGCManager() {
         if (char == null || gatt == null) return
         char.value = packet
         char.writeType = BluetoothGattCharacteristic.WRITE_TYPE_NO_RESPONSE
-        val ok = gatt.writeCharacteristic(char)
-        bgcapNoteWriteResult(ok) // BGCAP
+        // A rejected write never entered Android's queue. Retry on this dedicated
+        // BLE worker before later commands (especially a page replacement) overtake it.
+        var ok = false
+        for (attempt in 0 until 5) {
+            ok = gatt.writeCharacteristic(char)
+            bgcapNoteWriteResult(ok)
+            if (ok) break
+            if (attempt < 4) Thread.sleep(BLE_PACKET_GAP_MS)
+        }
         if (leg != null) {
             Bridge.log("G2/FILE: write $leg ${packet.size}B -> ${if (ok) "queued" else "DROPPED (stack busy)"}")
         }
@@ -2190,7 +2199,7 @@ class G2 : SGCManager() {
         val rBorderColor = borderColor ?: defaultTextBorderColor
         val rBorderRadius = borderRadius ?: defaultTextBorderRadius
         val rPaddingLength = paddingLength ?: defaultTextPaddingLength
-        val content = if (text.isEmpty()) " " else text
+        val content = G2Text.containerContent(text)
 
         // Pure state mutation: update the container's content and schedule its sends; the reconcile
         // loop does the actual updateText writes. Reuse an existing container if the rect matches
@@ -2257,6 +2266,12 @@ class G2 : SGCManager() {
     }
 
     override fun clearDisplay() {
+        // Expo invokes this on its worker queue; all container mutations must
+        // share Main with reconcileDisplay and scene updates.
+        if (Looper.myLooper() != Looper.getMainLooper()) {
+            mainHandler.post { clearDisplay() }
+            return
+        }
         Bridge.log("G2: clearDisplay()")
         // Clear the text in place — do NOT shut down + rebuild the EvenHub page. Tearing the page
         // down (rebuildPage) kills audio streaming AND triggers a firmware systemExit /
@@ -2266,9 +2281,22 @@ class G2 : SGCManager() {
         // several seconds (incident 8164175a). Just blank the text + clear images; the reconcile
         // loop pushes the blanked text on a live page, and a dead page is only resurrected for
         // meaningful (non-blank) content, so a clear can't churn it back up.
-        for (i in textContainers.indices) {
-            textContainers[i].content = "\n"
-            textContainers[i].pendingSends = 1 + EVEN_HUB_RESEND_COUNT
+        for (container in textContainers) {
+            // Erase the firmware's existing text BEFORE forgetting its container.
+            // A queued reconcile cannot do this after the positioned container is removed.
+            // Cover the previous byte range, rather than replacing only its first character.
+            val blank = " ".repeat(maxOf(1, container.content.toByteArray(Charsets.UTF_8).size))
+            container.content = blank
+            container.pendingSends = 1 + EVEN_HUB_RESEND_COUNT
+            if (pageCreated) {
+                val erase = EvenHubProto.updateTextMessage(
+                    containerID = container.id,
+                    contentOffset = 0,
+                    contentLength = blank.length,
+                    content = blank
+                )
+                repeat(1 + EVEN_HUB_RESEND_COUNT) { sendEvenHubCommand(erase) }
+            }
         }
         for (i in imageContainers.indices) {
             // The firmware still shows this container's image; emptying bmpData locally never reaches
@@ -2296,8 +2324,13 @@ class G2 : SGCManager() {
             textContainers.removeAll { it.id in huskIds }
             sceneTextByElement.entries.removeAll { it.value in huskIds }
             sceneImageByElement.clear()
-            Bridge.log("G2: clearDisplay() — purging ${huskIds.size} positioned husk container(s), one rebuild")
-            displayScope.launch { coalescedPageRebuild() }
+            // Replace the live page now, while still on Main. A shutdown followed by
+            // reconcile cannot clear this case: reconcile intentionally skips blank pages,
+            // leaving the firmware's old positioned text visible until new speech arrives.
+            // Queue the blank replacement before any following miniapp frame, without
+            // tearing down the page (or its microphone session).
+            Bridge.log("G2: clearDisplay() — replacing page after removing ${huskIds.size} positioned container(s)")
+            if (pageCreated) createPageWithContainers()
         }
     }
 
@@ -2344,6 +2377,15 @@ class G2 : SGCManager() {
                     return false
                 }
 
+        if (Looper.myLooper() != Looper.getMainLooper()) {
+            mainHandler.post { applyBitmap(rx, ry, rw, rh, bmpData) }
+            return true
+        }
+        return applyBitmap(rx, ry, rw, rh, bmpData)
+    }
+
+    // Called only on Main, including the inline scene-frame path.
+    private fun applyBitmap(rx: Int, ry: Int, rw: Int, rh: Int, bmpData: ByteArray): Boolean {
         // Pure state mutation: update the target container's bytes and mark it dirty. The reconcile
         // loop is the sole sender, so two displayBitmap calls can never overlap a sendImageData and
         // clobber the single-slot image ACK — no lock needed. Reuse an existing container if the rect
@@ -2538,7 +2580,7 @@ class G2 : SGCManager() {
         @Suppress("NAME_SHADOWING")
         val height = minOf(maxOf(height, minTextContainerHeight), 288 - y)
         run {
-            val content = if (text.isEmpty()) " " else text
+            val content = G2Text.containerContent(text)
             val existingId = sceneTextByElement[elementId]
             if (existingId != null) {
                 val idx = textContainers.indexOfFirst { it.id == existingId }
@@ -2999,15 +3041,15 @@ class G2 : SGCManager() {
                 }
                 // Only settle the flag if it's still empty — a displayBitmap during the await would
                 // have set new bytes, so leave it dirty for the next pass to send the real image.
-                val jj = imageContainers.indexOfFirst { it.id == container.id }
+                val jj = imageContainers.indexOfFirst { it === container }
                 if (jj >= 0 && imageContainers[jj].bmpData.isEmpty()) {
                     imageContainers[jj].dirty = false
                 }
                 continue
             }
             sendImageData(container.id, container.name, sentBytes)
-            // Re-find by id: the list may have shifted (eviction) during the await.
-            val j = imageContainers.indexOfFirst { it.id == container.id }
+            // Re-find by identity: eviction can reuse this ID during the await.
+            val j = imageContainers.indexOfFirst { it === container }
             if (j >= 0 && imageContainers[j].bmpData.contentEquals(sentBytes)) {
                 imageContainers[j].dirty = false
             }
@@ -3677,8 +3719,17 @@ class G2 : SGCManager() {
         rightAuthenticated = false
         startupPageCreated = false
         pageCreated = false
-        imageContainers.clear()
-        textContainers.clear()
+        // Keep GATT teardown synchronous for manager replacement, but never
+        // remove containers underneath Main's reconcile/scene iteration.
+        if (Looper.myLooper() == Looper.getMainLooper()) {
+            imageContainers.clear()
+            textContainers.clear()
+        } else {
+            mainHandler.post {
+                imageContainers.clear()
+                textContainers.clear()
+            }
+        }
         dashboardShowing = 0
         dashboardOpening = false
         heartbeatCounter = 0

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

@@ -0,0 +1,39 @@
+package com.mentra.bluetoothsdk.sgcs
+
+import java.text.Normalizer
+
+private val LATIN_COMBINING_MARKS = Regex("\\p{M}+")
+private val LATIN_LETTERS_WITH_MARKS = Regex("\\p{IsLatin}\\p{M}*")
+
+/** Converts accented and extended Latin letters to base glyphs at the device boundary. */
+internal fun sanitizeLatinDisplayText(text: String, preserveOtherScripts: Boolean = false): 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)
+            }
+        }
+    }
+
+    if (preserveOtherScripts) {
+        return LATIN_LETTERS_WITH_MARKS.replace(expanded) { match ->
+            Normalizer.normalize(match.value, Normalizer.Form.NFD).replace(LATIN_COMBINING_MARKS, "")
+        }
+    }
+    return Normalizer.normalize(expanded, Normalizer.Form.NFD)
+        .replace(LATIN_COMBINING_MARKS, "")
+}