Extract RefreshRateData from DisplayDeviceConfig
Crete sparate structure for RefreshRateData to simplify adding Low Power / Low Brightness refreshRates configuration.
Moved defaultRR to new structure
Bug: b/335458967
Test: atest DisplayModeDirectorTest, atest DisplayDeviceConfigTest
Change-Id: I28115f1e68cb9590eb5e0a3bfb1cda357f51c15a
diff --git a/services/core/java/com/android/server/display/DisplayDeviceConfig.java b/services/core/java/com/android/server/display/DisplayDeviceConfig.java
index 5c93181..a6335e3 100644
--- a/services/core/java/com/android/server/display/DisplayDeviceConfig.java
+++ b/services/core/java/com/android/server/display/DisplayDeviceConfig.java
@@ -70,6 +70,7 @@
import com.android.server.display.config.PowerThrottlingPoint;
import com.android.server.display.config.PredefinedBrightnessLimitNames;
import com.android.server.display.config.RefreshRateConfigs;
+import com.android.server.display.config.RefreshRateData;
import com.android.server.display.config.RefreshRateRange;
import com.android.server.display.config.RefreshRateThrottlingMap;
import com.android.server.display.config.RefreshRateThrottlingPoint;
@@ -617,9 +618,7 @@
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_REFRESH_RATE_IN_HBM = 0;
+
private static final int DEFAULT_HIGH_REFRESH_RATE = 0;
private static final float[] DEFAULT_BRIGHTNESS_THRESHOLDS = new float[]{};
@@ -754,32 +753,6 @@
private boolean mDdcAutoBrightnessAvailable = true;
/**
- * The default peak refresh rate for a given device. This value prevents the framework from
- * 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;
-
- /**
- * 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.
- */
- private int mDefaultRefreshRate = DEFAULT_REFRESH_RATE;
-
- /**
- * Default refresh rate while the device has high brightness mode enabled for HDR.
- */
- private int mDefaultRefreshRateInHbmHdr = DEFAULT_REFRESH_RATE_IN_HBM;
-
- /**
- * Default refresh rate while the device has high brightness mode enabled for Sunlight.
- */
- private int mDefaultRefreshRateInHbmSunlight = DEFAULT_REFRESH_RATE_IN_HBM;
- /**
* 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.
*/
@@ -867,6 +840,8 @@
@Nullable
public EvenDimmerBrightnessData mEvenDimmerBrightnessData;
+ private RefreshRateData mRefreshRateData = RefreshRateData.DEFAULT_REFRESH_RATE_DATA;
+
/**
* Maximum screen brightness setting when screen brightness capped in Wear Bedtime mode.
*/
@@ -1450,33 +1425,8 @@
return mDisplayBrightnessMapping.getBrightnessArray(mode, preset);
}
- /**
- * @return Default peak refresh rate of the associated display
- */
- public int getDefaultPeakRefreshRate() {
- return mDefaultPeakRefreshRate;
- }
-
- /**
- * @return Default refresh rate of the associated display
- */
- public int getDefaultRefreshRate() {
- return mDefaultRefreshRate;
- }
-
- /**
- * @return Default refresh rate while the device has high brightness mode enabled for HDR.
- */
- public int getDefaultRefreshRateInHbmHdr() {
- return mDefaultRefreshRateInHbmHdr;
- }
-
- /**
- * @return Default refresh rate while the device has high brightness mode enabled because of
- * high lux.
- */
- public int getDefaultRefreshRateInHbmSunlight() {
- return mDefaultRefreshRateInHbmSunlight;
+ public RefreshRateData getRefreshRateData() {
+ return mRefreshRateData;
}
/**
@@ -1687,11 +1637,8 @@
+ "\n"
+ "mDefaultLowBlockingZoneRefreshRate= " + mDefaultLowBlockingZoneRefreshRate
+ ", mDefaultHighBlockingZoneRefreshRate= " + mDefaultHighBlockingZoneRefreshRate
- + ", mDefaultPeakRefreshRate= " + mDefaultPeakRefreshRate
- + ", mDefaultRefreshRate= " + mDefaultRefreshRate
+ + ", mRefreshRateData= " + mRefreshRateData
+ ", mRefreshRateZoneProfiles= " + mRefreshRateZoneProfiles
- + ", mDefaultRefreshRateInHbmHdr= " + mDefaultRefreshRateInHbmHdr
- + ", mDefaultRefreshRateInHbmSunlight= " + mDefaultRefreshRateInHbmSunlight
+ ", mRefreshRateThrottlingMap= " + mRefreshRateThrottlingMap
+ ", mLowBlockingZoneThermalMapId= " + mLowBlockingZoneThermalMapId
+ ", mHighBlockingZoneThermalMapId= " + mHighBlockingZoneThermalMapId
@@ -1782,6 +1729,8 @@
mScreenOffBrightnessSensor = SensorData.loadScreenOffBrightnessSensorConfig(config);
mProximitySensor = SensorData.loadProxSensorConfig(mFlags, config);
mTempSensor = SensorData.loadTempSensorConfig(mFlags, config);
+ mRefreshRateData = RefreshRateData
+ .loadRefreshRateData(config, mContext.getResources());
loadAmbientHorizonFromDdc(config);
loadBrightnessChangeThresholds(config);
loadAutoBrightnessConfigValues(config);
@@ -1812,6 +1761,8 @@
mAmbientLightSensor = SensorData.loadAmbientLightSensorConfig(mContext.getResources());
mProximitySensor = SensorData.loadSensorUnspecifiedConfig();
mTempSensor = SensorData.loadTempSensorUnspecifiedConfig();
+ mRefreshRateData = RefreshRateData
+ .loadRefreshRateData(null, mContext.getResources());
loadBrightnessChangeThresholdsFromXml();
loadAutoBrightnessConfigsFromConfigXml();
loadAutoBrightnessAvailableFromConfigXml();
@@ -2162,33 +2113,13 @@
BlockingZoneConfig higherBlockingZoneConfig =
(refreshRateConfigs == null) ? null
: refreshRateConfigs.getHigherBlockingZoneConfigs();
- loadPeakDefaultRefreshRate(refreshRateConfigs);
- loadDefaultRefreshRate(refreshRateConfigs);
- loadDefaultRefreshRateInHbm(refreshRateConfigs);
loadLowerRefreshRateBlockingZones(lowerBlockingZoneConfig);
loadHigherRefreshRateBlockingZones(higherBlockingZoneConfig);
loadRefreshRateZoneProfiles(refreshRateConfigs);
}
- 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 profiles. */
private void loadRefreshRateZoneProfiles(RefreshRateConfigs refreshRateConfigs) {
@@ -2205,26 +2136,6 @@
}
}
- private void loadDefaultRefreshRateInHbm(RefreshRateConfigs refreshRateConfigs) {
- if (refreshRateConfigs != null
- && refreshRateConfigs.getDefaultRefreshRateInHbmHdr() != null) {
- mDefaultRefreshRateInHbmHdr = refreshRateConfigs.getDefaultRefreshRateInHbmHdr()
- .intValue();
- } else {
- mDefaultRefreshRateInHbmHdr = mContext.getResources().getInteger(
- R.integer.config_defaultRefreshRateInHbmHdr);
- }
-
- if (refreshRateConfigs != null
- && refreshRateConfigs.getDefaultRefreshRateInHbmSunlight() != null) {
- mDefaultRefreshRateInHbmSunlight =
- refreshRateConfigs.getDefaultRefreshRateInHbmSunlight().intValue();
- } else {
- mDefaultRefreshRateInHbmSunlight = mContext.getResources().getInteger(
- R.integer.config_defaultRefreshRateInHbmSunlight);
- }
- }
-
/**
* Loads the refresh rate configurations pertaining to the lower blocking zones.
*/
diff --git a/services/core/java/com/android/server/display/config/RefreshRateData.java b/services/core/java/com/android/server/display/config/RefreshRateData.java
new file mode 100644
index 0000000..b186fd5
--- /dev/null
+++ b/services/core/java/com/android/server/display/config/RefreshRateData.java
@@ -0,0 +1,138 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.server.display.config;
+
+import android.annotation.Nullable;
+import android.content.res.Resources;
+
+import com.android.internal.R;
+
+/**
+ * RefreshRates config for display
+ */
+public class RefreshRateData {
+ public static RefreshRateData DEFAULT_REFRESH_RATE_DATA = loadRefreshRateData(null, null);
+
+ private static final int DEFAULT_REFRESH_RATE = 60;
+ private static final int DEFAULT_PEAK_REFRESH_RATE = 0;
+ private static final int DEFAULT_REFRESH_RATE_IN_HBM = 0;
+
+ /**
+ * 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
+ * defaultRefreshRate is set to 0, but this is not supported anymore.
+ */
+ public final int defaultRefreshRate;
+
+ /**
+ * The default peak refresh rate for a given device. This value prevents the framework from
+ * 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.
+ */
+ public final int defaultPeakRefreshRate;
+
+ /**
+ * Default refresh rate while the device has high brightness mode enabled for HDR.
+ */
+ public final int defaultRefreshRateInHbmHdr;
+
+ /**
+ * Default refresh rate while the device has high brightness mode enabled for Sunlight.
+ */
+ public final int defaultRefreshRateInHbmSunlight;
+
+ public RefreshRateData(int defaultRefreshRate, int defaultPeakRefreshRate,
+ int defaultRefreshRateInHbmHdr, int defaultRefreshRateInHbmSunlight) {
+ this.defaultRefreshRate = defaultRefreshRate;
+ this.defaultPeakRefreshRate = defaultPeakRefreshRate;
+ this.defaultRefreshRateInHbmHdr = defaultRefreshRateInHbmHdr;
+ this.defaultRefreshRateInHbmSunlight = defaultRefreshRateInHbmSunlight;
+ }
+
+
+ @Override
+ public String toString() {
+ return "RefreshRateData {"
+ + "defaultRefreshRate: " + defaultRefreshRate
+ + "defaultPeakRefreshRate: " + defaultPeakRefreshRate
+ + "defaultRefreshRateInHbmHdr: " + defaultRefreshRateInHbmHdr
+ + "defaultRefreshRateInHbmSunlight: " + defaultRefreshRateInHbmSunlight
+ + "} ";
+ }
+
+ /**
+ * Loads RefreshRateData from DisplayConfiguration and Resources
+ */
+ public static RefreshRateData loadRefreshRateData(
+ @Nullable DisplayConfiguration config, @Nullable Resources resources) {
+ RefreshRateConfigs refreshRateConfigs = config == null ? null : config.getRefreshRate();
+
+ int defaultRefreshRate = loadDefaultRefreshRate(refreshRateConfigs, resources);
+ int defaultPeakRefreshRate = loadDefaultPeakRefreshRate(refreshRateConfigs, resources);
+ int defaultRefreshRateInHbmHdr = loadDefaultRefreshRateInHbm(refreshRateConfigs, resources);
+ int defaultRefreshRateInHbmSunlight = loadDefaultRefreshRateInHbmSunlight(
+ refreshRateConfigs, resources);
+
+ return new RefreshRateData(defaultRefreshRate, defaultPeakRefreshRate,
+ defaultRefreshRateInHbmHdr, defaultRefreshRateInHbmSunlight);
+ }
+
+ private static int loadDefaultRefreshRate(
+ @Nullable RefreshRateConfigs refreshRateConfigs, @Nullable Resources resources) {
+ if (refreshRateConfigs != null && refreshRateConfigs.getDefaultRefreshRate() != null) {
+ return refreshRateConfigs.getDefaultRefreshRate().intValue();
+ } else if (resources != null) {
+ return resources.getInteger(R.integer.config_defaultRefreshRate);
+ }
+ return DEFAULT_REFRESH_RATE;
+ }
+
+ private static int loadDefaultPeakRefreshRate(
+ @Nullable RefreshRateConfigs refreshRateConfigs, @Nullable Resources resources) {
+ if (refreshRateConfigs != null && refreshRateConfigs.getDefaultPeakRefreshRate() != null) {
+ return refreshRateConfigs.getDefaultPeakRefreshRate().intValue();
+ } else if (resources != null) {
+ return resources.getInteger(R.integer.config_defaultPeakRefreshRate);
+ }
+ return DEFAULT_PEAK_REFRESH_RATE;
+ }
+
+ private static int loadDefaultRefreshRateInHbm(
+ @Nullable RefreshRateConfigs refreshRateConfigs, @Nullable Resources resources) {
+ if (refreshRateConfigs != null
+ && refreshRateConfigs.getDefaultRefreshRateInHbmHdr() != null) {
+ return refreshRateConfigs.getDefaultRefreshRateInHbmHdr().intValue();
+ } else if (resources != null) {
+ return resources.getInteger(R.integer.config_defaultRefreshRateInHbmHdr);
+ }
+ return DEFAULT_REFRESH_RATE_IN_HBM;
+ }
+
+ private static int loadDefaultRefreshRateInHbmSunlight(
+ @Nullable RefreshRateConfigs refreshRateConfigs, @Nullable Resources resources) {
+ if (refreshRateConfigs != null
+ && refreshRateConfigs.getDefaultRefreshRateInHbmSunlight() != null) {
+ return refreshRateConfigs.getDefaultRefreshRateInHbmSunlight().intValue();
+ } else if (resources != null) {
+ return resources.getInteger(R.integer.config_defaultRefreshRateInHbmSunlight);
+ }
+ return DEFAULT_REFRESH_RATE_IN_HBM;
+ }
+}
diff --git a/services/core/java/com/android/server/display/mode/DisplayModeDirector.java b/services/core/java/com/android/server/display/mode/DisplayModeDirector.java
index fa42316..1c8c8a4 100644
--- a/services/core/java/com/android/server/display/mode/DisplayModeDirector.java
+++ b/services/core/java/com/android/server/display/mode/DisplayModeDirector.java
@@ -77,6 +77,7 @@
import com.android.server.LocalServices;
import com.android.server.display.DisplayDeviceConfig;
import com.android.server.display.config.IdleScreenRefreshRateTimeoutLuxThresholdPoint;
+import com.android.server.display.config.RefreshRateData;
import com.android.server.display.feature.DeviceConfigParameterProvider;
import com.android.server.display.feature.DisplayManagerFlags;
import com.android.server.display.utils.AmbientFilter;
@@ -961,13 +962,15 @@
* This is used to update the refresh rate configs from the DeviceConfig, which
* if missing from DisplayDeviceConfig, and finally fallback to config.xml.
*/
- public void setRefreshRates(DisplayDeviceConfig displayDeviceConfig,
+ void setRefreshRates(DisplayDeviceConfig displayDeviceConfig,
boolean attemptReadFromFeatureParams) {
+ RefreshRateData refreshRateData = displayDeviceConfig == null ? null
+ : displayDeviceConfig.getRefreshRateData();
setDefaultPeakRefreshRate(displayDeviceConfig, attemptReadFromFeatureParams);
mDefaultRefreshRate =
- (displayDeviceConfig == null) ? (float) mContext.getResources().getInteger(
- R.integer.config_defaultRefreshRate)
- : (float) displayDeviceConfig.getDefaultRefreshRate();
+ (refreshRateData == null) ? (float) mContext.getResources().getInteger(
+ R.integer.config_defaultRefreshRate)
+ : (float) refreshRateData.defaultRefreshRate;
}
public void observe() {
@@ -1049,7 +1052,8 @@
defaultPeakRefreshRate =
(displayDeviceConfig == null) ? (float) mContext.getResources().getInteger(
R.integer.config_defaultPeakRefreshRate)
- : (float) displayDeviceConfig.getDefaultPeakRefreshRate();
+ : (float) displayDeviceConfig.getRefreshRateData()
+ .defaultPeakRefreshRate;
}
mDefaultPeakRefreshRate = defaultPeakRefreshRate;
}
@@ -2809,7 +2813,7 @@
private int getRefreshRateInHbmHdr(DisplayDeviceConfig displayDeviceConfig) {
return getRefreshRate(
() -> mConfigParameterProvider.getRefreshRateInHbmHdr(),
- () -> displayDeviceConfig.getDefaultRefreshRateInHbmHdr(),
+ () -> displayDeviceConfig.getRefreshRateData().defaultRefreshRateInHbmHdr,
R.integer.config_defaultRefreshRateInHbmHdr,
displayDeviceConfig
);
@@ -2818,7 +2822,7 @@
private int getRefreshRateInHbmSunlight(DisplayDeviceConfig displayDeviceConfig) {
return getRefreshRate(
() -> mConfigParameterProvider.getRefreshRateInHbmSunlight(),
- () -> displayDeviceConfig.getDefaultRefreshRateInHbmSunlight(),
+ () -> displayDeviceConfig.getRefreshRateData().defaultRefreshRateInHbmSunlight,
R.integer.config_defaultRefreshRateInHbmSunlight,
displayDeviceConfig
);
diff --git a/services/tests/displayservicetests/src/com/android/server/display/DisplayDeviceConfigTest.java b/services/tests/displayservicetests/src/com/android/server/display/DisplayDeviceConfigTest.java
index 0877146..a0a611f 100644
--- a/services/tests/displayservicetests/src/com/android/server/display/DisplayDeviceConfigTest.java
+++ b/services/tests/displayservicetests/src/com/android/server/display/DisplayDeviceConfigTest.java
@@ -57,6 +57,7 @@
import com.android.server.display.config.HdrBrightnessData;
import com.android.server.display.config.HysteresisLevels;
import com.android.server.display.config.IdleScreenRefreshRateTimeoutLuxThresholdPoint;
+import com.android.server.display.config.RefreshRateData;
import com.android.server.display.config.ThermalStatus;
import com.android.server.display.feature.DisplayManagerFlags;
import com.android.server.display.feature.flags.Flags;
@@ -222,17 +223,18 @@
assertArrayEquals(new float[]{0.23f, 0.24f, 0.25f},
ambientIdleHysteresis.getDarkeningThresholdsPercentages(), ZERO_DELTA);
+ RefreshRateData refreshRateData = mDisplayDeviceConfig.getRefreshRateData();
assertEquals(75, mDisplayDeviceConfig.getDefaultLowBlockingZoneRefreshRate());
assertEquals(90, mDisplayDeviceConfig.getDefaultHighBlockingZoneRefreshRate());
- assertEquals(85, mDisplayDeviceConfig.getDefaultPeakRefreshRate());
- assertEquals(45, mDisplayDeviceConfig.getDefaultRefreshRate());
+ assertEquals(85, refreshRateData.defaultPeakRefreshRate);
+ assertEquals(45, refreshRateData.defaultRefreshRate);
assertEquals(2, mDisplayDeviceConfig.getRefreshRangeProfiles().size());
assertEquals(60, mDisplayDeviceConfig.getRefreshRange("test1").min, SMALL_DELTA);
assertEquals(60, mDisplayDeviceConfig.getRefreshRange("test1").max, SMALL_DELTA);
assertEquals(80, mDisplayDeviceConfig.getRefreshRange("test2").min, SMALL_DELTA);
assertEquals(90, mDisplayDeviceConfig.getRefreshRange("test2").max, SMALL_DELTA);
- assertEquals(82, mDisplayDeviceConfig.getDefaultRefreshRateInHbmHdr());
- assertEquals(83, mDisplayDeviceConfig.getDefaultRefreshRateInHbmSunlight());
+ assertEquals(82, refreshRateData.defaultRefreshRateInHbmHdr);
+ assertEquals(83, refreshRateData.defaultRefreshRateInHbmSunlight);
assertNotNull(mDisplayDeviceConfig.getHostUsiVersion());
assertEquals(mDisplayDeviceConfig.getHostUsiVersion().getMajorVersion(), 2);
@@ -697,6 +699,7 @@
HysteresisLevels screenHysteresis = mDisplayDeviceConfig.getScreenBrightnessHysteresis();
HysteresisLevels screenIdleHysteresis =
mDisplayDeviceConfig.getScreenBrightnessIdleHysteresis();
+
// Test thresholds
assertEquals(0, ambientHysteresis.getMinBrightening(), ZERO_DELTA);
assertEquals(0, ambientIdleHysteresis.getMinBrightening(), ZERO_DELTA);
@@ -737,6 +740,8 @@
assertArrayEquals(new float[]{0.37f, 0.38f, 0.39f},
screenIdleHysteresis.getDarkeningThresholdsPercentages(), ZERO_DELTA);
+ RefreshRateData refreshRateData = mDisplayDeviceConfig.getRefreshRateData();
+
assertArrayEquals(new float[]{0, 30, 31},
ambientIdleHysteresis.getBrighteningThresholdLevels(), ZERO_DELTA);
assertArrayEquals(new float[]{0.27f, 0.28f, 0.29f},
@@ -749,13 +754,12 @@
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(refreshRateData.defaultPeakRefreshRate, DEFAULT_PEAK_REFRESH_RATE);
+ assertEquals(refreshRateData.defaultRefreshRate, DEFAULT_REFRESH_RATE);
assertEquals(0, mDisplayDeviceConfig.getRefreshRangeProfiles().size());
- assertEquals(mDisplayDeviceConfig.getDefaultRefreshRateInHbmSunlight(),
+ assertEquals(refreshRateData.defaultRefreshRateInHbmSunlight,
DEFAULT_REFRESH_RATE_IN_HBM_SUNLIGHT);
- assertEquals(mDisplayDeviceConfig.getDefaultRefreshRateInHbmHdr(),
- DEFAULT_REFRESH_RATE_IN_HBM_HDR);
+ assertEquals(refreshRateData.defaultRefreshRateInHbmHdr, DEFAULT_REFRESH_RATE_IN_HBM_HDR);
assertEquals("test_light_sensor", mDisplayDeviceConfig.getAmbientLightSensor().type);
assertEquals("", mDisplayDeviceConfig.getAmbientLightSensor().name);
diff --git a/services/tests/displayservicetests/src/com/android/server/display/mode/DisplayModeDirectorTest.java b/services/tests/displayservicetests/src/com/android/server/display/mode/DisplayModeDirectorTest.java
index 4591d91..a2a4773 100644
--- a/services/tests/displayservicetests/src/com/android/server/display/mode/DisplayModeDirectorTest.java
+++ b/services/tests/displayservicetests/src/com/android/server/display/mode/DisplayModeDirectorTest.java
@@ -94,6 +94,7 @@
import com.android.server.display.DisplayDeviceConfig;
import com.android.server.display.TestUtils;
import com.android.server.display.config.IdleScreenRefreshRateTimeoutLuxThresholdPoint;
+import com.android.server.display.config.RefreshRateData;
import com.android.server.display.feature.DisplayManagerFlags;
import com.android.server.display.mode.DisplayModeDirector.BrightnessObserver;
import com.android.server.display.mode.DisplayModeDirector.DesiredDisplayModeSpecs;
@@ -128,6 +129,12 @@
@SmallTest
@RunWith(JUnitParamsRunner.class)
public class DisplayModeDirectorTest {
+ private static final RefreshRateData EMPTY_REFRESH_RATE_DATA = new RefreshRateData(
+ /* defaultRefreshRate= */ 0,
+ /* defaultPeakRefreshRate= */ 0,
+ /* defaultRefreshRateInHbmHdr= */ 0,
+ /* defaultRefreshRateInHbmSunlight= */ 0);
+
public static Collection<Object[]> getAppRequestedSizeTestCases() {
var appRequestedSizeTestCases = Arrays.asList(new Object[][] {
{/*expectedBaseModeId*/ DEFAULT_MODE_75.getModeId(),
@@ -1545,6 +1552,7 @@
// Set the DisplayDeviceConfig
DisplayDeviceConfig ddcMock = mock(DisplayDeviceConfig.class);
+ when(ddcMock.getRefreshRateData()).thenReturn(EMPTY_REFRESH_RATE_DATA);
when(ddcMock.getDefaultHighBlockingZoneRefreshRate()).thenReturn(90);
when(ddcMock.getHighDisplayBrightnessThresholds()).thenReturn(new float[] { 200 });
when(ddcMock.getHighAmbientBrightnessThresholds()).thenReturn(new float[] { 8000 });
@@ -1625,6 +1633,7 @@
// Set the thresholds for High Zone
DisplayDeviceConfig ddcMock = mock(DisplayDeviceConfig.class);
+ when(ddcMock.getRefreshRateData()).thenReturn(EMPTY_REFRESH_RATE_DATA);
when(ddcMock.getDefaultHighBlockingZoneRefreshRate()).thenReturn(90);
when(ddcMock.getHighDisplayBrightnessThresholds()).thenReturn(new float[] { 200 });
when(ddcMock.getHighAmbientBrightnessThresholds()).thenReturn(new float[] { 8000 });
@@ -1724,6 +1733,7 @@
// Set the thresholds for Low Zone
DisplayDeviceConfig ddcMock = mock(DisplayDeviceConfig.class);
+ when(ddcMock.getRefreshRateData()).thenReturn(EMPTY_REFRESH_RATE_DATA);
when(ddcMock.getDefaultLowBlockingZoneRefreshRate()).thenReturn(90);
when(ddcMock.getHighDisplayBrightnessThresholds()).thenReturn(new float[] { 200 });
when(ddcMock.getHighAmbientBrightnessThresholds()).thenReturn(new float[] { 8000 });
@@ -3367,10 +3377,14 @@
// Notify that the default display is updated, such that DisplayDeviceConfig has new values
DisplayDeviceConfig displayDeviceConfig = mock(DisplayDeviceConfig.class);
+ RefreshRateData refreshRateData = new RefreshRateData(
+ /* defaultRefreshRate= */ 60,
+ /* defaultPeakRefreshRate= */ 65,
+ /* defaultRefreshRateInHbmHdr= */ 65,
+ /* defaultRefreshRateInHbmSunlight= */ 75);
+ when(displayDeviceConfig.getRefreshRateData()).thenReturn(refreshRateData);
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 float[]{0.025f});
when(displayDeviceConfig.getLowAmbientBrightnessThresholds())
@@ -3379,8 +3393,6 @@
.thenReturn(new float[]{0.21f});
when(displayDeviceConfig.getHighAmbientBrightnessThresholds())
.thenReturn(new float[]{2100});
- when(displayDeviceConfig.getDefaultRefreshRateInHbmHdr()).thenReturn(65);
- when(displayDeviceConfig.getDefaultRefreshRateInHbmSunlight()).thenReturn(75);
director.defaultDisplayDeviceUpdated(displayDeviceConfig);
// Verify the new values are from the freshly loaded DisplayDeviceConfig.
@@ -3490,6 +3502,7 @@
any(Handler.class));
DisplayDeviceConfig ddcMock = mock(DisplayDeviceConfig.class);
+ when(ddcMock.getRefreshRateData()).thenReturn(EMPTY_REFRESH_RATE_DATA);
when(ddcMock.getDefaultLowBlockingZoneRefreshRate()).thenReturn(50);
when(ddcMock.getDefaultHighBlockingZoneRefreshRate()).thenReturn(55);
when(ddcMock.getLowDisplayBrightnessThresholds()).thenReturn(new float[]{0.025f});
