@mentra/bluetooth-sdk 3.2.0-dev.200 → 3.2.0-dev.206

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
@@ -600,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
@@ -1004,6 +1011,8 @@ class MentraLive : SGCManager() {
 
         // Initialize CTKD bonding receiver
         initializeBondingReceiver()
+        initializeClassicAudioReceiver()
+        registerClassicAudioReceiver()
 
         // Initialize the send queue processor
         processSendQueueRunnable = Runnable {
@@ -2272,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)
@@ -3305,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()
@@ -3325,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()
@@ -3350,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) {
@@ -3367,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", "")) {
@@ -3386,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)
@@ -3394,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?) {
@@ -3411,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
         }
@@ -3446,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
@@ -3944,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)
@@ -4044,6 +4086,14 @@ class MentraLive : SGCManager() {
                 val percent = json.optInt("percent", batteryLevel)
                 updateBatteryStatus(percent, isCharging)
             }
+            "stream_controller_probe" -> {
+                val values = mapOf("protocolVersion" to json.opt("protocolVersion"),
+                    "controllerId" to json.opt("controllerId"), "streamId" to json.opt("streamId"),
+                    "probeId" to json.opt("probeId"))
+                com.mentra.bluetoothsdk.streaming.StreamControllerProbe.response(values)?.let {
+                    sendJson(JSONObject(it))
+                }
+            }
             "pong" ->
                     // Process heartbeat pong response
                     Bridge.log("LIVE: Received pong response - connection healthy")
@@ -4098,6 +4148,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)
@@ -4479,8 +4567,16 @@ 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
+                Bridge.sendTypedMessage("stream_control_ready", mapOf(
+                    "sid" to json.optString("sid", ""),
+                    "streamControlVersion" to json.optInt("streamControlVersion", 0),
+                ))
 
                 // Set the ready flag to stop any future readiness checks
                 glassesReady = true
@@ -4673,6 +4769,7 @@ class MentraLive : SGCManager() {
                 }
 
                 val versionInfoLegacy = HashMap<String, Any>()
+                versionInfoLegacy["version_info_type"] = "version_info"
                 versionInfoLegacy["appVersion"] = appVersionLegacy
                 versionInfoLegacy["buildNumber"] = buildNumberLegacy
                 versionInfoLegacy["deviceModel"] = deviceModelLegacy
@@ -4856,6 +4953,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()
@@ -6716,6 +6814,8 @@ class MentraLive : SGCManager() {
             val json = JSONObject(message as Map<*, *>)
             // Remove timestamp as iOS does
             json.remove("timestamp")
+            json.put("controllerProbeVersion", 1)
+            json.put("controllerId", com.mentra.bluetoothsdk.streaming.StreamControllerProbe.controllerId)
             sendJson(json, true)
         } catch (e: Exception) {
             Log.e(TAG, "Error creating RTMP stream start JSON", e)
@@ -6978,7 +7078,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
@@ -7078,6 +7187,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
@@ -7154,7 +7381,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)
@@ -7164,7 +7391,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 */
@@ -7223,11 +7450,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
@@ -7280,16 +7507,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"
@@ -7372,10 +7601,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
         }
 
@@ -7507,12 +7736,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()
@@ -8867,9 +9099,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" +
@@ -8879,7 +9112,8 @@ class MentraLive : SGCManager() {
                         " wire=" +
                         wireBytes +
                         " packets=" +
-                        packetCount
+                        packetCount,
+                bridgeLogging,
         )
     }
 
@@ -8897,15 +9131,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 =
@@ -8933,14 +9171,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
@@ -8954,7 +9192,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"
@@ -8972,7 +9210,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 " +
@@ -9030,13 +9269,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 =
@@ -9070,7 +9309,9 @@ class MentraLive : SGCManager() {
             }
         } catch (e: Exception) {
             Log.e(TAG, "Error creating data JSON", e)
+            return false
         }
+        return sessionGeneration == bleSessionGeneration.get()
     }
 
     private fun sendDataToGlassesBinary(
@@ -9078,8 +9319,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
@@ -9098,6 +9340,7 @@ class MentraLive : SGCManager() {
                         wakeup,
                         ackRequested
                 )
+        if (fragments.isEmpty()) return false
         var totalWireBytes = 0
         for (i in fragments.indices) {
             val fragment = fragments[i]
@@ -9146,7 +9389,8 @@ class MentraLive : SGCManager() {
                 totalWireBytes,
                 fragments.size,
                 BleWireProtocol.PROTOCOL_V2,
-                "phone_to_glasses"
+                "phone_to_glasses",
+                bridgeLogging,
         )
 
         if (isPhotoRequest) {
@@ -9157,6 +9401,7 @@ class MentraLive : SGCManager() {
                             totalWireBytes
             )
         }
+        return sessionGeneration == bleSessionGeneration.get()
     }
 
     private fun parseOutgoingBleCommandTraceInfo(payload: String): OutgoingBleCommandTraceInfo {
@@ -9438,16 +9683,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) {
@@ -9554,6 +9828,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)
     }