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

Commit b8f4cc2a authored by William Escande's avatar William Escande Committed by Automerger Merge Worker
Browse files

Merge "BassClientService: fix binder logic" into main am: dd572237 am: 1790783c 

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



Change-Id: Ieda693db9e59b3576983783ac63db64ba45e150e
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents f2ba56c5 1790783c

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

+83 −149
Original line number Diff line number Diff line
@@ -3744,86 +3744,62 @@ public class BassClientService extends ProfileService { 


        @Override

        public int getConnectionState(BluetoothDevice sink) {

            try {

            BassClientService service = getService();

            if (service == null) {

                Log.e(TAG, "Service is null");

                return BluetoothProfile.STATE_DISCONNECTED;

            }

            return service.getConnectionState(sink);

            } catch (RuntimeException e) {

                Log.e(TAG, "Exception happened", e);

                return BluetoothProfile.STATE_DISCONNECTED;

            }

        }



        @Override

        public List<BluetoothDevice> getDevicesMatchingConnectionStates(int[] states) {

            try {

            BassClientService service = getService();

            if (service == null) {

                Log.e(TAG, "Service is null");

                return Collections.emptyList();

            }

            return service.getDevicesMatchingConnectionStates(states);

            } catch (RuntimeException e) {

                Log.e(TAG, "Exception happened", e);

                return Collections.emptyList();

            }

        }



        @Override

        public List<BluetoothDevice> getConnectedDevices() {

            try {

            BassClientService service = getService();

            if (service == null) {

                Log.e(TAG, "Service is null");

                return Collections.emptyList();

            }

            return service.getConnectedDevices();

            } catch (RuntimeException e) {

                Log.e(TAG, "Exception happened", e);

                return Collections.emptyList();

            }

        }



        @Override

        public boolean setConnectionPolicy(BluetoothDevice device, int connectionPolicy) {

            try {

            BassClientService service = getService();

            if (service == null) {

                Log.e(TAG, "Service is null");

                return false;

            }

                mService.enforceCallingOrSelfPermission(

                        BLUETOOTH_CONNECT, "Need BLUETOOTH_CONNECT permission");



            service.enforceCallingOrSelfPermission(BLUETOOTH_CONNECT, null);



            return service.setConnectionPolicy(device, connectionPolicy);

            } catch (RuntimeException e) {

                Log.e(TAG, "Exception happened", e);

                return false;

            }

        }



        @Override

        public int getConnectionPolicy(BluetoothDevice device) {

            try {

            BassClientService service = getService();

            if (service == null) {

                Log.e(TAG, "Service is null");

                return BluetoothProfile.CONNECTION_POLICY_FORBIDDEN;

            }

                mService.enforceCallingOrSelfPermission(

                        BLUETOOTH_CONNECT, "Need BLUETOOTH_CONNECT permission");



            service.enforceCallingOrSelfPermission(BLUETOOTH_CONNECT, null);



            return service.getConnectionPolicy(device);

            } catch (RuntimeException e) {

                Log.e(TAG, "Exception happened", e);

                return BluetoothProfile.CONNECTION_POLICY_FORBIDDEN;

            }

        }



        @Override

        public void registerCallback(IBluetoothLeBroadcastAssistantCallback cb) {

            try {

            BassClientService service = getService();

            if (service == null) {

                Log.e(TAG, "Service is null");
@@ -3831,14 +3807,10 @@ public class BassClientService extends ProfileService { 
            }

            enforceBluetoothPrivilegedPermission(service);

            service.registerCallback(cb);

            } catch (RuntimeException e) {

                Log.e(TAG, "Exception happened", e);

            }

        }



        @Override

        public void unregisterCallback(IBluetoothLeBroadcastAssistantCallback cb) {

            try {

            BassClientService service = getService();

            if (service == null) {

                Log.e(TAG, "Service is null");
@@ -3846,14 +3818,10 @@ public class BassClientService extends ProfileService { 
            }

            enforceBluetoothPrivilegedPermission(service);

            service.unregisterCallback(cb);

            } catch (RuntimeException e) {

                Log.e(TAG, "Exception happened", e);

            }

        }



        @Override

        public void startSearchingForSources(List<ScanFilter> filters) {

            try {

            BassClientService service = getService();

            if (service == null) {

                Log.e(TAG, "Service is null");
@@ -3861,14 +3829,10 @@ public class BassClientService extends ProfileService { 
            }

            enforceBluetoothPrivilegedPermission(service);

            service.startSearchingForSources(filters);

            } catch (RuntimeException e) {

                Log.e(TAG, "Exception happened", e);

            }

        }



        @Override

        public void stopSearchingForSources() {

            try {

            BassClientService service = getService();

            if (service == null) {

                Log.e(TAG, "Service is null");
@@ -3876,14 +3840,10 @@ public class BassClientService extends ProfileService { 
            }

            enforceBluetoothPrivilegedPermission(service);

            service.stopSearchingForSources();

            } catch (RuntimeException e) {

                Log.e(TAG, "Exception happened", e);

            }

        }



        @Override

        public boolean isSearchInProgress() {

            try {

            BassClientService service = getService();

            if (service == null) {

                Log.e(TAG, "Service is null");
@@ -3891,10 +3851,6 @@ public class BassClientService extends ProfileService { 
            }

            enforceBluetoothPrivilegedPermission(service);

            return service.isSearchInProgress();

            } catch (RuntimeException e) {

                Log.e(TAG, "Exception happened", e);

                return false;

            }

        }



        @Override
@@ -3902,7 +3858,6 @@ public class BassClientService extends ProfileService { 
                BluetoothDevice sink,

                BluetoothLeBroadcastMetadata sourceMetadata,

                boolean isGroupOp) {

            try {

            BassClientService service = getService();

            if (service == null) {

                Log.e(TAG, "Service is null");
@@ -3910,15 +3865,11 @@ public class BassClientService extends ProfileService { 
            }

            enforceBluetoothPrivilegedPermission(service);

            service.addSource(sink, sourceMetadata, isGroupOp);

            } catch (RuntimeException e) {

                Log.e(TAG, "Exception happened", e);

            }

        }



        @Override

        public void modifySource(

                BluetoothDevice sink, int sourceId, BluetoothLeBroadcastMetadata updatedMetadata) {

            try {

            BassClientService service = getService();

            if (service == null) {

                Log.e(TAG, "Service is null");
@@ -3926,14 +3877,10 @@ public class BassClientService extends ProfileService { 
            }

            enforceBluetoothPrivilegedPermission(service);

            service.modifySource(sink, sourceId, updatedMetadata);

            } catch (RuntimeException e) {

                Log.e(TAG, "Exception happened", e);

            }

        }



        @Override

        public void removeSource(BluetoothDevice sink, int sourceId) {

            try {

            BassClientService service = getService();

            if (service == null) {

                Log.e(TAG, "Service is null");
@@ -3941,30 +3888,21 @@ public class BassClientService extends ProfileService { 
            }

            enforceBluetoothPrivilegedPermission(service);

            service.removeSource(sink, sourceId);

            } catch (RuntimeException e) {

                Log.e(TAG, "Exception happened", e);

            }

        }



        @Override

        public List<BluetoothLeBroadcastReceiveState> getAllSources(BluetoothDevice sink) {

            try {

            BassClientService service = getService();

                if (sink == null) {

            if (service == null) {

                Log.e(TAG, "Service is null");

                return Collections.emptyList();

            }

            enforceBluetoothPrivilegedPermission(service);

            return service.getAllSources(sink);

            } catch (RuntimeException e) {

                Log.e(TAG, "Exception happened", e);

                return Collections.emptyList();

            }

        }



        @Override

        public int getMaximumSourceCapacity(BluetoothDevice sink) {

            try {

            BassClientService service = getService();

            if (service == null) {

                Log.e(TAG, "Service is null");
@@ -3972,10 +3910,6 @@ public class BassClientService extends ProfileService { 
            }

            enforceBluetoothPrivilegedPermission(service);

            return service.getMaximumSourceCapacity(sink);

            } catch (RuntimeException e) {

                Log.e(TAG, "Exception happened", e);

                return 0;

            }

        }

    }

}

android/app/tests/unit/src/com/android/bluetooth/bass_client/BleBroadcastAssistantBinderTest.java

+57 −108
Original line number Diff line number Diff line
@@ -21,7 +21,6 @@ import static android.bluetooth.BluetoothProfile.STATE_DISCONNECTED; 
import static com.google.common.truth.Truth.assertThat;



import static org.mockito.Mockito.any;

import static org.mockito.Mockito.doThrow;

import static org.mockito.Mockito.never;

import static org.mockito.Mockito.verify;
@@ -51,15 +50,16 @@ public class BleBroadcastAssistantBinderTest { 


    @Rule public MockitoRule mockitoRule = MockitoJUnit.rule();



    private final BluetoothAdapter mAdapter = BluetoothAdapter.getDefaultAdapter();

    private final BluetoothDevice mDevice = TestUtils.getTestDevice(mAdapter, 0);



    @Mock private BassClientService mService;



    private BassClientService.BluetoothLeBroadcastAssistantBinder mBinder;

    private BluetoothAdapter mAdapter;



    @Before

    public void setUp() {

        mBinder = new BassClientService.BluetoothLeBroadcastAssistantBinder(mService);

        mAdapter = BluetoothAdapter.getDefaultAdapter();

    }



    @Test
@@ -70,15 +70,11 @@ public class BleBroadcastAssistantBinderTest { 


    @Test

    public void getConnectionState() {

        BluetoothDevice device = TestUtils.getTestDevice(mAdapter, 0);

        mBinder.getConnectionState(device);

        verify(mService).getConnectionState(device);



        doThrow(new RuntimeException()).when(mService).getConnectionState(device);

        assertThat(mBinder.getConnectionState(device)).isEqualTo(STATE_DISCONNECTED);

        mBinder.getConnectionState(mDevice);

        verify(mService).getConnectionState(mDevice);



        mBinder.cleanup();

        assertThat(mBinder.getConnectionState(device)).isEqualTo(STATE_DISCONNECTED);

        assertThat(mBinder.getConnectionState(mDevice)).isEqualTo(STATE_DISCONNECTED);

    }



    @Test
@@ -87,10 +83,6 @@ public class BleBroadcastAssistantBinderTest { 
        mBinder.getDevicesMatchingConnectionStates(states);

        verify(mService).getDevicesMatchingConnectionStates(states);



        doThrow(new RuntimeException()).when(mService).getDevicesMatchingConnectionStates(states);

        assertThat(mBinder.getDevicesMatchingConnectionStates(states))

                .isEqualTo(Collections.emptyList());



        mBinder.cleanup();

        assertThat(mBinder.getDevicesMatchingConnectionStates(states))

                .isEqualTo(Collections.emptyList());
@@ -101,42 +93,27 @@ public class BleBroadcastAssistantBinderTest { 
        mBinder.getConnectedDevices();

        verify(mService).getConnectedDevices();



        doThrow(new RuntimeException()).when(mService).getConnectedDevices();

        assertThat(mBinder.getConnectedDevices()).isEqualTo(Collections.emptyList());



        mBinder.cleanup();

        assertThat(mBinder.getConnectedDevices()).isEqualTo(Collections.emptyList());

    }



    @Test

    public void setConnectionPolicy() {

        BluetoothDevice device = TestUtils.getTestDevice(mAdapter, 0);

        mBinder.setConnectionPolicy(device, BluetoothProfile.CONNECTION_POLICY_ALLOWED);

        verify(mService).setConnectionPolicy(device, BluetoothProfile.CONNECTION_POLICY_ALLOWED);



        doThrow(new RuntimeException())

                .when(mService)

                .setConnectionPolicy(device, BluetoothProfile.CONNECTION_POLICY_ALLOWED);

        assertThat(mBinder.setConnectionPolicy(device, BluetoothProfile.CONNECTION_POLICY_ALLOWED))

                .isFalse();

        mBinder.setConnectionPolicy(mDevice, BluetoothProfile.CONNECTION_POLICY_ALLOWED);

        verify(mService).setConnectionPolicy(mDevice, BluetoothProfile.CONNECTION_POLICY_ALLOWED);



        mBinder.cleanup();

        assertThat(mBinder.setConnectionPolicy(device, BluetoothProfile.CONNECTION_POLICY_ALLOWED))

        assertThat(mBinder.setConnectionPolicy(mDevice, BluetoothProfile.CONNECTION_POLICY_ALLOWED))

                .isFalse();

    }



    @Test

    public void getConnectionPolicy() {

        BluetoothDevice device = TestUtils.getTestDevice(mAdapter, 0);

        mBinder.getConnectionPolicy(device);

        verify(mService).getConnectionPolicy(device);



        doThrow(new RuntimeException()).when(mService).getConnectionPolicy(device);

        assertThat(mBinder.getConnectionPolicy(device))

                .isEqualTo(BluetoothProfile.CONNECTION_POLICY_FORBIDDEN);

        mBinder.getConnectionPolicy(mDevice);

        verify(mService).getConnectionPolicy(mDevice);



        mBinder.cleanup();

        assertThat(mBinder.getConnectionPolicy(device))

        assertThat(mBinder.getConnectionPolicy(mDevice))

                .isEqualTo(BluetoothProfile.CONNECTION_POLICY_FORBIDDEN);

    }
@@ -146,15 +123,13 @@ public class BleBroadcastAssistantBinderTest { 
                Mockito.mock(IBluetoothLeBroadcastAssistantCallback.class);

        mBinder.registerCallback(cb);

        verify(mService).registerCallback(cb);

    }



        Mockito.clearInvocations(mService);

        doThrow(new RuntimeException()).when(mService).enforceCallingOrSelfPermission(any(), any());

        mBinder.registerCallback(cb);

        verify(mService, never()).registerCallback(cb);



    @Test

    public void registerCallback_afterCleanup_doNothing() {

        mBinder.cleanup();

        mBinder.registerCallback(cb);

        verify(mService, never()).registerCallback(cb);

        mBinder.registerCallback(null);

        verify(mService, never()).registerCallback(any());

    }



    @Test
@@ -163,15 +138,13 @@ public class BleBroadcastAssistantBinderTest { 
                Mockito.mock(IBluetoothLeBroadcastAssistantCallback.class);

        mBinder.unregisterCallback(cb);

        verify(mService).unregisterCallback(cb);

    }



        Mockito.clearInvocations(mService);

        doThrow(new RuntimeException()).when(mService).enforceCallingOrSelfPermission(any(), any());

        mBinder.unregisterCallback(cb);

        verify(mService, never()).unregisterCallback(cb);



    @Test

    public void unregisterCallback_afterCleanup_doNothing() {

        mBinder.cleanup();

        mBinder.unregisterCallback(cb);

        verify(mService, never()).unregisterCallback(cb);

        mBinder.unregisterCallback(null);

        verify(mService, never()).unregisterCallback(any());

    }



    @Test
@@ -179,27 +152,23 @@ public class BleBroadcastAssistantBinderTest { 
        List<ScanFilter> filters = Collections.EMPTY_LIST;

        mBinder.startSearchingForSources(filters);

        verify(mService).startSearchingForSources(filters);

    }



        Mockito.clearInvocations(mService);

        doThrow(new RuntimeException()).when(mService).enforceCallingOrSelfPermission(any(), any());

        mBinder.startSearchingForSources(filters);

        verify(mService, never()).startSearchingForSources(filters);



    @Test

    public void startSearchingForSources_afterCleanup_doNothing() {

        mBinder.cleanup();

        mBinder.startSearchingForSources(filters);

        verify(mService, never()).startSearchingForSources(filters);

        mBinder.startSearchingForSources(null);

        verify(mService, never()).startSearchingForSources(any());

    }



    @Test

    public void stopSearchingForSources() {

        mBinder.stopSearchingForSources();

        verify(mService).stopSearchingForSources();

    }



        Mockito.clearInvocations(mService);

        doThrow(new RuntimeException()).when(mService).enforceCallingOrSelfPermission(any(), any());

        mBinder.stopSearchingForSources();

        verify(mService, never()).stopSearchingForSources();



    @Test

    public void stopSearchingForSources_afterCleanup_doNothing() {

        mBinder.cleanup();

        mBinder.stopSearchingForSources();

        verify(mService, never()).stopSearchingForSources();
@@ -210,84 +179,64 @@ public class BleBroadcastAssistantBinderTest { 
        mBinder.isSearchInProgress();

        verify(mService).isSearchInProgress();



        doThrow(new RuntimeException()).when(mService).enforceCallingOrSelfPermission(any(), any());

        assertThat(mBinder.isSearchInProgress()).isFalse();



        mBinder.cleanup();

        assertThat(mBinder.isSearchInProgress()).isFalse();

    }



    @Test

    public void addSource() {

        BluetoothDevice device = TestUtils.getTestDevice(mAdapter, 0);

        mBinder.addSource(device, null, false);

        verify(mService).addSource(device, null, false);



        Mockito.clearInvocations(mService);

        doThrow(new RuntimeException()).when(mService).enforceCallingOrSelfPermission(any(), any());

        mBinder.addSource(device, null, false);

        verify(mService, never()).addSource(device, null, false);

        mBinder.addSource(mDevice, null, false);

        verify(mService).addSource(mDevice, null, false);

    }



    @Test

    public void addSource_afterCleanup_doNothing() {

        mBinder.cleanup();

        mBinder.addSource(device, null, false);

        verify(mService, never()).addSource(device, null, false);

        mBinder.addSource(mDevice, null, false);

        verify(mService, never()).addSource(mDevice, null, false);

    }



    @Test

    public void modifySource() {

        BluetoothDevice device = TestUtils.getTestDevice(mAdapter, 0);

        mBinder.modifySource(device, 0, null);

        verify(mService).modifySource(device, 0, null);



        Mockito.clearInvocations(mService);

        doThrow(new RuntimeException()).when(mService).enforceCallingOrSelfPermission(any(), any());

        mBinder.modifySource(device, 0, null);

        verify(mService, never()).modifySource(device, 0, null);

        mBinder.modifySource(mDevice, 0, null);

        verify(mService).modifySource(mDevice, 0, null);

    }



    @Test

    public void modifySource_afterCleanup_doNothing() {

        mBinder.cleanup();

        mBinder.modifySource(device, 0, null);

        verify(mService, never()).modifySource(device, 0, null);

        mBinder.modifySource(mDevice, 0, null);

        verify(mService, never()).modifySource(mDevice, 0, null);

    }



    @Test

    public void removeSource() {

        BluetoothDevice device = TestUtils.getTestDevice(mAdapter, 0);

        mBinder.removeSource(device, 0);

        verify(mService).removeSource(device, 0);



        Mockito.clearInvocations(mService);

        doThrow(new RuntimeException()).when(mService).enforceCallingOrSelfPermission(any(), any());

        mBinder.removeSource(device, 0);

        verify(mService, never()).removeSource(device, 0);

        mBinder.removeSource(mDevice, 0);

        verify(mService).removeSource(mDevice, 0);

    }



    @Test

    public void removeSource_afterCleanup_doNothing() {

        mBinder.cleanup();

        mBinder.removeSource(device, 0);

        verify(mService, never()).removeSource(device, 0);

        mBinder.removeSource(mDevice, 0);

        verify(mService, never()).removeSource(mDevice, 0);

    }



    @Test

    public void getAllSources() {

        BluetoothDevice device = TestUtils.getTestDevice(mAdapter, 0);

        mBinder.getAllSources(device);

        verify(mService).getAllSources(device);



        doThrow(new RuntimeException()).when(mService).getConnectionPolicy(device);

        assertThat(mBinder.getAllSources(device)).isEqualTo(Collections.emptyList());

        mBinder.getAllSources(mDevice);

        verify(mService).getAllSources(mDevice);



        mBinder.cleanup();

        assertThat(mBinder.getAllSources(device)).isEqualTo(Collections.emptyList());

        assertThat(mBinder.getAllSources(mDevice)).isEqualTo(Collections.emptyList());

    }



    @Test

    public void getMaximumSourceCapacity() {

        BluetoothDevice device = TestUtils.getTestDevice(mAdapter, 0);

        mBinder.getMaximumSourceCapacity(device);

        verify(mService).getMaximumSourceCapacity(device);



        doThrow(new RuntimeException()).when(mService).getMaximumSourceCapacity(device);

        assertThat(mBinder.getMaximumSourceCapacity(device)).isEqualTo(0);

        mBinder.getMaximumSourceCapacity(mDevice);

        verify(mService).getMaximumSourceCapacity(mDevice);



        mBinder.cleanup();

        assertThat(mBinder.getMaximumSourceCapacity(device)).isEqualTo(0);

        assertThat(mBinder.getMaximumSourceCapacity(mDevice)).isEqualTo(0);

    }

}