Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 0d37dad0 authored by Jeffrey Huang's avatar Jeffrey Huang Committed by Android (Google) Code Review
Browse files

Merge changes Ie94273c2,Ib9230336 

* changes:
  Introduce AbstractBluetoothA2dpPreferenceCtrl
  Refactor A2dpStore to be a non-static object
parents 5345e0bd 027da329

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

0 → 100644
+214 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2017 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;



import android.bluetooth.BluetoothA2dp;

import android.bluetooth.BluetoothCodecConfig;

import android.content.Context;

import android.support.annotation.VisibleForTesting;

import android.support.v7.preference.ListPreference;

import android.support.v7.preference.Preference;

import android.support.v7.preference.PreferenceScreen;



import com.android.settings.R;

import com.android.settings.core.PreferenceControllerMixin;

import com.android.settingslib.core.lifecycle.Lifecycle;

import com.android.settingslib.core.lifecycle.LifecycleObserver;

import com.android.settingslib.core.lifecycle.events.OnDestroy;

import com.android.settingslib.development.DeveloperOptionsPreferenceController;



public abstract class AbstractBluetoothA2dpPreferenceController extends

        DeveloperOptionsPreferenceController implements Preference.OnPreferenceChangeListener,

        PreferenceControllerMixin, BluetoothServiceConnectionListener, LifecycleObserver,

        OnDestroy {



    @VisibleForTesting

    static final int STREAMING_LABEL_ID = R.string.bluetooth_select_a2dp_codec_streaming_label;



    protected final BluetoothA2dpConfigStore mBluetoothA2dpConfigStore;

    protected final Object mBluetoothA2dpLock;

    protected BluetoothA2dp mBluetoothA2dp;

    private final String[] mListValues;

    private final String[] mListSummaries;

    private ListPreference mPreference;



    public AbstractBluetoothA2dpPreferenceController(Context context, Lifecycle lifecycle,

            Object bluetoothA2dpLock, BluetoothA2dpConfigStore store) {

        super(context);



        mBluetoothA2dpLock = bluetoothA2dpLock;

        mBluetoothA2dpConfigStore = store;

        mListValues = getListValues();

        mListSummaries = getListSummaries();



        if (lifecycle != null) {

            lifecycle.addObserver(this);

        }

    }



    @Override

    public void displayPreference(PreferenceScreen screen) {

        super.displayPreference(screen);



        mPreference = (ListPreference) screen.findPreference(getPreferenceKey());



        // Set a default value because BluetoothCodecConfig is null initially.

        mPreference.setValue(mListValues[getDefaultIndex()]);

        mPreference.setSummary(mListSummaries[getDefaultIndex()]);

    }



    @Override

    public boolean onPreferenceChange(Preference preference, Object newValue) {

        if (mBluetoothA2dp == null) {

            return false;

        }



        writeConfigurationValues(newValue);



        final BluetoothCodecConfig codecConfig = mBluetoothA2dpConfigStore.createCodecConfig();

        synchronized (mBluetoothA2dpLock) {

            if (mBluetoothA2dp != null) {

                setCodecConfigPreference(codecConfig);

            }

        }

        // Because the setting is not persisted into permanent storage, we cannot call update state

        // here to update the preference.

        // Instead, we just assume it was set and update the preference here.

        final int index = mPreference.findIndexOfValue(newValue.toString());

        // We only want to append "Streaming" if not using default

        if (index == getDefaultIndex()) {

            mPreference.setSummary(mListSummaries[index]);

        } else {

            mPreference.setSummary(

                    mContext.getResources().getString(STREAMING_LABEL_ID, mListSummaries[index]));

        }

        return true;

    }



    @Override

    public void updateState(Preference preference) {

        if (getCodecConfig() == null || mPreference == null) {

            return;

        }



        BluetoothCodecConfig codecConfig;

        synchronized (mBluetoothA2dpLock) {

            codecConfig = getCodecConfig();

        }



        final int index = getCurrentA2dpSettingIndex(codecConfig);

        mPreference.setValue(mListValues[index]);



        // We only want to append "Streaming" if not using default

        if (index == getDefaultIndex()) {

            mPreference.setSummary(mListSummaries[index]);

        } else {

            mPreference.setSummary(

                    mContext.getResources().getString(STREAMING_LABEL_ID, mListSummaries[index]));

        }



        writeConfigurationValues(mListValues[index]);

    }



    @Override

    public void onBluetoothServiceConnected(BluetoothA2dp bluetoothA2dp) {

        mBluetoothA2dp = bluetoothA2dp;

        updateState(mPreference);

    }



    @Override

    public void onBluetoothCodecUpdated() {

        // intentional no-op

        // We do not want to call update state here because the setting is not persisted in

        // permanent storage.

    }



    @Override

    public void onBluetoothServiceDisconnected() {

        mBluetoothA2dp = null;

    }



    @Override

    public void onDestroy() {

        mBluetoothA2dp = null;

    }



    @Override

    protected void onDeveloperOptionsSwitchEnabled() {

        mPreference.setEnabled(true);

    }



    @Override

    protected void onDeveloperOptionsSwitchDisabled() {

        mPreference.setEnabled(false);

    }



    /**

     * @return an array of string values that correspond to the current {@link ListPreference}.

     */

    protected abstract String[] getListValues();



    /**

     * @return an array of string summaries that correspond to the current {@link ListPreference}.

     */

    protected abstract String[] getListSummaries();



    /**

     * Updates the new value to the {@link BluetoothA2dpConfigStore}.

     *

     * @param newValue the new setting value

     */

    protected abstract void writeConfigurationValues(Object newValue);



    /**

     * @return the current selected index for the {@link ListPreference}.

     */

    protected abstract int getCurrentA2dpSettingIndex(BluetoothCodecConfig config);



    /**

     * @return default setting index for the {@link ListPreference}.

     */

    protected abstract int getDefaultIndex();



    @VisibleForTesting

    void setCodecConfigPreference(BluetoothCodecConfig config) {

        mBluetoothA2dp.setCodecConfigPreference(config);

    }



    @VisibleForTesting

    BluetoothCodecConfig getCodecConfig() {

        if (mBluetoothA2dp == null || mBluetoothA2dp.getCodecStatus() == null) {

            return null;

        }



        return mBluetoothA2dp.getCodecStatus().getCodecConfig();

    }



    @VisibleForTesting

    BluetoothCodecConfig createCodecConfig(int codecTypeValue, int codecPriorityValue,

            int sampleRateValue, int bitsPerSampleValue,

            int channelModeValue, long codecSpecific1Value,

            long codecSpecific2Value, long codecSpecific3Value,

            long codecSpecific4Value) {

        return new BluetoothCodecConfig(codecTypeValue, codecPriorityValue,

                sampleRateValue, bitsPerSampleValue,

                channelModeValue, codecSpecific1Value,

                codecSpecific2Value, codecSpecific3Value,

                codecSpecific4Value);

    }



}

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

