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

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

+16 −67

Original line number	Original line	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 STABLE_ID_SUFFIX_FORMAT = "id_%d";
	private static final String NO_SUFFIX_FORMAT = "%d";		private static final String NO_SUFFIX_FORMAT = "%d";
	private static final long STABLE_FLAG = 1L << 62;		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_LOW_REFRESH_RATE = 60;
	private static final int DEFAULT_HIGH_REFRESH_RATE = 0;		private static final int DEFAULT_HIGH_REFRESH_RATE = 0;
	private static final int[] DEFAULT_BRIGHTNESS_THRESHOLDS = new int[]{};		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		* 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.		* 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		* 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		* 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		* 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		* higher refresh rate modes if an app chooses one by setting preferredDisplayModeId or calling
	* setFrameRate(). We have historically allowed fallback to mDefaultPeakRefreshRate if		* setFrameRate(). We have historically allowed fallback to mDefaultHighRefreshRate if
	* mDefaultRefreshRate is set to 0, but this is not supported anymore.		* mDefaultLowRefreshRate is set to 0, but this is not supported anymore.
	*/		*/
	private int mDefaultRefreshRate = DEFAULT_REFRESH_RATE;		private int mDefaultLowRefreshRate = DEFAULT_LOW_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		* 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		* @return Default peak refresh rate of the associated display
	*/		*/
	public int getDefaultPeakRefreshRate() {		public int getDefaultHighRefreshRate() {
	return mDefaultPeakRefreshRate;		return mDefaultHighRefreshRate;
	}		}

	/**		/**
	* @return Default refresh rate of the associated display		* @return Default refresh rate of the associated display
	*/		*/
	public int getDefaultRefreshRate() {		public int getDefaultLowRefreshRate() {
	return mDefaultRefreshRate;		return mDefaultLowRefreshRate;
	}

	/**
	* @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;
	}		}

	/**		/**
	@@ -1510,10 +1482,8 @@ public class DisplayDeviceConfig {
	+ ", mDdcAutoBrightnessAvailable= " + mDdcAutoBrightnessAvailable		+ ", mDdcAutoBrightnessAvailable= " + mDdcAutoBrightnessAvailable
	+ ", mAutoBrightnessAvailable= " + mAutoBrightnessAvailable		+ ", mAutoBrightnessAvailable= " + mAutoBrightnessAvailable
	+ "\n"		+ "\n"
	+ ", mDefaultLowBlockingZoneRefreshRate= " + mDefaultLowBlockingZoneRefreshRate		+ ", mDefaultRefreshRate= " + mDefaultLowRefreshRate
	+ ", mDefaultHighBlockingZoneRefreshRate= " + mDefaultHighBlockingZoneRefreshRate		+ ", mDefaultPeakRefreshRate= " + mDefaultHighRefreshRate
	+ ", mDefaultPeakRefreshRate= " + mDefaultPeakRefreshRate
	+ ", mDefaultRefreshRate= " + mDefaultRefreshRate
	+ ", mLowDisplayBrightnessThresholds= "		+ ", mLowDisplayBrightnessThresholds= "
	+ Arrays.toString(mLowDisplayBrightnessThresholds)		+ Arrays.toString(mLowDisplayBrightnessThresholds)
	+ ", mLowAmbientBrightnessThresholds= "		+ ", mLowAmbientBrightnessThresholds= "
	@@ -1868,31 +1838,10 @@ public class DisplayDeviceConfig {
	BlockingZoneConfig higherBlockingZoneConfig =		BlockingZoneConfig higherBlockingZoneConfig =
	(refreshRateConfigs == null) ? null		(refreshRateConfigs == null) ? null
	: refreshRateConfigs.getHigherBlockingZoneConfigs();		: refreshRateConfigs.getHigherBlockingZoneConfigs();
	loadPeakDefaultRefreshRate(refreshRateConfigs);
	loadDefaultRefreshRate(refreshRateConfigs);
	loadLowerRefreshRateBlockingZones(lowerBlockingZoneConfig);		loadLowerRefreshRateBlockingZones(lowerBlockingZoneConfig);
	loadHigherRefreshRateBlockingZones(higherBlockingZoneConfig);		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.		* Loads the refresh rate configurations pertaining to the upper blocking zones.
	@@ -1917,10 +1866,10 @@ public class DisplayDeviceConfig {
	private void loadHigherBlockingZoneDefaultRefreshRate(		private void loadHigherBlockingZoneDefaultRefreshRate(
	BlockingZoneConfig upperBlockingZoneConfig) {		BlockingZoneConfig upperBlockingZoneConfig) {
	if (upperBlockingZoneConfig == null) {		if (upperBlockingZoneConfig == null) {
	mDefaultHighBlockingZoneRefreshRate = mContext.getResources().getInteger(		mDefaultHighRefreshRate = mContext.getResources().getInteger(
	com.android.internal.R.integer.config_fixedRefreshRateInHighZone);		com.android.internal.R.integer.config_defaultPeakRefreshRate);
	} else {		} else {
	mDefaultHighBlockingZoneRefreshRate =		mDefaultHighRefreshRate =
	upperBlockingZoneConfig.getDefaultRefreshRate().intValue();		upperBlockingZoneConfig.getDefaultRefreshRate().intValue();
	}		}
	}		}
	@@ -1932,10 +1881,10 @@ public class DisplayDeviceConfig {
	private void loadLowerBlockingZoneDefaultRefreshRate(		private void loadLowerBlockingZoneDefaultRefreshRate(
	BlockingZoneConfig lowerBlockingZoneConfig) {		BlockingZoneConfig lowerBlockingZoneConfig) {
	if (lowerBlockingZoneConfig == null) {		if (lowerBlockingZoneConfig == null) {
	mDefaultLowBlockingZoneRefreshRate = mContext.getResources().getInteger(		mDefaultLowRefreshRate = mContext.getResources().getInteger(
	com.android.internal.R.integer.config_defaultRefreshRateInZone);		com.android.internal.R.integer.config_defaultRefreshRate);
	} else {		} else {
	mDefaultLowBlockingZoneRefreshRate =		mDefaultLowRefreshRate =
	lowerBlockingZoneConfig.getDefaultRefreshRate().intValue();		lowerBlockingZoneConfig.getDefaultRefreshRate().intValue();
	}		}
	}		}

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

+32 −93

Original line number	Original line	Diff line number	Diff line
	@@ -1373,7 +1373,7 @@ public class DisplayModeDirector {
	mDefaultRefreshRate =		mDefaultRefreshRate =
	(displayDeviceConfig == null) ? (float) mContext.getResources().getInteger(		(displayDeviceConfig == null) ? (float) mContext.getResources().getInteger(
	R.integer.config_defaultRefreshRate)		R.integer.config_defaultRefreshRate)
	: (float) displayDeviceConfig.getDefaultRefreshRate();		: (float) displayDeviceConfig.getDefaultLowRefreshRate();
	}		}

	public void observe() {		public void observe() {
	@@ -1460,7 +1460,7 @@ public class DisplayModeDirector {
	defaultPeakRefreshRate =		defaultPeakRefreshRate =
	(displayDeviceConfig == null) ? (float) mContext.getResources().getInteger(		(displayDeviceConfig == null) ? (float) mContext.getResources().getInteger(
	R.integer.config_defaultPeakRefreshRate)		R.integer.config_defaultPeakRefreshRate)
	: (float) displayDeviceConfig.getDefaultPeakRefreshRate();		: (float) displayDeviceConfig.getDefaultHighRefreshRate();
	}		}
	mDefaultPeakRefreshRate = defaultPeakRefreshRate;		mDefaultPeakRefreshRate = defaultPeakRefreshRate;
	}		}
	@@ -1819,26 +1819,8 @@ public class DisplayModeDirector {
	return mHighAmbientBrightnessThresholds;		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,		private void loadLowBrightnessThresholds(DisplayDeviceConfig displayDeviceConfig,
	boolean attemptLoadingFromDeviceConfig) {		boolean attemptLoadingFromDeviceConfig) {
	loadRefreshRateInHighZone(displayDeviceConfig, attemptLoadingFromDeviceConfig);
	loadRefreshRateInLowZone(displayDeviceConfig, attemptLoadingFromDeviceConfig);
	mLowDisplayBrightnessThresholds = loadBrightnessThresholds(		mLowDisplayBrightnessThresholds = loadBrightnessThresholds(
	() -> mDeviceConfigDisplaySettings.getLowDisplayBrightnessThresholds(),		() -> mDeviceConfigDisplaySettings.getLowDisplayBrightnessThresholds(),
	() -> displayDeviceConfig.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,		private void loadHighBrightnessThresholds(DisplayDeviceConfig displayDeviceConfig,
	boolean attemptLoadingFromDeviceConfig) {		boolean attemptLoadingFromDeviceConfig) {
	mHighDisplayBrightnessThresholds = loadBrightnessThresholds(		mHighDisplayBrightnessThresholds = loadBrightnessThresholds(
	@@ -1949,6 +1893,14 @@ public class DisplayModeDirector {
	return brightnessThresholds;		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		* @return the display brightness thresholds for the low brightness zones
	*/		*/
	@@ -1994,17 +1946,8 @@ public class DisplayModeDirector {
	mHighAmbientBrightnessThresholds = highAmbientBrightnessThresholds;		mHighAmbientBrightnessThresholds = highAmbientBrightnessThresholds;
	}		}

	final int refreshRateInLowZone = mDeviceConfigDisplaySettings		mRefreshRateInLowZone = mDeviceConfigDisplaySettings.getRefreshRateInLowZone();
	.getRefreshRateInLowZone();		mRefreshRateInHighZone = mDeviceConfigDisplaySettings.getRefreshRateInHighZone();
	if (refreshRateInLowZone != -1) {
	mRefreshRateInLowZone = refreshRateInLowZone;
	}

	final int refreshRateInHighZone = mDeviceConfigDisplaySettings
	.getRefreshRateInHighZone();
	if (refreshRateInHighZone != -1) {
	mRefreshRateInHighZone = refreshRateInHighZone;
	}

	restartObserver();		restartObserver();
	mDeviceConfigDisplaySettings.startListening();		mDeviceConfigDisplaySettings.startListening();
	@@ -2058,10 +2001,6 @@ public class DisplayModeDirector {
	restartObserver();		restartObserver();
	}		}

	/**
	* Used to reload the lower blocking zone refresh rate in case of changes in the
	* DeviceConfig properties.
	*/
	public void onDeviceConfigRefreshRateInLowZoneChanged(int refreshRate) {		public void onDeviceConfigRefreshRateInLowZoneChanged(int refreshRate) {
	if (refreshRate != mRefreshRateInLowZone) {		if (refreshRate != mRefreshRateInLowZone) {
	mRefreshRateInLowZone = refreshRate;		mRefreshRateInLowZone = refreshRate;
	@@ -2085,10 +2024,6 @@ public class DisplayModeDirector {
	restartObserver();		restartObserver();
	}		}

	/**
	* Used to reload the higher blocking zone refresh rate in case of changes in the
	* DeviceConfig properties.
	*/
	public void onDeviceConfigRefreshRateInHighZoneChanged(int refreshRate) {		public void onDeviceConfigRefreshRateInHighZoneChanged(int refreshRate) {
	if (refreshRate != mRefreshRateInHighZone) {		if (refreshRate != mRefreshRateInHighZone) {
	mRefreshRateInHighZone = refreshRate;		mRefreshRateInHighZone = refreshRate;
	@@ -2939,10 +2874,15 @@ public class DisplayModeDirector {
	}		}

	public int getRefreshRateInLowZone() {		public int getRefreshRateInLowZone() {
	return mDeviceConfig.getInt(		int defaultRefreshRateInZone = mContext.getResources().getInteger(
			R.integer.config_defaultRefreshRateInZone);

			int refreshRate = mDeviceConfig.getInt(
	DeviceConfig.NAMESPACE_DISPLAY_MANAGER,		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() {		public int getRefreshRateInHighZone() {
	return mDeviceConfig.getInt(		int defaultRefreshRateInZone = mContext.getResources().getInteger(
			R.integer.config_fixedRefreshRateInHighZone);

			int refreshRate = mDeviceConfig.getInt(
	DeviceConfig.NAMESPACE_DISPLAY_MANAGER,		DeviceConfig.NAMESPACE_DISPLAY_MANAGER,
	DisplayManager.DeviceConfig.KEY_REFRESH_RATE_IN_HIGH_ZONE,		DisplayManager.DeviceConfig.KEY_REFRESH_RATE_IN_HIGH_ZONE,
	-1);		defaultRefreshRateInZone);

			return refreshRate;
	}		}

	public int getRefreshRateInHbmSunlight() {		public int getRefreshRateInHbmSunlight() {
	@@ -3015,29 +2960,23 @@ public class DisplayModeDirector {

	int[] lowDisplayBrightnessThresholds = getLowDisplayBrightnessThresholds();		int[] lowDisplayBrightnessThresholds = getLowDisplayBrightnessThresholds();
	int[] lowAmbientBrightnessThresholds = getLowAmbientBrightnessThresholds();		int[] lowAmbientBrightnessThresholds = getLowAmbientBrightnessThresholds();
	final int refreshRateInLowZone = getRefreshRateInLowZone();		int refreshRateInLowZone = getRefreshRateInLowZone();

	mHandler.obtainMessage(MSG_LOW_BRIGHTNESS_THRESHOLDS_CHANGED,		mHandler.obtainMessage(MSG_LOW_BRIGHTNESS_THRESHOLDS_CHANGED,
	new Pair<>(lowDisplayBrightnessThresholds, lowAmbientBrightnessThresholds))		new Pair<>(lowDisplayBrightnessThresholds, lowAmbientBrightnessThresholds))
	.sendToTarget();		.sendToTarget();
			mHandler.obtainMessage(MSG_REFRESH_RATE_IN_LOW_ZONE_CHANGED, refreshRateInLowZone, 0)
	if (refreshRateInLowZone != -1) {		.sendToTarget();
	mHandler.obtainMessage(MSG_REFRESH_RATE_IN_LOW_ZONE_CHANGED, refreshRateInLowZone,
	0).sendToTarget();
	}

	int[] highDisplayBrightnessThresholds = getHighDisplayBrightnessThresholds();		int[] highDisplayBrightnessThresholds = getHighDisplayBrightnessThresholds();
	int[] highAmbientBrightnessThresholds = getHighAmbientBrightnessThresholds();		int[] highAmbientBrightnessThresholds = getHighAmbientBrightnessThresholds();
	final int refreshRateInHighZone = getRefreshRateInHighZone();		int refreshRateInHighZone = getRefreshRateInHighZone();

	mHandler.obtainMessage(MSG_HIGH_BRIGHTNESS_THRESHOLDS_CHANGED,		mHandler.obtainMessage(MSG_HIGH_BRIGHTNESS_THRESHOLDS_CHANGED,
	new Pair<>(highDisplayBrightnessThresholds, highAmbientBrightnessThresholds))		new Pair<>(highDisplayBrightnessThresholds, highAmbientBrightnessThresholds))
	.sendToTarget();		.sendToTarget();
			mHandler.obtainMessage(MSG_REFRESH_RATE_IN_HIGH_ZONE_CHANGED, refreshRateInHighZone, 0)
	if (refreshRateInHighZone != -1) {		.sendToTarget();
	mHandler.obtainMessage(MSG_REFRESH_RATE_IN_HIGH_ZONE_CHANGED, refreshRateInHighZone,
	0).sendToTarget();
	}

	final int refreshRateInHbmSunlight = getRefreshRateInHbmSunlight();		final int refreshRateInHbmSunlight = getRefreshRateInHbmSunlight();
	mHandler.obtainMessage(MSG_REFRESH_RATE_IN_HBM_SUNLIGHT_CHANGED,		mHandler.obtainMessage(MSG_REFRESH_RATE_IN_HBM_SUNLIGHT_CHANGED,

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

+0 −8

Original line number	Original line	Diff line number	Diff line
	@@ -472,14 +472,6 @@
	</xs:complexType>		</xs:complexType>

	<xs:complexType name="refreshRateConfigs">		<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"		<xs:element name="lowerBlockingZoneConfigs" type="blockingZoneConfig"
	minOccurs="0" maxOccurs="1">		minOccurs="0" maxOccurs="1">
	<xs:annotation name="final"/>		<xs:annotation name="final"/>

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

+0 −4

Original line number	Original line	Diff line number	Diff line
	@@ -188,12 +188,8 @@ package com.android.server.display.config {

	public class RefreshRateConfigs {		public class RefreshRateConfigs {
	ctor public 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 getHigherBlockingZoneConfigs();
	method public final com.android.server.display.config.BlockingZoneConfig getLowerBlockingZoneConfigs();		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 setHigherBlockingZoneConfigs(com.android.server.display.config.BlockingZoneConfig);
	method public final void setLowerBlockingZoneConfigs(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	Original line	Diff line number	Diff line
	@@ -53,8 +53,6 @@ import java.util.List;
	public final class DisplayDeviceConfigTest {		public final class DisplayDeviceConfigTest {
	private static final int DEFAULT_PEAK_REFRESH_RATE = 75;		private static final int DEFAULT_PEAK_REFRESH_RATE = 75;
	private static final int DEFAULT_REFRESH_RATE = 120;		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_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[] 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};		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},		assertArrayEquals(new float[]{23, 24, 25},
	mDisplayDeviceConfig.getAmbientDarkeningPercentagesIdle(), ZERO_DELTA);		mDisplayDeviceConfig.getAmbientDarkeningPercentagesIdle(), ZERO_DELTA);

	assertEquals(75, mDisplayDeviceConfig.getDefaultLowBlockingZoneRefreshRate());		assertEquals(75, mDisplayDeviceConfig.getDefaultLowRefreshRate());
	assertEquals(90, mDisplayDeviceConfig.getDefaultHighBlockingZoneRefreshRate());		assertEquals(90, mDisplayDeviceConfig.getDefaultHighRefreshRate());
	assertEquals(85, mDisplayDeviceConfig.getDefaultPeakRefreshRate());
	assertEquals(45, mDisplayDeviceConfig.getDefaultRefreshRate());
	assertArrayEquals(new int[]{45, 55},		assertArrayEquals(new int[]{45, 55},
	mDisplayDeviceConfig.getLowDisplayBrightnessThresholds());		mDisplayDeviceConfig.getLowDisplayBrightnessThresholds());
	assertArrayEquals(new int[]{50, 60},		assertArrayEquals(new int[]{50, 60},
	@@ -282,12 +278,8 @@ public final class DisplayDeviceConfigTest {
	mDisplayDeviceConfig.getAmbientDarkeningLevelsIdle(), ZERO_DELTA);		mDisplayDeviceConfig.getAmbientDarkeningLevelsIdle(), ZERO_DELTA);
	assertArrayEquals(new float[]{29, 30, 31},		assertArrayEquals(new float[]{29, 30, 31},
	mDisplayDeviceConfig.getAmbientDarkeningPercentagesIdle(), ZERO_DELTA);		mDisplayDeviceConfig.getAmbientDarkeningPercentagesIdle(), ZERO_DELTA);
	assertEquals(mDisplayDeviceConfig.getDefaultLowBlockingZoneRefreshRate(),		assertEquals(mDisplayDeviceConfig.getDefaultLowRefreshRate(), DEFAULT_REFRESH_RATE);
	DEFAULT_LOW_BLOCKING_ZONE_REFRESH_RATE);		assertEquals(mDisplayDeviceConfig.getDefaultHighRefreshRate(), DEFAULT_PEAK_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(),		assertArrayEquals(mDisplayDeviceConfig.getLowDisplayBrightnessThresholds(),
	LOW_BRIGHTNESS_THRESHOLD_OF_PEAK_REFRESH_RATE);		LOW_BRIGHTNESS_THRESHOLD_OF_PEAK_REFRESH_RATE);
	assertArrayEquals(mDisplayDeviceConfig.getLowAmbientBrightnessThresholds(),		assertArrayEquals(mDisplayDeviceConfig.getLowAmbientBrightnessThresholds(),
	@@ -545,8 +537,6 @@ public final class DisplayDeviceConfigTest {
	+ "</concurrentDisplaysBrightnessThrottlingMap>\n"		+ "</concurrentDisplaysBrightnessThrottlingMap>\n"
	+ "</thermalThrottling>\n"		+ "</thermalThrottling>\n"
	+ "<refreshRate>\n"		+ "<refreshRate>\n"
	+ "<defaultRefreshRate>45</defaultRefreshRate>\n"
	+ "<defaultPeakRefreshRate>85</defaultPeakRefreshRate>\n"
	+ "<lowerBlockingZoneConfigs>\n"		+ "<lowerBlockingZoneConfigs>\n"
	+ "<defaultRefreshRate>75</defaultRefreshRate>\n"		+ "<defaultRefreshRate>75</defaultRefreshRate>\n"
	+ "<blockingZoneThreshold>\n"		+ "<blockingZoneThreshold>\n"
	@@ -652,14 +642,10 @@ public final class DisplayDeviceConfigTest {
	.thenReturn(new int[]{370, 380, 390});		.thenReturn(new int[]{370, 380, 390});

	// Configs related to refresh rates and blocking zones		// 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);		.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);		.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))		when(mResources.getIntArray(R.array.config_brightnessThresholdsOfPeakRefreshRate))
	.thenReturn(LOW_BRIGHTNESS_THRESHOLD_OF_PEAK_REFRESH_RATE);		.thenReturn(LOW_BRIGHTNESS_THRESHOLD_OF_PEAK_REFRESH_RATE);
	when(mResources.getIntArray(R.array.config_ambientThresholdsOfPeakRefreshRate))		when(mResources.getIntArray(R.array.config_ambientThresholdsOfPeakRefreshRate))