diff --git a/app/apps/evenhub/evenhub-window.ts b/app/apps/evenhub/evenhub-window.ts index a0937cb5..a51e7b35 100644 --- a/app/apps/evenhub/evenhub-window.ts +++ b/app/apps/evenhub/evenhub-window.ts @@ -4,7 +4,7 @@ * makes the content area exactly the 576x288 surface EvenHub apps expect. */ import { GrayImage } from "../../graphics/image"; -import { EVENHUB_SCREEN_WIDTH } from "./compositor"; +import { EVENHUB_SCREEN_WIDTH, EVENHUB_SCREEN_HEIGHT } from "./compositor"; import { directionalFallback, isDirectionalInput, type InputEvent } from "../../ui/gestures"; import { type Layer, type LayerContext } from "../../ui/layers"; import { @@ -24,21 +24,26 @@ class EvenHubAppLayer implements Layer { * extension's source field should see that they came from the watch. */ readonly acceptsDirectional = true; + private tallCanvas = false; constructor(private readonly session: EvenHubSession) {} + setTallCanvas(tall: boolean): void { + this.tallCanvas = tall; + } + paint(ctx: LayerContext): GrayImage { const size = ctx.stack.getBaseSize(); - // EvenHub apps lay out for the stock 576-wide surface. In the Full - // Screen display mode the window is 640 wide; paint at stock width and - // centre it rather than leaving all the slack on the right. - if (size.width > EVENHUB_SCREEN_WIDTH) { - const content = this.session.paint({ width: EVENHUB_SCREEN_WIDTH, height: size.height }, ctx.stack.isFocused()); - const image = new GrayImage(size.width, size.height, 0); - content.composeInto(image, Math.floor((size.width - EVENHUB_SCREEN_WIDTH) / 2), 0); - return image; - } - return this.session.paint(size, ctx.stack.isFocused()); + // Host full screen hides chrome; it does not enlarge the stock app canvas. + // Only the app's explicit Faceclaw extended-layout request opts into height. + const canvas = { width: EVENHUB_SCREEN_WIDTH, height: this.tallCanvas ? size.height : EVENHUB_SCREEN_HEIGHT }; + const content = this.session.paint(canvas, ctx.stack.isFocused()); + if (size.width === canvas.width && size.height === canvas.height) return content; + const image = new GrayImage(size.width, size.height, 0); + // Clip text to its logical canvas before placing it in the larger host window. + image.bitBlt(content.withDrawsBaked(), Math.max(0, Math.floor((size.width - canvas.width) / 2)), + Math.max(0, Math.floor((size.height - canvas.height) / 2))); + return image; } handleInput(event: InputEvent): void { @@ -60,6 +65,7 @@ export function createEvenHubWindow( requestShellRender: () => void, ): InProcessWindow { const fallbackIcon = windowIcon("package", session.manifest.name.charAt(0).toUpperCase() || "E"); + const appLayer = new EvenHubAppLayer(session); const created = createInProcessWindow({ appId, windowId, @@ -91,7 +97,7 @@ export function createEvenHubWindow( { label: "Show phone UI", onSelect: (ctx: LayerContext) => { ctx.stack.pop(); onShowPhone(); } }, ], actions: options.actions, - baseLayer: new EvenHubAppLayer(session), + baseLayer: appLayer, submitFrame: options.submitFrame, setSurfaceVisible: options.setSurfaceVisible, removeSurface: options.removeSurface, @@ -109,7 +115,10 @@ export function createEvenHubWindow( pushOverlay: (layer) => created.stack.push(layer), // The extended layout uses the full 576x452 app area ("max"); stock apps // stay in the 576x288 band ("medium"). - setTallCanvas: (tall) => created.setHeightMode(tall ? "max" : "medium"), + setTallCanvas: (tall) => { + appLayer.setTallCanvas(tall); + created.setHeightMode(tall ? "max" : "medium"); + }, setAttention: (attention) => shell.setWindowAttention(windowId, attention), // Only while the app listens for text: otherwise the shell's Type Into App // destinations (voice dialog, phone keyboard, watch) would send into a void. diff --git a/app/g2/dashboard-controller.ts b/app/g2/dashboard-controller.ts index ac7ba7de..5893a214 100644 --- a/app/g2/dashboard-controller.ts +++ b/app/g2/dashboard-controller.ts @@ -452,6 +452,8 @@ class DashboardController { openNotificationsWindow: () => this.openInProcessAppInBackground(NOTIFICATIONS_WINDOW_ID, NOTIFICATIONS_SURFACE_ID, createNotificationsAppWindow), onSwitcherBarHeightChanged: () => this.applySwitcherBarHeight(), + onWindowLayoutChanged: () => this.applySwitcherBarHeight(), + isLocked: () => this.glassesLocked, onScreenStateChanged: (on) => { // Any wake of the regular UI replaces a showing Glanceboard. if (on) this.glance.dismiss(); diff --git a/app/g2/ios-preview-controller.ts b/app/g2/ios-preview-controller.ts index 247d8f1d..89a3d934 100644 --- a/app/g2/ios-preview-controller.ts +++ b/app/g2/ios-preview-controller.ts @@ -221,6 +221,12 @@ export class IosPreviewController { shell.foregroundWindow()?.requestRender() this.requestShellRender() }, + onWindowLayoutChanged: () => { + this.relayout() + shell.foregroundWindow()?.requestRender() + this.requestShellRender() + }, + isLocked: () => this.glassesLocked, onScreenStateChanged: on => { if (on) this.glance.dismiss() // A wake unblanks only once the next shell render has staged an awake diff --git a/app/ui/dashboard-settings.ts b/app/ui/dashboard-settings.ts index 17ff529a..d29b9c98 100644 --- a/app/ui/dashboard-settings.ts +++ b/app/ui/dashboard-settings.ts @@ -148,6 +148,39 @@ export class ConfigSettingBoolean extends ConfigSet } } +const appFullscreenSettings = new Map(); + +/** A user choice independent of an app's own temporary immersive mode. */ +export function appFullscreenSetting(appId: string): ConfigSettingBoolean { + let setting = appFullscreenSettings.get(appId); + if (!setting) { + setting = new ConfigSettingBoolean({ + id: `app-fullscreen-${appId}`, label: "Full screen", + storageKey: `display.fullscreen.${appId}`, defaultValue: false, + reportInAnalytics: false, + }); + appFullscreenSettings.set(appId, setting); + } + return setting; +} + +const appKeepAwakeSettings = new Map(); + +/** Independent of full screen; applies only while this app is visible. */ +export function appKeepAwakeSetting(appId: string): ConfigSettingBoolean { + let setting = appKeepAwakeSettings.get(appId); + if (!setting) { + setting = new ConfigSettingBoolean({ + id: `app-keep-awake-${appId}`, label: "Keep screen awake", + description: "Prevent automatic sleep while this app is visible, in any display mode.", + storageKey: `display.keepAwake.${appId}`, defaultValue: false, + reportInAnalytics: false, + }); + appKeepAwakeSettings.set(appId, setting); + } + return setting; +} + type ConfigSettingEnumOptions = ConfigSettingOptions & { values: readonly TValue[]; normalize?: (value: string | null | undefined) => TValue; diff --git a/app/ui/shell/geometry.ts b/app/ui/shell/geometry.ts index b3b0c75e..606dcd63 100644 --- a/app/ui/shell/geometry.ts +++ b/app/ui/shell/geometry.ts @@ -1,6 +1,7 @@ import { G2_LENS_HEIGHT, G2_LENS_WIDTH } from "../../graphics/image"; import { appSwitcherPositionSetting, + appFullscreenSetting, type AppSwitcherPosition, displayLayoutSetting, type DisplayLayout, @@ -118,7 +119,7 @@ export function setAppImmersive(appId: string, immersive: boolean): boolean { } export function isImmersive(appId?: string): boolean { - return appId !== undefined && immersiveApps.has(appId); + return appId !== undefined && (immersiveApps.has(appId) || appFullscreenSetting(appId).get()); } /** Whether an app's windows span the panel's whole width: Full Screen, or immersive. */ diff --git a/app/ui/shell/shell.ts b/app/ui/shell/shell.ts index d96191c4..0ceff2d1 100644 --- a/app/ui/shell/shell.ts +++ b/app/ui/shell/shell.ts @@ -31,6 +31,9 @@ import type { AssistantContext } from "../../assistant/types"; import { SingleNotificationLayer } from "../notifications"; import { anthropicApiKeySetting, + appFullscreenSetting, + appKeepAwakeSetting, + toggleSettingMenuItem, assistantHermesKeySetting, assistantHermesUrlSetting, assistantBackendSetting, @@ -94,7 +97,8 @@ import type { AppSwitcherPosition } from "../dashboard-settings"; * Input flow: every event enters via receiveInput. The shell consumes * everything while the sidebar or a shell overlay has focus and forwards the * rest to the focused window. Long-press opens the shell-owned system menu - * (Focus app switcher, Voice input, Brightness, Close window, Debug) without reaching the + * (Focus app switcher, Voice input, Brightness, Close current app, Close all apps, + * Debug) without reaching the * app, so the shell keeps working when a window's handler hangs; a window * that claims long-press for a move of its own gets it forwarded instead, and * holding the press past the escape threshold still opens the system menu. @@ -109,7 +113,7 @@ export type ShellWindow = { title: string; /** Compositor surface this window renders to; configured at connect / launch. */ surfaceId: string; - /** Whether the system menu offers Close window (the launcher is pinned). */ + /** Whether the system menu can close this window (the launcher is pinned). */ closeable: boolean; /** * True when tap-then-hold currently opens the window's own context menu @@ -222,6 +226,10 @@ export type ShellConfig = { * after the shell paint that found it. */ onSwitcherBarHeightChanged?: () => void; + /** A per-app full-screen choice changed the viewport and compositor geometry. */ + onWindowLayoutChanged?: () => void; + /** An app's keep-awake preference must not keep the lock screen awake. */ + isLocked?: () => boolean; /** * The Notifications app's window, opened in the background (neither * foregrounded nor focused) unless it is open already, for the switcher @@ -655,6 +663,12 @@ class Shell { if (window) this.closeWindow(window.windowId); } + /** Snapshot ids: close callbacks may remove themselves or other windows. */ + closeAllWindows(): void { + const ids = this.windows.filter(window => window.closeable).map(window => window.windowId); + for (const id of ids) this.closeWindow(id); + } + getWindows(): readonly ShellWindow[] { return this.windows; } @@ -866,7 +880,9 @@ class Shell { // A foreground window that is playing video holds it off the same way. const foreground = this.foregroundWindow(); if (this.activeVoiceLayer || this.activeKeyboardLayer || this.assistantSession?.isTurnActive() || - foreground?.isVoiceCapturing?.() || foreground?.keepsScreenOn?.()) { + foreground?.isVoiceCapturing?.() || foreground?.keepsScreenOn?.() || + (foreground?.closeable && !this.config.isLocked?.() && + appKeepAwakeSetting(foreground.appId).get())) { this.lastInputAtMs = nowMs; return false; } @@ -1073,6 +1089,12 @@ class Shell { if (this.activeVoiceLayer || !this.stack.isAtBase()) { return { shell: true, window: false }; } + // The switcher owns its menu even when the selected app uses a hold + // for a game move or voice capture. + if (this.focus === "sidebar") { + this.openEscapeMenu(); + return { shell: true, window: false }; + } const window = this.foregroundWindow(); if (!window) { return { shell: true, window: false }; @@ -1082,10 +1104,6 @@ class Shell { return { shell: true, window: false }; } if (!window.holdToTalk) this.startEscapeMenuTimer(); - if (this.focus === "sidebar") { - this.focus = "window"; - window.onFocus?.(this.lastInput); - } // The window owns frameId from here (render or explicit finish). await window.handleInput(event, frameId); return { shell: true, window: true }; @@ -1096,6 +1114,10 @@ class Shell { // first), which answers with its own menu or asks for the system menu // when it has none. if (event.type === "short-then-long-press") { + if (this.focus === "sidebar" && !this.activeVoiceLayer && this.stack.isAtBase()) { + this.openEscapeMenu(); + return { shell: true, window: false }; + } const window = this.foregroundWindow(); if (window?.holdToTalk) { this.openEscapeMenu(); @@ -1913,7 +1935,7 @@ class Shell { /** * The system/escape menu: the entries every window shares (Focus app - * switcher, Voice input, Brightness, Close window) plus Debug. Shell-owned and + * switcher, Voice input, Brightness, Close current app, Close all apps) plus Debug. Shell-owned and * shell-drawn (never the app's), so an unresponsive app can always be * closed. It opens for long-press (over the app's own menu too), after an * extended hold in a window that claims long-press, and on a window's @@ -1926,16 +1948,16 @@ class Shell { const items: MenuItem[] = []; if (foreground.closeable) { items.push({ - label: "Close window", + label: "Close current app", onSelect: (ctx) => { // Pop the menu first (its onRemoved returns focus to the sidebar), // then close the window the menu was opened over. ctx.stack.pop(); - this.closeForegroundWindow(); + this.closeWindow(foreground.windowId); }, }); } - // Close window sits first but the menu opens on Focus app switcher, so a + // Close current app sits first but the menu opens on Focus app switcher, so a // reflexive tap never closes the window. const initialSelection = items.length; items.push( @@ -1959,6 +1981,38 @@ class Shell { }, }]), ); + items.push({ + label: "Close all apps", + disabled: () => !this.windows.some(window => window.closeable), + onSelect: (ctx) => { + ctx.stack.pop(); + this.closeAllWindows(); + }, + }); + if (foreground.closeable) { + const fullscreen = appFullscreenSetting(foreground.appId); + items.push({ + label: fullscreen.get() ? "Exit full screen" : "Enter full screen", + description: "Use the whole display for this app.", + onSelect: (ctx) => { + ctx.stack.pop(); + if (!this.windows.some(window => window.windowId === foreground.windowId)) return; + fullscreen.set(!fullscreen.get()); + this.noteUserActivity(); + this.config.onWindowLayoutChanged?.(); + this.focusWindow(foreground.windowId); + this.config.requestShellRender(); + }, + }); + items.push(toggleSettingMenuItem(appKeepAwakeSetting(foreground.appId), { + onChange: (ctx) => { + ctx.stack.pop(); + this.noteUserActivity(); + this.focusWindow(foreground.windowId); + this.config.requestShellRender(); + }, + })); + } if (brightnessSetting.get() !== "auto") { items.push({ label: "Brightness", diff --git a/app/ui/window-menu.ts b/app/ui/window-menu.ts index 07aab3a6..4dae4307 100644 --- a/app/ui/window-menu.ts +++ b/app/ui/window-menu.ts @@ -9,7 +9,7 @@ import type { WorkerAppReply } from "./shell/worker-window"; * The window context menu, opened by tap-then-hold: an app's own menu, * holding its app-specific actions. The shell's system menu (long-press) * carries the entries every window shares — Focus app switcher, Voice input, - * Close window — so an app with nothing of its own to offer has no menu of + * Close current app, Close all apps — so an app with nothing of its own to offer has no menu of * its own: tap-then-hold then opens the system menu in its place, so both * gestures land on the same menu. The system menu is also the safety net: * shell-owned, so an unresponsive app can always be closed (a window that diff --git a/docs/validation-app-fullscreen.md b/docs/validation-app-fullscreen.md new file mode 100644 index 00000000..31f64836 --- /dev/null +++ b/docs/validation-app-fullscreen.md @@ -0,0 +1,36 @@ +# Per-app full screen and keep awake + +Long-press opens the system menu. Closeable apps offer Enter full screen / Exit +full screen. The choice persists per app through the existing settings store, +independently of global display layout and app-controlled immersive mode. +Full screen fills the 640x480 panel, hides chrome while the app has focus, and +resizes existing in-process and worker windows without restarting the app. +The switcher remains accessible through the system menu. + +Stock EvenHub apps retain their logical 576x288 canvas in every host display +mode, including full screen. Content is centered at native pixel scale and +clipped to that canvas; extra space does not change wrapping or layout. +Only an app's explicit Faceclaw extended-layout request enables a taller canvas. +Regression tests compare the complete stock raster against its centered +full-screen placement, including text crossing the logical canvas boundary. + +Keep screen awake is a separate On/Off switch immediately after the full-screen +action in the system menu. It defaults off and persists per app independently +of full screen. Existing full-screen preferences remain unchanged and do not +implicitly enable keep awake. + +Automatic idle sleep is suspended only while an app with Keep screen awake +enabled is in the foreground, in any display mode. A background app does not +hold the display awake. Full screen alone does not suppress idle sleep. +The lock screen and explicit sleep still work. The inactivity countdown starts +fresh after disabling keep awake or leaving a kept-awake app. Existing automatic +holds for voice capture, assistant turns and video playback remain in effect. + +Software regressions cover geometry with every switcher position, preserving +other display settings and persistence after reload, captured menu targets, +exit, independent keep-awake persistence, foreground/background idle behavior, +lock timeout and manual sleep. + +On glasses, verify entry/exit from both in-process apps and worker apps, +reflow, state retention, idle timeout, app switching, lock/off-head behavior, +and reconnection. These hardware checks remain pending. No firmware change. diff --git a/docs/validation-app-switcher-menu.md b/docs/validation-app-switcher-menu.md new file mode 100644 index 00000000..7ae0334f --- /dev/null +++ b/docs/validation-app-switcher-menu.md @@ -0,0 +1,35 @@ +# App switcher close menu + +Feature branch: `feat/app-controls`, based on `main` so it can be +reviewed independently. The combined build lives on `build/all-features`. + +With the app switcher focused, long-press or tap-then-hold opens the existing +shell-owned System menu. “Close current app” closes the selected window when it +is closeable. It is absent for the pinned launcher (the large application grid). +“Close all apps” closes every closeable window, including background windows and +multiple windows belonging to one app. Pinned windows remain available. + +Both actions reuse the shell's normal close/cleanup path. The menu closes before +the windows do, and focus returns to the switcher. It opens on “Focus app switcher” +to avoid an accidental close. With no closeable windows, “Close all apps” is disabled. +No new preferences or persistence format are introduced. + +Software: `tests/app-switcher-menu.test.cjs` covers both gestures, apps claiming +holds/hold-to-talk, launcher exclusion, captured close targets, cancellation, +default selection, multiple windows, reentrant removal, callback errors and +screen-off behavior. Existing in-app gesture routing remains unchanged. + +Manual validation on glasses remains pending: + +1. Open several apps, focus the app switcher, and open the menu with both gestures. +2. Close the selected app; verify its surface disappears and other apps remain. +3. Select the large application grid; verify “Close current app” is absent. +4. Use “Close all apps”; verify the launcher remains usable and apps can reopen. +5. Repeat for left/right/bottom/popup switcher positions and with a running game, + a hold-to-talk app and an app exposing multiple windows. +6. Check cancel/back and the initial selection do not close anything. Check both + menu gestures still work normally when focus is inside an app. + +Closing windows retains each app's existing lifecycle semantics; it does not +uninstall apps or reset their preferences. Existing app-specific shutdown behavior +(such as a remote terminal connection) is the same as closing its window normally. diff --git a/tests/ai-chat.test.cjs b/tests/ai-chat.test.cjs index 635ce280..35bcea38 100644 --- a/tests/ai-chat.test.cjs +++ b/tests/ai-chat.test.cjs @@ -267,6 +267,9 @@ function shellEnv({ wakeAction = 'voice-input', skipConfirmation = false } = {}) } const voiceDialogs = []; const settings = { wakeWordActionSetting: { get: () => wakeAction }, brightnessSetting: { get: () => 'auto' }, + appFullscreenSetting: () => ({ get: () => false }), + appKeepAwakeSetting: () => ({ label: 'Keep screen awake', get: () => false }), + toggleSettingMenuItem: setting => ({ label: setting.label }), assistantSkipConfirmationSetting: { get: () => skipConfirmation } }; const { shell, rawInputEventToInputEvent } = load('app/ui/shell/shell.ts', { '../../graphics/shell-scene': { encodeShellScene: () => new Uint8Array([0, 0]) }, @@ -370,6 +373,7 @@ test('ordinary apps retain long-press system menu and games retain the escape ti assert.deepEqual(env.input, []); env.shell.stack.clearToBase(); env.app.window.claimsLongPress = () => true; + env.shell.focusWindow('ai-chat'); await env.shell.receiveInput(env.event('long-press')); assert.notEqual(env.shell.escapeMenuTimer, null); await env.shell.receiveInput(env.event('long-press-release')); diff --git a/tests/app-layout.test.cjs b/tests/app-layout.test.cjs index 533ae0e8..dc438155 100644 --- a/tests/app-layout.test.cjs +++ b/tests/app-layout.test.cjs @@ -15,6 +15,8 @@ function geometry() { appSwitcherPositionSetting: 'left', uiDepthSetting: '0', statusBarPositionSetting: 'top', statusBarVisibilitySetting: 'always', windowBorderSetting: true, }).map(([name, value]) => [name, { value, get() { return this.value; } }])); + const fullscreen = new Map(); + settings.appFullscreenSetting = id => ({ get: () => fullscreen.get(id) ?? false, set: value => fullscreen.set(id, value) }); const context = { exports: {}, require: (name) => { if (name === '../../graphics/image') return { G2_LENS_WIDTH: 640, G2_LENS_HEIGHT: 480 }; assert.equal(name, '../dashboard-settings'); @@ -27,6 +29,25 @@ function geometry() { const LAYOUTS = ['band-top', 'band-high', 'band-middle', 'band-low', 'band-bottom', 'tall', 'fullscreen']; +test('user full screen spans the panel with any switcher and survives app immersive cleanup', () => { + const g = geometry(); + const previous = g.rect('min', 'test'); + for (const position of ['left', 'right', 'bottom', 'popup']) { + g.settings.appSwitcherPositionSetting.value = position; + g.settings.appFullscreenSetting('test').set(true); + assert.deepEqual(g.rect('min', 'test'), { x: 0, y: 0, width: 640, height: 480 }); + assert.equal(g.sidebarStripVisible('window', 'test'), false); + assert.equal(g.sidebarStripVisible('sidebar', 'test'), true); + g.setAppImmersive('test', true); + g.setAppImmersive('test', false); + assert.equal(g.isImmersive('test'), true); + assert.equal(g.isImmersive('other'), false); + } + g.settings.appSwitcherPositionSetting.value = 'left'; + g.settings.appFullscreenSetting('test').set(false); + assert.deepEqual(g.rect('min', 'test'), previous); +}); + test('defaults preserve normal windows, EvenHub height and tall terminal sessions', () => { const g = geometry(); assert.deepEqual(g.rect('min', 'navigate'), { x: 64, y: 124, width: 576, height: 260 }); diff --git a/tests/app-switcher-menu.test.cjs b/tests/app-switcher-menu.test.cjs new file mode 100644 index 00000000..ff461063 --- /dev/null +++ b/tests/app-switcher-menu.test.cjs @@ -0,0 +1,226 @@ +const test = require('node:test'); +const assert = require('node:assert/strict'); +const fs = require('node:fs'); +const path = require('node:path'); +const vm = require('node:vm'); +const ts = require('typescript'); + +function fixture(options = {}) { + const source = ts.createSourceFile('shell.ts', fs.readFileSync(path.join(__dirname, '../app/ui/shell/shell.ts'), 'utf8'), ts.ScriptTarget.Latest, true); + const shellClass = source.statements.find(node => ts.isClassDeclaration(node) && node.name.text === 'Shell'); + const names = new Set(['routeInput', 'openEscapeMenu', 'closeAllWindows', 'closeWindow', 'removeWindow', + 'foregroundWindow', 'noteWindowVisible', 'mostRecentWindowIndex', 'yieldFocusToSidebar', 'applyScreenTimeout']); + const methods = shellClass.members.filter(node => names.has(node.name?.getText(source))); + assert.equal(methods.length, names.size); + const overlay = source.statements.find(node => ts.isClassDeclaration(node) && node.name.text === 'ShellOverlayMenuLayer'); + class MenuLayer { + constructor(title, items) { this.title = title; this.items = items; } + selectItem(index) { this.selectedIndex = index; } + } + const fullscreen = new Map(); + const keepAwake = new Map(); + const context = { + exports: {}, MenuLayer, console: { warn: () => {} }, + appViewportRect: () => ({ x: 0, y: 0, width: 576 }), CONTEXT_MENU_DIM: 0.5, + brightnessSetting: { get: () => 'auto' }, gestureHints: () => 'App menu', + GESTURE_SHORT_THEN_LONG_PRESS: 'tap-hold', makeInputEvent: event => event, + isWatchInput: event => event.source === 'watch', isDirectionalInput: () => false, + appFullscreenSetting: id => ({ get: () => fullscreen.get(id) ?? false, set: value => fullscreen.set(id, value) }), + appKeepAwakeSetting: id => ({ label: 'Keep screen awake', get: () => keepAwake.get(id) ?? false, set: value => keepAwake.set(id, value) }), + toggleSettingMenuItem: (setting, options) => ({ label: setting.label, onSelect(ctx) { + setting.set(!setting.get()); options.onChange(ctx); + } }), + }; + vm.runInNewContext(ts.transpileModule(`${overlay.getText(source)}\nexport class Shell { ${methods.map(node => node.getText(source)).join('\n')} }`, { + compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2020 }, + }).outputText, context); + const s = new context.exports.Shell(); + const closed = [], delivered = [], warnings = [], renders = []; + context.console.warn = message => warnings.push(message); + const window = (id, closeable = true, extra = {}) => ({ + appId: id, windowId: id, closeable, + handleInput: async event => delivered.push([id, event.type]), + requestRender: () => renders.push(id), + close: () => closed.push(id), + ...extra, + }); + const launcher = window('launcher', false); + const app = window('current', true, options.app); + const background = window('background'); + const layers = []; + s.stack = { + isAtBase: () => !layers.length, + push: layer => layers.push(layer), + pop: () => layers.pop()?.onRemoved?.(), + popIfTop: predicate => { if (!layers.length || !predicate(layers.at(-1))) return false; s.stack.pop(); return true; }, + handleInput: async event => { if (event.type === 'double-click') s.stack.pop(); }, + }; + Object.assign(s, { + windows: [launcher, app, background], selectedIndex: 1, focus: 'sidebar', screenOn: true, + mruWindowIds: ['current', 'background', 'launcher'], attention: new Map(), + config: { voiceInputEnabled: false, requestShellRender() {}, onWindowsChanged() {} }, + cancelEscapeMenuTimer() {}, startEscapeMenuTimer() { s.escapeStarted = true; }, + lastInput: null, + lastInputAtMs: 0, + noteUserActivity() { this.lastInputAtMs = 100; }, + focusWindow(id) { this.selectedIndex = this.windows.findIndex(w => w.windowId === id); this.focus = 'window'; }, + sleep() { this.screenOn = false; }, + }); + const input = type => s.routeInput({ type, source: 'ring', timestampMs: 100 }, 1); + const menu = () => layers.at(-1); + const choose = label => { + const item = menu().items.find(item => item.label === label); + assert.ok(item, label); + item.onSelect({ stack: s.stack }); + }; + return { s, input, menu, choose, closed, delivered, warnings, renders, launcher, app, background, window, fullscreen, keepAwake }; +} + +test('full screen targets the captured app without inhibiting idle sleep', async () => { + const h = fixture(); + h.s.config.getScreenTimeoutMs = () => 1000; + let relayouts = 0; + h.s.config.onWindowLayoutChanged = () => relayouts++; + await h.input('long-press'); + h.s.selectedIndex = 2; + h.choose('Enter full screen'); + assert.equal(h.fullscreen.get('current'), true); + assert.equal(h.s.foregroundWindow().windowId, 'current'); + assert.equal(h.s.focus, 'window'); + assert.equal(relayouts, 1); + assert.equal(h.s.applyScreenTimeout(5000), true); + h.s.screenOn = true; + h.s.focusWindow('current'); + await h.input('long-press'); + h.choose('Exit full screen'); + assert.equal(h.fullscreen.get('current'), false); + assert.equal(relayouts, 2); + assert.equal(h.s.applyScreenTimeout(7000), true); +}); + +test('keep awake is independent of full screen and applies only to the visible app', async () => { + const h = fixture(); + h.s.config.getScreenTimeoutMs = () => 1000; + await h.input('long-press'); + const labels = h.menu().items.map(item => item.label); + assert.equal(labels.indexOf('Keep screen awake'), labels.indexOf('Enter full screen') + 1); + h.s.selectedIndex = 2; + h.choose('Keep screen awake'); + assert.equal(h.keepAwake.get('current'), true); + assert.equal(h.fullscreen.get('current'), undefined); + assert.equal(h.s.foregroundWindow().windowId, 'current'); + assert.equal(h.s.applyScreenTimeout(5000), false); + h.s.focusWindow('background'); + assert.equal(h.s.applyScreenTimeout(5500), false); + assert.equal(h.s.applyScreenTimeout(6000), true); + h.s.screenOn = true; + h.s.focusWindow('current'); + await h.input('long-press'); h.choose('Enter full screen'); + assert.equal(h.s.applyScreenTimeout(7000), false); + await h.input('long-press'); h.choose('Exit full screen'); + assert.equal(h.keepAwake.get('current'), true); + assert.equal(h.s.applyScreenTimeout(8000), false); + await h.input('long-press'); h.choose('Keep screen awake'); + assert.equal(h.keepAwake.get('current'), false); + assert.equal(h.s.applyScreenTimeout(9000), true); +}); + +test('keep awake does not suppress lock timeout or manual sleep, and options are absent for the launcher', async () => { + const h = fixture(); + h.fullscreen.set('current', true); + h.keepAwake.set('current', true); + h.s.config.getScreenTimeoutMs = () => 1000; + h.s.config.isLocked = () => true; + assert.equal(h.s.applyScreenTimeout(5000), true); + h.s.screenOn = true; + h.s.config.isLocked = () => false; + h.s.sleep(); + assert.equal(h.s.screenOn, false); + h.s.screenOn = true; + h.s.selectedIndex = 0; + await h.input('long-press'); + assert.ok(!h.menu().items.some(item => /full screen/.test(item.label))); + assert.ok(!h.menu().items.some(item => item.label === 'Keep screen awake')); +}); + +test('switcher opens its menu on hold or tap-hold even for an app claiming holds or hold-to-talk', async () => { + for (const type of ['long-press', 'short-then-long-press']) { + for (const app of [{}, { claimsLongPress: () => true }, { holdToTalk: true }]) { + const h = fixture({ app }); + await h.input(type); + assert.ok(h.menu()); + assert.ok(h.menu().items.some(item => item.label === 'Close current app')); + assert.ok(h.menu().items.some(item => item.label === 'Close all apps')); + assert.equal(h.menu().items[h.menu().selectedIndex].label, 'Focus app switcher'); + assert.deepEqual(h.delivered, [['current', 'system-menu-opened']]); + assert.equal(h.s.escapeStarted, undefined); + assert.equal(h.s.focus, 'sidebar'); + } + } +}); + +test('close current app closes the captured window and preserves the launcher and background windows', async () => { + const h = fixture(); + await h.input('long-press'); + h.s.selectedIndex = 2; // An asynchronous focus change must not redirect the close action. + h.choose('Close current app'); + assert.deepEqual(h.closed, ['current']); + assert.deepEqual(h.s.windows.map(w => w.windowId), ['launcher', 'background']); + assert.equal(h.s.focus, 'sidebar'); + assert.equal(h.menu(), undefined); +}); + +test('launcher offers close all but never close current; close all leaves only the launcher', async () => { + const h = fixture(); + h.s.selectedIndex = 0; + await h.input('short-then-long-press'); + assert.ok(!h.menu().items.some(item => item.label === 'Close current app')); + h.choose('Close all apps'); + assert.deepEqual(h.closed, ['current', 'background']); + assert.deepEqual(h.s.windows.map(w => w.windowId), ['launcher']); + assert.equal(h.s.selectedIndex, 0); + assert.equal(h.s.focus, 'sidebar'); + await h.input('long-press'); + assert.equal(h.menu().items.find(item => item.label === 'Close all apps').disabled(), true); +}); + +test('close all uses normal cleanup despite reentrant removal, multiple windows per app and throwing callbacks', () => { + const h = fixture(); + h.s.windows.push(h.window('another', true, { appId: 'current' }), h.window('pinned', false)); + h.app.close = () => { h.closed.push('current'); h.s.removeWindow('current'); }; + h.background.close = () => { h.closed.push('background'); throw new Error('failed cleanup'); }; + h.s.closeAllWindows(); + assert.deepEqual(h.closed, ['current', 'background', 'another']); + assert.deepEqual(h.s.windows.map(w => w.windowId), ['launcher', 'pinned']); + assert.equal(h.warnings.length, 1); + assert.equal(h.s.foregroundWindow().windowId, 'launcher'); +}); + +test('default selection and cancel do not close apps; an open overlay never receives a second menu', async () => { + const h = fixture(); + await h.input('long-press'); + h.choose(h.menu().items[h.menu().selectedIndex].label); + assert.deepEqual(h.closed, []); + await h.input('long-press'); + const menu = h.menu(); + await h.input('long-press'); + assert.equal(h.menu(), menu); + await h.input('double-click'); + assert.equal(h.menu(), undefined); + assert.deepEqual(h.closed, []); +}); + +test('in-app hold actions and app menus keep their existing routing; asleep switcher stays asleep', async () => { + for (const [app, type] of [[{ claimsLongPress: () => true }, 'long-press'], [{ holdToTalk: true }, 'long-press'], [{}, 'short-then-long-press']]) { + const h = fixture({ app }); + h.s.focus = 'window'; + await h.input(type); + assert.deepEqual(h.delivered, [['current', type]]); + assert.equal(h.menu(), undefined); + } + const h = fixture(); + h.s.screenOn = false; + await h.input('long-press'); + assert.equal(h.menu(), undefined); + assert.deepEqual(h.closed, []); +}); diff --git a/tests/brightness-picker.test.cjs b/tests/brightness-picker.test.cjs index bc212b57..2b9daffc 100644 --- a/tests/brightness-picker.test.cjs +++ b/tests/brightness-picker.test.cjs @@ -39,6 +39,9 @@ const menu = load('app/ui/menu.ts', { function fixture(initial = '50', viewport = { x: 64, y: 124, width: 576, height: 260 }) { let value = initial, writes = 0, closed = 0; const settings = { + appFullscreenSetting: () => ({ get: () => false }), + appKeepAwakeSetting: () => ({ label: 'Keep screen awake', get: () => false }), + toggleSettingMenuItem: setting => ({ label: setting.label }), brightnessSetting: { get: () => value, set: (next) => { value = next; writes++; } }, brightnessSettingToLevel: (value) => value === 'auto' ? null : Number(value), }; @@ -120,13 +123,16 @@ test('system menu hides brightness in Auto and opens its picker between Voice in shell.openSystemMenu('test'); let opened = shell.stack.layers.at(-1); assert.deepEqual(Array.from(opened.items, (item) => item.label), - ['Close window', 'Focus app switcher', 'Voice input', 'Debug']); + ['Close current app', 'Focus app switcher', 'Voice input', 'Close all apps', 'Enter full screen', 'Keep screen awake', 'Debug']); shell.stack.clearToBase(); f.settings.brightnessSetting.set('40'); shell.openSystemMenu('test'); opened = shell.stack.layers.at(-1); assert.deepEqual(Array.from(opened.items, (item) => item.label), - ['Close window', 'Focus app switcher', 'Voice input', 'Brightness', 'Debug']); + ['Close current app', 'Focus app switcher', 'Voice input', 'Close all apps', 'Enter full screen', 'Keep screen awake', 'Brightness', 'Debug']); + await shell.stack.handleInput(gestures.makeInputEvent({ type: 'scroll-down' })); + await shell.stack.handleInput(gestures.makeInputEvent({ type: 'scroll-down' })); + await shell.stack.handleInput(gestures.makeInputEvent({ type: 'scroll-down' })); await shell.stack.handleInput(gestures.makeInputEvent({ type: 'scroll-down' })); await shell.stack.handleInput(gestures.makeInputEvent({ type: 'scroll-down' })); await shell.stack.handleInput(gestures.makeInputEvent({ type: 'click', source: 'ring' })); diff --git a/tests/display-layout-setting.test.cjs b/tests/display-layout-setting.test.cjs index 55e44f71..84332242 100644 --- a/tests/display-layout-setting.test.cjs +++ b/tests/display-layout-setting.test.cjs @@ -64,3 +64,32 @@ test('Full Screen is offered only with a bottom or popup app switcher', () => { assert.deepEqual(Array.from(api.DISPLAY_LAYOUT_VALUES, (value) => api.displayLayoutLabel(value)), ['Band · Top', 'Band · High', 'Band · Middle', 'Band · Low', 'Band · Bottom', 'Tall', 'Full Screen']); }); + +test('per-app full screen defaults off, persists across restart and preserves display preferences', () => { + const store = new Map([['display.layout', 'band-low'], ['terminal.displayLayout', 'tall']]); + const prefs = settingsFixture(store); + assert.equal(prefs.appFullscreenSetting('terminal').get(), false); + prefs.appFullscreenSetting('terminal').set(true); + const restarted = settingsFixture(store); + assert.equal(restarted.appFullscreenSetting('terminal').get(), true); + assert.equal(restarted.appFullscreenSetting('other').get(), false); + restarted.appFullscreenSetting('terminal').set(false); + assert.equal(restarted.displayLayoutSetting.get(), 'band-low'); + assert.equal(store.get('terminal.displayLayout'), 'tall'); +}); + +test('keep awake persists per app independently of full screen, including existing full-screen choices', () => { + const store = new Map([['display.fullscreen.terminal', true]]); + let prefs = settingsFixture(store); + assert.equal(prefs.appFullscreenSetting('terminal').get(), true); + assert.equal(prefs.appKeepAwakeSetting('terminal').get(), false); + prefs.appKeepAwakeSetting('terminal').set(true); + prefs = settingsFixture(store); + assert.equal(prefs.appKeepAwakeSetting('terminal').get(), true); + assert.equal(prefs.appKeepAwakeSetting('other').get(), false); + prefs.appFullscreenSetting('terminal').set(false); + assert.equal(prefs.appKeepAwakeSetting('terminal').get(), true); + prefs.appKeepAwakeSetting('terminal').set(false); + prefs = settingsFixture(store); + assert.equal(prefs.appKeepAwakeSetting('terminal').get(), false); +}); diff --git a/tests/evenhub-window-canvas.test.cjs b/tests/evenhub-window-canvas.test.cjs new file mode 100644 index 00000000..3694ad97 --- /dev/null +++ b/tests/evenhub-window-canvas.test.cjs @@ -0,0 +1,81 @@ +const test = require('node:test'); +const assert = require('node:assert/strict'); +const { loader } = require('./helpers/load-typescript.cjs'); +const { GrayImage } = require('../.test-build/app/graphics/image.js'); + +function fixture() { + let options, hooks; + const paints = [], heights = []; + const session = { + manifest: { name: 'Test', packageId: 'test.app' }, + renderWindowIcon() {}, contextMenuItems: () => [], keepsScreenOn: () => false, + attachWindow(value) { hooks = value; }, + paint(size, focused) { + paints.push({ ...size, focused }); + const image = new GrayImage(size.width, size.height); + image.setPixel(0, 0, 255); + image.setPixel(size.width - 1, size.height - 1, 120); + // Deliberately overflow a deferred text run: stock clips it at 576x288. + image.drawFwText({ bakeFwTextRun(target, run, dx, dy) { + target.fillRect(run.x + dx, run.y + dy, 20, 20, run.value); + } }, 570, 280, 200, [{}]); + return image; + }, + }; + const load = loader({}, { + '../../graphics/image': { GrayImage }, + './compositor': { EVENHUB_SCREEN_WIDTH: 576, EVENHUB_SCREEN_HEIGHT: 288 }, + '../../ui/gestures': {}, '../../ui/shell/shell': { shell: {} }, './session': {}, + '../../ui/shell/chrome-layer': { windowIcon: () => () => null, makeImageWindowIcon: () => () => null }, + './installed-apps': {}, + '../../ui/shell/in-process-window': { createInProcessWindow(value) { + options = value; + return { window: {}, stack: {}, requestRender() {}, setHeightMode(mode) { heights.push(mode); } }; + } }, + }); + load('app/apps/evenhub/evenhub-window.ts').createEvenHubWindow('test', 'test', session, {}, () => {}, () => {}); + return { paints, heights, hooks: () => hooks, + paint(width, height, focused = true) { + return options.baseLayer.paint({ stack: { getBaseSize: () => ({ width, height }), isFocused: () => focused } }); + }, + }; +} + +test('stock EvenHub canvas remains 576x288 through full-screen entry, resize and exit', () => { + const f = fixture(); + for (const [width, height] of [[576, 288], [640, 480], [576, 452], [640, 480], [576, 288]]) { + const image = f.paint(width, height); + assert.deepEqual(f.paints.at(-1), { width: 576, height: 288, focused: true }); + assert.equal(image.width, width); + assert.equal(image.height, height); + } +}); + +test('full screen centers stock pixels at native scale and clips overflowing text to the stock canvas', () => { + const f = fixture(); + const stock = f.paint(576, 288).withDrawsBaked(); + const full = f.paint(640, 480).withDrawsBaked(); + for (let y = 0; y < 480; y++) { + for (let x = 0; x < 640; x++) { + const expected = x >= 32 && x < 608 && y >= 96 && y < 384 ? stock.getPixel(x - 32, y - 96) : 0; + assert.equal(full.getPixel(x, y), expected); + } + } +}); + +test('only an explicit extended-layout request opts into the taller canvas', () => { + const f = fixture(); + f.paint(640, 480, false); + assert.deepEqual(f.paints.at(-1), { width: 576, height: 288, focused: false }); + f.hooks().setTallCanvas(true); + assert.deepEqual(f.heights, ['max']); + f.paint(576, 452); + assert.equal(f.paints.at(-1).height, 452); + f.paint(640, 480); + assert.equal(f.paints.at(-1).width, 576); + assert.equal(f.paints.at(-1).height, 480); + f.hooks().setTallCanvas(false); + f.paint(640, 480); + assert.deepEqual(f.heights, ['max', 'medium']); + assert.equal(f.paints.at(-1).height, 288); +});