@mentra/bluetooth-sdk 0.1.20 → 0.1.21-beta.1

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

@@ -34,6 +34,7 @@ import com.mentra.bluetoothsdk.Bridge
 import com.mentra.bluetoothsdk.DeviceManager
 import com.mentra.bluetoothsdk.PhotoRequest
 import com.mentra.bluetoothsdk.PhotoSize
+import com.mentra.bluetoothsdk.PhotoMode
 import com.mentra.bluetoothsdk.DeviceStore
 import com.mentra.bluetoothsdk.ObservableStore
 import com.mentra.bluetoothsdk.debug.BleTraceLogger
@@ -94,6 +95,7 @@ class MentraLive : SGCManager() {
         // LC3 frame size for Mentra Live
         private const val LC3_FRAME_SIZE = 40
         private const val VOICE_ACTIVITY_DETECTION_SWITCH_TYPE = 8
+        private const val LOUDNESS_GATE_SWITCH_TYPE = 10
         private const val BES2700_MTU_LIMIT = 509
 
         // L2CAP CoC fast path: new BES2700 firmware registers an LE L2CAP CoC server on this
@@ -146,6 +148,10 @@ class MentraLive : SGCManager() {
 
         // Heartbeat parameters
         private const val HEARTBEAT_INTERVAL_MS = 30000 // 30 seconds
+        // Grace period before an unanswered BLE wire v2 handshake is re-armed for retry,
+        // and the per-session cap on automatic retries (see sendWireHandshake).
+        private const val WIRE_HANDSHAKE_RETRY_GRACE_MS = 5000L
+        private const val WIRE_HANDSHAKE_MAX_ATTEMPTS = 3
         private const val BATTERY_REQUEST_EVERY_N_HEARTBEATS = 10 // Every 10 heartbeats (5 minutes)
         private const val RSSI_READ_INTERVAL_MS = 10000L // 10 seconds
 
@@ -213,12 +219,30 @@ class MentraLive : SGCManager() {
     private var peerWireProtocolVersion = 0
     private var useBinaryWireProtocol = false
     private var wireHandshakeQueued = false
+    private var wireHandshakeAttempts = 0
+    // Session generation in which the LAST outgoing v2 handshake was sent. A handshake
+    // reply only activates v2 when it answers a handshake from the CURRENT epoch - a
+    // stale handshake that survived in flight across an epoch reset must not flip the
+    // new session to v2 before it negotiated its own build and capabilities.
+    private var wireHandshakeSentGeneration = -1
+    // Bumped on every BLE session reset; scheduled handshake-retry callbacks capture it
+    // and no-op if the session changed, so a timer from a dead session can't poke a new one.
+    private var wireSessionGeneration = 0
     // Negotiated K900 STRING length endianness for the phone<->glasses BLE link. Defaults to
     // legacy big-endian; upgraded to little-endian only when the glasses advertise wire_caps.k900_le
     // (or a v2 binary handshake succeeds, which implies wire-v2 LE).
     private var peerK900Le = false
     private var peerWireCapsBinary = false
     private var peerFilePayloadV2 = false
+    // Last observed glasses process session id (`sid` in glasses_ready / version_info_1).
+    // The BES keeps the BLE link alive across asg_client restarts, so transport state
+    // cannot signal a restart - a CHANGED (or newly appearing) sid is the restart signal.
+    // Null = no sid observed this BLE session (legacy glasses, or none seen yet).
+    private var glassesSessionId: String? = null
+    // True once a glasses_ready completed on THIS physical BLE session; resets only with
+    // the physical connection (never on heartbeat readiness flaps), so a first-seen sid
+    // after an upgrade OTA is always detected as a restart.
+    private var readinessCompletedThisBleSession = false
     // Note: appVersion, buildNumber, deviceModel, androidVersion
     // are inherited from SGCManager parent class
 
@@ -313,6 +337,8 @@ class MentraLive : SGCManager() {
     // So we temporarily suspend the LC3 mic during phone audio playback
     private var micIntentEnabled = false // User/system WANTS mic enabled
     private var micSuspendedForAudio = false // Mic temporarily suspended due to phone audio
+    override val isMicSuspendedForAudio: Boolean
+        get() = micSuspendedForAudio
     private var phoneAudioMonitor: PhoneAudioMonitor? = null
     private var micOnCount = 0
     private var micOffCount = 0
@@ -780,18 +806,25 @@ class MentraLive : SGCManager() {
         val isEqual = state == connectionState
         if (isEqual) {
             if (state == ConnTypes.DISCONNECTED) {
-                incomingChunkReassembler.clear()
-                peerWireProtocolVersion = 0
-                useBinaryWireProtocol = false
-                wireHandshakeQueued = false
-                peerK900Le = false
-                peerWireCapsBinary = false
-                peerFilePayloadV2 = false
-                BleJsonCompact.resetSession()
+                resetWireNegotiationState()
+                // Queued writes are session-bound: transmitting them into the NEXT session
+                // (e.g. a stale handshake whose reply activates v2 before the new session
+                // negotiated) is the bug class this clear removes. Higher layers re-send
+                // what still matters via their own ACK/retry tracking.
+                sendQueue.clear()
             }
             return
         }
 
+        if (state == ConnTypes.DISCONNECTED) {
+            // A manufacturing serial is session-bound. Clear it on disconnect so a previous
+            // pair's serial can never be associated with the next connection. Connect must NOT
+            // clear it: DeviceManager.disconnect already wipes it before any new connection, and
+            // clearing on CONNECTED would wipe a still-valid serial mid-session when a same-link
+            // glasses_ready (e.g. ASG restart) re-publishes CONNECTED.
+            DeviceStore.apply("glasses", "serialNumber", "")
+        }
+
         // Actually update the connection state!
         DeviceStore.apply("glasses", "connectionState", state)
 
@@ -807,6 +840,10 @@ class MentraLive : SGCManager() {
             DeviceStore.apply("glasses", "appVersion", "")
             DeviceStore.apply("glasses", "besFirmwareVersion", "")
             DeviceStore.apply("glasses", "mtkFirmwareVersion", "")
+            // Modern ASG builds omit ota_version_url entirely (the phone owns manifest
+            // selection), and the chunked parser only writes present fields — clear it here so
+            // a URL reported by a previous build cannot leak into this session.
+            DeviceStore.apply("glasses", "otaVersionUrl", "")
             Bridge.log("LIVE: Cleared cached version_info fields for fresh session")
         }
 
@@ -815,14 +852,9 @@ class MentraLive : SGCManager() {
             DeviceStore.apply("glasses", "connected", false)
             DeviceStore.apply("glasses", "signalStrength", -1)
             DeviceStore.apply("glasses", "signalStrengthUpdatedAt", 0L)
-            incomingChunkReassembler.clear()
-            peerWireProtocolVersion = 0
-            useBinaryWireProtocol = false
-            wireHandshakeQueued = false
-            peerK900Le = false
-            peerWireCapsBinary = false
-            peerFilePayloadV2 = false
-            BleJsonCompact.resetSession()
+            resetWireNegotiationState()
+            sendQueue.clear() // see the disconnect reset above: stale writes die with the session
+
             // Drop OTA caches when fully disconnected — avoids leaking session/step state
             // from a previous pairing into the next one.
             resetOtaCache()
@@ -1552,6 +1584,8 @@ class MentraLive : SGCManager() {
 
                             connectedDevice = null
                             glassesReady = false // Reset ready state on disconnect
+                            glassesSessionId = null // Fresh BLE session starts with no sid known
+                            readinessCompletedThisBleSession = false
 
                             // Reset audio pairing flags
                             glassesReadyReceived = false
@@ -1616,6 +1650,8 @@ class MentraLive : SGCManager() {
                         isConnected = false
                         isConnecting = false
                         glassesReady = false
+                        glassesSessionId = null
+                        readinessCompletedThisBleSession = false
                         glassesReadyReceived = false
                         audioConnected = false
 
@@ -3136,7 +3172,12 @@ class MentraLive : SGCManager() {
                     DeviceStore.apply("glasses", "wifiError", "")
                 }
 
-                updateWifiStatus(wifiConnectedStatus, ssid, localIp)
+                updateWifiStatus(
+                        wifiConnectedStatus,
+                        ssid,
+                        localIp,
+                        wifiError.takeIf { it.isNotEmpty() }
+                )
             }
             "hotspot_status_update" -> {
                 // Process hotspot status information (same pattern as "wifi_status")
@@ -3239,7 +3280,8 @@ class MentraLive : SGCManager() {
 
                 val scanComplete =
                         json.optBoolean("scan_complete", json.optBoolean("scanComplete", false))
-                Bridge.updateWifiScanResults(networks, scanComplete)
+                val scanId = json.optString("scanId", "").ifEmpty { null }
+                Bridge.updateWifiScanResults(networks, scanComplete, scanId)
             }
             "token_status" -> {
                 // Process coreToken acknowledgment
@@ -3492,8 +3534,19 @@ class MentraLive : SGCManager() {
                 // Glasses SOC has booted and is ready for communication
                 Bridge.log("LIVE: 🎉 Received glasses_ready message - SOC is booted and ready!")
 
-                // Negotiate wire capabilities advertised in the glasses_ready handshake.
+                // glasses_ready is a REMOTE wire-session reset: the glasses ran
+                // onTransportReset() before sending it, so their side is back on legacy
+                // framing regardless of what this side negotiated earlier. Start a fresh
+                // wire epoch (clears v2-active state that would otherwise gate the
+                // handshake off), then negotiate from the caps this message advertises.
+                resetWireNegotiationState()
                 parsePeerWireCaps(json)
+                maybeSendWireHandshake()
+                // 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 }
+                readinessCompletedThisBleSession = true
 
                 // Set the ready flag to stop any future readiness checks
                 glassesReady = true
@@ -3653,7 +3706,7 @@ class MentraLive : SGCManager() {
 
             "version_info" -> {
                 // Process version information from ASG client (legacy single-message format)
-                Bridge.log("LIVE: Received version info from ASG client: " + json.toString())
+                Bridge.log("LIVE: Received version info from ASG client")
 
                 // Extract version information
                 val appVersionLegacy = json.optString("app_version", "")
@@ -3663,6 +3716,7 @@ class MentraLive : SGCManager() {
                 val otaVersionUrlLegacy: String? = json.optString("ota_version_url", null)
                 val firmwareVersionLegacy = json.optString("firmware_version", "")
                 val btMacAddressLegacy = json.optString("bt_mac_address", "")
+                val serialNumberLegacy = json.optString("serial_number", "")
 
                 // Update parent SGCManager fields
                 DeviceStore.apply("glasses", "appVersion", appVersionLegacy)
@@ -3676,6 +3730,9 @@ class MentraLive : SGCManager() {
                 )
                 DeviceStore.apply("glasses", "firmwareVersion", firmwareVersionLegacy)
                 DeviceStore.apply("glasses", "bluetoothMacAddress", btMacAddressLegacy)
+                if (serialNumberLegacy.isNotBlank()) {
+                    DeviceStore.apply("glasses", "serialNumber", serialNumberLegacy)
+                }
 
                 val versionInfoLegacy = HashMap<String, Any>()
                 versionInfoLegacy["appVersion"] = appVersionLegacy
@@ -3857,7 +3914,7 @@ class MentraLive : SGCManager() {
             else -> {
                 // Flexible version_info parsing - handle any version_info* message
                 if (type.startsWith("version_info")) {
-                    Bridge.log("LIVE: Received " + type + ": " + json.toString())
+                    Bridge.log("LIVE: Received " + type)
 
                     // Extract all fields from JSON (except "type")
                     val fields = HashMap<String, Any>()
@@ -3884,8 +3941,6 @@ class MentraLive : SGCManager() {
                             val buildNumInt = Integer.parseInt(buildNum)
                             buildNumberInt = buildNumInt
                             Bridge.log("LIVE: Parsed build number as integer: " + buildNumInt)
-                            parsePeerWireCaps(json)
-                            maybeSendWireHandshake()
                         } catch (e: NumberFormatException) {
                             buildNumberInt = 0
                             Log.e(TAG, "Failed to parse build number as integer: " + buildNum)
@@ -3946,6 +4001,10 @@ class MentraLive : SGCManager() {
                                 fields["bt_mac_address"] as String
                         )
                     }
+                    val serialNumber = fields["serial_number"] as? String
+                    if (!serialNumber.isNullOrBlank()) {
+                        DeviceStore.apply("glasses", "serialNumber", serialNumber)
+                    }
                     if (fields.containsKey("system_time_ms")) {
                         val v = fields["system_time_ms"]
                         if (v is Number) {
@@ -3953,6 +4012,17 @@ class MentraLive : SGCManager() {
                         }
                     }
 
+                    // Negotiate wire caps from ANY version_info chunk, not only the one
+                    // carrying build_number: the glasses put wire_caps in version_info_3
+                    // (firmware chunk) while build_number travels in version_info_1, so
+                    // gating negotiation on build_number silently discards the caps.
+                    // parsePeerWireCaps no-ops without a wire_caps key and
+                    // maybeSendWireHandshake gates on caps + build + not-yet-queued, so
+                    // running them per chunk is safe.
+                    parsePeerWireCaps(json)
+                    maybeSendWireHandshake()
+                    handleGlassesSessionId(json)
+
                     Bridge.log("LIVE: Processed version_info fields and sent to RN")
                     Bridge.sendVersionInfo(fields)
                 } else {
@@ -4303,15 +4373,7 @@ class MentraLive : SGCManager() {
                             // The glassesReady flag is reset on disconnect/reconnect, so this won't
                             // prevent proper reconnection
                             if (!glassesReady) {
-                                Bridge.log(
-                                        "LIVE: 📱 Sending phone_ready to glasses - waiting for glasses_ready response"
-                                )
-                                val readyMsg = JSONObject()
-                                readyMsg.put("type", "phone_ready")
-                                readyMsg.put("timestamp", System.currentTimeMillis())
-
-                                // Send it through our data channel
-                                sendJson(readyMsg, true)
+                                sendPhoneReady("SOC ready")
                             } else {
                                 Bridge.log(
                                         "LIVE: ✅ Glasses already marked as ready, skipping phone_ready"
@@ -4392,6 +4454,8 @@ class MentraLive : SGCManager() {
                 updateConnectionState(ConnTypes.DISCONNECTED)
                 glassesReady = false
                 glassesReadyReceived = false
+                glassesSessionId = null
+                readinessCompletedThisBleSession = false
             }
             "sr_adota" -> {
                 // BES chip OTA progress — K900 path (serial busy during BES flash). Emit ota_status
@@ -4457,7 +4521,20 @@ class MentraLive : SGCManager() {
 
                         val syntheticStatus: String
                         if ("FINISHED" == besOtaStatus) {
-                            syntheticStatus = "step_complete"
+                            // The glasses power-cycle right after the final BES tick, so a
+                            // session whose BES step is the LAST step never gets a follow-up
+                            // ota_status from the glasses — consumers mapping on this synthetic
+                            // status would otherwise never see a terminal state. Emit "complete"
+                            // for the final step; mid-session BES steps keep "step_complete" so
+                            // session-level trackers advance normally. Unknown sessions
+                            // (cachedOtaTotalSteps == 0, e.g. legacy glasses that never sent an
+                            // ota_status) conservatively keep "step_complete".
+                            syntheticStatus =
+                                    if (cachedOtaTotalSteps > 0 &&
+                                                    cachedOtaCurrentStep >= cachedOtaTotalSteps
+                                    )
+                                            "complete"
+                                    else "step_complete"
                         } else if ("FAILED" == besOtaStatus) {
                             syntheticStatus = "failed"
                         } else {
@@ -4701,7 +4778,12 @@ class MentraLive : SGCManager() {
     /**
      * Update WiFi status and notify listeners Matches iOS MentraLive.swift updateWifiStatus pattern
      */
-    private fun updateWifiStatus(connected: Boolean, ssid: String, localIp: String) {
+    private fun updateWifiStatus(
+            connected: Boolean,
+            ssid: String,
+            localIp: String,
+            error: String? = null
+    ) {
         Bridge.log("LIVE: 🌐 Updating WiFi status - connected: " + connected + ", SSID: " + ssid)
 
         // Update parent SGCManager fields
@@ -4710,7 +4792,7 @@ class MentraLive : SGCManager() {
         DeviceStore.apply("glasses", "wifiLocalIp", localIp)
 
         // Send event to bridge for cloud communication
-        Bridge.sendWifiStatusChange(connected, ssid, localIp)
+        Bridge.sendWifiStatusChange(connected, ssid, localIp, error)
     }
 
     /**
@@ -4784,10 +4866,13 @@ class MentraLive : SGCManager() {
     /**
      * Request WiFi scan from the glasses This will ask the glasses to scan for available networks
      */
-    override fun requestWifiScan() {
+    override fun requestWifiScan(scanId: String?) {
         try {
             val json = JSONObject()
             json.put("type", "request_wifi_scan")
+            if (!scanId.isNullOrEmpty()) {
+                json.put("scanId", scanId)
+            }
             sendJson(json, true)
             Bridge.log("LIVE: Sending WiFi scan request to glasses")
         } catch (e: JSONException) {
@@ -5458,8 +5543,9 @@ class MentraLive : SGCManager() {
             val bleImgId = "I" + String.format("%09d", System.currentTimeMillis() % 1000000000)
             json.put("bleImgId", bleImgId)
 
-            // Use auto mode by default - glasses try WiFi direct upload, BLE fallback via bleImgId
-            json.put("transferMethod", "auto")
+            // Miniapps may explicitly skip direct Wi-Fi upload and force the
+            // phone-relayed BLE path. Auto remains the default.
+            json.put("transferMethod", request.transferMethod)
 
             // Always prepare for potential BLE transfer
             if (webhookUrl != null && !webhookUrl.isEmpty()) {
@@ -5469,7 +5555,7 @@ class MentraLive : SGCManager() {
                 blePhotoTransfers[bleImgId] = transfer
             }
 
-            Bridge.log("LIVE: Using auto transfer mode with BLE fallback ID: " + bleImgId)
+            Bridge.log("LIVE: Using " + request.transferMethod + " transfer mode with BLE fallback ID: " + bleImgId)
             Bridge.log(
                     "LIVE: PHOTO PIPELINE [5b/6] JSON ready mode=" +
                             mode +
@@ -5488,14 +5574,19 @@ class MentraLive : SGCManager() {
     fun warmUpCamera(
         requestId: String,
         size: PhotoSize,
+        mode: PhotoMode = PhotoMode.PHOTO,
         exposureTimeNs: Long?,
         durationMs: Int,
+        zsl: Boolean? = null,
+        mfnr: Boolean? = null,
     ) {
         Bridge.log(
                 "LIVE: warmUpCamera() entry — requestId=" +
                         requestId +
                         ", size=" +
                         size.value +
+                        ", mode=" +
+                        mode.value +
                         ", durationMs=" +
                         durationMs
         )
@@ -5506,9 +5597,16 @@ class MentraLive : SGCManager() {
             json.put("requestId", requestId)
             val sizeValue = size.value
             json.put("size", if (sizeValue.isNotEmpty()) sizeValue else "medium")
+            json.put("mode", mode.value)
             if (exposureTimeNs != null && exposureTimeNs > 0L) {
                 json.put("exposureTimeNs", exposureTimeNs)
             }
+            if (mfnr != null) {
+                json.put("mfnr", mfnr)
+            }
+            if (zsl != null) {
+                json.put("zsl", zsl)
+            }
             json.put("durationMs", if (durationMs > 0) durationMs else 15000)
             sendJson(json, true)
         } catch (e: JSONException) {
@@ -5516,6 +5614,16 @@ class MentraLive : SGCManager() {
         }
     }
 
+    fun stopCameraWarmUp(requestId: String) {
+        if (!isConnected) {
+            throw IllegalStateException("not_connected")
+        }
+        val json = JSONObject()
+        json.put("type", "camera_warm_up_stop")
+        json.put("requestId", requestId)
+        sendJson(json, true)
+    }
+
     override fun startStream(message: MutableMap<String, Any>) {
         Bridge.log("LIVE: Starting RTMP stream")
 
@@ -7162,6 +7270,84 @@ class MentraLive : SGCManager() {
      * negotiated per-link endianness and binary support. Missing wire_caps leaves the legacy
      * defaults (BE, no binary) untouched so older glasses keep working.
      */
+    /**
+     * Drop every negotiated wire-session artifact and bump the session generation so
+     * scheduled callbacks from the old session stand down. Called on BLE disconnect and on
+     * glasses_ready: the glasses run onTransportReset() before sending glasses_ready, so a
+     * mid-link ASG restart (no BLE disconnect) resets THEIR side to legacy framing - the
+     * phone must treat every glasses_ready as a new wire epoch and renegotiate (bounded by
+     * the per-session handshake attempt cap) instead of trusting stale v2-active state.
+     */
+    private fun resetWireNegotiationState() {
+        incomingChunkReassembler.clear()
+        peerWireProtocolVersion = 0
+        useBinaryWireProtocol = false
+        wireHandshakeQueued = false
+        wireHandshakeAttempts = 0
+        wireSessionGeneration++
+        peerK900Le = false
+        peerWireCapsBinary = false
+        peerFilePayloadV2 = false
+        BleJsonCompact.resetSession()
+        wireHandshakeSentGeneration = -1
+    }
+
+    /** Sends phone_ready to (re)start the glasses-driven readiness flow. */
+    private fun sendPhoneReady(reason: String) {
+        Bridge.log("LIVE: 📱 Sending phone_ready to glasses ($reason) - waiting for glasses_ready response")
+        val readyMsg = JSONObject()
+        readyMsg.put("type", "phone_ready")
+        readyMsg.put("timestamp", System.currentTimeMillis())
+        sendJson(readyMsg, true)
+    }
+
+    /**
+     * Tracks the glasses process session id (`sid`) and re-runs the phone-driven readiness
+     * flow when it changes under a live BLE link. The BES holds the link across asg_client
+     * restarts (APK OTA, crash recovery), so a restarted glasses process is invisible to
+     * transport state; the sid is the explicit protocol signal.
+     *
+     * Tri-state by design (retro-compat with pre-sid glasses builds):
+     * - no `sid` key: legacy glasses - do nothing, today's behavior;
+     * - sid appears where none was known on an ESTABLISHED session: the glasses just
+     *   updated from a pre-sid build and restarted - treat as a restart (this is the
+     *   upgrade OTA itself);
+     * - sid differs from the recorded one: the glasses restarted - treat as a restart;
+     * - same sid: same process, no action.
+     *
+     * A restart is handled as a LOGICAL session reset: send phone_ready immediately
+     * (instead of waiting for the next sr_hrt heartbeat, and bypassing its stale
+     * glassesReady suppression); the returning glasses_ready runs the full existing
+     * remote-wire-reset flow. glassesReady/fullyBooted are deliberately left untouched -
+     * the physical link never dropped, so the connection UI must not flap. The RN layer
+     * is notified so the OTA coordinator can treat it as its reconnect edge.
+     */
+    private fun handleGlassesSessionId(json: JSONObject) {
+        val sid = json.optString("sid", "")
+        if (sid.isEmpty()) return
+        val previous = glassesSessionId
+        if (sid == previous) return
+        glassesSessionId = sid
+        if (previous == null && !readinessCompletedThisBleSession) {
+            // First sid of a fresh BLE session before readiness completes: the normal
+            // pairing/readiness flow is already running - just record it.
+            return
+        }
+        Bridge.log(
+                "LIVE: 🔁 Glasses session changed (${previous ?: "<pre-sid build>"} -> $sid) - " +
+                        "asg restarted under a live link, re-running readiness"
+        )
+        sendPhoneReady("glasses session changed")
+        try {
+            val payload = HashMap<String, Any>()
+            payload["previous_sid"] = previous ?: ""
+            payload["sid"] = sid
+            Bridge.sendTypedMessage("glasses_session_changed", payload)
+        } catch (e: Exception) {
+            Log.e(TAG, "Error emitting glasses_session_changed", e)
+        }
+    }
+
     private fun parsePeerWireCaps(json: JSONObject) {
         val caps = json.optJSONObject("wire_caps") ?: return
         if (caps.optBoolean("k900_le", false)) {
@@ -7233,7 +7419,39 @@ class MentraLive : SGCManager() {
                     )
             Bridge.log("LIVE: Sending BLE wire v2 handshake")
             wireHandshakeQueued = true
+            wireHandshakeSentGeneration = wireSessionGeneration
             queueData(packed, null)
+            // The handshake and its reply are fire-and-forget binary frames with no ACK
+            // tracking; if either is lost, wireHandshakeQueued would block every future
+            // attempt and the session would silently stay on the legacy string wire.
+            // Re-arm after a grace period so negotiation can retry, bounded per session
+            // so a peer that advertises binary but never answers doesn't get pinged
+            // forever (later caps/version triggers may still retry explicitly).
+            wireHandshakeAttempts++
+            val scheduledGeneration = wireSessionGeneration
+            handler.postDelayed(
+                    {
+                        if (scheduledGeneration == wireSessionGeneration &&
+                                        wireHandshakeQueued &&
+                                        peerWireProtocolVersion < BleWireProtocol.PROTOCOL_V2
+                        ) {
+                            Bridge.log(
+                                    "LIVE: BLE wire v2 handshake unanswered after " +
+                                            WIRE_HANDSHAKE_RETRY_GRACE_MS +
+                                            "ms (attempt " +
+                                            wireHandshakeAttempts +
+                                            "/" +
+                                            WIRE_HANDSHAKE_MAX_ATTEMPTS +
+                                            ") - re-arming"
+                            )
+                            wireHandshakeQueued = false
+                            if (wireHandshakeAttempts < WIRE_HANDSHAKE_MAX_ATTEMPTS) {
+                                maybeSendWireHandshake()
+                            }
+                        }
+                    },
+                    WIRE_HANDSHAKE_RETRY_GRACE_MS
+            )
         } catch (e: Exception) {
             Log.e(TAG, "Failed to send wire handshake", e)
         }
@@ -7243,12 +7461,17 @@ class MentraLive : SGCManager() {
         peerWireProtocolVersion = BleWireProtocol.PROTOCOL_V2
         useBinaryWireProtocol = true
         wireHandshakeQueued = false
+        wireHandshakeAttempts = 0
         peerK900Le = true
         BleJsonCompact.markSessionConnected(System.currentTimeMillis())
         Bridge.log(logMessage)
     }
 
     private fun handlePeerWireHandshake() {
+        if (wireHandshakeSentGeneration != wireSessionGeneration) {
+            Bridge.log("LIVE: Ignoring wire v2 handshake reply from a previous session epoch")
+            return
+        }
         activateBinaryWireV2Session("LIVE: Peer confirmed BLE wire protocol v2")
     }
 
@@ -7947,7 +8170,7 @@ class MentraLive : SGCManager() {
             val type = json.optString("type", "")
 
             when (type) {
-                "request_wifi_scan" -> requestWifiScan()
+                "request_wifi_scan" -> requestWifiScan(null)
                 "rgb_led_control_on", "rgb_led_control_off" -> {
                     // Forward LED control commands directly to glasses via BLE
                     Log.d(TAG, "💡 Forwarding LED control command to glasses: " + type)
@@ -8763,6 +8986,9 @@ class MentraLive : SGCManager() {
 
         // Send glasses-side Voice Activity Detection setting.
         sendVoiceActivityDetectionSetting()
+
+        // Send glasses-side loudness / Barrier gate setting.
+        sendLoudnessGateSetting()
     }
 
     override fun sendVoiceActivityDetectionSetting() {
@@ -8805,11 +9031,56 @@ class MentraLive : SGCManager() {
         }
     }
 
+    override fun sendLoudnessGateSetting() {
+        val value = DeviceStore.get("bluetooth", "loudness_gate_enabled")
+        val enabled =
+                if (value is Boolean) value
+                else BluetoothSdkDefaults.LOUDNESS_GATE_ENABLED
+
+        Bridge.log("LIVE: 🎚️ Sending loudness/Barrier gate setting to glasses: " + enabled)
+
+        if (!isConnected) {
+            Bridge.log("LIVE: Cannot send loudness gate setting - not connected")
+            return
+        }
+
+        try {
+            val body = JSONObject()
+            body.put("type", LOUDNESS_GATE_SWITCH_TYPE)
+            body.put("switch", if (enabled) 1 else 0)
+
+            val cmdObject = JSONObject()
+            cmdObject.put("C", "cs_swit")
+            cmdObject.put("V", 1)
+            cmdObject.put("B", body.toString())
+
+            val packedData =
+                    K900ProtocolUtils.packDataToK900(
+                            cmdObject.toString().toByteArray(StandardCharsets.UTF_8),
+                            K900ProtocolUtils.CMD_TYPE_STRING,
+                            k900LengthEndian()
+                    )
+            if (packedData == null) {
+                Bridge.log("LIVE: Failed to pack loudness gate setting command")
+                return
+            }
+            queueData(packedData)
+        } catch (e: JSONException) {
+            Log.e(TAG, "Error creating loudness gate setting command", e)
+        }
+    }
+
     /** Send button photo settings to glasses, replaying all stored scan-tuning fields. */
     override fun sendButtonPhotoSettings() {
+        val legacyZslMfnr =
+            DeviceStore.get(ObservableStore.BLUETOOTH_CATEGORY, "button_photo_zsl_mfnr") as Boolean?
         val size = DeviceStore.get(ObservableStore.BLUETOOTH_CATEGORY, "button_photo_size") as String?
-        val mfnr = DeviceStore.get(ObservableStore.BLUETOOTH_CATEGORY, "button_photo_mfnr") as Boolean?
-        val zsl = DeviceStore.get(ObservableStore.BLUETOOTH_CATEGORY, "button_photo_zsl") as Boolean?
+        val mfnr =
+            (DeviceStore.get(ObservableStore.BLUETOOTH_CATEGORY, "button_photo_mfnr") as Boolean?)
+                ?: legacyZslMfnr
+        val zsl =
+            (DeviceStore.get(ObservableStore.BLUETOOTH_CATEGORY, "button_photo_zsl") as Boolean?)
+                ?: legacyZslMfnr
         val noiseReduction = DeviceStore.get(ObservableStore.BLUETOOTH_CATEGORY, "button_photo_noise_reduction") as Boolean?
         val edgeEnhancement = DeviceStore.get(ObservableStore.BLUETOOTH_CATEGORY, "button_photo_edge_enhancement") as Boolean?
         val ispDigitalGain = DeviceStore.get(ObservableStore.BLUETOOTH_CATEGORY, "button_photo_isp_digital_gain") as Int?
@@ -8868,6 +9139,35 @@ class MentraLive : SGCManager() {
         }
     }
 
+    fun sendCameraFovOverride(
+        requestId: String,
+        leaseId: String,
+        fov: Int,
+        roiPosition: Int,
+        ttlMs: Int,
+    ) {
+        val json = JSONObject()
+        json.put("type", "camera_fov_override")
+        json.put("request_id", requestId)
+        json.put(
+            "params",
+            JSONObject()
+                .put("lease_id", leaseId)
+                .put("fov", fov)
+                .put("roi_position", roiPosition)
+                .put("ttl_ms", ttlMs),
+        )
+        sendJson(json, true)
+    }
+
+    fun releaseCameraFovOverride(requestId: String, leaseId: String) {
+        val json = JSONObject()
+        json.put("type", "camera_fov_override_release")
+        json.put("request_id", requestId)
+        json.put("params", JSONObject().put("lease_id", leaseId))
+        sendJson(json, true)
+    }
+
     /**
      * Send camera tuning config (ANR / gain) to the glasses via the {@code camera_tuning_config}
      * command. The ASG client relays this as a {@code camconfig} broadcast to the camera HAL.