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

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

@@ -0,0 +1,120 @@
+package com.mentra.bluetoothsdk.sgcs
+
+import android.os.Looper
+import android.bluetooth.BluetoothGatt
+import android.bluetooth.BluetoothGattCharacteristic
+import java.util.UUID
+import java.util.concurrent.ExecutorService
+import java.util.concurrent.TimeUnit
+import org.junit.Assert.assertTrue
+import org.robolectric.annotation.Implementation
+import org.robolectric.annotation.Implements
+import org.robolectric.shadow.api.Shadow
+import com.mentra.bluetoothsdk.Bridge
+import org.junit.Assert.assertEquals
+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
+
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [28], shadows = [RecordingGatt::class])
+@LooperMode(LooperMode.Mode.PAUSED)
+class G2DisplayThreadTest {
+    @Test fun `worker clear cannot remove containers under the main-thread reconcile loop`() {
+        Bridge.initialize(RuntimeEnvironment.getApplication())
+        val g2 = G2()
+        val add = G2::class.java.declaredMethods.single { it.name == "addTextContainer" }
+        add.isAccessible = true
+        add.invoke(g2, 0, 0, 576, 288, "captions", 0, 0, 0, 0)
+        add.invoke(g2, 10, 10, 100, 40, "HUD", 0, 0, 0, 0)
+        val field = G2::class.java.getDeclaredField("textContainers").apply { isAccessible = true }
+        val containers = field.get(g2) as List<*>
+        // This is the heartbeat's captured index range at the crash site.
+        val indices = containers.indices
+        val worker = Thread { g2.clearDisplay() }
+        worker.start()
+        worker.join()
+        assertEquals(2, containers.size)
+        indices.forEach { containers[it] } // crashed here when clear ran on the worker
+        shadowOf(Looper.getMainLooper()).idle()
+        assertEquals(1, containers.size) // only the positioned HUD husk is purged
+    }
+
+    @Test fun `closing positioned captions clears the live page without waiting for new speech`() {
+        Bridge.initialize(RuntimeEnvironment.getApplication())
+        val g2 = G2()
+        val add = G2::class.java.declaredMethods.single { it.name == "addTextContainer" }
+        add.isAccessible = true
+        add.invoke(g2, 10, 10, 500, 100, "old captions", 0, 0, 0, 0)
+        val page = G2::class.java.getDeclaredField("pageCreated").apply { isAccessible = true }
+        page.setBoolean(g2, true)
+
+        g2.clearDisplay()
+        shadowOf(Looper.getMainLooper()).idle()
+
+        val field = G2::class.java.getDeclaredField("textContainers").apply { isAccessible = true }
+        assertEquals(0, (field.get(g2) as List<*>).size)
+        // No shutdown or deferred recreation: the replacement page is already live,
+        // even if the user remains silent and no new caption frame ever arrives.
+        assertEquals(true, page.getBoolean(g2))
+        g2.clearDisplay()
+        shadowOf(Looper.getMainLooper()).idle()
+        assertEquals(true, page.getBoolean(g2))
+    }
+
+
+    @Test fun `clear transmits an erase before dropping the old caption container and retries busy writes`() {
+        Bridge.initialize(RuntimeEnvironment.getApplication())
+        val g2 = G2()
+        val gatt = Shadow.newInstanceOf(BluetoothGatt::class.java)
+        val recorder = Shadow.extract<RecordingGatt>(gatt)
+        recorder.rejectWrites = 1
+        G2::class.java.getDeclaredField("rightGatt").apply { isAccessible = true }.set(g2, gatt)
+        G2::class.java.getDeclaredField("rightWriteChar").apply { isAccessible = true }.set(
+            g2, BluetoothGattCharacteristic(UUID.randomUUID(), 4, 16)
+        )
+        val add = G2::class.java.declaredMethods.single { it.name == "addTextContainer" }
+        add.isAccessible = true
+        add.invoke(g2, 10, 10, 500, 100, "old captions", 0, 0, 0, 0)
+        G2::class.java.getDeclaredField("pageCreated").apply { isAccessible = true }.setBoolean(g2, true)
+
+        g2.clearDisplay()
+        shadowOf(Looper.getMainLooper()).idle()
+        val executor = G2::class.java.getDeclaredField("bleWriteExecutor").apply { isAccessible = true }
+            .get(g2) as ExecutorService
+        executor.submit {}.get(5, TimeUnit.SECONDS)
+
+        // Transport header is eight bytes; protobuf field 1 is the EvenHub command.
+        val commands = recorder.accepted.map { it[9].toInt() }
+        assertEquals(5, commands.first()) // UPDATE_TEXT_DATA, before REBUILD_PAGE (7)
+        assertTrue(commands.indexOf(7) > 0)
+        assertTrue(String(recorder.accepted.first(), Charsets.UTF_8).contains(" ".repeat(12)))
+        assertTrue(recorder.attempted[0].contentEquals(recorder.attempted[1]))
+        assertEquals(recorder.accepted.size + 1, recorder.attempted.size)
+    }
+
+}
+
+
+@Implements(BluetoothGatt::class)
+class RecordingGatt {
+    var rejectWrites = 0
+    val attempted = mutableListOf<ByteArray>()
+    val accepted = mutableListOf<ByteArray>()
+
+    @Implementation
+    fun writeCharacteristic(characteristic: BluetoothGattCharacteristic): Boolean {
+        val packet = characteristic.value.copyOf()
+        attempted.add(packet)
+        if (rejectWrites > 0) {
+            rejectWrites--
+            return false
+        }
+        accepted.add(packet)
+        return true
+    }
+}

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/MentraLiveClassicDisconnectTest.kt

