Add a way to exit/minimize the app on Android when back is pressed

osu.Framework.Android/AndroidGameActivity.cs

@@ -118,22 +118,34 @@ protected override void OnRestart()
             Bass.Start();
         }
 
+        private bool allowExiting => gameView.Host?.AllowExitingAndroid.Result.Value ?? true;
+
         public override void OnBackPressed()
         {
-            // Avoid the default implementation that does close the app.
-            // This only happens when the back button could not be captured from OnKeyDown.
+            // This method is called only when the back button was not handled by OnKeyDown and OnKeyUp.
+            // Avoid the default implementation that closes the app. Return to the home screen instead.
+            if (allowExiting)
+                MoveTaskToBack(true);
         }
 
         // On some devices and keyboard combinations the OnKeyDown event does not propagate the key event to the view.
         // Here it is done manually to ensure that the keys actually land in the view.
 
         public override bool OnKeyDown([GeneratedEnum] Keycode keyCode, KeyEvent e)
         {
+            if (keyCode == Keycode.Back && allowExiting)
+                // let the base handle it so we get the `OnBackPressed()` event.
+                return base.OnKeyDown(keyCode, e);
+
             return gameView.OnKeyDown(keyCode, e);
         }
 
         public override bool OnKeyUp([GeneratedEnum] Keycode keyCode, KeyEvent e)
         {
+            if (keyCode == Keycode.Back && allowExiting)
+                // let the base handle it so we get the `OnBackPressed()` event.
+                return base.OnKeyUp(keyCode, e);
+
             return gameView.OnKeyUp(keyCode, e);
         }
 

osu.Framework.Tests.Android/TestGameActivity.cs

@@ -2,8 +2,6 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using Android.App;
-using Android.OS;
-using Android.Views;
 using osu.Framework.Android;
 
 namespace osu.Framework.Tests.Android

osu.Framework.Tests/Visual/Platform/TestSceneAllowExitingAndroid.cs

@@ -0,0 +1,84 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Input.Events;
+using osu.Framework.Platform;
+using osuTK.Graphics;
+using osuTK.Input;
+
+namespace osu.Framework.Tests.Visual.Platform
+{
+    public class TestSceneAllowExitingAndroid : FrameworkTestScene
+    {
+        [Resolved]
+        private GameHost host { get; set; }
+
+        private readonly BindableBool allowExit = new BindableBool(true);
+
+        public TestSceneAllowExitingAndroid()
+        {
+            Children = new Drawable[]
+            {
+                new ExitVisualiser
+                {
+                    Width = 0.5f,
+                    RelativeSizeAxes = Axes.Both,
+                },
+                new EscapeVisualizer
+                {
+                    Colour = Color4.Black,
+                    RelativeSizeAxes = Axes.Both,
+                    Width = 0.5f,
+                    Anchor = Anchor.TopRight,
+                    Origin = Anchor.TopRight,
+                },
+            };
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+            host.AllowExitingAndroid.AddSource(allowExit);
+        }
+
+        [Test]
+        public void TestToggleSuspension()
+        {
+            AddToggleStep("toggle allow exit", v => allowExit.Value = v);
+        }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            host.AllowExitingAndroid.RemoveSource(allowExit);
+            base.Dispose(isDisposing);
+        }
+
+        private class ExitVisualiser : Box
+        {
+            private readonly IBindable<bool> allowExit = new Bindable<bool>();
+
+            [BackgroundDependencyLoader]
+            private void load(GameHost host)
+            {
+                allowExit.BindTo(host.AllowExitingAndroid.Result);
+                allowExit.BindValueChanged(v => Colour = v.NewValue ? Color4.Green : Color4.Red, true);
+            }
+        }
+
+        private class EscapeVisualizer : Box
+        {
+            protected override bool OnKeyDown(KeyDownEvent e)
+            {
+                if (e.Key == Key.Escape)
+                    this.FlashColour(Color4.Blue, 700, Easing.OutQuart);
+
+                return base.OnKeyDown(e);
+            }
+        }
+    }
+}

osu.Framework/Platform/GameHost.cs

@@ -70,6 +70,15 @@ public abstract class GameHost : IIpcHost, IDisposable
         /// </remarks>
         public readonly AggregateBindable<bool> AllowScreenSuspension = new AggregateBindable<bool>((a, b) => a & b, new Bindable<bool>(true));
 
+        /// <summary>
+        /// Allow exiting the app on Android when the back button is pressed.
+        /// </summary>
+        /// <remarks>
+        /// If <c>true</c>, pressing back will return to the home screen (putting the app in background and suspending it).
+        /// If <c>false</c>, the back button will be treated as <see cref="InputKey.Escape"/>.
+        /// </remarks>
+        public readonly AggregateBindable<bool> AllowExitingAndroid = new AggregateBindable<bool>((a, b) => a & b, new Bindable<bool>(true));
+
         /// <summary>
         /// For IPC messaging purposes, whether this <see cref="GameHost"/> is the primary (bound) host.
         /// </summary>