forked from Blendman974/faceclaw
490 lines
19 KiB
TypeScript
490 lines
19 KiB
TypeScript
import { Frame, Observable } from "@nativescript/core";
|
|
|
|
import { G1ArmScanner } from "../g1/arm-scanner";
|
|
import { EVEN_G1_RESTORE } from "../g1/even-firmware";
|
|
import { G1V0_IMAGE } from "../g1/firmware/g1v0-image";
|
|
import {
|
|
buildEvenG1Firmware,
|
|
buildG1Firmware,
|
|
type BuiltEvenG1Firmware,
|
|
type BuiltG1Firmware,
|
|
type G1BuildProgress,
|
|
} from "../g1/firmware-builder";
|
|
import { saveG1Arm, saveG1Pair } from "../g1/addresses";
|
|
import {
|
|
G1_CASE_DELAY_HINT,
|
|
G1_CASE_INSTRUCTIONS,
|
|
G1_INSTALL_NOTICE,
|
|
G1_SIDES,
|
|
G1_UNINSTALL_NOTICE,
|
|
G1_UNINSTALL_SIDES,
|
|
g1FlashPercent,
|
|
type G1FlashResult,
|
|
type G1Side,
|
|
} from "../g1/flash-plan";
|
|
import { loadDeviceAddresses, loadPairedGlassesIdentity } from "../g2/device-addresses";
|
|
import { downloadAndExtractEvenHubFonts, hasExtractedEvenHubFonts } from "../g2/firmware-builder";
|
|
import { type GlassesPairCandidate } from "../g2/pairing-candidates";
|
|
import { resumeAutoReconnect, suppressAutoReconnect } from "../g2/reconnect-policy";
|
|
import { ensureBlePermissions } from "../native/ble-permissions";
|
|
import { forgetG1Pairing, G1Flasher, type G1FlasherOptions } from "../native/g1-flasher";
|
|
import { formatErrorMessage } from "../util/format-error";
|
|
import { finishOnboardingNavigation } from "./onboarding-navigation";
|
|
import { setOnboardingCompleted, setPreviewOnlyMode } from "./onboarding-state";
|
|
|
|
type Phase = "intro" | "preparing" | "flashing" | "flashed" | "error";
|
|
|
|
const LOCATE_MS = 45_000;
|
|
/** An arm takes about 20 s to copy the image, and a hung boot resets itself within two minutes. */
|
|
const RETURN_MS = 240_000;
|
|
/** Even's image is larger than g1v0, and MCUboot first installs the network core's. */
|
|
const RESTORE_RETURN_MS = 300_000;
|
|
/**
|
|
* Just after its reset an arm may still be heard on g1v0. Later than this, one heard on g1v0 has booted it again:
|
|
* MCUboot didn't take Even's firmware.
|
|
*/
|
|
const OLD_FIRMWARE_GRACE_MS = 15_000;
|
|
const CONNECT_MS = 60_000;
|
|
/** A new arm pairs only once it knows it's in the case, which a full case can take a while to tell it. */
|
|
const FIRST_PAIRING_MS = 120_000;
|
|
|
|
/**
|
|
* The install and uninstall page on a G1, in place of OnboardingFlashViewModel. The two arms are separate devices that
|
|
* each take the image over MCUmgr (G1ArmFlashFlow), left first; an uninstall goes right first and puts back both of
|
|
* Even's images, the network core's too. There is nothing on the lens to confirm with while an arm runs Even's
|
|
* firmware, so the confirmation is on the phone: the page before, or this one's intro.
|
|
*
|
|
* Every run starts by listening for what each arm runs now, so a retry picks up wherever the last one stopped. An arm's
|
|
* new address is saved as soon as it's known.
|
|
*/
|
|
export class G1FlashViewModel extends Observable {
|
|
private phase: Phase = "intro";
|
|
private readonly fromOnboarding: boolean;
|
|
private readonly uninstalling: boolean;
|
|
private readonly scanner = new G1ArmScanner();
|
|
private image: BuiltG1Firmware | null = null;
|
|
private evenImage: BuiltEvenG1Firmware | null = null;
|
|
private flasher: G1Flasher | null = null;
|
|
private generation = 0;
|
|
private disposed = false;
|
|
private unpairedArm = false;
|
|
/** An uninstall's outcome, for the last page: an arm's store erased, a pairing this phone couldn't remove, an arm done. */
|
|
private wiped = false;
|
|
private pairingLeft = false;
|
|
private restoredArm = false;
|
|
|
|
headline = "Install Faceclaw's Firmware";
|
|
status = "";
|
|
log = "";
|
|
busy = false;
|
|
progress = 0;
|
|
|
|
constructor(options?: { mode?: "install" | "uninstall"; fromOnboarding?: boolean; autoStart?: boolean }) {
|
|
super();
|
|
this.fromOnboarding = options?.fromOnboarding ?? true;
|
|
this.uninstalling = options?.mode === "uninstall";
|
|
suppressAutoReconnect();
|
|
if (this.uninstalling) {
|
|
this.headline = "Back to Even's Firmware";
|
|
this.status = `${G1_CASE_INSTRUCTIONS}\n\n${G1_UNINSTALL_NOTICE}`;
|
|
} else {
|
|
this.status = `${G1_CASE_INSTRUCTIONS}\n\n${G1_INSTALL_NOTICE}`;
|
|
}
|
|
if (options?.autoStart) void this.run();
|
|
}
|
|
|
|
// --- what the page binds --------------------------------------------------
|
|
|
|
get logVisibility(): "visible" | "collapse" {
|
|
return this.log ? "visible" : "collapse";
|
|
}
|
|
|
|
get busyVisibility(): "visible" | "collapse" {
|
|
return this.busy ? "visible" : "collapse";
|
|
}
|
|
|
|
get progressVisibility(): "visible" | "collapse" {
|
|
return this.phase === "flashing" ? "visible" : "collapse";
|
|
}
|
|
|
|
get primaryLabel(): string {
|
|
switch (this.phase) {
|
|
case "intro":
|
|
return this.uninstalling ? "Uninstall" : "Install";
|
|
case "flashed":
|
|
return "Finish";
|
|
case "error":
|
|
return "Retry";
|
|
default:
|
|
return "";
|
|
}
|
|
}
|
|
|
|
get primaryVisibility(): "visible" | "collapse" {
|
|
return this.primaryLabel ? "visible" : "collapse";
|
|
}
|
|
|
|
get secondaryLabel(): string {
|
|
return "Back";
|
|
}
|
|
|
|
get secondaryVisibility(): "visible" | "collapse" {
|
|
// No way out mid-install, or after one.
|
|
return this.phase === "preparing" || this.phase === "flashing" || this.phase === "flashed" ? "collapse" : "visible";
|
|
}
|
|
|
|
onPrimaryTap(): void {
|
|
if (this.phase === "intro" || this.phase === "error") void this.run();
|
|
else if (this.phase === "flashed") this.finish();
|
|
}
|
|
|
|
onSecondaryTap(): void {
|
|
if (this.phase === "intro" || this.phase === "error") this.leave();
|
|
}
|
|
|
|
// --- the install ----------------------------------------------------------
|
|
|
|
private async run(): Promise<void> {
|
|
const generation = ++this.generation;
|
|
const live = () => !this.disposed && generation === this.generation;
|
|
this.setPhase("preparing");
|
|
this.setBusy(true);
|
|
this.setText("Preparing Firmware", this.uninstalling ? "Getting Even's firmware ready..." : "Getting the firmware ready...");
|
|
try {
|
|
await ensureBlePermissions();
|
|
if (!live()) return;
|
|
if (this.uninstalling) {
|
|
if (!this.evenImage) {
|
|
this.evenImage = await buildEvenG1Firmware((progress) => {
|
|
if (live()) this.setStatus(describeEvenBuild(progress));
|
|
});
|
|
this.appendLog(`Even's firmware ${this.evenImage.version} downloaded and verified (${this.evenImage.bytes.toLocaleString()} bytes)`);
|
|
}
|
|
} else {
|
|
if (!this.image) {
|
|
this.image = await buildG1Firmware((progress) => {
|
|
if (live()) this.setStatus(describeBuild(progress));
|
|
});
|
|
this.appendLog(`firmware ${this.image.version} prepared and verified (${this.image.bytes.toLocaleString()} bytes)`);
|
|
}
|
|
await this.prepareFonts(live);
|
|
}
|
|
if (!live()) return;
|
|
|
|
this.setPhase("flashing");
|
|
this.setText(this.uninstalling ? "Restoring Even's Firmware" : "Installing Firmware", "Listening for your glasses...");
|
|
const identity = loadPairedGlassesIdentity();
|
|
const stored = loadDeviceAddresses();
|
|
const pair = await this.scanner.waitForPair({ serial: identity?.serial, left: stored.left, right: stored.right }, LOCATE_MS);
|
|
if (!live()) return;
|
|
if (!pair) {
|
|
throw new Error("Couldn't hear both arms of your glasses. Make sure they're in the case with the lid open, and that no other app " +
|
|
"or phone is connected to them, then retry.");
|
|
}
|
|
saveG1Pair(pair);
|
|
|
|
if (this.uninstalling) {
|
|
for (const side of G1_UNINSTALL_SIDES) {
|
|
await this.restoreArm(side, pair, live);
|
|
if (!live()) return;
|
|
}
|
|
this.restored();
|
|
return;
|
|
}
|
|
this.unpairedArm = false;
|
|
for (const side of G1_SIDES) {
|
|
await this.installArm(side, pair, live);
|
|
if (!live()) return;
|
|
}
|
|
this.finished();
|
|
} catch (error) {
|
|
if (live()) this.failed(formatErrorMessage(error));
|
|
}
|
|
}
|
|
|
|
private async installArm(side: G1Side, pair: GlassesPairCandidate, live: () => boolean): Promise<void> {
|
|
const arm = pair[side]!;
|
|
const fromStock = arm.g1Firmware === "stock";
|
|
this.setProgress(g1FlashPercent(side, 0, 1));
|
|
this.setStatus(`Connecting to the ${side} arm...`);
|
|
const installed = await this.flash({
|
|
address: arm.address,
|
|
side,
|
|
firmwarePath: this.image!.path,
|
|
mode: fromStock ? "stock" : "update",
|
|
connectWindowMs: CONNECT_MS,
|
|
}, (state) => {
|
|
if (state === "pairing") this.setStatus(`Pairing with the ${side} arm. If your phone asks, accept it.`);
|
|
else if (state === "checking") this.setStatus(`Checking the ${side} arm...`);
|
|
else if (state === "flashing") this.setStatus(`Sending the firmware to the ${side} arm. Nothing has changed yet.`);
|
|
else if (state === "committing") this.setStatus(`Installing on the ${side} arm. Keep the glasses in the case.`);
|
|
}, (sent, total) => this.setProgress(g1FlashPercent(side, sent, total)));
|
|
if (!live()) return;
|
|
this.setProgress(g1FlashPercent(side, 1, 1));
|
|
if (!installed.flashed) {
|
|
this.appendLog(`${side} arm already runs ${installed.version}`);
|
|
return;
|
|
}
|
|
|
|
this.setStatus(`The ${side} arm is restarting into the new firmware. This takes about 20 seconds; keep it in the case.`);
|
|
const identity = loadPairedGlassesIdentity();
|
|
const back = await this.scanner.waitForG1v0Arm(side, identity?.serial ?? pair.serial, RETURN_MS);
|
|
if (!live()) return;
|
|
if (!back) {
|
|
throw new Error(`The ${side} arm hasn't come back yet. Leave the glasses in the plugged-in case for a few minutes, with the lid ` +
|
|
"open: an interrupted install finishes by itself. Then retry.");
|
|
}
|
|
saveG1Arm(side, back);
|
|
// Coming from firmware before 0.5.66, which had an address of its own: the phone needn't remember that one.
|
|
if (back.address !== arm.address) forgetG1Pairing(arm.address);
|
|
if (back.g1Firmware === "g1v0-safe") {
|
|
throw new Error(`The ${side} arm came back in safe mode: the new firmware restarted repeatedly. Retry to install it again.`);
|
|
}
|
|
|
|
this.setStatus(`Checking the ${side} arm. If your phone asks to pair, accept it. ${G1_CASE_DELAY_HINT}`);
|
|
// An arm at a new address has no bond yet (coming from Even's firmware the address is kept from 0.5.66 on, and so is the
|
|
// bond). It may refuse one for a while: it's installed either way, and the session pairs it later.
|
|
const newAddress = back.address !== arm.address;
|
|
let running: G1FlashResult;
|
|
try {
|
|
running = await this.flash({
|
|
address: back.address,
|
|
side,
|
|
firmwarePath: "",
|
|
mode: "probe",
|
|
connectWindowMs: newAddress ? FIRST_PAIRING_MS : RETURN_MS,
|
|
});
|
|
} catch (error) {
|
|
if (!newAddress || !live()) throw error;
|
|
// Installed, as its advertising shows; it just won't pair yet. The next connection pairs it.
|
|
this.appendLog(`${side} arm not paired yet: ${formatErrorMessage(error)}`);
|
|
this.unpairedArm = true;
|
|
return;
|
|
}
|
|
if (!live()) return;
|
|
if (running.version !== installed.version) {
|
|
throw new Error(`The ${side} arm runs ${running.version}, not ${installed.version}: it didn't take the new firmware. Retry to try again.`);
|
|
}
|
|
this.appendLog(`${side} arm runs ${running.version}`);
|
|
}
|
|
|
|
/**
|
|
* Even's firmware back on one arm, then a wait for it to advertise as Even's. An arm already on Even's firmware is
|
|
* left alone: a retry goes on from there.
|
|
*/
|
|
private async restoreArm(side: G1Side, pair: GlassesPairCandidate, live: () => boolean): Promise<void> {
|
|
const arm = pair[side]!;
|
|
if (arm.g1Firmware === "stock") {
|
|
this.appendLog(`${side} arm already runs Even's firmware`);
|
|
this.setProgress(g1FlashPercent(side, 1, 1, G1_UNINSTALL_SIDES));
|
|
return;
|
|
}
|
|
const even = this.evenImage!;
|
|
this.setProgress(g1FlashPercent(side, 0, 1, G1_UNINSTALL_SIDES));
|
|
this.setStatus(`Connecting to the ${side} arm...`);
|
|
const result = await this.flash({
|
|
address: arm.address,
|
|
side,
|
|
firmwarePath: even.appPath,
|
|
netCorePath: even.netCorePath,
|
|
mode: "restore",
|
|
connectWindowMs: CONNECT_MS,
|
|
}, (state) => {
|
|
if (state === "pairing") this.setStatus(`Pairing with the ${side} arm. If your phone asks, accept it.`);
|
|
else if (state === "checking") this.setStatus(`Checking the ${side} arm...`);
|
|
else if (state === "wiping") {
|
|
this.setStatus(`Erasing Faceclaw's storage on the ${side} arm, where Even's fonts were. This can take several minutes; keep the ` +
|
|
"glasses in the case. Nothing else has changed yet.");
|
|
} else if (state === "flashing") this.setStatus(`Sending Even's firmware to the ${side} arm. Its firmware hasn't changed yet.`);
|
|
else if (state === "committing") this.setStatus(`Installing on the ${side} arm. Keep the glasses in the case.`);
|
|
}, (sent, total) => this.setProgress(g1FlashPercent(side, sent, total, G1_UNINSTALL_SIDES)));
|
|
if (!live()) return;
|
|
if (result.wiped) this.wiped = true;
|
|
this.setProgress(g1FlashPercent(side, 1, 1, G1_UNINSTALL_SIDES));
|
|
|
|
this.setStatus(`The ${side} arm is restarting into Even's firmware. This takes a minute or two; keep it in the case.`);
|
|
const resetAt = Date.now();
|
|
const identity = loadPairedGlassesIdentity();
|
|
const back = await this.scanner.waitForArm(side, identity?.serial ?? pair.serial, RESTORE_RETURN_MS,
|
|
(heard) => heard.g1Firmware === "stock" || Date.now() - resetAt >= OLD_FIRMWARE_GRACE_MS);
|
|
if (!live()) return;
|
|
if (!back) {
|
|
throw new Error(`The ${side} arm hasn't come back yet. Leave the glasses in the plugged-in case for a few minutes, with the lid ` +
|
|
"open: an interrupted install finishes by itself. Then retry.");
|
|
}
|
|
if (back.g1Firmware !== "stock") {
|
|
throw new Error(`The ${side} arm came back on Faceclaw's firmware: it didn't take Even's. Retry to try again.`);
|
|
}
|
|
saveG1Arm(side, back);
|
|
this.restoredArm = true;
|
|
// Even's app makes its own pairing with Even's firmware; the one this phone made with g1v0 would only be in its way.
|
|
this.forgetPairing(back.address);
|
|
if (back.address !== arm.address) this.forgetPairing(arm.address);
|
|
this.appendLog(`${side} arm runs Even's firmware`);
|
|
}
|
|
|
|
private forgetPairing(address: string): void {
|
|
if (!forgetG1Pairing(address)) this.pairingLeft = true;
|
|
}
|
|
|
|
private async flash(
|
|
options: G1FlasherOptions,
|
|
onState?: (state: string) => void,
|
|
onProgress?: (sent: number, total: number) => void,
|
|
) {
|
|
const flasher = new G1Flasher(options);
|
|
this.flasher = flasher;
|
|
flasher.onLog((line) => this.appendLog(line));
|
|
if (onState) flasher.onState(onState);
|
|
if (onProgress) flasher.onProgress(onProgress);
|
|
try {
|
|
return await flasher.run();
|
|
} finally {
|
|
if (this.flasher === flasher) this.flasher = null;
|
|
flasher.close();
|
|
}
|
|
}
|
|
|
|
/** A G2's install gets these from the same download; Faceclaw's fonts are a phone-side matter, so a failure here is no reason to stop. */
|
|
private async prepareFonts(live: () => boolean): Promise<void> {
|
|
if (hasExtractedEvenHubFonts()) return;
|
|
if (live()) this.setStatus("Preparing fonts...");
|
|
try {
|
|
await downloadAndExtractEvenHubFonts();
|
|
} catch (error) {
|
|
this.appendLog(`fonts not prepared: ${formatErrorMessage(error)}`);
|
|
}
|
|
}
|
|
|
|
private finished(): void {
|
|
// The glasses are ready for the main page to connect to.
|
|
resumeAutoReconnect();
|
|
this.setBusy(false);
|
|
this.setProgress(100);
|
|
this.setPhase("flashed");
|
|
this.setText("All Done", `Both arms run Faceclaw's firmware ${G1V0_IMAGE.version}.` + (this.unpairedArm
|
|
? " Keep the glasses in the case with the lid open until Faceclaw has connected: they only pair in the case."
|
|
: ""));
|
|
}
|
|
|
|
private restored(): void {
|
|
// Stays manually disconnected: Faceclaw would only find firmware it can't run.
|
|
this.setBusy(false);
|
|
this.setProgress(100);
|
|
this.setPhase("flashed");
|
|
if (!this.restoredArm) {
|
|
this.setText("All Done", "Both arms already run Even's firmware.");
|
|
return;
|
|
}
|
|
const steps = [`Both arms run Even's firmware ${EVEN_G1_RESTORE.version}.`];
|
|
if (this.pairingLeft) {
|
|
steps.push("Before pairing them in Even's app, remove both arms in this phone's Bluetooth settings (\"Forget This Device\"): " +
|
|
"Faceclaw's firmware made that pairing, and Even's firmware makes its own.");
|
|
} else {
|
|
steps.push("To use them, pair them in Even's app.");
|
|
}
|
|
if (this.wiped) {
|
|
steps.push("Even's Chinese, Japanese and Korean text and its demo pictures were erased with Faceclaw's storage, and don't come back.");
|
|
}
|
|
this.setText("All Done", steps.join("\n\n"));
|
|
}
|
|
|
|
private failed(message: string): void {
|
|
this.setBusy(false);
|
|
this.setPhase("error");
|
|
this.setText("Something Went Wrong", message);
|
|
}
|
|
|
|
private finish(): void {
|
|
if (!this.uninstalling) {
|
|
setPreviewOnlyMode(false);
|
|
setOnboardingCompleted(true);
|
|
}
|
|
this.teardown();
|
|
finishOnboardingNavigation();
|
|
}
|
|
|
|
private leave(): void {
|
|
this.teardown();
|
|
const frame = Frame.topmost();
|
|
if (this.fromOnboarding && frame?.canGoBack()) {
|
|
frame.goBack();
|
|
return;
|
|
}
|
|
if (!this.fromOnboarding) {
|
|
finishOnboardingNavigation();
|
|
return;
|
|
}
|
|
frame?.navigate({ moduleName: "phone-ui/onboarding-page", clearHistory: true });
|
|
}
|
|
|
|
dispose(): void {
|
|
this.disposed = true;
|
|
this.teardown();
|
|
}
|
|
|
|
private teardown(): void {
|
|
++this.generation;
|
|
this.scanner.stop();
|
|
this.flasher?.close();
|
|
this.flasher = null;
|
|
}
|
|
|
|
// --- page state -----------------------------------------------------------
|
|
|
|
private setText(headline: string, status: string): void {
|
|
this.set("headline", headline);
|
|
this.set("status", status);
|
|
}
|
|
|
|
private setStatus(status: string): void {
|
|
this.set("status", status);
|
|
}
|
|
|
|
private setBusy(busy: boolean): void {
|
|
this.set("busy", busy);
|
|
this.notifyPropertyChange("busyVisibility", this.busyVisibility);
|
|
}
|
|
|
|
private setProgress(percent: number): void {
|
|
this.set("progress", Math.max(0, Math.min(100, Math.round(percent))));
|
|
}
|
|
|
|
private setPhase(phase: Phase): void {
|
|
this.phase = phase;
|
|
for (const property of ["primaryLabel", "primaryVisibility", "secondaryVisibility", "progressVisibility"] as const) {
|
|
this.notifyPropertyChange(property, this[property]);
|
|
}
|
|
}
|
|
|
|
private appendLog(line: string): void {
|
|
const stamp = new Date().toISOString().slice(11, 19);
|
|
this.set("log", this.log ? `${this.log}\n[${stamp}] ${line}` : `[${stamp}] ${line}`);
|
|
this.notifyPropertyChange("logVisibility", this.logVisibility);
|
|
}
|
|
}
|
|
|
|
function describeEvenBuild(progress: G1BuildProgress): string {
|
|
switch (progress) {
|
|
case "downloading":
|
|
return "Downloading Even's firmware from Even's firmware server...";
|
|
case "verifying":
|
|
return "Verifying the download...";
|
|
default:
|
|
return "Saving the firmware...";
|
|
}
|
|
}
|
|
|
|
function describeBuild(progress: G1BuildProgress): string {
|
|
switch (progress) {
|
|
case "downloading":
|
|
return "Downloading the parts it needs from Even's firmware server...";
|
|
case "verifying":
|
|
return "Verifying the download...";
|
|
case "assembling":
|
|
return "Assembling the firmware...";
|
|
default:
|
|
return "Saving the firmware...";
|
|
}
|
|
}
|