@mentra/bluetooth-sdk 3.2.1-beta.373 → 3.2.1-beta.386

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

@@ -1501,12 +1501,16 @@ class DeviceManager internal constructor(initializeHardware: Boolean) {
             return
         }
 
+        // A new identity must never inherit the previous glasses' address when
+        // pairing supplied only a name. Same-device reconnects retain their cache.
+        val identityChanged = pendingDeviceName.isNotEmpty() &&
+            (pendingDeviceName != deviceName || sgc?.type != defaultWearable)
+        if (identityChanged || pendingDeviceAddress.isNotEmpty()) {
+            deviceAddress = pendingDeviceAddress
+        }
         if (pendingDeviceName.isNotEmpty()) {
             deviceName = pendingDeviceName
         }
-        if (pendingDeviceAddress.isNotEmpty()) {
-            deviceAddress = pendingDeviceAddress
-        }
         clearPendingConnection()
 
         val readyKey = "${sgc?.type}:${deviceName}"

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

@@ -3,9 +3,9 @@ package com.mentra.bluetoothsdk
 /** Generated by release CI. Do not edit in a release checkout. */
 internal object GeneratedReleaseMetadata {
     const val FAMILY_BASE_VERSION: String = "3.2.1"
-    const val RELEASE_IDENTITY: String = "3.2.1-beta.373"
-    const val RELEASE_SET_ID: String = "mentra-3.2.1-beta.373"
-    const val SOURCE_COMMIT: String = "d60eecea0008160ce942b298f87a2d805ab3a2a6"
-    const val OTA_MANIFEST_URL: String = "https://artifactscdn.mentraglass.com/Mentra-Community/MentraOS/releases/mentra-builds-v3.2.1/mentra-live-ota-3.2.1-beta.373.json"
-    const val OTA_MANIFEST_SHA256: String = "25529f33b89d378b1009b2a90f51ef2d971eb365d126769f74b2b37c699f9520"
+    const val RELEASE_IDENTITY: String = "3.2.1-beta.386"
+    const val RELEASE_SET_ID: String = "mentra-3.2.1-beta.386"
+    const val SOURCE_COMMIT: String = "447155847a6e3f268b9f8dcfd664aee9b59cfb68"
+    const val OTA_MANIFEST_URL: String = "https://artifactscdn.mentraglass.com/Mentra-Community/MentraOS/releases/mentra-builds-v3.2.1/mentra-live-ota-3.2.1-beta.386.json"
+    const val OTA_MANIFEST_SHA256: String = "33fba6c95820df3762605aabe9ae04d45268430e0938cf136ff4716b8bd2a64c"
 }

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

@@ -1370,8 +1370,8 @@ class G1 : SGCManager() {
         context!!.registerReceiver(bondingReceiver, filter)
         isBondingReceiverRegistered = true
 
-        preferredG1DeviceId = DeviceStore.get("bluetooth", "device_name") as String?
-
+        // Keep the target supplied by connectById. device_name still belongs to
+        // the previous pairing until DeviceManager promotes the ready device.
         if (!bluetoothAdapter!!.isEnabled()) {
             return
         }

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

@@ -1364,17 +1364,18 @@ class G2 : SGCManager() {
     // Map device names to serial numbers (populated from manufacturer data during scan)
     private val deviceNameToSerialNumber = mutableMapOf<String, String>()
 
-    // Saved addresses for reconnection
+    // Scope each side's address to the selected serial. Legacy global addresses have
+    // no trustworthy owner, so the first connection after upgrading learns them by scan.
     private var leftGlassAddress: String?
         get() =
             context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
-                .getString(KEY_LEFT_ADDRESS, null)
+                .getString("$KEY_LEFT_ADDRESS:$DEVICE_SEARCH_ID", null)
         set(value) {
             context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
                 .edit()
                 .apply {
-                    if (value != null) putString(KEY_LEFT_ADDRESS, value)
-                    else remove(KEY_LEFT_ADDRESS)
+                    if (value != null) putString("$KEY_LEFT_ADDRESS:$DEVICE_SEARCH_ID", value)
+                    else remove("$KEY_LEFT_ADDRESS:$DEVICE_SEARCH_ID")
                 }
                 .apply()
         }
@@ -1382,13 +1383,13 @@ class G2 : SGCManager() {
     private var rightGlassAddress: String?
         get() =
             context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
-                .getString(KEY_RIGHT_ADDRESS, null)
+                .getString("$KEY_RIGHT_ADDRESS:$DEVICE_SEARCH_ID", null)
         set(value) {
             context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
                 .edit()
                 .apply {
-                    if (value != null) putString(KEY_RIGHT_ADDRESS, value)
-                    else remove(KEY_RIGHT_ADDRESS)
+                    if (value != null) putString("$KEY_RIGHT_ADDRESS:$DEVICE_SEARCH_ID", value)
+                    else remove("$KEY_RIGHT_ADDRESS:$DEVICE_SEARCH_ID")
                 }
                 .apply()
         }

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

@@ -2148,7 +2148,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
@@ -6163,7 +6163,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)
@@ -6625,6 +6626,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) {
@@ -6659,13 +6668,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

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)
             }

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

@@ -0,0 +1,17 @@
+package com.mentra.bluetoothsdk.sgcs
+
+/** An address is usable only when its accompanying name identifies the requested device. */
+internal object SelectedDeviceAddress {
+    fun resolve(
+        target: String,
+        pendingName: String?,
+        pendingAddress: String?,
+        savedName: String?,
+        savedAddress: String?,
+    ): String? {
+        if (target.isBlank()) return null
+        if (pendingName == target && !pendingAddress.isNullOrBlank()) return pendingAddress
+        if (savedName == target && !savedAddress.isNullOrBlank()) return savedAddress
+        return null
+    }
+}

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

@@ -0,0 +1,59 @@
+package com.mentra.bluetoothsdk
+
+import androidx.test.core.app.ApplicationProvider
+import com.mentra.bluetoothsdk.sgcs.Simulated
+import org.junit.Assert.assertEquals
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.annotation.Config
+import org.robolectric.annotation.LooperMode
+
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [33])
+@LooperMode(LooperMode.Mode.PAUSED)
+class DeviceIdentityPairingTest {
+    @Test fun `readiness promotes a coherent name and address while preserving same-device reconnects`() {
+        Bridge.initialize(ApplicationProvider.getApplicationContext())
+        val saved = listOf("bluetooth", "glasses").associateWith { DeviceStore.store.getCategory(it) }
+        val singleton = DeviceManager::class.java.getDeclaredField("_instance").apply { isAccessible = true }
+        val previous = singleton.get(null)
+        val cases = listOf(
+            // pending name, pending address, saved model, expected address
+            listOf("new", "", "test", ""),
+            listOf("new", "new-address", "test", "new-address"),
+            listOf("old", "", "test", "old-address"),
+            listOf("", "", "test", "old-address"),
+            listOf("old", "", "other-model", ""),
+        )
+        try {
+            for ((pendingName, pendingAddress, savedModel, expectedAddress) in cases) {
+                val manager = DeviceManager(initializeHardware = false)
+                singleton.set(null, manager)
+                manager.sgc = Simulated().apply { type = "test" }
+                DeviceStore.set("bluetooth", "default_wearable", savedModel)
+                DeviceStore.set("bluetooth", "device_name", "old")
+                DeviceStore.set("bluetooth", "device_address", "old-address")
+                DeviceStore.set("bluetooth", "pending_device_name", pendingName)
+                DeviceStore.set("bluetooth", "pending_device_address", pendingAddress)
+                DeviceStore.set("bluetooth", "shouldSendBootingMessage", false)
+                try {
+                    manager.handleDeviceReady()
+                    assertEquals(pendingName.ifEmpty { "old" }, DeviceStore.get("bluetooth", "device_name"))
+                    assertEquals(expectedAddress, DeviceStore.get("bluetooth", "device_address"))
+                    assertEquals("", DeviceStore.get("bluetooth", "pending_device_name"))
+                    assertEquals("", DeviceStore.get("bluetooth", "pending_device_address"))
+                } finally {
+                    manager.disconnect()
+                    manager.cleanup()
+                }
+            }
+        } finally {
+            singleton.set(null, previous)
+            saved.forEach { (category, values) ->
+                (DeviceStore.store.getCategory(category).keys - values.keys).forEach { DeviceStore.store.remove(category, it) }
+                values.forEach { (key, value) -> DeviceStore.set(category, key, value) }
+            }
+        }
+    }
+}

