Faceclaw support for G1s

Relies on the glasses having the firmware from
https://github.com/jimrandomh/scouter_kit, based on Mafik's Scouter Kit.
This commit is contained in:
James Babcock committed 2026-11-06 00:12:23 -08:00
1 parent f803f4212c
commit 67aff19923
27 files changed
+1902 -45

No files matched your search

+40
View File
@@ -180,3 +180,43 @@ test("RayNeo iO advertisements classify as one device with its MAC", () => {
// G2 advertisements are untouched
assert.equal(classifyAdvertisement(raw({})).role, "left");
});
// ---------------------------------------------------------------------------
// Even G1
// ---------------------------------------------------------------------------
const g1Ascii = (text) => Array.from(text).map((c) => c.charCodeAt(0).toString(16).padStart(2, "0")).join("");
const g1Raw = (name, manufacturerData, address = "F4:27:E9:CA:E8:3F") => ({
address,
name,
manufacturerData,
rssi: -50,
txPower: null,
connectable: true,
bonded: false,
source: "scan",
seenAtMs: 1000,
});
test("a G1 arm on Even's firmware: side from the name, serial after the side byte", () => {
const ad = classifyAdvertisement(g1Raw("Even G1_70_L_EF50E5", "02" + g1Ascii("S110LABC030139") + "0000000000"));
assert.equal(ad.role, "left");
assert.equal(ad.g1Firmware, "stock");
assert.equal(ad.serial, "S110LABC030139");
assert.equal(ad.embeddedMac, null);
});
test("a G1 arm on g1v0: the name says all, the serial is in the 0xFFFF record", () => {
const ad = classifyAdvertisement(g1Raw("G1v0_R", "ffff" + "01" + "04" + g1Ascii("S110LABC030139")));
assert.equal(ad.role, "right");
assert.equal(ad.g1Firmware, "g1v0");
assert.equal(ad.serial, "S110LABC030139");
assert.equal(classifyAdvertisement(g1Raw("G1v0S_L", "")).g1Firmware, "g1v0-safe");
assert.equal(classifyAdvertisement(g1Raw("G1v0S_L", "")).serial, null);
});
test("names that only look like a G1 are not admitted", () => {
for (const name of ["G1v0_X", "G1v0", "G1 Tracker", "Even G1", "Pixel G1v0_L"]) {
assert.equal(classifyAdvertisement(g1Raw(name, "")), null, name);
}
});
@@ -0,0 +1,777 @@
package com.faceclaw.app
import kotlin.concurrent.Volatile
import kotlin.test.Test
import kotlin.test.assertEquals
import kotlin.test.assertFalse
import kotlin.test.assertNotNull
import kotlin.test.assertNull
import kotlin.test.assertTrue
private const val LEFT = "F4:27:E9:CA:E8:3F"
private const val RIGHT = "CD:EB:89:BF:E9:EC"
private const val W = 640
private const val H = 480
private const val STRIDE = W / 2
private fun awaitTrue(timeoutMs: Long, condition: () -> Boolean): Boolean {
val platform = testPlatform()
val deadline = platform.elapsedRealtimeMs() + timeoutMs
while (platform.elapsedRealtimeMs() < deadline) {
if (condition()) return true
sleepMs(10)
}
return condition()
}
private fun nibble(frame: ByteArray, x: Int, y: Int): Int {
val v = frame[y * STRIDE + x / 2].toInt() and 255
return if (x % 2 == 0) v ushr 4 else v and 15
}
private fun setNibble(frame: ByteArray, x: Int, y: Int, c: Int) {
val i = y * STRIDE + x / 2
val v = frame[i].toInt() and 255
frame[i] = (if (x % 2 == 0) (v and 0x0f) or (c shl 4) else (v and 0xf0) or c).toByte()
}
/** What fc.c does with a draw message: bbox and clear calls into [frame]; returns the calls' rectangles. */
private fun applyDraw(frame: ByteArray, m: ByteArray): List<IntArray> {
val rects = ArrayList<IntArray>()
fun u16(p: Int) = (m[p].toInt() and 255) or ((m[p + 1].toInt() and 255) shl 8)
val count = u16(1)
var p = 3
repeat(count) {
val len = u16(p)
p += 2
val end = p + len
assertEquals(0, m[p + 1].toInt(), "a G1 call carries no target, depth or clip")
assertEquals(DRAW_OP_BOUNDING_BOX, m[p].toInt(), "only pixels on a G1")
var q = p + 2
val x: Int
val y: Int
val w: Int
val h: Int
if (m[q].toInt() == 0) {
x = (m[q + 1].toInt() and 255) * 4
y = (m[q + 2].toInt() and 255) * 2
w = (m[q + 3].toInt() and 255) * 4
h = (m[q + 4].toInt() and 255) * 2
q += 5
} else {
x = u16(q + 1)
y = u16(q + 3)
w = u16(q + 5)
h = u16(q + 7)
q += 9
}
assertTrue(x + w <= W && y + h <= H, "rect $x,$y ${w}x$h")
var left = w * h
var cx = x
var cy = y
while (q < end) {
val token = m[q++].toInt() and 255
val color = token and 15
var run = token ushr 4
if (run == 0) {
run = m[q++].toInt() and 255
if (run == 0) {
run = u16(q)
q += 2
}
}
left -= run
assertTrue(left >= 0, "RLE overruns its rectangle")
repeat(run) {
setNibble(frame, cx, cy, color)
cx++
if (cx == x + w) {
cx = x
cy++
}
}
}
assertEquals(0, left, "RLE must cover the rectangle exactly")
rects.add(intArrayOf(x, y, w, h))
p = end
}
assertEquals(m.size, p)
return rects
}
/** One arm on g1v0, as the phone sees it over GATT. */
private class FakeG1Arm(val left: Boolean) {
val frame = ByteArray(STRIDE * H)
/** What a look through the lens shows: the frame as of the last PRESENT while visible. */
val panel = ByteArray(STRIDE * H)
var visible = true
var panelOn = false
val records = ArrayList<ByteArray>()
var current = ByteArray(0)
val messageTypes = ArrayList<Int>()
val rects = ArrayList<IntArray>()
var nackNext = false
var brightness = -1
var wireBytes = 0
var pairedWrites = 0
var eventsMask = 0
var healthOk = 0
var bonded = false
var inCase = 0
var battery = 80
}
private class FakeG1Glasses(platform: ProtocolPlatform) : SessionLink {
lateinit var core: GlassesSessionCore
val lock = platform.createLock()
val leftArm = FakeG1Arm(true)
val rightArm = FakeG1Arm(false)
@Volatile var hasDisplayPath = true
/** Out of the case, or the OS said no: no bond can be made. */
@Volatile var pairingRefused = false
private val out = ArrayList<Pair<String, ByteArray>>()
private fun arm(address: String) = if (address == LEFT) leftArm else rightArm
/** Delivered off the writer's stack, as the BLE callback thread does: the session writes outside its monitor. */
private fun event(address: String, type: Int, body: ByteArray) {
val data = ByteArray(9) + body
data[0] = type.toByte()
core.onNotification(address, G1Ble.EVT_CHAR_UUID, data)
}
fun input(address: String, trigger: Int, value: Int) {
val body = ByteArray(7)
body[2] = trigger.toByte()
for (i in 0..3) body[3 + i] = (value ushr (8 * i)).toByte()
event(address, G1Protocol.EV_INPUT, body)
}
override fun connect(address: String, timeoutMs: Int): Boolean = true
override fun isConnected(address: String): Boolean = true
override fun requestHighPriority(address: String) {}
override fun requestMtu(address: String, mtu: Int, timeoutMs: Int): Boolean = true
override fun negotiatedMtu(address: String): Int = 185
override fun discoverServices(address: String, timeoutMs: Int): Boolean = true
override fun enableNotifications(address: String, characteristicUuid: String, enable: Boolean, timeoutMs: Int): Boolean =
characteristicUuid == G1Ble.EVT_CHAR_UUID
override fun requestBond(address: String) {
if (!pairingRefused) lock.withLock { arm(address).bonded = true }
}
override fun writeFrames(address: String, characteristicUuid: String, frames: List<ByteArray>, mode: GattWriteMode, timeoutMs: Int): Boolean {
val a = arm(address)
when (characteristicUuid) {
G1Ble.PAIR_CHAR_UUID -> {
assertEquals(GattWriteMode.WITH_RESPONSE, mode, "only a write with response can make the OS pair")
if (pairingRefused) return false
lock.withLock {
a.pairedWrites++
a.bonded = true
}
}
G1Ble.CTRL_CHAR_UUID -> for (f in frames) control(address, a, f)
G1Ble.FC_CHAR_UUID -> {
assertEquals(GattWriteMode.WITHOUT_RESPONSE, mode)
assertTrue(frames.all { it.size <= 182 }, "writes must fit the MTU")
for (f in frames) packet(address, a, f)
}
else -> throw AssertionError("write to $characteristicUuid")
}
return true
}
private fun reply(address: String, op: Int, tag: Int, status: Int, body: ByteArray = ByteArray(0)) =
event(address, 0x80 or op, byteArrayOf(tag.toByte(), status.toByte()) + body)
private fun control(address: String, a: FakeG1Arm, f: ByteArray) {
val op = f[0].toInt() and 255
val tag = f[1].toInt() and 255
when (op) {
G1Protocol.OP_HELLO -> {
val body = ByteArray(35)
body[0] = 5
body[1] = 0
body[2] = 5
body[3] = 62
body[4] = (if (a.left) 1 else 0).toByte()
body[5] = (2 or 64).toByte()
reply(address, op, tag, 0, body)
}
G1Protocol.OP_FC_INFO -> if (hasDisplayPath) {
val body = ByteArray(26)
body[0] = 1
reply(address, op, tag, 0, body)
} else reply(address, op, tag, 2)
G1Protocol.OP_EVENTS -> {
lock.withLock { a.eventsMask = (f[2].toInt() and 255) or ((f[3].toInt() and 255) shl 8) }
reply(address, op, tag, 0, f.copyOfRange(2, 4))
}
G1Protocol.OP_HEALTH_OK -> {
lock.withLock { a.healthOk++ }
reply(address, op, tag, 0, ByteArray(1))
}
G1Protocol.OP_PROPS -> {
val values = lock.withLock { intArrayOf(a.battery, 0, a.inCase, 1) }
val body = ByteArray(4 * values.size)
for (i in values.indices) for (b in 0..3) body[4 * i + b] = (values[i] ushr (8 * b)).toByte()
reply(address, op, tag, 0, body)
}
else -> reply(address, op, tag, 2)
}
}
private fun packet(address: String, a: FakeG1Arm, p: ByteArray) {
val opts = p[0].toInt() and 255
val stream = p[1].toInt() and 255
val complete = lock.withLock {
if (opts and 0x80 != 0) a.current = ByteArray(0)
a.current += p.copyOfRange(2, p.size)
if (opts and 0x40 != 0) a.current.also { a.current = ByteArray(0) } else null
} ?: return
var size = 0
val crc = (complete[3].toInt() and 255) or ((complete[4].toInt() and 255) shl 8)
var ok = false
lock.withLock {
a.wireBytes += complete.size
val lens = complete[0].toInt() and CfwTransport.BOTH
assertEquals(if (a.left) 1 else 2, lens, "a record names the arm it goes to")
if (a.nackNext) {
a.nackNext = false
} else {
if (complete[0].toInt() and CfwTransport.RESET_CONTEXT != 0) a.records.clear()
a.records.add(complete)
val message = inflateRecords(a.records).last()
size = message.size
assertTrue(size <= 16384, "the firmware's limit on a decoded message: $size")
if (CfwTransport.crc(message) == crc) {
ok = true
apply(a, message)
}
}
}
val body = byteArrayOf((if (ok) 1 else 3).toByte(), stream.toByte(), 0, 0, (if (a.left) 1 else 2).toByte(),
size.toByte(), (size ushr 8).toByte(), crc.toByte(), (crc ushr 8).toByte())
event(address, G1Protocol.EV_FC_ACK, body)
}
private fun apply(a: FakeG1Arm, m: ByteArray) {
val type = m[0].toInt() and 255
a.messageTypes.add(type)
when (type) {
CFW_MSG_DRAW_CALLS -> a.rects.addAll(applyDraw(a.frame, m))
CFW_MSG_PRESENT -> if (a.visible) {
a.frame.copyInto(a.panel)
a.panelOn = true
}
CFW_MSG_BRIGHTNESS -> {
a.brightness = m[2].toInt() and 255
if (a.visible && m[3].toInt() == 0) a.panelOn = false
a.visible = m[3].toInt() != 0
}
else -> throw AssertionError("message type $type must not reach a G1")
}
}
override fun disconnect(address: String) {}
override fun close() {}
override fun isBonded(address: String): Boolean = lock.withLock { arm(address).bonded }
override fun prepareBenchmarkLink(address: String, mode: Int) {}
override fun recordDisplayFrameSent() {}
}
private class G1Listener(platform: ProtocolPlatform) : FaceclawBleCommunicatorListener {
private val lock = platform.createLock()
private val phaseList = ArrayList<String>()
private val eventList = ArrayList<String>()
private val batteryList = ArrayList<String>()
private val firmwareList = ArrayList<String>()
private val wearList = ArrayList<Boolean>()
@Volatile var lastStatus = ""
val phases get() = lock.withLock { phaseList.toList() }
val events get() = lock.withLock { eventList.toList() }
val batteries get() = lock.withLock { batteryList.toList() }
val firmware get() = lock.withLock { firmwareList.toList() }
val wear get() = lock.withLock { wearList.toList() }
override fun onStateChange(phase: String?, status: String?) {
lock.withLock { phaseList.add(phase ?: "") }
lastStatus = status ?: ""
}
override fun onRingEvent(kind: String?, containerName: String?, eventType: Int, eventSource: Int, systemExitReasonCode: Int, frameId: Int, ringTick: Long, ringType: Int, ringAux: Int, ringSpeed: Int) {
lock.withLock { eventList.add("$kind:$eventType:$eventSource") }
}
override fun onBatteryState(headsetBattery: Int, headsetCharging: Int, ringBattery: Int, ringCharging: Int) {
lock.withLock { batteryList.add("$headsetBattery/$headsetCharging") }
}
override fun onSilentMode(silent: Boolean) {}
override fun onWearState(wearing: Boolean) {
lock.withLock { wearList.add(wearing) }
}
override fun onPhoneLockState(locked: Boolean) {}
override fun onCaseState(caseBattery: Int, caseCharging: Int, caseDocked: Boolean) {}
override fun onEvenAppConflict(message: String?) {}
override fun onFrameMetrics(paintMs: Int, transmitMs: Int, tileCount: Int) {}
override fun onFrameFinished(frameId: Int, outcome: String?) {}
override fun onFirmwareInfo(leftVersion: String?, rightVersion: String?, extension: String?) {
lock.withLock { firmwareList.add("$leftVersion|$rightVersion|$extension") }
}
}
private class G1Session {
val platform = testPlatform()
val glasses = FakeG1Glasses(platform)
private val host = object : SessionHost {
private val lock = platform.createLock()
private val lines = ArrayList<String>()
private var done: Latch? = null
fun logs(): List<String> = lock.withLock { lines.toList() }
override fun postToMain(action: () -> Unit) = action()
override fun currentThreadDispatcher(): SessionDispatcher = SessionDispatcher { it() }
override fun isPhoneLocked(): Boolean = false
override fun setScreenWakeLock(on: Boolean) {}
override fun isEvenAppActive(): Boolean = false
override fun startWorker(body: () -> Unit) {
val latch = Latch(1, platform)
done = latch
startThread("g1-test-session", true) {
try {
body()
} finally {
latch.countDown()
}
}
}
override fun joinWorker(timeoutMs: Long) {
done?.await(timeoutMs)
}
override fun log(level: SessionLogLevel, tag: String, message: String, error: Throwable?) {
lock.withLock { lines.add("$level $tag: $message") }
}
}
val listener = G1Listener(platform)
val core = GlassesSessionCore(glasses, host, FrameTimingsCore(platform), platform, RIGHT, LEFT, "")
init {
glasses.core = core
core.setListener(listener)
core.setRequiredFirmwareRevision(38)
core.useG1()
core.configureCompositorScreen(W, H)
core.configureSurface("s", 0, 0, W, 64, 0, SurfaceCompositor.TRANSPARENCY_OPAQUE)
}
fun ready(): Boolean = core.monitor.withLock { core.sessionReady && core.fixedLayoutCreated }
fun displayedMatchesDesired(): Boolean = core.monitor.withLock {
core.desiredTilesLock.locked { core.desiredFingerprint.isNotEmpty() && core.desiredFingerprint == core.displayedFingerprint }
}
fun pixels(seed: Int) = ByteArray(W * 64) { if ((it + seed) % 11 == 0) 0xF0.toByte() else if (it % 17 == 0) 0x70 else 0 }
fun submit(seed: Int, frameId: Int) =
core.submitSurfaceFrame(ArrayByteReader(pixels(seed)), "s", 0, 0, W, 64, "content-$seed", 0, frameId, null)
/** The packed picture the surface's gray pixels should give on both lenses. */
fun expected(seed: Int): ByteArray {
val packed = ByteArray(STRIDE * H)
BmpUtil.pack4bppFromGray8(pixels(seed), W, 64).copyInto(packed)
return packed
}
fun tail(): String = host.logs().takeLast(30).joinToString("\n")
fun shownOnBoth(picture: ByteArray): Boolean = glasses.lock.withLock {
glasses.leftArm.panel.contentEquals(picture) && glasses.rightArm.panel.contentEquals(picture)
}
}
class G1SessionTest {
@Test
fun pairsOnFirstConnectAndShowsEachLensItsFrame() {
val s = G1Session()
try {
assertTrue(s.core.start())
assertTrue(awaitTrue(5_000) { s.ready() }, "never ready:\n" + s.tail())
assertTrue(s.core.isEvenG1())
assertEquals(1, s.glasses.leftArm.pairedWrites, "each arm's encryption is proved by a PAIR write")
assertEquals(1, s.glasses.rightArm.pairedWrites)
assertEquals(G1Protocol.EVENTS_MASK, s.glasses.leftArm.eventsMask)
assertEquals(G1Protocol.EVENTS_MASK, s.glasses.rightArm.eventsMask)
assertEquals(1, s.glasses.leftArm.healthOk, "the boot is confirmed healthy")
assertTrue(s.listener.firmware.single().startsWith("g1v0 0.5.62|g1v0 0.5.62|Faceclaw/"), s.listener.firmware.toString())
s.submit(1, 1)
assertTrue(awaitTrue(5_000) { s.displayedMatchesDesired() }, "frame never displayed:\n" + s.tail())
val picture = s.expected(1)
assertTrue(s.shownOnBoth(picture), "both lenses show the whole frame:\n" + s.tail())
for (arm in listOf(s.glasses.leftArm, s.glasses.rightArm)) {
assertEquals(CFW_MSG_PRESENT, arm.messageTypes.last(), "an update ends in PRESENT")
assertTrue(arm.messageTypes.all { it == CFW_MSG_DRAW_CALLS || it == CFW_MSG_PRESENT || it == CFW_MSG_BRIGHTNESS },
arm.messageTypes.toString())
}
} finally {
s.core.disconnect()
}
}
@Test
fun aSecondFrameIsADeltaThatCostsLittle() {
val s = G1Session()
try {
assertTrue(s.core.start())
assertTrue(awaitTrue(5_000) { s.ready() }, s.tail())
s.submit(1, 1)
assertTrue(awaitTrue(5_000) { s.displayedMatchesDesired() }, s.tail())
val first = s.glasses.lock.withLock { s.glasses.leftArm.wireBytes }
val rectsBefore = s.glasses.lock.withLock { s.glasses.leftArm.rects.size }
// One small area of the surface changes.
val pixels = s.pixels(1)
for (y in 10 until 14) for (x in 100 until 120) pixels[y * W + x] = 0x80.toByte()
s.core.submitSurfaceFrame(ArrayByteReader(pixels), "s", 0, 0, W, 64, "content-delta", 0, 2, null)
assertTrue(awaitTrue(5_000) { s.displayedMatchesDesired() }, s.tail())
val packed = ByteArray(STRIDE * H)
BmpUtil.pack4bppFromGray8(pixels, W, 64).copyInto(packed)
assertTrue(s.shownOnBoth(packed), s.tail())
s.glasses.lock.withLock {
val rects = s.glasses.leftArm.rects.drop(rectsBefore)
assertTrue(rects.isNotEmpty() && rects.all { it[2] * it[3] < 64 * 16 }, "tight rects: " + rects.map { it.toList() })
assertTrue(s.glasses.leftArm.wireBytes - first < first, "${s.glasses.leftArm.wireBytes - first} after $first")
}
} finally {
s.core.disconnect()
}
}
@Test
fun anUnchangedFrameSendsNothing() {
val s = G1Session()
try {
assertTrue(s.core.start())
assertTrue(awaitTrue(5_000) { s.ready() }, s.tail())
s.submit(1, 1)
assertTrue(awaitTrue(5_000) { s.displayedMatchesDesired() }, s.tail())
val before = s.glasses.lock.withLock { s.glasses.leftArm.messageTypes.size }
s.core.submitSurfaceFrame(ArrayByteReader(s.pixels(1)), "s", 0, 0, W, 64, "content-again", 0, 2, null)
assertTrue(awaitTrue(5_000) { s.displayedMatchesDesired() }, s.tail())
assertEquals(before, s.glasses.lock.withLock { s.glasses.leftArm.messageTypes.size })
} finally {
s.core.disconnect()
}
}
@Test
fun aNackReplaysFromAResetStreamAndTheFrameStillArrives() {
val s = G1Session()
try {
assertTrue(s.core.start())
assertTrue(awaitTrue(5_000) { s.ready() }, s.tail())
s.glasses.lock.withLock { s.glasses.rightArm.nackNext = true }
s.submit(2, 1)
assertTrue(awaitTrue(8_000) { s.displayedMatchesDesired() }, "never displayed:\n" + s.tail())
assertTrue(s.shownOnBoth(s.expected(2)), s.tail())
assertFalse(s.glasses.lock.withLock { s.glasses.rightArm.nackNext })
} finally {
s.core.disconnect()
}
}
@Test
fun gesturesWearAndBatteryReachTheListener() {
val s = G1Session()
try {
assertTrue(s.core.start())
assertTrue(awaitTrue(5_000) { s.ready() }, s.tail())
s.glasses.input(LEFT, G1Protocol.TRIGGER_TOUCH, G1Protocol.GESTURE_TAP)
s.glasses.input(RIGHT, G1Protocol.TRIGGER_TOUCH, G1Protocol.GESTURE_TAP)
s.glasses.input(RIGHT, G1Protocol.TRIGGER_TOUCH, G1Protocol.GESTURE_DOUBLE_TAP)
s.glasses.input(LEFT, G1Protocol.TRIGGER_TOUCH, G1Protocol.GESTURE_LONG_START)
s.glasses.input(LEFT, G1Protocol.TRIGGER_TOUCH, G1Protocol.GESTURE_LONG_END)
assertEquals(
listOf(
"sys-event:${BleProtocol.EVENT_SCROLL_TOP}:${BleProtocol.EVENT_SOURCE_GLASSES_L}",
"sys-event:${BleProtocol.EVENT_SCROLL_BOTTOM}:${BleProtocol.EVENT_SOURCE_GLASSES_R}",
"sys-event:${BleProtocol.EVENT_CLICK}:${BleProtocol.EVENT_SOURCE_GLASSES_R}",
"sys-event:${BleProtocol.EVENT_DOUBLE_CLICK}:${BleProtocol.EVENT_SOURCE_GLASSES_L}",
),
s.listener.events,
)
// The first props poll tells battery and wear; the pair reads its lower arm.
assertTrue(awaitTrue(3_000) { s.listener.batteries.contains("80/0") }, s.listener.batteries.toString())
assertTrue(awaitTrue(3_000) { s.listener.wear.contains(true) }, s.listener.wear.toString())
s.glasses.input(LEFT, G1Protocol.TRIGGER_BATTERY, 55)
assertTrue(awaitTrue(3_000) { s.listener.batteries.contains("55/0") }, s.listener.batteries.toString())
} finally {
s.core.disconnect()
}
}
@Test
fun blankingHidesThePanelsAndWakingIsADelta() {
val s = G1Session()
try {
assertTrue(s.core.start())
assertTrue(awaitTrue(5_000) { s.ready() }, s.tail())
s.submit(1, 1)
assertTrue(awaitTrue(5_000) { s.displayedMatchesDesired() }, s.tail())
val wire = s.glasses.lock.withLock { s.glasses.leftArm.wireBytes }
val draws = s.glasses.lock.withLock { s.glasses.leftArm.messageTypes.count { it == CFW_MSG_DRAW_CALLS } }
s.core.setScreenBlanked(true)
assertTrue(awaitTrue(5_000) { s.glasses.lock.withLock { !s.glasses.leftArm.visible && !s.glasses.rightArm.visible } }, s.tail())
assertTrue(s.shownOnBoth(s.expected(1)), "the arms keep the picture for the wake")
assertFalse(s.glasses.lock.withLock { s.glasses.leftArm.panelOn })
// In the dark a tap is for the Glanceboard and a double tap wakes, as on a G2.
s.glasses.input(LEFT, G1Protocol.TRIGGER_TOUCH, G1Protocol.GESTURE_TAP)
s.glasses.input(RIGHT, G1Protocol.TRIGGER_TOUCH, G1Protocol.GESTURE_DOUBLE_TAP)
assertEquals(
listOf("sys-event:${BleProtocol.EVENT_CLICK}:${BleProtocol.EVENT_SOURCE_GLASSES_L}",
"display-wake:${BleProtocol.EVENT_DOUBLE_CLICK}:0"),
s.listener.events,
)
s.core.setScreenBlanked(false)
assertTrue(awaitTrue(5_000) {
s.glasses.lock.withLock { s.glasses.leftArm.visible && s.glasses.leftArm.panelOn && s.glasses.rightArm.panelOn }
}, "the panels must come back with a PRESENT:\n" + s.tail())
assertEquals(draws, s.glasses.lock.withLock { s.glasses.leftArm.messageTypes.count { it == CFW_MSG_DRAW_CALLS } },
"the same picture needs no pixels")
assertTrue(s.glasses.lock.withLock { s.glasses.leftArm.wireBytes } - wire < 256)
} finally {
s.core.disconnect()
}
}
@Test
fun bothArmsInTheCaseDarkenThePanelsAndStopFrames() {
val s = G1Session()
try {
assertTrue(s.core.start())
assertTrue(awaitTrue(5_000) { s.ready() }, s.tail())
s.submit(1, 1)
assertTrue(awaitTrue(5_000) { s.displayedMatchesDesired() }, s.tail())
s.glasses.input(LEFT, G1Protocol.TRIGGER_CASE, 1)
assertFalse(s.core.monitor.withLock { s.core.chargingMode }, "one arm isn't the pair")
s.glasses.input(RIGHT, G1Protocol.TRIGGER_CASE, 1)
assertTrue(awaitTrue(3_000) { s.listener.phases.contains("charging") }, s.listener.phases.toString())
assertTrue(awaitTrue(3_000) { s.glasses.lock.withLock { !s.glasses.leftArm.visible && !s.glasses.rightArm.visible } }, s.tail())
} finally {
s.core.disconnect()
}
}
@Test
fun anArmThatCannotBondParksWithInstructions() {
val s = G1Session()
s.glasses.pairingRefused = true
try {
// A short window for the test: the session waits for the OS's pairing dialog.
assertTrue(s.core.start())
assertTrue(awaitTrue(40_000) { s.listener.phases.contains("unpaired") }, s.listener.phases.toString() + "\n" + s.tail())
assertTrue(s.listener.lastStatus.contains("case"), s.listener.lastStatus)
assertFalse(s.ready())
} finally {
s.core.disconnect()
}
}
@Test
fun firmwareWithoutTheDisplayPathIsIncompatible() {
val s = G1Session()
s.glasses.hasDisplayPath = false
try {
assertTrue(s.core.start())
assertTrue(awaitTrue(5_000) { s.listener.phases.contains("incompatible-firmware") }, s.listener.phases.toString() + "\n" + s.tail())
assertTrue(s.listener.firmware.single().endsWith("|"), s.listener.firmware.toString())
} finally {
s.core.disconnect()
}
}
}
class G1ProtocolTest {
@Test
fun packetsCarryARecordWithinTheMtu() {
val record = ByteArray(1000) { it.toByte() }
val packets = G1Protocol.packets(record, 42, 185)
assertTrue(packets.all { it.size <= 182 })
assertEquals(0x80, packets.first()[0].toInt() and 0xC0)
assertEquals(0x40, packets.last()[0].toInt() and 0xC0)
assertTrue(packets.drop(1).dropLast(1).all { it[0].toInt() == 0 })
assertTrue(packets.all { it[1].toInt() == 42 })
assertTrue(record.contentEquals(packets.flatMap { it.drop(2) }.toByteArray()))
val one = G1Protocol.packets(byteArrayOf(1, 2, 3, 4, 5), 7, 247)
assertEquals(1, one.size)
assertEquals(0xC0, one[0][0].toInt() and 0xC0)
}
@Test
fun theFirmwaresPacketLimitHoldsAtAnyMtu() {
assertEquals(244, G1Protocol.packets(ByteArray(5000), 1, 512).maxOf { it.size })
}
@Test
fun eventsAreParsed() {
val ack = ByteArray(9) + byteArrayOf(1, 9, 0, 0, 2, 0x34, 0x12, 0x78, 0x56)
ack[0] = G1Protocol.EV_FC_ACK.toByte()
val parsed = assertNotNull(G1Protocol.parseFcAck(ack))
assertFalse(parsed.nack)
assertEquals(9, parsed.streamId)
assertEquals(2, parsed.lens)
assertEquals(0x1234, parsed.size)
assertEquals(0x5678, parsed.checksum)
ack[9] = 3
assertTrue(assertNotNull(G1Protocol.parseFcAck(ack)).nack)
ack[9] = 2
assertNull(G1Protocol.parseFcAck(ack))
assertNull(G1Protocol.parseFcAck(ByteArray(5)))
val input = ByteArray(9) + byteArrayOf(1, 0, G1Protocol.TRIGGER_TOUCH.toByte(), 2, 0, 0, 0)
input[0] = G1Protocol.EV_INPUT.toByte()
val parsedInput = assertNotNull(G1Protocol.parseInput(input))
assertEquals(G1Protocol.TRIGGER_TOUCH, parsedInput.trigger)
assertEquals(2, parsedInput.value)
val reply = assertNotNull(G1Protocol.parseReply(ByteArray(9).also { it[0] = 0x81.toByte() } + byteArrayOf(7, 0, 42)))
assertEquals(1, reply.op)
assertEquals(7, reply.tag)
assertEquals(42, reply.body[0].toInt())
}
@Test
fun helloAndPropsAreParsed() {
val body = ByteArray(35)
body[0] = 5
body[1] = 0
body[2] = 5
body[3] = 62
body[4] = 1
body[5] = (2 or 64 or 128).toByte()
val hello = assertNotNull(G1Protocol.parseHello(body))
assertEquals("0.5.62", hello.version)
assertTrue(hello.leftArm && hello.panelOk && hello.encrypted && hello.inCase)
assertFalse(hello.safeMode)
body[0] = 4
assertNull(G1Protocol.parseHello(body), "protocol 4 is not this firmware")
val unknown = byteArrayOf(0, 0, 0, 0x80.toByte(), 7, 0, 0, 0)
val props = assertNotNull(G1Protocol.parseProps(unknown, 2))
assertEquals(G1Protocol.UNKNOWN, props[0])
assertEquals(7, props[1])
assertNull(G1Protocol.parseProps(unknown, 3))
}
@Test
fun gesturesMapToWhatTheUiExpects() {
assertEquals(BleProtocol.EVENT_SCROLL_TOP, G1Protocol.gestureEventType(G1Protocol.GESTURE_TAP, true))
assertEquals(BleProtocol.EVENT_SCROLL_BOTTOM, G1Protocol.gestureEventType(G1Protocol.GESTURE_TAP, false))
assertEquals(BleProtocol.EVENT_CLICK, G1Protocol.gestureEventType(G1Protocol.GESTURE_DOUBLE_TAP, true))
assertEquals(BleProtocol.EVENT_DOUBLE_CLICK, G1Protocol.gestureEventType(G1Protocol.GESTURE_TRIPLE_TAP, false))
assertEquals(BleProtocol.EVENT_DOUBLE_CLICK, G1Protocol.gestureEventType(G1Protocol.GESTURE_LONG_START, true))
assertNull(G1Protocol.gestureEventType(G1Protocol.GESTURE_LONG_END, true))
assertEquals(BleProtocol.EVENT_CLICK, G1Protocol.gestureEventType(G1Protocol.GESTURE_TAP, false, dark = true))
assertEquals(BleProtocol.EVENT_DOUBLE_CLICK, G1Protocol.gestureEventType(G1Protocol.GESTURE_DOUBLE_TAP, false, dark = true))
}
}
class G1FramePlannerTest {
private fun noise(seed: Int): ByteArray {
var state = seed
return ByteArray(STRIDE * H) {
state = state * 1103515245 + 12345
(state ushr 16).toByte()
}
}
private fun replay(start: ByteArray?, messages: List<ByteArray>): ByteArray {
val frame = start?.copyOf() ?: ByteArray(STRIDE * H)
for (m in messages) applyDraw(frame, m)
return frame
}
@Test
fun aFullFrameOfNoiseFitsTheMessageLimit() {
val next = noise(5)
val messages = G1FramePlanner.plan(null, next, W, H)
assertTrue(messages.size > 1)
assertTrue(messages.all { it.size <= G1FramePlanner.MAX_MESSAGE }, messages.maxOf { it.size }.toString())
assertTrue(replay(null, messages).contentEquals(next))
}
@Test
fun nothingChangedIsEmpty() {
val next = noise(5)
assertTrue(G1FramePlanner.plan(next, next.copyOf(), W, H).isEmpty())
}
@Test
fun deltasReconstructTheFrameAtAnyPosition() {
val before = noise(5)
for ((x, y, w, h) in listOf(listOf(0, 0, 1, 1), listOf(639, 479, 1, 1), listOf(101, 51, 33, 17), listOf(0, 100, 640, 3), listOf(300, 0, 2, 480))) {
val next = before.copyOf()
for (yy in y until y + h) for (xx in x until x + w) setNibble(next, xx, yy, 15 - nibble(next, xx, yy))
val messages = G1FramePlanner.plan(before, next, W, H)
assertTrue(messages.isNotEmpty())
assertTrue(replay(before, messages).contentEquals(next), "rect $x,$y ${w}x$h")
}
// Two far-apart changes
val next = before.copyOf()
setNibble(next, 3, 3, 15 - nibble(next, 3, 3))
setNibble(next, 600, 440, 15 - nibble(next, 600, 440))
assertTrue(replay(before, G1FramePlanner.plan(before, next, W, H)).contentEquals(next))
}
}
class G1ShellSceneTest {
@Test
fun aSceneWithNoLayersIsTheScreen() {
val screen = ByteArray(STRIDE * H)
assertTrue(ShellScene.EMPTY.composed(screen, W, H, false) === screen)
assertFalse(ShellScene.EMPTY.hasStereoDepth)
}
@Test
fun depthShiftsEachLensItsOwnWay() {
val screen = ByteArray(STRIDE * H)
setNibble(screen, 100, 50, 9)
val scene = ShellScene(emptyList(), screenDepth = 2)
assertTrue(scene.hasStereoDepth)
val left = scene.composed(screen, W, H, false)
val right = scene.composed(screen, W, H, true)
assertEquals(9, nibble(left, 101, 50), "depth +2 moves the left lens +1")
assertEquals(9, nibble(right, 99, 50), "and the right lens -1")
assertEquals(0, nibble(left, 100, 50))
assertEquals(9, nibble(screen, 100, 50), "the screen itself is left alone")
}
}
+55
View File
@@ -306,3 +306,58 @@ test("a RayNeo iO is its own candidate, never half of a G2 pair", () => {
assert.equal(row.canSelect, true);
assert.equal(row.isPreviouslyPaired, true);
});
// ---------------------------------------------------------------------------
// Even G1
// ---------------------------------------------------------------------------
const G1_SERIAL = "S110LABC030139";
const g1Arm = (name, address, manufacturerData) => ({
address, name, manufacturerData, rssi: -50, txPower: null, connectable: true, bonded: false, source: "scan", seenAtMs: 1000,
});
const g1v0Arm = (side, address) => g1Arm(`G1v0_${side}`, address, "ffff0104" + ascii(G1_SERIAL));
test("G1 arms on g1v0 join on the frame serial and can be selected", () => {
const aggregator = new DiscoveryAggregator();
aggregator.ingest(g1v0Arm("L", "F4:27:E9:CA:E8:3F"));
aggregator.ingest(g1v0Arm("R", "CD:EB:89:BF:E9:EC"));
const [pair, ...rest] = aggregator.pairs();
assert.equal(rest.length, 0);
assert.equal(pair.completeness, "complete");
assert.equal(pair.g1Firmware, "g1v0");
assert.equal(pair.identity, null);
const row = glassesRow(pair);
assert.equal(row.modelTitle, "Even Realities G1");
assert.equal(row.canSelect, true);
assert.match(row.armsSummary, /case/);
});
test("G1 arms on Even's firmware show up but can't be selected", () => {
const aggregator = new DiscoveryAggregator();
aggregator.ingest(g1Arm("Even G1_70_L_EF50E5", "C0:66:16:EF:50:E5", "02" + ascii(G1_SERIAL)));
aggregator.ingest(g1Arm("Even G1_70_R_CBE689", "E4:46:BA:CB:E6:89", "01" + ascii(G1_SERIAL)));
const [pair] = aggregator.pairs();
assert.equal(pair.g1Firmware, "stock");
assert.equal(pair.completeness, "complete");
const row = glassesRow(pair);
assert.equal(row.canSelect, false);
assert.match(row.armsSummary, /computer/);
});
test("a G1 pair with one arm in safe mode can't be selected", () => {
const aggregator = new DiscoveryAggregator();
aggregator.ingest(g1v0Arm("L", "F4:27:E9:CA:E8:3F"));
aggregator.ingest(g1Arm("G1v0S_R", "CD:EB:89:BF:E9:EC", "ffff0104" + ascii(G1_SERIAL)));
const [pair] = aggregator.pairs();
assert.equal(pair.g1Firmware, "g1v0-safe");
assert.equal(glassesRow(pair).canSelect, false);
});
test("G2 pairs carry no G1 firmware", () => {
const aggregator = new DiscoveryAggregator();
aggregator.ingest(arm("left", "S110LABC030139", "EC:D7:82:69:3C:CB", -50));
aggregator.ingest(arm("right", "S110LABC030139", "D0:7A:47:82:09:67", -50));
const pairs = aggregator.pairs();
assert.equal(pairs.length, 1);
assert.equal(pairs[0].g1Firmware, undefined);
});