Added observable & observer for TTS, to react faster to new messages when waiting.

Chat/Observers/TTSConsumer.cs

@@ -0,0 +1,41 @@
+using Serilog;
+using TwitchChatTTS.Chat.Speech;
+
+namespace TwitchChatTTS.Chat.Observers
+{
+    public class TTSConsumer : IObserver<TTSGroupedMessage>
+    {
+        private readonly TTSEngine _engine;
+        private readonly ILogger _logger;
+
+        private IDisposable? _cancellation;
+
+        public TTSConsumer(TTSEngine engine, ILogger logger)
+        {
+            _engine = engine;
+            _logger = logger;
+        }
+
+        public virtual void Subscribe(TTSPublisher provider) =>
+            _cancellation = provider.Subscribe(this);
+
+        public virtual void Unsubscribe()
+        {
+            _cancellation?.Dispose();
+        }
+
+        public void OnCompleted()
+        {
+        }
+
+        public void OnError(Exception error)
+        {
+            _logger.Error(error, "An error happened while observing for TTS messages.");
+        }
+
+        public void OnNext(TTSGroupedMessage value)
+        {
+            _engine.PlayerSource?.Cancel();
+        }
+    }
+}

Chat/Observers/TTSPublisher.cs

@@ -0,0 +1,40 @@
+using TwitchChatTTS.Chat.Speech;
+
+namespace TwitchChatTTS.Chat.Observers
+{
+    public class TTSPublisher : IObservable<TTSGroupedMessage>
+    {
+        private readonly HashSet<IObserver<TTSGroupedMessage>> _observers;
+        private readonly HashSet<TTSGroupedMessage> _messages;
+
+
+        public TTSPublisher()
+        {
+            _observers = new();
+            _messages = new();
+        }
+
+
+        public IDisposable Subscribe(IObserver<TTSGroupedMessage> observer)
+        {
+            if (_observers.Add(observer))
+            {
+                foreach (var item in _messages)
+                    observer.OnNext(item);
+            }
+
+            return new Unsubscriber<TTSGroupedMessage>(_observers, observer);
+        }
+    }
+
+    internal sealed class Unsubscriber<T> : IDisposable
+    {
+        private readonly ISet<IObserver<T>> _observers;
+        private readonly IObserver<T> _observer;
+
+        internal Unsubscriber(ISet<IObserver<T>> observers, IObserver<T> observer)
+            => (_observers, _observer) = (observers, observer);
+
+        public void Dispose() => _observers.Remove(_observer);
+    }
+}