mirror of
https://github.com/kuhyx/screen-locker.git
synced 2026-11-20 20:32:24 +01:00
Some checks failed
dependency freshness / dependencies on newest stable (push) Has been cancelled
md-naming / markdown naming convention (push) Has been cancelled
pre-commit / pre-commit (push) Has been cancelled
Tests / test (push) Has been cancelled
Tests / lock-popup-safety (push) Has been cancelled
release-apk / release (APK) (push) Has been cancelled
The between-set break never finished once the phone's screen was off. Three independent causes (worked through on-device on 2026-09-12; left uncommitted awaiting the go-ahead, committed here as-is plus one pin bump): 1. The countdown was not wall-clock: `_breakRemaining--` on a Timer.periodic, which Android throttles and Doze suspends in a backgrounded isolate, so the counter stalled and _onBreakFinished() never fired. Now a BreakClock deadline on the wall clock. 2. An expired break was silently dropped on restore (`if (remaining > 0)` only) — now cued and logged. 3. No notification infrastructure at all: no package, no POST_NOTIFICATIONS / FOREGROUND_SERVICE / WAKE_LOCK. Now: flutter_foreground_task runs the countdown in a service isolate that survives BACK and the screen lock; flutter_local_notifications shows an ongoing "Workout A · break m:ss / Next: …" notification with −1 rep / Done actions and a "Break over" alert on its own channel (raw break_end sound, vibration). Button presses go through a persisted BreakIntent queue the screen drains on resume, so a press with the app killed is not lost. Finish and Reset stop the service; a startup reaper handles the crash case. Verified on the phone with the screen off and locked: service alive and ticking while Dozing, both notifications on the lock screen, channel importance 5 with the break_end sound. Not verifiable from adb (receiver is RECEIVER_NOT_EXPORTED): an actual action-button tap, and a true recents swipe — see stronglift_replacement/TODO-workout-app-v2.md. Also fixed en route: the break-end sound had never played in any widget test (AssetSource needs path_provider, which nothing faked, and the failure was swallowed by catchError); the queue's prune wrote back a stale list. This commit additionally: - takes the freshness gate's bump flutter_local_notifications 22.3.1; - restores web/package.json to HEAD (the tree held a stale pre-bump copy); - gives scripts/check_flutter_coverage.sh a FLUTTER_TEST_CONCURRENCY knob: the default one-isolate-per-core run peaks over 4 GiB and is OOM-killed under the resource cap. Default behaviour unchanged. Gate: flutter analyze clean, 511 tests, 3187/3187 lines (100%), pre-commit green. Not re-installed on the phone for the 22.3.1 pin: no device attached at commit time. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01C7vgacLhb4WJjxuVj2QLEP
163 lines
6.9 KiB
Dart
163 lines
6.9 KiB
Dart
|
|
import 'dart:async';
|
|
import 'dart:io' show Platform;
|
|
import 'package:flutter/material.dart';
|
|
import 'package:flutter_foreground_task/flutter_foreground_task.dart';
|
|
import 'package:sqflite_common_ffi/sqflite_ffi.dart';
|
|
import 'package:workout_app/screens/home_screen.dart';
|
|
import 'package:workout_app/services/backup_service.dart';
|
|
import 'package:workout_app/services/break_service_controller.dart';
|
|
import 'package:workout_app/services/foreground_break_client_flutter.dart';
|
|
import 'package:workout_app/services/http_server_service.dart';
|
|
import 'package:workout_app/services/lock_mode.dart';
|
|
import 'package:workout_app/services/progression_sync_service.dart';
|
|
import 'package:workout_app/services/storage_service.dart';
|
|
import 'package:workout_app/services/sync_device_id.dart';
|
|
import 'package:workout_app/ui/theme.dart';
|
|
|
|
// coverage:ignore-start
|
|
// App bootstrap: permission request, DB init, and a real listening socket —
|
|
// platform-channel work that can't run on the CI test host. The pieces it wires
|
|
// up are unit-tested individually; the entry point itself is not.
|
|
void main(List<String> args) async {
|
|
WidgetsFlutterBinding.ensureInitialized();
|
|
// The UI end of the channel the break foreground service talks back on.
|
|
// Must precede runApp, and must happen even on Linux: the call is a no-op
|
|
// where there is no service, and skipping it would mean the workout screen
|
|
// silently never hears a notification button press.
|
|
FlutterForegroundTask.initCommunicationPort();
|
|
// Must precede runApp: the UI reads this to decide whether to offer
|
|
// any way out of the workout.
|
|
lockModeEnabled = parseLockMode(args);
|
|
// Linux desktop has no sqflite plugin. The FFI factory runs the same
|
|
// schema and migrations against the same SQL, so this is a transport
|
|
// swap, not a second storage implementation. Must precede any DB open.
|
|
if (Platform.isLinux) {
|
|
sqfliteFfiInit();
|
|
databaseFactory = databaseFactoryFfi;
|
|
}
|
|
// Before anything that stamps an Hlc or syncs: until this resolves, the
|
|
// device id falls back to the pre-migration constant.
|
|
await initSyncDeviceId();
|
|
// Storage permission is settled before the DB is opened: opening it seeds
|
|
// factory defaults for any missing exercise, and restoring afterwards is a
|
|
// no-op once rows exist. Losing that race is what wiped months of
|
|
// progression on 2026-08-05.
|
|
//
|
|
// CHECKED, never requested. `request()` throws the user into a system
|
|
// Settings page on every launch where the permission is absent, and since
|
|
// Firebase now carries progression the `/sdcard` backup is a second copy
|
|
// rather than the only one. The grant prompt lives in Settings, where the
|
|
// user asks for it.
|
|
final storageGranted = await BackupService.instance.hasStoragePermission();
|
|
if (!storageGranted) {
|
|
debugPrint(
|
|
'WorkoutApp: no storage permission — the backup at $kBackupPath can '
|
|
'neither be read nor written, so progression rides on Firebase alone. '
|
|
'Grant it in Settings to keep a second, offline copy.',
|
|
);
|
|
}
|
|
await StorageService.init();
|
|
// Before the UI exists: a service left over from a crashed or force-stopped
|
|
// workout must not sit in the status bar counting down nothing.
|
|
await stopStaleBreakService(
|
|
FlutterForegroundBreakClient(),
|
|
hasActiveWorkout: () async =>
|
|
await StorageService.instance.loadActiveSession() != null,
|
|
);
|
|
await StorageService.instance.restoreFromBackupIfNeeded();
|
|
// The permission-free restore path, and the reason storage is now optional.
|
|
// `backup.json` is unreadable without the grant, so on a denied reinstall the
|
|
// line above is a no-op and this is the ONLY thing between the user and
|
|
// factory defaults. Safe to run unconditionally: it applies remote records
|
|
// only to a freshly-installed DB, so it restores a wiped install but never
|
|
// overwrites progression — or a deliberate reset — made on this phone.
|
|
//
|
|
// Bounded: this is N sequential network reads on the launch path, so a slow
|
|
// or half-open connection would otherwise hold the UI on a blank screen.
|
|
// Timing out is safe — it leaves `progression_synced_at` unset, so the next
|
|
// launch retries and, until it succeeds, pushProgression refuses to
|
|
// overwrite the remote copy.
|
|
final restored = await ProgressionSyncService()
|
|
.pullProgression()
|
|
.timeout(
|
|
const Duration(seconds: 20),
|
|
onTimeout: () => const ProgressionSyncResult(
|
|
changed: false,
|
|
reason:
|
|
'progression pull timed out after 20s — starting on local state; '
|
|
'the next launch will retry',
|
|
),
|
|
);
|
|
debugPrint('WorkoutApp: ${restored.reason}');
|
|
// Android-only transport: it exists so the PC can pull today's workout off
|
|
// the phone over LAN. On the PC itself it would bind the very port the PC
|
|
// scans, so it is skipped rather than serving the machine to itself.
|
|
if (!Platform.isLinux) {
|
|
await HttpServerService.instance.start();
|
|
}
|
|
runApp(const WorkoutApp());
|
|
}
|
|
// coverage:ignore-end
|
|
|
|
/// Root widget that bootstraps the app with Material 3 dark theming.
|
|
///
|
|
/// Also owns the app-lifecycle observer that stops [HttpServerService]'s
|
|
/// listening socket while the app is backgrounded, so the process (and its
|
|
/// open socket) doesn't sit alive indefinitely and block Doze/App-Standby.
|
|
class WorkoutApp extends StatefulWidget {
|
|
/// Creates the root app widget.
|
|
const WorkoutApp({super.key});
|
|
|
|
@override
|
|
State<WorkoutApp> createState() => _WorkoutAppState();
|
|
}
|
|
|
|
class _WorkoutAppState extends State<WorkoutApp> with WidgetsBindingObserver {
|
|
@override
|
|
void initState() {
|
|
super.initState();
|
|
WidgetsBinding.instance.addObserver(this);
|
|
}
|
|
|
|
@override
|
|
void dispose() {
|
|
WidgetsBinding.instance.removeObserver(this);
|
|
super.dispose();
|
|
}
|
|
|
|
// coverage:ignore-start
|
|
// Platform edge, same shape as storage_service_schema's: the suite runs on
|
|
// Linux, where this returns on the first line, so the switch below is
|
|
// unreachable from any test this repo can run. Covering it would mean
|
|
// threading a platform seam through the nine Platform.isLinux checks in
|
|
// this app purely for test reachability.
|
|
@override
|
|
void didChangeAppLifecycleState(AppLifecycleState state) {
|
|
// The socket is never started on Linux (see main()), so there is nothing
|
|
// to stop or restart here either.
|
|
if (Platform.isLinux) return;
|
|
switch (state) {
|
|
case AppLifecycleState.paused:
|
|
case AppLifecycleState.detached:
|
|
unawaited(HttpServerService.instance.stop());
|
|
case AppLifecycleState.resumed:
|
|
unawaited(HttpServerService.instance.start());
|
|
case AppLifecycleState.inactive:
|
|
case AppLifecycleState.hidden:
|
|
break;
|
|
}
|
|
}
|
|
// coverage:ignore-end
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
return MaterialApp(
|
|
title: 'Workout Tracker',
|
|
debugShowCheckedModeBanner: false,
|
|
theme: buildAppTheme(),
|
|
home: const HomeScreen(),
|
|
);
|
|
}
|
|
}
|