PawletOS/app_Settings
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge "24Q4: Removal of a2dp_offload_codec_extensibility_settings" into main

Browse Source
This commit is contained in:
Treehugger Robot
2025-01-15 01:05:14 -08:00
committed by Android (Google) Code Review
parent cc4a8539b9 2c869d337c
commit eb927665a3
13 changed files with 23 additions and 758 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
tests/robotests/src/com/android/settings/development/bluetooth/AbstractBluetoothDialogPreferenceControllerTest.java
View File

@@ -220,7 +220,7 @@ public class AbstractBluetoothDialogPreferenceControllerTest {
mActiveDevice)).thenReturn(mCodecStatus);
mController.onBluetoothServiceConnected(mBluetoothA2dp);
verify(mBluetoothA2dpConfigStore).setCodecType(mCodecConfigAAC.getCodecType());
verify(mBluetoothA2dpConfigStore).setCodecType(mCodecConfigAAC.getExtendedCodecType());
verify(mBluetoothA2dpConfigStore).setSampleRate(mCodecConfigAAC.getSampleRate());
verify(mBluetoothA2dpConfigStore).setBitsPerSample(mCodecConfigAAC.getBitsPerSample());
verify(mBluetoothA2dpConfigStore).setChannelMode(mCodecConfigAAC.getChannelMode());

279
tests/robotests/src/com/android/settings/development/bluetooth/BluetoothCodecDialogPreferenceControllerTest.java
View File

