Merge "developer settings: remove unused a2dp Preference" into main am: b896665a

/*

 * Copyright (C) 2017 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

package com.android.settings.development;

import android.bluetooth.BluetoothA2dp;

import android.bluetooth.BluetoothAdapter;

import android.bluetooth.BluetoothCodecConfig;

import android.bluetooth.BluetoothCodecStatus;

import android.bluetooth.BluetoothDevice;

import android.bluetooth.BluetoothManager;

import android.bluetooth.BluetoothProfile;

import android.content.Context;

import androidx.annotation.VisibleForTesting;

import androidx.preference.ListPreference;

import androidx.preference.Preference;

import androidx.preference.PreferenceScreen;

import com.android.settings.core.PreferenceControllerMixin;

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

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

import com.android.settingslib.core.lifecycle.events.OnDestroy;

import com.android.settingslib.development.DeveloperOptionsPreferenceController;

import java.util.List;

public abstract class AbstractBluetoothA2dpPreferenceController extends

        DeveloperOptionsPreferenceController implements Preference.OnPreferenceChangeListener,

        PreferenceControllerMixin, BluetoothServiceConnectionListener, LifecycleObserver,

        OnDestroy {

    @VisibleForTesting

    static final int STREAMING_LABEL_ID =

            com.android.settingslib.R.string.bluetooth_select_a2dp_codec_streaming_label;

    protected final BluetoothA2dpConfigStore mBluetoothA2dpConfigStore;

    protected BluetoothA2dp mBluetoothA2dp;

    protected ListPreference mPreference;

    private final String[] mListValues;

    private final String[] mListSummaries;

    @VisibleForTesting

    BluetoothAdapter mBluetoothAdapter;

    public AbstractBluetoothA2dpPreferenceController(Context context, Lifecycle lifecycle,

            BluetoothA2dpConfigStore store) {

        super(context);

        mBluetoothA2dpConfigStore = store;

        mBluetoothAdapter = context.getSystemService(BluetoothManager.class).getAdapter();

        mListValues = getListValues();

        mListSummaries = getListSummaries();

        if (lifecycle != null) {

            lifecycle.addObserver(this);

        }

    }

    @Override

    public void displayPreference(PreferenceScreen screen) {

        super.displayPreference(screen);

        mPreference = screen.findPreference(getPreferenceKey());

        // Set a default value because BluetoothCodecConfig is null initially.

        mPreference.setValue(mListValues[getDefaultIndex()]);

        mPreference.setSummary(mListSummaries[getDefaultIndex()]);

    }

    @Override

    public boolean onPreferenceChange(Preference preference, Object newValue) {

        if (mBluetoothA2dp == null) {

            return false;

        }

        writeConfigurationValues(newValue);

        final BluetoothCodecConfig codecConfig = mBluetoothA2dpConfigStore.createCodecConfig();

        synchronized (mBluetoothA2dpConfigStore) {

            BluetoothDevice activeDevice = getA2dpActiveDevice();

            if (activeDevice == null) {

                return false;

            }

            setCodecConfigPreference(activeDevice, codecConfig);

        }

        // Because the setting is not persisted into permanent storage, we cannot call update state

        // here to update the preference.

        // Instead, we just assume it was set and update the preference here.

        final int index = mPreference.findIndexOfValue(newValue.toString());

        // We only want to append "Streaming" if not using default

        if (index == getDefaultIndex()) {

            mPreference.setSummary(mListSummaries[index]);

        } else {

            mPreference.setSummary(

                    mContext.getResources().getString(STREAMING_LABEL_ID, mListSummaries[index]));

        }

        return true;

    }

    @Override

    public void updateState(Preference preference) {

        BluetoothDevice activeDevice = getA2dpActiveDevice();

        if (activeDevice == null || getCodecConfig(activeDevice) == null || mPreference == null) {

            return;

        }

        BluetoothCodecConfig codecConfig;

        synchronized (mBluetoothA2dpConfigStore) {

            codecConfig = getCodecConfig(activeDevice);

        }

        final int index = getCurrentA2dpSettingIndex(codecConfig);

        mPreference.setValue(mListValues[index]);

        // We only want to append "Streaming" if not using default

        if (index == getDefaultIndex()) {

            mPreference.setSummary(mListSummaries[index]);

        } else {

            mPreference.setSummary(

                    mContext.getResources().getString(STREAMING_LABEL_ID, mListSummaries[index]));

        }

        writeConfigurationValues(mListValues[index]);

    }

    @Override

    public void onBluetoothServiceConnected(BluetoothA2dp bluetoothA2dp) {

        mBluetoothA2dp = bluetoothA2dp;

        updateState(mPreference);

    }

    @Override

    public void onBluetoothCodecUpdated() {

        // intentional no-op

        // We do not want to call update state here because the setting is not persisted in

        // permanent storage.

    }

    @Override

    public void onBluetoothServiceDisconnected() {

        mBluetoothA2dp = null;

    }

    @Override

    public void onDestroy() {

        mBluetoothA2dp = null;

    }

    /**

     * @return an array of string values that correspond to the current {@link ListPreference}.

     */

    protected abstract String[] getListValues();

    /**

     * @return an array of string summaries that correspond to the current {@link ListPreference}.

     */

    protected abstract String[] getListSummaries();

    /**

     * Updates the new value to the {@link BluetoothA2dpConfigStore} and the {@link BluetoothA2dp}.

     *

     * @param newValue the new setting value

     */

    protected abstract void writeConfigurationValues(Object newValue);

    /**

     * @return the current selected index for the {@link ListPreference}.

     */

    protected abstract int getCurrentA2dpSettingIndex(BluetoothCodecConfig config);

    /**

     * @return default setting index for the {@link ListPreference}.

     */

    protected abstract int getDefaultIndex();

    @VisibleForTesting

    void setCodecConfigPreference(BluetoothDevice device,

            BluetoothCodecConfig config) {

        BluetoothDevice bluetoothDevice =

                (device != null) ? device : getA2dpActiveDevice();

        if (bluetoothDevice == null) {

            return;

        }

        mBluetoothA2dp.setCodecConfigPreference(bluetoothDevice, config);

    }

    @VisibleForTesting

    BluetoothCodecConfig getCodecConfig(BluetoothDevice device) {

        if (mBluetoothA2dp != null) {

            BluetoothDevice bluetoothDevice =

                    (device != null) ? device : getA2dpActiveDevice();

            if (bluetoothDevice == null) {

                return null;

            }

            BluetoothCodecStatus codecStatus = mBluetoothA2dp.getCodecStatus(bluetoothDevice);

            if (codecStatus != null) {

                return codecStatus.getCodecConfig();

            }

        }

        return null;

    }

    private BluetoothDevice getA2dpActiveDevice() {

        if (mBluetoothAdapter == null) {

            return null;

        }

        List<BluetoothDevice> activeDevices =

                mBluetoothAdapter.getActiveDevices(BluetoothProfile.A2DP);

        return (activeDevices.size() > 0) ? activeDevices.get(0) : null;

    }

}

