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); + } }