@@ -1,279 +0,0 @@
/*
* Copyright (C) 2019 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.mockito.Mockito.atLeastOnce;
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.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.Arrays;
import java.util.List;
@RunWith(RobolectricTestRunner.class)
public class BluetoothCodecDialogPreferenceControllerTest {
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 BluetoothCodecDialogPreferenceController mController;
private BluetoothCodecDialogPreference mPreference;
private BluetoothA2dpConfigStore mBluetoothA2dpConfigStore;
private BluetoothCodecStatus mCodecStatus;
private BluetoothCodecConfig mCodecConfigAAC;
private BluetoothCodecConfig mCodecConfigSBC;
private BluetoothCodecConfig mCodecConfigAPTX;
private BluetoothCodecConfig mCodecConfigAPTXHD;
private BluetoothCodecConfig mCodecConfigLDAC;
private BluetoothCodecConfig mCodecConfigOPUS;
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 BluetoothCodecDialogPreferenceController(mContext, mLifecycle,
mBluetoothA2dpConfigStore, mCallback);
mController.mBluetoothAdapter = mBluetoothAdapter;
mPreference = new BluetoothCodecDialogPreference(mContext);
when(mScreen.findPreference(mController.getPreferenceKey())).thenReturn(mPreference);
mController.displayPreference(mScreen);
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();
when(mBluetoothAdapter.getActiveDevices(eq(BluetoothProfile.A2DP)))
.thenReturn(Arrays.asList(mActiveDevice));
}
@Test
public void writeConfigurationValues_selectDefault_setHighest() {
BluetoothCodecConfig[] mCodecConfigs = {mCodecConfigOPUS, mCodecConfigAAC,
mCodecConfigSBC};
mCodecStatus = new BluetoothCodecStatus.Builder()
.setCodecConfig(mCodecConfigSBC)
.setCodecsSelectableCapabilities(Arrays.asList(mCodecConfigs))
.build();
when(mBluetoothA2dp.getCodecStatus(mActiveDevice)).thenReturn(mCodecStatus);
when(mBluetoothA2dp.isOptionalCodecsEnabled(mActiveDevice)).thenReturn(
BluetoothA2dp.OPTIONAL_CODECS_PREF_ENABLED);
mController.onBluetoothServiceConnected(mBluetoothA2dp);
mController.writeConfigurationValues(0);
verify(mBluetoothA2dpConfigStore).setCodecType(
BluetoothCodecConfig.SOURCE_CODEC_TYPE_OPUS);
}
@Test
public void writeConfigurationValues_checkCodec() {
BluetoothCodecConfig[] mCodecConfigs = {mCodecConfigOPUS, mCodecConfigAAC,
mCodecConfigSBC, mCodecConfigAPTX, mCodecConfigAPTXHD, mCodecConfigLDAC};
mCodecStatus = new BluetoothCodecStatus.Builder()
.setCodecConfig(mCodecConfigSBC)
.setCodecsSelectableCapabilities(Arrays.asList(mCodecConfigs))
.build();
when(mBluetoothA2dp.getCodecStatus(mActiveDevice)).thenReturn(mCodecStatus);
mController.onBluetoothServiceConnected(mBluetoothA2dp);
mController.writeConfigurationValues(1);
verify(mBluetoothA2dpConfigStore, atLeastOnce()).setCodecType(
BluetoothCodecConfig.SOURCE_CODEC_TYPE_SBC);
mController.writeConfigurationValues(2);
verify(mBluetoothA2dpConfigStore).setCodecType(BluetoothCodecConfig.SOURCE_CODEC_TYPE_AAC);
mController.writeConfigurationValues(3);
verify(mBluetoothA2dpConfigStore).setCodecType(BluetoothCodecConfig.SOURCE_CODEC_TYPE_APTX);
mController.writeConfigurationValues(4);
verify(mBluetoothA2dpConfigStore).setCodecType(
BluetoothCodecConfig.SOURCE_CODEC_TYPE_APTX_HD);
mController.writeConfigurationValues(5);
verify(mBluetoothA2dpConfigStore).setCodecType(BluetoothCodecConfig.SOURCE_CODEC_TYPE_LDAC);
mController.writeConfigurationValues(7);
verify(mBluetoothA2dpConfigStore).setCodecType(
BluetoothCodecConfig.SOURCE_CODEC_TYPE_OPUS);
}
@Test
public void writeConfigurationValues_resetHighestConfig() {
BluetoothCodecConfig[] mCodecConfigs = {mCodecConfigAAC, mCodecConfigSBC, mCodecConfigAPTX,
mCodecConfigAPTXHD, mCodecConfigLDAC, mCodecConfigOPUS};
mCodecStatus = new BluetoothCodecStatus.Builder()
.setCodecConfig(mCodecConfigAAC)
.setCodecsSelectableCapabilities(Arrays.asList(mCodecConfigs))
.build();
when(mBluetoothA2dp.getCodecStatus(mActiveDevice)).thenReturn(mCodecStatus);
mController.onBluetoothServiceConnected(mBluetoothA2dp);
mController.writeConfigurationValues(2);
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 getCurrentIndexByConfig_verifyIndex() {
assertThat(mController.getCurrentIndexByConfig(mCodecConfigAAC)).isEqualTo(
mController.convertCfgToBtnIndex(BluetoothCodecConfig.SOURCE_CODEC_TYPE_AAC));
}
@Test
public void getCurrentIndexByConfig_verifyOpusIndex() {
assertThat(mController.getCurrentIndexByConfig(mCodecConfigOPUS)).isEqualTo(
mController.convertCfgToBtnIndex(
BluetoothCodecConfig.SOURCE_CODEC_TYPE_OPUS));
}
@Test
public void onIndexUpdated_notifyPreference() {
mController.onIndexUpdated(0);
verify(mCallback).onBluetoothCodecChanged();
}
@Test
public void onHDAudioEnabled_optionalCodecEnabled_setsCodecTypeAsOpus() {
List<BluetoothCodecConfig> mCodecConfigs = Arrays.asList(mCodecConfigOPUS,
mCodecConfigAAC, mCodecConfigSBC);
mCodecStatus = new BluetoothCodecStatus.Builder()
.setCodecConfig(mCodecConfigOPUS)
.setCodecsSelectableCapabilities(mCodecConfigs)
.build();
when(mBluetoothA2dp.getCodecStatus(mActiveDevice)).thenReturn(mCodecStatus);
when(mBluetoothA2dp.isOptionalCodecsEnabled(mActiveDevice)).thenReturn(
BluetoothA2dp.OPTIONAL_CODECS_PREF_ENABLED);
mController.onBluetoothServiceConnected(mBluetoothA2dp);
mController.onHDAudioEnabled(/* enabled= */ true);
verify(mBluetoothA2dpConfigStore, atLeastOnce()).setCodecType(
eq(BluetoothCodecConfig.SOURCE_CODEC_TYPE_OPUS));
}
@Test
public void onHDAudioEnabled_optionalCodecEnabled_setsCodecTypeAsAAC() {
List<BluetoothCodecConfig> mCodecConfigs = Arrays.asList(mCodecConfigOPUS,
mCodecConfigAAC, mCodecConfigSBC);
mCodecStatus = new BluetoothCodecStatus.Builder()
.setCodecConfig(mCodecConfigAAC)
.setCodecsSelectableCapabilities(mCodecConfigs)
.build();
when(mBluetoothA2dp.getCodecStatus(mActiveDevice)).thenReturn(mCodecStatus);
when(mBluetoothA2dp.isOptionalCodecsEnabled(mActiveDevice)).thenReturn(
BluetoothA2dp.OPTIONAL_CODECS_PREF_ENABLED);
mController.onBluetoothServiceConnected(mBluetoothA2dp);
mController.onHDAudioEnabled(/* enabled= */ true);
verify(mBluetoothA2dpConfigStore, atLeastOnce()).setCodecType(
eq(BluetoothCodecConfig.SOURCE_CODEC_TYPE_AAC));
}
@Test
public void onHDAudioEnabled_optionalCodecDisabled_setsCodecTypeAsSBC() {
List<BluetoothCodecConfig> mCodecConfigs = Arrays.asList(mCodecConfigOPUS,
mCodecConfigAAC, mCodecConfigSBC);
mCodecStatus = new BluetoothCodecStatus.Builder()
.setCodecConfig(mCodecConfigAAC)
.setCodecsSelectableCapabilities(mCodecConfigs)
.build();
when(mBluetoothA2dp.getCodecStatus(mActiveDevice)).thenReturn(mCodecStatus);
when(mBluetoothA2dp.isOptionalCodecsEnabled(mActiveDevice)).thenReturn(
BluetoothA2dp.OPTIONAL_CODECS_PREF_DISABLED);
mController.onBluetoothServiceConnected(mBluetoothA2dp);
mController.onHDAudioEnabled(/* enabled= */ false);
verify(mBluetoothA2dpConfigStore, atLeastOnce()).setCodecType(
eq(BluetoothCodecConfig.SOURCE_CODEC_TYPE_SBC));
}
}

