Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge "csip: Add Coordinated Set Identification Profile"

Browse Source
This commit is contained in:
Jakub Pawlowski
2021-09-13 20:40:31 +00:00
committed by Gerrit Code Review
parent 49dcfea031 58ad9295c7
commit baea19f18f
5 changed files with 586 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
core/api/current.txt
View File

@@ -8657,6 +8657,15 @@ package android.bluetooth {
field public static final int TELEPHONY = 4194304; // 0x400000
}
public final class BluetoothCsipSetCoordinator implements java.lang.AutoCloseable android.bluetooth.BluetoothProfile {
method public void close();
method protected void finalize();
method @NonNull public java.util.List<android.bluetooth.BluetoothDevice> getConnectedDevices();
method public int getConnectionState(@Nullable android.bluetooth.BluetoothDevice);
method @NonNull public java.util.List<android.bluetooth.BluetoothDevice> getDevicesMatchingConnectionStates(@NonNull int[]);
field @RequiresPermission(android.Manifest.permission.BLUETOOTH) public static final String ACTION_CSIS_CONNECTION_STATE_CHANGED = "android.bluetooth.action.CSIS_CONNECTION_STATE_CHANGED";
}
public final class BluetoothDevice implements android.os.Parcelable {
method public android.bluetooth.BluetoothGatt connectGatt(android.content.Context, boolean, android.bluetooth.BluetoothGattCallback);
method public android.bluetooth.BluetoothGatt connectGatt(android.content.Context, boolean, android.bluetooth.BluetoothGattCallback, int);

15
core/api/system-current.txt
View File

@@ -1507,6 +1507,21 @@ package android.bluetooth {
method public void onOobData(int, @NonNull android.bluetooth.OobData);
}
public final class BluetoothCsipSetCoordinator implements java.lang.AutoCloseable android.bluetooth.BluetoothProfile {
method @NonNull @RequiresPermission(android.Manifest.permission.BLUETOOTH_PRIVILEGED) public java.util.List<java.lang.Integer> getAllGroupIds(@Nullable android.os.ParcelUuid);
method @RequiresPermission(android.Manifest.permission.BLUETOOTH_PRIVILEGED) public int getConnectionPolicy(@Nullable android.bluetooth.BluetoothDevice);
method @NonNull @RequiresPermission(android.Manifest.permission.BLUETOOTH_PRIVILEGED) public java.util.Map getGroupUuidMapByDevice(@Nullable android.bluetooth.BluetoothDevice);
method @Nullable @RequiresPermission(android.Manifest.permission.BLUETOOTH_PRIVILEGED) public java.util.UUID groupLock(int, @Nullable java.util.concurrent.Executor, @Nullable android.bluetooth.BluetoothCsipSetCoordinator.ClientLockCallback);
method @RequiresPermission(android.Manifest.permission.BLUETOOTH_PRIVILEGED) public boolean groupUnlock(@NonNull java.util.UUID);
method @RequiresPermission(android.Manifest.permission.BLUETOOTH_PRIVILEGED) public boolean setConnectionPolicy(@Nullable android.bluetooth.BluetoothDevice, int);
field @RequiresPermission(android.Manifest.permission.BLUETOOTH_PRIVILEGED) public static final String ACTION_CSIS_DEVICE_AVAILABLE = "android.bluetooth.action.CSIS_DEVICE_AVAILABLE";
field @RequiresPermission(android.Manifest.permission.BLUETOOTH_PRIVILEGED) public static final String ACTION_CSIS_SET_MEMBER_AVAILABLE = "android.bluetooth.action.CSIS_SET_MEMBER_AVAILABLE";
}
public static interface BluetoothCsipSetCoordinator.ClientLockCallback {
method public void onGroupLockSet(int, int, boolean);
}
public final class BluetoothDevice implements android.os.Parcelable {
method @RequiresPermission(android.Manifest.permission.BLUETOOTH_PRIVILEGED) public boolean cancelBondProcess();
method @RequiresPermission(android.Manifest.permission.BLUETOOTH_PRIVILEGED) public boolean createBondOutOfBand(int, @Nullable android.bluetooth.OobData, @Nullable android.bluetooth.OobData);

9
core/java/android/bluetooth/BluetoothAdapter.java
View File

@@ -2819,6 +2819,10 @@ public final class BluetoothAdapter {
} else if (profile == BluetoothProfile.VOLUME_CONTROL) {
BluetoothVolumeControl vcs = new BluetoothVolumeControl(context, listener, this);
return true;
} else if (profile == BluetoothProfile.CSIP_SET_COORDINATOR) {
BluetoothCsipSetCoordinator csipSetCoordinator =
new BluetoothCsipSetCoordinator(context, listener);
return true;
} else {
return false;
}
@@ -2908,6 +2912,11 @@ public final class BluetoothAdapter {
BluetoothVolumeControl vcs = (BluetoothVolumeControl) proxy;
vcs.close();
break;
case BluetoothProfile.CSIP_SET_COORDINATOR:
BluetoothCsipSetCoordinator csipSetCoordinator =
(BluetoothCsipSetCoordinator) proxy;
csipSetCoordinator.close();
break;
}
}

550
core/java/android/bluetooth/BluetoothCsipSetCoordinator.java Normal file
View File

@@ -0,0 +1,550 @@
/*
* Copyright 2021 HIMSA II K/S - www.himsa.com.
* Represented by EHIMA - www.ehima.com
*
* 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;
import android.Manifest;
import android.annotation.CallbackExecutor;
import android.annotation.NonNull;
import android.annotation.Nullable;
import android.annotation.RequiresPermission;
import android.annotation.SdkConstant;
import android.annotation.SdkConstant.SdkConstantType;
import android.annotation.SystemApi;
import android.content.Context;
import android.os.Binder;
import android.os.IBinder;
import android.os.ParcelUuid;
import android.os.RemoteException;
import android.util.CloseGuard;
import android.util.Log;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.Executor;
/**
* This class provides the public APIs to control the Bluetooth CSIP set coordinator.
*
* <p>BluetoothCsipSetCoordinator is a proxy object for controlling the Bluetooth VC
* Service via IPC. Use {@link BluetoothAdapter#getProfileProxy} to get
* the BluetoothCsipSetCoordinator proxy object.
*
*/
public final class BluetoothCsipSetCoordinator implements BluetoothProfile, AutoCloseable {
private static final String TAG = "BluetoothCsipSetCoordinator";
private static final boolean DBG = false;
private static final boolean VDBG = false;
private CloseGuard mCloseGuard;
/**
* @hide
*/
@SystemApi
public interface ClientLockCallback {
/**
* @hide
*/
@SystemApi void onGroupLockSet(int groupId, int opStatus, boolean isLocked);
}
private static class BluetoothCsipSetCoordinatorLockCallbackDelegate
extends IBluetoothCsipSetCoordinatorLockCallback.Stub {
private final ClientLockCallback mCallback;
private final Executor mExecutor;
BluetoothCsipSetCoordinatorLockCallbackDelegate(
Executor executor, ClientLockCallback callback) {
mExecutor = executor;
mCallback = callback;
}
@Override
public void onGroupLockSet(int groupId, int opStatus, boolean isLocked) {
mExecutor.execute(() -> mCallback.onGroupLockSet(groupId, opStatus, isLocked));
}
};
/**
* Intent used to broadcast the change in connection state of the CSIS
* Client.
*
* <p>This intent will have 3 extras:
* <ul>
* <li> {@link #EXTRA_STATE} - The current state of the profile. </li>
* <li> {@link #EXTRA_PREVIOUS_STATE}- The previous state of the profile.</li>
* <li> {@link BluetoothDevice#EXTRA_DEVICE} - The remote device. </li>
* </ul>
*
* <p>{@link #EXTRA_STATE} or {@link #EXTRA_PREVIOUS_STATE} can be any of
* {@link #STATE_DISCONNECTED}, {@link #STATE_CONNECTING},
* {@link #STATE_CONNECTED}, {@link #STATE_DISCONNECTING}.
*/
@RequiresPermission(android.Manifest.permission.BLUETOOTH)
@SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
public static final String ACTION_CSIS_CONNECTION_STATE_CHANGED =
"android.bluetooth.action.CSIS_CONNECTION_STATE_CHANGED";
/**
* Intent used to expose broadcast receiving device.
*
* <p>This intent will have 2 extras:
* <ul>
* <li> {@link BluetoothDevice#EXTRA_DEVICE} - The remote Broadcast receiver device. </li>
* <li> {@link #EXTRA_CSIS_GROUP_ID} - Group identifier. </li>
* <li> {@link #EXTRA_CSIS_GROUP_SIZE} - Group size. </li>
* <li> {@link #EXTRA_CSIS_GROUP_TYPE_UUID} - Group type UUID. </li>
* </ul>
*
* @hide
*/
@SystemApi
@RequiresPermission(android.Manifest.permission.BLUETOOTH_PRIVILEGED)
@SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
public static final String ACTION_CSIS_DEVICE_AVAILABLE =
"android.bluetooth.action.CSIS_DEVICE_AVAILABLE";
/**
* Used as an extra field in {@link #ACTION_CSIS_DEVICE_AVAILABLE} intent.
* Contains the group id.
*
* @hide
*/
public static final String EXTRA_CSIS_GROUP_ID = "android.bluetooth.extra.CSIS_GROUP_ID";
/**
* Group size as int extra field in {@link #ACTION_CSIS_DEVICE_AVAILABLE} intent.
*
* @hide
*/
public static final String EXTRA_CSIS_GROUP_SIZE = "android.bluetooth.extra.CSIS_GROUP_SIZE";
/**
* Group type uuid extra field in {@link #ACTION_CSIS_DEVICE_AVAILABLE} intent.
*
* @hide
*/
public static final String EXTRA_CSIS_GROUP_TYPE_UUID =
"android.bluetooth.extra.CSIS_GROUP_TYPE_UUID";
/**
* Intent used to broadcast information about identified set member
* ready to connect.
*
* <p>This intent will have one extra:
* <ul>
* <li> {@link BluetoothDevice#EXTRA_DEVICE} - The remote device. It can
* be null if no device is active. </li>
* <li> {@link #EXTRA_CSIS_GROUP_ID} - Group identifier. </li>
* </ul>
*
* @hide
*/
@SystemApi
@RequiresPermission(android.Manifest.permission.BLUETOOTH_PRIVILEGED)
@SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
public static final String ACTION_CSIS_SET_MEMBER_AVAILABLE =
"android.bluetooth.action.CSIS_SET_MEMBER_AVAILABLE";
/**
* This represents an invalid group ID.
*
* @hide
*/
public static final int GROUP_ID_INVALID = IBluetoothCsipSetCoordinator.CSIS_GROUP_ID_INVALID;
/**
* Indicating that group was locked with success.
*
* @hide
*/
public static final int GROUP_LOCK_SUCCESS = 0;
/**
* Indicating that group locked failed due to invalid group ID.
*
* @hide
*/
public static final int GROUP_LOCK_FAILED_INVALID_GROUP = 1;
/**
* Indicating that group locked failed due to empty group.
*
* @hide
*/
public static final int GROUP_LOCK_FAILED_GROUP_EMPTY = 2;
/**
* Indicating that group locked failed due to group members being disconnected.
*
* @hide
*/
public static final int GROUP_LOCK_FAILED_GROUP_NOT_CONNECTED = 3;
/**
* Indicating that group locked failed due to group member being already locked.
*
* @hide
*/
public static final int GROUP_LOCK_FAILED_LOCKED_BY_OTHER = 4;
/**
* Indicating that group locked failed due to other reason.
*
* @hide
*/
public static final int GROUP_LOCK_FAILED_OTHER_REASON = 5;
/**
* Indicating that group member in locked state was lost.
*
* @hide
*/
public static final int LOCKED_GROUP_MEMBER_LOST = 6;
private BluetoothAdapter mAdapter;
private final BluetoothProfileConnector<IBluetoothCsipSetCoordinator> mProfileConnector =
new BluetoothProfileConnector(this, BluetoothProfile.CSIP_SET_COORDINATOR, TAG,
IBluetoothCsipSetCoordinator.class.getName()) {
@Override
public IBluetoothCsipSetCoordinator getServiceInterface(IBinder service) {
return IBluetoothCsipSetCoordinator.Stub.asInterface(
Binder.allowBlocking(service));
}
};
/**
* Create a BluetoothCsipSetCoordinator proxy object for interacting with the local
* Bluetooth CSIS service.
*/
/*package*/ BluetoothCsipSetCoordinator(Context context, ServiceListener listener) {
mAdapter = BluetoothAdapter.getDefaultAdapter();
mProfileConnector.connect(context, listener);
mCloseGuard = new CloseGuard();
mCloseGuard.open("close");
}
/**
* @hide
*/
protected void finalize() {
if (mCloseGuard != null) {
mCloseGuard.warnIfOpen();
}
close();
}
/**
* @hide
*/
public void close() {
mProfileConnector.disconnect();
}
private IBluetoothCsipSetCoordinator getService() {
return mProfileConnector.getService();
}
/**
* Lock the set.
* @param groupId group ID to lock,
* @param executor callback executor,
* @param cb callback to report lock and unlock events - stays valid until the app unlocks
* using the returned lock identifier or the lock timeouts on the remote side,
* as per CSIS specification,
* @return unique lock identifier used for unlocking or null if lock has failed.
*
* @hide
*/
@SystemApi
@RequiresPermission(Manifest.permission.BLUETOOTH_PRIVILEGED)
public
@Nullable UUID groupLock(int groupId, @Nullable @CallbackExecutor Executor executor,
@Nullable ClientLockCallback cb) {
if (VDBG) {
log("groupLockSet()");
}
final IBluetoothCsipSetCoordinator service = getService();
try {
if (service != null && isEnabled()) {
IBluetoothCsipSetCoordinatorLockCallback delegate = null;
if ((executor != null) && (cb != null)) {
delegate = new BluetoothCsipSetCoordinatorLockCallbackDelegate(executor, cb);
}
return service.groupLock(groupId, delegate).getUuid();
}
if (service == null) {
Log.w(TAG, "Proxy not attached to service");
}
return null;
} catch (RemoteException e) {
Log.e(TAG, "Stack:" + Log.getStackTraceString(new Throwable()));
return null;
}
}
/**
* Unlock the set.
* @param lockUuid unique lock identifier
* @return true if unlocked, false on error
*
* @hide
*/
@SystemApi
@RequiresPermission(Manifest.permission.BLUETOOTH_PRIVILEGED)
public boolean groupUnlock(@NonNull UUID lockUuid) {
if (VDBG) {
log("groupLockSet()");
}
if (lockUuid == null) {
return false;
}
final IBluetoothCsipSetCoordinator service = getService();
try {
if (service != null && isEnabled()) {
service.groupUnlock(new ParcelUuid(lockUuid));
return true;
}
if (service == null) {
Log.w(TAG, "Proxy not attached to service");
}
return false;
} catch (RemoteException e) {
Log.e(TAG, "Stack:" + Log.getStackTraceString(new Throwable()));
return false;
}
}
/**
* Get device's groups.
* @param device the active device
* @return Map of groups ids and related UUIDs
*
* @hide
*/
@SystemApi
@RequiresPermission(Manifest.permission.BLUETOOTH_PRIVILEGED)
public @NonNull Map getGroupUuidMapByDevice(@Nullable BluetoothDevice device) {
if (VDBG) {
log("getGroupUuidMapByDevice()");
}
final IBluetoothCsipSetCoordinator service = getService();
try {
if (service != null && isEnabled()) {
return service.getGroupUuidMapByDevice(device);
}
if (service == null) {
Log.w(TAG, "Proxy not attached to service");
}
return new HashMap<>();
} catch (RemoteException e) {
Log.e(TAG, "Stack:" + Log.getStackTraceString(new Throwable()));
return new HashMap<>();
}
}
/**
* Get group id for the given UUID
* @param uuid
* @return list of group IDs
*
* @hide
*/
@SystemApi
@RequiresPermission(Manifest.permission.BLUETOOTH_PRIVILEGED)
public @NonNull List<Integer> getAllGroupIds(@Nullable ParcelUuid uuid) {
if (VDBG) {
log("getAllGroupIds()");
}
final IBluetoothCsipSetCoordinator service = getService();
try {
if (service != null && isEnabled()) {
return service.getAllGroupIds(uuid);
}
if (service == null) {
Log.w(TAG, "Proxy not attached to service");
}
return new ArrayList<Integer>();
} catch (RemoteException e) {
Log.e(TAG, "Stack:" + Log.getStackTraceString(new Throwable()));
return new ArrayList<Integer>();
}
}
/**
* {@inheritDoc}
*/
@Override
public @NonNull List<BluetoothDevice> getConnectedDevices() {
if (VDBG) {
log("getConnectedDevices()");
}
final IBluetoothCsipSetCoordinator service = getService();
if (service != null && isEnabled()) {
try {
return service.getConnectedDevices();
} catch (RemoteException e) {
Log.e(TAG, "Stack:" + Log.getStackTraceString(new Throwable()));
return new ArrayList<BluetoothDevice>();
}
}
if (service == null) {
Log.w(TAG, "Proxy not attached to service");
}
return new ArrayList<BluetoothDevice>();
}
/**
* {@inheritDoc}
*/
@Override
public
@NonNull List<BluetoothDevice> getDevicesMatchingConnectionStates(
@NonNull int[] states) {
if (VDBG) {
log("getDevicesMatchingStates(states=" + Arrays.toString(states) + ")");
}
final IBluetoothCsipSetCoordinator service = getService();
if (service != null && isEnabled()) {
try {
return service.getDevicesMatchingConnectionStates(states);
} catch (RemoteException e) {
Log.e(TAG, "Stack:" + Log.getStackTraceString(new Throwable()));
return new ArrayList<BluetoothDevice>();
}
}
if (service == null) {
Log.w(TAG, "Proxy not attached to service");
}
return new ArrayList<BluetoothDevice>();
}
/**
* {@inheritDoc}
*/
@Override
public
@BluetoothProfile.BtProfileState int getConnectionState(
@Nullable BluetoothDevice device) {
if (VDBG) {
log("getState(" + device + ")");
}
final IBluetoothCsipSetCoordinator service = getService();
if (service != null && isEnabled() && isValidDevice(device)) {
try {
return service.getConnectionState(device);
} catch (RemoteException e) {
Log.e(TAG, "Stack:" + Log.getStackTraceString(new Throwable()));
return BluetoothProfile.STATE_DISCONNECTED;
}
}
if (service == null) {
Log.w(TAG, "Proxy not attached to service");
}
return BluetoothProfile.STATE_DISCONNECTED;
}
/**
* Set connection policy of the profile
*
* <p> The device should already be paired.
* Connection policy can be one of {@link #CONNECTION_POLICY_ALLOWED},
* {@link #CONNECTION_POLICY_FORBIDDEN}, {@link #CONNECTION_POLICY_UNKNOWN}
*
* @param device Paired bluetooth device
* @param connectionPolicy is the connection policy to set to for this profile
* @return true if connectionPolicy is set, false on error
*
* @hide
*/
@SystemApi
@RequiresPermission(Manifest.permission.BLUETOOTH_PRIVILEGED)
public boolean setConnectionPolicy(
@Nullable BluetoothDevice device, @ConnectionPolicy int connectionPolicy) {
if (DBG) {
log("setConnectionPolicy(" + device + ", " + connectionPolicy + ")");
}
final IBluetoothCsipSetCoordinator service = getService();
try {
if (service != null && isEnabled() && isValidDevice(device)) {
if (connectionPolicy != BluetoothProfile.CONNECTION_POLICY_FORBIDDEN
&& connectionPolicy != BluetoothProfile.CONNECTION_POLICY_ALLOWED) {
return false;
}
return service.setConnectionPolicy(device, connectionPolicy);
}
if (service == null) {
Log.w(TAG, "Proxy not attached to service");
}
return false;
} catch (RemoteException e) {
Log.e(TAG, "Stack:" + Log.getStackTraceString(new Throwable()));
return false;
}
}
/**
* Get the connection policy of the profile.
*
* <p> The connection policy can be any of:
* {@link #CONNECTION_POLICY_ALLOWED}, {@link #CONNECTION_POLICY_FORBIDDEN},
* {@link #CONNECTION_POLICY_UNKNOWN}
*
* @param device Bluetooth device
* @return connection policy of the device
*
* @hide
*/
@SystemApi
@RequiresPermission(Manifest.permission.BLUETOOTH_PRIVILEGED)
public @ConnectionPolicy int getConnectionPolicy(@Nullable BluetoothDevice device) {
if (VDBG) {
log("getConnectionPolicy(" + device + ")");
}
final IBluetoothCsipSetCoordinator service = getService();
try {
if (service != null && isEnabled() && isValidDevice(device)) {
return service.getConnectionPolicy(device);
}
if (service == null) {
Log.w(TAG, "Proxy not attached to service");
}
return BluetoothProfile.CONNECTION_POLICY_FORBIDDEN;
} catch (RemoteException e) {
Log.e(TAG, "Stack:" + Log.getStackTraceString(new Throwable()));
return BluetoothProfile.CONNECTION_POLICY_FORBIDDEN;
}
}
private boolean isEnabled() {
return mAdapter.getState() == BluetoothAdapter.STATE_ON;
}
private static boolean isValidDevice(@Nullable BluetoothDevice device) {
return device != null && BluetoothAdapter.checkBluetoothAddress(device.getAddress());
}
private static void log(String msg) {
Log.d(TAG, msg);
}
}

3
core/res/AndroidManifest.xml
View File

@@ -196,6 +196,9 @@
android:name="android.bluetooth.hearingaid.profile.action.PLAYING_STATE_CHANGED" />
<protected-broadcast
android:name="android.bluetooth.hearingaid.profile.action.ACTIVE_DEVICE_CHANGED" />
<protected-broadcast android:name="android.bluetooth.action.CSIS_CONNECTION_STATE_CHANGED" />
<protected-broadcast android:name="android.bluetooth.action.CSIS_DEVICE_AVAILABLE" />
<protected-broadcast android:name="android.bluetooth.action.CSIS_SET_MEMBER_AVAILABLE" />
<protected-broadcast
android:name="android.bluetooth.volume-control.profile.action.CONNECTION_STATE_CHANGED" />
<protected-broadcast