Files
faceclaw/app/native/faceclaw-communicator.ts
T

796 lines
29 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
import type { GlassesType } from "../ui/dashboard-settings";
import type { RingInput } from "../g2/ring-input";
import { ImageSource, Utils } from "@nativescript/core";
import * as frameTimings from "./frame-timings";
import { JavaDirectBuffer } from "./java-direct-buffer";
declare const com: any;
const PREVIEW_BRIGHTEN_GAMMA = 0.7;
export type CommunicatorPhase =
| "disconnected"
| "connecting"
| "connected"
| "charging"
| "retrying"
| "unpaired"
| "incompatible-firmware"
| "disconnecting";
export type CommunicatorState = {
phase: CommunicatorPhase;
status: string;
};
export type HeadsetBatteryState = {
battery: number;
chargingStatus: number;
ringBattery?: number;
ringChargingStatus?: number;
};
/**
* A charging-case reading, as the glasses relay it. battery is 0..100, or null when the reading
* has none (the glasses are out of the case). charging (the case is on USB) is only known while
* docked.
*/
export type CaseBatteryState = { battery: number | null; charging: boolean; docked: boolean };
export type FrameMetrics = {
paintMs: number;
transmitMs: number;
tileCount: number;
};
import { REQUIRED_FACECLAW_FIRMWARE_VERSION, type FirmwareInfo } from "../g2/firmware-compat";
export type { FirmwareInfo };
/**
* Compositor surface configuration. Position/size are in screen pixels;
* surfaces composite in ascending zOrder onto a black background. A
* "color-key" surface treats pixel value 0 as transparent and 1 as black
* (painters must clamp intentional black to 1); "opaque" surfaces cover
* their whole rect.
*/
export type SurfaceOptions = {
x: number;
y: number;
width: number;
height: number;
zOrder: number;
transparency: "opaque" | "color-key";
};
export type RawInputEvent = { ringInput?: RingInput } & (
| {
kind: "list-click";
containerName: string;
eventType: number;
eventSource: number;
systemExitReasonCode: number;
frameId: number;
}
| {
kind: "text-click";
containerName: string;
eventType: number;
eventSource: number;
systemExitReasonCode: number;
frameId: number;
}
| {
kind: "sys-event";
containerName: string;
eventType: number;
eventSource: number;
systemExitReasonCode: number;
frameId: number;
}
| {
/**
* Stock Even AI app (sid 0x07), not EvenHub. `eventType` carries
* eEvenAIStatus -- see EvenAIStatus in app/g2/events.ts. The only one we
* act on is EVEN_AI_WAKE_UP, i.e. the "Hey Even" wakeword.
*/
kind: "even-ai";
containerName: string;
eventType: number;
eventSource: number;
systemExitReasonCode: number;
frameId: number;
}
| {
/**
* Synthetic directional gesture from the Wear OS remote; `eventType` is
* a WatchGestureType (app/g2/events.ts). Never produced by Java.
*/
kind: "watch-gesture";
containerName: string;
eventType: number;
eventSource: number;
systemExitReasonCode: number;
frameId: number;
}
| {
/**
* Stock display-lifecycle wake observed after a ring or arm double tap
* while Faceclaw's EvenHub page is suspended.
*/
kind: "display-wake";
containerName: string;
eventType: number;
eventSource: number;
systemExitReasonCode: number;
frameId: number;
});
function nonNegativeNumber(value: number): number {
const numeric = Number(value);
return Number.isFinite(numeric) ? Math.max(0, numeric) : 0;
}
/** A 0..1 brightness factor as the compositor's 0..256 fixed-point form. */
export function dimFactor256(factor: number): number {
return Math.round(Math.max(0, Math.min(1, factor)) * 256);
}
export class FaceclawCommunicatorBridge {
private readonly communicator: any;
private readonly listenerProxy: any;
private javaCallQueue: Promise<void> = Promise.resolve();
/** Calls waiting on javaCallQueue; 0 means enqueueJavaCall's fast path is safe. */
private queuedJavaCalls = 0;
/** Queued calls that may change what a surface holds; see isSurfaceCurrent. */
private queuedSurfaceChanges = 0;
// Reused Java-side buffers for byte payloads; passing a JS ArrayBuffer to
// Java leaks it (see java-direct-buffer.ts). Loaded inside the queued call,
// immediately before the synchronous Java call that consumes them.
private readonly framePixelsBuffer = new JavaDirectBuffer(640 * 480);
private readonly frameDrawsBuffer = new JavaDirectBuffer();
private readonly shellSceneBuffer = new JavaDirectBuffer();
private readonly buzzerBuffer = new JavaDirectBuffer();
private readonly frameMetricWaiters = new Set<(metrics: FrameMetrics) => void>();
// Recent frame-finished outcomes from the Java side, so waitForFrameFinished
// does not race against finishes that land before the wait starts.
private readonly finishedFrameOutcomes = new Map<number, string>();
private readonly frameFinishedWaiters = new Map<number, Set<(outcome: string) => void>>();
private readonly stateListeners = new Set<(state: CommunicatorState) => void>();
private readonly ringListeners = new Set<(event: RawInputEvent) => void>();
private readonly batteryListeners = new Set<(state: HeadsetBatteryState) => void>();
private readonly caseListeners = new Set<(state: CaseBatteryState) => void>();
private readonly silentModeListeners = new Set<(silent: boolean) => void>();
private readonly wearStateListeners = new Set<(wearing: boolean) => void>();
private readonly phoneLockStateListeners = new Set<(locked: boolean) => void>();
private latestWearState: boolean | null = null;
private latestPhoneLockState: boolean | null = null;
private readonly evenAppConflictListeners = new Set<(message: string) => void>();
private readonly frameMetricsListeners = new Set<(metrics: FrameMetrics) => void>();
private readonly firmwareInfoListeners = new Set<(info: FirmwareInfo) => void>();
private readonly previewAnimationListeners = new Set<() => void>();
constructor(addresses: { right: string; left: string; ring?: string; ringRole?: string; glassesType?: GlassesType }) {
const context = Utils.android.getApplicationContext();
if (!context) throw new Error("Android application context unavailable");
this.communicator = new com.faceclaw.app.FaceclawBleCommunicator(
context,
addresses.right,
addresses.left,
addresses.ring ?? "",
);
// The shared session halts on any other firmware ("incompatible-firmware").
this.communicator.setRequiredFirmwareRevision(REQUIRED_FACECLAW_FIRMWARE_VERSION);
// RayNeo iO: one link (its address in both arm slots), its own handshake and page lease.
if (addresses.glassesType === "rayneo-io") this.communicator.useRayNeoIo();
// Which R1 role the direct ring link claims; only matters with a ring address.
if (addresses.ringRole) this.communicator.setDirectRingRole(addresses.ringRole);
this.listenerProxy = new com.faceclaw.app.FaceclawBleCommunicatorListener({
onStateChange: (phase: string, status: string) => {
const state = {
phase: String(phase) as CommunicatorPhase,
status: String(status),
};
this.emitAsync(this.stateListeners, state);
},
onRingEvent: (
kind: string,
containerName: string,
eventType: number,
eventSource: number,
systemExitReasonCode: number,
frameId: number,
ringTick: number, ringType: number, ringAux: number, ringSpeed: number,
) => {
const event = {
kind: String(kind) as RawInputEvent["kind"],
containerName: String(containerName),
eventType: Number(eventType),
eventSource: Number(eventSource),
systemExitReasonCode: Number(systemExitReasonCode),
frameId: Number(frameId),
ringInput: Number(ringTick) >= 0 ? { tick: Number(ringTick), type: Number(ringType),
aux: Number(ringAux), speed: Number(ringSpeed) } : undefined,
};
frameTimings.logFrame(event.frameId, "input event received on JS side");
this.emitAsync(this.ringListeners, event);
},
onBatteryState: (headsetBattery: number, headsetCharging: number, ringBattery: number, ringCharging: number) => {
const state = {
battery: Number(headsetBattery),
chargingStatus: Number(headsetCharging),
ringBattery: Number(ringBattery),
ringChargingStatus: Number(ringCharging),
};
this.emitAsync(this.batteryListeners, state);
},
onCaseState: (caseBattery: number, caseCharging: number, caseDocked: boolean) => {
const battery = Number(caseBattery);
this.emitAsync(this.caseListeners, {
battery: Number.isInteger(battery) && battery >= 0 && battery <= 100 ? battery : null,
charging: Number(caseCharging) > 0,
docked: Boolean(caseDocked),
});
},
onSilentMode: (silent: boolean) => {
this.emitAsync(this.silentModeListeners, Boolean(silent));
},
onWearState: (wearing: boolean) => {
this.latestWearState = Boolean(wearing);
this.emitAsync(this.wearStateListeners, this.latestWearState);
},
onPhoneLockState: (locked: boolean) => {
this.latestPhoneLockState = Boolean(locked);
this.emitAsync(this.phoneLockStateListeners, this.latestPhoneLockState);
},
onEvenAppConflict: (message: string) => {
this.emitAsync(this.evenAppConflictListeners, String(message));
},
onFrameMetrics: (paintMs: number, transmitMs: number, tileCount: number) => {
const metrics = {
paintMs: nonNegativeNumber(paintMs),
transmitMs: nonNegativeNumber(transmitMs),
tileCount: nonNegativeNumber(tileCount),
};
const waiters = Array.from(this.frameMetricWaiters);
this.frameMetricWaiters.clear();
for (const waiter of waiters) {
setTimeout(() => waiter(metrics), 0);
}
this.emitAsync(this.frameMetricsListeners, metrics);
},
onFrameFinished: (frameId: number, outcome: string) => {
this.recordFrameFinished(Number(frameId), String(outcome));
},
onFirmwareInfo: (leftVersion: string, rightVersion: string, extension: string) => {
const info: FirmwareInfo = {
leftVersion: String(leftVersion),
rightVersion: String(rightVersion),
extension: String(extension),
};
this.emitAsync(this.firmwareInfoListeners, info);
},
});
this.communicator.setListener(this.listenerProxy);
// Already posted to the main looper by the Java side.
this.communicator.setPreviewAnimationListener(
new java.lang.Runnable({
run: () => {
for (const listener of Array.from(this.previewAnimationListeners)) listener();
},
}),
);
}
private emitAsync<T>(listeners: Set<(value: T) => void>, value: T): void {
const snapshot = Array.from(listeners);
setTimeout(() => {
for (const listener of snapshot) {
listener(value);
}
}, 0);
}
/**
* Run a Java call, ordered against every other call made through here.
*
* inlineWhenIdle runs the call on the spot when nothing is queued ahead of
* it. Ordering still holds — the fast path only fires when no earlier call
* is waiting — and it skips a task-queue hop that measured ~18ms on device
* (the gap between "span submit start" and the Java side's own log line in
* the frame timings), which is pure latency on a call the caller is already
* awaiting. Off by default: a call that might block for a while should keep
* yielding to the main looper first.
*
* preservesSurfaces marks a call that neither changes a surface's retained
* content nor leaves a change waiting for a later composite (it composites
* itself), so having it queued does not make isSurfaceCurrent answer false.
*/
private enqueueJavaCall<T>(operation: () => T, inlineWhenIdle = false, preservesSurfaces = false): Promise<T> {
if (inlineWhenIdle && this.queuedJavaCalls === 0) {
try {
return Promise.resolve(operation());
} catch (error) {
return Promise.reject(error);
}
}
this.queuedJavaCalls++;
if (!preservesSurfaces) this.queuedSurfaceChanges++;
const run = () =>
new Promise<T>((resolve, reject) => {
setTimeout(() => {
this.queuedJavaCalls--;
if (!preservesSurfaces) this.queuedSurfaceChanges--;
try {
resolve(operation());
} catch (error) {
reject(error);
}
}, 0);
});
const result = this.javaCallQueue.then(run, run);
this.javaCallQueue = result.then(
() => undefined,
() => undefined,
);
return result;
}
onStateChange(listener: (state: CommunicatorState) => void): () => void {
this.stateListeners.add(listener);
return () => this.stateListeners.delete(listener);
}
onRingEvent(listener: (event: RawInputEvent) => void): () => void {
this.ringListeners.add(listener);
return () => this.ringListeners.delete(listener);
}
onBatteryState(listener: (state: HeadsetBatteryState) => void): () => void {
this.batteryListeners.add(listener);
return () => this.batteryListeners.delete(listener);
}
/**
* Charging-case readings: read at session start and on docking, then pushed by the glasses
* on every change, including leaving the case.
*/
onCaseState(listener: (state: CaseBatteryState) => void): () => void {
this.caseListeners.add(listener);
return () => this.caseListeners.delete(listener);
}
/**
* Silent mode, toggled on the glasses by long-pressing both touchpads. While
* it is on the firmware ignores all input and blanks the display.
*/
onSilentMode(listener: (silent: boolean) => void): () => void {
this.silentModeListeners.add(listener);
return () => this.silentModeListeners.delete(listener);
}
onWearState(listener: (wearing: boolean) => void): () => void {
this.wearStateListeners.add(listener);
if (this.latestWearState !== null) {
const wearing = this.latestWearState;
setTimeout(() => {
if (this.wearStateListeners.has(listener)) listener(wearing);
}, 0);
}
return () => this.wearStateListeners.delete(listener);
}
onPhoneLockState(listener: (locked: boolean) => void): () => void {
this.phoneLockStateListeners.add(listener);
if (this.latestPhoneLockState !== null) {
const locked = this.latestPhoneLockState;
setTimeout(() => {
if (this.phoneLockStateListeners.has(listener)) listener(locked);
}, 0);
}
return () => this.phoneLockStateListeners.delete(listener);
}
onEvenAppConflict(listener: (message: string) => void): () => void {
this.evenAppConflictListeners.add(listener);
return () => this.evenAppConflictListeners.delete(listener);
}
onFrameMetrics(listener: (metrics: FrameMetrics) => void): () => void {
this.frameMetricsListeners.add(listener);
return () => this.frameMetricsListeners.delete(listener);
}
/**
* Each step of an animation the phone preview is replaying (a menu slide
* reaches the glasses as one frame, so frame metrics fire only at its start).
*/
onPreviewAnimationFrame(listener: () => void): () => void {
this.previewAnimationListeners.add(listener);
return () => this.previewAnimationListeners.delete(listener);
}
onFirmwareInfo(listener: (info: FirmwareInfo) => void): () => void {
this.firmwareInfoListeners.add(listener);
return () => this.firmwareInfoListeners.delete(listener);
}
getNativeCommunicator(): any {
return this.communicator;
}
private recordFrameFinished(frameId: number, outcome: string): void {
if (!Number.isFinite(frameId) || frameId <= 0) return;
this.finishedFrameOutcomes.set(frameId, outcome);
while (this.finishedFrameOutcomes.size > 128) {
const oldest = this.finishedFrameOutcomes.keys().next().value;
if (oldest === undefined) break;
this.finishedFrameOutcomes.delete(oldest);
}
const waiters = this.frameFinishedWaiters.get(frameId);
if (waiters) {
this.frameFinishedWaiters.delete(frameId);
for (const waiter of waiters) {
setTimeout(() => waiter(outcome), 0);
}
}
}
/**
* Resolve with the frame's outcome once the Java side finishes it (sent,
* discarded, or timed out), or with null after timeoutMs. Used as transmit
* backpressure: unlike waiting for frame metrics, this also resolves when a
* frame is discarded (e.g. deduped as unchanged), so no-op renders do not
* stall the render loop.
*/
waitForFrameFinished(frameId: number, timeoutMs: number): Promise<string | null> {
const known = this.finishedFrameOutcomes.get(frameId);
if (known !== undefined) return Promise.resolve(known);
if (frameId <= 0) return Promise.resolve(null);
const delayMs = Math.max(1, Math.round(nonNegativeNumber(timeoutMs)));
return new Promise((resolve) => {
let settled = false;
const onFinished = (outcome: string) => {
if (settled) return;
settled = true;
clearTimeout(timeoutHandle);
resolve(outcome);
};
let waiters = this.frameFinishedWaiters.get(frameId);
if (!waiters) {
waiters = new Set();
this.frameFinishedWaiters.set(frameId, waiters);
}
waiters.add(onFinished);
const timeoutHandle = setTimeout(() => {
if (settled) return;
settled = true;
const pending = this.frameFinishedWaiters.get(frameId);
if (pending) {
pending.delete(onFinished);
if (pending.size === 0) this.frameFinishedWaiters.delete(frameId);
}
resolve(null);
}, delayMs);
});
}
waitForNextFrameMetrics(timeoutMs: number): Promise<FrameMetrics | null> {
const delayMs = Math.max(1, Math.round(nonNegativeNumber(timeoutMs)));
return new Promise((resolve) => {
let settled = false;
let timeoutHandle: ReturnType<typeof setTimeout> | null = null;
const complete = (metrics: FrameMetrics | null) => {
if (settled) return;
settled = true;
if (timeoutHandle !== null) {
clearTimeout(timeoutHandle);
}
this.frameMetricWaiters.delete(onMetrics);
resolve(metrics);
};
const onMetrics = (metrics: FrameMetrics) => complete(metrics);
this.frameMetricWaiters.add(onMetrics);
timeoutHandle = setTimeout(() => complete(null), delayMs);
});
}
async start(): Promise<void> {
await this.enqueueJavaCall(() => this.communicator.start());
}
async setG2ScreenOn(screenOn: boolean): Promise<void> {
await this.enqueueJavaCall(() => this.communicator.setG2ScreenOn(Boolean(screenOn)));
}
async setFirmwareDebugFlags(enabled: boolean): Promise<void> {
await this.enqueueJavaCall(() => this.communicator.setFirmwareDebugFlags(Boolean(enabled)));
}
/** Set lens brightness: Faceclaw auto or a fixed level (clamped to 2–100). */
async setBrightness(autoAdjust: boolean, level: number): Promise<void> {
await this.enqueueJavaCall(() => this.communicator.setBrightness(Boolean(autoAdjust), Math.round(level)));
}
async configureBrightness(p: { auto: boolean; level: number; minimum: number; maximum: number; curve: string; fadeMs: number }): Promise<void> {
await this.enqueueJavaCall(() => this.communicator.configureBrightness(p.auto, p.level, p.minimum, p.maximum, p.curve, p.fadeMs));
}
async enableWearDetectionAndRequestState(): Promise<void> {
await this.enqueueJavaCall(() => this.communicator.enableWearDetectionAndRequestState());
}
/** Whether the transport prelude has finished (each arm reports "connected" before it). */
isSessionReady(): boolean {
return Boolean(this.communicator.isSessionReady());
}
/** Set the compositor's output frame size. Call before configuring surfaces. */
async configureCompositorScreen(width: number, height: number): Promise<void> {
await this.enqueueJavaCall(() => {
this.communicator.configureCompositorScreen(Math.round(width), Math.round(height));
});
}
/**
* Phone-UI preview of the current composited screen, or null if none yet.
* `green` tints it green-on-black (the Preview color setting) instead of
* grayscale; `crop` limits it to a screen area (the Preview scaling
* setting), black where that runs past the screen's edges.
*/
getCompositePreview(green = false, crop: { x: number; y: number; width: number; height: number } | null = null): ImageSource | null {
if (!global.isAndroid) return null;
const bitmap = crop
? this.communicator.getCompositePreviewBitmap(
PREVIEW_BRIGHTEN_GAMMA,
green,
Math.round(crop.x),
Math.round(crop.y),
Math.round(crop.width),
Math.round(crop.height),
)
: this.communicator.getCompositePreviewBitmap(PREVIEW_BRIGHTEN_GAMMA, green);
return bitmap ? new ImageSource(bitmap) : null;
}
/** Save the current composite as a 4-bit grayscale PNG; returns the path (empty if none). */
saveScreenshot(crop?: { x: number; y: number; width: number; height: number }): string {
if (!global.isAndroid) return "";
if (!crop) return String(this.communicator.saveCompositePngScreenshot());
return String(
this.communicator.saveCompositePngScreenshot(
Math.round(crop.x),
Math.round(crop.y),
Math.round(crop.width),
Math.round(crop.height),
),
);
}
/** Begin collecting composite frames for an animated-GIF screen recording. */
startScreenRecording(): void {
if (!global.isAndroid) return;
this.communicator.startScreenRecording();
}
/** Capture the current composite into the active recording; no-op when idle. */
recordScreenFrame(): void {
if (!global.isAndroid) return;
this.communicator.recordScreenFrame();
}
/** Finish the recording and save the animated GIF; returns the path (empty if no frames). */
stopScreenRecording(): string {
if (!global.isAndroid) return "";
return String(this.communicator.stopScreenRecording());
}
/**
* Create or reconfigure a compositor surface. Geometry changes take effect
* when the next frame is submitted.
*/
async configureSurface(id: string, options: SurfaceOptions): Promise<void> {
const transparency = options.transparency === "color-key" ? 1 : 0;
await this.enqueueJavaCall(() => {
this.communicator.configureSurface(
id,
Math.round(options.x),
Math.round(options.y),
Math.round(options.width),
Math.round(options.height),
Math.round(options.zOrder),
transparency,
);
});
}
async removeSurface(id: string): Promise<void> {
await this.enqueueJavaCall(() => {
this.communicator.removeSurface(id);
});
}
/**
* Dim every compositor surface whose zOrder is below `belowZOrder` to
* `factor` (0..1; 1 = no dimming) of its brightness; takes effect at the
* next composite. How a shell overlay's Layer.dimUnderneath reaches the
* window surfaces beneath the shell surface.
*/
async submitShellScene(bytes: Uint8Array, paintMs = 0, frameId = 0): Promise<void> {
const snapshot = new Uint8Array(bytes);
await this.enqueueJavaCall(
() => this.communicator.submitShellScene(this.shellSceneBuffer.load(snapshot), paintMs, frameId),
true,
true,
);
}
async setUnderlayDim(belowZOrder: number, factor: number): Promise<void> {
await this.enqueueJavaCall(() => {
this.communicator.setUnderlayDim(Math.round(belowZOrder), dimFactor256(factor));
});
}
/** Show or hide a compositor surface; takes effect at the next composite. */
async setSurfaceVisible(id: string, visible: boolean): Promise<void> {
await this.enqueueJavaCall(() => {
this.communicator.setSurfaceVisible(id, Boolean(visible));
}, false, true);
}
/**
* Whether submitting a full-surface frame with this fingerprint would
* change nothing: Java already holds that content for the surface, and no
* queued or not-yet-composited change is waiting on a composite. Lets a
* repaint that came out identical (a window re-rendered when it comes to
* the foreground, say) skip flattening and submitting its frame.
*/
isSurfaceCurrent(surfaceId: string, fingerprint: string): boolean {
if (this.queuedSurfaceChanges > 0) return false;
return Boolean(this.communicator.isSurfaceCurrent(surfaceId, fingerprint));
}
/**
* Stereo depth for a surface, applied while it is the topmost visible
* surface and opaquely covers the screen; takes effect at its next frame.
*/
async setSurfaceDepth(id: string, depth: number): Promise<void> {
await this.enqueueJavaCall(() => {
this.communicator.setSurfaceDepth(id, Math.round(depth));
});
}
/**
* Blank (screen off) or unblank the composited output; retained surface
* state survives, so unblanking restores the screen without repaints.
*/
async setScreenBlanked(blanked: boolean): Promise<void> {
await this.enqueueJavaCall(() => {
this.communicator.setScreenBlanked(Boolean(blanked));
});
}
/**
* Apply an update covering rect (in surface-local coordinates) to a surface
* and submit the recomposited screen to the glasses. pixels8bpp holds
* rect.width*rect.height bytes, row-major; fingerprint identifies the
* surface's full content after the update.
*/
async submitSurfaceFrame(
surfaceId: string,
pixels8bpp: Uint8Array,
rect: { x: number; y: number; width: number; height: number },
fingerprint: string,
paintMs = -1,
frameId = 0,
/**
* The frame's glyph draws in surface coordinates (see
* graphics/glyph-wire.ts prepareFrameGlyphs); lets the texture-cache
* pipeline ship text as on-glasses cached draws instead of pixels.
*/
glyphs: ArrayBuffer | null = null,
): Promise<void> {
// Snapshot because the Java call is deferred. The bytes reach Java as a
// ByteBuffer (no ~150ms per-element copy, as a byte[] parameter would
// need), but through a reused Java direct buffer rather than by passing
// the ArrayBuffer itself, which NativeScript never frees
// (java-direct-buffer.ts).
const snapshot = new Uint8Array(pixels8bpp);
// inlineWhenIdle: this is the frame path, the Java side of it measures
// ~5ms (composite + pack), and the caller awaits it either way.
await this.enqueueJavaCall(() => {
this.communicator.submitSurfaceFrame(
this.framePixelsBuffer.load(snapshot),
surfaceId,
Math.round(rect.x),
Math.round(rect.y),
Math.round(rect.width),
Math.round(rect.height),
fingerprint,
Math.round(nonNegativeNumber(paintMs)),
Math.round(nonNegativeNumber(frameId)),
this.frameDrawsBuffer.loadOptional(glyphs),
);
}, true);
}
async disconnect(): Promise<void> {
await this.enqueueJavaCall(() => this.communicator.disconnect());
}
async sendShutdown(exitMode = 0): Promise<boolean> {
return this.enqueueJavaCall(() => Boolean(this.communicator.sendShutdown(exitMode)));
}
/**
* Ask CFW mode 11 to release all custom-session state. On success this must
* remain the final Faceclaw message before close(); false requests the legacy
* shutdown/release fallback for older firmware.
*/
async sendCfwCleanup(): Promise<boolean> {
return this.enqueueJavaCall(() => Boolean(this.communicator.sendCfwCleanup()));
}
/**
* End only the EvenHub page/session, leaving both arm BLE connections and
* their async notification subscriptions alive.
*/
async suspendEvenHubSession(): Promise<boolean> {
return this.enqueueJavaCall(() => Boolean(this.communicator.suspendEvenHubSession()));
}
/**
* Re-enable the EvenHub page lifecycle. The retained compositor frame is
* sent after the layout and image path have been recreated.
*/
async resumeEvenHubSession(): Promise<boolean> {
return this.enqueueJavaCall(() => Boolean(this.communicator.resumeEvenHubSession()));
}
/**
* Own CFW's fail-open stock-wake policy while Faceclaw handles wakewords or
* suspends EvenHub with the screen off. Returns after both arm writes complete.
*/
async setFaceclawWakeLeaseEnabled(enabled: boolean): Promise<boolean> {
return this.enqueueJavaCall(() =>
Boolean(this.communicator.setFaceclawWakeLeaseEnabled(enabled)),
);
}
/**
* Whether the glasses' own wake word reaches Faceclaw: on a RayNeo iO, its
* "Hey RayNeo" switch (G2 glasses use the wake lease above instead).
*/
async setVoiceWakeEnabled(enabled: boolean): Promise<void> {
await this.enqueueJavaCall(() => this.communicator.setVoiceWakeEnabled(enabled));
}
/**
* Resolve only once the recreated layout and retained frame
* are visible. CFW's deferred-dashboard READY is emitted from this barrier.
*/
async awaitEvenHubSessionReady(timeoutMs: number): Promise<boolean> {
return this.enqueueJavaCall(() =>
Boolean(this.communicator.awaitEvenHubSessionReady(Math.round(nonNegativeNumber(timeoutMs)))),
);
}
/** Play a CFW mode-5 kind-4 tone sequence (complete wire payload). */
async playBuzzerSequence(payload: Uint8Array): Promise<void> {
const snapshot = new Uint8Array(payload);
await this.enqueueJavaCall(() => {
this.communicator.playBuzzerSequence(this.buzzerBuffer.load(snapshot));
});
}
async close(): Promise<void> {
this.previewAnimationListeners.clear();
await this.enqueueJavaCall(() => {
this.communicator.setPreviewAnimationListener(null);
this.communicator.close();
});
}
}