apps/CtsVerifierUSBCompanion/src/com/android/cts/verifierusbcompanion/AccessoryTestCompanion.java - platform/cts - Git at Google

 /*
  * 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.verifierusbcompanion;

 import static org.junit.Assert.assertEquals;

 import android.app.PendingIntent;
 import android.content.BroadcastReceiver;
 import android.content.Context;
 import android.content.Intent;
 import android.content.IntentFilter;
 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.support.annotation.NonNull;

 import java.nio.ByteBuffer;
 import java.nio.charset.Charset;

 /**
  * Companion code for com.android.cts.verifier.usb.device.UsbAccessoryTestActivity
  */
 class AccessoryTestCompanion extends TestCompanion {
     private static final int TIMEOUT_MILLIS = 500;
     private static final int MAX_BUFFER_SIZE = 16384;
     private static final int TEST_DATA_SIZE_THRESHOLD = 100 * 1024 * 1024; // 100MB

     private static final String ACTION_USB_PERMISSION =
             "com.android.cts.verifierusbcompanion.USB_PERMISSION";

     private UsbManager mUsbManager;
     private BroadcastReceiver mUsbDeviceConnectionReceiver;
     private UsbDevice mDevice;

     AccessoryTestCompanion(@NonNull Context context, @NonNull TestObserver observer) {
         super(context, observer);
     }

     /**
      * @throws Throwable
      */
     @Override
     protected void runTest() throws Throwable {
         updateStatus("Waiting for device under test to connect");

         mUsbManager = getContext().getSystemService(UsbManager.class);

         mUsbDeviceConnectionReceiver = new BroadcastReceiver() {
             @Override
             public void onReceive(Context context, Intent intent) {
                 synchronized (AccessoryTestCompanion.this) {
                     UsbDevice device = intent.getParcelableExtra(UsbManager.EXTRA_DEVICE);

                     switch (intent.getAction()) {
                         case UsbManager.ACTION_USB_DEVICE_ATTACHED:
                             if (mUsbManager.hasPermission(device)) {
                                 onDeviceAccessPermitted(device);
                             } else {
                                 mUsbManager.requestPermission(device,
                                         PendingIntent.getBroadcast(getContext(), 0,
                                                 new Intent(ACTION_USB_PERMISSION), 0));
                             }
                             break;
                         case ACTION_USB_PERMISSION:
                             boolean granted = intent.getBooleanExtra(
                                     UsbManager.EXTRA_PERMISSION_GRANTED, false);

                             if (granted) {
                                 onDeviceAccessPermitted(device);
                             } else {
                                 fail("Permission to connect to " + device.getProductName()
                                         + " not granted");
                             }
                             break;
                     }
                 }
             }
         };

         IntentFilter filter = new IntentFilter();
         filter.addAction(ACTION_USB_PERMISSION);
         filter.addAction(UsbManager.ACTION_USB_DEVICE_ATTACHED);

         getContext().registerReceiver(mUsbDeviceConnectionReceiver, filter);

         synchronized (this) {
             while (mDevice == null) {
                 wait();
             }
         }

         UsbInterface iface = null;
         for (int i = 0; i < mDevice.getConfigurationCount(); i++) {
             if (mDevice.getInterface(i).getName().equals("Android Accessory Interface")) {
                 iface = mDevice.getInterface(i);
                 break;
             }
         }

         UsbEndpoint in = getEndpoint(iface, UsbConstants.USB_DIR_IN);
         UsbEndpoint out = getEndpoint(iface, UsbConstants.USB_DIR_OUT);

         UsbDeviceConnection connection = mUsbManager.openDevice(mDevice);

         try {
             String testName;
             do {
                 testName = nextTest(connection, in, out, true);

                 updateStatus("Running test \"" + testName + "\"");

                 switch (testName) {
                     case "echo 32 bytes": {
                         byte[] buffer = new byte[32];

                         int numTransferred = connection.bulkTransfer(in, buffer, 32, 0);
                         assertEquals(32, numTransferred);

                         numTransferred = connection.bulkTransfer(out, buffer, 32, 0);
                         assertEquals(32, numTransferred);
                     }
                     break;

                     case "echo two 16 byte transfers as one": {
                         byte[] buffer = new byte[48];

                         // We receive the individual transfers even if we wait for more data
                         int numTransferred = connection.bulkTransfer(in, buffer, 32, 0);
                         assertEquals(16, numTransferred);
                         numTransferred = connection.bulkTransfer(in, buffer, 16, 32, 0);
                         assertEquals(16, numTransferred);

                         numTransferred = connection.bulkTransfer(out, buffer, 32, 0);
                         assertEquals(32, numTransferred);
                     }
                     break;

                     case "echo 32 bytes as two 16 byte transfers": {
                         byte[] buffer = new byte[32];

                         int numTransferred = connection.bulkTransfer(in, buffer, 32, 0);
                         assertEquals(32, numTransferred);

                         numTransferred = connection.bulkTransfer(out, buffer, 16, 0);
                         assertEquals(16, numTransferred);
                         numTransferred = connection.bulkTransfer(out, buffer, 16, 16, 0);
                         assertEquals(16, numTransferred);
                     }
                     break;

                     case "measure out transfer speed": {
                         byte[] buffer = new byte[MAX_BUFFER_SIZE];

                         long bytesRead = 0;
                         while (bytesRead < TEST_DATA_SIZE_THRESHOLD) {
                             int numTransferred = connection.bulkTransfer(
                                     in, buffer, MAX_BUFFER_SIZE, 0);
                             bytesRead += numTransferred;
                         }

                         // MAX_BUFFER_SIZE is a multiple of the package size, hence we get a zero
                         // sized package after. Some older devices do not send these packages, but
                         // this is not compliant anymore.
                         int numTransferred = connection.bulkTransfer(in, buffer, 1, TIMEOUT_MILLIS);
                         assertEquals(0, numTransferred);

                         byte[] confirm = new byte[] {1};
                         numTransferred = connection.bulkTransfer(out, confirm, 1, 0);
                         assertEquals(1, numTransferred);
                     }
                     break;

                     case "measure in transfer speed": {
                         byte[] buffer = new byte[MAX_BUFFER_SIZE];

                         long bytesWritten = 0;
                         int numTransferred = 0;
                         while (bytesWritten < TEST_DATA_SIZE_THRESHOLD) {
                             numTransferred =
                                     connection.bulkTransfer(out, buffer, MAX_BUFFER_SIZE, 0);
                             assertEquals(MAX_BUFFER_SIZE, numTransferred);
                             bytesWritten += numTransferred;
                         }

                         byte[] confirm = new byte[] {1};
                         numTransferred = connection.bulkTransfer(out, confirm, 1, 0);
                         assertEquals(1, numTransferred);
                     }
                     break;

                     case "echo max bytes": {
                         byte[] buffer = new byte[MAX_BUFFER_SIZE];

                         int numTransferred = connection.bulkTransfer(in, buffer, MAX_BUFFER_SIZE,
                                 0);
                         assertEquals(MAX_BUFFER_SIZE, numTransferred);

                         // MAX_BUFFER_SIZE is a multiple of the package size, hence we get a zero
                         // sized package after. Some older devices do not send these packages, but
                         // this is not compliant anymore.
                         numTransferred = connection.bulkTransfer(in, buffer, 1, TIMEOUT_MILLIS);
                         assertEquals(0, numTransferred);

                         numTransferred = connection.bulkTransfer(out, buffer, MAX_BUFFER_SIZE, 0);
                         assertEquals(MAX_BUFFER_SIZE, numTransferred);
                     }
                     break;

                     case "echo max*2 bytes": {
                         byte[] buffer = new byte[MAX_BUFFER_SIZE * 2];

                         int numTransferred = connection.bulkTransfer(in, buffer, MAX_BUFFER_SIZE,
                                 0);
                         assertEquals(MAX_BUFFER_SIZE, numTransferred);

                         // Oversized transfers get split into two
                         numTransferred = connection.bulkTransfer(in, buffer, MAX_BUFFER_SIZE,
                                 MAX_BUFFER_SIZE, 0);
                         assertEquals(MAX_BUFFER_SIZE, numTransferred);

                         // MAX_BUFFER_SIZE is a multiple of the package size, hence we get a zero
                         // sized package after. Some older devices do not send these packages, but
                         // this is not compliant anymore.
                         numTransferred = connection.bulkTransfer(in, buffer, 1, TIMEOUT_MILLIS);
                         assertEquals(0, numTransferred);

                         numTransferred = connection.bulkTransfer(out, buffer, MAX_BUFFER_SIZE, 100);
                         assertEquals(MAX_BUFFER_SIZE, numTransferred);

                         numTransferred = connection.bulkTransfer(out, buffer, MAX_BUFFER_SIZE,
                                 MAX_BUFFER_SIZE, 0);
                         assertEquals(MAX_BUFFER_SIZE, numTransferred);
                     }
                     break;

                     default:
                         break;
                 }
             } while (!testName.equals("done"));
         } finally {
             connection.close();
         }
     }

     /**
      * If access to a device was permitted either make the device an accessory if it already is,
      * start the test.
      *
      * @param device The device access was permitted to
      */
     private void onDeviceAccessPermitted(@NonNull UsbDevice device) {
         if (!AoapInterface.isDeviceInAoapMode(device)) {
             UsbDeviceConnection connection = mUsbManager.openDevice(device);
             try {
                 makeThisDeviceAnAccessory(connection);
             } finally {
                 connection.close();
             }
         } else {
             getContext().unregisterReceiver(mUsbDeviceConnectionReceiver);
             mUsbDeviceConnectionReceiver = null;

             synchronized (AccessoryTestCompanion.this) {
                 mDevice = device;

                 AccessoryTestCompanion.this.notifyAll();
             }
         }
     }

     @NonNull private String nextTest(@NonNull UsbDeviceConnection connection,
             @NonNull UsbEndpoint in, @NonNull UsbEndpoint out, boolean isSuccess) {
         byte[] sizeBuffer = new byte[1];

         updateStatus("Waiting for next test");

         int numTransferred = connection.bulkTransfer(in, sizeBuffer, 1, 0);
         assertEquals(1, numTransferred);

         int nameSize = sizeBuffer[0];

         byte[] nameBuffer = new byte[nameSize];
         numTransferred = connection.bulkTransfer(in, nameBuffer, nameSize, 0);
         assertEquals(nameSize, numTransferred);

         numTransferred = connection.bulkTransfer(out, new byte[]{(byte) (isSuccess ? 1 : 0)}, 1, 0);
         assertEquals(1, numTransferred);

         numTransferred = connection.bulkTransfer(in, new byte[1], 1, 0);
         assertEquals(1, numTransferred);

         String name = Charset.forName("UTF-8").decode(ByteBuffer.wrap(nameBuffer)).toString();

         updateStatus("Next test is " + name);

         return name;
     }

     /**
      * 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}.
      */
     @NonNull private 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());
     }

     /**
      * 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);
     }
 }
	/*
	* 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.verifierusbcompanion;

	import static org.junit.Assert.assertEquals;

	import android.app.PendingIntent;
	import android.content.BroadcastReceiver;
	import android.content.Context;
	import android.content.Intent;
	import android.content.IntentFilter;
	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.support.annotation.NonNull;

	import java.nio.ByteBuffer;
	import java.nio.charset.Charset;

	/**
	* Companion code for com.android.cts.verifier.usb.device.UsbAccessoryTestActivity
	*/
	class AccessoryTestCompanion extends TestCompanion {
	private static final int TIMEOUT_MILLIS = 500;
	private static final int MAX_BUFFER_SIZE = 16384;
	private static final int TEST_DATA_SIZE_THRESHOLD = 100 * 1024 * 1024; // 100MB

	private static final String ACTION_USB_PERMISSION =
	"com.android.cts.verifierusbcompanion.USB_PERMISSION";

	private UsbManager mUsbManager;
	private BroadcastReceiver mUsbDeviceConnectionReceiver;
	private UsbDevice mDevice;

	AccessoryTestCompanion(@NonNull Context context, @NonNull TestObserver observer) {
	super(context, observer);
	}

	/**
	* @throws Throwable
	*/
	@Override
	protected void runTest() throws Throwable {
	updateStatus("Waiting for device under test to connect");

	mUsbManager = getContext().getSystemService(UsbManager.class);

	mUsbDeviceConnectionReceiver = new BroadcastReceiver() {
	@Override
	public void onReceive(Context context, Intent intent) {
	synchronized (AccessoryTestCompanion.this) {
	UsbDevice device = intent.getParcelableExtra(UsbManager.EXTRA_DEVICE);

	switch (intent.getAction()) {
	case UsbManager.ACTION_USB_DEVICE_ATTACHED:
	if (mUsbManager.hasPermission(device)) {
	onDeviceAccessPermitted(device);
	} else {
	mUsbManager.requestPermission(device,
	PendingIntent.getBroadcast(getContext(), 0,
	new Intent(ACTION_USB_PERMISSION), 0));
	}
	break;
	case ACTION_USB_PERMISSION:
	boolean granted = intent.getBooleanExtra(
	UsbManager.EXTRA_PERMISSION_GRANTED, false);

	if (granted) {
	onDeviceAccessPermitted(device);
	} else {
	fail("Permission to connect to " + device.getProductName()
	+ " not granted");
	}
	break;
	}
	}
	}
	};

	IntentFilter filter = new IntentFilter();
	filter.addAction(ACTION_USB_PERMISSION);
	filter.addAction(UsbManager.ACTION_USB_DEVICE_ATTACHED);

	getContext().registerReceiver(mUsbDeviceConnectionReceiver, filter);

	synchronized (this) {
	while (mDevice == null) {
	wait();
	}
	}

	UsbInterface iface = null;
	for (int i = 0; i < mDevice.getConfigurationCount(); i++) {
	if (mDevice.getInterface(i).getName().equals("Android Accessory Interface")) {
	iface = mDevice.getInterface(i);
	break;
	}
	}

	UsbEndpoint in = getEndpoint(iface, UsbConstants.USB_DIR_IN);
	UsbEndpoint out = getEndpoint(iface, UsbConstants.USB_DIR_OUT);

	UsbDeviceConnection connection = mUsbManager.openDevice(mDevice);

	try {
	String testName;
	do {
	testName = nextTest(connection, in, out, true);

	updateStatus("Running test \"" + testName + "\"");

	switch (testName) {
	case "echo 32 bytes": {
	byte[] buffer = new byte[32];

	int numTransferred = connection.bulkTransfer(in, buffer, 32, 0);
	assertEquals(32, numTransferred);

	numTransferred = connection.bulkTransfer(out, buffer, 32, 0);
	assertEquals(32, numTransferred);
	}
	break;

	case "echo two 16 byte transfers as one": {
	byte[] buffer = new byte[48];

	// We receive the individual transfers even if we wait for more data
	int numTransferred = connection.bulkTransfer(in, buffer, 32, 0);
	assertEquals(16, numTransferred);
	numTransferred = connection.bulkTransfer(in, buffer, 16, 32, 0);
	assertEquals(16, numTransferred);

	numTransferred = connection.bulkTransfer(out, buffer, 32, 0);
	assertEquals(32, numTransferred);
	}
	break;

	case "echo 32 bytes as two 16 byte transfers": {
	byte[] buffer = new byte[32];

	int numTransferred = connection.bulkTransfer(in, buffer, 32, 0);
	assertEquals(32, numTransferred);

	numTransferred = connection.bulkTransfer(out, buffer, 16, 0);
	assertEquals(16, numTransferred);
	numTransferred = connection.bulkTransfer(out, buffer, 16, 16, 0);
	assertEquals(16, numTransferred);
	}
	break;

	case "measure out transfer speed": {
	byte[] buffer = new byte[MAX_BUFFER_SIZE];

	long bytesRead = 0;
	while (bytesRead < TEST_DATA_SIZE_THRESHOLD) {
	int numTransferred = connection.bulkTransfer(
	in, buffer, MAX_BUFFER_SIZE, 0);
	bytesRead += numTransferred;
	}

	// MAX_BUFFER_SIZE is a multiple of the package size, hence we get a zero
	// sized package after. Some older devices do not send these packages, but
	// this is not compliant anymore.
	int numTransferred = connection.bulkTransfer(in, buffer, 1, TIMEOUT_MILLIS);
	assertEquals(0, numTransferred);

	byte[] confirm = new byte[] {1};
	numTransferred = connection.bulkTransfer(out, confirm, 1, 0);
	assertEquals(1, numTransferred);
	}
	break;

	case "measure in transfer speed": {
	byte[] buffer = new byte[MAX_BUFFER_SIZE];

	long bytesWritten = 0;
	int numTransferred = 0;
	while (bytesWritten < TEST_DATA_SIZE_THRESHOLD) {
	numTransferred =
	connection.bulkTransfer(out, buffer, MAX_BUFFER_SIZE, 0);
	assertEquals(MAX_BUFFER_SIZE, numTransferred);
	bytesWritten += numTransferred;
	}

	byte[] confirm = new byte[] {1};
	numTransferred = connection.bulkTransfer(out, confirm, 1, 0);
	assertEquals(1, numTransferred);
	}
	break;

	case "echo max bytes": {
	byte[] buffer = new byte[MAX_BUFFER_SIZE];

	int numTransferred = connection.bulkTransfer(in, buffer, MAX_BUFFER_SIZE,
	0);
	assertEquals(MAX_BUFFER_SIZE, numTransferred);

	// MAX_BUFFER_SIZE is a multiple of the package size, hence we get a zero
	// sized package after. Some older devices do not send these packages, but
	// this is not compliant anymore.
	numTransferred = connection.bulkTransfer(in, buffer, 1, TIMEOUT_MILLIS);
	assertEquals(0, numTransferred);

	numTransferred = connection.bulkTransfer(out, buffer, MAX_BUFFER_SIZE, 0);
	assertEquals(MAX_BUFFER_SIZE, numTransferred);
	}
	break;

	case "echo max*2 bytes": {
	byte[] buffer = new byte[MAX_BUFFER_SIZE * 2];

	int numTransferred = connection.bulkTransfer(in, buffer, MAX_BUFFER_SIZE,
	0);
	assertEquals(MAX_BUFFER_SIZE, numTransferred);

	// Oversized transfers get split into two
	numTransferred = connection.bulkTransfer(in, buffer, MAX_BUFFER_SIZE,
	MAX_BUFFER_SIZE, 0);
	assertEquals(MAX_BUFFER_SIZE, numTransferred);

	// MAX_BUFFER_SIZE is a multiple of the package size, hence we get a zero
	// sized package after. Some older devices do not send these packages, but
	// this is not compliant anymore.
	numTransferred = connection.bulkTransfer(in, buffer, 1, TIMEOUT_MILLIS);
	assertEquals(0, numTransferred);

	numTransferred = connection.bulkTransfer(out, buffer, MAX_BUFFER_SIZE, 100);
	assertEquals(MAX_BUFFER_SIZE, numTransferred);

	numTransferred = connection.bulkTransfer(out, buffer, MAX_BUFFER_SIZE,
	MAX_BUFFER_SIZE, 0);
	assertEquals(MAX_BUFFER_SIZE, numTransferred);
	}
	break;

	default:
	break;
	}
	} while (!testName.equals("done"));
	} finally {
	connection.close();
	}
	}

	/**
	* If access to a device was permitted either make the device an accessory if it already is,
	* start the test.
	*
	* @param device The device access was permitted to
	*/
	private void onDeviceAccessPermitted(@NonNull UsbDevice device) {
	if (!AoapInterface.isDeviceInAoapMode(device)) {
	UsbDeviceConnection connection = mUsbManager.openDevice(device);
	try {
	makeThisDeviceAnAccessory(connection);
	} finally {
	connection.close();
	}
	} else {
	getContext().unregisterReceiver(mUsbDeviceConnectionReceiver);
	mUsbDeviceConnectionReceiver = null;

	synchronized (AccessoryTestCompanion.this) {
	mDevice = device;

	AccessoryTestCompanion.this.notifyAll();
	}
	}
	}

	@NonNull private String nextTest(@NonNull UsbDeviceConnection connection,
	@NonNull UsbEndpoint in, @NonNull UsbEndpoint out, boolean isSuccess) {
	byte[] sizeBuffer = new byte[1];

	updateStatus("Waiting for next test");

	int numTransferred = connection.bulkTransfer(in, sizeBuffer, 1, 0);
	assertEquals(1, numTransferred);

	int nameSize = sizeBuffer[0];

	byte[] nameBuffer = new byte[nameSize];
	numTransferred = connection.bulkTransfer(in, nameBuffer, nameSize, 0);
	assertEquals(nameSize, numTransferred);

	numTransferred = connection.bulkTransfer(out, new byte[]{(byte) (isSuccess ? 1 : 0)}, 1, 0);
	assertEquals(1, numTransferred);

	numTransferred = connection.bulkTransfer(in, new byte[1], 1, 0);
	assertEquals(1, numTransferred);

	String name = Charset.forName("UTF-8").decode(ByteBuffer.wrap(nameBuffer)).toString();

	updateStatus("Next test is " + name);

	return name;
	}

	/**
	* 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}.
	*/
	@NonNull private 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());
	}

	/**
	* 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);
	}
	}