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

Merge "Loading lower and higher blocking zone refresh rates" into tm-qpr-dev am: 2f3a6b6a2b

Browse Source 
Original change: https://googleplex-android-review.googlesource.com/c/platform/frameworks/base/+/20873245

Change-Id: Ie74957eef9de5fa19357c5059264f5cb7156ca16
Signed-off-by: Automerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
This commit is contained in:
Rupesh Bansal
2023-01-11 14:58:17 +00:00
committed by Automerger Merge Worker
parent 1320567b29 2f3a6b6a2b
commit 2086273229
6 changed files with 211 additions and 59 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

@@ -402,6 +402,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[]{};
@@ -570,17 +572,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
@@ -1295,15 +1309,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;
}
/**
@@ -1441,8 +1469,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= "
@@ -1756,10 +1786,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.
@@ -1784,10 +1835,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();
}
}
@@ -1799,10 +1850,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();
}
}

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

@@ -1169,7 +1169,7 @@ public class DisplayModeDirector {
mDefaultRefreshRate =
(displayDeviceConfig == null) ? (float) mContext.getResources().getInteger(
R.integer.config_defaultRefreshRate)
: (float) displayDeviceConfig.getDefaultLowRefreshRate();
: (float) displayDeviceConfig.getDefaultRefreshRate();
}
public void observe() {
@@ -1256,7 +1256,7 @@ public class DisplayModeDirector {
defaultPeakRefreshRate =
(displayDeviceConfig == null) ? (float) mContext.getResources().getInteger(
R.integer.config_defaultPeakRefreshRate)
: (float) displayDeviceConfig.getDefaultHighRefreshRate();
: (float) displayDeviceConfig.getDefaultPeakRefreshRate();
}
mDefaultPeakRefreshRate = defaultPeakRefreshRate;
}
@@ -1612,8 +1612,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(),
@@ -1634,6 +1652,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(
@@ -1686,14 +1742,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
*/
@@ -1739,8 +1787,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();
@@ -1794,6 +1851,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;
@@ -1817,6 +1878,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;
@@ -2664,15 +2729,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;
}
/*
@@ -2694,15 +2754,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() {
@@ -2750,23 +2805,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)
if (refreshRateInLowZone != -1) {
mHandler.obtainMessage(MSG_REFRESH_RATE_IN_LOW_ZONE_CHANGED, refreshRateInLowZone)
.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)
if (refreshRateInHighZone != -1) {
mHandler.obtainMessage(MSG_REFRESH_RATE_IN_HIGH_ZONE_CHANGED, refreshRateInHighZone)
.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

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

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

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

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

@@ -51,6 +51,8 @@ import java.nio.file.Path;
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};
@@ -150,8 +152,10 @@ public final class DisplayDeviceConfigTest {
assertEquals("ProximitySensor123", mDisplayDeviceConfig.getProximitySensor().name);
assertEquals("prox_type_1", mDisplayDeviceConfig.getProximitySensor().type);
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},
@@ -230,8 +234,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(),
@@ -449,6 +457,8 @@ public final class DisplayDeviceConfigTest {
+ "<type>prox_type_1</type>\n"
+ "</proxSensor>\n"
+ "<refreshRate>\n"
+ "<defaultRefreshRate>45</defaultRefreshRate>\n"
+ "<defaultPeakRefreshRate>85</defaultPeakRefreshRate>\n"
+ "<lowerBlockingZoneConfigs>\n"
+ "<defaultRefreshRate>75</defaultRefreshRate>\n"
+ "<blockingZoneThreshold>\n"
@@ -550,10 +560,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))

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

@@ -1869,6 +1869,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))
@@ -1888,6 +1892,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(),
@@ -1899,17 +1905,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(),
@@ -1922,6 +1932,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});
@@ -1929,9 +1941,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(),
@@ -1971,8 +1985,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});