Add locally sent logs event

Author: LucHeart

Desktop/Backend/BackendHubManager.cs

@@ -1,12 +1,6 @@
-using System.Collections.Concurrent;
-using System.Globalization;
-using System.Reactive.Subjects;
-using MudBlazor.Extensions;
+using System.Reactive.Subjects;
 using OpenShock.Desktop.Config;
-using OpenShock.Desktop.Models;
 using OpenShock.Desktop.Models.BaseImpl;
-using OpenShock.Desktop.ModuleBase.Models;
-using OpenShock.Desktop.Services;
 using OpenShock.MinimalEvents;
 using OpenShock.SDK.CSharp.Hub;
 using OpenShock.SDK.CSharp.Hub.Models;
@@ -22,14 +16,12 @@ public sealed class BackendHubManager
     private readonly OpenShockHubClient _openShockHubClient;
     private readonly OpenShockApi _openShockApi;
 
-    private string _liveConnectionId = string.Empty;
+    private string _currentHubConnectionId = string.Empty;
 
-    public IAsyncMinimalEventObservable<LogEventArgs> OnRemoteControlledShocker => _onRemoteControlledShocker;
-    private readonly AsyncMinimalEvent<LogEventArgs> _onRemoteControlledShocker = new();
+    public IAsyncMinimalEventObservable<ShockerLogEventArgs> OnShockerLog => _onShockerLog;
+    private readonly AsyncMinimalEvent<ShockerLogEventArgs> _onShockerLog = new();
 
     public Subject<Guid?> OnHubStatusUpdated { get; } = new();
-    
-
 
     public BackendHubManager(ILogger<BackendHubManager> logger,
         ConfigManager configManager,
@@ -41,15 +33,15 @@ public BackendHubManager(ILogger<BackendHubManager> logger,
         _openShockApi = openShockApi;
 
         _openShockHubClient.OnWelcome.SubscribeAsync(Welcome).AsTask().Wait();;
-        _openShockHubClient.OnLog.SubscribeAsync(RemoteActivateShockers).AsTask().Wait();
+        _openShockHubClient.OnLog.SubscribeAsync(OnShockerLogHandler).AsTask().Wait();
         _openShockHubClient.OnHubUpdate.SubscribeAsync(DeviceUpdate).AsTask().Wait();
 
         _openShockHubClient.OnHubStatus.SubscribeAsync(HubStatus).AsTask().Wait();
     }
 
     private Task Welcome(string connectionId)
     {
-        _liveConnectionId = connectionId;
+        _currentHubConnectionId = connectionId;
         _openShockApi.HubStates.Clear();
 
         OnHubStatusUpdated.OnNext(null);
@@ -105,15 +97,15 @@ await _openShockHubClient.Setup(new HubClientOptions
         });
     }
 
-    private Task RemoteActivateShockers(LogEventArgs logEventArgs)
+    private Task OnShockerLogHandler(LogEventArgs logEventArgs)
     {
-        if (logEventArgs.Sender.ConnectionId == _liveConnectionId)
+        var eventArgs = new ShockerLogEventArgs
         {
-            _logger.LogDebug("Ignoring remote command log cause it was the local connection");
-            return Task.CompletedTask;
-        }
+            LogEventArgs = logEventArgs,
+            IsRemote = logEventArgs.Sender.ConnectionId != _currentHubConnectionId
+        };
 
-        return _onRemoteControlledShocker.InvokeAsyncParallel(logEventArgs);
+        return _onShockerLog.InvokeAsyncParallel(eventArgs);
     }
 
     /// <summary>
@@ -134,5 +126,10 @@ public Task Control(IEnumerable<Control> shocks, string? customName = null)
         var shocksToSend = shocks.Where(x => enabledShockers.Contains(x.Id));
         return _openShockHubClient.Control(shocksToSend, customName);
     }
-    
+}
+
+public readonly struct ShockerLogEventArgs
+{
+    public required LogEventArgs LogEventArgs { get; init; }
+    public required bool IsRemote { get; init; }
 }

Desktop/ModuleManager/Implementation/OpenShockControl.cs

@@ -1,6 +1,5 @@
 using System.Collections.Immutable;
 using OpenShock.Desktop.Backend;
