diff --git a/res/values/config.xml b/res/values/config.xml index a41e41b96f7..b2323c27548 100755 --- a/res/values/config.xml +++ b/res/values/config.xml @@ -530,4 +530,24 @@ true + + + + @string/color_mode_option_natural + @string/color_mode_option_boosted + @string/color_mode_option_saturated + @string/color_mode_option_automatic + + + + + 0 + 1 + 2 + 3 + diff --git a/src/com/android/settings/display/ColorModePreferenceController.java b/src/com/android/settings/display/ColorModePreferenceController.java index 7a43e5c3d70..6cd4867b588 100644 --- a/src/com/android/settings/display/ColorModePreferenceController.java +++ b/src/com/android/settings/display/ColorModePreferenceController.java @@ -18,13 +18,10 @@ import android.hardware.display.ColorDisplayManager; import androidx.annotation.VisibleForTesting; -import com.android.settings.R; import com.android.settings.core.BasePreferenceController; public class ColorModePreferenceController extends BasePreferenceController { - private ColorDisplayManager mColorDisplayManager; - public ColorModePreferenceController(Context context, String key) { super(context, key); } @@ -39,24 +36,11 @@ public class ColorModePreferenceController extends BasePreferenceController { @Override public CharSequence getSummary() { - final int colorMode = getColorDisplayManager().getColorMode(); - if (colorMode == ColorDisplayManager.COLOR_MODE_AUTOMATIC) { - return mContext.getText(R.string.color_mode_option_automatic); - } - if (colorMode == ColorDisplayManager.COLOR_MODE_SATURATED) { - return mContext.getText(R.string.color_mode_option_saturated); - } - if (colorMode == ColorDisplayManager.COLOR_MODE_BOOSTED) { - return mContext.getText(R.string.color_mode_option_boosted); - } - return mContext.getText(R.string.color_mode_option_natural); + return ColorModeUtils.getColorModeMapping(mContext.getResources()).get(getColorMode()); } @VisibleForTesting - ColorDisplayManager getColorDisplayManager() { - if (mColorDisplayManager == null) { - mColorDisplayManager = mContext.getSystemService(ColorDisplayManager.class); - } - return mColorDisplayManager; + public int getColorMode() { + return mContext.getSystemService(ColorDisplayManager.class).getColorMode(); } } diff --git a/src/com/android/settings/display/ColorModePreferenceFragment.java b/src/com/android/settings/display/ColorModePreferenceFragment.java index c48c1d414f2..b8fa0b9a5fd 100644 --- a/src/com/android/settings/display/ColorModePreferenceFragment.java +++ b/src/com/android/settings/display/ColorModePreferenceFragment.java @@ -13,9 +13,17 @@ */ package com.android.settings.display; +import static android.hardware.display.ColorDisplayManager.COLOR_MODE_AUTOMATIC; +import static android.hardware.display.ColorDisplayManager.COLOR_MODE_BOOSTED; +import static android.hardware.display.ColorDisplayManager.COLOR_MODE_NATURAL; +import static android.hardware.display.ColorDisplayManager.COLOR_MODE_SATURATED; +import static android.hardware.display.ColorDisplayManager.VENDOR_COLOR_MODE_RANGE_MAX; +import static android.hardware.display.ColorDisplayManager.VENDOR_COLOR_MODE_RANGE_MIN; + import android.app.settings.SettingsEnums; import android.content.ContentResolver; import android.content.Context; +import android.content.res.Resources; import android.database.ContentObserver; import android.graphics.drawable.Drawable; import android.hardware.display.ColorDisplayManager; @@ -36,28 +44,26 @@ import com.android.settingslib.widget.LayoutPreference; import java.util.ArrayList; import java.util.List; +import java.util.Map; @SuppressWarnings("WeakerAccess") @SearchIndexable public class ColorModePreferenceFragment extends RadioButtonPickerFragment { - @VisibleForTesting - static final String KEY_COLOR_MODE_NATURAL = "color_mode_natural"; - @VisibleForTesting - static final String KEY_COLOR_MODE_BOOSTED = "color_mode_boosted"; - @VisibleForTesting - static final String KEY_COLOR_MODE_SATURATED = "color_mode_saturated"; - @VisibleForTesting - static final String KEY_COLOR_MODE_AUTOMATIC = "color_mode_automatic"; + private static final String KEY_COLOR_MODE_PREFIX = "color_mode_"; + + private static final int COLOR_MODE_FALLBACK = COLOR_MODE_NATURAL; private ContentObserver mContentObserver; private ColorDisplayManager mColorDisplayManager; + private Resources mResources; @Override public void onAttach(Context context) { super.onAttach(context); mColorDisplayManager = context.getSystemService(ColorDisplayManager.class); + mResources = context.getResources(); final ContentResolver cr = context.getContentResolver(); mContentObserver = new ContentObserver(new Handler(Looper.getMainLooper())) { @@ -81,11 +87,11 @@ public class ColorModePreferenceFragment extends RadioButtonPickerFragment { @Override public void onDetach() { - super.onDetach(); if (mContentObserver != null) { getContext().getContentResolver().unregisterContentObserver(mContentObserver); mContentObserver = null; } + super.onDetach(); } @Override @@ -108,72 +114,72 @@ public class ColorModePreferenceFragment extends RadioButtonPickerFragment { @Override protected List getCandidates() { - final Context c = getContext(); - final int[] availableColorModes = c.getResources().getIntArray( - com.android.internal.R.array.config_availableColorModes); - - List candidates = new ArrayList<>(); - if (availableColorModes != null) { - for (int colorMode : availableColorModes) { - if (colorMode == ColorDisplayManager.COLOR_MODE_NATURAL) { - candidates.add(new ColorModeCandidateInfo( - c.getText(R.string.color_mode_option_natural), - KEY_COLOR_MODE_NATURAL, true /* enabled */)); - } else if (colorMode == ColorDisplayManager.COLOR_MODE_BOOSTED) { - candidates.add(new ColorModeCandidateInfo( - c.getText(R.string.color_mode_option_boosted), - KEY_COLOR_MODE_BOOSTED, true /* enabled */)); - } else if (colorMode == ColorDisplayManager.COLOR_MODE_SATURATED) { - candidates.add(new ColorModeCandidateInfo( - c.getText(R.string.color_mode_option_saturated), - KEY_COLOR_MODE_SATURATED, true /* enabled */)); - } else if (colorMode == ColorDisplayManager.COLOR_MODE_AUTOMATIC) { - candidates.add(new ColorModeCandidateInfo( - c.getText(R.string.color_mode_option_automatic), - KEY_COLOR_MODE_AUTOMATIC, true /* enabled */)); - } - } + final Map colorModesToSummaries = + ColorModeUtils.getColorModeMapping(mResources); + final List candidates = new ArrayList<>(); + for (int colorMode : mResources.getIntArray( + com.android.internal.R.array.config_availableColorModes)) { + candidates.add(new ColorModeCandidateInfo( + colorModesToSummaries.get(colorMode), + getKeyForColorMode(colorMode), + true /* enabled */)); } return candidates; } @Override protected String getDefaultKey() { - final int colorMode = mColorDisplayManager.getColorMode(); - if (colorMode == ColorDisplayManager.COLOR_MODE_AUTOMATIC) { - return KEY_COLOR_MODE_AUTOMATIC; - } else if (colorMode == ColorDisplayManager.COLOR_MODE_SATURATED) { - return KEY_COLOR_MODE_SATURATED; - } else if (colorMode == ColorDisplayManager.COLOR_MODE_BOOSTED) { - return KEY_COLOR_MODE_BOOSTED; + final int colorMode = getColorMode(); + if (isValidColorMode(colorMode)) { + return getKeyForColorMode(colorMode); } - return KEY_COLOR_MODE_NATURAL; + return getKeyForColorMode(COLOR_MODE_FALLBACK); } @Override protected boolean setDefaultKey(String key) { - switch (key) { - case KEY_COLOR_MODE_NATURAL: - mColorDisplayManager.setColorMode(ColorDisplayManager.COLOR_MODE_NATURAL); - break; - case KEY_COLOR_MODE_BOOSTED: - mColorDisplayManager.setColorMode(ColorDisplayManager.COLOR_MODE_BOOSTED); - break; - case KEY_COLOR_MODE_SATURATED: - mColorDisplayManager.setColorMode(ColorDisplayManager.COLOR_MODE_SATURATED); - break; - case KEY_COLOR_MODE_AUTOMATIC: - mColorDisplayManager.setColorMode(ColorDisplayManager.COLOR_MODE_AUTOMATIC); - break; + int colorMode = Integer.parseInt(key.substring(key.lastIndexOf("_") + 1)); + if (isValidColorMode(colorMode)) { + setColorMode(colorMode); } return true; } + /** + * Wraps ColorDisplayManager#getColorMode for substitution in testing. + */ + @VisibleForTesting + public int getColorMode() { + return mColorDisplayManager.getColorMode(); + } + + /** + * Wraps ColorDisplayManager#setColorMode for substitution in testing. + */ + @VisibleForTesting + public void setColorMode(int colorMode) { + mColorDisplayManager.setColorMode(colorMode); + } + @Override public int getMetricsCategory() { return SettingsEnums.COLOR_MODE_SETTINGS; } + @VisibleForTesting + String getKeyForColorMode(int colorMode) { + return KEY_COLOR_MODE_PREFIX + colorMode; + } + + private boolean isValidColorMode(int colorMode) { + return colorMode == COLOR_MODE_NATURAL + || colorMode == COLOR_MODE_BOOSTED + || colorMode == COLOR_MODE_SATURATED + || colorMode == COLOR_MODE_AUTOMATIC + || (colorMode >= VENDOR_COLOR_MODE_RANGE_MIN + && colorMode <= VENDOR_COLOR_MODE_RANGE_MAX); + } + @VisibleForTesting static class ColorModeCandidateInfo extends CandidateInfo { private final CharSequence mLabel; diff --git a/src/com/android/settings/display/ColorModeUtils.java b/src/com/android/settings/display/ColorModeUtils.java new file mode 100644 index 00000000000..cdd978e4bbc --- /dev/null +++ b/src/com/android/settings/display/ColorModeUtils.java @@ -0,0 +1,62 @@ +/* + * Copyright (C) 2021 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.display; + +import static android.hardware.display.ColorDisplayManager.COLOR_MODE_AUTOMATIC; +import static android.hardware.display.ColorDisplayManager.COLOR_MODE_BOOSTED; +import static android.hardware.display.ColorDisplayManager.COLOR_MODE_NATURAL; +import static android.hardware.display.ColorDisplayManager.COLOR_MODE_SATURATED; +import static android.hardware.display.ColorDisplayManager.VENDOR_COLOR_MODE_RANGE_MAX; +import static android.hardware.display.ColorDisplayManager.VENDOR_COLOR_MODE_RANGE_MIN; + +import android.content.res.Resources; +import android.util.ArrayMap; + +import com.android.settings.R; + +import java.util.Map; + +final class ColorModeUtils { + + private ColorModeUtils() { + // Do not instantiate. + } + + static Map getColorModeMapping(Resources resources) { + final String[] colorModeOptionsStrings = resources.getStringArray( + R.array.config_color_mode_options_strings); + final int[] colorModeOptionsValues = resources.getIntArray( + R.array.config_color_mode_options_values); + if (colorModeOptionsStrings.length != colorModeOptionsValues.length) { + throw new RuntimeException("Color mode options of unequal length"); + } + + final Map colorModesToSummaries = new ArrayMap<>(); + for (int i = 0; i < colorModeOptionsValues.length; i++) { + final int colorMode = colorModeOptionsValues[i]; + if (colorMode == COLOR_MODE_NATURAL + || colorMode == COLOR_MODE_BOOSTED + || colorMode == COLOR_MODE_SATURATED + || colorMode == COLOR_MODE_AUTOMATIC + || (colorMode >= VENDOR_COLOR_MODE_RANGE_MIN + && colorMode <= VENDOR_COLOR_MODE_RANGE_MAX)) { + colorModesToSummaries.put(colorMode, colorModeOptionsStrings[i]); + } + } + return colorModesToSummaries; + } +} diff --git a/tests/robotests/src/com/android/settings/display/ColorModePreferenceFragmentTest.java b/tests/robotests/src/com/android/settings/display/ColorModePreferenceFragmentTest.java deleted file mode 100644 index 54e8e4de186..00000000000 --- a/tests/robotests/src/com/android/settings/display/ColorModePreferenceFragmentTest.java +++ /dev/null @@ -1,236 +0,0 @@ -/* - * 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.display; - -import static com.google.common.truth.Truth.assertThat; - -import static org.mockito.ArgumentMatchers.anyInt; -import static org.mockito.Mockito.doNothing; -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.spy; -import static org.mockito.Mockito.times; -import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.when; - -import android.hardware.display.ColorDisplayManager; -import android.os.Bundle; - -import androidx.preference.Preference; -import androidx.preference.PreferenceScreen; - -import com.android.internal.logging.nano.MetricsProto; -import com.android.settings.R; -import com.android.settings.testutils.shadow.SettingsShadowResources; -import com.android.settingslib.widget.CandidateInfo; -import com.android.settingslib.widget.LayoutPreference; - -import org.junit.After; -import org.junit.Before; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.mockito.ArgumentCaptor; -import org.mockito.Mock; -import org.mockito.MockitoAnnotations; -import org.robolectric.RobolectricTestRunner; -import org.robolectric.RuntimeEnvironment; -import org.robolectric.annotation.Config; -import org.robolectric.util.ReflectionHelpers; - -import java.util.List; - -@RunWith(RobolectricTestRunner.class) -@Config(shadows = SettingsShadowResources.class) -public class ColorModePreferenceFragmentTest { - - private ColorModePreferenceFragment mFragment; - - @Mock - private ColorDisplayManager mManager; - - @Before - public void setup() { - MockitoAnnotations.initMocks(this); - - mFragment = spy(new ColorModePreferenceFragment()); - ReflectionHelpers.setField(mFragment, "mColorDisplayManager", mManager); - } - - @After - public void tearDown() { - SettingsShadowResources.reset(); - } - - @Test - public void verifyMetricsConstant() { - assertThat(mFragment.getMetricsCategory()) - .isEqualTo(MetricsProto.MetricsEvent.COLOR_MODE_SETTINGS); - } - - @Test - public void getCandidates_all() { - when(mFragment.getContext()).thenReturn(RuntimeEnvironment.application); - SettingsShadowResources.overrideResource( - com.android.internal.R.array.config_availableColorModes, new int[]{ - ColorDisplayManager.COLOR_MODE_NATURAL, - ColorDisplayManager.COLOR_MODE_BOOSTED, - ColorDisplayManager.COLOR_MODE_SATURATED, - ColorDisplayManager.COLOR_MODE_AUTOMATIC - }); - List candidates = mFragment.getCandidates(); - - assertThat(candidates.size()).isEqualTo(4); - assertThat(candidates.get(0).getKey()) - .isEqualTo(ColorModePreferenceFragment.KEY_COLOR_MODE_NATURAL); - assertThat(candidates.get(1).getKey()) - .isEqualTo(ColorModePreferenceFragment.KEY_COLOR_MODE_BOOSTED); - assertThat(candidates.get(2).getKey()) - .isEqualTo(ColorModePreferenceFragment.KEY_COLOR_MODE_SATURATED); - assertThat(candidates.get(3).getKey()) - .isEqualTo(ColorModePreferenceFragment.KEY_COLOR_MODE_AUTOMATIC); - } - - @Test - public void getCandidates_none() { - when(mFragment.getContext()).thenReturn(RuntimeEnvironment.application); - SettingsShadowResources.overrideResource( - com.android.internal.R.array.config_availableColorModes, null); - List candidates = mFragment.getCandidates(); - - assertThat(candidates.size()).isEqualTo(0); - } - - @Test - public void getCandidates_withAutomatic() { - when(mFragment.getContext()).thenReturn(RuntimeEnvironment.application); - SettingsShadowResources.overrideResource( - com.android.internal.R.array.config_availableColorModes, new int[]{ - ColorDisplayManager.COLOR_MODE_NATURAL, - ColorDisplayManager.COLOR_MODE_AUTOMATIC - }); - List candidates = mFragment.getCandidates(); - - assertThat(candidates.size()).isEqualTo(2); - assertThat(candidates.get(0).getKey()) - .isEqualTo(ColorModePreferenceFragment.KEY_COLOR_MODE_NATURAL); - assertThat(candidates.get(1).getKey()) - .isEqualTo(ColorModePreferenceFragment.KEY_COLOR_MODE_AUTOMATIC); - } - - @Test - public void getCandidates_withoutAutomatic() { - when(mFragment.getContext()).thenReturn(RuntimeEnvironment.application); - SettingsShadowResources.overrideResource( - com.android.internal.R.array.config_availableColorModes, new int[]{ - ColorDisplayManager.COLOR_MODE_NATURAL, - ColorDisplayManager.COLOR_MODE_BOOSTED, - ColorDisplayManager.COLOR_MODE_SATURATED, - }); - List candidates = mFragment.getCandidates(); - - assertThat(candidates.size()).isEqualTo(3); - assertThat(candidates.get(0).getKey()) - .isEqualTo(ColorModePreferenceFragment.KEY_COLOR_MODE_NATURAL); - assertThat(candidates.get(1).getKey()) - .isEqualTo(ColorModePreferenceFragment.KEY_COLOR_MODE_BOOSTED); - assertThat(candidates.get(2).getKey()) - .isEqualTo(ColorModePreferenceFragment.KEY_COLOR_MODE_SATURATED); - } - - @Test - public void getKey_natural() { - when(mManager.getColorMode()) - .thenReturn(ColorDisplayManager.COLOR_MODE_NATURAL); - - assertThat(mFragment.getDefaultKey()) - .isEqualTo(ColorModePreferenceFragment.KEY_COLOR_MODE_NATURAL); - } - - @Test - public void getKey_boosted() { - when(mManager.getColorMode()) - .thenReturn(ColorDisplayManager.COLOR_MODE_BOOSTED); - - assertThat(mFragment.getDefaultKey()) - .isEqualTo(ColorModePreferenceFragment.KEY_COLOR_MODE_BOOSTED); - } - - @Test - public void getKey_saturated() { - when(mManager.getColorMode()) - .thenReturn(ColorDisplayManager.COLOR_MODE_SATURATED); - - assertThat(mFragment.getDefaultKey()) - .isEqualTo(ColorModePreferenceFragment.KEY_COLOR_MODE_SATURATED); - } - - @Test - public void getKey_automatic() { - when(mManager.getColorMode()) - .thenReturn(ColorDisplayManager.COLOR_MODE_AUTOMATIC); - - assertThat(mFragment.getDefaultKey()) - .isEqualTo(ColorModePreferenceFragment.KEY_COLOR_MODE_AUTOMATIC); - } - - @Test - public void setKey_natural() { - mFragment.setDefaultKey(ColorModePreferenceFragment.KEY_COLOR_MODE_NATURAL); - verify(mManager).setColorMode(ColorDisplayManager.COLOR_MODE_NATURAL); - } - - @Test - public void setKey_boosted() { - mFragment.setDefaultKey(ColorModePreferenceFragment.KEY_COLOR_MODE_BOOSTED); - verify(mManager).setColorMode(ColorDisplayManager.COLOR_MODE_BOOSTED); - } - - @Test - public void setKey_saturated() { - mFragment.setDefaultKey(ColorModePreferenceFragment.KEY_COLOR_MODE_SATURATED); - verify(mManager).setColorMode(ColorDisplayManager.COLOR_MODE_SATURATED); - } - - @Test - public void setKey_automatic() { - mFragment.setDefaultKey(ColorModePreferenceFragment.KEY_COLOR_MODE_AUTOMATIC); - verify(mManager).setColorMode(ColorDisplayManager.COLOR_MODE_AUTOMATIC); - } - - @Test - public void onCreatePreferences_useNewTitle_shouldAddColorModePreferences() { - when(mFragment.getContext()).thenReturn(RuntimeEnvironment.application); - doNothing().when(mFragment).addPreferencesFromResource(anyInt()); - doNothing().when(mFragment).updateCandidates(); - - mFragment.onCreatePreferences(Bundle.EMPTY, null /* rootKey */); - - verify(mFragment).addPreferencesFromResource(R.xml.color_mode_settings); - } - - @Test - public void addStaticPreferences_shouldAddPreviewImage() { - PreferenceScreen mockPreferenceScreen = mock(PreferenceScreen.class); - LayoutPreference mockPreview = mock(LayoutPreference.class); - - ArgumentCaptor preferenceCaptor = ArgumentCaptor.forClass(Preference.class); - - mFragment.configureAndInstallPreview(mockPreview, mockPreferenceScreen); - verify(mockPreview, times(1)).setSelectable(false); - verify(mockPreferenceScreen, times(1)).addPreference(preferenceCaptor.capture()); - - assertThat(preferenceCaptor.getValue()).isEqualTo(mockPreview); - } -} diff --git a/tests/robotests/src/com/android/settings/display/ColorModePreferenceControllerTest.java b/tests/unit/src/com/android/settings/display/ColorModePreferenceControllerTest.java similarity index 51% rename from tests/robotests/src/com/android/settings/display/ColorModePreferenceControllerTest.java rename to tests/unit/src/com/android/settings/display/ColorModePreferenceControllerTest.java index cf7e34f5404..e2f77fd5389 100644 --- a/tests/robotests/src/com/android/settings/display/ColorModePreferenceControllerTest.java +++ b/tests/unit/src/com/android/settings/display/ColorModePreferenceControllerTest.java @@ -1,5 +1,5 @@ /* - * Copyright (C) 2018 The Android Open Source Project + * Copyright (C) 2021 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. @@ -23,80 +23,75 @@ import static org.mockito.Mockito.spy; import static org.mockito.Mockito.when; import android.content.Context; +import android.content.res.Resources; import android.hardware.display.ColorDisplayManager; import androidx.preference.Preference; - -import com.android.settings.R; +import androidx.test.annotation.UiThreadTest; +import androidx.test.core.app.ApplicationProvider; +import androidx.test.ext.junit.runners.AndroidJUnit4; 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) +@RunWith(AndroidJUnit4.class) public class ColorModePreferenceControllerTest { - @Mock - private ColorDisplayManager mColorDisplayManager; - - private Context mContext; private Preference mPreference; private ColorModePreferenceController mController; @Before public void setup() { - MockitoAnnotations.initMocks(this); - mContext = RuntimeEnvironment.application; - mController = spy(new ColorModePreferenceController(mContext, "test")); - mPreference = new Preference(mContext); - doReturn(mColorDisplayManager).when(mController).getColorDisplayManager(); + final Context context = spy(ApplicationProvider.getApplicationContext()); + mController = spy(new ColorModePreferenceController(context, "test")); + mPreference = new Preference(context); + final Resources res = spy(context.getResources()); + when(res.getIntArray(com.android.internal.R.array.config_availableColorModes)).thenReturn( + new int[]{ + ColorDisplayManager.COLOR_MODE_NATURAL, + ColorDisplayManager.COLOR_MODE_BOOSTED, + ColorDisplayManager.COLOR_MODE_SATURATED, + ColorDisplayManager.COLOR_MODE_AUTOMATIC + }); + doReturn(res).when(context).getResources(); } @Test + @UiThreadTest public void updateState_colorModeAutomatic_shouldSetSummaryToAutomatic() { - when(mColorDisplayManager.getColorMode()) - .thenReturn(ColorDisplayManager.COLOR_MODE_AUTOMATIC); + doReturn(ColorDisplayManager.COLOR_MODE_AUTOMATIC).when(mController).getColorMode(); mController.updateState(mPreference); - assertThat(mPreference.getSummary()) - .isEqualTo(mContext.getText(R.string.color_mode_option_automatic)); + assertThat(mPreference.getSummary()).isEqualTo("Adaptive"); } @Test + @UiThreadTest public void updateState_colorModeSaturated_shouldSetSummaryToSaturated() { - when(mColorDisplayManager.getColorMode()) - .thenReturn(ColorDisplayManager.COLOR_MODE_SATURATED); + doReturn(ColorDisplayManager.COLOR_MODE_SATURATED).when(mController).getColorMode(); mController.updateState(mPreference); - assertThat(mPreference.getSummary()) - .isEqualTo(mContext.getText(R.string.color_mode_option_saturated)); + assertThat(mPreference.getSummary()).isEqualTo("Saturated"); } @Test public void updateState_colorModeBoosted_shouldSetSummaryToBoosted() { - when(mColorDisplayManager.getColorMode()) - .thenReturn(ColorDisplayManager.COLOR_MODE_BOOSTED); + doReturn(ColorDisplayManager.COLOR_MODE_BOOSTED).when(mController).getColorMode(); mController.updateState(mPreference); - assertThat(mPreference.getSummary()) - .isEqualTo(mContext.getText(R.string.color_mode_option_boosted)); + assertThat(mPreference.getSummary()).isEqualTo("Boosted"); } @Test public void updateState_colorModeNatural_shouldSetSummaryToNatural() { - when(mColorDisplayManager.getColorMode()) - .thenReturn(ColorDisplayManager.COLOR_MODE_NATURAL); + doReturn(ColorDisplayManager.COLOR_MODE_NATURAL).when(mController).getColorMode(); mController.updateState(mPreference); - assertThat(mPreference.getSummary()) - .isEqualTo(mContext.getText(R.string.color_mode_option_natural)); + assertThat(mPreference.getSummary()).isEqualTo("Natural"); } } diff --git a/tests/unit/src/com/android/settings/display/ColorModePreferenceFragmentTest.java b/tests/unit/src/com/android/settings/display/ColorModePreferenceFragmentTest.java new file mode 100644 index 00000000000..cfdedc78e0c --- /dev/null +++ b/tests/unit/src/com/android/settings/display/ColorModePreferenceFragmentTest.java @@ -0,0 +1,235 @@ +/* + * Copyright (C) 2021 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.display; + +import static com.google.common.truth.Truth.assertThat; + +import static org.mockito.ArgumentMatchers.anyInt; +import static org.mockito.Mockito.doNothing; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.spy; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import android.content.Context; +import android.content.res.Resources; +import android.hardware.display.ColorDisplayManager; + +import androidx.test.annotation.UiThreadTest; +import androidx.test.core.app.ApplicationProvider; +import androidx.test.ext.junit.runners.AndroidJUnit4; + +import com.android.internal.logging.nano.MetricsProto; +import com.android.settingslib.widget.CandidateInfo; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; + +import java.util.List; + +@RunWith(AndroidJUnit4.class) +public class ColorModePreferenceFragmentTest { + + private ColorModePreferenceFragment mFragment; + + private Context mContext; + + @Before + @UiThreadTest + public void setup() { + mContext = spy(ApplicationProvider.getApplicationContext()); + mFragment = spy(new ColorModePreferenceFragment()); + doNothing().when(mFragment).setColorMode(anyInt()); + } + + @Test + public void verifyMetricsConstant() { + assertThat(mFragment.getMetricsCategory()) + .isEqualTo(MetricsProto.MetricsEvent.COLOR_MODE_SETTINGS); + } + + @Test + @UiThreadTest + public void getCandidates_all() { + final Resources res = spy(mContext.getResources()); + when(res.getIntArray(com.android.internal.R.array.config_availableColorModes)).thenReturn( + new int[]{ + ColorDisplayManager.COLOR_MODE_NATURAL, + ColorDisplayManager.COLOR_MODE_BOOSTED, + ColorDisplayManager.COLOR_MODE_SATURATED, + ColorDisplayManager.COLOR_MODE_AUTOMATIC + }); + doReturn(res).when(mContext).getResources(); + mFragment.onAttach(mContext); + + final List candidates = mFragment.getCandidates(); + + assertThat(candidates.size()).isEqualTo(4); + assertThat(candidates.get(0).getKey()) + .isEqualTo(mFragment.getKeyForColorMode(ColorDisplayManager.COLOR_MODE_NATURAL)); + assertThat(candidates.get(1).getKey()) + .isEqualTo(mFragment.getKeyForColorMode(ColorDisplayManager.COLOR_MODE_BOOSTED)); + assertThat(candidates.get(2).getKey()) + .isEqualTo(mFragment.getKeyForColorMode(ColorDisplayManager.COLOR_MODE_SATURATED)); + assertThat(candidates.get(3).getKey()) + .isEqualTo(mFragment.getKeyForColorMode(ColorDisplayManager.COLOR_MODE_AUTOMATIC)); + } + + @Test + @UiThreadTest + public void getCandidates_none() { + final Resources res = spy(mContext.getResources()); + when(res.getIntArray(com.android.internal.R.array.config_availableColorModes)).thenReturn( + new int[]{ + }); + doReturn(res).when(mContext).getResources(); + mFragment.onAttach(mContext); + + List candidates = mFragment.getCandidates(); + + assertThat(candidates.size()).isEqualTo(0); + } + + @Test + @UiThreadTest + public void getCandidates_withAutomatic() { + final Resources res = spy(mContext.getResources()); + when(res.getIntArray(com.android.internal.R.array.config_availableColorModes)).thenReturn( + new int[]{ + ColorDisplayManager.COLOR_MODE_NATURAL, + ColorDisplayManager.COLOR_MODE_AUTOMATIC + }); + doReturn(res).when(mContext).getResources(); + mFragment.onAttach(mContext); + + List candidates = mFragment.getCandidates(); + + assertThat(candidates.size()).isEqualTo(2); + assertThat(candidates.get(0).getKey()) + .isEqualTo(mFragment.getKeyForColorMode(ColorDisplayManager.COLOR_MODE_NATURAL)); + assertThat(candidates.get(1).getKey()) + .isEqualTo(mFragment.getKeyForColorMode(ColorDisplayManager.COLOR_MODE_AUTOMATIC)); + } + + @Test + @UiThreadTest + public void getCandidates_withoutAutomatic() { + final Resources res = spy(mContext.getResources()); + when(res.getIntArray(com.android.internal.R.array.config_availableColorModes)).thenReturn( + new int[]{ + ColorDisplayManager.COLOR_MODE_NATURAL, + ColorDisplayManager.COLOR_MODE_BOOSTED, + ColorDisplayManager.COLOR_MODE_SATURATED + }); + doReturn(res).when(mContext).getResources(); + mFragment.onAttach(mContext); + + List candidates = mFragment.getCandidates(); + + assertThat(candidates.size()).isEqualTo(3); + assertThat(candidates.get(0).getKey()) + .isEqualTo(mFragment.getKeyForColorMode(ColorDisplayManager.COLOR_MODE_NATURAL)); + assertThat(candidates.get(1).getKey()) + .isEqualTo(mFragment.getKeyForColorMode(ColorDisplayManager.COLOR_MODE_BOOSTED)); + assertThat(candidates.get(2).getKey()) + .isEqualTo(mFragment.getKeyForColorMode(ColorDisplayManager.COLOR_MODE_SATURATED)); + } + + @Test + @UiThreadTest + public void getKey_natural() { + doReturn(ColorDisplayManager.COLOR_MODE_NATURAL).when(mFragment).getColorMode(); + mFragment.onAttach(mContext); + + assertThat(mFragment.getDefaultKey()) + .isEqualTo(mFragment.getKeyForColorMode(ColorDisplayManager.COLOR_MODE_NATURAL)); + } + + @Test + @UiThreadTest + public void getKey_boosted() { + doReturn(ColorDisplayManager.COLOR_MODE_BOOSTED).when(mFragment).getColorMode(); + mFragment.onAttach(mContext); + + assertThat(mFragment.getDefaultKey()) + .isEqualTo(mFragment.getKeyForColorMode(ColorDisplayManager.COLOR_MODE_BOOSTED)); + } + + @Test + @UiThreadTest + public void getKey_saturated() { + doReturn(ColorDisplayManager.COLOR_MODE_SATURATED).when(mFragment).getColorMode(); + mFragment.onAttach(mContext); + + assertThat(mFragment.getDefaultKey()) + .isEqualTo(mFragment.getKeyForColorMode(ColorDisplayManager.COLOR_MODE_SATURATED)); + } + + @Test + @UiThreadTest + public void getKey_automatic() { + doReturn(ColorDisplayManager.COLOR_MODE_AUTOMATIC).when(mFragment).getColorMode(); + mFragment.onAttach(mContext); + + assertThat(mFragment.getDefaultKey()) + .isEqualTo(mFragment.getKeyForColorMode(ColorDisplayManager.COLOR_MODE_AUTOMATIC)); + } + + @Test + @UiThreadTest + public void setKey_natural() { + mFragment.onAttach(mContext); + + mFragment.setDefaultKey( + mFragment.getKeyForColorMode(ColorDisplayManager.COLOR_MODE_NATURAL)); + + verify(mFragment).setColorMode(ColorDisplayManager.COLOR_MODE_NATURAL); + } + + @Test + @UiThreadTest + public void setKey_boosted() { + mFragment.onAttach(mContext); + + mFragment.setDefaultKey( + mFragment.getKeyForColorMode(ColorDisplayManager.COLOR_MODE_BOOSTED)); + + verify(mFragment).setColorMode(ColorDisplayManager.COLOR_MODE_BOOSTED); + } + + @Test + @UiThreadTest + public void setKey_saturated() { + mFragment.onAttach(mContext); + + mFragment.setDefaultKey( + mFragment.getKeyForColorMode(ColorDisplayManager.COLOR_MODE_SATURATED)); + + verify(mFragment).setColorMode(ColorDisplayManager.COLOR_MODE_SATURATED); + } + + @Test + @UiThreadTest + public void setKey_automatic() { + mFragment.onAttach(mContext); + + mFragment.setDefaultKey( + mFragment.getKeyForColorMode(ColorDisplayManager.COLOR_MODE_AUTOMATIC)); + + verify(mFragment).setColorMode(ColorDisplayManager.COLOR_MODE_AUTOMATIC); + } +}