@glassly/bluetooth-sdk 0.1.0-dev.98 → 0.2.8-dev.444

package/android/src/test/java/com/glassly/bluetoothsdk/sgcs/G2KeyboardTest.kt

@@ -0,0 +1,271 @@
+package com.glassly.bluetoothsdk.sgcs
+
+import com.glassly.bluetoothsdk.GlassesStatus
+import com.glassly.bluetoothsdk.GlassesStatusUpdate
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.runBlocking
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertThrows
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+/**
+ * Pins the keyboard bridge wire format and HID decoding shared with g2flash's
+ * patches/keyboard_core.h and demos/keyboard.test.ts (same vectors).
+ */
+class G2KeyboardTest {
+    private val boot = bytes(
+        0x05, 1, 0x09, 6, 0xA1, 1, 0x05, 7, 0x19, 0xE0, 0x29, 0xE7, 0x15, 0, 0x25, 1, 0x75, 1, 0x95, 8, 0x81, 2,
+        0x75, 8, 0x95, 1, 0x81, 1, 0x95, 6, 0x75, 8, 0x15, 0, 0x25, 0x65, 0x05, 7, 0x19, 0, 0x29, 0x65, 0x81, 0, 0xC0,
+    )
+    private val numbered = boot.copyOfRange(0, 6) + bytes(0x85, 1) + boot.copyOfRange(6, boot.size - 1) + bytes(
+        0x85, 2, 0x05, 0x0C, 0x15, 0, 0x25, 1, 0x75, 1, 0x95, 3, 0x09, 0xE9, 0x09, 0xEA, 0x09, 0xE2, 0x81, 2,
+        0x75, 5, 0x95, 1, 0x81, 1, 0xC0,
+    )
+
+    private fun bytes(vararg values: Int) = ByteArray(values.size) { values[it].toByte() }
+    private fun le16(v: Int) = G2KeyboardProtocol.le16(v)
+    private fun le32(v: Long) = bytes((v and 0xFF).toInt(), ((v shr 8) and 0xFF).toInt(), ((v shr 16) and 0xFF).toInt(), ((v shr 24) and 0xFF).toInt())
+
+    private fun frame(
+        kind: Int, seq: Long, epoch: Int, request: Int, code: Int, handle: Int, data: ByteArray,
+        offset: Int = 0, total: Int = data.size,
+    ): ByteArray =
+        bytes(75, 66, 1, kind) + le32(seq) + le16(epoch) + le16(request) + le16(code) + le16(handle) +
+            le16(total) + le16(offset) + le32(1234) + data
+
+    private fun usages(keys: List<G2KeyboardHid.Usage>) = keys.map { listOf(it.page, it.usage) }
+    private fun events(keys: List<G2KeyboardHid.KeyEvent>) = keys.map { listOf(it.page, it.usage, if (it.down) 1 else 0) }
+
+    @Test
+    fun bootArrayModifiersReleaseRepeatsAndRollover() {
+        val r = G2KeyboardHid.parseReportMap(boot).getValue(0)
+        val keys = G2KeyboardHid.HeldKeys()
+        assertEquals(listOf(listOf(7, 0xE1, 1), listOf(7, 4, 1)), events(keys.update(12, r, bytes(2, 0, 4, 0, 0, 0, 0, 0))))
+        assertEquals(emptyList<List<Int>>(), events(keys.update(12, r, bytes(2, 0, 4, 0, 0, 0, 0, 0))))
+        val rollover = assertThrows(IllegalArgumentException::class.java) { keys.update(12, r, bytes(0, 0, 1, 1, 1, 1, 1, 1)) }
+        assertTrue(rollover.message!!.contains("rollover"))
+        assertEquals(listOf(false, false), keys.reset().map { it.down })
+        val length = assertThrows(IllegalArgumentException::class.java) { G2KeyboardHid.reportKeys(r, bytes(0)) }
+        assertTrue(length.message!!.contains("length"))
+    }
+
+    @Test
+    fun hogpReportIdsAreOutOfBandWithConsumerKeys() {
+        val maps = G2KeyboardHid.parseReportMap(numbered)
+        assertEquals(listOf(listOf(7, 5)), usages(G2KeyboardHid.reportKeys(maps.getValue(1), bytes(0, 0, 5, 0, 0, 0, 0, 0))))
+        assertEquals(listOf(listOf(12, 0xE9), listOf(12, 0xE2)), usages(G2KeyboardHid.reportKeys(maps.getValue(2), bytes(5))))
+        assertThrows(IllegalArgumentException::class.java) { G2KeyboardHid.reportKeys(maps.getValue(2), bytes(2, 5)) }
+    }
+
+    @Test
+    fun nkroBitmapWithUnalignedFieldsAndReportUnion() {
+        val r = G2KeyboardHid.parseReportMap(bytes(5, 7, 0x19, 4, 0x29, 19, 0x15, 0, 0x25, 1, 0x75, 1, 0x95, 16, 0x81, 2)).getValue(0)
+        assertEquals(listOf(listOf(7, 4), listOf(7, 11), listOf(7, 19)), usages(G2KeyboardHid.reportKeys(r, bytes(0x81, 0x80))))
+        val keys = G2KeyboardHid.HeldKeys()
+        assertEquals(1, keys.update(10, r, bytes(1, 0)).size)
+        assertEquals(emptyList<G2KeyboardHid.KeyEvent>(), keys.update(11, r, bytes(1, 0)))
+        assertEquals(emptyList<G2KeyboardHid.KeyEvent>(), keys.update(10, r, bytes(0, 0)))
+        assertEquals(listOf(listOf(7, 4, 0)), events(keys.update(11, r, bytes(0, 0))))
+    }
+
+    @Test
+    fun arrayValuesIndexUsagesRelativeToLogicalMinimum() {
+        val r = G2KeyboardHid.parseReportMap(bytes(5, 7, 0x19, 4, 0x29, 6, 0x15, 1, 0x25, 3, 0x75, 8, 0x95, 1, 0x81, 0)).getValue(0)
+        assertEquals(listOf(listOf(7, 5)), usages(G2KeyboardHid.reportKeys(r, bytes(2))))
+        assertEquals(emptyList<G2KeyboardHid.Usage>(), G2KeyboardHid.reportKeys(r, bytes(0)))
+    }
+
+    @Test
+    fun descriptorBoundsAndMalformedItems() {
+        val malformed = listOf(
+            bytes(), ByteArray(513), bytes(0xFE), bytes(0x75), bytes(0xB4), bytes(0xC0), bytes(0x85, 0),
+            bytes(0x75, 33, 0x95, 1, 0x81, 2), bytes(0x75, 32, 0x96, 0, 2, 0x81, 2), bytes(0xA1, 1),
+        )
+        for (data in malformed) assertThrows(IllegalArgumentException::class.java) { G2KeyboardHid.parseReportMap(data) }
+        // Deterministic malformed corpus; parsing must be bounded and never hang.
+        var seed = 1L
+        for (i in 0 until 1000) {
+            val data = ByteArray(i % 128 + 1) {
+                seed = (seed * 1664525L + 1013904223L) and 0xFFFF_FFFFL
+                (seed shr 24).toByte()
+            }
+            runCatching { G2KeyboardHid.parseReportMap(data) }
+        }
+    }
+
+    @Test
+    fun wireControlHasTheDedicatedFieldAndEpoch() {
+        val packet = G2KeyboardProtocol.controlPacket(G2KeyboardProtocol.Op.CONNECT, 0x1234, 0x5678, bytes(1, 2, 3, 4, 5, 6, 7), magic = 5)
+        assertEquals(
+            listOf(8, 2, 16, 5, 0x22, 2, 8, 1, 0x92, 8, 15, 75, 66, 1, 4, 0x34, 0x12, 0x78, 0x56, 1, 2, 3, 4, 5, 6, 7),
+            packet.map { it.toInt() and 0xFF },
+        )
+        // Magic ids above 127 take two varint bytes.
+        val query = G2KeyboardProtocol.controlPacket(G2KeyboardProtocol.Op.QUERY, 1, 0, magic = 200)
+        assertEquals(listOf(8, 2, 16, 0xC8, 0x01), query.take(5).map { it.toInt() and 0xFF })
+    }
+
+    @Test
+    fun fragmentsDuplicatesGapsEpochsAndSequenceWrap() {
+        val stream = G2KeyboardProtocol.RecordAssembler()
+        val data = ByteArray(200) { it.toByte() }
+        assertNull(stream.push(frame(3, 0xFFFF_FFFFL, 1, 0, 13, 33, data.copyOfRange(0, 96), 0, 200)))
+        assertNull(stream.push(frame(3, 0xFFFF_FFFFL, 1, 0, 13, 33, data.copyOfRange(96, 192), 96, 200)))
+        assertTrue(data.contentEquals(stream.push(frame(3, 0xFFFF_FFFFL, 1, 0, 13, 33, data.copyOfRange(192, 200), 192, 200))!!.data))
+        val status = frame(1, 0, 1, 0, 0, 0, ByteArray(10))
+        assertEquals(0L, stream.push(status)!!.sequence)
+        assertNull(stream.push(status))
+        assertEquals(1, stream.gaps)
+        stream.push(frame(1, 2, 1, 0, 0, 0, ByteArray(10)))
+        assertEquals(2, stream.gaps)
+        assertNull(stream.push(status))
+        assertEquals(2, stream.gaps)
+        stream.push(frame(1, 3, 2, 0, 0, 0, ByteArray(10)))
+        assertEquals(3, stream.gaps)
+    }
+
+    @Test
+    fun mismatchedFragmentsNeverEmitPartialInput() {
+        val stream = G2KeyboardProtocol.RecordAssembler()
+        stream.push(frame(3, 1, 1, 0, 13, 10, ByteArray(96), 0, 100))
+        assertNull(stream.push(frame(3, 1, 1, 0, 13, 11, ByteArray(4), 96, 100)))
+        assertEquals(2, stream.gaps)
+        assertNull(stream.push(frame(3, 1, 1, 0, 13, 10, ByteArray(4), 96, 100)))
+        assertNull(stream.push(ByteArray(513)))
+    }
+
+    @Test
+    fun advertParsingNamesHidDevicesAndReversesAddresses() {
+        val body = bytes(1, 0xFF, 0xEE, 0xDD, 0xCC, 0xBB, 0xAA, 0xC4, 0, 12, 3, 3, 0x12, 0x18, 5, 9, 0x4B, 0x65, 0x79, 0x73)
+        val advert = G2KeyboardProtocol.Advert.parse(body)!!
+        assertEquals("aa:bb:cc:dd:ee:ff", advert.addressText)
+        assertEquals(-60, advert.rssi)
+        assertTrue(advert.hid)
+        assertEquals("Keys", advert.name)
+        assertEquals(advert.address, G2KeyboardProtocol.addressFromText(advert.addressText)!!.map { it.toInt() and 0xFF })
+        assertNull(G2KeyboardProtocol.addressFromText("aa:bb"))
+    }
+
+    @Test
+    fun advertAppearanceMarksHidAndScanResponseMerges() {
+        // ADV_IND with only a keyboard appearance (0x03C1), no 0x1812 service list.
+        val first = G2KeyboardProtocol.Advert.parse(bytes(1, 0xFF, 0xEE, 0xDD, 0xCC, 0xBB, 0xAA, 0xC4, 0, 4, 3, 0x19, 0xC1, 0x03))!!
+        assertTrue(first.hid)
+        assertEquals("", first.name)
+        // SCAN_RSP for the same address carries the name and a better RSSI.
+        val second = G2KeyboardProtocol.Advert.parse(bytes(1, 0xFF, 0xEE, 0xDD, 0xCC, 0xBB, 0xAA, 0xCE, 4, 6, 5, 9, 0x4B, 0x65, 0x79, 0x73))!!
+        assertFalse(second.hid)
+        val merged = first.merging(second)
+        assertEquals("Keys", merged.name)
+        assertTrue(merged.hid)
+        assertEquals(-50, merged.rssi)
+        assertEquals(first.address, merged.address)
+        // A non-HID appearance (generic phone) does not qualify.
+        assertFalse(G2KeyboardProtocol.Advert.parse(bytes(1, 0xFF, 0xEE, 0xDD, 0xCC, 0xBB, 0xAA, 0xC4, 0, 4, 3, 0x19, 0x40, 0x00))!!.hid)
+    }
+
+    @Test
+    fun keyboardStatusSurvivesSnapshotAndPartialStatusBridge() {
+        val values = mapOf<String, Any>(
+            "keyboardBridge" to true, "keyboardConnected" to true, "keyboardName" to "Bluetooth Keyboard",
+            "keyboardSaved" to true, "keyboardState" to "connected", "keyboardError" to "",
+        )
+        val snapshot = GlassesStatus.fromMap(values).toMap()
+        for ((key, value) in values) assertEquals(value, snapshot[key])
+        assertEquals(values, GlassesStatusUpdate.fromMap(values).toMap())
+        assertEquals("idle", GlassesStatus.fromMap(emptyMap()).keyboardState)
+    }
+
+    @Test
+    fun fullSimulatedHogpDiscoveryTypingAndLossRecovery() = runBlocking {
+        class Attr(val uuid: Int, val value: ByteArray)
+        val attrs = LinkedHashMap<Int, Attr>()
+        fun add(h: Int, uuid: Int, value: ByteArray) { attrs[h] = Attr(uuid, value) }
+        val mockMap = numbered.copyOfRange(0, numbered.size - 1) + bytes(0x85, 3, 0x05, 6, 0x09, 0x20, 0x15, 0, 0x25, 100, 0x75, 8, 0x95, 1, 0x81, 2, 0xC0)
+        add(1, 0x2800, bytes(1, 0x18)); add(2, 0x2803, bytes(0x20, 3, 0, 5, 0x2A)); add(3, 0x2A05, bytes()); add(4, 0x2902, bytes(0, 0))
+        add(20, 0x2800, bytes(0x12, 0x18))
+        add(21, 0x2803, bytes(2, 22, 0, 0x4B, 0x2A)); add(22, 0x2A4B, mockMap); add(23, 0x2907, bytes(0x19, 0x2A))
+        add(24, 0x2803, bytes(6, 25, 0, 0x4E, 0x2A)); add(25, 0x2A4E, bytes(1))
+        add(26, 0x2803, bytes(0x12, 27, 0, 0x4D, 0x2A)); add(27, 0x2A4D, bytes()); add(28, 0x2902, bytes(0, 0)); add(29, 0x2908, bytes(1, 1))
+        add(30, 0x2803, bytes(0x12, 31, 0, 0x4D, 0x2A)); add(31, 0x2A4D, bytes()); add(32, 0x2902, bytes(0, 0)); add(33, 0x2908, bytes(2, 1))
+        add(40, 0x2800, bytes(0x0F, 0x18)); add(41, 0x2803, bytes(0x12, 42, 0, 0x19, 0x2A)); add(42, 0x2A19, bytes(100)); add(43, 0x2902, bytes(0, 0)); add(44, 0x2908, bytes(3, 1))
+
+        var seq = 0L
+        var epoch = 0
+        val writes = ArrayList<Int>()
+        var watches = emptyList<Int>()
+        val typed = ArrayList<List<Int>>()
+        lateinit var client: G2KeyboardClient
+        fun emit(kind: Int, request: Int, code: Int, handle: Int, data: ByteArray) {
+            seq += 1
+            client.accept(frame(kind, seq, epoch, request, code, handle, data))
+        }
+        val scope = CoroutineScope(coroutineContext)
+        client = G2KeyboardClient(scope, { pb, _ ->
+            // Field 130 (tag 0x92 0x08) follows a magic varint of one or two bytes.
+            val tag = (0 until pb.size - 1).first { pb[it] == 0x92.toByte() && pb[it + 1] == 0x08.toByte() }
+            val body = pb.copyOfRange(tag + 3, pb.size)
+            val op = body[3].toInt()
+            val req = G2KeyboardProtocol.u16(body, 4)
+            val h = if (body.size >= 10) G2KeyboardProtocol.u16(body, 8) else 0
+            when (op) {
+                1 -> emit(1, req, 0, 0, bytes(1, 0, 0, 0, 0, 0, 0, 0, 0, 0))
+                4 -> { epoch += 1; emit(1, req, 0, 0, bytes(1, 3, 1, 1, 0, 0, 0, 0, 0, 0)) }
+                9 -> {
+                    val batch = attrs.keys.sorted().filter { it >= h }.take(4)
+                    val payload = if (batch.isEmpty()) bytes() else bytes(1) + batch.fold(ByteArray(0)) { acc, handle -> acc + le16(handle) + le16(attrs.getValue(handle).uuid) }
+                    emit(2, req, if (batch.isEmpty()) (10 shl 8) or 2 else 2, h, payload)
+                }
+                10 -> {
+                    val data = attrs.getValue(h).value
+                    val offset = G2KeyboardProtocol.u16(body, 10)
+                    val status = if (offset >= data.size) (7 shl 8) or 6 else if (offset > 0) 6 else 5
+                    emit(2, req, status, h, data.copyOfRange(minOf(offset, data.size), minOf(offset + 20, data.size)))
+                }
+                11 -> { writes.add(h); emit(2, req, if (body[10].toInt() != 0) 10 else 9, h, bytes()) }
+                12 -> {
+                    val count = body[8].toInt()
+                    watches = (0 until count).map { G2KeyboardProtocol.u16(body, 9 + 2 * it) }
+                    emit(1, req, 0, 0, bytes(1, 3, 1, 1, 0, 0, 0, 0, 0, 0))
+                }
+                else -> throw AssertionError("Unexpected op $op")
+            }
+        }) { event ->
+            if (event is G2KeyboardClient.Event.Keys) typed.addAll(event.events.map { listOf(it.usage, if (it.down) 1 else 0) })
+        }
+
+        client.enable()
+        client.connect(1, ByteArray(6))
+        val config = client.configure()
+        assertEquals(listOf(27, 31, 42, 3), watches)
+        assertEquals(listOf(25, 4, 28, 32, 43), writes)
+        assertEquals(listOf(1, 2, 3), config.reports.map { it.id })
+
+        emit(3, 0, 13, 27, bytes(0, 0, 4, 0, 0, 0, 0, 0))
+        emit(3, 0, 13, 31, bytes(1))
+        assertEquals(listOf(listOf(4, 1), listOf(0xE9, 1)), typed)
+        seq += 1 // release lost in the firmware queue or phone notification path
+        emit(1, 0, 0, 0, bytes(1, 3, 1, 1, 0, 0, 0, 0, 0, 0))
+        assertEquals(listOf(0, 0), typed.takeLast(2).map { it[1] })
+
+        val restored = G2KeyboardClient(scope, { _, _ -> }) { event ->
+            if (event is G2KeyboardClient.Event.Keys) typed.addAll(event.events.map { listOf(it.usage, if (it.down) 1 else 0) })
+        }
+        restored.restore(config)
+        seq += 1
+        restored.accept(frame(3, seq, epoch, 0, 13, 27, bytes(0, 0, 5, 0, 0, 0, 0, 0)))
+        assertEquals(listOf(5, 1), typed.last())
+        restored.lostPhoneLink()
+        assertEquals(listOf(5, 0), typed.last())
+
+        emit(3, 0, 14, 3, bytes(1, 0, 255, 255)) // Service Changed invalidates the mapping
+        val count = typed.size
+        emit(3, 0, 13, 27, bytes(0, 0, 6, 0, 0, 0, 0, 0))
+        assertEquals(count, typed.size)
+        client.close()
+        restored.close()
+    }
+}

