@mentra/bluetooth-sdk 3.2.1-dev.311 → 3.2.1

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

@@ -0,0 +1,13 @@
+package com.mentra.bluetoothsdk
+
+import com.mentra.bluetoothsdk.utils.G2Text
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+class G2TextTest {
+  @Test fun blankRowsAreEncodedOnlyAtTheDeviceBoundary() {
+    assertEquals("hello\n\u200B\nworld\n\u200B", G2Text.containerContent("hello\n\nworld\n"))
+    assertEquals(" ", G2Text.containerContent(""))
+    assertEquals("hello\nworld", G2Text.containerContent("hello\nworld"))
+  }
+}

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

@@ -102,6 +102,77 @@ class VersionInfoResponseAccumulatorTest {
             .isEqualTo(VersionInfoAccumulatorOutcome.Waiting)
     }
 
+    @Test
+    fun factoryAsg27CompletesAfterItsTwoChunks() {
+        // Exact January wire shape after Bridge normalization; firmware can be unknown.
+        for (firmware in listOf("", "17.26.1.13")) {
+            val accumulator = VersionInfoResponseAccumulator("request-1")
+            accumulator.accept(chunk("version_info_1", null, "buildNumber" to "27", "appVersion" to "27.0"))
+            val complete = accumulator.accept(chunk("version_info_2", null,
+                "buildNumber" to "", "otaVersionUrl" to "https://ota.example/live_version.json", "firmwareVersion" to firmware,
+            )) as VersionInfoAccumulatorOutcome.Complete
+            assertThat(complete.result.buildNumber).isEqualTo("27")
+            assertThat(complete.result.otaVersionUrl).isEqualTo("https://ota.example/live_version.json")
+            assertThat(complete.result.firmwareVersion).isEqualTo(firmware)
+        }
+    }
+
+    @Test
+    fun otherLegacyBuildsStillRequireTheirThirdChunk() {
+        for (build in listOf("", "26", "28", "31", "37", "42")) {
+            val accumulator = VersionInfoResponseAccumulator("request-1")
+            accumulator.accept(chunk("version_info_1", null, "buildNumber" to build))
+            assertThat(accumulator.accept(chunk("version_info_2", null,
+                "otaVersionUrl" to "https://ota.example/version.json",
+            ))).isEqualTo(VersionInfoAccumulatorOutcome.Waiting)
+            assertThat(accumulator.accept(chunk("version_info_3", null, "besFirmwareVersion" to "new")))
+                .isInstanceOf(VersionInfoAccumulatorOutcome.Complete::class.java)
+        }
+    }
+
+    @Test
+    fun factorySecondChunkCannotCompleteWithoutFirstChunkAndOtaUrl() {
+        val accumulator = VersionInfoResponseAccumulator("request-1")
+        val second = chunk("version_info_2", null, "otaVersionUrl" to "https://ota.example/version.json")
+        assertThat(accumulator.accept(second)).isEqualTo(VersionInfoAccumulatorOutcome.Ignored)
+        accumulator.accept(chunk("version_info_1", null, "buildNumber" to "27"))
+        for (values in listOf(emptyMap(), mapOf("otaVersionUrl" to ""), mapOf("otaVersionUrl" to " \n"))) {
+            assertThat(accumulator.accept(chunk("version_info_2", null) + values))
+                .isEqualTo(VersionInfoAccumulatorOutcome.Waiting)
+        }
+        assertThat(accumulator.accept(second)).isInstanceOf(VersionInfoAccumulatorOutcome.Complete::class.java)
+    }
+
+    @Test
+    fun secondChunkCannotChangeBuildIntoFactoryProtocol() {
+        val accumulator = VersionInfoResponseAccumulator("request-1")
+        accumulator.accept(chunk("version_info_1", null, "buildNumber" to "31"))
+        assertThat(accumulator.accept(chunk("version_info_2", null,
+            "buildNumber" to "27", "otaVersionUrl" to "https://ota.example/version.json",
+        ))).isEqualTo(VersionInfoAccumulatorOutcome.Waiting)
+    }
+
+    @Test
+    fun repeatedFirstChunkClearsFactoryCompletionRule() {
+        val accumulator = VersionInfoResponseAccumulator("request-1")
+        accumulator.accept(chunk("version_info_1", null, "buildNumber" to "27"))
+        accumulator.accept(chunk("version_info_1", null, "buildNumber" to "31"))
+        assertThat(accumulator.accept(chunk("version_info_2", null,
+            "otaVersionUrl" to "https://ota.example/version.json",
+        ))).isEqualTo(VersionInfoAccumulatorOutcome.Waiting)
+    }
+
+    @Test
+    fun factoryBuildCannotBypassModernCorrelation() {
+        val accumulator = VersionInfoResponseAccumulator("request-1")
+        accumulator.accept(chunk("version_info_1", "request-1", "buildNumber" to "27"))
+        assertThat(accumulator.accept(chunk("version_info_2", null,
+            "otaVersionUrl" to "https://ota.example/version.json",
+        ))).isEqualTo(VersionInfoAccumulatorOutcome.Ignored)
+        assertThat(accumulator.accept(chunk("version_info_3", "request-1", "besFirmwareVersion" to "new")))
+            .isInstanceOf(VersionInfoAccumulatorOutcome.Complete::class.java)
+    }
+
     @Test
     fun modernFinalChunkWaitsForMissingFirstChunk() {
         val accumulator = VersionInfoResponseAccumulator("request-1")

package/android/src/test/java/com/mentra/bluetoothsdk/services/G2ConnectionRecoveryTest.kt

@@ -0,0 +1,51 @@
+package com.mentra.bluetoothsdk.services
+
+import com.mentra.bluetoothsdk.utils.DeviceTypes
+import org.junit.Assert.*
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.RuntimeEnvironment
+import org.robolectric.annotation.Config
+
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [28])
+class G2ConnectionRecoveryTest {
+    private fun recovery() = G2ConnectionRecovery(RuntimeEnvironment.getApplication())
+    private fun settings() = mapOf<String, Any>(
+        "default_wearable" to DeviceTypes.G2, "device_name" to "S200-test",
+        "brightness" to 75, "auto_brightness" to false,
+        "core_token" to "must-not-persist", "micEnabled" to true,
+        "searching" to true, "pending_device_name" to "unpaired",
+    )
+
+    @Before fun reset() { recovery().clear() }
+
+    @Test fun `a fresh recovery owner restores identity and settings but not runtime or auth state`() {
+        recovery().save(settings())
+        val restored = recovery().read()!!
+        assertEquals("S200-test", restored["device_name"])
+        assertEquals(75, restored["brightness"])
+        assertEquals(false, restored["auto_brightness"])
+        assertFalse(restored.containsKey("core_token"))
+        assertFalse(restored.containsKey("micEnabled"))
+        assertFalse(restored.containsKey("searching"))
+        assertFalse(restored.containsKey("pending_device_name"))
+    }
+
+    @Test fun `explicit disconnect clears recovery across owner recreation`() {
+        recovery().save(settings())
+        recovery().clear()
+        assertNull(recovery().read())
+    }
+
+    @Test fun `forget or switching models cannot resurrect old G2 pairing`() {
+        recovery().save(settings())
+        recovery().save(settings() + ("device_name" to ""))
+        assertNull(recovery().read())
+        recovery().save(settings())
+        recovery().save(settings() + ("default_wearable" to DeviceTypes.G1))
+        assertNull(recovery().read())
+    }
+}

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