From 027da329fe7f71443af76ca6d7c080bd4e9bb430 Mon Sep 17 00:00:00 2001 From: jeffreyhuang Date: Wed, 11 Oct 2017 17:45:48 -0700 Subject: [PATCH] Introduce AbstractBluetoothA2dpPreferenceCtrl - Refactor BluetoothAudioSampleRatePreferenceController into AbstractBluetoothA2dpPreferenceController - Make it easier to implement future bluetooth a2dp preferences Bug: 34203528 Test: make RunSettingsRoboTests -j40 Change-Id: Ie94273c2b97504f4fb63f11b1afc21abc6944ffb --- ...ractBluetoothA2dpPreferenceController.java | 214 ++++++++++++++++++ ...thAudioSampleRatePreferenceController.java | 185 ++++----------- .../DevelopmentSettingsDashboardFragment.java | 13 +- ...BluetoothA2dpPreferenceControllerTest.java | 175 ++++++++++++++ ...dioSampleRatePreferenceControllerTest.java | 88 ++----- 5 files changed, 454 insertions(+), 221 deletions(-) create mode 100644 src/com/android/settings/development/AbstractBluetoothA2dpPreferenceController.java create mode 100644 tests/robotests/src/com/android/settings/development/AbstractBluetoothA2dpPreferenceControllerTest.java diff --git a/src/com/android/settings/development/AbstractBluetoothA2dpPreferenceController.java b/src/com/android/settings/development/AbstractBluetoothA2dpPreferenceController.java new file mode 100644 index 00000000000..bb03df1f7b4 --- /dev/null +++ b/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); + } + +} diff --git a/src/com/android/settings/development/BluetoothAudioSampleRatePreferenceController.java b/src/com/android/settings/development/BluetoothAudioSampleRatePreferenceController.java index baabe3d67c2..5d84de8f94d 100644 --- a/src/com/android/settings/development/BluetoothAudioSampleRatePreferenceController.java +++ b/src/com/android/settings/development/BluetoothAudioSampleRatePreferenceController.java @@ -16,53 +16,26 @@ 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 final BluetoothA2dpConfigStore mBluetoothA2dpConfigStore; private ListPreference mPreference; - private BluetoothA2dp mBluetoothA2dp; public BluetoothAudioSampleRatePreferenceController(Context context, Lifecycle lifecycle, Object bluetoothA2dpLock, BluetoothA2dpConfigStore store) { - super(context); - - mBluetoothA2dpLock = bluetoothA2dpLock; - mBluetoothA2dpConfigStore = store; - 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); - } + super(context, lifecycle, bluetoothA2dpLock, store); } @Override @@ -78,80 +51,52 @@ public class BluetoothAudioSampleRatePreferenceController extends } @Override - public boolean onPreferenceChange(Preference preference, Object newValue) { - if (mBluetoothA2dp == null) { - return false; + protected String[] getListValues() { + return mContext.getResources().getStringArray( + R.array.bluetooth_a2dp_codec_sample_rate_values); + } + + @Override + protected String[] getListSummaries() { + return mContext.getResources().getStringArray( + R.array.bluetooth_a2dp_codec_sample_rate_summaries); + } + + @Override + protected int getDefaultIndex() { + return DEFAULT_INDEX; + } + + @Override + 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; } - - final int sampleRate = mapPreferenceValueToSampleRate(newValue.toString()); - mBluetoothA2dpConfigStore.setSampleRate(sampleRate); - - // get values from shared store - BluetoothCodecConfig codecConfig = mBluetoothA2dpConfigStore.createCodecConfig(); - - synchronized (mBluetoothA2dpLock) { - if (mBluetoothA2dp != null) { - setCodecConfigPreference(codecConfig); - } - } - updateState(mPreference); - return true; + mBluetoothA2dpConfigStore.setSampleRate(sampleRateValue); } @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 - mBluetoothA2dpConfigStore.setSampleRate(sampleRate); - } - - @Override - public void onBluetoothServiceConnected(BluetoothA2dp bluetoothA2dp) { - mBluetoothA2dp = bluetoothA2dp; - updateState(mPreference); - } - - @Override - public void onBluetoothCodecUpdated() { - updateState(mPreference); - } - - @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); - } - - 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; @@ -173,44 +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(); - } } diff --git a/src/com/android/settings/development/DevelopmentSettingsDashboardFragment.java b/src/com/android/settings/development/DevelopmentSettingsDashboardFragment.java index c3488d70954..efea72eb477 100644 --- a/src/com/android/settings/development/DevelopmentSettingsDashboardFragment.java +++ b/src/com/android/settings/development/DevelopmentSettingsDashboardFragment.java @@ -298,7 +298,8 @@ public class DevelopmentSettingsDashboardFragment extends RestrictedDashboardFra @Override protected List 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 buildPreferenceControllers(Context context, Activity activity, Lifecycle lifecycle, DevelopmentSettingsDashboardFragment fragment, - Object bluetoothA2dpLock) { + Object bluetoothA2dpLock, BluetoothA2dpConfigStore bluetoothA2dpConfigStore) { final List controllers = new ArrayList<>(); controllers.add(new BugReportPreferenceControllerV2(context)); controllers.add(new LocalBackupPasswordPreferenceController(context)); @@ -375,10 +376,10 @@ public class DevelopmentSettingsDashboardFragment extends RestrictedDashboardFra controllers.add(new BluetoothAbsoluteVolumePreferenceController(context)); controllers.add(new BluetoothInbandRingingPreferenceController(context)); controllers.add(new BluetoothAvrcpVersionPreferenceController(context)); - final BluetoothA2dpConfigStore store = new BluetoothA2dpConfigStore(); - // bluetooth audio codec + //controllers.add(new BluetoothAudioCodecPreferenceController(context, lifecycle, + // bluetoothA2dpLock, bluetoothA2dpConfigStore)); controllers.add(new BluetoothAudioSampleRatePreferenceController(context, lifecycle, - bluetoothA2dpLock, store)); + bluetoothA2dpLock, bluetoothA2dpConfigStore)); // bluetooth audio bits per sample // bluetooth audio channel mode // bluetooth audio ldac codec: playback quality @@ -446,7 +447,7 @@ public class DevelopmentSettingsDashboardFragment extends RestrictedDashboardFra context) { return buildPreferenceControllers(context, null /* activity */, null /* lifecycle */, null /* devOptionsDashboardFragment */, - null /* bluetoothA2dpLock */); + null /* bluetoothA2dpLock */, null /* bluetoothA2dpConfigStore */); } }; } diff --git a/tests/robotests/src/com/android/settings/development/AbstractBluetoothA2dpPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/development/AbstractBluetoothA2dpPreferenceControllerTest.java new file mode 100644 index 00000000000..e78dd7fc518 --- /dev/null +++ b/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; + } + } + +} diff --git a/tests/robotests/src/com/android/settings/development/BluetoothAudioSampleRatePreferenceControllerTest.java b/tests/robotests/src/com/android/settings/development/BluetoothAudioSampleRatePreferenceControllerTest.java index 27766d9997d..89195766e5d 100644 --- a/tests/robotests/src/com/android/settings/development/BluetoothAudioSampleRatePreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/development/BluetoothAudioSampleRatePreferenceControllerTest.java @@ -16,28 +16,17 @@ 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; @@ -54,8 +43,6 @@ 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 @@ -73,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; @@ -85,83 +71,35 @@ public class BluetoothAudioSampleRatePreferenceControllerTest { mLifecycle = new Lifecycle(); mController = spy(new BluetoothAudioSampleRatePreferenceController(mContext, mLifecycle, new Object(), mBluetoothA2dpConfigStore)); - doReturn(mBluetoothCodecConfig).when(mController).getCodecConfig(); - doNothing().when(mController).setCodecConfigPreference(any()); - when(mBluetoothA2dpConfigStore.createCodecConfig()).thenReturn(mBluetoothCodecConfig); - mListValues = mContext.getResources().getStringArray( - R.array.bluetooth_a2dp_codec_sample_rate_values); - mListSummaries = mContext.getResources().getStringArray( - R.array.bluetooth_a2dp_codec_sample_rate_summaries); + mListValues = mController.getListValues(); when(mScreen.findPreference(mController.getPreferenceKey())).thenReturn(mPreference); mController.displayPreference(mScreen); } @Test - public void updateState_nothingSet_shouldUpdateToDefault() { - mController.updateState(mPreference); + public void writeConfigurationValues_option2_shouldWriteOption2ToSharedStore() { + when(mPreference.findIndexOfValue(mListValues[2])).thenReturn(2); + mController.writeConfigurationValues(mListValues[2]); - verify(mPreference).setValue(mListValues[0]); - verify(mPreference).setSummary( - mContext.getResources().getString(STREAMING_LABEL_ID, mListSummaries[0])); - } - - @Test - public void updateState_option2Set_shouldUpdateToOption2() { - when(mBluetoothCodecConfig.getSampleRate()).thenReturn( - BluetoothCodecConfig.SAMPLE_RATE_48000); - - mController.updateState(mPreference); - - verify(mPreference).setValue(mListValues[2]); - verify(mPreference).setSummary( - mContext.getResources().getString(STREAMING_LABEL_ID, mListSummaries[2])); verify(mBluetoothA2dpConfigStore).setSampleRate(BluetoothCodecConfig.SAMPLE_RATE_48000); } @Test - public void onPreferenceChange_bluetoothConnected_shouldUpdateCodec() { - mController.onBluetoothServiceConnected(mBluetoothA2dp); + public void getCurrentA2dpSettingIndex_option2_shouldReturnSecondIndex() { + when(mBluetoothCodecConfig.getSampleRate()).thenReturn( + BluetoothCodecConfig.SAMPLE_RATE_48000); - mController.onPreferenceChange(mPreference, "" /* new value */); + final int index = mController.getCurrentA2dpSettingIndex(mBluetoothCodecConfig); - verify(mController).setCodecConfigPreference(any()); + assertThat(index).isEqualTo(2); } @Test - public void onPreferenceChange_bluetoothNotConnected_shouldUpdateCodec() { - mController.onBluetoothServiceDisconnected(); + public void getCurrentA2dpSettingIndex_unknownOption_shouldReturnDefault() { + when(mBluetoothCodecConfig.getSampleRate()).thenReturn(1381391835); - mController.onPreferenceChange(mPreference, "" /* new value */); + final int index = mController.getCurrentA2dpSettingIndex(mBluetoothCodecConfig); - verify(mController, never()).setCodecConfigPreference(any()); + assertThat(index).isEqualTo(0); } - - @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); - } - }