/// <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;
}));
}
