FISLib_Old/FISSDK/FISIMPL/LiveVideoServiceForAndroid.cs

using FISLib;
using FISLib.LiveVideo;
using FISLib.Notification;
using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;
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 LiveVideoServiceForAndroid : ILiveVideoService, IDisposable
    {
        private ILiveVideo _liveVideo;
        private ILiveVideoV2 _liveVideoV2;
        private FileTransferReader _fileReaderForLiveVideoUltrasoundImage;
        private FileTransferWriter _fileWriterForLiveVideoCameraPreviewImage;
        private FISImageFrameData _imageFrameData;

        /// <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)
                        {
                            _fileReaderForLiveVideoUltrasoundImage.ExceptionThrows -= OnExceptionThrows;
                            _fileReaderForLiveVideoUltrasoundImage.DataReceived -= OnDataReceived;
                            _fileReaderForLiveVideoUltrasoundImage.Dispose();
                            _fileReaderForLiveVideoUltrasoundImage = null;
                            _fileWriterForLiveVideoCameraPreviewImage.ExceptionThrows -= OnExceptionThrows;
                            _fileWriterForLiveVideoCameraPreviewImage.Dispose();
                            _fileWriterForLiveVideoCameraPreviewImage = null;
                        }
                    }
                    _liveVideo = newLiveVideo;
                    if (_liveVideo != null)
                    {
                        _liveVideo.PreviewCameraCaptured += OnPreviewCameraCaptured;
                        _liveVideo.CameraPreviewImageSizeChanged += OnCameraPreviewImageSizeChanged;
                        _liveVideo.LiveNotification += OnLiveNotification;
                        if (FISIMPL.IsRunningJsonRpcMode)
                        {
                            _fileReaderForLiveVideoUltrasoundImage = new FileTransferReader(FISConsts.ImageTransferFolderForLiveVideoUltrasoundImage, FISConsts.ImageTransferFolderForLiveVideo, FISIMPL.UltrasoundMachineInfo?.FISFolder);
                            _fileReaderForLiveVideoUltrasoundImage.ExceptionThrows += OnExceptionThrows;
                            _fileReaderForLiveVideoUltrasoundImage.DataReceived += OnDataReceived;
                            _fileReaderForLiveVideoUltrasoundImage.StartContinuousRead();
                            _fileWriterForLiveVideoCameraPreviewImage = new FileTransferWriter(FISConsts.ImageTransferFolderForLiveVideoCameraPreviewImage, FISConsts.ImageTransferFolderForLiveVideo, FISIMPL.UltrasoundMachineInfo?.FISFolder);
                            _fileWriterForLiveVideoCameraPreviewImage.ExceptionThrows += OnExceptionThrows;
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"LiveVideoServiceForAndroid 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.Dispose();
                        _liveVideoV2 = null;
                        if (FISIMPL.IsRunningJsonRpcMode)
                        {
                            _fileReaderForLiveVideoUltrasoundImage.ExceptionThrows -= OnExceptionThrows;
                            _fileReaderForLiveVideoUltrasoundImage.DataReceived -= OnDataReceived;
                            _fileReaderForLiveVideoUltrasoundImage.Dispose();
                            _fileReaderForLiveVideoUltrasoundImage = null;
                            _fileWriterForLiveVideoCameraPreviewImage.ExceptionThrows -= OnExceptionThrows;
                            _fileWriterForLiveVideoCameraPreviewImage.Dispose();
                            _fileWriterForLiveVideoCameraPreviewImage = null;
                        }
                    }
                    _liveVideoV2 = newLiveVideo;
                    if (_liveVideoV2 != null)
                    {
                        _liveVideoV2.PreviewCameraCaptured += OnPreviewCameraCaptured;
                        _liveVideoV2.CameraPreviewImageSizeChanged += OnCameraPreviewImageSizeChanged;
                        _liveVideoV2.LiveNotification += OnLiveNotification;
                        if (FISIMPL.IsRunningJsonRpcMode)
                        {
                            _fileReaderForLiveVideoUltrasoundImage = new FileTransferReader(FISConsts.ImageTransferFolderForLiveVideoUltrasoundImage, FISConsts.ImageTransferFolderForLiveVideo, FISIMPL.UltrasoundMachineInfo?.FISFolder);
                            _fileReaderForLiveVideoUltrasoundImage.ExceptionThrows += OnExceptionThrows;
                            _fileReaderForLiveVideoUltrasoundImage.DataReceived += OnDataReceived;
                            _fileReaderForLiveVideoUltrasoundImage.StartContinuousRead();
                            _fileWriterForLiveVideoCameraPreviewImage = new FileTransferWriter(FISConsts.ImageTransferFolderForLiveVideoCameraPreviewImage, FISConsts.ImageTransferFolderForLiveVideo, FISIMPL.UltrasoundMachineInfo?.FISFolder);
                            _fileWriterForLiveVideoCameraPreviewImage.ExceptionThrows += OnExceptionThrows;
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"LiveVideoServiceForAndroid Update 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($"LiveVideoServiceForAndroid OnCameraPreviewImageSizeChanged Error:{ex}");
            }
        }

        /// <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 videoV2 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($"LiveVideoServiceForAndroid ChangeCameraSetting Error:{ex}");
            }
        }

        public void ChangeCameraSettingForSonopost(CameraSettingForSonopost cameraSetting)
        {
            throw new NotImplementedException();
        }

        /// <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>
        /// 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($"LiveVideoServiceForAndroid StartSpeedTest Error:{ex}");
                return false;
            }
        }

        /// <summary>
        /// 约耗时100ms+，不如OnDataReceived快(约50ms)，故弃用。
        /// </summary>
        /// <param name="length"></param>
        /// <param name="width"></param>
        /// <param name="height"></param>
        public void CapturedUSImageData(int length, int width, int height)
        {
            try
            {
                var byteImage = _fileReaderForLiveVideoUltrasoundImage?.ReadFromFile(length);
                if (byteImage == null || byteImage.Length != length)
                {
                    return;
                }
                var imageCaptureDataInfo = new CaptureDataInfo
                {
                    Width = width,
                    Height = height,
                    Data = byteImage,
                };
                ImageDataCapturer.RaiseImdageDataCaptured(imageCaptureDataInfo);
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"LiveVideoServiceForAndroid CapturedUSImageData Error:{ex}");
            }
        }

        /// <summary>
        /// Capture ultrasound machie image data.
        /// </summary>
        /// <param name="fisVideoFrameData">image data</param>
        public void CapturedUSImageData_2(FISVideoFrameData fisVideoFrameData)
        {
            try
            {
                var imageCaptureDataInfo = new CaptureDataInfo
                {
                    Width = fisVideoFrameData.Width,
                    Height = fisVideoFrameData.Height,
                    Data = fisVideoFrameData.Data,
                };
                ImageDataCapturer.RaiseImdageDataCaptured(imageCaptureDataInfo);
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"LiveVideoServiceForAndroid CapturedUSImageData Error:{ex}");
            }
        }

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

        private void OnPreviewCameraCaptured(object sender, byte[] e)
        {
            try
            {
                if (e == null)
                {
                    return;
                }
                if (FISIMPL.IsRunningJsonRpcMode)
                {
                    _fileWriterForLiveVideoCameraPreviewImage.WriteToFileContinuous(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($"LiveVideoServiceForAndroid OnPreviewCameraCaptured 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($"LiveVideoServiceForAndroid OnLiveNotification Error:{ex}");
            }
        }

        private void OnExceptionThrows(object sender, Exception e)
        {
            if (sender is FileTransferReader fileReader)
            {
                Logger.WriteLineError($"File Reader {fileReader.Name} throw exception {e}");
            }
            else if (sender is FileTransferWriter fileWriter)
            {
                Logger.WriteLineError($"File Writer {fileWriter.Name} throw exception {e}");
            }
        }

        private void OnDataReceived(object sender, byte[] e)
        {
            FISVideoFrameData videoFrameData = new FISVideoFrameData();
            try
            {
                videoFrameData.LoadFromBytes(e);
                var imageCaptureDataInfo = new CaptureDataInfo
                {
                    Width = videoFrameData.Width,
                    Height = videoFrameData.Height,
                    Data = videoFrameData.Data,
                };
                ImageDataCapturer.RaiseImdageDataCaptured(imageCaptureDataInfo);
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"LiveVideoServiceForAndroid OnDataReceived Error:{ex}");
            }
            finally
            {
                videoFrameData?.Close();
            }
        }

        public void ChangeRealTimeCaptureSetting(bool isStart)
        {
            throw new NotImplementedException();
        }

        /// <summary>
        /// Capture current Image
        /// </summary>
        public void CaptureCurrentImage()
        {
            throw new NotImplementedException();
        }

        /// <summary>
        /// Start Record Video
        /// </summary>
        public void StartRecordVideo()
        {
            throw new NotImplementedException();
        }

        /// <summary>
        /// Stop Record Video
        /// </summary>
        public void StopRecordVideo(bool isTimeOut)
        {
            throw new NotImplementedException();
        }

        public void ReUploadRestVid()
        {
            throw new NotImplementedException();
        }
    }
}