@mentra/bluetooth-sdk 3.2.0-dev.195 → 3.2.0-dev.203

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

@@ -0,0 +1,271 @@
+package com.mentra.bluetoothsdk
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class WifiRequestResolutionTest {
+    @Test
+    fun `future fractional and malformed capabilities are unsupported not legacy`() {
+        for (version in listOf(0, 2, -1, 1.5, "1", true)) {
+            val capabilities = WifiSessionCapabilities()
+            capabilities.reset("sid")
+            capabilities.applyVersionInfo1(mapOf("wifiForgetResultVersion" to version, "savedWifiNetworksVersion" to version))
+            assertEquals(WifiRequestMode.UNSUPPORTED, capabilities.forgetMode())
+            assertEquals(WifiRequestMode.UNSUPPORTED, capabilities.savedNetworksMode())
+        }
+        val missingSession = WifiSessionCapabilities()
+        missingSession.applyVersionInfo1(mapOf("wifiForgetResultVersion" to 1))
+        assertEquals(WifiRequestMode.UNSUPPORTED, missingSession.forgetMode())
+    }
+
+    @Test
+    fun `raw response rejects partial tuples and coercion before normalization`() {
+        val tuple = mapOf<String, Any>("protocol_version" to 1, "requestId" to "request", "sid" to "sid")
+        assertTrue(wifiResponseEnvelopeIsValid(tuple, false))
+        for (key in tuple.keys) assertFalse(wifiResponseEnvelopeIsValid(tuple - key, true))
+        for (version in listOf(0, 2, 1.5, "1", true)) {
+            assertFalse(wifiResponseEnvelopeIsValid(tuple + ("protocol_version" to version), true))
+        }
+        assertFalse(wifiResponseEnvelopeIsValid(tuple + ("connected" to 0), true))
+        assertFalse(wifiResponseEnvelopeIsValid(tuple + ("dispatched" to true), true))
+        assertTrue(wifiResponseEnvelopeIsValid(mapOf("dispatched" to true), true))
+        assertFalse(wifiResponseEnvelopeIsValid(mapOf("requestId" to "", "dispatched" to true), true))
+        assertFalse(wifiResponseEnvelopeIsValid(emptyMap(), false))
+    }
+
+    @Test
+    fun `semantic results omit transport metadata`() {
+        val data = mapOf<String, Any>("requestId" to "request", "sid" to "sid", "protocolVersion" to 1,
+            "ssid" to "AP", "outcome" to "confirmed", "networks" to listOf("AP"))
+        val forbidden = setOf("mode", "capabilityVersion", "requestId", "sid", "protocolVersion")
+        assertTrue(parseWifiForgetResult("request", "sid", "AP", 1, data)!!.toMap().keys.intersect(forbidden).isEmpty())
+        assertTrue(parseSavedWifiNetworks("request", "sid", 1, data)!!.toMap().keys.intersect(forbidden).isEmpty())
+        assertNull(parseWifiForgetResult("request", "sid", "AP", 1, data + ("protocolVersion" to 1.5)))
+        assertNull(parseSavedWifiNetworks("request", "sid", 1, data + ("protocolVersion" to 1.5)))
+    }
+
+    @Test
+    fun `capabilities are unknown per session until version info finalizes them`() {
+        val capabilities = WifiSessionCapabilities()
+        capabilities.reset("sid-1")
+
+        assertEquals(WifiRequestMode.DISCOVERING, capabilities.forgetMode())
+        assertEquals(WifiRequestMode.DISCOVERING, capabilities.savedNetworksMode())
+        capabilities.applyVersionInfo1(mapOf("sid" to "sid-1", "wifiForgetResultVersion" to 1))
+
+        assertEquals(WifiProtocolCapability.Supported(1), capabilities.forgetResult)
+        assertEquals(WifiProtocolCapability.Legacy, capabilities.savedNetworks)
+        assertEquals(WifiRequestMode.MODERN, capabilities.forgetMode())
+        assertEquals(WifiRequestMode.LEGACY, capabilities.savedNetworksMode())
+    }
+
+    @Test
+    fun `new session resets capabilities and advances epoch`() {
+        val capabilities = WifiSessionCapabilities()
+        capabilities.reset("sid-1")
+        capabilities.applyVersionInfo1(
+            mapOf("wifiForgetResultVersion" to 1, "savedWifiNetworksVersion" to 1)
+        )
+        val oldEpoch = capabilities.epoch
+
+        capabilities.reset("sid-2")
+
+        assertTrue(capabilities.epoch > oldEpoch)
+        assertEquals("sid-2", capabilities.sessionId)
+        assertEquals(WifiProtocolCapability.Unknown, capabilities.forgetResult)
+        assertEquals(WifiProtocolCapability.Unknown, capabilities.savedNetworks)
+    }
+
+    @Test
+    fun `saved request snapshot cannot mix mode with a later session`() {
+        val capabilities = WifiSessionCapabilities()
+        capabilities.reset("sid-1")
+        capabilities.applyVersionInfo1(mapOf("savedWifiNetworksVersion" to 1))
+        val first = capabilities.savedNetworksRequestSnapshot()
+
+        capabilities.reset("sid-2")
+        val second = capabilities.savedNetworksRequestSnapshot()
+
+        assertEquals(WifiRequestMode.MODERN, first.mode)
+        assertEquals("sid-1", first.sessionId)
+        assertEquals(WifiRequestMode.DISCOVERING, second.mode)
+        assertEquals("sid-2", second.sessionId)
+        assertTrue(second.epoch > first.epoch)
+    }
+
+    @Test
+    fun `SSID validation rejects blank input without changing identity`() {
+        assertFalse(wifiSsidIsValid("   "))
+        assertTrue(wifiSsidIsValid(" Field AP "))
+    }
+
+    @Test
+    fun `forget result requires exact id session ssid and protocol`() {
+        val exact =
+            mapOf<String, Any>(
+                "requestId" to "forget-1",
+                "sid" to "sid-1",
+                "ssid" to " Field AP ",
+                "protocolVersion" to 1,
+                "outcome" to "dispatched",
+                "connected" to false,
+            )
+
+        assertNull(parseWifiForgetResult("other", "sid-1", " Field AP ", 1, exact))
+        assertNull(parseWifiForgetResult("forget-1", "sid-1", " Field AP ", 1, exact - "requestId"))
+        assertNull(parseWifiForgetResult("forget-1", "other", " Field AP ", 1, exact))
+        assertNull(parseWifiForgetResult("forget-1", "sid-1", "Field AP", 1, exact))
+        assertNull(parseWifiForgetResult("forget-1", "sid-1", " Field AP ", 2, exact))
+        assertEquals(
+            WifiForgetOutcome.DISPATCHED,
+            parseWifiForgetResult("forget-1", "sid-1", " Field AP ", 1, exact)?.outcome,
+        )
+    }
+
+    @Test
+    fun `forget parser preserves each honest terminal outcome`() {
+        listOf("confirmed", "dispatched", "not_found", "unsupported", "failed").forEach { outcome ->
+            val parsed =
+                parseWifiForgetResult(
+                    "forget-1",
+                    "sid-1",
+                    "AP",
+                    1,
+                    mapOf(
+                        "requestId" to "forget-1",
+                        "sid" to "sid-1",
+                        "ssid" to "AP",
+                        "protocolVersion" to 1,
+                        "outcome" to outcome,
+                    ),
+                )
+            assertEquals(outcome, parsed?.outcome?.wireValue)
+        }
+    }
+
+    @Test
+    fun `missing connectivity snapshot remains unknown`() {
+        val parsed =
+            parseWifiForgetResult(
+                "forget-1",
+                "sid-1",
+                "AP",
+                1,
+                mapOf(
+                    "requestId" to "forget-1",
+                    "sid" to "sid-1",
+                    "ssid" to "AP",
+                    "protocolVersion" to 1,
+                    "outcome" to "dispatched",
+                ),
+            )
+
+        assertNull(parsed?.connected)
+        assertFalse(parsed?.toMap()?.containsKey("connected") ?: true)
+    }
+
+    @Test
+    fun `legacy forget is explicitly unverified`() {
+        val result =
+            legacyWifiForgetResult(
+                "AP",
+            )
+
+        assertFalse(result.toMap().keys.any { it in setOf("mode", "capabilityVersion", "requestId", "sid") })
+        assertEquals(WifiForgetOutcome.LEGACY_UNVERIFIED, result.outcome)
+        assertNull(result.connected)
+        assertNull(result.currentSsid)
+        assertNull(result.localIp)
+    }
+
+    @Test
+    fun `saved list preserves exact identity and requires correlation tuple`() {
+        val exact =
+            mapOf<String, Any>(
+                "requestId" to "saved-1",
+                "sid" to "sid-1",
+                "protocolVersion" to 1,
+                "outcome" to "confirmed",
+                "networks" to listOf(" Field AP ", "", "Field AP", " Field AP "),
+            )
+
+        assertNull(parseSavedWifiNetworks("other", "sid-1", 1, exact))
+        assertNull(parseSavedWifiNetworks("saved-1", "sid-1", 1, exact - "requestId"))
+        assertNull(parseSavedWifiNetworks("saved-1", "other", 1, exact))
+        assertNull(parseSavedWifiNetworks("saved-1", "sid-1", 2, exact))
+        assertEquals(
+            listOf(" Field AP ", "Field AP"),
+            parseSavedWifiNetworks("saved-1", "sid-1", 1, exact)?.networks,
+        )
+
+        val failure =
+            parseSavedWifiNetworks(
+                "saved-1",
+                "sid-1",
+                1,
+                exact + ("outcome" to "failed") + ("error" to "backend_failed") + ("networks" to emptyList<String>()),
+            )
+        assertEquals(SavedWifiNetworksOutcome.FAILED, failure?.outcome)
+        assertEquals("backend_failed", failure?.error)
+    }
+
+
+    @Test
+    fun `raw forget event preserves modern and legacy wire truth`() {
+        val modern =
+            normalizeWifiForgetResultEvent(
+                "forget-1",
+                "sid-1",
+                "AP",
+                1,
+                "dispatched",
+                null,
+                false,
+                "",
+                "",
+                null,
+            )
+        val legacy =
+            normalizeWifiForgetResultEvent(
+                "",
+                "",
+                "AP",
+                0,
+                "",
+                true,
+                false,
+                "",
+                "",
+                null,
+            )
+        val withoutSnapshot =
+            normalizeWifiForgetResultEvent(
+                "forget-unknown",
+                "sid-1",
+                "AP",
+                1,
+                "dispatched",
+                null,
+                null,
+                "",
+                "",
+                null,
+            )
+
+        assertEquals("modern", modern?.get("mode"))
+        assertEquals("dispatched", modern?.get("outcome"))
+        assertEquals("legacy", legacy?.get("mode"))
+        assertEquals(true, legacy?.get("dispatched"))
+        assertFalse(legacy?.containsKey("sid") ?: true)
+        assertFalse(withoutSnapshot?.containsKey("connected") ?: true)
+        assertNull(
+            normalizeWifiForgetResultEvent(
+                "bad", "", "AP", 0, "", null, false, "", "", null
+            )
+        )
+    }
+
+}

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

