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

using FISLib.Hardware;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Management;
using System.Net.NetworkInformation;
using System.Threading;
using System.Threading.Tasks;
using Vinno.FIS.Sonopost.Managers.Interfaces;
using Vinno.FIS.Sonopost.Settings;
using Vinno.IUS.Common.Log;

namespace Vinno.FIS.Sonopost.Managers
{
    internal class DeviceManager : SonopostManager, IDeviceManager
    {
        private const string Scope = "root\\CIMV2";
        private const string Win32USBHubQuery = "SELECT * FROM {0} WITHIN 2 WHERE TargetInstance ISA 'Win32_USBHub'";
        private const string Win32_USBControllerDeviceQuery = "SELECT * FROM {0} WITHIN 2 WHERE TargetInstance ISA 'Win32_USBControllerDevice'";
        private const string CreationEvent = "__InstanceCreationEvent";
        private const string DeletionEvent = "__InstanceDeletionEvent";

        private readonly IHardwareService _fisHardwareService;
        private readonly List<FISCameraInfo> _cameraInfos;
        private readonly List<FISMicInfo> _micInfos;
        private readonly object _deviceLocker = new object();
        private readonly object _locker = new object();
        private bool _networkChanged;
        private ManagementEventWatcher _wifiModuleInsertWatcher;
        private ManagementEventWatcher _wifiModuleRemoveWatcher;
        private ManagementEventWatcher _usbInsertWatcher;
        private ManagementEventWatcher _usbRemoveWatcher;

        /// <summary>
        /// 当WIFI 模块插入时触发
        /// </summary>
        public event EventHandler<EventArrivedEventArgs> WifiModuleInserted;

        /// <summary>
        /// 当U盘设备插入时触发
        /// </summary>
        public event EventHandler<string> UDiskInserted;

        /// <summary>
        /// 当网络地址变化时触发
        /// </summary>
        public event EventHandler NetworkAddressChanged;

        public DeviceManager()
        {
            _cameraInfos = new List<FISCameraInfo>();
            _micInfos = new List<FISMicInfo>();
            _fisHardwareService = AppManager.Instance.GetManager<IFISManager>().FISHardwareService;
            RefreshCameras();
        }

        public void Init()
        {
            var scope = new ManagementScope(Scope);
            scope.Options.EnablePrivileges = true;
            _wifiModuleInsertWatcher = new ManagementEventWatcher(scope, new WqlEventQuery(string.Format(Win32_USBControllerDeviceQuery, CreationEvent)));
            _wifiModuleInsertWatcher.EventArrived += OnWifiModuleInserted;
            _wifiModuleInsertWatcher.Start();
            _wifiModuleRemoveWatcher = new ManagementEventWatcher(scope, new WqlEventQuery(string.Format(Win32_USBControllerDeviceQuery, DeletionEvent)));
            _wifiModuleRemoveWatcher.EventArrived += OnWifiModuleRemoved;
            _wifiModuleRemoveWatcher.Start();
            _usbInsertWatcher = new ManagementEventWatcher(scope, new WqlEventQuery(string.Format(Win32USBHubQuery, CreationEvent)));
            _usbInsertWatcher.EventArrived += OnUSBInserted;
            _usbInsertWatcher.Start();
            _usbRemoveWatcher = new ManagementEventWatcher(scope, new WqlEventQuery(string.Format(Win32USBHubQuery, DeletionEvent)));
            _usbRemoveWatcher.EventArrived += OnUSBRemoved;
            _usbRemoveWatcher.Start();
            NetworkChange.NetworkAddressChanged += OnNetworkAddressChanged;
            Logger.WriteLineInfo($"Device Manager Init Invoke");
        }

        private void OnNetworkAddressChanged(object sender, EventArgs e)
        {
            lock (_deviceLocker)
            {
                if (_networkChanged)
                {
                    return;
                }
                _networkChanged = true;
                Task.Run(() =>
                {
                    Thread.Sleep(1000);
                    Logger.WriteLineInfo($"Device Manager OnNetworkAddressChanged Invoke");
                    NetworkAddressChanged?.Invoke(this, e);
                    _networkChanged = false;
                });
            }
        }

        private void OnWifiModuleInserted(object sender, EventArrivedEventArgs e)
        {
            lock (_deviceLocker)
            {
                try
                {
                    var instance = (ManagementBaseObject)e.NewEvent["TargetInstance"];
                    var dependent = (instance["Dependent"] as String).Replace("\"", String.Empty).Split(new Char[] { '=' })[1].Replace("\\\\", "\\");
                    if (dependent.ToLower().Contains("vwifimp"))
                    {
                        Logger.WriteLineInfo($"Device Manager:Wifi Module Inserted , Dependent:{dependent}");
                        WifiModuleInserted?.Invoke(this, e);
                    }
                }
                catch (Exception ex)
                {
                    Logger.WriteLineError($"Device Manager OnWifiModuleInserted Error:{ex}");
                }
            }
        }

        private void OnWifiModuleRemoved(object sender, EventArrivedEventArgs e)
        {
            lock (_deviceLocker)
            {
                try
                {
                    var instance = (ManagementBaseObject)e.NewEvent["TargetInstance"];
                    var dependent = (instance["Dependent"] as String).Replace("\"", String.Empty).Split(new Char[] { '=' })[1].Replace("\\\\", "\\");
                    if (dependent.ToLower().Contains("vwifimp"))
                    {
                        Logger.WriteLineInfo($"Device Manager : Wifi Module Removed , Dependent:{dependent}");
                    }
                }
                catch (Exception ex)
                {
                    Logger.WriteLineError($"Device Manager OnWifiModuleRemoved Error:{ex}");
                }
            }
        }

