diff options
author | Jakub Rotkiewicz <rotkiewicz@google.com> | 2023-11-22 10:11:25 +0000 |
---|---|---|
committer | Jakub Rotkiewicz <rotkiewicz@google.com> | 2024-03-21 11:06:18 +0000 |
commit | de27acef863432f2d5e8a1fb77aeb8ee9d2356dd (patch) | |
tree | 01a0465f14afc637f613a75b7f0bbf5474443d4f | |
parent | 33722b512a2df4aaccea4f5623b8e9cf079cd955 (diff) | |
download | Settings-de27acef863432f2d5e8a1fb77aeb8ee9d2356dd.tar.gz |
Refactor Bluetooth Codec settings to dynamic ListPreference
Fetch supported codecs from native and present to user using
ListPreference.
Bug: 305779598
Bug: 311451118
Bug: 323319530
Tag: #feature
Test: atest SettingsRoboTests:com.android.settings.development.bluetooth.AbstractBluetoothListPreferenceController
Test: atest SettingsRoboTests:com.android.settings.development.bluetooth.BluetoothCodecListPreferenceControllerTest
Merged-In: Iedbfd01c0d1b59df8a073f4e9aedca3913e6d45f
Change-Id: I90ed0d83c3250c64789e27707b0b7bff30043335
11 files changed, 1105 insertions, 8 deletions
diff --git a/aconfig/development/settings_core_flag_declarations.aconfig b/aconfig/development/settings_core_flag_declarations.aconfig index c0122631d96..fdbafa7b5fd 100644 --- a/aconfig/development/settings_core_flag_declarations.aconfig +++ b/aconfig/development/settings_core_flag_declarations.aconfig @@ -1,6 +1,13 @@ package: "com.android.settings.development" flag { + name: "a2dp_offload_codec_extensibility_settings" + namespace: "bluetooth" + description: "Feature flag for Bluetooth Audio Codec extensibility in Settings" + bug: "323319530" +} + +flag { name: "deprecate_list_activity" namespace: "android_settings" description: "Feature flag for deprecating ListActivity in Settings" diff --git a/res/values/strings.xml b/res/values/strings.xml index 60702065f75..9f4f8e53a91 100644 --- a/res/values/strings.xml +++ b/res/values/strings.xml @@ -167,6 +167,9 @@ <!-- Description for text in accessibility hearing aids footer. [CHAR LIMIT=NONE] --> <string name="bluetooth_audio_routing_footer_summary">By default, audio output is determined by individual apps</string> + <!-- Bluetooth audio codec related settings. Title of the default audio codec selection. [CHAR LIMIT=60] --> + <string name="bluetooth_audio_codec_default_selection">Use System Selection (Default)</string> + <!--Bluetooth settings screen, summary text for Bluetooth device with no name --> <string name="bluetooth_device">Unnamed Bluetooth device</string> <!--Bluetooth settings screen, text that appears in heading bar when scanning for devices --> diff --git a/res/xml/development_settings.xml b/res/xml/development_settings.xml index 0f1732eba60..64dad21a5c8 100644 --- a/res/xml/development_settings.xml +++ b/res/xml/development_settings.xml @@ -411,6 +411,11 @@ android:positiveButtonText="" android:negativeButtonText="@string/dlg_ok"/> + <ListPreference + android:key="bluetooth_audio_codec_settings_list" + android:title="@string/bluetooth_select_a2dp_codec_type" + android:dialogTitle="@string/bluetooth_select_a2dp_codec_type_dialog_title"/> + <com.android.settings.development.bluetooth.BluetoothSampleRateDialogPreference android:key="bluetooth_sample_rate_settings" android:title="@string/bluetooth_select_a2dp_codec_sample_rate" diff --git a/src/com/android/settings/development/BluetoothA2dpConfigStore.java b/src/com/android/settings/development/BluetoothA2dpConfigStore.java index 7fd7b133f38..d6b849f5718 100644 --- a/src/com/android/settings/development/BluetoothA2dpConfigStore.java +++ b/src/com/android/settings/development/BluetoothA2dpConfigStore.java @@ -16,15 +16,19 @@ package com.android.settings.development; +import android.annotation.FlaggedApi; import android.bluetooth.BluetoothCodecConfig; +import android.bluetooth.BluetoothCodecType; -/** - * Utility class for storing current Bluetooth A2DP profile values - */ +import androidx.annotation.NonNull; +import androidx.annotation.Nullable; + +/** Utility class for storing current Bluetooth A2DP profile values */ public class BluetoothA2dpConfigStore { // init default values - private int mCodecType = BluetoothCodecConfig.SOURCE_CODEC_TYPE_INVALID; + private int mCodecTypeNative = BluetoothCodecConfig.SOURCE_CODEC_TYPE_INVALID; + @Nullable private BluetoothCodecType mCodecType = null; private int mCodecPriority = BluetoothCodecConfig.CODEC_PRIORITY_DEFAULT; private int mSampleRate = BluetoothCodecConfig.SAMPLE_RATE_NONE; private int mBitsPerSample = BluetoothCodecConfig.BITS_PER_SAMPLE_NONE; @@ -35,6 +39,10 @@ public class BluetoothA2dpConfigStore { private long mCodecSpecific4Value; public void setCodecType(int codecType) { + mCodecTypeNative = codecType; + } + + public void setCodecType(@Nullable BluetoothCodecType codecType) { mCodecType = codecType; } @@ -70,9 +78,26 @@ public class BluetoothA2dpConfigStore { mCodecSpecific4Value = codecSpecific4Value; } + /** Create codec config utilizing {@link BluetoothCodecConfig.SourceCodecType} */ public BluetoothCodecConfig createCodecConfig() { return new BluetoothCodecConfig.Builder() - .setCodecType(mCodecType) + .setCodecType(mCodecTypeNative) + .setCodecPriority(mCodecPriority) + .setSampleRate(mSampleRate) + .setBitsPerSample(mBitsPerSample) + .setChannelMode(mChannelMode) + .setCodecSpecific1(mCodecSpecific1Value) + .setCodecSpecific2(mCodecSpecific2Value) + .setCodecSpecific3(mCodecSpecific3Value) + .setCodecSpecific4(mCodecSpecific4Value) + .build(); + } + + /** Create codec config utilizing {@link BluetoothCodecType} */ + @FlaggedApi(Flags.FLAG_A2DP_OFFLOAD_CODEC_EXTENSIBILITY_SETTINGS) + public @NonNull BluetoothCodecConfig createCodecConfigFromCodecType() { + return new BluetoothCodecConfig.Builder() + .setExtendedCodecType(mCodecType) .setCodecPriority(mCodecPriority) .setSampleRate(mSampleRate) .setBitsPerSample(mBitsPerSample) diff --git a/src/com/android/settings/development/DevelopmentSettingsDashboardFragment.java b/src/com/android/settings/development/DevelopmentSettingsDashboardFragment.java index 09b08894dab..35b011a0a61 100644 --- a/src/com/android/settings/development/DevelopmentSettingsDashboardFragment.java +++ b/src/com/android/settings/development/DevelopmentSettingsDashboardFragment.java @@ -62,10 +62,12 @@ import com.android.settings.development.autofill.AutofillCategoryController; import com.android.settings.development.autofill.AutofillLoggingLevelPreferenceController; import com.android.settings.development.autofill.AutofillResetOptionsPreferenceController; import com.android.settings.development.bluetooth.AbstractBluetoothDialogPreferenceController; +import com.android.settings.development.bluetooth.AbstractBluetoothListPreferenceController; import com.android.settings.development.bluetooth.AbstractBluetoothPreferenceController; import com.android.settings.development.bluetooth.BluetoothBitPerSampleDialogPreferenceController; import com.android.settings.development.bluetooth.BluetoothChannelModeDialogPreferenceController; import com.android.settings.development.bluetooth.BluetoothCodecDialogPreferenceController; +import com.android.settings.development.bluetooth.BluetoothCodecListPreferenceController; import com.android.settings.development.bluetooth.BluetoothHDAudioPreferenceController; import com.android.settings.development.bluetooth.BluetoothQualityDialogPreferenceController; import com.android.settings.development.bluetooth.BluetoothSampleRateDialogPreferenceController; @@ -724,6 +726,9 @@ public class DevelopmentSettingsDashboardFragment extends RestrictedDashboardFra controllers.add(new AutofillResetOptionsPreferenceController(context)); controllers.add(new BluetoothCodecDialogPreferenceController(context, lifecycle, bluetoothA2dpConfigStore, fragment)); + controllers.add( + new BluetoothCodecListPreferenceController( + context, lifecycle, bluetoothA2dpConfigStore, fragment)); controllers.add(new BluetoothSampleRateDialogPreferenceController(context, lifecycle, bluetoothA2dpConfigStore)); controllers.add(new BluetoothBitPerSampleDialogPreferenceController(context, lifecycle, @@ -771,6 +776,9 @@ public class DevelopmentSettingsDashboardFragment extends RestrictedDashboardFra ((AbstractBluetoothDialogPreferenceController) controller).onHDAudioEnabled( enabled); } + if (controller instanceof AbstractBluetoothListPreferenceController) { + ((AbstractBluetoothListPreferenceController) controller).onHDAudioEnabled(enabled); + } } } diff --git a/src/com/android/settings/development/bluetooth/AbstractBluetoothListPreferenceController.java b/src/com/android/settings/development/bluetooth/AbstractBluetoothListPreferenceController.java new file mode 100644 index 00000000000..9436e06bee5 --- /dev/null +++ b/src/com/android/settings/development/bluetooth/AbstractBluetoothListPreferenceController.java @@ -0,0 +1,268 @@ +/* + * Copyright (C) 2023 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.settings.development.bluetooth; + +import static android.bluetooth.BluetoothCodecConfig.CODEC_PRIORITY_HIGHEST; + +import android.bluetooth.BluetoothA2dp; +import android.bluetooth.BluetoothCodecConfig; +import android.bluetooth.BluetoothCodecStatus; +import android.bluetooth.BluetoothDevice; +import android.content.Context; +import android.util.Log; + +import androidx.annotation.NonNull; +import androidx.annotation.Nullable; +import androidx.preference.ListPreference; +import androidx.preference.Preference; +import androidx.preference.PreferenceScreen; + +import com.android.settings.R; +import com.android.settings.development.BluetoothA2dpConfigStore; +import com.android.settingslib.core.lifecycle.Lifecycle; + +import java.util.List; + +/** Abstract class for Bluetooth A2DP config list controller in developer option. */ +public abstract class AbstractBluetoothListPreferenceController + extends AbstractBluetoothPreferenceController + implements Preference.OnPreferenceChangeListener { + + private static final String TAG = "AbstrBtListPrefCtrl"; + private static final boolean DEBUG = Log.isLoggable(TAG, Log.DEBUG); + + protected static final int DEFAULT_VALUE_INT = 1000; + + @Nullable protected ListPreference mListPreference; + + protected String mDefaultEntry; + protected String mDefaultValue; + + @Nullable protected final BluetoothA2dpConfigStore mBluetoothA2dpConfigStore; + + public AbstractBluetoothListPreferenceController( + @NonNull Context context, + @Nullable Lifecycle lifecycle, + @Nullable BluetoothA2dpConfigStore store) { + super(context, lifecycle, store); + + mDefaultEntry = mContext.getString(R.string.bluetooth_audio_codec_default_selection); + mDefaultValue = String.valueOf(DEFAULT_VALUE_INT); + + mBluetoothA2dpConfigStore = store; + } + + @Override + public void displayPreference(@NonNull PreferenceScreen screen) { + super.displayPreference(screen); + mListPreference = screen.findPreference(getPreferenceKey()); + } + + @Override + public boolean onPreferenceChange(@Nullable Preference preference, @NonNull Object newValue) { + if (DEBUG) { + Log.d(TAG, "onPreferenceChange: newValue=" + (String) newValue); + } + if (mListPreference == null) { + Log.e(TAG, "onPreferenceChange: List preference is null"); + return false; + } + updateState(mListPreference); + return true; + } + + @Override + public void updateState(@Nullable Preference preference) { + setupDefaultListPreference(); + } + + @Override + public void onBluetoothServiceConnected(@NonNull BluetoothA2dp bluetoothA2dp) { + super.onBluetoothServiceConnected(bluetoothA2dp); + initConfigStore(); + } + + @Override + protected void onDeveloperOptionsSwitchDisabled() { + super.onDeveloperOptionsSwitchDisabled(); + if (DEBUG) { + Log.d(TAG, "onDeveloperOptionsSwitchDisabled"); + } + if (mListPreference == null) { + Log.e(TAG, "onDeveloperOptionsSwitchDisabled: List preference is null"); + return; + } + updateState(mListPreference); + } + + /** + * Method to notify controller when the HD audio(optional codec) state is changed. + * + * @param enabled Is {@code true} when the setting is enabled. + */ + public void onHDAudioEnabled(boolean enabled) {} + + /** + * Updates the new value to the {@link BluetoothA2dpConfigStore}. + * + * @param entryValue the new setting entry value + */ + protected abstract void writeConfigurationValues(String entryValue); + + /** + * Gets the current bluetooth codec status. + * + * @return {@link BluetoothCodecStatus}. + */ + @Nullable + protected BluetoothCodecStatus getBluetoothCodecStatus() { + final BluetoothA2dp bluetoothA2dp = mBluetoothA2dp; + if (bluetoothA2dp == null) { + Log.e( + TAG, + "getBluetoothCodecStatus: Unable to get codec status. Bluetooth A2dp is null."); + return null; + } + final BluetoothDevice activeDevice = getA2dpActiveDevice(); + if (activeDevice == null) { + Log.e(TAG, "getBluetoothCodecStatus: Unable to get codec status. No active device."); + return null; + } + final BluetoothCodecStatus codecStatus = bluetoothA2dp.getCodecStatus(activeDevice); + if (codecStatus == null) { + Log.e(TAG, "getBluetoothCodecStatus: Codec status is null"); + return null; + } + return codecStatus; + } + + /** + * Gets the current bluetooth codec config. + * + * @return {@link BluetoothCodecConfig}. + */ + @Nullable + protected BluetoothCodecConfig getCurrentCodecConfig() { + final BluetoothCodecStatus codecStatus = getBluetoothCodecStatus(); + if (codecStatus == null) { + Log.e( + TAG, + "getCurrentCodecConfig: Unable to get current codec config. Codec status is" + + " null"); + return null; + } + + return codecStatus.getCodecConfig(); + } + + /** + * Sets the {@link ListPreference}. This method adds the default entry and the entry value + * automatically. + * + * @param entries list of String entries for the {@link ListPreference}. + * @param entryValues list of String entry values for the {@link ListPreference}. + * @param selectedEntry currently selected entry. + * @param selectedValue currently selected entry value. + */ + protected void setupListPreference( + List<String> entries, + List<String> entryValues, + String selectedEntry, + String selectedValue) { + if (entries.size() != entryValues.size()) { + Log.e( + TAG, + ("setupListPreference: size of entries: " + entries.size()) + + (", size of entryValues" + entryValues.size())); + setupDefaultListPreference(); + return; + } + if (entries.isEmpty() || entryValues.isEmpty()) { + Log.e(TAG, "setupListPreference: entries or entryValues empty"); + setupDefaultListPreference(); + return; + } + entries.add(0, mDefaultEntry); + entryValues.add(0, mDefaultValue); + + if (mListPreference == null) { + Log.e(TAG, "setupListPreference: List preference is null"); + return; + } + mListPreference.setEntries(entries.toArray(new String[entries.size()])); + mListPreference.setEntryValues(entryValues.toArray(new String[entryValues.size()])); + mListPreference.setValue(selectedValue); + mListPreference.setSummary(selectedEntry); + } + + /** + * Check HD Audio enabled. + * + * @return true if HD Audio is enabled. + */ + protected boolean isHDAudioEnabled() { + final BluetoothA2dp bluetoothA2dp = mBluetoothA2dp; + if (bluetoothA2dp == null) { + Log.e(TAG, "isHDAudioEnabled: Unable to get codec status. BluetoothA2dp is null."); + return false; + } + BluetoothDevice activeDevice = getA2dpActiveDevice(); + if (activeDevice == null) { + Log.e(TAG, "isHDAudioEnabled: Unable to get codec status. No active device."); + return false; + } + return (bluetoothA2dp.isOptionalCodecsEnabled(activeDevice) + == BluetoothA2dp.OPTIONAL_CODECS_PREF_ENABLED); + } + + private void setupDefaultListPreference() { + if (DEBUG) { + Log.d( + TAG, + "setupDefaultListPreference: mDefaultEntry=" + + mDefaultEntry + + ", mDefaultValue=" + + mDefaultValue); + } + if (mListPreference == null) { + Log.e(TAG, "setupListPreference: List preference is null"); + return; + } + mListPreference.setEntries(new String[] {mDefaultEntry}); + mListPreference.setEntryValues(new String[] {mDefaultValue}); + mListPreference.setValue(mDefaultValue); + mListPreference.setSummary(mDefaultEntry); + } + + private void initConfigStore() { + final BluetoothCodecConfig config = getCurrentCodecConfig(); + if (config == null) { + Log.e(TAG, "initConfigStore: Current codec config is null."); + return; + } + if (mBluetoothA2dpConfigStore == null) { + Log.e(TAG, "initConfigStore: Bluetooth A2dp Config Store is null."); + return; + } + mBluetoothA2dpConfigStore.setCodecType(config.getExtendedCodecType()); + mBluetoothA2dpConfigStore.setSampleRate(config.getSampleRate()); + mBluetoothA2dpConfigStore.setBitsPerSample(config.getBitsPerSample()); + mBluetoothA2dpConfigStore.setChannelMode(config.getChannelMode()); + mBluetoothA2dpConfigStore.setCodecPriority(CODEC_PRIORITY_HIGHEST); + mBluetoothA2dpConfigStore.setCodecSpecific1Value(config.getCodecSpecific1()); + } +} diff --git a/src/com/android/settings/development/bluetooth/AbstractBluetoothPreferenceController.java b/src/com/android/settings/development/bluetooth/AbstractBluetoothPreferenceController.java index d3fab674a92..14bc27573bb 100644 --- a/src/com/android/settings/development/bluetooth/AbstractBluetoothPreferenceController.java +++ b/src/com/android/settings/development/bluetooth/AbstractBluetoothPreferenceController.java @@ -23,6 +23,7 @@ import android.bluetooth.BluetoothManager; import android.bluetooth.BluetoothProfile; import android.content.Context; +import androidx.annotation.Nullable; import androidx.annotation.VisibleForTesting; import com.android.settings.core.PreferenceControllerMixin; @@ -42,13 +43,15 @@ public abstract class AbstractBluetoothPreferenceController extends DeveloperOptionsPreferenceController implements BluetoothServiceConnectionListener, LifecycleObserver, OnDestroy, PreferenceControllerMixin { - protected volatile BluetoothA2dp mBluetoothA2dp; + @Nullable protected volatile BluetoothA2dp mBluetoothA2dp; @VisibleForTesting BluetoothAdapter mBluetoothAdapter; - public AbstractBluetoothPreferenceController(Context context, Lifecycle lifecycle, - BluetoothA2dpConfigStore store) { + public AbstractBluetoothPreferenceController( + @Nullable Context context, + @Nullable Lifecycle lifecycle, + @Nullable BluetoothA2dpConfigStore store) { super(context); if (lifecycle != null) { lifecycle.addObserver(this); diff --git a/src/com/android/settings/development/bluetooth/BluetoothCodecDialogPreferenceController.java b/src/com/android/settings/development/bluetooth/BluetoothCodecDialogPreferenceController.java index 2f0d27c2fef..b7b557464fb 100644 --- a/src/com/android/settings/development/bluetooth/BluetoothCodecDialogPreferenceController.java +++ b/src/com/android/settings/development/bluetooth/BluetoothCodecDialogPreferenceController.java @@ -26,6 +26,7 @@ import androidx.annotation.VisibleForTesting; import androidx.preference.PreferenceScreen; import com.android.settings.development.BluetoothA2dpConfigStore; +import com.android.settings.development.Flags; import com.android.settingslib.core.lifecycle.Lifecycle; import java.util.ArrayList; @@ -50,6 +51,11 @@ public class BluetoothCodecDialogPreferenceController extends } @Override + public boolean isAvailable() { + return !Flags.a2dpOffloadCodecExtensibilitySettings(); + } + + @Override public String getPreferenceKey() { return KEY; } diff --git a/src/com/android/settings/development/bluetooth/BluetoothCodecListPreferenceController.java b/src/com/android/settings/development/bluetooth/BluetoothCodecListPreferenceController.java new file mode 100644 index 00000000000..79b629efcb6 --- /dev/null +++ b/src/com/android/settings/development/bluetooth/BluetoothCodecListPreferenceController.java @@ -0,0 +1,265 @@ +/* + * Copyright (C) 2023 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.settings.development.bluetooth; + +import android.bluetooth.BluetoothA2dp; +import android.bluetooth.BluetoothCodecConfig; +import android.bluetooth.BluetoothCodecStatus; +import android.bluetooth.BluetoothCodecType; +import android.bluetooth.BluetoothDevice; +import android.content.Context; +import android.util.Log; + +import androidx.annotation.NonNull; +import androidx.annotation.Nullable; +import androidx.preference.Preference; +import androidx.preference.PreferenceScreen; + +import com.android.settings.development.BluetoothA2dpConfigStore; +import com.android.settings.development.Flags; +import com.android.settingslib.core.lifecycle.Lifecycle; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +/** List preference controller to set the Bluetooth A2DP codec */ +public class BluetoothCodecListPreferenceController + extends AbstractBluetoothListPreferenceController { + + private static final String KEY = "bluetooth_audio_codec_settings_list"; + private static final String TAG = "BtExtCodecCtr"; + private static final boolean DEBUG = Log.isLoggable(TAG, Log.DEBUG); + + @Nullable private final Callback mCallback; + + public BluetoothCodecListPreferenceController( + @NonNull Context context, + @Nullable Lifecycle lifecycle, + @Nullable BluetoothA2dpConfigStore store, + @Nullable Callback callback) { + super(context, lifecycle, store); + mCallback = callback; + } + + @Override + public boolean isAvailable() { + boolean available = Flags.a2dpOffloadCodecExtensibilitySettings(); + if (DEBUG) { + Log.d(TAG, "isAvailable: " + available); + } + return available; + } + + @Override + public @NonNull String getPreferenceKey() { + return KEY; + } + + @Override + public void displayPreference(@NonNull PreferenceScreen screen) { + super.displayPreference(screen); + mListPreference = screen.findPreference(getPreferenceKey()); + } + + @Override + public boolean onPreferenceChange(@Nullable Preference preference, @NonNull Object newValue) { + if (DEBUG) { + Log.d(TAG, "onPreferenceChange: newValue=" + (String) newValue); + } + final BluetoothA2dp bluetoothA2dp = mBluetoothA2dp; + if (bluetoothA2dp == null) { + Log.e(TAG, "onPreferenceChange: bluetoothA2dp is null"); + return false; + } + + writeConfigurationValues((String) newValue); + + if (mBluetoothA2dpConfigStore == null) { + Log.e(TAG, "onPreferenceChange: Bluetooth A2dp Config Store is null"); + return false; + } + BluetoothCodecConfig codecConfig; + if (Flags.a2dpOffloadCodecExtensibilitySettings()) { + codecConfig = mBluetoothA2dpConfigStore.createCodecConfigFromCodecType(); + } else { + codecConfig = mBluetoothA2dpConfigStore.createCodecConfig(); + } + + final BluetoothDevice activeDevice = getA2dpActiveDevice(); + if (activeDevice == null) { + Log.e(TAG, "onPreferenceChange: active device is null"); + return false; + } + + if (DEBUG) { + Log.d(TAG, "onPreferenceChange: setCodecConfigPreference: " + codecConfig.toString()); + } + bluetoothA2dp.setCodecConfigPreference(activeDevice, codecConfig); + if (mCallback != null) { + mCallback.onBluetoothCodecChanged(); + } + + return true; + } + + @Override + public void updateState(@Nullable Preference preference) { + super.updateState(preference); + final List<String> codecIds = new ArrayList<>(); + final List<String> labels = new ArrayList<>(); + String selectedCodecId = mDefaultValue; + String selectedLabel = mDefaultEntry; + + if (isHDAudioEnabled()) { + final BluetoothCodecStatus codecStatus = getBluetoothCodecStatus(); + if (codecStatus == null) { + Log.e(TAG, "updateState: Bluetooth Codec Status is null"); + return; + } + + final BluetoothCodecConfig currentCodecConfig = codecStatus.getCodecConfig(); + if (currentCodecConfig == null) { + Log.e(TAG, "updateState: currentCodecConfig is null"); + return; + } + + final BluetoothA2dp bluetoothA2dp = mBluetoothA2dp; + if (bluetoothA2dp == null) { + Log.e(TAG, "updateState: bluetoothA2dp is null"); + return; + } + + final Collection<BluetoothCodecType> codecTypes = + bluetoothA2dp.getSupportedCodecTypes(); + for (BluetoothCodecType codecType : codecTypes) { + labels.add(codecType.getCodecName()); + codecIds.add(String.valueOf(codecType.getCodecId())); + if (currentCodecConfig != null + && currentCodecConfig.getExtendedCodecType().equals(codecType)) { + selectedCodecId = codecIds.get(codecIds.size() - 1); + selectedLabel = labels.get(labels.size() - 1); + if (DEBUG) { + Log.d( + TAG, + "updateState: Current config: " + + selectedLabel + + ", id: " + + selectedCodecId); + } + } + } + + setupListPreference(labels, codecIds, selectedLabel, selectedCodecId); + } + } + + @Override + public void onHDAudioEnabled(boolean enabled) { + if (DEBUG) { + Log.d(TAG, "onHDAudioEnabled: enabled=" + enabled); + } + if (mListPreference == null) { + Log.e(TAG, "onHDAudioEnabled: List preference is null"); + return; + } + mListPreference.setEnabled(enabled); + } + + @Override + protected void writeConfigurationValues(String entryValue) { + long codecIdValue = getCodecIdFromEntryValue(entryValue); + BluetoothCodecType selectedCodecType = null; + BluetoothCodecConfig selectedCodecConfig = null; + + final BluetoothA2dp bluetoothA2dp = mBluetoothA2dp; + if (bluetoothA2dp == null) { + Log.e(TAG, "writeConfigurationValues: bluetoothA2dp is null"); + return; + } + + final Collection<BluetoothCodecType> codecTypes = bluetoothA2dp.getSupportedCodecTypes(); + for (BluetoothCodecType codecType : codecTypes) { + if (codecType.getCodecId() == codecIdValue) { + selectedCodecType = codecType; + } + } + + if (selectedCodecType == null) { + Log.e( + TAG, + "writeConfigurationValues: No selectable codec ID: " + + codecIdValue + + " found. Unable to change codec"); + return; + } + + if (DEBUG) { + Log.d(TAG, "writeConfigurationValues: Selected codec: " + selectedCodecType.toString()); + } + final BluetoothCodecStatus codecStatus = getBluetoothCodecStatus(); + if (codecStatus == null) { + Log.e(TAG, "writeConfigurationValues: Bluetooth Codec Status is null"); + return; + } + + final List<BluetoothCodecConfig> codecConfigs = + codecStatus.getCodecsSelectableCapabilities(); + for (BluetoothCodecConfig config : codecConfigs) { + BluetoothCodecType codecType = config.getExtendedCodecType(); + if (codecType == null) { + Log.e(TAG, "codec type for config:" + config + " is null"); + } + if (codecType != null && codecType.equals(selectedCodecType)) { + selectedCodecConfig = config; + } + } + + if (selectedCodecConfig == null) { + Log.e( + TAG, + "writeConfigurationValues: No selectable codec config for codec: " + + selectedCodecType.toString()); + return; + } + + if (mBluetoothA2dpConfigStore == null) { + Log.e(TAG, "writeConfigurationValues: Bluetooth A2dp Config Store is null"); + return; + } + + mBluetoothA2dpConfigStore.setCodecType(selectedCodecType); + mBluetoothA2dpConfigStore.setCodecPriority(BluetoothCodecConfig.CODEC_PRIORITY_HIGHEST); + mBluetoothA2dpConfigStore.setSampleRate( + AbstractBluetoothDialogPreferenceController.getHighestSampleRate( + selectedCodecConfig)); + mBluetoothA2dpConfigStore.setBitsPerSample( + AbstractBluetoothDialogPreferenceController.getHighestBitsPerSample( + selectedCodecConfig)); + mBluetoothA2dpConfigStore.setChannelMode( + AbstractBluetoothDialogPreferenceController.getHighestChannelMode( + selectedCodecConfig)); + } + + private long getCodecIdFromEntryValue(String entryValue) { + long codecType = BluetoothCodecType.CODEC_ID_SBC; + if (entryValue.isEmpty() || Long.valueOf(entryValue) == DEFAULT_VALUE_INT) { + return codecType; + } + return Long.valueOf(entryValue); + } +} diff --git a/tests/robotests/src/com/android/settings/development/bluetooth/AbstractBluetoothListPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/development/bluetooth/AbstractBluetoothListPreferenceControllerTest.java new file mode 100644 index 00000000000..8abc633f84d --- /dev/null +++ b/tests/robotests/src/com/android/settings/development/bluetooth/AbstractBluetoothListPreferenceControllerTest.java @@ -0,0 +1,240 @@ +/* + * Copyright (C) 2023 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.settings.development.bluetooth; + +import static android.bluetooth.BluetoothCodecConfig.CODEC_PRIORITY_HIGHEST; + +import static com.google.common.truth.Truth.assertThat; + +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; +import static org.mockito.Mockito.eq; +import static org.mockito.Mockito.spy; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import android.bluetooth.BluetoothA2dp; +import android.bluetooth.BluetoothAdapter; +import android.bluetooth.BluetoothCodecConfig; +import android.bluetooth.BluetoothCodecStatus; +import android.bluetooth.BluetoothDevice; +import android.bluetooth.BluetoothProfile; +import android.content.Context; + +import androidx.lifecycle.LifecycleOwner; +import androidx.preference.ListPreference; +import androidx.preference.PreferenceScreen; + +import com.android.settings.R; +import com.android.settings.development.BluetoothA2dpConfigStore; +import com.android.settingslib.core.lifecycle.Lifecycle; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; +import org.robolectric.RobolectricTestRunner; +import org.robolectric.RuntimeEnvironment; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +@RunWith(RobolectricTestRunner.class) +public class AbstractBluetoothListPreferenceControllerTest { + + private static final String DEVICE_ADDRESS = "00:11:22:33:44:55"; + + private static String DEFAULT_ENTRY; + private static final String DEFAULT_ENTRY_VALUE = "1000"; + + @Mock private BluetoothA2dp mBluetoothA2dp; + @Mock private BluetoothAdapter mBluetoothAdapter; + @Mock private PreferenceScreen mScreen; + + private AbstractBluetoothListPreferenceController mController; + private ListPreference mPreference; + private BluetoothA2dpConfigStore mBluetoothA2dpConfigStore; + private BluetoothCodecStatus mCodecStatus; + private BluetoothCodecConfig mCodecConfigAAC; + private BluetoothCodecConfig mCodecConfigSBC; + private BluetoothCodecConfig[] mCodecConfigs = new BluetoothCodecConfig[2]; + private BluetoothDevice mActiveDevice; + private Context mContext; + private LifecycleOwner mLifecycleOwner; + private Lifecycle mLifecycle; + + @Before + public void setup() { + MockitoAnnotations.initMocks(this); + mContext = RuntimeEnvironment.application; + mLifecycleOwner = () -> mLifecycle; + mLifecycle = new Lifecycle(mLifecycleOwner); + mBluetoothA2dpConfigStore = spy(new BluetoothA2dpConfigStore()); + mActiveDevice = BluetoothAdapter.getDefaultAdapter().getRemoteDevice(DEVICE_ADDRESS); + mController = + spy( + new AbstractBluetoothListPreferenceControllerImpl( + mContext, mLifecycle, mBluetoothA2dpConfigStore)); + mController.mBluetoothAdapter = mBluetoothAdapter; + mPreference = spy(new ListPreference(mContext)); + + mCodecConfigAAC = + new BluetoothCodecConfig.Builder() + .setCodecType(BluetoothCodecConfig.SOURCE_CODEC_TYPE_AAC) + .build(); + mCodecConfigSBC = + new BluetoothCodecConfig.Builder() + .setCodecType(BluetoothCodecConfig.SOURCE_CODEC_TYPE_SBC) + .build(); + mCodecConfigs[0] = mCodecConfigAAC; + mCodecConfigs[1] = mCodecConfigSBC; + + when(mScreen.findPreference(mController.getPreferenceKey())).thenReturn(mPreference); + mController.displayPreference(mScreen); + when(mBluetoothAdapter.getActiveDevices(eq(BluetoothProfile.A2DP))) + .thenReturn(Arrays.asList(mActiveDevice)); + + DEFAULT_ENTRY = mContext.getString(R.string.bluetooth_audio_codec_default_selection); + } + + private void verifySetupDefaultListPreference() { + List<String> entries = new ArrayList<>(1); + entries.add(DEFAULT_ENTRY); + List<String> entryValues = new ArrayList<>(1); + entryValues.add(DEFAULT_ENTRY_VALUE); + + verify(mPreference).setEntries(entries.toArray(new String[entries.size()])); + verify(mPreference).setEntryValues(entryValues.toArray(new String[entryValues.size()])); + verify(mPreference).setValue(DEFAULT_ENTRY_VALUE); + verify(mPreference).setSummary(DEFAULT_ENTRY); + } + + @Test + public void onPreferenceChange_shouldSetupDefaultListPreference() { + mController.onPreferenceChange(mPreference, "" /* new value */); + verifySetupDefaultListPreference(); + } + + @Test + public void setupListPreference_wrongSize_shouldSetupDefaultListPreference() { + List<String> entries = new ArrayList<>(1); + entries.add(DEFAULT_ENTRY); + List<String> entryValues = new ArrayList<>(2); + entryValues.add(DEFAULT_ENTRY_VALUE); + entryValues.add(DEFAULT_ENTRY_VALUE); + + mController.setupListPreference(entries, entryValues, "", ""); + verifySetupDefaultListPreference(); + } + + @Test + public void setupListPreference_listEmpty_shouldSetupDefaultListPreference() { + List<String> entries = new ArrayList<>(1); + entries.add(DEFAULT_ENTRY); + List<String> entryValues = new ArrayList<>(); + + mController.setupListPreference(entries, entryValues, "", ""); + verifySetupDefaultListPreference(); + } + + @Test + public void getBluetoothCodecStatus_errorChecking() { + mController.onBluetoothServiceConnected(null); + assertThat(mController.getBluetoothCodecStatus()).isNull(); + + mController.onBluetoothServiceConnected(mBluetoothA2dp); + + when(mBluetoothA2dp.getCodecStatus(mActiveDevice)).thenReturn(null); + assertThat(mController.getBluetoothCodecStatus()).isNull(); + } + + @Test + public void getCurrentCodecConfig_errorChecking() { + mController.onBluetoothServiceConnected(null); + assertThat(mController.getCurrentCodecConfig()).isNull(); + + mController.onBluetoothServiceConnected(mBluetoothA2dp); + when(mBluetoothA2dp.getCodecStatus(mActiveDevice)).thenReturn(null); + assertThat(mController.getCurrentCodecConfig()).isNull(); + } + + @Test + public void getCurrentCodecConfig_verifyConfig() { + mCodecStatus = new BluetoothCodecStatus.Builder().setCodecConfig(mCodecConfigAAC).build(); + when(mBluetoothA2dp.getCodecStatus(mActiveDevice)).thenReturn(mCodecStatus); + mController.onBluetoothServiceConnected(mBluetoothA2dp); + + assertThat(mController.getCurrentCodecConfig()).isEqualTo(mCodecConfigAAC); + } + + @Test + public void isHDAudioEnabled_errorChecking() { + mController.onBluetoothServiceConnected(null); + assertFalse(mController.isHDAudioEnabled()); + + mController.onBluetoothServiceConnected(mBluetoothA2dp); + when(mBluetoothA2dp.isOptionalCodecsEnabled(mActiveDevice)) + .thenReturn(BluetoothA2dp.OPTIONAL_CODECS_PREF_DISABLED); + assertFalse(mController.isHDAudioEnabled()); + } + + @Test + public void isHDAudioEnabled_verifyEnabled() { + mController.onBluetoothServiceConnected(mBluetoothA2dp); + when(mBluetoothA2dp.isOptionalCodecsEnabled(mActiveDevice)) + .thenReturn(BluetoothA2dp.OPTIONAL_CODECS_PREF_ENABLED); + assertTrue(mController.isHDAudioEnabled()); + } + + @Test + public void onBluetoothServiceConnected_verifyBluetoothA2dpConfigStore() { + mCodecStatus = + new BluetoothCodecStatus.Builder() + .setCodecConfig(mCodecConfigAAC) + .setCodecsSelectableCapabilities(Arrays.asList(mCodecConfigs)) + .build(); + when(mBluetoothA2dp.getCodecStatus(mActiveDevice)).thenReturn(mCodecStatus); + mController.onBluetoothServiceConnected(mBluetoothA2dp); + + verify(mBluetoothA2dpConfigStore).setCodecType(mCodecConfigAAC.getExtendedCodecType()); + verify(mBluetoothA2dpConfigStore).setSampleRate(mCodecConfigAAC.getSampleRate()); + verify(mBluetoothA2dpConfigStore).setBitsPerSample(mCodecConfigAAC.getBitsPerSample()); + verify(mBluetoothA2dpConfigStore).setChannelMode(mCodecConfigAAC.getChannelMode()); + verify(mBluetoothA2dpConfigStore).setCodecPriority(CODEC_PRIORITY_HIGHEST); + verify(mBluetoothA2dpConfigStore) + .setCodecSpecific1Value(mCodecConfigAAC.getCodecSpecific1()); + } + + private static class AbstractBluetoothListPreferenceControllerImpl + extends AbstractBluetoothListPreferenceController { + + private AbstractBluetoothListPreferenceControllerImpl( + Context context, Lifecycle lifecycle, BluetoothA2dpConfigStore store) { + super(context, lifecycle, store); + } + + @Override + public String getPreferenceKey() { + return "KEY"; + } + + @Override + protected void writeConfigurationValues(String entryValue) {} + } +} diff --git a/tests/robotests/src/com/android/settings/development/bluetooth/BluetoothCodecListPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/development/bluetooth/BluetoothCodecListPreferenceControllerTest.java new file mode 100644 index 00000000000..b86d9df1c85 --- /dev/null +++ b/tests/robotests/src/com/android/settings/development/bluetooth/BluetoothCodecListPreferenceControllerTest.java @@ -0,0 +1,267 @@ +/* + * Copyright (C) 2023 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.settings.development.bluetooth; + +import static com.google.common.truth.Truth.assertThat; + +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; +import static org.mockito.Mockito.atLeastOnce; +import static org.mockito.Mockito.eq; +import static org.mockito.Mockito.spy; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import android.bluetooth.BluetoothA2dp; +import android.bluetooth.BluetoothAdapter; +import android.bluetooth.BluetoothCodecConfig; +import android.bluetooth.BluetoothCodecStatus; +import android.bluetooth.BluetoothCodecType; +import android.bluetooth.BluetoothDevice; +import android.bluetooth.BluetoothProfile; +import android.content.Context; + +import androidx.lifecycle.LifecycleOwner; +import androidx.preference.ListPreference; +import androidx.preference.PreferenceScreen; + +import com.android.settings.development.BluetoothA2dpConfigStore; +import com.android.settingslib.core.lifecycle.Lifecycle; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; +import org.robolectric.RobolectricTestRunner; +import org.robolectric.RuntimeEnvironment; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +@RunWith(RobolectricTestRunner.class) +public class BluetoothCodecListPreferenceControllerTest { + + private static final String DEVICE_ADDRESS = "00:11:22:33:44:55"; + + @Mock private BluetoothA2dp mBluetoothA2dp; + @Mock private BluetoothAdapter mBluetoothAdapter; + @Mock private PreferenceScreen mScreen; + @Mock private AbstractBluetoothPreferenceController.Callback mCallback; + + private BluetoothCodecListPreferenceController mController; + private ListPreference mPreference; + private BluetoothA2dpConfigStore mBluetoothA2dpConfigStore; + private BluetoothCodecStatus mCodecStatus; + private BluetoothCodecType mCodecTypeAAC; + private BluetoothCodecType mCodecTypeSBC; + private BluetoothCodecType mCodecTypeAPTX; + private BluetoothCodecType mCodecTypeLDAC; + private BluetoothCodecType mCodecTypeOPUS; + private List<BluetoothCodecType> mCodecTypes; + + private BluetoothCodecConfig mCodecConfigAAC; + private BluetoothCodecConfig mCodecConfigSBC; + private BluetoothCodecConfig mCodecConfigAPTX; + private BluetoothCodecConfig mCodecConfigAPTXHD; + private BluetoothCodecConfig mCodecConfigLDAC; + private BluetoothCodecConfig mCodecConfigOPUS; + private List<BluetoothCodecConfig> mCodecConfigs; + private BluetoothDevice mActiveDevice; + private Context mContext; + private LifecycleOwner mLifecycleOwner; + private Lifecycle mLifecycle; + + @Before + public void setup() { + MockitoAnnotations.initMocks(this); + mContext = RuntimeEnvironment.application; + mLifecycleOwner = () -> mLifecycle; + mLifecycle = new Lifecycle(mLifecycleOwner); + mBluetoothA2dpConfigStore = spy(new BluetoothA2dpConfigStore()); + mActiveDevice = BluetoothAdapter.getDefaultAdapter().getRemoteDevice(DEVICE_ADDRESS); + mController = + new BluetoothCodecListPreferenceController( + mContext, mLifecycle, mBluetoothA2dpConfigStore, mCallback); + mController.mBluetoothAdapter = mBluetoothAdapter; + mPreference = new ListPreference(mContext); + when(mScreen.findPreference(mController.getPreferenceKey())).thenReturn(mPreference); + mController.displayPreference(mScreen); + + mCodecTypeAAC = + BluetoothCodecType.createFromType(BluetoothCodecConfig.SOURCE_CODEC_TYPE_AAC); + mCodecTypeSBC = + BluetoothCodecType.createFromType(BluetoothCodecConfig.SOURCE_CODEC_TYPE_SBC); + mCodecTypeAPTX = + BluetoothCodecType.createFromType(BluetoothCodecConfig.SOURCE_CODEC_TYPE_APTX); + mCodecTypeLDAC = + BluetoothCodecType.createFromType(BluetoothCodecConfig.SOURCE_CODEC_TYPE_LDAC); + mCodecTypeOPUS = + BluetoothCodecType.createFromType(BluetoothCodecConfig.SOURCE_CODEC_TYPE_OPUS); + + mCodecTypes = new ArrayList<>(); + mCodecTypes.addAll( + Arrays.asList( + mCodecTypeSBC, + mCodecTypeAAC, + mCodecTypeAPTX, + mCodecTypeLDAC, + mCodecTypeOPUS)); + + mCodecConfigSBC = + new BluetoothCodecConfig.Builder() + .setCodecType(BluetoothCodecConfig.SOURCE_CODEC_TYPE_SBC) + .setCodecPriority(BluetoothCodecConfig.CODEC_PRIORITY_HIGHEST) + .setSampleRate( + BluetoothCodecConfig.SAMPLE_RATE_96000 + | BluetoothCodecConfig.SAMPLE_RATE_176400) + .setBitsPerSample(BluetoothCodecConfig.BITS_PER_SAMPLE_32) + .setChannelMode( + BluetoothCodecConfig.CHANNEL_MODE_MONO + | BluetoothCodecConfig.CHANNEL_MODE_STEREO) + .build(); + mCodecConfigAAC = + new BluetoothCodecConfig.Builder() + .setCodecType(BluetoothCodecConfig.SOURCE_CODEC_TYPE_AAC) + .setCodecPriority(BluetoothCodecConfig.CODEC_PRIORITY_HIGHEST) + .setSampleRate( + BluetoothCodecConfig.SAMPLE_RATE_48000 + | BluetoothCodecConfig.SAMPLE_RATE_88200) + .setBitsPerSample( + BluetoothCodecConfig.BITS_PER_SAMPLE_16 + | BluetoothCodecConfig.BITS_PER_SAMPLE_24) + .setChannelMode(BluetoothCodecConfig.CHANNEL_MODE_STEREO) + .build(); + mCodecConfigAPTX = + new BluetoothCodecConfig.Builder() + .setCodecType(BluetoothCodecConfig.SOURCE_CODEC_TYPE_APTX) + .build(); + mCodecConfigAPTXHD = + new BluetoothCodecConfig.Builder() + .setCodecType(BluetoothCodecConfig.SOURCE_CODEC_TYPE_APTX_HD) + .build(); + mCodecConfigLDAC = + new BluetoothCodecConfig.Builder() + .setCodecType(BluetoothCodecConfig.SOURCE_CODEC_TYPE_LDAC) + .build(); + mCodecConfigOPUS = + new BluetoothCodecConfig.Builder() + .setCodecType(BluetoothCodecConfig.SOURCE_CODEC_TYPE_OPUS) + .build(); + + mCodecConfigs = new ArrayList<>(); + mCodecConfigs.addAll( + Arrays.asList( + mCodecConfigOPUS, + mCodecConfigAAC, + mCodecConfigSBC, + mCodecConfigAPTX, + mCodecConfigAPTXHD, + mCodecConfigLDAC)); + + when(mBluetoothAdapter.getActiveDevices(eq(BluetoothProfile.A2DP))) + .thenReturn(Arrays.asList(mActiveDevice)); + when(mBluetoothA2dp.getSupportedCodecTypes()).thenReturn(mCodecTypes); + } + + @Test + public void writeConfigurationValues_selectDefault() { + mCodecStatus = + new BluetoothCodecStatus.Builder() + .setCodecConfig(mCodecConfigSBC) + .setCodecsSelectableCapabilities(mCodecConfigs) + .build(); + when(mBluetoothA2dp.getCodecStatus(mActiveDevice)).thenReturn(mCodecStatus); + when(mBluetoothA2dp.isOptionalCodecsEnabled(mActiveDevice)) + .thenReturn(BluetoothA2dp.OPTIONAL_CODECS_PREF_ENABLED); + + mController.onBluetoothServiceConnected(mBluetoothA2dp); + + mController.writeConfigurationValues(String.valueOf(mController.DEFAULT_VALUE_INT)); + verify(mBluetoothA2dpConfigStore, times(2)).setCodecType(mCodecTypeSBC); + } + + @Test + public void writeConfigurationValues_checkCodec() { + mCodecStatus = + new BluetoothCodecStatus.Builder() + .setCodecConfig(mCodecConfigSBC) + .setCodecsSelectableCapabilities(mCodecConfigs) + .build(); + when(mBluetoothA2dp.getCodecStatus(mActiveDevice)).thenReturn(mCodecStatus); + mController.onBluetoothServiceConnected(mBluetoothA2dp); + + mController.writeConfigurationValues(String.valueOf(mCodecTypeSBC.getCodecId())); + verify(mBluetoothA2dpConfigStore, atLeastOnce()).setCodecType(mCodecTypeSBC); + + mController.writeConfigurationValues(String.valueOf(mCodecTypeAAC.getCodecId())); + verify(mBluetoothA2dpConfigStore).setCodecType(mCodecTypeAAC); + + mController.writeConfigurationValues(String.valueOf(mCodecTypeAPTX.getCodecId())); + verify(mBluetoothA2dpConfigStore).setCodecType(mCodecTypeAPTX); + + mController.writeConfigurationValues(String.valueOf(mCodecTypeLDAC.getCodecId())); + verify(mBluetoothA2dpConfigStore).setCodecType(mCodecTypeLDAC); + + mController.writeConfigurationValues(String.valueOf(mCodecTypeOPUS.getCodecId())); + verify(mBluetoothA2dpConfigStore).setCodecType(mCodecTypeOPUS); + } + + @Test + public void writeConfigurationValues_chooseHighestConfig() { + mCodecStatus = + new BluetoothCodecStatus.Builder() + .setCodecConfig(mCodecConfigSBC) + .setCodecsSelectableCapabilities((mCodecConfigs)) + .build(); + when(mBluetoothA2dp.getCodecStatus(mActiveDevice)).thenReturn(mCodecStatus); + mController.onBluetoothServiceConnected(mBluetoothA2dp); + mController.writeConfigurationValues(String.valueOf(mCodecTypeAAC.getCodecId())); + + verify(mBluetoothA2dpConfigStore, atLeastOnce()) + .setCodecPriority(BluetoothCodecConfig.CODEC_PRIORITY_HIGHEST); + verify(mBluetoothA2dpConfigStore, atLeastOnce()) + .setSampleRate(BluetoothCodecConfig.SAMPLE_RATE_88200); + verify(mBluetoothA2dpConfigStore, atLeastOnce()) + .setBitsPerSample(BluetoothCodecConfig.BITS_PER_SAMPLE_24); + verify(mBluetoothA2dpConfigStore, atLeastOnce()) + .setChannelMode(BluetoothCodecConfig.CHANNEL_MODE_STEREO); + } + + @Test + public void onPreferenceChange_notifyPreference() { + assertFalse( + mController.onPreferenceChange( + mPreference, String.valueOf(mCodecTypeAAC.getCodecId()))); + + mController.onBluetoothServiceConnected(mBluetoothA2dp); + + assertTrue( + mController.onPreferenceChange( + mPreference, String.valueOf(mCodecTypeAAC.getCodecId()))); + + verify(mCallback).onBluetoothCodecChanged(); + } + + @Test + public void onHDAudioEnabled_setsPreferenceEnabled() { + mController.onHDAudioEnabled(/* enabled= */ true); + assertThat(mPreference.isEnabled()).isTrue(); + } +} |