Merge pull request #268 from winnerspiros/copilot/fix-app-navigation-and-performance

Android: fix back-key minimise, mouse jitter, S Pen misclicks; reorganise audio/debug settings; one-shot hardware audio offset; FPS additional-info line

Author: winnerspiros

osu.Android.props

@@ -25,21 +25,46 @@
   </PropertyGroup>
 
   <!-- Release-only optimisations.
-       Trimming and AOT were previously enabled here for size/startup, but caused a
-       reproducible "splash → black screen → crash, no logs" failure on real devices.
-       Root cause: PublishTrimmed + TrimMode=partial + AndroidEnableProfiledAot, with
-       SuppressTrimAnalysisWarnings=true masking the build-time signal. Only Microsoft.CSharp
-       and ppy.Veldrid.SPIRV were rooted — osu.Game, the rulesets, Realm, Newtonsoft.Json,
-       AutoMapper, Sentry, OsuTK and other reflection-heavy assemblies were not. A trimmed
-       method/type or an un-AOT'd profiled-AOT call site throws TypeLoadException /
-       MissingMethodException early in OsuGame construction, before the file logger is open;
-       the process dies on the SDLThread / .NET ThreadPool thread with only a tombstone, so
-       the user gets no osu.log and Logcat shows a bare native crash.
-       Upstream ppy/osu's osu.Android.props enables NEITHER trimming NOR AOT — we now match
-       that baseline. The remaining release-only knobs (assembly compression, no PDBs) are
-       safe and unrelated to the startup crash. To re-enable trimming/AOT in the future,
-       reintroduce them one at a time, root every reflection-using assembly explicitly, and
-       run with SuppressTrimAnalysisWarnings=false to surface the gaps before shipping. -->
+       History:
+         Trimming + AOT were once enabled together (PublishTrimmed + TrimMode=partial +
+         AndroidEnableProfiledAot, with SuppressTrimAnalysisWarnings=true masking the
+         build-time signal). That combination caused a reproducible "splash → black screen
+         → crash, no logs" failure: only Microsoft.CSharp and ppy.Veldrid.SPIRV were rooted,
+         while osu.Game, the rulesets, Realm, Newtonsoft.Json, AutoMapper, Sentry, OsuTK
+         and other reflection-heavy assemblies were not. A trimmed method/type or an
+         un-AOT'd profiled-AOT call site threw TypeLoadException / MissingMethodException
+         early in OsuGame construction, before the file logger was open; the process died
+         on SDLThread / .NET ThreadPool with only a tombstone, so the user got no osu.log
+         and Logcat showed a bare native crash.
+
+       Current policy:
+         * AndroidEnableProfiledAot=true — re-enabled. The crash root cause was the
+           trimming side of the combination (untrimmed-but-AOT'd is safe — every method
+           the profile lists exists in the assembly because nothing was stripped; methods
+           outside the profile fall back to the JIT and are also still present). This
+           gives a measurable startup time reduction and cuts steady-state CPU on hot
+           managed paths (the JIT no longer needs to tier them up at runtime, and Mono's
+           profiled AOT covers framework/game hot loops including draw-thread Schedulers,
+           bindable propagation, and the texture upload path).
+         * PublishTrimmed stays OFF — re-enabling it requires explicitly rooting every
+           reflection-using assembly (osu.Game, rulesets, Realm, Newtonsoft.Json,
+           AutoMapper, Sentry, OsuTK, Microsoft.CSharp, ppy.Veldrid.SPIRV …) and running
+           with SuppressTrimAnalysisWarnings=false to surface gaps before shipping. That
+           is a separate, larger PR.
+         * AndroidEnableMarshalMethods stays OFF (see PropertyGroup above) — silent
+           SIGSEGV with current interop on .NET 10 Android.
+         * Server GC is enabled for Release: workstation GC's STW pauses on the Update/
+           Draw threads are a primary source of >1ms frame spikes that defeat our 1ms
+           frame-time goal. Server GC parallelises mark/sweep across cores and uses
+           per-core LOH/SOH allocation contexts, dramatically lowering pause time at
+           the cost of ~20-30% extra resident memory. Mono Android has supported this
+           since .NET 8; ppy/osu desktop already uses it. Concurrent GC is the .NET
+           default but we set it explicitly so Server GC runs in the background mode
+           rather than blocking foreground.
+
+       To re-enable trimming in the future, reintroduce it on its own, root every
+       reflection-using assembly explicitly, and run with SuppressTrimAnalysisWarnings=false
+       to surface the gaps before shipping. -->
   <PropertyGroup Condition="'$(Configuration)' == 'Release'">
     <!-- Compress managed assemblies inside the APK (LZ4).  Android extracts them on first run
          but the download/APK size is significantly smaller. -->
