Support vendor modes in color mode preference

Bug: 161299146
Test: atest SettingsUnitTests:ColorModePreferenceControllerTest and
atest SettingsUnitTests:ColorModePreferenceFragmentTest

Change-Id: I76ed54bb444170d4b8935f8f12bed599a946aa14

res/values/config.xml

@@ -530,4 +530,24 @@
 
     <!-- Whether to show Smart Storage toggle -->
     <bool name="config_show_smart_storage_toggle">true</bool>
+
+    <!-- Display settings screen, Color mode options. Must be the same length and order as
+         config_color_mode_options_values below. Only the values that also appear in
+         frameworks/base/core/res/res/values/config.xml's config_availableColorModes are shown. -->
+    <string-array name="config_color_mode_options_strings" translatable="false">
+        <item>@string/color_mode_option_natural</item>
+        <item>@string/color_mode_option_boosted</item>
+        <item>@string/color_mode_option_saturated</item>
+        <item>@string/color_mode_option_automatic</item>
+    </string-array>
+
+    <!-- Display settings screen, Color mode options. Must be the same length and order as
+         config_color_mode_options_strings above. Only the values that also appear in
+         frameworks/base/core/res/res/values/config.xml's config_availableColorModes are shown. -->
+    <integer-array name="config_color_mode_options_values" translatable="false">
+        <item>0</item>
+        <item>1</item>
+        <item>2</item>
+        <item>3</item>
+    </integer-array>
 </resources>

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();
+        return ColorModeUtils.getColorModeMapping(mContext.getResources()).get(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);
     }
 
     @VisibleForTesting
-    ColorDisplayManager getColorDisplayManager() {
+    public int getColorMode() {
-        if (mColorDisplayManager == null) {
+        return mContext.getSystemService(ColorDisplayManager.class).getColorMode();
-            mColorDisplayManager = mContext.getSystemService(ColorDisplayManager.class);
-        }
-        return mColorDisplayManager;
     }
 }

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
+    private static final String KEY_COLOR_MODE_PREFIX = "color_mode_";
-    static final String KEY_COLOR_MODE_NATURAL = "color_mode_natural";
+
-    @VisibleForTesting
+    private static final int COLOR_MODE_FALLBACK = COLOR_MODE_NATURAL;
-    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 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<? extends CandidateInfo> getCandidates() {
-        final Context c = getContext();
+        final Map<Integer, String> colorModesToSummaries =
-        final int[] availableColorModes = c.getResources().getIntArray(
+                ColorModeUtils.getColorModeMapping(mResources);
-                com.android.internal.R.array.config_availableColorModes);
+        final List<ColorModeCandidateInfo> candidates = new ArrayList<>();
-
+        for (int colorMode : mResources.getIntArray(
-        List<ColorModeCandidateInfo> candidates = new ArrayList<>();
+                com.android.internal.R.array.config_availableColorModes)) {
-        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),
+                    colorModesToSummaries.get(colorMode),
-                                KEY_COLOR_MODE_NATURAL, true /* enabled */));
+                    getKeyForColorMode(colorMode),
-                } else if (colorMode == ColorDisplayManager.COLOR_MODE_BOOSTED) {
+                    true /* enabled */));
-                    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 */));
-                }
-            }
         }
         return candidates;
     }
 
     @Override
     protected String getDefaultKey() {
-        final int colorMode = mColorDisplayManager.getColorMode();
+        final int colorMode = getColorMode();
-        if (colorMode == ColorDisplayManager.COLOR_MODE_AUTOMATIC) {
+        if (isValidColorMode(colorMode)) {
-            return KEY_COLOR_MODE_AUTOMATIC;
+            return getKeyForColorMode(colorMode);
-        } else if (colorMode == ColorDisplayManager.COLOR_MODE_SATURATED) {
-            return KEY_COLOR_MODE_SATURATED;
-        } else if (colorMode == ColorDisplayManager.COLOR_MODE_BOOSTED) {
-            return KEY_COLOR_MODE_BOOSTED;
         }
-        return KEY_COLOR_MODE_NATURAL;
+        return getKeyForColorMode(COLOR_MODE_FALLBACK);
     }
 
     @Override
     protected boolean setDefaultKey(String key) {
-        switch (key) {
+        int colorMode = Integer.parseInt(key.substring(key.lastIndexOf("_") + 1));
-            case KEY_COLOR_MODE_NATURAL:
+        if (isValidColorMode(colorMode)) {
-                mColorDisplayManager.setColorMode(ColorDisplayManager.COLOR_MODE_NATURAL);
+            setColorMode(colorMode);
-                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;
         }
         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;

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<Integer, String> 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<Integer, String> 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;
+    }
+}

tests/robotests/src/com/android/settings/display/ColorModePreferenceFragmentTest.java

@@ -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<? extends CandidateInfo> 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<? extends CandidateInfo> 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<? extends CandidateInfo> 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<? extends CandidateInfo> 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<Preference> 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);
-    }
-}

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 androidx.test.annotation.UiThreadTest;
-import com.android.settings.R;
+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);
+        final Context context = spy(ApplicationProvider.getApplicationContext());
-        mContext = RuntimeEnvironment.application;
+        mController = spy(new ColorModePreferenceController(context, "test"));
-        mController = spy(new ColorModePreferenceController(mContext, "test"));
+        mPreference = new Preference(context);
-        mPreference = new Preference(mContext);
+        final Resources res = spy(context.getResources());
-        doReturn(mColorDisplayManager).when(mController).getColorDisplayManager();
+        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())
+        doReturn(ColorDisplayManager.COLOR_MODE_AUTOMATIC).when(mController).getColorMode();
-                .thenReturn(ColorDisplayManager.COLOR_MODE_AUTOMATIC);
 
         mController.updateState(mPreference);
 
