Merge pull request #272 from winnerspiros/copilot/fix-s-pen-issue-and-review-logs

Fix S Pen "stuck top-left" via current-window-metrics + orientation refresh; honest DeX README

Author: winnerspiros

README.md

@@ -98,20 +98,22 @@ Turn it on and the game squeezes every bit of performance from your hardware:
 The game queries your screen's supported modes and picks the highest refresh rate automatically:
 
 - Supports 60 / 90 / 120 / 144 / 165 Hz panels (and beyond)
-- Tells the Android compositor your target frame rate for optimal scheduling
-- On Samsung DeX, it finds and uses the external display's best mode
+- Tells the Android compositor your target frame rate for optimal scheduling (`Surface.SetFrameRate` with the *seamless-only* flag, so a mode change can never destroy the active Vulkan swapchain mid-frame)
+- On Samsung DeX, queries the active (external) display's mode list via `Activity.Display` / `DisplayManager`
 
 ---
 
 ### 🖥️ Samsung DeX
 
 Plug your phone into a monitor and play on the big screen:
 
-- **Auto-detected** — the game knows when you're in DeX mode
-- Performance mode and immersive fullscreen turn on automatically
-- External display refresh rate is detected and applied
-- Keyboard + mouse input works seamlessly (no extra setup)
-- The game stays alive during display transitions (no restart)
+- **Auto-detected** via `UiMode.TypeDesk` — the game knows when you're in DeX mode
+- Performance mode and immersive fullscreen turn on automatically when DeX is connected
+- The active display's mode list is enumerated and the highest refresh rate is **requested** via `WindowManagerLayoutParams.PreferredDisplayModeId` (see honest caveat below)
+- Keyboard + mouse input works because of the dedicated `AndroidMouseHandler` / `AndroidKeyboardHandler` (those handlers aren't DeX-specific — they apply equally to USB peripherals on a phone)
+- The Activity is annotated with `ConfigurationChanges = …UiMode|ScreenSize|ScreenLayout|Density|…` so the game stays alive across DeX dock/undock without a full process restart
+
+> **Honest caveat:** Samsung DeX runs your activity inside a virtual display that is fully managed by Samsung's compositor. From a regular (non-system) app, **there is no public Android API to enumerate the physical monitor's true EDID mode list or to force a specific resolution/refresh rate on the HDMI link** — the only public hook is `WindowManagerLayoutParams.PreferredDisplayModeId`, which DeX treats as a hint and frequently ignores. The mode list returned by `display.GetSupportedModes()` for the DeX virtual display is whatever DeX itself chooses to advertise, not the monitor's full mode list. Resolution change is not attempted (no public API exists). The DeX-mode fast-path in this fork is therefore: detect DeX, flip performance + immersive toggles, ask the compositor nicely for the highest refresh rate it will admit to. Anything beyond that requires the vendor-private `com.samsung.android.dex.SDexManager`, which is signature-protected and not callable from a normal app.
 
 ---
 

osu.Android.props

@@ -99,7 +99,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="ppy.osu.Framework.Android" Version="2026.423.1" />
+    <PackageReference Include="ppy.osu.Framework.Android" Version="2026.427.1" />
     <!-- `ppy.osu.Framework.NativeLibs` is a transitive dependency of `ppy.osu.Framework`
          that ships desktop-only natives (Linux/macOS/Windows) under `runtimes/<rid>/native/`
          — including a bare Linux `libbass.so`/`libbass_fx.so`/`libbassmix.so` for linux-arm64.

osu.Android/AndroidNativeBridgeManager.cs

@@ -23,7 +23,7 @@ internal sealed class AndroidNativeBridgeManager : IDisposable
         private readonly object oboeLock = new object();
 
         [MethodImpl(MethodImplOptions.NoInlining)]
-        public void StartOboeBridge(Scheduler scheduler, Action<double> onLatencyMeasured, IntPtr provider, int sampleRate = 0, Action<int>? onStarted = null)
+        public void StartOboeBridge(IntPtr provider, int sampleRate = 0, Action<int>? onStarted = null)
         {
             lock (oboeLock)
             {
@@ -75,16 +75,19 @@ public void StartOboeBridge(Scheduler scheduler, Action<double> onLatencyMeasure
 
                             onStarted?.Invoke(bridge.SampleRate);
 
-                            // 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);
+                            // No automatic hardware-latency measurement on startup.
+                            //
+                            // The previous implementation polled the bridge for ~2 s after every
+                            // cold start and silently overwrote the user's AudioOffset with the
+                            // first positive AAudio reading. That fought the user's manual offset
+                            // tweaking (especially on devices where AAudio's reported latency
+                            // disagrees with their perception by tens of milliseconds) and was
+                            // observable as a "jittering" offset they couldn't pin down.
+                            //
+                            // Hardware-latency measurement is now exclusively user-triggered via
+                            // the "Resync hardware audio offset" button in Settings → Audio →
+                            // Android, which kicks off a 2-second sampling window and applies the
+                            // median of the readings. See ResyncHardwareAudioOffset below.
                         }
                         else
                         {
@@ -107,16 +110,56 @@ 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.
+        /// Whether a measurement window is currently active. Exposed so the public
+        /// <see cref="ResyncHardwareAudioOffset"/> entry point can no-op (rather than
+        /// queuing or interrupting) repeated clicks within the 2-second window — matching
+        /// the user-facing contract that "you can click it as many times as you like, just
+        /// not within these 2 seconds".
         /// </summary>
-        private void scheduleHardwareLatencyMeasurement(Scheduler scheduler, Action<double> onLatencyMeasured)
+        public bool IsMeasuringHardwareLatency => hardwareLatencyDelegate != null;
+
+        /// <summary>
+        /// Public hook for the user-facing "Resync hardware audio offset" button. Polls the
+        /// AAudio-reported output latency every <c>sample_interval_ms</c> for a fixed
+        /// <c>window_ms</c> measurement window, drops the very first reading (warm-up
+        /// transient), and applies the MEDIAN of the remaining positive readings via
+        /// <paramref name="onLatencyMeasured"/>. Median is robust against the occasional
+        /// outlier AAudio reports right after a presentation glitch — strictly better than
+        /// the previous "first positive reading wins" policy.
+        ///
+        /// <para>Repeated clicks while a window is in flight are ignored (logged) so users
+        /// can mash the button without producing partial measurements.</para>
+        ///
+        /// <para>If the Oboe bridge isn't active or no positive readings arrive in the
+        /// window, the callback is not invoked and the previous offset is left in place.</para>
+        /// </summary>
+        public void ResyncHardwareAudioOffset(Scheduler scheduler, Action<double> onLatencyMeasured)
         {
-            hardwareLatencyDelegate?.Cancel();
+            if (oboeBridge is not OboeAudioBridge)
+            {
+                Logger.Log("[osu!] Resync requested but Oboe bridge is not active — enable low-latency audio first.", level: LogLevel.Important);
+                return;
+            }
 
-            const int interval_ms = 250;
-            const int budget_ticks = 8; // 8 × 250ms = 2 s
+            if (hardwareLatencyDelegate != null)
+            {
+                Logger.Log("[osu!] Resync ignored — a measurement is already in progress (wait ~2s).", level: LogLevel.Important);
+                return;
+            }
+
+            Logger.Log("[osu!] Hardware audio offset: starting 2 s measurement window.");
+
+            const int sample_interval_ms = 150;
+            const int window_ms = 2000;
+            const int max_samples = window_ms / sample_interval_ms; // ~13
+
+            // Fixed-size buffer rather than List<double>: max_samples is known at
+            // compile time, so the List's heap-allocated backing T[] + per-Add
+            // bounds-check / count-bump is wasted work for a 13-element buffer
+            // measured once per user click. The whole resync now allocates
+            // exactly one double[13] (vs List<double> + the wrapped double[]).
+            double[] samples = new double[max_samples];
+            int samplesCount = 0;
             int ticks = 0;
 
             ScheduledDelegate? handle = null;
@@ -125,49 +168,46 @@ private void scheduleHardwareLatencyMeasurement(Scheduler scheduler, Action<doub
                 if (oboeBridge is not OboeAudioBridge b)
                 {
                     handle?.Cancel();
+                    hardwareLatencyDelegate = null;
                     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;
-                }
+                // Drop the very first reading: AAudio's getTimestamp() needs a few hundred
+                // milliseconds of pulled frames before its reported presentation latency
+                // stabilises, and the warm-up sample tends to be biased high.
+                if (ticks > 1 && latency > 0 && samplesCount < samples.Length)
+                    samples[samplesCount++] = latency;
 
-                if (ticks >= budget_ticks)
+                if (ticks * sample_interval_ms >= window_ms)
                 {
-                    Logger.Log("[osu!] Hardware audio latency unavailable after 2 s — leaving audio offset unchanged.", level: LogLevel.Important);
                     handle?.Cancel();
+                    hardwareLatencyDelegate = null;
+
+                    if (samplesCount == 0)
+                    {
+                        Logger.Log("[osu!] Hardware audio latency unavailable after 2 s — leaving audio offset unchanged.", level: LogLevel.Important);
+                        return;
+                    }
+
+                    Array.Sort(samples, 0, samplesCount);
+                    double median = samplesCount % 2 == 1
+                        ? samples[samplesCount / 2]
+                        : 0.5 * (samples[samplesCount / 2 - 1] + samples[samplesCount / 2]);
+
+                    Logger.Log($"[osu!] Hardware audio latency measured: median={median:F1} ms (n={samplesCount}, range=[{samples[0]:F1}, {samples[samplesCount - 1]:F1}] ms)");
+
+                    try { onLatencyMeasured(median); }
+                    catch (Exception ex) { Logger.Log($"[osu!] Hardware-latency callback failed: {ex.Message}", level: LogLevel.Error); }
                 }
-            }, interval_ms, interval_ms);
+            }, sample_interval_ms, sample_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()
         {
@@ -297,10 +337,7 @@ public string GetVulkanStatus()
             int major = (ver >> 22) & 0x3FF;
             int minor = (ver >> 12) & 0x3FF;
 
-            cachedVulkanStatus = $"Vk{major}.{minor}"
-                                 + (probe.DisablePresentId ? " [NoID]" : "")
-                                 + (probe.DisablePresentWait ? " [NoWait]" : "")
-                                 + (probe.DisableGraphicsPipelineLibrary ? " [NoGPL]" : "");
+            cachedVulkanStatus = $"Vk{major}.{minor}";
             return cachedVulkanStatus;
         }