@@ -48,6 +73,16 @@
          Stack traces still work via embedded metadata. -->
     <DebugType>none</DebugType>
     <DebugSymbols>false</DebugSymbols>
+    <!-- Profiled AOT: pre-compile the hot methods listed in the bundled .NET / Android
+         profiles. Methods outside the profile remain JIT-compiled at runtime. NO trimming —
+         every method in every assembly stays present, so a profile-miss falls back to JIT
+         instead of throwing MissingMethodException like the previous trim+AOT combo did. -->
+    <AndroidEnableProfiledAot>true</AndroidEnableProfiledAot>
+    <!-- Concurrent Server GC. Server GC uses per-core allocation contexts and parallel
+         collections to reduce STW pause time, which is the largest source of >1ms frame
+         spikes on the Update/Draw threads. Memory usage rises ~20-30% in exchange. -->
+    <ServerGarbageCollection>true</ServerGarbageCollection>
+    <ConcurrentGarbageCollection>true</ConcurrentGarbageCollection>
   </PropertyGroup>
 
   <ItemGroup>

osu.Android/AndroidManifest.xml

@@ -1,7 +1,16 @@
 <?xml version='1.0' encoding='utf-8'?>
 <manifest xmlns:android="http://schemas.android.com/apk/res/android" package="sh.ppy.osulazer" android:installLocation="auto">
 	<uses-sdk android:minSdkVersion="33" android:targetSdkVersion="36" />
-	<application android:allowBackup="true" android:supportsRtl="true" android:label="osu!" android:icon="@mipmap/ic_launcher" android:roundIcon="@mipmap/ic_launcher" android:largeHeap="true" android:hardwareAccelerated="true" android:extractNativeLibs="false">
+	<!--
+	  android:enableOnBackInvokedCallback="false" — opt OUT of the Android predictive back gesture.
+	  With targetSdk=36 the OnBackInvokedDispatcher path is enabled by default, which routes the
+	  system Back gesture through OnBackInvokedCallback INSTEAD of the legacy KeyEvent pipeline.
+	  Our OsuGameActivity.DispatchKeyEvent overrides the legacy path to translate KEYCODE_BACK
+	  into Escape so Back navigates within the game; without this opt-out the gesture never
+	  reaches DispatchKeyEvent and the OS default for root-task activities (moveTaskToBack,
+	  i.e. minimise) takes over instead.
+	-->
+	<application android:allowBackup="true" android:supportsRtl="true" android:label="osu!" android:icon="@mipmap/ic_launcher" android:roundIcon="@mipmap/ic_launcher" android:largeHeap="true" android:hardwareAccelerated="true" android:extractNativeLibs="false" android:enableOnBackInvokedCallback="false">
         <provider android:name="androidx.core.content.FileProvider" android:authorities="sh.ppy.osulazer.fileprovider" android:grantUriPermissions="true" android:exported="false">
             <meta-data android:name="android.support.FILE_PROVIDER_PATHS" android:resource="@xml/filepaths" />
         </provider>

osu.Android/AndroidNativeBridgeManager.cs

