Snap for 11025555 from 392239a61cade5e3be28b66fc9ade328ef039f9a to 24Q1-release (793a1845) · Commits · e / os / android_packages_modules_Bluetooth

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

+378 −264

File changed.

Preview size limit exceeded, changes collapsed.

android/app/src/com/android/bluetooth/le_audio/LeAudioService.java

+43 −4

Original line number	Diff line number	Diff line
		@@ -74,6 +74,8 @@ import com.android.bluetooth.btservice.ProfileService;
		import com.android.bluetooth.btservice.ServiceFactory;
		import com.android.bluetooth.btservice.storage.DatabaseManager;
		import com.android.bluetooth.csip.CsipSetCoordinatorService;
		import com.android.bluetooth.flags.FeatureFlags;
		import com.android.bluetooth.flags.FeatureFlagsImpl;
		import com.android.bluetooth.hap.HapClientService;
		import com.android.bluetooth.hfp.HeadsetService;
		import com.android.bluetooth.mcp.McpService;
		@@ -130,6 +132,7 @@ public class LeAudioService extends ProfileService {
		private BluetoothDevice mExposedActiveDevice;
		private LeAudioCodecConfig mLeAudioCodecConfig;
		private final Object mGroupLock = new Object();
		private final FeatureFlags mFeatureFlags = new FeatureFlagsImpl();
		ServiceFactory mServiceFactory = new ServiceFactory();

		LeAudioNativeInterface mLeAudioNativeInterface;
		@@ -148,7 +151,6 @@ public class LeAudioService extends ProfileService {
		private final LinkedList<BluetoothLeBroadcastSettings> mCreateBroadcastQueue =
		new LinkedList<>();


		@VisibleForTesting
		TbsService mTbsService;

		@@ -201,6 +203,7 @@ public class LeAudioService extends ProfileService {

		private static class LeAudioDeviceDescriptor {
		LeAudioDeviceDescriptor(boolean isInbandRingtonEnabled) {
		mAclConnected = false;
		mStateMachine = null;
		mGroupId = LE_AUDIO_GROUP_ID_INVALID;
		mSinkAudioLocation = BluetoothLeAudio.AUDIO_LOCATION_INVALID;
		@@ -208,6 +211,7 @@ public class LeAudioService extends ProfileService {
		mDevInbandRingtoneEnabled = isInbandRingtonEnabled;
		}

		public boolean mAclConnected;
		public LeAudioStateMachine mStateMachine;
		public Integer mGroupId;
		public Integer mSinkAudioLocation;
		@@ -1275,12 +1279,37 @@ public class LeAudioService extends ProfileService {
		return false;
		}

		if (allLeAudioDevicesConnected()) {
		Log.d(TAG, "isScannerNeeded: all devices connected, scanner not needed");
		return false;
		}

		if (DBG) {
		Log.d(TAG, "isScannerNeeded: true");
		}
		return true;
		}

		boolean allLeAudioDevicesConnected() {
		synchronized (mGroupLock) {
		for (Map.Entry<BluetoothDevice, LeAudioDeviceDescriptor> deviceEntry :
		mDeviceDescriptors.entrySet()) {
		LeAudioDeviceDescriptor deviceDescriptor = deviceEntry.getValue();

		if (deviceDescriptor.mStateMachine == null) {
		/* Lack of state machine means device is not connected */
		return false;
		}

		if (!deviceDescriptor.mStateMachine.isConnected()
		\|\| !deviceDescriptor.mAclConnected) {
		return false;
		}
		}
		}
		return true;
		}

		private class AudioServerScanCallback extends ScanCallback {
		int mMaxScanRetires = 10;
		int mScanRetries = 0;
		@@ -2060,6 +2089,7 @@ public class LeAudioService extends ProfileService {
		switch (stackEvent.valueInt1) {
		case LeAudioStackEvent.CONNECTION_STATE_DISCONNECTING:
		case LeAudioStackEvent.CONNECTION_STATE_DISCONNECTED:
		deviceDescriptor.mAclConnected = false;
		startAudioServersBackgroundScan(/* retry = */ false);

		boolean disconnectDueToUnbond =
		@@ -2078,6 +2108,7 @@ public class LeAudioService extends ProfileService {
		break;
		case LeAudioStackEvent.CONNECTION_STATE_CONNECTED:
		case LeAudioStackEvent.CONNECTION_STATE_CONNECTING:
		deviceDescriptor.mAclConnected = true;
		if (descriptor != null
		&& Objects.equals(
		descriptor.mLostLeadDeviceWhileStreaming,
		@@ -2096,6 +2127,7 @@ public class LeAudioService extends ProfileService {
		switch (stackEvent.valueInt1) {
		case LeAudioStackEvent.CONNECTION_STATE_CONNECTED:
		case LeAudioStackEvent.CONNECTION_STATE_CONNECTING:
		deviceDescriptor.mAclConnected = true;
		sm = getOrCreateStateMachine(device);
		/* Incoming connection try to connect other devices from the group */
		connectSet(device);
		@@ -2410,8 +2442,13 @@ public class LeAudioService extends ProfileService {
		Log.d(TAG, "Creating a new state machine for " + device);
		}

		sm = LeAudioStateMachine.make(device, this,
		mLeAudioNativeInterface, mStateMachinesThread.getLooper());
		sm =
		LeAudioStateMachine.make(
		device,
		this,
		mLeAudioNativeInterface,
		mStateMachinesThread.getLooper(),
		mFeatureFlags);
		descriptor.mStateMachine = sm;
		return sm;
		}
		@@ -4114,7 +4151,8 @@ public class LeAudioService extends ProfileService {
		} else {
		ProfileService.println(sb, "state machine is null");
		}

		ProfileService.println(
		sb, " mAclConnected: " + deviceDescriptor.mAclConnected);
		ProfileService.println(sb, " mDevInbandRingtoneEnabled: "
		+ deviceDescriptor.mDevInbandRingtoneEnabled);
		ProfileService.println(sb, " mSinkAudioLocation: "
		@@ -4134,6 +4172,7 @@ public class LeAudioService extends ProfileService {
		}

		deviceDescriptor.mStateMachine.dump(sb);
		ProfileService.println(sb, " mAclConnected: " + deviceDescriptor.mAclConnected);
		ProfileService.println(sb, " mDevInbandRingtoneEnabled: "
		+ deviceDescriptor.mDevInbandRingtoneEnabled);
		ProfileService.println(sb, " mSinkAudioLocation: "

android/app/src/com/android/bluetooth/le_audio/LeAudioStateMachine.java

+24 −6

Original line number	Diff line number	Diff line
		@@ -53,6 +53,7 @@ import android.os.Message;
		import android.util.Log;

		import com.android.bluetooth.btservice.ProfileService;
		import com.android.bluetooth.flags.FeatureFlags;
		import com.android.internal.annotations.VisibleForTesting;
		import com.android.internal.util.State;
		import com.android.internal.util.StateMachine;
		@@ -87,13 +88,19 @@ final class LeAudioStateMachine extends StateMachine {
		private LeAudioNativeInterface mNativeInterface;

		private final BluetoothDevice mDevice;

		LeAudioStateMachine(BluetoothDevice device, LeAudioService svc,
		LeAudioNativeInterface nativeInterface, Looper looper) {
		private final FeatureFlags mFeatureFlags;

		LeAudioStateMachine(
		BluetoothDevice device,
		LeAudioService svc,
		LeAudioNativeInterface nativeInterface,
		Looper looper,
		FeatureFlags featureFlags) {
		super(TAG, looper);
		mDevice = device;
		mService = svc;
		mNativeInterface = nativeInterface;
		mFeatureFlags = featureFlags;

		mDisconnected = new Disconnected();
		mConnecting = new Connecting();
		@@ -108,10 +115,15 @@ final class LeAudioStateMachine extends StateMachine {
		setInitialState(mDisconnected);
		}

		static LeAudioStateMachine make(BluetoothDevice device, LeAudioService svc,
		LeAudioNativeInterface nativeInterface, Looper looper) {
		static LeAudioStateMachine make(
		BluetoothDevice device,
		LeAudioService svc,
		LeAudioNativeInterface nativeInterface,
		Looper looper,
		FeatureFlags featureFlags) {
		Log.i(TAG, "make for device");
		LeAudioStateMachine LeAudioSm = new LeAudioStateMachine(device, svc, nativeInterface, looper);
		LeAudioStateMachine LeAudioSm =
		new LeAudioStateMachine(device, svc, nativeInterface, looper, featureFlags);
		LeAudioSm.start();
		return LeAudioSm;
		}
		@@ -139,6 +151,9 @@ final class LeAudioStateMachine extends StateMachine {
		// Don't broadcast during startup
		broadcastConnectionState(BluetoothProfile.STATE_DISCONNECTED,
		mLastConnectionState);
		if (mFeatureFlags.audioRoutingCentralization()) {
		mService.deviceDisconnected(mDevice, false);
		}
		}
		}

		@@ -426,6 +441,9 @@ final class LeAudioStateMachine extends StateMachine {
		+ messageWhatToString(getCurrentMessage().what));
		mConnectionState = BluetoothProfile.STATE_CONNECTED;
		removeDeferredMessages(CONNECT);
		if (mFeatureFlags.audioRoutingCentralization()) {
		mService.deviceConnected(mDevice);
		}
		broadcastConnectionState(BluetoothProfile.STATE_CONNECTED, mLastConnectionState);
		}

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

+37 −74

Original line number	Diff line number	Diff line
		@@ -16,6 +16,8 @@

		package com.android.bluetooth.btservice;

		import static android.bluetooth.IBluetoothLeAudio.LE_AUDIO_GROUP_ID_INVALID;

		import static com.google.common.truth.Truth.assertThat;

		import static org.mockito.ArgumentMatchers.anyBoolean;
		@@ -150,6 +152,7 @@ public class AudioRoutingManagerTest {
		when(mHearingAidService.setActiveDevice(any())).thenReturn(true);
		when(mLeAudioService.setActiveDevice(any())).thenReturn(true);
		when(mLeAudioService.removeActiveDevice(anyBoolean())).thenReturn(true);
		when(mLeAudioService.getGroupId(any())).thenReturn(LE_AUDIO_GROUP_ID_INVALID);

		List<BluetoothDevice> connectedHearingAidDevices = new ArrayList<>();
		connectedHearingAidDevices.add(mHearingAidDevice);
		@@ -580,31 +583,30 @@ public class AudioRoutingManagerTest {

		/** A Hearing Aid is connected. Then a combo (A2DP + Headset) device is connected. */
		@Test
		public void hearingAidActive_dontSetA2dpAndHeadsetActive() {
		public void hearingAidAndA2dpHeadsetConnected_setA2dpHeadsetActive() {
		hearingAidActiveDeviceChanged(mHearingAidDevice);
		a2dpConnected(mA2dpHeadsetDevice, true);
		headsetConnected(mA2dpHeadsetDevice, true);

		TestUtils.waitForLooperToFinishScheduledTask(mAudioRoutingManager.getHandlerLooper());
		verify(mA2dpService, never()).setActiveDevice(mA2dpHeadsetDevice);
		verify(mHeadsetService, never()).setActiveDevice(mA2dpHeadsetDevice);
		verify(mHearingAidService).removeActiveDevice(false);
		verify(mA2dpService).setActiveDevice(mA2dpHeadsetDevice);
		verify(mHeadsetService).setActiveDevice(mA2dpHeadsetDevice);
		}

		/** A Hearing Aid is connected. Then an A2DP active device is explicitly set. */
		/** A Hearing Aid is connected. Then an A2DP connected. */
		@Test
		public void hearingAidActive_setA2dpActiveExplicitly() {
		when(mHearingAidService.removeActiveDevice(anyBoolean())).thenReturn(true);

		hearingAidActiveDeviceChanged(mHearingAidDevice);
		a2dpConnected(mA2dpDevice, false);
		a2dpActiveDeviceChanged(mA2dpDevice);

		TestUtils.waitForLooperToFinishScheduledTask(mAudioRoutingManager.getHandlerLooper());
		verify(mHearingAidService).removeActiveDevice(false);
		// Don't call mA2dpService.setActiveDevice()
		verify(mA2dpService, never()).setActiveDevice(mA2dpDevice);

		assertThat(mAudioRoutingManager.getA2dpActiveDevice()).isEqualTo(mA2dpDevice);
		assertThat(mAudioRoutingManager.getHearingAidActiveDevices().isEmpty()).isTrue();
		assertThat(mAudioRoutingManager.getHearingAidActiveDevices()).isEmpty();
		}

		/** A Hearing Aid is connected. Then a Headset active device is explicitly set. */
		@@ -614,14 +616,11 @@ public class AudioRoutingManagerTest {

		hearingAidActiveDeviceChanged(mHearingAidDevice);
		headsetConnected(mHeadsetDevice, false);
		headsetActiveDeviceChanged(mHeadsetDevice);

		TestUtils.waitForLooperToFinishScheduledTask(mAudioRoutingManager.getHandlerLooper());
		verify(mHearingAidService).removeActiveDevice(false);
		// Don't call mHeadsetService.setActiveDevice()
		verify(mHeadsetService, never()).setActiveDevice(mHeadsetDevice);
		assertThat(mAudioRoutingManager.getHfpActiveDevice()).isEqualTo(mHeadsetDevice);
		assertThat(mAudioRoutingManager.getHearingAidActiveDevices().isEmpty()).isTrue();
		assertThat(mAudioRoutingManager.getHearingAidActiveDevices()).isEmpty();
		}

		@Test
		@@ -786,7 +785,6 @@ public class AudioRoutingManagerTest {

		verify(mLeAudioService, never()).removeActiveDevice(false);
		verify(mLeAudioService, never()).setActiveDevice(mLeAudioDevice2);
		verify(mLeAudioService, timeout(TIMEOUT_MS)).deviceDisconnected(mLeAudioDevice, false);
		}

		/**
		@@ -813,7 +811,6 @@ public class AudioRoutingManagerTest {
		leAudioDisconnected(mLeAudioDevice2);

		verify(mLeAudioService, timeout(TIMEOUT_MS)).removeActiveDevice(false);
		verify(mLeAudioService, timeout(TIMEOUT_MS)).deviceDisconnected(mLeAudioDevice2, false);
		}

		/**
		@@ -836,7 +833,6 @@ public class AudioRoutingManagerTest {
		leAudioDisconnected(mLeAudioDevice2);

		verify(mLeAudioService, timeout(TIMEOUT_MS)).setActiveDevice(mLeAudioDevice);
		verify(mLeAudioService, timeout(TIMEOUT_MS)).deviceDisconnected(mLeAudioDevice2, true);
		}

		/**
		@@ -883,36 +879,6 @@ public class AudioRoutingManagerTest {
		verify(mHearingAidService, timeout(TIMEOUT_MS)).setActiveDevice(mHearingAidDevice);
		}

		/**
		* Hearing aid is connected, but active device is different BT. When the active device is
		* disconnected, the hearing aid should be the active one.
		*/
		@Test
		public void activeDeviceDisconnected_fallbackToHearingAid() {
		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);
		verify(mHearingAidService, timeout(TIMEOUT_MS)).setActiveDevice(mHearingAidDevice);

		leAudioConnected(mLeAudioDevice);
		a2dpConnected(mA2dpDevice, false);

		a2dpActiveDeviceChanged(mA2dpDevice);
		TestUtils.waitForLooperToFinishScheduledTask(mAudioRoutingManager.getHandlerLooper());

		verify(mHearingAidService).removeActiveDevice(false);
		verify(mLeAudioService, never()).setActiveDevice(mLeAudioDevice);
		verify(mA2dpService, never()).setActiveDevice(mA2dpDevice);

		a2dpDisconnected(mA2dpDevice);
		verify(mA2dpService, timeout(TIMEOUT_MS).atLeast(1)).removeActiveDevice(false);
		verify(mHearingAidService, timeout(TIMEOUT_MS).times(2)).setActiveDevice(mHearingAidDevice);
		}

		/** One LE Hearing Aid is connected. */
		@Test
		public void onlyLeHearingAidConnected_setLeAudioActive() {
		@@ -924,20 +890,20 @@ public class AudioRoutingManagerTest {
		verify(mLeAudioService, timeout(TIMEOUT_MS)).setActiveDevice(mLeHearingAidDevice);
		}

		/** LE audio is connected after LE Hearing Aid device. Keep LE hearing Aid active. */
		/** LE audio is connected after LE Hearing Aid device. LE audio active. */
		@Test
		public void leAudioConnectedAfterLeHearingAid_setLeAudioActiveShouldNotBeCalled() {
		public void leAudioConnectedAfterLeHearingAid_callsSetLeAudioActive() {
		leHearingAidConnected(mLeHearingAidDevice);
		leAudioConnected(mLeHearingAidDevice);
		verify(mLeAudioService, timeout(TIMEOUT_MS)).setActiveDevice(mLeHearingAidDevice);

		leAudioConnected(mLeAudioDevice);
		TestUtils.waitForLooperToFinishScheduledTask(mAudioRoutingManager.getHandlerLooper());
		verify(mLeAudioService, never()).setActiveDevice(mLeAudioDevice);
		verify(mLeAudioService).setActiveDevice(mLeAudioDevice);
		}

		/**
		* Test connect/disconnect of devices. Hearing Aid, LE Hearing Aid, A2DP connected, then LE
		* Test connect/disconnect of devices. Hearing Aid, A2DP connected, LE Hearing Aid, then LE
		* hearing Aid and hearing aid disconnected.
		*/
		@Test
		@@ -948,22 +914,21 @@ public class AudioRoutingManagerTest {
		hearingAidConnected(mHearingAidDevice);
		verify(mHearingAidService, timeout(TIMEOUT_MS)).setActiveDevice(mHearingAidDevice);

		a2dpConnected(mA2dpDevice, false);
		verify(mA2dpService, timeout(TIMEOUT_MS)).setActiveDevice(mA2dpDevice);
		verify(mHearingAidService, timeout(TIMEOUT_MS)).removeActiveDevice(false);

		Mockito.clearInvocations(mHearingAidService, mA2dpService, mLeAudioService);
		leHearingAidConnected(mLeHearingAidDevice);
		leAudioConnected(mLeHearingAidDevice);
		verify(mLeAudioService, timeout(TIMEOUT_MS)).setActiveDevice(mLeHearingAidDevice);
		verify(mA2dpService, timeout(TIMEOUT_MS)).removeActiveDevice(false);

		a2dpConnected(mA2dpDevice, false);
		TestUtils.waitForLooperToFinishScheduledTask(mAudioRoutingManager.getHandlerLooper());
		verify(mA2dpService, never()).setActiveDevice(mA2dpDevice);

		Mockito.clearInvocations(mHearingAidService, mA2dpService);
		Mockito.clearInvocations(mHearingAidService, mA2dpService, mLeAudioService);
		leHearingAidDisconnected(mLeHearingAidDevice);
		leAudioDisconnected(mLeHearingAidDevice);
		verify(mHearingAidService, timeout(TIMEOUT_MS)).setActiveDevice(mHearingAidDevice);
		verify(mA2dpService, timeout(TIMEOUT_MS)).removeActiveDevice(false);

		hearingAidDisconnected(mHearingAidDevice);
		verify(mA2dpService, timeout(TIMEOUT_MS)).setActiveDevice(mA2dpDevice);
		verify(mLeAudioService, timeout(TIMEOUT_MS)).removeActiveDevice(true);
		}

		/**
		@@ -982,7 +947,6 @@ public class AudioRoutingManagerTest {
		.setActiveDevice(mDualModeAudioDevice);
		verify(mHeadsetService, timeout(TIMEOUT_MS).atLeastOnce())
		.setActiveDevice(mDualModeAudioDevice);
		verify(mLeAudioService, timeout(TIMEOUT_MS).atLeastOnce()).removeActiveDevice(true);
		assertThat(mAudioRoutingManager.getA2dpActiveDevice()).isEqualTo(mDualModeAudioDevice);
		assertThat(mAudioRoutingManager.getHfpActiveDevice()).isEqualTo(mDualModeAudioDevice);

		@@ -1050,46 +1014,45 @@ public class AudioRoutingManagerTest {

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

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

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

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

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

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

		leAudioConnected(mLeHearingAidDevice);
		leHearingAidConnected(mLeHearingAidDevice);
		TestUtils.waitForLooperToFinishScheduledTask(mAudioRoutingManager.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());
		verify(mA2dpService).removeActiveDevice(anyBoolean());
		verify(mHeadsetService).setActiveDevice(null);
		verify(mHearingAidService).removeActiveDevice(anyBoolean());
		}

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

android/app/tests/unit/src/com/android/bluetooth/le_audio/LeAudioStateMachineTest.java

+13 −4

Original line number	Diff line number	Diff line
		@@ -42,6 +42,8 @@ import androidx.test.runner.AndroidJUnit4;

		import com.android.bluetooth.TestUtils;
		import com.android.bluetooth.btservice.AdapterService;
		import com.android.bluetooth.flags.FakeFeatureFlagsImpl;
		import com.android.bluetooth.flags.Flags;

		import org.junit.After;
		import org.junit.Before;
		@@ -58,6 +60,7 @@ public class LeAudioStateMachineTest {
		private HandlerThread mHandlerThread;
		private LeAudioStateMachine mLeAudioStateMachine;
		private BluetoothDevice mTestDevice;
		private FakeFeatureFlagsImpl mFakeFlagsImpl;
		private static final int TIMEOUT_MS = 1000;

		@Mock private AdapterService mAdapterService;
		@@ -72,6 +75,8 @@ public class LeAudioStateMachineTest {
		TestUtils.setAdapterService(mAdapterService);

		mAdapter = BluetoothAdapter.getDefaultAdapter();
		mFakeFlagsImpl = new FakeFeatureFlagsImpl();
		mFakeFlagsImpl.setFlag(Flags.FLAG_AUDIO_ROUTING_CENTRALIZATION, false);

		// Get a device for testing
		mTestDevice = mAdapter.getRemoteDevice("00:01:02:03:04:05");
		@@ -79,11 +84,15 @@ public class LeAudioStateMachineTest {
		// Set up thread and looper
		mHandlerThread = new HandlerThread("LeAudioStateMachineTestHandlerThread");
		mHandlerThread.start();
		mLeAudioStateMachine = new LeAudioStateMachine(mTestDevice, mLeAudioService,
		mLeAudioNativeInterface, mHandlerThread.getLooper());
		// Override the timeout value to speed up the test
		mLeAudioStateMachine.sConnectTimeoutMs = 1000; // 1s
		mLeAudioStateMachine.start();
		LeAudioStateMachine.sConnectTimeoutMs = 1000; // 1s
		mLeAudioStateMachine =
		LeAudioStateMachine.make(
		mTestDevice,
		mLeAudioService,
		mLeAudioNativeInterface,
		mHandlerThread.getLooper(),
		mFakeFlagsImpl);
		}

		@After