Revert "Loading lower and higher blocking zone refresh rates" (abdb5347) · Commits · e / os / android_frameworks_base

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

+16 −67

Original line number	Diff line number	Diff line
		@@ -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();
		}
		}

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

+32 −93

Original line number	Diff line number	Diff line
		@@ -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(
		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, -1);
		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,

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

+0 −8

Original line number	Diff line number	Diff line
		@@ -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"/>

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

+0 −4

Original line number	Diff line number	Diff line
		@@ -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);
		}

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

+6 −20

Original line number	Diff line number	Diff line
		@@ -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))