Merge changes I2eb4f0b8,I0f59e1a1,Id1fddef6,I9f6ab7bd,I80c5878e, ... into main am: 78af57b47b (6f4b2fd4) · Commits · e / os / android_packages_modules_Bluetooth

android/app/src/com/android/bluetooth/Utils.java

+19 −0

Original line number	Diff line number	Diff line
		@@ -59,6 +59,7 @@ import android.os.Build;
		import android.os.ParcelUuid;
		import android.os.PowerExemptionManager;
		import android.os.Process;
		import android.os.RemoteException;
		import android.os.SystemProperties;
		import android.os.UserHandle;
		import android.os.UserManager;
		@@ -92,6 +93,7 @@ import java.util.UUID;
		import java.util.concurrent.ExecutorService;
		import java.util.concurrent.Executors;
		import java.util.concurrent.TimeUnit;
		import java.util.function.Consumer;

		public final class Utils {
		private static final String TAG = "BluetoothUtils";
		@@ -1258,6 +1260,23 @@ public final class Utils {
		\|\| pm.hasSystemFeature(PackageManager.FEATURE_LEANBACK);
		}

		/** A {@link Consumer} that automatically ignores any {@link RemoteException}s. */
		@FunctionalInterface
		@SuppressWarnings("FunctionalInterfaceMethodChanged")
		public interface RemoteExceptionIgnoringConsumer<T> extends Consumer<T> {
		/** Called by {@code accept}. */
		void acceptOrThrow(T t) throws RemoteException;

		@Override
		default void accept(T t) {
		try {
		acceptOrThrow(t);
		} catch (RemoteException ex) {
		// Ignore RemoteException
		}
		}
		}

		/**
		* Returns the longest prefix of a string for which the UTF-8 encoding fits into the given
		* number of bytes, with the additional guarantee that the string is not truncated in the middle

android/app/src/com/android/bluetooth/hap/HapClientBinder.java

0 → 100644

+333 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright 2024 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.hap;

		import static android.Manifest.permission.BLUETOOTH_CONNECT;
		import static android.Manifest.permission.BLUETOOTH_PRIVILEGED;

		import static java.util.Objects.requireNonNull;

		import android.annotation.RequiresPermission;
		import android.bluetooth.BluetoothCsipSetCoordinator;
		import android.bluetooth.BluetoothDevice;
		import android.bluetooth.BluetoothHapClient;
		import android.bluetooth.BluetoothHapPresetInfo;
		import android.bluetooth.BluetoothProfile;
		import android.bluetooth.IBluetoothHapClient;
		import android.bluetooth.IBluetoothHapClientCallback;
		import android.content.AttributionSource;
		import android.util.Log;

		import com.android.bluetooth.Utils;
		import com.android.bluetooth.btservice.ProfileService;
		import com.android.internal.annotations.VisibleForTesting;

		import java.util.Collections;
		import java.util.List;

		/** HapClientBinder class */
		@VisibleForTesting
		class HapClientBinder extends IBluetoothHapClient.Stub
		implements ProfileService.IProfileServiceBinder {
		private static final String TAG = HapClientBinder.class.getSimpleName();
		private HapClientService mService;

		HapClientBinder(HapClientService svc) {
		mService = svc;
		}

		@Override
		public void cleanup() {
		mService = null;
		}

		@RequiresPermission(allOf = {BLUETOOTH_CONNECT, BLUETOOTH_PRIVILEGED})
		private HapClientService getService(AttributionSource source) {
		requireNonNull(source);
		// Cache mService because it can change while getService is called
		HapClientService service = mService;

		if (Utils.isInstrumentationTestMode()) {
		return service;
		}

		if (!Utils.checkServiceAvailable(service, TAG)
		\|\| !Utils.checkCallerIsSystemOrActiveOrManagedUser(service, TAG)
		\|\| !Utils.checkConnectPermissionForDataDelivery(service, source, TAG)) {
		Log.w(TAG, "Hearing Access call not allowed for non-active user");
		return null;
		}

		service.enforceCallingOrSelfPermission(BLUETOOTH_PRIVILEGED, null);
		return service;
		}

		@Override
		public List<BluetoothDevice> getConnectedDevices(AttributionSource source) {
		HapClientService service = getService(source);
		if (service == null) {
		return Collections.emptyList();
		}

		return service.getConnectedDevices();
		}

		@Override
		public List<BluetoothDevice> getDevicesMatchingConnectionStates(
		int[] states, AttributionSource source) {
		HapClientService service = getService(source);
		if (service == null) {
		return Collections.emptyList();
		}

		return service.getDevicesMatchingConnectionStates(states);
		}

		@Override
		public int getConnectionState(BluetoothDevice device, AttributionSource source) {
		HapClientService service = getService(source);
		if (service == null) {
		return BluetoothProfile.STATE_DISCONNECTED;
		}

		requireNonNull(device);

		return service.getConnectionState(device);
		}

		@Override
		public boolean setConnectionPolicy(
		BluetoothDevice device, int connectionPolicy, AttributionSource source) {
		HapClientService service = getService(source);
		if (service == null) {
		return false;
		}

		requireNonNull(device);
		if (connectionPolicy != BluetoothProfile.CONNECTION_POLICY_ALLOWED
		&& connectionPolicy != BluetoothProfile.CONNECTION_POLICY_FORBIDDEN) {
		throw new IllegalArgumentException(
		"Invalid connectionPolicy value: " + connectionPolicy);
		}

		return service.setConnectionPolicy(device, connectionPolicy);
		}

		@Override
		public int getConnectionPolicy(BluetoothDevice device, AttributionSource source) {
		HapClientService service = getService(source);
		if (service == null) {
		return BluetoothProfile.CONNECTION_POLICY_UNKNOWN;
		}

		requireNonNull(device);

		return service.getConnectionPolicy(device);
		}

		@Override
		public int getActivePresetIndex(BluetoothDevice device, AttributionSource source) {
		HapClientService service = getService(source);
		if (service == null) {
		return BluetoothHapClient.PRESET_INDEX_UNAVAILABLE;
		}

		requireNonNull(device);

		return service.getActivePresetIndex(device);
		}

		@Override
		public BluetoothHapPresetInfo getActivePresetInfo(
		BluetoothDevice device, AttributionSource source) {
		HapClientService service = getService(source);
		if (service == null) {
		return null;
		}

		requireNonNull(device);

		return service.getActivePresetInfo(device);
		}

		@Override
		public int getHapGroup(BluetoothDevice device, AttributionSource source) {
		HapClientService service = getService(source);
		if (service == null) {
		return BluetoothCsipSetCoordinator.GROUP_ID_INVALID;
		}

		requireNonNull(device);

		return service.getHapGroup(device);
		}

		@Override
		public void selectPreset(BluetoothDevice device, int presetIndex, AttributionSource source) {
		HapClientService service = getService(source);
		if (service == null) {
		return;
		}

		requireNonNull(device);

		service.selectPreset(device, presetIndex);
		}

		@Override
		public void selectPresetForGroup(int groupId, int presetIndex, AttributionSource source) {
		HapClientService service = getService(source);
		if (service == null) {
		return;
		}

		service.selectPresetForGroup(groupId, presetIndex);
		}

		@Override
		public void switchToNextPreset(BluetoothDevice device, AttributionSource source) {
		HapClientService service = getService(source);
		if (service == null) {
		return;
		}

		requireNonNull(device);

		service.switchToNextPreset(device);
		}

		@Override
		public void switchToNextPresetForGroup(int groupId, AttributionSource source) {
		HapClientService service = getService(source);
		if (service == null) {
		return;
		}

		service.switchToNextPresetForGroup(groupId);
		}

		@Override
		public void switchToPreviousPreset(BluetoothDevice device, AttributionSource source) {
		HapClientService service = getService(source);
		if (service == null) {
		return;
		}

		requireNonNull(device);

		service.switchToPreviousPreset(device);
		}

		@Override
		public void switchToPreviousPresetForGroup(int groupId, AttributionSource source) {
		HapClientService service = getService(source);
		if (service == null) {
		return;
		}

		service.switchToPreviousPresetForGroup(groupId);
		}

		@Override
		public BluetoothHapPresetInfo getPresetInfo(
		BluetoothDevice device, int presetIndex, AttributionSource source) {
		HapClientService service = getService(source);
		if (service == null) {
		return null;
		}

		requireNonNull(device);

		return service.getPresetInfo(device, presetIndex);
		}

		@Override
		public List<BluetoothHapPresetInfo> getAllPresetInfo(
		BluetoothDevice device, AttributionSource source) {
		HapClientService service = getService(source);
		if (service == null) {
		return Collections.emptyList();
		}

		requireNonNull(device);

		return service.getAllPresetInfo(device);
		}

		@Override
		public int getFeatures(BluetoothDevice device, AttributionSource source) {
		HapClientService service = getService(source);
		if (service == null) {
		return 0x00;
		}

		requireNonNull(device);

		return service.getFeatures(device);
		}

		@Override
		public void setPresetName(
		BluetoothDevice device, int presetIndex, String name, AttributionSource source) {
		HapClientService service = getService(source);
		if (service == null) {
		return;
		}

		requireNonNull(device);
		requireNonNull(name);

		service.setPresetName(device, presetIndex, name);
		}

		@Override
		public void setPresetNameForGroup(
		int groupId, int presetIndex, String name, AttributionSource source) {
		HapClientService service = getService(source);
		if (service == null) {
		return;
		}

		requireNonNull(name);

		service.setPresetNameForGroup(groupId, presetIndex, name);
		}

		@Override
		public void registerCallback(IBluetoothHapClientCallback callback, AttributionSource source) {
		HapClientService service = getService(source);
		if (service == null) {
		return;
		}

		requireNonNull(callback);

		service.registerCallback(callback);
		}

		@Override
		public void unregisterCallback(IBluetoothHapClientCallback callback, AttributionSource source) {
		HapClientService service = getService(source);
		if (service == null) {
		return;
		}

		requireNonNull(callback);

		service.unregisterCallback(callback);
		}
		}

android/app/src/com/android/bluetooth/hap/HapClientService.java

+230 −810

File changed.

Preview size limit exceeded, changes collapsed.

android/app/tests/unit/src/com/android/bluetooth/hap/HapClientBinderTest.java

0 → 100644

+302 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright 2024 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.hap;

		import static org.junit.Assert.assertThrows;
		import static org.mockito.Mockito.any;
		import static org.mockito.Mockito.eq;
		import static org.mockito.Mockito.verify;

		import android.bluetooth.BluetoothAdapter;
		import android.bluetooth.BluetoothDevice;
		import android.bluetooth.BluetoothProfile;
		import android.bluetooth.IBluetoothHapClientCallback;
		import android.content.AttributionSource;

		import androidx.test.filters.MediumTest;
		import androidx.test.runner.AndroidJUnit4;

		import com.android.bluetooth.TestUtils;

		import org.junit.Before;
		import org.junit.Rule;
		import org.junit.Test;
		import org.junit.runner.RunWith;
		import org.mockito.Mock;
		import org.mockito.Mockito;
		import org.mockito.junit.MockitoJUnit;
		import org.mockito.junit.MockitoRule;

		@MediumTest
		@RunWith(AndroidJUnit4.class)
		public class HapClientBinderTest {
		@Rule public MockitoRule mockitoRule = MockitoJUnit.rule();

		@Mock private HapClientService mHapClientService;

		private final BluetoothAdapter mAdapter = BluetoothAdapter.getDefaultAdapter();
		private final AttributionSource mAttributionSource = mAdapter.getAttributionSource();
		private final BluetoothDevice mDevice = TestUtils.getTestDevice(mAdapter, 0);

		private HapClientBinder mBinder;

		@Before
		public void setUp() throws Exception {
		mBinder = new HapClientBinder(mHapClientService);
		}

		@Test
		public void getConnectedDevices() {
		assertThrows(NullPointerException.class, () -> mBinder.getConnectedDevices(null));
		mBinder.getConnectedDevices(mAttributionSource);
		verify(mHapClientService).getConnectedDevices();
		}

		@Test
		public void getDevicesMatchingConnectionStates() {
		assertThrows(
		NullPointerException.class,
		() -> mBinder.getDevicesMatchingConnectionStates(null, null));
		mBinder.getDevicesMatchingConnectionStates(null, mAttributionSource);
		verify(mHapClientService).getDevicesMatchingConnectionStates(any());
		}

		@Test
		public void getConnectionState() {
		assertThrows(NullPointerException.class, () -> mBinder.getConnectionState(mDevice, null));
		assertThrows(
		NullPointerException.class,
		() -> mBinder.getConnectionState(null, mAttributionSource));

		mBinder.getConnectionState(mDevice, mAttributionSource);
		verify(mHapClientService).getConnectionState(eq(mDevice));
		}

		@Test
		public void setConnectionPolicy() {
		assertThrows(
		NullPointerException.class,
		() ->
		mBinder.setConnectionPolicy(
		mDevice, BluetoothProfile.CONNECTION_POLICY_ALLOWED, null));
		assertThrows(
		NullPointerException.class,
		() ->
		mBinder.setConnectionPolicy(
		null,
		BluetoothProfile.CONNECTION_POLICY_ALLOWED,
		mAttributionSource));
		assertThrows(
		IllegalArgumentException.class,
		() ->
		mBinder.setConnectionPolicy(
		mDevice,
		BluetoothProfile.CONNECTION_POLICY_UNKNOWN,
		mAttributionSource));

		mBinder.setConnectionPolicy(
		mDevice, BluetoothProfile.CONNECTION_POLICY_ALLOWED, mAttributionSource);
		verify(mHapClientService)
		.setConnectionPolicy(eq(mDevice), eq(BluetoothProfile.CONNECTION_POLICY_ALLOWED));
		}

		@Test
		public void getConnectionPolicy() {
		assertThrows(NullPointerException.class, () -> mBinder.getConnectionPolicy(mDevice, null));
		assertThrows(
		NullPointerException.class,
		() -> mBinder.getConnectionPolicy(null, mAttributionSource));
		mBinder.getConnectionPolicy(mDevice, mAttributionSource);
		verify(mHapClientService).getConnectionPolicy(eq(mDevice));
		}

		@Test
		public void getActivePresetIndex() {
		assertThrows(NullPointerException.class, () -> mBinder.getActivePresetIndex(mDevice, null));
		assertThrows(
		NullPointerException.class,
		() -> mBinder.getActivePresetIndex(null, mAttributionSource));
		mBinder.getActivePresetIndex(mDevice, mAttributionSource);
		verify(mHapClientService).getActivePresetIndex(eq(mDevice));
		}

		@Test
		public void getActivePresetInfo() {
		assertThrows(NullPointerException.class, () -> mBinder.getActivePresetInfo(mDevice, null));
		assertThrows(
		NullPointerException.class,
		() -> mBinder.getActivePresetInfo(null, mAttributionSource));
		mBinder.getActivePresetInfo(mDevice, mAttributionSource);
		verify(mHapClientService).getActivePresetInfo(eq(mDevice));
		}

		@Test
		public void getHapGroup() {
		assertThrows(NullPointerException.class, () -> mBinder.getHapGroup(mDevice, null));
		assertThrows(
		NullPointerException.class, () -> mBinder.getHapGroup(null, mAttributionSource));
		mBinder.getHapGroup(mDevice, mAttributionSource);
		verify(mHapClientService).getHapGroup(eq(mDevice));
		}

		@Test
		public void selectPreset() {
		int index = 42;
		assertThrows(NullPointerException.class, () -> mBinder.selectPreset(mDevice, index, null));
		assertThrows(
		NullPointerException.class,
		() -> mBinder.selectPreset(null, index, mAttributionSource));
		mBinder.selectPreset(mDevice, index, mAttributionSource);
		verify(mHapClientService).selectPreset(eq(mDevice), eq(index));
		}

		@Test
		public void selectPresetForGroup() {
		int index = 42;
		int groupId = 4242;
		assertThrows(
		NullPointerException.class,
		() -> mBinder.selectPresetForGroup(groupId, index, null));
		mBinder.selectPresetForGroup(groupId, index, mAttributionSource);
		verify(mHapClientService).selectPresetForGroup(eq(groupId), eq(index));
		}

		@Test
		public void switchToNextPreset() {
		assertThrows(NullPointerException.class, () -> mBinder.switchToNextPreset(mDevice, null));
		assertThrows(
		NullPointerException.class,
		() -> mBinder.switchToNextPreset(null, mAttributionSource));
		mBinder.switchToNextPreset(mDevice, mAttributionSource);
		verify(mHapClientService).switchToNextPreset(eq(mDevice));
		}

		@Test
		public void switchToNextPresetForGroup() {
		int groupId = 4242;
		assertThrows(
		NullPointerException.class,
		() -> mBinder.switchToNextPresetForGroup(groupId, null));
		mBinder.switchToNextPresetForGroup(groupId, mAttributionSource);
		verify(mHapClientService).switchToNextPresetForGroup(eq(groupId));
		}

		@Test
		public void switchToPreviousPreset() {
		assertThrows(
		NullPointerException.class, () -> mBinder.switchToPreviousPreset(mDevice, null));
		assertThrows(
		NullPointerException.class,
		() -> mBinder.switchToPreviousPreset(null, mAttributionSource));
		mBinder.switchToPreviousPreset(mDevice, mAttributionSource);
		verify(mHapClientService).switchToPreviousPreset(eq(mDevice));
		}

		@Test
		public void switchToPreviousPresetForGroup() {
		int groupId = 4242;
		assertThrows(
		NullPointerException.class,
		() -> mBinder.switchToPreviousPresetForGroup(groupId, null));
		mBinder.switchToPreviousPresetForGroup(groupId, mAttributionSource);
		verify(mHapClientService).switchToPreviousPresetForGroup(eq(groupId));
		}

		@Test
		public void getPresetInfo() {
		int index = 42;
		assertThrows(NullPointerException.class, () -> mBinder.getPresetInfo(mDevice, index, null));
		assertThrows(
		NullPointerException.class,
		() -> mBinder.getPresetInfo(null, index, mAttributionSource));
		mBinder.getPresetInfo(mDevice, index, mAttributionSource);
		verify(mHapClientService).getPresetInfo(eq(mDevice), eq(index));
		}

		@Test
		public void getAllPresetInfo() {
		assertThrows(NullPointerException.class, () -> mBinder.getAllPresetInfo(mDevice, null));
		assertThrows(
		NullPointerException.class,
		() -> mBinder.getAllPresetInfo(null, mAttributionSource));
		mBinder.getAllPresetInfo(mDevice, mAttributionSource);
		verify(mHapClientService).getAllPresetInfo(eq(mDevice));
		}

		@Test
		public void getFeatures() {
		assertThrows(NullPointerException.class, () -> mBinder.getFeatures(mDevice, null));
		assertThrows(
		NullPointerException.class, () -> mBinder.getFeatures(null, mAttributionSource));
		mBinder.getFeatures(mDevice, mAttributionSource);
		verify(mHapClientService).getFeatures(eq(mDevice));
		}

		@Test
		public void setPresetName() {
		String name = "This is a preset name";
		int index = 42;
		assertThrows(
		NullPointerException.class,
		() -> mBinder.setPresetName(null, index, name, mAttributionSource));
		assertThrows(
		NullPointerException.class,
		() -> mBinder.setPresetName(mDevice, index, null, mAttributionSource));
		assertThrows(
		NullPointerException.class,
		() -> mBinder.setPresetName(mDevice, index, name, null));
		mBinder.setPresetName(mDevice, index, name, mAttributionSource);
		verify(mHapClientService).setPresetName(eq(mDevice), eq(index), eq(name));
		}

		@Test
		public void setPresetNameForGroup() {
		String name = "This is a preset name";
		int index = 42;
		int groupId = 4242;
		assertThrows(
		NullPointerException.class,
		() -> mBinder.setPresetNameForGroup(groupId, index, null, mAttributionSource));
		assertThrows(
		NullPointerException.class,
		() -> mBinder.setPresetNameForGroup(groupId, index, name, null));
		mBinder.setPresetNameForGroup(groupId, index, name, mAttributionSource);
		verify(mHapClientService).setPresetNameForGroup(eq(groupId), eq(index), eq(name));
		}

		@Test
		public void registerCallback() {
		IBluetoothHapClientCallback callback = Mockito.mock(IBluetoothHapClientCallback.class);
		assertThrows(
		NullPointerException.class,
		() -> mBinder.registerCallback(null, mAttributionSource));
		assertThrows(NullPointerException.class, () -> mBinder.registerCallback(callback, null));
		mBinder.registerCallback(callback, mAttributionSource);
		verify(mHapClientService).registerCallback(eq(callback));
		}

		@Test
		public void unregisterCallback() {
		IBluetoothHapClientCallback callback = Mockito.mock(IBluetoothHapClientCallback.class);
		assertThrows(
		NullPointerException.class,
		() -> mBinder.unregisterCallback(null, mAttributionSource));
		assertThrows(NullPointerException.class, () -> mBinder.unregisterCallback(callback, null));
		mBinder.unregisterCallback(callback, mAttributionSource);
		verify(mHapClientService).unregisterCallback(eq(callback));
		}
		}

android/app/tests/unit/src/com/android/bluetooth/hap/HapClientTest.java→android/app/tests/unit/src/com/android/bluetooth/hap/HapClientServiceTest.java

+23 −60

File changed and moved.

Preview size limit exceeded, changes collapsed.