MainWindowViewModel.cs

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

using Dreamine.Hybrid.Interfaces;
using DreamineVMS.Messages;
using DreamineVMS.Models;
using DreamineVMS.Services.Cameras;
using DreamineVMS.Services.Dashboard;
using DreamineVMS.Services.Runtime;
using DreamineVMS.Services.Streaming;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Runtime.CompilerServices;
using System.Windows.Input;
 
namespace DreamineVMS.ViewModels;

public sealed class MainWindowViewModel : INotifyPropertyChanged, IDisposable
{
    private readonly IVmsCameraRepository _repository;
    private readonly ICameraRuntimeStateService _runtimeState;
    private readonly ICameraStreamService _streamService;
    private readonly IVmsDashboardStateService _dashboardStateService;
    private readonly IDisposable _dashboardSubscription;
    private readonly AgentSettingsViewModel _agentSettings;
    private CameraRowViewModel? _selectedCamera;
    private string _statusMessage = "VMS application started.";
    public AgentSettingsViewModel AgentSettings => _agentSettings;

    public MainWindowViewModel(
        IVmsCameraRepository repository,
        ICameraRuntimeStateService runtimeState,
        ICameraStreamService streamService,
        IVmsDashboardStateService dashboardStateService,
        IHybridMessageBus messageBus,
        AgentSettingsViewModel agentSettings)
    {
        _repository = repository ?? throw new ArgumentNullException(nameof(repository));
        _runtimeState = runtimeState ?? throw new ArgumentNullException(nameof(runtimeState));
        _streamService = streamService ?? throw new ArgumentNullException(nameof(streamService));
        _dashboardStateService = dashboardStateService ?? throw new ArgumentNullException(nameof(dashboardStateService));
        ArgumentNullException.ThrowIfNull(messageBus);
        _agentSettings = agentSettings ?? throw new ArgumentNullException(nameof(agentSettings));
 
        foreach (CameraDevice camera in _repository.GetAll())
        {
            CameraRuntimeState state = _runtimeState.GetState(camera.Id);
            Cameras.Add(new CameraRowViewModel(camera, state));
        }
 
        SelectedCamera = Cameras.FirstOrDefault();
        Logs.Add(new VmsLogItem { Message = "VMS application started." });
 
        ConnectSelectedCameraCommand = new AsyncRelayCommand(ConnectSelectedCameraAsync, () => SelectedCamera is not null);
        DisconnectSelectedCameraCommand = new AsyncRelayCommand(DisconnectSelectedCameraAsync, () => SelectedCamera is not null);
        StartAllCommand = new AsyncRelayCommand(StartAllAsync);
        StopAllCommand = new AsyncRelayCommand(StopAllAsync);
        ClearLogsCommand = new RelayCommand(ClearLogs);
 
        _runtimeState.StateChanged += OnCameraRuntimeStateChanged;
        _dashboardSubscription = messageBus.Subscribe<VmsDashboardActionRequestedMessage>(OnDashboardActionRequestedAsync);
    }

    public event PropertyChangedEventHandler? PropertyChanged;

    public event EventHandler? OpenLiveTabRequested;

    public ObservableCollection<CameraRowViewModel> Cameras { get; } = new();

    public ObservableCollection<VmsLogItem> Logs { get; } = new();

    public CameraRowViewModel? SelectedCamera
    {
        get => _selectedCamera;
        set
        {
            if (ReferenceEquals(_selectedCamera, value))
            {
                return;
            }
 
            _selectedCamera = value;
            OnPropertyChanged();
            (ConnectSelectedCameraCommand as AsyncRelayCommand)?.RaiseCanExecuteChanged();
            (DisconnectSelectedCameraCommand as AsyncRelayCommand)?.RaiseCanExecuteChanged();
        }
    }

    public string StatusMessage
    {
        get => _statusMessage;
        private set
        {
            if (_statusMessage == value)
            {
                return;
            }
 
            _statusMessage = value;
            OnPropertyChanged();
        }
    }

    public ICommand ConnectSelectedCameraCommand { get; }

    public ICommand DisconnectSelectedCameraCommand { get; }

    public ICommand StartAllCommand { get; }

    public ICommand StopAllCommand { get; }

