Merge "Fix SubscriptionInfoListViewModelTest" into main
diff --git a/aconfig/development/settings_core_flag_declarations.aconfig b/aconfig/development/settings_core_flag_declarations.aconfig
index b73b026..fec67f6 100644
--- a/aconfig/development/settings_core_flag_declarations.aconfig
+++ b/aconfig/development/settings_core_flag_declarations.aconfig
@@ -2,6 +2,13 @@
container: "system"
flag {
+ name: "a2dp_offload_codec_extensibility_settings"
+ namespace: "bluetooth"
+ description: "Feature flag for Bluetooth Audio Codec extensibility in Settings"
+ bug: "323319530"
+}
+
+flag {
name: "deprecate_list_activity"
namespace: "android_settings"
description: "Feature flag for deprecating ListActivity in Settings"
diff --git a/res/values/strings.xml b/res/values/strings.xml
index f1c995f..b275638 100644
--- a/res/values/strings.xml
+++ b/res/values/strings.xml
@@ -178,6 +178,9 @@
<!-- Description for text in accessibility hearing aids footer. [CHAR LIMIT=NONE] -->
<string name="bluetooth_audio_routing_footer_summary">By default, audio output is determined by individual apps</string>
+ <!-- Bluetooth audio codec related settings. Title of the default audio codec selection. [CHAR LIMIT=60] -->
+ <string name="bluetooth_audio_codec_default_selection">Use System Selection (Default)</string>
+
<!--Bluetooth settings screen, summary text for Bluetooth device with no name -->
<string name="bluetooth_device">Unnamed Bluetooth device</string>
<!--Bluetooth settings screen, text that appears in heading bar when scanning for devices -->
diff --git a/res/xml/development_settings.xml b/res/xml/development_settings.xml
index 23eb1f2..682a9c2 100644
--- a/res/xml/development_settings.xml
+++ b/res/xml/development_settings.xml
@@ -430,6 +430,11 @@
android:positiveButtonText=""
android:negativeButtonText="@string/dlg_ok"/>
+ <ListPreference
+ android:key="bluetooth_audio_codec_settings_list"
+ android:title="@string/bluetooth_select_a2dp_codec_type"
+ android:dialogTitle="@string/bluetooth_select_a2dp_codec_type_dialog_title"/>
+
<com.android.settings.development.bluetooth.BluetoothSampleRateDialogPreference
android:key="bluetooth_sample_rate_settings"
android:title="@string/bluetooth_select_a2dp_codec_sample_rate"
diff --git a/src/com/android/settings/development/BluetoothA2dpConfigStore.java b/src/com/android/settings/development/BluetoothA2dpConfigStore.java
index 7fd7b13..d6b849f 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 @@
private long mCodecSpecific4Value;
public void setCodecType(int codecType) {
+ mCodecTypeNative = codecType;
+ }
+
+ public void setCodecType(@Nullable BluetoothCodecType codecType) {
mCodecType = codecType;
}
@@ -70,9 +78,26 @@
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 3e211de..43aa783 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.AutofillLoggingLevelPreferenceController;
import com.android.settings.development.autofill.AutofillResetOptionsPreferenceController;
import com.android.settings.development.bluetooth.AbstractBluetoothDialogPreferenceController;
+import com.android.settings.development.bluetooth.AbstractBluetoothListPreferenceController;
import com.android.settings.development.bluetooth.AbstractBluetoothPreferenceController;
import com.android.settings.development.bluetooth.BluetoothBitPerSampleDialogPreferenceController;
import com.android.settings.development.bluetooth.BluetoothChannelModeDialogPreferenceController;
import com.android.settings.development.bluetooth.BluetoothCodecDialogPreferenceController;
+import com.android.settings.development.bluetooth.BluetoothCodecListPreferenceController;
import com.android.settings.development.bluetooth.BluetoothHDAudioPreferenceController;
import com.android.settings.development.bluetooth.BluetoothQualityDialogPreferenceController;
import com.android.settings.development.bluetooth.BluetoothSampleRateDialogPreferenceController;
@@ -744,6 +746,9 @@
controllers.add(new AutofillResetOptionsPreferenceController(context));
controllers.add(new BluetoothCodecDialogPreferenceController(context, lifecycle,
bluetoothA2dpConfigStore, fragment));
+ controllers.add(
+ new BluetoothCodecListPreferenceController(
+ context, lifecycle, bluetoothA2dpConfigStore, fragment));
controllers.add(new BluetoothSampleRateDialogPreferenceController(context, lifecycle,
bluetoothA2dpConfigStore));
controllers.add(new BluetoothBitPerSampleDialogPreferenceController(context, lifecycle,
@@ -792,6 +797,9 @@
((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 0000000..9436e06
--- /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 d3fab67..14bc275 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.BluetoothProfile;
import android.content.Context;
+import androidx.annotation.Nullable;
import androidx.annotation.VisibleForTesting;
import com.android.settings.core.PreferenceControllerMixin;
@@ -42,13 +43,15 @@
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 2f0d27c..b7b5574 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.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 @@
}
@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 0000000..79b629e
--- /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/src/com/android/settings/display/BrightnessLevelPreferenceController.java b/src/com/android/settings/display/BrightnessLevelPreferenceController.java
index ac1a1cb..468a1d8 100644
--- a/src/com/android/settings/display/BrightnessLevelPreferenceController.java
+++ b/src/com/android/settings/display/BrightnessLevelPreferenceController.java
@@ -31,6 +31,8 @@
import android.net.Uri;
import android.os.Handler;
import android.os.Looper;
+import android.os.Process;
+import android.os.UserManager;
import android.provider.Settings.System;
import android.text.TextUtils;
@@ -116,6 +118,10 @@
@Override
public void updateState(Preference preference) {
+ if (preference.isEnabled() && UserManager.get(mContext).hasBaseUserRestriction(
+ UserManager.DISALLOW_CONFIG_BRIGHTNESS, Process.myUserHandle())) {
+ preference.setEnabled(false);
+ }
updatedSummary(preference);
}
diff --git a/src/com/android/settings/display/ScreenTimeoutPreferenceController.java b/src/com/android/settings/display/ScreenTimeoutPreferenceController.java
index 1254116..5809c79 100644
--- a/src/com/android/settings/display/ScreenTimeoutPreferenceController.java
+++ b/src/com/android/settings/display/ScreenTimeoutPreferenceController.java
@@ -23,6 +23,7 @@
import android.app.admin.DevicePolicyManager;
import android.content.Context;
+import android.os.Process;
import android.os.UserHandle;
import android.os.UserManager;
import android.provider.Settings;
@@ -67,9 +68,13 @@
.getString(DISABLED_BY_IT_ADMIN_TITLE,
() -> mContext.getString(R.string.disabled_by_policy_title)));
((RestrictedPreference) preference).setDisabledByAdmin(admin);
- } else {
- preference.setSummary(getTimeoutSummary(maxTimeout));
+ return;
}
+ if (UserManager.get(mContext).hasBaseUserRestriction(
+ UserManager.DISALLOW_CONFIG_SCREEN_TIMEOUT, Process.myUserHandle())) {
+ preference.setEnabled(false);
+ }
+ preference.setSummary(getTimeoutSummary(maxTimeout));
}
private CharSequence getTimeoutSummary(long maxTimeout) {
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 0000000..8abc633
--- /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 0000000..b86d9df
--- /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();
+ }
+}