Added removing arcdps listener

Denrage · Jan 19, 2025 · 51ae52b · 51ae52b
1 parent 3df7def
commit 51ae52b
Show file tree

Hide file tree

Showing 7 changed files with 76 additions and 27 deletions.
diff --git a/Blish HUD/GameServices/ArcDps/V2/ArcDpsClient.cs b/Blish HUD/GameServices/ArcDps/V2/ArcDpsClient.cs
@@ -62,14 +62,14 @@ public ArcDpsClient(ArcDpsBridgeVersion arcDpsBridgeVersion) {
         public bool IsMessageTypeAvailable(MessageType type)
             => this._processors.ContainsKey((int)type);
 
-        public void RegisterMessageTypeListener<T>(int type, Func<T, CancellationToken, Task> listener)
+        public void RegisterMessageTypeListener<T>(IArcDpsMessageListener<T> listener)
             where T : struct {
-            var processor = (MessageProcessor<T>)_processors[type];
-            if (_messageQueues[type] == null) {
-                _messageQueues[type] = new BlockingCollection<byte[]>();
+            var processor = (MessageProcessor<T>)_processors[(int)listener.MessageType];
+            if (_messageQueues[(int)listener.MessageType] == null) {
+                _messageQueues[(int)listener.MessageType] = new BlockingCollection<byte[]>();
 
                 try {
-                    Task.Run(() => ProcessMessage(processor, _messageQueues[type]));
+                    Task.Run(() => ProcessMessage(processor, _messageQueues[(int)listener.MessageType]));
                 } catch (OperationCanceledException) {
                     // NOP
                 }

diff --git a/Blish HUD/GameServices/ArcDps/V2/CommonFields.cs b/Blish HUD/GameServices/ArcDps/V2/CommonFields.cs
@@ -41,7 +41,7 @@ public void Activate() {
             if (_enabled) return;
 
             _enabled = true;
-            GameService.ArcDpsV2.RegisterMessageType<CombatCallback>(MessageType.CombatEventArea, CombatHandler);
+            GameService.ArcDpsV2.RegisterMessageType<CombatCallback>(new ArcDpsMessageListener<CombatCallback>(MessageType.CombatEventArea, CombatHandler));
         }
 
         private Task CombatHandler(CombatCallback combatEvent, CancellationToken ct) {

diff --git a/Blish HUD/GameServices/ArcDps/V2/IArcDpsClient.cs b/Blish HUD/GameServices/ArcDps/V2/IArcDpsClient.cs
@@ -19,6 +19,6 @@ internal interface IArcDpsClient : IDisposable {
 
         bool IsMessageTypeAvailable(MessageType type);
 
-        void RegisterMessageTypeListener<T>(int type, Func<T, CancellationToken, Task> listener) where T : struct;
+        void RegisterMessageTypeListener<T>(IArcDpsMessageListener<T> listener) where T : struct;
     }
 }
diff --git a/Blish HUD/GameServices/ArcDps/V2/IArcDpsMessageListener.cs b/Blish HUD/GameServices/ArcDps/V2/IArcDpsMessageListener.cs
@@ -0,0 +1,38 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Blish_HUD.GameServices.ArcDps.V2 {
+    public interface IArcDpsMessageListener<T> : IDisposable
+        where T : struct {
+        event Action<IArcDpsMessageListener<T>> Disposing;
+
+        MessageType MessageType { get; }
+
+        Task HandleAsync(T message, CancellationToken ct);
+    }
+
+    public class ArcDpsMessageListener<T> : IArcDpsMessageListener<T>
+        where T : struct {
+        private readonly Func<T, CancellationToken, Task> listener;
+
+        public MessageType MessageType { get; }
+
+        public event Action<IArcDpsMessageListener<T>> Disposing;
+
+        public ArcDpsMessageListener(MessageType type, Func<T, CancellationToken, Task> listener) {
+            this.MessageType = type;
+            this.listener = listener;
+        }
+
+        public async Task HandleAsync(T message, CancellationToken ct)
+            => await this.listener(message, ct);
+
+        public void Dispose() {
+            this.Disposing?.Invoke(this);
+        }
+    }
+}
diff --git a/Blish HUD/GameServices/ArcDps/V2/Processors/MessageProcessor{T}.cs b/Blish HUD/GameServices/ArcDps/V2/Processors/MessageProcessor{T}.cs
@@ -7,7 +7,7 @@
 namespace Blish_HUD.GameServices.ArcDps.V2.Processors {
     internal abstract class MessageProcessor<T> : MessageProcessor
         where T : struct {
-        private readonly List<Func<T, CancellationToken, Task>> listeners = new List<Func<T, CancellationToken, Task>>();
+        private readonly List<IArcDpsMessageListener<T>> listeners = new List<IArcDpsMessageListener<T>>();
 
         public override void Process(byte[] message, CancellationToken ct) {
             if (listeners.Count > 0 && TryInternalProcess(message, out var parsedMessage)) {
@@ -19,14 +19,20 @@ public override void Process(byte[] message, CancellationToken ct) {
         private async Task SendToListener(T Message, CancellationToken ct) {
             foreach (var listener in listeners) {
                 ct.ThrowIfCancellationRequested();
-                await listener.Invoke(Message, ct);
+                await listener.HandleAsync(Message, ct);
             }
         }
 
         internal abstract bool TryInternalProcess(byte[] message, out T result);
 
-        public void RegisterListener(Func<T, CancellationToken, Task> listener) {
+        public void RegisterListener(IArcDpsMessageListener<T> listener) {
             listeners.Add(listener);
+            listener.Disposing += RemoveListener;
+        }
+
+        private void RemoveListener(IArcDpsMessageListener<T> listener) {
+            listener.Disposing -= RemoveListener;
+            listeners.Remove(listener);
         }
 
     }

diff --git a/Blish HUD/GameServices/ArcDpsService.cs b/Blish HUD/GameServices/ArcDpsService.cs
@@ -67,14 +67,14 @@ public class ArcDpsService : GameService {
         public void SubscribeToCombatEventId(Action<object, RawCombatEventArgs> func, params uint[] skillIds) {
 
             if (!_subscribed) {
-                GameService.ArcDpsV2.RegisterMessageType<CombatCallback>(GameServices.ArcDps.V2.MessageType.CombatEventArea, async (combatEvent, ct) => {
+                GameService.ArcDpsV2.RegisterMessageType(new GameServices.ArcDps.V2.ArcDpsMessageListener<CombatCallback>(GameServices.ArcDps.V2.MessageType.CombatEventArea, async (combatEvent, ct) => {
                     DispatchSkillSubscriptions(combatEvent, RawCombatEventArgs.CombatEventType.Area);
                     await System.Threading.Tasks.Task.CompletedTask;
-                });
-                GameService.ArcDpsV2.RegisterMessageType<CombatCallback>(GameServices.ArcDps.V2.MessageType.CombatEventLocal, async (combatEvent, ct) => {
+                }));
+                GameService.ArcDpsV2.RegisterMessageType(new GameServices.ArcDps.V2.ArcDpsMessageListener<CombatCallback>(GameServices.ArcDps.V2.MessageType.CombatEventLocal, async (combatEvent, ct) => {
                     DispatchSkillSubscriptions(combatEvent, RawCombatEventArgs.CombatEventType.Local);
                     await System.Threading.Tasks.Task.CompletedTask;
-                });
+                }));
                 _subscribed = true;
             }
 
@@ -117,17 +117,17 @@ protected override void Initialize() {
             this.RawCombatEvent += (a, b) => { Interlocked.Increment(ref Counter); };
 #endif
 
-            GameService.ArcDpsV2.RegisterMessageType<CombatCallback>(GameServices.ArcDps.V2.MessageType.CombatEventArea, async (combatEvent, ct) => {
+            GameService.ArcDpsV2.RegisterMessageType(new GameServices.ArcDps.V2.ArcDpsMessageListener<CombatCallback>(GameServices.ArcDps.V2.MessageType.CombatEventArea, async (combatEvent, ct) => {
                 var rawCombat = ConvertFrom(combatEvent, RawCombatEventArgs.CombatEventType.Area);
                 this.RawCombatEvent?.Invoke(this, rawCombat);
                 await System.Threading.Tasks.Task.CompletedTask;
-            });
+            }));
 
-            GameService.ArcDpsV2.RegisterMessageType<CombatCallback>(GameServices.ArcDps.V2.MessageType.CombatEventLocal, async (combatEvent, ct) => {
+            GameService.ArcDpsV2.RegisterMessageType(new GameServices.ArcDps.V2.ArcDpsMessageListener<CombatCallback>(GameServices.ArcDps.V2.MessageType.CombatEventLocal, async (combatEvent, ct) => {
                 var rawCombat = ConvertFrom(combatEvent, RawCombatEventArgs.CombatEventType.Local);
                 this.RawCombatEvent?.Invoke(this, rawCombat);
                 await System.Threading.Tasks.Task.CompletedTask;
-            });
+            }));
         }
 
         protected override void Load() {

diff --git a/Blish HUD/GameServices/ArcDpsServiceV2.cs b/Blish HUD/GameServices/ArcDpsServiceV2.cs
@@ -77,20 +77,25 @@ private set {
         public bool IsMessageTypeAvailable(MessageType type)
             => _arcDpsClient.IsMessageTypeAvailable(type);
 
-        public void RegisterMessageType<T>(MessageType type, Func<T, CancellationToken, Task> listener)
+        public void RegisterMessageType<T>(IArcDpsMessageListener<T> listener)
             where T : struct {
-            RegisterMessageType<T>((int)type, listener);
-        }
-
-        public void RegisterMessageType<T>(int type, Func<T, CancellationToken, Task> listener)
-            where T : struct {
-            Action action = () => _arcDpsClient.RegisterMessageTypeListener(type, listener);
+            Action action = () => _arcDpsClient.RegisterMessageTypeListener(listener);
             _registerListeners.Add(action);
             if (_arcDpsClient != null) {
                 action();
             }
         }
 
+        public void RegisterMessageType<T>(MessageType messageType, Func<T, CancellationToken, Task> listener)
+            where T : struct {
+            RegisterMessageType(new ArcDpsMessageListener<T>(messageType, listener));
+        }
+
+        public void RegisterMessageType<T>(int messageType, Func<T, CancellationToken, Task> listener) 
+            where T : struct {
+            RegisterMessageType(new ArcDpsMessageListener<T>((MessageType)messageType, listener));
+        }
+
         protected override void Initialize() {
             this.Common = new CommonFields();
             _stopwatch = new Stopwatch();
@@ -133,9 +138,9 @@ private void Start(uint processId) {
                 _arcDpsClient.Error += SocketErrorHandler;
                 _arcDpsClient.Initialize(new IPEndPoint(IPAddress.Loopback, GetPort(processId, version)), _arcDpsClientCancellationTokenSource.Token);
 
-                RegisterMessageType<ImGuiCallback>(MessageType.ImGui, async (imGuiCallback, ct) => {
+                RegisterMessageType(new ArcDpsMessageListener<ImGuiCallback>(MessageType.ImGui, async (imGuiCallback, ct) => {
                     this.HudIsActive = imGuiCallback.NotCharacterSelectOrLoading != 0;
-                });
+                }));
             }
         }