feat: ability to restart OpenRGB

Author: andrewbabbittdev

src/ChromaControl.SDK.OpenRGB/IOpenRGBService.cs

@@ -35,6 +35,13 @@ public interface IOpenRGBService
     /// <param name="config">The <see cref="JsonNode"/> configuration.</param>
     void UpdateConfiguration(JsonNode config);
 
+    /// <summary>
+    /// Restarts the service.
+    /// </summary>
+    /// <param name="cancellationToken">A <see cref="CancellationToken"/>.</param>
+    /// <returns>A <see cref="Task"/>.</returns>
+    Task Restart(CancellationToken cancellationToken = default);
+
     /// <summary>
     /// Updates the device list.
     /// </summary>

src/ChromaControl.SDK.OpenRGB/Internal/OpenRGBManager.cs

@@ -13,13 +13,14 @@ internal sealed partial class OpenRGBManager : IDisposable
 {
     private static bool Is32Bit => nint.Size == 4;
 
-    private readonly Process _process = CreateProcess();
+    private Process? _process;
     private readonly Job _job;
     private readonly string _configFilePath = Path.Combine(OpenRGBConstants.ConfigPath, "OpenRGB.json");
 
     public OpenRGBManager()
     {
         _job = new();
+        _job.AssignProcess(Process.GetCurrentProcess());
     }
 
     public void UpdateConfigFile(JsonNode config)
@@ -34,20 +35,33 @@ public void UpdateConfigFile(JsonNode config)
 
     public void Start()
     {
-        _job.AssignProcess(Process.GetCurrentProcess());
-
-        _process.Start();
+        if (_process == null)
+        {
+            _process = CreateProcess();
+            _process.Start();
+        }
     }
 
     public void Stop()
     {
-        _process.Kill();
+        if (_process != null)
+        {
+            _process.Kill();
+            _process.Dispose();
+            _process = null;
+        }
+
+        var processes = Process.GetProcessesByName("ChromaControl.OpenRGB");
+
+        foreach (var process in processes)
+        {
+            process.Kill();
+        }
     }
 
     public void Dispose()
     {
-        _process.Kill();
-        _process.Dispose();
+        Stop();
 
         _job.Dispose();
 

src/ChromaControl.SDK.OpenRGB/OpenRGBService.cs

@@ -14,9 +14,9 @@ namespace ChromaControl.SDK.OpenRGB;
 /// <inheritdoc/>
 public class OpenRGBService : IOpenRGBService, IAsyncDisposable
 {
+    private NativeOpenRGBService _service;
+    private BlockingCollection<OpenRGBDevice> _devices;
     private readonly OpenRGBManager _manager;
-    private readonly NativeOpenRGBService _service;
-    private readonly BlockingCollection<OpenRGBDevice> _devices;
 
     /// <inheritdoc/>
     public bool Started { get; internal set; }
@@ -45,6 +45,26 @@ public void UpdateConfiguration(JsonNode config)
         _manager.UpdateConfigFile(config);
     }
 
+    /// <inheritdoc/>
+    public async Task Restart(CancellationToken cancellationToken = default)
+    {
+        if (Started)
+        {
+            Started = false;
+
+            _service.DeviceListUpdated -= OnDeviceListUpdated;
+            await _service.DisposeAsync();
+            _service = new();
+            _service.DeviceListUpdated += OnDeviceListUpdated;
+
+            _devices = [];
+
+            _manager.Stop();
+
+            await StartServiceAsync(cancellationToken);
+        }
+    }
+
     /// <inheritdoc/>
     public async Task UpdateDeviceListAsync(CancellationToken cancellationToken = default)
     {
@@ -68,6 +88,11 @@ public async Task UpdateDeviceListAsync(CancellationToken cancellationToken = de
     /// <inheritdoc/>
     public async Task ResizeZoneAsync(int deviceIndex, int zoneIndex, int size, CancellationToken cancellationToken = default)
     {
+        if (!Started)
+        {
+            return;
+        }
+
         await _service.ResizeZoneAsync((uint)deviceIndex, (uint)zoneIndex, (uint)size, cancellationToken);
 
         _service.OnDeviceListUpdated(_service, new());
@@ -76,60 +101,110 @@ public async Task ResizeZoneAsync(int deviceIndex, int zoneIndex, int size, Canc
     /// <inheritdoc/>
     public Task ResizeZoneAsync(OpenRGBDevice device, int zoneIndex, int size, CancellationToken cancellationToken = default)
     {
+        if (!Started)
+        {
+            return Task.CompletedTask;
+        }
+
         return ResizeZoneAsync(device.Index, zoneIndex, size, cancellationToken);
     }
 
     /// <inheritdoc/>
     public Task ResizeZoneAsync(OpenRGBDevice device, OpenRGBZone zone, int size, CancellationToken cancellationToken = default)
     {
+        if (!Started)
+        {
+            return Task.CompletedTask;
+        }
+
         return ResizeZoneAsync(device.Index, zone.Index, size, cancellationToken);
     }
 
     /// <inheritdoc/>
     public async Task UpdateLedsAsync(int deviceIndex, Color[] colors, CancellationToken cancellationToken = default)
     {
+        if (!Started)
+        {
+            return;
+        }
+
         await _service.UpdateLedsAsync((uint)deviceIndex, colors, cancellationToken);
     }
 
     /// <inheritdoc/>
     public Task UpdateLedsAsync(OpenRGBDevice device, Color[] colors, CancellationToken cancellationToken = default)
     {
+        if (!Started)
+        {
+            return Task.CompletedTask;
+        }
+
         return UpdateLedsAsync(device.Index, colors, cancellationToken);
     }
 
     /// <inheritdoc/>
     public async Task UpdateZoneLedsAsync(int deviceIndex, int zoneIndex, Color[] colors, CancellationToken cancellationToken = default)
     {
+        if (!Started)
+        {
+            return;
+        }
+
         await _service.UpdateZoneLedsAsync((uint)deviceIndex, (uint)zoneIndex, colors, cancellationToken);
     }
 
     /// <inheritdoc/>
     public Task UpdateZoneLedsAsync(OpenRGBDevice device, int zoneIndex, Color[] colors, CancellationToken cancellationToken = default)
     {
+        if (!Started)
+        {
+            return Task.CompletedTask;
+        }
+
         return UpdateZoneLedsAsync(device.Index, zoneIndex, colors, cancellationToken);
     }
 
     /// <inheritdoc/>
     public Task UpdateZoneLedsAsync(OpenRGBDevice device, OpenRGBZone zone, Color[] colors, CancellationToken cancellationToken = default)
     {
+        if (!Started)
+        {
+            return Task.CompletedTask;
+        }
+
         return UpdateZoneLedsAsync(device.Index, zone.Index, colors, cancellationToken);
     }
 
     /// <inheritdoc/>
     public async Task UpdateSingleLedAsync(int deviceIndex, int ledIndex, Color color, CancellationToken cancellationToken = default)
     {
+        if (!Started)
+        {
+            return;
+        }
+
         await _service.UpdateSingleLedAsync((uint)deviceIndex, (uint)ledIndex, color, cancellationToken);
     }
 
     /// <inheritdoc/>
     public Task UpdateSingleLedAsync(OpenRGBDevice device, int ledIndex, Color color, CancellationToken cancellationToken = default)
     {
+        if (!Started)
+        {
+            return Task.CompletedTask;
+        }
+
         return UpdateSingleLedAsync(device.Index, ledIndex, color, cancellationToken);
     }
 
     /// <inheritdoc/>
     public Task UpdateSingleLedAsync(OpenRGBDevice device, OpenRGBLed led, Color color, CancellationToken cancellationToken = default)
     {
+        if (!Started)
+        {
+            return Task.CompletedTask;
+        }
+
         return UpdateSingleLedAsync(device.Index, led.Index, color, cancellationToken);
     }