Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 7c07c6f8 authored by David Duarte's avatar David Duarte Committed by Automerger Merge Worker
Browse files

Merge changes Id1d283a3,I3d228b93 into main am: 49aaa965 

Original change: https://android-review.googlesource.com/c/platform/packages/modules/Bluetooth/+/2855329



Change-Id: Icb5552461e9e55ab00bdb65c6fcc35452a4fcf67
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents 1f5096ec 49aaa965

android/app/src/com/android/bluetooth/bass_client/BassClientService.java

+0 −67
Original line number Diff line number Diff line
@@ -63,7 +63,6 @@ import java.util.ArrayList; 
import java.util.Arrays;

import java.util.Collections;

import java.util.HashMap;

import java.util.LinkedList;

import java.util.List;

import java.util.Map;

import java.util.Objects;
@@ -91,9 +90,6 @@ public class BassClientService extends ProfileService { 
            new ConcurrentHashMap<>();

    private final Map<BluetoothDevice, List<Integer>> mActiveSourceMap = new ConcurrentHashMap<>();

    private final FeatureFlags mFeatureFlags;

    private final Map<BluetoothDevice, BluetoothLeBroadcastMetadata> mBroadcastMetadataMap =

            new ConcurrentHashMap<>();

    private final LinkedList<BluetoothDevice> mPausedBroadcastSinks = new LinkedList<>();



    private HandlerThread mStateMachinesThread;

    private HandlerThread mCallbackHandlerThread;
@@ -428,9 +424,6 @@ public class BassClientService extends ProfileService { 
        if (mCachedBroadcasts != null) {

            mCachedBroadcasts.clear();

        }

        if (mBroadcastMetadataMap != null) {

            mBroadcastMetadataMap.clear();

        }

        if (mSyncHandleToBroadcastIdMap != null) {

            mSyncHandleToBroadcastIdMap.clear();

            mSyncHandleToBroadcastIdMap = null;
@@ -1217,9 +1210,6 @@ public class BassClientService extends ProfileService { 
            return;

        }



        /* Store metadata for sink device */

        mBroadcastMetadataMap.put(sink, sourceMetadata);



        byte[] code = sourceMetadata.getBroadcastCode();

        for (BluetoothDevice device : devices) {

            BassClientStateMachine stateMachine = getOrCreateStateMachine(device);
@@ -1311,9 +1301,6 @@ public class BassClientService extends ProfileService { 
            return;

        }



        /* Update metadata for sink device */

        mBroadcastMetadataMap.put(sink, updatedMetadata);



        byte[] code = updatedMetadata.getBroadcastCode();

        for (Map.Entry<BluetoothDevice, Integer> deviceSourceIdPair : devices.entrySet()) {

            BluetoothDevice device = deviceSourceIdPair.getKey();
@@ -1392,12 +1379,6 @@ public class BassClientService extends ProfileService { 
            BluetoothDevice device = deviceSourceIdPair.getKey();

            Integer deviceSourceId = deviceSourceIdPair.getValue();

            BassClientStateMachine stateMachine = getOrCreateStateMachine(device);



            /* Removes metadata for sink device if not paused */

            if (!mPausedBroadcastSinks.contains(device)) {

                mBroadcastMetadataMap.remove(device);

            }



            if (stateMachine == null) {

                log("removeSource: Error bad parameters: device = " + device);

                mCallbacks.notifySourceRemoveFailed(device, sourceId,
@@ -1529,54 +1510,6 @@ public class BassClientService extends ProfileService { 
        }

    }



    private void stopLocalSourceReceivers(int broadcastId, boolean store) {

        if (DBG) {

            Log.d(TAG, "stopLocalSourceReceivers()");

        }



        if (store && !mPausedBroadcastSinks.isEmpty()) {

            Log.w(TAG, "stopLocalSourceReceivers(), paused broadcast sinks are replaced");

            mPausedBroadcastSinks.clear();

        }



        for (BluetoothDevice device : getConnectedDevices()) {

            for (BluetoothLeBroadcastReceiveState receiveState : getAllSources(device)) {

                /* Check if local/last broadcast is the synced one */

                if (receiveState.getBroadcastId() != broadcastId) continue;



                removeSource(device, receiveState.getSourceId());



                if (store && !mPausedBroadcastSinks.contains(device)) {

                    mPausedBroadcastSinks.add(device);

                }

            }

        }

    }



    /** Request receivers to suspend broadcast sources synchronization */

    public void suspendReceiversSourceSynchronization(int broadcastId) {

        sEventLogger.logd(DBG, TAG, "Suspend receivers source synchronization: " + broadcastId);

        stopLocalSourceReceivers(broadcastId, true);

    }



    /** Request receivers to stop broadcast sources synchronization and remove them */

    public void stopReceiversSourceSynchronization(int broadcastId) {

        sEventLogger.logd(DBG, TAG, "Stop receivers source synchronization: " + broadcastId);

        stopLocalSourceReceivers(broadcastId, false);

    }



    /** Request receivers to resume broadcast source synchronization */

    public void resumeReceiversSourceSynchronization(int broadcastId) {

        sEventLogger.logd(DBG, TAG, "Resume receivers source synchronization: " + broadcastId);



        while (!mPausedBroadcastSinks.isEmpty()) {

            BluetoothDevice sink = mPausedBroadcastSinks.remove();

            BluetoothLeBroadcastMetadata metadata = mBroadcastMetadataMap.get(sink);



            addSource(sink, metadata, true);

        }

    }



    /**

     * Callback handler

     */

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

+43 −273

File changed.

Preview size limit exceeded, changes collapsed.

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

+28 −269
Original line number Diff line number Diff line
@@ -17,7 +17,6 @@ 


package com.android.bluetooth.le_audio;



import static android.bluetooth.IBluetoothLeAudio.LE_AUDIO_GROUP_ID_INVALID;

import static org.mockito.Mockito.*;



import android.annotation.Nullable;
@@ -35,8 +34,6 @@ import androidx.test.filters.MediumTest; 
import androidx.test.rule.ServiceTestRule;

import androidx.test.runner.AndroidJUnit4;



import com.android.bluetooth.flags.FakeFeatureFlagsImpl;

import com.android.bluetooth.flags.Flags;

import com.android.bluetooth.TestUtils;

import com.android.bluetooth.btservice.ActiveDeviceManager;

import com.android.bluetooth.btservice.AdapterService;
@@ -53,6 +50,7 @@ import org.mockito.MockitoAnnotations; 
import org.mockito.Spy;



import java.util.concurrent.LinkedBlockingQueue;

import java.util.concurrent.TimeoutException;

import java.util.List;



@MediumTest
@@ -67,7 +65,6 @@ public class LeAudioBroadcastServiceTest { 
    private LeAudioService mService;

    private LeAudioIntentReceiver mLeAudioIntentReceiver;

    private LinkedBlockingQueue<Intent> mIntentQueue;

    private FakeFeatureFlagsImpl mFakeFlagsImpl;

    @Mock private ActiveDeviceManager mActiveDeviceManager;

    @Mock

    private AdapterService mAdapterService;
@@ -187,21 +184,11 @@ public class LeAudioBroadcastServiceTest { 


        mAdapter = BluetoothAdapter.getDefaultAdapter();



        mFakeFlagsImpl = new FakeFeatureFlagsImpl();

        mFakeFlagsImpl.setFlag(Flags.FLAG_AUDIO_ROUTING_CENTRALIZATION, true);

        mFakeFlagsImpl.setFlag(Flags.FLAG_LEAUDIO_BROADCAST_AUDIO_HANDOVER_POLICIES, false);



        LeAudioBroadcasterNativeInterface.setInstance(mLeAudioBroadcasterNativeInterface);

        LeAudioNativeInterface.setInstance(mLeAudioNativeInterface);

        mService = new LeAudioService(mTargetContext, mFakeFlagsImpl);

        mService.doStart();

        startService();

        mService.mAudioManager = mAudioManager;



        LeAudioStackEvent stackEvent =

                new LeAudioStackEvent(LeAudioStackEvent.EVENT_TYPE_NATIVE_INITIALIZED);

        mService.messageFromNative(stackEvent);

        Assert.assertTrue(mService.mLeAudioNativeIsInitialized);



        // Set up the State Changed receiver

        IntentFilter filter = new IntentFilter();

        filter.setPriority(IntentFilter.SYSTEM_HIGH_PRIORITY);
@@ -222,7 +209,7 @@ public class LeAudioBroadcastServiceTest { 
            return;

        }



        mService.doStop();

        stopService();

        LeAudioBroadcasterNativeInterface.setInstance(null);

        LeAudioNativeInterface.setInstance(null);

        mTargetContext.unregisterReceiver(mLeAudioIntentReceiver);
@@ -230,6 +217,18 @@ public class LeAudioBroadcastServiceTest { 
        reset(mAudioManager);

    }



    private void startService() throws TimeoutException {

        TestUtils.startService(mServiceRule, LeAudioService.class);

        mService = LeAudioService.getLeAudioService();

        Assert.assertNotNull(mService);

    }



    private void stopService() throws TimeoutException {

        TestUtils.stopService(mServiceRule, LeAudioService.class);

        mService = LeAudioService.getLeAudioService();

        Assert.assertNull(mService);

    }



    /**

     * Test getting LeAudio Service

     */
@@ -534,11 +533,20 @@ public class LeAudioBroadcastServiceTest { 
        }

    }



    private void prepareConnectedUnicastDevice(int groupId) {

    @Test

    public void testCreatePendingBroadcast() {

        int groupId = 1;

        int direction = 3;

        int snkAudioLocation = 3;

        int srcAudioLocation = 4;

        int availableContexts = 5;

        byte[] code = {0x00, 0x01, 0x00, 0x02};



        BluetoothLeAudioContentMetadata.Builder meta_builder =

                new BluetoothLeAudioContentMetadata.Builder();

        meta_builder.setLanguage("ENG");

        meta_builder.setProgramInfo("Public broadcast info");

        BluetoothLeAudioContentMetadata meta = meta_builder.build();



        /* Prepare active group to cause pending broadcast */

        doReturn(BluetoothDevice.BOND_BONDED)
@@ -589,38 +597,20 @@ public class LeAudioBroadcastServiceTest { 
        create_event.valueInt4 = srcAudioLocation;

        create_event.valueInt5 = availableContexts;

        mService.messageFromNative(create_event);

    }



    @Test

    public void testCreatePendingBroadcast() {

        int groupId = 1;

        byte[] code = {0x00, 0x01, 0x00, 0x02};



        prepareConnectedUnicastDevice(groupId);



        LeAudioStackEvent create_event =

                new LeAudioStackEvent(LeAudioStackEvent.EVENT_TYPE_GROUP_STATUS_CHANGED);

        create_event = new LeAudioStackEvent(LeAudioStackEvent.EVENT_TYPE_GROUP_STATUS_CHANGED);

        create_event.valueInt1 = groupId;

        create_event.valueInt2 = LeAudioStackEvent.GROUP_STATUS_ACTIVE;

        mService.messageFromNative(create_event);



        /* Prepare create broadcast */

        BluetoothLeAudioContentMetadata.Builder meta_builder =

                new BluetoothLeAudioContentMetadata.Builder();

        meta_builder.setLanguage("ENG");

        meta_builder.setProgramInfo("Public broadcast info");

        BluetoothLeAudioContentMetadata meta = meta_builder.build();



        BluetoothLeBroadcastSettings settings = buildBroadcastSettingsFromMetadata(meta, code, 1);

        mService.createBroadcast(settings);



        /* Active group should become inactive */

        /* Check if broadcast is queued, active group should not change */

        int activeGroup = mService.getActiveGroupId();

        Assert.assertEquals(activeGroup, LE_AUDIO_GROUP_ID_INVALID);

        Assert.assertEquals(activeGroup, groupId);



        /* Imitate group inactivity to cause create broadcast */

        create_event = new LeAudioStackEvent(LeAudioStackEvent.EVENT_TYPE_GROUP_STATUS_CHANGED);

        create_event.valueInt1 = groupId;

        create_event.valueInt2 = LeAudioStackEvent.GROUP_STATUS_INACTIVE;

        mService.messageFromNative(create_event);
@@ -674,237 +664,6 @@ public class LeAudioBroadcastServiceTest { 
                mOnBroadcastStartFailedReason);

    }



    @Test

    public void testInCallDrivenBroadcastSwitch() {

        mFakeFlagsImpl.setFlag(Flags.FLAG_LEAUDIO_BROADCAST_AUDIO_HANDOVER_POLICIES, true);

        int groupId = 1;

        int broadcastId = 243;

        byte[] code = {0x00, 0x01, 0x00, 0x02};



        mService.mBroadcastCallbacks.register(mCallbacks);



        prepareConnectedUnicastDevice(groupId);



        LeAudioStackEvent create_event =

                new LeAudioStackEvent(LeAudioStackEvent.EVENT_TYPE_GROUP_STATUS_CHANGED);

        create_event.valueInt1 = groupId;

        create_event.valueInt2 = LeAudioStackEvent.GROUP_STATUS_ACTIVE;

        mService.messageFromNative(create_event);



        /* Prepare create broadcast */

        BluetoothLeAudioContentMetadata.Builder meta_builder =

                new BluetoothLeAudioContentMetadata.Builder();

        meta_builder.setLanguage("ENG");

        meta_builder.setProgramInfo("Public broadcast info");

        BluetoothLeAudioContentMetadata meta = meta_builder.build();



        BluetoothLeBroadcastSettings settings = buildBroadcastSettingsFromMetadata(meta, code, 1);

        mService.createBroadcast(settings);



        /* Active group should become inactive */

        int activeGroup = mService.getActiveGroupId();

        Assert.assertEquals(activeGroup, LE_AUDIO_GROUP_ID_INVALID);



        /* Imitate group inactivity to cause create broadcast */

        create_event = new LeAudioStackEvent(LeAudioStackEvent.EVENT_TYPE_GROUP_STATUS_CHANGED);

        create_event.valueInt1 = groupId;

        create_event.valueInt2 = LeAudioStackEvent.GROUP_STATUS_INACTIVE;

        mService.messageFromNative(create_event);



        List<BluetoothLeBroadcastSubgroupSettings> settingsList = settings.getSubgroupSettings();



        int[] expectedQualityArray =

                settingsList.stream().mapToInt(setting -> setting.getPreferredQuality()).toArray();

        byte[][] expectedDataArray =

                settingsList.stream()

                        .map(setting -> setting.getContentMetadata().getRawMetadata())

                        .toArray(byte[][]::new);



        verify(mLeAudioBroadcasterNativeInterface, times(1))

                .createBroadcast(

                        eq(true),

                        eq(TEST_BROADCAST_NAME),

                        eq(settings.getBroadcastCode()),

                        eq(settings.getPublicBroadcastMetadata().getRawMetadata()),

                        eq(expectedQualityArray),

                        eq(expectedDataArray));



        activeGroup = mService.getActiveGroupId();

        Assert.assertEquals(LE_AUDIO_GROUP_ID_INVALID, activeGroup);



        /* Check if broadcast is started automatically when created */

        create_event = new LeAudioStackEvent(LeAudioStackEvent.EVENT_TYPE_BROADCAST_CREATED);

        create_event.valueInt1 = broadcastId;

        create_event.valueBool1 = true;

        mService.messageFromNative(create_event);



        /* Verify if broadcast is auto-started on start */

        verify(mLeAudioBroadcasterNativeInterface, times(1)).startBroadcast(eq(broadcastId));



        /* Switch to active streaming */

        create_event = new LeAudioStackEvent(LeAudioStackEvent.EVENT_TYPE_BROADCAST_STATE);

        create_event.valueInt1 = broadcastId;

        create_event.valueInt2 = LeAudioStackEvent.BROADCAST_STATE_STREAMING;

        mService.messageFromNative(create_event);



        /* Imitate setting device in call */

        mService.setInCall(true);



        /* Check if broadcast is paused by InCall handling */

        verify(mLeAudioBroadcasterNativeInterface, times(1)).pauseBroadcast(eq(broadcastId));



        LeAudioStackEvent state_event =

                new LeAudioStackEvent(LeAudioStackEvent.EVENT_TYPE_BROADCAST_STATE);

        state_event.valueInt1 = broadcastId;

        state_event.valueInt2 = LeAudioStackEvent.BROADCAST_STATE_PAUSED;

        mService.messageFromNative(state_event);



        verify(mLeAudioNativeInterface, times(1)).setInCall(eq(true));



        create_event = new LeAudioStackEvent(LeAudioStackEvent.EVENT_TYPE_GROUP_STATUS_CHANGED);

        create_event.valueInt1 = groupId;

        create_event.valueInt2 = LeAudioStackEvent.GROUP_STATUS_ACTIVE;

        mService.messageFromNative(create_event);



        /* Active group should become the one that was active before broadcasting */

        activeGroup = mService.getActiveGroupId();

        Assert.assertEquals(activeGroup, groupId);



        /* Imitate setting device not in call */

        mService.setInCall(false);



        verify(mLeAudioNativeInterface, times(2)).groupSetActive(eq(LE_AUDIO_GROUP_ID_INVALID));



        /* Imitate group inactivity to cause start broadcast */

        create_event = new LeAudioStackEvent(LeAudioStackEvent.EVENT_TYPE_GROUP_STATUS_CHANGED);

        create_event.valueInt1 = groupId;

        create_event.valueInt2 = LeAudioStackEvent.GROUP_STATUS_INACTIVE;

        mService.messageFromNative(create_event);



        /* Verify if broadcast is auto-started on start */

        verify(mLeAudioBroadcasterNativeInterface, times(2)).startBroadcast(eq(broadcastId));

    }



    @Test

    public void testBroadcastResumeUnicastGroupChangeRequestDriven() {

        mFakeFlagsImpl.setFlag(Flags.FLAG_LEAUDIO_BROADCAST_AUDIO_HANDOVER_POLICIES, true);

        int groupId = 1;

        int broadcastId = 243;

        byte[] code = {0x00, 0x01, 0x00, 0x02};



        mService.mBroadcastCallbacks.register(mCallbacks);



        prepareConnectedUnicastDevice(groupId);



        LeAudioStackEvent create_event =

                new LeAudioStackEvent(LeAudioStackEvent.EVENT_TYPE_GROUP_STATUS_CHANGED);

        create_event.valueInt1 = groupId;

        create_event.valueInt2 = LeAudioStackEvent.GROUP_STATUS_ACTIVE;

        mService.messageFromNative(create_event);



        /* Prepare create broadcast */

        BluetoothLeAudioContentMetadata.Builder meta_builder =

                new BluetoothLeAudioContentMetadata.Builder();

        meta_builder.setLanguage("ENG");

        meta_builder.setProgramInfo("Public broadcast info");

        BluetoothLeAudioContentMetadata meta = meta_builder.build();



        BluetoothLeBroadcastSettings settings = buildBroadcastSettingsFromMetadata(meta, code, 1);

        mService.createBroadcast(settings);



        /* Active group should become inactive */

        int activeGroup = mService.getActiveGroupId();

        Assert.assertEquals(activeGroup, LE_AUDIO_GROUP_ID_INVALID);



        /* Imitate group inactivity to cause create broadcast */

        create_event = new LeAudioStackEvent(LeAudioStackEvent.EVENT_TYPE_GROUP_STATUS_CHANGED);

        create_event.valueInt1 = groupId;

        create_event.valueInt2 = LeAudioStackEvent.GROUP_STATUS_INACTIVE;

        mService.messageFromNative(create_event);



        List<BluetoothLeBroadcastSubgroupSettings> settingsList = settings.getSubgroupSettings();



        int[] expectedQualityArray =

                settingsList.stream().mapToInt(setting -> setting.getPreferredQuality()).toArray();

        byte[][] expectedDataArray =

                settingsList.stream()

                        .map(setting -> setting.getContentMetadata().getRawMetadata())

                        .toArray(byte[][]::new);



        verify(mLeAudioBroadcasterNativeInterface, times(1))

                .createBroadcast(

                        eq(true),

                        eq(TEST_BROADCAST_NAME),

                        eq(settings.getBroadcastCode()),

                        eq(settings.getPublicBroadcastMetadata().getRawMetadata()),

                        eq(expectedQualityArray),

                        eq(expectedDataArray));

        verify(mLeAudioNativeInterface, times(1))

                .setUnicastMonitorMode(eq(LeAudioStackEvent.DIRECTION_SINK),eq(true));



        activeGroup = mService.getActiveGroupId();

        Assert.assertEquals(LE_AUDIO_GROUP_ID_INVALID, activeGroup);



        /* Check if broadcast is started automatically when created */

        create_event = new LeAudioStackEvent(LeAudioStackEvent.EVENT_TYPE_BROADCAST_CREATED);

        create_event.valueInt1 = broadcastId;

        create_event.valueBool1 = true;

        mService.messageFromNative(create_event);



        /* Verify if broadcast is auto-started on start */

        verify(mLeAudioBroadcasterNativeInterface, times(1)).startBroadcast(eq(broadcastId));



        /* Switch to active streaming */

        create_event = new LeAudioStackEvent(LeAudioStackEvent.EVENT_TYPE_BROADCAST_STATE);

        create_event.valueInt1 = broadcastId;

        create_event.valueInt2 = LeAudioStackEvent.BROADCAST_STATE_STREAMING;

        mService.messageFromNative(create_event);



        /* Verify if broadcast is auto-started on start */

        verify(mLeAudioBroadcasterNativeInterface, times(1)).startBroadcast(eq(broadcastId));



        /* Imitate group change request by Bluetooth Sink HAL resume request */

        create_event = new LeAudioStackEvent(LeAudioStackEvent.EVENT_TYPE_UNICAST_MONITOR_MODE_STATUS);

        create_event.valueInt1 = LeAudioStackEvent.DIRECTION_SINK;

        create_event.valueInt2 = LeAudioStackEvent.STATUS_LOCAL_STREAM_REQUESTED;

        mService.messageFromNative(create_event);



        /* Check if broadcast is paused triggered by group change request */

        verify(mLeAudioBroadcasterNativeInterface, times(1)).pauseBroadcast(eq(broadcastId));



        LeAudioStackEvent state_event =

                new LeAudioStackEvent(LeAudioStackEvent.EVENT_TYPE_BROADCAST_STATE);

        state_event.valueInt1 = broadcastId;

        state_event.valueInt2 = LeAudioStackEvent.BROADCAST_STATE_PAUSED;

        mService.messageFromNative(state_event);



        create_event = new LeAudioStackEvent(LeAudioStackEvent.EVENT_TYPE_GROUP_STATUS_CHANGED);

        create_event.valueInt1 = groupId;

        create_event.valueInt2 = LeAudioStackEvent.GROUP_STATUS_ACTIVE;

        mService.messageFromNative(create_event);



        /* Active group should become the one that was active before broadcasting */

        activeGroup = mService.getActiveGroupId();

        Assert.assertEquals(activeGroup, groupId);



        /* Imitate group change request by Bluetooth Sink HAL suspend request */

        create_event = new LeAudioStackEvent(LeAudioStackEvent.EVENT_TYPE_UNICAST_MONITOR_MODE_STATUS);

        create_event.valueInt1 = LeAudioStackEvent.DIRECTION_SINK;

        create_event.valueInt2 = LeAudioStackEvent.STATUS_LOCAL_STREAM_SUSPENDED;

        mService.messageFromNative(create_event);



        verify(mLeAudioNativeInterface, times(2)).groupSetActive(eq(LE_AUDIO_GROUP_ID_INVALID));



        /* Imitate group inactivity to cause start broadcast */

        create_event = new LeAudioStackEvent(LeAudioStackEvent.EVENT_TYPE_GROUP_STATUS_CHANGED);

        create_event.valueInt1 = groupId;

        create_event.valueInt2 = LeAudioStackEvent.GROUP_STATUS_INACTIVE;

        mService.messageFromNative(create_event);



        /* Verify if broadcast is auto-started on start */

        verify(mLeAudioBroadcasterNativeInterface, times(2)).startBroadcast(eq(broadcastId));

    }



    private class LeAudioIntentReceiver extends BroadcastReceiver {

        @Override

        public void onReceive(Context context, Intent intent) {

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

+16 −11
Original line number Diff line number Diff line
@@ -194,17 +194,8 @@ public class LeAudioServiceTest { 
        doAnswer(invocation -> mBondedDevices.toArray(new BluetoothDevice[]{})).when(

                mAdapterService).getBondedDevices();



        mFakeFlagsImpl = new FakeFeatureFlagsImpl();

        mFakeFlagsImpl.setFlag(Flags.FLAG_LEAUDIO_UNICAST_INACTIVATE_DEVICE_BASED_ON_CONTEXT,

                false);

        mFakeFlagsImpl.setFlag(Flags.FLAG_AUDIO_ROUTING_CENTRALIZATION,

                false);

        mFakeFlagsImpl.setFlag(Flags.FLAG_LEAUDIO_BROADCAST_AUDIO_HANDOVER_POLICIES, false);



        LeAudioNativeInterface.setInstance(mNativeInterface);

        mService = new LeAudioService(mTargetContext, mFakeFlagsImpl);

        mService.doStart();



        startService();

        mService.mAudioManager = mAudioManager;

        mService.mMcpService = mMcpService;

        mService.mTbsService = mTbsService;
@@ -265,7 +256,7 @@ public class LeAudioServiceTest { 


        mBondedDevices.clear();

        mGroupIntentQueue.clear();

        mService.doStop();

        stopService();

        if (mDeviceQueueMap != null) {

            mDeviceQueueMap.clear();

        }
@@ -273,6 +264,18 @@ public class LeAudioServiceTest { 
        LeAudioNativeInterface.setInstance(null);

    }



    private void startService() throws TimeoutException {

        TestUtils.startService(mServiceRule, LeAudioService.class);

        mService = LeAudioService.getLeAudioService();

        assertThat(mService).isNotNull();

    }



    private void stopService() throws TimeoutException {

        TestUtils.stopService(mServiceRule, LeAudioService.class);

        mService = LeAudioService.getLeAudioService();

        assertThat(mService).isNull();

    }



    private class LeAudioIntentReceiver extends BroadcastReceiver {

        @Override

        public void onReceive(Context context, Intent intent) {
@@ -1539,8 +1542,10 @@ public class LeAudioServiceTest { 
    @Test

    public void testMediaContextUnavailableForAWhile() {



        mFakeFlagsImpl = new FakeFeatureFlagsImpl();

        mFakeFlagsImpl.setFlag(Flags.FLAG_LEAUDIO_UNICAST_INACTIVATE_DEVICE_BASED_ON_CONTEXT, true);

        mFakeFlagsImpl.setFlag(Flags.FLAG_AUDIO_ROUTING_CENTRALIZATION, true);

        mService.setFeatureFlags(mFakeFlagsImpl);



        doReturn(true).when(mNativeInterface).connectLeAudio(any(BluetoothDevice.class));

        connectTestDevice(mSingleDevice, testGroupId);