FISLib_Old/Vinno.FIS.Sonopost/Managers/LiveVideoManager.cs

using FISLib.Connect;
using FISLib.LiveVideo;
using FISLib.Remedical;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using Vinno.FIS.Sonopost.Common;
using Vinno.FIS.Sonopost.Features.Config;
using Vinno.FIS.Sonopost.Features.Dicom;
using Vinno.FIS.Sonopost.Managers.Interfaces;
using Vinno.IUS.Common.Log;

namespace Vinno.FIS.Sonopost.Managers
{
    internal class LiveVideoManager : SonopostManager, ILiveVideoManager
    {
        private readonly ILoginManager _loginManager;
        private readonly ILiveVideoService _fisLiveVideoService;
        private readonly IRemedicalManager _remedicalManager;
        private readonly IKeyBoardListenManager _keyBoardListenManager;
        private CameraSettingForSonopost _cameraSetting;
        private bool _isRecording;
        private AutoResetEvent _checkImageRecordEvent = new AutoResetEvent(false);

        public event EventHandler<FISImageFrameData> PreviewImageReceived;

        public LiveVideoManager()
        {
            _loginManager = AppManager.Instance.GetManager<ILoginManager>();
            _keyBoardListenManager = AppManager.Instance.GetManager<IKeyBoardListenManager>();
            _keyBoardListenManager.LeftKeyPressedEvent += OnLeftKeyPressedEvent;
            _keyBoardListenManager.RightKeyPressedEvent += OnRightKeyPressedEvent;
            _fisLiveVideoService = AppManager.Instance.GetManager<IFISManager>().FISLiveVideoService;
            _fisLiveVideoService.PreviewCameraCaptured += OnPreviewCameraCaptured;
            _fisLiveVideoService.CaptureImageGenerated += OnCaptureImageGenerated;
            _fisLiveVideoService.RecordVideoGenerated += OnRecordVideoGenerated;
            _remedicalManager = AppManager.Instance.GetManager<IRemedicalManager>();
            _cameraSetting = new CameraSettingForSonopost(false, FISLiveChannelCategory.Main, new List<FISVideoDeviceInfo>(), new FISRainbowImageDetectConfig()
            {
                IsDetectRainbowImage = SonopostSystemSettings.Instance.RainbowImageDetectSetting.IsDetectRainbowImage,
                BeforeDisableIntervalTime = SonopostSystemSettings.Instance.RainbowImageDetectSetting.BeforeDisableIntervalTime,
                BeforeEnableIntervalTime = SonopostSystemSettings.Instance.RainbowImageDetectSetting.BeforeEnableIntervalTime,
                AfterEnableIntervalTime = SonopostSystemSettings.Instance.RainbowImageDetectSetting.AfterEnableIntervalTime,
                ScanIntervalTime = SonopostSystemSettings.Instance.RainbowImageDetectSetting.ScanIntervalTime,
                CaptureCardList = SonopostSystemSettings.Instance.RainbowImageDetectSetting.CaptureCardList.ToList(),
            }, new FISMicDeviceInfo());
        }

        private void OnLeftKeyPressedEvent(object sender, EventArgs e)
        {
            try
            {
                if (_loginManager.DeviceStatus != DeviceStatus.Logon)
                {
                    Logger.WriteLineError($"LiveVideoManager OnLeftKeyPressedEvent Invoke Error,please connect the vCloud Server first");
                    return;
                }
                if (!SonopostUserDefinedSettings.Instance.CaptureSetting.RealTimeCaptureEnabled)
                {
                    Logger.WriteLineError($"LiveVideoManager OnLeftKeyPressedEvent Invoke,But the CaptureEnable is False,so skipped it");
                    return;
                }
                if (SonopostUserDefinedSettings.Instance.CaptureSetting.ImageCaptureKeyForFootToogle == EnumFootToggleKey.LeftKey)
                {
                    _fisLiveVideoService.CaptureCurrentImage();
                }
                else if (SonopostUserDefinedSettings.Instance.CaptureSetting.VideoCaptureKeyForFootToggle == EnumFootToggleKey.LeftKey)
                {
                    if (!_isRecording)
                    {
                        _fisLiveVideoService.StartRecordVideo();
                        TimeJudgment();
                        _isRecording = true;
                    }
                    else
                    {
                        _fisLiveVideoService.StopRecordVideo();
                        _isRecording = false;
                    }
                }
                else
                {
                    Logger.WriteLineError($"LiveVideoManager OnLeftKeyPressedEvent Error,capture or record is all not left key");
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"LiveVideoManager OnLeftKeyPressedEvent Error:{ex}");
            }
        }

