@mentra/bluetooth-sdk 0.1.21-beta.3 → 3.1.0-beta.100

package/android/src/test/java/com/mentra/bluetoothsdk/otaserver/LocalOtaServerTest.kt

@@ -0,0 +1,82 @@
+package com.mentra.bluetoothsdk.otaserver
+
+import java.io.File
+import java.net.HttpURLConnection
+import java.net.URL
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.After
+import org.junit.Before
+import org.junit.Test
+
+class LocalOtaServerTest {
+    private lateinit var server: LocalOtaServer
+    private lateinit var artifactFile: File
+    private var port = 0
+
+    private val manifest = """{"apps":{"com.mentra.asg_client":{"versionCode":1}}}"""
+    private val artifactBytes = ByteArray(1024) { (it % 251).toByte() }
+    private val sha = "a".repeat(64)
+
+    @Before
+    fun startServer() {
+        artifactFile = File.createTempFile("ota-artifact", ".bin").apply {
+            writeBytes(artifactBytes)
+        }
+        server = LocalOtaServer(onLog = {})
+        server.configure(manifest, mapOf(sha to artifactFile))
+        port = server.start("127.0.0.1", 0)
+    }
+
+    @After
+    fun stopServer() {
+        server.close()
+        artifactFile.delete()
+    }
+
+    @Test
+    fun `serves the configured manifest`() {
+        val connection = open("/version.json")
+        assertThat(connection.responseCode).isEqualTo(200)
+        assertThat(connection.contentType).isEqualTo("application/json")
+        assertThat(connection.inputStream.readBytes().decodeToString()).isEqualTo(manifest)
+    }
+
+    @Test
+    fun `streams a full artifact`() {
+        val connection = open("/artifacts/$sha")
+        assertThat(connection.responseCode).isEqualTo(200)
+        assertThat(connection.inputStream.readBytes()).isEqualTo(artifactBytes)
+    }
+
+    @Test
+    fun `returns 404 for unknown artifacts`() {
+        val connection = open("/artifacts/${"b".repeat(64)}")
+        assertThat(connection.responseCode).isEqualTo(404)
+    }
+
+    @Test
+    fun `rejects non-GET methods`() {
+        val connection = open("/version.json")
+        connection.requestMethod = "POST"
+        connection.doOutput = true
+        connection.outputStream.use { it.write("{}".toByteArray()) }
+        assertThat(connection.responseCode).isEqualTo(405)
+    }
+
+    @Test
+    fun `reconfigures while running`() {
+        server.configure("""{"updated":true}""", emptyMap())
+        val manifestConnection = open("/version.json")
+        assertThat(manifestConnection.inputStream.readBytes().decodeToString())
+            .isEqualTo("""{"updated":true}""")
+        val artifactConnection = open("/artifacts/$sha")
+        assertThat(artifactConnection.responseCode).isEqualTo(404)
+    }
+
+    private fun open(path: String): HttpURLConnection {
+        val connection = URL("http://127.0.0.1:$port$path").openConnection() as HttpURLConnection
+        connection.connectTimeout = 5_000
+        connection.readTimeout = 5_000
+        return connection
+    }
+}

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

@@ -0,0 +1,69 @@
+package com.mentra.bluetoothsdk.services
+
+import android.content.pm.ServiceInfo
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class ForegroundServiceTypeTest {
+    @Test
+    fun `bootstrap starts as dataSync`() {
+        assertEquals(
+            ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC,
+            ForegroundService.bootstrapServiceType(),
+        )
+    }
+
+    @Test
+    fun `preferred types remove dataSync once connectedDevice is available`() {
+        val serviceType =
+            ForegroundService.preferredServiceType(
+                hasConnectedDeviceAccess = true,
+                hasMicrophoneAccess = false,
+                hasLocationAccess = false,
+                includeMediaPlayback = false,
+            )
+
+        assertTrue(
+            serviceType and ServiceInfo.FOREGROUND_SERVICE_TYPE_CONNECTED_DEVICE != 0,
+        )
+        assertEquals(
+            0,
+            serviceType and ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC,
+        )
+    }
+
+    @Test
+    fun `preferred types retain dataSync only when no better type is available`() {
+        val serviceType =
+            ForegroundService.preferredServiceType(
+                hasConnectedDeviceAccess = false,
+                hasMicrophoneAccess = false,
+                hasLocationAccess = false,
+                includeMediaPlayback = false,
+            )
+
+        assertEquals(
+            ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC,
+            serviceType,
+        )
+    }
+
+    @Test
+    fun `production mask never carries dataSync with media playback`() {
+        val serviceType =
+            ForegroundService.preferredServiceType(
+                hasConnectedDeviceAccess = true,
+                hasMicrophoneAccess = true,
+                hasLocationAccess = true,
+            )
+
+        assertEquals(
+            0,
+            serviceType and ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC,
+        )
+        assertTrue(
+            serviceType and ServiceInfo.FOREGROUND_SERVICE_TYPE_MEDIA_PLAYBACK != 0,
+        )
+    }
+}

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

