Google Git
Sign in
android / platform / cts / b02e60db28cc7fd6c2c8af23c54045101973b71b / . / apps / CtsVerifier / src / com / android / cts / verifier / usb / device / UsbDeviceTestActivity.java
blob: 6794059a3de227cc8af32d1f3e594f1901c25367 [file] [log] [blame]
/*
* Copyright (C) 2016 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.cts.verifier.usb.device;
import static com.android.cts.verifier.usb.Util.runAndAssertException;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
import static org.junit.Assume.assumeNotNull;
import static org.junit.Assume.assumeTrue;
import android.app.PendingIntent;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.hardware.usb.UsbConfiguration;
import android.hardware.usb.UsbConstants;
import android.hardware.usb.UsbDevice;
import android.hardware.usb.UsbDeviceConnection;
import android.hardware.usb.UsbEndpoint;
import android.hardware.usb.UsbInterface;
import android.hardware.usb.UsbManager;
import android.hardware.usb.UsbRequest;
import android.os.Bundle;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
import android.util.ArraySet;
import android.util.Log;
import android.util.Pair;
import android.view.View;
import android.widget.ProgressBar;
import android.widget.TextView;
import android.widget.Toast;
import com.android.cts.verifier.PassFailButtons;
import com.android.cts.verifier.R;
import org.junit.AssumptionViolatedException;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.Random;
import java.util.Set;
import java.util.concurrent.TimeoutException;
import java.util.concurrent.atomic.AtomicInteger;
public class UsbDeviceTestActivity extends PassFailButtons.Activity {
private static final String ACTION_USB_PERMISSION =
"com.android.cts.verifier.usb.device.USB_PERMISSION";
private static final String LOG_TAG = UsbDeviceTestActivity.class.getSimpleName();
private static final int TIMEOUT_MILLIS = 5000;
private static final int MAX_BUFFER_SIZE = 16384;
private static final int OVERSIZED_BUFFER_SIZE = MAX_BUFFER_SIZE + 100;
private UsbManager mUsbManager;
private BroadcastReceiver mUsbDeviceConnectionReceiver;
private Thread mTestThread;
private TextView mStatus;
private ProgressBar mProgress;
/**
* Some N and older accessories do not send a zero sized package after a request that is a
* multiple of the maximum package size.
*/
private boolean mDoesCompanionZeroTerminate;
private static long now() {
return System.nanoTime() / 1000000;
}
/**
* Check if we should expect a zero sized transfer after a certain sized transfer
*
* @param transferSize The size of the previous transfer
*
* @return {@code true} if a zero sized transfer is expected
*/
private boolean isZeroTransferExpected(int transferSize) {
if (mDoesCompanionZeroTerminate) {
if (transferSize % 1024 == 0) {
if (transferSize % 8 != 0) {
throw new IllegalArgumentException("As the transfer speed is unknown the code "
+ "has to work for all speeds");
}
return true;
}
}
return false;
}
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.usb_main);
setInfoResources(R.string.usb_device_test, R.string.usb_device_test_info, -1);
mStatus = (TextView) findViewById(R.id.status);
mProgress = (ProgressBar) findViewById(R.id.progress_bar);
mUsbManager = getSystemService(UsbManager.class);
getPassButton().setEnabled(false);
IntentFilter filter = new IntentFilter();
filter.addAction(ACTION_USB_PERMISSION);
filter.addAction(UsbManager.ACTION_USB_DEVICE_ATTACHED);
mStatus.setText(R.string.usb_device_test_step1);
mUsbDeviceConnectionReceiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
synchronized (UsbDeviceTestActivity.this) {
UsbDevice device = intent.getParcelableExtra(UsbManager.EXTRA_DEVICE);
switch (intent.getAction()) {
case UsbManager.ACTION_USB_DEVICE_ATTACHED:
if (!AoapInterface.isDeviceInAoapMode(device)) {
mStatus.setText(R.string.usb_device_test_step2);
}
mUsbManager.requestPermission(device,
PendingIntent.getBroadcast(UsbDeviceTestActivity.this, 0,
new Intent(ACTION_USB_PERMISSION), 0));
break;
case ACTION_USB_PERMISSION:
boolean granted = intent.getBooleanExtra(
UsbManager.EXTRA_PERMISSION_GRANTED, false);
if (granted) {
if (!AoapInterface.isDeviceInAoapMode(device)) {
mStatus.setText(R.string.usb_device_test_step3);
UsbDeviceConnection connection = mUsbManager.openDevice(device);
try {
makeThisDeviceAnAccessory(connection);
} finally {
connection.close();
}
} else {
mStatus.setText(R.string.usb_device_test_step4);
mProgress.setIndeterminate(true);
mProgress.setVisibility(View.VISIBLE);
unregisterReceiver(mUsbDeviceConnectionReceiver);
mUsbDeviceConnectionReceiver = null;
// Do not run test on main thread
mTestThread = new Thread() {
@Override
public void run() {
runTests(device);
}
};
mTestThread.start();
}
} else {
fail("Permission to connect to " + device.getProductName()
+ " not granted", null);
}
break;
}
}
}
};
registerReceiver(mUsbDeviceConnectionReceiver, filter);
}
/**
* Indicate that the test failed.
*/
private void fail(@Nullable String s, @Nullable Throwable e) {
Log.e(LOG_TAG, s, e);
setTestResultAndFinish(false);
}
/**
* Converts the device under test into an Android accessory. Accessories are USB hosts that are
* detected on the device side via {@link UsbManager#getAccessoryList()}.
*
* @param connection The connection to the USB device
*/
private void makeThisDeviceAnAccessory(@NonNull UsbDeviceConnection connection) {
AoapInterface.sendString(connection, AoapInterface.ACCESSORY_STRING_MANUFACTURER,
"Android");
AoapInterface.sendString(connection, AoapInterface.ACCESSORY_STRING_MODEL,
"Android device");
AoapInterface.sendString(connection, AoapInterface.ACCESSORY_STRING_DESCRIPTION,
"Android device running CTS verifier");
AoapInterface.sendString(connection, AoapInterface.ACCESSORY_STRING_VERSION, "1");
AoapInterface.sendString(connection, AoapInterface.ACCESSORY_STRING_URI,
"https://source.android.com/compatibility/cts/verifier.html");
AoapInterface.sendString(connection, AoapInterface.ACCESSORY_STRING_SERIAL, "0");
AoapInterface.sendAoapStart(connection);
}
/**
* Switch to next test.
*
* @param connection Connection to the USB device
* @param in The in endpoint
* @param out The out endpoint
* @param nextTestName The name of the new test
*/
private void nextTest(@NonNull UsbDeviceConnection connection, @NonNull UsbEndpoint in,
@NonNull UsbEndpoint out, @NonNull CharSequence nextTestName) {
Log.v(LOG_TAG, "Finishing previous test");
// Make sure name length is not a multiple of 8 to avoid zero-termination issues
StringBuilder safeNextTestName = new StringBuilder(nextTestName);
if (nextTestName.length() % 8 == 0) {
safeNextTestName.append(' ');
}
// Send name of next test
assertTrue(safeNextTestName.length() <= Byte.MAX_VALUE);
ByteBuffer nextTestNameBuffer = Charset.forName("UTF-8")
.encode(CharBuffer.wrap(safeNextTestName));
byte[] sizeBuffer = { (byte) nextTestNameBuffer.limit() };
int numSent = connection.bulkTransfer(out, sizeBuffer, 1, 0);
assertEquals(1, numSent);
numSent = connection.bulkTransfer(out, nextTestNameBuffer.array(),
nextTestNameBuffer.limit(), 0);
assertEquals(nextTestNameBuffer.limit(), numSent);
// Receive result of last test
byte[] lastTestResultBytes = new byte[1];
int numReceived = connection.bulkTransfer(in, lastTestResultBytes,
lastTestResultBytes.length, TIMEOUT_MILLIS);
assertEquals(1, numReceived);
assertEquals(1, lastTestResultBytes[0]);
// Send ready signal
sizeBuffer[0] = 42;
numSent = connection.bulkTransfer(out, sizeBuffer, 1, 0);
assertEquals(1, numSent);
Log.i(LOG_TAG, "Running test \"" + safeNextTestName + "\"");
}
/**
* Receive a transfer that has size zero using bulk-transfer.
*
* @param connection Connection to the USB device
* @param in The in endpoint
*/
private void receiveZeroSizedTransfer(@NonNull UsbDeviceConnection connection,
@NonNull UsbEndpoint in) {
byte[] buffer = new byte[1];
int numReceived = connection.bulkTransfer(in, buffer, 1, TIMEOUT_MILLIS);
assertEquals(0, numReceived);
}
/**
* Send some data and expect it to be echoed back.
*
* @param connection Connection to the USB device
* @param in The in endpoint
* @param out The out endpoint
* @param size The number of bytes to send
*/
private void echoBulkTransfer(@NonNull UsbDeviceConnection connection,
@NonNull UsbEndpoint in, @NonNull UsbEndpoint out, int size) {
byte[] sentBuffer = new byte[size];
Random r = new Random();
r.nextBytes(sentBuffer);
int numSent = connection.bulkTransfer(out, sentBuffer, sentBuffer.length, 0);
assertEquals(size, numSent);
byte[] receivedBuffer = new byte[size];
int numReceived = connection.bulkTransfer(in, receivedBuffer, receivedBuffer.length,
TIMEOUT_MILLIS);
assertEquals(size, numReceived);
assertArrayEquals(sentBuffer, receivedBuffer);
if (isZeroTransferExpected(size)) {
receiveZeroSizedTransfer(connection, in);
}
}
/**
* Send some data and expect it to be echoed back (but have an offset in the send buffer).
*
* @param connection Connection to the USB device
* @param in The in endpoint
* @param out The out endpoint
* @param size The number of bytes to send
*/
private void echoBulkTransferOffset(@NonNull UsbDeviceConnection connection,
@NonNull UsbEndpoint in, @NonNull UsbEndpoint out, int offset, int size) {
byte[] sentBuffer = new byte[offset + size];
Random r = new Random();
r.nextBytes(sentBuffer);
int numSent = connection.bulkTransfer(out, sentBuffer, offset, size, 0);
assertEquals(size, numSent);
byte[] receivedBuffer = new byte[offset + size];
int numReceived = connection.bulkTransfer(in, receivedBuffer, offset, size, TIMEOUT_MILLIS);
assertEquals(size, numReceived);
for (int i = 0; i < offset + size; i++) {
if (i < offset) {
assertEquals(0, receivedBuffer[i]);
} else {
assertEquals(sentBuffer[i], receivedBuffer[i]);
}
}
if (isZeroTransferExpected(size)) {
receiveZeroSizedTransfer(connection, in);
}
}
/**
* Send a transfer that is larger than MAX_BUFFER_SIZE.
*
* @param connection Connection to the USB device
* @param in The in endpoint
* @param out The out endpoint
*/
private void echoOversizedBulkTransfer(@NonNull UsbDeviceConnection connection,
@NonNull UsbEndpoint in, @NonNull UsbEndpoint out) {
int totalSize = OVERSIZED_BUFFER_SIZE;
byte[] sentBuffer = new byte[totalSize];
Random r = new Random();
r.nextBytes(sentBuffer);
int numSent = connection.bulkTransfer(out, sentBuffer, sentBuffer.length, 0);
// Buffer will only be partially transferred
assertEquals(MAX_BUFFER_SIZE, numSent);
byte[] receivedBuffer = new byte[totalSize];
int numReceived = connection.bulkTransfer(in, receivedBuffer, receivedBuffer.length,
TIMEOUT_MILLIS);
// All beyond MAX_BUFFER_SIZE was not send, hence it will not be echoed back
assertEquals(MAX_BUFFER_SIZE, numReceived);
for (int i = 0; i < totalSize; i++) {
if (i < MAX_BUFFER_SIZE) {
assertEquals(sentBuffer[i], receivedBuffer[i]);
} else {
assertEquals(0, receivedBuffer[i]);
}
}
if (mDoesCompanionZeroTerminate) {
receiveZeroSizedTransfer(connection, in);
}
}
/**
* Receive a transfer that is larger than MAX_BUFFER_SIZE
*
* @param connection Connection to the USB device
* @param in The in endpoint
*/
private void receiveOversizedBulkTransfer(@NonNull UsbDeviceConnection connection,
@NonNull UsbEndpoint in) {
// Buffer will be received as two transfers
byte[] receivedBuffer1 = new byte[OVERSIZED_BUFFER_SIZE];
int numReceived = connection.bulkTransfer(in, receivedBuffer1, receivedBuffer1.length,
TIMEOUT_MILLIS);
assertEquals(MAX_BUFFER_SIZE, numReceived);
byte[] receivedBuffer2 = new byte[OVERSIZED_BUFFER_SIZE - MAX_BUFFER_SIZE];
numReceived = connection.bulkTransfer(in, receivedBuffer2, receivedBuffer2.length,
TIMEOUT_MILLIS);
assertEquals(OVERSIZED_BUFFER_SIZE - MAX_BUFFER_SIZE, numReceived);
assertEquals(1, receivedBuffer1[0]);
assertEquals(2, receivedBuffer1[MAX_BUFFER_SIZE - 1]);
assertEquals(3, receivedBuffer2[0]);
assertEquals(4, receivedBuffer2[OVERSIZED_BUFFER_SIZE - MAX_BUFFER_SIZE - 1]);
}
/**
* Receive data but supply an empty buffer. This causes the thread to block until any data is
* sent. The zero-sized receive-transfer just returns without data and the next transfer can
* actually read the data.
*
* @param connection Connection to the USB device
* @param in The in endpoint
* @param buffer The buffer to use
* @param offset The offset into the buffer
* @param length The lenght of data to receive
*/
private void receiveWithEmptyBuffer(@NonNull UsbDeviceConnection connection,
@NonNull UsbEndpoint in, @Nullable byte[] buffer, int offset, int length) {
long startTime = now();
int numReceived;
if (offset == 0) {
numReceived = connection.bulkTransfer(in, buffer, length, 0);
} else {
numReceived = connection.bulkTransfer(in, buffer, offset, length, 0);
}
long endTime = now();
assertEquals(-1, numReceived);
// The transfer should block
assertTrue(endTime - startTime > 100);
numReceived = connection.bulkTransfer(in, new byte[1], 1, 0);
assertEquals(1, numReceived);
}
/**
* Tests {@link UsbDeviceConnection#controlTransfer}.
*
* <p>Note: We cannot send ctrl data to the device as it thinks it talks to an accessory, hence
* the testing is currently limited.</p>
*
* @param connection The connection to use for testing
*
* @throws Throwable
*/
private void ctrlTransferTests(@NonNull UsbDeviceConnection connection) throws Throwable {
runAndAssertException(() -> connection.controlTransfer(0, 0, 0, 0, null, 1, 0),
IllegalArgumentException.class);
runAndAssertException(() -> connection.controlTransfer(0, 0, 0, 0, new byte[1], -1, 0),
IllegalArgumentException.class);
runAndAssertException(() -> connection.controlTransfer(0, 0, 0, 0, new byte[1], 2, 0),
IllegalArgumentException.class);
runAndAssertException(() -> connection.controlTransfer(0, 0, 0, 0, null, 0, 1, 0),
IllegalArgumentException.class);
runAndAssertException(() -> connection.controlTransfer(0, 0, 0, 0, new byte[1], 0, -1, 0),
IllegalArgumentException.class);
runAndAssertException(() -> connection.controlTransfer(0, 0, 0, 0, new byte[1], 1, 1, 0),
IllegalArgumentException.class);
}
/**
* Search an {@link UsbInterface} for an {@link UsbEndpoint endpoint} of a certain direction.
*
* @param iface The interface to search
* @param direction The direction the endpoint is for.
*
* @return The first endpoint found or {@link null}.
*/
private @NonNull UsbEndpoint getEndpoint(@NonNull UsbInterface iface, int direction) {
for (int i = 0; i < iface.getEndpointCount(); i++) {
UsbEndpoint ep = iface.getEndpoint(i);
if (ep.getDirection() == direction) {
return ep;
}
}
throw new IllegalStateException("Could not find " + direction + " endpoint in "
+ iface.getName());
}
/**
* Receive a transfer that has size zero using deprecated usb-request methods.
*
* @param connection Connection to the USB device
* @param in The in endpoint
*/
private void receiveZeroSizeRequestLegacy(@NonNull UsbDeviceConnection connection,
@NonNull UsbEndpoint in) {
UsbRequest receiveZero = new UsbRequest();
boolean isInited = receiveZero.initialize(connection, in);
assertTrue(isInited);
ByteBuffer zeroBuffer = ByteBuffer.allocate(1);
receiveZero.queue(zeroBuffer, 1);
UsbRequest finished = connection.requestWait();
assertEquals(receiveZero, finished);
assertEquals(0, zeroBuffer.position());
}
/**
* Send a USB request using the {@link UsbRequest#queue legacy path} and receive it back.
*
* @param connection The connection to use
* @param in The endpoint to receive requests from
* @param out The endpoint to send requests to
* @param size The size of the request to send
* @param originalSize The size of the original buffer
* @param sliceStart The start of the final buffer in the original buffer
* @param sliceEnd The end of the final buffer in the original buffer
* @param positionInSlice The position parameter in the final buffer
* @param limitInSlice The limited parameter in the final buffer
* @param useDirectBuffer If the buffer to be used should be a direct buffer
*/
private void echoUsbRequestLegacy(@NonNull UsbDeviceConnection connection,
@NonNull UsbEndpoint in, @NonNull UsbEndpoint out, int size, int originalSize,
int sliceStart, int sliceEnd, int positionInSlice, int limitInSlice,
boolean useDirectBuffer) {
Random random = new Random();
UsbRequest sent = new UsbRequest();
boolean isInited = sent.initialize(connection, out);
assertTrue(isInited);
Object sentClientData = new Object();
sent.setClientData(sentClientData);
UsbRequest receive = new UsbRequest();
isInited = receive.initialize(connection, in);
assertTrue(isInited);
Object receiveClientData = new Object();
receive.setClientData(receiveClientData);
ByteBuffer bufferSent;
if (useDirectBuffer) {
bufferSent = ByteBuffer.allocateDirect(originalSize);
} else {
bufferSent = ByteBuffer.allocate(originalSize);
}
for (int i = 0; i < originalSize; i++) {
bufferSent.put((byte) random.nextInt());
}
bufferSent.position(sliceStart);
bufferSent.limit(sliceEnd);
ByteBuffer bufferSentSliced = bufferSent.slice();
bufferSentSliced.position(positionInSlice);
bufferSentSliced.limit(limitInSlice);
bufferSent.position(0);
bufferSent.limit(originalSize);
ByteBuffer bufferReceived;
if (useDirectBuffer) {
bufferReceived = ByteBuffer.allocateDirect(originalSize);
} else {
bufferReceived = ByteBuffer.allocate(originalSize);
}
bufferReceived.position(sliceStart);
bufferReceived.limit(sliceEnd);
ByteBuffer bufferReceivedSliced = bufferReceived.slice();
bufferReceivedSliced.position(positionInSlice);
bufferReceivedSliced.limit(limitInSlice);
bufferReceived.position(0);
bufferReceived.limit(originalSize);
boolean wasQueued = receive.queue(bufferReceivedSliced, size);
assertTrue(wasQueued);
wasQueued = sent.queue(bufferSentSliced, size);
assertTrue(wasQueued);
for (int reqRun = 0; reqRun < 2; reqRun++) {
UsbRequest finished;
try {
finished = connection.requestWait();
} catch (IllegalArgumentException e) {
if (size > bufferSentSliced.limit() || size > bufferReceivedSliced.limit()) {
Log.e(LOG_TAG, "Expected failure", e);
continue;
} else {
throw e;
}
}
// Should we have gotten a failure?
if (finished == receive) {
// We should have gotten an exception if size > limit
assumeTrue(bufferReceivedSliced.limit() >= size);
assertEquals(size, bufferReceivedSliced.position());
for (int i = 0; i < size; i++) {
if (i < size) {
assertEquals(bufferSent.get(i), bufferReceived.get(i));
} else {
assertEquals(0, bufferReceived.get(i));
}
}
assertSame(receiveClientData, finished.getClientData());
assertSame(in, finished.getEndpoint());
} else {
assertEquals(size, bufferSentSliced.position());
// We should have gotten an exception if size > limit
assumeTrue(bufferSentSliced.limit() >= size);
assertSame(sent, finished);
assertSame(sentClientData, finished.getClientData());
assertSame(out, finished.getEndpoint());
}
finished.close();
}
if (isZeroTransferExpected(size)) {
receiveZeroSizeRequestLegacy(connection, in);
}
}
/**
* Receive a transfer that has size zero using current usb-request methods.
*
* @param connection Connection to the USB device
* @param in The in endpoint
*/
private void receiveZeroSizeRequest(@NonNull UsbDeviceConnection connection,
@NonNull UsbEndpoint in) {
UsbRequest receiveZero = new UsbRequest();
boolean isInited = receiveZero.initialize(connection, in);
assertTrue(isInited);
ByteBuffer zeroBuffer = ByteBuffer.allocate(1);
receiveZero.queue(zeroBuffer);
UsbRequest finished = connection.requestWait();
assertEquals(receiveZero, finished);
assertEquals(0, zeroBuffer.position());
}
/**
* Send a USB request and receive it back.
*
* @param connection The connection to use
* @param in The endpoint to receive requests from
* @param out The endpoint to send requests to
* @param originalSize The size of the original buffer
* @param sliceStart The start of the final buffer in the original buffer
* @param sliceEnd The end of the final buffer in the original buffer
* @param positionInSlice The position parameter in the final buffer
* @param limitInSlice The limited parameter in the final buffer
* @param useDirectBuffer If the buffer to be used should be a direct buffer
*/
private void echoUsbRequest(@NonNull UsbDeviceConnection connection, @NonNull UsbEndpoint in,
@NonNull UsbEndpoint out, int originalSize, int sliceStart, int sliceEnd,
int positionInSlice, int limitInSlice, boolean useDirectBuffer,
boolean makeSendBufferReadOnly) {
Random random = new Random();
UsbRequest sent = new UsbRequest();
boolean isInited = sent.initialize(connection, out);
assertTrue(isInited);
Object sentClientData = new Object();
sent.setClientData(sentClientData);
UsbRequest receive = new UsbRequest();
isInited = receive.initialize(connection, in);
assertTrue(isInited);
Object receiveClientData = new Object();
receive.setClientData(receiveClientData);
ByteBuffer bufferSent;
if (useDirectBuffer) {
bufferSent = ByteBuffer.allocateDirect(originalSize);
} else {
bufferSent = ByteBuffer.allocate(originalSize);
}
for (int i = 0; i < originalSize; i++) {
bufferSent.put((byte) random.nextInt());
}
if (makeSendBufferReadOnly) {
bufferSent = bufferSent.asReadOnlyBuffer();
}
bufferSent.position(sliceStart);
bufferSent.limit(sliceEnd);
ByteBuffer bufferSentSliced = bufferSent.slice();
bufferSentSliced.position(positionInSlice);
bufferSentSliced.limit(limitInSlice);
bufferSent.position(0);
bufferSent.limit(originalSize);
ByteBuffer bufferReceived;
if (useDirectBuffer) {
bufferReceived = ByteBuffer.allocateDirect(originalSize);
} else {
bufferReceived = ByteBuffer.allocate(originalSize);
}
bufferReceived.position(sliceStart);
bufferReceived.limit(sliceEnd);
ByteBuffer bufferReceivedSliced = bufferReceived.slice();
bufferReceivedSliced.position(positionInSlice);
bufferReceivedSliced.limit(limitInSlice);
bufferReceived.position(0);
bufferReceived.limit(originalSize);
boolean wasQueued = receive.queue(bufferReceivedSliced);
assertTrue(wasQueued);
wasQueued = sent.queue(bufferSentSliced);
assertTrue(wasQueued);
for (int reqRun = 0; reqRun < 2; reqRun++) {
UsbRequest finished = connection.requestWait();
if (finished == receive) {
assertEquals(limitInSlice, bufferReceivedSliced.limit());
assertEquals(limitInSlice, bufferReceivedSliced.position());
for (int i = 0; i < originalSize; i++) {
if (i >= sliceStart + positionInSlice && i < sliceStart + limitInSlice) {
assertEquals(bufferSent.get(i), bufferReceived.get(i));
} else {
assertEquals(0, bufferReceived.get(i));
}
}
assertSame(receiveClientData, finished.getClientData());
assertSame(in, finished.getEndpoint());
} else {
assertEquals(limitInSlice, bufferSentSliced.limit());
assertEquals(limitInSlice, bufferSentSliced.position());
assertSame(sent, finished);
assertSame(sentClientData, finished.getClientData());
assertSame(out, finished.getEndpoint());
}
finished.close();
}
if (isZeroTransferExpected(sliceStart + limitInSlice - (sliceStart + positionInSlice))) {
receiveZeroSizeRequest(connection, in);
}
}
/**
* Send a USB request using the {@link UsbRequest#queue legacy path} and receive it back.
*
* @param connection The connection to use
* @param in The endpoint to receive requests from
* @param out The endpoint to send requests to
* @param size The size of the request to send
* @param useDirectBuffer If the buffer to be used should be a direct buffer
*/
private void echoUsbRequestLegacy(@NonNull UsbDeviceConnection connection,
@NonNull UsbEndpoint in, @NonNull UsbEndpoint out, int size, boolean useDirectBuffer) {
echoUsbRequestLegacy(connection, in, out, size, size, 0, size, 0, size, useDirectBuffer);
}
/**
* Send a USB request and receive it back.
*
* @param connection The connection to use
* @param in The endpoint to receive requests from
* @param out The endpoint to send requests to
* @param size The size of the request to send
* @param useDirectBuffer If the buffer to be used should be a direct buffer
*/
private void echoUsbRequest(@NonNull UsbDeviceConnection connection, @NonNull UsbEndpoint in,
@NonNull UsbEndpoint out, int size, boolean useDirectBuffer) {
echoUsbRequest(connection, in, out, size, 0, size, 0, size, useDirectBuffer, false);
}
/**
* Send a USB request which more than the allowed size and receive it back.
*
* @param connection The connection to use
* @param in The endpoint to receive requests from
* @param out The endpoint to send requests to
*/
private void echoOversizedUsbRequestLegacy(@NonNull UsbDeviceConnection connection,
@NonNull UsbEndpoint in, @NonNull UsbEndpoint out) {
Random random = new Random();
int totalSize = OVERSIZED_BUFFER_SIZE;
UsbRequest sent = new UsbRequest();
boolean isInited = sent.initialize(connection, out);
assertTrue(isInited);
UsbRequest receive = new UsbRequest();
isInited = receive.initialize(connection, in);
assertTrue(isInited);
byte[] sentBytes = new byte[totalSize];
random.nextBytes(sentBytes);
ByteBuffer bufferSent = ByteBuffer.wrap(sentBytes);
byte[] receivedBytes = new byte[totalSize];
ByteBuffer bufferReceived = ByteBuffer.wrap(receivedBytes);
boolean wasQueued = receive.queue(bufferReceived, totalSize);
assertTrue(wasQueued);
wasQueued = sent.queue(bufferSent, totalSize);
assertTrue(wasQueued);
for (int requestNum = 0; requestNum < 2; requestNum++) {
UsbRequest finished = connection.requestWait();
if (finished == receive) {
// size beyond MAX_BUFFER_SIZE is ignored
for (int i = 0; i < totalSize; i++) {
if (i < MAX_BUFFER_SIZE) {
assertEquals(sentBytes[i], receivedBytes[i]);
} else {
assertEquals(0, receivedBytes[i]);
}
}
} else {
assertSame(sent, finished);
}
finished.close();
}
if (mDoesCompanionZeroTerminate) {
receiveZeroSizeRequestLegacy(connection, in);
}
}
/**
* Time out while waiting for USB requests.
*
* @param connection The connection to use
*/
private void timeoutWhileWaitingForUsbRequest(@NonNull UsbDeviceConnection connection)
throws Throwable {
runAndAssertException(() -> connection.requestWait(-1), IllegalArgumentException.class);
long startTime = now();
runAndAssertException(() -> connection.requestWait(100), TimeoutException.class);
assertTrue(now() - startTime >= 100);
assertTrue(now() - startTime < 400);
startTime = now();
runAndAssertException(() -> connection.requestWait(0), TimeoutException.class);
assertTrue(now() - startTime < 400);
}
/**
* Receive a USB request before a timeout triggers
*
* @param connection The connection to use
* @param in The endpoint to receive requests from
*/
private void receiveAfterTimeout(@NonNull UsbDeviceConnection connection,
@NonNull UsbEndpoint in, long timeout) throws InterruptedException, TimeoutException {
UsbRequest reqQueued = new UsbRequest();
ByteBuffer buffer = ByteBuffer.allocate(1);
reqQueued.initialize(connection, in);
reqQueued.queue(buffer);
// Let the kernel receive and process the request
Thread.sleep(50);
long startTime = now();
UsbRequest reqFinished = connection.requestWait(timeout);
assertTrue(now() - startTime < timeout + 50);
assertSame(reqQueued, reqFinished);
reqFinished.close();
}
/**
* Send a USB request with size 0 using the {@link UsbRequest#queue legacy path}.
*
* @param connection The connection to use
* @param out The endpoint to send requests to
* @param useDirectBuffer Send data from a direct buffer
*/
private void sendZeroLengthRequestLegacy(@NonNull UsbDeviceConnection connection,
@NonNull UsbEndpoint out, boolean useDirectBuffer) {
UsbRequest sent = new UsbRequest();
boolean isInited = sent.initialize(connection, out);
assertTrue(isInited);
ByteBuffer buffer;
if (useDirectBuffer) {
buffer = ByteBuffer.allocateDirect(0);
} else {
buffer = ByteBuffer.allocate(0);
}
boolean isQueued = sent.queue(buffer, 0);
assumeTrue(isQueued);
UsbRequest finished = connection.requestWait();
assertSame(finished, sent);
finished.close();
}
/**
* Send a USB request with size 0.
*
* @param connection The connection to use
* @param out The endpoint to send requests to
* @param useDirectBuffer Send data from a direct buffer
*/
private void sendZeroLengthRequest(@NonNull UsbDeviceConnection connection,
@NonNull UsbEndpoint out, boolean useDirectBuffer) {
UsbRequest sent = new UsbRequest();
boolean isInited = sent.initialize(connection, out);
assertTrue(isInited);
ByteBuffer buffer;
if (useDirectBuffer) {
buffer = ByteBuffer.allocateDirect(0);
} else {
buffer = ByteBuffer.allocate(0);
}
boolean isQueued = sent.queue(buffer);
assumeTrue(isQueued);
UsbRequest finished = connection.requestWait();
assertSame(finished, sent);
finished.close();
}
/**
* Send a USB request with a null buffer.
*
* @param connection The connection to use
* @param out The endpoint to send requests to
*/
private void sendNullRequest(@NonNull UsbDeviceConnection connection,
@NonNull UsbEndpoint out) {
UsbRequest sent = new UsbRequest();
boolean isInited = sent.initialize(connection, out);
assertTrue(isInited);
boolean isQueued = sent.queue(null);
assumeTrue(isQueued);
UsbRequest finished = connection.requestWait();
assertSame(finished, sent);
finished.close();
}
/**
* Receive a USB request with size 0.
*
* @param connection The connection to use
* @param in The endpoint to recevie requests from
*/
private void receiveZeroLengthRequestLegacy(@NonNull UsbDeviceConnection connection,
@NonNull UsbEndpoint in, boolean useDirectBuffer) {
UsbRequest zeroReceived = new UsbRequest();
boolean isInited = zeroReceived.initialize(connection, in);
assertTrue(isInited);
UsbRequest oneReceived = new UsbRequest();
isInited = oneReceived.initialize(connection, in);
assertTrue(isInited);
ByteBuffer buffer;
if (useDirectBuffer) {
buffer = ByteBuffer.allocateDirect(0);
} else {
buffer = ByteBuffer.allocate(0);
}
ByteBuffer buffer1;
if (useDirectBuffer) {
buffer1 = ByteBuffer.allocateDirect(1);
} else {
buffer1 = ByteBuffer.allocate(1);
}
boolean isQueued = zeroReceived.queue(buffer);
assumeTrue(isQueued);
isQueued = oneReceived.queue(buffer1);
assumeTrue(isQueued);
// We expect both to be returned after some time
ArrayList<UsbRequest> finished = new ArrayList<>(2);
// We expect both request to come back after the delay, but then quickly
long startTime = now();
finished.add(connection.requestWait());
long firstReturned = now();
finished.add(connection.requestWait());
long secondReturned = now();
assumeTrue(firstReturned - startTime > 100);
assumeTrue(secondReturned - firstReturned < 100);
assertTrue(finished.contains(zeroReceived));
assertTrue(finished.contains(oneReceived));
}
/**
* Tests the {@link UsbRequest#queue legacy implementaion} of {@link UsbRequest} and
* {@link UsbDeviceConnection#requestWait()}.
*
* @param connection The connection to use for testing
* @param iface The interface of the android accessory interface of the device
* @throws Throwable
*/
private void usbRequestLegacyTests(@NonNull UsbDeviceConnection connection,
@NonNull UsbInterface iface) throws Throwable {
// Find bulk in and out endpoints
assumeTrue(iface.getEndpointCount() == 2);
final UsbEndpoint in = getEndpoint(iface, UsbConstants.USB_DIR_IN);
final UsbEndpoint out = getEndpoint(iface, UsbConstants.USB_DIR_OUT);
assertNotNull(in);
assertNotNull(out);
// Single threaded send and receive
nextTest(connection, in, out, "Echo 1 byte");
echoUsbRequestLegacy(connection, in, out, 1, true);
nextTest(connection, in, out, "Echo 1 byte");
echoUsbRequestLegacy(connection, in, out, 1, false);
nextTest(connection, in, out, "Echo max bytes");
echoUsbRequestLegacy(connection, in, out, MAX_BUFFER_SIZE, true);
nextTest(connection, in, out, "Echo max bytes");
echoUsbRequestLegacy(connection, in, out, MAX_BUFFER_SIZE, false);
nextTest(connection, in, out, "Echo oversized buffer");
echoOversizedUsbRequestLegacy(connection, in, out);
// Send empty requests
sendZeroLengthRequestLegacy(connection, out, true);
sendZeroLengthRequestLegacy(connection, out, false);
// waitRequest with timeout
timeoutWhileWaitingForUsbRequest(connection);
nextTest(connection, in, out, "Receive byte after some time");
receiveAfterTimeout(connection, in, 400);
nextTest(connection, in, out, "Receive byte immediately");
// Make sure the data is received before we queue the request for it
Thread.sleep(50);
receiveAfterTimeout(connection, in, 0);
/* TODO: Unreliable
// Zero length means waiting for the next data and then return
nextTest(connection, in, out, "Receive byte after some time");
receiveZeroLengthRequestLegacy(connection, in, true);
nextTest(connection, in, out, "Receive byte after some time");
receiveZeroLengthRequestLegacy(connection, in, true);
*/
// UsbRequest.queue ignores position, limit, arrayOffset, and capacity
nextTest(connection, in, out, "Echo 42 bytes");
echoUsbRequestLegacy(connection, in, out, 42, 42, 0, 42, 5, 42, false);
nextTest(connection, in, out, "Echo 42 bytes");
echoUsbRequestLegacy(connection, in, out, 42, 42, 0, 42, 0, 36, false);
nextTest(connection, in, out, "Echo 42 bytes");
echoUsbRequestLegacy(connection, in, out, 42, 42, 5, 42, 0, 36, false);
nextTest(connection, in, out, "Echo 42 bytes");
echoUsbRequestLegacy(connection, in, out, 42, 42, 0, 36, 0, 31, false);
nextTest(connection, in, out, "Echo 42 bytes");
echoUsbRequestLegacy(connection, in, out, 42, 47, 0, 47, 0, 47, false);
nextTest(connection, in, out, "Echo 42 bytes");
echoUsbRequestLegacy(connection, in, out, 42, 47, 5, 47, 0, 42, false);
nextTest(connection, in, out, "Echo 42 bytes");
echoUsbRequestLegacy(connection, in, out, 42, 47, 0, 42, 0, 42, false);
nextTest(connection, in, out, "Echo 42 bytes");
echoUsbRequestLegacy(connection, in, out, 42, 47, 0, 47, 5, 47, false);
nextTest(connection, in, out, "Echo 42 bytes");
echoUsbRequestLegacy(connection, in, out, 42, 47, 5, 47, 5, 36, false);
// Illegal arguments
final UsbRequest req1 = new UsbRequest();
runAndAssertException(() -> req1.initialize(null, in), NullPointerException.class);
runAndAssertException(() -> req1.initialize(connection, null), NullPointerException.class);
boolean isInited = req1.initialize(connection, in);
assertTrue(isInited);
runAndAssertException(() -> req1.queue(null, 0), NullPointerException.class);
runAndAssertException(() -> req1.queue(ByteBuffer.allocate(1).asReadOnlyBuffer(), 1),
IllegalArgumentException.class);
req1.close();
// Cannot queue closed request
runAndAssertException(() -> req1.queue(ByteBuffer.allocate(1), 1),
NullPointerException.class);
runAndAssertException(() -> req1.queue(ByteBuffer.allocateDirect(1), 1),
NullPointerException.class);
}
/**
* Repeat c n times
*
* @param c The character to repeat
* @param n The number of times to repeat
*
* @return c repeated n times
*/
public static String repeat(char c, int n) {
final StringBuilder result = new StringBuilder();
for (int i = 0; i < n; i++) {
if (c != ' ' && i % 10 == 0) {
result.append(i / 10);
} else {
result.append(c);
}
}
return result.toString();
}
/**
* Tests {@link UsbRequest} and {@link UsbDeviceConnection#requestWait()}.
*
* @param connection The connection to use for testing
* @param iface The interface of the android accessory interface of the device
* @throws Throwable
*/
private void usbRequestTests(@NonNull UsbDeviceConnection connection,
@NonNull UsbInterface iface) throws Throwable {
// Find bulk in and out endpoints
assumeTrue(iface.getEndpointCount() == 2);
final UsbEndpoint in = getEndpoint(iface, UsbConstants.USB_DIR_IN);
final UsbEndpoint out = getEndpoint(iface, UsbConstants.USB_DIR_OUT);
assertNotNull(in);
assertNotNull(out);
// Single threaded send and receive
nextTest(connection, in, out, "Echo 1 byte");
echoUsbRequest(connection, in, out, 1, true);
nextTest(connection, in, out, "Echo 1 byte");
echoUsbRequest(connection, in, out, 1, false);
nextTest(connection, in, out, "Echo max bytes");
echoUsbRequest(connection, in, out, MAX_BUFFER_SIZE, true);
nextTest(connection, in, out, "Echo max bytes");
echoUsbRequest(connection, in, out, MAX_BUFFER_SIZE, false);
// Send empty requests
sendZeroLengthRequest(connection, out, true);
sendZeroLengthRequest(connection, out, false);
sendNullRequest(connection, out);
/* TODO: Unreliable
// Zero length means waiting for the next data and then return
nextTest(connection, in, out, "Receive byte after some time");
receiveZeroLengthRequest(connection, in, true);
nextTest(connection, in, out, "Receive byte after some time");
receiveZeroLengthRequest(connection, in, true);
*/
for (int startOfSlice : new int[]{0, 1}) {
for (int endOffsetOfSlice : new int[]{0, 2}) {
for (int positionInSlice : new int[]{0, 5}) {
for (int limitOffsetInSlice : new int[]{0, 11}) {
for (boolean useDirectBuffer : new boolean[]{true, false}) {
for (boolean makeSendBufferReadOnly : new boolean[]{true, false}) {
int sliceSize = 42 + positionInSlice + limitOffsetInSlice;
int originalSize = sliceSize + startOfSlice + endOffsetOfSlice;
nextTest(connection, in, out, "Echo 42 bytes");
// Log buffer, slice, and data offsets
Log.i(LOG_TAG,
"buffer" + (makeSendBufferReadOnly ? "(ro): [" : ": [")
+ repeat('.', originalSize) + "]");
Log.i(LOG_TAG,
"slice: " + repeat(' ', startOfSlice) + " [" + repeat(
'.', sliceSize) + "]");
Log.i(LOG_TAG,
"data: " + repeat(' ', startOfSlice + positionInSlice)
+ " [" + repeat('.', 42) + "]");
echoUsbRequest(connection, in, out, originalSize, startOfSlice,
originalSize - endOffsetOfSlice, positionInSlice,
sliceSize - limitOffsetInSlice, useDirectBuffer,
makeSendBufferReadOnly);
}
}
}
}
}
}
// Illegal arguments
final UsbRequest req1 = new UsbRequest();
runAndAssertException(() -> req1.initialize(null, in), NullPointerException.class);
runAndAssertException(() -> req1.initialize(connection, null), NullPointerException.class);
boolean isInited = req1.initialize(connection, in);
assertTrue(isInited);
runAndAssertException(() -> req1.queue(ByteBuffer.allocate(16384 + 1).asReadOnlyBuffer()),
IllegalArgumentException.class);
runAndAssertException(() -> req1.queue(ByteBuffer.allocate(1).asReadOnlyBuffer()),
IllegalArgumentException.class);
req1.close();
// Cannot queue closed request
runAndAssertException(() -> req1.queue(ByteBuffer.allocate(1)),
IllegalStateException.class);
runAndAssertException(() -> req1.queue(ByteBuffer.allocateDirect(1)),
IllegalStateException.class);
// Initialize
UsbRequest req2 = new UsbRequest();
isInited = req2.initialize(connection, in);
assertTrue(isInited);
isInited = req2.initialize(connection, out);
assertTrue(isInited);
req2.close();
// Close
req2 = new UsbRequest();
req2.close();
req2.initialize(connection, in);
req2.close();
req2.close();
}
/** State of a {@link UsbRequest} in flight */
private static class RequestState {
final ByteBuffer buffer;
final Object clientData;
private RequestState(ByteBuffer buffer, Object clientData) {
this.buffer = buffer;
this.clientData = clientData;
}
}
/** Recycles elements that might be expensive to create */
private abstract class Recycler<T> {
private final Random mRandom;
private final LinkedList<T> mData;
protected Recycler() {
mData = new LinkedList<>();
mRandom = new Random();
}
/**
* Add a new element to be recycled.
*
* @param newElement The element that is not used anymore and can be used by someone else.
*/
private void recycle(@NonNull T newElement) {
synchronized (mData) {
if (mRandom.nextBoolean()) {
mData.addLast(newElement);
} else {
mData.addFirst(newElement);
}
}
}
/**
* Get a recycled element or create a new one if needed.
*
* @return An element that can be used (maybe recycled)
*/
private @NonNull T get() {
T recycledElement;
try {
synchronized (mData) {
recycledElement = mData.pop();
}
} catch (NoSuchElementException ignored) {
recycledElement = create();
}
reset(recycledElement);
return recycledElement;
}
/** Reset internal state of {@code recycledElement} */
protected abstract void reset(@NonNull T recycledElement);
/** Create a new element */
protected abstract @NonNull T create();
/** Get all elements that are currently recycled and waiting to be used again */
public @NonNull LinkedList<T> getAll() {
return mData;
}
}
/**
* Common code between {@link QueuerThread} and {@link ReceiverThread}.
*/
private class TestThread extends Thread {
/** State copied from the main thread (see runTest()) */
protected final UsbDeviceConnection mConnection;
protected final Recycler<UsbRequest> mInRequestRecycler;
protected final Recycler<UsbRequest> mOutRequestRecycler;
protected final Recycler<ByteBuffer> mBufferRecycler;
protected final HashMap<UsbRequest, RequestState> mRequestsInFlight;
protected final HashMap<Integer, Integer> mData;
protected final ArrayList<Throwable> mErrors;
protected volatile boolean mShouldStop;
TestThread(@NonNull UsbDeviceConnection connection,
@NonNull Recycler<UsbRequest> inRequestRecycler,
@NonNull Recycler<UsbRequest> outRequestRecycler,
@NonNull Recycler<ByteBuffer> bufferRecycler,
@NonNull HashMap<UsbRequest, RequestState> requestsInFlight,
@NonNull HashMap<Integer, Integer> data,
@NonNull ArrayList<Throwable> errors) {
super();
mShouldStop = false;
mConnection = connection;
mBufferRecycler = bufferRecycler;
mInRequestRecycler = inRequestRecycler;
mOutRequestRecycler = outRequestRecycler;
mRequestsInFlight = requestsInFlight;
mData = data;
mErrors = errors;
}
/**
* Stop thread
*/
void abort() {
mShouldStop = true;
interrupt();
}
}
/**
* A thread that queues matching write and read {@link UsbRequest requests}. We expect the
* writes to be echoed back and return in unchanged in the read requests.
* <p> This thread just issues the requests and does not care about them anymore after the
* system took them. The {@link ReceiverThread} handles the result of both write and read
* requests.</p>
*/
private class QueuerThread extends TestThread {
private static final int MAX_IN_FLIGHT = 64;
private static final long RUN_TIME = 10 * 1000;
private final AtomicInteger mCounter;
/**
* Create a new thread that queues matching write and read UsbRequests.
*
* @param connection Connection to communicate with
* @param inRequestRecycler Pool of in-requests that can be reused
* @param outRequestRecycler Pool of out-requests that can be reused
* @param bufferRecycler Pool of byte buffers that can be reused
* @param requestsInFlight State of the requests currently in flight
* @param data Mapping counter -> data
* @param counter An atomic counter
* @param errors Pool of throwables created by threads like this
*/
QueuerThread(@NonNull UsbDeviceConnection connection,
@NonNull Recycler<UsbRequest> inRequestRecycler,
@NonNull Recycler<UsbRequest> outRequestRecycler,
@NonNull Recycler<ByteBuffer> bufferRecycler,
@NonNull HashMap<UsbRequest, RequestState> requestsInFlight,
@NonNull HashMap<Integer, Integer> data,
@NonNull AtomicInteger counter,
@NonNull ArrayList<Throwable> errors) {
super(connection, inRequestRecycler, outRequestRecycler, bufferRecycler,
requestsInFlight, data, errors);
mCounter = counter;
}
@Override
public void run() {
Random random = new Random();
long endTime = now() + RUN_TIME;
while (now() < endTime && !mShouldStop) {
try {
int counter = mCounter.getAndIncrement();
if (counter % 1024 == 0) {
Log.i(LOG_TAG, "Counter is " + counter);
}
// Write [1:counter:data]
UsbRequest writeRequest = mOutRequestRecycler.get();
ByteBuffer writeBuffer = mBufferRecycler.get();
int data = random.nextInt();
writeBuffer.put((byte)1).putInt(counter).putInt(data);
writeBuffer.flip();
// Send read that will receive the data back from the write as the other side
// will echo all requests.
UsbRequest readRequest = mInRequestRecycler.get();
ByteBuffer readBuffer = mBufferRecycler.get();
// Register requests
synchronized (mRequestsInFlight) {
// Wait until previous requests were processed
while (mRequestsInFlight.size() > MAX_IN_FLIGHT) {
try {
mRequestsInFlight.wait();
} catch (InterruptedException e) {
break;
}
}
if (mShouldStop) {
break;
} else {
mRequestsInFlight.put(writeRequest, new RequestState(writeBuffer,
writeRequest.getClientData()));
mRequestsInFlight.put(readRequest, new RequestState(readBuffer,
readRequest.getClientData()));
mRequestsInFlight.notifyAll();
}
}
// Store which data was written for the counter
synchronized (mData) {
mData.put(counter, data);
}
// Send both requests to the system. Once they finish the ReceiverThread will
// be notified
boolean isQueued = writeRequest.queue(writeBuffer);
assertTrue(isQueued);
isQueued = readRequest.queue(readBuffer, 9);
assertTrue(isQueued);
} catch (Throwable t) {
synchronized (mErrors) {
mErrors.add(t);
mErrors.notify();
}
break;
}
}
}
}
/**
* A thread that receives processed UsbRequests and compares the expected result. The requests
* can be both read and write requests. The requests were created and given to the system by
* the {@link QueuerThread}.
*/
private class ReceiverThread extends TestThread {
private final UsbEndpoint mOut;
/**
* Create a thread that receives processed UsbRequests and compares the expected result.
*
* @param connection Connection to communicate with
* @param out Endpoint to queue write requests on
* @param inRequestRecycler Pool of in-requests that can be reused
* @param outRequestRecycler Pool of out-requests that can be reused
* @param bufferRecycler Pool of byte buffers that can be reused
* @param requestsInFlight State of the requests currently in flight
* @param data Mapping counter -> data
* @param errors Pool of throwables created by threads like this
*/
ReceiverThread(@NonNull UsbDeviceConnection connection, @NonNull UsbEndpoint out,
@NonNull Recycler<UsbRequest> inRequestRecycler,
@NonNull Recycler<UsbRequest> outRequestRecycler,
@NonNull Recycler<ByteBuffer> bufferRecycler,
@NonNull HashMap<UsbRequest, RequestState> requestsInFlight,
@NonNull HashMap<Integer, Integer> data, @NonNull ArrayList<Throwable> errors) {
super(connection, inRequestRecycler, outRequestRecycler, bufferRecycler,
requestsInFlight, data, errors);
mOut = out;
}
@Override
public void run() {
while (!mShouldStop) {
try {
// Wait until a request is queued as mConnection.requestWait() cannot be
// interrupted.
synchronized (mRequestsInFlight) {
while (mRequestsInFlight.isEmpty()) {
try {
mRequestsInFlight.wait();
} catch (InterruptedException e) {
break;
}
}
if (mShouldStop) {
break;
}
}
// Receive request
UsbRequest request = mConnection.requestWait();
assertNotNull(request);
// Find the state the request should have
RequestState state;
synchronized (mRequestsInFlight) {
state = mRequestsInFlight.remove(request);
mRequestsInFlight.notifyAll();
}
// Compare client data
assertSame(state.clientData, request.getClientData());
// There is nothing more to check about write requests, but for read requests
// (the ones going to an out endpoint) we know that it just an echoed back write
// request.
if (!request.getEndpoint().equals(mOut)) {
state.buffer.flip();
// Read request buffer, check that data is correct
byte alive = state.buffer.get();
int counter = state.buffer.getInt();
int receivedData = state.buffer.getInt();
// We stored which data-combinations were written
int expectedData;
synchronized(mData) {
expectedData = mData.remove(counter);
}
// Make sure read request matches a write request we sent before
assertEquals(1, alive);
assertEquals(expectedData, receivedData);
}
// Recycle buffers and requests so they can be reused later.
mBufferRecycler.recycle(state.buffer);
if (request.getEndpoint().equals(mOut)) {
mOutRequestRecycler.recycle(request);
} else {
mInRequestRecycler.recycle(request);
}
} catch (Throwable t) {
synchronized (mErrors) {
mErrors.add(t);
mErrors.notify();
}
break;
}
}
}
}
/**
* Tests parallel issuance and receiving of {@link UsbRequest usb requests}.
*
* @param connection The connection to use for testing
* @param iface The interface of the android accessory interface of the device
*/
private void parallelUsbRequestsTests(@NonNull UsbDeviceConnection connection,
@NonNull UsbInterface iface) {
// Find bulk in and out endpoints
assumeTrue(iface.getEndpointCount() == 2);
final UsbEndpoint in = getEndpoint(iface, UsbConstants.USB_DIR_IN);
final UsbEndpoint out = getEndpoint(iface, UsbConstants.USB_DIR_OUT);
assertNotNull(in);
assertNotNull(out);
// Recycler for requests for the in-endpoint
Recycler<UsbRequest> inRequestRecycler = new Recycler<UsbRequest>() {
@Override
protected void reset(@NonNull UsbRequest recycledElement) {
recycledElement.setClientData(new Object());
}
@Override
protected @NonNull UsbRequest create() {
UsbRequest request = new UsbRequest();
request.initialize(connection, in);
return request;
}
};
// Recycler for requests for the in-endpoint
Recycler<UsbRequest> outRequestRecycler = new Recycler<UsbRequest>() {
@Override
protected void reset(@NonNull UsbRequest recycledElement) {
recycledElement.setClientData(new Object());
}
@Override
protected @NonNull UsbRequest create() {
UsbRequest request = new UsbRequest();
request.initialize(connection, out);
return request;
}
};
// Recycler for requests for read and write buffers
Recycler<ByteBuffer> bufferRecycler = new Recycler<ByteBuffer>() {
@Override
protected void reset(@NonNull ByteBuffer recycledElement) {
recycledElement.rewind();
}
@Override
protected @NonNull ByteBuffer create() {
return ByteBuffer.allocateDirect(9);
}
};
HashMap<UsbRequest, RequestState> requestsInFlight = new HashMap<>();
// Data in the requests
HashMap<Integer, Integer> data = new HashMap<>();
AtomicInteger counter = new AtomicInteger(0);
// Errors created in the threads
ArrayList<Throwable> errors = new ArrayList<>();
// Create two threads that queue read and write requests
QueuerThread queuer1 = new QueuerThread(connection, inRequestRecycler,
outRequestRecycler, bufferRecycler, requestsInFlight, data, counter, errors);
QueuerThread queuer2 = new QueuerThread(connection, inRequestRecycler,
outRequestRecycler, bufferRecycler, requestsInFlight, data, counter, errors);
// Create a thread that receives the requests after they are processed.
ReceiverThread receiver = new ReceiverThread(connection, out, inRequestRecycler,
outRequestRecycler, bufferRecycler, requestsInFlight, data, errors);
nextTest(connection, in, out, "Echo until stop signal");
queuer1.start();
queuer2.start();
receiver.start();
Log.i(LOG_TAG, "Waiting for queuers to stop");
try {
queuer1.join();
queuer2.join();
} catch (InterruptedException e) {
synchronized(errors) {
errors.add(e);
}
}
if (errors.isEmpty()) {
Log.i(LOG_TAG, "Wait for all requests to finish");
synchronized (requestsInFlight) {
while (!requestsInFlight.isEmpty()) {
try {
requestsInFlight.wait();
} catch (InterruptedException e) {
synchronized(errors) {
errors.add(e);
}
break;
}
}
}
receiver.abort();
try {
receiver.join();
} catch (InterruptedException e) {
synchronized(errors) {
errors.add(e);
}
}
// Close all requests that are currently recycled
inRequestRecycler.getAll().forEach(UsbRequest::close);
outRequestRecycler.getAll().forEach(UsbRequest::close);
} else {
receiver.abort();
}
for (Throwable t : errors) {
Log.e(LOG_TAG, "Error during test", t);
}
byte[] stopBytes = new byte[9];
connection.bulkTransfer(out, stopBytes, 9, 0);
// If we had any error make the test fail
assertEquals(0, errors.size());
}
/**
* Tests {@link UsbDeviceConnection#bulkTransfer}.
*
* @param connection The connection to use for testing
* @param iface The interface of the android accessory interface of the device
* @throws Throwable
*/
private void bulkTransferTests(@NonNull UsbDeviceConnection connection,
@NonNull UsbInterface iface) throws Throwable {
// Find bulk in and out endpoints
assumeTrue(iface.getEndpointCount() == 2);
final UsbEndpoint in = getEndpoint(iface, UsbConstants.USB_DIR_IN);
final UsbEndpoint out = getEndpoint(iface, UsbConstants.USB_DIR_OUT);
assertNotNull(in);
assertNotNull(out);
// Transmission tests
nextTest(connection, in, out, "Echo 1 byte");
echoBulkTransfer(connection, in, out, 1);
nextTest(connection, in, out, "Echo 42 bytes");
echoBulkTransferOffset(connection, in, out, 23, 42);
nextTest(connection, in, out, "Echo max bytes");
echoBulkTransfer(connection, in, out, MAX_BUFFER_SIZE);
nextTest(connection, in, out, "Echo oversized buffer");
echoOversizedBulkTransfer(connection, in, out);
nextTest(connection, in, out, "Receive oversized buffer");
receiveOversizedBulkTransfer(connection, in);
// Illegal arguments
runAndAssertException(() -> connection.bulkTransfer(out, new byte[1], 2, 0),
IllegalArgumentException.class);
runAndAssertException(() -> connection.bulkTransfer(in, new byte[1], 2, 0),
IllegalArgumentException.class);
runAndAssertException(() -> connection.bulkTransfer(out, new byte[2], 1, 2, 0),
IllegalArgumentException.class);
runAndAssertException(() -> connection.bulkTransfer(in, new byte[2], 1, 2, 0),
IllegalArgumentException.class);
runAndAssertException(() -> connection.bulkTransfer(out, new byte[1], -1, 0),
IllegalArgumentException.class);
runAndAssertException(() -> connection.bulkTransfer(in, new byte[1], -1, 0),
IllegalArgumentException.class);
runAndAssertException(() -> connection.bulkTransfer(out, new byte[1], 1, -1, 0),
IllegalArgumentException.class);
runAndAssertException(() -> connection.bulkTransfer(in, new byte[1], 1, -1, 0),
IllegalArgumentException.class);
runAndAssertException(() -> connection.bulkTransfer(out, new byte[1], -1, -1, 0),
IllegalArgumentException.class);
runAndAssertException(() -> connection.bulkTransfer(in, new byte[1], -1, -1, 0),
IllegalArgumentException.class);
runAndAssertException(() -> connection.bulkTransfer(null, new byte[1], 1, 0),
NullPointerException.class);
// Transmissions that do nothing
int numSent = connection.bulkTransfer(out, null, 0, 0);
assertEquals(0, numSent);
numSent = connection.bulkTransfer(out, null, 0, 0, 0);
assertEquals(0, numSent);
numSent = connection.bulkTransfer(out, new byte[0], 0, 0);
assertEquals(0, numSent);
numSent = connection.bulkTransfer(out, new byte[0], 0, 0, 0);
assertEquals(0, numSent);
numSent = connection.bulkTransfer(out, new byte[2], 2, 0, 0);
assertEquals(0, numSent);
/* TODO: These tests are flaky as they appear to be affected by previous tests
// Transmissions that do not transfer data:
// - first transfer blocks until data is received, but does not return the data.
// - The data is read in the second transfer
nextTest(connection, in, out, "Receive byte after some time");
receiveWithEmptyBuffer(connection, in, null, 0, 0);
nextTest(connection, in, out, "Receive byte after some time");
receiveWithEmptyBuffer(connection, in, new byte[0], 0, 0);
nextTest(connection, in, out, "Receive byte after some time");
receiveWithEmptyBuffer(connection, in, new byte[2], 2, 0);
*/
// Timeouts
int numReceived = connection.bulkTransfer(in, new byte[1], 1, 100);
assertEquals(-1, numReceived);
nextTest(connection, in, out, "Receive byte after some time");
numReceived = connection.bulkTransfer(in, new byte[1], 1, 10000);
assertEquals(1, numReceived);
nextTest(connection, in, out, "Receive byte after some time");
numReceived = connection.bulkTransfer(in, new byte[1], 1, 0);
assertEquals(1, numReceived);
nextTest(connection, in, out, "Receive byte after some time");
numReceived = connection.bulkTransfer(in, new byte[1], 1, -1);
assertEquals(1, numReceived);
numReceived = connection.bulkTransfer(in, new byte[2], 1, 1, 100);
assertEquals(-1, numReceived);
nextTest(connection, in, out, "Receive byte after some time");
numReceived = connection.bulkTransfer(in, new byte[2], 1, 1, 0);
assertEquals(1, numReceived);
nextTest(connection, in, out, "Receive byte after some time");
numReceived = connection.bulkTransfer(in, new byte[2], 1, 1, -1);
assertEquals(1, numReceived);
}
/**
* Test if the companion device zero-terminates their requests that are multiples of the
* maximum package size. Then sets {@link #mDoesCompanionZeroTerminate} if the companion
* zero terminates
*
* @param connection Connection to the USB device
* @param iface The interface to use
*/
private void testIfCompanionZeroTerminates(@NonNull UsbDeviceConnection connection,
@NonNull UsbInterface iface) {
assumeTrue(iface.getEndpointCount() == 2);
final UsbEndpoint in = getEndpoint(iface, UsbConstants.USB_DIR_IN);
final UsbEndpoint out = getEndpoint(iface, UsbConstants.USB_DIR_OUT);
assertNotNull(in);
assertNotNull(out);
nextTest(connection, in, out, "does companion zero terminate");
// The other size sends:
// - 1024 bytes
// - maybe a zero sized package
// - 1 byte
byte[] buffer = new byte[1024];
int numTransferred = connection.bulkTransfer(in, buffer, 1024, 0);
assertEquals(1024, numTransferred);
numTransferred = connection.bulkTransfer(in, buffer, 1, 0);
if (numTransferred == 0) {
assertEquals(0, numTransferred);
numTransferred = connection.bulkTransfer(in, buffer, 1, 0);
assertEquals(1, numTransferred);
mDoesCompanionZeroTerminate = true;
Log.i(LOG_TAG, "Companion zero terminates");
} else {
assertEquals(1, numTransferred);
Log.i(LOG_TAG, "Companion does not zero terminate - an older device");
}
}
/**
* Send signal to the remove device that testing is finished.
*
* @param connection The connection to use for testing
* @param iface The interface of the android accessory interface of the device
*/
private void endTesting(@NonNull UsbDeviceConnection connection, @NonNull UsbInterface iface) {
// "done" signals that testing is over
nextTest(connection, getEndpoint(iface, UsbConstants.USB_DIR_IN),
getEndpoint(iface, UsbConstants.USB_DIR_OUT), "done");
}
/**
* Test the behavior of {@link UsbDeviceConnection#claimInterface} and
* {@link UsbDeviceConnection#releaseInterface}.
*
* <p>Note: The interface under test is <u>not</u> claimed by a kernel driver, hence there is
* no difference in behavior between force and non-force versions of
* {@link UsbDeviceConnection#claimInterface}</p>
*
* @param connection The connection to use
* @param iface The interface to claim and release
*
* @throws Throwable
*/
private void claimInterfaceTests(@NonNull UsbDeviceConnection connection,
@NonNull UsbInterface iface) throws Throwable {
// The interface is not claimed by the kernel driver, so not forcing it should work
boolean claimed = connection.claimInterface(iface, false);
assertTrue(claimed);
boolean released = connection.releaseInterface(iface);
assertTrue(released);
// Forcing if it is not necessary does no harm
claimed = connection.claimInterface(iface, true);
assertTrue(claimed);
// Re-claiming does nothing
claimed = connection.claimInterface(iface, true);
assertTrue(claimed);
released = connection.releaseInterface(iface);
assertTrue(released);
// Re-releasing is not allowed
released = connection.releaseInterface(iface);
assertFalse(released);
// Using an unclaimed interface claims it automatically
int numSent = connection.bulkTransfer(getEndpoint(iface, UsbConstants.USB_DIR_OUT), null, 0,
0);
assertEquals(0, numSent);
released = connection.releaseInterface(iface);
assertTrue(released);
runAndAssertException(() -> connection.claimInterface(null, true),
NullPointerException.class);
runAndAssertException(() -> connection.claimInterface(null, false),
NullPointerException.class);
runAndAssertException(() -> connection.releaseInterface(null), NullPointerException.class);
}
/**
* Test all input parameters to {@link UsbDeviceConnection#setConfiguration} .
*
* <p>Note:
* <ul>
* <li>The device under test only supports one configuration, hence changing configuration
* is not tested.</li>
* <li>This test sets the current configuration again. This resets the device.</li>
* </ul></p>
*
* @param device the device under test
* @param connection The connection to use
* @param iface An interface of the device
*
* @throws Throwable
*/
private void setConfigurationTests(@NonNull UsbDevice device,
@NonNull UsbDeviceConnection connection, @NonNull UsbInterface iface) throws Throwable {
assumeTrue(device.getConfigurationCount() == 1);
boolean wasSet = connection.setConfiguration(device.getConfiguration(0));
assertTrue(wasSet);
// Cannot set configuration for a device with a claimed interface
boolean claimed = connection.claimInterface(iface, false);
assertTrue(claimed);
wasSet = connection.setConfiguration(device.getConfiguration(0));
assertFalse(wasSet);
boolean released = connection.releaseInterface(iface);
assertTrue(released);
runAndAssertException(() -> connection.setConfiguration(null), NullPointerException.class);
}
/**
* Test all input parameters to {@link UsbDeviceConnection#setConfiguration} .
*
* <p>Note: The interface under test only supports one settings, hence changing the setting can
* not be tested.</p>
*
* @param connection The connection to use
* @param iface The interface to test
*
* @throws Throwable
*/
private void setInterfaceTests(@NonNull UsbDeviceConnection connection,
@NonNull UsbInterface iface) throws Throwable {
boolean claimed = connection.claimInterface(iface, false);
assertTrue(claimed);
boolean wasSet = connection.setInterface(iface);
assertTrue(wasSet);
boolean released = connection.releaseInterface(iface);
assertTrue(released);
// Setting the interface for an unclaimed interface automatically claims it
wasSet = connection.setInterface(iface);
assertTrue(wasSet);
released = connection.releaseInterface(iface);
assertTrue(released);
runAndAssertException(() -> connection.setInterface(null), NullPointerException.class);
}
/**
* Enumerate all known devices and check basic relationship between the properties.
*/
private void enumerateDevices() throws Exception {
Set<Integer> knownDeviceIds = new ArraySet<>();
for (Map.Entry<String, UsbDevice> entry : mUsbManager.getDeviceList().entrySet()) {
UsbDevice device = entry.getValue();
assertEquals(entry.getKey(), device.getDeviceName());
assertNotNull(device.getDeviceName());
// Device ID should be unique
assertFalse(knownDeviceIds.contains(device.getDeviceId()));
knownDeviceIds.add(device.getDeviceId());
assertEquals(device.getDeviceName(), UsbDevice.getDeviceName(device.getDeviceId()));
// Properties without constraints
device.getManufacturerName();
device.getProductName();
device.getVersion();
device.getSerialNumber();
device.getVendorId();
device.getProductId();
device.getDeviceClass();
device.getDeviceSubclass();
device.getDeviceProtocol();
Set<UsbInterface> interfacesFromAllConfigs = new ArraySet<>();
Set<Pair<Integer, Integer>> knownInterfaceIds = new ArraySet<>();
Set<Integer> knownConfigurationIds = new ArraySet<>();
int numConfigurations = device.getConfigurationCount();
for (int configNum = 0; configNum < numConfigurations; configNum++) {
UsbConfiguration config = device.getConfiguration(configNum);
// Configuration ID should be unique
assertFalse(knownConfigurationIds.contains(config.getId()));
knownConfigurationIds.add(config.getId());
assertTrue(config.getMaxPower() >= 0);
// Properties without constraints
config.getName();
config.isSelfPowered();
config.isRemoteWakeup();
int numInterfaces = config.getInterfaceCount();
for (int interfaceNum = 0; interfaceNum < numInterfaces; interfaceNum++) {
UsbInterface iface = config.getInterface(interfaceNum);
interfacesFromAllConfigs.add(iface);
Pair<Integer, Integer> ifaceId = new Pair<>(iface.getId(),
iface.getAlternateSetting());
assertFalse(knownInterfaceIds.contains(ifaceId));
knownInterfaceIds.add(ifaceId);
// Properties without constraints
iface.getName();
iface.getInterfaceClass();
iface.getInterfaceSubclass();
iface.getInterfaceProtocol();
int numEndpoints = iface.getEndpointCount();
for (int endpointNum = 0; endpointNum < numEndpoints; endpointNum++) {
UsbEndpoint endpoint = iface.getEndpoint(endpointNum);
assertEquals(endpoint.getAddress(),
endpoint.getEndpointNumber() | endpoint.getDirection());
assertTrue(endpoint.getDirection() == UsbConstants.USB_DIR_OUT ||
endpoint.getDirection() == UsbConstants.USB_DIR_IN);
assertTrue(endpoint.getType() == UsbConstants.USB_ENDPOINT_XFER_CONTROL ||
endpoint.getType() == UsbConstants.USB_ENDPOINT_XFER_ISOC ||
endpoint.getType() == UsbConstants.USB_ENDPOINT_XFER_BULK ||
endpoint.getType() == UsbConstants.USB_ENDPOINT_XFER_INT);
assertTrue(endpoint.getMaxPacketSize() >= 0);
assertTrue(endpoint.getInterval() >= 0);
// Properties without constraints
endpoint.getAttributes();
}
}
}
int numInterfaces = device.getInterfaceCount();
for (int interfaceNum = 0; interfaceNum < numInterfaces; interfaceNum++) {
assertTrue(interfacesFromAllConfigs.contains(device.getInterface(interfaceNum)));
}
}
}
/**
* Run tests.
*
* @param device The device to run the test against. This device is running
* com.android.cts.verifierusbcompanion.DeviceTestCompanion
*/
private void runTests(@NonNull UsbDevice device) {
try {
// Find the AOAP interface
UsbInterface iface = null;
for (int i = 0; i < device.getConfigurationCount(); i++) {
if (device.getInterface(i).getName().equals("Android Accessory Interface")) {
iface = device.getInterface(i);
break;
}
}
assumeNotNull(iface);
enumerateDevices();
UsbDeviceConnection connection = mUsbManager.openDevice(device);
assertNotNull(connection);
claimInterfaceTests(connection, iface);
boolean claimed = connection.claimInterface(iface, false);
assertTrue(claimed);
testIfCompanionZeroTerminates(connection, iface);
usbRequestLegacyTests(connection, iface);
usbRequestTests(connection, iface);
parallelUsbRequestsTests(connection, iface);
ctrlTransferTests(connection);
bulkTransferTests(connection, iface);
// Signal to the DeviceTestCompanion that there are no more transfer test
endTesting(connection, iface);
boolean released = connection.releaseInterface(iface);
assertTrue(released);
setInterfaceTests(connection, iface);
setConfigurationTests(device, connection, iface);
assertFalse(connection.getFileDescriptor() == -1);
assertNotNull(connection.getRawDescriptors());
assertFalse(connection.getRawDescriptors().length == 0);
assertEquals(device.getSerialNumber(), connection.getSerial());
connection.close();
// We should not be able to communicate with the device anymore
assertFalse(connection.claimInterface(iface, true));
assertFalse(connection.releaseInterface(iface));
assertFalse(connection.setConfiguration(device.getConfiguration(0)));
assertFalse(connection.setInterface(iface));
assertTrue(connection.getFileDescriptor() == -1);
assertNull(connection.getRawDescriptors());
assertNull(connection.getSerial());
assertEquals(-1, connection.bulkTransfer(getEndpoint(iface, UsbConstants.USB_DIR_OUT),
new byte[1], 1, 0));
assertEquals(-1, connection.bulkTransfer(getEndpoint(iface, UsbConstants.USB_DIR_OUT),
null, 0, 0));
assertEquals(-1, connection.bulkTransfer(getEndpoint(iface, UsbConstants.USB_DIR_IN),
null, 0, 0));
assertFalse((new UsbRequest()).initialize(connection, getEndpoint(iface,
UsbConstants.USB_DIR_IN)));
// Double close should do no harm
connection.close();
setTestResultAndFinish(true);
} catch (AssumptionViolatedException e) {
// Assumptions failing means that somehow the device/connection is set up incorrectly
Toast.makeText(this, getString(R.string.usb_device_unexpected, e.getLocalizedMessage()),
Toast.LENGTH_LONG).show();
} catch (Throwable e) {
fail(null, e);
}
}
@Override
protected void onDestroy() {
if (mUsbDeviceConnectionReceiver != null) {
unregisterReceiver(mUsbDeviceConnectionReceiver);
}
super.onDestroy();
}
}