Fix 3 CI build errors, re-enable Vulkan on all Android GPUs

- CS0122: BassAudioMixer is internal to framework, use reflection for Handle
- CS0104: Qualify Environment.ProcessorCount as System.Environment
- CS8602: Add null check on Window.DecorView before setting PointerIcon
- Remove unused refreshRateDropdown field (InspectCode warning)
- Re-enable Vulkan in renderer dropdown for all supported GPUs (not just recommended)
  Users with Adreno 7xx (S23 Ultra) can now see and select Vulkan

Agent-Logs-Url: https://github.com/winnerspiros/osu/sessions/399426d4-c22f-491c-9cdd-8970c556a3db

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

Author: Copilot

osu.Android/AndroidNativeBridgeManager.cs

@@ -48,7 +48,7 @@ public void StartOboeBridge(Scheduler scheduler, Action<double> onLatencyMeasure
 
                         // Calculate dynamic big-core mask for audio thread, matching the pattern in OsuGameAndroid.LoadComplete
                         int audioAffinityMask;
-                        int cores = Environment.ProcessorCount;
+                        int cores = System.Environment.ProcessorCount;
                         int bigStart = Math.Max(cores / 2, 1);
                         audioAffinityMask = 0;
 

osu.Android/OboeAudioRedirector.cs

@@ -12,13 +12,12 @@
 using ManagedBass.Mix;
 using osu.Framework.Audio;
 using osu.Framework.Audio.Mixing;
-using osu.Framework.Audio.Mixing.Bass;
 
 namespace osu.Android
 {
     /// <summary>
     /// Redirects audio from BASS mixers into an unmanaged callback (Oboe).
-    /// Uses BassAudioMixer.Handle directly instead of fragile reflection-based handle discovery.
+    /// Discovers mixer handles via reflection since BassAudioMixer is internal to the framework.
     /// </summary>
     public class OboeAudioRedirector : IDisposable
     {
@@ -285,19 +284,14 @@ private void addMixer(AudioMixer? mixer)
         }
 
         /// <summary>
-        /// Gets the BASS handle from an AudioMixer using the public BassAudioMixer.Handle property.
-        /// This replaces the previous fragile reflection-based approach.
+        /// Gets the BASS handle from an AudioMixer via reflection.
+        /// BassAudioMixer is internal to the framework, so we access its Handle property via reflection.
         /// </summary>
         private static int getHandle(AudioMixer mixer)
         {
-            if (mixer is BassAudioMixer bassMixer)
-                return bassMixer.Handle;
-
-            // Fallback: if the mixer is not a BassAudioMixer (shouldn't happen in practice),
-            // try reflection as a last resort.
             try
             {
-                var handleProp = mixer.GetType().GetProperty("Handle", BindingFlags.Instance | BindingFlags.Public);
+                var handleProp = mixer.GetType().GetProperty("Handle", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
                 if (handleProp?.GetValue(mixer) is int h)
                     return h;
             }

osu.Android/OsuGameActivity.cs

@@ -114,7 +114,10 @@ protected override void OnCreate(Bundle? savedInstanceState)
                 {
                     try
                     {
-                        Window.DecorView.PointerIcon = PointerIcon.GetSystemIcon(this, PointerIconType.Null);
+                        var decorView = Window.DecorView;
+
+                        if (decorView != null)
+                            decorView.PointerIcon = PointerIcon.GetSystemIcon(this, PointerIconType.Null);
                     }
                     catch (Exception e)
                     {

osu.Android/OsuGameAndroid.cs

@@ -199,7 +199,7 @@ protected override void LoadComplete()
         {
             // Calculate big-core affinity mask dynamically based on device core count.
             // On big.LITTLE architectures, the upper half of cores are typically performance cores.
-            int coreCount = Environment.ProcessorCount;
+            int coreCount = System.Environment.ProcessorCount;
             int bigCoreStart = Math.Max(coreCount / 2, 1);
             int affinityMask = 0;
 

osu.Game/Overlays/Settings/Sections/Graphics/AndroidPerformanceSettings.cs

@@ -29,7 +29,7 @@ private void load(OsuConfigManager config, OsuGame? game)
                     HintText = "Enables sustained performance mode, immersive fullscreen, and auto-selects the highest refresh rate. Auto-enabled in DeX mode.",
                     Current = config.GetBindable<bool>(OsuSetting.AndroidPerformanceMode),
                 }),
-                new SettingsItemV2(refreshRateDropdown = new RefreshRateDropdown
+                new SettingsItemV2(new RefreshRateDropdown
                 {
                     Caption = "Display refresh rate",
                     HintText = "Select the display refresh rate. In DeX mode, this controls the external monitor's refresh rate.",
@@ -60,8 +60,6 @@ private void load(OsuConfigManager config, OsuGame? game)
             };
         }
 
-        private RefreshRateDropdown refreshRateDropdown = null!;
-
         private partial class RefreshRateDropdown : FormDropdown<int>
         {
             protected override LocalisableString GenerateItemText(int item)

osu.Game/Overlays/Settings/Sections/Graphics/RendererSettings.cs

@@ -32,16 +32,16 @@ private void load(FrameworkConfigManager config, OsuConfigManager osuConfig, IDi
 
             var rendererItems = host.GetPreferredRenderersForCurrentPlatform().ToList();
 
-            // Only show Vulkan on Android if the VulkanProbe recommends it (not just supported).
-            // On devices with known Vulkan issues (e.g. Adreno 7xx flickering), IsVulkanRecommended
-            // returns false even though the GPU technically supports Vulkan. Showing the option leads
-            // users to select it and experience poor performance vs OpenGL ES.
+            // Always show Vulkan on Android when the GPU supports it, so users can try it.
+            // The VulkanProbe detects feature support; even if some features are disabled (e.g. on
+            // Adreno 7xx), the renderer itself may still work and provide better performance than
+            // OpenGL ES for some workloads.
             if (RuntimeInfo.OS == RuntimeInfo.Platform.Android)
             {
-                bool isRecommended = game?.IsVulkanRecommended ?? false;
+                bool isSupported = game?.IsVulkanSupported ?? false;
                 bool isCurrentlySelected = renderer.Value == RendererType.Vulkan;
 
-                if ((isRecommended || isCurrentlySelected) && !rendererItems.Contains(RendererType.Vulkan))
+                if ((isSupported || isCurrentlySelected) && !rendererItems.Contains(RendererType.Vulkan))
                     rendererItems.Add(RendererType.Vulkan);
             }