Merge changes Ie94273c2,Ib9230336

* changes:
  Introduce AbstractBluetoothA2dpPreferenceCtrl
  Refactor A2dpStore to be a non-static object

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

@@ -0,0 +1,214 @@
+/*
+ * 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,0 +1,80 @@
+/*
+ * 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

@@ -1,108 +0,0 @@
-/*
- * 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

@@ -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,
+        AbstractBluetoothA2dpPreferenceController {
-        PreferenceControllerMixin, BluetoothServiceConnectionListener, LifecycleObserver,
-        OnDestroy {
 
+    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) {
+            Object bluetoothA2dpLock, BluetoothA2dpConfigStore store) {
-        super(context);
+        super(context, lifecycle, bluetoothA2dpLock, store);
-
-        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);
     }
-    }
-
 
     @Override
     public String getPreferenceKey() {
@@ -77,94 +51,52 @@ public class BluetoothAudioSampleRatePreferenceController extends
     }
 
     @Override
-    public boolean onPreferenceChange(Preference preference, Object newValue) {
+    protected String[] getListValues() {
-        if (mBluetoothA2dp == null) {
+        return mContext.getResources().getStringArray(
-            return false;
+                R.array.bluetooth_a2dp_codec_sample_rate_values);
-        }
-
-        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) {
+    protected String[] getListSummaries() {
-        if (getCodecConfig() == null || mPreference == null) {
+        return mContext.getResources().getStringArray(
-            return;
+                R.array.bluetooth_a2dp_codec_sample_rate_summaries);
-        }
-
-        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) {
+    protected int getDefaultIndex() {
-        mBluetoothA2dp = bluetoothA2dp;
+        return DEFAULT_INDEX;
-        updateState(mPreference);
     }
 
     @Override
-    public void onBluetoothCodecUpdated() {
+    protected void writeConfigurationValues(Object newValue) {
-        updateState(mPreference);
+        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;
+        }
+        mBluetoothA2dpConfigStore.setSampleRate(sampleRateValue);
     }
 
     @Override
-    public void onBluetoothServiceDisconnected() {
+    protected int getCurrentA2dpSettingIndex(BluetoothCodecConfig config) {
-        mBluetoothA2dp = null;
+        final int sampleRate = config.getSampleRate();
-    }
+        int index = DEFAULT_INDEX;
-
-    @Override
-    public void onDestroy() {
-        mBluetoothA2dp = null;
-    }
-
-    @Override
-    protected void onDeveloperOptionsSwitchEnabled() {
-        mPreference.setEnabled(true);
-    }
-
-    @Override
-    protected void onDeveloperOptionsSwitchDisabled() {
-        mPreference.setEnabled(false);
-    }
-
-    private int mapSampleRateToIndex(int sampleRate) {
-        int index = 0;
         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

@@ -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 */);
                 }
             };
 }

tests/robotests/src/com/android/settings/development/AbstractBluetoothA2dpPreferenceControllerTest.java

