Merge pull request #145 from winnerspiros/android-s-pen-optimization-482001571077316104

Optimize Android Input Latency and Native S Pen Support

Author: winnerspiros

osu.Android/Input/AndroidStylusHandler.cs

@@ -0,0 +1,109 @@
+// 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;
+using Android.Views;
+using osu.Framework.Bindables;
+using osu.Framework.Input.Handlers;
+using osu.Framework.Input.Handlers.Tablet;
+using osu.Framework.Input.StateChanges;
+using osu.Framework.Platform;
+using osu.Framework.Logging;
+using osuTK;
+using osuTK.Input;
+
+namespace osu.Android.Input
+{
+    public class AndroidStylusHandler : InputHandler, ITabletHandler
+    {
+        public override string Description => "S Pen / Stylus";
+
+        public Bindable<Vector2> AreaOffset { get; } = new Bindable<Vector2>();
+        public Bindable<Vector2> AreaSize { get; } = new Bindable<Vector2>();
+        public Bindable<Vector2> OutputAreaSize { get; } = new Bindable<Vector2>();
+        public Bindable<Vector2> OutputAreaOffset { get; } = new Bindable<Vector2>();
+        public IBindable<TabletInfo?> Tablet => tablet;
+        public Bindable<float> Rotation { get; } = new Bindable<float>();
+        public BindableFloat PressureThreshold { get; } = new BindableFloat(0.05f)
+        {
+            MinValue = 0f,
+            MaxValue = 1f,
+            Precision = 0.005f,
+        };
+
+        private readonly Bindable<TabletInfo?> tablet = new Bindable<TabletInfo?>();
+
+        public override bool IsActive => Enabled.Value;
+
+        private bool lastLeftDown;
+        private bool lastRightDown;
+        private bool firstEventReceived;
+
+        public AndroidStylusHandler()
+        {
+            Enabled.Default = true;
+            Enabled.Value = true;
+        }
+
+        public override bool Initialize(GameHost host)
+        {
+            // Initial tablet info with a sane default. We'll refine this as events arrive.
+            tablet.Value = new TabletInfo("S Pen", new Vector2(2000, 1000));
+            return base.Initialize(host);
+        }
+
+        public void HandleMotionEvent(MotionEvent e)
+        {
+            if (!Enabled.Value) return;
+
+            if (!firstEventReceived)
+            {
+                Logger.Log($"[osu!] S Pen input detected. Source={e.Source}, ToolType={e.GetToolType(0)}", LoggingTarget.Input);
+                firstEventReceived = true;
+            }
+
+            // Process historical points for maximum accuracy.
+            for (int i = 0; i < e.HistorySize; i++)
+            {
+                handlePointer(e, i);
+            }
+            handlePointer(e, -1);
+        }
+
+        private void handlePointer(MotionEvent e, int historyIndex)
+        {
+            const int pointer_index = 0;
+
+            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 pressure = historyIndex < 0 ? e.GetPressure(pointer_index) : e.GetHistoricalPressure(pointer_index, historyIndex);
+
+            // Dynamically update tablet bounds.
+            if (tablet.Value == null || x > tablet.Value.Size.X || y > 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));
+                tablet.Value = new TabletInfo("S Pen", newSize);
+            }
+
+            // Report absolute position.
+            PendingInputs.Enqueue(new MousePositionAbsoluteInput { Position = new Vector2(x, y) });
+
+            // Map pressure to mouse buttons.
+            bool isLeftDown = pressure >= PressureThreshold.Value;
+            if (isLeftDown != lastLeftDown)
+            {
+                PendingInputs.Enqueue(new MouseButtonInput(MouseButton.Left, isLeftDown));
+                lastLeftDown = isLeftDown;
+            }
+
+            // Map side button to Right Click.
+            bool isRightDown = (e.ButtonState & MotionEventButtonState.StylusPrimary) != 0;
+            if (isRightDown != lastRightDown)
+            {
+                PendingInputs.Enqueue(new MouseButtonInput(MouseButton.Right, isRightDown));
+                lastRightDown = isRightDown;
+            }
+        }
+    }
+}

osu.Android/OsuGameActivity.cs

@@ -1,3 +1,4 @@
+using osu.Android.Input;
 // 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.
 
@@ -18,13 +19,15 @@
 using osu.Framework.Android;
 using osu.Game.Database;
 using osu.Android.Native;
