target sdk 35

Used separate threads for reading and writing, enhancing concurrency and performance.

Note: before was possible to start `SerialInputOutputManager` with `Executors.newSingleThreadExecutor().submit(ioManager)`. Now you have to use `ioManager.start()`

.github/workflows/build.yml

@@ -0,0 +1,17 @@
+name: build
+
+on: [push]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v3
+    - uses: actions/setup-java@v3
+      with:
+        distribution: 'temurin'
+        java-version: '17'
+    - name: Build with Gradle
+      run: ./gradlew assembleDebug

.gitignore

@@ -1,9 +1,43 @@
-UsbSerialLibrary/bin
-UsbSerialLibrary/gen
+# Built application files
+*.apk
+*.ap_
 
-UsbSerialExamples/bin
-UsbSerialExamples/gen
-UsbSerialLibrary/dictionary.txt
-UsbSerialLibrary/local.properties
-UsbSerialLibrary/proguard-project.txt
-UsbSerialLibrary/build.xml
+# Files for the Dalvik VM
+*.dex
+
+# Java class files
+*.class
+
+# Generated files
+bin/
+gen/
+
+# Studio/Gradle
+*.iml
+.gradle/
+build/
+
+# User-specific stuff:
+.idea/workspace.xml
+.idea/tasks.xml
+.idea/dictionaries
+.idea/markdown-navigator*.xml
+
+# Sensitive or high-churn files:
+.idea/dataSources.ids
+.idea/dataSources.xml
+.idea/sqlDataSources.xml
+.idea/dynamic.xml
+.idea/uiDesigner.xml
+
+# Gradle:
+.idea/gradle.xml
+.idea/libraries
+.idea/jarRepositories.xml
+
+# Eclipse/Android/Misc
+.metadata/
+local.properties
+*.DS_Store
+proguard/
+jacoco.exec

.idea/.gitignore

@@ -0,0 +1,9 @@
+caches
+codeStyles
+libraries
+workspace.xml
+androidTestResultsUserPreferences.xml
+appInsightsSettings.xml
+deploymentTargetDropDown.xml
+deploymentTargetSelector.xml
+other.xml

.idea/AndroidProjectSystem.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="AndroidProjectSystem">
+    <option name="providerId" value="com.android.tools.idea.GradleProjectSystem" />
+  </component>
+</project>

.idea/compiler.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="CompilerConfiguration">
+    <bytecodeTargetLevel target="21" />
+  </component>
+</project>

.idea/misc.xml

@@ -0,0 +1,61 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ExternalStorageConfigurationManager" enabled="true" />
+  <component name="NullableNotNullManager">
+    <option name="myDefaultNullable" value="androidx.annotation.Nullable" />
+    <option name="myDefaultNotNull" value="androidx.annotation.NonNull" />
+    <option name="myNullables">
+      <value>
+        <list size="18">
+          <item index="0" class="java.lang.String" itemvalue="org.jetbrains.annotations.Nullable" />
+          <item index="1" class="java.lang.String" itemvalue="javax.annotation.Nullable" />
+          <item index="2" class="java.lang.String" itemvalue="javax.annotation.CheckForNull" />
+          <item index="3" class="java.lang.String" itemvalue="edu.umd.cs.findbugs.annotations.Nullable" />
+          <item index="4" class="java.lang.String" itemvalue="android.support.annotation.Nullable" />
+          <item index="5" class="java.lang.String" itemvalue="androidx.annotation.Nullable" />
+          <item index="6" class="java.lang.String" itemvalue="androidx.annotation.RecentlyNullable" />
+          <item index="7" class="java.lang.String" itemvalue="android.annotation.Nullable" />
+          <item index="8" class="java.lang.String" itemvalue="org.checkerframework.checker.nullness.qual.Nullable" />
+          <item index="9" class="java.lang.String" itemvalue="org.checkerframework.checker.nullness.compatqual.NullableDecl" />
+          <item index="10" class="java.lang.String" itemvalue="org.checkerframework.checker.nullness.compatqual.NullableType" />
+          <item index="11" class="java.lang.String" itemvalue="com.android.annotations.Nullable" />
+          <item index="12" class="java.lang.String" itemvalue="org.eclipse.jdt.annotation.Nullable" />
+          <item index="13" class="java.lang.String" itemvalue="io.reactivex.annotations.Nullable" />
+          <item index="14" class="java.lang.String" itemvalue="io.reactivex.rxjava3.annotations.Nullable" />
+          <item index="15" class="java.lang.String" itemvalue="org.jspecify.nullness.Nullable" />
+          <item index="16" class="java.lang.String" itemvalue="jakarta.annotation.Nullable" />
+          <item index="17" class="java.lang.String" itemvalue="org.jspecify.annotations.Nullable" />
+        </list>
+      </value>
+    </option>
+    <option name="myNotNulls">
+      <value>
+        <list size="17">
+          <item index="0" class="java.lang.String" itemvalue="org.jetbrains.annotations.NotNull" />
+          <item index="1" class="java.lang.String" itemvalue="javax.annotation.Nonnull" />
+          <item index="2" class="java.lang.String" itemvalue="edu.umd.cs.findbugs.annotations.NonNull" />
+          <item index="3" class="java.lang.String" itemvalue="android.support.annotation.NonNull" />
+          <item index="4" class="java.lang.String" itemvalue="androidx.annotation.NonNull" />
+          <item index="5" class="java.lang.String" itemvalue="androidx.annotation.RecentlyNonNull" />
+          <item index="6" class="java.lang.String" itemvalue="android.annotation.NonNull" />
+          <item index="7" class="java.lang.String" itemvalue="org.checkerframework.checker.nullness.qual.NonNull" />
+          <item index="8" class="java.lang.String" itemvalue="org.checkerframework.checker.nullness.compatqual.NonNullDecl" />
+          <item index="9" class="java.lang.String" itemvalue="org.checkerframework.checker.nullness.compatqual.NonNullType" />
+          <item index="10" class="java.lang.String" itemvalue="com.android.annotations.NonNull" />
+          <item index="11" class="java.lang.String" itemvalue="org.eclipse.jdt.annotation.NonNull" />
+          <item index="12" class="java.lang.String" itemvalue="io.reactivex.annotations.NonNull" />
+          <item index="13" class="java.lang.String" itemvalue="io.reactivex.rxjava3.annotations.NonNull" />
+          <item index="14" class="java.lang.String" itemvalue="jakarta.annotation.Nonnull" />
+          <item index="15" class="java.lang.String" itemvalue="org.jspecify.nullness.NonNull" />
+          <item index="16" class="java.lang.String" itemvalue="org.jspecify.annotations.NonNull" />
+        </list>
+      </value>
+    </option>
+  </component>
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_21" default="true" project-jdk-name="jbr-21" project-jdk-type="JavaSDK">
+    <output url="file://$PROJECT_DIR$/build/classes" />
+  </component>
+  <component name="ProjectType">
+    <option name="id" value="Android" />
+  </component>
+</project>

.idea/runConfigurations.xml

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="RunConfigurationProducerService">
+    <option name="ignoredProducers">
+      <set>
+        <option value="com.intellij.execution.junit.AbstractAllInDirectoryConfigurationProducer" />
+        <option value="com.intellij.execution.junit.AllInPackageConfigurationProducer" />
+        <option value="com.intellij.execution.junit.PatternConfigurationProducer" />
+        <option value="com.intellij.execution.junit.TestInClassConfigurationProducer" />
+        <option value="com.intellij.execution.junit.UniqueIdConfigurationProducer" />
+        <option value="com.intellij.execution.junit.testDiscovery.JUnitTestDiscoveryConfigurationProducer" />
+        <option value="org.jetbrains.kotlin.idea.junit.KotlinJUnitRunConfigurationProducer" />
+        <option value="org.jetbrains.kotlin.idea.junit.KotlinPatternConfigurationProducer" />
+      </set>
+    </option>
+  </component>
+</project>

.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="" vcs="Git" />
+  </component>
+</project>

CHANGELOG.txt

@@ -1,3 +1,20 @@
-2011-12-28  mike wakerly  <opensource@hoho.com>
+For recent changelog look here:
+  * https://github.com/mik3y/usb-serial-for-android/releases
 
-	* Initial release.
+v0.2.0 (unreleased)
+  * Gradle, Android Studio support.
+  * New driver: CP2102 (thanks Ducky).
+  * New prober support: LUFA Virtual Serial, Leaflabs Maple, Teensyduino.
+  * New driver methods: getCD, getCTS, getDSR, getDTR, setDTR, getRI, getRTS,
+    setRTS.
+  * API change: setBaudrate() has been removed; use setParameters().
+  * API change: open() no longer implicitly sets the baud rate.  Clients should
+    call setParameters() immediately after open(), when necessary.
+  * Library version is available in `com.hoho.android.usbserial.BuildInfo`.
+
+v0.1.0 (2012-10-12)
+  * New driver: CdcAcmSerialDriver.
+  * Better tuned read and write buffer sizes.
+
+v0.0.1 (2011-12-28)
+  * Initial release.

LICENSE.txt

@@ -1,165 +1,22 @@
-                   GNU LESSER GENERAL PUBLIC LICENSE
-                       Version 3, 29 June 2007
+MIT License
 
- Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
+Copyright (c) 2011-2013 Google Inc.
+Copyright (c) 2013 Mike Wakerly
 
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
 
-  This version of the GNU Lesser General Public License incorporates
-the terms and conditions of version 3 of the GNU General Public
-License, supplemented by the additional permissions listed below.
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
 
