diff options
6 files changed, 213 insertions, 61 deletions
diff --git a/services/core/java/com/android/server/display/DisplayDeviceConfig.java b/services/core/java/com/android/server/display/DisplayDeviceConfig.java index e048a0f87d82..7a002646ed0c 100644 --- a/services/core/java/com/android/server/display/DisplayDeviceConfig.java +++ b/services/core/java/com/android/server/display/DisplayDeviceConfig.java @@ -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(); } } diff --git a/services/core/java/com/android/server/display/DisplayModeDirector.java b/services/core/java/com/android/server/display/DisplayModeDirector.java index 72c9a4a32fb3..5f6660bff7b9 100644 --- a/services/core/java/com/android/server/display/DisplayModeDirector.java +++ b/services/core/java/com/android/server/display/DisplayModeDirector.java @@ -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( @@ -1894,14 +1950,6 @@ public class DisplayModeDirector { } /** - * @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 */ @VisibleForTesting @@ -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, diff --git a/services/core/xsd/display-device-config/display-device-config.xsd b/services/core/xsd/display-device-config/display-device-config.xsd index 97dbe04e7388..164a387cd86b 100644 --- a/services/core/xsd/display-device-config/display-device-config.xsd +++ b/services/core/xsd/display-device-config/display-device-config.xsd @@ -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"/> diff --git a/services/core/xsd/display-device-config/schema/current.txt b/services/core/xsd/display-device-config/schema/current.txt index aba8a2c9bcb2..5684ab69416b 100644 --- a/services/core/xsd/display-device-config/schema/current.txt +++ b/services/core/xsd/display-device-config/schema/current.txt @@ -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); } diff --git a/services/tests/servicestests/src/com/android/server/display/DisplayDeviceConfigTest.java b/services/tests/servicestests/src/com/android/server/display/DisplayDeviceConfigTest.java index 0ea20a8c06b7..fdb9f312eb70 100644 --- a/services/tests/servicestests/src/com/android/server/display/DisplayDeviceConfigTest.java +++ b/services/tests/servicestests/src/com/android/server/display/DisplayDeviceConfigTest.java @@ -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)) diff --git a/services/tests/servicestests/src/com/android/server/display/DisplayModeDirectorTest.java b/services/tests/servicestests/src/com/android/server/display/DisplayModeDirectorTest.java index a35f4eab1772..27d912be1c0d 100644 --- a/services/tests/servicestests/src/com/android/server/display/DisplayModeDirectorTest.java +++ b/services/tests/servicestests/src/com/android/server/display/DisplayModeDirectorTest.java @@ -2260,6 +2260,10 @@ public class DisplayModeDirectorTest { .thenReturn(75); when(resources.getInteger(R.integer.config_defaultRefreshRate)) .thenReturn(45); + when(resources.getInteger(R.integer.config_fixedRefreshRateInHighZone)) + .thenReturn(65); + when(resources.getInteger(R.integer.config_defaultRefreshRateInZone)) + .thenReturn(85); when(resources.getIntArray(R.array.config_brightnessThresholdsOfPeakRefreshRate)) .thenReturn(new int[]{5}); when(resources.getIntArray(R.array.config_ambientThresholdsOfPeakRefreshRate)) @@ -2279,6 +2283,8 @@ public class DisplayModeDirectorTest { assertEquals(director.getSettingsObserver().getDefaultRefreshRate(), 45, 0.0); assertEquals(director.getSettingsObserver().getDefaultPeakRefreshRate(), 75, 0.0); + assertEquals(director.getBrightnessObserver().getRefreshRateInHighZone(), 65); + assertEquals(director.getBrightnessObserver().getRefreshRateInLowZone(), 85); assertArrayEquals(director.getBrightnessObserver().getHighDisplayBrightnessThreshold(), new int[]{250}); assertArrayEquals(director.getBrightnessObserver().getHighAmbientBrightnessThreshold(), @@ -2290,17 +2296,21 @@ public class DisplayModeDirectorTest { // Notify that the default display is updated, such that DisplayDeviceConfig has new values DisplayDeviceConfig displayDeviceConfig = mock(DisplayDeviceConfig.class); - when(displayDeviceConfig.getDefaultLowRefreshRate()).thenReturn(50); - when(displayDeviceConfig.getDefaultHighRefreshRate()).thenReturn(55); + when(displayDeviceConfig.getDefaultLowBlockingZoneRefreshRate()).thenReturn(50); + when(displayDeviceConfig.getDefaultHighBlockingZoneRefreshRate()).thenReturn(55); + when(displayDeviceConfig.getDefaultRefreshRate()).thenReturn(60); + when(displayDeviceConfig.getDefaultPeakRefreshRate()).thenReturn(65); when(displayDeviceConfig.getLowDisplayBrightnessThresholds()).thenReturn(new int[]{25}); when(displayDeviceConfig.getLowAmbientBrightnessThresholds()).thenReturn(new int[]{30}); when(displayDeviceConfig.getHighDisplayBrightnessThresholds()).thenReturn(new int[]{210}); when(displayDeviceConfig.getHighAmbientBrightnessThresholds()).thenReturn(new int[]{2100}); director.defaultDisplayDeviceUpdated(displayDeviceConfig); - assertEquals(director.getSettingsObserver().getDefaultRefreshRate(), 50, 0.0); - assertEquals(director.getSettingsObserver().getDefaultPeakRefreshRate(), 55, + assertEquals(director.getSettingsObserver().getDefaultRefreshRate(), 60, 0.0); + assertEquals(director.getSettingsObserver().getDefaultPeakRefreshRate(), 65, 0.0); + assertEquals(director.getBrightnessObserver().getRefreshRateInHighZone(), 55); + assertEquals(director.getBrightnessObserver().getRefreshRateInLowZone(), 50); assertArrayEquals(director.getBrightnessObserver().getHighDisplayBrightnessThreshold(), new int[]{210}); assertArrayEquals(director.getBrightnessObserver().getHighAmbientBrightnessThreshold(), @@ -2313,6 +2323,8 @@ public class DisplayModeDirectorTest { // Notify that the default display is updated, such that DeviceConfig has new values FakeDeviceConfig config = mInjector.getDeviceConfig(); config.setDefaultPeakRefreshRate(60); + config.setRefreshRateInHighZone(65); + config.setRefreshRateInLowZone(70); config.setLowAmbientBrightnessThresholds(new int[]{20}); config.setLowDisplayBrightnessThresholds(new int[]{10}); config.setHighDisplayBrightnessThresholds(new int[]{255}); @@ -2320,9 +2332,11 @@ public class DisplayModeDirectorTest { director.defaultDisplayDeviceUpdated(displayDeviceConfig); - assertEquals(director.getSettingsObserver().getDefaultRefreshRate(), 50, 0.0); + assertEquals(director.getSettingsObserver().getDefaultRefreshRate(), 60, 0.0); assertEquals(director.getSettingsObserver().getDefaultPeakRefreshRate(), 60, 0.0); + assertEquals(director.getBrightnessObserver().getRefreshRateInHighZone(), 65); + assertEquals(director.getBrightnessObserver().getRefreshRateInLowZone(), 70); assertArrayEquals(director.getBrightnessObserver().getHighDisplayBrightnessThreshold(), new int[]{255}); assertArrayEquals(director.getBrightnessObserver().getHighAmbientBrightnessThreshold(), @@ -2362,8 +2376,8 @@ public class DisplayModeDirectorTest { any(Handler.class)); DisplayDeviceConfig ddcMock = mock(DisplayDeviceConfig.class); - when(ddcMock.getDefaultLowRefreshRate()).thenReturn(50); - when(ddcMock.getDefaultHighRefreshRate()).thenReturn(55); + when(ddcMock.getDefaultLowBlockingZoneRefreshRate()).thenReturn(50); + when(ddcMock.getDefaultHighBlockingZoneRefreshRate()).thenReturn(55); when(ddcMock.getLowDisplayBrightnessThresholds()).thenReturn(new int[]{25}); when(ddcMock.getLowAmbientBrightnessThresholds()).thenReturn(new int[]{30}); when(ddcMock.getHighDisplayBrightnessThresholds()).thenReturn(new int[]{210}); |