Merge "HFP: Reset battery level on HFP disconnect" (e4aa1e58) · Commits · e / os / android_packages_apps_Bluetooth

src/com/android/bluetooth/btservice/RemoteDevices.java

+42 −9

Original line number	Original line	Diff line number	Diff line
	@@ -21,6 +21,7 @@ import android.bluetooth.BluetoothAssignedNumbers;
	import android.bluetooth.BluetoothClass;		import android.bluetooth.BluetoothClass;
	import android.bluetooth.BluetoothDevice;		import android.bluetooth.BluetoothDevice;
	import android.bluetooth.BluetoothHeadset;		import android.bluetooth.BluetoothHeadset;
			import android.bluetooth.BluetoothProfile;
	import android.content.BroadcastReceiver;		import android.content.BroadcastReceiver;
	import android.content.Context;		import android.content.Context;
	import android.content.Intent;		import android.content.Intent;
	@@ -60,7 +61,6 @@ final class RemoteDevices {
	private final BroadcastReceiver mReceiver = new BroadcastReceiver() {		private final BroadcastReceiver mReceiver = new BroadcastReceiver() {
	@Override		@Override
	public void onReceive(Context context, Intent intent) {		public void onReceive(Context context, Intent intent) {
	Log.d(TAG, "Received intent: " + intent);
	String action = intent.getAction();		String action = intent.getAction();
	switch (action) {		switch (action) {
	case BluetoothHeadset.ACTION_HF_INDICATORS_VALUE_CHANGED:		case BluetoothHeadset.ACTION_HF_INDICATORS_VALUE_CHANGED:
	@@ -69,6 +69,9 @@ final class RemoteDevices {
	case BluetoothHeadset.ACTION_VENDOR_SPECIFIC_HEADSET_EVENT:		case BluetoothHeadset.ACTION_VENDOR_SPECIFIC_HEADSET_EVENT:
	onVendorSpecificHeadsetEvent(intent);		onVendorSpecificHeadsetEvent(intent);
	break;		break;
			case BluetoothHeadset.ACTION_CONNECTION_STATE_CHANGED:
			onHeadsetConnectionStateChanged(intent);
			break;
	default:		default:
	Log.w(TAG, "Unhandled intent: " + intent);		Log.w(TAG, "Unhandled intent: " + intent);
	break;		break;
	@@ -95,6 +98,7 @@ final class RemoteDevices {
	+ BluetoothAssignedNumbers.PLANTRONICS);		+ BluetoothAssignedNumbers.PLANTRONICS);
	filter.addCategory(BluetoothHeadset.VENDOR_SPECIFIC_HEADSET_EVENT_COMPANY_ID_CATEGORY + "."		filter.addCategory(BluetoothHeadset.VENDOR_SPECIFIC_HEADSET_EVENT_COMPANY_ID_CATEGORY + "."
	+ BluetoothAssignedNumbers.APPLE);		+ BluetoothAssignedNumbers.APPLE);
			filter.addAction(BluetoothHeadset.ACTION_CONNECTION_STATE_CHANGED);
	mAdapterService.registerReceiver(mReceiver, filter);		mAdapterService.registerReceiver(mReceiver, filter);
	}		}

	@@ -382,13 +386,8 @@ final class RemoteDevices {
	}		}
	deviceProperties.setBatteryLevel(batteryLevel);		deviceProperties.setBatteryLevel(batteryLevel);
	}		}
	Intent intent = new Intent(BluetoothDevice.ACTION_BATTERY_LEVEL_CHANGED);		sendBatteryLevelChangedBroadcast(device, batteryLevel);
	intent.putExtra(BluetoothDevice.EXTRA_DEVICE, device);		Log.d(TAG, "Updated device " + device + " battery level to " + batteryLevel + "%");
	intent.putExtra(BluetoothDevice.EXTRA_BATTERY_LEVEL, batteryLevel);
	intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT);
	mAdapterService.sendBroadcast(intent, AdapterService.BLUETOOTH_PERM);
	Log.d(TAG, "Updated device " + device + " battery level to " + String.valueOf(batteryLevel)
	+ "%");
	}		}

	/**		/**
	@@ -405,8 +404,24 @@ final class RemoteDevices {
	if (deviceProperties == null) {		if (deviceProperties == null) {
	return;		return;
	}		}
			synchronized (mObject) {
			if (deviceProperties.getBatteryLevel() == BluetoothDevice.BATTERY_LEVEL_UNKNOWN) {
			debugLog("Battery level was never set or is already reset, device=" + device);
			return;
			}
	deviceProperties.setBatteryLevel(BluetoothDevice.BATTERY_LEVEL_UNKNOWN);		deviceProperties.setBatteryLevel(BluetoothDevice.BATTERY_LEVEL_UNKNOWN);
	}		}
			sendBatteryLevelChangedBroadcast(device, BluetoothDevice.BATTERY_LEVEL_UNKNOWN);
			Log.d(TAG, "Reset battery level, device=" + device);
			}

			private void sendBatteryLevelChangedBroadcast(BluetoothDevice device, int batteryLevel) {
			Intent intent = new Intent(BluetoothDevice.ACTION_BATTERY_LEVEL_CHANGED);
			intent.putExtra(BluetoothDevice.EXTRA_DEVICE, device);
			intent.putExtra(BluetoothDevice.EXTRA_BATTERY_LEVEL, batteryLevel);
			intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT);
			mAdapterService.sendBroadcast(intent, AdapterService.BLUETOOTH_PERM);
			}

	void devicePropertyChangedCallback(byte[] address, int[] types, byte[][] values) {		void devicePropertyChangedCallback(byte[] address, int[] types, byte[][] values) {
	Intent intent;		Intent intent;
	@@ -579,6 +594,24 @@ final class RemoteDevices {
	mHandler.sendMessage(message);		mHandler.sendMessage(message);
	}		}

			/**
			* Handles headset connection state change event
			* @param intent must be {@link BluetoothHeadset#ACTION_CONNECTION_STATE_CHANGED} intent
			*/
			@VisibleForTesting
			void onHeadsetConnectionStateChanged(Intent intent) {
			BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
			if (device == null) {
			Log.e(TAG, "onHeadsetConnectionStateChanged() remote device is null");
			return;
			}
			if (intent.getIntExtra(BluetoothProfile.EXTRA_STATE, BluetoothProfile.STATE_DISCONNECTED)
			== BluetoothProfile.STATE_DISCONNECTED) {
			// TODO: Rework this when non-HFP sources of battery level indication is added
			resetBatteryLevel(device);
			}
			}

	@VisibleForTesting		@VisibleForTesting
	void onHfIndicatorValueChanged(Intent intent) {		void onHfIndicatorValueChanged(Intent intent) {
	BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);		BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);

