mirror of
https://git.undefined-dev.fr/Blendman974/faceclaw.git
synced 2026-11-19 21:03:09 +00:00
Most of the builtin apps had some padding between the window edge and their content, because they expect to be displayed with a line border on their edge. We added a customization option to remove the border, so, that padding is not always necessary. Make the layouts dynamically adjust, to omit the padding when it isn't needed.
307 lines
16 KiB
JavaScript
307 lines
16 KiB
JavaScript
const test = require('node:test');
|
|
const assert = require('node:assert/strict');
|
|
const { bordered } = require('./helpers/viewport.cjs');
|
|
const fs = require('node:fs');
|
|
const path = require('node:path');
|
|
const vm = require('node:vm');
|
|
const ts = require('typescript');
|
|
|
|
function evaluate(source, requireModule, globals = {}) {
|
|
const context = { exports: {}, require: requireModule, ...globals };
|
|
vm.runInNewContext(ts.transpileModule(source, {
|
|
compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2020 },
|
|
}).outputText, context);
|
|
return context.exports;
|
|
}
|
|
const source = (file) => fs.readFileSync(path.join(__dirname, '..', file), 'utf8');
|
|
const load = (file, requireModule) => evaluate(source(file), requireModule);
|
|
|
|
function store(settings = new Map()) {
|
|
return load('app/native/notification-sources.ts', () => ({
|
|
getStringSetting: (key, fallback) => settings.get(key) ?? fallback,
|
|
setStringSetting: (key, value) => settings.set(key, value),
|
|
}));
|
|
}
|
|
const mail = { packageName: 'com.mail', appName: 'Mail' };
|
|
|
|
/** dashboard-settings.ts over the same in-memory store, with `prefs` as its notification-sources. */
|
|
function dashboardSettings(settings, prefs) {
|
|
return evaluate(source('app/ui/dashboard-settings.ts'), (id) => {
|
|
if (id.includes('settings-store')) return {
|
|
onSettingsStoreChanged() {}, getStringSetting: (key, fallback) => settings.get(key) ?? fallback,
|
|
setStringSetting: (key, value) => settings.set(key, value),
|
|
getBooleanSetting: (key, fallback) => settings.get(key) ?? fallback, setBooleanSetting: (key, value) => settings.set(key, value),
|
|
};
|
|
if (id.includes('notification-sources')) return prefs;
|
|
if (id.includes('brightness-curve')) return require('../.test-build/app/g2/brightness-curve.js');
|
|
if (id.includes('animation-speed')) return require('../.test-build/app/ui/animation-speed.js');
|
|
return { Layer: class {}, ASSISTANT_MODEL_CHOICES: [] };
|
|
}, { global: { isIOS: false } });
|
|
}
|
|
|
|
test('"Display new notifications" defaults to 15s; Off stops every popup, the filter still mutes single apps', () => {
|
|
const settings = new Map();
|
|
const prefs = store(settings);
|
|
const api = dashboardSettings(settings, prefs);
|
|
assert.equal(api.newNotificationDisplaySetting.get(), '15s');
|
|
// Array.from: the module's arrays come from its own VM realm.
|
|
const values = Array.from(api.newNotificationDisplaySetting.values);
|
|
assert.deepEqual(values.map((value) => api.newNotificationDisplaySetting.displayValue(value)),
|
|
['Off', 'Until dismissed', '5s', '15s', '1min']);
|
|
assert.deepEqual(values.map(api.newNotificationDisplayTimeoutMs), [null, null, 5_000, 15_000, 60_000]);
|
|
assert.equal(api.shouldPopUpNewNotification(mail.packageName), true);
|
|
prefs.setNotificationSourceEnabled(mail, false);
|
|
assert.equal(api.shouldPopUpNewNotification(mail.packageName), false);
|
|
assert.equal(api.shouldPopUpNewNotification('com.other'), true);
|
|
api.newNotificationDisplaySetting.set('off');
|
|
assert.equal(api.shouldPopUpNewNotification('com.other'), false);
|
|
api.newNotificationDisplaySetting.set('until-dismissed');
|
|
assert.equal(api.shouldPopUpNewNotification('com.other'), true);
|
|
});
|
|
|
|
test('sources default on and retain per-package choices and names across restart and rediscovery', () => {
|
|
const settings = new Map();
|
|
let prefs = store(settings);
|
|
assert.equal(prefs.shouldShowNotificationOnGlasses(mail.packageName), true);
|
|
prefs.rememberNotificationSources([mail, mail, { packageName: 'com.other', appName: 'Mail' }]);
|
|
assert.equal(prefs.readNotificationSources().length, 2);
|
|
prefs.setNotificationSourceEnabled({ ...mail, text: 'private notification content' }, false);
|
|
assert.ok(!Array.from(settings.values()).join('').includes('private notification content'));
|
|
prefs = store(settings);
|
|
prefs.rememberNotificationSources([{ ...mail, appName: 'Renamed Mail' }, { packageName: 'com.new', appName: '' }]);
|
|
assert.equal(prefs.shouldShowNotificationOnGlasses(mail.packageName), false);
|
|
assert.equal(prefs.shouldShowNotificationOnGlasses('com.other'), true);
|
|
assert.equal(prefs.shouldShowNotificationOnGlasses('com.new'), true);
|
|
assert.equal(prefs.readNotificationSources().find((s) => s.packageName === mail.packageName).appName, 'Renamed Mail');
|
|
prefs.setNotificationSourceEnabled(mail, true);
|
|
assert.equal(store(settings).shouldShowNotificationOnGlasses(mail.packageName), true);
|
|
});
|
|
|
|
test('invalid saved source data falls back to enabled', () => {
|
|
for (const raw of ['invalid', '{}', '[null, {}, {"packageName": 1}]']) {
|
|
assert.equal(store(new Map([['notifications.sources', raw]])).shouldShowNotificationOnGlasses('com.mail'), true);
|
|
}
|
|
});
|
|
|
|
function ui(fontSize = 12) {
|
|
const prefs = store();
|
|
let active = [{ ...mail, key: 'key', title: 'Message', text: 'Hello', bigText: '', lines: [], actions: [], postTime: 0 }];
|
|
let dismissals = 0;
|
|
let closes = 0;
|
|
const textwrap = load('app/graphics/textwrap.ts');
|
|
const graphics = require('../.test-build/app/graphics/image.js');
|
|
const { BdfFont } = load('app/graphics/bdffont.ts', () => ({}));
|
|
const font = BdfFont.parse(source(`app/fonts/terminus/ter-u${fontSize}n.bdf`));
|
|
class RecordingImage extends graphics.GrayImage {
|
|
texts = [];
|
|
drawMenuSelection(source, x, y, ...args) {
|
|
this.texts.push(...source.texts.map(t => ({ ...t, x: t.x + x, y: t.y + y })));
|
|
super.drawMenuSelection(source, x, y, ...args);
|
|
}
|
|
drawText(font, x, y, text, value) {
|
|
this.texts.push({ x, y, text });
|
|
super.drawText(font, x, y, text, value);
|
|
}
|
|
}
|
|
const native = {
|
|
ALL_NOTIFICATIONS: 0x7fffffff,
|
|
readActiveNotifications: () => { prefs.rememberNotificationSources(active); return active; },
|
|
dismissNotification: () => { dismissals++; active = []; return true; },
|
|
readNotificationIconByKey: () => ({ icon: null, stale: false }),
|
|
};
|
|
const dependencies = {
|
|
'../graphics/image': { ...graphics, GrayImage: RecordingImage },
|
|
'../graphics/textwrap': textwrap,
|
|
'../graphics/ui-fonts': { getDefaultSmallFont: () => font },
|
|
'../util/numeric-util': { clamp: (n, lo, hi) => Math.max(lo, Math.min(hi, n)) },
|
|
'~/util/numeric-util': { clamp: (n, lo, hi) => Math.max(lo, Math.min(hi, n)) },
|
|
'~/util/date-util': { formatRelativeTime: () => '' },
|
|
'../native/notification-icons': native,
|
|
'../native/notification-sources': prefs,
|
|
'../native/notification-types': require('../.test-build/app/native/notification-types.js'),
|
|
'../native/notification-access': { isNotificationListenerEnabled: () => true },
|
|
'../util/render-freshness': { renderPassAllowsStaleData: () => false },
|
|
'./menu-highlight-motion': require('../.test-build/app/ui/menu-highlight-motion.js'), '../graphics/menu-scroll-list': require('../.test-build/app/graphics/menu-scroll-list.js'), './menu-scroll-motion': require('../.test-build/app/ui/menu-scroll-motion.js'), '../graphics/draw-expression': require('../.test-build/app/graphics/draw-expression.js'),
|
|
'./metrics': load('app/ui/metrics.ts'),
|
|
'./menu-animation-pref': require('../.test-build/app/ui/menu-animation-pref.js'), './animation-speed': require('../.test-build/app/ui/animation-speed.js'), '../native/settings-store': { getStringSetting: (_key, fallback) => fallback }, '../graphics/screen-size': { screenWidth: () => 640, screenHeight: () => 480 },
|
|
'./gestures': {},
|
|
};
|
|
const requireModule = (name) => {
|
|
assert.ok(name in dependencies, `Unexpected dependency ${name}`);
|
|
return dependencies[name];
|
|
};
|
|
dependencies['./menu-core'] = load('app/ui/menu-core.ts', requireModule);
|
|
dependencies['./menu'] = load('app/ui/menu.ts', requireModule);
|
|
const { SingleNotificationLayer } = load('app/ui/notifications.ts', requireModule);
|
|
const { NotificationFilterLayer } = load('app/ui/notification-filter.ts', requireModule);
|
|
const ctx = { stack: { getBaseSize: () => bordered(540, 224), isFocused: () => true, pop: () => closes++ } };
|
|
const popup = new SingleNotificationLayer('key', { origin: 'new-notification-modal', onClose: () => closes++ });
|
|
const trayCloses = [];
|
|
const tray = new SingleNotificationLayer('key', { origin: 'notification-tray', onClose: (_ctx, gone) => trayCloses.push(gone) });
|
|
const filter = new NotificationFilterLayer();
|
|
let paintedBelow = 0;
|
|
const paint = (layer) => layer.paint(ctx, () => { paintedBelow++; return new RecordingImage(540, 224); });
|
|
const input = (layer, type) => layer.handleInput({ type }, ctx);
|
|
return { prefs, popup, tray, filter, paint, input, active: (value) => { active = value; },
|
|
dismissals: () => dismissals, closes: () => closes, trayCloses, paintedBelow: () => paintedBelow };
|
|
}
|
|
|
|
test('a notification the switcher selected reports back and dismissal to it, and repeats its last frame once gone', async () => {
|
|
const app = ui();
|
|
const labels = (image) => image.texts.map(({ text }) => text);
|
|
assert.ok(labels(app.paint(app.tray)).includes('Back'));
|
|
assert.ok(!labels(app.paint(app.tray)).some((text) => text.includes("Don't show")));
|
|
await app.input(app.tray, 'double-click');
|
|
await app.input(app.tray, 'click');
|
|
assert.deepEqual(app.trayCloses, [false, false]);
|
|
await app.input(app.tray, 'scroll-down');
|
|
const last = app.paint(app.tray);
|
|
await app.input(app.tray, 'click');
|
|
assert.equal(app.dismissals(), 1);
|
|
assert.deepEqual(app.trayCloses, [false, false, true]);
|
|
// The switcher swaps in a neighbour after the paint; until then the paint
|
|
// holds what was showing rather than the list below.
|
|
const again = app.paint(app.tray);
|
|
assert.deepEqual(app.trayCloses, [false, false, true, true]);
|
|
assert.equal(app.paintedBelow(), 0);
|
|
// (Compared unbaked: the menu highlight's draws animate with the clock.)
|
|
assert.deepEqual(Buffer.from(again.pixels), Buffer.from(last.pixels));
|
|
assert.deepEqual(again.drawList, last.drawList);
|
|
});
|
|
|
|
test('popup dismisses before confirmation; confirming disables the source even after the notification disappears', async () => {
|
|
const app = ui();
|
|
await app.input(app.popup, 'scroll-down');
|
|
await app.input(app.popup, 'scroll-down');
|
|
await app.input(app.popup, 'click');
|
|
assert.equal(app.dismissals(), 1);
|
|
assert.equal(app.closes(), 0);
|
|
assert.equal(app.prefs.shouldShowNotificationOnGlasses(mail.packageName), true);
|
|
assert.ok(app.paint(app.popup).texts.some(({ text }) => text.includes('Mail')));
|
|
assert.equal(app.closes(), 0);
|
|
await app.input(app.popup, 'scroll-down');
|
|
await app.input(app.popup, 'click');
|
|
assert.equal(app.prefs.shouldShowNotificationOnGlasses(mail.packageName), false);
|
|
assert.equal(app.closes(), 1);
|
|
});
|
|
|
|
test('cancel and back dismiss the popup without changing source preferences', async () => {
|
|
for (const cancel of ['click', 'double-click']) {
|
|
const app = ui();
|
|
await app.input(app.popup, 'scroll-down');
|
|
await app.input(app.popup, 'scroll-down');
|
|
await app.input(app.popup, 'click');
|
|
await app.input(app.popup, cancel);
|
|
assert.equal(app.dismissals(), 1);
|
|
assert.equal(app.closes(), 1);
|
|
assert.equal(app.prefs.shouldShowNotificationOnGlasses(mail.packageName), true);
|
|
}
|
|
});
|
|
|
|
test('filter toggles persist after notifications disappear and discovers new sources while open', async () => {
|
|
const app = ui();
|
|
app.paint(app.filter);
|
|
await app.input(app.filter, 'click');
|
|
assert.equal(app.prefs.shouldShowNotificationOnGlasses(mail.packageName), false);
|
|
app.active([{ packageName: 'com.alpha', appName: 'Alpha' }]);
|
|
const image = app.paint(app.filter);
|
|
assert.ok(image.texts.some(({ text }) => text === 'Alpha'));
|
|
assert.ok(image.texts.some(({ text }) => text === 'Mail'));
|
|
// A source inserted before the selection must not move the toggle to another app.
|
|
await app.input(app.filter, 'click');
|
|
assert.equal(app.prefs.shouldShowNotificationOnGlasses(mail.packageName), true);
|
|
assert.equal(app.prefs.shouldShowNotificationOnGlasses('com.alpha'), true);
|
|
});
|
|
|
|
test('popup action wraps fully and stays visible with small and large fonts', async () => {
|
|
for (const size of [12, 20]) {
|
|
const app = ui(size);
|
|
await app.input(app.popup, 'scroll-down');
|
|
await app.input(app.popup, 'scroll-down');
|
|
const image = app.paint(app.popup);
|
|
assert.ok(image.texts.map(({ text }) => text).join(' ').includes("Don't show on glasses again"));
|
|
assert.ok(image.texts.every(({ y }) => y >= 0 && y < image.height));
|
|
}
|
|
});
|
|
|
|
test('controller filters before waking or opening a popup, and still refreshes the tray', () => {
|
|
const file = ts.createSourceFile('controller.ts', source('app/g2/dashboard-controller.ts'), ts.ScriptTarget.Latest, true);
|
|
const controller = file.statements.find((node) => ts.isClassDeclaration(node) && node.name.text === 'DashboardController');
|
|
const members = ['handleAndroidNotificationPosted', 'handleAndroidNotificationRemoved', 'popUpAndroidNotification']
|
|
.map((name) => controller.members.find((node) => node.name?.getText(file) === name).getText(file));
|
|
const { NotificationPopupDelay, notificationPopupDelayMs } = require('../.test-build/app/ui/shell/notification-popup-delay.js');
|
|
const settings = new Map();
|
|
const prefs = store(settings);
|
|
const { newNotificationDisplaySetting, shouldPopUpNewNotification } = dashboardSettings(settings, prefs);
|
|
let active = [{ ...mail, key: 'key' }];
|
|
let wakes = 0, popups = 0, renders = 0;
|
|
const removed = [];
|
|
const { Harness } = evaluate(`export class Harness { ${members.join('\n')} }`, null, {
|
|
ALL_NOTIFICATIONS: 0x7fffffff,
|
|
readActiveNotifications: () => active,
|
|
shouldPopUpNewNotification,
|
|
notificationPopupDelayMs,
|
|
shell: {
|
|
isScreenOn: () => false,
|
|
wake: () => { wakes++; return true; },
|
|
openNotificationModal: () => popups++,
|
|
notificationRemoved: (key) => removed.push(key),
|
|
},
|
|
});
|
|
// Popup delays run when the test says so.
|
|
let timers = [];
|
|
const elapse = () => { const due = timers; timers = []; for (const timer of due) if (!timer.cancelled) timer.run(); };
|
|
const instance = new Harness();
|
|
instance.notificationPopups = new NotificationPopupDelay((key) => instance.popUpAndroidNotification(key), (run) => {
|
|
const timer = { run, cancelled: false };
|
|
timers.push(timer);
|
|
return () => { timer.cancelled = true; };
|
|
});
|
|
instance.requestShellRender = () => renders++;
|
|
instance.appendLog = () => {};
|
|
|
|
prefs.setNotificationSourceEnabled(mail, false);
|
|
instance.handleAndroidNotificationPosted('key');
|
|
instance.handleAndroidNotificationPosted('gone');
|
|
elapse();
|
|
assert.equal(wakes, 0);
|
|
assert.equal(popups, 0);
|
|
assert.equal(renders, 2);
|
|
|
|
prefs.setNotificationSourceEnabled(mail, true);
|
|
instance.handleAndroidNotificationPosted('key');
|
|
assert.equal(popups, 0, 'the popup waits out its delay');
|
|
elapse();
|
|
assert.equal(wakes, 1);
|
|
assert.equal(popups, 1);
|
|
|
|
// Withdrawn by its source during the delay: no wake, no popup, and the shell hears of it.
|
|
active = [{ ...mail, key: 'working', foregroundService: true }];
|
|
instance.handleAndroidNotificationPosted('working');
|
|
active = [];
|
|
instance.handleAndroidNotificationRemoved('working');
|
|
elapse();
|
|
assert.equal(wakes, 1);
|
|
assert.equal(popups, 1);
|
|
assert.deepEqual(removed, ['working']);
|
|
|
|
// The filter is checked again once the delay is over.
|
|
active = [{ ...mail, key: 'key' }];
|
|
instance.handleAndroidNotificationPosted('key');
|
|
prefs.setNotificationSourceEnabled(mail, false);
|
|
elapse();
|
|
assert.equal(popups, 1);
|
|
|
|
// "Display new notifications: Off" holds back every app's popup, also once the delay is over.
|
|
prefs.setNotificationSourceEnabled(mail, true);
|
|
newNotificationDisplaySetting.set('off');
|
|
instance.handleAndroidNotificationPosted('key');
|
|
elapse();
|
|
newNotificationDisplaySetting.set('15s');
|
|
instance.handleAndroidNotificationPosted('key');
|
|
newNotificationDisplaySetting.set('off');
|
|
elapse();
|
|
assert.equal(wakes, 1);
|
|
assert.equal(popups, 1);
|
|
});
|