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.
465 lines
18 KiB
TypeScript
465 lines
18 KiB
TypeScript
import { evaluateNightscoutAlerts } from "./nightscout-alerts";
|
|
import { getDefaultLargeFont, getDefaultSmallFont } from "../../graphics/ui-fonts";
|
|
import { GrayImage, type UiFont } from "../../graphics/image";
|
|
import { truncateText } from "../../graphics/textwrap";
|
|
import { InputEvent } from "../../ui/gestures";
|
|
import { Layer, LayerContext } from "../../ui/layers";
|
|
import { nightscoutBridge, type NightscoutState } from "../../native/nightscout-bridge";
|
|
import {
|
|
isNightscoutSettingsConfigured,
|
|
loadNightscoutThresholds,
|
|
nightscoutMaxCannulaAgeSetting,
|
|
nightscoutCartridgeLowSetting,
|
|
nightscoutBatteryLowSetting,
|
|
nightscoutMaxLoopAgeSetting,
|
|
nightscoutAlwaysShowInTopBarSetting,
|
|
nightscoutMissedBolusAlertsSetting,
|
|
nightscoutMissedBolusCooldownSetting,
|
|
toggleSettingMenuItem,
|
|
nightscoutApiTokenSetting,
|
|
nightscoutSiteUrlSetting,
|
|
textSettingMenuItem,
|
|
} from "../../ui/dashboard-settings";
|
|
import { formatAgeShortFromTimestamp, formatTimestamp } from "~/util/date-util";
|
|
import { type MenuItem } from "../../ui/menu";
|
|
import { openSettingsSubMenu } from "../../ui/dashboard/settings-panel";
|
|
import { lineStep } from "../../ui/metrics";
|
|
|
|
const nightscoutLargeFont = getDefaultLargeFont();
|
|
export const NIGHTSCOUT_STALE_MS = 15 * 60 * 1000;
|
|
const NIGHTSCOUT_GRAPH_WINDOW_MS = 2 * 60 * 60 * 1000;
|
|
const NIGHTSCOUT_GRAPH_TIME_QUANTUM_MS = 60 * 1000;
|
|
|
|
/**
|
|
* The app page's fixed parts, placed from the title at the window's top and
|
|
* left padding: a status message and the graph, down from the title's top,
|
|
* and the status lines' column, right of the readout's left edge.
|
|
*/
|
|
const PAGE_MESSAGE_OFFSET_Y = 28;
|
|
const PAGE_GRAPH_OFFSET_Y = 112;
|
|
const PAGE_STATUS_OFFSET_X = 148;
|
|
/** Gap between the page's graph and the caption under it. */
|
|
const PAGE_CAPTION_GAP = 6;
|
|
/** The shortest graph the page draws above its caption; with less room the graph takes the caption's. */
|
|
const PAGE_MIN_GRAPH_HEIGHT = 40;
|
|
|
|
/** Draws the trend indicator; returns its width. */
|
|
export function drawDirectionIndicator(
|
|
image: GrayImage,
|
|
font: UiFont,
|
|
x: number,
|
|
y: number,
|
|
direction: string,
|
|
shade: number,
|
|
): number {
|
|
const label = directionGlyphLabel(font, direction) || (direction ? truncateLine(direction, 10) : "");
|
|
if (label) image.drawText(font, x, y, label, shade);
|
|
return font.measureText(label);
|
|
}
|
|
|
|
/**
|
|
* The trend as unicode arrows (U+2191..U+2198), drawn as ordinary text so
|
|
* they scale with the font. A bitmap face missing a diagonal falls back to
|
|
* the vertical arrow; a face with no arrows at all falls back to the raw
|
|
* direction text in drawDirectionIndicator.
|
|
*/
|
|
function directionGlyphLabel(font: UiFont, direction: string): string {
|
|
const pick = (...candidates: string[]): string => {
|
|
for (const candidate of candidates) {
|
|
if (font.hasGlyph(candidate.codePointAt(0)!)) return candidate;
|
|
}
|
|
return "";
|
|
};
|
|
switch (direction) {
|
|
case "DoubleUp":
|
|
return pick("↑").repeat(2);
|
|
case "SingleUp":
|
|
return pick("↑");
|
|
case "FortyFiveUp":
|
|
return pick("↗", "↑");
|
|
case "Flat":
|
|
return pick("→");
|
|
case "FortyFiveDown":
|
|
return pick("↘", "↓");
|
|
case "SingleDown":
|
|
return pick("↓");
|
|
case "DoubleDown":
|
|
return pick("↓").repeat(2);
|
|
default:
|
|
return "";
|
|
}
|
|
}
|
|
|
|
function truncateLine(text: string, maxChars: number): string {
|
|
if (text.length <= maxChars) return text;
|
|
return `${text.slice(0, Math.max(0, maxChars - 3))}...`;
|
|
}
|
|
|
|
export function formatDelta(delta: number | null): string {
|
|
if (delta === null) return "--";
|
|
return `${delta >= 0 ? "+" : ""}${Math.round(delta)}`;
|
|
}
|
|
|
|
function formatWholeNumber(value: number): string {
|
|
return `${Math.round(value)}`;
|
|
}
|
|
|
|
function formatBolusLabel(value: number): string {
|
|
return Number.isInteger(value) ? `${value}` : value.toFixed(1);
|
|
}
|
|
|
|
export function drawNightscoutGraph(
|
|
image: GrayImage,
|
|
bounds: { x: number; y: number; width: number; height: number },
|
|
nightscout: NightscoutState,
|
|
nowMs: number,
|
|
font: UiFont,
|
|
): void {
|
|
if (bounds.width <= 2 || bounds.height <= 2) {
|
|
return;
|
|
}
|
|
|
|
const graphNowMs = minuteBucketTimestampMs(nowMs);
|
|
const windowStartMs = graphNowMs - NIGHTSCOUT_GRAPH_WINDOW_MS;
|
|
const visibleHistory = nightscout.history.filter((point) => {
|
|
const pointTimestampMs = minuteBucketTimestampMs(point.timestampMs);
|
|
return pointTimestampMs >= windowStartMs && pointTimestampMs <= graphNowMs;
|
|
});
|
|
if (visibleHistory.length === 0) {
|
|
return;
|
|
}
|
|
|
|
const values = visibleHistory.map((point) => point.sgv);
|
|
const min = Math.min(...values, 60);
|
|
const max = Math.max(...values, 200);
|
|
const range = Math.max(20, max - min);
|
|
const paddedMin = min - range * 0.1;
|
|
const paddedMax = max + range * 0.1;
|
|
|
|
image.drawRect(bounds.x, bounds.y, bounds.width, bounds.height, 56);
|
|
drawNightscoutBasalOverlay(image, bounds, nightscout.basal, graphNowMs);
|
|
drawNightscoutReferenceLine(image, bounds, paddedMin, paddedMax, 60, 40);
|
|
drawNightscoutReferenceLine(image, bounds, paddedMin, paddedMax, 100, 40);
|
|
drawNightscoutReferenceLine(image, bounds, paddedMin, paddedMax, 180, 40);
|
|
|
|
const plotted = visibleHistory.map((point) => ({
|
|
point,
|
|
x: timeToGraphX(bounds, windowStartMs, point.timestampMs),
|
|
y:
|
|
bounds.y +
|
|
bounds.height -
|
|
1 -
|
|
Math.round(((point.sgv - paddedMin) / Math.max(1, paddedMax - paddedMin)) * Math.max(1, bounds.height - 1)),
|
|
}));
|
|
|
|
for (let i = 0; i < plotted.length; i++) {
|
|
const current = plotted[i]!;
|
|
const previous = i > 0 ? plotted[i - 1]! : null;
|
|
const next = i + 1 < plotted.length ? plotted[i + 1]! : null;
|
|
const connectedToPrevious =
|
|
previous !== null && current.point.timestampMs - previous.point.timestampMs <= NIGHTSCOUT_STALE_MS;
|
|
const connectedToNext =
|
|
next !== null && next.point.timestampMs - current.point.timestampMs <= NIGHTSCOUT_STALE_MS;
|
|
|
|
if (connectedToPrevious && previous) {
|
|
image.drawLine(previous.x, previous.y, current.x, current.y, 220);
|
|
}
|
|
if (!connectedToPrevious && !connectedToNext) {
|
|
image.fillRect(current.x - 1, current.y - 1, 2, 2, 220);
|
|
}
|
|
}
|
|
drawNightscoutCarbMarkers(image, bounds, font, nightscout.carbs, graphNowMs);
|
|
drawNightscoutBolusMarkers(image, bounds, font, nightscout.boluses, graphNowMs);
|
|
}
|
|
|
|
function drawNightscoutBasalOverlay(
|
|
image: GrayImage,
|
|
bounds: { x: number; y: number; width: number; height: number },
|
|
basalEvents: NightscoutState["basal"],
|
|
nowMs: number,
|
|
): void {
|
|
const graphNowMs = minuteBucketTimestampMs(nowMs);
|
|
const windowStartMs = graphNowMs - NIGHTSCOUT_GRAPH_WINDOW_MS;
|
|
const visibleEvents = basalEvents.filter(
|
|
(event) =>
|
|
minuteBucketTimestampMs(event.timestampMs + event.durationMinutes * 60_000) >= windowStartMs &&
|
|
minuteBucketTimestampMs(event.timestampMs) <= graphNowMs,
|
|
);
|
|
if (visibleEvents.length === 0) {
|
|
return;
|
|
}
|
|
const maxRate = Math.max(...visibleEvents.map((event) => event.rate), 0);
|
|
if (maxRate <= 0) {
|
|
return;
|
|
}
|
|
const overlayHeight = Math.max(8, Math.min(18, Math.floor(bounds.height * 0.22)));
|
|
const bottomY = bounds.y + bounds.height - 2;
|
|
for (const event of visibleEvents) {
|
|
const startMs = Math.max(windowStartMs, minuteBucketTimestampMs(event.timestampMs));
|
|
const endMs = Math.min(graphNowMs, minuteBucketTimestampMs(event.timestampMs + event.durationMinutes * 60_000));
|
|
if (endMs <= startMs) {
|
|
continue;
|
|
}
|
|
const leftX = timeToGraphX(bounds, windowStartMs, startMs);
|
|
const rightX = timeToGraphX(bounds, windowStartMs, endMs);
|
|
const height = Math.max(1, Math.round((event.rate / maxRate) * overlayHeight));
|
|
image.fillRect(leftX, bottomY - height + 1, Math.max(1, rightX - leftX + 1), height, 15);
|
|
}
|
|
}
|
|
|
|
function drawNightscoutCarbMarkers(
|
|
image: GrayImage,
|
|
bounds: { x: number; y: number; width: number; height: number },
|
|
font: UiFont,
|
|
carbEvents: NightscoutState["carbs"],
|
|
nowMs: number,
|
|
): void {
|
|
const graphNowMs = minuteBucketTimestampMs(nowMs);
|
|
const windowStartMs = graphNowMs - NIGHTSCOUT_GRAPH_WINDOW_MS;
|
|
const baselineY = bounds.y + bounds.height - 2;
|
|
for (const event of carbEvents) {
|
|
const eventTimestampMs = minuteBucketTimestampMs(event.timestampMs);
|
|
if (eventTimestampMs < windowStartMs || eventTimestampMs > graphNowMs) {
|
|
continue;
|
|
}
|
|
const x = timeToGraphX(bounds, windowStartMs, eventTimestampMs);
|
|
image.drawLine(x, baselineY, x, baselineY - 6, 150);
|
|
drawTextCentered(image, font, x, Math.max(bounds.y + 2, baselineY - 18), `${Math.round(event.carbs)}`, 150, bounds);
|
|
}
|
|
}
|
|
|
|
function drawNightscoutBolusMarkers(
|
|
image: GrayImage,
|
|
bounds: { x: number; y: number; width: number; height: number },
|
|
font: UiFont,
|
|
bolusEvents: NightscoutState["boluses"],
|
|
nowMs: number,
|
|
): void {
|
|
const graphNowMs = minuteBucketTimestampMs(nowMs);
|
|
const windowStartMs = graphNowMs - NIGHTSCOUT_GRAPH_WINDOW_MS;
|
|
const topY = bounds.y + 1;
|
|
for (const event of bolusEvents) {
|
|
const eventTimestampMs = minuteBucketTimestampMs(event.timestampMs);
|
|
if (eventTimestampMs < windowStartMs || eventTimestampMs > graphNowMs) {
|
|
continue;
|
|
}
|
|
const x = timeToGraphX(bounds, windowStartMs, eventTimestampMs);
|
|
image.drawLine(x, topY, x, topY + 6, 144);
|
|
if (event.insulin >= 1) {
|
|
drawTextCentered(
|
|
image,
|
|
font,
|
|
x,
|
|
Math.min(bounds.y + bounds.height - font.lineHeight - 1, topY + 8),
|
|
formatBolusLabel(event.insulin),
|
|
144,
|
|
bounds,
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
function drawTextCentered(
|
|
image: GrayImage,
|
|
font: UiFont,
|
|
centerX: number,
|
|
y: number,
|
|
text: string,
|
|
shade: number,
|
|
bounds: { x: number; y: number; width: number; height: number },
|
|
): void {
|
|
const textWidth = font.measureText(text);
|
|
const x = Math.max(bounds.x + 1, Math.min(bounds.x + bounds.width - textWidth - 1, centerX - Math.round(textWidth / 2)));
|
|
image.drawText(font, x, y, text, shade);
|
|
}
|
|
|
|
function timeToGraphX(
|
|
bounds: { x: number; y: number; width: number; height: number },
|
|
windowStartMs: number,
|
|
timestampMs: number,
|
|
): number {
|
|
const graphTimestampMs = minuteBucketTimestampMs(timestampMs);
|
|
return (
|
|
bounds.x +
|
|
Math.round(
|
|
((graphTimestampMs - windowStartMs) / Math.max(1, NIGHTSCOUT_GRAPH_WINDOW_MS)) * Math.max(1, bounds.width - 1),
|
|
)
|
|
);
|
|
}
|
|
|
|
function minuteBucketTimestampMs(timestampMs: number): number {
|
|
return Math.floor(timestampMs / NIGHTSCOUT_GRAPH_TIME_QUANTUM_MS) * NIGHTSCOUT_GRAPH_TIME_QUANTUM_MS;
|
|
}
|
|
|
|
function drawNightscoutReferenceLine(
|
|
image: GrayImage,
|
|
bounds: { x: number; y: number; width: number; height: number },
|
|
minValue: number,
|
|
maxValue: number,
|
|
value: number,
|
|
shade: number,
|
|
): void {
|
|
const y =
|
|
bounds.y +
|
|
bounds.height -
|
|
1 -
|
|
Math.round(((value - minValue) / Math.max(1, maxValue - minValue)) * Math.max(1, bounds.height - 1));
|
|
image.drawLine(bounds.x + 1, y, bounds.x + bounds.width - 2, y, shade);
|
|
}
|
|
|
|
|
|
export class NightscoutLayer implements Layer {
|
|
paint(ctx: LayerContext): GrayImage {
|
|
const font = getDefaultSmallFont();
|
|
// Sized to the hosting stack (the Nightscout app viewport). Nothing here
|
|
// scrolls, so the page keeps inside the padding suggested for each of
|
|
// the viewport's edges: the title, the readout and the graph start at
|
|
// the left padding, and the graph and its caption end at the bottom's.
|
|
const { width, height, padding } = ctx.stack.getBaseSize();
|
|
const image = new GrayImage(width, height, 0);
|
|
const nightscout = nightscoutBridge.snapshot();
|
|
const nowMs = Date.now();
|
|
const step = lineStep(font);
|
|
const left = padding.left;
|
|
const top = padding.top;
|
|
const right = width - padding.right;
|
|
const bottom = height - padding.bottom;
|
|
image.drawText(font, left, top, "Nightscout", 220);
|
|
|
|
const messageY = top + PAGE_MESSAGE_OFFSET_Y;
|
|
if (!isNightscoutSettingsConfigured() || nightscout.configurationMissing) {
|
|
image.drawText(font, left, messageY, "Nightscout needs configuration.", 180);
|
|
image.drawText(font, left, messageY + step, "Long-press for the menu, then pick Settings to set", 140);
|
|
image.drawText(font, left, messageY + 2 * step, "the site URL and API token.", 140);
|
|
return image;
|
|
}
|
|
|
|
if (!nightscout.available || !nightscout.latest) {
|
|
image.drawText(font, left, messageY, "No Nightscout data available.", 180);
|
|
image.drawText(font, left, messageY + step, truncateLine(nightscout.status, 60), 140);
|
|
return image;
|
|
}
|
|
|
|
// Two-column header above the graph: title + current glucose on the
|
|
// left, the status lines bottom-aligned on the right.
|
|
const graphTop = top + PAGE_GRAPH_OFFSET_Y;
|
|
const latest = nightscout.latest;
|
|
const glucoseText = `${latest.sgv}`;
|
|
const glucoseX = left;
|
|
const glucoseWidth = nightscoutLargeFont.measureText(glucoseText);
|
|
// Glucose value vertically centered between the title and the graph.
|
|
const titleBottom = top + font.lineHeight;
|
|
const glucoseY = Math.round((titleBottom + graphTop - nightscoutLargeFont.lineHeight) / 2);
|
|
image.drawText(nightscoutLargeFont, glucoseX, glucoseY, glucoseText, 230);
|
|
if (isNightscoutPointStale(latest, nowMs)) {
|
|
drawNightscoutValueStrikeThrough(image, glucoseX, glucoseY + (nightscoutLargeFont.lineHeight >> 1), glucoseWidth);
|
|
}
|
|
image.drawText(font, glucoseX + glucoseWidth + 8, glucoseY + nightscoutLargeFont.lineHeight - font.lineHeight, nightscout.units, 140);
|
|
|
|
const statusX = left + PAGE_STATUS_OFFSET_X;
|
|
const statusWidth = right - statusX;
|
|
const alerts = evaluateNightscoutAlerts(nightscout, loadNightscoutThresholds(), nowMs);
|
|
const statusLines: { text: string; shade: number; direction?: string; fields?: { text: string; warning?: boolean }[] }[] = [
|
|
{ text: `Delta ${formatDelta(nightscout.delta)} Trend `, shade: 180, direction: nightscout.direction },
|
|
{
|
|
text: `IOB ${nightscout.iob === null ? "--" : nightscout.iob.toFixed(2)} COB ${nightscout.cob === null ? "--" : formatWholeNumber(nightscout.cob)} Updated ${formatTimestamp(latest.timestampMs)}`,
|
|
shade: 160,
|
|
},
|
|
{
|
|
text: "", shade: 160,
|
|
fields: [
|
|
{ text: `CAGE ${formatAgeShortFromTimestamp(nightscout.cageTimestampMs, nowMs)}`, warning: alerts.cannula },
|
|
{ text: `Loop ${formatAgeShortFromTimestamp(nightscout.loopTimestampMs, nowMs)}`, warning: alerts.loop },
|
|
],
|
|
},
|
|
{
|
|
text: "", shade: 150,
|
|
fields: [
|
|
{ text: "Pump" },
|
|
{ text: nightscout.reservoirUnits === null ? "--U" : `${Math.round(nightscout.reservoirUnits)}U`, warning: alerts.cartridge },
|
|
{ text: nightscout.batteryVoltage === null ? "--V" : `${nightscout.batteryVoltage.toFixed(2)}V`, warning: alerts.battery },
|
|
{ text: nightscout.pumpStatus || "--" },
|
|
],
|
|
},
|
|
];
|
|
let statusY = graphTop - 8 - statusLines.length * step;
|
|
for (const line of statusLines) {
|
|
if (line.fields) {
|
|
let x = statusX;
|
|
for (const field of line.fields) {
|
|
const text = truncateText(font, field.text, Math.max(0, statusX + statusWidth - x));
|
|
const textWidth = font.measureText(text);
|
|
if (field.warning && textWidth > 0) image.fillRect(x - 2, statusY - 1, textWidth + 4, font.lineHeight + 2, 230);
|
|
image.drawText(font, x, statusY, text, field.warning ? 0 : line.shade);
|
|
x += textWidth + font.measureText(" ");
|
|
if (x >= statusX + statusWidth) break;
|
|
}
|
|
} else if (line.direction !== undefined) {
|
|
image.drawText(font, statusX, statusY, line.text, line.shade);
|
|
drawDirectionIndicator(image, font, statusX + font.measureText(line.text), statusY, line.direction, line.shade);
|
|
} else {
|
|
image.drawText(font, statusX, statusY, truncateText(font, line.text, statusWidth), line.shade);
|
|
}
|
|
statusY += step;
|
|
}
|
|
|
|
// The graph spans the padded width, down to the caption on the last
|
|
// line above the bottom padding. A window too short for both gives the
|
|
// caption's room to the graph.
|
|
const captionY = bottom - font.lineHeight;
|
|
const captioned = captionY - PAGE_CAPTION_GAP - graphTop >= PAGE_MIN_GRAPH_HEIGHT;
|
|
const graphBottom = captioned ? captionY - PAGE_CAPTION_GAP : bottom;
|
|
drawNightscoutGraph(image, { x: left, y: graphTop, width: right - left, height: graphBottom - graphTop }, nightscout, nowMs, font);
|
|
if (captioned) image.drawText(font, left, captionY, "2-hour glucose history with basal / carbs / boluses", 130);
|
|
return image;
|
|
}
|
|
|
|
async handleInput(event: InputEvent, ctx: LayerContext): Promise<void> {
|
|
// The menu lives on the window's long-press menu (see nightscoutMenuItems);
|
|
// double-click at the app root is handled by the yield wrapper.
|
|
if (event.type === "double-click") {
|
|
ctx.stack.pop();
|
|
}
|
|
}
|
|
}
|
|
|
|
/** App-specific entries for the window's long-press menu. */
|
|
export function nightscoutMenuItems(): MenuItem[] {
|
|
return [
|
|
{
|
|
label: "Refresh",
|
|
onSelect: async (ctx) => {
|
|
ctx.stack.pop();
|
|
await nightscoutBridge.refreshNow();
|
|
},
|
|
},
|
|
{
|
|
label: "Settings",
|
|
onSelect: (ctx) => {
|
|
// Pop the menu first so closing the settings modal lands back on
|
|
// the glucose view, not this menu.
|
|
ctx.stack.pop();
|
|
openSettingsSubMenu(ctx, "Nightscout settings", [
|
|
textSettingMenuItem(nightscoutSiteUrlSetting),
|
|
textSettingMenuItem(nightscoutApiTokenSetting),
|
|
toggleSettingMenuItem(nightscoutAlwaysShowInTopBarSetting),
|
|
textSettingMenuItem(nightscoutMaxCannulaAgeSetting),
|
|
textSettingMenuItem(nightscoutCartridgeLowSetting),
|
|
textSettingMenuItem(nightscoutBatteryLowSetting),
|
|
textSettingMenuItem(nightscoutMaxLoopAgeSetting),
|
|
toggleSettingMenuItem(nightscoutMissedBolusAlertsSetting),
|
|
textSettingMenuItem(nightscoutMissedBolusCooldownSetting),
|
|
]);
|
|
},
|
|
},
|
|
];
|
|
}
|
|
|
|
export function isNightscoutPointStale(point: NightscoutState["latest"], nowMs: number): boolean {
|
|
return point !== null && nowMs - point.timestampMs > NIGHTSCOUT_STALE_MS;
|
|
}
|
|
|
|
export function drawNightscoutValueStrikeThrough(image: GrayImage, x: number, y: number, width: number): void {
|
|
image.drawLine(x, y, x + width, y, 180);
|
|
}
|