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 Original line 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 STABLE_ID_SUFFIX_FORMAT = "id_%d";

    private static final String NO_SUFFIX_FORMAT = "%d";

    private static final String NO_SUFFIX_FORMAT = "%d";

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

    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_LOW_REFRESH_RATE = 60;

    private static final int DEFAULT_HIGH_REFRESH_RATE = 0;

    private static final int DEFAULT_HIGH_REFRESH_RATE = 0;

    private static final int[] DEFAULT_BRIGHTNESS_THRESHOLDS = new int[]{};

    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

     * 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.

     * 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

     * 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

     * 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

     * 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

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

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

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

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

     * 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

     * 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

     * @return Default peak refresh rate of the associated display

     */

     */

    public int getDefaultHighRefreshRate() {

    public int getDefaultPeakRefreshRate() {

        return mDefaultHighRefreshRate;

        return mDefaultPeakRefreshRate;

    }

    }





    /**

    /**

     * @return Default refresh rate of the associated display

     * @return Default refresh rate of the associated display

     */

     */

    public int getDefaultLowRefreshRate() {

    public int getDefaultRefreshRate() {

        return mDefaultLowRefreshRate;

        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

                + ", mDdcAutoBrightnessAvailable= " + mDdcAutoBrightnessAvailable

                + ", mAutoBrightnessAvailable= " + mAutoBrightnessAvailable

                + ", mAutoBrightnessAvailable= " + mAutoBrightnessAvailable

                + "\n"

                + "\n"

                + ", mDefaultRefreshRate= " + mDefaultLowRefreshRate

                + ", mDefaultLowBlockingZoneRefreshRate= " + mDefaultLowBlockingZoneRefreshRate

                + ", mDefaultPeakRefreshRate= " + mDefaultHighRefreshRate

                + ", mDefaultHighBlockingZoneRefreshRate= " + mDefaultHighBlockingZoneRefreshRate

                + ", mDefaultPeakRefreshRate= " + mDefaultPeakRefreshRate

                + ", mDefaultRefreshRate= " + mDefaultRefreshRate

                + ", mLowDisplayBrightnessThresholds= "

                + ", mLowDisplayBrightnessThresholds= "

                + Arrays.toString(mLowDisplayBrightnessThresholds)

                + Arrays.toString(mLowDisplayBrightnessThresholds)

                + ", mLowAmbientBrightnessThresholds= "

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

        BlockingZoneConfig higherBlockingZoneConfig =

                (refreshRateConfigs == null) ? null

                (refreshRateConfigs == null) ? null

                        : refreshRateConfigs.getHigherBlockingZoneConfigs();

                        : refreshRateConfigs.getHigherBlockingZoneConfigs();

        loadPeakDefaultRefreshRate(refreshRateConfigs);

        loadDefaultRefreshRate(refreshRateConfigs);

        loadLowerRefreshRateBlockingZones(lowerBlockingZoneConfig);

        loadLowerRefreshRateBlockingZones(lowerBlockingZoneConfig);

        loadHigherRefreshRateBlockingZones(higherBlockingZoneConfig);

        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.

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

    private void loadHigherBlockingZoneDefaultRefreshRate(

                BlockingZoneConfig upperBlockingZoneConfig) {

                BlockingZoneConfig upperBlockingZoneConfig) {

        if (upperBlockingZoneConfig == null) {

        if (upperBlockingZoneConfig == null) {

            mDefaultHighRefreshRate = mContext.getResources().getInteger(

            mDefaultHighBlockingZoneRefreshRate = mContext.getResources().getInteger(

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

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

        } else {

        } else {

            mDefaultHighRefreshRate =

            mDefaultHighBlockingZoneRefreshRate =

                upperBlockingZoneConfig.getDefaultRefreshRate().intValue();

                upperBlockingZoneConfig.getDefaultRefreshRate().intValue();

        }

        }

    }

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

    private void loadLowerBlockingZoneDefaultRefreshRate(

                BlockingZoneConfig lowerBlockingZoneConfig) {

                BlockingZoneConfig lowerBlockingZoneConfig) {

        if (lowerBlockingZoneConfig == null) {

        if (lowerBlockingZoneConfig == null) {

            mDefaultLowRefreshRate = mContext.getResources().getInteger(

            mDefaultLowBlockingZoneRefreshRate = mContext.getResources().getInteger(

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

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

        } else {

        } else {

            mDefaultLowRefreshRate =

            mDefaultLowBlockingZoneRefreshRate =

                lowerBlockingZoneConfig.getDefaultRefreshRate().intValue();

                lowerBlockingZoneConfig.getDefaultRefreshRate().intValue();

        }

        }

    }

    }

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

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

            mDefaultRefreshRate =

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

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

                        R.integer.config_defaultRefreshRate)

                        R.integer.config_defaultRefreshRate)

                        : (float) displayDeviceConfig.getDefaultLowRefreshRate();

                        : (float) displayDeviceConfig.getDefaultRefreshRate();

        }

        }





        public void observe() {

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

                defaultPeakRefreshRate =

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

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

                                R.integer.config_defaultPeakRefreshRate)

                                R.integer.config_defaultPeakRefreshRate)

                                : (float) displayDeviceConfig.getDefaultHighRefreshRate();

                                : (float) displayDeviceConfig.getDefaultPeakRefreshRate();

            }

            }

            mDefaultPeakRefreshRate = defaultPeakRefreshRate;

            mDefaultPeakRefreshRate = defaultPeakRefreshRate;

        }

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

            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,

        private void loadLowBrightnessThresholds(DisplayDeviceConfig displayDeviceConfig,

                boolean attemptLoadingFromDeviceConfig) {

                boolean attemptLoadingFromDeviceConfig) {

            loadRefreshRateInHighZone(displayDeviceConfig, attemptLoadingFromDeviceConfig);

            loadRefreshRateInLowZone(displayDeviceConfig, attemptLoadingFromDeviceConfig);

            mLowDisplayBrightnessThresholds = loadBrightnessThresholds(

            mLowDisplayBrightnessThresholds = loadBrightnessThresholds(

                    () -> mDeviceConfigDisplaySettings.getLowDisplayBrightnessThresholds(),

                    () -> mDeviceConfigDisplaySettings.getLowDisplayBrightnessThresholds(),

                    () -> displayDeviceConfig.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,

        private void loadHighBrightnessThresholds(DisplayDeviceConfig displayDeviceConfig,

                boolean attemptLoadingFromDeviceConfig) {

                boolean attemptLoadingFromDeviceConfig) {

            mHighDisplayBrightnessThresholds = loadBrightnessThresholds(

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

            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

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

         */

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

                mHighAmbientBrightnessThresholds = highAmbientBrightnessThresholds;

            }

            }





            mRefreshRateInLowZone = mDeviceConfigDisplaySettings.getRefreshRateInLowZone();

            final int refreshRateInLowZone = mDeviceConfigDisplaySettings

            mRefreshRateInHighZone = mDeviceConfigDisplaySettings.getRefreshRateInHighZone();

                    .getRefreshRateInLowZone();

            if (refreshRateInLowZone != -1) {

                mRefreshRateInLowZone = refreshRateInLowZone;

            }



            final int refreshRateInHighZone = mDeviceConfigDisplaySettings

                    .getRefreshRateInHighZone();

            if (refreshRateInHighZone != -1) {

                mRefreshRateInHighZone = refreshRateInHighZone;

            }





            restartObserver();

            restartObserver();

            mDeviceConfigDisplaySettings.startListening();

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

            restartObserver();

        }

        }





        /**

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

         * DeviceConfig properties.

         */

        public void onDeviceConfigRefreshRateInLowZoneChanged(int refreshRate) {

        public void onDeviceConfigRefreshRateInLowZoneChanged(int refreshRate) {

            if (refreshRate != mRefreshRateInLowZone) {

            if (refreshRate != mRefreshRateInLowZone) {

                mRefreshRateInLowZone = refreshRate;

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

            restartObserver();

        }

        }





        /**

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

         * DeviceConfig properties.

         */

        public void onDeviceConfigRefreshRateInHighZoneChanged(int refreshRate) {

        public void onDeviceConfigRefreshRateInHighZoneChanged(int refreshRate) {

            if (refreshRate != mRefreshRateInHighZone) {

            if (refreshRate != mRefreshRateInHighZone) {

                mRefreshRateInHighZone = refreshRate;

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

        }





        public int getRefreshRateInLowZone() {

        public int getRefreshRateInLowZone() {

            int defaultRefreshRateInZone = mContext.getResources().getInteger(

            return mDeviceConfig.getInt(

                    R.integer.config_defaultRefreshRateInZone);



            int refreshRate = mDeviceConfig.getInt(

                    DeviceConfig.NAMESPACE_DISPLAY_MANAGER,

                    DeviceConfig.NAMESPACE_DISPLAY_MANAGER,

                    DisplayManager.DeviceConfig.KEY_REFRESH_RATE_IN_LOW_ZONE,

                    DisplayManager.DeviceConfig.KEY_REFRESH_RATE_IN_LOW_ZONE, -1);

                    defaultRefreshRateInZone);





            return refreshRate;

        }

        }





        /*

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

        }





        public int getRefreshRateInHighZone() {

        public int getRefreshRateInHighZone() {

            int defaultRefreshRateInZone = mContext.getResources().getInteger(

            return mDeviceConfig.getInt(

                    R.integer.config_fixedRefreshRateInHighZone);



            int refreshRate = mDeviceConfig.getInt(

                    DeviceConfig.NAMESPACE_DISPLAY_MANAGER,

                    DeviceConfig.NAMESPACE_DISPLAY_MANAGER,

                    DisplayManager.DeviceConfig.KEY_REFRESH_RATE_IN_HIGH_ZONE,

                    DisplayManager.DeviceConfig.KEY_REFRESH_RATE_IN_HIGH_ZONE,

                    defaultRefreshRateInZone);

                    -1);



            return refreshRate;

        }

        }





        public int getRefreshRateInHbmSunlight() {

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




            int[] lowDisplayBrightnessThresholds = getLowDisplayBrightnessThresholds();

            int[] lowDisplayBrightnessThresholds = getLowDisplayBrightnessThresholds();

            int[] lowAmbientBrightnessThresholds = getLowAmbientBrightnessThresholds();

            int[] lowAmbientBrightnessThresholds = getLowAmbientBrightnessThresholds();

            int refreshRateInLowZone = getRefreshRateInLowZone();

            final int refreshRateInLowZone = getRefreshRateInLowZone();





            mHandler.obtainMessage(MSG_LOW_BRIGHTNESS_THRESHOLDS_CHANGED,

            mHandler.obtainMessage(MSG_LOW_BRIGHTNESS_THRESHOLDS_CHANGED,

                    new Pair<>(lowDisplayBrightnessThresholds, lowAmbientBrightnessThresholds))

                    new Pair<>(lowDisplayBrightnessThresholds, lowAmbientBrightnessThresholds))

                    .sendToTarget();

                    .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[] highDisplayBrightnessThresholds = getHighDisplayBrightnessThresholds();

            int[] highAmbientBrightnessThresholds = getHighAmbientBrightnessThresholds();

            int[] highAmbientBrightnessThresholds = getHighAmbientBrightnessThresholds();

            int refreshRateInHighZone = getRefreshRateInHighZone();

            final int refreshRateInHighZone = getRefreshRateInHighZone();





            mHandler.obtainMessage(MSG_HIGH_BRIGHTNESS_THRESHOLDS_CHANGED,

            mHandler.obtainMessage(MSG_HIGH_BRIGHTNESS_THRESHOLDS_CHANGED,

                    new Pair<>(highDisplayBrightnessThresholds, highAmbientBrightnessThresholds))

                    new Pair<>(highDisplayBrightnessThresholds, highAmbientBrightnessThresholds))

                    .sendToTarget();

                    .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();

            final int refreshRateInHbmSunlight = getRefreshRateInHbmSunlight();

            mHandler.obtainMessage(MSG_REFRESH_RATE_IN_HBM_SUNLIGHT_CHANGED,

            mHandler.obtainMessage(MSG_REFRESH_RATE_IN_HBM_SUNLIGHT_CHANGED,

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

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

    </xs:complexType>





    <xs:complexType name="refreshRateConfigs">

    <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"

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

                    minOccurs="0" maxOccurs="1">

                    minOccurs="0" maxOccurs="1">

            <xs:annotation name="final"/>

            <xs:annotation name="final"/>

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

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




  public class RefreshRateConfigs {

  public class RefreshRateConfigs {

    ctor public 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 getHigherBlockingZoneConfigs();

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

    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 setHigherBlockingZoneConfigs(com.android.server.display.config.BlockingZoneConfig);

    method public final void setLowerBlockingZoneConfigs(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 Original line Diff line number Diff line
@@ -53,6 +53,8 @@ import java.util.List; 
public final class DisplayDeviceConfigTest {

public final class DisplayDeviceConfigTest {

    private static final int DEFAULT_PEAK_REFRESH_RATE = 75;

    private static final int DEFAULT_PEAK_REFRESH_RATE = 75;

    private static final int DEFAULT_REFRESH_RATE = 120;

    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_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[] 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};

    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},

        assertArrayEquals(new float[]{23, 24, 25},

                mDisplayDeviceConfig.getAmbientDarkeningPercentagesIdle(), ZERO_DELTA);

                mDisplayDeviceConfig.getAmbientDarkeningPercentagesIdle(), ZERO_DELTA);





        assertEquals(75, mDisplayDeviceConfig.getDefaultLowRefreshRate());

        assertEquals(75, mDisplayDeviceConfig.getDefaultLowBlockingZoneRefreshRate());

        assertEquals(90, mDisplayDeviceConfig.getDefaultHighRefreshRate());

        assertEquals(90, mDisplayDeviceConfig.getDefaultHighBlockingZoneRefreshRate());

        assertEquals(85, mDisplayDeviceConfig.getDefaultPeakRefreshRate());

        assertEquals(45, mDisplayDeviceConfig.getDefaultRefreshRate());

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

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

                mDisplayDeviceConfig.getLowDisplayBrightnessThresholds());

                mDisplayDeviceConfig.getLowDisplayBrightnessThresholds());

        assertArrayEquals(new int[]{50, 60},

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

                mDisplayDeviceConfig.getAmbientDarkeningLevelsIdle(), ZERO_DELTA);

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

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

                mDisplayDeviceConfig.getAmbientDarkeningPercentagesIdle(), ZERO_DELTA);

                mDisplayDeviceConfig.getAmbientDarkeningPercentagesIdle(), ZERO_DELTA);

        assertEquals(mDisplayDeviceConfig.getDefaultLowRefreshRate(), DEFAULT_REFRESH_RATE);

        assertEquals(mDisplayDeviceConfig.getDefaultLowBlockingZoneRefreshRate(),

        assertEquals(mDisplayDeviceConfig.getDefaultHighRefreshRate(), DEFAULT_PEAK_REFRESH_RATE);

                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(),

        assertArrayEquals(mDisplayDeviceConfig.getLowDisplayBrightnessThresholds(),

                LOW_BRIGHTNESS_THRESHOLD_OF_PEAK_REFRESH_RATE);

                LOW_BRIGHTNESS_THRESHOLD_OF_PEAK_REFRESH_RATE);

        assertArrayEquals(mDisplayDeviceConfig.getLowAmbientBrightnessThresholds(),

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

                +       "</concurrentDisplaysBrightnessThrottlingMap>\n"

                +   "</thermalThrottling>\n"

                +   "</thermalThrottling>\n"

                +   "<refreshRate>\n"

                +   "<refreshRate>\n"

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

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

                +       "<lowerBlockingZoneConfigs>\n"

                +       "<lowerBlockingZoneConfigs>\n"

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

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

                +           "<blockingZoneThreshold>\n"

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

                .thenReturn(new int[]{370, 380, 390});





        // Configs related to refresh rates and blocking zones

        // 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);

                .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);

                .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))

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

                .thenReturn(LOW_BRIGHTNESS_THRESHOLD_OF_PEAK_REFRESH_RATE);

                .thenReturn(LOW_BRIGHTNESS_THRESHOLD_OF_PEAK_REFRESH_RATE);

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

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