Rewrite S Pen handler as true tablet with area mapping, fix thread safety

- S Pen now acts as a real tablet: area mapping, rotation, pressure threshold
- Display-based initialization from actual screen dimensions (not 2000x1000)
- Cached area transform values for hot-path performance
- TabletSettings UI shown on Android via CreateSettingsSubsectionFor override
- Thread-safe JNI surface ref (Interlocked.Exchange), error string mutex in C++
- Dynamic audio thread affinity matching OsuGameAndroid pattern

Agent-Logs-Url: https://github.com/winnerspiros/osu/sessions/62a8048b-6fe1-424d-9c00-a3fbddf6ba74

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

Author: Copilot

osu.Android/AndroidNativeBridgeManager.cs

@@ -46,7 +46,18 @@ public void StartOboeBridge(Scheduler scheduler, Action<double> onLatencyMeasure
                         if (provider != IntPtr.Zero)
                             bridge.SetProvider(provider);
 
-                        try { SetThreadAffinity(Environment.ProcessorCount > 4 ? 0xF0 : 0x0C); }
+                        // Calculate dynamic big-core mask for audio thread, matching the pattern in OsuGameAndroid.LoadComplete
+                        int audioAffinityMask;
+                        int cores = Environment.ProcessorCount;
+                        int bigStart = Math.Max(cores / 2, 1);
+                        audioAffinityMask = 0;
+
+                        for (int i = bigStart; i < Math.Min(cores, 32); i++)
+                            audioAffinityMask |= 1 << i;
+
+                        if (audioAffinityMask == 0) audioAffinityMask = (1 << cores) - 1;
+
+                        try { SetThreadAffinity(audioAffinityMask); }
                         catch (Exception e) { Debug.WriteLine($"[osu!] Audio thread affinity failed: {e.Message}"); }
 
                         bool started = bridge.Start();

osu.Android/Input/AndroidStylusHandler.cs

@@ -13,9 +13,14 @@
 
 namespace osu.Android.Input
 {
+    /// <summary>
+    /// Handles Samsung S Pen / stylus input as a true tablet device with area mapping.
+    /// Provides the same coordinate transformation as desktop Wacom tablets:
+    /// raw digitizer coordinates → area selection → output area on screen.
+    /// </summary>
     public class AndroidStylusHandler : InputHandler, ITabletHandler
     {
-        public override string Description => "S Pen / Stylus (Low Latency)";
+        public override string Description => "S Pen / Stylus";
         public override bool IsActive => Enabled.Value;
 
         public Bindable<Vector2> AreaOffset { get; } = new Bindable<Vector2>();
@@ -28,6 +33,7 @@ public class AndroidStylusHandler : InputHandler, ITabletHandler
         {
             MinValue = 0.01f,
             MaxValue = 0.9f,
+            Precision = 0.01f,
         };
 
         private readonly Bindable<TabletInfo?> tablet = new Bindable<TabletInfo?>();
@@ -36,6 +42,11 @@ public class AndroidStylusHandler : InputHandler, ITabletHandler
         private bool lastRightDown;
         private bool lastEraserDown;
 
+        // Cached area values for hot path (avoids bindable access per event).
+        private float areaLeft, areaTop, areaWidth, areaHeight;
+        private float outLeft, outTop, outWidth, outHeight;
+        private float rotSin, rotCos;
+
         public AndroidStylusHandler()
         {
             Enabled.Default = true;
@@ -44,10 +55,70 @@ public AndroidStylusHandler()
 
         public override bool Initialize(GameHost host)
         {
-            tablet.Value = new TabletInfo("S Pen", new Vector2(2000, 1000));
+            // Default size will be updated by SetDisplaySize once the display metrics are known.
+            tablet.Value = new TabletInfo("S Pen", new Vector2(1920, 1080));
+
+            AreaSize.BindValueChanged(_ => updateCachedTransform());
+            AreaOffset.BindValueChanged(_ => updateCachedTransform());
+            OutputAreaSize.BindValueChanged(_ => updateCachedTransform());
+            OutputAreaOffset.BindValueChanged(_ => updateCachedTransform());
+            Rotation.BindValueChanged(_ => updateCachedTransform());
+
             return base.Initialize(host);
         }
 
+        /// <summary>
+        /// Sets the digitizer/display dimensions. Must be called after the display is known.
+        /// This sets the full tablet area and default output area.
+        /// </summary>
+        public void SetDisplaySize(int width, int height)
+        {
+            var size = new Vector2(width, height);
+            tablet.Value = new TabletInfo("S Pen", size);
+
+            // Default: full digitizer area mapped to full screen (1:1 passthrough).
+            AreaSize.Default = size;
+            AreaOffset.Default = size / 2;
+            OutputAreaSize.Default = size;
+            OutputAreaOffset.Default = size / 2;
+
+            // Only set current values if they haven't been configured by the user yet.
+            if (AreaSize.Value == default || AreaSize.Value == new Vector2(1920, 1080))
+            {
+                AreaSize.Value = size;
+                AreaOffset.Value = size / 2;
+            }
+
+            if (OutputAreaSize.Value == default || OutputAreaSize.Value == new Vector2(1920, 1080))
+            {
+                OutputAreaSize.Value = size;
+                OutputAreaOffset.Value = size / 2;
+            }
+
+            updateCachedTransform();
+        }
+
+        private void updateCachedTransform()
+        {
+            var aSize = AreaSize.Value;
+            var aOff = AreaOffset.Value;
+            areaLeft = aOff.X - aSize.X / 2;
+            areaTop = aOff.Y - aSize.Y / 2;
+            areaWidth = aSize.X;
+            areaHeight = aSize.Y;
+
+            var oSize = OutputAreaSize.Value;
+            var oOff = OutputAreaOffset.Value;
+            outLeft = oOff.X - oSize.X / 2;
+            outTop = oOff.Y - oSize.Y / 2;
+            outWidth = oSize.X;
+            outHeight = oSize.Y;
+
+            float radians = MathF.PI / 180f * Rotation.Value;
+            rotSin = MathF.Sin(radians);
+            rotCos = MathF.Cos(radians);
+        }
+
         public bool HandleMotionEvent(MotionEvent e)
         {
             if (!Enabled.Value) return false;
@@ -61,10 +132,10 @@ public bool HandleMotionEvent(MotionEvent e)
                     return true;
             }
 
+            // Process all batched historical events for maximum accuracy.
             for (int i = 0; i < e.HistorySize; i++)
-            {
                 handlePointer(e, i);
-            }
+
             handlePointer(e, -1);
 
             return true;
@@ -75,19 +146,50 @@ private void handlePointer(MotionEvent e, int historyIndex)
             const int pointer_index = 0;
             if (e.PointerCount <= pointer_index) return;
 
-            float x = historyIndex < 0 ? e.GetX(pointer_index) : e.GetHistoricalX(pointer_index, historyIndex);
-            float y = historyIndex < 0 ? e.GetY(pointer_index) : e.GetHistoricalY(pointer_index, historyIndex);
+            float rawX = historyIndex < 0 ? e.GetX(pointer_index) : e.GetHistoricalX(pointer_index, historyIndex);
+            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);
 
-            if (tablet.Value == null || x > tablet.Value.Size.X || y > tablet.Value.Size.Y)
+            // Auto-expand tablet size if the digitizer reports coordinates beyond current bounds.
+            if (tablet.Value == null || rawX > tablet.Value.Size.X || rawY > tablet.Value.Size.Y)
             {
                 var currentSize = tablet.Value?.Size ?? Vector2.Zero;
-                var newSize = new Vector2(Math.Max(x, currentSize.X), Math.Max(y, currentSize.Y));
+                var newSize = new Vector2(Math.Max(rawX + 1, currentSize.X), Math.Max(rawY + 1, currentSize.Y));
                 tablet.Value = new TabletInfo("S Pen", newSize);
             }
 
-            PendingInputs.Enqueue(new MousePositionAbsoluteInput { Position = new Vector2(x, y) });
+            // Apply tablet area → output area coordinate mapping.
+            float mappedX, mappedY;
+
+            if (areaWidth > 0 && areaHeight > 0)
+            {
+                // Normalize to [0, 1] within the configured tablet area.
+                float normX = (rawX - areaLeft) / areaWidth;
+                float normY = (rawY - areaTop) / areaHeight;
+
+                // Apply rotation around center of normalized space.
+                if (Rotation.Value != 0)
+                {
+                    float cx = normX - 0.5f;
+                    float cy = normY - 0.5f;
+                    normX = cx * rotCos - cy * rotSin + 0.5f;
+                    normY = cx * rotSin + cy * rotCos + 0.5f;
+                }
+
+                // Map to output area.
+                mappedX = outLeft + normX * outWidth;
+                mappedY = outTop + normY * outHeight;
+            }
+            else
+            {
+                // Fallback: raw passthrough if area is invalid.
+                mappedX = rawX;
+                mappedY = rawY;
+            }
+
+            PendingInputs.Enqueue(new MousePositionAbsoluteInput { Position = new Vector2(mappedX, mappedY) });
 
+            // Button state: pressure-based click (primary) with action overrides.
             bool isLeftDown = pressure >= PressureThreshold.Value;
             if (e.ActionMasked == MotionEventActions.Down || e.ActionMasked == MotionEventActions.ButtonPress) isLeftDown = true;
             else if (e.ActionMasked == MotionEventActions.Up || e.ActionMasked == MotionEventActions.ButtonRelease || e.ActionMasked == MotionEventActions.Cancel) isLeftDown = false;
@@ -99,13 +201,15 @@ private void handlePointer(MotionEvent e, int historyIndex)
                 lastLeftDown = isLeftDown;
             }
 
+            // S Pen button → right click.
             bool isRightDown = (e.ButtonState & MotionEventButtonState.StylusPrimary) != 0;
             if (isRightDown != lastRightDown)
             {
                 PendingInputs.Enqueue(new MouseButtonInput(MouseButton.Right, isRightDown));
                 lastRightDown = isRightDown;
             }
 
+            // Eraser → middle click.
             bool isEraserDown = (e.ButtonState & MotionEventButtonState.StylusSecondary) != 0 || e.GetToolType(pointer_index) == MotionEventToolType.Eraser;
             if (isEraserDown != lastEraserDown)
             {

osu.Android/Native/oboe_bridge.cpp

@@ -60,15 +60,15 @@ bool OboeBridge::open(int32_t sampleRate) {
     if (result != oboe::Result::OK) {
         LOGE("AAudio open failed (%s), falling back to unspecified API",
              oboe::convertToText(result));
-        lastError_ = std::string("AAudio: ") + oboe::convertToText(result);
+        { std::lock_guard<std::mutex> eLock(errorLock_); lastError_ = std::string("AAudio: ") + oboe::convertToText(result); }
         builder.setAudioApi(oboe::AudioApi::Unspecified);
         builder.setSharingMode(oboe::SharingMode::Shared);
         result = builder.openStream(stream_);
     }
 
     if (result != oboe::Result::OK) {
         LOGE("Failed to open Oboe stream: %s", oboe::convertToText(result));
-        lastError_ = std::string("Open failed: ") + oboe::convertToText(result);
+        { std::lock_guard<std::mutex> eLock(errorLock_); lastError_ = std::string("Open failed: ") + oboe::convertToText(result); }
         return false;
     }
 
@@ -108,7 +108,7 @@ bool OboeBridge::start() {
 
     if (result != oboe::Result::OK) {
         LOGE("Failed to start Oboe stream: %s", oboe::convertToText(result));
-        lastError_ = std::string("Start failed: ") + oboe::convertToText(result);
+        { std::lock_guard<std::mutex> eLock(errorLock_); lastError_ = std::string("Start failed: ") + oboe::convertToText(result); }
         return false;
     }
 
@@ -174,6 +174,7 @@ void OboeBridge::setProvider(OboeAudioProvider provider) {
 }
 
 const char* OboeBridge::getLastError() const {
+    std::lock_guard<std::mutex> lock(errorLock_);
     return lastError_.empty() ? nullptr : lastError_.c_str();
 }
 

osu.Android/Native/oboe_bridge.h

@@ -55,6 +55,7 @@ class OboeBridge : public oboe::AudioStreamCallback {
     std::atomic<bool> affinitySet_{false};
     int32_t requestedSampleRate_{0};
     std::string lastError_;
+    mutable std::mutex errorLock_;
 
     void updateLatency();
     bool reopenAndRestart();

osu.Android/OsuGameActivity.cs

@@ -337,14 +337,14 @@ public void SurfaceCreated(ISurfaceHolder holder)
                 IntPtr handle = surface.Handle;
                 if (handle == IntPtr.Zero) return;
 
-                // Release previous reference to prevent JNI global reference leak on rapid surface recreation.
-                if (surfaceGlobalRef != IntPtr.Zero)
-                {
-                    global::Android.Runtime.JNIEnv.DeleteGlobalRef(surfaceGlobalRef);
-                    surfaceGlobalRef = IntPtr.Zero;
-                }
+                IntPtr newRef = global::Android.Runtime.JNIEnv.NewGlobalRef(handle);
+
+                // Atomically swap the old reference to prevent race with SurfaceDestroyed.
+                IntPtr oldRef = System.Threading.Interlocked.Exchange(ref surfaceGlobalRef, newRef);
+
+                if (oldRef != IntPtr.Zero)
+                    global::Android.Runtime.JNIEnv.DeleteGlobalRef(oldRef);
 
-                surfaceGlobalRef = global::Android.Runtime.JNIEnv.NewGlobalRef(handle);
                 surfaceEvent.Set();
                 Debug.WriteLine("[osu!] Native surface JNI global reference created");
             }
@@ -356,11 +356,11 @@ public void SurfaceChanged(ISurfaceHolder holder, global::Android.Graphics.Forma
 
         public void SurfaceDestroyed(ISurfaceHolder holder)
         {
-            if (surfaceGlobalRef != IntPtr.Zero)
-            {
-                global::Android.Runtime.JNIEnv.DeleteGlobalRef(surfaceGlobalRef);
-                surfaceGlobalRef = IntPtr.Zero;
-            }
+            IntPtr oldRef = System.Threading.Interlocked.Exchange(ref surfaceGlobalRef, IntPtr.Zero);
+
+            if (oldRef != IntPtr.Zero)
+                global::Android.Runtime.JNIEnv.DeleteGlobalRef(oldRef);
+
             surfaceEvent.Reset();
         }
 

osu.Android/OsuGameAndroid.cs

@@ -144,6 +144,25 @@ private void load()
             Host.AvailableInputHandlers.Add(stylusHandler);
             gameActivity.StylusHandler = stylusHandler;
 
+            // Pass actual display dimensions to the stylus handler so the tablet area
+            // matches the real digitizer/screen size (not a hardcoded placeholder).
+            try
+            {
+                if (gameActivity.WindowManager?.DefaultDisplay != null)
+                {
+                    var displaySize = new global::Android.Graphics.Point();
+#pragma warning disable CA1422
+                    gameActivity.WindowManager.DefaultDisplay.GetRealSize(displaySize);
+#pragma warning restore CA1422
+                    if (displaySize.X > 0 && displaySize.Y > 0)
+                        stylusHandler.SetDisplaySize(displaySize.X, displaySize.Y);
+                }
+            }
+            catch (Exception e)
+            {
+                Debug.WriteLine($"[osu!] Failed to get display size for stylus handler: {e.Message}");
+            }
+
             mouseHandler = new AndroidMouseHandler();
             Host.AvailableInputHandlers.Add(mouseHandler);
             gameActivity.MouseHandler = mouseHandler;