-        assertThat(mPreference.getSummary())
+        assertThat(mPreference.getSummary()).isEqualTo("Adaptive");
-                .isEqualTo(mContext.getText(R.string.color_mode_option_automatic));
     }
 
     @Test
+    @UiThreadTest
     public void updateState_colorModeSaturated_shouldSetSummaryToSaturated() {
-        when(mColorDisplayManager.getColorMode())
+        doReturn(ColorDisplayManager.COLOR_MODE_SATURATED).when(mController).getColorMode();
-                .thenReturn(ColorDisplayManager.COLOR_MODE_SATURATED);
 
         mController.updateState(mPreference);
 
-        assertThat(mPreference.getSummary())
+        assertThat(mPreference.getSummary()).isEqualTo("Saturated");
-                .isEqualTo(mContext.getText(R.string.color_mode_option_saturated));
     }
 
     @Test
     public void updateState_colorModeBoosted_shouldSetSummaryToBoosted() {
-        when(mColorDisplayManager.getColorMode())
+        doReturn(ColorDisplayManager.COLOR_MODE_BOOSTED).when(mController).getColorMode();
-                .thenReturn(ColorDisplayManager.COLOR_MODE_BOOSTED);
 
         mController.updateState(mPreference);
 
-        assertThat(mPreference.getSummary())
+        assertThat(mPreference.getSummary()).isEqualTo("Boosted");
-                .isEqualTo(mContext.getText(R.string.color_mode_option_boosted));
     }
 
     @Test
     public void updateState_colorModeNatural_shouldSetSummaryToNatural() {
-        when(mColorDisplayManager.getColorMode())
+        doReturn(ColorDisplayManager.COLOR_MODE_NATURAL).when(mController).getColorMode();
-                .thenReturn(ColorDisplayManager.COLOR_MODE_NATURAL);
 
         mController.updateState(mPreference);
 
-        assertThat(mPreference.getSummary())
+        assertThat(mPreference.getSummary()).isEqualTo("Natural");
-                .isEqualTo(mContext.getText(R.string.color_mode_option_natural));
     }
 }

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