G1 support: Preserve connections after flashing, debug

This commit is contained in:
James Babcock committed 2026-11-07 04:16:15 -08:00
1 parent 595b462b2e
commit b353483ac2
38 files changed
+1291 -178

No files matched your search

@@ -72,6 +72,15 @@ private class FakeArm(private val image: ByteArray, var stock: Boolean = false)
var silentAtOffset = -1
var onChunk: (() -> Unit)? = null
var connects = 0
/** The OS remembers a table without g1v0's services, as after an install at the same address. */
var staleTable = false
var refreshes = 0
/** Android says bonded and the arm has lost its half. */
var staleBond = false
var removedBonds = 0
var inCase = false
/** Even's firmware's answer to its battery query; null: it says nothing. */
var stockBatteryReply: ByteArray? = null
val wantHash = G1Smp.imageHash(image)
@@ -83,13 +92,31 @@ private class FakeArm(private val image: ByteArray, var stock: Boolean = false)
}
override fun prepareLink(address: String, desiredMtu: Int, timeoutMs: Int) {}
override fun discoverServices(address: String, timeoutMs: Int): Boolean = connected
/** As FaceclawBleManager: a characteristic the table lacks throws, a refused one (no encryption) returns false. */
override fun enableNotifications(address: String, characteristicUuid: String, timeoutMs: Int): Boolean {
if (!connected) return false
if (stock && characteristicUuid == G1Ble.EVT_CHAR_UUID) return false
if (!stock && characteristicUuid == G1Smp.NUS_TX_UUID) return false
if (!connected) throw IllegalStateException("Not connected")
if (!hasCharacteristic(address, characteristicUuid)) throw IllegalStateException("Characteristic not found: $characteristicUuid")
if (stock && staleBond && characteristicUuid == G1Smp.NUS_TX_UUID) return false
subscribed.add(characteristicUuid)
return true
}
override fun hasCharacteristic(address: String, characteristicUuid: String): Boolean = when (characteristicUuid) {
G1Ble.EVT_CHAR_UUID -> !stock && !staleTable
G1Smp.NUS_TX_UUID -> stock
else -> true
}
override fun refreshServices(address: String, timeoutMs: Int): Boolean {
refreshes++
staleTable = false
return connected
}
override fun removeBond(address: String): Boolean {
removedBonds++
bond = BondState.NONE
staleBond = false
connected = false
return true
}
override fun isConnected(address: String): Boolean = connected
override fun bondState(address: String): BondState = bond
override fun requestBond(address: String) {
@@ -108,8 +135,15 @@ private class FakeArm(private val image: ByteArray, var stock: Boolean = false)
override fun writeFrames(address: String, characteristicUuid: String, frames: List<ByteArray>, mode: GattWriteMode, timeoutMs: Int): Boolean {
if (!connected) throw IllegalStateException("Not connected")
when (characteristicUuid) {
G1Smp.NUS_RX_UUID -> heartbeats.add(frames.single())
G1Ble.PAIR_CHAR_UUID -> return bond == BondState.BONDED
G1Smp.NUS_RX_UUID -> {
val frame = frames.single()
if (frame[0].toInt() == 0x2c) {
stockBatteryReply?.let { inbound?.onNotification(ARM, G1Smp.NUS_TX_UUID, it) }
} else {
heartbeats.add(frame)
}
}
G1Ble.PAIR_CHAR_UUID -> return bond == BondState.BONDED && !staleBond
G1Ble.CTRL_CHAR_UUID -> control(frames.single())
G1Smp.SMP_CHAR_UUID -> {
for (frame in frames) assertTrue(frame.size <= 97, "a write longer than the MTU allows")
@@ -126,7 +160,7 @@ private class FakeArm(private val image: ByteArray, var stock: Boolean = false)
val body = when (op) {
G1Protocol.OP_HELLO -> {
val parts = runningVersion.split(".").map { it.toInt().toByte() }
val flags = (if (safeMode) 1 else 0) or 2 or 64
val flags = (if (safeMode) 1 else 0) or 2 or (if (staleBond) 0 else 64) or (if (inCase) 128 else 0)
byteArrayOf(5, parts[0], parts[1], parts[2], 1, flags.toByte(), 0)
}
G1Protocol.OP_PROPS -> byteArrayOf(battery.toByte(), 0, 0, 0)
@@ -230,6 +264,19 @@ private val FAST = G1FlashTimings(
controlReplyMs = 20, controlTries = 2, uploadReplyMs = 150, smpReplyMs = 150, resetReplyMs = 50, heartbeatMs = 30, pollMs = 5, uploadRetries = 5,
)
class G1SmpStockTest {
@Test
fun stocksBatteryReplyIsReadOnlyWhenItIsOne() {
// What the real firmware answered in emulation (g1-fw BLE_COMMAND_SET_REPORT), first bytes.
assertEquals(100, G1Smp.parseStockBattery(byteArrayOf(0x2c, 0x66, 0x64, 0x64, 0xf9.toByte(), 0x80.toByte())))
assertEquals(null, G1Smp.parseStockBattery(byteArrayOf(0x2c, 0x66, 0)))
assertEquals(null, G1Smp.parseStockBattery(byteArrayOf(0x2c, 0x66, 101)))
assertEquals(null, G1Smp.parseStockBattery(byteArrayOf(0x2c, 0xc9.toByte(), 50)))
assertEquals(null, G1Smp.parseStockBattery(byteArrayOf(0x25, 0x66, 50)))
assertEquals(null, G1Smp.parseStockBattery(byteArrayOf(0x2c, 0x66)))
}
}
class G1SmpTest {
private val sha = ByteArray(32) { it.toByte() }
@@ -519,6 +566,75 @@ class G1ArmFlashFlowTest {
assertTrue("an arm pairs only in its case" in listener.detail, listener.detail)
}
@Test
fun aStaleBondInTheCaseIsRemovedAndMadeAgain() {
val arm = FakeArm(image)
arm.staleBond = true
arm.inCase = true
val result = run(arm, G1ArmFlashFlow.Mode.UPDATE)
assertEquals(true, result.success, result.detail)
assertEquals(1, arm.removedBonds)
assertEquals(1, arm.bondRequests)
confirmIsLast(arm)
}
@Test
fun aBondIsNeverGivenUpOutOfTheCase() {
val arm = FakeArm(image)
arm.staleBond = true
arm.inCase = false
val result = run(arm, G1ArmFlashFlow.Mode.UPDATE, window = 1)
assertEquals(false, result.success)
assertEquals(0, arm.removedBonds, "no new bond can be made out of the case")
}
@Test
fun aStaleBondOnStockIsRemovedAndMadeAgain() {
val arm = FakeArm(image, stock = true)
arm.staleBond = true
val result = run(arm, G1ArmFlashFlow.Mode.STOCK)
assertEquals(true, result.success, result.detail)
assertEquals(1, arm.removedBonds)
assertEquals(1, arm.bondRequests)
}
@Test
fun anOldServiceTableIsReadAgainBeforeItIsBelieved() {
val arm = FakeArm(image)
arm.staleTable = true
val result = run(arm, G1ArmFlashFlow.Mode.PROBE)
assertEquals(true, result.success, result.detail)
assertEquals(1, arm.refreshes)
assertTrue("\"firmware\":\"g1v0\"" in result.detail, result.detail)
}
@Test
fun aLowBatteryOnStockStopsBeforeAnyUpload() {
val arm = FakeArm(image, stock = true)
arm.stockBatteryReply = byteArrayOf(0x2c, 0x66, 12, 12)
val result = run(arm, G1ArmFlashFlow.Mode.STOCK)
assertEquals(false, result.success)
assertTrue("12%" in result.detail, result.detail)
assertFalse("upload" in arm.calls)
}
@Test
fun aChargedArmOnStockGoesOn() {
val arm = FakeArm(image, stock = true)
arm.stockBatteryReply = byteArrayOf(0x2c, 0x66, 100, 100)
val result = run(arm, G1ArmFlashFlow.Mode.STOCK)
assertEquals(true, result.success, result.detail)
assertTrue(result.logs.any { "battery 100%" in it }, result.logs.toString())
}
@Test
fun aStockArmThatSaysNothingAboutItsBatteryGoesOn() {
val arm = FakeArm(image, stock = true)
val result = run(arm, G1ArmFlashFlow.Mode.STOCK)
assertEquals(true, result.success, result.detail)
assertTrue(result.logs.any { "battery unknown" in it }, result.logs.toString())
}
@Test
fun aProbeSaysWhatAnArmRuns() {
val arm = FakeArm(image)
@@ -139,6 +139,19 @@ private class FakeG1Glasses(platform: ProtocolPlatform) : SessionLink {
val ancsWrites = ArrayList<Pair<String, ByteArray>>()
/** Out of the case, or the OS said no: no bond can be made. */
@Volatile var pairingRefused = false
/** Both arms run Even's firmware: no g1v0 service. */
@Volatile var stockFirmware = false
/** The OS remembers a table without g1v0's services, as after an install at the same address. */
@Volatile var staleTable = false
@Volatile var refreshes = 0
@Volatile var removedBonds = 0
/** The OS says bonded and the arm has lost its half: PAIR fails with the link up. */
@Volatile var staleBond = false
@Volatile var helloInCase = false
/** An arm that won't connect, whatever it's asked. */
val away = HashSet<String>()
/** Links up. Everything stays up unless a test takes it down. */
private val up = hashSetOf(LEFT, RIGHT)
private val out = ArrayList<Pair<String, ByteArray>>()
private fun arm(address: String) = if (address == LEFT) leftArm else rightArm
@@ -169,9 +182,53 @@ private class FakeG1Glasses(platform: ProtocolPlatform) : SessionLink {
event(address, G1Protocol.EV_INPUT, body)
}
override fun connect(address: String, timeoutMs: Int): Boolean = true
/** The link drops, as the BLE callback thread reports it. */
fun drop(address: String) {
lock.withLock { up.remove(address) }
core.onConnectionStateChange(address, false)
}
override fun isConnected(address: String): Boolean = true
/** The arm comes back in range: the next connection attempt gets it. */
fun comeBack(address: String) {
lock.withLock { away.remove(address) }
}
override fun connect(address: String, timeoutMs: Int): Boolean = lock.withLock {
if (address in away) return@withLock false
up.add(address)
true
}
override fun beginConnect(address: String, background: Boolean): Boolean {
val connected = connect(address, 0)
if (connected) core.onConnectionStateChange(address, true)
return connected
}
override fun isConnected(address: String): Boolean = lock.withLock { address in up }
override fun hasCharacteristic(address: String, characteristicUuid: String): Boolean = when (characteristicUuid) {
G1Ble.EVT_CHAR_UUID -> !stockFirmware && !staleTable
G1Ble.ANCS_CHAR_UUID -> !ancsCharacteristicMissing
else -> true
}
override fun refreshServices(address: String, timeoutMs: Int): Boolean {
refreshes++
staleTable = false
return true
}
override fun removeBond(address: String): Boolean {
removedBonds++
lock.withLock {
arm(address).bonded = false
up.remove(address)
}
staleBond = false
core.onConnectionStateChange(address, false)
return true
}
override fun requestHighPriority(address: String) {}
@@ -181,12 +238,12 @@ private class FakeG1Glasses(platform: ProtocolPlatform) : SessionLink {
override fun discoverServices(address: String, timeoutMs: Int): Boolean = true
/** As FaceclawBleManager: a characteristic the table lacks throws, it doesn't return false. */
override fun enableNotifications(address: String, characteristicUuid: String, enable: Boolean, timeoutMs: Int): Boolean {
if (characteristicUuid == G1Ble.ANCS_CHAR_UUID && !ancsCharacteristicMissing) {
lock.withLock { ancsSubscribed.add(address) }
return true
}
return characteristicUuid == G1Ble.EVT_CHAR_UUID
if (!isConnected(address)) throw IllegalStateException("Not connected: $address")
if (!hasCharacteristic(address, characteristicUuid)) throw IllegalStateException("Characteristic not found: $characteristicUuid")
if (characteristicUuid == G1Ble.ANCS_CHAR_UUID) lock.withLock { ancsSubscribed.add(address) }
return true
}
override fun requestBond(address: String) {
@@ -194,11 +251,12 @@ private class FakeG1Glasses(platform: ProtocolPlatform) : SessionLink {
}
override fun writeFrames(address: String, characteristicUuid: String, frames: List<ByteArray>, mode: GattWriteMode, timeoutMs: Int): Boolean {
if (!isConnected(address)) throw IllegalStateException("Not connected: $address")
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
if (pairingRefused || staleBond) return false
lock.withLock {
a.pairedWrites++
a.bonded = true
@@ -233,7 +291,7 @@ private class FakeG1Glasses(platform: ProtocolPlatform) : SessionLink {
body[2] = 5
body[3] = 63
body[4] = (if (a.left) 1 else 0).toByte()
body[5] = (2 or 64).toByte()
body[5] = (2 or (if (staleBond) 0 else 64) or (if (helloInCase) 128 else 0)).toByte()
body[6] = ((if (a.left) 0 else 4) or (if (hasAncsRelay) 8 else 0)).toByte()
reply(address, op, tag, 0, body)
}
@@ -473,6 +531,199 @@ private class G1Session {
}
}
class G1LinkTest {
private fun started(s: G1Session, seed: Int = 1) {
s.core.monitor.withLock { s.core.g1.armRecoveryMs = 2_000 }
assertTrue(s.core.start())
assertTrue(awaitTrue(5_000) { s.ready() }, "never ready:\n" + s.tail())
s.submit(seed, seed)
assertTrue(awaitTrue(5_000) { s.displayedMatchesDesired() }, "frame never displayed:\n" + s.tail())
}
@Test
fun evensFirmwareSaysWhyInsteadOfRetrying() {
val s = G1Session()
try {
s.glasses.stockFirmware = true
assertTrue(s.core.start())
assertTrue(awaitTrue(5_000) { s.listener.firmware.isNotEmpty() }, "no firmware report:\n" + s.tail())
assertEquals("Even's firmware|Even's firmware|", s.listener.firmware.single())
assertTrue(s.glasses.refreshes >= 1, "the table is read again before it's believed")
assertFalse(s.ready())
} finally {
s.core.disconnect()
}
}
@Test
fun anOldServiceTableIsReadAgain() {
val s = G1Session()
try {
s.glasses.staleTable = true
assertTrue(s.core.start())
assertTrue(awaitTrue(5_000) { s.ready() }, "never ready:\n" + s.tail())
assertEquals(1, s.glasses.refreshes)
assertTrue(s.listener.firmware.single().endsWith("Faceclaw/38"), s.listener.firmware.toString())
} finally {
s.core.disconnect()
}
}
@Test
fun aStalePairingInTheCaseIsRemovedAndMadeAgain() {
val s = G1Session()
try {
s.glasses.leftArm.bonded = true
s.glasses.rightArm.bonded = true
s.glasses.staleBond = true
s.glasses.helloInCase = true
assertTrue(s.core.start())
assertTrue(awaitTrue(8_000) { s.ready() }, "never ready:\n" + s.tail())
assertEquals(1, s.glasses.removedBonds)
assertFalse("unpaired" in s.listener.phases, "this isn't for the wearer to fix: " + s.listener.phases)
} finally {
s.core.disconnect()
}
}
@Test
fun aStalePairingOutOfTheCaseIsKeptAndExplained() {
val s = G1Session()
try {
s.glasses.leftArm.bonded = true
s.glasses.rightArm.bonded = true
s.glasses.staleBond = true
assertTrue(s.core.start())
assertTrue(awaitTrue(8_000) { "charging case" in s.listener.lastStatus }, "status: " + s.listener.lastStatus + "\n" + s.tail())
assertEquals(0, s.glasses.removedBonds, "no new bond can be made out of the case")
assertFalse("Exception" in s.listener.lastStatus, s.listener.lastStatus)
assertFalse("unpaired" in s.listener.phases, s.listener.phases.toString())
} finally {
s.core.disconnect()
}
}
@Test
fun aFailedConnectSaysWhatHappened() {
val s = G1Session()
try {
s.glasses.leftArm.bonded = true
s.glasses.rightArm.bonded = true
s.core.start()
// An arm that goes away during setup, before the session is ready.
s.glasses.drop(RIGHT)
s.glasses.away.add(RIGHT)
assertTrue(awaitTrue(25_000) { "right arm" in s.listener.lastStatus || s.ready() }, "status: " + s.listener.lastStatus)
assertFalse("Exception" in s.listener.lastStatus, s.listener.lastStatus)
} finally {
s.core.disconnect()
}
}
@Test
fun oneArmDroppingLeavesTheSessionAndTheOtherEyeAlone() {
val s = G1Session()
try {
started(s)
val phasesBefore = s.listener.phases.size
val rightBefore = s.glasses.lock.withLock { s.glasses.rightArm.wireBytes }
s.glasses.away.add(LEFT)
s.glasses.drop(LEFT)
assertTrue(s.ready(), "the session goes on")
// The right eye keeps getting frames, and nothing waits for the left.
s.submit(2, 2)
assertTrue(awaitTrue(5_000) { s.glasses.lock.withLock { s.glasses.rightArm.panel.contentEquals(s.expected(2)) } },
"the right eye stopped:\n" + s.tail())
assertTrue(s.glasses.lock.withLock { s.glasses.rightArm.wireBytes } > rightBefore)
assertTrue(s.ready())
assertTrue(s.listener.phases.drop(phasesBefore).none { it == "retrying" || it == "connecting" },
"no reconnect shown for a blip: " + s.listener.phases.drop(phasesBefore))
} finally {
s.core.disconnect()
}
}
@Test
fun anArmThatComesBackCatchesUpByItself() {
val s = G1Session()
try {
started(s)
val leftEvents = s.glasses.lock.withLock { s.glasses.leftArm.healthOk }
val rightPairs = s.glasses.lock.withLock { s.glasses.rightArm.pairedWrites }
s.glasses.away.add(LEFT)
s.glasses.drop(LEFT)
s.submit(2, 2)
assertTrue(awaitTrue(5_000) { s.glasses.lock.withLock { s.glasses.rightArm.panel.contentEquals(s.expected(2)) } })
s.glasses.lock.withLock { s.glasses.leftArm.records.clear() }
s.glasses.comeBack(LEFT)
assertTrue(awaitTrue(5_000) { s.shownOnBoth(s.expected(2)) }, "the left eye never caught up:\n" + s.tail())
assertTrue(s.ready())
assertTrue(s.glasses.lock.withLock { s.glasses.leftArm.healthOk } > leftEvents, "it was set up again")
assertEquals(rightPairs, s.glasses.lock.withLock { s.glasses.rightArm.pairedWrites }, "the other arm wasn't touched")
assertEquals(CFW_MSG_PRESENT, s.glasses.lock.withLock { s.glasses.leftArm.messageTypes.last() })
} finally {
s.core.disconnect()
}
}
@Test
fun theRightArmComingBackStartsItsMicAgain() {
val s = G1Session()
try {
started(s)
val listener = object : FaceclawAudioPacketListener {
override fun onAudioPacket(data: ByteArray?, arm: String?, arrivalMs: Long) {}
}
assertTrue(s.core.g1StartAudioCapture(listener))
assertTrue(awaitTrue(3_000) { s.glasses.lock.withLock { s.glasses.rightArm.micRequests.isNotEmpty() } })
s.glasses.away.add(RIGHT)
s.glasses.drop(RIGHT)
val before = s.glasses.lock.withLock { s.glasses.rightArm.micRequests.size }
s.glasses.comeBack(RIGHT)
assertTrue(awaitTrue(5_000) { s.glasses.lock.withLock { s.glasses.rightArm.micRequests.size } > before }, s.tail())
} finally {
s.core.disconnect()
}
}
@Test
fun anArmThatStaysAwayEndsInAFullReconnect() {
val s = G1Session()
try {
started(s)
s.glasses.away.add(LEFT)
s.glasses.drop(LEFT)
assertTrue(awaitTrue(8_000) { "left arm" in s.listener.lastStatus }, "status: " + s.listener.lastStatus + "\n" + s.tail())
assertFalse("Exception" in s.listener.lastStatus, s.listener.lastStatus)
s.glasses.comeBack(LEFT)
assertTrue(awaitTrue(15_000) { s.ready() }, "never back:\n" + s.tail())
s.submit(3, 3)
assertTrue(awaitTrue(5_000) { s.shownOnBoth(s.expected(3)) }, s.tail())
} finally {
s.core.disconnect()
}
}
@Test
fun bothArmsDroppingIsAFullReconnectAndAFastOne() {
val s = G1Session()
try {
started(s)
s.glasses.drop(LEFT)
s.glasses.drop(RIGHT)
val droppedAt = s.platform.elapsedRealtimeMs()
assertTrue(awaitTrue(5_000) { s.ready() }, "never back:\n" + s.tail())
assertTrue(s.platform.elapsedRealtimeMs() - droppedAt < 3_000, "the first retry comes quickly")
s.submit(4, 4)
assertTrue(awaitTrue(5_000) { s.shownOnBoth(s.expected(4)) }, s.tail())
} finally {
s.core.disconnect()
}
}
}
class G1SessionTest {
@Test
fun pairsOnFirstConnectAndShowsEachLensItsFrame() {