Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add connect HID/NAP BT stress test

Browse Source 
Change-Id: I6480510cbb88fb21fd9169d2dd0602e933a3beaf
This commit is contained in:
Eric Rowe
2010-12-07 16:32:53 -08:00
parent 627bf68e0e
commit 7e4d0c0982
3 changed files with 823 additions and 5 deletions
Download Patch File Download Diff File Expand all files Collapse all files

152
core/tests/coretests/src/android/bluetooth/BluetoothStressTest.java
View File

@@ -19,6 +19,16 @@ package android.bluetooth;
import android.content.Context;
import android.test.InstrumentationTestCase;
/**
* Stress test suite for Bluetooth related functions.
*
* Includes tests for enabling/disabling bluetooth, enabling/disabling discoverable mode,
* starting/stopping scans, connecting/disconnecting to HFP, A2DP, HID, PAN profiles, and verifying
* that remote connections/disconnections occur for the PAN profile.
* <p>
* This test suite uses {@link android.bluetooth.BluetoothTestRunner} to for parameters such as the
* number of iterations and the addresses of remote Bluetooth devices.
*/
public class BluetoothStressTest extends InstrumentationTestCase {
private static final String TAG = "BluetoothStressTest";
private static final String OUTPUT_FILE = "BluetoothStressTestOutput.txt";
@@ -40,6 +50,9 @@ public class BluetoothStressTest extends InstrumentationTestCase {
mTestUtils.close();
}
/**
* Stress test for enabling and disabling Bluetooth.
*/
public void testEnable() {
int iterations = BluetoothTestRunner.sEnableIterations;
if (iterations == 0) {
@@ -55,6 +68,9 @@ public class BluetoothStressTest extends InstrumentationTestCase {
}
}
/**
* Stress test for putting the device in and taking the device out of discoverable mode.
*/
public void testDiscoverable() {
int iterations = BluetoothTestRunner.sDiscoverableIterations;
if (iterations == 0) {
@@ -73,6 +89,9 @@ public class BluetoothStressTest extends InstrumentationTestCase {
mTestUtils.disable(adapter);
}
/**
* Stress test for starting and stopping Bluetooth scans.
*/
public void testScan() {
int iterations = BluetoothTestRunner.sScanIterations;
if (iterations == 0) {
@@ -91,6 +110,30 @@ public class BluetoothStressTest extends InstrumentationTestCase {
mTestUtils.disable(adapter);
}
/**
* Stress test for enabling and disabling the PAN NAP profile.
*/
public void testEnablePan() {
int iterations = BluetoothTestRunner.sEnablePanIterations;
BluetoothAdapter adapter = BluetoothAdapter.getDefaultAdapter();
mTestUtils.enable(adapter);
for (int i = 0; i < iterations; i++) {
mTestUtils.writeOutput("testEnablePan iteration " + (i + 1) + " of "
+ iterations);
mTestUtils.enablePan(adapter);
mTestUtils.disablePan(adapter);
}
mTestUtils.disable(adapter);
}
/**
* Stress test for pairing and unpairing with a remote device.
* <p>
* In this test, the local device initiates pairing with a remote device, and then unpairs with
* the device after the pairing has successfully completed.
*/
public void testPair() {
int iterations = BluetoothTestRunner.sPairIterations;
if (iterations == 0) {
@@ -110,6 +153,12 @@ public class BluetoothStressTest extends InstrumentationTestCase {
mTestUtils.disable(adapter);
}
/**
* Stress test for accepting a pairing request and unpairing with a remote device.
* <p>
* In this test, the local device waits for a pairing request from a remote device. It accepts
* the request and then unpairs after the paring has successfully completed.
*/
public void testAcceptPair() {
int iterations = BluetoothTestRunner.sPairIterations;
BluetoothAdapter adapter = BluetoothAdapter.getDefaultAdapter();
@@ -125,6 +174,12 @@ public class BluetoothStressTest extends InstrumentationTestCase {
mTestUtils.disable(adapter);
}
/**
* Stress test for connecting and disconnecting with an A2DP source.
* <p>
* In this test, the local device plays the role of an A2DP sink, and initiates connections and
* disconnections with an A2DP source.
*/
public void testConnectA2dp() {
int iterations = BluetoothTestRunner.sConnectA2dpIterations;
if (iterations == 0) {
@@ -143,10 +198,16 @@ public class BluetoothStressTest extends InstrumentationTestCase {
mTestUtils.disconnectProfile(adapter, device, BluetoothProfile.A2DP);
}
// TODO: Unpair from device if device can accept pairing after unpairing
mTestUtils.unpair(adapter, device);
mTestUtils.disable(adapter);
}
/**
* Stress test for connecting and disconnecting the HFP with a hands free device.
* <p>
* In this test, the local device plays the role of an HFP audio gateway, and initiates
* connections and disconnections with a hands free device.
*/
public void testConnectHeadset() {
int iterations = BluetoothTestRunner.sConnectHeadsetIterations;
if (iterations == 0) {
@@ -165,7 +226,94 @@ public class BluetoothStressTest extends InstrumentationTestCase {
mTestUtils.disconnectProfile(adapter, device, BluetoothProfile.HEADSET);
}
// TODO: Unpair from device if device can accept pairing after unpairing
mTestUtils.unpair(adapter, device);
mTestUtils.disable(adapter);
}
/**
* Stress test for connecting and disconnecting with a HID device.
* <p>
* In this test, the local device plays the role of a HID host, and initiates connections and
* disconnections with a HID device.
*/
public void testConnectInput() {
int iterations = BluetoothTestRunner.sConnectInputIterations;
if (iterations == 0) {
return;
}
BluetoothAdapter adapter = BluetoothAdapter.getDefaultAdapter();
BluetoothDevice device = adapter.getRemoteDevice(BluetoothTestRunner.sInputAddress);
mTestUtils.enable(adapter);
mTestUtils.pair(adapter, device, BluetoothTestRunner.sPairPasskey,
BluetoothTestRunner.sPairPin);
for (int i = 0; i < iterations; i++) {
mTestUtils.writeOutput("connectInput iteration " + (i + 1) + " of " + iterations);
mTestUtils.connectInput(adapter, device);
mTestUtils.disconnectInput(adapter, device);
}
mTestUtils.unpair(adapter, device);
mTestUtils.disable(adapter);
}
/**
* Stress test for connecting and disconnecting with a PAN NAP.
* <p>
* In this test, the local device plays the role of a PANU, and initiates connections and
* disconnections with a NAP.
*/
public void testConnectPan() {
int iterations = BluetoothTestRunner.sConnectPanIterations;
if (iterations == 0) {
return;
}
BluetoothAdapter adapter = BluetoothAdapter.getDefaultAdapter();
BluetoothDevice device = adapter.getRemoteDevice(BluetoothTestRunner.sPanAddress);
mTestUtils.enable(adapter);
mTestUtils.pair(adapter, device, BluetoothTestRunner.sPairPasskey,
BluetoothTestRunner.sPairPin);
for (int i = 0; i < iterations; i++) {
mTestUtils.writeOutput("connectPan iteration " + (i + 1) + " of " + iterations);
mTestUtils.connectPan(adapter, device);
mTestUtils.disconnectPan(adapter, device);
}
mTestUtils.unpair(adapter, device);
mTestUtils.disable(adapter);
}
/**
* Stress test for verifying a PANU connecting and disconnecting with the device.
* <p>
* In this test, the local device plays the role of a NAP which a remote PANU connects and
* disconnects from.
*/
public void testIncomingPanConnection() {
int iterations = BluetoothTestRunner.sConnectPanIterations;
if (iterations == 0) {
return;
}
BluetoothAdapter adapter = BluetoothAdapter.getDefaultAdapter();
BluetoothDevice device = adapter.getRemoteDevice(BluetoothTestRunner.sPanAddress);
mTestUtils.enable(adapter);
mTestUtils.enablePan(adapter);
mTestUtils.acceptPair(adapter, device, BluetoothTestRunner.sPairPasskey,
BluetoothTestRunner.sPairPin);
for (int i = 0; i < iterations; i++) {
mTestUtils.writeOutput("incomingPanConnection iteration " + (i + 1) + " of "
+ iterations);
mTestUtils.incomingPanConnection(adapter, device);
mTestUtils.incomingPanDisconnection(adapter, device);
}
mTestUtils.unpair(adapter, device);
mTestUtils.disablePan(adapter);
mTestUtils.disable(adapter);
}
}

73
core/tests/coretests/src/android/bluetooth/BluetoothTestRunner.java
View File

@@ -23,19 +23,51 @@ import android.test.InstrumentationTestRunner;
import android.test.InstrumentationTestSuite;
import android.util.Log;
/**
* Instrumentation test runner for Bluetooth tests.
* <p>
* To run:
* <pre>
* {@code
* adb shell am instrument \
* [-e enable_iterations <iterations>] \
* [-e discoverable_iterations <iterations>] \
* [-e scan_iterations <iterations>] \
* [-e enable_pan_iterations <iterations>] \
* [-e pair_iterations <iterations>] \
* [-e connect_a2dp_iterations <iterations>] \
* [-e connect_headset_iterations <iterations>] \
* [-e connect_input_iterations <iterations>] \
* [-e connect_pan_iterations <iterations>] \
* [-e pair_address <address>] \
* [-e headset_address <address>] \
* [-e a2dp_address <address>] \
* [-e input_address <address>] \
* [-e pan_address <address>] \
* [-e pair_pin <pin>] \
* [-e pair_passkey <passkey>] \
* -w com.android.frameworks.coretests/android.bluetooth.BluetoothTestRunner
* }
* </pre>
*/
public class BluetoothTestRunner extends InstrumentationTestRunner {
private static final String TAG = "BluetoothTestRunner";
public static int sEnableIterations = 100;
public static int sDiscoverableIterations = 1000;
public static int sScanIterations = 1000;
public static int sEnablePanIterations = 1000;
public static int sPairIterations = 100;
public static int sConnectHeadsetIterations = 100;
public static int sConnectA2dpIterations = 100;
public static int sConnectInputIterations = 100;
public static int sConnectPanIterations = 100;
public static String sPairAddress = "";
public static String sHeadsetAddress = "";
public static String sA2dpAddress = "";
public static String sInputAddress = "";
public static String sPanAddress = "";
public static byte[] sPairPin = {'1', '2', '3', '4'};
public static int sPairPasskey = 123456;
@@ -81,6 +113,15 @@ public class BluetoothTestRunner extends InstrumentationTestRunner {
}
}
val = arguments.getString("enable_pan_iterations");
if (val != null) {
try {
sEnablePanIterations = Integer.parseInt(val);
} catch (NumberFormatException e) {
// Invalid argument, fall back to default value
}
}
val = arguments.getString("pair_iterations");
if (val != null) {
try {
@@ -108,6 +149,24 @@ public class BluetoothTestRunner extends InstrumentationTestRunner {
}
}
val = arguments.getString("connect_input_iterations");
if (val != null) {
try {
sConnectInputIterations = Integer.parseInt(val);
} catch (NumberFormatException e) {
// Invalid argument, fall back to default value
}
}
val = arguments.getString("connect_pan_iterations");
if (val != null) {
try {
sConnectPanIterations = Integer.parseInt(val);
} catch (NumberFormatException e) {
// Invalid argument, fall back to default value
}
}
val = arguments.getString("pair_address");
if (val != null) {
sPairAddress = val;
@@ -123,6 +182,16 @@ public class BluetoothTestRunner extends InstrumentationTestRunner {
sA2dpAddress = val;
}
val = arguments.getString("input_address");
if (val != null) {
sInputAddress = val;
}
val = arguments.getString("pan_address");
if (val != null) {
sPanAddress = val;
}
val = arguments.getString("pair_pin");
if (val != null) {
sPairPin = BluetoothDevice.convertPinToBytes(val);
@@ -143,9 +212,13 @@ public class BluetoothTestRunner extends InstrumentationTestRunner {
Log.i(TAG, String.format("pair_iterations=%d", sPairIterations));
Log.i(TAG, String.format("connect_a2dp_iterations=%d", sConnectA2dpIterations));
Log.i(TAG, String.format("connect_headset_iterations=%d", sConnectHeadsetIterations));
Log.i(TAG, String.format("connect_input_iterations=%d", sConnectInputIterations));
Log.i(TAG, String.format("connect_pan_iterations=%d", sConnectPanIterations));
Log.i(TAG, String.format("pair_address=%s", sPairAddress));
Log.i(TAG, String.format("a2dp_address=%s", sA2dpAddress));
Log.i(TAG, String.format("headset_address=%s", sHeadsetAddress));
Log.i(TAG, String.format("input_address=%s", sInputAddress));
Log.i(TAG, String.format("pan_address=%s", sPanAddress));
Log.i(TAG, String.format("pair_pin=%s", new String(sPairPin)));
Log.i(TAG, String.format("pair_passkey=%d", sPairPasskey));

603
core/tests/coretests/src/android/bluetooth/BluetoothTestUtils.java
View File

@@ -270,6 +270,91 @@ public class BluetoothTestUtils extends Assert {
}
}
private class ConnectInputReceiver extends FlagReceiver {
private static final int STATE_DISCONNECTED_FLAG = 1;
private static final int STATE_CONNECTING_FLAG = 1 << 1;
private static final int STATE_CONNECTED_FLAG = 1 << 2;
private static final int STATE_DISCONNECTING_FLAG = 1 << 3;
private BluetoothDevice mDevice;
public ConnectInputReceiver(BluetoothDevice device, int expectedFlags) {
super(expectedFlags);
mDevice = device;
}
@Override
public void onReceive(Context context, Intent intent) {
if (!mDevice.equals(intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE))) {
return;
}
if (BluetoothInputDevice.ACTION_INPUT_DEVICE_STATE_CHANGED.equals(intent.getAction())) {
int state = intent.getIntExtra(BluetoothInputDevice.EXTRA_INPUT_DEVICE_STATE, -1);
assertNotSame(-1, state);
switch (state) {
case BluetoothInputDevice.STATE_DISCONNECTED:
setFiredFlag(STATE_DISCONNECTED_FLAG);
break;
case BluetoothInputDevice.STATE_CONNECTING:
setFiredFlag(STATE_CONNECTING_FLAG);
break;
case BluetoothInputDevice.STATE_CONNECTED:
setFiredFlag(STATE_CONNECTED_FLAG);
break;
case BluetoothInputDevice.STATE_DISCONNECTING:
setFiredFlag(STATE_DISCONNECTING_FLAG);
break;
}
}
}
}
private class ConnectPanReceiver extends FlagReceiver {
private static final int STATE_DISCONNECTED_FLAG = 1;
private static final int STATE_CONNECTING_FLAG = 1 << 1;
private static final int STATE_CONNECTED_FLAG = 1 << 2;
private static final int STATE_DISCONNECTING_FLAG = 1 << 3;
private BluetoothDevice mDevice;
private int mRole;
public ConnectPanReceiver(BluetoothDevice device, int role, int expectedFlags) {
super (expectedFlags);
mDevice = device;
mRole = role;
}
@Override
public void onReceive(Context context, Intent intent) {
if (!mDevice.equals(intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE))
|| mRole != intent.getIntExtra(BluetoothPan.EXTRA_LOCAL_ROLE, -1)) {
return;
}
if (BluetoothPan.ACTION_PAN_STATE_CHANGED.equals(intent.getAction())) {
int state = intent.getIntExtra(BluetoothPan.EXTRA_PAN_STATE, -1);
assertNotSame(-1, state);
switch (state) {
case BluetoothPan.STATE_DISCONNECTED:
setFiredFlag(STATE_DISCONNECTED_FLAG);
break;
case BluetoothPan.STATE_CONNECTING:
setFiredFlag(STATE_CONNECTING_FLAG);
break;
case BluetoothPan.STATE_CONNECTED:
setFiredFlag(STATE_CONNECTED_FLAG);
break;
case BluetoothPan.STATE_DISCONNECTING:
setFiredFlag(STATE_DISCONNECTING_FLAG);
break;
}
}
}
}
private BluetoothProfile.ServiceListener mServiceListener =
new BluetoothProfile.ServiceListener() {
public void onServiceConnected(int profile, BluetoothProfile proxy) {
@@ -309,10 +394,24 @@ public class BluetoothTestUtils extends Assert {
private BluetoothA2dp mA2dp;
private BluetoothHeadset mHeadset;
/**
* Creates a utility instance for testing Bluetooth.
*
* @param context The context of the application using the utility.
* @param tag The log tag of the application using the utility.
*/
public BluetoothTestUtils(Context context, String tag) {
this(context, tag, null);
}
/**
* Creates a utility instance for testing Bluetooth.
*
* @param context The context of the application using the utility.
* @param tag The log tag of the application using the utility.
* @param outputFile The path to an output file if the utility is to write results to a
* separate file.
*/
public BluetoothTestUtils(Context context, String tag, String outputFile) {
mContext = context;
mTag = tag;
@@ -331,6 +430,9 @@ public class BluetoothTestUtils extends Assert {
}
}
/**
* Closes the utility instance and unregisters any BroadcastReceivers.
*/
public void close() {
while (!mReceivers.isEmpty()) {
mContext.unregisterReceiver(mReceivers.remove(0));
@@ -345,6 +447,12 @@ public class BluetoothTestUtils extends Assert {
}
}
/**
* Enables Bluetooth and checks to make sure that Bluetooth was turned on and that the correct
* actions were broadcast.
*
* @param adapter The BT adapter.
*/
public void enable(BluetoothAdapter adapter) {
int mask = (BluetoothReceiver.STATE_TURNING_ON_FLAG | BluetoothReceiver.STATE_ON_FLAG
| BluetoothReceiver.SCAN_MODE_CONNECTABLE_FLAG);
@@ -399,6 +507,12 @@ public class BluetoothTestUtils extends Assert {
state, BluetoothAdapter.STATE_ON, firedFlags, mask));
}
/**
* Disables Bluetooth and checks to make sure that Bluetooth was turned off and that the correct
* actions were broadcast.
*
* @param adapter The BT adapter.
*/
public void disable(BluetoothAdapter adapter) {
int mask = (BluetoothReceiver.STATE_TURNING_OFF_FLAG | BluetoothReceiver.STATE_OFF_FLAG
| BluetoothReceiver.SCAN_MODE_NONE_FLAG);
@@ -453,6 +567,12 @@ public class BluetoothTestUtils extends Assert {
state, BluetoothAdapter.STATE_OFF, firedFlags, mask));
}
/**
* Puts the local device into discoverable mode and checks to make sure that the local device
* is in discoverable mode and that the correct actions were broadcast.
*
* @param adapter The BT adapter.
*/
public void discoverable(BluetoothAdapter adapter) {
int mask = BluetoothReceiver.SCAN_MODE_CONNECTABLE_DISCOVERABLE_FLAG;
@@ -490,6 +610,12 @@ public class BluetoothTestUtils extends Assert {
firedFlags, mask));
}
/**
* Puts the local device into connectable only mode and checks to make sure that the local
* device is in in connectable mode and that the correct actions were broadcast.
*
* @param adapter The BT adapter.
*/
public void undiscoverable(BluetoothAdapter adapter) {
int mask = BluetoothReceiver.SCAN_MODE_CONNECTABLE_FLAG;
@@ -527,6 +653,12 @@ public class BluetoothTestUtils extends Assert {
mask));
}
/**
* Starts a scan for remote devices and checks to make sure that the local device is scanning
* and that the correct actions were broadcast.
*
* @param adapter The BT adapter.
*/
public void startScan(BluetoothAdapter adapter) {
int mask = BluetoothReceiver.DISCOVERY_STARTED_FLAG;
@@ -559,6 +691,12 @@ public class BluetoothTestUtils extends Assert {
adapter.isDiscovering(), firedFlags, mask));
}
/**
* Stops a scan for remote devices and checks to make sure that the local device is not scanning
* and that the correct actions were broadcast.
*
* @param adapter The BT adapter.
*/
public void stopScan(BluetoothAdapter adapter) {
int mask = BluetoothReceiver.DISCOVERY_FINISHED_FLAG;
@@ -593,20 +731,84 @@ public class BluetoothTestUtils extends Assert {
}
/**
* Enables PAN tethering on the local device and checks to make sure that tethering is enabled.
*
* @param adapter The BT adapter.
*/
public void enablePan(BluetoothAdapter adapter) {
BluetoothPan pan = new BluetoothPan(mContext);
assertNotNull(pan);
long start = System.currentTimeMillis();
pan.setBluetoothTethering(true);
long stop = System.currentTimeMillis();
assertTrue(pan.isTetheringOn());
writeOutput(String.format("enablePan() completed in %d ms", (stop - start)));
}
/**
* Disables PAN tethering on the local device and checks to make sure that tethering is
* disabled.
*
* @param adapter The BT adapter.
*/
public void disablePan(BluetoothAdapter adapter) {
BluetoothPan pan = new BluetoothPan(mContext);
assertNotNull(pan);
long start = System.currentTimeMillis();
pan.setBluetoothTethering(false);
long stop = System.currentTimeMillis();
assertFalse(pan.isTetheringOn());
writeOutput(String.format("disablePan() completed in %d ms", (stop - start)));
}
/**
* Initiates a pairing with a remote device and checks to make sure that the devices are paired
* and that the correct actions were broadcast.
*
* @param adapter The BT adapter.
* @param device The remote device.
* @param passkey The pairing passkey if pairing requires a passkey. Any value if not.
* @param pin The pairing pin if pairing requires a pin. Any value if not.
*/
public void pair(BluetoothAdapter adapter, BluetoothDevice device, int passkey, byte[] pin) {
pairOrAcceptPair(adapter, device, passkey, pin, true);
}
/**
* Accepts a pairing with a remote device and checks to make sure that the devices are paired
* and that the correct actions were broadcast.
*
* @param adapter The BT adapter.
* @param device The remote device.
* @param passkey The pairing passkey if pairing requires a passkey. Any value if not.
* @param pin The pairing pin if pairing requires a pin. Any value if not.
*/
public void acceptPair(BluetoothAdapter adapter, BluetoothDevice device, int passkey,
byte[] pin) {
pairOrAcceptPair(adapter, device, passkey, pin, false);
}
/**
* Helper method used by {@link #pair(BluetoothAdapter, BluetoothDevice, int, byte[])} and
* {@link #acceptPair(BluetoothAdapter, BluetoothDevice, int, byte[])} to either pair or accept
* a pairing request.
*
* @param adapter The BT adapter.
* @param device The remote device.
* @param passkey The pairing passkey if pairing requires a passkey. Any value if not.
* @param pin The pairing pin if pairing requires a pin. Any value if not.
* @param shouldPair Whether to pair or accept the pair.
*/
private void pairOrAcceptPair(BluetoothAdapter adapter, BluetoothDevice device, int passkey,
byte[] pin, boolean pair) {
byte[] pin, boolean shouldPair) {
int mask = PairReceiver.STATE_BONDING_FLAG | PairReceiver.STATE_BONDED_FLAG;
long start = -1;
String methodName = pair ? "pair()" : "acceptPair()";
String methodName = shouldPair ? "pair()" : "acceptPair()";
if (!adapter.isEnabled()) {
fail(methodName + " bluetooth not enabled");
@@ -619,7 +821,7 @@ public class BluetoothTestUtils extends Assert {
case BluetoothDevice.BOND_NONE:
assertFalse(adapter.getBondedDevices().contains(device));
start = System.currentTimeMillis();
if (pair) {
if (shouldPair) {
assertTrue(device.createBond());
}
break;
@@ -660,6 +862,13 @@ public class BluetoothTestUtils extends Assert {
BluetoothDevice.BOND_BONDED, firedFlags, mask));
}
/**
* Deletes a pairing with a remote device and checks to make sure that the devices are unpaired
* and that the correct actions were broadcast.
*
* @param adapter The BT adapter.
* @param device The remote device.
*/
public void unpair(BluetoothAdapter adapter, BluetoothDevice device) {
int mask = PairReceiver.STATE_NONE_FLAG;
long start = -1;
@@ -714,6 +923,15 @@ public class BluetoothTestUtils extends Assert {
firedFlags, mask));
}
/**
* Connects a profile from the local device to a remote device and checks to make sure that the
* profile is connected and that the correct actions were broadcast.
*
* @param adapter The BT adapter.
* @param device The remote device.
* @param profile The profile to connect. One of {@link BluetoothProfile#A2DP} or
* {@link BluetoothProfile#HEADSET}.
*/
public void connectProfile(BluetoothAdapter adapter, BluetoothDevice device, int profile) {
int mask = (ConnectProfileReceiver.STATE_CONNECTING_FLAG
| ConnectProfileReceiver.STATE_CONNECTED_FLAG);
@@ -782,6 +1000,15 @@ public class BluetoothTestUtils extends Assert {
BluetoothProfile.STATE_CONNECTED, firedFlags, mask));
}
/**
* Disconnects a profile between the local device and a remote device and checks to make sure
* that the profile is disconnected and that the correct actions were broadcast.
*
* @param adapter The BT adapter.
* @param device The remote device.
* @param profile The profile to disconnect. One of {@link BluetoothProfile#A2DP} or
* {@link BluetoothProfile#HEADSET}.
*/
public void disconnectProfile(BluetoothAdapter adapter, BluetoothDevice device, int profile) {
int mask = (ConnectProfileReceiver.STATE_DISCONNECTING_FLAG
| ConnectProfileReceiver.STATE_DISCONNECTED_FLAG);
@@ -850,6 +1077,360 @@ public class BluetoothTestUtils extends Assert {
BluetoothProfile.STATE_DISCONNECTED, firedFlags, mask));
}
/**
* Connects the local device with a remote HID device and checks to make sure that the profile
* is connected and that the correct actions were broadcast.
*
* @param adapter The BT adapter.
* @param device The remote device.
*/
public void connectInput(BluetoothAdapter adapter, BluetoothDevice device) {
int mask = (ConnectInputReceiver.STATE_CONNECTING_FLAG
| ConnectInputReceiver.STATE_CONNECTED_FLAG);
long start = -1;
if (!adapter.isEnabled()) {
fail(String.format("connectInput() bluetooth not enabled: device=%s", device));
}
if (!adapter.getBondedDevices().contains(device)) {
fail(String.format("connectInput() device not paired: device=%s", device));
}
BluetoothInputDevice inputDevice = new BluetoothInputDevice(mContext);
assertNotNull(inputDevice);
ConnectInputReceiver receiver = getConnectInputReceiver(device, mask);
int state = inputDevice.getInputDeviceState(device);
switch (state) {
case BluetoothInputDevice.STATE_CONNECTED:
removeReceiver(receiver);
return;
case BluetoothInputDevice.STATE_CONNECTING:
mask = 0; // Don't check for received intents since we might have missed them.
break;
case BluetoothInputDevice.STATE_DISCONNECTED:
case BluetoothInputDevice.STATE_DISCONNECTING:
start = System.currentTimeMillis();
assertTrue(inputDevice.connectInputDevice(device));
break;
default:
removeReceiver(receiver);
fail(String.format("connectInput() invalid state: device=%s, state=%d", device,
state));
}
long s = System.currentTimeMillis();
while (System.currentTimeMillis() - s < CONNECT_DISCONNECT_PROFILE_TIMEOUT) {
state = inputDevice.getInputDeviceState(device);
if (state == BluetoothInputDevice.STATE_CONNECTED
&& (receiver.getFiredFlags() & mask) == mask) {
long finish = receiver.getCompletedTime();
if (start != -1 && finish != -1) {
writeOutput(String.format("connectInput() completed in %d ms: device=%s",
(finish - start), device));
} else {
writeOutput(String.format("connectInput() completed: device=%s", device));
}
removeReceiver(receiver);
return;
}
sleep(POLL_TIME);
}
int firedFlags = receiver.getFiredFlags();
removeReceiver(receiver);
fail(String.format("connectInput() timeout: device=%s, state=%d (expected %d), "
+ "flags=0x%x (expected 0x%s)", device, state, BluetoothInputDevice.STATE_CONNECTED,
firedFlags, mask));
}
/**
* Disconnects the local device with a remote HID device and checks to make sure that the
* profile is connected and that the correct actions were broadcast.
*
* @param adapter The BT adapter.
* @param device The remote device.
*/
public void disconnectInput(BluetoothAdapter adapter, BluetoothDevice device) {
int mask = (ConnectInputReceiver.STATE_DISCONNECTING_FLAG
| ConnectInputReceiver.STATE_DISCONNECTED_FLAG);
long start = -1;
if (!adapter.isEnabled()) {
fail(String.format("disconnectInput() bluetooth not enabled: device=%s", device));
}
if (!adapter.getBondedDevices().contains(device)) {
fail(String.format("disconnectInput() device not paired: device=%s", device));
}
BluetoothInputDevice inputDevice = new BluetoothInputDevice(mContext);
assertNotNull(inputDevice);
ConnectInputReceiver receiver = getConnectInputReceiver(device, mask);
int state = inputDevice.getInputDeviceState(device);
switch (state) {
case BluetoothInputDevice.STATE_CONNECTED:
case BluetoothInputDevice.STATE_CONNECTING:
start = System.currentTimeMillis();
assertTrue(inputDevice.disconnectInputDevice(device));
break;
case BluetoothInputDevice.STATE_DISCONNECTED:
removeReceiver(receiver);
return;
case BluetoothInputDevice.STATE_DISCONNECTING:
mask = 0; // Don't check for received intents since we might have missed them.
break;
default:
removeReceiver(receiver);
fail(String.format("disconnectInput() invalid state: device=%s, state=%d", device,
state));
}
long s = System.currentTimeMillis();
while (System.currentTimeMillis() - s < CONNECT_DISCONNECT_PROFILE_TIMEOUT) {
state = inputDevice.getInputDeviceState(device);
if (state == BluetoothInputDevice.STATE_DISCONNECTED
&& (receiver.getFiredFlags() & mask) == mask) {
long finish = receiver.getCompletedTime();
if (start != -1 && finish != -1) {
writeOutput(String.format("disconnectInput() completed in %d ms: device=%s",
(finish - start), device));
} else {
writeOutput(String.format("disconnectInput() completed: device=%s", device));
}
removeReceiver(receiver);
return;
}
sleep(POLL_TIME);
}
int firedFlags = receiver.getFiredFlags();
removeReceiver(receiver);
fail(String.format("disconnectInput() timeout: device=%s, state=%d (expected %d), "
+ "flags=0x%x (expected 0x%s)", device, state,
BluetoothInputDevice.STATE_DISCONNECTED, firedFlags, mask));
}
/**
* Connects the PANU to a remote NAP and checks to make sure that the PANU is connected and that
* the correct actions were broadcast.
*
* @param adapter The BT adapter.
* @param device The remote device.
*/
public void connectPan(BluetoothAdapter adapter, BluetoothDevice device) {
connectPanOrIncomingPanConnection(adapter, device, true);
}
/**
* Checks that a remote PANU connects to the local NAP correctly and that the correct actions
* were broadcast.
*
* @param adapter The BT adapter.
* @param device The remote device.
*/
public void incomingPanConnection(BluetoothAdapter adapter, BluetoothDevice device) {
connectPanOrIncomingPanConnection(adapter, device, false);
}
/**
* Helper method used by {@link #connectPan(BluetoothAdapter, BluetoothDevice)} and
* {@link #incomingPanConnection(BluetoothAdapter, BluetoothDevice)} to either connect to a
* remote NAP or verify that a remote device connected to the local NAP.
*
* @param adapter The BT adapter.
* @param device The remote device.
* @param connect If the method should initiate the connection (is PANU)
*/
private void connectPanOrIncomingPanConnection(BluetoothAdapter adapter, BluetoothDevice device,
boolean connect) {
long start = -1;
int mask, role;
String methodName;
if (connect) {
methodName = "connectPan()";
mask = (ConnectPanReceiver.STATE_CONNECTED_FLAG |
ConnectPanReceiver.STATE_CONNECTING_FLAG);
role = BluetoothPan.LOCAL_PANU_ROLE;
} else {
methodName = "incomingPanConnection()";
mask = ConnectPanReceiver.STATE_CONNECTED_FLAG;
role = BluetoothPan.LOCAL_NAP_ROLE;
}
if (!adapter.isEnabled()) {
fail(String.format("%s bluetooth not enabled: device=%s", methodName, device));
}
if (!adapter.getBondedDevices().contains(device)) {
fail(String.format("%s device not paired: device=%s", methodName, device));
}
BluetoothPan pan = new BluetoothPan(mContext);
assertNotNull(pan);
ConnectPanReceiver receiver = getConnectPanReceiver(device, role, mask);
int state = pan.getPanDeviceState(device);
switch (state) {
case BluetoothPan.STATE_CONNECTED:
removeReceiver(receiver);
return;
case BluetoothPan.STATE_CONNECTING:
mask = 0; // Don't check for received intents since we might have missed them.
break;
case BluetoothPan.STATE_DISCONNECTED:
case BluetoothPan.STATE_DISCONNECTING:
start = System.currentTimeMillis();
if (role == BluetoothPan.LOCAL_PANU_ROLE) {
Log.i("BT", "connect to pan");
assertTrue(pan.connect(device));
}
break;
default:
removeReceiver(receiver);
fail(String.format("%s invalid state: device=%s, state=%d", methodName, device,
state));
}
long s = System.currentTimeMillis();
while (System.currentTimeMillis() - s < CONNECT_DISCONNECT_PROFILE_TIMEOUT) {
state = pan.getPanDeviceState(device);
if (state == BluetoothPan.STATE_CONNECTED
&& (receiver.getFiredFlags() & mask) == mask) {
long finish = receiver.getCompletedTime();
if (start != -1 && finish != -1) {
writeOutput(String.format("%s completed in %d ms: device=%s", methodName,
(finish - start), device));
} else {
writeOutput(String.format("%s completed: device=%s", methodName, device));
}
removeReceiver(receiver);
return;
}
sleep(POLL_TIME);
}
int firedFlags = receiver.getFiredFlags();
removeReceiver(receiver);
fail(String.format("%s timeout: device=%s, state=%d (expected %d), "
+ "flags=0x%x (expected 0x%s)", methodName, device, state,
BluetoothPan.STATE_CONNECTED, firedFlags, mask));
}
/**
* Disconnects the PANU from a remote NAP and checks to make sure that the PANU is disconnected
* and that the correct actions were broadcast.
*
* @param adapter The BT adapter.
* @param device The remote device.
*/
public void disconnectPan(BluetoothAdapter adapter, BluetoothDevice device) {
disconnectFromRemoteOrVerifyConnectNap(adapter, device, true);
}
/**
* Checks that a remote PANU disconnects from the local NAP correctly and that the correct
* actions were broadcast.
*
* @param adapter The BT adapter.
* @param device The remote device.
*/
public void incomingPanDisconnection(BluetoothAdapter adapter, BluetoothDevice device) {
disconnectFromRemoteOrVerifyConnectNap(adapter, device, false);
}
/**
* Helper method used by {@link #disconnectPan(BluetoothAdapter, BluetoothDevice)} and
* {@link #incomingPanDisconnection(BluetoothAdapter, BluetoothDevice)} to either disconnect
* from a remote NAP or verify that a remote device disconnected from the local NAP.
*
* @param adapter The BT adapter.
* @param device The remote device.
* @param disconnect Whether the method should connect or verify.
*/
private void disconnectFromRemoteOrVerifyConnectNap(BluetoothAdapter adapter,
BluetoothDevice device, boolean disconnect) {
long start = -1;
int mask, role;
String methodName;
if (disconnect) {
methodName = "disconnectPan()";
mask = (ConnectPanReceiver.STATE_DISCONNECTED_FLAG |
ConnectPanReceiver.STATE_DISCONNECTING_FLAG);
role = BluetoothPan.LOCAL_PANU_ROLE;
} else {
methodName = "incomingPanDisconnection()";
mask = ConnectPanReceiver.STATE_DISCONNECTED_FLAG;
role = BluetoothPan.LOCAL_NAP_ROLE;
}
if (!adapter.isEnabled()) {
fail(String.format("%s bluetooth not enabled: device=%s", methodName, device));
}
if (!adapter.getBondedDevices().contains(device)) {
fail(String.format("%s device not paired: device=%s", methodName, device));
}
BluetoothPan pan = new BluetoothPan(mContext);
assertNotNull(pan);
ConnectPanReceiver receiver = getConnectPanReceiver(device, role, mask);
int state = pan.getPanDeviceState(device);
switch (state) {
case BluetoothInputDevice.STATE_CONNECTED:
case BluetoothInputDevice.STATE_CONNECTING:
start = System.currentTimeMillis();
if (role == BluetoothPan.LOCAL_PANU_ROLE) {
assertTrue(pan.disconnect(device));
}
break;
case BluetoothInputDevice.STATE_DISCONNECTED:
removeReceiver(receiver);
return;
case BluetoothInputDevice.STATE_DISCONNECTING:
mask = 0; // Don't check for received intents since we might have missed them.
break;
default:
removeReceiver(receiver);
fail(String.format("%s invalid state: device=%s, state=%d", methodName, device,
state));
}
long s = System.currentTimeMillis();
while (System.currentTimeMillis() - s < CONNECT_DISCONNECT_PROFILE_TIMEOUT) {
state = pan.getPanDeviceState(device);
if (state == BluetoothInputDevice.STATE_DISCONNECTED
&& (receiver.getFiredFlags() & mask) == mask) {
long finish = receiver.getCompletedTime();
if (start != -1 && finish != -1) {
writeOutput(String.format("%s completed in %d ms: device=%s", methodName,
(finish - start), device));
} else {
writeOutput(String.format("%s completed: device=%s", methodName, device));
}
removeReceiver(receiver);
return;
}
sleep(POLL_TIME);
}
int firedFlags = receiver.getFiredFlags();
removeReceiver(receiver);
fail(String.format("%s timeout: device=%s, state=%d (expected %d), "
+ "flags=0x%x (expected 0x%s)", methodName, device, state,
BluetoothInputDevice.STATE_DISCONNECTED, firedFlags, mask));
}
/**
* Writes a string to the logcat and a file if a file has been specified in the constructor.
*
* @param s The string to be written.
*/
public void writeOutput(String s) {
Log.i(mTag, s);
if (mOutputWriter == null) {
@@ -904,6 +1485,22 @@ public class BluetoothTestUtils extends Assert {
return receiver;
}
private ConnectInputReceiver getConnectInputReceiver(BluetoothDevice device,
int expectedFlags) {
String[] actions = {BluetoothInputDevice.ACTION_INPUT_DEVICE_STATE_CHANGED};
ConnectInputReceiver receiver = new ConnectInputReceiver(device, expectedFlags);
addReceiver(receiver, actions);
return receiver;
}
private ConnectPanReceiver getConnectPanReceiver(BluetoothDevice device, int role,
int expectedFlags) {
String[] actions = {BluetoothPan.ACTION_PAN_STATE_CHANGED};
ConnectPanReceiver receiver = new ConnectPanReceiver(device, role, expectedFlags);
addReceiver(receiver, actions);
return receiver;
}
private void removeReceiver(BroadcastReceiver receiver) {
mContext.unregisterReceiver(receiver);
mReceivers.remove(receiver);