FISLib_Old/Vinno.FIS.Sonopost/App.xaml.cs

using Microsoft.Win32;
using System;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Net.NetworkInformation;
using System.Reflection;
using System.Threading;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Threading;
using Vinno.FIS.Sonopost.Common;
using Vinno.FIS.Sonopost.Features.Config;
using Vinno.FIS.Sonopost.Features.Network;
using Vinno.FIS.Sonopost.Features.Oled;
using Vinno.FIS.Sonopost.Helpers;
using Vinno.FIS.Sonopost.Managers;
using Vinno.FIS.Sonopost.Managers.Interfaces;
using Vinno.IUS.Common.Log;

namespace Vinno.FIS.Sonopost
{
    /// <summary>
    /// App.xaml 的交互逻辑
    /// </summary>
    public partial class App : Application
    {
        private LogEngine _logEngine;
        private WebHost _webHost;
        private IOledManager _oledManager;
        private bool _isWifi;
        private bool _isDisposed;
        private readonly ManualResetEvent _manualResetEvent = new ManualResetEvent(false);
        private INetworkManager _networkManager;

        protected override void OnStartup(StartupEventArgs e)
        {
            try
            {
                base.OnStartup(e);
                CheckedOpenRepeatedly();
                var absolutePath = Path.GetPathRoot(AppDomain.CurrentDomain.BaseDirectory);
                var path = Path.Combine(absolutePath, "Sonopost");
                if (!Directory.Exists(path))
                {
                    Directory.CreateDirectory(path);
                }
                SonopostConstants.DataFolder = path;
                _logEngine = new SonopostLogEngine();
                Logger.RegisterEngine(_logEngine);
                Logger.WriteLineWarn("=======================Sonopost BootUp=======================");
                FISIMPL.FISIMPL.InitLogEngine(_logEngine);
                var version = Assembly.GetExecutingAssembly().GetName().Version.ToString();
                Logger.WriteLineInfo($"Current Version:{version}");
                AppDomain.CurrentDomain.UnhandledException += CurrentDomainUnhandledException;
                this.DispatcherUnhandledException += OnDispatcherUnhandledException;
                SystemEvents.SessionEnded += OnSessionEnded;
                ClearUp();
                AppManager.Instance.Initialize();
                Init();
                _webHost = new WebHost();
                _webHost.Start();
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"Sonopost Start Up Error:{ex}");
                Process.GetCurrentProcess().Kill();
            }
        }

        private void Init()
        {
            SetNetwork();
            _networkManager = AppManager.Instance.GetManager<INetworkManager>();
            _networkManager.CurrentNetworkChanged += OnCurrentNetworkChanged;
            _networkManager.CurrentWifiLevelChanged += OnCurrentWifiLevelChanged;
            _oledManager = AppManager.Instance.GetManager<IOledManager>();
            _oledManager.ShowStatus(OledMessage.Started);
            OnCurrentNetworkChanged(null, _networkManager.CurrentNetwork);
            OnCurrentWifiLevelChanged(null, _networkManager.CurrentWifiLevel);
            // CheckAvailableDevices();
            AutoLogin();
            var deviceManager = AppManager.Instance.GetManager<IDeviceManager>();
            deviceManager.Init();
        }

        private void ClearUp()
        {
            var path = AppDomain.CurrentDomain.BaseDirectory;
            string newUpgrade = Path.Combine(path, SonopostConstants.NewUpgradeAppFileName);
            string oldUpgrade = Path.Combine(path, SonopostConstants.UpgradeAppFileName);
            if (File.Exists(newUpgrade))
            {
                if (File.Exists(oldUpgrade))
                {
                    var result = ProcessHelper.FinishProcessByName(SonopostConstants.UpgradeAppName);
                    if (result == false)
                    {
                        Logger.WriteLineError("Finish Upgrade Process Error!");
                        return;
                    }
                    Thread.Sleep(100);
                    File.Delete(oldUpgrade);
                }
                File.Move(newUpgrade, oldUpgrade);
            }
        }

        private void OnCurrentNetworkChanged(object sender, NetworkInterfaceInfo e)
        {
            if (e != null)
            {
                var ip = e.IpAddress.Value;
                var mac = e.MacAddress;
                Logger.WriteLineInfo($"Current IP:{ip}");
                Logger.WriteLineInfo($"Current Mac:{mac}");
                if (!string.IsNullOrEmpty(ip) && e.OperationalStatus == OperationStatus.Connected)
                {
                    _oledManager.ShowMessages(1, MessageType.DisplayEnglishMediumWithPageNum, ip, 1);
                }
                else
                {
                    _oledManager.ShowMessages(1, MessageType.DisplayEnglishMediumWithPageNum, mac, 1);
                }
                _isWifi = e.NetworkInterfaceType == NetworkInterfaceType.Wireless80211;
                if (!_isWifi)
                {
                    _oledManager.ClearImage(1, 104, 4, 24, 24);
                }
            }
        }

