There's a category of bug that only shows up in production apps — the kind that doesn't crash, doesn't throw an exception, and doesn't even look wrong on the surface. It just quietly does the wrong thing.
One of the most common in security-sensitive Flutter apps is this: the app is backgrounded, the user changes something significant — enables developer options, toggles mock location, grants a new permission — and then returns. The app resumes and carries on as if nothing happened. It trusts whatever state it had when it left. That trust is the problem.
didChangeAppLifecycleState is where you fix it.
What the Lifecycle States Actually Mean
Flutter surfaces four app-level states through AppLifecycleState:
resumed — the app is in the foreground and the user can interact with itinactive — the app is visible but not interactive (incoming call, app switcher, system dialog)paused — the app is in the background and not visibledetached — the Flutter engine is running but no UI is attached
For most security and freshness checks, resumed is the state you care about. It fires every time the app returns to the foreground — from the background, from a lock screen, from switching apps. That's the moment you want to re-examine assumptions.
Setting It Up
Add WidgetsBindingObserver to your state class, register in initState, and always remove in dispose:
class _HomeState extends State<HomeScreen> with WidgetsBindingObserver {
@override
void initState() {
super.initState();
WidgetsBinding.instance.addObserver(this);
}
@override
void dispose() {
WidgetsBinding.instance.removeObserver(this);
super.dispose();
}
@override
void didChangeAppLifecycleState(AppLifecycleState state) {
if (state == AppLifecycleState.resumed) {
_onAppResumed();
} else if (state == AppLifecycleState.paused) {
_onAppPaused();
}
}
}
The removeObserver call in dispose is not optional. Skipping it means the widget keeps receiving lifecycle callbacks after it's been removed from the tree, which can cause calls on disposed resources or setState on unmounted widgets.
Re-Validating Security on Resume
The most important use of resumed in security-sensitive apps is re-running the checks that determine whether the environment is still trustworthy. A user can:
- Enable developer options while your app is backgrounded
- Enable mock location in developer settings
- Connect a USB debugger
- Grant or revoke permissions
- Enable a VPN
None of these trigger any callback while your app is in the background. The only opportunity you have to detect them is when the app comes back to the foreground.
void _onAppResumed() {
_validateEnvironment();
}
Future<void> _validateEnvironment() async {
final isDeveloperModeEnabled = await _checkDeveloperOptions();
final isMockLocationEnabled = await _checkMockLocation();
final isRooted = await _checkRootAccess();
if (isDeveloperModeEnabled || isMockLocationEnabled || isRooted) {
_blockUsage();
}
}
This is standard behavior in banking apps, delivery tracking apps, attendance systems, and anywhere location or session integrity matters. The app doesn't assume the environment is still safe — it checks every time it resumes.
Auto Logout After Inactivity
For apps that handle sensitive data, automatic logout after a period of inactivity is a compliance requirement in many contexts. didChangeAppLifecycleState gives you a clean way to implement it:
DateTime? _pausedAt;
void _onAppPaused() {
_pausedAt = DateTime.now();
}
void _onAppResumed() {
if (_pausedAt != null) {
final elapsed = DateTime.now().difference(_pausedAt!);
if (elapsed > const Duration(minutes: 10)) {
_logoutUser();
return;
}
}
_pausedAt = null;
}
The timeout window depends on the app's sensitivity. Financial apps often use 5 minutes. The pattern is the same regardless.
Refreshing Stale Data
Rather than polling on a timer or force-refreshing every time a screen is pushed, resumed is a natural moment to check whether data needs updating:
void _onAppResumed() {
final timeSinceLastSync = DateTime.now().difference(_lastSyncTime);
if (timeSinceLastSync > const Duration(minutes: 5)) {
_refreshData();
}
}
This feels more intentional than a background timer — it only refreshes when the user actually returns to the app.
Pausing and Resuming Resources
The paused state is the right place to release resources that shouldn't run in the background:
void _onAppPaused() {
_videoController.pause();
_locationSubscription.cancel();
_animationController.stop();
}
void _onAppResumed() {
if (_shouldAutoPlay) _videoController.play();
_startLocationUpdates();
}
Cancelling the location subscription when paused and restarting it on resume prevents unnecessary GPS usage while the app isn't visible. On battery-sensitive devices, this matters.
Handling Permission Changes
A common UX scenario: your app requests a permission, the user declines, then goes to Settings and manually grants it. When they return to your app, you should detect the new permission state without asking again:
void _onAppResumed() {
_recheckPermissions();
}
Future<void> _recheckPermissions() async {
final status = await Permission.camera.status;
if (status.isGranted && !_cameraReady) {
_initializeCamera();
}
}
Silently re-checking on resume, rather than showing another permission dialog, is the right pattern here.
Using AppLifecycleListener (Newer API)
Flutter also offers AppLifecycleListener, added in Flutter 3.13, which provides named callbacks instead of a switch statement. For new code, it's cleaner:
late final AppLifecycleListener _listener;
@override
void initState() {
super.initState();
_listener = AppLifecycleListener(
onResume: _onAppResumed,
onPause: _onAppPaused,
onInactive: _onInactive,
);
}
@override
void dispose() {
_listener.dispose();
super.dispose();
}
The behavior is identical to WidgetsBindingObserver, but the intent of each callback is explicit from the name rather than requiring a switch on the state enum.
A Few Practical Notes
Keep resume logic fast. _onAppResumed fires before the UI is interactive again. If you kick off a slow API call here, the user will notice the lag. Run quick local checks synchronously; defer heavy network work.
Guard against async races. If _onAppResumed triggers an async operation, the widget might be disposed before it completes. Check mounted before calling setState in any callback that crosses an await boundary.
Centralize your checks. Rather than duplicating security or permission checks across multiple screens, keep them in a single service class. Your lifecycle handler calls into that service, and the service decides what action to take. This keeps the lifecycle handler thin and the logic testable.
The Underlying Point
An app that resumes and blindly trusts its previous state is an app that can be manipulated. The window between backgrounding and resuming is exactly when users — or bad actors — can change conditions your app depends on. didChangeAppLifecycleState is how you close that window. Use it to re-check anything your app's correctness or security depends on, and treat resumed not as a continuation of the previous session but as a fresh opportunity to verify that the environment is still what you expect.
