Define brightness curve in backlight in DDC (6dbbddc2) · Commits · e / os / android_frameworks_base

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

+17 −6

Original line number	Original line	Diff line number	Diff line
	@@ -121,6 +121,7 @@ public abstract class BrightnessMappingStrategy {

	// Display independent, mode dependent values		// Display independent, mode dependent values
	float[] brightnessLevelsNits;		float[] brightnessLevelsNits;
			float[] brightnessLevels = null;
	float[] luxLevels;		float[] luxLevels;
	if (isForIdleMode) {		if (isForIdleMode) {
	brightnessLevelsNits = getFloatArray(resources.obtainTypedArray(		brightnessLevelsNits = getFloatArray(resources.obtainTypedArray(
	@@ -130,11 +131,21 @@ public abstract class BrightnessMappingStrategy {
	} else {		} else {
	brightnessLevelsNits = displayDeviceConfig.getAutoBrightnessBrighteningLevelsNits();		brightnessLevelsNits = displayDeviceConfig.getAutoBrightnessBrighteningLevelsNits();
	luxLevels = displayDeviceConfig.getAutoBrightnessBrighteningLevelsLux();		luxLevels = displayDeviceConfig.getAutoBrightnessBrighteningLevelsLux();

			brightnessLevels = displayDeviceConfig.getAutoBrightnessBrighteningLevels();
			if (brightnessLevels == null \|\| brightnessLevels.length == 0) {
			// Load the old configuration in the range [0, 255]. The values need to be
			// normalized to the range [0, 1].
			int[] brightnessLevelsInt = resources.getIntArray(
			com.android.internal.R.array.config_autoBrightnessLcdBacklightValues);
			brightnessLevels = new float[brightnessLevelsInt.length];
			for (int i = 0; i < brightnessLevels.length; i++) {
			brightnessLevels[i] = normalizeAbsoluteBrightness(brightnessLevelsInt[i]);
			}
			}
	}		}

	// Display independent, mode independent values		// Display independent, mode independent values
	int[] brightnessLevelsBacklight = resources.getIntArray(
	com.android.internal.R.array.config_autoBrightnessLcdBacklightValues);
	float autoBrightnessAdjustmentMaxGamma = resources.getFraction(		float autoBrightnessAdjustmentMaxGamma = resources.getFraction(
	com.android.internal.R.fraction.config_autoBrightnessAdjustmentMaxGamma,		com.android.internal.R.fraction.config_autoBrightnessAdjustmentMaxGamma,
	1, 1);		1, 1);
	@@ -155,8 +166,8 @@ public abstract class BrightnessMappingStrategy {
	builder.setShortTermModelUpperLuxMultiplier(SHORT_TERM_MODEL_THRESHOLD_RATIO);		builder.setShortTermModelUpperLuxMultiplier(SHORT_TERM_MODEL_THRESHOLD_RATIO);
	return new PhysicalMappingStrategy(builder.build(), nitsRange, brightnessRange,		return new PhysicalMappingStrategy(builder.build(), nitsRange, brightnessRange,
	autoBrightnessAdjustmentMaxGamma, isForIdleMode, displayWhiteBalanceController);		autoBrightnessAdjustmentMaxGamma, isForIdleMode, displayWhiteBalanceController);
	} else if (isValidMapping(luxLevels, brightnessLevelsBacklight) && !isForIdleMode) {		} else if (isValidMapping(luxLevels, brightnessLevels)) {
	return new SimpleMappingStrategy(luxLevels, brightnessLevelsBacklight,		return new SimpleMappingStrategy(luxLevels, brightnessLevels,
	autoBrightnessAdjustmentMaxGamma, shortTermModelTimeout);		autoBrightnessAdjustmentMaxGamma, shortTermModelTimeout);
	} else {		} else {
	return null;		return null;
	@@ -620,7 +631,7 @@ public abstract class BrightnessMappingStrategy {
	private float mUserBrightness;		private float mUserBrightness;
	private long mShortTermModelTimeout;		private long mShortTermModelTimeout;

	private SimpleMappingStrategy(float[] lux, int[] brightness, float maxGamma,		private SimpleMappingStrategy(float[] lux, float[] brightness, float maxGamma,
	long timeout) {		long timeout) {
	Preconditions.checkArgument(lux.length != 0 && brightness.length != 0,		Preconditions.checkArgument(lux.length != 0 && brightness.length != 0,
	"Lux and brightness arrays must not be empty!");		"Lux and brightness arrays must not be empty!");
	@@ -635,7 +646,7 @@ public abstract class BrightnessMappingStrategy {
	mBrightness = new float[N];		mBrightness = new float[N];
	for (int i = 0; i < N; i++) {		for (int i = 0; i < N; i++) {
	mLux[i] = lux[i];		mLux[i] = lux[i];
	mBrightness[i] = normalizeAbsoluteBrightness(brightness[i]);		mBrightness[i] = brightness[i];
	}		}

	mMaxGamma = maxGamma;		mMaxGamma = maxGamma;

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

+10 −2

Original line number	Original line	Diff line number	Diff line
	@@ -20,6 +20,8 @@ import android.content.Context;
	import android.os.Handler;		import android.os.Handler;
	import android.view.Display;		import android.view.Display;

			import com.android.server.display.feature.DisplayManagerFlags;

	import java.io.PrintWriter;		import java.io.PrintWriter;
	import java.util.concurrent.atomic.AtomicInteger;		import java.util.concurrent.atomic.AtomicInteger;

	@@ -39,6 +41,7 @@ abstract class DisplayAdapter {
	private final Handler mHandler;		private final Handler mHandler;
	private final Listener mListener;		private final Listener mListener;
	private final String mName;		private final String mName;
			private final DisplayManagerFlags mFeatureFlags;

	public static final int DISPLAY_DEVICE_EVENT_ADDED = 1;		public static final int DISPLAY_DEVICE_EVENT_ADDED = 1;
	public static final int DISPLAY_DEVICE_EVENT_CHANGED = 2;		public static final int DISPLAY_DEVICE_EVENT_CHANGED = 2;
	@@ -50,13 +53,14 @@ abstract class DisplayAdapter {
	private static final AtomicInteger NEXT_DISPLAY_MODE_ID = new AtomicInteger(1); // 0 = no mode.		private static final AtomicInteger NEXT_DISPLAY_MODE_ID = new AtomicInteger(1); // 0 = no mode.

	// Called with SyncRoot lock held.		// Called with SyncRoot lock held.
	public DisplayAdapter(DisplayManagerService.SyncRoot syncRoot,		DisplayAdapter(DisplayManagerService.SyncRoot syncRoot, Context context, Handler handler,
	Context context, Handler handler, Listener listener, String name) {		Listener listener, String name, DisplayManagerFlags featureFlags) {
	mSyncRoot = syncRoot;		mSyncRoot = syncRoot;
	mContext = context;		mContext = context;
	mHandler = handler;		mHandler = handler;
	mListener = listener;		mListener = listener;
	mName = name;		mName = name;
			mFeatureFlags = featureFlags;
	}		}

	/**		/**
	@@ -88,6 +92,10 @@ abstract class DisplayAdapter {
	return mName;		return mName;
	}		}

			public final DisplayManagerFlags getFeatureFlags() {
			return mFeatureFlags;
			}

	/**		/**
	* Registers the display adapter with the display manager.		* Registers the display adapter with the display manager.
	*		*

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

+2 −1

Original line number	Original line	Diff line number	Diff line
	@@ -400,6 +400,7 @@ abstract class DisplayDevice {
	}		}

	private DisplayDeviceConfig loadDisplayDeviceConfig() {		private DisplayDeviceConfig loadDisplayDeviceConfig() {
	return DisplayDeviceConfig.create(mContext, false);		return DisplayDeviceConfig.create(mContext, /* useConfigXml= */ false,
			mDisplayAdapter.getFeatureFlags());
	}		}
	}		}

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

+82 −56

Original line number	Original line	Diff line number	Diff line
	@@ -57,6 +57,7 @@ import com.android.server.display.config.HdrBrightnessData;
	import com.android.server.display.config.HighBrightnessMode;		import com.android.server.display.config.HighBrightnessMode;
	import com.android.server.display.config.IntegerArray;		import com.android.server.display.config.IntegerArray;
	import com.android.server.display.config.LuxThrottling;		import com.android.server.display.config.LuxThrottling;
			import com.android.server.display.config.LuxToBrightnessMapping;
	import com.android.server.display.config.NitsMap;		import com.android.server.display.config.NitsMap;
	import com.android.server.display.config.NonNegativeFloatToFloatPoint;		import com.android.server.display.config.NonNegativeFloatToFloatPoint;
	import com.android.server.display.config.Point;		import com.android.server.display.config.Point;
	@@ -77,6 +78,7 @@ import com.android.server.display.config.ThermalThrottling;
	import com.android.server.display.config.ThresholdPoint;		import com.android.server.display.config.ThresholdPoint;
	import com.android.server.display.config.UsiVersion;		import com.android.server.display.config.UsiVersion;
	import com.android.server.display.config.XmlParser;		import com.android.server.display.config.XmlParser;
			import com.android.server.display.feature.DisplayManagerFlags;
	import com.android.server.display.utils.DebugUtils;		import com.android.server.display.utils.DebugUtils;

	import org.xmlpull.v1.XmlPullParserException;		import org.xmlpull.v1.XmlPullParserException;
	@@ -310,16 +312,18 @@ import javax.xml.datatype.DatatypeConfigurationException;
	* <darkeningLightDebounceIdleMillis>		* <darkeningLightDebounceIdleMillis>
	* 1000		* 1000
	* </darkeningLightDebounceIdleMillis>		* </darkeningLightDebounceIdleMillis>
	* <displayBrightnessMapping>		* <luxToBrightnessMapping>
	* <displayBrightnessPoint>		* <map>
	* <lux>50</lux>		* <point>
	* <nits>45.32</nits>		* <first>0</first>
	* </displayBrightnessPoint>		* <second>0.2</second>
	* <displayBrightnessPoint>		* </point>
	* <lux>80</lux>		* <point>
	* <nits>75.43</nits>		* <first>80</first>
	* </displayBrightnessPoint>		* <second>0.3</second>
	* </displayBrightnessMapping>		* </point>
			* </map>
			* </luxToBrightnessMapping>
	* </autoBrightness>		* </autoBrightness>
	*		*
	* <screenBrightnessRampFastDecrease>0.01</screenBrightnessRampFastDecrease>		* <screenBrightnessRampFastDecrease>0.01</screenBrightnessRampFastDecrease>
	@@ -630,7 +634,6 @@ public class DisplayDeviceConfig {
	// for the corresponding values above		// for the corresponding values above
	private float[] mBrightness;		private float[] mBrightness;


	/**		/**
	* Array of desired screen brightness in nits corresponding to the lux values		* Array of desired screen brightness in nits corresponding to the lux values
	* in the mBrightnessLevelsLux array. The display brightness is defined as the		* in the mBrightnessLevelsLux array. The display brightness is defined as the
	@@ -640,20 +643,25 @@ public class DisplayDeviceConfig {
	private float[] mBrightnessLevelsNits;		private float[] mBrightnessLevelsNits;

	/**		/**
	* Array of light sensor lux values to define our levels for auto backlight		* Array of desired screen brightness corresponding to the lux values
	* brightness support.		* in the mBrightnessLevelsLux array. The brightness values must be non-negative and
			* non-decreasing. They must be between {@link PowerManager.BRIGHTNESS_MIN} and
			* {@link PowerManager.BRIGHTNESS_MAX}. This must be overridden in platform specific overlays
			*/
			private float[] mBrightnessLevels;

			/**
			* Array of light sensor lux values to define our levels for auto-brightness support.
	*		*
	* The N + 1 entries of this array define N control points defined in mBrightnessLevelsNits,		* The first lux value is always 0.
	* with first value always being 0 lux
	*		*
	* The control points must be strictly increasing. Each control point		* The control points must be strictly increasing. Each control point corresponds to an entry
	* corresponds to an entry in the brightness backlight values arrays.		* in the brightness values arrays. For example, if lux == luxLevels[1] (second element
	* For example, if lux == level[1] (second element of the levels array)		* of the levels array) then the brightness will be determined by brightnessLevels[1] (second
	* then the brightness will be determined by value[0] (first element		* element of the brightness values array).
	* of the brightness values array).
	*		*
	* Spline interpolation is used to determine the auto-brightness		* Spline interpolation is used to determine the auto-brightness values for lux levels between
	* backlight values for lux levels between these control points.		* these control points.
	*/		*/
	private float[] mBrightnessLevelsLux;		private float[] mBrightnessLevelsLux;

	@@ -849,9 +857,12 @@ public class DisplayDeviceConfig {
	*/		*/
	private float mBrightnessCapForWearBedtimeMode;		private float mBrightnessCapForWearBedtimeMode;

			private final DisplayManagerFlags mFlags;

	@VisibleForTesting		@VisibleForTesting
	DisplayDeviceConfig(Context context) {		DisplayDeviceConfig(Context context, DisplayManagerFlags flags) {
	mContext = context;		mContext = context;
			mFlags = flags;
	}		}

	/**		/**
	@@ -867,9 +878,9 @@ public class DisplayDeviceConfig {
	* @return A configuration instance for the specified display.		* @return A configuration instance for the specified display.
	*/		*/
	public static DisplayDeviceConfig create(Context context, long physicalDisplayId,		public static DisplayDeviceConfig create(Context context, long physicalDisplayId,
	boolean isFirstDisplay) {		boolean isFirstDisplay, DisplayManagerFlags flags) {
	final DisplayDeviceConfig config = createWithoutDefaultValues(context, physicalDisplayId,		final DisplayDeviceConfig config = createWithoutDefaultValues(context, physicalDisplayId,
	isFirstDisplay);		isFirstDisplay, flags);

	config.copyUninitializedValuesFromSecondaryConfig(loadDefaultConfigurationXml(context));		config.copyUninitializedValuesFromSecondaryConfig(loadDefaultConfigurationXml(context));
	return config;		return config;
	@@ -884,28 +895,29 @@ public class DisplayDeviceConfig {
	* or the default values.		* or the default values.
	* @return A configuration instance.		* @return A configuration instance.
	*/		*/
	public static DisplayDeviceConfig create(Context context, boolean useConfigXml) {		public static DisplayDeviceConfig create(Context context, boolean useConfigXml,
			DisplayManagerFlags flags) {
	final DisplayDeviceConfig config;		final DisplayDeviceConfig config;
	if (useConfigXml) {		if (useConfigXml) {
	config = getConfigFromGlobalXml(context);		config = getConfigFromGlobalXml(context, flags);
	} else {		} else {
	config = getConfigFromPmValues(context);		config = getConfigFromPmValues(context, flags);
	}		}
	return config;		return config;
	}		}

	private static DisplayDeviceConfig createWithoutDefaultValues(Context context,		private static DisplayDeviceConfig createWithoutDefaultValues(Context context,
	long physicalDisplayId, boolean isFirstDisplay) {		long physicalDisplayId, boolean isFirstDisplay, DisplayManagerFlags flags) {
	DisplayDeviceConfig config;		DisplayDeviceConfig config;

	config = loadConfigFromDirectory(context, Environment.getProductDirectory(),		config = loadConfigFromDirectory(context, Environment.getProductDirectory(),
	physicalDisplayId);		physicalDisplayId, flags);
	if (config != null) {		if (config != null) {
	return config;		return config;
	}		}

	config = loadConfigFromDirectory(context, Environment.getVendorDirectory(),		config = loadConfigFromDirectory(context, Environment.getVendorDirectory(),
	physicalDisplayId);		physicalDisplayId, flags);
	if (config != null) {		if (config != null) {
	return config;		return config;
	}		}
	@@ -913,7 +925,7 @@ public class DisplayDeviceConfig {
	// If no config can be loaded from any ddc xml at all,		// If no config can be loaded from any ddc xml at all,
	// prepare a whole config using the global config.xml.		// prepare a whole config using the global config.xml.
	// Guaranteed not null		// Guaranteed not null
	return create(context, isFirstDisplay);		return create(context, isFirstDisplay, flags);
	}		}

	private static DisplayConfiguration loadDefaultConfigurationXml(Context context) {		private static DisplayConfiguration loadDefaultConfigurationXml(Context context) {
	@@ -966,18 +978,19 @@ public class DisplayDeviceConfig {
	}		}

	private static DisplayDeviceConfig loadConfigFromDirectory(Context context,		private static DisplayDeviceConfig loadConfigFromDirectory(Context context,
	File baseDirectory, long physicalDisplayId) {		File baseDirectory, long physicalDisplayId, DisplayManagerFlags flags) {
	DisplayDeviceConfig config;		DisplayDeviceConfig config;
	// Create config using filename from physical ID (including "stable" bit).		// Create config using filename from physical ID (including "stable" bit).
	config = getConfigFromSuffix(context, baseDirectory, STABLE_ID_SUFFIX_FORMAT,		config = getConfigFromSuffix(context, baseDirectory, STABLE_ID_SUFFIX_FORMAT,
	physicalDisplayId);		physicalDisplayId, flags);
	if (config != null) {		if (config != null) {
	return config;		return config;
	}		}

	// Create config using filename from physical ID (excluding "stable" bit).		// Create config using filename from physical ID (excluding "stable" bit).
	final long withoutStableFlag = physicalDisplayId & ~STABLE_FLAG;		final long withoutStableFlag = physicalDisplayId & ~STABLE_FLAG;
	config = getConfigFromSuffix(context, baseDirectory, NO_SUFFIX_FORMAT, withoutStableFlag);		config = getConfigFromSuffix(context, baseDirectory, NO_SUFFIX_FORMAT, withoutStableFlag,
			flags);
	if (config != null) {		if (config != null) {
	return config;		return config;
	}		}
	@@ -986,7 +999,7 @@ public class DisplayDeviceConfig {
	final DisplayAddress.Physical physicalAddress =		final DisplayAddress.Physical physicalAddress =
	DisplayAddress.fromPhysicalDisplayId(physicalDisplayId);		DisplayAddress.fromPhysicalDisplayId(physicalDisplayId);
	int port = physicalAddress.getPort();		int port = physicalAddress.getPort();
	config = getConfigFromSuffix(context, baseDirectory, PORT_SUFFIX_FORMAT, port);		config = getConfigFromSuffix(context, baseDirectory, PORT_SUFFIX_FORMAT, port, flags);
	return config;		return config;
	}		}

	@@ -1604,6 +1617,13 @@ public class DisplayDeviceConfig {
	return mBrightnessLevelsNits;		return mBrightnessLevelsNits;
	}		}

			/**
			* @return Auto brightness brightening levels
			*/
			public float[] getAutoBrightnessBrighteningLevels() {
			return mBrightnessLevels;
			}

	/**		/**
	* @return Default peak refresh rate of the associated display		* @return Default peak refresh rate of the associated display
	*/		*/
	@@ -1857,6 +1877,7 @@ public class DisplayDeviceConfig {
	+ mAutoBrightnessDarkeningLightDebounceIdle		+ mAutoBrightnessDarkeningLightDebounceIdle
	+ ", mBrightnessLevelsLux= " + Arrays.toString(mBrightnessLevelsLux)		+ ", mBrightnessLevelsLux= " + Arrays.toString(mBrightnessLevelsLux)
	+ ", mBrightnessLevelsNits= " + Arrays.toString(mBrightnessLevelsNits)		+ ", mBrightnessLevelsNits= " + Arrays.toString(mBrightnessLevelsNits)
			+ ", mBrightnessLevels= " + Arrays.toString(mBrightnessLevels)
	+ ", mDdcAutoBrightnessAvailable= " + mDdcAutoBrightnessAvailable		+ ", mDdcAutoBrightnessAvailable= " + mDdcAutoBrightnessAvailable
	+ ", mAutoBrightnessAvailable= " + mAutoBrightnessAvailable		+ ", mAutoBrightnessAvailable= " + mAutoBrightnessAvailable
	+ "\n"		+ "\n"
	@@ -1890,27 +1911,29 @@ public class DisplayDeviceConfig {
	}		}

	private static DisplayDeviceConfig getConfigFromSuffix(Context context, File baseDirectory,		private static DisplayDeviceConfig getConfigFromSuffix(Context context, File baseDirectory,
	String suffixFormat, long idNumber) {		String suffixFormat, long idNumber, DisplayManagerFlags flags) {

	final String suffix = String.format(Locale.ROOT, suffixFormat, idNumber);		final String suffix = String.format(Locale.ROOT, suffixFormat, idNumber);
	final String filename = String.format(Locale.ROOT, CONFIG_FILE_FORMAT, suffix);		final String filename = String.format(Locale.ROOT, CONFIG_FILE_FORMAT, suffix);
	final File filePath = Environment.buildPath(		final File filePath = Environment.buildPath(
	baseDirectory, ETC_DIR, DISPLAY_CONFIG_DIR, filename);		baseDirectory, ETC_DIR, DISPLAY_CONFIG_DIR, filename);
	final DisplayDeviceConfig config = new DisplayDeviceConfig(context);		final DisplayDeviceConfig config = new DisplayDeviceConfig(context, flags);
	if (config.initFromFile(filePath)) {		if (config.initFromFile(filePath)) {
	return config;		return config;
	}		}
	return null;		return null;
	}		}

	private static DisplayDeviceConfig getConfigFromGlobalXml(Context context) {		private static DisplayDeviceConfig getConfigFromGlobalXml(Context context,
	DisplayDeviceConfig config = new DisplayDeviceConfig(context);		DisplayManagerFlags flags) {
			DisplayDeviceConfig config = new DisplayDeviceConfig(context, flags);
	config.initFromGlobalXml();		config.initFromGlobalXml();
	return config;		return config;
	}		}

	private static DisplayDeviceConfig getConfigFromPmValues(Context context) {		private static DisplayDeviceConfig getConfigFromPmValues(Context context,
	DisplayDeviceConfig config = new DisplayDeviceConfig(context);		DisplayManagerFlags flags) {
			DisplayDeviceConfig config = new DisplayDeviceConfig(context, flags);
	config.initFromDefaultValues();		config.initFromDefaultValues();
	return config;		return config;
	}		}
	@@ -2615,8 +2638,23 @@ public class DisplayDeviceConfig {
	* loading the value from the display config, and if not present, falls back to config.xml.		* loading the value from the display config, and if not present, falls back to config.xml.
	*/		*/
	private void loadAutoBrightnessDisplayBrightnessMapping(AutoBrightness autoBrightnessConfig) {		private void loadAutoBrightnessDisplayBrightnessMapping(AutoBrightness autoBrightnessConfig) {
	if (autoBrightnessConfig == null		if (mFlags.areAutoBrightnessModesEnabled() && autoBrightnessConfig != null
	\|\| autoBrightnessConfig.getDisplayBrightnessMapping() == null) {		&& autoBrightnessConfig.getLuxToBrightnessMapping() != null) {
			LuxToBrightnessMapping mapping = autoBrightnessConfig.getLuxToBrightnessMapping();
			final int size = mapping.getMap().getPoint().size();
			mBrightnessLevels = new float[size];
			mBrightnessLevelsLux = new float[size];
			for (int i = 0; i < size; i++) {
			float backlight = mapping.getMap().getPoint().get(i).getSecond().floatValue();
			mBrightnessLevels[i] = mBacklightToBrightnessSpline.interpolate(backlight);
			mBrightnessLevelsLux[i] = mapping.getMap().getPoint().get(i).getFirst()
			.floatValue();
			}
			if (size > 0 && mBrightnessLevelsLux[0] != 0) {
			throw new IllegalArgumentException(
			"The first lux value in the display brightness mapping must be 0");
			}
			} else {
	mBrightnessLevelsNits = getFloatArray(mContext.getResources()		mBrightnessLevelsNits = getFloatArray(mContext.getResources()
	.obtainTypedArray(com.android.internal.R.array		.obtainTypedArray(com.android.internal.R.array
	.config_autoBrightnessDisplayValuesNits), PowerManager		.config_autoBrightnessDisplayValuesNits), PowerManager
	@@ -2624,18 +2662,6 @@ public class DisplayDeviceConfig {
	mBrightnessLevelsLux = getLuxLevels(mContext.getResources()		mBrightnessLevelsLux = getLuxLevels(mContext.getResources()
	.getIntArray(com.android.internal.R.array		.getIntArray(com.android.internal.R.array
	.config_autoBrightnessLevels));		.config_autoBrightnessLevels));
	} else {
	final int size = autoBrightnessConfig.getDisplayBrightnessMapping()
	.getDisplayBrightnessPoint().size();
	mBrightnessLevelsNits = new float[size];
	// The first control point is implicit and always at 0 lux.
	mBrightnessLevelsLux = new float[size + 1];
	for (int i = 0; i < size; i++) {
	mBrightnessLevelsNits[i] = autoBrightnessConfig.getDisplayBrightnessMapping()
	.getDisplayBrightnessPoint().get(i).getNits().floatValue();
	mBrightnessLevelsLux[i + 1] = autoBrightnessConfig.getDisplayBrightnessMapping()
	.getDisplayBrightnessPoint().get(i).getLux().floatValue();
	}
	}		}
	}		}

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

+7 −5

Original line number	Original line	Diff line number	Diff line
	@@ -1853,7 +1853,7 @@ public final class DisplayManagerService extends SystemService {
	// early apps like SetupWizard/Launcher. In particular, SUW is displayed using		// early apps like SetupWizard/Launcher. In particular, SUW is displayed using
	// the virtual display inside VR before any VR-specific apps even run.		// the virtual display inside VR before any VR-specific apps even run.
	mVirtualDisplayAdapter = mInjector.getVirtualDisplayAdapter(mSyncRoot, mContext,		mVirtualDisplayAdapter = mInjector.getVirtualDisplayAdapter(mSyncRoot, mContext,
	mHandler, mDisplayDeviceRepo);		mHandler, mDisplayDeviceRepo, mFlags);
	if (mVirtualDisplayAdapter != null) {		if (mVirtualDisplayAdapter != null) {
	registerDisplayAdapterLocked(mVirtualDisplayAdapter);		registerDisplayAdapterLocked(mVirtualDisplayAdapter);
	}		}
	@@ -1871,7 +1871,7 @@ public final class DisplayManagerService extends SystemService {

	private void registerOverlayDisplayAdapterLocked() {		private void registerOverlayDisplayAdapterLocked() {
	registerDisplayAdapterLocked(new OverlayDisplayAdapter(		registerDisplayAdapterLocked(new OverlayDisplayAdapter(
	mSyncRoot, mContext, mHandler, mDisplayDeviceRepo, mUiHandler));		mSyncRoot, mContext, mHandler, mDisplayDeviceRepo, mUiHandler, mFlags));
	}		}

	private void registerWifiDisplayAdapterLocked() {		private void registerWifiDisplayAdapterLocked() {
	@@ -1880,7 +1880,7 @@ public final class DisplayManagerService extends SystemService {
	\|\| SystemProperties.getInt(FORCE_WIFI_DISPLAY_ENABLE, -1) == 1) {		\|\| SystemProperties.getInt(FORCE_WIFI_DISPLAY_ENABLE, -1) == 1) {
	mWifiDisplayAdapter = new WifiDisplayAdapter(		mWifiDisplayAdapter = new WifiDisplayAdapter(
	mSyncRoot, mContext, mHandler, mDisplayDeviceRepo,		mSyncRoot, mContext, mHandler, mDisplayDeviceRepo,
	mPersistentDataStore);		mPersistentDataStore, mFlags);
	registerDisplayAdapterLocked(mWifiDisplayAdapter);		registerDisplayAdapterLocked(mWifiDisplayAdapter);
	}		}
	}		}
	@@ -3288,8 +3288,10 @@ public final class DisplayManagerService extends SystemService {
	@VisibleForTesting		@VisibleForTesting
	static class Injector {		static class Injector {
	VirtualDisplayAdapter getVirtualDisplayAdapter(SyncRoot syncRoot, Context context,		VirtualDisplayAdapter getVirtualDisplayAdapter(SyncRoot syncRoot, Context context,
	Handler handler, DisplayAdapter.Listener displayAdapterListener) {		Handler handler, DisplayAdapter.Listener displayAdapterListener,
	return new VirtualDisplayAdapter(syncRoot, context, handler, displayAdapterListener);		DisplayManagerFlags flags) {
			return new VirtualDisplayAdapter(syncRoot, context, handler, displayAdapterListener,
			flags);
	}		}

	LocalDisplayAdapter getLocalDisplayAdapter(SyncRoot syncRoot, Context context,		LocalDisplayAdapter getLocalDisplayAdapter(SyncRoot syncRoot, Context context,