Gate phase transitions on alarm stop

Author: utsapoddar

work_timer/android/app/src/main/kotlin/com/utsapoddar/sift/TimerService.kt

@@ -42,6 +42,7 @@ class TimerService : Service() {
     private var wakeLock: android.os.PowerManager.WakeLock? = null
     private var audioFocusRequest: AudioFocusRequest? = null
     private var vibrator: Vibrator? = null
+    private var alarmGateStartedAt: Long? = null
 
     override fun onBind(intent: Intent?): IBinder? = null
 
@@ -74,6 +75,8 @@ class TimerService : Service() {
         when (intent.action) {
             ACTION_ALARM_FIRED -> {
                 currentPhaseName = intent.getStringExtra(EXTRA_PHASE_NAME) ?: currentPhaseName
+                alarmGateStartedAt = System.currentTimeMillis()
+                cancelAlarms()
                 updateNotification()
                 playAlarm()
                 // Notify Flutter if it's alive
@@ -92,6 +95,7 @@ class TimerService : Service() {
             }
             ACTION_SILENCE -> {
                 stopAlarmSound()
+                resumeAlarmsAfterGate()
                 // Also notify Flutter so the UI can react
                 sendBroadcast(Intent("com.sift.timer.alarm_notify").setPackage(packageName).apply {
                     action = ACTION_SILENCE
@@ -208,6 +212,24 @@ class TimerService : Service() {
         getSharedPreferences("sift_boot", Context.MODE_PRIVATE).edit().clear().apply()
     }
 
+    private fun resumeAlarmsAfterGate() {
+        val gateStartedAt = alarmGateStartedAt ?: return
+        val elapsedMs = (System.currentTimeMillis() - gateStartedAt).coerceAtLeast(0L)
+        val prefs = getSharedPreferences("sift_boot", Context.MODE_PRIVATE)
+        val namesStr = prefs.getString("phase_names", null) ?: return
+        val timesStr = prefs.getString("phase_times", null) ?: return
+        val names = namesStr.split(",").toTypedArray()
+        val shiftedTimes = timesStr.split(",")
+            .mapNotNull { it.toLongOrNull() }
+            .map { if (it > gateStartedAt) it + elapsedMs else it }
+            .toLongArray()
+        if (shiftedTimes.isNotEmpty()) {
+            scheduleAlarms(names, shiftedTimes)
+            savePhaseDataForBoot(names, shiftedTimes)
+        }
+        alarmGateStartedAt = null
+    }
+
     private fun playAlarm() {
         stopAlarmSound()
         requestAlarmAudioFocus()
@@ -253,7 +275,7 @@ class TimerService : Service() {
                 }
             }
             mediaPlayer?.apply {
-                isLooping = false
+                isLooping = true
                 setOnCompletionListener { mp ->
                     if (mediaPlayer == mp) {
                         try { mp.release() } catch (_: Exception) {}

work_timer/lib/screens/home_screen.dart

@@ -15,6 +15,7 @@ import '../services/durable_stats.dart';
 import '../services/milestones.dart';
 import '../services/live_activity.dart';
 import '../services/notifications.dart';
+import '../services/phase_alarm_gate.dart';
 import 'milestone_screen.dart';
 
 const _accent = Color(0xFFF97316);
@@ -44,6 +45,9 @@ class _HomeScreenState extends State<HomeScreen>
   int _totalPausedMs = 0;
   bool _alarmPlaying = false;
   bool _sessionComplete = false;
+  bool _waitingForAlarmStop = false;
+  DateTime? _alarmGateStart;
+  int? _pendingPhaseIndexAfterAlarm;
   int _lastPhaseIndex = -1;
   String? _ringtonePath;
   StreamSubscription<void>? _alarmCompleteSub;
@@ -89,7 +93,7 @@ class _HomeScreenState extends State<HomeScreen>
       if (!mounted) return;
       if (_sessionComplete) {
         _stop();
-      } else {
+      } else if (!_waitingForAlarmStop) {
         setState(() => _alarmPlaying = false);
       }
     });
@@ -527,6 +531,9 @@ class _HomeScreenState extends State<HomeScreen>
       _pauseStart = null;
       _totalPausedMs = 0;
       _sessionComplete = false;
+      _waitingForAlarmStop = false;
+      _alarmGateStart = null;
+      _pendingPhaseIndexAfterAlarm = null;
       _lastPhaseIndex = -1;
     });
     await _persistActiveSession();
@@ -561,9 +568,17 @@ class _HomeScreenState extends State<HomeScreen>
     }
   }
 
-  Future<void> _triggerAlarm() async {
-    setState(() => _alarmPlaying = true);
-    await playAlarm();
+  Future<void> _triggerAlarm({required int pendingPhaseIndex}) async {
+    _ticker?.cancel();
+    _ticker = null;
+    setState(() {
+      _waitingForAlarmStop = true;
+      _alarmGateStart = DateTime.now();
+      _pendingPhaseIndexAfterAlarm = pendingPhaseIndex;
+      _alarmPlaying = true;
+    });
+    unawaited(_persistActiveSession());
+    await playAlarm(loop: true);
   }
 
   Future<void> _stopAlarm({bool nativeOrigin = false}) async {
@@ -573,9 +588,56 @@ class _HomeScreenState extends State<HomeScreen>
     }
     if (_sessionComplete) {
       _stop();
-    } else {
-      setState(() => _alarmPlaying = false);
+      return;
+    }
+
+    final schedule = _schedule;
+    final gateStart = _alarmGateStart;
+    final pendingPhaseIndex = _pendingPhaseIndexAfterAlarm;
+    if (_waitingForAlarmStop &&
+        schedule != null &&
+        gateStart != null &&
+        pendingPhaseIndex != null &&
+        pendingPhaseIndex < schedule.phases.length) {
+      final resolved = resolvePhaseAlarmGate(
+        totalPausedMs: _totalPausedMs,
+        gateStartedAt: gateStart,
+        stoppedAt: DateTime.now(),
+        pendingPhaseIndex: pendingPhaseIndex,
+      );
+      _totalPausedMs = resolved.totalPausedMs;
+      _lastPhaseIndex = resolved.activePhaseIndex;
+      final now = DateTime.now().subtract(
+        Duration(milliseconds: _totalPausedMs),
+      );
+      final phase = schedule.phases[resolved.activePhaseIndex];
+      setState(() {
+        _waitingForAlarmStop = false;
+        _alarmGateStart = null;
+        _pendingPhaseIndexAfterAlarm = null;
+        _alarmPlaying = false;
+        _phaseIndex = resolved.activePhaseIndex;
+        _remaining = phase.remaining(now);
+        _phaseProgress = phase.progress(now);
+      });
+      unawaited(_persistActiveSession());
+      unawaited(scheduleAll(schedule, offsetMs: _totalPausedMs));
+      unawaited(
+        startTimerService(
+          phaseNames: schedule.phases.map((p) => p.phase.name).toList(),
+          phaseEndTimes: shiftedPhaseEndTimes(schedule, _totalPausedMs),
+        ),
+      );
+      _ticker = Timer.periodic(const Duration(seconds: 1), (_) => _tick());
+      return;
     }
+
+    setState(() {
+      _waitingForAlarmStop = false;
+      _alarmGateStart = null;
+      _pendingPhaseIndexAfterAlarm = null;
+      _alarmPlaying = false;
+    });
   }
 
   void _stop() async {
@@ -599,6 +661,9 @@ class _HomeScreenState extends State<HomeScreen>
       _pauseStart = null;
       _totalPausedMs = 0;
       _alarmPlaying = false;
+      _waitingForAlarmStop = false;
+      _alarmGateStart = null;
+      _pendingPhaseIndexAfterAlarm = null;
       _sessionComplete = false;
       _pendingMilestone = null;
       _phaseIndex = 0;
@@ -688,7 +753,7 @@ class _HomeScreenState extends State<HomeScreen>
 
   void _tick() {
     final schedule = _schedule;
-    if (schedule == null) return;
+    if (schedule == null || _waitingForAlarmStop) return;
 
     final now = DateTime.now().subtract(Duration(milliseconds: _totalPausedMs));
     final idx = schedule.currentPhaseIndex(now);
@@ -699,7 +764,7 @@ class _HomeScreenState extends State<HomeScreen>
       unawaited(_onSessionComplete());
       setState(() => _sessionComplete = true);
       unawaited(cancelNotification(schedule.phases.length - 1));
-      _triggerAlarm();
+      _triggerAlarm(pendingPhaseIndex: schedule.phases.length);
       return;
     }
 
@@ -708,18 +773,24 @@ class _HomeScreenState extends State<HomeScreen>
     final progress = phase.progress(now);
 
     if (idx != _lastPhaseIndex && _lastPhaseIndex != -1) {
-      // Cancel the notification for the completed phase — app handles alarm in-app
+      final completedPhase = schedule.phases[_lastPhaseIndex];
       unawaited(cancelNotification(_lastPhaseIndex));
-      _triggerAlarm();
+      setState(() {
+        _phaseIndex = _lastPhaseIndex;
+        _remaining = Duration.zero;
+        _phaseProgress = 1.0;
+      });
       updateLiveActivity(
-        phaseName: phase.phase.name,
-        phaseEndTime: phase.endTime,
-        remainingSeconds: remaining.inSeconds,
-        totalSeconds: phase.phase.duration.inSeconds,
-        isBreak: phase.phase.isBreak,
+        phaseName: completedPhase.phase.name,
+        phaseEndTime: completedPhase.endTime,
+        remainingSeconds: 0,
+        totalSeconds: completedPhase.phase.duration.inSeconds,
+        isBreak: completedPhase.phase.isBreak,
         isPaused: false,
-        alarmPlaying: _alarmPlaying,
+        alarmPlaying: true,
       );
+      _triggerAlarm(pendingPhaseIndex: idx);
+      return;
     }
     _lastPhaseIndex = idx;
 

work_timer/lib/services/audio.dart

@@ -18,10 +18,11 @@ void _ensureVibrationStopsOnCompletion() {
   });
 }
 
-Future<void> playAlarm() async {
+Future<void> playAlarm({bool loop = false}) async {
   _ensureVibrationStopsOnCompletion();
   try {
     await _player.stop();
+    await _player.setReleaseMode(loop ? ReleaseMode.loop : ReleaseMode.release);
     stopAlarmVibration();
     if (Platform.isAndroid) {
       await _player.setAudioContext(
@@ -64,5 +65,6 @@ Future<void> stopAlarm() async {
   stopAlarmVibration();
   try {
     await _player.stop();
+    await _player.setReleaseMode(ReleaseMode.release);
   } catch (_) {}
 }

work_timer/lib/services/phase_alarm_gate.dart

@@ -0,0 +1,22 @@
+class PhaseAlarmGateResolution {
+  final int totalPausedMs;
+  final int activePhaseIndex;
+
+  const PhaseAlarmGateResolution({
+    required this.totalPausedMs,
+    required this.activePhaseIndex,
+  });
+}
+
+PhaseAlarmGateResolution resolvePhaseAlarmGate({
+  required int totalPausedMs,
+  required DateTime gateStartedAt,
+  required DateTime stoppedAt,
+  required int pendingPhaseIndex,
+}) {
+  final gateMs = stoppedAt.difference(gateStartedAt).inMilliseconds;
+  return PhaseAlarmGateResolution(
+    totalPausedMs: totalPausedMs + (gateMs < 0 ? 0 : gateMs),
+    activePhaseIndex: pendingPhaseIndex,
+  );
+}

work_timer/pubspec.yaml

@@ -2,7 +2,7 @@ name: work_timer
 description: "Work session timer with automatic break scheduling."
 publish_to: 'none'
 
-version: 1.0.15+15
+version: 1.0.16+16
 environment:
   sdk: ^3.11.3
 

work_timer/test/phase_alarm_gate_test.dart

@@ -0,0 +1,19 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:work_timer/services/phase_alarm_gate.dart';
+
+void main() {
+  test('stopping a phase alarm shifts future phases by alarm wait time', () {
+    final gateStart = DateTime.fromMillisecondsSinceEpoch(10000);
+    final stoppedAt = DateTime.fromMillisecondsSinceEpoch(25000);
+
+    final resolved = resolvePhaseAlarmGate(
+      totalPausedMs: 2000,
+      gateStartedAt: gateStart,
+      stoppedAt: stoppedAt,
+      pendingPhaseIndex: 1,
+    );
+
+    expect(resolved.totalPausedMs, 17000);
+    expect(resolved.activePhaseIndex, 1);
+  });
+}