@@ -0,0 +1,73 @@
+package com.mentra.bluetoothsdk.sgcs
+
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class BesOtaHeartbeatGuardTest {
+    @Test
+    fun leaseSuppressesUntilDeadlineAndThenExpires() {
+        val guard = BesOtaHeartbeatGuard(120_000)
+        guard.refresh(1_000)
+
+        assertTrue(guard.shouldSuppress(120_999))
+        assertFalse(guard.shouldSuppress(121_000))
+    }
+
+    @Test
+    fun progressRenewsLease() {
+        val guard = BesOtaHeartbeatGuard(120_000)
+        guard.refresh(1_000)
+        guard.refresh(60_000)
+
+        assertTrue(guard.shouldSuppress(121_000))
+        assertFalse(guard.shouldSuppress(180_000))
+    }
+
+    @Test
+    fun terminalStatusClearsLeaseImmediately() {
+        val guard = BesOtaHeartbeatGuard(120_000)
+        guard.refresh(1_000)
+        guard.clear()
+
+        assertFalse(guard.shouldSuppress(1_001))
+    }
+
+    @Test
+    fun besInstallStatusArmsLease() {
+        val guard = BesOtaHeartbeatGuard(120_000)
+
+        guard.observeOtaStatus("BES", "INSTALL", "in_progress", 1_000)
+
+        assertTrue(guard.shouldSuppress(120_999))
+    }
+
+    @Test
+    fun legacyBesInstallStatusUsesSameLease() {
+        val guard = BesOtaHeartbeatGuard(120_000)
+
+        guard.observeOtaStatus("bes", "install", "in_progress", 5_000)
+
+        assertTrue(guard.shouldSuppress(124_999))
+    }
+
+    @Test
+    fun unrelatedStatusDoesNotClearActiveLease() {
+        val guard = BesOtaHeartbeatGuard(120_000)
+        guard.observeOtaStatus("bes", "install", "in_progress", 1_000)
+
+        guard.observeOtaStatus("apk", "install", "complete", 2_000)
+
+        assertTrue(guard.shouldSuppress(120_999))
+    }
+
+    @Test
+    fun besStepCompleteClearsLease() {
+        val guard = BesOtaHeartbeatGuard(120_000)
+        guard.observeOtaStatus("bes", "install", "in_progress", 1_000)
+
+        guard.observeOtaStatus("bes", "install", "step_complete", 2_000)
+
+        assertFalse(guard.shouldSuppress(2_001))
+    }
+}

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