0 → 100644
+80 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2017 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;



import android.bluetooth.BluetoothCodecConfig;



/**

 * 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 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 mCodecSpecific1Value;

    private long mCodecSpecific2Value;

    private long mCodecSpecific3Value;

    private long mCodecSpecific4Value;



    public void setCodecType(int codecType) {

        mCodecType = codecType;

    }



    public void setCodecPriority(int codecPriority) {

        mCodecPriority = codecPriority;

    }



    public void setSampleRate(int sampleRate) {

        mSampleRate = sampleRate;

    }



    public void setBitsPerSample(int bitsPerSample) {

        mBitsPerSample = bitsPerSample;

    }



    public void setChannelMode(int channelMode) {

        mChannelMode = channelMode;

    }



    public void setCodecSpecific1Value(int codecSpecific1Value) {

        mCodecSpecific1Value = codecSpecific1Value;

    }



    public void setCodecSpecific2Value(int codecSpecific2Value) {

        mCodecSpecific2Value = codecSpecific2Value;

    }



    public void setCodecSpecific3Value(int codecSpecific3Value) {

        mCodecSpecific3Value = codecSpecific3Value;

    }



    public void setCodecSpecific4Value(int codecSpecific4Value) {

        mCodecSpecific4Value = codecSpecific4Value;

    }



    public BluetoothCodecConfig createCodecConfig() {

        return new BluetoothCodecConfig(mCodecType, mCodecPriority,

                mSampleRate, mBitsPerSample,

                mChannelMode, mCodecSpecific1Value,

                mCodecSpecific2Value, mCodecSpecific3Value,

                mCodecSpecific4Value);

    }

}

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

deleted100644 → 0
+0 −108
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2017 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;



import android.bluetooth.BluetoothCodecConfig;



/**

 * Utility class for storing current Bluetooth A2DP profile values

 */

