@mentra/bluetooth-sdk 3.2.0-dev.200 → 3.2.0-dev.206

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

@@ -313,8 +313,10 @@ abstract class SGCManager {
 
     // Network Management
     abstract fun requestWifiScan(scanId: String?)
+    open fun requestSavedWifiNetworks(requestId: String, sid: String): Boolean = false
     abstract fun sendWifiCredentials(ssid: String, password: String)
     abstract fun forgetWifiNetwork(ssid: String)
+    open fun forgetWifiNetwork(ssid: String, requestId: String?, sid: String?): Boolean = false
     abstract fun sendHotspotState(enabled: Boolean)
 
     /** Set glasses system clock (Mentra Live and G2; no-op on other devices). */

package/android/src/main/java/com/mentra/bluetoothsdk/status/DeviceStatus.kt

@@ -189,6 +189,10 @@ data class VersionInfoResult(
     val appVersion: String,
     val packageName: String,
     val hotspotOtaVersion: Int,
+    val wifiForgetResultVersion: Int? = null,
+    val savedWifiNetworksVersion: Int? = null,
+    val versionInfoType: String? = null,
+    val sid: String? = null,
 ) {
     internal fun toMap(): Map<String, Any> =
         buildMap {
@@ -206,6 +210,10 @@ data class VersionInfoResult(
                 put("packageName", packageName)
             }
             put("hotspotOtaVersion", hotspotOtaVersion)
+            wifiForgetResultVersion?.let { put("wifiForgetResultVersion", it) }
+            savedWifiNetworksVersion?.let { put("savedWifiNetworksVersion", it) }
+            versionInfoType?.let { put("versionInfoType", it) }
+            sid?.let { put("sid", it) }
         }
 
     companion object {
@@ -236,6 +244,12 @@ data class VersionInfoResult(
                 packageName = stringValue(values, "packageName", "package_name") ?: "",
                 hotspotOtaVersion =
                     numberValue(values, "hotspotOtaVersion", "hotspot_ota_version") ?: 0,
+                wifiForgetResultVersion =
+                    numberValue(values, "wifiForgetResultVersion", "wifi_forget_result_version"),
+                savedWifiNetworksVersion =
+                    numberValue(values, "savedWifiNetworksVersion", "saved_wifi_networks_version"),
+                versionInfoType = stringValue(values, "versionInfoType", "version_info_type"),
+                sid = stringValue(values, "sid"),
             )
     }
 }

package/android/src/main/java/com/mentra/bluetoothsdk/streaming/StreamControllerProbe.kt

@@ -0,0 +1,14 @@
+package com.mentra.bluetoothsdk.streaming
+
+/** Process-scoped native ownership survives BLE reconnects, not app termination. */
+internal object StreamControllerProbe {
+    val controllerId: String = java.util.UUID.randomUUID().toString()
+
+    fun response(values: Map<String, Any?>): Map<String, Any>? {
+        if (values["protocolVersion"] != 1 || values["controllerId"] != controllerId) return null
+        val streamId = (values["streamId"] as? String)?.takeIf { it.isNotEmpty() } ?: return null
+        val probeId = (values["probeId"] as? String)?.takeIf { it.isNotEmpty() } ?: return null
+        return mapOf("type" to "stream_controller_response", "protocolVersion" to 1,
+            "controllerId" to controllerId, "streamId" to streamId, "probeId" to probeId)
+    }
+}

package/android/src/main/java/com/mentra/bluetoothsdk/streaming/StreamModels.kt

@@ -481,6 +481,14 @@ data class StreamStatusEvent(
     val status: StreamStatus,
     val stats: StreamLiveStats? = null,
 ) {
+    var processSessionId: String? = null
+        private set
+    var revision: Long? = null
+        private set
+    var terminal: Boolean? = null
+        private set
+    var errorDetails: String? = null
+        private set
     // True when the glasses will retry the failed publisher themselves
     // (emitting side lands in PR #3488); absent on older firmware and on
     // events not parsed from a glasses status map. Carried here instead of
@@ -493,6 +501,10 @@ data class StreamStatusEvent(
         stats = StreamLiveStats.fromMap(stringMapValue(values["stats"])),
     ) {
         willRetry = boolValue(values, "willRetry")
+        processSessionId = stringValue(values, "sid")
+        revision = longValue(values, "revision")
+        terminal = boolValue(values, "terminal")
+        errorDetails = stringValue(values, "errorDetails")
     }
 
     val state: StreamState get() = status.state
@@ -501,6 +513,10 @@ data class StreamStatusEvent(
     val values: Map<String, Any>
         get() = buildMap {
             putAll(status.toEventMap())
+            processSessionId?.let { put("sid", it) }
+            revision?.let { put("revision", it) }
+            terminal?.let { put("terminal", it) }
+            errorDetails?.let { put("errorDetails", it) }
             stats?.let { put("stats", it.toMap()) }
             willRetry?.let { put("willRetry", it) }
         }

package/android/src/main/java/com/mentra/bluetoothsdk/streaming/StreamSessionState.kt

@@ -0,0 +1,32 @@
+package com.mentra.bluetoothsdk.streaming
+
+/** Observes glasses-owned streaming; delivery gaps never imply publisher failure. */
+internal class StreamSessionState {
+    @Volatile var processSessionId: String? = null
+        private set
+    @Volatile var currentStreamId: String? = null
+        private set
+    @Volatile var supported = false
+        private set
+    private var revision = -1L
+
+    @Synchronized
+    fun ready(sessionId: String?, controlVersion: Int?) {
+        supported = controlVersion == 1 && !sessionId.isNullOrEmpty()
+        if (processSessionId != sessionId) {
+            currentStreamId = null
+            revision = -1
+        }
+        processSessionId = sessionId
+    }
+
+    @Synchronized
+    fun accept(values: Map<String, Any?>): Boolean {
+        if (!supported || values["sid"] != processSessionId) return false
+        val incomingRevision = (values["revision"] as? Number)?.toLong() ?: return false
+        if (incomingRevision < revision) return false
+        revision = incomingRevision
+        currentStreamId = if (values["terminal"] == true) null else values["streamId"] as? String
+        return true
+    }
+}

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

@@ -0,0 +1,14 @@
+package com.mentra.bluetoothsdk
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.Test
+
+class GlassesStatusClassicAudioTest {
+    @Test
+    fun `serializes connected Classic audio state for React Native`() {
+        val serialized =
+                GlassesStatus.fromMap(mapOf("bluetoothClassicConnected" to true)).toMap()
+
+        assertThat(serialized["bluetoothClassicConnected"]).isEqualTo(true)
+    }
+}

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

@@ -0,0 +1,16 @@
+package com.mentra.bluetoothsdk
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Test
+
+class MessageAckPolicyTest {
+    @Test
+    fun `every non-ack message id is acknowledged regardless of type`() {
+        assertEquals(17L, incomingGlassesMessageAckId("wifi_forget_result", 17L))
+        assertEquals(18L, incomingGlassesMessageAckId("saved_wifi_networks", 18L))
+        assertEquals(19L, incomingGlassesMessageAckId("future_terminal_type", 19L))
+        assertNull(incomingGlassesMessageAckId("msg_ack", 20L))
+        assertNull(incomingGlassesMessageAckId("wifi_forget_result", null))
+    }
+}

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/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/streaming/StreamControllerProbeTest.kt

@@ -0,0 +1,24 @@
+package com.mentra.bluetoothsdk.streaming
+
+import org.junit.Assert.*
+import org.junit.Test
+
+class StreamControllerProbeTest {
+    private fun probe() = mapOf<String, Any>("protocolVersion" to 1,
+        "controllerId" to StreamControllerProbe.controllerId, "streamId" to "stream", "probeId" to "nonce")
+
+    @Test fun answersCurrentProcessChallengeWithoutJsOrTimer() {
+        val response = StreamControllerProbe.response(probe())!!
+        assertEquals("stream_controller_response", response["type"])
+        assertEquals("nonce", response["probeId"])
+        assertEquals("stream", response["streamId"])
+    }
+
+    @Test fun rejectsPreviousProcessAndMalformedChallenges() {
+        assertNull(StreamControllerProbe.response(probe() + ("controllerId" to "previous-process")))
+        assertNull(StreamControllerProbe.response(probe() + ("protocolVersion" to 2)))
+        assertNull(StreamControllerProbe.response(probe() + ("protocolVersion" to true)))
+        assertNull(StreamControllerProbe.response(probe() + ("probeId" to "")))
+        assertNull(StreamControllerProbe.response(probe() - "streamId"))
+    }
+}

package/android/src/test/java/com/mentra/bluetoothsdk/streaming/StreamSessionStateTest.kt

@@ -0,0 +1,43 @@
+package com.mentra.bluetoothsdk.streaming
+
+import org.junit.Assert.*
+import org.junit.Test
+
+class StreamSessionStateTest {
+    @Test fun readinessRequiresKnownProtocolAndProcessIdentity() {
+        val state = StreamSessionState()
+        state.ready("asg", null)
+        assertFalse(state.supported)
+        state.ready("asg", 2)
+        assertFalse(state.supported)
+        state.ready("", 1)
+        assertFalse(state.supported)
+        state.ready("asg", 1)
+        assertTrue(state.supported)
+    }
+
+    @Test fun reconnectReconcilesTerminalStateWithoutHeartbeatTimeouts() {
+        val state = StreamSessionState()
+        state.ready("asg", 1)
+        assertTrue(state.accept(event("asg", 1, false)))
+        state.ready("asg", 1)
+        assertEquals("stream", state.currentStreamId)
+        assertTrue(state.accept(event("asg", 3, true)))
+        assertNull(state.currentStreamId)
+        assertFalse(state.accept(event("asg", 2, false)))
+        assertNull(state.currentStreamId)
+    }
+
+    @Test fun restartRejectsOldStatusAndAcceptsNewStoppedSnapshot() {
+        val state = StreamSessionState()
+        state.ready("old", 1)
+        assertTrue(state.accept(event("old", 8, false)))
+        state.ready("new", 1)
+        assertFalse(state.accept(event("old", 9, false)))
+        assertTrue(state.accept(mapOf("sid" to "new", "revision" to 0, "terminal" to true)))
+        assertNull(state.currentStreamId)
+    }
+
+    private fun event(sid: String, revision: Int, terminal: Boolean) =
+        mapOf("sid" to sid, "revision" to revision, "streamId" to "stream", "terminal" to terminal)
+}