FISLib_Old/Vinno.vCloud.Common.FIS/LiveVideos/PreviewManager.cs

using System;
using System.Collections.Generic;
using System.Linq;
using Vinno.FIS.TRTCClient.Common.Enum;
using Vinno.IUS.Common.Log;
using Vinno.vCloud.FIS.CrossPlatform.Common;
using Vinno.vCloud.FIS.CrossPlatform.Common.LiveVideo;
using Vinno.vCloud.FIS.CrossPlatform.Common.LiveVideo.Interface;

namespace Vinno.vCloud.Common.FIS.LiveVideos
{
    internal class PreviewManager : IPreviewManager
    {
        private readonly ILiveVideoPusherManager _liveVideoPushManager;
        private readonly List<CPVideoDeviceInfo> _currentVideoDeviceInfoList;
        private readonly object _locker = new object();
        private readonly CPVideoDeviceInfo _currentVideoDeviceInfo;

        private bool _disposed;
        private ICapturer _capturer;
        private bool _isPreviewingCache;//推流状态改变时赋值
        private bool _isPaused;

        public bool IsPreviewing { get; private set; }

        public event EventHandler<ImageFrameData> PreviewImageReceived;

        public PreviewManager(ILiveVideoPusherManager liveVideoPushManager)
        {
            _liveVideoPushManager = liveVideoPushManager;
            _liveVideoPushManager.PusherStateChanged += OnPusherStateChanged;
            _liveVideoPushManager.PreviewImageReceived += OnPreviewImageReceived;
            _currentVideoDeviceInfo = new CPVideoDeviceInfo();
            _currentVideoDeviceInfoList = new List<CPVideoDeviceInfo>();
        }

        public void UpdateCurrentVideoDeviceInfoList(List<CPVideoDeviceInfo> infos)
        {
            _currentVideoDeviceInfoList.Clear();
            if (infos != null)
            {
                foreach (var info in infos)
                {
                    var item = info.Clone() as CPVideoDeviceInfo;
                    _currentVideoDeviceInfoList.Add(item);
                }
            }
            _liveVideoPushManager?.UpdateCurrentVideoDeviceInfoList(infos);
        }

        private void OnPusherStateChanged(object sender, PusherState e)
        {
            if (e == PusherState.Preparing)
            {
                _isPreviewingCache = IsPreviewing;
                StopPreview(false);
            }
            else if (e == PusherState.Prepared)
            {
                if (_isPreviewingCache)
                {
                    StartPreview(_currentVideoDeviceInfo.Id, _currentVideoDeviceInfo.Width, _currentVideoDeviceInfo.Height, _currentVideoDeviceInfo.FrameRate, _currentVideoDeviceInfo.Category);
                }
            }
        }

        public void SetIsPaused(bool isPaused)
        {
            Logger.WriteLineInfo($"Preview Manager Set IsPaused:{isPaused}");
            _isPaused = isPaused;
            if (isPaused)
            {
                StopPreview(false);
            }
            else
            {
                OnPusherStateChanged(this, PusherState.Prepared);
            }
        }

        public void StartPreview(string deviceId, int width, int height, int frameRate, EnumLiveChannelCategory category)
        {
            lock (_locker)
            {
                if (_isPaused)
                {
                    Logger.WriteLineInfo("Preview Manager is Paused,Start Preview later");
                    _isPreviewingCache = true;
                    return;
                }
                if (IsPreviewing || string.IsNullOrEmpty(deviceId))
                {
                    return;
                }
                Logger.WriteLineInfo($"Start Preview:{deviceId}");
                var capturingDevice = _currentVideoDeviceInfoList.FirstOrDefault(d => d.IsEnable && d.IsAvailable && d.Id == deviceId);
                if (_liveVideoPushManager.IsPushing == true && capturingDevice != null)
                {
                    _liveVideoPushManager.StopPreview();

                    _liveVideoPushManager.StartPreview(capturingDevice.Category);
                }
                else
                {
                    if (_capturer != null)
                    {
                        _capturer.ImageFrameReceived -= OnPreviewImageReceived;
                        _capturer.StopCapture();
                        _capturer.Dispose();
                        _capturer = null;
                    }
                    _capturer = CrossPlatformHelper.Instance.CapturerCreator.CreateCapturer(deviceId, width, height, category == EnumLiveChannelCategory.Main ? 20 : 15, category, width, height);
                    _capturer.ImageFrameReceived += OnPreviewImageReceived;
                    _capturer.StartCapture();
                }
                _currentVideoDeviceInfo.Id = deviceId;
                _currentVideoDeviceInfo.Width = width;
                _currentVideoDeviceInfo.Height = height;
                _currentVideoDeviceInfo.FrameRate = frameRate;
                _currentVideoDeviceInfo.Category = category;
                IsPreviewing = true;
                LiveVideoStatusChecker.Instance.IsPreviewing = true;
            }
        }

        public void StopPreview(bool setPreviewCacheFalse)
        {
            lock (_locker)
            {
                if (setPreviewCacheFalse)
                {
                    _isPreviewingCache = false;
                }
                if (!IsPreviewing)
                {
                    return;
                }
                Logger.WriteLineInfo($"Stop Preview");
                if (_liveVideoPushManager.IsPushing == true)
                {
                    _liveVideoPushManager.StopPreview();
                }
                if (_capturer != null)
                {
                    _capturer.ImageFrameReceived -= OnPreviewImageReceived;
                    _capturer.StopCapture();
                    _capturer.Dispose();
                    _capturer = null;
                }
                IsPreviewing = false;
                LiveVideoStatusChecker.Instance.IsPreviewing = false;
            }
        }

        private void OnPreviewImageReceived(object sender, ImageFrameData e)
        {
            PreviewImageReceived?.Invoke(this, e);
        }

        public void Dispose()
        {
            if (!_disposed)
            {
                DoDispose();
                GC.SuppressFinalize(this);
                _disposed = true;
            }
        }

        public void DoDispose()
        {
            StopPreview(true);
            _liveVideoPushManager.PusherStateChanged -= OnPusherStateChanged;
            _liveVideoPushManager.PreviewImageReceived -= OnPreviewImageReceived;
        }

        ~PreviewManager()
        {
            Dispose();
        }
    }
}