package/android/src/test/java/com/mentra/bluetoothsdk/sgcs/G1PairingTest.kt

@@ -0,0 +1,105 @@
+package com.mentra.bluetoothsdk.sgcs
+
+import android.bluetooth.BluetoothAdapter
+import android.bluetooth.BluetoothDevice
+import android.bluetooth.BluetoothGatt
+import android.bluetooth.BluetoothProfile
+import android.bluetooth.le.ScanResult
+import android.bluetooth.le.ScanSettings
+import android.os.Looper
+import androidx.test.core.app.ApplicationProvider
+import com.mentra.bluetoothsdk.Bridge
+import com.mentra.bluetoothsdk.DeviceStore
+import com.mentra.lc3Lib.Lc3Cpp
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.Shadows.shadowOf
+import org.robolectric.annotation.Config
+import org.robolectric.annotation.Implementation
+import org.robolectric.annotation.Implements
+import org.robolectric.annotation.LooperMode
+import java.util.concurrent.TimeUnit
+
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [33], shadows = [G1PairingTest.ShadowLc3Cpp::class], instrumentedPackages = ["com.mentra.lc3Lib"])
+@LooperMode(LooperMode.Mode.PAUSED)
+class G1PairingTest {
+    @Before
+    fun setup() {
+        Bridge.initialize(ApplicationProvider.getApplicationContext())
+        shadowOf(BluetoothAdapter.getDefaultAdapter()).setState(BluetoothAdapter.STATE_ON)
+    }
+
+    @Test
+    fun `fresh pairing connects the selected G1 without a saved identity`() {
+        assertSelectedGlassesConnect("")
+    }
+
+    @Test
+    fun `pairing from simulated glasses connects the selected G1`() {
+        assertSelectedGlassesConnect("Simulated Glasses")
+    }
+
+    @Test
+    fun `switching G1 pairs ignores the previously saved pair`() {
+        assertSelectedGlassesConnect("12")
+    }
+
+    @Test
+    fun `reconnecting the saved G1 still connects both halves`() {
+        assertSelectedGlassesConnect("47")
+    }
+
+    private fun assertSelectedGlassesConnect(savedName: String) {
+        DeviceStore.set("bluetooth", "device_name", savedName)
+        DeviceStore.set("bluetooth", "pending_device_name", "47")
+        val adapter = BluetoothAdapter.getDefaultAdapter()
+        val scanner = shadowOf(adapter.bluetoothLeScanner)
+        val glasses = G1()
+        try {
+            glasses.connectById("47")
+            val callback = scanner.scanCallbacks.single()
+            val unrelated = device("00:00:00:00:12:01", "Even G1_12_L_000001")
+            val left = device("00:00:00:00:47:01", "Even G1_47_L_000001")
+            val right = device("00:00:00:00:47:02", "Even G1_47_R_000002")
+
+            for (device in listOf(unrelated, left, right)) {
+                callback.onScanResult(
+                    ScanSettings.CALLBACK_TYPE_ALL_MATCHES,
+                    ScanResult(device, null, -50, 0),
+                )
+            }
+            shadowOf(Looper.getMainLooper()).idle()
+            assertTrue("The previously saved pair must not receive a GATT connection", shadowOf(unrelated).bluetoothGatts.isEmpty())
+            assertEquals("Connect the selected left half", 1, shadowOf(left).bluetoothGatts.size)
+            shadowOf(left).simulateGattConnectionChange(BluetoothGatt.GATT_SUCCESS, BluetoothProfile.STATE_CONNECTED)
+            shadowOf(Looper.getMainLooper()).idleFor(2, TimeUnit.SECONDS)
+            assertEquals("Connect the selected right half", 1, shadowOf(right).bluetoothGatts.size)
+            assertTrue("Stop scanning once both selected halves are found", scanner.scanCallbacks.isEmpty())
+            assertEquals("Scanning must not promote an unready pairing", savedName, DeviceStore.get("bluetooth", "device_name"))
+        } finally {
+            glasses.disconnect()
+        }
+    }
+
+    private fun device(address: String, name: String): BluetoothDevice =
+        BluetoothAdapter.getDefaultAdapter().getRemoteDevice(address).also {
+            shadowOf(it).setName(name)
+            shadowOf(it).setAlias(name)
+            shadowOf(it).setBondState(BluetoothDevice.BOND_BONDED)
+        }
+
+    // Pairing tests exercise the real G1 driver; only its unrelated native audio codec is stubbed.
+    @Implements(Lc3Cpp::class)
+    class ShadowLc3Cpp {
+        companion object {
+            @JvmStatic @Implementation fun __staticInitializer__() {}
+            @JvmStatic @Implementation fun initDecoder(): Long = 1L
+            @JvmStatic @Implementation fun freeDecoder(decoderPtr: Long) {}
+        }
+    }
+}

package/android/src/test/java/com/mentra/bluetoothsdk/sgcs/G2PairingTargetTest.kt

@@ -0,0 +1,90 @@
+package com.mentra.bluetoothsdk.sgcs
+
+import android.bluetooth.BluetoothAdapter
+import android.bluetooth.BluetoothGatt
+import android.bluetooth.BluetoothProfile
+import android.bluetooth.le.ScanRecord
+import android.bluetooth.le.ScanResult
+import android.bluetooth.le.ScanSettings
+import android.content.Context
+import android.os.Looper
+import com.mentra.bluetoothsdk.Bridge
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.RuntimeEnvironment
+import org.robolectric.Shadows.shadowOf
+import org.robolectric.annotation.Config
+import org.robolectric.annotation.LooperMode
+import org.robolectric.util.ReflectionHelpers
+import org.robolectric.util.ReflectionHelpers.ClassParameter
+
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [33])
+@LooperMode(LooperMode.Mode.PAUSED)
+class G2PairingTargetTest {
+    @Before fun setup() {
+        Bridge.initialize(RuntimeEnvironment.getApplication())
+        shadowOf(BluetoothAdapter.getDefaultAdapter()).setState(BluetoothAdapter.STATE_ON)
+    }
+
+    @Test fun `unscoped legacy addresses cannot connect a different G2 pair`() {
+        RuntimeEnvironment.getApplication().getSharedPreferences("G2Prefs", Context.MODE_PRIVATE).edit()
+            .putString("g2_leftGlassAddress", "00:00:00:00:01:01")
+            .putString("g2_rightGlassAddress", "00:00:00:00:01:02").apply()
+        val g2 = G2()
+        try {
+            g2.connectById("S2NEW000000001")
+            val adapter = BluetoothAdapter.getDefaultAdapter()
+            assertTrue(shadowOf(adapter.getRemoteDevice("00:00:00:00:01:01")).bluetoothGatts.isEmpty())
+            assertTrue(shadowOf(adapter.getRemoteDevice("00:00:00:00:01:02")).bluetoothGatts.isEmpty())
+            assertEquals(1, shadowOf(adapter.bluetoothLeScanner).scanCallbacks.size)
+        } finally { g2.disconnect() }
+    }
+
+    @Test fun `learned addresses reconnect only their own serial across driver recreation`() {
+        val serial = "S2NEW000000001"
+        val adapter = BluetoothAdapter.getDefaultAdapter()
+        val left = adapter.getRemoteDevice("00:00:00:00:02:01")
+        val right = adapter.getRemoteDevice("00:00:00:00:02:02")
+        shadowOf(left).setName("Even G2_47_L_000001")
+        shadowOf(right).setName("Even G2_47_R_000002")
+        var g2 = G2()
+        try {
+            g2.connectById(serial)
+            val callback = shadowOf(adapter.bluetoothLeScanner).scanCallbacks.single()
+            // Manufacturer record: company ID 0x4552, followed by the advertised serial.
+            val payload = byteArrayOf(0x52, 0x45) + serial.toByteArray(Charsets.US_ASCII)
+            val record = ReflectionHelpers.callStaticMethod<ScanRecord>(
+                ScanRecord::class.java, "parseFromBytes",
+                ClassParameter.from(ByteArray::class.java, byteArrayOf((payload.size + 1).toByte(), 0xff.toByte()) + payload + byteArrayOf(0)),
+            )
+            for (device in listOf(left, right)) {
+                callback.onScanResult(ScanSettings.CALLBACK_TYPE_ALL_MATCHES, ScanResult(device, record, -50, 0))
+            }
+            shadowOf(Looper.getMainLooper()).idle()
+            for (device in listOf(left, right)) {
+                assertEquals(1, shadowOf(device).bluetoothGatts.size)
+                shadowOf(device).simulateGattConnectionChange(BluetoothGatt.GATT_SUCCESS, BluetoothProfile.STATE_CONNECTED)
+            }
+            shadowOf(Looper.getMainLooper()).idle()
+            g2.disconnect()
+
+            g2 = G2()
+            g2.connectById("S2OTHER0000001")
+            assertEquals(1, shadowOf(left).bluetoothGatts.size)
+            assertEquals(1, shadowOf(right).bluetoothGatts.size)
+            assertEquals(1, shadowOf(adapter.bluetoothLeScanner).scanCallbacks.size)
+            g2.disconnect()
+
+            g2 = G2()
+            g2.connectById(serial)
+            assertEquals(2, shadowOf(left).bluetoothGatts.size)
+            assertEquals(2, shadowOf(right).bluetoothGatts.size)
+            assertTrue(shadowOf(adapter.bluetoothLeScanner).scanCallbacks.isEmpty())
+        } finally { g2.disconnect() }
+    }
+}

