@mentra/bluetooth-sdk 0.1.21-beta.3 → 3.1.0-beta.100

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

@@ -89,6 +89,14 @@ class DeviceManager {
         get() = DeviceStore.store.get("bluetooth", "pending_wearable") as? String ?: ""
         set(value) = DeviceStore.apply("bluetooth", "pending_wearable", value)
 
+    private var pendingDeviceName: String
+        get() = DeviceStore.store.get("bluetooth", "pending_device_name") as? String ?: ""
+        set(value) = DeviceStore.apply("bluetooth", "pending_device_name", value)
+
+    private var pendingDeviceAddress: String
+        get() = DeviceStore.store.get("bluetooth", "pending_device_address") as? String ?: ""
+        set(value) = DeviceStore.apply("bluetooth", "pending_device_address", value)
+
     public var deviceName: String
         get() = DeviceStore.store.get("bluetooth", "device_name") as? String ?: ""
         set(value) = DeviceStore.apply("bluetooth", "device_name", value)
@@ -205,6 +213,7 @@ class DeviceManager {
     private var lastReadyHandledAtMs: Long = 0L
     private var lastReadyHandledKey: String = ""
     private var lastSystemTimeSyncConnectionKey: String = ""
+    private var pendingSystemTimeSync: Runnable? = null
 
     private var systemMicUnavailable: Boolean
         get() = DeviceStore.store.get("bluetooth", "systemMicUnavailable") as? Boolean ?: false
@@ -250,6 +259,12 @@ class DeviceManager {
     // Audio output format - defaults to LC3 for bandwidth savings
     private var audioOutputFormat: AudioOutputFormat = AudioOutputFormat.LC3
     private var lastLc3Event: Long? = null
+    private val micHealthLock = Any()
+    private var sequenceGapEvents = 0L
+    private var decodeFailures = 0L
+    private var lastLc3ReceivedAt: Long? = null
+    private var lastPcmProducedAt: Long? = null
+    private var lastLc3Sequence: Int? = null
     private var micReinitRunnable: Runnable? = null
     private var systemMicAvailabilityRecheckRunnable: Runnable? = null
 
@@ -742,7 +757,69 @@ class DeviceManager {
      * this per uplink packet — otherwise the watchdog keeps re-enabling a working mic.
      */
     fun reportGlassesAudioActivity() {
-        lastLc3Event = System.currentTimeMillis()
+        val now = System.currentTimeMillis()
+        lastLc3Event = now
+        synchronized(micHealthLock) {
+            lastPcmProducedAt = now
+        }
+    }
+
+    private fun micHealthSnapshotLocked(): MicHealth =
+        MicHealth(
+            sequenceGapEvents = sequenceGapEvents,
+            decodeFailures = decodeFailures,
+            lastLc3ReceivedAt = lastLc3ReceivedAt,
+            lastPcmProducedAt = lastPcmProducedAt,
+        )
+
+    private fun resetMicHealth() {
+        synchronized(micHealthLock) {
+            sequenceGapEvents = 0
+            decodeFailures = 0
+            lastLc3ReceivedAt = null
+            lastPcmProducedAt = null
+            lastLc3Sequence = null
+        }
+        lastLc3Event = null
+    }
+
+    fun resetMicSequenceBaseline() {
+        synchronized(micHealthLock) { lastLc3Sequence = null }
+    }
+
+    private fun recordLc3Packet(sequenceNumber: Int?) {
+        var gap = false
+        val health = synchronized(micHealthLock) {
+            val now = System.currentTimeMillis()
+            lastLc3ReceivedAt = now
+            lastLc3Event = now
+            if (sequenceNumber != null) {
+                val normalized = sequenceNumber and 0xff
+                lastLc3Sequence?.let { previous ->
+                    val expected = (previous + 1) and 0xff
+                    if (normalized != expected) {
+                        gap = true
+                        sequenceGapEvents += 1
+                        Bridge.log("MAN: LC3 packet sequence mismatch. Expected: $expected, Got: $normalized")
+                    }
+                }
+                lastLc3Sequence = normalized
+            }
+            micHealthSnapshotLocked()
+        }
+        if (gap) Bridge.sendMicHealth(health, "sequence_gap")
+    }
+
+    private fun recordMicDecodeFailure() {
+        val health = synchronized(micHealthLock) {
+            decodeFailures += 1
+            micHealthSnapshotLocked()
+        }
+        Bridge.sendMicHealth(health, "decode_failure")
+    }
+
+    private fun recordMicPcmProduced() {
+        synchronized(micHealthLock) { lastPcmProducedAt = System.currentTimeMillis() }
     }
 
     /**
@@ -750,12 +827,14 @@ class DeviceManager {
      * canonical LC3 encoding. Note: frameSize here is for glasses→phone decoding, NOT for
      * phone→cloud encoding.
      */
-    fun handleGlassesMicData(rawLC3Data: ByteArray, frameSize: Int = 40) {
-        lastLc3Event = System.currentTimeMillis()
+    @JvmOverloads
+    fun handleGlassesMicData(rawLC3Data: ByteArray, frameSize: Int = 40, sequenceNumber: Int? = null) {
+        recordLc3Packet(sequenceNumber)
         val pcmData: ByteArray?
         synchronized(lc3Lock) {
             if (lc3DecoderPtr == 0L) {
                 Bridge.log("MAN: LC3 decoder not initialized, cannot process glasses audio")
+                recordMicDecodeFailure()
                 return
             }
 
@@ -764,14 +843,17 @@ class DeviceManager {
                 pcmData = Lc3Cpp.decodeLC3(lc3DecoderPtr, rawLC3Data, frameSize)
             } catch (e: Exception) {
                 Bridge.log("MAN: Failed to decode glasses LC3: ${e.message}")
+                recordMicDecodeFailure()
                 return
             }
         }
         if (pcmData != null && pcmData.isNotEmpty()) {
             // Re-encode to canonical LC3 via handlePcm (outside lock to avoid deadlock)
+            recordMicPcmProduced()
             handlePcm(pcmData)
         } else {
             Bridge.log("MAN: LC3 decode returned empty data")
+            recordMicDecodeFailure()
         }
     }
 
@@ -948,15 +1030,20 @@ class DeviceManager {
 
         when (currentViewState.layoutType) {
             "text_wall" -> {
-                sgc?.sendTextWall(currentViewState.text)
+                sgc?.sendTextWall(parsePlaceholders(currentViewState.text))
             }
 
             "double_text_wall" -> {
-                sgc?.sendDoubleTextWall(currentViewState.topText, currentViewState.bottomText)
+                sgc?.sendDoubleTextWall(
+                    parsePlaceholders(currentViewState.topText),
+                    parsePlaceholders(currentViewState.bottomText)
+                )
             }
 
             "reference_card" -> {
-                sgc?.sendTextWall("${currentViewState.title}\n\n${currentViewState.text}")
+                val title = parsePlaceholders(currentViewState.title)
+                val text = parsePlaceholders(currentViewState.text)
+                sgc?.sendTextWall("$title\n\n$text")
             }
 
             "bitmap_view" -> {
@@ -973,7 +1060,7 @@ class DeviceManager {
 
             "positioned_text" -> {
                 sgc?.sendPositionedText(
-                    currentViewState.text,
+                    parsePlaceholders(currentViewState.text),
                     currentViewState.bmpX ?: 0,
                     currentViewState.bmpY ?: 0,
                     currentViewState.bmpWidth ?: 576,
@@ -994,6 +1081,8 @@ class DeviceManager {
     }
 
     private fun parsePlaceholders(text: String): String {
+        if (!text.contains('$')) return text
+
         val dateFormatter = SimpleDateFormat("M/dd, h:mm", Locale.getDefault())
         val formattedDate = dateFormatter.format(Date())
 
@@ -1141,7 +1230,7 @@ class DeviceManager {
             Bridge.log("MAN: Cleaning up previous sgc type: ${sgc?.type}")
             sgc?.cleanup()
             sgc = null
-            lastSystemTimeSyncConnectionKey = ""
+            resetSystemTimeSync()
         }
 
         if (sgc != null) {
@@ -1264,6 +1353,14 @@ class DeviceManager {
             return
         }
 
+        if (pendingDeviceName.isNotEmpty()) {
+            deviceName = pendingDeviceName
+        }
+        if (pendingDeviceAddress.isNotEmpty()) {
+            deviceAddress = pendingDeviceAddress
+        }
+        clearPendingConnection()
+
         val readyKey = "${sgc?.type}:${deviceName}"
         val now = System.currentTimeMillis()
         if (readyKey == lastReadyHandledKey && now - lastReadyHandledAtMs < 2000) {
@@ -1274,7 +1371,7 @@ class DeviceManager {
         lastReadyHandledAtMs = now
 
         Bridge.log("MAN: handleDeviceReady() ${sgc?.type}")
-        pendingWearable = ""
+        resetMicHealth()
         defaultWearable = sgc?.type ?: ""
         searching = false
 
@@ -1344,9 +1441,25 @@ class DeviceManager {
         }
 
         lastSystemTimeSyncConnectionKey = connectionKey
-        val timestampMs = System.currentTimeMillis()
-        Bridge.log("MAN: Syncing glasses system time once for connection: $timestampMs")
-        activeSgc.sendSetSystemTime(timestampMs)
+        pendingSystemTimeSync?.let { mainHandler.removeCallbacks(it) }
+        val sync =
+            Runnable {
+                pendingSystemTimeSync = null
+                if (lastSystemTimeSyncConnectionKey != connectionKey || sgc !== activeSgc) {
+                    return@Runnable
+                }
+                val timestampMs = System.currentTimeMillis()
+                Bridge.log("MAN: Syncing glasses system time once for connection: $timestampMs")
+                activeSgc.sendSetSystemTime(timestampMs)
+            }
+        pendingSystemTimeSync = sync
+        mainHandler.postDelayed(sync, 3000)
+    }
+
+    private fun resetSystemTimeSync() {
+        pendingSystemTimeSync?.let { mainHandler.removeCallbacks(it) }
+        pendingSystemTimeSync = null
+        lastSystemTimeSyncConnectionKey = ""
     }
 
     private fun handleG1Ready() {
@@ -1361,7 +1474,8 @@ class DeviceManager {
 
     fun handleDeviceDisconnected() {
         Bridge.log("MAN: Device disconnected")
-        lastSystemTimeSyncConnectionKey = ""
+        resetSystemTimeSync()
+        resetMicHealth()
         DeviceStore.apply("glasses", "headUp", false)
         DeviceStore.apply(
             "glasses",
@@ -1634,6 +1748,11 @@ class DeviceManager {
         sgc?.sendHotspotState(enabled)
     }
 
+    fun setWifiAdbState(enabled: Boolean) {
+        Bridge.log("MAN: Setting glasses Wi-Fi ADB state: $enabled")
+        sgc?.sendWifiAdbState(enabled)
+    }
+
     fun setSystemTime(timestampMs: Long) {
         Bridge.log("MAN: Setting glasses system time: $timestampMs")
         sgc?.sendSetSystemTime(timestampMs)
@@ -1868,6 +1987,11 @@ class DeviceManager {
         )
     }
 
+    fun queryVideoRecordingStatus(requestId: String) {
+        Bridge.log("MAN: Querying video recording status: requestId=$requestId")
+        sgc?.queryVideoRecordingStatus(requestId)
+    }
+
     fun stopVideoRecording(requestId: String, webhookUrl: String?, authToken: String?) {
         Bridge.log(
             "MAN: onStopVideoRecording: requestId=$requestId, webhook=" +
@@ -1954,6 +2078,11 @@ class DeviceManager {
             return
         }
         initSGC(defaultWearable)
+        val live = sgc as? MentraLive
+        if (live?.isPairingYieldActive() == true) {
+            Bridge.log("MAN: connectDefault skipped — Mentra Live pairing yield active")
+            return
+        }
         searching = true
         sgc?.connectById(reconnectTarget)
         connectDefaultController()
@@ -2006,13 +2135,13 @@ class DeviceManager {
             return
         }
 
-        disconnect()
+        disconnect(clearPendingIdentity = false)
         Thread.sleep(100)
         searching = true
-        deviceName = name
+        pendingDeviceName = name
 
         initSGC(pendingWearable)
-        sgc?.connectById(deviceName)
+        sgc?.connectById(name)
     }
 
     fun connectDevice(deviceModel: String, deviceName: String) {
@@ -2039,11 +2168,12 @@ class DeviceManager {
         handleDeviceReady()
     }
 
-    fun disconnect() {
+    fun disconnect(clearPendingIdentity: Boolean = true) {
         sgc?.clearDisplay()
         sgc?.disconnect()
         sgc = null // Clear the SGC reference after disconnect
-        lastSystemTimeSyncConnectionKey = ""
+        resetSystemTimeSync()
+        resetMicHealth()
         searching = false
         micEnabled = false
         updateMicState()
@@ -2054,6 +2184,7 @@ class DeviceManager {
         // previously connected pair can never be reported for the next connection.
         DeviceStore.apply("glasses", "serialNumber", "")
         DeviceStore.apply("glasses", "bluetoothMacAddress", "")
+        DeviceStore.apply("glasses", "wifiMacAddress", "")
         DeviceStore.apply("glasses", "leftMacAddress", "")
         DeviceStore.apply("glasses", "rightMacAddress", "")
         DeviceStore.apply("glasses", "macAddress", "")
@@ -2069,6 +2200,15 @@ class DeviceManager {
         DeviceStore.apply("glasses", "controllerConnected", false)
         controller?.disconnect()
         controller = null
+        if (clearPendingIdentity) {
+            clearPendingConnection()
+        }
+    }
+
+    private fun clearPendingConnection() {
+        pendingDeviceName = ""
+        pendingDeviceAddress = ""
+        pendingWearable = ""
     }
 
     fun disconnectController() {
@@ -2082,20 +2222,73 @@ class DeviceManager {
     fun forget() {
         Bridge.log("MAN: Forgetting smart glasses")
 
-        // Call forget first to stop timers/handlers/reconnect logic
-        sgc?.forget()
-
-        // Then disconnect to close connections
-        disconnect()
+        val live = sgc as? MentraLive
+        if (live != null) {
+            // MentraLive.forget() disconnects GATT then removeBond. Do not refuse
+            // during CTKD bonding — Unpair is an explicit user request to drop the pair.
+            live.forget()
+            // MentraLive.forget() already destroyed the SGC. Clear the manager reference and
+            // session state without calling disconnect() again (that would hit a dead instance
+            // and leave a destroyed MentraLive retained for the next scan).
+            sgc = null
+            resetSystemTimeSync()
+            searching = false
+            micEnabled = false
+            updateMicState()
+            shouldSendBootingMessage = true
+            DeviceStore.apply("glasses", "deviceModel", "")
+            DeviceStore.apply("glasses", "serialNumber", "")
+            DeviceStore.apply("glasses", "bluetoothMacAddress", "")
+            DeviceStore.apply("glasses", "leftMacAddress", "")
+            DeviceStore.apply("glasses", "rightMacAddress", "")
+            DeviceStore.apply("glasses", "macAddress", "")
+            DeviceStore.apply("glasses", "fullyBooted", false)
+            DeviceStore.apply("glasses", "connected", false)
+            DeviceStore.apply(
+                    "glasses",
+                    "voiceActivityDetectionEnabled",
+                    BluetoothSdkDefaults.VOICE_ACTIVITY_DETECTION_ENABLED,
+            )
+            searchingController = false
+            DeviceStore.apply("glasses", "controllerConnected", false)
+            controller?.disconnect()
+            controller = null
+        } else {
+            // Typical abandonAttempt path: disconnect() already destroyed SGC and nulled
+            // this.sgc, so MentraLive.forget() never ran and Classic bonds stayed up —
+            // glasses keep IBRT ACL and stop BLE advertising. Only tear Live bonds when
+            // the selected/pending wearable is Mentra Live — forgetting G1/G2 must not
+            // unpair an unrelated Live unit.
+            val liveTarget =
+                    defaultWearable == DeviceTypes.LIVE || pendingWearable == DeviceTypes.LIVE
+            if (liveTarget) {
+                val extraAddress =
+                        when {
+                            defaultWearable == DeviceTypes.LIVE ->
+                                    deviceAddress.takeIf { it.isNotEmpty() }
+                            pendingWearable == DeviceTypes.LIVE ->
+                                    pendingDeviceAddress.takeIf { it.isNotEmpty() }
+                            else -> null
+                        }
+                MentraLive.unbondBondedMentraLiveDevices(
+                        Bridge.getContext(),
+                        extraAddress,
+                )
+            }
+            sgc?.forget()
+            disconnect()
+        }
 
         // Clear state
         defaultWearable = ""
         deviceName = ""
         deviceAddress = ""
+        clearPendingConnection()
         Bridge.saveSetting("default_wearable", "")
         Bridge.saveSetting("device_name", "")
         Bridge.saveSetting("device_address", "")
         Bridge.saveSetting("project_name", "")
+        Bridge.saveSetting("pending_wearable", "")
     }
 
     fun forgetController() {

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

@@ -65,6 +65,7 @@ object DeviceStore {
         store.set("glasses", "connectionState", ConnTypes.DISCONNECTED)
         store.set("glasses", "deviceModel", "")
         store.set("glasses", "firmwareVersion", "")
+        store.set("glasses", "hotspotOtaVersion", 0)
         store.set("glasses", "micEnabled", false)
         store.set("glasses", "voiceActivityDetectionEnabled", BluetoothSdkDefaults.VOICE_ACTIVITY_DETECTION_ENABLED)
         store.set("glasses", "bluetoothClassicConnected", false)
@@ -74,6 +75,7 @@ object DeviceStore {
         store.set("glasses", "caseBatteryLevel", -1)
         store.set("glasses", "headUp", false)
         store.set("glasses", "bluetoothMacAddress", "")
+        store.set("glasses", "wifiMacAddress", "")
         store.set("glasses", "leftMacAddress", "")
         store.set("glasses", "rightMacAddress", "")
         store.set("glasses", "macAddress", "")

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

@@ -0,0 +1,7 @@
+package com.mentra.bluetoothsdk
+
+/** Generated from /changelogs. Do not edit directly. */
+internal val GENERATED_RELEASE_CHANGELOGS: List<ReleaseChangelog> =
+    listOf(
+        ReleaseChangelog(version = "3.1.0", markdown = "Software updates are more reliable, with clearer progress and recovery when the glasses restart.\n\n- MentraOS, Mentra Engine, the Bluetooth SDK, and the glasses client now share one coordinated release version.\n- Mentra Live updates can continue across APK, system, and firmware restarts without asking the user to start the same update again.\n- Bluetooth photo capture and transfer diagnostics are more precise and less disruptive to normal glasses traffic."),
+    )

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

@@ -0,0 +1,11 @@
+package com.mentra.bluetoothsdk
+
+/** Generated by release CI. Do not edit in a release checkout. */
+internal object GeneratedReleaseMetadata {
+    const val FAMILY_BASE_VERSION: String = "3.1.0"
+    const val RELEASE_IDENTITY: String = "3.1.0-beta.100"
+    const val RELEASE_SET_ID: String = "mentra-3.1.0-beta.100"
+    const val SOURCE_COMMIT: String = "c7c90f50ce7fd83dadc9a005e152db1d88083e4f"
+    const val OTA_MANIFEST_URL: String = "https://github.com/Mentra-Community/MentraOS/releases/download/mentra-builds-v3.1.0/mentra-live-ota-3.1.0-beta.100.json"
+    const val OTA_MANIFEST_SHA256: String = "7fdf5b1f75d5d07007e45c929495cd4b6800c810c94e3c60c62bda99d1c61552"
+}