@mentra/bluetooth-sdk 0.1.21-beta.5 → 3.1.0-dev.10

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()
         }
     }
 
@@ -1148,7 +1230,7 @@ class DeviceManager {
             Bridge.log("MAN: Cleaning up previous sgc type: ${sgc?.type}")
             sgc?.cleanup()
             sgc = null
-            lastSystemTimeSyncConnectionKey = ""
+            resetSystemTimeSync()
         }
 
         if (sgc != null) {
@@ -1271,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) {
@@ -1281,7 +1371,7 @@ class DeviceManager {
         lastReadyHandledAtMs = now
 
         Bridge.log("MAN: handleDeviceReady() ${sgc?.type}")
-        pendingWearable = ""
+        resetMicHealth()
         defaultWearable = sgc?.type ?: ""
         searching = false
 
@@ -1351,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() {
@@ -1368,7 +1474,8 @@ class DeviceManager {
 
     fun handleDeviceDisconnected() {
         Bridge.log("MAN: Device disconnected")
-        lastSystemTimeSyncConnectionKey = ""
+        resetSystemTimeSync()
+        resetMicHealth()
         DeviceStore.apply("glasses", "headUp", false)
         DeviceStore.apply(
             "glasses",
@@ -1641,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)
@@ -1875,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=" +
@@ -1961,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()
@@ -2013,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) {
@@ -2046,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()
@@ -2061,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", "")
@@ -2076,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() {
@@ -2089,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/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-dev.10"
+    const val RELEASE_SET_ID: String = "mentra-3.1.0-dev.10"
+    const val SOURCE_COMMIT: String = "64cf83b23a71e70261571a5f4401d1a7538f1852"
+    const val OTA_MANIFEST_URL: String = "https://github.com/Mentra-Community/MentraOS/releases/download/mentra-v3.1.0-dev.10/mentra-live-ota-3.1.0-dev.10.json"
+    const val OTA_MANIFEST_SHA256: String = "214d92c8894033eaab276e668cb553c79990005d3330d23aaf499a514dc08cff"
+}

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

@@ -1,7 +1,10 @@
 package com.mentra.bluetoothsdk
 
+import android.app.Activity
+import android.app.Application
 import android.bluetooth.BluetoothManager
 import android.content.Context
+import android.os.Bundle
 import android.os.Handler
 import android.os.Looper
 import com.mentra.bluetoothsdk.utils.ControllerTypes
@@ -30,6 +33,23 @@ class MentraBluetoothSdk private constructor(
     private val discoveredDeviceNames = mutableSetOf<String>()
     private val bridgeEventSinkId: String
     private val storeListenerId: String
+    private val activityLifecycleCallbacks =
+        object : Application.ActivityLifecycleCallbacks {
+            override fun onActivityResumed(activity: Activity) {
+                // Match the Mentra App's OnActivityEntersForeground hook. This runs after
+                // runtime permission dialogs in native host apps, allowing the service to
+                // replace its temporary dataSync type with connectedDevice/microphone/location.
+                deviceManager.refreshForegroundServiceTypes()
+            }
+
+            override fun onActivityCreated(activity: Activity, savedInstanceState: Bundle?) = Unit
+            override fun onActivityStarted(activity: Activity) = Unit
+            override fun onActivityPaused(activity: Activity) = Unit
+            override fun onActivityStopped(activity: Activity) = Unit
+            override fun onActivitySaveInstanceState(activity: Activity, outState: Bundle) = Unit
+            override fun onActivityDestroyed(activity: Activity) = Unit
+        }
+    private var activityLifecycleCallbacksRegistered = false
     private var suppressDefaultDeviceEvents = false
     private val streamKeepAliveLock = Any()
     private var activeStreamKeepAlive: ActiveStreamKeepAlive? = null
@@ -57,6 +77,10 @@ class MentraBluetoothSdk private constructor(
         listeners.add(listener)
         Bridge.initialize(appContext)
         deviceManager = DeviceManager.getInstance()
+        (appContext as? Application)?.let { application ->
+            application.registerActivityLifecycleCallbacks(activityLifecycleCallbacks)
+            activityLifecycleCallbacksRegistered = true
+        }
         bridgeEventSinkId = Bridge.addEventSink { eventName, data -> dispatchBridgeEvent(eventName, data) }
         // Baseline the analytics connection state before subscribing to the store:
         // store updates invoke listeners synchronously on the updating thread, so a
@@ -258,6 +282,8 @@ class MentraBluetoothSdk private constructor(
             DeviceStore.apply(ObservableStore.BLUETOOTH_CATEGORY, "device_name", device.name)
             DeviceStore.apply(ObservableStore.BLUETOOTH_CATEGORY, "device_address", device.address ?: "")
             DeviceStore.apply(ObservableStore.BLUETOOTH_CATEGORY, "project_name", device.projectName ?: "")
+            DeviceStore.apply(ObservableStore.BLUETOOTH_CATEGORY, "pending_device_name", "")
+            DeviceStore.apply(ObservableStore.BLUETOOTH_CATEGORY, "pending_device_address", "")
         } finally {
             suppressDefaultDeviceEvents = false
         }
@@ -271,6 +297,8 @@ class MentraBluetoothSdk private constructor(
             DeviceStore.apply(ObservableStore.BLUETOOTH_CATEGORY, "device_name", "")
             DeviceStore.apply(ObservableStore.BLUETOOTH_CATEGORY, "device_address", "")
             DeviceStore.apply(ObservableStore.BLUETOOTH_CATEGORY, "project_name", "")
+            DeviceStore.apply(ObservableStore.BLUETOOTH_CATEGORY, "pending_device_name", "")
+            DeviceStore.apply(ObservableStore.BLUETOOTH_CATEGORY, "pending_device_address", "")
         } finally {
             suppressDefaultDeviceEvents = false
         }
@@ -383,8 +411,24 @@ class MentraBluetoothSdk private constructor(
                 cancelConnectionAttempt()
             }
         }
-        if (options.saveAsDefault && !isController) {
-            setDefaultDevice(device)
+        if (!isController) {
+            if (options.saveAsDefault) {
+                setDefaultDevice(device)
+            } else {
+                // Pairing uses saveAsDefault=false so default identity stays on the
+                // previous owner until handleDeviceReady. Stash the GATT target separately
+                // so MentraLive can connect by MAC without promoting getDefaultDevice().
+                DeviceStore.apply(
+                        ObservableStore.BLUETOOTH_CATEGORY,
+                        "pending_device_name",
+                        device.name,
+                )
+                DeviceStore.apply(
+                        ObservableStore.BLUETOOTH_CATEGORY,
+                        "pending_device_address",
+                        device.address ?: "",
+                )
+            }
         }
         DeviceStore.apply(ObservableStore.BLUETOOTH_CATEGORY, "pending_wearable", device.model.deviceType)
         deviceManager.connectByName(device.name)
@@ -408,6 +452,8 @@ class MentraBluetoothSdk private constructor(
     }
 
     fun cancelConnectionAttempt() {
+        DeviceStore.apply(ObservableStore.BLUETOOTH_CATEGORY, "pending_device_name", "")
+        DeviceStore.apply(ObservableStore.BLUETOOTH_CATEGORY, "pending_device_address", "")
         deviceManager.disconnect()
     }
 
@@ -416,6 +462,8 @@ class MentraBluetoothSdk private constructor(
     }
 
     fun disconnect() {
+        DeviceStore.apply(ObservableStore.BLUETOOTH_CATEGORY, "pending_device_name", "")
+        DeviceStore.apply(ObservableStore.BLUETOOTH_CATEGORY, "pending_device_address", "")
         deviceManager.disconnect()
     }
 
@@ -856,6 +904,10 @@ class MentraBluetoothSdk private constructor(
         }
     }
 
+    fun setWifiAdbState(enabled: Boolean) {
+        deviceManager.setWifiAdbState(enabled)
+    }
+
     fun setSystemTime(timestampMs: Long) {
         deviceManager.setSystemTime(timestampMs)
     }
@@ -1087,6 +1139,25 @@ class MentraBluetoothSdk private constructor(
         }
     }
 
+    suspend fun queryVideoRecordingStatus(requestId: String): VideoRecordingStatusEvent {
+        require(requestId.isNotBlank()) { "requestId is required to query video recording status." }
+        requireGlassesConnected("query video recording status")
+        val pending = PendingResponse<VideoRecordingStatusEvent>("query video recording status")
+        val pendingRequest = PendingVideoRecordingRequest("recording_status", pending)
+        if (pendingVideoRecordingRequests.putIfAbsent(requestId, pendingRequest) != null) {
+            throw BluetoothSdkException(
+                "request_in_flight",
+                "A video recording command is already waiting for requestId $requestId.",
+            )
+        }
+        try {
+            deviceManager.queryVideoRecordingStatus(requestId)
+            return pending.await()
+        } finally {
+            pendingVideoRecordingRequests.remove(requestId, pendingRequest)
+        }
+    }
+
     suspend fun requestVersionInfo(): VersionInfoResult {
         val pending = PendingResponse<VersionInfoResult>("version info request")
         synchronized(oneShotLock) {
@@ -1110,11 +1181,13 @@ class MentraBluetoothSdk private constructor(
         }
     }
 
-    internal fun setOtaVersionUrl(otaVersionUrl: String) {
+    /** Select the HTTP(S) manifest used by subsequent OTA checks and installs. */
+    fun setOtaVersionUrl(otaVersionUrl: String) {
         configuredOtaVersionUrl = OtaManifestChecker.normalizeHttpUrl(otaVersionUrl)
     }
 
-    internal fun getOtaVersionUrl(): String = configuredOtaVersionUrl ?: OtaManifestDefaults.defaultOtaVersionUrl()
+    /** Return the configured OTA manifest, or this SDK release's default manifest. */
+    fun getOtaVersionUrl(): String = configuredOtaVersionUrl ?: OtaManifestDefaults.defaultOtaVersionUrl()
 
     /** Fetch the configured OTA manifest and return whether any ASG/BES/MTK update is available. */
     suspend fun checkForOtaUpdate(): Boolean {
@@ -1240,6 +1313,12 @@ class MentraBluetoothSdk private constructor(
                 systemTimeMs = versionInfo.systemTimeMs ?: status.systemTimeMs,
                 otaVersionUrl = versionInfo.otaVersionUrl.ifBlank { status.otaVersionUrl },
                 appVersion = versionInfo.appVersion.ifBlank { status.appVersion },
+                hotspotOtaVersion =
+                    if (versionInfo.hotspotOtaVersion > 0) {
+                        versionInfo.hotspotOtaVersion
+                    } else {
+                        status.hotspotOtaVersion
+                    },
             )
         } catch (cancellation: CancellationException) {
             // Never swallow cancellation into the stale-status fallback: callers
@@ -1323,6 +1402,12 @@ class MentraBluetoothSdk private constructor(
 
     override fun close() {
         stopStreamKeepAliveMonitor()
+        if (activityLifecycleCallbacksRegistered) {
+            (appContext as? Application)?.unregisterActivityLifecycleCallbacks(
+                activityLifecycleCallbacks,
+            )
+            activityLifecycleCallbacksRegistered = false
+        }
         Bridge.removeEventSink(bridgeEventSinkId)
         DeviceStore.store.removeListener(storeListenerId)
         analytics.shutdown()
@@ -1520,6 +1605,9 @@ class MentraBluetoothSdk private constructor(
                 }
                 dispatchToListeners { it.onGalleryStatus(event) }
             }
+            "pairing_info" -> {
+                dispatchToListeners { it.onRawEvent(eventName, data) }
+            }
             "photo_response" -> {
                 val event = PhotoResponseEvent(data)
                 handlePhotoResponseForRequests(event)
@@ -1567,10 +1655,19 @@ class MentraBluetoothSdk private constructor(
             }
             "ota_status" -> {
                 val resultValues = data + mapOf("type" to "ota_status")
+                val event = OtaStatusEvent.fromMap(resultValues)
                 synchronized(oneShotLock) {
                     pendingOtaQuery?.resolve(OtaQueryResult(resultValues))
+                    otaStartRejectionErrorCode(event)?.let { errorCode ->
+                        pendingOtaStart?.reject(
+                            BluetoothSdkException(errorCode, "Glasses rejected OTA start: $errorCode")
+                        )
+                    }
                 }
-                dispatchToListeners { it.onOtaStatus(OtaStatusEvent.fromMap(resultValues)) }
+                dispatchToListeners { it.onOtaStatus(event) }
+            }
+            "mic_health" -> {
+                dispatchToListeners { it.onMicHealth(MicHealthEvent.fromMap(data)) }
             }
             "settings_ack" -> {
                 val event = SettingsAckEvent(data)
@@ -2161,6 +2258,13 @@ class MentraBluetoothSdk private constructor(
     }
 }
 
-
-
-
+/** OTA status messages are not request-correlated, so only known pre-ack failures settle a start. */
+internal fun otaStartRejectionErrorCode(event: OtaStatusEvent): String? =
+    if (
+        event.status.equals("failed", ignoreCase = true) &&
+            event.errorMessage.equals("battery_low", ignoreCase = true)
+    ) {
+        "battery_low"
+    } else {
+        null
+    }