package/android/src/test/java/com/glassly/bluetoothsdk/sgcs/G2NotificationFileTest.kt

@@ -0,0 +1,204 @@
+package com.glassly.bluetoothsdk.sgcs
+
+import com.glassly.bluetoothsdk.AllowedApp
+import com.glassly.bluetoothsdk.PhoneNotificationUpload
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNotEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class G2NotificationFileTest {
+    private fun readLittleEndian(bytes: ByteArray, offset: Int): Long {
+        var value = 0L
+        for (i in 0 until 4) {
+            value = value or ((bytes[offset + i].toLong() and 0xFF) shl (8 * i))
+        }
+        return value
+    }
+
+    @Test
+    fun `header is 93 bytes with a command byte then file type and size`() {
+        val content = "hello glasses".toByteArray(Charsets.UTF_8)
+        val header =
+            G2NotificationFile.fileCheckHeader(
+                G2NotificationFile.FILENAME,
+                content,
+                G2NotificationFile.FILE_TYPE_NOTIFICATION
+            )
+
+        assertEquals(93, header.size)
+        assertEquals(0, header[0].toInt()) // SEND_START
+        assertEquals(1L, readLittleEndian(header, 1)) // ANDROID_MSG_JSON_NOTIFICATION
+        assertEquals(content.size.toLong(), readLittleEndian(header, 5))
+        // The docs' shifted view of the same bytes.
+        assertEquals(0x100L, readLittleEndian(header, 0))
+        assertEquals((content.size * 256).toLong(), readLittleEndian(header, 4))
+    }
+
+    @Test
+    fun `whitelist header carries file type zero`() {
+        val header =
+            G2NotificationFile.fileCheckHeader(
+                G2NotificationFile.FILENAME,
+                "{}".toByteArray(Charsets.UTF_8),
+                G2NotificationFile.FILE_TYPE_WHITELIST
+            )
+        assertEquals(0L, readLittleEndian(header, 1))
+    }
+
+    @Test
+    fun `header checksum and extra reconstruct the crc`() {
+        val content = "the quick brown fox".toByteArray(Charsets.UTF_8)
+        val header =
+            G2NotificationFile.fileCheckHeader(
+                G2NotificationFile.FILENAME,
+                content,
+                G2NotificationFile.FILE_TYPE_NOTIFICATION
+            )
+
+        val checksum = readLittleEndian(header, 8).toInt()
+        val extra = header[12].toInt() and 0xFF
+        val reconstructed = (extra shl 24) or (checksum ushr 8)
+
+        assertEquals(G2NotificationFile.crc32c(content), reconstructed)
+    }
+
+    @Test
+    fun `header carries a nul-padded filename`() {
+        val header =
+            G2NotificationFile.fileCheckHeader(
+                G2NotificationFile.FILENAME,
+                ByteArray(0),
+                G2NotificationFile.FILE_TYPE_WHITELIST
+            )
+        val nameBytes = G2NotificationFile.FILENAME.toByteArray(Charsets.UTF_8)
+
+        assertEquals(
+            G2NotificationFile.FILENAME,
+            String(header, 13, nameBytes.size, Charsets.UTF_8)
+        )
+        for (i in (13 + nameBytes.size) until 93) {
+            assertEquals(0, header[i].toInt())
+        }
+    }
+
+    @Test
+    fun `crc is deterministic and content sensitive`() {
+        val a = "alpha".toByteArray(Charsets.UTF_8)
+        val b = "alphb".toByteArray(Charsets.UTF_8)
+
+        assertEquals(G2NotificationFile.crc32c(a), G2NotificationFile.crc32c(a))
+        assertNotEquals(G2NotificationFile.crc32c(a), G2NotificationFile.crc32c(b))
+        assertEquals(0, G2NotificationFile.crc32c(ByteArray(0)))
+    }
+
+    @Test
+    fun `whitelist drops over-long ids and truncates names`() {
+        val longId = "c".repeat(G2NotificationFile.MAX_IDENTIFIER_BYTES + 1)
+        val json =
+            String(
+                G2NotificationFile.whitelistJson(
+                    filterEnabled = true,
+                    apps =
+                        listOf(
+                            AllowedApp("com.example.mail", "A Very Long Application Name"),
+                            AllowedApp(longId, "Dropped")
+                        )
+                ),
+                Charsets.UTF_8
+            )
+
+        assertTrue(json.contains("\"enable\":true"))
+        assertTrue(json.contains("\"id\":\"com.example.mail\""))
+        assertFalse(json.contains(longId))
+        assertTrue(json.contains("\"name\":\"A Very Long App\""))
+    }
+
+    @Test
+    fun `whitelist caps the list and is deterministic`() {
+        val apps = (0 until G2NotificationFile.MAX_APPS + 10).map { AllowedApp("app.$it", "App $it") }
+        val first = G2NotificationFile.whitelistJson(false, apps)
+        val second = G2NotificationFile.whitelistJson(false, apps)
+
+        assertTrue(first.contentEquals(second))
+        assertEquals(
+            G2NotificationFile.MAX_APPS,
+            String(first, Charsets.UTF_8).split("\"id\":").size - 1
+        )
+    }
+
+    @Test
+    fun `notification json carries every field under the android root`() {
+        val upload =
+            PhoneNotificationUpload(
+                notificationId = "n-1",
+                packageName = "com.example.chat",
+                appName = "Chat",
+                title = "  Ada  ",
+                subtitle = "Re: build",
+                body = "the lenses are fine",
+                timestampMs = 1_700_000_000_000L
+            )
+
+        val json = String(G2NotificationFile.notificationJson(upload, 4242, 0L), Charsets.UTF_8)
+
+        assertTrue(json.startsWith("{\"android_notification\":{"))
+        assertTrue(json.contains("\"action\":0"))
+        assertTrue(json.contains("\"app_identifier\":\"com.example.chat\""))
+        assertTrue(json.contains("\"display_name\":\"Chat\""))
+        assertTrue(json.contains("\"msg_id\":4242"))
+        assertTrue(json.contains("\"time_s\":1700000000"))
+        assertTrue(json.contains("\"title\":\"Ada\""))
+        assertTrue(json.contains("\"subtitle\":\"Re: build\""))
+        assertTrue(json.contains("\"message\":\"the lenses are fine\""))
+        assertTrue(Regex("\"date\":\"\\d{8}T\\d{6}\"").containsMatchIn(json))
+    }
+
+    @Test
+    fun `notification json caps title and message lengths`() {
+        val upload =
+            PhoneNotificationUpload(
+                notificationId = "n-2",
+                packageName = "com.example.chat",
+                appName = "Chat",
+                title = "t".repeat(400),
+                subtitle = "",
+                body = "b".repeat(2000),
+                timestampMs = 1_700_000_000_000L
+            )
+
+        val json = String(G2NotificationFile.notificationJson(upload, 1, 0L), Charsets.UTF_8)
+
+        assertTrue(json.contains("\"title\":\"" + "t".repeat(G2NotificationFile.MAX_TITLE_BYTES) + "\""))
+        assertTrue(json.contains("\"message\":\"" + "b".repeat(G2NotificationFile.MAX_MESSAGE_BYTES) + "\""))
+    }
+
+    @Test
+    fun `truncation never splits a code point`() {
+        // Each emoji is 4 UTF-8 bytes, so a 6-byte budget keeps exactly one.
+        val truncated = G2NotificationFile.truncateUtf8("😀😀", 6)
+
+        assertEquals("😀", truncated)
+        assertEquals(4, truncated.toByteArray(Charsets.UTF_8).size)
+    }
+
+    @Test
+    fun `json strings escape quotes and control characters`() {
+        val upload =
+            PhoneNotificationUpload(
+                notificationId = "n-3",
+                packageName = "com.example.chat",
+                appName = "Chat",
+                title = "say \"hi\"",
+                subtitle = "",
+                body = "line\none",
+                timestampMs = 1_700_000_000_000L
+            )
+
+        val json = String(G2NotificationFile.notificationJson(upload, 1, 0L), Charsets.UTF_8)
+
+        assertTrue(json.contains("\\\"hi\\\""))
+        assertTrue(json.contains("line\\none"))
+    }
+}

