Merge "Bumble Java Le Audio Service Discovery Test cases" into main (beb41ad3) · Commits · e / os / android_packages_modules_Bluetooth

framework/tests/bumble/bumble_config.json

+1 −0

Original line number	Diff line number	Diff line
		@@ -2,5 +2,6 @@
		"advertising_interval": 200,
		"address": "51:F7:A8:75:AC:5E",
		"classic_enabled": true,
		"class_of_device": 2376708,
		"irk": "1F66F4B5F0C742F807DD0DDBF64E9213"
		}

framework/tests/bumble/src/android/bluetooth/service_discovery/LeAudioServiceDiscoveryTest.java

0 → 100644

+370 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2023 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 android.bluetooth.service_discovery.pairing;

		import static androidx.test.espresso.intent.matcher.IntentMatchers.hasAction;
		import static androidx.test.espresso.intent.matcher.IntentMatchers.hasExtra;

		import static com.google.common.truth.Truth.assertThat;

		import static org.mockito.Mockito.any;
		import static org.mockito.Mockito.doAnswer;
		import static org.mockito.Mockito.inOrder;
		import static org.mockito.Mockito.timeout;

		import android.bluetooth.BluetoothAdapter;
		import android.bluetooth.BluetoothDevice;
		import android.bluetooth.BluetoothManager;
		import android.bluetooth.BluetoothUuid;
		import android.bluetooth.Host;
		import android.bluetooth.PandoraDevice;
		import android.bluetooth.test_utils.EnableBluetoothRule;
		import android.content.BroadcastReceiver;
		import android.content.Context;
		import android.content.Intent;
		import android.content.IntentFilter;
		import android.os.ParcelUuid;
		import android.platform.test.flag.junit.CheckFlagsRule;
		import android.platform.test.flag.junit.DeviceFlagsValueProvider;
		import android.util.Log;

		import androidx.test.ext.junit.runners.AndroidJUnit4;
		import androidx.test.platform.app.InstrumentationRegistry;

		import com.android.compatibility.common.util.AdoptShellPermissionsRule;

		import org.hamcrest.Matcher;
		import org.hamcrest.Matchers;
		import org.hamcrest.core.AllOf;
		import org.junit.After;
		import org.junit.Before;
		import org.junit.Rule;
		import org.junit.Test;
		import org.junit.runner.RunWith;
		import org.mockito.InOrder;
		import org.mockito.Mock;
		import org.mockito.MockitoAnnotations;
		import org.mockito.hamcrest.MockitoHamcrest;

		import pandora.GattProto;
		import pandora.HostProto.AdvertiseRequest;
		import pandora.HostProto.DiscoverabilityMode;
		import pandora.HostProto.OwnAddressType;
		import pandora.HostProto.SetDiscoverabilityModeRequest;

		import java.time.Duration;
		import java.util.Arrays;
		import java.util.HashMap;
		import java.util.Map;
		import java.util.concurrent.CompletableFuture;
		import java.util.concurrent.TimeUnit;

		@RunWith(AndroidJUnit4.class)
		public class LeAudioServiceDiscoveryTest {
		private static final String TAG = LeAudioServiceDiscoveryTest.class.getSimpleName();
		private static final String BUMBLE_DEVICE_NAME = "Bumble";
		private static final Duration BOND_INTENT_TIMEOUT = Duration.ofSeconds(10);
		private static final int DISCOVERY_TIMEOUT = 2000; // 2 seconds
		private CompletableFuture<BluetoothDevice> mDeviceFound;
		private static final ParcelUuid BATTERY_UUID =
		ParcelUuid.fromString("0000180F-0000-1000-8000-00805F9B34FB");
		private static final ParcelUuid LEAUDIO_UUID =
		ParcelUuid.fromString("0000184E-0000-1000-8000-00805F9B34FB");

		private static final Context sTargetContext =
		InstrumentationRegistry.getInstrumentation().getTargetContext();
		private static final BluetoothAdapter sAdapter =
		sTargetContext.getSystemService(BluetoothManager.class).getAdapter();

		@Rule(order = 0)
		public final CheckFlagsRule mCheckFlagsRule = DeviceFlagsValueProvider.createCheckFlagsRule();

		@Rule(order = 1)
		public final AdoptShellPermissionsRule mPermissionRule = new AdoptShellPermissionsRule();

		@Rule(order = 2)
		public final PandoraDevice mBumble = new PandoraDevice();

		@Rule(order = 3)
		public final EnableBluetoothRule mEnableBluetoothRule =
		new EnableBluetoothRule(false /* enableTestMode /, true / toggleBluetooth */);

		@Mock private BroadcastReceiver mReceiver;
		private final Map<String, Integer> mActionRegistrationCounts = new HashMap<>();
		private InOrder mInOrder = null;
		private BluetoothDevice mBumbleDevice;
		private Host mHost;

		@Before
		public void setUp() throws Exception {
		MockitoAnnotations.initMocks(this);

		doAnswer(
		inv -> {
		Log.d(
		TAG,
		"onReceive(): intent=" + Arrays.toString(inv.getArguments()));
		Intent intent = inv.getArgument(1);
		String action = intent.getAction();
		if (BluetoothDevice.ACTION_UUID.equals(action)) {
		ParcelUuid[] uuids =
		intent.getParcelableArrayExtra(
		BluetoothDevice.EXTRA_UUID, ParcelUuid.class);
		Log.d(TAG, "onReceive(): UUID=" + Arrays.toString(uuids));
		} else if (BluetoothDevice.ACTION_FOUND.equals(intent.getAction())) {
		BluetoothDevice device =
		intent.getParcelableExtra(
		BluetoothDevice.EXTRA_DEVICE,
		BluetoothDevice.class);
		String deviceName =
		String.valueOf(
		intent.getStringExtra(BluetoothDevice.EXTRA_NAME));
		Log.i(
		TAG,
		"Discovered device: "
		+ device
		+ " with name: "
		+ deviceName);
		if (deviceName != null && BUMBLE_DEVICE_NAME.equals(deviceName)) {
		mDeviceFound.complete(device);
		}
		} else if (BluetoothDevice.ACTION_ACL_CONNECTED.equals(
		intent.getAction())) {
		BluetoothDevice device =
		intent.getParcelableExtra(
		BluetoothDevice.EXTRA_DEVICE,
		BluetoothDevice.class);
		int transport =
		intent.getIntExtra(
		BluetoothDevice.EXTRA_TRANSPORT,
		BluetoothDevice.TRANSPORT_AUTO);
		Log.i(
		TAG,
		"ACL connected for device="
		+ device
		+ " with transport: "
		+ transport);
		}
		return null;
		})
		.when(mReceiver)
		.onReceive(any(), any());

		mInOrder = inOrder(mReceiver);
		mHost = new Host(sTargetContext);
		}

		@After
		public void tearDown() throws Exception {
		if (mBumbleDevice.getBondState() == BluetoothDevice.BOND_BONDED) {
		mHost.removeBondAndVerify(mBumbleDevice);
		}
		mHost.close();
		mBumbleDevice = null;
		if (getTotalActionRegistrationCounts() > 0) {
		sTargetContext.unregisterReceiver(mReceiver);
		mActionRegistrationCounts.clear();
		}
		}

		/**
		* Ensure that successful service discovery results on both Transport for LE Audio capable
		* device
		*
		* <p>Prerequisites:
		*
		* <ol>
		* <li>Bumble and Android are not bonded
		* <li>Bumble has GATT services in addition to GAP and GATT services
		* </ol>
		*
		* <p>Steps:
		*
		* <ol>
		* <li>Bumble is discoverable and connectable on both Transport
		* <li>Android creates the Bond
		* <li>Android starts service discovery on both Transport
		* </ol>
		*
		* Expectation: ACTION_UUID intent is received and The ACTION_UUID intent has both LE and
		* Classic services
		*/
		@Test
		public void testServiceDiscoveryWithRandomAddr() {

		registerIntentActions(
		BluetoothDevice.ACTION_ACL_CONNECTED,
		BluetoothDevice.ACTION_UUID,
		BluetoothDevice.ACTION_FOUND);

		// Register Battery and Le Audio services on Bumble
		mBumble.gattBlocking()
		.registerService(
		GattProto.RegisterServiceRequest.newBuilder()
		.setService(
		GattProto.GattServiceParams.newBuilder()
		.setUuid(BATTERY_UUID.toString())
		.build())
		.build());
		mBumble.gattBlocking()
		.registerService(
		GattProto.RegisterServiceRequest.newBuilder()
		.setService(
		GattProto.GattServiceParams.newBuilder()
		.setUuid(LEAUDIO_UUID.toString())
		.build())
		.build());

		// Make Bumble connectable
		mBumble.hostBlocking()
		.advertise(
		AdvertiseRequest.newBuilder()
		.setLegacy(true)
		.setConnectable(true)
		.setOwnAddressType(OwnAddressType.RANDOM)
		.build());
		// Make Bumble discoverable over BR/EDR
		mBumble.hostBlocking()
		.setDiscoverabilityMode(
		SetDiscoverabilityModeRequest.newBuilder()
		.setMode(DiscoverabilityMode.DISCOVERABLE_GENERAL)
		.build());
		// Start Discovery
		mDeviceFound = new CompletableFuture<>();
		assertThat(sAdapter.startDiscovery()).isTrue();
		mBumbleDevice =
		mDeviceFound
		.completeOnTimeout(null, DISCOVERY_TIMEOUT, TimeUnit.MILLISECONDS)
		.join();
		assertThat(sAdapter.cancelDiscovery()).isTrue();
		// Create Bond
		mHost.createBondAndVerify(mBumbleDevice);

		// Verify ACL connection on classic transport first and then LE transport
		verifyIntentReceived(
		hasAction(BluetoothDevice.ACTION_ACL_CONNECTED),
		hasExtra(BluetoothDevice.EXTRA_TRANSPORT, BluetoothDevice.TRANSPORT_BREDR));
		verifyIntentReceived(
		hasAction(BluetoothDevice.ACTION_ACL_CONNECTED),
		hasExtra(BluetoothDevice.EXTRA_TRANSPORT, BluetoothDevice.TRANSPORT_LE));

		// Verify both LE and Classic Services
		verifyIntentReceived(
		hasAction(BluetoothDevice.ACTION_UUID),
		hasExtra(
		BluetoothDevice.EXTRA_UUID,
		Matchers.allOf(
		Matchers.hasItemInArray(BluetoothUuid.HFP),
		Matchers.hasItemInArray(BluetoothUuid.HID),
		Matchers.hasItemInArray(BluetoothUuid.A2DP_SOURCE),
		Matchers.hasItemInArray(BluetoothUuid.A2DP_SINK),
		Matchers.hasItemInArray(BluetoothUuid.AVRCP),
		Matchers.hasItemInArray(BluetoothUuid.LE_AUDIO),
		Matchers.hasItemInArray(BluetoothUuid.BATTERY),
		Matchers.hasItemInArray(BluetoothUuid.HOGP))));
		unregisterIntentActions(
		BluetoothDevice.ACTION_UUID,
		BluetoothDevice.ACTION_ACL_CONNECTED,
		BluetoothDevice.ACTION_FOUND);
		}

		@SafeVarargs
		private void verifyIntentReceived(Matcher<Intent>... matchers) {
		mInOrder.verify(mReceiver, timeout(BOND_INTENT_TIMEOUT.toMillis()))
		.onReceive(any(Context.class), MockitoHamcrest.argThat(AllOf.allOf(matchers)));
		}

		/**
		* Helper function to add reference count to registered intent actions
		*
		* @param actions new intent actions to add. If the array is empty, it is a no-op.
		*/
		private void registerIntentActions(String... actions) {
		if (actions.length == 0) {
		return;
		}
		if (getTotalActionRegistrationCounts() > 0) {
		Log.d(TAG, "registerIntentActions(): unregister ALL intents");
		sTargetContext.unregisterReceiver(mReceiver);
		}
		for (String action : actions) {
		mActionRegistrationCounts.merge(action, 1, Integer::sum);
		}
		IntentFilter filter = new IntentFilter();
		mActionRegistrationCounts.entrySet().stream()
		.filter(entry -> entry.getValue() > 0)
		.forEach(
		entry -> {
		Log.d(
		TAG,
		"registerIntentActions(): Registering action = "
		+ entry.getKey());
		filter.addAction(entry.getKey());
		});
		sTargetContext.registerReceiver(mReceiver, filter);
		}

		/**
		* Helper function to reduce reference count to registered intent actions If total reference
		* count is zero after removal, no broadcast receiver will be registered.
		*
		* @param actions intent actions to be removed. If some action is not registered, it is no-op
		* for that action. If the actions array is empty, it is also a no-op.
		*/
		private void unregisterIntentActions(String... actions) {
		if (actions.length == 0) {
		return;
		}
		if (getTotalActionRegistrationCounts() <= 0) {
		return;
		}
		Log.d(TAG, "unregisterIntentActions(): unregister ALL intents");
		sTargetContext.unregisterReceiver(mReceiver);
		for (String action : actions) {
		if (!mActionRegistrationCounts.containsKey(action)) {
		continue;
		}
		mActionRegistrationCounts.put(action, mActionRegistrationCounts.get(action) - 1);
		if (mActionRegistrationCounts.get(action) <= 0) {
		mActionRegistrationCounts.remove(action);
		}
		}
		if (getTotalActionRegistrationCounts() > 0) {
		IntentFilter filter = new IntentFilter();
		mActionRegistrationCounts.entrySet().stream()
		.filter(entry -> entry.getValue() > 0)
		.forEach(
		entry -> {
		Log.d(
		TAG,
		"unregisterIntentActions(): Registering action = "
		+ entry.getKey());
		filter.addAction(entry.getKey());
		});
		sTargetContext.registerReceiver(mReceiver, filter);
		}
		}

		/**
		* Get sum of reference count from all registered actions
		*
		* @return sum of reference count from all registered actions
		*/
		private int getTotalActionRegistrationCounts() {
		return mActionRegistrationCounts.values().stream().reduce(0, Integer::sum);
		}
		}