0724f2a811
1. Click on the icon on the header will mute/unmute the remote devices in the same set if the remote devices are both mutable. 2. Show different icon when the value of the volume slide bars changed. Flag: com.android.settingslib.flags.hearing_devices_ambient_volume_control Bug: 357878944 Test: atest AmbientVolumePreferenceTest Test: atest BluetoothDetailsAmbientVolumePreferenceControllerTest Change-Id: I829c5e08f1456c8ef9936d0314045dc8da37cd95
435 lines
18 KiB
Java
435 lines
18 KiB
Java
/*
|
|
* Copyright (C) 2024 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.bluetooth;
|
|
|
|
import static android.bluetooth.AudioInputControl.MUTE_DISABLED;
|
|
import static android.bluetooth.AudioInputControl.MUTE_NOT_MUTED;
|
|
import static android.bluetooth.AudioInputControl.MUTE_MUTED;
|
|
import static android.bluetooth.BluetoothDevice.BOND_BONDED;
|
|
|
|
import static com.android.settings.bluetooth.BluetoothDetailsAmbientVolumePreferenceController.KEY_AMBIENT_VOLUME;
|
|
import static com.android.settings.bluetooth.BluetoothDetailsAmbientVolumePreferenceController.KEY_AMBIENT_VOLUME_SLIDER;
|
|
import static com.android.settings.bluetooth.BluetoothDetailsHearingDeviceController.KEY_HEARING_DEVICE_GROUP;
|
|
import static com.android.settingslib.bluetooth.HearingAidInfo.DeviceSide.SIDE_LEFT;
|
|
import static com.android.settingslib.bluetooth.HearingAidInfo.DeviceSide.SIDE_RIGHT;
|
|
|
|
import static com.google.common.truth.Truth.assertThat;
|
|
|
|
import static org.mockito.ArgumentMatchers.any;
|
|
import static org.mockito.ArgumentMatchers.anyBoolean;
|
|
import static org.mockito.ArgumentMatchers.anyInt;
|
|
import static org.mockito.ArgumentMatchers.anyLong;
|
|
import static org.mockito.ArgumentMatchers.eq;
|
|
import static org.mockito.Mockito.atLeastOnce;
|
|
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 static org.robolectric.Shadows.shadowOf;
|
|
|
|
import android.bluetooth.BluetoothDevice;
|
|
import android.bluetooth.BluetoothProfile;
|
|
import android.content.ContentResolver;
|
|
import android.os.Handler;
|
|
import android.os.Looper;
|
|
import android.provider.Settings;
|
|
|
|
import androidx.preference.PreferenceCategory;
|
|
|
|
import com.android.settings.testutils.shadow.ShadowThreadUtils;
|
|
import com.android.settings.widget.SeekBarPreference;
|
|
import com.android.settingslib.bluetooth.AmbientVolumeController;
|
|
import com.android.settingslib.bluetooth.BluetoothEventManager;
|
|
import com.android.settingslib.bluetooth.CachedBluetoothDevice;
|
|
import com.android.settingslib.bluetooth.HearingDeviceLocalDataManager;
|
|
import com.android.settingslib.bluetooth.LocalBluetoothManager;
|
|
import com.android.settingslib.bluetooth.LocalBluetoothProfileManager;
|
|
import com.android.settingslib.bluetooth.VolumeControlProfile;
|
|
|
|
import org.junit.Before;
|
|
import org.junit.Rule;
|
|
import org.junit.Test;
|
|
import org.junit.runner.RunWith;
|
|
import org.mockito.Mock;
|
|
import org.mockito.junit.MockitoJUnit;
|
|
import org.mockito.junit.MockitoRule;
|
|
import org.robolectric.RobolectricTestRunner;
|
|
import org.robolectric.annotation.Config;
|
|
import org.robolectric.annotation.Implementation;
|
|
import org.robolectric.annotation.Implements;
|
|
import org.robolectric.shadows.ShadowSettings;
|
|
|
|
import java.util.HashMap;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.Set;
|
|
import java.util.concurrent.Executor;
|
|
|
|
/** Tests for {@link BluetoothDetailsAmbientVolumePreferenceController}. */
|
|
@RunWith(RobolectricTestRunner.class)
|
|
@Config(shadows = {
|
|
BluetoothDetailsAmbientVolumePreferenceControllerTest.ShadowGlobal.class,
|
|
ShadowThreadUtils.class
|
|
})
|
|
public class BluetoothDetailsAmbientVolumePreferenceControllerTest extends
|
|
BluetoothDetailsControllerTestBase {
|
|
|
|
@Rule
|
|
public final MockitoRule mMockitoRule = MockitoJUnit.rule();
|
|
|
|
private static final String LEFT_CONTROL_KEY = KEY_AMBIENT_VOLUME_SLIDER + "_" + SIDE_LEFT;
|
|
private static final String RIGHT_CONTROL_KEY = KEY_AMBIENT_VOLUME_SLIDER + "_" + SIDE_RIGHT;
|
|
private static final String TEST_ADDRESS = "00:00:00:00:11";
|
|
private static final String TEST_MEMBER_ADDRESS = "00:00:00:00:22";
|
|
|
|
@Mock
|
|
private CachedBluetoothDevice mCachedMemberDevice;
|
|
@Mock
|
|
private BluetoothDevice mDevice;
|
|
@Mock
|
|
private BluetoothDevice mMemberDevice;
|
|
@Mock
|
|
private HearingDeviceLocalDataManager mLocalDataManager;
|
|
@Mock
|
|
private LocalBluetoothManager mBluetoothManager;
|
|
@Mock
|
|
private BluetoothEventManager mEventManager;
|
|
@Mock
|
|
private LocalBluetoothProfileManager mProfileManager;
|
|
@Mock
|
|
private VolumeControlProfile mVolumeControlProfile;
|
|
@Mock
|
|
private AmbientVolumeController mVolumeController;
|
|
@Mock
|
|
private Handler mTestHandler;
|
|
|
|
private BluetoothDetailsAmbientVolumePreferenceController mController;
|
|
|
|
@Before
|
|
public void setUp() {
|
|
super.setUp();
|
|
|
|
mContext = spy(mContext);
|
|
PreferenceCategory deviceControls = new PreferenceCategory(mContext);
|
|
deviceControls.setKey(KEY_HEARING_DEVICE_GROUP);
|
|
mScreen.addPreference(deviceControls);
|
|
mController = spy(
|
|
new BluetoothDetailsAmbientVolumePreferenceController(mContext, mBluetoothManager,
|
|
mFragment, mCachedDevice, mLifecycle, mLocalDataManager,
|
|
mVolumeController));
|
|
|
|
when(mBluetoothManager.getEventManager()).thenReturn(mEventManager);
|
|
when(mBluetoothManager.getProfileManager()).thenReturn(mProfileManager);
|
|
when(mProfileManager.getVolumeControlProfile()).thenReturn(mVolumeControlProfile);
|
|
when(mVolumeControlProfile.getConnectionStatus(mDevice)).thenReturn(
|
|
BluetoothProfile.STATE_CONNECTED);
|
|
when(mVolumeControlProfile.getConnectionStatus(mMemberDevice)).thenReturn(
|
|
BluetoothProfile.STATE_CONNECTED);
|
|
when(mCachedDevice.getProfiles()).thenReturn(List.of(mVolumeControlProfile));
|
|
when(mLocalDataManager.get(any(BluetoothDevice.class))).thenReturn(
|
|
new HearingDeviceLocalDataManager.Data.Builder().build());
|
|
|
|
when(mContext.getMainThreadHandler()).thenReturn(mTestHandler);
|
|
when(mTestHandler.postDelayed(any(Runnable.class), anyLong())).thenAnswer(
|
|
invocationOnMock -> {
|
|
invocationOnMock.getArgument(0, Runnable.class).run();
|
|
return null;
|
|
});
|
|
}
|
|
|
|
@Test
|
|
public void init_deviceWithoutMember_controlNotExpandable() {
|
|
prepareDevice(/* hasMember= */ false);
|
|
|
|
mController.init(mScreen);
|
|
|
|
AmbientVolumePreference preference = mScreen.findPreference(KEY_AMBIENT_VOLUME);
|
|
assertThat(preference).isNotNull();
|
|
assertThat(preference.isExpandable()).isFalse();
|
|
}
|
|
|
|
@Test
|
|
public void init_deviceWithMember_controlExpandable() {
|
|
prepareDevice(/* hasMember= */ true);
|
|
|
|
mController.init(mScreen);
|
|
|
|
AmbientVolumePreference preference = mScreen.findPreference(KEY_AMBIENT_VOLUME);
|
|
assertThat(preference).isNotNull();
|
|
assertThat(preference.isExpandable()).isTrue();
|
|
}
|
|
|
|
@Test
|
|
public void onDeviceLocalDataChange_noMemberAndExpanded_uiCorrectAndDataUpdated() {
|
|
prepareDevice(/* hasMember= */ false);
|
|
mController.init(mScreen);
|
|
HearingDeviceLocalDataManager.Data data = new HearingDeviceLocalDataManager.Data.Builder()
|
|
.ambient(0).groupAmbient(0).ambientControlExpanded(true).build();
|
|
when(mLocalDataManager.get(mDevice)).thenReturn(data);
|
|
|
|
mController.onDeviceLocalDataChange(TEST_ADDRESS, data);
|
|
shadowOf(Looper.getMainLooper()).idle();
|
|
|
|
AmbientVolumePreference preference = mScreen.findPreference(KEY_AMBIENT_VOLUME);
|
|
assertThat(preference).isNotNull();
|
|
assertThat(preference.isExpanded()).isFalse();
|
|
verifyDeviceDataUpdated(mDevice);
|
|
}
|
|
|
|
@Test
|
|
public void onDeviceLocalDataChange_noMemberAndCollapsed_uiCorrectAndDataUpdated() {
|
|
prepareDevice(/* hasMember= */ false);
|
|
mController.init(mScreen);
|
|
HearingDeviceLocalDataManager.Data data = new HearingDeviceLocalDataManager.Data.Builder()
|
|
.ambient(0).groupAmbient(0).ambientControlExpanded(false).build();
|
|
when(mLocalDataManager.get(mDevice)).thenReturn(data);
|
|
|
|
mController.onDeviceLocalDataChange(TEST_ADDRESS, data);
|
|
shadowOf(Looper.getMainLooper()).idle();
|
|
|
|
AmbientVolumePreference preference = mScreen.findPreference(KEY_AMBIENT_VOLUME);
|
|
assertThat(preference).isNotNull();
|
|
assertThat(preference.isExpanded()).isFalse();
|
|
verifyDeviceDataUpdated(mDevice);
|
|
}
|
|
|
|
@Test
|
|
public void onDeviceLocalDataChange_hasMemberAndExpanded_uiCorrectAndDataUpdated() {
|
|
prepareDevice(/* hasMember= */ true);
|
|
mController.init(mScreen);
|
|
HearingDeviceLocalDataManager.Data data = new HearingDeviceLocalDataManager.Data.Builder()
|
|
.ambient(0).groupAmbient(0).ambientControlExpanded(true).build();
|
|
when(mLocalDataManager.get(mDevice)).thenReturn(data);
|
|
|
|
mController.onDeviceLocalDataChange(TEST_ADDRESS, data);
|
|
shadowOf(Looper.getMainLooper()).idle();
|
|
|
|
AmbientVolumePreference preference = mScreen.findPreference(KEY_AMBIENT_VOLUME);
|
|
assertThat(preference).isNotNull();
|
|
assertThat(preference.isExpanded()).isTrue();
|
|
verifyDeviceDataUpdated(mDevice);
|
|
}
|
|
|
|
@Test
|
|
public void onDeviceLocalDataChange_hasMemberAndCollapsed_uiCorrectAndDataUpdated() {
|
|
prepareDevice(/* hasMember= */ true);
|
|
mController.init(mScreen);
|
|
HearingDeviceLocalDataManager.Data data = new HearingDeviceLocalDataManager.Data.Builder()
|
|
.ambient(0).groupAmbient(0).ambientControlExpanded(false).build();
|
|
when(mLocalDataManager.get(mDevice)).thenReturn(data);
|
|
|
|
mController.onDeviceLocalDataChange(TEST_ADDRESS, data);
|
|
shadowOf(Looper.getMainLooper()).idle();
|
|
|
|
AmbientVolumePreference preference = mScreen.findPreference(KEY_AMBIENT_VOLUME);
|
|
assertThat(preference).isNotNull();
|
|
assertThat(preference.isExpanded()).isFalse();
|
|
verifyDeviceDataUpdated(mDevice);
|
|
}
|
|
|
|
@Test
|
|
public void onStart_localDataManagerStartAndCallbackRegistered() {
|
|
prepareDevice(/* hasMember= */ true);
|
|
mController.init(mScreen);
|
|
|
|
mController.onStart();
|
|
|
|
verify(mLocalDataManager, atLeastOnce()).start();
|
|
verify(mVolumeController).registerCallback(any(Executor.class), eq(mDevice));
|
|
verify(mVolumeController).registerCallback(any(Executor.class), eq(mMemberDevice));
|
|
verify(mCachedDevice).registerCallback(any(Executor.class),
|
|
any(CachedBluetoothDevice.Callback.class));
|
|
verify(mCachedMemberDevice).registerCallback(any(Executor.class),
|
|
any(CachedBluetoothDevice.Callback.class));
|
|
}
|
|
|
|
@Test
|
|
public void onStop_localDataManagerStopAndCallbackUnregistered() {
|
|
prepareDevice(/* hasMember= */ true);
|
|
mController.init(mScreen);
|
|
|
|
mController.onStop();
|
|
|
|
verify(mLocalDataManager).stop();
|
|
verify(mVolumeController).unregisterCallback(mDevice);
|
|
verify(mVolumeController).unregisterCallback(mMemberDevice);
|
|
verify(mCachedDevice).unregisterCallback(any(CachedBluetoothDevice.Callback.class));
|
|
verify(mCachedMemberDevice).unregisterCallback(any(CachedBluetoothDevice.Callback.class));
|
|
}
|
|
|
|
@Test
|
|
public void onDeviceAttributesChanged_newDevice_newPreference() {
|
|
prepareDevice(/* hasMember= */ false);
|
|
mController.init(mScreen);
|
|
|
|
// check the right control is null before onDeviceAttributesChanged()
|
|
SeekBarPreference leftControl = mScreen.findPreference(LEFT_CONTROL_KEY);
|
|
SeekBarPreference rightControl = mScreen.findPreference(RIGHT_CONTROL_KEY);
|
|
assertThat(leftControl).isNotNull();
|
|
assertThat(rightControl).isNull();
|
|
|
|
prepareDevice(/* hasMember= */ true);
|
|
mController.onDeviceAttributesChanged();
|
|
shadowOf(Looper.getMainLooper()).idle();
|
|
|
|
// check the right control is created after onDeviceAttributesChanged()
|
|
SeekBarPreference updatedLeftControl = mScreen.findPreference(LEFT_CONTROL_KEY);
|
|
SeekBarPreference updatedRightControl = mScreen.findPreference(RIGHT_CONTROL_KEY);
|
|
assertThat(updatedLeftControl).isEqualTo(leftControl);
|
|
assertThat(updatedRightControl).isNotNull();
|
|
}
|
|
|
|
@Test
|
|
public void onAmbientChanged_refreshWhenNotInitiateFromUi() {
|
|
prepareDevice(/* hasMember= */ false);
|
|
mController.init(mScreen);
|
|
final int testAmbient = 10;
|
|
HearingDeviceLocalDataManager.Data data = new HearingDeviceLocalDataManager.Data.Builder()
|
|
.ambient(testAmbient)
|
|
.groupAmbient(testAmbient)
|
|
.ambientControlExpanded(false)
|
|
.build();
|
|
when(mLocalDataManager.get(mDevice)).thenReturn(data);
|
|
getPreference().setExpanded(true);
|
|
|
|
mController.onAmbientChanged(mDevice, testAmbient);
|
|
verify(mController, never()).refresh();
|
|
|
|
final int updatedTestAmbient = 20;
|
|
mController.onAmbientChanged(mDevice, updatedTestAmbient);
|
|
verify(mController).refresh();
|
|
}
|
|
|
|
@Test
|
|
public void onMuteChanged_refreshWhenNotInitiateFromUi() {
|
|
prepareDevice(/* hasMember= */ false);
|
|
mController.init(mScreen);
|
|
final int testMute = MUTE_NOT_MUTED;
|
|
AmbientVolumeController.RemoteAmbientState state =
|
|
new AmbientVolumeController.RemoteAmbientState(testMute, 0);
|
|
when(mVolumeController.refreshAmbientState(mDevice)).thenReturn(state);
|
|
getPreference().setMuted(false);
|
|
|
|
mController.onMuteChanged(mDevice, testMute);
|
|
verify(mController, never()).refresh();
|
|
|
|
final int updatedTestMute = MUTE_MUTED;
|
|
mController.onMuteChanged(mDevice, updatedTestMute);
|
|
verify(mController).refresh();
|
|
}
|
|
|
|
@Test
|
|
public void refresh_leftAndRightDifferentGainSetting_expandControl() {
|
|
prepareDevice(/* hasMember= */ true);
|
|
mController.init(mScreen);
|
|
prepareRemoteData(mDevice, 10, MUTE_NOT_MUTED);
|
|
prepareRemoteData(mMemberDevice, 20, MUTE_NOT_MUTED);
|
|
getPreference().setExpanded(false);
|
|
|
|
mController.refresh();
|
|
|
|
assertThat(getPreference().isExpanded()).isTrue();
|
|
}
|
|
|
|
@Test
|
|
public void refresh_oneSideNotMutable_controlNotMutableAndNotMuted() {
|
|
prepareDevice(/* hasMember= */ true);
|
|
mController.init(mScreen);
|
|
prepareRemoteData(mDevice, 10, MUTE_DISABLED);
|
|
prepareRemoteData(mMemberDevice, 20, MUTE_NOT_MUTED);
|
|
getPreference().setMutable(true);
|
|
getPreference().setMuted(true);
|
|
|
|
mController.refresh();
|
|
|
|
assertThat(getPreference().isMutable()).isFalse();
|
|
assertThat(getPreference().isMuted()).isFalse();
|
|
}
|
|
|
|
@Test
|
|
public void refresh_oneSideNotMuted_controlNotMutedAndSyncToRemote() {
|
|
prepareDevice(/* hasMember= */ true);
|
|
mController.init(mScreen);
|
|
prepareRemoteData(mDevice, 10, MUTE_MUTED);
|
|
prepareRemoteData(mMemberDevice, 20, MUTE_NOT_MUTED);
|
|
getPreference().setMutable(true);
|
|
getPreference().setMuted(true);
|
|
|
|
mController.refresh();
|
|
|
|
assertThat(getPreference().isMutable()).isTrue();
|
|
assertThat(getPreference().isMuted()).isFalse();
|
|
verify(mVolumeController).setMuted(mDevice, false);
|
|
}
|
|
|
|
private void prepareDevice(boolean hasMember) {
|
|
when(mCachedDevice.getDeviceSide()).thenReturn(SIDE_LEFT);
|
|
when(mCachedDevice.getDevice()).thenReturn(mDevice);
|
|
when(mCachedDevice.getBondState()).thenReturn(BOND_BONDED);
|
|
when(mDevice.getAddress()).thenReturn(TEST_ADDRESS);
|
|
when(mDevice.getAnonymizedAddress()).thenReturn(TEST_ADDRESS);
|
|
when(mDevice.isConnected()).thenReturn(true);
|
|
if (hasMember) {
|
|
when(mCachedDevice.getMemberDevice()).thenReturn(Set.of(mCachedMemberDevice));
|
|
when(mCachedMemberDevice.getDeviceSide()).thenReturn(SIDE_RIGHT);
|
|
when(mCachedMemberDevice.getDevice()).thenReturn(mMemberDevice);
|
|
when(mCachedMemberDevice.getBondState()).thenReturn(BOND_BONDED);
|
|
when(mMemberDevice.getAddress()).thenReturn(TEST_MEMBER_ADDRESS);
|
|
when(mMemberDevice.getAnonymizedAddress()).thenReturn(TEST_MEMBER_ADDRESS);
|
|
when(mMemberDevice.isConnected()).thenReturn(true);
|
|
}
|
|
}
|
|
|
|
private void prepareRemoteData(BluetoothDevice device, int gainSetting, int mute) {
|
|
when(mVolumeController.isAmbientControlAvailable(device)).thenReturn(true);
|
|
when(mVolumeController.refreshAmbientState(device)).thenReturn(
|
|
new AmbientVolumeController.RemoteAmbientState(gainSetting, mute));
|
|
}
|
|
|
|
private void verifyDeviceDataUpdated(BluetoothDevice device) {
|
|
verify(mLocalDataManager, atLeastOnce()).updateAmbient(eq(device), anyInt());
|
|
verify(mLocalDataManager, atLeastOnce()).updateGroupAmbient(eq(device), anyInt());
|
|
verify(mLocalDataManager, atLeastOnce()).updateAmbientControlExpanded(eq(device),
|
|
anyBoolean());
|
|
}
|
|
|
|
private AmbientVolumePreference getPreference() {
|
|
return mScreen.findPreference(KEY_AMBIENT_VOLUME);
|
|
}
|
|
|
|
@Implements(value = Settings.Global.class)
|
|
public static class ShadowGlobal extends ShadowSettings.ShadowGlobal {
|
|
private static final Map<ContentResolver, Map<String, String>> sDataMap = new HashMap<>();
|
|
|
|
@Implementation
|
|
protected static boolean putStringForUser(
|
|
ContentResolver cr, String name, String value, int userHandle) {
|
|
get(cr).put(name, value);
|
|
return true;
|
|
}
|
|
|
|
@Implementation
|
|
protected static String getStringForUser(ContentResolver cr, String name, int userHandle) {
|
|
return get(cr).get(name);
|
|
}
|
|
|
|
private static Map<String, String> get(ContentResolver cr) {
|
|
return sDataMap.computeIfAbsent(cr, k -> new HashMap<>());
|
|
}
|
|
}
|
|
}
|