@@ -0,0 +1,57 @@
+package com.mentra.bluetoothsdk.services
+
+import android.Manifest
+import android.content.ComponentName
+import android.content.Intent
+import android.content.pm.ServiceInfo
+import android.location.LocationManager
+import org.junit.Assert.assertEquals
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.Robolectric
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.RuntimeEnvironment
+import org.robolectric.Shadows.shadowOf
+import org.robolectric.annotation.Config
+import org.robolectric.util.ReflectionHelpers
+
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [33])
+class ForegroundServiceManifestTest {
+    @Test
+    fun `host manifest controls startup and resume even with all permissions granted`() {
+        val application = RuntimeEnvironment.getApplication()
+        val component = ComponentName(application, ForegroundService::class.java)
+        val info = application.packageManager.getServiceInfo(component, 0)
+        ReflectionHelpers.setField(info, "mForegroundServiceType", ServiceInfo.FOREGROUND_SERVICE_TYPE_CONNECTED_DEVICE)
+        shadowOf(application.packageManager).addOrUpdateService(info)
+        shadowOf(application).grantPermissions(
+            Manifest.permission.BLUETOOTH_CONNECT,
+            Manifest.permission.RECORD_AUDIO,
+            Manifest.permission.ACCESS_FINE_LOCATION,
+        )
+        shadowOf(application.getSystemService(LocationManager::class.java)).setLocationEnabled(true)
+
+        val controller = Robolectric.buildService(ForegroundService::class.java).create()
+        val service = controller.get()
+        try {
+            assertEquals(ServiceInfo.FOREGROUND_SERVICE_TYPE_CONNECTED_DEVICE, service.foregroundServiceType)
+            service.onStartCommand(Intent(ForegroundService.ACTION_REFRESH_TYPES), 0, 1)
+            assertEquals(ServiceInfo.FOREGROUND_SERVICE_TYPE_CONNECTED_DEVICE, service.foregroundServiceType)
+            service.onStartCommand(null, 0, 2)
+            assertEquals(ServiceInfo.FOREGROUND_SERVICE_TYPE_CONNECTED_DEVICE, service.foregroundServiceType)
+        } finally {
+            controller.destroy()
+        }
+    }
+
+    @Test
+    fun `default library manifest retains the MentraOS startup type`() {
+        val controller = Robolectric.buildService(ForegroundService::class.java).create()
+        try {
+            assertEquals(ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC, controller.get().foregroundServiceType)
+        } finally {
+            controller.destroy()
+        }
+    }
+}

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

