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

Commit eb2ebada authored by Jakub Pawłowski's avatar Jakub Pawłowski Committed by Automerger Merge Worker
Browse files

Merge changes from topic "fix-unit-leaudioservice" am: 0248db45 am: 3a4245d4 am: d401edbd 

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



Change-Id: I1eb1cf03acf85306a6e72f32fb08a6262d9c77a7
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents 0eb80390 d401edbd

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

+73 −12
Original line number Diff line number Diff line
@@ -115,17 +115,21 @@ public class LeAudioService extends ProfileService { 
    private volatile BluetoothDevice mActiveAudioOutDevice;

    private volatile BluetoothDevice mActiveAudioInDevice;

    private LeAudioCodecConfig mLeAudioCodecConfig;

    private Object mGroupLock = new Object();

    private final Object mGroupLock = new Object();

    ServiceFactory mServiceFactory = new ServiceFactory();



    LeAudioNativeInterface mLeAudioNativeInterface;

    boolean mLeAudioNativeIsInitialized = false;

    boolean mBluetoothEnabled = false;

    BluetoothDevice mHfpHandoverDevice = null;

    LeAudioBroadcasterNativeInterface mLeAudioBroadcasterNativeInterface = null;

    @VisibleForTesting

    AudioManager mAudioManager;

    LeAudioTmapGattServer mTmapGattServer;



    @VisibleForTesting

    McpService mMcpService;



    @VisibleForTesting

    VolumeControlService mVolumeControlService;
@@ -330,6 +334,7 @@ public class LeAudioService extends ProfileService { 
        mLeAudioNativeInterface.cleanup();

        mLeAudioNativeInterface = null;

        mLeAudioNativeIsInitialized = false;

        mBluetoothEnabled = false;

        mHfpHandoverDevice = null;



        mActiveAudioOutDevice = null;
@@ -391,6 +396,7 @@ public class LeAudioService extends ProfileService { 


        mAdapterService = null;

        mAudioManager = null;

        mMcpService = null;

        mVolumeControlService = null;



        return true;
@@ -895,7 +901,13 @@ public class LeAudioService extends ProfileService { 
        return false;

    }



    private void notifyActiveDeviceChanged() {

    /**

     * Send broadcast intent about LeAudio active device.

     * This is called when AudioManager confirms, LeAudio device

     * is added or removed.

     */

    @VisibleForTesting

    void notifyActiveDeviceChanged() {

        Intent intent = new Intent(BluetoothLeAudio.ACTION_LE_AUDIO_ACTIVE_DEVICE_CHANGED);

        intent.putExtra(BluetoothDevice.EXTRA_DEVICE,

                mActiveAudioOutDevice != null ? mActiveAudioOutDevice : mActiveAudioInDevice);
@@ -1683,11 +1695,6 @@ public class LeAudioService extends ProfileService { 
            } else {

                Log.e(TAG, "no descriptors for group: " + myGroupId);

            }



            McpService mcpService = mServiceFactory.getMcpService();

            if (mcpService != null) {

                mcpService.setDeviceAuthorized(device, true);

            }

        }

        // Check if the device is disconnected - if unbond, remove the state machine

        if (toState == BluetoothProfile.STATE_DISCONNECTED) {
@@ -1699,11 +1706,6 @@ public class LeAudioService extends ProfileService { 
                removeStateMachine(device);

            }



            McpService mcpService = mServiceFactory.getMcpService();

            if (mcpService != null) {

                mcpService.setDeviceAuthorized(device, false);

            }



            int myGroupId = getGroupId(device);

            LeAudioGroupDescriptor descriptor = getGroupDescriptor(myGroupId);

            if (descriptor == null) {
@@ -1971,6 +1973,50 @@ public class LeAudioService extends ProfileService { 
        }

    }



    McpService getMcpService() {

        if (mMcpService != null) {

            return mMcpService;

        }



        mMcpService = mServiceFactory.getMcpService();

        return mMcpService;

    }



    /**

     * This function is called when the framework registers

     * a callback with the service for this first time.

     * This is used as an indication that Bluetooth has been enabled.

     * 

     * It is used to authorize all known LeAudio devices in the services

     * which requires that e.g. GMCS

     */

    @VisibleForTesting

    void handleBluetoothEnabled() {

        if (DBG) {

            Log.d(TAG, "handleBluetoothEnabled ");

        }



        mBluetoothEnabled = true;



        synchronized (mGroupLock) {

            if (mDeviceGroupIdMap.isEmpty()) {

                return;

            }

        }



        McpService mcpService = getMcpService();

        if (mcpService == null) {

            Log.e(TAG, "mcpService not available ");

            return;

        }



        synchronized (mGroupLock) {

            for (Map.Entry<BluetoothDevice, Integer> entry : mDeviceGroupIdMap.entrySet()) {

                mcpService.setDeviceAuthorized(entry.getKey(), true);

            }

        }

    }



    private LeAudioGroupDescriptor getGroupDescriptor(int groupId) {

        synchronized (mGroupLock) {

            return mGroupDescriptors.get(groupId);
@@ -1990,6 +2036,13 @@ public class LeAudioService extends ProfileService { 
            }

            notifyGroupNodeAdded(device, groupId);

        }



        if (mBluetoothEnabled) {

            McpService mcpService = getMcpService();

            if (mcpService != null) {

                mcpService.setDeviceAuthorized(device, true);

            }

        }

    }



    private void notifyGroupNodeAdded(BluetoothDevice device, int groupId) {
@@ -2033,6 +2086,11 @@ public class LeAudioService extends ProfileService { 
            }

            notifyGroupNodeRemoved(device, groupId);

        }



        McpService mcpService = getMcpService();

        if (mcpService != null) {

            mcpService.setDeviceAuthorized(device, false);

        }

    }



    private void notifyGroupNodeRemoved(BluetoothDevice device, int groupId) {
@@ -2668,6 +2726,9 @@ public class LeAudioService extends ProfileService { 


                enforceBluetoothPrivilegedPermission(service);

                service.mLeAudioCallbacks.register(callback);

                if (!service.mBluetoothEnabled) {

                    service.handleBluetoothEnabled();

                }

                receiver.send(null);

            } catch (RuntimeException e) {

                receiver.propagateException(e);

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

+80 −35
Original line number Diff line number Diff line
@@ -28,7 +28,6 @@ import static org.mockito.Mockito.doNothing; 
import static org.mockito.Mockito.doReturn;

import static org.mockito.Mockito.eq;

import static org.mockito.Mockito.never;

import static org.mockito.Mockito.spy;

import static org.mockito.Mockito.timeout;

import static org.mockito.Mockito.times;

import static org.mockito.Mockito.verify;
@@ -47,8 +46,6 @@ import android.content.BroadcastReceiver; 
import android.content.Context;

import android.content.Intent;

import android.content.IntentFilter;

import android.media.AudioDeviceCallback;

import android.media.AudioDeviceInfo;

import android.media.AudioManager;

import android.media.BluetoothProfileConnectionInfo;

import android.os.Parcel;
@@ -65,12 +62,12 @@ import com.android.bluetooth.btservice.AdapterService; 
import com.android.bluetooth.btservice.ServiceFactory;

import com.android.bluetooth.btservice.storage.DatabaseManager;

import com.android.bluetooth.hfp.HeadsetService;

import com.android.bluetooth.mcp.McpService;

import com.android.bluetooth.vc.VolumeControlService;



import org.junit.After;

import org.junit.Assume;

import org.junit.Before;

import org.junit.Ignore;

import org.junit.Rule;

import org.junit.Test;

import org.junit.runner.RunWith;
@@ -113,12 +110,13 @@ public class LeAudioServiceTest { 
    private BroadcastReceiver mLeAudioIntentReceiver;



    @Mock private AdapterService mAdapterService;

    @Mock private AudioManager mAudioManager;

    @Mock private DatabaseManager mDatabaseManager;

    @Mock private LeAudioNativeInterface mNativeInterface;

    @Mock private VolumeControlService mVolumeControlService;

    @Mock private LeAudioTmapGattServer mTmapGattServer;

    @Mock private McpService mMcpService;

    @Mock private VolumeControlService mVolumeControlService;

    @Spy private LeAudioObjectsFactory mObjectsFactory = LeAudioObjectsFactory.getInstance();

    @Spy private AudioManager mAudioManager;

    @Spy private ServiceFactory mServiceFactory = new ServiceFactory();



    @Rule public final ServiceTestRule mServiceRule = new ServiceTestRule();
@@ -182,8 +180,8 @@ public class LeAudioServiceTest { 


        LeAudioNativeInterface.setInstance(mNativeInterface);

        startService();

        mAudioManager = spy(mService.mAudioManager);

        mService.mAudioManager = mAudioManager;

        mService.mMcpService = mMcpService;

        mService.mServiceFactory = mServiceFactory;

        when(mServiceFactory.getVolumeControlService()).thenReturn(mVolumeControlService);
@@ -865,6 +863,24 @@ public class LeAudioServiceTest { 
        verifyNoConnectionStateIntent(TIMEOUT_MS, device);

    }



    private void generateGroupNodeAdded(BluetoothDevice device, int groupId) {

        LeAudioStackEvent nodeGroupAdded =

        new LeAudioStackEvent(LeAudioStackEvent.EVENT_TYPE_GROUP_NODE_STATUS_CHANGED);

        nodeGroupAdded.device = device;

        nodeGroupAdded.valueInt1 = groupId;

        nodeGroupAdded.valueInt2 = LeAudioStackEvent.GROUP_NODE_ADDED;

        mService.messageFromNative(nodeGroupAdded);

    }



    private void generateGroupNodeRemoved(BluetoothDevice device, int groupId) {

        LeAudioStackEvent nodeGroupRemoved =

        new LeAudioStackEvent(LeAudioStackEvent.EVENT_TYPE_GROUP_NODE_STATUS_CHANGED);

        nodeGroupRemoved.device = device;

        nodeGroupRemoved.valueInt1 = groupId;

        nodeGroupRemoved.valueInt2 = LeAudioStackEvent.GROUP_NODE_REMOVED;

        mService.messageFromNative(nodeGroupRemoved);

    }



    private void verifyNoConnectionStateIntent(int timeoutMs, BluetoothDevice device) {

        Intent intent = TestUtils.waitForNoIntent(timeoutMs, mDeviceQueueMap.get(device));

        assertThat(intent).isNull();
@@ -1102,7 +1118,6 @@ public class LeAudioServiceTest { 
     * Test native interface audio configuration changed message handling

     */

    @Test

    @Ignore("b/258573934")

    public void testMessageFromNativeAudioConfChangedActiveGroup() {

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

        connectTestDevice(mSingleDevice, testGroupId);
@@ -1110,16 +1125,16 @@ public class LeAudioServiceTest { 
                         BluetoothLeAudio.CONTEXT_TYPE_CONVERSATIONAL, 3);

        injectGroupStatusChange(testGroupId, BluetoothLeAudio.GROUP_STATUS_ACTIVE);



        String action = BluetoothLeAudio.ACTION_LE_AUDIO_ACTIVE_DEVICE_CHANGED;



        ArgumentCaptor<AudioDeviceCallback> audioDeviceCallback =

                ArgumentCaptor.forClass(AudioDeviceCallback.class);

        verify(mAudioManager, times(1)).registerAudioDeviceCallback(audioDeviceCallback.capture(),

                any());

        AudioDeviceInfo audioDeviceInfo[] =

                mAudioManager.getDevices(AudioManager.GET_DEVICES_OUTPUTS);

        audioDeviceCallback.getValue().onAudioDevicesAdded(audioDeviceInfo);

        /* Expect 2 calles to Audio Manager - one for output and second for input as this is

         * Conversational use case */

        verify(mAudioManager, times(2)).handleBluetoothActiveDeviceChanged(any(), any(),

                        any(BluetoothProfileConnectionInfo.class));

        /* Since LeAudioService called AudioManager - assume Audio manager calles properly callback

        * mAudioManager.onAudioDeviceAdded

        */

        mService.notifyActiveDeviceChanged();



        String action = BluetoothLeAudio.ACTION_LE_AUDIO_ACTIVE_DEVICE_CHANGED;

        Intent intent = TestUtils.waitForIntent(TIMEOUT_MS, mDeviceQueueMap.get(mSingleDevice));

        assertThat(intent).isNotNull();

        assertThat(action).isEqualTo(intent.getAction());
@@ -1288,7 +1303,6 @@ public class LeAudioServiceTest { 
     * Test native interface group status message handling

     */

    @Test

    @Ignore("b/258573934")

    public void testLeadGroupDeviceDisconnects() {

        int groupId = 1;

        /* AUDIO_DIRECTION_OUTPUT_BIT = 0x01 */
@@ -1331,16 +1345,11 @@ public class LeAudioServiceTest { 
        assertThat(mService.getActiveDevices().contains(leadDevice)).isTrue();

        verify(mAudioManager, times(1)).handleBluetoothActiveDeviceChanged(eq(leadDevice), any(),

                        any(BluetoothProfileConnectionInfo.class));



        /* Since LeAudioService called AudioManager - assume Audio manager calles properly callback

         * mAudioManager.onAudioDeviceAdded

         */

        mService.notifyActiveDeviceChanged();

        doReturn(BluetoothDevice.BOND_BONDED).when(mAdapterService).getBondState(leadDevice);



        ArgumentCaptor<AudioDeviceCallback> audioDeviceCallback =

                ArgumentCaptor.forClass(AudioDeviceCallback.class);

        verify(mAudioManager, times(1)).registerAudioDeviceCallback(audioDeviceCallback.capture(),

                any());

        AudioDeviceInfo audioDeviceInfo[] =

                mAudioManager.getDevices(AudioManager.GET_DEVICES_OUTPUTS);

        audioDeviceCallback.getValue().onAudioDevicesAdded(audioDeviceInfo);

        verifyActiveDeviceStateIntent(AUDIO_MANAGER_DEVICE_ADD_TIMEOUT_MS, leadDevice);

        injectNoVerifyDeviceDisconnected(leadDevice);
@@ -1363,7 +1372,6 @@ public class LeAudioServiceTest { 
     * Test native interface group status message handling

     */

    @Test

    @Ignore("b/258573934")

    public void testLeadGroupDeviceReconnects() {

        int groupId = 1;

        /* AUDIO_DIRECTION_OUTPUT_BIT = 0x01 */
@@ -1406,14 +1414,11 @@ public class LeAudioServiceTest { 
        assertThat(mService.getActiveDevices().contains(leadDevice)).isTrue();

        verify(mAudioManager, times(1)).handleBluetoothActiveDeviceChanged(eq(leadDevice), any(),

                        any(BluetoothProfileConnectionInfo.class));

        /* Since LeAudioService called AudioManager - assume Audio manager calles properly callback

         * mAudioManager.onAudioDeviceAdded

         */

        mService.notifyActiveDeviceChanged();



        ArgumentCaptor<AudioDeviceCallback> audioDeviceCallback =

                ArgumentCaptor.forClass(AudioDeviceCallback.class);

        verify(mAudioManager, times(1)).registerAudioDeviceCallback(audioDeviceCallback.capture(),

                any());

        AudioDeviceInfo audioDeviceInfo[] =

                mAudioManager.getDevices(AudioManager.GET_DEVICES_OUTPUTS);

        audioDeviceCallback.getValue().onAudioDevicesAdded(audioDeviceInfo);

        verifyActiveDeviceStateIntent(AUDIO_MANAGER_DEVICE_ADD_TIMEOUT_MS, leadDevice);

        /* We don't want to distribute DISCONNECTION event, instead will try to reconnect

         * (in native)
@@ -1578,4 +1583,44 @@ public class LeAudioServiceTest { 
        StringBuilder sb = new StringBuilder();

        mService.dump(sb);

    }



    /**

     * Test setting authorization for LeAudio device in the McpService

     */

    @Test

    public void testAuthorizeMcpServiceWhenDeviceConnecting() {

        int groupId = 1;



        mService.handleBluetoothEnabled();

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

        connectTestDevice(mLeftDevice, groupId);

        connectTestDevice(mRightDevice, groupId);

        verify(mMcpService, times(1)).setDeviceAuthorized(mLeftDevice, true);

        verify(mMcpService, times(1)).setDeviceAuthorized(mRightDevice, true);

    }



    /**

     * Test setting authorization for LeAudio device in the McpService

     */

    @Test

    public void testAuthorizeMcpServiceOnBluetoothEnableAndNodeRemoval() {

        int groupId = 1;



        generateGroupNodeAdded(mLeftDevice, groupId);

        generateGroupNodeAdded(mRightDevice, groupId);



        verify(mMcpService, times(0)).setDeviceAuthorized(mLeftDevice, true);

        verify(mMcpService, times(0)).setDeviceAuthorized(mRightDevice, true);



        mService.handleBluetoothEnabled();



        verify(mMcpService, times(1)).setDeviceAuthorized(mLeftDevice, true);

        verify(mMcpService, times(1)).setDeviceAuthorized(mRightDevice, true);



        generateGroupNodeRemoved(mLeftDevice, groupId);

        verify(mMcpService, times(1)).setDeviceAuthorized(mLeftDevice, false);



        generateGroupNodeRemoved(mRightDevice, groupId);

        verify(mMcpService, times(1)).setDeviceAuthorized(mRightDevice, false);

    }

}