50
tests/robotests/src/com/android/settings/development/bluetooth/BluetoothCodecDialogPreferenceTest.java
View File

@@ -1,50 +0,0 @@
/*
* Copyright (C) 2019 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 android.content.Context;
import com.android.settings.R;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.MockitoAnnotations;
import org.robolectric.RobolectricTestRunner;
import org.robolectric.RuntimeEnvironment;
@RunWith(RobolectricTestRunner.class)
public class BluetoothCodecDialogPreferenceTest {
private BluetoothCodecDialogPreference mPreference;
private Context mContext;
@Before
public void setup() {
MockitoAnnotations.initMocks(this);
mContext = RuntimeEnvironment.application;
mPreference = new BluetoothCodecDialogPreference(mContext);
}
@Test
public void getRadioButtonGroupId() {
assertThat(mPreference.getRadioButtonGroupId())
.isEqualTo(R.id.bluetooth_audio_codec_radio_group);
}
}

26
tests/robotests/src/com/android/settings/development/bluetooth/BluetoothCodecListPreferenceControllerTest.java
View File

@@ -18,7 +18,6 @@ package com.android.settings.development.bluetooth;
import static com.google.common.truth.Truth.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.atLeastOnce;
@@ -35,14 +34,12 @@ import android.bluetooth.BluetoothCodecType;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothProfile;
import android.content.Context;
import android.platform.test.annotations.EnableFlags;
import androidx.lifecycle.LifecycleOwner;
import androidx.preference.ListPreference;
import androidx.preference.PreferenceScreen;
import com.android.settings.development.BluetoothA2dpConfigStore;
import com.android.settings.development.Flags;
import com.android.settingslib.core.lifecycle.Lifecycle;
import org.junit.Before;
@@ -73,6 +70,7 @@ public class BluetoothCodecListPreferenceControllerTest {
private BluetoothCodecType mCodecTypeAAC;
private BluetoothCodecType mCodecTypeSBC;
private BluetoothCodecType mCodecTypeAPTX;
private BluetoothCodecType mCodecTypeAPTXHD;
private BluetoothCodecType mCodecTypeLDAC;
private BluetoothCodecType mCodecTypeOPUS;
private List<BluetoothCodecType> mCodecTypes;
@@ -114,6 +112,8 @@ public class BluetoothCodecListPreferenceControllerTest {
BluetoothCodecType.createFromType(BluetoothCodecConfig.SOURCE_CODEC_TYPE_SBC);
mCodecTypeAPTX =
BluetoothCodecType.createFromType(BluetoothCodecConfig.SOURCE_CODEC_TYPE_APTX);
mCodecTypeAPTXHD =
BluetoothCodecType.createFromType(BluetoothCodecConfig.SOURCE_CODEC_TYPE_APTX_HD);
mCodecTypeLDAC =
BluetoothCodecType.createFromType(BluetoothCodecConfig.SOURCE_CODEC_TYPE_LDAC);
mCodecTypeOPUS =
@@ -125,6 +125,7 @@ public class BluetoothCodecListPreferenceControllerTest {
mCodecTypeSBC,
mCodecTypeAAC,
mCodecTypeAPTX,
mCodecTypeAPTXHD,
mCodecTypeLDAC,
mCodecTypeOPUS));
@@ -212,6 +213,11 @@ public class BluetoothCodecListPreferenceControllerTest {
mController.writeConfigurationValues(String.valueOf(mCodecTypeAPTX.getCodecId())));
verify(mBluetoothA2dpConfigStore).setCodecType(mCodecTypeAPTX);
assertTrue(
mController.writeConfigurationValues(String.valueOf(
mCodecTypeAPTXHD.getCodecId())));
verify(mBluetoothA2dpConfigStore).setCodecType(mCodecTypeAPTXHD);
assertTrue(
mController.writeConfigurationValues(String.valueOf(mCodecTypeLDAC.getCodecId())));
verify(mBluetoothA2dpConfigStore).setCodecType(mCodecTypeLDAC);
@@ -244,7 +250,6 @@ public class BluetoothCodecListPreferenceControllerTest {
}
@Test
@EnableFlags(Flags.FLAG_A2DP_OFFLOAD_CODEC_EXTENSIBILITY_SETTINGS)
public void onPreferenceChange_notifyPreference() {
assertFalse(
mController.onPreferenceChange(
@@ -271,7 +276,6 @@ public class BluetoothCodecListPreferenceControllerTest {
}
@Test
@EnableFlags(Flags.FLAG_A2DP_OFFLOAD_CODEC_EXTENSIBILITY_SETTINGS)
public void onPreferenceChange_listPreferenceIsNull() {
when(mScreen.findPreference(mController.getPreferenceKey())).thenReturn(null);
assertFalse(
@@ -280,13 +284,11 @@ public class BluetoothCodecListPreferenceControllerTest {
}
@Test
@EnableFlags(Flags.FLAG_A2DP_OFFLOAD_CODEC_EXTENSIBILITY_SETTINGS)
public void onPreferenceChange_unknownCodecId() {
assertFalse(mController.onPreferenceChange(mPreference, String.valueOf(TEST_ENTRY_VALUE)));
}
@Test
@EnableFlags(Flags.FLAG_A2DP_OFFLOAD_CODEC_EXTENSIBILITY_SETTINGS)
public void onPreferenceChange_codecSelection() {
when(mBluetoothA2dp.getCodecStatus(mActiveDevice)).thenReturn(mCodecStatus);
when(mBluetoothA2dp.isOptionalCodecsEnabled(mActiveDevice))
@@ -325,6 +327,14 @@ public class BluetoothCodecListPreferenceControllerTest {
assertTrue(
mController.onPreferenceChange(
mPreference, String.valueOf(mCodecTypeAPTX.getCodecId())));
mCodecStatus =
new BluetoothCodecStatus.Builder()
.setCodecConfig(mCodecConfigAPTXHD)
.setCodecsSelectableCapabilities(mCodecConfigs)
.build();
assertTrue(
mController.onPreferenceChange(
mPreference, String.valueOf(mCodecTypeAPTXHD.getCodecId())));
mCodecStatus =
new BluetoothCodecStatus.Builder()
.setCodecConfig(mCodecConfigOPUS)
@@ -336,7 +346,6 @@ public class BluetoothCodecListPreferenceControllerTest {
}
@Test
@EnableFlags(Flags.FLAG_A2DP_OFFLOAD_CODEC_EXTENSIBILITY_SETTINGS)
public void updateState_notifyPreference() {
assertFalse(
mController.onPreferenceChange(
@@ -437,7 +446,6 @@ public class BluetoothCodecListPreferenceControllerTest {
}
@Test
@EnableFlags(Flags.FLAG_A2DP_OFFLOAD_CODEC_EXTENSIBILITY_SETTINGS)
public void onBluetoothServiceConnected_verifyBluetoothA2dpConfigStore() {
mCodecStatus =
new BluetoothCodecStatus.Builder()