Files
faceclaw/app/ui/shell/keyboard-input.ts
T

160 lines
5.3 KiB
TypeScript

import { type GrayImage } from "../../graphics/image";
import { type InputEvent } from "../gestures";
import { Layer, type LayerActions, type LayerContext } from "../layers";
import { paintInputDialog } from "./input-dialog";
import { type VoiceSendTarget } from "./voice-input";
/**
* The phone side's handle on an open keyboard-input dialog: the phone types
* into it and picks where the text goes. The layer itself implements this;
* the controller hands it to the phone UI while the dialog is up.
*/
export type KeyboardInputSession = {
/** The send destinations, in the glasses menu's row order. */
readonly targets: ReadonlyArray<{ id: string; label: string }>;
/** Replace the message with what the phone's text field now holds. */
setText(text: string): void;
/**
* Send to the destination highlighted on the glasses (the entry point's
* default unless the user scrolled the menu). The IME's send key.
*/
send(): void;
sendTo(targetId: string): void;
discard(): void;
};
export type KeyboardInputLayerOptions = {
actions: LayerActions;
/** Post-removal cleanup (also fires when the screen turns off). */
onClosed: () => void;
/** Pop this layer off the shell stack. */
dismiss: () => void;
/** Ordered send destinations shown as the first menu rows. */
sendTargets: VoiceSendTarget[];
/** Which send target is highlighted by default (entry-point dependent). */
defaultTargetIndex?: number;
};
/**
* The voice dialog's keyboard twin: the same box on the glasses, but the
* message is typed on the phone (its IME, opened by the keyboard button next
* to the mic button) instead of transcribed. The glasses mirror the text as
* it is typed and show the same send / discard menu, which works from either
* end: the ring or watch scrolls and clicks it, the phone has a button per
* row plus the IME's send key. There is no Continue row — the phone can
* simply edit the text.
*/
export class KeyboardInputLayer implements Layer, KeyboardInputSession {
private text = "";
private menuIndex: number;
private closed = false;
private readonly actions: LayerActions;
private readonly onClosed: () => void;
private readonly dismiss: () => void;
private readonly sendTargets: VoiceSendTarget[];
private readonly defaultTargetIndex: number;
constructor(options: KeyboardInputLayerOptions) {
this.actions = options.actions;
this.onClosed = options.onClosed;
this.dismiss = options.dismiss;
this.sendTargets = options.sendTargets;
const defaultIndex = options.defaultTargetIndex ?? 0;
this.defaultTargetIndex = Math.min(Math.max(0, defaultIndex), Math.max(0, this.sendTargets.length - 1));
this.menuIndex = this.defaultTargetIndex;
}
get targets(): ReadonlyArray<{ id: string; label: string }> {
return this.sendTargets.map((target) => ({ id: target.id, label: target.label }));
}
setText(text: string): void {
if (this.closed || this.text === text) return;
this.text = text;
this.actions.requestRender();
}
send(): void {
const row = this.menuRows()[this.menuIndex];
const target = row?.target ?? this.sendTargets[this.defaultTargetIndex];
if (target) this.sendToTarget(target);
}
sendTo(targetId: string): void {
const target = this.sendTargets.find((candidate) => candidate.id === targetId);
if (target) this.sendToTarget(target);
}
discard(): void {
if (!this.closed) this.dismiss();
}
private sendToTarget(target: VoiceSendTarget): void {
if (this.closed) return;
const text = this.text.trim();
// An empty message has nothing to deliver; the dialog stays up for the
// phone to keep typing (the glasses row is drawn dim for the same reason).
if (!text) return;
this.dismiss();
target.onSend(text);
}
/** The menu rows: one per send target, then Discard. */
private menuRows(): Array<{ label: string; dim: boolean; target?: VoiceSendTarget }> {
const hasText = this.text.trim().length > 0;
const rows: Array<{ label: string; dim: boolean; target?: VoiceSendTarget }> = [];
for (const target of this.sendTargets) {
rows.push({ label: target.label, dim: !hasText, target });
}
rows.push({ label: "Discard", dim: false });
return rows;
}
paint(_ctx: LayerContext, paintBelow: () => GrayImage): GrayImage {
const image = paintBelow();
paintInputDialog(image, {
title: "Keyboard",
status: "Type on the phone",
text: this.text || "(nothing typed yet)",
rows: this.menuRows(),
selectedRow: this.menuIndex,
});
return image;
}
handleInput(event: InputEvent, _ctx: LayerContext): void {
const rowCount = this.menuRows().length;
switch (event.type) {
case "scroll-up":
this.menuIndex = (this.menuIndex + rowCount - 1) % rowCount;
this.actions.requestRender();
return;
case "scroll-down":
this.menuIndex = (this.menuIndex + 1) % rowCount;
this.actions.requestRender();
return;
case "click": {
const row = this.menuRows()[this.menuIndex];
if (!row) return;
if (row.target) {
this.sendToTarget(row.target);
} else {
this.dismiss();
}
return;
}
case "double-click":
this.dismiss();
return;
default:
return;
}
}
onRemoved(): void {
this.closed = true;
this.onClosed();
}
}