FISLib_Old/FISSDK/FISIMPL/LiveVideoServiceForWindows.cs

using FISLib;
using FISLib.LiveVideo;
using FISLib.Notification;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Runtime.InteropServices;
using System.Threading;
using Vinno.FIS.TRTCClient.Common.Enum;
using Vinno.IUS.Common.Log;
using Vinno.vCloud.Common.FIS;
using Vinno.vCloud.Common.FIS.LiveVideos;
using Vinno.vCloud.FIS.CrossPlatform.Common.LiveVideo;

namespace FISIMPL
{
    internal class LiveVideoServiceForWindows : ILiveVideoService, IDisposable
    {
        private readonly ConcurrentStack<byte[]> _byteImageCache = new ConcurrentStack<byte[]>();

        private ILiveVideo _liveVideo;
        private ILiveVideoV2 _liveVideoV2;
        private PipeClient _pipeClient;
        private PipeServer _pipeServer;
        private FISImageFrameData _imageFrameData;
        private FISBase64ImageData _tempBase64ImageData;
        /// <summary>
        /// Raised when local camera live execute
        /// </summary>
        public event EventHandler<FISImageFrameData> PreviewCameraCaptured;

        /// <summary>
        /// Raised when capture image generated.(only for new server)
        /// </summary>
        public event EventHandler<string> CaptureImageGenerated;

        /// <summary>
        /// Raised when record video generated.(only for new server)
        /// </summary>
        public event EventHandler<string> RecordVideoGenerated;

