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.
396 lines
16 KiB
JavaScript
396 lines
16 KiB
JavaScript
#!/usr/bin/env node
|
|
/**
|
|
* Render every health surface to a PNG, under plain node, with no emulator.
|
|
*
|
|
* ## Why this exists
|
|
*
|
|
* The first pass at this feature verified its layout by building an Android
|
|
* AVD, booting it headless, installing the app and screenshotting it. That
|
|
* works, and it cost most of a three-hour dispatch to set up for a question -
|
|
* "does this layout look right?" - that never needed a device in the loop.
|
|
*
|
|
* Everything the health screens draw goes into a `GrayImage` through code that
|
|
* imports nothing from NativeScript: `health/health-chart.ts` (the primitives),
|
|
* `health/health-glance.ts` (the glasses pages) and
|
|
* `health/health-phone-chart.ts` (the phone bitmap). So this script calls the
|
|
* REAL drawing functions with fixture data and writes what comes back. The
|
|
* previews cannot drift from the app, because they are not a second
|
|
* implementation of it - they are the same functions the device calls.
|
|
*
|
|
* ## The one platform shim, and why it is honest
|
|
*
|
|
* `graphics/bdffont.ts` reads the bundled .bdf through
|
|
* `knownFolders.currentApp()`. That is the only NativeScript call anywhere
|
|
* under the drawing code, so it gets one stub backed by node:fs, pointed at the
|
|
* same `app/fonts/` files the device loads. The glyphs are the real glyphs.
|
|
*
|
|
* ⚠ FONT CAVEAT, worth knowing before reading a preview as gospel. The device's
|
|
* DEFAULT UI font is Roboto-Light at 14px, a TTF - and TTF rasterization on
|
|
* this project happens in Java (`TtfFont.load` bails unless `global.isAndroid`),
|
|
* so it cannot run here. Off Android the shipping code falls back to the
|
|
* Terminus bitmap faces, which is what these previews use. That is a real,
|
|
* user-selectable configuration rather than a preview-only invention, but it is
|
|
* not the default, and text will not be pixel-identical to a device screenshot.
|
|
*
|
|
* The layouts are written against `font.lineHeight` / `measureText` rather than
|
|
* fixed offsets, so what actually matters is whether they survive the font
|
|
* metric range. `--big` re-renders everything one bitmap size up (small 12px ->
|
|
* 16px, large 24px -> 32px) to check exactly that; the guaranteed small-font
|
|
* line-height band is 12..21 (see ui-fonts.ts), and 12 and 16 sit inside it.
|
|
*
|
|
* ## Use
|
|
*
|
|
* npx tsc -p tests/tsconfig.json # or: npm test
|
|
* node tools/health-preview.cjs [--out DIR] [--big] [--real DIR]
|
|
*
|
|
* ## --real: the same surfaces, on data pulled off the phone
|
|
*
|
|
* `--real DIR` reads a `sleep.jsonl` (and, if present, a `samples-*.jsonl`)
|
|
* copied out of `files/health/` under `com.faceclaw.app` and renders the sleep
|
|
* surfaces from THAT instead of from fixtures. Nothing about the drawing
|
|
* changes - it is the same `drawGlancePage` and `renderPhoneChart` - so the
|
|
* question it answers is only ever "what does the real data look like in the
|
|
* layout we already have", never "should the layout be different".
|
|
*
|
|
* A stored session written by a pre-correction build carries
|
|
* `timeResolved: false` and RAW ring seconds. Those are run back through the
|
|
* shipping `convertRecords()` with the real clock correction, so the preview
|
|
* shows what the phone will store after the fix rather than a hand-placed
|
|
* guess. A session already marked resolved is used as-is and not corrected
|
|
* twice.
|
|
*/
|
|
|
|
const fs = require("node:fs");
|
|
const path = require("node:path");
|
|
const Module = require("node:module");
|
|
|
|
const ROOT = path.resolve(__dirname, "..");
|
|
const APP = path.join(ROOT, "app");
|
|
const BUILD = path.join(ROOT, ".test-build", "app");
|
|
|
|
// --- the one platform shim -------------------------------------------------
|
|
const nsCoreStub = {
|
|
knownFolders: {
|
|
currentApp: () => ({
|
|
getFile: (relative) => ({
|
|
readTextSync: () => fs.readFileSync(path.join(APP, relative), "utf8"),
|
|
}),
|
|
}),
|
|
},
|
|
};
|
|
const realLoad = Module._load;
|
|
Module._load = function (request) {
|
|
if (request === "@nativescript/core") return nsCoreStub;
|
|
return realLoad.apply(this, arguments);
|
|
};
|
|
|
|
if (!fs.existsSync(BUILD)) {
|
|
console.error(`No ${path.relative(ROOT, BUILD)} - run: npx tsc -p tests/tsconfig.json`);
|
|
process.exit(1);
|
|
}
|
|
|
|
const { GrayImage } = require(path.join(BUILD, "graphics/image.js"));
|
|
const { getFont } = require(path.join(BUILD, "graphics/bdffont.js"));
|
|
const { buildFixtures } = require(path.join(BUILD, "health/health-fixtures.js"));
|
|
const {
|
|
dailySummary,
|
|
hypnogram,
|
|
rollupSeries,
|
|
shortWeekday,
|
|
sleepNights,
|
|
sleepSummary,
|
|
stageSeconds,
|
|
formatDuration,
|
|
} = require(path.join(BUILD, "health/health-derive.js"));
|
|
const { drawGlancePage, GLANCE_PAGES } = require(path.join(BUILD, "health/health-glance.js"));
|
|
const { drawHealthCard } = require(path.join(BUILD, "health/health-card.js"));
|
|
const { convertRecords } = require(path.join(BUILD, "health/health-ingest.js"));
|
|
const { HealthStore } = require(path.join(BUILD, "health/health-store.js"));
|
|
const { renderPhoneChart } = require(path.join(BUILD, "health/health-phone-chart.js"));
|
|
const { stageLabel } = require(path.join(BUILD, "health/sleep-stages.js"));
|
|
const { DAY_MS, SAMPLE_METRICS, startOfLocalDay } = require(path.join(BUILD, "health/health-types.js"));
|
|
const UPNG = require("upng-js");
|
|
|
|
// --- arguments -------------------------------------------------------------
|
|
const args = process.argv.slice(2);
|
|
const big = args.includes("--big");
|
|
const realIndex = args.indexOf("--real");
|
|
const REAL_DIR = realIndex >= 0 && args[realIndex + 1] ? path.resolve(args[realIndex + 1]) : null;
|
|
const outIndex = args.indexOf("--out");
|
|
const OUT = path.resolve(
|
|
outIndex >= 0 && args[outIndex + 1] ? args[outIndex + 1] : path.join(ROOT, "preview"),
|
|
);
|
|
fs.mkdirSync(OUT, { recursive: true });
|
|
|
|
const small = getFont(big ? "terminus16" : "terminus12");
|
|
const large = getFont(big ? "terminus32" : "terminus24");
|
|
const fonts = { small, large };
|
|
|
|
// --- real data, when asked for ---------------------------------------------
|
|
/**
|
|
* `HealthStorageBackend` over a plain directory.
|
|
*
|
|
* Reading the pulled files THROUGH the real store, rather than parsing them
|
|
* here, is the same rule the rest of this tool follows. The on-disk sample line
|
|
* is a compact seven-key shape (`{m,t,s,n,x,a,u}`) that only `health-store.ts`
|
|
* knows how to read; a hand-rolled parser for it in a preview script is exactly
|
|
* the kind of second implementation that drifts. Read-only - `append`/`write`
|
|
* throw rather than quietly doing nothing, so a preview can never mutate a
|
|
* pulled copy of real data.
|
|
*/
|
|
class DirBackend {
|
|
constructor(dir) {
|
|
this.dir = dir;
|
|
}
|
|
exists(name) {
|
|
return fs.existsSync(path.join(this.dir, name));
|
|
}
|
|
read(name) {
|
|
return this.exists(name) ? fs.readFileSync(path.join(this.dir, name), "utf8") : null;
|
|
}
|
|
append() {
|
|
throw new Error("health-preview is read-only");
|
|
}
|
|
write() {
|
|
throw new Error("health-preview is read-only");
|
|
}
|
|
list() {
|
|
return fs.readdirSync(this.dir);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Put a stored session in the frame the corrected build will store it in.
|
|
*
|
|
* The correction is NOT applied here by hand - the record is turned back into
|
|
* the wire shape and pushed through the real `convertRecords()`, so if that
|
|
* function is wrong the preview is wrong in exactly the same way the phone is,
|
|
* which is the only useful behaviour for a check like this.
|
|
*/
|
|
function resolveStoredSleep(stored) {
|
|
if (stored.timeResolved) return stored;
|
|
const startTs = Math.round(stored.startMs / 1000);
|
|
const endTs = Math.round(stored.endMs / 1000);
|
|
const correction = 2 * new Date(stored.startMs).getTimezoneOffset() * 60 * 1000;
|
|
const { sleep } = convertRecords([
|
|
{
|
|
kind: "sleep",
|
|
startTs,
|
|
endTs,
|
|
totalSec: stored.totalSec,
|
|
wakeSec: stored.wakeSec,
|
|
remSec: stored.remSec,
|
|
lightSec: stored.lightSec,
|
|
deepSec: stored.deepSec,
|
|
segments: stored.segments,
|
|
receivedAtMs: stored.startMs,
|
|
clockCorrectionMs: correction,
|
|
},
|
|
]);
|
|
return sleep[0];
|
|
}
|
|
|
|
function loadReal(dir) {
|
|
const store = new HealthStore(new DirBackend(dir));
|
|
const sleep = store.sleepSessions().map(resolveStoredSleep);
|
|
if (sleep.length === 0) {
|
|
console.error(`No sleep sessions in ${dir}/sleep.jsonl`);
|
|
process.exit(1);
|
|
}
|
|
// Pin the clock to mid-afternoon of the most recent night's WAKE-UP day, so
|
|
// "today" is the day that night belongs to and the glance reads like a real
|
|
// one rather than an empty day.
|
|
const latest = sleep.reduce((a, b) => (b.dayStartMs > a.dayStartMs ? b : a));
|
|
const nowMs = latest.dayStartMs + 15 * 3600 * 1000 + 20 * 60 * 1000;
|
|
// A bounded window, not (0, MAX): samplesInRange walks a shard per MONTH, so
|
|
// an open range asks it to name a few million files and it returns nothing.
|
|
// A quarter back covers every view this tool renders.
|
|
const samples = store.samplesInRange(nowMs - 120 * DAY_MS, nowMs + DAY_MS);
|
|
console.log(`real data: ${sleep.length} sleep session(s), ${samples.length} samples`);
|
|
for (const night of sleep) {
|
|
console.log(
|
|
` night ${new Date(night.startMs).toString()}\n` +
|
|
` -> ${new Date(night.endMs).toString()}` +
|
|
` total ${night.totalSec}s wake ${night.wakeSec}s` +
|
|
` timeResolved=${night.timeResolved}`,
|
|
);
|
|
}
|
|
return { samples, sleep, nowMs };
|
|
}
|
|
|
|
// --- data ------------------------------------------------------------------
|
|
// A fixed clock so a preview is reproducible and its date caption is stable.
|
|
// Mid-afternoon, so "today so far" is a partial day like a real glance.
|
|
const real = REAL_DIR ? loadReal(REAL_DIR) : null;
|
|
const NOW = real ? real.nowMs : new Date(2026, 8, 10, 15, 20, 0).getTime();
|
|
const TODAY = startOfLocalDay(NOW);
|
|
const fixtures = real
|
|
? { samples: real.samples, sleep: real.sleep }
|
|
: buildFixtures({ days: 95, nowMs: NOW, seed: 0x5eed });
|
|
|
|
const todaySamples = fixtures.samples.filter(
|
|
(sample) => sample.startMs >= TODAY && sample.startMs < TODAY + DAY_MS,
|
|
);
|
|
const summary = dailySummary(todaySamples, fixtures.sleep, TODAY);
|
|
const lastNight = fixtures.sleep.find((session) => session.dayStartMs === TODAY);
|
|
|
|
const hourly = {};
|
|
for (const metric of SAMPLE_METRICS) {
|
|
hourly[metric] = rollupSeries(todaySamples, {
|
|
metric,
|
|
granularity: "hour",
|
|
startMs: TODAY,
|
|
endMs: TODAY + DAY_MS,
|
|
});
|
|
}
|
|
|
|
const glanceData = {
|
|
summary,
|
|
hourly,
|
|
stageBands: lastNight ? hypnogram(lastNight) : [],
|
|
nowMs: NOW,
|
|
// The badge the glasses footer draws. It must follow the DATA, or a real
|
|
// render comes out stamped "Sample data" and the preview lies about the one
|
|
// thing it exists to show.
|
|
fixture: !real,
|
|
};
|
|
|
|
// --- PNG out ---------------------------------------------------------------
|
|
const written = [];
|
|
|
|
function writePng(name, image) {
|
|
const baked = image.withDrawsBaked();
|
|
const rgba = new Uint8Array(baked.width * baked.height * 4);
|
|
for (let i = 0; i < baked.pixels.length; i += 1) {
|
|
const value = baked.pixels[i];
|
|
rgba[i * 4] = value;
|
|
rgba[i * 4 + 1] = value;
|
|
rgba[i * 4 + 2] = value;
|
|
rgba[i * 4 + 3] = 255;
|
|
}
|
|
const file = path.join(OUT, `${REAL_DIR ? "real-" : ""}${name}${big ? "-big" : ""}.png`);
|
|
fs.writeFileSync(file, Buffer.from(UPNG.encode([rgba.buffer], baked.width, baked.height, 0)));
|
|
|
|
// A blank canvas would otherwise be a silent pass, and a page that drew
|
|
// nothing is exactly the failure a preview is supposed to catch.
|
|
let lit = 0;
|
|
for (const value of baked.pixels) if (value > 0) lit += 1;
|
|
const inkPercent = ((lit / baked.pixels.length) * 100).toFixed(1);
|
|
written.push({ name: path.basename(file), size: `${baked.width}x${baked.height}`, ink: `${inkPercent}%` });
|
|
if (lit === 0) console.error(` !! ${file} is entirely blank`);
|
|
}
|
|
|
|
// --- the glasses: 640x480, the G2 lens ------------------------------------
|
|
// As a window with a border line along every edge: the padding the shell
|
|
// suggests there (app/ui/viewport.ts BORDER_EDGE_PADDING).
|
|
const EDGE_PADDING = 8;
|
|
const LENS = {
|
|
width: 640, height: 480,
|
|
padding: { top: EDGE_PADDING, right: EDGE_PADDING, bottom: EDGE_PADDING, left: EDGE_PADDING },
|
|
};
|
|
GLANCE_PAGES.forEach((page, index) => {
|
|
const name =
|
|
page.kind === "overview" ? "overview" : page.kind === "sleep" ? "sleep" : page.metric;
|
|
const image = new GrayImage(LENS.width, LENS.height, 0);
|
|
drawGlancePage(image, LENS, fonts, page, glanceData);
|
|
writePng(`glasses-${String(index + 1).padStart(2, "0")}-${name}`, image);
|
|
});
|
|
|
|
// --- the phone -------------------------------------------------------------
|
|
/**
|
|
* Two widths, both real: 411dp is the Fold 7's cover screen (the compact
|
|
* layout), 750dp its inner screen (expanded). Both are the numbers the first
|
|
* pass measured on screen in the emulator, so the previews line up with the
|
|
* readout in those screenshots. The chart renders at RENDER_SCALE 2 into a box
|
|
* of (width - 32)dp, matching health-view-model.ts.
|
|
*/
|
|
const RENDER_SCALE = 2;
|
|
const PHONE_LAYOUTS = [
|
|
{ name: "narrow", widthDp: 411, chartHeightDp: 190 },
|
|
{ name: "wide", widthDp: 750, chartHeightDp: 380 },
|
|
];
|
|
|
|
function phoneChart(layout, name, content) {
|
|
const image = renderPhoneChart({
|
|
width: Math.round((layout.widthDp - 32) * RENDER_SCALE),
|
|
height: Math.round(layout.chartHeightDp * RENDER_SCALE),
|
|
font: small,
|
|
content,
|
|
});
|
|
writePng(`phone-${layout.name}-${name}`, image);
|
|
}
|
|
|
|
function metricContent(metric, granularity, days) {
|
|
const startMs = TODAY - (days - 1) * DAY_MS;
|
|
const points = rollupSeries(fixtures.samples, {
|
|
metric,
|
|
granularity,
|
|
startMs,
|
|
endMs: TODAY + DAY_MS,
|
|
});
|
|
return {
|
|
kind: "metric",
|
|
metric,
|
|
points,
|
|
mode: metric === "steps" || metric === "calories" ? "bars" : "band",
|
|
xLabel: (point) =>
|
|
granularity === "hour"
|
|
? `${new Date(point.startMs).getHours()}`
|
|
: days <= 7
|
|
? shortWeekday(point.startMs)
|
|
: `${new Date(point.startMs).getDate()}`,
|
|
};
|
|
}
|
|
|
|
function nightsContent(days) {
|
|
const startMs = TODAY - (days - 1) * DAY_MS;
|
|
return {
|
|
kind: "nights",
|
|
nights: sleepNights(fixtures.sleep, startMs, TODAY + DAY_MS),
|
|
xLabel: (night) =>
|
|
days <= 7 ? shortWeekday(night.startMs) : `${new Date(night.startMs).getDate()}`,
|
|
};
|
|
}
|
|
|
|
function lanesContent() {
|
|
const summaryOfNight = lastNight ? sleepSummary(lastNight) : null;
|
|
return {
|
|
kind: "lanes",
|
|
bands: lastNight ? hypnogram(lastNight) : [],
|
|
laneText: (stage) => ({
|
|
label: stageLabel(stage),
|
|
value: summaryOfNight ? formatDuration(stageSeconds(stage, summaryOfNight)) : "--",
|
|
}),
|
|
};
|
|
}
|
|
|
|
for (const layout of PHONE_LAYOUTS) {
|
|
phoneChart(layout, "hr-day", metricContent("heartRate", "hour", 1));
|
|
phoneChart(layout, "hr-week", metricContent("heartRate", "day", 7));
|
|
phoneChart(layout, "spo2-day", metricContent("spo2", "hour", 1));
|
|
phoneChart(layout, "steps-week", metricContent("steps", "day", 7));
|
|
phoneChart(layout, "sleep-day-lanes", lanesContent());
|
|
phoneChart(layout, "sleep-week", nightsContent(7));
|
|
phoneChart(layout, "sleep-month", nightsContent(30));
|
|
phoneChart(layout, "sleep-quarter", nightsContent(90));
|
|
}
|
|
|
|
// --- report ----------------------------------------------------------------
|
|
for (const [name, data] of [
|
|
["live", { kind: "live", summary: dailySummary(fixtures.samples, fixtures.sleep, TODAY), hasSteps: true, hasCalories: true }],
|
|
["partial", { kind: "live", summary: dailySummary([], [], TODAY), hasSteps: true, hasCalories: false }],
|
|
["sample", { kind: "fixture" }],
|
|
["empty", { kind: "empty" }],
|
|
["error", { kind: "error" }],
|
|
]) {
|
|
const card = new GrayImage(288, 144, 0);
|
|
drawHealthCard(card, data, small, getFont(big ? "terminus24" : "terminus16"));
|
|
writePng(`glanceboard-health-${name}`, card);
|
|
}
|
|
|
|
console.log(`font: small lineHeight ${small.lineHeight}, large lineHeight ${large.lineHeight}`);
|
|
console.log(`wrote ${written.length} PNGs to ${OUT}\n`);
|
|
for (const entry of written) {
|
|
console.log(` ${entry.name.padEnd(34)} ${entry.size.padEnd(10)} ink ${entry.ink}`);
|
|
}
|