From b222b9640721ef2e7392255464ac5a66d81a7e62 Mon Sep 17 00:00:00 2001 From: Michael Mikhail Date: Fri, 7 Jul 2023 18:37:45 +0000 Subject: [PATCH] Override the state description of volume seekbar. This overrides the state description of seekbar in order to adjust the progress percentage. The percentage of seekbar is not matching with the percentage said by talkback feature when the volume changes. This CL rounds the percentage to match what is said by talkback. Bug: 285458191 Test: Enabled talkback and checked percentages of sliders of all sounds and vibrations volumes. Video attached in bug link. Test: atest VolumeSeekBarPreferenceTest. Change-Id: Iedcf3eccb13b7f8ee1a4ca521f0783c55d7a1902 --- .../notification/SeekBarVolumizerFactory.java | 44 +++++++++ .../notification/VolumeSeekBarPreference.java | 41 +++++++- .../VolumeSeekBarPreferenceTest.java | 95 +++++++++++++++++-- 3 files changed, 171 insertions(+), 9 deletions(-) create mode 100644 src/com/android/settings/notification/SeekBarVolumizerFactory.java diff --git a/src/com/android/settings/notification/SeekBarVolumizerFactory.java b/src/com/android/settings/notification/SeekBarVolumizerFactory.java new file mode 100644 index 00000000000..6fac2c13e00 --- /dev/null +++ b/src/com/android/settings/notification/SeekBarVolumizerFactory.java @@ -0,0 +1,44 @@ +/* + * 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.notification; + +import android.content.Context; +import android.net.Uri; +import android.preference.SeekBarVolumizer; + +/** + * Testable wrapper around {@link SeekBarVolumizer} constructor. + */ +public class SeekBarVolumizerFactory { + private final Context mContext; + + public SeekBarVolumizerFactory(Context context) { + mContext = context; + } + + /** + * Creates a new SeekBarVolumizer. + * + * @param streamType of the audio manager. + * @param defaultUri of the volume. + * @param sbvc callback of the seekbar volumizer. + * @return a SeekBarVolumizer. + */ + public SeekBarVolumizer create(int streamType, Uri defaultUri, SeekBarVolumizer.Callback sbvc) { + return new SeekBarVolumizer(mContext, streamType, defaultUri, sbvc); + } +} diff --git a/src/com/android/settings/notification/VolumeSeekBarPreference.java b/src/com/android/settings/notification/VolumeSeekBarPreference.java index 0000eba2ba7..9f14b738a9d 100644 --- a/src/com/android/settings/notification/VolumeSeekBarPreference.java +++ b/src/com/android/settings/notification/VolumeSeekBarPreference.java @@ -37,6 +37,8 @@ import com.android.internal.jank.InteractionJankMonitor; import com.android.settings.R; import com.android.settings.widget.SeekBarPreference; +import java.text.NumberFormat; +import java.util.Locale; import java.util.Objects; /** A slider preference that directly controls an audio stream volume (no dialog) **/ @@ -47,8 +49,9 @@ public class VolumeSeekBarPreference extends SeekBarPreference { protected SeekBar mSeekBar; private int mStream; + private SeekBarVolumizer mVolumizer; @VisibleForTesting - SeekBarVolumizer mVolumizer; + SeekBarVolumizerFactory mSeekBarVolumizerFactory; private Callback mCallback; private Listener mListener; private ImageView mIconView; @@ -62,30 +65,36 @@ public class VolumeSeekBarPreference extends SeekBarPreference { private boolean mStopped; @VisibleForTesting AudioManager mAudioManager; + private Locale mLocale; + private NumberFormat mNumberFormat; public VolumeSeekBarPreference(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) { super(context, attrs, defStyleAttr, defStyleRes); setLayoutResource(R.layout.preference_volume_slider); mAudioManager = (AudioManager) context.getSystemService(Context.AUDIO_SERVICE); + mSeekBarVolumizerFactory = new SeekBarVolumizerFactory(context); } public VolumeSeekBarPreference(Context context, AttributeSet attrs, int defStyleAttr) { super(context, attrs, defStyleAttr); setLayoutResource(R.layout.preference_volume_slider); mAudioManager = (AudioManager) context.getSystemService(Context.AUDIO_SERVICE); + mSeekBarVolumizerFactory = new SeekBarVolumizerFactory(context); } public VolumeSeekBarPreference(Context context, AttributeSet attrs) { super(context, attrs); setLayoutResource(R.layout.preference_volume_slider); mAudioManager = (AudioManager) context.getSystemService(Context.AUDIO_SERVICE); + mSeekBarVolumizerFactory = new SeekBarVolumizerFactory(context); } public VolumeSeekBarPreference(Context context) { super(context); setLayoutResource(R.layout.preference_volume_slider); mAudioManager = (AudioManager) context.getSystemService(Context.AUDIO_SERVICE); + mSeekBarVolumizerFactory = new SeekBarVolumizerFactory(context); } public void setStream(int stream) { @@ -143,6 +152,7 @@ public class VolumeSeekBarPreference extends SeekBarPreference { if (mCallback != null) { mCallback.onStreamValueChanged(mStream, progress); } + overrideSeekBarStateDescription(formatStateDescription(progress)); } @Override public void onMuted(boolean muted, boolean zenMuted) { @@ -170,7 +180,7 @@ public class VolumeSeekBarPreference extends SeekBarPreference { }; final Uri sampleUri = mStream == AudioManager.STREAM_MUSIC ? getMediaVolumeUri() : null; if (mVolumizer == null) { - mVolumizer = new SeekBarVolumizer(getContext(), mStream, sampleUri, sbvc); + mVolumizer = mSeekBarVolumizerFactory.create(mStream, sampleUri, sbvc); } mVolumizer.start(); mVolumizer.setSeekBar(mSeekBar); @@ -216,6 +226,33 @@ public class VolumeSeekBarPreference extends SeekBarPreference { + "/" + R.raw.media_volume); } + @VisibleForTesting + CharSequence formatStateDescription(int progress) { + // This code follows the same approach in ProgressBar.java, but it rounds down the percent + // to match it with what the talkback feature says after any progress change. (b/285458191) + // Cache the locale-appropriate NumberFormat. Configuration locale is guaranteed + // non-null, so the first time this is called we will always get the appropriate + // NumberFormat, then never regenerate it unless the locale changes on the fly. + Locale curLocale = getContext().getResources().getConfiguration().getLocales().get(0); + if (mLocale == null || !mLocale.equals(curLocale)) { + mLocale = curLocale; + mNumberFormat = NumberFormat.getPercentInstance(mLocale); + } + return mNumberFormat.format(getPercent(progress)); + } + + @VisibleForTesting + double getPercent(float progress) { + final float maxProgress = getMax(); + final float minProgress = getMin(); + final float diffProgress = maxProgress - minProgress; + if (diffProgress <= 0.0f) { + return 0.0f; + } + final float percent = (progress - minProgress) / diffProgress; + return Math.floor(Math.max(0.0f, Math.min(1.0f, percent)) * 100) / 100; + } + public void setSuppressionText(String text) { if (Objects.equals(text, mSuppressionText)) return; mSuppressionText = text; diff --git a/tests/robotests/src/com/android/settings/notification/VolumeSeekBarPreferenceTest.java b/tests/robotests/src/com/android/settings/notification/VolumeSeekBarPreferenceTest.java index 59f0bcb91b9..47bf99db4f3 100644 --- a/tests/robotests/src/com/android/settings/notification/VolumeSeekBarPreferenceTest.java +++ b/tests/robotests/src/com/android/settings/notification/VolumeSeekBarPreferenceTest.java @@ -17,62 +17,81 @@ package com.android.settings.notification; import static org.mockito.ArgumentMatchers.anyInt; +import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.doCallRealMethod; import static org.mockito.Mockito.never; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; import android.content.Context; +import android.content.res.Configuration; +import android.content.res.Resources; import android.media.AudioManager; +import android.os.LocaleList; import android.preference.SeekBarVolumizer; import android.widget.SeekBar; import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; +import org.mockito.ArgumentCaptor; +import org.mockito.Captor; import org.mockito.Mock; import org.mockito.MockitoAnnotations; import org.robolectric.RobolectricTestRunner; +import java.util.Locale; + @RunWith(RobolectricTestRunner.class) public class VolumeSeekBarPreferenceTest { private static final CharSequence CONTENT_DESCRIPTION = "TEST"; + private static final int STREAM = 5; @Mock private AudioManager mAudioManager; @Mock private VolumeSeekBarPreference mPreference; @Mock private Context mContext; + + @Mock + private Resources mRes; + @Mock + private Configuration mConfig; @Mock private SeekBar mSeekBar; + @Captor + private ArgumentCaptor mSbvc; @Mock private SeekBarVolumizer mVolumizer; + @Mock + private SeekBarVolumizerFactory mSeekBarVolumizerFactory; private VolumeSeekBarPreference.Listener mListener; @Before public void setUp() { MockitoAnnotations.initMocks(this); when(mContext.getSystemService(Context.AUDIO_SERVICE)).thenReturn(mAudioManager); + when(mSeekBarVolumizerFactory.create(eq(STREAM), eq(null), mSbvc.capture())) + .thenReturn(mVolumizer); + doCallRealMethod().when(mPreference).setStream(anyInt()); doCallRealMethod().when(mPreference).updateContentDescription(CONTENT_DESCRIPTION); mPreference.mSeekBar = mSeekBar; mPreference.mAudioManager = mAudioManager; - mPreference.mVolumizer = mVolumizer; + mPreference.mSeekBarVolumizerFactory = mSeekBarVolumizerFactory; mListener = () -> mPreference.updateContentDescription(CONTENT_DESCRIPTION); } @Test public void setStream_shouldSetMinMaxAndProgress() { - final int stream = 5; final int max = 17; final int min = 1; final int progress = 4; - when(mAudioManager.getStreamMaxVolume(stream)).thenReturn(max); - when(mAudioManager.getStreamMinVolumeInt(stream)).thenReturn(min); - when(mAudioManager.getStreamVolume(stream)).thenReturn(progress); - doCallRealMethod().when(mPreference).setStream(anyInt()); + when(mAudioManager.getStreamMaxVolume(STREAM)).thenReturn(max); + when(mAudioManager.getStreamMinVolumeInt(STREAM)).thenReturn(min); + when(mAudioManager.getStreamVolume(STREAM)).thenReturn(progress); - mPreference.setStream(stream); + mPreference.setStream(STREAM); verify(mPreference).setMax(max); verify(mPreference).setMin(min); @@ -84,6 +103,7 @@ public class VolumeSeekBarPreferenceTest { doCallRealMethod().when(mPreference).setListener(mListener); doCallRealMethod().when(mPreference).init(); + mPreference.setStream(STREAM); mPreference.setListener(mListener); mPreference.init(); @@ -94,8 +114,69 @@ public class VolumeSeekBarPreferenceTest { public void init_listenerNotSet_noException() { doCallRealMethod().when(mPreference).init(); + mPreference.setStream(STREAM); mPreference.init(); verify(mPreference, never()).updateContentDescription(CONTENT_DESCRIPTION); } + + @Test + public void init_changeProgress_overrideStateDescriptionCalled() { + final int progress = 4; + when(mPreference.formatStateDescription(progress)).thenReturn(CONTENT_DESCRIPTION); + doCallRealMethod().when(mPreference).init(); + + mPreference.setStream(STREAM); + mPreference.init(); + + verify(mSeekBarVolumizerFactory).create(eq(STREAM), eq(null), mSbvc.capture()); + + mSbvc.getValue().onProgressChanged(mSeekBar, 4, true); + + verify(mPreference).overrideSeekBarStateDescription(CONTENT_DESCRIPTION); + } + + @Test + public void init_changeProgress_stateDescriptionValueUpdated() { + final int max = 17; + final int min = 1; + int progress = 4; + when(mAudioManager.getStreamMaxVolume(STREAM)).thenReturn(max); + when(mAudioManager.getStreamMinVolumeInt(STREAM)).thenReturn(min); + when(mAudioManager.getStreamVolume(STREAM)).thenReturn(progress); + when(mPreference.getMin()).thenReturn(min); + when(mPreference.getMax()).thenReturn(max); + when(mPreference.getContext()).thenReturn(mContext); + when(mContext.getResources()).thenReturn(mRes); + when(mRes.getConfiguration()).thenReturn(mConfig); + when(mConfig.getLocales()).thenReturn(new LocaleList(Locale.US)); + doCallRealMethod().when(mPreference).init(); + + mPreference.setStream(STREAM); + mPreference.init(); + + // On progress change, Round down the percent to match it with what the talkback says. + // (b/285458191) + // when progress is 4, the percent is 0.187. The state description should be set to 18%. + testFormatStateDescription(progress, "18%"); + + progress = 6; + + // when progress is 6, the percent is 0.3125. The state description should be set to 31%. + testFormatStateDescription(progress, "31%"); + + progress = 7; + + // when progress is 7, the percent is 0.375. The state description should be set to 37%. + testFormatStateDescription(progress, "37%"); + } + + private void testFormatStateDescription(int progress, String expected) { + doCallRealMethod().when(mPreference).formatStateDescription(progress); + doCallRealMethod().when(mPreference).getPercent(progress); + + mSbvc.getValue().onProgressChanged(mSeekBar, progress, true); + + verify(mPreference).overrideSeekBarStateDescription(expected); + } }