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

714 lines
31 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 { RingInput } from "../g2/ring-input";
import { File, knownFolders, path, type ImageSource } from "@nativescript/core";
import { REQUIRED_FACECLAW_FIRMWARE_VERSION, type FirmwareInfo } from "../g2/firmware-compat";
import { type CompassEvent } from "./compass-types";
import { fromData, toData } from "./kotlin-data";
import { previewPixels } from "./ios-graphics";
import { iosBluetooth } from "./ios-bluetooth";
export type { FirmwareInfo };
// Kotlin/Native facades exported by FaceclawKit (see native/kotlin/shared/src/iosMain/.../ble).
declare const FaceclawKitIosGlassesSession: any;
declare const FaceclawKitFaceclawBleCommunicatorListener: any;
declare const FaceclawKitIosAncsListener: any;
declare const FaceclawKitIosAudioPacketListener: any;
declare const FaceclawKitFaceclawCompassListener: any;
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;
};
export type FrameMetrics = {
paintMs: number;
transmitMs: number;
tileCount: number;
};
/** See the Android twin: compositor surface configuration in screen pixels. */
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 }
| { kind: "even-ai"; containerName: string; eventType: number; eventSource: number; systemExitReasonCode: number; frameId: number }
| { kind: "watch-gesture"; containerName: string; eventType: number; eventSource: number; systemExitReasonCode: number; frameId: number }
| { 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);
}
function timestamp(): string {
const now = new Date();
const pad = (value: number, width = 2) => String(value).padStart(width, "0");
return `${now.getFullYear()}${pad(now.getMonth() + 1)}${pad(now.getDate())}-${pad(now.getHours())}${pad(now.getMinutes())}${pad(now.getSeconds())}-${pad(now.getMilliseconds(), 3)}`;
}
export type PeripheralIdentifiers = { right: string; left: string; ring: string };
/**
* Map the configured MAC addresses to CoreBluetooth identifiers through the scan
* layer (app/native/ios-bluetooth.ts): the mapping a previous scan persisted, else a
* fresh scan that classifies Even advertisements. The scan layer also owns Bluetooth
* readiness (creating the central triggers the permission prompt on first use).
*/
export async function resolveIosPeripherals(addresses: { right: string; left: string; ring?: string }): Promise<PeripheralIdentifiers> {
const resolved = await iosBluetooth().resolveDevices({ right: addresses.right, left: addresses.left, ring: addresses.ring ?? "" });
return {
right: String(resolved.right ?? "").toUpperCase(),
left: String(resolved.left ?? "").toUpperCase(),
ring: String(resolved.ring ?? "").toUpperCase(),
};
}
/** Bluetooth powered on and authorized (prompts for permission the first time); rejects with the user-facing reason. */
export function ensureIosBluetoothReady(): Promise<void> {
return iosBluetooth().ensureReady();
}
@NativeClass()
class SessionListener extends NSObject {
static ObjCProtocols = [FaceclawKitFaceclawBleCommunicatorListener];
bridge!: FaceclawCommunicatorBridge;
onStateChangePhaseStatus(phase: string, status: string): void { this.bridge.handleStateChange(String(phase ?? ""), String(status ?? "")); }
onRingEventKindContainerNameEventTypeEventSourceSystemExitReasonCodeFrameIdRingTickRingTypeRingAuxRingSpeed(
kind: string, containerName: string, eventType: number, eventSource: number, systemExitReasonCode: number,
frameId: number, ringTick: number, ringType: number, ringAux: number, ringSpeed: number,
): void {
this.bridge.handleRingEvent(String(kind ?? ""), String(containerName ?? ""), Number(eventType), Number(eventSource),
Number(systemExitReasonCode), Number(frameId), Number(ringTick), Number(ringType), Number(ringAux), Number(ringSpeed));
}
onBatteryStateHeadsetBatteryHeadsetChargingRingBatteryRingCharging(headsetBattery: number, headsetCharging: number, ringBattery: number, ringCharging: number): void {
this.bridge.handleBatteryState(Number(headsetBattery), Number(headsetCharging), Number(ringBattery), Number(ringCharging));
}
onSilentModeSilent(silent: boolean): void { this.bridge.handleSilentMode(Boolean(silent)); }
onWearStateWearing(wearing: boolean): void { this.bridge.handleWearState(Boolean(wearing)); }
onPhoneLockStateLocked(locked: boolean): void { this.bridge.handlePhoneLockState(Boolean(locked)); }
onEvenAppConflictMessage(message: string): void { this.bridge.handleEvenAppConflict(String(message ?? "")); }
onFrameMetricsPaintMsTransmitMsTileCount(paintMs: number, transmitMs: number, tileCount: number): void {
this.bridge.handleFrameMetrics(Number(paintMs), Number(transmitMs), Number(tileCount));
}
onFrameFinishedFrameIdOutcome(frameId: number, outcome: string): void { this.bridge.handleFrameFinished(Number(frameId), String(outcome ?? "")); }
onFirmwareInfoLeftVersionRightVersionExtension(leftVersion: string, rightVersion: string, extension: string): void {
this.bridge.handleFirmwareInfo(String(leftVersion ?? ""), String(rightVersion ?? ""), String(extension ?? ""));
}
}
@NativeClass()
class AncsListener extends NSObject {
static ObjCProtocols = [FaceclawKitIosAncsListener];
bridge!: FaceclawCommunicatorBridge;
onAncsAuthorizationAuthorized(authorized: boolean): void { this.bridge.handleAncsAuthorization(Boolean(authorized)); }
onRelayFrameData(data: NSData): void { this.bridge.handleAncsRelayFrame(fromData(data)); }
}
@NativeClass()
class AudioPacketListener extends NSObject {
static ObjCProtocols = [FaceclawKitIosAudioPacketListener];
handler!: (packet: Uint8Array, arm: string, arrivalMs: number) => void;
onAudioPacketDataArmArrivalMs(data: NSData, arm: string, arrivalMs: number): void {
this.handler(fromData(data), String(arm ?? ""), Number(arrivalMs));
}
}
@NativeClass()
class CompassListener extends NSObject {
static ObjCProtocols = [FaceclawKitFaceclawCompassListener];
handler!: (event: CompassEvent) => void;
onCompassEventCommandHeadingDegreesMagneticAccuracyMagneticAnomaliesOrientationSourceDiagnosticFlagsSampleTimeMs(
command: number, headingDegrees: number, magneticAccuracy: number, magneticAnomalies: number,
orientationSource: number, diagnosticFlags: number, sampleTimeMs: number,
): void {
this.handler({
command: Number(command), headingDegrees: Number(headingDegrees),
diagnostics: diagnosticFlags >= 0 ? {
magneticAccuracy: Number(magneticAccuracy), magneticAnomalies: Number(magneticAnomalies),
orientationSource: Number(orientationSource), flags: Number(diagnosticFlags), sampleTimeMs: Number(sampleTimeMs),
} : undefined,
});
}
}
/**
* The iOS twin of the Android communicator bridge: the same public API over
* the shared Kotlin session (FaceclawKitIosGlassesSession, CoreBluetooth
* underneath). Addresses are CoreBluetooth identifiers (resolveIosPeripherals
* maps the configured MACs). Every Kotlin callback already arrives on the
* main queue; listener fan-out is still deferred with setTimeout like on
* Android so callers never re-enter the bridge from a Kotlin frame.
*/
export class FaceclawCommunicatorBridge {
private readonly communicator: any;
private readonly listenerProxy: SessionListener;
private ancsProxy: AncsListener | null = null;
private nativeCallQueue: Promise<void> = Promise.resolve();
private queuedNativeCalls = 0;
private readonly frameMetricWaiters = new Set<(metrics: FrameMetrics) => void>();
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 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 previewAnimationListeners = new Set<() => void>();
private readonly firmwareInfoListeners = new Set<(info: FirmwareInfo) => void>();
private readonly ancsAuthorizationListeners = new Set<(authorized: boolean) => void>();
private readonly ancsRelayListeners = new Set<(frame: Uint8Array) => void>();
private audioListener: AudioPacketListener | null = null;
private microphoneWork: Promise<void> = Promise.resolve();
private microphoneToken = 0;
constructor(addresses: { right: string; left: string; ring?: string }) {
this.communicator = FaceclawKitIosGlassesSession.alloc().initWithRightAddressLeftAddressRingAddress(
String(addresses.right ?? "").toUpperCase(),
String(addresses.left ?? "").toUpperCase(),
String(addresses.ring ?? "").toUpperCase(),
);
// The shared session halts on any other firmware ("incompatible-firmware").
this.communicator.setRequiredFirmwareRevisionRevision(REQUIRED_FACECLAW_FIRMWARE_VERSION);
this.listenerProxy = SessionListener.new() as SessionListener;
this.listenerProxy.bridge = this;
this.communicator.setListenerListener(this.listenerProxy);
// Kotlin calls this on the main queue.
this.communicator.setPreviewAnimationListenerListener(() => {
for (const listener of Array.from(this.previewAnimationListeners)) listener();
});
}
// ----- Kotlin listener entry points (main queue) -----------------------------------
/** @internal */
handleStateChange(phase: string, status: string): void {
this.emitAsync(this.stateListeners, { phase: phase as CommunicatorPhase, status });
}
/** @internal */
handleRingEvent(kind: string, containerName: string, eventType: number, eventSource: number, systemExitReasonCode: number,
frameId: number, ringTick: number, ringType: number, ringAux: number, ringSpeed: number): void {
const event = {
kind: kind as RawInputEvent["kind"], containerName, eventType, eventSource, systemExitReasonCode, frameId,
ringInput: ringTick >= 0 ? { tick: ringTick, type: ringType, aux: ringAux, speed: ringSpeed } : undefined,
} as RawInputEvent;
this.emitAsync(this.ringListeners, event);
}
/** @internal */
handleBatteryState(battery: number, chargingStatus: number, ringBattery: number, ringChargingStatus: number): void {
this.emitAsync(this.batteryListeners, { battery, chargingStatus, ringBattery, ringChargingStatus });
}
/** @internal */
handleSilentMode(silent: boolean): void { this.emitAsync(this.silentModeListeners, silent); }
/** @internal */
handleWearState(wearing: boolean): void {
this.latestWearState = wearing;
this.emitAsync(this.wearStateListeners, wearing);
}
/** @internal */
handlePhoneLockState(locked: boolean): void {
this.latestPhoneLockState = locked;
this.emitAsync(this.phoneLockStateListeners, locked);
}
/** @internal */
handleEvenAppConflict(message: string): void { this.emitAsync(this.evenAppConflictListeners, message); }
/** @internal */
handleFrameMetrics(paintMs: number, transmitMs: number, tileCount: number): void {
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);
}
/** @internal */
handleFrameFinished(frameId: number, outcome: string): void { this.recordFrameFinished(frameId, outcome); }
/** @internal */
handleFirmwareInfo(leftVersion: string, rightVersion: string, extension: string): void {
this.emitAsync(this.firmwareInfoListeners, { leftVersion, rightVersion, extension });
}
/** @internal */
handleAncsAuthorization(authorized: boolean): void { this.emitAsync(this.ancsAuthorizationListeners, authorized); }
/** @internal */
handleAncsRelayFrame(frame: Uint8Array): void { this.emitAsync(this.ancsRelayListeners, frame); }
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);
}
/** Same FIFO as the Android bridge: native calls stay ordered; the fast path skips a task hop when idle. */
private enqueueNativeCall<T>(operation: () => T, inlineWhenIdle = false): Promise<T> {
if (inlineWhenIdle && this.queuedNativeCalls === 0) {
try {
return Promise.resolve(operation());
} catch (error) {
return Promise.reject(error);
}
}
this.queuedNativeCalls++;
const run = () =>
new Promise<T>((resolve, reject) => {
setTimeout(() => {
this.queuedNativeCalls--;
try {
resolve(operation());
} catch (error) {
reject(error);
}
}, 0);
});
const result = this.nativeCallQueue.then(run, run);
this.nativeCallQueue = result.then(() => undefined, () => undefined);
return result;
}
// ----- listeners -------------------------------------------------------------------
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);
}
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);
}
}
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);
});
}
// ----- session ---------------------------------------------------------------------
async start(): Promise<void> {
await this.enqueueNativeCall(() => { this.communicator.start(); });
}
async setG2ScreenOn(screenOn: boolean): Promise<void> {
await this.enqueueNativeCall(() => this.communicator.setG2ScreenOnScreenOn(Boolean(screenOn)));
}
async setFirmwareDebugFlags(enabled: boolean): Promise<void> {
await this.enqueueNativeCall(() => this.communicator.setFirmwareDebugFlagsEnabled(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.enqueueNativeCall(() => this.communicator.setBrightnessAutoAdjustBrightnessLevel(Boolean(autoAdjust), Math.round(level)));
}
async configureBrightness(p: { auto: boolean; level: number; minimum: number; maximum: number; curve: string; fadeMs: number }): Promise<void> {
await this.enqueueNativeCall(() => this.communicator.configureBrightnessAutoLevelMinimumMaximumCurveFadeMs(p.auto, p.level, p.minimum, p.maximum, p.curve, p.fadeMs));
}
async enableWearDetectionAndRequestState(): Promise<void> {
await this.enqueueNativeCall(() => this.communicator.enableWearDetectionAndRequestState());
}
isSessionReady(): boolean {
return Boolean(this.communicator.isSessionReady());
}
/** The platform's lock/screen signal (the iOS host also observes protected data itself). */
onPhoneLockSignal(): void {
this.communicator.onPhoneLockSignal();
}
// ----- compositor ------------------------------------------------------------------
async configureCompositorScreen(width: number, height: number): Promise<void> {
await this.enqueueNativeCall(() => {
this.communicator.configureCompositorScreenWidthHeight(Math.round(width), Math.round(height));
});
}
/** Phone-UI preview of the current composited screen (or of `crop`'s area of it), or null if none yet. */
getCompositePreview(green = false, crop: { x: number; y: number; width: number; height: number } | null = null): ImageSource | null {
const frame = this.communicator.previewComposite();
if (!frame) return null;
const width = Number(this.communicator.compositeWidth()), height = Number(this.communicator.compositeHeight());
if (width <= 0 || height <= 0) return null;
return previewPixels(fromData(frame.pixels), width, height, green, crop);
}
/** Save the current composite as a 4-bit grayscale PNG under Documents; returns the path (empty if none). Cropping is not supported on iOS. */
saveScreenshot(crop?: { x: number; y: number; width: number; height: number }): string {
if (crop) return "";
const png = this.communicator.screenshotPng();
if (!png) return "";
const target = path.join(knownFolders.documents().path, `screen-${timestamp()}.png`);
File.fromPath(target).writeSync(png);
return target;
}
/** Screen recording is not available on iOS yet. */
startScreenRecording(): void {}
recordScreenFrame(): void {}
stopScreenRecording(): string { return ""; }
async configureSurface(id: string, options: SurfaceOptions): Promise<void> {
const transparency = options.transparency === "color-key" ? 1 : 0;
await this.enqueueNativeCall(() => {
this.communicator.configureSurfaceIdXYWidthHeightZOrderTransparency(
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.enqueueNativeCall(() => { this.communicator.removeSurfaceId(id); });
}
async submitShellScene(bytes: Uint8Array, paintMs = 0, frameId = 0): Promise<void> {
const snapshot = new Uint8Array(bytes);
await this.enqueueNativeCall(() => this.communicator.submitShellSceneBytesPaintMsFrameId(toData(snapshot), Math.round(nonNegativeNumber(paintMs)), Math.round(nonNegativeNumber(frameId))), true);
}
async setUnderlayDim(belowZOrder: number, factor: number): Promise<void> {
await this.enqueueNativeCall(() => {
this.communicator.setUnderlayDimBelowZOrderFactor256(Math.round(belowZOrder), dimFactor256(factor));
});
}
async setSurfaceVisible(id: string, visible: boolean): Promise<void> {
await this.enqueueNativeCall(() => { this.communicator.setSurfaceVisibleIdVisible(id, Boolean(visible)); });
}
async setSurfaceDepth(id: string, depth: number): Promise<void> {
await this.enqueueNativeCall(() => { this.communicator.setSurfaceDepthIdDepth(id, Math.round(depth)); });
}
async setScreenBlanked(blanked: boolean): Promise<void> {
await this.enqueueNativeCall(() => { this.communicator.setScreenBlankedBlanked(Boolean(blanked)); });
}
/**
* See the Android bridge. Not wired to the shared compositor's check on iOS
* yet, so every repaint is submitted as before.
*/
isSurfaceCurrent(_surfaceId: string, _fingerprint: string): boolean {
return false;
}
async submitSurfaceFrame(
surfaceId: string,
pixels8bpp: Uint8Array,
rect: { x: number; y: number; width: number; height: number },
fingerprint: string,
paintMs = -1,
frameId = 0,
glyphs: ArrayBuffer | null = null,
): Promise<void> {
const snapshot = new Uint8Array(pixels8bpp);
const draws = glyphs ? toData(new Uint8Array(glyphs)) : null;
await this.enqueueNativeCall(() => {
this.communicator.submitSurfaceFramePixels8bppSurfaceIdRectXRectYRectWidthRectHeightContentFingerprintPaintMsFrameIdGlyphs(
toData(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)), draws,
);
}, true);
}
// ----- controls --------------------------------------------------------------------
async disconnect(): Promise<void> {
await this.enqueueNativeCall(() => this.communicator.disconnect());
}
async sendShutdown(exitMode = 0): Promise<boolean> {
return this.enqueueNativeCall(() => Boolean(this.communicator.sendShutdownExitMode(exitMode)));
}
async sendCfwCleanup(): Promise<boolean> {
return this.enqueueNativeCall(() => Boolean(this.communicator.sendCfwCleanup()));
}
async suspendEvenHubSession(): Promise<boolean> {
return this.enqueueNativeCall(() => Boolean(this.communicator.suspendEvenHubSession()));
}
async resumeEvenHubSession(): Promise<boolean> {
return this.enqueueNativeCall(() => Boolean(this.communicator.resumeEvenHubSession()));
}
async setFaceclawWakeLeaseEnabled(enabled: boolean): Promise<boolean> {
return this.enqueueNativeCall(() => Boolean(this.communicator.setFaceclawWakeLeaseEnabledEnabled(Boolean(enabled))));
}
async awaitEvenHubSessionReady(timeoutMs: number): Promise<boolean> {
return this.enqueueNativeCall(() => Boolean(this.communicator.awaitEvenHubSessionReadyTimeoutMs(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.enqueueNativeCall(() => { this.communicator.playBuzzerSequencePayload(toData(snapshot)); });
}
async close(): Promise<void> {
this.setAncsListeners(false);
this.previewAnimationListeners.clear();
await this.enqueueNativeCall(() => {
this.communicator.setPreviewAnimationListenerListener(null);
this.communicator.close();
});
}
// ----- iOS extras: compass, microphone, iPhone notifications (ANCS) ----------------------
/** CFW mode-10 compass on behalf of `owner`; the magnetometer runs while any owner wants it. */
setCompassEnabled(enabled: boolean, owner = "compass"): void {
this.communicator.setCompassEnabledForOwnerOwnerEnable(owner, Boolean(enabled));
}
/** Compass heading/calibration events, delivered on the main queue. */
addCompassListener(listener: (event: CompassEvent) => void): () => void {
const proxy = CompassListener.new() as CompassListener;
proxy.handler = listener;
this.communicator.addCompassListenerListener(proxy);
return () => { this.communicator.removeCompassListenerListener(proxy); };
}
/**
* Serialized glasses microphone enable/disable (the voice bridge's
* IosMicrophoneSession contract). A release while an enable awaits its ACK
* still wins: the token check drops the stale packets.
*/
setMicrophone(enabled: boolean, listener?: (packet: Uint8Array) => void): Promise<void> {
const token = ++this.microphoneToken;
const work = this.microphoneWork.catch(() => {}).then(async () => {
if (token !== this.microphoneToken) return;
if (!enabled) {
this.audioListener = null;
await this.enqueueNativeCall(() => this.communicator.stopG2AudioCapture());
return;
}
if (!this.isSessionReady()) throw new Error("Connect the glasses before starting voice input.");
const proxy = AudioPacketListener.new() as AudioPacketListener;
proxy.handler = (packet) => { if (token === this.microphoneToken && listener) listener(packet); };
this.audioListener = proxy;
const started = await this.enqueueNativeCall(() => Boolean(this.communicator.startG2AudioCaptureNsDataListener(proxy)));
if (!started) {
this.audioListener = null;
throw new Error("The glasses did not enable their microphone. Reconnect and try again.");
}
});
this.microphoneWork = work;
return work;
}
/** Ask CoreBluetooth for ANCS on the right arm's next connection (call before start()). */
setRequiresAncs(required: boolean): void {
this.communicator.setRequiresAncsRequired(Boolean(required));
this.setAncsListeners(required);
}
isAncsAuthorized(): boolean {
return Boolean(this.communicator.isAncsAuthorized());
}
onAncsAuthorization(listener: (authorized: boolean) => void): () => void {
this.ancsAuthorizationListeners.add(listener);
return () => this.ancsAuthorizationListeners.delete(listener);
}
/** Relay frames ('A','N',...) received on the right arm, for the ANCS client. */
onAncsRelayFrame(listener: (frame: Uint8Array) => void): () => void {
this.ancsRelayListeners.add(listener);
return () => this.ancsRelayListeners.delete(listener);
}
/** Queue one relay packet for the right arm; the Kotlin side writes it off the JS thread. */
async writeRawToRight(packet: Uint8Array): Promise<void> {
if (!this.isSessionReady()) throw new Error("Glasses are not connected.");
const snapshot = new Uint8Array(packet);
this.communicator.writeRawToRightPacket(toData(snapshot));
}
/** The right arm's usable write payload for relay packets (20 until connected). */
rightWriteLimit(): number {
return Number(this.communicator.rightWriteLimit()) || 20;
}
private setAncsListeners(install: boolean): void {
if (install && !this.ancsProxy) {
this.ancsProxy = AncsListener.new() as AncsListener;
this.ancsProxy.bridge = this;
this.communicator.setAncsListenerListener(this.ancsProxy);
} else if (!install && this.ancsProxy) {
this.communicator.setAncsListenerListener(null);
this.ancsProxy = null;
}
}
}