Files
faceclaw/app/g1/flash-plan.ts
T

89 lines
3.9 KiB
TypeScript

/** What installing firmware on a G1 has to decide. No I/O. */
import type { GlassesPairCandidate } from "../g2/pairing-candidates";
export type G1Side = "left" | "right";
/** Left first: a right arm on g1v0 next to a left arm on Even's firmware would leave the left eye dark. */
export const G1_SIDES: readonly G1Side[] = ["left", "right"];
export const G1_CASE_INSTRUCTIONS =
"Put the glasses in their charging case with the lid open, and plug the case in. Stay nearby, and leave Faceclaw open.";
export const G1_INSTALL_NOTICE =
"This replaces the firmware on both arms, about two minutes each. Going back to Even's firmware later takes a computer, and " +
"may not be the version you have now. Installing custom firmware is not covered by warranty.";
/** What the native flow says when it finishes (G1ArmFlashFlow). */
export type G1FlashResult = {
flashed?: boolean;
firmware?: "g1v0" | "stock";
version?: string;
safeMode?: boolean;
inCase?: boolean;
battery?: number | null;
};
export function parseG1FlashResult(detail: string): G1FlashResult {
try {
const parsed = JSON.parse(detail);
return parsed && typeof parsed === "object" ? (parsed as G1FlashResult) : {};
} catch {
return {};
}
}
/** Dotted versions, component by component; a missing component counts as 0. */
export function compareG1Versions(a: string, b: string): number {
const parts = (version: string) => version.split(".").map((part) => parseInt(part, 10) || 0);
const left = parts(a);
const right = parts(b);
for (let i = 0; i < Math.max(left.length, right.length); i++) {
const delta = (left[i] ?? 0) - (right[i] ?? 0);
if (delta !== 0) return delta;
}
return 0;
}
export type G1Wanted = { serial?: string | null; left?: string; right?: string };
const serialOf = (serial: string | null | undefined) => (serial ?? "").trim().toUpperCase();
export function sameG1Serial(a: string | null | undefined, b: string | null | undefined): boolean {
return serialOf(a) !== "" && serialOf(a) === serialOf(b);
}
/**
* The pair being installed on, among those heard, once both arms have been. Its serial decides, as a flash changes an arm's
* address; an address it was saved under also tells. Only with neither known does the only G1 around count: firmware
* must never go to someone else's glasses because the wanted ones weren't heard.
*/
export function pickG1Pair(pairs: readonly GlassesPairCandidate[], wanted: G1Wanted): GlassesPairCandidate | null {
const g1 = pairs.filter((pair) => pair.g1Firmware);
const complete = (pair: GlassesPairCandidate | undefined) => (pair?.left && pair.right ? pair : null);
const bySerial = g1.find((pair) => sameG1Serial(pair.serial, wanted.serial));
if (bySerial) return complete(bySerial);
const byAddress = g1.find((pair) =>
(!!wanted.left && pair.left?.address === wanted.left) || (!!wanted.right && pair.right?.address === wanted.right));
if (byAddress) return complete(byAddress);
if (serialOf(wanted.serial) || wanted.left || wanted.right) return null;
return g1.length === 1 ? complete(g1[0]) : null;
}
/**
* What a check of the two arms found: "stock", Even's firmware on an arm; "safe-mode", g1v0 restarted repeatedly and only
* updates work; "older", older than the app ships; "current", nothing to do.
*/
export type G1FirmwareState = "stock" | "safe-mode" | "older" | "current";
export function g1FirmwareState(arms: readonly G1FlashResult[], shipped: string): G1FirmwareState {
if (arms.some((arm) => arm.firmware === "stock")) return "stock";
if (arms.some((arm) => arm.safeMode)) return "safe-mode";
return arms.some((arm) => compareG1Versions(arm.version ?? "", shipped) < 0) ? "older" : "current";
}
/** Each arm counts for half of the bar. */
export function g1FlashPercent(side: G1Side, bytesSent: number, bytesTotal: number): number {
const within = bytesTotal > 0 ? Math.min(1, bytesSent / bytesTotal) : 0;
return ((side === "right" ? 1 + within : within) / 2) * 100;
}