Fix S Pen stuck top-left + rewrite TreatAsTouch as TouchInput; Back exits on Android

Agent-Logs-Url: https://github.com/winnerspiros/osu/sessions/b47fdb81-471e-4b32-bd21-242b71bf8ed3

Co-authored-by: winnerspiros <1675249+winnerspiros@users.noreply.github.com>

Author: Copilot

osu.Android/Input/AndroidStylusHandler.cs

@@ -5,6 +5,7 @@
 using System.Runtime.CompilerServices;
 using Android.Views;
 using osu.Framework.Bindables;
+using osu.Framework.Input;
 using osu.Framework.Input.Handlers;
 using osu.Framework.Input.Handlers.Tablet;
 using osu.Framework.Input.StateChanges;
@@ -40,6 +41,16 @@ public class AndroidStylusHandler : InputHandler, ITabletHandler
         private readonly Bindable<TabletInfo?> tablet = new Bindable<TabletInfo?>();
 
         private bool lastLeftDown;
+        private bool lastTouchActive;
+
+        /// <summary>
+        /// Mirrored from <see cref="osu.Game.Configuration.OsuSetting.AndroidStylusAsTouch"/>.
+        /// When true, stylus events are enqueued as <see cref="TouchInput"/> (TouchSource.Touch1)
+        /// instead of <see cref="MousePositionAbsoluteInput"/> + <see cref="MouseButtonInput"/>.
+        /// Held as a volatile field so the OS dispatch thread can read it without
+        /// crossing the managed-config bindable lock on every motion event.
+        /// </summary>
+        public volatile bool TreatAsTouch;
 
         // Cached area values for hot path (avoids bindable access per event).
         private float areaLeft, areaTop, areaWidth, areaHeight;
@@ -147,11 +158,20 @@ public bool HandleMotionEvent(MotionEvent e)
 
             if (actionMasked == MotionEventActions.HoverExit || actionMasked == MotionEventActions.Up || actionMasked == MotionEventActions.Cancel)
             {
-                if (lastLeftDown) { PendingInputs.Enqueue(new MouseButtonInput(MouseButton.Left, false)); lastLeftDown = false; }
+                releaseAllButtons();
 
                 if (actionMasked != MotionEventActions.HoverExit)
                     return true;
             }
+            else if (actionMasked == MotionEventActions.HoverEnter)
+            {
+                // Reset stale button/touch state across sleep / focus-regain cycles. The
+                // previous hover session may have ended without a clean Up if the OS
+                // dropped the activity; without this reset the next first sample can
+                // strand `lastLeftDown=true` (or `lastTouchActive=true`) and produce a
+                // phantom hold from wherever the cursor last was.
+                releaseAllButtons();
+            }
 
             // Process all batched historical events for maximum accuracy.
             int historySize = e.HistorySize;
