Merge changes Ic7aaa7ed,I6edac61f (0a912f16) · Commits · e / os / android_packages_modules_Bluetooth

android/app/src/com/android/bluetooth/btservice/ActiveDeviceManager.java

+106 −52

Original line number	Original line	Diff line number	Diff line
	@@ -22,6 +22,7 @@ import android.annotation.RequiresPermission;
	import android.annotation.SuppressLint;		import android.annotation.SuppressLint;
	import android.bluetooth.BluetoothA2dp;		import android.bluetooth.BluetoothA2dp;
	import android.bluetooth.BluetoothAdapter;		import android.bluetooth.BluetoothAdapter;
			import android.bluetooth.BluetoothClass;
	import android.bluetooth.BluetoothDevice;		import android.bluetooth.BluetoothDevice;
	import android.bluetooth.BluetoothHapClient;		import android.bluetooth.BluetoothHapClient;
	import android.bluetooth.BluetoothHeadset;		import android.bluetooth.BluetoothHeadset;
	@@ -262,9 +263,9 @@ class ActiveDeviceManager {
	// New connected device: select it as active		// New connected device: select it as active
	// Activate HFP and A2DP at the same time if both profile already connected.		// Activate HFP and A2DP at the same time if both profile already connected.
	if (mHfpConnectedDevices.contains(device)) {		if (mHfpConnectedDevices.contains(device)) {
	setA2dpActiveDevice(device);		boolean a2dpMadeActive = setA2dpActiveDevice(device);
	setHfpActiveDevice(device);		boolean hfpMadeActive = setHfpActiveDevice(device);
	if (!Utils.isDualModeAudioEnabled()) {		if ((a2dpMadeActive \|\| hfpMadeActive) && !Utils.isDualModeAudioEnabled()) {
	setLeAudioActiveDevice(null, true);		setLeAudioActiveDevice(null, true);
	}		}
	return;		return;
	@@ -273,8 +274,8 @@ class ActiveDeviceManager {
	// Activate A2DP, if HFP is not supported or enabled.		// Activate A2DP, if HFP is not supported or enabled.
	if (dbManager.getProfileConnectionPolicy(device, BluetoothProfile.HEADSET)		if (dbManager.getProfileConnectionPolicy(device, BluetoothProfile.HEADSET)
	!= BluetoothProfile.CONNECTION_POLICY_ALLOWED) {		!= BluetoothProfile.CONNECTION_POLICY_ALLOWED) {
	setA2dpActiveDevice(device);		boolean a2dpMadeActive = setA2dpActiveDevice(device);
	if (!Utils.isDualModeAudioEnabled()) {		if (a2dpMadeActive && !Utils.isDualModeAudioEnabled()) {
	setLeAudioActiveDevice(null, true);		setLeAudioActiveDevice(null, true);
	}		}
	}		}
	@@ -306,9 +307,12 @@ class ActiveDeviceManager {
	// New connected device: select it as active		// New connected device: select it as active
	// Activate HFP and A2DP at the same time once both profile connected.		// Activate HFP and A2DP at the same time once both profile connected.
	if (mA2dpConnectedDevices.contains(device)) {		if (mA2dpConnectedDevices.contains(device)) {
	setA2dpActiveDevice(device);		boolean a2dpMadeActive = setA2dpActiveDevice(device);
	setHfpActiveDevice(device);		boolean hfpMadeActive = setHfpActiveDevice(device);
	if (!Utils.isDualModeAudioEnabled()) {
			/* Make LEA inactive if device is made active for any classic audio profile
			and dual mode is disabled */
			if ((a2dpMadeActive \|\| hfpMadeActive) && !Utils.isDualModeAudioEnabled()) {
	setLeAudioActiveDevice(null, true);		setLeAudioActiveDevice(null, true);
	}		}
	return;		return;
	@@ -317,8 +321,15 @@ class ActiveDeviceManager {
	// Activate HFP, if A2DP is not supported or enabled.		// Activate HFP, if A2DP is not supported or enabled.
	if (dbManager.getProfileConnectionPolicy(device, BluetoothProfile.A2DP)		if (dbManager.getProfileConnectionPolicy(device, BluetoothProfile.A2DP)
	!= BluetoothProfile.CONNECTION_POLICY_ALLOWED) {		!= BluetoothProfile.CONNECTION_POLICY_ALLOWED) {
	setHfpActiveDevice(device);		if (isWatch(device)) {
	if (!Utils.isDualModeAudioEnabled()) {		Log.i(TAG, "Do not set hfp active for watch device " + device);
			return;
			}
			// Tries to make the device active for HFP
			boolean hfpMadeActive = setHfpActiveDevice(device);

			// Makes LEA inactive if device is made active for HFP & dual mode is disabled
			if (hfpMadeActive && !Utils.isDualModeAudioEnabled()) {
	setLeAudioActiveDevice(null, true);		setLeAudioActiveDevice(null, true);
	}		}
	}		}
	@@ -336,12 +347,13 @@ class ActiveDeviceManager {
	}		}
	mHearingAidConnectedDevices.add(device);		mHearingAidConnectedDevices.add(device);
	// New connected device: select it as active		// New connected device: select it as active
	setHearingAidActiveDevice(device);		if (setHearingAidActiveDevice(device)) {
	setA2dpActiveDevice(null, true);		setA2dpActiveDevice(null, true);
	setHfpActiveDevice(null);		setHfpActiveDevice(null);
	setLeAudioActiveDevice(null, true);		setLeAudioActiveDevice(null, true);
	}		}
	}		}
			}

	private void handleLeAudioConnected(BluetoothDevice device) {		private void handleLeAudioConnected(BluetoothDevice device) {
	synchronized (mLock) {		synchronized (mLock) {
	@@ -364,19 +376,20 @@ class ActiveDeviceManager {
	&& mLeHearingAidActiveDevice == null		&& mLeHearingAidActiveDevice == null
	&& mPendingLeHearingAidActiveDevice.isEmpty()) {		&& mPendingLeHearingAidActiveDevice.isEmpty()) {
	// New connected device: select it as active		// New connected device: select it as active
	setLeAudioActiveDevice(device);		boolean leAudioMadeActive = setLeAudioActiveDevice(device);
	if (!Utils.isDualModeAudioEnabled()) {		if (leAudioMadeActive && !Utils.isDualModeAudioEnabled()) {
	setA2dpActiveDevice(null, true);		setA2dpActiveDevice(null, true);
	setHfpActiveDevice(null);		setHfpActiveDevice(null);
	}		}
	} else if (mPendingLeHearingAidActiveDevice.contains(device)) {		} else if (mPendingLeHearingAidActiveDevice.contains(device)) {
	setLeHearingAidActiveDevice(device);		if (setLeHearingAidActiveDevice(device)) {
	setHearingAidActiveDevice(null, true);		setHearingAidActiveDevice(null, true);
	setA2dpActiveDevice(null, true);		setA2dpActiveDevice(null, true);
	setHfpActiveDevice(null);		setHfpActiveDevice(null);
	}		}
	}		}
	}		}
			}

	private void handleHapConnected(BluetoothDevice device) {		private void handleHapConnected(BluetoothDevice device) {
	synchronized (mLock) {		synchronized (mLock) {
	@@ -393,13 +406,14 @@ class ActiveDeviceManager {
	mLeHearingAidActiveDevice = device;		mLeHearingAidActiveDevice = device;
	} else {		} else {
	// New connected device: select it as active		// New connected device: select it as active
	setLeHearingAidActiveDevice(device);		if (setLeHearingAidActiveDevice(device)) {
	setHearingAidActiveDevice(null, true);		setHearingAidActiveDevice(null, true);
	setA2dpActiveDevice(null, true);		setA2dpActiveDevice(null, true);
	setHfpActiveDevice(null);		setHfpActiveDevice(null);
	}		}
	}		}
	}		}
			}

	private void handleA2dpDisconnected(BluetoothDevice device) {		private void handleA2dpDisconnected(BluetoothDevice device) {
	synchronized (mLock) {		synchronized (mLock) {
	@@ -701,11 +715,12 @@ class ActiveDeviceManager {
	return mHandlerThread.getLooper();		return mHandlerThread.getLooper();
	}		}

	private void setA2dpActiveDevice(@NonNull BluetoothDevice device) {		private boolean setA2dpActiveDevice(@NonNull BluetoothDevice device) {
	setA2dpActiveDevice(device, false);		return setA2dpActiveDevice(device, false);
	}		}

	private void setA2dpActiveDevice(@Nullable BluetoothDevice device, boolean hasFallbackDevice) {		private boolean setA2dpActiveDevice(@Nullable BluetoothDevice device,
			boolean hasFallbackDevice) {
	if (DBG) {		if (DBG) {
	Log.d(TAG, "setA2dpActiveDevice(" + device + ")"		Log.d(TAG, "setA2dpActiveDevice(" + device + ")"
	+ (device == null ? " hasFallbackDevice=" + hasFallbackDevice : ""));		+ (device == null ? " hasFallbackDevice=" + hasFallbackDevice : ""));
	@@ -713,7 +728,7 @@ class ActiveDeviceManager {

	final A2dpService a2dpService = mFactory.getA2dpService();		final A2dpService a2dpService = mFactory.getA2dpService();
	if (a2dpService == null) {		if (a2dpService == null) {
	return;		return false;
	}		}

	boolean success = false;		boolean success = false;
	@@ -724,40 +739,43 @@ class ActiveDeviceManager {
	}		}

	if (!success) {		if (!success) {
	return;		return false;
	}		}

	synchronized (mLock) {		synchronized (mLock) {
	mA2dpActiveDevice = device;		mA2dpActiveDevice = device;
	}		}
			return true;
	}		}

	@RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE)		@RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE)
	private void setHfpActiveDevice(BluetoothDevice device) {		private boolean setHfpActiveDevice(BluetoothDevice device) {
	synchronized (mLock) {		synchronized (mLock) {
	if (DBG) {		if (DBG) {
	Log.d(TAG, "setHfpActiveDevice(" + device + ")");		Log.d(TAG, "setHfpActiveDevice(" + device + ")");
	}		}
	final HeadsetService headsetService = mFactory.getHeadsetService();		final HeadsetService headsetService = mFactory.getHeadsetService();
	if (headsetService == null) {		if (headsetService == null) {
	return;		return false;
	}		}
	BluetoothSinkAudioPolicy audioPolicy = headsetService.getHfpCallAudioPolicy(device);		BluetoothSinkAudioPolicy audioPolicy = headsetService.getHfpCallAudioPolicy(device);
	if (audioPolicy == null \|\| audioPolicy.getActiveDevicePolicyAfterConnection()		if (audioPolicy != null && audioPolicy.getActiveDevicePolicyAfterConnection()
	!= BluetoothSinkAudioPolicy.POLICY_NOT_ALLOWED) {		== BluetoothSinkAudioPolicy.POLICY_NOT_ALLOWED) {
			return false;
			}
	if (!headsetService.setActiveDevice(device)) {		if (!headsetService.setActiveDevice(device)) {
	return;		return false;
	}		}
	mHfpActiveDevice = device;		mHfpActiveDevice = device;
	}		}
	}		return true;
	}		}

	private void setHearingAidActiveDevice(@NonNull BluetoothDevice device) {		private boolean setHearingAidActiveDevice(@NonNull BluetoothDevice device) {
	setHearingAidActiveDevice(device, false);		return setHearingAidActiveDevice(device, false);
	}		}

	private void setHearingAidActiveDevice(@Nullable BluetoothDevice device,		private boolean setHearingAidActiveDevice(@Nullable BluetoothDevice device,
	boolean hasFallbackDevice) {		boolean hasFallbackDevice) {
	if (DBG) {		if (DBG) {
	Log.d(TAG, "setHearingAidActiveDevice(" + device + ")"		Log.d(TAG, "setHearingAidActiveDevice(" + device + ")"
	@@ -766,34 +784,37 @@ class ActiveDeviceManager {
	synchronized (mLock) {		synchronized (mLock) {
	final HearingAidService hearingAidService = mFactory.getHearingAidService();		final HearingAidService hearingAidService = mFactory.getHearingAidService();
	if (hearingAidService == null) {		if (hearingAidService == null) {
	return;		return false;
	}		}

	if (device == null) {		if (device == null) {
	hearingAidService.removeActiveDevice(!hasFallbackDevice);		if (!hearingAidService.removeActiveDevice(!hasFallbackDevice)) {
			return false;
			}
	mHearingAidActiveDevices.clear();		mHearingAidActiveDevices.clear();
	return;		return true;
	}		}

	long hiSyncId = hearingAidService.getHiSyncId(device);		long hiSyncId = hearingAidService.getHiSyncId(device);
	if (getHearingAidActiveHiSyncIdLocked() == hiSyncId) {		if (getHearingAidActiveHiSyncIdLocked() == hiSyncId) {
	mHearingAidActiveDevices.add(device);		mHearingAidActiveDevices.add(device);
	return;		return true;
	}		}

	if (!hearingAidService.setActiveDevice(device)) {		if (!hearingAidService.setActiveDevice(device)) {
	return;		return false;
	}		}
	mHearingAidActiveDevices.clear();		mHearingAidActiveDevices.clear();
	mHearingAidActiveDevices.addAll(hearingAidService.getConnectedPeerDevices(hiSyncId));		mHearingAidActiveDevices.addAll(hearingAidService.getConnectedPeerDevices(hiSyncId));
	}		}
			return true;
	}		}

	private void setLeAudioActiveDevice(@NonNull BluetoothDevice device) {		private boolean setLeAudioActiveDevice(@NonNull BluetoothDevice device) {
	setLeAudioActiveDevice(device, false);		return setLeAudioActiveDevice(device, false);
	}		}

	private void setLeAudioActiveDevice(@Nullable BluetoothDevice device,		private boolean setLeAudioActiveDevice(@Nullable BluetoothDevice device,
	boolean hasFallbackDevice) {		boolean hasFallbackDevice) {
	if (DBG) {		if (DBG) {
	Log.d(TAG, "setLeAudioActiveDevice(" + device + ")"		Log.d(TAG, "setLeAudioActiveDevice(" + device + ")"
	@@ -802,7 +823,7 @@ class ActiveDeviceManager {
	synchronized (mLock) {		synchronized (mLock) {
	final LeAudioService leAudioService = mFactory.getLeAudioService();		final LeAudioService leAudioService = mFactory.getLeAudioService();
	if (leAudioService == null) {		if (leAudioService == null) {
	return;		return false;
	}		}
	boolean success;		boolean success;
	if (device == null) {		if (device == null) {
	@@ -812,7 +833,7 @@ class ActiveDeviceManager {
	}		}

	if (!success) {		if (!success) {
	return;		return false;
	}		}

	mLeAudioActiveDevice = device;		mLeAudioActiveDevice = device;
	@@ -821,19 +842,24 @@ class ActiveDeviceManager {
	mPendingLeHearingAidActiveDevice.remove(device);		mPendingLeHearingAidActiveDevice.remove(device);
	}		}
	}		}
			return true;
	}		}

	private void setLeHearingAidActiveDevice(BluetoothDevice device) {		private boolean setLeHearingAidActiveDevice(BluetoothDevice device) {
	synchronized (mLock) {		synchronized (mLock) {
	if (!Objects.equals(mLeAudioActiveDevice, device)) {		if (!Objects.equals(mLeAudioActiveDevice, device)) {
	setLeAudioActiveDevice(device);		if (!setLeAudioActiveDevice(device)) {
			return false;
			}
	}		}
	if (Objects.equals(mLeAudioActiveDevice, device)) {		if (Objects.equals(mLeAudioActiveDevice, device)) {
	// setLeAudioActiveDevice succeed		// setLeAudioActiveDevice succeed
	mLeHearingAidActiveDevice = device;		mLeHearingAidActiveDevice = device;
	mPendingLeHearingAidActiveDevice.remove(device);		mPendingLeHearingAidActiveDevice.remove(device);
			return true;
	}		}
	}		}
			return false;
	}		}

	/**		/**
	@@ -1030,6 +1056,34 @@ class ActiveDeviceManager {
	return BluetoothHearingAid.HI_SYNC_ID_INVALID;		return BluetoothHearingAid.HI_SYNC_ID_INVALID;
	}		}

			/**
			* Checks CoD and metadata to determine if the device is a watch
			* @param device the remote device
			* @return {@code true} if it's a watch, {@code false} otherwise
			*/
			private boolean isWatch(BluetoothDevice device) {
			// Check CoD
			BluetoothClass deviceClass = device.getBluetoothClass();
			if (deviceClass != null && deviceClass.getDeviceClass()
			== BluetoothClass.Device.WEARABLE_WRIST_WATCH) {
			return true;
			}

			// Check metadata
			DatabaseManager dbManager = mAdapterService.getDatabase();
			byte[] deviceType = dbManager.getCustomMeta(device,
			BluetoothDevice.METADATA_DEVICE_TYPE);
			if (deviceType == null) {
			return false;
			}
			String deviceTypeStr = new String(deviceType);
			if (deviceTypeStr.equals(BluetoothDevice.DEVICE_TYPE_WATCH)) {
			return true;
			}

			return false;
			}

	/**		/**
	* Called when a wired audio device is connected.		* Called when a wired audio device is connected.
	* It might be called multiple times each time a wired audio device is connected.		* It might be called multiple times each time a wired audio device is connected.

android/app/tests/unit/src/com/android/bluetooth/btservice/ActiveDeviceManagerTest.java

+64 −0

Original line number	Original line	Diff line number	Diff line
	@@ -393,6 +393,8 @@ public class ActiveDeviceManagerTest {
	*/		*/
	@Test		@Test
	public void hearingAidActive_setA2dpActiveExplicitly() {		public void hearingAidActive_setA2dpActiveExplicitly() {
			when(mHearingAidService.removeActiveDevice(anyBoolean())).thenReturn(true);

	hearingAidActiveDeviceChanged(mHearingAidDevice);		hearingAidActiveDeviceChanged(mHearingAidDevice);
	a2dpConnected(mA2dpDevice, false);		a2dpConnected(mA2dpDevice, false);
	a2dpActiveDeviceChanged(mA2dpDevice);		a2dpActiveDeviceChanged(mA2dpDevice);
	@@ -410,6 +412,8 @@ public class ActiveDeviceManagerTest {
	*/		*/
	@Test		@Test
	public void hearingAidActive_setHeadsetActiveExplicitly() {		public void hearingAidActive_setHeadsetActiveExplicitly() {
			when(mHearingAidService.removeActiveDevice(anyBoolean())).thenReturn(true);

	hearingAidActiveDeviceChanged(mHearingAidDevice);		hearingAidActiveDeviceChanged(mHearingAidDevice);
	headsetConnected(mHeadsetDevice, false);		headsetConnected(mHeadsetDevice, false);
	headsetActiveDeviceChanged(mHeadsetDevice);		headsetActiveDeviceChanged(mHeadsetDevice);
	@@ -623,6 +627,10 @@ public class ActiveDeviceManagerTest {
	@Test		@Test
	public void activeDeviceDisconnected_fallbackToHearingAid() {		public void activeDeviceDisconnected_fallbackToHearingAid() {
	when(mAudioManager.getMode()).thenReturn(AudioManager.MODE_NORMAL);		when(mAudioManager.getMode()).thenReturn(AudioManager.MODE_NORMAL);
			when(mA2dpService.setActiveDevice(any())).thenReturn(true);
			when(mLeAudioService.setActiveDevice(any())).thenReturn(true);
			when(mHearingAidService.setActiveDevice(any())).thenReturn(true);
			when(mHearingAidService.removeActiveDevice(anyBoolean())).thenReturn(true);

	hearingAidConnected(mHearingAidDevice);		hearingAidConnected(mHearingAidDevice);
	verify(mHearingAidService, timeout(TIMEOUT_MS)).setActiveDevice(mHearingAidDevice);		verify(mHearingAidService, timeout(TIMEOUT_MS)).setActiveDevice(mHearingAidDevice);
	@@ -678,6 +686,7 @@ public class ActiveDeviceManagerTest {
	@Test		@Test
	public void activeDeviceChange_withHearingAidLeHearingAidAndA2dpDevices() {		public void activeDeviceChange_withHearingAidLeHearingAidAndA2dpDevices() {
	when(mAudioManager.getMode()).thenReturn(AudioManager.MODE_NORMAL);		when(mAudioManager.getMode()).thenReturn(AudioManager.MODE_NORMAL);
			when(mHearingAidService.removeActiveDevice(anyBoolean())).thenReturn(true);

	hearingAidConnected(mHearingAidDevice);		hearingAidConnected(mHearingAidDevice);
	verify(mHearingAidService, timeout(TIMEOUT_MS)).setActiveDevice(mHearingAidDevice);		verify(mHearingAidService, timeout(TIMEOUT_MS)).setActiveDevice(mHearingAidDevice);
	@@ -768,6 +777,61 @@ public class ActiveDeviceManagerTest {
	Assert.assertEquals(null, mActiveDeviceManager.getLeAudioActiveDevice());		Assert.assertEquals(null, mActiveDeviceManager.getLeAudioActiveDevice());
	}		}

			/**
			* Verifies that other profiles do not have their active device cleared when we fail to make
			* a newly connected device active.
			*/
			@Test
			public void setActiveDeviceFailsUponConnection() {
			Utils.setDualModeAudioStateForTesting(false);
			when(mHeadsetService.setActiveDevice(any())).thenReturn(false);
			when(mA2dpService.setActiveDevice(any())).thenReturn(false);
			when(mHearingAidService.setActiveDevice(any())).thenReturn(false);
			when(mLeAudioService.setActiveDevice(any())).thenReturn(false);

			leAudioConnected(mDualModeAudioDevice);
			TestUtils.waitForLooperToFinishScheduledTask(mActiveDeviceManager.getHandlerLooper());
			verify(mLeAudioService, timeout(TIMEOUT_MS)).setActiveDevice(mDualModeAudioDevice);

			leAudioActiveDeviceChanged(mDualModeAudioDevice);
			TestUtils.waitForLooperToFinishScheduledTask(mActiveDeviceManager.getHandlerLooper());
			verify(mA2dpService, times(1)).removeActiveDevice(anyBoolean());
			verify(mHeadsetService, times(1)).setActiveDevice(null);
			verify(mHearingAidService, times(1)).removeActiveDevice(anyBoolean());

			a2dpConnected(mA2dpDevice, false);
			TestUtils.waitForLooperToFinishScheduledTask(mActiveDeviceManager.getHandlerLooper());
			verify(mA2dpService, timeout(TIMEOUT_MS)).setActiveDevice(mA2dpDevice);
			verify(mLeAudioService, never()).removeActiveDevice(anyBoolean());

			a2dpConnected(mA2dpHeadsetDevice, true);
			headsetConnected(mA2dpHeadsetDevice, true);
			TestUtils.waitForLooperToFinishScheduledTask(mActiveDeviceManager.getHandlerLooper());
			verify(mA2dpService, timeout(TIMEOUT_MS)).setActiveDevice(mA2dpHeadsetDevice);
			verify(mHeadsetService, timeout(TIMEOUT_MS)).setActiveDevice(mA2dpHeadsetDevice);
			verify(mLeAudioService, never()).removeActiveDevice(anyBoolean());

			headsetConnected(mHeadsetDevice, false);
			TestUtils.waitForLooperToFinishScheduledTask(mActiveDeviceManager.getHandlerLooper());
			verify(mHeadsetService, timeout(TIMEOUT_MS)).setActiveDevice(mHeadsetDevice);
			verify(mLeAudioService, never()).removeActiveDevice(anyBoolean());

			hearingAidConnected(mHearingAidDevice);
			TestUtils.waitForLooperToFinishScheduledTask(mActiveDeviceManager.getHandlerLooper());
			verify(mHearingAidService, timeout(TIMEOUT_MS)).setActiveDevice(mHearingAidDevice);
			verify(mLeAudioService, never()).removeActiveDevice(anyBoolean());
			verify(mA2dpService, times(1)).removeActiveDevice(anyBoolean());
			verify(mHeadsetService, times(1)).setActiveDevice(null);

			leAudioConnected(mLeHearingAidDevice);
			leHearingAidConnected(mLeHearingAidDevice);
			TestUtils.waitForLooperToFinishScheduledTask(mActiveDeviceManager.getHandlerLooper());
			verify(mLeAudioService, times(2)).setActiveDevice(mLeHearingAidDevice);
			verify(mA2dpService, times(1)).removeActiveDevice(anyBoolean());
			verify(mHeadsetService, times(1)).setActiveDevice(null);
			verify(mHearingAidService, times(1)).removeActiveDevice(anyBoolean());
			}

	/**		/**
	* A wired audio device is connected. Then all active devices are set to null.		* A wired audio device is connected. Then all active devices are set to null.
	*/		*/