feat!: Pause game when backgrounded

.github/.cspell/gamedev_dictionary.txt

@@ -24,6 +24,8 @@ arial # name of a typeface
 arities # plural of arity
 arity # number of parameters a function takes
 autofocus # auto focus event
+backgrounded # moving the app to the background
+backgrounding # moving the app to the background
 backpressure # strategy to deal with excess flow of data
 backquote # another word for backtick
 backtick # the back tick character "`"
@@ -39,6 +41,7 @@ coord # coordinate
 coords # plural of coord
 deduplication # removal of duplicates
 easings # Easing functions specify the rate of change of a parameter over time
+foregrounded # moving the app to the foreground
 fullscreen # mode in which a program or app occupies the entire screen with no borders
 goldens # test files used as reference for Golden Tests
 hardcoding # putting a value as a literal instead of computing it

doc/flame/game.md

@@ -226,3 +226,21 @@ While the game is paused, it is possible to advanced it frame by frame using the
 method.
 It might not be much useful in the final game, but can be very helpful in inspecting game state step
 by step during the development cycle.
+
+
+### Backgrounding
+
+The game will be automatically paused when the app is sent to the background,
+and resumed when it comes back to the foreground. This behavior can be disabled by setting
+`pauseWhenBackgrounded` to `false`.
+
+```dart
+class MyGame extends FlameGame {
+  MyGame() {
+    pauseWhenBackgrounded = false;
+  }
+}
+```
+
+On the current Flutter stable (3.13), this flag is effectively ignored on
+non-mobile platforms including the web.

packages/flame/lib/src/game/flame_game.dart

@@ -255,4 +255,44 @@ class FlameGame<W extends World> extends ComponentTreeRoot
       }
     }
   }
+
+  /// Whether the game should pause when the app is backgrounded.
+  ///
+  /// On the latest Flutter stable at the time of writing (3.13),
+  /// this is only working on Android and iOS.
+  ///
+  /// Defaults to true.
+  bool pauseWhenBackgrounded = true;
+  bool _pausedBecauseBackgrounded = false;
+
+  @override
+  @mustCallSuper
+  void lifecycleStateChange(AppLifecycleState state) {
+    switch (state) {
+      case AppLifecycleState.resumed:
+      case AppLifecycleState.inactive:
+        if (_pausedBecauseBackgrounded) {
+          resumeEngine();
+        }
+      case AppLifecycleState.paused:
+      case AppLifecycleState.detached:
+      case AppLifecycleState.hidden:
+        if (pauseWhenBackgrounded && !paused) {
+          pauseEngine();
+          _pausedBecauseBackgrounded = true;
+        }
+    }
+  }
+
+  @override
+  void pauseEngine() {
+    _pausedBecauseBackgrounded = false;
+    super.pauseEngine();
+  }
+
+  @override
+  void resumeEngine() {
+    _pausedBecauseBackgrounded = false;
+    super.resumeEngine();
+  }
 }

packages/flame/lib/src/game/game_widget/game_widget.dart

@@ -254,6 +254,9 @@ class GameWidgetState<T extends Game> extends State<GameWidget<T>> {
       currentGame = widget.game!;
     }
     currentGame.addGameStateListener(_onGameStateChange);
+    currentGame.lifecycleStateChange(
+      WidgetsBinding.instance.lifecycleState ?? AppLifecycleState.resumed,
+    );
     _loaderFuture = null;
   }
 