package/android/src/test/java/com/mentra/bluetoothsdk/sgcs/MentraLivePairingTargetTest.kt

@@ -0,0 +1,65 @@
+package com.mentra.bluetoothsdk.sgcs
+
+import android.bluetooth.BluetoothAdapter
+import android.os.Looper
+import androidx.test.core.app.ApplicationProvider
+import com.mentra.bluetoothsdk.Bridge
+import com.mentra.bluetoothsdk.DeviceStore
+import java.time.Duration
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.Shadows.shadowOf
+import org.robolectric.annotation.Config
+import org.robolectric.annotation.LooperMode
+
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [33], shadows = [G1PairingTest.ShadowLc3Cpp::class], instrumentedPackages = ["com.mentra.lc3Lib"])
+@LooperMode(LooperMode.Mode.PAUSED)
+class MentraLivePairingTargetTest {
+    @Before fun setup() {
+        Bridge.initialize(ApplicationProvider.getApplicationContext())
+        shadowOf(BluetoothAdapter.getDefaultAdapter()).setState(BluetoothAdapter.STATE_ON)
+        DeviceStore.set("bluetooth", "pending_device_name", "MENTRA_LIVE_NEW")
+    }
+
+    @Test fun `name-only selection scans instead of connecting the previous Live`() {
+        assertTarget("MENTRA_LIVE_OLD", "00:00:00:00:00:01", "", scanExpected = true)
+    }
+
+    @Test fun `normal pairing connects the pending Live address`() {
+        assertTarget("MENTRA_LIVE_OLD", "00:00:00:00:00:01", "00:00:00:00:00:02")
+    }
+
+    @Test fun `normal saved Live reconnect keeps the matching address`() {
+        assertTarget("MENTRA_LIVE_NEW", "00:00:00:00:00:02", "")
+    }
+
+    private fun assertTarget(savedName: String, savedAddress: String, pendingAddress: String, scanExpected: Boolean = false) {
+        DeviceStore.set("bluetooth", "device_name", savedName)
+        DeviceStore.set("bluetooth", "device_address", savedAddress)
+        DeviceStore.set("bluetooth", "pending_device_address", pendingAddress)
+        val adapter = BluetoothAdapter.getDefaultAdapter()
+        val old = adapter.getRemoteDevice("00:00:00:00:00:01")
+        val selected = adapter.getRemoteDevice("00:00:00:00:00:02")
+        shadowOf(old).setName("MENTRA_LIVE_OLD")
+        shadowOf(selected).setName("MENTRA_LIVE_NEW")
+        val live = MentraLive()
+        try {
+            live.connectById("MENTRA_LIVE_NEW")
+            shadowOf(Looper.getMainLooper()).idle()
+            assertTrue(shadowOf(old).bluetoothGatts.isEmpty())
+            assertEquals(if (scanExpected) 0 else 1, shadowOf(selected).bluetoothGatts.size)
+            assertEquals(if (scanExpected) 1 else 0, shadowOf(adapter.bluetoothLeScanner).scanCallbacks.size)
+            assertEquals(savedName, DeviceStore.get("bluetooth", "device_name"))
+        } finally {
+            live.destroy()
+            // Robolectric does not deliver the disconnect callback automatically.
+            // Complete the production teardown timeout before another test connects.
+            shadowOf(Looper.getMainLooper()).idleFor(Duration.ofSeconds(2))
+        }
+    }
+}

package/android/src/test/java/com/mentra/bluetoothsdk/sgcs/MentraNexPairingTest.kt

