Merge branch 'main' into pr/936

.github/ISSUE_TEMPLATE/bug_report.md

@@ -14,6 +14,7 @@ labels: bug
 - [ ] GPD
 - [ ] ONEXPLAYER
 - [ ] VALVE
+- [ ] LENOVO
 
 **Device model**
 Your device model

HandheldCompanion/Controllers/NeptuneController.cs

@@ -346,6 +346,11 @@ public override void Unplug()
         base.Unplug();
     }
 
+    public override void Cleanup()
+    {
+        TimerManager.Tick -= UpdateInputs;
+    }
+
     public bool GetHapticIntensity(byte? input, sbyte minIntensity, sbyte maxIntensity, out sbyte output)
     {
         output = default;

HandheldCompanion/Controls/Hints/Hint_HWiNFO12hLimitPassed.cs

@@ -0,0 +1,60 @@
+using HandheldCompanion.Managers;
+using HandheldCompanion.Platforms;
+using System;
+using System.Windows;
+
+namespace HandheldCompanion.Controls.Hints
+{
+    public class Hint_HWiNFO12hLimitPassed : IHint
+    {
+        public Hint_HWiNFO12hLimitPassed() : base()
+        {
+            PlatformManager.HWiNFO.Updated += HWiNFO_Updated;
+            PlatformManager.HWiNFO.SettingValueChanged += HWiNFO_SettingValueChanged;
+
+            PlatformManager.Initialized += PlatformManager_Initialized;
+
+            // default state
+            this.HintActionButton.Visibility = Visibility.Collapsed;
+
+            this.HintTitle.Text = Properties.Resources.Hint_HWiNFO12hLimitPassed;
+            this.HintDescription.Text = Properties.Resources.Hint_HWiNFO12hLimitPassedDesc;
+            this.HintReadMe.Text = Properties.Resources.Hint_HWiNFO12hLimitPassedReadme;
+        }
+
+        private void HWiNFO_Updated(PlatformStatus status)
+        {
+            CheckSettings();
+        }
+
+        private void HWiNFO_SettingValueChanged(string name, object value)
+        {
+            // UI thread (async)
+            Application.Current.Dispatcher.BeginInvoke(() =>
+            {
+                switch(name)
+                {
+                    case "SensorsSM":
+                        this.Visibility = Convert.ToBoolean(value) ? Visibility.Collapsed : Visibility.Visible;
+                        break;
+                }
+            });
+        }
+
+        private void PlatformManager_Initialized()
+        {
+            CheckSettings();
+        }
+
+        private void CheckSettings()
+        {
+            bool SensorsSM = PlatformManager.HWiNFO.GetProperty("SensorsSM");
+            HWiNFO_SettingValueChanged("SensorsSM", SensorsSM);
+        }
+
+        public override void Stop()
+        {
+            base.Stop();
+        }
+    }
+}

HandheldCompanion/Controls/Hints/Hint_LegionGoDaemon.cs

@@ -0,0 +1,81 @@
+using HandheldCompanion.Devices;
+using HandheldCompanion.Views;
+using Microsoft.Win32.TaskScheduler;
+using System.Diagnostics;
+using System.Linq;
+using System.Timers;
+using System.Windows;
+using Task = System.Threading.Tasks.Task;
+
+namespace HandheldCompanion.Controls.Hints
+{
+    public class Hint_LegionGoDaemon : IHint
+    {
+        private Process process;
+        private const string taskName = "LSDaemon";
+        private Timer taskTimer;
+
+        public Hint_LegionGoDaemon() : base()
+        {
+            if (MainWindow.CurrentDevice is not LegionGo)
+                return;
+
+            taskTimer = new Timer(4000);
+            taskTimer.Elapsed += TaskTimer_Elapsed;
+            taskTimer.Start();
+
+            // default state
+            this.HintActionButton.Visibility = Visibility.Visible;
+
+            this.HintTitle.Text = Properties.Resources.Hint_LegionGoDaemon;
+            this.HintDescription.Text = Properties.Resources.Hint_LegionGoDaemonDesc;
+            this.HintReadMe.Text = Properties.Resources.Hint_LegionGoDaemonReadme;
+
+            this.HintActionButton.Content = Properties.Resources.Hint_LegionGoDaemonAction;
+        }
+
+        private void TaskTimer_Elapsed(object? sender, ElapsedEventArgs e)
+        {
+            // Get all the processes with the given name
+            process = Process.GetProcessesByName(taskName).FirstOrDefault();
+
+            // If there is at least one process, return true
+            // UI thread (async)
+            Application.Current.Dispatcher.BeginInvoke(() =>
+            {
+                if (process is not null && !process.HasExited)
+                    this.Visibility = Visibility.Visible;
+                else
+                    this.Visibility = Visibility.Collapsed;
+            });
+        }
+
+        protected override void HintActionButton_Click(object sender, RoutedEventArgs e)
+        {
+            Task.Run(async () =>
+            {
+                // Get the task service instance
+                using (TaskService ts = new TaskService())
+                {
+                    // Get the task by name
+                    Microsoft.Win32.TaskScheduler.Task task = ts.GetTask(taskName);
+                    if (task != null && task.State == TaskState.Running)
+                    {
+                        task.Stop();
+                        task.Enabled = false;
+                    }
+                }
+            });
+
+            // If the process exists and is running, kill it
+            if (process != null && !process.HasExited)
+                process.Kill();
+        }
+
+        public override void Stop()
+        {
+            taskTimer.Stop();
+            base.Stop();
+        }
+    }
+}

HandheldCompanion/Controls/Hints/Hint_LegionGoServices.cs

@@ -0,0 +1,107 @@
+using HandheldCompanion.Devices;
+using HandheldCompanion.Utils;
+using HandheldCompanion.Views;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.ServiceProcess;
+using System.Threading.Tasks;
+using System.Timers;
+using System.Windows;
+
+namespace HandheldCompanion.Controls.Hints
+{
+    public class Hint_LegionGoServices : IHint
+    {
+        private List<string> serviceNames = new()
+        {
+            "DAService",
+        };
+
+        private List<ServiceController> serviceControllers = new();
+        private Timer serviceTimer;
+
+        public Hint_LegionGoServices() : base()
+        {
+            if (MainWindow.CurrentDevice is not LegionGo)
+                return;
+
+            // Get all the services installed on the local computer
+            ServiceController[] services = ServiceController.GetServices();
+            foreach (string serviceName in serviceNames)
+            {
+                if (services.Any(s => serviceNames.Contains(s.ServiceName)))
+                {
+                    // Create a service controller object for the specified service
+                    ServiceController serviceController = new ServiceController(serviceName);
+                    serviceControllers.Add(serviceController);
+                }
+            }
+
+            // Check if any of the services in the list exist
+            if (!serviceControllers.Any())
+                return;
+
+            serviceTimer = new Timer(4000);
+            serviceTimer.Elapsed += ServiceTimer_Elapsed;
+            serviceTimer.Start();
+
+            // default state
+            this.HintActionButton.Visibility = Visibility.Visible;
+
+            this.HintTitle.Text = Properties.Resources.Hint_LegionGoServices;
+            this.HintDescription.Text = Properties.Resources.Hint_LegionGoServicesDesc;
+            this.HintReadMe.Text = Properties.Resources.Hint_LegionGoServicesReadme;
+
+            this.HintActionButton.Content = Properties.Resources.Hint_LegionGoServicesAction;
+        }
+
+        private void ServiceTimer_Elapsed(object? sender, ElapsedEventArgs e)
+        {
+            if(!serviceControllers.Any())
+                return;
+
+            // Check if any of the services in the list exist and are running
+            bool anyRunning = false;
+
+            foreach (ServiceController serviceController in serviceControllers)
+            {
+                serviceController.Refresh();
+                if (serviceController.Status == ServiceControllerStatus.Running)
+                {
+                    anyRunning = true;
+                    break;
+                }
+            }
+
+            // UI thread (async)
+            Application.Current.Dispatcher.BeginInvoke(() =>
+            {
+                this.Visibility = anyRunning ? Visibility.Visible : Visibility.Collapsed;
+            });
+        }
+
+        protected override void HintActionButton_Click(object sender, RoutedEventArgs e)
+        {
+            if (!serviceControllers.Any())
+                return;
+
+            Task.Run(async () =>
+            {
+                foreach (ServiceController serviceController in serviceControllers)
+                {
+                    if (serviceController.Status == ServiceControllerStatus.Running)
+                        serviceController.Stop();
+                    serviceController.WaitForStatus(ServiceControllerStatus.Stopped);
+                    ServiceUtils.ChangeStartMode(serviceController, ServiceStartMode.Disabled, out _);
+                }
+            });
+        }
+
+        public override void Stop()
+        {
+            serviceTimer.Stop();
+            base.Stop();
+        }
+    }
+}

HandheldCompanion/Devices/AOKZOE/AOKZOEA1.cs

@@ -128,4 +128,19 @@ public override string GetGlyph(ButtonFlags button)
 
         return defaultGlyph;
     }