@@ -163,6 +183,24 @@ public bool HandleMotionEvent(MotionEvent e)
             return true;
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private void releaseAllButtons()
+        {
+            if (lastLeftDown)
+            {
+                PendingInputs.Enqueue(new MouseButtonInput(MouseButton.Left, false));
+                lastLeftDown = false;
+            }
+
+            if (lastTouchActive)
+            {
+                PendingInputs.Enqueue(new TouchInput(new[] { new Touch(TouchSource.Touch1, lastTouchPosition) }, false));
+                lastTouchActive = false;
+            }
+        }
+
+        private Vector2 lastTouchPosition;
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private void handlePointer(MotionEvent e, int historyIndex, MotionEventActions actionMasked)
         {
@@ -173,6 +211,19 @@ private void handlePointer(MotionEvent e, int historyIndex, MotionEventActions a
             float rawY = historyIndex < 0 ? e.GetY(pointer_index) : e.GetHistoricalY(pointer_index, historyIndex);
             float pressure = historyIndex < 0 ? e.GetPressure(pointer_index) : e.GetHistoricalPressure(pointer_index, historyIndex);
 
+            // Drop (0, 0, 0) garbage samples. The Samsung digitizer occasionally emits a
+            // single (rawX=0, rawY=0, pressure=0) sample when the pen wakes up after sleep,
+            // when the activity regains focus, or as the very first HoverEnter sample
+            // before the real coordinate is latched. Mapping that sample produces a snap
+            // to the top-left of the screen — the long-standing "S Pen stuck top-left"
+            // bug. A real pen sample would always have *some* coordinate (the pen is
+            // physically *somewhere* on the digitizer to have triggered an event), so a
+            // strict triple-zero match is a safe filter that doesn't drop legitimate
+            // edge-of-digitizer samples (which would have pressure > 0 on contact, or
+            // non-zero hover Y/X off the screen origin).
+            if (rawX == 0f && rawY == 0f && pressure == 0f)
+                return;
+
             // Auto-expand tablet size if the digitizer reports coordinates beyond current bounds.
             // Compares against cached field values to avoid the bindable read + property access on
             // every historical sample (which can fire 5-20× per MotionEvent on busy stylus drags).
@@ -214,7 +265,18 @@ private void handlePointer(MotionEvent e, int historyIndex, MotionEventActions a
                 mappedY = rawY;
             }
 
-            PendingInputs.Enqueue(new MousePositionAbsoluteInput { Position = new Vector2(mappedX, mappedY) });
+            var mappedPos = new Vector2(mappedX, mappedY);
+
+            // Belt-and-braces: drop pathologically out-of-bounds mapped samples. A
+            // half-initialised digitizer or a device-specific firmware glitch can emit
+            // raw coordinates a few orders of magnitude beyond the actual screen — those
+            // map to coordinates several screens away and visibly fling the cursor.
+            // The ±2x output-area window is generous enough to keep legitimate
+            // off-area samples (hover near the screen edge, area-rotation overshoot)
+            // while rejecting the obvious garbage.
+            if (mappedX < outLeft - 2f * outWidth || mappedX > outLeft + 3f * outWidth
+                || mappedY < outTop - 2f * outHeight || mappedY > outTop + 3f * outHeight)
+                return;
 
             // Button state: pressure-based click (primary) with action overrides.
             // Uses the cached threshold field rather than `PressureThreshold.Value` to skip the
@@ -230,10 +292,52 @@ private void handlePointer(MotionEvent e, int historyIndex, MotionEventActions a
             else if (actionMasked == MotionEventActions.Up || actionMasked == MotionEventActions.ButtonRelease || actionMasked == MotionEventActions.Cancel) isLeftDown = false;
             else if (actionMasked == MotionEventActions.Move && (buttonState & MotionEventButtonState.Primary) != 0) isLeftDown = true;
 
-            if (isLeftDown != lastLeftDown)
+            if (TreatAsTouch)
             {
-                PendingInputs.Enqueue(new MouseButtonInput(MouseButton.Left, isLeftDown));
-                lastLeftDown = isLeftDown;
+                // Route as a Touch1 event so the gameplay paths that only fire on real
+                // touch input (osu! relax/touch-device mod, mania touch columns, mobile
+                // tap suppression toggles, etc.) treat the S Pen as a finger.
+                //
+                // Two queue items per state change:
+                //   - Position update (always, so hover-only motion still moves the touch
+                //     point — needed for slider drawing in the editor and for the
+                //     OsuTouchInputMapper to track the active touch).
+                //   - Activate/deactivate when contact state changes.
+                //
+                // The companion mouse-pipeline state is force-released so a runtime toggle
+                // of the setting doesn't strand a phantom MouseButton.Left=true.
+                if (lastLeftDown)
+                {
+                    PendingInputs.Enqueue(new MouseButtonInput(MouseButton.Left, false));
+                    lastLeftDown = false;
+                }
+
+                lastTouchPosition = mappedPos;
+
+                // Position update (always emitted while the touch is active or starting).
+                if (isLeftDown || lastTouchActive)
+                    PendingInputs.Enqueue(new TouchInput(new[] { new Touch(TouchSource.Touch1, mappedPos) }, isLeftDown));
+
+                if (isLeftDown != lastTouchActive)
+                    lastTouchActive = isLeftDown;
+            }
+            else
+            {
+                // Mouse-pipeline path. Position is published as MousePositionAbsoluteInput
+                // so the desktop-style cursor tracks the pen tip even when not in contact.
+                PendingInputs.Enqueue(new MousePositionAbsoluteInput { Position = mappedPos });
+
+                if (lastTouchActive)
+                {
+                    PendingInputs.Enqueue(new TouchInput(new[] { new Touch(TouchSource.Touch1, lastTouchPosition) }, false));
+                    lastTouchActive = false;
+                }
+
+                if (isLeftDown != lastLeftDown)
+                {
+                    PendingInputs.Enqueue(new MouseButtonInput(MouseButton.Left, isLeftDown));
+                    lastLeftDown = isLeftDown;
+                }
             }
 
             // S Pen side button and eraser tip are intentionally NOT mapped to right/middle

osu.Android/Input/AndroidStylusSettings.cs

@@ -0,0 +1,47 @@
+// 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 System.Collections.Generic;
+using System.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Localisation;
+using osu.Game.Configuration;
+using osu.Game.Graphics.UserInterfaceV2;
+using osu.Game.Overlays.Settings;
+using osu.Game.Overlays.Settings.Sections.Input;
+
+namespace osu.Android.Input
+{
+    /// <summary>
+    /// Android-specific stylus / S Pen settings subsection. Reuses the standard
+    /// <see cref="TabletSettings"/> area-mapping UI and adds the Android-only
+    /// "Treat S Pen as touch" toggle so it lives next to the related stylus settings
+    /// (rather than buried inside the Android Performance graphics subsection).
+    /// </summary>
+    public partial class AndroidStylusSettings : TabletSettings
+    {
+        public AndroidStylusSettings(AndroidStylusHandler handler)
+            : base(handler)
+        {
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuConfigManager osuConfig)
+        {
+            // Appended after the base TabletSettings.AddRange (the area-selection UI),
+            // so the toggle appears at the bottom of the section. Settings search
+            // (FilterTerms below) still surfaces it under "s pen" / "stylus" / "touch".
+            Add(new SettingsItemV2(new FormCheckBox
+            {
+                Caption = "Treat S Pen as touch",
+                HintText = "When enabled, S Pen / stylus input is enqueued as touch events (TouchSource.Touch1) rather than mouse events. Useful if a touch-only ruleset (e.g. mania touch columns, osu! touch-device mod) should treat the pen as a finger, or if the stylus pipeline misbehaves on your device.",
+                Current = osuConfig.GetBindable<bool>(OsuSetting.AndroidStylusAsTouch),
+            }));
+        }
+
+        public override IEnumerable<LocalisableString> FilterTerms => base.FilterTerms.Concat(new LocalisableString[]
+        {
+            @"s pen", @"spen", @"stylus", @"pen", @"touch", @"samsung",
+        });
+    }
+}

osu.Android/OsuGameActivity.cs

@@ -394,26 +394,17 @@ public override bool OnGenericMotionEvent(MotionEvent? e)
             return base.OnGenericMotionEvent(e);
         }
 
-        /// <summary>
-        /// When true, S Pen / stylus events are routed through the standard touch dispatch
-        /// pipeline (i.e. treated like a finger) instead of through <see cref="AndroidStylusHandler"/>.
-        /// Mirrored from <see cref="osu.Game.Configuration.OsuSetting.AndroidStylusAsTouch"/>
-        /// by <see cref="OsuGameAndroid"/>. Held as a volatile static so the per-event
-        /// dispatch hot path on the OS dispatch thread can read it without crossing the
-        /// managed-config bindable lock.
-        /// </summary>
-        internal static volatile bool StylusAsTouch;
-
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         private bool isStylusEvent(MotionEvent e)
         {
-            // User opted to treat S Pen as plain touch input — short-circuit so the
-            // event flows to base.DispatchTouchEvent (and the framework's SDL touch
-            // handler) instead of to AndroidStylusHandler.
-            if (StylusAsTouch)
-                return false;
-
             // Source flag check is cheapest and short-circuits for the common case.
+            // Note: the "Treat S Pen as touch" toggle is intentionally NOT consulted here.
+            // We always route stylus events through AndroidStylusHandler — that handler
+            // internally branches between MousePositionAbsoluteInput and TouchInput based
+            // on the toggle (see AndroidStylusHandler.TreatAsTouch). Letting events fall
+            // through to the framework's SDL touch dispatch (the previous implementation)
+            // dropped them entirely on phones (we strip SDL's PenHandler) and on the
+            // secondary DeX display (different Window token).
             if ((e.Source & InputSourceType.Stylus) == InputSourceType.Stylus)
                 return true;
 

osu.Android/OsuGameAndroid.cs

@@ -217,9 +217,16 @@ private void load(FrameworkConfigManager frameworkConfig)
                 LocalConfig.BindWith(OsuSetting.AndroidHardwareAudioOffsetEnabled, hardwareAudioOffsetEnabled);
 
                 // Mirror the stylus-as-touch toggle into the volatile flag the OS-thread
-                // dispatch hot path reads. Subscribed (not just set once) so toggling at
-                // runtime takes effect on the very next motion event.
-                stylusAsTouch.BindValueChanged(e => OsuGameActivity.StylusAsTouch = e.NewValue, true);
+                // dispatch hot path reads on AndroidStylusHandler. Subscribed (not just
+                // set once) so toggling at runtime takes effect on the very next motion
+                // event. The handler instance may not yet exist at this point — the
+                // value is also re-applied at the bottom of registerInputHandlers() once
+                // the handler is constructed, so the initial value is never lost.
+                stylusAsTouch.BindValueChanged(e =>
+                {
+                    if (stylusHandler != null)
+                        stylusHandler.TreatAsTouch = e.NewValue;
+                }, true);
 
                 // sentinelOnDisable=true → presence ⇒ "feature disabled". The
                 // safety nets default to ON, so the sentinel is created only
@@ -1276,6 +1283,20 @@ public override void PerformPlatformExit()
 
         public double GetMeasuredAudioLatencyMs() => getMeasuredAudioLatencyFromBridge();
 
+        /// <summary>
+        /// On Android, "Back at the top of the navigation stack" should fully exit the
+        /// process rather than the framework default of <c>MoveTaskToBack</c>. The default
+        /// leaves the audio thread mixing, the GC scheduling work, and the Vulkan swapchain
+        /// pinned — perceived by the user as "I closed the app, why is it still draining
+        /// battery?". Routing to <see cref="PerformPlatformExit"/> reuses the documented
+        /// hard-exit dance (MoveTaskToBack + Activity.Finish + Process.KillProcess(MyPid)).
+        /// </summary>
+        public override bool SuspendToBackground()
+        {
+            PerformPlatformExit();
+            return true;
+        }
+
         // ------------------------------------------------------------------
         // Layer 3 helpers — extracted Oboe / Vulkan-probe BindValueChanged
         // bodies so the initial fire can be EITHER synchronous (the original
@@ -1639,6 +1660,12 @@ private void registerAndroidInputHandlers(GameHost host)
                 mouseHandler = new AndroidMouseHandler();
                 keyboardHandler = new AndroidKeyboardHandler();
 
+                // Apply the persisted "Treat S Pen as touch" preference now that the
+                // handler instance exists. The BindValueChanged subscription installed
+                // in load() may have fired before this point (when stylusHandler was
+                // still null) — re-applying the current value here closes that race.
+                stylusHandler.TreatAsTouch = stylusAsTouch.Value;
+
                 gameActivity.StylusHandler = stylusHandler;
                 gameActivity.MouseHandler = mouseHandler;
                 gameActivity.KeyboardHandler = keyboardHandler;
@@ -1834,7 +1861,7 @@ protected override void Dispose(bool isDisposing)
         public override osu.Game.Overlays.Settings.SettingsSubsection CreateSettingsSubsectionFor(osu.Framework.Input.Handlers.InputHandler handler)
         {
             if (handler is AndroidStylusHandler stylus)
-                return new osu.Game.Overlays.Settings.Sections.Input.TabletSettings(stylus);
+                return new AndroidStylusSettings(stylus);
 
             return base.CreateSettingsSubsectionFor(handler);
         }

osu.Game/OsuGameBase.cs

@@ -167,6 +167,18 @@ public virtual void ResyncHardwareAudioOffset() { }
         /// </summary>
         public virtual void PerformPlatformExit() => RequestExit();
 
+        /// <summary>
+        /// Send the running game to the background — invoked when the user presses Back at the
+        /// top of the navigation stack on a host whose <see cref="GameHost.CanExit"/> is
+        /// <c>false</c> (i.e. mobile platforms). The base implementation defers to
+        /// <see cref="GameHost.SuspendToBackground"/> (the framework default of "minimise the
+        /// task"). Platforms that prefer a hard exit at this point (notably Android, where
+        /// task-minimise leaves the audio thread / GC running and the user expects Back-from-menu
+        /// to fully close the app) override this to call <see cref="PerformPlatformExit"/>.
+        /// </summary>
+        /// <returns><c>true</c> if the request was handled.</returns>
+        public virtual bool SuspendToBackground() => Host.SuspendToBackground();
+
         public virtual string Version
         {
             get