Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 8e2aa11e authored by timhypeng's avatar timhypeng
Browse files

Add codec dialog preference controller for Bluetooth developer option 

Bug: 142227996
Test: make -j50 RunSettingsRoboTests
Change-Id: I5cff61f9f90d9e6a125455685a3608be043f6e7c
parent 810f7861

src/com/android/settings/development/bluetooth/BluetoothCodecDialogPreferenceController.java

0 → 100644
+190 −0
Original line number Diff line number Diff line 
/*

 * 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 android.bluetooth.BluetoothA2dp;

import android.bluetooth.BluetoothCodecConfig;

import android.bluetooth.BluetoothDevice;

import android.content.Context;

import android.util.Log;



import androidx.annotation.VisibleForTesting;

import androidx.preference.PreferenceScreen;



import com.android.settings.development.BluetoothA2dpConfigStore;

import com.android.settingslib.core.lifecycle.Lifecycle;



import java.util.ArrayList;

import java.util.List;



/**

 * Dialog preference controller to set the Bluetooth A2DP config of codec

 */

public class BluetoothCodecDialogPreferenceController extends

        AbstractBluetoothDialogPreferenceController {



    private static final String KEY = "bluetooth_audio_codec_settings";

    private static final String TAG = "BtCodecCtr";



    private final Callback mCallback;



    public BluetoothCodecDialogPreferenceController(Context context, Lifecycle lifecycle,

                                                    BluetoothA2dpConfigStore store,

                                                    Callback callback) {

        super(context, lifecycle, store);

        mCallback = callback;

    }



    @Override

    public String getPreferenceKey() {

        return KEY;

    }



    @Override

    public void displayPreference(PreferenceScreen screen) {

        super.displayPreference(screen);

        ((BaseBluetoothDialogPreference) mPreference).setCallback(this);

    }



    @Override

    public void onHDAudioEnabled(boolean enabled) {

        if (!enabled) {

            // If option codec is disabled, SBC is the only only one available codec.

            onIndexUpdated(convertCfgToBtnIndex(BluetoothCodecConfig.SOURCE_CODEC_TYPE_SBC));

        }

    }



    @Override

    public List<Integer> getSelectableIndex() {

        List<Integer> index = new ArrayList<>();

        final BluetoothA2dp bluetoothA2dp = mBluetoothA2dp;



        index.add(getDefaultIndex());

        if (bluetoothA2dp == null) {

            return index;

        }

        final BluetoothDevice activeDevice = bluetoothA2dp.getActiveDevice();

        if (activeDevice == null) {

            Log.d(TAG, "Unable to get selectable index. No Active Bluetooth device");

            return index;

        }

        // Check HD audio is enabled, display the available list.

        if (bluetoothA2dp.getOptionalCodecsEnabled(activeDevice)

                == BluetoothA2dp.OPTIONAL_CODECS_PREF_ENABLED) {

            BluetoothCodecConfig[] configs = getSelectableConfigs(null);

            if (configs != null) {

                return getIndexFromConfig(configs);

            }

        }

        // If HD audio is disabled, SBC is the only one available codec.

        index.add(convertCfgToBtnIndex(BluetoothCodecConfig.SOURCE_CODEC_TYPE_SBC));

        return index;

    }



    @Override

    protected void writeConfigurationValues(final int index) {

        int codecTypeValue = BluetoothCodecConfig.SOURCE_CODEC_TYPE_SBC; // default

        int codecPriorityValue = BluetoothCodecConfig.CODEC_PRIORITY_DEFAULT;

        switch (index) {

            case 0:

                codecTypeValue = getHighestCodec(getSelectableConfigs(null));

                codecPriorityValue = BluetoothCodecConfig.CODEC_PRIORITY_HIGHEST;

                break;

            case 1:

                codecTypeValue = BluetoothCodecConfig.SOURCE_CODEC_TYPE_SBC;

                codecPriorityValue = BluetoothCodecConfig.CODEC_PRIORITY_HIGHEST;

                break;

            case 2:

                codecTypeValue = BluetoothCodecConfig.SOURCE_CODEC_TYPE_AAC;

                codecPriorityValue = BluetoothCodecConfig.CODEC_PRIORITY_HIGHEST;

                break;

            case 3:

                codecTypeValue = BluetoothCodecConfig.SOURCE_CODEC_TYPE_APTX;

                codecPriorityValue = BluetoothCodecConfig.CODEC_PRIORITY_HIGHEST;

                break;

            case 4:

                codecTypeValue = BluetoothCodecConfig.SOURCE_CODEC_TYPE_APTX_HD;

                codecPriorityValue = BluetoothCodecConfig.CODEC_PRIORITY_HIGHEST;

                break;

            case 5:

                codecTypeValue = BluetoothCodecConfig.SOURCE_CODEC_TYPE_LDAC;

                codecPriorityValue = BluetoothCodecConfig.CODEC_PRIORITY_HIGHEST;

                break;

            default:

                break;

        }

        mBluetoothA2dpConfigStore.setCodecType(codecTypeValue);

        mBluetoothA2dpConfigStore.setCodecPriority(codecPriorityValue);



        // Once user changes codec, to reset configs with highest quality.

        final BluetoothCodecConfig config = getSelectableByCodecType(codecTypeValue);

        if (config == null) {

            Log.d(TAG, "Selectable config is null. Unable to reset");

        }

        mBluetoothA2dpConfigStore.setSampleRate(getHighestSampleRate(config));

        mBluetoothA2dpConfigStore.setBitsPerSample(getHighestBitsPerSample(config));

        mBluetoothA2dpConfigStore.setChannelMode(getHighestChannelMode(config));

    }



    @Override

    protected int getCurrentIndexByConfig(BluetoothCodecConfig config) {

        if (config == null) {

            Log.e(TAG, "Unable to get current config index. Config is null.");

        }

        return convertCfgToBtnIndex(config.getCodecType());

    }



    @Override

    public void onIndexUpdated(int index) {

        super.onIndexUpdated(index);

        mCallback.onBluetoothCodecChanged();

    }



    private List<Integer> getIndexFromConfig(BluetoothCodecConfig[] configs) {

        List<Integer> indexArray = new ArrayList<>();

        for (int i = 0; i < configs.length; i++) {

            indexArray.add(convertCfgToBtnIndex(configs[i].getCodecType()));

        }

        return indexArray;

    }



    @VisibleForTesting

    int convertCfgToBtnIndex(int config) {

        int index = getDefaultIndex();

        switch (config) {

            case BluetoothCodecConfig.SOURCE_CODEC_TYPE_SBC:

                index = 1;

                break;

            case BluetoothCodecConfig.SOURCE_CODEC_TYPE_AAC:

                index = 2;

                break;

            case BluetoothCodecConfig.SOURCE_CODEC_TYPE_APTX:

                index = 3;

                break;

            case BluetoothCodecConfig.SOURCE_CODEC_TYPE_APTX_HD:

                index = 4;

                break;

            case BluetoothCodecConfig.SOURCE_CODEC_TYPE_LDAC:

                index = 5;

                break;

            default:

                Log.e(TAG, "Unsupported config:" + config);

                break;

        }

        return index;

    }

}

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

