Files
faceclaw/app/ui/notifications.ts
T
James Babcock 032797f0f6 Add support for embedded icons and custom layouts in Android notifications
The practical upshot of this is that gmail, messages and similar apps
show the sender's profile picture on the glasses, the Dexcom app shows a
2026-10-31 12:39:20 -07:00

657 lines
27 KiB
TypeScript

import { clamp } from "~/util/numeric-util";
import { formatRelativeTime } from "~/util/date-util";
import { getDefaultSmallFont } from "../graphics/ui-fonts";
import { truncateText, wrapText } from "../graphics/textwrap";
import { GrayImage, type UiFont } from "../graphics/image";
import { LIST_ROW_TEXT_INSET, centeredTextY, lineStep, listRowHeight } from "./metrics";
import {
ALL_NOTIFICATIONS,
dismissNotification,
invokeNotificationAction,
readActiveNotifications,
readNotificationCustomView,
readNotificationIconByKey,
readNotificationLargeIcon,
readNotificationPicture,
type AndroidNotification,
type AndroidNotificationAction,
type NotificationImageResult,
} from "../native/notification-icons";
import { setNotificationSourceEnabled } from "../native/notification-sources";
import { notificationEmptyMessage } from "../native/notification-access";
import { noteStaleDataUsed, renderPassAllowsStaleData } from "../util/render-freshness";
import { type InputEvent } from "./gestures";
import { type Layer, type LayerContext, type PaintBelow } from "./layers";
import { Menu, type MenuBox } from "./menu-core";
// Title position, shared with the other list apps (terminal, calendar).
const TITLE_X = 18;
const TITLE_Y = 10;
const LIST_TOP = 38;
const CARD_X = 20;
const ICON_SIZE = 24;
const ICON_TEXT_GAP = 8;
const CARD_TEXT_X = 10 + ICON_SIZE + ICON_TEXT_GAP;
const CARD_GAP = 6;
const MAX_NOTIFICATIONS = 50;
// Right-hand action menu of the detail view.
const DETAIL_MENU_WIDTH = 148;
/** Top of the action menu's first row box, and the space kept below its last. */
const DETAIL_MENU_TOP = 22;
const DETAIL_MENU_BOTTOM_MARGIN = 17;
const DETAIL_MENU_ROW_GAP = 3;
/** Row text inset from the row box: horizontal, then vertical. */
const DETAIL_MENU_TEXT_X = 8;
const DETAIL_MENU_TEXT_Y = 4;
const DETAIL_CONTENT_X = 24;
const DETAIL_TITLE_Y = 21;
/** Gaps below the title's line box and below the icon/app-name header row. */
const DETAIL_HEADER_GAP = 3;
const DETAIL_BODY_GAP = 4;
/** Untitled text lines that attached images (custom layout, picture) leave room for above them, when there are that many; they take the rest. */
const DETAIL_PICTURE_TEXT_LINES = 2;
/** Gap between the text and an attached picture, and the space kept below the picture. */
const DETAIL_PICTURE_GAP = 6;
const DETAIL_PICTURE_BOTTOM_MARGIN = 12;
/** An attached picture with less height than this to fit in (a large UI font) is left out. */
const DETAIL_PICTURE_MIN_HEIGHT = 32;
/** Likewise a custom layout; Dexcom's reading is about 40 high. */
const DETAIL_CUSTOM_VIEW_MIN_HEIGHT = 16;
/** A large icon (sender's avatar, site's logo): at the right of a list card, left of the detail view's title. */
const LARGE_ICON_SIZE = 32;
const LARGE_ICON_GAP = 8;
// Disable-source confirmation: actions on top, the explanation below them.
const CONFIRM_X = 24;
const CONFIRM_Y = 8;
const CONFIRM_TEXT_X = 10;
const CONFIRM_PROMPT_GAP = 16;
/** Icon for a paint pass: allow-stale, reporting staleness to the render loop. */
function iconForNotification(key: string): GrayImage | null {
const { icon, stale } = readNotificationIconByKey(key, renderPassAllowsStaleData());
if (stale) {
noteStaleDataUsed();
}
return icon;
}
/** A notification image read for a paint pass (allow-stale like iconForNotification). */
function imageForPaint(
read: (allowStale: boolean) => NotificationImageResult,
): NotificationImageResult {
const result = read(renderPassAllowsStaleData());
if (result.stale) {
noteStaleDataUsed();
}
return result;
}
/** Attached picture for a paint pass, fitting maxWidth x maxHeight. */
function pictureForNotification(notification: AndroidNotification, maxWidth: number, maxHeight: number): GrayImage | null {
if (!notification.hasPicture || maxHeight < DETAIL_PICTURE_MIN_HEIGHT) return null;
return imageForPaint((allowStale) => readNotificationPicture(notification, maxWidth, maxHeight, allowStale)).image;
}
/** Large icon for a paint pass, LARGE_ICON_SIZE square at most. */
function largeIconForNotification(notification: AndroidNotification): GrayImage | null {
if (!notification.hasLargeIcon) return null;
return imageForPaint((allowStale) => readNotificationLargeIcon(notification, LARGE_ICON_SIZE, allowStale)).image;
}
type CardLayout = {
notification: AndroidNotification;
height: number;
lines: string[];
};
type DetailMenuItem =
| { kind: "back"; label: string }
| { kind: "action"; label: string; action: AndroidNotificationAction }
| { kind: "dismiss"; label: string }
| { kind: "disable-source"; label: string };
type ConfirmationItem = { label: string; run: (ctx: LayerContext) => void };
export type SingleNotificationLayerOrigin = "notifications-list" | "new-notification-modal" | "notification-tray";
type SingleNotificationLayerOptions = {
origin: SingleNotificationLayerOrigin;
/**
* Close hook for hosts that take the layer down themselves instead of
* popping it: the modal (the layer is the modal stack's base, so pop()
* cannot close it), and the app switcher's tray selection, which keeps
* the layer up until the selection moves on. `gone` says the notification
* itself went away (dismissed, or removed by one of its actions).
*/
onClose?: (ctx: LayerContext, gone: boolean) => void;
};
/**
* Scrollable list of active Android notifications. Sized to its hosting
* stack (the Notifications app viewport). Selecting one pushes the detail
* view.
*/
export class NotificationsListLayer implements Layer {
private selectedKey = "";
paint(ctx: LayerContext): GrayImage {
const font = getDefaultSmallFont();
const { width, height } = ctx.stack.getBaseSize();
const image = new GrayImage(width, height, 0);
const cardWidth = width - 2 * CARD_X;
const cardTextWidth = cardWidth - CARD_TEXT_X - 14;
const notifications = readActiveNotifications(MAX_NOTIFICATIONS);
const selectedIndex = this.resolveSelectedIndex(notifications);
const layouts = notifications.map((notification, index) =>
buildNotificationCardLayout(font, notification, index === selectedIndex, cardTextWidth),
);
if (!notifications.length) {
image.drawText(font, TITLE_X, TITLE_Y, "Notifications", 220);
const message = notificationEmptyMessage();
const messageLines = wrapText(font, message, width - 48);
for (let index = 0; index < messageLines.length; index++) {
image.drawText(font, 24, 72 + index * lineStep(font), messageLines[index]!, 190);
}
return image;
}
const focused = ctx.stack.isFocused();
const listBottom = height;
const scrollY = scrollForSelected(layouts, selectedIndex, listBottom - LIST_TOP);
// The title scrolls away with the list. Card text is drawn as deferred
// glyphs (always composited above raster fills), so a fixed title would
// show through cards scrolled over it; moving it with the content keeps
// it above the first card instead.
if (TITLE_Y - scrollY + font.lineHeight > 0) {
image.drawText(font, TITLE_X, TITLE_Y - scrollY, "Notifications", 220);
}
let cursorY = LIST_TOP - scrollY;
for (let index = 0; index < layouts.length; index++) {
const layout = layouts[index]!;
if (cursorY + layout.height >= LIST_TOP && cursorY <= listBottom) {
// Icons are only resolved for cards actually drawn, so a long list
// does not fetch icons for everything below the fold.
const icon = iconForNotification(layout.notification.key);
const largeIcon = largeIconForNotification(layout.notification);
drawNotificationCard(image, font, layout, CARD_X, cursorY, cardWidth, index === selectedIndex, focused, icon, largeIcon);
}
cursorY += layout.height + CARD_GAP;
if (cursorY > listBottom + 80) break;
}
return image;
}
handleInput(event: InputEvent, ctx: LayerContext): void {
const notifications = readActiveNotifications(MAX_NOTIFICATIONS);
const selectedIndex = this.resolveSelectedIndex(notifications);
if (event.type === "double-click") {
// At the app's root this is intercepted by the yield wrapper; reached
// only if hosted somewhere deeper, where popping is right.
ctx.stack.pop();
return;
}
if (!notifications.length) return;
if (event.type === "scroll-up") {
this.selectedKey = notifications[Math.max(0, selectedIndex - 1)]!.key;
return;
}
if (event.type === "scroll-down") {
this.selectedKey = notifications[Math.min(notifications.length - 1, selectedIndex + 1)]!.key;
return;
}
if (event.type === "click") {
ctx.stack.push(new SingleNotificationLayer(notifications[selectedIndex]!.key, {
origin: "notifications-list",
}));
}
}
private resolveSelectedIndex(notifications: AndroidNotification[]): number {
if (!notifications.length) {
this.selectedKey = "";
return -1;
}
let index = notifications.findIndex((notification) => notification.key === this.selectedKey);
if (index < 0) {
index = 0;
this.selectedKey = notifications[0]!.key;
}
return index;
}
}
/**
* One notification's full content plus its action menu. Sized to its hosting
* stack: the Notifications app viewport, or the interior of the shell's
* new-notification modal.
*/
export class SingleNotificationLayer implements Layer {
/** The action column; its items are rebuilt from the live notification on every paint and input. */
private readonly detailMenu = createNotificationActionMenu<DetailMenuItem>((item) => item.kind === "disable-source");
private confirmation: { source: AndroidNotification; menu: Menu<ConfirmationItem> } | null = null;
// The last paint, which a tray-hosted layer repeats once its notification
// is gone, until the tray swaps in a neighbour's (see closeUnavailableNotification).
private lastImage: GrayImage | null = null;
constructor(
private readonly notificationKey: string,
private readonly options: SingleNotificationLayerOptions,
) {}
/** Whether the layer stays up once its notification is gone: the disable-source confirmation dismisses it first. */
outlivesNotification(): boolean {
return this.confirmation !== null;
}
paint(ctx: LayerContext, paintBelow: PaintBelow): GrayImage {
if (this.confirmation) return this.paintConfirmation(ctx);
const font = getDefaultSmallFont();
const { width, height } = ctx.stack.getBaseSize();
const image = new GrayImage(width, height, 0);
const notification = readActiveNotifications(ALL_NOTIFICATIONS).find((item) => item.key === this.notificationKey);
if (!notification) {
return this.closeUnavailableNotification(ctx, paintBelow);
}
this.detailMenu.setItems(buildDetailMenu(notification, this.options.origin));
drawDetailContent(image, font, notification, iconForNotification(notification.key), width, height);
this.detailMenu.paint(image, notificationActionMenuBox(width, height), ctx.stack.isFocused());
this.lastImage = image;
return image;
}
async handleInput(event: InputEvent, ctx: LayerContext): Promise<void> {
if (this.confirmation) {
const { menu } = this.confirmation;
if (event.type === "double-click") this.close(ctx);
else if (event.type === "click") menu.selectedItem?.run(ctx);
else await menu.handleInput(event);
return;
}
const notification = readActiveNotifications(ALL_NOTIFICATIONS).find((item) => item.key === this.notificationKey);
if (!notification) {
this.closeUnavailableNotification(ctx);
return;
}
this.detailMenu.setItems(buildDetailMenu(notification, this.options.origin));
if (event.type === "double-click") {
this.close(ctx);
return;
}
if (event.type === "scroll-up" || event.type === "scroll-down") {
await this.detailMenu.handleInput(event);
return;
}
if (event.type !== "click") return;
// "(unavailable)" actions stay clickable: Android decides whether they do anything.
const item = this.detailMenu.selectedItem;
if (!item) return;
if (item.kind === "back") {
this.close(ctx);
} else if (item.kind === "action") {
invokeNotificationAction(this.notificationKey, item.action.index);
if (!readActiveNotifications(ALL_NOTIFICATIONS).some((active) => active.key === this.notificationKey)) {
this.closeUnavailableNotification(ctx);
}
} else if (item.kind === "dismiss") {
dismissNotification(this.notificationKey);
this.closeUnavailableNotification(ctx);
} else if (item.kind === "disable-source") {
// Keep the modal alive for confirmation even after Android removes the notification.
this.confirmation = {
source: notification,
menu: new Menu<ConfirmationItem>({
items: [
{ label: "Cancel", run: (runCtx) => this.close(runCtx) },
{ label: "Turn off popups", run: (runCtx) => {
setNotificationSourceEnabled(notification, false);
this.close(runCtx);
} },
],
wrap: true,
rowGap: 1,
getHeight: () => listRowHeight(getDefaultSmallFont()),
draw: ({ image, item: option, x, y, selected }) => {
image.drawText(getDefaultSmallFont(), x + CONFIRM_TEXT_X, y + LIST_ROW_TEXT_INSET, option.label, selected ? 255 : 200);
},
}),
};
dismissNotification(this.notificationKey);
}
}
private paintConfirmation(ctx: LayerContext): GrayImage {
const { source, menu } = this.confirmation!;
const font = getDefaultSmallFont();
const { width, height } = ctx.stack.getBaseSize();
const image = new GrayImage(width, height, 0);
// Put actions first so they remain reachable even with a large UI font.
const menuBox: MenuBox = {
x: CONFIRM_X,
y: CONFIRM_Y,
width: width - 2 * CONFIRM_X,
height: Math.min(menu.items.length * listRowHeight(font), height - CONFIRM_Y),
};
menu.paint(image, menuBox, ctx.stack.isFocused());
const top = menuBox.y + menuBox.height + CONFIRM_PROMPT_GAP;
const prompt = `Turn off notification popups from ${source.appName || source.packageName}? You can turn them back on in the Notifications app's Notification filter.`;
const lines = wrapText(font, prompt, width - 2 * CONFIRM_X);
const maxLines = Math.max(1, Math.floor((height - top - 12) / lineStep(font)));
for (let index = 0; index < Math.min(lines.length, maxLines); index++) {
const text = index === maxLines - 1 && lines.length > maxLines
? truncateText(font, lines[index] + "...", width - 2 * CONFIRM_X) : lines[index]!;
image.drawText(font, CONFIRM_X, top + index * lineStep(font), text, 210);
}
return image;
}
/** Leave the detail view, whatever hosts it. */
private close(ctx: LayerContext, gone = false): void {
if (this.options.onClose) {
this.options.onClose(ctx, gone);
} else {
ctx.stack.pop();
}
}
private closeUnavailableNotification(ctx: LayerContext, paintBelow?: PaintBelow): GrayImage {
this.close(ctx, true);
const { width, height } = ctx.stack.getBaseSize();
// The tray replaces this layer only after the paint (swapping layers
// mid-paint would render re-entrantly); meanwhile the screen keeps what
// it showed rather than flashing the list beneath.
if (this.options.origin === "notification-tray" && this.lastImage) {
return this.lastImage.clone();
}
return paintBelow ? paintBelow() : new GrayImage(width, height, 0);
}
}
function buildNotificationCardLayout(
font: UiFont,
notification: AndroidNotification,
selected: boolean,
fullTextWidth: number,
): CardLayout {
// The large icon sits at the card's right, beside all its text.
const cardTextWidth = notification.hasLargeIcon ? fullTextWidth - LARGE_ICON_SIZE - LARGE_ICON_GAP : fullTextWidth;
const lines: string[] = [];
const time = formatRelativeTime(notification.postTime);
const title = notificationTitle(notification);
const timeSuffix = time ? ` ${time}` : "";
lines.push(truncateText(font, `${title}${timeSuffix}`, cardTextWidth));
const appName = notification.appName || notification.packageName;
const body = primaryNotificationBody(notification);
if (selected) {
if (appName && appName !== title) {
lines.push(truncateText(font, appName, cardTextWidth));
}
if (body) {
lines.push(...wrapText(font, body, cardTextWidth).slice(0, 4));
}
} else if (body) {
lines.push(truncateText(font, wrapText(font, body, cardTextWidth)[0]!, cardTextWidth));
}
if (notification.actions.length) {
lines.push(`${notification.actions.length} quick action${notification.actions.length === 1 ? "" : "s"}`);
}
return {
notification,
lines,
height: Math.max(ICON_SIZE + 18, notification.hasLargeIcon ? LARGE_ICON_SIZE + 16 : 0, 12 + lines.length * lineStep(font)),
};
}
function drawNotificationCard(
image: GrayImage,
font: UiFont,
layout: CardLayout,
x: number,
y: number,
width: number,
selected: boolean,
focused: boolean,
icon: GrayImage | null,
largeIcon: GrayImage | null,
): void {
// Match the shared menu highlight: faint border + black fill when
// unselected; bright border when selected; the non-black fill only appears
// when the app also has focus (selected-but-unfocused stays black-filled).
const fill = selected && focused ? 15 : 1;
const stroke = selected ? 110 : 38;
image.fillRoundedRect(x, y, width, layout.height, fill, 8);
image.drawRoundedRect(x, y, width, layout.height, stroke, 8);
if (icon) {
image.bitBlt(icon, x + 10, y + 8, { transparentZero: true });
}
if (largeIcon) {
image.bitBlt(largeIcon, x + width - 10 - LARGE_ICON_SIZE + ((LARGE_ICON_SIZE - largeIcon.width) >> 1), y + 8);
}
for (let index = 0; index < layout.lines.length; index++) {
const value = index === 0 ? 140 : selected ? 235 : 185;
image.drawText(font, x + CARD_TEXT_X, y + 7 + index * lineStep(font), layout.lines[index]!, value);
}
}
function scrollForSelected(layouts: CardLayout[], selectedIndex: number, viewportHeight: number): number {
if (selectedIndex < 0) return 0;
let selectedTop = 0;
for (let index = 0; index < selectedIndex; index++) {
selectedTop += layouts[index]!.height + CARD_GAP;
}
const selectedBottom = selectedTop + layouts[selectedIndex]!.height;
const contentHeight = layouts.reduce((sum, layout) => sum + layout.height + CARD_GAP, 0);
const maxScroll = Math.max(0, contentHeight - viewportHeight);
const centered = selectedTop - Math.max(0, (viewportHeight - (selectedBottom - selectedTop)) / 2);
return clamp(centered | 0, 0, maxScroll);
}
function drawDetailContent(
image: GrayImage,
font: UiFont,
notification: AndroidNotification,
icon: GrayImage | null,
width: number,
height: number,
): void {
const contentX = NOTIFICATION_CONTENT_X;
const contentWidth = notificationContentWidth(width);
const step = lineStep(font);
const bottom = height - DETAIL_PICTURE_BOTTOM_MARGIN;
let top = drawNotificationHeader(image, font, icon, `${notification.appName || notification.packageName} ${formatRelativeTime(notification.postTime)}`);
// The title, beside the large icon (a sender's avatar, a site's logo) when
// there is one. A picture or custom layout can be the whole notification
// (Dexcom's has no text), so either stands in for the "(untitled)" placeholder.
const hasImages = Boolean(notification.hasPicture || notification.hasCustomView);
const title = notification.title || (hasImages ? "" : "(untitled)");
const avatarSize = notification.hasLargeIcon ? LARGE_ICON_SIZE : 0;
const titleX = avatarSize ? contentX + avatarSize + LARGE_ICON_GAP : contentX;
const titleWidth = contentX + contentWidth - titleX;
const titleLines = title ? wrapText(font, title, titleWidth) : [];
let titleHeight = 0;
if (avatarSize) {
const avatar = largeIconForNotification(notification);
if (avatar) image.bitBlt(avatar, contentX + ((avatarSize - avatar.width) >> 1), top + ((avatarSize - avatar.height) >> 1));
titleHeight = avatarSize;
}
if (titleLines.length) {
// A title shorter than the avatar is centered on it.
const titleTop = top + Math.max(0, (avatarSize - titleLines.length * step) >> 1);
const shown = drawClippedLines(image, font, titleLines, titleX, titleTop, titleWidth, ((bottom - top) / step) | 0, 230);
titleHeight = Math.max(titleHeight, shown * step);
}
const lines: string[] = [];
const body = detailNotificationBody(notification);
if (body) {
lines.push(...wrapText(font, body, contentWidth));
}
const meta = [notification.subText, notification.infoText, notification.summaryText].filter(Boolean).join(" ");
if (meta) {
if (lines.length) lines.push("");
lines.push(...wrapText(font, meta, contentWidth));
}
// Text follows the title after a blank line (just a gap beside an avatar); images after a gap.
if (titleHeight) {
top += titleHeight + (lines.length && !avatarSize ? step : DETAIL_PICTURE_GAP);
}
// The custom layout, then the picture, take what is left below the title,
// or below the first few lines of text when there is no title.
const reservedTextHeight = titleHeight ? 0 : Math.min(lines.length, DETAIL_PICTURE_TEXT_LINES) * step;
const roomForImages = bottom - top - (reservedTextHeight ? reservedTextHeight + DETAIL_PICTURE_GAP : 0);
let customView: GrayImage | null = null;
if (notification.hasCustomView && roomForImages >= DETAIL_CUSTOM_VIEW_MIN_HEIGHT) {
const result = imageForPaint((allowStale) => readNotificationCustomView(notification, contentWidth, roomForImages, allowStale));
customView = result.image;
if (!customView && !result.stale && notification.customText?.length) {
// It couldn't be drawn: its text is better than nothing.
lines.unshift(...wrapText(font, notification.customText.join(" "), contentWidth), ...(lines.length ? [""] : []));
}
}
const picture = pictureForNotification(notification, contentWidth,
roomForImages - (customView ? customView.height + DETAIL_PICTURE_GAP : 0));
// The text gets whatever the images leave, above them, with its last shown
// line marked when some is cut off.
const imagesHeight = (customView ? customView.height : 0) + (picture ? picture.height : 0)
+ (customView && picture ? DETAIL_PICTURE_GAP : 0);
const roomForText = bottom - top - (imagesHeight ? imagesHeight + DETAIL_PICTURE_GAP : 0);
const shownLines = drawClippedLines(image, font, lines, contentX, top, contentWidth, (roomForText / step) | 0, 190);
let imageTop = top + shownLines * step + (shownLines ? DETAIL_PICTURE_GAP : 0);
if (customView) {
image.bitBlt(customView, contentX, imageTop);
imageTop += customView.height + DETAIL_PICTURE_GAP;
}
if (picture) {
image.bitBlt(picture, contentX, imageTop);
}
}
/**
* Draw up to maxLines of lines from (x, y), marking the last one drawn with
* "..." when some are left out. Returns how many were drawn.
*/
function drawClippedLines(
image: GrayImage,
font: UiFont,
lines: string[],
x: number,
y: number,
width: number,
maxLines: number,
value: number,
): number {
const shown = Math.min(lines.length, Math.max(0, maxLines));
for (let index = 0; index < shown; index++) {
const line = index === shown - 1 && lines.length > shown ? truncateText(font, lines[index] + "...", width) : lines[index]!;
image.drawText(font, x, y + index * lineStep(font), line, value);
}
return shown;
}
/** Left edge of a notification detail view's content column. */
export const NOTIFICATION_CONTENT_X = DETAIL_CONTENT_X;
/** Width of a notification detail view's content column, left of the action column. */
export function notificationContentWidth(width: number): number {
return width - DETAIL_MENU_WIDTH - 24 - NOTIFICATION_CONTENT_X - 20;
}
/**
* The top of a notification detail view: the "Notification" title, then the
* source's icon and label. Returns the y where the body starts.
*/
export function drawNotificationHeader(image: GrayImage, font: UiFont, icon: GrayImage | null, sourceLabel: string): number {
const contentX = NOTIFICATION_CONTENT_X;
image.drawText(font, contentX, DETAIL_TITLE_Y, "Notification", 220);
// The header row (icon + app name) and the body stack below the title's
// line box, so a large UI font pushes them down instead of overlapping.
const headerTop = DETAIL_TITLE_Y + font.lineHeight + DETAIL_HEADER_GAP;
const headerHeight = Math.max(ICON_SIZE, font.lineHeight);
let sourceX = contentX;
if (icon) {
image.bitBlt(icon, contentX, headerTop + ((headerHeight - ICON_SIZE) >> 1), { transparentZero: true });
sourceX = contentX + ICON_SIZE + ICON_TEXT_GAP;
}
image.drawText(font, sourceX, centeredTextY(font, headerTop, headerHeight), sourceLabel, 150);
return headerTop + headerHeight + DETAIL_BODY_GAP;
}
/**
* A notification detail view's right-hand action column. Rows truncate their
* label to one line, except those `wraps` picks, which wrap it.
*/
export function createNotificationActionMenu<T extends { label: string }>(wraps: (item: T) => boolean = () => false): Menu<T> {
const rowLines = (font: UiFont, item: T, rowWidth: number): string[] => {
const textWidth = rowWidth - 2 * DETAIL_MENU_TEXT_X;
return wraps(item) ? wrapText(font, item.label, textWidth) : [truncateText(font, item.label, textWidth)];
};
return new Menu<T>({
wrap: false,
rowGap: DETAIL_MENU_ROW_GAP,
highlight: { radius: 6 },
getHeight: (item, width) => {
const font = getDefaultSmallFont();
return rowLines(font, item, width).length * lineStep(font) + 8;
},
draw: ({ image, item, x, y, width, selected }) => {
const font = getDefaultSmallFont();
const lines = rowLines(font, item, width);
for (let line = 0; line < lines.length; line++) {
image.drawText(font, x + DETAIL_MENU_TEXT_X, y + DETAIL_MENU_TEXT_Y + line * lineStep(font), lines[line]!, selected ? 255 : 185);
}
},
});
}
/** The action column's row boxes: right of the content, from DETAIL_MENU_TOP to the bottom margin. */
export function notificationActionMenuBox(width: number, height: number): MenuBox {
return {
x: width - DETAIL_MENU_WIDTH - 32,
y: DETAIL_MENU_TOP,
width: DETAIL_MENU_WIDTH,
height: height - DETAIL_MENU_TOP - DETAIL_MENU_BOTTOM_MARGIN,
};
}
function buildDetailMenu(notification: AndroidNotification, origin: SingleNotificationLayerOrigin): DetailMenuItem[] {
return [
{ kind: "back", label: "Back" },
...notification.actions.map((action): DetailMenuItem => ({
kind: "action",
label: action.enabled ? action.title : `${action.title} (unavailable)`,
action,
})),
{ kind: "dismiss", label: notification.dismissLabel || "Dismiss" },
...(origin === "new-notification-modal" && notification.packageName
? [{ kind: "disable-source" as const, label: "Don't show on glasses again" }] : []),
];
}
function primaryNotificationBody(notification: AndroidNotification): string {
const title = notificationTitle(notification);
const body = notification.bigText || notification.text || notification.lines.join(" / ") || notification.summaryText || "";
return body === title ? "" : body;
}
function detailNotificationBody(notification: AndroidNotification): string {
const lines = notification.lines.length ? notification.lines.join("\n") : "";
return [notification.bigText || notification.text, lines].filter(Boolean).join("\n");
}
function notificationTitle(notification: AndroidNotification): string {
return notification.title || notification.text || notification.customText?.join(" ") || notification.summaryText
|| notification.appName || notification.packageName || "(untitled)";
}