@@ -0,0 +1,151 @@
+package com.mentra.bluetoothsdk.sgcs
+
+import android.bluetooth.BluetoothAdapter
+import android.bluetooth.BluetoothDevice
+import android.bluetooth.BluetoothGatt
+import android.bluetooth.BluetoothProfile
+import android.bluetooth.le.ScanResult
+import android.bluetooth.le.ScanSettings
+import android.os.Looper
+import androidx.test.core.app.ApplicationProvider
+import com.mentra.bluetoothsdk.Bridge
+import com.mentra.bluetoothsdk.DeviceManager
+import com.mentra.bluetoothsdk.DeviceStore
+import com.mentra.bluetoothsdk.utils.DeviceTypes
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.Shadows.shadowOf
+import org.robolectric.annotation.Config
+import org.robolectric.annotation.Implementation
+import org.robolectric.annotation.Implements
+import org.robolectric.annotation.LooperMode
+import org.robolectric.shadows.ShadowBluetoothGatt
+
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [33], shadows = [G1PairingTest.ShadowLc3Cpp::class, MentraNexPairingTest.ShadowNexGatt::class], instrumentedPackages = ["com.mentra.lc3Lib"])
+@LooperMode(LooperMode.Mode.PAUSED)
+class MentraNexPairingTest {
+    // Robolectric implements connection callbacks but not the PHY binder request.
+    @Implements(BluetoothGatt::class)
+    class ShadowNexGatt : ShadowBluetoothGatt() {
+        @Implementation fun setPreferredPhy(txPhy: Int, rxPhy: Int, phyOptions: Int) {}
+    }
+
+    @Before fun setup() {
+        Bridge.initialize(ApplicationProvider.getApplicationContext())
+        shadowOf(BluetoothAdapter.getDefaultAdapter()).setState(BluetoothAdapter.STATE_ON)
+        DeviceStore.set("bluetooth", "pending_device_name", "Nex1-2")
+        DeviceStore.set("bluetooth", "pending_device_address", "")
+        DeviceStore.set("bluetooth", "device_address", "")
+    }
+
+    @Test fun `fresh pairing selects only the requested Nex`() {
+        assertScansSelectedTarget("", "")
+    }
+
+    @Test fun `simulated pairing selects only the requested Nex`() {
+        assertScansSelectedTarget("Simulated Glasses", "")
+    }
+
+    @Test fun `a different saved Nex name and address cannot redirect selection`() {
+        assertScansSelectedTarget("Nex1-1", "00:00:00:00:00:01")
+    }
+
+    @Test fun `pending address targets the new Nex instead of the saved pair`() {
+        assertDirectTarget("Nex1-1", "00:00:00:00:00:01", "00:00:00:00:00:02")
+    }
+
+    @Test fun `saved Nex reconnect retains its address`() {
+        assertDirectTarget("Nex1-2", "00:00:00:00:00:02", "")
+    }
+
+    @Test fun `name-only pairing readiness cannot associate the old MAC with the new Nex`() {
+        DeviceStore.set("bluetooth", "default_wearable", DeviceTypes.NEX)
+        DeviceStore.set("bluetooth", "pending_wearable", DeviceTypes.NEX)
+        DeviceStore.set("bluetooth", "device_name", "Nex1-1")
+        DeviceStore.set("bluetooth", "device_address", "00:00:00:00:00:01")
+        DeviceStore.set("bluetooth", "shouldSendBootingMessage", false)
+        DeviceStore.set("glasses", "fullyBooted", false)
+        val old = device("00:00:00:00:00:01", "Nex1-1")
+        val selected = device("00:00:00:00:00:02", "Nex1-2")
+        val singleton = DeviceManager::class.java.getDeclaredField("_instance").apply { isAccessible = true }
+        val previous = singleton.get(null)
+        val manager = DeviceManager(initializeHardware = false)
+        singleton.set(null, manager)
+        try {
+            var nex = MentraNex()
+            manager.sgc = nex
+            nex.connectById("Nex1-2")
+            val scanner = shadowOf(BluetoothAdapter.getDefaultAdapter().bluetoothLeScanner)
+            scanner.scanCallbacks.single().onScanResult(
+                ScanSettings.CALLBACK_TYPE_ALL_MATCHES, ScanResult(selected, null, -50, 0),
+            )
+            shadowOf(Looper.getMainLooper()).idle()
+            // Drive the actual ready callback and DeviceManager's identity promotion.
+            shadowOf(selected).simulateGattConnectionChange(BluetoothGatt.GATT_SUCCESS, BluetoothProfile.STATE_CONNECTED)
+            assertEquals("Nex1-2", DeviceStore.get("bluetooth", "device_name"))
+            assertEquals("", DeviceStore.get("bluetooth", "device_address"))
+            assertEquals("", DeviceStore.get("bluetooth", "pending_device_name"))
+            manager.disconnect()
+
+            nex = MentraNex()
+            manager.sgc = nex
+            nex.connectById(DeviceStore.get("bluetooth", "device_name") as String)
+            assertTrue(shadowOf(old).bluetoothGatts.isEmpty())
+            scanner.scanCallbacks.single().onScanResult(
+                ScanSettings.CALLBACK_TYPE_ALL_MATCHES, ScanResult(selected, null, -50, 0),
+            )
+            shadowOf(Looper.getMainLooper()).idle()
+            assertEquals(2, shadowOf(selected).bluetoothGatts.size)
+        } finally {
+            manager.disconnect()
+            manager.cleanup()
+            singleton.set(null, previous)
+        }
+    }
+
+    private fun assertScansSelectedTarget(savedName: String, savedAddress: String) {
+        DeviceStore.set("bluetooth", "device_name", savedName)
+        DeviceStore.set("bluetooth", "device_address", savedAddress)
+        val old = device("00:00:00:00:00:01", "Nex1-1")
+        val prefixCollision = device("00:00:00:00:00:03", "Nex1-23")
+        val selected = device("00:00:00:00:00:02", "Nex1-2")
+        val nex = MentraNex()
+        try {
+            nex.connectById("Nex1-2")
+            val scanner = shadowOf(BluetoothAdapter.getDefaultAdapter().bluetoothLeScanner)
+            val callback = scanner.scanCallbacks.single()
+            for (found in listOf(old, prefixCollision, selected)) {
+                callback.onScanResult(ScanSettings.CALLBACK_TYPE_ALL_MATCHES, ScanResult(found, null, -50, 0))
+                shadowOf(Looper.getMainLooper()).idle()
+            }
+            assertTrue(shadowOf(old).bluetoothGatts.isEmpty())
+            assertTrue(shadowOf(prefixCollision).bluetoothGatts.isEmpty())
+            assertEquals(1, shadowOf(selected).bluetoothGatts.size)
+            assertEquals(savedName, DeviceStore.get("bluetooth", "device_name"))
+        } finally { nex.disconnect() }
+    }
+
+    private fun assertDirectTarget(savedName: String, savedAddress: String, pendingAddress: String) {
+        DeviceStore.set("bluetooth", "device_name", savedName)
+        DeviceStore.set("bluetooth", "device_address", savedAddress)
+        DeviceStore.set("bluetooth", "pending_device_address", pendingAddress)
+        val old = device("00:00:00:00:00:01", "Nex1-1")
+        val selected = device("00:00:00:00:00:02", "Nex1-2")
+        val nex = MentraNex()
+        try {
+            nex.connectById("Nex1-2")
+            shadowOf(Looper.getMainLooper()).idle()
+            assertTrue(shadowOf(old).bluetoothGatts.isEmpty())
+            assertEquals(1, shadowOf(selected).bluetoothGatts.size)
+            assertEquals(savedName, DeviceStore.get("bluetooth", "device_name"))
+        } finally { nex.disconnect() }
+    }
+
+    private fun device(address: String, name: String): BluetoothDevice =
+        BluetoothAdapter.getDefaultAdapter().getRemoteDevice(address).also { shadowOf(it).setName(name) }
+}

package/android/src/test/java/com/mentra/bluetoothsdk/sgcs/SelectedDeviceAddressTest.kt

@@ -0,0 +1,27 @@
+package com.mentra.bluetoothsdk.sgcs
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Test
+
+class SelectedDeviceAddressTest {
+    @Test fun `selected pending address wins over saved address`() {
+        assertEquals("new", SelectedDeviceAddress.resolve("LIVE_2", "LIVE_2", "new", "LIVE_1", "old"))
+    }
+
+    @Test fun `a name-only selection cannot use another device's saved address`() {
+        assertNull(SelectedDeviceAddress.resolve("LIVE_2", "LIVE_2", "", "LIVE_1", "old"))
+        assertNull(SelectedDeviceAddress.resolve("Nex1-2", "Nex1-2", null, "Nex1-1", "old"))
+        assertNull(SelectedDeviceAddress.resolve("Nex1-2", null, null, "Simulated Glasses", ""))
+    }
+
+    @Test fun `saved reconnect keeps its address even with an unrelated pending selection`() {
+        assertEquals("old", SelectedDeviceAddress.resolve("LIVE_1", "LIVE_2", "new", "LIVE_1", "old"))
+        assertEquals("old", SelectedDeviceAddress.resolve("Nex1-1", null, null, "Nex1-1", "old"))
+    }
+
+    @Test fun `empty or mismatched identities never supply an address`() {
+        assertNull(SelectedDeviceAddress.resolve("", "", "new", "", "old"))
+        assertNull(SelectedDeviceAddress.resolve("LIVE_2", "LIVE_1", "new", "LIVE_1", "old"))
+    }
+}

package/build/generated/releaseMetadata.js

