@mentra/bluetooth-sdk 3.3.0-dev.516 → 3.3.0-dev.523

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

@@ -550,6 +550,8 @@ class BluetoothSdkModule : Module() {
 
         SdkAsyncFunction("forget") { -> sdk?.forget() }
 
+        SdkCoroutineFunction("unpair") { -> deviceManager?.unpair() }
+
         AsyncFunction("connectDefaultController") { deviceManager?.connectDefaultController() }
 
         AsyncFunction("disconnectController") { deviceManager?.disconnectController() }

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

@@ -35,7 +35,10 @@ import com.mentra.bluetoothsdk.utils.MicTypes
 import com.mentra.bluetoothsdk.utils.PhoneAudioMonitor
 import com.mentra.lc3Lib.Lc3Cpp
 import com.mentra.bluetoothsdk.stt.SherpaOnnxTranscriber
+import kotlin.coroutines.resume
+import kotlinx.coroutines.suspendCancellableCoroutine
 import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.withContext
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 import java.text.SimpleDateFormat
@@ -1378,7 +1381,8 @@ class DeviceManager internal constructor(initializeHardware: Boolean) {
             Bridge.log("MAN: Cleaning up previous sgc type: ${sgc?.type}")
             sgc?.cleanup()
             sgc = null
-            resetSystemTimeSync()
+            DeviceStore.apply("glasses", "micEnabled", false)
+            resetConnectionReadyState()
         }
 
         if (sgc != null) {
@@ -1536,6 +1540,7 @@ class DeviceManager internal constructor(initializeHardware: Boolean) {
         // re-apply display height/depth after reconnection
         mainHandler.postDelayed(
             {
+                val device = sgc ?: return@postDelayed
                 val h =
                     (DeviceStore.store.get("bluetooth", "dashboard_height") as? Number)
                         ?.toInt()
@@ -1544,8 +1549,8 @@ class DeviceManager internal constructor(initializeHardware: Boolean) {
                     (DeviceStore.store.get("bluetooth", "dashboard_depth") as? Number)
                         ?.toInt()
                         ?: dashboardDepth // canonical default (2), not 1
-                val d = rawDepth.coerceIn(1, 4)
-                sgc?.setDashboardPosition(h, d)
+                val d = if (device.type == DeviceTypes.NIMO) rawDepth.coerceIn(0, 10) else rawDepth.coerceIn(1, 4)
+                device.setDashboardPosition(h, d)
             },
             2000
         )
@@ -1574,10 +1579,11 @@ class DeviceManager internal constructor(initializeHardware: Boolean) {
             handleMach1Ready() // Z100 uses same initialization as Mach1
         }
 
-        // Re-apply microphone settings after reconnection
-        // Cache was cleared on disconnect, so this will definitely send commands
+        // Disconnect clears micEnabled but preserves the consumers' audio requests.
+        // Recompute that derived flag before selecting a microphone; replaying an
+        // unchanged should_send_* setting is deduplicated by DeviceStore.apply().
         Bridge.log("MAN: Re-applying microphone settings after reconnection")
-        updateMicState()
+        setMicState()
 
         // send to the server our battery status:
         Bridge.sendBatteryStatus(sgc?.batteryLevel ?: -1, false)
@@ -1617,7 +1623,11 @@ class DeviceManager internal constructor(initializeHardware: Boolean) {
         mainHandler.postDelayed(sync, 3000)
     }
 
-    private fun resetSystemTimeSync() {
+    private fun resetConnectionReadyState() {
+        // Suppress duplicate readiness only within one connection, never across
+        // a genuine disconnect/reconnect of the same glasses inside two seconds.
+        lastReadyHandledKey = ""
+        lastReadyHandledAtMs = 0L
         pendingSystemTimeSync?.let { mainHandler.removeCallbacks(it) }
         pendingSystemTimeSync = null
         lastSystemTimeSyncConnectionKey = ""
@@ -1635,7 +1645,7 @@ class DeviceManager internal constructor(initializeHardware: Boolean) {
 
     fun handleDeviceDisconnected() {
         Bridge.log("MAN: Device disconnected")
-        resetSystemTimeSync()
+        resetConnectionReadyState()
         resetMicHealth()
         DeviceStore.apply("glasses", "headUp", false)
         DeviceStore.apply(
@@ -2445,7 +2455,10 @@ class DeviceManager internal constructor(initializeHardware: Boolean) {
         val device = sgc
         if (device is Nimo) device.cleanup() else device?.disconnect()
         sgc = null // Clear the SGC reference after disconnect
-        resetSystemTimeSync()
+        // This cache belongs to the discarded connection. Keep consumer demand,
+        // but require a new mic-enable command when replacement glasses are ready.
+        DeviceStore.apply("glasses", "micEnabled", false)
+        resetConnectionReadyState()
         resetMicHealth()
         searching = false
         micEnabled = false
@@ -2492,6 +2505,37 @@ class DeviceManager internal constructor(initializeHardware: Boolean) {
         controller = null
     }
 
+    private var unpairInProgress = false
+
+    /** Explicit user Unpair, separate from passive pairing cleanup and logout. */
+    suspend fun unpair() = withContext(Dispatchers.Main) {
+        check(!unpairInProgress) { "Unpair already in progress" }
+        unpairInProgress = true
+        try {
+            val target = sgc
+            val nimo = target as? Nimo
+            val savedNimoAddress = when {
+                defaultWearable == DeviceTypes.NIMO -> deviceAddress
+                pendingWearable == DeviceTypes.NIMO -> pendingDeviceAddress
+                else -> null
+            }
+            if (nimo != null) {
+                suspendCancellableCoroutine<Boolean> { continuation ->
+                    nimo.resetForUnpair { if (continuation.isActive) continuation.resume(it) }
+                }
+                check(sgc === target) { "Glasses changed during Unpair" }
+                // Drop the encrypted link before removing the phone's bond.
+                nimo.disconnect()
+                nimo.removeBluetoothBond()
+            } else if (target == null && savedNimoAddress != null) {
+                Nimo.removeBluetoothBond(savedNimoAddress)
+            }
+            forget()
+        } finally {
+            unpairInProgress = false
+        }
+    }
+
     fun forget() {
         synchronized(recoveryLock) {
             recoverG2Connection = false
@@ -2508,7 +2552,8 @@ class DeviceManager internal constructor(initializeHardware: Boolean) {
             // 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()
+            DeviceStore.apply("glasses", "micEnabled", false)
+            resetConnectionReadyState()
             searching = false
             micEnabled = false
             updateMicState()

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

@@ -3,9 +3,9 @@ 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.3.0"
-    const val RELEASE_IDENTITY: String = "3.3.0-dev.516"
-    const val RELEASE_SET_ID: String = "mentra-3.3.0-dev.516"
-    const val SOURCE_COMMIT: String = "e140b9dbfadd4922046b5a1d57692c1d9e268271"
-    const val OTA_MANIFEST_URL: String = "https://artifactscdn.mentraglass.com/Mentra-Community/MentraOS/releases/mentra-builds-v3.3.0/mentra-live-ota-3.3.0-dev.516.json"
-    const val OTA_MANIFEST_SHA256: String = "8c6a0d5badb8cecadc3da43bbb9ecbc22d9126fccb6aee3274fe9b75af61e893"
+    const val RELEASE_IDENTITY: String = "3.3.0-dev.523"
+    const val RELEASE_SET_ID: String = "mentra-3.3.0-dev.523"
+    const val SOURCE_COMMIT: String = "0dd41dbb1e055eb1d80fb39d26a7ba20448de657"
+    const val OTA_MANIFEST_URL: String = "https://artifactscdn.mentraglass.com/Mentra-Community/MentraOS/releases/mentra-builds-v3.3.0/mentra-live-ota-3.3.0-dev.523.json"
+    const val OTA_MANIFEST_SHA256: String = "ad3129a46a5ff8f018c80defcecc6acf88e7ab2d248d0914ed4c2eb097c3f3ec"
 }

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

@@ -69,6 +69,7 @@ internal object NimoProtocol {
     const val CMD_INSTRUCTION_REPORT = 0x06
     const val CMD_CONTROL_INSTRUCTION = 0x07
     const val CMD_CONTROL_FACTORY = 0x08
+    const val FACTORY_RECOVER = 0x03
     const val CMD_CONTROL_NOTIFICATION = 0x09
 
     // get parameter keys
@@ -89,6 +90,9 @@ internal object NimoProtocol {
     const val SET_DISPLAY_OFF = 0x0F
     const val SET_PHONE_TYPE = 0x14
     const val SET_HEIGHT_LEVEL = 0x17
+    // Dynamic-v1 firmware: 1-based UI locale; 1 selects English.
+    const val SET_SYSTEM_LANGUAGE = 0x24
+    const val LANGUAGE_ENGLISH = 0x01
 
     // control instruction keys
     const val CTRL_ENTER_APP = 0x01
@@ -889,6 +893,17 @@ class Nimo : SGCManager() {
         private const val KEY_LAST_ADDRESS = "nimo_lastDeviceAddress"
         private const val KEY_LAST_NAME = "nimo_lastDeviceName"
 
+        internal fun removeBluetoothBond(address: String?) {
+            if (address.isNullOrBlank()) return
+            try {
+                val device = BluetoothAdapter.getDefaultAdapter()?.getRemoteDevice(address) ?: return
+                val removed = device.javaClass.getMethod("removeBond").invoke(device) as? Boolean
+                Bridge.log("NIMO: Bluetooth unbond requested=$removed")
+            } catch (error: Exception) {
+                Bridge.log("NIMO: Bluetooth unbond failed: ${error.message}")
+            }
+        }
+
         private const val TWS_TIMEOUT_MS = 10_000L
         private const val ACK_TIMEOUT_MS = 5_000L
         // Generous: the glasses' classic bond can take 30-45s PER attempt and may need
@@ -1097,6 +1112,31 @@ class Nimo : SGCManager() {
         DeviceStore.apply("glasses", "connectionState", ConnTypes.DISCONNECTED)
     }
 
+    /** Explicit Unpair only. Ordinary forget/cleanup must never reset the glasses. */
+    internal fun resetForUnpair(onResult: (Boolean) -> Unit) {
+        check(Looper.myLooper() == mainHandler.looper)
+        if (gatt == null || txChar == null || handshakeState != HandshakeState.READY) {
+            Bridge.log("NIMO: unpair while offline; remote reset unavailable")
+            onResult(false)
+            return
+        }
+        isDisconnecting = true
+        stopTimers()
+        reconnectionManager.stop()
+        canvasEncoder.invalidate()
+        canvas.disconnected()
+        Bridge.log("NIMO: sending factory reset for explicit Unpair")
+        sendAwaitingAck(NimoProtocol.CMD_CONTROL_FACTORY, NimoProtocol.FACTORY_RECOVER, byteArrayOf()) {
+            Bridge.log("NIMO: factory reset acknowledged=$it")
+            onResult(it)
+        }
+    }
+
+    internal fun removeBluetoothBond() {
+        val address = gatt?.device?.address ?: lastDeviceAddress ?: return
+        removeBluetoothBond(address)
+    }
+
     override fun forget() {
         if (Looper.myLooper() != mainHandler.looper) {
             runBlocking { withContext(Dispatchers.Main) { forget() } }
@@ -1980,7 +2020,10 @@ class Nimo : SGCManager() {
         }
         val timeout = Runnable {
             // Do not retry a timed-out key on the same transport: a late response is uncorrelated.
-            if (pendingAcks.remove(ackKey) != null) abortTransport("Handshake ACK timeout cmd=$cmd key=$key")
+            pendingAcks.remove(ackKey)?.let { expired ->
+                abortTransport("ACK timeout cmd=$cmd key=$key")
+                expired.onResult(false)
+            }
         }
         pendingAcks[ackKey] = PendingAck(onResult, timeout)
         mainHandler.postDelayed(timeout, timeoutMs)
@@ -2080,6 +2123,9 @@ class Nimo : SGCManager() {
                         needsAck = false
                 )
         )
+        // Optional setting: older firmware may reject it without preventing connection.
+        sendFrame(NimoFrameCodec.encodeFrame(NimoProtocol.CMD_SET_PARAMETER,
+            NimoProtocol.SET_SYSTEM_LANGUAGE, byteArrayOf(NimoProtocol.LANGUAGE_ENGLISH.toByte())))
         getBatteryStatus()
         requestVersionInfo()
 
@@ -2099,7 +2145,10 @@ class Nimo : SGCManager() {
             )
         }
         diagnostics?.connected((negotiatedMtu - 3).coerceIn(20, 512))
-        canvas.readiness(twsConnected && peerCompanionReady == true)
+        // Launch checks peer readiness in firmware; do not wait up to a minute for
+        // the first unsolicited heartbeat just because peer status is still unknown.
+        canvas.activate()
+        canvas.readiness(twsConnected && peerCompanionReady != false)
     }
 
     private fun handshakeFailed() {
@@ -2117,6 +2166,10 @@ class Nimo : SGCManager() {
         canvasEncoder.invalidate()
         canvas.disconnected()
         audioClient.stop()
+        // Nimo's decoder/stream belongs to this GATT session. Consumer demand
+        // remains in bluetooth.should_send_*; readiness must start a fresh stream
+        // even when reconnecting with this same adapter instance.
+        DeviceStore.apply("glasses", "micEnabled", false)
         receiveAssembler.reset()
         writes.reset()
         negotiatedMtu = 23
@@ -2171,6 +2224,7 @@ class Nimo : SGCManager() {
         if (diagnostics?.onPacket(packet) == true) return
         if (packet.size >= 10 && packet[8].toInt() == 7 && (packet[9].toInt() and 255) in listOf(1, 3, 4)) {
             val response = NimoCanvasCodec.response(packet) ?: return
+            if (response.first == 1) Bridge.log("NIMO: canvas Launch response status=${response.second.firstOrNull()?.toInt()}")
             canvas.response(response.first, response.second)
             return
         }
@@ -2202,13 +2256,13 @@ class Nimo : SGCManager() {
                             if (appId != NimoCanvasCodec.APP_ID) {
                                 diagnostics?.cancelHeldCapture("Native app takeover preempted held capture", resumeCanvas = false)
                             }
-                            if (canvas.nativeApp(appId, true)) canvasEncoder.invalidate()
+                            canvas.nativeApp(appId, true)
                         }
                         NimoProtocol.STATE_EXIT -> {
                             if (appId == NimoCanvasCodec.APP_ID) {
                                 diagnostics?.cancelHeldCapture("Canvas exit preempted held capture", resumeCanvas = false)
                             }
-                            if (canvas.nativeApp(appId, false)) canvasEncoder.invalidate()
+                            canvas.nativeApp(appId, false)
                         }
                     }
                 }
@@ -2240,7 +2294,7 @@ class Nimo : SGCManager() {
                     // Both predicates were sampled by this device report. TWS-only
                     // reports and cached state cannot release a status-7 wait.
                     if (handshakeState == HandshakeState.READY) {
-                        canvas.confirmedReadiness(twsConnected && peerCompanionReady == true)
+                        canvas.confirmedReadiness(twsConnected && peerCompanionReady != false)
                     }
                 }
             }
@@ -2266,7 +2320,7 @@ class Nimo : SGCManager() {
         if (!connected && handshakeState == HandshakeState.READY) {
             Bridge.log("NIMO: TWS service dropped mid-session (arm removed/off?)")
         }
-        if (handshakeState == HandshakeState.READY) canvas.readiness(connected && peerCompanionReady == true)
+        if (handshakeState == HandshakeState.READY) canvas.readiness(connected && peerCompanionReady != false)
     }
 
     private fun handleInputEvent(code: Int) {
@@ -2302,6 +2356,9 @@ class Nimo : SGCManager() {
             // 5 not supported, 6 bad parameter, 7 device busy.
             Bridge.log("NIMO: response cmd=$cmd key=$key error status=$statusCode")
         }
+        if (cmd == NimoProtocol.CMD_SET_PARAMETER && key == NimoProtocol.SET_SYSTEM_LANGUAGE) {
+            Bridge.log("NIMO: English menu setting acknowledged=${statusCode == 0} status=$statusCode")
+        }
         resolvePendingAck(cmd, key, statusCode == 0)
 
         if (cmd != NimoProtocol.CMD_GET_PARAMETER || statusCode != 0) return

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

@@ -132,6 +132,7 @@ internal class NimoCanvasCoordinator(
     private var holding = false
     private var heldScope: String? = null
     private var cancelDeadline: (() -> Unit)? = null
+    private var cancelRetry: (() -> Unit)? = null
 
     fun offer(bytes: ByteArray, scope: String, force: Boolean = false) {
         if (holding && scope != heldScope) {
@@ -140,8 +141,15 @@ internal class NimoCanvasCoordinator(
         }
         run(session.offer(bytes, scope, force))
     }
-    fun readiness(ready: Boolean) = run(session.readiness(ready))
-    fun confirmedReadiness(ready: Boolean) = run(session.confirmedReadiness(ready))
+    fun activate() = run(session.activate())
+    fun readiness(ready: Boolean) {
+        if (!ready) { cancelRetry?.invoke(); cancelRetry = null }
+        run(session.readiness(ready))
+    }
+    fun confirmedReadiness(ready: Boolean) {
+        if (!ready) { cancelRetry?.invoke(); cancelRetry = null }
+        run(session.confirmedReadiness(ready))
+    }
     fun hold(onReady: () -> Unit) {
         session.hold(true)
         holding = true
@@ -155,19 +163,14 @@ internal class NimoCanvasCoordinator(
         heldScope = null
         run(session.hold(false, resume))
     }
-    fun exit() = run(session.exit())
-    /** Whether this report also invalidates an unfinished host encode. Exit's report does not
-     * invalidate a NEW scene submitted while the explicit Exit waits for its business ACK. */
-    fun nativeApp(appId: Int, entered: Boolean): Boolean {
-        val takeover = (appId == NimoCanvasCodec.APP_ID && !entered) ||
-            (appId != NimoCanvasCodec.APP_ID && entered)
-        val expectedExitReport = appId == NimoCanvasCodec.APP_ID && !entered && flight?.action?.key == 3
-        val invalidateEncoding = takeover && !expectedExitReport
-        run(session.nativeApp(appId, entered))
-        return invalidateEncoding
+    fun exit() {
+        cancelRetry?.invoke(); cancelRetry = null
+        run(session.exit())
     }
+    fun nativeApp(appId: Int, entered: Boolean) = run(session.nativeApp(appId, entered))
 
     fun disconnected() {
+        cancelRetry?.invoke(); cancelRetry = null
         cancelDeadline?.invoke(); cancelDeadline = null
         flight = null
         holdReady = null
@@ -199,6 +202,7 @@ internal class NimoCanvasCoordinator(
     private fun run(actions: List<NimoCanvasSession.Action>) {
         for (action in actions) when (action) {
             is NimoCanvasSession.Action.Send -> {
+                cancelRetry?.invoke(); cancelRetry = null
                 cancelDeadline?.invoke()
                 val current = Flight(action)
                 flight = current
@@ -219,7 +223,16 @@ internal class NimoCanvasCoordinator(
                 }
             }
             is NimoCanvasSession.Action.Reconnect -> { disconnected(); reconnect(action.reason) }
-            is NimoCanvasSession.Action.Rejected -> rejected(action.status)
+            is NimoCanvasSession.Action.Rejected -> {
+                rejected(action.status)
+                if (action.status == 7) {
+                    cancelRetry?.invoke()
+                    cancelRetry = scheduler.post(1_000) {
+                        cancelRetry = null
+                        run(session.retryNotReady())
+                    }
+                }
+            }
         }
     }
 }

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

@@ -9,6 +9,7 @@ internal class NimoCanvasSession {
   }
   private data class Flight(val key: Int, val frame: ByteArray, val ticket: Long)
   private var ready = false
+  private var transportReady = false
   private var active = false
   private var held = false
   private var locked = false
@@ -16,6 +17,7 @@ internal class NimoCanvasSession {
   private var waitingReadiness = false
   private var observedNotReady = false
   private var readinessRetries = 0
+  private var probeRetries = 0
   private var exitRequested = false
   private var desired: ByteArray? = null
   private var accepted: ByteArray? = null
@@ -35,6 +37,23 @@ internal class NimoCanvasSession {
     return pump()
   }
 
+  /** Enter a blank canvas on a fresh connection unless a newer host scene is retained. */
+  fun activate(): List<Action> {
+    if (desired == null) desired = byteArrayOf(0, 0, 1)
+    exitRequested = false
+    return pump()
+  }
+
+  /** Launch itself checks peer readiness in firmware. Retry only explicit NOT_READY,
+   * with a small budget; never retry an ambiguous/missing business ACK on this link. */
+  fun retryNotReady(): List<Action> {
+    if (!transportReady || !waitingReadiness || desired == null || probeRetries >= 3) return emptyList()
+    probeRetries++
+    waitingReadiness = false
+    ready = true
+    return pump()
+  }
+
   /** Debug capture seam; production behavior is unchanged unless explicitly held. */
   fun hold(value: Boolean, resume: Boolean = true): List<Action> {
     held = value
@@ -50,7 +69,8 @@ internal class NimoCanvasSession {
   fun confirmedReadiness(value: Boolean): List<Action> = updateReadiness(value, confirmed = true)
 
   private fun updateReadiness(value: Boolean, confirmed: Boolean): List<Action> {
-    if (!value) readinessRetries = 0
+    transportReady = value
+    if (!value) { readinessRetries = 0; probeRetries = 0 }
     if (!value && flight != null) return resetLink("Readiness lost during canvas command")
     if (waitingReadiness) {
       if (!value) observedNotReady = true
@@ -67,9 +87,9 @@ internal class NimoCanvasSession {
 
   /** A new transport generation has no accepted frame. Retain only the latest desired scene. */
   fun disconnected() {
-    ready = false; active = false; held = false; locked = false; launchBlocked = false
+    ready = false; transportReady = false; active = false; held = false; locked = false; launchBlocked = false
     waitingReadiness = false; observedNotReady = false
-    readinessRetries = 0
+    readinessRetries = 0; probeRetries = 0
     accepted = null; rejected = null; flight = null; ticket++; forceRevision++
   }
 
@@ -78,21 +98,13 @@ internal class NimoCanvasSession {
     return pump()
   }
 
-  /** A local gesture/native app takeover suppresses replay until the host submits another scene. */
+  /** Firmware can restore its stock UI after reconnect. Keep host ownership and
+   * replay the newest scene, serializing behind any outstanding command ACK. */
   fun nativeApp(appId: Int, entered: Boolean): List<Action> {
     if ((appId == NimoCanvasCodec.APP_ID && !entered) || (appId != NimoCanvasCodec.APP_ID && entered)) {
-      // The expected FD Exit report preserves newer host content. A different
-      // native app entering is a real takeover, even while our Exit waits for ACK.
-      if (flight?.key == 3) {
-        active = false; accepted = null
-        if (appId != NimoCanvasCodec.APP_ID && entered) {
-          desired = null; rejected = null; scope = null
-        }
-        return emptyList()
-      }
-      val ambiguous = flight != null
-      desired = null; accepted = null; rejected = null; active = false; exitRequested = false; scope = null
-      if (ambiguous) return resetLink("Native app transition interrupted canvas command")
+      active = false
+      accepted = null
+      return pump()
     }
     return emptyList()
   }
@@ -130,8 +142,8 @@ internal class NimoCanvasSession {
       return listOf(Action.Rejected(status)) + pump()
     }
     when (key) {
-      1 -> active = true
-      4 -> { accepted = current.frame; rejected = null; readinessRetries = 0 }
+      1 -> { active = true; accepted = null }
+      4 -> { accepted = current.frame; rejected = null; readinessRetries = 0; probeRetries = 0 }
       3 -> { active = false; accepted = null; exitRequested = false }
     }
     return pump()
@@ -143,7 +155,7 @@ internal class NimoCanvasSession {
   }
 
   private fun resetLink(reason: String): List<Action> {
-    ready = false; active = false; accepted = null; flight = null; ticket++; forceRevision++
+    ready = false; transportReady = false; active = false; accepted = null; flight = null; ticket++; forceRevision++
     return listOf(Action.Reconnect(reason))
   }
 

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

@@ -4,6 +4,7 @@ import android.bluetooth.BluetoothGatt
 import android.bluetooth.BluetoothGattCallback
 import android.bluetooth.BluetoothGattCharacteristic
 import android.bluetooth.BluetoothGattDescriptor
+import android.os.Build
 
 /**
  * Binder callbacks only capture their arguments. Session validation and all callback effects run
@@ -45,6 +46,10 @@ internal abstract class SerializedGattCallback(
     final override fun onCharacteristicChanged(
         gatt: BluetoothGatt, characteristic: BluetoothGattCharacteristic,
     ) {
+        // Android 13 introduced the value callback; some framework versions also call
+        // this deprecated overload for the same notification. Decoding both replays
+        // each LC3 packet and doubles recorded audio. Older Android uses this path.
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) return
         val value = characteristic.value?.copyOf() ?: return
         dispatch(gatt) { handleCharacteristicChanged(gatt, characteristic, value) }
     }

package/android/src/test/java/com/mentra/bluetoothsdk/DeviceManagerSceneHandoffTest.kt

@@ -24,6 +24,110 @@ import java.util.concurrent.TimeUnit
 class DeviceManagerSceneHandoffTest {
     @Before fun setup() { Bridge.initialize(ApplicationProvider.getApplicationContext()) }
 
+    @Test @LooperMode(LooperMode.Mode.PAUSED)
+    fun delayedReconnectReplayPreservesNimoDepthEndpoints() {
+        for (depth in listOf(0, 10)) {
+            withReadyRecordingDevice { manager, device, _ ->
+                DeviceStore.set("bluetooth", "dashboard_height", 7)
+                DeviceStore.set("bluetooth", "dashboard_depth", depth)
+                manager.handleDeviceReady()
+                assertTrue(device.positions.isEmpty())
+                Shadows.shadowOf(Looper.getMainLooper()).idleFor(2, TimeUnit.SECONDS)
+                assertEquals(listOf(7 to depth), device.positions)
+            }
+        }
+    }
+
+    @Test @LooperMode(LooperMode.Mode.PAUSED)
+    fun reconnectRestoresUnchangedAudioRequests() {
+        for (request in listOf("should_send_lc3", "should_send_pcm", "should_send_transcript", "local_stt_fallback_active")) {
+            withReadyRecordingDevice { manager, original, _ ->
+                for (key in listOf("should_send_lc3", "should_send_pcm", "should_send_transcript", "local_stt_fallback_active")) {
+                    DeviceStore.set("bluetooth", key, key == request)
+                }
+                DeviceStore.set("bluetooth", "micRanking", listOf("glasses"))
+                DeviceStore.set("glasses", "micEnabled", false)
+                original.hasMic = true
+                manager.setMicState()
+                assertEquals(true, DeviceStore.get("bluetooth", "micEnabled"))
+                assertEquals(true, DeviceStore.get("glasses", "micEnabled"))
+
+                repeat(3) {
+                    manager.disconnect()
+                    assertEquals(false, DeviceStore.get("bluetooth", "micEnabled"))
+                    assertEquals(false, DeviceStore.get("glasses", "micEnabled"))
+                    assertEquals(true, DeviceStore.get("bluetooth", request))
+                    val replacement = NimoRecordingSGC().apply { hasMic = true }
+                    manager.sgc = replacement
+
+                    // No test reset of glasses.micEnabled: production teardown must
+                    // clear it. Replaying the same consumer request is deduplicated.
+                    DeviceStore.apply("bluetooth", request, true)
+                    assertEquals(false, DeviceStore.get("bluetooth", "micEnabled"))
+                    DeviceStore.apply("glasses", "fullyBooted", true)
+
+                    assertEquals("Reconnect must restore $request", true, DeviceStore.get("bluetooth", "micEnabled"))
+                    assertEquals(listOf(true), replacement.micChanges)
+                    assertEquals("glasses", manager.activeMicSource())
+                }
+            }
+        }
+    }
+
+    @Test @LooperMode(LooperMode.Mode.PAUSED)
+    fun linkDisconnectRetainsIntentForTheSameCommunicator() {
+        withReadyRecordingDevice { manager, original, _ ->
+            original.hasMic = true
+            DeviceStore.set("bluetooth", "micRanking", listOf("glasses"))
+            DeviceStore.set("glasses", "micEnabled", false)
+            DeviceStore.set("bluetooth", "should_send_lc3", true)
+            manager.setMicState()
+            assertEquals(listOf(true), original.micChanges)
+            DeviceStore.set("glasses", "fullyBooted", true)
+            DeviceStore.apply("glasses", "fullyBooted", false)
+            assertSame(original, manager.sgc)
+            assertEquals(true, DeviceStore.get("bluetooth", "should_send_lc3"))
+            assertEquals(true, DeviceStore.get("glasses", "micEnabled"))
+        }
+    }
+
+    @Test @LooperMode(LooperMode.Mode.PAUSED)
+    fun discardingCommunicatorInvalidatesMicCache() {
+        withReadyRecordingDevice { manager, original, _ ->
+            original.hasMic = true
+            DeviceStore.set("bluetooth", "micRanking", listOf("glasses"))
+            DeviceStore.set("glasses", "micEnabled", false)
+            DeviceStore.set("bluetooth", "should_send_lc3", true)
+            manager.setMicState()
+            manager.initSGC(original.type)
+            assertEquals(true, DeviceStore.get("glasses", "micEnabled"))
+
+            // An unsupported model exercises disposal without starting real BLE.
+            manager.initSGC("Unavailable test glasses")
+            assertNull(manager.sgc)
+            assertEquals(false, DeviceStore.get("glasses", "micEnabled"))
+            assertEquals(true, DeviceStore.get("bluetooth", "should_send_lc3"))
+        }
+    }
+
+    @Test @LooperMode(LooperMode.Mode.PAUSED)
+    fun reconnectWithoutAudioRequestsLeavesMicrophoneOff() {
+        withReadyRecordingDevice { manager, _, _ ->
+            for (key in listOf("should_send_lc3", "should_send_pcm", "should_send_transcript", "local_stt_fallback_active")) {
+                DeviceStore.set("bluetooth", key, false)
+            }
+            DeviceStore.set("glasses", "micEnabled", true)
+            manager.disconnect()
+            assertEquals(false, DeviceStore.get("glasses", "micEnabled"))
+            val replacement = NimoRecordingSGC().apply { hasMic = true }
+            manager.sgc = replacement
+            DeviceStore.apply("glasses", "fullyBooted", true)
+            assertEquals(false, DeviceStore.get("bluetooth", "micEnabled"))
+            assertEquals("", manager.activeMicSource())
+            assertTrue(replacement.micChanges.isEmpty())
+        }
+    }
+
     @Test @LooperMode(LooperMode.Mode.PAUSED)
     fun nimoBrightnessChangesDoNotReplaceTheSelectedScene() {
         for (headUp in listOf(false, true)) for ((key, value) in brightnessChanges()) {
@@ -499,8 +603,10 @@ class DeviceManagerSceneHandoffTest {
     }
 
     private open class RecordingSGC(override val sceneHandoffRequiresClear: Boolean) : SGCManager() {
+        val micChanges = mutableListOf<Boolean>()
         val calls = CopyOnWriteArrayList<String>()
         val brightnessCalls = mutableListOf<String>()
+        val positions = mutableListOf<Pair<Int, Int>>()
         val textSent = CountDownLatch(1)
         var lastTextNanos = 0L
         var lastClearNanos = 0L
@@ -511,7 +617,10 @@ class DeviceManagerSceneHandoffTest {
         override fun sendTextWall(text: String) { lastTextNanos = System.nanoTime(); calls += "text:$text"; textSent.countDown() }
         override fun disconnect() { calls += "disconnect" }
         override fun cleanup() { calls += "cleanup" }
-        override fun setMicEnabled(enabled: Boolean) {}
+        override fun setMicEnabled(enabled: Boolean) {
+            micChanges += enabled
+            DeviceStore.set("glasses", "micEnabled", enabled)
+        }
         override fun sortMicRanking(list: MutableList<String>) = list
         override fun requestPhoto(request: PhotoRequest) {}
         override fun startStream(message: MutableMap<String, Any>) {}
@@ -528,7 +637,7 @@ class DeviceManagerSceneHandoffTest {
         override fun sendDoubleTextWall(top: String, bottom: String) {}
         override fun displayBitmap(base64ImageData: String, x: Int?, y: Int?, width: Int?, height: Int?) = true
         override fun showDashboard() {}
-        override fun setDashboardPosition(height: Int, depth: Int) {}
+        override fun setDashboardPosition(height: Int, depth: Int) { positions += height to depth }
         override fun setHeadUpAngle(angle: Int) {}
         override fun getBatteryStatus() {}
         override fun setSilentMode(enabled: Boolean) {}