Snap for 9385690 from 563586d313707c0e19dd7f90e1e45a834a06512d to tm-qpr2-release (06d71246) · Commits · e / os / android_packages_modules_Bluetooth

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

+10 −0

Original line number	Diff line number	Diff line
		@@ -5164,6 +5164,8 @@ public class AdapterService extends Service {
		}

		// Boolean flags
		private static final String SDP_SKIP_RNR_IF_KNOWN = "INIT_sdp_skip_rnr_if_known";
		private static final String SDP_SERIALIZATION_FLAG = "INIT_sdp_serialization";
		private static final String GD_CORE_FLAG = "INIT_gd_core";
		private static final String GD_ADVERTISING_FLAG = "INIT_gd_advertising";
		private static final String GD_SCANNING_FLAG = "INIT_gd_scanning";
		@@ -5206,6 +5208,14 @@ public class AdapterService extends Service {
		if (DeviceConfig.getBoolean(DeviceConfig.NAMESPACE_BLUETOOTH, GD_CORE_FLAG, false)) {
		initFlags.add(String.format("%s=%s", GD_CORE_FLAG, "true"));
		}
		if (DeviceConfig.getBoolean(DeviceConfig.NAMESPACE_BLUETOOTH,
		SDP_SKIP_RNR_IF_KNOWN, true)) {
		initFlags.add(String.format("%s=%s", SDP_SKIP_RNR_IF_KNOWN, "true"));
		}
		if (DeviceConfig.getBoolean(DeviceConfig.NAMESPACE_BLUETOOTH,
		SDP_SERIALIZATION_FLAG, true)) {
		initFlags.add(String.format("%s=%s", SDP_SERIALIZATION_FLAG, "true"));
		}
		if (DeviceConfig.getBoolean(DeviceConfig.NAMESPACE_BLUETOOTH, GD_ADVERTISING_FLAG, false)) {
		initFlags.add(String.format("%s=%s", GD_ADVERTISING_FLAG, "true"));
		}

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

+3 −0

Original line number	Diff line number	Diff line
		@@ -2265,6 +2265,9 @@ public class LeAudioService extends ProfileService {

		@RequiresPermission(android.Manifest.permission.BLUETOOTH_CONNECT)
		private LeAudioService getService(AttributionSource source) {
		if (Utils.isInstrumentationTestMode()) {
		return mService;
		}
		if (!Utils.checkServiceAvailable(mService, TAG)
		\|\| !Utils.checkCallerIsSystemOrActiveOrManagedUser(mService, TAG)
		\|\| !Utils.checkConnectPermissionForDataDelivery(mService, source, TAG)) {

android/app/tests/unit/AndroidManifest.xml

+14 −0

Original line number	Diff line number	Diff line
		<?xml version="1.0" encoding="utf-8"?>
		<!-- package name must be unique so suffix with "tests" so package loader doesn't ignore us -->
		<manifest xmlns:android="http://schemas.android.com/apk/res/android"
		xmlns:tools="http://schemas.android.com/tools"
		package="com.android.bluetooth.tests">

		<uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
		@@ -57,6 +58,19 @@
		android:autoRevokePermissions="disallowed">
		<uses-library android:name="android.test.runner" />
		<uses-library android:name="org.apache.http.legacy" android:required="false" />

		<!-- Workaround for *ActivityTest failures (b/260295342) -->
		<activity
		android:name="androidx.test.core.app.InstrumentationActivityInvoker$BootstrapActivity"
		tools:node="merge">
		<intent-filter tools:node="removeAll" />
		</activity>
		<activity
		android:name="androidx.test.core.app.InstrumentationActivityInvoker$EmptyActivity"
		tools:node="merge">
		<intent-filter tools:node="removeAll" />
		</activity>

		</application>
		<!--
		This declares that this application uses the instrumentation test runner targeting

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

0 → 100644

+384 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright 2022 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		package com.android.bluetooth.le_audio;

		import static org.mockito.Mockito.verify;

		import android.bluetooth.BluetoothAdapter;
		import android.bluetooth.BluetoothDevice;
		import android.bluetooth.BluetoothLeAudio;
		import android.bluetooth.BluetoothLeAudioCodecConfig;
		import android.bluetooth.BluetoothLeAudioCodecStatus;
		import android.bluetooth.BluetoothLeAudioContentMetadata;
		import android.bluetooth.BluetoothLeBroadcastMetadata;
		import android.bluetooth.BluetoothProfile;
		import android.bluetooth.IBluetoothLeAudioCallback;
		import android.bluetooth.IBluetoothLeBroadcastCallback;
		import android.content.AttributionSource;
		import android.os.ParcelUuid;
		import android.os.RemoteCallbackList;

		import com.android.bluetooth.TestUtils;
		import com.android.bluetooth.x.com.android.modules.utils.SynchronousResultReceiver;

		import org.junit.After;
		import org.junit.Before;
		import org.junit.Test;
		import org.mockito.Mock;
		import org.mockito.Mockito;
		import org.mockito.MockitoAnnotations;

		import java.util.List;
		import java.util.UUID;

		public class LeAudioBinderTest {
		@Mock
		private LeAudioService mMockService;
		@Mock
		private RemoteCallbackList<IBluetoothLeAudioCallback> mLeAudioCallbacks;
		@Mock
		private RemoteCallbackList<IBluetoothLeBroadcastCallback> mBroadcastCallbacks;

		private LeAudioService.BluetoothLeAudioBinder mBinder;
		private BluetoothAdapter mAdapter;

		@Before
		public void setUp() throws Exception {
		MockitoAnnotations.initMocks(this);
		mAdapter = BluetoothAdapter.getDefaultAdapter();
		mBinder = new LeAudioService.BluetoothLeAudioBinder(mMockService);
		mMockService.mLeAudioCallbacks = mLeAudioCallbacks;
		mMockService.mBroadcastCallbacks = mBroadcastCallbacks;
		}

		@After
		public void cleanUp() {
		mBinder.cleanup();
		}

		@Test
		public void connect() {
		BluetoothDevice device = TestUtils.getTestDevice(mAdapter, 0);
		AttributionSource source = new AttributionSource.Builder(0).build();
		final SynchronousResultReceiver<Boolean> recv = SynchronousResultReceiver.get();

		mBinder.connect(device, source, recv);
		verify(mMockService).connect(device);
		}

		@Test
		public void disconnect() {
		BluetoothDevice device = TestUtils.getTestDevice(mAdapter, 0);
		AttributionSource source = new AttributionSource.Builder(0).build();
		final SynchronousResultReceiver<Boolean> recv = SynchronousResultReceiver.get();

		mBinder.disconnect(device, source, recv);
		verify(mMockService).disconnect(device);
		}

		@Test
		public void getConnectedDevices() {
		AttributionSource source = new AttributionSource.Builder(0).build();
		final SynchronousResultReceiver<List<BluetoothDevice>> recv =
		SynchronousResultReceiver.get();

		mBinder.getConnectedDevices(source, recv);
		verify(mMockService).getConnectedDevices();
		}

		@Test
		public void getConnectedGroupLeadDevice() {
		int groupId = 1;
		AttributionSource source = new AttributionSource.Builder(0).build();
		final SynchronousResultReceiver<List<BluetoothDevice>> recv =
		SynchronousResultReceiver.get();

		mBinder.getConnectedGroupLeadDevice(groupId, source, recv);
		verify(mMockService).getConnectedGroupLeadDevice(groupId);
		}

		@Test
		public void getDevicesMatchingConnectionStates() {
		int[] states = new int[] {BluetoothProfile.STATE_DISCONNECTED };
		AttributionSource source = new AttributionSource.Builder(0).build();
		final SynchronousResultReceiver<List<BluetoothDevice>> recv =
		SynchronousResultReceiver.get();

		mBinder.getDevicesMatchingConnectionStates(states, source, recv);
		verify(mMockService).getDevicesMatchingConnectionStates(states);
		}

		@Test
		public void getConnectionState() {
		BluetoothDevice device = TestUtils.getTestDevice(mAdapter, 0);
		AttributionSource source = new AttributionSource.Builder(0).build();
		final SynchronousResultReceiver<Integer> recv = SynchronousResultReceiver.get();

		mBinder.getConnectionState(device, source, recv);
		verify(mMockService).getConnectionState(device);
		}

		@Test
		public void setActiveDevice() {
		BluetoothDevice device = TestUtils.getTestDevice(mAdapter, 0);
		AttributionSource source = new AttributionSource.Builder(0).build();
		final SynchronousResultReceiver<Boolean> recv = SynchronousResultReceiver.get();

		mBinder.setActiveDevice(device, source, recv);
		verify(mMockService).setActiveDevice(device);
		}

		@Test
		public void getActiveDevices() {
		AttributionSource source = new AttributionSource.Builder(0).build();
		final SynchronousResultReceiver<Boolean> recv = SynchronousResultReceiver.get();

		mBinder.getActiveDevices(source, recv);
		verify(mMockService).getActiveDevices();
		}

		@Test
		public void getAudioLocation() {
		BluetoothDevice device = TestUtils.getTestDevice(mAdapter, 0);
		AttributionSource source = new AttributionSource.Builder(0).build();
		final SynchronousResultReceiver<Integer> recv = SynchronousResultReceiver.get();

		mBinder.getAudioLocation(device, source, recv);
		verify(mMockService).getAudioLocation(device);
		}

		@Test
		public void setConnectionPolicy() {
		BluetoothDevice device = TestUtils.getTestDevice(mAdapter, 0);
		int connectionPolicy = BluetoothProfile.CONNECTION_POLICY_UNKNOWN;
		AttributionSource source = new AttributionSource.Builder(0).build();
		final SynchronousResultReceiver<Boolean> recv = SynchronousResultReceiver.get();

		mBinder.setConnectionPolicy(device, connectionPolicy, source, recv);
		verify(mMockService).setConnectionPolicy(device, connectionPolicy);
		}

		@Test
		public void getConnectionPolicy() {
		BluetoothDevice device = TestUtils.getTestDevice(mAdapter, 0);
		AttributionSource source = new AttributionSource.Builder(0).build();
		final SynchronousResultReceiver<Integer> recv = SynchronousResultReceiver.get();

		mBinder.getConnectionPolicy(device, source, recv);
		verify(mMockService).getConnectionPolicy(device);
		}

		@Test
		public void setCcidInformation() {
		ParcelUuid uuid = new ParcelUuid(new UUID(0, 0));
		int ccid = 0;
		int contextType = BluetoothLeAudio.CONTEXT_TYPE_UNSPECIFIED;
		AttributionSource source = new AttributionSource.Builder(0).build();
		final SynchronousResultReceiver<Void> recv = SynchronousResultReceiver.get();

		mBinder.setCcidInformation(uuid, ccid, contextType, source, recv);
		verify(mMockService).setCcidInformation(uuid, ccid, contextType);
		}

		@Test
		public void getGroupId() {
		BluetoothDevice device = TestUtils.getTestDevice(mAdapter, 0);
		AttributionSource source = new AttributionSource.Builder(0).build();
		final SynchronousResultReceiver<Integer> recv = SynchronousResultReceiver.get();

		mBinder.getGroupId(device, source, recv);
		verify(mMockService).getGroupId(device);
		}

		@Test
		public void groupAddNode() {
		int groupId = 1;
		BluetoothDevice device = TestUtils.getTestDevice(mAdapter, 0);
		AttributionSource source = new AttributionSource.Builder(0).build();
		final SynchronousResultReceiver<Integer> recv = SynchronousResultReceiver.get();

		mBinder.groupAddNode(groupId, device, source, recv);
		verify(mMockService).groupAddNode(groupId, device);
		}

		@Test
		public void setInCall() {
		boolean inCall = true;
		AttributionSource source = new AttributionSource.Builder(0).build();
		final SynchronousResultReceiver<Void> recv = SynchronousResultReceiver.get();

		mBinder.setInCall(inCall, source, recv);
		verify(mMockService).setInCall(inCall);
		}

		@Test
		public void setInactiveForHfpHandover() {
		BluetoothDevice device = TestUtils.getTestDevice(mAdapter, 0);
		AttributionSource source = new AttributionSource.Builder(0).build();
		final SynchronousResultReceiver<Void> recv = SynchronousResultReceiver.get();

		mBinder.setInactiveForHfpHandover(device, source, recv);
		verify(mMockService).setInactiveForHfpHandover(device);
		}

		@Test
		public void groupRemoveNode() {
		int groupId = 1;
		BluetoothDevice device = TestUtils.getTestDevice(mAdapter, 0);
		AttributionSource source = new AttributionSource.Builder(0).build();
		final SynchronousResultReceiver<Boolean> recv = SynchronousResultReceiver.get();

		mBinder.groupRemoveNode(groupId, device, source, recv);
		verify(mMockService).groupRemoveNode(groupId, device);
		}

		@Test
		public void setVolume() {
		int volume = 3;
		AttributionSource source = new AttributionSource.Builder(0).build();
		final SynchronousResultReceiver<Void> recv = SynchronousResultReceiver.get();

		mBinder.setVolume(volume, source, recv);
		verify(mMockService).setVolume(volume);
		}

		@Test
		public void registerCallback() {
		IBluetoothLeAudioCallback callback = Mockito.mock(IBluetoothLeAudioCallback.class);
		AttributionSource source = new AttributionSource.Builder(0).build();
		final SynchronousResultReceiver<Void> recv = SynchronousResultReceiver.get();

		mBinder.registerCallback(callback, source, recv);
		verify(mMockService.mLeAudioCallbacks).register(callback);
		}

		@Test
		public void unregisterCallback() {
		IBluetoothLeAudioCallback callback = Mockito.mock(IBluetoothLeAudioCallback.class);
		AttributionSource source = new AttributionSource.Builder(0).build();
		final SynchronousResultReceiver<Void> recv = SynchronousResultReceiver.get();

		mBinder.unregisterCallback(callback, source, recv);
		verify(mMockService.mLeAudioCallbacks).unregister(callback);
		}

		@Test
		public void registerLeBroadcastCallback() {
		IBluetoothLeBroadcastCallback callback = Mockito.mock(IBluetoothLeBroadcastCallback.class);
		AttributionSource source = new AttributionSource.Builder(0).build();
		final SynchronousResultReceiver<Void> recv = SynchronousResultReceiver.get();

		mBinder.registerLeBroadcastCallback(callback, source, recv);
		verify(mMockService.mBroadcastCallbacks).register(callback);
		}

		@Test
		public void unregisterLeBroadcastCallback() {
		IBluetoothLeBroadcastCallback callback = Mockito.mock(IBluetoothLeBroadcastCallback.class);
		AttributionSource source = new AttributionSource.Builder(0).build();
		final SynchronousResultReceiver<Void> recv = SynchronousResultReceiver.get();

		mBinder.unregisterLeBroadcastCallback(callback, source, recv);
		verify(mMockService.mBroadcastCallbacks).unregister(callback);
		}

		@Test
		public void startBroadcast() {
		BluetoothLeAudioContentMetadata metadata =
		new BluetoothLeAudioContentMetadata.Builder().build();
		byte[] code = new byte[] { 0x00 };
		AttributionSource source = new AttributionSource.Builder(0).build();

		mBinder.startBroadcast(metadata, code, source);
		verify(mMockService).createBroadcast(metadata, code);
		}

		@Test
		public void stopBroadcast() {
		int id = 1;
		AttributionSource source = new AttributionSource.Builder(0).build();

		mBinder.stopBroadcast(id, source);
		verify(mMockService).stopBroadcast(id);
		}

		@Test
		public void updateBroadcast() {
		int id = 1;
		BluetoothLeAudioContentMetadata metadata =
		new BluetoothLeAudioContentMetadata.Builder().build();
		AttributionSource source = new AttributionSource.Builder(0).build();

		mBinder.updateBroadcast(id, metadata, source);
		verify(mMockService).updateBroadcast(id, metadata);
		}

		@Test
		public void isPlaying() {
		int id = 1;
		BluetoothLeAudioContentMetadata metadata =
		new BluetoothLeAudioContentMetadata.Builder().build();
		AttributionSource source = new AttributionSource.Builder(0).build();
		final SynchronousResultReceiver<Boolean> recv = SynchronousResultReceiver.get();

		mBinder.isPlaying(id, source, recv);
		verify(mMockService).isPlaying(id);
		}

		@Test
		public void getAllBroadcastMetadata() {
		AttributionSource source = new AttributionSource.Builder(0).build();
		final SynchronousResultReceiver<List<BluetoothLeBroadcastMetadata>> recv =
		SynchronousResultReceiver.get();

		mBinder.getAllBroadcastMetadata(source, recv);
		verify(mMockService).getAllBroadcastMetadata();
		}

		@Test
		public void getMaximumNumberOfBroadcasts() {
		AttributionSource source = new AttributionSource.Builder(0).build();
		final SynchronousResultReceiver<Integer> recv = SynchronousResultReceiver.get();

		mBinder.getMaximumNumberOfBroadcasts(source, recv);
		verify(mMockService).getMaximumNumberOfBroadcasts();
		}

		@Test
		public void getCodecStatus() {
		int groupId = 1;
		AttributionSource source = new AttributionSource.Builder(0).build();
		final SynchronousResultReceiver<BluetoothLeAudioCodecStatus> recv =
		SynchronousResultReceiver.get();

		mBinder.getCodecStatus(groupId, source, recv);
		verify(mMockService).getCodecStatus(groupId);
		}

		@Test
		public void setCodecConfigPreference() {
		int groupId = 1;
		BluetoothLeAudioCodecConfig inputConfig =
		new BluetoothLeAudioCodecConfig.Builder().build();
		BluetoothLeAudioCodecConfig outputConfig =
		new BluetoothLeAudioCodecConfig.Builder().build();
		AttributionSource source = new AttributionSource.Builder(0).build();

		mBinder.setCodecConfigPreference(groupId, inputConfig, outputConfig, source);
		verify(mMockService).setCodecConfigPreference(groupId, inputConfig, outputConfig);
		}
		}

android/app/tests/unit/src/com/android/bluetooth/vc/VolumeControlServiceTest.java

+8 −0

Original line number	Diff line number	Diff line
		@@ -855,6 +855,14 @@ public class VolumeControlServiceTest {
		Assert.assertEquals(0, descriptor.size());
		}

		@Test
		public void testDump_doesNotCrash() throws Exception {
		connectDevice(mDevice);

		StringBuilder sb = new StringBuilder();
		mService.dump(sb);
		}

		private void connectDevice(BluetoothDevice device) throws Exception {
		VolumeControlStackEvent connCompletedEvent;