package/android/src/test/java/com/glassly/bluetoothsdk/sgcs/G2RingBatteryTest.kt

@@ -0,0 +1,56 @@
+package com.glassly.bluetoothsdk.sgcs
+
+import com.glassly.bluetoothsdk.GlassesStatus
+import com.glassly.bluetoothsdk.GlassesStatusUpdate
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Test
+
+class G2RingBatteryTest {
+    private fun decode(vararg bytes: Int) = G2RingBattery.decode(bytes.map { it.toByte() }.toByteArray())
+
+    @Test
+    fun connectedBatteryIncludingEmptyFullAndCharging() {
+        for (level in listOf(0, 62, 100)) {
+            assertEquals(G2RingBattery(true, level, false), decode(0x52, 0x42, 1, 3, level))
+            assertEquals(G2RingBattery(true, level, true), decode(0x52, 0x42, 1, 7, level))
+        }
+    }
+
+    @Test
+    fun disconnectedAndUnknownReportsClearCachedBattery() {
+        assertEquals(G2RingBattery.DISCONNECTED, decode(0x52, 0x42, 1, 0, 255))
+        assertEquals(G2RingBattery.DISCONNECTED, decode(0x52, 0x42, 1, 6, 62))
+        assertEquals(G2RingBattery(true, -1, false), decode(0x52, 0x42, 1, 1, 255))
+        assertEquals(G2RingBattery(true, -1, false), decode(0x52, 0x42, 1, 5, 62))
+    }
+
+    @Test
+    fun batterySurvivesSnapshotAndPartialStatusBridge() {
+        val battery = decode(0x52, 0x42, 1, 7, 62)!!
+        val values = mapOf<String, Any>(
+            "ringConnected" to battery.connected,
+            "ringBatteryLevel" to battery.level,
+            "ringCharging" to battery.charging,
+        )
+        val snapshot = GlassesStatus.fromMap(values).toMap()
+        for ((key, value) in values) assertEquals(value, snapshot[key])
+        assertEquals(false, snapshot["controllerConnected"])
+        assertEquals(-1, snapshot["controllerBatteryLevel"])
+        assertEquals(values, GlassesStatusUpdate.fromMap(values).toMap())
+        assertEquals(emptyMap<String, Any>(), GlassesStatusUpdate.fromMap(emptyMap()).toMap())
+        assertEquals(-1, GlassesStatus.fromMap(emptyMap()).ringBatteryLevel)
+        val cleared = mapOf<String, Any>("ringConnected" to false, "ringBatteryLevel" to -1, "ringCharging" to false)
+        assertEquals(cleared, GlassesStatusUpdate.fromMap(cleared).toMap())
+    }
+
+    @Test
+    fun malformedReportsAreIgnored() {
+        val malformed = listOf(
+            intArrayOf(), intArrayOf(0x52, 0x42, 1, 3), intArrayOf(0x52, 0x42, 1, 3, 62, 0),
+            intArrayOf(0x41, 0x42, 1, 3, 62), intArrayOf(0x52, 0x41, 1, 3, 62),
+            intArrayOf(0x52, 0x42, 2, 3, 62), intArrayOf(0x52, 0x42, 1, 3, 101), intArrayOf(0x52, 0x42, 1, 3, 255),
+        )
+        for (bytes in malformed) assertNull(decode(*bytes))
+    }
+}

