DashboardPageViewModel.cs

이 파일의 문서화 페이지로 가기

using Dreamine.Hybrid.Interfaces;
using Dreamine.Hybrid.State;
using DreamineVMS.Messages;
using DreamineVMS.Models;
using DreamineVMS.Services.Cameras;
using DreamineVMS.Services.Runtime;
using DreamineVMS.States;
 
namespace DreamineVMS.Blazor.ViewModels;

public sealed class DashboardPageViewModel : IDisposable
{
    private readonly IHybridStateStore<VmsDashboardState> _store;
    private readonly IHybridMessageBus _bus;
    private readonly IVmsCameraRepository _repository;
    private readonly ICameraRuntimeStateService _runtimeState;
    private bool _isInitialized;

    public DashboardPageViewModel(
        IHybridStateStore<VmsDashboardState> store,
        IHybridMessageBus bus,
        IVmsCameraRepository repository,
        ICameraRuntimeStateService runtimeState)
    {
        _store = store ?? throw new ArgumentNullException(nameof(store));
        _bus = bus ?? throw new ArgumentNullException(nameof(bus));
        _repository = repository ?? throw new ArgumentNullException(nameof(repository));
        _runtimeState = runtimeState ?? throw new ArgumentNullException(nameof(runtimeState));
    }

    public event EventHandler? StateChanged;

    public int TotalCameraCount => _store.State.TotalCameraCount;

    public int ConnectedCameraCount => _store.State.ConnectedCameraCount;

    public int RecordingCameraCount => _store.State.RecordingCameraCount;

    public string LastEvent => _store.State.LastEvent;

    public string LastUpdatedText => _store.State.LastUpdated?.ToString("yyyy-MM-dd HH:mm:ss") ?? "-";

    public IReadOnlyList<DashboardCameraItemViewModel> Cameras { get; private set; }
        = Array.Empty<DashboardCameraItemViewModel>();

    public void Initialize()
    {
        if (_isInitialized)
        {
            return;
        }
 
        RefreshCameras();
 
        _store.StateChanged += OnDashboardStateChanged;
        _runtimeState.StateChanged += OnCameraRuntimeStateChanged;
 
        _isInitialized = true;
    }

    public Task OpenLiveAsync()
    {
        return Task.CompletedTask;
    }

    public Task ConnectCameraAsync(string cameraId)
    {
        return PublishAsync(VmsDashboardActions.CameraConnect, cameraId);
    }

    public Task DisconnectCameraAsync(string cameraId)
    {
        return PublishAsync(VmsDashboardActions.CameraDisconnect, cameraId);
    }

    public Task StartAllAsync()
    {
        return PublishAsync(VmsDashboardActions.CameraStartAll);
    }

    public Task StopAllAsync()
    {
        return PublishAsync(VmsDashboardActions.CameraStopAll);
    }

    public Task ClearLogsAsync()
    {
        return PublishAsync(VmsDashboardActions.ClearLogs);
    }

    private Task PublishAsync(string action, string? cameraId = null)
    {
        return _bus.PublishAsync(new VmsDashboardActionRequestedMessage
        {
            Action = action,
            CameraId = cameraId
        });
    }

    public void Dispose()
    {
        if (!_isInitialized)
        {
            return;
        }
 
        _store.StateChanged -= OnDashboardStateChanged;
        _runtimeState.StateChanged -= OnCameraRuntimeStateChanged;
 
        _isInitialized = false;
    }

    private void RefreshCameras()
    {
        Cameras = _repository.GetAll()
            .OrderBy(camera => camera.DisplayOrder)
            .Select(CreateCameraItem)
            .ToArray();
    }

    private DashboardCameraItemViewModel CreateCameraItem(CameraDevice camera)
    {
        CameraRuntimeState runtimeState = _runtimeState.GetState(camera.Id);
 
        return new DashboardCameraItemViewModel(
            id: camera.Id,
            name: camera.Name,
            host: camera.Host,
            hlsUrl: camera.HlsUrl,
            displayOrder: camera.DisplayOrder,
            enabled: camera.Enabled,
            state: runtimeState.State,
            lastMessage: runtimeState.LastMessage,
            lastError: runtimeState.LastError,
            lastUpdated: runtimeState.LastUpdated,
            restartCount: runtimeState.RestartCount);
    }

    private void OnDashboardStateChanged(
        object? sender,
        HybridStateChangedEventArgs<VmsDashboardState> e)
    {
        NotifyStateChanged();
    }

    private void OnCameraRuntimeStateChanged(object? sender, CameraRuntimeState e)
    {
        RefreshCameras();
        NotifyStateChanged();
    }

    private void NotifyStateChanged()
    {
        StateChanged?.Invoke(this, EventArgs.Empty);
    }
}

public sealed class DashboardCameraItemViewModel
{
    public DashboardCameraItemViewModel(
        string id,
        string name,
        string host,
        string hlsUrl,
        int displayOrder,
        bool enabled,
        CameraConnectionState state,
        string lastMessage,
        string? lastError,
        DateTimeOffset lastUpdated,
        int restartCount)
    {
        Id = id;
        Name = name;
        Host = host;
        HlsUrl = hlsUrl;
        DisplayOrder = displayOrder;
        Enabled = enabled;
        State = state;
        LastMessage = lastMessage;
        LastError = lastError;
        LastUpdated = lastUpdated;
        RestartCount = restartCount;
    }

    public string Id { get; }

    public string Name { get; }

    public string Host { get; }

    public string HlsUrl { get; }

    public int DisplayOrder { get; }

    public bool Enabled { get; }

    public CameraConnectionState State { get; }

    public string LastMessage { get; }

    public string? LastError { get; }

    public DateTimeOffset LastUpdated { get; }

    public int RestartCount { get; }

    public string StateCssClass => State.ToString().ToLowerInvariant();

    public string StateText => State.ToString();

    public string LastUpdatedText => LastUpdated.ToString("yyyy-MM-dd HH:mm:ss");
}