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

using FISLib;
using FISLib.Connect;
using FISLib.LiveVideo;
using System;
using System.Linq;
using Vinno.FIS.Sonopost.Features.Config;
using Vinno.FIS.Sonopost.Features.Oled;
using Vinno.FIS.Sonopost.Managers.Interfaces;
using Vinno.IUS.Common.Log;
using Vinno.IUS.Common.Utilities;

namespace Vinno.FIS.Sonopost.Managers
{
    internal class LoginManager : SonopostManager, ILoginManager
    {
        private FISServerInfo _serverInfo;
        private FISAccountInfo _accountInfo;
        private UltrasoundMachineInfo _ultrasoundMachineInfo;
        private readonly IConfigManager _configManager;
        private readonly IConnectionService _connectionService;
        private IVersionCheckManager _versionCheckManager;
        private ILiveVideoManager _liveVideoManager;
        private IOledManager _oledManager;
        private IRemedicalManager _remedicalManager;
        private IKeyBoardListenManager _keyBoardListenManager;

        public bool IsLoginWithAccountAndPassword { get; private set; }

        public bool HasGetFasterServer { get; private set; }
        public string UniqueId { get; private set; }

        public string QRCodeString { get; private set; }
        public DeviceStatus DeviceStatus { get; private set; }

        public bool IsConnectWithOldServer => FISIMPL.FISIMPL.IsConnectWithOldServer;

        public event EventHandler<DeviceStatus> LoginStatusChanged;

        public LoginManager()
        {
            _configManager = AppManager.Instance.GetManager<IConfigManager>();
            _connectionService = AppManager.Instance.GetManager<IFISManager>().FISConnectionService;
            _connectionService.SetIsSonopost(true);
            _connectionService.FISDeviceStatusChanged += OnFISDeviceStatusChanged;
            _ultrasoundMachineInfo = AppManager.Instance.GetManager<IFISManager>().UltrasoundMachineInfo;
            HasGetFasterServer = false;
            IsLoginWithAccountAndPassword = SonopostUserDefinedSettings.Instance.ServerSetting.IsLoginWithAccountAndPassword;
        }

        public void Init()
        {
            _liveVideoManager = AppManager.Instance.GetManager<ILiveVideoManager>();
            _versionCheckManager = AppManager.Instance.GetManager<IVersionCheckManager>();
            _oledManager = AppManager.Instance.GetManager<IOledManager>();
            _keyBoardListenManager = AppManager.Instance.GetManager<IKeyBoardListenManager>();
            _remedicalManager = AppManager.Instance.GetManager<IRemedicalManager>();
        }

        private void OnFISDeviceStatusChanged(object sender, FISDeviceStatusInfo e)
        {
            try
            {
                DeviceStatus = e.Status;
                Logger.WriteLineInfo($"Device Status Changed:{e.Status},UniqueId:{e.UniqueId}");
                switch (e.Status)
                {
                    case DeviceStatus.Logon:
                        UniqueId = e.UniqueId;
                        QRCodeString = _connectionService.GetQRStringForVCloudLogin();
                        _configManager.SaveVCloudServer();
                        if (SonopostUserDefinedSettings.Instance.IsFirstLogin && _liveVideoManager.SonoDevice != null && _liveVideoManager.SonoDevice.Capabilities.Any(x => x.Width == 1280 && x.Height == 720))
                        {
                            var videoInfos = SonopostUserDefinedSettings.Instance.HardwareSetting.VideoDeviceInfoList;
                            var config = videoInfos?.FirstOrDefault(x => x.Category == FISLiveChannelCategory.Main);
                            if (config == null)
                            {
                                config = new FISVideoDeviceInfo
                                {
                                    Category = FISLiveChannelCategory.Main
                                };
                                videoInfos.Add(config);
                            }

                            config.Id = _liveVideoManager.SonoDevice.Id;
                            config.Name = _liveVideoManager.SonoDevice.Name;
                            config.IsEnable = true;
                            config.Width = 1280;
                            config.Height = 720;
                            config.FrameRate = 20;
                            config.IsAvailable = true;
                            SonopostUserDefinedSettings.Instance.IsFirstLogin = false;
                            _configManager.Save();
                        }
                        if (IsConnectWithOldServer)
                        {
                            if (SonopostUserDefinedSettings.Instance.CaptureSetting.RealTimeCaptureEnabled)
                            {
                                SonopostUserDefinedSettings.Instance.CaptureSetting.RealTimeCaptureEnabled = false;
                                _configManager.Save();
                                _keyBoardListenManager.StopKeyBoardListen();
                            }
                        }
                        var organization = _connectionService.GetOrganizationName();
                        if (organization != _ultrasoundMachineInfo.Organizataion)
                        {
                            _ultrasoundMachineInfo.Organizataion = organization;
                            FISIMPL.FISIMPL.SetUltrasoundMachineInfo(_ultrasoundMachineInfo);
                        }
                        _oledManager.ShowStatus(OledMessage.Logined);
                        break;

                    case DeviceStatus.Logoning:
                        UniqueId = string.Empty;
                        QRCodeString = string.Empty;
                        _oledManager.ShowStatus(OledMessage.Logining);
                        break;

                    case DeviceStatus.Reconnecting:
                        UniqueId = string.Empty;
                        QRCodeString = string.Empty;
                        _oledManager.ShowStatus(OledMessage.Reconnecting);
                        break;

                    case DeviceStatus.LoginFailed:
                    case DeviceStatus.WrongAccount:
                    case DeviceStatus.WrongPassword:
                        UniqueId = string.Empty;
                        QRCodeString = string.Empty;
                        _oledManager.ShowStatus(OledMessage.LoginFail);
                        break;

                    default:
                        UniqueId = string.Empty;
                        QRCodeString = string.Empty;
                        _oledManager.ShowStatus(OledMessage.Offline);
                        break;
                }
                LoginStatusChanged?.Invoke(this, e.Status);
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"LoginManager OnFISDeviceStatusChanged Error:{ex}");
            }
        }

