| /****************************************************************************** |
| * |
| * 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.bluetooth.BluetoothAdapter; |
| import android.bluetooth.BluetoothDevice; |
| import android.bluetooth.IBluetoothGatt; |
| import android.bluetooth.IBluetoothManager; |
| import java.lang.annotation.RetentionPolicy; |
| import java.lang.annotation.Retention; |
| import android.annotation.IntDef; |
| import android.compat.annotation.UnsupportedAppUsage; |
| |
| import android.os.Parcel; |
| import android.os.Parcelable; |
| import android.os.Handler; |
| import android.os.Looper; |
| import android.os.RemoteException; |
| import android.util.Log; |
| import java.util.Objects; |
| import android.util.Log; |
| import java.util.List; |
| import java.util.ArrayList; |
| import java.util.IdentityHashMap; |
| import java.util.Map; |
| import java.util.HashMap; |
| |
| /** |
| * This class provides methods to get various information of Broadcast |
| * source information stored in remote. Users can call get/set methods |
| * enquire the required information |
| * |
| * <p>This also acts as general data structure for updating the Broadcast |
| * source information |
| * This class is used to input the User provided data for below operations |
| * {@link BleBroadcastAudioScanAssistManager#addBroadcastSource}, |
| * {@link BleBroadcastAudioScanAssistManager#updateBroadcastSource} and |
| * {@link BleBroadcastAudioScanAssistManager#setBroadcastCode} |
| * |
| * <p>This is also used to pack all Broadcast source information as part of {@link #ACTION_BROADCAST_RECEIVER_STATE} |
| * Intent. User can retrive the {@link BleBroadcastSourceInfo} using {@link BleBroadcastSourceInfo#EXTRA_RECEIVER_STATE} |
| * extra field |
| * @hide |
| */ |
| public final class BleBroadcastSourceInfo implements Parcelable { |
| |
| private static final String TAG = "BleBroadcastSourceInfo"; |
| private static final boolean BASS_DBG = Log.isLoggable(TAG, Log.VERBOSE); |
| |
| /** @hide |
| * @deprecated |
| */ |
| @Deprecated |
| @IntDef(prefix = "BROADCAST_ASSIST_ADDRESS_TYPE_", value = { |
| BROADCAST_ASSIST_ADDRESS_TYPE_PUBLIC, |
| BROADCAST_ASSIST_ADDRESS_TYPE_RANDOM |
| }) |
| @Retention(RetentionPolicy.SOURCE) |
| public @interface BroadcastAssistAddressType {} |
| |
| /** |
| * Address Type of the LE Broadcast Audio Source Device |
| * Specifies whether LE Broadcast Audio Source device using public OR |
| * random address for the LE Audio broadcasts |
| * |
| * @deprecated |
| */ |
| @Deprecated |
| public static final int BROADCAST_ASSIST_ADDRESS_TYPE_PUBLIC = 0; |
| /** |
| * Address Type of the LE Broadcast Audio Source Device |
| * Specifies whether LE Broadcast Audio Source device using public OR |
| * random address for the LE Audio broadcasts |
| * |
| * @deprecated |
| */ |
| @Deprecated |
| public static final int BROADCAST_ASSIST_ADDRESS_TYPE_RANDOM = 1; |
| /** |
| * Address Type of the LE Broadcast Audio Source Device |
| * Specifies whether LE Broadcast Audio Source device using public PR |
| * random address for the LE Audio broadcasts |
| * |
| * @deprecated |
| */ |
| @Deprecated |
| public static final int BROADCAST_ASSIST_ADDRESS_TYPE_INVALID = 0xFFFF; |
| |
| /** @hide */ |
| @IntDef(prefix = "BROADCAST_ASSIST_PA_SYNC_STATE_", value = { |
| BROADCAST_ASSIST_PA_SYNC_STATE_IDLE, |
| BROADCAST_ASSIST_PA_SYNC_STATE_SYNCINFO_REQ, |
| BROADCAST_ASSIST_PA_SYNC_STATE_IN_SYNC, |
| BROADCAST_ASSIST_PA_SYNC_STATE_SYNC_FAIL, |
| BROADCAST_ASSIST_PA_SYNC_STATE_NO_PAST |
| }) |
| @Retention(RetentionPolicy.SOURCE) |
| public @interface BroadcastAssistMetadataSyncState {} |
| |
| /** |
| * Meta data Sync State |
| * Broadcast receiver sync state w.r.t PA. State IDLE specifies that broadcast |
| * receiver is not able to sync the Metada/PA |
| */ |
| public static final int BROADCAST_ASSIST_PA_SYNC_STATE_IDLE = 0; |
| /** |
| * Meta data Sync State |
| * Broadcast receiver sync state w.r.t PA. State SYNCINFO REQ specifies that broadcast |
| * receiver requesting for SYNCINFO from the Scan Offloader to synchronie |
| * to Metadata/PA |
| */ |
| public static final int BROADCAST_ASSIST_PA_SYNC_STATE_SYNCINFO_REQ = 1; |
| /** |
| * Meta data Sync State |
| * Broadcast receiver sync state w.r.t PA. State INSYNC specifies that broadcast |
| * receiver in sync with to Metadata/PA. |
| */ |
| public static final int BROADCAST_ASSIST_PA_SYNC_STATE_IN_SYNC = 2; |
| /** |
| * Meta data Sync State |
| * Broadcast receiver sync state w.r.t PA. State INSYNC specifies that broadcast |
| * receiver is failed to sync with Metadata/PA. |
| */ |
| public static final int BROADCAST_ASSIST_PA_SYNC_STATE_SYNC_FAIL = 3; |
| /** |
| * Meta data Sync State |
| * Broadcast receiver sync state w.r.t PA. State SYNC NOPAST denotes that broadcast |
| * receiver needs PAST procedure to sync with Metadata. |
| */ |
| public static final int BROADCAST_ASSIST_PA_SYNC_STATE_NO_PAST = 4; |
| /** |
| * Meta data Sync State |
| * Broadcast receiver sync state w.r.t PA. State SYNC NOPAST denotes that broadcast |
| * receiver needs PAST procedure to sync with Metadata. |
| */ |
| public static final int BROADCAST_ASSIST_PA_SYNC_STATE_INVALID = 0xFFFF; |
| |
| /** @hide */ |
| @IntDef(prefix = "BROADCAST_ASSIST_AUDIO_SYNC_STATE_", value = { |
| BROADCAST_ASSIST_AUDIO_SYNC_STATE_NOT_SYNCHRONIZED, |
| BROADCAST_ASSIST_AUDIO_SYNC_STATE_SYNCHRONIZED |
| }) |
| @Retention(RetentionPolicy.SOURCE) |
| public @interface BroadcastAssistAudioSyncState {} |
| |
| /** |
| * Broadcast Audio stream Sync State |
| * Broadcast receiver sync state w.r.t Broadcast Audio stream BIS. denotes |
| * receiver is not synchronized to LE Audio BIS |
| */ |
| public static final int BROADCAST_ASSIST_AUDIO_SYNC_STATE_NOT_SYNCHRONIZED = 0; |
| /** |
| * Broadcast Audio stream Sync State |
| * Broadcast receiver sync state w.r.t Broadcast Audio stream BIS. denotes |
| * receiver is not synchronized to LE Audio BIS |
| */ |
| public static final int BROADCAST_ASSIST_AUDIO_SYNC_STATE_SYNCHRONIZED = 1; |
| /** |
| * Broadcast Audio stream Sync State |
| * Broadcast receiver sync state w.r.t Broadcast Audio stream BIS. denotes |
| * receiver is not synchronized to LE Audio BIS |
| */ |
| public static final int BROADCAST_ASSIST_AUDIO_SYNC_STATE_INVALID = 0xFFFF; |
| |
| |
| /** @hide */ |
| @IntDef(prefix = "BROADCAST_ASSIST_ENC_STATE_", value = { |
| BROADCAST_ASSIST_ENC_STATE_UNENCRYPTED, |
| BROADCAST_ASSIST_ENC_STATE_PIN_NEEDED, |
| BROADCAST_ASSIST_ENC_STATE_DECRYPTING |
| }) |
| @Retention(RetentionPolicy.SOURCE) |
| public @interface BroadcastAssistEncryptionState {} |
| /** |
| * Encryption Status at the LE Audio broadcast receiver side |
| * UNENCRYPTED denoted that broadcast receiver is in sync with an uncrypted |
| * broadcasted audio |
| */ |
| public static final int BROADCAST_ASSIST_ENC_STATE_UNENCRYPTED = 0; |
| /** |
| * Encryption Status at the LE Audio broadcast receiver side |
| * PIN_NEEDED denote that the Broadcast receiver needs broadcast PIN |
| * to sync and listen to Broadcasted Audio |
| */ |
| public static final int BROADCAST_ASSIST_ENC_STATE_PIN_NEEDED = 1; |
| /** |
| * Encryption Status at the LE Audio broadcast receiver side |
| * state DECRYPTING denote that the Broadcast receiver is able to decrypt |
| * and listen to the Broadcasted Audio |
| */ |
| public static final int BROADCAST_ASSIST_ENC_STATE_DECRYPTING = 2; |
| /** |
| * Encryption Status at the LE Audio broadcast receiver side |
| * state BADCODE denote that the Broadcast receiver has got bad code |
| * and not able decrypt |
| * Incorrect code that Scan delegator tried to decrypt can be retrieved from |
| * |
| */ |
| public static final int BROADCAST_ASSIST_ENC_STATE_BADCODE = 3; |
| /** |
| * Encryption Status at the LE Audio broadcast receiver side |
| * state DECRYPTING denote that the Broadcast receiver is able to decrypt |
| * and listen to the Broadcasted Audio |
| */ |
| public static final int BROADCAST_ASSIST_ENC_STATE_INVALID = 0xFFFF; |
| |
| /* |
| * Invalid Broadcast source Information Id |
| */ |
| public static final byte BROADCAST_ASSIST_INVALID_SOURCE_ID = (byte)0x00; |
| /* |
| * Invalid Broadcaster Identifier of the given Broadcast Source |
| */ |
| public static final int BROADCASTER_ID_INVALID = 0xFFFF; |
| /** |
| * Used as an int extra field in {@link BleBroadcastAudioScanAssistManager#ACTION_BROADCAST_RECEIVER_STATE} |
| * intent notifys the Broadcast Source Information to Application layer |
| * |
| * <p> Source Info object can be extracted using this extra field at Application layer |
| * |
| * This is used to read the {@link BleBroadcastSourceInfo } parcelable object |
| * @hide |
| */ |
| public static final String EXTRA_SOURCE_INFO = "android.bluetooth.device.extra.SOURCE_INFO"; |
| /** |
| * Used as an int extra field in {@link BleBroadcastAudioScanAssistManager#ACTION_BROADCAST_RECEIVER_STATE} |
| * intent Broadcast Source Information to Application layer |
| * |
| * <p> Index of the Source Info object can be extracted using this extra field at Application layer |
| * |
| * This is used to read the {@link BleBroadcastSourceInfo } parcelable object |
| * @hide |
| */ |
| public static final String EXTRA_SOURCE_INFO_INDEX = "android.bluetooth.device.extra.SOURCE_INFO_INDEX"; |
| /** |
| * Used as an int extra field in {@link BleBroadcastAudioScanAssistManager#ACTION_BROADCAST_RECEIVER_STATE} |
| * intent notifys the Broadcast Source Information to Application layer |
| * |
| * <p> Maximm number of the Broadcast Source Information that given broadcast receiver can hold, can be extracted using |
| * this extra field at Application layer |
| * |
| * @hide |
| */ |
| public static final String EXTRA_MAX_NUM_SOURCE_INFOS = "android.bluetooth.device.extra.MAX_NUM_SOURCE_INFOS"; |
| private byte mSourceId; |
| private @BroadcastAssistAddressType int mSourceAddressType; |
| private BluetoothDevice mSourceDevice; |
| private byte mSourceAdvSid; |
| private int mBroadcasterId; |
| private @BroadcastAssistMetadataSyncState int mMetaDataSyncState; |
| private @BroadcastAssistAudioSyncState int mAudioSyncState; |
| private Map<Integer, Integer> mAudioBisIndexList = new HashMap <Integer, Integer>(); |
| private @BroadcastAssistEncryptionState int mEncyptionStatus; |
| private Map<Integer, byte[]> mMetadataList = new HashMap<Integer, byte[]>(); |
| private String mBroadcastCode; |
| private byte[] mBadBroadcastCode; |
| private byte mNumSubGroups; |
| private static final int BIS_NO_PREF = 0xFFFFFFFF; |
| private static final int BROADCAST_CODE_SIZE = 16; |
| |
| /** |
| * Constructor to create an Empty object of {@link BleBroadcastSourceInfo } with given source Id, |
| * which contains, Broadcast reciever state information for Broadcast Assistant Usecases. |
| * |
| * This is mainly used to represent the Empty Broadcast source entries |
| * |
| * @param sourceId Source Id for this broadcast source info object |
| * |
| * @deprecated |
| * @hide |
| */ |
| @Deprecated |
| public BleBroadcastSourceInfo (byte sourceId) { |
| mSourceId = sourceId; |
| mMetaDataSyncState = BROADCAST_ASSIST_PA_SYNC_STATE_INVALID; |
| mAudioSyncState = BROADCAST_ASSIST_AUDIO_SYNC_STATE_INVALID; |
| mSourceAddressType = BROADCAST_ASSIST_ADDRESS_TYPE_INVALID; |
| mSourceDevice = null; |
| mSourceAdvSid = (byte)0x00; |
| mEncyptionStatus = BROADCAST_ASSIST_ENC_STATE_INVALID; |
| mBroadcastCode = null; |
| mBadBroadcastCode = null; |
| mNumSubGroups = 0; |
| mBroadcasterId = BROADCASTER_ID_INVALID; |
| } |
| /** |
| * Constructor to create an object of {@link BleBroadcastSourceInfo } which contains |
| * Broadcast reciever state information for Broadcast Assistant Usecases. |
| * This is mainly used for input purpose of {@link BleBroadcastAudioScanAssistManager#addBroadcastSource} |
| * operation |
| * |
| * @param audioSource BluetoothDevice object whcih is selected as Broadcast source |
| * @param advSid advertising Sid of the Broadcast source device for which reciever synchronized with. |
| * @param addressType type of address. This can be be one of {@link #BROADCAST_ASSIST_ADDRESS_TYPE_PUBLIC} or |
| * {@link #BROADCAST_ASSIST_ADDRESS_TYPE_RANDOM} |
| * @param metadataSyncState sync status of metadata at the receiver side from this Broadcast source. This can |
| * be one of {@link #BROADCAST_ASSIST_PA_SYNC_STATE_IDLE}, {@link #BROADCAST_ASSIST_PA_SYNC_STATE_SYNCINFO_REQ}, |
| * {@link #BROADCAST_ASSIST_PA_SYNC_STATE_IN_SYNC}, |
| * {@link #BROADCAST_ASSIST_PA_SYNC_STATE_SYNC_FAIL} OR {@link #BROADCAST_ASSIST_PA_SYNC_STATE_SYNC_NO_PAST} |
| * @param audioSyncState Audio sync status of metadata at the receiver side from this broadcast source. This can be |
| * one of {@link #BROADCAST_ASSIST_AUDIO_SYNC_STATE_NOT_SYNCHRONIZED} OR |
| * {@link #BROADCAST_ASSIST_AUDIO_SYNC_STATE_SYNCHRONIZED} |
| * @param audioBisIndex Audio BIS index for what Broadcast reciever synchronized with |
| * @param metadataLength Length of the metadata field |
| * @prama metadata metadata information about the type Broadcast information being synchronized at receiver side |
| * |
| * |
| * @hide |
| */ |
| /*package*/ BleBroadcastSourceInfo (BluetoothDevice audioSource, |
| byte advSid, |
| @BroadcastAssistAddressType int addressType, |
| @BroadcastAssistMetadataSyncState int metadataSyncstate, |
| @BroadcastAssistAudioSyncState int audioSyncstate, |
| List<BleBroadcastSourceChannel> selectedBISIndicies |
| ) { |
| mMetaDataSyncState = metadataSyncstate; |
| mAudioSyncState = audioSyncstate; |
| mSourceAddressType = addressType; |
| mSourceDevice = audioSource; |
| mSourceAdvSid = advSid; |
| mBroadcasterId = BROADCASTER_ID_INVALID; |
| if (selectedBISIndicies == null) { |
| BASS_Debug(TAG, "selectedBISIndiciesList is null"); |
| } else { |
| for (int i=0; i<selectedBISIndicies.size(); i++) { |
| if (selectedBISIndicies.get(i).getStatus() == true) { |
| Integer audioBisIndex = 0; |
| int subGroupId = selectedBISIndicies.get(i).getSubGroupId(); |
| if (mAudioBisIndexList.containsKey(subGroupId)) { |
| audioBisIndex = mAudioBisIndexList.get(subGroupId); |
| } |
| audioBisIndex = audioBisIndex | (1<<selectedBISIndicies.get(i).getIndex()); |
| BASS_Debug(TAG, "index" + selectedBISIndicies.get(i).getIndex() + "is set"); |
| mAudioBisIndexList.put(subGroupId, audioBisIndex); |
| } |
| } |
| } |
| |
| //not valid info |
| mSourceId = BROADCAST_ASSIST_INVALID_SOURCE_ID; |
| mEncyptionStatus = BROADCAST_ASSIST_ENC_STATE_INVALID; |
| mBroadcastCode = null; |
| mBadBroadcastCode = null; |
| mNumSubGroups = 0; |
| } |
| |
| /** |
| * Constructor override to create an object of {@link BleBroadcastSourceInfo } which contains |
| * Broadcast reciever state information for Broadcast Assistant Usecases. |
| * |
| * This is mainly used for output purpose to create an object from the receiver state information |
| * read from the remote BASS server. This will be packed and broadcasted as an Intent using |
| * {@link #ACTION_BROADCAST_RECEIVER_STATE} |
| * |
| * @param audioSource BluetoothDevice object whcih is selected as Broadcast source |
| * @param sourceId Source Id for this broadcast source info object |
| * @param advSid advertising Sid of the Broadcast source device for which reciever synchronized with |
| * @param addressType type of address. This can be be one of {@link #BLE_ASSIST_ADDRESS_TYPE_PUBLIC} or |
| * {@link #BLE_ASSIST_ADDRESS_TYPE_RANDOM} |
| * @param metadataSyncState sync status of metadata at the receiver side from this Broadcast source. This can |
| * be one of {@link #BROADCAST_ASSIST_PA_SYNC_STATE_IDLE}, {@link #BROADCAST_ASSIST_PA_SYNC_STATE_SYNCINFO_REQ}, |
| * {@link #BROADCAST_ASSIST_PA_SYNC_STATE_IN_SYNC}, |
| * {@link #BROADCAST_ASSIST_PA_SYNC_STATE_SYNC_FAIL} OR {@link #BROADCAST_ASSIST_PA_SYNC_STATE_SYNC_NO_PAST} |
| * @param audioSyncState Audio sync status of metadata at the receiver side from this broadcast source. This can be |
| * one of {@link #BROADCAST_ASSIST_AUDIO_SYNC_STATE_NOT_SYNCHRONIZED} OR |
| * {@link #BROADCAST_ASSIST_AUDIO_SYNC_STATE_SYNCHRONIZED} |
| * @param encryptionStatus Encryotion state at Broadcast receiver. This can be one of {@link #BROADCAST_ASSIST_ENC_STATE_UNENCRYPTED}, |
| {@link #BROADCAST_ASSIST_ENC_STATE_PIN_NEEDED} OR {@link #BROADCAST_ASSIST_ENC_STATE_DECRYPTING} |
| * @param audioBisIndex Audio BIS index for what Broadcast reciever synchronized with |
| * @param metadataLength Length of the metadata field |
| * @prama metadata metadata information about the type Broadcast information being synchronized at receiver side |
| * |
| * |
| * @deprecated |
| * @hide |
| */ |
| @Deprecated |
| public BleBroadcastSourceInfo (BluetoothDevice audioSource, |
| byte sourceId, |
| byte advSid, |
| int broadcasterId, |
| @BroadcastAssistAddressType int addressType, |
| @BroadcastAssistMetadataSyncState int metadataSyncstate, |
| @BroadcastAssistEncryptionState int encryptionStatus, |
| byte[] badCode, |
| byte numSubGroups, |
| @BroadcastAssistAudioSyncState int audioSyncstate, |
| Map<Integer, List<BleBroadcastSourceChannel>> selectedBISIndiciesList, |
| Map<Integer, byte[]> metadataList |
| ) { |
| mSourceId = sourceId; |
| mSourceAddressType = addressType; |
| mSourceDevice = audioSource; |
| mSourceAdvSid = advSid; |
| mBroadcasterId = broadcasterId; |
| mMetaDataSyncState = metadataSyncstate; |
| mAudioSyncState = audioSyncstate; |
| mEncyptionStatus = encryptionStatus; |
| if (badCode != null) { |
| mBadBroadcastCode = new byte[BROADCAST_CODE_SIZE]; |
| System.arraycopy(badCode, 0, mBadBroadcastCode, 0, mBadBroadcastCode.length); |
| } |
| mNumSubGroups = numSubGroups; |
| int audioBisIndex = 0; |
| if (selectedBISIndiciesList != null) { |
| for (Map.Entry<Integer, List<BleBroadcastSourceChannel>> entry : selectedBISIndiciesList.entrySet()) { |
| List<BleBroadcastSourceChannel> selectedBISIndicies = entry.getValue(); |
| if (selectedBISIndicies == null) { |
| //do nothing |
| BASS_Debug(TAG, "selectedBISIndiciesList is null"); |
| } else { |
| for (int i=0; i<selectedBISIndicies.size(); i++) { |
| if (selectedBISIndicies.get(i).getStatus() == true) { |
| audioBisIndex = audioBisIndex | (1<<selectedBISIndicies.get(i).getIndex()); |
| BASS_Debug(TAG, "index" + selectedBISIndicies.get(i).getIndex() + "is set"); |
| } |
| } |
| } |
| BASS_Debug(TAG, "subGroupId:" + entry.getKey() + "audioBisIndex" + audioBisIndex); |
| mAudioBisIndexList.put(entry.getKey(), audioBisIndex); |
| } |
| } |
| if (metadataList != null) { |
| for (Map.Entry<Integer, byte[]> entry : metadataList.entrySet()) { |
| byte[] metadata = entry.getValue(); |
| if (metadata != null && metadata.length != 0) { |
| byte[] mD = new byte[metadata.length]; |
| System.arraycopy(metadata, 0, mD, 0, metadata.length); |
| } |
| mMetadataList.put(entry.getKey(), metadata); |
| } |
| } |
| } |
| |
| /** |
| * Constructor override to create an object of {@link BleBroadcastSourceInfo } which contains |
| * Broadcast reciever state information for Broadcast Assistant Usecases. |
| * |
| * This is mainly used for output purpose to create an object from the receiver state information |
| * read from the remote BASS server. This will be packed and broadcasted as an Intent using |
| * {@link #ACTION_BROADCAST_RECEIVER_STATE} |
| * |
| * @param audioSource BluetoothDevice object whcih is selected as Broadcast source |
| * @param advSid advertising Sid of the Broadcast source device for which reciever synchronized with |
| * @param addressType type of address. This can be be one of {@link #BLE_ASSIST_ADDRESS_TYPE_PUBLIC} or |
| * {@link #BLE_ASSIST_ADDRESS_TYPE_RANDOM} |
| * @param metadataSyncState sync status of metadata at the receiver side from this Broadcast source. This can |
| * be one of {@link #BROADCAST_ASSIST_PA_SYNC_STATE_IDLE}, {@link #BROADCAST_ASSIST_PA_SYNC_STATE_SYNCINFO_REQ}, |
| * {@link #BROADCAST_ASSIST_PA_SYNC_STATE_IN_SYNC}, |
| * {@link #BROADCAST_ASSIST_PA_SYNC_STATE_SYNC_FAIL} OR {@link #BROADCAST_ASSIST_PA_SYNC_STATE_SYNC_NO_PAST} |
| * @param audioSyncState Audio sync status of metadata at the receiver side from this broadcast source. This can be |
| * one of {@link #BROADCAST_ASSIST_AUDIO_SYNC_STATE_NOT_SYNCHRONIZED} OR |
| * {@link #BROADCAST_ASSIST_AUDIO_SYNC_STATE_SYNCHRONIZED} |
| * @param encryptionStatus Encryotion state at Broadcast receiver. This can be one of {@link #BROADCAST_ASSIST_ENC_STATE_UNENCRYPTED}, |
| * {@link #BROADCAST_ASSIST_ENC_STATE_PIN_NEEDED} OR {@link #BROADCAST_ASSIST_ENC_STATE_DECRYPTING} |
| * @param audioBisIndex Audio BIS index for what Broadcast reciever synchronized with |
| * @param metadataLength Length of the metadata field |
| * @prama metadata metadata information about the type Broadcast information being synchronized at receiver side |
| * @param broadcastCode Numeric Character String maximum of 16 characters in length, which serves as broadcast PIN code |
| * |
| * @hide |
| */ |
| /*package*/ BleBroadcastSourceInfo (BluetoothDevice device, |
| byte sourceId, |
| byte advSid, |
| @BroadcastAssistAddressType int addressType, |
| @BroadcastAssistMetadataSyncState int metadataSyncstate, |
| @BroadcastAssistAudioSyncState int audioSyncstate, |
| List<BleBroadcastSourceChannel> selectedBISIndicies, |
| @BroadcastAssistEncryptionState int encryptionStatus, |
| String broadcastCode) { |
| mSourceId = sourceId; |
| mMetaDataSyncState = metadataSyncstate; |
| mAudioSyncState = audioSyncstate; |
| mEncyptionStatus = encryptionStatus; |
| mSourceAddressType = addressType; |
| mSourceDevice = device; |
| mSourceAdvSid = advSid; |
| mBroadcasterId = BROADCASTER_ID_INVALID; |
| if (selectedBISIndicies == null) { |
| BASS_Debug(TAG, "selectedBISIndiciesList is null"); |
| } else { |
| for (int i=0; i<selectedBISIndicies.size(); i++) { |
| if (selectedBISIndicies.get(i).getStatus() == true) { |
| Integer audioBisIndex = 0; |
| int subGroupId = selectedBISIndicies.get(i).getSubGroupId(); |
| if (mAudioBisIndexList.containsKey(subGroupId)) { |
| audioBisIndex = mAudioBisIndexList.get(subGroupId); |
| } |
| audioBisIndex = audioBisIndex | (1<<selectedBISIndicies.get(i).getIndex()); |
| BASS_Debug(TAG, "index" + selectedBISIndicies.get(i).getIndex() + "is set"); |
| BASS_Debug(TAG, "audioBisIndex" + audioBisIndex); |
| mAudioBisIndexList.put(subGroupId, audioBisIndex); |
| } |
| } |
| |
| } |
| /*if (metadata != null && metadata.length != 0) { |
| mMetadata = new byte[metadata.length]; |
| System.arraycopy(metadata, 0, mMetadata, 0, metadata.length); |
| }*/ |
| mBroadcastCode = broadcastCode; |
| mBadBroadcastCode = null; |
| mNumSubGroups = 0; |
| } |
| |
| /*package*/ BleBroadcastSourceInfo (BluetoothDevice device, |
| byte sourceId, |
| byte advSid, |
| int broadcasterId, |
| @BroadcastAssistAddressType int addressType, |
| @BroadcastAssistMetadataSyncState int metadataSyncstate, |
| @BroadcastAssistAudioSyncState int audioSyncstate, |
| @BroadcastAssistEncryptionState int encryptionStatus, |
| String broadcastCode, |
| byte[] badCode, |
| byte numSubGroups, |
| Map<Integer, Integer> bisIndiciesList, |
| Map<Integer, byte[]> metadataList |
| ) { |
| mSourceId = sourceId; |
| mMetaDataSyncState = metadataSyncstate; |
| mAudioSyncState = audioSyncstate; |
| mEncyptionStatus = encryptionStatus; |
| mSourceAddressType = addressType; |
| mSourceDevice = device; |
| mSourceAdvSid = advSid; |
| mBroadcasterId = broadcasterId; |
| mBroadcastCode = broadcastCode; |
| if (badCode != null && badCode.length != 0) { |
| mBadBroadcastCode= new byte[badCode.length]; |
| System.arraycopy(badCode, 0, mBadBroadcastCode, 0, badCode.length); |
| } |
| mNumSubGroups = numSubGroups; |
| mAudioBisIndexList = new HashMap<Integer, Integer> (bisIndiciesList); |
| mMetadataList = new HashMap<Integer, byte[]> (metadataList); |
| } |
| |
| @Override |
| public boolean equals(Object o) { |
| if (o instanceof BleBroadcastSourceInfo) { |
| BleBroadcastSourceInfo other = (BleBroadcastSourceInfo) o; |
| BASS_Debug(TAG, "other>> " + o.toString()); |
| BASS_Debug(TAG, "local>> " + toString()); |
| return (other.mSourceId == mSourceId |
| && other.mMetaDataSyncState == mMetaDataSyncState |
| && other.mAudioSyncState == mAudioSyncState |
| && other.mSourceAddressType == mSourceAddressType |
| && other.mSourceDevice == mSourceDevice |
| && other.mSourceAdvSid == mSourceAdvSid |
| && other.mEncyptionStatus == mEncyptionStatus |
| && other.mBroadcastCode == mBroadcastCode |
| && other.mBroadcasterId == mBroadcasterId |
| ); |
| } |
| return false; |
| } |
| |
| public boolean isEmptyEntry() { |
| boolean ret = false; |
| if (mMetaDataSyncState == (int)BROADCAST_ASSIST_PA_SYNC_STATE_INVALID && |
| mAudioSyncState == (int)BROADCAST_ASSIST_AUDIO_SYNC_STATE_INVALID && |
| mSourceAddressType == (int)BROADCAST_ASSIST_ADDRESS_TYPE_INVALID && |
| mSourceDevice == null && |
| mSourceAdvSid == (byte)0 && |
| mEncyptionStatus == (int)BROADCAST_ASSIST_ENC_STATE_INVALID |
| ) { |
| ret = true; |
| } |
| BASS_Debug(TAG, "isEmptyEntry returns: " + ret); |
| return ret; |
| } |
| |
| public boolean matches(BleBroadcastSourceInfo srcInfo) { |
| boolean ret = false; |
| if (srcInfo == null) { |
| ret = false; |
| } else { |
| if (mSourceDevice == null) { |
| if (mSourceAdvSid == srcInfo.getAdvertisingSid() && |
| mSourceAddressType == srcInfo.getAdvAddressType()) { |
| ret = true; |
| } |
| } else { |
| if (mSourceDevice.equals(srcInfo.getSourceDevice()) && |
| mSourceAdvSid == srcInfo.getAdvertisingSid() && |
| mSourceAddressType == srcInfo.getAdvAddressType() && |
| mBroadcasterId == srcInfo.getBroadcasterId()) { |
| ret = true; |
| } |
| } |
| } |
| BASS_Debug(TAG, "matches returns: " + ret); |
| return ret; |
| } |
| |
| @Override |
| public int hashCode() { |
| return Objects.hash(mSourceId, mMetaDataSyncState, mAudioSyncState, |
| mSourceAddressType, mSourceDevice, mSourceAdvSid, |
| mEncyptionStatus, mBroadcastCode); |
| } |
| |
| @Override |
| public int describeContents() { |
| return 0; |
| } |
| @Override |
| public String toString() { |
| return "{BleBroadcastSourceInfo : mSourceId" + mSourceId |
| + " sourceDevice: " + mSourceDevice |
| + " addressType: " + mSourceAddressType |
| + " mSourceAdvSid:" + mSourceAdvSid |
| + " mMetaDataSyncState:" + mMetaDataSyncState |
| + " mAudioSyncState" + mAudioSyncState |
| + " mEncyptionStatus" + mEncyptionStatus |
| + " mBadBroadcastCode" + mBadBroadcastCode |
| + " mNumSubGroups" + mNumSubGroups |
| + " mBroadcastCode" + mBroadcastCode |
| + " mAudioBisIndexList" + mAudioBisIndexList |
| + " mMetadataList" + mMetadataList |
| + " mBroadcasterId" + mBroadcasterId |
| + "}"; |
| } |
| |
| /** |
| * Gets the Source Id of the BleBroadcastSourceInfo Object |
| * |
| * @return byte representing the Source Id of the Broadcast Source Info Object |
| * {@link #BROADCAST_ASSIST_INVALID_SOURCE_ID} in case if this field is not valid |
| * @hide |
| */ |
| public byte getSourceId () { |
| return mSourceId; |
| } |
| |
| /** |
| * Sets the Source Id of the BleBroadcastSourceInfo Object |
| * |
| * @param byte source Id for the BleBroadcastSourceInfo Object |
| * |
| * @hide |
| */ |
| public void setSourceId (byte sourceId) { |
| mSourceId = sourceId; |
| } |
| |
| /** |
| * Sets the Broadcast source device for the BleBroadcastSourceInfo Object |
| * |
| * @param BluetoothDevice which need to be set as Broadcast source device |
| * @hide |
| */ |
| public void setSourceDevice(BluetoothDevice sourceDevice) { |
| mSourceDevice = sourceDevice; |
| } |
| |
| /** |
| * Gets the Broadcast source Device object from the BleBroadcastSourceInfo Object |
| * |
| * @return BluetoothDevice object for Broadcast source device |
| * @hide |
| */ |
| public BluetoothDevice getSourceDevice () { |
| return mSourceDevice; |
| } |
| |
| /** |
| * Sets the address type of the Broadcast source advertisement for the BleBroadcastSourceInfo Object |
| * |
| * @param byte addressType, this can be one of {@link #BROADCAST_ASSIST_ADDRESS_TYPE_PUBLIC} OR {@link #BROADCAST_ASSIST_ADDRESS_TYPE_PUBLIC} |
| * @hide |
| */ |
| public void setAdvAddressType(int addressType) { |
| mSourceAddressType = addressType; |
| } |
| |
| /** |
| * Gets the address type of the Broadcast source advertisement for the BleBroadcastSourceInfo Object |
| * |
| * @return byte addressType, this can be one of {@link #BROADCAST_ASSIST_ADDRESS_TYPE_PUBLIC} OR {@link #BROADCAST_ASSIST_ADDRESS_TYPE_PUBLIC} |
| * @hide |
| * |
| * @deprecated |
| */ |
| @UnsupportedAppUsage |
| @Deprecated |
| public int getAdvAddressType () { |
| return mSourceAddressType; |
| } |
| |
| /** |
| * Sets the advertising Sid of the Broadcast source advertisement for the BleBroadcastSourceInfo Object |
| * |
| * @param byte advertising Sid value |
| * @hide |
| */ |
| public void setAdvertisingSid(byte advSid) { |
| mSourceAdvSid = advSid; |
| } |
| |
| /** |
| * Gets the advertising Sid of the Broadcast source advertisement for the BleBroadcastSourceInfo Object |
| * |
| * @return byte advertising Sid value |
| * @hide |
| */ |
| public byte getAdvertisingSid () { |
| return mSourceAdvSid; |
| } |
| |
| /** |
| * Gets the Broadcast Id of the Broadcast source of the BleBroadcastSourceInfo Object |
| * |
| * @return int broadcast source Identifier |
| * @hide |
| */ |
| public int getBroadcasterId () { |
| return mBroadcasterId; |
| } |
| |
| /** |
| * Sets the Metadata sync status at the Broadcast receiver side for the BleBroadcastSourceInfo Object |
| * |
| * @param BroadcastAssistMetadataSyncState representing the state of Meta data sync status. this can be one of |
| * {@link #BROADCAST_ASSIST_PA_SYNC_STATE_IDLE}, {@link #BROADCAST_ASSIST_PA_SYNC_STATE_SYNCINFO_REQ}, |
| * {@link #BROADCAST_ASSIST_PA_SYNC_STATE_IN_SYNC}, |
| * {@link #BROADCAST_ASSIST_PA_SYNC_STATE_SYNC_FAIL} OR {@link #BROADCAST_ASSIST_PA_SYNC_STATE_SYNC_NO_PAST} |
| * |
| * @hide |
| */ |
| /*package*/ void setMetadataSyncState(@BroadcastAssistMetadataSyncState int metadataSyncState) { |
| mMetaDataSyncState = metadataSyncState; |
| } |
| |
| /** |
| * Gets the Metadata sync status at the Broadcast receiver side from the BleBroadcastSourceInfo Object |
| * |
| * @return BroadcastAssistMetadataSyncState representing the state of Meta data sync status. this can be one of |
| * {@link #BROADCAST_ASSIST_PA_SYNC_STATE_IDLE}, {@link #BROADCAST_ASSIST_PA_SYNC_STATE_SYNCINFO_REQ}, |
| * {@link #BROADCAST_ASSIST_PA_SYNC_STATE_IN_SYNC}, |
| * {@link #BROADCAST_ASSIST_PA_SYNC_STATE_SYNC_FAIL} OR {@link #BROADCAST_ASSIST_PA_SYNC_STATE_SYNC_NO_PAST} |
| * |
| * @hide |
| */ |
| public @BroadcastAssistMetadataSyncState int getMetadataSyncState () { |
| return mMetaDataSyncState; |
| } |
| |
| /** |
| * Sets the Audio sync status at the Broadcast receiver side for the BleBroadcastSourceInfo Object |
| * |
| * @param BroadcastAssistAudioSyncState representing the state of Meta data sync status. this can be one of |
| * {@link #BROADCAST_ASSIST_AUDIO_SYNC_STATE_NOT_SYNCHRONIZED} OR |
| * {@link #BROADCAST_ASSIST_AUDIO_SYNC_STATE_SYNCHRONIZED} |
| * |
| * @hide |
| */ |
| /*package*/ void setAudioSyncState(@BroadcastAssistAudioSyncState int audioSyncState) { |
| mAudioSyncState = audioSyncState; |
| } |
| |
| /** |
| * Gets the Audio sync status at the Broadcast receiver side from the BleBroadcastSourceInfo Object |
| * |
| * @return BroadcastAssistAudioSyncState representing the state of Meta data sync status. this can be one of |
| * {@link #BROADCAST_ASSIST_AUDIO_SYNC_STATE_NOT_SYNCHRONIZED} OR |
| * {@link #BROADCAST_ASSIST_AUDIO_SYNC_STATE_SYNCHRONIZED} * |
| * @hide |
| */ |
| public @BroadcastAssistAudioSyncState int getAudioSyncState () { |
| return mAudioSyncState; |
| } |
| |
| /** |
| * Sets the Encryption status at the Broadcast receiver side for the BleBroadcastSourceInfo Object |
| * |
| * @param BroadcastAssistEncryptionState representing the state of Meta data sync status. This can be one of |
| * {@link #BROADCAST_ASSIST_ENC_STATE_UNENCRYPTED}, |
| * {@link #BROADCAST_ASSIST_ENC_STATE_PIN_NEEDED}, {@link #BROADCAST_ASSIST_ENC_STATE_DECRYPTING} |
| * Or {@link #BROADCAST_ASSIST_ENC_STATE_BADCODE} |
| * @hide |
| */ |
| /*package*/ void setEncryptionStatus(@BroadcastAssistEncryptionState int encryptionStatus) { |
| mEncyptionStatus = encryptionStatus; |
| } |
| |
| /** |
| * Gets the Audio sync status at the Broadcast receiver side from the BleBroadcastSourceInfo Object |
| * |
| * @return BroadcastAssistEncryptionState representing the state of Meta data sync status. This can be one of |
| * {@link #BROADCAST_ASSIST_ENC_STATE_UNENCRYPTED}, |
| * {@link #BROADCAST_ASSIST_ENC_STATE_PIN_NEEDED} ,{@link #BROADCAST_ASSIST_ENC_STATE_DECRYPTING} |
| * Or {@link #BROADCAST_ASSIST_ENC_STATE_BADCODE} |
| * @hide |
| */ |
| public @BroadcastAssistEncryptionState int getEncryptionStatus () { |
| return mEncyptionStatus; |
| } |
| |
| /** |
| * Gets the Incorrect Broadcast code with which Scan delegator try |
| * decrypt the Broadcast audio and failed |
| * |
| * This code is valid only if {@link #getEncryptionStatus} returns |
| * {@link #BROADCAST_ASSIST_ENC_STATE_BADCODE} |
| * |
| * @param byte[] byte array containing bad broadcast value |
| * null if the current Encryptetion status is |
| * not {@link #BROADCAST_ASSIST_ENC_STATE_BADCODE} |
| * |
| * @hide |
| */ |
| public byte[] getBadBroadcastCode () { |
| return mBadBroadcastCode; |
| } |
| |
| /** |
| * Gets the number of subgroups of the BleBroadcastSourceInfo Object |
| * |
| * @return byte number of subgroups |
| * @hide |
| * |
| * @deprecated |
| */ |
| @UnsupportedAppUsage |
| @Deprecated |
| public byte getNumberOfSubGroups () { |
| return mNumSubGroups; |
| } |
| |
| /** |
| * Sets the Audio Broadcast channels to which receiver need to be synchronized with, |
| * for BleBroadcastSourceInfo Object |
| * |
| * |
| * @param int audioBis Index to which reciever need to be synchronized with |
| * @hide |
| */ |
| /*package*/ void setBroadcastChannelsSyncStatus(List<BleBroadcastSourceChannel> selectedBISIndicies) { |
| if (selectedBISIndicies == null) { |
| //set No preference |
| BASS_Debug(TAG, "selectedBISIndiciesList is null"); |
| return; |
| } |
| for (int i=0; i<selectedBISIndicies.size(); i++) { |
| if (selectedBISIndicies.get(i).getStatus() == true) { |
| Integer audioBisIndex = 0; |
| int subGroupId = selectedBISIndicies.get(i).getSubGroupId(); |
| if (mAudioBisIndexList.containsKey(subGroupId)) { |
| audioBisIndex = mAudioBisIndexList.get(subGroupId); |
| } |
| audioBisIndex = audioBisIndex | (1<<selectedBISIndicies.get(i).getIndex()); |
| BASS_Debug(TAG, "index" + selectedBISIndicies.get(i).getIndex() + "is set"); |
| mAudioBisIndexList.put(subGroupId, audioBisIndex); |
| } |
| } |
| |
| } |
| /** |
| * Gets the Broadcast channels index and the sync status from BleBroadcastSourceInfo Object |
| * This maps the various broadcast source indicies and sync status of them |
| * |
| * @param int audio BIS index from the BleBroadcastSourceInfo object |
| * @hide |
| */ |
| public List<BleBroadcastSourceChannel> getBroadcastChannelsSyncStatus () { |
| List<BleBroadcastSourceChannel> bcastIndicies = new ArrayList<BleBroadcastSourceChannel>(); |
| for (int i=0; i<mNumSubGroups; i++) { |
| int bisIndexValue = mAudioBisIndexList.get(i); |
| int index =0; |
| while (bisIndexValue != 0) { |
| if ((bisIndexValue&0x01) == 0x01) { |
| BleBroadcastSourceChannel bI = |
| new BleBroadcastSourceChannel(index, String.valueOf(index), true, i, mMetadataList.get(i)); |
| bcastIndicies.add(bI); |
| } |
| bisIndexValue = bisIndexValue>>1; |
| index++; |
| } |
| } |
| |
| BASS_Debug(TAG, "returning Bisindicies:" + bcastIndicies); |
| return bcastIndicies; |
| } |
| |
| @UnsupportedAppUsage |
| @Deprecated |
| public Map<Integer, Integer> getBisIndexList() { |
| return mAudioBisIndexList; |
| } |
| |
| /*package*/ void setBroadcastCode(String broadcastCode) { |
| mBroadcastCode = broadcastCode; |
| } |
| |
| @UnsupportedAppUsage |
| @Deprecated |
| public void setBroadcasterId(int broadcasterId) { |
| mBroadcasterId = broadcasterId; |
| } |
| |
| /** |
| * Gets the broadcastCode value from BleBroadcastSourceInfo Object |
| * |
| * @param String broadcast code from the BleBroadcastSourceInfo object |
| * @hide |
| * |
| * @deprecated |
| */ |
| @UnsupportedAppUsage |
| @Deprecated |
| public String getBroadcastCode () { |
| return mBroadcastCode; |
| } |
| |
| private void writeMapToParcel(Parcel dest, Map<Integer, Integer> bisIndexList) { |
| dest.writeInt(bisIndexList.size()); |
| for (Map.Entry<Integer, Integer> entry : bisIndexList.entrySet()) { |
| dest.writeInt(entry.getKey()); |
| dest.writeInt(entry.getValue()); |
| } |
| } |
| |
| private static void readMapFromParcel(Parcel in, Map<Integer, Integer> bisIndexList) { |
| int size = in.readInt(); |
| |
| for (int i = 0; i < size; i++) { |
| Integer key = in.readInt(); |
| Integer value = in.readInt(); |
| bisIndexList.put(key, value); |
| } |
| } |
| |
| private void writeMetadataListToParcel(Parcel dest, Map<Integer, byte[]> metadataList) { |
| dest.writeInt(metadataList.size()); |
| for (Map.Entry<Integer, byte[]> entry : metadataList.entrySet()) { |
| dest.writeInt(entry.getKey()); |
| byte[] metadata = entry.getValue(); |
| if (metadata != null) { |
| dest.writeInt(metadata.length); |
| dest.writeByteArray(metadata); |
| } |
| } |
| } |
| |
| private static void readMetadataListFromParcel(Parcel in, Map<Integer, byte[]> metadataList) { |
| int size = in.readInt(); |
| |
| for (int i = 0; i < size; i++) { |
| Integer key = in.readInt(); |
| Integer metaDataLen = in.readInt(); |
| byte[] metadata = null; |
| if (metaDataLen != 0) { |
| metadata = new byte[metaDataLen]; |
| in.readByteArray(metadata); |
| } |
| metadataList.put(key, metadata); |
| } |
| } |
| |
| public static final @android.annotation.NonNull Parcelable.Creator<BleBroadcastSourceInfo> CREATOR = |
| new Parcelable.Creator<BleBroadcastSourceInfo>() { |
| public BleBroadcastSourceInfo createFromParcel(Parcel in) { |
| |
| BASS_Debug(TAG, "createFromParcel>"); |
| final byte sourceId = in.readByte(); |
| final int sourceAddressType = in.readInt(); |
| final BluetoothDevice sourceDevice = in.readTypedObject( |
| BluetoothDevice.CREATOR); |
| final byte sourceAdvSid = in.readByte(); |
| final int broadcastId = in.readInt(); |
| BASS_Debug(TAG, "broadcastId" + broadcastId); |
| final int metaDataSyncState = in.readInt(); |
| final int audioSyncState = in.readInt(); |
| BASS_Debug(TAG, "audioSyncState" + audioSyncState); |
| final int encyptionStatus = in.readInt(); |
| final int badBroadcastLen = in.readInt(); |
| byte[] badBroadcastCode = null; |
| if (badBroadcastLen > 0) { |
| badBroadcastCode = new byte[badBroadcastLen]; |
| in.readByteArray(badBroadcastCode); |
| } |
| final byte numSubGroups = in.readByte(); |
| final String broadcastCode = in.readString(); |
| Map<Integer,Integer> bisIndexList = new HashMap <Integer, Integer>(); |
| readMapFromParcel(in, bisIndexList); |
| Map<Integer,byte[]> metadataList = new HashMap <Integer, byte[]>(); |
| readMetadataListFromParcel(in, metadataList); |
| |
| BleBroadcastSourceInfo srcInfo = new BleBroadcastSourceInfo(sourceDevice, sourceId, sourceAdvSid, broadcastId, |
| sourceAddressType, metaDataSyncState,audioSyncState, |
| encyptionStatus, broadcastCode, badBroadcastCode, numSubGroups, bisIndexList, metadataList); |
| BASS_Debug(TAG, "createFromParcel:" + srcInfo); |
| return srcInfo; |
| } |
| |
| public BleBroadcastSourceInfo[] newArray(int size) { |
| return new BleBroadcastSourceInfo[size]; |
| } |
| }; |
| |
| @Override |
| public void writeToParcel(Parcel out, int flags) { |
| BASS_Debug(TAG, "writeToParcel>"); |
| out.writeByte(mSourceId); |
| out.writeInt(mSourceAddressType); |
| out.writeTypedObject(mSourceDevice, 0); |
| out.writeByte(mSourceAdvSid); |
| out.writeInt(mBroadcasterId); |
| out.writeInt(mMetaDataSyncState); |
| out.writeInt(mAudioSyncState); |
| out.writeInt(mEncyptionStatus); |
| if (mBadBroadcastCode != null) { |
| out.writeInt(mBadBroadcastCode.length); |
| out.writeByteArray(mBadBroadcastCode); |
| } else { |
| //write ZERO to parcel to say no badBroadcastcode |
| out.writeInt(0); |
| } |
| out.writeByte(mNumSubGroups); |
| out.writeString(mBroadcastCode); |
| writeMapToParcel(out, mAudioBisIndexList); |
| writeMetadataListToParcel(out, mMetadataList); |
| BASS_Debug(TAG, "writeToParcel:" + toString()); |
| } |
| |
| static void BASS_Debug(String TAG, String msg) { |
| if (BASS_DBG) { |
| Log.d(TAG, msg); |
| } |
| } |
| |
| }; |
| |
