public IDevice GetDevice(ConnectedDeviceDefinition deviceDefinition)
{
return(deviceDefinition.DeviceType != DeviceType ? null : new WindowsUsbDevice(deviceDefinition.DeviceId)
{
Logger = Logger
});
}
public IDevice GetDevice(ConnectedDeviceDefinition deviceDefinition)
{
var usbDeviceFinder = new UsbDeviceFinder((int)deviceDefinition.VendorId.Value, (int)deviceDefinition.ProductId.Value);
var usbDevice = UsbDevice.OpenUsbDevice(usbDeviceFinder);
return(usbDevice != null ? new LibUsbDevice(usbDevice, 3000) : null);
}
public MockHidDevice(string deviceId, ILogger logger, ITracer tracer) : base(deviceId, logger, tracer)
{
ConnectedDeviceDefinition = new ConnectedDeviceDefinition(DeviceId)
{
ProductId = ProductId, VendorId = VendorId, DeviceType = DeviceType.Hid
};
}
private static ConnectedDeviceDefinition GetDeviceDefinition(SafeFileHandle defaultInterfaceHandle, string deviceId)
{
var deviceDefinition = new ConnectedDeviceDefinition(deviceId)
{
DeviceType = DeviceType.Usb
};
var bufferLength = (uint)Marshal.SizeOf(typeof(USB_DEVICE_DESCRIPTOR));
var isSuccess2 = WinUsbApiCalls.WinUsb_GetDescriptor(defaultInterfaceHandle, WinUsbApiCalls.DEFAULT_DESCRIPTOR_TYPE, 0, WinUsbApiCalls.EnglishLanguageID, out var _UsbDeviceDescriptor, bufferLength, out var lengthTransferred);
HandleError(isSuccess2, "Couldn't get device descriptor");
if (_UsbDeviceDescriptor.iProduct > 0)
{
deviceDefinition.ProductName = WinUsbApiCalls.GetDescriptor(defaultInterfaceHandle, _UsbDeviceDescriptor.iProduct, "Couldn't get product name");
}
if (_UsbDeviceDescriptor.iSerialNumber > 0)
{
deviceDefinition.SerialNumber = WinUsbApiCalls.GetDescriptor(defaultInterfaceHandle, _UsbDeviceDescriptor.iSerialNumber, "Couldn't get serial number");
}
if (_UsbDeviceDescriptor.iManufacturer > 0)
{
deviceDefinition.Manufacturer = WinUsbApiCalls.GetDescriptor(defaultInterfaceHandle, _UsbDeviceDescriptor.iManufacturer, "Couldn't get manufacturer");
}
deviceDefinition.VendorId = _UsbDeviceDescriptor.idVendor;
deviceDefinition.ProductId = _UsbDeviceDescriptor.idProduct;
deviceDefinition.WriteBufferSize = _UsbDeviceDescriptor.bMaxPacketSize0;
deviceDefinition.ReadBufferSize = _UsbDeviceDescriptor.bMaxPacketSize0;
return(deviceDefinition);
}
public IDevice GetDevice(ConnectedDeviceDefinition deviceDefinition)
{
return(deviceDefinition.DeviceType == DeviceType.Usb ? null : new UWPHidDevice(deviceDefinition.DeviceId)
{
Logger = Logger
});
}
public WindowsSerialPortDevice(string deviceId, IApiService apiService, int baudRate, StopBits stopBits, Parity parity, byte byteSize, ushort readBufferSize, ILogger logger, ITracer tracer) : base(deviceId, logger, tracer)
{
ApiService = apiService ?? throw new ArgumentNullException(nameof(apiService));
ConnectedDeviceDefinition = new ConnectedDeviceDefinition(DeviceId);
if ((byteSize == 5 && stopBits == StopBits.Two) || (stopBits == StopBits.OnePointFive && byteSize > 5))
{
throw new ArgumentException(Messages.ErrorInvalidByteSizeAndStopBitsCombo);
}
if (byteSize < 5 || byteSize > 8)
{
throw new ArgumentOutOfRangeException(nameof(byteSize), Messages.ErrorByteSizeMustBeFiveToEight);
}
if (baudRate < 110 || baudRate > 256000)
{
throw new ArgumentOutOfRangeException(nameof(baudRate), Messages.ErrorBaudRateInvalid);
}
if (stopBits == StopBits.None)
{
throw new ArgumentException(Messages.ErrorMessageStopBitsMustBeSpecified, nameof(stopBits));
}
_ReadBufferSize = readBufferSize;
_BaudRate = baudRate;
_ByteSize = byteSize;
_StopBits = stopBits;
_Parity = parity;
}
public IDevice GetDevice(ConnectedDeviceDefinition deviceDefinition)
{
if (deviceDefinition.DeviceType == DeviceType.Usb)
{
return(null);
}
return(new UWPHidDevice(deviceDefinition.DeviceId));
}
public MockHidDevice(ILogger logger, ITracer tracer) : base(logger, tracer)
{
DeviceId = MockedDeviceId;
ConnectedDeviceDefinition = new ConnectedDeviceDefinition(DeviceId)
{
ProductId = ProductId, VendorId = VendorId, DeviceType = DeviceType.Hid
};
}
public IDevice GetDevice(ConnectedDeviceDefinition deviceDefinition)
{
if (!int.TryParse(deviceDefinition.DeviceId, out var deviceId))
{
throw new Exception($"The device Id '{deviceDefinition.DeviceId}' is not a valid integer");
}
return(new UsbDevice(new AndroidUsbInterfaceManager(UsbManager, Context, deviceId, Logger, Tracer, ReadBufferSize, WriteBufferSize), Logger, Tracer));
}
public IDevice GetDevice(ConnectedDeviceDefinition deviceDefinition)
{
if (deviceDefinition == null)
{
throw new ArgumentNullException(nameof(deviceDefinition));
}
return(deviceDefinition.DeviceType != DeviceType ? null : new UsbDevice(deviceDefinition.DeviceId, new WindowsUsbInterfaceManager(deviceDefinition.DeviceId, Logger, Tracer, ReadBufferSize, WriteBufferSize), Logger, Tracer));
}
public IDevice GetDevice(ConnectedDeviceDefinition deviceDefinition)
{
if (deviceDefinition == null)
{
throw new ArgumentNullException(nameof(deviceDefinition));
}
return(deviceDefinition.DeviceType == DeviceType.Usb ? null : new UWPHidDevice(deviceDefinition.DeviceId, Logger, Tracer));
}
public IDevice GetDevice(ConnectedDeviceDefinition deviceDefinition)
{
if (deviceDefinition == null)
{
throw new ArgumentNullException(nameof(deviceDefinition));
}
return(new WindowsSerialPortDevice(deviceDefinition.DeviceId));
}
public IDevice GetDevice(ConnectedDeviceDefinition deviceDefinition)
{
if (deviceDefinition.DeviceType == DeviceType.Hid)
{
return(null);
}
return(new UWPUsbDevice(deviceDefinition)
{
Logger = Logger
});
}
public MockHidDevice()
{
DeviceId = MockedDeviceId;
ConnectedDeviceDefinition = new ConnectedDeviceDefinition(DeviceId)
{
ProductId = ProductId, VendorId = VendorId
};
Logger = new DebugLogger {
LogToConsole = true
};
}
public async Task InitializeUSBAsync(ConnectedDeviceDefinition deviceDefinition)
{
//Get the first available device and connect to it
USBDevice = DeviceManager.Current.GetDevice(deviceDefinition);
Console.WriteLine(USBDevice);
if (USBDevice == null)
{
throw new Exception("There were no devices found");
}
await USBDevice.InitializeAsync();
}
/// <summary>
/// Select a device from the IDevice list to use for connections.
/// </summary>
/// <param name="selectDevice">Device to select.</param>
protected void SelectDevice(ConnectedDeviceDefinition selectDevice)
{
if (selectDevice == null)
{
this.SelectedUSBDevice = null;
}
else
{
this.SelectedUSBDevice = DeviceManager.Current.GetDevice(selectDevice);
Task.Run(() => this.ContinousRead(), this.ContinousReadCancellationToken);
}
}
public override IDevice GetDevice(ConnectedDeviceDefinition deviceDefinition)
{
if (deviceDefinition != null)
{
if (deviceDefinition.DeviceId == DeviceId)
{
if (!deviceDefinition.DeviceType.HasValue || deviceDefinition.DeviceType == DeviceType.Usb)
{
return(new MockUsbDevice());
}
}
}
throw new Exception("Couldn't get a device");
}
public async Task <IEnumerable <ConnectedDeviceDefinition> > GetConnectedDeviceDefinitionsAsync(CancellationToken cancellationToken = default)
{
_logger.LogInformation("Filtering devices with AQS filter:\r\n{aqs}", aqsFilter);
var deviceInformationCollection = aqsFilter != null
? await wde.DeviceInformation.FindAllAsync(aqsFilter).AsTask(cancellationToken)
: await wde.DeviceInformation.FindAllAsync().AsTask(cancellationToken);
var deviceDefinitions = deviceInformationCollection
.Where(_deviceInformationFilter)
.Select(d => DeviceBase.GetDeviceDefinitionFromWindowsDeviceId(d.Id, _deviceType, _logger));
if (!deviceDefinitions.Any())
{
_logger.LogInformation("Found no devices");
}
var deviceDefinitionList = new List <ConnectedDeviceDefinition>();
foreach (var deviceDef in deviceDefinitions)
{
_logger.LogInformation("Testing connection for device Id {deviceId}", deviceDef.DeviceId);
var connectionInformation = await TestConnection(deviceDef.DeviceId, cancellationToken);
if (connectionInformation.CanConnect)
{
var connectedDeviceDefinition = new ConnectedDeviceDefinition(
deviceDef.DeviceId,
_deviceType,
usagePage: connectionInformation.UsagePage,
vendorId: deviceDef.VendorId,
productId: deviceDef.ProductId
);
deviceDefinitionList.Add(connectedDeviceDefinition);
_logger.LogInformation("Test connection succeeded for connected device {deviceId} {connectedDeviceDefinition}", deviceDef.DeviceId, connectedDeviceDefinition);
}
else
{
_logger.LogWarning("Connection test failed for {deviceId}", deviceDef.DeviceId);
}
}
return(new ReadOnlyCollection <ConnectedDeviceDefinition>(deviceDefinitionList));
}
public WindowsSerialPortDevice(
string deviceId,
int baudRate = 9600,
StopBits stopBits = StopBits.One,
Parity parity = Parity.None,
byte byteSize = 8,
ushort readBufferSize = 1024,
ILoggerFactory loggerFactory = null,
IApiService apiService = null) : base(
deviceId,
loggerFactory,
(loggerFactory ?? NullLoggerFactory.Instance).CreateLogger <WindowsSerialPortDevice>())
{
ApiService = apiService ?? new ApiService(null);
ConnectedDeviceDefinition = new ConnectedDeviceDefinition(DeviceId, DeviceType.SerialPort);
if ((byteSize == 5 && stopBits == StopBits.Two) || (stopBits == StopBits.OnePointFive && byteSize > 5))
{
throw new ArgumentException(Messages.ErrorInvalidByteSizeAndStopBitsCombo);
}
if (byteSize is < 5 or > 8)
{
throw new ArgumentOutOfRangeException(nameof(byteSize), Messages.ErrorByteSizeMustBeFiveToEight);
}
if (baudRate is < 110 or > 256000)
{
throw new ArgumentOutOfRangeException(nameof(baudRate), Messages.ErrorBaudRateInvalid);
}
if (stopBits == StopBits.None)
{
throw new ArgumentException(Messages.ErrorMessageStopBitsMustBeSpecified, nameof(stopBits));
}
ReadBufferSize = readBufferSize;
_BaudRate = baudRate;
_ByteSize = byteSize;
_StopBits = stopBits;
_Parity = parity;
}
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 static KnxInterfaceUsb CheckHid(ConnectedDeviceDefinition def)
{
var assembly = Assembly.GetExecutingAssembly();
string resourceName = assembly.GetManifestResourceNames().Single(str => str.EndsWith("knx_interfaces.xml"));
using (Stream stream = assembly.GetManifestResourceStream(resourceName))
using (StreamReader reader = new StreamReader(stream))
{
string result = reader.ReadToEnd();
XDocument doc = XDocument.Parse(result);
var inters = doc.Descendants(XName.Get("Interface"));
if (!inters.Any(inter => inter.Attribute("VendorID").Value == Convert.ToInt32(def.VendorId).ToString("X") && inter.Attribute("ProductID").Value == Convert.ToInt32(def.ProductId).ToString("X")))
{
return(null);
}
XElement xinter = inters.Single(inter => inter.Attribute("VendorID").Value == Convert.ToInt32(def.VendorId).ToString("X") && inter.Attribute("ProductID").Value == Convert.ToInt32(def.ProductId).ToString("X"));
IEnumerable <XElement> trans = xinter.Descendants(XName.Get("Translation"));
string name = xinter.Attribute("DefaultDisplayText").Value;
string current = System.Globalization.CultureInfo.CurrentCulture.Name;
if (trans.Any(t => t.Attribute("Language").Value == current))
{
XElement translation = trans.Single(t => t.Attribute("Language").Value == current);
name = translation.Attribute("Text").Value;
}
else if (trans.Any(t => t.Attribute("Language").Value.StartsWith(current.Substring(0, 3))))
{
XElement translation = trans.First(t => t.Attribute("Language").Value.StartsWith(current.Substring(0, 3)));
name = translation.Attribute("Text").Value;
}
return(new KnxInterfaceUsb()
{
Name = name,
ConnDefinition = def
});
}
}
public static UsbDevice GetDevice(ConnectedDeviceDefinition deviceDefinition)
{
if (deviceDefinition == null)
{
throw new ArgumentNullException(nameof(deviceDefinition));
}
#pragma warning disable CA2208
if (deviceDefinition.VendorId == null)
{
throw new ArgumentNullException(nameof(ConnectedDeviceDefinition.VendorId));
}
if (deviceDefinition.ProductId == null)
{
throw new ArgumentNullException(nameof(ConnectedDeviceDefinition.ProductId));
}
#pragma warning restore CA2208
var usbDeviceFinder = new UsbDeviceFinder((int)deviceDefinition.VendorId.Value, (int)deviceDefinition.ProductId.Value);
return(UsbDevice.OpenUsbDevice(usbDeviceFinder));
}
public IDevice GetDevice(ConnectedDeviceDefinition deviceDefinition)
{
if (deviceDefinition == null)
{
throw new ArgumentNullException(nameof(deviceDefinition));
}
if (deviceDefinition.VendorId == null)
{
throw new ArgumentNullException(nameof(ConnectedDeviceDefinition.VendorId));
}
if (deviceDefinition.ProductId == null)
{
throw new ArgumentNullException(nameof(ConnectedDeviceDefinition.ProductId));
}
var usbDeviceFinder = new UsbDeviceFinder((int)deviceDefinition.VendorId.Value, (int)deviceDefinition.ProductId.Value);
var usbDevice = UsbDevice.OpenUsbDevice(usbDeviceFinder);
return(usbDevice != null ? new LibUsbDevice(usbDevice, 3000, Logger, Tracer) : null);
}
public override IDevice GetDevice(ConnectedDeviceDefinition deviceDefinition)
{
if (deviceDefinition == null)
{
return(null);
}
if (deviceDefinition.DeviceId != DeviceId)
{
return(null);
}
if (deviceDefinition.DeviceType.HasValue && deviceDefinition.DeviceType != DeviceType.Hid)
{
return(null);
}
Logger?.Log(string.Format(FoundMessage, DeviceId), nameof(MockHidFactory), null, LogLevel.Information);
return(new MockHidDevice(Logger, Tracer));
}
public override IDevice GetDevice(ConnectedDeviceDefinition deviceDefinition)
{
if (deviceDefinition == null)
{
throw new Exception("Couldn't get a device");
}
if (deviceDefinition.DeviceId != DeviceId)
{
throw new Exception("Couldn't get a device");
}
if (deviceDefinition.DeviceType.HasValue && deviceDefinition.DeviceType != DeviceType.Usb)
{
throw new Exception("Couldn't get a device");
}
Logger?.Log(string.Format(FoundMessage, DeviceId), nameof(MockUsbFactory), null, LogLevel.Information);
return(new MockUsbDevice(DeviceId, Logger, Tracer));
}
private static async Task Run()
{
var logger = new DebugLogger();
var tracer = new DebugTracer();
DeviceManager.Current.DeviceFactories.Add(new CustomWindowsUsbDeviceFactory(WindowsDeviceConstants.GUID_DEVINTERFACE_USB_DEVICE, logger, tracer));
var devices = await DeviceManager.Current.GetConnectedDeviceDefinitionsAsync(null);
ConnectedDeviceDefinition garminDefinition = devices.SingleOrDefault(device => device.VendorId == 0x091E && device.ProductId == 0x0003);
if (garminDefinition == null)
{
Console.WriteLine("No connected Garmin device found");
return;
}
var usbInterfaceManager = new WindowsUsbInterfaceManager
(
garminDefinition.DeviceId,
logger,
tracer,
null,
null
);
var usbDevice = new UsbDevice(garminDefinition.DeviceId, usbInterfaceManager, logger, tracer);
await usbDevice.InitializeAsync();
var firstUsbInterface = usbDevice.UsbInterfaceManager.UsbInterfaces.First();
usbInterfaceManager.WriteUsbInterface = firstUsbInterface;
firstUsbInterface.WriteEndpoint = firstUsbInterface.UsbInterfaceEndpoints.First(e => e.IsWrite);
var writeBuffer = Unhexify("140000002f0400000100000000");
await usbDevice.WriteAsync(writeBuffer);
Console.WriteLine("Command sent");
}
public UwpHidDeviceHandler(
ConnectedDeviceDefinition connectedDeviceDefinition,
IDataReceiver dataReceiver,
ILoggerFactory loggerFactory = null,
ushort?writeBufferSize = null,
ushort?readBufferSize = null,
Func <TransferResult, Report> readTransferTransform = null,
Func <byte[], byte, byte[]> writeTransferTransform = null
) : base(connectedDeviceDefinition.DeviceId, dataReceiver, loggerFactory)
{
ConnectedDeviceDefinition = connectedDeviceDefinition ?? throw new ArgumentNullException(nameof(connectedDeviceDefinition));
_writeBufferSize = writeBufferSize;
_writeBufferSize = readBufferSize;
_readTransferTransform = readTransferTransform ?? new Func <TransferResult, Report>((tr) => tr.ToReadReport(Logger));
_writeTransferTransform = writeTransferTransform ??
new Func <byte[], byte, byte[]>(
//By default we put the Report Id back at index zero and shift the array 1 to the right
//In effect, we do exactly the same thing as windows
(data, reportId) => data.InsertReportIdAtIndexZero(reportId, Logger));
}
private static async Task Go()
{
ConnectedDeviceDefinition menuOption = await Menu();
try
{
await _DeviceConnectionExample.InitializeUSBAsync(menuOption);
Console.WriteLine("Waiting for DisplayDataAsync()...");
await DisplayDataAsync();
_DeviceConnectionExample.Dispose();
GC.Collect();
await Task.Delay(10000);
}
catch (Exception ex)
{
Console.Clear();
Console.WriteLine(ex.ToString());
}
Console.ReadKey();
}
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 SpaceMouse(ConnectedDeviceDefinition hidInfo)
{
_mouseInfo = hidInfo;
}
