| /* |
| * Copyright (C) 2016 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.FlaggedApi; |
| import android.annotation.IntDef; |
| import android.annotation.NonNull; |
| import android.annotation.Nullable; |
| import android.annotation.SuppressLint; |
| import android.compat.annotation.UnsupportedAppUsage; |
| import android.os.Parcel; |
| import android.os.Parcelable; |
| |
| import com.android.bluetooth.flags.Flags; |
| |
| import java.lang.annotation.Retention; |
| import java.lang.annotation.RetentionPolicy; |
| import java.util.Objects; |
| |
| /** |
| * Represents the codec configuration for a Bluetooth A2DP source device. |
| * |
| * <p>Contains the source codec type, the codec priority, the codec sample rate, the codec bits per |
| * sample, and the codec channel mode. |
| * |
| * <p>The source codec type values are the same as those supported by the device hardware. |
| * |
| * @see BluetoothA2dp |
| */ |
| public final class BluetoothCodecConfig implements Parcelable { |
| /** @hide */ |
| @IntDef( |
| prefix = "SOURCE_CODEC_TYPE_", |
| value = { |
| SOURCE_CODEC_TYPE_SBC, |
| SOURCE_CODEC_TYPE_AAC, |
| SOURCE_CODEC_TYPE_APTX, |
| SOURCE_CODEC_TYPE_APTX_HD, |
| SOURCE_CODEC_TYPE_LDAC, |
| SOURCE_CODEC_TYPE_LC3, |
| SOURCE_CODEC_TYPE_OPUS, |
| SOURCE_CODEC_TYPE_INVALID |
| }) |
| @Retention(RetentionPolicy.SOURCE) |
| public @interface SourceCodecType {} |
| |
| /** |
| * Source codec type SBC. This is the mandatory source codec type. |
| * |
| * @deprecated Use the {@link BluetoothCodecType} values returned by {@link |
| * BluetoothA2dp#getSupportedCodecTypes} instead. |
| */ |
| @Deprecated public static final int SOURCE_CODEC_TYPE_SBC = 0; |
| |
| /** |
| * Source codec type AAC. |
| * |
| * @deprecated Use the {@link BluetoothCodecType} values returned by {@link |
| * BluetoothA2dp#getSupportedCodecTypes} instead. |
| */ |
| @Deprecated public static final int SOURCE_CODEC_TYPE_AAC = 1; |
| |
| /** |
| * Source codec type APTX. |
| * |
| * @deprecated Use the {@link BluetoothCodecType} values returned by {@link |
| * BluetoothA2dp#getSupportedCodecTypes} instead. |
| */ |
| @Deprecated public static final int SOURCE_CODEC_TYPE_APTX = 2; |
| |
| /** |
| * Source codec type APTX HD. |
| * |
| * @deprecated Use the {@link BluetoothCodecType} values returned by {@link |
| * BluetoothA2dp#getSupportedCodecTypes} instead. |
| */ |
| @Deprecated public static final int SOURCE_CODEC_TYPE_APTX_HD = 3; |
| |
| /** |
| * Source codec type LDAC. |
| * |
| * @deprecated Use the {@link BluetoothCodecType} values returned by {@link |
| * BluetoothA2dp#getSupportedCodecTypes} instead. |
| */ |
| @Deprecated public static final int SOURCE_CODEC_TYPE_LDAC = 4; |
| |
| /** |
| * Source codec type LC3. |
| * |
| * @deprecated Use the {@link BluetoothCodecType} values returned by {@link |
| * BluetoothA2dp#getSupportedCodecTypes} instead. |
| */ |
| @Deprecated public static final int SOURCE_CODEC_TYPE_LC3 = 5; |
| |
| /** |
| * Source codec type Opus. |
| * |
| * @deprecated Use the {@link BluetoothCodecType} values returned by {@link |
| * BluetoothA2dp#getSupportedCodecTypes} instead. |
| */ |
| @Deprecated public static final int SOURCE_CODEC_TYPE_OPUS = 6; |
| |
| /** |
| * Source codec type invalid. This is the default value used for codec type. |
| * |
| * @deprecated Use the {@link BluetoothCodecType} values returned by {@link |
| * BluetoothA2dp#getSupportedCodecTypes} instead. |
| */ |
| @Deprecated public static final int SOURCE_CODEC_TYPE_INVALID = 1000 * 1000; |
| |
| /** Represents the count of valid source codec types. */ |
| static final int SOURCE_CODEC_TYPE_MAX = 7; |
| |
| /** @hide */ |
| @IntDef( |
| prefix = "CODEC_PRIORITY_", |
| value = {CODEC_PRIORITY_DISABLED, CODEC_PRIORITY_DEFAULT, CODEC_PRIORITY_HIGHEST}) |
| @Retention(RetentionPolicy.SOURCE) |
| public @interface CodecPriority {} |
| |
| /** |
| * Codec priority disabled. Used to indicate that this codec is disabled and should not be used. |
| */ |
| public static final int CODEC_PRIORITY_DISABLED = -1; |
| |
| /** Codec priority default. Default value used for codec priority. */ |
| public static final int CODEC_PRIORITY_DEFAULT = 0; |
| |
| /** Codec priority highest. Used to indicate the highest priority a codec can have. */ |
| public static final int CODEC_PRIORITY_HIGHEST = 1000 * 1000; |
| |
| /** @hide */ |
| @IntDef( |
| prefix = "SAMPLE_RATE_", |
| value = { |
| SAMPLE_RATE_NONE, |
| SAMPLE_RATE_44100, |
| SAMPLE_RATE_48000, |
| SAMPLE_RATE_88200, |
| SAMPLE_RATE_96000, |
| SAMPLE_RATE_176400, |
| SAMPLE_RATE_192000 |
| }) |
| @Retention(RetentionPolicy.SOURCE) |
| public @interface SampleRate {} |
| |
| /** Codec sample rate 0 Hz. Default value used for codec sample rate. */ |
| public static final int SAMPLE_RATE_NONE = 0; |
| |
| /** Codec sample rate 44100 Hz. */ |
| public static final int SAMPLE_RATE_44100 = 0x1 << 0; |
| |
| /** Codec sample rate 48000 Hz. */ |
| public static final int SAMPLE_RATE_48000 = 0x1 << 1; |
| |
| /** Codec sample rate 88200 Hz. */ |
| public static final int SAMPLE_RATE_88200 = 0x1 << 2; |
| |
| /** Codec sample rate 96000 Hz. */ |
| public static final int SAMPLE_RATE_96000 = 0x1 << 3; |
| |
| /** Codec sample rate 176400 Hz. */ |
| public static final int SAMPLE_RATE_176400 = 0x1 << 4; |
| |
| /** Codec sample rate 192000 Hz. */ |
| public static final int SAMPLE_RATE_192000 = 0x1 << 5; |
| |
| /** @hide */ |
| @IntDef( |
| prefix = "BITS_PER_SAMPLE_", |
| value = { |
| BITS_PER_SAMPLE_NONE, |
| BITS_PER_SAMPLE_16, |
| BITS_PER_SAMPLE_24, |
| BITS_PER_SAMPLE_32 |
| }) |
| @Retention(RetentionPolicy.SOURCE) |
| public @interface BitsPerSample {} |
| |
| /** Codec bits per sample 0. Default value of the codec bits per sample. */ |
| public static final int BITS_PER_SAMPLE_NONE = 0; |
| |
| /** Codec bits per sample 16. */ |
| public static final int BITS_PER_SAMPLE_16 = 0x1 << 0; |
| |
| /** Codec bits per sample 24. */ |
| public static final int BITS_PER_SAMPLE_24 = 0x1 << 1; |
| |
| /** Codec bits per sample 32. */ |
| public static final int BITS_PER_SAMPLE_32 = 0x1 << 2; |
| |
| /** @hide */ |
| @IntDef( |
| prefix = "CHANNEL_MODE_", |
| value = {CHANNEL_MODE_NONE, CHANNEL_MODE_MONO, CHANNEL_MODE_STEREO}) |
| @Retention(RetentionPolicy.SOURCE) |
| public @interface ChannelMode {} |
| |
| /** Codec channel mode NONE. Default value of the codec channel mode. */ |
| public static final int CHANNEL_MODE_NONE = 0; |
| |
| /** Codec channel mode MONO. */ |
| public static final int CHANNEL_MODE_MONO = 0x1 << 0; |
| |
| /** Codec channel mode STEREO. */ |
| public static final int CHANNEL_MODE_STEREO = 0x1 << 1; |
| |
| private final @Nullable BluetoothCodecType mCodecType; |
| private @CodecPriority int mCodecPriority; |
| private final @SampleRate int mSampleRate; |
| private final @BitsPerSample int mBitsPerSample; |
| private final @ChannelMode int mChannelMode; |
| private final long mCodecSpecific1; |
| private final long mCodecSpecific2; |
| private final long mCodecSpecific3; |
| private final long mCodecSpecific4; |
| |
| /** |
| * Creates a new BluetoothCodecConfig. |
| * |
| * @param codecType the source codec type |
| * @param codecPriority the priority of this codec |
| * @param sampleRate the codec sample rate |
| * @param bitsPerSample the bits per sample of this codec |
| * @param channelMode the channel mode of this codec |
| * @param codecSpecific1 the specific value 1 |
| * @param codecSpecific2 the specific value 2 |
| * @param codecSpecific3 the specific value 3 |
| * @param codecSpecific4 the specific value 4 values to 0. |
| * @hide |
| */ |
| @UnsupportedAppUsage |
| public BluetoothCodecConfig( |
| @SourceCodecType int codecType, |
| @CodecPriority int codecPriority, |
| @SampleRate int sampleRate, |
| @BitsPerSample int bitsPerSample, |
| @ChannelMode int channelMode, |
| long codecSpecific1, |
| long codecSpecific2, |
| long codecSpecific3, |
| long codecSpecific4) { |
| this( |
| BluetoothCodecType.createFromType(codecType), |
| codecPriority, |
| sampleRate, |
| bitsPerSample, |
| channelMode, |
| codecSpecific1, |
| codecSpecific2, |
| codecSpecific3, |
| codecSpecific4); |
| } |
| |
| /** |
| * Creates a new BluetoothCodecConfig. |
| * |
| * @param codecType the source codec type |
| * @param codecPriority the priority of this codec |
| * @param sampleRate the codec sample rate |
| * @param bitsPerSample the bits per sample of this codec |
| * @param channelMode the channel mode of this codec |
| * @param codecSpecific1 the specific value 1 |
| * @param codecSpecific2 the specific value 2 |
| * @param codecSpecific3 the specific value 3 |
| * @param codecSpecific4 the specific value 4 values to 0. |
| * @hide |
| */ |
| public BluetoothCodecConfig( |
| @Nullable BluetoothCodecType codecType, |
| @CodecPriority int codecPriority, |
| @SampleRate int sampleRate, |
| @BitsPerSample int bitsPerSample, |
| @ChannelMode int channelMode, |
| long codecSpecific1, |
| long codecSpecific2, |
| long codecSpecific3, |
| long codecSpecific4) { |
| mCodecType = codecType; |
| mCodecPriority = codecPriority; |
| mSampleRate = sampleRate; |
| mBitsPerSample = bitsPerSample; |
| mChannelMode = channelMode; |
| mCodecSpecific1 = codecSpecific1; |
| mCodecSpecific2 = codecSpecific2; |
| mCodecSpecific3 = codecSpecific3; |
| mCodecSpecific4 = codecSpecific4; |
| } |
| |
| /** |
| * Creates a new BluetoothCodecConfig. |
| * |
| * <p>By default, the codec priority will be set to {@link |
| * BluetoothCodecConfig#CODEC_PRIORITY_DEFAULT}, the sample rate to {@link |
| * BluetoothCodecConfig#SAMPLE_RATE_NONE}, the bits per sample to {@link |
| * BluetoothCodecConfig#BITS_PER_SAMPLE_NONE}, the channel mode to {@link |
| * BluetoothCodecConfig#CHANNEL_MODE_NONE}, and all the codec specific values to 0. |
| * |
| * @param codecType the source codec type |
| * @hide |
| */ |
| public BluetoothCodecConfig(@SourceCodecType int codecType) { |
| this( |
| BluetoothCodecType.createFromType(codecType), |
| BluetoothCodecConfig.CODEC_PRIORITY_DEFAULT, |
| BluetoothCodecConfig.SAMPLE_RATE_NONE, |
| BluetoothCodecConfig.BITS_PER_SAMPLE_NONE, |
| BluetoothCodecConfig.CHANNEL_MODE_NONE, |
| 0, |
| 0, |
| 0, |
| 0); |
| } |
| |
| private BluetoothCodecConfig(Parcel in) { |
| mCodecType = BluetoothCodecType.createFromType(in.readInt()); |
| mCodecPriority = in.readInt(); |
| mSampleRate = in.readInt(); |
| mBitsPerSample = in.readInt(); |
| mChannelMode = in.readInt(); |
| mCodecSpecific1 = in.readLong(); |
| mCodecSpecific2 = in.readLong(); |
| mCodecSpecific3 = in.readLong(); |
| mCodecSpecific4 = in.readLong(); |
| } |
| |
| @Override |
| public boolean equals(@Nullable Object o) { |
| if (o instanceof BluetoothCodecConfig) { |
| BluetoothCodecConfig other = (BluetoothCodecConfig) o; |
| return (Objects.equals(other.mCodecType, mCodecType) |
| && other.mCodecPriority == mCodecPriority |
| && other.mSampleRate == mSampleRate |
| && other.mBitsPerSample == mBitsPerSample |
| && other.mChannelMode == mChannelMode |
| && other.mCodecSpecific1 == mCodecSpecific1 |
| && other.mCodecSpecific2 == mCodecSpecific2 |
| && other.mCodecSpecific3 == mCodecSpecific3 |
| && other.mCodecSpecific4 == mCodecSpecific4); |
| } |
| return false; |
| } |
| |
| /** |
| * Returns a hash representation of this BluetoothCodecConfig based on all the config values. |
| */ |
| @Override |
| public int hashCode() { |
| return Objects.hash( |
| mCodecType, |
| mCodecPriority, |
| mSampleRate, |
| mBitsPerSample, |
| mChannelMode, |
| mCodecSpecific1, |
| mCodecSpecific2, |
| mCodecSpecific3, |
| mCodecSpecific4); |
| } |
| |
| /** |
| * Adds capability string to an existing string. |
| * |
| * @param prevStr the previous string with the capabilities. Can be a {@code null} pointer |
| * @param capStr the capability string to append to prevStr argument |
| * @return the result string in the form "prevStr|capStr" |
| */ |
| private static String appendCapabilityToString( |
| @Nullable String prevStr, @NonNull String capStr) { |
| if (prevStr == null) { |
| return capStr; |
| } |
| return prevStr + "|" + capStr; |
| } |
| |
| /** |
| * Returns a {@link String} that describes each BluetoothCodecConfig parameter current value. |
| */ |
| @Override |
| public String toString() { |
| String codecName = null; |
| int codecType = SOURCE_CODEC_TYPE_INVALID; |
| if (mCodecType != null) { |
| codecName = mCodecType.getCodecName(); |
| codecType = mCodecType.getNativeCodecType(); |
| } |
| |
| String sampleRateStr = null; |
| if (mSampleRate == SAMPLE_RATE_NONE) { |
| sampleRateStr = appendCapabilityToString(sampleRateStr, "NONE"); |
| } |
| if ((mSampleRate & SAMPLE_RATE_44100) != 0) { |
| sampleRateStr = appendCapabilityToString(sampleRateStr, "44100"); |
| } |
| if ((mSampleRate & SAMPLE_RATE_48000) != 0) { |
| sampleRateStr = appendCapabilityToString(sampleRateStr, "48000"); |
| } |
| if ((mSampleRate & SAMPLE_RATE_88200) != 0) { |
| sampleRateStr = appendCapabilityToString(sampleRateStr, "88200"); |
| } |
| if ((mSampleRate & SAMPLE_RATE_96000) != 0) { |
| sampleRateStr = appendCapabilityToString(sampleRateStr, "96000"); |
| } |
| if ((mSampleRate & SAMPLE_RATE_176400) != 0) { |
| sampleRateStr = appendCapabilityToString(sampleRateStr, "176400"); |
| } |
| if ((mSampleRate & SAMPLE_RATE_192000) != 0) { |
| sampleRateStr = appendCapabilityToString(sampleRateStr, "192000"); |
| } |
| |
| String bitsPerSampleStr = null; |
| if (mBitsPerSample == BITS_PER_SAMPLE_NONE) { |
| bitsPerSampleStr = appendCapabilityToString(bitsPerSampleStr, "NONE"); |
| } |
| if ((mBitsPerSample & BITS_PER_SAMPLE_16) != 0) { |
| bitsPerSampleStr = appendCapabilityToString(bitsPerSampleStr, "16"); |
| } |
| if ((mBitsPerSample & BITS_PER_SAMPLE_24) != 0) { |
| bitsPerSampleStr = appendCapabilityToString(bitsPerSampleStr, "24"); |
| } |
| if ((mBitsPerSample & BITS_PER_SAMPLE_32) != 0) { |
| bitsPerSampleStr = appendCapabilityToString(bitsPerSampleStr, "32"); |
| } |
| |
| String channelModeStr = null; |
| if (mChannelMode == CHANNEL_MODE_NONE) { |
| channelModeStr = appendCapabilityToString(channelModeStr, "NONE"); |
| } |
| if ((mChannelMode & CHANNEL_MODE_MONO) != 0) { |
| channelModeStr = appendCapabilityToString(channelModeStr, "MONO"); |
| } |
| if ((mChannelMode & CHANNEL_MODE_STEREO) != 0) { |
| channelModeStr = appendCapabilityToString(channelModeStr, "STEREO"); |
| } |
| |
| return ("{codecName:" + codecName) |
| + (",mCodecType:" + codecType) |
| + (",mCodecPriority:" + mCodecPriority) |
| + (",mSampleRate:" + String.format("0x%x", mSampleRate) + "(" + sampleRateStr + ")") |
| + (",mBitsPerSample:" |
| + String.format("0x%x", mBitsPerSample) |
| + "(" |
| + bitsPerSampleStr |
| + ")") |
| + (",mChannelMode:" |
| + String.format("0x%x", mChannelMode) |
| + "(" |
| + channelModeStr |
| + ")") |
| + (",mCodecSpecific1:" + mCodecSpecific1) |
| + (",mCodecSpecific2:" + mCodecSpecific2) |
| + (",mCodecSpecific3:" + mCodecSpecific3) |
| + (",mCodecSpecific4:" + mCodecSpecific4) |
| + "}"; |
| } |
| |
| /** |
| * @return 0 |
| * @hide |
| */ |
| @Override |
| public int describeContents() { |
| return 0; |
| } |
| |
| public static final @NonNull Creator<BluetoothCodecConfig> CREATOR = |
| new Creator<>() { |
| public BluetoothCodecConfig createFromParcel(Parcel in) { |
| return new BluetoothCodecConfig(in); |
| } |
| |
| public BluetoothCodecConfig[] newArray(int size) { |
| return new BluetoothCodecConfig[size]; |
| } |
| }; |
| |
| /** |
| * Flattens the object to a parcel |
| * |
| * @param out The Parcel in which the object should be written |
| * @param flags Additional flags about how the object should be written |
| * @hide |
| */ |
| @Override |
| public void writeToParcel(Parcel out, int flags) { |
| out.writeInt(getCodecType()); |
| out.writeInt(mCodecPriority); |
| out.writeInt(mSampleRate); |
| out.writeInt(mBitsPerSample); |
| out.writeInt(mChannelMode); |
| out.writeLong(mCodecSpecific1); |
| out.writeLong(mCodecSpecific2); |
| out.writeLong(mCodecSpecific3); |
| out.writeLong(mCodecSpecific4); |
| } |
| |
| /** |
| * Returns the codec name converted to {@link String}. |
| * |
| * @hide |
| */ |
| public static @NonNull String getCodecName(@SourceCodecType int codecType) { |
| switch (codecType) { |
| case SOURCE_CODEC_TYPE_SBC: |
| return "SBC"; |
| case SOURCE_CODEC_TYPE_AAC: |
| return "AAC"; |
| case SOURCE_CODEC_TYPE_APTX: |
| return "aptX"; |
| case SOURCE_CODEC_TYPE_APTX_HD: |
| return "aptX HD"; |
| case SOURCE_CODEC_TYPE_LDAC: |
| return "LDAC"; |
| case SOURCE_CODEC_TYPE_LC3: |
| return "LC3"; |
| case SOURCE_CODEC_TYPE_OPUS: |
| return "Opus"; |
| case SOURCE_CODEC_TYPE_INVALID: |
| return "INVALID CODEC"; |
| default: |
| break; |
| } |
| return "UNKNOWN CODEC(" + codecType + ")"; |
| } |
| |
| /** |
| * Returns the source codec type of this config. |
| * |
| * @deprecated use {@link BluetoothCodecConfig#getExtendedCodecType} instead. |
| */ |
| @Deprecated |
| @SuppressLint("WrongConstant") |
| public @SourceCodecType int getCodecType() { |
| return mCodecType == null ? SOURCE_CODEC_TYPE_INVALID : mCodecType.getNativeCodecType(); |
| } |
| |
| /** Returns the source codec type of this config. */ |
| @FlaggedApi(Flags.FLAG_A2DP_OFFLOAD_CODEC_EXTENSIBILITY) |
| public @Nullable BluetoothCodecType getExtendedCodecType() { |
| return mCodecType; |
| } |
| |
| /** |
| * Checks whether the codec is mandatory. |
| * |
| * <p>The actual mandatory codec type for Android Bluetooth audio is SBC. See {@link |
| * #SOURCE_CODEC_TYPE_SBC}. |
| * |
| * @return {@code true} if the codec is mandatory, {@code false} otherwise |
| */ |
| public boolean isMandatoryCodec() { |
| return mCodecType == null ? false : mCodecType.isMandatoryCodec(); |
| } |
| |
| /** |
| * Returns the codec selection priority. |
| * |
| * <p>The codec selection priority is relative to other codecs: larger value means higher |
| * priority. |
| */ |
| public @CodecPriority int getCodecPriority() { |
| return mCodecPriority; |
| } |
| |
| /** |
| * Sets the codec selection priority. |
| * |
| * <p>The codec selection priority is relative to other codecs: larger value means higher |
| * priority. |
| * |
| * @param codecPriority the priority this codec should have |
| * @hide |
| */ |
| public void setCodecPriority(@CodecPriority int codecPriority) { |
| mCodecPriority = codecPriority; |
| } |
| |
| /** |
| * Returns the codec sample rate. The value can be a bitmask with all supported sample rates. |
| */ |
| public @SampleRate int getSampleRate() { |
| return mSampleRate; |
| } |
| |
| /** |
| * Returns the codec bits per sample. The value can be a bitmask with all bits per sample |
| * supported. |
| */ |
| public @BitsPerSample int getBitsPerSample() { |
| return mBitsPerSample; |
| } |
| |
| /** |
| * Returns the codec channel mode. The value can be a bitmask with all supported channel modes. |
| */ |
| public @ChannelMode int getChannelMode() { |
| return mChannelMode; |
| } |
| |
| /** |
| * Returns the codec specific value1. As the value and usage differ for each codec, please refer |
| * to the concerned codec specification to obtain the codec specific information. |
| * |
| * <p>See section 4.3.2 of the Bluetooth A2dp specification for SBC codec specific information |
| * elements. |
| * |
| * <p>See section 4.4.2 of the Bluetooth A2dp specification for MPEG-1,2 Audio codec specific |
| * information elements. |
| * |
| * <p>See section 4.5.2 of the Bluetooth A2dp specification for MPEG-2, 4 AAC codec specific |
| * information elements. |
| * |
| * <p>See section 4.6.2 of the Bluetooth A2dp specification for ATRAC family codec specific |
| * information elements. |
| * |
| * <p>See section 4.7.2 of the Bluetooth A2dp specification for Vendor Specific A2DP codec |
| * specific information elements. |
| */ |
| public long getCodecSpecific1() { |
| return mCodecSpecific1; |
| } |
| |
| /** |
| * Returns the codec specific value2. As the value and usage differ for each codec, please refer |
| * to the concerned codec specification to obtain the codec specific information. |
| * |
| * <p>See section 4.3.2 of the Bluetooth A2dp specification for SBC codec specific information |
| * elements. |
| * |
| * <p>See section 4.4.2 of the Bluetooth A2dp specification for MPEG-1,2 Audio codec specific |
| * information elements. |
| * |
| * <p>See section 4.5.2 of the Bluetooth A2dp specification for MPEG-2, 4 AAC codec specific |
| * information elements. |
| * |
| * <p>See section 4.6.2 of the Bluetooth A2dp specification for ATRAC family codec specific |
| * information elements. |
| * |
| * <p>See section 4.7.2 of the Bluetooth A2dp specification for Vendor Specific A2DP codec |
| * specific information elements. |
| */ |
| public long getCodecSpecific2() { |
| return mCodecSpecific2; |
| } |
| |
| /** |
| * Returns the codec specific value3. As the value and usage differ for each codec, please refer |
| * to the concerned codec specification to obtain the codec specific information. |
| * |
| * <p>See section 4.3.2 of the Bluetooth A2dp specification for SBC codec specific information |
| * elements. |
| * |
| * <p>See section 4.4.2 of the Bluetooth A2dp specification for MPEG-1,2 Audio codec specific |
| * information elements. |
| * |
| * <p>See section 4.5.2 of the Bluetooth A2dp specification for MPEG-2, 4 AAC codec specific |
| * information elements. |
| * |
| * <p>See section 4.6.2 of the Bluetooth A2dp specification for ATRAC family codec specific |
| * information elements. |
| * |
| * <p>See section 4.7.2 of the Bluetooth A2dp specification for Vendor Specific A2DP codec |
| * specific information elements. |
| */ |
| public long getCodecSpecific3() { |
| return mCodecSpecific3; |
| } |
| |
| /** |
| * Returns the codec specific value4. As the value and usage differ for each codec, please refer |
| * to the concerned codec specification to obtain the codec specific information. |
| * |
| * <p>See section 4.3.2 of the Bluetooth A2dp specification for SBC codec specific information |
| * elements. |
| * |
| * <p>See section 4.4.2 of the Bluetooth A2dp specification for MPEG-1,2 Audio codec specific |
| * information elements. |
| * |
| * <p>See section 4.5.2 of the Bluetooth A2dp specification for MPEG-2, 4 AAC codec specific |
| * information elements. |
| * |
| * <p>See section 4.6.2 of the Bluetooth A2dp specification for ATRAC family codec specific |
| * information elements. |
| * |
| * <p>See section 4.7.2 of the Bluetooth A2dp specification for Vendor Specific A2DP codec |
| * specific information elements. |
| */ |
| public long getCodecSpecific4() { |
| return mCodecSpecific4; |
| } |
| |
| /** |
| * Checks whether a value set presented by a bitmask has zero or single bit |
| * |
| * @param valueSet the value set presented by a bitmask |
| * @return {@code true} if the valueSet contains zero or single bit, {@code false} otherwise |
| * @hide |
| */ |
| private static boolean hasSingleBit(int valueSet) { |
| return (valueSet == 0 || (valueSet & (valueSet - 1)) == 0); |
| } |
| |
| /** |
| * Returns whether the object contains none or single sample rate. |
| * |
| * @hide |
| */ |
| public boolean hasSingleSampleRate() { |
| return hasSingleBit(mSampleRate); |
| } |
| |
| /** |
| * Returns whether the object contains none or single bits per sample. |
| * |
| * @hide |
| */ |
| public boolean hasSingleBitsPerSample() { |
| return hasSingleBit(mBitsPerSample); |
| } |
| |
| /** |
| * Returns whether the object contains none or single channel mode. |
| * |
| * @hide |
| */ |
| public boolean hasSingleChannelMode() { |
| return hasSingleBit(mChannelMode); |
| } |
| |
| /** |
| * Checks whether the audio feeding parameters are the same. |
| * |
| * @param other the codec config to compare against |
| * @return {@code true} if the audio feeding parameters are same, {@code false} otherwise |
| * @hide |
| */ |
| public boolean sameAudioFeedingParameters(BluetoothCodecConfig other) { |
| return (other != null |
| && other.mSampleRate == mSampleRate |
| && other.mBitsPerSample == mBitsPerSample |
| && other.mChannelMode == mChannelMode); |
| } |
| |
| /** |
| * Checks whether another codec config has the similar feeding parameters. Any parameters with |
| * NONE value will be considered to be a wildcard matching. |
| * |
| * @param other the codec config to compare against |
| * @return {@code true} if the audio feeding parameters are similar, {@code false} otherwise |
| * @hide |
| */ |
| public boolean similarCodecFeedingParameters(BluetoothCodecConfig other) { |
| if (other == null || !Objects.equals(mCodecType, other.mCodecType)) { |
| return false; |
| } |
| int sampleRate = other.mSampleRate; |
| if (mSampleRate == SAMPLE_RATE_NONE || sampleRate == SAMPLE_RATE_NONE) { |
| sampleRate = mSampleRate; |
| } |
| int bitsPerSample = other.mBitsPerSample; |
| if (mBitsPerSample == BITS_PER_SAMPLE_NONE || bitsPerSample == BITS_PER_SAMPLE_NONE) { |
| bitsPerSample = mBitsPerSample; |
| } |
| int channelMode = other.mChannelMode; |
| if (mChannelMode == CHANNEL_MODE_NONE || channelMode == CHANNEL_MODE_NONE) { |
| channelMode = mChannelMode; |
| } |
| return sameAudioFeedingParameters( |
| new BluetoothCodecConfig( |
| mCodecType, /* priority */ |
| 0, |
| sampleRate, |
| bitsPerSample, |
| channelMode, |
| /* specific1 */ 0, /* specific2 */ |
| 0, /* specific3 */ |
| 0, |
| /* specific4 */ 0)); |
| } |
| |
| /** |
| * Checks whether the codec specific parameters are the same. |
| * |
| * <p>Currently, only AAC VBR and LDAC Playback Quality on CodecSpecific1 are compared. |
| * |
| * @param other the codec config to compare against |
| * @return {@code true} if the codec specific parameters are the same, {@code false} otherwise |
| * @hide |
| */ |
| public boolean sameCodecSpecificParameters(BluetoothCodecConfig other) { |
| if (other == null && !Objects.equals(mCodecType, other.mCodecType)) { |
| return false; |
| } |
| switch (getCodecType()) { |
| case SOURCE_CODEC_TYPE_AAC: |
| case SOURCE_CODEC_TYPE_LDAC: |
| case SOURCE_CODEC_TYPE_LC3: |
| case SOURCE_CODEC_TYPE_OPUS: |
| if (mCodecSpecific1 != other.mCodecSpecific1) { |
| return false; |
| } |
| // fall through |
| default: |
| return true; |
| } |
| } |
| |
| /** |
| * Builder for {@link BluetoothCodecConfig}. |
| * |
| * <p>By default, the codec type will be set to {@link |
| * BluetoothCodecConfig#SOURCE_CODEC_TYPE_INVALID}, the codec priority to {@link |
| * BluetoothCodecConfig#CODEC_PRIORITY_DEFAULT}, the sample rate to {@link |
| * BluetoothCodecConfig#SAMPLE_RATE_NONE}, the bits per sample to {@link |
| * BluetoothCodecConfig#BITS_PER_SAMPLE_NONE}, the channel mode to {@link |
| * BluetoothCodecConfig#CHANNEL_MODE_NONE}, and all the codec specific values to 0. |
| */ |
| public static final class Builder { |
| private @Nullable BluetoothCodecType mCodecType = null; |
| private int mCodecPriority = BluetoothCodecConfig.CODEC_PRIORITY_DEFAULT; |
| private int mSampleRate = BluetoothCodecConfig.SAMPLE_RATE_NONE; |
| private int mBitsPerSample = BluetoothCodecConfig.BITS_PER_SAMPLE_NONE; |
| private int mChannelMode = BluetoothCodecConfig.CHANNEL_MODE_NONE; |
| private long mCodecSpecific1 = 0; |
| private long mCodecSpecific2 = 0; |
| private long mCodecSpecific3 = 0; |
| private long mCodecSpecific4 = 0; |
| |
| /** |
| * Set codec type for Bluetooth codec config. |
| * |
| * @param codecType of this codec |
| * @return the same Builder instance |
| * @deprecated use {@link BluetoothCodecType} instead |
| */ |
| @Deprecated |
| public @NonNull Builder setCodecType(@SourceCodecType int codecType) { |
| mCodecType = BluetoothCodecType.createFromType(codecType); |
| return this; |
| } |
| |
| /** |
| * Set codec type for Bluetooth codec config. |
| * |
| * @param codecType of this codec |
| * @return the same Builder instance |
| */ |
| @FlaggedApi(Flags.FLAG_A2DP_OFFLOAD_CODEC_EXTENSIBILITY) |
| public @NonNull Builder setExtendedCodecType(@Nullable BluetoothCodecType codecType) { |
| mCodecType = codecType; |
| return this; |
| } |
| |
| /** |
| * Set codec priority for Bluetooth codec config. |
| * |
| * @param codecPriority of this codec |
| * @return the same Builder instance |
| */ |
| public @NonNull Builder setCodecPriority(@CodecPriority int codecPriority) { |
| mCodecPriority = codecPriority; |
| return this; |
| } |
| |
| /** |
| * Set sample rate for Bluetooth codec config. |
| * |
| * @param sampleRate of this codec |
| * @return the same Builder instance |
| */ |
| public @NonNull Builder setSampleRate(@SampleRate int sampleRate) { |
| mSampleRate = sampleRate; |
| return this; |
| } |
| |
| /** |
| * Set the bits per sample for Bluetooth codec config. |
| * |
| * @param bitsPerSample of this codec |
| * @return the same Builder instance |
| */ |
| public @NonNull Builder setBitsPerSample(@BitsPerSample int bitsPerSample) { |
| mBitsPerSample = bitsPerSample; |
| return this; |
| } |
| |
| /** |
| * Set the channel mode for Bluetooth codec config. |
| * |
| * @param channelMode of this codec |
| * @return the same Builder instance |
| */ |
| public @NonNull Builder setChannelMode(@ChannelMode int channelMode) { |
| mChannelMode = channelMode; |
| return this; |
| } |
| |
| /** |
| * Set the first codec specific values for Bluetooth codec config. |
| * |
| * @param codecSpecific1 codec specific value or 0 if default |
| * @return the same Builder instance |
| */ |
| public @NonNull Builder setCodecSpecific1(long codecSpecific1) { |
| mCodecSpecific1 = codecSpecific1; |
| return this; |
| } |
| |
| /** |
| * Set the second codec specific values for Bluetooth codec config. |
| * |
| * @param codecSpecific2 codec specific value or 0 if default |
| * @return the same Builder instance |
| */ |
| public @NonNull Builder setCodecSpecific2(long codecSpecific2) { |
| mCodecSpecific2 = codecSpecific2; |
| return this; |
| } |
| |
| /** |
| * Set the third codec specific values for Bluetooth codec config. |
| * |
| * @param codecSpecific3 codec specific value or 0 if default |
| * @return the same Builder instance |
| */ |
| public @NonNull Builder setCodecSpecific3(long codecSpecific3) { |
| mCodecSpecific3 = codecSpecific3; |
| return this; |
| } |
| |
| /** |
| * Set the fourth codec specific values for Bluetooth codec config. |
| * |
| * @param codecSpecific4 codec specific value or 0 if default |
| * @return the same Builder instance |
| */ |
| public @NonNull Builder setCodecSpecific4(long codecSpecific4) { |
| mCodecSpecific4 = codecSpecific4; |
| return this; |
| } |
| |
| /** |
| * Build {@link BluetoothCodecConfig}. |
| * |
| * @return new BluetoothCodecConfig built |
| */ |
| public @NonNull BluetoothCodecConfig build() { |
| return new BluetoothCodecConfig( |
| mCodecType, |
| mCodecPriority, |
| mSampleRate, |
| mBitsPerSample, |
| mChannelMode, |
| mCodecSpecific1, |
| mCodecSpecific2, |
| mCodecSpecific3, |
| mCodecSpecific4); |
| } |
| } |
| } |
