LivePageViewModel.cs

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

using DreamineVMS.Models;
using DreamineVMS.Services.Cameras;
using DreamineVMS.Services.Runtime;
using Microsoft.JSInterop;
 
namespace DreamineVMS.Blazor.ViewModels;

public sealed class LivePageViewModel : IAsyncDisposable
{
    private readonly IVmsCameraRepository _repository;
    private readonly ICameraRuntimeStateService _runtimeState;
    private readonly IJSRuntime _jsRuntime;
    private readonly object _gate = new();
    private bool _isInitialized;
    private bool _isDisposed;

    public LivePageViewModel(
        IVmsCameraRepository repository,
        ICameraRuntimeStateService runtimeState,
        IJSRuntime jsRuntime)
    {
        _repository = repository ?? throw new ArgumentNullException(nameof(repository));
        _runtimeState = runtimeState ?? throw new ArgumentNullException(nameof(runtimeState));
        _jsRuntime = jsRuntime ?? throw new ArgumentNullException(nameof(jsRuntime));
    }

    public event EventHandler? PlayersNeedSync;

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

    public void Initialize()
    {
        lock (_gate)
        {
            if (_isInitialized || _isDisposed)
            {
                return;
            }
 
            Cameras = _repository.GetAll()
                .Where(camera => camera.Enabled)
                .OrderBy(camera => camera.DisplayOrder)
                .Take(5)
                .ToArray();
 
            _runtimeState.StateChanged += OnRuntimeStateChanged;
            _isInitialized = true;
        }
    }

    public async Task OnAfterRenderAsync(bool firstRender)
    {
        if (!firstRender)
        {
            return;
        }
 
        await SynchronizePlayersAsync();
    }

    public async Task SynchronizePlayersAsync()
    {
        if (_isDisposed)
        {
            return;
        }
 
        foreach (CameraDevice camera in Cameras)
        {
            CameraRuntimeState state = _runtimeState.GetState(camera.Id);
 
            if (state.State is CameraConnectionState.Connected or CameraConnectionState.Connecting)
            {
                await EnsurePlayerAsync(camera);
                continue;
            }
 
            await DestroyPlayerAsync(camera, state.LastMessage);
        }
    }

    public static string GetPlayerId(CameraDevice camera)
    {
        ArgumentNullException.ThrowIfNull(camera);
        return $"video-{camera.Id}";
    }

    public async ValueTask DisposeAsync()
    {
        lock (_gate)
        {
            if (_isDisposed)
            {
                return;
            }
 
            _isDisposed = true;
 
            if (_isInitialized)
            {
                _runtimeState.StateChanged -= OnRuntimeStateChanged;
                _isInitialized = false;
            }
        }
 
        foreach (CameraDevice camera in Cameras)
        {
            await DestroyPlayerAsync(camera, "Live view disposed.");
        }
    }
 

    private static string BuildVersionedHlsUrl(CameraDevice camera, CameraRuntimeState state)
    {
        ArgumentNullException.ThrowIfNull(camera);
        ArgumentNullException.ThrowIfNull(state);
 
        string separator = camera.HlsUrl.Contains('?', StringComparison.Ordinal) ? "&" : "?";
        return $"{camera.HlsUrl}{separator}session={state.RestartCount}";
    }

    private async Task EnsurePlayerAsync(CameraDevice camera)
    {
        try
        {
            CameraRuntimeState state = _runtimeState.GetState(camera.Id);
            string source = BuildVersionedHlsUrl(camera, state);
 
            await _jsRuntime.InvokeVoidAsync(
                "dreamineVmsHls.init",
                GetPlayerId(camera),
                source);
        }
        catch (JSDisconnectedException)
        {
            // Circuit이 끊긴 상태는 무시합니다.
        }
        catch (Exception ex)
        {
            System.Diagnostics.Debug.WriteLine($"[LivePageViewModel] player init failed: {camera.Id}: {ex}");
        }
    }

    private async Task DestroyPlayerAsync(CameraDevice camera, string? reason)
    {
        try
        {
            await _jsRuntime.InvokeVoidAsync(
                "dreamineVmsHls.destroy",
                GetPlayerId(camera),
                string.IsNullOrWhiteSpace(reason) ? "Stream stopped." : reason);
        }
        catch (JSDisconnectedException)
        {
            // Circuit이 끊긴 상태는 무시합니다.
        }
        catch
        {
            // 화면 종료 중 JS 런타임이 이미 끊긴 경우는 무시합니다.
        }
    }

    private void OnRuntimeStateChanged(object? sender, CameraRuntimeState state)
    {
        if (Cameras.All(c => c.Id != state.CameraId))
        {
            return;
        }
 
        if (_isDisposed)
        {
            return;
        }
 
        PlayersNeedSync?.Invoke(this, EventArgs.Empty);
    }
}