0 → 100644
+162 −0
Original line number Diff line number Diff line 
/*

 * 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.spy;

import static org.mockito.Mockito.verify;

import static org.mockito.Mockito.when;



import android.bluetooth.BluetoothA2dp;

import android.bluetooth.BluetoothCodecConfig;

import android.bluetooth.BluetoothCodecStatus;

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;



@RunWith(RobolectricTestRunner.class)

public class BluetoothCodecDialogPreferenceControllerTest {



    @Mock

    private BluetoothA2dp mBluetoothA2dp;

    @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 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());

        mController = new BluetoothCodecDialogPreferenceController(mContext, mLifecycle,

                mBluetoothA2dpConfigStore, mCallback);

        mPreference = new BluetoothCodecDialogPreference(mContext);

        when(mScreen.findPreference(mController.getPreferenceKey())).thenReturn(mPreference);

        mController.displayPreference(mScreen);

        mCodecConfigSBC = new BluetoothCodecConfig(BluetoothCodecConfig.SOURCE_CODEC_TYPE_SBC,

                BluetoothCodecConfig.CODEC_PRIORITY_HIGHEST,

                BluetoothCodecConfig.SAMPLE_RATE_96000 | BluetoothCodecConfig.SAMPLE_RATE_176400,

                BluetoothCodecConfig.BITS_PER_SAMPLE_32,

                BluetoothCodecConfig.CHANNEL_MODE_MONO | BluetoothCodecConfig.CHANNEL_MODE_STEREO,

                0, 0, 0, 0);

        mCodecConfigAAC = new BluetoothCodecConfig(BluetoothCodecConfig.SOURCE_CODEC_TYPE_AAC,

                BluetoothCodecConfig.CODEC_PRIORITY_HIGHEST,

                BluetoothCodecConfig.SAMPLE_RATE_48000 | BluetoothCodecConfig.SAMPLE_RATE_88200,

                BluetoothCodecConfig.BITS_PER_SAMPLE_16 | BluetoothCodecConfig.BITS_PER_SAMPLE_24,

                BluetoothCodecConfig.CHANNEL_MODE_STEREO,

                0, 0, 0, 0);

        mCodecConfigAPTX = new BluetoothCodecConfig(BluetoothCodecConfig.SOURCE_CODEC_TYPE_APTX);

        mCodecConfigAPTXHD = new BluetoothCodecConfig(

                BluetoothCodecConfig.SOURCE_CODEC_TYPE_APTX_HD);

        mCodecConfigLDAC = new BluetoothCodecConfig(BluetoothCodecConfig.SOURCE_CODEC_TYPE_LDAC);

    }



    @Test

    public void writeConfigurationValues_selectDefault_setHighest() {

        BluetoothCodecConfig[] mCodecConfigs = {mCodecConfigAAC, mCodecConfigSBC};

        mCodecStatus = new BluetoothCodecStatus(mCodecConfigSBC, null, mCodecConfigs);

        when(mBluetoothA2dp.getCodecStatus(null)).thenReturn(mCodecStatus);

        mController.onBluetoothServiceConnected(mBluetoothA2dp);



        mController.writeConfigurationValues(0);

        verify(mBluetoothA2dpConfigStore).setCodecType(BluetoothCodecConfig.SOURCE_CODEC_TYPE_AAC);

    }



    @Test

    public void writeConfigurationValues_checkCodec() {

        BluetoothCodecConfig[] mCodecConfigs = {mCodecConfigAAC, mCodecConfigSBC, mCodecConfigAPTX,

                mCodecConfigAPTXHD, mCodecConfigLDAC, mCodecConfigAAC, mCodecConfigSBC};

        mCodecStatus = new BluetoothCodecStatus(mCodecConfigSBC, null, mCodecConfigs);

        when(mBluetoothA2dp.getCodecStatus(null)).thenReturn(mCodecStatus);

        mController.onBluetoothServiceConnected(mBluetoothA2dp);



        mController.writeConfigurationValues(1);

        verify(mBluetoothA2dpConfigStore).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);



    }



    @Test

    public void writeConfigurationValues_resetHighestConfig() {

        BluetoothCodecConfig[] mCodecConfigs = {mCodecConfigAAC, mCodecConfigSBC, mCodecConfigAPTX,

                mCodecConfigAPTXHD, mCodecConfigLDAC, mCodecConfigAAC, mCodecConfigSBC};

        mCodecStatus = new BluetoothCodecStatus(mCodecConfigAAC, null, mCodecConfigs);

        when(mBluetoothA2dp.getCodecStatus(null)).thenReturn(mCodecStatus);

        mController.onBluetoothServiceConnected(mBluetoothA2dp);

        mController.writeConfigurationValues(2);



        verify(mBluetoothA2dpConfigStore).setCodecPriority(

                BluetoothCodecConfig.CODEC_PRIORITY_HIGHEST);

        verify(mBluetoothA2dpConfigStore).setSampleRate(BluetoothCodecConfig.SAMPLE_RATE_88200);

        verify(mBluetoothA2dpConfigStore).setBitsPerSample(BluetoothCodecConfig.BITS_PER_SAMPLE_24);

        verify(mBluetoothA2dpConfigStore).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 onIndexUpdated_notifyPreference() {

        mController.onIndexUpdated(0);



        verify(mCallback).onBluetoothCodecChanged();

    }

}