@@ -0,0 +1,67 @@
+package com.mentra.bluetoothsdk.sgcs
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Test
+
+class BesOtaProgressMapperTest {
+    @Test
+    fun explicitSuccessIsTerminal() {
+        val mapping = mapBesOtaProgress("success", 0, null)
+
+        assertEquals("FINISHED", mapping.status)
+        assertEquals(100, mapping.progress)
+        assertNull(mapping.errorMessage)
+    }
+
+    @Test
+    fun hundredPercentUpdateIsAlsoNonterminal() {
+        val mapping = mapBesOtaProgress("update", 100, null)
+
+        assertEquals("PROGRESS", mapping.status)
+        assertEquals(95, mapping.progress)
+    }
+
+    @Test
+    fun roundedHundredPercentUpdateIsCappedBelowTerminal() {
+        val mapping = mapBesOtaProgress("update", 98, null)
+
+        assertEquals("PROGRESS", mapping.status)
+        assertEquals(95, mapping.progress)
+    }
+
+    @Test
+    fun explicitBesErrorRemainsTerminalFailure() {
+        val mapping = mapBesOtaProgress("error", 65, "CRC failed")
+
+        assertEquals("FAILED", mapping.status)
+        assertEquals(65, mapping.progress)
+        assertEquals("CRC failed", mapping.errorMessage)
+    }
+
+    @Test
+    fun blankBesErrorUsesStableFallback() {
+        val mapping = mapBesOtaProgress("error", 65, "   ")
+
+        assertEquals("FAILED", mapping.status)
+        assertEquals("BES update failed", mapping.errorMessage)
+    }
+
+    @Test
+    fun ordinaryUpdateProgressRemainsNonterminal() {
+        val mapping = mapBesOtaProgress("update", 40, null)
+
+        assertEquals("PROGRESS", mapping.status)
+        assertEquals(40, mapping.progress)
+        assertNull(mapping.errorMessage)
+    }
+
+    @Test
+    fun failAliasRemainsTerminalFailure() {
+        val mapping = mapBesOtaProgress("fail", 25, "apply failed")
+
+        assertEquals("FAILED", mapping.status)
+        assertEquals(25, mapping.progress)
+        assertEquals("apply failed", mapping.errorMessage)
+    }
+}

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

@@ -0,0 +1,39 @@
+package com.mentra.bluetoothsdk.sgcs
+
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class MentraLiveGattCharacteristicsTest {
+    @Test
+    fun `accepts the core characteristic pair without requiring optional characteristics`() {
+        assertTrue(
+            hasRequiredMentraLiveCoreCharacteristics(
+                hasRxCharacteristic = true,
+                hasTxCharacteristic = true,
+            )
+        )
+    }
+
+    @Test
+    fun `rejects an incomplete core characteristic pair`() {
+        assertFalse(
+            hasRequiredMentraLiveCoreCharacteristics(
+                hasRxCharacteristic = false,
+                hasTxCharacteristic = true,
+            )
+        )
+        assertFalse(
+            hasRequiredMentraLiveCoreCharacteristics(
+                hasRxCharacteristic = true,
+                hasTxCharacteristic = false,
+            )
+        )
+        assertFalse(
+            hasRequiredMentraLiveCoreCharacteristics(
+                hasRxCharacteristic = false,
+                hasTxCharacteristic = false,
+            )
+        )
+    }
+}

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