    public ICommand ClearLogsCommand { get; }

    public void Dispose()
    {
        _dashboardSubscription.Dispose();
        _runtimeState.StateChanged -= OnCameraRuntimeStateChanged;
 
        foreach (CameraRowViewModel row in Cameras)
        {
            row.Dispose();
        }
        Cameras.Clear();
    }

    private async Task ConnectSelectedCameraAsync()
    {
        CameraRowViewModel? selected = SelectedCamera;
        if (selected is null)
        {
            return;
        }
 
        await _streamService.StartAsync(selected.Id);
        AddLog($"Connect requested: {selected.Name}");
    }

    private async Task DisconnectSelectedCameraAsync()
    {
        CameraRowViewModel? selected = SelectedCamera;
        if (selected is null)
        {
            return;
        }
 
        await _streamService.StopAsync(selected.Id);
        AddLog($"Disconnect requested: {selected.Name}");
    }

    private async Task ConnectCameraAsync(string? cameraId)
    {
        if (string.IsNullOrWhiteSpace(cameraId))
        {
            AddLog("Connect request ignored: camera id is empty.");
            return;
        }
 
        CameraRowViewModel? camera = Cameras.FirstOrDefault(row => string.Equals(row.Id, cameraId, StringComparison.OrdinalIgnoreCase));
        if (camera is null)
        {
            AddLog($"Connect request ignored: camera not found. id={cameraId}");
            return;
        }
 
        await _streamService.StartAsync(camera.Id).ConfigureAwait(false);
        AddLog($"Dashboard connect requested: {camera.Name}");
    }

    private async Task DisconnectCameraAsync(string? cameraId)
    {
        if (string.IsNullOrWhiteSpace(cameraId))
        {
            AddLog("Disconnect request ignored: camera id is empty.");
            return;
        }
 
        CameraRowViewModel? camera = Cameras.FirstOrDefault(row => string.Equals(row.Id, cameraId, StringComparison.OrdinalIgnoreCase));
        if (camera is null)
        {
            AddLog($"Disconnect request ignored: camera not found. id={cameraId}");
            return;
        }
 
        await _streamService.StopAsync(camera.Id).ConfigureAwait(false);
        AddLog($"Dashboard disconnect requested: {camera.Name}");
    }

    private async Task StartAllAsync()
    {
        await _streamService.StartAllAsync();
        AddLog("Start all cameras requested.");
    }

    private async Task StopAllAsync()
    {
        await _streamService.StopAllAsync();
        AddLog("Stop all cameras requested.");
    }

    private async Task OnDashboardActionRequestedAsync(VmsDashboardActionRequestedMessage message, CancellationToken cancellationToken)
    {
        switch (message.Action)
        {
            case VmsDashboardActions.EmbeddedRefresh:
                _dashboardStateService.Refresh("Embedded dashboard refresh requested.");
                AddLog("Embedded dashboard refresh requested.");
                break;
 
            case VmsDashboardActions.ServerOpenLive:
                // Server Dashboard is a browser/WebView route.
                // Do not switch the WPF tab from here, otherwise the Server Dashboard tab and WPF Live tab appear to be mixed.
                AddLog("Server dashboard requested Open Live. Use /live route in the server WebView.");
                break;
 
            case VmsDashboardActions.CameraConnect:
                await ConnectCameraAsync(message.CameraId).ConfigureAwait(false);
                break;
 
            case VmsDashboardActions.CameraDisconnect:
                await DisconnectCameraAsync(message.CameraId).ConfigureAwait(false);
                break;
 
            case VmsDashboardActions.CameraStartAll:
                await StartAllAsync().ConfigureAwait(false);
                break;
 
            case VmsDashboardActions.CameraStopAll:
                await StopAllAsync().ConfigureAwait(false);
                break;
 
            case VmsDashboardActions.ClearLogs:
                ClearLogs();
                break;
 
            default:
                AddLog($"Dashboard action requested: {message.Action}");
                break;
        }
    }

    private void OnCameraRuntimeStateChanged(object? sender, CameraRuntimeState state)
    {
        // 상태 스토어 갱신은 IVmsDashboardStateService가 담당.
        // 여기서는 WPF UI 로그/상태 메시지만 처리.
        DispatchToUi(() => AddLogCore(state.LastMessage));
    }