        private void OnCurrentWifiLevelChanged(object sender, int e)
        {
            if (_isWifi)
            {
                var levelPic = $"wifi_{e}.png";
                _oledManager.ShowImage(1, MessageType.DisplayImageInCurrentPage, 104, 4, levelPic);
            }
        }

        private void SetNetwork()
        {
            try
            {
                var netWorkManager = AppManager.Instance.GetManager<INetworkManager>();
                var configManager = AppManager.Instance.GetManager<IConfigManager>();

                if (SonopostUserDefinedSettings.Instance.NetworkSetting.NeedDoubleNetwork)
                {
                    var outsideAddress = SonopostUserDefinedSettings.Instance.NetworkSetting.OutsideNetworkMacAddress;

                    var outsideInterface = netWorkManager.GetAllNetworkInterfaceInfos().FirstOrDefault(c => c.MacAddress == outsideAddress);

                    if (outsideInterface == null)
                        return;

                    var result = netWorkManager.SetDualNetwork(outsideInterface.MacAddress);

                    Logger.WriteLineInfo(result ? "SetDualNetworkEnable Success!" : "SetDualNetworkEnable Fail!");
                }
            }
            catch (Exception e)
            {
                Logger.WriteLineError($"SetNetwork Error:{e}");
            }
        }

        private void AutoLogin()
        {
            var isAutoLogin = SonopostUserDefinedSettings.Instance.ServerSetting.IsAutoLogin;
            Logger.WriteLineInfo($"Auto Login:{isAutoLogin}");
            if (isAutoLogin)
            {
                Thread.Sleep(3000);
                var loginManager = AppManager.Instance.GetManager<ILoginManager>();
                loginManager.Login();
                Thread.Sleep(1500);
            }
        }

        protected override void OnExit(ExitEventArgs e)
        {
            Logger.WriteLineWarn("OnExit Invoke");
            Dispose();
            base.OnExit(e);
        }

        private void OnDispatcherUnhandledException(object sender, DispatcherUnhandledExceptionEventArgs e)
        {
            Logger.WriteLineError($"DispatcherUnhandledException:{e.Exception}");
            _oledManager?.ShowStatus(OledMessage.Error);
            Thread.Sleep(2000);
            Process.GetCurrentProcess().Kill();
        }

        private void CurrentDomainUnhandledException(object sender, UnhandledExceptionEventArgs e)
        {
            Logger.WriteLineError($"UnhandledException:{e.ExceptionObject}");
            _oledManager?.ShowStatus(OledMessage.Error);
            Thread.Sleep(2000);
            Process.GetCurrentProcess().Kill();
        }

        /// <summary>
        /// 判断是否重复打开
        /// </summary>
        private void CheckedOpenRepeatedly()
        {
            var thisProcess = Process.GetCurrentProcess();
            if (Process.GetProcessesByName(thisProcess.ProcessName).Where(x => x.ProcessName == thisProcess.ProcessName).Count() > 1)
            {
                thisProcess.Kill();
            }
        }

        private void OnSessionEnded(object sender, SessionEndedEventArgs e)
        {
            try
            {
                Logger.WriteLineWarn($"Sonopost OnSessionEnded Invoke");
                _oledManager?.ShowStatus(OledMessage.ShutDown);
                Dispose();
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"Sonopost OnSessionEnded Invoke Error:{ex}");
            }
            finally
            {
                Logger.WriteLineWarn("=======================Sonopost Shutdown=======================");
                Process.GetCurrentProcess().Kill();
            }
        }

        private void Dispose()
        {
            if (_isDisposed)
            {
                return;
            }

            Logger.WriteLineWarn("Sonopost Dispose Invoke");
            try
            {
                Task.Run(() =>
                {
                    try
                    {
                        _networkManager.CurrentNetworkChanged -= OnCurrentNetworkChanged;
                        _networkManager.CurrentWifiLevelChanged -= OnCurrentWifiLevelChanged;
                        AppDomain.CurrentDomain.UnhandledException -= CurrentDomainUnhandledException;
                        SystemEvents.SessionEnded -= OnSessionEnded;
                        _webHost?.Dispose();
                        AppManager.Instance.DisposeAllManagers();
                    }
                    catch (Exception ex)
                    {
                        Logger.WriteLineError($"Sonopost Dispose Error:{ex}");
                    }
                });
                _manualResetEvent.WaitOne(3000);
                _isDisposed = true;
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"Sonopost Dispose Error:{ex}");
            }
        }
    }
}