@@ -1,10 +1,10 @@
 export const BLUETOOTH_SDK_RELEASE_METADATA = Object.freeze({
     "schemaVersion": 1,
     "familyBaseVersion": "3.2.1",
-    "releaseIdentity": "3.2.1-beta.373",
-    "releaseSetId": "mentra-3.2.1-beta.373",
-    "sourceCommit": "d60eecea0008160ce942b298f87a2d805ab3a2a6",
-    "otaManifestUrl": "https://artifactscdn.mentraglass.com/Mentra-Community/MentraOS/releases/mentra-builds-v3.2.1/mentra-live-ota-3.2.1-beta.373.json",
-    "otaManifestSha256": "25529f33b89d378b1009b2a90f51ef2d971eb365d126769f74b2b37c699f9520"
+    "releaseIdentity": "3.2.1-beta.386",
+    "releaseSetId": "mentra-3.2.1-beta.386",
+    "sourceCommit": "447155847a6e3f268b9f8dcfd664aee9b59cfb68",
+    "otaManifestUrl": "https://artifactscdn.mentraglass.com/Mentra-Community/MentraOS/releases/mentra-builds-v3.2.1/mentra-live-ota-3.2.1-beta.386.json",
+    "otaManifestSha256": "33fba6c95820df3762605aabe9ae04d45268430e0938cf136ff4716b8bd2a64c"
 });
 //# sourceMappingURL=releaseMetadata.js.map

package/build/generated/releaseMetadata.js.map

@@ -1 +1 @@
-{"version":3,"file":"releaseMetadata.js","sourceRoot":"","sources":["../../src/generated/releaseMetadata.ts"],"names":[],"mappings":"AAWA,MAAM,CAAC,MAAM,8BAA8B,GAA0C,MAAM,CAAC,MAAM,CAAC;IACjG,eAAe,EAAE,CAAC;IAClB,mBAAmB,EAAE,OAAO;IAC5B,iBAAiB,EAAE,gBAAgB;IACnC,cAAc,EAAE,uBAAuB;IACvC,cAAc,EAAE,0CAA0C;IAC1D,gBAAgB,EAAE,kIAAkI;IACpJ,mBAAmB,EAAE,kEAAkE;CACxF,CAAC,CAAA","sourcesContent":["/** Generated by release CI. Do not edit in a release checkout. */\nexport interface BluetoothSdkReleaseMetadata {\n  schemaVersion: 1\n  familyBaseVersion: string | null\n  releaseIdentity: string | null\n  releaseSetId: string | null\n  sourceCommit: string | null\n  otaManifestUrl: string | null\n  otaManifestSha256: string | null\n}\n\nexport const BLUETOOTH_SDK_RELEASE_METADATA: Readonly<BluetoothSdkReleaseMetadata> = Object.freeze({\n  \"schemaVersion\": 1,\n  \"familyBaseVersion\": \"3.2.1\",\n  \"releaseIdentity\": \"3.2.1-beta.373\",\n  \"releaseSetId\": \"mentra-3.2.1-beta.373\",\n  \"sourceCommit\": \"d60eecea0008160ce942b298f87a2d805ab3a2a6\",\n  \"otaManifestUrl\": \"https://artifactscdn.mentraglass.com/Mentra-Community/MentraOS/releases/mentra-builds-v3.2.1/mentra-live-ota-3.2.1-beta.373.json\",\n  \"otaManifestSha256\": \"25529f33b89d378b1009b2a90f51ef2d971eb365d126769f74b2b37c699f9520\"\n})\n"]}
+{"version":3,"file":"releaseMetadata.js","sourceRoot":"","sources":["../../src/generated/releaseMetadata.ts"],"names":[],"mappings":"AAWA,MAAM,CAAC,MAAM,8BAA8B,GAA0C,MAAM,CAAC,MAAM,CAAC;IACjG,eAAe,EAAE,CAAC;IAClB,mBAAmB,EAAE,OAAO;IAC5B,iBAAiB,EAAE,gBAAgB;IACnC,cAAc,EAAE,uBAAuB;IACvC,cAAc,EAAE,0CAA0C;IAC1D,gBAAgB,EAAE,kIAAkI;IACpJ,mBAAmB,EAAE,kEAAkE;CACxF,CAAC,CAAA","sourcesContent":["/** Generated by release CI. Do not edit in a release checkout. */\nexport interface BluetoothSdkReleaseMetadata {\n  schemaVersion: 1\n  familyBaseVersion: string | null\n  releaseIdentity: string | null\n  releaseSetId: string | null\n  sourceCommit: string | null\n  otaManifestUrl: string | null\n  otaManifestSha256: string | null\n}\n\nexport const BLUETOOTH_SDK_RELEASE_METADATA: Readonly<BluetoothSdkReleaseMetadata> = Object.freeze({\n  \"schemaVersion\": 1,\n  \"familyBaseVersion\": \"3.2.1\",\n  \"releaseIdentity\": \"3.2.1-beta.386\",\n  \"releaseSetId\": \"mentra-3.2.1-beta.386\",\n  \"sourceCommit\": \"447155847a6e3f268b9f8dcfd664aee9b59cfb68\",\n  \"otaManifestUrl\": \"https://artifactscdn.mentraglass.com/Mentra-Community/MentraOS/releases/mentra-builds-v3.2.1/mentra-live-ota-3.2.1-beta.386.json\",\n  \"otaManifestSha256\": \"33fba6c95820df3762605aabe9ae04d45268430e0938cf136ff4716b8bd2a64c\"\n})\n"]}

package/ios/Source/BluetoothSdkDefaults.swift