+
+    public override string GetGlyph(ButtonFlags button)
+    {
+        switch (button)
+        {
+            case ButtonFlags.OEM1:
+                return "\u220C";
+            case ButtonFlags.OEM2:
+                return "\u2210";
+            case ButtonFlags.OEM3:
+                return "\u2211";
+        }
+
+        return defaultGlyph;
+    }
 }

HandheldCompanion/Devices/AYANEO/AYANEO2021.cs

@@ -69,4 +69,19 @@ public override string GetGlyph(ButtonFlags button)
 
         return defaultGlyph;
     }
+
+    public override string GetGlyph(ButtonFlags button)
+    {
+        switch (button)
+        {
+            case ButtonFlags.OEM1:
+                return "\uE008";
+            case ButtonFlags.OEM2:
+                return "\u242F";
+            case ButtonFlags.OEM3:
+                return "\u243D";
+        }
+
+        return defaultGlyph;
+    }
 }

HandheldCompanion/Devices/GPD/GPDWinMax2.cs

@@ -57,4 +57,17 @@ public override string GetGlyph(ButtonFlags button)
 
         return defaultGlyph;
     }
+
+    public override string GetGlyph(ButtonFlags button)
+    {
+        switch (button)
+        {
+            case ButtonFlags.OEM2:
+                return "\u220E";
+            case ButtonFlags.OEM3:
+                return "\u220F";
+        }
+
+        return defaultGlyph;
+    }
 }

HandheldCompanion/Devices/OneXPlayer/OneXPlayerMini.cs

@@ -72,6 +72,20 @@ public override string GetGlyph(ButtonFlags button)
 
         return defaultGlyph;
     }
+    public override string GetGlyph(ButtonFlags button)
+    {
+        switch (button)
+        {
+            case ButtonFlags.OEM1:
+                return "\u2219";
+            case ButtonFlags.OEM2:
+                return "\u2210";
+            case ButtonFlags.OEM3:
+                return "\u2218";
+        }
+
+        return defaultGlyph;
+    }
 
     public override bool Open()
     {