package/android/src/test/java/com/glassly/bluetoothsdk/sgcs/G2SensorsTest.kt

@@ -0,0 +1,56 @@
+package com.glassly.bluetoothsdk.sgcs
+
+import org.junit.Assert.*
+import org.junit.Test
+
+class G2SensorsTest {
+    @Test fun northMayOmitTheProtobufScalarButMalformedHeadingsAreRejected() {
+        assertEquals(0, G2Sensors.heading(emptyMap()))
+        assertEquals(0, G2Sensors.heading(mapOf(1 to 0)))
+        assertEquals(359, G2Sensors.heading(mapOf(1 to 359)))
+        assertNull(G2Sensors.heading(mapOf(1 to 360)))
+        assertNull(G2Sensors.heading(mapOf(1 to byteArrayOf(0))))
+    }
+
+    @Test fun commandsMatchUpstreamModesAndLittleEndianOptions() {
+        assertArrayEquals(byteArrayOf(16, 0), G2Sensors.command("light", "query", emptyMap()))
+        assertArrayEquals(byteArrayOf(16, 1, 1, 244.toByte(), 1, 1, 0, 136.toByte(), 19), G2Sensors.command("light", "start", emptyMap()))
+        assertArrayEquals(byteArrayOf(10, 2, 250.toByte(), 0, 0, 0), G2Sensors.command("compass", "start", mapOf("intervalMs" to 250.0, "minChangeDegrees" to 0.0)))
+        assertArrayEquals(byteArrayOf(16, 2), G2Sensors.command("light", "stop", emptyMap()))
+        assertArrayEquals(byteArrayOf(10, 0), G2Sensors.command("compass", "stop", emptyMap()))
+        assertNull(G2Sensors.command("light", "start", mapOf("intervalMs" to 99.0)))
+        assertNull(G2Sensors.command("compass", "start", mapOf("intervalMs" to Double.NaN)))
+        assertNull(G2Sensors.command("compass", "start", mapOf("minChangeDegrees" to 0.5)))
+    }
+    @Test fun lightReportPreservesRawValuesAndFreshness() {
+        val bytes = listOf(65,76,1,2,15,3,210,4,0,0,46,22,0,0,250,0,9,3,0,4,66,0,0,240).map { it.toByte() }.toByteArray()
+        val report = G2Sensors.light(bytes)!!
+        assertEquals("poll", report["reason"])
+        assertEquals(1234L, report["value"])
+        assertEquals(5678L, report["peak"])
+        assertEquals(4026531906L, report["sampleTimestampMs"])
+        assertEquals(true, report["readSucceeded"])
+        assertEquals(true, report["autoBrightness"])
+        assertEquals(true, report["passive"])
+        assertNull(G2Sensors.light(bytes.copyOf(23)))
+        bytes[4] = 0
+        assertEquals(false, G2Sensors.light(bytes)!!["readSucceeded"])
+        bytes[2] = 2
+        assertNull(G2Sensors.light(bytes))
+    }
+    @Test fun compassDiagnosticsAndUnknownMarkers() {
+        val bytes = listOf(67,77,1,3,1,2,143,0,66,0,0,240).map { it.toByte() }.toByteArray()
+        val report = G2Sensors.compass(bytes)!!
+        assertEquals("gmrv", report["source"])
+        assertEquals(3, report["accuracy"])
+        assertEquals(true, report["sampleMatched"])
+        assertEquals(true, report["magneticDataFresh"])
+        assertEquals(4026531906L, report["sampleTimestampMs"])
+        bytes[3] = 255.toByte(); bytes[4] = 255.toByte(); bytes[5] = 0; bytes[6] = 0
+        assertNull(G2Sensors.compass(bytes)!!["accuracy"])
+        assertEquals(false, G2Sensors.compass(bytes)!!["sampleMatched"])
+        bytes[3] = 4
+        assertNull(G2Sensors.compass(bytes))
+        assertNull(G2Sensors.compass(bytes.copyOf(11)))
+    }
+}

