refactor: 实现 INetworkMonitorService 逻辑

Author: ArgoZhang

src/BootstrapBlazor/Components/NetworkMonitor/NetworkMonitor.cs

@@ -22,5 +22,3 @@
         </div>
     </Template>
 </Popover>
-
-<NetworkMonitor OnNetworkStateChanged="OnNetworkStateChanged" Indicators="@_indicators"></NetworkMonitor>

src/BootstrapBlazor/Components/NetworkMonitor/NetworkMonitorIndicator.razor

@@ -13,7 +13,7 @@ namespace BootstrapBlazor.Components;
 /// <remarks>This component allows you to configure the text, placement, and trigger behavior of a tooltip that
 /// appears when interacting with the network monitor indicator. The tooltip can be customized to provide additional
 /// information to users.</remarks>
-public partial class NetworkMonitorIndicator
+public partial class NetworkMonitorIndicator : IDisposable
 {
     /// <summary>
     /// 获得/设置 Popover 弹窗标题 默认为 null
@@ -37,8 +37,10 @@ public partial class NetworkMonitorIndicator
     [Inject, NotNull]
     private IStringLocalizer<NetworkMonitorIndicator>? Localizer { get; set; }
 
+    [Inject, NotNull]
+    private INetworkMonitorService? NetworkMonitorService { get; set; }
+
     private NetworkMonitorState _state = new();
-    private readonly List<string> _indicators = [];
     private string _networkTypeString = "";
     private string _downlinkString = "";
     private string _rttString = "";
@@ -53,11 +55,11 @@ public partial class NetworkMonitorIndicator
     /// <summary>
     /// <inheritdoc/>
     /// </summary>
-    protected override void OnInitialized()
+    protected override async Task OnInitializedAsync()
     {
-        base.OnInitialized();
+        await base.OnInitializedAsync();
 
-        _indicators.Add(Id);
+        await NetworkMonitorService.RegisterStateChangedCallback(this, OnNetworkStateChanged);
     }
 
     /// <summary>
@@ -69,6 +71,7 @@ protected override void OnParametersSet()
 
         Trigger ??= "hover focus";
         Title ??= Localizer["Title"];
+
         _networkTypeString = Localizer["NetworkType"];
         _downlinkString = Localizer["Downlink"];
         _rttString = Localizer["RTT"];
@@ -80,4 +83,22 @@ private Task OnNetworkStateChanged(NetworkMonitorState state)
         StateHasChanged();
         return Task.CompletedTask;
     }
+
+    private void Dispose(bool disposing)
+    {
+        if (disposing)
+        {
+            NetworkMonitorService.UnregisterStateChangedCallback(this);
+        }
+    }
+
+    /// <summary>
+    /// <inheritdoc/>
+    /// </summary>
+    /// <exception cref="NotImplementedException"></exception>
+    public void Dispose()
+    {
+        Dispose(true);
+        GC.SuppressFinalize(this);
+    }
 }

src/BootstrapBlazor/Components/NetworkMonitor/NetworkMonitorIndicator.razor.cs