@@ -0,0 +1,175 @@
+/*
+ * 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 static com.android.settings.development.AbstractBluetoothA2dpPreferenceController
+        .STREAMING_LABEL_ID;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.anyLong;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.never;
+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.BluetoothCodecConfig;
+import android.content.Context;
+import android.support.v7.preference.ListPreference;
+import android.support.v7.preference.PreferenceScreen;
+
+import com.android.settings.TestConfig;
+import com.android.settings.testutils.SettingsRobolectricTestRunner;
+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.RuntimeEnvironment;
+import org.robolectric.annotation.Config;
+
+@RunWith(SettingsRobolectricTestRunner.class)
+@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)
+public class AbstractBluetoothA2dpPreferenceControllerTest {
+
+    @Mock
+    private BluetoothA2dp mBluetoothA2dp;
+    @Mock
+    private BluetoothCodecConfig mBluetoothCodecConfig;
+    @Mock
+    private ListPreference mPreference;
+    @Mock
+    private PreferenceScreen mScreen;
+    @Mock
+    private BluetoothA2dpConfigStore mBluetoothA2dpConfigStore;
+
+    private Lifecycle mLifecycle;
+    private Context mContext;
+    private AbstractBluetoothA2dpPreferenceController mController;
+
+    @Before
+    public void setup() {
+        MockitoAnnotations.initMocks(this);
+        mContext = RuntimeEnvironment.application;
+        mLifecycle = new Lifecycle();
+        mController = spy(new AbstractBluetoothA2dpPreferenceControllerImpl(mContext, mLifecycle,
+                new Object(), mBluetoothA2dpConfigStore));
+        doReturn(mBluetoothCodecConfig).when(mController).getCodecConfig();
+        doNothing().when(mController).setCodecConfigPreference(any());
+        when(mBluetoothA2dpConfigStore.createCodecConfig()).thenReturn(mBluetoothCodecConfig);
+        when(mScreen.findPreference(mController.getPreferenceKey())).thenReturn(mPreference);
+        mController.displayPreference(mScreen);
+    }
+
+    @Test
+    public void onPreferenceChange_bluetoothConnected_shouldUpdateCodec() {
+        mController.onBluetoothServiceConnected(mBluetoothA2dp);
+
+        mController.onPreferenceChange(mPreference, "" /* new value */);
+
+        verify(mController).setCodecConfigPreference(any());
+    }
+
+    @Test
+    public void onPreferenceChange_bluetoothNotConnected_shouldNotUpdateCodec() {
+        mController.onBluetoothServiceDisconnected();
+
+        mController.onPreferenceChange(mPreference, "" /* new value */);
+
+        verify(mController, never()).setCodecConfigPreference(any());
+    }
+
+    @Test
+    public void updateState_option2Set_shouldUpdateToOption2() {
+        when(mBluetoothCodecConfig.getSampleRate()).thenReturn(
+                BluetoothCodecConfig.SAMPLE_RATE_48000);
+
+        doReturn(2).when(mController).getCurrentA2dpSettingIndex(any());
+        mController.updateState(mPreference);
+
+        verify(mPreference).setValue(mController.getListValues()[2]);
+        verify(mPreference).setSummary(mContext.getResources().getString(STREAMING_LABEL_ID,
+                mController.getListSummaries()[2]));
+    }
+
+    @Test
+    public void onBluetoothServiceConnected_shouldUpdateState() {
+        mController.onBluetoothServiceConnected(mBluetoothA2dp);
+
+        verify(mController).updateState(mPreference);
+    }
+
+    @Test
+    public void onDeveloperOptionsSwitchEnabled_shouldEnablePreference() {
+        mController.onDeveloperOptionsSwitchEnabled();
+
+        verify(mPreference).setEnabled(true);
+    }
+
+    @Test
+    public void onDeveloperOptionsSwitchDisabled_shouldDisablePreference() {
+        mController.onDeveloperOptionsSwitchDisabled();
+
+        verify(mPreference).setEnabled(false);
+    }
+
+    static class AbstractBluetoothA2dpPreferenceControllerImpl extends
+            AbstractBluetoothA2dpPreferenceController {
+
+        public AbstractBluetoothA2dpPreferenceControllerImpl(Context context,
+                Lifecycle lifecycle, Object bluetoothA2dpLock, BluetoothA2dpConfigStore store) {
+            super(context, lifecycle, bluetoothA2dpLock, store);
+        }
+
+        @Override
+        public String getPreferenceKey() {
+            return null;
+        }
+
+        @Override
+        protected String[] getListValues() {
+            return new String[]{"1", "2", "3"};
+        }
+
+        @Override
+        protected String[] getListSummaries() {
+            return new String[]{"foo", "bar", "foobar"};
+        }
+
+        @Override
+        protected void writeConfigurationValues(Object newValue) {
+        }
+
+        @Override
+        protected int getCurrentA2dpSettingIndex(BluetoothCodecConfig config) {
+            return 0;
+        }
+
+        @Override
+        protected int getDefaultIndex() {
+            return 0;
+        }
+    }
+
+}

tests/robotests/src/com/android/settings/development/BluetoothAudioSampleRatePreferenceControllerTest.java

@@ -16,33 +16,21 @@
 
 package com.android.settings.development;
 
-import static com.android.settings.development.BluetoothAudioSampleRatePreferenceController
-        .STREAMING_LABEL_ID;
-
 import static com.google.common.truth.Truth.assertThat;
 
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.anyInt;
-import static org.mockito.ArgumentMatchers.anyLong;
-import static org.mockito.Mockito.doNothing;
-import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.never;
 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.BluetoothCodecConfig;
 import android.content.Context;
 import android.support.v7.preference.ListPreference;
 import android.support.v7.preference.PreferenceScreen;
 
-import com.android.settings.R;
 import com.android.settings.TestConfig;
 import com.android.settings.testutils.SettingsRobolectricTestRunner;
 import com.android.settingslib.core.lifecycle.Lifecycle;
 