@@ -262,6 +265,7 @@ class GameWidgetState<T extends Game> extends State<GameWidget<T>> {
   /// `currentGame`'s `onDispose` method will be called; otherwise, it will not.
   void disposeCurrentGame({bool callGameOnDispose = false}) {
     currentGame.removeGameStateListener(_onGameStateChange);
+    currentGame.lifecycleStateChange(AppLifecycleState.paused);
     currentGame.onRemove();
     if (callGameOnDispose) {
       currentGame.onDispose();

packages/flame/test/game/flame_game_test.dart

@@ -9,8 +9,8 @@ import 'package:flame/game.dart';
 import 'package:flame/src/events/flame_game_mixins/multi_tap_dispatcher.dart';
 import 'package:flame/src/game/game_render_box.dart';
 import 'package:flame_test/flame_test.dart';
+import 'package:flutter/material.dart';
 import 'package:flutter/rendering.dart';
-import 'package:flutter/widgets.dart';
 import 'package:flutter_test/flutter_test.dart';
 
 import '../components/component_test.dart';
@@ -47,8 +47,8 @@ void main() {
       await game.ready();
 
       expect(innerGame.canvasSize, closeToVector(Vector2(800, 600)));
-      expect(innerGame.isLoaded, true);
-      expect(innerGame.isMounted, true);
+      expect(innerGame.isLoaded, isTrue);
+      expect(innerGame.isMounted, isTrue);
     });
 
     group('components', () {
@@ -58,8 +58,8 @@ void main() {
           final component = Component();
           await game.ensureAdd(component);
 
-          expect(component.isMounted, true);
-          expect(game.children.contains(component), true);
+          expect(component.isMounted, isTrue);
+          expect(game.children.contains(component), isTrue);
         },
       );
 
@@ -69,7 +69,7 @@ void main() {
           final component = _MyAsyncComponent();
           await game.ensureAdd(component);
 
-          expect(game.children.contains(component), true);
+          expect(game.children.contains(component), isTrue);
           expect(component.gameSize, game.size);
           expect(component.game, game);
         },
@@ -128,12 +128,12 @@ void main() {
           await game.add(component);
           renderBox.gameLoopCallback(1.0);
 
-          expect(component.isUpdateCalled, true);
+          expect(component.isUpdateCalled, isTrue);
           renderBox.paint(
             PaintingContext(ContainerLayer(), Rect.zero),
             Offset.zero,
           );
-          expect(component.isRenderCalled, true);
+          expect(component.isRenderCalled, isTrue);
           renderBox.detach();
         },
       );
@@ -165,7 +165,7 @@ void main() {
           expect(world.children.length, equals(1));
           component.removeFromParent();
           game.updateTree(0);
-          expect(world.children.isEmpty, equals(true));
+          expect(world.children.isEmpty, equals(isTrue));
         },
       );
 
@@ -175,7 +175,7 @@ void main() {
           final game = FlameGame();
           final world = game.world;
           final component = Component()..addToParent(world);
-          expect(game.hasLayout, false);
+          expect(game.hasLayout, isFalse);
 
           await tester.pumpWidget(GameWidget(game: game));
           game.update(0);
@@ -698,6 +698,66 @@ void main() {
         });
       });
     });
+
+    group('pauseWhenBackgrounded:', () {
+      testWithFlameGame('true', (game) async {
+        game.pauseWhenBackgrounded = true;
+
+        game.lifecycleStateChange(AppLifecycleState.paused);
+        expect(game.paused, isTrue);
+
+        game.lifecycleStateChange(AppLifecycleState.resumed);
+        expect(game.paused, isFalse);
+      });
+
+      testWithFlameGame('false', (game) async {
+        game.pauseWhenBackgrounded = false;
+
+        game.lifecycleStateChange(AppLifecycleState.paused);
+        expect(game.paused, isFalse);
+
+        game.lifecycleStateChange(AppLifecycleState.resumed);
+        expect(game.paused, isFalse);
+      });
+
+      testWidgets(
+        'game is not paused on start',
+        (tester) async {
+          final game = FlameGame();
+
+          await tester.pumpWidget(
+            GameWidget(game: game),
+          );
+
+          await game.toBeLoaded();
+          await tester.pump();
+
+          expect(game.paused, isFalse);
+        },
+      );
+
+      testWidgets(
+        'game is paused when app is backgrounded',
+        (tester) async {
+          final game = FlameGame();
+
+          await tester.pumpWidget(GameWidget(game: game));
+
+          await game.toBeLoaded();
+          await tester.pump();
+
+          expect(game.paused, isFalse);
+          WidgetsBinding.instance.handleAppLifecycleStateChanged(
+            AppLifecycleState.paused,
+          );
+          expect(game.paused, isTrue);
+          WidgetsBinding.instance.handleAppLifecycleStateChanged(
+            AppLifecycleState.resumed,
+          );
+          expect(game.paused, isFalse);
+        },
+      );
+    });
   });
 }