@@ -70,20 +70,21 @@ public void StartOboeBridge(Scheduler scheduler, Action<double> onLatencyMeasure
 
                         if (started)
                         {
-                            Logger.Log("[osu!] Oboe bridge started successfully");
+                            Logger.Log($"[osu!] Oboe bridge started successfully (api={(bridge.IsAAudio ? "AAudio" : "OpenSLES")}, mmap={bridge.IsMMap}, rate={bridge.SampleRate}Hz, burst={bridge.FramesPerBurst}f, buffer={bridge.BufferSizeInFrames}f)");
                             logOboeInfo(bridge);
 
                             onStarted?.Invoke(bridge.SampleRate);
 
-                            scheduler.Add(new ScheduledDelegate(() =>
-                            {
-                                if (oboeBridge is not OboeAudioBridge b) return;
-
-                                double latency = b.GetOutputLatencyMs();
-
-                                if (latency > 0)
-                                    onLatencyMeasured(latency);
-                            }, 2000, 5000));
+                            // One-shot hardware-latency measurement. The native pipeline needs a few
+                            // hundred milliseconds of warm-up before AAudio reports a stable timestamp,
+                            // so we poll every 250 ms for up to ~2 s and apply the FIRST positive
+                            // reading we see. Once applied (or once the budget is exhausted), the
+                            // ScheduledDelegate cancels itself and never fires again. The previous
+                            // implementation used a 5000 ms repeat period, which kept overwriting the
+                            // user's audio offset every 5 s for the entire session — visible to the
+                            // user as a "jittering" / "auto-altering" hardware offset they could not
+                            // pin down. Use ResyncHardwareAudioOffset() for an explicit re-measure.
+                            scheduleHardwareLatencyMeasurement(scheduler, onLatencyMeasured);
                         }
                         else
                         {
@@ -103,12 +104,78 @@ public void StartOboeBridge(Scheduler scheduler, Action<double> onLatencyMeasure
             }
         }
 
+        private ScheduledDelegate? hardwareLatencyDelegate;
+
+        /// <summary>
+        /// Schedules a one-shot hardware-latency measurement that polls the bridge every 250 ms
+        /// for up to ~2 s, applies the first positive reading via <paramref name="onLatencyMeasured"/>,
+        /// and then cancels itself. Cancels any previously-scheduled measurement.
+        /// </summary>
+        private void scheduleHardwareLatencyMeasurement(Scheduler scheduler, Action<double> onLatencyMeasured)
+        {
+            hardwareLatencyDelegate?.Cancel();
+
+            const int interval_ms = 250;
+            const int budget_ticks = 8; // 8 × 250ms = 2 s
+            int ticks = 0;
+
+            ScheduledDelegate? handle = null;
+            handle = new ScheduledDelegate(() =>
+            {
+                if (oboeBridge is not OboeAudioBridge b)
+                {
+                    handle?.Cancel();
+                    return;
+                }
+
+                double latency = b.GetOutputLatencyMs();
+                ticks++;
+
+                if (latency > 0)
+                {
+                    Logger.Log($"[osu!] Hardware audio latency measured: {latency:F1} ms (after {ticks * interval_ms} ms warm-up)");
+                    try { onLatencyMeasured(latency); }
+                    catch (Exception ex) { Logger.Log($"[osu!] Hardware-latency callback failed: {ex.Message}", level: LogLevel.Error); }
+                    handle?.Cancel();
+                    return;
+                }
+
+                if (ticks >= budget_ticks)
+                {
+                    Logger.Log("[osu!] Hardware audio latency unavailable after 2 s — leaving audio offset unchanged.", level: LogLevel.Important);
+                    handle?.Cancel();
+                }
+            }, interval_ms, interval_ms);
+
+            hardwareLatencyDelegate = handle;
+            scheduler.Add(handle);
+        }
+
+        /// <summary>
+        /// Public hook for the user-facing "Resync hardware audio offset" button. Re-runs the
+        /// one-shot measurement if the Oboe bridge is currently active. No-op otherwise.
+        /// </summary>
+        public void ResyncHardwareAudioOffset(Scheduler scheduler, Action<double> onLatencyMeasured)
+        {
+            if (oboeBridge is OboeAudioBridge)
+            {
+                Logger.Log("[osu!] Resyncing hardware audio offset (user request)");
+                scheduleHardwareLatencyMeasurement(scheduler, onLatencyMeasured);
+            }
+            else
+            {
+                Logger.Log("[osu!] Resync requested but Oboe bridge is not active — enable low-latency audio first.", level: LogLevel.Important);
+            }
+        }
+
         [MethodImpl(MethodImplOptions.NoInlining)]
         public void StopOboeBridge()
         {
             lock (oboeLock)
             {
                 Logger.Log("[osu!] Stopping Oboe bridge...");
+                hardwareLatencyDelegate?.Cancel();
+                hardwareLatencyDelegate = null;
                 (oboeBridge as OboeAudioBridge)?.Dispose();
                 oboeBridge = null;
                 cachedOboeStatus = null;
@@ -279,6 +346,9 @@ public void Dispose()
             if (disposed) return;
             disposed = true;
 
+            try { hardwareLatencyDelegate?.Cancel(); } catch { }
+            hardwareLatencyDelegate = null;
+
             try { (oboeBridge as OboeAudioBridge)?.Dispose(); } catch { }
             oboeBridge = null;
 

osu.Android/Input/AndroidStylusHandler.cs

@@ -40,8 +40,6 @@ public class AndroidStylusHandler : InputHandler, ITabletHandler
         private readonly Bindable<TabletInfo?> tablet = new Bindable<TabletInfo?>();
 
         private bool lastLeftDown;
-        private bool lastRightDown;
-        private bool lastEraserDown;
 
         // Cached area values for hot path (avoids bindable access per event).
         private float areaLeft, areaTop, areaWidth, areaHeight;
@@ -143,7 +141,6 @@ public bool HandleMotionEvent(MotionEvent e)
             if (e.ActionMasked == MotionEventActions.HoverExit || e.ActionMasked == MotionEventActions.Up || e.ActionMasked == MotionEventActions.Cancel)
             {
                 if (lastLeftDown) { PendingInputs.Enqueue(new MouseButtonInput(MouseButton.Left, false)); lastLeftDown = false; }
-                if (lastRightDown) { PendingInputs.Enqueue(new MouseButtonInput(MouseButton.Right, false)); lastRightDown = false; }
 
                 if (e.ActionMasked != MotionEventActions.HoverExit)
                     return true;
@@ -227,21 +224,13 @@ private void handlePointer(MotionEvent e, int historyIndex)
                 lastLeftDown = isLeftDown;
             }
 
-            // S Pen button → right click.
-            bool isRightDown = (buttonState & MotionEventButtonState.StylusPrimary) != 0;
-            if (isRightDown != lastRightDown)
-            {
-                PendingInputs.Enqueue(new MouseButtonInput(MouseButton.Right, isRightDown));
-                lastRightDown = isRightDown;
-            }
-
-            // Eraser → middle click.
-            bool isEraserDown = (buttonState & MotionEventButtonState.StylusSecondary) != 0 || e.GetToolType(pointer_index) == MotionEventToolType.Eraser;
-            if (isEraserDown != lastEraserDown)
-            {
-                PendingInputs.Enqueue(new MouseButtonInput(MouseButton.Middle, isEraserDown));
-                lastEraserDown = isEraserDown;
-            }
+            // S Pen side button and eraser tip are intentionally NOT mapped to right/middle
+            // mouse buttons. On Samsung devices a stray button-bit on a normal tap was
+            // synthesizing a right-click, which opened in-game context overlays at whatever
+            // position the desktop-style mouse cursor was last at (often (0,0) — the
+            // "stuck top-left options" the user reported). Pressure-only left-click is the
+            // expected pen-as-pointer behaviour and matches how the framework handles
+            // graphics-tablet styli on desktop.
         }
     }
 }

osu.Android/OsuGameActivity.cs

@@ -394,9 +394,25 @@ 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.
             if ((e.Source & InputSourceType.Stylus) == InputSourceType.Stylus)
                 return true;