    private void AddLog(string message)
    {
        DispatchToUi(() => AddLogCore(message));
    }

    private void AddLogCore(string message)
    {
        StatusMessage = message;
        Logs.Insert(0, new VmsLogItem { Message = message });
        while (Logs.Count > 300)
        {
            Logs.RemoveAt(Logs.Count - 1);
        }
    }

    private void ClearLogs()
    {
        Logs.Clear();
        AddLog("Logs cleared.");
    }

    private void RaiseOpenLiveTabRequested()
    {
        DispatchToUi(() => OpenLiveTabRequested?.Invoke(this, EventArgs.Empty));
    }

    private static void DispatchToUi(Action action)
    {
        System.Windows.Application? app = System.Windows.Application.Current;
        if (app is null)
        {
            return;
        }
 
        var dispatcher = app.Dispatcher;
 
        // 종료 시퀀스 중에는 Invoke가 OperationCanceledException을 던지므로 무시합니다.
        if (dispatcher.HasShutdownStarted || dispatcher.HasShutdownFinished)
        {
            return;
        }
 
        if (dispatcher.CheckAccess())
        {
            action();
        }
        else
        {
            try
            {
                dispatcher.Invoke(action);
            }
            catch (OperationCanceledException) { }
        }
    }

    private void OnPropertyChanged([CallerMemberName] string? propertyName = null)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }
}

public sealed class RelayCommand : ICommand
{
    private readonly Action _execute;
    private readonly Func<bool>? _canExecute;

    public RelayCommand(Action execute, Func<bool>? canExecute = null)
    {
        _execute = execute ?? throw new ArgumentNullException(nameof(execute));
        _canExecute = canExecute;
    }

    public event EventHandler? CanExecuteChanged;

    public bool CanExecute(object? parameter) => _canExecute?.Invoke() ?? true;

    public void Execute(object? parameter) => _execute();

    public void RaiseCanExecuteChanged()
    {
        System.Windows.Threading.Dispatcher? dispatcher =
            System.Windows.Application.Current?.Dispatcher;
 
        if (dispatcher is null || dispatcher.CheckAccess())
        {
            CanExecuteChanged?.Invoke(this, EventArgs.Empty);
            return;
        }
 
        dispatcher.InvokeAsync(() => CanExecuteChanged?.Invoke(this, EventArgs.Empty));
    }
}

public sealed class AsyncRelayCommand : ICommand
{
    private readonly Func<Task> _execute;
    private readonly Func<bool>? _canExecute;
    private bool _isRunning;

    public AsyncRelayCommand(Func<Task> execute, Func<bool>? canExecute = null)
    {
        _execute = execute ?? throw new ArgumentNullException(nameof(execute));
        _canExecute = canExecute;
    }

    public event EventHandler? CanExecuteChanged;

    public bool CanExecute(object? parameter) => !_isRunning && (_canExecute?.Invoke() ?? true);

    public async void Execute(object? parameter)
    {
        if (!CanExecute(parameter))
        {
            return;
        }
 
        try
        {
            _isRunning = true;
            RaiseCanExecuteChanged();
 
            // WPF UI 컨텍스트를 유지하기 위해 ConfigureAwait(false) 사용 안 함.
            await _execute();
        }
        catch (Exception ex)
        {
            // 비동기 명령의 미처리 예외가 UI 스레드로 던져져 앱이 죽는 것을 막습니다.
            System.Diagnostics.Debug.WriteLine($"[AsyncRelayCommand] {ex}");
        }
        finally
        {
            _isRunning = false;
            RaiseCanExecuteChanged();
        }
    }

    public void RaiseCanExecuteChanged()
    {
        System.Windows.Threading.Dispatcher? dispatcher =
            System.Windows.Application.Current?.Dispatcher;
 
        if (dispatcher is null || dispatcher.CheckAccess())
        {
            CanExecuteChanged?.Invoke(this, EventArgs.Empty);
            return;
        }
 
        dispatcher.InvokeAsync(() => CanExecuteChanged?.Invoke(this, EventArgs.Empty));
    }
}