mirror of
https://github.com/mik3y/usb-serial-for-android
synced 2025-06-07 16:06:10 +00:00
Compare commits
No commits in common. "master" and "v3.6.0" have entirely different histories.
5
.github/workflows/build.yml
vendored
5
.github/workflows/build.yml
vendored
@ -8,8 +8,9 @@ jobs:
|
||||
runs-on: ubuntu-latest
|
||||
|
||||
steps:
|
||||
- uses: actions/checkout@v3
|
||||
- uses: actions/setup-java@v3
|
||||
- uses: actions/checkout@v2
|
||||
- name: set up JDK 1.17
|
||||
uses: actions/setup-java@v2
|
||||
with:
|
||||
distribution: 'temurin'
|
||||
java-version: '17'
|
||||
|
||||
7
.idea/.gitignore
generated
vendored
7
.idea/.gitignore
generated
vendored
@ -2,8 +2,5 @@ caches
|
||||
codeStyles
|
||||
libraries
|
||||
workspace.xml
|
||||
androidTestResultsUserPreferences.xml
|
||||
appInsightsSettings.xml
|
||||
deploymentTargetDropDown.xml
|
||||
deploymentTargetSelector.xml
|
||||
other.xml
|
||||
androidTestResultsUserPreferences.xml
|
||||
deploymentTargetDropDown.xml
|
||||
6
.idea/AndroidProjectSystem.xml
generated
6
.idea/AndroidProjectSystem.xml
generated
@ -1,6 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<project version="4">
|
||||
<component name="AndroidProjectSystem">
|
||||
<option name="providerId" value="com.android.tools.idea.GradleProjectSystem" />
|
||||
</component>
|
||||
</project>
|
||||
2
.idea/compiler.xml
generated
2
.idea/compiler.xml
generated
@ -1,6 +1,6 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<project version="4">
|
||||
<component name="CompilerConfiguration">
|
||||
<bytecodeTargetLevel target="21" />
|
||||
<bytecodeTargetLevel target="17" />
|
||||
</component>
|
||||
</project>
|
||||
13
.idea/misc.xml
generated
13
.idea/misc.xml
generated
@ -1,4 +1,3 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<project version="4">
|
||||
<component name="ExternalStorageConfigurationManager" enabled="true" />
|
||||
<component name="NullableNotNullManager">
|
||||
@ -6,7 +5,7 @@
|
||||
<option name="myDefaultNotNull" value="androidx.annotation.NonNull" />
|
||||
<option name="myNullables">
|
||||
<value>
|
||||
<list size="18">
|
||||
<list size="15">
|
||||
<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" />
|
||||
@ -22,15 +21,12 @@
|
||||
<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">
|
||||
<list size="14">
|
||||
<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" />
|
||||
@ -45,14 +41,11 @@
|
||||
<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">
|
||||
<component name="ProjectRootManager" version="2" languageLevel="JDK_17" project-jdk-name="jbr-17" project-jdk-type="JavaSDK">
|
||||
<output url="file://$PROJECT_DIR$/build/classes" />
|
||||
</component>
|
||||
<component name="ProjectType">
|
||||
|
||||
17
.idea/runConfigurations.xml
generated
17
.idea/runConfigurations.xml
generated
@ -1,17 +0,0 @@
|
||||
<?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>
|
||||
32
README.md
32
README.md
@ -37,15 +37,10 @@ dependencyResolutionManagement {
|
||||
}
|
||||
```
|
||||
|
||||
If using gradle kotlin use line
|
||||
```gradle.kts
|
||||
maven(url = "https://jitpack.io")
|
||||
```
|
||||
|
||||
Add library to dependencies
|
||||
```gradle
|
||||
dependencies {
|
||||
implementation 'com.github.mik3y:usb-serial-for-android:3.9.0'
|
||||
implementation 'com.github.mik3y:usb-serial-for-android:3.6.0'
|
||||
}
|
||||
```
|
||||
|
||||
@ -115,10 +110,9 @@ For a simple example, see
|
||||
[UsbSerialExamples](https://github.com/mik3y/usb-serial-for-android/blob/master/usbSerialExamples)
|
||||
folder in this project.
|
||||
|
||||
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
|
||||
For a more complete example with background service to stay connected while
|
||||
the app is not visible or rotating, see separate github project
|
||||
[SimpleUsbTerminal](https://github.com/kai-morich/SimpleUsbTerminal).
|
||||
|
||||
## Probing for Unrecognized Devices
|
||||
|
||||
@ -145,8 +139,8 @@ 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.
|
||||
*Note*: as of v3.5.0 this library detects CDC devices by USB interface types instead of fixed VID+PID,
|
||||
so custom probers are typically not required any more for CDC 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
|
||||
@ -154,21 +148,17 @@ a compatible UsbDevice.
|
||||
|
||||
## Compatible Devices
|
||||
|
||||
This library supports USB to serial converter chips with specific drivers
|
||||
This library supports USB to serial converter chips:
|
||||
* FTDI FT232R, FT232H, FT2232H, FT4232H, FT230X, FT231X, FT234XD
|
||||
* Prolific PL2303
|
||||
* Silabs CP2102, CP210*
|
||||
* Qinheng CH340, CH341A
|
||||
|
||||
some other device specific drivers
|
||||
* Silabs CP2102 and all other CP210x
|
||||
* Qinheng CH340, CH341A, CH9102
|
||||
* GsmModem devices, e.g. for Unisoc based Fibocom GSM modems
|
||||
* Chrome OS CCD (Closed Case Debugging)
|
||||
|
||||
and devices implementing the generic CDC/ACM protocol like
|
||||
* Qinheng CH9102
|
||||
* Microchip MCP2221
|
||||
and devices implementing the CDC/ACM protocol like
|
||||
* Arduino using ATmega32U4
|
||||
* Digispark using V-USB software USB
|
||||
* BBC micro:bit using ARM mbed DAPLink firmware
|
||||
* ...
|
||||
|
||||
## Help & Discussion
|
||||
|
||||
@ -6,7 +6,7 @@ buildscript {
|
||||
google()
|
||||
}
|
||||
dependencies {
|
||||
classpath 'com.android.tools.build:gradle:8.9.1'
|
||||
classpath 'com.android.tools.build:gradle:8.0.2'
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -1,5 +0,0 @@
|
||||
codecov:
|
||||
max_report_age: off
|
||||
require_ci_to_pass: no
|
||||
notify:
|
||||
wait_for_ci: no
|
||||
2
gradle/wrapper/gradle-wrapper.properties
vendored
2
gradle/wrapper/gradle-wrapper.properties
vendored
@ -3,4 +3,4 @@ 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
|
||||
distributionUrl=https\://services.gradle.org/distributions/gradle-8.0-all.zip
|
||||
|
||||
@ -3,7 +3,7 @@ plugins {
|
||||
}
|
||||
|
||||
android {
|
||||
compileSdkVersion 35
|
||||
compileSdkVersion 33
|
||||
|
||||
compileOptions {
|
||||
sourceCompatibility JavaVersion.VERSION_1_8
|
||||
@ -12,7 +12,7 @@ android {
|
||||
|
||||
defaultConfig {
|
||||
minSdkVersion 17
|
||||
targetSdkVersion 35
|
||||
targetSdkVersion 33
|
||||
vectorDrawables.useSupportLibrary = true
|
||||
|
||||
missingDimensionStrategy 'device', 'anyDevice'
|
||||
@ -28,6 +28,6 @@ android {
|
||||
|
||||
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
|
||||
implementation 'androidx.appcompat:appcompat:1.6.1'
|
||||
implementation 'com.google.android.material:material:1.9.0'
|
||||
}
|
||||
|
||||
@ -28,7 +28,6 @@ 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;
|
||||
@ -90,22 +89,12 @@ public class TerminalFragment extends Fragment implements SerialInputOutputManag
|
||||
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))
|
||||
getActivity().registerReceiver(broadcastReceiver, new IntentFilter(INTENT_ACTION_GRANT_USB));
|
||||
|
||||
if(usbPermission == UsbPermission.Unknown || usbPermission == UsbPermission.Granted)
|
||||
mainLooper.post(this::connect);
|
||||
}
|
||||
|
||||
@ -115,6 +104,7 @@ public class TerminalFragment extends Fragment implements SerialInputOutputManag
|
||||
status("disconnected");
|
||||
disconnect();
|
||||
}
|
||||
getActivity().unregisterReceiver(broadcastReceiver);
|
||||
super.onPause();
|
||||
}
|
||||
|
||||
@ -214,7 +204,7 @@ public class TerminalFragment extends Fragment implements SerialInputOutputManag
|
||||
status("connection failed: no driver for device");
|
||||
return;
|
||||
}
|
||||
if(portNum >= driver.getPorts().size()) {
|
||||
if(driver.getPorts().size() < portNum) {
|
||||
status("connection failed: not enough ports at device");
|
||||
return;
|
||||
}
|
||||
@ -223,9 +213,7 @@ public class TerminalFragment extends Fragment implements SerialInputOutputManag
|
||||
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);
|
||||
PendingIntent usbPermissionIntent = PendingIntent.getBroadcast(getActivity(), 0, new Intent(INTENT_ACTION_GRANT_USB), flags);
|
||||
usbManager.requestPermission(driver.getDevice(), usbPermissionIntent);
|
||||
return;
|
||||
}
|
||||
|
||||
@ -4,16 +4,16 @@ plugins {
|
||||
}
|
||||
|
||||
android {
|
||||
compileSdkVersion 35
|
||||
compileSdkVersion 33
|
||||
|
||||
defaultConfig {
|
||||
minSdkVersion 17
|
||||
targetSdkVersion 35
|
||||
targetSdkVersion 33
|
||||
consumerProguardFiles 'proguard-rules.pro'
|
||||
|
||||
testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
|
||||
testInstrumentationRunnerArguments = [ // Raspi Windows LinuxVM ...
|
||||
'rfc2217_server_host': '192.168.0.78',
|
||||
'rfc2217_server_host': '192.168.0.143',
|
||||
'rfc2217_server_nonstandard_baudrates': 'true', // true false false
|
||||
]
|
||||
}
|
||||
@ -31,14 +31,13 @@ android {
|
||||
}
|
||||
|
||||
dependencies {
|
||||
implementation "androidx.annotation:annotation:1.9.1"
|
||||
implementation "androidx.annotation:annotation:1.5.0"
|
||||
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'
|
||||
testImplementation 'org.mockito:mockito-core:5.4.0'
|
||||
androidTestImplementation 'androidx.test:core:1.5.0'
|
||||
androidTestImplementation 'androidx.test:runner:1.5.2'
|
||||
androidTestImplementation 'commons-net:commons-net:3.9.0'
|
||||
androidTestImplementation 'org.apache.commons:commons-lang3:3.12.0'
|
||||
}
|
||||
|
||||
// gradle task: publishToMavenLocal
|
||||
@ -51,7 +50,7 @@ project.afterEvaluate {
|
||||
// values used for local maven repo, jitpack uses github release:
|
||||
groupId 'com.github.mik3y'
|
||||
artifactId 'usb-serial-for-android'
|
||||
version '3.8.0beta'
|
||||
version '3.5.2beta'
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -2,13 +2,13 @@
|
||||
apply plugin: 'jacoco'
|
||||
|
||||
android {
|
||||
flavorDimensions += 'device'
|
||||
flavorDimensions 'device'
|
||||
productFlavors {
|
||||
anyDevice {
|
||||
// Used as fallback in usbSerialExample/build.gradle -> missingDimensionStrategy, but not for coverage report
|
||||
dimension 'device'
|
||||
}
|
||||
mcp2221 {
|
||||
arduino {
|
||||
dimension 'device'
|
||||
testInstrumentationRunnerArguments = ['test_device_driver': 'CdcAcm']
|
||||
}
|
||||
@ -18,7 +18,7 @@ android {
|
||||
}
|
||||
cp2102 { // and cp2105 first port
|
||||
dimension 'device'
|
||||
testInstrumentationRunnerArguments = ['test_device_driver': 'Cp21xx', 'test_device_port': '0']
|
||||
testInstrumentationRunnerArguments = ['test_device_driver': 'Cp21xx']
|
||||
}
|
||||
cp2105 { // second port
|
||||
dimension 'device'
|
||||
@ -26,7 +26,7 @@ android {
|
||||
}
|
||||
ft232 { // and ft2232 first port
|
||||
dimension 'device'
|
||||
testInstrumentationRunnerArguments = ['test_device_driver': 'Ftdi', 'test_device_port': '0']
|
||||
testInstrumentationRunnerArguments = ['test_device_driver': 'Ftdi']
|
||||
}
|
||||
ft2232 { // second port
|
||||
dimension 'device'
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -18,7 +18,6 @@ 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;
|
||||
@ -33,8 +32,6 @@ 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;
|
||||
@ -59,13 +56,11 @@ public class UsbWrapper implements SerialInputOutputManager.Listener {
|
||||
|
||||
// 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;
|
||||
@ -90,11 +85,9 @@ public class UsbWrapper implements SerialInputOutputManager.Listener {
|
||||
}
|
||||
};
|
||||
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);
|
||||
PendingIntent permissionIntent = PendingIntent.getBroadcast(context, 0, new Intent("com.android.example.USB_PERMISSION"), flags);
|
||||
IntentFilter filter = new IntentFilter("com.android.example.USB_PERMISSION");
|
||||
ContextCompat.registerReceiver(context, usbReceiver, filter, Context.RECEIVER_NOT_EXPORTED);
|
||||
context.registerReceiver(usbReceiver, filter);
|
||||
usbManager.requestPermission(serialDriver.getDevice(), permissionIntent);
|
||||
for(int i=0; i<5000; i++) {
|
||||
if(granted[0] != null) break;
|
||||
@ -106,10 +99,9 @@ public class UsbWrapper implements SerialInputOutputManager.Listener {
|
||||
|
||||
// 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
|
||||
// output lines are supported by all drivers
|
||||
// input lines are supported by all 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
|
||||
@ -118,21 +110,16 @@ public class UsbWrapper implements SerialInputOutputManager.Listener {
|
||||
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) {
|
||||
@ -149,18 +136,10 @@ public class UsbWrapper implements SerialInputOutputManager.Listener {
|
||||
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
|
||||
writePacketSize = 64; writeBufferSize = 128;
|
||||
}
|
||||
|
||||
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() {
|
||||
@ -189,8 +168,6 @@ public class UsbWrapper implements SerialInputOutputManager.Listener {
|
||||
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) {
|
||||
}
|
||||
@ -240,10 +217,6 @@ public class UsbWrapper implements SerialInputOutputManager.Listener {
|
||||
readBuffer.clear();
|
||||
}
|
||||
readError = null;
|
||||
|
||||
if (serialDriver instanceof ProlificSerialDriver && ProlificSerialPortWrapper.isDeviceTypeHxn(serialPort)) {
|
||||
readBufferSize = 768;
|
||||
}
|
||||
}
|
||||
|
||||
public void waitForIoManagerStarted() throws IOException {
|
||||
@ -258,15 +231,12 @@ public class UsbWrapper implements SerialInputOutputManager.Listener {
|
||||
throw new IOException("IoManager not started");
|
||||
}
|
||||
|
||||
public boolean hasIoManagerThreads() {
|
||||
int c = 0;
|
||||
public boolean hasIoManagerThread() {
|
||||
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;
|
||||
if (thread.getName().equals(SerialInputOutputManager.class.getSimpleName()))
|
||||
return true;
|
||||
}
|
||||
return c == 2;
|
||||
return false;
|
||||
}
|
||||
|
||||
// wait full time
|
||||
|
||||
@ -22,366 +22,366 @@ import java.util.Map;
|
||||
|
||||
public class Ch34xSerialDriver implements UsbSerialDriver {
|
||||
|
||||
private static final String TAG = Ch34xSerialDriver.class.getSimpleName();
|
||||
private static final String TAG = Ch34xSerialDriver.class.getSimpleName();
|
||||
|
||||
private final UsbDevice mDevice;
|
||||
private final UsbSerialPort mPort;
|
||||
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 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;
|
||||
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);
|
||||
}
|
||||
public Ch34xSerialDriver(UsbDevice device) {
|
||||
mDevice = device;
|
||||
mPort = new Ch340SerialPort(mDevice, 0);
|
||||
}
|
||||
|
||||
@Override
|
||||
public UsbDevice getDevice() {
|
||||
return mDevice;
|
||||
}
|
||||
@Override
|
||||
public UsbDevice getDevice() {
|
||||
return mDevice;
|
||||
}
|
||||
|
||||
@Override
|
||||
public List<UsbSerialPort> getPorts() {
|
||||
return Collections.singletonList(mPort);
|
||||
}
|
||||
@Override
|
||||
public List<UsbSerialPort> getPorts() {
|
||||
return Collections.singletonList(mPort);
|
||||
}
|
||||
|
||||
public class Ch340SerialPort extends CommonUsbSerialPort {
|
||||
public class Ch340SerialPort extends CommonUsbSerialPort {
|
||||
|
||||
private static final int USB_TIMEOUT_MILLIS = 5000;
|
||||
private static final int USB_TIMEOUT_MILLIS = 5000;
|
||||
|
||||
private final int DEFAULT_BAUD_RATE = 9600;
|
||||
private final int DEFAULT_BAUD_RATE = 9600;
|
||||
|
||||
private boolean dtr = false;
|
||||
private boolean rts = false;
|
||||
private boolean dtr = false;
|
||||
private boolean rts = false;
|
||||
|
||||
public Ch340SerialPort(UsbDevice device, int portNumber) {
|
||||
super(device, portNumber);
|
||||
}
|
||||
public Ch340SerialPort(UsbDevice device, int portNumber) {
|
||||
super(device, portNumber);
|
||||
}
|
||||
|
||||
@Override
|
||||
public UsbSerialDriver getDriver() {
|
||||
return Ch34xSerialDriver.this;
|
||||
}
|
||||
@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");
|
||||
}
|
||||
}
|
||||
@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;
|
||||
}
|
||||
}
|
||||
}
|
||||
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);
|
||||
}
|
||||
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) {}
|
||||
}
|
||||
@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 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 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);
|
||||
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 < 0) {
|
||||
throw new IOException("Failed send cmd [" + msg + "]");
|
||||
}
|
||||
|
||||
if (ret != expected.length) {
|
||||
throw new IOException("Expected " + expected.length + " bytes, but get " + ret + " [" + 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;
|
||||
}
|
||||
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 + "]");
|
||||
}
|
||||
}
|
||||
}
|
||||
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 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 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});
|
||||
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");
|
||||
}
|
||||
if (controlOut(0xa1, 0, 0) < 0) {
|
||||
throw new IOException("Init failed: #2");
|
||||
}
|
||||
|
||||
setBaudRate(DEFAULT_BAUD_RATE);
|
||||
setBaudRate(DEFAULT_BAUD_RATE);
|
||||
|
||||
checkState("init #4", 0x95, 0x2518, new int[]{-1 /* 0x56, c3*/, 0x00});
|
||||
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");
|
||||
}
|
||||
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*/});
|
||||
checkState("init #6", 0x95, 0x0706, new int[]{-1/*0xf?*/, -1/*0xec,0xee*/});
|
||||
|
||||
if (controlOut(0xa1, 0x501f, 0xd90a) < 0) {
|
||||
throw new IOException("Init failed: #7");
|
||||
}
|
||||
if (controlOut(0xa1, 0x501f, 0xd90a) < 0) {
|
||||
throw new IOException("Init failed: #7");
|
||||
}
|
||||
|
||||
setBaudRate(DEFAULT_BAUD_RATE);
|
||||
setBaudRate(DEFAULT_BAUD_RATE);
|
||||
|
||||
setControlLines();
|
||||
setControlLines();
|
||||
|
||||
checkState("init #10", 0x95, 0x0706, new int[]{-1/* 0x9f, 0xff*/, -1/*0xec,0xee*/});
|
||||
}
|
||||
checkState("init #10", 0x95, 0x0706, new int[]{-1/* 0x9f, 0xff*/, -1/*0xec,0xee*/});
|
||||
}
|
||||
|
||||
|
||||
private void setBaudRate(int baudRate) throws IOException {
|
||||
long factor;
|
||||
long divisor;
|
||||
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 (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;
|
||||
}
|
||||
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");
|
||||
}
|
||||
}
|
||||
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);
|
||||
@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;
|
||||
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 (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 (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);
|
||||
}
|
||||
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");
|
||||
}
|
||||
}
|
||||
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 getCD() throws IOException {
|
||||
return (getStatus() & GCL_CD) == 0;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean getCTS() throws IOException {
|
||||
return (getStatus() & GCL_CTS) == 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 getDSR() throws IOException {
|
||||
return (getStatus() & GCL_DSR) == 0;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean getDTR() throws IOException {
|
||||
return dtr;
|
||||
}
|
||||
@Override
|
||||
public boolean getDTR() throws IOException {
|
||||
return dtr;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setDTR(boolean value) throws IOException {
|
||||
dtr = value;
|
||||
setControlLines();
|
||||
}
|
||||
@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 getRI() throws IOException {
|
||||
return (getStatus() & GCL_RI) == 0;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean getRTS() throws IOException {
|
||||
return rts;
|
||||
}
|
||||
@Override
|
||||
public boolean getRTS() throws IOException {
|
||||
return rts;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setRTS(boolean value) throws IOException {
|
||||
rts = value;
|
||||
setControlLines();
|
||||
}
|
||||
@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> 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 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");
|
||||
}
|
||||
}
|
||||
}
|
||||
@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;
|
||||
}
|
||||
@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;
|
||||
}
|
||||
|
||||
}
|
||||
@ -1,91 +0,0 @@
|
||||
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 java.io.IOException;
|
||||
import java.util.Collections;
|
||||
import java.util.EnumSet;
|
||||
import java.util.LinkedHashMap;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.ArrayList;
|
||||
|
||||
public class ChromeCcdSerialDriver implements UsbSerialDriver{
|
||||
|
||||
private final String TAG = ChromeCcdSerialDriver.class.getSimpleName();
|
||||
|
||||
private final UsbDevice mDevice;
|
||||
private final List<UsbSerialPort> mPorts;
|
||||
|
||||
@Override
|
||||
public UsbDevice getDevice() {
|
||||
return mDevice;
|
||||
}
|
||||
|
||||
@Override
|
||||
public List<UsbSerialPort> getPorts() {
|
||||
return mPorts;
|
||||
}
|
||||
|
||||
public ChromeCcdSerialDriver(UsbDevice mDevice) {
|
||||
this.mDevice = mDevice;
|
||||
mPorts = new ArrayList<UsbSerialPort>();
|
||||
for (int i = 0; i < 3; i++)
|
||||
mPorts.add(new ChromeCcdSerialPort(mDevice, i));
|
||||
}
|
||||
|
||||
public class ChromeCcdSerialPort extends CommonUsbSerialPort {
|
||||
private UsbInterface mDataInterface;
|
||||
|
||||
public ChromeCcdSerialPort(UsbDevice device, int portNumber) {
|
||||
super(device, portNumber);
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void openInt() throws IOException {
|
||||
Log.d(TAG, "claiming interfaces, count=" + mDevice.getInterfaceCount());
|
||||
mDataInterface = mDevice.getInterface(mPortNumber);
|
||||
if (!mConnection.claimInterface(mDataInterface, true)) {
|
||||
throw new IOException("Could not claim shared control/data interface");
|
||||
}
|
||||
Log.d(TAG, "endpoint count=" + mDataInterface.getEndpointCount());
|
||||
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;
|
||||
} else if ((ep.getDirection() == UsbConstants.USB_DIR_OUT) && (ep.getType() == UsbConstants.USB_ENDPOINT_XFER_BULK)) {
|
||||
mWriteEndpoint = ep;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void closeInt() {
|
||||
try {
|
||||
mConnection.releaseInterface(mDataInterface);
|
||||
} catch(Exception ignored) {}
|
||||
}
|
||||
|
||||
@Override
|
||||
public UsbSerialDriver getDriver() {
|
||||
return ChromeCcdSerialDriver.this;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setParameters(int baudRate, int dataBits, int stopBits, int parity) throws IOException {
|
||||
throw new UnsupportedOperationException();
|
||||
}
|
||||
}
|
||||
|
||||
public static Map<Integer, int[]> getSupportedDevices() {
|
||||
final Map<Integer, int[]> supportedDevices = new LinkedHashMap<>();
|
||||
supportedDevices.put(UsbId.VENDOR_GOOGLE, new int[]{
|
||||
UsbId.GOOGLE_CR50,
|
||||
});
|
||||
return supportedDevices;
|
||||
}
|
||||
}
|
||||
@ -10,7 +10,6 @@ import android.hardware.usb.UsbDevice;
|
||||
import android.hardware.usb.UsbDeviceConnection;
|
||||
import android.hardware.usb.UsbEndpoint;
|
||||
import android.hardware.usb.UsbRequest;
|
||||
import android.os.Build;
|
||||
import android.util.Log;
|
||||
|
||||
import com.hoho.android.usbserial.util.MonotonicClock;
|
||||
@ -29,17 +28,16 @@ public abstract class CommonUsbSerialPort implements UsbSerialPort {
|
||||
public static boolean DEBUG = false;
|
||||
|
||||
private static final String TAG = CommonUsbSerialPort.class.getSimpleName();
|
||||
private static final int MAX_READ_SIZE = 16 * 1024; // = old bulkTransfer limit prior to Android 9
|
||||
private static final int MAX_READ_SIZE = 16 * 1024; // = old bulkTransfer limit
|
||||
|
||||
protected final UsbDevice mDevice;
|
||||
protected final int mPortNumber;
|
||||
|
||||
// non-null when open()
|
||||
protected UsbDeviceConnection mConnection;
|
||||
protected UsbDeviceConnection mConnection = null;
|
||||
protected UsbEndpoint mReadEndpoint;
|
||||
protected UsbEndpoint mWriteEndpoint;
|
||||
protected UsbRequest mUsbRequest;
|
||||
protected FlowControl mFlowControl = FlowControl.NONE;
|
||||
|
||||
/**
|
||||
* Internal write buffer.
|
||||
@ -119,7 +117,6 @@ public abstract class CommonUsbSerialPort implements UsbSerialPort {
|
||||
throw new IllegalArgumentException("Connection is null");
|
||||
}
|
||||
mConnection = connection;
|
||||
boolean ok = false;
|
||||
try {
|
||||
openInt();
|
||||
if (mReadEndpoint == null || mWriteEndpoint == null) {
|
||||
@ -127,13 +124,11 @@ public abstract class CommonUsbSerialPort implements UsbSerialPort {
|
||||
}
|
||||
mUsbRequest = new UsbRequest();
|
||||
mUsbRequest.initialize(mConnection, mReadEndpoint);
|
||||
ok = true;
|
||||
} finally {
|
||||
if (!ok) {
|
||||
try {
|
||||
close();
|
||||
} catch (Exception ignored) {}
|
||||
}
|
||||
} catch(Exception e) {
|
||||
try {
|
||||
close();
|
||||
} catch(Exception ignored) {}
|
||||
throw e;
|
||||
}
|
||||
}
|
||||
|
||||
@ -144,11 +139,10 @@ public abstract class CommonUsbSerialPort implements UsbSerialPort {
|
||||
if (mConnection == null) {
|
||||
throw new IOException("Already closed");
|
||||
}
|
||||
UsbRequest usbRequest = mUsbRequest;
|
||||
mUsbRequest = null;
|
||||
try {
|
||||
usbRequest.cancel();
|
||||
mUsbRequest.cancel();
|
||||
} catch(Exception ignored) {}
|
||||
mUsbRequest = null;
|
||||
try {
|
||||
closeInt();
|
||||
} catch(Exception ignored) {}
|
||||
@ -163,40 +157,28 @@ public abstract class CommonUsbSerialPort implements UsbSerialPort {
|
||||
/**
|
||||
* use simple USB request supported by all devices to test if connection is still valid
|
||||
*/
|
||||
protected void testConnection(boolean full) throws IOException {
|
||||
testConnection(full, "USB get_status request failed");
|
||||
}
|
||||
|
||||
protected void testConnection(boolean full, String msg) throws IOException {
|
||||
if(mUsbRequest == null) {
|
||||
protected void testConnection() throws IOException {
|
||||
if(mConnection == null || mUsbRequest == null) {
|
||||
throw new IOException("Connection closed");
|
||||
}
|
||||
if(!full) {
|
||||
return;
|
||||
}
|
||||
byte[] buf = new byte[2];
|
||||
int len = mConnection.controlTransfer(0x80 /*DEVICE*/, 0 /*GET_STATUS*/, 0, 0, buf, buf.length, 200);
|
||||
if(len < 0)
|
||||
throw new IOException(msg);
|
||||
throw new IOException("USB get_status request failed");
|
||||
}
|
||||
|
||||
@Override
|
||||
public int read(final byte[] dest, final int timeout) throws IOException {
|
||||
if(dest.length == 0) {
|
||||
throw new IllegalArgumentException("Read buffer too small");
|
||||
}
|
||||
return read(dest, dest.length, timeout);
|
||||
return read(dest, timeout, true);
|
||||
}
|
||||
|
||||
@Override
|
||||
public int read(final byte[] dest, final int length, final int timeout) throws IOException {return read(dest, length, timeout, true);}
|
||||
|
||||
protected int read(final byte[] dest, int length, final int timeout, boolean testConnection) throws IOException {
|
||||
testConnection(false);
|
||||
if(length <= 0) {
|
||||
throw new IllegalArgumentException("Read length too small");
|
||||
protected int read(final byte[] dest, final int timeout, boolean testConnection) throws IOException {
|
||||
if(mConnection == null || mUsbRequest == null) {
|
||||
throw new IOException("Connection closed");
|
||||
}
|
||||
if(dest.length <= 0) {
|
||||
throw new IllegalArgumentException("Read buffer to small");
|
||||
}
|
||||
length = Math.min(length, dest.length);
|
||||
final int nread;
|
||||
if (timeout != 0) {
|
||||
// bulkTransfer will cause data loss with short timeout + high baud rates + continuous transfer
|
||||
@ -208,16 +190,16 @@ public abstract class CommonUsbSerialPort implements UsbSerialPort {
|
||||
// /system/lib64/libandroid_runtime.so (android_hardware_UsbDeviceConnection_request_wait(_JNIEnv*, _jobject*, long)+84)
|
||||
// data loss / crashes were observed with timeout up to 200 msec
|
||||
long endTime = testConnection ? MonotonicClock.millis() + timeout : 0;
|
||||
int readMax = (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) ? length : Math.min(length, MAX_READ_SIZE);
|
||||
int readMax = Math.min(dest.length, MAX_READ_SIZE);
|
||||
nread = mConnection.bulkTransfer(mReadEndpoint, dest, readMax, timeout);
|
||||
// Android error propagation is improvable:
|
||||
// nread == -1 can be: timeout, connection lost, buffer to small, ???
|
||||
if(nread == -1 && testConnection)
|
||||
testConnection(MonotonicClock.millis() < endTime);
|
||||
if(nread == -1 && testConnection && MonotonicClock.millis() < endTime)
|
||||
testConnection();
|
||||
|
||||
} else {
|
||||
final ByteBuffer buf = ByteBuffer.wrap(dest, 0, length);
|
||||
if (!mUsbRequest.queue(buf, length)) {
|
||||
final ByteBuffer buf = ByteBuffer.wrap(dest);
|
||||
if (!mUsbRequest.queue(buf, dest.length)) {
|
||||
throw new IOException("Queueing USB request failed");
|
||||
}
|
||||
final UsbRequest response = mConnection.requestWait();
|
||||
@ -228,23 +210,21 @@ public abstract class CommonUsbSerialPort implements UsbSerialPort {
|
||||
// Android error propagation is improvable:
|
||||
// response != null & nread == 0 can be: connection lost, buffer to small, ???
|
||||
if(nread == 0) {
|
||||
testConnection(true);
|
||||
testConnection();
|
||||
}
|
||||
}
|
||||
return Math.max(nread, 0);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void write(byte[] src, int timeout) throws IOException {write(src, src.length, timeout);}
|
||||
|
||||
@Override
|
||||
public void write(final byte[] src, int length, final int timeout) throws IOException {
|
||||
public void write(final byte[] src, final int timeout) throws IOException {
|
||||
int offset = 0;
|
||||
long startTime = MonotonicClock.millis();
|
||||
length = Math.min(length, src.length);
|
||||
final long endTime = (timeout == 0) ? 0 : (MonotonicClock.millis() + timeout);
|
||||
|
||||
testConnection(false);
|
||||
while (offset < length) {
|
||||
if(mConnection == null) {
|
||||
throw new IOException("Connection closed");
|
||||
}
|
||||
while (offset < src.length) {
|
||||
int requestTimeout;
|
||||
final int requestLength;
|
||||
final int actualLength;
|
||||
@ -255,7 +235,7 @@ public abstract class CommonUsbSerialPort implements UsbSerialPort {
|
||||
if (mWriteBuffer == null) {
|
||||
mWriteBuffer = new byte[mWriteEndpoint.getMaxPacketSize()];
|
||||
}
|
||||
requestLength = Math.min(length - offset, mWriteBuffer.length);
|
||||
requestLength = Math.min(src.length - offset, mWriteBuffer.length);
|
||||
if (offset == 0) {
|
||||
writeBuffer = src;
|
||||
} else {
|
||||
@ -266,7 +246,7 @@ public abstract class CommonUsbSerialPort implements UsbSerialPort {
|
||||
if (timeout == 0 || offset == 0) {
|
||||
requestTimeout = timeout;
|
||||
} else {
|
||||
requestTimeout = (int)(startTime + timeout - MonotonicClock.millis());
|
||||
requestTimeout = (int)(endTime - MonotonicClock.millis());
|
||||
if(requestTimeout == 0)
|
||||
requestTimeout = -1;
|
||||
}
|
||||
@ -276,19 +256,16 @@ public abstract class CommonUsbSerialPort implements UsbSerialPort {
|
||||
actualLength = mConnection.bulkTransfer(mWriteEndpoint, writeBuffer, requestLength, requestTimeout);
|
||||
}
|
||||
}
|
||||
long elapsed = MonotonicClock.millis() - startTime;
|
||||
if (DEBUG) {
|
||||
Log.d(TAG, "Wrote " + actualLength + "/" + requestLength + " offset " + offset + "/" + length + " time " + elapsed + "/" + requestTimeout);
|
||||
Log.d(TAG, "Wrote " + actualLength + "/" + requestLength + " offset " + offset + "/" + src.length + " timeout " + requestTimeout);
|
||||
}
|
||||
if (actualLength <= 0) {
|
||||
String msg = "Error writing " + requestLength + " bytes at offset " + offset + " of total " + src.length + " after " + elapsed + "msec, rc=" + actualLength;
|
||||
if (timeout != 0) {
|
||||
// could be buffer full because: writing to fast, stopped by flow control
|
||||
testConnection(elapsed < timeout, msg);
|
||||
throw new SerialTimeoutException(msg, offset);
|
||||
if (timeout != 0 && MonotonicClock.millis() >= endTime) {
|
||||
SerialTimeoutException ex = new SerialTimeoutException("Error writing " + requestLength + " bytes at offset " + offset + " of total " + src.length + ", rc=" + actualLength);
|
||||
ex.bytesTransferred = offset;
|
||||
throw ex;
|
||||
} else {
|
||||
throw new IOException(msg);
|
||||
|
||||
throw new IOException("Error writing " + requestLength + " bytes at offset " + offset + " of total " + src.length);
|
||||
}
|
||||
}
|
||||
offset += actualLength;
|
||||
@ -297,7 +274,7 @@ public abstract class CommonUsbSerialPort implements UsbSerialPort {
|
||||
|
||||
@Override
|
||||
public boolean isOpen() {
|
||||
return mUsbRequest != null;
|
||||
return mConnection != null;
|
||||
}
|
||||
|
||||
@Override
|
||||
@ -328,29 +305,16 @@ public abstract class CommonUsbSerialPort implements UsbSerialPort {
|
||||
public void setRTS(boolean value) throws IOException { throw new UnsupportedOperationException(); }
|
||||
|
||||
@Override
|
||||
public EnumSet<ControlLine> getControlLines() throws IOException { throw new UnsupportedOperationException(); }
|
||||
public abstract EnumSet<ControlLine> getControlLines() throws IOException;
|
||||
|
||||
@Override
|
||||
public EnumSet<ControlLine> getSupportedControlLines() throws IOException { return EnumSet.noneOf(ControlLine.class); }
|
||||
public abstract EnumSet<ControlLine> getSupportedControlLines() throws IOException;
|
||||
|
||||
@Override
|
||||
public void setFlowControl(FlowControl flowcontrol) throws IOException {
|
||||
if (flowcontrol != FlowControl.NONE)
|
||||
throw new UnsupportedOperationException();
|
||||
public void purgeHwBuffers(boolean purgeWriteBuffers, boolean purgeReadBuffers) throws IOException {
|
||||
throw new UnsupportedOperationException();
|
||||
}
|
||||
|
||||
@Override
|
||||
public FlowControl getFlowControl() { return mFlowControl; }
|
||||
|
||||
@Override
|
||||
public EnumSet<FlowControl> getSupportedFlowControl() { return EnumSet.of(FlowControl.NONE); }
|
||||
|
||||
@Override
|
||||
public boolean getXON() throws IOException { throw new UnsupportedOperationException(); }
|
||||
|
||||
@Override
|
||||
public void purgeHwBuffers(boolean purgeWriteBuffers, boolean purgeReadBuffers) throws IOException { throw new UnsupportedOperationException(); }
|
||||
|
||||
@Override
|
||||
public void setBreak(boolean value) throws IOException { throw new UnsupportedOperationException(); }
|
||||
|
||||
|
||||
@ -60,14 +60,9 @@ public class Cp21xxSerialDriver implements UsbSerialDriver {
|
||||
private static final int SILABSER_SET_LINE_CTL_REQUEST_CODE = 0x03;
|
||||
private static final int SILABSER_SET_BREAK_REQUEST_CODE = 0x05;
|
||||
private static final int SILABSER_SET_MHS_REQUEST_CODE = 0x07;
|
||||
private static final int SILABSER_GET_MDMSTS_REQUEST_CODE = 0x08;
|
||||
private static final int SILABSER_SET_XON_REQUEST_CODE = 0x09;
|
||||
private static final int SILABSER_SET_XOFF_REQUEST_CODE = 0x0A;
|
||||
private static final int SILABSER_GET_COMM_STATUS_REQUEST_CODE = 0x10;
|
||||
private static final int SILABSER_SET_BAUDRATE = 0x1E;
|
||||
private static final int SILABSER_FLUSH_REQUEST_CODE = 0x12;
|
||||
private static final int SILABSER_SET_FLOW_REQUEST_CODE = 0x13;
|
||||
private static final int SILABSER_SET_CHARS_REQUEST_CODE = 0x19;
|
||||
private static final int SILABSER_SET_BAUDRATE_REQUEST_CODE = 0x1E;
|
||||
private static final int SILABSER_GET_MDMSTS_REQUEST_CODE = 0x08;
|
||||
|
||||
private static final int FLUSH_READ_CODE = 0x0a;
|
||||
private static final int FLUSH_WRITE_CODE = 0x05;
|
||||
@ -89,8 +84,6 @@ public class Cp21xxSerialDriver implements UsbSerialDriver {
|
||||
/*
|
||||
* SILABSER_GET_MDMSTS_REQUEST_CODE
|
||||
*/
|
||||
private static final int STATUS_DTR = 0x01;
|
||||
private static final int STATUS_RTS = 0x02;
|
||||
private static final int STATUS_CTS = 0x10;
|
||||
private static final int STATUS_DSR = 0x20;
|
||||
private static final int STATUS_RI = 0x40;
|
||||
@ -125,7 +118,7 @@ public class Cp21xxSerialDriver implements UsbSerialDriver {
|
||||
byte[] buffer = new byte[1];
|
||||
int result = mConnection.controlTransfer(REQTYPE_DEVICE_TO_HOST, SILABSER_GET_MDMSTS_REQUEST_CODE, 0,
|
||||
mPortNumber, buffer, buffer.length, USB_WRITE_TIMEOUT_MILLIS);
|
||||
if (result != buffer.length) {
|
||||
if (result != 1) {
|
||||
throw new IOException("Control transfer failed: " + SILABSER_GET_MDMSTS_REQUEST_CODE + " / " + 0 + " -> " + result);
|
||||
}
|
||||
return buffer[0];
|
||||
@ -154,7 +147,6 @@ public class Cp21xxSerialDriver implements UsbSerialDriver {
|
||||
|
||||
setConfigSingle(SILABSER_IFC_ENABLE_REQUEST_CODE, UART_ENABLE);
|
||||
setConfigSingle(SILABSER_SET_MHS_REQUEST_CODE, (dtr ? DTR_ENABLE : DTR_DISABLE) | (rts ? RTS_ENABLE : RTS_DISABLE));
|
||||
setFlowControl(mFlowControl);
|
||||
}
|
||||
|
||||
@Override
|
||||
@ -174,7 +166,7 @@ public class Cp21xxSerialDriver implements UsbSerialDriver {
|
||||
(byte) ((baudRate >> 16) & 0xff),
|
||||
(byte) ((baudRate >> 24) & 0xff)
|
||||
};
|
||||
int ret = mConnection.controlTransfer(REQTYPE_HOST_TO_DEVICE, SILABSER_SET_BAUDRATE_REQUEST_CODE,
|
||||
int ret = mConnection.controlTransfer(REQTYPE_HOST_TO_DEVICE, SILABSER_SET_BAUDRATE,
|
||||
0, mPortNumber, data, 4, USB_WRITE_TIMEOUT_MILLIS);
|
||||
if (ret < 0) {
|
||||
throw new IOException("Error setting baud rate");
|
||||
@ -297,11 +289,9 @@ public class Cp21xxSerialDriver implements UsbSerialDriver {
|
||||
public EnumSet<ControlLine> getControlLines() throws IOException {
|
||||
byte status = getStatus();
|
||||
EnumSet<ControlLine> set = EnumSet.noneOf(ControlLine.class);
|
||||
//if(rts) set.add(ControlLine.RTS); // configured value
|
||||
if((status & STATUS_RTS) != 0) set.add(ControlLine.RTS); // actual value
|
||||
if(rts) set.add(ControlLine.RTS);
|
||||
if((status & STATUS_CTS) != 0) set.add(ControlLine.CTS);
|
||||
//if(dtr) set.add(ControlLine.DTR); // configured value
|
||||
if((status & STATUS_DTR) != 0) set.add(ControlLine.DTR); // actual value
|
||||
if(dtr) set.add(ControlLine.DTR);
|
||||
if((status & STATUS_DSR) != 0) set.add(ControlLine.DSR);
|
||||
if((status & STATUS_CD) != 0) set.add(ControlLine.CD);
|
||||
if((status & STATUS_RI) != 0) set.add(ControlLine.RI);
|
||||
@ -313,73 +303,6 @@ public class Cp21xxSerialDriver implements UsbSerialDriver {
|
||||
return EnumSet.allOf(ControlLine.class);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean getXON() throws IOException {
|
||||
byte[] buffer = new byte[0x13];
|
||||
int result = mConnection.controlTransfer(REQTYPE_DEVICE_TO_HOST, SILABSER_GET_COMM_STATUS_REQUEST_CODE, 0,
|
||||
mPortNumber, buffer, buffer.length, USB_WRITE_TIMEOUT_MILLIS);
|
||||
if (result != buffer.length) {
|
||||
throw new IOException("Control transfer failed: " + SILABSER_GET_COMM_STATUS_REQUEST_CODE + " -> " + result);
|
||||
}
|
||||
return (buffer[4] & 8) == 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* emulate external XON/OFF
|
||||
* @throws IOException
|
||||
*/
|
||||
public void setXON(boolean value) throws IOException {
|
||||
setConfigSingle(value ? SILABSER_SET_XON_REQUEST_CODE : SILABSER_SET_XOFF_REQUEST_CODE, 0);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setFlowControl(FlowControl flowControl) throws IOException {
|
||||
byte[] data = new byte[16];
|
||||
if(flowControl == FlowControl.RTS_CTS) {
|
||||
data[4] |= 0b1000_0000; // RTS
|
||||
data[0] |= 0b0000_1000; // CTS
|
||||
} else {
|
||||
if(rts)
|
||||
data[4] |= 0b0100_0000;
|
||||
}
|
||||
if(flowControl == FlowControl.DTR_DSR) {
|
||||
data[0] |= 0b0000_0010; // DTR
|
||||
data[0] |= 0b0001_0000; // DSR
|
||||
} else {
|
||||
if(dtr)
|
||||
data[0] |= 0b0000_0001;
|
||||
}
|
||||
if(flowControl == FlowControl.XON_XOFF) {
|
||||
byte[] chars = new byte[]{0, 0, 0, 0, CHAR_XON, CHAR_XOFF};
|
||||
int ret = mConnection.controlTransfer(REQTYPE_HOST_TO_DEVICE, SILABSER_SET_CHARS_REQUEST_CODE,
|
||||
0, mPortNumber, chars, chars.length, USB_WRITE_TIMEOUT_MILLIS);
|
||||
if (ret != chars.length) {
|
||||
throw new IOException("Error setting XON/XOFF chars");
|
||||
}
|
||||
data[4] |= 0b0000_0011;
|
||||
data[7] |= 0b1000_0000;
|
||||
data[8] = (byte)128;
|
||||
data[12] = (byte)128;
|
||||
}
|
||||
if(flowControl == FlowControl.XON_XOFF_INLINE) {
|
||||
throw new UnsupportedOperationException();
|
||||
}
|
||||
int ret = mConnection.controlTransfer(REQTYPE_HOST_TO_DEVICE, SILABSER_SET_FLOW_REQUEST_CODE,
|
||||
0, mPortNumber, data, data.length, USB_WRITE_TIMEOUT_MILLIS);
|
||||
if (ret != data.length) {
|
||||
throw new IOException("Error setting flow control");
|
||||
}
|
||||
if(flowControl == FlowControl.XON_XOFF) {
|
||||
setXON(true);
|
||||
}
|
||||
mFlowControl = flowControl;
|
||||
}
|
||||
|
||||
@Override
|
||||
public EnumSet<FlowControl> getSupportedFlowControl() {
|
||||
return EnumSet.of(FlowControl.NONE, FlowControl.RTS_CTS, FlowControl.DTR_DSR, FlowControl.XON_XOFF);
|
||||
}
|
||||
|
||||
@Override
|
||||
// note: only working on some devices, on other devices ignored w/o error
|
||||
public void purgeHwBuffers(boolean purgeWriteBuffers, boolean purgeReadBuffers) throws IOException {
|
||||
|
||||
@ -64,7 +64,6 @@ public class FtdiSerialDriver implements UsbSerialDriver {
|
||||
|
||||
private static final int RESET_REQUEST = 0;
|
||||
private static final int MODEM_CONTROL_REQUEST = 1;
|
||||
private static final int SET_FLOW_CONTROL_REQUEST = 2;
|
||||
private static final int SET_BAUD_RATE_REQUEST = 3;
|
||||
private static final int SET_DATA_REQUEST = 4;
|
||||
private static final int GET_MODEM_STATUS_REQUEST = 5;
|
||||
@ -121,7 +120,6 @@ public class FtdiSerialDriver implements UsbSerialDriver {
|
||||
if (result != 0) {
|
||||
throw new IOException("Init RTS,DTR failed: result=" + result);
|
||||
}
|
||||
setFlowControl(mFlowControl);
|
||||
|
||||
// mDevice.getVersion() would require API 23
|
||||
byte[] rawDescriptors = mConnection.getRawDescriptors();
|
||||
@ -141,37 +139,24 @@ public class FtdiSerialDriver implements UsbSerialDriver {
|
||||
}
|
||||
|
||||
@Override
|
||||
public int read(final byte[] dest, final int timeout) throws IOException
|
||||
{
|
||||
public int read(final byte[] dest, final int timeout) throws IOException {
|
||||
if(dest.length <= READ_HEADER_LENGTH) {
|
||||
throw new IllegalArgumentException("Read buffer too small");
|
||||
throw new IllegalArgumentException("Read buffer to small");
|
||||
// could allocate larger buffer, including space for 2 header bytes, but this would
|
||||
// result in buffers not being 64 byte aligned any more, causing data loss at continuous
|
||||
// data transfer at high baud rates when buffers are fully filled.
|
||||
}
|
||||
return read(dest, dest.length, timeout);
|
||||
}
|
||||
|
||||
@Override
|
||||
public int read(final byte[] dest, int length, final int timeout) throws IOException {
|
||||
if(length <= READ_HEADER_LENGTH) {
|
||||
throw new IllegalArgumentException("Read length too small");
|
||||
// could allocate larger buffer, including space for 2 header bytes, but this would
|
||||
// result in buffers not being 64 byte aligned any more, causing data loss at continuous
|
||||
// data transfer at high baud rates when buffers are fully filled.
|
||||
}
|
||||
length = Math.min(length, dest.length);
|
||||
int nread;
|
||||
if (timeout != 0) {
|
||||
long endTime = MonotonicClock.millis() + timeout;
|
||||
do {
|
||||
nread = super.read(dest, length, Math.max(1, (int)(endTime - MonotonicClock.millis())), false);
|
||||
nread = super.read(dest, Math.max(1, (int)(endTime - MonotonicClock.millis())), false);
|
||||
} while (nread == READ_HEADER_LENGTH && MonotonicClock.millis() < endTime);
|
||||
if(nread <= 0)
|
||||
testConnection(MonotonicClock.millis() < endTime);
|
||||
if(nread <= 0 && MonotonicClock.millis() < endTime)
|
||||
testConnection();
|
||||
} else {
|
||||
do {
|
||||
nread = super.read(dest, length, timeout);
|
||||
nread = super.read(dest, timeout);
|
||||
} while (nread == READ_HEADER_LENGTH);
|
||||
}
|
||||
return readFilter(dest, nread);
|
||||
@ -305,7 +290,7 @@ public class FtdiSerialDriver implements UsbSerialDriver {
|
||||
byte[] data = new byte[2];
|
||||
int result = mConnection.controlTransfer(REQTYPE_DEVICE_TO_HOST, GET_MODEM_STATUS_REQUEST,
|
||||
0, mPortNumber+1, data, data.length, USB_WRITE_TIMEOUT_MILLIS);
|
||||
if (result != data.length) {
|
||||
if (result != 2) {
|
||||
throw new IOException("Get modem status failed: result=" + result);
|
||||
}
|
||||
return data[0];
|
||||
@ -379,38 +364,6 @@ public class FtdiSerialDriver implements UsbSerialDriver {
|
||||
return EnumSet.allOf(ControlLine.class);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setFlowControl(FlowControl flowControl) throws IOException {
|
||||
int value = 0;
|
||||
int index = mPortNumber+1;
|
||||
switch (flowControl) {
|
||||
case NONE:
|
||||
break;
|
||||
case RTS_CTS:
|
||||
index |= 0x100;
|
||||
break;
|
||||
case DTR_DSR:
|
||||
index |= 0x200;
|
||||
break;
|
||||
case XON_XOFF_INLINE:
|
||||
value = CHAR_XON + (CHAR_XOFF << 8);
|
||||
index |= 0x400;
|
||||
break;
|
||||
default:
|
||||
throw new UnsupportedOperationException();
|
||||
}
|
||||
int result = mConnection.controlTransfer(REQTYPE_HOST_TO_DEVICE, SET_FLOW_CONTROL_REQUEST,
|
||||
value, index, null, 0, USB_WRITE_TIMEOUT_MILLIS);
|
||||
if (result != 0)
|
||||
throw new IOException("Set flow control failed: result=" + result);
|
||||
mFlowControl = flowControl;
|
||||
}
|
||||
|
||||
@Override
|
||||
public EnumSet<FlowControl> getSupportedFlowControl() {
|
||||
return EnumSet.of(FlowControl.NONE, FlowControl.RTS_CTS, FlowControl.DTR_DSR, FlowControl.XON_XOFF_INLINE);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void purgeHwBuffers(boolean purgeWriteBuffers, boolean purgeReadBuffers) throws IOException {
|
||||
if (purgeWriteBuffers) {
|
||||
@ -453,7 +406,7 @@ public class FtdiSerialDriver implements UsbSerialDriver {
|
||||
byte[] data = new byte[1];
|
||||
int result = mConnection.controlTransfer(REQTYPE_DEVICE_TO_HOST, GET_LATENCY_TIMER_REQUEST,
|
||||
0, mPortNumber+1, data, data.length, USB_WRITE_TIMEOUT_MILLIS);
|
||||
if (result != data.length) {
|
||||
if (result != 1) {
|
||||
throw new IOException("Get latency timer failed: result=" + result);
|
||||
}
|
||||
return data[0];
|
||||
|
||||
@ -89,6 +89,15 @@ public class GsmModemSerialDriver implements UsbSerialDriver{
|
||||
throw new UnsupportedOperationException();
|
||||
}
|
||||
|
||||
@Override
|
||||
public EnumSet<ControlLine> getControlLines() throws IOException {
|
||||
throw new UnsupportedOperationException();
|
||||
}
|
||||
|
||||
@Override
|
||||
public EnumSet<ControlLine> getSupportedControlLines() throws IOException {
|
||||
throw new UnsupportedOperationException();
|
||||
}
|
||||
}
|
||||
|
||||
public static Map<Integer, int[]> getSupportedDevices() {
|
||||
|
||||
@ -122,7 +122,7 @@ public class ProlificSerialDriver implements UsbSerialDriver {
|
||||
private volatile Thread mReadStatusThread = null;
|
||||
private final Object mReadStatusThreadLock = new Object();
|
||||
private boolean mStopReadStatusThread = false;
|
||||
private Exception mReadStatusException = null;
|
||||
private IOException mReadStatusException = null;
|
||||
|
||||
|
||||
public ProlificSerialPort(UsbDevice device, int portNumber) {
|
||||
@ -201,12 +201,12 @@ public class ProlificSerialDriver implements UsbSerialDriver {
|
||||
|
||||
private void readStatusThreadFunction() {
|
||||
try {
|
||||
byte[] buffer = new byte[STATUS_BUFFER_SIZE];
|
||||
while (!mStopReadStatusThread) {
|
||||
byte[] buffer = new byte[STATUS_BUFFER_SIZE];
|
||||
long endTime = MonotonicClock.millis() + 500;
|
||||
int readBytesCount = mConnection.bulkTransfer(mInterruptEndpoint, buffer, STATUS_BUFFER_SIZE, 500);
|
||||
if(readBytesCount == -1)
|
||||
testConnection(MonotonicClock.millis() < endTime);
|
||||
if(readBytesCount == -1 && MonotonicClock.millis() < endTime)
|
||||
testConnection();
|
||||
if (readBytesCount > 0) {
|
||||
if (readBytesCount != STATUS_BUFFER_SIZE) {
|
||||
throw new IOException("Invalid status notification, expected " + STATUS_BUFFER_SIZE + " bytes, got " + readBytesCount);
|
||||
@ -217,9 +217,8 @@ public class ProlificSerialDriver implements UsbSerialDriver {
|
||||
}
|
||||
}
|
||||
}
|
||||
} catch (Exception e) {
|
||||
if (isOpen())
|
||||
mReadStatusException = e;
|
||||
} catch (IOException e) {
|
||||
mReadStatusException = e;
|
||||
}
|
||||
//Log.d(TAG, "end control line status thread " + mStopReadStatusThread + " " + (mReadStatusException == null ? "-" : mReadStatusException.getMessage()));
|
||||
}
|
||||
@ -250,8 +249,8 @@ public class ProlificSerialDriver implements UsbSerialDriver {
|
||||
}
|
||||
}
|
||||
|
||||
/* throw and clear an exception which occurred in the status read thread */
|
||||
Exception readStatusException = mReadStatusException;
|
||||
/* throw and clear an exception which occured in the status read thread */
|
||||
IOException readStatusException = mReadStatusException;
|
||||
if (mReadStatusException != null) {
|
||||
mReadStatusException = null;
|
||||
throw new IOException(readStatusException);
|
||||
@ -315,7 +314,6 @@ public class ProlificSerialDriver implements UsbSerialDriver {
|
||||
resetDevice();
|
||||
doBlackMagic();
|
||||
setControlLines(mControlLinesValue);
|
||||
setFlowControl(mFlowControl);
|
||||
}
|
||||
|
||||
@Override
|
||||
@ -527,6 +525,7 @@ public class ProlificSerialDriver implements UsbSerialDriver {
|
||||
setControlLines(newControlLinesValue);
|
||||
}
|
||||
|
||||
|
||||
@Override
|
||||
public EnumSet<ControlLine> getControlLines() throws IOException {
|
||||
int status = getStatus();
|
||||
@ -545,39 +544,6 @@ public class ProlificSerialDriver implements UsbSerialDriver {
|
||||
return EnumSet.allOf(ControlLine.class);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setFlowControl(FlowControl flowControl) throws IOException {
|
||||
// vendorOut values from https://www.mail-archive.com/linux-usb@vger.kernel.org/msg110968.html
|
||||
switch (flowControl) {
|
||||
case NONE:
|
||||
if (mDeviceType == DeviceType.DEVICE_TYPE_HXN)
|
||||
vendorOut(0x0a, 0xff, null);
|
||||
else
|
||||
vendorOut(0, 0, null);
|
||||
break;
|
||||
case RTS_CTS:
|
||||
if (mDeviceType == DeviceType.DEVICE_TYPE_HXN)
|
||||
vendorOut(0x0a, 0xfa, null);
|
||||
else
|
||||
vendorOut(0, 0x61, null);
|
||||
break;
|
||||
case XON_XOFF_INLINE:
|
||||
if (mDeviceType == DeviceType.DEVICE_TYPE_HXN)
|
||||
vendorOut(0x0a, 0xee, null);
|
||||
else
|
||||
vendorOut(0, 0xc1, null);
|
||||
break;
|
||||
default:
|
||||
throw new UnsupportedOperationException();
|
||||
}
|
||||
mFlowControl = flowControl;
|
||||
}
|
||||
|
||||
@Override
|
||||
public EnumSet<FlowControl> getSupportedFlowControl() {
|
||||
return EnumSet.of(FlowControl.NONE, FlowControl.RTS_CTS, FlowControl.XON_XOFF_INLINE);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void purgeHwBuffers(boolean purgeWriteBuffers, boolean purgeReadBuffers) throws IOException {
|
||||
if (mDeviceType == DeviceType.DEVICE_TYPE_HXN) {
|
||||
|
||||
@ -9,8 +9,7 @@ import java.io.InterruptedIOException;
|
||||
* {@see InterruptedIOException#bytesTransferred} may contain bytes transferred
|
||||
*/
|
||||
public class SerialTimeoutException extends InterruptedIOException {
|
||||
public SerialTimeoutException(String s, int bytesTransferred) {
|
||||
public SerialTimeoutException(String s) {
|
||||
super(s);
|
||||
this.bytesTransferred = bytesTransferred;
|
||||
}
|
||||
}
|
||||
|
||||
@ -37,9 +37,6 @@ public final class UsbId {
|
||||
public static final int PROLIFIC_PL2303GE = 0x23e3; // "
|
||||
public static final int PROLIFIC_PL2303GS = 0x23f3; // "
|
||||
|
||||
public static final int VENDOR_GOOGLE = 0x18d1;
|
||||
public static final int GOOGLE_CR50 = 0x5014;
|
||||
|
||||
public static final int VENDOR_QINHENG = 0x1a86;
|
||||
public static final int QINHENG_CH340 = 0x7523;
|
||||
public static final int QINHENG_CH341A = 0x5523;
|
||||
|
||||
@ -58,16 +58,7 @@ public interface UsbSerialPort extends Closeable {
|
||||
int STOPBITS_2 = 2;
|
||||
|
||||
/** Values for get[Supported]ControlLines() */
|
||||
enum ControlLine { RTS, CTS, DTR, DSR, CD, RI }
|
||||
|
||||
/** Values for (set|get|getSupported)FlowControl() */
|
||||
enum FlowControl { NONE, RTS_CTS, DTR_DSR, XON_XOFF, XON_XOFF_INLINE }
|
||||
|
||||
/** XON character used with flow control XON/XOFF */
|
||||
char CHAR_XON = 17;
|
||||
/** XOFF character used with flow control XON/XOFF */
|
||||
char CHAR_XOFF = 19;
|
||||
|
||||
enum ControlLine { RTS, CTS, DTR, DSR, CD, RI }
|
||||
|
||||
/**
|
||||
* Returns the driver used by this port.
|
||||
@ -131,17 +122,6 @@ public interface UsbSerialPort extends Closeable {
|
||||
*/
|
||||
int read(final byte[] dest, final int timeout) throws IOException;
|
||||
|
||||
/**
|
||||
* Reads bytes with specified length into the destination buffer.
|
||||
*
|
||||
* @param dest the destination byte buffer
|
||||
* @param length the maximum length of the data to read
|
||||
* @param timeout the timeout for reading in milliseconds, 0 is infinite
|
||||
* @return the actual number of bytes read
|
||||
* @throws IOException if an error occurred during reading
|
||||
*/
|
||||
int read(final byte[] dest, int length, final int timeout) throws IOException;
|
||||
|
||||
/**
|
||||
* Writes as many bytes as possible from the source buffer.
|
||||
*
|
||||
@ -153,18 +133,6 @@ public interface UsbSerialPort extends Closeable {
|
||||
*/
|
||||
void write(final byte[] src, final int timeout) throws IOException;
|
||||
|
||||
/**
|
||||
* Writes bytes with specified length from the source buffer.
|
||||
*
|
||||
* @param src the source byte buffer
|
||||
* @param length the length of the data to write
|
||||
* @param timeout the timeout for writing in milliseconds, 0 is infinite
|
||||
* @throws SerialTimeoutException if timeout reached before sending all data.
|
||||
* ex.bytesTransferred may contain bytes transferred
|
||||
* @throws IOException if an error occurred during writing
|
||||
*/
|
||||
void write(final byte[] src, int length, final int timeout) throws IOException;
|
||||
|
||||
/**
|
||||
* Sets various serial port parameters.
|
||||
*
|
||||
@ -175,7 +143,7 @@ public interface UsbSerialPort extends Closeable {
|
||||
* @param parity one of {@link #PARITY_NONE}, {@link #PARITY_ODD},
|
||||
* {@link #PARITY_EVEN}, {@link #PARITY_MARK}, or {@link #PARITY_SPACE}.
|
||||
* @throws IOException on error setting the port parameters
|
||||
* @throws UnsupportedOperationException if not supported or values are not supported by a specific device
|
||||
* @throws UnsupportedOperationException if values are not supported by a specific device
|
||||
*/
|
||||
void setParameters(int baudRate, int dataBits, int stopBits, @Parity int parity) throws IOException;
|
||||
|
||||
@ -257,7 +225,6 @@ public interface UsbSerialPort extends Closeable {
|
||||
*
|
||||
* @return EnumSet.contains(...) is {@code true} if set, else {@code false}
|
||||
* @throws IOException if an error occurred during reading
|
||||
* @throws UnsupportedOperationException if not supported
|
||||
*/
|
||||
EnumSet<ControlLine> getControlLines() throws IOException;
|
||||
|
||||
@ -269,36 +236,6 @@ public interface UsbSerialPort extends Closeable {
|
||||
*/
|
||||
EnumSet<ControlLine> getSupportedControlLines() throws IOException;
|
||||
|
||||
/**
|
||||
* Set flow control mode, if supported
|
||||
* @param flowControl @FlowControl
|
||||
* @throws IOException if an error occurred during writing
|
||||
* @throws UnsupportedOperationException if not supported
|
||||
*/
|
||||
void setFlowControl(FlowControl flowControl) throws IOException;
|
||||
|
||||
/**
|
||||
* Get flow control mode.
|
||||
* @return FlowControl
|
||||
*/
|
||||
FlowControl getFlowControl();
|
||||
|
||||
/**
|
||||
* Get supported flow control modes
|
||||
* @return EnumSet.contains(...) is {@code true} if supported, else {@code false}
|
||||
*/
|
||||
EnumSet<FlowControl> getSupportedFlowControl();
|
||||
|
||||
/**
|
||||
* If flow control = XON_XOFF, indicates that send is enabled by XON.
|
||||
* Devices supporting flow control = XON_XOFF_INLINE return CHAR_XON/CHAR_XOFF in read() data.
|
||||
*
|
||||
* @return the current state
|
||||
* @throws IOException if an error occurred during reading
|
||||
* @throws UnsupportedOperationException if not supported
|
||||
*/
|
||||
boolean getXON() throws IOException;
|
||||
|
||||
/**
|
||||
* Purge non-transmitted output data and / or non-read input data.
|
||||
*
|
||||
|
||||
@ -38,7 +38,6 @@ public class UsbSerialProber {
|
||||
probeTable.addDriver(ProlificSerialDriver.class);
|
||||
probeTable.addDriver(Ch34xSerialDriver.class);
|
||||
probeTable.addDriver(GsmModemSerialDriver.class);
|
||||
probeTable.addDriver(ChromeCcdSerialDriver.class);
|
||||
return probeTable;
|
||||
}
|
||||
|
||||
|
||||
@ -27,9 +27,6 @@ public class HexDump {
|
||||
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'
|
||||
};
|
||||
|
||||
private HexDump() {
|
||||
}
|
||||
|
||||
public static String dumpHexString(byte[] array) {
|
||||
return dumpHexString(array, 0, array.length);
|
||||
}
|
||||
|
||||
@ -13,19 +13,16 @@ import com.hoho.android.usbserial.driver.UsbSerialPort;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.nio.ByteBuffer;
|
||||
import java.util.concurrent.CountDownLatch;
|
||||
import java.util.concurrent.atomic.AtomicReference;
|
||||
|
||||
/**
|
||||
* Utility class which services a {@link UsbSerialPort} in its {@link #runWrite()} ()} and {@link #runRead()} ()} ()} methods.
|
||||
* Utility class which services a {@link UsbSerialPort} in its {@link #run()} method.
|
||||
*
|
||||
* @author mike wakerly (opensource@hoho.com)
|
||||
*/
|
||||
public class SerialInputOutputManager {
|
||||
public class SerialInputOutputManager implements Runnable {
|
||||
|
||||
public enum State {
|
||||
STOPPED,
|
||||
STARTING,
|
||||
RUNNING,
|
||||
STOPPING
|
||||
}
|
||||
@ -35,6 +32,9 @@ public class SerialInputOutputManager {
|
||||
private static final String TAG = SerialInputOutputManager.class.getSimpleName();
|
||||
private static final int BUFSIZ = 4096;
|
||||
|
||||
/**
|
||||
* default read timeout is infinite, to avoid data loss with bulkTransfer API
|
||||
*/
|
||||
private int mReadTimeout = 0;
|
||||
private int mWriteTimeout = 0;
|
||||
|
||||
@ -45,8 +45,7 @@ public class SerialInputOutputManager {
|
||||
private ByteBuffer mWriteBuffer = ByteBuffer.allocate(BUFSIZ);
|
||||
|
||||
private int mThreadPriority = Process.THREAD_PRIORITY_URGENT_AUDIO;
|
||||
private final AtomicReference<State> mState = new AtomicReference<>(State.STOPPED);
|
||||
private CountDownLatch mStartuplatch = new CountDownLatch(2);
|
||||
private State mState = State.STOPPED; // Synchronized by 'this'
|
||||
private Listener mListener; // Synchronized by 'this'
|
||||
private final UsbSerialPort mSerialPort;
|
||||
|
||||
@ -57,7 +56,7 @@ public class SerialInputOutputManager {
|
||||
void onNewData(byte[] data);
|
||||
|
||||
/**
|
||||
* Called when {@link SerialInputOutputManager#runRead()} ()} or {@link SerialInputOutputManager#runWrite()} ()} ()} aborts due to an error.
|
||||
* Called when {@link SerialInputOutputManager#run()} aborts due to an error.
|
||||
*/
|
||||
void onRunError(Exception e);
|
||||
}
|
||||
@ -87,9 +86,8 @@ public class SerialInputOutputManager {
|
||||
* @param threadPriority see {@link Process#setThreadPriority(int)}
|
||||
* */
|
||||
public void setThreadPriority(int threadPriority) {
|
||||
if (!mState.compareAndSet(State.STOPPED, State.STOPPED)) {
|
||||
if (mState != State.STOPPED)
|
||||
throw new IllegalStateException("threadPriority only configurable before SerialInputOutputManager is started");
|
||||
}
|
||||
mThreadPriority = threadPriority;
|
||||
}
|
||||
|
||||
@ -98,7 +96,7 @@ public class SerialInputOutputManager {
|
||||
*/
|
||||
public void setReadTimeout(int timeout) {
|
||||
// when set if already running, read already blocks and the new value will not become effective now
|
||||
if(mReadTimeout == 0 && timeout != 0 && mState.get() != State.STOPPED)
|
||||
if(mReadTimeout == 0 && timeout != 0 && mState != State.STOPPED)
|
||||
throw new IllegalStateException("readTimeout only configurable before SerialInputOutputManager is started");
|
||||
mReadTimeout = timeout;
|
||||
}
|
||||
@ -146,152 +144,79 @@ public class SerialInputOutputManager {
|
||||
}
|
||||
|
||||
/**
|
||||
* write data asynchronously
|
||||
* when using writeAsync, it is recommended to use readTimeout != 0,
|
||||
* else the write will be delayed until read data is available
|
||||
*/
|
||||
public void writeAsync(byte[] data) {
|
||||
synchronized (mWriteBufferLock) {
|
||||
mWriteBuffer.put(data);
|
||||
mWriteBufferLock.notifyAll(); // Notify waiting threads
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* start SerialInputOutputManager in separate threads
|
||||
* start SerialInputOutputManager in separate thread
|
||||
*/
|
||||
public void start() {
|
||||
if(mState.compareAndSet(State.STOPPED, State.STARTING)) {
|
||||
mStartuplatch = new CountDownLatch(2);
|
||||
new Thread(this::runRead, this.getClass().getSimpleName() + "_read").start();
|
||||
new Thread(this::runWrite, this.getClass().getSimpleName() + "_write").start();
|
||||
try {
|
||||
mStartuplatch.await();
|
||||
mState.set(State.RUNNING);
|
||||
} catch (InterruptedException e) {
|
||||
Thread.currentThread().interrupt();
|
||||
}
|
||||
} else {
|
||||
if(mState != State.STOPPED)
|
||||
throw new IllegalStateException("already started");
|
||||
}
|
||||
new Thread(this, this.getClass().getSimpleName()).start();
|
||||
}
|
||||
|
||||
/**
|
||||
* stop SerialInputOutputManager threads
|
||||
* stop SerialInputOutputManager thread
|
||||
*
|
||||
* when using readTimeout == 0 (default), additionally use usbSerialPort.close() to
|
||||
* interrupt blocking read
|
||||
*/
|
||||
public void stop() {
|
||||
if(mState.compareAndSet(State.RUNNING, State.STOPPING)) {
|
||||
synchronized (mWriteBufferLock) {
|
||||
mWriteBufferLock.notifyAll(); // wake up write thread to check the stop condition
|
||||
}
|
||||
public synchronized void stop() {
|
||||
if (getState() == State.RUNNING) {
|
||||
Log.i(TAG, "Stop requested");
|
||||
mState = State.STOPPING;
|
||||
}
|
||||
}
|
||||
|
||||
public State getState() {
|
||||
return mState.get();
|
||||
public synchronized State getState() {
|
||||
return mState;
|
||||
}
|
||||
|
||||
/**
|
||||
* @return true if the thread is still running
|
||||
* Continuously services the read and write buffers until {@link #stop()} is
|
||||
* called, or until a driver exception is raised.
|
||||
*/
|
||||
private boolean isStillRunning() {
|
||||
State state = mState.get();
|
||||
return ((state == State.RUNNING) || (state == State.STARTING))
|
||||
&& !Thread.currentThread().isInterrupted();
|
||||
}
|
||||
|
||||
/**
|
||||
* Notify listener of an error
|
||||
*
|
||||
* @param e the exception
|
||||
*/
|
||||
private void notifyErrorListener(Throwable e) {
|
||||
Listener listener = getListener();
|
||||
if (listener != null) {
|
||||
try {
|
||||
listener.onRunError(e instanceof Exception ? (Exception) e : new Exception(e));
|
||||
} catch (Throwable t) {
|
||||
Log.w(TAG, "Exception in onRunError: " + t.getMessage(), t);
|
||||
@Override
|
||||
public void run() {
|
||||
synchronized (this) {
|
||||
if (getState() != State.STOPPED) {
|
||||
throw new IllegalStateException("Already running");
|
||||
}
|
||||
mState = State.RUNNING;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the thread priority
|
||||
*/
|
||||
private void setThreadPriority() {
|
||||
if (mThreadPriority != Process.THREAD_PRIORITY_DEFAULT) {
|
||||
Process.setThreadPriority(mThreadPriority);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Continuously services the read buffers until {@link #stop()} is called, or until a driver exception is
|
||||
* raised.
|
||||
*/
|
||||
void runRead() {
|
||||
Log.i(TAG, "runRead running ...");
|
||||
Log.i(TAG, "Running ...");
|
||||
try {
|
||||
setThreadPriority();
|
||||
mStartuplatch.countDown();
|
||||
do {
|
||||
stepRead();
|
||||
} while (isStillRunning());
|
||||
Log.i(TAG, "runRead: Stopping mState=" + getState());
|
||||
} catch (Throwable e) {
|
||||
if (Thread.currentThread().isInterrupted()) {
|
||||
Log.w(TAG, "runRead: interrupted");
|
||||
} else if(mSerialPort.isOpen()) {
|
||||
Log.w(TAG, "runRead ending due to exception: " + e.getMessage(), e);
|
||||
} else {
|
||||
Log.i(TAG, "runRead: Socket closed");
|
||||
}
|
||||
notifyErrorListener(e);
|
||||
} finally {
|
||||
if (mState.compareAndSet(State.RUNNING, State.STOPPING)) {
|
||||
synchronized (mWriteBufferLock) {
|
||||
mWriteBufferLock.notifyAll(); // wake up write thread to check the stop condition
|
||||
if(mThreadPriority != Process.THREAD_PRIORITY_DEFAULT)
|
||||
Process.setThreadPriority(mThreadPriority);
|
||||
while (true) {
|
||||
if (getState() != State.RUNNING) {
|
||||
Log.i(TAG, "Stopping mState=" + getState());
|
||||
break;
|
||||
}
|
||||
} else if (mState.compareAndSet(State.STOPPING, State.STOPPED)) {
|
||||
Log.i(TAG, "runRead: Stopped mState=" + getState());
|
||||
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");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Continuously services the write buffers until {@link #stop()} is called, or until a driver exception is
|
||||
* raised.
|
||||
*/
|
||||
void runWrite() {
|
||||
Log.i(TAG, "runWrite running ...");
|
||||
try {
|
||||
setThreadPriority();
|
||||
mStartuplatch.countDown();
|
||||
do {
|
||||
stepWrite();
|
||||
} while (isStillRunning());
|
||||
Log.i(TAG, "runWrite: Stopping mState=" + getState());
|
||||
} catch (Throwable e) {
|
||||
if (Thread.currentThread().isInterrupted()) {
|
||||
Log.w(TAG, "runWrite: interrupted");
|
||||
} else if(mSerialPort.isOpen()) {
|
||||
Log.w(TAG, "runWrite ending due to exception: " + e.getMessage(), e);
|
||||
} else {
|
||||
Log.i(TAG, "runWrite: Socket closed");
|
||||
}
|
||||
notifyErrorListener(e);
|
||||
} finally {
|
||||
if (!mState.compareAndSet(State.RUNNING, State.STOPPING)) {
|
||||
if (mState.compareAndSet(State.STOPPING, State.STOPPED)) {
|
||||
Log.i(TAG, "runWrite: Stopped mState=" + getState());
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private void stepRead() throws IOException {
|
||||
private void step() throws IOException {
|
||||
// Handle incoming data.
|
||||
byte[] buffer;
|
||||
synchronized (mReadBufferLock) {
|
||||
@ -309,26 +234,21 @@ public class SerialInputOutputManager {
|
||||
listener.onNewData(data);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private void stepWrite() throws IOException, InterruptedException {
|
||||
// Handle outgoing data.
|
||||
byte[] buffer = null;
|
||||
buffer = null;
|
||||
synchronized (mWriteBufferLock) {
|
||||
int len = mWriteBuffer.position();
|
||||
len = mWriteBuffer.position();
|
||||
if (len > 0) {
|
||||
buffer = new byte[len];
|
||||
mWriteBuffer.rewind();
|
||||
mWriteBuffer.get(buffer, 0, len);
|
||||
mWriteBuffer.clear();
|
||||
mWriteBufferLock.notifyAll(); // Notify writeAsync that there is space in the buffer
|
||||
} else {
|
||||
mWriteBufferLock.wait();
|
||||
}
|
||||
}
|
||||
if (buffer != null) {
|
||||
if (DEBUG) {
|
||||
Log.d(TAG, "Writing data len=" + buffer.length);
|
||||
Log.d(TAG, "Writing data len=" + len);
|
||||
}
|
||||
mSerialPort.write(buffer, mWriteTimeout);
|
||||
}
|
||||
|
||||
@ -6,9 +6,6 @@ import java.util.ArrayList;
|
||||
|
||||
public class UsbUtils {
|
||||
|
||||
private UsbUtils() {
|
||||
}
|
||||
|
||||
public static ArrayList<byte[]> getDescriptors(UsbDeviceConnection connection) {
|
||||
ArrayList<byte[]> descriptors = new ArrayList<>();
|
||||
byte[] rawDescriptors = connection.getRawDescriptors();
|
||||
|
||||
@ -1,47 +0,0 @@
|
||||
package com.hoho.android.usbserial.util;
|
||||
|
||||
import com.hoho.android.usbserial.driver.UsbSerialPort;
|
||||
|
||||
import java.io.IOException;
|
||||
|
||||
/**
|
||||
* Some devices return XON and XOFF characters inline in read() data.
|
||||
* Other devices return XON / XOFF condition thru getXOFF() method.
|
||||
*/
|
||||
|
||||
public class XonXoffFilter {
|
||||
private boolean xon = true;
|
||||
|
||||
public XonXoffFilter() {
|
||||
}
|
||||
|
||||
public boolean getXON() {
|
||||
return xon;
|
||||
}
|
||||
|
||||
/**
|
||||
* Filter XON/XOFF from read() data and remember
|
||||
*
|
||||
* @param data unfiltered data
|
||||
* @return filtered data
|
||||
*/
|
||||
public byte[] filter(byte[] data) {
|
||||
int found = 0;
|
||||
for (int i=0; i<data.length; i++) {
|
||||
if (data[i] == UsbSerialPort.CHAR_XON || data[i] == UsbSerialPort.CHAR_XOFF)
|
||||
found++;
|
||||
}
|
||||
if(found == 0)
|
||||
return data;
|
||||
byte[] filtered = new byte[data.length - found];
|
||||
for (int i=0, j=0; i<data.length; i++) {
|
||||
if (data[i] == UsbSerialPort.CHAR_XON)
|
||||
xon = true;
|
||||
else if(data[i] == UsbSerialPort.CHAR_XOFF)
|
||||
xon = false;
|
||||
else
|
||||
filtered[j++] = data[i];
|
||||
}
|
||||
return filtered;
|
||||
}
|
||||
}
|
||||
@ -17,11 +17,6 @@ public class Log {
|
||||
return 0;
|
||||
}
|
||||
|
||||
public static int w(String tag, String msg, Throwable tr) {
|
||||
System.out.println("WARN: " + tag + ": " + msg + " / " + tr.getMessage());
|
||||
return 0;
|
||||
}
|
||||
|
||||
public static int e(String tag, String msg) {
|
||||
System.out.println("ERROR: " + tag + ": " + msg);
|
||||
return 0;
|
||||
|
||||
@ -1,44 +0,0 @@
|
||||
package com.hoho.android.usbserial.util;
|
||||
|
||||
import static org.hamcrest.CoreMatchers.equalTo;
|
||||
import static org.hamcrest.MatcherAssert.assertThat;
|
||||
import static org.junit.Assert.assertEquals;
|
||||
import static org.junit.Assert.assertThrows;
|
||||
|
||||
import org.junit.Test;
|
||||
|
||||
import java.security.InvalidParameterException;
|
||||
|
||||
public class HexDumpText {
|
||||
|
||||
@Test
|
||||
public void toByteArray() throws Exception {
|
||||
assertThat(HexDump.toByteArray((byte)0x4a), equalTo(new byte[]{ 0x4A}));
|
||||
assertThat(HexDump.toByteArray((short)0x4a5b), equalTo(new byte[]{ 0x4A, 0x5B}));
|
||||
assertThat(HexDump.toByteArray((int)0x4a5b6c7d), equalTo(new byte[]{ 0x4A, 0x5B, 0x6C, 0x7D}));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void toHexString() throws Exception {
|
||||
assertEquals("4A", HexDump.toHexString((byte)0x4a));
|
||||
assertEquals("4A 5B", HexDump.toHexString((short)0x4a5b));
|
||||
assertEquals("4A 5B 6C 7D", HexDump.toHexString((int)0x4a5b6c7d));
|
||||
assertEquals("4A 5B 6C 7D", HexDump.toHexString(new byte[]{ 0x4A, 0x5B, 0x6C, 0x7D}));
|
||||
assertEquals("5B 6C", HexDump.toHexString(new byte[]{ 0x4A, 0x5B, 0x6C, 0x7D}, 1, 2));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void dumpHexString() throws Exception {
|
||||
assertEquals("10 31 32 33 34 35 36 37 .1234567\n18 39 .9", HexDump.dumpHexString(new byte[]{ 0x10, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x18, 0x39}));
|
||||
assertEquals("31 32 12", HexDump.dumpHexString(new byte[]{ 0x30, 0x31, 0x32, 0x33}, 1, 2));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void toByte() throws Exception {
|
||||
assertThat(HexDump.hexStringToByteArray("4a 5B-6c\n7d"), equalTo(new byte[]{ 0x4A, 0x5B, 0x6C, 0x7D}));
|
||||
assertThrows(InvalidParameterException.class, () -> HexDump.hexStringToByteArray("3 "));
|
||||
assertThrows(InvalidParameterException.class, () -> HexDump.hexStringToByteArray("3z"));
|
||||
assertThrows(InvalidParameterException.class, () -> HexDump.hexStringToByteArray("3Z"));
|
||||
}
|
||||
|
||||
}
|
||||
@ -1,55 +0,0 @@
|
||||
package com.hoho.android.usbserial.util;
|
||||
|
||||
import static org.junit.Assert.assertEquals;
|
||||
import static org.mockito.Mockito.mock;
|
||||
import static org.mockito.Mockito.when;
|
||||
|
||||
import android.hardware.usb.UsbEndpoint;
|
||||
import android.os.Process;
|
||||
|
||||
import com.hoho.android.usbserial.driver.CommonUsbSerialPort;
|
||||
|
||||
import org.junit.Test;
|
||||
|
||||
public class SerialInputOutputManagerTest {
|
||||
|
||||
|
||||
// catch all Throwables in onNewData() and onRunError()
|
||||
@Test
|
||||
public void throwable() throws Exception {
|
||||
|
||||
class ExceptionListener implements SerialInputOutputManager.Listener {
|
||||
public Exception e;
|
||||
@Override public void onNewData(byte[] data) { throw new RuntimeException("exception1"); }
|
||||
@Override public void onRunError(Exception e) { this.e = e; throw new RuntimeException("exception2"); }
|
||||
}
|
||||
class ErrorListener implements SerialInputOutputManager.Listener {
|
||||
public Exception e;
|
||||
@Override public void onNewData(byte[] data) { throw new UnknownError("error1"); }
|
||||
@Override public void onRunError(Exception e) { this.e = e; throw new UnknownError("error2");}
|
||||
}
|
||||
|
||||
UsbEndpoint readEndpoint = mock(UsbEndpoint.class);
|
||||
when(readEndpoint.getMaxPacketSize()).thenReturn(16);
|
||||
CommonUsbSerialPort port = mock(CommonUsbSerialPort.class);
|
||||
when(port.getReadEndpoint()).thenReturn(readEndpoint);
|
||||
when(port.read(new byte[16], 0)).thenReturn(1);
|
||||
when(port.isOpen()).thenReturn(true);
|
||||
SerialInputOutputManager manager = new SerialInputOutputManager(port);
|
||||
manager.setThreadPriority(Process.THREAD_PRIORITY_DEFAULT);
|
||||
|
||||
ExceptionListener exceptionListener = new ExceptionListener();
|
||||
manager.setListener(exceptionListener);
|
||||
manager.runRead();
|
||||
assertEquals(RuntimeException.class, exceptionListener.e.getClass());
|
||||
assertEquals("exception1", exceptionListener.e.getMessage());
|
||||
|
||||
ErrorListener errorListener = new ErrorListener();
|
||||
manager.setListener(errorListener);
|
||||
manager.runRead();
|
||||
assertEquals(Exception.class, errorListener.e.getClass());
|
||||
assertEquals("java.lang.UnknownError: error1", errorListener.e.getMessage());
|
||||
assertEquals(UnknownError.class, errorListener.e.getCause().getClass());
|
||||
assertEquals("error1", errorListener.e.getCause().getMessage());
|
||||
}
|
||||
}
|
||||
Loading…
x
Reference in New Issue
Block a user