diff options
8 files changed, 497 insertions, 288 deletions
diff --git a/services/core/java/com/android/server/display/BrightnessMappingStrategy.java b/services/core/java/com/android/server/display/BrightnessMappingStrategy.java index acd253b38b3d..f2ffd4d3f1d9 100644 --- a/services/core/java/com/android/server/display/BrightnessMappingStrategy.java +++ b/services/core/java/com/android/server/display/BrightnessMappingStrategy.java @@ -35,7 +35,6 @@ import android.util.Slog; import android.util.Spline; import com.android.internal.annotations.VisibleForTesting; -import com.android.internal.display.BrightnessSynchronizer; import com.android.internal.display.BrightnessUtils; import com.android.internal.util.Preconditions; import com.android.server.display.utils.Plog; @@ -97,28 +96,17 @@ public abstract class BrightnessMappingStrategy { float[] brightnessLevels = null; float[] luxLevels = null; switch (mode) { - case AUTO_BRIGHTNESS_MODE_DEFAULT: + case AUTO_BRIGHTNESS_MODE_DEFAULT -> { brightnessLevelsNits = displayDeviceConfig.getAutoBrightnessBrighteningLevelsNits(); 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]); - } - } - break; - case AUTO_BRIGHTNESS_MODE_IDLE: + } + case AUTO_BRIGHTNESS_MODE_IDLE -> { brightnessLevelsNits = getFloatArray(resources.obtainTypedArray( com.android.internal.R.array.config_autoBrightnessDisplayValuesNitsIdle)); luxLevels = getLuxLevels(resources.getIntArray( com.android.internal.R.array.config_autoBrightnessLevelsIdle)); - break; + } } // Display independent, mode independent values @@ -426,11 +414,6 @@ public abstract class BrightnessMappingStrategy { } } - // Normalize entire brightness range to 0 - 1. - protected static float normalizeAbsoluteBrightness(int brightness) { - return BrightnessSynchronizer.brightnessIntToFloat(brightness); - } - private Pair<float[], float[]> insertControlPoint( float[] luxLevels, float[] brightnessLevels, float lux, float brightness) { final int idx = findInsertionPoint(luxLevels, lux); diff --git a/services/core/java/com/android/server/display/DisplayDeviceConfig.java b/services/core/java/com/android/server/display/DisplayDeviceConfig.java index d97127c91fbf..7d22a87065b4 100644 --- a/services/core/java/com/android/server/display/DisplayDeviceConfig.java +++ b/services/core/java/com/android/server/display/DisplayDeviceConfig.java @@ -49,6 +49,7 @@ import com.android.server.display.config.BrightnessThresholds; import com.android.server.display.config.BrightnessThrottlingMap; import com.android.server.display.config.BrightnessThrottlingPoint; import com.android.server.display.config.Density; +import com.android.server.display.config.DisplayBrightnessMappingConfig; import com.android.server.display.config.DisplayBrightnessPoint; import com.android.server.display.config.DisplayConfiguration; import com.android.server.display.config.DisplayQuirks; @@ -57,7 +58,6 @@ import com.android.server.display.config.HdrBrightnessData; import com.android.server.display.config.HighBrightnessMode; import com.android.server.display.config.IntegerArray; 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.NonNegativeFloatToFloatPoint; import com.android.server.display.config.Point; @@ -313,6 +313,21 @@ import javax.xml.datatype.DatatypeConfigurationException; * 1000 * </darkeningLightDebounceIdleMillis> * <luxToBrightnessMapping> + * <mode>default</mode> + * <map> + * <point> + * <first>0</first> + * <second>0.2</second> + * </point> + * <point> + * <first>80</first> + * <second>0.3</second> + * </point> + * </map> + * </luxToBrightnessMapping> + * <luxToBrightnessMapping> + * <mode>doze</mode> + * <setting>dim</setting> * <map> * <point> * <first>0</first> @@ -634,36 +649,8 @@ public class DisplayDeviceConfig { // for the corresponding values above private float[] mBrightness; - /** - * Array of desired screen brightness in nits corresponding to the lux values - * in the mBrightnessLevelsLux array. The display brightness is defined as the - * measured brightness of an all-white image. The brightness values must be non-negative and - * non-decreasing. This must be overridden in platform specific overlays - */ - private float[] mBrightnessLevelsNits; - - /** - * Array of desired screen brightness corresponding to the lux values - * 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 first lux value is always 0. - * - * The control points must be strictly increasing. Each control point corresponds to an entry - * in the brightness values arrays. For example, if lux == luxLevels[1] (second element - * of the levels array) then the brightness will be determined by brightnessLevels[1] (second - * element of the brightness values array). - * - * Spline interpolation is used to determine the auto-brightness values for lux levels between - * these control points. - */ - private float[] mBrightnessLevelsLux; + @Nullable + private DisplayBrightnessMappingConfig mDisplayBrightnessMapping; private float mBacklightMinimum = Float.NaN; private float mBacklightMaximum = Float.NaN; @@ -1604,24 +1591,57 @@ public class DisplayDeviceConfig { } /** - * @return Auto brightness brightening ambient lux levels + * @return The default auto-brightness brightening ambient lux levels */ public float[] getAutoBrightnessBrighteningLevelsLux() { - return mBrightnessLevelsLux; + if (mDisplayBrightnessMapping == null) { + return null; + } + return mDisplayBrightnessMapping.getLuxArray(); + } + + /** + * @param mode The auto-brightness mode + * @param setting The brightness setting + * @return Auto brightness brightening ambient lux levels for the specified mode and setting + */ + public float[] getAutoBrightnessBrighteningLevelsLux(String mode, String setting) { + if (mDisplayBrightnessMapping == null) { + return null; + } + return mDisplayBrightnessMapping.getLuxArray(mode, setting); } /** * @return Auto brightness brightening nits levels */ public float[] getAutoBrightnessBrighteningLevelsNits() { - return mBrightnessLevelsNits; + if (mDisplayBrightnessMapping == null) { + return null; + } + return mDisplayBrightnessMapping.getNitsArray(); } /** - * @return Auto brightness brightening levels + * @return The default auto-brightness brightening levels */ public float[] getAutoBrightnessBrighteningLevels() { - return mBrightnessLevels; + if (mDisplayBrightnessMapping == null) { + return null; + } + return mDisplayBrightnessMapping.getBrightnessArray(); + } + + /** + * @param mode The auto-brightness mode + * @param setting The brightness setting + * @return Auto brightness brightening backlight levels for the specified mode and setting + */ + public float[] getAutoBrightnessBrighteningLevels(String mode, String setting) { + if (mDisplayBrightnessMapping == null) { + return null; + } + return mDisplayBrightnessMapping.getBrightnessArray(mode, setting); } /** @@ -1875,9 +1895,7 @@ public class DisplayDeviceConfig { + mAutoBrightnessBrighteningLightDebounceIdle + ", mAutoBrightnessDarkeningLightDebounceIdle= " + mAutoBrightnessDarkeningLightDebounceIdle - + ", mBrightnessLevelsLux= " + Arrays.toString(mBrightnessLevelsLux) - + ", mBrightnessLevelsNits= " + Arrays.toString(mBrightnessLevelsNits) - + ", mBrightnessLevels= " + Arrays.toString(mBrightnessLevels) + + ", mDisplayBrightnessMapping= " + mDisplayBrightnessMapping + ", mDdcAutoBrightnessAvailable= " + mDdcAutoBrightnessAvailable + ", mAutoBrightnessAvailable= " + mAutoBrightnessAvailable + "\n" @@ -2568,7 +2586,8 @@ public class DisplayDeviceConfig { // Idle must be called after interactive, since we fall back to it if needed. loadAutoBrightnessBrighteningLightDebounceIdle(autoBrightness); loadAutoBrightnessDarkeningLightDebounceIdle(autoBrightness); - loadAutoBrightnessDisplayBrightnessMapping(autoBrightness); + mDisplayBrightnessMapping = new DisplayBrightnessMappingConfig(mContext, mFlags, + autoBrightness, mBacklightToBrightnessSpline); loadEnableAutoBrightness(autoBrightness); } @@ -2633,38 +2652,6 @@ public class DisplayDeviceConfig { } } - /** - * Loads the auto-brightness display brightness mappings. Internally, this takes care of - * loading the value from the display config, and if not present, falls back to config.xml. - */ - private void loadAutoBrightnessDisplayBrightnessMapping(AutoBrightness autoBrightnessConfig) { - if (mFlags.areAutoBrightnessModesEnabled() && autoBrightnessConfig != 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() - .obtainTypedArray(com.android.internal.R.array - .config_autoBrightnessDisplayValuesNits), PowerManager - .BRIGHTNESS_OFF_FLOAT); - mBrightnessLevelsLux = getLuxLevels(mContext.getResources() - .getIntArray(com.android.internal.R.array - .config_autoBrightnessLevels)); - } - } - private void loadAutoBrightnessAvailableFromConfigXml() { mAutoBrightnessAvailable = mContext.getResources().getBoolean( R.bool.config_automatic_brightness_available); @@ -2977,7 +2964,8 @@ public class DisplayDeviceConfig { } private void loadAutoBrightnessConfigsFromConfigXml() { - loadAutoBrightnessDisplayBrightnessMapping(null /*AutoBrightnessConfig*/); + mDisplayBrightnessMapping = new DisplayBrightnessMappingConfig(mContext, mFlags, + /* autoBrightnessConfig= */ null, mBacklightToBrightnessSpline); } private void loadBrightnessChangeThresholdsFromXml() { @@ -3347,7 +3335,12 @@ public class DisplayDeviceConfig { return vals; } - private static float[] getLuxLevels(int[] lux) { + /** + * @param lux The lux array + * @return The lux array with 0 appended at the beginning - the first lux value should always + * be 0 + */ + public static float[] getLuxLevels(int[] lux) { // The first control point is implicit and always at 0 lux. float[] levels = new float[lux.length + 1]; for (int i = 0; i < lux.length; i++) { diff --git a/services/core/java/com/android/server/display/config/DisplayBrightnessMappingConfig.java b/services/core/java/com/android/server/display/config/DisplayBrightnessMappingConfig.java new file mode 100644 index 000000000000..21628503adcf --- /dev/null +++ b/services/core/java/com/android/server/display/config/DisplayBrightnessMappingConfig.java @@ -0,0 +1,217 @@ +/* + * Copyright (C) 2023 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.content.Context; +import android.os.PowerManager; +import android.util.Spline; + +import com.android.internal.display.BrightnessSynchronizer; +import com.android.server.display.DisplayDeviceConfig; +import com.android.server.display.feature.DisplayManagerFlags; + +import java.util.Arrays; +import java.util.HashMap; +import java.util.Map; + +/** + * Provides a mapping between lux and brightness values in order to support auto-brightness. + */ +public class DisplayBrightnessMappingConfig { + + private static final String DEFAULT_BRIGHTNESS_MAPPING_KEY = "default_normal"; + + /** + * Array of desired screen brightness in nits corresponding to the lux values + * in the mBrightnessLevelsLuxMap.get(DEFAULT_ID) array. The display brightness is defined as + * the measured brightness of an all-white image. The brightness values must be non-negative and + * non-decreasing. This must be overridden in platform specific overlays + */ + private float[] mBrightnessLevelsNits; + + /** + * Map of arrays of desired screen brightness corresponding to the lux values + * in mBrightnessLevelsLuxMap, indexed by the auto-brightness mode and the brightness setting. + * The brightness values must be non-negative and non-decreasing. They must be between + * {@link PowerManager.BRIGHTNESS_MIN} and {@link PowerManager.BRIGHTNESS_MAX}. + * + * The keys are a concatenation of the auto-brightness mode and the brightness setting + * separated by an underscore, e.g. default_normal, default_dim, default_bright, doze_normal, + * doze_dim, doze_bright. + */ + private final Map<String, float[]> mBrightnessLevelsMap = new HashMap<>(); + + /** + * Map of arrays of light sensor lux values to define our levels for auto-brightness support, + * indexed by the auto-brightness mode and the brightness setting. + * + * The first lux value in every array is always 0. + * + * The control points must be strictly increasing. Each control point corresponds to an entry + * in the brightness values arrays. For example, if lux == luxLevels[1] (second element + * of the levels array) then the brightness will be determined by brightnessLevels[1] (second + * element of the brightness values array). + * + * Spline interpolation is used to determine the auto-brightness values for lux levels between + * these control points. + * + * The keys are a concatenation of the auto-brightness mode and the brightness setting + * separated by an underscore, e.g. default_normal, default_dim, default_bright, doze_normal, + * doze_dim, doze_bright. + */ + private final Map<String, float[]> mBrightnessLevelsLuxMap = new HashMap<>(); + + /** + * Loads the auto-brightness display brightness mappings. Internally, this takes care of + * loading the value from the display config, and if not present, falls back to config.xml. + */ + public DisplayBrightnessMappingConfig(Context context, DisplayManagerFlags flags, + AutoBrightness autoBrightnessConfig, Spline backlightToBrightnessSpline) { + if (flags.areAutoBrightnessModesEnabled() && autoBrightnessConfig != null + && autoBrightnessConfig.getLuxToBrightnessMapping() != null + && autoBrightnessConfig.getLuxToBrightnessMapping().size() > 0) { + for (LuxToBrightnessMapping mapping + : autoBrightnessConfig.getLuxToBrightnessMapping()) { + final int size = mapping.getMap().getPoint().size(); + float[] brightnessLevels = new float[size]; + float[] brightnessLevelsLux = new float[size]; + for (int i = 0; i < size; i++) { + float backlight = mapping.getMap().getPoint().get(i).getSecond().floatValue(); + brightnessLevels[i] = backlightToBrightnessSpline.interpolate(backlight); + brightnessLevelsLux[i] = mapping.getMap().getPoint().get(i).getFirst() + .floatValue(); + } + if (size == 0) { + throw new IllegalArgumentException( + "A display brightness mapping should not be empty"); + } + if (brightnessLevelsLux[0] != 0) { + throw new IllegalArgumentException( + "The first lux value in the display brightness mapping must be 0"); + } + + String key = (mapping.getMode() == null ? "default" : mapping.getMode()) + "_" + + (mapping.getSetting() == null ? "normal" : mapping.getSetting()); + if (mBrightnessLevelsMap.containsKey(key) + || mBrightnessLevelsLuxMap.containsKey(key)) { + throw new IllegalArgumentException( + "A display brightness mapping with key " + key + " already exists"); + } + mBrightnessLevelsMap.put(key, brightnessLevels); + mBrightnessLevelsLuxMap.put(key, brightnessLevelsLux); + } + } + + if (!mBrightnessLevelsMap.containsKey(DEFAULT_BRIGHTNESS_MAPPING_KEY) + || !mBrightnessLevelsLuxMap.containsKey(DEFAULT_BRIGHTNESS_MAPPING_KEY)) { + mBrightnessLevelsNits = DisplayDeviceConfig.getFloatArray(context.getResources() + .obtainTypedArray(com.android.internal.R.array + .config_autoBrightnessDisplayValuesNits), PowerManager + .BRIGHTNESS_OFF_FLOAT); + + float[] brightnessLevelsLux = DisplayDeviceConfig.getLuxLevels(context.getResources() + .getIntArray(com.android.internal.R.array + .config_autoBrightnessLevels)); + mBrightnessLevelsLuxMap.put(DEFAULT_BRIGHTNESS_MAPPING_KEY, brightnessLevelsLux); + + // Load the old configuration in the range [0, 255]. The values need to be normalized + // to the range [0, 1]. + int[] brightnessLevels = context.getResources().getIntArray( + com.android.internal.R.array.config_autoBrightnessLcdBacklightValues); + mBrightnessLevelsMap.put(DEFAULT_BRIGHTNESS_MAPPING_KEY, + brightnessArrayIntToFloat(brightnessLevels, backlightToBrightnessSpline)); + } + } + + /** + * @return The default auto-brightness brightening ambient lux levels + */ + public float[] getLuxArray() { + return mBrightnessLevelsLuxMap.get(DEFAULT_BRIGHTNESS_MAPPING_KEY); + } + + /** + * @param mode The auto-brightness mode + * @param setting The brightness setting + * @return Auto brightness brightening ambient lux levels for the specified mode and setting + */ + public float[] getLuxArray(String mode, String setting) { + return mBrightnessLevelsLuxMap.get(mode + "_" + setting); + } + + /** + * @return Auto brightness brightening nits levels + */ + public float[] getNitsArray() { + return mBrightnessLevelsNits; + } + + /** + * @return The default auto-brightness brightening levels + */ + public float[] getBrightnessArray() { + return mBrightnessLevelsMap.get(DEFAULT_BRIGHTNESS_MAPPING_KEY); + } + + /** + * @param mode The auto-brightness mode + * @param setting The brightness setting + * @return Auto brightness brightening ambient lux levels for the specified mode and setting + */ + public float[] getBrightnessArray(String mode, String setting) { + return mBrightnessLevelsMap.get(mode + "_" + setting); + } + + @Override + public String toString() { + StringBuilder brightnessLevelsLuxMapString = new StringBuilder("{"); + for (Map.Entry<String, float[]> entry : mBrightnessLevelsLuxMap.entrySet()) { + brightnessLevelsLuxMapString.append(entry.getKey()).append("=").append( + Arrays.toString(entry.getValue())).append(", "); + } + if (brightnessLevelsLuxMapString.length() > 2) { + brightnessLevelsLuxMapString.delete(brightnessLevelsLuxMapString.length() - 2, + brightnessLevelsLuxMapString.length()); + } + brightnessLevelsLuxMapString.append("}"); + + StringBuilder brightnessLevelsMapString = new StringBuilder("{"); + for (Map.Entry<String, float[]> entry : mBrightnessLevelsMap.entrySet()) { + brightnessLevelsMapString.append(entry.getKey()).append("=").append( + Arrays.toString(entry.getValue())).append(", "); + } + if (brightnessLevelsMapString.length() > 2) { + brightnessLevelsMapString.delete(brightnessLevelsMapString.length() - 2, + brightnessLevelsMapString.length()); + } + brightnessLevelsMapString.append("}"); + + return "mBrightnessLevelsNits= " + Arrays.toString(mBrightnessLevelsNits) + + ", mBrightnessLevelsLuxMap= " + brightnessLevelsLuxMapString + + ", mBrightnessLevelsMap= " + brightnessLevelsMapString; + } + + private float[] brightnessArrayIntToFloat(int[] brightnessInt, + Spline backlightToBrightnessSpline) { + float[] brightnessFloat = new float[brightnessInt.length]; + for (int i = 0; i < brightnessInt.length; i++) { + brightnessFloat[i] = backlightToBrightnessSpline.interpolate( + BrightnessSynchronizer.brightnessIntToFloat(brightnessInt[i])); + } + return brightnessFloat; + } +} diff --git a/services/core/xsd/display-device-config/display-device-config.xsd b/services/core/xsd/display-device-config/display-device-config.xsd index c625b1e1eef7..adbd3c9c5096 100644 --- a/services/core/xsd/display-device-config/display-device-config.xsd +++ b/services/core/xsd/display-device-config/display-device-config.xsd @@ -595,7 +595,7 @@ <!-- Sets the brightness mapping of the desired screen brightness to the corresponding lux for the current display --> <xs:element name="luxToBrightnessMapping" type="luxToBrightnessMapping" - minOccurs="0" maxOccurs="1"> + minOccurs="0" maxOccurs="unbounded"> <xs:annotation name="final"/> </xs:element> </xs:sequence> @@ -619,12 +619,20 @@ This is used in place of config_autoBrightnessLevels and config_autoBrightnessLcdBacklightValues defined in the config XML resource. + + On devices that allow users to choose from a set of predefined options in display + auto-brightness settings, multiple mappings for different modes and settings can be defined. + + If no mode is specified, the mapping will be used for the default mode. + If no setting is specified, the mapping will be used for the normal brightness setting. --> <xs:complexType name="luxToBrightnessMapping"> <xs:element name="map" type="nonNegativeFloatToFloatMap"> <xs:annotation name="nonnull"/> <xs:annotation name="final"/> </xs:element> + <xs:element name="mode" type="xs:string" minOccurs="0"/> + <xs:element name="setting" type="xs:string" minOccurs="0"/> </xs:complexType> <!-- Represents a point in the display brightness mapping, representing the lux level from the diff --git a/services/core/xsd/display-device-config/schema/current.txt b/services/core/xsd/display-device-config/schema/current.txt index 8c8c1230f944..98c95edef237 100644 --- a/services/core/xsd/display-device-config/schema/current.txt +++ b/services/core/xsd/display-device-config/schema/current.txt @@ -8,13 +8,12 @@ package com.android.server.display.config { method public final java.math.BigInteger getDarkeningLightDebounceIdleMillis(); method public final java.math.BigInteger getDarkeningLightDebounceMillis(); method public boolean getEnabled(); - method public final com.android.server.display.config.LuxToBrightnessMapping getLuxToBrightnessMapping(); + method public final java.util.List<com.android.server.display.config.LuxToBrightnessMapping> getLuxToBrightnessMapping(); method public final void setBrighteningLightDebounceIdleMillis(java.math.BigInteger); method public final void setBrighteningLightDebounceMillis(java.math.BigInteger); method public final void setDarkeningLightDebounceIdleMillis(java.math.BigInteger); method public final void setDarkeningLightDebounceMillis(java.math.BigInteger); method public void setEnabled(boolean); - method public final void setLuxToBrightnessMapping(com.android.server.display.config.LuxToBrightnessMapping); } public class BlockingZoneConfig { @@ -220,7 +219,11 @@ package com.android.server.display.config { public class LuxToBrightnessMapping { ctor public LuxToBrightnessMapping(); method @NonNull public final com.android.server.display.config.NonNegativeFloatToFloatMap getMap(); + method public String getMode(); + method public String getSetting(); method public final void setMap(@NonNull com.android.server.display.config.NonNegativeFloatToFloatMap); + method public void setMode(String); + method public void setSetting(String); } public class NitsMap { diff --git a/services/tests/displayservicetests/src/com/android/server/display/BrightnessMappingStrategyTest.java b/services/tests/displayservicetests/src/com/android/server/display/BrightnessMappingStrategyTest.java index 189d9bbfe806..c5a1ba1f6758 100644 --- a/services/tests/displayservicetests/src/com/android/server/display/BrightnessMappingStrategyTest.java +++ b/services/tests/displayservicetests/src/com/android/server/display/BrightnessMappingStrategyTest.java @@ -107,20 +107,6 @@ public class BrightnessMappingStrategyTest { 468.5f, }; - private static final int[] DISPLAY_LEVELS_INT = { - 9, - 30, - 45, - 62, - 78, - 96, - 119, - 146, - 178, - 221, - 255 - }; - private static final float[] DISPLAY_LEVELS = { 0.03f, 0.11f, @@ -172,62 +158,23 @@ public class BrightnessMappingStrategyTest { DisplayWhiteBalanceController mMockDwbc; @Test - public void testSimpleStrategyMappingAtControlPoints_IntConfig() { - Resources res = createResources(DISPLAY_LEVELS_INT); - DisplayDeviceConfig ddc = createDdc(); + public void testSimpleStrategyMappingAtControlPoints() { + Resources res = createResources(); + DisplayDeviceConfig ddc = new DdcBuilder().setAutoBrightnessLevels(DISPLAY_LEVELS).build(); BrightnessMappingStrategy simple = BrightnessMappingStrategy.create(res, ddc, - AUTO_BRIGHTNESS_MODE_DEFAULT, - mMockDwbc); - assertNotNull("BrightnessMappingStrategy should not be null", simple); - for (int i = 0; i < LUX_LEVELS.length; i++) { - final float expectedLevel = MathUtils.map(PowerManager.BRIGHTNESS_OFF + 1, - PowerManager.BRIGHTNESS_ON, PowerManager.BRIGHTNESS_MIN, - PowerManager.BRIGHTNESS_MAX, DISPLAY_LEVELS_INT[i]); - assertEquals(expectedLevel, - simple.getBrightness(LUX_LEVELS[i]), 0.0001f /*tolerance*/); - } - } - - @Test - public void testSimpleStrategyMappingBetweenControlPoints_IntConfig() { - Resources res = createResources(DISPLAY_LEVELS_INT); - DisplayDeviceConfig ddc = createDdc(); - BrightnessMappingStrategy simple = BrightnessMappingStrategy.create(res, ddc, - AUTO_BRIGHTNESS_MODE_DEFAULT, - mMockDwbc); - assertNotNull("BrightnessMappingStrategy should not be null", simple); - for (int i = 1; i < LUX_LEVELS.length; i++) { - final float lux = (LUX_LEVELS[i - 1] + LUX_LEVELS[i]) / 2; - final float backlight = simple.getBrightness(lux) * PowerManager.BRIGHTNESS_ON; - assertTrue("Desired brightness should be between adjacent control points.", - backlight > DISPLAY_LEVELS_INT[i - 1] - && backlight < DISPLAY_LEVELS_INT[i]); - } - } - - @Test - public void testSimpleStrategyMappingAtControlPoints_FloatConfig() { - Resources res = createResources(EMPTY_INT_ARRAY); - DisplayDeviceConfig ddc = createDdc(EMPTY_FLOAT_ARRAY, EMPTY_FLOAT_ARRAY, LUX_LEVELS, - EMPTY_FLOAT_ARRAY, DISPLAY_LEVELS); - BrightnessMappingStrategy simple = BrightnessMappingStrategy.create(res, ddc, - AUTO_BRIGHTNESS_MODE_DEFAULT, - mMockDwbc); + AUTO_BRIGHTNESS_MODE_DEFAULT, mMockDwbc); assertNotNull("BrightnessMappingStrategy should not be null", simple); for (int i = 0; i < LUX_LEVELS.length; i++) { - assertEquals(DISPLAY_LEVELS[i], simple.getBrightness(LUX_LEVELS[i]), - /* tolerance= */ 0.0001f); + assertEquals(DISPLAY_LEVELS[i], simple.getBrightness(LUX_LEVELS[i]), TOLERANCE); } } @Test - public void testSimpleStrategyMappingBetweenControlPoints_FloatConfig() { - Resources res = createResources(EMPTY_INT_ARRAY); - DisplayDeviceConfig ddc = createDdc(EMPTY_FLOAT_ARRAY, EMPTY_FLOAT_ARRAY, LUX_LEVELS, - EMPTY_FLOAT_ARRAY, DISPLAY_LEVELS); + public void testSimpleStrategyMappingBetweenControlPoints() { + Resources res = createResources(); + DisplayDeviceConfig ddc = new DdcBuilder().setAutoBrightnessLevels(DISPLAY_LEVELS).build(); BrightnessMappingStrategy simple = BrightnessMappingStrategy.create(res, ddc, - AUTO_BRIGHTNESS_MODE_DEFAULT, - mMockDwbc); + AUTO_BRIGHTNESS_MODE_DEFAULT, mMockDwbc); assertNotNull("BrightnessMappingStrategy should not be null", simple); for (int i = 1; i < LUX_LEVELS.length; i++) { final float lux = (LUX_LEVELS[i - 1] + LUX_LEVELS[i]) / 2; @@ -239,8 +186,8 @@ public class BrightnessMappingStrategyTest { @Test public void testSimpleStrategyIgnoresNewConfiguration() { - Resources res = createResources(DISPLAY_LEVELS_INT); - DisplayDeviceConfig ddc = createDdc(); + Resources res = createResources(); + DisplayDeviceConfig ddc = new DdcBuilder().setAutoBrightnessLevels(DISPLAY_LEVELS).build(); BrightnessMappingStrategy strategy = BrightnessMappingStrategy.create(res, ddc, AUTO_BRIGHTNESS_MODE_DEFAULT, mMockDwbc); @@ -255,25 +202,23 @@ public class BrightnessMappingStrategyTest { @Test public void testSimpleStrategyIgnoresNullConfiguration() { - Resources res = createResources(DISPLAY_LEVELS_INT); - DisplayDeviceConfig ddc = createDdc(); + Resources res = createResources(); + DisplayDeviceConfig ddc = new DdcBuilder().setAutoBrightnessLevels(DISPLAY_LEVELS).build(); BrightnessMappingStrategy strategy = BrightnessMappingStrategy.create(res, ddc, AUTO_BRIGHTNESS_MODE_DEFAULT, mMockDwbc); strategy.setBrightnessConfiguration(null); - final int n = DISPLAY_LEVELS_INT.length; - final float expectedBrightness = - (float) DISPLAY_LEVELS_INT[n - 1] / PowerManager.BRIGHTNESS_ON; + final int n = DISPLAY_LEVELS.length; + final float expectedBrightness = DISPLAY_LEVELS[n - 1]; assertEquals(expectedBrightness, strategy.getBrightness(LUX_LEVELS[n - 1]), 0.0001f /*tolerance*/); } @Test public void testPhysicalStrategyMappingAtControlPoints() { - Resources res = createResources(EMPTY_INT_ARRAY); - DisplayDeviceConfig ddc = createDdc(DISPLAY_RANGE_NITS, - DISPLAY_LEVELS_RANGE_BACKLIGHT_FLOAT, - LUX_LEVELS, DISPLAY_LEVELS_NITS); + Resources res = createResources(); + DisplayDeviceConfig ddc = new DdcBuilder().setAutoBrightnessLevelsNits(DISPLAY_LEVELS_NITS) + .build(); BrightnessMappingStrategy physical = BrightnessMappingStrategy.create(res, ddc, AUTO_BRIGHTNESS_MODE_DEFAULT, mMockDwbc); assertNotNull("BrightnessMappingStrategy should not be null", physical); @@ -290,9 +235,9 @@ public class BrightnessMappingStrategyTest { @Test public void testPhysicalStrategyMappingBetweenControlPoints() { - Resources res = createResources(EMPTY_INT_ARRAY); - DisplayDeviceConfig ddc = createDdc(DISPLAY_RANGE_NITS, BACKLIGHT_RANGE_ZERO_TO_ONE, - LUX_LEVELS, DISPLAY_LEVELS_NITS); + Resources res = createResources(); + DisplayDeviceConfig ddc = new DdcBuilder().setBrightnessRange(BACKLIGHT_RANGE_ZERO_TO_ONE) + .setAutoBrightnessLevelsNits(DISPLAY_LEVELS_NITS).build(); BrightnessMappingStrategy physical = BrightnessMappingStrategy.create(res, ddc, AUTO_BRIGHTNESS_MODE_DEFAULT, mMockDwbc); assertNotNull("BrightnessMappingStrategy should not be null", physical); @@ -309,9 +254,9 @@ public class BrightnessMappingStrategyTest { @Test public void testPhysicalStrategyUsesNewConfigurations() { - Resources res = createResources(EMPTY_INT_ARRAY); - DisplayDeviceConfig ddc = createDdc(DISPLAY_RANGE_NITS, - DISPLAY_LEVELS_RANGE_BACKLIGHT_FLOAT, LUX_LEVELS, DISPLAY_LEVELS_NITS); + Resources res = createResources(); + DisplayDeviceConfig ddc = new DdcBuilder().setAutoBrightnessLevelsNits(DISPLAY_LEVELS_NITS) + .build(); BrightnessMappingStrategy strategy = BrightnessMappingStrategy.create(res, ddc, AUTO_BRIGHTNESS_MODE_DEFAULT, mMockDwbc); @@ -336,9 +281,9 @@ public class BrightnessMappingStrategyTest { @Test public void testPhysicalStrategyRecalculateSplines() { - Resources res = createResources(EMPTY_INT_ARRAY); - DisplayDeviceConfig ddc = createDdc(DISPLAY_RANGE_NITS, - DISPLAY_LEVELS_RANGE_BACKLIGHT_FLOAT, LUX_LEVELS, DISPLAY_LEVELS_NITS); + Resources res = createResources(); + DisplayDeviceConfig ddc = new DdcBuilder().setAutoBrightnessLevelsNits(DISPLAY_LEVELS_NITS) + .build(); BrightnessMappingStrategy strategy = BrightnessMappingStrategy.create(res, ddc, AUTO_BRIGHTNESS_MODE_DEFAULT, mMockDwbc); float[] adjustedNits50p = new float[DISPLAY_RANGE_NITS.length]; @@ -381,9 +326,10 @@ public class BrightnessMappingStrategyTest { @Test public void testDefaultStrategyIsPhysical() { - Resources res = createResources(DISPLAY_LEVELS_INT); - DisplayDeviceConfig ddc = createDdc(DISPLAY_RANGE_NITS, - DISPLAY_LEVELS_RANGE_BACKLIGHT_FLOAT, LUX_LEVELS, DISPLAY_LEVELS_NITS); + Resources res = createResources(); + DisplayDeviceConfig ddc = new DdcBuilder().setAutoBrightnessLevels(DISPLAY_LEVELS) + .setAutoBrightnessLevelsNits(DISPLAY_LEVELS_NITS) + .build(); BrightnessMappingStrategy strategy = BrightnessMappingStrategy.create(res, ddc, AUTO_BRIGHTNESS_MODE_DEFAULT, mMockDwbc); assertTrue(strategy instanceof BrightnessMappingStrategy.PhysicalMappingStrategy); @@ -396,17 +342,17 @@ public class BrightnessMappingStrategyTest { float tmp = lux[idx]; lux[idx] = lux[idx + 1]; lux[idx + 1] = tmp; - Resources res = createResources(EMPTY_INT_ARRAY); - DisplayDeviceConfig ddc = createDdc(DISPLAY_RANGE_NITS, - DISPLAY_LEVELS_RANGE_BACKLIGHT_FLOAT, lux, DISPLAY_LEVELS_NITS); + Resources res = createResources(); + DisplayDeviceConfig ddc = new DdcBuilder().setAutoBrightnessLevelsLux(lux) + .setAutoBrightnessLevelsNits(DISPLAY_LEVELS_NITS).build(); BrightnessMappingStrategy strategy = BrightnessMappingStrategy.create(res, ddc, AUTO_BRIGHTNESS_MODE_DEFAULT, mMockDwbc); assertNull(strategy); // And make sure we get the same result even if it's monotone but not increasing. lux[idx] = lux[idx + 1]; - ddc = createDdc(DISPLAY_RANGE_NITS, DISPLAY_LEVELS_RANGE_BACKLIGHT_FLOAT, lux, - DISPLAY_LEVELS_NITS); + ddc = new DdcBuilder().setAutoBrightnessLevelsLux(lux) + .setAutoBrightnessLevelsNits(DISPLAY_LEVELS_NITS).build(); strategy = BrightnessMappingStrategy.create(res, ddc, AUTO_BRIGHTNESS_MODE_DEFAULT, mMockDwbc); assertNull(strategy); @@ -419,25 +365,25 @@ public class BrightnessMappingStrategyTest { // Make sure it's strictly increasing so that the only failure is the differing array // lengths lux[lux.length - 1] = lux[lux.length - 2] + 1; - Resources res = createResources(EMPTY_INT_ARRAY); - DisplayDeviceConfig ddc = createDdc(DISPLAY_RANGE_NITS, - DISPLAY_LEVELS_RANGE_BACKLIGHT_FLOAT, lux, DISPLAY_LEVELS_NITS); + Resources res = createResources(); + DisplayDeviceConfig ddc = new DdcBuilder().setAutoBrightnessLevelsLux(lux) + .setAutoBrightnessLevelsNits(DISPLAY_LEVELS_NITS).build(); BrightnessMappingStrategy strategy = BrightnessMappingStrategy.create(res, ddc, AUTO_BRIGHTNESS_MODE_DEFAULT, mMockDwbc); assertNull(strategy); - res = createResources(DISPLAY_LEVELS_INT); + ddc = new DdcBuilder().setAutoBrightnessLevelsLux(lux) + .setAutoBrightnessLevelsNits(DISPLAY_LEVELS_NITS) + .setAutoBrightnessLevels(DISPLAY_LEVELS).build(); strategy = BrightnessMappingStrategy.create(res, ddc, AUTO_BRIGHTNESS_MODE_DEFAULT, mMockDwbc); assertNull(strategy); // Extra backlight level - final int[] backlight = Arrays.copyOf( - DISPLAY_LEVELS_INT, DISPLAY_LEVELS_INT.length + 1); + final float[] backlight = Arrays.copyOf(DISPLAY_LEVELS, DISPLAY_LEVELS.length + 1); backlight[backlight.length - 1] = backlight[backlight.length - 2] + 1; - res = createResources(backlight); - ddc = createDdc(DISPLAY_RANGE_NITS, - DISPLAY_LEVELS_RANGE_BACKLIGHT_FLOAT, LUX_LEVELS, EMPTY_FLOAT_ARRAY); + res = createResources(); + ddc = new DdcBuilder().setAutoBrightnessLevels(backlight).build(); strategy = BrightnessMappingStrategy.create(res, ddc, AUTO_BRIGHTNESS_MODE_DEFAULT, mMockDwbc); assertNull(strategy); @@ -445,9 +391,9 @@ public class BrightnessMappingStrategyTest { // Extra nits level final float[] nits = Arrays.copyOf(DISPLAY_RANGE_NITS, DISPLAY_LEVELS_NITS.length + 1); nits[nits.length - 1] = nits[nits.length - 2] + 1; - res = createResources(EMPTY_INT_ARRAY); - ddc = createDdc(DISPLAY_RANGE_NITS, - DISPLAY_LEVELS_RANGE_BACKLIGHT_FLOAT, LUX_LEVELS, nits); + res = createResources(); + ddc = new DdcBuilder().setAutoBrightnessLevelsNits(nits) + .setAutoBrightnessLevels(EMPTY_FLOAT_ARRAY).build(); strategy = BrightnessMappingStrategy.create(res, ddc, AUTO_BRIGHTNESS_MODE_DEFAULT, mMockDwbc); assertNull(strategy); @@ -455,40 +401,32 @@ public class BrightnessMappingStrategyTest { @Test public void testPhysicalStrategyRequiresNitsMapping() { - Resources res = createResources(EMPTY_INT_ARRAY /*brightnessLevelsBacklight*/); - DisplayDeviceConfig ddc = createDdc(EMPTY_FLOAT_ARRAY /*nitsRange*/); + Resources res = createResources(); + DisplayDeviceConfig ddc = new DdcBuilder().setNitsRange(EMPTY_FLOAT_ARRAY).build(); BrightnessMappingStrategy physical = BrightnessMappingStrategy.create(res, ddc, AUTO_BRIGHTNESS_MODE_DEFAULT, mMockDwbc); assertNull(physical); - - res = createResources(EMPTY_INT_ARRAY /*brightnessLevelsBacklight*/); - physical = BrightnessMappingStrategy.create(res, ddc, AUTO_BRIGHTNESS_MODE_DEFAULT, - mMockDwbc); - assertNull(physical); - - res = createResources(EMPTY_INT_ARRAY /*brightnessLevelsBacklight*/); - physical = BrightnessMappingStrategy.create(res, ddc, AUTO_BRIGHTNESS_MODE_DEFAULT, - mMockDwbc); - assertNull(physical); } @Test public void testStrategiesAdaptToUserDataPoint() { - Resources res = createResources(EMPTY_INT_ARRAY /*brightnessLevelsBacklight*/); - DisplayDeviceConfig ddc = createDdc(DISPLAY_RANGE_NITS, BACKLIGHT_RANGE_ZERO_TO_ONE, - LUX_LEVELS, DISPLAY_LEVELS_NITS); + Resources res = createResources(); + DisplayDeviceConfig ddc = new DdcBuilder().setBrightnessRange(BACKLIGHT_RANGE_ZERO_TO_ONE) + .setAutoBrightnessLevelsNits(DISPLAY_LEVELS_NITS).build(); assertStrategyAdaptsToUserDataPoints(BrightnessMappingStrategy.create(res, ddc, AUTO_BRIGHTNESS_MODE_DEFAULT, mMockDwbc)); - ddc = createDdc(DISPLAY_RANGE_NITS, BACKLIGHT_RANGE_ZERO_TO_ONE); - res = createResources(DISPLAY_LEVELS_INT); + ddc = new DdcBuilder().setBrightnessRange(BACKLIGHT_RANGE_ZERO_TO_ONE) + .setAutoBrightnessLevels(DISPLAY_LEVELS).build(); + res = createResources(); assertStrategyAdaptsToUserDataPoints(BrightnessMappingStrategy.create(res, ddc, AUTO_BRIGHTNESS_MODE_DEFAULT, mMockDwbc)); } @Test public void testIdleModeConfigLoadsCorrectly() { - Resources res = createResourcesIdle(LUX_LEVELS_IDLE, DISPLAY_LEVELS_NITS_IDLE); - DisplayDeviceConfig ddc = createDdc(DISPLAY_RANGE_NITS, BACKLIGHT_RANGE_ZERO_TO_ONE); + Resources res = createResources(LUX_LEVELS_IDLE, DISPLAY_LEVELS_NITS_IDLE); + DisplayDeviceConfig ddc = new DdcBuilder().setBrightnessRange(BACKLIGHT_RANGE_ZERO_TO_ONE) + .build(); // Create an idle mode bms // This will fail if it tries to fetch the wrong configuration. @@ -562,17 +500,11 @@ public class BrightnessMappingStrategyTest { assertEquals(minBrightness, strategy.getBrightness(LUX_LEVELS[0]), 0.0001f /*tolerance*/); } - private Resources createResources(int[] brightnessLevelsBacklight) { - return createResources(brightnessLevelsBacklight, EMPTY_INT_ARRAY, EMPTY_FLOAT_ARRAY); - } - - private Resources createResourcesIdle(int[] luxLevelsIdle, float[] brightnessLevelsNitsIdle) { - return createResources(EMPTY_INT_ARRAY, - luxLevelsIdle, brightnessLevelsNitsIdle); + private Resources createResources() { + return createResources(EMPTY_INT_ARRAY, EMPTY_FLOAT_ARRAY); } - private Resources createResources(int[] brightnessLevelsBacklight, int[] luxLevelsIdle, - float[] brightnessLevelsNitsIdle) { + private Resources createResources(int[] luxLevelsIdle, float[] brightnessLevelsNitsIdle) { Resources mockResources = mock(Resources.class); if (luxLevelsIdle.length > 0) { @@ -583,10 +515,6 @@ public class BrightnessMappingStrategyTest { .thenReturn(luxLevelsIdleResource); } - when(mockResources.getIntArray( - com.android.internal.R.array.config_autoBrightnessLcdBacklightValues)) - .thenReturn(brightnessLevelsBacklight); - TypedArray mockBrightnessLevelNitsIdle = createFloatTypedArray(brightnessLevelsNitsIdle); when(mockResources.obtainTypedArray( com.android.internal.R.array.config_autoBrightnessDisplayValuesNitsIdle)) @@ -604,41 +532,6 @@ public class BrightnessMappingStrategyTest { return mockResources; } - private DisplayDeviceConfig createDdc() { - return createDdc(DISPLAY_RANGE_NITS); - } - - private DisplayDeviceConfig createDdc(float[] nitsArray) { - return createDdc(nitsArray, DISPLAY_LEVELS_RANGE_BACKLIGHT_FLOAT); - } - - private DisplayDeviceConfig createDdc(float[] nitsArray, float[] backlightArray) { - DisplayDeviceConfig mockDdc = mock(DisplayDeviceConfig.class); - when(mockDdc.getNits()).thenReturn(nitsArray); - when(mockDdc.getBrightness()).thenReturn(backlightArray); - when(mockDdc.getAutoBrightnessBrighteningLevelsLux()).thenReturn(LUX_LEVELS); - when(mockDdc.getAutoBrightnessBrighteningLevelsNits()).thenReturn(EMPTY_FLOAT_ARRAY); - when(mockDdc.getAutoBrightnessBrighteningLevels()).thenReturn(EMPTY_FLOAT_ARRAY); - return mockDdc; - } - - private DisplayDeviceConfig createDdc(float[] nitsArray, float[] backlightArray, - float[] luxLevelsFloat, float[] brightnessLevelsNits) { - return createDdc(nitsArray, backlightArray, luxLevelsFloat, brightnessLevelsNits, - EMPTY_FLOAT_ARRAY); - } - - private DisplayDeviceConfig createDdc(float[] nitsArray, float[] backlightArray, - float[] luxLevelsFloat, float[] brightnessLevelsNits, float[] brightnessLevels) { - DisplayDeviceConfig mockDdc = mock(DisplayDeviceConfig.class); - when(mockDdc.getNits()).thenReturn(nitsArray); - when(mockDdc.getBrightness()).thenReturn(backlightArray); - when(mockDdc.getAutoBrightnessBrighteningLevelsLux()).thenReturn(luxLevelsFloat); - when(mockDdc.getAutoBrightnessBrighteningLevelsNits()).thenReturn(brightnessLevelsNits); - when(mockDdc.getAutoBrightnessBrighteningLevels()).thenReturn(brightnessLevels); - return mockDdc; - } - private TypedArray createFloatTypedArray(float[] vals) { TypedArray mockArray = mock(TypedArray.class); when(mockArray.length()).thenAnswer(invocation -> { @@ -677,10 +570,9 @@ public class BrightnessMappingStrategyTest { final float y2 = GAMMA_CORRECTION_SPLINE.interpolate(x2); final float y3 = GAMMA_CORRECTION_SPLINE.interpolate(x3); - Resources resources = createResources(EMPTY_INT_ARRAY); - DisplayDeviceConfig ddc = createDdc(DISPLAY_RANGE_NITS, - DISPLAY_LEVELS_RANGE_BACKLIGHT_FLOAT, GAMMA_CORRECTION_LUX, - GAMMA_CORRECTION_NITS); + Resources resources = createResources(); + DisplayDeviceConfig ddc = new DdcBuilder().setAutoBrightnessLevelsLux(GAMMA_CORRECTION_LUX) + .setAutoBrightnessLevelsNits(GAMMA_CORRECTION_NITS).build(); BrightnessMappingStrategy strategy = BrightnessMappingStrategy.create(resources, ddc, AUTO_BRIGHTNESS_MODE_DEFAULT, mMockDwbc); // Let's start with a validity check: @@ -708,10 +600,9 @@ public class BrightnessMappingStrategyTest { final float y1 = GAMMA_CORRECTION_SPLINE.interpolate(x1); final float y2 = GAMMA_CORRECTION_SPLINE.interpolate(x2); final float y3 = GAMMA_CORRECTION_SPLINE.interpolate(x3); - Resources resources = createResources(EMPTY_INT_ARRAY); - DisplayDeviceConfig ddc = createDdc(DISPLAY_RANGE_NITS, - DISPLAY_LEVELS_RANGE_BACKLIGHT_FLOAT, GAMMA_CORRECTION_LUX, - GAMMA_CORRECTION_NITS); + Resources resources = createResources(); + DisplayDeviceConfig ddc = new DdcBuilder().setAutoBrightnessLevelsLux(GAMMA_CORRECTION_LUX) + .setAutoBrightnessLevelsNits(GAMMA_CORRECTION_NITS).build(); BrightnessMappingStrategy strategy = BrightnessMappingStrategy.create(resources, ddc, AUTO_BRIGHTNESS_MODE_DEFAULT, mMockDwbc); // Validity check: @@ -736,10 +627,9 @@ public class BrightnessMappingStrategyTest { public void testGammaCorrectionExtremeChangeAtCenter() { // Extreme changes (e.g. setting brightness to 0.0 or 1.0) can't be gamma corrected, so we // just make sure the adjustment reflects the change. - Resources resources = createResources(EMPTY_INT_ARRAY); - DisplayDeviceConfig ddc = createDdc(DISPLAY_RANGE_NITS, - DISPLAY_LEVELS_RANGE_BACKLIGHT_FLOAT, GAMMA_CORRECTION_LUX, - GAMMA_CORRECTION_NITS); + Resources resources = createResources(); + DisplayDeviceConfig ddc = new DdcBuilder().setAutoBrightnessLevelsLux(GAMMA_CORRECTION_LUX) + .setAutoBrightnessLevelsNits(GAMMA_CORRECTION_NITS).build(); BrightnessMappingStrategy strategy = BrightnessMappingStrategy.create(resources, ddc, AUTO_BRIGHTNESS_MODE_DEFAULT, mMockDwbc); assertEquals(0.0f, strategy.getAutoBrightnessAdjustment(), /* delta= */ 0.0001f); @@ -760,10 +650,9 @@ public class BrightnessMappingStrategyTest { final float y0 = GAMMA_CORRECTION_SPLINE.interpolate(x0); final float y2 = GAMMA_CORRECTION_SPLINE.interpolate(x2); final float y4 = GAMMA_CORRECTION_SPLINE.interpolate(x4); - Resources resources = createResources(EMPTY_INT_ARRAY); - DisplayDeviceConfig ddc = createDdc(DISPLAY_RANGE_NITS, - DISPLAY_LEVELS_RANGE_BACKLIGHT_FLOAT, GAMMA_CORRECTION_LUX, - GAMMA_CORRECTION_NITS); + Resources resources = createResources(); + DisplayDeviceConfig ddc = new DdcBuilder().setAutoBrightnessLevelsLux(GAMMA_CORRECTION_LUX) + .setAutoBrightnessLevelsNits(GAMMA_CORRECTION_NITS).build(); BrightnessMappingStrategy strategy = BrightnessMappingStrategy.create(resources, ddc, AUTO_BRIGHTNESS_MODE_DEFAULT, mMockDwbc); // Validity, as per tradition: @@ -790,11 +679,54 @@ public class BrightnessMappingStrategyTest { @Test public void testGetMode() { - Resources res = createResourcesIdle(LUX_LEVELS_IDLE, DISPLAY_LEVELS_NITS_IDLE); - DisplayDeviceConfig ddc = createDdc(DISPLAY_RANGE_NITS, BACKLIGHT_RANGE_ZERO_TO_ONE); + Resources res = createResources(LUX_LEVELS_IDLE, DISPLAY_LEVELS_NITS_IDLE); + DisplayDeviceConfig ddc = new DdcBuilder().setBrightnessRange(BACKLIGHT_RANGE_ZERO_TO_ONE) + .build(); BrightnessMappingStrategy strategy = BrightnessMappingStrategy.create(res, ddc, AUTO_BRIGHTNESS_MODE_IDLE, mMockDwbc); assertEquals(AUTO_BRIGHTNESS_MODE_IDLE, strategy.getMode()); } + + private static class DdcBuilder { + private DisplayDeviceConfig mDdc; + + DdcBuilder() { + mDdc = mock(DisplayDeviceConfig.class); + when(mDdc.getNits()).thenReturn(DISPLAY_RANGE_NITS); + when(mDdc.getBrightness()).thenReturn(DISPLAY_LEVELS_RANGE_BACKLIGHT_FLOAT); + when(mDdc.getAutoBrightnessBrighteningLevelsLux()).thenReturn(LUX_LEVELS); + when(mDdc.getAutoBrightnessBrighteningLevelsNits()).thenReturn(EMPTY_FLOAT_ARRAY); + when(mDdc.getAutoBrightnessBrighteningLevels()).thenReturn(EMPTY_FLOAT_ARRAY); + } + + DdcBuilder setNitsRange(float[] nitsArray) { + when(mDdc.getNits()).thenReturn(nitsArray); + return this; + } + + DdcBuilder setBrightnessRange(float[] brightnessArray) { + when(mDdc.getBrightness()).thenReturn(brightnessArray); + return this; + } + + DdcBuilder setAutoBrightnessLevelsLux(float[] luxLevels) { + when(mDdc.getAutoBrightnessBrighteningLevelsLux()).thenReturn(luxLevels); + return this; + } + + DdcBuilder setAutoBrightnessLevelsNits(float[] brightnessLevelsNits) { + when(mDdc.getAutoBrightnessBrighteningLevelsNits()).thenReturn(brightnessLevelsNits); + return this; + } + + DdcBuilder setAutoBrightnessLevels(float[] brightnessLevels) { + when(mDdc.getAutoBrightnessBrighteningLevels()).thenReturn(brightnessLevels); + return this; + } + + DisplayDeviceConfig build() { + return mDdc; + } + } } 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 31d7e88e671b..a4c15b5c5725 100644 --- a/services/tests/displayservicetests/src/com/android/server/display/DisplayDeviceConfigTest.java +++ b/services/tests/displayservicetests/src/com/android/server/display/DisplayDeviceConfigTest.java @@ -17,6 +17,7 @@ package com.android.server.display; +import static com.android.internal.display.BrightnessSynchronizer.brightnessIntToFloat; import static com.android.server.display.config.SensorData.SupportedMode; import static com.android.server.display.utils.DeviceConfigParsingUtils.ambientBrightnessThresholdsIntToFloat; import static com.android.server.display.utils.DeviceConfigParsingUtils.displayBrightnessThresholdsIntToFloat; @@ -47,7 +48,6 @@ import androidx.test.ext.junit.runners.AndroidJUnit4; import androidx.test.filters.SmallTest; import com.android.internal.R; -import com.android.internal.display.BrightnessSynchronizer; import com.android.server.display.config.HdrBrightnessData; import com.android.server.display.config.ThermalStatus; import com.android.server.display.feature.DisplayManagerFlags; @@ -609,6 +609,9 @@ public final class DisplayDeviceConfigTest { float[]{2.0f, 200.0f, 600.0f}, ZERO_DELTA); assertArrayEquals(mDisplayDeviceConfig.getAutoBrightnessBrighteningLevelsLux(), new float[]{0.0f, 110.0f, 500.0f}, ZERO_DELTA); + assertArrayEquals(mDisplayDeviceConfig.getAutoBrightnessBrighteningLevels(), new + float[]{brightnessIntToFloat(50), brightnessIntToFloat(100), + brightnessIntToFloat(150)}, SMALL_DELTA); // Test thresholds assertEquals(0, mDisplayDeviceConfig.getAmbientLuxBrighteningMinThreshold(), ZERO_DELTA); @@ -674,7 +677,7 @@ public final class DisplayDeviceConfigTest { assertEquals("test_light_sensor", mDisplayDeviceConfig.getAmbientLightSensor().type); assertEquals("", mDisplayDeviceConfig.getAmbientLightSensor().name); - assertEquals(BrightnessSynchronizer.brightnessIntToFloat(35), + assertEquals(brightnessIntToFloat(35), mDisplayDeviceConfig.getBrightnessCapForWearBedtimeMode(), ZERO_DELTA); } @@ -737,6 +740,27 @@ public final class DisplayDeviceConfigTest { mDisplayDeviceConfig.getAutoBrightnessBrighteningLevelsLux(), ZERO_DELTA); assertArrayEquals(new float[]{0.2f, 0.3f}, mDisplayDeviceConfig.getAutoBrightnessBrighteningLevels(), SMALL_DELTA); + + assertArrayEquals(new float[]{0.0f, 90}, + mDisplayDeviceConfig.getAutoBrightnessBrighteningLevelsLux("default", "dim"), + ZERO_DELTA); + assertArrayEquals(new float[]{0.3f, 0.4f}, + mDisplayDeviceConfig.getAutoBrightnessBrighteningLevels("default", "dim"), + SMALL_DELTA); + + assertArrayEquals(new float[]{0.0f, 95}, + mDisplayDeviceConfig.getAutoBrightnessBrighteningLevelsLux("doze", "normal"), + ZERO_DELTA); + assertArrayEquals(new float[]{0.35f, 0.45f}, + mDisplayDeviceConfig.getAutoBrightnessBrighteningLevels("doze", "normal"), + SMALL_DELTA); + + assertArrayEquals(new float[]{0.0f, 100}, + mDisplayDeviceConfig.getAutoBrightnessBrighteningLevelsLux("doze", "bright"), + ZERO_DELTA); + assertArrayEquals(new float[]{0.4f, 0.5f}, + mDisplayDeviceConfig.getAutoBrightnessBrighteningLevels("doze", "bright"), + SMALL_DELTA); } @Test @@ -746,7 +770,9 @@ public final class DisplayDeviceConfigTest { setupDisplayDeviceConfigFromDisplayConfigFile(getContent(getValidLuxThrottling(), getValidProxSensor(), /* includeIdleMode= */ false)); - assertNull(mDisplayDeviceConfig.getAutoBrightnessBrighteningLevels()); + assertArrayEquals(new float[]{brightnessIntToFloat(50), brightnessIntToFloat(100), + brightnessIntToFloat(150)}, + mDisplayDeviceConfig.getAutoBrightnessBrighteningLevels(), SMALL_DELTA); assertArrayEquals(new float[]{0, 110, 500}, mDisplayDeviceConfig.getAutoBrightnessBrighteningLevelsLux(), ZERO_DELTA); assertArrayEquals(new float[]{2, 200, 600}, @@ -1138,6 +1164,46 @@ public final class DisplayDeviceConfigTest { + "</point>\n" + "</map>\n" + "</luxToBrightnessMapping>\n" + + "<luxToBrightnessMapping>\n" + + "<setting>dim</setting>\n" + + "<map>\n" + + "<point>\n" + + "<first>0</first>\n" + + "<second>0.3</second>\n" + + "</point>\n" + + "<point>\n" + + "<first>90</first>\n" + + "<second>0.4</second>\n" + + "</point>\n" + + "</map>\n" + + "</luxToBrightnessMapping>\n" + + "<luxToBrightnessMapping>\n" + + "<mode>doze</mode>\n" + + "<map>\n" + + "<point>\n" + + "<first>0</first>\n" + + "<second>0.35</second>\n" + + "</point>\n" + + "<point>\n" + + "<first>95</first>\n" + + "<second>0.45</second>\n" + + "</point>\n" + + "</map>\n" + + "</luxToBrightnessMapping>\n" + + "<luxToBrightnessMapping>\n" + + "<mode>doze</mode>\n" + + "<setting>bright</setting>\n" + + "<map>\n" + + "<point>\n" + + "<first>0</first>\n" + + "<second>0.4</second>\n" + + "</point>\n" + + "<point>\n" + + "<first>100</first>\n" + + "<second>0.5</second>\n" + + "</point>\n" + + "</map>\n" + + "</luxToBrightnessMapping>\n" + "</autoBrightness>\n" + getPowerThrottlingConfig() + "<highBrightnessMode enabled=\"true\">\n" @@ -1435,6 +1501,10 @@ public final class DisplayDeviceConfigTest { when(mResources.getIntArray( com.android.internal.R.array.config_autoBrightnessLevels)) .thenReturn(screenBrightnessLevelLux); + int[] screenBrightnessLevels = new int[]{50, 100, 150}; + when(mResources.getIntArray( + com.android.internal.R.array.config_autoBrightnessLcdBacklightValues)) + .thenReturn(screenBrightnessLevels); // Thresholds // Config.xml requires the levels arrays to be of length N and the thresholds arrays to be diff --git a/services/tests/displayservicetests/src/com/android/server/display/LocalDisplayAdapterTest.java b/services/tests/displayservicetests/src/com/android/server/display/LocalDisplayAdapterTest.java index 0c845de8846e..00f98924eff3 100644 --- a/services/tests/displayservicetests/src/com/android/server/display/LocalDisplayAdapterTest.java +++ b/services/tests/displayservicetests/src/com/android/server/display/LocalDisplayAdapterTest.java @@ -206,6 +206,9 @@ public class LocalDisplayAdapterTest { when(mMockedResources.getIntArray( com.android.internal.R.array.config_highAmbientBrightnessThresholdsOfFixedRefreshRate)) .thenReturn(new int[]{}); + when(mMockedResources.getIntArray( + com.android.internal.R.array.config_autoBrightnessLcdBacklightValues)) + .thenReturn(new int[]{}); doReturn(true).when(mFlags).isDisplayOffloadEnabled(); initDisplayOffloadSession(); } |