@mentra/bluetooth-sdk 3.2.0-dev.195 → 3.2.0-dev.203

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

@@ -39,6 +39,8 @@ import com.mentra.bluetoothsdk.PhotoSize
 import com.mentra.bluetoothsdk.PhotoMode
 import com.mentra.bluetoothsdk.DeviceStore
 import com.mentra.bluetoothsdk.ObservableStore
+import com.mentra.bluetoothsdk.incomingGlassesMessageAckId
+import com.mentra.bluetoothsdk.wifiResponseEnvelopeIsValid
 import com.mentra.bluetoothsdk.debug.BleTraceLogger
 import com.mentra.bluetoothsdk.utils.BlePhotoUploadService
 import com.mentra.bluetoothsdk.utils.ConnTypes
@@ -141,6 +143,9 @@ class MentraLive : SGCManager() {
         private const val A2DP_CONNECT_MAX_ATTEMPTS = 5
         private const val A2DP_CONNECT_RETRY_MS = 800L
         private const val UNPAIR_FLUSH_MS = 400L
+        private const val GATT_DISCONNECT_TIMEOUT_MS = 2_000L
+        private const val MTU_CALLBACK_TIMEOUT_MS = 3_000L
+        private val gattTeardownBarrier = MentraLiveGattTeardownBarrier()
 
         // L2CAP CoC fast path: new BES2700 firmware registers an LE L2CAP CoC server on this
         // PSM. When the phone opens the channel, the glasses send file packets over it instead
@@ -564,6 +569,12 @@ class MentraLive : SGCManager() {
     private var bluetoothAdapter: BluetoothAdapter? = null
     private var bluetoothScanner: BluetoothLeScanner? = null
     @Volatile private var bluetoothGatt: BluetoothGatt? = null
+    private val gattLifecycleHandler = Handler(Looper.getMainLooper())
+    // Owned exclusively by the main looper, including callback validation and mutation.
+    private var gattEpoch = 0L
+    private var connectionRequestEpoch = 0L
+    @Volatile private var gattTeardownToken: Long? = null
+    @Volatile private var gattTeardownTimeoutRunnable: Runnable? = null
     private var connectedDevice: BluetoothDevice? = null
     private var txCharacteristic: BluetoothGattCharacteristic? = null
     private var rxCharacteristic: BluetoothGattCharacteristic? = null
@@ -591,9 +602,14 @@ class MentraLive : SGCManager() {
 
     // CTKD (Cross-Transport Key Derivation) support for BES devices
     private var isBondingReceiverRegistered = false
-    private var isBtClassicConnected = false
     private var bondingReceiver: BroadcastReceiver? = null
     private var bondingRetryCount = 0
+    private var classicAudioReceiver: BroadcastReceiver? = null
+    private var isClassicAudioReceiverRegistered = false
+    private val classicAudioConnectionTracker =
+            ClassicAudioConnectionTracker { connected ->
+                DeviceStore.apply("glasses", "bluetoothClassicConnected", connected)
+            }
 
     // Pairing timing diagnostics (filter logcat: PAIRING_TIMING)
     private var pairingTimingActive = false
@@ -643,6 +659,9 @@ class MentraLive : SGCManager() {
     private var isDescriptorWriteInProgress = false
     private var notificationsEnabled =
             false // Track if enableNotifications was already called this connection
+    private val mtuSetupGate = MentraLiveMtuSetupGate()
+    private var mtuSetupToken: Long? = null
+    private var mtuWatchdogRunnable: Runnable? = null
     private var connectionTimeoutRunnable: Runnable? = null
     private var connectionTimeoutHandler = Handler(Looper.getMainLooper())
     private var processSendQueueRunnable: Runnable? = null
@@ -992,6 +1011,8 @@ class MentraLive : SGCManager() {
 
         // Initialize CTKD bonding receiver
         initializeBondingReceiver()
+        initializeClassicAudioReceiver()
+        registerClassicAudioReceiver()
 
         // Initialize the send queue processor
         processSendQueueRunnable = Runnable {
@@ -1233,6 +1254,7 @@ class MentraLive : SGCManager() {
 
     /** Starts BLE scanning for Mentra Live glasses */
     private fun startScan() {
+        if (postGattLifecycle { startScan() }) return
         if (pairingYieldActive) {
             Bridge.log("LIVE: startScan blocked — pairing yield active")
             return
@@ -1297,6 +1319,7 @@ class MentraLive : SGCManager() {
 
             val generation = ++scanGeneration
             isScanning = true
+            scanCallback = createScanCallback(generation)
             bluetoothScanner!!.startScan(filters, settings, scanCallback)
 
             // Set a timeout to stop scanning
@@ -1349,6 +1372,7 @@ class MentraLive : SGCManager() {
 
     /** Stops BLE scanning */
     override fun stopScan() {
+        if (postGattLifecycle { stopScan() }) return
         manualDiscoveryActive = false
         if (bluetoothAdapter == null || bluetoothScanner == null || !isScanning) {
             return
@@ -1424,9 +1448,13 @@ class MentraLive : SGCManager() {
     var seenDevices: MutableSet<String> = HashSet()
 
     /** BLE Scan callback */
-    private val scanCallback: ScanCallback =
+    private var scanCallback: ScanCallback? = null
+
+    private fun createScanCallback(generation: Int): ScanCallback =
             object : ScanCallback() {
                 override fun onScanResult(callbackType: Int, result: ScanResult) {
+                    if (postGattLifecycle { onScanResult(callbackType, result) }) return
+                    if (!isScanning || generation != scanGeneration) return
                     // Check if the object has been destroyed to prevent NPE
                     if (context == null || isKilled) {
                         Bridge.log("LIVE: Ignoring scan result - object destroyed or killed")
@@ -1559,6 +1587,8 @@ class MentraLive : SGCManager() {
                 }
 
                 override fun onScanFailed(errorCode: Int) {
+                    if (postGattLifecycle { onScanFailed(errorCode) }) return
+                    if (generation != scanGeneration || !isScanning) return
                     Log.e(TAG, "BLE scan failed with error: " + errorCode)
                     isScanning = false
                     if (isReconnecting && !isKilled) {
@@ -1588,30 +1618,120 @@ class MentraLive : SGCManager() {
         }
     }
 
-    /**
-     * Safely tear down the GATT reference. Avoids NPE / races with gatt callbacks disconnecting on
-     * a binder thread while a queued teardown runnable fires. Pass disconnect=true to call
-     * disconnect() before close().
-     */
-    @Synchronized
+    /** Return true when work was handed to the single process-wide lifecycle queue. */
+    private fun postGattLifecycle(work: () -> Unit): Boolean {
+        if (Looper.myLooper() == gattLifecycleHandler.looper) return false
+        gattLifecycleHandler.post { work() }
+        return true
+    }
+
+    /** Safely close GATT, waiting for Android to finish a requested disconnect when possible. */
     private fun closeGattQuietly(disconnect: Boolean) {
+        check(Looper.myLooper() == gattLifecycleHandler.looper)
         val gatt = bluetoothGatt
-        bluetoothGatt = null
         if (gatt == null) {
             return
         }
+        cancelMtuWatchdog()
+        if (disconnect) {
+            beginGattTeardown(gatt)
+            return
+        }
+        bluetoothGatt = null
+        releaseGattSessionMedia()
         try {
-            if (disconnect) {
-                gatt.disconnect()
-            }
+            gatt.close()
+        } catch (e: Exception) {
+            Log.w(TAG, "🔌 closeGattQuietly: close threw " + e)
+        }
+    }
+
+    /** Release side channels on every teardown, including missing disconnect callbacks. */
+    private fun releaseGattSessionMedia() {
+        closeL2capFileChannel()
+        fileProcessingHandler.removeCallbacksAndMessages(null)
+        clearFilePacketBuffer()
+        closeLc3Logging()
+        lc3AudioPlayer?.stopPlay()
+    }
+
+    private fun beginGattTeardown(gatt: BluetoothGatt) {
+        check(Looper.myLooper() == gattLifecycleHandler.looper)
+        if (gatt !== bluetoothGatt || gattTeardownToken != null) {
+            return
+        }
+        val token = gattTeardownBarrier.beginTeardown()
+        gattTeardownToken = token
+        // Teardown owns session invalidation, including the timeout/replacement paths that do
+        // not receive the normal remote-disconnect cleanup callback.
+        cancelMtuWatchdog()
+        isConnected = false
+        isConnecting = false
+        connectedDevice = null
+        glassesReady = false
+        glassesSessionId = null
+        readinessCompletedThisBleSession = false
+        glassesReadyReceived = false
+        ctkdInitiatedThisGattSession = false
+        audioConnected = false
+        notificationsEnabled = false
+        currentMtu = 23
+        pendingDescriptorWrites.clear()
+        isDescriptorWriteInProgress = false
+        txCharacteristic = null
+        rxCharacteristic = null
+        lc3ReadCharacteristic = null
+        lc3WriteCharacteristic = null
+        handler.removeCallbacks(processSendQueueRunnable!!)
+        stopReadinessCheckLoop()
+        stopHeartbeat()
+        stopSignalStrengthPolling()
+        stopMicBeat()
+        releaseGattSessionMedia()
+        updateConnectionState(ConnTypes.DISCONNECTED)
+        val timeout =
+                Runnable {
+                    Bridge.log(
+                            "LIVE: 🔌 GATT disconnect callback timed out after ${GATT_DISCONNECT_TIMEOUT_MS}ms; closing transport"
+                    )
+                    completeGattTeardown(gatt, token, "timeout")
+                }
+        gattTeardownTimeoutRunnable = timeout
+        gattLifecycleHandler.postDelayed(timeout, GATT_DISCONNECT_TIMEOUT_MS)
+        try {
+            Bridge.log("LIVE: 🔌 Waiting for GATT disconnected callback before close")
+            gatt.disconnect()
         } catch (e: Exception) {
-            Log.w(TAG, "🔌 closeGattQuietly: disconnect threw " + e)
+            Log.w(TAG, "🔌 GATT disconnect threw " + e)
+            completeGattTeardown(gatt, token, "disconnect_exception")
+        }
+    }
+
+    private fun completeGattTeardown(gatt: BluetoothGatt, token: Long, reason: String) {
+        check(Looper.myLooper() == gattLifecycleHandler.looper)
+        if (gattTeardownToken != token) {
+            return
+        }
+        gattTeardownTimeoutRunnable?.let { gattLifecycleHandler.removeCallbacks(it) }
+        gattTeardownTimeoutRunnable = null
+        gattTeardownToken = null
+        if (gatt === bluetoothGatt) {
+            bluetoothGatt = null
         }
         try {
             gatt.close()
         } catch (e: Exception) {
-            Log.w(TAG, "🔌 closeGattQuietly: close threw " + e)
+            Log.w(TAG, "🔌 GATT close after $reason threw " + e)
         }
+        Bridge.log("LIVE: 🔌 GATT teardown complete ($reason)")
+        gattTeardownBarrier.completeTeardown(token)
+    }
+
+    private fun cancelMtuWatchdog() {
+        mtuWatchdogRunnable?.let { gattLifecycleHandler.removeCallbacks(it) }
+        mtuWatchdogRunnable = null
+        mtuSetupToken = null
+        mtuSetupGate.cancel()
     }
 
     /**
@@ -1634,6 +1754,11 @@ class MentraLive : SGCManager() {
         return false
     }
 
+    /** Ignore all non-disconnect work once this GATT is stale or tearing down. */
+    private fun isActiveGattCallback(gatt: BluetoothGatt): Boolean {
+        return isCurrentGattCallback(gatt) && gattTeardownToken == null
+    }
+
     private fun beginPairingTiming(reason: String) {
         pairingTimingStartMs = SystemClock.elapsedRealtime()
         pairingTimingLastMs = pairingTimingStartMs
@@ -1662,15 +1787,32 @@ class MentraLive : SGCManager() {
 
     /** Connect to a specific BLE device */
     private fun connectToDevice(device: BluetoothDevice?) {
+        if (postGattLifecycle { connectToDevice(device) }) return
         if (device == null) {
             return
         }
-        if (pairingYieldActive) {
+        if (isKilled || pairingYieldActive) {
             Bridge.log("LIVE: connectToDevice blocked — pairing yield active")
             isConnecting = false
             isReconnecting = false
             return
         }
+        val requestEpoch = ++connectionRequestEpoch
+        // Never replace a still-open GATT. Its disconnect/close must finish first.
+        bluetoothGatt?.let { beginGattTeardown(it) }
+        gattTeardownBarrier.runWhenIdle {
+            if (requestEpoch == connectionRequestEpoch && !isKilled && !pairingYieldActive) {
+                connectToDeviceWhenIdle(device)
+            }
+        }
+    }
+
+    private fun connectToDeviceWhenIdle(device: BluetoothDevice) {
+        check(Looper.myLooper() == gattLifecycleHandler.looper)
+        check(bluetoothGatt == null)
+        val epoch = ++gattEpoch
+        currentMtu = 23
+        val gattCallback = createGattCallback(epoch)
 
         beginPairingTiming(
                 "connectToDevice addr=${device.address} name=${safeDeviceName(device)} attempt=$reconnectAttempts"
@@ -1683,7 +1825,7 @@ class MentraLive : SGCManager() {
 
         // Set connection timeout
         connectionTimeoutRunnable = Runnable {
-            if (isConnecting && !isConnected) {
+            if (epoch == gattEpoch && isConnecting && !isConnected) {
                 Log.w(
                         TAG,
                         "🔌 ⏰ CONNECTION TIMEOUT after " +
@@ -1775,6 +1917,8 @@ class MentraLive : SGCManager() {
     // }
 
     private fun enterPairingYield(windowMs: Long) {
+        if (postGattLifecycle { enterPairingYield(windowMs) }) return
+        connectionRequestEpoch++
         pairingYieldActive = true
         pairingYieldAwaitingReclaim = false
         isReconnecting = false
@@ -1855,6 +1999,7 @@ class MentraLive : SGCManager() {
 
     /** Handle reconnection with exponential backoff */
     private fun handleReconnection() {
+        if (postGattLifecycle { handleReconnection() }) return
         // Don't attempt reconnection if we've been killed/forgotten
         if (isKilled) {
             Bridge.log("LIVE: 🔌 RECONNECT ABORTED - device has been killed/forgotten")
@@ -2093,9 +2238,13 @@ class MentraLive : SGCManager() {
     }
 
     /** GATT callback for BLE operations */
-    private val gattCallback: BluetoothGattCallback =
-            object : BluetoothGattCallback() {
-                override fun onConnectionStateChange(
+    private fun createGattCallback(epoch: Long): BluetoothGattCallback =
+            object : SerializedGattCallback({ work ->
+                // Always enqueue, even for an inline platform callback during connectGatt().
+                // This lets connectGatt return and install the identity before validation.
+                gattLifecycleHandler.post { work() }
+            }, { gatt -> epoch == gattEpoch && isCurrentGattCallback(gatt) }) {
+                override fun handleConnectionStateChange(
                         gatt: BluetoothGatt,
                         status: Int,
                         newState: Int
@@ -2103,6 +2252,19 @@ class MentraLive : SGCManager() {
                     if (!isCurrentGattCallback(gatt)) {
                         return
                     }
+                    val teardownToken = gattTeardownToken
+                    if (teardownToken != null) {
+                        if (
+                                newState == BluetoothProfile.STATE_DISCONNECTED ||
+                                        status != BluetoothGatt.GATT_SUCCESS
+                        ) {
+                            completeGattTeardown(gatt, teardownToken, "disconnected_callback")
+                        }
+                        // Once teardown starts, a queued successful CONNECTED callback belongs to
+                        // the closing transport. It must not resurrect application connection
+                        // state while the disconnect callback is still pending.
+                        return
+                    }
 
                     // Cancel the connection timeout
                     if (connectionTimeoutRunnable != null) {
@@ -2119,6 +2281,8 @@ class MentraLive : SGCManager() {
                             isConnecting = false
                             isConnected = true
                             connectedDevice = gatt.device
+                            classicAudioConnectionTracker.setTarget(gatt.device.address)
+                            refreshClassicAudioConnectionState(gatt.device)
                             emitConnectedPendingDeviceForPairingScan()
 
                             DeviceStore.apply("glasses", "bluetoothName", connectedDevice!!.name)
@@ -2209,11 +2373,6 @@ class MentraLive : SGCManager() {
                             // Stop micbeat mechanism
                             stopMicBeat()
 
-                            // Close the L2CAP file channel (if the fast path was open)
-                            closeL2capFileChannel()
-                            fileProcessingHandler.removeCallbacksAndMessages(null)
-                            clearFilePacketBuffer()
-
                             // Clean up GATT resources
                             closeGattQuietly(false)
 
@@ -2223,13 +2382,6 @@ class MentraLive : SGCManager() {
                                 handleReconnection()
                             }
 
-                            // Close LC3 audio logging
-                            closeLc3Logging()
-
-                            // stop LC3 player
-                            if (lc3AudioPlayer != null) {
-                                lc3AudioPlayer!!.stopPlay()
-                            }
                         }
                     } else {
                         // Connection error
@@ -2302,7 +2454,7 @@ class MentraLive : SGCManager() {
                     }
                 }
 
-                override fun onPhyUpdate(
+                override fun handlePhyUpdate(
                         gatt: BluetoothGatt,
                         txPhy: Int,
                         rxPhy: Int,
@@ -2318,7 +2470,7 @@ class MentraLive : SGCManager() {
                     )
                 }
 
-                override fun onPhyRead(
+                override fun handlePhyRead(
                         gatt: BluetoothGatt,
                         txPhy: Int,
                         rxPhy: Int,
@@ -2334,7 +2486,10 @@ class MentraLive : SGCManager() {
                     )
                 }
 
-                override fun onServicesDiscovered(gatt: BluetoothGatt, status: Int) {
+                override fun handleServicesDiscovered(gatt: BluetoothGatt, status: Int) {
+                    if (!isActiveGattCallback(gatt)) {
+                        return
+                    }
                     if (status == BluetoothGatt.GATT_SUCCESS) {
                         Bridge.log("LIVE: GATT services discovered")
 
@@ -2397,7 +2552,17 @@ class MentraLive : SGCManager() {
                                 // This ensures no concurrent GATT operations on older Android BLE
                                 // stacks.
                                 if (checkPermission()) {
-                                    val mtuRequested = gatt.requestMtu(512)
+                                    val mtuToken = mtuSetupGate.begin()
+                                    mtuSetupToken = mtuToken
+                                    val mtuRequested =
+                                            try {
+                                                gatt.requestMtu(512)
+                                            } catch (e: SecurityException) {
+                                                Bridge.log(
+                                                        "LIVE: ⚠️ MTU request denied; continuing with notification setup"
+                                                )
+                                                false
+                                            }
                                     Bridge.log(
                                             "LIVE: 🔄 Requested MTU size 512, success: " +
                                                     mtuRequested
@@ -2405,12 +2570,18 @@ class MentraLive : SGCManager() {
                                     if (!mtuRequested) {
                                         // MTU request failed to even start, enable notifications
                                         // directly
-                                        enableNotifications()
+                                        completeMtuSetup(
+                                                gatt,
+                                                mtuToken,
+                                                "request_not_started"
+                                        )
+                                    } else {
+                                        startMtuWatchdog(gatt, mtuToken)
                                     }
                                     // Otherwise, enableNotifications() will be called from
                                     // onMtuChanged
                                 } else {
-                                    enableNotifications()
+                                    enableNotificationsAfterMtu(gatt, "permission_fallback")
                                 }
 
                                 // NOTE: Send queue and readiness loop are started AFTER descriptor
@@ -2437,11 +2608,14 @@ class MentraLive : SGCManager() {
                     }
                 }
 
-                override fun onCharacteristicRead(
+                override fun handleCharacteristicRead(
                         gatt: BluetoothGatt,
                         characteristic: BluetoothGattCharacteristic,
                         status: Int
                 ) {
+                    if (!isActiveGattCallback(gatt)) {
+                        return
+                    }
                     if (status == BluetoothGatt.GATT_SUCCESS) {
                         Bridge.log("LIVE: Characteristic read successful")
                         // Process the read data if needed
@@ -2450,7 +2624,10 @@ class MentraLive : SGCManager() {
                     }
                 }
 
-                override fun onReadRemoteRssi(gatt: BluetoothGatt, rssi: Int, status: Int) {
+                override fun handleReadRemoteRssi(gatt: BluetoothGatt, rssi: Int, status: Int) {
+                    if (!isActiveGattCallback(gatt)) {
+                        return
+                    }
                     rssiReadInProgress = false
                     if (status == BluetoothGatt.GATT_SUCCESS) {
                         if (isConnected && bluetoothGatt != null && gatt === bluetoothGatt) {
@@ -2461,11 +2638,14 @@ class MentraLive : SGCManager() {
                     }
                 }
 
-                override fun onCharacteristicWrite(
+                override fun handleCharacteristicWrite(
                         gatt: BluetoothGatt,
                         characteristic: BluetoothGattCharacteristic,
                         status: Int
                 ) {
+                    if (!isActiveGattCallback(gatt)) {
+                        return
+                    }
                     val trace = inFlightBleWriteTrace
                     val callbackAtMs = System.currentTimeMillis()
                     val callbackDelayMs =
@@ -2527,11 +2707,12 @@ class MentraLive : SGCManager() {
                     }
                 }
 
-                override fun onCharacteristicChanged(
+                override fun handleCharacteristicChanged(
                         gatt: BluetoothGatt,
-                        characteristic: BluetoothGattCharacteristic
+                        characteristic: BluetoothGattCharacteristic,
+                        data: ByteArray
                 ) {
-                    if (!isCurrentGattCallback(gatt)) {
+                    if (!isActiveGattCallback(gatt)) {
                         return
                     }
 
@@ -2539,8 +2720,7 @@ class MentraLive : SGCManager() {
                     val threadId = Thread.currentThread().id
                     val uuid = characteristic.uuid
 
-                    val data = characteristic.value
-                    if (data == null || data.isEmpty()) {
+                    if (data.isEmpty()) {
                         return
                     }
 
@@ -2584,11 +2764,14 @@ class MentraLive : SGCManager() {
                     processReceivedData(data, data.size)
                 }
 
-                override fun onDescriptorWrite(
+                override fun handleDescriptorWrite(
                         gatt: BluetoothGatt,
                         descriptor: BluetoothGattDescriptor,
                         status: Int
                 ) {
+                    if (!isActiveGattCallback(gatt)) {
+                        return
+                    }
                     val threadId = Thread.currentThread().id
 
                     if (status == BluetoothGatt.GATT_SUCCESS) {
@@ -2616,43 +2799,91 @@ class MentraLive : SGCManager() {
                     writeNextDescriptor()
                 }
 
-                override fun onMtuChanged(gatt: BluetoothGatt, mtu: Int, status: Int) {
-                    if (status == BluetoothGatt.GATT_SUCCESS) {
-                        Bridge.log(
-                                "LIVE: 🔵 MTU negotiation successful - changed to " + mtu + " bytes"
-                        )
-                        val effectivePayload = mtu - 3
-                        Bridge.log(
-                                "LIVE:    Effective payload size: " + effectivePayload + " bytes"
-                        )
+                override fun handleMtuChanged(gatt: BluetoothGatt, mtu: Int, status: Int) {
+                    handler.post {
+                        if (!isActiveGattCallback(gatt)) {
+                            return@post
+                        }
+                        if (status == BluetoothGatt.GATT_SUCCESS) {
+                            Bridge.log(
+                                    "LIVE: 🔵 MTU negotiation successful - changed to " +
+                                            mtu +
+                                            " bytes"
+                            )
+                            val effectivePayload = mtu - 3
+                            Bridge.log(
+                                    "LIVE:    Effective payload size: " +
+                                            effectivePayload +
+                                            " bytes"
+                            )
 
-                        // Store the new MTU value
-                        currentMtu = mtu
+                            currentMtu = mtu
 
-                        // If the negotiated MTU is sufficient for LC3 audio packets (typically
-                        // 40-60 bytes)
-                        if (mtu >= 64) {
-                            Bridge.log("LIVE: ✅ MTU size is sufficient for LC3 audio data packets")
+                            if (mtu >= 64) {
+                                Bridge.log(
+                                        "LIVE: ✅ MTU size is sufficient for LC3 audio data packets"
+                                )
+                            } else {
+                                Log.w(
+                                        TAG,
+                                        "⚠️ MTU size may be too small for LC3 audio data packets"
+                                )
+                                Bridge.log(
+                                        "LIVE: 📊 Effective MTU payload: " +
+                                                effectivePayload +
+                                                " bytes"
+                                )
+                            }
                         } else {
-                            Log.w(TAG, "⚠️ MTU size may be too small for LC3 audio data packets")
-                            Bridge.log(
-                                    "LIVE: 📊 Effective MTU payload: " + effectivePayload + " bytes"
+                            Log.e(TAG, "❌ MTU change failed with status: " + status)
+                            Log.w(
+                                    TAG,
+                                    "   Will continue with default MTU (23 bytes, 20 byte payload)"
                             )
                         }
-                    } else {
-                        Log.e(TAG, "❌ MTU change failed with status: " + status)
-                        Log.w(TAG, "   Will continue with default MTU (23 bytes, 20 byte payload)")
-                    }
 
-                    // Now that MTU operation is complete, enable notifications
-                    // (descriptor writes are GATT operations and can't overlap with MTU request)
-                    if (!notificationsEnabled) {
-                        notificationsEnabled = true
-                        enableNotifications()
+                        mtuSetupToken?.let { completeMtuSetup(gatt, it, "callback") }
                     }
                 }
             }
 
+    private fun startMtuWatchdog(gatt: BluetoothGatt, token: Long) {
+        mtuWatchdogRunnable?.let { gattLifecycleHandler.removeCallbacks(it) }
+        val watchdog =
+                Runnable {
+                    handler.post {
+                        if (!isActiveGattCallback(gatt)) {
+                            return@post
+                        }
+                        Bridge.log(
+                                "LIVE: ⚠️ MTU callback timed out after ${MTU_CALLBACK_TIMEOUT_MS}ms; continuing with notification setup"
+                        )
+                        completeMtuSetup(gatt, token, "watchdog")
+                    }
+                }
+        mtuWatchdogRunnable = watchdog
+        gattLifecycleHandler.postDelayed(watchdog, MTU_CALLBACK_TIMEOUT_MS)
+    }
+
+    private fun completeMtuSetup(gatt: BluetoothGatt, token: Long, reason: String) {
+        if (!mtuSetupGate.complete(token)) {
+            return
+        }
+        mtuWatchdogRunnable?.let { gattLifecycleHandler.removeCallbacks(it) }
+        mtuWatchdogRunnable = null
+        mtuSetupToken = null
+        enableNotificationsAfterMtu(gatt, reason)
+    }
+
+    private fun enableNotificationsAfterMtu(gatt: BluetoothGatt, reason: String) {
+        if (!isActiveGattCallback(gatt) || notificationsEnabled) {
+            return
+        }
+        notificationsEnabled = true
+        Bridge.log("LIVE: 🔔 Continuing GATT setup after MTU ($reason)")
+        enableNotifications()
+    }
+
     /**
      * Write the next queued descriptor, or mark the queue as idle. Must be called after each
      * onDescriptorWrite callback to serialize BLE GATT operations. On older Android devices,
@@ -2660,6 +2891,12 @@ class MentraLive : SGCManager() {
      * subsequent writes to silently fail.
      */
     private fun writeNextDescriptor() {
+        val gatt = bluetoothGatt ?: return
+        if (!isActiveGattCallback(gatt)) return
+        val epoch = gattEpoch
+        val continueSetup = Runnable {
+            if (epoch == gattEpoch && isActiveGattCallback(gatt)) writeNextDescriptor()
+        }
         val next = pendingDescriptorWrites.poll()
         if (next == null) {
             isDescriptorWriteInProgress = false
@@ -2703,12 +2940,12 @@ class MentraLive : SGCManager() {
                                 uuid +
                                 ", continuing queue"
                 )
-                handler.postDelayed(this::writeNextDescriptor, 50L)
+                handler.postDelayed(continueSetup, 50L)
             }
         } catch (e: Exception) {
             val threadId = Thread.currentThread().id
             Log.e(TAG, "Thread-" + threadId + ": ⚠️ Error writing descriptor: " + e.message)
-            handler.postDelayed(this::writeNextDescriptor, 50L)
+            handler.postDelayed(continueSetup, 50L)
         }
     }
 
@@ -3079,8 +3316,12 @@ class MentraLive : SGCManager() {
         return messageId
     }
 
-    /** Send a JSON object to the glasses with message ID and ACK tracking */
+    /** Send a JSON object to the glasses with message ID and ACK tracking. */
     private fun sendJson(json: JSONObject?, wakeup: Boolean) {
+        sendJson(json, wakeup, true)
+    }
+
+    private fun sendJson(json: JSONObject?, wakeup: Boolean, bridgeLogging: Boolean): Boolean {
         if (json != null) {
             try {
                 val sessionGeneration = bleSessionGeneration.get()
@@ -3099,7 +3340,7 @@ class MentraLive : SGCManager() {
                             json,
                             jsonStr.length
                     )
-                    sendDataToGlasses(jsonStr, wakeup, sessionGeneration)
+                    return sendDataToGlasses(jsonStr, wakeup, sessionGeneration, bridgeLogging)
                 } else {
                     // Add esoteric message ID to the JSON
                     val messageId = generateEsotericMessageId()
@@ -3124,12 +3365,13 @@ class MentraLive : SGCManager() {
                             // Calculate dynamic timeout for chunked message
                             val estimatedChunks = Math.ceil(jsonStr.length / 300.0).toInt()
                             ackTimeout = ACK_TIMEOUT_MS + (estimatedChunks * 50L) + 2000L
-                            Bridge.log(
+                            transportLog(
                                     "LIVE: Message will be chunked into ~" +
                                             estimatedChunks +
                                             " chunks, using dynamic timeout: " +
                                             ackTimeout +
-                                            "ms"
+                                            "ms",
+                                    bridgeLogging,
                             )
                         }
                     } catch (e: JSONException) {
@@ -3141,7 +3383,13 @@ class MentraLive : SGCManager() {
                     }
 
                     // Track the message for ACK with appropriate timeout
-                    trackMessageForAck(messageId, jsonStr, ackTimeout, sessionGeneration)
+                    trackMessageForAck(
+                            messageId,
+                            jsonStr,
+                            ackTimeout,
+                            sessionGeneration,
+                            bridgeLogging,
+                    )
 
                     // Send the data
                     if ("take_photo" == json.optString("type", "")) {
@@ -3160,7 +3408,9 @@ class MentraLive : SGCManager() {
                             json,
                             jsonStr.length
                     )
-                    sendDataToGlasses(jsonStr, wakeup, sessionGeneration)
+                    val accepted = sendDataToGlasses(jsonStr, wakeup, sessionGeneration, bridgeLogging)
+                    if (!accepted) pendingMessages.remove(messageId)
+                    return accepted
                 }
             } catch (e: JSONException) {
                 Log.e(TAG, "Error adding message ID to JSON", e)
@@ -3168,6 +3418,7 @@ class MentraLive : SGCManager() {
         } else {
             Bridge.log("LIVE: Cannot send JSON to ASG, JSON is null")
         }
+        return false
     }
 
     private fun sendJson(json: JSONObject?) {
@@ -3185,20 +3436,25 @@ class MentraLive : SGCManager() {
             messageId: Long,
             messageData: String,
             timeoutMs: Long,
-            sessionGeneration: Long
+            sessionGeneration: Long,
+            bridgeLogging: Boolean = true,
     ) {
         if (!isConnected || sessionGeneration != bleSessionGeneration.get()) {
-            Bridge.log("LIVE: Not connected, skipping ACK tracking for message " + messageId)
+            transportLog(
+                    "LIVE: Not connected, skipping ACK tracking for message " + messageId,
+                    bridgeLogging,
+            )
             return
         }
 
         // Skip ACK tracking for glasses with build number < 5 (older firmware)
         if (buildNumberInt < 5) {
-            Bridge.log(
+            transportLog(
                     "LIVE: Glasses build number (" +
                             buildNumberInt +
                             ") < 5, skipping ACK tracking for message " +
-                            messageId
+                            messageId,
+                    bridgeLogging,
             )
             return
         }
@@ -3220,11 +3476,20 @@ class MentraLive : SGCManager() {
         // Schedule ACK timeout with custom timeout
         handler.postDelayed({ checkMessageAck(messageId, sessionGeneration) }, timeoutMs)
 
-        Bridge.log(
-                "LIVE: 📋 Tracking message " + messageId + " for ACK (timeout: " + timeoutMs + "ms)"
+        transportLog(
+                "LIVE: 📋 Tracking message " + messageId + " for ACK (timeout: " + timeoutMs + "ms)",
+                bridgeLogging,
         )
     }
 
+    private fun transportLog(message: String, bridgeLogging: Boolean) {
+        if (bridgeLogging) {
+            Bridge.log(message)
+        } else {
+            Log.d(TAG, message)
+        }
+    }
+
     /**
      * Ends the current BLE send session before clearing its ACK state. Scheduled callbacks capture
      * the old generation, and queued retries retain it, so a retry racing this clear cannot become
@@ -3718,6 +3983,9 @@ class MentraLive : SGCManager() {
             }
         }
 
+        val incomingMessageId = if (json.has("mId")) json.optLong("mId") else null
+        incomingGlassesMessageAckId(type, incomingMessageId)?.let(::sendAckToGlasses)
+
         // Check if this is a K900 command format (has "C" field instead of "type")
         if (json.has("C")) {
             processK900JsonMessage(json)
@@ -3872,6 +4140,44 @@ class MentraLive : SGCManager() {
                         wifiError.takeIf { it.isNotEmpty() }
                 )
             }
+            "wifi_forget_result" -> {
+                if (!wifiResponseEnvelopeIsValid(json.keys().asSequence().associateWith { json.get(it) }, allowLegacy = true)) return
+                Bridge.sendWifiForgetResult(
+                        requestId = json.optString("requestId", ""),
+                        sid = json.optString("sid", ""),
+                        ssid = json.optString("ssid", ""),
+                        protocolVersion = json.optInt("protocol_version", 0),
+                        outcome = json.optString("outcome", ""),
+                        legacyDispatched =
+                                if (json.has("dispatched")) json.optBoolean("dispatched") else null,
+                        connected =
+                                if (json.has("connected")) json.optBoolean("connected") else null,
+                        currentSsid = json.optString("current_ssid", ""),
+                        localIp = json.optString("local_ip", ""),
+                        error = json.optString("error", "").ifEmpty { null },
+                )
+            }
+            "saved_wifi_networks" -> {
+                if (!wifiResponseEnvelopeIsValid(json.keys().asSequence().associateWith { json.get(it) }, allowLegacy = false)) return
+                val networks = mutableListOf<String>()
+                val networkArray = json.optJSONArray("networks") ?: return
+                if (networkArray != null) {
+                    for (i in 0 until networkArray.length()) {
+                        val network = networkArray.opt(i) as? String ?: return
+                        network.takeIf { it.trim().isNotEmpty() }?.let {
+                            networks.add(it)
+                        }
+                    }
+                }
+                Bridge.sendSavedWifiNetworks(
+                        requestId = json.optString("requestId", ""),
+                        sid = json.optString("sid", ""),
+                        protocolVersion = json.optInt("protocol_version", 0),
+                        outcome = json.optString("outcome", ""),
+                        networks = networks,
+                        error = json.optString("error", "").ifEmpty { null },
+                )
+            }
             "hotspot_status_update" -> {
                 // Process hotspot status information (same pattern as "wifi_status")
                 val hotspotEnabled = json.optBoolean("hotspot_enabled", false)
@@ -4253,7 +4559,11 @@ class MentraLive : SGCManager() {
                 // Record the session id BEFORE marking ready: an unsolicited glasses_ready
                 // already runs this full remote-reset flow, so recording (not re-triggering)
                 // is correct here; version_info detection covers the restart case.
-                json.optString("sid", "").takeIf { it.isNotEmpty() }?.let { glassesSessionId = it }
+                glassesSessionId = json.optString("sid", "").takeIf { it.isNotEmpty() }
+                Bridge.sendTypedMessage(
+                        "wifi_protocol_session_ready",
+                        mapOf("sid" to (glassesSessionId ?: "")),
+                )
                 readinessCompletedThisBleSession = true
 
                 // Set the ready flag to stop any future readiness checks
@@ -4447,6 +4757,7 @@ class MentraLive : SGCManager() {
                 }
 
                 val versionInfoLegacy = HashMap<String, Any>()
+                versionInfoLegacy["version_info_type"] = "version_info"
                 versionInfoLegacy["appVersion"] = appVersionLegacy
                 versionInfoLegacy["buildNumber"] = buildNumberLegacy
                 versionInfoLegacy["deviceModel"] = deviceModelLegacy
@@ -4630,6 +4941,7 @@ class MentraLive : SGCManager() {
 
                     // Extract all fields from JSON (except "type")
                     val fields = HashMap<String, Any>()
+                    fields["version_info_type"] = type
                     val keys = json.keys()
                     while (keys.hasNext()) {
                         val key = keys.next()
@@ -4743,7 +5055,7 @@ class MentraLive : SGCManager() {
                     handleGlassesSessionId(json)
 
                     Bridge.log("LIVE: Processed version_info fields and sent to RN")
-                    Bridge.sendVersionInfo(fields)
+                    Bridge.sendVersionInfo(fields, type)
                 } else {
                     Log.d(TAG, "📦 Unknown message type: " + type)
                 }
@@ -5664,9 +5976,14 @@ class MentraLive : SGCManager() {
      * build number, firmware version, etc.
      */
     override fun requestVersionInfo() {
+        requestVersionInfo(null)
+    }
+
+    fun requestVersionInfo(requestId: String?) {
         try {
             val json = JSONObject()
             json.put("type", "request_version")
+            requestId?.let { json.put("request_id", it) }
             sendJson(json, false)
             Bridge.log("LIVE: 📱 Requesting version info from glasses")
         } catch (e: JSONException) {
@@ -5938,6 +6255,8 @@ class MentraLive : SGCManager() {
     // SmartGlassesCommunicator interface implementation
 
     override fun findCompatibleDevices() {
+        if (postGattLifecycle { findCompatibleDevices() }) return
+        connectionRequestEpoch++
         Bridge.log("LIVE: Finding compatible Mentra Live glasses")
 
         // A fresh user scan owns the radio. Invalidate delayed reconnect callbacks
@@ -6002,6 +6321,7 @@ class MentraLive : SGCManager() {
     }
 
     override fun connectById(id: String) {
+        if (postGattLifecycle { connectById(id) }) return
         if (pairingYieldActive) {
             Bridge.log("LIVE: connectById blocked — pairing yield active")
             return
@@ -6031,6 +6351,7 @@ class MentraLive : SGCManager() {
     }
 
     override fun forget() {
+        if (postGattLifecycle { forget() }) return
         Bridge.log("LIVE: Forgetting Mentra Live glasses")
 
         // Clear saved device name so a leftover name can't bypass the pairing-mode
@@ -6075,6 +6396,7 @@ class MentraLive : SGCManager() {
     }
 
     override fun disconnect() {
+        if (postGattLifecycle { disconnect() }) return
         if (unpairFlushPending) {
             Bridge.log("LIVE: disconnect deferred — waiting for unpair write")
             return
@@ -6116,6 +6438,7 @@ class MentraLive : SGCManager() {
     }
 
     fun connectToSmartGlasses() {
+        if (postGattLifecycle { connectToSmartGlasses() }) return
         if (pairingYieldActive) {
             Bridge.log("LIVE: connectToSmartGlasses blocked — pairing yield active")
             return
@@ -6741,7 +7064,16 @@ class MentraLive : SGCManager() {
                                                 "ctkd_bond_none",
                                                 "prev=$previousBondState queueSize=${sendQueue.size}"
                                         )
-                                        isBtClassicConnected = false
+                                        if (previousBondState == BluetoothDevice.BOND_BONDED) {
+                                            // A real unpair ends this Classic session. Invalidate
+                                            // the target so delayed profile broadcasts cannot
+                                            // make pairing look connected again.
+                                            classicAudioConnectionTracker.invalidate(device.address)
+                                        } else {
+                                            // A failed/cancelled bond may be retried below, so keep
+                                            // the target while clearing any partial profile state.
+                                            classicAudioConnectionTracker.clear(device.address)
+                                        }
                                         audioConnected = false
                                         if (previousBondState == BluetoothDevice.BOND_BONDING) {
                                             // User cancelled or bonding failed - retry up to
@@ -6841,6 +7173,124 @@ class MentraLive : SGCManager() {
         }
     }
 
+    /** Observe the two Android Classic audio profiles that Mentra Live exposes. */
+    private fun initializeClassicAudioReceiver() {
+        classicAudioReceiver =
+                object : BroadcastReceiver() {
+                    override fun onReceive(context: Context?, intent: Intent?) {
+                        if (intent?.action != BluetoothA2dp.ACTION_CONNECTION_STATE_CHANGED &&
+                                intent?.action != BluetoothHeadset.ACTION_CONNECTION_STATE_CHANGED) return
+                        val device = intent.bluetoothDeviceExtra() ?: return
+                        refreshClassicAudioConnectionState(device)
+                    }
+                }
+    }
+
+    private fun registerClassicAudioReceiver() {
+        val ctx = context ?: return
+        val receiver = classicAudioReceiver ?: return
+        if (isClassicAudioReceiverRegistered) return
+
+        try {
+            val filter =
+                    IntentFilter().apply {
+                        addAction(BluetoothA2dp.ACTION_CONNECTION_STATE_CHANGED)
+                        addAction(BluetoothHeadset.ACTION_CONNECTION_STATE_CHANGED)
+                    }
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+                ctx.registerReceiver(receiver, filter, Context.RECEIVER_EXPORTED)
+            } else {
+                ctx.registerReceiver(receiver, filter)
+            }
+            isClassicAudioReceiverRegistered = true
+            Bridge.log("LIVE: Classic: A2DP/HFP status receiver registered")
+        } catch (e: Exception) {
+            Bridge.log("LIVE: Classic: failed to register status receiver: " + e.message)
+        }
+    }
+
+    private fun unregisterClassicAudioReceiver() {
+        if (!isClassicAudioReceiverRegistered || classicAudioReceiver == null) return
+
+        try {
+            context?.unregisterReceiver(classicAudioReceiver)
+        } catch (e: Exception) {
+            Bridge.log("LIVE: Classic: failed to unregister status receiver: " + e.message)
+        } finally {
+            isClassicAudioReceiverRegistered = false
+        }
+    }
+
+    /**
+     * Broadcast payloads are hints, never current truth (even when the MAC matches). Query both
+     * profiles and publish one combined snapshot. A newer refresh or teardown invalidates all
+     * outstanding results, including a previous connection to the same physical glasses.
+     */
+    private fun refreshClassicAudioConnectionState(device: BluetoothDevice) {
+        if (Looper.myLooper() != handler.looper) {
+            handler.post { refreshClassicAudioConnectionState(device) }
+            return
+        }
+        if (isKilled) return
+        val adapter = bluetoothAdapter ?: return
+        val ctx = context ?: return
+        val ticket = classicAudioConnectionTracker.beginSnapshot(device.address) ?: return
+        val states = mutableMapOf<ClassicAudioProfile, Boolean>()
+        for ((profileId, audioProfile) in listOf(
+            BluetoothProfile.A2DP to ClassicAudioProfile.A2DP,
+            BluetoothProfile.HEADSET to ClassicAudioProfile.HEADSET,
+        )) {
+            try {
+                val requested = adapter.getProfileProxy(ctx, object : BluetoothProfile.ServiceListener {
+                    override fun onServiceConnected(profile: Int, proxy: BluetoothProfile) {
+                        // Close before dispatch: destroy() may discard queued handler work.
+                        val connectedState = try {
+                            if (profile != profileId) null
+                            else proxy.getConnectionState(device) == BluetoothProfile.STATE_CONNECTED
+                        } catch (e: Exception) {
+                            Bridge.log("LIVE: Classic: snapshot unavailable: " + e.message)
+                            null
+                        } finally {
+                            try { adapter.closeProfileProxy(profileId, proxy) }
+                            catch (_: Exception) {}
+                        }
+                        if (connectedState == null) return
+                        handler.post {
+                                if (isKilled || profile != profileId) return@post
+                                states[audioProfile] = connectedState
+                                val connected = readyClassicAudioSnapshot(states) ?: return@post
+                                classicAudioConnectionTracker.applySnapshot(
+                                        ticket, device.address, connected) {
+                                    if (ClassicAudioProfile.A2DP in connected) {
+                                        markAudioConnected(device)
+                                    } else if (states[ClassicAudioProfile.A2DP] == false && audioConnected) {
+                                        audioConnected = false
+                                        Bridge.sendAudioDisconnected()
+                                    }
+                                }
+                        }
+                    }
+                    override fun onServiceDisconnected(profile: Int) {}
+                }, profileId)
+                if (!requested) {
+                    // Unknown is not disconnected. A successful other-profile read can still
+                    // publish connected without waiting for this unavailable service.
+                    Bridge.log("LIVE: Classic: profile service unavailable: $profileId")
+                }
+            } catch (e: Exception) {
+                Bridge.log("LIVE: Classic: profile query unavailable: " + e.message)
+            }
+        }
+    }
+
+    @Suppress("DEPRECATION")
+    private fun Intent.bluetoothDeviceExtra(): BluetoothDevice? =
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+                getParcelableExtra(BluetoothDevice.EXTRA_DEVICE, BluetoothDevice::class.java)
+            } else {
+                getParcelableExtra(BluetoothDevice.EXTRA_DEVICE)
+            }
+
     /**
      * Start CTKD Classic bonding / A2DP only after BLE notifications are ready. Calling this from
      * onConnectionStateChange(CONNECTED) races dual-mode stacks and frequently yields GATT 19
@@ -6917,7 +7367,7 @@ class MentraLive : SGCManager() {
             val method = device.javaClass.getMethod("removeBond")
             val result = method.invoke(device) as Boolean
             Bridge.log("LIVE: CTKD: Bond removal initiated, result: " + result)
-            isBtClassicConnected = false
+            classicAudioConnectionTracker.invalidate(device.address)
             return result
         } catch (e: Exception) {
             Bridge.log("LIVE: CTKD: Error removing bond: " + e.message)
@@ -6927,7 +7377,7 @@ class MentraLive : SGCManager() {
 
     /** Check if BT Classic is connected via CTKD */
     fun isBtClassicConnected(): Boolean {
-        return isBtClassicConnected
+        return classicAudioConnectionTracker.connected
     }
 
     /** A2DP profile service listener for connecting to already-bonded devices */
@@ -6986,11 +7436,11 @@ class MentraLive : SGCManager() {
         try {
             val state = a2dpProfile!!.getConnectionState(device)
             Bridge.log("LIVE: A2DP: Current connection state: " + state)
+            refreshClassicAudioConnectionState(device)
 
             if (state == BluetoothProfile.STATE_CONNECTED) {
                 Bridge.log("LIVE: A2DP: Already connected to " + device.name)
                 a2dpConnectAttempts = 0
-                markAudioConnected(device.name)
             } else if (state == BluetoothProfile.STATE_DISCONNECTED) {
                 Bridge.log("LIVE: A2DP: Connecting to " + device.name)
                 // Use reflection to call connect() as it's a hidden API
@@ -7043,16 +7493,18 @@ class MentraLive : SGCManager() {
     }
 
     /** Helper to mark audio as connected and notify */
-    private fun markAudioConnected(deviceName: String?) {
+    private fun markAudioConnected(device: BluetoothDevice) {
         if (isKilled) {
             Bridge.log(
                     "LIVE: A2DP: Ignoring markAudioConnected — SGC destroyed (would confuse DeviceManager)"
             )
             return
         }
-        isBtClassicConnected = true
+        val wasAudioConnected = audioConnected
         audioConnected = true
-        Bridge.sendAudioConnected(deviceName!!)
+        if (!wasAudioConnected) {
+            Bridge.sendAudioConnected(safeDeviceName(device))
+        }
         if (glassesReadyReceived) {
             Bridge.log(
                     "LIVE: A2DP: Both audio and glasses_ready confirmed - marking as fully connected"
@@ -7135,10 +7587,10 @@ class MentraLive : SGCManager() {
                         device.address +
                         ")"
         )
-        val isActiveDevice =
-                connectedDevice?.address?.equals(device.address, ignoreCase = true) == true
-        if (isActiveDevice) {
-            isBtClassicConnected = false
+        // The BLE device reference may already be cleared after a GATT drop. The tracker owns the
+        // authoritative target address, so let it decide whether this teardown belongs to the
+        // active Classic session instead of consulting connectedDevice.
+        if (classicAudioConnectionTracker.invalidate(device.address)) {
             audioConnected = false
         }
 
@@ -7247,6 +7699,8 @@ class MentraLive : SGCManager() {
     }
 
     fun destroy() {
+        if (postGattLifecycle { destroy() }) return
+        connectionRequestEpoch++
         Bridge.log("LIVE: Destroying MentraLiveSGC")
 
         // Mark as killed to prevent reconnection attempts
@@ -7268,12 +7722,15 @@ class MentraLive : SGCManager() {
 
         // CTKD Implementation: Unregister bonding receiver
         unregisterBondingReceiver()
+        unregisterClassicAudioReceiver()
 
         // Tear down Classic (A2DP/HFP) before GATT close. Closing only the proxy left the
         // phone's system Bluetooth UI showing Mentra Live still connected.
         val classicDevice = connectedDevice
         disconnectClassicProfiles(classicDevice)
         closeA2dpProxy()
+        classicAudioConnectionTracker.reset()
+        DeviceStore.apply("glasses", "bluetoothClassicConnected", false)
 
         // Stop readiness check loop
         stopReadinessCheckLoop()
@@ -8628,9 +9085,10 @@ class MentraLive : SGCManager() {
             wireBytes: Int,
             packetCount: Int,
             protocolVersion: Int,
-            direction: String
+            direction: String,
+            bridgeLogging: Boolean = true,
     ) {
-        Bridge.log(
+        transportLog(
                 "BLE_TRACE direction=" +
                         direction +
                         " proto=v" +
@@ -8640,7 +9098,8 @@ class MentraLive : SGCManager() {
                         " wire=" +
                         wireBytes +
                         " packets=" +
-                        packetCount
+                        packetCount,
+                bridgeLogging,
         )
     }
 
@@ -8658,15 +9117,19 @@ class MentraLive : SGCManager() {
     private fun sendDataToGlasses(
             data: String?,
             wakeup: Boolean,
-            sessionGeneration: Long
-    ) {
+            sessionGeneration: Long,
+            bridgeLogging: Boolean = true,
+    ): Boolean {
         if (data == null || data.isEmpty()) {
             Log.e(TAG, "Cannot send empty data to glasses")
-            return
+            return false
         }
         if (sessionGeneration != bleSessionGeneration.get()) {
-            Bridge.log("LIVE: Dropping send request from stale BLE session $sessionGeneration")
-            return
+            transportLog(
+                    "LIVE: Dropping send request from stale BLE session $sessionGeneration",
+                    bridgeLogging,
+            )
+            return false
         }
 
         val wireData =
@@ -8694,14 +9157,14 @@ class MentraLive : SGCManager() {
             }
 
             if (useBinaryWireProtocol && buildNumberInt >= 5) {
-                sendDataToGlassesBinary(
+                return sendDataToGlassesBinary(
                         wireData,
                         wakeup,
                         commandTraceInfo,
                         isPhotoRequest,
-                        sessionGeneration
+                        sessionGeneration,
+                        bridgeLogging,
                 )
-                return
             }
 
             // First check if the message needs chunking
@@ -8715,7 +9178,7 @@ class MentraLive : SGCManager() {
 
             // Check if chunking is needed
             if (MessageChunker.needsChunking(testWrappedJson)) {
-                Bridge.log("LIVE: Message exceeds threshold, chunking required")
+                transportLog("LIVE: Message exceeds threshold, chunking required", bridgeLogging)
                 if (isPhotoRequest) {
                     Bridge.log(
                             "LIVE: PHOTO PIPELINE BLE handoff — chunking enabled for request payload"
@@ -8733,7 +9196,8 @@ class MentraLive : SGCManager() {
 
                 // Create chunks
                 val chunks = MessageChunker.createChunks(wireData, messageId, wakeup)
-                Bridge.log("LIVE: Sending " + chunks.size + " chunks")
+                if (chunks.isEmpty()) return false
+                transportLog("LIVE: Sending " + chunks.size + " chunks", bridgeLogging)
                 if (isPhotoRequest) {
                     Bridge.log(
                             "LIVE: PHOTO PIPELINE BLE handoff — created " +
@@ -8791,13 +9255,13 @@ class MentraLive : SGCManager() {
                     }
                 }
 
-                Bridge.log("LIVE: All chunks queued for transmission")
+                transportLog("LIVE: All chunks queued for transmission", bridgeLogging)
                 if (isPhotoRequest) {
                     Bridge.log("LIVE: PHOTO PIPELINE BLE handoff — all photo chunks queued")
                 }
             } else {
                 // Normal single message transmission
-                Bridge.log("LIVE: Sending data to glasses: " + wireData)
+                transportLog("LIVE: Sending data to glasses: " + wireData, bridgeLogging)
 
                 // Pack the data using the centralized utility with the negotiated endianness
                 val packedData =
@@ -8831,7 +9295,9 @@ class MentraLive : SGCManager() {
             }
         } catch (e: Exception) {
             Log.e(TAG, "Error creating data JSON", e)
+            return false
         }
+        return sessionGeneration == bleSessionGeneration.get()
     }
 
     private fun sendDataToGlassesBinary(
@@ -8839,8 +9305,9 @@ class MentraLive : SGCManager() {
             wakeup: Boolean,
             commandTraceInfo: OutgoingBleCommandTraceInfo,
             isPhotoRequest: Boolean,
-            sessionGeneration: Long
-    ) {
+            sessionGeneration: Long,
+            bridgeLogging: Boolean,
+    ): Boolean {
         val payloadBytes = data.toByteArray(StandardCharsets.UTF_8)
         var messageId = 0
         var ackRequested = false
@@ -8859,6 +9326,7 @@ class MentraLive : SGCManager() {
                         wakeup,
                         ackRequested
                 )
+        if (fragments.isEmpty()) return false
         var totalWireBytes = 0
         for (i in fragments.indices) {
             val fragment = fragments[i]
@@ -8907,7 +9375,8 @@ class MentraLive : SGCManager() {
                 totalWireBytes,
                 fragments.size,
                 BleWireProtocol.PROTOCOL_V2,
-                "phone_to_glasses"
+                "phone_to_glasses",
+                bridgeLogging,
         )
 
         if (isPhotoRequest) {
@@ -8918,6 +9387,7 @@ class MentraLive : SGCManager() {
                             totalWireBytes
             )
         }
+        return sessionGeneration == bleSessionGeneration.get()
     }
 
     private fun parseOutgoingBleCommandTraceInfo(payload: String): OutgoingBleCommandTraceInfo {
@@ -9199,16 +9669,45 @@ class MentraLive : SGCManager() {
      * K900 SystemUI can properly clear the cached credentials
      */
     override fun forgetWifiNetwork(ssid: String) {
-        Bridge.log("LIVE: 📶 Sending WiFi forget command for SSID: " + ssid)
+        forgetWifiNetwork(ssid, null, null)
+    }
+
+    override fun forgetWifiNetwork(ssid: String, requestId: String?, sid: String?): Boolean {
+        if (!isConnected || bluetoothGatt == null || txCharacteristic == null || ssid.isBlank()) return false
+        if ((requestId == null) != (sid == null)) return false
+        if (requestId != null && (requestId.isBlank() || sid.isNullOrBlank())) return false
+        Log.d(TAG, "LIVE: 📶 Sending WiFi forget command for SSID: " + ssid)
 
         try {
             val wifiCommand = JSONObject()
             wifiCommand.put("type", "forget_wifi")
             wifiCommand.put("ssid", ssid)
-            sendJson(wifiCommand, true)
+            if (!requestId.isNullOrEmpty()) {
+                wifiCommand.put("requestId", requestId)
+            }
+            if (!sid.isNullOrEmpty()) {
+                wifiCommand.put("sid", sid)
+                wifiCommand.put("protocolVersion", 1)
+            }
+            // This dispatch runs under the WiFi lifecycle lock. Keep its transport logs
+            // native-only so a public log listener cannot re-enter reset before it is queued.
+            return sendJson(wifiCommand, true, bridgeLogging = false)
         } catch (e: JSONException) {
             Log.e(TAG, "Error creating WiFi forget JSON", e)
         }
+        return false
+    }
+
+    override fun requestSavedWifiNetworks(requestId: String, sid: String): Boolean {
+        if (!isConnected || bluetoothGatt == null || txCharacteristic == null || requestId.isBlank() || sid.isBlank()) return false
+        val command = JSONObject()
+        command.put("type", "request_saved_wifi_networks")
+        command.put("requestId", requestId)
+        command.put("protocolVersion", 1)
+        if (sid.isNotEmpty()) {
+            command.put("sid", sid)
+        }
+        return sendJson(command, true, bridgeLogging = false)
     }
 
     override fun sendHotspotState(enabled: Boolean) {
@@ -9315,6 +9814,13 @@ class MentraLive : SGCManager() {
         }
     }
 
+    private fun sendAckToGlasses(messageId: Long) {
+        val ack = JSONObject()
+        ack.put("type", "msg_ack")
+        ack.put("mId", messageId)
+        sendJsonWithoutAck(ack, false)
+    }
+
     private fun sendJsonWithoutAck(json: JSONObject?) {
         sendJsonWithoutAck(json, false)
     }