public UsbConnector(Context context) {
UsbManager manager = (UsbManager) context.getSystemService(Context.USB_SERVICE);
HashMap<String, UsbDevice> deviceList = manager.getDeviceList();
Iterator<UsbDevice> deviceIterator = deviceList.values().iterator();
Log.d(TAG, "===>UsbConnector");
while (deviceIterator.hasNext()) {
UsbDevice device = deviceIterator.next();
Log.d(
TAG,
"device="
+ device.getDeviceName()
+ ","
+ device.getDeviceSubclass()
+ ","
+ device.getDeviceProtocol());
Log.d(TAG, "ifs=" + device.getInterfaceCount() + "," + device.getInterface(0).toString());
Log.d(TAG, "end=" + device.getInterface(0).getEndpoint(0).toString());
Log.d(
TAG,
"class="
+ device.getDeviceClass()
+ ", pid="
+ device.getProductId()
+ ",vid="
+ device.getVendorId());
// your code
}
}
public static void authorize(Context svcContext, PendingIntent usbAuthPendingIntent) {
androidUsbManager = ((UsbManager) svcContext.getSystemService(Context.USB_SERVICE));
if (!androidUsbManager.hasPermission(adkAccessory)) {
androidUsbManager.requestPermission(adkAccessory, usbAuthPendingIntent);
}
}
/**
* Searches for the device and opens it if successful
*
* @return true, if connection was successful
*/
public boolean FindDevice() {
_usbManager = (UsbManager) _context.getSystemService(Context.USB_SERVICE);
HashMap<String, UsbDevice> deviceList = _usbManager.getDeviceList();
Iterator<UsbDevice> deviceIterator = deviceList.values().iterator();
_usbDevice = null;
// Iterate all the available devices and find ours.
while (deviceIterator.hasNext()) {
UsbDevice device = deviceIterator.next();
if (device.getProductId() == _productId && device.getVendorId() == _vendorId) {
_usbDevice = device;
_deviceName = _usbDevice.getDeviceName();
}
}
if (_usbDevice == null) {
Log("Cannot find the device. Did you forgot to plug it?");
Log(String.format("\t I search for VendorId: %s and ProductId: %s", _vendorId, _productId));
_connectionHandler.onDeviceNotFound();
return false;
}
// Create and intent and request a permission.
PendingIntent mPermissionIntent =
PendingIntent.getBroadcast(_context, 0, new Intent(ACTION_USB_PERMISSION), 0);
IntentFilter filter = new IntentFilter(ACTION_USB_PERMISSION);
_context.registerReceiver(mUsbReceiver, filter);
_usbManager.requestPermission(_usbDevice, mPermissionIntent);
Log("Found the device and requested permission.");
return true;
}
/**
* Iterate over all attached USB devices and look for Crazyradio. If Crazyradio is found, request
* permission.
*/
private static UsbDevice searchForCrazyradio(Context context, UsbManager usbManager) {
UsbDevice device = null;
HashMap<String, UsbDevice> deviceList = usbManager.getDeviceList();
// Iterate over USB devices
for (Entry<String, UsbDevice> e : deviceList.entrySet()) {
Log.i(
LOG_TAG,
"String: "
+ e.getKey()
+ " "
+ e.getValue().getVendorId()
+ " "
+ e.getValue().getProductId());
if (isCrazyradio(e.getValue())) {
device = e.getValue();
break; // stop after first matching device is found
}
}
if (device != null && !usbManager.hasPermission(device)) {
Log.d(LOG_TAG, "Request permission");
mPermissionIntent =
PendingIntent.getBroadcast(
context, 0, new Intent(context.getPackageName() + ".USB_PERMISSION"), 0);
usbManager.requestPermission(device, mPermissionIntent);
} else if (device != null && usbManager.hasPermission(device)) {
Log.d(LOG_TAG, "Has permission");
} else {
Log.d(LOG_TAG, "device == null");
}
return device;
}
@Override
public void onResume() {
super.onResume();
// Return if the streams are already initialized
if (mInputStream != null && mOutputStream != null) {
return;
}
// Initialize the streams
UsbAccessory[] accessories = mUsbManager.getAccessoryList();
UsbAccessory accessory = (accessories == null ? null : accessories[0]);
if (accessory != null) {
if (mUsbManager.hasPermission(accessory)) {
openAccessory(accessory);
} else {
synchronized (mUsbReceiver) {
if (!mPermissionRequestPending) {
mUsbManager.requestPermission(accessory, mPermissionIntent);
mPermissionRequestPending = true;
}
}
}
} else {
Log.d(TAG, "mAccessory is null");
}
}
/**
* デバイスの利用開始。
*
* @return null=正常、null以外=エラーメッセージ
*/
public String onStart(UsbDevice device) {
Log.d(TAG, "onStart:" + device);
if (!device.equals(usbDevice)) {
return "No device attach.";
}
if (!usbManager.hasPermission(usbDevice)) {
return "No device permission.";
}
usbConnection = usbManager.openDevice(usbDevice);
// TODO:インターフェースの検出は端折ってます。
UsbInterface usbIf = usbDevice.getInterface(INTERFACE_INDEX);
// EndPointの検索。分かってる場合は直接取り出しても良い。
for (int i = 0; i < usbIf.getEndpointCount(); i++) {
UsbEndpoint ep = usbIf.getEndpoint(i);
Log.d(TAG, "tye=" + ep.getType());
if (ep.getType() == UsbConstants.USB_ENDPOINT_XFER_INT) {
if (ep.getDirection() == UsbConstants.USB_DIR_IN) {
endpointIn = ep;
} else if (ep.getDirection() == UsbConstants.USB_DIR_OUT) {
endpointOut = ep;
}
}
}
if (endpointIn == null || endpointOut == null) {
Log.e(TAG, "Device has not IN/OUT Endpoint.");
return "Device has not IN/OUT Endpoint.";
}
// デバイスの確保
usbConnection.claimInterface(usbIf, true);
isReady = true;
return null;
}
@Override
protected void onResume() {
super.onResume();
setNames(); // in case name changed, we also want the name to update on its button
if (mInputStream != null && mOutputStream != null) {
return;
}
UsbAccessory accessories[] = mUsbManager.getAccessoryList();
UsbAccessory accessory = (accessories == null ? null : accessories[0]);
if (accessory != null) {
if (mUsbManager.hasPermission(accessory)) {
openAccessory(accessory);
} else {
synchronized (mUsbReceiver) {
if (!mPermissionRequestPending) {
mUsbManager.requestPermission(accessory, mPermissionIntent);
mPermissionRequestPending = true;
}
}
}
} else {
Log.d(TAG, "mAccessory is null");
debug.setText("didnt reopen accessory");
}
}
private void updateUsbNotification() {
if (mNotificationManager == null || !mUseUsbNotification) return;
int id = 0;
Resources r = mContext.getResources();
if (mConnected || mHostConnected) {
if (!mUsbDataUnlocked) {
id = com.android.internal.R.string.usb_charging_notification_title;
} else if (UsbManager.containsFunction(mCurrentFunctions, UsbManager.USB_FUNCTION_MTP)) {
id = com.android.internal.R.string.usb_mtp_notification_title;
} else if (UsbManager.containsFunction(mCurrentFunctions, UsbManager.USB_FUNCTION_PTP)) {
id = com.android.internal.R.string.usb_ptp_notification_title;
} else if (UsbManager.containsFunction(mCurrentFunctions, UsbManager.USB_FUNCTION_MIDI)) {
id = com.android.internal.R.string.usb_midi_notification_title;
} else if (UsbManager.containsFunction(
mCurrentFunctions, UsbManager.USB_FUNCTION_ACCESSORY)) {
id = com.android.internal.R.string.usb_accessory_notification_title;
} else {
id = com.android.internal.R.string.usb_charging_notification_title;
}
}
if (id != mUsbNotificationId) {
// clear notification if title needs changing
if (mUsbNotificationId != 0) {
mNotificationManager.cancelAsUser(null, mUsbNotificationId, UserHandle.ALL);
mUsbNotificationId = 0;
}
if (id != 0) {
CharSequence message = r.getText(com.android.internal.R.string.usb_notification_message);
CharSequence title = r.getText(id);
Intent intent =
Intent.makeRestartActivityTask(
new ComponentName(
"com.android.settings",
"com.android.settings.deviceinfo.UsbModeChooserActivity"));
PendingIntent pi =
PendingIntent.getActivityAsUser(mContext, 0, intent, 0, null, UserHandle.CURRENT);
Notification notification =
new Notification.Builder(mContext)
.setSmallIcon(com.android.internal.R.drawable.stat_sys_adb)
.setWhen(0)
.setOngoing(true)
.setTicker(title)
.setDefaults(0) // please be quiet
.setPriority(Notification.PRIORITY_MIN)
.setColor(
mContext.getColor(
com.android.internal.R.color.system_notification_accent_color))
.setContentTitle(title)
.setContentText(message)
.setContentIntent(pi)
.setVisibility(Notification.VISIBILITY_PUBLIC)
.build();
mNotificationManager.notifyAsUser(null, id, notification, UserHandle.ALL);
mUsbNotificationId = id;
}
}
}
private String applyAdbFunction(String functions) {
if (mAdbEnabled) {
functions = UsbManager.addFunction(functions, UsbManager.USB_FUNCTION_ADB);
} else {
functions = UsbManager.removeFunction(functions, UsbManager.USB_FUNCTION_ADB);
}
return functions;
}
private void setToMtpByDefault() {
UsbManager usbManager = (UsbManager) mContext.getSystemService(Context.USB_SERVICE);
StringBuilder builder = new StringBuilder();
builder.append(UsbManager.USB_FUNCTION_MTP);
builder.append(",");
builder.append(UsbManager.USB_FUNCTION_MASS_STORAGE);
String targetFunction = builder.toString();
usbManager.setCurrentFunction(targetFunction, true);
}
@Override
public void handleMessage(Message msg) {
synchronized (mLock) {
switch (msg.what) {
case MSG_UPDATE_STATE:
if (mConnected != mLastConnected || mConfiguration != mLastConfiguration) {
if (mConnected == 0) {
if (UsbManager.isFunctionEnabled(UsbManager.USB_FUNCTION_ACCESSORY)) {
// make sure accessory mode is off, and restore default functions
Log.d(TAG, "exited USB accessory mode");
if (!UsbManager.setFunctionEnabled(
UsbManager.USB_FUNCTION_ACCESSORY, false)) {
Log.e(TAG, "could not disable accessory function");
}
int count = mDefaultFunctions.size();
for (int i = 0; i < count; i++) {
String function = mDefaultFunctions.get(i);
if (!UsbManager.setFunctionEnabled(function, true)) {
Log.e(TAG, "could not reenable function " + function);
}
}
if (mCurrentAccessory != null) {
mDeviceManager.accessoryDetached(mCurrentAccessory);
mCurrentAccessory = null;
}
}
}
final ContentResolver cr = mContext.getContentResolver();
if (Settings.Secure.getInt(cr, Settings.Secure.DEVICE_PROVISIONED, 0) == 0) {
Slog.i(TAG, "Device not provisioned, skipping USB broadcast");
return;
}
mLastConnected = mConnected;
mLastConfiguration = mConfiguration;
// send a sticky broadcast containing current USB state
Intent intent = new Intent(UsbManager.ACTION_USB_STATE);
intent.addFlags(Intent.FLAG_RECEIVER_REPLACE_PENDING);
intent.putExtra(UsbManager.USB_CONNECTED, mConnected != 0);
intent.putExtra(UsbManager.USB_CONFIGURATION, mConfiguration);
addEnabledFunctionsLocked(intent);
mContext.sendStickyBroadcast(intent);
}
break;
case MSG_FUNCTION_ENABLED:
case MSG_FUNCTION_DISABLED:
functionEnabledLocked((String) msg.obj, msg.what == MSG_FUNCTION_ENABLED);
break;
}
}
}
int waitForUSBPermission() {
UsbManager manager = (UsbManager) getSystemService(Context.USB_SERVICE);
if (usbListener == null) return -1;
while (!usbListener.permissionGranted()) {
SystemClock.sleep(100);
}
UsbDevice depthCamera = usbListener.getDevice();
UsbDeviceConnection con = manager.openDevice(depthCamera);
return con.getFileDescriptor();
}
@Override
protected void onResume() {
super.onResume();
HashMap<String, UsbDevice> deviceList = mManager.getDeviceList();
Iterator<UsbDevice> deviceIterator = deviceList.values().iterator();
while (deviceIterator.hasNext()) {
UsbDevice device = deviceIterator.next();
if (device.getProductId() == PID && device.getVendorId() == VID) {
if (mManager.hasPermission(device)) mManager.requestPermission(device, mPermissionIntent);
break;
}
}
}
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
if (savedInstanceState == null) {
getFragmentManager()
.beginTransaction()
.add(R.id.container, new PlaceholderFragment())
.commit();
}
//
mUsbManager = (UsbManager) getSystemService(Context.USB_SERVICE);
//
filterAttached_and_Detached = new IntentFilter(UsbManager.ACTION_USB_ACCESSORY_DETACHED);
filterAttached_and_Detached.addAction(UsbManager.ACTION_USB_DEVICE_ATTACHED);
filterAttached_and_Detached.addAction(ACTION_USB_PERMISSION);
//
registerReceiver(mUsbReceiver, filterAttached_and_Detached);
//
HashMap<String, UsbDevice> deviceList = mUsbManager.getDeviceList();
Log.d("1", deviceList.size() + " USB device(s) found");
Iterator<UsbDevice> deviceIterator = deviceList.values().iterator();
while (deviceIterator.hasNext()) {
UsbDevice device = deviceIterator.next();
Log.d("1", "" + device);
}
}
public void setDevice(UsbManager usbManager, UsbDevice usbDevice) {
// Log.d(TAG, "setDevice " + usbDevice);
device = usbDevice;
if (device != null) {
usbDeviceDump(usbDevice);
UsbInterface controlInterface = device.getInterface(1);
endpoint = controlInterface.getEndpoint(0);
UsbDeviceConnection connection = usbManager.openDevice(device);
if (connection != null && connection.claimInterface(controlInterface, true)) {
controlConnection = connection;
serial = UsbSerialDevice.createUsbSerialDevice(device, controlConnection);
boolean t = serial.open();
Log.d("Set DEVICE : ", "" + t);
serial.setBaudRate(9600);
serial.setParity(UsbSerialInterface.PARITY_NONE);
serial.setStopBits(UsbSerialInterface.STOP_BITS_1);
serial.setDataBits(UsbSerialInterface.DATA_BITS_8);
} else {
Log.e(TAG, "open connection FAIL");
controlConnection = null;
}
}
}
private UsbDevice findDevice() {
HashMap<String, UsbDevice> devList = mUsbManager.getDeviceList();
for (UsbDevice dev : devList.values()) {
Log.d(
TAG,
"Dev: "
+ dev
+ " "
+ dev.hashCode()
+ " "
+ dev.getVendorId()
+ " "
+ dev.getProductId()
+ " "
+ dev.getDeviceId()
+ " "
+ dev.getDeviceName());
if (isCSCID(dev)) {
return dev;
}
}
return null;
}
private void setDevice(UsbDevice device) {
mConnection = mUsbManager.openDevice(device);
intf = device.getInterface(0);
UsbEndpoint epOut = null;
UsbEndpoint epIn = null;
UsbEndpoint epEv = null;
// Looking for Bulk Endpoints
for (int i = 0; i < intf.getEndpointCount(); i++) {
UsbEndpoint ep = intf.getEndpoint(i);
if (ep.getType() == UsbConstants.USB_ENDPOINT_XFER_BULK) {
if (ep.getDirection() == UsbConstants.USB_DIR_OUT) {
epOut = ep;
} else {
epIn = ep;
}
}
if (ep.getType() == UsbConstants.USB_ENDPOINT_XFER_INT) {
epEv = ep;
}
}
if (epOut == null || epIn == null || epEv == null) {
throw new IllegalArgumentException("not all endpoints found");
}
mEndpointBulkOut = epOut;
mEndpointBulkIn = epIn;
mEndpointIntr = epEv;
inMaxPS = mEndpointBulkIn.getMaxPacketSize();
}
@Override
public void onReceive(Context arg0, Intent arg1) {
if (arg1.getAction().equals(ACTION_USB_PERMISSION)) {
boolean granted = arg1.getExtras().getBoolean(UsbManager.EXTRA_PERMISSION_GRANTED);
if (granted) // User accepted our USB connection. Try to open the device as a serial
// port
{
Intent intent = new Intent(ACTION_USB_PERMISSION_GRANTED);
arg0.sendBroadcast(intent);
connection = usbManager.openDevice(device);
serialPortConnected = true;
new ConnectionThread().run();
} else // User not accepted our USB connection. Send an Intent to the Main Activity
{
Intent intent = new Intent(ACTION_USB_PERMISSION_NOT_GRANTED);
arg0.sendBroadcast(intent);
}
} else if (arg1.getAction().equals(ACTION_USB_ATTACHED)) {
if (!serialPortConnected)
findSerialPortDevice(); // A USB device has been attached. Try to open it as a Serial
// port
} else if (arg1.getAction().equals(ACTION_USB_DETACHED)) {
// Usb device was disconnected. send an intent to the Main Activity
Intent intent = new Intent(ACTION_USB_DISCONNECTED);
arg0.sendBroadcast(intent);
serialPortConnected = false;
serialPort.close();
}
}
private void findSerialPortDevice() {
// This snippet will try to open the first encountered usb device connected, excluding usb root
// hubs
HashMap<String, UsbDevice> usbDevices = usbManager.getDeviceList();
if (!usbDevices.isEmpty()) {
boolean keep = true;
for (Map.Entry<String, UsbDevice> entry : usbDevices.entrySet()) {
device = entry.getValue();
int deviceVID = device.getVendorId();
int devicePID = device.getProductId();
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(ACTION_NO_USB);
sendBroadcast(intent);
}
} else {
// There is no USB devices connected. Send an intent to MainActivity
Intent intent = new Intent(ACTION_NO_USB);
sendBroadcast(intent);
}
}
/**
* デバイスの接続通知。
*
* @return null=正常、null以外=エラーメッセージ
*/
public String onAttach(UsbDevice device) {
Log.d(TAG, "onAttach:" + device);
usbDevice = device;
if (usbDevice == null) {
Log.e(TAG, "Not found USB Device.");
return "Not found USB Device.";
}
if (usbManager.hasPermission(usbDevice)) {
return onStart(usbDevice);
} else {
// デバイスの利用許可をユーザに求める。
// 結果は UsbReceiver.onReceive()にコールバック。
usbManager.requestPermission(usbDevice, permissionIntent);
}
return null;
}
private void updateAudioSourceFunction() {
boolean enabled =
UsbManager.containsFunction(mCurrentFunctions, UsbManager.USB_FUNCTION_AUDIO_SOURCE);
if (enabled != mAudioSourceEnabled) {
int card = -1;
int device = -1;
if (enabled) {
Scanner scanner = null;
try {
scanner = new Scanner(new File(AUDIO_SOURCE_PCM_PATH));
card = scanner.nextInt();
device = scanner.nextInt();
} catch (FileNotFoundException e) {
Slog.e(TAG, "could not open audio source PCM file", e);
} finally {
if (scanner != null) {
scanner.close();
}
}
}
mUsbAlsaManager.setAccessoryAudioState(enabled, card, device);
mAudioSourceEnabled = enabled;
}
}
public String Open_USB_Port() {
List<UsbSerialDriver> availableDrivers =
UsbSerialProber.getDefaultProber().findAllDrivers(mUsbManager);
String message = "null";
if (availableDrivers.isEmpty()) {
Log.v(TAG, "No USB Drivers connected");
return "No Drivers Detected";
}
final UsbSerialDriver driver = availableDrivers.get(0);
connection = mUsbManager.openDevice(driver.getDevice());
if (connection == null) {
Log.v(TAG, "No USB connection found");
return "No USB Available";
} else {
final List<UsbSerialPort> portList = driver.getPorts();
port = portList.get(0);
try {
port.open(connection);
port.setParameters(38400, 8, UsbSerialPort.STOPBITS_1, UsbSerialPort.PARITY_NONE);
return "USB Connected";
} catch (IOException e) {
System.out.print("Can't Connect to ELM327!");
// alertView("Connection Problem", "Can't find the ELM327");
}
}
return message;
}
/**
* Creates and returns a new {@link UsbSerialDriver} instance for the first compatible {@link
* UsbDevice} found on the bus. If none are found, returns {@code null}.
*
* <p>The order of devices is undefined, therefore if there are multiple devices on the bus, the
* chosen device may not be predictable (clients should use {@link #findAllDevices(UsbManager)}
* instead).
*
* @param usbManager the {@link UsbManager} to use.
* @return the first available {@link UsbSerialDriver}, or {@code null} if none are available.
*/
public static UsbSerialDriver findFirstDevice(final UsbManager usbManager) {
for (final UsbDevice usbDevice : usbManager.getDeviceList().values()) {
for (final UsbSerialProber prober : values()) {
final List<UsbSerialDriver> probedDevices = prober.probe(usbManager, usbDevice);
if (!probedDevices.isEmpty()) {
return probedDevices.get(0);
}
}
}
return null;
}
/**
* Creates a new {@link UsbSerialDriver} instance for all compatible {@link UsbDevice}s found on
* the bus. If no compatible devices are found, the list will be empty.
*
* @param usbManager
* @return
*/
public static List<UsbSerialDriver> findAllDevices(final UsbManager usbManager) {
final List<UsbSerialDriver> result = new ArrayList<UsbSerialDriver>();
// Log.i("QGC_UsbSerialProber", "Looking for USB devices");
// For each UsbDevice, call probe() for each prober.
for (final UsbDevice usbDevice : usbManager.getDeviceList().values()) {
// Log.i("QGC_UsbSerialProber", "Probing device: " + usbDevice.getDeviceName() + " mid: " +
// usbDevice.getVendorId() + " pid: " + usbDevice.getDeviceId());
result.addAll(probeSingleDevice(usbManager, usbDevice));
}
return result;
}
@Override
public List<UsbSerialDriver> probe(final UsbManager manager, final UsbDevice usbDevice) {
if (!testIfSupported(usbDevice, Cp2102SerialDriver.getSupportedDevices())) {
return Collections.emptyList();
}
final UsbDeviceConnection connection = manager.openDevice(usbDevice);
if (connection == null) {
return Collections.emptyList();
}
final UsbSerialDriver driver = new Cp2102SerialDriver(usbDevice, connection);
return Collections.singletonList(driver);
}
private static UsbDevice findDevice(UsbManager usbManager, int venderId, int productId) {
HashMap<String, UsbDevice> deviceList = usbManager.getDeviceList();
Iterator<UsbDevice> deviceIterator = deviceList.values().iterator();
while (deviceIterator.hasNext()) {
UsbDevice d = deviceIterator.next();
Log.d(TAG, "device=" + d);
if (d.getVendorId() == venderId && d.getProductId() == productId) {
return d;
}
}
return null;
}
// initializes the usb connection to the arduino
// returns the the status to be displayed on the GUI
public static String start(Context context) {
Log.i(TAG, "Starting ArduinoController");
// set up usb manager
if (usbManager == null) usbManager = (UsbManager) context.getSystemService(Context.USB_SERVICE);
// get all available usb drivers
Log.i(TAG, "Listing Drivers");
SystemClock.sleep(1000);
List<UsbSerialDriver> drivers = UsbSerialProber.getDefaultProber().findAllDrivers(usbManager);
if (drivers.isEmpty()) {
Log.i(TAG, "No drivers found!");
return "No drivers found!";
}
// look for a supported usb driver
Log.i(TAG, "Drivers found: " + drivers.toString());
arduinoPort = drivers.get(0).getPorts().get(0); // assume first one is the arduino
if (arduinoPort == null) {
Log.i(TAG, "Did not find arduino device.");
return "Arduino Not Found!";
}
// open the usb device
UsbDevice device = arduinoPort.getDriver().getDevice();
Log.i(TAG, "Connected to productID: " + device.getVendorId());
UsbDeviceConnection connection = usbManager.openDevice(device);
if (connection == null) {
Log.i(TAG, "Could not open device");
return "Opening device failed!";
}
// open usb connection and set parity and baud rate
try {
arduinoPort.open(connection);
// set to send over 8 bits
arduinoPort.setParameters(
9600, UsbSerialPort.DATABITS_8, UsbSerialPort.STOPBITS_1, UsbSerialPort.PARITY_NONE);
} catch (IOException e) {
String result = "Error opening device: " + e.getMessage();
Log.i(TAG, result);
try {
arduinoPort.close();
} catch (IOException e2) {
// Ignore
}
return result;
}
onDeviceStateChange(); // Restart the IO manager
return "Connected to: " + arduinoPort.getClass().getSimpleName();
}
private void openAccessory(UsbAccessory accessory) {
mFileDescriptor = mUsbManager.openAccessory(accessory);
if (mFileDescriptor != null) {
mAccessory = accessory;
FileDescriptor fd = mFileDescriptor.getFileDescriptor();
mInputStream = new FileInputStream(fd);
mOutputStream = new FileOutputStream(fd);
Log.d(TAG, "accessory opened");
} else {
Log.d(TAG, "accessory open fail");
}
}
public ZBCoordinator(Context context, String actionUsbPermission) {
super();
UsbManager manager = (UsbManager) context.getSystemService(Context.USB_SERVICE);
HashMap<String, UsbDevice> deviceList = manager.getDeviceList();
Iterator<UsbDevice> deviceIterator = deviceList.values().iterator();
UsbDevice device = null;
while (deviceIterator.hasNext()) {
UsbDevice devi = deviceIterator.next();
// TODO Remove hardcoded IDs
if (devi.getProductId() == 0x05dc && devi.getVendorId() == 0x16c0) device = devi;
// TODO Make sure this is the ZBCoordinator using RAW Descriptors
}
PendingIntent mPermissionIntent =
PendingIntent.getBroadcast(context, 0, new Intent(actionUsbPermission), 0);
if (device != null && !manager.hasPermission(device))
manager.requestPermission(device, mPermissionIntent);
if (device != null && manager.hasPermission(device)) {
UsbInterface intf = device.getInterface(0);
this.endpointInt = intf.getEndpoint(0);
this.usbDeviceConnection = manager.openDevice(device);
this.usbDeviceConnection.claimInterface(intf, false);
this.canUse = true;
}
}
// GIVEN FUNCTIONS
private void openAccessory(UsbAccessory mAccessory2) {
mFileDescriptor = mUsbManager.openAccessory(mAccessory2);
if (mFileDescriptor != null) {
mAccessory = mAccessory2;
FileDescriptor fd = mFileDescriptor.getFileDescriptor();
mInputStream = new FileInputStream(fd);
mOutputStream = new FileOutputStream(fd);
Log.d(TAG, "accessory opened");
} else {
Log.d(TAG, "accessory open fail");
debug.setText("did not open");
}
}