public class BluetoothA2dpSharedStore {



    // init default values

    private static int sCodecType = BluetoothCodecConfig.SOURCE_CODEC_TYPE_INVALID;

    private static int sCodecPriority = BluetoothCodecConfig.CODEC_PRIORITY_DEFAULT;

    private static int sSampleRate = BluetoothCodecConfig.SAMPLE_RATE_NONE;

    private static int sBitsPerSample = BluetoothCodecConfig.BITS_PER_SAMPLE_NONE;

    private static int sChannelMode = BluetoothCodecConfig.CHANNEL_MODE_NONE;

    private static long sCodecSpecific1Value = 0;

    private static long sCodecSpecific2Value = 0;

    private static long sCodecSpecific3Value = 0;

    private static long sCodecSpecific4Value = 0;



    public static int getCodecType() {

        return sCodecType;

    }



    public static int getCodecPriority() {

        return sCodecPriority;

    }



    public static int getSampleRate() {

        return sSampleRate;

    }



    public static int getBitsPerSample() {

        return sBitsPerSample;

    }



    public static int getChannelMode() {

        return sChannelMode;

    }



    public static long getCodecSpecific1Value() {

        return sCodecSpecific1Value;

    }



    public static long getCodecSpecific2Value() {

        return sCodecSpecific2Value;

    }



    public static long getCodecSpecific3Value() {

        return sCodecSpecific3Value;

    }



    public static long getCodecSpecific4Value() {

        return sCodecSpecific4Value;

    }



    public static void setCodecType(int codecType) {

        sCodecType = codecType;

    }



    public static void setCodecPriority(int codecPriority) {

        sCodecPriority = codecPriority;

    }



    public static void setSampleRate(int sampleRate) {

        sSampleRate = sampleRate;

    }



    public static void setBitsPerSample(int bitsPerSample) {

        sBitsPerSample = bitsPerSample;

    }



    public static void setChannelMode(int channelMode) {

        sChannelMode = channelMode;

    }



    public static void setCodecSpecific1Value(int codecSpecific1Value) {

        sCodecSpecific1Value = codecSpecific1Value;

    }



    public static void setCodecSpecific2Value(int codecSpecific2Value) {

        sCodecSpecific2Value = codecSpecific2Value;

    }



    public static void setCodecSpecific3Value(int codecSpecific3Value) {

        sCodecSpecific3Value = codecSpecific3Value;

    }



    public static void setCodecSpecific4Value(int codecSpecific4Value) {

        sCodecSpecific4Value = codecSpecific4Value;

    }

}

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

+38 −160
Original line number Diff line number Diff line
@@ -16,53 +16,27 @@ 


package com.android.settings.development;



import android.bluetooth.BluetoothA2dp;

import android.bluetooth.BluetoothCodecConfig;

import android.content.Context;

import android.support.annotation.VisibleForTesting;