        public DeviceStatus Login(string organizationName = null)
        {
            try
            {
                var userName = DesBuilder.Decrypt(SonopostUserDefinedSettings.Instance.ServerSetting.UserName);
                var password = DesBuilder.Decrypt(SonopostUserDefinedSettings.Instance.ServerSetting.UserPassword);
                IsLoginWithAccountAndPassword = SonopostUserDefinedSettings.Instance.ServerSetting.IsLoginWithAccountAndPassword;
                AppManager.Instance.GetManager<IOledManager>().ShowStatus(OledMessage.Logining);
                if (IsLoginWithAccountAndPassword)
                {
                    _accountInfo = new FISAccountInfo(userName, password, true);
                }
                else
                {
                    _accountInfo = new FISAccountInfo(userName, password, false);
                }
                _serverInfo = new FISServerInfo(_configManager.VCloudServerAddress, _configManager.VCloudServerPort);
                var connectionInfo = new FISConnectionInfo(_serverInfo, _accountInfo, organizationName, new FISFeatureSettings
                {
                    AfterSalesEnabled = true,
                    LiveVideoEnabled = true,
                    RemedicalEnabled = true,
                    TeachingEnabled = false,
                });
                var loginResult = _connectionService.Connect(connectionInfo, false, "", "");
                if (loginResult == null)
                {
                    loginResult = new FISDeviceStatusInfo
                    {
                        Status = DeviceStatus.LoginFailed,
                    };
                }
                OnFISDeviceStatusChanged(this, loginResult);
                return loginResult.Status;
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"LoginManager Login Error:{ex}");
                return DeviceStatus.LoginFailed;
            }
        }

        public bool Logoff()
        {
            try
            {
                _connectionService.Disconnect();
                return true;
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"LoginManager LogOff Error:{ex}");
                return false;
            }
        }

        public FISServerInfo GetFasterServerInfo()
        {
            try
            {
                var result = _connectionService.GetFasterServer(false);
                if (result != null)
                {
                    HasGetFasterServer = true;
                }
                return result;
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"GetFasterServerInfo Error:{ex}");
            }
            return null;
        }

        public bool ChangeServer(string address, int port, string vCloudServerName)
        {
            try
            {
                _configManager.SwitchVCloudServer(address, port, vCloudServerName);
                ResetServerAddress($"{address}:{port}");
                return true;
            }
            catch
            {
                return false;
            }
        }

        private void ResetServerAddress(string serverAddress)
        {
            if (string.IsNullOrEmpty(serverAddress))
            {
                return;
            }

            var server = serverAddress.Split(':');
            if (server.Length == 2)
            {
                var host = server[0];
                var port = server[1];
                int.TryParse(port, out var portNumber);
                _serverInfo = new FISServerInfo(host, portNumber);
            }
        }

        public override void DoDispose()
        {
            try
            {
                if (DeviceStatus == DeviceStatus.Logon)
                {
                    Logoff();
                }
                UniqueId = string.Empty;
                QRCodeString = string.Empty;
                _connectionService.FISDeviceStatusChanged -= OnFISDeviceStatusChanged;
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"LoginManager DoDispose Error:{ex}");
            }
            base.DoDispose();
        }
    }
}