@@ -0,0 +1,133 @@
+package com.mentra.bluetoothsdk.sgcs
+
+import android.bluetooth.BluetoothA2dp
+import android.bluetooth.BluetoothAdapter
+import android.bluetooth.BluetoothDevice
+import android.bluetooth.BluetoothGatt
+import android.bluetooth.BluetoothHeadset
+import android.bluetooth.BluetoothProfile
+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.assertNull
+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.shadow.api.Shadow
+import org.robolectric.shadows.ShadowBluetoothA2dp
+import org.robolectric.shadows.ShadowBluetoothHeadset
+import org.robolectric.util.ReflectionHelpers
+
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [33], shadows = [G1PairingTest.ShadowLc3Cpp::class,
+    MentraLiveClassicDisconnectTest.RecordingA2dp::class,
+    MentraLiveClassicDisconnectTest.RecordingHeadset::class],
+    instrumentedPackages = ["com.mentra.lc3Lib"])
+@LooperMode(LooperMode.Mode.PAUSED)
+class MentraLiveClassicDisconnectTest {
+    private val adapter = BluetoothAdapter.getDefaultAdapter()
+    private val target = adapter.getRemoteDevice("AA:BB:CC:DD:EE:FF")
+    private val other = adapter.getRemoteDevice("11:22:33:44:55:66")
+    private val a2dp = Shadow.newInstanceOf(BluetoothA2dp::class.java)
+    private val headset = Shadow.newInstanceOf(BluetoothHeadset::class.java)
+    private val audio: RecordingA2dp = Shadow.extract(a2dp)
+    private val handsfree: RecordingHeadset = Shadow.extract(headset)
+
+    @Before fun setup() {
+        Bridge.initialize(ApplicationProvider.getApplicationContext())
+        shadowOf(adapter).setState(BluetoothAdapter.STATE_ON)
+        shadowOf(target).setName("MENTRA_LIVE_TEST")
+        shadowOf(target).setBondState(BluetoothDevice.BOND_BONDED)
+        DeviceStore.set("bluetooth", "device_name", "MENTRA_LIVE_TEST")
+        DeviceStore.set("bluetooth", "device_address", target.address)
+        DeviceStore.set("bluetooth", "pending_device_name", "MENTRA_LIVE_TEST")
+        DeviceStore.set("bluetooth", "pending_device_address", target.address)
+    }
+
+    @Test fun `BLE loss followed by explicit disconnect releases both Classic profiles and keeps bond`() {
+        assertDisconnect(dropBle = true)
+    }
+
+    @Test fun `explicit disconnect with BLE still connected releases both Classic profiles`() {
+        assertDisconnect(dropBle = false)
+    }
+
+    private fun assertDisconnect(dropBle: Boolean) {
+        val live = MentraLive()
+        try {
+            live.connectById("MENTRA_LIVE_TEST")
+            shadowOf(Looper.getMainLooper()).idle()
+            shadowOf(target).simulateGattConnectionChange(BluetoothGatt.GATT_SUCCESS, BluetoothProfile.STATE_CONNECTED)
+            shadowOf(Looper.getMainLooper()).idle()
+            if (dropBle) {
+                shadowOf(target).simulateGattConnectionChange(BluetoothGatt.GATT_SUCCESS, BluetoothProfile.STATE_DISCONNECTED)
+                shadowOf(Looper.getMainLooper()).idle()
+                assertNull(ReflectionHelpers.getField<BluetoothDevice?>(live, "connectedDevice"))
+            }
+            installConnectedProfiles()
+            live.disconnect()
+            shadowOf(Looper.getMainLooper()).idle()
+            assertEquals(listOf(target), audio.disconnected)
+            assertEquals(listOf(target), handsfree.disconnected)
+            assertEquals(BluetoothProfile.STATE_CONNECTED, a2dp.getConnectionState(other))
+            assertEquals(BluetoothProfile.STATE_CONNECTED, headset.getConnectionState(other))
+            assertEquals(BluetoothDevice.BOND_BONDED, target.bondState)
+        } finally {
+            live.destroy()
+            shadowOf(Looper.getMainLooper()).idleFor(Duration.ofSeconds(2))
+        }
+    }
+
+    @Test fun `a manager with no connection session does not disconnect an unrelated bonded device`() {
+        val live = MentraLive()
+        try {
+            installConnectedProfiles()
+            live.disconnect()
+            shadowOf(Looper.getMainLooper()).idle()
+            assertEquals(emptyList<BluetoothDevice>(), audio.disconnected)
+            assertEquals(emptyList<BluetoothDevice>(), handsfree.disconnected)
+        } finally {
+            live.destroy()
+            shadowOf(Looper.getMainLooper()).idleFor(Duration.ofSeconds(2))
+        }
+    }
+
+    private fun installConnectedProfiles() {
+        for (device in listOf(target, other)) {
+            audio.addDevice(device, BluetoothProfile.STATE_CONNECTED)
+            handsfree.addDevice(device, BluetoothProfile.STATE_CONNECTED)
+        }
+        shadowOf(adapter).setProfileProxy(BluetoothProfile.A2DP, a2dp)
+        shadowOf(adapter).setProfileProxy(BluetoothProfile.HEADSET, headset)
+    }
+
+    // The real MentraLive lifecycle runs; only Android's audio profile services are simulated.
+    @Implements(BluetoothA2dp::class)
+    class RecordingA2dp : ShadowBluetoothA2dp() {
+        val disconnected = mutableListOf<BluetoothDevice>()
+        @Implementation fun disconnect(device: BluetoothDevice): Boolean {
+            disconnected.add(device)
+            removeDevice(device)
+            return true
+        }
+    }
+
+    @Implements(BluetoothHeadset::class)
+    class RecordingHeadset : ShadowBluetoothHeadset() {
+        val disconnected = mutableListOf<BluetoothDevice>()
+        @Implementation fun disconnect(device: BluetoothDevice): Boolean {
+            disconnected.add(device)
+            removeDevice(device)
+            return true
+        }
+    }
+}

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