package/android/src/test/java/com/glassly/bluetoothsdk/sgcs/G2TouchInputTest.kt

@@ -0,0 +1,60 @@
+package com.glassly.bluetoothsdk.sgcs
+
+import org.junit.Assert.*
+import org.junit.Test
+
+class G2TouchInputTest {
+    private fun fields(event: Int, wire: Int, tick: Long = 123): Map<Int, Any> = mapOf(
+        1 to event, 2 to 2, 100 to byteArrayOf(0x52, 0x49, 1, 1, wire.toByte(), 0, 0, 0,
+            tick.toByte(), (tick shr 8).toByte(), (tick shr 16).toByte(), (tick shr 24).toByte()),
+    )
+
+    @Test fun rawRingCompletionsSurviveCloselySpacedInput() {
+        val debounce = G2TouchDebounce()
+        // The old global gate accepted the second touch_down but lost its click.
+        for ((event, wire) in listOf(1 to 4, 14 to 10, 0 to 1)) {
+            val ring = G2RingInput.parse(fields(event, wire))!!
+            assertTrue(debounce.accepts(event, ring, 1000))
+        }
+    }
+
+    @Test fun delayedProcessingUsesReceiptTimeForLegacyInput() {
+        val debounce = G2TouchDebounce()
+        // Processed together after a delay, but received a second apart.
+        assertTrue(debounce.accepts(0, null, 1000))
+        assertTrue(debounce.accepts(0, null, 2000))
+        assertFalse(debounce.accepts(0, null, 2010))
+    }
+
+    @Test fun edgesAndUnknownReportsDoNotConsumeLegacyDebounce() {
+        val debounce = G2TouchDebounce()
+        for (event in listOf(9, 10, 14, 127)) assertTrue(debounce.accepts(event, null, 1000))
+        assertTrue(debounce.accepts(0, null, 1000))
+        assertFalse(debounce.accepts(0, null, 1010))
+        assertTrue(debounce.accepts(10, null, 1020))
+    }
+
+    @Test fun ringInputDoesNotSuppressIndependentTempleInput() {
+        val debounce = G2TouchDebounce()
+        assertTrue(debounce.accepts(0, G2RingInput.parse(fields(0, 1))!!, 1000))
+        assertTrue(debounce.accepts(0, null, 1000))
+    }
+
+    @Test fun metadataValidatesSourceFormatAndEventMapping() {
+        val valid = fields(10, 8, 0xf1234567L)
+        val ring = G2RingInput.parse(valid)!!
+        assertEquals(8, ring.wireType)
+        assertEquals(0xf1234567L, ring.tick)
+        for (key in listOf(1, 2, 100)) assertNull(G2RingInput.parse(valid - key))
+        assertNull(G2RingInput.parse(valid + (2 to 0)))
+        for (index in listOf(0, 1, 2, 3, 4, 7)) {
+            val bytes = (valid[100] as ByteArray).copyOf().also { it[index] = 255.toByte() }
+            assertNull(G2RingInput.parse(valid + (100 to bytes)))
+        }
+        assertNull(G2RingInput.parse(valid + (100 to byteArrayOf(0x52, 0x49))))
+        assertNotNull(G2RingInput.parse(fields(127, 255)))
+        for ((wire, event) in mapOf(0 to 9, 1 to 0, 2 to 3, 4 to 1, 5 to 2, 8 to 10, 9 to 11, 10 to 14)) {
+            assertNotNull(G2RingInput.parse(fields(event, wire)))
+        }
+    }
+}