forked from Blendman974/faceclaw
198 lines
6.8 KiB
TypeScript
198 lines
6.8 KiB
TypeScript
/**
|
|
* HEALTH - the glasses status page.
|
|
*
|
|
* This file is now PLUMBING ONLY: the store reads, the refresh timer, the
|
|
* scroll cursor, the window lifecycle. Every pixel is drawn by
|
|
* `health/health-glance.ts`, which has no NativeScript imports and therefore
|
|
* renders under plain node - see `tools/health-preview.cjs`, which produces a
|
|
* PNG of each page below without an emulator. The first pass drew and plumbed
|
|
* in one file and could only be looked at by booting an AVD; that is the
|
|
* difference this split buys, and it is the reason to keep the two apart.
|
|
*
|
|
* ## The surface, after Chris's 2026-09-10 review
|
|
*
|
|
* The overview is a SUMMARY - text only, no charts - and scrolling walks a
|
|
* cursor through a detail page per parameter, ending at sleep's own view.
|
|
* `GLANCE_PAGES` in `health-glance.ts` is the page list, and the doc comment
|
|
* there carries the reasoning for the carousel (including which parts of it are
|
|
* interpretation rather than spec).
|
|
*/
|
|
|
|
import { getDefaultLargeFont, getDefaultSmallFont } from "../../graphics/ui-fonts";
|
|
import { GrayImage } from "../../graphics/image";
|
|
import { type InputEvent } from "../../ui/gestures";
|
|
import { type Layer, type LayerContext } from "../../ui/layers";
|
|
import {
|
|
createInProcessWindow,
|
|
YieldAtRootLayer,
|
|
type InProcessAppOptions,
|
|
type InProcessWindow,
|
|
} from "../../ui/shell/in-process-window";
|
|
import { dailySummary, dailyHypnogram, rollupSeries, type DailySummary } from "../../health/health-derive";
|
|
import {
|
|
drawGlancePage,
|
|
GLANCE_PAGES,
|
|
type GlanceData,
|
|
} from "../../health/health-glance";
|
|
import { healthStore } from "../../health/health-store-files";
|
|
import { requestFreshPull, syncLiveRecords } from "../../health/health-live";
|
|
import { isFixtureData, seedFixturesIfNeeded } from "../../health/health-seed";
|
|
import {
|
|
DAY_MS,
|
|
SAMPLE_METRICS,
|
|
startOfLocalDay,
|
|
type RollupPoint,
|
|
type SampleMetric,
|
|
} from "../../health/health-types";
|
|
|
|
export const HEALTH_WINDOW_ID = "health";
|
|
export const HEALTH_SURFACE_ID = "window:health";
|
|
|
|
/** Cheap enough to re-read on a timer; the store is a few hundred rows a day. */
|
|
const REFRESH_INTERVAL_MS = 60_000;
|
|
|
|
class HealthLayer implements Layer {
|
|
private summary: DailySummary | null = null;
|
|
/** Today by hour, per metric - what the drill-down pages plot. */
|
|
private hourly: Partial<Record<SampleMetric, RollupPoint[]>> = {};
|
|
private stageBands: GlanceData["stageBands"] = [];
|
|
private fixture = false;
|
|
/** Index into GLANCE_PAGES. 0 is the overview. */
|
|
private pageIndex = 0;
|
|
private timer: ReturnType<typeof setInterval> | null = null;
|
|
private removed = false;
|
|
|
|
constructor(private readonly requestRender: () => void) {}
|
|
|
|
start(): void {
|
|
// Live data first: if the ring has been pulled this session, this stores it
|
|
// and wipes any fixtures out of the way. Only if that leaves us with
|
|
// nothing does seeding fill the screen, and seeding refuses outright once
|
|
// real data has ever landed.
|
|
syncLiveRecords();
|
|
// Ask for something current rather than showing whatever the last
|
|
// automatic 30-minute pull happened to catch. Returns immediately; the
|
|
// pull takes ~15s and lands via the refresh tick below.
|
|
requestFreshPull();
|
|
seedFixturesIfNeeded();
|
|
this.reload();
|
|
this.timer = setInterval(() => this.reload(), REFRESH_INTERVAL_MS);
|
|
}
|
|
|
|
stop(): void {
|
|
if (this.removed) return;
|
|
this.removed = true;
|
|
if (this.timer !== null) clearInterval(this.timer);
|
|
this.timer = null;
|
|
}
|
|
|
|
onRemoved(): void {
|
|
this.stop();
|
|
}
|
|
|
|
private reload(): void {
|
|
if (this.removed) return;
|
|
// Cheap on every tick: a no-op when the communicator has nothing new, and
|
|
// the store dedupes when it does, so a 30-minute pull shows up here within
|
|
// one refresh instead of waiting for the app to be reopened.
|
|
syncLiveRecords();
|
|
try {
|
|
const store = healthStore();
|
|
const today = startOfLocalDay(Date.now());
|
|
const samples = store.samplesInRange(today, today + DAY_MS);
|
|
const sessions = store.sleepSessions();
|
|
this.summary = dailySummary(samples, sessions, today);
|
|
// One pass per metric over a day's samples - a few hundred rows, and the
|
|
// drill-down has to be instant when the cursor lands on it.
|
|
const hourly: Partial<Record<SampleMetric, RollupPoint[]>> = {};
|
|
for (const metric of SAMPLE_METRICS) {
|
|
hourly[metric] = rollupSeries(samples, {
|
|
metric,
|
|
granularity: "hour",
|
|
startMs: today,
|
|
endMs: today + DAY_MS,
|
|
});
|
|
}
|
|
this.hourly = hourly;
|
|
this.stageBands = dailyHypnogram(sessions, today);
|
|
this.fixture = isFixtureData();
|
|
} catch (error) {
|
|
console.warn("health glance reload failed", error);
|
|
}
|
|
this.requestRender();
|
|
}
|
|
|
|
paint(ctx: LayerContext): GrayImage {
|
|
const { width, height } = ctx.stack.getBaseSize();
|
|
const image = new GrayImage(width, height, 0);
|
|
drawGlancePage(
|
|
image,
|
|
{ width, height },
|
|
{ small: getDefaultSmallFont(), large: getDefaultLargeFont() },
|
|
GLANCE_PAGES[this.pageIndex] ?? GLANCE_PAGES[0]!,
|
|
{
|
|
summary: this.summary,
|
|
hourly: this.hourly,
|
|
stageBands: this.stageBands,
|
|
nowMs: Date.now(),
|
|
fixture: this.fixture,
|
|
},
|
|
);
|
|
return image;
|
|
}
|
|
|
|
/**
|
|
* Scrolling moves between the overview and the per-parameter detail pages.
|
|
*
|
|
* The cursor WRAPS. With seven pages and no back gesture available
|
|
* (`YieldAtRootLayer` takes double-click for back-out-to-home), wrapping is
|
|
* what guarantees the overview is always reachable by holding one direction -
|
|
* a user who has scrolled to the end never has to work out which way is back.
|
|
* Click advances too, so the drill-down is reachable without ever scrolling.
|
|
*/
|
|
handleInput(event: InputEvent, _ctx: LayerContext): void {
|
|
switch (event.type) {
|
|
case "scroll-down":
|
|
case "click":
|
|
this.movePage(1);
|
|
return;
|
|
case "scroll-up":
|
|
this.movePage(-1);
|
|
return;
|
|
default:
|
|
return;
|
|
}
|
|
}
|
|
|
|
private movePage(delta: number): void {
|
|
const count = GLANCE_PAGES.length;
|
|
this.pageIndex = (this.pageIndex + delta + count) % count;
|
|
this.requestRender();
|
|
}
|
|
}
|
|
|
|
export function createHealthAppWindow(options: InProcessAppOptions): InProcessWindow {
|
|
let requestRender = () => {};
|
|
const layer = new HealthLayer(() => requestRender());
|
|
const app = createInProcessWindow({
|
|
appId: "health",
|
|
windowId: HEALTH_WINDOW_ID,
|
|
title: "Health",
|
|
iconLetter: "H",
|
|
icon: "activity",
|
|
closeable: true,
|
|
actions: options.actions,
|
|
baseLayer: new YieldAtRootLayer(layer),
|
|
submitFrame: options.submitFrame,
|
|
setSurfaceVisible: options.setSurfaceVisible,
|
|
removeSurface: options.removeSurface,
|
|
onClosed: () => {
|
|
layer.stop();
|
|
options.onClosed();
|
|
},
|
|
});
|
|
requestRender = app.requestRender;
|
|
layer.start();
|
|
return app;
|
|
}
|