Refactor Bluetooth Codec settings to dynamic ListPreference

Fetch supported codecs from native and present to user using
ListPreference.

Bug: 305779598
Bug: 311451118
Bug: 323319530
Tag: #feature
Test: atest SettingsRoboTests:com.android.settings.development.bluetooth.AbstractBluetoothListPreferenceController
Test: atest SettingsRoboTests:com.android.settings.development.bluetooth.BluetoothCodecListPreferenceControllerTest

Change-Id: Iedbfd01c0d1b59df8a073f4e9aedca3913e6d45f

aconfig/development/settings_core_flag_declarations.aconfig

@@ -1,6 +1,13 @@
 package: "com.android.settings.development"
 container: "system"
 
+flag {
+  name: "a2dp_offload_codec_extensibility_settings"
+  namespace: "bluetooth"
+  description: "Feature flag for Bluetooth Audio Codec extensibility in Settings"
+  bug: "323319530"
+}
+
 flag {
   name: "deprecate_list_activity"
   namespace: "android_settings"

res/values/strings.xml

@@ -178,6 +178,9 @@
     <!-- Description for text in accessibility hearing aids footer. [CHAR LIMIT=NONE] -->
     <string name="bluetooth_audio_routing_footer_summary">By default, audio output is determined by individual apps</string>
 
+    <!-- Bluetooth audio codec related settings. Title of the default audio codec selection. [CHAR LIMIT=60] -->
+    <string name="bluetooth_audio_codec_default_selection">Use System Selection (Default)</string>
+
     <!--Bluetooth settings screen, summary text for Bluetooth device with no name -->
     <string name="bluetooth_device">Unnamed Bluetooth device</string>
     <!--Bluetooth settings screen, text that appears in heading bar when scanning for devices -->

res/xml/development_settings.xml

@@ -430,6 +430,11 @@
             android:positiveButtonText=""
             android:negativeButtonText="@string/dlg_ok"/>
 
+        <ListPreference
+            android:key="bluetooth_audio_codec_settings_list"
+            android:title="@string/bluetooth_select_a2dp_codec_type"
+            android:dialogTitle="@string/bluetooth_select_a2dp_codec_type_dialog_title"/>
+
         <com.android.settings.development.bluetooth.BluetoothSampleRateDialogPreference
             android:key="bluetooth_sample_rate_settings"
             android:title="@string/bluetooth_select_a2dp_codec_sample_rate"

src/com/android/settings/development/BluetoothA2dpConfigStore.java

@@ -16,15 +16,19 @@
 
 package com.android.settings.development;
 
+import android.annotation.FlaggedApi;
 import android.bluetooth.BluetoothCodecConfig;
+import android.bluetooth.BluetoothCodecType;
 
-/**
+import androidx.annotation.NonNull;
- * Utility class for storing current Bluetooth A2DP profile values
+import androidx.annotation.Nullable;
- */
+
+/** Utility class for storing current Bluetooth A2DP profile values */
 public class BluetoothA2dpConfigStore {
 
     // init default values
-    private int mCodecType = BluetoothCodecConfig.SOURCE_CODEC_TYPE_INVALID;
+    private int mCodecTypeNative = BluetoothCodecConfig.SOURCE_CODEC_TYPE_INVALID;
+    @Nullable private 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;
@@ -35,6 +39,10 @@ public class BluetoothA2dpConfigStore {
     private long mCodecSpecific4Value;
 
     public void setCodecType(int codecType) {
+        mCodecTypeNative = codecType;
+    }
+
+    public void setCodecType(@Nullable BluetoothCodecType codecType) {
         mCodecType = codecType;
     }
 
@@ -70,9 +78,26 @@ public class BluetoothA2dpConfigStore {
         mCodecSpecific4Value = codecSpecific4Value;
     }
 
+    /** Create codec config utilizing {@link BluetoothCodecConfig.SourceCodecType} */
     public BluetoothCodecConfig createCodecConfig() {
         return new BluetoothCodecConfig.Builder()
-                .setCodecType(mCodecType)
+                .setCodecType(mCodecTypeNative)
+                .setCodecPriority(mCodecPriority)
+                .setSampleRate(mSampleRate)
+                .setBitsPerSample(mBitsPerSample)
+                .setChannelMode(mChannelMode)
+                .setCodecSpecific1(mCodecSpecific1Value)
+                .setCodecSpecific2(mCodecSpecific2Value)
+                .setCodecSpecific3(mCodecSpecific3Value)
+                .setCodecSpecific4(mCodecSpecific4Value)
+                .build();
+    }
+
+    /** Create codec config utilizing {@link BluetoothCodecType} */
+    @FlaggedApi(Flags.FLAG_A2DP_OFFLOAD_CODEC_EXTENSIBILITY_SETTINGS)
+    public @NonNull BluetoothCodecConfig createCodecConfigFromCodecType() {
+        return new BluetoothCodecConfig.Builder()
+                .setExtendedCodecType(mCodecType)
                 .setCodecPriority(mCodecPriority)
                 .setSampleRate(mSampleRate)
                 .setBitsPerSample(mBitsPerSample)

src/com/android/settings/development/DevelopmentSettingsDashboardFragment.java

@@ -62,10 +62,12 @@ import com.android.settings.development.autofill.AutofillCategoryController;
 import com.android.settings.development.autofill.AutofillLoggingLevelPreferenceController;
 import com.android.settings.development.autofill.AutofillResetOptionsPreferenceController;
 import com.android.settings.development.bluetooth.AbstractBluetoothDialogPreferenceController;
+import com.android.settings.development.bluetooth.AbstractBluetoothListPreferenceController;
 import com.android.settings.development.bluetooth.AbstractBluetoothPreferenceController;
 import com.android.settings.development.bluetooth.BluetoothBitPerSampleDialogPreferenceController;
 import com.android.settings.development.bluetooth.BluetoothChannelModeDialogPreferenceController;
 import com.android.settings.development.bluetooth.BluetoothCodecDialogPreferenceController;
+import com.android.settings.development.bluetooth.BluetoothCodecListPreferenceController;
 import com.android.settings.development.bluetooth.BluetoothHDAudioPreferenceController;
 import com.android.settings.development.bluetooth.BluetoothQualityDialogPreferenceController;
 import com.android.settings.development.bluetooth.BluetoothSampleRateDialogPreferenceController;
@@ -744,6 +746,9 @@ public class DevelopmentSettingsDashboardFragment extends RestrictedDashboardFra
         controllers.add(new AutofillResetOptionsPreferenceController(context));
         controllers.add(new BluetoothCodecDialogPreferenceController(context, lifecycle,
                 bluetoothA2dpConfigStore, fragment));
+        controllers.add(
+                new BluetoothCodecListPreferenceController(
+                        context, lifecycle, bluetoothA2dpConfigStore, fragment));
         controllers.add(new BluetoothSampleRateDialogPreferenceController(context, lifecycle,
                 bluetoothA2dpConfigStore));
         controllers.add(new BluetoothBitPerSampleDialogPreferenceController(context, lifecycle,
@@ -792,6 +797,9 @@ public class DevelopmentSettingsDashboardFragment extends RestrictedDashboardFra
                 ((AbstractBluetoothDialogPreferenceController) controller).onHDAudioEnabled(
                         enabled);
             }
+            if (controller instanceof AbstractBluetoothListPreferenceController) {
+                ((AbstractBluetoothListPreferenceController) controller).onHDAudioEnabled(enabled);
+            }
         }
     }
 

src/com/android/settings/development/bluetooth/AbstractBluetoothListPreferenceController.java

@@ -0,0 +1,268 @@
+/*
+ * Copyright (C) 2023 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 com.android.settings.development.bluetooth;
+
+import static android.bluetooth.BluetoothCodecConfig.CODEC_PRIORITY_HIGHEST;
+
+import android.bluetooth.BluetoothA2dp;
+import android.bluetooth.BluetoothCodecConfig;
+import android.bluetooth.BluetoothCodecStatus;
+import android.bluetooth.BluetoothDevice;
+import android.content.Context;
+import android.util.Log;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.preference.ListPreference;
+import androidx.preference.Preference;
+import androidx.preference.PreferenceScreen;
+
+import com.android.settings.R;
+import com.android.settings.development.BluetoothA2dpConfigStore;
+import com.android.settingslib.core.lifecycle.Lifecycle;
+
+import java.util.List;
+
+/** Abstract class for Bluetooth A2DP config list controller in developer option. */
+public abstract class AbstractBluetoothListPreferenceController
+        extends AbstractBluetoothPreferenceController
+        implements Preference.OnPreferenceChangeListener {
+
+    private static final String TAG = "AbstrBtListPrefCtrl";
+    private static final boolean DEBUG = Log.isLoggable(TAG, Log.DEBUG);
+
+    protected static final int DEFAULT_VALUE_INT = 1000;
+
+    @Nullable protected ListPreference mListPreference;
+
+    protected String mDefaultEntry;
+    protected String mDefaultValue;
+
+    @Nullable protected final BluetoothA2dpConfigStore mBluetoothA2dpConfigStore;
+
+    public AbstractBluetoothListPreferenceController(
+            @NonNull Context context,
+            @Nullable Lifecycle lifecycle,
+            @Nullable BluetoothA2dpConfigStore store) {
+        super(context, lifecycle, store);
+
+        mDefaultEntry = mContext.getString(R.string.bluetooth_audio_codec_default_selection);
+        mDefaultValue = String.valueOf(DEFAULT_VALUE_INT);
+
+        mBluetoothA2dpConfigStore = store;
+    }
+
+    @Override
+    public void displayPreference(@NonNull PreferenceScreen screen) {
+        super.displayPreference(screen);
+        mListPreference = screen.findPreference(getPreferenceKey());
+    }
+
+    @Override
+    public boolean onPreferenceChange(@Nullable Preference preference, @NonNull Object newValue) {
+        if (DEBUG) {
+            Log.d(TAG, "onPreferenceChange: newValue=" + (String) newValue);
+        }
+        if (mListPreference == null) {
+            Log.e(TAG, "onPreferenceChange: List preference is null");
+            return false;
+        }
+        updateState(mListPreference);
+        return true;
+    }
+
+    @Override
+    public void updateState(@Nullable Preference preference) {
+        setupDefaultListPreference();
+    }
+
+    @Override
+    public void onBluetoothServiceConnected(@NonNull BluetoothA2dp bluetoothA2dp) {
+        super.onBluetoothServiceConnected(bluetoothA2dp);
+        initConfigStore();
+    }
+
+    @Override
+    protected void onDeveloperOptionsSwitchDisabled() {
+        super.onDeveloperOptionsSwitchDisabled();
+        if (DEBUG) {
+            Log.d(TAG, "onDeveloperOptionsSwitchDisabled");
+        }
+        if (mListPreference == null) {
+            Log.e(TAG, "onDeveloperOptionsSwitchDisabled: List preference is null");
+            return;
+        }
+        updateState(mListPreference);
+    }
+
+    /**
+     * Method to notify controller when the HD audio(optional codec) state is changed.
+     *
+     * @param enabled Is {@code true} when the setting is enabled.
+     */
+    public void onHDAudioEnabled(boolean enabled) {}
+
+    /**
+     * Updates the new value to the {@link BluetoothA2dpConfigStore}.
+     *
+     * @param entryValue the new setting entry value
+     */
+    protected abstract void writeConfigurationValues(String entryValue);
+
+    /**
+     * Gets the current bluetooth codec status.
+     *
+     * @return {@link BluetoothCodecStatus}.
+     */
+    @Nullable
+    protected BluetoothCodecStatus getBluetoothCodecStatus() {
+        final BluetoothA2dp bluetoothA2dp = mBluetoothA2dp;
+        if (bluetoothA2dp == null) {
+            Log.e(
+                    TAG,
+                    "getBluetoothCodecStatus: Unable to get codec status. Bluetooth A2dp is null.");
+            return null;
+        }
+        final BluetoothDevice activeDevice = getA2dpActiveDevice();
+        if (activeDevice == null) {
+            Log.e(TAG, "getBluetoothCodecStatus: Unable to get codec status. No active device.");
+            return null;
+        }
+        final BluetoothCodecStatus codecStatus = bluetoothA2dp.getCodecStatus(activeDevice);
+        if (codecStatus == null) {
+            Log.e(TAG, "getBluetoothCodecStatus: Codec status is null");
+            return null;
+        }
+        return codecStatus;
+    }
+
+    /**
+     * Gets the current bluetooth codec config.
+     *
+     * @return {@link BluetoothCodecConfig}.
+     */
+    @Nullable
+    protected BluetoothCodecConfig getCurrentCodecConfig() {
+        final BluetoothCodecStatus codecStatus = getBluetoothCodecStatus();
+        if (codecStatus == null) {
+            Log.e(
+                    TAG,
+                    "getCurrentCodecConfig: Unable to get current codec config. Codec status is"
+                            + " null");
+            return null;
+        }
+
+        return codecStatus.getCodecConfig();
+    }
+
+    /**
+     * Sets the {@link ListPreference}. This method adds the default entry and the entry value
+     * automatically.
+     *
+     * @param entries list of String entries for the {@link ListPreference}.
+     * @param entryValues list of String entry values for the {@link ListPreference}.
+     * @param selectedEntry currently selected entry.
+     * @param selectedValue currently selected entry value.
+     */
+    protected void setupListPreference(
+            List<String> entries,
+            List<String> entryValues,
+            String selectedEntry,
+            String selectedValue) {
+        if (entries.size() != entryValues.size()) {
+            Log.e(
+                    TAG,
+                    ("setupListPreference: size of entries: " + entries.size())
+                            + (", size of entryValues" + entryValues.size()));
+            setupDefaultListPreference();
+            return;
+        }
+        if (entries.isEmpty() || entryValues.isEmpty()) {
+            Log.e(TAG, "setupListPreference: entries or entryValues empty");
+            setupDefaultListPreference();
+            return;
+        }
+        entries.add(0, mDefaultEntry);
+        entryValues.add(0, mDefaultValue);
+
+        if (mListPreference == null) {
+            Log.e(TAG, "setupListPreference: List preference is null");
+            return;
+        }
+        mListPreference.setEntries(entries.toArray(new String[entries.size()]));
+        mListPreference.setEntryValues(entryValues.toArray(new String[entryValues.size()]));
+        mListPreference.setValue(selectedValue);
+        mListPreference.setSummary(selectedEntry);
+    }
+
+    /**
+     * Check HD Audio enabled.
+     *
+     * @return true if HD Audio is enabled.
+     */
+    protected boolean isHDAudioEnabled() {
+        final BluetoothA2dp bluetoothA2dp = mBluetoothA2dp;
+        if (bluetoothA2dp == null) {
+            Log.e(TAG, "isHDAudioEnabled: Unable to get codec status. BluetoothA2dp is null.");
+            return false;
+        }
+        BluetoothDevice activeDevice = getA2dpActiveDevice();
+        if (activeDevice == null) {
+            Log.e(TAG, "isHDAudioEnabled: Unable to get codec status. No active device.");
+            return false;
+        }
+        return (bluetoothA2dp.isOptionalCodecsEnabled(activeDevice)
+                == BluetoothA2dp.OPTIONAL_CODECS_PREF_ENABLED);
+    }
+
+    private void setupDefaultListPreference() {
+        if (DEBUG) {
+            Log.d(
+                    TAG,
+                    "setupDefaultListPreference: mDefaultEntry="
+                            + mDefaultEntry
+                            + ", mDefaultValue="
+                            + mDefaultValue);
+        }
+        if (mListPreference == null) {
+            Log.e(TAG, "setupListPreference: List preference is null");
+            return;
+        }
+        mListPreference.setEntries(new String[] {mDefaultEntry});
+        mListPreference.setEntryValues(new String[] {mDefaultValue});
+        mListPreference.setValue(mDefaultValue);
+        mListPreference.setSummary(mDefaultEntry);
+    }
+
+    private void initConfigStore() {
+        final BluetoothCodecConfig config = getCurrentCodecConfig();
+        if (config == null) {
+            Log.e(TAG, "initConfigStore: Current codec config is null.");
+            return;
+        }
+        if (mBluetoothA2dpConfigStore == null) {
+            Log.e(TAG, "initConfigStore: Bluetooth A2dp Config Store is null.");
+            return;
+        }
+        mBluetoothA2dpConfigStore.setCodecType(config.getExtendedCodecType());
+        mBluetoothA2dpConfigStore.setSampleRate(config.getSampleRate());
+        mBluetoothA2dpConfigStore.setBitsPerSample(config.getBitsPerSample());
+        mBluetoothA2dpConfigStore.setChannelMode(config.getChannelMode());
+        mBluetoothA2dpConfigStore.setCodecPriority(CODEC_PRIORITY_HIGHEST);
+        mBluetoothA2dpConfigStore.setCodecSpecific1Value(config.getCodecSpecific1());
+    }
+}

src/com/android/settings/development/bluetooth/AbstractBluetoothPreferenceController.java

@@ -23,6 +23,7 @@ import android.bluetooth.BluetoothManager;
 import android.bluetooth.BluetoothProfile;
 import android.content.Context;
 
+import androidx.annotation.Nullable;
 import androidx.annotation.VisibleForTesting;
 
 import com.android.settings.core.PreferenceControllerMixin;
@@ -42,13 +43,15 @@ public abstract class AbstractBluetoothPreferenceController extends
         DeveloperOptionsPreferenceController implements BluetoothServiceConnectionListener,
         LifecycleObserver, OnDestroy, PreferenceControllerMixin {
 
-    protected volatile BluetoothA2dp mBluetoothA2dp;
+    @Nullable protected volatile BluetoothA2dp mBluetoothA2dp;
 
     @VisibleForTesting
     BluetoothAdapter mBluetoothAdapter;
 
-    public AbstractBluetoothPreferenceController(Context context, Lifecycle lifecycle,
+    public AbstractBluetoothPreferenceController(
-                                                 BluetoothA2dpConfigStore store) {
+            @Nullable Context context,
+            @Nullable Lifecycle lifecycle,
+            @Nullable BluetoothA2dpConfigStore store) {
         super(context);
         if (lifecycle != null) {
             lifecycle.addObserver(this);

src/com/android/settings/development/bluetooth/BluetoothCodecDialogPreferenceController.java

@@ -26,6 +26,7 @@ import androidx.annotation.VisibleForTesting;
 import androidx.preference.PreferenceScreen;
 
 import com.android.settings.development.BluetoothA2dpConfigStore;
+import com.android.settings.development.Flags;
 import com.android.settingslib.core.lifecycle.Lifecycle;
 
 import java.util.ArrayList;
@@ -49,6 +50,11 @@ public class BluetoothCodecDialogPreferenceController extends
         mCallback = callback;
     }
 
+    @Override
+    public boolean isAvailable() {
+        return !Flags.a2dpOffloadCodecExtensibilitySettings();
+    }
+
     @Override
     public String getPreferenceKey() {
         return KEY;

src/com/android/settings/development/bluetooth/BluetoothCodecListPreferenceController.java

@@ -0,0 +1,265 @@
+/*
+ * Copyright (C) 2023 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 com.android.settings.development.bluetooth;
+
+import android.bluetooth.BluetoothA2dp;
+import android.bluetooth.BluetoothCodecConfig;
+import android.bluetooth.BluetoothCodecStatus;
+import android.bluetooth.BluetoothCodecType;
+import android.bluetooth.BluetoothDevice;
+import android.content.Context;
+import android.util.Log;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.preference.Preference;
+import androidx.preference.PreferenceScreen;
+
+import com.android.settings.development.BluetoothA2dpConfigStore;
+import com.android.settings.development.Flags;
+import com.android.settingslib.core.lifecycle.Lifecycle;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+/** List preference controller to set the Bluetooth A2DP codec */
+public class BluetoothCodecListPreferenceController
+        extends AbstractBluetoothListPreferenceController {
+
+    private static final String KEY = "bluetooth_audio_codec_settings_list";
+    private static final String TAG = "BtExtCodecCtr";
+    private static final boolean DEBUG = Log.isLoggable(TAG, Log.DEBUG);
+
+    @Nullable private final Callback mCallback;
+
+    public BluetoothCodecListPreferenceController(
+            @NonNull Context context,
+            @Nullable Lifecycle lifecycle,
+            @Nullable BluetoothA2dpConfigStore store,
+            @Nullable Callback callback) {
+        super(context, lifecycle, store);
+        mCallback = callback;
+    }
+
+    @Override
+    public boolean isAvailable() {
+        boolean available = Flags.a2dpOffloadCodecExtensibilitySettings();
+        if (DEBUG) {
+            Log.d(TAG, "isAvailable: " + available);
+        }
+        return available;
+    }
+
+    @Override
+    public @NonNull String getPreferenceKey() {
+        return KEY;
+    }
+
+    @Override
+    public void displayPreference(@NonNull PreferenceScreen screen) {
+        super.displayPreference(screen);
+        mListPreference = screen.findPreference(getPreferenceKey());
+    }
+
+    @Override
+    public boolean onPreferenceChange(@Nullable Preference preference, @NonNull Object newValue) {
+        if (DEBUG) {
+            Log.d(TAG, "onPreferenceChange: newValue=" + (String) newValue);
+        }
+        final BluetoothA2dp bluetoothA2dp = mBluetoothA2dp;
+        if (bluetoothA2dp == null) {
+            Log.e(TAG, "onPreferenceChange: bluetoothA2dp is null");
+            return false;
+        }
+
+        writeConfigurationValues((String) newValue);
+
+        if (mBluetoothA2dpConfigStore == null) {
+            Log.e(TAG, "onPreferenceChange: Bluetooth A2dp Config Store is null");
+            return false;
+        }
+        BluetoothCodecConfig codecConfig;
+        if (Flags.a2dpOffloadCodecExtensibilitySettings()) {
+            codecConfig = mBluetoothA2dpConfigStore.createCodecConfigFromCodecType();
+        } else {
+            codecConfig = mBluetoothA2dpConfigStore.createCodecConfig();
+        }
+
+        final BluetoothDevice activeDevice = getA2dpActiveDevice();
+        if (activeDevice == null) {
+            Log.e(TAG, "onPreferenceChange: active device is null");
+            return false;
+        }
+
+        if (DEBUG) {
+            Log.d(TAG, "onPreferenceChange: setCodecConfigPreference: " + codecConfig.toString());
+        }
+        bluetoothA2dp.setCodecConfigPreference(activeDevice, codecConfig);
+        if (mCallback != null) {
+            mCallback.onBluetoothCodecChanged();
+        }
+
+        return true;
+    }
+
+    @Override
+    public void updateState(@Nullable Preference preference) {
+        super.updateState(preference);
+        final List<String> codecIds = new ArrayList<>();
+        final List<String> labels = new ArrayList<>();
+        String selectedCodecId = mDefaultValue;
+        String selectedLabel = mDefaultEntry;
+
+        if (isHDAudioEnabled()) {
+            final BluetoothCodecStatus codecStatus = getBluetoothCodecStatus();
+            if (codecStatus == null) {
+                Log.e(TAG, "updateState: Bluetooth Codec Status is null");
+                return;
+            }
+
+            final BluetoothCodecConfig currentCodecConfig = codecStatus.getCodecConfig();
+            if (currentCodecConfig == null) {
+                Log.e(TAG, "updateState: currentCodecConfig is null");
+                return;
+            }
+
+            final BluetoothA2dp bluetoothA2dp = mBluetoothA2dp;
+            if (bluetoothA2dp == null) {
+                Log.e(TAG, "updateState: bluetoothA2dp is null");
+                return;
+            }
+
+            final Collection<BluetoothCodecType> codecTypes =
+                    bluetoothA2dp.getSupportedCodecTypes();
+            for (BluetoothCodecType codecType : codecTypes) {
+                labels.add(codecType.getCodecName());
+                codecIds.add(String.valueOf(codecType.getCodecId()));
+                if (currentCodecConfig != null
+                        && currentCodecConfig.getExtendedCodecType().equals(codecType)) {
+                    selectedCodecId = codecIds.get(codecIds.size() - 1);
+                    selectedLabel = labels.get(labels.size() - 1);
+                    if (DEBUG) {
+                        Log.d(
+                                TAG,
+                                "updateState: Current config: "
+                                        + selectedLabel
+                                        + ", id: "
+                                        + selectedCodecId);
+                    }
+                }
+            }
+
+            setupListPreference(labels, codecIds, selectedLabel, selectedCodecId);
+        }
+    }
+
+    @Override
+    public void onHDAudioEnabled(boolean enabled) {
+        if (DEBUG) {
+            Log.d(TAG, "onHDAudioEnabled: enabled=" + enabled);
+        }
+        if (mListPreference == null) {
+            Log.e(TAG, "onHDAudioEnabled: List preference is null");
+            return;
+        }
+        mListPreference.setEnabled(enabled);
+    }
+
+    @Override
+    protected void writeConfigurationValues(String entryValue) {
+        long codecIdValue = getCodecIdFromEntryValue(entryValue);
+        BluetoothCodecType selectedCodecType = null;
+        BluetoothCodecConfig selectedCodecConfig = null;
+
+        final BluetoothA2dp bluetoothA2dp = mBluetoothA2dp;
+        if (bluetoothA2dp == null) {
+            Log.e(TAG, "writeConfigurationValues: bluetoothA2dp is null");
+            return;
+        }
+
+        final Collection<BluetoothCodecType> codecTypes = bluetoothA2dp.getSupportedCodecTypes();
+        for (BluetoothCodecType codecType : codecTypes) {
+            if (codecType.getCodecId() == codecIdValue) {
+                selectedCodecType = codecType;
+            }
+        }
+
+        if (selectedCodecType == null) {
+            Log.e(
+                    TAG,
+                    "writeConfigurationValues: No selectable codec ID: "
+                            + codecIdValue
+                            + " found. Unable to change codec");
+            return;
+        }
+
+        if (DEBUG) {
+            Log.d(TAG, "writeConfigurationValues: Selected codec: " + selectedCodecType.toString());
+        }
+        final BluetoothCodecStatus codecStatus = getBluetoothCodecStatus();
+        if (codecStatus == null) {
+            Log.e(TAG, "writeConfigurationValues: Bluetooth Codec Status is null");
+            return;
+        }
+
+        final List<BluetoothCodecConfig> codecConfigs =
+                codecStatus.getCodecsSelectableCapabilities();
+        for (BluetoothCodecConfig config : codecConfigs) {
+            BluetoothCodecType codecType = config.getExtendedCodecType();
+            if (codecType == null) {
+                Log.e(TAG, "codec type for config:" + config + " is null");
+            }
+            if (codecType != null && codecType.equals(selectedCodecType)) {
+                selectedCodecConfig = config;
+            }
+        }
+
+        if (selectedCodecConfig == null) {
+            Log.e(
+                    TAG,
+                    "writeConfigurationValues: No selectable codec config for codec: "
+                            + selectedCodecType.toString());
+            return;
+        }
+
+        if (mBluetoothA2dpConfigStore == null) {
+            Log.e(TAG, "writeConfigurationValues: Bluetooth A2dp Config Store is null");
+            return;
+        }
+
+        mBluetoothA2dpConfigStore.setCodecType(selectedCodecType);
+        mBluetoothA2dpConfigStore.setCodecPriority(BluetoothCodecConfig.CODEC_PRIORITY_HIGHEST);
+        mBluetoothA2dpConfigStore.setSampleRate(
+                AbstractBluetoothDialogPreferenceController.getHighestSampleRate(
+                        selectedCodecConfig));
+        mBluetoothA2dpConfigStore.setBitsPerSample(
+                AbstractBluetoothDialogPreferenceController.getHighestBitsPerSample(
+                        selectedCodecConfig));
+        mBluetoothA2dpConfigStore.setChannelMode(
+                AbstractBluetoothDialogPreferenceController.getHighestChannelMode(
+                        selectedCodecConfig));
+    }
+
+    private long getCodecIdFromEntryValue(String entryValue) {
+        long codecType = BluetoothCodecType.CODEC_ID_SBC;
+        if (entryValue.isEmpty() || Long.valueOf(entryValue) == DEFAULT_VALUE_INT) {
+            return codecType;
+        }
+        return Long.valueOf(entryValue);
+    }
+}

tests/robotests/src/com/android/settings/development/bluetooth/AbstractBluetoothListPreferenceControllerTest.java

@@ -0,0 +1,240 @@
+/*
+ * Copyright (C) 2023 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 com.android.settings.development.bluetooth;
+
+import static android.bluetooth.BluetoothCodecConfig.CODEC_PRIORITY_HIGHEST;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.eq;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import android.bluetooth.BluetoothA2dp;
+import android.bluetooth.BluetoothAdapter;
+import android.bluetooth.BluetoothCodecConfig;
+import android.bluetooth.BluetoothCodecStatus;
+import android.bluetooth.BluetoothDevice;
+import android.bluetooth.BluetoothProfile;
+import android.content.Context;
+
+import androidx.lifecycle.LifecycleOwner;
+import androidx.preference.ListPreference;
+import androidx.preference.PreferenceScreen;
+
+import com.android.settings.R;
+import com.android.settings.development.BluetoothA2dpConfigStore;
+import com.android.settingslib.core.lifecycle.Lifecycle;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.robolectric.RobolectricTestRunner;
+import org.robolectric.RuntimeEnvironment;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+@RunWith(RobolectricTestRunner.class)
+public class AbstractBluetoothListPreferenceControllerTest {
+
+    private static final String DEVICE_ADDRESS = "00:11:22:33:44:55";
+
+    private static String DEFAULT_ENTRY;
+    private static final String DEFAULT_ENTRY_VALUE = "1000";
+
+    @Mock private BluetoothA2dp mBluetoothA2dp;
+    @Mock private BluetoothAdapter mBluetoothAdapter;
+    @Mock private PreferenceScreen mScreen;
+
+    private AbstractBluetoothListPreferenceController mController;
+    private ListPreference mPreference;
+    private BluetoothA2dpConfigStore mBluetoothA2dpConfigStore;
+    private BluetoothCodecStatus mCodecStatus;
+    private BluetoothCodecConfig mCodecConfigAAC;
+    private BluetoothCodecConfig mCodecConfigSBC;
+    private BluetoothCodecConfig[] mCodecConfigs = new BluetoothCodecConfig[2];
+    private BluetoothDevice mActiveDevice;
+    private Context mContext;
+    private LifecycleOwner mLifecycleOwner;
+    private Lifecycle mLifecycle;
+
+    @Before
+    public void setup() {
+        MockitoAnnotations.initMocks(this);
+        mContext = RuntimeEnvironment.application;
+        mLifecycleOwner = () -> mLifecycle;
+        mLifecycle = new Lifecycle(mLifecycleOwner);
+        mBluetoothA2dpConfigStore = spy(new BluetoothA2dpConfigStore());
+        mActiveDevice = BluetoothAdapter.getDefaultAdapter().getRemoteDevice(DEVICE_ADDRESS);
+        mController =
+                spy(
+                        new AbstractBluetoothListPreferenceControllerImpl(
+                                mContext, mLifecycle, mBluetoothA2dpConfigStore));
+        mController.mBluetoothAdapter = mBluetoothAdapter;
+        mPreference = spy(new ListPreference(mContext));
+
+        mCodecConfigAAC =
+                new BluetoothCodecConfig.Builder()
+                        .setCodecType(BluetoothCodecConfig.SOURCE_CODEC_TYPE_AAC)
+                        .build();
+        mCodecConfigSBC =
+                new BluetoothCodecConfig.Builder()
+                        .setCodecType(BluetoothCodecConfig.SOURCE_CODEC_TYPE_SBC)
+                        .build();
+        mCodecConfigs[0] = mCodecConfigAAC;
+        mCodecConfigs[1] = mCodecConfigSBC;
+
+        when(mScreen.findPreference(mController.getPreferenceKey())).thenReturn(mPreference);
+        mController.displayPreference(mScreen);
+        when(mBluetoothAdapter.getActiveDevices(eq(BluetoothProfile.A2DP)))
+                .thenReturn(Arrays.asList(mActiveDevice));
+
+        DEFAULT_ENTRY = mContext.getString(R.string.bluetooth_audio_codec_default_selection);
+    }
+
+    private void verifySetupDefaultListPreference() {
+        List<String> entries = new ArrayList<>(1);
+        entries.add(DEFAULT_ENTRY);
+        List<String> entryValues = new ArrayList<>(1);
+        entryValues.add(DEFAULT_ENTRY_VALUE);
+
+        verify(mPreference).setEntries(entries.toArray(new String[entries.size()]));
+        verify(mPreference).setEntryValues(entryValues.toArray(new String[entryValues.size()]));
+        verify(mPreference).setValue(DEFAULT_ENTRY_VALUE);
+        verify(mPreference).setSummary(DEFAULT_ENTRY);
+    }
+
+    @Test
+    public void onPreferenceChange_shouldSetupDefaultListPreference() {
+        mController.onPreferenceChange(mPreference, "" /* new value */);
+        verifySetupDefaultListPreference();
+    }
+
+    @Test
+    public void setupListPreference_wrongSize_shouldSetupDefaultListPreference() {
+        List<String> entries = new ArrayList<>(1);
+        entries.add(DEFAULT_ENTRY);
+        List<String> entryValues = new ArrayList<>(2);
+        entryValues.add(DEFAULT_ENTRY_VALUE);
+        entryValues.add(DEFAULT_ENTRY_VALUE);
+
+        mController.setupListPreference(entries, entryValues, "", "");
+        verifySetupDefaultListPreference();
+    }
+
+    @Test
+    public void setupListPreference_listEmpty_shouldSetupDefaultListPreference() {
+        List<String> entries = new ArrayList<>(1);
+        entries.add(DEFAULT_ENTRY);
+        List<String> entryValues = new ArrayList<>();
+
+        mController.setupListPreference(entries, entryValues, "", "");
+        verifySetupDefaultListPreference();
+    }
+
+    @Test
+    public void getBluetoothCodecStatus_errorChecking() {
+        mController.onBluetoothServiceConnected(null);
+        assertThat(mController.getBluetoothCodecStatus()).isNull();
+
+        mController.onBluetoothServiceConnected(mBluetoothA2dp);
+
+        when(mBluetoothA2dp.getCodecStatus(mActiveDevice)).thenReturn(null);
+        assertThat(mController.getBluetoothCodecStatus()).isNull();
+    }
+
+    @Test
+    public void getCurrentCodecConfig_errorChecking() {
+        mController.onBluetoothServiceConnected(null);
+        assertThat(mController.getCurrentCodecConfig()).isNull();
+
+        mController.onBluetoothServiceConnected(mBluetoothA2dp);
+        when(mBluetoothA2dp.getCodecStatus(mActiveDevice)).thenReturn(null);
+        assertThat(mController.getCurrentCodecConfig()).isNull();
+    }
+
+    @Test
+    public void getCurrentCodecConfig_verifyConfig() {
+        mCodecStatus = new BluetoothCodecStatus.Builder().setCodecConfig(mCodecConfigAAC).build();
+        when(mBluetoothA2dp.getCodecStatus(mActiveDevice)).thenReturn(mCodecStatus);
+        mController.onBluetoothServiceConnected(mBluetoothA2dp);
+
+        assertThat(mController.getCurrentCodecConfig()).isEqualTo(mCodecConfigAAC);
+    }
+
+    @Test
+    public void isHDAudioEnabled_errorChecking() {
+        mController.onBluetoothServiceConnected(null);
+        assertFalse(mController.isHDAudioEnabled());
+
+        mController.onBluetoothServiceConnected(mBluetoothA2dp);
+        when(mBluetoothA2dp.isOptionalCodecsEnabled(mActiveDevice))
+                .thenReturn(BluetoothA2dp.OPTIONAL_CODECS_PREF_DISABLED);
+        assertFalse(mController.isHDAudioEnabled());
+    }
+
+    @Test
+    public void isHDAudioEnabled_verifyEnabled() {
+        mController.onBluetoothServiceConnected(mBluetoothA2dp);
+        when(mBluetoothA2dp.isOptionalCodecsEnabled(mActiveDevice))
+                .thenReturn(BluetoothA2dp.OPTIONAL_CODECS_PREF_ENABLED);
+        assertTrue(mController.isHDAudioEnabled());
+    }
+
+    @Test
+    public void onBluetoothServiceConnected_verifyBluetoothA2dpConfigStore() {
+        mCodecStatus =
+                new BluetoothCodecStatus.Builder()
+                        .setCodecConfig(mCodecConfigAAC)
+                        .setCodecsSelectableCapabilities(Arrays.asList(mCodecConfigs))
+                        .build();
+        when(mBluetoothA2dp.getCodecStatus(mActiveDevice)).thenReturn(mCodecStatus);
+        mController.onBluetoothServiceConnected(mBluetoothA2dp);
+
+        verify(mBluetoothA2dpConfigStore).setCodecType(mCodecConfigAAC.getExtendedCodecType());
+        verify(mBluetoothA2dpConfigStore).setSampleRate(mCodecConfigAAC.getSampleRate());
+        verify(mBluetoothA2dpConfigStore).setBitsPerSample(mCodecConfigAAC.getBitsPerSample());
+        verify(mBluetoothA2dpConfigStore).setChannelMode(mCodecConfigAAC.getChannelMode());
+        verify(mBluetoothA2dpConfigStore).setCodecPriority(CODEC_PRIORITY_HIGHEST);
+        verify(mBluetoothA2dpConfigStore)
+                .setCodecSpecific1Value(mCodecConfigAAC.getCodecSpecific1());
+    }
+
+    private static class AbstractBluetoothListPreferenceControllerImpl
+            extends AbstractBluetoothListPreferenceController {
+
+        private AbstractBluetoothListPreferenceControllerImpl(
+                Context context, Lifecycle lifecycle, BluetoothA2dpConfigStore store) {
+            super(context, lifecycle, store);
+        }
+
+        @Override
+        public String getPreferenceKey() {
+            return "KEY";
+        }
+
+        @Override
+        protected void writeConfigurationValues(String entryValue) {}
+    }
+}

tests/robotests/src/com/android/settings/development/bluetooth/BluetoothCodecListPreferenceControllerTest.java

@@ -0,0 +1,267 @@
+/*
+ * Copyright (C) 2023 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 com.android.settings.development.bluetooth;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.atLeastOnce;
+import static org.mockito.Mockito.eq;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import android.bluetooth.BluetoothA2dp;
+import android.bluetooth.BluetoothAdapter;
+import android.bluetooth.BluetoothCodecConfig;
+import android.bluetooth.BluetoothCodecStatus;
+import android.bluetooth.BluetoothCodecType;
+import android.bluetooth.BluetoothDevice;
+import android.bluetooth.BluetoothProfile;
+import android.content.Context;
+
+import androidx.lifecycle.LifecycleOwner;
+import androidx.preference.ListPreference;
+import androidx.preference.PreferenceScreen;
+
+import com.android.settings.development.BluetoothA2dpConfigStore;
+import com.android.settingslib.core.lifecycle.Lifecycle;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.robolectric.RobolectricTestRunner;
+import org.robolectric.RuntimeEnvironment;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+@RunWith(RobolectricTestRunner.class)
+public class BluetoothCodecListPreferenceControllerTest {
+
+    private static final String DEVICE_ADDRESS = "00:11:22:33:44:55";
+
+    @Mock private BluetoothA2dp mBluetoothA2dp;
+    @Mock private BluetoothAdapter mBluetoothAdapter;
+    @Mock private PreferenceScreen mScreen;
+    @Mock private AbstractBluetoothPreferenceController.Callback mCallback;
+
+    private BluetoothCodecListPreferenceController mController;
+    private ListPreference mPreference;
+    private BluetoothA2dpConfigStore mBluetoothA2dpConfigStore;
+    private BluetoothCodecStatus mCodecStatus;
+    private BluetoothCodecType mCodecTypeAAC;
+    private BluetoothCodecType mCodecTypeSBC;
+    private BluetoothCodecType mCodecTypeAPTX;
+    private BluetoothCodecType mCodecTypeLDAC;
+    private BluetoothCodecType mCodecTypeOPUS;
+    private List<BluetoothCodecType> mCodecTypes;
+
+    private BluetoothCodecConfig mCodecConfigAAC;
+    private BluetoothCodecConfig mCodecConfigSBC;
+    private BluetoothCodecConfig mCodecConfigAPTX;
+    private BluetoothCodecConfig mCodecConfigAPTXHD;
+    private BluetoothCodecConfig mCodecConfigLDAC;
+    private BluetoothCodecConfig mCodecConfigOPUS;
+    private List<BluetoothCodecConfig> mCodecConfigs;
+    private BluetoothDevice mActiveDevice;
+    private Context mContext;
+    private LifecycleOwner mLifecycleOwner;
+    private Lifecycle mLifecycle;
+
+    @Before
+    public void setup() {
+        MockitoAnnotations.initMocks(this);
+        mContext = RuntimeEnvironment.application;
+        mLifecycleOwner = () -> mLifecycle;
+        mLifecycle = new Lifecycle(mLifecycleOwner);
+        mBluetoothA2dpConfigStore = spy(new BluetoothA2dpConfigStore());
+        mActiveDevice = BluetoothAdapter.getDefaultAdapter().getRemoteDevice(DEVICE_ADDRESS);
+        mController =
+                new BluetoothCodecListPreferenceController(
+                        mContext, mLifecycle, mBluetoothA2dpConfigStore, mCallback);
+        mController.mBluetoothAdapter = mBluetoothAdapter;
+        mPreference = new ListPreference(mContext);
+        when(mScreen.findPreference(mController.getPreferenceKey())).thenReturn(mPreference);
+        mController.displayPreference(mScreen);
+
+        mCodecTypeAAC =
+                BluetoothCodecType.createFromType(BluetoothCodecConfig.SOURCE_CODEC_TYPE_AAC);
+        mCodecTypeSBC =
+                BluetoothCodecType.createFromType(BluetoothCodecConfig.SOURCE_CODEC_TYPE_SBC);
+        mCodecTypeAPTX =
+                BluetoothCodecType.createFromType(BluetoothCodecConfig.SOURCE_CODEC_TYPE_APTX);
+        mCodecTypeLDAC =
+                BluetoothCodecType.createFromType(BluetoothCodecConfig.SOURCE_CODEC_TYPE_LDAC);
+        mCodecTypeOPUS =
+                BluetoothCodecType.createFromType(BluetoothCodecConfig.SOURCE_CODEC_TYPE_OPUS);
+
+        mCodecTypes = new ArrayList<>();
+        mCodecTypes.addAll(
+                Arrays.asList(
+                        mCodecTypeSBC,
+                        mCodecTypeAAC,
+                        mCodecTypeAPTX,
+                        mCodecTypeLDAC,
+                        mCodecTypeOPUS));
+
+        mCodecConfigSBC =
+                new BluetoothCodecConfig.Builder()
+                        .setCodecType(BluetoothCodecConfig.SOURCE_CODEC_TYPE_SBC)
+                        .setCodecPriority(BluetoothCodecConfig.CODEC_PRIORITY_HIGHEST)
+                        .setSampleRate(
+                                BluetoothCodecConfig.SAMPLE_RATE_96000
+                                        | BluetoothCodecConfig.SAMPLE_RATE_176400)
+                        .setBitsPerSample(BluetoothCodecConfig.BITS_PER_SAMPLE_32)
+                        .setChannelMode(
+                                BluetoothCodecConfig.CHANNEL_MODE_MONO
+                                        | BluetoothCodecConfig.CHANNEL_MODE_STEREO)
+                        .build();
+        mCodecConfigAAC =
+                new BluetoothCodecConfig.Builder()
+                        .setCodecType(BluetoothCodecConfig.SOURCE_CODEC_TYPE_AAC)
+                        .setCodecPriority(BluetoothCodecConfig.CODEC_PRIORITY_HIGHEST)
+                        .setSampleRate(
+                                BluetoothCodecConfig.SAMPLE_RATE_48000
+                                        | BluetoothCodecConfig.SAMPLE_RATE_88200)
+                        .setBitsPerSample(
+                                BluetoothCodecConfig.BITS_PER_SAMPLE_16
+                                        | BluetoothCodecConfig.BITS_PER_SAMPLE_24)
+                        .setChannelMode(BluetoothCodecConfig.CHANNEL_MODE_STEREO)
+                        .build();
+        mCodecConfigAPTX =
+                new BluetoothCodecConfig.Builder()
+                        .setCodecType(BluetoothCodecConfig.SOURCE_CODEC_TYPE_APTX)
+                        .build();
+        mCodecConfigAPTXHD =
+                new BluetoothCodecConfig.Builder()
+                        .setCodecType(BluetoothCodecConfig.SOURCE_CODEC_TYPE_APTX_HD)
+                        .build();
+        mCodecConfigLDAC =
+                new BluetoothCodecConfig.Builder()
+                        .setCodecType(BluetoothCodecConfig.SOURCE_CODEC_TYPE_LDAC)
+                        .build();
+        mCodecConfigOPUS =
+                new BluetoothCodecConfig.Builder()
+                        .setCodecType(BluetoothCodecConfig.SOURCE_CODEC_TYPE_OPUS)
+                        .build();
+
+        mCodecConfigs = new ArrayList<>();
+        mCodecConfigs.addAll(
+                Arrays.asList(
+                        mCodecConfigOPUS,
+                        mCodecConfigAAC,
+                        mCodecConfigSBC,
+                        mCodecConfigAPTX,
+                        mCodecConfigAPTXHD,
+                        mCodecConfigLDAC));
+
+        when(mBluetoothAdapter.getActiveDevices(eq(BluetoothProfile.A2DP)))
+                .thenReturn(Arrays.asList(mActiveDevice));
+        when(mBluetoothA2dp.getSupportedCodecTypes()).thenReturn(mCodecTypes);
+    }
+
+    @Test
+    public void writeConfigurationValues_selectDefault() {
+        mCodecStatus =
+                new BluetoothCodecStatus.Builder()
+                        .setCodecConfig(mCodecConfigSBC)
+                        .setCodecsSelectableCapabilities(mCodecConfigs)
+                        .build();
+        when(mBluetoothA2dp.getCodecStatus(mActiveDevice)).thenReturn(mCodecStatus);
+        when(mBluetoothA2dp.isOptionalCodecsEnabled(mActiveDevice))
+                .thenReturn(BluetoothA2dp.OPTIONAL_CODECS_PREF_ENABLED);
+
+        mController.onBluetoothServiceConnected(mBluetoothA2dp);
+
+        mController.writeConfigurationValues(String.valueOf(mController.DEFAULT_VALUE_INT));
+        verify(mBluetoothA2dpConfigStore, times(2)).setCodecType(mCodecTypeSBC);
+    }
+
+    @Test
+    public void writeConfigurationValues_checkCodec() {
+        mCodecStatus =
+                new BluetoothCodecStatus.Builder()
+                        .setCodecConfig(mCodecConfigSBC)
+                        .setCodecsSelectableCapabilities(mCodecConfigs)
+                        .build();
+        when(mBluetoothA2dp.getCodecStatus(mActiveDevice)).thenReturn(mCodecStatus);
+        mController.onBluetoothServiceConnected(mBluetoothA2dp);
+
+        mController.writeConfigurationValues(String.valueOf(mCodecTypeSBC.getCodecId()));
+        verify(mBluetoothA2dpConfigStore, atLeastOnce()).setCodecType(mCodecTypeSBC);
+
+        mController.writeConfigurationValues(String.valueOf(mCodecTypeAAC.getCodecId()));
+        verify(mBluetoothA2dpConfigStore).setCodecType(mCodecTypeAAC);
+
+        mController.writeConfigurationValues(String.valueOf(mCodecTypeAPTX.getCodecId()));
+        verify(mBluetoothA2dpConfigStore).setCodecType(mCodecTypeAPTX);
+
+        mController.writeConfigurationValues(String.valueOf(mCodecTypeLDAC.getCodecId()));
+        verify(mBluetoothA2dpConfigStore).setCodecType(mCodecTypeLDAC);
+
+        mController.writeConfigurationValues(String.valueOf(mCodecTypeOPUS.getCodecId()));
+        verify(mBluetoothA2dpConfigStore).setCodecType(mCodecTypeOPUS);
+    }
+
+    @Test
+    public void writeConfigurationValues_chooseHighestConfig() {
+        mCodecStatus =
+                new BluetoothCodecStatus.Builder()
+                        .setCodecConfig(mCodecConfigSBC)
+                        .setCodecsSelectableCapabilities((mCodecConfigs))
+                        .build();
+        when(mBluetoothA2dp.getCodecStatus(mActiveDevice)).thenReturn(mCodecStatus);
+        mController.onBluetoothServiceConnected(mBluetoothA2dp);
+        mController.writeConfigurationValues(String.valueOf(mCodecTypeAAC.getCodecId()));
+
+        verify(mBluetoothA2dpConfigStore, atLeastOnce())
+                .setCodecPriority(BluetoothCodecConfig.CODEC_PRIORITY_HIGHEST);
+        verify(mBluetoothA2dpConfigStore, atLeastOnce())
+                .setSampleRate(BluetoothCodecConfig.SAMPLE_RATE_88200);
+        verify(mBluetoothA2dpConfigStore, atLeastOnce())
+                .setBitsPerSample(BluetoothCodecConfig.BITS_PER_SAMPLE_24);
+        verify(mBluetoothA2dpConfigStore, atLeastOnce())
+                .setChannelMode(BluetoothCodecConfig.CHANNEL_MODE_STEREO);
+    }
+
+    @Test
+    public void onPreferenceChange_notifyPreference() {
+        assertFalse(
+                mController.onPreferenceChange(
+                        mPreference, String.valueOf(mCodecTypeAAC.getCodecId())));
+
+        mController.onBluetoothServiceConnected(mBluetoothA2dp);
+
+        assertTrue(
+                mController.onPreferenceChange(
+                        mPreference, String.valueOf(mCodecTypeAAC.getCodecId())));
+
+        verify(mCallback).onBluetoothCodecChanged();
+    }
+
+    @Test
+    public void onHDAudioEnabled_setsPreferenceEnabled() {
+        mController.onHDAudioEnabled(/* enabled= */ true);
+        assertThat(mPreference.isEnabled()).isTrue();
+    }
+}