tests/src/com/android/bluetooth/btservice/RemoteDevicesTest.java

+96 −19

Original line number	Original line	Diff line number	Diff line
	@@ -12,6 +12,7 @@ import android.bluetooth.BluetoothAdapter;
	import android.bluetooth.BluetoothAssignedNumbers;		import android.bluetooth.BluetoothAssignedNumbers;
	import android.bluetooth.BluetoothDevice;		import android.bluetooth.BluetoothDevice;
	import android.bluetooth.BluetoothHeadset;		import android.bluetooth.BluetoothHeadset;
			import android.bluetooth.BluetoothProfile;
	import android.content.Intent;		import android.content.Intent;
	import android.os.Looper;		import android.os.Looper;
	import android.support.test.runner.AndroidJUnit4;		import android.support.test.runner.AndroidJUnit4;
	@@ -68,7 +69,7 @@ public class RemoteDevicesTest {
	// Verify that updating battery level triggers ACTION_BATTERY_LEVEL_CHANGED intent		// Verify that updating battery level triggers ACTION_BATTERY_LEVEL_CHANGED intent
	mRemoteDevices.updateBatteryLevel(mDevice1, batteryLevel);		mRemoteDevices.updateBatteryLevel(mDevice1, batteryLevel);
	verify(mAdapterService).sendBroadcast(mIntentArgument.capture(), mStringArgument.capture());		verify(mAdapterService).sendBroadcast(mIntentArgument.capture(), mStringArgument.capture());
	verfyBatteryLevelChangedIntent(mDevice1, batteryLevel, mIntentArgument);		verifyBatteryLevelChangedIntent(mDevice1, batteryLevel, mIntentArgument);
	Assert.assertEquals(AdapterService.BLUETOOTH_PERM, mStringArgument.getValue());		Assert.assertEquals(AdapterService.BLUETOOTH_PERM, mStringArgument.getValue());

	// Verify that user can get battery level after the update		// Verify that user can get battery level after the update
	@@ -86,7 +87,7 @@ public class RemoteDevicesTest {
	verify(mAdapterService, times(2))		verify(mAdapterService, times(2))
	.sendBroadcast(mIntentArgument.capture(), mStringArgument.capture());		.sendBroadcast(mIntentArgument.capture(), mStringArgument.capture());
	Assert.assertEquals(AdapterService.BLUETOOTH_PERM, mStringArgument.getValue());		Assert.assertEquals(AdapterService.BLUETOOTH_PERM, mStringArgument.getValue());
	verfyBatteryLevelChangedIntent(mDevice1, batteryLevel, mIntentArgument);		verifyBatteryLevelChangedIntent(mDevice1, batteryLevel, mIntentArgument);

	// Verify that user can get battery level after the update		// Verify that user can get battery level after the update
	Assert.assertEquals(		Assert.assertEquals(
	@@ -151,7 +152,7 @@ public class RemoteDevicesTest {
	// Verify that updating battery level triggers ACTION_BATTERY_LEVEL_CHANGED intent		// Verify that updating battery level triggers ACTION_BATTERY_LEVEL_CHANGED intent
	mRemoteDevices.updateBatteryLevel(mDevice1, batteryLevel);		mRemoteDevices.updateBatteryLevel(mDevice1, batteryLevel);
	verify(mAdapterService).sendBroadcast(mIntentArgument.capture(), mStringArgument.capture());		verify(mAdapterService).sendBroadcast(mIntentArgument.capture(), mStringArgument.capture());
	verfyBatteryLevelChangedIntent(mDevice1, batteryLevel, mIntentArgument);		verifyBatteryLevelChangedIntent(mDevice1, batteryLevel, mIntentArgument);
	Assert.assertEquals(AdapterService.BLUETOOTH_PERM, mStringArgument.getValue());		Assert.assertEquals(AdapterService.BLUETOOTH_PERM, mStringArgument.getValue());

	// Verify that user can get battery level after the update		// Verify that user can get battery level after the update
	@@ -162,15 +163,70 @@ public class RemoteDevicesTest {
	// Verify that resetting battery level changes it back to BluetoothDevice		// Verify that resetting battery level changes it back to BluetoothDevice
	// .BATTERY_LEVEL_UNKNOWN		// .BATTERY_LEVEL_UNKNOWN
	mRemoteDevices.resetBatteryLevel(mDevice1);		mRemoteDevices.resetBatteryLevel(mDevice1);
			// Verify BATTERY_LEVEL_CHANGED intent is sent after first reset
			verify(mAdapterService, times(2))
			.sendBroadcast(mIntentArgument.capture(), mStringArgument.capture());
			verifyBatteryLevelChangedIntent(
			mDevice1, BluetoothDevice.BATTERY_LEVEL_UNKNOWN, mIntentArgument);
			Assert.assertEquals(AdapterService.BLUETOOTH_PERM, mStringArgument.getValue());
			// Verify value is reset in properties
	Assert.assertNotNull(mRemoteDevices.getDeviceProperties(mDevice1));		Assert.assertNotNull(mRemoteDevices.getDeviceProperties(mDevice1));
	Assert.assertEquals(mRemoteDevices.getDeviceProperties(mDevice1).getBatteryLevel(),		Assert.assertEquals(mRemoteDevices.getDeviceProperties(mDevice1).getBatteryLevel(),
	BluetoothDevice.BATTERY_LEVEL_UNKNOWN);		BluetoothDevice.BATTERY_LEVEL_UNKNOWN);

			// Verify no intent is sent after second reset
			mRemoteDevices.resetBatteryLevel(mDevice1);
			verify(mAdapterService, times(2)).sendBroadcast(any(), anyString());

	// Verify that updating battery level triggers ACTION_BATTERY_LEVEL_CHANGED intent again		// Verify that updating battery level triggers ACTION_BATTERY_LEVEL_CHANGED intent again
	mRemoteDevices.updateBatteryLevel(mDevice1, batteryLevel);		mRemoteDevices.updateBatteryLevel(mDevice1, batteryLevel);
			verify(mAdapterService, times(3))
			.sendBroadcast(mIntentArgument.capture(), mStringArgument.capture());
			verifyBatteryLevelChangedIntent(mDevice1, batteryLevel, mIntentArgument);
			Assert.assertEquals(AdapterService.BLUETOOTH_PERM, mStringArgument.getValue());

			verifyNoMoreInteractions(mAdapterService);
			}

			@Test
			public void testResetBatteryLevelOnHeadsetStateChange() {
			int batteryLevel = 10;

			// Verify that device property is null initially
			Assert.assertNull(mRemoteDevices.getDeviceProperties(mDevice1));

			// Verify that updating battery level triggers ACTION_BATTERY_LEVEL_CHANGED intent
			mRemoteDevices.updateBatteryLevel(mDevice1, batteryLevel);
			verify(mAdapterService).sendBroadcast(mIntentArgument.capture(), mStringArgument.capture());
			verifyBatteryLevelChangedIntent(mDevice1, batteryLevel, mIntentArgument);
			Assert.assertEquals(AdapterService.BLUETOOTH_PERM, mStringArgument.getValue());

			// Verify that user can get battery level after the update
			Assert.assertNotNull(mRemoteDevices.getDeviceProperties(mDevice1));
			Assert.assertEquals(
			mRemoteDevices.getDeviceProperties(mDevice1).getBatteryLevel(), batteryLevel);

			// Verify that resetting battery level changes it back to BluetoothDevice
			// .BATTERY_LEVEL_UNKNOWN
			mRemoteDevices.onHeadsetConnectionStateChanged(
			getHeadsetConnectionStateChangedIntent(mDevice1,
			BluetoothProfile.STATE_DISCONNECTING, BluetoothProfile.STATE_DISCONNECTED));
			// Verify BATTERY_LEVEL_CHANGED intent is sent after first reset
	verify(mAdapterService, times(2))		verify(mAdapterService, times(2))
	.sendBroadcast(mIntentArgument.capture(), mStringArgument.capture());		.sendBroadcast(mIntentArgument.capture(), mStringArgument.capture());
	verfyBatteryLevelChangedIntent(mDevice1, batteryLevel, mIntentArgument);		verifyBatteryLevelChangedIntent(
			mDevice1, BluetoothDevice.BATTERY_LEVEL_UNKNOWN, mIntentArgument);
			Assert.assertEquals(AdapterService.BLUETOOTH_PERM, mStringArgument.getValue());
			// Verify value is reset in properties
			Assert.assertNotNull(mRemoteDevices.getDeviceProperties(mDevice1));
			Assert.assertEquals(mRemoteDevices.getDeviceProperties(mDevice1).getBatteryLevel(),
			BluetoothDevice.BATTERY_LEVEL_UNKNOWN);

			// Verify that updating battery level triggers ACTION_BATTERY_LEVEL_CHANGED intent again
			mRemoteDevices.updateBatteryLevel(mDevice1, batteryLevel);
			verify(mAdapterService, times(3))
			.sendBroadcast(mIntentArgument.capture(), mStringArgument.capture());
			verifyBatteryLevelChangedIntent(mDevice1, batteryLevel, mIntentArgument);
	Assert.assertEquals(AdapterService.BLUETOOTH_PERM, mStringArgument.getValue());		Assert.assertEquals(AdapterService.BLUETOOTH_PERM, mStringArgument.getValue());

	verifyNoMoreInteractions(mAdapterService);		verifyNoMoreInteractions(mAdapterService);
	@@ -186,7 +242,7 @@ public class RemoteDevicesTest {
	// Verify that updating battery level triggers ACTION_BATTERY_LEVEL_CHANGED intent		// Verify that updating battery level triggers ACTION_BATTERY_LEVEL_CHANGED intent
	mRemoteDevices.updateBatteryLevel(mDevice1, batteryLevel);		mRemoteDevices.updateBatteryLevel(mDevice1, batteryLevel);
	verify(mAdapterService).sendBroadcast(mIntentArgument.capture(), mStringArgument.capture());		verify(mAdapterService).sendBroadcast(mIntentArgument.capture(), mStringArgument.capture());
	verfyBatteryLevelChangedIntent(mDevice1, batteryLevel, mIntentArgument);		verifyBatteryLevelChangedIntent(mDevice1, batteryLevel, mIntentArgument);
	Assert.assertEquals(AdapterService.BLUETOOTH_PERM, mStringArgument.getValue());		Assert.assertEquals(AdapterService.BLUETOOTH_PERM, mStringArgument.getValue());

	// Verify that user can get battery level after the update		// Verify that user can get battery level after the update
	@@ -201,16 +257,26 @@ public class RemoteDevicesTest {
	0, Utils.getByteAddress(mDevice1), AbstractionLayer.BT_ACL_STATE_DISCONNECTED);		0, Utils.getByteAddress(mDevice1), AbstractionLayer.BT_ACL_STATE_DISCONNECTED);
	verify(mAdapterService).getState();		verify(mAdapterService).getState();
	verify(mAdapterService).getConnectionState(mDevice1);		verify(mAdapterService).getConnectionState(mDevice1);
	verify(mAdapterService, times(2)).sendBroadcast(any(), anyString());		// Verify ACTION_ACL_DISCONNECTED and BATTERY_LEVEL_CHANGED intent are sent
			verify(mAdapterService, times(3))
			.sendBroadcast(mIntentArgument.capture(), mStringArgument.capture());
			verifyBatteryLevelChangedIntent(mDevice1, BluetoothDevice.BATTERY_LEVEL_UNKNOWN,
			mIntentArgument.getAllValues().get(mIntentArgument.getAllValues().size() - 2));
			Assert.assertEquals(AdapterService.BLUETOOTH_PERM,
			mStringArgument.getAllValues().get(mStringArgument.getAllValues().size() - 2));
			Assert.assertEquals(
			BluetoothDevice.ACTION_ACL_DISCONNECTED, mIntentArgument.getValue().getAction());
			Assert.assertEquals(AdapterService.BLUETOOTH_PERM, mStringArgument.getValue());
			// Verify value is reset in properties
	Assert.assertNotNull(mRemoteDevices.getDeviceProperties(mDevice1));		Assert.assertNotNull(mRemoteDevices.getDeviceProperties(mDevice1));
	Assert.assertEquals(BluetoothDevice.BATTERY_LEVEL_UNKNOWN,		Assert.assertEquals(BluetoothDevice.BATTERY_LEVEL_UNKNOWN,
	mRemoteDevices.getDeviceProperties(mDevice1).getBatteryLevel());		mRemoteDevices.getDeviceProperties(mDevice1).getBatteryLevel());

	// Verify that updating battery level triggers ACTION_BATTERY_LEVEL_CHANGED intent again		// Verify that updating battery level triggers ACTION_BATTERY_LEVEL_CHANGED intent again
	mRemoteDevices.updateBatteryLevel(mDevice1, batteryLevel);		mRemoteDevices.updateBatteryLevel(mDevice1, batteryLevel);
	verify(mAdapterService, times(3))		verify(mAdapterService, times(4))
	.sendBroadcast(mIntentArgument.capture(), mStringArgument.capture());		.sendBroadcast(mIntentArgument.capture(), mStringArgument.capture());
	verfyBatteryLevelChangedIntent(mDevice1, batteryLevel, mIntentArgument);		verifyBatteryLevelChangedIntent(mDevice1, batteryLevel, mIntentArgument);
	Assert.assertEquals(AdapterService.BLUETOOTH_PERM, mStringArgument.getValue());		Assert.assertEquals(AdapterService.BLUETOOTH_PERM, mStringArgument.getValue());

	verifyNoMoreInteractions(mAdapterService);		verifyNoMoreInteractions(mAdapterService);
	@@ -227,7 +293,7 @@ public class RemoteDevicesTest {
	mRemoteDevices.onHfIndicatorValueChanged(getHfIndicatorIntent(		mRemoteDevices.onHfIndicatorValueChanged(getHfIndicatorIntent(
	mDevice1, batteryLevel, HeadsetHalConstants.HF_INDICATOR_BATTERY_LEVEL_STATUS));		mDevice1, batteryLevel, HeadsetHalConstants.HF_INDICATOR_BATTERY_LEVEL_STATUS));
	verify(mAdapterService).sendBroadcast(mIntentArgument.capture(), mStringArgument.capture());		verify(mAdapterService).sendBroadcast(mIntentArgument.capture(), mStringArgument.capture());
	verfyBatteryLevelChangedIntent(mDevice1, batteryLevel, mIntentArgument);		verifyBatteryLevelChangedIntent(mDevice1, batteryLevel, mIntentArgument);
	Assert.assertEquals(AdapterService.BLUETOOTH_PERM, mStringArgument.getValue());		Assert.assertEquals(AdapterService.BLUETOOTH_PERM, mStringArgument.getValue());
	}		}

	@@ -256,7 +322,7 @@ public class RemoteDevicesTest {
	BluetoothAssignedNumbers.PLANTRONICS, BluetoothHeadset.AT_CMD_TYPE_SET,		BluetoothAssignedNumbers.PLANTRONICS, BluetoothHeadset.AT_CMD_TYPE_SET,
	getXEventArray(3, 8), mDevice1));		getXEventArray(3, 8), mDevice1));
	verify(mAdapterService).sendBroadcast(mIntentArgument.capture(), mStringArgument.capture());		verify(mAdapterService).sendBroadcast(mIntentArgument.capture(), mStringArgument.capture());
	verfyBatteryLevelChangedIntent(mDevice1, 37, mIntentArgument);		verifyBatteryLevelChangedIntent(mDevice1, 37, mIntentArgument);
	Assert.assertEquals(AdapterService.BLUETOOTH_PERM, mStringArgument.getValue());		Assert.assertEquals(AdapterService.BLUETOOTH_PERM, mStringArgument.getValue());
	}		}

	@@ -274,7 +340,7 @@ public class RemoteDevicesTest {
	2, 1, 3, 10},		2, 1, 3, 10},
	mDevice1));		mDevice1));
	verify(mAdapterService).sendBroadcast(mIntentArgument.capture(), mStringArgument.capture());		verify(mAdapterService).sendBroadcast(mIntentArgument.capture(), mStringArgument.capture());
	verfyBatteryLevelChangedIntent(mDevice1, 60, mIntentArgument);		verifyBatteryLevelChangedIntent(mDevice1, 60, mIntentArgument);
	Assert.assertEquals(AdapterService.BLUETOOTH_PERM, mStringArgument.getValue());		Assert.assertEquals(AdapterService.BLUETOOTH_PERM, mStringArgument.getValue());
	}		}

	@@ -327,16 +393,27 @@ public class RemoteDevicesTest {
	new Object[] {1, "WRONG", "WRONG"}));		new Object[] {1, "WRONG", "WRONG"}));
	}		}

	private static void verfyBatteryLevelChangedIntent(		private static void verifyBatteryLevelChangedIntent(
	BluetoothDevice device, int batteryLevel, ArgumentCaptor<Intent> intentArgument) {		BluetoothDevice device, int batteryLevel, ArgumentCaptor<Intent> intentArgument) {
	Assert.assertEquals(BluetoothDevice.ACTION_BATTERY_LEVEL_CHANGED,		verifyBatteryLevelChangedIntent(device, batteryLevel, intentArgument.getValue());
	intentArgument.getValue().getAction());		}

			private static void verifyBatteryLevelChangedIntent(
			BluetoothDevice device, int batteryLevel, Intent intent) {
			Assert.assertEquals(BluetoothDevice.ACTION_BATTERY_LEVEL_CHANGED, intent.getAction());
			Assert.assertEquals(device, intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE));
	Assert.assertEquals(		Assert.assertEquals(
	device, intentArgument.getValue().getParcelableExtra(BluetoothDevice.EXTRA_DEVICE));		batteryLevel, intent.getIntExtra(BluetoothDevice.EXTRA_BATTERY_LEVEL, -15));
	Assert.assertEquals(batteryLevel,		Assert.assertEquals(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT, intent.getFlags());
	intentArgument.getValue().getIntExtra(BluetoothDevice.EXTRA_BATTERY_LEVEL, -15));		}
	Assert.assertEquals(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT,
	intentArgument.getValue().getFlags());		private static Intent getHeadsetConnectionStateChangedIntent(
			BluetoothDevice device, int oldState, int newState) {
			Intent intent = new Intent(BluetoothHeadset.ACTION_CONNECTION_STATE_CHANGED);
			intent.putExtra(BluetoothDevice.EXTRA_DEVICE, device);
			intent.putExtra(BluetoothProfile.EXTRA_PREVIOUS_STATE, oldState);
			intent.putExtra(BluetoothProfile.EXTRA_STATE, newState);
			return intent;
	}		}

	private static Intent getHfIndicatorIntent(		private static Intent getHfIndicatorIntent(