@@ -10,11 +10,6 @@ namespace BootstrapBlazor.Components;
 /// </summary>
 public class NetworkMonitorState
 {
-    /// <summary>
-    /// Gets or sets a value indicating whether the network is online
-    /// </summary>
-    public bool IsOnline { get; set; }
-
     /// <summary>
     /// Gets or sets the current network type
     /// </summary>

src/BootstrapBlazor/Components/NetworkMonitor/NetworkMonitorState.cs

@@ -93,6 +93,7 @@ public static IServiceCollection AddBootstrapBlazor(this IServiceCollection serv
         services.TryAddScoped<IMediaDevices, DefaultMediaDevices>();
         services.TryAddScoped<IVideoDevice, DefaultVideoDevice>();
         services.TryAddScoped<IAudioDevice, DefaultAudioDevice>();
+        services.TryAddScoped<INetworkMonitorService, DefaultNetowrkMonitorService>();
         services.AddScoped<TabItemTextOptions>();
         services.AddScoped<DialogService>();
         services.AddScoped<MaskService>();

src/BootstrapBlazor/Extensions/BootstrapBlazorServiceCollectionExtensions.cs

@@ -3,24 +3,110 @@
 // See the LICENSE file in the project root for more information.
 // Maintainer: Argo Zhang([email protected]) Website: https://www.blazor.zone
 
+using System.Collections.Concurrent;
+
 namespace BootstrapBlazor.Components;
 
 /// <summary>
 /// 网络状态服务
 /// </summary>
-class DefaultNetowrkMonitorService(IJSRuntime jSRuntime)
+class DefaultNetowrkMonitorService : INetworkMonitorService, IAsyncDisposable
 {
     [NotNull]
     private JSModule? _module = null;
+    [NotNull]
+    private JSModule? _networkModule = null;
+    private readonly IJSRuntime _runtime;
+    private readonly DotNetObjectReference<DefaultNetowrkMonitorService> _interop;
+    private readonly ConcurrentDictionary<IComponent, Func<NetworkMonitorState, Task>> _callbacks = new();
+    private bool _init = false;
+    private readonly SemaphoreSlim _semaphoreSlim = new(1, 1);
 
-    private Task<JSModule> LoadModule() => jSRuntime.LoadUtility();
+    public DefaultNetowrkMonitorService(IJSRuntime jsRuntime)
+    {
+        _runtime = jsRuntime;
+        _interop = DotNetObjectReference.Create(this);
+    }
+
+    private Task<JSModule> LoadModule() => _runtime.LoadUtility();
 
     /// <summary>
-    /// 获取剪切板数据方法
+    /// <inheritdoc/>
     /// </summary>
     public async Task<NetworkMonitorState> GetNetworkMonitorState(CancellationToken token = default)
     {
         _module ??= await LoadModule();
         return await _module.InvokeAsync<NetworkMonitorState?>("getNetworkInfo", token) ?? new();
     }
+
+    /// <summary>
+    /// <inheritdoc/>
+    /// </summary>
+    /// <param name="component"></param>
+    /// <param name="callback"></param>
+    public async Task RegisterStateChangedCallback(IComponent component, Func<NetworkMonitorState, Task> callback)
+    {
+        _callbacks.AddOrUpdate(component, key => callback, (k, v) => callback);
+
+        if (!_init)
+        {
+            await _semaphoreSlim.WaitAsync();
+            if (!_init)
+            {
+                _init = true;
+
+                _networkModule ??= await _runtime.LoadModuleByName("net");
+                await _networkModule.InvokeVoidAsync("init", new
+                {
+                    Invoke = _interop,
+                    OnNetworkStateChangedCallback = nameof(TriggerNetworkStateChanged)
+                });
+            }
+            _semaphoreSlim.Release();
+        }
+    }
+
+    /// <summary>
+    /// <inheritdoc/>
+    /// </summary>
+    /// <param name="component"></param>
+    public void UnregisterStateChangedCallback(IComponent component)
+    {
+        _callbacks.TryRemove(component, out _);
+    }
+
+    /// <summary>
+    /// JSInvoke 回调方法
+    /// </summary>
+    /// <returns></returns>
+    [JSInvokable]
+    public async Task TriggerNetworkStateChanged(NetworkMonitorState state)
+    {
+        foreach (var callback in _callbacks.Values)
+        {
+            if (callback != null)
+            {
+                await callback(state);
+            }
+        }
+    }
+
+    /// <summary>
+    /// <inheritdoc/>
+    /// </summary>
+    /// <returns></returns>
+    public async ValueTask DisposeAsync()
+    {
+        if (_module != null)
+        {
+            await _module.DisposeAsync();
+            _module = null;
+        }
+        if (_networkModule != null)
+        {
+            await _networkModule.DisposeAsync();
+            _networkModule = null;
+        }
+        _interop?.Dispose();
+    }
 }

src/BootstrapBlazor/Services/DefaultNetworkMonitorService.cs

@@ -6,9 +6,32 @@
 namespace BootstrapBlazor.Components;
 
 /// <summary>
-/// 
+/// Defines a service for monitoring network state and retrieving the current network monitor status.
 /// </summary>
 public interface INetworkMonitorService
 {
+    /// <summary>
+    /// Retrieves the current state of the network monitor.
+    /// </summary>
+    /// <param name="token">A cancellation token that can be used to cancel the operation.</param>
+    /// <returns>A task representing the asynchronous operation. The task result contains the current <see
+    /// cref="NetworkMonitorState"/>.</returns>
+    Task<NetworkMonitorState> GetNetworkMonitorState(CancellationToken token = default);
 
+    /// <summary>
+    /// Registers a callback to be invoked when the network monitor state changes.
+    /// </summary>
+    /// <remarks>The callback is executed asynchronously whenever the network monitor detects a change in
+    /// state. Ensure that the callback function is thread-safe and handles any exceptions that may occur during
+    /// execution.</remarks>
+    /// <param name="component">The component that will be associated with the callback. Cannot be null.</param>
+    /// <param name="callback">A function to be called when the network monitor state changes. The function receives the new state and returns
+    /// a task. Cannot be null.</param>
+    Task RegisterStateChangedCallback(IComponent component, Func<NetworkMonitorState, Task> callback);
+
+    /// <summary>
+    /// Unregisters a previously registered callback for state changes on the specified component.
+    /// </summary>
+    /// <param name="component">The component for which the state change callback should be unregistered. Cannot be null.</param>
+    void UnregisterStateChangedCallback(IComponent component);
 }