-  0. Additional Definitions.
-
-  As used herein, "this License" refers to version 3 of the GNU Lesser
-General Public License, and the "GNU GPL" refers to version 3 of the GNU
-General Public License.
-
-  "The Library" refers to a covered work governed by this License,
-other than an Application or a Combined Work as defined below.
-
-  An "Application" is any work that makes use of an interface provided
-by the Library, but which is not otherwise based on the Library.
-Defining a subclass of a class defined by the Library is deemed a mode
-of using an interface provided by the Library.
-
-  A "Combined Work" is a work produced by combining or linking an
-Application with the Library.  The particular version of the Library
-with which the Combined Work was made is also called the "Linked
-Version".
-
-  The "Minimal Corresponding Source" for a Combined Work means the
-Corresponding Source for the Combined Work, excluding any source code
-for portions of the Combined Work that, considered in isolation, are
-based on the Application, and not on the Linked Version.
-
-  The "Corresponding Application Code" for a Combined Work means the
-object code and/or source code for the Application, including any data
-and utility programs needed for reproducing the Combined Work from the
-Application, but excluding the System Libraries of the Combined Work.
-
-  1. Exception to Section 3 of the GNU GPL.
-
-  You may convey a covered work under sections 3 and 4 of this License
-without being bound by section 3 of the GNU GPL.
-
-  2. Conveying Modified Versions.
-
-  If you modify a copy of the Library, and, in your modifications, a
-facility refers to a function or data to be supplied by an Application
-that uses the facility (other than as an argument passed when the
-facility is invoked), then you may convey a copy of the modified
-version:
-
-   a) under this License, provided that you make a good faith effort to
-   ensure that, in the event an Application does not supply the
-   function or data, the facility still operates, and performs
-   whatever part of its purpose remains meaningful, or
-
-   b) under the GNU GPL, with none of the additional permissions of
-   this License applicable to that copy.
-
-  3. Object Code Incorporating Material from Library Header Files.
-
-  The object code form of an Application may incorporate material from
-a header file that is part of the Library.  You may convey such object
-code under terms of your choice, provided that, if the incorporated
-material is not limited to numerical parameters, data structure
-layouts and accessors, or small macros, inline functions and templates
-(ten or fewer lines in length), you do both of the following:
-
-   a) Give prominent notice with each copy of the object code that the
-   Library is used in it and that the Library and its use are
-   covered by this License.
-
-   b) Accompany the object code with a copy of the GNU GPL and this license
-   document.
-
-  4. Combined Works.
-
-  You may convey a Combined Work under terms of your choice that,
-taken together, effectively do not restrict modification of the
-portions of the Library contained in the Combined Work and reverse
-engineering for debugging such modifications, if you also do each of
-the following:
-
-   a) Give prominent notice with each copy of the Combined Work that
-   the Library is used in it and that the Library and its use are
-   covered by this License.
-
-   b) Accompany the Combined Work with a copy of the GNU GPL and this license
-   document.
-
-   c) For a Combined Work that displays copyright notices during
-   execution, include the copyright notice for the Library among
-   these notices, as well as a reference directing the user to the
-   copies of the GNU GPL and this license document.
-
-   d) Do one of the following:
-
-       0) Convey the Minimal Corresponding Source under the terms of this
-       License, and the Corresponding Application Code in a form
-       suitable for, and under terms that permit, the user to
-       recombine or relink the Application with a modified version of
-       the Linked Version to produce a modified Combined Work, in the
-       manner specified by section 6 of the GNU GPL for conveying
-       Corresponding Source.
-
-       1) Use a suitable shared library mechanism for linking with the
-       Library.  A suitable mechanism is one that (a) uses at run time
-       a copy of the Library already present on the user's computer
-       system, and (b) will operate properly with a modified version
-       of the Library that is interface-compatible with the Linked
-       Version.
-
-   e) Provide Installation Information, but only if you would otherwise
-   be required to provide such information under section 6 of the
-   GNU GPL, and only to the extent that such information is
-   necessary to install and execute a modified version of the
-   Combined Work produced by recombining or relinking the
-   Application with a modified version of the Linked Version. (If
-   you use option 4d0, the Installation Information must accompany
-   the Minimal Corresponding Source and Corresponding Application
-   Code. If you use option 4d1, you must provide the Installation
-   Information in the manner specified by section 6 of the GNU GPL
-   for conveying Corresponding Source.)
-
-  5. Combined Libraries.
-
-  You may place library facilities that are a work based on the
-Library side by side in a single library together with other library
-facilities that are not Applications and are not covered by this
-License, and convey such a combined library under terms of your
-choice, if you do both of the following:
-
-   a) Accompany the combined library with a copy of the same work based
-   on the Library, uncombined with any other library facilities,
-   conveyed under the terms of this License.
-
-   b) Give prominent notice with the combined library that part of it
-   is a work based on the Library, and explaining where to find the
-   accompanying uncombined form of the same work.
-
-  6. Revised Versions of the GNU Lesser General Public License.
-
-  The Free Software Foundation may publish revised and/or new versions
-of the GNU Lesser General Public License from time to time. Such new
-versions will be similar in spirit to the present version, but may
-differ in detail to address new problems or concerns.
-
-  Each version is given a distinguishing version number. If the
-Library as you received it specifies that a certain numbered version
-of the GNU Lesser General Public License "or any later version"
-applies to it, you have the option of following the terms and
-conditions either of that published version or of any later version
-published by the Free Software Foundation. If the Library as you
-received it does not specify a version number of the GNU Lesser
-General Public License, you may choose any version of the GNU Lesser
-General Public License ever published by the Free Software Foundation.
-
-  If the Library as you received it specifies that a proxy can decide
-whether future versions of the GNU Lesser General Public License shall
-apply, that proxy's public statement of acceptance of any version is
-permanent authorization for you to choose that version for the
-Library.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,81 +1,179 @@
+[![Actions Status](https://github.com/mik3y/usb-serial-for-android/workflows/build/badge.svg)](https://github.com/mik3y/usb-serial-for-android/actions)
+[![Jitpack](https://jitpack.io/v/mik3y/usb-serial-for-android.svg)](https://jitpack.io/#mik3y/usb-serial-for-android)
+[![Codacy](https://app.codacy.com/project/badge/Grade/ef799bba8a7343818af0a90eba3ecb46)](https://app.codacy.com/gh/kai-morich/usb-serial-for-android-mik3y/dashboard?utm_source=gh&utm_medium=referral&utm_content=&utm_campaign=Badge_grade)
+[![codecov](https://codecov.io/gh/mik3y/usb-serial-for-android/branch/master/graph/badge.svg)](https://codecov.io/gh/mik3y/usb-serial-for-android)
+
 # usb-serial-for-android
 
-Library for talking to Arduinos and other USB serial devices on Android, using
-USB Host mode and Android 3.1+
+This is a driver library for communication with Arduinos and other USB serial hardware on
+Android, using the
+[Android USB Host Mode (OTG)](http://developer.android.com/guide/topics/connectivity/usb/host.html)
+available since Android 3.1 and working reliably since Android 4.2.
 
-Homepage: http://code.google.com/p/usb-serial-for-android
+No root access, ADK, or special kernel drivers are required; all drivers are implemented in
+Java.  You get a raw serial port with `read()`, `write()`, and [other functions](https://github.com/mik3y/usb-serial-for-android/wiki/FAQ#Feature_Matrix) for use with your own protocols.
 
-## About
+## Quick Start
 
-This project provides an Android userspace driver for USB serial devices.  You
-can use it to talk to your Arduino, or any other supported serial devices.
+**1.** Add library to your project:
 
-## Usage
+Add jitpack.io repository to your root build.gradle:
+```gradle
+allprojects {
+    repositories {
+        ...
+        maven { url 'https://jitpack.io' }
+    }
+}
+```
 
-Download the sources.  Inside you will find two Eclipse projects:
+Starting with gradle 6.8 you can alternatively add jitpack.io repository to your settings.gradle:
+```gradle
+dependencyResolutionManagement {
+    repositories {
+        ...
+        maven { url 'https://jitpack.io' }
+    }
+}
+```
 
-* UsbSerialLibrary - the main library code, an "Android Library" project.
-* UsbSerialExamples - a demo Android application
+If using gradle kotlin  use line
+```gradle.kts
+        maven(url = "https://jitpack.io")
+```
 
-In Eclipse, open "File", "Import", and then select "General, "Existing Projects
-into Workspace".
+Add library to dependencies
+```gradle
+dependencies {
+    implementation 'com.github.mik3y:usb-serial-for-android:3.9.0'
+}
+```
 
-Navigate to the directory you just checked out and import both projects.  Then
-run the demo application.
+**2.** If the app should be notified when a device is attached, add 
+[device_filter.xml](https://github.com/mik3y/usb-serial-for-android/blob/master/usbSerialExamples/src/main/res/xml/device_filter.xml) 
+to your project's `res/xml/` directory and configure in your `AndroidManifest.xml`.
 
+```xml
+<activity
+    android:name="..."
+    ...>
+    <intent-filter>
+        <action android:name="android.hardware.usb.action.USB_DEVICE_ATTACHED" />
+    </intent-filter>
+    <meta-data
+        android:name="android.hardware.usb.action.USB_DEVICE_ATTACHED"
+        android:resource="@xml/device_filter" />
+</activity>
+```
 
-## Compatible Serial Devices
+**3.** Use it! Example code snippet:
 
-Supported and tested:
+open device:
+```java
+    // Find all available drivers from attached devices.
+    UsbManager manager = (UsbManager) getSystemService(Context.USB_SERVICE);
+    List<UsbSerialDriver> availableDrivers = UsbSerialProber.getDefaultProber().findAllDrivers(manager);
+    if (availableDrivers.isEmpty()) {
+        return;
+    }
 
-*   FT232R
+    // Open a connection to the first available driver.
+    UsbSerialDriver driver = availableDrivers.get(0);
+    UsbDeviceConnection connection = manager.openDevice(driver.getDevice());
+    if (connection == null) {
+        // add UsbManager.requestPermission(driver.getDevice(), ..) handling here
+        return;
+    }
 
-Possibly supported (untested):
+    UsbSerialPort port = driver.getPorts().get(0); // Most devices have just one port (port 0)
+    port.open(connection);
+    port.setParameters(115200, 8, UsbSerialPort.STOPBITS_1, UsbSerialPort.PARITY_NONE);
+```
+then use direct read/write
+```java
+    port.write(request, WRITE_WAIT_MILLIS);
+    len = port.read(response, READ_WAIT_MILLIS);
+```
+or direct write + event driven read:
+```java
+    usbIoManager = new SerialInputOutputManager(usbSerialPort, this);
+    usbIoManager.start();
+    ...
+    port.write("hello".getBytes(), WRITE_WAIT_MILLIS);
     
-*   FT232H
-*   FT2232D
-*   FT2432H
+@Override
+public void onNewData(byte[] data) {
+    runOnUiThread(() -> { textView.append(new String(data)); });
+}
+```
+and finally:
+```java
+    port.close();
+```
 
-Unsupported (send patches!):
+For a simple example, see
+[UsbSerialExamples](https://github.com/mik3y/usb-serial-for-android/blob/master/usbSerialExamples)
+folder in this project.
 
-*   Arduino Uno (CDC)
+See separate github project [SimpleUsbTerminal](https://github.com/kai-morich/SimpleUsbTerminal) 
+for a more complete example with:
+* Background service to stay connected while the app is not visible or rotating
+* Flow control 
 
+## Probing for Unrecognized Devices
 
-## Compatible Android Devices
+Sometimes you may need to do a little extra work to support devices which
+usb-serial-for-android doesn't (yet) know about -- but which you know to be
+compatible with one of the built-in drivers.  This may be the case for a brand
+new device or for one using a custom VID/PID pair.
 
-Supported and tested:
+UsbSerialProber is a class to help you find and instantiate compatible
+UsbSerialDrivers from the tree of connected UsbDevices.  Normally, you will use
+the default prober returned by ``UsbSerialProber.getDefaultProber()``, which
+uses USB interface types and the built-in list of well-known VIDs and PIDs that
+are supported by our drivers.
 
-*   Motorola Xoom, Android 3.1/3.2
+To use your own set of rules, create and use a custom prober:
 
-Possibly supported (untested):
+```java
+// Probe for our custom FTDI device, which use VID 0x1234 and PID 0x0001 and 0x0002.
+ProbeTable customTable = new ProbeTable();
+customTable.addProduct(0x1234, 0x0001, FtdiSerialDriver.class);
+customTable.addProduct(0x1234, 0x0002, FtdiSerialDriver.class);
 
-*   Samsung Galaxy Tab 10.1
+UsbSerialProber prober = new UsbSerialProber(customTable);
+List<UsbSerialDriver> drivers = prober.findAllDrivers(usbManager);
+// ...
+```
+*Note*: as of v3.5.0 this library detects CDC/ACM devices by USB interface types instead of fixed VID+PID,
+so custom probers are typically not required any more for CDC/ACM devices.
 
+Of course, nothing requires you to use UsbSerialProber at all: you can
+instantiate driver classes directly if you know what you're doing; just supply
+a compatible UsbDevice.
 
-## License and Copyright
+## Compatible Devices
 
-This library is licensed under LGPL Version 2.1.  Please see LICENSE.txt for the
-complete license.
+This library supports USB to serial converter chips with specific drivers
+* FTDI FT232R, FT232H, FT2232H, FT4232H, FT230X, FT231X, FT234XD
+* Prolific PL2303
+* Silabs CP2102, CP210*
+* Qinheng CH340, CH341A
 
-Copyright 2011, Google Inc. All Rights Reserved.
+some other device specific drivers
+* GsmModem devices, e.g. for Unisoc based Fibocom GSM modems
+* Chrome OS CCD (Closed Case Debugging)
 
-Portions of this library are based on libftdi
-(http://www.intra2net.com/en/developer/libftdi).  Please see
-FtdiSerialDriver.java for more information.
+and devices implementing the generic CDC/ACM protocol like
+* Qinheng CH9102
+* Microchip MCP2221
+* Arduino using ATmega32U4
+* Digispark using V-USB software USB
+* ...
 
+## Help & Discussion
 
-## Contributing
-
-Patches are welcome.  We're especially interested in supporting more devices.
-Please open a bug report.
-
-
-## Credits
-
-Author/maintainer: mike wakerly <opensource@hoho.com>
-
-Contributors:
-
-*   Robert Tsai <rob@tsaiberspace.com> (code review)
-
+For common problems, see the [FAQ](https://github.com/mik3y/usb-serial-for-android/wiki/FAQ) wiki page.
 
+Are you using the library? Add your project to 
+[ProjectsUsingUsbSerialForAndroid](https://github.com/mik3y/usb-serial-for-android/wiki/Projects-Using-usb-serial-for-android).

UsbSerialExamples/.classpath

@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<classpath>
-	<classpathentry combineaccessrules="false" kind="src" path="/UsbSerialLibrary"/>
-	<classpathentry kind="src" path="src"/>
-	<classpathentry kind="src" path="gen"/>
-	<classpathentry kind="con" path="com.android.ide.eclipse.adt.ANDROID_FRAMEWORK"/>
-	<classpathentry kind="con" path="com.android.ide.eclipse.adt.LIBRARIES"/>
-	<classpathentry kind="output" path="bin/classes"/>
-</classpath>

UsbSerialExamples/.project

@@ -1,33 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>UsbSerialExamples</name>
-	<comment></comment>
-	<projects>
-	</projects>
-	<buildSpec>
-		<buildCommand>
-			<name>com.android.ide.eclipse.adt.ResourceManagerBuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-		<buildCommand>
-			<name>com.android.ide.eclipse.adt.PreCompilerBuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-		<buildCommand>
-			<name>org.eclipse.jdt.core.javabuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-		<buildCommand>
-			<name>com.android.ide.eclipse.adt.ApkBuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-	</buildSpec>
-	<natures>
-		<nature>com.android.ide.eclipse.adt.AndroidNature</nature>
-		<nature>org.eclipse.jdt.core.javanature</nature>
-	</natures>
-</projectDescription>

UsbSerialExamples/.settings/org.eclipse.jdt.core.prefs

@@ -1,280 +0,0 @@
-#Thu Jun 02 12:32:09 PDT 2011
-eclipse.preferences.version=1
-org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
-org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.6
-org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
-org.eclipse.jdt.core.compiler.compliance=1.6
-org.eclipse.jdt.core.compiler.debug.lineNumber=generate
-org.eclipse.jdt.core.compiler.debug.localVariable=generate
-org.eclipse.jdt.core.compiler.debug.sourceFile=generate
-org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
-org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
-org.eclipse.jdt.core.compiler.source=1.6
-org.eclipse.jdt.core.formatter.align_type_members_on_columns=false
-org.eclipse.jdt.core.formatter.alignment_for_arguments_in_allocation_expression=16
-org.eclipse.jdt.core.formatter.alignment_for_arguments_in_annotation=0
-org.eclipse.jdt.core.formatter.alignment_for_arguments_in_enum_constant=16
-org.eclipse.jdt.core.formatter.alignment_for_arguments_in_explicit_constructor_call=16
-org.eclipse.jdt.core.formatter.alignment_for_arguments_in_method_invocation=16
-org.eclipse.jdt.core.formatter.alignment_for_arguments_in_qualified_allocation_expression=16
-org.eclipse.jdt.core.formatter.alignment_for_assignment=0
-org.eclipse.jdt.core.formatter.alignment_for_binary_expression=16
-org.eclipse.jdt.core.formatter.alignment_for_compact_if=16
-org.eclipse.jdt.core.formatter.alignment_for_conditional_expression=80
-org.eclipse.jdt.core.formatter.alignment_for_enum_constants=0
-org.eclipse.jdt.core.formatter.alignment_for_expressions_in_array_initializer=16
-org.eclipse.jdt.core.formatter.alignment_for_method_declaration=0
-org.eclipse.jdt.core.formatter.alignment_for_multiple_fields=16
-org.eclipse.jdt.core.formatter.alignment_for_parameters_in_constructor_declaration=16
-org.eclipse.jdt.core.formatter.alignment_for_parameters_in_method_declaration=16
-org.eclipse.jdt.core.formatter.alignment_for_selector_in_method_invocation=16
-org.eclipse.jdt.core.formatter.alignment_for_superclass_in_type_declaration=16
-org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_enum_declaration=16
-org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_type_declaration=16
-org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_constructor_declaration=16
-org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_method_declaration=16
-org.eclipse.jdt.core.formatter.blank_lines_after_imports=1
-org.eclipse.jdt.core.formatter.blank_lines_after_package=1
-org.eclipse.jdt.core.formatter.blank_lines_before_field=0
-org.eclipse.jdt.core.formatter.blank_lines_before_first_class_body_declaration=0
-org.eclipse.jdt.core.formatter.blank_lines_before_imports=1
-org.eclipse.jdt.core.formatter.blank_lines_before_member_type=1
-org.eclipse.jdt.core.formatter.blank_lines_before_method=1
-org.eclipse.jdt.core.formatter.blank_lines_before_new_chunk=1
-org.eclipse.jdt.core.formatter.blank_lines_before_package=1
-org.eclipse.jdt.core.formatter.blank_lines_between_import_groups=1
-org.eclipse.jdt.core.formatter.blank_lines_between_type_declarations=1
-org.eclipse.jdt.core.formatter.brace_position_for_annotation_type_declaration=end_of_line
-org.eclipse.jdt.core.formatter.brace_position_for_anonymous_type_declaration=end_of_line
-org.eclipse.jdt.core.formatter.brace_position_for_array_initializer=end_of_line
-org.eclipse.jdt.core.formatter.brace_position_for_block=end_of_line
-org.eclipse.jdt.core.formatter.brace_position_for_block_in_case=end_of_line
-org.eclipse.jdt.core.formatter.brace_position_for_constructor_declaration=end_of_line
-org.eclipse.jdt.core.formatter.brace_position_for_enum_constant=end_of_line
-org.eclipse.jdt.core.formatter.brace_position_for_enum_declaration=end_of_line
-org.eclipse.jdt.core.formatter.brace_position_for_method_declaration=end_of_line
-org.eclipse.jdt.core.formatter.brace_position_for_switch=end_of_line
-org.eclipse.jdt.core.formatter.brace_position_for_type_declaration=end_of_line
-org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_block_comment=true
-org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_javadoc_comment=true
-org.eclipse.jdt.core.formatter.comment.format_block_comments=true
-org.eclipse.jdt.core.formatter.comment.format_header=false
-org.eclipse.jdt.core.formatter.comment.format_html=true
-org.eclipse.jdt.core.formatter.comment.format_javadoc_comments=true
-org.eclipse.jdt.core.formatter.comment.format_line_comments=true
-org.eclipse.jdt.core.formatter.comment.format_source_code=true
-org.eclipse.jdt.core.formatter.comment.indent_parameter_description=true
-org.eclipse.jdt.core.formatter.comment.indent_root_tags=true
-org.eclipse.jdt.core.formatter.comment.insert_new_line_before_root_tags=insert
-org.eclipse.jdt.core.formatter.comment.insert_new_line_for_parameter=do not insert
-org.eclipse.jdt.core.formatter.comment.line_length=80
-org.eclipse.jdt.core.formatter.comment.new_lines_at_block_boundaries=true
-org.eclipse.jdt.core.formatter.comment.new_lines_at_javadoc_boundaries=true
-org.eclipse.jdt.core.formatter.compact_else_if=true
-org.eclipse.jdt.core.formatter.continuation_indentation=2
-org.eclipse.jdt.core.formatter.continuation_indentation_for_array_initializer=2
-org.eclipse.jdt.core.formatter.disabling_tag=@formatter\:off
-org.eclipse.jdt.core.formatter.enabling_tag=@formatter\:on
-org.eclipse.jdt.core.formatter.format_guardian_clause_on_one_line=false
-org.eclipse.jdt.core.formatter.format_line_comment_starting_on_first_column=true
-org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_annotation_declaration_header=true
-org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_enum_constant_header=true
-org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_enum_declaration_header=true
-org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_type_header=true
-org.eclipse.jdt.core.formatter.indent_breaks_compare_to_cases=true
-org.eclipse.jdt.core.formatter.indent_empty_lines=false
-org.eclipse.jdt.core.formatter.indent_statements_compare_to_block=true
-org.eclipse.jdt.core.formatter.indent_statements_compare_to_body=true
-org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_cases=true
-org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_switch=true
-org.eclipse.jdt.core.formatter.indentation.size=4
-org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_local_variable=insert
-org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_member=insert
-org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_parameter=do not insert
-org.eclipse.jdt.core.formatter.insert_new_line_after_label=do not insert
-org.eclipse.jdt.core.formatter.insert_new_line_after_opening_brace_in_array_initializer=insert
-org.eclipse.jdt.core.formatter.insert_new_line_at_end_of_file_if_missing=insert
-org.eclipse.jdt.core.formatter.insert_new_line_before_catch_in_try_statement=do not insert
-org.eclipse.jdt.core.formatter.insert_new_line_before_closing_brace_in_array_initializer=insert
-org.eclipse.jdt.core.formatter.insert_new_line_before_else_in_if_statement=do not insert
-org.eclipse.jdt.core.formatter.insert_new_line_before_finally_in_try_statement=do not insert
-org.eclipse.jdt.core.formatter.insert_new_line_before_while_in_do_statement=do not insert
-org.eclipse.jdt.core.formatter.insert_new_line_in_empty_annotation_declaration=insert
-org.eclipse.jdt.core.formatter.insert_new_line_in_empty_anonymous_type_declaration=insert
-org.eclipse.jdt.core.formatter.insert_new_line_in_empty_block=insert
-org.eclipse.jdt.core.formatter.insert_new_line_in_empty_enum_constant=insert
-org.eclipse.jdt.core.formatter.insert_new_line_in_empty_enum_declaration=insert
-org.eclipse.jdt.core.formatter.insert_new_line_in_empty_method_body=insert
-org.eclipse.jdt.core.formatter.insert_new_line_in_empty_type_declaration=insert
-org.eclipse.jdt.core.formatter.insert_space_after_and_in_type_parameter=insert
-org.eclipse.jdt.core.formatter.insert_space_after_assignment_operator=insert
-org.eclipse.jdt.core.formatter.insert_space_after_at_in_annotation=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_at_in_annotation_type_declaration=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_binary_operator=insert
-org.eclipse.jdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_arguments=insert
-org.eclipse.jdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_parameters=insert
-org.eclipse.jdt.core.formatter.insert_space_after_closing_brace_in_block=insert
-org.eclipse.jdt.core.formatter.insert_space_after_closing_paren_in_cast=insert
-org.eclipse.jdt.core.formatter.insert_space_after_colon_in_assert=insert
-org.eclipse.jdt.core.formatter.insert_space_after_colon_in_case=insert
-org.eclipse.jdt.core.formatter.insert_space_after_colon_in_conditional=insert
-org.eclipse.jdt.core.formatter.insert_space_after_colon_in_for=insert
-org.eclipse.jdt.core.formatter.insert_space_after_colon_in_labeled_statement=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_allocation_expression=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_annotation=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_array_initializer=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_constructor_declaration_parameters=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_constructor_declaration_throws=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_enum_constant_arguments=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_enum_declarations=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_explicitconstructorcall_arguments=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_for_increments=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_for_inits=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_declaration_parameters=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_declaration_throws=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_invocation_arguments=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_multiple_field_declarations=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_multiple_local_declarations=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_parameterized_type_reference=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_superinterfaces=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_type_arguments=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_type_parameters=insert
-org.eclipse.jdt.core.formatter.insert_space_after_ellipsis=insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_parameterized_type_reference=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_arguments=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_parameters=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_brace_in_array_initializer=insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_bracket_in_array_allocation_expression=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_bracket_in_array_reference=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_annotation=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_cast=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_catch=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_constructor_declaration=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_enum_constant=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_for=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_if=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_method_declaration=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_method_invocation=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_parenthesized_expression=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_switch=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_synchronized=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_while=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_postfix_operator=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_prefix_operator=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_question_in_conditional=insert
-org.eclipse.jdt.core.formatter.insert_space_after_question_in_wildcard=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_semicolon_in_for=insert
-org.eclipse.jdt.core.formatter.insert_space_after_unary_operator=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_and_in_type_parameter=insert
-org.eclipse.jdt.core.formatter.insert_space_before_assignment_operator=insert
-org.eclipse.jdt.core.formatter.insert_space_before_at_in_annotation_type_declaration=insert
-org.eclipse.jdt.core.formatter.insert_space_before_binary_operator=insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_parameterized_type_reference=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_arguments=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_parameters=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_brace_in_array_initializer=insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_bracket_in_array_allocation_expression=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_bracket_in_array_reference=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_annotation=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_cast=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_catch=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_constructor_declaration=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_enum_constant=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_for=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_if=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_method_declaration=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_method_invocation=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_parenthesized_expression=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_switch=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_synchronized=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_while=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_colon_in_assert=insert
-org.eclipse.jdt.core.formatter.insert_space_before_colon_in_case=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_colon_in_conditional=insert
-org.eclipse.jdt.core.formatter.insert_space_before_colon_in_default=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_colon_in_for=insert
-org.eclipse.jdt.core.formatter.insert_space_before_colon_in_labeled_statement=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_allocation_expression=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_annotation=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_array_initializer=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_constructor_declaration_parameters=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_constructor_declaration_throws=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_enum_constant_arguments=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_enum_declarations=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_explicitconstructorcall_arguments=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_for_increments=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_for_inits=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_declaration_parameters=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_declaration_throws=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_invocation_arguments=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_multiple_field_declarations=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_multiple_local_declarations=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_parameterized_type_reference=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_superinterfaces=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_type_arguments=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_type_parameters=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_ellipsis=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_parameterized_type_reference=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_type_arguments=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_type_parameters=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_annotation_type_declaration=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_anonymous_type_declaration=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_array_initializer=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_block=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_constructor_declaration=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_enum_constant=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_enum_declaration=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_method_declaration=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_switch=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_type_declaration=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_allocation_expression=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_reference=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_type_reference=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_annotation=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_annotation_type_member_declaration=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_catch=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_constructor_declaration=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_enum_constant=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_for=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_if=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_method_declaration=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_method_invocation=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_parenthesized_expression=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_switch=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_synchronized=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_while=insert
-org.eclipse.jdt.core.formatter.insert_space_before_parenthesized_expression_in_return=insert
-org.eclipse.jdt.core.formatter.insert_space_before_parenthesized_expression_in_throw=insert
-org.eclipse.jdt.core.formatter.insert_space_before_postfix_operator=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_prefix_operator=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_question_in_conditional=insert
-org.eclipse.jdt.core.formatter.insert_space_before_question_in_wildcard=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_semicolon=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_semicolon_in_for=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_unary_operator=do not insert
-org.eclipse.jdt.core.formatter.insert_space_between_brackets_in_array_type_reference=do not insert
-org.eclipse.jdt.core.formatter.insert_space_between_empty_braces_in_array_initializer=do not insert
-org.eclipse.jdt.core.formatter.insert_space_between_empty_brackets_in_array_allocation_expression=do not insert
-org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_annotation_type_member_declaration=do not insert
-org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_constructor_declaration=do not insert
-org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_enum_constant=do not insert
-org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_method_declaration=do not insert
-org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_method_invocation=do not insert
-org.eclipse.jdt.core.formatter.join_lines_in_comments=true
-org.eclipse.jdt.core.formatter.join_wrapped_lines=false
-org.eclipse.jdt.core.formatter.keep_else_statement_on_same_line=false
-org.eclipse.jdt.core.formatter.keep_empty_array_initializer_on_one_line=false
-org.eclipse.jdt.core.formatter.keep_imple_if_on_one_line=false
-org.eclipse.jdt.core.formatter.keep_then_statement_on_same_line=false
-org.eclipse.jdt.core.formatter.lineSplit=100
-org.eclipse.jdt.core.formatter.never_indent_block_comments_on_first_column=false
-org.eclipse.jdt.core.formatter.never_indent_line_comments_on_first_column=false
-org.eclipse.jdt.core.formatter.number_of_blank_lines_at_beginning_of_method_body=0
-org.eclipse.jdt.core.formatter.number_of_empty_lines_to_preserve=1
-org.eclipse.jdt.core.formatter.put_empty_statement_on_new_line=true
-org.eclipse.jdt.core.formatter.tabulation.char=space
-org.eclipse.jdt.core.formatter.tabulation.size=4
-org.eclipse.jdt.core.formatter.use_on_off_tags=false
-org.eclipse.jdt.core.formatter.use_tabs_only_for_leading_indentations=false
-org.eclipse.jdt.core.formatter.wrap_before_binary_operator=true
-org.eclipse.jdt.core.formatter.wrap_outer_expressions_when_nested=true

UsbSerialExamples/.settings/org.eclipse.jdt.ui.prefs

@@ -1,4 +0,0 @@
-#Thu Apr 21 23:18:48 PDT 2011
-eclipse.preferences.version=1
-formatter_profile=_Android
-formatter_settings_version=11

UsbSerialExamples/AndroidManifest.xml

@@ -1,32 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-    package="com.hoho.android.usbserial.examples"
-    android:versionCode="1"
-    android:versionName="1.0" >
-
-    <uses-sdk android:minSdkVersion="12" />
-    
-    <uses-feature android:name="android.hardware.usb.host" />
-
-    <application
-        android:icon="@drawable/ic_launcher"
-        android:label="@string/app_name" >
-        <activity
-            android:label="@string/app_name"
-            android:name="com.hoho.android.usbserial.examples.DemoActivity" >
-            <intent-filter >
-                <action android:name="android.intent.action.MAIN" />
-                <category android:name="android.intent.category.DEFAULT" />
-                <category android:name="android.intent.category.LAUNCHER" />
-            </intent-filter>
-            <intent-filter>
-                <action
-                    android:name="android.hardware.usb.action.USB_DEVICE_ATTACHED" />
-            </intent-filter>
-            <meta-data
-                android:name="android.hardware.usb.action.USB_DEVICE_ATTACHED"
-                android:resource="@xml/device_filter" />
-        </activity>
-    </application>
-
-</manifest>

UsbSerialExamples/proguard.cfg

@@ -1,40 +0,0 @@
--optimizationpasses 5
--dontusemixedcaseclassnames
--dontskipnonpubliclibraryclasses
--dontpreverify
--verbose
--optimizations !code/simplification/arithmetic,!field/*,!class/merging/*
-
--keep public class * extends android.app.Activity
--keep public class * extends android.app.Application
--keep public class * extends android.app.Service
--keep public class * extends android.content.BroadcastReceiver
--keep public class * extends android.content.ContentProvider
--keep public class * extends android.app.backup.BackupAgentHelper
--keep public class * extends android.preference.Preference
--keep public class com.android.vending.licensing.ILicensingService
-
--keepclasseswithmembernames class * {
-    native <methods>;
-}
-
--keepclasseswithmembers class * {
-    public <init>(android.content.Context, android.util.AttributeSet);
-}
-
--keepclasseswithmembers class * {
-    public <init>(android.content.Context, android.util.AttributeSet, int);
-}
-
--keepclassmembers class * extends android.app.Activity {
-   public void *(android.view.View);
-}
-
--keepclassmembers enum * {
-    public static **[] values();
-    public static ** valueOf(java.lang.String);
-}
-
--keep class * implements android.os.Parcelable {
-  public static final android.os.Parcelable$Creator *;
-}

UsbSerialExamples/project.properties

@@ -1,12 +0,0 @@
-# This file is automatically generated by Android Tools.
-# Do not modify this file -- YOUR CHANGES WILL BE ERASED!
-#
-# This file must be checked in Version Control Systems.
-#
-# To customize properties used by the Ant build system use,
-# "ant.properties", and override values to adapt the script to your
-# project structure.
-
-# Project target.
-target=android-12
-android.library.reference.1=../UsbSerialLibrary

UsbSerialExamples/res/layout/main.xml

@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
-    android:layout_width="fill_parent"
-    android:layout_height="fill_parent"
-    android:orientation="vertical" >
-
-    <TextView
-        android:id="@+id/demoTitle"
-        android:layout_width="match_parent"
-        android:layout_height="wrap_content"
-        android:text="@string/hello" />
-
-    <ScrollView
-        android:id="@+id/demoScroller"
-        android:layout_width="match_parent"
-        android:layout_height="wrap_content" >
-
-        <TextView
-            android:id="@+id/demoText"
-            android:layout_width="match_parent"
-            android:layout_height="match_parent"
-            android:typeface="monospace" />
-        
-    </ScrollView>
-
-</LinearLayout>

UsbSerialExamples/res/values/strings.xml

@@ -1,7 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<resources>
-
-    <string name="hello">Hello World, DemoActivity!</string>
-    <string name="app_name">UsbSerialExamples</string>
-
-</resources>

UsbSerialExamples/res/xml/device_filter.xml

@@ -1,12 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<resources>
-    <!-- 0x0403 / 0x6001: FTDI FT232R UART -->
-    <usb-device vendor-id="1027" product-id="24577" />
-
-    <!-- 0x2341 / Arduino -->
-    <usb-device vendor-id="9025" />
-
-    <!-- 0x16C0 / 0x0483: Teensyduino  -->
-    <usb-device vendor-id="5824" product-id="1155" />
-
-</resources>

UsbSerialExamples/src/com/hoho/android/usbserial/examples/DemoActivity.java

@@ -1,165 +0,0 @@
-/* Copyright 2011 Google Inc.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301,
- * USA.
- *
- * Project home page: http://code.google.com/p/usb-serial-for-android/
- */
-
-package com.hoho.android.usbserial.examples;
-
-import android.app.Activity;
-import android.content.Context;
-import android.hardware.usb.UsbManager;
-import android.os.Bundle;
-import android.util.Log;
-import android.widget.ScrollView;
-import android.widget.TextView;
-
-import com.hoho.android.usbserial.R;
-import com.hoho.android.usbserial.driver.UsbSerialDriver;
-import com.hoho.android.usbserial.driver.UsbSerialProber;
-import com.hoho.android.usbserial.util.HexDump;
-import com.hoho.android.usbserial.util.SerialInputOutputManager;
-
-import java.io.IOException;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-
-/**
- * A sample Activity demonstrating USB-Serial support.
- *
- * @author mike wakerly (opensource@hoho.com)
- */
-public class DemoActivity extends Activity {
-
-    private final String TAG = DemoActivity.class.getSimpleName();
-
-    /**
-     * The device currently in use, or {@code null}.
-     */
-    private UsbSerialDriver mSerialDevice;
-
-    /**
-     * The system's USB service.
-     */
-    private UsbManager mUsbManager;
-
-    private TextView mTitleTextView;
-    private TextView mDumpTextView;
-    private ScrollView mScrollView;
-
-    private final ExecutorService mExecutor = Executors.newSingleThreadExecutor();
-
-    private SerialInputOutputManager mSerialIoManager;
-
-    private final SerialInputOutputManager.Listener mListener =
-            new SerialInputOutputManager.Listener() {
-
-        @Override
-        public void onRunError(Exception e) {
-            Log.d(TAG, "Runner stopped.");
-        }
-
-        @Override
-        public void onNewData(final byte[] data) {
-            DemoActivity.this.runOnUiThread(new Runnable() {
-                @Override
-                public void run() {
-                    DemoActivity.this.updateReceivedData(data);
-                }
-            });
-        }
-    };
-
-    @Override
-    public void onCreate(Bundle savedInstanceState) {
-        super.onCreate(savedInstanceState);
-        setContentView(R.layout.main);
-        mUsbManager = (UsbManager) getSystemService(Context.USB_SERVICE);
-        mTitleTextView = (TextView) findViewById(R.id.demoTitle);
-        mDumpTextView = (TextView) findViewById(R.id.demoText);
-        mScrollView = (ScrollView) findViewById(R.id.demoScroller);
-    }
-
-    @Override
-    protected void onPause() {
-        super.onPause();
-        stopIoManager();
-        if (mSerialDevice != null) {
-            try {
-                mSerialDevice.close();
-            } catch (IOException e) {
-                // Ignore.
-            }
-            mSerialDevice = null;
-        }
-    }
-
-    @Override
-    protected void onResume() {
-        super.onResume();
-        mSerialDevice = UsbSerialProber.acquire(mUsbManager);
-        Log.d(TAG, "Resumed, mSerialDevice=" + mSerialDevice);
-        if (mSerialDevice == null) {
-            mTitleTextView.setText("No serial device.");
-        } else {
-            try {
-                mSerialDevice.open();
-            } catch (IOException e) {
-                Log.e(TAG, "Error setting up device: " + e.getMessage(), e);
-                mTitleTextView.setText("Error opening device: " + e.getMessage());
-                try {
-                    mSerialDevice.close();
-                } catch (IOException e2) {
-                    // Ignore.
-                }
-                mSerialDevice = null;
-                return;
-            }
-            mTitleTextView.setText("Serial device: " + mSerialDevice);
-        }
-        onDeviceStateChange();
-    }
-
-    private void stopIoManager() {
-        if (mSerialIoManager != null) {
-            Log.i(TAG, "Stopping io manager ..");
-            mSerialIoManager.stop();
-            mSerialIoManager = null;
-        }
-    }
-
-    private void startIoManager() {
-        if (mSerialDevice != null) {
-            Log.i(TAG, "Starting io manager ..");
-            mSerialIoManager = new SerialInputOutputManager(mSerialDevice, mListener);
-            mExecutor.submit(mSerialIoManager);
-        }
-    }
-
-    private void onDeviceStateChange() {
-        stopIoManager();
-        startIoManager();
-    }
-
-    private void updateReceivedData(byte[] data) {
-        final String message = "Read " + data.length + " bytes: \n"
-                + HexDump.dumpHexString(data) + "\n\n";
-        mDumpTextView.append(message);
-        mScrollView.smoothScrollTo(0, mDumpTextView.getBottom());
-    }
-
-}

UsbSerialLibrary/.classpath

@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<classpath>
-	<classpathentry kind="src" path="src"/>
-	<classpathentry kind="src" path="gen"/>
-	<classpathentry kind="con" path="com.android.ide.eclipse.adt.ANDROID_FRAMEWORK"/>
-	<classpathentry exported="true" kind="con" path="com.android.ide.eclipse.adt.LIBRARIES"/>
-	<classpathentry kind="output" path="bin/classes"/>
-</classpath>

UsbSerialLibrary/.project

@@ -1,33 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>UsbSerialLibrary</name>
-	<comment></comment>
-	<projects>
-	</projects>
-	<buildSpec>
-		<buildCommand>
-			<name>com.android.ide.eclipse.adt.ResourceManagerBuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-		<buildCommand>
-			<name>com.android.ide.eclipse.adt.PreCompilerBuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-		<buildCommand>
-			<name>org.eclipse.jdt.core.javabuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-		<buildCommand>
-			<name>com.android.ide.eclipse.adt.ApkBuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-	</buildSpec>
-	<natures>
-		<nature>com.android.ide.eclipse.adt.AndroidNature</nature>
-		<nature>org.eclipse.jdt.core.javanature</nature>
-	</natures>
-</projectDescription>

UsbSerialLibrary/.settings/org.eclipse.jdt.core.prefs

@@ -1,280 +0,0 @@
-#Thu Jun 02 12:32:09 PDT 2011
-eclipse.preferences.version=1
-org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
-org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.6
-org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
-org.eclipse.jdt.core.compiler.compliance=1.6
-org.eclipse.jdt.core.compiler.debug.lineNumber=generate
-org.eclipse.jdt.core.compiler.debug.localVariable=generate
-org.eclipse.jdt.core.compiler.debug.sourceFile=generate
-org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
-org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
-org.eclipse.jdt.core.compiler.source=1.6
-org.eclipse.jdt.core.formatter.align_type_members_on_columns=false
-org.eclipse.jdt.core.formatter.alignment_for_arguments_in_allocation_expression=16
-org.eclipse.jdt.core.formatter.alignment_for_arguments_in_annotation=0
-org.eclipse.jdt.core.formatter.alignment_for_arguments_in_enum_constant=16
-org.eclipse.jdt.core.formatter.alignment_for_arguments_in_explicit_constructor_call=16
-org.eclipse.jdt.core.formatter.alignment_for_arguments_in_method_invocation=16
-org.eclipse.jdt.core.formatter.alignment_for_arguments_in_qualified_allocation_expression=16
-org.eclipse.jdt.core.formatter.alignment_for_assignment=0
-org.eclipse.jdt.core.formatter.alignment_for_binary_expression=16
-org.eclipse.jdt.core.formatter.alignment_for_compact_if=16
-org.eclipse.jdt.core.formatter.alignment_for_conditional_expression=80
-org.eclipse.jdt.core.formatter.alignment_for_enum_constants=0
-org.eclipse.jdt.core.formatter.alignment_for_expressions_in_array_initializer=16
-org.eclipse.jdt.core.formatter.alignment_for_method_declaration=0
-org.eclipse.jdt.core.formatter.alignment_for_multiple_fields=16
-org.eclipse.jdt.core.formatter.alignment_for_parameters_in_constructor_declaration=16
-org.eclipse.jdt.core.formatter.alignment_for_parameters_in_method_declaration=16
-org.eclipse.jdt.core.formatter.alignment_for_selector_in_method_invocation=16
-org.eclipse.jdt.core.formatter.alignment_for_superclass_in_type_declaration=16
-org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_enum_declaration=16
-org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_type_declaration=16
-org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_constructor_declaration=16
-org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_method_declaration=16
-org.eclipse.jdt.core.formatter.blank_lines_after_imports=1
-org.eclipse.jdt.core.formatter.blank_lines_after_package=1
-org.eclipse.jdt.core.formatter.blank_lines_before_field=0
-org.eclipse.jdt.core.formatter.blank_lines_before_first_class_body_declaration=0
-org.eclipse.jdt.core.formatter.blank_lines_before_imports=1
-org.eclipse.jdt.core.formatter.blank_lines_before_member_type=1
-org.eclipse.jdt.core.formatter.blank_lines_before_method=1
-org.eclipse.jdt.core.formatter.blank_lines_before_new_chunk=1
-org.eclipse.jdt.core.formatter.blank_lines_before_package=1
-org.eclipse.jdt.core.formatter.blank_lines_between_import_groups=1
-org.eclipse.jdt.core.formatter.blank_lines_between_type_declarations=1
-org.eclipse.jdt.core.formatter.brace_position_for_annotation_type_declaration=end_of_line
-org.eclipse.jdt.core.formatter.brace_position_for_anonymous_type_declaration=end_of_line
-org.eclipse.jdt.core.formatter.brace_position_for_array_initializer=end_of_line
-org.eclipse.jdt.core.formatter.brace_position_for_block=end_of_line
-org.eclipse.jdt.core.formatter.brace_position_for_block_in_case=end_of_line
-org.eclipse.jdt.core.formatter.brace_position_for_constructor_declaration=end_of_line
-org.eclipse.jdt.core.formatter.brace_position_for_enum_constant=end_of_line
-org.eclipse.jdt.core.formatter.brace_position_for_enum_declaration=end_of_line
-org.eclipse.jdt.core.formatter.brace_position_for_method_declaration=end_of_line
-org.eclipse.jdt.core.formatter.brace_position_for_switch=end_of_line
-org.eclipse.jdt.core.formatter.brace_position_for_type_declaration=end_of_line
-org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_block_comment=true
-org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_javadoc_comment=true
-org.eclipse.jdt.core.formatter.comment.format_block_comments=true
-org.eclipse.jdt.core.formatter.comment.format_header=false
-org.eclipse.jdt.core.formatter.comment.format_html=true
-org.eclipse.jdt.core.formatter.comment.format_javadoc_comments=true
-org.eclipse.jdt.core.formatter.comment.format_line_comments=true
-org.eclipse.jdt.core.formatter.comment.format_source_code=true
-org.eclipse.jdt.core.formatter.comment.indent_parameter_description=true
-org.eclipse.jdt.core.formatter.comment.indent_root_tags=true
-org.eclipse.jdt.core.formatter.comment.insert_new_line_before_root_tags=insert
-org.eclipse.jdt.core.formatter.comment.insert_new_line_for_parameter=do not insert
-org.eclipse.jdt.core.formatter.comment.line_length=80
-org.eclipse.jdt.core.formatter.comment.new_lines_at_block_boundaries=true
-org.eclipse.jdt.core.formatter.comment.new_lines_at_javadoc_boundaries=true
-org.eclipse.jdt.core.formatter.compact_else_if=true
-org.eclipse.jdt.core.formatter.continuation_indentation=2
-org.eclipse.jdt.core.formatter.continuation_indentation_for_array_initializer=2
-org.eclipse.jdt.core.formatter.disabling_tag=@formatter\:off
-org.eclipse.jdt.core.formatter.enabling_tag=@formatter\:on
-org.eclipse.jdt.core.formatter.format_guardian_clause_on_one_line=false
-org.eclipse.jdt.core.formatter.format_line_comment_starting_on_first_column=true
-org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_annotation_declaration_header=true
-org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_enum_constant_header=true
-org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_enum_declaration_header=true
-org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_type_header=true
-org.eclipse.jdt.core.formatter.indent_breaks_compare_to_cases=true
-org.eclipse.jdt.core.formatter.indent_empty_lines=false
-org.eclipse.jdt.core.formatter.indent_statements_compare_to_block=true
-org.eclipse.jdt.core.formatter.indent_statements_compare_to_body=true
-org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_cases=true
-org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_switch=true
-org.eclipse.jdt.core.formatter.indentation.size=4
-org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_local_variable=insert
-org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_member=insert
-org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_parameter=do not insert
-org.eclipse.jdt.core.formatter.insert_new_line_after_label=do not insert
-org.eclipse.jdt.core.formatter.insert_new_line_after_opening_brace_in_array_initializer=insert
-org.eclipse.jdt.core.formatter.insert_new_line_at_end_of_file_if_missing=insert
-org.eclipse.jdt.core.formatter.insert_new_line_before_catch_in_try_statement=do not insert
-org.eclipse.jdt.core.formatter.insert_new_line_before_closing_brace_in_array_initializer=insert
-org.eclipse.jdt.core.formatter.insert_new_line_before_else_in_if_statement=do not insert
-org.eclipse.jdt.core.formatter.insert_new_line_before_finally_in_try_statement=do not insert
-org.eclipse.jdt.core.formatter.insert_new_line_before_while_in_do_statement=do not insert
-org.eclipse.jdt.core.formatter.insert_new_line_in_empty_annotation_declaration=insert
-org.eclipse.jdt.core.formatter.insert_new_line_in_empty_anonymous_type_declaration=insert
-org.eclipse.jdt.core.formatter.insert_new_line_in_empty_block=insert
-org.eclipse.jdt.core.formatter.insert_new_line_in_empty_enum_constant=insert
-org.eclipse.jdt.core.formatter.insert_new_line_in_empty_enum_declaration=insert
-org.eclipse.jdt.core.formatter.insert_new_line_in_empty_method_body=insert
-org.eclipse.jdt.core.formatter.insert_new_line_in_empty_type_declaration=insert
-org.eclipse.jdt.core.formatter.insert_space_after_and_in_type_parameter=insert
-org.eclipse.jdt.core.formatter.insert_space_after_assignment_operator=insert
-org.eclipse.jdt.core.formatter.insert_space_after_at_in_annotation=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_at_in_annotation_type_declaration=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_binary_operator=insert
-org.eclipse.jdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_arguments=insert
-org.eclipse.jdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_parameters=insert
-org.eclipse.jdt.core.formatter.insert_space_after_closing_brace_in_block=insert
-org.eclipse.jdt.core.formatter.insert_space_after_closing_paren_in_cast=insert
-org.eclipse.jdt.core.formatter.insert_space_after_colon_in_assert=insert
-org.eclipse.jdt.core.formatter.insert_space_after_colon_in_case=insert
-org.eclipse.jdt.core.formatter.insert_space_after_colon_in_conditional=insert
-org.eclipse.jdt.core.formatter.insert_space_after_colon_in_for=insert
-org.eclipse.jdt.core.formatter.insert_space_after_colon_in_labeled_statement=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_allocation_expression=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_annotation=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_array_initializer=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_constructor_declaration_parameters=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_constructor_declaration_throws=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_enum_constant_arguments=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_enum_declarations=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_explicitconstructorcall_arguments=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_for_increments=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_for_inits=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_declaration_parameters=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_declaration_throws=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_invocation_arguments=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_multiple_field_declarations=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_multiple_local_declarations=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_parameterized_type_reference=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_superinterfaces=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_type_arguments=insert
-org.eclipse.jdt.core.formatter.insert_space_after_comma_in_type_parameters=insert
-org.eclipse.jdt.core.formatter.insert_space_after_ellipsis=insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_parameterized_type_reference=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_arguments=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_parameters=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_brace_in_array_initializer=insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_bracket_in_array_allocation_expression=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_bracket_in_array_reference=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_annotation=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_cast=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_catch=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_constructor_declaration=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_enum_constant=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_for=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_if=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_method_declaration=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_method_invocation=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_parenthesized_expression=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_switch=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_synchronized=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_while=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_postfix_operator=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_prefix_operator=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_question_in_conditional=insert
-org.eclipse.jdt.core.formatter.insert_space_after_question_in_wildcard=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_semicolon_in_for=insert
-org.eclipse.jdt.core.formatter.insert_space_after_unary_operator=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_and_in_type_parameter=insert
-org.eclipse.jdt.core.formatter.insert_space_before_assignment_operator=insert
-org.eclipse.jdt.core.formatter.insert_space_before_at_in_annotation_type_declaration=insert
-org.eclipse.jdt.core.formatter.insert_space_before_binary_operator=insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_parameterized_type_reference=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_arguments=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_parameters=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_brace_in_array_initializer=insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_bracket_in_array_allocation_expression=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_bracket_in_array_reference=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_annotation=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_cast=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_catch=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_constructor_declaration=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_enum_constant=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_for=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_if=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_method_declaration=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_method_invocation=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_parenthesized_expression=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_switch=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_synchronized=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_while=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_colon_in_assert=insert
-org.eclipse.jdt.core.formatter.insert_space_before_colon_in_case=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_colon_in_conditional=insert
-org.eclipse.jdt.core.formatter.insert_space_before_colon_in_default=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_colon_in_for=insert
-org.eclipse.jdt.core.formatter.insert_space_before_colon_in_labeled_statement=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_allocation_expression=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_annotation=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_array_initializer=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_constructor_declaration_parameters=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_constructor_declaration_throws=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_enum_constant_arguments=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_enum_declarations=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_explicitconstructorcall_arguments=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_for_increments=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_for_inits=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_declaration_parameters=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_declaration_throws=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_invocation_arguments=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_multiple_field_declarations=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_multiple_local_declarations=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_parameterized_type_reference=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_superinterfaces=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_type_arguments=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_comma_in_type_parameters=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_ellipsis=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_parameterized_type_reference=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_type_arguments=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_type_parameters=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_annotation_type_declaration=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_anonymous_type_declaration=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_array_initializer=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_block=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_constructor_declaration=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_enum_constant=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_enum_declaration=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_method_declaration=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_switch=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_type_declaration=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_allocation_expression=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_reference=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_type_reference=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_annotation=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_annotation_type_member_declaration=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_catch=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_constructor_declaration=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_enum_constant=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_for=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_if=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_method_declaration=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_method_invocation=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_parenthesized_expression=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_switch=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_synchronized=insert
-org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_while=insert
-org.eclipse.jdt.core.formatter.insert_space_before_parenthesized_expression_in_return=insert
-org.eclipse.jdt.core.formatter.insert_space_before_parenthesized_expression_in_throw=insert
-org.eclipse.jdt.core.formatter.insert_space_before_postfix_operator=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_prefix_operator=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_question_in_conditional=insert
-org.eclipse.jdt.core.formatter.insert_space_before_question_in_wildcard=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_semicolon=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_semicolon_in_for=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_unary_operator=do not insert
-org.eclipse.jdt.core.formatter.insert_space_between_brackets_in_array_type_reference=do not insert
-org.eclipse.jdt.core.formatter.insert_space_between_empty_braces_in_array_initializer=do not insert
-org.eclipse.jdt.core.formatter.insert_space_between_empty_brackets_in_array_allocation_expression=do not insert
-org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_annotation_type_member_declaration=do not insert
-org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_constructor_declaration=do not insert
-org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_enum_constant=do not insert
-org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_method_declaration=do not insert
-org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_method_invocation=do not insert
-org.eclipse.jdt.core.formatter.join_lines_in_comments=true
-org.eclipse.jdt.core.formatter.join_wrapped_lines=false
-org.eclipse.jdt.core.formatter.keep_else_statement_on_same_line=false
-org.eclipse.jdt.core.formatter.keep_empty_array_initializer_on_one_line=false
-org.eclipse.jdt.core.formatter.keep_imple_if_on_one_line=false
-org.eclipse.jdt.core.formatter.keep_then_statement_on_same_line=false
-org.eclipse.jdt.core.formatter.lineSplit=100
-org.eclipse.jdt.core.formatter.never_indent_block_comments_on_first_column=false
-org.eclipse.jdt.core.formatter.never_indent_line_comments_on_first_column=false
-org.eclipse.jdt.core.formatter.number_of_blank_lines_at_beginning_of_method_body=0
-org.eclipse.jdt.core.formatter.number_of_empty_lines_to_preserve=1
-org.eclipse.jdt.core.formatter.put_empty_statement_on_new_line=true
-org.eclipse.jdt.core.formatter.tabulation.char=space
-org.eclipse.jdt.core.formatter.tabulation.size=4
-org.eclipse.jdt.core.formatter.use_on_off_tags=false
-org.eclipse.jdt.core.formatter.use_tabs_only_for_leading_indentations=false
-org.eclipse.jdt.core.formatter.wrap_before_binary_operator=true
-org.eclipse.jdt.core.formatter.wrap_outer_expressions_when_nested=true

UsbSerialLibrary/.settings/org.eclipse.jdt.ui.prefs

@@ -1,4 +0,0 @@
-#Thu Apr 21 23:18:48 PDT 2011
-eclipse.preferences.version=1
-formatter_profile=_Android
-formatter_settings_version=11

UsbSerialLibrary/proguard.cfg

@@ -1,36 +0,0 @@
--optimizationpasses 5
--dontusemixedcaseclassnames
--dontskipnonpubliclibraryclasses
--dontpreverify
--verbose
--optimizations !code/simplification/arithmetic,!field/*,!class/merging/*
-
--keep public class * extends android.app.Activity
--keep public class * extends android.app.Application
--keep public class * extends android.app.Service
--keep public class * extends android.content.BroadcastReceiver
--keep public class * extends android.content.ContentProvider
--keep public class * extends android.app.backup.BackupAgentHelper
--keep public class * extends android.preference.Preference
--keep public class com.android.vending.licensing.ILicensingService
-
--keepclasseswithmembernames class * {
-    native <methods>;
-}
-
--keepclasseswithmembernames class * {
-    public <init>(android.content.Context, android.util.AttributeSet);
-}
-
--keepclasseswithmembernames class * {
-    public <init>(android.content.Context, android.util.AttributeSet, int);
-}
-
--keepclassmembers enum * {
-    public static **[] values();
-    public static ** valueOf(java.lang.String);
-}
-
--keep class * implements android.os.Parcelable {
-  public static final android.os.Parcelable$Creator *;
-}

UsbSerialLibrary/project.properties

@@ -1,12 +0,0 @@
-# This file is automatically generated by Android Tools.
-# Do not modify this file -- YOUR CHANGES WILL BE ERASED!
-#
-# This file must be checked in Version Control Systems.
-#
-# To customize properties used by the Ant build system use,
-# "ant.properties", and override values to adapt the script to your
-# project structure.
-
-# Project target.
-target=android-12
-android.library=true

UsbSerialLibrary/src/com/hoho/android/usbserial/driver/CdcAcmSerialDriver.java

@@ -1,175 +0,0 @@
-package com.hoho.android.usbserial.driver;
-
-import java.io.IOException;
-import java.util.LinkedHashMap;
-import java.util.Map;
-
-import android.hardware.usb.UsbConstants;
-import android.hardware.usb.UsbDevice;
-import android.hardware.usb.UsbDeviceConnection;
-import android.hardware.usb.UsbEndpoint;
-import android.hardware.usb.UsbInterface;
-import android.util.Log;
-
-/**
- * USB CDC/ACM serial driver implementation.
- *
- * @author mike wakerly (opensource@hoho.com)
- */
-public class CdcAcmSerialDriver extends UsbSerialDriver {
-
-    private final String TAG = CdcAcmSerialDriver.class.getSimpleName();
-
-    private UsbInterface mControlInterface;
-    private UsbInterface mDataInterface;
-
-    private UsbEndpoint mControlEndpoint;
-    private UsbEndpoint mReadEndpoint;
-    private UsbEndpoint mWriteEndpoint;
-
-    public CdcAcmSerialDriver(UsbDevice device, UsbDeviceConnection connection) {
-        super(device, connection);
-    }
-
-    @Override
-    public void open() throws IOException {
-        Log.d(TAG, "claiming interfaces, count=" + mDevice.getInterfaceCount());
-
-        Log.d(TAG, "Claiming control interface.");
-        mControlInterface = mDevice.getInterface(0);
-        Log.d(TAG, "Control iface=" + mControlInterface);
-        // class should be USB_CLASS_COMM
-
-        if (!mConnection.claimInterface(mControlInterface, true)) {
-            throw new IOException("Could not claim control interface.");
-        }
-        mControlEndpoint = mControlInterface.getEndpoint(0);
-        Log.d(TAG, "Control endpoint direction: " + mControlEndpoint.getDirection());
-
-        Log.d(TAG, "Claiming data interface.");
-        mDataInterface = mDevice.getInterface(1);
-        Log.d(TAG, "data iface=" + mDataInterface);
-        // class should be USB_CLASS_CDC_DATA
-
-        if (!mConnection.claimInterface(mDataInterface, true)) {
-            throw new IOException("Could not claim data interface.");
-        }
-        mReadEndpoint = mDataInterface.getEndpoint(1);
-        Log.d(TAG, "Read endpoint direction: " + mReadEndpoint.getDirection());
-        mWriteEndpoint = mDataInterface.getEndpoint(0);
-        Log.d(TAG, "Write endpoint direction: " + mWriteEndpoint.getDirection());
-
-        Log.d(TAG, "Setting line coding");
-        setBaudRate(115200);
-
-    }
-
-    private static final int USB_RECIP_INTERFACE = 0x01;
-    private static final int USB_RT_ACM = UsbConstants.USB_TYPE_CLASS | USB_RECIP_INTERFACE;
-
-    private static final int SET_LINE_CODING = 0x20;  // USB CDC 1.1 section 6.2
-
-    private int sendAcmControlMessage(int request, int value, byte[] buf) {
-        return mConnection.controlTransfer(USB_RT_ACM, request, value, 0, buf, buf != null ? buf.length : 0, 5000);
-    }
-
-    private int setAcmLineCoding(int bitRate, int stopBits, int parity, int dataBits) {
-        byte[] msg = {
-                (byte) ( bitRate & 0xff),
-                (byte) ((bitRate >> 8 ) & 0xff),
-                (byte) ((bitRate >> 16) & 0xff),
-                (byte) ((bitRate >> 24) & 0xff),
-
-                (byte) stopBits,
-                (byte) parity,
-                (byte) dataBits};
-        return sendAcmControlMessage(SET_LINE_CODING, 0, msg);
-    }
-
-    @Override
-    public void close() throws IOException {
-        mConnection.close();
-    }
-
-    @Override
-    public int read(byte[] dest, int timeoutMillis) throws IOException {
-        final int numBytesRead;
-        synchronized (mReadBufferLock) {
-            int readAmt = Math.min(dest.length, mReadBuffer.length);
-            numBytesRead = mConnection.bulkTransfer(mReadEndpoint, mReadBuffer, readAmt,
-                    timeoutMillis);
-            if (numBytesRead < 0) {
-                // This sucks: we get -1 on timeout, not 0 as preferred.
-                // We *should* use UsbRequest, except it has a bug/api oversight
-                // where there is no way to determine the number of bytes read
-                // in response :\ -- http://b.android.com/28023
-                return 0;
-            }
-            System.arraycopy(mReadBuffer, 0, dest, 0, numBytesRead);
-        }
-        return numBytesRead;
-    }
-
-    @Override
-    public int write(byte[] src, int timeoutMillis) throws IOException {
-        // TODO(mikey): Nearly identical to FtdiSerial write. Refactor.
-        int offset = 0;
-
-        while (offset < src.length) {
-            final int writeLength;
-            final int amtWritten;
-
-            synchronized (mWriteBufferLock) {
-                final byte[] writeBuffer;
-
-                writeLength = Math.min(src.length - offset, mWriteBuffer.length);
-                if (offset == 0) {
-                    writeBuffer = src;
-                } else {
-                    // bulkTransfer does not support offsets, make a copy.
-                    System.arraycopy(src, offset, mWriteBuffer, 0, writeLength);
-                    writeBuffer = mWriteBuffer;
-                }
-
-                amtWritten = mConnection.bulkTransfer(mWriteEndpoint, writeBuffer, writeLength,
-                        timeoutMillis);
-            }
-            if (amtWritten <= 0) {
-                throw new IOException("Error writing " + writeLength
-                        + " bytes at offset " + offset + " length=" + src.length);
-            }
-
-            Log.d(TAG, "Wrote amt=" + amtWritten + " attempted=" + writeLength);
-            offset += amtWritten;
-        }
-        return offset;
-    }
-
-    @Override
-    public int setBaudRate(int baudRate) throws IOException {
-        setAcmLineCoding(baudRate, 0, 0, 8);
-        return baudRate;
-    }
-
-    public static Map<Integer, int[]> getSupportedDevices() {
-        final Map<Integer, int[]> supportedDevices = new LinkedHashMap<Integer, int[]>();
-        supportedDevices.put(Integer.valueOf(UsbId.VENDOR_ARDUINO),
-                new int[] {
-                        UsbId.ARDUINO_UNO,
-                        UsbId.ARDUINO_UNO_R3,
-                        UsbId.ARDUINO_MEGA_2560,
-                        UsbId.ARDUINO_MEGA_2560_R3,
-                        UsbId.ARDUINO_SERIAL_ADAPTER,
-                        UsbId.ARDUINO_SERIAL_ADAPTER_R3,
-                        UsbId.ARDUINO_MEGA_ADK,
-                        UsbId.ARDUINO_MEGA_ADK_R3,
-                        UsbId.ARDUINO_LEONARDO,
-                });
-        supportedDevices.put(Integer.valueOf(UsbId.VENDOR_VAN_OOIJEN_TECH),
-                new int[] {
-                    UsbId.VAN_OOIJEN_TECH_TEENSYDUINO_SERIAL,
-                });
-        return supportedDevices;
-    }
-
-}

UsbSerialLibrary/src/com/hoho/android/usbserial/driver/FtdiSerialDriver.java

@@ -1,421 +0,0 @@
-/* Copyright 2011 Google Inc.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301,
- * USA.
- *
- * Project home page: http://code.google.com/p/usb-serial-for-android/
- */
-
-package com.hoho.android.usbserial.driver;
-
-import java.io.IOException;
-import java.nio.ByteBuffer;
-import java.util.LinkedHashMap;
-import java.util.Map;
-
-import android.hardware.usb.UsbConstants;
-import android.hardware.usb.UsbDevice;
-import android.hardware.usb.UsbDeviceConnection;
-import android.hardware.usb.UsbEndpoint;
-import android.hardware.usb.UsbRequest;
-import android.util.Log;
-
-import com.hoho.android.usbserial.util.HexDump;
-
-/**
- * A {@link UsbSerialDriver} implementation for a variety of FTDI devices
- * <p>
- * This driver is based on
- * <a href="http://www.intra2net.com/en/developer/libftdi">libftdi</a>, and is
- * copyright and subject to the following terms:
- *
- * <pre>
- *   Copyright (C) 2003 by Intra2net AG
- *
- *   This program is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU Lesser General Public License
- *   version 2.1 as published by the Free Software Foundation;
- *
- *   opensource@intra2net.com
- *   http://www.intra2net.com/en/developer/libftdi
- * </pre>
- *
- * </p>
- * <p>
- * Some FTDI devices have not been tested; see later listing of supported and
- * unsupported devices. Devices listed as "supported" support the following
- * features:
- * <ul>
- * <li>Read and write of serial data (see {@link #read(byte[], int)} and
- * {@link #write(byte[], int)}.
- * <li>Setting baud rate (see {@link #setBaudRate(int)}).
- * </ul>
- * </p>
- * <p>
- * Supported and tested devices:
- * <ul>
- * <li>{@value DeviceType#TYPE_R}</li>
- * </ul>
- * </p>
- * <p>
- * Unsupported but possibly working devices (please contact the author with
- * feedback or patches):
- * <ul>
- * <li>{@value DeviceType#TYPE_2232C}</li>
- * <li>{@value DeviceType#TYPE_2232H}</li>
- * <li>{@value DeviceType#TYPE_4232H}</li>
- * <li>{@value DeviceType#TYPE_AM}</li>
- * <li>{@value DeviceType#TYPE_BM}</li>
- * </ul>
- * </p>
- *
- * @author mike wakerly (opensource@hoho.com)
- * @see <a href="http://code.google.com/p/usb-serial-for-android/">USB Serial
- * for Android project page</a>
- * @see <a href="http://www.ftdichip.com/">FTDI Homepage</a>
- * @see <a href="http://www.intra2net.com/en/developer/libftdi">libftdi</a>
- */
-public class FtdiSerialDriver extends UsbSerialDriver {
-
-    private static final int DEFAULT_BAUD_RATE = 115200;
-
-    public static final int USB_TYPE_STANDARD = 0x00 << 5;
-    public static final int USB_TYPE_CLASS = 0x00 << 5;
-    public static final int USB_TYPE_VENDOR = 0x00 << 5;
-    public static final int USB_TYPE_RESERVED = 0x00 << 5;
-
-    public static final int USB_RECIP_DEVICE = 0x00;
-    public static final int USB_RECIP_INTERFACE = 0x01;
-    public static final int USB_RECIP_ENDPOINT = 0x02;
-    public static final int USB_RECIP_OTHER = 0x03;
-
-    public static final int USB_ENDPOINT_IN = 0x80;
-    public static final int USB_ENDPOINT_OUT = 0x00;
-
-    public static final int USB_WRITE_TIMEOUT_MILLIS = 5000;
-    public static final int USB_READ_TIMEOUT_MILLIS = 5000;
-
-    // From ftdi.h
-    /**
-     * Reset the port.
-     */
-    private static final int SIO_RESET_REQUEST = 0;
-
-    /**
-     * Set the modem control register.
-     */
-    private static final int SIO_MODEM_CTRL_REQUEST = 1;
-
-    /**
-     * Set flow control register.
-     */
-    private static final int SIO_SET_FLOW_CTRL_REQUEST = 2;
-
-    /**
-     * Set baud rate.
-     */
-    private static final int SIO_SET_BAUD_RATE_REQUEST = 3;
-
-    /**
-     * Set the data characteristics of the port.
-     */
-    private static final int SIO_SET_DATA_REQUEST = 4;
-
-    private static final int SIO_RESET_SIO = 0;
-
-    public static final int FTDI_DEVICE_OUT_REQTYPE =
-            UsbConstants.USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_ENDPOINT_OUT;
-
-    public static final int FTDI_DEVICE_IN_REQTYPE =
-            UsbConstants.USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_ENDPOINT_IN;
-
-    /**
-     * Length of the modem status header, transmitted with every read.
-     */
-    private static final int MODEM_STATUS_HEADER_LENGTH = 2;
-
-    private final String TAG = FtdiSerialDriver.class.getSimpleName();
-
-    private DeviceType mType;
-
-    /**
-     * FTDI chip types.
-     */
-    private static enum DeviceType {
-        TYPE_BM, TYPE_AM, TYPE_2232C, TYPE_R, TYPE_2232H, TYPE_4232H;
-    }
-
-    private int mInterface = 0; /* INTERFACE_ANY */
-
-    private int mMaxPacketSize = 64; // TODO(mikey): detect
-
-    /**
-     * Due to http://b.android.com/28023 , we cannot use UsbRequest async reads
-     * since it gives no indication of number of bytes read. Set this to
-     * {@code true} on platforms where it is fixed.
-     */
-    private static final boolean ENABLE_ASYNC_READS = false;
-
-    /**
-     * Constructor.
-     *
-     * @param usbDevice the {@link UsbDevice} to use
-     * @param usbConnection the {@link UsbDeviceConnection} to use
-     * @throws UsbSerialRuntimeException if the given device is incompatible
-     *             with this driver
-     */
-    public FtdiSerialDriver(UsbDevice usbDevice, UsbDeviceConnection usbConnection) {
-        super(usbDevice, usbConnection);
-        mType = null;
-    }
-
-    public void reset() throws IOException {
-        int result = mConnection.controlTransfer(FTDI_DEVICE_OUT_REQTYPE, SIO_RESET_REQUEST,
-                SIO_RESET_SIO, 0 /* index */, null, 0, USB_WRITE_TIMEOUT_MILLIS);
-        if (result != 0) {
-            throw new IOException("Reset failed: result=" + result);
-        }
-
-        // TODO(mikey): autodetect.
-        mType = DeviceType.TYPE_R;
-    }
-
-    @Override
-    public void open() throws IOException {
-        boolean opened = false;
-        try {
-            for (int i = 0; i < mDevice.getInterfaceCount(); i++) {
-                if (mConnection.claimInterface(mDevice.getInterface(i), true)) {
-                    Log.d(TAG, "claimInterface " + i + " SUCCESS");
-                } else {
-                    Log.d(TAG, "claimInterface " + i + " FAIL");
-                }
-            }
-            reset();
-            setBaudRate(DEFAULT_BAUD_RATE);
-            opened = true;
-        } finally {
-            if (!opened) {
-                close();
-            }
-        }
-    }
-
-    @Override
-    public void close() {
-        mConnection.close();
-    }
-
-    @Override
-    public int read(byte[] dest, int timeoutMillis) throws IOException {
-        final UsbEndpoint endpoint = mDevice.getInterface(0).getEndpoint(0);
-
-        if (ENABLE_ASYNC_READS) {
-            final int readAmt;
-            synchronized (mReadBufferLock) {
-                // mReadBuffer is only used for maximum read size.
-                readAmt = Math.min(dest.length, mReadBuffer.length);
-            }
-
-            final UsbRequest request = new UsbRequest();
-            request.initialize(mConnection, endpoint);
-
-            final ByteBuffer buf = ByteBuffer.wrap(dest);
-            if (!request.queue(buf, readAmt)) {
-                throw new IOException("Error queueing request.");
-            }
-
-            final UsbRequest response = mConnection.requestWait();
-            if (response == null) {
-                throw new IOException("Null response");
-            }
-
-            final int payloadBytesRead = buf.position() - MODEM_STATUS_HEADER_LENGTH;
-            if (payloadBytesRead > 0) {
-                Log.d(TAG, HexDump.dumpHexString(dest, 0, Math.min(32, dest.length)));
-                return payloadBytesRead;
-            } else {
-                return 0;
-            }
-        } else {
-            final int totalBytesRead;
-
-            synchronized (mReadBufferLock) {
-                final int readAmt = Math.min(dest.length, mReadBuffer.length);
-                totalBytesRead = mConnection.bulkTransfer(endpoint, mReadBuffer,
-                        readAmt, timeoutMillis);
-            }
-
-            if (totalBytesRead < MODEM_STATUS_HEADER_LENGTH) {
-                throw new IOException("Expected at least " + MODEM_STATUS_HEADER_LENGTH + " bytes");
-            }
-
-            final int payloadBytesRead = totalBytesRead - MODEM_STATUS_HEADER_LENGTH;
-            if (payloadBytesRead > 0) {
-                System.arraycopy(mReadBuffer, MODEM_STATUS_HEADER_LENGTH, dest, 0, payloadBytesRead);
-            }
-            return payloadBytesRead;
-        }
-    }
-
-    @Override
-    public int write(byte[] src, int timeoutMillis) throws IOException {
-        final UsbEndpoint endpoint = mDevice.getInterface(0).getEndpoint(1);
-        int offset = 0;
-
-        while (offset < src.length) {
-            final int writeLength;
-            final int amtWritten;
-
-            synchronized (mWriteBufferLock) {
-                final byte[] writeBuffer;
-
-                writeLength = Math.min(src.length - offset, mWriteBuffer.length);
-                if (offset == 0) {
-                    writeBuffer = src;
-                } else {
-                    // bulkTransfer does not support offsets, make a copy.
-                    System.arraycopy(src, offset, mWriteBuffer, 0, writeLength);
-                    writeBuffer = mWriteBuffer;
-                }
-
-                amtWritten = mConnection.bulkTransfer(endpoint, writeBuffer, writeLength,
-                        timeoutMillis);
-            }
-
-            if (amtWritten <= 0) {
-                throw new IOException("Error writing " + writeLength
-                        + " bytes at offset " + offset + " length=" + src.length);
-            }
-
-            Log.d(TAG, "Wrote amtWritten=" + amtWritten + " attempted=" + writeLength);
-            offset += amtWritten;
-        }
-        return offset;
-    }
-
-    @Override
-    public int setBaudRate(int baudRate) throws IOException {
-        long[] vals = convertBaudrate(baudRate);
-        long actualBaudrate = vals[0];
-        long index = vals[1];
-        long value = vals[2];
-        Log.i(TAG, "Requested baudrate=" + baudRate + ", actual=" + actualBaudrate);
-
-        int result = mConnection.controlTransfer(FTDI_DEVICE_OUT_REQTYPE,
-                SIO_SET_BAUD_RATE_REQUEST, (int) value, (int) index,
-                null, 0, USB_WRITE_TIMEOUT_MILLIS);
-        if (result != 0) {
-            throw new IOException("Setting baudrate failed: result=" + result);
-        }
-        return (int) actualBaudrate;
-    }
-
-    private long[] convertBaudrate(int baudrate) {
-        // TODO(mikey): Braindead transcription of libfti method.  Clean up,
-        // using more idiomatic Java where possible.
-        int divisor = 24000000 / baudrate;
-        int bestDivisor = 0;
-        int bestBaud = 0;
-        int bestBaudDiff = 0;
-        int fracCode[] = {
-                0, 3, 2, 4, 1, 5, 6, 7
-        };
-
-        for (int i = 0; i < 2; i++) {
-            int tryDivisor = divisor + i;
-            int baudEstimate;
-            int baudDiff;
-
-            if (tryDivisor <= 8) {
-                // Round up to minimum supported divisor
-                tryDivisor = 8;
-            } else if (mType != DeviceType.TYPE_AM && tryDivisor < 12) {
-                // BM doesn't support divisors 9 through 11 inclusive
-                tryDivisor = 12;
-            } else if (divisor < 16) {
-                // AM doesn't support divisors 9 through 15 inclusive
-                tryDivisor = 16;
-            } else {
-                if (mType == DeviceType.TYPE_AM) {
-                    // TODO
-                } else {
-                    if (tryDivisor > 0x1FFFF) {
-                        // Round down to maximum supported divisor value (for
-                        // BM)
-                        tryDivisor = 0x1FFFF;
-                    }
-                }
-            }
-
-            // Get estimated baud rate (to nearest integer)
-            baudEstimate = (24000000 + (tryDivisor / 2)) / tryDivisor;
-
-            // Get absolute difference from requested baud rate
-            if (baudEstimate < baudrate) {
-                baudDiff = baudrate - baudEstimate;
-            } else {
-                baudDiff = baudEstimate - baudrate;
-            }
-
-            if (i == 0 || baudDiff < bestBaudDiff) {
-                // Closest to requested baud rate so far
-                bestDivisor = tryDivisor;
-                bestBaud = baudEstimate;
-                bestBaudDiff = baudDiff;
-                if (baudDiff == 0) {
-                    // Spot on! No point trying
-                    break;
-                }
-            }
-        }
-
-        // Encode the best divisor value
-        long encodedDivisor = (bestDivisor >> 3) | (fracCode[bestDivisor & 7] << 14);
-        // Deal with special cases for encoded value
-        if (encodedDivisor == 1) {
-            encodedDivisor = 0; // 3000000 baud
-        } else if (encodedDivisor == 0x4001) {
-            encodedDivisor = 1; // 2000000 baud (BM only)
-        }
-
-        // Split into "value" and "index" values
-        long value = encodedDivisor & 0xFFFF;
-        long index;
-        if (mType == DeviceType.TYPE_2232C || mType == DeviceType.TYPE_2232H
-                || mType == DeviceType.TYPE_4232H) {
-            index = (encodedDivisor >> 8) & 0xffff;
-            index &= 0xFF00;
-            index |= 0 /* TODO mIndex */;
-        } else {
-            index = (encodedDivisor >> 16) & 0xffff;
-        }
-
-        // Return the nearest baud rate
-        return new long[] {
-                bestBaud, index, value
-        };
-    }
-
-    public static Map<Integer, int[]> getSupportedDevices() {
-        final Map<Integer, int[]> supportedDevices = new LinkedHashMap<Integer, int[]>();
-        supportedDevices.put(Integer.valueOf(UsbId.VENDOR_FTDI),
-                new int[] {
-                    UsbId.FTDI_FT232R,
-                });
-        return supportedDevices;
-    }
-
-}

UsbSerialLibrary/src/com/hoho/android/usbserial/driver/UsbId.java

@@ -1,53 +0,0 @@
-/* Copyright 2012 Google Inc.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301,
- * USA.
- *
- * Project home page: http://code.google.com/p/usb-serial-for-android/
- */
-package com.hoho.android.usbserial.driver;
-
-/**
- * Registry of USB vendor/product ID constants.
- *
- * Culled from various sources; see
- * <a href="http://www.linux-usb.org/usb.ids">usb.ids</a> for one listing.
- *
- * @author mike wakerly (opensource@hoho.com)
- */
-public final class UsbId {
-
-    public static final int VENDOR_FTDI = 0x0403;
-    public static final int FTDI_FT232R = 0x6001;
-
-    public static final int VENDOR_ARDUINO = 0x2341;
-    public static final int ARDUINO_UNO = 0x0001;
-    public static final int ARDUINO_MEGA_2560 = 0x0010;
-    public static final int ARDUINO_SERIAL_ADAPTER = 0x003b;
-    public static final int ARDUINO_MEGA_ADK = 0x003f;
-    public static final int ARDUINO_MEGA_2560_R3 = 0x0042;
-    public static final int ARDUINO_UNO_R3 = 0x0043;
-    public static final int ARDUINO_MEGA_ADK_R3 = 0x0044;
-    public static final int ARDUINO_SERIAL_ADAPTER_R3 = 0x0044;
-    public static final int ARDUINO_LEONARDO = 0x8036;
-
-    public static final int VENDOR_VAN_OOIJEN_TECH = 0x16c0;
-    public static final int VAN_OOIJEN_TECH_TEENSYDUINO_SERIAL = 0x0483;
-
-    private UsbId() {
-        throw new IllegalAccessError("Non-instantiable class.");
-    }
-
-}

UsbSerialLibrary/src/com/hoho/android/usbserial/driver/UsbSerialDriver.java

@@ -1,141 +0,0 @@
-/* Copyright 2011 Google Inc.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301,
- * USA.
- *
- * Project home page: http://code.google.com/p/usb-serial-for-android/
- */
-
-package com.hoho.android.usbserial.driver;
-
-import java.io.IOException;
-
-import android.hardware.usb.UsbDevice;
-import android.hardware.usb.UsbDeviceConnection;
-
-/**
- * Driver interface for a supported USB serial device.
- *
- * @author mike wakerly (opensource@hoho.com)
- */
-public abstract class UsbSerialDriver {
-
-    public static final int DEFAULT_READ_BUFFER_SIZE = 16 * 1024;
-    public static final int DEFAULT_WRITE_BUFFER_SIZE = 16 * 1024;
-
-    protected final UsbDevice mDevice;
-    protected final UsbDeviceConnection mConnection;
-
-    protected final Object mReadBufferLock = new Object();
-    protected final Object mWriteBufferLock = new Object();
-
-    /** Internal read buffer.  Guarded by {@link #mReadBufferLock}. */
-    protected byte[] mReadBuffer;
-
-    /** Internal write buffer.  Guarded by {@link #mWriteBufferLock}. */
-    protected byte[] mWriteBuffer;
-
-    public UsbSerialDriver(UsbDevice device, UsbDeviceConnection connection) {
-        mDevice = device;
-        mConnection = connection;
-
-        mReadBuffer = new byte[DEFAULT_READ_BUFFER_SIZE];
-        mWriteBuffer = new byte[DEFAULT_WRITE_BUFFER_SIZE];
-    }
-
-    /**
-     * Opens and initializes the device as a USB serial device. Upon success,
-     * caller must ensure that {@link #close()} is eventually called.
-     *
-     * @throws IOException on error opening or initializing the device.
-     */
-    public abstract void open() throws IOException;
-
-    /**
-     * Closes the serial device.
-     *
-     * @throws IOException on error closing the device.
-     */
-    public abstract void close() throws IOException;
-
-    /**
-     * Reads as many bytes as possible into the destination buffer.
-     *
-     * @param dest the destination byte buffer
-     * @param timeoutMillis the timeout for reading
-     * @return the actual number of bytes read
-     * @throws IOException if an error occurred during reading
-     */
-    public abstract int read(final byte[] dest, final int timeoutMillis) throws IOException;
-
-    /**
-     * Writes as many bytes as possible from the source buffer.
-     *
-     * @param src the source byte buffer
-     * @param timeoutMillis the timeout for writing
-     * @return the actual number of bytes written
-     * @throws IOException if an error occurred during writing
-     */
-    public abstract int write(final byte[] src, final int timeoutMillis) throws IOException;
-
-    /**
-     * Sets the baud rate of the serial device.
-     *
-     * @param baudRate the desired baud rate, in bits per second
-     * @return the actual rate set
-     * @throws IOException on error setting the baud rate
-     */
-    public abstract int setBaudRate(final int baudRate) throws IOException;
-
-    /**
-     * Returns the currently-bound USB device.
-     *
-     * @return the device
-     */
-    public final UsbDevice getDevice() {
-        return mDevice;
-    }
-
-    /**
-     * Sets the size of the internal buffer used to exchange data with the USB
-     * stack for read operations.  Most users should not need to change this.
-     *
-     * @param bufferSize the size in bytes
-     */
-    public final void setReadBufferSize(int bufferSize) {
-        synchronized (mReadBufferLock) {
-            if (bufferSize == mReadBuffer.length) {
-                return;
-            }
-            mReadBuffer = new byte[bufferSize];
-        }
-    }
-
-    /**
-     * Sets the size of the internal buffer used to exchange data with the USB
-     * stack for write operations.  Most users should not need to change this.
-     *
-     * @param bufferSize the size in bytes
-     */
-    public final void setWriteBufferSize(int bufferSize) {
-        synchronized (mWriteBufferLock) {
-            if (bufferSize == mWriteBuffer.length) {
-                return;
-            }
-            mWriteBuffer = new byte[bufferSize];
-        }
-    }
-
-}

UsbSerialLibrary/src/com/hoho/android/usbserial/driver/UsbSerialProber.java

@@ -1,147 +0,0 @@
-/* Copyright 2011 Google Inc.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301,
- * USA.
- *
- * Project home page: http://code.google.com/p/usb-serial-for-android/
- */
-
-package com.hoho.android.usbserial.driver;
-
-import java.util.Map;
-
-import android.hardware.usb.UsbDevice;
-import android.hardware.usb.UsbDeviceConnection;
-import android.hardware.usb.UsbManager;
-
-/**
- * Helper class to assist in detecting and building {@link UsbSerialDriver}
- * instances from available hardware.
- *
- * @author mike wakerly (opensource@hoho.com)
- */
-public enum UsbSerialProber {
-
-    // TODO(mikey): Too much boilerplate.
-
-    /**
-     * Prober for {@link FtdiSerialDriver}.
-     *
-     * @see FtdiSerialDriver
-     */
-    FTDI_SERIAL {
-        @Override
-        public UsbSerialDriver getDevice(final UsbManager manager, final UsbDevice usbDevice) {
-            if (!testIfSupported(usbDevice, FtdiSerialDriver.getSupportedDevices())) {
-                return null;
-            }
-            final UsbDeviceConnection connection = manager.openDevice(usbDevice);
-            if (connection == null) {
-                return null;
-            }
-            return new FtdiSerialDriver(usbDevice, connection);
-        }
-    },
-
-    CDC_ACM_SERIAL {
-        @Override
-        public UsbSerialDriver getDevice(UsbManager manager, UsbDevice usbDevice) {
-            if (!testIfSupported(usbDevice, CdcAcmSerialDriver.getSupportedDevices())) {
-               return null;
-            }
-            final UsbDeviceConnection connection = manager.openDevice(usbDevice);
-            if (connection == null) {
-                return null;
-            }
-            return new CdcAcmSerialDriver(usbDevice, connection);
-        }
-    };
-
-    /**
-     * Builds a new {@link UsbSerialDriver} instance from the raw device, or
-     * returns <code>null</code> if it could not be built (for example, if the
-     * probe failed).
-     *
-     * @param manager the {@link UsbManager} to use
-     * @param usbDevice the raw {@link UsbDevice} to use
-     * @return the first available {@link UsbSerialDriver}, or {@code null} if
-     *         no devices could be acquired
-     */
-    public abstract UsbSerialDriver getDevice(final UsbManager manager, final UsbDevice usbDevice);
-
-    /**
-     * Acquires and returns the first available serial device among all
-     * available {@link UsbDevice}s, or returns {@code null} if no device could
-     * be acquired.
-     *
-     * @param usbManager the {@link UsbManager} to use
-     * @return the first available {@link UsbSerialDriver}, or {@code null} if
-     *         no devices could be acquired
-     */
-    public static UsbSerialDriver acquire(final UsbManager usbManager) {
-        for (final UsbDevice usbDevice : usbManager.getDeviceList().values()) {
-            final UsbSerialDriver probedDevice = acquire(usbManager, usbDevice);
-            if (probedDevice != null) {
-                return probedDevice;
-            }
-        }
-        return null;
-    }
-
-    /**
-     * Builds and returns a new {@link UsbSerialDriver} from the given
-     * {@link UsbDevice}, or returns {@code null} if no drivers supported this
-     * device.
-     *
-     * @param usbManager the {@link UsbManager} to use
-     * @param usbDevice the {@link UsbDevice} to use
-     * @return a new {@link UsbSerialDriver}, or {@code null} if no devices
-     *         could be acquired
-     */
-    public static UsbSerialDriver acquire(final UsbManager usbManager, final UsbDevice usbDevice) {
-        for (final UsbSerialProber prober : values()) {
-            final UsbSerialDriver probedDevice = prober.getDevice(usbManager, usbDevice);
-            if (probedDevice != null) {
-                return probedDevice;
-            }
-        }
-        return null;
-    }
-
-    /**
-     * Returns {@code true} if the given device is found in the vendor/product map.
-     *
-     * @param usbDevice the device to test
-     * @param supportedDevices map of vendor ids to product id(s)
-     * @return {@code true} if supported
-     */
-    private static boolean testIfSupported(final UsbDevice usbDevice,
-            final Map<Integer, int[]> supportedDevices) {
-        final int[] supportedProducts = supportedDevices.get(
-                Integer.valueOf(usbDevice.getVendorId()));
-        if (supportedProducts == null) {
-            return false;
-        }
-
-        final int productId = usbDevice.getProductId();
-        for (int supportedProductId : supportedProducts) {
-            if (productId == supportedProductId) {
-                return true;
-            }
-        }
-        return false;
-    }
-
-}

UsbSerialLibrary/src/com/hoho/android/usbserial/driver/UsbSerialRuntimeException.java

@@ -1,46 +0,0 @@
-/*
- * Copyright 2011 Google Inc.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301,
- * USA.
- */
-
-package com.hoho.android.usbserial.driver;
-
-/**
- * Generic unchecked exception for the usbserial package.
- *
- * @author mike wakerly (opensource@hoho.com)
- */
-@SuppressWarnings("serial")
-public class UsbSerialRuntimeException extends RuntimeException {
-
-    public UsbSerialRuntimeException() {
-        super();
-    }
-
-    public UsbSerialRuntimeException(String detailMessage, Throwable throwable) {
-        super(detailMessage, throwable);
-    }
-
-    public UsbSerialRuntimeException(String detailMessage) {
-        super(detailMessage);
-    }
-
-    public UsbSerialRuntimeException(Throwable throwable) {
-        super(throwable);
-    }
-
-}

UsbSerialLibrary/src/com/hoho/android/usbserial/util/SerialInputOutputManager.java

@@ -1,188 +0,0 @@
-/* Copyright 2011 Google Inc.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301,
- * USA.
- *
- * Project home page: http://code.google.com/p/usb-serial-for-android/
- */
-
-package com.hoho.android.usbserial.util;
-
-import java.io.IOException;
-import java.nio.ByteBuffer;
-
-import android.hardware.usb.UsbRequest;
-import android.util.Log;
-
-import com.hoho.android.usbserial.driver.UsbSerialDriver;
-
-/**
- * Utility class which services a {@link UsbSerialDriver} in its {@link #run()}
- * method.
- *
- * @author mike wakerly (opensource@hoho.com)
- */
-public class SerialInputOutputManager implements Runnable {
-
-    private static final String TAG = SerialInputOutputManager.class.getSimpleName();
-    private static final boolean DEBUG = true;
-
-    private static final int READ_WAIT_MILLIS = 200;
-    private static final int BUFSIZ = 4096;
-
-    private final UsbSerialDriver mDriver;
-
-    private final ByteBuffer mReadBuffer = ByteBuffer.allocate(BUFSIZ);
-
-    // Synchronized by 'mWriteBuffer'
-    private final ByteBuffer mWriteBuffer = ByteBuffer.allocate(BUFSIZ);
-
-    private enum State {
-        STOPPED,
-        RUNNING,
-        STOPPING
-    }
-
-    // Synchronized by 'this'
-    private State mState = State.STOPPED;
-
-    // Synchronized by 'this'
-    private Listener mListener;
-
-    public interface Listener {
-        /**
-         * Called when new incoming data is available.
-         */
-        public void onNewData(byte[] data);
-
-        /**
-         * Called when {@link SerialInputOutputManager#run()} aborts due to an
-         * error.
-         */
-        public void onRunError(Exception e);
-    }
-
-    /**
-     * Creates a new instance with no listener.
-     */
-    public SerialInputOutputManager(UsbSerialDriver driver) {
-        this(driver, null);
-    }
-
-    /**
-     * Creates a new instance with the provided listener.
-     */
-    public SerialInputOutputManager(UsbSerialDriver driver, Listener listener) {
-        mDriver = driver;
-        mListener = listener;
-    }
-
-    public synchronized void setListener(Listener listener) {
-        mListener = listener;
-    }
-
-    public synchronized Listener getListener() {
-        return mListener;
-    }
-
-    public void writeAsync(byte[] data) {
-        synchronized (mWriteBuffer) {
-            mWriteBuffer.put(data);
-        }
-    }
-
-    public synchronized void stop() {
-        if (getState() == State.RUNNING) {
-            Log.i(TAG, "Stop requested");
-            mState = State.STOPPING;
-        }
-    }
-
-    private synchronized State getState() {
-        return mState;
-    }
-
-    /**
-     * Continuously services the read and write buffers until {@link #stop()} is
-     * called, or until a driver exception is raised.
-     *
-     * NOTE(mikey): Uses inefficient read/write-with-timeout.
-     * TODO(mikey): Read asynchronously with {@link UsbRequest#queue(ByteBuffer, int)}
-     */
-    @Override
-    public void run() {
-        synchronized (this) {
-            if (getState() != State.STOPPED) {
-                throw new IllegalStateException("Already running.");
-            }
-            mState = State.RUNNING;
-        }
-
-        Log.i(TAG, "Running ..");
-        try {
-            while (true) {
-                if (getState() != State.RUNNING) {
-                    Log.i(TAG, "Stopping mState=" + getState());
-                    break;
-                }
-                step();
-            }
-        } catch (Exception e) {
-            Log.w(TAG, "Run ending due to exception: " + e.getMessage(), e);
-            final Listener listener = getListener();
-            if (listener != null) {
-              listener.onRunError(e);
-            }
-        } finally {
-            synchronized (this) {
-                mState = State.STOPPED;
-                Log.i(TAG, "Stopped.");
-            }
-        }
-    }
-
-    private void step() throws IOException {
-        // Handle incoming data.
-        int len = mDriver.read(mReadBuffer.array(), READ_WAIT_MILLIS);
-        if (len > 0) {
-            if (DEBUG) Log.d(TAG, "Read data len=" + len);
-            final Listener listener = getListener();
-            if (listener != null) {
-                final byte[] data = new byte[len];
-                mReadBuffer.get(data, 0, len);
-                listener.onNewData(data);
-            }
-            mReadBuffer.clear();
-        }
-
-        // Handle outgoing data.
-        byte[] outBuff = null;
-        synchronized (mWriteBuffer) {
-            if (mWriteBuffer.position() > 0) {
-                len = mWriteBuffer.position();
-                outBuff = new byte[len];
-                mWriteBuffer.get(outBuff, 0, len);
-                mWriteBuffer.clear();
-            }
-        }
-        if (outBuff != null) {
-            if (DEBUG) {
-                Log.d(TAG, "Writing data len=" + len);
-            }
-            mDriver.write(outBuff, READ_WAIT_MILLIS);
-        }
-    }
-
-}

arduino/serial_test.ino

@@ -1,43 +0,0 @@
-/* Copyright 2012 Google Inc.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301,
- * USA.
- *
- * Project home page: http://code.google.com/p/usb-serial-for-android/
- */
-
-// Sample Arduino sketch for use with usb-serial-for-android.
-// Prints an ever-increasing counter, and writes back anything
-// it receives.
-
-static int counter = 0;
-void setup() {
-  Serial.begin(115200);
-}
-
-void loop() {
-  Serial.print("Tick #");
-  Serial.print(counter++, DEC);
-  Serial.print("\n");
-
-  if (Serial.peek() != -1) {
-    Serial.print("Read: ");
-    do {
-      Serial.print((char) Serial.read());
-    } while (Serial.peek() != -1);
-    Serial.print("\n");
-  }
-  delay(1000);
-}

build.gradle

@@ -0,0 +1,18 @@
+// Top-level gradle script.
+
+buildscript {
+    repositories {
+        mavenCentral()
+        google()
+    }
+    dependencies {
+        classpath 'com.android.tools.build:gradle:8.9.1'
+    }
+}
+
+allprojects {
+    repositories {
+        mavenCentral()
+        google()
+    }
+}

codecov.yml

@@ -0,0 +1,5 @@
+codecov:
+  max_report_age: off
+  require_ci_to_pass: no
+  notify:
+    wait_for_ci: no

gradle.properties

@@ -0,0 +1,3 @@
+android.enableJetifier=true
+android.useAndroidX=true
+android.defaults.buildfeatures.buildconfig=true

gradle/wrapper/gradle-wrapper.properties

@@ -0,0 +1,6 @@
+#Tue Oct 13 21:20:09 CEST 2020
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.11.1-all.zip

gradlew

@@ -0,0 +1,188 @@
+#!/usr/bin/env sh
+
+#
+# Copyright 2015 the original author or authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+##############################################################################
+##
+##  Gradle start up script for UN*X
+##
+##############################################################################
+
+# Attempt to set APP_HOME
+# Resolve links: $0 may be a link
+PRG="$0"
+# Need this for relative symlinks.
+while [ -h "$PRG" ] ; do
+    ls=`ls -ld "$PRG"`
+    link=`expr "$ls" : '.*-> \(.*\)$'`
+    if expr "$link" : '/.*' > /dev/null; then
+        PRG="$link"
+    else
+        PRG=`dirname "$PRG"`"/$link"
+    fi
+done
+SAVED="`pwd`"
+cd "`dirname \"$PRG\"`/" >/dev/null
+APP_HOME="`pwd -P`"
+cd "$SAVED" >/dev/null
+
+APP_NAME="Gradle"
+APP_BASE_NAME=`basename "$0"`
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD="maximum"
+
+warn () {
+    echo "$*"
+}
+
+die () {
+    echo
+    echo "$*"
+    echo
+    exit 1
+}
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "`uname`" in
+  CYGWIN* )
+    cygwin=true
+    ;;
+  Darwin* )
+    darwin=true
+    ;;
+  MINGW* )
+    msys=true
+    ;;
+  NONSTOP* )
+    nonstop=true
+    ;;
+esac
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD="$JAVA_HOME/jre/sh/java"
+    else
+        JAVACMD="$JAVA_HOME/bin/java"
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD="java"
+    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+
+# Increase the maximum file descriptors if we can.
+if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
+    MAX_FD_LIMIT=`ulimit -H -n`
+    if [ $? -eq 0 ] ; then
+        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
+            MAX_FD="$MAX_FD_LIMIT"
+        fi
+        ulimit -n $MAX_FD
+        if [ $? -ne 0 ] ; then
+            warn "Could not set maximum file descriptor limit: $MAX_FD"
+        fi
+    else
+        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
+    fi
+fi
+
+# For Darwin, add options to specify how the application appears in the dock
+if $darwin; then
+    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
+fi
+
+# For Cygwin, switch paths to Windows format before running java
+if $cygwin ; then
+    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
+    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
+    JAVACMD=`cygpath --unix "$JAVACMD"`
+
+    # We build the pattern for arguments to be converted via cygpath
+    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
+    SEP=""
+    for dir in $ROOTDIRSRAW ; do
+        ROOTDIRS="$ROOTDIRS$SEP$dir"
+        SEP="|"
+    done
+    OURCYGPATTERN="(^($ROOTDIRS))"
+    # Add a user-defined pattern to the cygpath arguments
+    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
+        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
+    fi
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    i=0
+    for arg in "$@" ; do
+        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
+        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
+
+        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
+            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
+        else
+            eval `echo args$i`="\"$arg\""
+        fi
+        i=$((i+1))
+    done
+    case $i in
+        (0) set -- ;;
+        (1) set -- "$args0" ;;
+        (2) set -- "$args0" "$args1" ;;
+        (3) set -- "$args0" "$args1" "$args2" ;;
+        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+    esac
+fi
+
+# Escape application args
+save () {
+    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
+    echo " "
+}
+APP_ARGS=$(save "$@")
+
+# Collect all arguments for the java command, following the shell quoting and substitution rules
+eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
+
+# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong
+if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then
+  cd "$(dirname "$0")"
+fi
+
+exec "$JAVACMD" "$@"

gradlew.bat

@@ -0,0 +1,100 @@
+@rem
+@rem Copyright 2015 the original author or authors.
+@rem
+@rem Licensed under the Apache License, Version 2.0 (the "License");
+@rem you may not use this file except in compliance with the License.
+@rem You may obtain a copy of the License at
+@rem
+@rem      http://www.apache.org/licenses/LICENSE-2.0
+@rem
+@rem Unless required by applicable law or agreed to in writing, software
+@rem distributed under the License is distributed on an "AS IS" BASIS,
+@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+@rem See the License for the specific language governing permissions and
+@rem limitations under the License.
+@rem
+
+@if "%DEBUG%" == "" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+set DIRNAME=%~dp0
+if "%DIRNAME%" == "" set DIRNAME=.
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if "%ERRORLEVEL%" == "0" goto init
+
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto init
+
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:init
+@rem Get command-line arguments, handling Windows variants
+
+if not "%OS%" == "Windows_NT" goto win9xME_args
+
+:win9xME_args
+@rem Slurp the command line arguments.
+set CMD_LINE_ARGS=
+set _SKIP=2
+
+:win9xME_args_slurp
+if "x%~1" == "x" goto execute
+
+set CMD_LINE_ARGS=%*
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
+
+:end
+@rem End local scope for the variables with windows NT shell
+if "%ERRORLEVEL%"=="0" goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
+exit /b 1
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega

jitpack.yml

@@ -0,0 +1,4 @@
+jdk:
+  - openjdk17
+install:
+  - ./gradlew :usbSerialForAndroid:publishToMavenLocal

settings.gradle

@@ -0,0 +1 @@
+include 'usbSerialForAndroid', 'usbSerialExamples'

test/arduino_leonardo_bridge/arduino_leonardo_bridge.ino

@@ -0,0 +1,64 @@
+/*
+  bridge USB-serial to hardware-serial
+
+  for Arduinos based on ATmega32u4 (Leonardo and compatible Pro Micro, Micro)
+  hardware serial is configured with baud-rate, databits, stopbits, parity as send over USB
+
+  see https://github.com/arduino/Arduino/tree/master/hardware/arduino/avr/cores/arduino 
+  -> CDC.cpp|HardwareSerial.cpp for serial implementation details
+
+  this sketch is mainly for demonstration / test of CDC communication
+  performance as real usb-serial bridge would be inacceptable as each byte is send in separate USB packet
+*/
+
+uint32_t baud = 9600;
+uint8_t databits = 8;
+uint8_t stopbits = 1;
+uint8_t parity = 0;
+
+void setup() {
+  Serial.begin(baud); // USB
+  Serial1.begin(baud, SERIAL_8N1);
+}
+
+void loop() {
+  // show USB connected state
+  if (Serial) TXLED1;
+  else        TXLED0;
+
+  // configure hardware serial
+  if (Serial.baud() != baud ||
+      Serial.numbits() != databits ||
+      Serial.stopbits() != stopbits ||
+      Serial.paritytype() != parity) {
+    baud = Serial.baud();
+    databits = Serial.numbits();
+    stopbits = Serial.stopbits();
+    parity = Serial.paritytype();
+    uint8_t config = 0; // ucsrc register
+    switch (databits) {
+      case 5: break;
+      case 6: config |= 2; break;
+      case 7: config |= 4; break;
+      case 8: config |= 6; break;
+      default: config |= 6;
+    }
+    switch (stopbits) {
+      case 2: config |= 8;
+        // 1.5 stopbits not supported
+    }
+    switch (parity) {
+      case 1: config |= 0x30; break; // odd
+      case 2: config |= 0x20; break; // even
+        // mark, space not supported
+    }
+    Serial1.end();
+    Serial1.begin(baud, config);
+  }
+
+  // bridge
+  if (Serial.available() > 0)
+    Serial1.write(Serial.read());
+  if (Serial1.available() > 0)
+    Serial.write(Serial1.read());
+}

test/arduino_leonardo_bridge_castrated_cdc/CDC.cpp

@@ -0,0 +1,303 @@
+
+
+/* Copyright (c) 2011, Peter Barrett  
+**  
+** Permission to use, copy, modify, and/or distribute this software for  
+** any purpose with or without fee is hereby granted, provided that the  
+** above copyright notice and this permission notice appear in all copies.  
+** 
+** THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL  
+** WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED  
+** WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR  
+** BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES  
+** OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,  
+** WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,  
+** ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS  
+** SOFTWARE.  
+*/
+
+#include "USBCore.h" // kai:added
+#include "USBAPI.h"
+#include <avr/wdt.h>
+#include <util/atomic.h>
+
+#if defined(USBCON)
+
+typedef struct
+{
+	u32	dwDTERate;
+	u8	bCharFormat;
+	u8 	bParityType;
+	u8 	bDataBits;
+	u8	lineState;
+} LineInfo;
+
+static volatile LineInfo _usbLineInfo = { 57600, 0x00, 0x00, 0x00, 0x00 };
+static volatile int32_t breakValue = -1;
+
+static u8 wdtcsr_save;
+
+#define WEAK __attribute__ ((weak))
+
+extern const CDCDescriptor _cdcInterface PROGMEM;
+const CDCDescriptor _cdcInterface =
+{
+	D_IAD(0,2,CDC_COMMUNICATION_INTERFACE_CLASS,CDC_ABSTRACT_CONTROL_MODEL,1),
+
+	//	CDC communication interface
+	D_INTERFACE(CDC_ACM_INTERFACE,3,CDC_COMMUNICATION_INTERFACE_CLASS,CDC_ABSTRACT_CONTROL_MODEL,0), // kai
+	D_CDCCS(CDC_HEADER,0x10,0x01),								// Header (1.10 bcd)
+	D_CDCCS(CDC_CALL_MANAGEMENT,1,1),							// Device handles call management (not)
+	D_CDCCS4(CDC_ABSTRACT_CONTROL_MANAGEMENT,6),				// SET_LINE_CODING, GET_LINE_CODING, SET_CONTROL_LINE_STATE supported
+	D_CDCCS(CDC_UNION,CDC_ACM_INTERFACE,CDC_DATA_INTERFACE),	// Communication interface is master, data interface is slave 0
+	D_ENDPOINT(USB_ENDPOINT_IN (CDC_ENDPOINT_ACM),USB_ENDPOINT_TYPE_INTERRUPT,0x10,0x40),
+
+	//	CDC data interface
+	//D_INTERFACE(CDC_DATA_INTERFACE,2,CDC_DATA_INTERFACE_CLASS,0,0), // kai:removed
+	D_ENDPOINT(USB_ENDPOINT_OUT(CDC_ENDPOINT_OUT),USB_ENDPOINT_TYPE_BULK,USB_EP_SIZE,0),
+	D_ENDPOINT(USB_ENDPOINT_IN (CDC_ENDPOINT_IN ),USB_ENDPOINT_TYPE_BULK,USB_EP_SIZE,0)
+};
+
+bool isLUFAbootloader()
+{
+	return pgm_read_word(FLASHEND - 1) == NEW_LUFA_SIGNATURE;
+}
+
+int CDC_GetInterface(u8* interfaceNum)
+{
+	interfaceNum[0] += 1;	// kai
+	return USB_SendControl(TRANSFER_PGM,&_cdcInterface,sizeof(_cdcInterface));
+}
+
+bool CDC_Setup(USBSetup& setup)
+{
+	u8 r = setup.bRequest;
+	u8 requestType = setup.bmRequestType;
+
+	if (REQUEST_DEVICETOHOST_CLASS_INTERFACE == requestType)
+	{
+		if (CDC_GET_LINE_CODING == r)
+		{
+			USB_SendControl(0,(void*)&_usbLineInfo,7);
+			return true;
+		}
+	}
+
+	if (REQUEST_HOSTTODEVICE_CLASS_INTERFACE == requestType)
+	{
+		if (CDC_SEND_BREAK == r)
+		{
+			breakValue = ((uint16_t)setup.wValueH << 8) | setup.wValueL;
+		}
+
+		if (CDC_SET_LINE_CODING == r)
+		{
+			USB_RecvControl((void*)&_usbLineInfo,7);
+		}
+
+		if (CDC_SET_CONTROL_LINE_STATE == r)
+		{
+			_usbLineInfo.lineState = setup.wValueL;
+
+			// auto-reset into the bootloader is triggered when the port, already 
+			// open at 1200 bps, is closed.  this is the signal to start the watchdog
+			// with a relatively long period so it can finish housekeeping tasks
+			// like servicing endpoints before the sketch ends
+
+			uint16_t magic_key_pos = MAGIC_KEY_POS;
+
+// If we don't use the new RAMEND directly, check manually if we have a newer bootloader.
+// This is used to keep compatible with the old leonardo bootloaders.
+// You are still able to set the magic key position manually to RAMEND-1 to save a few bytes for this check.
+#if MAGIC_KEY_POS != (RAMEND-1)
+			// For future boards save the key in the inproblematic RAMEND
+			// Which is reserved for the main() return value (which will never return)
+			if (isLUFAbootloader()) {
+				// horray, we got a new bootloader!
+				magic_key_pos = (RAMEND-1);
+			}
+#endif
+
+			// We check DTR state to determine if host port is open (bit 0 of lineState).
+			if (1200 == _usbLineInfo.dwDTERate && (_usbLineInfo.lineState & 0x01) == 0)
+			{
+#if MAGIC_KEY_POS != (RAMEND-1)
+				// Backup ram value if its not a newer bootloader and it hasn't already been saved.
+				// This should avoid memory corruption at least a bit, not fully
+				if (magic_key_pos != (RAMEND-1) && *(uint16_t *)magic_key_pos != MAGIC_KEY) {
+					*(uint16_t *)(RAMEND-1) = *(uint16_t *)magic_key_pos;
+				}
+#endif
+				// Store boot key
+				*(uint16_t *)magic_key_pos = MAGIC_KEY;
+				// Save the watchdog state in case the reset is aborted.
+				wdtcsr_save = WDTCSR;
+				wdt_enable(WDTO_120MS);
+			}
+			else if (*(uint16_t *)magic_key_pos == MAGIC_KEY)
+			{
+				// Most OSs do some intermediate steps when configuring ports and DTR can
+				// twiggle more than once before stabilizing.
+				// To avoid spurious resets we set the watchdog to 120ms and eventually
+				// cancel if DTR goes back high.
+				// Cancellation is only done if an auto-reset was started, which is
+				// indicated by the magic key having been set.
+
+				wdt_reset();
+				// Restore the watchdog state in case the sketch was using it.
+				WDTCSR |= (1<<WDCE) | (1<<WDE);
+				WDTCSR = wdtcsr_save;
+#if MAGIC_KEY_POS != (RAMEND-1)
+				// Restore backed up (old bootloader) magic key data
+				if (magic_key_pos != (RAMEND-1)) {
+					*(uint16_t *)magic_key_pos = *(uint16_t *)(RAMEND-1);
+				} else
+#endif
+				{
+				// Clean up RAMEND key
+					*(uint16_t *)magic_key_pos = 0x0000;
+				}
+			}
+		}
+		return true;
+	}
+	return false;
+}
+
+
+void Serial_::begin(unsigned long /* baud_count */)
+{
+	peek_buffer = -1;
+}
+
+void Serial_::begin(unsigned long /* baud_count */, byte /* config */)
+{
+	peek_buffer = -1;
+}
+
+void Serial_::end(void)
+{
+}
+
+int Serial_::available(void)
+{
+	if (peek_buffer >= 0) {
+		return 1 + USB_Available(CDC_RX);
+	}
+	return USB_Available(CDC_RX);
+}
+
+int Serial_::peek(void)
+{
+	if (peek_buffer < 0)
+		peek_buffer = USB_Recv(CDC_RX);
+	return peek_buffer;
+}
+
+int Serial_::read(void)
+{
+	if (peek_buffer >= 0) {
+		int c = peek_buffer;
+		peek_buffer = -1;
+		return c;
+	}
+	return USB_Recv(CDC_RX);
+}
+
+int Serial_::availableForWrite(void)
+{
+	return USB_SendSpace(CDC_TX);
+}
+
+void Serial_::flush(void)
+{
+	USB_Flush(CDC_TX);
+}
+
+size_t Serial_::write(uint8_t c)
+{
+	return write(&c, 1);
+}
+
+size_t Serial_::write(const uint8_t *buffer, size_t size)
+{
+	/* only try to send bytes if the high-level CDC connection itself 
+	 is open (not just the pipe) - the OS should set lineState when the port
+	 is opened and clear lineState when the port is closed.
+	 bytes sent before the user opens the connection or after
+	 the connection is closed are lost - just like with a UART. */
+	
+	// TODO - ZE - check behavior on different OSes and test what happens if an
+	// open connection isn't broken cleanly (cable is yanked out, host dies
+	// or locks up, or host virtual serial port hangs)
+	if (_usbLineInfo.lineState > 0)	{
+		int r = USB_Send(CDC_TX,buffer,size);
+		if (r > 0) {
+			return r;
+		} else {
+			setWriteError();
+			return 0;
+		}
+	}
+	setWriteError();
+	return 0;
+}
+
+// This operator is a convenient way for a sketch to check whether the
+// port has actually been configured and opened by the host (as opposed
+// to just being connected to the host).  It can be used, for example, in 
+// setup() before printing to ensure that an application on the host is
+// actually ready to receive and display the data.
+// We add a short delay before returning to fix a bug observed by Federico
+// where the port is configured (lineState != 0) but not quite opened.
+Serial_::operator bool() {
+	bool result = false;
+	if (_usbLineInfo.lineState > 0) 
+		result = true;
+	delay(10);
+	return result;
+}
+
+unsigned long Serial_::baud() {
+	// Disable interrupts while reading a multi-byte value
+	uint32_t baudrate;
+	ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
+		baudrate =  _usbLineInfo.dwDTERate;
+	}
+	return baudrate;
+}
+
+uint8_t Serial_::stopbits() {
+	return _usbLineInfo.bCharFormat;
+}
+
+uint8_t Serial_::paritytype() {
+	return _usbLineInfo.bParityType;
+}
+
+uint8_t Serial_::numbits() {
+	return _usbLineInfo.bDataBits;
+}
+
+bool Serial_::dtr() {
+	return _usbLineInfo.lineState & 0x1;
+}
+
+bool Serial_::rts() {
+	return _usbLineInfo.lineState & 0x2;
+}
+
+int32_t Serial_::readBreak() {
+	int32_t ret;
+	// Disable IRQs while reading and clearing breakValue to make
+	// sure we don't overwrite a value just set by the ISR.
+	ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
+		ret = breakValue;
+		breakValue = -1;
+	}
+	return ret;
+}
+
+Serial_ Serial;
+
+#endif /* if defined(USBCON) */

test/arduino_leonardo_bridge_castrated_cdc/README.md

@@ -0,0 +1,8 @@
+## castrated CDC test (single interface with 3 endpoints)
+
+As mentioned [here](https://arduino.stackexchange.com/a/31695/62145), Arduino functions can be _overwritten_ by copying complete files into the own project. 
+
+This is used to create a castrated CDC device with a single interface containing 3 endpoints. 
+
+The modifications have been done against Arduino 1.8.10, for changes see comments containing `kai`.
+

test/arduino_leonardo_bridge_castrated_cdc/USBCore.h

@@ -0,0 +1,301 @@
+
+// Copyright (c) 2010, Peter Barrett 
+/*
+** Permission to use, copy, modify, and/or distribute this software for  
+** any purpose with or without fee is hereby granted, provided that the  
+** above copyright notice and this permission notice appear in all copies.  
+**  
+** THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL  
+** WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED  
+** WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR  
+** BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES  
+** OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,  
+** WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,  
+** ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS  
+** SOFTWARE.  
+*/
+
+#ifndef __USBCORE_H__
+#define __USBCORE_H__
+
+#include "USBAPI.h"
+
+//	Standard requests
+#define GET_STATUS			0
+#define CLEAR_FEATURE		1
+#define SET_FEATURE			3
+#define SET_ADDRESS			5
+#define GET_DESCRIPTOR		6
+#define SET_DESCRIPTOR		7
+#define GET_CONFIGURATION	8
+#define SET_CONFIGURATION	9
+#define GET_INTERFACE		10
+#define SET_INTERFACE		11
+
+
+// bmRequestType
+#define REQUEST_HOSTTODEVICE	0x00
+#define REQUEST_DEVICETOHOST	0x80
+#define REQUEST_DIRECTION		0x80
+
+#define REQUEST_STANDARD		0x00
+#define REQUEST_CLASS			0x20
+#define REQUEST_VENDOR			0x40
+#define REQUEST_TYPE			0x60
+
+#define REQUEST_DEVICE			0x00
+#define REQUEST_INTERFACE		0x01
+#define REQUEST_ENDPOINT		0x02
+#define REQUEST_OTHER			0x03
+#define REQUEST_RECIPIENT		0x03
+
+#define REQUEST_DEVICETOHOST_CLASS_INTERFACE    (REQUEST_DEVICETOHOST | REQUEST_CLASS | REQUEST_INTERFACE)
+#define REQUEST_HOSTTODEVICE_CLASS_INTERFACE    (REQUEST_HOSTTODEVICE | REQUEST_CLASS | REQUEST_INTERFACE)
+#define REQUEST_DEVICETOHOST_STANDARD_INTERFACE (REQUEST_DEVICETOHOST | REQUEST_STANDARD | REQUEST_INTERFACE)
+
+//	Class requests
+
+#define CDC_SET_LINE_CODING			0x20
+#define CDC_GET_LINE_CODING			0x21
+#define CDC_SET_CONTROL_LINE_STATE	0x22
+#define CDC_SEND_BREAK				0x23
+
+#define MSC_RESET					0xFF
+#define MSC_GET_MAX_LUN				0xFE
+
+//	Descriptors
+
+#define USB_DEVICE_DESC_SIZE 18
+#define USB_CONFIGUARTION_DESC_SIZE 9
+#define USB_INTERFACE_DESC_SIZE 9
+#define USB_ENDPOINT_DESC_SIZE 7
+
+#define USB_DEVICE_DESCRIPTOR_TYPE             1
+#define USB_CONFIGURATION_DESCRIPTOR_TYPE      2
+#define USB_STRING_DESCRIPTOR_TYPE             3
+#define USB_INTERFACE_DESCRIPTOR_TYPE          4
+#define USB_ENDPOINT_DESCRIPTOR_TYPE           5
+
+// usb_20.pdf Table 9.6 Standard Feature Selectors
+#define DEVICE_REMOTE_WAKEUP                   1
+#define ENDPOINT_HALT                          2
+#define TEST_MODE                              3
+
+// usb_20.pdf Figure 9-4. Information Returned by a GetStatus() Request to a Device
+#define FEATURE_SELFPOWERED_ENABLED     (1 << 0)
+#define FEATURE_REMOTE_WAKEUP_ENABLED   (1 << 1)
+
+#define USB_DEVICE_CLASS_COMMUNICATIONS        0x02
+#define USB_DEVICE_CLASS_HUMAN_INTERFACE       0x03
+#define USB_DEVICE_CLASS_STORAGE               0x08
+#define USB_DEVICE_CLASS_VENDOR_SPECIFIC       0xFF
+
+#define USB_CONFIG_POWERED_MASK                0x40
+#define USB_CONFIG_BUS_POWERED                 0x80
+#define USB_CONFIG_SELF_POWERED                0xC0
+#define USB_CONFIG_REMOTE_WAKEUP               0x20
+
+// bMaxPower in Configuration Descriptor
+#define USB_CONFIG_POWER_MA(mA)                ((mA)/2)
+
+// bEndpointAddress in Endpoint Descriptor
+#define USB_ENDPOINT_DIRECTION_MASK            0x80
+#define USB_ENDPOINT_OUT(addr)                 (lowByte((addr) | 0x00))
+#define USB_ENDPOINT_IN(addr)                  (lowByte((addr) | 0x80))
+
+#define USB_ENDPOINT_TYPE_MASK                 0x03
+#define USB_ENDPOINT_TYPE_CONTROL              0x00
+#define USB_ENDPOINT_TYPE_ISOCHRONOUS          0x01
+#define USB_ENDPOINT_TYPE_BULK                 0x02
+#define USB_ENDPOINT_TYPE_INTERRUPT            0x03
+
+#define TOBYTES(x) ((x) & 0xFF),(((x) >> 8) & 0xFF)
+
+#define CDC_V1_10                               0x0110
+#define CDC_COMMUNICATION_INTERFACE_CLASS       0x02
+
+#define CDC_CALL_MANAGEMENT                     0x01
+#define CDC_ABSTRACT_CONTROL_MODEL              0x02
+#define CDC_HEADER                              0x00
+#define CDC_ABSTRACT_CONTROL_MANAGEMENT         0x02
+#define CDC_UNION                               0x06
+#define CDC_CS_INTERFACE                        0x24
+#define CDC_CS_ENDPOINT                         0x25
+#define CDC_DATA_INTERFACE_CLASS                0x0A
+
+#define MSC_SUBCLASS_SCSI						0x06 
+#define MSC_PROTOCOL_BULK_ONLY					0x50 
+
+#ifndef USB_VERSION
+#define USB_VERSION 0x200
+#endif
+
+//	Device
+typedef struct {
+	u8 len;				// 18
+	u8 dtype;			// 1 USB_DEVICE_DESCRIPTOR_TYPE
+	u16 usbVersion;		// 0x200 or 0x210
+	u8	deviceClass;
+	u8	deviceSubClass;
+	u8	deviceProtocol;
+	u8	packetSize0;	// Packet 0
+	u16	idVendor;
+	u16	idProduct;
+	u16	deviceVersion;	// 0x100
+	u8	iManufacturer;
+	u8	iProduct;
+	u8	iSerialNumber;
+	u8	bNumConfigurations;
+} DeviceDescriptor;
+
+//	Config
+typedef struct {
+	u8	len;			// 9
+	u8	dtype;			// 2
+	u16 clen;			// total length
+	u8	numInterfaces;
+	u8	config;
+	u8	iconfig;
+	u8	attributes;
+	u8	maxPower;
+} ConfigDescriptor;
+
+//	String
+
+//	Interface
+typedef struct
+{
+	u8 len;		// 9
+	u8 dtype;	// 4
+	u8 number;
+	u8 alternate;
+	u8 numEndpoints;
+	u8 interfaceClass;
+	u8 interfaceSubClass;
+	u8 protocol;
+	u8 iInterface;
+} InterfaceDescriptor;
+
+//	Endpoint
+typedef struct
+{
+	u8 len;		// 7
+	u8 dtype;	// 5
+	u8 addr;
+	u8 attr;
+	u16 packetSize;
+	u8 interval;
+} EndpointDescriptor;
+
+// Interface Association Descriptor
+// Used to bind 2 interfaces together in CDC compostite device
+typedef struct
+{
+	u8 len;				// 8
+	u8 dtype;			// 11
+	u8 firstInterface;
+	u8 interfaceCount;
+	u8 functionClass;
+	u8 funtionSubClass;
+	u8 functionProtocol;
+	u8 iInterface;
+} IADDescriptor;
+
+//	CDC CS interface descriptor
+typedef struct
+{
+	u8 len;		// 5
+	u8 dtype;	// 0x24
+	u8 subtype;
+	u8 d0;
+	u8 d1;
+} CDCCSInterfaceDescriptor;
+
+typedef struct
+{
+	u8 len;		// 4
+	u8 dtype;	// 0x24
+	u8 subtype;
+	u8 d0;
+} CDCCSInterfaceDescriptor4;
+
+typedef struct 
+{
+    u8	len;
+    u8 	dtype;		// 0x24
+    u8 	subtype;	// 1
+    u8 	bmCapabilities;
+    u8 	bDataInterface;
+} CMFunctionalDescriptor;
+	
+typedef struct 
+{
+    u8	len;
+    u8 	dtype;		// 0x24
+    u8 	subtype;	// 1
+    u8 	bmCapabilities;
+} ACMFunctionalDescriptor;
+
+typedef struct 
+{
+	//	IAD
+	IADDescriptor				iad;	// Only needed on compound device
+
+	//	Control
+	InterfaceDescriptor			cif;	// 
+	CDCCSInterfaceDescriptor	header;
+	CMFunctionalDescriptor		callManagement;			// Call Management
+	ACMFunctionalDescriptor		controlManagement;		// ACM
+	CDCCSInterfaceDescriptor	functionalDescriptor;	// CDC_UNION
+	EndpointDescriptor			cifin;
+
+	//	Data
+	//InterfaceDescriptor			dif; // kai:removed
+	EndpointDescriptor			in;
+	EndpointDescriptor			out;
+} CDCDescriptor;
+
+typedef struct 
+{
+	InterfaceDescriptor			msc;
+	EndpointDescriptor			in;
+	EndpointDescriptor			out;
+} MSCDescriptor;
+
+
+#define D_DEVICE(_class,_subClass,_proto,_packetSize0,_vid,_pid,_version,_im,_ip,_is,_configs) \
+	{ 18, 1, USB_VERSION, _class,_subClass,_proto,_packetSize0,_vid,_pid,_version,_im,_ip,_is,_configs }
+
+#define D_CONFIG(_totalLength,_interfaces) \
+	{ 9, 2, _totalLength,_interfaces, 1, 0, USB_CONFIG_BUS_POWERED | USB_CONFIG_REMOTE_WAKEUP, USB_CONFIG_POWER_MA(500) }
+
+#define D_INTERFACE(_n,_numEndpoints,_class,_subClass,_protocol) \
+	{ 9, 4, _n, 0, _numEndpoints, _class,_subClass, _protocol, 0 }
+
+#define D_ENDPOINT(_addr,_attr,_packetSize, _interval) \
+	{ 7, 5, _addr,_attr,_packetSize, _interval }
+
+#define D_IAD(_firstInterface, _count, _class, _subClass, _protocol) \
+	{ 8, 11, _firstInterface, _count, _class, _subClass, _protocol, 0 }
+
+#define D_CDCCS(_subtype,_d0,_d1)	{ 5, 0x24, _subtype, _d0, _d1 }
+#define D_CDCCS4(_subtype,_d0)		{ 4, 0x24, _subtype, _d0 }
+
+// Bootloader related fields
+// Old Caterina bootloader places the MAGIC key into unsafe RAM locations (it can be rewritten
+// by the running sketch before to actual reboot).
+// Newer bootloaders, recognizable by the LUFA "signature" at the end of the flash, can handle both
+// the usafe and the safe location.
+#ifndef MAGIC_KEY
+#define MAGIC_KEY 0x7777
+#endif
+
+#ifndef MAGIC_KEY_POS
+#define MAGIC_KEY_POS 0x0800
+#endif
+
+#ifndef NEW_LUFA_SIGNATURE
+#define NEW_LUFA_SIGNATURE 0xDCFB
+#endif
+
+#endif

test/arduino_leonardo_bridge_castrated_cdc/arduino_leonardo_bridge_castrated_cdc.ino

@@ -0,0 +1,64 @@
+/*
+  bridge USB-serial to hardware-serial
+
+  for Arduinos based on ATmega32u4 (Leonardo and compatible Pro Micro, Micro)
+  hardware serial is configured with baud-rate, databits, stopbits, parity as send over USB
+
+  see https://github.com/arduino/Arduino/tree/master/hardware/arduino/avr/cores/arduino 
+  -> CDC.cpp|HardwareSerial.cpp for serial implementation details
+
+  this sketch is mainly for demonstration / test of CDC communication
+  performance as real usb-serial bridge would be inacceptable as each byte is send in separate USB packet
+*/
+
+uint32_t baud = 9600;
+uint8_t databits = 8;
+uint8_t stopbits = 1;
+uint8_t parity = 0;
+
+void setup() {
+  Serial.begin(baud); // USB
+  Serial1.begin(baud, SERIAL_8N1);
+}
+
+void loop() {
+  // show USB connected state
+  if (Serial) TXLED1;
+  else        TXLED0;
+
+  // configure hardware serial
+  if (Serial.baud() != baud ||
+      Serial.numbits() != databits ||
+      Serial.stopbits() != stopbits ||
+      Serial.paritytype() != parity) {
+    baud = Serial.baud();
+    databits = Serial.numbits();
+    stopbits = Serial.stopbits();
+    parity = Serial.paritytype();
+    uint8_t config = 0; // ucsrc register
+    switch (databits) {
+      case 5: break;
+      case 6: config |= 2; break;
+      case 7: config |= 4; break;
+      case 8: config |= 6; break;
+      default: config |= 6;
+    }
+    switch (stopbits) {
+      case 2: config |= 8;
+        // 1.5 stopbits not supported
+    }
+    switch (parity) {
+      case 1: config |= 0x30; break; // odd
+      case 2: config |= 0x20; break; // even
+        // mark, space not supported
+    }
+    Serial1.end();
+    Serial1.begin(baud, config);
+  }
+
+  // bridge
+  if (Serial.available() > 0)
+    Serial1.write(Serial.read());
+  if (Serial1.available() > 0)
+    Serial.write(Serial1.read());
+}

test/arduino_leonardo_bridge_multi_cdc/CDC.cpp

@@ -0,0 +1,320 @@
+
+
+/* Copyright (c) 2011, Peter Barrett  
+**  
+** Permission to use, copy, modify, and/or distribute this software for  
+** any purpose with or without fee is hereby granted, provided that the  
+** above copyright notice and this permission notice appear in all copies.  
+** 
+** THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL  
+** WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED  
+** WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR  
+** BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES  
+** OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,  
+** WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,  
+** ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS  
+** SOFTWARE.  
+*/
+
+#include "USBCore.h" // kai:added
+#include "USBAPI.h"
+#include "USBDesc.h" // kai:added
+#include <avr/wdt.h>
+#include <util/atomic.h>
+
+#if defined(USBCON)
+
+typedef struct
+{
+	u32	dwDTERate;
+	u8	bCharFormat;
+	u8 	bParityType;
+	u8 	bDataBits;
+	u8	lineState;
+} LineInfo;
+
+static volatile LineInfo _usbLineInfo = { 57600, 0x00, 0x00, 0x00, 0x00 };
+static volatile int32_t breakValue = -1;
+
+static u8 wdtcsr_save;
+
+#define WEAK __attribute__ ((weak))
+
+extern const CDCDescriptor _cdcInterface PROGMEM;
+const CDCDescriptor _cdcInterface =
+{
+	D_IAD(0,2,CDC_COMMUNICATION_INTERFACE_CLASS,CDC_ABSTRACT_CONTROL_MODEL,1),
+
+	//	CDC communication interface
+	D_INTERFACE(CDC_ACM_INTERFACE1,1,CDC_COMMUNICATION_INTERFACE_CLASS,CDC_ABSTRACT_CONTROL_MODEL,0),
+	D_CDCCS(CDC_HEADER,0x10,0x01),								// Header (1.10 bcd)
+	D_CDCCS(CDC_CALL_MANAGEMENT,1,1),							// Device handles call management (not)
+	D_CDCCS4(CDC_ABSTRACT_CONTROL_MANAGEMENT,6),				// SET_LINE_CODING, GET_LINE_CODING, SET_CONTROL_LINE_STATE supported
+	D_CDCCS(CDC_UNION,CDC_ACM_INTERFACE1,CDC_DATA_INTERFACE1),	// Communication interface is master, data interface is slave 0
+	D_ENDPOINT(USB_ENDPOINT_IN (CDC_ENDPOINT_ACM1),USB_ENDPOINT_TYPE_INTERRUPT,0x10,0x40),
+
+	//	CDC data interface
+	D_INTERFACE(CDC_DATA_INTERFACE1,2,CDC_DATA_INTERFACE_CLASS,0,0),
+	D_ENDPOINT(USB_ENDPOINT_OUT(CDC_ENDPOINT_OUT1),USB_ENDPOINT_TYPE_BULK,USB_EP_SIZE,0),
+	D_ENDPOINT(USB_ENDPOINT_IN (CDC_ENDPOINT_IN1 ),USB_ENDPOINT_TYPE_BULK,USB_EP_SIZE,0)
+	
+	, // kai: added
+  D_IAD(2,2,CDC_COMMUNICATION_INTERFACE_CLASS,CDC_ABSTRACT_CONTROL_MODEL,1),
+
+  //  CDC communication interface
+  D_INTERFACE(CDC_ACM_INTERFACE2,1,CDC_COMMUNICATION_INTERFACE_CLASS,CDC_ABSTRACT_CONTROL_MODEL,0),
+  D_CDCCS(CDC_HEADER,0x10,0x01),                // Header (1.10 bcd)
+  D_CDCCS(CDC_CALL_MANAGEMENT,1,1),             // Device handles call management (not)
+  D_CDCCS4(CDC_ABSTRACT_CONTROL_MANAGEMENT,6),        // SET_LINE_CODING, GET_LINE_CODING, SET_CONTROL_LINE_STATE supported
+  D_CDCCS(CDC_UNION,CDC_ACM_INTERFACE2,CDC_DATA_INTERFACE2),  // Communication interface is master, data interface is slave 0
+  D_ENDPOINT(USB_ENDPOINT_IN (CDC_ENDPOINT_ACM2),USB_ENDPOINT_TYPE_INTERRUPT,0x10,0x40),
+  
+  //  CDC data interface
+  D_INTERFACE(CDC_DATA_INTERFACE2,2,CDC_DATA_INTERFACE_CLASS,0,0),
+  D_ENDPOINT(USB_ENDPOINT_OUT(CDC_ENDPOINT_OUT2),USB_ENDPOINT_TYPE_BULK,USB_EP_SIZE,0),
+  D_ENDPOINT(USB_ENDPOINT_IN (CDC_ENDPOINT_IN2),USB_ENDPOINT_TYPE_BULK,USB_EP_SIZE,0)
+};
+
+bool isLUFAbootloader()
+{
+	return pgm_read_word(FLASHEND - 1) == NEW_LUFA_SIGNATURE;
+}
+
+int CDC_GetInterface(u8* interfaceNum)
+{
+	interfaceNum[0] += 4;	// kai
+	return USB_SendControl(TRANSFER_PGM,&_cdcInterface,sizeof(_cdcInterface));
+}
+
+bool CDC_Setup(USBSetup& setup)
+{
+	u8 r = setup.bRequest;
+	u8 requestType = setup.bmRequestType;
+
+	if (REQUEST_DEVICETOHOST_CLASS_INTERFACE == requestType)
+	{
+		if (CDC_GET_LINE_CODING == r)
+		{
+			USB_SendControl(0,(void*)&_usbLineInfo,7);
+			return true;
+		}
+	}
+
+	if (REQUEST_HOSTTODEVICE_CLASS_INTERFACE == requestType)
+	{
+		if (CDC_SEND_BREAK == r)
+		{
+			breakValue = ((uint16_t)setup.wValueH << 8) | setup.wValueL;
+		}
+
+		if (CDC_SET_LINE_CODING == r)
+		{
+			USB_RecvControl((void*)&_usbLineInfo,7);
+		}
+
+		if (CDC_SET_CONTROL_LINE_STATE == r)
+		{
+			_usbLineInfo.lineState = setup.wValueL;
+
+			// auto-reset into the bootloader is triggered when the port, already 
+			// open at 1200 bps, is closed.  this is the signal to start the watchdog
+			// with a relatively long period so it can finish housekeeping tasks
+			// like servicing endpoints before the sketch ends
+
+			uint16_t magic_key_pos = MAGIC_KEY_POS;
+
+// If we don't use the new RAMEND directly, check manually if we have a newer bootloader.
+// This is used to keep compatible with the old leonardo bootloaders.
+// You are still able to set the magic key position manually to RAMEND-1 to save a few bytes for this check.
+#if MAGIC_KEY_POS != (RAMEND-1)
+			// For future boards save the key in the inproblematic RAMEND
+			// Which is reserved for the main() return value (which will never return)
+			if (isLUFAbootloader()) {
+				// horray, we got a new bootloader!
+				magic_key_pos = (RAMEND-1);
+			}
+#endif
+
+			// We check DTR state to determine if host port is open (bit 0 of lineState).
+			if (1200 == _usbLineInfo.dwDTERate && (_usbLineInfo.lineState & 0x01) == 0)
+			{
+#if MAGIC_KEY_POS != (RAMEND-1)
+				// Backup ram value if its not a newer bootloader and it hasn't already been saved.
+				// This should avoid memory corruption at least a bit, not fully
+				if (magic_key_pos != (RAMEND-1) && *(uint16_t *)magic_key_pos != MAGIC_KEY) {
+					*(uint16_t *)(RAMEND-1) = *(uint16_t *)magic_key_pos;
+				}
+#endif
+				// Store boot key
+				*(uint16_t *)magic_key_pos = MAGIC_KEY;
+				// Save the watchdog state in case the reset is aborted.
+				wdtcsr_save = WDTCSR;
+				wdt_enable(WDTO_120MS);
+			}
+			else if (*(uint16_t *)magic_key_pos == MAGIC_KEY)
+			{
+				// Most OSs do some intermediate steps when configuring ports and DTR can
+				// twiggle more than once before stabilizing.
+				// To avoid spurious resets we set the watchdog to 120ms and eventually
+				// cancel if DTR goes back high.
+				// Cancellation is only done if an auto-reset was started, which is
+				// indicated by the magic key having been set.
+
+				wdt_reset();
+				// Restore the watchdog state in case the sketch was using it.
+				WDTCSR |= (1<<WDCE) | (1<<WDE);
+				WDTCSR = wdtcsr_save;
+#if MAGIC_KEY_POS != (RAMEND-1)
+				// Restore backed up (old bootloader) magic key data
+				if (magic_key_pos != (RAMEND-1)) {
+					*(uint16_t *)magic_key_pos = *(uint16_t *)(RAMEND-1);
+				} else
+#endif
+				{
+				// Clean up RAMEND key
+					*(uint16_t *)magic_key_pos = 0x0000;
+				}
+			}
+		}
+		return true;
+	}
+	return false;
+}
+
+
+void Serial_::begin(unsigned long /* baud_count */)
+{
+	peek_buffer = -1;
+}
+
+void Serial_::begin(unsigned long /* baud_count */, byte /* config */)
+{
+	peek_buffer = -1;
+}
+
+void Serial_::end(void)
+{
+}
+
+int Serial_::available(void)
+{
+	if (peek_buffer >= 0) {
+		return 1 + USB_Available(CDC_RX);
+	}
+	return USB_Available(CDC_RX);
+}
+
+int Serial_::peek(void)
+{
+	if (peek_buffer < 0)
+		peek_buffer = USB_Recv(CDC_RX);
+	return peek_buffer;
+}
+
+int Serial_::read(void)
+{
+	if (peek_buffer >= 0) {
+		int c = peek_buffer;
+		peek_buffer = -1;
+		return c;
+	}
+	return USB_Recv(CDC_RX);
+}
+
+int Serial_::availableForWrite(void)
+{
+	return USB_SendSpace(CDC_TX);
+}
+
+void Serial_::flush(void)
+{
+	USB_Flush(CDC_TX);
+}
+
+size_t Serial_::write(uint8_t c)
+{
+	return write(&c, 1);
+}
+
+size_t Serial_::write(const uint8_t *buffer, size_t size)
+{
+	/* only try to send bytes if the high-level CDC connection itself 
+	 is open (not just the pipe) - the OS should set lineState when the port
+	 is opened and clear lineState when the port is closed.
+	 bytes sent before the user opens the connection or after
+	 the connection is closed are lost - just like with a UART. */
+	
+	// TODO - ZE - check behavior on different OSes and test what happens if an
+	// open connection isn't broken cleanly (cable is yanked out, host dies
+	// or locks up, or host virtual serial port hangs)
+	if (_usbLineInfo.lineState > 0)	{
+		int r = USB_Send(CDC_TX,buffer,size);
+		if (r > 0) {
+			return r;
+		} else {
+			setWriteError();
+			return 0;
+		}
+	}
+	setWriteError();
+	return 0;
+}
+
+// This operator is a convenient way for a sketch to check whether the
+// port has actually been configured and opened by the host (as opposed
+// to just being connected to the host).  It can be used, for example, in 
+// setup() before printing to ensure that an application on the host is
+// actually ready to receive and display the data.
+// We add a short delay before returning to fix a bug observed by Federico
+// where the port is configured (lineState != 0) but not quite opened.
+Serial_::operator bool() {
+	bool result = false;
+	if (_usbLineInfo.lineState > 0) 
+		result = true;
+	delay(10);
+	return result;
+}
+
+unsigned long Serial_::baud() {
+	// Disable interrupts while reading a multi-byte value
+	uint32_t baudrate;
+	ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
+		baudrate =  _usbLineInfo.dwDTERate;
+	}
+	return baudrate;
+}
+
+uint8_t Serial_::stopbits() {
+	return _usbLineInfo.bCharFormat;
+}
+
+uint8_t Serial_::paritytype() {
+	return _usbLineInfo.bParityType;
+}
+
+uint8_t Serial_::numbits() {
+	return _usbLineInfo.bDataBits;
+}
+
+bool Serial_::dtr() {
+	return _usbLineInfo.lineState & 0x1;
+}
+
+bool Serial_::rts() {
+	return _usbLineInfo.lineState & 0x2;
+}
+
+int32_t Serial_::readBreak() {
+	int32_t ret;
+	// Disable IRQs while reading and clearing breakValue to make
+	// sure we don't overwrite a value just set by the ISR.
+	ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
+		ret = breakValue;
+		breakValue = -1;
+	}
+	return ret;
+}
+
+Serial_ Serial;
+
+#endif /* if defined(USBCON) */

test/arduino_leonardo_bridge_multi_cdc/README.md

@@ -0,0 +1,8 @@
+## multiple CDC interface test
+
+As mentioned [here](https://arduino.stackexchange.com/a/31695/62145),  Arduino functions can be _overwritten_ by copying complete files into the own project. 
+
+This is used to create a device with 2 CDC interfaces. For simplicity only one of both is functional (configurable in USBDesc.h)
+
+The modifications have been done against Arduino 1.8.10, for changes see comments containing `kai`.
+

test/arduino_leonardo_bridge_multi_cdc/USBCore.cpp

@@ -0,0 +1,870 @@
+
+
+/* Copyright (c) 2010, Peter Barrett
+** Sleep/Wakeup support added by Michael Dreher
+**  
+** Permission to use, copy, modify, and/or distribute this software for  
+** any purpose with or without fee is hereby granted, provided that the  
+** above copyright notice and this permission notice appear in all copies.  
+** 
+** THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL  
+** WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED  
+** WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR  
+** BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES  
+** OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,  
+** WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,  
+** ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS  
+** SOFTWARE.  
+*/
+
+#include "USBAPI.h"
+#include "USBDesc.h" // kai:added
+#include "PluggableUSB.h"
+#include <stdlib.h>
+
+#if defined(USBCON)
+
+/** Pulse generation counters to keep track of the number of milliseconds remaining for each pulse type */
+#define TX_RX_LED_PULSE_MS 100
+volatile u8 TxLEDPulse; /**< Milliseconds remaining for data Tx LED pulse */
+volatile u8 RxLEDPulse; /**< Milliseconds remaining for data Rx LED pulse */
+
+//==================================================================
+//==================================================================
+
+extern const u16 STRING_LANGUAGE[] PROGMEM;
+extern const u8 STRING_PRODUCT[] PROGMEM;
+extern const u8 STRING_MANUFACTURER[] PROGMEM;
+extern const DeviceDescriptor USB_DeviceDescriptorIAD PROGMEM;
+
+const u16 STRING_LANGUAGE[2] = {
+	(3<<8) | (2+2),
+	0x0409	// English
+};
+
+#ifndef USB_PRODUCT
+// If no product is provided, use USB IO Board
+#define USB_PRODUCT     "USB IO Board"
+#endif
+
+const u8 STRING_PRODUCT[] PROGMEM = USB_PRODUCT;
+
+#if USB_VID == 0x2341
+#  if defined(USB_MANUFACTURER)
+#    undef USB_MANUFACTURER
+#  endif
+#  define USB_MANUFACTURER "Arduino LLC"
+#elif USB_VID == 0x1b4f
+#  if defined(USB_MANUFACTURER)
+#    undef USB_MANUFACTURER
+#  endif
+#  define USB_MANUFACTURER "SparkFun"
+#elif !defined(USB_MANUFACTURER)
+// Fall through to unknown if no manufacturer name was provided in a macro
+#  define USB_MANUFACTURER "Unknown"
+#endif
+
+const u8 STRING_MANUFACTURER[] PROGMEM = USB_MANUFACTURER;
+
+
+#define DEVICE_CLASS 0x02
+
+//	DEVICE DESCRIPTOR
+const DeviceDescriptor USB_DeviceDescriptorIAD =
+	D_DEVICE(0xEF,0x02,0x01,64,USB_VID,USB_PID,0x100,IMANUFACTURER,IPRODUCT,ISERIAL,1);
+
+//==================================================================
+//==================================================================
+
+volatile u8 _usbConfiguration = 0;
+volatile u8 _usbCurrentStatus = 0; // meaning of bits see usb_20.pdf, Figure 9-4. Information Returned by a GetStatus() Request to a Device
+volatile u8 _usbSuspendState = 0; // copy of UDINT to check SUSPI and WAKEUPI bits
+
+static inline void WaitIN(void)
+{
+	while (!(UEINTX & (1<<TXINI)))
+		;
+}
+
+static inline void ClearIN(void)
+{
+	UEINTX = ~(1<<TXINI);
+}
+
+static inline void WaitOUT(void)
+{
+	while (!(UEINTX & (1<<RXOUTI)))
+		;
+}
+
+static inline u8 WaitForINOrOUT()
+{
+	while (!(UEINTX & ((1<<TXINI)|(1<<RXOUTI))))
+		;
+	return (UEINTX & (1<<RXOUTI)) == 0;
+}
+
+static inline void ClearOUT(void)
+{
+	UEINTX = ~(1<<RXOUTI);
+}
+
+static inline void Recv(volatile u8* data, u8 count)
+{
+	while (count--)
+		*data++ = UEDATX;
+	
+	RXLED1;					// light the RX LED
+	RxLEDPulse = TX_RX_LED_PULSE_MS;	
+}
+
+static inline u8 Recv8()
+{
+	RXLED1;					// light the RX LED
+	RxLEDPulse = TX_RX_LED_PULSE_MS;
+
+	return UEDATX;	
+}
+
+static inline void Send8(u8 d)
+{
+	UEDATX = d;
+}
+
+static inline void SetEP(u8 ep)
+{
+	UENUM = ep;
+}
+
+static inline u8 FifoByteCount()
+{
+	return UEBCLX;
+}
+
+static inline u8 ReceivedSetupInt()
+{
+	return UEINTX & (1<<RXSTPI);
+}
+
+static inline void ClearSetupInt()
+{
+	UEINTX = ~((1<<RXSTPI) | (1<<RXOUTI) | (1<<TXINI));
+}
+
+static inline void Stall()
+{
+	UECONX = (1<<STALLRQ) | (1<<EPEN);
+}
+
+static inline u8 ReadWriteAllowed()
+{
+	return UEINTX & (1<<RWAL);
+}
+
+static inline u8 Stalled()
+{
+	return UEINTX & (1<<STALLEDI);
+}
+
+static inline u8 FifoFree()
+{
+	return UEINTX & (1<<FIFOCON);
+}
+
+static inline void ReleaseRX()
+{
+	UEINTX = 0x6B;	// FIFOCON=0 NAKINI=1 RWAL=1 NAKOUTI=0 RXSTPI=1 RXOUTI=0 STALLEDI=1 TXINI=1
+}
+
+static inline void ReleaseTX()
+{
+	UEINTX = 0x3A;	// FIFOCON=0 NAKINI=0 RWAL=1 NAKOUTI=1 RXSTPI=1 RXOUTI=0 STALLEDI=1 TXINI=0
+}
+
+static inline u8 FrameNumber()
+{
+	return UDFNUML;
+}
+
+//==================================================================
+//==================================================================
+
+u8 USBGetConfiguration(void)
+{
+	return _usbConfiguration;
+}
+
+#define USB_RECV_TIMEOUT
+class LockEP
+{
+	u8 _sreg;
+public:
+	LockEP(u8 ep) : _sreg(SREG)
+	{
+		cli();
+		SetEP(ep & 7);
+	}
+	~LockEP()
+	{
+		SREG = _sreg;
+	}
+};
+
+//	Number of bytes, assumes a rx endpoint
+u8 USB_Available(u8 ep)
+{
+	LockEP lock(ep);
+	return FifoByteCount();
+}
+
+//	Non Blocking receive
+//	Return number of bytes read
+int USB_Recv(u8 ep, void* d, int len)
+{
+	if (!_usbConfiguration || len < 0)
+		return -1;
+	
+	LockEP lock(ep);
+	u8 n = FifoByteCount();
+	len = min(n,len);
+	n = len;
+	u8* dst = (u8*)d;
+	while (n--)
+		*dst++ = Recv8();
+	if (len && !FifoByteCount())	// release empty buffer
+		ReleaseRX();
+	
+	return len;
+}
+
+//	Recv 1 byte if ready
+int USB_Recv(u8 ep)
+{
+	u8 c;
+	if (USB_Recv(ep,&c,1) != 1)
+		return -1;
+	return c;
+}
+
+//	Space in send EP
+u8 USB_SendSpace(u8 ep)
+{
+	LockEP lock(ep);
+	if (!ReadWriteAllowed())
+		return 0;
+	return USB_EP_SIZE - FifoByteCount();
+}
+
+//	Blocking Send of data to an endpoint
+int USB_Send(u8 ep, const void* d, int len)
+{
+	if (!_usbConfiguration)
+		return -1;
+
+	if (_usbSuspendState & (1<<SUSPI)) {
+		//send a remote wakeup
+		UDCON |= (1 << RMWKUP);
+	}
+
+	int r = len;
+	const u8* data = (const u8*)d;
+	u8 timeout = 250;		// 250ms timeout on send? TODO
+	bool sendZlp = false;
+
+	while (len || sendZlp)
+	{
+		u8 n = USB_SendSpace(ep);
+		if (n == 0)
+		{
+			if (!(--timeout))
+				return -1;
+			delay(1);
+			continue;
+		}
+
+		if (n > len) {
+			n = len;
+		}
+
+		{
+			LockEP lock(ep);
+			// Frame may have been released by the SOF interrupt handler
+			if (!ReadWriteAllowed())
+				continue;
+
+			len -= n;
+			if (ep & TRANSFER_ZERO)
+			{
+				while (n--)
+					Send8(0);
+			}
+			else if (ep & TRANSFER_PGM)
+			{
+				while (n--)
+					Send8(pgm_read_byte(data++));
+			}
+			else
+			{
+				while (n--)
+					Send8(*data++);
+			}
+
+			if (sendZlp) {
+				ReleaseTX();
+				sendZlp = false;
+			} else if (!ReadWriteAllowed()) { // ...release if buffer is full...
+				ReleaseTX();
+				if (len == 0) sendZlp = true;
+			} else if ((len == 0) && (ep & TRANSFER_RELEASE)) { // ...or if forced with TRANSFER_RELEASE
+				// XXX: TRANSFER_RELEASE is never used can be removed?
+				ReleaseTX();
+			}
+		}
+	}
+	TXLED1;					// light the TX LED
+	TxLEDPulse = TX_RX_LED_PULSE_MS;
+	return r;
+}
+
+u8 _initEndpoints[USB_ENDPOINTS] =
+{
+	0,                      // Control Endpoint
+	
+  EP_TYPE_INTERRUPT_IN,   // CDC_ENDPOINT_ACM
+  EP_TYPE_BULK_OUT,       // CDC_ENDPOINT_OUT
+  EP_TYPE_BULK_IN,        // CDC_ENDPOINT_IN
+
+  // kai:added
+  EP_TYPE_INTERRUPT_IN,   // CDC_ENDPOINT_ACM
+  EP_TYPE_BULK_OUT,       // CDC_ENDPOINT_OUT
+  EP_TYPE_BULK_IN,        // CDC_ENDPOINT_IN
+
+	// Following endpoints are automatically initialized to 0
+};
+
+#define EP_SINGLE_64 0x32	// EP0
+#define EP_DOUBLE_64 0x36	// Other endpoints
+#define EP_SINGLE_16 0x12
+
+static
+void InitEP(u8 index, u8 type, u8 size)
+{
+	UENUM = index;
+	UECONX = (1<<EPEN);
+	UECFG0X = type;
+	UECFG1X = size;
+}
+
+static
+void InitEndpoints()
+{
+	for (u8 i = 1; i < sizeof(_initEndpoints) && _initEndpoints[i] != 0; i++)
+	{
+		UENUM = i;
+		UECONX = (1<<EPEN);
+		UECFG0X = _initEndpoints[i];
+#if USB_EP_SIZE == 16
+		UECFG1X = EP_SINGLE_16;
+#elif USB_EP_SIZE == 64
+		UECFG1X = EP_DOUBLE_64;
+#else
+#error Unsupported value for USB_EP_SIZE
+#endif
+	}
+	UERST = 0x7E;	// And reset them
+	UERST = 0;
+}
+
+//	Handle CLASS_INTERFACE requests
+static
+bool ClassInterfaceRequest(USBSetup& setup)
+{
+	u8 i = setup.wIndex;
+
+  if (CDC_CLASS_INTERFACE == i) // kai
+    return CDC_Setup(setup);
+
+#ifdef PLUGGABLE_USB_ENABLED
+	return PluggableUSB().setup(setup);
+#endif
+	return false;
+}
+
+static int _cmark;
+static int _cend;
+void InitControl(int end)
+{
+	SetEP(0);
+	_cmark = 0;
+	_cend = end;
+}
+
+static
+bool SendControl(u8 d)
+{
+	if (_cmark < _cend)
+	{
+		if (!WaitForINOrOUT())
+			return false;
+		Send8(d);
+		if (!((_cmark + 1) & 0x3F))
+			ClearIN();	// Fifo is full, release this packet
+	}
+	_cmark++;
+	return true;
+}
+
+//	Clipped by _cmark/_cend
+int USB_SendControl(u8 flags, const void* d, int len)
+{
+	int sent = len;
+	const u8* data = (const u8*)d;
+	bool pgm = flags & TRANSFER_PGM;
+	while (len--)
+	{
+		u8 c = pgm ? pgm_read_byte(data++) : *data++;
+		if (!SendControl(c))
+			return -1;
+	}
+	return sent;
+}
+
+// Send a USB descriptor string. The string is stored in PROGMEM as a
+// plain ASCII string but is sent out as UTF-16 with the correct 2-byte
+// prefix
+static bool USB_SendStringDescriptor(const u8*string_P, u8 string_len, uint8_t flags) {
+        SendControl(2 + string_len * 2);
+        SendControl(3);
+        bool pgm = flags & TRANSFER_PGM;
+        for(u8 i = 0; i < string_len; i++) {
+                bool r = SendControl(pgm ? pgm_read_byte(&string_P[i]) : string_P[i]);
+                r &= SendControl(0); // high byte
+                if(!r) {
+                        return false;
+                }
+        }
+        return true;
+}
+
+//	Does not timeout or cross fifo boundaries
+int USB_RecvControl(void* d, int len)
+{
+	auto length = len;
+	while(length)
+	{
+		// Dont receive more than the USB Control EP has to offer
+		// Use fixed 64 because control EP always have 64 bytes even on 16u2.
+		auto recvLength = length;
+		if(recvLength > 64){
+			recvLength = 64;
+		}
+
+		// Write data to fit to the end (not the beginning) of the array
+		WaitOUT();
+		Recv((u8*)d + len - length, recvLength);
+		ClearOUT();
+		length -= recvLength;
+	}
+	return len;
+}
+
+static u8 SendInterfaces()
+{
+	u8 interfaces = 0;
+
+	CDC_GetInterface(&interfaces);
+
+#ifdef PLUGGABLE_USB_ENABLED
+	PluggableUSB().getInterface(&interfaces);
+#endif
+
+	return interfaces;
+}
+
+//	Construct a dynamic configuration descriptor
+//	This really needs dynamic endpoint allocation etc
+//	TODO
+static
+bool SendConfiguration(int maxlen)
+{
+	//	Count and measure interfaces
+	InitControl(0);
+	u8 interfaces = SendInterfaces();
+	ConfigDescriptor config = D_CONFIG(_cmark + sizeof(ConfigDescriptor),interfaces);
+
+	//	Now send them
+	InitControl(maxlen);
+	USB_SendControl(0,&config,sizeof(ConfigDescriptor));
+	SendInterfaces();
+	return true;
+}
+
+static
+bool SendDescriptor(USBSetup& setup)
+{
+	int ret;
+	u8 t = setup.wValueH;
+	if (USB_CONFIGURATION_DESCRIPTOR_TYPE == t)
+		return SendConfiguration(setup.wLength);
+
+	InitControl(setup.wLength);
+#ifdef PLUGGABLE_USB_ENABLED
+	ret = PluggableUSB().getDescriptor(setup);
+	if (ret != 0) {
+		return (ret > 0 ? true : false);
+	}
+#endif
+
+	const u8* desc_addr = 0;
+	if (USB_DEVICE_DESCRIPTOR_TYPE == t)
+	{
+		desc_addr = (const u8*)&USB_DeviceDescriptorIAD;
+	}
+	else if (USB_STRING_DESCRIPTOR_TYPE == t)
+	{
+		if (setup.wValueL == 0) {
+			desc_addr = (const u8*)&STRING_LANGUAGE;
+		}
+		else if (setup.wValueL == IPRODUCT) {
+			return USB_SendStringDescriptor(STRING_PRODUCT, strlen(USB_PRODUCT), TRANSFER_PGM);
+		}
+		else if (setup.wValueL == IMANUFACTURER) {
+			return USB_SendStringDescriptor(STRING_MANUFACTURER, strlen(USB_MANUFACTURER), TRANSFER_PGM);
+		}
+		else if (setup.wValueL == ISERIAL) {
+#ifdef PLUGGABLE_USB_ENABLED
+			char name[ISERIAL_MAX_LEN];
+			PluggableUSB().getShortName(name);
+			return USB_SendStringDescriptor((uint8_t*)name, strlen(name), 0);
+#endif
+		}
+		else
+			return false;
+	}
+
+	if (desc_addr == 0)
+		return false;
+	u8 desc_length = pgm_read_byte(desc_addr);
+
+	USB_SendControl(TRANSFER_PGM,desc_addr,desc_length);
+	return true;
+}
+
+//	Endpoint 0 interrupt
+ISR(USB_COM_vect)
+{
+    SetEP(0);
+	if (!ReceivedSetupInt())
+		return;
+
+	USBSetup setup;
+	Recv((u8*)&setup,8);
+	ClearSetupInt();
+
+	u8 requestType = setup.bmRequestType;
+	if (requestType & REQUEST_DEVICETOHOST)
+		WaitIN();
+	else
+		ClearIN();
+
+    bool ok = true;
+	if (REQUEST_STANDARD == (requestType & REQUEST_TYPE))
+	{
+		//	Standard Requests
+		u8 r = setup.bRequest;
+		u16 wValue = setup.wValueL | (setup.wValueH << 8);
+		if (GET_STATUS == r)
+		{
+			if (requestType == (REQUEST_DEVICETOHOST | REQUEST_STANDARD | REQUEST_DEVICE))
+			{
+				Send8(_usbCurrentStatus);
+				Send8(0);
+			}
+			else
+			{
+				// TODO: handle the HALT state of an endpoint here
+				// see "Figure 9-6. Information Returned by a GetStatus() Request to an Endpoint" in usb_20.pdf for more information
+				Send8(0);
+				Send8(0);
+			}
+		}
+		else if (CLEAR_FEATURE == r)
+		{
+			if((requestType == (REQUEST_HOSTTODEVICE | REQUEST_STANDARD | REQUEST_DEVICE))
+				&& (wValue == DEVICE_REMOTE_WAKEUP))
+			{
+				_usbCurrentStatus &= ~FEATURE_REMOTE_WAKEUP_ENABLED;
+			}
+		}
+		else if (SET_FEATURE == r)
+		{
+			if((requestType == (REQUEST_HOSTTODEVICE | REQUEST_STANDARD | REQUEST_DEVICE))
+				&& (wValue == DEVICE_REMOTE_WAKEUP))
+			{
+				_usbCurrentStatus |= FEATURE_REMOTE_WAKEUP_ENABLED;
+			}
+		}
+		else if (SET_ADDRESS == r)
+		{
+			WaitIN();
+			UDADDR = setup.wValueL | (1<<ADDEN);
+		}
+		else if (GET_DESCRIPTOR == r)
+		{
+			ok = SendDescriptor(setup);
+		}
+		else if (SET_DESCRIPTOR == r)
+		{
+			ok = false;
+		}
+		else if (GET_CONFIGURATION == r)
+		{
+			Send8(1);
+		}
+		else if (SET_CONFIGURATION == r)
+		{
+			if (REQUEST_DEVICE == (requestType & REQUEST_RECIPIENT))
+			{
+				InitEndpoints();
+				_usbConfiguration = setup.wValueL;
+			} else
+				ok = false;
+		}
+		else if (GET_INTERFACE == r)
+		{
+		}
+		else if (SET_INTERFACE == r)
+		{
+		}
+	}
+	else
+	{
+		InitControl(setup.wLength);		//	Max length of transfer
+		ok = ClassInterfaceRequest(setup);
+	}
+
+	if (ok)
+		ClearIN();
+	else
+	{
+		Stall();
+	}
+}
+
+void USB_Flush(u8 ep)
+{
+	SetEP(ep);
+	if (FifoByteCount())
+		ReleaseTX();
+}
+
+static inline void USB_ClockDisable()
+{
+#if defined(OTGPADE)
+	USBCON = (USBCON & ~(1<<OTGPADE)) | (1<<FRZCLK); // freeze clock and disable VBUS Pad
+#else // u2 Series
+	USBCON = (1 << FRZCLK); // freeze clock
+#endif
+	PLLCSR &= ~(1<<PLLE);  // stop PLL
+}
+
+static inline void USB_ClockEnable()
+{
+#if defined(UHWCON)
+	UHWCON |= (1<<UVREGE);			// power internal reg
+#endif
+	USBCON = (1<<USBE) | (1<<FRZCLK);	// clock frozen, usb enabled
+
+// ATmega32U4
+#if defined(PINDIV)
+#if F_CPU == 16000000UL
+	PLLCSR |= (1<<PINDIV);                   // Need 16 MHz xtal
+#elif F_CPU == 8000000UL
+	PLLCSR &= ~(1<<PINDIV);                  // Need  8 MHz xtal
+#else
+#error "Clock rate of F_CPU not supported"
+#endif
+
+#elif defined(__AVR_AT90USB82__) || defined(__AVR_AT90USB162__) || defined(__AVR_ATmega32U2__) || defined(__AVR_ATmega16U2__) || defined(__AVR_ATmega8U2__)
+	// for the u2 Series the datasheet is confusing. On page 40 its called PINDIV and on page 290 its called PLLP0
+#if F_CPU == 16000000UL
+	// Need 16 MHz xtal
+	PLLCSR |= (1 << PLLP0);
+#elif F_CPU == 8000000UL
+	// Need 8 MHz xtal
+	PLLCSR &= ~(1 << PLLP0);
+#endif
+
+// AT90USB646, AT90USB647, AT90USB1286, AT90USB1287
+#elif defined(PLLP2)
+#if F_CPU == 16000000UL
+#if defined(__AVR_AT90USB1286__) || defined(__AVR_AT90USB1287__)
+	// For Atmel AT90USB128x only. Do not use with Atmel AT90USB64x.
+	PLLCSR = (PLLCSR & ~(1<<PLLP1)) | ((1<<PLLP2) | (1<<PLLP0)); // Need 16 MHz xtal
+#elif defined(__AVR_AT90USB646__) || defined(__AVR_AT90USB647__)
+	// For AT90USB64x only. Do not use with AT90USB128x.
+	PLLCSR = (PLLCSR & ~(1<<PLLP0)) | ((1<<PLLP2) | (1<<PLLP1)); // Need 16 MHz xtal
+#else
+#error "USB Chip not supported, please defined method of USB PLL initialization"
+#endif
+#elif F_CPU == 8000000UL
+	// for Atmel AT90USB128x and AT90USB64x
+	PLLCSR = (PLLCSR & ~(1<<PLLP2)) | ((1<<PLLP1) | (1<<PLLP0)); // Need 8 MHz xtal
+#else
+#error "Clock rate of F_CPU not supported"
+#endif
+#else
+#error "USB Chip not supported, please defined method of USB PLL initialization"
+#endif
+
+	PLLCSR |= (1<<PLLE);
+	while (!(PLLCSR & (1<<PLOCK)))		// wait for lock pll
+	{
+	}
+
+	// Some tests on specific versions of macosx (10.7.3), reported some
+	// strange behaviors when the board is reset using the serial
+	// port touch at 1200 bps. This delay fixes this behavior.
+	delay(1);
+#if defined(OTGPADE)
+	USBCON = (USBCON & ~(1<<FRZCLK)) | (1<<OTGPADE);	// start USB clock, enable VBUS Pad
+#else
+	USBCON &= ~(1 << FRZCLK);	// start USB clock
+#endif
+
+#if defined(RSTCPU)
+#if defined(LSM)
+	UDCON &= ~((1<<RSTCPU) | (1<<LSM) | (1<<RMWKUP) | (1<<DETACH));	// enable attach resistor, set full speed mode
+#else // u2 Series
+	UDCON &= ~((1 << RSTCPU) | (1 << RMWKUP) | (1 << DETACH));	// enable attach resistor, set full speed mode
+#endif
+#else
+	// AT90USB64x and AT90USB128x don't have RSTCPU
+	UDCON &= ~((1<<LSM) | (1<<RMWKUP) | (1<<DETACH));	// enable attach resistor, set full speed mode
+#endif
+}
+
+//	General interrupt
+ISR(USB_GEN_vect)
+{
+	u8 udint = UDINT;
+	UDINT &= ~((1<<EORSTI) | (1<<SOFI)); // clear the IRQ flags for the IRQs which are handled here, except WAKEUPI and SUSPI (see below)
+
+	//	End of Reset
+	if (udint & (1<<EORSTI))
+	{
+		InitEP(0,EP_TYPE_CONTROL,EP_SINGLE_64);	// init ep0
+		_usbConfiguration = 0;			// not configured yet
+		UEIENX = 1 << RXSTPE;			// Enable interrupts for ep0
+	}
+
+	//	Start of Frame - happens every millisecond so we use it for TX and RX LED one-shot timing, too
+	if (udint & (1<<SOFI))
+	{
+		USB_Flush(CDC_TX);				// Send a tx frame if found
+		
+		// check whether the one-shot period has elapsed.  if so, turn off the LED
+		if (TxLEDPulse && !(--TxLEDPulse))
+			TXLED0;
+		if (RxLEDPulse && !(--RxLEDPulse))
+			RXLED0;
+	}
+
+	// the WAKEUPI interrupt is triggered as soon as there are non-idle patterns on the data
+	// lines. Thus, the WAKEUPI interrupt can occur even if the controller is not in the "suspend" mode.
+	// Therefore the we enable it only when USB is suspended
+	if (udint & (1<<WAKEUPI))
+	{
+		UDIEN = (UDIEN & ~(1<<WAKEUPE)) | (1<<SUSPE); // Disable interrupts for WAKEUP and enable interrupts for SUSPEND
+
+		//TODO
+		// WAKEUPI shall be cleared by software (USB clock inputs must be enabled before).
+		//USB_ClockEnable();
+		UDINT &= ~(1<<WAKEUPI);
+		_usbSuspendState = (_usbSuspendState & ~(1<<SUSPI)) | (1<<WAKEUPI);
+	}
+	else if (udint & (1<<SUSPI)) // only one of the WAKEUPI / SUSPI bits can be active at time
+	{
+		UDIEN = (UDIEN & ~(1<<SUSPE)) | (1<<WAKEUPE); // Disable interrupts for SUSPEND and enable interrupts for WAKEUP
+
+		//TODO
+		//USB_ClockDisable();
+
+		UDINT &= ~((1<<WAKEUPI) | (1<<SUSPI)); // clear any already pending WAKEUP IRQs and the SUSPI request
+		_usbSuspendState = (_usbSuspendState & ~(1<<WAKEUPI)) | (1<<SUSPI);
+	}
+}
+
+//	VBUS or counting frames
+//	Any frame counting?
+u8 USBConnected()
+{
+	u8 f = UDFNUML;
+	delay(3);
+	return f != UDFNUML;
+}
+
+//=======================================================================
+//=======================================================================
+
+USBDevice_ USBDevice;
+
+USBDevice_::USBDevice_()
+{
+}
+
+void USBDevice_::attach()
+{
+	_usbConfiguration = 0;
+	_usbCurrentStatus = 0;
+	_usbSuspendState = 0;
+	USB_ClockEnable();
+
+	UDINT &= ~((1<<WAKEUPI) | (1<<SUSPI)); // clear already pending WAKEUP / SUSPEND requests
+	UDIEN = (1<<EORSTE) | (1<<SOFE) | (1<<SUSPE);	// Enable interrupts for EOR (End of Reset), SOF (start of frame) and SUSPEND
+	
+	TX_RX_LED_INIT;
+}
+
+void USBDevice_::detach()
+{
+}
+
+//	Check for interrupts
+//	TODO: VBUS detection
+bool USBDevice_::configured()
+{
+	return _usbConfiguration;
+}
+
+void USBDevice_::poll()
+{
+}
+
+bool USBDevice_::wakeupHost()
+{
+	// clear any previous wakeup request which might have been set but could be processed at that time
+	// e.g. because the host was not suspended at that time
+	UDCON &= ~(1 << RMWKUP);
+
+	if(!(UDCON & (1 << RMWKUP))
+	  && (_usbSuspendState & (1<<SUSPI))
+	  && (_usbCurrentStatus & FEATURE_REMOTE_WAKEUP_ENABLED))
+	{
+		// This short version will only work, when the device has not been suspended. Currently the
+		// Arduino core doesn't handle SUSPEND at all, so this is ok.
+		USB_ClockEnable();
+		UDCON |= (1 << RMWKUP); // send the wakeup request
+		return true;
+	}
+
+	return false;
+}
+
+bool USBDevice_::isSuspended()
+{
+	return (_usbSuspendState & (1 << SUSPI));
+}
+
+
+#endif /* if defined(USBCON) */

test/arduino_leonardo_bridge_multi_cdc/USBCore.h

@@ -0,0 +1,317 @@
+
+// Copyright (c) 2010, Peter Barrett 
+/*
+** Permission to use, copy, modify, and/or distribute this software for  
+** any purpose with or without fee is hereby granted, provided that the  
+** above copyright notice and this permission notice appear in all copies.  
+**  
+** THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL  
+** WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED  
+** WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR  
+** BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES  
+** OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,  
+** WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,  
+** ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS  
+** SOFTWARE.  
+*/
+
+#ifndef __USBCORE_H__
+#define __USBCORE_H__
+
+#include "USBAPI.h"
+
+//	Standard requests
+#define GET_STATUS			0
+#define CLEAR_FEATURE		1
+#define SET_FEATURE			3
+#define SET_ADDRESS			5
+#define GET_DESCRIPTOR		6
+#define SET_DESCRIPTOR		7
+#define GET_CONFIGURATION	8
+#define SET_CONFIGURATION	9
+#define GET_INTERFACE		10
+#define SET_INTERFACE		11
+
+
+// bmRequestType
+#define REQUEST_HOSTTODEVICE	0x00
+#define REQUEST_DEVICETOHOST	0x80
+#define REQUEST_DIRECTION		0x80
+
+#define REQUEST_STANDARD		0x00
+#define REQUEST_CLASS			0x20
+#define REQUEST_VENDOR			0x40
+#define REQUEST_TYPE			0x60
+
+#define REQUEST_DEVICE			0x00
+#define REQUEST_INTERFACE		0x01
+#define REQUEST_ENDPOINT		0x02
+#define REQUEST_OTHER			0x03
+#define REQUEST_RECIPIENT		0x03
+
+#define REQUEST_DEVICETOHOST_CLASS_INTERFACE    (REQUEST_DEVICETOHOST | REQUEST_CLASS | REQUEST_INTERFACE)
+#define REQUEST_HOSTTODEVICE_CLASS_INTERFACE    (REQUEST_HOSTTODEVICE | REQUEST_CLASS | REQUEST_INTERFACE)
+#define REQUEST_DEVICETOHOST_STANDARD_INTERFACE (REQUEST_DEVICETOHOST | REQUEST_STANDARD | REQUEST_INTERFACE)
+
+//	Class requests
+
+#define CDC_SET_LINE_CODING			0x20
+#define CDC_GET_LINE_CODING			0x21
+#define CDC_SET_CONTROL_LINE_STATE	0x22
+#define CDC_SEND_BREAK				0x23
+
+#define MSC_RESET					0xFF
+#define MSC_GET_MAX_LUN				0xFE
+
+//	Descriptors
+
+#define USB_DEVICE_DESC_SIZE 18
+#define USB_CONFIGUARTION_DESC_SIZE 9
+#define USB_INTERFACE_DESC_SIZE 9
+#define USB_ENDPOINT_DESC_SIZE 7
+
+#define USB_DEVICE_DESCRIPTOR_TYPE             1
+#define USB_CONFIGURATION_DESCRIPTOR_TYPE      2
+#define USB_STRING_DESCRIPTOR_TYPE             3
+#define USB_INTERFACE_DESCRIPTOR_TYPE          4
+#define USB_ENDPOINT_DESCRIPTOR_TYPE           5
+
+// usb_20.pdf Table 9.6 Standard Feature Selectors
+#define DEVICE_REMOTE_WAKEUP                   1
+#define ENDPOINT_HALT                          2
+#define TEST_MODE                              3
+
+// usb_20.pdf Figure 9-4. Information Returned by a GetStatus() Request to a Device
+#define FEATURE_SELFPOWERED_ENABLED     (1 << 0)
+#define FEATURE_REMOTE_WAKEUP_ENABLED   (1 << 1)
+
+#define USB_DEVICE_CLASS_COMMUNICATIONS        0x02
+#define USB_DEVICE_CLASS_HUMAN_INTERFACE       0x03
+#define USB_DEVICE_CLASS_STORAGE               0x08
+#define USB_DEVICE_CLASS_VENDOR_SPECIFIC       0xFF
+
+#define USB_CONFIG_POWERED_MASK                0x40
+#define USB_CONFIG_BUS_POWERED                 0x80
+#define USB_CONFIG_SELF_POWERED                0xC0
+#define USB_CONFIG_REMOTE_WAKEUP               0x20
+
+// bMaxPower in Configuration Descriptor
+#define USB_CONFIG_POWER_MA(mA)                ((mA)/2)
+
+// bEndpointAddress in Endpoint Descriptor
+#define USB_ENDPOINT_DIRECTION_MASK            0x80
+#define USB_ENDPOINT_OUT(addr)                 (lowByte((addr) | 0x00))
+#define USB_ENDPOINT_IN(addr)                  (lowByte((addr) | 0x80))
+
+#define USB_ENDPOINT_TYPE_MASK                 0x03
+#define USB_ENDPOINT_TYPE_CONTROL              0x00
+#define USB_ENDPOINT_TYPE_ISOCHRONOUS          0x01
+#define USB_ENDPOINT_TYPE_BULK                 0x02
+#define USB_ENDPOINT_TYPE_INTERRUPT            0x03
+
+#define TOBYTES(x) ((x) & 0xFF),(((x) >> 8) & 0xFF)
+
+#define CDC_V1_10                               0x0110
+#define CDC_COMMUNICATION_INTERFACE_CLASS       0x02
+
+#define CDC_CALL_MANAGEMENT                     0x01
+#define CDC_ABSTRACT_CONTROL_MODEL              0x02
+#define CDC_HEADER                              0x00
+#define CDC_ABSTRACT_CONTROL_MANAGEMENT         0x02
+#define CDC_UNION                               0x06
+#define CDC_CS_INTERFACE                        0x24
+#define CDC_CS_ENDPOINT                         0x25
+#define CDC_DATA_INTERFACE_CLASS                0x0A
+
+#define MSC_SUBCLASS_SCSI						0x06 
+#define MSC_PROTOCOL_BULK_ONLY					0x50 
+
+#ifndef USB_VERSION
+#define USB_VERSION 0x200
+#endif
+
+//	Device
+typedef struct {
+	u8 len;				// 18
+	u8 dtype;			// 1 USB_DEVICE_DESCRIPTOR_TYPE
+	u16 usbVersion;		// 0x200 or 0x210
+	u8	deviceClass;
+	u8	deviceSubClass;
+	u8	deviceProtocol;
+	u8	packetSize0;	// Packet 0
+	u16	idVendor;
+	u16	idProduct;
+	u16	deviceVersion;	// 0x100
+	u8	iManufacturer;
+	u8	iProduct;
+	u8	iSerialNumber;
+	u8	bNumConfigurations;
+} DeviceDescriptor;
+
+//	Config
+typedef struct {
+	u8	len;			// 9
+	u8	dtype;			// 2
+	u16 clen;			// total length
+	u8	numInterfaces;
+	u8	config;
+	u8	iconfig;
+	u8	attributes;
+	u8	maxPower;
+} ConfigDescriptor;
+
+//	String
+
+//	Interface
+typedef struct
+{
+	u8 len;		// 9
+	u8 dtype;	// 4
+	u8 number;
+	u8 alternate;
+	u8 numEndpoints;
+	u8 interfaceClass;
+	u8 interfaceSubClass;
+	u8 protocol;
+	u8 iInterface;
+} InterfaceDescriptor;
+
+//	Endpoint
+typedef struct
+{
+	u8 len;		// 7
+	u8 dtype;	// 5
+	u8 addr;
+	u8 attr;
+	u16 packetSize;
+	u8 interval;
+} EndpointDescriptor;
+
+// Interface Association Descriptor
+// Used to bind 2 interfaces together in CDC compostite device
+typedef struct
+{
+	u8 len;				// 8
+	u8 dtype;			// 11
+	u8 firstInterface;
+	u8 interfaceCount;
+	u8 functionClass;
+	u8 funtionSubClass;
+	u8 functionProtocol;
+	u8 iInterface;
+} IADDescriptor;
+
+//	CDC CS interface descriptor
+typedef struct
+{
+	u8 len;		// 5
+	u8 dtype;	// 0x24
+	u8 subtype;
+	u8 d0;
+	u8 d1;
+} CDCCSInterfaceDescriptor;
+
+typedef struct
+{
+	u8 len;		// 4
+	u8 dtype;	// 0x24
+	u8 subtype;
+	u8 d0;
+} CDCCSInterfaceDescriptor4;
+
+typedef struct 
+{
+    u8	len;
+    u8 	dtype;		// 0x24
+    u8 	subtype;	// 1
+    u8 	bmCapabilities;
+    u8 	bDataInterface;
+} CMFunctionalDescriptor;
+	
+typedef struct 
+{
+    u8	len;
+    u8 	dtype;		// 0x24
+    u8 	subtype;	// 1
+    u8 	bmCapabilities;
+} ACMFunctionalDescriptor;
+
+typedef struct 
+{
+	//	IAD
+	IADDescriptor				iad;	// Only needed on compound device
+
+	//	Control
+	InterfaceDescriptor			cif;	// 
+	CDCCSInterfaceDescriptor	header;
+	CMFunctionalDescriptor		callManagement;			// Call Management
+	ACMFunctionalDescriptor		controlManagement;		// ACM
+	CDCCSInterfaceDescriptor	functionalDescriptor;	// CDC_UNION
+	EndpointDescriptor			cifin;
+
+	//	Data
+	InterfaceDescriptor			dif;
+	EndpointDescriptor			in;
+	EndpointDescriptor			out;
+
+  // kai:added
+  IADDescriptor       iad2;  // Only needed on compound device
+
+  //  Control
+  InterfaceDescriptor     cif2;  // 
+  CDCCSInterfaceDescriptor  header2;
+  CMFunctionalDescriptor    callManagement2;     // Call Management
+  ACMFunctionalDescriptor   controlManagement2;    // ACM
+  CDCCSInterfaceDescriptor  functionalDescriptor2; // CDC_UNION
+  EndpointDescriptor      cifin2;
+
+  //  Data
+  InterfaceDescriptor     dif2;
+  EndpointDescriptor      in2;
+  EndpointDescriptor      out2;
+} CDCDescriptor;
+
+typedef struct 
+{
+	InterfaceDescriptor			msc;
+	EndpointDescriptor			in;
+	EndpointDescriptor			out;
+} MSCDescriptor;
+
+
+#define D_DEVICE(_class,_subClass,_proto,_packetSize0,_vid,_pid,_version,_im,_ip,_is,_configs) \
+	{ 18, 1, USB_VERSION, _class,_subClass,_proto,_packetSize0,_vid,_pid,_version,_im,_ip,_is,_configs }
+
+#define D_CONFIG(_totalLength,_interfaces) \
+	{ 9, 2, _totalLength,_interfaces, 1, 0, USB_CONFIG_BUS_POWERED | USB_CONFIG_REMOTE_WAKEUP, USB_CONFIG_POWER_MA(500) }
+
+#define D_INTERFACE(_n,_numEndpoints,_class,_subClass,_protocol) \
+	{ 9, 4, _n, 0, _numEndpoints, _class,_subClass, _protocol, 0 }
+
+#define D_ENDPOINT(_addr,_attr,_packetSize, _interval) \
+	{ 7, 5, _addr,_attr,_packetSize, _interval }
+
+#define D_IAD(_firstInterface, _count, _class, _subClass, _protocol) \
+	{ 8, 11, _firstInterface, _count, _class, _subClass, _protocol, 0 }
+
+#define D_CDCCS(_subtype,_d0,_d1)	{ 5, 0x24, _subtype, _d0, _d1 }
+#define D_CDCCS4(_subtype,_d0)		{ 4, 0x24, _subtype, _d0 }
+
+// Bootloader related fields
+// Old Caterina bootloader places the MAGIC key into unsafe RAM locations (it can be rewritten
+// by the running sketch before to actual reboot).
+// Newer bootloaders, recognizable by the LUFA "signature" at the end of the flash, can handle both
+// the usafe and the safe location.
+#ifndef MAGIC_KEY
+#define MAGIC_KEY 0x7777
+#endif
+
+#ifndef MAGIC_KEY_POS
+#define MAGIC_KEY_POS 0x0800
+#endif
+
+#ifndef NEW_LUFA_SIGNATURE
+#define NEW_LUFA_SIGNATURE 0xDCFB
+#endif
+
+#endif

test/arduino_leonardo_bridge_multi_cdc/USBDesc.h

@@ -0,0 +1,77 @@
+/*
+   Copyright (c) 2011, Peter Barrett
+   Copyright (c) 2015, Arduino LLC
+
+   Permission to use, copy, modify, and/or distribute this software for
+   any purpose with or without fee is hereby granted, provided that the
+   above copyright notice and this permission notice appear in all copies.
+
+   THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+   WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+   WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR
+   BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES
+   OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+   WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+   ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+   SOFTWARE.
+ */
+
+#define PLUGGABLE_USB_ENABLED
+
+#if defined(EPRST6)
+#define USB_ENDPOINTS 7 // AtMegaxxU4
+#else
+#define USB_ENDPOINTS 5 // AtMegaxxU2
+#endif
+
+#define ISERIAL_MAX_LEN     20
+
+#define CDC_INTERFACE_COUNT	2
+#define CDC_ENPOINT_COUNT	3
+
+// kai:begin
+#undef CDC_ACM_INTERFACE
+#undef CDC_DATA_INTERFACE
+#undef CDC_FIRST_ENDPOINT
+#undef CDC_ENDPOINT_ACM
+#undef CDC_ENDPOINT_OUT
+#undef CDC_ENDPOINT_IN
+#undef CDC_RX
+#undef CDC_TX
+
+#define CDC_ACM_INTERFACE1	0	// CDC ACM
+#define CDC_DATA_INTERFACE1	1	// CDC Data
+#define CDC_FIRST_ENDPOINT1	1
+#define CDC_ENDPOINT_ACM1	(CDC_FIRST_ENDPOINT1)							// CDC First
+#define CDC_ENDPOINT_OUT1	(CDC_FIRST_ENDPOINT1+1)
+#define CDC_ENDPOINT_IN1		(CDC_FIRST_ENDPOINT1+2)
+
+#define CDC_ACM_INTERFACE2  2 // CDC ACM
+#define CDC_DATA_INTERFACE2  3 // CDC Data
+#define CDC_FIRST_ENDPOINT2  4 
+#define CDC_ENDPOINT_ACM2  (CDC_FIRST_ENDPOINT2)              // CDC First
+#define CDC_ENDPOINT_OUT2  (CDC_FIRST_ENDPOINT2+1)
+#define CDC_ENDPOINT_IN2  (CDC_FIRST_ENDPOINT2+2)
+
+// only one of both interfaces is functional:
+#define ACTIVE_INTERFACE 1
+
+#if ACTIVE_INTERFACE == 1
+# define CDC_CLASS_INTERFACE CDC_ACM_INTERFACE1
+# define CDC_RX              CDC_ENDPOINT_OUT1
+# define CDC_TX              CDC_ENDPOINT_IN1
+#else
+# define CDC_CLASS_INTERFACE CDC_ACM_INTERFACE2
+# define CDC_RX              CDC_ENDPOINT_OUT2
+# define CDC_TX              CDC_ENDPOINT_IN2
+#endif
+
+#undef USB_VID
+#define USB_VID 0x2342
+// kai:end
+
+#define INTERFACE_COUNT    (MSC_INTERFACE + MSC_INTERFACE_COUNT)
+
+#define IMANUFACTURER   1
+#define IPRODUCT        2
+#define ISERIAL         3

test/arduino_leonardo_bridge_multi_cdc/arduino_leonardo_bridge_multi_cdc.ino

@@ -0,0 +1,64 @@
+/*
+  bridge USB-serial to hardware-serial
+
+  for Arduinos based on ATmega32u4 (Leonardo and compatible Pro Micro, Micro)
+  hardware serial is configured with baud-rate, databits, stopbits, parity as send over USB
+
+  see https://github.com/arduino/Arduino/tree/master/hardware/arduino/avr/cores/arduino 
+  -> CDC.cpp|HardwareSerial.cpp for serial implementation details
+
+  this sketch is mainly for demonstration / test of CDC communication
+  performance as real usb-serial bridge would be inacceptable as each byte is send in separate USB packet
+*/
+
+uint32_t baud = 9600;
+uint8_t databits = 8;
+uint8_t stopbits = 1;
+uint8_t parity = 0;
+
+void setup() {
+  Serial.begin(baud); // USB
+  Serial1.begin(baud, SERIAL_8N1);
+}
+
+void loop() {
+  // show USB connected state
+  if (Serial) TXLED1;
+  else        TXLED0;
+
+  // configure hardware serial
+  if (Serial.baud() != baud ||
+      Serial.numbits() != databits ||
+      Serial.stopbits() != stopbits ||
+      Serial.paritytype() != parity) {
+    baud = Serial.baud();
+    databits = Serial.numbits();
+    stopbits = Serial.stopbits();
+    parity = Serial.paritytype();
+    uint8_t config = 0; // ucsrc register
+    switch (databits) {
+      case 5: break;
+      case 6: config |= 2; break;
+      case 7: config |= 4; break;
+      case 8: config |= 6; break;
+      default: config |= 6;
+    }
+    switch (stopbits) {
+      case 2: config |= 8;
+        // 1.5 stopbits not supported
+    }
+    switch (parity) {
+      case 1: config |= 0x30; break; // odd
+      case 2: config |= 0x20; break; // even
+        // mark, space not supported
+    }
+    Serial1.end();
+    Serial1.begin(baud, config);
+  }
+
+  // bridge
+  if (Serial.available() > 0)
+    Serial1.write(Serial.read());
+  if (Serial1.available() > 0)
+    Serial.write(Serial1.read());
+}

test/pi_pico/README.md

@@ -0,0 +1,6 @@
+
+# `tinyusb_dev_cdc_dual_ports.uf2`
+
+compiled from `C:/Program Files/Raspberry Pi/Pico SDK v1.5.1/pico-sdk/lib/tinyusb/examples/device/cdc_dual_ports`
+to `C:/Users/` _user_`/Documents/Pico-v1.5.1/pico-examples/build/usb/device/tinyusb_device_examples/cdc_dual_ports/tinyusb_dev_cdc_dual_ports.uf2`
+

test/rfc2217_server.diff

@@ -0,0 +1,42 @@
+*** /n/archiv/python/rfc2217_server.py	2018-03-10 09:02:07.613771600 +0100
+--- rfc2217_server.py	2018-03-09 20:57:44.933717100 +0100
+***************
+*** 26,31 ****
+--- 26,32 ----
+              self,
+              logger=logging.getLogger('rfc2217.server') if debug else None)
+          self.log = logging.getLogger('redirector')
++         self.dlog = logging.getLogger('data')
+  
+      def statusline_poller(self):
+          self.log.debug('status line poll thread started')
+***************
+*** 55,60 ****
+--- 56,62 ----
+              try:
+                  data = self.serial.read(self.serial.in_waiting or 1)
+                  if data:
++                     self.dlog.debug("serial read: "+data.encode('hex'))
+                      # escape outgoing data when needed (Telnet IAC (0xff) character)
+                      self.write(b''.join(self.rfc2217.escape(data)))
+              except socket.error as msg:
+***************
+*** 76,81 ****
+--- 78,84 ----
+                  data = self.socket.recv(1024)
+                  if not data:
+                      break
++                 self.dlog.debug("socket read: "+data.encode('hex'))
+                  self.serial.write(b''.join(self.rfc2217.filter(data)))
+              except socket.error as msg:
+                  self.log.error('{}'.format(msg))
+***************
+*** 132,137 ****
+--- 135,141 ----
+      logging.basicConfig(level=logging.INFO)
+      #~ logging.getLogger('root').setLevel(logging.INFO)
+      logging.getLogger('rfc2217').setLevel(level)
++     logging.getLogger('data').setLevel(level)
+  
+      # connect to serial port
+      ser = serial.serial_for_url(args.SERIALPORT, do_not_open=True)

usbSerialExamples/build.gradle

@@ -0,0 +1,33 @@
+plugins {
+    id 'com.android.application'
+}
+
+android {
+    compileSdkVersion 35
+
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_8
+        targetCompatibility JavaVersion.VERSION_1_8
+    }
+
+    defaultConfig {
+        minSdkVersion 17
+        targetSdkVersion 35
+        vectorDrawables.useSupportLibrary = true
+
+        missingDimensionStrategy 'device', 'anyDevice'
+    }
+
+    buildTypes {
+        release {
+            minifyEnabled true
+        }
+    }
+    namespace 'com.hoho.android.usbserial.examples'
+}
+
+dependencies {
+    implementation project(':usbSerialForAndroid')
+    implementation 'androidx.appcompat:appcompat:1.6.1' // later versions have minsdk 21
+    implementation 'com.google.android.material:material:1.11.0' // later versions have minsdk 19
+}

usbSerialExamples/src/main/AndroidManifest.xml

@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools">
+
+    <!-- mipmap/ic_launcher created with Android Studio -> New -> Image Asset using @color/colorPrimary and USB clip art -->
+    <application
+        android:icon="@mipmap/ic_launcher"
+        android:label="@string/app_name"
+        android:theme="@style/AppTheme"
+        tools:ignore="AllowBackup,GoogleAppIndexingWarning">
+        <!-- for this simple app launchMode=singleTask and singleTop have same effect.
+             If you would start another activity in the app, e.g. Android Settings
+             then you should use singleTask, else a new MainActivity would be started
+             when the settings activity is currently shown -->
+        <activity
+            android:name=".MainActivity"
+            android:launchMode="singleTask"
+            android:windowSoftInputMode="stateHidden|adjustResize"
+            android:exported="true">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+            <intent-filter>
+                <action android:name="android.hardware.usb.action.USB_DEVICE_ATTACHED" />
+            </intent-filter>
+            <meta-data
+                android:name="android.hardware.usb.action.USB_DEVICE_ATTACHED"
+                android:resource="@xml/device_filter" />
+        </activity>
+    </application>
+</manifest>

usbSerialExamples/src/main/java/com/hoho/android/usbserial/examples/CustomProber.java

@@ -0,0 +1,22 @@
+package com.hoho.android.usbserial.examples;
+
+import com.hoho.android.usbserial.driver.FtdiSerialDriver;
+import com.hoho.android.usbserial.driver.ProbeTable;
+import com.hoho.android.usbserial.driver.UsbSerialProber;
+
+/**
+ * add devices here, that are not known to DefaultProber
+ *
+ * if the App should auto start for these devices, also
+ * add IDs to app/src/main/res/xml/device_filter.xml
+ */
+class CustomProber {
+
+    static UsbSerialProber getCustomProber() {
+        ProbeTable customTable = new ProbeTable();
+        customTable.addProduct(0x1234, 0x0001, FtdiSerialDriver.class); // e.g. device with custom VID+PID
+        customTable.addProduct(0x1234, 0x0002, FtdiSerialDriver.class); // e.g. device with custom VID+PID
+        return new UsbSerialProber(customTable);
+    }
+
+}

usbSerialExamples/src/main/java/com/hoho/android/usbserial/examples/DevicesFragment.java

@@ -0,0 +1,164 @@
+package com.hoho.android.usbserial.examples;
+
+import android.app.AlertDialog;
+import android.content.Context;
+import android.hardware.usb.UsbDevice;
+import android.hardware.usb.UsbManager;
+import android.os.Bundle;
+
+import androidx.annotation.NonNull;
+import androidx.fragment.app.Fragment;
+import androidx.fragment.app.ListFragment;
+import android.view.Menu;
+import android.view.MenuInflater;
+import android.view.MenuItem;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.ArrayAdapter;
+import android.widget.ListView;
+import android.widget.TextView;
+import android.widget.Toast;
+
+import com.hoho.android.usbserial.driver.UsbSerialDriver;
+import com.hoho.android.usbserial.driver.UsbSerialProber;
+
+import java.util.ArrayList;
+import java.util.Locale;
+
+public class DevicesFragment extends ListFragment {
+
+    static class ListItem {
+        UsbDevice device;
+        int port;
+        UsbSerialDriver driver;
+
+        ListItem(UsbDevice device, int port, UsbSerialDriver driver) {
+            this.device = device;
+            this.port = port;
+            this.driver = driver;
+        }
+    }
+
+    private final ArrayList<ListItem> listItems = new ArrayList<>();
+    private ArrayAdapter<ListItem> listAdapter;
+    private int baudRate = 19200;
+    private boolean withIoManager = true;
+
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setHasOptionsMenu(true);
+        listAdapter = new ArrayAdapter<ListItem>(getActivity(), 0, listItems) {
+            @NonNull
+            @Override
+            public View getView(int position, View view, @NonNull ViewGroup parent) {
+                ListItem item = listItems.get(position);
+                if (view == null)
+                    view = getActivity().getLayoutInflater().inflate(R.layout.device_list_item, parent, false);
+                TextView text1 = view.findViewById(R.id.text1);
+                TextView text2 = view.findViewById(R.id.text2);
+                if(item.driver == null)
+                    text1.setText("<no driver>");
+                else if(item.driver.getPorts().size() == 1)
+                    text1.setText(item.driver.getClass().getSimpleName().replace("SerialDriver",""));
+                else
+                    text1.setText(item.driver.getClass().getSimpleName().replace("SerialDriver","")+", Port "+item.port);
+                text2.setText(String.format(Locale.US, "Vendor %04X, Product %04X", item.device.getVendorId(), item.device.getProductId()));
+                return view;
+            }
+        };
+    }
+
+    @Override
+    public void onActivityCreated(Bundle savedInstanceState) {
+        super.onActivityCreated(savedInstanceState);
+        setListAdapter(null);
+        View header = getActivity().getLayoutInflater().inflate(R.layout.device_list_header, null, false);
+        getListView().addHeaderView(header, null, false);
+        setEmptyText("<no USB devices found>");
+        ((TextView) getListView().getEmptyView()).setTextSize(18);
+        setListAdapter(listAdapter);
+    }
+
+    @Override
+    public void onCreateOptionsMenu(@NonNull Menu menu, MenuInflater inflater) {
+        inflater.inflate(R.menu.menu_devices, menu);
+    }
+
+    @Override
+    public void onResume() {
+        super.onResume();
+        refresh();
+    }
+
+    @Override
+    public boolean onOptionsItemSelected(MenuItem item) {
+        int id = item.getItemId();
+        if(id == R.id.refresh) {
+            refresh();
+            return true;
+        } else if (id ==R.id.baud_rate) {
+            final String[] values = getResources().getStringArray(R.array.baud_rates);
+            int pos = java.util.Arrays.asList(values).indexOf(String.valueOf(baudRate));
+            AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
+            builder.setTitle("Baud rate");
+            builder.setSingleChoiceItems(values, pos, (dialog, which) -> {
+                baudRate = Integer.parseInt(values[which]);
+                dialog.dismiss();
+            });
+            builder.create().show();
+            return true;
+        } else if (id ==R.id.read_mode) {
+            final String[] values = getResources().getStringArray(R.array.read_modes);
+            int pos = withIoManager ? 0 : 1; // read_modes[0]=event/io-manager, read_modes[1]=direct
+            AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
+            builder.setTitle("Read mode");
+            builder.setSingleChoiceItems(values, pos, (dialog, which) -> {
+                withIoManager = (which == 0);
+                dialog.dismiss();
+            });
+            builder.create().show();
+            return true;
+        } else {
+            return super.onOptionsItemSelected(item);
+        }
+    }
+
+    void refresh() {
+        UsbManager usbManager = (UsbManager) getActivity().getSystemService(Context.USB_SERVICE);
+        UsbSerialProber usbDefaultProber = UsbSerialProber.getDefaultProber();
+        UsbSerialProber usbCustomProber = CustomProber.getCustomProber();
+        listItems.clear();
+        for(UsbDevice device : usbManager.getDeviceList().values()) {
+            UsbSerialDriver driver = usbDefaultProber.probeDevice(device);
+            if(driver == null) {
+                driver = usbCustomProber.probeDevice(device);
+            }
+            if(driver != null) {
+                for(int port = 0; port < driver.getPorts().size(); port++)
+                    listItems.add(new ListItem(device, port, driver));
+            } else {
+                listItems.add(new ListItem(device, 0, null));
+            }
+        }
+        listAdapter.notifyDataSetChanged();
+    }
+
+    @Override
+    public void onListItemClick(@NonNull ListView l, @NonNull View v, int position, long id) {
+        ListItem item = listItems.get(position-1);
+        if(item.driver == null) {
+            Toast.makeText(getActivity(), "no driver", Toast.LENGTH_SHORT).show();
+        } else {
+            Bundle args = new Bundle();
+            args.putInt("device", item.device.getDeviceId());
+            args.putInt("port", item.port);
+            args.putInt("baud", baudRate);
+            args.putBoolean("withIoManager", withIoManager);
+            Fragment fragment = new TerminalFragment();
+            fragment.setArguments(args);
+            getFragmentManager().beginTransaction().replace(R.id.fragment, fragment, "terminal").addToBackStack(null).commit();
+        }
+    }
+
+}

usbSerialExamples/src/main/java/com/hoho/android/usbserial/examples/MainActivity.java

@@ -0,0 +1,45 @@
+package com.hoho.android.usbserial.examples;
+
+import android.content.Intent;
+import android.os.Bundle;
+import androidx.fragment.app.FragmentManager;
+import androidx.appcompat.app.AppCompatActivity;
+import androidx.appcompat.widget.Toolbar;
+
+public class MainActivity extends AppCompatActivity implements FragmentManager.OnBackStackChangedListener {
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.activity_main);
+        Toolbar toolbar = findViewById(R.id.toolbar);
+        setSupportActionBar(toolbar);
+        getSupportFragmentManager().addOnBackStackChangedListener(this);
+        if (savedInstanceState == null)
+            getSupportFragmentManager().beginTransaction().add(R.id.fragment, new DevicesFragment(), "devices").commit();
+        else
+            onBackStackChanged();
+    }
+
+    @Override
+    public void onBackStackChanged() {
+        getSupportActionBar().setDisplayHomeAsUpEnabled(getSupportFragmentManager().getBackStackEntryCount()>0);
+    }
+
+    @Override
+    public boolean onSupportNavigateUp() {
+        onBackPressed();
+        return true;
+    }
+
+    @Override
+    protected void onNewIntent(Intent intent) {
+        if("android.hardware.usb.action.USB_DEVICE_ATTACHED".equals(intent.getAction())) {
+            TerminalFragment terminal = (TerminalFragment)getSupportFragmentManager().findFragmentByTag("terminal");
+            if (terminal != null)
+                terminal.status("USB device detected");
+        }
+        super.onNewIntent(intent);
+    }
+
+}

usbSerialExamples/src/main/java/com/hoho/android/usbserial/examples/TerminalFragment.java

@@ -0,0 +1,409 @@
+package com.hoho.android.usbserial.examples;
+
+import android.app.PendingIntent;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.hardware.usb.UsbDevice;
+import android.hardware.usb.UsbDeviceConnection;
+import android.hardware.usb.UsbManager;
+import android.os.Build;
+import android.os.Bundle;
+import android.os.Handler;
+import android.os.Looper;
+import android.text.Spannable;
+import android.text.SpannableStringBuilder;
+import android.text.method.ScrollingMovementMethod;
+import android.text.style.ForegroundColorSpan;
+import android.view.LayoutInflater;
+import android.view.Menu;
+import android.view.MenuInflater;
+import android.view.MenuItem;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.TextView;
+import android.widget.Toast;
+import android.widget.ToggleButton;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.core.content.ContextCompat;
+import androidx.fragment.app.Fragment;
+
+import com.hoho.android.usbserial.driver.UsbSerialDriver;
+import com.hoho.android.usbserial.driver.UsbSerialPort;
+import com.hoho.android.usbserial.driver.UsbSerialProber;
+import com.hoho.android.usbserial.util.HexDump;
+import com.hoho.android.usbserial.util.SerialInputOutputManager;
+
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.EnumSet;
+
+public class TerminalFragment extends Fragment implements SerialInputOutputManager.Listener {
+
+    private enum UsbPermission { Unknown, Requested, Granted, Denied }
+
+    private static final String INTENT_ACTION_GRANT_USB = BuildConfig.APPLICATION_ID + ".GRANT_USB";
+    private static final int WRITE_WAIT_MILLIS = 2000;
+    private static final int READ_WAIT_MILLIS = 2000;
+
+    private int deviceId, portNum, baudRate;
+    private boolean withIoManager;
+
+    private final BroadcastReceiver broadcastReceiver;
+    private final Handler mainLooper;
+    private TextView receiveText;
+    private ControlLines controlLines;
+
+    private SerialInputOutputManager usbIoManager;
+    private UsbSerialPort usbSerialPort;
+    private UsbPermission usbPermission = UsbPermission.Unknown;
+    private boolean connected = false;
+
+    public TerminalFragment() {
+        broadcastReceiver = new BroadcastReceiver() {
+            @Override
+            public void onReceive(Context context, Intent intent) {
+                if(INTENT_ACTION_GRANT_USB.equals(intent.getAction())) {
+                    usbPermission = intent.getBooleanExtra(UsbManager.EXTRA_PERMISSION_GRANTED, false)
+                            ? UsbPermission.Granted : UsbPermission.Denied;
+                    connect();
+                }
+            }
+        };
+        mainLooper = new Handler(Looper.getMainLooper());
+    }
+
+    /*
+     * Lifecycle
+     */
+    @Override
+    public void onCreate(@Nullable Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setHasOptionsMenu(true);
+        setRetainInstance(true);
+        deviceId = getArguments().getInt("device");
+        portNum = getArguments().getInt("port");
+        baudRate = getArguments().getInt("baud");
+        withIoManager = getArguments().getBoolean("withIoManager");
+    }
+
+    @Override
+    public void onStart() {
+        super.onStart();
+        ContextCompat.registerReceiver(getActivity(), broadcastReceiver, new IntentFilter(INTENT_ACTION_GRANT_USB), ContextCompat.RECEIVER_NOT_EXPORTED);
+    }
+
+    @Override
+    public void onStop() {
+        getActivity().unregisterReceiver(broadcastReceiver);
+        super.onStop();
+    }
+
+    @Override
+    public void onResume() {
+        super.onResume();
+        if(!connected && (usbPermission == UsbPermission.Unknown || usbPermission == UsbPermission.Granted))
+            mainLooper.post(this::connect);
+    }
+
+    @Override
+    public void onPause() {
+        if(connected) {
+            status("disconnected");
+            disconnect();
+        }
+        super.onPause();
+    }
+
+    /*
+     * UI
+     */
+    @Override
+    public View onCreateView(@NonNull LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
+        View view = inflater.inflate(R.layout.fragment_terminal, container, false);
+        receiveText = view.findViewById(R.id.receive_text);                          // TextView performance decreases with number of spans
+        receiveText.setTextColor(getResources().getColor(R.color.colorRecieveText)); // set as default color to reduce number of spans
+        receiveText.setMovementMethod(ScrollingMovementMethod.getInstance());
+        TextView sendText = view.findViewById(R.id.send_text);
+        View sendBtn = view.findViewById(R.id.send_btn);
+        sendBtn.setOnClickListener(v -> send(sendText.getText().toString()));
+        View receiveBtn = view.findViewById(R.id.receive_btn);
+        controlLines = new ControlLines(view);
+        if(withIoManager) {
+            receiveBtn.setVisibility(View.GONE);
+        } else {
+            receiveBtn.setOnClickListener(v -> read());
+        }
+        return view;
+    }
+
+    @Override
+    public void onCreateOptionsMenu(@NonNull Menu menu, MenuInflater inflater) {
+        inflater.inflate(R.menu.menu_terminal, menu);
+    }
+
+    @Override
+    public boolean onOptionsItemSelected(MenuItem item) {
+        int id = item.getItemId();
+        if (id == R.id.clear) {
+            receiveText.setText("");
+            return true;
+        } else if( id == R.id.send_break) {
+            if(!connected) {
+                Toast.makeText(getActivity(), "not connected", Toast.LENGTH_SHORT).show();
+            } else {
+                try {
+                    usbSerialPort.setBreak(true);
+                    Thread.sleep(100); // should show progress bar instead of blocking UI thread
+                    usbSerialPort.setBreak(false);
+                    SpannableStringBuilder spn = new SpannableStringBuilder();
+                    spn.append("send <break>\n");
+                    spn.setSpan(new ForegroundColorSpan(getResources().getColor(R.color.colorSendText)), 0, spn.length(), Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
+                    receiveText.append(spn);
+                } catch(UnsupportedOperationException ignored) {
+                    Toast.makeText(getActivity(), "BREAK not supported", Toast.LENGTH_SHORT).show();
+                } catch(Exception e) {
+                    Toast.makeText(getActivity(), "BREAK failed: " + e.getMessage(), Toast.LENGTH_SHORT).show();
+                }
+            }
+            return true;
+        } else {
+            return super.onOptionsItemSelected(item);
+        }
+    }
+
+    /*
+     * Serial
+     */
+    @Override
+    public void onNewData(byte[] data) {
+        mainLooper.post(() -> {
+            receive(data);
+        });
+    }
+
+    @Override
+    public void onRunError(Exception e) {
+        mainLooper.post(() -> {
+            status("connection lost: " + e.getMessage());
+            disconnect();
+        });
+    }
+
+    /*
+     * Serial + UI
+     */
+    private void connect() {
+        UsbDevice device = null;
+        UsbManager usbManager = (UsbManager) getActivity().getSystemService(Context.USB_SERVICE);
+        for(UsbDevice v : usbManager.getDeviceList().values())
+            if(v.getDeviceId() == deviceId)
+                device = v;
+        if(device == null) {
+            status("connection failed: device not found");
+            return;
+        }
+        UsbSerialDriver driver = UsbSerialProber.getDefaultProber().probeDevice(device);
+        if(driver == null) {
+            driver = CustomProber.getCustomProber().probeDevice(device);
+        }
+        if(driver == null) {
+            status("connection failed: no driver for device");
+            return;
+        }
+        if(portNum >= driver.getPorts().size()) {
+            status("connection failed: not enough ports at device");
+            return;
+        }
+        usbSerialPort = driver.getPorts().get(portNum);
+        UsbDeviceConnection usbConnection = usbManager.openDevice(driver.getDevice());
+        if(usbConnection == null && usbPermission == UsbPermission.Unknown && !usbManager.hasPermission(driver.getDevice())) {
+            usbPermission = UsbPermission.Requested;
+            int flags = Build.VERSION.SDK_INT >= Build.VERSION_CODES.M ? PendingIntent.FLAG_MUTABLE : 0;
+            Intent intent = new Intent(INTENT_ACTION_GRANT_USB);
+            intent.setPackage(getActivity().getPackageName());
+            PendingIntent usbPermissionIntent = PendingIntent.getBroadcast(getActivity(), 0, intent, flags);
+            usbManager.requestPermission(driver.getDevice(), usbPermissionIntent);
+            return;
+        }
+        if(usbConnection == null) {
+            if (!usbManager.hasPermission(driver.getDevice()))
+                status("connection failed: permission denied");
+            else
+                status("connection failed: open failed");
+            return;
+        }
+
+        try {
+            usbSerialPort.open(usbConnection);
+            try{
+                usbSerialPort.setParameters(baudRate, 8, 1, UsbSerialPort.PARITY_NONE);
+            }catch (UnsupportedOperationException e){
+                status("unsupport setparameters");
+            }
+            if(withIoManager) {
+                usbIoManager = new SerialInputOutputManager(usbSerialPort, this);
+                usbIoManager.start();
+            }
+            status("connected");
+            connected = true;
+            controlLines.start();
+        } catch (Exception e) {
+            status("connection failed: " + e.getMessage());
+            disconnect();
+        }
+    }
+
+    private void disconnect() {
+        connected = false;
+        controlLines.stop();
+        if(usbIoManager != null) {
+            usbIoManager.setListener(null);
+            usbIoManager.stop();
+        }
+        usbIoManager = null;
+        try {
+            usbSerialPort.close();
+        } catch (IOException ignored) {}
+        usbSerialPort = null;
+    }
+
+    private void send(String str) {
+        if(!connected) {
+            Toast.makeText(getActivity(), "not connected", Toast.LENGTH_SHORT).show();
+            return;
+        }
+        try {
+        byte[] data = (str + '\n').getBytes();
+            SpannableStringBuilder spn = new SpannableStringBuilder();
+            spn.append("send " + data.length + " bytes\n");
+            spn.append(HexDump.dumpHexString(data)).append("\n");
+            spn.setSpan(new ForegroundColorSpan(getResources().getColor(R.color.colorSendText)), 0, spn.length(), Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
+            receiveText.append(spn);
+            usbSerialPort.write(data, WRITE_WAIT_MILLIS);
+        } catch (Exception e) {
+            onRunError(e);
+        }
+    }
+
+    private void read() {
+        if(!connected) {
+            Toast.makeText(getActivity(), "not connected", Toast.LENGTH_SHORT).show();
+            return;
+        }
+        try {
+            byte[] buffer = new byte[8192];
+            int len = usbSerialPort.read(buffer, READ_WAIT_MILLIS);
+            receive(Arrays.copyOf(buffer, len));
+        } catch (IOException e) {
+            // when using read with timeout, USB bulkTransfer returns -1 on timeout _and_ errors
+            // like connection loss, so there is typically no exception thrown here on error
+            status("connection lost: " + e.getMessage());
+            disconnect();
+        }
+    }
+
+    private void receive(byte[] data) {
+        SpannableStringBuilder spn = new SpannableStringBuilder();
+        spn.append("receive " + data.length + " bytes\n");
+        if(data.length > 0)
+            spn.append(HexDump.dumpHexString(data)).append("\n");
+        receiveText.append(spn);
+    }
+
+    void status(String str) {
+        SpannableStringBuilder spn = new SpannableStringBuilder(str+'\n');
+        spn.setSpan(new ForegroundColorSpan(getResources().getColor(R.color.colorStatusText)), 0, spn.length(), Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
+        receiveText.append(spn);
+    }
+
+    class ControlLines {
+        private static final int refreshInterval = 200; // msec
+
+        private final Runnable runnable;
+        private final ToggleButton rtsBtn, ctsBtn, dtrBtn, dsrBtn, cdBtn, riBtn;
+
+        ControlLines(View view) {
+            runnable = this::run; // w/o explicit Runnable, a new lambda would be created on each postDelayed, which would not be found again by removeCallbacks
+
+            rtsBtn = view.findViewById(R.id.controlLineRts);
+            ctsBtn = view.findViewById(R.id.controlLineCts);
+            dtrBtn = view.findViewById(R.id.controlLineDtr);
+            dsrBtn = view.findViewById(R.id.controlLineDsr);
+            cdBtn = view.findViewById(R.id.controlLineCd);
+            riBtn = view.findViewById(R.id.controlLineRi);
+            rtsBtn.setOnClickListener(this::toggle);
+            dtrBtn.setOnClickListener(this::toggle);
+        }
+
+        private void toggle(View v) {
+            ToggleButton btn = (ToggleButton) v;
+            if (!connected) {
+                btn.setChecked(!btn.isChecked());
+                Toast.makeText(getActivity(), "not connected", Toast.LENGTH_SHORT).show();
+                return;
+            }
+            String ctrl = "";
+            try {
+                if (btn.equals(rtsBtn)) { ctrl = "RTS"; usbSerialPort.setRTS(btn.isChecked()); }
+                if (btn.equals(dtrBtn)) { ctrl = "DTR"; usbSerialPort.setDTR(btn.isChecked()); }
+            } catch (IOException e) {
+                status("set" + ctrl + "() failed: " + e.getMessage());
+            }
+        }
+
+        private void run() {
+            if (!connected)
+                return;
+            try {
+                EnumSet<UsbSerialPort.ControlLine> controlLines = usbSerialPort.getControlLines();
+                rtsBtn.setChecked(controlLines.contains(UsbSerialPort.ControlLine.RTS));
+                ctsBtn.setChecked(controlLines.contains(UsbSerialPort.ControlLine.CTS));
+                dtrBtn.setChecked(controlLines.contains(UsbSerialPort.ControlLine.DTR));
+                dsrBtn.setChecked(controlLines.contains(UsbSerialPort.ControlLine.DSR));
+                cdBtn.setChecked(controlLines.contains(UsbSerialPort.ControlLine.CD));
+                riBtn.setChecked(controlLines.contains(UsbSerialPort.ControlLine.RI));
+                mainLooper.postDelayed(runnable, refreshInterval);
+            } catch (Exception e) {
+                status("getControlLines() failed: " + e.getMessage() + " -> stopped control line refresh");
+            }
+        }
+
+        void start() {
+            if (!connected)
+                return;
+            try {
+                EnumSet<UsbSerialPort.ControlLine> controlLines = usbSerialPort.getSupportedControlLines();
+                if (!controlLines.contains(UsbSerialPort.ControlLine.RTS)) rtsBtn.setVisibility(View.INVISIBLE);
+                if (!controlLines.contains(UsbSerialPort.ControlLine.CTS)) ctsBtn.setVisibility(View.INVISIBLE);
+                if (!controlLines.contains(UsbSerialPort.ControlLine.DTR)) dtrBtn.setVisibility(View.INVISIBLE);
+                if (!controlLines.contains(UsbSerialPort.ControlLine.DSR)) dsrBtn.setVisibility(View.INVISIBLE);
+                if (!controlLines.contains(UsbSerialPort.ControlLine.CD))   cdBtn.setVisibility(View.INVISIBLE);
+                if (!controlLines.contains(UsbSerialPort.ControlLine.RI))   riBtn.setVisibility(View.INVISIBLE);
+                run();
+            } catch (Exception e) {
+                Toast.makeText(getActivity(), "getSupportedControlLines() failed: " + e.getMessage(), Toast.LENGTH_SHORT).show();
+                rtsBtn.setVisibility(View.INVISIBLE);
+                ctsBtn.setVisibility(View.INVISIBLE);
+                dtrBtn.setVisibility(View.INVISIBLE);
+                dsrBtn.setVisibility(View.INVISIBLE);
+                cdBtn.setVisibility(View.INVISIBLE);
+                cdBtn.setVisibility(View.INVISIBLE);
+                riBtn.setVisibility(View.INVISIBLE);
+            }
+        }
+
+        void stop() {
+            mainLooper.removeCallbacks(runnable);
+            rtsBtn.setChecked(false);
+            ctsBtn.setChecked(false);
+            dtrBtn.setChecked(false);
+            dsrBtn.setChecked(false);
+            cdBtn.setChecked(false);
+            riBtn.setChecked(false);
+        }
+    }
+}

usbSerialExamples/src/main/res/drawable/ic_delete_white_24dp.xml

@@ -0,0 +1,9 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+        android:width="24dp"
+        android:height="24dp"
+        android:viewportWidth="24.0"
+        android:viewportHeight="24.0">
+    <path
+        android:fillColor="#FFFFFFFF"
+        android:pathData="M6,19c0,1.1 0.9,2 2,2h8c1.1,0 2,-0.9 2,-2V7H6v12zM19,4h-3.5l-1,-1h-5l-1,1H5v2h14V4z"/>
+</vector>

usbSerialExamples/src/main/res/drawable/ic_send_white_24dp.xml

@@ -0,0 +1,9 @@
+<vector  xmlns:android="http://schemas.android.com/apk/res/android"
+        android:width="24dp"
+        android:height="24dp"
+        android:viewportWidth="24.0"
+        android:viewportHeight="24.0">
+    <path
+        android:fillColor="#FFFFFFFF"
+        android:pathData="M2.01,21L23,12 2.01,3 2,10l15,2 -15,2z"/>
+</vector>

usbSerialExamples/src/main/res/layout/activity_main.xml

@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="utf-8"?>
+<androidx.coordinatorlayout.widget.CoordinatorLayout
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    tools:context=".MainActivity">
+
+    <com.google.android.material.appbar.AppBarLayout
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content">
+
+        <androidx.appcompat.widget.Toolbar
+            android:id="@+id/toolbar"
+            android:layout_width="match_parent"
+            android:layout_height="?attr/actionBarSize"
+            android:background="?attr/colorPrimary" />
+
+    </com.google.android.material.appbar.AppBarLayout>
+
+    <RelativeLayout
+        android:id="@+id/fragment"
+        android:layout_width="match_parent"
+        android:layout_height="match_parent"
+        app:layout_behavior="@string/appbar_scrolling_view_behavior"/>
+
+</androidx.coordinatorlayout.widget.CoordinatorLayout>

usbSerialExamples/src/main/res/layout/device_list_header.xml

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:background="?android:attr/listDivider"
+    android:orientation="vertical">
+
+    <TextView
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:layout_marginTop="12dp"
+        android:layout_marginBottom="12dp"
+        android:gravity="center"
+        android:text="@string/devices"
+        android:textAppearance="@style/TextAppearance.AppCompat.Medium" />
+</LinearLayout>

usbSerialExamples/src/main/res/layout/device_list_item.xml

@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:orientation="vertical">
+
+    <TextView
+        android:id="@+id/text1"
+        android:layout_marginTop="12dp"
+        android:layout_marginStart="12dp"
+        android:layout_marginEnd="12dp"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:textAppearance="@style/TextAppearance.AppCompat.Medium" />
+
+    <TextView
+        android:id="@+id/text2"
+        android:layout_marginStart="20dp"
+        android:layout_marginEnd="20dp"
+        android:layout_marginBottom="12dp"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:textAppearance="@style/TextAppearance.AppCompat.Small" />
+
+</LinearLayout>

usbSerialExamples/src/main/res/layout/fragment_terminal.xml

@@ -0,0 +1,128 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:orientation="vertical">
+
+    <LinearLayout
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:orientation="horizontal">
+
+        <ToggleButton
+            android:id="@+id/controlLineRts"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:minWidth="48sp"
+            android:textOff="RTS"
+            android:textOn="RTS" />
+
+        <ToggleButton
+            android:id="@+id/controlLineCts"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:minWidth="48sp"
+            android:clickable="false"
+            android:textColor="@android:color/secondary_text_dark"
+            android:textOff="CTS"
+            android:textOn="CTS" />
+
+        <View
+            android:layout_height="match_parent"
+            android:layout_width="6dp" />
+
+        <ToggleButton
+            android:id="@+id/controlLineDtr"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:minWidth="48sp"
+            android:textOff="DTR"
+            android:textOn="DTR" />
+
+        <ToggleButton
+            android:id="@+id/controlLineDsr"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:clickable="false"
+            android:minWidth="48sp"
+            android:textColor="@android:color/secondary_text_dark"
+            android:textOff="DSR"
+            android:textOn="DSR" />
+
+        <View
+            android:layout_height="match_parent"
+            android:layout_width="6dp" />
+
+        <ToggleButton
+            android:id="@+id/controlLineCd"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:clickable="false"
+            android:minWidth="48sp"
+            android:textColor="@android:color/secondary_text_dark"
+            android:textOff="CD"
+            android:textOn="CD" />
+
+        <ToggleButton
+            android:id="@+id/controlLineRi"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:minWidth="48sp"
+            android:clickable="false"
+            android:textColor="@android:color/secondary_text_dark"
+            android:textOff="RI"
+            android:textOn="RI" />
+
+    </LinearLayout>
+
+    <View
+        android:layout_width="match_parent"
+        android:background="?android:attr/listDivider"
+        android:layout_height="2dp" />
+
+    <TextView
+        android:id="@+id/receive_text"
+        android:layout_width="match_parent"
+        android:layout_height="0dp"
+        android:layout_weight="1"
+        android:freezesText="true"
+        android:gravity="bottom"
+        android:scrollbars="vertical"
+        android:textAppearance="@style/TextAppearance.AppCompat.Medium"
+        android:typeface="monospace" />
+
+    <Button
+        android:id="@+id/receive_btn"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:text="Read" />
+
+    <View
+        android:layout_width="match_parent"
+        android:background="?android:attr/listDivider"
+        android:layout_height="2dp" />
+
+    <LinearLayout
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:orientation="horizontal">
+
+        <EditText
+            android:id="@+id/send_text"
+            android:layout_width="0dp"
+            android:layout_height="match_parent"
+            android:layout_weight="1"
+            android:inputType="text|textNoSuggestions"
+            android:singleLine="true" />
+
+        <ImageButton
+            android:id="@+id/send_btn"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            app:srcCompat="@drawable/ic_send_white_24dp" />
+    </LinearLayout>
+
+</LinearLayout>
+

usbSerialExamples/src/main/res/menu/menu_devices.xml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="utf-8"?>
+<menu xmlns:android="http://schemas.android.com/apk/res/android">
+    <item
+        android:id="@+id/refresh"
+        android:title="Refresh devices" />
+    <item
+        android:id="@+id/baud_rate"
+        android:title="Baud rate" />
+    <item
+        android:id="@+id/read_mode"
+        android:title="Read mode" />
+</menu>

usbSerialExamples/src/main/res/menu/menu_terminal.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="utf-8"?>
+<menu xmlns:app="http://schemas.android.com/apk/res-auto"
+    xmlns:android="http://schemas.android.com/apk/res/android">
+    <item
+        android:id="@+id/clear"
+        android:icon="@drawable/ic_delete_white_24dp"
+        android:title="Clear"
+        app:showAsAction="always" />
+    <item
+        android:id="@+id/send_break"
+        android:title="Send BREAK"
+        app:showAsAction="never" />
+</menu>

usbSerialExamples/src/main/res/values/arrays.xml

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string-array name="baud_rates">
+        <item>2400</item>
+        <item>9600</item>
+        <item>19200</item>
+        <item>57600</item>
+        <item>115200</item>
+    </string-array>
+    <string-array name="read_modes">
+        <item>event: SerialInputOutputManager.onNewData()</item>
+        <item>direct: UsbSerialPort.read()</item>
+    </string-array>
+</resources>

usbSerialExamples/src/main/res/values/colors.xml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <color name="colorPrimary">#949C29</color>
+    <color name="colorPrimaryDark">#61671B</color>
+    <color name="colorAccent">#D8E33B</color>
+
+    <color name="colorRecieveText">#00FF00</color>
+    <color name="colorSendText">#82CAFF</color>
+    <color name="colorStatusText">#FFDB58</color>
+</resources>

usbSerialExamples/src/main/res/values/strings.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="app_title">USB Serial For Android Example</string>
+    <string name="app_name">USB Serial Example</string>
+    <string name="devices">USB Devices</string>
+</resources>

usbSerialExamples/src/main/res/values/styles.xml

@@ -0,0 +1,7 @@
+<resources>
+    <style name="AppTheme" parent="Theme.AppCompat.NoActionBar">
+        <item name="colorPrimary">@color/colorPrimary</item>
+        <item name="colorPrimaryDark">@color/colorPrimaryDark</item>
+        <item name="colorAccent">@color/colorAccent</item>
+    </style>
+</resources>

usbSerialExamples/src/main/res/xml/device_filter.xml

@@ -0,0 +1,38 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <!-- 0x0403 / 0x60??: FTDI -->
+    <usb-device vendor-id="1027" product-id="24577" /> <!-- 0x6001: FT232R -->
+    <usb-device vendor-id="1027" product-id="24592" /> <!-- 0x6010: FT2232H -->
+    <usb-device vendor-id="1027" product-id="24593" /> <!-- 0x6011: FT4232H -->
+    <usb-device vendor-id="1027" product-id="24596" /> <!-- 0x6014: FT232H -->
+    <usb-device vendor-id="1027" product-id="24597" /> <!-- 0x6015: FT230X, FT231X, FT234XD -->
+
+    <!-- 0x10C4 / 0xEA??: Silabs CP210x -->
+    <usb-device vendor-id="4292" product-id="60000" /> <!-- 0xea60: CP2102 and other CP210x single port devices -->
+    <usb-device vendor-id="4292" product-id="60016" /> <!-- 0xea70: CP2105 -->
+    <usb-device vendor-id="4292" product-id="60017" /> <!-- 0xea71: CP2108 -->
+
+    <!-- 0x067B / 0x23?3: Prolific PL2303x -->
+    <usb-device vendor-id="1659" product-id="8963" /> <!-- 0x2303: PL2303HX, HXD, TA, ... -->
+    <usb-device vendor-id="1659" product-id="9123" /> <!-- 0x23a3: PL2303GC -->
+    <usb-device vendor-id="1659" product-id="9139" /> <!-- 0x23b3: PL2303GB -->
+    <usb-device vendor-id="1659" product-id="9155" /> <!-- 0x23c3: PL2303GT -->
+    <usb-device vendor-id="1659" product-id="9171" /> <!-- 0x23d3: PL2303GL -->
+    <usb-device vendor-id="1659" product-id="9187" /> <!-- 0x23e3: PL2303GE -->
+    <usb-device vendor-id="1659" product-id="9203" /> <!-- 0x23f3: PL2303GS -->
+
+    <!-- 0x1a86 / 0x?523: Qinheng CH34x -->
+    <usb-device vendor-id="6790" product-id="21795" /> <!-- 0x5523: CH341A -->
+    <usb-device vendor-id="6790" product-id="29987" /> <!-- 0x7523: CH340 -->
+
+    <!-- CDC driver -->
+    <usb-device vendor-id="9025" />                   <!-- 0x2341 / ......: Arduino -->
+    <usb-device vendor-id="5824" product-id="1155" /> <!-- 0x16C0 / 0x0483: Teensyduino  -->
+    <usb-device vendor-id="1003" product-id="8260" /> <!-- 0x03EB / 0x2044: Atmel Lufa -->
+    <usb-device vendor-id="7855" product-id="4"    /> <!-- 0x1eaf / 0x0004: Leaflabs Maple -->
+    <usb-device vendor-id="3368" product-id="516"  /> <!-- 0x0d28 / 0x0204: ARM mbed -->
+    <usb-device vendor-id="1155" product-id="22336" /><!-- 0x0483 / 0x5740: ST CDC -->
+    <usb-device vendor-id="11914" product-id="5"   /> <!-- 0x2E8A / 0x0005: Raspberry Pi Pico Micropython -->
+    <usb-device vendor-id="11914" product-id="10"  /> <!-- 0x2E8A / 0x000A: Raspberry Pi Pico SDK -->
+    <usb-device vendor-id="6790" product-id="21972" /><!-- 0x1A86 / 0x55D4: Qinheng CH9102F -->
+</resources>

usbSerialForAndroid/build.gradle

@@ -0,0 +1,60 @@
+plugins {
+    id 'com.android.library'
+    id 'maven-publish'
+}
+
+android {
+    compileSdkVersion 35
+
+    defaultConfig {
+        minSdkVersion 17
+        targetSdkVersion 35
+        consumerProguardFiles 'proguard-rules.pro'
+        
+        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+        testInstrumentationRunnerArguments = [                    // Raspi   Windows   LinuxVM   ...
+                'rfc2217_server_host': '192.168.0.78',
+                'rfc2217_server_nonstandard_baudrates': 'true',   // true    false     false
+        ]
+    }
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_8
+        targetCompatibility JavaVersion.VERSION_1_8
+    }
+    namespace 'com.hoho.android.usbserial'
+    publishing {
+        // if coverage is enabled, change 'release' to 'anyDeviceRelease' or comment out publishing rule
+        singleVariant('release') {
+            withSourcesJar()
+        }
+    }
+}
+
+dependencies {
+    implementation "androidx.annotation:annotation:1.9.1"
+    testImplementation 'junit:junit:4.13.2'
+    testImplementation 'org.mockito:mockito-core:5.15.2'
+    androidTestImplementation 'androidx.appcompat:appcompat:1.6.1' // later versions have minsdk 21
+    androidTestImplementation 'androidx.test:core:1.5.0' // later versions have minsdk 19
+    androidTestImplementation 'androidx.test:runner:1.5.2' // later versions have minsdk 19
+    androidTestImplementation 'commons-net:commons-net:3.9.0' // later versions fail on old Android devices with missing java.time.Duration class
+    androidTestImplementation 'org.apache.commons:commons-lang3:3.14.0'
+}
+
+// gradle task: publishToMavenLocal
+project.afterEvaluate {
+    publishing {
+        publications {
+            release(MavenPublication) {
+                from components.release
+
+                // values used for local maven repo, jitpack uses github release:
+                groupId 'com.github.mik3y'
+                artifactId 'usb-serial-for-android'
+                version '3.8.0beta'
+            }
+        }
+    }
+}
+
+//apply from: 'coverage.gradle'

usbSerialForAndroid/coverage.gradle

@@ -0,0 +1,78 @@
+// see https://github.com/mik3y/usb-serial-for-android/wiki/Device-Tests-&-Coverage-Report for instructions
+apply plugin: 'jacoco'
+
+android {
+    flavorDimensions += 'device'
+    productFlavors {
+        anyDevice {
+            // Used as fallback in usbSerialExample/build.gradle -> missingDimensionStrategy, but not for coverage report
+            dimension 'device'
+        }
+        mcp2221 {
+            dimension 'device'
+            testInstrumentationRunnerArguments = ['test_device_driver': 'CdcAcm']
+        }
+        ch340 {
+            dimension 'device'
+            testInstrumentationRunnerArguments = ['test_device_driver': 'Ch34x']
+        }
+        cp2102 { // and cp2105 first port
+            dimension 'device'
+            testInstrumentationRunnerArguments = ['test_device_driver': 'Cp21xx', 'test_device_port': '0']
+        }
+        cp2105 { // second port
+            dimension 'device'
+            testInstrumentationRunnerArguments = ['test_device_driver': 'Cp21xx', 'test_device_port': '1']
+        }
+        ft232 { // and ft2232 first port
+            dimension 'device'
+            testInstrumentationRunnerArguments = ['test_device_driver': 'Ftdi', 'test_device_port': '0']
+        }
+        ft2232 { // second port
+            dimension 'device'
+            testInstrumentationRunnerArguments = ['test_device_driver': 'Ftdi', 'test_device_port': '1']
+        }
+        pl2303 {
+            dimension 'device'
+            testInstrumentationRunnerArguments = ['test_device_driver': 'Prolific']
+        }
+        pl2303t {
+            dimension 'device'
+            testInstrumentationRunnerArguments = ['test_device_driver': 'Prolific']
+        }
+        pl2303g {
+            dimension 'device'
+            testInstrumentationRunnerArguments = ['test_device_driver': 'Prolific']
+        }
+    }
+
+    buildTypes {
+        debug {
+            enableUnitTestCoverage true
+            enableAndroidTestCoverage true
+        }
+    }
+}
+
+// create report even if tests fail
+project.gradle.taskGraph.whenReady {
+    -> project.tasks.findAll { it.name =~ /connected.+AndroidTest/ }.each {
+        it.ignoreFailures = true
+    }
+}
+
+task jacocoTestReport(type: JacocoReport, dependsOn: ['compileAnyDeviceDebugSources'
+                                                  /*, 'testAnyDeviceDebugUnitTest' */
+                                                  /*, 'create<device>DebugCoverageReport' */]) {
+    def fileFilter = ['**/R.class', '**/R$*.class', '**/BuildConfig.*', '**/Manifest*.*', '**/*Test*.*', 'android/**/*.*']
+    def debugTree = fileTree(dir: "$project.buildDir/intermediates/javac/anyDeviceDebug", excludes: fileFilter)
+    def mainSrc = "$project.projectDir/src/main/java"
+
+    reports.xml.required = true
+    sourceDirectories.from files([mainSrc])
+    classDirectories.from files([debugTree])
+    executionData.from fileTree(dir: project.buildDir, includes: [
+            'outputs/unit_test_code_coverage/anyDeviceDebugUnitTest/testAnyDeviceDebugUnitTest.exec',
+            'outputs/code_coverage/*DebugAndroidTest/connected/*/coverage.ec'
+    ])
+}

usbSerialForAndroid/proguard-rules.pro

@@ -0,0 +1 @@
+-keep class com.hoho.android.usbserial.driver.* { *; }

usbSerialForAndroid/src/androidTest/AndroidManifest.xml

@@ -1,7 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
-      package="com.hoho.android.usbserial"
       android:versionCode="1"
       android:versionName="1.0">
-    <uses-sdk android:minSdkVersion="12" />
+    <uses-permission android:name="android.permission.INTERNET"/>
 </manifest>

usbSerialForAndroid/src/androidTest/java/com/hoho/android/usbserial/CrossoverTest.java

@@ -0,0 +1,216 @@
+/*
+ * test multiple devices or multiple ports on same device
+ *
+ * TxD and RxD have to be cross connected
+ */
+package com.hoho.android.usbserial;
+
+import android.content.Context;
+import android.hardware.usb.UsbManager;
+import androidx.test.core.app.ApplicationProvider;
+import androidx.test.platform.app.InstrumentationRegistry;
+import androidx.test.runner.AndroidJUnit4;
+import android.util.Log;
+
+import com.hoho.android.usbserial.driver.UsbSerialDriver;
+import com.hoho.android.usbserial.driver.UsbSerialPort;
+import com.hoho.android.usbserial.driver.UsbSerialProber;
+import com.hoho.android.usbserial.util.TestBuffer;
+import com.hoho.android.usbserial.util.UsbWrapper;
+
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TestRule;
+import org.junit.rules.TestWatcher;
+import org.junit.runner.Description;
+import org.junit.runner.RunWith;
+
+import java.io.IOException;
+import java.util.EnumSet;
+import java.util.List;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertThat;
+import static org.junit.Assert.fail;
+import static org.junit.Assume.assumeTrue;
+
+@RunWith(AndroidJUnit4.class)
+public class CrossoverTest {
+
+    private final static String  TAG = CrossoverTest.class.getSimpleName();
+
+    private Context context;
+    private UsbManager usbManager;
+    private UsbWrapper usb1, usb2;
+
+    @Rule
+    public TestRule watcher = new TestWatcher() {
+        protected void starting(Description description) {
+            Log.i(TAG, "===== starting test: " + description.getMethodName()+ " =====");
+        }
+    };
+
+    @Before
+    public void setUp() throws Exception {
+        assumeTrue("ignore test for device specific coverage report",
+                InstrumentationRegistry.getArguments().getString("test_device_driver") == null);
+
+        context = ApplicationProvider.getApplicationContext();
+        usbManager = (UsbManager) context.getSystemService(Context.USB_SERVICE);
+        List<UsbSerialDriver> availableDrivers = UsbSerialProber.getDefaultProber().findAllDrivers(usbManager);
+        assertNotEquals("no USB device found", 0, availableDrivers.size());
+        if (availableDrivers.size() == 0) {
+            fail("no USB device found");
+        } else if (availableDrivers.size() == 1) {
+            assertEquals("expected device with 2 ports.", 2, availableDrivers.get(0).getPorts().size());
+            usb1 = new UsbWrapper(context, availableDrivers.get(0), 0);
+            usb2 = new UsbWrapper(context, availableDrivers.get(0), 1);
+        } else {
+            assertEquals("expected 2 devices with 1 port.", 1, availableDrivers.get(0).getPorts().size());
+            assertEquals("expected 2 devices with 1 port.", 1, availableDrivers.get(1).getPorts().size());
+            usb1 = new UsbWrapper(context, availableDrivers.get(0), 0);
+            usb2 = new UsbWrapper(context, availableDrivers.get(1), 0);
+        }
+        usb1.setUp();
+        usb2.setUp();
+    }
+
+    @Test
+    public void reopen() throws Exception {
+        byte[] buf;
+
+        usb1.open(EnumSet.of(UsbWrapper.OpenCloseFlags.NO_IOMANAGER_THREAD));
+        usb2.open(EnumSet.of(UsbWrapper.OpenCloseFlags.NO_IOMANAGER_THREAD));
+        usb1.setParameters(19200, 8, 1, UsbSerialPort.PARITY_NONE);
+        usb2.setParameters(19200, 8, 1, UsbSerialPort.PARITY_NONE);
+
+        usb1.write("x".getBytes());
+        buf = usb2.read(1);
+        assertThat(buf, equalTo("x".getBytes()));
+
+        usb2.write("y".getBytes());
+        buf = usb1.read(1);
+        assertThat(buf, equalTo("y".getBytes()));
+
+        usb2.close(); // does not affect usb1 with individual UsbDeviceConnection on same device
+
+        usb2.open(EnumSet.of(UsbWrapper.OpenCloseFlags.NO_IOMANAGER_THREAD));
+        usb2.setParameters(19200, 8, 1, UsbSerialPort.PARITY_NONE);
+
+        usb1.write("x".getBytes());
+        buf = usb2.read(1);
+        assertThat(buf, equalTo("x".getBytes()));
+
+        usb2.write("y".getBytes());
+        buf = usb1.read(1);
+        assertThat(buf, equalTo("y".getBytes()));
+
+        usb1.close();
+        usb2.close();
+    }
+
+    @Test
+    public void ioManager() throws Exception {
+        byte[] buf;
+
+        // each SerialInputOutputManager thread runs in it's own SingleThreadExecutor
+        usb1.open();
+        usb2.open();
+        usb1.setParameters(19200, 8, 1, UsbSerialPort.PARITY_NONE);
+        usb2.setParameters(19200, 8, 1, UsbSerialPort.PARITY_NONE);
+
+        usb1.write("x".getBytes());
+        buf = usb2.read(1);
+        assertThat(buf, equalTo("x".getBytes()));
+
+        usb2.write("y".getBytes());
+        buf = usb1.read(1);
+        assertThat(buf, equalTo("y".getBytes()));
+
+        usb1.close();
+        usb2.close();
+    }
+
+    @Test
+    public void baudRate() throws Exception {
+        byte[] buf;
+
+        usb1.open(EnumSet.of(UsbWrapper.OpenCloseFlags.NO_IOMANAGER_THREAD));
+        usb2.open(EnumSet.of(UsbWrapper.OpenCloseFlags.NO_IOMANAGER_THREAD));
+        usb1.setParameters(19200, 8, 1, UsbSerialPort.PARITY_NONE);
+        usb2.setParameters(9600, 8, 1, UsbSerialPort.PARITY_NONE);
+
+        // a - start bit (0)
+        // o - stop bit  (1)
+        // 0/1 - data bit
+
+        // out 19k2: a00011001o
+        // in 9k6:   a 0 1 0 1 1 1 1 1 o
+        usb1.write(new byte[]{(byte)0x98});
+        buf = usb2.read(1);
+        assertThat(buf, equalTo(new byte[]{(byte)0xfa}));
+
+        // out 9k6: a 1 0 1 1 1 1 1 1 o
+        // in 19k2: a01100111o
+        usb2.write(new byte[]{(byte)0xfd});
+        buf = usb1.read(1);
+        assertThat(buf, equalTo(new byte[]{(byte)0xe6}));
+
+        usb1.close();
+        usb2.close();
+    }
+
+    @Test
+    public void concurrent() throws Exception {
+        // 115200 baud ~= 11kB/sec => ~1.5 second test duration with 16kB tbuf
+        // concurrent (+ blocking) write calls as tbuf larger than any buffer size returned by UsbWrapper.getWriteSizes()
+        // concurrent read calls in IoManager threads
+        TestBuffer tbuf1 = new TestBuffer(16*1024);
+        TestBuffer tbuf2 = new TestBuffer(16*1024);
+
+        class WriteRunnable implements Runnable {
+            public WriteRunnable(int port) { this.port = port; }
+            private final int port;
+            Exception exc;
+            @Override
+            public void run() {
+                byte[] buf = new byte[1024];
+                try {
+                    for(int i=0; i<tbuf1.buf.length / 1024; i++) {
+                        System.arraycopy(tbuf1.buf, i*1024, buf, 0, 1024);
+                        if (port == 1)
+                            usb1.write(buf);
+                        else
+                            usb2.write(buf);
+                    }
+                } catch (IOException exc) {
+                    this.exc = exc;
+                }
+            }
+        }
+
+        usb1.open();
+        usb2.open();
+        usb1.setParameters(115200, 8, 1, UsbSerialPort.PARITY_NONE);
+        usb2.setParameters(115200, 8, 1, UsbSerialPort.PARITY_NONE);
+        WriteRunnable wr1 = new WriteRunnable(1), wr2 = new WriteRunnable(2);
+        Thread wt1 = new Thread(wr1), wt2 = new Thread(wr2);
+        boolean done1 = false, done2 = false;
+        wt1.start();
+        Thread.sleep(50);
+        wt2.start();
+        while(!done1 && !done2) {
+            if(!done1)
+                done1 = tbuf1.testRead(usb1.read(-1));
+            if(!done2)
+                done2 = tbuf2.testRead(usb2.read(-1));
+        }
+        wt1.join(); wt2.join();
+        assertNull(wr1.exc);
+        assertNull(wr2.exc);
+    }
+}

usbSerialForAndroid/src/androidTest/java/com/hoho/android/usbserial/driver/CommonUsbSerialPortWrapper.java

@@ -0,0 +1,8 @@
+package com.hoho.android.usbserial.driver;
+
+public class CommonUsbSerialPortWrapper {
+    public static byte[] getWriteBuffer(UsbSerialPort serialPort) {
+        CommonUsbSerialPort commonSerialPort = (CommonUsbSerialPort) serialPort;
+        return commonSerialPort.mWriteBuffer;
+    }
+}

usbSerialForAndroid/src/androidTest/java/com/hoho/android/usbserial/driver/ProlificSerialPortWrapper.java

@@ -0,0 +1,13 @@
+package com.hoho.android.usbserial.driver;
+
+public class ProlificSerialPortWrapper {
+    public static boolean isDeviceTypeT(UsbSerialPort serialPort) {
+        ProlificSerialDriver.ProlificSerialPort prolificSerialPort = (ProlificSerialDriver.ProlificSerialPort) serialPort;
+        return prolificSerialPort.mDeviceType == ProlificSerialDriver.DeviceType.DEVICE_TYPE_T;
+    }
+
+    public static boolean isDeviceTypeHxn(UsbSerialPort serialPort) {
+        ProlificSerialDriver.ProlificSerialPort prolificSerialPort = (ProlificSerialDriver.ProlificSerialPort) serialPort;
+        return prolificSerialPort.mDeviceType == ProlificSerialDriver.DeviceType.DEVICE_TYPE_HXN;
+    }
+}

usbSerialForAndroid/src/androidTest/java/com/hoho/android/usbserial/util/TelnetWrapper.java

@@ -0,0 +1,152 @@
+package com.hoho.android.usbserial.util;
+
+import com.hoho.android.usbserial.driver.UsbSerialPort;
+
+import org.apache.commons.net.telnet.InvalidTelnetOptionException;
+import org.apache.commons.net.telnet.TelnetClient;
+import org.apache.commons.net.telnet.TelnetCommand;
+import org.apache.commons.net.telnet.TelnetOptionHandler;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+
+import static org.junit.Assert.assertEquals;
+
+public class TelnetWrapper {
+    private final static String  TAG = TelnetWrapper.class.getSimpleName();
+
+    private final static int     TELNET_READ_WAIT = 500;
+    private final static int     TELNET_COMMAND_WAIT = 2000;
+
+    private final static byte    RFC2217_COM_PORT_OPTION = 0x2c;
+    private final static byte    RFC2217_SET_BAUDRATE = 1;
+    private final static byte    RFC2217_SET_DATASIZE = 2;
+    private final static byte    RFC2217_SET_PARITY   = 3;
+    private final static byte    RFC2217_SET_STOPSIZE = 4;
+    private final static byte    RFC2217_PURGE_DATA = 12;
+
+    private final String host;
+    private final int port;
+
+    private TelnetClient telnetClient;
+    private InputStream readStream;
+    private OutputStream writeStream;
+    private ArrayList<int[]> commandResponse = new ArrayList<>();
+    public int writeDelay = 0;
+
+    public TelnetWrapper(String host, int port) {
+        this.host = host;
+        this.port = port;
+        telnetClient = null;
+    }
+
+    private void setUpFixtureInt() throws Exception {
+        if(telnetClient != null)
+            return;
+        telnetClient = new TelnetClient();
+        telnetClient.addOptionHandler(new TelnetOptionHandler(RFC2217_COM_PORT_OPTION, false, false, false, false) {
+            @Override
+            public int[] answerSubnegotiation(int[] suboptionData, int suboptionLength) {
+                int[] data = new int[suboptionLength];
+                System.arraycopy(suboptionData, 0, data, 0, suboptionLength);
+                commandResponse.add(data);
+                return super.answerSubnegotiation(suboptionData, suboptionLength);
+            }
+        });
+
+        telnetClient.setConnectTimeout(2000);
+        telnetClient.connect(host, port);
+        telnetClient.setTcpNoDelay(true);
+        writeStream = telnetClient.getOutputStream();
+        readStream = telnetClient.getInputStream();
+    }
+
+    private int[] doCommand(String name, byte[] command) throws IOException, InterruptedException {
+        commandResponse.clear();
+        telnetClient.sendCommand((byte) TelnetCommand.SB);
+        writeStream.write(command);
+        telnetClient.sendCommand((byte)TelnetCommand.SE);
+
+        for(int i=0; i<TELNET_COMMAND_WAIT; i++) {
+            if(commandResponse.size() > 0) break;
+            Thread.sleep(1);
+        }
+        assertEquals("RFC2217 " + name+ " w/o response.", 1, commandResponse.size());
+        //Log.d(TAG, name + " -> " + Arrays.toString(commandResponse.get(0)));
+        return commandResponse.get(0);
+    }
+
+    public void setUp() throws Exception {
+        setUpFixtureInt();
+        telnetClient.sendAYT(1000); // not correctly handled by rfc2217_server.py, but WARNING output "ignoring Telnet command: '\xf6'" is a nice separator between tests
+        doCommand("purge-data", new byte[] {RFC2217_COM_PORT_OPTION, RFC2217_PURGE_DATA, 3});
+        writeDelay = 0;
+    }
+
+    public void tearDown() {
+        try {
+            read(0);
+        } catch (Exception ignored) {
+        }
+    }
+
+    public void tearDownFixture() throws Exception {
+        try {
+            telnetClient.disconnect();
+        } catch (Exception ignored) {}
+        readStream = null;
+        writeStream = null;
+        telnetClient = null;
+    }
+
+    // wait full time
+    public byte[] read() throws Exception {
+        return read(-1, -1);
+    }
+    public byte[] read(int expectedLength) throws Exception {
+        return read(expectedLength, -1);
+    }
+    public byte[] read(int expectedLength, int readWait) throws Exception {
+        if(readWait == -1)
+            readWait = TELNET_READ_WAIT;
+        long end = System.currentTimeMillis() + readWait;
+        ByteBuffer buf = ByteBuffer.allocate(65536);
+        while(System.currentTimeMillis() < end) {
+            if(readStream.available() > 0) {
+                buf.put((byte) readStream.read());
+            } else {
+                if (expectedLength >= 0 && buf.position() >= expectedLength)
+                    break;
+                Thread.sleep(1);
+            }
+        }
+        byte[] data = new byte[buf.position()];
+        buf.flip();
+        buf.get(data);
+        return data;
+    }
+
+    public void write(byte[] data) throws Exception{
+        if(writeDelay != 0) {
+            for(byte b : data) {
+                writeStream.write(b);
+                writeStream.flush();
+                Thread.sleep(writeDelay);
+            }
+        } else {
+            writeStream.write(data);
+            writeStream.flush();
+        }
+    }
+
+    public void setParameters(int baudRate, int dataBits, int stopBits, @UsbSerialPort.Parity int parity) throws IOException, InterruptedException, InvalidTelnetOptionException {
+        doCommand("set-baudrate", new byte[] {RFC2217_COM_PORT_OPTION, RFC2217_SET_BAUDRATE, (byte)(baudRate>>24), (byte)(baudRate>>16), (byte)(baudRate>>8), (byte)baudRate});
+        doCommand("set-datasize", new byte[] {RFC2217_COM_PORT_OPTION, RFC2217_SET_DATASIZE, (byte)dataBits});
+        doCommand("set-stopsize", new byte[] {RFC2217_COM_PORT_OPTION, RFC2217_SET_STOPSIZE, (byte)stopBits});
+        doCommand("set-parity", new byte[] {RFC2217_COM_PORT_OPTION, RFC2217_SET_PARITY, (byte)(parity+1)});
+    }
+
+}

usbSerialForAndroid/src/androidTest/java/com/hoho/android/usbserial/util/TestBuffer.java

@@ -0,0 +1,32 @@
+package com.hoho.android.usbserial.util;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.assertTrue;
+
+public class TestBuffer {
+    public final byte[] buf;
+    public int len;
+
+    public TestBuffer(int length) {
+        len = 0;
+        buf = new byte[length];
+        int i = 0;
+        int j = 0;
+        for (j = 0; j < length / 16; j++)
+            for (int k = 0; k < 16; k++)
+                buf[i++] = (byte) j;
+        while (i < length)
+            buf[i++] = (byte) j;
+    }
+
+    public boolean testRead(byte[] data) {
+        assertNotEquals(0, data.length);
+        assertTrue("got " + (len + data.length) + " bytes", (len + data.length) <= buf.length);
+        for (int j = 0; j < data.length; j++)
+            assertEquals("at pos " + (len + j), (byte) ((len + j) / 16), data[j]);
+        len += data.length;
+        //Log.d(TAG, "read " + len);
+        return len == buf.length;
+    }
+}

usbSerialForAndroid/src/androidTest/java/com/hoho/android/usbserial/util/UsbWrapper.java

@@ -0,0 +1,390 @@
+package com.hoho.android.usbserial.util;
+
+import android.app.PendingIntent;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.hardware.usb.UsbDeviceConnection;
+import android.hardware.usb.UsbManager;
+import android.media.RingtoneManager;
+import android.net.Uri;
+import android.os.Build;
+import android.util.Log;
+
+import com.hoho.android.usbserial.driver.CdcAcmSerialDriver;
+import com.hoho.android.usbserial.driver.Ch34xSerialDriver;
+import com.hoho.android.usbserial.driver.CommonUsbSerialPort;
+import com.hoho.android.usbserial.driver.Cp21xxSerialDriver;
+import com.hoho.android.usbserial.driver.FtdiSerialDriver;
+import com.hoho.android.usbserial.driver.ProlificSerialDriver;
+import com.hoho.android.usbserial.driver.ProlificSerialPortWrapper;
+import com.hoho.android.usbserial.driver.UsbId;
+import com.hoho.android.usbserial.driver.UsbSerialDriver;
+import com.hoho.android.usbserial.driver.UsbSerialPort;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.util.Deque;
+import java.util.EnumSet;
+import java.util.LinkedList;
+import java.util.concurrent.Callable;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import androidx.core.content.ContextCompat;
+
+public class UsbWrapper implements SerialInputOutputManager.Listener {
+
+    public final static int     USB_READ_WAIT = 500;
+    public final static int     USB_WRITE_WAIT = 500;
+    private static final String TAG = UsbWrapper.class.getSimpleName();
+
+    public enum OpenCloseFlags { NO_IOMANAGER_THREAD, NO_IOMANAGER_START, NO_CONTROL_LINE_INIT, NO_DEVICE_CONNECTION };
+
+    // constructor
+    final Context context;
+    public final UsbSerialDriver serialDriver;
+    public final int devicePort;
+    public final UsbSerialPort serialPort;
+    // open
+    public UsbDeviceConnection deviceConnection;
+    public SerialInputOutputManager ioManager;
+    // read
+    final Deque<byte[]> readBuffer = new LinkedList<>();
+    Exception readError;
+    public boolean readBlock = false;
+    long readTime = 0;
+
+    // device properties
+    public boolean isCp21xxRestrictedPort; // second port of Cp2105 has limited dataBits, stopBits, parity
+    public boolean outputLinesSupported;
+    public boolean inputLinesSupported;
+    public boolean inputLinesConnected;
+    public boolean inputLinesOnlyRtsCts;
+    public int writePacketSize = -1;
+    public int writeBufferSize = -1;
+    public int readBufferSize = -1;
+
+    public UsbWrapper(Context context, UsbSerialDriver serialDriver, int devicePort) {
+        this.context = context;
+        this.serialDriver = serialDriver;
+        this.devicePort = devicePort;
+        serialPort = serialDriver.getPorts().get(devicePort);
+        CommonUsbSerialPort.DEBUG = true;
+    }
+
+    public void setUp() throws Exception {
+        UsbManager usbManager = (UsbManager) context.getSystemService(Context.USB_SERVICE);
+        if (!usbManager.hasPermission(serialDriver.getDevice())) {
+            Uri notification = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION);
+            RingtoneManager.getRingtone(context, notification).play();
+
+            Log.d(TAG,"USB permission ...");
+            final Boolean[] granted = {null};
+            BroadcastReceiver usbReceiver = new BroadcastReceiver() {
+                @Override
+                public void onReceive(Context context, Intent intent) {
+                    granted[0] = intent.getBooleanExtra(UsbManager.EXTRA_PERMISSION_GRANTED, false);
+                }
+            };
+            int flags = Build.VERSION.SDK_INT >= Build.VERSION_CODES.M ? PendingIntent.FLAG_MUTABLE : 0;
+            Intent intent = new Intent("com.android.example.USB_PERMISSION");
+            intent.setPackage(context.getPackageName());
+            PendingIntent permissionIntent = PendingIntent.getBroadcast(context, 0, intent, flags);
+            IntentFilter filter = new IntentFilter("com.android.example.USB_PERMISSION");
+            ContextCompat.registerReceiver(context, usbReceiver, filter, Context.RECEIVER_NOT_EXPORTED);
+            usbManager.requestPermission(serialDriver.getDevice(), permissionIntent);
+            for(int i=0; i<5000; i++) {
+                if(granted[0] != null) break;
+                Thread.sleep(1);
+            }
+            Log.d(TAG,"USB permission "+granted[0]);
+            assertTrue("USB permission dialog not confirmed", granted[0] != null && granted[0]);
+        }
+
+        // extract some device properties:
+        isCp21xxRestrictedPort = serialDriver instanceof Cp21xxSerialDriver && serialDriver.getPorts().size()==2 && serialPort.getPortNumber() == 1;
+        // output lines are supported by all common drivers
+        // input lines are supported by all common drivers except CDC
+        if (serialDriver instanceof FtdiSerialDriver) {
+            outputLinesSupported = true;
+            inputLinesSupported = true;
+            if(serialDriver.getDevice().getProductId() == UsbId.FTDI_FT2232H)
+                inputLinesConnected = true; // I only have 74LS138 connected at FT2232, not at FT232
+            if(serialDriver.getDevice().getProductId() == UsbId.FTDI_FT231X) {
+                inputLinesConnected = true;
+                inputLinesOnlyRtsCts = true; // I only test with FT230X that has only these 2 control lines. DTR is silently ignored
+            }
+        } else if (serialDriver instanceof Cp21xxSerialDriver) {
+            outputLinesSupported = true;
+            inputLinesSupported = true;
+            if(serialDriver.getPorts().size() == 1)
+                inputLinesConnected = true; // I only have 74LS138 connected at CP2102, not at CP2105
+        } else if (serialDriver instanceof ProlificSerialDriver) {
+            outputLinesSupported = true;
+            inputLinesSupported = true;
+            inputLinesConnected = true;
+        } else if (serialDriver instanceof Ch34xSerialDriver) {
+            outputLinesSupported = true;
+            inputLinesSupported = true;
+            if(serialDriver.getDevice().getProductId() == UsbId.QINHENG_CH340)
+                inputLinesConnected = true;  // I only have 74LS138 connected at CH340, not connected at CH341A
+        } else if (serialDriver instanceof CdcAcmSerialDriver) {
+            outputLinesSupported = true;
+        }
+
+        if (serialDriver instanceof Cp21xxSerialDriver) {
+            if (serialDriver.getPorts().size() == 1) { writePacketSize = 64; writeBufferSize = 576; }
+            else if (serialPort.getPortNumber() == 0) { writePacketSize = 64; writeBufferSize = 320; }
+            else { writePacketSize = 32; writeBufferSize = 128; }; //, 160}; // write buffer size detection is unreliable
+        } else if (serialDriver instanceof Ch34xSerialDriver) {
+            writePacketSize = 32; writeBufferSize = 64;
+        } else if (serialDriver instanceof ProlificSerialDriver) {
+            writePacketSize = 64; writeBufferSize = 256;
+        } else if (serialDriver instanceof FtdiSerialDriver) {
+            switch (serialDriver.getPorts().size()) {
+                case 1: writePacketSize = 64; writeBufferSize = 128; break;
+                case 2: writePacketSize = 512; writeBufferSize = 4096; break;
+                case 4: writePacketSize = 512; writeBufferSize = 2048; break;
+            }
+            if(serialDriver.getDevice().getProductId() == UsbId.FTDI_FT231X)
+                writeBufferSize = 512;
+        } else if (serialDriver instanceof CdcAcmSerialDriver) {
+            writePacketSize = 16; writeBufferSize = 32; // MCP2221 values, other devices might be different
+        }
+
+        readBufferSize = writeBufferSize;
+        if (serialDriver instanceof Cp21xxSerialDriver && serialDriver.getPorts().size() == 2) {
+            readBufferSize = 256;
+        } else if (serialDriver instanceof FtdiSerialDriver && serialDriver.getPorts().size() == 1 && serialDriver.getDevice().getProductId() != UsbId.FTDI_FT231X) {
+            readBufferSize = 256;
+        } // PL2303 HXN checked in open()
+    }
+
+    public void tearDown() {
+        try {
+            if (ioManager != null)
+                read(0);
+            else
+                serialPort.purgeHwBuffers(true, true);
+        } catch (Exception ignored) {
+        }
+        close();
+        //usb.serialDriver = null;
+    }
+
+    public void close() {
+        close(EnumSet.noneOf(OpenCloseFlags.class));
+    }
+
+    public void close(EnumSet<OpenCloseFlags> flags) {
+        if (ioManager != null) {
+            ioManager.setListener(null);
+            ioManager.stop();
+        }
+        if (serialPort != null) {
+            try {
+                if(!flags.contains(OpenCloseFlags.NO_CONTROL_LINE_INIT)) {
+                    serialPort.setDTR(false);
+                    serialPort.setRTS(false);
+                    if (serialPort.getFlowControl() != UsbSerialPort.FlowControl.NONE)
+                        serialPort.setFlowControl(UsbSerialPort.FlowControl.NONE);
+                }
+            } catch (Exception ignored) {
+            }
+            try {
+                serialPort.close();
+            } catch (Exception ignored) {
+            }
+            //usbSerialPort = null;
+        }
+        if(!flags.contains(OpenCloseFlags.NO_DEVICE_CONNECTION)) {
+            deviceConnection = null; // closed in usbSerialPort.close()
+        }
+        if(ioManager != null) {
+            for (int i = 0; i < 2000; i++) {
+                if (SerialInputOutputManager.State.STOPPED == ioManager.getState()) break;
+                try {
+                    Thread.sleep(1);
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+            }
+            assertEquals(SerialInputOutputManager.State.STOPPED, ioManager.getState());
+            ioManager = null;
+        }
+    }
+
+    public void open() throws Exception {
+        open(EnumSet.noneOf(OpenCloseFlags.class));
+    }
+
+    public void open(EnumSet<OpenCloseFlags> flags) throws Exception {
+        if(!flags.contains(OpenCloseFlags.NO_DEVICE_CONNECTION)) {
+            UsbManager usbManager = (UsbManager) context.getSystemService(Context.USB_SERVICE);
+            deviceConnection = usbManager.openDevice(serialDriver.getDevice());
+        }
+        serialPort.open(deviceConnection);
+        if(!flags.contains(OpenCloseFlags.NO_CONTROL_LINE_INIT)) {
+            serialPort.setDTR(true);
+            serialPort.setRTS(true);
+        }
+        if(!flags.contains(OpenCloseFlags.NO_IOMANAGER_THREAD)) {
+            ioManager = new SerialInputOutputManager(serialPort, this);
+            if(!flags.contains(OpenCloseFlags.NO_IOMANAGER_START))
+                ioManager.start();
+        }
+        synchronized (readBuffer) {
+            readBuffer.clear();
+        }
+        readError = null;
+
+        if (serialDriver instanceof ProlificSerialDriver && ProlificSerialPortWrapper.isDeviceTypeHxn(serialPort)) {
+            readBufferSize = 768;
+        }
+    }
+
+    public void waitForIoManagerStarted() throws IOException {
+        for (int i = 0; i < 100; i++) {
+            if (SerialInputOutputManager.State.STOPPED != ioManager.getState()) return;
+            try {
+                Thread.sleep(1);
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+        }
+        throw new IOException("IoManager not started");
+    }
+
+    public boolean hasIoManagerThreads() {
+        int c = 0;
+        for (Thread thread : Thread.getAllStackTraces().keySet()) {
+            if (thread.getName().equals(SerialInputOutputManager.class.getSimpleName() + "_read"))
+                c += 1;
+            if (thread.getName().equals(SerialInputOutputManager.class.getSimpleName() + "_write"))
+                c += 1;
+        }
+        return c == 2;
+    }
+
+    // wait full time
+    public byte[] read() throws Exception {
+        return read(-1, -1, -1);
+    }
+    public byte[] read(int expectedLength) throws Exception {
+        return read(expectedLength, -1, -1);
+    }
+    public byte[] read(int expectedLength, int readBufferSize) throws Exception {
+        return read(expectedLength, readBufferSize, -1);
+    }
+    public byte[] read(int expectedLength, int readBufferSize, int readWait) throws Exception {
+        if(readWait == -1)
+            readWait = USB_READ_WAIT;
+        long end = System.currentTimeMillis() + readWait;
+        ByteBuffer buf = ByteBuffer.allocate(16*1024);
+        if(ioManager != null) {
+            while (System.currentTimeMillis() < end) {
+                if(readError != null)
+                    throw new IOException(readError);
+                synchronized (readBuffer) {
+                    while(readBuffer.peek() != null)
+                        buf.put(readBuffer.remove());
+                }
+                if (expectedLength >= 0 && buf.position() >= expectedLength)
+                    break;
+                Thread.sleep(1);
+            }
+
+        } else {
+            byte[] b1 = new byte[readBufferSize > 0 ? readBufferSize : 256];
+            while (System.currentTimeMillis() < end) {
+                int len = serialPort.read(b1, USB_READ_WAIT);
+                if (len > 0)
+                    buf.put(b1, 0, len);
+                if (expectedLength >= 0 && buf.position() >= expectedLength)
+                    break;
+            }
+        }
+        byte[] data = new byte[buf.position()];
+        buf.flip();
+        buf.get(data);
+        return data;
+    }
+
+    public void write(byte[] data) throws IOException {
+        serialPort.write(data, USB_WRITE_WAIT);
+    }
+
+    public void setParameters(int baudRate, int dataBits, int stopBits, @UsbSerialPort.Parity int parity) throws IOException, InterruptedException {
+        serialPort.setParameters(baudRate, dataBits, stopBits, parity);
+        if(serialDriver instanceof CdcAcmSerialDriver)
+            Thread.sleep(10); // arduino_leonardeo_bridge.ini needs some time
+        else
+            Thread.sleep(1);
+    }
+
+    /* return TRUE/FALSE/null instead of true/false/<throw UnsupportedOperationException> */
+    public Boolean getControlLine(Callable<?> callable) throws Exception {
+        try {
+            return (Boolean)callable.call();
+        } catch (UnsupportedOperationException t) {
+            return null;
+        }
+    }
+
+    // return [write packet size, write buffer size(s)]
+    public int[] getWriteSizes() {
+        if (serialDriver instanceof Cp21xxSerialDriver) {
+            if (serialDriver.getPorts().size() == 1) return new int[]{64, 576};
+            else if (serialPort.getPortNumber() == 0) return new int[]{64, 320};
+            else return new int[]{32, 128, 160}; // write buffer size detection is unreliable
+        } else if (serialDriver instanceof Ch34xSerialDriver) {
+            return new int[]{32, 64};
+        } else if (serialDriver instanceof ProlificSerialDriver) {
+            return new int[]{64, 256};
+        } else if (serialDriver instanceof FtdiSerialDriver) {
+            switch (serialDriver.getPorts().size()) {
+                case 1: return new int[]{64, 128};
+                case 2: return new int[]{512, 4096};
+                case 4: return new int[]{512, 2048};
+                default: return null;
+            }
+        } else if (serialDriver instanceof CdcAcmSerialDriver) {
+            return new int[]{64, 128};
+        } else {
+            return null;
+        }
+    }
+
+
+    @Override
+    public void onNewData(byte[] data) {
+        long now = System.currentTimeMillis();
+        if(readTime == 0)
+            readTime = now;
+        if(data.length > 64) {
+            Log.d(TAG, "usb " + devicePort + " read: time+=" + String.format("%-3d",now- readTime) + " len=" + String.format("%-4d",data.length) + " data=" + new String(data, 0, 32) + "..." + new String(data, data.length-32, 32));
+        } else {
+            Log.d(TAG, "usb " + devicePort + " read: time+=" + String.format("%-3d",now- readTime) + " len=" + String.format("%-4d",data.length) + " data=" + new String(data));
+        }
+        readTime = now;
+
+        while(readBlock)
+            try {
+                Thread.sleep(1);
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+        synchronized (readBuffer) {
+            readBuffer.add(data);
+        }
+    }
+
+    @Override
+    public void onRunError(Exception e) {
+        readError = e;
+    }
+
+}

usbSerialForAndroid/src/main/AndroidManifest.xml

@@ -0,0 +1,3 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

usbSerialForAndroid/src/main/java/com/hoho/android/usbserial/driver/CdcAcmSerialDriver.java

@@ -0,0 +1,359 @@
+/* Copyright 2011-2013 Google Inc.
+ * Copyright 2013 mike wakerly <opensource@hoho.com>
+ *
+ * Project home page: https://github.com/mik3y/usb-serial-for-android
+ */
+
+package com.hoho.android.usbserial.driver;
+
+import android.hardware.usb.UsbConstants;
+import android.hardware.usb.UsbDevice;
+import android.hardware.usb.UsbEndpoint;
+import android.hardware.usb.UsbInterface;
+import android.util.Log;
+
+import com.hoho.android.usbserial.util.HexDump;
+import com.hoho.android.usbserial.util.UsbUtils;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.EnumSet;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * USB CDC/ACM serial driver implementation.
+ *
+ * @author mike wakerly (opensource@hoho.com)
+ * @see <a
+ *      href="http://www.usb.org/developers/devclass_docs/usbcdc11.pdf">Universal
+ *      Serial Bus Class Definitions for Communication Devices, v1.1</a>
+ */
+public class CdcAcmSerialDriver implements UsbSerialDriver {
+
+    public static final int USB_SUBCLASS_ACM = 2;
+
+    private final String TAG = CdcAcmSerialDriver.class.getSimpleName();
+
+    private final UsbDevice mDevice;
+    private final List<UsbSerialPort> mPorts;
+
+    public CdcAcmSerialDriver(UsbDevice device) {
+        mDevice = device;
+        mPorts = new ArrayList<>();
+        int ports = countPorts(device);
+        for (int port = 0; port < ports; port++) {
+            mPorts.add(new CdcAcmSerialPort(mDevice, port));
+        }
+        if (mPorts.size() == 0) {
+            mPorts.add(new CdcAcmSerialPort(mDevice, -1));
+        }
+    }
+
+    @SuppressWarnings({"unused"})
+    public static boolean probe(UsbDevice device) {
+        return countPorts(device) > 0;
+    }
+
+    private static int countPorts(UsbDevice device) {
+        int controlInterfaceCount = 0;
+        int dataInterfaceCount = 0;
+        for (int i = 0; i < device.getInterfaceCount(); i++) {
+            if (device.getInterface(i).getInterfaceClass() == UsbConstants.USB_CLASS_COMM &&
+                    device.getInterface(i).getInterfaceSubclass() == USB_SUBCLASS_ACM)
+                controlInterfaceCount++;
+            if (device.getInterface(i).getInterfaceClass() == UsbConstants.USB_CLASS_CDC_DATA)
+                dataInterfaceCount++;
+        }
+        return Math.min(controlInterfaceCount, dataInterfaceCount);
+    }
+
+    @Override
+    public UsbDevice getDevice() {
+        return mDevice;
+    }
+
+    @Override
+    public List<UsbSerialPort> getPorts() {
+        return mPorts;
+    }
+
+    public class CdcAcmSerialPort extends CommonUsbSerialPort {
+
+        private UsbInterface mControlInterface;
+        private UsbInterface mDataInterface;
+
+        private UsbEndpoint mControlEndpoint;
+
+        private int mControlIndex;
+
+        private boolean mRts = false;
+        private boolean mDtr = false;
+
+        private static final int USB_RECIP_INTERFACE = 0x01;
+        private static final int USB_RT_ACM = UsbConstants.USB_TYPE_CLASS | USB_RECIP_INTERFACE;
+
+        private static final int SET_LINE_CODING = 0x20;  // USB CDC 1.1 section 6.2
+        private static final int GET_LINE_CODING = 0x21;
+        private static final int SET_CONTROL_LINE_STATE = 0x22;
+        private static final int SEND_BREAK = 0x23;
+
+        public CdcAcmSerialPort(UsbDevice device, int portNumber) {
+            super(device, portNumber);
+        }
+
+        @Override
+        public UsbSerialDriver getDriver() {
+            return CdcAcmSerialDriver.this;
+        }
+
+        @Override
+        protected void openInt() throws IOException {
+            Log.d(TAG, "interfaces:");
+            for (int i = 0; i < mDevice.getInterfaceCount(); i++) {
+                Log.d(TAG, mDevice.getInterface(i).toString());
+            }
+            if (mPortNumber == -1) {
+                Log.d(TAG,"device might be castrated ACM device, trying single interface logic");
+                openSingleInterface();
+            } else {
+                Log.d(TAG,"trying default interface logic");
+                openInterface();
+            }
+        }
+
+        private void openSingleInterface() throws IOException {
+            // the following code is inspired by the cdc-acm driver in the linux kernel
+
+            mControlIndex = 0;
+            mControlInterface = mDevice.getInterface(0);
+            mDataInterface = mDevice.getInterface(0);
+            if (!mConnection.claimInterface(mControlInterface, true)) {
+                throw new IOException("Could not claim shared control/data interface");
+            }
+
+            for (int i = 0; i < mControlInterface.getEndpointCount(); ++i) {
+                UsbEndpoint ep = mControlInterface.getEndpoint(i);
+                if ((ep.getDirection() == UsbConstants.USB_DIR_IN) && (ep.getType() == UsbConstants.USB_ENDPOINT_XFER_INT)) {
+                    mControlEndpoint = ep;
+                } else if ((ep.getDirection() == UsbConstants.USB_DIR_IN) && (ep.getType() == UsbConstants.USB_ENDPOINT_XFER_BULK)) {
+                    mReadEndpoint = ep;
+                } else if ((ep.getDirection() == UsbConstants.USB_DIR_OUT) && (ep.getType() == UsbConstants.USB_ENDPOINT_XFER_BULK)) {
+                    mWriteEndpoint = ep;
+                }
+            }
+            if (mControlEndpoint == null) {
+                throw new IOException("No control endpoint");
+            }
+        }
+
+        private void openInterface() throws IOException {
+
+            mControlInterface = null;
+            mDataInterface = null;
+            int j = getInterfaceIdFromDescriptors();
+            Log.d(TAG, "interface count=" + mDevice.getInterfaceCount() + ", IAD=" + j);
+            if (j >= 0) {
+                for (int i = 0; i < mDevice.getInterfaceCount(); i++) {
+                    UsbInterface usbInterface = mDevice.getInterface(i);
+                    if (usbInterface.getId() == j || usbInterface.getId() == j+1) {
+                        if (usbInterface.getInterfaceClass() == UsbConstants.USB_CLASS_COMM &&
+                                usbInterface.getInterfaceSubclass() == USB_SUBCLASS_ACM) {
+                            mControlIndex = usbInterface.getId();
+                            mControlInterface = usbInterface;
+                        }
+                        if (usbInterface.getInterfaceClass() == UsbConstants.USB_CLASS_CDC_DATA) {
+                            mDataInterface = usbInterface;
+                        }
+                    }
+                }
+            }
+            if (mControlInterface == null || mDataInterface == null) {
+                Log.d(TAG, "no IAD fallback");
+                int controlInterfaceCount = 0;
+                int dataInterfaceCount = 0;
+                for (int i = 0; i < mDevice.getInterfaceCount(); i++) {
+                    UsbInterface usbInterface = mDevice.getInterface(i);
+                    if (usbInterface.getInterfaceClass() == UsbConstants.USB_CLASS_COMM &&
+                            usbInterface.getInterfaceSubclass() == USB_SUBCLASS_ACM) {
+                        if (controlInterfaceCount == mPortNumber) {
+                            mControlIndex = usbInterface.getId();
+                            mControlInterface = usbInterface;
+                        }
+                        controlInterfaceCount++;
+                    }
+                    if (usbInterface.getInterfaceClass() == UsbConstants.USB_CLASS_CDC_DATA) {
+                        if (dataInterfaceCount == mPortNumber) {
+                            mDataInterface = usbInterface;
+                        }
+                        dataInterfaceCount++;
+                    }
+                }
+            }
+
+            if(mControlInterface == null) {
+                throw new IOException("No control interface");
+            }
+            Log.d(TAG, "Control interface id " + mControlInterface.getId());
+
+            if (!mConnection.claimInterface(mControlInterface, true)) {
+                throw new IOException("Could not claim control interface");
+            }
+            mControlEndpoint = mControlInterface.getEndpoint(0);
+            if (mControlEndpoint.getDirection() != UsbConstants.USB_DIR_IN || mControlEndpoint.getType() != UsbConstants.USB_ENDPOINT_XFER_INT) {
+                throw new IOException("Invalid control endpoint");
+            }
+
+            if(mDataInterface == null) {
+                throw new IOException("No data interface");
+            }
+            Log.d(TAG, "data interface id " + mDataInterface.getId());
+            if (!mConnection.claimInterface(mDataInterface, true)) {
+                throw new IOException("Could not claim data interface");
+            }
+            for (int i = 0; i < mDataInterface.getEndpointCount(); i++) {
+                UsbEndpoint ep = mDataInterface.getEndpoint(i);
+                if (ep.getDirection() == UsbConstants.USB_DIR_IN && ep.getType() == UsbConstants.USB_ENDPOINT_XFER_BULK)
+                    mReadEndpoint = ep;
+                if (ep.getDirection() == UsbConstants.USB_DIR_OUT && ep.getType() == UsbConstants.USB_ENDPOINT_XFER_BULK)
+                    mWriteEndpoint = ep;
+            }
+        }
+
+        private int getInterfaceIdFromDescriptors() {
+            ArrayList<byte[]> descriptors = UsbUtils.getDescriptors(mConnection);
+            Log.d(TAG, "USB descriptor:");
+            for(byte[] descriptor : descriptors)
+                Log.d(TAG, HexDump.toHexString(descriptor));
+
+            if (descriptors.size() > 0 &&
+                    descriptors.get(0).length == 18 &&
+                    descriptors.get(0)[1] == 1 && // bDescriptorType
+                    descriptors.get(0)[4] == (byte)(UsbConstants.USB_CLASS_MISC) && //bDeviceClass
+                    descriptors.get(0)[5] == 2 && // bDeviceSubClass
+                    descriptors.get(0)[6] == 1) { // bDeviceProtocol
+                // is IAD device, see https://www.usb.org/sites/default/files/iadclasscode_r10.pdf
+                int port = -1;
+                for (int d = 1; d < descriptors.size(); d++) {
+                    if (descriptors.get(d).length == 8 &&
+                            descriptors.get(d)[1] == 0x0b && // bDescriptorType == IAD
+                            descriptors.get(d)[4] == UsbConstants.USB_CLASS_COMM && // bFunctionClass == CDC
+                            descriptors.get(d)[5] == USB_SUBCLASS_ACM) { // bFunctionSubClass == ACM
+                        port++;
+                        if (port == mPortNumber &&
+                                descriptors.get(d)[3] == 2) { // bInterfaceCount
+                            return descriptors.get(d)[2]; // bFirstInterface
+                        }
+                    }
+                }
+            }
+            return -1;
+        }
+
+        private int sendAcmControlMessage(int request, int value, byte[] buf) throws IOException {
+            int len = mConnection.controlTransfer(
+                    USB_RT_ACM, request, value, mControlIndex, buf, buf != null ? buf.length : 0, 5000);
+            if(len < 0) {
+                throw new IOException("controlTransfer failed");
+            }
+            return len;
+        }
+
+        @Override
+        protected void closeInt() {
+            try {
+                mConnection.releaseInterface(mControlInterface);
+                mConnection.releaseInterface(mDataInterface);
+            } catch(Exception ignored) {}
+        }
+
+        @Override
+        public void setParameters(int baudRate, int dataBits, int stopBits, @Parity int parity) throws IOException {
+            if(baudRate <= 0) {
+                throw new IllegalArgumentException("Invalid baud rate: " + baudRate);
+            }
+            if(dataBits < DATABITS_5 || dataBits > DATABITS_8) {
+                throw new IllegalArgumentException("Invalid data bits: " + dataBits);
+            }
+            byte stopBitsByte;
+            switch (stopBits) {
+                case STOPBITS_1: stopBitsByte = 0; break;
+                case STOPBITS_1_5: stopBitsByte = 1; break;
+                case STOPBITS_2: stopBitsByte = 2; break;
+                default: throw new IllegalArgumentException("Invalid stop bits: " + stopBits);
+            }
+
+            byte parityBitesByte;
+            switch (parity) {
+                case PARITY_NONE: parityBitesByte = 0; break;
+                case PARITY_ODD: parityBitesByte = 1; break;
+                case PARITY_EVEN: parityBitesByte = 2; break;
+                case PARITY_MARK: parityBitesByte = 3; break;
+                case PARITY_SPACE: parityBitesByte = 4; break;
+                default: throw new IllegalArgumentException("Invalid parity: " + parity);
+            }
+            byte[] msg = {
+                    (byte) ( baudRate & 0xff),
+                    (byte) ((baudRate >> 8 ) & 0xff),
+                    (byte) ((baudRate >> 16) & 0xff),
+                    (byte) ((baudRate >> 24) & 0xff),
+                    stopBitsByte,
+                    parityBitesByte,
+                    (byte) dataBits};
+            sendAcmControlMessage(SET_LINE_CODING, 0, msg);
+        }
+
+        @Override
+        public boolean getDTR() throws IOException {
+            return mDtr;
+        }
+
+        @Override
+        public void setDTR(boolean value) throws IOException {
+            mDtr = value;
+            setDtrRts();
+        }
+
+        @Override
+        public boolean getRTS() throws IOException {
+            return mRts;
+        }
+
+        @Override
+        public void setRTS(boolean value) throws IOException {
+            mRts = value;
+            setDtrRts();
+        }
+
+        private void setDtrRts() throws IOException {
+            int value = (mRts ? 0x2 : 0) | (mDtr ? 0x1 : 0);
+            sendAcmControlMessage(SET_CONTROL_LINE_STATE, value, null);
+        }
+
+        @Override
+        public EnumSet<ControlLine> getControlLines() throws IOException {
+            EnumSet<ControlLine> set = EnumSet.noneOf(ControlLine.class);
+            if(mRts) set.add(ControlLine.RTS);
+            if(mDtr) set.add(ControlLine.DTR);
+            return set;
+        }
+
+        @Override
+        public EnumSet<ControlLine> getSupportedControlLines() throws IOException {
+            return EnumSet.of(ControlLine.RTS, ControlLine.DTR);
+        }
+
+        @Override
+        public void setBreak(boolean value) throws IOException {
+            sendAcmControlMessage(SEND_BREAK, value ? 0xffff : 0, null);
+        }
+
+    }
+
+    @SuppressWarnings({"unused"})
+    public static Map<Integer, int[]> getSupportedDevices() {
+        return new LinkedHashMap<>();
+    }
+
+}

usbSerialForAndroid/src/main/java/com/hoho/android/usbserial/driver/Ch34xSerialDriver.java

@@ -0,0 +1,387 @@
+/* Copyright 2014 Andreas Butti
+ *
+ * Project home page: https://github.com/mik3y/usb-serial-for-android
+ */
+
+package com.hoho.android.usbserial.driver;
+
+import android.hardware.usb.UsbConstants;
+import android.hardware.usb.UsbDevice;
+import android.hardware.usb.UsbEndpoint;
+import android.hardware.usb.UsbInterface;
+import android.util.Log;
+
+import com.hoho.android.usbserial.BuildConfig;
+
+import java.io.IOException;
+import java.util.Collections;
+import java.util.EnumSet;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+public class Ch34xSerialDriver implements UsbSerialDriver {
+
+    private static final String TAG = Ch34xSerialDriver.class.getSimpleName();
+
+    private final UsbDevice mDevice;
+    private final UsbSerialPort mPort;
+
+    private static final int LCR_ENABLE_RX   = 0x80;
+    private static final int LCR_ENABLE_TX   = 0x40;
+    private static final int LCR_MARK_SPACE  = 0x20;
+    private static final int LCR_PAR_EVEN    = 0x10;
+    private static final int LCR_ENABLE_PAR  = 0x08;
+    private static final int LCR_STOP_BITS_2 = 0x04;
+    private static final int LCR_CS8         = 0x03;
+    private static final int LCR_CS7         = 0x02;
+    private static final int LCR_CS6         = 0x01;
+    private static final int LCR_CS5         = 0x00;
+
+    private static final int GCL_CTS = 0x01;
+    private static final int GCL_DSR = 0x02;
+    private static final int GCL_RI  = 0x04;
+    private static final int GCL_CD  = 0x08;
+    private static final int SCL_DTR = 0x20;
+    private static final int SCL_RTS = 0x40;
+
+    public Ch34xSerialDriver(UsbDevice device) {
+        mDevice = device;
+        mPort = new Ch340SerialPort(mDevice, 0);
+    }
+
+    @Override
+    public UsbDevice getDevice() {
+        return mDevice;
+    }
+
+    @Override
+    public List<UsbSerialPort> getPorts() {
+        return Collections.singletonList(mPort);
+    }
+
+    public class Ch340SerialPort extends CommonUsbSerialPort {
+
+        private static final int USB_TIMEOUT_MILLIS = 5000;
+
+        private final int DEFAULT_BAUD_RATE = 9600;
+
+        private boolean dtr = false;
+        private boolean rts = false;
+
+        public Ch340SerialPort(UsbDevice device, int portNumber) {
+            super(device, portNumber);
+        }
+
+        @Override
+        public UsbSerialDriver getDriver() {
+            return Ch34xSerialDriver.this;
+        }
+
+        @Override
+        protected void openInt() throws IOException {
+            for (int i = 0; i < mDevice.getInterfaceCount(); i++) {
+                UsbInterface usbIface = mDevice.getInterface(i);
+                if (!mConnection.claimInterface(usbIface, true)) {
+                    throw new IOException("Could not claim data interface");
+                }
+            }
+
+            UsbInterface dataIface = mDevice.getInterface(mDevice.getInterfaceCount() - 1);
+            for (int i = 0; i < dataIface.getEndpointCount(); i++) {
+                UsbEndpoint ep = dataIface.getEndpoint(i);
+                if (ep.getType() == UsbConstants.USB_ENDPOINT_XFER_BULK) {
+                    if (ep.getDirection() == UsbConstants.USB_DIR_IN) {
+                        mReadEndpoint = ep;
+                    } else {
+                        mWriteEndpoint = ep;
+                    }
+                }
+            }
+
+            initialize();
+            setBaudRate(DEFAULT_BAUD_RATE);
+        }
+
+        @Override
+        protected void closeInt() {
+            try {
+                for (int i = 0; i < mDevice.getInterfaceCount(); i++)
+                    mConnection.releaseInterface(mDevice.getInterface(i));
+            } catch(Exception ignored) {}
+        }
+
+        private int controlOut(int request, int value, int index) {
+            final int REQTYPE_HOST_TO_DEVICE = UsbConstants.USB_TYPE_VENDOR | UsbConstants.USB_DIR_OUT;
+            return mConnection.controlTransfer(REQTYPE_HOST_TO_DEVICE, request,
+                    value, index, null, 0, USB_TIMEOUT_MILLIS);
+        }
+
+
+        private int controlIn(int request, int value, int index, byte[] buffer) {
+            final int REQTYPE_DEVICE_TO_HOST = UsbConstants.USB_TYPE_VENDOR | UsbConstants.USB_DIR_IN;
+            return mConnection.controlTransfer(REQTYPE_DEVICE_TO_HOST, request,
+                    value, index, buffer, buffer.length, USB_TIMEOUT_MILLIS);
+        }
+
+
+        private void checkState(String msg, int request, int value, int[] expected) throws IOException {
+            byte[] buffer = new byte[expected.length];
+            int ret = controlIn(request, value, 0, buffer);
+
+            if (ret < 0) {
+                throw new IOException("Failed send cmd [" + msg + "]");
+            }
+
+            if (ret != expected.length) {
+                throw new IOException("Expected " + expected.length + " bytes, but get " + ret + " [" + msg + "]");
+            }
+
+            for (int i = 0; i < expected.length; i++) {
+                if (expected[i] == -1) {
+                    continue;
+                }
+
+                int current = buffer[i] & 0xff;
+                if (expected[i] != current) {
+                    throw new IOException("Expected 0x" + Integer.toHexString(expected[i]) + " byte, but get 0x" + Integer.toHexString(current) + " [" + msg + "]");
+                }
+            }
+        }
+
+        private void setControlLines() throws IOException {
+            if (controlOut(0xa4, ~((dtr ? SCL_DTR : 0) | (rts ? SCL_RTS : 0)), 0) < 0) {
+                throw new IOException("Failed to set control lines");
+            }
+        }
+
+        private byte getStatus() throws IOException {
+            byte[] buffer = new byte[2];
+            int ret = controlIn(0x95, 0x0706, 0, buffer);
+            if (ret < 0)
+                throw new IOException("Error getting control lines");
+            return buffer[0];
+        }
+
+        private void initialize() throws IOException {
+            checkState("init #1", 0x5f, 0, new int[]{-1 /* 0x27, 0x30 */, 0x00});
+
+            if (controlOut(0xa1, 0, 0) < 0) {
+                throw new IOException("Init failed: #2");
+            }
+
+            setBaudRate(DEFAULT_BAUD_RATE);
+
+            checkState("init #4", 0x95, 0x2518, new int[]{-1 /* 0x56, c3*/, 0x00});
+
+            if (controlOut(0x9a, 0x2518, LCR_ENABLE_RX | LCR_ENABLE_TX | LCR_CS8) < 0) {
+                throw new IOException("Init failed: #5");
+            }
+
+            checkState("init #6", 0x95, 0x0706, new int[]{-1/*0xf?*/, -1/*0xec,0xee*/});
+
+            if (controlOut(0xa1, 0x501f, 0xd90a) < 0) {
+                throw new IOException("Init failed: #7");
+            }
+
+            setBaudRate(DEFAULT_BAUD_RATE);
+
+            setControlLines();
+
+            checkState("init #10", 0x95, 0x0706, new int[]{-1/* 0x9f, 0xff*/, -1/*0xec,0xee*/});
+        }
+
+
+        private void setBaudRate(int baudRate) throws IOException {
+            long factor;
+            long divisor;
+
+            if (baudRate == 921600) {
+                divisor = 7;
+                factor = 0xf300;
+            } else {
+                final long BAUDBASE_FACTOR = 1532620800;
+                final int BAUDBASE_DIVMAX = 3;
+
+                if(BuildConfig.DEBUG && (baudRate & (3<<29)) == (1<<29))
+                    baudRate &= ~(1<<29); // for testing purpose bypass dedicated baud rate handling
+                factor = BAUDBASE_FACTOR / baudRate;
+                divisor = BAUDBASE_DIVMAX;
+                while ((factor > 0xfff0) && divisor > 0) {
+                    factor >>= 3;
+                    divisor--;
+                }
+                if (factor > 0xfff0) {
+                    throw new UnsupportedOperationException("Unsupported baud rate: " + baudRate);
+                }
+                factor = 0x10000 - factor;
+            }
+
+            divisor |= 0x0080; // else ch341a waits until buffer full
+            int val1 = (int) ((factor & 0xff00) | divisor);
+            int val2 = (int) (factor & 0xff);
+            Log.d(TAG, String.format("baud rate=%d, 0x1312=0x%04x, 0x0f2c=0x%04x", baudRate, val1, val2));
+            int ret = controlOut(0x9a, 0x1312, val1);
+            if (ret < 0) {
+                throw new IOException("Error setting baud rate: #1)");
+            }
+            ret = controlOut(0x9a, 0x0f2c, val2);
+            if (ret < 0) {
+                throw new IOException("Error setting baud rate: #2");
+            }
+        }
+
+        @Override
+        public void setParameters(int baudRate, int dataBits, int stopBits, @Parity int parity) throws IOException {
+            if(baudRate <= 0) {
+                throw new IllegalArgumentException("Invalid baud rate: " + baudRate);
+            }
+            setBaudRate(baudRate);
+
+            int lcr = LCR_ENABLE_RX | LCR_ENABLE_TX;
+
+            switch (dataBits) {
+                case DATABITS_5:
+                    lcr |= LCR_CS5;
+                    break;
+                case DATABITS_6:
+                    lcr |= LCR_CS6;
+                    break;
+                case DATABITS_7:
+                    lcr |= LCR_CS7;
+                    break;
+                case DATABITS_8:
+                    lcr |= LCR_CS8;
+                    break;
+                default:
+                    throw new IllegalArgumentException("Invalid data bits: " + dataBits);
+            }
+
+            switch (parity) {
+                case PARITY_NONE:
+                    break;
+                case PARITY_ODD:
+                    lcr |= LCR_ENABLE_PAR;
+                    break;
+                case PARITY_EVEN:
+                    lcr |= LCR_ENABLE_PAR | LCR_PAR_EVEN;
+                    break;
+                case PARITY_MARK:
+                    lcr |= LCR_ENABLE_PAR | LCR_MARK_SPACE;
+                    break;
+                case PARITY_SPACE:
+                    lcr |= LCR_ENABLE_PAR | LCR_MARK_SPACE | LCR_PAR_EVEN;
+                    break;
+                default:
+                    throw new IllegalArgumentException("Invalid parity: " + parity);
+            }
+
+            switch (stopBits) {
+                case STOPBITS_1:
+                    break;
+                case STOPBITS_1_5:
+                    throw new UnsupportedOperationException("Unsupported stop bits: 1.5");
+                case STOPBITS_2:
+                    lcr |= LCR_STOP_BITS_2;
+                    break;
+                default:
+                    throw new IllegalArgumentException("Invalid stop bits: " + stopBits);
+            }
+
+            int ret = controlOut(0x9a, 0x2518, lcr);
+            if (ret < 0) {
+                throw new IOException("Error setting control byte");
+            }
+        }
+
+        @Override
+        public boolean getCD() throws IOException {
+            return (getStatus() & GCL_CD) == 0;
+        }
+
+        @Override
+        public boolean getCTS() throws IOException {
+            return (getStatus() & GCL_CTS) == 0;
+        }
+
+        @Override
+        public boolean getDSR() throws IOException {
+            return (getStatus() & GCL_DSR) == 0;
+        }
+
+        @Override
+        public boolean getDTR() throws IOException {
+            return dtr;
+        }
+
+        @Override
+        public void setDTR(boolean value) throws IOException {
+            dtr = value;
+            setControlLines();
+        }
+
+        @Override
+        public boolean getRI() throws IOException {
+            return (getStatus() & GCL_RI) == 0;
+        }
+
+        @Override
+        public boolean getRTS() throws IOException {
+            return rts;
+        }
+
+        @Override
+        public void setRTS(boolean value) throws IOException {
+            rts = value;
+            setControlLines();
+        }
+
+        @Override
+        public EnumSet<ControlLine> getControlLines() throws IOException {
+            int status = getStatus();
+            EnumSet<ControlLine> set = EnumSet.noneOf(ControlLine.class);
+            if(rts) set.add(ControlLine.RTS);
+            if((status & GCL_CTS) == 0) set.add(ControlLine.CTS);
+            if(dtr) set.add(ControlLine.DTR);
+            if((status & GCL_DSR) == 0) set.add(ControlLine.DSR);
+            if((status & GCL_CD) == 0) set.add(ControlLine.CD);
+            if((status & GCL_RI) == 0) set.add(ControlLine.RI);
+            return set;
+        }
+
+        @Override
+        public EnumSet<ControlLine> getSupportedControlLines() throws IOException {
+            return EnumSet.allOf(ControlLine.class);
+        }
+
+        @Override
+        public void setBreak(boolean value) throws IOException {
+            byte[] req = new byte[2];
+            if(controlIn(0x95, 0x1805, 0, req) < 0) {
+                throw new IOException("Error getting BREAK condition");
+            }
+            if(value) {
+                req[0] &= ~1;
+                req[1] &= ~0x40;
+            } else {
+                req[0] |= 1;
+                req[1] |= 0x40;
+            }
+            int val = (req[1] & 0xff) << 8 | (req[0] & 0xff);
+            if(controlOut(0x9a, 0x1805, val) < 0) {
+                throw new IOException("Error setting BREAK condition");
+            }
+        }
+    }
+
+    @SuppressWarnings({"unused"})
+    public static Map<Integer, int[]> getSupportedDevices() {
+        final Map<Integer, int[]> supportedDevices = new LinkedHashMap<>();
+        supportedDevices.put(UsbId.VENDOR_QINHENG, new int[]{
+                UsbId.QINHENG_CH340,
+                UsbId.QINHENG_CH341A,
+        });
+        return supportedDevices;
+    }
+
+}