diff --git a/app/lib/features/settings/settings_custom_font_actions.dart b/app/lib/features/settings/settings_custom_font_actions.dart new file mode 100644 index 00000000..cf90c7b4 --- /dev/null +++ b/app/lib/features/settings/settings_custom_font_actions.dart @@ -0,0 +1,153 @@ +import 'package:flutter/cupertino.dart'; +import 'package:flutter/material.dart'; + +import '../../ui/theme/app_font_controller.dart'; +import '../../ui/theme/custom_fonts/custom_font.dart'; +import '../../ui/theme/custom_fonts/custom_font_draft.dart'; +import '../../ui/theme/custom_fonts/font_file_picker.dart'; +import 'settings_custom_font_dialogs.dart'; +import 'settings_theme.dart'; + +const addCustomFontText = 'Add font…'; +const addingCustomFontText = 'Adding…'; +const renameCustomFontText = 'Rename'; +const removeCustomFontText = 'Remove'; +const customFontActionsTooltip = 'Font options'; + +/// Pick files, check them, ask for the family's name, then register, store +/// and choose the font. Every refusal is said in a dialog; nothing is +/// stored unless the whole family loaded. +Future addCustomFont( + BuildContext context, + AppFontController fonts, + FontFilePicker pick, +) async { + Future problem(String message) async { + if (context.mounted) { + await showFontProblem(context, addCustomFontFailedTitle, message); + } + } + + final List? files; + try { + files = await pick(); + } on CustomFontRejected catch (error) { + return problem(error.message); + } catch (_) { + return problem('The chosen files could not be read.'); + } + if (files == null || !context.mounted) return; + final CustomFontDraft draft; + try { + draft = await fonts.inspect(files); + } on CustomFontRejected catch (error) { + return problem(error.message); + } + if (!context.mounted) return; + final name = await showFontNameDialog( + context, + title: addCustomFontTitle, + initial: draft.suggestedName, + confirm: 'Add', + detail: draft.faces.map((f) => '${f.styleName} · ${f.fileName}').join('\n'), + ); + if (name == null) return; + try { + await fonts.addCustom(draft, name); + } on CustomFontRejected catch (error) { + return problem(error.message); + } +} + +enum _CustomFontAction { rename, remove } + +/// The overflow control on an added font's row: Rename and Remove. +class CustomFontMenu extends StatelessWidget { + const CustomFontMenu({super.key, required this.fonts, required this.font}); + + final AppFontController fonts; + final CustomFont font; + + Future _run(BuildContext context, _CustomFontAction action) async { + switch (action) { + case _CustomFontAction.rename: + final name = await showFontNameDialog( + context, + title: renameCustomFontTitle, + initial: font.name, + confirm: renameCustomFontText, + ); + if (name == null || name == font.name) return; + try { + await fonts.renameCustom(font, name); + } on CustomFontRejected catch (error) { + if (context.mounted) { + await showFontProblem( + context, + renameCustomFontTitle, + error.message, + ); + } + } + case _CustomFontAction.remove: + if (await confirmRemoveFont(context, font.name)) { + await fonts.removeCustom(font); + } + } + } + + Future _cupertinoSheet(BuildContext context) async { + final action = await showCupertinoModalPopup<_CustomFontAction>( + context: context, + builder: (context) => CupertinoActionSheet( + title: Text(font.name), + actions: [ + CupertinoActionSheetAction( + onPressed: () => Navigator.pop(context, _CustomFontAction.rename), + child: const Text(renameCustomFontText), + ), + CupertinoActionSheetAction( + isDestructiveAction: true, + onPressed: () => Navigator.pop(context, _CustomFontAction.remove), + child: const Text(removeCustomFontText), + ), + ], + cancelButton: CupertinoActionSheetAction( + onPressed: () => Navigator.pop(context), + child: const Text('Cancel'), + ), + ), + ); + if (action != null && context.mounted) await _run(context, action); + } + + @override + Widget build(BuildContext context) { + if (usesCupertinoControls(context)) { + return Semantics( + label: customFontActionsTooltip, + button: true, + excludeSemantics: true, + child: CupertinoButton( + padding: EdgeInsets.zero, + onPressed: () => _cupertinoSheet(context), + child: const Icon(CupertinoIcons.ellipsis_circle), + ), + ); + } + return PopupMenuButton<_CustomFontAction>( + tooltip: customFontActionsTooltip, + onSelected: (action) => _run(context, action), + itemBuilder: (context) => const >[ + PopupMenuItem( + value: _CustomFontAction.rename, + child: Text(renameCustomFontText), + ), + PopupMenuItem( + value: _CustomFontAction.remove, + child: Text(removeCustomFontText), + ), + ], + ); + } +} diff --git a/app/lib/features/settings/settings_custom_font_dialogs.dart b/app/lib/features/settings/settings_custom_font_dialogs.dart new file mode 100644 index 00000000..f0d58d5d --- /dev/null +++ b/app/lib/features/settings/settings_custom_font_dialogs.dart @@ -0,0 +1,213 @@ +import 'package:flutter/cupertino.dart'; +import 'package:flutter/material.dart'; + +import '../../ui/theme/custom_fonts/custom_font_draft.dart'; +import 'settings_theme.dart'; + +const customFontNameLabel = 'Name'; +const addCustomFontTitle = 'Add font'; +const renameCustomFontTitle = 'Rename font'; +const addCustomFontFailedTitle = 'Could not add font'; + +/// Asks for a font family's name, prefilled with [initial]; null when +/// cancelled. [detail] lists what is being added. +Future showFontNameDialog( + BuildContext context, { + required String title, + required String initial, + required String confirm, + String? detail, +}) { + final dialog = _FontNameDialog( + title: title, + initial: initial, + confirm: confirm, + detail: detail, + ); + return usesCupertinoControls(context) + ? showCupertinoDialog(context: context, builder: (_) => dialog) + : showDialog(context: context, builder: (_) => dialog); +} + +class _FontNameDialog extends StatefulWidget { + const _FontNameDialog({ + required this.title, + required this.initial, + required this.confirm, + this.detail, + }); + + final String title; + final String initial; + final String confirm; + final String? detail; + + @override + State<_FontNameDialog> createState() => _FontNameDialogState(); +} + +class _FontNameDialogState extends State<_FontNameDialog> { + late final TextEditingController _name = TextEditingController( + text: widget.initial, + ); + String? _problem; + + @override + void dispose() { + _name.dispose(); + super.dispose(); + } + + void _submit() { + final problem = CustomFontLimits.nameProblem(_name.text); + if (problem != null) { + setState(() => _problem = problem); + return; + } + Navigator.pop(context, _name.text.trim()); + } + + @override + Widget build(BuildContext context) { + final cupertino = usesCupertinoControls(context); + final field = cupertino + ? CupertinoTextField( + controller: _name, + autofocus: true, + placeholder: customFontNameLabel, + maxLength: CustomFontLimits.maxNameLength, + onSubmitted: (_) => _submit(), + ) + : TextField( + controller: _name, + autofocus: true, + maxLength: CustomFontLimits.maxNameLength, + decoration: InputDecoration( + labelText: customFontNameLabel, + errorText: _problem, + ), + onSubmitted: (_) => _submit(), + ); + final content = Column( + mainAxisSize: MainAxisSize.min, + crossAxisAlignment: CrossAxisAlignment.stretch, + children: [ + if (widget.detail != null) ...[ + Text(widget.detail!), + const SizedBox(height: 12), + ], + field, + if (cupertino && _problem != null) + Text(_problem!, style: TextStyle(color: settingsErrorColor(context))), + ], + ); + if (cupertino) { + return CupertinoAlertDialog( + title: Text(widget.title), + content: Padding( + padding: const EdgeInsets.only(top: 8), + child: content, + ), + actions: [ + CupertinoDialogAction( + onPressed: () => Navigator.pop(context), + child: const Text('Cancel'), + ), + CupertinoDialogAction( + isDefaultAction: true, + onPressed: _submit, + child: Text(widget.confirm), + ), + ], + ); + } + return AlertDialog( + title: Text(widget.title), + content: SingleChildScrollView(child: content), + actions: [ + TextButton( + onPressed: () => Navigator.pop(context), + child: const Text('Cancel'), + ), + TextButton(onPressed: _submit, child: Text(widget.confirm)), + ], + ); + } +} + +/// Confirms deleting an added font; true when the user agrees. +Future confirmRemoveFont(BuildContext context, String name) async { + final title = Text('Remove $name?'); + const body = Text('Its files are deleted from this device.'); + final confirmed = usesCupertinoControls(context) + ? await showCupertinoDialog( + context: context, + builder: (context) => CupertinoAlertDialog( + title: title, + content: body, + actions: [ + CupertinoDialogAction( + onPressed: () => Navigator.pop(context, false), + child: const Text('Cancel'), + ), + CupertinoDialogAction( + isDestructiveAction: true, + onPressed: () => Navigator.pop(context, true), + child: const Text('Remove'), + ), + ], + ), + ) + : await showDialog( + context: context, + builder: (context) => AlertDialog( + title: title, + content: body, + actions: [ + TextButton( + onPressed: () => Navigator.pop(context, false), + child: const Text('Cancel'), + ), + TextButton( + onPressed: () => Navigator.pop(context, true), + child: const Text('Remove'), + ), + ], + ), + ); + return confirmed ?? false; +} + +/// Says why a font could not be added or changed. +Future showFontProblem( + BuildContext context, + String title, + String message, +) => usesCupertinoControls(context) + ? showCupertinoDialog( + context: context, + builder: (context) => CupertinoAlertDialog( + title: Text(title), + content: Text(message), + actions: [ + CupertinoDialogAction( + isDefaultAction: true, + onPressed: () => Navigator.pop(context), + child: const Text('OK'), + ), + ], + ), + ) + : showDialog( + context: context, + builder: (context) => AlertDialog( + title: Text(title), + content: Text(message), + actions: [ + TextButton( + onPressed: () => Navigator.pop(context), + child: const Text('OK'), + ), + ], + ), + ); diff --git a/app/lib/features/settings/settings_font_section.dart b/app/lib/features/settings/settings_font_section.dart index 049aba7f..b6a83bce 100644 --- a/app/lib/features/settings/settings_font_section.dart +++ b/app/lib/features/settings/settings_font_section.dart @@ -5,49 +5,82 @@ import 'package:flutter/material.dart'; import '../../ui/theme/app_font.dart'; import '../../ui/theme/app_font_controller.dart'; +import '../../ui/theme/custom_fonts/custom_font.dart'; +import '../../ui/theme/custom_fonts/font_file_picker.dart'; +import '../../ui/theme/font_choice.dart'; +import 'settings_custom_font_actions.dart'; import 'settings_group.dart'; import 'settings_row.dart'; import 'settings_theme.dart'; const fontSectionTitle = 'Font'; const fontSectionFooter = - 'Saved on this device only. Code keeps its monospace font.'; + 'Saved on this device only. Code keeps its monospace font. ' + 'Added fonts: .ttf or .otf, up to 10 MB each.'; const fontLoadingText = 'Loading…'; const fontLoadFailedText = 'Could not load this font.'; const fontSaveFailedText = 'Not saved on this device; it applies until reload.'; -ValueKey settingsFontKey(AppFont font) => +ValueKey settingsFontKey(FontChoice font) => ValueKey('settings-font-${font.id}'); +const ValueKey settingsAddFontKey = ValueKey( + 'settings-font-add', +); + /// The device's interface font: one row per option, each named in its own -/// face. Material rows are radio tiles, Cupertino rows carry the checkmark. +/// face, the user's added fonts below the bundled ones, then "Add font…". +/// Material rows are radio tiles, Cupertino rows carry the checkmark. /// A choice is stored locally and applies as soon as its files load. class SettingsFontSection extends StatefulWidget { - const SettingsFontSection({super.key, required this.controller}); + const SettingsFontSection({ + super.key, + required this.controller, + this.pickFiles = pickFontFiles, + }); final AppFontController controller; + /// The host file picker; tests substitute chosen files. + final FontFilePicker pickFiles; + @override State createState() => _SettingsFontSectionState(); } class _SettingsFontSectionState extends State { + bool _adding = false; + @override void initState() { super.initState(); - _preview(); + unawaited(_preview()); } @override void didUpdateWidget(SettingsFontSection oldWidget) { super.didUpdateWidget(oldWidget); - if (oldWidget.controller != widget.controller) _preview(); + if (oldWidget.controller != widget.controller) unawaited(_preview()); } /// Only the regular weight of each option, only once Settings is shown. - void _preview() { + Future _preview() async { + final controller = widget.controller; for (final font in AppFont.values) { - unawaited(widget.controller.preview(font)); + unawaited(controller.preview(font)); + } + await controller.loadCustomFonts(); + for (final font in controller.customFonts) { + unawaited(controller.preview(font)); + } + } + + Future _add() async { + setState(() => _adding = true); + try { + await addCustomFont(context, widget.controller, widget.pickFiles); + } finally { + if (mounted) setState(() => _adding = false); } } @@ -60,6 +93,7 @@ class _SettingsFontSectionState extends State { Widget _group(BuildContext context) { final controller = widget.controller; final cupertino = usesCupertinoControls(context); + final options = [...AppFont.values, ...controller.customFonts]; final group = SettingsGroup( title: fontSectionTitle, footer: Column( @@ -74,19 +108,28 @@ class _SettingsFontSectionState extends State { ], ), children: [ - for (final font in AppFont.values) + for (final font in options) cupertino ? _cupertinoRow(context, font) - : RadioListTile( - key: settingsFontKey(font), - value: font, - title: _name(context, font), - subtitle: _status(context, font), - ), + : _materialRow(context, font), + // Its own node: a bare list tile would lend its label and tap to the + // section around it. + Semantics( + container: true, + child: SettingsRow( + key: settingsAddFontKey, + action: true, + enabled: !_adding, + leading: Icon(cupertino ? CupertinoIcons.add : Icons.add), + title: const Text(addCustomFontText), + subtitle: _adding ? const Text(addingCustomFontText) : null, + onTap: () => unawaited(_add()), + ), + ), ], ); if (cupertino) return group; - return RadioGroup( + return RadioGroup( groupValue: controller.selected, onChanged: (font) { if (font != null) unawaited(controller.select(font)); @@ -95,38 +138,84 @@ class _SettingsFontSectionState extends State { ); } - Widget _cupertinoRow(BuildContext context, AppFont font) => SettingsRow( - key: settingsFontKey(font), - title: _name(context, font), - subtitle: _status(context, font), - trailing: widget.controller.selected == font + Widget _materialRow(BuildContext context, FontChoice font) { + final tile = RadioListTile( + key: settingsFontKey(font), + value: font, + title: _name(context, font), + subtitle: _status(context, font), + ); + if (font is! CustomFont) return tile; + // The options button sits beside the tile rather than in its + // `secondary` slot: the tile merges its children's semantics, which + // would leave the button unreachable on its own. + return Row( + children: [ + Expanded(child: tile), + Padding( + padding: const EdgeInsetsDirectional.only(end: 8), + child: CustomFontMenu(fonts: widget.controller, font: font), + ), + ], + ); + } + + Widget _cupertinoRow(BuildContext context, FontChoice font) { + final check = widget.controller.selected == font ? Icon( CupertinoIcons.check_mark, color: CupertinoTheme.of(context).primaryColor, ) - : null, - onTap: () => unawaited(widget.controller.select(font)), - ); + : null; + // One node per option, announced as selected. + final row = Semantics( + container: true, + selected: check != null, + child: SettingsRow( + key: settingsFontKey(font), + title: _name(context, font), + subtitle: _status(context, font), + trailing: check, + onTap: () => unawaited(widget.controller.select(font)), + ), + ); + if (font is! CustomFont) return row; + // Beside the row, not in it: the list tile merges its children's + // semantics (see [_materialRow]). + return Row( + children: [ + Expanded(child: row), + Padding( + padding: const EdgeInsetsDirectional.only(end: 12), + child: CustomFontMenu(fonts: widget.controller, font: font), + ), + ], + ); + } /// The option's name in its own face once its regular weight has loaded; /// the system face until then (and always for the system option). - Widget _name(BuildContext context, AppFont font) { + Widget _name(BuildContext context, FontChoice font) { final family = widget.controller.canPreview(font) ? font.family ?? _systemFamily(context) : _systemFamily(context); return Text(font.label, style: TextStyle(fontFamily: family)); } - Widget? _status(BuildContext context, AppFont font) { + /// Loading or failure for the chosen option; an added font otherwise + /// lists its styles. + Widget? _status(BuildContext context, FontChoice font) { final controller = widget.controller; - if (controller.selected != font) return null; - if (controller.loadFailed == font) { - return Text( - fontLoadFailedText, - style: TextStyle(color: settingsErrorColor(context)), - ); + if (controller.selected == font) { + if (controller.loadFailed == font) { + return Text( + fontLoadFailedText, + style: TextStyle(color: settingsErrorColor(context)), + ); + } + if (controller.loading) return const Text(fontLoadingText); } - return controller.loading ? const Text(fontLoadingText) : null; + return font is CustomFont ? Text(font.styles) : null; } } diff --git a/app/lib/ui/theme/app_font.dart b/app/lib/ui/theme/app_font.dart index 491378ae..e7c581e1 100644 --- a/app/lib/ui/theme/app_font.dart +++ b/app/lib/ui/theme/app_font.dart @@ -1,9 +1,11 @@ -/// The interface typefaces a device can choose. [AppFont.system] keeps the +import 'font_choice.dart'; + +/// The bundled interface typefaces a device can choose. [AppFont.system] keeps the /// platform's own typography (Roboto on Android and the web, SF on iOS); every /// other option is an open-licence (SIL OFL 1.1) family bundled under /// `fonts//` as plain assets, not under pubspec `fonts:`, so a web /// page downloads only the family it actually shows. -enum AppFont { +enum AppFont implements FontChoice { system('system', 'System default', null, null, []), inter('inter', 'Inter', 'Inter', 'inter', [ 'Inter-Regular.ttf', @@ -50,13 +52,13 @@ enum AppFont { const AppFont(this.id, this.label, this.family, this._directory, this._files); - /// The stored value. Stable across releases; never the display label. + @override final String id; - /// The picker's name for the option. + @override final String label; - /// The registered family name; null keeps the platform typography. + @override final String? family; final String? _directory; @@ -70,6 +72,12 @@ enum AppFont { /// The regular weight alone: enough to preview the option's name. String? get previewAsset => _files.isEmpty ? null : assets.first; + @override + List get sources => assets; + + @override + String? get previewSource => previewAsset; + /// The licence shipped beside the files. String? get licenseAsset => _directory == null ? null : 'fonts/$_directory/OFL.txt'; diff --git a/app/lib/ui/theme/app_font_controller.dart b/app/lib/ui/theme/app_font_controller.dart index 3109282f..f4d290b3 100644 --- a/app/lib/ui/theme/app_font_controller.dart +++ b/app/lib/ui/theme/app_font_controller.dart @@ -1,28 +1,21 @@ import 'dart:async'; +import 'dart:typed_data'; -import 'package:flutter/services.dart'; import 'package:flutter/widgets.dart'; import 'app_font.dart'; +import 'app_font_loaders.dart'; import 'app_font_store.dart'; +import 'custom_fonts/custom_font.dart'; +import 'custom_fonts/custom_font_draft.dart'; +import 'custom_fonts/custom_font_library.dart'; +import 'font_choice.dart'; -/// Registers [assets] under [family]. Production reads them from the bundle; -/// tests substitute a recorder. -typedef AppFontAssetLoader = - Future Function(String family, List assets); - -/// Loads bundled font files on demand with a [FontLoader]. On the web each -/// asset is fetched only now, when its family is first previewed or chosen. -Future loadBundledFontAssets(String family, List assets) async { - final loader = FontLoader(family); - for (final asset in assets) { - loader.addFont(rootBundle.load(asset)); - } - await loader.load(); -} +export 'app_font_loaders.dart'; /// The device's interface font: the stored choice, the family the theme -/// actually uses, and the on-demand loading between the two. +/// actually uses, the on-demand loading between the two, and the fonts the +/// user added. /// /// The theme keeps the previous family (at first the platform's) until the /// chosen files are registered, then switches once; text never lays out in a @@ -30,51 +23,69 @@ Future loadBundledFontAssets(String family, List assets) async { class AppFontController extends ChangeNotifier { AppFontController({ this._store = const SharedPreferencesAppFontStore(), - this._loader = loadBundledFontAssets, - }); + AppFontAssetLoader? loader, + this._bytesLoader = loadFontBytes, + CustomFontLibrary? library, + }) : _library = library ?? CustomFontLibrary() { + _loader = loader ?? appFontSourceLoader(_library.read); + } /// The app's own controller: one per running app, shared by the theme /// hosts and the Settings picker. static final AppFontController instance = AppFontController(); final AppFontStore _store; - final AppFontAssetLoader _loader; + late final AppFontAssetLoader _loader; + final AppFontBytesLoader _bytesLoader; + final CustomFontLibrary _library; final Map> _assetLoads = >{}; final Set _loadedAssets = {}; + Future? _libraryLoad; - AppFont _selected = AppFont.system; - AppFont _applied = AppFont.system; + FontChoice _selected = AppFont.system; + FontChoice _applied = AppFont.system; bool _saveFailed = false; - AppFont? _loadFailed; + FontChoice? _loadFailed; /// The option the picker shows as chosen. - AppFont get selected => _selected; + FontChoice get selected => _selected; /// The option the theme uses now. - AppFont get applied => _applied; + FontChoice get applied => _applied; /// The theme's family; null keeps the platform typography. String? get family => _applied.family; - /// The chosen family's files are still downloading. + /// The fonts the user added on this device, in the order added. + List get customFonts => _library.fonts; + + /// The chosen family's files are still loading. bool get loading => _selected != _applied && _loadFailed != _selected; /// The last choice could not be stored on this device. bool get saveFailed => _saveFailed; /// The chosen family's files could not be loaded; the theme kept [applied]. - AppFont? get loadFailed => _loadFailed; + FontChoice? get loadFailed => _loadFailed; /// Whether [font]'s regular weight is registered, so its name can be drawn /// in its own face. - bool canPreview(AppFont font) => - font.previewAsset == null || _loadedAssets.contains(font.previewAsset); + bool canPreview(FontChoice font) => + font.previewSource == null || _loadedAssets.contains(font.previewSource); + + /// Reads the added fonts' index once. + Future loadCustomFonts() => _libraryLoad ??= () async { + await _library.load(); + notifyListeners(); + }(); /// Reads the stored choice and starts loading it. With [wait], returns once /// it is applied or after [wait], whichever is first; a slower load still /// applies when it finishes. Future restore({Duration? wait}) async { - final font = await _store.load(); + final id = await _store.load(); + if (id == null || id == AppFont.system.id) return; + final font = await _resolve(id); if (font == AppFont.system || font == _selected) return; _selected = font; notifyListeners(); @@ -86,13 +97,25 @@ class AppFontController extends ChangeNotifier { ]); } + Future _resolve(String id) async { + for (final font in AppFont.values) { + if (font.id == id) return font; + } + if (!id.startsWith(CustomFont.idPrefix)) return AppFont.system; + await loadCustomFonts(); + for (final font in customFonts) { + if (font.id == id) return font; + } + return AppFont.system; + } + /// Chooses [font], stores it, and applies it once its files are loaded. - Future select(AppFont font) async { + Future select(FontChoice font) async { if (font == _selected && _loadFailed != font) return; _selected = font; _loadFailed = null; notifyListeners(); - final saved = await _store.save(font); + final saved = await _store.save(font.id); if (saved == _saveFailed) { _saveFailed = !saved; notifyListeners(); @@ -102,25 +125,78 @@ class AppFontController extends ChangeNotifier { /// Loads [font]'s regular weight for its picker row. Failures are quiet: the /// row keeps the current face and choosing it reports the problem. - Future preview(AppFont font) async { - final asset = font.previewAsset; + Future preview(FontChoice font) async { + final source = font.previewSource; final family = font.family; - if (asset == null || family == null || _loadedAssets.contains(asset)) { + if (source == null || family == null || _loadedAssets.contains(source)) { return; } try { - await _ensure(family, [asset]); + await _ensure(family, [source]); } catch (_) { return; } notifyListeners(); } - Future _apply(AppFont font) async { + /// Checks picked files before they are named; see + /// [CustomFontDraft.inspect]. Throws [CustomFontRejected]. + Future inspect(List files) async { + await loadCustomFonts(); + return CustomFontDraft.inspect(files, storedBytes: _library.storedBytes); + } + + /// Registers [draft]'s files with the engine, and only if that works + /// stores them as [name] and chooses the new font. Throws + /// [CustomFontRejected]; a rejected font is never stored. + Future addCustom(CustomFontDraft draft, String name) async { + final problem = CustomFontLimits.nameProblem(name); + if (problem != null) throw CustomFontRejected(problem); + await loadCustomFonts(); + final font = _library.prepare(draft, name.trim()); + try { + await _bytesLoader(font.family, [ + for (final face in draft.faces) face.bytes, + ]); + } catch (_) { + throw const CustomFontRejected('This font could not be loaded.'); + } + await _library.store(font, draft); + for (final source in font.sources) { + _assetLoads[source] = Future.value(); + _loadedAssets.add(source); + } + notifyListeners(); + await select(font); + return font; + } + + /// Renames an added font; the choice and the theme keep it. + Future renameCustom(CustomFont font, String name) async { + final problem = CustomFontLimits.nameProblem(name); + if (problem != null) throw CustomFontRejected(problem); + final renamed = await _library.rename(font, name.trim()); + if (_selected == font) _selected = renamed; + if (_applied == font) _applied = renamed; + notifyListeners(); + } + + /// Deletes an added font. When it is chosen (or still shown), the device + /// returns to the system default. + Future removeCustom(CustomFont font) async { + await _library.remove(font); + if (_selected == font || _applied == font) { + _applied = AppFont.system; + await select(AppFont.system); + } + notifyListeners(); + } + + Future _apply(FontChoice font) async { final family = font.family; if (family != null) { try { - await _ensure(family, font.assets); + await _ensure(family, font.sources); } catch (_) { if (_selected == font) { _loadFailed = font; @@ -135,22 +211,22 @@ class AppFontController extends ChangeNotifier { notifyListeners(); } - /// Registers the assets not yet loaded or loading, in one [FontLoader], and - /// waits for all of [assets]. A failed asset can be retried. - Future _ensure(String family, List assets) { - final missing = assets.where((a) => !_assetLoads.containsKey(a)).toList(); + /// Registers the sources not yet loaded or loading, in one [FontLoader], + /// and waits for all of [sources]. A failed source can be retried. + Future _ensure(String family, List sources) { + final missing = sources.where((s) => !_assetLoads.containsKey(s)).toList(); if (missing.isNotEmpty) { final load = _loader(family, missing); - for (final asset in missing) { - _assetLoads[asset] = load.then( - (_) => _loadedAssets.add(asset), + for (final source in missing) { + _assetLoads[source] = load.then( + (_) => _loadedAssets.add(source), onError: (Object error, StackTrace stack) { - _assetLoads.remove(asset); + _assetLoads.remove(source); Error.throwWithStackTrace(error, stack); }, ); } } - return Future.wait(assets.map((a) => _assetLoads[a]!)); + return Future.wait(sources.map((s) => _assetLoads[s]!)); } } diff --git a/app/lib/ui/theme/app_font_loaders.dart b/app/lib/ui/theme/app_font_loaders.dart new file mode 100644 index 00000000..6d3cd615 --- /dev/null +++ b/app/lib/ui/theme/app_font_loaders.dart @@ -0,0 +1,43 @@ +import 'package:flutter/services.dart'; + +import 'font_choice.dart'; + +/// Registers [sources] under [family]. Production reads them from the bundle +/// or the custom font store; tests substitute a recorder. +typedef AppFontAssetLoader = + Future Function(String family, List sources); + +/// Registers font files already in memory under [family]; used to check an +/// added font before it is stored. +typedef AppFontBytesLoader = + Future Function(String family, List faces); + +/// Reads the bytes of an added face by its store key. +typedef CustomFontReader = Future Function(String key); + +/// Loads font files on demand with a [FontLoader]: bundle assets (on the web +/// each is fetched only now, when its family is first previewed or chosen) +/// and [customFontSource] keys, read through [readCustom]. +AppFontAssetLoader appFontSourceLoader(CustomFontReader readCustom) => + (family, sources) async { + final loader = FontLoader(family); + for (final source in sources) { + loader.addFont( + source.startsWith(customFontSourcePrefix) + ? readCustom( + source.substring(customFontSourcePrefix.length), + ).then(ByteData.sublistView) + : rootBundle.load(source), + ); + } + await loader.load(); + }; + +/// Registers in-memory font files with a [FontLoader]. +Future loadFontBytes(String family, List faces) async { + final loader = FontLoader(family); + for (final face in faces) { + loader.addFont(Future.value(ByteData.sublistView(face))); + } + await loader.load(); +} diff --git a/app/lib/ui/theme/app_font_store.dart b/app/lib/ui/theme/app_font_store.dart index 6a2ec375..6fe2ddb7 100644 --- a/app/lib/ui/theme/app_font_store.dart +++ b/app/lib/ui/theme/app_font_store.dart @@ -1,18 +1,18 @@ import 'package:shared_preferences/shared_preferences.dart'; -import 'app_font.dart'; - /// The device's font choice. It lives in this device's (or browser's) own /// preferences and is never sent to a server, so a phone and a browser signed /// in to the same server keep their own choice. const String appFontKey = 'pipelines.next.font.v1'; -/// The persistence seam for the font choice. +/// The persistence seam for the font choice: the chosen option's stable id +/// (a bundled `AppFont.id` or an added `CustomFont.id`). abstract interface class AppFontStore { - Future load(); + /// The stored id; null when nothing is stored or it cannot be read. + Future load(); /// Whether the choice is actually stored. - Future save(AppFont font); + Future save(String id); } /// `shared_preferences` storage. An unavailable or unreadable store means the @@ -21,20 +21,20 @@ class SharedPreferencesAppFontStore implements AppFontStore { const SharedPreferencesAppFontStore(); @override - Future load() async { + Future load() async { try { final preferences = await SharedPreferences.getInstance(); - return AppFont.fromId(preferences.getString(appFontKey)); + return preferences.getString(appFontKey); } catch (_) { - return AppFont.system; + return null; } } @override - Future save(AppFont font) async { + Future save(String id) async { try { final preferences = await SharedPreferences.getInstance(); - return await preferences.setString(appFontKey, font.id); + return await preferences.setString(appFontKey, id); } catch (_) { return false; } @@ -43,18 +43,18 @@ class SharedPreferencesAppFontStore implements AppFontStore { /// An in-memory store for tests and fixtures. class MemoryAppFontStore implements AppFontStore { - MemoryAppFontStore([this.font = AppFont.system]); + MemoryAppFontStore([this.id]); - AppFont font; + String? id; bool failSaves = false; @override - Future load() async => font; + Future load() async => id; @override - Future save(AppFont font) async { + Future save(String id) async { if (failSaves) return false; - this.font = font; + this.id = id; return true; } } diff --git a/app/lib/ui/theme/custom_fonts/custom_font.dart b/app/lib/ui/theme/custom_fonts/custom_font.dart new file mode 100644 index 00000000..57fb609d --- /dev/null +++ b/app/lib/ui/theme/custom_fonts/custom_font.dart @@ -0,0 +1,141 @@ +import '../font_choice.dart'; +import 'font_file_info.dart'; + +/// One file of a [CustomFont]: where its bytes are stored and the weight +/// and style it declares. +class CustomFontFace { + const CustomFontFace({ + required this.key, + required this.fileName, + required this.weight, + required this.italic, + required this.size, + }); + + /// The bytes' key in the custom font store. + final String key; + + /// The name the file had when it was added (shown, never used as a path). + final String fileName; + final int weight; + final bool italic; + final int size; + + String get styleName => fontStyleName(weight, italic: italic); + + Map toJson() => { + 'key': key, + 'file': fileName, + 'weight': weight, + 'italic': italic, + 'size': size, + }; + + static CustomFontFace? fromJson(Object? json) { + if (json is! Map) return null; + final key = json['key']; + final file = json['file']; + final weight = json['weight']; + final italic = json['italic']; + final size = json['size']; + if (key is! String || key.isEmpty || file is! String) return null; + if (weight is! int || italic is! bool || size is! int) return null; + return CustomFontFace( + key: key, + fileName: file, + weight: weight, + italic: italic, + size: size, + ); + } +} + +/// A family the user added from their own font files. Its registered +/// [family] is derived from the stable [id], so a rename changes only the +/// [label] and never re-registers the files. +class CustomFont implements FontChoice { + const CustomFont({required this.id, required this.name, required this.faces}); + + static const String idPrefix = 'custom-'; + + @override + final String id; + + /// The user's name for the family. + final String name; + + /// At least one face, in the order they were added. + final List faces; + + @override + String get label => name; + + @override + String get family => 'Pipelines $id'; + + @override + List get sources => [ + for (final face in faces) customFontSource(face.key), + ]; + + /// The upright face nearest to 400, else the face nearest to 400. + @override + String? get previewSource { + CustomFontFace? best; + int score(CustomFontFace face) => + (face.weight - 400).abs() + (face.italic ? 2000 : 0); + for (final face in faces) { + if (best == null || score(face) < score(best)) best = face; + } + return best == null ? null : customFontSource(best.key); + } + + /// The styles it has, lightest first: "Regular, Bold". + String get styles { + final sorted = [...faces] + ..sort( + (a, b) => a.weight != b.weight + ? a.weight.compareTo(b.weight) + : (a.italic ? 1 : 0).compareTo(b.italic ? 1 : 0), + ); + return sorted.map((face) => face.styleName).join(', '); + } + + int get size => faces.fold(0, (total, face) => total + face.size); + + CustomFont renamed(String name) => + CustomFont(id: id, name: name, faces: faces); + + Map toJson() => { + 'id': id, + 'name': name, + 'faces': [for (final face in faces) face.toJson()], + }; + + /// A stored entry, or null when it is not one this version can use. + static CustomFont? fromJson(Object? json) { + if (json is! Map) return null; + final id = json['id']; + final name = json['name']; + final faces = json['faces']; + if (id is! String || !id.startsWith(idPrefix) || name is! String) { + return null; + } + if (faces is! List) return null; + final parsed = []; + for (final face in faces) { + final value = CustomFontFace.fromJson(face); + if (value == null) return null; + parsed.add(value); + } + if (parsed.isEmpty || name.trim().isEmpty) return null; + return CustomFont(id: id, name: name, faces: parsed); + } + + /// The same option whatever its current name. + @override + bool operator ==(Object other) => other is CustomFont && other.id == id; + + @override + int get hashCode => id.hashCode; +} diff --git a/app/lib/ui/theme/custom_fonts/custom_font_draft.dart b/app/lib/ui/theme/custom_fonts/custom_font_draft.dart new file mode 100644 index 00000000..4cf55a07 --- /dev/null +++ b/app/lib/ui/theme/custom_fonts/custom_font_draft.dart @@ -0,0 +1,144 @@ +import 'dart:typed_data'; + +import 'font_file_info.dart'; + +/// One file the user picked, with the bytes the picker read. +class PickedFontFile { + const PickedFontFile({required this.name, required this.bytes}); + + final String name; + final Uint8List bytes; +} + +/// Why picked files cannot be added; [message] is shown as is. +class CustomFontRejected implements Exception { + const CustomFontRejected(this.message); + + final String message; + + @override + String toString() => message; +} + +/// The limits that keep added fonts within what a device and a browser's +/// storage hold comfortably. +abstract final class CustomFontLimits { + static const int maxFileBytes = 10 * 1024 * 1024; + static const int maxTotalBytes = 40 * 1024 * 1024; + static const int maxFilesPerFamily = 16; + static const int maxNameLength = 64; + static const List extensions = ['ttf', 'otf']; + + /// Why [name] cannot name a font, or null when it can. + static String? nameProblem(String name) { + final trimmed = name.trim(); + if (trimmed.isEmpty) return 'Enter a name.'; + if (trimmed.length > maxNameLength) { + return 'Use at most $maxNameLength characters.'; + } + return null; + } +} + +/// A face that passed inspection but is not stored yet. +class DraftFontFace { + const DraftFontFace({ + required this.fileName, + required this.bytes, + required this.info, + }); + + final String fileName; + final Uint8List bytes; + final FontFileInfo info; + + String get styleName => fontStyleName(info.weight, italic: info.italic); +} + +/// Picked files grouped into one family, ready for the user to name. +class CustomFontDraft { + const CustomFontDraft({required this.suggestedName, required this.faces}); + + /// The family the files name most often, else the first file's name + /// without its extension. + final String suggestedName; + final List faces; + + int get size => faces.fold(0, (total, face) => total + face.bytes.length); + + /// Checks [files] and reads their names and weights. [storedBytes] is what + /// added fonts already occupy. Throws [CustomFontRejected] naming the + /// first problem; nothing is stored either way. + static CustomFontDraft inspect( + List files, { + int storedBytes = 0, + }) { + if (files.isEmpty) throw const CustomFontRejected('No font file chosen.'); + if (files.length > CustomFontLimits.maxFilesPerFamily) { + throw const CustomFontRejected( + 'Choose at most ${CustomFontLimits.maxFilesPerFamily} files at once.', + ); + } + final faces = []; + for (final file in files) { + final name = file.name; + final dot = name.lastIndexOf('.'); + final extension = dot < 0 ? '' : name.substring(dot + 1).toLowerCase(); + if (!CustomFontLimits.extensions.contains(extension)) { + throw CustomFontRejected('“$name” is not a .ttf or .otf font file.'); + } + if (file.bytes.length > CustomFontLimits.maxFileBytes) { + throw CustomFontRejected( + '“$name” is larger than ${_mb(CustomFontLimits.maxFileBytes)}.', + ); + } + final FontFileInfo info; + try { + info = FontFileInfo.parse(file.bytes); + } on FormatException catch (error) { + throw CustomFontRejected('“$name” cannot be used: ${error.message}'); + } + final face = DraftFontFace(fileName: name, bytes: file.bytes, info: info); + final twin = faces.where( + (f) => f.info.weight == info.weight && f.info.italic == info.italic, + ); + if (twin.isNotEmpty) { + throw CustomFontRejected( + '“${twin.first.fileName}” and “$name” are both ${face.styleName}; ' + 'add them as separate fonts.', + ); + } + faces.add(face); + } + final draft = CustomFontDraft( + suggestedName: _suggestName(faces), + faces: faces, + ); + if (storedBytes + draft.size > CustomFontLimits.maxTotalBytes) { + throw CustomFontRejected( + 'Added fonts can use up to ${_mb(CustomFontLimits.maxTotalBytes)} ' + 'on this device; remove one first.', + ); + } + return draft; + } + + static String _suggestName(List faces) { + final counts = {}; + for (final face in faces) { + final family = face.info.family; + if (family != null) counts[family] = (counts[family] ?? 0) + 1; + } + if (counts.isNotEmpty) { + return counts.entries.reduce((a, b) => b.value > a.value ? b : a).key; + } + final name = faces.first.fileName; + final dot = name.lastIndexOf('.'); + final stem = (dot > 0 ? name.substring(0, dot) : name).trim(); + return stem.length > CustomFontLimits.maxNameLength + ? stem.substring(0, CustomFontLimits.maxNameLength) + : stem; + } + + static String _mb(int bytes) => '${bytes ~/ (1024 * 1024)} MB'; +} diff --git a/app/lib/ui/theme/custom_fonts/custom_font_library.dart b/app/lib/ui/theme/custom_fonts/custom_font_library.dart new file mode 100644 index 00000000..870d5d5e --- /dev/null +++ b/app/lib/ui/theme/custom_fonts/custom_font_library.dart @@ -0,0 +1,148 @@ +import 'dart:convert'; +import 'dart:typed_data'; + +import 'package:shared_preferences/shared_preferences.dart'; + +import 'custom_font.dart'; +import 'custom_font_draft.dart'; +import 'font_bytes_store.dart'; + +/// The index of added fonts, in this device's preferences beside the font +/// choice. It is small (names, weights, keys); the bytes live in a +/// [FontBytesStore]. +const String customFontsKey = 'pipelines.next.custom-fonts.v1'; + +/// The fonts the user added on this device: an index in preferences and +/// the files' bytes in [FontBytesStore]. +/// +/// Bytes are written before the index names them and the index drops an +/// entry before its bytes are deleted, so the index never names a file that +/// was not completely stored. +class CustomFontLibrary { + CustomFontLibrary({FontBytesStore? bytes, DateTime Function()? clock}) + : _bytesStore = bytes, + _clock = clock ?? DateTime.now; + + FontBytesStore? _bytesStore; + final DateTime Function() _clock; + List _fonts = const []; + + FontBytesStore get _bytes => _bytesStore ??= hostFontBytesStore(); + + /// The added fonts, in the order they were added. + List get fonts => _fonts; + + /// What the added fonts occupy, for [CustomFontDraft.inspect]. + int get storedBytes => _fonts.fold(0, (total, font) => total + font.size); + + /// Reads the index. An unreadable index or entry is skipped, not fatal. + Future> load() async { + try { + final preferences = await SharedPreferences.getInstance(); + final raw = preferences.getString(customFontsKey); + final decoded = raw == null ? null : jsonDecode(raw); + _fonts = [ + if (decoded is List) + for (final entry in decoded) ?CustomFont.fromJson(entry), + ]; + } catch (_) { + _fonts = const []; + } + return _fonts; + } + + /// The bytes of the face stored under [key]. + Future read(String key) => _bytes.read(key); + + /// The entry [draft] would become under [name], with a fresh id and keys; + /// nothing is stored until [store]. + CustomFont prepare(CustomFontDraft draft, String name) { + final id = _newId(); + return CustomFont( + id: id, + name: name, + faces: [ + for (final (index, face) in draft.faces.indexed) + CustomFontFace( + key: '$id-$index', + fileName: face.fileName, + weight: face.info.weight, + italic: face.info.italic, + size: face.bytes.length, + ), + ], + ); + } + + /// Stores [font] (from [prepare]) with [draft]'s bytes. Throws + /// [CustomFontRejected] when the files or the index cannot be stored; + /// nothing is left behind. + Future store(CustomFont font, CustomFontDraft draft) async { + final written = []; + try { + for (final (index, face) in font.faces.indexed) { + await _bytes.write(face.key, draft.faces[index].bytes); + written.add(face.key); + } + await _saveIndex([..._fonts, font]); + return font; + } catch (error) { + for (final key in written) { + await _quietly(() => _bytes.delete(key)); + } + if (error is CustomFontRejected) rethrow; + throw const CustomFontRejected( + 'The font could not be stored on this device.', + ); + } + } + + /// Renames [font]; returns the renamed entry. + Future rename(CustomFont font, String name) async { + final renamed = font.renamed(name); + await _saveIndex([ + for (final f in _fonts) f == font ? renamed : f, + ]); + return renamed; + } + + /// Forgets [font] and deletes its files. + Future remove(CustomFont font) async { + await _saveIndex([ + for (final f in _fonts) + if (f != font) f, + ]); + for (final face in font.faces) { + await _quietly(() => _bytes.delete(face.key)); + } + } + + Future _saveIndex(List fonts) async { + final preferences = await SharedPreferences.getInstance(); + final saved = await preferences.setString( + customFontsKey, + jsonEncode([for (final font in fonts) font.toJson()]), + ); + if (!saved) { + throw const CustomFontRejected( + 'The font list could not be saved on this device.', + ); + } + _fonts = List.unmodifiable(fonts); + } + + String _newId() { + var stamp = _clock().microsecondsSinceEpoch; + String id() => '${CustomFont.idPrefix}${stamp.toRadixString(36)}'; + while (_fonts.any((font) => font.id == id())) { + stamp += 1; + } + return id(); + } + + static Future _quietly(Future Function() action) async { + try { + await action(); + } catch (_) {} + } +} diff --git a/app/lib/ui/theme/custom_fonts/font_bytes_store.dart b/app/lib/ui/theme/custom_fonts/font_bytes_store.dart new file mode 100644 index 00000000..b99a64a2 --- /dev/null +++ b/app/lib/ui/theme/custom_fonts/font_bytes_store.dart @@ -0,0 +1,45 @@ +import 'dart:typed_data'; + +import 'font_bytes_store_stub.dart' + if (dart.library.js_interop) 'font_bytes_store_web.dart' + if (dart.library.io) 'font_bytes_store_io.dart' + as platform; + +/// Where the bytes of user-added font files live on this device. The index +/// that names them is kept separately (`CustomFontLibrary`). +/// +/// Native hosts keep one file per face in the app's support directory; the +/// web keeps them in IndexedDB, because `localStorage` (where +/// `shared_preferences` stores everything on the web) holds only about +/// 5 MB of UTF-16 text per origin, shared with every other preference. +abstract interface class FontBytesStore { + Future write(String key, Uint8List bytes); + + /// The stored bytes; throws when [key] is missing or unreadable. + Future read(String key); + + /// Removes [key]; a missing key is not an error. + Future delete(String key); +} + +/// The running host's store. +FontBytesStore hostFontBytesStore() => platform.hostFontBytesStore(); + +/// An in-memory store for tests and fixtures. +class MemoryFontBytesStore implements FontBytesStore { + final Map files = {}; + bool failWrites = false; + + @override + Future write(String key, Uint8List bytes) async { + if (failWrites) throw StateError('write refused'); + files[key] = Uint8List.fromList(bytes); + } + + @override + Future read(String key) async => + files[key] ?? (throw StateError('no stored font $key')); + + @override + Future delete(String key) async => files.remove(key); +} diff --git a/app/lib/ui/theme/custom_fonts/font_bytes_store_io.dart b/app/lib/ui/theme/custom_fonts/font_bytes_store_io.dart new file mode 100644 index 00000000..624efce8 --- /dev/null +++ b/app/lib/ui/theme/custom_fonts/font_bytes_store_io.dart @@ -0,0 +1,50 @@ +import 'dart:io'; +import 'dart:typed_data'; + +import 'package:path_provider/path_provider.dart'; + +import 'font_bytes_store.dart'; + +FontBytesStore hostFontBytesStore() => DirectoryFontBytesStore( + () async => Directory( + '${(await getApplicationSupportDirectory()).path}' + '${Platform.pathSeparator}custom-fonts', + ), +); + +/// One file per key in a private directory. The app support directory is +/// used rather than Documents: it is not shown in the iOS Files app and is +/// removed with the app. +class DirectoryFontBytesStore implements FontBytesStore { + DirectoryFontBytesStore(this._directory); + + final Future Function() _directory; + + static final RegExp _safeKey = RegExp(r'^[A-Za-z0-9_-]+$'); + + Future _file(String key) async { + // Keys are generated by the library; refuse anything path-like. + if (!_safeKey.hasMatch(key)) throw ArgumentError.value(key, 'key'); + final directory = await _directory(); + return File('${directory.path}${Platform.pathSeparator}$key'); + } + + @override + Future write(String key, Uint8List bytes) async { + final file = await _file(key); + await file.parent.create(recursive: true); + // Write beside, then rename, so a failed write never leaves half a file. + final partial = File('${file.path}.partial'); + await partial.writeAsBytes(bytes, flush: true); + await partial.rename(file.path); + } + + @override + Future read(String key) async => (await _file(key)).readAsBytes(); + + @override + Future delete(String key) async { + final file = await _file(key); + if (await file.exists()) await file.delete(); + } +} diff --git a/app/lib/ui/theme/custom_fonts/font_bytes_store_stub.dart b/app/lib/ui/theme/custom_fonts/font_bytes_store_stub.dart new file mode 100644 index 00000000..6143e1d9 --- /dev/null +++ b/app/lib/ui/theme/custom_fonts/font_bytes_store_stub.dart @@ -0,0 +1,5 @@ +import 'font_bytes_store.dart'; + +/// A host with neither files nor IndexedDB cannot keep added fonts. +FontBytesStore hostFontBytesStore() => + throw UnsupportedError('Added fonts need file or IndexedDB storage.'); diff --git a/app/lib/ui/theme/custom_fonts/font_bytes_store_web.dart b/app/lib/ui/theme/custom_fonts/font_bytes_store_web.dart new file mode 100644 index 00000000..92fc945f --- /dev/null +++ b/app/lib/ui/theme/custom_fonts/font_bytes_store_web.dart @@ -0,0 +1,105 @@ +import 'dart:async'; +import 'dart:js_interop'; +import 'dart:typed_data'; + +import 'package:web/web.dart' as web; + +import 'font_bytes_store.dart'; + +FontBytesStore hostFontBytesStore() => IndexedDbFontBytesStore(); + +/// Font bytes in this origin's IndexedDB, one record per key. +/// +/// IndexedDB stores binary values directly (no base64) and its quota is a +/// share of the disk, not localStorage's ~5 MB; it also works on a plain +/// `http://` LAN address, where Cache Storage is unavailable. Each write +/// asks the browser to keep the origin's storage persistent, so a browser +/// under disk pressure does not evict the fonts silently; if it still does, +/// the font fails to load and the picker says so. +class IndexedDbFontBytesStore implements FontBytesStore { + IndexedDbFontBytesStore({this.database = 'pipelines-custom-fonts'}); + + final String database; + static const String _store = 'fonts'; + + Future? _opening; + + Future _open() => _opening ??= () { + final request = web.window.indexedDB.open(database, 1); + request.onupgradeneeded = ((web.Event _) { + final db = request.result! as web.IDBDatabase; + if (!db.objectStoreNames.contains(_store)) db.createObjectStore(_store); + }).toJS; + return _settle(request).catchError((Object error) { + _opening = null; + throw error; + }); + }(); + + Future _settle(web.IDBRequest request) { + final done = Completer(); + request.onsuccess = ((web.Event _) => done.complete( + request.result as T, + )).toJS; + request.onerror = ((web.Event _) => done.completeError( + StateError(request.error?.message ?? 'IndexedDB request failed'), + )).toJS; + return done.future; + } + + Future _commit(web.IDBTransaction transaction) { + final done = Completer(); + transaction.oncomplete = ((web.Event _) => done.complete()).toJS; + void fail(web.Event _) { + if (done.isCompleted) return; + done.completeError( + StateError(transaction.error?.message ?? 'IndexedDB write failed'), + ); + } + + transaction.onerror = fail.toJS; + transaction.onabort = fail.toJS; + return done.future; + } + + @override + Future write(String key, Uint8List bytes) async { + final db = await _open(); + final transaction = db.transaction(_store.toJS, 'readwrite'); + final committed = _commit(transaction); + transaction.objectStore(_store).put(bytes.toJS, key.toJS); + await committed; + unawaited(_persist()); + } + + @override + Future read(String key) async { + final db = await _open(); + final request = db + .transaction(_store.toJS, 'readonly') + .objectStore(_store) + .get(key.toJS); + final value = await _settle(request); + if (value == null || !value.isA()) { + throw StateError('No stored font $key'); + } + return (value as JSUint8Array).toDart; + } + + @override + Future delete(String key) async { + final db = await _open(); + final transaction = db.transaction(_store.toJS, 'readwrite'); + final committed = _commit(transaction); + transaction.objectStore(_store).delete(key.toJS); + await committed; + } + + /// Best effort: some browsers grant it silently, others only for + /// installed or bookmarked sites. A refusal changes nothing. + Future _persist() async { + try { + await web.window.navigator.storage.persist().toDart; + } catch (_) {} + } +} diff --git a/app/lib/ui/theme/custom_fonts/font_file_info.dart b/app/lib/ui/theme/custom_fonts/font_file_info.dart new file mode 100644 index 00000000..9bdb4f89 --- /dev/null +++ b/app/lib/ui/theme/custom_fonts/font_file_info.dart @@ -0,0 +1,183 @@ +import 'dart:typed_data'; + +/// What a TrueType or OpenType file says about itself: enough to name the +/// family it belongs to and to tell its weights apart. +/// +/// [FontFileInfo.parse] is a small, bounded reader of the sfnt table +/// directory, the `name` table and the `OS/2` table. Every offset is checked +/// against the file before it is read, so a damaged or hostile file fails +/// with a [FormatException], never a range error or a long loop. +class FontFileInfo { + const FontFileInfo({ + required this.family, + required this.subfamily, + required this.weight, + required this.italic, + }); + + /// The typographic family (name ID 16), else the legacy family (ID 1); + /// null when the file names neither readably. + final String? family; + + /// The style name (ID 17, else ID 2), e.g. "Bold Italic"; may be null. + final String? subfamily; + + /// `OS/2.usWeightClass` (1–1000), 400 when the table is absent or odd. + final int weight; + + /// `OS/2.fsSelection` bit 0, else a subfamily naming italic or oblique. + final bool italic; + + static const int _maxTables = 512; + static const int _maxNameRecords = 4096; + static const int _maxNameLength = 64; + + /// Reads [bytes]. Throws [FormatException] with a user-facing message + /// when they are not a single TrueType/OpenType font. + static FontFileInfo parse(Uint8List bytes) { + final data = ByteData.sublistView(bytes); + if (bytes.length < 12) { + throw const FormatException('The file is too short.'); + } + final version = data.getUint32(0); + switch (version) { + case 0x00010000 || 0x4F54544F || 0x74727565: // 1.0, 'OTTO', 'true' + break; + case 0x74746366: // 'ttcf' + throw const FormatException( + 'Font collections (.ttc) are not supported; add single fonts.', + ); + case 0x774F4646 || 0x774F4632: // 'wOFF', 'wOF2' + throw const FormatException('WOFF web fonts are not supported.'); + default: + throw const FormatException('Not a TrueType or OpenType font.'); + } + final count = data.getUint16(4); + if (count == 0 || count > _maxTables || 12 + count * 16 > bytes.length) { + throw const FormatException('The font table directory is damaged.'); + } + final tables = {}; + for (var i = 0; i < count; i++) { + final record = 12 + i * 16; + final tag = String.fromCharCodes(bytes, record, record + 4); + final offset = data.getUint32(record + 8); + final length = data.getUint32(record + 12); + if (offset + length > bytes.length) { + throw const FormatException('A font table lies outside the file.'); + } + tables[tag] = (offset, length); + } + final outlines = + (tables.containsKey('glyf') && tables.containsKey('loca')) || + tables.containsKey('CFF ') || + tables.containsKey('CFF2'); + if (!tables.containsKey('cmap') || + !tables.containsKey('head') || + !outlines) { + throw const FormatException('The font is missing required tables.'); + } + final names = _names(data, tables['name']); + final subfamily = names[17] ?? names[2]; + final os2 = tables['OS/2']; + var weight = 400; + bool? italic; + if (os2 != null && os2.$2 >= 6) { + final value = data.getUint16(os2.$1 + 4); + if (value >= 1 && value <= 1000) weight = value; + if (os2.$2 >= 64) italic = data.getUint16(os2.$1 + 62) & 1 == 1; + } + italic ??= RegExp( + 'italic|oblique', + caseSensitive: false, + ).hasMatch(subfamily ?? ''); + return FontFileInfo( + family: names[16] ?? names[1], + subfamily: subfamily, + weight: weight, + italic: italic, + ); + } + + /// Name IDs 1, 2, 16 and 17, each from the best record: Windows English, + /// then any Windows, then Unicode, then Mac Roman. + static Map _names(ByteData data, (int, int)? table) { + final found = {}; + if (table == null || table.$2 < 6) return const {}; + final (start, length) = table; + final end = start + length; + final count = data.getUint16(start + 2); + final strings = start + data.getUint16(start + 4); + if (count > _maxNameRecords || start + 6 + count * 12 > end) { + return const {}; + } + for (var i = 0; i < count; i++) { + final record = start + 6 + i * 12; + final platform = data.getUint16(record); + final encoding = data.getUint16(record + 2); + final language = data.getUint16(record + 4); + final id = data.getUint16(record + 6); + if (id != 1 && id != 2 && id != 16 && id != 17) continue; + final rank = switch (platform) { + 3 when encoding == 1 || encoding == 10 => language == 0x409 ? 4 : 3, + 0 => 2, + 1 when encoding == 0 && language == 0 => 1, + _ => 0, + }; + if (rank == 0 || (found[id]?.$1 ?? 0) >= rank) continue; + final size = data.getUint16(record + 8); + final offset = strings + data.getUint16(record + 10); + if (offset + size > end || size > _maxNameLength * 4) continue; + final text = _clean( + platform == 1 + ? _macRoman(data, offset, size) + : _utf16(data, offset, size), + ); + if (text.isNotEmpty) found[id] = (rank, text); + } + return { + for (final entry in found.entries) entry.key: entry.value.$2, + }; + } + + static String _utf16(ByteData data, int offset, int size) => + String.fromCharCodes([ + for (var i = 0; i + 1 < size; i += 2) data.getUint16(offset + i), + ]); + + /// ASCII from Mac Roman; the rare accented byte becomes a space. + static String _macRoman(ByteData data, int offset, int size) => + String.fromCharCodes([ + for (var i = 0; i < size; i++) + data.getUint8(offset + i) < 0x80 ? data.getUint8(offset + i) : 0x20, + ]); + + /// Drops control characters, collapses runs of space and caps the length. + static String _clean(String raw) { + final text = raw + .replaceAll(RegExp(r'[\x00-\x1F\x7F�]'), '') + .replaceAll(RegExp(r'\s+'), ' ') + .trim(); + return text.length > _maxNameLength + ? text.substring(0, _maxNameLength).trim() + : text; + } +} + +/// The conventional name of an OpenType weight class, plus "Italic". +String fontStyleName(int weight, {bool italic = false}) { + const names = [ + 'Thin', + 'ExtraLight', + 'Light', + 'Regular', + 'Medium', + 'SemiBold', + 'Bold', + 'ExtraBold', + 'Black', + ]; + final index = ((weight.clamp(100, 900) + 50) ~/ 100) - 1; + final name = names[index.clamp(0, names.length - 1)]; + if (!italic) return name; + return name == 'Regular' ? 'Italic' : '$name Italic'; +} diff --git a/app/lib/ui/theme/custom_fonts/font_file_picker.dart b/app/lib/ui/theme/custom_fonts/font_file_picker.dart new file mode 100644 index 00000000..85db4c6b --- /dev/null +++ b/app/lib/ui/theme/custom_fonts/font_file_picker.dart @@ -0,0 +1,34 @@ +import 'package:file_picker/file_picker.dart'; +import 'package:flutter/foundation.dart'; + +import 'custom_font_draft.dart'; + +/// Opens the host's file picker for font files; null when the user cancels. +/// Throws [CustomFontRejected] for a file too large to read. +typedef FontFilePicker = Future?> Function(); + +/// The host picker through `file_picker`. The web and Apple pickers filter +/// to .ttf/.otf; Android's document picker filters by MIME type, which many +/// providers do not report for fonts, so there every file is offered and +/// [CustomFontDraft.inspect] rejects the rest by name. +Future?> pickFontFiles() async { + final android = !kIsWeb && defaultTargetPlatform == TargetPlatform.android; + final picked = await FilePicker.pickFiles( + type: android ? FileType.any : FileType.custom, + allowedExtensions: android ? null : CustomFontLimits.extensions, + ); + if (picked.isEmpty) return null; + final files = []; + for (final file in picked) { + final length = file.lengthSync() ?? await file.length(); + if (length != null && length > CustomFontLimits.maxFileBytes) { + // Refuse before reading a huge file into memory. + throw CustomFontRejected( + '“${file.name}” is larger than ' + '${CustomFontLimits.maxFileBytes ~/ (1024 * 1024)} MB.', + ); + } + files.add(PickedFontFile(name: file.name, bytes: await file.readAsBytes())); + } + return files; +} diff --git a/app/lib/ui/theme/font_choice.dart b/app/lib/ui/theme/font_choice.dart new file mode 100644 index 00000000..886da7f5 --- /dev/null +++ b/app/lib/ui/theme/font_choice.dart @@ -0,0 +1,25 @@ +/// One interface font option the device can choose: a bundled family +/// (`AppFont`) or one the user added (`CustomFont`). +abstract interface class FontChoice { + /// The stored value; stable across releases and renames. + String get id; + + /// The picker's name for the option. + String get label; + + /// The registered family name; null keeps the platform typography. + String? get family; + + /// Every file the family needs, as loader sources: bundle asset paths, or + /// [customFontSource] keys for files the user added. + List get sources; + + /// The one source that previews the option's name (its regular weight). + String? get previewSource; +} + +/// Loader sources naming a user-added file start with this prefix; the rest +/// is the file's key in the custom font store. +const String customFontSourcePrefix = 'custom-font:'; + +String customFontSource(String key) => '$customFontSourcePrefix$key'; diff --git a/app/notes/interface-font-choice.md b/app/notes/interface-font-choice.md index 3ab07c94..917c57fd 100644 --- a/app/notes/interface-font-choice.md +++ b/app/notes/interface-font-choice.md @@ -42,3 +42,79 @@ same compressed amount (not measured). RobotoMono; they now follow the chosen font too. - On the web Cupertino fixture, "System default" names an unregistered `CupertinoSystemText` family, which the browser engine substitutes. + +## Fonts the user adds + +Settings > Font ends with **Add font…**. It opens the host picker +(`file_picker`; .ttf/.otf filter on the web and Apple hosts, every file on +Android, whose document picker filters by MIME type), then: + +1. `CustomFontDraft.inspect` refuses other extensions, files over 10 MB, + more than 16 files at once, two files of the same weight and style, and a + total over 40 MB of added fonts. Each file is read by + `custom_fonts/font_file_info.dart`, a bounded pure-Dart sfnt reader: it + rejects TTC collections, WOFF, damaged table directories and fonts + without `cmap`/`head`/outlines, reads the family from the `name` table + (ID 16, else ID 1; Windows English first) and the weight from + `OS/2.usWeightClass` (400 when absent) plus the italic bit. +2. A name dialog is prefilled from the font's family (else the file name) + and lists each file's style; the user can rename it there or later. +3. `AppFontController.addCustom` registers the bytes with a `FontLoader` + under the new family first; only if that succeeds are the bytes and the + index stored, and the font is chosen. A failure stores nothing. (The + engine ignores undecodable bytes rather than throwing, so the structural + check in step 1 is the real gate; the loader catches the rest.) + +Rows for added fonts sit below the bundled ones, named in their own face, +with their styles ("Regular, Bold") and an options button (Rename, Remove) +beside the row, outside the tile's merged semantics. Remove asks first and +deletes the files; if the font was chosen, the device returns to System +default. The engine keeps a removed family registered until the next start, +but nothing uses it. + +The choice key is unchanged (`pipelines.next.font.v1` now holds either a +bundled id or `custom-`). A stored added font loads at startup within +the same bounded wait; missing bytes keep the system face and the picker +says "Could not load this font." + +### Storage + +- Index: `shared_preferences` key `pipelines.next.custom-fonts.v1`, JSON of + names, weights and byte keys (a few hundred bytes per font). +- Native bytes: one file per face under the app support directory + (`custom-fonts/`), written to a `.partial` file and renamed. Support, + not Documents: it is private (not in the iOS Files app) and leaves with + the app. +- Web bytes: IndexedDB database `pipelines-custom-fonts` via `package:web`. + `localStorage` (which `shared_preferences` uses on the web) was rejected: + browsers cap it at about 5 MB of UTF-16 text per origin, shared with every + other preference, and base64 inflates a four-weight family to 1–2 MB, so a + 15 MB cap could never be honoured and an overflow would break other + settings. Cache Storage needs a secure context, which a plain `http://` + LAN address is not. IndexedDB stores binary values directly with a + disk-sized quota; each write asks `navigator.storage.persist()` so the + browser keeps the fonts under disk pressure (best effort). +- Bytes are written before the index names them, and the index forgets a + font before its bytes are deleted, so the index never names a partial + font. + +### Evidence + +Tests: `test/ui/theme/custom_fonts/` (parser on the bundled fonts and +damaged/hostile inputs; draft limits; library round trip with an in-memory +byte store; native directory store on a temp dir; controller add, reject, +rename, remove, restore, missing bytes, real `FontLoader`) and +`test/features/settings/settings_custom_font_test.dart` (Material and +Cupertino add/rename/remove, invalid file, cancel). The IndexedDB store has +no VM test (it needs a browser); the browser run below covers it. + +Browser (`tool/capture/`, new `files=` step answering the file chooser): +the fixture app at 880x1400, Material and Cupertino, adding the bundled +Atkinson Hyperlegible Next Regular and Bold as a user font named +"My Atkinson". Shots: the name dialog prefilled "Atkinson Hyperlegible +Next" with both styles; the added row chosen and the app redrawn in it; the +same after a page reload (restored from IndexedDB); run 7 in the added +face; the options menu and action sheet; rename to "Body face"; the remove +confirmation; the fallback to System default; and a fake `.ttf` refused +with "“fake.ttf” cannot be used: The file is too short." Android and iOS +were not run on a device. diff --git a/app/test/features/settings/settings_custom_font_test.dart b/app/test/features/settings/settings_custom_font_test.dart new file mode 100644 index 00000000..4b2ac360 --- /dev/null +++ b/app/test/features/settings/settings_custom_font_test.dart @@ -0,0 +1,201 @@ +import 'dart:convert'; +import 'dart:io'; + +import 'package:flutter/cupertino.dart'; +import 'package:flutter/material.dart'; +import 'package:flutter_test/flutter_test.dart'; +import 'package:pipelines_app/features/settings/settings_custom_font_actions.dart'; +import 'package:pipelines_app/features/settings/settings_custom_font_dialogs.dart'; +import 'package:pipelines_app/features/settings/settings_font_section.dart'; +import 'package:pipelines_app/ui/theme/app_font.dart'; +import 'package:pipelines_app/ui/theme/app_font_controller.dart'; +import 'package:pipelines_app/ui/theme/app_font_store.dart'; +import 'package:pipelines_app/ui/theme/custom_fonts/custom_font.dart'; +import 'package:pipelines_app/ui/theme/custom_fonts/custom_font_draft.dart'; +import 'package:pipelines_app/ui/theme/custom_fonts/custom_font_library.dart'; +import 'package:pipelines_app/ui/theme/custom_fonts/font_bytes_store.dart'; +import 'package:shared_preferences/shared_preferences.dart'; + +PickedFontFile _pick(String path) => PickedFontFile( + name: path.split('/').last, + bytes: File(path).readAsBytesSync(), +); + +class _Harness { + final store = MemoryAppFontStore(); + final bytes = MemoryFontBytesStore(); + List? next; + + late final fonts = AppFontController( + store: store, + library: CustomFontLibrary(bytes: bytes), + loader: (family, sources) async {}, + bytesLoader: (family, faces) async {}, + ); + + Future?> pick() async => next; +} + +Future _pump( + WidgetTester tester, + _Harness harness, { + bool cupertino = false, +}) async { + final section = SingleChildScrollView( + child: SettingsFontSection( + controller: harness.fonts, + pickFiles: harness.pick, + ), + ); + await tester.pumpWidget( + cupertino + ? CupertinoApp(home: CupertinoPageScaffold(child: section)) + : MaterialApp(home: Scaffold(body: section)), + ); + await tester.pumpAndSettle(); +} + +void main() { + setUp(() => SharedPreferences.setMockInitialValues({})); + + final regular = _pick('fonts/inter/Inter-Regular.ttf'); + final bold = _pick('fonts/inter/Inter-Bold.ttf'); + + testWidgets('Material: add, name, rename and remove an added font', ( + tester, + ) async { + final harness = _Harness()..next = [regular, bold]; + await _pump(tester, harness); + + await tester.tap(find.text(addCustomFontText)); + await tester.pumpAndSettle(); + // The family name comes from the font; the files are listed. + expect(find.text(addCustomFontTitle), findsOneWidget); + expect( + find.text('Regular · Inter-Regular.ttf\nBold · Inter-Bold.ttf'), + findsOneWidget, + ); + final field = find.byType(TextField); + expect(tester.widget(field).controller!.text, 'Inter'); + await tester.enterText(field, 'My Inter'); + await tester.tap(find.text('Add')); + await tester.pumpAndSettle(); + + final font = harness.fonts.customFonts.single; + expect(font.name, 'My Inter'); + expect(harness.store.id, font.id, reason: 'a new font is chosen'); + final row = find.byKey(settingsFontKey(font)); + expect(row, findsOneWidget); + // Below the bundled options, named in its own face. + expect( + tester.getTopLeft(row).dy, + greaterThan( + tester.getTopLeft(find.byKey(settingsFontKey(AppFont.values.last))).dy, + ), + ); + final name = tester.widget( + find.descendant(of: row, matching: find.text('My Inter')), + ); + expect(name.style?.fontFamily, font.family); + expect( + find.descendant(of: row, matching: find.text('Regular, Bold')), + findsOneWidget, + ); + + // Its own control, not merged into the radio tile. + final options = tester.getSemantics( + find.byTooltip(customFontActionsTooltip), + ); + expect(options.tooltip, customFontActionsTooltip); + expect(options.label, isNot(contains('My Inter'))); + expect(find.bySemanticsLabel(addCustomFontText), findsOneWidget); + + await tester.tap(find.byTooltip(customFontActionsTooltip)); + await tester.pumpAndSettle(); + await tester.tap(find.text(renameCustomFontText)); + await tester.pumpAndSettle(); + await tester.enterText(find.byType(TextField), 'Body'); + await tester.tap(find.widgetWithText(TextButton, renameCustomFontText)); + await tester.pumpAndSettle(); + expect(find.text('Body'), findsOneWidget); + expect(harness.fonts.selected.label, 'Body'); + + await tester.tap(find.byTooltip(customFontActionsTooltip)); + await tester.pumpAndSettle(); + await tester.tap(find.text(removeCustomFontText)); + await tester.pumpAndSettle(); + expect(find.text('Remove Body?'), findsOneWidget); + await tester.tap(find.widgetWithText(TextButton, 'Remove')); + await tester.pumpAndSettle(); + expect(find.text('Body'), findsNothing); + expect(harness.fonts.selected, AppFont.system); + expect(harness.store.id, AppFont.system.id); + expect(harness.bytes.files, isEmpty); + }); + + testWidgets('an invalid file is refused with a message, nothing stored', ( + tester, + ) async { + final harness = _Harness() + ..next = [ + PickedFontFile(name: 'fake.ttf', bytes: utf8.encode('not a font')), + ]; + await _pump(tester, harness); + + await tester.tap(find.text(addCustomFontText)); + await tester.pumpAndSettle(); + expect(find.text(addCustomFontFailedTitle), findsOneWidget); + expect(find.textContaining('“fake.ttf” cannot be used'), findsOneWidget); + expect(find.text(addCustomFontTitle), findsNothing); + await tester.tap(find.text('OK')); + await tester.pumpAndSettle(); + expect(harness.fonts.customFonts, isEmpty); + expect(harness.bytes.files, isEmpty); + }); + + testWidgets('a cancelled pick or name dialog adds nothing', (tester) async { + final harness = _Harness(); + await _pump(tester, harness); + await tester.tap(find.text(addCustomFontText)); + await tester.pumpAndSettle(); + expect(find.byType(AlertDialog), findsNothing); + + harness.next = [regular]; + await tester.tap(find.text(addCustomFontText)); + await tester.pumpAndSettle(); + await tester.tap(find.text('Cancel')); + await tester.pumpAndSettle(); + expect(harness.fonts.customFonts, isEmpty); + }); + + testWidgets('Cupertino: an added font has the checkmark and options', ( + tester, + ) async { + final harness = _Harness()..next = [regular]; + await _pump(tester, harness, cupertino: true); + await tester.tap(find.text(addCustomFontText)); + await tester.pumpAndSettle(); + await tester.tap(find.text('Add')); + await tester.pumpAndSettle(); + + final CustomFont font = harness.fonts.customFonts.single; + final row = find.byKey(settingsFontKey(font)); + expect( + find.descendant( + of: row, + matching: find.byIcon(CupertinoIcons.check_mark), + ), + findsOneWidget, + ); + // The options button is its own control beside the row. + expect(find.bySemanticsLabel(customFontActionsTooltip), findsOneWidget); + await tester.tap(find.byIcon(CupertinoIcons.ellipsis_circle)); + await tester.pumpAndSettle(); + await tester.tap(find.text(removeCustomFontText)); + await tester.pumpAndSettle(); + await tester.tap(find.widgetWithText(CupertinoDialogAction, 'Remove')); + await tester.pumpAndSettle(); + expect(harness.fonts.customFonts, isEmpty); + expect(harness.fonts.selected, AppFont.system); + }); +} diff --git a/app/test/features/settings/settings_font_section_test.dart b/app/test/features/settings/settings_font_section_test.dart index fd8aedd3..eeb4cfd2 100644 --- a/app/test/features/settings/settings_font_section_test.dart +++ b/app/test/features/settings/settings_font_section_test.dart @@ -7,6 +7,7 @@ import 'package:pipelines_app/features/settings/settings_font_section.dart'; import 'package:pipelines_app/ui/theme/app_font.dart'; import 'package:pipelines_app/ui/theme/app_font_controller.dart'; import 'package:pipelines_app/ui/theme/app_font_store.dart'; +import 'package:pipelines_app/ui/theme/font_choice.dart'; class _Harness { _Harness({this.hold = false}); @@ -71,8 +72,8 @@ void main() { for (final font in AppFont.values) if (font.previewAsset != null) font.previewAsset, ]); - final group = tester.widget>( - find.byType(RadioGroup), + final group = tester.widget>( + find.byType(RadioGroup), ); expect(group.groupValue, AppFont.system); }); @@ -85,10 +86,10 @@ void main() { await tester.tap(find.text('Source Sans 3')); await tester.pump(); - expect(harness.store.font, AppFont.sourceSans3); + expect(harness.store.id, AppFont.sourceSans3.id); expect( tester - .widget>(find.byType(RadioGroup)) + .widget>(find.byType(RadioGroup)) .groupValue, AppFont.sourceSans3, ); @@ -107,7 +108,7 @@ void main() { final harness = _Harness(); await _pump(tester, harness, cupertino: true); - expect(find.byType(RadioListTile), findsNothing); + expect(find.byType(RadioListTile), findsNothing); expect(_familyOf(tester, AppFont.system), 'CupertinoSystemText'); Finder check(AppFont font) => find.descendant( of: find.byKey(settingsFontKey(font)), @@ -119,7 +120,7 @@ void main() { await tester.pumpAndSettle(); expect(check(AppFont.system), findsNothing); expect(check(AppFont.inter), findsOneWidget); - expect(harness.store.font, AppFont.inter); + expect(harness.store.id, AppFont.inter.id); expect(harness.fonts.family, 'Inter'); }); diff --git a/app/test/ui/theme/app_font_controller_test.dart b/app/test/ui/theme/app_font_controller_test.dart index 865ad00f..9fb42435 100644 --- a/app/test/ui/theme/app_font_controller_test.dart +++ b/app/test/ui/theme/app_font_controller_test.dart @@ -36,7 +36,7 @@ void main() { test('restore loads only the stored family, then applies it', () async { final loads = _Loads()..immediate = false; final fonts = AppFontController( - store: MemoryAppFontStore(AppFont.inter), + store: MemoryAppFontStore(AppFont.inter.id), loader: loads.call, ); final restoring = fonts.restore(); @@ -57,7 +57,7 @@ void main() { () async { final loads = _Loads()..immediate = false; final fonts = AppFontController( - store: MemoryAppFontStore(AppFont.sourceSans3), + store: MemoryAppFontStore(AppFont.sourceSans3.id), loader: loads.call, ); await fonts.restore(wait: const Duration(milliseconds: 10)); @@ -75,10 +75,10 @@ void main() { final loads = _Loads(); final fonts = AppFontController(store: store, loader: loads.call); await fonts.select(AppFont.atkinsonHyperlegible); - expect(store.font, AppFont.atkinsonHyperlegible); + expect(store.id, AppFont.atkinsonHyperlegible.id); expect(fonts.family, 'Atkinson Hyperlegible Next'); await fonts.select(AppFont.system); - expect(store.font, AppFont.system); + expect(store.id, AppFont.system.id); expect(fonts.family, isNull); expect(loads.calls, hasLength(1)); }, diff --git a/app/test/ui/theme/app_font_store_test.dart b/app/test/ui/theme/app_font_store_test.dart index 7e6f46cf..636cf972 100644 --- a/app/test/ui/theme/app_font_store_test.dart +++ b/app/test/ui/theme/app_font_store_test.dart @@ -10,32 +10,25 @@ void main() { setUp(() => SharedPreferences.setMockInitialValues({})); - test('nothing stored is the system default', () async { - expect(await const SharedPreferencesAppFontStore().load(), AppFont.system); + test('nothing stored reads as no choice', () async { + expect(await const SharedPreferencesAppFontStore().load(), isNull); }); test( 'a choice round-trips under its stable id, on the device only', () async { const store = SharedPreferencesAppFontStore(); - expect(await store.save(AppFont.ibmPlexSans), isTrue); + expect(await store.save(AppFont.ibmPlexSans.id), isTrue); final preferences = await SharedPreferences.getInstance(); expect(preferences.getKeys(), {appFontKey}); expect(preferences.getString(appFontKey), 'ibm-plex-sans'); - expect(await store.load(), AppFont.ibmPlexSans); + expect(await store.load(), AppFont.ibmPlexSans.id); - expect(await store.save(AppFont.system), isTrue); - expect(await store.load(), AppFont.system); + expect(await store.save(AppFont.system.id), isTrue); + expect(await store.load(), 'system'); }, ); - test('an unknown stored id falls back to the system default', () async { - SharedPreferences.setMockInitialValues({ - appFontKey: 'comic-sans', - }); - expect(await const SharedPreferencesAppFontStore().load(), AppFont.system); - }); - test('every bundled option has its four weights and its licence', () { for (final font in AppFont.values) { if (font == AppFont.system) { diff --git a/app/test/ui/theme/custom_fonts/custom_font_controller_test.dart b/app/test/ui/theme/custom_fonts/custom_font_controller_test.dart new file mode 100644 index 00000000..077f5533 --- /dev/null +++ b/app/test/ui/theme/custom_fonts/custom_font_controller_test.dart @@ -0,0 +1,160 @@ +import 'dart:io'; +import 'dart:typed_data'; + +import 'package:flutter_test/flutter_test.dart'; +import 'package:pipelines_app/ui/theme/app_font.dart'; +import 'package:pipelines_app/ui/theme/app_font_controller.dart'; +import 'package:pipelines_app/ui/theme/app_font_store.dart'; +import 'package:pipelines_app/ui/theme/custom_fonts/custom_font.dart'; +import 'package:pipelines_app/ui/theme/custom_fonts/custom_font_draft.dart'; +import 'package:pipelines_app/ui/theme/custom_fonts/custom_font_library.dart'; +import 'package:pipelines_app/ui/theme/custom_fonts/font_bytes_store.dart'; +import 'package:shared_preferences/shared_preferences.dart'; + +PickedFontFile _pick(String path) => PickedFontFile( + name: path.split('/').last, + bytes: File(path).readAsBytesSync(), +); + +class _Device { + _Device({MemoryAppFontStore? store, MemoryFontBytesStore? bytes}) + : store = store ?? MemoryAppFontStore(), + bytes = bytes ?? MemoryFontBytesStore(); + + final MemoryAppFontStore store; + final MemoryFontBytesStore bytes; + final loads = >[]; + final checked = []; + bool rejectBytes = false; + + /// A fresh app start on this device: real index, the given byte store. + late final AppFontController fonts = AppFontController( + store: store, + library: CustomFontLibrary(bytes: bytes), + loader: (family, sources) async => loads.add(sources), + bytesLoader: (family, faces) async { + checked.add(family); + if (rejectBytes) throw StateError('engine refused'); + }, + ); +} + +void main() { + TestWidgetsFlutterBinding.ensureInitialized(); + setUp(() => SharedPreferences.setMockInitialValues({})); + + final regular = _pick('fonts/inter/Inter-Regular.ttf'); + final bold = _pick('fonts/inter/Inter-Bold.ttf'); + + test( + 'adding checks the files with the engine, stores and chooses them', + () async { + final device = _Device(); + final draft = await device.fonts.inspect([regular, bold]); + final font = await device.fonts.addCustom(draft, ' My Inter '); + + expect(font.name, 'My Inter'); + expect(device.checked, [font.family]); + expect(device.fonts.customFonts, [font]); + expect(device.fonts.selected, font); + expect(device.fonts.family, font.family); + expect(device.loads, isEmpty, reason: 'already registered by the check'); + expect(device.store.id, font.id); + expect(device.bytes.files, hasLength(2)); + }, + ); + + test('a font the engine cannot load is rejected and never stored', () async { + final device = _Device()..rejectBytes = true; + final draft = await device.fonts.inspect([regular]); + await expectLater( + device.fonts.addCustom(draft, 'Broken'), + throwsA(isA()), + ); + expect(device.bytes.files, isEmpty); + expect(device.fonts.customFonts, isEmpty); + expect(device.fonts.selected, AppFont.system); + expect(device.store.id, isNull); + }); + + test('an empty name is refused before anything is stored', () async { + final device = _Device(); + final draft = await device.fonts.inspect([regular]); + await expectLater( + device.fonts.addCustom(draft, ' '), + throwsA(isA()), + ); + expect(device.checked, isEmpty); + }); + + test('a stored added font loads at startup from the byte store', () async { + final first = _Device(); + final draft = await first.fonts.inspect([regular, bold]); + final font = await first.fonts.addCustom(draft, 'Mine'); + + final next = _Device(store: first.store, bytes: first.bytes); + await next.fonts.restore(wait: const Duration(seconds: 1)); + expect(next.fonts.selected, font); + expect(next.fonts.family, font.family); + expect(next.loads.single, font.sources); + }); + + test('a stored id with no font behind it is the system default', () async { + for (final id in ['comic-sans', 'custom-gone']) { + final device = _Device(store: MemoryAppFontStore(id)); + await device.fonts.restore(); + expect(device.fonts.selected, AppFont.system); + expect(device.loads, isEmpty); + } + }); + + test('missing bytes at startup keep the system face and say so', () async { + final first = _Device(); + final draft = await first.fonts.inspect([regular]); + final font = await first.fonts.addCustom(draft, 'Mine'); + first.bytes.files.clear(); + + final next = AppFontController( + store: first.store, + library: CustomFontLibrary(bytes: first.bytes), + loader: appFontSourceLoader(first.bytes.read), + ); + await next.restore(); + expect(next.selected, font); + expect(next.loadFailed, font); + expect(next.family, isNull); + }); + + test('renaming keeps the choice; removing it falls back to system', () async { + final device = _Device(); + final draft = await device.fonts.inspect([regular]); + final font = await device.fonts.addCustom(draft, 'Mine'); + + await device.fonts.renameCustom(font, 'Body'); + expect(device.fonts.selected.label, 'Body'); + expect(device.fonts.family, font.family); + expect(device.store.id, font.id); + + await device.fonts.removeCustom(device.fonts.customFonts.single); + expect(device.fonts.customFonts, isEmpty); + expect(device.fonts.selected, AppFont.system); + expect(device.fonts.family, isNull); + expect(device.store.id, AppFont.system.id); + expect(device.bytes.files, isEmpty); + }); + + test('removing a font that is not chosen keeps the choice', () async { + final device = _Device(); + final draft = await device.fonts.inspect([regular]); + final font = await device.fonts.addCustom(draft, 'Mine'); + await device.fonts.select(AppFont.inter); + await device.fonts.removeCustom(font); + expect(device.fonts.selected, AppFont.inter); + expect(device.store.id, AppFont.inter.id); + }); + + test('the real FontLoader accepts a bundled file as a user font', () async { + // The engine path production uses; bytes come from a fixture file. + await loadFontBytes('Fixture user font', [regular.bytes]); + }); +} diff --git a/app/test/ui/theme/custom_fonts/custom_font_store_test.dart b/app/test/ui/theme/custom_fonts/custom_font_store_test.dart new file mode 100644 index 00000000..7f01e68d --- /dev/null +++ b/app/test/ui/theme/custom_fonts/custom_font_store_test.dart @@ -0,0 +1,197 @@ +import 'dart:convert'; +import 'dart:io'; +import 'dart:typed_data'; + +import 'package:flutter_test/flutter_test.dart'; +import 'package:pipelines_app/ui/theme/custom_fonts/custom_font.dart'; +import 'package:pipelines_app/ui/theme/custom_fonts/custom_font_draft.dart'; +import 'package:pipelines_app/ui/theme/custom_fonts/custom_font_library.dart'; +import 'package:pipelines_app/ui/theme/custom_fonts/font_bytes_store.dart'; +import 'package:pipelines_app/ui/theme/custom_fonts/font_bytes_store_io.dart'; +import 'package:pipelines_app/ui/theme/font_choice.dart'; +import 'package:shared_preferences/shared_preferences.dart'; + +PickedFontFile _pick(String path, [String? name]) => PickedFontFile( + name: name ?? path.split('/').last, + bytes: File(path).readAsBytesSync(), +); + +final _regular = _pick('fonts/inter/Inter-Regular.ttf'); +final _bold = _pick('fonts/inter/Inter-Bold.ttf'); + +void main() { + TestWidgetsFlutterBinding.ensureInitialized(); + setUp(() => SharedPreferences.setMockInitialValues({})); + + group('inspect', () { + test('groups files into one family named from the name table', () { + final draft = CustomFontDraft.inspect([_regular, _bold]); + expect(draft.suggestedName, 'Inter'); + expect(draft.faces.map((f) => f.styleName), ['Regular', 'Bold']); + }); + + test('a file without names is named after the file', () { + final copy = Uint8List.fromList(_regular.bytes); + final data = ByteData.sublistView(copy); + for (var i = 0; i < data.getUint16(4); i++) { + final record = 12 + i * 16; + if (String.fromCharCodes(copy, record, record + 4) == 'name') { + copy.setAll(record, 'zzzz'.codeUnits); + } + } + final draft = CustomFontDraft.inspect([ + PickedFontFile(name: 'My Face.OTF', bytes: copy), + ]); + expect(draft.suggestedName, 'My Face'); + }); + + test('refuses other files, damaged fonts, twins and oversize', () { + void refuses(List files, String text, {int stored = 0}) => + expect( + () => CustomFontDraft.inspect(files, storedBytes: stored), + throwsA( + isA().having( + (e) => e.message, + 'message', + contains(text), + ), + ), + ); + + refuses([], 'No font file'); + refuses([ + PickedFontFile(name: 'notes.txt', bytes: _regular.bytes), + ], 'not a .ttf or .otf'); + refuses([ + PickedFontFile(name: 'fake.ttf', bytes: utf8.encode('hello')), + ], 'cannot be used'); + refuses([ + PickedFontFile( + name: 'huge.ttf', + bytes: Uint8List(CustomFontLimits.maxFileBytes + 1), + ), + ], 'larger than 10 MB'); + refuses([ + _regular, + _pick('fonts/source-sans-3/SourceSans3-Regular.ttf'), + ], 'both Regular'); + refuses( + [_regular], + 'up to 40 MB', + stored: CustomFontLimits.maxTotalBytes - 1000, + ); + }); + + test('names are trimmed, required and bounded', () { + expect(CustomFontLimits.nameProblem(' '), isNotNull); + expect(CustomFontLimits.nameProblem('x' * 65), isNotNull); + expect(CustomFontLimits.nameProblem(' Mine '), isNull); + }); + }); + + group('library', () { + test('round-trips the index and bytes, then removes both', () async { + final bytes = MemoryFontBytesStore(); + final library = CustomFontLibrary(bytes: bytes); + await library.load(); + final draft = CustomFontDraft.inspect([_regular, _bold]); + final font = await library.store(library.prepare(draft, 'Mine'), draft); + expect(font.styles, 'Regular, Bold'); + expect(font.sources, [ + for (final face in font.faces) customFontSource(face.key), + ]); + expect(font.previewSource, customFontSource(font.faces.first.key)); + expect(bytes.files.keys, font.faces.map((f) => f.key)); + + final reopened = CustomFontLibrary(bytes: bytes); + final fonts = await reopened.load(); + expect(fonts.single.name, 'Mine'); + expect(fonts.single.faces.map((f) => f.weight), [400, 700]); + expect(await reopened.read(font.faces.last.key), _bold.bytes); + expect(reopened.storedBytes, draft.size); + + final renamed = await reopened.rename(fonts.single, 'Body'); + expect(renamed.family, font.family, reason: 'registration is kept'); + expect( + (await CustomFontLibrary(bytes: bytes).load()).single.label, + 'Body', + ); + + await reopened.remove(renamed); + expect(bytes.files, isEmpty); + expect(await CustomFontLibrary(bytes: bytes).load(), isEmpty); + }); + + test('a failed write stores nothing and says so', () async { + final bytes = MemoryFontBytesStore()..failWrites = true; + final library = CustomFontLibrary(bytes: bytes); + final draft = CustomFontDraft.inspect([_regular]); + await expectLater( + library.store(library.prepare(draft, 'Mine'), draft), + throwsA(isA()), + ); + expect(bytes.files, isEmpty); + expect(await library.load(), isEmpty); + }); + + test('an unreadable index or entry is skipped', () async { + SharedPreferences.setMockInitialValues({ + customFontsKey: jsonEncode([ + {'id': 'evil', 'name': 'x', 'faces': []}, + const CustomFont( + id: 'custom-1', + name: 'Kept', + faces: [ + CustomFontFace( + key: 'custom-1-0', + fileName: 'a.ttf', + weight: 400, + italic: false, + size: 3, + ), + ], + ).toJson(), + ]), + }); + final fonts = await CustomFontLibrary( + bytes: MemoryFontBytesStore(), + ).load(); + expect(fonts.map((f) => f.name), ['Kept']); + + SharedPreferences.setMockInitialValues({ + customFontsKey: '{not json', + }); + expect( + await CustomFontLibrary(bytes: MemoryFontBytesStore()).load(), + isEmpty, + ); + }); + }); + + group('native file store', () { + late Directory temp; + setUp(() => temp = Directory.systemTemp.createTempSync('custom-fonts')); + tearDown(() => temp.deleteSync(recursive: true)); + + test('writes, reads and deletes one file per key', () async { + final dir = Directory('${temp.path}/custom-fonts'); + final store = DirectoryFontBytesStore(() async => dir); + await store.write('custom-1-0', _regular.bytes); + expect(File('${dir.path}/custom-1-0').existsSync(), isTrue); + expect(dir.listSync(), hasLength(1), reason: 'no partial file left'); + expect(await store.read('custom-1-0'), _regular.bytes); + await store.delete('custom-1-0'); + await store.delete('custom-1-0'); + expect(dir.listSync(), isEmpty); + await expectLater(store.read('custom-1-0'), throwsA(anything)); + }); + + test('refuses a key that could name another path', () async { + final store = DirectoryFontBytesStore(() async => temp); + await expectLater( + store.write('../escape', _regular.bytes), + throwsArgumentError, + ); + }); + }); +} diff --git a/app/test/ui/theme/custom_fonts/font_file_info_test.dart b/app/test/ui/theme/custom_fonts/font_file_info_test.dart new file mode 100644 index 00000000..174ce402 --- /dev/null +++ b/app/test/ui/theme/custom_fonts/font_file_info_test.dart @@ -0,0 +1,103 @@ +import 'dart:io'; +import 'dart:typed_data'; + +import 'package:flutter_test/flutter_test.dart'; +import 'package:pipelines_app/ui/theme/custom_fonts/font_file_info.dart'; + +Uint8List _font(String path) => File(path).readAsBytesSync(); + +/// [bytes] with the table directory's [tag] renamed, so the table is gone. +Uint8List _withoutTable(Uint8List bytes, String tag) { + final copy = Uint8List.fromList(bytes); + final data = ByteData.sublistView(copy); + for (var i = 0; i < data.getUint16(4); i++) { + final record = 12 + i * 16; + if (String.fromCharCodes(copy, record, record + 4) == tag) { + copy.setAll(record, 'zzzz'.codeUnits); + } + } + return copy; +} + +void main() { + test('reads family, style and weight from the bundled fonts', () { + final regular = FontFileInfo.parse(_font('fonts/inter/Inter-Regular.ttf')); + expect(regular.family, 'Inter'); + expect(regular.subfamily, 'Regular'); + expect(regular.weight, 400); + expect(regular.italic, isFalse); + + final bold = FontFileInfo.parse(_font('fonts/inter/Inter-Bold.ttf')); + expect(bold.family, 'Inter'); + expect(bold.weight, 700); + + final semibold = FontFileInfo.parse( + _font('fonts/source-sans-3/SourceSans3-Semibold.ttf'), + ); + expect(semibold.family, 'Source Sans 3'); + expect(semibold.weight, 600); + + final plex = FontFileInfo.parse( + _font('fonts/ibm-plex-sans/IBMPlexSans-Medium.ttf'), + ); + expect(plex.family, 'IBM Plex Sans'); + expect(plex.weight, 500); + + final mono = FontFileInfo.parse(_font('fonts/RobotoMono-Bold.ttf')); + expect(mono.family, 'Roboto Mono'); + expect(mono.weight, 700); + }); + + test('a font without OS/2 is weight 400; without names, no family', () { + final bold = _font('fonts/inter/Inter-Bold.ttf'); + expect(FontFileInfo.parse(_withoutTable(bold, 'OS/2')).weight, 400); + expect(FontFileInfo.parse(_withoutTable(bold, 'name')).family, isNull); + }); + + test('rejects what is not a single TrueType/OpenType font', () { + final inter = _font('fonts/inter/Inter-Regular.ttf'); + void rejects(List bytes, String message) => expect( + () => FontFileInfo.parse(Uint8List.fromList(bytes)), + throwsA( + isA().having( + (e) => e.message, + 'message', + contains(message), + ), + ), + ); + + rejects([], 'too short'); + rejects('just some text, not a font'.codeUnits, 'Not a TrueType'); + rejects([...'ttcf'.codeUnits, ...List.filled(12, 0)], 'collections'); + rejects([...'wOFF'.codeUnits, ...List.filled(12, 0)], 'WOFF'); + // The directory promises tables the file does not hold. + rejects(inter.sublist(0, 2000), 'outside the file'); + rejects(inter.sublist(0, 20), 'directory is damaged'); + rejects(_withoutTable(inter, 'cmap'), 'missing required tables'); + }); + + test('a hostile name table is bounded, not trusted', () { + final copy = Uint8List.fromList(_font('fonts/inter/Inter-Regular.ttf')); + final data = ByteData.sublistView(copy); + for (var i = 0; i < data.getUint16(4); i++) { + final record = 12 + i * 16; + if (String.fromCharCodes(copy, record, record + 4) == 'name') { + // An absurd record count: ignored, the font still parses. + data.setUint16(data.getUint32(record + 8) + 2, 0xFFFF); + } + } + final info = FontFileInfo.parse(copy); + expect(info.family, isNull); + expect(info.weight, 400); + }); + + test('style names follow the weight classes', () { + expect(fontStyleName(400), 'Regular'); + expect(fontStyleName(700), 'Bold'); + expect(fontStyleName(600, italic: true), 'SemiBold Italic'); + expect(fontStyleName(400, italic: true), 'Italic'); + expect(fontStyleName(1000), 'Black'); + expect(fontStyleName(1), 'Thin'); + }); +} diff --git a/app/tool/capture/README.md b/app/tool/capture/README.md index ce1fd3c8..cff65da4 100644 --- a/app/tool/capture/README.md +++ b/app/tool/capture/README.md @@ -53,6 +53,7 @@ In JSON, a step can also set `wait` (ms), `timeout`, `name`, `ms` and `frames`. | `labels=name` | write the visible semantics labels, keys and rects to JSON | | `film=` | screencast a click for `--film-ms` (900) and write the frames plus a contact sheet | | `wait=ms` | sleep | +| `files=a.ttf[,b.ttf]` | answer the next file chooser the page opens with these files (paths relative to the working directory); put it before the click that opens the picker | | `swipe=>dx,dy` | one-finger touch swipe (needs `--touch true`, which emulates a touch screen once semantics is on) | | `pinch=>scale` | two-finger touch pinch, spreading (>1) or closing (<1) (needs `--touch true`) | | `tabs=name` | write the open tabs (`{url, type}`) to JSON, e.g. to see a link open a new tab | diff --git a/app/tool/capture/capture.mjs b/app/tool/capture/capture.mjs index 3d1b2d85..f0039439 100644 --- a/app/tool/capture/capture.mjs +++ b/app/tool/capture/capture.mjs @@ -23,6 +23,7 @@ options: --script --size WxH (880x1000) --platform material|cuperti --touch true (emulate a touch screen: mobile metrics, touch input) steps: open=[@WxH] wait= shot= click= waitfor= type= press= scroll= size=WxH + files=[,] (answers the next file chooser) film= labels= tabs= eval= expect= hover= drag=>, (JSON: drag, dx, dy, steps, gap, hold) swipe=>, pinch=> (with --touch true) @@ -113,6 +114,7 @@ try { break; } case 'waitfor': await page.waitFor(value, step.timeout ?? 10000); break; + case 'files': await page.armFiles(String(value).split(',').map((p) => resolve(p))); break; case 'type': await page.type(String(value)); await delay(step.wait ?? settle); break; case 'press': await page.press(String(value)); await delay(step.wait ?? settle); break; case 'scroll': { diff --git a/app/tool/capture/page.mjs b/app/tool/capture/page.mjs index 6714e417..0f0af3b5 100644 --- a/app/tool/capture/page.mjs +++ b/app/tool/capture/page.mjs @@ -122,6 +122,17 @@ export function flutterPage(browser, log, { touch = false } = {}) { return point; }, waitFor: (target, timeout) => locate(target, timeout), + /** Answers the next file chooser the page opens with [paths] (absolute). */ + async armFiles(paths) { + await send('Page.setInterceptFileChooserDialog', { enabled: true }); + const off = browser.on('Page.fileChooserOpened', (p) => { + off(); + send('DOM.setFileInputFiles', { files: paths, backendNodeId: p.backendNodeId }) + .then(() => log(` chose ${paths.join(', ')}`)) + .catch((e) => errors.push(`files: ${e.message}`)) + .finally(() => send('Page.setInterceptFileChooserDialog', { enabled: false }).catch(() => {})); + }); + }, async type(text) { const focused = await evaluate(`(() => { const a = document.activeElement;