@mentra/bluetooth-sdk 3.3.0-dev.382 → 3.3.0-dev.388

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.3.0"
-    const val RELEASE_IDENTITY: String = "3.3.0-dev.382"
-    const val RELEASE_SET_ID: String = "mentra-3.3.0-dev.382"
-    const val SOURCE_COMMIT: String = "6a757abb267592562702b3320cdbb3281e90a59e"
-    const val OTA_MANIFEST_URL: String = "https://artifactscdn.mentraglass.com/Mentra-Community/MentraOS/releases/mentra-builds-v3.3.0/mentra-live-ota-3.3.0-dev.382.json"
-    const val OTA_MANIFEST_SHA256: String = "7d807fb6eea2ed3b6e0fe915decfe79524504752c1c7d8f48b24a3c1e5d56d31"
+    const val RELEASE_IDENTITY: String = "3.3.0-dev.388"
+    const val RELEASE_SET_ID: String = "mentra-3.3.0-dev.388"
+    const val SOURCE_COMMIT: String = "ed07419fbd2a6eeeb9b854fccc1145d3442cf565"
+    const val OTA_MANIFEST_URL: String = "https://artifactscdn.mentraglass.com/Mentra-Community/MentraOS/releases/mentra-builds-v3.3.0/mentra-live-ota-3.3.0-dev.388.json"
+    const val OTA_MANIFEST_SHA256: String = "f240924248f94a3b052c9cc1a45729a9d961e16c6f105dee8bffaf4690c13bdc"
 }

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
@@ -4138,7 +4138,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" ->
@@ -6161,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)
@@ -6623,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) {
@@ -6657,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))
+        }
+    }
+}