@@ -0,0 +1,55 @@
+package com.mentra.bluetoothsdk.sgcs
+
+import org.junit.Assert.*
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.annotation.Config
+
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [33])
+class MentraLiveFileTransferSessionTest {
+    @Test fun dynamicPayloadUsesTrueSizeEvenWhenDivisibleBy400() {
+        for (pack in listOf(244, 474, 800)) {
+            val session = MentraLive.FileTransferSession("photo", 80000, 2)
+            session.recalculateTotalPackets(pack)
+            assertEquals((80000 + pack - 1) / pack, session.totalPackets)
+            for (index in 0 until session.totalPackets) {
+                assertTrue(session.addPacket(index, ByteArray(minOf(pack, 80000 - index * pack))))
+            }
+            assertTrue(session.isComplete)
+            assertEquals(80000, session.assembleFile()!!.size)
+        }
+    }
+
+    @Test fun legacyInflatedSizeAndLargeUnflaggedPayloads() {
+        // Flag 1 enables batched ACKs but still uses legacy size semantics.
+        for ((pack, headerSize, actualSize, packets) in listOf(
+                listOf(221, 80000, 43982, 200),
+                listOf(400, 80000, 79777, 200),
+                listOf(800, 80000, 80000, 100))) {
+            val session = MentraLive.FileTransferSession("photo", headerSize, 1)
+            session.recalculateTotalPackets(pack)
+            assertEquals(packets, session.totalPackets)
+            val source = ByteArray(actualSize) { (it % 251).toByte() }
+            for (index in (0 until packets).reversed()) {
+                val start = index * pack
+                assertTrue(session.addPacket(index, source.copyOfRange(start, minOf(start + pack, actualSize))))
+            }
+            assertTrue(session.isComplete)
+            assertArrayEquals(source, session.assembleFile())
+        }
+    }
+
+    @Test fun malformedOrDuplicatePacketsCannotCompleteFile() {
+        val session = MentraLive.FileTransferSession("photo", 1000, 2)
+        session.recalculateTotalPackets(800)
+        assertFalse(session.addPacket(0, ByteArray(799)))
+        assertFalse(session.addPacket(2, ByteArray(200)))
+        assertTrue(session.addPacket(1, ByteArray(200)))
+        assertFalse(session.isComplete)
+        assertFalse(session.addPacket(1, ByteArray(200)))
+        assertTrue(session.addPacket(0, ByteArray(800)))
+        assertEquals(1000, session.assembleFile()!!.size)
+    }
+}

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

