Merge "BassClientService: fix binder logic" into main (dd572237) · Commits · e / os / android_packages_modules_Bluetooth

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);
		}
		}