import android.support.v7.preference.ListPreference;

import android.support.v7.preference.Preference;

import android.support.v7.preference.PreferenceScreen;



import com.android.settings.R;

import com.android.settings.core.PreferenceControllerMixin;

import com.android.settingslib.core.lifecycle.Lifecycle;

import com.android.settingslib.core.lifecycle.LifecycleObserver;

import com.android.settingslib.core.lifecycle.events.OnDestroy;

import com.android.settingslib.development.DeveloperOptionsPreferenceController;



public class BluetoothAudioSampleRatePreferenceController extends

        DeveloperOptionsPreferenceController implements Preference.OnPreferenceChangeListener,

        PreferenceControllerMixin, BluetoothServiceConnectionListener, LifecycleObserver,

        OnDestroy {

        AbstractBluetoothA2dpPreferenceController {



    private static final int DEFAULT_INDEX = 0;

    private static final String BLUETOOTH_SELECT_A2DP_SAMPLE_RATE_KEY =

            "bluetooth_select_a2dp_sample_rate";



    @VisibleForTesting

    static final int STREAMING_LABEL_ID = R.string.bluetooth_select_a2dp_codec_streaming_label;



    private final String[] mListValues;

    private final String[] mListSummaries;

    private final Object mBluetoothA2dpLock;

    private ListPreference mPreference;

    private BluetoothA2dp mBluetoothA2dp;



    public BluetoothAudioSampleRatePreferenceController(Context context, Lifecycle lifecycle,

            Object bluetoothA2dpLock) {

        super(context);



        mBluetoothA2dpLock = bluetoothA2dpLock;

        mListValues = context.getResources().getStringArray(

                R.array.bluetooth_a2dp_codec_sample_rate_values);

        mListSummaries = context.getResources().getStringArray(

                R.array.bluetooth_a2dp_codec_sample_rate_summaries);



        if (lifecycle != null) {

            lifecycle.addObserver(this);

            Object bluetoothA2dpLock, BluetoothA2dpConfigStore store) {

        super(context, lifecycle, bluetoothA2dpLock, store);

    }

    }





    @Override

    public String getPreferenceKey() {
@@ -77,94 +51,52 @@ public class BluetoothAudioSampleRatePreferenceController extends 
    }



    @Override

    public boolean onPreferenceChange(Preference preference, Object newValue) {

        if (mBluetoothA2dp == null) {

            return false;

        }



        final int sampleRate = mapPreferenceValueToSampleRate(newValue.toString());

        BluetoothA2dpSharedStore.setSampleRate(sampleRate);



        final int codecTypeValue = BluetoothA2dpSharedStore.getCodecType();

        final int codecPriorityValue = BluetoothA2dpSharedStore.getCodecPriority();

        final int sampleRateValue = BluetoothA2dpSharedStore.getSampleRate();

        final int bitsPerSampleValue = BluetoothA2dpSharedStore.getBitsPerSample();

        final int channelModeValue = BluetoothA2dpSharedStore.getChannelMode();

        final long codecSpecific1Value = BluetoothA2dpSharedStore.getCodecSpecific1Value();

        final long codecSpecific2Value = BluetoothA2dpSharedStore.getCodecSpecific2Value();

        final long codecSpecific3Value = BluetoothA2dpSharedStore.getCodecSpecific3Value();

        final long codecSpecific4Value = BluetoothA2dpSharedStore.getCodecSpecific4Value();



        // get values from shared store

        BluetoothCodecConfig codecConfig = createCodecConfig(codecTypeValue, codecPriorityValue,

                sampleRateValue, bitsPerSampleValue,

                channelModeValue, codecSpecific1Value,

                codecSpecific2Value, codecSpecific3Value,

                codecSpecific4Value);



        synchronized (mBluetoothA2dpLock) {

            if (mBluetoothA2dp != null) {

                setCodecConfigPreference(codecConfig);

            }

        }

        updateState(mPreference);

        return true;

    }



    @Override

    public void updateState(Preference preference) {

        if (getCodecConfig() == null || mPreference == null) {

            return;

        }



        BluetoothCodecConfig codecConfig;

        synchronized (mBluetoothA2dpLock) {

            codecConfig = getCodecConfig();

        }

        final int sampleRate = codecConfig.getSampleRate();

        final int index = mapSampleRateToIndex(sampleRate);



        mPreference.setValue(mListValues[index]);

        mPreference.setSummary(

                mContext.getResources().getString(STREAMING_LABEL_ID, mListSummaries[index]));



        // write value to shared store

        BluetoothA2dpSharedStore.setSampleRate(sampleRate);

    }



    @Override

    public void onBluetoothServiceConnected(BluetoothA2dp bluetoothA2dp) {

        mBluetoothA2dp = bluetoothA2dp;

        updateState(mPreference);

    protected String[] getListValues() {

        return mContext.getResources().getStringArray(

                R.array.bluetooth_a2dp_codec_sample_rate_values);

    }



    @Override

    public void onBluetoothCodecUpdated() {

        updateState(mPreference);

    protected String[] getListSummaries() {

        return mContext.getResources().getStringArray(

                R.array.bluetooth_a2dp_codec_sample_rate_summaries);

    }



    @Override

    public void onBluetoothServiceDisconnected() {

        mBluetoothA2dp = null;

    protected int getDefaultIndex() {

        return DEFAULT_INDEX;

    }



    @Override

    public void onDestroy() {

        mBluetoothA2dp = null;

    protected void writeConfigurationValues(Object newValue) {

        final int index = mPreference.findIndexOfValue(newValue.toString());

        int sampleRateValue = BluetoothCodecConfig.SAMPLE_RATE_NONE; // default

        switch (index) {

            case 0:

                sampleRateValue = BluetoothCodecConfig.SAMPLE_RATE_NONE;

                break;

            case 1:

                sampleRateValue = BluetoothCodecConfig.SAMPLE_RATE_44100;

                break;

            case 2:

                sampleRateValue = BluetoothCodecConfig.SAMPLE_RATE_48000;

                break;

            case 3:

                sampleRateValue = BluetoothCodecConfig.SAMPLE_RATE_88200;

                break;

            case 4:

                sampleRateValue = BluetoothCodecConfig.SAMPLE_RATE_96000;

                break;

            default:

                break;

        }



    @Override

    protected void onDeveloperOptionsSwitchEnabled() {

        mPreference.setEnabled(true);

        mBluetoothA2dpConfigStore.setSampleRate(sampleRateValue);

    }



    @Override

    protected void onDeveloperOptionsSwitchDisabled() {

        mPreference.setEnabled(false);

    }



    private int mapSampleRateToIndex(int sampleRate) {

        int index = 0;

    protected int getCurrentA2dpSettingIndex(BluetoothCodecConfig config) {

        final int sampleRate = config.getSampleRate();

        int index = DEFAULT_INDEX;

        switch (sampleRate) {

            case BluetoothCodecConfig.SAMPLE_RATE_44100:

                index = 1;
@@ -186,58 +118,4 @@ public class BluetoothAudioSampleRatePreferenceController extends 
        }

        return index;

    }



    private int mapPreferenceValueToSampleRate(String value) {

        final int index = mPreference.findIndexOfValue(value);

        int sampleRateValue = 0;

        switch (index) {

            case 0:

                // Reset to default

                sampleRateValue = BluetoothCodecConfig.SAMPLE_RATE_NONE;

                break;

            case 1:

                sampleRateValue = BluetoothCodecConfig.SAMPLE_RATE_44100;

                break;

            case 2:

                sampleRateValue = BluetoothCodecConfig.SAMPLE_RATE_48000;

                break;

            case 3:

                sampleRateValue = BluetoothCodecConfig.SAMPLE_RATE_88200;

                break;

            case 4:

                sampleRateValue = BluetoothCodecConfig.SAMPLE_RATE_96000;

                break;

            default:

                break;

        }

        return sampleRateValue;

    }



    @VisibleForTesting

    void setCodecConfigPreference(BluetoothCodecConfig config) {

        mBluetoothA2dp.setCodecConfigPreference(config);

    }



    @VisibleForTesting

    BluetoothCodecConfig getCodecConfig() {

        if (mBluetoothA2dp == null || mBluetoothA2dp.getCodecStatus() == null) {

            return null;

        }



        return mBluetoothA2dp.getCodecStatus().getCodecConfig();

    }



    @VisibleForTesting

    BluetoothCodecConfig createCodecConfig(int codecTypeValue, int codecPriorityValue,

            int sampleRateValue, int bitsPerSampleValue,

            int channelModeValue, long codecSpecific1Value,

            long codecSpecific2Value, long codecSpecific3Value,

            long codecSpecific4Value) {

        return new BluetoothCodecConfig(codecTypeValue, codecPriorityValue,

                sampleRateValue, bitsPerSampleValue,

                channelModeValue, codecSpecific1Value,

                codecSpecific2Value, codecSpecific3Value,

                codecSpecific4Value);

    }



}

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

+7 −5
Original line number Diff line number Diff line
@@ -298,7 +298,8 @@ public class DevelopmentSettingsDashboardFragment extends RestrictedDashboardFra 
    @Override

    protected List<AbstractPreferenceController> getPreferenceControllers(Context context) {

        mPreferenceControllers = buildPreferenceControllers(context, getActivity(), getLifecycle(),

                this /* devOptionsDashboardFragment */, mBluetoothA2dpLock);

                this /* devOptionsDashboardFragment */, mBluetoothA2dpLock,

                new BluetoothA2dpConfigStore());

        return mPreferenceControllers;

    }
@@ -333,7 +334,7 @@ public class DevelopmentSettingsDashboardFragment extends RestrictedDashboardFra 


    private static List<AbstractPreferenceController> buildPreferenceControllers(Context context,

            Activity activity, Lifecycle lifecycle, DevelopmentSettingsDashboardFragment fragment,

            Object bluetoothA2dpLock) {

            Object bluetoothA2dpLock, BluetoothA2dpConfigStore bluetoothA2dpConfigStore) {

        final List<AbstractPreferenceController> controllers = new ArrayList<>();

        controllers.add(new BugReportPreferenceControllerV2(context));

        controllers.add(new LocalBackupPasswordPreferenceController(context));
@@ -375,9 +376,10 @@ public class DevelopmentSettingsDashboardFragment extends RestrictedDashboardFra 
        controllers.add(new BluetoothAbsoluteVolumePreferenceController(context));

        controllers.add(new BluetoothInbandRingingPreferenceController(context));

        controllers.add(new BluetoothAvrcpVersionPreferenceController(context));

        // bluetooth audio codec

        //controllers.add(new BluetoothAudioCodecPreferenceController(context, lifecycle,

        //        bluetoothA2dpLock, bluetoothA2dpConfigStore));

        controllers.add(new BluetoothAudioSampleRatePreferenceController(context, lifecycle,

                bluetoothA2dpLock));

                bluetoothA2dpLock, bluetoothA2dpConfigStore));

        // bluetooth audio bits per sample

        // bluetooth audio channel mode

        // bluetooth audio ldac codec: playback quality
@@ -445,7 +447,7 @@ public class DevelopmentSettingsDashboardFragment extends RestrictedDashboardFra 
                        context) {

                    return buildPreferenceControllers(context, null /* activity */,

                            null /* lifecycle */, null /* devOptionsDashboardFragment */,

                            null /* bluetoothA2dpLock */);

                            null /* bluetoothA2dpLock */, null /* bluetoothA2dpConfigStore */);

                }

            };

}