@@ -78,6 +78,39 @@ class MentraLiveGattCallbackTest {
         assertArrayEquals(byteArrayOf(3, 2), callback.packets[1])
     }
 
+    @Test
+    @Config(sdk = [33])
+    @Suppress("DEPRECATION")
+    fun `modern and legacy callbacks for one notification deliver one packet`() {
+        val queue = ArrayDeque<() -> Unit>()
+        val callback = RecordingCallback({ work -> queue.addLast(work) })
+        val gatt = gatt()
+        val characteristic = BluetoothGattCharacteristic(UUID.randomUUID(), 0, 0)
+        val value = byteArrayOf(0xf1.toByte(), 7, 1, 2)
+        characteristic.value = value
+        callback.onCharacteristicChanged(gatt, characteristic, value)
+        callback.onCharacteristicChanged(gatt, characteristic)
+        value[2] = 9
+        while (queue.isNotEmpty()) queue.removeFirst().invoke()
+        assertEquals(1, callback.packets.size)
+        assertArrayEquals(byteArrayOf(0xf1.toByte(), 7, 1, 2), callback.packets.single())
+    }
+
+    @Test
+    @Config(sdk = [33])
+    fun `separate modern notifications retain identical payloads`() {
+        val queue = ArrayDeque<() -> Unit>()
+        val callback = RecordingCallback({ work -> queue.addLast(work) })
+        val gatt = gatt()
+        val characteristic = BluetoothGattCharacteristic(UUID.randomUUID(), 0, 0)
+        val value = byteArrayOf(1, 2)
+        repeat(2) { callback.onCharacteristicChanged(gatt, characteristic, value) }
+        value[0] = 9
+        while (queue.isNotEmpty()) queue.removeFirst().invoke()
+        assertEquals(2, callback.packets.size)
+        callback.packets.forEach { assertArrayEquals(byteArrayOf(1, 2), it) }
+    }
+
     @Test
     fun `replacement invalidates callbacks already waiting on the lifecycle queue`() {
         val queue = ArrayDeque<() -> Unit>()

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

@@ -0,0 +1,126 @@
+package com.mentra.bluetoothsdk.sgcs
+
+import android.bluetooth.BluetoothAdapter
+import android.bluetooth.BluetoothGattCallback
+import android.bluetooth.BluetoothGattCharacteristic
+import android.os.Looper
+import androidx.test.core.app.ApplicationProvider
+import com.mentra.bluetoothsdk.BluetoothSdkException
+import com.mentra.bluetoothsdk.Bridge
+import com.mentra.bluetoothsdk.DeviceStore
+import java.nio.charset.StandardCharsets
+import java.time.Duration
+import java.util.UUID
+import java.util.concurrent.atomic.AtomicLong
+import org.junit.Assert.*
+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
+import org.robolectric.shadows.ShadowLog
+
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [33], shadows = [G1PairingTest.ShadowLc3Cpp::class], instrumentedPackages = ["com.mentra.lc3Lib"])
+@LooperMode(LooperMode.Mode.PAUSED)
+class MentraLiveIncidentDispatchTest {
+    private val incident = "rep_01M4HBVT88DFSN8TYNZ1WTV4PB"
+    private val apiBase = "https://core.dev.us-west-2.mentraglass.com"
+
+    @Test fun `missing native BLE link rejects even when cached status is connected`() = withLive { live ->
+        DeviceStore.set("glasses", "connected", true)
+        expectCode("glasses_not_connected") { live.sendIncidentId(incident, apiBase) }
+        assertTrue(queuedWrites(live).isEmpty())
+    }
+
+    @Test fun `missing current token does not fall back to old stored credentials`() = withLive { live ->
+        ready(live)
+        DeviceStore.set("bluetooth", "core_token", "")
+        val context = ApplicationProvider.getApplicationContext<android.content.Context>()
+        val prefs = context.getSharedPreferences("augmentos_auth_prefs", android.content.Context.MODE_PRIVATE)
+        prefs.edit().putString("core_token", "stale-synthetic-token").commit()
+        expectCode("core_token_unavailable") { live.sendIncidentId(incident, apiBase) }
+        assertTrue(queuedWrites(live).isEmpty())
+        prefs.edit().remove("core_token").commit()
+    }
+
+    @Test fun `current token is queued before upload and never logged`() = withLive { live ->
+        ready(live)
+        val token = "synthetic-${UUID.randomUUID()}"
+        DeviceStore.set("bluetooth", "core_token", token)
+        ShadowLog.clear()
+        live.sendIncidentId(incident, apiBase)
+        val writes = queuedWrites(live)
+        val wire = writes.joinToString("") { String(it, StandardCharsets.UTF_8) }
+        assertEquals(2, writes.size)
+        assertTrue(wire.indexOf("auth_token") < wire.indexOf("upload_incident_logs"))
+        assertTrue(wire.contains(token))
+        assertTrue(wire.contains(incident))
+        assertFalse("token logged", ShadowLog.getLogs().any { it.msg.contains(token) })
+    }
+
+    @Test fun `link losing TX characteristic rejects instead of retaining incident relay`() = withLive { live ->
+        ready(live)
+        DeviceStore.set("bluetooth", "core_token", "synthetic")
+        set(live, "txCharacteristic", null)
+        expectCode("glasses_not_connected") { live.sendIncidentId(incident, apiBase) }
+        assertTrue(queuedWrites(live).isEmpty())
+        val relays = get(live, "bleIncidentLogRelays") as Map<*, *>
+        assertTrue(relays.isEmpty())
+    }
+
+    @Test fun `session loss during token serialization cannot queue an upload into the next session`() = withLive { live ->
+        ready(live)
+        DeviceStore.set("bluetooth", "core_token", "synthetic-token")
+        val generation = get(live, "bleSessionGeneration") as AtomicLong
+        val sink = Bridge.addEventSink { type, body ->
+            if (type == "log" && body["message"].toString().contains("<auth_token with credentials omitted>")) {
+                generation.incrementAndGet()
+            }
+        }
+        try {
+            expectCode("incident_dispatch_failed") { live.sendIncidentId(incident, apiBase) }
+            val wire = queuedWrites(live).joinToString("") { String(it, StandardCharsets.UTF_8) }
+            assertFalse(wire.contains("upload_incident_logs"))
+            assertTrue((get(live, "bleIncidentLogRelays") as Map<*, *>).isEmpty())
+        } finally { Bridge.removeEventSink(sink) }
+    }
+
+    private fun ready(live: MentraLive) {
+        val context = ApplicationProvider.getApplicationContext<android.content.Context>()
+        val gatt = BluetoothAdapter.getDefaultAdapter().getRemoteDevice("AA:BB:CC:DD:EE:FF")
+            .connectGatt(context, false, object : BluetoothGattCallback() {})
+        set(live, "isConnected", true)
+        set(live, "bluetoothGatt", gatt)
+        set(live, "txCharacteristic", BluetoothGattCharacteristic(UUID.randomUUID(), 0, 0))
+    }
+
+    private fun withLive(body: (MentraLive) -> Unit) {
+        Bridge.initialize(ApplicationProvider.getApplicationContext())
+        val live = MentraLive()
+        val token = DeviceStore.get("bluetooth", "core_token")
+        val connected = DeviceStore.get("glasses", "connected")
+        try { body(live) } finally {
+            DeviceStore.set("bluetooth", "core_token", token ?: "")
+            DeviceStore.set("glasses", "connected", connected ?: false)
+            live.destroy()
+            shadowOf(Looper.getMainLooper()).idleFor(Duration.ofSeconds(2))
+        }
+    }
+
+    private fun expectCode(code: String, body: () -> Unit) {
+        try { body(); fail("Expected $code") } catch (error: BluetoothSdkException) { assertEquals(code, error.code) }
+    }
+
+    private fun get(live: MentraLive, name: String): Any? =
+        MentraLive::class.java.getDeclaredField(name).apply { isAccessible = true }.get(live)
+
+    private fun set(live: MentraLive, name: String, value: Any?) {
+        MentraLive::class.java.getDeclaredField(name).apply { isAccessible = true }.set(live, value)
+    }
+
+    private fun queuedWrites(live: MentraLive): List<ByteArray> = (get(live, "sendQueue") as Iterable<*>).map { write ->
+        write!!.javaClass.getDeclaredField("data").apply { isAccessible = true }.get(write) as ByteArray
+    }
+}

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