@@ -0,0 +1,133 @@
+package com.mentra.bluetoothsdk.sgcs
+
+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 MentraLivePairingAdvertisementParserTest {
+    @Test
+    fun connectedPairingRecoveryRequiresExplicitPendingTarget() {
+        assertFalse(
+                isPendingMentraLivePairingTarget(
+                        connectedName = "MENTRA_LIVE_BLE_OWNER",
+                        connectedAddress = "AA:BB:CC:DD:EE:FF",
+                        pendingName = "",
+                        pendingAddress = "",
+                )
+        )
+        assertTrue(
+                isPendingMentraLivePairingTarget(
+                        connectedName = "MENTRA_LIVE_BLE_TARGET",
+                        connectedAddress = "AA:BB:CC:DD:EE:FF",
+                        pendingName = "MENTRA_LIVE_BLE_TARGET",
+                        pendingAddress = "",
+                )
+        )
+        assertTrue(
+                isPendingMentraLivePairingTarget(
+                        connectedName = "MENTRA_LIVE_BLE_TARGET",
+                        connectedAddress = "AA:BB:CC:DD:EE:FF",
+                        pendingName = "OTHER",
+                        pendingAddress = "aa:bb:cc:dd:ee:ff",
+                )
+        )
+        assertFalse(
+                isPendingMentraLivePairingTarget(
+                        connectedName = "MENTRA_LIVE_BLE_TARGET",
+                        connectedAddress = "AA:BB:CC:DD:EE:FF",
+                        pendingName = "MENTRA_LIVE_BLE_TARGET",
+                        pendingAddress = "11:22:33:44:55:66",
+                )
+        )
+    }
+
+    @Test
+    fun connectedPairingRecoveryRequiresActiveGattConnection() {
+        assertFalse(
+                shouldRecoverConnectedMentraLivePairingTarget(
+                        isConnected = false,
+                        connectedName = "MENTRA_LIVE_BLE_TARGET",
+                        connectedAddress = "AA:BB:CC:DD:EE:FF",
+                        pendingName = "MENTRA_LIVE_BLE_TARGET",
+                        pendingAddress = "AA:BB:CC:DD:EE:FF",
+                )
+        )
+        assertTrue(
+                shouldRecoverConnectedMentraLivePairingTarget(
+                        isConnected = true,
+                        connectedName = "MENTRA_LIVE_BLE_TARGET",
+                        connectedAddress = "AA:BB:CC:DD:EE:FF",
+                        pendingName = "MENTRA_LIVE_BLE_TARGET",
+                        pendingAddress = "AA:BB:CC:DD:EE:FF",
+                )
+        )
+    }
+
+    @Test
+    fun parsesMarkedSecurePairingAdvertisement() {
+        val result = MentraLivePairingAdvertisementParser.parse(securePayload(pairingFlag = 1))
+
+        assertEquals("1234", result?.pairingCode)
+        assertTrue(result?.pairingMode == true)
+    }
+
+    @Test
+    fun parsesMarkedOwnedAdvertisement() {
+        val result = MentraLivePairingAdvertisementParser.parse(securePayload(pairingFlag = 0))
+
+        assertEquals("1234", result?.pairingCode)
+        assertFalse(result?.pairingMode == true)
+    }
+
+    @Test
+    fun rejectsLegacyPayloadThatMatchesOldVersionCapabilityHeuristic() {
+        val legacyPayload = ByteArray(27)
+        legacyPayload[5] = 0
+        legacyPayload[6] = 1
+        legacyPayload[7] = 1
+        legacyPayload[8] = 0x34
+        legacyPayload[9] = 0x12
+
+        assertNull(MentraLivePairingAdvertisementParser.parse(legacyPayload))
+    }
+
+    @Test
+    fun rejectsUnmarkedFirstGenerationSecureTrailer() {
+        val unmarkedPayload = securePayload(pairingFlag = 1)
+        unmarkedPayload[10] = 0x11
+        unmarkedPayload[11] = 0x22
+
+        assertNull(MentraLivePairingAdvertisementParser.parse(unmarkedPayload))
+    }
+
+    @Test
+    fun rejectsEveryLegacyVersionAndCapabilityCombination() {
+        for (version in 0..255) {
+            for (capability in 0..255) {
+                val legacyPayload = ByteArray(27)
+                legacyPayload[5] = 1
+                legacyPayload[6] = version.toByte()
+                legacyPayload[7] = capability.toByte()
+                legacyPayload[10] = 0x4D
+                // Offset 11 is padding in the legacy format, so it cannot contain the second
+                // non-zero marker byte.
+                legacyPayload[11] = 0
+                assertNull(MentraLivePairingAdvertisementParser.parse(legacyPayload))
+            }
+        }
+    }
+
+    private fun securePayload(pairingFlag: Int): ByteArray {
+        return ByteArray(27).also {
+            it[5] = pairingFlag.toByte()
+            it[6] = 2
+            it[7] = 1
+            it[8] = 0x34
+            it[9] = 0x12
+            it[10] = 0x4D
+            it[11] = 0x50
+        }
+    }
+}

package/android/src/test/java/com/mentra/bluetoothsdk/utils/BleJsonCompactTest.java

@@ -43,10 +43,13 @@ public class BleJsonCompactTest {
         assertEquals("photo_status", compact.getString("t"));
         assertEquals("p1", compact.getString("r"));
         assertEquals(3, compact.getInt("s"));
-        assertEquals(100L, compact.getLong("ts"));
-        assertFalse(compact.has("rc"));
+        assertEquals(1_700_000_000_100L, compact.getLong("timestamp"));
+        assertFalse(compact.has("ts"));
+        assertTrue(compact.has("rc"));
+        assertFalse(compact.getBoolean("rc"));
         assertEquals(1, compact.getJSONObject("cm").getInt("aes"));
         assertEquals(1, compact.getJSONObject("cm").getInt("src"));
+        assertTrue(compact.toString().length() < input.toString().length());
     }
 
     @Test
