feat(native): home and lock screen widgets in the TREK look

Four widgets instead of one plain text block, drawn in the phone tokens
(warm paper by day, near black by night) with contour lines and a route arc
as the travel motif:

- Trip (small, medium, large, lock screen): the cover photo, a countdown ring
  and a plane on its arc before the trip; the day of the trip as segments,
  the weather and the next stops on frosted glass while it runs
- Today (medium, large): the day as a timeline in its category colours, with
  a now line, the day's progress and the weather
- Bookings (small, medium, large, lock screen): flights, trains, hotels and
  tables ahead as coloured tiles, the next one featured, status dots
- To-dos (small, medium, large, lock screen): to-dos and packing as nested
  rings, the most pressing open to-dos with priority and due dates

The app now sends the destination, a small cover JPEG, the weather where the
trip is, the bookings ahead, the open to-dos and the packing count; every
new field is optional on both sides, so older binaries and servers keep
working. Timelines step every quarter hour so the now line moves without
the app. client/ios/WidgetPreviews renders every widget in every size, light
and dark, on the CI's Mac, uploaded as the widget-previews artifact.
This commit is contained in:
Maurice
2026-11-06 19:01:08 +01:00
parent 3466556849
commit b1037dec62
48 changed files with 3033 additions and 127 deletions
+99
View File
@@ -0,0 +1,99 @@
import { fetchWeather } from '../services/weatherQueue';
import { temperature } from './widgetExtras';
import type { WidgetWeather } from './widgets';
/**
* The two things the widget snapshot needs from the network: the weather where
* the trip is, and the trip's cover as a small JPEG the widget can draw without
* a session of its own. Both are best effort: offline or failing, the widget
* simply goes without them, and both are kept so a quarter-hourly sync does not
* fetch them again.
*/
const WEATHER_TTL_MS = 60 * 60 * 1000;
const weatherCache = new Map<string, { at: number; value: WidgetWeather | null }>();
export async function widgetWeather(
{ lat, lng }: { lat: number; lng: number },
{ date, lang, unit, place }: { date: string; lang: string; unit: string | undefined; place?: string | null }
): Promise<WidgetWeather | null> {
const key = `${lat.toFixed(2)},${lng.toFixed(2)},${date},${lang},${unit ?? ''}`;
const hit = weatherCache.get(key);
if (hit && Date.now() - hit.at < WEATHER_TTL_MS) return hit.value;
let value: WidgetWeather | null = null;
try {
const w = await fetchWeather(lat, lng, date, lang);
if (!w.error && Number.isFinite(w.temp)) {
value = {
temp: temperature(w.temp, unit),
...(w.temp_max != null ? { high: temperature(w.temp_max, unit) } : {}),
...(w.temp_min != null ? { low: temperature(w.temp_min, unit) } : {}),
main: w.main,
label: w.description,
...(place ? { place } : {}),
...(w.precipitation_probability_max != null ? { rain: Math.round(w.precipitation_probability_max) } : {}),
};
}
} catch {
// Offline or the provider failed: the widget shows no weather until the next sync.
value = null;
}
weatherCache.set(key, { at: Date.now(), value });
return value;
}
const COVER_KEY = 'trek.widgetCover';
const COVER_MAX_PX = 720;
const COVER_MAX_BYTES = 15 * 1024 * 1024;
/** Kept under this so the keychain item the widget reads stays small. */
const COVER_MAX_BASE64 = 160_000;
function storedCover(url: string): string | null {
try {
const raw = localStorage.getItem(COVER_KEY);
const parsed = raw ? (JSON.parse(raw) as { url?: string; data?: string }) : null;
return parsed?.url === url && parsed.data ? parsed.data : null;
} catch {
return null;
}
}
function storeCover(url: string, data: string): void {
try {
localStorage.setItem(COVER_KEY, JSON.stringify({ url, data }));
} catch {
// Storage full: the cover is fetched again next time, nothing else depends on it.
}
}
/**
* The cover at `url` scaled to fit COVER_MAX_PX, as base64 JPEG without the
* data: prefix. Null without a cover, offline, or for anything not an image.
*/
export async function widgetCover(url: string | null | undefined): Promise<string | null> {
if (!url) return null;
const stored = storedCover(url);
if (stored) return stored;
try {
const res = await fetch(url, { credentials: 'include', signal: AbortSignal.timeout(10_000) });
const length = Number(res.headers.get('content-length') ?? 0);
if (!res.ok || length > COVER_MAX_BYTES) return null;
const blob = await res.blob();
if (!blob.type.startsWith('image/') || blob.size > COVER_MAX_BYTES) return null;
const bitmap = await createImageBitmap(blob);
const scale = Math.min(1, COVER_MAX_PX / Math.max(bitmap.width, bitmap.height));
const canvas = document.createElement('canvas');
canvas.width = Math.round(bitmap.width * scale);
canvas.height = Math.round(bitmap.height * scale);
canvas.getContext('2d')?.drawImage(bitmap, 0, 0, canvas.width, canvas.height);
bitmap.close();
let data = canvas.toDataURL('image/jpeg', 0.74).split(',')[1] ?? '';
if (data.length > COVER_MAX_BASE64) data = canvas.toDataURL('image/jpeg', 0.5).split(',')[1] ?? '';
if (!data || data.length > COVER_MAX_BASE64) return null;
storeCover(url, data);
return data;
} catch {
// Offline, a timeout or an image the WebView cannot decode: no cover this time.
return null;
}
}