| /****************************************************************************** |
| * |
| * 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.Manifest; |
| import android.annotation.NonNull; |
| import android.annotation.Nullable; |
| import android.annotation.RequiresPermission; |
| import android.annotation.SdkConstant; |
| import android.annotation.SystemApi; |
| import android.annotation.IntDef; |
| import android.annotation.SdkConstant.SdkConstantType; |
| import java.lang.annotation.RetentionPolicy; |
| import java.lang.annotation.Retention; |
| import android.bluetooth.BluetoothAdapter; |
| import android.bluetooth.BluetoothDevice; |
| import android.bluetooth.IBluetoothGatt; |
| import android.bluetooth.IBluetoothManager; |
| import android.bluetooth.BluetoothProfile; |
| import android.bluetooth.BluetoothAdapter.LeScanCallback; |
| import android.os.Binder; |
| import android.os.IBinder; |
| import android.os.Handler; |
| import android.os.Looper; |
| import android.os.RemoteException; |
| import java.io.InvalidClassException; |
| import android.os.DeadObjectException; |
| import android.util.Log; |
| import android.content.Context; |
| import java.util.UUID; |
| import android.os.ParcelUuid; |
| |
| import java.util.IdentityHashMap; |
| import java.util.Map; |
| import java.util.ArrayList; |
| import java.util.List; |
| import java.util.HashMap; |
| import java.util.Objects; |
| |
| import android.bluetooth.le.ScanResult; |
| import android.bluetooth.le.ScanSettings; |
| import android.bluetooth.le.ScanFilter; |
| import android.bluetooth.le.ScanCallback; |
| import android.bluetooth.le.ScanRecord; |
| import android.bluetooth.le.BluetoothLeScanner; |
| import android.bluetooth.BleBroadcastAudioScanAssistManager; |
| |
| import android.os.SystemProperties; |
| |
| /** |
| * This class provides methods to perform Broadcast Assistance related |
| * operations. |
| * <p> |
| * Use {@link BleBroadcastAudioScanAssistManager()} to get an |
| * instance of {@link BleBroadcastAudioScanAssistManager}. |
| * <p> |
| * <b>Note:</b> Most of the methods here require |
| * {@link android.Manifest.permission#BLUETOOTH_ADMIN} permission. |
| * |
| * @hide |
| */ |
| public final class BleBroadcastAudioScanAssistManager { |
| |
| private static final String TAG = "BleBroadcastAudioScanAssistManager"; |
| private static final boolean DBG = true; |
| private static final boolean VDBG = true; |
| |
| /** @hide */ |
| @IntDef(prefix = "SYNC_", value = { |
| SYNC_METADATA, |
| SYNC_AUDIO, |
| SYNC_METADATA_AUDIO |
| }) |
| @Retention(RetentionPolicy.SOURCE) |
| public @interface BroadcastAssistSyncState {} |
| /** |
| * Input to {@link BleBroadcastAudioScanAssistManager#addBroadcastSource} method |
| * where Application wants to synchronize only to Metadata (i.e. Only Periodic advs) and not to |
| * Broadcsat audio stream (i.e. BIS )from broadcast source |
| */ |
| public static final int SYNC_METADATA = 0; |
| /** |
| * Input to {@link BleBroadcastAudioScanAssistManager#addBroadcastSource} method |
| * where Application wants to synchronize only to Broadcast Audio stream (i.e. BIS) and not to |
| Metadata (i.e. Periodic advs )from broadcast source |
| */ |
| public static final int SYNC_AUDIO = 1; |
| /** |
| * Input to {@link BleBroadcastAudioScanAssistManager#addBroadcastSource} method |
| * where Application wants to synchronize to both Broadcast Audio stream (i.e. BIS) and also to |
| * Metadata (i.e. Periodic advs )from broadcast source |
| */ |
| public static final int SYNC_METADATA_AUDIO = 2; |
| |
| private BluetoothAdapter mBluetoothAdapter; |
| BleBroadcastAudioScanAssistCallback mAppCallback; |
| BluetoothDevice mBluetoothDevice; |
| int mSyncState = SYNC_METADATA; |
| BluetoothSyncHelper mBluetoothSyncHelper = null; |
| BleBroadcastSourceInfo mBroadcastAudioSourceInfo = null; |
| private byte INVALID_SOURCE_ID = -1; |
| |
| /** |
| * Intent used to broadcast the "Broadcast receiver State" information of a Scan delegator device. |
| * Whenever there is a change in Broadcast source Information stored at Scan delegator device |
| * this Itent will be delivered to Application layer |
| * |
| * {@link #BluetoothSyncHelper} profile need to be connected to the Scan delegator device |
| * to get these notifications |
| * |
| * <p>This intent will have two extra: |
| * <ul> |
| * <li> {@link BluetoothDevice#EXTRA_DEVICE} - The remote device for which broadcast reciver |
| * state information is broadcasted. It can |
| * be null if no device is active. </li> |
| * </ul> |
| * <ul> |
| * <li> {@link BleBroadcastSourceInfo#EXTRA_SOURCE_INFO} - The BleBroadcastSourceInfo Object |
| * having information Broadcast receiver state </li> |
| * </ul> |
| * <ul> |
| * <li> {@link BleBroadcastSourceInfo#EXTRA_SOURCE_INFO_INDEX} - Index of the BleBroadcastSourceInfo |
| * object broadcasted </li> |
| * </ul> |
| * <ul> |
| * <li> {@link BleBroadcastSourceInfo#EXTRA_MAX_NUM_SOURCE_INFOS} - Maximum number of source Informations |
| * that this Broadcast receiver can hold </li> |
| * </ul> |
| * |
| * <p>Requires {@link android.Manifest.permission#BLUETOOTH} permission to |
| * receive. |
| * |
| * @hide |
| */ |
| @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION) |
| public static final String ACTION_BROADCAST_SOURCE_INFO = |
| "android.bluetooth.BroadcastAudioSAManager.action.BROADCAST_SOURCE_INFO"; |
| |
| |
| // These callbacks run on the main thread. |
| private final class BassclientServiceListener |
| implements BluetoothProfile.ServiceListener { |
| |
| public void onServiceConnected(int profile, BluetoothProfile proxy) { |
| log(TAG, "BassService connected"); |
| onBluetoothSyncHelperStateChanged(true, proxy); |
| |
| } |
| |
| public void onServiceDisconnected(int profile) { |
| log(TAG, "BassService disconnected"); |
| onBluetoothSyncHelperStateChanged(false, null); |
| } |
| } |
| |
| private void onBluetoothSyncHelperStateChanged(boolean on, BluetoothProfile proxy) { |
| if (on) { |
| mBluetoothSyncHelper = (BluetoothSyncHelper) proxy; |
| mBluetoothSyncHelper.registerAppCallback(mBluetoothDevice, mAppCallback); |
| this.notifyAll(); |
| } else { |
| mBluetoothSyncHelper = null; |
| } |
| } |
| |
| /*package*/BleBroadcastAudioScanAssistManager(BluetoothSyncHelper scanOffloader, BluetoothDevice device, |
| BleBroadcastAudioScanAssistCallback callback |
| ) { |
| mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter(); |
| |
| mAppCallback = callback; |
| mBluetoothDevice = device; |
| mBluetoothSyncHelper = scanOffloader; |
| } |
| |
| |
| /*finalize method to cleanup*/ |
| protected void finalize() { |
| log(TAG, "finalize()"); |
| if (mBluetoothSyncHelper != null) { |
| mBluetoothSyncHelper.unregisterAppCallback(mBluetoothDevice, mAppCallback); |
| } |
| } |
| |
| /** |
| * Search for Le Audio Broadcasters on behalf of the Scan delegator with which this |
| * {@ BleBroadcastAudioScanAssistManager} is instantiated |
| * |
| * search results will be delivered to application using |
| * {@link BleBroadcastAudioScanAssistCallback#onBleBroadcastSourceFound} |
| * |
| * @return returns true if It is successfully initiated the Search for Audio broadcasters, |
| * false otherwise |
| * @hide |
| */ |
| public boolean searchforLeAudioBroadcasters () { |
| log(TAG, "searchforLeAudioBroadcasters: "); |
| if (mBluetoothSyncHelper != null) { |
| return mBluetoothSyncHelper.searchforLeAudioBroadcasters(mBluetoothDevice); |
| } else { |
| Log.e(TAG, "searchforLeAudioBroadcasters: mBluetoothSyncHelper is null"); |
| } |
| return false; |
| } |
| /** |
| * Stops an ongoing Bluetooth LE Search for Audio Broadcasters. |
| * |
| * @return returns true if It is successfully initiated the Stopped the Search for Audio broadcasters |
| * false otherwise |
| * |
| *@hide |
| */ |
| @RequiresPermission(Manifest.permission.BLUETOOTH_ADMIN) |
| public boolean stopSearchforLeAudioBroadcasters() { |
| log(TAG, "stopSearchforLeAudioBroadcasters()"); |
| if (mBluetoothSyncHelper != null) { |
| return mBluetoothSyncHelper.stopSearchforLeAudioBroadcasters(mBluetoothDevice); |
| } else { |
| Log.e(TAG, "stopSearchforLeAudioBroadcasters: mBluetoothSyncHelper is null"); |
| } |
| return false; |
| |
| } |
| |
| /* Internal helper function to convert user input sync state to required internal |
| * format |
| */ |
| private int convertMetadataSyncState(int syncState) { |
| if (syncState == SYNC_METADATA_AUDIO || syncState == SYNC_METADATA) { |
| return BleBroadcastSourceInfo.BROADCAST_ASSIST_PA_SYNC_STATE_IN_SYNC; |
| } |
| return BleBroadcastSourceInfo.BROADCAST_ASSIST_PA_SYNC_STATE_IDLE; |
| } |
| |
| /* Internal helper function to convert user input sync state to required internal |
| * format |
| */ |
| private int convertAudioDataSyncState(int syncState) { |
| if (syncState == SYNC_METADATA_AUDIO || syncState == SYNC_AUDIO) { |
| return BleBroadcastSourceInfo.BROADCAST_ASSIST_AUDIO_SYNC_STATE_SYNCHRONIZED; |
| } else { |
| Log.e(TAG, "searchforLeAudioBroadcasters: mBluetoothSyncHelper is null"); |
| } |
| return BleBroadcastSourceInfo.BROADCAST_ASSIST_AUDIO_SYNC_STATE_NOT_SYNCHRONIZED; |
| } |
| |
| /** |
| * Selects broadcast source for the Scan delegator. This internally performs Periodic |
| * synchronization to the given Broadcast source device, upon acquision of Synchronization information, |
| * It will be notified with avaiable Broadcast source channels that can be synchronized in the remote |
| * device. |
| * Application should select set of Broadcast channels that need to be synchronized and follow up |
| * with a call to {@link #addBroadcastSource} operation |
| * |
| * Result of selction of Broadcast source will be delivered through |
| * {@link BleBroadcastAudioScanAssistCallback#OnBroadcastAudioSourceSelected} |
| * |
| * If this operation need to be performed over all the members of coordinated set members, isGroupOp |
| * will be set to true. Select broadcast source operation will be performed on behalf of |
| * all the Coordinated set devices |
| * |
| * |
| * @param ScanResult {@link #ScanResult} of the Broadcasting source, |
| * this is the result obtained from the {@link BleBroadcastAudioScanAssistCallback#onBleBroadcastSourceFound} |
| * @param isGroupOp set to true If Application wants to perform this operation for the whole |
| * coordinated set members |
| * |
| * @return returns true if It is successfully initiated select Broadcast source operation |
| * false otherwise |
| * @hide |
| */ |
| public boolean selectBroadcastSource(ScanResult scanRes, boolean isGroupOp) { |
| if (scanRes == null) { |
| Log.e(TAG, "selectBroadcastSource: Invalid scan res"); |
| return false; |
| } |
| log(TAG, "selectBroadcastSource: " + scanRes); |
| if (mBluetoothSyncHelper != null) { |
| return mBluetoothSyncHelper.selectBroadcastSource(mBluetoothDevice, scanRes, isGroupOp); |
| } else { |
| Log.e(TAG, "selectBroadcastSource: mBluetoothSyncHelper is null"); |
| } |
| return false; |
| } |
| |
| |
| private boolean isValidBroadcastSourceInfo(BleBroadcastSourceInfo srcInfo) { |
| boolean ret = true; |
| List<BleBroadcastSourceInfo> currentSourceInfos = |
| mBluetoothSyncHelper.getAllBroadcastSourceInformation(mBluetoothDevice); |
| if (currentSourceInfos == null) { |
| Log.e(TAG, "no source info details for remote"); |
| ret = false; |
| } else { |
| for (int i=0; i<currentSourceInfos.size(); i++) { |
| if (srcInfo.matches(currentSourceInfos.get(i))) { |
| ret = false; |
| break; |
| } |
| } |
| } |
| |
| log(TAG, "isValidBroadcastSourceInfo returns: " + ret); |
| return ret; |
| } |
| |
| private boolean isValidSourceId (byte sourceId) { |
| boolean retVal = false; |
| List<BleBroadcastSourceInfo> currentSourceInfos = |
| mBluetoothSyncHelper.getAllBroadcastSourceInformation(mBluetoothDevice); |
| if (currentSourceInfos == null) { |
| retVal = false; |
| } else { |
| for (int i=0; i<currentSourceInfos.size(); i++) { |
| if (currentSourceInfos.get(i).getSourceId() == sourceId) { |
| retVal = true; |
| break; |
| } |
| } |
| } |
| log(TAG, "isValidSourceId returns: " + retVal); |
| return retVal; |
| } |
| |
| private void printSelectedIndicies(List<BleBroadcastSourceChannel> selectedBISIndicies) { |
| if (selectedBISIndicies == null) { |
| log(TAG, "printSelectedIndicies : no selected indicies"); |
| return; |
| } |
| for (int i=0; i<selectedBISIndicies.size(); i++) { |
| log(TAG, selectedBISIndicies.get(i).getDescription() + ": " + selectedBISIndicies.get(i).getStatus()); |
| } |
| } |
| /** |
| * Adds a broadcast source information to the Scan delegator. This internally performs Periodic |
| * synchronization to the given Broadcast source device, upon acquision of Synchronization information, |
| * It will be written on to the "Scan delegators" Characteristics |
| * |
| * Result of addition of Broadcast source to the scan delegator will be delivered through |
| * {@link BleBroadcastAudioScanAssistCallback#onBleBroadcastAudioSourceAdded} |
| * |
| * Successful addition Broadcast source will be indicated through Broadcast reciver state information |
| * update intent through {@link #ACTION_BROADCAST_RECEIVER_STATE} intent |
| * |
| * |
| * If this operation need to be performed over all the members of coordinated set members, isGroupOp |
| * will be set to true. add broadcast source operation will be performed on behalf of |
| * all the Coordinated set devices |
| * |
| * Same Broadcast source Information will be written on to all the members of Coordinated set and |
| * PAST will be performed based on the request. |
| * |
| * In case of Group Operation, If there is any matching entry already present in any of coordinated set members, |
| * Add Broadcast source opeation will be failed and result will notified through |
| * {@link BleBroadcastAudioScanAssistCallback#onBleBroadcastAudioSourceAdded} |
| * |
| * @param audioSource {@link #BluetoothDevice} object selected as Source which need to be synchronized with |
| * @param ScanResult {@link #ScanResult} result obtained from the {@link BleBroadcastAudioScanAssistCallback#onBleBroadcastSourceFound} |
| * @param syncState can be one of {@link #SYNC_METADATA}, |
| * {@link #SYNC_METADATA_AUDIO} |
| * @param selectedBroadcastChannels is a List of Broadcast channels that need to be synchronized with the given broadcast audio source |
| * from Avaialble Broadcast indicies. |
| * Avaiable broadcast indicies are notified application using {@link BleBroadcastAudioScanAssistCallback#onBleBroadcastSourceSelected} |
| * BroadcastSourceChannel.mStatus set to be TRUE or FALSE based on the need of synchronization. |
| * |
| * |
| * null value of selectedBroadcastChannels resulting in syncing to all avaialble Broadcast channels. |
| * check {@link BleBroadcastSourceChannel} for more information |
| * @param isGroupOp set to true If Application wants to perform this operation for the whole |
| * coordinated set members, False otherwise |
| * |
| * @return returns true if It is successfully initiated add Broadcast source operation |
| * false otherwise |
| * @hide |
| */ |
| public boolean addBroadcastSource (BluetoothDevice audioSource, |
| @BroadcastAssistSyncState int syncState, |
| List<BleBroadcastSourceChannel> selectedBroadcastChannels, |
| boolean isGroupOp) { |
| if (mBluetoothSyncHelper == null) { |
| log(TAG, "addBroadcastSource: no BluetoothSyncHelper handle"); |
| return false; |
| } |
| |
| if (syncState != SYNC_METADATA && |
| syncState != SYNC_METADATA_AUDIO) { |
| log(TAG, "addBroadcastSource: Invalid syncState" + syncState); |
| return false; |
| } |
| printSelectedIndicies(selectedBroadcastChannels); |
| int metadataSyncState = -1; |
| int audioSyncState = -1; |
| mSyncState = syncState; |
| metadataSyncState = convertMetadataSyncState (mSyncState); |
| audioSyncState = convertAudioDataSyncState(mSyncState); |
| if (mBroadcastAudioSourceInfo == null) { |
| //all of these will be overriden at service layer later |
| mBroadcastAudioSourceInfo = new BleBroadcastSourceInfo( |
| audioSource, |
| (byte)0xBB, /*advSid*/ |
| BleBroadcastSourceInfo.BROADCAST_ASSIST_ADDRESS_TYPE_PUBLIC, |
| metadataSyncState, |
| audioSyncState, |
| selectedBroadcastChannels); |
| if (mBroadcastAudioSourceInfo == null) { |
| Log.e(TAG, "addBroadcastSource: mBroadcastAudioSourceInfo instantiated failure"); |
| return false; |
| } |
| } |
| if(isValidBroadcastSourceInfo(mBroadcastAudioSourceInfo)) { |
| mBluetoothSyncHelper.addBroadcastSource(mBluetoothDevice, |
| mBroadcastAudioSourceInfo, |
| isGroupOp |
| ); |
| } else { |
| log(TAG, "Similar source information already exists"); |
| return false; |
| } |
| return true; |
| } |
| /** |
| * Updates a broadcast source information in the Scan delegator. |
| * It will be written on to the Scan delegator's Characteristics |
| * |
| * Result of updating of Broadcast source to the scan delegator will be delivered through |
| * {@link BleBroadcastAudioScanAssistCallback#onBleBroadcastAudioSourceUpdated} |
| * |
| * However Successful updating of Broadcast source information will be indicated through Broadcast reciver state information |
| * update intent through {@link #ACTION_BROADCAST_RECEIVER_STATE} intent |
| * |
| * If this operation need to be performed over all the members of coordinated set members, isGroupOp |
| * will be set to true. Update broadcast source operation will be performed on behalf of |
| * all the Coordinated set devices |
| * |
| * Same Broadcast source Information change will be written on to all the members of Coordinated set and |
| * PAST will be performed based on the request from remote. |
| * |
| * In case of Group Operation, If there are no matching source Information present in any of coordinated set members, |
| * Update Broadcast source opeation will be failed and result will notified through |
| * {@link BleBroadcastAudioScanAssistCallback#onBleBroadcastAudioSourceUpdated} |
| * |
| * @param sourceId sourceId of the Broadcast Source information which need to be updated |
| * @param syncState can be one of {@link #SYNC_METADATA}, |
| * {@link #SYNC_AUDIO}, {@link #SYNC_METADATA_AUDIO} |
| * |
| * @param selectedBroadcastChannels is a List of Broadcast channels that need to be synchronized with the given broadcast audio source |
| * from Avaialble Broadcast indicies. |
| * Avaiable broadcast indicies are notified application using {@link BleBroadcastAudioScanAssistCallback#onBleBroadcastSourceSelected} |
| * BroadcastSourceChannel.mStatus set to be TRUE or FALSE based on the need of synchronization. |
| * |
| * null value of selectedBroadcastChannels resulting in syncing to all avaialble Broadcast channels. |
| * check {@link BleurceChannel} for more information |
| * @param isGroupOp set to true If Application wants to perform this operation for the whole |
| * coordinated set members, False otherwise |
| * |
| * @return returns true if It is successfully initiated update Broadcast source information |
| * operation |
| * false otherwise |
| * @hide |
| */ |
| public boolean updateBroadcastSource (byte sourceId, int syncState, |
| List<BleBroadcastSourceChannel> selectedBroadcastChannels, |
| boolean isGroupOp) { |
| if (mBluetoothSyncHelper == null) { |
| log(TAG, "updateBroadcastSource: no BluetoothSyncHelper handle"); |
| return false; |
| } |
| if (isValidSourceId(sourceId) == false) { |
| log(TAG, "updateBroadcastSource: Invalid source Id"); |
| return false; |
| } |
| int audioSyncState = -1; |
| int metadataSyncState = -1; |
| log(TAG, "updateBroadcastSource: sourceId" + sourceId + ", syncState:" + syncState); |
| |
| mSyncState = syncState; |
| metadataSyncState = convertMetadataSyncState (mSyncState); |
| audioSyncState = convertAudioDataSyncState(mSyncState); |
| |
| printSelectedIndicies(selectedBroadcastChannels); |
| |
| log(TAG, "updateBroadcastSource: audioSyncState:" + audioSyncState); |
| log(TAG, "updateBroadcastSource: metadataSyncState:" + metadataSyncState); |
| |
| BleBroadcastSourceInfo sourceInfo = new BleBroadcastSourceInfo(sourceId); |
| if (sourceInfo != null) { |
| sourceInfo.setMetadataSyncState(metadataSyncState); |
| sourceInfo.setAudioSyncState(audioSyncState); |
| sourceInfo.setSourceId(sourceId); |
| sourceInfo.setBroadcastChannelsSyncStatus(selectedBroadcastChannels); |
| } else { |
| Log.e(TAG, "updateBroadcastSource: sourceInfo not created"); |
| return false; |
| } |
| return mBluetoothSyncHelper.updateBroadcastSource(mBluetoothDevice, |
| sourceInfo, |
| isGroupOp); |
| } |
| /** |
| * Sets the Broadcast pin code to the Scan delegator so that It can decrypt |
| * the synchronized audio at the reciver side |
| * |
| * It will be written on to the Scan delegator's Characteristics. |
| * Result of Setting of Broadcast PIN code to the scan delegator will be delivered through |
| * {@link BleBroadcastAudioScanAssistCallback#onBroadcastPinUpdated} |
| * |
| * If this operation need to be performed over all the members of coordinated set members, isGroupOp |
| * will be set to true. set Broadcast PIN operation will be performed on all the Coordinated set devices |
| * |
| * Same Broadcast PIN code will be written on to all the members of Coordinated set and |
| * on the request from remote. |
| * |
| * In case of Group Operation, If there are no matching source Information(BD address, adv instance) |
| * present in any of coordinated set members, |
| * Set Broadcast PIN opeation will be failed and result will notified through |
| * {@link BleBroadcastAudioScanAssistCallback#onBroadcastPinUpdated} |
| * |
| * |
| * However, Successful updating of Broadcast PIN code will be indicated through Broadcast reciver state information |
| * update intent through {@link #ACTION_BROADCAST_RECEIVER_STATE} intent. |
| * |
| * @param sourceId sourceId of the Broadcast Source information which need to be updated |
| * @param broadcastCode is the String of maximum 16 characters in length |
| * @param isGroupOp set to true If Application wants to perform this operation for the whole |
| * coordinated set members, False otherwise |
| * |
| * @return returns true if It is successfully initiated set Broadcast code operation |
| * false otherwise |
| * @hide |
| */ |
| public boolean setBroadcastCode (byte sourceId, String broadcastCode, boolean isGroupOp) { |
| if (mBluetoothSyncHelper == null) { |
| log(TAG, "setBroadcastCode: no BluetoothSyncHelper handle"); |
| return false; |
| } |
| if (isValidSourceId(sourceId) == false) { |
| log(TAG, "setBroadcastCode: Invalid source Id"); |
| return false; |
| } |
| |
| log(TAG, "setBroadcastCode: " + "sourceId:" |
| + sourceId + "BroadcastCode:" + broadcastCode); |
| BleBroadcastSourceInfo sourceInfo = new BleBroadcastSourceInfo(sourceId); |
| if (sourceInfo != null) { |
| sourceInfo.setSourceId(sourceId); |
| sourceInfo.setBroadcastCode(broadcastCode); |
| } else { |
| Log.e(TAG, "setBroadcastCode: sourceInfo not created"); |
| return false; |
| } |
| return mBluetoothSyncHelper.setBroadcastCode(mBluetoothDevice, |
| sourceInfo, |
| isGroupOp); |
| } |
| /** |
| * Removes the Broadcast Source Information from the Scan delegator |
| * It will be written on to the "Scan delegators" Characteristics |
| * |
| * Result of removal of Broadcast source to the scan delegator will be delivered through |
| * {@link BleBroadcastAudioScanAssistCallback#OnBroadcastAudioSourRemoved} |
| * |
| * If this operation need to be performed over all the members of coordinated set members, isGroupOp |
| * will be set to true. remove broadcast operation will be performed on all the Coordinated set devices |
| * |
| * Remove Broadcast will be performed on to all the members of Coordinated set |
| * |
| * In case of Group Operation, If there are no matching source Information(BD address, adv instance) |
| * present in any of coordinated set members. |
| * |
| * Set Broadcast PIN opeation will be failed and result will notified through |
| * {@link BleBroadcastAudioScanAssistCallback#onBroadcastPinUpdated} |
| * Successful removal of Brocast source information will be indicated through |
| * Broadcast receiver state Information through |
| * {@link #ACTION_BROADCAST_RECEIVER_STATE} intent |
| * |
| * @param sourceId sourceId of the Broadcast Source information which need to be updated |
| * @param isGroupOp set to true If Application wants to perform this operation for the whole |
| * coordinated set members, False otherwise |
| * |
| * @return returns true if It is successfully initiated remove broadcast source operation |
| * false otherwise |
| * @hide |
| */ |
| public boolean removeBroadcastSource (byte sourceId, boolean isGroupOp) { |
| if (mBluetoothSyncHelper == null) { |
| log(TAG, "removeBroadcastSource: no BluetoothSyncHelper handle"); |
| return false; |
| } |
| if (isValidSourceId(sourceId) == false) { |
| log(TAG, "removeBroadcastSource: Invalid source Id"); |
| return false; |
| } |
| log(TAG, "removeBroadcastSource: sourceId" + sourceId); |
| |
| return mBluetoothSyncHelper.removeBroadcastSource(mBluetoothDevice, |
| sourceId, |
| isGroupOp); |
| } |
| /** |
| * Get all the Broadcast Source Information stored in remote Scan delegators |
| * |
| * @return returns the List of Broadcast Source Information {@link #BleBroadcastSourceInfo} stored in |
| * remote and its corresponding state or null in case if there are nothing |
| * |
| * @hide |
| */ |
| public List<BleBroadcastSourceInfo> getAllBroadcastSourceInformation () { |
| if (mBluetoothSyncHelper == null) { |
| log(TAG, "GetNumberOfAcceptableBroadcastSources: no BluetoothSyncHelper handle"); |
| return null; |
| } |
| return mBluetoothSyncHelper.getAllBroadcastSourceInformation(mBluetoothDevice); |
| } |
| |
| private static void log(String TAG, String msg) { |
| BleBroadcastSourceInfo.BASS_Debug(TAG, msg); |
| } |
| } |
