Files
pipelines/app/lib/features/settings/settings_screen.dart
T
alan 2853b18b9e Settings: per-device interface font choice
System default plus Inter, IBM Plex Sans, Source Sans 3 and Atkinson
Hyperlegible Next (OFL 1.1, bundled as on-demand assets and loaded with
FontLoader, so the web fetches only the previewed/chosen files). Stored in
shared_preferences, applied live to Material and Cupertino text themes;
RobotoMono styles unchanged. Licences registered with LicenseRegistry.
2026-11-04 02:01:49 +00:00

266 lines
9.3 KiB
Dart

import '../../ui/adaptive/segmented_bar.dart';
import 'dart:async';
import 'package:flutter/cupertino.dart';
import 'package:flutter/material.dart';
import '../../core/transport/pipelines_client.dart' as transport;
import '../../shell/shell_bar.dart';
import '../attention/notify/notification_controller.dart';
import 'default_endpoint.dart';
import 'settings_controller.dart';
import 'settings_controls.dart';
import 'settings_font_section.dart';
import '../../ui/theme/app_font_controller.dart';
import 'settings_group.dart';
import 'settings_page_body.dart';
import 'settings_notifications_section.dart';
import 'settings_ntfy_section.dart';
import 'settings_device_delivery_section.dart';
import '../notification_service/notification_service_bridge.dart';
import '../notification_service/notification_service_controller.dart';
import 'settings_android_download_section.dart';
import 'settings_schedules_section.dart';
import 'settings_sections.dart';
import 'settings_sign_in_section.dart';
import 'settings_updates_section.dart';
import '../updates/app_updates.dart';
import 'settings_store.dart';
import 'settings_templates_section.dart';
import 'server_connections.dart';
import 'saved_servers_section.dart';
import 'managed_connection_section.dart';
/// The Settings destination: the server connection and the server-side
/// workspace, in native Material (native platforms) or Cupertino (iOS) controls.
///
/// The shared [transport.PipelinesClient] is supplied by the shell. This screen
/// subscribes to it, connects/disconnects it and pings it on connected, but it
/// never opens a connection on its own and never disposes the client. One
/// controller is created in [initState], so rebuilding the screen cannot start
/// a second connection.
class SettingsScreen extends StatefulWidget {
const SettingsScreen({
super.key,
required this.client,
this.initialEndpoint,
this.store,
this.ping,
this.embedded = false,
this.onOpenTemplates,
this.onOpenSchedules,
this.notifications,
this.showSignIn = false,
this.showAndroidDownload = false,
this.servers,
this.deliveryService,
this.deliveryServiceController,
this.fonts,
});
/// The device's interface font; defaults to the app's shared controller.
final AppFontController? fonts;
/// Android background delivery; hidden when absent or unsupported.
final NotificationServiceBridge? deliveryService;
final NotificationServiceController? deliveryServiceController;
final transport.PipelinesClient client;
/// Whether to offer the web sign-in (the native app; a browser has its own).
final bool showSignIn;
/// A browser page links the Android app the server offers.
final bool showAndroidDownload;
final ServerConnections? servers;
/// A fixture/preview seed for the URL field. Persisted settings still load;
/// this value takes precedence for the draft and is never written by itself.
final Uri? initialEndpoint;
/// The feature's own persistence. Defaults to the `pipelines.next` keys.
final SettingsStore? store;
/// Test seam for the exact ping request. Production uses `client.call('ping')`.
final PingCallback? ping;
/// The application shell already owns the native navigation bar and safe area.
final bool embedded;
/// Opens the Templates gallery. Null keeps Settings standalone/incomplete
/// without a dead row that would go nowhere.
final VoidCallback? onOpenTemplates;
/// Opens the saved-schedule list above Settings.
final VoidCallback? onOpenSchedules;
/// The app-level notification capability; absent in connection-only fixtures.
final NotificationController? notifications;
@override
State<SettingsScreen> createState() => _SettingsScreenState();
}
class _SettingsScreenState extends State<SettingsScreen> {
final TextEditingController _serverUrlField = TextEditingController();
final TextEditingController _workspaceField = TextEditingController();
late final SettingsController _controller;
@override
void initState() {
super.initState();
_controller = SettingsController(
client: widget.client,
store: widget.store ?? const SharedPreferencesSettingsStore(),
initialEndpoint: widget.initialEndpoint,
defaultEndpoint: defaultServerUrl(),
ping: widget.ping,
);
_controller.addListener(_onSettingsChanged);
unawaited(_controller.initialize());
}
void _onSettingsChanged() {
if (!mounted) return;
_syncField(_serverUrlField, _controller.serverUrl);
_syncField(_workspaceField, _controller.workspaceDraft);
setState(() {});
}
/// Follow the controller's value (a restored value or the normalised URL)
/// without disturbing a field the operator is already typing in.
void _syncField(TextEditingController field, String value) {
if (field.text == value) return;
field.value = TextEditingValue(
text: value,
selection: TextSelection.collapsed(offset: value.length),
);
}
@override
void dispose() {
_controller.removeListener(_onSettingsChanged);
_controller.dispose();
_serverUrlField.dispose();
_workspaceField.dispose();
// The shared client is owned by the shell and deliberately outlives this
// screen, so it is not disposed here.
super.dispose();
}
String get _endpoint => widget.servers == null
? _controller.serverUrl
: widget.client.endpoint?.toString() ?? '';
void _reconnectAfterSignIn() {
final endpoint = widget.client.endpoint;
if (endpoint != null) {
widget.client.connectAny(
widget.client.endpoints.isEmpty ? [endpoint] : widget.client.endpoints,
);
}
}
@override
Widget build(BuildContext context) {
final servers = widget.servers;
final content = SettingsPageBody(
children: <Widget>[
if (servers != null) ...<Widget>[
SavedServersSection(connections: servers),
ManagedConnectionSection(
client: widget.client,
controller: _controller,
),
] else
SettingsConnectionSection(
controller: _controller,
serverUrlField: _serverUrlField,
),
// A phone signs in at the web login; a browser has its own.
if (widget.showSignIn)
_single(
'Sign in',
SettingsSignInSection(
endpoint: _endpoint,
onChanged: _reconnectAfterSignIn,
),
),
// The web page links the Android app the server offers.
if (widget.showAndroidDownload)
_single('Android app', const SettingsAndroidDownloadSection()),
// A phone installs newer builds from the server.
if (widget.showSignIn && appUpdatesSupported)
_single('App updates', SettingsUpdatesSection(endpoint: _endpoint)),
SettingsWorkspaceSection(
controller: _controller,
workspaceField: _workspaceField,
),
// A device-local choice: a browser and a phone keep their own.
SettingsFontSection(
controller: widget.fonts ?? AppFontController.instance,
),
if (widget.notifications case final notifications?)
SettingsNotificationsSection(controller: notifications),
if (widget.deliveryService case final service? when service.supported)
SettingsDeviceDeliverySection(
bridge: service,
controller: widget.deliveryServiceController,
requestNotificationPermission: widget.notifications == null
? null
: () async {
await widget.notifications!.requestPermission();
},
),
// The server's ntfy choices, beside the in-app permission.
SettingsNtfySection(
gateway: widget.client,
connected:
widget.client.state.kind == transport.ConnectionKind.connected,
),
if (widget.onOpenSchedules != null || widget.onOpenTemplates != null)
SettingsGroup(
title: 'Library',
leadingRows: true,
children: <Widget>[
if (widget.onOpenSchedules case final open?)
SettingsSchedulesSection(onOpen: open),
if (widget.onOpenTemplates case final open?)
SettingsTemplatesSection(onOpen: open),
],
),
],
);
if (widget.embedded) {
// Under the shell's bar the Cupertino page is the grouped background
// right up to the top edge: the bar's scrim takes the same colour, so
// no white band or seam shows above the groups.
if (usesCupertinoControls(context) && ShellBar.available(context)) {
return ShellBar(
backgroundColor: settingsCupertinoBackground,
child: content,
);
}
return content;
}
if (usesCupertinoControls(context)) {
return CupertinoPageScaffold(
backgroundColor: settingsCupertinoBackground,
navigationBar: const SegmentedBar(cupertino: true, title: 'Settings'),
child: content,
);
}
return Scaffold(
extendBodyBehindAppBar: true,
appBar: const SegmentedBar(cupertino: false, title: 'Settings'),
body: content,
);
}
/// A group holding one free-form block (a form, a status with buttons).
Widget _single(String title, Widget child) => SettingsGroup(
title: title,
children: <Widget>[SettingsGroupItem(child: child)],
);
}