Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 9dc66fe9 authored by Rupesh Bansal's avatar Rupesh Bansal
Browse files

Loading lower and higher blocking zone refresh rates 

This is to fix the issue where the lower and higher blocking zone
refresh rate are set to the default and peak refresh rates, causing
unexpected behaviours in the refresh rates of both the blocking zones

Bug: 264418555
Test: atest DisplayDeviceConfigTest DisplayModeDirectorTest
Test: Manual
Merged-In: I04d2fff7af7643149c9a9f7107765c160fb3f483
Change-Id: I72f6c5c2d746bdd85fcf1be4e95d1529084046f3
(cherry picked from commit d184f2f1)
parent b4ee4ef1

services/core/java/com/android/server/display/DisplayDeviceConfig.java

+67 −16
Original line number Diff line number Diff line
@@ -421,6 +421,8 @@ public class DisplayDeviceConfig { 
    private static final String STABLE_ID_SUFFIX_FORMAT = "id_%d";

    private static final String NO_SUFFIX_FORMAT = "%d";

    private static final long STABLE_FLAG = 1L << 62;

    private static final int DEFAULT_PEAK_REFRESH_RATE = 0;

    private static final int DEFAULT_REFRESH_RATE = 60;

    private static final int DEFAULT_LOW_REFRESH_RATE = 60;

    private static final int DEFAULT_HIGH_REFRESH_RATE = 0;

    private static final int[] DEFAULT_BRIGHTNESS_THRESHOLDS = new int[]{};
@@ -589,17 +591,29 @@ public class DisplayDeviceConfig { 
     * using higher refresh rates, even if display modes with higher refresh rates are available

     * from hardware composer. Only has an effect if the value is non-zero.

     */

    private int mDefaultHighRefreshRate = DEFAULT_HIGH_REFRESH_RATE;

    private int mDefaultPeakRefreshRate = DEFAULT_PEAK_REFRESH_RATE;



    /**

     * The default refresh rate for a given device. This value sets the higher default

     * refresh rate. If the hardware composer on the device supports display modes with

     * a higher refresh rate than the default value specified here, the framework may use those

     * higher refresh rate modes if an app chooses one by setting preferredDisplayModeId or calling

     * setFrameRate(). We have historically allowed fallback to mDefaultHighRefreshRate if

     * mDefaultLowRefreshRate is set to 0, but this is not supported anymore.

     * setFrameRate(). We have historically allowed fallback to mDefaultPeakRefreshRate if

     * mDefaultRefreshRate is set to 0, but this is not supported anymore.

     */

    private int mDefaultLowRefreshRate = DEFAULT_LOW_REFRESH_RATE;

    private int mDefaultRefreshRate = DEFAULT_REFRESH_RATE;



    /**

     * Default refresh rate in the high zone defined by brightness and ambient thresholds.

     * If non-positive, then the refresh rate is unchanged even if thresholds are configured.

     */

    private int mDefaultHighBlockingZoneRefreshRate = DEFAULT_HIGH_REFRESH_RATE;



    /**

     * Default refresh rate in the zone defined by brightness and ambient thresholds.

     * If non-positive, then the refresh rate is unchanged even if thresholds are configured.

     */

    private int mDefaultLowBlockingZoneRefreshRate = DEFAULT_LOW_REFRESH_RATE;



    /**

     * The display uses different gamma curves for different refresh rates. It's hard for panel
@@ -1327,15 +1341,29 @@ public class DisplayDeviceConfig { 
    /**

     * @return Default peak refresh rate of the associated display

     */

    public int getDefaultHighRefreshRate() {

        return mDefaultHighRefreshRate;

    public int getDefaultPeakRefreshRate() {

        return mDefaultPeakRefreshRate;

    }



    /**

     * @return Default refresh rate of the associated display

     */

    public int getDefaultLowRefreshRate() {

        return mDefaultLowRefreshRate;

    public int getDefaultRefreshRate() {

        return mDefaultRefreshRate;

    }



    /**

     * @return Default refresh rate in the higher blocking zone of the associated display

     */

    public int getDefaultHighBlockingZoneRefreshRate() {

        return mDefaultHighBlockingZoneRefreshRate;

    }



    /**

     * @return Default refresh rate in the lower blocking zone of the associated display

     */

    public int getDefaultLowBlockingZoneRefreshRate() {

        return mDefaultLowBlockingZoneRefreshRate;

    }



    /**
@@ -1482,8 +1510,10 @@ public class DisplayDeviceConfig { 
                + ", mDdcAutoBrightnessAvailable= " + mDdcAutoBrightnessAvailable

                + ", mAutoBrightnessAvailable= " + mAutoBrightnessAvailable

                + "\n"

                + ", mDefaultRefreshRate= " + mDefaultLowRefreshRate

                + ", mDefaultPeakRefreshRate= " + mDefaultHighRefreshRate

                + ", mDefaultLowBlockingZoneRefreshRate= " + mDefaultLowBlockingZoneRefreshRate

                + ", mDefaultHighBlockingZoneRefreshRate= " + mDefaultHighBlockingZoneRefreshRate

                + ", mDefaultPeakRefreshRate= " + mDefaultPeakRefreshRate

                + ", mDefaultRefreshRate= " + mDefaultRefreshRate

                + ", mLowDisplayBrightnessThresholds= "

                + Arrays.toString(mLowDisplayBrightnessThresholds)

                + ", mLowAmbientBrightnessThresholds= "
@@ -1838,10 +1868,31 @@ public class DisplayDeviceConfig { 
        BlockingZoneConfig higherBlockingZoneConfig =

                (refreshRateConfigs == null) ? null

                        : refreshRateConfigs.getHigherBlockingZoneConfigs();

        loadPeakDefaultRefreshRate(refreshRateConfigs);

        loadDefaultRefreshRate(refreshRateConfigs);

        loadLowerRefreshRateBlockingZones(lowerBlockingZoneConfig);

        loadHigherRefreshRateBlockingZones(higherBlockingZoneConfig);

    }



    private void loadPeakDefaultRefreshRate(RefreshRateConfigs refreshRateConfigs) {

        if (refreshRateConfigs == null || refreshRateConfigs.getDefaultPeakRefreshRate() == null) {

            mDefaultPeakRefreshRate = mContext.getResources().getInteger(

                R.integer.config_defaultPeakRefreshRate);

        } else {

            mDefaultPeakRefreshRate =

                refreshRateConfigs.getDefaultPeakRefreshRate().intValue();

        }

    }



    private void loadDefaultRefreshRate(RefreshRateConfigs refreshRateConfigs) {

        if (refreshRateConfigs == null || refreshRateConfigs.getDefaultRefreshRate() == null) {

            mDefaultRefreshRate = mContext.getResources().getInteger(

                R.integer.config_defaultRefreshRate);

        } else {

            mDefaultRefreshRate =

                refreshRateConfigs.getDefaultRefreshRate().intValue();

        }

    }



    /**

     * Loads the refresh rate configurations pertaining to the upper blocking zones.
@@ -1866,10 +1917,10 @@ public class DisplayDeviceConfig { 
    private void loadHigherBlockingZoneDefaultRefreshRate(

                BlockingZoneConfig upperBlockingZoneConfig) {

        if (upperBlockingZoneConfig == null) {

            mDefaultHighRefreshRate = mContext.getResources().getInteger(

                com.android.internal.R.integer.config_defaultPeakRefreshRate);

            mDefaultHighBlockingZoneRefreshRate = mContext.getResources().getInteger(

                com.android.internal.R.integer.config_fixedRefreshRateInHighZone);

        } else {

            mDefaultHighRefreshRate =

            mDefaultHighBlockingZoneRefreshRate =

                upperBlockingZoneConfig.getDefaultRefreshRate().intValue();

        }

    }
@@ -1881,10 +1932,10 @@ public class DisplayDeviceConfig { 
    private void loadLowerBlockingZoneDefaultRefreshRate(

                BlockingZoneConfig lowerBlockingZoneConfig) {

        if (lowerBlockingZoneConfig == null) {

            mDefaultLowRefreshRate = mContext.getResources().getInteger(

                com.android.internal.R.integer.config_defaultRefreshRate);

            mDefaultLowBlockingZoneRefreshRate = mContext.getResources().getInteger(

                com.android.internal.R.integer.config_defaultRefreshRateInZone);

        } else {

            mDefaultLowRefreshRate =

            mDefaultLowBlockingZoneRefreshRate =

                lowerBlockingZoneConfig.getDefaultRefreshRate().intValue();

        }

    }

services/core/java/com/android/server/display/DisplayModeDirector.java

+93 −32
Original line number Diff line number Diff line
@@ -1373,7 +1373,7 @@ public class DisplayModeDirector { 
            mDefaultRefreshRate =

                    (displayDeviceConfig == null) ? (float) mContext.getResources().getInteger(

                        R.integer.config_defaultRefreshRate)

                        : (float) displayDeviceConfig.getDefaultLowRefreshRate();

                        : (float) displayDeviceConfig.getDefaultRefreshRate();

        }



        public void observe() {
@@ -1460,7 +1460,7 @@ public class DisplayModeDirector { 
                defaultPeakRefreshRate =

                        (displayDeviceConfig == null) ? (float) mContext.getResources().getInteger(

                                R.integer.config_defaultPeakRefreshRate)

                                : (float) displayDeviceConfig.getDefaultHighRefreshRate();

                                : (float) displayDeviceConfig.getDefaultPeakRefreshRate();

            }

            mDefaultPeakRefreshRate = defaultPeakRefreshRate;

        }
@@ -1819,8 +1819,26 @@ public class DisplayModeDirector { 
            return mHighAmbientBrightnessThresholds;

        }



        /**

         * @return the refresh rate to lock to when in a high brightness zone

         */

        @VisibleForTesting

        int getRefreshRateInHighZone() {

            return mRefreshRateInHighZone;

        }



        /**

         * @return the refresh rate to lock to when in a low brightness zone

         */

        @VisibleForTesting

        int getRefreshRateInLowZone() {

            return mRefreshRateInLowZone;

        }



        private void loadLowBrightnessThresholds(DisplayDeviceConfig displayDeviceConfig,

                boolean attemptLoadingFromDeviceConfig) {

            loadRefreshRateInHighZone(displayDeviceConfig, attemptLoadingFromDeviceConfig);

            loadRefreshRateInLowZone(displayDeviceConfig, attemptLoadingFromDeviceConfig);

            mLowDisplayBrightnessThresholds = loadBrightnessThresholds(

                    () -> mDeviceConfigDisplaySettings.getLowDisplayBrightnessThresholds(),

                    () -> displayDeviceConfig.getLowDisplayBrightnessThresholds(),
@@ -1841,6 +1859,44 @@ public class DisplayModeDirector { 
            }

        }



        private void loadRefreshRateInLowZone(DisplayDeviceConfig displayDeviceConfig,

                boolean attemptLoadingFromDeviceConfig) {

            int refreshRateInLowZone =

                    (displayDeviceConfig == null) ? mContext.getResources().getInteger(

                        R.integer.config_defaultRefreshRateInZone)

                        : displayDeviceConfig.getDefaultLowBlockingZoneRefreshRate();

            if (attemptLoadingFromDeviceConfig) {

                try {

                    refreshRateInLowZone = mDeviceConfig.getInt(

                        DeviceConfig.NAMESPACE_DISPLAY_MANAGER,

                        DisplayManager.DeviceConfig.KEY_REFRESH_RATE_IN_LOW_ZONE,

                        refreshRateInLowZone);

                } catch (Exception exception) {

                    // Do nothing

                }

            }

            mRefreshRateInLowZone = refreshRateInLowZone;

        }



        private void loadRefreshRateInHighZone(DisplayDeviceConfig displayDeviceConfig,

                boolean attemptLoadingFromDeviceConfig) {

            int refreshRateInHighZone =

                    (displayDeviceConfig == null) ? mContext.getResources().getInteger(

                        R.integer.config_fixedRefreshRateInHighZone) : displayDeviceConfig

                        .getDefaultHighBlockingZoneRefreshRate();

            if (attemptLoadingFromDeviceConfig) {

                try {

                    refreshRateInHighZone = mDeviceConfig.getInt(

                        DeviceConfig.NAMESPACE_DISPLAY_MANAGER,

                        DisplayManager.DeviceConfig.KEY_REFRESH_RATE_IN_HIGH_ZONE,

                        refreshRateInHighZone);

                } catch (Exception exception) {

                    // Do nothing

                }

            }

            mRefreshRateInHighZone = refreshRateInHighZone;

        }



        private void loadHighBrightnessThresholds(DisplayDeviceConfig displayDeviceConfig,

                boolean attemptLoadingFromDeviceConfig) {

            mHighDisplayBrightnessThresholds = loadBrightnessThresholds(
@@ -1893,14 +1949,6 @@ public class DisplayModeDirector { 
            return brightnessThresholds;

        }



        /**

         * @return the refresh to lock to when in a low brightness zone

         */

        @VisibleForTesting

        int getRefreshRateInLowZone() {

            return mRefreshRateInLowZone;

        }



        /**

         * @return the display brightness thresholds for the low brightness zones

         */
@@ -1946,8 +1994,17 @@ public class DisplayModeDirector { 
                mHighAmbientBrightnessThresholds = highAmbientBrightnessThresholds;

            }



            mRefreshRateInLowZone = mDeviceConfigDisplaySettings.getRefreshRateInLowZone();

            mRefreshRateInHighZone = mDeviceConfigDisplaySettings.getRefreshRateInHighZone();

            final int refreshRateInLowZone = mDeviceConfigDisplaySettings

                    .getRefreshRateInLowZone();

            if (refreshRateInLowZone != -1) {

                mRefreshRateInLowZone = refreshRateInLowZone;

            }



            final int refreshRateInHighZone = mDeviceConfigDisplaySettings

                    .getRefreshRateInHighZone();

            if (refreshRateInHighZone != -1) {

                mRefreshRateInHighZone = refreshRateInHighZone;

            }



            restartObserver();

            mDeviceConfigDisplaySettings.startListening();
@@ -2001,6 +2058,10 @@ public class DisplayModeDirector { 
            restartObserver();

        }



        /**

         * Used to reload the lower blocking zone refresh rate in case of changes in the

         * DeviceConfig properties.

         */

        public void onDeviceConfigRefreshRateInLowZoneChanged(int refreshRate) {

            if (refreshRate != mRefreshRateInLowZone) {

                mRefreshRateInLowZone = refreshRate;
@@ -2024,6 +2085,10 @@ public class DisplayModeDirector { 
            restartObserver();

        }



        /**

         * Used to reload the higher blocking zone refresh rate in case of changes in the

         * DeviceConfig properties.

         */

        public void onDeviceConfigRefreshRateInHighZoneChanged(int refreshRate) {

            if (refreshRate != mRefreshRateInHighZone) {

                mRefreshRateInHighZone = refreshRate;
@@ -2874,15 +2939,10 @@ public class DisplayModeDirector { 
        }



        public int getRefreshRateInLowZone() {

            int defaultRefreshRateInZone = mContext.getResources().getInteger(

                    R.integer.config_defaultRefreshRateInZone);



            int refreshRate = mDeviceConfig.getInt(

            return mDeviceConfig.getInt(

                    DeviceConfig.NAMESPACE_DISPLAY_MANAGER,

                    DisplayManager.DeviceConfig.KEY_REFRESH_RATE_IN_LOW_ZONE,

                    defaultRefreshRateInZone);

                    DisplayManager.DeviceConfig.KEY_REFRESH_RATE_IN_LOW_ZONE, -1);



            return refreshRate;

        }



        /*
@@ -2904,15 +2964,10 @@ public class DisplayModeDirector { 
        }



        public int getRefreshRateInHighZone() {

            int defaultRefreshRateInZone = mContext.getResources().getInteger(

                    R.integer.config_fixedRefreshRateInHighZone);



            int refreshRate = mDeviceConfig.getInt(

            return mDeviceConfig.getInt(

                    DeviceConfig.NAMESPACE_DISPLAY_MANAGER,

                    DisplayManager.DeviceConfig.KEY_REFRESH_RATE_IN_HIGH_ZONE,

                    defaultRefreshRateInZone);



            return refreshRate;

                    -1);

        }



        public int getRefreshRateInHbmSunlight() {
@@ -2960,23 +3015,29 @@ public class DisplayModeDirector { 


            int[] lowDisplayBrightnessThresholds = getLowDisplayBrightnessThresholds();

            int[] lowAmbientBrightnessThresholds = getLowAmbientBrightnessThresholds();

            int refreshRateInLowZone = getRefreshRateInLowZone();

            final int refreshRateInLowZone = getRefreshRateInLowZone();



            mHandler.obtainMessage(MSG_LOW_BRIGHTNESS_THRESHOLDS_CHANGED,

                    new Pair<>(lowDisplayBrightnessThresholds, lowAmbientBrightnessThresholds))

                    .sendToTarget();

            mHandler.obtainMessage(MSG_REFRESH_RATE_IN_LOW_ZONE_CHANGED, refreshRateInLowZone, 0)

                    .sendToTarget();



            if (refreshRateInLowZone != -1) {

                mHandler.obtainMessage(MSG_REFRESH_RATE_IN_LOW_ZONE_CHANGED, refreshRateInLowZone,

                        0).sendToTarget();

            }



            int[] highDisplayBrightnessThresholds = getHighDisplayBrightnessThresholds();

            int[] highAmbientBrightnessThresholds = getHighAmbientBrightnessThresholds();

            int refreshRateInHighZone = getRefreshRateInHighZone();

            final int refreshRateInHighZone = getRefreshRateInHighZone();



            mHandler.obtainMessage(MSG_HIGH_BRIGHTNESS_THRESHOLDS_CHANGED,

                    new Pair<>(highDisplayBrightnessThresholds, highAmbientBrightnessThresholds))

                    .sendToTarget();

            mHandler.obtainMessage(MSG_REFRESH_RATE_IN_HIGH_ZONE_CHANGED, refreshRateInHighZone, 0)

                    .sendToTarget();



            if (refreshRateInHighZone != -1) {

                mHandler.obtainMessage(MSG_REFRESH_RATE_IN_HIGH_ZONE_CHANGED, refreshRateInHighZone,

                        0).sendToTarget();

            }



            final int refreshRateInHbmSunlight = getRefreshRateInHbmSunlight();

            mHandler.obtainMessage(MSG_REFRESH_RATE_IN_HBM_SUNLIGHT_CHANGED,

services/core/xsd/display-device-config/display-device-config.xsd

+8 −0
Original line number Diff line number Diff line
@@ -472,6 +472,14 @@ 
    </xs:complexType>



    <xs:complexType name="refreshRateConfigs">

        <xs:element name="defaultRefreshRate" type="xs:nonNegativeInteger"

                    minOccurs="0" maxOccurs="1">

            <xs:annotation name="final"/>

        </xs:element>

        <xs:element name="defaultPeakRefreshRate" type="xs:nonNegativeInteger"

                    minOccurs="0" maxOccurs="1">

            <xs:annotation name="final"/>

        </xs:element>

        <xs:element name="lowerBlockingZoneConfigs" type="blockingZoneConfig"

                    minOccurs="0" maxOccurs="1">

            <xs:annotation name="final"/>

services/core/xsd/display-device-config/schema/current.txt

+4 −0
Original line number Diff line number Diff line
@@ -188,8 +188,12 @@ package com.android.server.display.config { 


  public class RefreshRateConfigs {

    ctor public RefreshRateConfigs();

    method public final java.math.BigInteger getDefaultPeakRefreshRate();

    method public final java.math.BigInteger getDefaultRefreshRate();

    method public final com.android.server.display.config.BlockingZoneConfig getHigherBlockingZoneConfigs();

    method public final com.android.server.display.config.BlockingZoneConfig getLowerBlockingZoneConfigs();

    method public final void setDefaultPeakRefreshRate(java.math.BigInteger);

    method public final void setDefaultRefreshRate(java.math.BigInteger);

    method public final void setHigherBlockingZoneConfigs(com.android.server.display.config.BlockingZoneConfig);

    method public final void setLowerBlockingZoneConfigs(com.android.server.display.config.BlockingZoneConfig);

  }

services/tests/servicestests/src/com/android/server/display/DisplayDeviceConfigTest.java

+20 −6
Original line number Diff line number Diff line
@@ -53,6 +53,8 @@ import java.util.List; 
public final class DisplayDeviceConfigTest {

    private static final int DEFAULT_PEAK_REFRESH_RATE = 75;

    private static final int DEFAULT_REFRESH_RATE = 120;

    private static final int DEFAULT_HIGH_BLOCKING_ZONE_REFRESH_RATE = 55;

    private static final int DEFAULT_LOW_BLOCKING_ZONE_REFRESH_RATE = 95;

    private static final int[] LOW_BRIGHTNESS_THRESHOLD_OF_PEAK_REFRESH_RATE = new int[]{10, 30};

    private static final int[] LOW_AMBIENT_THRESHOLD_OF_PEAK_REFRESH_RATE = new int[]{1, 21};

    private static final int[] HIGH_BRIGHTNESS_THRESHOLD_OF_PEAK_REFRESH_RATE = new int[]{160};
@@ -149,8 +151,10 @@ public final class DisplayDeviceConfigTest { 
        assertArrayEquals(new float[]{23, 24, 25},

                mDisplayDeviceConfig.getAmbientDarkeningPercentagesIdle(), ZERO_DELTA);



        assertEquals(75, mDisplayDeviceConfig.getDefaultLowRefreshRate());

        assertEquals(90, mDisplayDeviceConfig.getDefaultHighRefreshRate());

        assertEquals(75, mDisplayDeviceConfig.getDefaultLowBlockingZoneRefreshRate());

        assertEquals(90, mDisplayDeviceConfig.getDefaultHighBlockingZoneRefreshRate());

        assertEquals(85, mDisplayDeviceConfig.getDefaultPeakRefreshRate());

        assertEquals(45, mDisplayDeviceConfig.getDefaultRefreshRate());

        assertArrayEquals(new int[]{45, 55},

                mDisplayDeviceConfig.getLowDisplayBrightnessThresholds());

        assertArrayEquals(new int[]{50, 60},
@@ -278,8 +282,12 @@ public final class DisplayDeviceConfigTest { 
                mDisplayDeviceConfig.getAmbientDarkeningLevelsIdle(), ZERO_DELTA);

        assertArrayEquals(new float[]{29, 30, 31},

                mDisplayDeviceConfig.getAmbientDarkeningPercentagesIdle(), ZERO_DELTA);

        assertEquals(mDisplayDeviceConfig.getDefaultLowRefreshRate(), DEFAULT_REFRESH_RATE);

        assertEquals(mDisplayDeviceConfig.getDefaultHighRefreshRate(), DEFAULT_PEAK_REFRESH_RATE);

        assertEquals(mDisplayDeviceConfig.getDefaultLowBlockingZoneRefreshRate(),

                DEFAULT_LOW_BLOCKING_ZONE_REFRESH_RATE);

        assertEquals(mDisplayDeviceConfig.getDefaultHighBlockingZoneRefreshRate(),

                DEFAULT_HIGH_BLOCKING_ZONE_REFRESH_RATE);

        assertEquals(mDisplayDeviceConfig.getDefaultPeakRefreshRate(), DEFAULT_PEAK_REFRESH_RATE);

        assertEquals(mDisplayDeviceConfig.getDefaultRefreshRate(), DEFAULT_REFRESH_RATE);

        assertArrayEquals(mDisplayDeviceConfig.getLowDisplayBrightnessThresholds(),

                LOW_BRIGHTNESS_THRESHOLD_OF_PEAK_REFRESH_RATE);

        assertArrayEquals(mDisplayDeviceConfig.getLowAmbientBrightnessThresholds(),
@@ -537,6 +545,8 @@ public final class DisplayDeviceConfigTest { 
                +       "</concurrentDisplaysBrightnessThrottlingMap>\n"

                +   "</thermalThrottling>\n"

                +   "<refreshRate>\n"

                +       "<defaultRefreshRate>45</defaultRefreshRate>\n"

                +       "<defaultPeakRefreshRate>85</defaultPeakRefreshRate>\n"

                +       "<lowerBlockingZoneConfigs>\n"

                +           "<defaultRefreshRate>75</defaultRefreshRate>\n"

                +           "<blockingZoneThreshold>\n"
@@ -642,10 +652,14 @@ public final class DisplayDeviceConfigTest { 
                .thenReturn(new int[]{370, 380, 390});



        // Configs related to refresh rates and blocking zones

        when(mResources.getInteger(com.android.internal.R.integer.config_defaultPeakRefreshRate))

        when(mResources.getInteger(R.integer.config_defaultPeakRefreshRate))

                .thenReturn(DEFAULT_PEAK_REFRESH_RATE);

        when(mResources.getInteger(com.android.internal.R.integer.config_defaultRefreshRate))

        when(mResources.getInteger(R.integer.config_defaultRefreshRate))

                .thenReturn(DEFAULT_REFRESH_RATE);

        when(mResources.getInteger(R.integer.config_fixedRefreshRateInHighZone))

            .thenReturn(DEFAULT_HIGH_BLOCKING_ZONE_REFRESH_RATE);

        when(mResources.getInteger(R.integer.config_defaultRefreshRateInZone))

            .thenReturn(DEFAULT_LOW_BLOCKING_ZONE_REFRESH_RATE);

        when(mResources.getIntArray(R.array.config_brightnessThresholdsOfPeakRefreshRate))

                .thenReturn(LOW_BRIGHTNESS_THRESHOLD_OF_PEAK_REFRESH_RATE);

        when(mResources.getIntArray(R.array.config_ambientThresholdsOfPeakRefreshRate))