        private void OnRightKeyPressedEvent(object sender, EventArgs e)
        {
            try
            {
                if (_loginManager.DeviceStatus != DeviceStatus.Logon)
                {
                    Logger.WriteLineError($"LiveVideoManager OnRightKeyPressedEvent Invoke Error,please connect the vCloud Server first");
                    return;
                }
                if (!SonopostUserDefinedSettings.Instance.CaptureSetting.RealTimeCaptureEnabled)
                {
                    Logger.WriteLineError($"LiveVideoManager OnRightKeyPressedEvent Invoke,But the CaptureEnable is False,so skipped it");
                    return;
                }
                if (SonopostUserDefinedSettings.Instance.CaptureSetting.ImageCaptureKeyForFootToogle == EnumFootToggleKey.RightKey)
                {
                    _fisLiveVideoService.CaptureCurrentImage();
                }
                else if (SonopostUserDefinedSettings.Instance.CaptureSetting.VideoCaptureKeyForFootToggle == EnumFootToggleKey.RightKey)
                {
                    if (!_isRecording)
                    {
                        _fisLiveVideoService.StartRecordVideo();
                        TimeJudgment();
                        _isRecording = true;
                    }
                    else
                    {
                        _fisLiveVideoService.StopRecordVideo();
                        _isRecording = false;
                    }
                }
                else
                {
                    Logger.WriteLineError($"LiveVideoManager OnRightKeyPressedEvent Error,capture or record is all not left key");
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"LiveVideoManager OnRightKeyPressedEvent Error:{ex}");
            }
        }

        private void TimeJudgment()
        {
            Task.Run(() =>
            {
                try
                {
                    _checkImageRecordEvent.Reset();
                    _checkImageRecordEvent.WaitOne(30000);
                    if (_isRecording)
                    {
                        _fisLiveVideoService.StopRecordVideo();
                        _isRecording = false;
                    }
                }
                catch (Exception ex)
                {
                    Logger.WriteLineError($"LivevideoManager TimeJudgment Error:{ex}");
                }
            });
        }

        private void OnCaptureImageGenerated(object sender, string e)
        {
            try
            {
                if (string.IsNullOrEmpty(e))
                {
                    Logger.WriteLineError($"Capture Image Generated Failed ,File Path is null");
                    return;
                }
                if (!File.Exists(e))
                {
                    Logger.WriteLineError($"Capture Image Generated Failed: {e} is not exist");
                    return;
                }
                if (Path.GetExtension(e).ToLower() != $".{SonopostConstants.VidFileName}")
                {
                    Logger.WriteLineError($"Capture Image Generated Failed: {e} is not vid file");
                    return;
                }
                var vidInfo = new VidInfo()
                {
                    VidFilePath = e,
                };
                if (_loginManager.DeviceStatus == DeviceStatus.Logon)
                {
                    var examRecordId = _remedicalManager.GetCollcetingRecordCode();
                    if (!string.IsNullOrEmpty(examRecordId))
                    {
                        var detailInfo = _remedicalManager.GetvCloudExamDetailInfoByExamRecordId(examRecordId);
                        if (detailInfo == null)
                        {
                            Logger.WriteLineError($"LiveVideoManager GetvCloudExamDetailInfoByExamRecordId Result is null");
                        }
                        else
                        {
                            if (detailInfo.ExamStatus == FISRecordStatus.NotScanned || detailInfo.ExamStatus == FISRecordStatus.Uploaded)
                            {
                                vidInfo.ExamRecordId = examRecordId;
                                vidInfo.PatientInfo = detailInfo.PatientScanInfo;
                            }
                        }
                    }
                }
                DicomUploadQueue.Instance.Enqueue(vidInfo);
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"LiveVideoManager OnCaptureImageGenerated Error:{ex}");
            }
        }

