public void Dispose()
{
if (NativeDevice != null)
{
NativeDevice.Dispose();
NativeDevice = null;
}
if (Connection != null)
{
Connection.Dispose();
Connection = null;
}
if (Endpoint != null)
{
Endpoint.Dispose();
Endpoint = null;
}
if (EndpointWrite != null)
{
EndpointWrite.Dispose();
EndpointWrite = null;
}
if (Manager != null)
{
Manager.Dispose();
Manager = null;
}
}
public CH34xSerialDevice(UsbDevice device, UsbDeviceConnection connection, int iface) : base(device, connection)
{
hexData = new HexData();
rtsCtsEnabled = false;
dtrDsrEnabled = false;
mInterface = device.GetInterface(iface >= 0 ? iface : 0);
}
public void Close()
{
if (_IsClosing)
{
return;
}
_IsClosing = true;
try
{
_UsbDeviceConnection?.Dispose();
_UsbDevice?.Dispose();
ReadUsbInterface?.Dispose();
WriteUsbInterface?.Dispose();
_UsbDeviceConnection = null;
_UsbDevice = null;
ReadUsbInterface = null;
WriteUsbInterface = null;
}
catch (Exception)
{
//TODO: Logging
}
_IsClosing = false;
}
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 static UsbSerialDevice CreateUsbSerialDevice(UsbDevice device, UsbDeviceConnection connection, int iface)
{
/*
* It checks given vid and pid and will return a custom driver or a CDC serial driver.
* When CDC is returned open() method is even more important, its response will inform about if it can be really
* opened as a serial device with a generic CDC serial driver
*/
int vid = device.VendorId;
int pid = device.ProductId;
if (FTDISioIds.IsDeviceSupported(vid, pid))
{
return(new FTDISerialDevice(device, connection, iface));
}
else if (CP210xIds.IsDeviceSupported(vid, pid))
{
return(new CP2102SerialDevice(device, connection, iface));
}
else if (PL2303Ids.IsDeviceSupported(vid, pid))
{
return(new PL2303SerialDevice(device, connection, iface));
}
else if (CH34xIds.IsDeviceSupported(vid, pid))
{
return(new CH34xSerialDevice(device, connection, iface));
}
else if (IsCdcDevice(device))
{
return(new CDCSerialDevice(device, connection, iface));
}
else
{
return(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 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 UsbSerialDevice(UsbDevice device, UsbDeviceConnection connection)
{
this.device = device;
this.connection = connection;
this.asyncMode = true;
serialBuffer = new SerialBuffer(mr1Version);
}
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);
}
/// <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);
}
private async Task CheckForDeviceAsync()
{
var devices = UsbManager.DeviceList.Select(kvp => kvp.Value).ToList();
Logger.Log($"Connected devices: {(string.Join(",", devices.Select(d => d.VendorId)))}.", null, LogSection);
_UsbDevice?.Dispose();
_UsbDevice = devices.FirstOrDefault(d => d.VendorId == VendorId && d.ProductId == ProductId);
if (_UsbDevice != null)
{
if (_UsbDeviceConnection == null)
{
Logger.Log($"Initializing Android Hid device", null, LogSection);
await InitializeAsync();
}
}
else
{
var wasConnected = _UsbDeviceConnection != null;
_UsbDeviceConnection?.Dispose();
_UsbDeviceConnection = null;
if (wasConnected)
{
Disconnected?.Invoke(this, new EventArgs());
}
}
}
/**
* 打开设备
*/
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();
}
}
}
private void WireupUsb(IUsbSerialDriver device)
{
UsbManager manager = (UsbManager)GetSystemService(UsbService);
var port1 = device.Ports[0];
UsbDeviceConnection connection = manager.OpenDevice(device.Device);
port1.Open(connection);
port1.SetParameters(115200, DataBits._8, StopBits._1, Parity.None);
var buffer = new byte[500];
Log.Debug("main", "here");
var timeout = (int)TimeSpan.FromSeconds(1).TotalMilliseconds;
port1.CtsChanged += Port1_CtsChanged;
port1.Rts = true;
while (true)
{
var bytesRead = port1.Read(buffer, timeout);
if (bytesRead > 0)
{
var str = Encoding.ASCII.GetString(buffer, 0, bytesRead);
Log.Debug("card read", str);
}
Thread.Sleep(50);
}
}
public async Task <bool> Open(int baudRate)
{
Console.WriteLine("Getting permission");
var perm = await usbManager.RequestPermissionAsync(port.Driver.Device, ctx);
if (perm)
{
try {
conn = usbManager.OpenDevice(port.Driver.Device);
port.Open(conn);
port.SetParameters(baudRate, 8, StopBits.One, Parity.None);
port.SetDTR(true);
new Handler(Looper.MainLooper).Post(() => {
Toast.MakeText(ctx, "Serial connected", ToastLength.Short).Show();
});
} catch (Java.IO.IOException) {
// TODO: Handle this
throw;
}
return(true);
}
else
{
return(false);
}
}
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;
}
}
}
/// <summary>
/// 释放连接
/// </summary>
public void Close()
{
if (myDeviceConnection != null)
{
myDeviceConnection.Close();
myDeviceConnection = null;
}
}
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 UsbDataBinder(UsbManager manager, UsbDevice device)
{
// TODO Auto-generated constructor stub
mUsbManager = manager;
mDevice = device;
mIntf = mDevice.GetInterface(0);
mEndpoint = mIntf.GetEndpoint(0);
mConnection = mUsbManager.OpenDevice(mDevice);
}
public PL2303SerialDevice(UsbDevice device, UsbDeviceConnection connection, int iface) : base(device, connection)
{
hexData = new HexData();
if (iface > 1)
{
throw new ArgumentException("Multi-interface PL2303 devices not supported!");
}
mInterface = device.GetInterface(iface >= 0 ? iface : 0);
}
public FTDISerialDevice(UsbDevice device, UsbDeviceConnection connection, int iface) : base(device, connection)
{
ftdiUtilities = new FTDIUtilities(this);
rtsCtsEnabled = false;
dtrDsrEnabled = false;
ctsState = true;
dsrState = true;
firstTime = true;
mInterface = device.GetInterface(iface >= 0 ? iface : 0);
}
public void Close()
{
connection = null;
fd = -1;
usbdev = null;
usbIface = null;
ep_in = null;
ep_out = null;
max_pkt_size = 0;
}
public ReadingRun(UsbDeviceConnection connection, UsbEndpoint readEndpoint, UsbEndpoint writeEndpoint, Handler handler, CancellationToken token, int channel = -1)
{
_connection = connection;
_readEndpoint = readEndpoint;
_writeEndpoint = writeEndpoint;
_handler = handler;
_token = token;
_scanMode = channel < 0;
_channel = !_scanMode ? channel : 0;
}
private void getEndpoint(UsbDeviceConnection connection, UsbInterface intf)
{
if (intf.GetEndpoint(1) != null)
{
epOut = intf.GetEndpoint(1);
}
if (intf.GetEndpoint(0) != null)
{
epIn = intf.GetEndpoint(0);
}
}
public static UsbSpiDevice CreateUsbSerialDevice(UsbDevice device, UsbDeviceConnection connection, int iface)
{
int vid = device.VendorId;
int pid = device.ProductId;
if (CP2130Ids.IsDeviceSupported(vid, pid))
{
return(new CP2130SpiDevice(device, connection, iface));
}
else
{
return(null);
}
}
/// <summary>
/// The FindSerialPortDevice
/// </summary>
public void FindSerialPortDevice()
{
isFirstRun = false;
// This snippet will try to open the first encountered usb device connected, excluding usb root hubs
IDictionary <string, UsbDevice> usbDevices = usbManager.DeviceList;
if (usbDevices.Count > 0)
{
bool keep = true;
foreach (KeyValuePair <string, UsbDevice> entry in usbDevices)
{
device = entry.Value;
int deviceVID = device.VendorId;
int devicePID = device.ProductId;
Android.Util.Log.Info("USB DEVICE CONNECTED", " VID: " + deviceVID + " PID: " + devicePID);
Android.Util.Log.Info("USB DEVICE CONNECTED", " VID: " + deviceVID.ToString("X2") + " PID: " + devicePID.ToString("X2"));
//if (deviceVID != 0x1d6b && (devicePID != 0x0001 && devicePID != 0x0002 && devicePID != 0x0003) && deviceVID != 0x5c6 && devicePID != 0x904c)
if (deviceVID != 0x1d6b && devicePID != 0x0001 && devicePID != 0x0002 && devicePID != 0x0003)
{
// There is a device connected to our Android device. Try to open it as a Serial Port.
RequestUserPermission();
keep = false;
}
else
{
connection = null;
device = null;
}
if (!keep)
{
break;
}
}
if (!keep)
{
// There is no USB devices connected (but usb host were listed). Send an intent to MainActivity.
Intent intent = new Intent(ServiceConstants.ACTION_NO_USB);
SendBroadcast(intent);
}
}
else
{
// There is no USB devices connected. Send an intent to MainActivity
Intent intent = new Intent(ServiceConstants.ACTION_NO_USB);
SendBroadcast(intent);
}
}
public void Stop()
{
_cts.Cancel();
_cts = null;
_handler.SendMessage(_handler.ObtainMessage((int)USBDeviceStatus.DeviceConnectionClosed));
_usbReadEndpoint = null;
_usbWriteEndpoint = null;
_usbConnection.Close();
_usbInterface = null;
_usbConnection = null;
_thread = null;
//Device.DataReceived -= Device_DataReceived;
//Device.Dispose();
//Device = null;
}
public override void Open(UsbDeviceConnection connection)
{
if (mConnection != null)
{
throw new IOException("Already open");
}
mConnection = connection;
bool opened = false;
try
{
if (1 == mDevice.InterfaceCount)
{
Log.Debug(TAG, "device might be castrated ACM device, trying single interface logic");
OpenSingleInterface();
}
else
{
Log.Debug(TAG, "trying default interface logic");
openInterface();
}
if (mEnableAsyncReads)
{
Log.Debug(TAG, "Async reads enabled");
}
else
{
Log.Debug(TAG, "Async reads disabled.");
}
opened = true;
}
finally
{
if (!opened)
{
mConnection = null;
// just to be on the save side
mControlEndpoint = null;
mReadEndpoint = null;
mWriteEndpoint = null;
}
}
}
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);
}
