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.
244 lines
13 KiB
JavaScript
244 lines
13 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 os = require('node:os');
|
|
const path = require('node:path');
|
|
const vm = require('node:vm');
|
|
const { execFileSync } = require('node:child_process');
|
|
const ts = require('typescript');
|
|
const { kotlinCompiler } = require('./helpers/kotlin-compiler.cjs');
|
|
|
|
const source = (file) => fs.readFileSync(path.join(__dirname, '..', file), 'utf8');
|
|
function load(file, requireModule, globals = {}) {
|
|
const context = { exports: {}, require: requireModule, console, ...globals };
|
|
vm.runInNewContext(ts.transpileModule(source(file), {
|
|
compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2020 },
|
|
}).outputText, context);
|
|
return context.exports;
|
|
}
|
|
function store(settings = new Map()) {
|
|
const listeners = [];
|
|
const storage = {
|
|
getStringSetting: (key, fallback) => settings.get(key) ?? fallback,
|
|
setStringSetting: (key, value) => {
|
|
settings.set(key, value);
|
|
for (const listener of listeners) listener(key);
|
|
},
|
|
onSettingsStoreChanged: (listener) => { listeners.push(listener); return () => {}; },
|
|
};
|
|
return { prefs: load('app/native/media-apps.ts', () => storage), storage };
|
|
}
|
|
const chrome = { packageName: 'com.android.chrome', appName: 'Chrome' };
|
|
const player = { packageName: 'com.player', appName: 'Player' };
|
|
|
|
test('defaults apply before discovery; explicit choices survive restart, renames and rediscovery', () => {
|
|
const settings = new Map();
|
|
let { prefs } = store(settings);
|
|
assert.equal(prefs.isMediaAppEnabled(chrome.packageName), false);
|
|
assert.equal(prefs.isMediaAppEnabled(player.packageName), true);
|
|
assert.equal(prefs.isMediaAppEnabled('com.android.chrome.music'), true);
|
|
prefs.rememberMediaApps([chrome, player, player, { packageName: '', appName: 'Invalid' }]);
|
|
assert.equal(prefs.readMediaApps().length, 2);
|
|
prefs.setMediaAppEnabled({ ...chrome, title: 'Do not store metadata' }, true);
|
|
prefs.setMediaAppEnabled(player, false);
|
|
({ prefs } = store(settings));
|
|
prefs.rememberMediaApps([{ ...player, appName: 'Renamed player' }, chrome]);
|
|
assert.equal(prefs.isMediaAppEnabled(chrome.packageName), true);
|
|
assert.equal(prefs.isMediaAppEnabled(player.packageName), false);
|
|
assert.equal(prefs.readMediaApps().find((a) => a.packageName === player.packageName).appName, 'Renamed player');
|
|
assert.ok(!Array.from(settings.values()).join('').includes('Do not store metadata'));
|
|
prefs.rememberMediaApps([]);
|
|
assert.equal(prefs.readMediaApps().length, 2);
|
|
prefs.setMediaAppEnabled(player, true);
|
|
prefs.setMediaAppEnabled(chrome, false);
|
|
assert.equal(store(settings).prefs.isMediaAppEnabled(player.packageName), true);
|
|
assert.equal(store(settings).prefs.isMediaAppEnabled(chrome.packageName), false);
|
|
});
|
|
|
|
test('malformed saved entries preserve defaults, and discovery does not freeze defaults', () => {
|
|
for (const raw of ['invalid', '{}', '[null, {}, {"packageName": 1}]',
|
|
'[{"packageName":"com.android.chrome","enabled":"true"}]']) {
|
|
const { prefs } = store(new Map([['music.apps', raw]]));
|
|
assert.equal(prefs.isMediaAppEnabled(chrome.packageName), false);
|
|
assert.equal(prefs.isMediaAppEnabled(player.packageName), true);
|
|
}
|
|
const { prefs } = store();
|
|
prefs.rememberMediaApps([chrome]);
|
|
assert.equal(prefs.readMediaApps()[0].enabled, undefined);
|
|
});
|
|
|
|
function bridges() {
|
|
const { prefs, storage } = store();
|
|
let browserListener, controllerListener, ignored, queries = 0, disconnects = 0, plays = 0;
|
|
const browsable = [chrome, player].map((app) => ({ ...app, serviceClass: `${app.packageName}.Browser` }));
|
|
class NativeBrowser {
|
|
setListener(listener) { browserListener = listener; }
|
|
listBrowsableAppsJson() { queries++; return JSON.stringify(browsable); }
|
|
connect(id) { browserListener.onConnectResult(id, true, 'root', ''); }
|
|
disconnect() { disconnects++; }
|
|
playFromMediaId() { plays++; }
|
|
}
|
|
class NativeController {
|
|
setIgnoredPackagesJson(json) { ignored = JSON.parse(json); }
|
|
setListener(listener) { controllerListener = listener; }
|
|
start() { assert.ok(ignored.includes(chrome.packageName)); }
|
|
}
|
|
const dependencies = {
|
|
'@nativescript/core': { Utils: { android: { getApplicationContext: () => ({}) } } },
|
|
'./media-apps': prefs,
|
|
'./settings-store': storage,
|
|
'../graphics/image': {},
|
|
'./image-files': {},
|
|
'./notification-access': { isNotificationListenerEnabled: () => true },
|
|
'./media-types': load('app/native/media-types.ts', () => { throw new Error('media-types has no imports'); }),
|
|
// Signed out of Spotify's Web API: the bridges are the native session and browser services alone.
|
|
'./spotify': { spotifyService: () => null },
|
|
'./spotify-player': { SPOTIFY_ANDROID_PACKAGE: 'com.spotify.music' },
|
|
};
|
|
const globals = { global: { isAndroid: true }, com: { faceclaw: { app: {
|
|
FaceclawMediaBrowser: NativeBrowser,
|
|
FaceclawMediaBrowserListener: function(listener) { return listener; },
|
|
FaceclawMediaController: NativeController,
|
|
FaceclawMediaControllerListener: function(listener) { return listener; },
|
|
} } } };
|
|
const requireModule = (name) => { assert.ok(name in dependencies, name); return dependencies[name]; };
|
|
const browser = load('app/native/media-browser.ts', requireModule, globals).mediaBrowserBridge;
|
|
const controller = load('app/native/media-controller.ts', requireModule, globals).mediaControllerBridge;
|
|
return { prefs, browser, controller, browsable, queries: () => queries, disconnects: () => disconnects,
|
|
plays: () => plays, ignored: () => ignored, observed: (apps) => controllerListener.onSessionAppsChanged(JSON.stringify(apps)) };
|
|
}
|
|
|
|
test('browse discovery remembers ignored apps and cached results reflect toggles immediately', async () => {
|
|
const b = bridges();
|
|
assert.deepEqual(Array.from(b.browser.listBrowsableApps(), (a) => a.packageName), [player.packageName]);
|
|
assert.equal(b.prefs.readMediaApps().length, 2);
|
|
b.prefs.setMediaAppEnabled(chrome, true);
|
|
assert.equal(b.browser.listBrowsableApps().length, 2);
|
|
assert.equal(b.queries(), 1);
|
|
await b.browser.connect(b.browsable[0]);
|
|
b.browser.playFromMediaId('song');
|
|
assert.equal(b.plays(), 1);
|
|
b.prefs.setMediaAppEnabled(chrome, false);
|
|
assert.equal(b.disconnects(), 1);
|
|
b.browser.playFromMediaId('song');
|
|
assert.equal(b.plays(), 1);
|
|
await assert.rejects(b.browser.connect(b.browsable[0]), /ignored/);
|
|
b.prefs.setMediaAppEnabled(player, false);
|
|
assert.equal(b.browser.listBrowsableApps().length, 0);
|
|
});
|
|
|
|
test('native controller gets defaults before start and records all session owners, retaining ended sessions', async () => {
|
|
const b = bridges();
|
|
await b.controller.start();
|
|
b.observed([chrome, player]);
|
|
b.observed([]);
|
|
assert.equal(b.prefs.readMediaApps().length, 2);
|
|
b.prefs.setMediaAppEnabled(chrome, true);
|
|
b.prefs.setMediaAppEnabled(player, false);
|
|
assert.ok(!b.ignored().includes(chrome.packageName));
|
|
assert.ok(b.ignored().includes(player.packageName));
|
|
});
|
|
|
|
test('Music settings keeps toggles and selection when a new app arrives and supports back', async () => {
|
|
const { prefs } = store();
|
|
let refreshes = 0, 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-u20n.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 deps = {
|
|
'../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)) },
|
|
'./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'), './gestures': {},
|
|
'./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 },
|
|
};
|
|
deps['./menu-core'] = load('app/ui/menu-core.ts', (name) => deps[name]);
|
|
const menu = load('app/ui/menu.ts', (name) => deps[name]);
|
|
const uiDeps = {
|
|
'../../graphics/image': deps['../graphics/image'],
|
|
'../../graphics/textwrap': textwrap,
|
|
'../../graphics/ui-fonts': deps['../graphics/ui-fonts'],
|
|
'../../native/media-apps': prefs,
|
|
'../../native/media-browser': { mediaBrowserBridge: { listBrowsableApps: (refresh) => {
|
|
assert.equal(refresh, true); refreshes++; prefs.rememberMediaApps([player]); return [];
|
|
} } },
|
|
'../../ui/menu': menu,
|
|
};
|
|
const { MusicSettingsLayer } = load('app/apps/music/music-settings.ts', (name) => uiDeps[name]);
|
|
const layer = new MusicSettingsLayer();
|
|
const ctx = { stack: { getBaseSize: () => bordered(540, 224), isFocused: () => true, pop: () => closes++ } };
|
|
const paint = () => layer.paint(ctx, () => new RecordingImage(540, 224));
|
|
const input = (type) => layer.handleInput({ type }, ctx);
|
|
assert.equal(refreshes, 1);
|
|
paint();
|
|
await input('click');
|
|
assert.equal(prefs.isMediaAppEnabled(player.packageName), false);
|
|
prefs.rememberMediaApps([{ packageName: 'com.alpha', appName: 'Alpha' }]);
|
|
const image = paint();
|
|
assert.ok(image.texts.some(({ text }) => text === 'Player'));
|
|
assert.ok(image.texts.some(({ text }) => text === 'Alpha'));
|
|
assert.ok(image.texts.every(({ y }) => y >= 0 && y + font.lineHeight <= image.height));
|
|
await input('click');
|
|
assert.equal(prefs.isMediaAppEnabled(player.packageName), true);
|
|
await input('double-click');
|
|
assert.equal(closes, 1);
|
|
});
|
|
|
|
test('native session selection skips ignored playing and idle apps, including the all-ignored case', (t) => {
|
|
// Execute the production selection method with lightweight media-session doubles.
|
|
const compiler = kotlinCompiler();
|
|
if (!compiler) return t.skip('Kotlin compiler not in the Gradle cache; run ./build.sh once');
|
|
const kotlin = source('App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawMediaController.kt');
|
|
const method = kotlin.slice(kotlin.indexOf(' private fun chooseController('),
|
|
kotlin.indexOf(' private fun emitSessionAppsLocked('));
|
|
const directory = fs.mkdtempSync(path.join(os.tmpdir(), 'faceclaw-media-kotlin-'));
|
|
const javaBin = process.env.JAVA_HOME ? path.join(process.env.JAVA_HOME, 'bin', 'java') : 'java';
|
|
try {
|
|
const file = path.join(directory, 'MediaSelectionTest.kt');
|
|
fs.writeFileSync(file, `
|
|
class PlaybackState(val state: Int) { companion object { const val STATE_PLAYING = 3 } }
|
|
class MediaController(val packageName: String, state: Int) { var playbackState: PlaybackState? = PlaybackState(state) }
|
|
class MediaSelectionTest {
|
|
val ignoredPackages: MutableSet<String> = HashSet()
|
|
${method}
|
|
fun run() {
|
|
val ignored = MediaController("browser", 3)
|
|
val paused = MediaController("player", 2)
|
|
val playing = MediaController("music", 3)
|
|
ignoredPackages.add("browser")
|
|
check(chooseController(listOf(ignored, paused)) === paused)
|
|
check(chooseController(listOf(ignored, paused, playing)) === playing)
|
|
check(chooseController(listOf(ignored)) == null)
|
|
ignored.playbackState = null
|
|
check(chooseController(listOf(ignored, paused)) === paused)
|
|
ignoredPackages.add("music")
|
|
check(chooseController(listOf(ignored, paused, playing)) === paused)
|
|
ignoredPackages.remove("browser"); ignored.playbackState = PlaybackState(3)
|
|
check(chooseController(listOf(ignored, paused)) === ignored)
|
|
check(chooseController(null) == null)
|
|
check(chooseController(emptyList()) == null)
|
|
}
|
|
}
|
|
fun main() { MediaSelectionTest().run() }
|
|
`);
|
|
const out = path.join(directory, 'out');
|
|
execFileSync(javaBin, ['-cp', compiler.classpath, 'org.jetbrains.kotlin.cli.jvm.K2JVMCompiler',
|
|
'-no-stdlib', '-cp', compiler.stdlib, '-d', out, file], { stdio: 'pipe' });
|
|
execFileSync(javaBin, ['-cp', [out, compiler.stdlib].join(path.delimiter), 'MediaSelectionTestKt'], { stdio: 'pipe' });
|
|
} finally {
|
|
fs.rmSync(directory, { recursive: true, force: true });
|
|
}
|
|
});
|