+using osu.Framework.Logging;
 
 namespace osu.Android
 {
     [Activity(ConfigurationChanges = DEFAULT_CONFIG_CHANGES, Exported = true, LaunchMode = DEFAULT_LAUNCH_MODE, MainLauncher = true)]
     [IntentFilter(new[] { Intent.ActionView }, Categories = new[] { Intent.CategoryDefault }, DataScheme = "content", DataPathPattern = ".*\\.osz", DataHost = "*", DataMimeType = "*/*")]
     [IntentFilter(new[] { Intent.ActionView }, Categories = new[] { Intent.CategoryDefault }, DataScheme = "content", DataPathPattern = ".*\\.osk", DataHost = "*", DataMimeType = "*/*")]
     [IntentFilter(new[] { Intent.ActionView }, Categories = new[] { Intent.CategoryDefault }, DataScheme = "content", DataPathPattern = ".*\\.osr", DataHost = "*", DataMimeType = "*/*")]
+    [IntentFilter(new[] { Intent.ActionView }, Categories = new[] { Intent.CategoryDefault }, DataScheme = "content", DataPathPattern = ".*\\.osr", DataHost = "*", DataMimeType = "application/x-osu-replay")]
     [IntentFilter(new[] { Intent.ActionView }, Categories = new[] { Intent.CategoryDefault }, DataScheme = "content", DataMimeType = "application/x-osu-beatmap-archive")]
     [IntentFilter(new[] { Intent.ActionView }, Categories = new[] { Intent.CategoryDefault }, DataScheme = "content", DataMimeType = "application/x-osu-skin-archive")]
     [IntentFilter(new[] { Intent.ActionView }, Categories = new[] { Intent.CategoryDefault }, DataScheme = "content", DataMimeType = "application/x-osu-replay")]
@@ -48,6 +51,7 @@ public class OsuGameActivity : AndroidGameActivity, ISurfaceHolderCallback
         public ScreenOrientation DefaultOrientation = ScreenOrientation.Unspecified;
 
         public new bool IsTablet { get; private set; }
+        internal AndroidStylusHandler? StylusHandler;
 
         private OsuGameAndroid? game;
 
@@ -83,6 +87,19 @@ protected override void OnCreate(Bundle? savedInstanceState)
             {
                 Window.AddFlags(WindowManagerFlags.Fullscreen);
                 Window.AddFlags(WindowManagerFlags.KeepScreenOn);
+
+                // Hide the system pointer icon to prevent double cursors in DeX or with mouse.
+                if (OperatingSystem.IsAndroidVersionAtLeast(24))
+                {
+                    try
+                    {
+                        Window.DecorView.PointerIcon = PointerIcon.GetSystemIcon(this, PointerIconType.Null);
+                    }
+                    catch (Exception e)
+                    {
+                        Logger.Log($"[osu!] Failed to hide system pointer icon: {e.Message}", LoggingTarget.Input);
+                    }
+                }
             }
 
             if (WindowManager?.DefaultDisplay != null && Resources?.DisplayMetrics != null)
@@ -106,6 +123,42 @@ protected override void OnCreate(Bundle? savedInstanceState)
 
         protected override void OnNewIntent(Intent? intent) => handleIntent(intent);
 
+        public override bool OnTouchEvent(MotionEvent? e)
+        {
+            if (e != null && isStylusEvent(e))
+            {
+                StylusHandler?.HandleMotionEvent(e);
+                return true;
+            }
+            return base.OnTouchEvent(e);
+        }
+
+        public override bool OnGenericMotionEvent(MotionEvent? e)
+        {
+            if (e != null && isStylusEvent(e))
+            {
+                StylusHandler?.HandleMotionEvent(e);
+                return true;
+            }
+            return base.OnGenericMotionEvent(e);
+        }
+
+        private bool isStylusEvent(MotionEvent e)
+        {
+            // Check source first, as it's the most reliable indicator on some devices.
+            if ((e.Source & InputSourceType.Stylus) == InputSourceType.Stylus)
+                return true;
+
+            // Check tool type for each pointer.
+            for (int i = 0; i < e.PointerCount; i++)
+            {
+                var toolType = e.GetToolType(i);
+                if (toolType == MotionEventToolType.Stylus || toolType == MotionEventToolType.Eraser)
+                    return true;
+            }
+            return false;
+        }
+
         public override void OnRequestPermissionsResult(int requestCode, string[] permissions, Permission[] grantResults)
         {
             Microsoft.Maui.ApplicationModel.Platform.OnRequestPermissionsResult(requestCode, permissions, grantResults);

osu.Android/OsuGameAndroid.cs

@@ -21,6 +21,7 @@
 using Android.OS;
 using Android.Views;
 using osu.Android.Native;
+using osu.Android.Input;
 using osu.Framework.Allocation;
 using AudioManager = osu.Framework.Audio.AudioManager;
 using osu.Framework.Bindables;
@@ -137,6 +138,8 @@ public override Version AssemblyVersion
             }
         }
 
+        private AndroidStylusHandler? stylusHandler;
+
         [BackgroundDependencyLoader]
         private void load()
         {
@@ -145,7 +148,11 @@ private void load()
             LocalConfig.BindWith(OsuSetting.AndroidVulkanProbe, vulkanProbeEnabled);
             LocalConfig.BindWith(OsuSetting.AudioOffset, audioOffset);
 
-                startVulkanProbe();
+            stylusHandler = new AndroidStylusHandler();
+            Host.AvailableInputHandlers.Add(stylusHandler);
+            gameActivity.StylusHandler = stylusHandler;
+
+            startVulkanProbe();
 
             audioRedirector = new OboeAudioRedirector(Audio);
 
@@ -299,7 +306,8 @@ protected override void LoadComplete()
                     {
                         try
                         {
-                            gameActivity.Window?.DecorView?.RequestUnbufferedDispatch((int)InputSourceType.Touchscreen);
+                            int sources = (int)(InputSourceType.Touchscreen | InputSourceType.Stylus | InputSourceType.Mouse | InputSourceType.Touchpad);
+                            gameActivity.Window?.DecorView?.RequestUnbufferedDispatch(sources);
                         }
                         catch (Exception e)
                         {
@@ -574,11 +582,18 @@ protected override void Dispose(bool isDisposing)
         [MethodImpl(MethodImplOptions.AggressiveOptimization)]
         protected override void UpdateAfterChildren() => base.UpdateAfterChildren();
 
+        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 base.CreateSettingsSubsectionFor(handler);
+        }
     }
 
     internal class AndroidBatteryInfo : BatteryInfo
     {
         public override double? ChargeLevel => Microsoft.Maui.Devices.Battery.ChargeLevel;
         public override bool OnBattery => Microsoft.Maui.Devices.Battery.PowerSource == global::Microsoft.Maui.Devices.BatteryPowerSource.Battery;
     }
-}
+}