@mentra/bluetooth-sdk 3.2.1-dev.314 → 3.3.0-beta.942

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

@@ -34,6 +34,7 @@ import android.os.SystemClock
 import com.mentra.bluetoothsdk.utils.NativeLog as Log
 import androidx.core.app.ActivityCompat
 import com.mentra.bluetoothsdk.BluetoothSdkDefaults
+import com.mentra.bluetoothsdk.BluetoothSdkException
 import com.mentra.bluetoothsdk.Bridge
 import com.mentra.bluetoothsdk.DeviceManager
 import com.mentra.bluetoothsdk.PhotoRequest
@@ -141,6 +142,7 @@ class MentraLive : SGCManager() {
         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 AUTO_POWER_OFF_SWITCH_TYPE = 11
         // Mic tuning field names, matching the BES cs_mictun body.
         private val MIC_TUNING_FIELDS =
                 listOf("gain", "open", "close", "attack", "hang", "sp_open", "sp_close", "sp_hold")
@@ -644,6 +646,10 @@ class MentraLive : SGCManager() {
     private var a2dpProfile: BluetoothA2dp? = null
     private var isA2dpProxyRegistered = false
     private var a2dpConnectAttempts = 0
+    private val classicAudioServiceDiscovery =
+            ClassicAudioServiceDiscovery(handler, CONNECTION_TIMEOUT_MS.toLong()) {
+                Bridge.log("LIVE: Classic: $it")
+            }
 
     private data class OutgoingBleCommandTraceInfo(
             val commandType: String,
@@ -776,7 +782,8 @@ class MentraLive : SGCManager() {
     }
 
     // Inner class to track incoming file transfers
-    private class FileTransferSession(var fileName: String, var fileSize: Int) {
+    internal class FileTransferSession(var fileName: String, var fileSize: Int, flags: Int = 0) {
+        private val dynamicPayload = (flags and 0x0002) != 0
         // NOTE: fileSize may be "fake" (inflated) due to BES firmware workaround
         var actualPackSize =
                 0 // Actual pack size from first received packet (for BES lie detection)
@@ -805,9 +812,8 @@ class MentraLive : SGCManager() {
          * Recalculate total packets based on actual pack size from received packet. Called when
          * first packet is received to handle variable pack sizes.
          *
-         * NOTE: Due to BES firmware workaround, fileSize in header may be "fake" (inflated). We
-         * detect this by checking if fileSize is a multiple of 400 (BES_HARDCODED_PACK_SIZE). If
-         * so, totalPackets = fileSize / 400, regardless of actual pack size.
+         * Dynamic-payload headers carry the true byte count. Only legacy small packs use
+         * the inflated-size workaround (multiples of BES_HARDCODED_PACK_SIZE).
          */
         fun recalculateTotalPackets(actualPackSize: Int) {
             if (actualPackSize <= 0 || actualPackSize > K900ProtocolUtils.FILE_PACK_SIZE) {
@@ -818,8 +824,8 @@ class MentraLive : SGCManager() {
 
             // Detect BES lie: if fileSize is exact multiple of 400, glasses used the lie strategy
             val isBesLie =
-                    (fileSize % BES_HARDCODED_PACK_SIZE == 0) &&
-                            (actualPackSize != BES_HARDCODED_PACK_SIZE)
+                    !dynamicPayload && (fileSize % BES_HARDCODED_PACK_SIZE == 0) &&
+                            (actualPackSize < BES_HARDCODED_PACK_SIZE)
 
             val newTotalPackets: Int
             if (isBesLie) {
@@ -857,6 +863,10 @@ class MentraLive : SGCManager() {
         }
 
         fun addPacket(index: Int, data: ByteArray): Boolean {
+            if (dynamicPayload && (index < 0 || index >= totalPackets || actualPackSize <= 0 ||
+                            data.size != minOf(actualPackSize, fileSize - index * actualPackSize))) {
+                return false
+            }
             if (index >= 0 && index < totalPackets && !receivedPackets.containsKey(index)) {
                 receivedPackets[index] = data
 
@@ -1703,6 +1713,7 @@ class MentraLive : SGCManager() {
         readinessCompletedThisBleSession = false
         glassesReadyReceived = false
         ctkdInitiatedThisGattSession = false
+        classicAudioServiceDiscovery.cancel()
         audioConnected = false
         notificationsEnabled = false
         currentMtu = 23
@@ -1978,6 +1989,7 @@ class MentraLive : SGCManager() {
         readinessCompletedThisBleSession = false
         glassesReadyReceived = false
         ctkdInitiatedThisGattSession = false
+        classicAudioServiceDiscovery.cancel()
         audioConnected = false
         notificationsEnabled = false
         processSendQueueRunnable?.let { handler.removeCallbacks(it) }
@@ -2147,7 +2159,7 @@ class MentraLive : SGCManager() {
                             // than scanning).
                             // Falls back to name-based scan if no address is saved.
                             val lastDeviceAddress =
-                                    DeviceStore.get("bluetooth", "device_address") as String?
+                                    selectedConnectionAddress()
                             if (lastDeviceAddress != null &&
                                             !lastDeviceAddress.isEmpty() &&
                                             bluetoothAdapter != null
@@ -2345,6 +2357,7 @@ class MentraLive : SGCManager() {
                             registerBondingReceiver()
                             bondingRetryCount = 0
                             ctkdInitiatedThisGattSession = false
+                            classicAudioServiceDiscovery.cancel()
                             Bridge.log(
                                     "LIVE: CTKD: BLE GATT up - deferring Classic/A2DP until notifications ready"
                             )
@@ -2393,6 +2406,7 @@ class MentraLive : SGCManager() {
                             // Reset audio pairing flags
                             glassesReadyReceived = false
                             ctkdInitiatedThisGattSession = false
+                            classicAudioServiceDiscovery.cancel()
                             audioConnected = false
 
                             notificationsEnabled = false
@@ -2455,6 +2469,7 @@ class MentraLive : SGCManager() {
                         glassesReadyReceived = false
                         audioConnected = false
                         ctkdInitiatedThisGattSession = false
+                        classicAudioServiceDiscovery.cancel()
 
                         notificationsEnabled = false
 
@@ -3366,10 +3381,12 @@ class MentraLive : SGCManager() {
         sendJson(json, wakeup, true)
     }
 
-    private fun sendJson(json: JSONObject?, wakeup: Boolean, bridgeLogging: Boolean): Boolean {
+    private fun sendJson(
+            json: JSONObject?, wakeup: Boolean, bridgeLogging: Boolean,
+            sessionGeneration: Long = bleSessionGeneration.get(),
+    ): Boolean {
         if (json != null) {
             try {
-                val sessionGeneration = bleSessionGeneration.get()
                 if (buildNumberInt < 5) {
                     val jsonStr = json.toString()
                     // Bridge.log("LIVE: 📤 Sending JSON with esoteric message ID: " + jsonStr);
@@ -4137,7 +4154,9 @@ class MentraLive : SGCManager() {
                     "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))
+                    // BES buffers non-waking commands when MTK enters standby, even while
+                    // its streaming CPU lease is held. The current probe needs a live reply.
+                    sendJson(JSONObject(it), true)
                 }
             }
             "pong" ->
@@ -5548,7 +5567,9 @@ class MentraLive : SGCManager() {
                     if (bodyObj != null) {
                         val type = bodyObj.optInt("type", -1)
                         val value = bodyObj.optInt("switch", -1)
-                        handleSwitchStatus(type, value, System.currentTimeMillis())
+                        // K900 replies carry result in "S"; 0 is RC_SUCCESS.
+                        val resultCode = json.optInt("S", -1)
+                        handleSwitchStatus(type, value, System.currentTimeMillis(), resultCode)
                     }
                 } catch (e: Exception) {
                     Log.e(TAG, "Error parsing sr_swit response", e)
@@ -5578,7 +5599,13 @@ class MentraLive : SGCManager() {
                 try {
                     val bodyObj = optK900Body(json)
                     if (bodyObj != null) {
-                        Bridge.sendWearState(bodyObj.optInt("on", 0) != 0)
+                        val extras = HashMap<String, Any>()
+                        if (bodyObj.has("elapsed_ms")) extras["elapsedMs"] = bodyObj.optInt("elapsed_ms")
+                        if (bodyObj.has("timeout_ms")) extras["timeoutMs"] = bodyObj.optInt("timeout_ms")
+                        if (bodyObj.has("enabled")) extras["enabled"] = bodyObj.optInt("enabled") != 0
+                        if (bodyObj.has("armed")) extras["armed"] = bodyObj.optInt("armed") != 0
+                        if (bodyObj.has("inhibited")) extras["inhibited"] = bodyObj.optInt("inhibited") != 0
+                        Bridge.sendWearState(bodyObj.optInt("on", 0) != 0, extras)
                     }
                 } catch (e: Exception) {
                     Log.e(TAG, "Error parsing sr_wrst response", e)
@@ -5933,8 +5960,20 @@ class MentraLive : SGCManager() {
         Bridge.sendWearTuningState(state)
     }
 
-    private fun handleSwitchStatus(switchType: Int, switchValue: Int, timestamp: Long) {
+    private fun handleSwitchStatus(
+            switchType: Int,
+            switchValue: Int,
+            timestamp: Long,
+            resultCode: Int = -1
+    ) {
         Bridge.sendSwitchStatus(switchType, switchValue, timestamp)
+        if (switchType == AUTO_POWER_OFF_SWITCH_TYPE) {
+            val ok = resultCode == 0
+            Bridge.log(
+                    "LIVE: 🔋 auto power-off sr_swit reply type=$switchType switch=$switchValue" +
+                            " result=$resultCode ok=$ok"
+            )
+        }
         if (switchType == VOICE_ACTIVITY_DETECTION_SWITCH_TYPE &&
                         (switchValue == 0 || switchValue == 1)
         ) {
@@ -6048,6 +6087,17 @@ class MentraLive : SGCManager() {
     }
 
     override fun sendIncidentId(incidentId: String, apiBaseUrl: String?) {
+        if (!isConnected || bluetoothGatt == null || txCharacteristic == null) {
+            throw BluetoothSdkException(
+                "glasses_not_connected", "Cannot request incident logs because the glasses BLE link is not ready.",
+            )
+        }
+        // The JS token sync may happen after glasses_ready. Use only its current native store value.
+        val coreToken = DeviceStore.get("bluetooth", "core_token") as? String
+        if (coreToken.isNullOrBlank()) {
+            throw BluetoothSdkException("core_token_unavailable", "Cannot request incident logs without the current Core access token.")
+        }
+        val sessionGeneration = bleSessionGeneration.get()
         try {
             var base = if (apiBaseUrl != null) apiBaseUrl.trim() else ""
             if (base.isEmpty()) {
@@ -6060,13 +6110,25 @@ class MentraLive : SGCManager() {
             bleIncidentLogRelays[lKey] =
                     BleIncidentLogRelay(lKey, incidentId, base, BleIncidentLogKind.LOGCAT)
 
+            val auth = JSONObject()
+            auth.put("type", "auth_token")
+            auth.put("coreToken", coreToken)
+            auth.put("timestamp", System.currentTimeMillis())
             val json = JSONObject()
             json.put("type", "upload_incident_logs")
             json.put("incidentId", incidentId)
             json.put("apiBaseUrl", base)
-            sendJson(json, true)
+            // Wake ASG with its current token before the upload command enters the same FIFO.
+            if (!sendJson(auth, true, true, sessionGeneration) ||
+                    sessionGeneration != bleSessionGeneration.get() ||
+                    !isConnected || bluetoothGatt == null || txCharacteristic == null ||
+                    !sendJson(json, true, true, sessionGeneration) || sessionGeneration != bleSessionGeneration.get()) {
+                bleIncidentLogRelays.remove(bKey)
+                bleIncidentLogRelays.remove(lKey)
+                throw BluetoothSdkException("incident_dispatch_failed", "Could not queue the glasses incident-log request.")
+            }
             Bridge.log(
-                    "LIVE: Sent incidentId to glasses for log upload: " +
+                    "LIVE: Queued incidentId to glasses for log upload: " +
                             incidentId +
                             " (BLE relay keys " +
                             bKey +
@@ -6075,7 +6137,7 @@ class MentraLive : SGCManager() {
                             ")"
             )
         } catch (e: JSONException) {
-            Log.e(TAG, "Error creating upload_incident_logs command", e)
+            throw BluetoothSdkException("incident_dispatch_failed", "Could not create the glasses incident-log request.", e)
         }
     }
 
@@ -6140,7 +6202,8 @@ class MentraLive : SGCManager() {
             val json = JSONObject()
             json.put("type", "request_version")
             requestId?.let { json.put("request_id", it) }
-            sendJson(json, false)
+            // Wake ASG so the version request and its response can finish after idle.
+            sendJson(json, true)
             Bridge.log("LIVE: 📱 Requesting version info from glasses")
         } catch (e: JSONException) {
             Log.e(TAG, "📱 Error creating request_version command", e)
@@ -6602,6 +6665,14 @@ class MentraLive : SGCManager() {
         return false
     }
 
+    private fun selectedConnectionAddress(): String? = SelectedDeviceAddress.resolve(
+        savedDeviceName,
+        DeviceStore.get("bluetooth", "pending_device_name") as? String,
+        DeviceStore.get("bluetooth", "pending_device_address") as? String,
+        DeviceStore.get("bluetooth", "device_name") as? String,
+        DeviceStore.get("bluetooth", "device_address") as? String,
+    )
+
     fun connectToSmartGlasses() {
         if (postGattLifecycle { connectToSmartGlasses() }) return
         if (pairingYieldActive) {
@@ -6636,13 +6707,7 @@ class MentraLive : SGCManager() {
         // var context = Bridge.getContext();
         // SharedPreferences prefs = context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE);
         // String lastDeviceAddress = prefs.getString(PREF_DEVICE_NAME, null);
-        val pendingAddress =
-                (DeviceStore.get("bluetooth", "pending_device_address") as String?)?.takeIf {
-                    it.isNotEmpty()
-                }
-        val lastDeviceAddress =
-                pendingAddress
-                        ?: (DeviceStore.get("bluetooth", "device_address") as String?)
+        val lastDeviceAddress = selectedConnectionAddress()
 
         if (lastDeviceAddress != null && lastDeviceAddress.length > 0) {
             // Connect to last known device if available
@@ -7178,7 +7243,7 @@ class MentraLive : SGCManager() {
                                     BluetoothDevice.BOND_BONDED ->
                                             run {
                                                 Bridge.log(
-                                                        "LIVE: CTKD: ✅ Successfully bonded with device - BT Classic connection established"
+                                                        "LIVE: CTKD: Successfully bonded - checking Classic audio services"
                                                 )
                                                 markPairingTiming(
                                                         "ctkd_bonded",
@@ -7197,7 +7262,7 @@ class MentraLive : SGCManager() {
                                                 // path does this at GATT connect).
                                                 // markAudioConnected / sendAudioConnected fire
                                                 // when the A2DP path completes.
-                                                connectA2dpProfile(device)
+                                                prepareClassicAudio(device)
 
                                                 // Safety net: if glasses_ready somehow missed
                                                 // setting fullyBooted, catch up here.
@@ -7234,6 +7299,7 @@ class MentraLive : SGCManager() {
                                                 }
                                             }
                                     BluetoothDevice.BOND_NONE -> {
+                                        classicAudioServiceDiscovery.cancel()
                                         Bridge.log(
                                                 "LIVE: CTKD: ❌ Bonding failed or removed for device"
                                         )
@@ -7355,6 +7421,10 @@ class MentraLive : SGCManager() {
         classicAudioReceiver =
                 object : BroadcastReceiver() {
                     override fun onReceive(context: Context?, intent: Intent?) {
+                        if (intent?.action == BluetoothDevice.ACTION_UUID) {
+                            intent.bluetoothDeviceExtra()?.let { classicAudioServiceDiscovery.onUuids(it) }
+                            return
+                        }
                         if (intent?.action != BluetoothA2dp.ACTION_CONNECTION_STATE_CHANGED &&
                                 intent?.action != BluetoothHeadset.ACTION_CONNECTION_STATE_CHANGED) return
                         val device = intent.bluetoothDeviceExtra() ?: return
@@ -7371,6 +7441,7 @@ class MentraLive : SGCManager() {
         try {
             val filter =
                     IntentFilter().apply {
+                        addAction(BluetoothDevice.ACTION_UUID)
                         addAction(BluetoothA2dp.ACTION_CONNECTION_STATE_CHANGED)
                         addAction(BluetoothHeadset.ACTION_CONNECTION_STATE_CHANGED)
                     }
@@ -7495,10 +7566,10 @@ class MentraLive : SGCManager() {
         when (device.bondState) {
             BluetoothDevice.BOND_BONDED -> {
                 Bridge.log(
-                        "LIVE: CTKD: Device is already bonded - connecting A2DP audio profile"
+                        "LIVE: CTKD: Device is already bonded - checking Classic audio services"
                 )
                 markPairingTiming("ctkd_already_bonded")
-                connectA2dpProfile(device)
+                prepareClassicAudio(device)
             }
             BluetoothDevice.BOND_BONDING -> {
                 // Secure pairing firmware may request SMP as soon as GATT connects.
@@ -7557,6 +7628,19 @@ class MentraLive : SGCManager() {
         return classicAudioConnectionTracker.connected
     }
 
+    private fun prepareClassicAudio(device: BluetoothDevice) {
+        if (!canConnectClassicAudio(device)) return
+        val gatt = bluetoothGatt
+        classicAudioServiceDiscovery.connectWhenDiscovered(device) {
+            if (bluetoothGatt === gatt && canConnectClassicAudio(device)) connectA2dpProfile(device)
+        }
+    }
+
+    private fun canConnectClassicAudio(device: BluetoothDevice): Boolean =
+            !isKilled && !pairingYieldActive && isConnected && notificationsEnabled &&
+                    ctkdInitiatedThisGattSession && connectedDevice?.address == device.address &&
+                    device.bondState == BluetoothDevice.BOND_BONDED
+
     /** A2DP profile service listener for connecting to already-bonded devices */
     private val a2dpServiceListener: BluetoothProfile.ServiceListener =
             object : BluetoothProfile.ServiceListener {
@@ -7605,7 +7689,9 @@ class MentraLive : SGCManager() {
             Bridge.log("LIVE: A2DP: Skipping connectA2dpWithProxy — SGC destroyed")
             return
         }
-        if (a2dpProfile == null || device == null) {
+        if (device == null || !canConnectClassicAudio(device) ||
+                !ClassicAudioServiceDiscovery.hasAudioSink(device)) return
+        if (a2dpProfile == null) {
             Bridge.log("LIVE: A2DP: Cannot connect - proxy or device is null")
             return
         }
@@ -7655,14 +7741,11 @@ class MentraLive : SGCManager() {
                 "LIVE: A2DP: Retry $a2dpConnectAttempts/$A2DP_CONNECT_MAX_ATTEMPTS in " +
                         "${A2DP_CONNECT_RETRY_MS}ms ($reason)"
         )
+        val gatt = bluetoothGatt
         handler.postDelayed(
                 Runnable {
-                    if (isKilled || pairingYieldActive || connectedDevice == null) {
-                        return@Runnable
-                    }
-                    val target = connectedDevice ?: return@Runnable
-                    if (a2dpProfile != null) {
-                        connectA2dpWithProxy(target)
+                    if (bluetoothGatt === gatt && canConnectClassicAudio(device)) {
+                        connectA2dpWithProxy(device)
                     }
                 },
                 A2DP_CONNECT_RETRY_MS
@@ -7882,6 +7965,7 @@ class MentraLive : SGCManager() {
 
         // Mark as killed to prevent reconnection attempts
         isKilled = true
+        classicAudioServiceDiscovery.cancel()
         explicitConnectByName = false
         pairingYieldActive = false
         pairingYieldAwaitingReclaim = false
@@ -7903,7 +7987,11 @@ class MentraLive : SGCManager() {
 
         // 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
+        // BLE loss clears connectedDevice while the OS audio profiles can remain connected.
+        // Use this session's existing Classic target before resetting the tracker below.
+        val classicDevice = connectedDevice ?: classicAudioConnectionTracker.targetForDisconnect()?.let {
+            bluetoothAdapter?.getRemoteDevice(it)
+        }
         disconnectClassicProfiles(classicDevice)
         closeA2dpProxy()
         classicAudioConnectionTracker.reset()
@@ -7980,6 +8068,7 @@ class MentraLive : SGCManager() {
         glassesReadyReceived = false
         audioConnected = false
         ctkdInitiatedThisGattSession = false
+        classicAudioServiceDiscovery.cancel()
         DeviceStore.apply("glasses", "fullyBooted", false)
         updateConnectionState(ConnTypes.DISCONNECTED)
 
@@ -9467,7 +9556,11 @@ class MentraLive : SGCManager() {
                 }
             } else {
                 // Normal single message transmission
-                transportLog("LIVE: Sending data to glasses: " + wireData, bridgeLogging)
+                transportLog(
+                        "LIVE: Sending data to glasses: " +
+                                loggableOutgoingPayload(wireData, commandTraceInfo.commandType),
+                        bridgeLogging
+                )
 
                 // Pack the data using the centralized utility with the negotiated endianness
                 val packedData =
@@ -9769,6 +9862,18 @@ class MentraLive : SGCManager() {
         }
     }
 
+    /**
+     * Credentials are sent unchanged but never logged; the BLE trace redacts their fields.
+     */
+    private fun loggableOutgoingPayload(payload: String, commandType: String): String =
+            try {
+                val json = JSONObject(payload)
+                if (json.has("password") || json.has("coreToken")) "<$commandType with credentials omitted>"
+                else payload
+            } catch (_: JSONException) {
+                payload
+            }
+
     private fun summarizeOutgoingMessage(payload: String?): String {
         if (payload == null || payload.isEmpty()) {
             return "type=unknown, requestId=none, appId=none, mode=none, transferMethod=none, bleImgId=none, exposureTimeNs=none, iso=none, mId=none"
@@ -10193,7 +10298,7 @@ class MentraLive : SGCManager() {
             if (incidentRelay.session == null) {
                 activeFileTransfers.remove(packetInfo.fileName)
                 incidentRelay.session =
-                        FileTransferSession(packetInfo.fileName, packetInfo.fileSize)
+                        FileTransferSession(packetInfo.fileName, packetInfo.fileSize, packetInfo.flags)
                 incidentRelay.session!!.recalculateTotalPackets(packetInfo.packSize)
                 Bridge.log(
                         "LIVE: 📦 Started BLE incident log transfer: " +
@@ -10244,7 +10349,7 @@ class MentraLive : SGCManager() {
             // Get or create session for this transfer
             if (photoTransfer.session == null) {
                 photoTransfer.session =
-                        FileTransferSession(packetInfo.fileName, packetInfo.fileSize)
+                        FileTransferSession(packetInfo.fileName, packetInfo.fileSize, packetInfo.flags)
                 // Recalculate total packets based on actual pack size (handles variable MTU)
                 photoTransfer.session!!.recalculateTotalPackets(packetInfo.packSize)
                 Bridge.log(
@@ -10330,7 +10435,7 @@ class MentraLive : SGCManager() {
         var session = activeFileTransfers[packetInfo.fileName]
         if (session == null) {
             // New file transfer
-            session = FileTransferSession(packetInfo.fileName, packetInfo.fileSize)
+            session = FileTransferSession(packetInfo.fileName, packetInfo.fileSize, packetInfo.flags)
             // Recalculate total packets based on actual pack size (handles variable MTU)
             session.recalculateTotalPackets(packetInfo.packSize)
             activeFileTransfers[packetInfo.fileName] = session
@@ -10825,6 +10930,9 @@ class MentraLive : SGCManager() {
         // Send glasses-side loudness / Barrier gate setting.
         sendLoudnessGateSetting()
 
+        // Send glasses-side auto power-off setting.
+        sendAutoPowerOffSetting()
+
         // Send mic tuning. With nothing authorized this sends a reset, which is
         // what returns a freshly connected pair of glasses to stock behaviour.
         sendMicTuningSetting()
@@ -11108,6 +11216,52 @@ class MentraLive : SGCManager() {
         }
     }
 
+    override fun sendAutoPowerOffSetting() {
+        val value = DeviceStore.get("bluetooth", "auto_power_off_enabled")
+        val enabled =
+                if (value is Boolean) value
+                else BluetoothSdkDefaults.AUTO_POWER_OFF_ENABLED
+
+        Bridge.log(
+                "LIVE: 🔋 Sending auto power-off setting to glasses: enabled=$enabled" +
+                        " (cs_swit type=$AUTO_POWER_OFF_SWITCH_TYPE)"
+        )
+
+        if (!isConnected) {
+            Bridge.log("LIVE: Cannot send auto power-off setting - not connected")
+            return
+        }
+
+        try {
+            val body = JSONObject()
+            body.put("type", AUTO_POWER_OFF_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 auto power-off setting command")
+                return
+            }
+            queueData(packedData)
+            Bridge.log(
+                    "LIVE: 🔋 Queued auto power-off cs_swit type=$AUTO_POWER_OFF_SWITCH_TYPE" +
+                            " switch=${if (enabled) 1 else 0}"
+            )
+        } catch (e: JSONException) {
+            Log.e(TAG, "Error creating auto power-off setting command", e)
+        }
+    }
+
     /** Send button photo settings to glasses, replaying all stored scan-tuning fields. */
     override fun sendButtonPhotoSettings() {
         val legacyZslMfnr =

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

@@ -208,7 +208,7 @@ class MentraNex : SGCManager() {
 
             // If we already have saved device names for main...
             if (name != null && preferredMainDeviceId != null) {
-                if (!name.contains(preferredMainDeviceId!!)) {
+                if (name != preferredMainDeviceId) {
                     return // Not a matching device
                 }
             }
@@ -230,7 +230,6 @@ class MentraNex : SGCManager() {
         type = DeviceTypes.NEX
         hasMic = true
         DeviceStore.apply("glasses", "micEnabled", false)
-        preferredMainDeviceId = DeviceManager.getInstance().deviceName
         
         // Initialize LC3 audio player
         lc3AudioPlayer = Lc3Player(context)
@@ -1315,23 +1314,28 @@ class MentraNex : SGCManager() {
     }
 
     private fun connectToSmartGlasses() {
-        val deviceModelName = DeviceManager.getInstance().deviceName
-        val deviceAddress = DeviceManager.getInstance().deviceAddress
+        val target = preferredMainDeviceId?.takeIf { it.isNotBlank() } ?: return
+        val deviceAddress = SelectedDeviceAddress.resolve(
+            target,
+            DeviceStore.get("bluetooth", "pending_device_name") as? String,
+            DeviceStore.get("bluetooth", "pending_device_address") as? String,
+            DeviceStore.get("bluetooth", "device_name") as? String,
+            DeviceStore.get("bluetooth", "device_address") as? String,
+        )
 
         // Register bonding receiver
         Bridge.log("connectToSmartGlasses start")
-        Bridge.log("try to ConnectToSmartGlassesing deviceModelName: ${deviceModelName} deviceAddress: ${deviceAddress}")
-        preferredMainDeviceId = DeviceManager.getInstance().deviceName
+        Bridge.log("Connecting to selected Nex: $target address: $deviceAddress")
         if (!bluetoothAdapter.isEnabled) {
             return
         }
         when {
-            !deviceModelName.isNullOrEmpty() && !deviceAddress.isNullOrEmpty() -> {
+            deviceAddress != null -> {
                 stopScan()
                 mainDevice = bluetoothAdapter.getRemoteDevice(deviceAddress)
                 mainTaskHandler?.sendEmptyMessageDelayed(MAIN_TASK_HANDLER_CODE_RECONNECT_DEVICE, 0)
             }
-            savedNexMainAddress != null -> {
+            savedNexMainName == target && savedNexMainAddress != null -> {
                 mainDevice = bluetoothAdapter.getRemoteDevice(savedNexMainAddress)
                 mainTaskHandler?.sendEmptyMessageDelayed(MAIN_TASK_HANDLER_CODE_RECONNECT_DEVICE, 0)
             }