PlayStation: move per-device HID state onto the device classes

Addresses DarthAffe's review feedback on PR #454 — the per-device
lifecycle state (HidStream, optional HidRawWriter, DevicePath, and
the "known disconnected" hint) was previously held in four collections
on the provider, all keyed by IRGBDevice. Moves that state onto the
DualShock4 / DualSense device classes themselves and lets each device
clean up its own I/O via Dispose.

- New IPlayStationRGBDevice interface exposes DevicePath /
  IsKnownDisconnected / MarkKnownDisconnected so the provider's
  hot-plug iteration can walk Devices.OfType<IPlayStationRGBDevice>()
  instead of consulting a Dictionary<IRGBDevice, ...>.
- DualShock4RGBDevice and DualSenseRGBDevice each take their HidStream,
  HidRawWriter? and DevicePath in the constructor, override Dispose
  to send a graceful off-frame (when not known-disconnected) and
  release the I/O. SuspendWrites / Shutdown are no longer needed on
  the device class — MarkKnownDisconnected covers the former,
  Dispose covers the latter.
- Provider drops _openStreams, _devicePaths, _rawWriters,
  _confirmedDisconnected dictionaries plus the _stateLock and
  _disposing flag they protected. RemoveDevice becomes a
  base.RemoveDevice + device.Dispose passthrough. Reconcile and
  SuspendDeadDevices iterate Devices.OfType<IPlayStationRGBDevice>()
  and read .DevicePath off each. Dispose marks all owned devices
  as known-disconnected before tearing them down so their off-frame
  attempt is skipped at app shutdown.

No behaviour change: same hot-plug timings, same off-frame policy,
same alive-paths snapshot mechanism.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: logicallysynced

RGB.NET.Devices.PlayStation/DualSense/DualSenseRGBDevice.cs

@@ -1,25 +1,40 @@
+using HidSharp;
 using RGB.NET.Core;
 
 namespace RGB.NET.Devices.PlayStation;
 
-/// <inheritdoc />
+/// <inheritdoc cref="AbstractRGBDevice{TDeviceInfo}" />
 /// <summary>
-/// Represents a Sony DualSense controller (PS5 / DualSense Edge).
+/// Represents a Sony DualSense controller (PS5 / DualSense Edge). Owns its
+/// HID I/O directly — the open <see cref="HidStream"/>, the optional Win32
+/// raw-write fallback, and the device path used for identity comparison
+/// during hot-plug — and tears them down on <see cref="Dispose"/>.
 /// </summary>
-public sealed class DualSenseRGBDevice : AbstractRGBDevice<PlayStationDeviceInfo>
+public sealed class DualSenseRGBDevice : AbstractRGBDevice<PlayStationDeviceInfo>, IPlayStationRGBDevice
 {
     #region Properties & Fields
 
     private readonly DualSenseUpdateQueue _updateQueue;
+    private readonly HidStream _stream;
+    private readonly HidRawWriter? _rawWriter;
+
+    /// <inheritdoc />
+    public string DevicePath { get; }
+
+    /// <inheritdoc />
+    public bool IsKnownDisconnected { get; private set; }
 
     #endregion
 
     #region Constructors
 
-    internal DualSenseRGBDevice(PlayStationDeviceInfo deviceInfo, DualSenseUpdateQueue updateQueue)
+    internal DualSenseRGBDevice(PlayStationDeviceInfo deviceInfo, DualSenseUpdateQueue updateQueue, HidStream stream, HidRawWriter? rawWriter, string devicePath)
         : base(deviceInfo, updateQueue)
     {
         _updateQueue = updateQueue;
+        _stream = stream;
+        _rawWriter = rawWriter;
+        DevicePath = devicePath ?? string.Empty;
         InitializeLayout();
     }
 
@@ -58,8 +73,22 @@ private void InitializeLayout()
         }
     }
 
-    internal void SuspendWrites() => _updateQueue.SuspendWrites();
-    internal void Shutdown(bool sendOffFrame = true) => _updateQueue.Shutdown(sendOffFrame);
+    /// <inheritdoc />
+    public void MarkKnownDisconnected()
+    {
+        IsKnownDisconnected = true;
+        try { _updateQueue.SuspendWrites(); } catch { /* best effort */ }
+    }
+
+    /// <inheritdoc />
+    public override void Dispose()
+    {
+        try { _updateQueue.Shutdown(sendOffFrame: !IsKnownDisconnected); } catch { /* best effort */ }
+        try { _rawWriter?.Dispose(); } catch { /* best effort */ }
+        try { _stream.Dispose(); } catch { /* best effort */ }
+
+        base.Dispose();
+    }
 
     #endregion
 }