-import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -55,14 +43,14 @@ import org.robolectric.annotation.Config;
 @Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)
 public class BluetoothAudioSampleRatePreferenceControllerTest {
 
-    @Mock
-    private BluetoothA2dp mBluetoothA2dp;
     @Mock
     private BluetoothCodecConfig mBluetoothCodecConfig;
     @Mock
     private ListPreference mPreference;
     @Mock
     private PreferenceScreen mScreen;
+    @Mock
+    private BluetoothA2dpConfigStore mBluetoothA2dpConfigStore;
 
     /**
      * 0: Use System Selection (Default)
@@ -72,7 +60,6 @@ public class BluetoothAudioSampleRatePreferenceControllerTest {
      * 4: 96.0 kHz
      */
     private String[] mListValues;
-    private String[] mListSummaries;
     private Lifecycle mLifecycle;
     private Context mContext;
     private BluetoothAudioSampleRatePreferenceController mController;
@@ -83,86 +70,36 @@ public class BluetoothAudioSampleRatePreferenceControllerTest {
         mContext = RuntimeEnvironment.application;
         mLifecycle = new Lifecycle();
         mController = spy(new BluetoothAudioSampleRatePreferenceController(mContext, mLifecycle,
-                new Object()));
+                new Object(), mBluetoothA2dpConfigStore));
-        doReturn(mBluetoothCodecConfig).when(mController).getCodecConfig();
+        mListValues = mController.getListValues();
-        doNothing().when(mController).setCodecConfigPreference(any());
-        doReturn(mBluetoothCodecConfig).when(mController).createCodecConfig(anyInt(), anyInt(),
-                anyInt(), anyInt(), anyInt(), anyLong(), anyLong(), anyLong(), anyLong());
-        mListValues = mContext.getResources().getStringArray(
-                R.array.bluetooth_a2dp_codec_sample_rate_values);
-        mListSummaries = mContext.getResources().getStringArray(
-                R.array.bluetooth_a2dp_codec_sample_rate_summaries);
         when(mScreen.findPreference(mController.getPreferenceKey())).thenReturn(mPreference);
         mController.displayPreference(mScreen);
     }
 
     @Test
-    public void updateState_nothingSet_shouldUpdateToDefault() {
+    public void writeConfigurationValues_option2_shouldWriteOption2ToSharedStore() {
-        mController.updateState(mPreference);
+        when(mPreference.findIndexOfValue(mListValues[2])).thenReturn(2);
+        mController.writeConfigurationValues(mListValues[2]);
 
-        verify(mPreference).setValue(mListValues[0]);
+        verify(mBluetoothA2dpConfigStore).setSampleRate(BluetoothCodecConfig.SAMPLE_RATE_48000);
-        verify(mPreference).setSummary(
-                mContext.getResources().getString(STREAMING_LABEL_ID, mListSummaries[0]));
     }
 
     @Test
-    public void updateState_option2Set_shouldUpdateToOption2() {
+    public void getCurrentA2dpSettingIndex_option2_shouldReturnSecondIndex() {
         when(mBluetoothCodecConfig.getSampleRate()).thenReturn(
                 BluetoothCodecConfig.SAMPLE_RATE_48000);
 
-        mController.updateState(mPreference);
+        final int index = mController.getCurrentA2dpSettingIndex(mBluetoothCodecConfig);
 
-        verify(mPreference).setValue(mListValues[2]);
+        assertThat(index).isEqualTo(2);
-        verify(mPreference).setSummary(
-                mContext.getResources().getString(STREAMING_LABEL_ID, mListSummaries[2]));
-        assertThat(BluetoothA2dpSharedStore.getSampleRate()).isEqualTo(
-                BluetoothCodecConfig.SAMPLE_RATE_48000);
     }
 
     @Test
-    public void onPreferenceChange_bluetoothConnected_shouldUpdateCodec() {
+    public void getCurrentA2dpSettingIndex_unknownOption_shouldReturnDefault() {
-        mController.onBluetoothServiceConnected(mBluetoothA2dp);
+        when(mBluetoothCodecConfig.getSampleRate()).thenReturn(1381391835);
 
-        mController.onPreferenceChange(mPreference, "" /* new value */);
+        final int index = mController.getCurrentA2dpSettingIndex(mBluetoothCodecConfig);
 
-        verify(mController).setCodecConfigPreference(any());
+        assertThat(index).isEqualTo(0);
     }
-
-    @Test
-    public void onPreferenceChange_bluetoothNotConnected_shouldUpdateCodec() {
-        mController.onBluetoothServiceDisconnected();
-
-        mController.onPreferenceChange(mPreference, "" /* new value */);
-
-        verify(mController, never()).setCodecConfigPreference(any());
-    }
-
-    @Test
-    public void onBluetoothServiceConnected_shouldUpdateState() {
-        mController.onBluetoothServiceConnected(mBluetoothA2dp);
-
-        verify(mController).updateState(mPreference);
-    }
-
-    @Test
-    public void onBluetoothCodecUpdated_shouldUpdateState() {
-        mController.onBluetoothCodecUpdated();
-
-        verify(mController).updateState(mPreference);
-    }
-
-    @Test
-    public void onDeveloperOptionsSwitchEnabled_shouldEnablePreference() {
-        mController.onDeveloperOptionsSwitchEnabled();
-
-        verify(mPreference).setEnabled(true);
-    }
-
-    @Test
-    public void onDeveloperOptionsSwitchDisabled_shouldDisablePreference() {
-        mController.onDeveloperOptionsSwitchDisabled();
-
-        verify(mPreference).setEnabled(false);
-    }
-
 }