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.
132 lines
4.8 KiB
TypeScript
132 lines
4.8 KiB
TypeScript
/**
|
|
* The keyboard bridge as the app uses it: one KeyboardBridge for the life of
|
|
* the app, fed by whichever glasses session is live, its remembered keyboard
|
|
* kept in the settings store, and its key transitions turned into KeyEvents.
|
|
* The dashboard controller reports the link coming and going and takes the
|
|
* keys; the Settings app drives pairing through `bridge`.
|
|
*/
|
|
import { addKeyboardEventListener, keyboardLinkSession, sendKeyboardControlRecord } from "../../native/keyboard-link";
|
|
import { getStringSetting, setStringSetting } from "../../native/settings-store";
|
|
import { KeyboardBridge, type KeyboardBridgeSnapshot, type SavedKeyboard } from "./bridge";
|
|
import { KeyTranslator, type KeyEvent } from "./keys";
|
|
|
|
declare const java: any;
|
|
declare const arc4random_uniform: ((bound: number) => number) | undefined;
|
|
|
|
/** JSON of the remembered keyboard ({ address, addressType, name }), or "" for none. */
|
|
const SAVED_KEYBOARD_KEY = "keyboard.saved";
|
|
|
|
export type KeyboardServiceHost = {
|
|
onKey(event: KeyEvent): void;
|
|
/** Routine lines only (failed background reconnects); the rest go to the device log directly. */
|
|
log(line: string): void;
|
|
/** Whether an absent keyboard is worth looking for now (see KeyboardBridgeHost). */
|
|
shouldReconnect(): boolean;
|
|
};
|
|
|
|
function loadSavedKeyboard(): SavedKeyboard | null {
|
|
try {
|
|
const raw = getStringSetting(SAVED_KEYBOARD_KEY, "");
|
|
if (!raw) return null;
|
|
const value = JSON.parse(raw);
|
|
if (typeof value?.address !== "string" || typeof value?.addressType !== "number") return null;
|
|
return { address: value.address, addressType: value.addressType, name: typeof value.name === "string" ? value.name : "" };
|
|
} catch {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/** Passkey entry only protects the pairing if the passkey can't be guessed. */
|
|
function randomPasskey(): number {
|
|
try {
|
|
if (global.isAndroid) return new java.security.SecureRandom().nextInt(1_000_000);
|
|
if (typeof arc4random_uniform === "function") return arc4random_uniform(1_000_000);
|
|
} catch {
|
|
// Fall through to the weaker source rather than failing the pairing.
|
|
}
|
|
return Math.floor(Math.random() * 1_000_000);
|
|
}
|
|
|
|
class KeyboardService {
|
|
private host: KeyboardServiceHost | null = null;
|
|
private session: unknown = null;
|
|
private offEvents: (() => void) | null = null;
|
|
private readonly listeners = new Set<() => void>();
|
|
private readonly translator = new KeyTranslator({ emit: (event) => this.host?.onKey(event) });
|
|
|
|
readonly bridge = new KeyboardBridge({
|
|
send: (record) => {
|
|
const session = this.session;
|
|
if (!session) return false;
|
|
try {
|
|
return sendKeyboardControlRecord(session, record, `op=${record[3]}`);
|
|
} catch {
|
|
return false;
|
|
}
|
|
},
|
|
loadSaved: loadSavedKeyboard,
|
|
storeSaved: (saved) => setStringSetting(SAVED_KEYBOARD_KEY, saved ? JSON.stringify(saved) : ""),
|
|
onKeys: (events) => this.translator.handle(events),
|
|
onKeyboardGone: () => this.translator.reset(),
|
|
onChanged: () => {
|
|
for (const listener of [...this.listeners]) listener();
|
|
},
|
|
// Pairing and setup are rare and are what a failure report needs, so
|
|
// they always reach the device log. Nothing here ever includes a key.
|
|
log: (line, routine) => {
|
|
if (routine) this.host?.log(line);
|
|
else console.log(`[keyboard] ${line}`);
|
|
},
|
|
randomPasskey,
|
|
shouldReconnect: () => this.host?.shouldReconnect() ?? true,
|
|
});
|
|
|
|
setHost(host: KeyboardServiceHost): void {
|
|
this.host = host;
|
|
}
|
|
|
|
snapshot(): KeyboardBridgeSnapshot {
|
|
return this.bridge.snapshot();
|
|
}
|
|
|
|
/** Called on every bridge state change. Returns an unsubscribe function. */
|
|
subscribe(listener: () => void): () => void {
|
|
this.listeners.add(listener);
|
|
return () => this.listeners.delete(listener);
|
|
}
|
|
|
|
/** The glasses came into use (the display woke): look for an absent keyboard now. */
|
|
retryNow(): void {
|
|
this.bridge.retryNow();
|
|
}
|
|
|
|
/** A G2 session on firmware with the bridge is up. Idempotent. */
|
|
linkReady(): void {
|
|
const session = keyboardLinkSession();
|
|
if (!session) return;
|
|
if (session !== this.session) {
|
|
// The native session object is rebuilt across reconnects.
|
|
this.offEvents?.();
|
|
this.session = session;
|
|
this.offEvents = addKeyboardEventListener(session, (body) => this.bridge.accept(body));
|
|
}
|
|
this.bridge.linkReady();
|
|
}
|
|
|
|
/**
|
|
* The session can't host the keyboard any more. `release` asks the firmware
|
|
* to let the keyboard go first, for when the link itself stays up (the
|
|
* glasses went into their case, or the app is disconnecting on purpose).
|
|
* Idempotent.
|
|
*/
|
|
linkLost(release = false): void {
|
|
if (release) this.bridge.linkClosing();
|
|
this.bridge.linkLost();
|
|
this.offEvents?.();
|
|
this.offEvents = null;
|
|
this.session = null;
|
|
}
|
|
}
|
|
|
|
export const keyboardService = new KeyboardService();
|