@@ -16,7 +16,7 @@ enum BluetoothSdkDefaults {
     /// silently disable it on every pair the app touches.
     static let autoPowerOffEnabled = false
     private static let infoSdkVersionKey = "MentraBluetoothSdkVersion"
-    private static let swiftPackageSdkVersion = "3.2.1-beta.373"
+    private static let swiftPackageSdkVersion = "3.2.1-beta.386"
     private static let swiftPackageSdkVersionPlaceholder = "__MENTRA" + "_BLUETOOTH_SDK_VERSION__"
 
     private static func normalizedSdkVersion(_ value: String?) -> String? {

package/ios/Source/DeviceManager.swift

@@ -998,12 +998,16 @@ struct ViewState {
         Bridge.log("MAN: handleDeviceReady(): \(sgc.type)")
         resetMicHealth()
 
+        // A new identity must never inherit the previous glasses' address when
+        // pairing supplied only a name. Same-device reconnects retain their cache.
+        let identityChanged = !pendingDeviceName.isEmpty &&
+            (pendingDeviceName != deviceName || sgc.type != defaultWearable)
+        if identityChanged || !pendingDeviceAddress.isEmpty {
+            deviceAddress = pendingDeviceAddress
+        }
         if !pendingDeviceName.isEmpty {
             deviceName = pendingDeviceName
         }
-        if !pendingDeviceAddress.isEmpty {
-            deviceAddress = pendingDeviceAddress
-        }
         clearPendingConnection()
         defaultWearable = sgc.type
         searching = false

package/ios/Source/GeneratedReleaseMetadata.swift

@@ -3,9 +3,9 @@ import Foundation
 /// Generated by release CI. Do not edit in a release checkout.
 enum GeneratedReleaseMetadata {
     static let familyBaseVersion = "3.2.1"
-    static let releaseIdentity = "3.2.1-beta.373"
-    static let releaseSetId = "mentra-3.2.1-beta.373"
-    static let sourceCommit = "d60eecea0008160ce942b298f87a2d805ab3a2a6"
-    static let otaManifestUrl = "https://artifactscdn.mentraglass.com/Mentra-Community/MentraOS/releases/mentra-builds-v3.2.1/mentra-live-ota-3.2.1-beta.373.json"
-    static let otaManifestSha256 = "25529f33b89d378b1009b2a90f51ef2d971eb365d126769f74b2b37c699f9520"
+    static let releaseIdentity = "3.2.1-beta.386"
+    static let releaseSetId = "mentra-3.2.1-beta.386"
+    static let sourceCommit = "447155847a6e3f268b9f8dcfd664aee9b59cfb68"
+    static let otaManifestUrl = "https://artifactscdn.mentraglass.com/Mentra-Community/MentraOS/releases/mentra-builds-v3.2.1/mentra-live-ota-3.2.1-beta.386.json"
+    static let otaManifestSha256 = "33fba6c95820df3762605aabe9ae04d45268430e0938cf136ff4716b8bd2a64c"
 }

package/ios/Source/sgcs/G1.swift

@@ -468,8 +468,10 @@ class G1: NSObject, SGCManager {
         set {
             if let newValue = newValue {
                 UserDefaults.standard.set(newValue.uuidString, forKey: "leftGlassUUID")
+                UserDefaults.standard.set(DEVICE_SEARCH_ID, forKey: "leftGlassSearchID")
             } else {
                 UserDefaults.standard.removeObject(forKey: "leftGlassUUID")
+                UserDefaults.standard.removeObject(forKey: "leftGlassSearchID")
             }
         }
     }
@@ -484,8 +486,10 @@ class G1: NSObject, SGCManager {
         set {
             if let newValue = newValue {
                 UserDefaults.standard.set(newValue.uuidString, forKey: "rightGlassUUID")
+                UserDefaults.standard.set(DEVICE_SEARCH_ID, forKey: "rightGlassSearchID")
             } else {
                 UserDefaults.standard.removeObject(forKey: "rightGlassUUID")
+                UserDefaults.standard.removeObject(forKey: "rightGlassSearchID")
             }
         }
     }
@@ -2401,17 +2405,22 @@ extension G1: CBCentralManagerDelegate, CBPeripheralDelegate {
         }
 
         Bridge.log("G1: 🔵 Attempting to connect by UUID")
-        var foundAny = false
+        var foundSides = 0
 
         if let leftUUID = leftGlassUUID {
             Bridge.log("G1: 🔵 Found stored left glass UUID: \(leftUUID.uuidString)")
             let leftDevices = centralManager!.retrievePeripherals(withIdentifiers: [leftUUID])
 
-            if let leftDevice = leftDevices.first {
+            if let leftDevice = leftDevices.first,
+               G1ConnectionTarget.matchesCachedPeripheral(
+                   name: leftDevice.name, searchID: DEVICE_SEARCH_ID,
+                   cachedSearchID: UserDefaults.standard.string(forKey: "leftGlassSearchID")
+               )
+            {
                 Bridge.log(
                     "G1: 🔵 Successfully retrieved left glass: \(leftDevice.name ?? "Unknown")"
                 )
-                foundAny = true
+                foundSides += 1
                 leftPeripheral = leftDevice
                 leftDevice.delegate = self
                 centralManager!.connect(
@@ -2428,11 +2437,16 @@ extension G1: CBCentralManagerDelegate, CBPeripheralDelegate {
             Bridge.log("G1: 🔵 Found stored right glass UUID: \(rightUUID.uuidString)")
             let rightDevices = centralManager!.retrievePeripherals(withIdentifiers: [rightUUID])
 
-            if let rightDevice = rightDevices.first {
+            if let rightDevice = rightDevices.first,
+               G1ConnectionTarget.matchesCachedPeripheral(
+                   name: rightDevice.name, searchID: DEVICE_SEARCH_ID,
+                   cachedSearchID: UserDefaults.standard.string(forKey: "rightGlassSearchID")
+               )
+            {
                 Bridge.log(
                     "G1: 🔵 Successfully retrieved right glass: \(rightDevice.name ?? "Unknown")"
                 )
-                foundAny = true
+                foundSides += 1
                 rightPeripheral = rightDevice
                 rightDevice.delegate = self
                 centralManager!.connect(
@@ -2445,7 +2459,8 @@ extension G1: CBCentralManagerDelegate, CBPeripheralDelegate {
             }
         }
 
-        return foundAny
+        // Continue scanning if only one matching cached half was available.
+        return foundSides == 2
     }
 
     func peripheral(_ peripheral: CBPeripheral, didDiscoverServices _: Error?) {

package/ios/Source/sgcs/G1ConnectionTarget.swift

@@ -0,0 +1,13 @@
+import Foundation
+
+enum G1ConnectionTarget {
+    /// A legacy UUID needs a matching peripheral name; newly recorded UUIDs can
+    /// also reconnect without a name because their search ID was saved with them.
+    static func matchesCachedPeripheral(name: String?, searchID: String, cachedSearchID: String?) -> Bool {
+        guard searchID != "NOT_SET", searchID.count > 2 else { return false }
+        if let name, !name.isEmpty {
+            return name.contains("G1" + searchID)
+        }
+        return cachedSearchID == searchID
+    }
+}

package/ios/Source/sgcs/Mach1.swift

@@ -133,6 +133,15 @@ class Mach1: UltraliteBaseViewController, SGCManager {
 
     /// Store discovered peripherals by their identifier
     private var discoveredPeripherals: [String: CBPeripheral] = [:]
+    private var selectedPeripheralID: String?
+
+    private var currentDeviceMatchesSelection: Bool {
+        guard let selectedPeripheralID else { return true }
+        let currentDevice = UltraliteManager.shared.currentDevice
+        return VuzixConnectionTarget.matches(
+            name: currentDevice?.peripheral?.name ?? currentDevice?.getName(), target: selectedPeripheralID
+        )
+    }
 
     private var textHandle: Int?
     private var tapTextHandle: Int?
@@ -146,6 +155,7 @@ class Mach1: UltraliteBaseViewController, SGCManager {
         if setupDone { return }
         isConnectedListener = BondListener(listener: { [weak self] value in
             guard let self else { return }
+            guard !value || self.currentDeviceMatchesSelection else { return }
             Bridge.log("MACH1: isConnectedListener: \(value)")
 
             if value {
@@ -171,6 +181,7 @@ class Mach1: UltraliteBaseViewController, SGCManager {
 
         batteryLevelListener = BondListener(listener: { [weak self] value in
             guard let self else { return }
+            guard self.currentDeviceMatchesSelection else { return }
             Bridge.log("MACH1: batteryLevelListener: \(value)")
             batteryLevel = value
             DeviceStore.shared.apply("glasses", "batteryLevel", value)
@@ -238,23 +249,22 @@ class Mach1: UltraliteBaseViewController, SGCManager {
 
         // Extract the ID from the device name if it contains brackets
         // e.g., "Vuzix Z100 [f1b87c]" -> "f1b87c"
-        var peripheralId = id
-        if let deviceId = id.split(separator: "[").last?.split(separator: "]").first {
-            peripheralId = String(deviceId)
-        }
+        let peripheralId = VuzixConnectionTarget.identifier(id)
+        selectedPeripheralID = peripheralId
 
         let isLinked = UltraliteManager.shared.isLinked.value
         let currentDevice = UltraliteManager.shared.currentDevice
         let isConnected =
             isLinked && currentDevice != nil && currentDevice!.isPaired
                 && currentDevice!.isConnected.value
-        let peripheral = discoveredPeripherals[peripheralId] ?? currentDevice?.peripheral
+        let matchesSelection = currentDeviceMatchesSelection
+        let peripheral = discoveredPeripherals[peripheralId] ?? (matchesSelection ? currentDevice?.peripheral : nil)
 
         // Bind listeners to get notified when device connects
         UltraliteManager.shared.currentDevice?.isConnected.bind(listener: isConnectedListener!)
         UltraliteManager.shared.currentDevice?.batteryLevel.bind(listener: batteryLevelListener!)
 
-        if isConnected {
+        if isConnected && matchesSelection {
             // Already connected, request control now
             let gotControl = currentDevice?.requestControl(
                 layout: UltraliteSDK.Ultralite.Layout.textBottomLeftAlign, timeout: 0,
@@ -266,7 +276,7 @@ class Mach1: UltraliteBaseViewController, SGCManager {
             return
         }
 
-        if !isLinked {
+        if !isLinked || !matchesSelection {
             if peripheral == nil {
                 Bridge.log("Mach1Manager: No peripheral found or stored with ID: \(peripheralId)")
                 CONNECTING_DEVICE = peripheralId
@@ -279,6 +289,8 @@ class Mach1: UltraliteBaseViewController, SGCManager {
             UltraliteManager.shared.stopScan()
             CONNECTING_DEVICE = ""
 
+            // Replace the SDK link only after finding the explicitly selected device.
+            if isLinked { UltraliteManager.shared.unlink() }
             UltraliteManager.shared.link(device: peripheral!, callback: linked)
             UltraliteManager.shared.currentDevice?.isConnected.bind(listener: isConnectedListener!)
             UltraliteManager.shared.currentDevice?.batteryLevel.bind(

package/ios/Source/sgcs/MentraLive.swift

@@ -5286,7 +5286,8 @@ class MentraLive: NSObject, SGCManager {
         if let requestId {
             json["request_id"] = requestId
         }
-        sendJson(json)
+        // Wake ASG so the version request and its response can finish after idle.
+        sendJson(json, wakeUp: true)
     }
 
     private func sendCoreTokenToAsgClient() {

package/ios/Source/sgcs/MentraNex.swift

@@ -994,7 +994,7 @@ class MentraNexSGC: NSObject, CBCentralManagerDelegate, CBPeripheralDelegate, SG
         // global "last" one. peripheralToConnectName == nil means an auto-reconnect with no
         // specific target, so the cached device is exactly what we want — keep using it.)
         if let targetName = peripheralToConnectName,
-           !(peripheralToConnect.name?.contains(targetName) ?? false)
+           peripheralToConnect.name != targetName
         {
             Bridge.log(
                 "NEX-CONN: 🔵 Stored UUID is '\(peripheralToConnect.name ?? "unnamed")' but target is '\(targetName)'. Skipping UUID fast-path; will scan for the target."
@@ -1088,7 +1088,7 @@ class MentraNexSGC: NSObject, CBCentralManagerDelegate, CBPeripheralDelegate, SG
             ])
             if let targetName = peripheralToConnectName,
                let existingPeripheral = connectedPeripherals.first(where: {
-                   $0.name?.contains(targetName) == true
+                   $0.name == targetName
                })
             {
                 Bridge.log(
@@ -2724,35 +2724,12 @@ class MentraNexSGC: NSObject, CBCentralManagerDelegate, CBPeripheralDelegate, SG
         // Always emit the discovered device for the UI list
         emitDiscoveredDevice(deviceName)
 
-        // Auto-connect logic based on target or saved device (from Java MentraNexSGC)
-        var shouldConnect = false
-        var connectionReason = ""
-
-        // Check if this matches our target device name for connection
-        if let targetName = peripheralToConnectName, deviceName.contains(targetName) {
-            shouldConnect = true
-            connectionReason = "Target device name match: \(targetName)"
-        }
-        // During a user-initiated discovery scan, only list devices — never auto-connect a
-        // saved/preferred device, so the user can pick a different one.
-        else if isDiscoveryScan {
-            shouldConnect = false
-        }
-        // Check if this matches our saved device for reconnection
-        else if let savedName = savedDeviceName, deviceName == savedName {
-            shouldConnect = true
-            connectionReason = "Saved device reconnection: \(savedName)"
-        }
-        // Check if this matches preferred device ID
-        else if let preferredId = preferredDeviceId {
-            if let extractedId = extractDeviceId(from: deviceName), extractedId == preferredId {
-                shouldConnect = true
-                connectionReason = "Preferred device ID match: \(preferredId)"
-            }
-        }
-
-        if shouldConnect {
-            connectToFoundDevice(peripheral, reason: connectionReason)
+        if NexConnectionTarget.shouldConnect(
+            name: deviceName, target: peripheralToConnectName, discoveryOnly: isDiscoveryScan,
+            savedName: savedDeviceName, preferredID: preferredDeviceId,
+            discoveredID: extractDeviceId(from: deviceName)
+        ) {
+            connectToFoundDevice(peripheral, reason: "Selected target or saved reconnect identity")
         }
     }
 

package/ios/Source/sgcs/NexConnectionTarget.swift

@@ -0,0 +1,15 @@
+import Foundation
+
+enum NexConnectionTarget {
+    static func shouldConnect(
+        name: String, target: String?, discoveryOnly: Bool,
+        savedName: String?, preferredID: String?, discoveredID: String?
+    ) -> Bool {
+        guard !discoveryOnly else { return false }
+        // An explicit selection is authoritative even when it does not match.
+        // Saved-device fallbacks are only for reconnecting without a selection.
+        if let target { return !target.isEmpty && name == target }
+        if let savedName, !savedName.isEmpty, name == savedName { return true }
+        return preferredID != nil && preferredID == discoveredID
+    }
+}

package/ios/Source/sgcs/VuzixConnectionTarget.swift

@@ -0,0 +1,15 @@
+import Foundation
+
+enum VuzixConnectionTarget {
+    static func identifier(_ name: String) -> String {
+        guard let start = name.lastIndex(of: "["),
+              let end = name[start...].firstIndex(of: "]")
+        else { return name }
+        return String(name[name.index(after: start) ..< end])
+    }
+
+    static func matches(name: String?, target: String) -> Bool {
+        guard let name, !target.isEmpty else { return false }
+        return identifier(name) == identifier(target)
+    }
+}

package/ios/Tests/DeviceIdentityPairingTests.swift

@@ -0,0 +1,49 @@
+@testable import MentraBluetoothSDK
+import XCTest
+
+@MainActor
+final class DeviceIdentityPairingTests: XCTestCase {
+    func testReadinessPromotesCoherentIdentityAndPreservesSameDeviceReconnects() {
+        let store = DeviceStore.shared.store
+        let saved = ["bluetooth", "glasses"].map { ($0, store.getCategory($0)) }
+        defer {
+            for (category, values) in saved {
+                for key in store.getCategory(category).keys where values[key] == nil {
+                    store.remove(category, key)
+                }
+                for (key, value) in values {
+                    store.set(category, key, value)
+                }
+            }
+        }
+        let cases = [
+            // pending name, pending address, saved model, expected address
+            ("new", "", "test", ""),
+            ("new", "new-address", "test", "new-address"),
+            ("old", "", "test", "old-address"),
+            ("", "", "test", "old-address"),
+            ("old", "", "other-model", ""),
+        ]
+        for (pendingName, pendingAddress, savedModel, expectedAddress) in cases {
+            let manager = DeviceManager()
+            let device = Simulated()
+            device.type = "test"
+            manager.sgc = device
+            defer {
+                manager.disconnect()
+                manager.cleanup()
+            }
+            store.set("bluetooth", "default_wearable", savedModel)
+            store.set("bluetooth", "device_name", "old")
+            store.set("bluetooth", "device_address", "old-address")
+            store.set("bluetooth", "pending_device_name", pendingName)
+            store.set("bluetooth", "pending_device_address", pendingAddress)
+            store.set("bluetooth", "shouldSendBootingMessage", false)
+            manager.handleDeviceReady()
+            XCTAssertEqual(DeviceStore.shared.get("bluetooth", "device_name") as? String, pendingName.isEmpty ? "old" : pendingName)
+            XCTAssertEqual(DeviceStore.shared.get("bluetooth", "device_address") as? String, expectedAddress)
+            XCTAssertEqual(DeviceStore.shared.get("bluetooth", "pending_device_name") as? String, "")
+            XCTAssertEqual(DeviceStore.shared.get("bluetooth", "pending_device_address") as? String, "")
+        }
+    }
+}

package/ios/Tests/SGCConnectionTargetTests.swift

@@ -0,0 +1,48 @@
+@testable import MentraBluetoothSDK
+import XCTest
+
+final class SGCConnectionTargetTests: XCTestCase {
+    func testG1RejectsAnotherPairsLegacyUUID() {
+        XCTAssertFalse(G1ConnectionTarget.matchesCachedPeripheral(name: "Even G1_12_L_123456", searchID: "_47_", cachedSearchID: nil))
+        XCTAssertTrue(G1ConnectionTarget.matchesCachedPeripheral(name: "Even G1_47_L_123456", searchID: "_47_", cachedSearchID: nil))
+        XCTAssertFalse(G1ConnectionTarget.matchesCachedPeripheral(name: "Even G1_470_R_123456", searchID: "_47_", cachedSearchID: nil))
+    }
+
+    func testG1NamelessBackgroundReconnectRequiresRecordedTarget() {
+        XCTAssertTrue(G1ConnectionTarget.matchesCachedPeripheral(name: nil, searchID: "_47_", cachedSearchID: "_47_"))
+        XCTAssertFalse(G1ConnectionTarget.matchesCachedPeripheral(name: nil, searchID: "_47_", cachedSearchID: "_12_"))
+        XCTAssertFalse(G1ConnectionTarget.matchesCachedPeripheral(name: nil, searchID: "_47_", cachedSearchID: nil))
+        XCTAssertFalse(G1ConnectionTarget.matchesCachedPeripheral(name: "Even G1_12_L_123456", searchID: "_47_", cachedSearchID: "_47_"))
+        XCTAssertFalse(G1ConnectionTarget.matchesCachedPeripheral(name: nil, searchID: "NOT_SET", cachedSearchID: "NOT_SET"))
+    }
+
+    func testNexExplicitSelectionExcludesSavedAndPreferredFallbacks() {
+        XCTAssertFalse(nex(name: "Nex1-old", target: "Nex1-new"))
+        XCTAssertFalse(nex(name: "Nex1-new-extra", target: "Nex1-new"))
+        XCTAssertTrue(nex(name: "Nex1-new", target: "Nex1-new"))
+        XCTAssertFalse(nex(name: "Nex1-old", target: ""))
+    }
+
+    func testNexDiscoveryNeverConnectsAndSavedReconnectStillWorks() {
+        XCTAssertFalse(nex(name: "Nex1-old", target: nil, discovery: true))
+        XCTAssertFalse(nex(name: "Nex1-new", target: "Nex1-new", discovery: true))
+        XCTAssertTrue(nex(name: "Nex1-old", target: nil))
+        XCTAssertTrue(nex(name: "Nex1-renamed", target: nil))
+    }
+
+    func testVuzixCurrentLinkMustMatchTheSelectedBracketedID() {
+        XCTAssertTrue(VuzixConnectionTarget.matches(name: "Vuzix Z100 [abc123]", target: "abc123"))
+        XCTAssertTrue(VuzixConnectionTarget.matches(name: "Vuzix Z100 [abc123]", target: "Vuzix Z100 [abc123]"))
+        XCTAssertFalse(VuzixConnectionTarget.matches(name: "Vuzix Z100 [old123]", target: "abc123"))
+        XCTAssertFalse(VuzixConnectionTarget.matches(name: nil, target: "abc123"))
+        XCTAssertFalse(VuzixConnectionTarget.matches(name: "", target: ""))
+        XCTAssertEqual(VuzixConnectionTarget.identifier("abc123"), "abc123")
+    }
+
+    private func nex(name: String, target: String?, discovery: Bool = false) -> Bool {
+        NexConnectionTarget.shouldConnect(
+            name: name, target: target, discoveryOnly: discovery,
+            savedName: "Nex1-old", preferredID: "old", discoveredID: "old"
+        )
+    }
+}

package/ios/Tests/VersionInfoCommandTests.swift

@@ -0,0 +1,53 @@
+@testable import MentraBluetoothSDK
+import XCTest
+
+@MainActor
+private final class VersionInfoCommandTransport: MentraLive {
+    var requestId: String?
+
+    override func sendJson(_ jsonOriginal: [String: Any], wakeUp: Bool, requireAck: Bool) {
+        XCTAssertEqual(jsonOriginal["type"] as? String, "request_version")
+        XCTAssertTrue(wakeUp, "An idle ASG must wake to finish its version response")
+        XCTAssertTrue(requireAck)
+        do {
+            let bytes = try JSONSerialization.data(withJSONObject: jsonOriginal)
+            let command = try XCTUnwrap(JSONSerialization.jsonObject(with: bytes) as? [String: Any])
+            let id = try XCTUnwrap(command["request_id"] as? String)
+            requestId = id
+            let common: [String: Any] = ["request_id": id, "sid": "asg-1", "chunkCount": 2]
+            for chunk: [String: Any] in [
+                ["type": "version_info_1", "chunkIndex": 1, "final": false,
+                 "build_number": "303000008", "app_version": "3.3.0"],
+                ["type": "version_info_3", "chunkIndex": 2, "final": true,
+                 "bes_fw_version": "26.9.23.0", "mtk_fw_version": "MentraLive_20260921.0"],
+            ] {
+                let response = common.merging(chunk) { _, value in value }
+                try processReceivedData(JSONSerialization.data(withJSONObject: response))
+            }
+        } catch {
+            XCTFail("Could not replay version request: \(error)")
+        }
+    }
+}
+
+@MainActor
+final class VersionInfoCommandTests: XCTestCase {
+    func testPublicVersionRequestWakesGlassesAndCombinesBothResponseChunks() async throws {
+        let previous = DeviceManager.shared.sgc
+        let transport = VersionInfoCommandTransport()
+        DeviceManager.shared.sgc = transport
+        let sdk = MentraBluetoothSDK()
+        defer {
+            sdk.invalidate()
+            DeviceManager.shared.sgc = previous
+        }
+
+        let result = try await sdk.requestVersionInfo()
+
+        XCTAssertNotNil(transport.requestId)
+        XCTAssertEqual(result.buildNumber, "303000008")
+        XCTAssertEqual(result.appVersion, "3.3.0")
+        XCTAssertEqual(result.besFirmwareVersion, "26.9.23.0")
+        XCTAssertEqual(result.mtkFirmwareVersion, "MentraLive_20260921.0")
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mentra/bluetooth-sdk",
-  "version": "3.2.1-beta.373",
+  "version": "3.2.1-beta.386",
   "description": "SDK for communicating with smart glasses",
   "main": "build/index.js",
   "react-native": "src/index.ts",
@@ -114,7 +114,7 @@
     "registry": "https://registry.npmjs.org/"
   },
   "dependencies": {
-    "@mentra/cloud-protocol": "3.2.1-beta.373"
+    "@mentra/cloud-protocol": "3.2.1-beta.386"
   },
   "devDependencies": {
     "@types/node": "^25.9.3",

package/src/generated/releaseMetadata.ts

@@ -12,9 +12,9 @@ export interface BluetoothSdkReleaseMetadata {
 export const BLUETOOTH_SDK_RELEASE_METADATA: Readonly<BluetoothSdkReleaseMetadata> = Object.freeze({
   "schemaVersion": 1,
   "familyBaseVersion": "3.2.1",
-  "releaseIdentity": "3.2.1-beta.373",
-  "releaseSetId": "mentra-3.2.1-beta.373",
-  "sourceCommit": "d60eecea0008160ce942b298f87a2d805ab3a2a6",
-  "otaManifestUrl": "https://artifactscdn.mentraglass.com/Mentra-Community/MentraOS/releases/mentra-builds-v3.2.1/mentra-live-ota-3.2.1-beta.373.json",
-  "otaManifestSha256": "25529f33b89d378b1009b2a90f51ef2d971eb365d126769f74b2b37c699f9520"
+  "releaseIdentity": "3.2.1-beta.386",
+  "releaseSetId": "mentra-3.2.1-beta.386",
+  "sourceCommit": "447155847a6e3f268b9f8dcfd664aee9b59cfb68",
+  "otaManifestUrl": "https://artifactscdn.mentraglass.com/Mentra-Community/MentraOS/releases/mentra-builds-v3.2.1/mentra-live-ota-3.2.1-beta.386.json",
+  "otaManifestSha256": "33fba6c95820df3762605aabe9ae04d45268430e0938cf136ff4716b8bd2a64c"
 })