@@ -6,6 +6,58 @@ import org.junit.Assert.assertTrue
 import org.junit.Test
 
 class ForegroundServiceTypeTest {
+    @Test
+    fun `connected-device-only host bootstraps without dataSync`() {
+        assertEquals(
+            ServiceInfo.FOREGROUND_SERVICE_TYPE_CONNECTED_DEVICE,
+            ForegroundService.bootstrapServiceType(ServiceInfo.FOREGROUND_SERVICE_TYPE_CONNECTED_DEVICE),
+        )
+    }
+
+    @Test
+    fun `permissions cannot enable types excluded by the host manifest`() {
+        assertEquals(
+            ServiceInfo.FOREGROUND_SERVICE_TYPE_CONNECTED_DEVICE,
+            ForegroundService.preferredServiceType(
+                hasConnectedDeviceAccess = true,
+                hasMicrophoneAccess = true,
+                hasLocationAccess = true,
+                declaredTypes = ServiceInfo.FOREGROUND_SERVICE_TYPE_CONNECTED_DEVICE,
+            ),
+        )
+    }
+
+    @Test
+    fun `restricted host fallback never adds undeclared dataSync`() {
+        assertEquals(
+            ServiceInfo.FOREGROUND_SERVICE_TYPE_CONNECTED_DEVICE,
+            ForegroundService.preferredServiceType(
+                hasConnectedDeviceAccess = false,
+                hasMicrophoneAccess = false,
+                hasLocationAccess = false,
+                declaredTypes = ServiceInfo.FOREGROUND_SERVICE_TYPE_CONNECTED_DEVICE,
+            ),
+        )
+    }
+
+    @Test
+    fun `MentraOS retains all eligible long-running types`() {
+        assertEquals(
+            ForegroundService.DEFAULT_SERVICE_TYPES and
+                    ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC.inv(),
+            ForegroundService.preferredServiceType(
+                hasConnectedDeviceAccess = true,
+                hasMicrophoneAccess = true,
+                hasLocationAccess = true,
+            ),
+        )
+    }
+
+    @Test(expected = IllegalArgumentException::class)
+    fun `host without a valid bootstrap type fails explicitly`() {
+        ForegroundService.bootstrapServiceType(ServiceInfo.FOREGROUND_SERVICE_TYPE_LOCATION)
+    }
+
     @Test
     fun `bootstrap starts as dataSync`() {
         assertEquals(

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

@@ -0,0 +1,131 @@
+package com.mentra.bluetoothsdk.sgcs
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.Test
+
+class ClassicAudioConnectionTrackerTest {
+    @Test
+    fun `available connected profile is sufficient even if the other query fails or never answers`() {
+        assertThat(readyClassicAudioSnapshot(mapOf(ClassicAudioProfile.A2DP to true)))
+            .containsExactly(ClassicAudioProfile.A2DP)
+        assertThat(readyClassicAudioSnapshot(mapOf(ClassicAudioProfile.HEADSET to true)))
+            .containsExactly(ClassicAudioProfile.HEADSET)
+    }
+
+    @Test
+    fun `missing profile never fabricates a disconnect during a profile switch`() {
+        assertThat(readyClassicAudioSnapshot(mapOf(ClassicAudioProfile.A2DP to false))).isNull()
+        assertThat(readyClassicAudioSnapshot(mapOf(ClassicAudioProfile.A2DP to false,
+            ClassicAudioProfile.HEADSET to false))).isEmpty()
+    }
+
+    private val address = "AA:BB:CC:DD:EE:FF"
+
+    private fun snapshot(tracker: ClassicAudioConnectionTracker, vararg profiles: ClassicAudioProfile) {
+        val ticket = tracker.beginSnapshot(address)!!
+        assertThat(tracker.applySnapshot(ticket, address, profiles.toSet())).isTrue()
+    }
+
+    @Test
+    fun `publishes complete A2DP and HFP snapshots without intermediate false negative`() {
+        val changes = mutableListOf<Boolean>()
+        val tracker = ClassicAudioConnectionTracker(changes::add)
+        tracker.setTarget(address)
+        snapshot(tracker, ClassicAudioProfile.A2DP)
+        snapshot(tracker, ClassicAudioProfile.HEADSET)
+        snapshot(tracker)
+        assertThat(changes).containsExactly(true, false)
+    }
+
+    @Test
+    fun `address comparison is case insensitive`() {
+        val tracker = ClassicAudioConnectionTracker {}
+        tracker.setTarget(address.lowercase())
+        snapshot(tracker, ClassicAudioProfile.A2DP)
+        assertThat(tracker.connected).isTrue()
+    }
+
+    @Test
+    fun `another device cannot request a snapshot`() {
+        val tracker = ClassicAudioConnectionTracker {}
+        tracker.setTarget(address)
+        assertThat(tracker.beginSnapshot("11:22:33:44:55:66")).isNull()
+    }
+
+    @Test
+    fun `late result for previous device cannot replace current profiles`() {
+        val tracker = ClassicAudioConnectionTracker {}
+        tracker.setTarget(address)
+        val ticket = tracker.beginSnapshot(address)!!
+        tracker.setTarget("11:22:33:44:55:66")
+        assertThat(tracker.applySnapshot(ticket, address, setOf(ClassicAudioProfile.A2DP))).isFalse()
+        assertThat(tracker.connected).isFalse()
+    }
+
+    @Test
+    fun `old response cannot resurrect reconnected session with same MAC`() {
+        val tracker = ClassicAudioConnectionTracker {}
+        tracker.setTarget(address)
+        val ticket = tracker.beginSnapshot(address)!!
+        tracker.invalidate(address)
+        tracker.setTarget(address)
+        snapshot(tracker)
+        assertThat(tracker.applySnapshot(ticket, address, setOf(ClassicAudioProfile.A2DP))).isFalse()
+        assertThat(tracker.connected).isFalse()
+    }
+
+    @Test
+    fun `newer query invalidates in flight snapshot even before its response arrives`() {
+        val tracker = ClassicAudioConnectionTracker {}
+        tracker.setTarget(address)
+        val first = tracker.beginSnapshot(address)!!
+        val second = tracker.beginSnapshot(address)!!
+        assertThat(tracker.applySnapshot(first, address, setOf(ClassicAudioProfile.A2DP))).isFalse()
+        assertThat(tracker.applySnapshot(second, address, emptySet())).isTrue()
+    }
+
+    @Test
+    fun `late disconnect snapshot cannot overwrite newer connected snapshot`() {
+        val tracker = ClassicAudioConnectionTracker {}
+        tracker.setTarget(address)
+        val old = tracker.beginSnapshot(address)!!
+        snapshot(tracker, ClassicAudioProfile.HEADSET)
+        assertThat(tracker.applySnapshot(old, address, emptySet())).isFalse()
+        assertThat(tracker.connected).isTrue()
+    }
+
+    @Test
+    fun `clear invalidates queries but retains target for retry`() {
+        val tracker = ClassicAudioConnectionTracker {}
+        tracker.setTarget(address)
+        val old = tracker.beginSnapshot(address)!!
+        assertThat(tracker.clear(address)).isTrue()
+        assertThat(tracker.applySnapshot(old, address, setOf(ClassicAudioProfile.A2DP))).isFalse()
+        snapshot(tracker, ClassicAudioProfile.A2DP)
+        assertThat(tracker.connected).isTrue()
+    }
+
+    @Test
+    fun `reset clears truth and prevents pending results from applying`() {
+        val changes = mutableListOf<Boolean>()
+        val tracker = ClassicAudioConnectionTracker(changes::add)
+        tracker.setTarget(address)
+        snapshot(tracker, ClassicAudioProfile.A2DP)
+        val ticket = tracker.beginSnapshot(address)!!
+        tracker.reset()
+        assertThat(tracker.applySnapshot(ticket, address, setOf(ClassicAudioProfile.A2DP))).isFalse()
+        assertThat(tracker.beginSnapshot(address)).isNull()
+        assertThat(changes).containsExactly(true, false)
+    }
+
+    @Test
+    fun `stale snapshot cannot emit audio routing notifications`() {
+        val tracker = ClassicAudioConnectionTracker {}
+        tracker.setTarget(address)
+        val old = tracker.beginSnapshot(address)!!
+        tracker.setTarget(address)
+        var notifications = 0
+        tracker.applySnapshot(old, address, setOf(ClassicAudioProfile.A2DP)) { notifications++ }
+        assertThat(notifications).isZero()
+    }
+}

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

@@ -0,0 +1,94 @@
+package com.mentra.bluetoothsdk.sgcs
+
+import android.bluetooth.BluetoothAdapter
+import android.bluetooth.BluetoothGatt
+import android.bluetooth.BluetoothGattCallback
+import android.bluetooth.BluetoothGattCharacteristic
+import android.bluetooth.BluetoothGattDescriptor
+import java.util.UUID
+import org.junit.Assert.assertArrayEquals
+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.annotation.Config
+
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [28])
+class MentraLiveGattCallbackTest {
+    private fun gatt(): BluetoothGatt =
+        BluetoothAdapter.getDefaultAdapter().getRemoteDevice("AA:BB:CC:DD:EE:FF")
+            .connectGatt(RuntimeEnvironment.getApplication(), false, object : BluetoothGattCallback() {})
+
+    private class RecordingCallback(
+        enqueue: (() -> Unit) -> Unit,
+        isCurrent: (BluetoothGatt) -> Boolean = { true },
+    ) : SerializedGattCallback(enqueue, isCurrent) {
+        val events = mutableListOf<String>()
+        val packets = mutableListOf<ByteArray>()
+        override fun handleConnectionStateChange(gatt: BluetoothGatt, status: Int, newState: Int) { events.add("connection") }
+        override fun handleServicesDiscovered(gatt: BluetoothGatt, status: Int) { events.add("services") }
+        override fun handlePhyUpdate(gatt: BluetoothGatt, txPhy: Int, rxPhy: Int, status: Int) { events.add("phyUpdate") }
+        override fun handlePhyRead(gatt: BluetoothGatt, txPhy: Int, rxPhy: Int, status: Int) { events.add("phyRead") }
+        override fun handleCharacteristicRead(gatt: BluetoothGatt, characteristic: BluetoothGattCharacteristic, status: Int) { events.add("read") }
+        override fun handleReadRemoteRssi(gatt: BluetoothGatt, rssi: Int, status: Int) { events.add("rssi") }
+        override fun handleCharacteristicWrite(gatt: BluetoothGatt, characteristic: BluetoothGattCharacteristic, status: Int) { events.add("write") }
+        override fun handleCharacteristicChanged(gatt: BluetoothGatt, characteristic: BluetoothGattCharacteristic, data: ByteArray) { packets.add(data) }
+        override fun handleDescriptorWrite(gatt: BluetoothGatt, descriptor: BluetoothGattDescriptor, status: Int) { events.add("descriptor") }
+        override fun handleMtuChanged(gatt: BluetoothGatt, mtu: Int, status: Int) { events.add("mtu") }
+    }
+
+    @Test
+    fun `all callbacks defer effects until the lifecycle owner executes them`() {
+        val queue = ArrayDeque<() -> Unit>()
+        val callback = RecordingCallback({ work -> queue.addLast(work) })
+        val gatt = gatt()
+        val characteristic = BluetoothGattCharacteristic(UUID.randomUUID(), 0, 0)
+        val descriptor = BluetoothGattDescriptor(UUID.randomUUID(), 0)
+        callback.onConnectionStateChange(gatt, 0, 2)
+        callback.onServicesDiscovered(gatt, 0)
+        callback.onPhyUpdate(gatt, 1, 1, 0)
+        callback.onPhyRead(gatt, 1, 1, 0)
+        callback.onCharacteristicRead(gatt, characteristic, 0)
+        callback.onReadRemoteRssi(gatt, -50, 0)
+        callback.onCharacteristicWrite(gatt, characteristic, 0)
+        callback.onDescriptorWrite(gatt, descriptor, 0)
+        callback.onMtuChanged(gatt, 512, 0)
+        assertEquals(emptyList<String>(), callback.events)
+        while (queue.isNotEmpty()) queue.removeFirst().invoke()
+        assertEquals(listOf("connection", "services", "phyUpdate", "phyRead", "read", "rssi", "write", "descriptor", "mtu"), callback.events)
+    }
+
+    @Test
+    @Suppress("DEPRECATION")
+    fun `queued notifications retain their own bytes when Android reuses characteristic`() {
+        val queue = ArrayDeque<() -> Unit>()
+        val callback = RecordingCallback({ work -> queue.addLast(work) })
+        val gatt = gatt()
+        val characteristic = BluetoothGattCharacteristic(UUID.randomUUID(), 0, 0)
+        val buffer = byteArrayOf(1, 2)
+        characteristic.value = buffer
+        callback.onCharacteristicChanged(gatt, characteristic)
+        buffer[0] = 3
+        callback.onCharacteristicChanged(gatt, characteristic)
+        buffer[0] = 4
+        while (queue.isNotEmpty()) queue.removeFirst().invoke()
+        assertArrayEquals(byteArrayOf(1, 2), callback.packets[0])
+        assertArrayEquals(byteArrayOf(3, 2), callback.packets[1])
+    }
+
+    @Test
+    fun `replacement invalidates callbacks already waiting on the lifecycle queue`() {
+        val queue = ArrayDeque<() -> Unit>()
+        var epoch = 1
+        val callback = RecordingCallback({ work -> queue.addLast(work) }, { epoch == 1 })
+        val gatt = gatt()
+        callback.onConnectionStateChange(gatt, 0, 0)
+        callback.onServicesDiscovered(gatt, 0)
+        callback.onMtuChanged(gatt, 512, 0)
+        epoch = 2
+        while (queue.isNotEmpty()) queue.removeFirst().invoke()
+        assertEquals(emptyList<String>(), callback.events)
+    }
+}