import { getDefaultSmallFont } from "../../graphics/ui-fonts"; import { truncateText, truncateLeft } from "../../graphics/textwrap"; import { GrayImage, type UiFont } from "../../graphics/image"; import { renderIcon, type IconName } from "../../graphics/icons"; import { clamp } from "../../util/numeric-util"; import { drawListScrollbar, drawSelectionHighlight, scrollToKeepSelectionVisible, type MenuItem } from "../../ui/menu"; import { iconGridMinRowHeight, tightRowHeight } from "../../ui/metrics"; import { ConfigSettingEnum } from "../../ui/dashboard-settings"; import { getStringSetting, setStringSetting } from "../../native/settings-store"; import { externalStorageRootPath, hasAllFilesAccess, listDirectory, requestAllFilesAccess, statPath, type DirectoryEntry, } from "../../native/file-access"; import { Layer, type DashboardInputEvent, type LayerContext } from "../../ui/layers"; const LIST_X = 20; /** Header: one line holding both the title and the current path. */ function headerHeight(font: UiFont): number { return 10 + font.lineHeight; } const GRID_COLS = 5; const ICON_SIZE = 44; const LABEL_GAP = 2; export type FilesViewMode = "icons" | "list"; export const filesViewModeSetting = new ConfigSettingEnum({ id: "files-view-mode", label: "View", storageKey: "files.viewMode", defaultValue: "icons", values: ["icons", "list"], formatValue: (value) => (value === "icons" ? "Icons" : "List"), }); // Bookmarked paths, in bookmarking order, stored as a JSON string array. const BOOKMARKS_KEY = "files.bookmarks"; export function getBookmarkedPaths(): string[] { try { const parsed = JSON.parse(getStringSetting(BOOKMARKS_KEY, "[]")); return Array.isArray(parsed) ? parsed.filter((path): path is string => typeof path === "string") : []; } catch { return []; } } export function isBookmarked(path: string): boolean { return getBookmarkedPaths().includes(path); } export function toggleBookmark(path: string): void { const paths = getBookmarkedPaths(); const next = paths.includes(path) ? paths.filter((p) => p !== path) : [...paths, path]; setStringSetting(BOOKMARKS_KEY, JSON.stringify(next)); } const TEXT_EXT = /\.(txt|md|markdown|log|json|xml|csv|ini|conf|cfg|yaml|yml|ts|js|py|java|c|cpp|h|sh|html|css)$/i; const IMAGE_EXT = /\.(png|jpe?g|gif|bmp|webp|heic|heif|svg)$/i; const VIDEO_EXT = /\.(mp4|mkv|webm|avi|mov|3gp|m4v)$/i; const AUDIO_EXT = /\.(mp3|m4a|aac|ogg|oga|opus|flac|wav|mid)$/i; const FONT_EXT = /\.(ttf|otf|ttc|bdf|woff2?)$/i; function fileIconName(name: string): IconName { if (TEXT_EXT.test(name)) return "file-text"; if (IMAGE_EXT.test(name)) return "image"; if (VIDEO_EXT.test(name)) return "film"; if (AUDIO_EXT.test(name)) return "music"; if (FONT_EXT.test(name)) return "type"; return "file"; } export type FileBrowserOptions = { /** Files failing this are listed dimmed (not viewable); picking them still fires onFilePicked. */ isSupportedFile: (name: string) => boolean; onFilePicked: (entry: DirectoryEntry, ctx: LayerContext) => void; /** Double-click while already at the Places level (leave the browser). */ onLeave: () => void; }; type EntryItem = { kind: "entry"; label: string; icon: IconName; entry: DirectoryEntry; supported: boolean; /** A bookmark whose path no longer exists (listed only for unbookmarking). */ missing?: boolean; /** An item on the Places level (a bookmark or a fixed storage root). */ place: boolean; /** Fixed Places roots cannot be bookmarked or unbookmarked. */ fixed: boolean; }; type BrowserItem = { kind: "grant"; label: string } | { kind: "info"; label: string } | EntryItem; type IconRow = | { kind: "special"; item: BrowserItem; flatIndex: number } | { kind: "grid"; items: EntryItem[]; firstIndex: number }; type IconMode = "row" | "item"; /** * Filesystem browser with two views. The top "Places" level lists bookmarks * and the storage roots; descending browses real directories. Icons view is a * 5-column grid with launcher-style two-level selection (scroll picks a row, * click drops into the row, scroll picks the item); list view is a flat list. * Click descends into a directory or picks a supported file; double-click * backs out one level (item selection, then parent directory, then Places, * then leaving the browser). Sized to its hosting stack. */ export class FileBrowserLayer implements Layer { /** Current directory, or null at the Places level. */ private location: string | null = null; /** The Places entry we descended through; going up from it returns to Places. */ private navRoot: string | null = null; private entries: DirectoryEntry[] | null = null; private listingFailed = false; private listIndex = 0; private selectedRow = 0; private selectedCol = 0; private iconMode: IconMode = "row"; private scrollRow = 0; constructor(private readonly options: FileBrowserOptions) {} paint(ctx: LayerContext): GrayImage { const font = getDefaultSmallFont(); const { width, height } = ctx.stack.getBaseSize(); const image = new GrayImage(width, height, 0); const rows = this.flatRows(); image.drawText(font, 20, 8, "Files", 220); const pathLabel = this.location === null ? "Places" : this.location; const pathX = 20 + font.measureText("Files") + 14; image.drawText(font, pathX, 8, truncateLeft(font, pathLabel, width - pathX - 20), 130); if (filesViewModeSetting.get() === "list") { this.paintList(image, font, rows, ctx); } else { this.paintIcons(image, font, rows, ctx); } return image; } private paintList(image: GrayImage, font: UiFont, rows: BrowserItem[], ctx: LayerContext): void { const { width, height } = ctx.stack.getBaseSize(); this.listIndex = clamp(this.listIndex, 0, Math.max(0, rows.length - 1)); const rowH = tightRowHeight(font); const headerH = headerHeight(font); const listHeight = height - headerH - 4; const visibleRows = Math.max(1, (listHeight / rowH) | 0); this.scrollRow = scrollToKeepSelectionVisible(this.scrollRow, this.listIndex, visibleRows, rows.length); const lastVisible = Math.min(rows.length, this.scrollRow + visibleRows); for (let index = this.scrollRow; index < lastVisible; index++) { const row = rows[index]!; const y = headerH + (index - this.scrollRow) * rowH; const selected = index === this.listIndex; if (selected) { drawSelectionHighlight(image, LIST_X - 6, y - 1, width - 2 * LIST_X + 12, rowH - 1, ctx.stack.isFocused(), 4); } const value = itemValue(row, selected); image.drawText(font, LIST_X, y + 1, truncateText(font, row.label, width - 2 * LIST_X), value); } } private paintIcons(image: GrayImage, font: UiFont, rows: BrowserItem[], ctx: LayerContext): void { const { width, height } = ctx.stack.getBaseSize(); const focused = ctx.stack.isFocused(); const iconRows = buildIconRows(rows); this.selectedRow = clamp(this.selectedRow, 0, Math.max(0, iconRows.length - 1)); const gridTop = headerHeight(font); const gridBottom = height - 6; const visibleRows = Math.max(1, Math.floor((gridBottom - gridTop) / iconGridMinRowHeight(font, ICON_SIZE, LABEL_GAP))); const rowH = Math.floor((gridBottom - gridTop) / visibleRows); const colW = width / GRID_COLS; this.scrollRow = scrollToKeepSelectionVisible(this.scrollRow, this.selectedRow, visibleRows, iconRows.length); const lastVisible = Math.min(iconRows.length, this.scrollRow + visibleRows); for (let rowIndex = this.scrollRow; rowIndex < lastVisible; rowIndex++) { const row = iconRows[rowIndex]!; const y = gridTop + (rowIndex - this.scrollRow) * rowH; const selected = rowIndex === this.selectedRow; if (row.kind === "special") { const textY = y + (((rowH - font.lineHeight) / 2) | 0); if (selected) { drawSelectionHighlight(image, LIST_X - 6, textY - 2, width - 2 * LIST_X + 12, font.lineHeight + 4, focused, 4); } image.drawText(font, LIST_X, textY, truncateText(font, row.item.label, width - 2 * LIST_X), itemValue(row.item, selected)); continue; } if (selected) { if (this.iconMode === "row") { drawSelectionHighlight(image, 4, y + 1, width - 8, rowH - 2, focused, 6); } else { this.selectedCol = clamp(this.selectedCol, 0, row.items.length - 1); drawSelectionHighlight(image, this.selectedCol * colW + 4, y + 1, colW - 8, rowH - 2, focused, 6); } } for (let col = 0; col < row.items.length; col++) { const item = row.items[col]!; const centerX = col * colW + colW / 2; const blockTop = y + Math.max(2, (rowH - ICON_SIZE - font.lineHeight - LABEL_GAP) / 2); const icon = renderIcon(item.icon, ICON_SIZE); if (icon) { image.bitBlt(item.supported ? icon : dimmedIcon(item.icon, icon), Math.round(centerX - icon.width / 2), Math.round(blockTop), { transparentZero: true, }); } const label = truncateText(font, item.label, colW - 8); const labelY = Math.round(blockTop + ICON_SIZE + LABEL_GAP); image.drawText(font, Math.round(centerX - font.measureText(label) / 2), labelY, label, item.supported ? 210 : 100); } } if (iconRows.length > visibleRows) { drawListScrollbar(image, width - 5, gridTop, visibleRows * rowH - 4, this.scrollRow, visibleRows, iconRows.length); } } async handleInput(event: DashboardInputEvent, ctx: LayerContext): Promise { if (filesViewModeSetting.get() === "list") { await this.handleListInput(event, ctx); } else { await this.handleIconsInput(event, ctx); } } private async handleListInput(event: DashboardInputEvent, ctx: LayerContext): Promise { const rows = this.flatRows(); switch (event.type) { case "scroll-up": this.listIndex = Math.max(0, this.listIndex - 1); return; case "scroll-down": this.listIndex = Math.min(Math.max(0, rows.length - 1), this.listIndex + 1); return; case "click": { const row = rows[clamp(this.listIndex, 0, Math.max(0, rows.length - 1))]; if (row) await this.activateItem(row, ctx); return; } case "double-click": this.navigateUp(); return; default: return; } } private async handleIconsInput(event: DashboardInputEvent, ctx: LayerContext): Promise { const rows = this.flatRows(); const iconRows = buildIconRows(rows); this.selectedRow = clamp(this.selectedRow, 0, Math.max(0, iconRows.length - 1)); const row = iconRows[this.selectedRow]; switch (event.type) { case "scroll-up": case "scroll-down": { const delta = event.type === "scroll-down" ? 1 : -1; if (this.iconMode === "item") { // Item selection traverses linearly: past a row's edge it continues // onto the adjacent row (a special row counts as a single item). if (row?.kind === "grid") { const next = clamp(this.selectedCol, 0, row.items.length - 1) + delta; if (next >= 0 && next < row.items.length) { this.selectedCol = next; return; } } const adjacentIndex = this.selectedRow + delta; if (adjacentIndex < 0 || adjacentIndex >= iconRows.length) return; this.selectedRow = adjacentIndex; const adjacent = iconRows[adjacentIndex]!; if (adjacent.kind === "grid") { this.selectedCol = delta > 0 ? 0 : adjacent.items.length - 1; } } else { this.selectedRow = clamp(this.selectedRow + delta, 0, Math.max(0, iconRows.length - 1)); } return; } case "click": { if (!row) return; if (row.kind === "special") { await this.activateItem(row.item, ctx); return; } if (this.iconMode === "row") { this.iconMode = "item"; // Default to the middle column (clamped to the row's item count). this.selectedCol = Math.min(Math.floor(GRID_COLS / 2), row.items.length - 1); } else { const item = row.items[clamp(this.selectedCol, 0, row.items.length - 1)]; if (item) await this.activateItem(item, ctx); } return; } case "double-click": if (this.iconMode === "item") { this.iconMode = "row"; } else { this.navigateUp(); } return; default: return; } } /** * App-specific entries for the window long-press menu: the view switch, * plus bookmark/unbookmark for the selected entry (in icons view only once * an item, not just a row, is selected). */ buildMenuItems(): MenuItem[] { const items: MenuItem[] = []; const mode = filesViewModeSetting.get(); items.push({ label: mode === "icons" ? "View as list" : "View as icons", onSelect: (ctx) => { this.setViewMode(mode === "icons" ? "list" : "icons"); ctx.stack.pop(); }, }); const target = this.currentItem(); if (target && target.kind === "entry" && !target.fixed) { const path = target.entry.path; const name = truncateChars(target.entry.name || path, 24); items.push({ label: isBookmarked(path) ? `Remove bookmark: ${name}` : `Bookmark: ${name}`, onSelect: (ctx) => { toggleBookmark(path); const rows = this.flatRows(); this.listIndex = clamp(this.listIndex, 0, Math.max(0, rows.length - 1)); ctx.stack.pop(); }, }); } return items; } /** The item an entry-specific action would apply to, if one is selected. */ private currentItem(): BrowserItem | null { const rows = this.flatRows(); if (!rows.length) return null; if (filesViewModeSetting.get() === "list") { return rows[clamp(this.listIndex, 0, rows.length - 1)] ?? null; } const iconRows = buildIconRows(rows); const row = iconRows[clamp(this.selectedRow, 0, iconRows.length - 1)]; if (!row) return null; if (row.kind === "special") return row.item; if (this.iconMode !== "item") return null; return row.items[clamp(this.selectedCol, 0, row.items.length - 1)] ?? null; } private setViewMode(mode: FilesViewMode): void { if (filesViewModeSetting.get() === mode) return; const rows = this.flatRows(); const iconRows = buildIconRows(rows); if (mode === "list") { // Carry the icon-grid selection into the flat list (clamped column when // only a row was selected). const row = iconRows[clamp(this.selectedRow, 0, Math.max(0, iconRows.length - 1))]; if (row) { this.listIndex = row.kind === "special" ? row.flatIndex : row.firstIndex + clamp(this.selectedCol, 0, row.items.length - 1); } } else { this.setGridSelectionFromFlatIndex(rows, clamp(this.listIndex, 0, Math.max(0, rows.length - 1))); this.iconMode = "row"; } filesViewModeSetting.set(mode); this.scrollRow = 0; } private async activateItem(item: BrowserItem, ctx: LayerContext): Promise { if (item.kind === "grant") { requestAllFilesAccess(); this.entries = null; // re-list after the user returns from Settings return; } if (item.kind !== "entry" || item.missing) return; if (item.entry.isDirectory) { this.navigateTo(item.entry.path, item.place); } else { // Every real file opens the picked-file dialog, viewable or not (the // dialog shows metadata; open actions depend on the type). this.options.onFilePicked(item.entry, ctx); } } private navigateTo(path: string, asRoot = false): void { if (asRoot) this.navRoot = path; this.location = path; this.entries = null; this.resetSelection(); } private navigateUp(): void { const from = this.location; if (from === null) { this.options.onLeave(); return; } if (from === this.navRoot || from === "/") { this.location = null; this.entries = null; this.resetSelection(); this.selectPath(this.navRoot ?? from); this.navRoot = null; return; } const parentRaw = from.slice(0, from.lastIndexOf("/")); this.navigateTo(parentRaw.length ? parentRaw : "/"); this.selectPath(from); } private resetSelection(): void { this.listIndex = 0; this.selectedRow = 0; this.selectedCol = 0; this.iconMode = "row"; this.scrollRow = 0; } /** Select the item with the given path (e.g. the directory just left). */ private selectPath(path: string): void { const rows = this.flatRows(); const index = rows.findIndex((row) => row.kind === "entry" && row.entry.path === path); if (index < 0) return; this.listIndex = index; this.setGridSelectionFromFlatIndex(rows, index); } private setGridSelectionFromFlatIndex(rows: BrowserItem[], index: number): void { const specials = leadingSpecialCount(rows); if (index < specials) { this.selectedRow = index; this.selectedCol = 0; return; } const ordinal = index - specials; this.selectedRow = specials + Math.floor(ordinal / GRID_COLS); this.selectedCol = ordinal % GRID_COLS; } private flatRows(): BrowserItem[] { const rows: BrowserItem[] = []; if (!hasAllFilesAccess()) { rows.push({ kind: "grant", label: "Grant file access (opens phone Settings)" }); } if (this.location === null) { for (const path of getBookmarkedPaths()) { rows.push(this.bookmarkItem(path)); } rows.push(this.placeItem("Internal storage", externalStorageRootPath())); rows.push(this.placeItem("/", "/")); return rows; } this.loadEntries(); for (const entry of this.entries ?? []) { rows.push({ kind: "entry", entry, label: entry.isDirectory ? `${entry.name}/` : entry.name, icon: entry.isDirectory ? "folder" : fileIconName(entry.name), supported: entry.isDirectory || this.options.isSupportedFile(entry.name), place: false, fixed: false, }); } if (!rows.some((row) => row.kind === "entry")) { rows.push({ kind: "info", label: this.listingFailed ? "(unreadable directory)" : "(empty directory)" }); } return rows; } private placeItem(label: string, path: string): EntryItem { return { kind: "entry", entry: { name: label, path, isDirectory: true, sizeBytes: 0, modifiedMs: 0 }, label, icon: "hard-drive", supported: true, place: true, fixed: true, }; } private bookmarkItem(path: string): EntryItem { const stat = statPath(path); if (!stat) { const name = basename(path); return { kind: "entry", entry: { name, path, isDirectory: false, sizeBytes: 0, modifiedMs: 0 }, label: `${name} (missing)`, icon: "file", supported: false, missing: true, place: true, fixed: false, }; } const name = stat.name || path; return { kind: "entry", entry: stat, label: stat.isDirectory ? `${name}/` : name, icon: stat.isDirectory ? "folder" : fileIconName(name), supported: stat.isDirectory || this.options.isSupportedFile(name), place: true, fixed: false, }; } private loadEntries(): void { if (this.entries !== null || this.location === null) return; const listing = listDirectory(this.location); this.listingFailed = listing === null; this.entries = listing ?? []; } } function buildIconRows(flat: BrowserItem[]): IconRow[] { const rows: IconRow[] = []; let index = 0; // Special rows (grant prompt, empty/unreadable info) lead the list; each // gets a full-width row of its own. Entries follow, chunked into grid rows. while (index < flat.length && flat[index]!.kind !== "entry") { rows.push({ kind: "special", item: flat[index]!, flatIndex: index }); index++; } for (; index < flat.length; index += GRID_COLS) { rows.push({ kind: "grid", items: flat.slice(index, index + GRID_COLS) as EntryItem[], firstIndex: index }); } return rows; } function leadingSpecialCount(rows: BrowserItem[]): number { let count = 0; while (count < rows.length && rows[count]!.kind !== "entry") count++; return count; } function itemValue(item: BrowserItem, selected: boolean): number { if (item.kind === "info") return 120; if (item.kind === "grant") return selected ? 255 : 210; if (!item.supported) return selected ? 140 : 100; return selected ? 255 : 200; } // Unsupported files draw their grid icon at half brightness; rendered once // per icon name and cached (all grid icons share one size). const dimmedIconCache = new Map(); function dimmedIcon(name: IconName, icon: GrayImage): GrayImage { const cached = dimmedIconCache.get(name); if (cached) return cached; const dimmed = new GrayImage(icon.width, icon.height, 0); for (let i = 0; i < icon.pixels.length; i++) { dimmed.pixels[i] = icon.pixels[i]! >> 1; } dimmedIconCache.set(name, dimmed); return dimmed; } function basename(path: string): string { const parts = path.split("/").filter((part) => part.length > 0); return parts[parts.length - 1] ?? path; } function truncateChars(text: string, maxLength: number): string { return text.length <= maxLength ? text : `${text.slice(0, Math.max(0, maxLength - 3))}...`; }