FISLib_Old/Vinno.FIS.Sonopost/Features/Network/WirelessNetworkInterfaceInfo.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.NetworkInformation;
using System.Threading;
using System.Threading.Tasks;
using Vinno.FIS.Sonopost.Wireless;
using Vinno.IUS.Common.Log;

namespace Vinno.FIS.Sonopost.Features.Network
{
    public class WirelessNetworkInterfaceInfo : NetworkInterfaceInfo
    {
        private Wifi _wifi;
        private NetworkInterface _wlanInterface;

        public WifiStatus ConnectionStatus => _wifi?.ConnectionStatus ?? WifiStatus.Disconnected;

        private int _timingRefreshInterval;//unit:second

        private readonly object _locker = new object();

        private readonly ManualResetEvent _timingRefreshManualResetEvent = new ManualResetEvent(false);
        private IList<AccessPoint> _wirelessNetworks;

        private IList<AccessPoint> _currentWirelessNetworks;

        public event EventHandler<WifiStatusEventArgs> ConnectionStatusChanged;

        public WirelessNetworkInterfaceInfo(NetworkInterface networkInterface) : base(networkInterface)
        {
            _wifi = new Wifi();
            _wlanInterface = networkInterface;
            _wirelessNetworks = new List<AccessPoint>();
            _currentWirelessNetworks = new List<AccessPoint>();
            RefreshNetworks();
            _timingRefreshInterval = 3;
            StartTimerRefreshTask();
        }

        private void StartTimerRefreshTask()
        {
            Logger.WriteLineInfo("WirelessNetworkInterfaceInfo Start Timer Refresh Task");
            Task.Run(() =>
            {
                _timingRefreshManualResetEvent.Reset();
                try
                {
                    while (!_timingRefreshManualResetEvent.WaitOne(_timingRefreshInterval * 1000))
                    {
                        RefreshNetworks();
                    }
                }
                catch (Exception ex)
                {
                    Logger.WriteLineError($"WirelessNetworkInterfaceInfo Timer Refresh Task Error, ex:{ex}");
                }
                finally
                {
                    Logger.WriteLineInfo($"WirelessNetworkInterfaceInfo Timer Refresh Task Finshed");
                }
            });
        }

        private void RefreshNetworks()
        {
            try
            {
                var list = _wifi.GetAccessPoints(_wlanInterface.Id);
                _wirelessNetworks.Clear();
                foreach (var item in list.OrderBy(c => c.SignalStrength))
                {
                    if (string.IsNullOrWhiteSpace(item.Name))
                    {
                        _wirelessNetworks.Add(item);
                    }
                    else
                    {
                        _wirelessNetworks.Insert(0, item);
                    }
                }
                lock (_locker)
                {
                    _currentWirelessNetworks.Clear();
                    foreach (var network in _wirelessNetworks)
                    {
                        _currentWirelessNetworks.Add((AccessPoint)network.Clone());
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"WirelessNetworkInterfaceInfo RefreshNetworks Error, ex:{ex}");
            }
        }

        public IList<AccessPoint> GetAccessPoints()
        {
            lock (_locker)
            {
                var wirelessNetworks = new List<AccessPoint>();
                foreach (var network in _currentWirelessNetworks)
                {
                    wirelessNetworks.Add((AccessPoint)network.Clone());
                }
                return wirelessNetworks;
            }
        }

        public bool Connect(AccessPoint accessPoint, string userName, string password, string domain = "")
        {
            try
            {
                AuthRequest authRequest = new AuthRequest(accessPoint);
                bool overwrite = true;
                if (authRequest.IsPasswordRequired)
                {
                    if (accessPoint.HasProfile)
                    {
                        overwrite = false;
                    }
                    if (overwrite)
                    {
                        if (authRequest.IsUsernameRequired)
                        {
                            authRequest.Username = userName;
                            if (!accessPoint.IsValidPassword(password))
                            {
                                return false;
                            }
                        }
                        authRequest.Password = password;
                        if (authRequest.IsDomainSupported)
                        {
                            authRequest.Domain = domain;
                        }
                    }
                }

                if (accessPoint?.Connect(authRequest, overwrite) == false)
                {
                    accessPoint.DeleteProfile();
                    return false;
                }
                return true;
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"Connect Wifi Error:{ex}");
            }
            return false;
        }

        public bool Disconnect()
        {
            try
            {
                _wifi?.Disconnect();
                return true;
            }
            catch (Exception e)
            {
                Logger.WriteLineError($"DisConnect Error:{e}");
                return false;
            }
        }

        public void DeleteProfile(AccessPoint accessPoint)
        {
            accessPoint.DeleteProfile();
        }

        internal override void Dispose()
        {
            base.Dispose();
            _timingRefreshManualResetEvent.Set();
        }
    }
}