forked from Blendman974/faceclaw
549 lines
17 KiB
TypeScript
549 lines
17 KiB
TypeScript
import { GESTURE_DOUBLE_CLICK } from "./gestures";
|
|
import {
|
|
getBooleanSetting,
|
|
getStringSetting,
|
|
onSettingsStoreChanged,
|
|
setBooleanSetting,
|
|
setStringSetting,
|
|
} from "~/native/settings-store";
|
|
import {
|
|
getDefaultSmallFont,
|
|
UI_FONT_SETTING_KEY,
|
|
UI_FONT_VALUES,
|
|
type UiFontChoice,
|
|
} from "~/graphics/bdffont";
|
|
import { wrapText } from "~/graphics/textwrap";
|
|
import { drawRightValueMenuItem, drawToggleMenuItem, MenuItem, MenuLayer } from "./menu";
|
|
import { DashboardInputEvent, Layer, type LayerContext } from "./layers";
|
|
import { GrayImage } from "~/graphics/image";
|
|
|
|
export type NightscoutSettings = {
|
|
siteUrl: string;
|
|
apiToken: string;
|
|
};
|
|
export type BatteryDisplayMode = "icon" | "percentage";
|
|
export type TimeFormat = "24h" | "12h";
|
|
export type ScreenTimeoutSetting = "15s" | "30s" | "1m" | "never";
|
|
// "auto" lets the glasses' ambient-light sensor drive brightness; the numeric
|
|
// values are exact levels on the firmware's 0-100 scale (nonlinear: ~30 is
|
|
// dim-but-readable indoors, ~60 is bright outdoors).
|
|
export const BRIGHTNESS_VALUES = ["auto", "0", "10", "20", "30", "40", "50", "60", "70", "80", "90", "100"] as const;
|
|
export type BrightnessSetting = (typeof BRIGHTNESS_VALUES)[number];
|
|
export type WakeWordAction = "voice-input" | "off" | "turn-screen-on";
|
|
|
|
type ConfigSettingOptions<TValue, TId extends string> = {
|
|
id: TId;
|
|
label: string;
|
|
storageKey: string;
|
|
defaultValue: TValue;
|
|
formatValue?: (value: TValue) => string;
|
|
};
|
|
|
|
// Fired after any setting changes, in any isolate (storage lives in the Java
|
|
// FaceclawSettings store and broadcasts to every isolate). Lets phone-side UI
|
|
// that depends on settings toggled from the glasses (e.g. the raw-screenshot
|
|
// button) update without waiting for an unrelated snapshot emit. Delivery is
|
|
// asynchronous: one message-loop tick after the set().
|
|
const settingChangeListeners = new Set<() => void>();
|
|
|
|
export function onAnySettingChanged(listener: () => void): () => void {
|
|
settingChangeListeners.add(listener);
|
|
return () => {
|
|
settingChangeListeners.delete(listener);
|
|
};
|
|
}
|
|
|
|
onSettingsStoreChanged(() => {
|
|
for (const listener of Array.from(settingChangeListeners)) {
|
|
listener();
|
|
}
|
|
});
|
|
|
|
export abstract class ConfigSetting<TValue, TId extends string = string> {
|
|
readonly id: TId;
|
|
readonly label: string;
|
|
protected readonly storageKey: string;
|
|
protected readonly defaultValue: TValue;
|
|
private readonly valueFormatter: (value: TValue) => string;
|
|
|
|
protected constructor(options: ConfigSettingOptions<TValue, TId>) {
|
|
this.id = options.id;
|
|
this.label = options.label;
|
|
this.storageKey = options.storageKey;
|
|
this.defaultValue = options.defaultValue;
|
|
this.valueFormatter = options.formatValue ?? ((value) => String(value));
|
|
}
|
|
|
|
abstract get(): TValue;
|
|
abstract set(value: TValue): TValue;
|
|
|
|
displayValue(value?: TValue): string {
|
|
const displayValue = arguments.length > 0 ? value as TValue : this.get();
|
|
return this.valueFormatter(displayValue);
|
|
}
|
|
}
|
|
|
|
export class ConfigSettingBoolean<TId extends string = string> extends ConfigSetting<boolean, TId> {
|
|
constructor(options: ConfigSettingOptions<boolean, TId>) {
|
|
super(options);
|
|
}
|
|
|
|
get(): boolean {
|
|
return getBooleanSetting(this.storageKey, this.defaultValue);
|
|
}
|
|
|
|
set(value: boolean): boolean {
|
|
setBooleanSetting(this.storageKey, value);
|
|
return value;
|
|
}
|
|
|
|
toggle(value = this.get()): boolean {
|
|
return this.set(!value);
|
|
}
|
|
}
|
|
|
|
type ConfigSettingEnumOptions<TValue extends string, TId extends string> = ConfigSettingOptions<TValue, TId> & {
|
|
values: readonly TValue[];
|
|
normalize?: (value: string | null | undefined) => TValue;
|
|
};
|
|
|
|
export class ConfigSettingEnum<TValue extends string, TId extends string = string> extends ConfigSetting<TValue, TId> {
|
|
readonly values: readonly TValue[];
|
|
private readonly normalizer: (value: string | null | undefined) => TValue;
|
|
|
|
constructor(options: ConfigSettingEnumOptions<TValue, TId>) {
|
|
super(options);
|
|
this.values = options.values;
|
|
if (options.normalize) {
|
|
this.normalizer = (value: string | null | undefined) => {
|
|
const normalized = options.normalize(value) as TValue|undefined;
|
|
if (normalized === undefined) return this.defaultValue;
|
|
return normalized;
|
|
}
|
|
} else {
|
|
this.normalizer = (value) => this.values.includes(value as TValue) ? value as TValue : this.defaultValue;
|
|
}
|
|
}
|
|
|
|
get(): TValue {
|
|
return this.normalizer(getStringSetting(this.storageKey, this.defaultValue));
|
|
}
|
|
|
|
set(value: TValue): TValue {
|
|
const normalized = this.normalizer(value);
|
|
setStringSetting(this.storageKey, normalized);
|
|
return normalized;
|
|
}
|
|
|
|
next(value = this.get()): TValue {
|
|
const index = this.values.indexOf(value);
|
|
return this.values[(index + 1) % this.values.length] ?? this.defaultValue;
|
|
}
|
|
}
|
|
|
|
type ConfigSettingStringOptions<TId extends string> = ConfigSettingOptions<string, TId> & {
|
|
editorTitle?: string;
|
|
glassesEditTitle?: string;
|
|
normalize?: (value: string | null | undefined) => string;
|
|
};
|
|
|
|
export class ConfigSettingString<TId extends string = string> extends ConfigSetting<string, TId> {
|
|
readonly editorTitle: string;
|
|
readonly glassesEditTitle: string;
|
|
private readonly normalizer: (value: string | null | undefined) => string;
|
|
|
|
constructor(options: ConfigSettingStringOptions<TId>) {
|
|
super(options);
|
|
this.editorTitle = options.editorTitle ?? options.label;
|
|
this.glassesEditTitle = options.glassesEditTitle ?? `Edit ${options.label}`;
|
|
this.normalizer = options.normalize ?? ((value) => value ?? "");
|
|
}
|
|
|
|
get(): string {
|
|
return this.normalizer(getStringSetting(this.storageKey, this.defaultValue));
|
|
}
|
|
|
|
set(value: string): string {
|
|
const normalized = this.normalizer(value);
|
|
setStringSetting(this.storageKey, normalized);
|
|
return normalized;
|
|
}
|
|
}
|
|
|
|
|
|
export const systemCardNameSetting = new ConfigSettingString({
|
|
id: "dashboard-name",
|
|
label: "Dashboard name",
|
|
storageKey: "dashboard.systemCardName",
|
|
defaultValue: "Faceclaw",
|
|
editorTitle: "Dashboard name",
|
|
glassesEditTitle: "Edit dashboard name",
|
|
normalize: normalizeSystemCardName,
|
|
formatValue: (value) => value || "Faceclaw",
|
|
});
|
|
|
|
export const batteryDisplayModeSetting = new ConfigSettingEnum<BatteryDisplayMode>({
|
|
id: "batteryDisplayMode",
|
|
label: "Battery display",
|
|
storageKey: "dashboard.systemCard.batteryDisplayMode",
|
|
defaultValue: "icon",
|
|
values: ["icon", "percentage"],
|
|
formatValue: batteryDisplayModeLabel,
|
|
});
|
|
|
|
export const uiFontSetting = new ConfigSettingEnum<UiFontChoice>({
|
|
id: "uiFont",
|
|
label: "Font",
|
|
storageKey: UI_FONT_SETTING_KEY,
|
|
defaultValue: "terminus",
|
|
values: UI_FONT_VALUES,
|
|
formatValue: uiFontLabel,
|
|
});
|
|
|
|
export const timeFormatSetting = new ConfigSettingEnum<TimeFormat>({
|
|
id: "timeFormat",
|
|
label: "Time format",
|
|
storageKey: "display.timeFormat",
|
|
defaultValue: "24h",
|
|
values: ["24h", "12h"],
|
|
formatValue: timeFormatLabel,
|
|
});
|
|
|
|
export const brightnessSetting = new ConfigSettingEnum<BrightnessSetting>({
|
|
id: "brightness",
|
|
label: "Brightness",
|
|
storageKey: "display.brightness",
|
|
defaultValue: "auto",
|
|
values: BRIGHTNESS_VALUES,
|
|
formatValue: brightnessLabel,
|
|
});
|
|
|
|
export const screenTimeoutSetting = new ConfigSettingEnum<ScreenTimeoutSetting>({
|
|
id: "screen-timeout",
|
|
label: "Screen timeout",
|
|
storageKey: "display.screenTimeout",
|
|
defaultValue: "30s",
|
|
values: ["15s", "30s", "1m", "never"],
|
|
formatValue: screenTimeoutLabel,
|
|
});
|
|
|
|
export const voiceControlEnabledSetting = new ConfigSettingBoolean({
|
|
id: "voice-control-enabled",
|
|
label: "Enable",
|
|
storageKey: "voice.enabled",
|
|
defaultValue: false,
|
|
});
|
|
|
|
export const rawScreenshotsEnabledSetting = new ConfigSettingBoolean({
|
|
id: "raw-screenshots-enabled",
|
|
label: "Take raw screenshots",
|
|
storageKey: "developer.rawScreenshots",
|
|
defaultValue: false,
|
|
});
|
|
|
|
export const firmwareDebugFlagsSetting = new ConfigSettingBoolean({
|
|
id: "firmware-debug-flags",
|
|
label: "Firmware debug flags",
|
|
storageKey: "developer.firmwareDebugFlags",
|
|
defaultValue: false,
|
|
});
|
|
|
|
export type VoiceProvider = "onboard" | "elevenlabs" | "whisper";
|
|
|
|
const voiceProviderLabels: Record<VoiceProvider, string> = {
|
|
onboard: "On-device",
|
|
elevenlabs: "ElevenLabs",
|
|
whisper: "Whisper",
|
|
};
|
|
|
|
export const voiceProviderSetting = new ConfigSettingEnum<VoiceProvider>({
|
|
id: "voice-provider",
|
|
label: "Transcription Provider",
|
|
storageKey: "voice.provider",
|
|
defaultValue: "onboard",
|
|
values: ["onboard", "elevenlabs", "whisper"],
|
|
formatValue: (value) => voiceProviderLabels[value] ?? value,
|
|
});
|
|
|
|
const wakeWordActionLabels: Record<WakeWordAction, string> = {
|
|
"voice-input": "Voice Input",
|
|
off: "Off",
|
|
"turn-screen-on": "Turn Screen On",
|
|
};
|
|
|
|
export const wakeWordActionSetting = new ConfigSettingEnum<WakeWordAction>({
|
|
id: "wake-word-action",
|
|
label: "Wakeword Action (\"Hey Even\")",
|
|
storageKey: "voice.wakeWordAction",
|
|
defaultValue: "voice-input",
|
|
values: ["voice-input", "off", "turn-screen-on"],
|
|
formatValue: (value) => wakeWordActionLabels[value] ?? value,
|
|
});
|
|
|
|
export const saveVoiceRecordingsSetting = new ConfigSettingBoolean({
|
|
id: "save-voice-recordings",
|
|
label: "Save voice recordings",
|
|
storageKey: "developer.saveVoiceRecordings",
|
|
defaultValue: false,
|
|
});
|
|
|
|
export const elevenLabsApiKeySetting = new ConfigSettingString({
|
|
id: "elevenlabs-api-key",
|
|
label: "ElevenLabs key",
|
|
storageKey: "voice.elevenLabsApiKey",
|
|
defaultValue: "",
|
|
editorTitle: "ElevenLabs API key",
|
|
glassesEditTitle: "Edit ElevenLabs key",
|
|
formatValue: (value) => (value ? `${value.slice(0, 6)}...` : "(not set)"),
|
|
});
|
|
|
|
export const openAiApiKeySetting = new ConfigSettingString({
|
|
id: "openai-api-key",
|
|
label: "OpenAI key",
|
|
storageKey: "voice.openAiApiKey",
|
|
defaultValue: "",
|
|
editorTitle: "OpenAI API key",
|
|
glassesEditTitle: "Edit OpenAI key",
|
|
formatValue: (value) => (value ? `${value.slice(0, 6)}...` : "(not set)"),
|
|
});
|
|
|
|
export const anthropicApiKeySetting = new ConfigSettingString({
|
|
id: "anthropic-api-key",
|
|
label: "Anthropic key",
|
|
storageKey: "llm.anthropicApiKey",
|
|
defaultValue: "",
|
|
editorTitle: "Anthropic API key",
|
|
glassesEditTitle: "Edit Anthropic key",
|
|
formatValue: (value) => (value ? `${value.slice(0, 6)}...` : "(not set)"),
|
|
});
|
|
|
|
export const terminalHostSetting = new ConfigSettingString({
|
|
id: "terminal-host",
|
|
label: "Host",
|
|
storageKey: "terminal.host",
|
|
defaultValue: "",
|
|
editorTitle: "g2mirror host (tailscale IP)",
|
|
glassesEditTitle: "Edit terminal host",
|
|
});
|
|
|
|
export const terminalPortSetting = new ConfigSettingString({
|
|
id: "terminal-port",
|
|
label: "Port",
|
|
storageKey: "terminal.port",
|
|
defaultValue: "8737",
|
|
editorTitle: "g2mirror port",
|
|
glassesEditTitle: "Edit terminal port",
|
|
});
|
|
|
|
export const terminalAuthTokenSetting = new ConfigSettingString({
|
|
id: "terminal-auth-token",
|
|
label: "Auth token",
|
|
storageKey: "terminal.authToken",
|
|
defaultValue: "",
|
|
editorTitle: "g2mirror auth token",
|
|
glassesEditTitle: "Edit terminal auth token",
|
|
});
|
|
|
|
export const nightscoutSiteUrlSetting = new ConfigSettingString({
|
|
id: "nightscout-site-url",
|
|
label: "Nightscout site URL",
|
|
storageKey: "integrations.nightscout.siteUrl",
|
|
defaultValue: "",
|
|
editorTitle: "Nightscout site URL",
|
|
glassesEditTitle: "Edit Nightscout URL",
|
|
normalize: normalizeNightscoutSiteUrl,
|
|
formatValue: emptySettingDisplay,
|
|
});
|
|
|
|
export const nightscoutApiTokenSetting = new ConfigSettingString({
|
|
id: "nightscout-api-token",
|
|
label: "Nightscout API token",
|
|
storageKey: "integrations.nightscout.apiToken",
|
|
defaultValue: "",
|
|
editorTitle: "Nightscout API token",
|
|
glassesEditTitle: "Edit API token",
|
|
normalize: normalizeNightscoutApiToken,
|
|
formatValue: maskToken,
|
|
});
|
|
|
|
|
|
export function screenTimeoutSettingToMs(value: ScreenTimeoutSetting): number | null {
|
|
switch (value) {
|
|
case "15s":
|
|
return 15_000;
|
|
case "30s":
|
|
return 30_000;
|
|
case "1m":
|
|
return 60_000;
|
|
case "never":
|
|
return null;
|
|
}
|
|
}
|
|
|
|
export function brightnessLabel(value: BrightnessSetting): string {
|
|
return value === "auto" ? "Auto" : value;
|
|
}
|
|
|
|
/** The exact level for the wire, or null when the ambient sensor drives it. */
|
|
export function brightnessSettingToLevel(value: BrightnessSetting): number | null {
|
|
return value === "auto" ? null : Number(value);
|
|
}
|
|
|
|
export function screenTimeoutLabel(value: ScreenTimeoutSetting): string {
|
|
return value === "never" ? "Never" : value;
|
|
}
|
|
|
|
export function batteryDisplayModeLabel(value: BatteryDisplayMode): string {
|
|
return value === "icon" ? "Icon" : "Percentage";
|
|
}
|
|
|
|
export function timeFormatLabel(value: TimeFormat): string {
|
|
return value === "12h" ? "12-hour" : "24-hour";
|
|
}
|
|
|
|
export function uiFontLabel(value: UiFontChoice): string {
|
|
return value === "terminusv" ? "TerminusV" : "Terminus";
|
|
}
|
|
|
|
export function loadNightscoutSettings(): NightscoutSettings {
|
|
return {
|
|
siteUrl: nightscoutSiteUrlSetting.get(),
|
|
apiToken: nightscoutApiTokenSetting.get(),
|
|
};
|
|
}
|
|
|
|
export function isNightscoutSettingsConfigured(): boolean {
|
|
return nightscoutSiteUrlSetting.get().length > 0 && nightscoutApiTokenSetting.get().length > 0;
|
|
}
|
|
|
|
|
|
function normalizeSystemCardName(name: string | null | undefined): string {
|
|
const normalized = (name ?? "").replace(/[\x00-\x1f]+/g, " ").replace(/\s+/g, " ").trim();
|
|
return normalized;
|
|
}
|
|
|
|
function normalizeNightscoutSiteUrl(siteUrl: string | null | undefined): string {
|
|
return (siteUrl ?? "").replace(/[\x00-\x1f]+/g, "").trim().replace(/\/+$/, "");
|
|
}
|
|
|
|
function normalizeNightscoutApiToken(apiToken: string | null | undefined): string {
|
|
return (apiToken ?? "").replace(/[\x00-\x1f]+/g, "").trim();
|
|
}
|
|
|
|
function emptySettingDisplay(value: string): string {
|
|
return value || "(empty)";
|
|
}
|
|
|
|
function maskToken(token: string): string {
|
|
if (!token) return "(empty)";
|
|
return token.length <= 6 ? "******" : `${token.slice(0, 2)}...${token.slice(-4)}`;
|
|
}
|
|
|
|
|
|
type SettingsMenuOptions<T> = {
|
|
style?: "cycle"|"submenu"
|
|
onChange?: (ctx: LayerContext, newValue: T, oldValue: T) => void
|
|
}
|
|
|
|
export function enumSettingMenuItem<TValue extends string, TId extends string = string>(
|
|
setting: ConfigSettingEnum<TValue, TId>,
|
|
opts?: SettingsMenuOptions<TValue>
|
|
): MenuItem {
|
|
const style = opts?.style ?? "cycle";
|
|
return {
|
|
label: setting.label,
|
|
onSelect: (ctx) => {
|
|
if (style === "cycle") {
|
|
const oldValue = setting.get();
|
|
const newValue = setting.next(oldValue);
|
|
setting.set(newValue);
|
|
opts?.onChange?.(ctx, newValue, oldValue);
|
|
} else {
|
|
const submenu = new MenuLayer(setting.label, setting.values.map((value) => ({
|
|
label: setting.displayValue(value),
|
|
onSelect: () => {
|
|
const oldValue = setting.get();
|
|
setting.set(value);
|
|
opts?.onChange?.(ctx, value, oldValue);
|
|
ctx.stack.pop();
|
|
},
|
|
render: ({ image, x, y }) => {
|
|
const selected = setting.get() === value ? " *" : "";
|
|
image.drawText(getDefaultSmallFont(), x, y + 3, `${setting.displayValue(value)}${selected}`, 200);
|
|
}
|
|
})));
|
|
ctx.stack.push(submenu);
|
|
}
|
|
},
|
|
render: ({ image, x, y, width }) => {
|
|
drawRightValueMenuItem(image, getDefaultSmallFont(), x, y, width, setting.label, setting.displayValue(setting.get()));
|
|
},
|
|
};
|
|
}
|
|
|
|
export function toggleSettingMenuItem<TId extends string = string>(
|
|
setting: ConfigSettingBoolean<TId>,
|
|
opts?: SettingsMenuOptions<boolean>
|
|
): MenuItem {
|
|
return {
|
|
label: setting.label,
|
|
onSelect: (ctx) => {
|
|
setting.set(!setting.get());
|
|
opts?.onChange?.(ctx, setting.get(), !setting.get());
|
|
},
|
|
render: ({ image, x, y, width, selected }) => {
|
|
drawToggleMenuItem(image, getDefaultSmallFont(), x, y, width, setting.label, setting.get(), selected);
|
|
},
|
|
};
|
|
}
|
|
|
|
export function textSettingMenuItem<TId extends string = string>(
|
|
setting: ConfigSettingString<TId>,
|
|
opts?: SettingsMenuOptions<string>
|
|
): MenuItem {
|
|
return {
|
|
label: setting.label,
|
|
onSelect: (ctx: LayerContext) => {
|
|
void ctx.actions.startTextSettingEdit(setting);
|
|
ctx.stack.push(new EditTextSettingLayer(setting));
|
|
},
|
|
render: ({ image, x, y }) => {
|
|
// displayValue honors the setting's formatValue, so secrets (API keys,
|
|
// tokens) can mask themselves instead of rendering in the clear.
|
|
image.drawText(getDefaultSmallFont(), x, y + 3, `${setting.label}: ${truncateSetting(setting.displayValue())}`, 200);
|
|
}
|
|
};
|
|
}
|
|
|
|
function truncateSetting(value: string, maxLength = 22): string {
|
|
const text = value || "(empty)";
|
|
return text.length <= maxLength ? text : `${text.slice(0, Math.max(0, maxLength - 3))}...`;
|
|
}
|
|
|
|
export class EditTextSettingLayer implements Layer {
|
|
constructor(private readonly setting: ConfigSettingString) {}
|
|
|
|
paint(ctx: LayerContext): GrayImage {
|
|
const font = getDefaultSmallFont();
|
|
// Sized to the hosting stack (full lens in the dashboard window, app
|
|
// viewport in the settings app).
|
|
const { width, height } = ctx.stack.getBaseSize();
|
|
const image = new GrayImage(width, height, 0);
|
|
image.drawText(font, 22, 16, this.setting.glassesEditTitle, 220);
|
|
const message = wrapText(font, "Look at the phone app to type a value.", width - 48);
|
|
for (let index = 0; index < message.length; index++) {
|
|
image.drawText(font, 22, 52 + index * 14, message[index]!, 200);
|
|
}
|
|
image.drawText(font, 22, 110, truncateSetting(this.setting.get(), 52), 220);
|
|
image.drawText(font, 22, height - 36, `${GESTURE_DOUBLE_CLICK} back`, 110);
|
|
return image;
|
|
}
|
|
|
|
handleInput(event: DashboardInputEvent, ctx: LayerContext): void {
|
|
if (event.type === "double-click") {
|
|
void ctx.actions.endTextSettingEdit();
|
|
ctx.stack.pop();
|
|
}
|
|
}
|
|
}
|