@@ -73,7 +76,7 @@ public class BleJsonCompactTest {
     }
 
     @Test
-    public void resolvedConfigDiffOmitsRepeatPayload() throws Exception {
+    public void resolvedConfigIsAlwaysSent() throws Exception {
         BleJsonCompact.markSessionConnected(1_000L);
         JSONObject config = new JSONObject("{\"source\":\"sdk\",\"transferMethod\":\"auto\"}");
         JSONObject first =
@@ -99,13 +102,97 @@ public class BleJsonCompactTest {
         JSONObject secondWire = BleJsonCompact.encode(second);
 
         assertTrue(firstWire.has("resolvedConfig"));
-        assertFalse(secondWire.has("resolvedConfig"));
-        assertEquals(
-                BleJsonCompact.hashConfig(config),
-                secondWire.getString(BleJsonCompact.KEY_RESOLVED_CONFIG_HASH));
+        assertTrue(secondWire.has("resolvedConfig"));
+        assertFalse(secondWire.has(BleJsonCompact.KEY_RESOLVED_CONFIG_HASH));
 
+        BleJsonCompact.markSessionConnected(9_000L);
         JSONObject restoredSecond = BleJsonCompact.decode(secondWire);
         assertEquals("sdk", restoredSecond.getJSONObject("resolvedConfig").getString("source"));
+        assertEquals(1_200L, restoredSecond.getLong("timestamp"));
+    }
+
+    @Test
+    public void legacyResolvedConfigHashStillDecodesWhenCached() throws Exception {
+        JSONObject config = new JSONObject("{\"source\":\"sdk\",\"transferMethod\":\"auto\"}");
+        JSONObject full =
+                new JSONObject(
+                        "{\"t\":\"stream_status\",\"s\":\"streaming\",\"resolvedConfig\":"
+                                + config
+                                + "}");
+        BleJsonCompact.decode(full);
+        JSONObject hashOnly =
+                new JSONObject(
+                        "{\"t\":\"stream_status\",\"s\":\"streaming\",\"rch\":\""
+                                + BleJsonCompact.hashConfig(config)
+                                + "\"}");
+
+        JSONObject restored = BleJsonCompact.decode(hashOnly);
+
+        assertEquals("sdk", restored.getJSONObject("resolvedConfig").getString("source"));
+        assertFalse(restored.has(BleJsonCompact.KEY_RESOLVED_CONFIG_HASH));
+    }
+
+    @Test
+    public void legacyResolvedConfigCacheMissKeepsHashForDiagnostics() throws Exception {
+        JSONObject hashOnly =
+                new JSONObject(
+                        "{\"t\":\"stream_status\",\"s\":\"streaming\",\"rch\":\"deadbeef\"}");
+
+        JSONObject restored = BleJsonCompact.decode(hashOnly);
+
+        assertEquals("deadbeef", restored.getString(BleJsonCompact.KEY_RESOLVED_CONFIG_HASH));
+        assertFalse(restored.has("resolvedConfig"));
+    }
+
+    @Test
+    public void ambiguousNestedWireKeysFallBackToVerboseJson() throws Exception {
+        JSONObject input =
+                new JSONObject(
+                        "{\"type\":\"stream_status\",\"payload\":{"
+                                + "\"s\":\"literal\",\"kind\":0,\"source\":1}}");
+
+        JSONObject wire = BleJsonCompact.encode(input);
+
+        assertTrue(wire.has("type"));
+        assertFalse(wire.has("t"));
+        assertEquals("literal", wire.getJSONObject("payload").getString("s"));
+        assertEquals(0, wire.getJSONObject("payload").getInt("kind"));
+        assertEquals(1, wire.getJSONObject("payload").getInt("source"));
+        JSONObject restored = BleJsonCompact.decodeIfSupported(wire);
+        assertEquals("literal", restored.getJSONObject("payload").getString("s"));
+        assertEquals(0, restored.getJSONObject("payload").getInt("kind"));
+        assertEquals(1, restored.getJSONObject("payload").getInt("source"));
+    }
+
+    @Test
+    public void numericEnumFieldsFallBackToVerboseJson() throws Exception {
+        JSONObject input =
+                new JSONObject(
+                        "{\"type\":\"stream_status\",\"payload\":{\"kind\":0,\"source\":1}}");
+
+        JSONObject wire = BleJsonCompact.encode(input);
+
+        assertTrue(wire.has("type"));
+        assertFalse(wire.has("t"));
+        assertEquals(0, wire.getJSONObject("payload").getInt("kind"));
+        assertEquals(1, wire.getJSONObject("payload").getInt("source"));
+    }
+
+    @Test
+    public void absoluteTimestampSurvivesDifferentSessionEpochs() throws Exception {
+        BleJsonCompact.markSessionConnected(1_000L);
+        JSONObject input =
+                new JSONObject(
+                        "{\"type\":\"stream_status\",\"status\":\"streaming\","
+                                + "\"timestamp\":1700000000123}");
+
+        JSONObject wire = BleJsonCompact.encode(input);
+        BleJsonCompact.markSessionConnected(9_000L);
+        JSONObject restored = BleJsonCompact.decode(wire);
+
+        assertEquals(1_700_000_000_123L, wire.getLong("timestamp"));
+        assertFalse(wire.has("ts"));
+        assertEquals(1_700_000_000_123L, restored.getLong("timestamp"));
     }
 
     @Test
@@ -135,6 +222,60 @@ public class BleJsonCompactTest {
         assertEquals("wifi_scan_result", BleJsonCompact.encode(wifiScan).getString("t"));
     }
 
+    @Test
+    public void startStreamPreservesDisabledSound() throws Exception {
+        JSONObject start =
+                new JSONObject(
+                        "{\"type\":\"start_stream\",\"streamUrl\":\"https://example.test/whip\","
+                                + "\"sound\":false}");
+
+        JSONObject wire = BleJsonCompact.encode(start);
+
+        assertEquals("start_stream", wire.getString("t"));
+        assertTrue(wire.has("sound"));
+        assertFalse(wire.getBoolean("sound"));
+        assertFalse(BleJsonCompact.decode(wire).getBoolean("sound"));
+    }
+
+    @Test
+    public void jsonValuesRoundTripAtEveryDepth() throws Exception {
+        JSONObject status =
+                new JSONObject(
+                        "{\"type\":\"stream_status\",\"status\":\"stopped\","
+                                + "\"streaming\":false,\"reconnecting\":false,"
+                                + "\"resolvedConfig\":{\"audio\":{\"echoCancellation\":false,"
+                                + "\"noiseSuppression\":false}},"
+                                + "\"nullValue\":null,\"emptyObject\":{},\"emptyArray\":[]}");
+
+        JSONObject wire = BleJsonCompact.encode(status);
+
+        assertTrue(wire.has("streaming"));
+        assertFalse(wire.getBoolean("streaming"));
+        assertTrue(wire.has("rc"));
+        assertFalse(wire.getBoolean("rc"));
+        JSONObject wireAudio = wire.getJSONObject("resolvedConfig").getJSONObject("audio");
+        assertTrue(wireAudio.has("echoCancellation"));
+        assertFalse(wireAudio.getBoolean("echoCancellation"));
+        assertTrue(wireAudio.has("noiseSuppression"));
+        assertFalse(wireAudio.getBoolean("noiseSuppression"));
+        assertTrue(wire.has("nullValue"));
+        assertTrue(wire.isNull("nullValue"));
+        assertEquals(0, wire.getJSONObject("emptyObject").length());
+        assertEquals(0, wire.getJSONArray("emptyArray").length());
+
+        JSONObject restored = BleJsonCompact.decode(wire);
+        assertFalse(restored.getBoolean("streaming"));
+        assertFalse(restored.getBoolean("reconnecting"));
+        JSONObject restoredAudio =
+                restored.getJSONObject("resolvedConfig").getJSONObject("audio");
+        assertFalse(restoredAudio.getBoolean("echoCancellation"));
+        assertFalse(restoredAudio.getBoolean("noiseSuppression"));
+        assertTrue(restored.has("nullValue"));
+        assertTrue(restored.isNull("nullValue"));
+        assertEquals(0, restored.getJSONObject("emptyObject").length());
+        assertEquals(0, restored.getJSONArray("emptyArray").length());
+    }
+
     @Test
     public void streamTelemetryRoundTripsWithCompactKeys() throws Exception {
         JSONObject status =