/// <summary> /// Creates a <see cref="IDeviceFactory"/> for Windows Hid devices /// </summary> /// <param name="filterDeviceDefinition">Devices must match this</param> /// <param name="loggerFactory"><see href="https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.iloggerfactory"/></param> /// <param name="hidApiService">Abstraction for Hid interaction</param> /// <param name="classGuid">Filters by specified class guid</param> /// <param name="readBufferSize">Override the input report size</param> /// <param name="writeBufferSize">Override the output report size</param> /// <param name="writeReportTransform">Given the data supplied, allow you to divide the data in to a <see cref="Report"/></param> /// <param name="getConnectedDeviceDefinitionsAsync">Override the default call for getting definitions</param> /// <param name="readReportTransform">Allows you to manually convert the <see cref="Report"/> in to a <see cref="TransferResult"/> so that the Report Id is not discarded on ReadAsync. By default, this inserts the Report Id at index zero of the array.</param> /// <param name="readTransferTransform">Exposes the raw data from the device (including Report Id) on reads and allows you to format the returned <see cref="TransferResult"/></param> /// <param name="writeTransferTransform">Given the Report Id and data supplied for the write, allow you to format the raw data that is sent to the device</param> /// <returns>A factory which enumerates and instantiates devices</returns> public static IDeviceFactory CreateWindowsHidDeviceFactory( this FilterDeviceDefinition filterDeviceDefinition, ILoggerFactory loggerFactory = null, IHidApiService hidApiService = null, Guid?classGuid = null, ushort?readBufferSize = null, ushort?writeBufferSize = null, GetConnectedDeviceDefinitionsAsync getConnectedDeviceDefinitionsAsync = null, Func <Report, TransferResult> readReportTransform = null, Func <TransferResult, Report> readTransferTransform = null, Func <byte[], byte, byte[]> writeTransferTransform = null, WriteReportTransform writeReportTransform = null) { return(CreateWindowsHidDeviceFactory( new ReadOnlyCollection <FilterDeviceDefinition>(new List <FilterDeviceDefinition> { filterDeviceDefinition }), loggerFactory, hidApiService, classGuid, readBufferSize, writeBufferSize, getConnectedDeviceDefinitionsAsync, readReportTransform, readTransferTransform, writeTransferTransform, writeReportTransform)); }
public static IDeviceFactory CreateAndroidUsbDeviceFactory( this FilterDeviceDefinition filterDeviceDefinition, UsbManager usbManager, Context context, ILoggerFactory loggerFactory = null, GetConnectedDeviceDefinitionsAsync getConnectedDeviceDefinitionsAsync = null, GetUsbInterfaceManager getUsbInterfaceManager = null, ushort?readBufferSize = null, ushort?writeBufferSize = null, IAndroidFactory androidFactory = null, Func <AndroidUsbDevice, IUsbPermissionBroadcastReceiver> getUsbPermissionBroadcastReceiver = null ) => CreateAndroidUsbDeviceFactory( new ReadOnlyCollection <FilterDeviceDefinition>(new List <FilterDeviceDefinition> { filterDeviceDefinition }), usbManager, context, loggerFactory, getConnectedDeviceDefinitionsAsync, getUsbInterfaceManager, readBufferSize, writeBufferSize, androidFactory, getUsbPermissionBroadcastReceiver);
/// <summary> /// Creates a <see cref="IDeviceFactory"/> for UWP Hid devices /// </summary> /// <param name="filterDeviceDefinition">Devices must match this</param> /// <param name="loggerFactory"><see href="https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.iloggerfactory"/></param> /// <param name="classGuid">Filters by specified class guid</param> /// <param name="deviceInformationFilter"></param> /// <param name="dataReceiver"></param> /// <param name="readBufferSize">Override the input report size</param> /// <param name="readTransferTransform">Exposes the raw data from the device (including Report Id) on reads and allows you to format the returned <see cref="TransferResult"/></param> /// <param name="writeTransferTransform">Given the Report Id and data supplied for the write, allow you to format the raw data that is sent to the device</param> /// <param name="writeReportTransform">Given the data supplied, allow you to divide the data in to a <see cref="Report"/></param> /// <param name="writeBufferSize">Override the output report size</param> /// <param name="getConnectedDeviceDefinitionsAsync">Override the default call for getting definitions</param> /// <param name="getDevice"></param> /// <param name="readReportTransform">Allows you to manually convert the <see cref="Report"/> in to a <see cref="TransferResult"/> so that the Report Id is not discarded on ReadAsync. By default, this inserts the Report Id at index zero of the array.</param> /// <returns>A factory which enumerates and instantiates devices</returns> public static IDeviceFactory CreateUwpHidDeviceFactory( this FilterDeviceDefinition filterDeviceDefinition, ILoggerFactory loggerFactory = null, GetConnectedDeviceDefinitionsAsync getConnectedDeviceDefinitionsAsync = null, GetDeviceAsync getDevice = null, Guid?classGuid = null, Func <wde.DeviceInformation, bool> deviceInformationFilter = null, IDataReceiver dataReceiver = null, ushort?writeBufferSize = null, ushort?readBufferSize = null, Func <Report, TransferResult> readReportTransform = null, Func <TransferResult, Report> readTransferTransform = null, Func <byte[], byte, byte[]> writeTransferTransform = null, WriteReportTransform writeReportTransform = null) => CreateUwpHidDeviceFactory( new List <FilterDeviceDefinition> { filterDeviceDefinition }, loggerFactory, getConnectedDeviceDefinitionsAsync, getDevice, classGuid, deviceInformationFilter, dataReceiver, writeBufferSize, readBufferSize, readReportTransform, readTransferTransform, writeTransferTransform, writeReportTransform);
public static async Task InitializeAsync() { var hidFactory = new FilterDeviceDefinition( LogitechVid, LogitechPowerPlayPid, LogitechPowerPlayUsagePage, LogitechPowerPlaFriendlyName) .CreateWindowsHidDeviceFactory(); // The correct device var powerPlayDeviceDefinition = (await hidFactory.GetConnectedDeviceDefinitionsAsync().ConfigureAwait(false)).FirstOrDefault(d => d.Usage == LogitechPowerPlayPage); var powerPlayDevice = await hidFactory.GetDeviceAsync(powerPlayDeviceDefinition).ConfigureAwait(false); if (powerPlayDeviceDefinition == null || powerPlayDevice == null) { IsInitialized = false; return; } powerPlayDevice.InitializeAsync().Wait(); MouseController = new PowerPlayController(powerPlayDevice, 0x01, 0x07); MatController = new PowerPlayController(powerPlayDevice, 0x07, 0x0B); // We assume the mouse exists because there is no way of know if there is a paired device. IsInitialized = true; }
public static async Task <bool> OpenAsync() { var deviceDefinitions = new FilterDeviceDefinition(AbletonVendorID, Push2ProductId); var deviceFactory = WindowsUsbDeviceFactoryExtensions.CreateWindowsUsbDeviceFactory(deviceDefinitions); var deviceDefinition = deviceFactory.GetConnectedDeviceDefinitionsAsync().Result; if (deviceDefinition == null || deviceDefinition.Count() < 1) { return(false); } var PushDeviceId = deviceDefinition.First().DeviceId; //This is the only platform specific part. Each platform has a UsbInterfaceManager var usbInterfaceManager = new WindowsUsbInterfaceManager(PushDeviceId); usbDevice = new UsbDevice(PushDeviceId, usbInterfaceManager); try { await usbDevice.InitializeAsync(); } catch (Exception) { usbDevice = null; return(false); } KeepDisplayRefreshed(); return(true); }
public async Task TestFindSTMDFUModeWithFactory() { var deviceFactory = new FilterDeviceDefinition(StmDfuVendorId, StmDfuProductId) .CreateWindowsUsbDeviceFactory(classGuid: WindowsDeviceConstants.GUID_DEVINTERFACE_USB_DEVICE); var devices = await deviceFactory.GetConnectedDeviceDefinitionsAsync(); Assert.IsTrue(devices.Any()); }
public static IDeviceFactory GetHidDeviceFactory( this FilterDeviceDefinition filterDeviceDefinition, ILoggerFactory loggerFactory, Func <Report, TransferResult> readReportTransform = null, WriteReportTransform writeReportTransform = null) => filterDeviceDefinition.CreateUwpHidDeviceFactory( loggerFactory, readReportTransform: readReportTransform, writeReportTransform: writeReportTransform);
internal static async Task <Scxi> Create(AppConfig config) { var hidFactory = new FilterDeviceDefinition(vendorId: 10462, productId: 4418, label: "Steam Controller") .CreateWindowsHidDeviceFactory(); var deviceDefinitions = await hidFactory.GetConnectedDeviceDefinitionsAsync(); var device = await hidFactory.GetDeviceAsync(deviceDefinitions.Single(d => d.DeviceId.Contains("mi_01"))); await device.InitializeAsync(); return(new Scxi((IHidDevice)device, XboxControllerAdapter.Create(), config)); }
public async Task FindUsbDevice() { var deviceFactory = new FilterDeviceDefinition(VENDOR_ID, PRODUCT_ID) .CreateWindowsUsbDeviceFactory(classGuid: WindowsDeviceConstants.GUID_DEVINTERFACE_USB_DEVICE); var devices = await deviceFactory.GetConnectedDeviceDefinitionsAsync(); //Get the first available device var deviceDefinition = devices.FirstOrDefault(); const string deviceID = @"\\?\usb#vid_0483&pid_5716#338a39613338#{a5dcbf10-6530-11d2-901f-00c04fb951ed}"; var windowsUsbDevice = new UsbDevice(deviceID, new WindowsUsbInterfaceManager(deviceID)); await windowsUsbDevice.InitializeAsync(); Console.WriteLine("test"); }
public async Task TestCreateWindowsHidDeviceFactory() { var result = new List <ConnectedDeviceDefinition> { new ConnectedDeviceDefinition("123", DeviceType.Hid) }; var deviceFactory = new FilterDeviceDefinition().CreateWindowsHidDeviceFactory( getConnectedDeviceDefinitionsAsync: (c) => { return(Task.FromResult <IEnumerable <ConnectedDeviceDefinition> >(result)); }); var deviceDefinitions = await deviceFactory.GetConnectedDeviceDefinitionsAsync(); Assert.AreEqual(deviceDefinitions.Count(), deviceDefinitions.Count()); Assert.AreEqual(deviceDefinitions.First().DeviceId, deviceDefinitions.First().DeviceId); }
public static IDeviceFactory CreateUwpUsbDeviceFactory( this FilterDeviceDefinition filterDeviceDefinitions, ILoggerFactory loggerFactory = null, GetConnectedDeviceDefinitionsAsync getConnectedDeviceDefinitionsAsync = null, GetUsbInterfaceManager getUsbInterfaceManager = null, ushort?readBufferSize = null, ushort?writeBufferSize = null ) => CreateUwpUsbDeviceFactory( new List <FilterDeviceDefinition> { filterDeviceDefinitions }, loggerFactory, getConnectedDeviceDefinitionsAsync, getUsbInterfaceManager, readBufferSize, writeBufferSize);
public static IDeviceFactory CreateLibUsbDeviceFactory( this FilterDeviceDefinition filterDeviceDefinition, ILoggerFactory loggerFactory = null, int?timeout = null, ushort?writeBufferSize = null, ushort?readBufferSize = null, Func <ConnectedDeviceDefinition, CancellationToken, Task <bool> > supportsDevice = null ) => CreateLibUsbDeviceFactory ( new ReadOnlyCollection <FilterDeviceDefinition>(new List <FilterDeviceDefinition> { filterDeviceDefinition }), loggerFactory, timeout, writeBufferSize, readBufferSize, supportsDevice );
public async Task TestWriteAndReadFromNanoHid() { //Send the request part of the Message Contract var request = new byte[NanoBufferSize]; request[0] = 63; request[1] = 62; request[2] = 1; request[3] = 1; request[4] = 1; var filterDeviceDefinition = new FilterDeviceDefinition(productId: 4112, vendorId: 10741); var integrationTester = new IntegrationTester(filterDeviceDefinition.GetHidDeviceFactory(loggerFactory)); await integrationTester.TestAsync(request, (result, device) => { Assert.AreEqual(NanoBufferSize, result.Data.Length); Assert.AreEqual(63, result.Data[0]); Assert.AreEqual(62, result.Data[1]); var windowsHidDevice = (HidDevice)device; #if WINDOWS_UWP #else //TODO: share this with UWP Assert.AreEqual(DeviceType.Hid, device.ConnectedDeviceDefinition.DeviceType); Assert.AreEqual("AirNetix", device.ConnectedDeviceDefinition.Manufacturer); Assert.AreEqual(filterDeviceDefinition.ProductId, device.ConnectedDeviceDefinition.ProductId); Assert.AreEqual(filterDeviceDefinition.VendorId, device.ConnectedDeviceDefinition.VendorId); Assert.AreEqual("STS-170", device.ConnectedDeviceDefinition.ProductName); Assert.AreEqual(NanoBufferSize, device.ConnectedDeviceDefinition.ReadBufferSize); Assert.AreEqual(NanoBufferSize, device.ConnectedDeviceDefinition.WriteBufferSize); Assert.AreEqual("000000000001", device.ConnectedDeviceDefinition.SerialNumber); Assert.AreEqual((ushort)1, device.ConnectedDeviceDefinition.Usage); Assert.AreEqual((ushort)65280, device.ConnectedDeviceDefinition.UsagePage); Assert.AreEqual((ushort)256, device.ConnectedDeviceDefinition.VersionNumber); Assert.AreEqual(NanoBufferSize, windowsHidDevice.ReadBufferSize); Assert.AreEqual(NanoBufferSize, windowsHidDevice.WriteBufferSize); #endif return(Task.FromResult(true)); }, NanoBufferSize); }
public override async Task LoadDevicesAsync() { var legacyHid = new FilterDeviceDefinition(vendorId: LOGITECH_VENDOR_ID, usagePage: 0xFF00) .CreateWindowsHidDeviceFactory(); var modernHid = new FilterDeviceDefinition(vendorId: LOGITECH_VENDOR_ID, usagePage: 0xFF43) .CreateWindowsHidDeviceFactory(); var factories = legacyHid.Aggregate(modernHid); var deviceDefinitions = (await factories.GetConnectedDeviceDefinitionsAsync().ConfigureAwait(false)).ToList(); _LogiDevices.Clear(); _deviceListener?.Dispose(); _deviceListener = new DeviceListener(factories, 1000, null); _deviceListener.DeviceInitialized += _deviceListener_DeviceInitialized; _deviceListener.DeviceDisconnected += _deviceListener_DeviceDisconnected; _deviceListener.Start(); }
//[TestMethod] //public async Task TestSTMDFUModePerformControlTransferSend_DefaultGuid_WinUSBGuid() //{ // var stmDfuDevice = (IusbDevice)await GetAndroidDeviceFactory(new FilterDeviceDefinition(0x0483, 0xdf11)).ConnectFirstAsync(); // await IntegrationTests.PerformStmDfTest(stmDfuDevice); //} #endregion #region Private Methods //TODO: there is duplicate code here private IDeviceFactory GetAndroidDeviceFactory(FilterDeviceDefinition filterDeviceDefinition, ushort?writeBufferSize = null) { return(filterDeviceDefinition.CreateAndroidUsbDeviceFactory(usbManagerMock.Object, contextMock.Object, loggerFactory, androidFactory: androidFactoryMock.Object, getUsbPermissionBroadcastReceiver: (ud) => { //Why do we have to do this? //We return the receiver but... var usbPermissionBroadcastReceiver = new UsbPermissionBroadcastReceiver(usbManagerMock.Object, ud, contextMock.Object, androidFactoryMock.Object); //We run this and send a receive until the received event fires #pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed _ = FakeReceiveAsync(usbPermissionBroadcastReceiver); #pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed return usbPermissionBroadcastReceiver; }, //TODO: We shouldn't have to specify this. We should pick this up automatically. This is basically a bug on Android writeBufferSize: writeBufferSize)); ///Keeps running until the received event fires which allows code elsewhere to continue async Task FakeReceiveAsync(UsbPermissionBroadcastReceiver usbPermissionBroadcastReceiver) { var received = false; usbPermissionBroadcastReceiver.Received += (s, e) => { received = true; }; while (!received) { await Task.Delay(10); usbPermissionBroadcastReceiver.OnReceive(contextMock.Object, intentMock.Object); } } }
public async Task TestWriteAndReadFromTemperHid() { //Send the request part of the Message Contract var request = new byte[9] { 0x00, 0x01, 0x80, 0x33, 0x01, 0x00, 0x00, 0x00, 0x00 }; var filterDeviceDefinition = new FilterDeviceDefinition(vendorId: 0x413d, productId: 0x2107, usagePage: 65280); var integrationTester = new IntegrationTester( #if WINDOWS_UWP filterDeviceDefinition.CreateUwpHidDeviceFactory(loggerFactory)); #else filterDeviceDefinition.GetHidDeviceFactory(loggerFactory)); #endif await integrationTester.TestAsync(request, (result, device) => { Assert.IsTrue(device.IsInitialized); var temperatureTimesOneHundred = (result.Data[4] & 0xFF) + (result.Data[3] << 8); var temp = Math.Round(temperatureTimesOneHundred / 100.0m, 2, MidpointRounding.ToEven); //I think my room should pretty much always be between these temperatures Assert.IsTrue(temp is > 10 and < 35); var windowsHidDevice = (HidDevice)device; #if WINDOWS_UWP #else //TODO: Share these with UWP Assert.AreEqual(TemperBufferSize, device.ConnectedDeviceDefinition.ReadBufferSize); Assert.AreEqual(TemperBufferSize, device.ConnectedDeviceDefinition.WriteBufferSize); Assert.AreEqual(TemperBufferSize, windowsHidDevice.ReadBufferSize); Assert.AreEqual(TemperBufferSize, windowsHidDevice.WriteBufferSize); #endif return(Task.FromResult(true)); }, TemperBufferSize); }
public Task <IEnumerable <ConnectedDeviceDefinition> > GetConnectedDeviceDefinitionsAsync(FilterDeviceDefinition deviceDefinition) { return(Task.Run <IEnumerable <ConnectedDeviceDefinition> >(() => { //TODO: Get more details about the device. if (deviceDefinition.VendorId.HasValue && deviceDefinition.ProductId.HasValue) { return UsbManager.DeviceList.Select(kvp => kvp.Value).Where(d => deviceDefinition.VendorId == d.VendorId && deviceDefinition.ProductId == d.ProductId).Select(GetAndroidDeviceDefinition).ToList(); } else if (deviceDefinition.VendorId.HasValue) { return UsbManager.DeviceList.Select(kvp => kvp.Value).Where(d => deviceDefinition.VendorId == d.VendorId).Select(GetAndroidDeviceDefinition).ToList(); } else { return UsbManager.DeviceList.Select(kvp => kvp.Value).Select(GetAndroidDeviceDefinition).ToList(); } })); }
public static IDeviceFactory GetUsbDeviceFactory( this FilterDeviceDefinition filterDeviceDefinition, #pragma warning disable IDE0060 // Remove unused parameter ILoggerFactory loggerFactory, object classGuid = null) #pragma warning restore IDE0060 // Remove unused parameter => filterDeviceDefinition.CreateUwpUsbDeviceFactory(loggerFactory);
public Task <IEnumerable <ConnectedDeviceDefinition> > GetConnectedDeviceDefinitionsAsync(FilterDeviceDefinition deviceDefinition) { var connectedDeviceDefinitions = DeviceIds.Select(d => new ConnectedDeviceDefinition(d) { DeviceType = DeviceType.Hid, VendorId = 0x2581, ProductId = 0x3b7c, UsagePage = 0xffa0 }); return(Task.FromResult(connectedDeviceDefinitions)); }
public async Task <IEnumerable <ConnectedDeviceDefinition> > GetConnectedDeviceDefinitionsAsync(FilterDeviceDefinition deviceDefinition) { var aqsFilter = GetAqsFilter(deviceDefinition.VendorId, deviceDefinition.ProductId); var deviceInformationCollection = await wde.DeviceInformation.FindAllAsync(aqsFilter).AsTask(); var deviceDefinitions = deviceInformationCollection.Select(d => GetDeviceInformation(d, DeviceType)); var deviceDefinitionList = new List <ConnectedDeviceDefinition>(); foreach (var deviceDef in deviceDefinitions) { var connectionInformation = await TestConnection(deviceDef.DeviceId); if (connectionInformation.CanConnect) { deviceDef.UsagePage = connectionInformation.UsagePage; deviceDefinitionList.Add(deviceDef); } } return(deviceDefinitionList); }
public Task <IEnumerable <ConnectedDeviceDefinition> > GetConnectedDeviceDefinitionsAsync(FilterDeviceDefinition deviceDefinition) { var result = new List <ConnectedDeviceDefinition>(); var mockConnectedDeviceDefinition = new ConnectedDeviceDefinition(DeviceId) { ProductId = ProductId, VendorId = VendorId }; if (IsConnected) { if (DeviceManager.IsDefinitionMatch(deviceDefinition, mockConnectedDeviceDefinition)) { result.Add(mockConnectedDeviceDefinition); } } return(Task.FromResult <IEnumerable <ConnectedDeviceDefinition> >(result)); }
public async Task Run(Target target) { Devices = new List <Device> { }; var logger = Logger.Instance(); if (target == Target.stm32) { var deviceFactory = new FilterDeviceDefinition(0x0483, 0xDF11) // STM32 Bootloader .CreateWindowsUsbDeviceFactory(classGuid: WindowsDeviceConstants.GUID_DEVINTERFACE_USB_DEVICE); var devices = await deviceFactory.GetConnectedDeviceDefinitionsAsync(); var device = devices.FirstOrDefault(); if (device != null) { Devices.Add(new Device(device)); } } if (target == Target.teensy) { var deviceFactory = new FilterDeviceDefinition(0x16C0, 0x0478) // Teensy Bootloader .CreateWindowsHidDeviceFactory(classGuid: WindowsDeviceConstants.GUID_DEVINTERFACE_HID); var devices = await deviceFactory.GetConnectedDeviceDefinitionsAsync(); var device = devices.FirstOrDefault(); if (device != null) { Devices.Add(new Device(device)); } } if (target == Target.all) { var hidGuid = WindowsDeviceConstants.GUID_DEVINTERFACE_HID; var usbGuid = WindowsDeviceConstants.GUID_DEVINTERFACE_USB_DEVICE; var deviceFactories = new List <IDeviceFactory> { new FilterDeviceDefinition(0x16C0, 0x0478) // Teensy Bootloader .CreateWindowsHidDeviceFactory(classGuid: hidGuid), new FilterDeviceDefinition(0x0483, 0xDF11) // STM32 Bootloader .CreateWindowsUsbDeviceFactory(classGuid: usbGuid), new FilterDeviceDefinition(0xFEED, 0x1307) // Legacy Ids Ergodox EZ .CreateWindowsHidDeviceFactory(classGuid: hidGuid), new FilterDeviceDefinition(0xFEED, 0x6060) // Legacy Ids Planck EZ .CreateWindowsHidDeviceFactory(classGuid: hidGuid), new FilterDeviceDefinition(0x3297, 0x1969) // Moonlander MK1 .CreateWindowsHidDeviceFactory(classGuid: hidGuid), new FilterDeviceDefinition(0x3297, 0x4974) // Ergodox EZ Standard .CreateWindowsHidDeviceFactory(classGuid: hidGuid), new FilterDeviceDefinition(0x3297, 0x4975) // Ergodox EZ Shine .CreateWindowsHidDeviceFactory(classGuid: hidGuid), new FilterDeviceDefinition(0x3297, 0x4976) // Ergodox EZ Glow .CreateWindowsHidDeviceFactory(classGuid: hidGuid), new FilterDeviceDefinition(0x3297, 0xC6CE) // Planck EZ Standard .CreateWindowsHidDeviceFactory(classGuid: hidGuid), new FilterDeviceDefinition(0x3297, 0xC6CF) // Planck EZ Glow .CreateWindowsHidDeviceFactory(classGuid: hidGuid), }; var deviceManager = new DeviceManager(deviceFactories, null); var devices = await deviceManager.GetConnectedDeviceDefinitionsAsync(); // The device manager returns an entry for each endpoints // as a result duplicates are removed by checking against // the pid / vid of previously enumerated devices. foreach (var device in devices) { var match = Devices.FindIndex((_dev) => _dev.Info.VendorId == device.VendorId && _dev.Info.ProductId == device.ProductId); if (match == -1) { Devices.Add(new Device(device)); } } } }
public async Task <IEnumerable <ConnectedDeviceDefinition> > GetConnectedDeviceDefinitionsAsync(FilterDeviceDefinition deviceDefinition) { return(await Task.Run <IEnumerable <ConnectedDeviceDefinition> >(() => { var deviceDefinitions = new Collection <ConnectedDeviceDefinition>(); var spDeviceInterfaceData = new SpDeviceInterfaceData(); var spDeviceInfoData = new SpDeviceInfoData(); var spDeviceInterfaceDetailData = new SpDeviceInterfaceDetailData(); spDeviceInterfaceData.CbSize = (uint)Marshal.SizeOf(spDeviceInterfaceData); spDeviceInfoData.CbSize = (uint)Marshal.SizeOf(spDeviceInfoData); var guidString = ClassGuid.ToString(); var copyOfClassGuid = new Guid(guidString); var devicesHandle = APICalls.SetupDiGetClassDevs(ref copyOfClassGuid, IntPtr.Zero, IntPtr.Zero, APICalls.DigcfDeviceinterface | APICalls.DigcfPresent); if (IntPtr.Size == 8) { spDeviceInterfaceDetailData.CbSize = 8; } else { spDeviceInterfaceDetailData.CbSize = 4 + Marshal.SystemDefaultCharSize; } var i = -1; var productIdHex = GetHex(deviceDefinition.ProductId); var vendorHex = GetHex(deviceDefinition.VendorId); while (true) { i++; var isSuccess = APICalls.SetupDiEnumDeviceInterfaces(devicesHandle, IntPtr.Zero, ref copyOfClassGuid, (uint)i, ref spDeviceInterfaceData); if (!isSuccess) { var errorCode = Marshal.GetLastWin32Error(); if (errorCode == APICalls.ERROR_NO_MORE_ITEMS) { break; } throw new Exception($"Could not enumerate devices. Error code: {errorCode}"); } isSuccess = APICalls.SetupDiGetDeviceInterfaceDetail(devicesHandle, ref spDeviceInterfaceData, ref spDeviceInterfaceDetailData, 256, out _, ref spDeviceInfoData); WindowsDeviceBase.HandleError(isSuccess, "Could not get device interface detail"); //Note this is a bit nasty but we can filter Vid and Pid this way I think... if (deviceDefinition.VendorId.HasValue && !spDeviceInterfaceDetailData.DevicePath.ToLower().Contains(vendorHex)) { continue; } if (deviceDefinition.ProductId.HasValue && !spDeviceInterfaceDetailData.DevicePath.ToLower().Contains(productIdHex)) { continue; } var connectedDeviceDefinition = GetDeviceDefinition(spDeviceInterfaceDetailData.DevicePath); if (connectedDeviceDefinition == null) { continue; } if (!DeviceManager.IsDefinitionMatch(deviceDefinition, connectedDeviceDefinition)) { continue; } deviceDefinitions.Add(connectedDeviceDefinition); } APICalls.SetupDiDestroyDeviceInfoList(devicesHandle); return deviceDefinitions; })); }
public async Task <IEnumerable <ConnectedDeviceDefinition> > GetConnectedDeviceDefinitionsAsync(FilterDeviceDefinition deviceDefinition) { return(await Task.Run(() => { IEnumerable <UsbRegistry> devices = UsbDevice.AllDevices; if (deviceDefinition == null) { return devices.Select(usbRegistry => new ConnectedDeviceDefinition(usbRegistry.DevicePath) { VendorId = (uint)usbRegistry.Vid, ProductId = (uint)usbRegistry.Pid, DeviceType = DeviceType }).ToList(); } if (deviceDefinition.VendorId.HasValue) { devices = devices.Where(d => d.Vid == deviceDefinition.VendorId.Value); } if (deviceDefinition.ProductId.HasValue) { devices = devices.Where(d => d.Pid == deviceDefinition.ProductId.Value); } return devices.Select(usbRegistry => new ConnectedDeviceDefinition(usbRegistry.DevicePath) { VendorId = (uint)usbRegistry.Vid, ProductId = (uint)usbRegistry.Pid, DeviceType = DeviceType }).ToList(); })); }
public async Task <IEnumerable <ConnectedDeviceDefinition> > GetConnectedDeviceDefinitionsAsync(FilterDeviceDefinition filterDeviceDefinition) { return(await Task.Run <IEnumerable <ConnectedDeviceDefinition> >(() => { var deviceDefinitions = new Collection <ConnectedDeviceDefinition>(); var spDeviceInterfaceData = new SpDeviceInterfaceData(); var spDeviceInfoData = new SpDeviceInfoData(); var spDeviceInterfaceDetailData = new SpDeviceInterfaceDetailData(); spDeviceInterfaceData.CbSize = (uint)Marshal.SizeOf(spDeviceInterfaceData); spDeviceInfoData.CbSize = (uint)Marshal.SizeOf(spDeviceInfoData); string productIdHex = null; string vendorHex = null; var guidString = GetClassGuid().ToString(); var copyOfClassGuid = new Guid(guidString); const int flags = APICalls.DigcfDeviceinterface | APICalls.DigcfPresent; Log($"About to call {nameof(APICalls.SetupDiGetClassDevs)} for class Guid {guidString}. Flags: {flags}", null, LogLevel.Information); var devicesHandle = APICalls.SetupDiGetClassDevs(ref copyOfClassGuid, IntPtr.Zero, IntPtr.Zero, flags); spDeviceInterfaceDetailData.CbSize = IntPtr.Size == 8 ? 8 : 4 + Marshal.SystemDefaultCharSize; var i = -1; if (filterDeviceDefinition != null) { if (filterDeviceDefinition.ProductId.HasValue) { productIdHex = Helpers.GetHex(filterDeviceDefinition.ProductId); } if (filterDeviceDefinition.VendorId.HasValue) { vendorHex = Helpers.GetHex(filterDeviceDefinition.VendorId); } } while (true) { try { i++; var isSuccess = APICalls.SetupDiEnumDeviceInterfaces(devicesHandle, IntPtr.Zero, ref copyOfClassGuid, (uint)i, ref spDeviceInterfaceData); if (!isSuccess) { var errorCode = Marshal.GetLastWin32Error(); if (errorCode == APICalls.ERROR_NO_MORE_ITEMS) { Log($"The call to {nameof(APICalls.SetupDiEnumDeviceInterfaces)} returned ERROR_NO_MORE_ITEMS", null, LogLevel.Information); break; } if (errorCode > 0) { Log($"{nameof(APICalls.SetupDiEnumDeviceInterfaces)} called successfully but a device was skipped while enumerating because something went wrong. The device was at index {i}. The error code was {errorCode}.", null, LogLevel.Warning); } } isSuccess = APICalls.SetupDiGetDeviceInterfaceDetail(devicesHandle, ref spDeviceInterfaceData, ref spDeviceInterfaceDetailData, 256, out _, ref spDeviceInfoData); if (!isSuccess) { var errorCode = Marshal.GetLastWin32Error(); if (errorCode == APICalls.ERROR_NO_MORE_ITEMS) { Log($"The call to {nameof(APICalls.SetupDiEnumDeviceInterfaces)} returned ERROR_NO_MORE_ITEMS", null, LogLevel.Information); //TODO: This probably can't happen but leaving this here because there was some strange behaviour break; } if (errorCode > 0) { Log($"{nameof(APICalls.SetupDiGetDeviceInterfaceDetail)} called successfully but a device was skipped while enumerating because something went wrong. The device was at index {i}. The error code was {errorCode}.", null, LogLevel.Warning); } } //Note this is a bit nasty but we can filter Vid and Pid this way I think... if (filterDeviceDefinition != null) { if (filterDeviceDefinition.VendorId.HasValue && !spDeviceInterfaceDetailData.DevicePath.ContainsIgnoreCase(vendorHex)) { continue; } if (filterDeviceDefinition.ProductId.HasValue && !spDeviceInterfaceDetailData.DevicePath.ContainsIgnoreCase(productIdHex)) { continue; } } var connectedDeviceDefinition = GetDeviceDefinition(spDeviceInterfaceDetailData.DevicePath); if (connectedDeviceDefinition == null) { Logger.Log($"Device with path {spDeviceInterfaceDetailData.DevicePath} was skipped. See previous logs.", GetType().Name, null, LogLevel.Warning); continue; } if (!DeviceManager.IsDefinitionMatch(filterDeviceDefinition, connectedDeviceDefinition)) { continue; } deviceDefinitions.Add(connectedDeviceDefinition); } catch (Exception ex) { Log(ex); } } APICalls.SetupDiDestroyDeviceInfoList(devicesHandle); return deviceDefinitions; })); }
public async Task <IEnumerable <ConnectedDeviceDefinition> > GetConnectedDeviceDefinitionsAsync(FilterDeviceDefinition deviceDefinition) { return(await Task.Run(() => { IEnumerable <UsbRegistry> devices = null; if (deviceDefinition.VendorId.HasValue) { if (deviceDefinition.ProductId.HasValue) { devices = UsbDevice.AllDevices.Where((d) => { return d.Vid == deviceDefinition.VendorId.Value && d.Pid == deviceDefinition.ProductId.Value; }); } else { devices = UsbDevice.AllDevices.Where(d => d.Vid == deviceDefinition.VendorId.Value); } } var retVal = new List <ConnectedDeviceDefinition>(); foreach (var usbRegistry in devices) { const string classPropertyName = "Class"; //var usbDeviceClass = DeviceType == DeviceType.Usb ? "USBDevice" : null; //if (!usbRegistry.DeviceProperties.ContainsKey(classPropertyName) || (string)usbRegistry.DeviceProperties[classPropertyName] != usbDeviceClass) //{ // continue; //} retVal.Add(new ConnectedDeviceDefinition(usbRegistry.DevicePath) { VendorId = (uint)usbRegistry.Vid, ProductId = (uint)usbRegistry.Pid, DeviceType = DeviceType }); } return retVal; })); }
public static IDeviceFactory GetUsbDeviceFactory( this FilterDeviceDefinition filterDeviceDefinition, ILoggerFactory loggerFactory, Guid?classGuid = null) => filterDeviceDefinition.CreateWindowsUsbDeviceFactory(loggerFactory, classGuid: classGuid);
public Task <IEnumerable <ConnectedDeviceDefinition> > GetConnectedDeviceDefinitionsAsync(FilterDeviceDefinition deviceDefinition) { var result = new List <ConnectedDeviceDefinition>(); var mockConnectedDeviceDefinition = new ConnectedDeviceDefinition(DeviceId) { ProductId = ProductId, VendorId = VendorId, DeviceType = this is MockHidFactory ? DeviceType.Hid : DeviceType.Usb }; if (!IsConnected) { return(Task.FromResult <IEnumerable <ConnectedDeviceDefinition> >(result)); } if (DeviceManager.IsDefinitionMatch(deviceDefinition, mockConnectedDeviceDefinition)) { result.Add(mockConnectedDeviceDefinition); } return(Task.FromResult <IEnumerable <ConnectedDeviceDefinition> >(result)); }
public async Task <IEnumerable <ConnectedDeviceDefinition> > GetConnectedDeviceDefinitionsAsync(FilterDeviceDefinition deviceDefinition) { #if NETSTANDARD if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) { throw new ValidationException(Messages.ErrorMessageOperationNotSupportedOnPlatform); } #endif var returnValue = new List <ConnectedDeviceDefinition>(); //TODO: Logging var registryAvailable = false; try { using (var key = Registry.LocalMachine.OpenSubKey(@"HARDWARE\DEVICEMAP\SERIALCOMM")) { if (key != null) { registryAvailable = true; //We can look at the registry var valueNames = key.GetValueNames(); foreach (var valueName in valueNames) { var comPortName = key.GetValue(valueName); returnValue.Add(new ConnectedDeviceDefinition($@"\\.\{comPortName}") { Label = valueName }); } } } } catch { //TODO: Logging } if (!registryAvailable) { //We can't look at the registry so try connecting to the devices for (var i = 0; i < 9; i++) { var portName = $@"\\.\COM{i}"; using (var serialPortDevice = new WindowsSerialPortDevice(portName)) { await serialPortDevice.InitializeAsync(); if (serialPortDevice.IsInitialized) { returnValue.Add(new ConnectedDeviceDefinition(portName)); } } } } return(returnValue); }
public async Task <IEnumerable <ConnectedDeviceDefinition> > GetConnectedDeviceDefinitionsAsync(FilterDeviceDefinition deviceDefinition) { return(await Task.Run(() => { IEnumerable <UsbRegistry> devices = UsbDevice.AllDevices; if (deviceDefinition != null) { if (deviceDefinition.VendorId.HasValue) { devices = devices.Where(d => d.Vid == deviceDefinition.VendorId.Value); } if (deviceDefinition.VendorId.HasValue) { devices = devices.Where(d => d.Pid == deviceDefinition.ProductId.Value); } } var retVal = new List <ConnectedDeviceDefinition>(); foreach (var usbRegistry in devices) { retVal.Add(new ConnectedDeviceDefinition(usbRegistry.DevicePath) { VendorId = (uint)usbRegistry.Vid, ProductId = (uint)usbRegistry.Pid, DeviceType = DeviceType }); } return retVal; })); }