/// Sync configuration. Primary path: "Connect Firebase" — sign in with the /// shared sync account, whose password is kept in the OS keystore. GitHub is /// only the cutover mirror, so its whole setup (device-flow OAuth, owner/repo, /// client id, PAT fallback) sits under "Advanced (GitHub mirror)" rather than /// competing with Firebase as a visible choice. Auto-sync (app launch + /// lifecycle pause/resume) lives in [LogMealScreen] and is silent on failure /// -- this screen is where errors get surfaced, as inline status text. library; import 'dart:async'; import 'package:crdt_sync/crdt_sync.dart'; import 'package:diet_guard_app/screens/log_meal_screen.dart'; import 'package:diet_guard_app/services/app_settings_service.dart'; import 'package:diet_guard_app/services/firebase_backend.dart'; import 'package:diet_guard_app/services/github_client_factory.dart'; import 'package:diet_guard_app/services/github_device_auth.dart'; import 'package:diet_guard_app/services/sync_service.dart'; import 'package:diet_guard_app/services/sync_settings.dart'; import 'package:diet_guard_app/ui/theme.dart'; import 'package:flutter/foundation.dart'; import 'package:flutter/material.dart'; import 'package:flutter/services.dart'; import 'package:http/http.dart' as http; import 'package:permission_handler/permission_handler.dart'; import 'package:url_launcher/url_launcher.dart'; /// Screen for configuring and triggering cross-device sync. class SettingsScreen extends StatefulWidget { /// Creates a [SettingsScreen]. const SettingsScreen({ super.key, this.httpClient, this.requestBatteryExemption, }); /// Injectable HTTP client; tests pass a [MockClient]. final http.Client? httpClient; /// Injectable battery-optimization-exemption request; tests pass a fake. /// Production defaults to /// `Permission.ignoreBatteryOptimizations.request()`. final Future Function()? requestBatteryExemption; @override State createState() => _SettingsScreenState(); } class _SettingsScreenState extends State { final _kcalGoalController = TextEditingController(); final _ownerController = TextEditingController(); final _repoController = TextEditingController(); final _tokenController = TextEditingController(); final _clientIdController = TextEditingController(); final _firebaseEmailController = TextEditingController(); final _firebasePasswordController = TextEditingController(); bool _firebaseConfigured = false; bool _loading = true; bool _busy = false; String? _status; @override void initState() { super.initState(); unawaited(_load()); } /// Loads saved settings, defaulting to blank fields if loading itself /// fails (e.g. no secret service available yet) -- the screen must still /// render, not spin forever, so the user can fill them in from scratch. Future _load() async { SyncSettings settings; try { settings = await SyncSettings.load(); } on Exception { settings = const SyncSettings(owner: '', repo: '', token: ''); } if (!mounted) return; _kcalGoalController.text = AppSettingsService.dailyKcalGoal.toString(); _ownerController.text = settings.owner; _repoController.text = settings.repo; // On web the stored "token" is only a stand-in for one the desktop // wrapper holds (see TokenVault); showing it would invite the user to // edit a literal. [_storedToken] keeps it for round-tripping. _storedToken = settings.token; _tokenController.text = SyncSettings.exposesTokenValue ? settings.token : ''; _clientIdController.text = settings.clientId; // Reflect a previously-stored account, so a returning user sees the // real state instead of an empty form that looks unconfigured. final account = await loadAccount(); if (!mounted) return; if (account != null) _firebaseEmailController.text = account.email; setState(() { _firebaseConfigured = account != null; _loading = false; }); } @override void dispose() { _kcalGoalDebounce?.cancel(); // Leaving the screen inside the debounce window must not silently drop // the edit the user just typed. _flushKcalGoal(); _kcalGoalController.dispose(); _ownerController.dispose(); _repoController.dispose(); _tokenController.dispose(); _firebaseEmailController.dispose(); _firebasePasswordController.dispose(); _clientIdController.dispose(); super.dispose(); } /// The token as loaded, so a platform that cannot display it (web) still /// round-trips it instead of blanking it on the next save. String _storedToken = ''; Timer? _kcalGoalDebounce; int? _pendingKcalGoal; /// Persists the pending goal, if any, and clears it. void _flushKcalGoal() { final goal = _pendingKcalGoal; if (goal == null) return; _pendingKcalGoal = null; unawaited(AppSettingsService.instance.saveDailyKcalGoal(goal)); } /// Saves the typed goal once typing settles. /// /// Debounced because every keystroke would otherwise be a real edit: /// typing "2000" saved 2, 20, 200, 2000 in turn, and a sync tick landing /// between keystrokes would push a nonsense budget to the other device. void _onKcalGoalChanged(String value) { _kcalGoalDebounce?.cancel(); final goal = int.tryParse(value); if (goal == null || goal <= 0) return; _pendingKcalGoal = goal; _kcalGoalDebounce = Timer( const Duration(milliseconds: 600), _flushKcalGoal, ); } SyncSettings _currentSettings() { final typed = _tokenController.text.trim(); return SyncSettings( owner: _ownerController.text.trim(), repo: _repoController.text.trim(), // The `_storedToken` side is web-only (the wrapper holds the real // token), so it is unreachable from a VM test. token: typed.isEmpty && !SyncSettings.exposesTokenValue // coverage:ignore-line ? _storedToken : typed, clientId: _clientIdController.text.trim(), ); } void _showMessage(String message) { if (!mounted) return; setState(() => _status = message); } /// Runs the OAuth device flow and, on success, fills in the token field. Future _connectGitHub() async { var clientId = _clientIdController.text.trim(); if (clientId.isEmpty) { final entered = await showDialog( context: context, builder: (_) => const _ClientIdSetupDialog(), ); if (entered == null || entered.isEmpty) return; clientId = entered; if (!mounted) return; setState(() => _clientIdController.text = clientId); await _currentSettings().save(); } final auth = createDeviceAuth(clientId, httpClient: widget.httpClient); try { final device = await auth.requestDeviceCode(); if (!mounted) return; final token = await showDialog( context: context, barrierDismissible: false, builder: (_) => _DeviceCodeDialog(device: device, auth: auth), ); if (token != null && token.isNotEmpty) { setState(() { _storedToken = token; if (SyncSettings.exposesTokenValue) _tokenController.text = token; }); _showMessage('Connected — syncing…'); await _currentSettings().save(); await _syncAfterConnect(); } } on Exception catch (e) { _showMessage('Could not start device flow: $e'); } finally { auth.close(); } } /// Runs a sync right after connecting so the device-flow token is proven /// to work immediately, with clear confirmation either way. Future _syncAfterConnect() async { final settings = _currentSettings(); final client = createGitHubClient(settings, httpClient: widget.httpClient); try { await runSync(await syncBackend(client)); _showMessage('Connected and synced.'); } on Exception catch (e) { _showMessage('Connected, but sync failed: $e'); } finally { client.close(); } } Future _save() async { setState(() => _busy = true); await _currentSettings().save(); if (!mounted) return; setState(() => _busy = false); _showMessage('Saved.'); } Future _testConnection() async { setState(() => _busy = true); final settings = _currentSettings(); final client = createGitHubClient(settings, httpClient: widget.httpClient); try { final ok = await client.canAccessRepo(); _showMessage( ok ? 'GitHub connection OK.' : 'GitHub connection failed.', ); } on Exception catch (e) { _showMessage('GitHub connection failed: $e'); } finally { client.close(); if (mounted) setState(() => _busy = false); } } Future _syncNow() async { setState(() => _busy = true); final settings = _currentSettings(); await settings.save(); final client = createGitHubClient(settings, httpClient: widget.httpClient); try { await runSync(await syncBackend(client)); _showMessage('Synced.'); } on Exception catch (e) { _showMessage('Sync failed: $e'); } finally { client.close(); if (mounted) setState(() => _busy = false); } } /// Requests exemption from OEM battery optimization (MIUI, some Samsung /// configs), which can otherwise degrade the 15-minute background-check /// reliability well past its accepted ±15 min target. Future _requestBatteryExemption() async { final request = widget.requestBatteryExemption ?? () => Permission.ignoreBatteryOptimizations.request(); try { final status = await request(); _showMessage( status.isGranted ? 'Battery optimization exemption granted.' : 'Exemption not granted -- notifications may be delayed.', ); } on Exception catch (e) { _showMessage('Could not request exemption: $e'); } } /// True on the one platform with OEM battery optimization to exempt from. /// /// Uses [defaultTargetPlatform] rather than `Platform.isAndroid` because /// `dart:io` is a throwing stub in the desktop web build. bool get _isAndroid => !kIsWeb && defaultTargetPlatform == TargetPlatform.android; /// Stores the Firebase account in the OS keystore and proves it works. /// /// Signing in here rather than only saving means a typo surfaces now, on /// the screen where it can be fixed, instead of as a silently failed /// background sync hours later. Future _saveFirebaseAccount() async { final email = _firebaseEmailController.text.trim(); final password = _firebasePasswordController.text; if (email.isEmpty || password.isEmpty) { setState(() => _status = 'Enter the sync account email and password.'); return; } setState(() { _busy = true; _status = null; }); try { await saveAccount(FirebaseAccount(email: email, password: password)); final client = await openFirebase(); if (client == null) { throw Exception('could not reach Firebase'); } final reachable = await client.canAccessRemote(); client.close(); if (!mounted) return; setState(() { _firebaseConfigured = reachable; _status = reachable ? 'Firebase connected - syncs now go there first.' : 'Signed in, but the database refused the read.'; }); } on Object catch (error) { // Broader than Exception: a missing platform binding raises an Error. // A half-stored account is worse than none, so forget it. await clearAccount(); if (!mounted) return; setState(() { _firebaseConfigured = false; _status = 'Firebase sign-in failed: $error'; }); } finally { if (mounted) setState(() => _busy = false); } } /// Forgets the Firebase account, so sync falls back to GitHub alone. Future _disconnectFirebase() async { await clearAccount(); _firebaseEmailController.clear(); _firebasePasswordController.clear(); if (!mounted) return; setState(() { _firebaseConfigured = false; _status = 'Firebase disconnected - syncing over GitHub only.'; }); } @override Widget build(BuildContext context) { if (_loading) { return const Scaffold(body: Center(child: CircularProgressIndicator())); } return Scaffold( appBar: AppBar(title: const Text('Settings')), // Centred and capped at the prose width. On the desktop surface this // ListView spanned the full ~1366px window, so the explanatory // paragraphs below ran ~180 characters per line -- roughly twice the // readable limit (tokens.md rule 21) -- and every field stretched with // them. Invisible on the phone, where the window is already narrow. body: Center( child: ConstrainedBox( constraints: const BoxConstraints(maxWidth: AppWidth.prose), child: ListView( padding: const EdgeInsets.all(16), children: [ Text('Nutrition', style: Theme.of(context).textTheme.titleMedium), const SizedBox(height: 8), // A four-digit number: capped so the field does not read as a // layout error by spanning the whole column. ConstrainedBox( constraints: const BoxConstraints(maxWidth: AppWidth.field), child: TextField( controller: _kcalGoalController, keyboardType: TextInputType.number, inputFormatters: [FilteringTextInputFormatter.digitsOnly], decoration: const InputDecoration( labelText: 'Daily kcal goal', helperText: 'Shown in the history day summary', suffixText: 'kcal', ), onChanged: _onKcalGoalChanged, ), ), const SizedBox(height: 24), const Divider(), const SizedBox(height: 8), Text( 'Firebase sync', style: Theme.of(context).textTheme.titleMedium, ), const SizedBox(height: 8), Text( _firebaseConfigured ? 'Connected. Syncs go to Firebase first, and still ' 'mirror to GitHub until every device has moved.' : 'Not connected - syncing over GitHub only. Enter the ' 'shared sync account to move this device over. The ' 'password is kept in the device keystore, never in ' 'the app or the repo.', style: Theme.of(context).textTheme.bodySmall, ), const SizedBox(height: 12), // Once connected, the account is shown as read-only text rather // than as prefilled inputs: an editable email box next to an // empty password box reads as "you still have to enter this", // which made a connected device look unconfigured. if (_firebaseConfigured) Row( children: [ const Icon(Icons.cloud_done, size: 20), const SizedBox(width: 8), Expanded( child: Text( _firebaseEmailController.text, style: Theme.of(context).textTheme.bodyMedium, ), ), TextButton( onPressed: _busy ? null : _disconnectFirebase, child: const Text('Disconnect'), ), ], ) else ...[ TextField( controller: _firebaseEmailController, keyboardType: TextInputType.emailAddress, autocorrect: false, decoration: const InputDecoration( labelText: 'Sync account email', ), ), const SizedBox(height: 8), TextField( controller: _firebasePasswordController, obscureText: true, autocorrect: false, decoration: const InputDecoration( labelText: 'Sync account password', ), ), const SizedBox(height: 12), FilledButton.icon( onPressed: _busy ? null : _saveFirebaseAccount, icon: const Icon(Icons.cloud_done), label: const Text('Connect Firebase'), ), ], const SizedBox(height: 24), const Divider(), const SizedBox(height: 8), // GitHub is a mirror during the cutover, not something to pick: // its whole configuration lives under "Advanced" so the primary // path stays a single choice. See CLAUDE.md "Cross-device sync". ExpansionTile( title: const Text('Advanced (GitHub mirror)'), tilePadding: EdgeInsets.zero, childrenPadding: const EdgeInsets.only(bottom: 8), children: [ Align( alignment: Alignment.centerLeft, child: Text( 'Syncs still mirror to GitHub until every device has ' 'moved to Firebase. Authorize in your browser — no ' 'token to paste.', style: Theme.of(context).textTheme.bodySmall, ), ), const SizedBox(height: 12), Align( alignment: Alignment.centerLeft, child: FilledButton.icon( onPressed: _connectGitHub, icon: const Icon(Icons.login), label: const Text('Connect GitHub'), ), ), const SizedBox(height: 16), TextField( controller: _ownerController, decoration: const InputDecoration( labelText: 'GitHub owner', ), ), const SizedBox(height: 8), TextField( controller: _repoController, decoration: const InputDecoration(labelText: 'Repo'), ), const SizedBox(height: 8), TextField( controller: _clientIdController, decoration: const InputDecoration( labelText: 'OAuth App client id', helperText: 'Needed for the Connect GitHub button', ), ), const SizedBox(height: 8), TextField( controller: _tokenController, obscureText: true, decoration: InputDecoration( labelText: 'Personal access token (fallback)', // Both wrapper hints are web-only; a VM test always takes // the null branch. // coverage:ignore-start helperText: SyncSettings.exposesTokenValue ? null : _storedToken.isEmpty ? 'Stored by the desktop wrapper, never by the ' 'browser' : 'A token is stored by the desktop wrapper; ' 'type here only to replace it', // coverage:ignore-end helperMaxLines: 2, ), ), ], ), const SizedBox(height: 16), Wrap( spacing: 8, children: [ ElevatedButton( onPressed: _busy ? null : _save, child: const Text('Save'), ), OutlinedButton( onPressed: _busy ? null : _testConnection, // Named for what it actually does: _testConnection builds a // GitHub client and calls canAccessRepo(). It says nothing // about Firebase, and the bare label implied otherwise. child: const Text('Test GitHub connection'), ), ElevatedButton( onPressed: _busy ? null : _syncNow, child: const Text('Sync now'), ), ], ), const SizedBox(height: 24), const Divider(), const SizedBox(height: 8), Text( 'Notifications', style: Theme.of(context).textTheme.titleMedium, ), const SizedBox(height: 4), Text( _isAndroid ? 'A background check nags you every ~15 min if a ' 'meal slot is overdue. Aggressive OEM battery ' 'optimization (MIUI, some Samsung configs) can ' 'delay this well past 15 min -- request an ' 'exemption for reliable nagging.' : 'A check runs every 5 min while this window is open and ' 'notifies you about an overdue meal slot. A browser ' 'cannot run anything once the window is closed -- on ' 'the PC the real backstop is the diet_guard gate, ' 'which locks the screen instead.', style: Theme.of(context).textTheme.bodySmall, ), // Battery-optimization exemption is Android-only, and // `permission_handler` has no web implementation at all; // the row would throw rather than degrade in the browser. if (_isAndroid) ...[ const SizedBox(height: 12), OutlinedButton.icon( onPressed: _requestBatteryExemption, icon: const Icon(Icons.battery_alert), label: const Text('Disable battery optimization'), ), ], if (_status != null) ...[ const SizedBox(height: 16), Text(_status!, style: Theme.of(context).textTheme.bodyMedium), ], ], ), ), ), ); } } /// Dialog shown when "Connect GitHub" is tapped with no OAuth App client id /// configured yet. Explains what it is, how to get one, and lets the user /// paste it in directly — rather than leaving them to discover a buried /// "Advanced" field on their own. Pops the trimmed client id, or null if /// cancelled. class _ClientIdSetupDialog extends StatefulWidget { const _ClientIdSetupDialog(); @override State<_ClientIdSetupDialog> createState() => _ClientIdSetupDialogState(); } class _ClientIdSetupDialogState extends State<_ClientIdSetupDialog> { final _controller = TextEditingController(); @override void dispose() { _controller.dispose(); super.dispose(); } @override Widget build(BuildContext context) { return AlertDialog( title: const Text('One-time GitHub setup needed'), content: SingleChildScrollView( child: Column( mainAxisSize: MainAxisSize.min, crossAxisAlignment: CrossAxisAlignment.start, children: [ const Text( 'Diet Guard signs in via a GitHub OAuth App (no password ' 'typed into this app). You only have to set this up once:', ), const SizedBox(height: 12), const Text( '1. On any device, open ' 'github.com/settings/developers → "New OAuth App".\n' '2. Name/Homepage/Callback URL can be anything (device flow ' "doesn't use the callback) — e.g. " '"Diet Guard" and your GitHub profile URL.\n' '3. Check "Enable Device Flow", then click "Register ' 'application".\n' "4. Copy the Client ID shown on the app's page and paste it " 'below.', ), const SizedBox(height: 12), const Text( 'When you connect below, log in with the GitHub account that ' 'has write access to kuhyx/syncs.', ), const SizedBox(height: 16), TextField( controller: _controller, autofocus: true, decoration: const InputDecoration(labelText: 'Client ID'), ), ], ), ), actions: [ TextButton( onPressed: () => Navigator.of(context).pop(), child: const Text('Cancel'), ), FilledButton( onPressed: () { final id = _controller.text.trim(); if (id.isNotEmpty) Navigator.of(context).pop(id); }, child: const Text('Continue'), ), ], ); } } /// Dialog shown during the device flow: displays the user code, opens the /// verification page, and polls until authorized — popping the token (or /// null if cancelled / failed). class _DeviceCodeDialog extends StatefulWidget { const _DeviceCodeDialog({required this.device, required this.auth}); final DeviceCodeResponse device; final GitHubDeviceAuth auth; @override State<_DeviceCodeDialog> createState() => _DeviceCodeDialogState(); } class _DeviceCodeDialogState extends State<_DeviceCodeDialog> { String? _error; @override void initState() { super.initState(); unawaited(_poll()); } Future _poll() async { try { final token = await widget.auth.pollForToken(widget.device); if (mounted) Navigator.of(context).pop(token); } on Exception catch (e) { if (mounted) setState(() => _error = '$e'); } } Future _openPage() async { await Clipboard.setData(ClipboardData(text: widget.device.userCode)); await launchUrl( Uri.parse(widget.device.verificationUri), mode: LaunchMode.externalApplication, ); } @override Widget build(BuildContext context) { return AlertDialog( title: const Text('Authorize on GitHub'), content: Column( mainAxisSize: MainAxisSize.min, crossAxisAlignment: CrossAxisAlignment.start, children: [ const Text('Enter this code on GitHub:'), const SizedBox(height: 8), SelectableText( widget.device.userCode, style: Theme.of(context).textTheme.headlineSmall, ), const SizedBox(height: 16), if (_error == null) const Row( children: [ SizedBox( width: 16, height: 16, child: CircularProgressIndicator(strokeWidth: 2), ), SizedBox(width: 12), Expanded(child: Text('Waiting for authorization…')), ], ) else Text( _error!, style: TextStyle(color: Theme.of(context).colorScheme.error), ), ], ), actions: [ TextButton( onPressed: () => Navigator.of(context).pop(), child: const Text('Cancel'), ), FilledButton.icon( onPressed: _openPage, icon: const Icon(Icons.open_in_new), label: const Text('Open GitHub & copy code'), ), ], ); } }