Merge branch 'development'

src/Artemis.Core/Plugins/DeviceProviders/DeviceProvider.cs

@@ -1,6 +1,7 @@
 using System;
 using System.IO;
 using System.Linq;
+using System.Threading.Tasks;
 using RGB.NET.Core;
 
 namespace Artemis.Core.DeviceProviders;
@@ -15,7 +16,7 @@ public abstract class DeviceProvider : PluginFeature
     ///     The RGB.NET device provider backing this Artemis device provider
     /// </summary>
     public abstract IRGBDeviceProvider RgbDeviceProvider { get; }
-    
+
     /// <summary>
     ///     A boolean indicating whether this device provider detects the physical layout of connected keyboards.
     ///     <para>
@@ -48,6 +49,11 @@ public abstract class DeviceProvider : PluginFeature
     /// </summary>
     public bool RemoveExcessiveLedsSupported { get; protected set; } = true;
 
+    /// <summary>
+    ///     Gets or sets a boolean indicating whether suspending the device provider is supported
+    /// </summary>
+    public bool SuspendSupported { get; protected set; }
+
     /// <summary>
     ///     Loads a layout for the specified device and wraps it in an <see cref="ArtemisLayout" />
     /// </summary>
@@ -109,4 +115,12 @@ public abstract class DeviceProvider : PluginFeature
 
         return fileName + ".xml";
     }
+
+    /// <summary>
+    /// Called when the device provider is being suspended, like when the system is going to sleep.
+    /// Note: This will be called while the plugin is disabled.
+    /// </summary>
+    public virtual void Suspend()
+    {
+    }
 }

src/Artemis.Core/Services/DeviceService.cs

@@ -2,13 +2,13 @@
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Linq;
+using System.Threading;
 using System.Threading.Tasks;
 using Artemis.Core.DeviceProviders;
 using Artemis.Core.Providers;
 using Artemis.Core.Services.Models;
 using Artemis.Storage.Entities.Surface;
 using Artemis.Storage.Repositories.Interfaces;
-using DryIoc;
 using RGB.NET.Core;
 using Serilog;
 
@@ -21,8 +21,10 @@ internal class DeviceService : IDeviceService
     private readonly IDeviceRepository _deviceRepository;
     private readonly Lazy<IRenderService> _renderService;
     private readonly Func<List<ILayoutProvider>> _getLayoutProviders;
-    private readonly List<ArtemisDevice> _enabledDevices = new();
-    private readonly List<ArtemisDevice> _devices = new();
+    private readonly List<ArtemisDevice> _enabledDevices = [];
+    private readonly List<ArtemisDevice> _devices = [];
+    private readonly List<DeviceProvider> _suspendedDeviceProviders = [];
+    private readonly object _suspensionLock = new();
 
     public DeviceService(ILogger logger,
         IPluginManagementService pluginManagementService,
@@ -69,7 +71,7 @@ internal class DeviceService : IDeviceService
                 OnDeviceRemoved(new DeviceEventArgs(device));
             }
 
-            List<Exception> providerExceptions = new();
+            List<Exception> providerExceptions = [];
 
             void DeviceProviderOnException(object? sender, ExceptionEventArgs e)
             {
@@ -95,7 +97,7 @@ internal class DeviceService : IDeviceService
                 return;
             }
 
-            List<ArtemisDevice> addedDevices = new();
+            List<ArtemisDevice> addedDevices = [];
             foreach (IRGBDevice rgbDevice in rgbDeviceProvider.Devices)
             {
                 ArtemisDevice artemisDevice = GetArtemisDevice(rgbDevice);
@@ -184,7 +186,7 @@ internal class DeviceService : IDeviceService
                 device.ApplyLayout(null, false, false);
             else
                 provider?.ApplyLayout(device, layout);
-            
+
             UpdateLeds();
         }
         catch (Exception e)
@@ -241,6 +243,83 @@ internal class DeviceService : IDeviceService
         UpdateLeds();
     }
 
+    /// <inheritdoc />
+    public void SuspendDeviceProviders()
+    {
+        lock (_suspensionLock)
+        {
+            _logger.Information("Suspending all device providers");
+
+            bool wasPaused = _renderService.Value.IsPaused;
+            try
+            {
+                _renderService.Value.IsPaused = true;
+                foreach (DeviceProvider deviceProvider in _pluginManagementService.GetFeaturesOfType<DeviceProvider>().Where(d => d.SuspendSupported))
+                    SuspendDeviceProvider(deviceProvider);
+            }
+            finally
+            {
+                _renderService.Value.IsPaused = wasPaused;
+            }
+        }
+    }
+
+    /// <inheritdoc />
+    public void ResumeDeviceProviders()
+    {
+        lock (_suspensionLock)
+        {
+            _logger.Information("Resuming all device providers");
+
+            bool wasPaused = _renderService.Value.IsPaused;
+            try
+            {
+                _renderService.Value.IsPaused = true;
+                foreach (DeviceProvider deviceProvider in _suspendedDeviceProviders.ToList())
+                    ResumeDeviceProvider(deviceProvider);
+            }
+            finally
+            {
+                _renderService.Value.IsPaused = wasPaused;
+            }
+        }
+    }
+
+    private void SuspendDeviceProvider(DeviceProvider deviceProvider)
+    {
+        if (_suspendedDeviceProviders.Contains(deviceProvider))
+        {
+            _logger.Warning("Device provider {DeviceProvider} is already suspended", deviceProvider.Info.Name);
+            return;
+        }
+
+        try
+        {
+            _pluginManagementService.DisablePluginFeature(deviceProvider, false);
+            deviceProvider.Suspend();
+            _suspendedDeviceProviders.Add(deviceProvider);
+            _logger.Information("Device provider {DeviceProvider} suspended", deviceProvider.Info.Name);
+        }
+        catch (Exception e)
+        {
+            _logger.Error(e, "Device provider {DeviceProvider} failed to suspend", deviceProvider.Info.Name);
+        }
+    }
+
+    private void ResumeDeviceProvider(DeviceProvider deviceProvider)
+    {
+        try
+        {
+            _pluginManagementService.EnablePluginFeature(deviceProvider, false, true);
+            _suspendedDeviceProviders.Remove(deviceProvider);
+            _logger.Information("Device provider {DeviceProvider} resumed", deviceProvider.Info.Name);
+        }
+        catch (Exception e)
+        {
+            _logger.Error(e, "Device provider {DeviceProvider} failed to resume", deviceProvider.Info.Name);
+        }
+    }
+
     private ArtemisDevice GetArtemisDevice(IRGBDevice rgbDevice)
     {
         string deviceIdentifier = rgbDevice.GetDeviceIdentifier();

src/Artemis.Core/Services/Interfaces/IDeviceService.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Threading.Tasks;
 using Artemis.Core.DeviceProviders;
 
 namespace Artemis.Core.Services;
@@ -71,6 +72,16 @@ public interface IDeviceService : IArtemisService
     /// </summary>
     void SaveDevices();
 
+    /// <summary>
+    ///     Suspends all active device providers
+    /// </summary>
+    void SuspendDeviceProviders();
+
+    /// <summary>
+    ///     Resumes all previously active device providers
+    /// </summary>
+    void ResumeDeviceProviders();
+
     /// <summary>
     ///     Occurs when a single device was added.
     /// </summary>