Flashing uses 2.2.9 as base version

This commit is contained in:
James Babcock committed 2026-09-02 00:30:50 -07:00
1 parent c7d4e7a630
commit 76825f68a7
8 files changed
+324 -91

No files matched your search

@@ -27,9 +27,18 @@ import java.util.concurrent.TimeUnit;
* whole lifecycle on a single worker thread. It expects the main app to be * whole lifecycle on a single worker thread. It expects the main app to be
* disconnected while it runs (onboarding, before flashing). * disconnected while it runs (onboarding, before flashing).
* *
* Only the right arm is used: the lenses relay messages to each other, so * Both arms are connected and security-authenticated up front, even though the
* anything sent to the right arm reaches both, and acks/events only ever come * prompt itself only needs the right arm (the lenses relay messages to each
* from the right arm anyway. * other, and acks/events only ever come from the right arm): on an unbonded
* phone the auth exchange is what raises the OS pairing prompt, and doing both
* here means both prompts appear at the start rather than one popping up half
* way through flashing the second lens. While connected, each arm's battery
* level is read (they are independent batteries) so the caller can refuse to
* flash on a low charge.
*
* With `skipPrompt` the on-glasses confirmation is not shown: the flow is just
* connect + auth + battery read + result(approved). Used to re-check the
* battery after the user has already confirmed once.
*/ */
public class FaceclawFlashPromptCommunicator implements FaceclawBleListener { public class FaceclawFlashPromptCommunicator implements FaceclawBleListener {
private static final String TAG = "FaceclawFlashPrompt"; private static final String TAG = "FaceclawFlashPrompt";
@@ -44,10 +53,13 @@ public class FaceclawFlashPromptCommunicator implements FaceclawBleListener {
private static final int HEARTBEAT_INTERVAL_MS = 4_000; private static final int HEARTBEAT_INTERVAL_MS = 4_000;
private static final int SELECTION_TIMEOUT_MS = 120_000; private static final int SELECTION_TIMEOUT_MS = 120_000;
private static final int CREATE_ACK_TIMEOUT_MS = 3_000; private static final int CREATE_ACK_TIMEOUT_MS = 3_000;
private static final int BATTERY_ACK_TIMEOUT_MS = 3_000;
private final Context context; private final Context context;
private final String rightAddress; private final String rightAddress;
private final String leftAddress;
private final String warningText; private final String warningText;
private final boolean skipPrompt;
private final FaceclawBleManager bleManager; private final FaceclawBleManager bleManager;
private final Handler mainHandler = new Handler(Looper.getMainLooper()); private final Handler mainHandler = new Handler(Looper.getMainLooper());
@@ -61,6 +73,7 @@ public class FaceclawFlashPromptCommunicator implements FaceclawBleListener {
private volatile boolean cancelled = false; private volatile boolean cancelled = false;
private volatile boolean finished = false; private volatile boolean finished = false;
private volatile boolean rightConnected = false; private volatile boolean rightConnected = false;
private volatile boolean leftConnected = false;
private volatile boolean rightLost = false; private volatile boolean rightLost = false;
private volatile Boolean approved = null; private volatile Boolean approved = null;
private volatile ScheduledExecutorService heartbeatExecutor; private volatile ScheduledExecutorService heartbeatExecutor;
@@ -68,10 +81,13 @@ public class FaceclawFlashPromptCommunicator implements FaceclawBleListener {
private int nextMagic = 100; private int nextMagic = 100;
private int nextSeq = 0x40; private int nextSeq = 0x40;
public FaceclawFlashPromptCommunicator(Context context, String rightAddress, String warningText) { public FaceclawFlashPromptCommunicator(
Context context, String rightAddress, String leftAddress, String warningText, boolean skipPrompt) {
this.context = context.getApplicationContext(); this.context = context.getApplicationContext();
this.rightAddress = rightAddress == null ? "" : rightAddress; this.rightAddress = rightAddress == null ? "" : rightAddress;
this.leftAddress = leftAddress == null ? "" : leftAddress;
this.warningText = warningText == null ? "" : warningText; this.warningText = warningText == null ? "" : warningText;
this.skipPrompt = skipPrompt;
this.bleManager = new FaceclawBleManager(this.context); this.bleManager = new FaceclawBleManager(this.context);
this.bleManager.setListener(this); this.bleManager.setListener(this);
} }
@@ -117,43 +133,85 @@ public class FaceclawFlashPromptCommunicator implements FaceclawBleListener {
} }
emitState("connecting", ""); emitState("connecting", "");
connectArm(rightAddress); connectArm(rightAddress, "right");
rightConnected = true; rightConnected = true;
if (cancelled) { if (cancelled) {
teardown(); teardown();
return; return;
} }
if (!leftAddress.trim().isEmpty()) {
connectArm(leftAddress, "left");
leftConnected = true;
if (cancelled) {
teardown();
return;
}
}
emitState("connected", ""); emitState("connected", "");
bringUpArm(rightAddress); // Auth both arms now (pairing prompts, if any, happen here) before
// anything else, so both bonds exist by the time flashing starts.
authenticateArm(rightAddress, "right");
if (leftConnected) {
authenticateArm(leftAddress, "left");
}
if (cancelled) {
teardown();
return;
}
sendPrelude(rightAddress);
startHeartbeat(); if (!skipPrompt) {
emitState("prompting", ""); showPrompt(rightAddress);
startHeartbeat();
emitState("prompting", "");
boolean signalled = selectionLatch.await(SELECTION_TIMEOUT_MS, TimeUnit.MILLISECONDS); selectionLatch.await(SELECTION_TIMEOUT_MS, TimeUnit.MILLISECONDS);
stopHeartbeat(); stopHeartbeat();
if (cancelled) {
emitState("cancelled", "");
teardown();
return;
}
if (approved == null) {
if (rightLost) {
emitState("disconnected", "Lost connection to the glasses.");
} else {
emitState("timeout", "No response from the glasses.");
}
teardown();
return;
}
try {
sendShutdown();
} catch (Exception ignored) {
}
if (!Boolean.TRUE.equals(approved)) {
emitResult(false);
emitState("result", "declined");
teardown();
return;
}
}
// Approved (or prompt skipped): read each arm's battery while the
// links are still up, then report the result.
emitState("battery", "");
readBatteries();
if (cancelled) { if (cancelled) {
emitState("cancelled", ""); emitState("cancelled", "");
teardown(); teardown();
return; return;
} }
if (approved != null) { if (rightLost) {
boolean result = Boolean.TRUE.equals(approved); emitState("disconnected", "Lost connection to the glasses.");
try {
sendShutdown();
} catch (Exception ignored) {
}
emitResult(result);
emitState("result", result ? "approved" : "declined");
teardown(); teardown();
return; return;
} }
if (rightLost) { finished = true;
emitState("disconnected", "Lost connection to the glasses."); emitResult(true);
} else { emitState("result", "approved");
emitState("timeout", "No response from the glasses.");
}
teardown(); teardown();
} catch (Exception e) { } catch (Exception e) {
stopHeartbeat(); stopHeartbeat();
@@ -165,26 +223,28 @@ public class FaceclawFlashPromptCommunicator implements FaceclawBleListener {
} }
} }
private void connectArm(String address) { private void connectArm(String address, String arm) {
if (!bleManager.connect(address, ConnectionOptions.CONNECT_TIMEOUT_MS)) { if (!bleManager.connect(address, ConnectionOptions.CONNECT_TIMEOUT_MS)) {
throw new IllegalStateException("connect failed: " + address); throw new IllegalStateException("could not connect to the " + arm + " arm (" + address + ")");
} }
bleManager.requestConnectionPriority(address, BluetoothGatt.CONNECTION_PRIORITY_HIGH); bleManager.requestConnectionPriority(address, BluetoothGatt.CONNECTION_PRIORITY_HIGH);
bleManager.requestMtu(address, ConnectionOptions.DESIRED_MTU, ConnectionOptions.CONNECT_TIMEOUT_MS); bleManager.requestMtu(address, ConnectionOptions.DESIRED_MTU, ConnectionOptions.CONNECT_TIMEOUT_MS);
if (!bleManager.discoverServices(address, ConnectionOptions.SERVICES_TIMEOUT_MS)) { if (!bleManager.discoverServices(address, ConnectionOptions.SERVICES_TIMEOUT_MS)) {
throw new IllegalStateException("discoverServices failed: " + address); throw new IllegalStateException("discoverServices failed: " + arm + " arm (" + address + ")");
} }
if (!bleManager.enableNotifications(address, BleProtocol.NOTIFY_CHAR_UUID, true, ConnectionOptions.DESCRIPTOR_TIMEOUT_MS)) { if (!bleManager.enableNotifications(address, BleProtocol.NOTIFY_CHAR_UUID, true, ConnectionOptions.DESCRIPTOR_TIMEOUT_MS)) {
throw new IllegalStateException("enableNotifications failed: " + address); throw new IllegalStateException("enableNotifications failed: " + arm + " arm (" + address + ")");
} }
emitLog("connected right arm"); emitLog("connected " + arm + " arm");
} }
private void bringUpArm(String address) throws InterruptedException { /**
// 1. Security-auth exchange on sid=0x80: firmware 2.2.9 will not run a * Security-auth exchange on sid=0x80: firmware 2.2.9 will not run a
// session (and closes the link after ~30 s) without it, and on an * session (and closes the link after ~30 s) without it, and on an
// unbonded phone this is what triggers SMP pairing, so it may sit * unbonded phone this is what triggers SMP pairing, so it may sit
// waiting on an OS pairing prompt. * waiting on an OS pairing prompt.
*/
private void authenticateArm(String address, String arm) throws InterruptedException {
int authMagic = allocMagic(); int authMagic = allocMagic();
byte[] authAck = writeAndAwaitAck( byte[] authAck = writeAndAwaitAck(
address, address,
@@ -195,10 +255,14 @@ public class FaceclawFlashPromptCommunicator implements FaceclawBleListener {
ConnectionOptions.SECURITY_AUTH_TIMEOUT_MS); ConnectionOptions.SECURITY_AUTH_TIMEOUT_MS);
if (authAck == null || !BleProtocol.isAuthenticationSuccess(authAck, authMagic)) { if (authAck == null || !BleProtocol.isAuthenticationSuccess(authAck, authMagic)) {
throw new IllegalStateException( throw new IllegalStateException(
"could not authenticate with the glasses (" + address "could not authenticate with the " + arm + " arm (" + address
+ ") — if Android shows a Bluetooth pairing request, accept it and try again"); + ") — if Android shows a Bluetooth pairing request, accept it and try again");
} }
// 2. Mandatory session prelude on sid=0x01 (app-launch). emitLog("security auth complete: " + arm + " arm");
}
/** Mandatory session prelude on sid=0x01 (app-launch). Right arm only; it relays. */
private void sendPrelude(String address) throws InterruptedException {
if (writeAndAwaitAck( if (writeAndAwaitAck(
address, address,
BleProtocol.PRELUDE_ACK_SID, BleProtocol.PRELUDE_ACK_SID,
@@ -208,10 +272,13 @@ public class FaceclawFlashPromptCommunicator implements FaceclawBleListener {
ConnectionOptions.PRELUDE_TIMEOUT_MS) == null) { ConnectionOptions.PRELUDE_TIMEOUT_MS) == null) {
throw new IllegalStateException("session prelude not acked: " + address); throw new IllegalStateException("session prelude not acked: " + address);
} }
// 3. Create the prompt page (warning text + No/Yes list) on sid=0xe0 Cmd=0. }
// Two attempts: on 2.2.9 the first request sent right after the
// prelude can be dropped while the lens emits its own sid-0x80 private void showPrompt(String address) throws InterruptedException {
// notifications (observed with the device-info settings read). // Create the prompt page (warning text + No/Yes list) on sid=0xe0 Cmd=0.
// Two attempts: on 2.2.9 the first request sent right after the
// prelude can be dropped while the lens emits its own sid-0x80
// notifications (observed with the device-info settings read).
byte[] pageAck = null; byte[] pageAck = null;
for (int attempt = 0; attempt < 2 && pageAck == null && !cancelled; attempt++) { for (int attempt = 0; attempt < 2 && pageAck == null && !cancelled; attempt++) {
int magic = allocMagic(); int magic = allocMagic();
@@ -228,6 +295,42 @@ public class FaceclawFlashPromptCommunicator implements FaceclawBleListener {
emitLog("prompt page shown on " + address); emitLog("prompt page shown on " + address);
} }
/**
* Read each arm's battery via a sid-0x09 settings read on that arm's own
* link (the arms have independent batteries and each answers with its
* own). An arm that does not answer reports -1; the caller decides what
* to do with a partial reading.
*/
private void readBatteries() throws InterruptedException {
int right = rightConnected ? readBattery(rightAddress, "right") : -1;
int left = leftConnected ? readBattery(leftAddress, "left") : -1;
emitLog("battery R=" + (right < 0 ? "?" : right + "%") + " L=" + (left < 0 ? "?" : left + "%"));
emitBattery(right, left);
}
private int readBattery(String address, String arm) throws InterruptedException {
for (int attempt = 0; attempt < 2 && !cancelled; attempt++) {
int magic = allocMagic();
byte[] ack = writeAndAwaitAck(
address,
BleProtocol.SID_UI_SETTING,
BleProtocol.FLAG_REQUEST,
magic,
BleProtocol.buildSettingsQuery(magic),
BATTERY_ACK_TIMEOUT_MS);
if (ack == null) {
emitLog("battery read attempt " + (attempt + 1) + " unacked: " + arm + " arm");
continue;
}
BleProtocol.BatterySnapshot snapshot = BleProtocol.parseSettingsBattery(ack);
if (snapshot != null) {
return snapshot.battery;
}
emitLog("battery read ack had no battery field: " + arm + " arm");
}
return -1;
}
/** Write and wait for the matching ack; returns the ack's protobuf (may be empty), or null on timeout/write failure. */ /** Write and wait for the matching ack; returns the ack's protobuf (may be empty), or null on timeout/write failure. */
private byte[] writeAndAwaitAck(String address, int sid, int flag, int magic, byte[] payload, int timeoutMs) private byte[] writeAndAwaitAck(String address, int sid, int flag, int magic, byte[] payload, int timeoutMs)
throws InterruptedException { throws InterruptedException {
@@ -312,6 +415,7 @@ public class FaceclawFlashPromptCommunicator implements FaceclawBleListener {
} catch (Exception ignored) { } catch (Exception ignored) {
} }
rightConnected = false; rightConnected = false;
leftConnected = false;
} }
@Override @Override
@@ -371,6 +475,13 @@ public class FaceclawFlashPromptCommunicator implements FaceclawBleListener {
if (connected) { if (connected) {
return; return;
} }
if (address.equalsIgnoreCase(leftAddress)) {
// The prompt itself only needs the right arm; a dropped left link
// just means no left battery reading.
leftConnected = false;
emitLog("left arm disconnected");
return;
}
if (address.equalsIgnoreCase(rightAddress)) { if (address.equalsIgnoreCase(rightAddress)) {
rightConnected = false; rightConnected = false;
synchronized (lock) { synchronized (lock) {
@@ -415,6 +526,15 @@ public class FaceclawFlashPromptCommunicator implements FaceclawBleListener {
}); });
} }
private void emitBattery(int rightPercent, int leftPercent) {
mainHandler.post(() -> {
FaceclawFlashPromptListener current = listener;
if (current != null) {
current.onBattery(rightPercent, leftPercent);
}
});
}
private void emitResult(boolean approvedResult) { private void emitResult(boolean approvedResult) {
mainHandler.post(() -> { mainHandler.post(() -> {
FaceclawFlashPromptListener current = listener; FaceclawFlashPromptListener current = listener;
@@ -6,11 +6,18 @@ public interface FaceclawFlashPromptListener {
/** /**
* Lifecycle updates. `state` is one of: connecting, connected, prompting, * Lifecycle updates. `state` is one of: connecting, connected, prompting,
* result, cancelled, timeout, disconnected, error. `detail` carries the * battery, result, cancelled, timeout, disconnected, error. `detail` carries the
* "approved"/"declined" text for result, or an error/explanation message. * "approved"/"declined" text for result, or an error/explanation message.
*/ */
void onState(String state, String detail); void onState(String state, String detail);
/** Fires once the user picks a menu row: true = flash, false = cancel. */ /**
* Battery percent of each arm, read after the user approved (or right
* after auth when the prompt is skipped); -1 when an arm didn't answer.
* Always fires before onResult(true).
*/
void onBattery(int rightPercent, int leftPercent);
/** Fires once the user picks a menu row (or, with skipPrompt, once the battery is read): true = flash, false = cancel. */
void onResult(boolean approved); void onResult(boolean approved);
} }
+11 -14
View File
@@ -1,23 +1,20 @@
# Changelog # Changelog
## 0.6.4 - Future ## 0.6.4 - 2026-09-02
* Context menus are centered and include window title * Context menus are centered and include window title
* Long-press and short-then-long with a context menu open switches between context menus * Long-press and short-then-long with a context menu open switches between context menus
* Developer speed metrics include bytes/frame * Developer speed metrics include bytes/frame
* The custom firmware uninstaller flashes 2.2.9.22, not 2.2.6.10
Compass app: * Compass app: Increase sample rate from 1/s to ~3/s
* Increase sample rate and minimum-change for the compass app * Compass app: Handle the distinction between true north and magnetic north
* Compass now handles the distincitn between true north and magnetic north
* EvenHub compass readings now include calibrated magnetic, declination and true headings * EvenHub compass readings now include calibrated magnetic, declination and true headings
* Files app: Viewing image files gamma-corrects and dithers them
Files app: * Watch app: Uses ambient mode so the watch no longer blurs when idle
* Viewing image files gamma-corrects and dithers them * Watch app: Fix flicker on waking the watch
* Watch app: Tapping the idle watch to wake it counts as a tap on the pad
Watch app: * Watch app: Remove a number of unfinished prototype features
* Ambient mode: the watch no longer blurs when idle * Firmware flasher checks for glasses battery>30% before starting
* Fix flicker on waking the watch * Fix a problem in 0.6.3 where it would abort before starting a custom firmware install with a checksum error
* Tapping the idle watch to wake it counts as a tap on the pad
* Remove a number of unfinished prototype features
## 0.6.3 - 2026-09-01 ## 0.6.3 - 2026-09-01
* Update custom firmware base version from 2.2.6 to 2.2.9 * Update custom firmware base version from 2.2.6 to 2.2.9
+9 -2
View File
@@ -254,8 +254,15 @@ function buildCommon(version: 1 | 3): string {
const fields: Record<string, string | number> = { const fields: Record<string, string | number> = {
platform: "16", platform: "16",
package: "com.even.sg", package: "com.even.sg",
versionName: "2.2.6", // versionName/build must be a real shipped pair of the official Android
build: "114", // app (versionName/versionCode from its manifest): 2.2.8 = versionCode 122
// (captures/even-2.2.8-base.apk). Earlier this said 2.2.6 with build 114,
// but 114 was actually 2.2.4's versionCode (see notes/firmware-download.md).
// buildTime is not a literal in the app binary (computed at runtime), so
// it still carries the value from the 2.2.4 capture; the API has accepted
// the mismatch so far.
versionName: "2.2.8",
build: "122",
brand: "Google", brand: "Google",
model: "Pixel 7a", model: "Pixel 7a",
osVersion: "16", osVersion: "16",
+11 -4
View File
@@ -1,6 +1,7 @@
/** /**
* Builds the Faceclaw custom firmware on-device: downloads the stock Even * Builds the Faceclaw custom firmware on-device: downloads the stock Even
* Realities G2 2.2.6.10 image from Even's CDN, verifies its SHA-256, applies * Realities G2 image the patch set was built against (CFW_PATCH_SET.base,
* currently 2.2.9.22) from Even's CDN, verifies its SHA-256, applies
* the committed byte-patch set (cfw-patches.ts), extracts the stock EvenHub * the committed byte-patch set (cfw-patches.ts), extracts the stock EvenHub
* fonts for phone-side rendering, verifies the patched SHA-256, and writes the * fonts for phone-side rendering, verifies the patched SHA-256, and writes the
* result to app storage. * result to app storage.
@@ -24,9 +25,15 @@ import { EvenHubFont } from "../graphics/evenhub-font";
declare const com: any; declare const com: any;
const FIRMWARE_URL = "https://cdn.evenreal.co/firmware/e28738432d7b612d625331b00383149b.bin"; // The CDN names firmware files by MD5. This must be the image whose SHA-256 is
const CFW_OUTPUT_FILENAME = "g2_2.2.6.10_cfw.bin"; // CFW_PATCH_SET.baseSha256 — keep it in sync with FW_URL in g2flash/build_cfw.sh
const STOCK_OUTPUT_FILENAME = "g2_2.2.6.10.bin"; // whenever cfw-patches.ts is regenerated against a new stock base.
// (2.2.9.22 = fc250b05…; the older 2.2.6.10 base was e2873843….)
const FIRMWARE_URL = "https://cdn.evenreal.co/firmware/fc250b05e98a9ff998b4b68f5f99f994.bin";
// Output names follow the patch set's base name (e.g. g2_2.2.9.22.bin →
// g2_2.2.9.22_cfw.bin) so a rebase can't leave stale version numbers here.
const STOCK_OUTPUT_FILENAME = CFW_PATCH_SET.base;
const CFW_OUTPUT_FILENAME = CFW_PATCH_SET.base.replace(/\.bin$/, "") + "_cfw.bin";
export type FirmwareProgress = export type FirmwareProgress =
| { phase: "downloading" } | { phase: "downloading" }
+9 -3
View File
@@ -21,10 +21,16 @@ type FontSpec = {
}; };
// Priority order is the stock EvenHub fallback chain (before the CJK font). // Priority order is the stock EvenHub fallback chain (before the CJK font).
// These are lv_font_fmt_txt_dsc_t addresses in the stock image the patch set
// is built against (CFW_PATCH_SET.base), so they move on every firmware
// rebase: run scripts/find-firmware-fonts.py against the new stock .bin and
// match rows by cmap count / code-point count (12/8081, 9/9566, 4/11590).
// 2.2.9.22: 0x007a8954, 0x007a8968, 0x007a8878
// 2.2.6.10: 0x0077f414, 0x0077f428, 0x0077f374
const FONT_SPECS: FontSpec[] = [ const FONT_SPECS: FontSpec[] = [
{ descriptor: 0x0077f414, lineHeight: 27, baseLine: 5 }, { descriptor: 0x007a8954, lineHeight: 27, baseLine: 5 },
{ descriptor: 0x0077f428, lineHeight: 26, baseLine: 5 }, { descriptor: 0x007a8968, lineHeight: 26, baseLine: 5 },
{ descriptor: 0x0077f374, lineHeight: 20, baseLine: 2 }, { descriptor: 0x007a8878, lineHeight: 20, baseLine: 2 },
]; ];
type ExtractedGlyph = { type ExtractedGlyph = {
+33 -4
View File
@@ -6,20 +6,32 @@ export type FlashPromptState =
| "connecting" | "connecting"
| "connected" | "connected"
| "prompting" | "prompting"
| "battery"
| "result" | "result"
| "cancelled" | "cancelled"
| "timeout" | "timeout"
| "disconnected" | "disconnected"
| "error"; | "error";
/** Per-arm battery percent; null when that arm didn't answer. */
export type FlashPromptBattery = { right: number | null; left: number | null };
function normalizePercent(value: number): number | null {
const n = Number(value);
return Number.isFinite(n) && n >= 0 ? n : null;
}
/** /**
* TS wrapper around the native FaceclawFlashPromptCommunicator — the * TS wrapper around the native FaceclawFlashPromptCommunicator — the
* stock-firmware-compatible BLE path that shows the pre-flash confirmation on * stock-firmware-compatible BLE path that shows the pre-flash confirmation on
* the glasses and reports the user's Yes/No choice. Separate from * the glasses and reports the user's Yes/No choice. Separate from
* FaceclawCommunicatorBridge on purpose (different, minimal protocol subset). * FaceclawCommunicatorBridge on purpose (different, minimal protocol subset).
* *
* Talks to the right arm only: the lenses relay messages between themselves, * Connects and authenticates both arms (so any OS pairing prompts happen up
* and acks/events always come from the right arm. * front, before flashing), shows the prompt via the right arm (the lenses relay
* messages between themselves, and acks/events always come from the right
* arm), then reads each arm's battery. With `skipPrompt` the on-glasses
* confirmation is omitted and only the battery is read.
*/ */
export class FlashPromptCommunicator { export class FlashPromptCommunicator {
private readonly communicator: any; private readonly communicator: any;
@@ -27,20 +39,32 @@ export class FlashPromptCommunicator {
private readonly logListeners = new Set<(line: string) => void>(); private readonly logListeners = new Set<(line: string) => void>();
private readonly stateListeners = new Set<(state: FlashPromptState, detail: string) => void>(); private readonly stateListeners = new Set<(state: FlashPromptState, detail: string) => void>();
private readonly resultListeners = new Set<(approved: boolean) => void>(); private readonly resultListeners = new Set<(approved: boolean) => void>();
private readonly batteryListeners = new Set<(battery: FlashPromptBattery) => void>();
constructor(rightAddress: string, warningText: string) { constructor(
addresses: { right: string; left: string },
warningText: string,
options?: { skipPrompt?: boolean },
) {
const context = Utils.android.getApplicationContext(); const context = Utils.android.getApplicationContext();
if (!context) throw new Error("Android application context unavailable"); if (!context) throw new Error("Android application context unavailable");
this.communicator = new com.faceclaw.app.FaceclawFlashPromptCommunicator( this.communicator = new com.faceclaw.app.FaceclawFlashPromptCommunicator(
context, context,
rightAddress, addresses.right,
addresses.left,
warningText, warningText,
Boolean(options?.skipPrompt),
); );
this.listenerProxy = new com.faceclaw.app.FaceclawFlashPromptListener({ this.listenerProxy = new com.faceclaw.app.FaceclawFlashPromptListener({
onLog: (line: string) => this.emit(this.logListeners, String(line)), onLog: (line: string) => this.emit(this.logListeners, String(line)),
onState: (state: string, detail: string) => onState: (state: string, detail: string) =>
this.emit(this.stateListeners, String(state) as FlashPromptState, String(detail ?? "")), this.emit(this.stateListeners, String(state) as FlashPromptState, String(detail ?? "")),
onBattery: (rightPercent: number, leftPercent: number) =>
this.emit(this.batteryListeners, {
right: normalizePercent(rightPercent),
left: normalizePercent(leftPercent),
}),
onResult: (approved: boolean) => this.emit(this.resultListeners, Boolean(approved)), onResult: (approved: boolean) => this.emit(this.resultListeners, Boolean(approved)),
}); });
this.communicator.setListener(this.listenerProxy); this.communicator.setListener(this.listenerProxy);
@@ -56,6 +80,11 @@ export class FlashPromptCommunicator {
return () => this.stateListeners.delete(listener); return () => this.stateListeners.delete(listener);
} }
onBattery(listener: (battery: FlashPromptBattery) => void): () => void {
this.batteryListeners.add(listener);
return () => this.batteryListeners.delete(listener);
}
onResult(listener: (approved: boolean) => void): () => void { onResult(listener: (approved: boolean) => void): () => void {
this.resultListeners.add(listener); this.resultListeners.add(listener);
return () => this.resultListeners.delete(listener); return () => this.resultListeners.delete(listener);
+83 -23
View File
@@ -14,7 +14,11 @@ import {
} from "../g2/firmware-builder"; } from "../g2/firmware-builder";
import { buildAddressSet, DeviceDiscoveryBridge } from "../native/device-discovery"; import { buildAddressSet, DeviceDiscoveryBridge } from "../native/device-discovery";
import { FirmwareFlasher, FlashProgress, FlashState } from "../native/firmware-flasher"; import { FirmwareFlasher, FlashProgress, FlashState } from "../native/firmware-flasher";
import { FlashPromptCommunicator, FlashPromptState } from "../native/flash-prompt-communicator"; import {
FlashPromptBattery,
FlashPromptCommunicator,
FlashPromptState,
} from "../native/flash-prompt-communicator";
import { resumeAutoReconnect, suppressAutoReconnect } from "../g2/reconnect-policy"; import { resumeAutoReconnect, suppressAutoReconnect } from "../g2/reconnect-policy";
import { setOnboardingCompleted, setPreviewOnlyMode } from "./onboarding-state"; import { setOnboardingCompleted, setPreviewOnlyMode } from "./onboarding-state";
import { formatErrorMessage } from "../util/format-error"; import { formatErrorMessage } from "../util/format-error";
@@ -23,6 +27,10 @@ type FlashPhase = "intro" | "prompt" | "building" | "ready" | "flashing" | "flas
export type FlashMode = "install" | "uninstall"; export type FlashMode = "install" | "uninstall";
// Flashing a lens takes minutes and the glasses reboot afterwards; refuse to
// start when either arm is below this so a flat battery can't interrupt it.
const MIN_FLASH_BATTERY_PERCENT = 30;
export class OnboardingFlashViewModel extends Observable { export class OnboardingFlashViewModel extends Observable {
private readonly mode: FlashMode; private readonly mode: FlashMode;
private readonly fromOnboarding: boolean; private readonly fromOnboarding: boolean;
@@ -40,6 +48,7 @@ export class OnboardingFlashViewModel extends Observable {
private prompt: FlashPromptCommunicator | null = null; private prompt: FlashPromptCommunicator | null = null;
private promptUnsubscribers: Array<() => void> = []; private promptUnsubscribers: Array<() => void> = [];
private promptBattery: FlashPromptBattery | null = null;
private flasher: FirmwareFlasher | null = null; private flasher: FirmwareFlasher | null = null;
private flasherUnsubscribers: Array<() => void> = []; private flasherUnsubscribers: Array<() => void> = [];
private retryAction: () => void = () => this.beginPrompt(); private retryAction: () => void = () => this.beginPrompt();
@@ -55,10 +64,10 @@ export class OnboardingFlashViewModel extends Observable {
this._headline = this.mode === "uninstall" ? "Uninstall Custom Firmware" : "Flash Custom Firmware"; this._headline = this.mode === "uninstall" ? "Uninstall Custom Firmware" : "Flash Custom Firmware";
this._status = this._status =
this.mode === "uninstall" this.mode === "uninstall"
? "This connects to your glasses, asks for confirmation on the lens, then downloads and reflashes the " + ? "This connects to your glasses, asks for confirmation on the lens, checks the battery, then downloads " +
"official firmware — removing Faceclaw's custom features." "and reflashes the official firmware — removing Faceclaw's custom features."
: "This connects to your glasses, asks for confirmation on the lens, then downloads, verifies, and flashes " + : "This connects to your glasses, asks for confirmation on the lens, checks the battery, then downloads, " +
"Faceclaw's custom firmware."; "verifies, and flashes Faceclaw's custom firmware.";
} }
// Kept short to fit the glasses' ~50-column text grid. // Kept short to fit the glasses' ~50-column text grid.
@@ -219,15 +228,24 @@ export class OnboardingFlashViewModel extends Observable {
// --- prompt flow ----------------------------------------------------------- // --- prompt flow -----------------------------------------------------------
private async beginPrompt(): Promise<void> { /**
* Connect to both arms, authenticate (this is where any Android pairing
* prompts appear), show the Yes/No confirmation on the lens, then read the
* battery. With `skipPrompt` (retrying after a low-battery refusal, when
* the user has already confirmed) the on-glasses confirmation is skipped
* and only the battery is re-checked.
*/
private async beginPrompt(options?: { skipPrompt?: boolean }): Promise<void> {
const skipPrompt = Boolean(options?.skipPrompt);
if (!global.isAndroid) { if (!global.isAndroid) {
this.toError("Flashing is only available on Android.", () => this.beginPrompt()); this.toError("Flashing is only available on Android.", () => this.beginPrompt(options));
return; return;
} }
this.setPhase("prompt"); this.setPhase("prompt");
this.headline = "Confirm On Your Glasses"; this.headline = skipPrompt ? "Checking Battery" : "Confirm On Your Glasses";
this.log = ""; this.log = "";
this.busy = true; this.busy = true;
this.promptBattery = null;
this.status = "Preparing to connect. Make sure your glasses are on and the Even app is disconnected."; this.status = "Preparing to connect. Make sure your glasses are on and the Even app is disconnected.";
try { try {
@@ -237,40 +255,50 @@ export class OnboardingFlashViewModel extends Observable {
this.busy = false; this.busy = false;
this.toError( this.toError(
"Couldn't find both glasses arms. Make sure the glasses are powered on and the Even app is disconnected, then retry.", "Couldn't find both glasses arms. Make sure the glasses are powered on and the Even app is disconnected, then retry.",
() => this.beginPrompt(), () => this.beginPrompt(options),
); );
return; return;
} }
this.addresses = addresses; this.addresses = addresses;
this.status = "Connecting to your glasses. Watch the lens for a Yes/No prompt."; this.status = skipPrompt
this.startCommunicator(addresses); ? "Connecting to your glasses to re-check the battery..."
: "Connecting to your glasses. Watch the lens for a Yes/No prompt.";
this.startCommunicator(addresses, skipPrompt);
} catch (error) { } catch (error) {
this.busy = false; this.busy = false;
this.toError(this.formatError(error), () => this.beginPrompt()); this.toError(this.formatError(error), () => this.beginPrompt(options));
} }
} }
private startCommunicator(addresses: { right: string; left: string }): void { private startCommunicator(addresses: { right: string; left: string }, skipPrompt: boolean): void {
this.disposePrompt(); this.disposePrompt();
const prompt = new FlashPromptCommunicator(addresses.right, this.glassesWarning); const prompt = new FlashPromptCommunicator(addresses, this.glassesWarning, { skipPrompt });
this.prompt = prompt; this.prompt = prompt;
this.promptUnsubscribers.push( this.promptUnsubscribers.push(
prompt.onLog((line) => this.appendLog(line)), prompt.onLog((line) => this.appendLog(line)),
prompt.onStateChange((state, detail) => this.handlePromptState(state, detail)), prompt.onStateChange((state, detail) => this.handlePromptState(state, detail, skipPrompt)),
prompt.onResult((approved) => this.handlePromptResult(approved)), prompt.onBattery((battery) => {
this.promptBattery = battery;
}),
prompt.onResult((approved) => this.handlePromptResult(approved, skipPrompt)),
); );
prompt.start(); prompt.start();
} }
private handlePromptState(state: FlashPromptState, detail: string): void { private handlePromptState(state: FlashPromptState, detail: string, skipPrompt: boolean): void {
switch (state) { switch (state) {
case "connecting": case "connecting":
this.status = "Connecting to your glasses..."; this.status = "Connecting to your glasses...";
break; break;
case "connected": case "connected":
this.status = "Connected. Showing the confirmation on the lens..."; this.status =
"Connected. Pairing with both lenses — if Android asks to pair, accept it (once per lens)." +
(skipPrompt ? "" : " Then watch the lens for the confirmation.");
break;
case "battery":
this.status = "Checking the glasses' battery level...";
break; break;
case "prompting": case "prompting":
this.status = this.status =
@@ -289,25 +317,57 @@ export class OnboardingFlashViewModel extends Observable {
break; break;
case "disconnected": case "disconnected":
this.busy = false; this.busy = false;
this.toError(detail || "Lost connection to the glasses.", () => this.beginPrompt()); this.toError(detail || "Lost connection to the glasses.", () => this.beginPrompt({ skipPrompt }));
break; break;
case "error": case "error":
this.busy = false; this.busy = false;
this.toError(detail || "Connection failed.", () => this.beginPrompt()); this.toError(detail || "Connection failed.", () => this.beginPrompt({ skipPrompt }));
break; break;
} }
} }
private handlePromptResult(approved: boolean): void { private handlePromptResult(approved: boolean, skipPrompt: boolean): void {
this.disposePrompt(); this.disposePrompt();
if (!approved) { if (!approved) {
this.busy = false; this.busy = false;
this.toError("You declined on the glasses. No firmware was written.", () => this.beginPrompt()); this.toError("You declined on the glasses. No firmware was written.", () => this.beginPrompt());
return; return;
} }
const lowBattery = this.describeLowBattery(this.promptBattery);
if (lowBattery) {
this.busy = false;
// The user already confirmed on the lens; a retry only re-checks the battery.
this.toError(lowBattery, () => this.beginPrompt({ skipPrompt: true }), "Charge Your Glasses");
return;
}
if (!this.promptBattery || (this.promptBattery.right === null && this.promptBattery.left === null)) {
this.appendLog("battery level unknown; proceeding");
}
this.appendLog(skipPrompt ? "battery ok; confirmed earlier on the lens" : "confirmed on the lens; battery ok");
void this.buildFirmware(); void this.buildFirmware();
} }
/** A "charge first" message when either arm is below the flashing threshold, else null. */
private describeLowBattery(battery: FlashPromptBattery | null): string | null {
if (!battery) {
return null;
}
const readings = [
{ arm: "right", percent: battery.right },
{ arm: "left", percent: battery.left },
].filter((r): r is { arm: string; percent: number } => r.percent !== null);
const low = readings.filter((r) => r.percent < MIN_FLASH_BATTERY_PERCENT);
if (low.length === 0) {
return null;
}
const levels = readings.map((r) => `${r.arm} ${r.percent}%`).join(", ");
return (
`The glasses' battery is too low to flash safely (${levels}). ` +
`Charge both lenses to at least ${MIN_FLASH_BATTERY_PERCENT}%, then tap Retry to check again. ` +
"You won't need to confirm on the lens a second time."
);
}
private cancelPrompt(): void { private cancelPrompt(): void {
this.status = "Cancelling..."; this.status = "Cancelling...";
try { try {
@@ -502,11 +562,11 @@ export class OnboardingFlashViewModel extends Observable {
}); });
} }
private toError(message: string, retry: () => void): void { private toError(message: string, retry: () => void, headline = "Something Went Wrong"): void {
this.retryAction = retry; this.retryAction = retry;
this.status = message; this.status = message;
this.setPhase("error"); this.setPhase("error");
this.headline = "Something Went Wrong"; this.headline = headline;
} }
private setPhase(phase: FlashPhase): void { private setPhase(phase: FlashPhase): void {