RGB.NET.Devices.PlayStation/DualShock4/DualShock4RGBDevice.cs

@@ -1,25 +1,40 @@
+using HidSharp;
 using RGB.NET.Core;
 
 namespace RGB.NET.Devices.PlayStation;
 
-/// <inheritdoc />
+/// <inheritdoc cref="AbstractRGBDevice{TDeviceInfo}" />
 /// <summary>
-/// Represents a Sony DualShock 4 controller.
+/// Represents a Sony DualShock 4 controller. Owns its HID I/O directly —
+/// the open <see cref="HidStream"/>, the optional Win32 raw-write fallback,
+/// and the device path used for identity comparison during hot-plug — and
+/// tears them down on <see cref="Dispose"/>.
 /// </summary>
-public sealed class DualShock4RGBDevice : AbstractRGBDevice<PlayStationDeviceInfo>
+public sealed class DualShock4RGBDevice : AbstractRGBDevice<PlayStationDeviceInfo>, IPlayStationRGBDevice
 {
     #region Properties & Fields
 
     private readonly DualShock4UpdateQueue _updateQueue;
+    private readonly HidStream _stream;
+    private readonly HidRawWriter? _rawWriter;
+
+    /// <inheritdoc />
+    public string DevicePath { get; }
+
+    /// <inheritdoc />
+    public bool IsKnownDisconnected { get; private set; }
 
     #endregion
 
     #region Constructors
 
-    internal DualShock4RGBDevice(PlayStationDeviceInfo deviceInfo, DualShock4UpdateQueue updateQueue)
+    internal DualShock4RGBDevice(PlayStationDeviceInfo deviceInfo, DualShock4UpdateQueue updateQueue, HidStream stream, HidRawWriter? rawWriter, string devicePath)
         : base(deviceInfo, updateQueue)
     {
         _updateQueue = updateQueue;
+        _stream = stream;
+        _rawWriter = rawWriter;
+        DevicePath = devicePath ?? string.Empty;
         InitializeLayout();
     }
 
@@ -38,8 +53,26 @@ private void InitializeLayout()
             lightbar.Shape = Shape.Rectangle;
     }
 
-    internal void SuspendWrites() => _updateQueue.SuspendWrites();
-    internal void Shutdown(bool sendOffFrame = true) => _updateQueue.Shutdown(sendOffFrame);
+    /// <inheritdoc />
+    public void MarkKnownDisconnected()
+    {
+        IsKnownDisconnected = true;
+        try { _updateQueue.SuspendWrites(); } catch { /* best effort */ }
+    }
+
+    /// <inheritdoc />
+    public override void Dispose()
+    {
+        // Off-frame is best-effort: send a final all-zero lightbar so the
+        // controller doesn't sit on our last colour after we tear down.
+        // Skipped when we've already been marked disconnected — the handle
+        // is invalid and the write would just throw.
+        try { _updateQueue.Shutdown(sendOffFrame: !IsKnownDisconnected); } catch { /* best effort */ }
+        try { _rawWriter?.Dispose(); } catch { /* best effort */ }
+        try { _stream.Dispose(); } catch { /* best effort */ }
+
+        base.Dispose();
+    }
 
     #endregion
 }

RGB.NET.Devices.PlayStation/Generic/IPlayStationRGBDevice.cs

@@ -0,0 +1,29 @@
+using RGB.NET.Core;
+
+namespace RGB.NET.Devices.PlayStation;
+
+/// <summary>
+/// Common contract for PlayStation controller RGB devices. Each device owns
+/// its own HID I/O (HidStream + optional HidRawWriter) and DevicePath, and
+/// is responsible for tearing those down on <see cref="System.IDisposable.Dispose"/>.
+/// </summary>
+internal interface IPlayStationRGBDevice : IRGBDevice
+{
+    /// <summary>The Windows / Linux HID device path the controller was opened on.</summary>
+    string DevicePath { get; }
+
+    /// <summary>
+    /// Set by the provider's hot-plug pass when the controller has disappeared
+    /// from HID enumeration. Causes Dispose to skip the polite off-frame write
+    /// (which would just throw against the invalidated handle anyway).
+    /// </summary>
+    bool IsKnownDisconnected { get; }
+
+    /// <summary>
+    /// Records that the device is no longer reachable on its HID path AND
+    /// suspends any further writes from the update queue. Called from the
+    /// hot-plug callback before the debounced Reconcile fires, so the next
+    /// 30Hz tick is a no-op rather than an exception.
+    /// </summary>
+    void MarkKnownDisconnected();
+}