975 lines
34 KiB
Java
975 lines
34 KiB
Java
/*
|
|
* 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);
|
|
}
|
|
}
|
|
}
|