-using OpenShock.Desktop.Models.BaseImpl;
 using OpenShock.Desktop.ModuleBase.Api;
 using OpenShock.Desktop.ModuleBase.Models;
 using OpenShock.Desktop.Services;
@@ -14,27 +13,30 @@ public class OpenShockControl : IOpenShockControl, IAsyncDisposable
     private readonly BackendHubManager _backendHubManager;
     private readonly LiveControlManager _liveControlManager;
 
-    private readonly IAsyncDisposable _remoteControlledSubscription;
+    private readonly IAsyncDisposable _onShockerLogSubscription;
 
     public OpenShockControl(BackendHubManager backendHubManager, LiveControlManager liveControlManager)
     {
         _backendHubManager = backendHubManager;
         _liveControlManager = liveControlManager;
 
-        _remoteControlledSubscription = _backendHubManager.OnRemoteControlledShocker.SubscribeAsync(args =>
+        _onShockerLogSubscription = _backendHubManager.OnShockerLog.SubscribeAsync(args =>
         {
-            return _onRemoteControlledShocker.InvokeAsyncParallel(new RemoteControlledShockerArgs()
+            var logEvent = args.LogEventArgs;
+            var sender = logEvent.Sender;
+            
+            var baseArgs = new RemoteControlledShockerArgs()
             {
                 Sender = new ControlLogSender
                 {
-                    Id = args.Sender.Id,
-                    Name = args.Sender.Name,
-                    Image = args.Sender.Image,
-                    AdditionalItems = args.Sender.AdditionalItems.AsReadOnly(),
-                    ConnectionId = args.Sender.ConnectionId,
-                    CustomName = args.Sender.CustomName,
+                    Id = sender.Id,
+                    Name = sender.Name,
+                    Image = sender.Image,
+                    AdditionalItems = sender.AdditionalItems.AsReadOnly(),
+                    ConnectionId = sender.ConnectionId,
+                    CustomName = sender.CustomName,
                 },
-                Logs = args.Logs.Select(log => new ControlLog
+                Logs = logEvent.Logs.Select(log => new ControlLog
                 {
                     Duration = log.Duration,
                     Intensity = log.Intensity,
@@ -46,7 +48,9 @@ public OpenShockControl(BackendHubManager backendHubManager, LiveControlManager
                     Type = (ControlType)log.Type,
                     ExecutedAt = log.ExecutedAt
                 }).ToImmutableArray()
-            });
+            };
+
+            return args.IsRemote ? _onRemoteControlledShocker.InvokeAsyncParallel(baseArgs) : _onLocalControlledShocker.InvokeAsyncParallel(baseArgs);
         }).AsTask().Result;
     }
 
@@ -68,6 +72,10 @@ public void ControlAllShockers(byte intensity, ControlType type)
     public IAsyncMinimalEventObservable<RemoteControlledShockerArgs> OnRemoteControlledShocker =>
         _onRemoteControlledShocker;
     private readonly AsyncMinimalEvent<RemoteControlledShockerArgs> _onRemoteControlledShocker = new();
+    
+    public IAsyncMinimalEventObservable<RemoteControlledShockerArgs> OnLocalControlledShocker =>
+        _onLocalControlledShocker;
+    private readonly AsyncMinimalEvent<RemoteControlledShockerArgs> _onLocalControlledShocker = new();
 
     private bool _disposed;
 
@@ -76,7 +84,7 @@ public async ValueTask DisposeAsync()
         if (_disposed) return;
         _disposed = true;
 
-        await _remoteControlledSubscription.DisposeAsync();
+        await _onShockerLogSubscription.DisposeAsync();
         GC.SuppressFinalize(this);
     }
 

ModuleBase/Api/IOpenShockControl.cs

@@ -28,5 +28,13 @@ public interface IOpenShockControl
     /// <param name="type"></param>
     public void ControlAllShockers(byte intensity, ControlType type);
 
+    /// <summary>
+    /// A shocker has been remotely controlled by another location.
+    /// </summary>
     public IAsyncMinimalEventObservable<RemoteControlledShockerArgs> OnRemoteControlledShocker { get; }
+    
+    /// <summary>
+    /// This OpenShock Desktop instance has controlled a shocker.
+    /// </summary>
+    public IAsyncMinimalEventObservable<RemoteControlledShockerArgs> OnLocalControlledShocker { get; }
 }