Files
faceclaw/tests/keyboard-bridge.test.cjs
T
James Babcock fd3c26333f Add bluetooth keyboard support
G2 only: You can pair the glasses with a bluetooth keyboard. It will
relay key events, and you can use it to type in some apps and to
navigate the UI.
2026-11-15 01:54:54 -08:00

510 lines
27 KiB
JavaScript

const test = require('node:test')
const assert = require('node:assert/strict')
const { HidKeys, parseReportMap, reportKeys } = require('../.test-build/app/g2/keyboard/hid.js')
const {
KeyboardRecords, keyboardControl, le16, u16, parseKeyboardAdvert, mergeKeyboardAdverts,
parseKeyboardAddress, formatKeyboardAddress,
} = require('../.test-build/app/g2/keyboard/protocol.js')
const { KeyboardClient, KeyboardClientError, attributeUuid } = require('../.test-build/app/g2/keyboard/client.js')
const { KeyboardBridge } = require('../.test-build/app/g2/keyboard/bridge.js')
// The HID vectors and the simulated HOGP keyboard follow g2flash demos/keyboard.test.ts.
const boot = Uint8Array.from([
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,
])
const numbered = Uint8Array.from([
...boot.slice(0, 6), 0x85,1,...boot.slice(6, -1),
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,
])
function frame(kind, seq, epoch, request, code, handle, data, offset = 0, total = data.length) {
const p = new Uint8Array(24 + data.length), v = new DataView(p.buffer)
p.set([75,66,1,kind]); v.setUint32(4,seq,true); v.setUint16(8,epoch,true); v.setUint16(10,request,true)
v.setUint16(12,code,true); v.setUint16(14,handle,true); v.setUint16(16,total,true); v.setUint16(18,offset,true)
v.setUint32(20,1234,true); p.set(data,24); return p
}
const flush = () => new Promise(resolve => setImmediate(resolve))
async function settle(rounds = 20) { for (let i = 0; i < rounds; i++) await flush() }
test('boot array, modifiers, release, repeats and rollover', () => {
const r = parseReportMap(boot).get(0), keys = new HidKeys()
assert.deepEqual(keys.update(12,r,Uint8Array.of(2,0,4,0,0,0,0,0)), [
{page:7,usage:0xe1,down:true},{page:7,usage:4,down:true},
])
assert.deepEqual(keys.update(12,r,Uint8Array.of(2,0,4,0,0,0,0,0)), [])
assert.throws(() => keys.update(12,r,Uint8Array.of(0,0,1,1,1,1,1,1)), /rollover/)
assert.deepEqual(keys.reset().map(k => k.down), [false,false])
assert.throws(() => reportKeys(r,Uint8Array.of(0)), /length/)
})
test('HOGP report IDs are out of band, with consumer keys', () => {
const maps = parseReportMap(numbered)
assert.deepEqual(reportKeys(maps.get(1),Uint8Array.of(0,0,5,0,0,0,0,0)), [{page:7,usage:5}])
assert.deepEqual(reportKeys(maps.get(2),Uint8Array.of(5)), [{page:12,usage:0xe9},{page:12,usage:0xe2}])
assert.throws(() => reportKeys(maps.get(2),Uint8Array.of(2,5)), /length/)
})
test('NKRO bitmap with non-byte-aligned fields and report union', () => {
const map = Uint8Array.of(5,7,0x19,4,0x29,19,0x15,0,0x25,1,0x75,1,0x95,16,0x81,2)
const r = parseReportMap(map).get(0), keys = new HidKeys()
assert.deepEqual(reportKeys(r,Uint8Array.of(0x81,0x80)), [{page:7,usage:4},{page:7,usage:11},{page:7,usage:19}])
assert.equal(keys.update(10,r,Uint8Array.of(1,0)).length, 1)
assert.deepEqual(keys.update(11,r,Uint8Array.of(1,0)), [])
assert.deepEqual(keys.update(10,r,Uint8Array.of(0,0)), [])
assert.deepEqual(keys.update(11,r,Uint8Array.of(0,0)), [{page:7,usage:4,down:false}])
})
test('array values index usages relative to logical minimum', () => {
const r = parseReportMap(Uint8Array.of(5,7,0x19,4,0x29,6,0x15,1,0x25,3,0x75,8,0x95,1,0x81,0)).get(0)
assert.deepEqual(reportKeys(r,Uint8Array.of(2)), [{page:7,usage:5}])
assert.deepEqual(reportKeys(r,Uint8Array.of(0)), [])
})
test('descriptor resource bounds and malformed items', () => {
for (const data of [new Uint8Array(),new Uint8Array(513),Uint8Array.of(0xfe),Uint8Array.of(0x75),
Uint8Array.of(0xb4),Uint8Array.of(0xc0),Uint8Array.of(0x85,0),Uint8Array.of(0x75,33,0x95,1,0x81,2),
Uint8Array.of(0x75,32,0x96,0,2,0x81,2),Uint8Array.of(0xa1,1)]) assert.throws(() => parseReportMap(data))
// Deterministic malformed corpus; parsing must be bounded and never hang.
let seed = 1
for (let i = 0; i < 1000; i++) {
const data = Uint8Array.from({length:i%128+1}, () => { seed=(Math.imul(seed,1664525)+1013904223)>>>0; return seed>>>24 })
try { parseReportMap(data) } catch (e) { assert.ok(e instanceof Error) }
}
})
test('control records, UUIDs and addresses', () => {
assert.deepEqual([...keyboardControl(4,0x1234,0x5678,[1,2,3,4,5,6,7])], [75,66,1,4,0x34,0x12,0x78,0x56,1,2,3,4,5,6,7])
assert.throws(() => keyboardControl(13,1,1))
assert.throws(() => keyboardControl(11,1,1,new Array(73).fill(0)))
assert.equal(attributeUuid(Uint8Array.of(0xfb,0x34,0x9b,0x5f,0x80,0,0,0x80,0,0x10,0,0,0x12,0x18,0,0)), 0x1812)
const address = parseKeyboardAddress('AA:bb:cc:dd:ee:01')
assert.deepEqual([...address], [1,0xee,0xdd,0xcc,0xbb,0xaa])
assert.equal(formatKeyboardAddress(address), 'aa:bb:cc:dd:ee:01')
assert.equal(parseKeyboardAddress('aa:bb:cc:dd:ee'), null)
assert.equal(parseKeyboardAddress('aa:bb:cc:dd:ee:gg'), null)
})
test('fragments, duplicate delivery, gaps, epochs and sequence wrap', () => {
let gaps = 0; const stream = new KeyboardRecords(() => gaps++)
const data = Uint8Array.from({length:200}, (_,i) => i)
assert.equal(stream.push(frame(3,0xffffffff,1,0,13,33,data.slice(0,96),0,200)), undefined)
assert.equal(stream.push(frame(3,0xffffffff,1,0,13,33,data.slice(96,192),96,200)), undefined)
assert.deepEqual(stream.push(frame(3,0xffffffff,1,0,13,33,data.slice(192),192,200)).data, data)
const status = frame(1,0,1,0,0,0,new Uint8Array(10))
assert.equal(stream.push(status).sequence, 0)
assert.equal(stream.push(status), undefined); assert.equal(gaps, 1)
stream.push(frame(1,2,1,0,0,0,new Uint8Array(10))); assert.equal(gaps, 2)
assert.equal(stream.push(status), undefined); assert.equal(gaps, 2)
stream.push(frame(1,3,2,0,0,0,new Uint8Array(10))); assert.equal(gaps, 3)
})
test('missing or mismatched fragments never emit partial input', () => {
let gaps = 0; const stream = new KeyboardRecords(() => gaps++)
stream.push(frame(3,1,1,0,13,10,new Uint8Array(96),0,100))
assert.equal(stream.push(frame(3,1,1,0,13,11,new Uint8Array(4),96,100)), undefined)
assert.equal(gaps, 2)
assert.equal(stream.push(frame(3,1,1,0,13,10,new Uint8Array(4),96,100)), undefined)
assert.equal(stream.push(new Uint8Array(513)), undefined)
// Another protocol version is not ours to decode.
const future = frame(1,5,1,0,0,0,new Uint8Array(10)); future[2] = 2
assert.equal(stream.push(future), undefined)
})
test('adverts: name from the scan response, HID from the service list or the appearance', () => {
const body = (ad, rssi = -60) => Uint8Array.from([1, 6,5,4,3,2,1, rssi & 255, 0, ad.length, ...ad])
const services = parseKeyboardAdvert(body([2,1,6, 3,3,0x12,0x18]))
assert.deepEqual(services, { addressType: 1, address: '01:02:03:04:05:06', rssi: -60, name: '', hid: true })
const named = parseKeyboardAdvert(body([5,9,0x4b,0x33,0x38,0x30], -48))
assert.equal(named.name, 'K380'); assert.equal(named.hid, false)
assert.deepEqual(mergeKeyboardAdverts(services, named), { ...services, name: 'K380', rssi: -48 })
assert.equal(parseKeyboardAdvert(body([3,0x19,0xc1,0x03])).hid, true)
assert.equal(parseKeyboardAdvert(body([3,0x19,0x41,0x03])).hid, false)
assert.equal(parseKeyboardAdvert(Uint8Array.of(1,2,3)), null)
// A truncated AD structure ends the parse without reading past the body.
assert.equal(parseKeyboardAdvert(body([9,9,0x41])).name, '')
})
/**
* The firmware bridge and a HOGP keyboard behind it, as far as the phone can
* tell: answers control records with the records the real one sends.
*/
function fakeGlasses(deliver) {
const attrs = new Map()
const add = (h, uuid, bytes) => attrs.set(h, { uuid, value: Uint8Array.from(bytes) })
const mockMap = Uint8Array.from([...numbered.slice(0,-1),0x85,3,0x05,6,0x09,0x20,0x15,0,0x25,100,0x75,8,0x95,1,0x81,2,0xc0])
add(1,0x2800,[1,0x18]); add(2,0x2803,[0x20,3,0,5,0x2a]); add(3,0x2a05,[]); add(4,0x2902,[0,0])
add(20,0x2800,[0x12,0x18])
add(21,0x2803,[2,22,0,0x4b,0x2a]); add(22,0x2a4b,mockMap); add(23,0x2907,[0x19,0x2a])
add(24,0x2803,[6,25,0,0x4e,0x2a]); add(25,0x2a4e,[1])
add(26,0x2803,[0x12,27,0,0x4d,0x2a]); add(27,0x2a4d,[]); add(28,0x2902,[0,0]); add(29,0x2908,[1,1])
add(30,0x2803,[0x12,31,0,0x4d,0x2a]); add(31,0x2a4d,[]); add(32,0x2902,[0,0]); add(33,0x2908,[2,1])
add(40,0x2800,[0x0f,0x18]); add(41,0x2803,[0x12,42,0,0x19,0x2a]); add(42,0x2a19,[100]); add(43,0x2902,[0,0]); add(44,0x2908,[3,1])
const g = {
seq: 0, epoch: 0, enabled: 0, conn: 0, connected: 0, encrypted: 0, scanning: 0,
ops: [], writes: [], watches: [], adverts: [], pins: [], compares: [],
reachable: true, bonded: false, pairing: 'just-works', up: true,
// The keyboard's attribute table, and how its stack answers a direct read
// of a characteristic declaration: 'full', 'short' (the properties byte
// alone) or 'refused'.
attrs, add, declarations: 'full',
}
g.emit = (kind, request, code, handle, data = []) =>
deliver(frame(kind, ++g.seq, g.epoch, request, code, handle, Uint8Array.from(data)))
g.status = (request = 0, code = 0) =>
g.emit(1, request, code, 0, [g.enabled, g.conn, g.connected, g.encrypted, g.scanning, 0, 0,0,0,0])
g.dm = (event, status = 0, data = []) => g.emit(4, 0, event | (status << 8), 0, data)
g.close = () => { if (!g.conn) return; g.conn = g.connected = g.encrypted = 0; g.watches = []; g.dm(0x28); g.status() }
g.encrypt = () => { g.encrypted = 1; g.dm(0x2c); g.status() }
g.input = (handle, bytes) => g.emit(3, 0, 13, handle, bytes)
g.send = (record) => {
if (!g.up) return false
const op = record[3], req = u16(record,4), epoch = u16(record,6), h = record.length >= 10 ? u16(record,8) : 0
g.ops.push(op)
if (op !== 0 && op !== 1 && epoch !== g.epoch) { g.status(req, 4); return true }
if (op === 0) g.status(req)
else if (op === 1) { g.enabled = 1; g.status(req) }
else if (op === 2) { g.enabled = 0; g.status(req); g.close() }
else if (op === 3) {
if (g.conn) { g.status(req, 3); return true }
g.scanning = 1; g.status(req)
for (const advert of g.adverts) g.emit(5, 0, 0, 0, advert)
g.scanning = 0; g.status()
} else if (op === 4) {
if (g.conn) { g.status(req, 3); return true }
g.epoch = (g.epoch + 1) & 0xffff; g.conn = 3; g.status(req)
if (!g.reachable) return true
g.connected = 1; g.dm(0x27); g.status()
if (g.bonded) g.encrypt()
} else if (op === 5) { g.status(req); g.close() }
else if (op === 6) {
if (!g.connected) { g.status(req, 6); return true }
g.status(req)
if (g.pairing === 'just-works') { g.dm(0x2a); g.encrypt() }
else if (g.pairing === 'display') g.dm(0x2e, 0, [0, 1])
else if (g.pairing === 'entry') g.dm(0x2e, 0, [0, 0])
else if (g.pairing === 'compare') g.dm(0x35, 0, [0x40, 0xe2, 0x01, 0])
else if (g.pairing === 'fail') { g.dm(0x2b, 5); g.close() }
} else if (op === 7) {
g.pins.push(record[8] | (record[9] << 8) | (record[10] << 16)); g.status(req); g.dm(0x2a); g.encrypt()
} else if (op === 8) {
g.compares.push(record[8]); g.status(req)
if (record[8]) { g.dm(0x2a); g.encrypt() } else { g.dm(0x2b, 4); g.close() }
} else if (op === 9) {
const batch = [...attrs].filter(([handle]) => handle >= h).slice(0,4)
g.emit(2, req, batch.length ? 2 : (10<<8)|2, h, batch.length ? [1, ...batch.flatMap(([handle,a]) => [...le16(handle), ...le16(a.uuid)])] : [])
} else if (op === 10) {
const attr = attrs.get(h), offset = u16(record,10)
if (attr.uuid === 0x2803 && g.declarations === 'refused') { g.emit(2, req, (2<<8)|5, h); return true }
const data = attr.uuid === 0x2803 && g.declarations === 'short' ? attr.value.slice(0,1) : attr.value
g.emit(2, req, offset >= data.length ? (7<<8)|6 : offset ? 6 : 5, h, data.slice(offset, offset+20))
} else if (op === 11) { g.writes.push(h); g.emit(2, req, record[10] ? 10 : 9, h) }
else if (op === 12) { g.watches = Array.from({length:record[8]}, (_,i) => u16(record,9+2*i)); g.status(req) }
else throw new Error(`Unexpected op ${op}`)
return true
}
return g
}
test('client: HOGP discovery, long Report Map, subscriptions, typing and loss recovery', async () => {
const events = []
let client
const g = fakeGlasses(payload => client.accept(payload))
client = new KeyboardClient(g.send, { keys: e => events.push(...e) })
await client.enable(); await client.connect(1, new Uint8Array(6)); const config = await client.configure()
// The battery level (an external report) is found, but it can't carry a
// key, so it isn't subscribed: only the two key reports and Service Changed.
assert.deepEqual(g.watches, [27,31,3]); assert.deepEqual(g.writes, [25,4,28,32])
assert.deepEqual(config.reports.map(r => r.id), [1,2,3]); assert.deepEqual(config.watched, [27,31])
assert.deepEqual(config.reports.map(r => r.properties), [0x12,0x12,0x12])
g.input(27, [0,0,4,0,0,0,0,0]); g.input(31, [1])
assert.deepEqual(events.map(e => [e.usage,e.down]), [[4,true],[0xe9,true]])
g.seq++ // a release lost in the firmware queue or on the way to the phone
g.status()
assert.deepEqual(events.slice(-2).map(e => e.down), [false,false])
// Another client on the same connection can take over with the mapping.
const restored = new KeyboardClient(() => true, { keys: e => events.push(...e) })
restored.restore(config); restored.accept(frame(3, g.seq + 1, g.epoch, 0, 13, 27, Uint8Array.of(0,0,5,0,0,0,0,0)))
assert.deepEqual([events.at(-1).usage, events.at(-1).down], [5, true]); restored.lostPhoneLink()
assert.deepEqual([events.at(-1).usage, events.at(-1).down], [5, false])
// Service Changed voids the handles: no more keys until configure() runs again.
g.emit(3, 0, 14, 3, [1,0,255,255])
const count = events.length; g.input(27, [0,0,6,0,0,0,0,0])
assert.equal(events.length, count)
client.close(); restored.close()
})
// A pointer's report, as a keyboard with a built-in trackpad adds: buttons and relative X/Y.
const mouseCollection = [0x05,1,0x09,2,0xa1,1,0x85,4,0x09,1,0xa1,0,0x05,9,0x19,1,0x29,3,0x15,0,0x25,1,0x75,1,0x95,3,0x81,2,
0x75,5,0x95,1,0x81,1,0x05,1,0x09,0x30,0x09,0x31,0x15,0x81,0x25,0x7f,0x75,8,0x95,2,0x81,6,0xc0,0xc0]
/** Turn the fake into a keyboard with a trackpad, whose battery level has no Report Reference. */
function makeCombo(g) {
g.add(22, 0x2a4b, [...g.attrs.get(22).value, ...mouseCollection])
g.add(34,0x2803,[0x12,35,0,0x4d,0x2a]); g.add(35,0x2a4d,[]); g.add(36,0x2902,[0,0]); g.add(37,0x2908,[4,1])
g.attrs.delete(44)
const sorted = [...g.attrs].sort((a, b) => a[0] - b[0])
g.attrs.clear(); for (const [handle, attr] of sorted) g.attrs.set(handle, attr)
}
for (const declarations of ['short', 'refused']) {
test(`client: a keyboard with a trackpad whose stack answers declaration reads ${declarations} still types`, async () => {
const events = [], logs = []
let client
const g = fakeGlasses(payload => client.accept(payload))
makeCombo(g); g.declarations = declarations
client = new KeyboardClient(g.send, { keys: e => events.push(...e), log: line => logs.push(line) })
await client.enable(); await client.connect(1, new Uint8Array(6)); const config = await client.configure()
// Keys and media keys are subscribed; the pointer and the battery are not.
assert.deepEqual(config.watched, [27,31]); assert.deepEqual(g.watches, [27,31,3]); assert.deepEqual(g.writes, [25,4,28,32])
assert.deepEqual(config.reports.map(r => [r.handle, r.id]), [[27,1],[31,2],[35,4]])
assert.deepEqual(config.reports.map(r => r.properties), declarations === 'short' ? [0x12,0x12,0x12] : [undefined,undefined,undefined])
g.input(27, [0,0,4,0,0,0,0,0])
assert.deepEqual(events.map(e => [e.usage,e.down]), [[4,true]])
// What was skipped, and why, is in the log; so is the table it came from.
assert.ok(logs.some(line => /^gatt 1=2800 2=2803 /.test(line)), logs.join('\n'))
assert.ok(logs.some(line => /report 42 skipped: no Report Reference/.test(line)), logs.join('\n'))
assert.ok(logs.some(line => /report 35 \(id 4\) carries no keys/.test(line)), logs.join('\n'))
assert.ok(logs.some(line => line.startsWith('report map 22: 0501')))
client.close()
})
}
test('client: one unusable report is skipped, and a device with no key report is refused with the reasons', async () => {
let client
const g = fakeGlasses(payload => client.accept(payload))
client = new KeyboardClient(g.send)
g.add(29, 0x2908, [1]) // a Report Reference of the wrong length
await client.enable(); await client.connect(1, new Uint8Array(6))
assert.deepEqual((await client.configure()).watched, [31])
g.add(33, 0x2908, [9,1]) // and one naming a report the map doesn't have
await assert.rejects(client.configure(), /No usable keyboard input report \(27: Report Reference 29 is 01; 31: input report id 9 is not in the Report Map\)/)
assert.equal(client.configuration, undefined)
// Not a HID device at all.
g.add(20, 0x2800, [0x0f,0x18])
await assert.rejects(client.configure(), /no HID service/)
client.close()
})
test('client: the link dropping during setup ends it, rather than being skipped over', async () => {
let client
const g = fakeGlasses(payload => client.accept(payload))
client = new KeyboardClient(g.send)
await client.enable(); await client.connect(1, new Uint8Array(6))
const send = g.send
g.send = (record) => {
// The keyboard goes away as the first Report Reference is read.
if (record[3] === 10 && u16(record, 8) === 29) { g.close(); return true }
return send(record)
}
client = new KeyboardClient(record => g.send(record))
await client.query()
await assert.rejects(client.configure(), /stream gap|link changed/)
client.close()
})
test('client: an unreachable keyboard fails the connect when the glasses give up, not by timeout', async () => {
let client
const g = fakeGlasses(payload => client.accept(payload)); g.reachable = false
client = new KeyboardClient(g.send)
await client.enable()
const pending = client.connect(1, new Uint8Array(6))
await settle(); g.close()
await assert.rejects(pending, /didn't answer/)
client.close()
})
test('client: firmware errors carry their code, and a dead link rejects at once', async () => {
let client
const g = fakeGlasses(payload => client.accept(payload))
client = new KeyboardClient(g.send)
await client.enable(); await client.connect(1, new Uint8Array(6))
await assert.rejects(client.command(4, [1,0,0,0,0,0,0]), e => e instanceof KeyboardClientError && e.code === 3)
g.up = false
await assert.rejects(client.query(), /aren't ready/)
client.close()
await assert.rejects(client.query(), /closed/)
})
function bridgeSetup(saved = null) {
const host = { keys: [], gone: 0, changes: 0, logs: [], prompts: [], saved, reconnect: true }
let bridge
const g = fakeGlasses(payload => bridge.accept(payload))
bridge = new KeyboardBridge({
send: g.send,
loadSaved: () => host.saved,
storeSaved: value => { host.saved = value },
onKeys: events => host.keys.push(...events),
onKeyboardGone: () => { host.gone++ },
onChanged: () => {
host.changes++
const pairing = bridge.snapshot().pairing
if (pairing && host.prompts.at(-1) !== pairing) host.prompts.push(pairing)
},
log: line => host.logs.push(line),
randomPasskey: () => 123456,
shouldReconnect: () => host.reconnect,
})
return { bridge, g, host }
}
const K380 = { address: 'aa:bb:cc:dd:ee:01', addressType: 1, name: 'K380' }
const advertOf = (lastByte, ad) => [1, lastByte,0xee,0xdd,0xcc,0xbb,0xaa, 0xc4, 0, ad.length, ...ad]
test('bridge: scan, pick, pair by typing the displayed passkey, type, forget', async () => {
const { bridge, g, host } = bridgeSetup()
assert.equal(bridge.snapshot().state, 'unavailable')
await assert.rejects(bridge.scan(), /Connect to G2 glasses/)
bridge.linkReady()
g.adverts = [
advertOf(2, [2,1,6]), // some other device
advertOf(1, [2,1,6, 3,3,0x12,0x18]), // the keyboard's advertisement
advertOf(1, [5,9,0x4b,0x33,0x38,0x30]), // and its scan response, with the name
]
const found = await bridge.scan()
assert.deepEqual(found.map(a => [a.address, a.name, a.hid]), [[K380.address,'K380',true],['aa:bb:cc:dd:ee:02','',false]])
assert.equal(bridge.snapshot().state, 'idle')
g.pairing = 'display'
await bridge.connect(K380)
// The passkey went up for the user to type, and to the glasses as the answer.
assert.deepEqual(host.prompts, [{ kind: 'display', pin: 123456 }])
assert.deepEqual(g.pins, [123456])
assert.equal(bridge.snapshot().state, 'connected'); assert.equal(bridge.snapshot().pairing, null)
assert.deepEqual(host.saved, K380); assert.ok(bridge.isConnected())
g.input(27, [2,0,4,0,0,0,0,0])
assert.deepEqual(host.keys.map(k => [k.usage, k.down]), [[0xe1,true],[4,true]])
await bridge.forget()
assert.equal(host.saved, null); assert.equal(host.gone, 1); assert.equal(g.conn, 0); assert.equal(g.enabled, 0)
assert.equal(bridge.snapshot().state, 'idle')
bridge.linkLost()
})
test('bridge: numeric comparison waits for the answer; declining fails the pairing', async () => {
const { bridge, g } = bridgeSetup()
bridge.linkReady(); g.pairing = 'compare'
const pending = bridge.connect(K380)
await settle()
assert.deepEqual(bridge.snapshot().pairing, { kind: 'compare', value: 123456 })
assert.equal(bridge.snapshot().state, 'pairing')
await bridge.answerCompare(false)
await assert.rejects(pending, /Pairing with the keyboard failed/)
assert.equal(bridge.snapshot().state, 'error'); assert.deepEqual(g.compares, [0])
await assert.rejects(bridge.answerCompare(true), /No pairing comparison/)
bridge.linkLost()
})
test('bridge: a keyboard that shows a code is paired with the code typed in', async () => {
const { bridge, g } = bridgeSetup()
bridge.linkReady(); g.pairing = 'entry'
const pending = bridge.connect(K380)
await settle()
assert.deepEqual(bridge.snapshot().pairing, { kind: 'entry' })
await bridge.answerPasskey(42)
await pending
assert.deepEqual(g.pins, [42]); assert.equal(bridge.snapshot().state, 'connected')
bridge.linkLost()
})
test('bridge: the remembered keyboard comes back with the link, and again after it drops', async (t) => {
t.mock.timers.enable({ apis: ['setTimeout'] })
const { bridge, g, host } = bridgeSetup(K380)
g.bonded = true
bridge.linkReady()
assert.equal(bridge.snapshot().waiting, true)
t.mock.timers.tick(1000); await settle()
assert.equal(bridge.snapshot().state, 'connected'); assert.equal(g.connected, 1)
// The keyboard goes to sleep: held keys are dropped, and it is looked for again.
g.input(27, [0,0,4,0,0,0,0,0])
g.close(); await settle()
assert.equal(host.gone, 1); assert.equal(bridge.snapshot().state, 'idle'); assert.equal(bridge.snapshot().waiting, true)
g.reachable = false
t.mock.timers.tick(2000); await settle()
assert.equal(bridge.snapshot().state, 'connecting')
g.close(); await settle()
// Asleep is the ordinary case, not an error in front of the user.
assert.equal(bridge.snapshot().state, 'idle'); assert.equal(bridge.snapshot().error, '')
g.reachable = true
t.mock.timers.tick(2000); await settle()
assert.equal(bridge.snapshot().state, 'connected')
// Disconnecting by hand stops the retries until asked again.
await bridge.disconnect()
assert.equal(bridge.snapshot().waiting, false); assert.equal(g.enabled, 0)
t.mock.timers.tick(60000); await settle()
assert.equal(bridge.snapshot().state, 'idle'); assert.equal(g.connected, 0)
bridge.linkLost()
})
test('bridge: the glasses kept the keyboard through a phone-side drop, so only discovery is redone', async (t) => {
t.mock.timers.enable({ apis: ['setTimeout'] })
const { bridge, g, host } = bridgeSetup(K380)
g.bonded = true
bridge.linkReady(); t.mock.timers.tick(1000); await settle()
assert.equal(bridge.snapshot().state, 'connected')
const epoch = g.epoch
bridge.linkLost()
assert.equal(bridge.snapshot().state, 'unavailable'); assert.equal(host.gone, 1)
g.ops.length = 0
bridge.linkReady(); t.mock.timers.tick(1000); await settle()
assert.equal(bridge.snapshot().state, 'connected')
assert.equal(g.epoch, epoch, 'no reconnect of the keyboard itself')
assert.ok(!g.ops.includes(4) && !g.ops.includes(2))
g.input(27, [0,0,7,0,0,0,0,0])
assert.deepEqual([host.keys.at(-1).usage, host.keys.at(-1).down], [7, true])
bridge.linkLost()
})
test('bridge: a scan started by hand takes over from an attempt in flight, and nothing retries while charging', async (t) => {
t.mock.timers.enable({ apis: ['setTimeout'] })
const { bridge, g, host } = bridgeSetup(K380)
g.reachable = false
bridge.linkReady(); t.mock.timers.tick(1000); await settle()
assert.equal(bridge.snapshot().state, 'connecting'); assert.equal(g.conn, 3)
g.adverts = [advertOf(1, [3,3,0x12,0x18])]
const scan = bridge.scan()
await settle(); t.mock.timers.tick(200); await settle()
assert.equal((await scan).length, 1)
assert.equal(g.conn, 0, 'the pending connection was released first')
assert.equal(bridge.snapshot().state, 'idle'); assert.equal(bridge.snapshot().busy, false)
// Reconnecting waits for the glasses to be in use.
host.reconnect = false
bridge.linkLost(); bridge.linkReady(); g.ops.length = 0
t.mock.timers.tick(1000); await settle()
t.mock.timers.tick(120000); await settle()
assert.deepEqual(g.ops, [])
// A bridge left enabled by an attempt is switched off for the wait, so the
// firmware's timer and its once-a-second status stop.
host.reconnect = true; g.reachable = false
bridge.retryNow(); t.mock.timers.tick(0); await settle()
assert.equal(g.enabled, 1); assert.equal(bridge.snapshot().state, 'connecting')
g.close(); await settle()
host.reconnect = false
t.mock.timers.tick(2000); await settle()
assert.equal(g.enabled, 0)
g.ops.length = 0
t.mock.timers.tick(120000); await settle()
assert.deepEqual(g.ops, [])
// The display woke: no waiting out the rest of the backoff.
host.reconnect = true; g.reachable = true; g.bonded = true
bridge.retryNow()
t.mock.timers.tick(0); await settle()
assert.equal(bridge.snapshot().state, 'connected')
// With the keyboard in use, or none remembered, there is nothing to retry.
g.ops.length = 0
bridge.retryNow(); t.mock.timers.tick(0); await settle()
assert.deepEqual(g.ops, [])
bridge.linkLost()
})
test('bridge: leaving on purpose tells the glasses to let the keyboard go', async (t) => {
t.mock.timers.enable({ apis: ['setTimeout'] })
const { bridge, g } = bridgeSetup(K380)
g.bonded = true
bridge.linkReady(); t.mock.timers.tick(1000); await settle()
assert.equal(g.connected, 1)
bridge.linkClosing(); bridge.linkLost()
assert.equal(g.enabled, 0); assert.equal(g.conn, 0)
// With no keyboard in use there is nothing to say.
const idle = bridgeSetup()
idle.bridge.linkReady(); idle.bridge.linkClosing(); idle.bridge.linkLost()
assert.deepEqual(idle.g.ops, [])
})
test('bridge: a keyboard forgotten while the glasses were away is released when they return', async (t) => {
t.mock.timers.enable({ apis: ['setTimeout'] })
const { bridge, g, host } = bridgeSetup(K380)
g.bonded = true
bridge.linkReady(); t.mock.timers.tick(1000); await settle()
assert.equal(g.connected, 1)
bridge.linkLost()
await bridge.forget()
assert.equal(host.saved, null); assert.equal(g.connected, 1, 'out of reach, so still attached')
bridge.linkReady(); await settle()
assert.equal(g.enabled, 0); assert.equal(g.conn, 0)
t.mock.timers.tick(60000); await settle()
assert.equal(bridge.snapshot().state, 'idle'); assert.equal(bridge.snapshot().waiting, false)
bridge.linkLost()
})