mirror of
https://github.com/kuhyx/diet-guard.git
synced 2026-11-19 23:14:25 +01:00
Four things about the sync settings read wrong on the phone, all of them left over from when GitHub was the only backend: - "Connect GitHub" sat on the primary path as a peer of "Connect Firebase", implying a choice. It is not one: GitHub is the cutover mirror. Its whole configuration -- device-flow OAuth, owner, repo, client id, PAT fallback -- now lives under "Advanced (GitHub mirror)". - "Test connection" builds a GitHubClient and calls canAccessRepo(). It has never said anything about Firebase, so it is now "Test GitHub connection", and its result messages name GitHub too. - Once connected, the account still rendered as an editable email box beside an empty password box, which reads as "you still have to enter this" -- a connected device looked unconfigured. It now shows the account as text with a Disconnect button, and the form appears only when disconnected. Also pins crdt-sync v0.5.1 (from v0.3.0), the shared-config release the Firebase cutover needs; verified importable under /usr/bin/python3, which is what diet-guard-gate.service actually runs. Adds coverage for both Firebase states, which had none: the disconnected form and the connected read-only display. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_017FH32BgGQbQLDstBhR26Xa
748 lines
27 KiB
Dart
748 lines
27 KiB
Dart
/// 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<PermissionStatus> Function()? requestBatteryExemption;
|
|
|
|
@override
|
|
State<SettingsScreen> createState() => _SettingsScreenState();
|
|
}
|
|
|
|
class _SettingsScreenState extends State<SettingsScreen> {
|
|
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<void> _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<void> _connectGitHub() async {
|
|
var clientId = _clientIdController.text.trim();
|
|
if (clientId.isEmpty) {
|
|
final entered = await showDialog<String>(
|
|
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<String>(
|
|
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<void> _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<void> _save() async {
|
|
setState(() => _busy = true);
|
|
await _currentSettings().save();
|
|
if (!mounted) return;
|
|
setState(() => _busy = false);
|
|
_showMessage('Saved.');
|
|
}
|
|
|
|
Future<void> _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<void> _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<void> _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<void> _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<void> _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<void> _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<void> _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'),
|
|
),
|
|
],
|
|
);
|
|
}
|
|
}
|