638 lines
22 KiB
Java
638 lines
22 KiB
Java
/*
|
|
* Copyright (C) 2021 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
package android.bluetooth;
|
|
|
|
import android.annotation.FlaggedApi;
|
|
import android.annotation.IntDef;
|
|
import android.annotation.NonNull;
|
|
import android.annotation.Nullable;
|
|
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 LE Audio source device.
|
|
*
|
|
* <p>Contains the source codec type.
|
|
*
|
|
* <p>The source codec type values are the same as those supported by the device hardware.
|
|
*
|
|
* @see BluetoothLeAudioCodecConfig
|
|
*/
|
|
public final class BluetoothLeAudioCodecConfig implements Parcelable {
|
|
// Add an entry for each source codec here.
|
|
|
|
/** @hide */
|
|
@IntDef(
|
|
prefix = "SOURCE_CODEC_TYPE_",
|
|
value = {SOURCE_CODEC_TYPE_LC3, SOURCE_CODEC_TYPE_INVALID})
|
|
@Retention(RetentionPolicy.SOURCE)
|
|
public @interface SourceCodecType {};
|
|
|
|
public static final int SOURCE_CODEC_TYPE_LC3 = 0;
|
|
public static final int SOURCE_CODEC_TYPE_INVALID = 1000 * 1000;
|
|
|
|
/** @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(
|
|
flag = true,
|
|
prefix = "SAMPLE_RATE_",
|
|
value = {
|
|
SAMPLE_RATE_NONE,
|
|
SAMPLE_RATE_8000,
|
|
SAMPLE_RATE_11025,
|
|
SAMPLE_RATE_16000,
|
|
SAMPLE_RATE_22050,
|
|
SAMPLE_RATE_24000,
|
|
SAMPLE_RATE_32000,
|
|
SAMPLE_RATE_44100,
|
|
SAMPLE_RATE_48000,
|
|
SAMPLE_RATE_88200,
|
|
SAMPLE_RATE_96000,
|
|
SAMPLE_RATE_176400,
|
|
SAMPLE_RATE_192000,
|
|
SAMPLE_RATE_384000
|
|
})
|
|
@Retention(RetentionPolicy.SOURCE)
|
|
public @interface SampleRate {}
|
|
|
|
/**
|
|
* Codec sample rate 0 Hz. Default value used for codec sample rate. Values are the bit mask as
|
|
* defined in the Bluetooth Assigned Numbers, Generic Audio, Supported_Sampling_Frequencies
|
|
* table.
|
|
*/
|
|
public static final int SAMPLE_RATE_NONE = 0;
|
|
|
|
/** Codec sample rate 8000 Hz. */
|
|
public static final int SAMPLE_RATE_8000 = 0x01 << 0;
|
|
|
|
/** Codec sample rate 11025 Hz. */
|
|
@FlaggedApi(Flags.FLAG_LEAUDIO_ADD_SAMPLING_FREQUENCIES)
|
|
public static final int SAMPLE_RATE_11025 = 0x01 << 1;
|
|
|
|
/** Codec sample rate 16000 Hz. */
|
|
public static final int SAMPLE_RATE_16000 = 0x01 << 2;
|
|
|
|
/** Codec sample rate 22050 Hz. */
|
|
@FlaggedApi(Flags.FLAG_LEAUDIO_ADD_SAMPLING_FREQUENCIES)
|
|
public static final int SAMPLE_RATE_22050 = 0x01 << 3;
|
|
|
|
/** Codec sample rate 24000 Hz. */
|
|
public static final int SAMPLE_RATE_24000 = 0x01 << 4;
|
|
|
|
/** Codec sample rate 32000 Hz. */
|
|
public static final int SAMPLE_RATE_32000 = 0x01 << 5;
|
|
|
|
/** Codec sample rate 44100 Hz. */
|
|
public static final int SAMPLE_RATE_44100 = 0x01 << 6;
|
|
|
|
/** Codec sample rate 48000 Hz. */
|
|
public static final int SAMPLE_RATE_48000 = 0x01 << 7;
|
|
|
|
/** Codec sample rate 88200 Hz. */
|
|
@FlaggedApi(Flags.FLAG_LEAUDIO_ADD_SAMPLING_FREQUENCIES)
|
|
public static final int SAMPLE_RATE_88200 = 0x01 << 8;
|
|
|
|
/** Codec sample rate 96000 Hz. */
|
|
@FlaggedApi(Flags.FLAG_LEAUDIO_ADD_SAMPLING_FREQUENCIES)
|
|
public static final int SAMPLE_RATE_96000 = 0x01 << 9;
|
|
|
|
/** Codec sample rate 176400 Hz. */
|
|
@FlaggedApi(Flags.FLAG_LEAUDIO_ADD_SAMPLING_FREQUENCIES)
|
|
public static final int SAMPLE_RATE_176400 = 0x01 << 10;
|
|
|
|
/** Codec sample rate 192000 Hz. */
|
|
@FlaggedApi(Flags.FLAG_LEAUDIO_ADD_SAMPLING_FREQUENCIES)
|
|
public static final int SAMPLE_RATE_192000 = 0x01 << 11;
|
|
|
|
/** Codec sample rate 384000 Hz. */
|
|
@FlaggedApi(Flags.FLAG_LEAUDIO_ADD_SAMPLING_FREQUENCIES)
|
|
public static final int SAMPLE_RATE_384000 = 0x01 << 12;
|
|
|
|
/** @hide */
|
|
@IntDef(
|
|
flag = true,
|
|
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 = 0x01 << 0;
|
|
|
|
/** Codec bits per sample 24. */
|
|
public static final int BITS_PER_SAMPLE_24 = 0x01 << 1;
|
|
|
|
/** Codec bits per sample 32. */
|
|
public static final int BITS_PER_SAMPLE_32 = 0x01 << 3;
|
|
|
|
/**
|
|
* Values are the bit mask as defined in the Bluetooth Assigned Numbers, Generic Audio,
|
|
* Supported_Audio_Channel_Counts table Note: We use only part of it.
|
|
*
|
|
* @hide
|
|
*/
|
|
@IntDef(
|
|
flag = true,
|
|
prefix = "CHANNEL_COUNT_",
|
|
value = {CHANNEL_COUNT_NONE, CHANNEL_COUNT_1, CHANNEL_COUNT_2})
|
|
@Retention(RetentionPolicy.SOURCE)
|
|
public @interface ChannelCount {}
|
|
|
|
/** Codec channel mode NONE. Default value of the codec channel mode. */
|
|
public static final int CHANNEL_COUNT_NONE = 0;
|
|
|
|
/** Codec channel mode MONO. */
|
|
public static final int CHANNEL_COUNT_1 = 0x01 << 0;
|
|
|
|
/** Codec channel mode STEREO. */
|
|
public static final int CHANNEL_COUNT_2 = 0x01 << 1;
|
|
|
|
/**
|
|
* Values are the bit mask as defined in the Bluetooth Assigned Numbers, Generic Audio,
|
|
* Supported_Frame_Durations table
|
|
*
|
|
* @hide
|
|
*/
|
|
@IntDef(
|
|
flag = true,
|
|
prefix = "FRAME_DURATION_",
|
|
value = {FRAME_DURATION_NONE, FRAME_DURATION_7500, FRAME_DURATION_10000})
|
|
@Retention(RetentionPolicy.SOURCE)
|
|
public @interface FrameDuration {}
|
|
|
|
/** Frame duration 0. Default value of the frame duration. */
|
|
public static final int FRAME_DURATION_NONE = 0;
|
|
|
|
/** Frame duration 7500 us. */
|
|
public static final int FRAME_DURATION_7500 = 0x01 << 0;
|
|
|
|
/** Frame duration 10000 us. */
|
|
public static final int FRAME_DURATION_10000 = 0x01 << 1;
|
|
|
|
private final @SourceCodecType int mCodecType;
|
|
private final @CodecPriority int mCodecPriority;
|
|
private final @SampleRate int mSampleRate;
|
|
private final @BitsPerSample int mBitsPerSample;
|
|
private final @ChannelCount int mChannelCount;
|
|
private final @FrameDuration int mFrameDuration;
|
|
private final int mOctetsPerFrame;
|
|
private final int mMinOctetsPerFrame;
|
|
private final int mMaxOctetsPerFrame;
|
|
|
|
/**
|
|
* Creates a new BluetoothLeAudioCodecConfig.
|
|
*
|
|
* @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 channelCount the channel count of this codec
|
|
* @param frameDuration the frame duration of this codec
|
|
* @param octetsPerFrame the octets per frame of this codec
|
|
* @param minOctetsPerFrame the minimum octets per frame of this codec
|
|
* @param maxOctetsPerFrame the maximum octets per frame of this codec
|
|
*/
|
|
private BluetoothLeAudioCodecConfig(
|
|
@SourceCodecType int codecType,
|
|
@CodecPriority int codecPriority,
|
|
@SampleRate int sampleRate,
|
|
@BitsPerSample int bitsPerSample,
|
|
@ChannelCount int channelCount,
|
|
@FrameDuration int frameDuration,
|
|
int octetsPerFrame,
|
|
int minOctetsPerFrame,
|
|
int maxOctetsPerFrame) {
|
|
mCodecType = codecType;
|
|
mCodecPriority = codecPriority;
|
|
mSampleRate = sampleRate;
|
|
mBitsPerSample = bitsPerSample;
|
|
mChannelCount = channelCount;
|
|
mFrameDuration = frameDuration;
|
|
mOctetsPerFrame = octetsPerFrame;
|
|
mMinOctetsPerFrame = minOctetsPerFrame;
|
|
mMaxOctetsPerFrame = maxOctetsPerFrame;
|
|
}
|
|
|
|
@Override
|
|
public int describeContents() {
|
|
return 0;
|
|
}
|
|
|
|
/** {@link Parcelable.Creator} interface implementation. */
|
|
public static final @android.annotation.NonNull Parcelable.Creator<BluetoothLeAudioCodecConfig>
|
|
CREATOR =
|
|
new Parcelable.Creator<BluetoothLeAudioCodecConfig>() {
|
|
public BluetoothLeAudioCodecConfig createFromParcel(Parcel in) {
|
|
int codecType = in.readInt();
|
|
int codecPriority = in.readInt();
|
|
int sampleRate = in.readInt();
|
|
int bitsPerSample = in.readInt();
|
|
int channelCount = in.readInt();
|
|
int frameDuration = in.readInt();
|
|
int octetsPerFrame = in.readInt();
|
|
int minOctetsPerFrame = in.readInt();
|
|
int maxOctetsPerFrame = in.readInt();
|
|
return new BluetoothLeAudioCodecConfig(
|
|
codecType,
|
|
codecPriority,
|
|
sampleRate,
|
|
bitsPerSample,
|
|
channelCount,
|
|
frameDuration,
|
|
octetsPerFrame,
|
|
minOctetsPerFrame,
|
|
maxOctetsPerFrame);
|
|
}
|
|
|
|
public BluetoothLeAudioCodecConfig[] newArray(int size) {
|
|
return new BluetoothLeAudioCodecConfig[size];
|
|
}
|
|
};
|
|
|
|
@Override
|
|
public void writeToParcel(@NonNull Parcel out, int flags) {
|
|
out.writeInt(mCodecType);
|
|
out.writeInt(mCodecPriority);
|
|
out.writeInt(mSampleRate);
|
|
out.writeInt(mBitsPerSample);
|
|
out.writeInt(mChannelCount);
|
|
out.writeInt(mFrameDuration);
|
|
out.writeInt(mOctetsPerFrame);
|
|
out.writeInt(mMinOctetsPerFrame);
|
|
out.writeInt(mMaxOctetsPerFrame);
|
|
}
|
|
|
|
private String sampleRateToString(@SampleRate int sampleRateBit) {
|
|
switch (sampleRateBit) {
|
|
case SAMPLE_RATE_NONE:
|
|
return "None";
|
|
case SAMPLE_RATE_8000:
|
|
return "8 kHz";
|
|
case SAMPLE_RATE_11025:
|
|
return "11.025 kHz";
|
|
case SAMPLE_RATE_16000:
|
|
return "16 kHz";
|
|
case SAMPLE_RATE_22050:
|
|
return "22.05 kHz";
|
|
case SAMPLE_RATE_24000:
|
|
return "24 kHz";
|
|
case SAMPLE_RATE_32000:
|
|
return "32 kHz";
|
|
case SAMPLE_RATE_44100:
|
|
return "44.1 kHz";
|
|
case SAMPLE_RATE_48000:
|
|
return "48 kHz";
|
|
case SAMPLE_RATE_88200:
|
|
return "88.2 kHz";
|
|
case SAMPLE_RATE_96000:
|
|
return "96 kHz";
|
|
case SAMPLE_RATE_176400:
|
|
return "176.4 kHz";
|
|
case SAMPLE_RATE_192000:
|
|
return "192 kHz";
|
|
case SAMPLE_RATE_384000:
|
|
return "384 kHz";
|
|
default:
|
|
return "Unknown bit " + sampleRateBit;
|
|
}
|
|
}
|
|
|
|
private String frameDurationToString(@FrameDuration int frameDurationBit) {
|
|
switch (frameDurationBit) {
|
|
case FRAME_DURATION_NONE:
|
|
return "None";
|
|
case FRAME_DURATION_7500:
|
|
return "7.5 ms";
|
|
case FRAME_DURATION_10000:
|
|
return "10 ms";
|
|
default:
|
|
return "Unknown bit " + frameDurationBit;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public String toString() {
|
|
return "{codecName:"
|
|
+ getCodecName()
|
|
+ ",mCodecType:"
|
|
+ mCodecType
|
|
+ ",mCodecPriority:"
|
|
+ mCodecPriority
|
|
+ ",mSampleRate:"
|
|
+ sampleRateToString(mSampleRate)
|
|
+ ",mBitsPerSample:"
|
|
+ mBitsPerSample
|
|
+ ",mChannelCountBitMask:"
|
|
+ mChannelCount
|
|
+ ",mFrameDuration:"
|
|
+ frameDurationToString(mFrameDuration)
|
|
+ ",mOctetsPerFrame:"
|
|
+ mOctetsPerFrame
|
|
+ ",mMinOctetsPerFrame:"
|
|
+ mMinOctetsPerFrame
|
|
+ ",mMaxOctetsPerFrame:"
|
|
+ mMaxOctetsPerFrame
|
|
+ "}";
|
|
}
|
|
|
|
/**
|
|
* Gets the codec type.
|
|
*
|
|
* @return the codec type
|
|
*/
|
|
public @SourceCodecType int getCodecType() {
|
|
return mCodecType;
|
|
}
|
|
|
|
/**
|
|
* Gets the codec name.
|
|
*
|
|
* @return the codec name
|
|
*/
|
|
public @NonNull String getCodecName() {
|
|
switch (mCodecType) {
|
|
case SOURCE_CODEC_TYPE_LC3:
|
|
return "LC3";
|
|
case SOURCE_CODEC_TYPE_INVALID:
|
|
return "INVALID CODEC";
|
|
default:
|
|
break;
|
|
}
|
|
return "UNKNOWN CODEC(" + mCodecType + ")";
|
|
}
|
|
|
|
/**
|
|
* 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;
|
|
}
|
|
|
|
/** Returns the codec sample rate. */
|
|
public @SampleRate int getSampleRate() {
|
|
return mSampleRate;
|
|
}
|
|
|
|
/** Returns the codec bits per sample. */
|
|
public @BitsPerSample int getBitsPerSample() {
|
|
return mBitsPerSample;
|
|
}
|
|
|
|
/** Returns the codec channel mode. */
|
|
public @ChannelCount int getChannelCount() {
|
|
return mChannelCount;
|
|
}
|
|
|
|
/** Returns the frame duration. */
|
|
public @FrameDuration int getFrameDuration() {
|
|
return mFrameDuration;
|
|
}
|
|
|
|
/** Returns the octets per frame */
|
|
public int getOctetsPerFrame() {
|
|
return mOctetsPerFrame;
|
|
}
|
|
|
|
/** Returns the minimum octets per frame */
|
|
public int getMinOctetsPerFrame() {
|
|
return mMinOctetsPerFrame;
|
|
}
|
|
|
|
/** Returns the maximum octets per frame */
|
|
public int getMaxOctetsPerFrame() {
|
|
return mMaxOctetsPerFrame;
|
|
}
|
|
|
|
@Override
|
|
public boolean equals(@Nullable Object o) {
|
|
if (o instanceof BluetoothLeAudioCodecConfig) {
|
|
BluetoothLeAudioCodecConfig other = (BluetoothLeAudioCodecConfig) o;
|
|
return (other.getCodecType() == mCodecType
|
|
&& other.getCodecPriority() == mCodecPriority
|
|
&& other.getSampleRate() == mSampleRate
|
|
&& other.getBitsPerSample() == mBitsPerSample
|
|
&& other.getChannelCount() == mChannelCount
|
|
&& other.getFrameDuration() == mFrameDuration
|
|
&& other.getOctetsPerFrame() == mOctetsPerFrame
|
|
&& other.getMinOctetsPerFrame() == mMinOctetsPerFrame
|
|
&& other.getMaxOctetsPerFrame() == mMaxOctetsPerFrame);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Returns a hash representation of this BluetoothLeAudioCodecConfig based on all the config
|
|
* values.
|
|
*/
|
|
@Override
|
|
public int hashCode() {
|
|
return Objects.hash(
|
|
mCodecType,
|
|
mCodecPriority,
|
|
mSampleRate,
|
|
mBitsPerSample,
|
|
mChannelCount,
|
|
mFrameDuration,
|
|
mOctetsPerFrame,
|
|
mMinOctetsPerFrame,
|
|
mMaxOctetsPerFrame);
|
|
}
|
|
|
|
/**
|
|
* Builder for {@link BluetoothLeAudioCodecConfig}.
|
|
*
|
|
* <p>By default, the codec type will be set to {@link
|
|
* BluetoothLeAudioCodecConfig#SOURCE_CODEC_TYPE_INVALID}
|
|
*/
|
|
public static final class Builder {
|
|
private int mCodecType = BluetoothLeAudioCodecConfig.SOURCE_CODEC_TYPE_INVALID;
|
|
private int mCodecPriority = BluetoothLeAudioCodecConfig.CODEC_PRIORITY_DEFAULT;
|
|
private int mSampleRate = BluetoothLeAudioCodecConfig.SAMPLE_RATE_NONE;
|
|
private int mBitsPerSample = BluetoothLeAudioCodecConfig.BITS_PER_SAMPLE_NONE;
|
|
private int mChannelCount = BluetoothLeAudioCodecConfig.CHANNEL_COUNT_NONE;
|
|
private int mFrameDuration = BluetoothLeAudioCodecConfig.FRAME_DURATION_NONE;
|
|
private int mOctetsPerFrame = 0;
|
|
private int mMinOctetsPerFrame = 0;
|
|
private int mMaxOctetsPerFrame = 0;
|
|
|
|
public Builder() {}
|
|
|
|
public Builder(@NonNull BluetoothLeAudioCodecConfig config) {
|
|
mCodecType = config.getCodecType();
|
|
mCodecPriority = config.getCodecPriority();
|
|
mSampleRate = config.getSampleRate();
|
|
mBitsPerSample = config.getBitsPerSample();
|
|
mChannelCount = config.getChannelCount();
|
|
mFrameDuration = config.getFrameDuration();
|
|
mOctetsPerFrame = config.getOctetsPerFrame();
|
|
mMinOctetsPerFrame = config.getMinOctetsPerFrame();
|
|
mMaxOctetsPerFrame = config.getMaxOctetsPerFrame();
|
|
}
|
|
|
|
/**
|
|
* Set codec type for Bluetooth LE audio codec config.
|
|
*
|
|
* @param codecType of this codec
|
|
* @return the same Builder instance
|
|
*/
|
|
public @NonNull Builder setCodecType(@SourceCodecType int codecType) {
|
|
mCodecType = codecType;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Set codec priority for Bluetooth LE audio 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 LE audio 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 LE audio 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 count for Bluetooth LE audio codec config.
|
|
*
|
|
* @param channelCount of this codec
|
|
* @return the same Builder instance
|
|
*/
|
|
public @NonNull Builder setChannelCount(@ChannelCount int channelCount) {
|
|
mChannelCount = channelCount;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Set the frame duration for Bluetooth LE audio codec config.
|
|
*
|
|
* @param frameDuration of this codec
|
|
* @return the same Builder instance
|
|
*/
|
|
public @NonNull Builder setFrameDuration(@FrameDuration int frameDuration) {
|
|
mFrameDuration = frameDuration;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Set the octets per frame for Bluetooth LE audio codec config.
|
|
*
|
|
* @param octetsPerFrame of this codec
|
|
* @return the same Builder instance
|
|
*/
|
|
public @NonNull Builder setOctetsPerFrame(int octetsPerFrame) {
|
|
mOctetsPerFrame = octetsPerFrame;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Set the minimum octets per frame for Bluetooth LE audio codec config.
|
|
*
|
|
* @param minOctetsPerFrame of this codec
|
|
* @return the same Builder instance
|
|
*/
|
|
public @NonNull Builder setMinOctetsPerFrame(int minOctetsPerFrame) {
|
|
mMinOctetsPerFrame = minOctetsPerFrame;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Set the maximum octets per frame for Bluetooth LE audio codec config.
|
|
*
|
|
* @param maxOctetsPerFrame of this codec
|
|
* @return the same Builder instance
|
|
*/
|
|
public @NonNull Builder setMaxOctetsPerFrame(int maxOctetsPerFrame) {
|
|
mMaxOctetsPerFrame = maxOctetsPerFrame;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Build {@link BluetoothLeAudioCodecConfig}.
|
|
*
|
|
* @return new BluetoothLeAudioCodecConfig built
|
|
*/
|
|
public @NonNull BluetoothLeAudioCodecConfig build() {
|
|
return new BluetoothLeAudioCodecConfig(
|
|
mCodecType,
|
|
mCodecPriority,
|
|
mSampleRate,
|
|
mBitsPerSample,
|
|
mChannelCount,
|
|
mFrameDuration,
|
|
mOctetsPerFrame,
|
|
mMinOctetsPerFrame,
|
|
mMaxOctetsPerFrame);
|
|
}
|
|
}
|
|
}
|