@mentra/bluetooth-sdk 3.3.0-dev.419 → 3.3.0-dev.421

package/android/src/main/java/com/mentra/bluetoothsdk/utils/MessageChunkReassembler.java

@@ -3,6 +3,7 @@ package com.mentra.bluetoothsdk.utils;
 import com.mentra.bluetoothsdk.utils.NativeLog;
 
 import java.util.Map;
+import java.util.Objects;
 import java.util.concurrent.ConcurrentHashMap;
 
 /**
@@ -17,7 +18,22 @@ public class MessageChunkReassembler {
 
     private final Map<Integer, BinarySession> activeBinarySessions = new ConcurrentHashMap<>();
 
+    /**
+     * Sessions whose fragments came from different receive origins (connection or wire epoch).
+     * Such a session is discarded rather than reassembled across the boundary.
+     */
+    private long mixedOriginDrops = 0;
+
+    public long getMixedOriginDrops() {
+        return mixedOriginDrops;
+    }
+
     public byte[] addBinaryFragment(int msgId, int fragIdx, int fragCount, byte[] data) {
+        return addBinaryFragment(msgId, fragIdx, fragCount, data, null);
+    }
+
+    /** Like {@link #addBinaryFragment(int, int, int, byte[])}; fragments of one message must share {@code origin}. */
+    public byte[] addBinaryFragment(int msgId, int fragIdx, int fragCount, byte[] data, Object origin) {
         cleanupTimedOutSessions();
 
         if (msgId < 0 || fragCount <= 0 || fragIdx < 0 || fragIdx >= fragCount || data == null) {
@@ -33,11 +49,16 @@ public class MessageChunkReassembler {
 
         BinarySession session = activeBinarySessions.compute(msgId, (ignored, existingSession) -> {
             if (existingSession == null) {
-                return new BinarySession(msgId, fragCount);
+                return new BinarySession(msgId, fragCount, origin);
+            }
+            if (!Objects.equals(existingSession.origin, origin)) {
+                NativeLog.w(TAG, "Receive origin changed for msgId " + msgId + ", discarding session");
+                mixedOriginDrops++;
+                return new BinarySession(msgId, fragCount, origin);
             }
             if (existingSession.fragCount != fragCount) {
                 NativeLog.w(TAG, "fragCount mismatch for msgId " + msgId + ", resetting session");
-                return new BinarySession(msgId, fragCount);
+                return new BinarySession(msgId, fragCount, origin);
             }
             return existingSession;
         });
@@ -58,6 +79,11 @@ public class MessageChunkReassembler {
     }
 
     public String addChunk(String chunkId, int chunkIndex, int totalChunks, String data) {
+        return addChunk(chunkId, chunkIndex, totalChunks, data, null);
+    }
+
+    /** Like {@link #addChunk(String, int, int, String)}; chunks of one message must share {@code origin}. */
+    public String addChunk(String chunkId, int chunkIndex, int totalChunks, String data, Object origin) {
         cleanupTimedOutSessions();
 
         if (chunkId == null || chunkId.isEmpty() || totalChunks <= 0 || chunkIndex < 0
@@ -74,12 +100,17 @@ public class MessageChunkReassembler {
 
         ChunkSession session = activeSessions.compute(chunkId, (ignored, existingSession) -> {
             if (existingSession == null) {
-                return new ChunkSession(chunkId, totalChunks);
+                return new ChunkSession(chunkId, totalChunks, origin);
+            }
+            if (!Objects.equals(existingSession.origin, origin)) {
+                NativeLog.w(TAG, "Receive origin changed for " + chunkId + ", discarding session");
+                mixedOriginDrops++;
+                return new ChunkSession(chunkId, totalChunks, origin);
             }
             if (existingSession.totalChunks != totalChunks) {
                 NativeLog.w(TAG, "totalChunks mismatch for " + chunkId + " (expected "
                         + existingSession.totalChunks + ", got " + totalChunks + "), resetting session");
-                return new ChunkSession(chunkId, totalChunks);
+                return new ChunkSession(chunkId, totalChunks, origin);
             }
             return existingSession;
         });
@@ -146,8 +177,10 @@ public class MessageChunkReassembler {
         final int totalChunks;
         final long createdAt;
         final Map<Integer, String> chunks;
+        final Object origin;
 
-        ChunkSession(String chunkId, int totalChunks) {
+        ChunkSession(String chunkId, int totalChunks, Object origin) {
+            this.origin = origin;
             this.chunkId = chunkId;
             this.totalChunks = totalChunks;
             this.createdAt = System.currentTimeMillis();
@@ -184,8 +217,10 @@ public class MessageChunkReassembler {
         final int fragCount;
         final long createdAt;
         final Map<Integer, byte[]> fragments;
+        final Object origin;
 
-        BinarySession(int msgId, int fragCount) {
+        BinarySession(int msgId, int fragCount, Object origin) {
+            this.origin = origin;
             this.msgId = msgId;
             this.fragCount = fragCount;
             this.createdAt = System.currentTimeMillis();

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

@@ -0,0 +1,117 @@
+package com.mentra.bluetoothsdk
+
+import androidx.test.core.app.ApplicationProvider
+import com.mentra.bluetoothsdk.debug.BleEvidenceLog
+import com.mentra.bluetoothsdk.sgcs.G1PairingTest
+import kotlinx.coroutines.CoroutineStart
+import kotlinx.coroutines.async
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.yield
+import org.json.JSONObject
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+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.annotation.Config
+
+/**
+ * Runs the production MentraBluetoothSdk.requestWifiScan and its Bridge chunk handling. Chunks
+ * enter through Bridge.updateWifiScanResults, the same call MentraLive makes after decoding.
+ */
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [33], shadows = [G1PairingTest.ShadowLc3Cpp::class], instrumentedPackages = ["com.mentra.lc3Lib"])
+class WifiScanEvidenceTest {
+    private lateinit var sdk: MentraBluetoothSdk
+
+    @Before fun setup() {
+        BleEvidenceLog.resetForTest()
+        sdk = MentraBluetoothSdk.create(ApplicationProvider.getApplicationContext(), object : MentraBluetoothSdkListener {})
+    }
+
+    @After fun close() = sdk.close()
+
+    private fun records(kind: String): List<JSONObject> {
+        val array = BleEvidenceLog.snapshot(0, null).getJSONArray("records")
+        return (0 until array.length()).map { array.getJSONObject(it) }.filter { it.getString("kind") == kind }
+    }
+
+    private fun freshScanId() = records("scan_request").single { it.getString("mode") == "fresh" }.getString("scanId")
+
+    private fun chunk(scanId: String?, ssid: String, complete: Boolean) =
+        Bridge.updateWifiScanResults(
+            listOf(mapOf("ssid" to ssid, "requiresPassword" to true, "signalStrength" to -40)),
+            complete,
+            scanId,
+            BleEvidenceLog.scanChunk(null, scanId, emptyList(), complete, entriesParsed = true),
+        )
+
+    @Test
+    fun `explicit completion of the fresh request is the only complete terminal`() = runBlocking {
+        val scan = async(start = CoroutineStart.UNDISPATCHED) { sdk.requestWifiScan() }
+        val scanId = freshScanId()
+        chunk(scanId, "LabAP", complete = false)
+        yield()
+        assertFalse(scan.isCompleted)
+        assertTrue("streamed chunks are not completion", records("scan_terminal").isEmpty())
+
+        chunk(scanId, "Other", complete = true)
+        assertEquals(listOf("LabAP", "Other"), scan.await().map { it.ssid })
+        val terminal = records("scan_terminal").single()
+        assertEquals(scanId, terminal.getString("scanId"))
+        assertEquals("complete", terminal.getString("result"))
+    }
+
+    @Test
+    fun `a joined caller is recorded as joining the older request, not a fresh scan`() = runBlocking {
+        val first = async(start = CoroutineStart.UNDISPATCHED) { sdk.requestWifiScan() }
+        val joined = async(start = CoroutineStart.UNDISPATCHED) { sdk.requestWifiScan() }
+        val scanId = freshScanId()
+        val requests = records("scan_request")
+        assertEquals(listOf("fresh", "joined"), requests.map { it.getString("mode") })
+        assertEquals(listOf(scanId, scanId), requests.map { it.getString("scanId") })
+
+        chunk(scanId, "LabAP", complete = true)
+        assertEquals(first.await(), joined.await())
+    }
+
+    @Test
+    fun `a chunk for another scan id neither resolves nor completes the fresh request`() = runBlocking {
+        val scan = async(start = CoroutineStart.UNDISPATCHED) { sdk.requestWifiScan() }
+        val scanId = freshScanId()
+        chunk("scan-older", "Stale", complete = true)
+        yield()
+        assertFalse(scan.isCompleted)
+        assertTrue(records("scan_terminal").isEmpty())
+
+        chunk(scanId, "LabAP", complete = true)
+        assertEquals(listOf("LabAP"), scan.await().map { it.ssid })
+    }
+
+    @Test
+    fun `legacy uncorrelated results are never a correlated completion`() = runBlocking {
+        val scan = async(start = CoroutineStart.UNDISPATCHED) { sdk.requestWifiScan() }
+        val scanId = freshScanId()
+        chunk(null, "Legacy", complete = true)
+        assertEquals(listOf("Legacy"), scan.await().map { it.ssid })
+        val terminal = records("scan_terminal").single()
+        assertEquals(scanId, terminal.getString("scanId"))
+        assertEquals("legacy_uncorrelated", terminal.getString("result"))
+    }
+
+    @Test
+    fun `a timeout that returns partial results is recorded as partial, not complete`() = runBlocking {
+        val scan = async(start = CoroutineStart.UNDISPATCHED) { sdk.requestWifiScan() }
+        val scanId = freshScanId()
+        chunk(scanId, "LabAP", complete = false)
+        // Customer behavior is unchanged: the promise still resolves with the partial list.
+        assertEquals(listOf("LabAP"), scan.await().map { it.ssid })
+        val terminal = records("scan_terminal").single()
+        assertEquals(scanId, terminal.getString("scanId"))
+        assertEquals("timeout_partial", terminal.getString("result"))
+        assertEquals(1, terminal.getInt("networks"))
+    }
+}

package/android/src/test/java/com/mentra/bluetoothsdk/debug/BleEvidenceLogTest.kt

@@ -0,0 +1,282 @@
+package com.mentra.bluetoothsdk.debug
+
+import android.os.Handler
+import android.os.HandlerThread
+import android.os.Looper
+import org.json.JSONObject
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNotEquals
+import org.junit.Assert.assertNull
+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.annotation.Config
+
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [33])
+class BleEvidenceLogTest {
+    @Before fun reset() = BleEvidenceLog.resetForTest()
+
+    private fun records(snapshot: JSONObject) =
+        snapshot.getJSONArray("records").let { array -> (0 until array.length()).map { array.getJSONObject(it) } }
+
+    @Test
+    fun `ids derive from one stream and a strict sequence`() {
+        val origin = BleEvidenceLog.connectionAccepted("AA:BB:CC:DD:EE:01")
+        val first = BleEvidenceLog.battery(origin, 57, "battery_status", null)
+        val second = BleEvidenceLog.battery(origin, 57, "battery_status", null)
+
+        assertEquals("${BleEvidenceLog.streamId}:2", first)
+        assertEquals("${BleEvidenceLog.streamId}:3", second)
+        val snapshot = BleEvidenceLog.snapshot(0, null)
+        assertEquals("ok", snapshot.getString("outcome"))
+        assertEquals(listOf(1L, 2L, 3L), records(snapshot).map { it.getLong("seq") })
+        assertEquals(3L, snapshot.getLong("fenceSeq"))
+        // Percent-only sources never claim PMU charging.
+        assertFalse(records(snapshot)[1].has("pmuCharging"))
+    }
+
+    @Test
+    fun `eviction is an explicit gap, never a clean interval`() {
+        repeat(BleEvidenceLog.CAPACITY + 88) { BleEvidenceLog.receiveRejected("stale_gatt", null) }
+
+        val gap = BleEvidenceLog.snapshot(0, null)
+        assertEquals("gap", gap.getString("outcome"))
+        assertEquals(88L, gap.getLong("droppedCount"))
+        assertEquals(89L, gap.getLong("firstRetainedSeq"))
+        assertEquals("ok", BleEvidenceLog.snapshot(88, null).getString("outcome"))
+    }
+
+    @Test
+    fun `cursor from another process or the future is stale`() {
+        BleEvidenceLog.connectionAccepted("AA:BB:CC:DD:EE:01")
+        val oldStream = BleEvidenceLog.streamId
+        BleEvidenceLog.resetForTest()
+
+        val stale = BleEvidenceLog.snapshot(1, null)
+        assertEquals("stale_cursor", stale.getString("outcome"))
+        assertNotEquals(oldStream, stale.getString("streamId"))
+        assertEquals(0, stale.getJSONArray("records").length())
+    }
+
+    @Test
+    fun `malformed requests are refused`() {
+        assertEquals("invalid_request", BleEvidenceLog.snapshot(null, null).getString("outcome"))
+        assertEquals("invalid_request", BleEvidenceLog.snapshot(0, "LabAP").getString("outcome"))
+    }
+
+    @Test
+    fun `scan snapshot reports only the requested target and never an SSID`() {
+        val origin = BleEvidenceLog.connectionAccepted("AA:BB:CC:DD:EE:01")
+        BleEvidenceLog.scanChunk(
+            origin,
+            "scan-1",
+            listOf(
+                mapOf("ssid" to "LabAP", "requiresPassword" to true),
+                mapOf("ssid" to "Neighbor", "requiresPassword" to false),
+                mapOf("ssid" to "Stringly", "requiresPassword" to "true"),
+            ),
+            complete = true,
+            entriesParsed = true,
+        )
+
+        val targeted = BleEvidenceLog.snapshot(0, BleEvidenceLog.sha256Hex("LabAP"))
+        val chunk = records(targeted).single { it.getString("kind") == "scan_chunk" }
+        assertTrue(chunk.getBoolean("targetSeen"))
+        assertTrue(chunk.getBoolean("targetRequiresPassword"))
+        assertEquals(3, chunk.getInt("networks"))
+        assertFalse(targeted.toString().contains("LabAP"))
+        assertFalse(targeted.toString().contains("Neighbor"))
+
+        val absent = records(BleEvidenceLog.snapshot(0, BleEvidenceLog.sha256Hex("Other"))).last()
+        assertFalse(absent.getBoolean("targetSeen"))
+        assertFalse(absent.has("targetRequiresPassword"))
+
+        // Only an exact boolean counts as the security value.
+        val nonBoolean = records(BleEvidenceLog.snapshot(0, BleEvidenceLog.sha256Hex("Stringly"))).last()
+        assertTrue(nonBoolean.getBoolean("targetSeen"))
+        assertTrue(nonBoolean.isNull("targetRequiresPassword"))
+
+        assertFalse(records(BleEvidenceLog.snapshot(0, null)).last().has("targetSeen"))
+    }
+
+    private fun chunkRecord(target: String) =
+        records(BleEvidenceLog.snapshot(0, BleEvidenceLog.sha256Hex(target))).last { it.getString("kind") == "scan_chunk" }
+
+    @Test
+    fun `a target beyond retained digests is unknown, never absent`() {
+        val origin = BleEvidenceLog.connectionAccepted("AA:BB:CC:DD:EE:01")
+        // 70 unique networks: only the first 64 digests are retained.
+        val networks = (1..70).map { mapOf("ssid" to "Net$it", "requiresPassword" to (it % 2 == 0)) }
+        BleEvidenceLog.scanChunk(origin, "scan-many", networks, complete = true, entriesParsed = true)
+
+        val beyond = chunkRecord("Net70")
+        assertTrue("target at index 70 must not be reported absent", beyond.isNull("targetSeen"))
+        assertEquals("incomplete", beyond.getString("targetCoverage"))
+        assertFalse(beyond.has("targetRequiresPassword"))
+        assertEquals(70, beyond.getInt("networks"))
+
+        // A retained target is still exact even when the chunk is truncated.
+        val covered = chunkRecord("Net2")
+        assertTrue(covered.getBoolean("targetSeen"))
+        assertTrue(covered.getBoolean("targetRequiresPassword"))
+        assertEquals("incomplete", covered.getString("targetCoverage"))
+
+        // Neither SSIDs nor unrelated digests are serialized.
+        val serialized = BleEvidenceLog.snapshot(0, BleEvidenceLog.sha256Hex("Net70")).toString()
+        assertFalse(serialized.contains("Net"))
+        assertFalse(serialized.contains(BleEvidenceLog.sha256Hex("Net1")))
+    }
+
+    @Test
+    fun `absence is reported only with complete coverage`() {
+        val origin = BleEvidenceLog.connectionAccepted("AA:BB:CC:DD:EE:01")
+        val networks = (1..64).map { mapOf("ssid" to "Net$it", "requiresPassword" to true) }
+        BleEvidenceLog.scanChunk(origin, "scan-full", networks, complete = true, entriesParsed = true)
+
+        val absent = chunkRecord("LabAP")
+        assertEquals("complete", absent.getString("targetCoverage"))
+        assertFalse(absent.getBoolean("targetSeen"))
+        val present = chunkRecord("Net64")
+        assertTrue(present.getBoolean("targetSeen"))
+        assertEquals("complete", present.getString("targetCoverage"))
+    }
+
+    @Test
+    fun `entries without an SSID or with conflicting duplicates are not certified`() {
+        val origin = BleEvidenceLog.connectionAccepted("AA:BB:CC:DD:EE:01")
+        BleEvidenceLog.scanChunk(
+            origin,
+            "scan-odd",
+            listOf(
+                mapOf("requiresPassword" to true),
+                mapOf("ssid" to "Dup", "requiresPassword" to true),
+                mapOf("ssid" to "Dup", "requiresPassword" to false),
+            ),
+            complete = true,
+            entriesParsed = true,
+        )
+        val missing = chunkRecord("LabAP")
+        assertEquals("incomplete", missing.getString("targetCoverage"))
+        assertTrue(missing.isNull("targetSeen"))
+        val duplicate = chunkRecord("Dup")
+        assertTrue(duplicate.getBoolean("targetSeen"))
+        assertTrue(duplicate.isNull("targetRequiresPassword"))
+    }
+
+    @Test
+    fun `a partially parsed chunk certifies neither absence nor security`() {
+        val origin = BleEvidenceLog.connectionAccepted("AA:BB:CC:DD:EE:01")
+        BleEvidenceLog.scanChunk(
+            origin,
+            "scan-partial",
+            listOf(mapOf("ssid" to "Other", "requiresPassword" to false)),
+            complete = true,
+            entriesParsed = false,
+        )
+        val absent = chunkRecord("LabAP")
+        assertTrue(absent.isNull("targetSeen"))
+        assertEquals("incomplete", absent.getString("targetCoverage"))
+        assertFalse(absent.getBoolean("entriesParsed"))
+        val seen = chunkRecord("Other")
+        assertTrue(seen.getBoolean("targetSeen"))
+        assertTrue(seen.isNull("targetRequiresPassword"))
+    }
+
+    @Test
+    fun `send-queue generations are ordered boundaries`() {
+        val first = BleEvidenceLog.bleGeneration(0, 0)
+        val origin = BleEvidenceLog.connectionAccepted("AA:BB:CC:DD:EE:01")
+        BleEvidenceLog.scanSend("scan-1", "queued", 0, 1, origin.connection, first)
+        BleEvidenceLog.connectionClosed(origin.connection, "remote_disconnect")
+        val second = BleEvidenceLog.bleGeneration(0, 1)
+
+        val snapshot = BleEvidenceLog.snapshot(0, null)
+        assertEquals(second, snapshot.getJSONObject("current").getLong("writeGeneration"))
+        val send = records(snapshot).single { it.getString("kind") == "scan_send" }
+        assertEquals(first, send.getLong("writeGeneration"))
+        assertEquals(listOf(0L, 1L), records(snapshot).filter { it.getString("kind") == "ble_generation" }.map { it.getLong("generation") })
+    }
+
+    @Test
+    fun `render markers accept only allowlisted surfaces, bounded values and ids of this stream`() {
+        val id = BleEvidenceLog.battery(BleEvidenceLog.connectionAccepted("AA:BB:CC:DD:EE:01"), 57, "battery_status", null)
+
+        assertFalse(BleEvidenceLog.uiRender("debug_panel", listOf(id), 1))
+        assertFalse(BleEvidenceLog.uiRender(BleEvidenceLog.SURFACE_BATTERY, listOf(id), 101))
+        assertTrue(
+            BleEvidenceLog.uiRender(
+                BleEvidenceLog.SURFACE_BATTERY,
+                listOf(id, "other-stream:2", "${BleEvidenceLog.streamId}:999"),
+                57,
+            )
+        )
+        val render = records(BleEvidenceLog.snapshot(0, null)).last()
+        assertEquals("ui_render", render.getString("kind"))
+        assertEquals(listOf(id), (0 until render.getJSONArray("eventIds").length()).map { render.getJSONArray("eventIds").getString(it) })
+        assertEquals(2, render.getInt("rejectedEventIds"))
+        assertEquals(57, render.getInt("value"))
+    }
+
+    @Test
+    fun `an out-of-range render value withdraws the surface without storing the value`() {
+        val id = BleEvidenceLog.battery(BleEvidenceLog.connectionAccepted("AA:BB:CC:DD:EE:01"), 57, "battery_status", null)
+        assertTrue(BleEvidenceLog.uiRender(BleEvidenceLog.SURFACE_BATTERY, listOf(id), 57))
+
+        for ((surface, value) in listOf(
+            BleEvidenceLog.SURFACE_BATTERY to 150,
+            BleEvidenceLog.SURFACE_BATTERY to -1,
+            BleEvidenceLog.SURFACE_WIFI_SCAN to 501,
+            BleEvidenceLog.SURFACE_WIFI_SCAN to Int.MAX_VALUE,
+        )) {
+            // The value is not accepted, but the surface's earlier marker must not stay current.
+            assertFalse(BleEvidenceLog.uiRender(surface, listOf(id), value))
+            val withdrawal = records(BleEvidenceLog.snapshot(0, null)).last()
+            assertEquals("ui_render", withdrawal.getString("kind"))
+            assertEquals(surface, withdrawal.getString("surface"))
+            assertEquals(0, withdrawal.getJSONArray("eventIds").length())
+            assertTrue(withdrawal.isNull("value"))
+            assertFalse(withdrawal.toString().contains(value.toString()))
+        }
+
+        // Boundary values stay qualifying markers; the next valid reading restores provenance.
+        assertTrue(BleEvidenceLog.uiRender(BleEvidenceLog.SURFACE_BATTERY, listOf(id), 100))
+        assertTrue(BleEvidenceLog.uiRender(BleEvidenceLog.SURFACE_WIFI_SCAN, emptyList(), 500))
+        val restored = records(BleEvidenceLog.snapshot(0, null)).last { it.getString("surface") == BleEvidenceLog.SURFACE_BATTERY }
+        assertEquals(100, restored.getInt("value"))
+        assertEquals(1, restored.getJSONArray("eventIds").length())
+
+        // An unknown surface has nothing to withdraw and is still refused without a record.
+        val before = BleEvidenceLog.snapshot(0, null).getLong("fenceSeq")
+        assertFalse(BleEvidenceLog.uiRender("debug_panel", listOf(id), 1))
+        assertEquals(before, BleEvidenceLog.snapshot(0, null).getLong("fenceSeq"))
+    }
+
+    @Test
+    fun `dump answers only its command and reports an unavailable owner`() {
+        BleEvidenceLog.connectionAccepted("AA:BB:CC:DD:EE:01")
+        val main = Handler(Looper.getMainLooper())
+
+        assertNull(BleEvidenceLog.dump(arrayOf("--other"), main))
+        assertNull(BleEvidenceLog.dump(null, main))
+
+        val line = BleEvidenceLog.dump(arrayOf(BleEvidenceLog.DUMP_COMMAND, "afterSeq=0"), main)!!
+        assertTrue(line.startsWith(BleEvidenceLog.OUTPUT_PREFIX))
+        val json = JSONObject(line.removePrefix(BleEvidenceLog.OUTPUT_PREFIX))
+        assertEquals("ok", json.getString("outcome"))
+        assertEquals("AA:BB:CC:DD:EE:01", json.getJSONObject("current").getString("peerMac"))
+
+        val unknownArg = BleEvidenceLog.dump(arrayOf(BleEvidenceLog.DUMP_COMMAND, "afterSeq=0", "eval=1"), main)!!
+        assertEquals("invalid_request", JSONObject(unknownArg.removePrefix(BleEvidenceLog.OUTPUT_PREFIX)).getString("outcome"))
+
+        val dead = HandlerThread("dead-owner").apply { start() }
+        val deadHandler = Handler(dead.looper)
+        dead.quitSafely()
+        dead.join()
+        val unavailable = BleEvidenceLog.dump(arrayOf(BleEvidenceLog.DUMP_COMMAND, "afterSeq=0"), deadHandler, 50)!!
+        assertEquals("unavailable", JSONObject(unavailable.removePrefix(BleEvidenceLog.OUTPUT_PREFIX)).getString("outcome"))
+    }
+}

package/android/src/test/java/com/mentra/bluetoothsdk/debug/BleTraceLoggerTest.kt

@@ -0,0 +1,69 @@
+package com.mentra.bluetoothsdk.debug
+
+import java.util.UUID
+import org.json.JSONArray
+import org.json.JSONObject
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.annotation.Config
+import org.robolectric.shadows.ShadowLog
+
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [28])
+class BleTraceLoggerTest {
+    @Test
+    fun wifiScanPreservesBooleanSecurityWhileRedactingCredentials() {
+        val secret = UUID.randomUUID().toString()
+        val networks = JSONArray()
+        for (secured in listOf(true, false)) {
+            networks.put(
+                JSONObject()
+                    .put("ssid", if (secured) "secured-fixture" else "open-fixture")
+                    .put("requiresPassword", secured)
+                    .put("signalStrength", -45)
+                    .put("password", secret)
+                    .put("token", secret)
+            )
+        }
+        ShadowLog.clear()
+        BleTraceLogger.logJson(
+            "glasses_to_phone",
+            "sdk_ble_event",
+            JSONObject().put("type", "wifi_scan_result").put("networks_neo", networks),
+        )
+        val message = ShadowLog.getLogsForTag("MentraBleTrace").single().msg
+        assertFalse(message.contains(secret))
+        val actual = JSONObject(message.substringAfter("payload=")).getJSONArray("networks_neo")
+        for ((index, secured) in listOf(true, false).withIndex()) {
+            val item = actual.getJSONObject(index)
+            assertEquals(secured, item.get("requiresPassword"))
+            assertEquals(-45, item.getInt("signalStrength"))
+            assertEquals("<redacted>", item.getString("password"))
+            assertEquals("<redacted>", item.getString("token"))
+        }
+    }
+
+    @Test
+    fun exceptionDoesNotExposeNonBooleanOrOtherPasswordFields() {
+        val secret = UUID.randomUUID().toString()
+        ShadowLog.clear()
+        BleTraceLogger.logJson(
+            "glasses_to_phone",
+            "sdk_ble_event",
+            JSONObject()
+                .put("type", "wifi_scan_result")
+                .put("requiresPassword", secret)
+                .put("password", true)
+                .put("RequiresPassword", false),
+        )
+        val message = ShadowLog.getLogsForTag("MentraBleTrace").single().msg
+        assertFalse(message.contains(secret))
+        val actual = JSONObject(message.substringAfter("payload="))
+        for (key in listOf("requiresPassword", "password", "RequiresPassword")) {
+            assertEquals("<redacted>", actual.getString(key))
+        }
+    }
+}