Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge "Revert "Loading lower and higher blocking zone refresh rates""

Browse Source
This commit is contained in:
Rupesh Bansal
2023-02-01 15:38:24 +00:00
committed by Android (Google) Code Review
parent 5b36cc0357 abdb5347d2
commit 6faa06f51f
6 changed files with 62 additions and 214 deletions
Download Patch File Download Diff File Expand all files Collapse all files

83
services/core/java/com/android/server/display/DisplayDeviceConfig.java
View File

@@ -421,8 +421,6 @@ 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[]{};
@@ -591,29 +589,17 @@ 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 mDefaultPeakRefreshRate = DEFAULT_PEAK_REFRESH_RATE;
private int mDefaultHighRefreshRate = DEFAULT_HIGH_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 mDefaultPeakRefreshRate if
* mDefaultRefreshRate is set to 0, but this is not supported anymore.
* setFrameRate(). We have historically allowed fallback to mDefaultHighRefreshRate if
* mDefaultLowRefreshRate is set to 0, but this is not supported anymore.
*/
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;
private int mDefaultLowRefreshRate = DEFAULT_LOW_REFRESH_RATE;
/**
* The display uses different gamma curves for different refresh rates. It's hard for panel
@@ -1341,29 +1327,15 @@ public class DisplayDeviceConfig {
/**
* @return Default peak refresh rate of the associated display
*/
public int getDefaultPeakRefreshRate() {
return mDefaultPeakRefreshRate;
public int getDefaultHighRefreshRate() {
return mDefaultHighRefreshRate;
}
/**
* @return Default refresh rate of the associated display
*/
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;
public int getDefaultLowRefreshRate() {
return mDefaultLowRefreshRate;
}
/**
@@ -1510,10 +1482,8 @@ public class DisplayDeviceConfig {
+ ", mDdcAutoBrightnessAvailable= " + mDdcAutoBrightnessAvailable
+ ", mAutoBrightnessAvailable= " + mAutoBrightnessAvailable
+ "\n"
+ ", mDefaultLowBlockingZoneRefreshRate= " + mDefaultLowBlockingZoneRefreshRate
+ ", mDefaultHighBlockingZoneRefreshRate= " + mDefaultHighBlockingZoneRefreshRate
+ ", mDefaultPeakRefreshRate= " + mDefaultPeakRefreshRate
+ ", mDefaultRefreshRate= " + mDefaultRefreshRate
+ ", mDefaultRefreshRate= " + mDefaultLowRefreshRate
+ ", mDefaultPeakRefreshRate= " + mDefaultHighRefreshRate
+ ", mLowDisplayBrightnessThresholds= "
+ Arrays.toString(mLowDisplayBrightnessThresholds)
+ ", mLowAmbientBrightnessThresholds= "
@@ -1868,31 +1838,10 @@ 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.
@@ -1917,10 +1866,10 @@ public class DisplayDeviceConfig {
private void loadHigherBlockingZoneDefaultRefreshRate(
BlockingZoneConfig upperBlockingZoneConfig) {
if (upperBlockingZoneConfig == null) {
mDefaultHighBlockingZoneRefreshRate = mContext.getResources().getInteger(
com.android.internal.R.integer.config_fixedRefreshRateInHighZone);
mDefaultHighRefreshRate = mContext.getResources().getInteger(
com.android.internal.R.integer.config_defaultPeakRefreshRate);
} else {
mDefaultHighBlockingZoneRefreshRate =
mDefaultHighRefreshRate =
upperBlockingZoneConfig.getDefaultRefreshRate().intValue();
}
}
@@ -1932,10 +1881,10 @@ public class DisplayDeviceConfig {
private void loadLowerBlockingZoneDefaultRefreshRate(
BlockingZoneConfig lowerBlockingZoneConfig) {
if (lowerBlockingZoneConfig == null) {
mDefaultLowBlockingZoneRefreshRate = mContext.getResources().getInteger(
com.android.internal.R.integer.config_defaultRefreshRateInZone);
mDefaultLowRefreshRate = mContext.getResources().getInteger(
com.android.internal.R.integer.config_defaultRefreshRate);
} else {
mDefaultLowBlockingZoneRefreshRate =
mDefaultLowRefreshRate =
lowerBlockingZoneConfig.getDefaultRefreshRate().intValue();
}
}

127
services/core/java/com/android/server/display/DisplayModeDirector.java
View File

@@ -1373,7 +1373,7 @@ public class DisplayModeDirector {
mDefaultRefreshRate =
(displayDeviceConfig == null) ? (float) mContext.getResources().getInteger(
R.integer.config_defaultRefreshRate)
: (float) displayDeviceConfig.getDefaultRefreshRate();
: (float) displayDeviceConfig.getDefaultLowRefreshRate();
}
public void observe() {
@@ -1460,7 +1460,7 @@ public class DisplayModeDirector {
defaultPeakRefreshRate =
(displayDeviceConfig == null) ? (float) mContext.getResources().getInteger(
R.integer.config_defaultPeakRefreshRate)
: (float) displayDeviceConfig.getDefaultPeakRefreshRate();
: (float) displayDeviceConfig.getDefaultHighRefreshRate();
}
mDefaultPeakRefreshRate = defaultPeakRefreshRate;
}
@@ -1819,26 +1819,8 @@ 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(),
@@ -1859,44 +1841,6 @@ 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(
@@ -1949,6 +1893,14 @@ 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
*/
@@ -1994,17 +1946,8 @@ public class DisplayModeDirector {
mHighAmbientBrightnessThresholds = highAmbientBrightnessThresholds;
}
final int refreshRateInLowZone = mDeviceConfigDisplaySettings
.getRefreshRateInLowZone();
if (refreshRateInLowZone != -1) {
mRefreshRateInLowZone = refreshRateInLowZone;
}
final int refreshRateInHighZone = mDeviceConfigDisplaySettings
.getRefreshRateInHighZone();
if (refreshRateInHighZone != -1) {
mRefreshRateInHighZone = refreshRateInHighZone;
}
mRefreshRateInLowZone = mDeviceConfigDisplaySettings.getRefreshRateInLowZone();
mRefreshRateInHighZone = mDeviceConfigDisplaySettings.getRefreshRateInHighZone();
restartObserver();
mDeviceConfigDisplaySettings.startListening();
@@ -2058,10 +2001,6 @@ 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;
@@ -2085,10 +2024,6 @@ 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;
@@ -2939,10 +2874,15 @@ public class DisplayModeDirector {
}
public int getRefreshRateInLowZone() {
return mDeviceConfig.getInt(
DeviceConfig.NAMESPACE_DISPLAY_MANAGER,
DisplayManager.DeviceConfig.KEY_REFRESH_RATE_IN_LOW_ZONE, -1);
int defaultRefreshRateInZone = mContext.getResources().getInteger(
R.integer.config_defaultRefreshRateInZone);
int refreshRate = mDeviceConfig.getInt(
DeviceConfig.NAMESPACE_DISPLAY_MANAGER,
DisplayManager.DeviceConfig.KEY_REFRESH_RATE_IN_LOW_ZONE,
defaultRefreshRateInZone);
return refreshRate;
}
/*
@@ -2964,10 +2904,15 @@ public class DisplayModeDirector {
}
public int getRefreshRateInHighZone() {
return mDeviceConfig.getInt(
int defaultRefreshRateInZone = mContext.getResources().getInteger(
R.integer.config_fixedRefreshRateInHighZone);
int refreshRate = mDeviceConfig.getInt(
DeviceConfig.NAMESPACE_DISPLAY_MANAGER,
DisplayManager.DeviceConfig.KEY_REFRESH_RATE_IN_HIGH_ZONE,
-1);
defaultRefreshRateInZone);
return refreshRate;
}
public int getRefreshRateInHbmSunlight() {
@@ -3015,29 +2960,23 @@ public class DisplayModeDirector {
int[] lowDisplayBrightnessThresholds = getLowDisplayBrightnessThresholds();
int[] lowAmbientBrightnessThresholds = getLowAmbientBrightnessThresholds();
final int refreshRateInLowZone = getRefreshRateInLowZone();
int refreshRateInLowZone = getRefreshRateInLowZone();
mHandler.obtainMessage(MSG_LOW_BRIGHTNESS_THRESHOLDS_CHANGED,
new Pair<>(lowDisplayBrightnessThresholds, lowAmbientBrightnessThresholds))
.sendToTarget();
if (refreshRateInLowZone != -1) {
mHandler.obtainMessage(MSG_REFRESH_RATE_IN_LOW_ZONE_CHANGED, refreshRateInLowZone,
0).sendToTarget();
}
mHandler.obtainMessage(MSG_REFRESH_RATE_IN_LOW_ZONE_CHANGED, refreshRateInLowZone, 0)
.sendToTarget();
int[] highDisplayBrightnessThresholds = getHighDisplayBrightnessThresholds();
int[] highAmbientBrightnessThresholds = getHighAmbientBrightnessThresholds();
final int refreshRateInHighZone = getRefreshRateInHighZone();
int refreshRateInHighZone = getRefreshRateInHighZone();
mHandler.obtainMessage(MSG_HIGH_BRIGHTNESS_THRESHOLDS_CHANGED,
new Pair<>(highDisplayBrightnessThresholds, highAmbientBrightnessThresholds))
.sendToTarget();
if (refreshRateInHighZone != -1) {
mHandler.obtainMessage(MSG_REFRESH_RATE_IN_HIGH_ZONE_CHANGED, refreshRateInHighZone,
0).sendToTarget();
}
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,

8
services/core/xsd/display-device-config/display-device-config.xsd
View File

@@ -472,14 +472,6 @@
</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"/>

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

@@ -188,12 +188,8 @@ 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);
}

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

@@ -53,8 +53,6 @@ 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};
@@ -151,10 +149,8 @@ public final class DisplayDeviceConfigTest {
assertArrayEquals(new float[]{23, 24, 25},
mDisplayDeviceConfig.getAmbientDarkeningPercentagesIdle(), ZERO_DELTA);
assertEquals(75, mDisplayDeviceConfig.getDefaultLowBlockingZoneRefreshRate());
assertEquals(90, mDisplayDeviceConfig.getDefaultHighBlockingZoneRefreshRate());
assertEquals(85, mDisplayDeviceConfig.getDefaultPeakRefreshRate());
assertEquals(45, mDisplayDeviceConfig.getDefaultRefreshRate());
assertEquals(75, mDisplayDeviceConfig.getDefaultLowRefreshRate());
assertEquals(90, mDisplayDeviceConfig.getDefaultHighRefreshRate());
assertArrayEquals(new int[]{45, 55},
mDisplayDeviceConfig.getLowDisplayBrightnessThresholds());
assertArrayEquals(new int[]{50, 60},
@@ -282,12 +278,8 @@ public final class DisplayDeviceConfigTest {
mDisplayDeviceConfig.getAmbientDarkeningLevelsIdle(), ZERO_DELTA);
assertArrayEquals(new float[]{29, 30, 31},
mDisplayDeviceConfig.getAmbientDarkeningPercentagesIdle(), ZERO_DELTA);
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);
assertEquals(mDisplayDeviceConfig.getDefaultLowRefreshRate(), DEFAULT_REFRESH_RATE);
assertEquals(mDisplayDeviceConfig.getDefaultHighRefreshRate(), DEFAULT_PEAK_REFRESH_RATE);
assertArrayEquals(mDisplayDeviceConfig.getLowDisplayBrightnessThresholds(),
LOW_BRIGHTNESS_THRESHOLD_OF_PEAK_REFRESH_RATE);
assertArrayEquals(mDisplayDeviceConfig.getLowAmbientBrightnessThresholds(),
@@ -545,8 +537,6 @@ 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"
@@ -652,14 +642,10 @@ public final class DisplayDeviceConfigTest {
.thenReturn(new int[]{370, 380, 390});
// Configs related to refresh rates and blocking zones
when(mResources.getInteger(R.integer.config_defaultPeakRefreshRate))
when(mResources.getInteger(com.android.internal.R.integer.config_defaultPeakRefreshRate))
.thenReturn(DEFAULT_PEAK_REFRESH_RATE);
when(mResources.getInteger(R.integer.config_defaultRefreshRate))
when(mResources.getInteger(com.android.internal.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))

28
services/tests/servicestests/src/com/android/server/display/DisplayModeDirectorTest.java
View File

@@ -2260,10 +2260,6 @@ 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))
@@ -2283,8 +2279,6 @@ 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(),
@@ -2296,21 +2290,17 @@ public class DisplayModeDirectorTest {
// Notify that the default display is updated, such that DisplayDeviceConfig has new values
DisplayDeviceConfig displayDeviceConfig = mock(DisplayDeviceConfig.class);
when(displayDeviceConfig.getDefaultLowBlockingZoneRefreshRate()).thenReturn(50);
when(displayDeviceConfig.getDefaultHighBlockingZoneRefreshRate()).thenReturn(55);
when(displayDeviceConfig.getDefaultRefreshRate()).thenReturn(60);
when(displayDeviceConfig.getDefaultPeakRefreshRate()).thenReturn(65);
when(displayDeviceConfig.getDefaultLowRefreshRate()).thenReturn(50);
when(displayDeviceConfig.getDefaultHighRefreshRate()).thenReturn(55);
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(), 60, 0.0);
assertEquals(director.getSettingsObserver().getDefaultPeakRefreshRate(), 65,
assertEquals(director.getSettingsObserver().getDefaultRefreshRate(), 50, 0.0);
assertEquals(director.getSettingsObserver().getDefaultPeakRefreshRate(), 55,
0.0);
assertEquals(director.getBrightnessObserver().getRefreshRateInHighZone(), 55);
assertEquals(director.getBrightnessObserver().getRefreshRateInLowZone(), 50);
assertArrayEquals(director.getBrightnessObserver().getHighDisplayBrightnessThreshold(),
new int[]{210});
assertArrayEquals(director.getBrightnessObserver().getHighAmbientBrightnessThreshold(),
@@ -2323,8 +2313,6 @@ 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});
@@ -2332,11 +2320,9 @@ public class DisplayModeDirectorTest {
director.defaultDisplayDeviceUpdated(displayDeviceConfig);
assertEquals(director.getSettingsObserver().getDefaultRefreshRate(), 60, 0.0);
assertEquals(director.getSettingsObserver().getDefaultRefreshRate(), 50, 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(),
@@ -2376,8 +2362,8 @@ public class DisplayModeDirectorTest {
any(Handler.class));
DisplayDeviceConfig ddcMock = mock(DisplayDeviceConfig.class);
when(ddcMock.getDefaultLowBlockingZoneRefreshRate()).thenReturn(50);
when(ddcMock.getDefaultHighBlockingZoneRefreshRate()).thenReturn(55);
when(ddcMock.getDefaultLowRefreshRate()).thenReturn(50);
when(ddcMock.getDefaultHighRefreshRate()).thenReturn(55);
when(ddcMock.getLowDisplayBrightnessThresholds()).thenReturn(new int[]{25});
when(ddcMock.getLowAmbientBrightnessThresholds()).thenReturn(new int[]{30});
when(ddcMock.getHighDisplayBrightnessThresholds()).thenReturn(new int[]{210});