mirror of
https://github.com/kuhyx/wake-alarm.git
synced 2026-11-22 21:02:17 +01:00
The alarm was opt-in: it only armed when the user tapped "Set Alarm & Sync to PC", so it could be defeated by simply not tapping it, or by cancelling it the night before. It is now automatic and there is no lever a half-asleep user can pull that buys them sleep. - AlarmPolicy bakes the schedule in at 08:00 daily. The only edit the UI offers is moving the NEXT alarm earlier; setEarlier() refuses anything at or after the baseline, and refuses to relax an active override. Earlier-only is the whole design: every available change costs the user sleep. - The ratchet resets after each fire, so an early start is one-shot. A one-way ratchet with no reset is a trap, not a defence — the first 05:00 would otherwise be permanent with no way back short of reinstalling. - load() re-validates the stored value and ignores anything at or after the baseline. SharedPreferences is not a trust boundary. - No cancel. The Kotlin handler is deleted, not just the Dart wrapper, so the capability genuinely does not exist rather than being one invokeMethod away. - Arming happens in main()'s init seam and via AlarmWatchdog, a daily self-rescheduling check that re-arms if nothing is scheduled — closing the gap where a force-stop or a failed re-arm goes unnoticed until the morning it does not ring. BootReceiver re-establishes it, since setInexactRepeating does not survive a reboot. - Publishing to the PC is automatic too; it used to need the same tap. PC half, so the two agree with the network down: - FALLBACK_ALARM_HOUR 13 -> 8, matching the phone's baseline. At 13:00 a Firebase outage silently moved the alarm five hours LATER — the one direction the design refuses to allow. - _trigger._clamp_to_baseline() refuses any resolved alarm later than the baseline, whatever its source. Without it the PC would faithfully reproduce a stale or tampered remote value and the forbidden direction stays reachable through sync. Tests: 465 Python at 100% branch coverage, 79 Dart. Both ratchet directions are covered, per the standing rule about monotonic counters. test_sync.py and test_trigger.py were split (payload, token, CLI, clamp) to stay under the 250-line gate; the split lost indirect coverage of extract_hlc/newest_alarm, which now have direct tests instead. `python -m wake_alarm._sync --show` and `_trigger --dry-run` both re-run and still print real output. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01EckWmyfetYq3Mi8MAnUudh
220 lines
7.1 KiB
Dart
220 lines
7.1 KiB
Dart
import 'dart:async';
|
|
import 'dart:developer' as developer;
|
|
|
|
import 'package:flutter/material.dart';
|
|
import 'package:wake_alarm_sync/services/alarm_policy.dart';
|
|
import 'package:wake_alarm_sync/services/alarm_scheduler.dart';
|
|
import 'package:wake_alarm_sync/services/challenge.dart';
|
|
import 'package:wake_alarm_sync/services/room_proof.dart';
|
|
import 'package:wake_alarm_sync/services/room_proof_settings.dart';
|
|
|
|
/// The dismiss screen shown over the lockscreen while the alarm rings.
|
|
///
|
|
/// Two gates, in order: prove you are in the other room, then solve a
|
|
/// challenge. Only then does the sound stop.
|
|
class RingScreen extends StatefulWidget {
|
|
/// Creates the ring screen; both dependencies are injectable for tests.
|
|
const RingScreen({super.key, this.scheduler, this.generator});
|
|
|
|
/// Platform bridge; defaults to the real MethodChannel.
|
|
final AlarmScheduler? scheduler;
|
|
|
|
/// Challenge source; defaults to a secure-random generator.
|
|
final ChallengeGenerator? generator;
|
|
|
|
@override
|
|
State<RingScreen> createState() => _RingScreenState();
|
|
}
|
|
|
|
class _RingScreenState extends State<RingScreen> {
|
|
late final AlarmScheduler _scheduler = widget.scheduler ?? AlarmScheduler();
|
|
late final ChallengeGenerator _generator =
|
|
widget.generator ?? ChallengeGenerator();
|
|
RoomProof _proof = RoomProof(scheduler: AlarmScheduler());
|
|
RoomProofSettings _settings = const RoomProofSettings();
|
|
bool _nfcAvailable = false;
|
|
late Challenge _challenge = _generator.next();
|
|
|
|
final TextEditingController _input = TextEditingController();
|
|
final Stopwatch _elapsed = Stopwatch()..start();
|
|
|
|
/// Whether the room proof has been satisfied; the challenge is gated on it.
|
|
bool _inRoom = false;
|
|
String _status = '';
|
|
|
|
|
|
@override
|
|
void initState() {
|
|
super.initState();
|
|
_proof = RoomProof(scheduler: _scheduler);
|
|
unawaited(_scheduler.beginStepCount());
|
|
unawaited(_loadRoomProof());
|
|
}
|
|
|
|
/// Loads the registered tag/QR and starts listening for NFC taps.
|
|
Future<void> _loadRoomProof() async {
|
|
final settings = await RoomProofSettings.load();
|
|
final hasNfc = await _scheduler.hasNfc();
|
|
if (!mounted) return;
|
|
setState(() {
|
|
_settings = settings;
|
|
_nfcAvailable = hasNfc;
|
|
_proof = RoomProof(
|
|
scheduler: _scheduler,
|
|
registeredTagId: settings.nfcTagId,
|
|
);
|
|
});
|
|
_scheduler.onNfcTag(_onNfcTag);
|
|
}
|
|
|
|
void _onNfcTag(String tagId) {
|
|
final result = _proof.checkNfc(tagId);
|
|
developer.log(
|
|
'nfc tag=$tagId satisfied=${result.satisfied} detail=${result.detail}',
|
|
name: 'WakeAlarmRing',
|
|
);
|
|
if (!mounted) return;
|
|
setState(() {
|
|
_inRoom = result.satisfied;
|
|
_status = result.detail;
|
|
});
|
|
if (result.satisfied) _logChallenge();
|
|
}
|
|
|
|
/// Logs the current challenge so a hardware test can be scripted.
|
|
///
|
|
/// Debug aid only: the answer is already on screen for whoever is holding
|
|
/// the phone, so this leaks nothing the user cannot see.
|
|
void _logChallenge() {
|
|
developer.log(
|
|
'challenge kind=${_challenge.kind.name} display="${_challenge.display}" '
|
|
'answer=${_challenge.answer}',
|
|
name: 'WakeAlarmRing',
|
|
);
|
|
}
|
|
|
|
/// Called by the QR scanner when a code is decoded.
|
|
void onQrScanned(String payload) {
|
|
final result = _proof.checkQr(payload, expected: _settings.qrPayload ?? '');
|
|
if (!mounted) return;
|
|
setState(() {
|
|
_inRoom = result.satisfied;
|
|
_status = result.detail;
|
|
});
|
|
}
|
|
|
|
@override
|
|
void dispose() {
|
|
_scheduler.clearNfcListener();
|
|
_input.dispose();
|
|
_elapsed.stop();
|
|
super.dispose();
|
|
}
|
|
|
|
Future<void> _trySteps() async {
|
|
final result = await _proof.checkSteps(_elapsed.elapsed);
|
|
developer.log(
|
|
'steps satisfied=${result.satisfied} detail=${result.detail}',
|
|
name: 'WakeAlarmRing',
|
|
);
|
|
if (!mounted) return;
|
|
setState(() {
|
|
_inRoom = result.satisfied;
|
|
_status = result.detail;
|
|
});
|
|
if (result.satisfied) _logChallenge();
|
|
}
|
|
|
|
void _submit() {
|
|
if (!_challenge.accepts(_input.text)) {
|
|
setState(() {
|
|
_status = 'Wrong — here is another one';
|
|
_challenge = _generator.next();
|
|
_input.clear();
|
|
});
|
|
return;
|
|
}
|
|
setState(() => _status = 'Dismissed');
|
|
unawaited(_finishDismiss());
|
|
}
|
|
|
|
/// Stops the ring, then closes this screen.
|
|
///
|
|
/// Ordered: the sound must stop even if closing the window fails.
|
|
Future<void> _finishDismiss() async {
|
|
developer.log('dismiss: stopping ring', name: 'WakeAlarmRing');
|
|
await _scheduler.dismiss();
|
|
// A one-shot earlier start applies to this alarm only. Without the reset
|
|
// the first early morning would become permanent, with no way back to the
|
|
// 08:00 baseline short of reinstalling — a ratchet with no reset is a
|
|
// trap, not a defence.
|
|
await AlarmPolicy.resetAfterFire();
|
|
developer.log('dismiss: closing screen', name: 'WakeAlarmRing');
|
|
await _scheduler.closeRingScreen();
|
|
}
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
final theme = Theme.of(context);
|
|
return PopScope(
|
|
// The alarm cannot be escaped with back; dismissing is the only way out.
|
|
canPop: false,
|
|
child: Scaffold(
|
|
body: SafeArea(
|
|
child: Padding(
|
|
padding: const EdgeInsets.all(24),
|
|
child: Column(
|
|
mainAxisAlignment: MainAxisAlignment.center,
|
|
children: <Widget>[
|
|
Text('Wake up', style: theme.textTheme.headlineMedium),
|
|
const SizedBox(height: 24),
|
|
if (!_inRoom) ..._roomGate(theme) else ..._challengeGate(theme),
|
|
const SizedBox(height: 16),
|
|
Text(_status, style: theme.textTheme.bodyMedium),
|
|
],
|
|
),
|
|
),
|
|
),
|
|
),
|
|
);
|
|
}
|
|
|
|
List<Widget> _roomGate(ThemeData theme) => <Widget>[
|
|
Text(
|
|
_nfcAvailable && _settings.nfcTagId != null
|
|
? 'Go to the other room and tap the NFC tag.'
|
|
: 'Go to the other room: scan the QR code, or walk '
|
|
'${RoomProof.requiredSteps} steps.',
|
|
textAlign: TextAlign.center,
|
|
style: theme.textTheme.bodyLarge,
|
|
),
|
|
const SizedBox(height: 16),
|
|
// The steps fallback stays reachable even when NFC is registered: a
|
|
// single failing mechanism at 06:00 must never make the alarm
|
|
// undismissable.
|
|
FilledButton(onPressed: _trySteps, child: const Text('Check steps')),
|
|
];
|
|
|
|
List<Widget> _challengeGate(ThemeData theme) => <Widget>[
|
|
Text(_challenge.hint, style: theme.textTheme.bodyLarge),
|
|
const SizedBox(height: 12),
|
|
Text(
|
|
// Always visible: a challenge that hides itself is unsolvable when the
|
|
// user reaches the screen seconds later, having walked to another room.
|
|
_challenge.display,
|
|
textAlign: TextAlign.center,
|
|
style: theme.textTheme.displaySmall,
|
|
),
|
|
const SizedBox(height: 16),
|
|
TextField(
|
|
controller: _input,
|
|
autofocus: true,
|
|
textCapitalization: TextCapitalization.characters,
|
|
decoration: const InputDecoration(labelText: 'Answer'),
|
|
onSubmitted: (_) => _submit(),
|
|
),
|
|
const SizedBox(height: 16),
|
|
FilledButton(onPressed: _submit, child: const Text('Dismiss')),
|
|
];
|
|
}
|