public UwpUsbInterface(
windowsUsbInterface usbInterface,
PerformControlTransferAsync performControlTransferAsync,
IDataReceiver dataReceiver,
ILoggerFactory loggerFactory,
ushort?readBuffersize = null,
ushort?writeBufferSize = null) : base(
performControlTransferAsync,
loggerFactory.CreateLogger <UwpUsbInterface>(),
readBuffersize,
writeBufferSize)
{
UsbInterface = usbInterface ?? throw new ArgumentNullException(nameof(usbInterface));
foreach (var inPipe in usbInterface.InterruptInPipes)
{
var uwpUsbInterfaceEndpoint = new UwpUsbInterfaceInterruptReadEndpoint(
inPipe,
dataReceiver,
loggerFactory.CreateLogger <UwpUsbInterfaceInterruptReadEndpoint>());
UsbInterfaceEndpoints.Add(uwpUsbInterfaceEndpoint);
InterruptReadEndpoint ??= uwpUsbInterfaceEndpoint;
}
foreach (var outPipe in usbInterface.InterruptOutPipes)
{
var uwpUsbInterfaceEndpoint =
new UwpUsbInterfaceEndpoint <UsbInterruptOutPipe>(
outPipe,
loggerFactory.CreateLogger <UwpUsbInterfaceEndpoint <UsbInterruptOutPipe> >());
UsbInterfaceEndpoints.Add(uwpUsbInterfaceEndpoint);
InterruptWriteEndpoint ??= uwpUsbInterfaceEndpoint;
}
foreach (var inPipe in usbInterface.BulkInPipes)
{
var uwpUsbInterfaceEndpoint = new UwpUsbInterfaceEndpoint <UsbBulkInPipe>(inPipe,
loggerFactory.CreateLogger <UwpUsbInterfaceEndpoint <UsbBulkInPipe> >());
UsbInterfaceEndpoints.Add(uwpUsbInterfaceEndpoint);
ReadEndpoint ??= uwpUsbInterfaceEndpoint;
}
foreach (var outPipe in usbInterface.BulkOutPipes)
{
var uwpUsbInterfaceEndpoint = new UwpUsbInterfaceEndpoint <UsbBulkOutPipe>(outPipe,
loggerFactory.CreateLogger <UwpUsbInterfaceEndpoint <UsbBulkOutPipe> >());
UsbInterfaceEndpoints.Add(uwpUsbInterfaceEndpoint);
WriteEndpoint ??= uwpUsbInterfaceEndpoint;
}
}
public UWPUsbInterface(windowsUsbInterface usbInterface, ILogger logger, ITracer tracer, ushort?readBuffersize, ushort?writeBufferSize) : base(logger, tracer, readBuffersize, writeBufferSize)
{
UsbInterface = usbInterface ?? throw new ArgumentNullException(nameof(usbInterface));
foreach (var inPipe in usbInterface.InterruptInPipes)
{
var uwpUsbInterfaceEndpoint = new UWPUsbInterfaceInterruptReadEndpoint(inPipe, Logger, Tracer);
UsbInterfaceEndpoints.Add(uwpUsbInterfaceEndpoint);
if (InterruptReadEndpoint == null)
{
InterruptReadEndpoint = uwpUsbInterfaceEndpoint;
}
}
foreach (var outPipe in usbInterface.InterruptOutPipes)
{
var uwpUsbInterfaceEndpoint = new UWPUsbInterfaceEndpoint <UsbInterruptOutPipe>(outPipe);
UsbInterfaceEndpoints.Add(uwpUsbInterfaceEndpoint);
if (InterruptWriteEndpoint == null)
{
InterruptWriteEndpoint = uwpUsbInterfaceEndpoint;
}
}
foreach (var inPipe in usbInterface.BulkInPipes)
{
var uwpUsbInterfaceEndpoint = new UWPUsbInterfaceEndpoint <UsbBulkInPipe>(inPipe);
UsbInterfaceEndpoints.Add(uwpUsbInterfaceEndpoint);
if (ReadEndpoint == null)
{
ReadEndpoint = uwpUsbInterfaceEndpoint;
}
}
foreach (var outPipe in usbInterface.BulkOutPipes)
{
var uwpUsbInterfaceEndpoint = new UWPUsbInterfaceEndpoint <UsbBulkOutPipe>(outPipe);
UsbInterfaceEndpoints.Add(uwpUsbInterfaceEndpoint);
if (WriteEndpoint == null)
{
WriteEndpoint = uwpUsbInterfaceEndpoint;
}
}
//TODO: Why does not UWP not support Control Transfer?
}
/// <summary>
/// This is an internal method called from CreateAsync method.
/// </summary>
/// <remarks>
/// The result of Task contains success(true) or failure(false).
/// </remarks>
private Task <bool> TryInitialize()
{
return(Task.Run(async() =>
{
var device = this.device;
Windows.Devices.Usb.UsbInterface cdcControl = null;
Windows.Devices.Usb.UsbInterface cdcData = null;
for (int i = 0; i < device.Configuration.UsbInterfaces.Count; i++)
{
var interf = device.Configuration.UsbInterfaces[i];
if (interf == null)
{
continue;
}
for (int j = 0; j < interf.InterfaceSettings.Count; j++)
{
var setting = interf.InterfaceSettings[j];
byte index = setting.InterfaceDescriptor.InterfaceNumber;
byte interfaceClass = setting.InterfaceDescriptor.ClassCode;
if (interfaceClass == InterfaceClass.CdcControl)
{
cdcControl = interf;
}
else if (interfaceClass == InterfaceClass.CdcData)
{
cdcData = interf;
}
else if (interfaceClass == InterfaceClass.VendorSpecific)
{
if (cdcControl == null)
{
// Test SetLineCoding/GetLineCoding
uint written = 0;
Windows.Storage.Streams.IBuffer gotBuffer = null;
try
{
written = await this.SetLineCoding(index, Constants.DteRateTestValue, 0, 0, Constants.DataBitsTestValue);
}
catch (Exception)
{
// This interface is not compatible with CDC ACM. Try the next interface.
continue;
}
try
{
gotBuffer = await this.GetLineCoding(index);
}
catch (Exception)
{
// This interface is not compatible with CDC ACM. Try the next interface.
continue;
}
if (gotBuffer != null && gotBuffer.Length == Constants.ExpectedResultGetLineCoding)
{
var lineCodingReader = Windows.Storage.Streams.DataReader.FromBuffer(gotBuffer);
lineCodingReader.ByteOrder = Windows.Storage.Streams.ByteOrder.LittleEndian;
var bps = lineCodingReader.ReadUInt32();
if (bps == Constants.DteRateTestValue)
{
// This could be a CdcControl.
cdcControl = interf;
}
}
}
if (cdcData == null)
{
if (interf.BulkInPipes.Count > 0 &&
interf.BulkOutPipes.Count > 0)
{
// This could be a CdcData.
cdcData = interf;
}
}
}
}
}
this.cdcControl = cdcControl;
this.cdcData = cdcData;
if (this.cdcControl != null && this.cdcData != null)
{
// Flush the pipes.
for (int IN = 0; IN < this.cdcData.BulkInPipes.Count; IN++)
{
this.cdcData.BulkInPipes[IN].FlushBuffer();
}
return true;
}
else
{
return false;
}
}));
}
