| /* |
| * Copyright 2021 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; |
| |
| import android.annotation.CallbackExecutor; |
| import android.annotation.IntDef; |
| import android.annotation.NonNull; |
| import android.annotation.Nullable; |
| import android.annotation.RequiresPermission; |
| import android.annotation.SdkConstant; |
| import android.annotation.SystemApi; |
| import android.bluetooth.annotations.RequiresBluetoothConnectPermission; |
| import android.bluetooth.annotations.RequiresBluetoothLocationPermission; |
| import android.bluetooth.annotations.RequiresBluetoothScanPermission; |
| import android.bluetooth.le.ScanFilter; |
| import android.bluetooth.le.ScanSettings; |
| import android.content.AttributionSource; |
| import android.content.Context; |
| import android.os.IBinder; |
| import android.os.RemoteException; |
| import android.util.CloseGuard; |
| import android.util.Log; |
| |
| import java.lang.annotation.Retention; |
| import java.lang.annotation.RetentionPolicy; |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Objects; |
| import java.util.concurrent.Executor; |
| |
| /** |
| * This class provides the public APIs for the LE Audio Broadcast Assistant role, which implements |
| * client side control points for Broadcast Audio Scan Service (BASS). |
| * |
| * <p>An LE Audio Broadcast Assistant can help a Broadcast Sink to scan for available Broadcast |
| * Sources. The Broadcast Sink achieves this by offloading the scan to a Broadcast Assistant. |
| * This is facilitated by the Broadcast Audio Scan Service (BASS). A BASS server is a GATT |
| * server that is part of the Scan Delegator on a Broadcast Sink. A BASS client instead runs on |
| * the Broadcast Assistant. |
| * |
| * <p>Once a GATT connection is established between the BASS client and the BASS server, the |
| * Broadcast Sink can offload the scans to the Broadcast Assistant. Upon finding new Broadcast |
| * Sources, the Broadcast Assistant then notifies the Broadcast Sink about these over the |
| * established GATT connection. The Scan Delegator on the Broadcast Sink can also notify the |
| * Assistant about changes such as addition and removal of Broadcast Sources. |
| * |
| * In the context of this class, BASS server will be addressed as Broadcast Sink and BASS client |
| * will be addressed as Broadcast Assistant. |
| * |
| * <p>BluetoothLeBroadcastAssistant is a proxy object for controlling the Broadcast Assistant |
| * service via IPC. Use {@link BluetoothAdapter#getProfileProxy} to get the |
| * BluetoothLeBroadcastAssistant proxy object. |
| * |
| * @hide |
| */ |
| @SystemApi |
| public final class BluetoothLeBroadcastAssistant implements BluetoothProfile, AutoCloseable { |
| private static final String TAG = "BluetoothLeBroadcastAssistant"; |
| private static final boolean DBG = true; |
| private final Map<Callback, Executor> mCallbackMap = new HashMap<>(); |
| |
| /** |
| * This class provides a set of callbacks that are invoked when scanning for Broadcast Sources |
| * is offloaded to a Broadcast Assistant. |
| * |
| * @hide |
| */ |
| @SystemApi |
| public interface Callback { |
| /** @hide */ |
| @Retention(RetentionPolicy.SOURCE) |
| @IntDef(value = { |
| BluetoothStatusCodes.ERROR_UNKNOWN, |
| BluetoothStatusCodes.REASON_LOCAL_APP_REQUEST, |
| BluetoothStatusCodes.REASON_LOCAL_STACK_REQUEST, |
| BluetoothStatusCodes.REASON_REMOTE_REQUEST, |
| BluetoothStatusCodes.REASON_SYSTEM_POLICY, |
| BluetoothStatusCodes.ERROR_HARDWARE_GENERIC, |
| BluetoothStatusCodes.ERROR_LE_BROADCAST_ASSISTANT_DUPLICATE_ADDITION, |
| BluetoothStatusCodes.ERROR_BAD_PARAMETERS, |
| BluetoothStatusCodes.ERROR_REMOTE_LINK_ERROR, |
| BluetoothStatusCodes.ERROR_REMOTE_NOT_ENOUGH_RESOURCES, |
| BluetoothStatusCodes.ERROR_LE_BROADCAST_ASSISTANT_INVALID_SOURCE_ID, |
| BluetoothStatusCodes.ERROR_ALREADY_IN_TARGET_STATE, |
| BluetoothStatusCodes.ERROR_REMOTE_OPERATION_REJECTED, |
| }) |
| @interface Reason {} |
| |
| /** |
| * Callback invoked when the implementation started searching for nearby Broadcast Sources. |
| * |
| * @param reason reason code on why search has started |
| * @hide |
| */ |
| @SystemApi |
| void onSearchStarted(@Reason int reason); |
| |
| /** |
| * Callback invoked when the implementation failed to start searching for nearby broadcast |
| * sources. |
| * |
| * @param reason reason for why search failed to start |
| * @hide |
| */ |
| @SystemApi |
| void onSearchStartFailed(@Reason int reason); |
| |
| /** |
| * Callback invoked when the implementation stopped searching for nearby Broadcast Sources. |
| * |
| * @param reason reason code on why search has stopped |
| * @hide |
| */ |
| @SystemApi |
| void onSearchStopped(@Reason int reason); |
| |
| /** |
| * Callback invoked when the implementation failed to stop searching for nearby broadcast |
| * sources. |
| * |
| * @param reason for why search failed to start |
| * @hide |
| */ |
| @SystemApi |
| void onSearchStopFailed(@Reason int reason); |
| |
| /** |
| * Callback invoked when a new Broadcast Source is found together with the |
| * {@link BluetoothLeBroadcastMetadata}. |
| * |
| * @param source {@link BluetoothLeBroadcastMetadata} representing a Broadcast Source |
| * @hide |
| */ |
| @SystemApi |
| void onSourceFound(@NonNull BluetoothLeBroadcastMetadata source); |
| |
| /** |
| * Callback invoked when a new Broadcast Source has been successfully added to the |
| * Broadcast Sink. |
| * |
| * Broadcast audio stream may not have been started after this callback, the caller need |
| * to monitor |
| * {@link #onReceiveStateChanged(BluetoothDevice, int, BluetoothLeBroadcastReceiveState)} |
| * to see if synchronization with Broadcast Source is successful |
| * |
| * When <var>isGroupOp</var> is true when |
| * {@link #addSource(BluetoothDevice, BluetoothLeBroadcastMetadata, boolean)} |
| * is called, each Broadcast Sink device in the coordinated set will trigger and individual |
| * update |
| * |
| * A new source could be added by the Broadcast Sink itself or other Broadcast Assistants |
| * connected to the Broadcast Sink and in this case the reason code will be |
| * {@link BluetoothStatusCodes#REASON_REMOTE_REQUEST} |
| * |
| * @param sink Broadcast Sink device on which a new Broadcast Source has been added |
| * @param sourceId source ID as defined in the BASS specification |
| * @param reason reason of source addition |
| * @hide |
| */ |
| @SystemApi |
| void onSourceAdded(@NonNull BluetoothDevice sink, @Reason int sourceId, |
| @Reason int reason); |
| |
| /** |
| * Callback invoked when the new Broadcast Source failed to be added to the Broadcast Sink. |
| * |
| * @param sink Broadcast Sink device on which a new Broadcast Source has been added |
| * @param source metadata representation of the Broadcast Source |
| * @param reason reason why the addition has failed |
| * @hide |
| */ |
| @SystemApi |
| void onSourceAddFailed(@NonNull BluetoothDevice sink, |
| @NonNull BluetoothLeBroadcastMetadata source, @Reason int reason); |
| |
| /** |
| * Callback invoked when an existing Broadcast Source within a Broadcast Sink has been |
| * modified. |
| * |
| * Actual state after the modification will be delivered via the next |
| * {@link Callback#onReceiveStateChanged(BluetoothDevice, int, |
| * BluetoothLeBroadcastReceiveState)} |
| * callback. |
| * |
| * A source could be modified by the Broadcast Sink itself or other Broadcast Assistants |
| * connected to the Broadcast Sink and in this case the reason code will be |
| * {@link BluetoothStatusCodes#REASON_REMOTE_REQUEST} |
| * |
| * @param sink Broadcast Sink device on which a Broadcast Source has been modified |
| * @param sourceId source ID as defined in the BASS specification |
| * @param reason reason of source modification |
| * @hide |
| */ |
| @SystemApi |
| void onSourceModified(@NonNull BluetoothDevice sink, int sourceId, @Reason int reason); |
| |
| /** |
| * Callback invoked when the Broadcast Assistant failed to modify an existing Broadcast |
| * Source on a Broadcast Sink. |
| * |
| * @param sink Broadcast Sink device on which a Broadcast Source has been modified |
| * @param sourceId source ID as defined in the BASS specification |
| * @param reason reason why the modification has failed |
| * @hide |
| */ |
| @SystemApi |
| void onSourceModifyFailed(@NonNull BluetoothDevice sink, int sourceId, @Reason int reason); |
| |
| /** |
| * Callback invoked when a Broadcast Source has been successfully removed from the |
| * Broadcast Sink. |
| * |
| * No more update for the source ID via |
| * {@link Callback#onReceiveStateChanged(BluetoothDevice, int, |
| * BluetoothLeBroadcastReceiveState)} |
| * after this callback. |
| * |
| * A source could be removed by the Broadcast Sink itself or other Broadcast Assistants |
| * connected to the Broadcast Sink and in this case the reason code will be |
| * {@link BluetoothStatusCodes#REASON_REMOTE_REQUEST} |
| * |
| * @param sink Broadcast Sink device from which a Broadcast Source has been removed |
| * @param sourceId source ID as defined in the BASS specification |
| * @param reason reason why the Broadcast Source was removed |
| * @hide |
| */ |
| @SystemApi |
| void onSourceRemoved(@NonNull BluetoothDevice sink, int sourceId, @Reason int reason); |
| |
| /** |
| * Callback invoked when the Broadcast Assistant failed to remove an existing Broadcast |
| * Source on a Broadcast Sink. |
| * |
| * @param sink Broadcast Sink device on which a Broadcast Source was to be removed |
| * @param sourceId source ID as defined in the BASS specification |
| * @param reason reason why the modification has failed |
| * @hide |
| */ |
| @SystemApi |
| void onSourceRemoveFailed(@NonNull BluetoothDevice sink, int sourceId, @Reason int reason); |
| |
| /** |
| * Callback invoked when the Broadcast Receive State information of a Broadcast Sink device |
| * changes. |
| * |
| * @param sink BASS server device that is also a Broadcast Sink device |
| * @param sourceId source ID as defined in the BASS specification |
| * @param state latest state information between the Broadcast Sink and a Broadcast Source |
| * @hide |
| */ |
| @SystemApi |
| void onReceiveStateChanged(@NonNull BluetoothDevice sink, int sourceId, |
| @NonNull BluetoothLeBroadcastReceiveState state); |
| } |
| |
| /** |
| * Intent used to broadcast the change in connection state of devices via Broadcast Audio Scan |
| * Service (BASS). Please note that in a coordinated set, each set member will connect via BASS |
| * individually. Group operations on a single set member will propagate to the entire set. |
| * |
| * For example, in the binaural case, there will be two different LE devices for the left and |
| * right side and each device will have their own connection state changes. If both devices |
| * belongs to on Coordinated Set, group operation on one of them will affect both devices. |
| * |
| * <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}. |
| * |
| * @hide |
| */ |
| @SystemApi |
| @RequiresBluetoothConnectPermission |
| @RequiresPermission(allOf = { |
| android.Manifest.permission.BLUETOOTH_CONNECT, |
| android.Manifest.permission.BLUETOOTH_PRIVILEGED, |
| }) |
| @SdkConstant(SdkConstant.SdkConstantType.BROADCAST_INTENT_ACTION) |
| public static final String ACTION_CONNECTION_STATE_CHANGED = |
| "android.bluetooth.action.CONNECTION_STATE_CHANGED"; |
| |
| private CloseGuard mCloseGuard; |
| private Context mContext; |
| private BluetoothAdapter mBluetoothAdapter; |
| private final AttributionSource mAttributionSource; |
| private BluetoothLeBroadcastAssistantCallback mCallback; |
| |
| private final BluetoothProfileConnector<IBluetoothLeBroadcastAssistant> mProfileConnector = |
| new BluetoothProfileConnector(this, BluetoothProfile.LE_AUDIO_BROADCAST_ASSISTANT, |
| TAG, IBluetoothLeBroadcastAssistant.class.getName()) { |
| @Override |
| public IBluetoothLeBroadcastAssistant getServiceInterface(IBinder service) { |
| return IBluetoothLeBroadcastAssistant.Stub.asInterface(service); |
| } |
| }; |
| |
| /** |
| * Create a new instance of an LE Audio Broadcast Assistant. |
| * |
| * @hide |
| */ |
| /*package*/ BluetoothLeBroadcastAssistant( |
| @NonNull Context context, @NonNull ServiceListener listener) { |
| mContext = context; |
| mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter(); |
| mAttributionSource = mBluetoothAdapter.getAttributionSource(); |
| mProfileConnector.connect(context, listener); |
| mCloseGuard = new CloseGuard(); |
| mCloseGuard.open("close"); |
| } |
| |
| /** @hide */ |
| protected void finalize() { |
| if (mCloseGuard != null) { |
| mCloseGuard.warnIfOpen(); |
| } |
| close(); |
| } |
| |
| /** @hide */ |
| @Override |
| public void close() { |
| mProfileConnector.disconnect(); |
| } |
| |
| private IBluetoothLeBroadcastAssistant getService() { |
| return mProfileConnector.getService(); |
| } |
| |
| /** |
| * {@inheritDoc} |
| * @hide |
| */ |
| @SystemApi |
| @RequiresBluetoothConnectPermission |
| @RequiresPermission(allOf = { |
| android.Manifest.permission.BLUETOOTH_CONNECT, |
| android.Manifest.permission.BLUETOOTH_PRIVILEGED, |
| }) |
| @Override |
| @BluetoothProfile.BtProfileState |
| public int getConnectionState(@NonNull BluetoothDevice sink) { |
| log("getConnectionState(" + sink + ")"); |
| Objects.requireNonNull(sink, "sink cannot be null"); |
| final IBluetoothLeBroadcastAssistant service = getService(); |
| final int defaultValue = BluetoothProfile.STATE_DISCONNECTED; |
| if (service == null) { |
| Log.w(TAG, "Proxy not attached to service"); |
| if (DBG) log(Log.getStackTraceString(new Throwable())); |
| } else if (mBluetoothAdapter.isEnabled() && isValidDevice(sink)) { |
| try { |
| return service.getConnectionState(sink); |
| } catch (RemoteException e) { |
| Log.e(TAG, e.toString() + "\n" + Log.getStackTraceString(new Throwable())); |
| } |
| } |
| return defaultValue; |
| } |
| |
| /** |
| * {@inheritDoc} |
| * @hide |
| */ |
| @SystemApi |
| @RequiresBluetoothConnectPermission |
| @RequiresPermission(allOf = { |
| android.Manifest.permission.BLUETOOTH_CONNECT, |
| android.Manifest.permission.BLUETOOTH_PRIVILEGED, |
| }) |
| @Override |
| @NonNull |
| public List<BluetoothDevice> getDevicesMatchingConnectionStates(@NonNull int[] states) { |
| log("getDevicesMatchingConnectionStates()"); |
| Objects.requireNonNull(states, "states cannot be null"); |
| final IBluetoothLeBroadcastAssistant service = getService(); |
| final List<BluetoothDevice> defaultValue = new ArrayList<BluetoothDevice>(); |
| if (service == null) { |
| Log.w(TAG, "Proxy not attached to service"); |
| if (DBG) log(Log.getStackTraceString(new Throwable())); |
| } else if (mBluetoothAdapter.isEnabled()) { |
| try { |
| return service.getDevicesMatchingConnectionStates(states); |
| } catch (RemoteException e) { |
| Log.e(TAG, e.toString() + "\n" + Log.getStackTraceString(new Throwable())); |
| } |
| } |
| return defaultValue; |
| } |
| |
| /** |
| * {@inheritDoc} |
| * @hide |
| */ |
| @SystemApi |
| @RequiresBluetoothConnectPermission |
| @RequiresPermission(allOf = { |
| android.Manifest.permission.BLUETOOTH_CONNECT, |
| android.Manifest.permission.BLUETOOTH_PRIVILEGED, |
| }) |
| @Override |
| public @NonNull List<BluetoothDevice> getConnectedDevices() { |
| log("getConnectedDevices()"); |
| final IBluetoothLeBroadcastAssistant service = getService(); |
| final List<BluetoothDevice> defaultValue = new ArrayList<BluetoothDevice>(); |
| if (service == null) { |
| Log.w(TAG, "Proxy not attached to service"); |
| if (DBG) log(Log.getStackTraceString(new Throwable())); |
| } else if (mBluetoothAdapter.isEnabled()) { |
| try { |
| return service.getConnectedDevices(); |
| } catch (RemoteException e) { |
| Log.e(TAG, e.toString() + "\n" + Log.getStackTraceString(new Throwable())); |
| } |
| } |
| return defaultValue; |
| } |
| |
| /** |
| * 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 |
| * @throws NullPointerException if <var>device</var> is null |
| * @hide |
| */ |
| @SystemApi |
| @RequiresBluetoothConnectPermission |
| @RequiresPermission(allOf = { |
| android.Manifest.permission.BLUETOOTH_CONNECT, |
| android.Manifest.permission.BLUETOOTH_PRIVILEGED, |
| }) |
| public boolean setConnectionPolicy(@NonNull BluetoothDevice device, |
| @ConnectionPolicy int connectionPolicy) { |
| log("setConnectionPolicy()"); |
| Objects.requireNonNull(device, "device cannot be null"); |
| final IBluetoothLeBroadcastAssistant service = getService(); |
| final boolean defaultValue = false; |
| if (service == null) { |
| Log.w(TAG, "Proxy not attached to service"); |
| if (DBG) log(Log.getStackTraceString(new Throwable())); |
| } else if (mBluetoothAdapter.isEnabled() && isValidDevice(device) |
| && (connectionPolicy == BluetoothProfile.CONNECTION_POLICY_FORBIDDEN |
| || connectionPolicy == BluetoothProfile.CONNECTION_POLICY_ALLOWED)) { |
| try { |
| return service.setConnectionPolicy(device, connectionPolicy); |
| } catch (RemoteException e) { |
| Log.e(TAG, e.toString() + "\n" + Log.getStackTraceString(new Throwable())); |
| } |
| } |
| return defaultValue; |
| } |
| |
| /** |
| * 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 |
| * @throws NullPointerException if <var>device</var> is null |
| * @hide |
| */ |
| @SystemApi |
| @RequiresBluetoothConnectPermission |
| @RequiresPermission(allOf = { |
| android.Manifest.permission.BLUETOOTH_CONNECT, |
| android.Manifest.permission.BLUETOOTH_PRIVILEGED, |
| }) |
| public @ConnectionPolicy int getConnectionPolicy(@NonNull BluetoothDevice device) { |
| log("getConnectionPolicy()"); |
| Objects.requireNonNull(device, "device cannot be null"); |
| final IBluetoothLeBroadcastAssistant service = getService(); |
| final int defaultValue = BluetoothProfile.CONNECTION_POLICY_FORBIDDEN; |
| if (service == null) { |
| Log.w(TAG, "Proxy not attached to service"); |
| if (DBG) log(Log.getStackTraceString(new Throwable())); |
| } else if (mBluetoothAdapter.isEnabled() && isValidDevice(device)) { |
| try { |
| return service.getConnectionPolicy(device); |
| } catch (RemoteException e) { |
| Log.e(TAG, e.toString() + "\n" + Log.getStackTraceString(new Throwable())); |
| } |
| } |
| return defaultValue; |
| } |
| |
| /** |
| * Register a {@link Callback} that will be invoked during the operation of this profile. |
| * |
| * Repeated registration of the same <var>callback</var> object after the first call to this |
| * method will result with IllegalArgumentException being thrown, even when the |
| * <var>executor</var> is different. API caller would have to call |
| * {@link #unregisterCallback(Callback)} with the same callback object before registering it |
| * again. |
| * |
| * @param executor an {@link Executor} to execute given callback |
| * @param callback user implementation of the {@link Callback} |
| * @throws NullPointerException if a null executor, or callback is given |
| * @throws IllegalArgumentException if the same <var>callback<var> is already registered |
| * @hide |
| */ |
| @SystemApi |
| @RequiresBluetoothConnectPermission |
| @RequiresPermission(allOf = { |
| android.Manifest.permission.BLUETOOTH_CONNECT, |
| android.Manifest.permission.BLUETOOTH_PRIVILEGED, |
| }) |
| public void registerCallback(@NonNull @CallbackExecutor Executor executor, |
| @NonNull Callback callback) { |
| Objects.requireNonNull(executor, "executor cannot be null"); |
| Objects.requireNonNull(callback, "callback cannot be null"); |
| log("registerCallback"); |
| final IBluetoothLeBroadcastAssistant service = getService(); |
| if (service == null) { |
| Log.w(TAG, "Proxy not attached to service"); |
| if (DBG) log(Log.getStackTraceString(new Throwable())); |
| } else if (mBluetoothAdapter.isEnabled()) { |
| if (mCallback == null) { |
| mCallback = new BluetoothLeBroadcastAssistantCallback(service); |
| } |
| mCallback.register(executor, callback); |
| } |
| } |
| |
| /** |
| * Unregister the specified {@link Callback}. |
| * |
| * <p>The same {@link Callback} object used when calling |
| * {@link #registerCallback(Executor, Callback)} must be used. |
| * |
| * <p>Callbacks are automatically unregistered when application process goes away. |
| * |
| * @param callback user implementation of the {@link Callback} |
| * @throws NullPointerException when callback is null |
| * @throws IllegalArgumentException when the <var>callback</var> was not registered before |
| * @hide |
| */ |
| @SystemApi |
| @RequiresBluetoothConnectPermission |
| @RequiresPermission(allOf = { |
| android.Manifest.permission.BLUETOOTH_CONNECT, |
| android.Manifest.permission.BLUETOOTH_PRIVILEGED, |
| }) |
| public void unregisterCallback(@NonNull Callback callback) { |
| Objects.requireNonNull(callback, "callback cannot be null"); |
| log("unregisterCallback"); |
| final IBluetoothLeBroadcastAssistant service = getService(); |
| if (service == null) { |
| Log.w(TAG, "Proxy not attached to service"); |
| if (DBG) log(Log.getStackTraceString(new Throwable())); |
| } else if (mBluetoothAdapter.isEnabled()) { |
| if (mCallback == null) { |
| throw new IllegalArgumentException("no callback was ever registered"); |
| } |
| mCallback.unregister(callback); |
| } |
| } |
| |
| /** |
| * Search for LE Audio Broadcast Sources on behalf of all devices connected via Broadcast Audio |
| * Scan Service, filtered by <var>filters</var>. |
| * |
| * On success, {@link Callback#onSearchStarted(int)} will be called with reason code |
| * {@link BluetoothStatusCodes#REASON_LOCAL_APP_REQUEST}. |
| * |
| * On failure, {@link Callback#onSearchStartFailed(int)} will be called with reason code |
| * |
| * The implementation will also synchronize with discovered Broadcast Sources and get their |
| * metadata before passing the Broadcast Source metadata back to the application using {@link |
| * Callback#onSourceFound(BluetoothLeBroadcastMetadata)}. |
| * |
| * Please disconnect the Broadcast Sink's BASS server by calling |
| * {@link #setConnectionPolicy(BluetoothDevice, int)} with |
| * {@link BluetoothProfile#CONNECTION_POLICY_FORBIDDEN} if you do not want the Broadcast Sink |
| * to receive notifications about this search before calling this method. |
| * |
| * App must also have |
| * {@link android.Manifest.permission#ACCESS_FINE_LOCATION ACCESS_FINE_LOCATION} |
| * permission in order to get results. |
| * |
| * <var>filters</var> will be AND'ed with internal filters in the implementation and |
| * {@link ScanSettings} will be managed by the implementation. |
| * |
| * @param filters {@link ScanFilter}s for finding exact Broadcast Source, if no filter is |
| * needed, please provide an empty list instead |
| * @throws NullPointerException when <var>filters</var> argument is null |
| * @throws IllegalStateException when no callback is registered |
| * @hide |
| */ |
| @SystemApi |
| @RequiresBluetoothScanPermission |
| @RequiresBluetoothLocationPermission |
| @RequiresPermission(allOf = { |
| android.Manifest.permission.BLUETOOTH_SCAN, |
| android.Manifest.permission.BLUETOOTH_PRIVILEGED, |
| }) |
| public void startSearchingForSources(@NonNull List<ScanFilter> filters) { |
| log("searchForBroadcastSources"); |
| Objects.requireNonNull(filters, "filters can be empty, but not null"); |
| if (mCallback == null) { |
| throw new IllegalStateException("No callback was ever registered"); |
| } |
| if (!mCallback.isAtLeastOneCallbackRegistered()) { |
| throw new IllegalStateException("All callbacks are unregistered"); |
| } |
| final IBluetoothLeBroadcastAssistant service = getService(); |
| if (service == null) { |
| Log.w(TAG, "Proxy not attached to service"); |
| if (DBG) log(Log.getStackTraceString(new Throwable())); |
| } else if (mBluetoothAdapter.isEnabled()) { |
| try { |
| service.startSearchingForSources(filters); |
| } catch (RemoteException e) { |
| Log.e(TAG, e.toString() + "\n" + Log.getStackTraceString(new Throwable())); |
| } |
| } |
| } |
| |
| /** |
| * Stops an ongoing search for nearby Broadcast Sources. |
| * |
| * On success, {@link Callback#onSearchStopped(int)} will be called with reason code |
| * {@link BluetoothStatusCodes#REASON_LOCAL_APP_REQUEST}. |
| * On failure, {@link Callback#onSearchStopFailed(int)} will be called with reason code |
| * |
| * @throws IllegalStateException if callback was not registered |
| * @hide |
| */ |
| @SystemApi |
| @RequiresBluetoothConnectPermission |
| @RequiresPermission(allOf = { |
| android.Manifest.permission.BLUETOOTH_CONNECT, |
| android.Manifest.permission.BLUETOOTH_PRIVILEGED, |
| }) |
| public void stopSearchingForSources() { |
| log("stopSearchingForSources:"); |
| if (mCallback == null) { |
| throw new IllegalStateException("No callback was ever registered"); |
| } |
| if (!mCallback.isAtLeastOneCallbackRegistered()) { |
| throw new IllegalStateException("All callbacks are unregistered"); |
| } |
| final IBluetoothLeBroadcastAssistant service = getService(); |
| if (service == null) { |
| Log.w(TAG, "Proxy not attached to service"); |
| if (DBG) log(Log.getStackTraceString(new Throwable())); |
| } else if (mBluetoothAdapter.isEnabled()) { |
| try { |
| service.stopSearchingForSources(); |
| } catch (RemoteException e) { |
| Log.e(TAG, e.toString() + "\n" + Log.getStackTraceString(new Throwable())); |
| } |
| } |
| } |
| |
| /** |
| * Return true if a search has been started by this application. |
| * |
| * @return true if a search has been started by this application |
| * @hide |
| */ |
| @SystemApi |
| @RequiresBluetoothConnectPermission |
| @RequiresPermission(allOf = { |
| android.Manifest.permission.BLUETOOTH_CONNECT, |
| android.Manifest.permission.BLUETOOTH_PRIVILEGED, |
| }) |
| public boolean isSearchInProgress() { |
| log("stopSearchingForSources:"); |
| final IBluetoothLeBroadcastAssistant service = getService(); |
| final boolean defaultValue = false; |
| if (service == null) { |
| Log.w(TAG, "Proxy not attached to service"); |
| if (DBG) log(Log.getStackTraceString(new Throwable())); |
| } else if (mBluetoothAdapter.isEnabled()) { |
| try { |
| return service.isSearchInProgress(); |
| } catch (RemoteException e) { |
| Log.e(TAG, e.toString() + "\n" + Log.getStackTraceString(new Throwable())); |
| } |
| } |
| return defaultValue; |
| } |
| |
| /** |
| * Add a Broadcast Source to the Broadcast Sink. |
| * |
| * Caller can modify <var>sourceMetadata</var> before using it in this method to set a |
| * Broadcast Code, to select a different Broadcast Channel in a Broadcast Source such as channel |
| * with a different language, and so on. What can be modified is listed in the documentation of |
| * {@link #modifySource(BluetoothDevice, int, BluetoothLeBroadcastMetadata)} and can also be |
| * modified after a source is added. |
| * |
| * On success, {@link Callback#onSourceAdded(BluetoothDevice, int, int)} will be invoked with |
| * a <var>sourceID</var> assigned by the Broadcast Sink with reason code |
| * {@link BluetoothStatusCodes#REASON_LOCAL_APP_REQUEST}. However, this callback only indicates |
| * that the Broadcast Sink has allocated resource to receive audio from the Broadcast Source, |
| * and audio stream may not have started. The caller should then wait for |
| * {@link Callback#onReceiveStateChanged(BluetoothDevice, int, |
| * BluetoothLeBroadcastReceiveState)} |
| * callback to monitor the encryption and audio sync state. |
| * |
| * Note that wrong broadcast code will not prevent the source from being added to the Broadcast |
| * Sink. Caller should modify the current source to correct the broadcast code. |
| * |
| * On failure, |
| * {@link Callback#onSourceAddFailed(BluetoothDevice, BluetoothLeBroadcastMetadata, int)} |
| * will be invoked with the same <var>source</var> metadata and reason code |
| * |
| * When too many sources was added to Broadcast sink, error |
| * {@link BluetoothStatusCodes#ERROR_REMOTE_NOT_ENOUGH_RESOURCES} will be delivered. In this |
| * case, check the capacity of Broadcast sink via |
| * {@link #getMaximumSourceCapacity(BluetoothDevice)} and the current list of sources via |
| * {@link #getAllSources(BluetoothDevice)}. |
| * |
| * Some sources might be added by other Broadcast Assistants and hence was not |
| * in {@link Callback#onSourceAdded(BluetoothDevice, int, int)} callback, but will be updated |
| * via {@link Callback#onReceiveStateChanged(BluetoothDevice, int, |
| * BluetoothLeBroadcastReceiveState)} |
| * |
| * <p>If there are multiple members in the coordinated set the sink belongs to, and isGroupOp is |
| * set to true, the Broadcast Source will be added to each sink in the coordinated set and a |
| * separate {@link Callback#onSourceAdded} callback will be invoked for each member of the |
| * coordinated set. |
| * |
| * <p>The <var>isGroupOp</var> option is sticky. This means that subsequent operations using |
| * {@link #modifySource(BluetoothDevice, int, BluetoothLeBroadcastMetadata)} and |
| * {@link #removeSource(BluetoothDevice, int)} will act on all devices in the same coordinated |
| * set for the <var>sink</var> and <var>sourceID</var> pair until the <var>sourceId</var> is |
| * removed from the <var>sink</var> by any Broadcast role (could be another remote device). |
| * |
| * <p>When <var>isGroupOp</var> is true, if one Broadcast Sink in a coordinated set |
| * disconnects from this Broadcast Assistant or lost the Broadcast Source, this Broadcast |
| * Assistant will try to add it back automatically to make sure the whole coordinated set |
| * is in the same state. |
| * |
| * @param sink Broadcast Sink to which the Broadcast Source should be added |
| * @param sourceMetadata Broadcast Source metadata to be added to the Broadcast Sink |
| * @param isGroupOp {@code true} if Application wants to perform this operation for all |
| * coordinated set members throughout this session. Otherwise, caller |
| * would have to add, modify, and remove individual set members. |
| * @throws NullPointerException if <var>sink</var> or <var>source</var> is null |
| * @throws IllegalStateException if callback was not registered |
| * @hide |
| */ |
| @SystemApi |
| @RequiresBluetoothConnectPermission |
| @RequiresPermission(allOf = { |
| android.Manifest.permission.BLUETOOTH_CONNECT, |
| android.Manifest.permission.BLUETOOTH_PRIVILEGED, |
| }) |
| public void addSource(@NonNull BluetoothDevice sink, |
| @NonNull BluetoothLeBroadcastMetadata sourceMetadata, boolean isGroupOp) { |
| log("addBroadcastSource: " + sourceMetadata + " on " + sink); |
| Objects.requireNonNull(sink, "sink cannot be null"); |
| Objects.requireNonNull(sourceMetadata, "sourceMetadata cannot be null"); |
| if (mCallback == null) { |
| throw new IllegalStateException("No callback was ever registered"); |
| } |
| if (!mCallback.isAtLeastOneCallbackRegistered()) { |
| throw new IllegalStateException("All callbacks are unregistered"); |
| } |
| final IBluetoothLeBroadcastAssistant service = getService(); |
| if (service == null) { |
| Log.w(TAG, "Proxy not attached to service"); |
| if (DBG) log(Log.getStackTraceString(new Throwable())); |
| } else if (mBluetoothAdapter.isEnabled() && isValidDevice(sink)) { |
| try { |
| service.addSource(sink, sourceMetadata, isGroupOp); |
| } catch (RemoteException e) { |
| Log.e(TAG, e.toString() + "\n" + Log.getStackTraceString(new Throwable())); |
| } |
| } |
| } |
| |
| /** |
| * Modify the Broadcast Source information on a Broadcast Sink. |
| * |
| * One can modify {@link BluetoothLeBroadcastMetadata#getBroadcastCode()} if |
| * {@link BluetoothLeBroadcastReceiveState#getBigEncryptionState()} returns |
| * {@link BluetoothLeBroadcastReceiveState#BIG_ENCRYPTION_STATE_BAD_CODE} or |
| * {@link BluetoothLeBroadcastReceiveState#BIG_ENCRYPTION_STATE_CODE_REQUIRED} |
| * |
| * One can modify {@link BluetoothLeBroadcastMetadata#getPaSyncInterval()} if the Broadcast |
| * Assistant received updated information. |
| * |
| * One can modify {@link BluetoothLeBroadcastChannel#isSelected()} to select different broadcast |
| * channel to listen to (one per {@link BluetoothLeBroadcastSubgroup} or set |
| * {@link BluetoothLeBroadcastSubgroup#isNoChannelPreference()} to leave the choice to the |
| * Broadcast Sink. |
| * |
| * One can modify {@link BluetoothLeBroadcastSubgroup#getContentMetadata()} if the subgroup |
| * metadata changes and the Broadcast Sink need help updating the metadata from Broadcast |
| * Assistant. |
| * |
| * Each of the above modifications can be accepted or rejected by the Broadcast Assistant |
| * implement and/or the Broadcast Sink. |
| * |
| * <p>On success, {@link Callback#onSourceModified(BluetoothDevice, int, int)} will be invoked |
| * with reason code {@link BluetoothStatusCodes#REASON_LOCAL_APP_REQUEST}. |
| * |
| * <p>On failure, {@link Callback#onSourceModifyFailed(BluetoothDevice, int, int)} will be |
| * invoked with reason code. |
| * |
| * <p>If there are multiple members in the coordinated set the sink belongs to, and isGroupOp |
| * is set to true during |
| * {@link #addSource(BluetoothDevice, BluetoothLeBroadcastMetadata, boolean)}, |
| * the source will be modified on each sink in the coordinated set and a separate |
| * {@link Callback#onSourceModified(BluetoothDevice, int, int)} callback will be invoked for |
| * each member of the coordinated set. |
| * |
| * @param sink Broadcast Sink to which the Broadcast Source should be updated |
| * @param sourceId source ID as delivered in |
| * {@link Callback#onSourceAdded(BluetoothDevice, int, int)} |
| * @param updatedMetadata updated Broadcast Source metadata to be updated on the Broadcast Sink |
| * @throws IllegalStateException if callback was not registered |
| * @throws NullPointerException if <var>sink</var> or <var>updatedMetadata</var> is null |
| * @hide |
| */ |
| @SystemApi |
| @RequiresBluetoothConnectPermission |
| @RequiresPermission(allOf = { |
| android.Manifest.permission.BLUETOOTH_CONNECT, |
| android.Manifest.permission.BLUETOOTH_PRIVILEGED, |
| }) |
| public void modifySource(@NonNull BluetoothDevice sink, int sourceId, |
| @NonNull BluetoothLeBroadcastMetadata updatedMetadata) { |
| log("updateBroadcastSource: " + updatedMetadata + " on " + sink); |
| Objects.requireNonNull(sink, "sink cannot be null"); |
| Objects.requireNonNull(updatedMetadata, "updatedMetadata cannot be null"); |
| if (mCallback == null) { |
| throw new IllegalStateException("No callback was ever registered"); |
| } |
| if (!mCallback.isAtLeastOneCallbackRegistered()) { |
| throw new IllegalStateException("All callbacks are unregistered"); |
| } |
| final IBluetoothLeBroadcastAssistant service = getService(); |
| if (service == null) { |
| Log.w(TAG, "Proxy not attached to service"); |
| if (DBG) log(Log.getStackTraceString(new Throwable())); |
| } else if (mBluetoothAdapter.isEnabled() && isValidDevice(sink)) { |
| try { |
| service.modifySource(sink, sourceId, updatedMetadata); |
| } catch (RemoteException e) { |
| Log.e(TAG, e.toString() + "\n" + Log.getStackTraceString(new Throwable())); |
| } |
| } |
| } |
| |
| /** |
| * Removes the Broadcast Source from a Broadcast Sink. |
| * |
| * <p>On success, {@link Callback#onSourceRemoved(BluetoothDevice, int, int)} will be invoked |
| * with reason code {@link BluetoothStatusCodes#REASON_LOCAL_APP_REQUEST}. |
| * |
| * <p>On failure, {@link Callback#onSourceRemoveFailed(BluetoothDevice, int, int)} will be |
| * invoked with reason code. |
| |
| * |
| * <p>If there are multiple members in the coordinated set the sink belongs to, and isGroupOp is |
| * set to true during |
| * {@link #addSource(BluetoothDevice, BluetoothLeBroadcastMetadata, boolean)}, |
| * the source will be removed from each sink in the coordinated set and a separate |
| * {@link Callback#onSourceRemoved(BluetoothDevice, int, int)} callback will be invoked for |
| * each member of the coordinated set. |
| * |
| * @param sink Broadcast Sink from which a Broadcast Source should be removed |
| * @param sourceId source ID as delivered in |
| * {@link Callback#onSourceAdded(BluetoothDevice, int, int)} |
| * @throws NullPointerException when the <var>sink</var> is null |
| * @throws IllegalStateException if callback was not registered |
| * @hide |
| */ |
| @SystemApi |
| @RequiresBluetoothConnectPermission |
| @RequiresPermission(allOf = { |
| android.Manifest.permission.BLUETOOTH_CONNECT, |
| android.Manifest.permission.BLUETOOTH_PRIVILEGED, |
| }) |
| public void removeSource(@NonNull BluetoothDevice sink, int sourceId) { |
| log("removeBroadcastSource: " + sourceId + " from " + sink); |
| Objects.requireNonNull(sink, "sink cannot be null"); |
| if (mCallback == null) { |
| throw new IllegalStateException("No callback was ever registered"); |
| } |
| if (!mCallback.isAtLeastOneCallbackRegistered()) { |
| throw new IllegalStateException("All callbacks are unregistered"); |
| } |
| final IBluetoothLeBroadcastAssistant service = getService(); |
| if (service == null) { |
| Log.w(TAG, "Proxy not attached to service"); |
| if (DBG) log(Log.getStackTraceString(new Throwable())); |
| } else if (mBluetoothAdapter.isEnabled() && isValidDevice(sink)) { |
| try { |
| service.removeSource(sink, sourceId); |
| } catch (RemoteException e) { |
| Log.e(TAG, e.toString() + "\n" + Log.getStackTraceString(new Throwable())); |
| } |
| } |
| } |
| |
| |
| /** |
| * Get information about all Broadcast Sources that a Broadcast Sink knows about. |
| * |
| * @param sink Broadcast Sink from which to get all Broadcast Sources |
| * @return the list of Broadcast Receive State {@link BluetoothLeBroadcastReceiveState} |
| * stored in the Broadcast Sink |
| * @throws NullPointerException when <var>sink</var> is null |
| * @hide |
| */ |
| @SystemApi |
| @RequiresBluetoothConnectPermission |
| @RequiresPermission(allOf = { |
| android.Manifest.permission.BLUETOOTH_CONNECT, |
| android.Manifest.permission.BLUETOOTH_PRIVILEGED, |
| }) |
| @NonNull |
| public List<BluetoothLeBroadcastReceiveState> getAllSources(@NonNull BluetoothDevice sink) { |
| log("getAllSources()"); |
| Objects.requireNonNull(sink, "sink cannot be null"); |
| final IBluetoothLeBroadcastAssistant service = getService(); |
| final List<BluetoothLeBroadcastReceiveState> defaultValue = |
| new ArrayList<BluetoothLeBroadcastReceiveState>(); |
| if (service == null) { |
| Log.w(TAG, "Proxy not attached to service"); |
| if (DBG) log(Log.getStackTraceString(new Throwable())); |
| } else if (mBluetoothAdapter.isEnabled()) { |
| try { |
| return service.getAllSources(sink); |
| } catch (RemoteException e) { |
| Log.e(TAG, e.toString() + "\n" + Log.getStackTraceString(new Throwable())); |
| } |
| } |
| return defaultValue; |
| } |
| |
| /** |
| * Get maximum number of sources that can be added to this Broadcast Sink. |
| * |
| * @param sink Broadcast Sink device |
| * @return maximum number of sources that can be added to this Broadcast Sink |
| * @throws NullPointerException when <var>sink</var> is null |
| * @hide |
| */ |
| @SystemApi |
| public int getMaximumSourceCapacity(@NonNull BluetoothDevice sink) { |
| Objects.requireNonNull(sink, "sink cannot be null"); |
| final IBluetoothLeBroadcastAssistant service = getService(); |
| final int defaultValue = 0; |
| if (service == null) { |
| Log.w(TAG, "Proxy not attached to service"); |
| if (DBG) log(Log.getStackTraceString(new Throwable())); |
| } else if (mBluetoothAdapter.isEnabled() && isValidDevice(sink)) { |
| try { |
| return service.getMaximumSourceCapacity(sink); |
| } catch (RemoteException e) { |
| Log.e(TAG, e.toString() + "\n" + Log.getStackTraceString(new Throwable())); |
| } |
| } |
| return defaultValue; |
| } |
| |
| private static void log(@NonNull String msg) { |
| if (DBG) { |
| Log.d(TAG, msg); |
| } |
| } |
| |
| private static boolean isValidDevice(@Nullable BluetoothDevice device) { |
| return device != null && BluetoothAdapter |
| .checkBluetoothAddress(device.getAddress()); |
| } |
| } |