/*

 * Copyright (C) 2017 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

package com.android.settings.development;

import static com.android.settings.development.AbstractBluetoothA2dpPreferenceController

        .STREAMING_LABEL_ID;

import static org.mockito.ArgumentMatchers.any;

import static org.mockito.Mockito.doNothing;

import static org.mockito.Mockito.doReturn;

import static org.mockito.Mockito.never;

import static org.mockito.Mockito.spy;

import static org.mockito.Mockito.verify;

import static org.mockito.Mockito.when;

import android.bluetooth.BluetoothA2dp;

import android.bluetooth.BluetoothCodecConfig;

import android.content.Context;

import androidx.lifecycle.LifecycleOwner;

import androidx.preference.ListPreference;

import androidx.preference.PreferenceScreen;

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

import org.junit.Before;

import org.junit.Ignore;

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 AbstractBluetoothA2dpPreferenceControllerTest {

    @Mock

    private BluetoothA2dp mBluetoothA2dp;

    @Mock

    private BluetoothCodecConfig mBluetoothCodecConfig;

    @Mock

    private ListPreference mPreference;

    @Mock

    private PreferenceScreen mScreen;

    @Mock

    private BluetoothA2dpConfigStore mBluetoothA2dpConfigStore;

    private LifecycleOwner mLifecycleOwner;

    private Lifecycle mLifecycle;

    private Context mContext;

    private AbstractBluetoothA2dpPreferenceController mController;

    @Before

    public void setup() {

        MockitoAnnotations.initMocks(this);

        mContext = RuntimeEnvironment.application;

        mLifecycleOwner = () -> mLifecycle;

        mLifecycle = new Lifecycle(mLifecycleOwner);

        mController = spy(new AbstractBluetoothA2dpPreferenceControllerImpl(mContext, mLifecycle,

                mBluetoothA2dpConfigStore));

        mController.mBluetoothAdapter = null;

        doReturn(mBluetoothCodecConfig).when(mController).getCodecConfig(null);

        doNothing().when(mController).setCodecConfigPreference(any(), any());

        when(mBluetoothA2dpConfigStore.createCodecConfig()).thenReturn(mBluetoothCodecConfig);

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

        mController.displayPreference(mScreen);

    }

    @Test

    @Ignore

    public void onPreferenceChange_bluetoothConnected_shouldUpdateCodec() {

        mController.onBluetoothServiceConnected(mBluetoothA2dp);

        mController.onPreferenceChange(mPreference, "" /* new value */);

        verify(mController).setCodecConfigPreference(any(), any());

    }

    @Test

    public void onPreferenceChange_bluetoothNotConnected_shouldNotUpdateCodec() {

        mController.onBluetoothServiceDisconnected();

        mController.onPreferenceChange(mPreference, "" /* new value */);

        verify(mController, never()).setCodecConfigPreference(any(), any());

    }

    @Test

    @Ignore

    public void updateState_option2Set_shouldUpdateToOption2() {

        when(mBluetoothCodecConfig.getSampleRate()).thenReturn(

                BluetoothCodecConfig.SAMPLE_RATE_48000);

        doReturn(2).when(mController).getCurrentA2dpSettingIndex(any());

        mController.updateState(mPreference);

        verify(mPreference).setValue(mController.getListValues()[2]);

        verify(mPreference).setSummary(mContext.getString(STREAMING_LABEL_ID,

            mController.getListSummaries()[2]));

    }

    @Test

    public void onBluetoothServiceConnected_shouldUpdateState() {

        mController.onBluetoothServiceConnected(mBluetoothA2dp);

        verify(mController).updateState(mPreference);

    }

    private static class AbstractBluetoothA2dpPreferenceControllerImpl

        extends AbstractBluetoothA2dpPreferenceController {

        private AbstractBluetoothA2dpPreferenceControllerImpl(Context context,

                Lifecycle lifecycle, BluetoothA2dpConfigStore store) {

            super(context, lifecycle, store);

        }

        @Override

        public String getPreferenceKey() {

            return null;

        }

        @Override

        protected String[] getListValues() {

            return new String[]{"1", "2", "3"};

        }

        @Override

        protected String[] getListSummaries() {

            return new String[]{"foo", "bar", "foobar"};

        }

        @Override

        protected void writeConfigurationValues(Object newValue) {

        }

        @Override

        protected int getCurrentA2dpSettingIndex(BluetoothCodecConfig config) {

            return 0;

        }

        @Override

        protected int getDefaultIndex() {

            return 0;

        }

    }

}