        internal void Update(IvCloudTerminal vcloudTerminal)
        {
            try
            {
                var newLiveVideo = vcloudTerminal?.GetFeature<ILiveVideo>(TerminalFeatureType.LiveVideo);
                if (newLiveVideo != _liveVideo)
                {
                    if (_liveVideo != null)
                    {
                        _liveVideo.PreviewCameraCaptured -= OnPreviewCameraCaptured;
                        _liveVideo.CameraPreviewImageSizeChanged -= OnCameraPreviewImageSizeChanged;
                        _liveVideo.LiveNotification -= OnLiveNotification;
                        _liveVideo.Dispose();
                        _liveVideo = null;
                        if (FISIMPL.IsRunningJsonRpcMode)
                        {
                            _pipeClient.Dispose();
                            _pipeClient.LogMsgThrow -= OnLogMsgThrow;
                            _pipeClient = null;
                            _pipeServer.DataReceived -= OnDataReceived;
                            _pipeServer.Dispose();
                            _pipeServer.LogMsgThrow -= OnLogMsgThrow;
                            _pipeServer = null;
                        }
                    }
                    _liveVideo = newLiveVideo;
                    if (_liveVideo != null)
                    {
                        _liveVideo.PreviewCameraCaptured += OnPreviewCameraCaptured;
                        _liveVideo.CameraPreviewImageSizeChanged += OnCameraPreviewImageSizeChanged;
                        _liveVideo.LiveNotification += OnLiveNotification;
                        if (FISIMPL.IsRunningJsonRpcMode)
                        {
                            _pipeClient = new PipeClient(FISConsts.PipeForLiveVideoCameraPreviewImage, FISIMPL.Platform == FISPlatform.Linux);
                            _pipeClient.LogMsgThrow += OnLogMsgThrow;
                            _pipeClient.Start();
                            _pipeServer = new PipeServer(FISConsts.PipeForLiveVideoUltrasoundImage);
                            _pipeServer.LogMsgThrow += OnLogMsgThrow;
                            _pipeServer.DataReceived += OnDataReceived;
                            _pipeServer.StartAndReceive();
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"LiveVideoServiceForWindows Update Error:{ex}");
            }
        }

        internal void UpdateV2(IvCloudTerminalV2 vcloudTerminalV2)
        {
            try
            {
                var newLiveVideo = vcloudTerminalV2?.GetFeature<ILiveVideoV2>(TerminalFeatureType.LiveVideo);
                if (newLiveVideo != _liveVideoV2)
                {
                    if (_liveVideoV2 != null)
                    {
                        _liveVideoV2.PreviewCameraCaptured -= OnPreviewCameraCaptured;
                        _liveVideoV2.CameraPreviewImageSizeChanged -= OnCameraPreviewImageSizeChanged;
                        _liveVideoV2.LiveNotification -= OnLiveNotification;
                        _liveVideoV2.CaptureImageGenerated -= OnCaptureImageGenerated;
                        _liveVideoV2.RecordVideoGenerated -= OnRecordVideoGenerated;
                        _liveVideoV2.Dispose();
                        _liveVideoV2 = null;
                        if (FISIMPL.IsRunningJsonRpcMode)
                        {
                            _pipeClient.Dispose();
                            _pipeClient.LogMsgThrow -= OnLogMsgThrow;
                            _pipeClient = null;
                            _pipeServer.DataReceived -= OnDataReceived;
                            _pipeServer.Dispose();
                            _pipeServer.LogMsgThrow -= OnLogMsgThrow;
                            _pipeServer = null;
                        }
                    }
                    _liveVideoV2 = newLiveVideo;
                    if (_liveVideoV2 != null)
                    {
                        _liveVideoV2.PreviewCameraCaptured += OnPreviewCameraCaptured;
                        _liveVideoV2.CameraPreviewImageSizeChanged += OnCameraPreviewImageSizeChanged;
                        _liveVideoV2.LiveNotification += OnLiveNotification;
                        _liveVideoV2.CaptureImageGenerated += OnCaptureImageGenerated;
                        _liveVideoV2.RecordVideoGenerated += OnRecordVideoGenerated;
                        if (FISIMPL.IsRunningJsonRpcMode)
                        {
                            _pipeClient = new PipeClient(FISConsts.PipeForLiveVideoCameraPreviewImage, FISIMPL.Platform == FISPlatform.Linux);
                            _pipeClient.LogMsgThrow += OnLogMsgThrow;
                            _pipeClient.Start();
                            _pipeServer = new PipeServer(FISConsts.PipeForLiveVideoUltrasoundImage);
                            _pipeServer.LogMsgThrow += OnLogMsgThrow;
                            _pipeServer.DataReceived += OnDataReceived;
                            _pipeServer.StartAndReceive();
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"LiveVideoServiceForWindows UpdateV2 Error:{ex}");
            }
        }

        private void OnCaptureImageGenerated(object sender, string e)
        {
            CaptureImageGenerated?.Invoke(this, e);
        }

        private void OnRecordVideoGenerated(object sender, string e)
        {
            RecordVideoGenerated?.Invoke(this, e);
        }

        private void OnDataReceived(object sender, byte[] e)
        {
            _byteImageCache.Push(e);
        }

        /// <summary>
        /// Change camera settings.
        /// </summary>
        /// <param name="cameraSetting"></param>
        public void ChangeCameraSetting(CameraSetting cameraSetting)
        {
            try
            {
                if (cameraSetting == null)
                {
                    Logger.WriteLineError($"ChangeCameraSetting error: cameraSetting is null");
                    return;
                }
                if (FISIMPL.IsConnectWithOldServer)
                {
                    if (_liveVideo == null)
                    {
                        Logger.WriteLineError($"ChangeCameraSetting error: live video feature is null");
                        return;
                    }
                    _liveVideo.ChangeCameraSettings(cameraSetting.CameraLiveEnabled && cameraSetting.LiveVideoEnabled, cameraSetting.CameraSource?.Id, cameraSetting.MicSource?.Id, cameraSetting.CameraPreviewEnabled, cameraSetting.LiveVideoEnabled, cameraSetting.IsMute);
                }
                else
                {
                    if (_liveVideoV2 == null)
                    {
                        Logger.WriteLineError($"ChangeCameraSetting error: live video v2 feature is null");
                        return;
                    }
                    _liveVideoV2.ChangeCameraSettings(cameraSetting.CameraLiveEnabled && cameraSetting.LiveVideoEnabled, cameraSetting.CameraSource?.Id, cameraSetting.MicSource?.Id, cameraSetting.CameraPreviewEnabled, cameraSetting.LiveVideoEnabled, cameraSetting.IsMute);
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"LiveVideoServiceForWindows ChangeCameraSetting Error:{ex}");
            }
        }

        /// <summary>
        /// Change camera settings for sonopost
        /// </summary>
        /// <param name="cameraSetting"></param>
        public void ChangeCameraSettingForSonopost(CameraSettingForSonopost cameraSetting)
        {
            try
            {
                if (cameraSetting == null)
                {
                    Logger.WriteLineError($"ChangeCameraSetting error: cameraSetting is null");
                    return;
                }
                var currentLiveChannelCategory = (EnumLiveChannelCategory)cameraSetting.CurrentLiveChannelCategory;
                var videoDeviceInfoList = new List<CPVideoDeviceInfo>();
                if (cameraSetting.VideoDeviceInfoList != null)
                {
                    foreach (var fisVideoDeviceInfo in cameraSetting.VideoDeviceInfoList)
                    {
                        var videoDeviceInfo = FISConverter.ConvertFISVideoDeviceInfoToCPVideoDeviceInfo(fisVideoDeviceInfo);
                        videoDeviceInfoList.Add(videoDeviceInfo);
                    }
                }
                string micId = null;
                bool isMute = true;
                if (cameraSetting.MicDeviceInfo != null)
                {
                    micId = cameraSetting.MicDeviceInfo.Id;
                    isMute = !cameraSetting.MicDeviceInfo.IsEnable;
                }
                var rainbowImageDetectConfig = FISConverter.ConvertFISRainbowImageDetectConfigToRainbowImageDetectConfig(cameraSetting.RainbowImageDetectConfig);
                if (FISIMPL.IsConnectWithOldServer)
                {
                    if (_liveVideo == null)
                    {
                        Logger.WriteLineError($"ChangeCameraSetting error: live video feature is null");
                        return;
                    }
                    _liveVideo.ChangeCameraSettingsForSonopost(cameraSetting.CameraPreviewEnabled, currentLiveChannelCategory, videoDeviceInfoList, rainbowImageDetectConfig, micId, isMute);
                }
                else
                {
                    if (_liveVideoV2 == null)
                    {
                        Logger.WriteLineError($"ChangeCameraSetting error: live videoV2 feature is null");
                        return;
                    }
                    _liveVideoV2.ChangeCameraSettingsForSonopost(cameraSetting.CameraPreviewEnabled, currentLiveChannelCategory, videoDeviceInfoList, micId, isMute, rainbowImageDetectConfig);
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"LiveVideoServiceForWindows ChangeCameraSettingForSonopost Error:{ex}");
            }
        }

        /// <summary>
        /// Speed live test network and auto select good network to server
        /// </summary>
        /// <returns></returns>
        public bool StartSpeedTest()
        {
            try
            {
                if (FISIMPL.IsConnectWithOldServer)
                {
                    if (_liveVideo == null)
                    {
                        Logger.WriteLineError($"ChangeCameraSetting error: live video feature is null");
                        return false;
                    }

                    return _liveVideo.StartSpeedTest();
                }
                else
                {
                    if (_liveVideoV2 == null)
                    {
                        Logger.WriteLineError($"ChangeCameraSetting error: live video v2 feature is null");
                        return false;
                    }

                    return _liveVideoV2.StartSpeedTest();
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"LiveVideoServiceForWindows StartSpeedTest Error:{ex}");
                return false;
            }
        }

        /// <summary>
        /// Capture ultrasound machie image data.
        /// </summary>
        /// <param name="length">image data length</param>
        /// <param name="width">image width</param>
        /// <param name="height">image height</param>
        public void CapturedUSImageData(int length, int width, int height)
        {
            try
            {
                byte[] byteImage = null;
                int retryCount = 0;
                while (!_byteImageCache.TryPop(out byteImage) && retryCount < 50)
                {
                    Thread.Sleep(10);
                    retryCount++;
                }
                if (byteImage == null)
                {
                    Logger.WriteLineError($"LiveVideoServiceForWindows-CapturedUSImageData Get Image Cache Fail");
                    return;
                }
                if (byteImage == null)
                {
                    return;
                }
                var imageCaptureDataInfo = new CaptureDataInfo
                {
                    Width = width,
                    Height = height,
                    Data = byteImage,
                };
                ImageDataCapturer.RaiseImdageDataCaptured(imageCaptureDataInfo);
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"LiveVideoServiceForWindows CapturedUSImageData Error:{ex}");
            }
        }

        /// <summary>
        /// 获取品牌列表
        /// </summary>
        /// <returns></returns>
        public List<string> GetBrandList()
        {
            try
            {
                if (FISIMPL.IsConnectWithOldServer)
                {
                    if (_liveVideo == null)
                    {
                        Logger.WriteLineError($"GetBrandList error: live video feature is null");
                        return new List<string>();
                    }
                    return _liveVideo.GetBrandList();
                }
                else
                {
                    if (_liveVideoV2 == null)
                    {
                        Logger.WriteLineError($"GetBrandList error: live videoV2 feature is null");
                        return new List<string>();
                    }
                    return _liveVideoV2.GetBrandList();
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"LiveVideoServiceForWindows GetBrandList Error:{ex}");
                return new List<string>();
            }
        }

        /// <summary>
        /// 获取型号列表
        /// </summary>
        /// <param name="brand"></param>
        /// <param name="model"></param>
        /// <returns></returns>
        public List<string> GetModelList(string brand)
        {
            try
            {
                if (FISIMPL.IsConnectWithOldServer)
                {
                    if (_liveVideo == null)
                    {
                        Logger.WriteLineError($"GetModelList error: live video feature is null");
                        return new List<string>();
                    }
                    return _liveVideo.GetModelList(brand);
                }
                else
                {
                    if (_liveVideoV2 == null)
                    {
                        Logger.WriteLineError($"GetModelList error: live videoV2 feature is null");
                        return new List<string>();
                    }
                    return _liveVideoV2.GetModelList(brand);
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"LiveVideoServiceForWindows GetModelList Error:{ex}");
                return new List<string>();
            }
        }

        /// <summary>
        /// 获取推荐分辨率
        /// </summary>
        /// <param name="brand"></param>
        /// <param name="model"></param>
        /// <returns></returns>
        public FISDeviceRecommandResolution GetRecommandResolution(string brand, string model)
        {
            try
            {
                if (FISIMPL.IsConnectWithOldServer)
                {
                    if (_liveVideo == null)
                    {
                        Logger.WriteLineError($"GetRecommandResolution error: live video feature is null");
                        return null;
                    }
                    var result = _liveVideo.GetRecommandResolution(brand, model);
                    return FISConverter.ConvertDeviceRecommandResolutionToFISDeviceRecommandResolution(result);
                }
                else
                {
                    if (_liveVideoV2 == null)
                    {
                        Logger.WriteLineError($"GetRecommandResolution error: live videoV2 feature is null");
                        return null;
                    }
                    var result = _liveVideoV2.GetRecommandResolution(brand, model);
                    return FISConverter.ConvertDeviceRecommandResolutionToFISDeviceRecommandResolution(result);
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"LiveVideoServiceForWindows GetRecommandResolution Error:{ex}");
                return null;
            }
        }

        /// <summary>
        /// Dispose
        /// </summary>
        public void Dispose()
        {
            try
            {
                Update(null);
                UpdateV2(null);
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"LiveVideoServiceForWindows Dispose Error:{ex}");
            }
        }

        private void OnPreviewCameraCaptured(object sender, byte[] e)
        {
            try
            {
                if (FISIMPL.IsRunningJsonRpcMode)
                {
                    _pipeClient?.SendBytes(e);
                }
                else
                {
                    if (_imageFrameData == null || _imageFrameData.Size != e.Length)
                    {
                        return;
                    }
                    Marshal.Copy(e, 0, _imageFrameData.Data, e.Length);
                    PreviewCameraCaptured?.Invoke(this, _imageFrameData);
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"LiveVideoServiceForWindows OnPreviewCameraCaptured Error:{ex}");
            }
        }

        private void OnCameraPreviewImageSizeChanged(object sender, ImageSize e)
        {
            try
            {
                if (FISIMPL.IsRunningJsonRpcMode)
                {
                    var fisImageSize = new FISImageSize(e.Width, e.Height);
                    NotificationSender.SendNotification(new FISNotificationArgs
                    {
                        NotificationType = FISNotificationType.FISLiveVideoCameraImageSizeChange,
                        Params = fisImageSize
                    });
                }
                else
                {
                    if (_imageFrameData == null)
                    {
                        _imageFrameData = new FISImageFrameData(e.Width, e.Height);
                    }
                    else if (_imageFrameData.Width != e.Width || _imageFrameData.Height != e.Height)
                    {
                        _imageFrameData.Resize(e.Width, e.Height);
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"LiveVideoServiceForWindows OnCameraPreviewImageSizeChanged Error:{ex}");
            }
        }

        private void OnLiveNotification(object sender, LiveNotificationArgs e)
        {
            try
            {
                var fisLiveNotificationArgs = new FISLiveNotificationArgs(e.IsLive, e.LiveWidth, e.LiveHeight);
                if (FISIMPL.IsRunningJsonRpcMode)
                {
                    NotificationSender.SendNotification(new FISNotificationArgs
                    {
                        Params = fisLiveNotificationArgs,
                        NotificationType = FISNotificationType.FISLiveVideoLiveNotification
                    });
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"LiveVideoServiceForWindows OnLiveNotification Error:{ex}");
            }
        }

        private void OnLogMsgThrow(object sender, FISLogEventArgs e)
        {
            if (e == null)
            {
                return;
            }
            switch (e.LogType)
            {
                case FISDeviceLogCategory.Error:
                    Logger.WriteLineError(e.Msg);
                    break;

                case FISDeviceLogCategory.Warn:
                    Logger.WriteLineWarn(e.Msg);
                    break;

                case FISDeviceLogCategory.Verb:
                    Logger.WriteLineVerbose(e.Msg);
                    break;

                case FISDeviceLogCategory.Info:
                default:
                    Logger.WriteLineInfo(e.Msg);
                    break;
            }
        }

        public void ChangeRealTimeCaptureSetting(bool isStart)
        {
            try
            {
                if (FISIMPL.IsConnectWithOldServer)
                {
                    Logger.WriteLineError($"ChangeRealTimeCaptureSetting error: old Server doesn't support");
                    return;
                }
                else
                {
                    if (_liveVideoV2 == null)
                    {
                        Logger.WriteLineError($"ChangeRealTimeCaptureSetting error: live videoV2 feature is null");
                        return;
                    }
                    _liveVideoV2.ChangeRealTimeCaptureSetting(isStart);
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"LiveVideoServiceForWindows ChangeRealTimeCaptureSetting Error:{ex}");
            }
        }

        /// <summary>
        /// Capture current Image
        /// </summary>
        public void CaptureCurrentImage()
        {
            try
            {
                if (FISIMPL.IsConnectWithOldServer)
                {
                    Logger.WriteLineError($"CaptureCurrentImage error: old Server doesn't support");
                    return;
                }
                else
                {
                    if (_liveVideoV2 == null)
                    {
                        Logger.WriteLineError($"CaptureCurrentImage error: live videoV2 feature is null");
                        return;
                    }
                    _liveVideoV2.CaptureCurrentImage();
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"LiveVideoServiceForWindows CaptureCurrentImage Error:{ex}");
            }
        }

        /// <summary>
        /// Start Record Video
        /// </summary>
        public void StartRecordVideo()
        {
            try
            {
                if (FISIMPL.IsConnectWithOldServer)
                {
                    Logger.WriteLineError($"StartRecordVideo error: old Server doesn't support");
                    return;
                }
                else
                {
                    if (_liveVideoV2 == null)
                    {
                        Logger.WriteLineError($"StartRecordVideo error: live videoV2 feature is null");
                        return;
                    }
                    _liveVideoV2.StartRecordVideo();
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"LiveVideoServiceForWindows StartRecordVideo Error:{ex}");
            }
        }

        /// <summary>
        /// Stop Record Video
        /// </summary>
        public void StopRecordVideo(bool isTimeOut)
        {
            try
            {
                if (FISIMPL.IsConnectWithOldServer)
                {
                    Logger.WriteLineError($"StopRecordVideo error: old Server doesn't support");
                    return;
                }
                else
                {
                    if (_liveVideoV2 == null)
                    {
                        Logger.WriteLineError($"StopRecordVideo error: live videoV2 feature is null");
                        return;
                    }
                    _liveVideoV2.StopRecordVideo(isTimeOut);
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"LiveVideoServiceForWindows StopRecordVideo Error:{ex}");
            }
        }

        public void ReUploadRestVid()
        {
            try
            {
                if (FISIMPL.IsConnectWithOldServer)
                {
                    Logger.WriteLineError($"ReUploadRestVid error: old Server doesn't support");
                    return;
                }
                else
                {
                    if (_liveVideoV2 == null)
                    {
                        Logger.WriteLineError($"ReUploadRestVid error: live videoV2 feature is null");
                        return;
                    }
                    _liveVideoV2.ReUploadRestVid();
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"LiveVideoServiceForWindows StopRecordVideo Error:{ex}");
            }
        }

        public FISBase64ImageData GetCurrentCaptureFrame()
        {
            try
            {
                if (FISIMPL.IsConnectWithOldServer)
                {
                    Logger.WriteLineError($"GetCurrentCaptureFrame error: old Server doesn't support");
                    return new FISBase64ImageData(0, 0, "", FailReasonForNullBase64Data.OldServerNotSupport);
                }
                else
                {
                    if (_liveVideoV2 == null)
                    {
                        Logger.WriteLineError($"GetCurrentCaptureFrame error: live videoV2 feature is null");
                        return new FISBase64ImageData(0, 0, "", FailReasonForNullBase64Data.vCloudIsDisconnected);
                    }
                    var videoFrameData = _liveVideoV2.GetCurrentCaptureFrame();
                    if (videoFrameData == null)
                    {
                        return new FISBase64ImageData(0, 0, "", FailReasonForNullBase64Data.Unknown);
                    }
                    else if (_tempBase64ImageData == null)
                    {
                        _tempBase64ImageData = new FISBase64ImageData(videoFrameData.Width, videoFrameData.Height, "");
                    }
                    else if (_tempBase64ImageData.Width != videoFrameData.Width || _tempBase64ImageData.Height != videoFrameData.Height)
                    {
                        _tempBase64ImageData.Width = videoFrameData.Width;
                        _tempBase64ImageData.Height = videoFrameData.Height;
                    }
                    _tempBase64ImageData.Base64Data = videoFrameData.Base64Data;
                    _tempBase64ImageData.FailMsg = (FailReasonForNullBase64Data)videoFrameData.FailMsg;
                    return _tempBase64ImageData;
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"LiveVideoServiceForWindows GetCurrentCaptureFrame Error:{ex}");
                return null;
            }
        }
    }
}