mirror of
https://git.undefined-dev.fr/Blendman974/faceclaw.git
synced 2026-11-19 21:03:09 +00:00
G1 support: Preserve connections after flashing, debug
This commit is contained in:
1 parent
595b462b2e
commit
b353483ac2
38 files changed
+1291
-178
No files matched your search
@@ -41,6 +41,13 @@ with tempfile.TemporaryDirectory() as d:
|
||||
try: m.read_document(p)
|
||||
except (ValueError, m.ET.ParseError): pass
|
||||
else: raise AssertionError(f'accepted invalid config {invalid!r}')
|
||||
pulled = {'schema': 2, 'platform': 'ios', 'settings': {'onboarding.lookalike': True, 'display.timeFormat': '24h'}, 'platformSettings': {
|
||||
'onboarding.complete': True, 'onboarding.previewOnly': False, 'onboarding.glassesFinishedVersion': '0.8.6', 'onboarding.step': 3, 'deviceAddress.left': 'AA'}}
|
||||
reset = json.loads(ios.onboarding_reset_document(json.dumps(pulled)))
|
||||
assert reset == {'schema': 2, 'platform': 'ios', 'settings': {}, 'platformSettings': {
|
||||
'onboarding.complete': False, 'onboarding.glassesFinishedVersion': '', 'onboarding.step': 0}}, reset
|
||||
assert m.check_document(json.dumps(reset)) == (2, 'ios', 3)
|
||||
assert ios.onboarding_reset_document(json.dumps({**pulled, 'platformSettings': {'onboarding.complete': False, 'onboarding.glassesFinishedVersion': '', 'deviceAddress.left': 'AA'}})) is None
|
||||
`], { stdio: 'inherit' });
|
||||
});
|
||||
|
||||
|
||||
@@ -215,8 +215,63 @@ test("a G1 arm on g1v0: the name says all, the serial is in the 0xFFFF record",
|
||||
assert.equal(classifyAdvertisement(g1Raw("G1v0S_L", "")).serial, null);
|
||||
});
|
||||
|
||||
const g1Record = (flags, version, serial = "S110LABC030139") => "ffff" + "02" + flags + version + g1Ascii(serial);
|
||||
|
||||
test("a G1 arm on g1v0 0.5.66+: its name tells pairs apart, its record says what it runs", () => {
|
||||
const ad = classifyAdvertisement(g1Raw("G1CFW_L_EF50E5", g1Record("05", "000542")));
|
||||
assert.equal(ad.role, "left");
|
||||
assert.equal(ad.g1Firmware, "g1v0");
|
||||
assert.equal(ad.g1Version, "0.5.66");
|
||||
assert.equal(ad.serial, "S110LABC030139");
|
||||
assert.equal(classifyAdvertisement(g1Raw("G1CFW_R_CBE689", g1Record("04", "000542"))).role, "right");
|
||||
});
|
||||
|
||||
test("a G1 arm in safe mode says so in its record, not its name", () => {
|
||||
const ad = classifyAdvertisement(g1Raw("G1CFW_L_EF50E5", g1Record("0d", "000542")));
|
||||
assert.equal(ad.g1Firmware, "g1v0-safe");
|
||||
assert.equal(ad.g1Version, "0.5.66");
|
||||
});
|
||||
|
||||
test("a G1 arm whose record hasn't arrived yet still shows, without a version or serial", () => {
|
||||
const ad = classifyAdvertisement(g1Raw("G1CFW_L_EF50E5", ""));
|
||||
assert.equal(ad.g1Firmware, "g1v0");
|
||||
assert.equal(ad.g1Version, undefined);
|
||||
assert.equal(ad.serial, null);
|
||||
});
|
||||
|
||||
test("g1v0 before 0.5.66 and Even's firmware advertise no version", () => {
|
||||
assert.equal(classifyAdvertisement(g1Raw("G1v0_R", "ffff" + "01" + "04" + g1Ascii("S110LABC030139"))).g1Version, undefined);
|
||||
assert.equal(classifyAdvertisement(g1Raw("Even G1_70_L_EF50E5", "02" + g1Ascii("S110LABC030139"))).g1Version, undefined);
|
||||
});
|
||||
|
||||
test("a G1 pair joins on its serial across firmware, so an install in progress stays one pair", () => {
|
||||
const stock = classifyAdvertisement(g1Raw("Even G1_70_L_EF50E5", "02" + g1Ascii("S110LABC030139") + "0000000000"));
|
||||
const custom = classifyAdvertisement(g1Raw("G1CFW_R_CBE689", g1Record("04", "000542")));
|
||||
assert.equal(stock.serial, custom.serial);
|
||||
});
|
||||
|
||||
test("on iOS a G1 arm gets an address from its peripheral identifier, and is found at all", () => {
|
||||
const { identifyIosPeripheral, g1IosAddress } = require("../.test-build/app/g2/ios-peripheral-identity.js");
|
||||
const identifier = "14b99254-0798-d1a8-3eec-b141bdabfae8";
|
||||
assert.equal(g1IosAddress(identifier), "14:B9:92:54:07:98");
|
||||
for (const [name, manufacturerData, firmware] of [
|
||||
["G1CFW_L_EF50E5", g1Record("05", "000542"), "g1v0"],
|
||||
["Even G1_70_L_EF50E5", "02" + g1Ascii("S110LABC030139"), "stock"],
|
||||
["G1v0_L", "ffff" + "01" + "05" + g1Ascii("S110LABC030139"), "g1v0"],
|
||||
]) {
|
||||
const device = identifyIosPeripheral({ identifier, name, manufacturerData, rssi: -50, connectable: true });
|
||||
assert.ok(device, name);
|
||||
assert.equal(device.address, "14:B9:92:54:07:98", name);
|
||||
assert.equal(device.identifier, identifier.toUpperCase(), name);
|
||||
assert.equal(device.role, "left", name);
|
||||
assert.equal(device.g1Firmware, firmware, name);
|
||||
assert.equal(device.serial, "S110LABC030139", name);
|
||||
}
|
||||
assert.equal(identifyIosPeripheral({ identifier: "not-a-uuid", name: "G1CFW_L_EF50E5", manufacturerData: "", rssi: 0, connectable: true }), 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"]) {
|
||||
for (const name of ["G1v0_X", "G1v0", "G1 Tracker", "Even G1", "Pixel G1v0_L", "G1CFW_L", "G1CFW_X_EF50E5", "G1CFW_L_EF50E", "Pixel G1CFW_L_EF50E5"]) {
|
||||
assert.equal(classifyAdvertisement(g1Raw(name, "")), null, name);
|
||||
}
|
||||
});
|
||||
@@ -153,6 +153,24 @@ test('the state of the two arms is that of the arm that needs the most', () => {
|
||||
assert.equal(state({ firmware: 'stock' }, on('0.5.63', { safeMode: true })), 'stock');
|
||||
});
|
||||
|
||||
test('what the advertising alone says about the arms', () => {
|
||||
const arm = (g1Firmware, g1Version) => ({ g1Firmware, g1Version });
|
||||
const state = (left, right) => plan.g1StateFromAdvertising({ left, right }, '0.5.66');
|
||||
assert.deepEqual(state(arm('g1v0', '0.5.66'), arm('g1v0', '0.5.66')), { state: 'current', version: '0.5.66' });
|
||||
assert.deepEqual(state(arm('g1v0', '0.5.67'), arm('g1v0', '0.5.66')), { state: 'current', version: '0.5.66' });
|
||||
assert.deepEqual(state(arm('g1v0', '0.5.66'), arm('g1v0', '0.5.100')), { state: 'current', version: '0.5.66' });
|
||||
assert.deepEqual(state(arm('stock'), arm('g1v0', '0.5.66')), { state: 'stock', version: '' });
|
||||
assert.deepEqual(state(arm('g1v0-safe', '0.5.66'), arm('g1v0', '0.5.66')), { state: 'safe-mode', version: '' });
|
||||
// Firmware before 0.5.66, or a record that hasn't arrived: an arm has to be asked.
|
||||
assert.equal(state(arm('g1v0'), arm('g1v0', '0.5.66')), null);
|
||||
assert.equal(state(arm('g1v0'), arm('g1v0')), null);
|
||||
});
|
||||
|
||||
test('an older arm wins over a newer one', () => {
|
||||
const arm = (g1Version) => ({ g1Firmware: 'g1v0', g1Version });
|
||||
assert.deepEqual(plan.g1StateFromAdvertising({ left: arm('0.5.67'), right: arm('0.5.65') }, '0.5.66'), { state: 'older', version: '0.5.65' });
|
||||
});
|
||||
|
||||
test('the native flow\'s answer is read, and nonsense is no answer', () => {
|
||||
assert.deepEqual(plan.parseG1FlashResult('{"flashed":true,"version":"0.5.64"}'), { flashed: true, version: '0.5.64' });
|
||||
assert.deepEqual(plan.parseG1FlashResult('nonsense'), {});
|
||||
|
||||
@@ -21,6 +21,8 @@ const planes = load('app/graphics/plane.ts', { './image': images });
|
||||
const timings = load('app/native/frame-timings.ts', {});
|
||||
const LAUNCHER_GRAY = 75;
|
||||
|
||||
let glassesType = 'g2';
|
||||
|
||||
function fixture() {
|
||||
const relay = { available: true, starts: 0, client: null, message: undefined };
|
||||
const observers = new Map(), phoneState = { protectedDataAvailable: true };
|
||||
@@ -105,7 +107,7 @@ function fixture() {
|
||||
const noop = () => () => {};
|
||||
class FaceclawCommunicatorBridge extends Display {
|
||||
phase = 'disconnected'; listeners = {};
|
||||
constructor() { super(); bridge = this; }
|
||||
constructor(addresses) { super(); bridge = this; this.addresses = addresses; }
|
||||
on(kind, fn) { this.listeners[kind] = fn; return () => { if (this.listeners[kind] === fn) delete this.listeners[kind]; }; }
|
||||
onStateChange(fn) { return this.on('state', fn); } onRingEvent(fn) { return this.on('ring', fn); }
|
||||
onWearState(fn) { return this.on('wear', fn); } onBatteryState(fn) { return this.on('battery', fn); } onCaseState(fn) { return this.on('case', fn); } onFirmwareInfo(fn) { return this.on('firmware', fn); }
|
||||
@@ -176,7 +178,7 @@ function fixture() {
|
||||
'../apps/all-apps': { ALL_APPS: [{ appId: 'glanceboard', glanceboard: provider }] },
|
||||
'../apps/onboarding/onboarding-progress': { claimGlassesOnboardingAutoLaunch: () => false },
|
||||
'../ui/shell/worker-window': {}, '../ui/shell/in-process-window': {},
|
||||
'../ui/dashboard-settings': { brightnessSetting: { get: () => 'auto' }, brightnessSettingToLevel: () => null, getBrightnessPreferences: () => ({ auto: true, level: 50, minimum: 2, maximum: 100, curve: '0:0,1000:100', fadeMs: 280 }), lockScreenEnabledSetting: { get: () => settings.lock }, ringConnectionModeSetting: { get: () => 'glasses' }, onAnySettingChanged: fn => { settingsChanged = fn; return () => {}; }, previewColorSetting: { get: () => 'white' } },
|
||||
'../ui/dashboard-settings': { glassesTypeSetting: { get: () => glassesType }, brightnessSetting: { get: () => 'auto' }, brightnessSettingToLevel: () => null, getBrightnessPreferences: () => ({ auto: true, level: 50, minimum: 2, maximum: 100, curve: '0:0,1000:100', fadeMs: 280 }), lockScreenEnabledSetting: { get: () => settings.lock }, ringConnectionModeSetting: { get: () => 'glasses' }, onAnySettingChanged: fn => { settingsChanged = fn; return () => {}; }, previewColorSetting: { get: () => 'white' } },
|
||||
'../native/phone-battery': { readPhoneBatteryState: () => ({ battery: 80, charging: false }) },
|
||||
'../apps/ios-availability': { iosAppUnavailableReason: () => null },
|
||||
'../graphics/glyph-wire': { prepareFrameDraws: () => null },
|
||||
@@ -222,6 +224,17 @@ function fixture() {
|
||||
get shellOptions() { return shellOptions; }, registered, inProcessApps,
|
||||
get bridge() { return bridge; }, connect, wear: wearing => bridge.emitWear(wearing), settingsChanged: () => settingsChanged(), sent, previews, received, boardStats, hardware, phone, advance, render };
|
||||
}
|
||||
test('the session is told which glasses it drives, as a G2 session gets nowhere on a G1', async () => {
|
||||
for (const type of ['g1', 'g2']) {
|
||||
glassesType = type;
|
||||
const f = fixture();
|
||||
await f.connect();
|
||||
assert.equal(f.bridge.addresses.glassesType, type);
|
||||
assert.ok('right' in f.bridge.addresses && 'left' in f.bridge.addresses, 'the arms still come with it');
|
||||
}
|
||||
glassesType = 'g2';
|
||||
});
|
||||
|
||||
test('a link that comes back asks for the notification relay again; a G1 without one is told to update', async () => {
|
||||
const f = fixture();
|
||||
await f.connect();
|
||||
|
||||
@@ -57,6 +57,16 @@ function alsRecord(alsValue) {
|
||||
return body;
|
||||
}
|
||||
|
||||
test('only a G1 session runs the G1 connect path', () => {
|
||||
for (const [glassesType, expected] of [['g1', 1], ['g2', 0], [undefined, 0]]) {
|
||||
const { session, FaceclawCommunicatorBridge } = harness();
|
||||
let used = 0;
|
||||
session.useG1 = () => { used++; };
|
||||
new FaceclawCommunicatorBridge({ right: 'r', left: 'l', glassesType });
|
||||
assert.equal(used, expected, String(glassesType));
|
||||
}
|
||||
});
|
||||
|
||||
test('the bridge is the active session from start() until close()', async () => {
|
||||
const h = harness();
|
||||
const bridge = new h.FaceclawCommunicatorBridge({ right: 'r', left: 'l' });
|
||||
|
||||
@@ -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() {
|
||||
|
||||
@@ -332,6 +332,28 @@ test("G1 arms on g1v0 join on the frame serial and can be selected", () => {
|
||||
assert.match(row.armsSummary, /case/);
|
||||
});
|
||||
|
||||
test("G1 arms on current firmware join on the serial, with the arm's own name", () => {
|
||||
const record = (flags) => "ffff" + "02" + flags + "000542" + ascii(G1_SERIAL);
|
||||
const aggregator = new DiscoveryAggregator();
|
||||
aggregator.ingest(g1Arm("G1CFW_L_EF50E5", "C0:66:16:EF:50:E5", record("05")));
|
||||
aggregator.ingest(g1Arm("G1CFW_R_CBE689", "E4:46:BA:CB:E6:89", record("04")));
|
||||
const [pair] = aggregator.pairs();
|
||||
assert.equal(pair.g1Firmware, "g1v0");
|
||||
assert.equal(pair.completeness, "complete");
|
||||
assert.equal(pair.left.g1Version, "0.5.66");
|
||||
assert.equal(glassesRow(pair).canSelect, true);
|
||||
});
|
||||
|
||||
test("a G1 pair halfway through an install is one pair, shown as needing it", () => {
|
||||
const aggregator = new DiscoveryAggregator();
|
||||
aggregator.ingest(g1Arm("G1CFW_L_EF50E5", "C0:66:16:EF:50:E5", "ffff" + "02" + "05" + "000542" + ascii(G1_SERIAL)));
|
||||
aggregator.ingest(g1Arm("Even G1_70_R_CBE689", "E4:46:BA:CB:E6:89", "01" + ascii(G1_SERIAL)));
|
||||
const pairs = aggregator.pairs();
|
||||
assert.equal(pairs.length, 1);
|
||||
assert.equal(pairs[0].g1Firmware, "stock");
|
||||
assert.equal(glassesRow(pairs[0]).canSelect, true);
|
||||
});
|
||||
|
||||
test("G1 arms on Even's firmware can be selected, to install on", () => {
|
||||
const aggregator = new DiscoveryAggregator();
|
||||
aggregator.ingest(g1Arm("Even G1_70_L_EF50E5", "C0:66:16:EF:50:E5", "02" + ascii(G1_SERIAL)));
|
||||
|
||||
Reference in new issue
Block a user