        private void OnRecordVideoGenerated(object sender, string e)
        {
            try
            {
                if (string.IsNullOrEmpty(e))
                {
                    Logger.WriteLineError($"Record Video Generated Failed, File Path is null");
                    return;
                }
                if (!File.Exists(e))
                {
                    Logger.WriteLineError($"Record Video Generated Failed: {e} is not exist");
                    return;
                }
                if (Path.GetExtension(e).ToLower() != $".{SonopostConstants.VidFileName}")
                {
                    Logger.WriteLineError($"Record Video Generated Failed: {e} is not vid file");
                    return;
                }
                var vidInfo = new VidInfo()
                {
                    VidFilePath = e,
                };
                if (_loginManager.DeviceStatus == DeviceStatus.Logon)
                {
                    var examRecordId = _remedicalManager.GetCollcetingRecordCode();
                    if (!string.IsNullOrEmpty(examRecordId))
                    {
                        var detailInfo = _remedicalManager.GetvCloudExamDetailInfoByExamRecordId(examRecordId);
                        if (detailInfo == null)
                        {
                            Logger.WriteLineError($"LiveVideoManager GetvCloudExamDetailInfoByExamRecordId Result is null");
                        }
                        else
                        {
                            if (detailInfo.ExamStatus == FISRecordStatus.NotScanned || detailInfo.ExamStatus == FISRecordStatus.Uploaded)
                            {
                                vidInfo.ExamRecordId = examRecordId;
                                vidInfo.PatientInfo = detailInfo.PatientScanInfo;
                            }
                        }
                    }
                }
                DicomUploadQueue.Instance.Enqueue(vidInfo);
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"LiveVideoManager OnCaptureImageGenerated Error:{ex}");
            }
        }

        private void OnPreviewCameraCaptured(object sender, FISImageFrameData e)
        {
            try
            {
                PreviewImageReceived?.Invoke(this, e);
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"Live Video Manager On Preview Camera Captured Error:{ex}");
            }
        }

        public List<string> GetBrandList()
        {
            try
            {
                if (_loginManager.DeviceStatus == DeviceStatus.Logon)
                {
                    return _fisLiveVideoService.GetBrandList();
                }
                return new List<string>();
            }
            catch (Exception e)
            {
                Logger.WriteLineError($"GetBrandList Error:{e}");
                return new List<string>();
            }
        }

        public List<string> GetModelList(string brand)
        {
            try
            {
                if (string.IsNullOrEmpty(brand))
                {
                    return new List<string>();
                }
                if (_loginManager.DeviceStatus == DeviceStatus.Logon)
                {
                    return _fisLiveVideoService.GetModelList(brand);
                }
                return new List<string>();
            }
            catch (Exception e)
            {
                Logger.WriteLineError($"GetModelList Error:{e}");
                return new List<string>();
            }
        }

        public FISDeviceRecommandResolution GetRecommandResolution(string brand, string model)
        {
            try
            {
                if (string.IsNullOrEmpty(brand) || string.IsNullOrEmpty(model))
                {
                    return null;
                }
                return _fisLiveVideoService.GetRecommandResolution(brand, model);
            }
            catch (Exception e)
            {
                Logger.WriteLineError($"GetRecommandResolution Error:{e}");
                return null;
            }
        }

        public void UpdateDeviceResoution()
        {
            try
            {
                _cameraSetting.CameraPreviewEnabled = false;
                Logger.WriteLineInfo("LiveVideoManager UpdateDeviceResoution");
                var list = new List<FISVideoDeviceInfo>();
                foreach (var device in SonopostUserDefinedSettings.Instance.HardwareSetting.VideoDeviceInfoList)
                {
                    if (device.IsAvailable && device.IsEnable)
                    {
                        var item = device.Clone() as FISVideoDeviceInfo;
                        list.Add(item);
                    }
                }
                _cameraSetting.VideoDeviceInfoList = list;
                _cameraSetting.MicDeviceInfo = SonopostUserDefinedSettings.Instance.HardwareSetting.MicDeviceInfo;
                if (_loginManager.DeviceStatus == DeviceStatus.Logon)
                {
                    _fisLiveVideoService.ChangeCameraSettingForSonopost(_cameraSetting);
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"LiveVideoManager Update Device Resoution Error:{ex}");
            }
        }

        public void UpdateRainbowImageDetectSetting()
        {
            try
            {
                _cameraSetting.RainbowImageDetectConfig.IsDetectRainbowImage = SonopostSystemSettings.Instance.RainbowImageDetectSetting.IsDetectRainbowImage;
                _cameraSetting.RainbowImageDetectConfig.BeforeDisableIntervalTime = SonopostSystemSettings.Instance.RainbowImageDetectSetting.BeforeDisableIntervalTime;
                _cameraSetting.RainbowImageDetectConfig.BeforeEnableIntervalTime = SonopostSystemSettings.Instance.RainbowImageDetectSetting.BeforeEnableIntervalTime;
                _cameraSetting.RainbowImageDetectConfig.AfterEnableIntervalTime = SonopostSystemSettings.Instance.RainbowImageDetectSetting.AfterEnableIntervalTime;
                _cameraSetting.RainbowImageDetectConfig.ScanIntervalTime = SonopostSystemSettings.Instance.RainbowImageDetectSetting.ScanIntervalTime;
                if (_loginManager.DeviceStatus == DeviceStatus.Logon)
                {
                    _fisLiveVideoService.ChangeCameraSettingForSonopost(_cameraSetting);
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"LiveVideoManager Update RainbowImageDetectSetting Error:{ex}");
            }
        }

        public void StartPreview(string id, int width, int height, int fps)
        {
            try
            {
                _cameraSetting.CameraPreviewEnabled = true;
                var deviceParameter = SonopostUserDefinedSettings.Instance.HardwareSetting.VideoDeviceInfoList;
                var capturingDevice = deviceParameter.FirstOrDefault(d => d.Id == id && d.IsEnable);
                if (capturingDevice != null)
                {
                    _cameraSetting.CurrentLiveChannelCategory = capturingDevice.Category;
                }
                else
                {
                    _cameraSetting.CameraPreviewEnabled = false;
                    _cameraSetting.CurrentLiveChannelCategory = FISLiveChannelCategory.Main;
                }
                if (_loginManager.DeviceStatus == DeviceStatus.Logon)
                {
                    _fisLiveVideoService.ChangeCameraSettingForSonopost(_cameraSetting);
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"LiveVideoManager Start Preview Error:{ex}");
            }
        }

        public void StopPreview()
        {
            try
            {
                _cameraSetting.CameraPreviewEnabled = false;
                if (_loginManager.DeviceStatus == DeviceStatus.Logon)
                {
                    _fisLiveVideoService.ChangeCameraSettingForSonopost(_cameraSetting);
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"LiveVideoManager Stop Preview Error:{ex}");
            }
        }

        public void ChangeRealTimeCaptureSetting()
        {
            try
            {
                if (_loginManager.DeviceStatus == DeviceStatus.Logon)
                {
                    _fisLiveVideoService.ChangeRealTimeCaptureSetting(SonopostUserDefinedSettings.Instance.CaptureSetting.RealTimeCaptureEnabled);
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"LiveVideoManager ChangeRealTimeCaptureSetting Error:{ex}");
            }
        }

        public override void DoDispose()
        {
            try
            {
                _keyBoardListenManager.LeftKeyPressedEvent -= OnLeftKeyPressedEvent;
                _keyBoardListenManager.RightKeyPressedEvent -= OnRightKeyPressedEvent;
                _fisLiveVideoService.PreviewCameraCaptured -= OnPreviewCameraCaptured;
                _fisLiveVideoService.CaptureImageGenerated -= OnCaptureImageGenerated;
                _fisLiveVideoService.RecordVideoGenerated -= OnRecordVideoGenerated;
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"LiveVideoManager DoDispose Error:{ex}");
            }
            base.DoDispose();
        }
    }
}