| /* |
| * Copyright (C) 2022 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.NonNull; |
| import android.annotation.Nullable; |
| import android.os.Parcel; |
| import android.os.Parcelable; |
| |
| import java.util.Collections; |
| import java.util.List; |
| import java.util.Objects; |
| |
| /** |
| * Represents the codec status (configuration and capability) for a Bluetooth Le Audio source |
| * device. |
| * |
| * @see BluetoothLeAudio |
| */ |
| public final class BluetoothLeAudioCodecStatus implements Parcelable { |
| /** |
| * Extra for the codec configuration intents of the individual profiles. |
| * |
| * <p>This extra represents the current codec status of the Le Audio profile. |
| */ |
| public static final String EXTRA_LE_AUDIO_CODEC_STATUS = |
| "android.bluetooth.extra.LE_AUDIO_CODEC_STATUS"; |
| |
| private final @Nullable BluetoothLeAudioCodecConfig mInputCodecConfig; |
| private final @Nullable BluetoothLeAudioCodecConfig mOutputCodecConfig; |
| private final @Nullable List<BluetoothLeAudioCodecConfig> mInputCodecsLocalCapabilities; |
| private final @Nullable List<BluetoothLeAudioCodecConfig> mOutputCodecsLocalCapabilities; |
| private final @Nullable List<BluetoothLeAudioCodecConfig> mInputCodecsSelectableCapabilities; |
| private final @Nullable List<BluetoothLeAudioCodecConfig> mOutputCodecsSelectableCapabilities; |
| |
| /** |
| * Represents the codec status for a Bluetooth LE Audio source device. |
| * |
| * @param inputCodecConfig the current input codec configuration. |
| * @param outputCodecConfig the current output codec configuration. |
| * @param inputCodecsLocalCapabilities the local input codecs capabilities. |
| * @param outputCodecsLocalCapabilities the local output codecs capabilities. |
| * @param inputCodecsSelectableCapabilities the selectable input codecs capabilities. |
| * @param outputCodecsSelectableCapabilities the selectable output codecs capabilities. |
| */ |
| public BluetoothLeAudioCodecStatus( |
| @Nullable BluetoothLeAudioCodecConfig inputCodecConfig, |
| @Nullable BluetoothLeAudioCodecConfig outputCodecConfig, |
| @NonNull List<BluetoothLeAudioCodecConfig> inputCodecsLocalCapabilities, |
| @NonNull List<BluetoothLeAudioCodecConfig> outputCodecsLocalCapabilities, |
| @NonNull List<BluetoothLeAudioCodecConfig> inputCodecsSelectableCapabilities, |
| @NonNull List<BluetoothLeAudioCodecConfig> outputCodecsSelectableCapabilities) { |
| mInputCodecConfig = inputCodecConfig; |
| mOutputCodecConfig = outputCodecConfig; |
| mInputCodecsLocalCapabilities = inputCodecsLocalCapabilities; |
| mOutputCodecsLocalCapabilities = outputCodecsLocalCapabilities; |
| mInputCodecsSelectableCapabilities = inputCodecsSelectableCapabilities; |
| mOutputCodecsSelectableCapabilities = outputCodecsSelectableCapabilities; |
| } |
| |
| private BluetoothLeAudioCodecStatus(Parcel in) { |
| mInputCodecConfig = in.readTypedObject(BluetoothLeAudioCodecConfig.CREATOR); |
| mOutputCodecConfig = in.readTypedObject(BluetoothLeAudioCodecConfig.CREATOR); |
| mInputCodecsLocalCapabilities = |
| in.createTypedArrayList(BluetoothLeAudioCodecConfig.CREATOR); |
| mOutputCodecsLocalCapabilities = |
| in.createTypedArrayList(BluetoothLeAudioCodecConfig.CREATOR); |
| mInputCodecsSelectableCapabilities = |
| in.createTypedArrayList(BluetoothLeAudioCodecConfig.CREATOR); |
| mOutputCodecsSelectableCapabilities = |
| in.createTypedArrayList(BluetoothLeAudioCodecConfig.CREATOR); |
| } |
| |
| @Override |
| public boolean equals(@Nullable Object o) { |
| if (o instanceof BluetoothLeAudioCodecStatus) { |
| BluetoothLeAudioCodecStatus other = (BluetoothLeAudioCodecStatus) o; |
| return (Objects.equals(other.mInputCodecConfig, mInputCodecConfig) |
| && Objects.equals(other.mOutputCodecConfig, mOutputCodecConfig) |
| && sameCapabilities( |
| other.mInputCodecsLocalCapabilities, mInputCodecsLocalCapabilities) |
| && sameCapabilities( |
| other.mOutputCodecsLocalCapabilities, mOutputCodecsLocalCapabilities) |
| && sameCapabilities( |
| other.mInputCodecsSelectableCapabilities, |
| mInputCodecsSelectableCapabilities) |
| && sameCapabilities( |
| other.mOutputCodecsSelectableCapabilities, |
| mOutputCodecsSelectableCapabilities)); |
| } |
| return false; |
| } |
| |
| /** |
| * Checks whether two lists of capabilities contain same capabilities. The order of the |
| * capabilities in each list is ignored. |
| * |
| * @param c1 the first list of capabilities to compare |
| * @param c2 the second list of capabilities to compare |
| * @return {@code true} if both lists contain same capabilities |
| */ |
| private static boolean sameCapabilities( |
| @Nullable List<BluetoothLeAudioCodecConfig> c1, |
| @Nullable List<BluetoothLeAudioCodecConfig> c2) { |
| if (c1 == null) { |
| return (c2 == null); |
| } |
| if (c2 == null) { |
| return false; |
| } |
| if (c1.size() != c2.size()) { |
| return false; |
| } |
| return c1.containsAll(c2); |
| } |
| |
| private boolean isCodecConfigSelectable( |
| BluetoothLeAudioCodecConfig codecConfig, BluetoothLeAudioCodecConfig selectableConfig) { |
| if (codecConfig.getCodecType() != selectableConfig.getCodecType()) { |
| return false; |
| } |
| if ((codecConfig.getFrameDuration() != BluetoothLeAudioCodecConfig.FRAME_DURATION_NONE) |
| && ((codecConfig.getFrameDuration() & selectableConfig.getFrameDuration()) == 0)) { |
| return false; |
| } |
| if ((codecConfig.getChannelCount() != BluetoothLeAudioCodecConfig.CHANNEL_COUNT_NONE) |
| && ((codecConfig.getChannelCount() & selectableConfig.getChannelCount()) == 0)) { |
| return false; |
| } |
| if ((codecConfig.getSampleRate() != BluetoothLeAudioCodecConfig.SAMPLE_RATE_NONE) |
| && ((codecConfig.getSampleRate() & selectableConfig.getSampleRate()) == 0)) { |
| return false; |
| } |
| if ((codecConfig.getBitsPerSample() != BluetoothLeAudioCodecConfig.BITS_PER_SAMPLE_NONE) |
| && ((codecConfig.getBitsPerSample() & selectableConfig.getBitsPerSample()) == 0)) { |
| return false; |
| } |
| if ((codecConfig.getOctetsPerFrame() != 0) |
| && ((codecConfig.getOctetsPerFrame() < selectableConfig.getMinOctetsPerFrame()) |
| || (codecConfig.getOctetsPerFrame() |
| > selectableConfig.getMaxOctetsPerFrame()))) { |
| return false; |
| } |
| return true; |
| } |
| |
| /** |
| * Checks whether the Input codec config matches the selectable capabilities. Any parameters of |
| * the codec config with NONE value will be considered a wildcard matching. |
| * |
| * @param codecConfig the codec config to compare against |
| * @return {@code true} if the codec config matches, {@code false} otherwise |
| */ |
| public boolean isInputCodecConfigSelectable(@Nullable BluetoothLeAudioCodecConfig codecConfig) { |
| if (codecConfig == null) { |
| return false; |
| } |
| for (BluetoothLeAudioCodecConfig selectableConfig : mInputCodecsSelectableCapabilities) { |
| if (isCodecConfigSelectable(codecConfig, selectableConfig)) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * Checks whether the Output codec config matches the selectable capabilities. Any parameters of |
| * the codec config with NONE value will be considered a wildcard matching. |
| * |
| * @param codecConfig the codec config to compare against |
| * @return {@code true} if the codec config matches, {@code false} otherwise |
| */ |
| public boolean isOutputCodecConfigSelectable( |
| @Nullable BluetoothLeAudioCodecConfig codecConfig) { |
| if (codecConfig == null) { |
| return false; |
| } |
| for (BluetoothLeAudioCodecConfig selectableConfig : mOutputCodecsSelectableCapabilities) { |
| if (isCodecConfigSelectable(codecConfig, selectableConfig)) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| /** Returns a hash based on the codec config and local capabilities. */ |
| @Override |
| public int hashCode() { |
| return Objects.hash( |
| mInputCodecConfig, |
| mOutputCodecConfig, |
| mInputCodecsLocalCapabilities, |
| mOutputCodecsLocalCapabilities, |
| mInputCodecsSelectableCapabilities, |
| mOutputCodecsSelectableCapabilities); |
| } |
| |
| /** |
| * Returns a {@link String} that describes each BluetoothLeAudioCodecStatus parameter current |
| * value. |
| */ |
| @Override |
| public String toString() { |
| return "{mInputCodecConfig:" |
| + mInputCodecConfig |
| + ",mOutputCodecConfig:" |
| + mOutputCodecConfig |
| + ",mInputCodecsLocalCapabilities:" |
| + mInputCodecsLocalCapabilities |
| + ",mOutputCodecsLocalCapabilities:" |
| + mOutputCodecsLocalCapabilities |
| + ",mInputCodecsSelectableCapabilities:" |
| + mInputCodecsSelectableCapabilities |
| + ",mOutputCodecsSelectableCapabilities:" |
| + mOutputCodecsSelectableCapabilities |
| + "}"; |
| } |
| |
| /** |
| * @return 0 |
| */ |
| @Override |
| public int describeContents() { |
| return 0; |
| } |
| |
| /** {@link Parcelable.Creator} interface implementation. */ |
| public static final @android.annotation.NonNull Parcelable.Creator<BluetoothLeAudioCodecStatus> |
| CREATOR = |
| new Parcelable.Creator<BluetoothLeAudioCodecStatus>() { |
| public BluetoothLeAudioCodecStatus createFromParcel(Parcel in) { |
| return new BluetoothLeAudioCodecStatus(in); |
| } |
| |
| public BluetoothLeAudioCodecStatus[] newArray(int size) { |
| return new BluetoothLeAudioCodecStatus[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 |
| */ |
| @Override |
| public void writeToParcel(@NonNull Parcel out, int flags) { |
| out.writeTypedObject(mInputCodecConfig, flags); |
| out.writeTypedObject(mOutputCodecConfig, flags); |
| out.writeTypedList(mInputCodecsLocalCapabilities); |
| out.writeTypedList(mOutputCodecsLocalCapabilities); |
| out.writeTypedList(mInputCodecsSelectableCapabilities); |
| out.writeTypedList(mOutputCodecsSelectableCapabilities); |
| } |
| |
| /** |
| * Returns the current Input codec configuration. |
| * |
| * @return The current input codec config. |
| */ |
| public @Nullable BluetoothLeAudioCodecConfig getInputCodecConfig() { |
| return mInputCodecConfig; |
| } |
| |
| /** |
| * Returns the current Output codec configuration. |
| * |
| * @return The current output codec config. |
| */ |
| public @Nullable BluetoothLeAudioCodecConfig getOutputCodecConfig() { |
| return mOutputCodecConfig; |
| } |
| |
| /** |
| * Returns the input codecs local capabilities. |
| * |
| * @return The list of codec config that supported by the local system. |
| */ |
| public @NonNull List<BluetoothLeAudioCodecConfig> getInputCodecLocalCapabilities() { |
| return (mInputCodecsLocalCapabilities == null) |
| ? Collections.emptyList() |
| : mInputCodecsLocalCapabilities; |
| } |
| |
| /** |
| * Returns the output codecs local capabilities. |
| * |
| * @return The list of codec config that supported by the local system. |
| */ |
| public @NonNull List<BluetoothLeAudioCodecConfig> getOutputCodecLocalCapabilities() { |
| return (mOutputCodecsLocalCapabilities == null) |
| ? Collections.emptyList() |
| : mOutputCodecsLocalCapabilities; |
| } |
| |
| /** |
| * Returns the Input codecs selectable capabilities. |
| * |
| * @return The list of codec config that supported by both of the local system and remote |
| * devices. |
| */ |
| public @NonNull List<BluetoothLeAudioCodecConfig> getInputCodecSelectableCapabilities() { |
| return (mInputCodecsSelectableCapabilities == null) |
| ? Collections.emptyList() |
| : mInputCodecsSelectableCapabilities; |
| } |
| |
| /** |
| * Returns the Output codecs selectable capabilities. |
| * |
| * @return The list of codec config that supported by both of the local system and remote |
| * devices. |
| */ |
| public @NonNull List<BluetoothLeAudioCodecConfig> getOutputCodecSelectableCapabilities() { |
| return (mOutputCodecsSelectableCapabilities == null) |
| ? Collections.emptyList() |
| : mOutputCodecsSelectableCapabilities; |
| } |
| } |