        /// <summary>
        /// 刷新摄像头
        /// </summary>
        public void RefreshCameras()
        {
            var camearaInfos = _fisHardwareService.GetCameraList();
            lock (_locker)
            {
                _cameraInfos.Clear();
                _cameraInfos.AddRange(camearaInfos);
                Logger.WriteLineInfo($"RefreshCameras:{_cameraInfos.Count}");
            }
        }

        public List<FISCameraInfo> GetCameras()
        {
            lock (_locker)
            {
                return _cameraInfos;
            }
        }

        /// <summary>
        /// 刷新摄像头
        /// </summary>
        public void RefreshMics()
        {
            var micInfos = _fisHardwareService.GetMicList().Where(x => !SonopostSystemSettings.Instance.SkippedMicDeviceNames.Contains(x.Name));
            lock (_locker)
            {
                _micInfos.Clear();
                _micInfos.AddRange(micInfos);
                Logger.WriteLineInfo($"RefreshMics:{_micInfos.Count}");
            }
        }

        public List<FISMicInfo> GetMics()
        {
            lock (_locker)
            {
                return _micInfos;
            }
        }

        private void OnUSBInserted(object sender, EventArrivedEventArgs e)
        {
            try
            {
                var instance = (ManagementBaseObject)e.NewEvent["TargetInstance"];
                var description = (string)instance.GetPropertyValue("Description");
                var deviceId = (string)instance.GetPropertyValue("DeviceID");
                Logger.WriteLineInfo($"Device Manager:UDisk Insert:{description},{deviceId}");
                var serialNum = deviceId.Substring(deviceId.LastIndexOf('\\')).Replace("\\", "");
                var letter = GetDriveLetter(serialNum);
                if (!string.IsNullOrEmpty(letter))
                {
                    UDiskInserted?.Invoke(this, letter);
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"Device Manager UDisk insert Error:{ex}");
            }
        }

        private void OnUSBRemoved(object sender, EventArrivedEventArgs e)
        {
            try
            {
                var instance = (ManagementBaseObject)e.NewEvent["TargetInstance"];
                var description = (string)instance.GetPropertyValue("Description");
                var deviceId = (string)instance.GetPropertyValue("DeviceID");
                Logger.WriteLineInfo($"Device Manager:USB Remove:{description},{deviceId}");
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"Device Manager USB Remove Error:{ex}");
            }
        }

        public override void DoDispose()
        {
            try
            {
                _cameraInfos.Clear();
                NetworkChange.NetworkAddressChanged -= OnNetworkAddressChanged;
                if (_wifiModuleInsertWatcher != null)
                {
                    _wifiModuleInsertWatcher.EventArrived -= OnWifiModuleInserted;
                    _wifiModuleInsertWatcher.Stop();
                    _wifiModuleInsertWatcher = null;
                }
                if (_wifiModuleRemoveWatcher != null)
                {
                    _wifiModuleRemoveWatcher.EventArrived -= OnWifiModuleInserted;
                    _wifiModuleRemoveWatcher.Stop();
                    _wifiModuleRemoveWatcher = null;
                }
                if (_usbInsertWatcher != null)
                {
                    _usbInsertWatcher.EventArrived -= OnUSBInserted;
                    _usbInsertWatcher.Stop();
                    _usbInsertWatcher = null;
                }
                if (_usbRemoveWatcher != null)
                {
                    _usbRemoveWatcher.EventArrived -= OnUSBRemoved;
                    _usbRemoveWatcher.Stop();
                    _usbRemoveWatcher = null;
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"DeviceManager DoDispose Error:{ex}");
            }
            base.DoDispose();
        }

        private string GetDriveLetter(string serialNum)
        {
            var devices = SelectDevices();

            foreach (var device in devices)
            {
                var deviceId = (string)device.GetPropertyValue("DeviceID");
                var pnpDeviceId = (string)device.GetPropertyValue("PNPDeviceID");
                var serialNumber = pnpDeviceId.Remove(pnpDeviceId.Length - 2).Substring(pnpDeviceId.LastIndexOf('\\')).Replace("\\", "");
                if (serialNumber.Contains(serialNumber))
                {
                    return (string)SelectPartitions(device).SelectMany(SelectDisks).Select(disk => disk["Name"]).Single();
                }
            }
            return string.Empty;
        }

        private IEnumerable<ManagementObject> SelectDevices()
        {
            return new ManagementObjectSearcher(@"SELECT * FROM Win32_DiskDrive WHERE InterfaceType LIKE 'USB%'").Get().Cast<ManagementObject>();
        }

        public IEnumerable<ManagementObject> SelectPartitions(ManagementObject device)
        {
            var deviceId = device.Properties["DeviceID"].Value;
            return new ManagementObjectSearcher("ASSOCIATORS OF {Win32_DiskDrive.DeviceID='" + deviceId + "'} WHERE AssocClass = Win32_DiskDriveToDiskPartition").Get().Cast<ManagementObject>();
        }

        public IEnumerable<ManagementObject> SelectDisks(ManagementObject partition)
        {
            var deviceId = partition["DeviceID"];
            return new ManagementObjectSearcher("ASSOCIATORS OF {Win32_DiskPartition.DeviceID='" + deviceId + "'} WHERE AssocClass = Win32_LogicalDiskToPartition").Get().Cast<ManagementObject>();
        }
    }
}