public override void Open(UsbDeviceConnection connection)
{
_connection = connection;
_controlInterface = Device.GetInterface(0);
if (!connection.ClaimInterface(_controlInterface, true))
{
throw new Exception("Could not claim control interface.");
}
_controlEndpoint = _controlInterface.GetEndpoint(0);
_dataInterface = Device.GetInterface(1);
if (!connection.ClaimInterface(_dataInterface, true))
{
throw new Exception("Could not claim data interface.");
}
if (Device.VendorId == 0x1cbe)
{
_writeEndpoint = _dataInterface.GetEndpoint(1);
_readEndpoint = _dataInterface.GetEndpoint(0);
}
else
{
_writeEndpoint = _dataInterface.GetEndpoint(0);
_readEndpoint = _dataInterface.GetEndpoint(1);
}
Init();
var buadSet = SetBaudrate(960000);
}
public override void Open(UsbDeviceConnection connection)
{
if (mConnection != null)
{
throw new IOException("Already opened.");
}
mConnection = connection;
bool opened = false;
bool controlInterfaceFound = false;
try
{
for (var i = 0; i < mDevice.InterfaceCount; i++)
{
mControlInterface = mDevice.GetInterface(i);
if (mControlInterface.InterfaceClass == UsbClass.Comm)
{
if (!mConnection.ClaimInterface(mControlInterface, true))
{
throw new IOException("Could not claim control interface");
}
(Driver as STM32SerialDriver).mCtrlInterf = i;
controlInterfaceFound = true;
break;
}
}
if (!controlInterfaceFound)
{
throw new IOException("Could not claim control interface");
}
for (var i = 0; i < mDevice.InterfaceCount; i++)
{
mDataInterface = mDevice.GetInterface(i);
if (mDataInterface.InterfaceClass == UsbClass.CdcData)
{
if (!mConnection.ClaimInterface(mDataInterface, true))
{
throw new IOException("Could not claim data interface");
}
mReadEndpoint = mDataInterface.GetEndpoint(1);
mWriteEndpoint = mDataInterface.GetEndpoint(0);
opened = true;
break;
}
}
if (!opened)
{
throw new IOException("Could not claim data interface.");
}
}
finally
{
if (!opened)
{
mConnection = null;
}
}
}
public override void Open(UsbDeviceConnection connection)
{
if (mConnection != null)
{
throw new IOException("Already open");
}
mConnection = connection;
Boolean opened = false;
try {
for (int i = 0; i < mDevice.InterfaceCount; i++)
{
if (connection.ClaimInterface(mDevice.GetInterface(i), true))
{
Log.Debug(TAG, "claimInterface " + i + " SUCCESS");
}
else
{
throw new IOException("Error claiming interface " + i);
}
}
Reset();
opened = true;
} finally {
if (!opened)
{
Close();
mConnection = null;
}
}
}
public SmartScopeUsbInterfaceXamarin(Context context, UsbManager usbManager, UsbDevice device)
{
Destroyed = false;
if (!usbManager.HasPermission(device))
{
Logger.Error("Permission denied");
throw new Exception("Device permission not obtained");
}
UsbInterface interf = device.GetInterface(0);
for (int i = 0; i < interf.EndpointCount; i++)
{
if (interf.GetEndpoint(i).EndpointNumber == 1)
{
dataEndpoint = interf.GetEndpoint(i);
}
else if (interf.GetEndpoint(i).EndpointNumber == 2)
{
commandWriteEndpoint = interf.GetEndpoint(i);
}
else if (interf.GetEndpoint(i).EndpointNumber == 3)
{
commandReadEndpoint = interf.GetEndpoint(i);
}
}
usbConnection = usbManager.OpenDevice(device);
usbConnection.ClaimInterface(interf, true);
}
/**
* 打开设备
*/
private void openDevice()
{
if (myInterface != null)
{
UsbDeviceConnection conn = null;
// 在open前判断是否有连接权限；对于连接权限可以静态分配，也可以动态分配权限，可以查阅相关资料
if (myUsbManager.HasPermission(myUsbDevice))
{
conn = myUsbManager.OpenDevice(myUsbDevice);
}
if (conn == null)
{
return;
}
if (conn.ClaimInterface(myInterface, true))
{
myDeviceConnection = conn; // 到此你的android设备已经连上HID设备
Log.Debug(TAG, "打开设备成功");
}
else
{
conn.Close();
}
}
}
/// <summary>
/// try to retreive an endpoint with the device
/// Is seems that usb-serial-for-android does this job
/// </summary>
/// <param name="connection"> The created connection</param>
/// <param name="epIn"> Endpoint found for the interface for device to host transmission </param>
/// <param name="epOut"> Endpoint found for the interface for host to device transmission </param>
/// <returns> operation result </returns>
protected int OpenInterface(UsbDevice usbdev, UsbDeviceConnection connection, ref UsbInterface usbIface, ref UsbEndpoint epIn, ref UsbEndpoint epOut)
{
int ret = -1;
int i;
// Search and claim the first interface available
for (i = 0; i < usbdev.InterfaceCount; i++)
{
usbIface = usbdev.GetInterface(i);
if (connection.ClaimInterface(usbIface, true))
{
// Now search IO endpoints
if (InterfaceGetBulkEndpoints(usbIface, ref epIn, ref epOut) == 0)
{
connection.SetInterface(usbIface);
return(0);
}
else
{
connection.ReleaseInterface(usbIface);
}
}
}
return(ret);
}
public override void Open(UsbDeviceConnection connection)
{
if (Connection != null)
{
throw new IOException("Already open");
}
Connection = connection;
bool opened = false;
try
{
if (connection.ClaimInterface(Device.GetInterface(PortNumber), true))
{
Log.Debug(TAG, "claimInterface " + PortNumber + " SUCCESS");
}
else
{
throw new IOException("Error claiming interface " + PortNumber);
}
Reset();
opened = true;
_readEndpoint = Device.GetInterface(PortNumber).GetEndpoint(0);
}
finally
{
if (!opened)
{
Close();
Connection = null;
}
}
}
public override void Open(UsbDeviceConnection connection)
{
if (_connection != null)
{
throw new UsbSerialException("Already open");
}
_connection = connection;
bool opened = false;
try
{
for (int i = 0; i < _driver.Device.InterfaceCount; i++)
{
if (connection.ClaimInterface(_driver.Device.GetInterface(i), true))
{
Log.Debug(nameof(FtdiSerialDriver), "claimInterface " + i + " SUCCESS");
}
else
{
throw new UsbSerialException("Error claiming interface " + i);
}
}
Reset();
opened = true;
}
finally
{
if (!opened)
{
Close();
_connection = null;
}
}
}
public override Task ClaimInterface()
{
Logger.LogInformation("Claimed interface {interfaceId}", InterfaceNumber);
return(!_UsbDeviceConnection.ClaimInterface(UsbInterface, true)
? throw new DeviceException("could not claim interface")
: Task.FromResult(true));
}
public override void Open(UsbDeviceConnection connection)
{
if (_connection != null)
{
throw new UsbSerialException("Already opened.");
}
_connection = connection;
bool opened = false;
try
{
for (int i = 0; i < _driver.Device.InterfaceCount; i++)
{
UsbInterface usbIface = _driver.Device.GetInterface(i);
Log.Debug(nameof(Ch34xSerialDriver),
_connection.ClaimInterface(usbIface, true)
? $"claimInterface {i} SUCCESS"
: $"claimInterface {i} FAIL");
}
UsbInterface dataIface = _driver.Device.GetInterface(_driver.Device.InterfaceCount - 1);
for (int i = 0; i < dataIface.EndpointCount; i++)
{
UsbEndpoint ep = dataIface.GetEndpoint(i);
if (ep.Type.IsEqualTo(ExtendedUsbConstants.USB_ENDPOINT_XFER_BULK))
{
if (ep.Direction.IsEqualTo(ExtendedUsbConstants.USB_DIR_IN))
{
_readEndpoint = ep;
}
else
{
_writeEndpoint = ep;
}
}
}
Initialize();
BaudRate = DEFAULT_BAUD_RATE;
opened = true;
}
finally
{
if (!opened)
{
try
{
Close();
}
catch (UsbSerialException)
{
//Swallowing this exception for now
}
}
}
}
public override void Open(UsbDeviceConnection connection)
{
if (_connection != null)
{
throw new UsbSerialException("Already opened.");
}
_connection = connection;
bool opened = false;
try
{
for (int i = 0; i < _driver.Device.InterfaceCount; i++)
{
UsbInterface usbIface = _driver.Device.GetInterface(i);
Log.Debug(nameof(Cp21xxSerialDriver),
_connection.ClaimInterface(usbIface, true)
? $"claimInterface {i} SUCCESS"
: $"claimInterface {i} FAIL");
}
UsbInterface dataIface = _driver.Device.GetInterface(_driver.Device.InterfaceCount - 1);
for (int i = 0; i < dataIface.EndpointCount; i++)
{
UsbEndpoint ep = dataIface.GetEndpoint(i);
if (ep.Type.IsEqualTo(ExtendedUsbConstants.USB_ENDPOINT_XFER_BULK))
{
if (ep.Direction.IsEqualTo(ExtendedUsbConstants.USB_DIR_IN))
{
_readEndpoint = ep;
}
else
{
_writeEndpoint = ep;
}
}
}
SetConfigSingle(SILABSER_IFC_ENABLE_REQUEST_CODE, UART_ENABLE);
SetConfigSingle(SILABSER_SET_MHS_REQUEST_CODE, MCR_ALL | CONTROL_WRITE_DTR | CONTROL_WRITE_RTS);
SetConfigSingle(SILABSER_SET_BAUDDIV_REQUEST_CODE, BAUD_RATE_GEN_FREQ / DEFAULT_BAUD_RATE);
opened = true;
}
finally
{
if (!opened)
{
try
{
Close();
}
catch (UsbSerialException)
{
//Swallowing this exception for now
}
}
}
}
public override Task ClaimInterface()
{
if (!_UsbDeviceConnection.ClaimInterface(UsbInterface, true))
{
throw new Exception("could not claim interface");
}
return(Task.FromResult(true));
}
public async Task <bool> OpenAsync()
{
if (connected)
{
return(false);
}
//usbManager.RequestPermission(usbDevice, PendingIntent.GetBroadcast(ConnectionService.Instance.Context, 0, new Intent(ConnectionService.Instance.ActionUsbPermission), PendingIntentFlags.CancelCurrent));
UsbInterface intf = usbDevice.GetInterface(0);
pinReportEndpoint = intf.GetEndpoint(0);
peripheralResponseEndpoint = intf.GetEndpoint(1);
pinConfigEndpoint = intf.GetEndpoint(2);
peripheralConfigEndpoint = intf.GetEndpoint(3);
connection = usbManager.OpenDevice(usbDevice);
if (connection != null)
{
bool intfClaimed = connection.ClaimInterface(intf, true);
if (intfClaimed)
{
connected = true;
pinListenerThread = new Thread(
() =>
{
byte[] data = new byte[64];
pinListenerThreadRunning = true;
while (pinListenerThreadRunning)
{
int res =
connection.BulkTransfer(pinReportEndpoint, data, 41,
100); // pin reports are 41 bytes long now
if (res > 0)
{
this.PinEventDataReceived?.Invoke(data);
}
}
});
pinListenerThread.Start();
return(true);
}
}
return(false);
}
/// <summary>
///
/// </summary>
public virtual void OpenDevice(UsbDevice device)
{
//
if ((m_UsbIntf = FindInterface(device)) == null)
{
Log.e("UsbStream", "Can't find the UsbInterface" + device.ToString() + ".");
OnOpenFailure();
return;
}
//
m_UsbConnection = m_UsbMgr.OpenDevice(m_UsbDevice = device);
m_UsbConnection.ClaimInterface(m_UsbIntf, true);
//
m_UsbReqIn = new UsbRequest();
m_UsbReqIn.Initialize(m_UsbConnection, m_UsbIntf.intIn);
// Check read buffer size.
if (m_SizeRead == -1)
{
Log.i("UsbStream", "Use default read buffer size:" + (m_SizeRead = 64).ToString());
}
#if USB_HANDLER_IN_UNITY
//
m_UsbBufferIn = ByteBuffer.Allocate(m_SizeRead);
//
m_ReadThread = new NativeThread(ReadThread_Step); //Looper
m_ReadThread.StartLoop(); //
#elif USB_HANDLER_IN_ANDROID
AndroidJavaObject handler = new AndroidJavaObject
("android.unity.SafeUsbHandler", m_UsbConnection.m_SealedPtr, m_UsbReqIn.m_SealedPtr, m_SizeRead);
handler.Call("setCallback", new CallbackProxy(this));
m_ReadThread = new NativeThread(handler);
m_ReadThread.Start2();
#endif
//
UsbManager.main.onUsbDeviceDetached += OnUsbDeviceDetached;
if (m_OpenCallback != null)
{
m_OpenCallback.OnStreamOpenSuccess(this);
}
//
m_IsOpen = true;
}
public override void Open(UsbDeviceConnection connection)
{
_connection = connection;
var intf = _device.GetInterface(0);
if (!connection.ClaimInterface(intf, true))
{
throw new Exception("Could not claim control interface.");
}
if (intf.EndpointCount > 1)
{
_writeEndpoint = intf.GetEndpoint(1);
}
_readEndpoint = intf.GetEndpoint(0);
_buffer = new byte[_readEndpoint.MaxPacketSize];
}
public void Start()
{
_usbConnection = _usbManager.OpenDevice(_usbDevice);
if (_usbConnection == null)
{
throw new NullReferenceException("connection");
}
_usbInterface = _usbDevice.GetInterface(1);
if (!_usbConnection.ClaimInterface(_usbInterface, true))
{
throw new Exception("claim interface");
}
_usbWriteEndpoint = _usbInterface.GetEndpoint(0);
_usbReadEndpoint = _usbInterface.GetEndpoint(1);
ScanNetworks();
}
/**
* 打开设备
*/
private int openDevice()
{
int err = 0;
if (myInterface != null)
{
UsbDeviceConnection conn = null;
// 在open前判断是否有连接权限；对于连接权限可以静态分配，也可以动态分配权限，可以查阅相关资料
// conn = myUsbManager.OpenDevice(myUsbDevice);
if (myUsbManager.HasPermission(myUsbDevice))
{
conn = myUsbManager.OpenDevice(myUsbDevice);
}
else
{
err = (int)PrintError.NoPermission;
Log.Debug("err", "没有连接权限");
return(err);
}
if (conn.ClaimInterface(myInterface, true))
{
myDeviceConnection = conn; // 到此你的android设备已经连上HID设备
Log.Debug("info", "连接HID设备成功");
err = 1;
return(err);
}
else
{
err = (int)PrintError.ConnectedFailure;
Log.Debug("err", "连接HID设备失败");
conn.Close();
return(err);
}
}
else
{
err = (int)PrintError.Error;
return(err);
}
}
public void Start()
{
var manager = (UsbManager)Application.Context.GetSystemService(Context.UsbService);
_connection = manager.OpenDevice(_device);
var claimed = _connection.ClaimInterface(_interface, true);
if (!claimed)
{
throw new Exception("Interface could not be claimed");
}
var rawDescriptors = _connection.GetRawDescriptors();
Descriptor = new CcidDescriptor(rawDescriptors);
if (SupportsInterrupt)
{
_interruptListenerThread = new Thread(StartListeningOnInterruptEndpoint);
_interruptListenerThread.Start();
}
}
public void Load(string devicePath)
{
Manager = (UsbManager)context.GetSystemService(Context.UsbService);
IDictionary <String, UsbDevice> deviceList = Manager.DeviceList;
DeviceList = deviceList.Values;
try
{
foreach (UsbDevice device in DeviceList)
{
if (device.DeviceName == devicePath)
{
if (Manager.HasPermission(device))
{
Connected = true;
NativeDevice = device;
Connection = Manager.OpenDevice(NativeDevice);
Endpoint = NativeDevice.GetInterface(0).GetEndpoint(0);
EndpointWrite = NativeDevice.GetInterface(0).GetEndpoint(1);
Connection.ClaimInterface(NativeDevice.GetInterface(0), true);
}
else
{
if (LoadReattempt)
{
LoadReattempt = false;
bool Granted = MainActivity.Instance.RequestUSBPermissions(Manager, device, Main);
Load(devicePath);
}
LoadReattempt = true;
}
}
}
}
catch
{
}
}
public override void Open(UsbDeviceConnection connection)
{
if (mConnection != null)
{
throw new IOException("Already opened.");
}
mConnection = connection;
bool opened = false;
bool controlInterfaceFound = false;
try
{
for (var i = 0; i < mDevice.InterfaceCount; i++)
{
mControlInterface = mDevice.GetInterface(i);
if (mControlInterface.InterfaceClass == UsbClass.Comm)
{
if (!mConnection.ClaimInterface(mControlInterface, true))
{
throw new IOException("Could not claim control interface");
}
(Driver as STM32SerialDriver).mCtrlInterf = i;
controlInterfaceFound = true;
break;
}
}
if (!controlInterfaceFound)
{
throw new IOException("Could not claim control interface");
}
for (var i = 0; i < mDevice.InterfaceCount; i++)
{
mDataInterface = mDevice.GetInterface(i);
if (mDataInterface.InterfaceClass == UsbClass.CdcData)
{
if (!mConnection.ClaimInterface(mDataInterface, true))
{
throw new IOException("Could not claim data interface");
}
for (int j = 0; j < mDataInterface.EndpointCount; ++j)
{
UsbEndpoint ep = mDataInterface.GetEndpoint(j);
if ((ep.Direction == UsbAddressing.In) &&
(ep.Type == UsbAddressing.XferBulk))
{
Log.Debug(TAG, "Found reading endpoint");
mReadEndpoint = ep;
}
else if ((ep.Direction == UsbAddressing.Out) &&
(ep.Type == UsbAddressing.XferBulk))
{
Log.Debug(TAG, "Found writing endpoint");
mWriteEndpoint = ep;
}
}
//mReadEndpoint = mDataInterface.GetEndpoint(1);
//mWriteEndpoint = mDataInterface.GetEndpoint(0);
//mReadEndpoint = mDataInterface.GetEndpoint(0);
//mWriteEndpoint = mDataInterface.GetEndpoint(1);
opened = true;
break;
}
}
if (!opened)
{
throw new IOException("Could not claim data interface.");
}
}
finally
{
if (!opened)
{
mConnection = null;
}
}
}
public override void Open(UsbDeviceConnection connection)
{
if (Connection != null)
{
throw new IOException("Already open");
}
Connection = connection;
UsbInterface usbInterface = Device.GetInterface(0);
if (!connection.ClaimInterface(usbInterface, true))
{
throw new IOException("Error claiming Prolific interface 0");
}
var opened = false;
try
{
for (int i = 0; i < usbInterface.EndpointCount; ++i)
{
UsbEndpoint currentEndpoint = usbInterface.GetEndpoint(i);
switch (currentEndpoint.Address)
{
case READ_ENDPOINT:
mReadEndpoint = currentEndpoint;
break;
case WRITE_ENDPOINT:
mWriteEndpoint = currentEndpoint;
break;
case INTERRUPT_ENDPOINT:
mInterruptEndpoint = currentEndpoint;
break;
}
}
if (Device.DeviceClass == (UsbClass)0x02)
{
mDeviceType = DEVICE_TYPE_0;
}
else
{
if ((Device.DeviceClass == 0x00) ||
(Device.DeviceClass == (UsbClass)0xff))
{
mDeviceType = DEVICE_TYPE_1;
}
else
{
mDeviceType = DEVICE_TYPE_HX;
}
}
SetControlLines(mControlLinesValue);
DoBlackMagic();
ResetDevice();
opened = true;
}
finally
{
if (!opened)
{
Connection = null;
connection.ReleaseInterface(usbInterface);
}
}
}
public void SetDevice(Intent intent, UsbDevice usbDevice)
{
int packetSize = 0;
IsReading = true;
if (usbDevice != null && intent.GetBooleanExtra(UsbManager.ExtraPermissionGranted, false))
{
connection = mUsbManager.OpenDevice(usbDevice);
intf = usbDevice.GetInterface(0);
if (null == connection)
{
Log.Debug("DEBUG", "unable to establish connection)\n");
}
else
{
connection.ClaimInterface(intf, true);
}
try
{
if (UsbAddressing.DirMask == intf.GetEndpoint(0).Direction)
{
endPointRead = intf.GetEndpoint(0);
packetSize = endPointRead.MaxPacketSize;
}
else
{
Log.Debug("####### DEBUG #######", "######### Cagou geral !!! ############");
}
}
catch (Exception e)
{
Log.Debug("endPointWrite", "Device have no endPointRead" + e);
}
var cancellationTokenSource = new CancellationTokenSource();
new Thread(new ThreadStart(delegate
{
try
{
if (connection != null && endPointRead != null)
{
while (IsReading)
{
byte[] buffer = new byte[packetSize];
int status = connection.BulkTransfer(endPointRead, buffer, packetSize, 100);
if (status > 0)
{
var count = bufferReaded.Count(x => x != 0x00);
Buffer.BlockCopy(buffer, 0, bufferReaded, count, buffer.Length);
Log.Debug("####### DEBUG #######", "COPIEEEI!");
}
}
}
}
catch (Exception e)
{
Log.Debug(TAG, "Error in receive thread" + e.Message);
}
})).Start();
//usbThreadDataReceiver = Task.Factory.StartNew(a =>
//{
// try
// {
// if (connection != null && endPointRead != null)
// {
// while (IsReading)
// {
// byte[] buffer = new byte[packetSize];
// int status = connection.BulkTransfer(endPointRead, buffer, packetSize, 100);
// if (status > 0)
// {
// var count = bufferReaded.Count(x => x != 0x00);
// Buffer.BlockCopy(buffer, 0, bufferReaded, count, buffer.Length);
// }
// }
// }
// }
// catch (Exception e)
// {
// Log.Debug(TAG, "Error in receive thread" + e.Message);
// }
//}, TaskCreationOptions.LongRunning, cancellationTokenSource.Token );
new Thread(new ThreadStart(delegate
{
try
{
while (IsReading)
{
if (bufferReaded.Count(x => x != 0x00) > 150)
{
int n = 0;
while ((bufferReaded[bufferReaded.Count(x => x != 0x00) - 2] != 0x7c) && (bufferReaded[bufferReaded.Count(x => x != 0x00) - 1] != 0x41))
{
if (bufferReaded.Count(x => x != 0x00) >= 255)
{
Array.Clear(bufferReaded, 0, bufferReaded.Length);
break;
}
}
var count = bufferReaded.Count(x => x != 0x00);
StringBuilder stringBuilder = new StringBuilder();
int i = 0;
for (; i < bufferReaded.Length && bufferReaded[i] != 0; i++)
{
stringBuilder.Append(Convert.ToString((char)bufferReaded[i]));
}
Array.Clear(bufferReaded, 0, bufferReaded.Length);
//Task.Factory.StartNew(() =>
//{
OnUsbDataReceiver?.Invoke(new object(), stringBuilder.ToString());
Log.Debug("####### DEBUG #######", stringBuilder.ToString());
//}).ConfigureAwait(false);
}
}
}
catch (Exception e)
{
Log.Debug(TAG, "Error verify buffer" + e.Message);
}
})).Start();
//verificaPacoteLido = Task.Factory.StartNew(a =>
//{
// try
// {
// while (IsReading)
// {
// if (bufferReaded.Count(x => x != 0x00) > 150)
// {
// int n = 0;
// while ((bufferReaded[bufferReaded.Count(x => x != 0x00) - 2] != 0x7c) && (bufferReaded[bufferReaded.Count(x => x != 0x00) - 1] != 0x41))
// {
// if (bufferReaded.Count(x => x != 0x00) >= 255)
// {
// Array.Clear(bufferReaded, 0, bufferReaded.Length);
// break;
// }
// }
// var count = bufferReaded.Count(x => x != 0x00);
// StringBuilder stringBuilder = new StringBuilder();
// int i = 0;
// for (; i < bufferReaded.Length && bufferReaded[i] != 0; i++)
// {
// stringBuilder.Append(Convert.ToString((char)bufferReaded[i]));
// }
// Array.Clear(bufferReaded, 0, bufferReaded.Length);
// //Task.Factory.StartNew(() =>
// //{
// //OnUsbDataReceiver?.Invoke(new object(), stringBuilder.ToString());
// Log.Debug("####### DEBUG #######", stringBuilder.ToString());
// //}).ConfigureAwait(false);
// }
// }
// }
// catch (Exception e)
// {
// Log.Debug(TAG, "Error verify buffer" + e.Message);
// }
//}, TaskCreationOptions.LongRunning, cancellationTokenSource.Token);
}
}
public async Task InitializeAsync()
{
if (_IsInitializing)
{
return;
}
_IsInitializing = true;
try
{
var isPermissionGranted = await RequestPermissionAsync();
if (!isPermissionGranted.HasValue)
{
throw new Exception("User did not respond to permission request");
}
if (!isPermissionGranted.Value)
{
throw new Exception("The user did not give the permission to access the device");
}
var usbInterface = _UsbDevice.GetInterface(0);
//TODO: This selection stuff needs to be moved up higher. The contructor should take these arguments
for (var i = 0; i < usbInterface.EndpointCount; i++)
{
var ep = usbInterface.GetEndpoint(i);
if (_ReadEndpoint == null && ep.Type == UsbAddressing.XferInterrupt && ep.Address == (UsbAddressing)129)
{
_ReadEndpoint = ep;
continue;
}
if (_WriteEndpoint == null && ep.Type == UsbAddressing.XferInterrupt && (ep.Address == (UsbAddressing)1 || ep.Address == (UsbAddressing)2))
{
_WriteEndpoint = ep;
}
}
//TODO: This is a bit of a guess. It only kicks in if the previous code fails. This needs to be reworked for different devices
if (_ReadEndpoint == null)
{
_ReadEndpoint = usbInterface.GetEndpoint(0);
}
if (_WriteEndpoint == null)
{
_WriteEndpoint = usbInterface.GetEndpoint(1);
}
if (_ReadEndpoint.MaxPacketSize != ReadBufferLength)
{
throw new Exception("Wrong packet size for read endpoint");
}
if (_WriteEndpoint.MaxPacketSize != ReadBufferLength)
{
throw new Exception("Wrong packet size for write endpoint");
}
_UsbDeviceConnection = UsbManager.OpenDevice(_UsbDevice);
if (_UsbDeviceConnection == null)
{
throw new Exception("could not open connection");
}
if (!_UsbDeviceConnection.ClaimInterface(usbInterface, true))
{
throw new Exception("could not claim interface");
}
Logger.Log("Hid device initialized. About to tell everyone.", null, LogSection);
IsInitialized = true;
Connected?.Invoke(this, new EventArgs());
return;
}
catch (Exception ex)
{
Logger.Log("Error initializing Hid Device", ex, LogSection);
}
_IsInitializing = false;
}
public override void Open(UsbDeviceConnection connection)
{
if (_connection != null)
{
throw new UsbSerialException("Already open");
}
UsbInterface usbInterface = _driver.Device.GetInterface(0);
if (!connection.ClaimInterface(usbInterface, true))
{
throw new UsbSerialException("Error claiming Prolific interface 0");
}
_connection = connection;
bool opened = false;
try
{
for (int i = 0; i < usbInterface.EndpointCount; ++i)
{
UsbEndpoint currentEndpoint = usbInterface.GetEndpoint(i);
if (currentEndpoint.Address.IsEqualTo(READ_ENDPOINT))
{
_readEndpoint = currentEndpoint;
}
else if (currentEndpoint.Address.IsEqualTo(WRITE_ENDPOINT))
{
_writeEndpoint = currentEndpoint;
}
else if (currentEndpoint.Address.IsEqualTo(INTERRUPT_ENDPOINT))
{
_interruptEndpoint = currentEndpoint;
}
}
if ((int)_driver.Device.DeviceClass == 0x02)
{
_deviceType = DEVICE_TYPE_0;
}
else
{
try
{
byte[] rawDescriptors = _connection.GetRawDescriptors();
byte maxPacketSize0 = rawDescriptors[7];
if (maxPacketSize0 == 64)
{
_deviceType = DEVICE_TYPE_HX;
}
else if ((_driver.Device.DeviceClass == 0x00) || ((int)_driver.Device.DeviceClass == 0xff))
{
_deviceType = DEVICE_TYPE_1;
}
else
{
Log.Warn(nameof(ProlificSerialDriver), "Could not detect PL2303 subtype, " + "Assuming that it is a HX device");
_deviceType = DEVICE_TYPE_HX;
}
}
catch (NoSuchMethodException)
{
Log.Warn(nameof(ProlificSerialDriver), "Method UsbDeviceConnection.getRawDescriptors, " + "required for PL2303 subtype detection, not " + "available! Assuming that it is a HX device");
_deviceType = DEVICE_TYPE_HX;
}
catch (Exception e)
{
Log.Warn(nameof(ProlificSerialDriver), "An unexpected exception occured while trying " + "to detect PL2303 subtype", e);
}
}
ControlLines = _controlLinesValue;
ResetDevice();
PerformInitializationSequence();
opened = true;
}
finally
{
if (!opened)
{
_connection = null;
connection.ReleaseInterface(usbInterface);
}
}
}
public override void Open(UsbDeviceConnection connection)
{
if (mConnection != null)
{
throw new IOException("Already opened.");
}
mConnection = connection;
Boolean opened = false;
try
{
for (int i = 0; i < mDevice.InterfaceCount; i++)
{
UsbInterface usbIface = mDevice.GetInterface(i);
if (mConnection.ClaimInterface(usbIface, true))
{
Log.Debug(TAG, "claimInterface " + i + " SUCCESS");
}
else
{
Log.Debug(TAG, "claimInterface " + i + " FAIL");
}
}
UsbInterface dataIface = mDevice.GetInterface(mDevice.InterfaceCount - 1);
for (int i = 0; i < dataIface.EndpointCount; i++)
{
UsbEndpoint ep = dataIface.GetEndpoint(i);
if (ep.Type == (UsbAddressing)UsbSupport.UsbEndpointXferBulk)
{
if (ep.Direction == (UsbAddressing)UsbSupport.UsbDirIn)
{
mReadEndpoint = ep;
}
else
{
mWriteEndpoint = ep;
}
}
}
Initialize();
SetBaudRate(DEFAULT_BAUD_RATE);
opened = true;
}
finally
{
if (!opened)
{
try
{
Close();
}
catch (IOException e)
{
// Ignore IOExceptions during close()
}
}
}
}
public override void Open(UsbDeviceConnection connection)
{
if (mConnection != null)
{
throw new IOException("Already open");
}
UsbInterface usbInterface = mDevice.GetInterface(0);
if (!connection.ClaimInterface(usbInterface, true))
{
throw new IOException("Error claiming Prolific interface 0");
}
mConnection = connection;
Boolean opened = false;
try
{
for (int i = 0; i < usbInterface.EndpointCount; ++i)
{
UsbEndpoint currentEndpoint = usbInterface.GetEndpoint(i);
switch (currentEndpoint.Address)
{
case (UsbAddressing)READ_ENDPOINT:
mReadEndpoint = currentEndpoint;
break;
case (UsbAddressing)WRITE_ENDPOINT:
mWriteEndpoint = currentEndpoint;
break;
case (UsbAddressing)INTERRUPT_ENDPOINT:
mInterruptEndpoint = currentEndpoint;
break;
}
}
if (mDevice.DeviceClass == (UsbClass)0x02)
{
mDeviceType = DEVICE_TYPE_0;
}
else
{
try
{
//Method getRawDescriptorsMethod
// = mConnection.getClass().getMethod("getRawDescriptors");
//byte[] rawDescriptors
// = (byte[])getRawDescriptorsMethod.invoke(mConnection);
byte[] rawDescriptors = mConnection.GetRawDescriptors();
byte maxPacketSize0 = rawDescriptors[7];
if (maxPacketSize0 == 64)
{
mDeviceType = DEVICE_TYPE_HX;
}
else if ((mDevice.DeviceClass == 0x00) ||
(mDevice.DeviceClass == (UsbClass)0xff))
{
mDeviceType = DEVICE_TYPE_1;
}
else
{
Log.Warn(TAG, "Could not detect PL2303 subtype, "
+ "Assuming that it is a HX device");
mDeviceType = DEVICE_TYPE_HX;
}
}
catch (NoSuchMethodException e)
{
Log.Warn(TAG, "Method UsbDeviceConnection.getRawDescriptors, "
+ "required for PL2303 subtype detection, not "
+ "available! Assuming that it is a HX device");
mDeviceType = DEVICE_TYPE_HX;
}
catch (Exception e)
{
Log.Error(TAG, "An unexpected exception occured while trying "
+ "to detect PL2303 subtype", e);
}
}
SetControlLines(mControlLinesValue);
ResetDevice();
DoBlackMagic();
opened = true;
}
finally
{
if (!opened)
{
mConnection = null;
connection.ReleaseInterface(usbInterface);
}
}
}
public override void Open(UsbDeviceConnection connection)
{
if (mConnection != null)
{
throw new IOException("Already opened.");
}
mConnection = connection;
Boolean opened = false;
try
{
for (int i = 0; i < mDevice.InterfaceCount; i++)
{
UsbInterface usbIface = mDevice.GetInterface(i);
if (mConnection.ClaimInterface(usbIface, true))
{
Log.Debug(TAG, $"claimInterface {i} SUCCESS");
}
else
{
Log.Debug(TAG, $"claimInterface {i} FAIL");
}
}
UsbInterface dataIface = mDevice.GetInterface(mDevice.InterfaceCount - 1);
for (int i = 0; i < dataIface.EndpointCount; i++)
{
UsbEndpoint ep = dataIface.GetEndpoint(i);
if (ep.Type == (UsbAddressing)UsbSupport.UsbEndpointXferBulk)
{
if (ep.Direction == (UsbAddressing)UsbSupport.UsbDirIn)
{
mReadEndpoint = ep;
}
else
{
mWriteEndpoint = ep;
}
}
}
SetConfigSingle(SILABSER_IFC_ENABLE_REQUEST_CODE, UART_ENABLE);
SetConfigSingle(SILABSER_SET_MHS_REQUEST_CODE, MCR_ALL | CONTROL_WRITE_DTR | CONTROL_WRITE_RTS);
SetConfigSingle(SILABSER_SET_BAUDDIV_REQUEST_CODE, BAUD_RATE_GEN_FREQ / DEFAULT_BAUD_RATE);
// setParameters(DEFAULT_BAUD_RATE, DEFAULT_DATA_BITS, DEFAULT_STOP_BITS, DEFAULT_PARITY);
opened = true;
}
finally
{
if (!opened)
{
try
{
Close();
}
catch (IOException e)
{
// Ignore IOExceptions during close()
}
}
}
}