Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 02989438 authored by Fiona Campbell's avatar Fiona Campbell Committed by Automerger Merge Worker
Browse files

Merge "Change BrightnessMappingStrategy to use DDC values" into sc-dev am: 26715c82 

Original change: https://googleplex-android-review.googlesource.com/c/platform/frameworks/base/+/13431734

MUST ONLY BE SUBMITTED BY AUTOMERGER

Change-Id: I616d87f845519d47ecdd1ecac7be63dac0a16c46
parents 157cd54b 26715c82

packages/SystemUI/src/com/android/systemui/settings/brightness/BrightnessController.java

+4 −10
Original line number Diff line number Diff line
@@ -72,8 +72,6 @@ public class BrightnessController implements ToggleSlider.Listener { 
    private static final Uri BRIGHTNESS_FOR_VR_FLOAT_URI =

            Settings.System.getUriFor(Settings.System.SCREEN_BRIGHTNESS_FOR_VR_FLOAT);



    private final float mMinimumBacklight;

    private final float mMaximumBacklight;

    private final float mDefaultBacklight;

    private final float mMinimumBacklightForVr;

    private final float mMaximumBacklightForVr;
@@ -314,10 +312,6 @@ public class BrightnessController implements ToggleSlider.Listener { 


        mDisplayId = mContext.getDisplayId();

        PowerManager pm = context.getSystemService(PowerManager.class);

        mMinimumBacklight = pm.getBrightnessConstraint(

                PowerManager.BRIGHTNESS_CONSTRAINT_TYPE_MINIMUM);

        mMaximumBacklight = pm.getBrightnessConstraint(

                PowerManager.BRIGHTNESS_CONSTRAINT_TYPE_MAXIMUM);

        mDefaultBacklight = mContext.getDisplay().getBrightnessDefault();

        mMinimumBacklightForVr = pm.getBrightnessConstraint(

                PowerManager.BRIGHTNESS_CONSTRAINT_TYPE_MINIMUM_VR);
@@ -375,8 +369,8 @@ public class BrightnessController implements ToggleSlider.Listener { 
            metric = mAutomatic

                    ? MetricsEvent.ACTION_BRIGHTNESS_AUTO

                    : MetricsEvent.ACTION_BRIGHTNESS;

            minBacklight = mMinimumBacklight;

            maxBacklight = mMaximumBacklight;

            minBacklight = PowerManager.BRIGHTNESS_MIN;

            maxBacklight = PowerManager.BRIGHTNESS_MAX;

            settingToChange = Settings.System.SCREEN_BRIGHTNESS_FLOAT;

        }

        final float valFloat = MathUtils.min(convertGammaToLinearFloat(value,
@@ -439,8 +433,8 @@ public class BrightnessController implements ToggleSlider.Listener { 
            min = mMinimumBacklightForVr;

            max = mMaximumBacklightForVr;

        } else {

            min = mMinimumBacklight;

            max = mMaximumBacklight;

            min = PowerManager.BRIGHTNESS_MIN;

            max = PowerManager.BRIGHTNESS_MAX;

        }

        // convertGammaToLinearFloat returns 0-1

        if (BrightnessSynchronizer.floatEquals(brightnessValue,

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

+52 −62
Original line number Diff line number Diff line
@@ -61,7 +61,10 @@ public abstract class BrightnessMappingStrategy { 
    private static final Plog PLOG = Plog.createSystemPlog(TAG);



    @Nullable

    public static BrightnessMappingStrategy create(Resources resources) {

    public static BrightnessMappingStrategy create(Resources resources,

            DisplayDeviceConfig displayDeviceConfig) {



        // Display independent values

        float[] luxLevels = getLuxLevels(resources.getIntArray(

                com.android.internal.R.array.config_autoBrightnessLevels));

        int[] brightnessLevelsBacklight = resources.getIntArray(
@@ -71,32 +74,22 @@ public abstract class BrightnessMappingStrategy { 
        float autoBrightnessAdjustmentMaxGamma = resources.getFraction(

                com.android.internal.R.fraction.config_autoBrightnessAdjustmentMaxGamma,

                1, 1);



        float[] nitsRange = getFloatArray(resources.obtainTypedArray(

                com.android.internal.R.array.config_screenBrightnessNits));

        int[] backlightRange = resources.getIntArray(

                com.android.internal.R.array.config_screenBrightnessBacklight);



        long shortTermModelTimeout = resources.getInteger(

                com.android.internal.R.integer.config_autoBrightnessShortTermModelTimeout);



        if (isValidMapping(nitsRange, backlightRange)

        // Display dependent values - used for physical mapping strategy nits -> brightness

        final float[] nitsRange = displayDeviceConfig.getNits();

        final float[] brightnessRange = displayDeviceConfig.getBrightness();



        if (isValidMapping(nitsRange, brightnessRange)

                && isValidMapping(luxLevels, brightnessLevelsNits)) {

            int minimumBacklight = resources.getInteger(

                    com.android.internal.R.integer.config_screenBrightnessSettingMinimum);

            int maximumBacklight = resources.getInteger(

                    com.android.internal.R.integer.config_screenBrightnessSettingMaximum);

            if (backlightRange[0] > minimumBacklight

                    || backlightRange[backlightRange.length - 1] < maximumBacklight) {

                Slog.w(TAG, "Screen brightness mapping does not cover whole range of available " +

                        "backlight values, autobrightness functionality may be impaired.");

            }



            BrightnessConfiguration.Builder builder = new BrightnessConfiguration.Builder(

                    luxLevels, brightnessLevelsNits);

            builder.setShortTermModelTimeoutMillis(shortTermModelTimeout);

            builder.setShortTermModelLowerLuxMultiplier(SHORT_TERM_MODEL_THRESHOLD_RATIO);

            builder.setShortTermModelUpperLuxMultiplier(SHORT_TERM_MODEL_THRESHOLD_RATIO);

            return new PhysicalMappingStrategy(builder.build(), nitsRange, backlightRange,

            return new PhysicalMappingStrategy(builder.build(), nitsRange, brightnessRange,

                    autoBrightnessAdjustmentMaxGamma);

        } else if (isValidMapping(luxLevels, brightnessLevelsBacklight)) {

            return new SimpleMappingStrategy(luxLevels, brightnessLevelsBacklight,
@@ -264,11 +257,11 @@ public abstract class BrightnessMappingStrategy { 
    public abstract boolean setAutoBrightnessAdjustment(float adjustment);



    /**

     * Converts the provided backlight value to nits if possible.

     * Converts the provided brightness value to nits if possible.

     *

     * Returns -1.0f if there's no available mapping for the backlight to nits.

     * Returns -1.0f if there's no available mapping for the brightness to nits.

     */

    public abstract float convertToNits(int backlight);

    public abstract float convertToNits(float brightness);



    /**

     * Adds a user interaction data point to the brightness mapping.
@@ -603,7 +596,7 @@ public abstract class BrightnessMappingStrategy { 
        }



        @Override

        public float convertToNits(int backlight) {

        public float convertToNits(float brightness) {

            return -1.0f;

        }
@@ -701,37 +694,39 @@ public abstract class BrightnessMappingStrategy { 
        // in nits.

        private Spline mBrightnessSpline;



        // A spline mapping from nits to the corresponding backlight value, normalized to the range

        // A spline mapping from nits to the corresponding brightness value, normalized to the range

        // [0, 1.0].

        private Spline mNitsToBacklightSpline;

        private Spline mNitsToBrightnessSpline;



        // A spline mapping from the system brightness value, normalized to the range [0, 1.0], to

        // a brightness in nits.

        private Spline mBrightnessToNitsSpline;



        // The default brightness configuration.

        private final BrightnessConfiguration mDefaultConfig;



        // A spline mapping from the device's backlight value, normalized to the range [0, 1.0], to

        // a brightness in nits.

        private Spline mBacklightToNitsSpline;



        private float[] mNits;

        private int[] mBacklight;

        private final float[] mNits;

        private final float[] mBrightness;



        private boolean mBrightnessRangeAdjustmentApplied;



        private float mMaxGamma;

        private final float mMaxGamma;

        private float mAutoBrightnessAdjustment;

        private float mUserLux;

        private float mUserBrightness;



        public PhysicalMappingStrategy(BrightnessConfiguration config, float[] nits,

                                       int[] backlight, float maxGamma) {

            Preconditions.checkArgument(nits.length != 0 && backlight.length != 0,

                    "Nits and backlight arrays must not be empty!");

            Preconditions.checkArgument(nits.length == backlight.length,

                    "Nits and backlight arrays must be the same length!");

                float[] brightness, float maxGamma) {



            Preconditions.checkArgument(nits.length != 0 && brightness.length != 0,

                    "Nits and brightness arrays must not be empty!");



            Preconditions.checkArgument(nits.length == brightness.length,

                    "Nits and brightness arrays must be the same length!");

            Objects.requireNonNull(config);

            Preconditions.checkArrayElementsInRange(nits, 0, Float.MAX_VALUE, "nits");

            Preconditions.checkArrayElementsInRange(backlight,

                    PowerManager.BRIGHTNESS_OFF, PowerManager.BRIGHTNESS_ON, "backlight");

            Preconditions.checkArrayElementsInRange(brightness,

                    PowerManager.BRIGHTNESS_MIN, PowerManager.BRIGHTNESS_MAX, "brightness");



            mMaxGamma = maxGamma;

            mAutoBrightnessAdjustment = 0;
@@ -739,7 +734,7 @@ public abstract class BrightnessMappingStrategy { 
            mUserBrightness = -1;



            mNits = nits;

            mBacklight = backlight;

            mBrightness = brightness;

            computeNitsBrightnessSplines(mNits);



            mDefaultConfig = config;
@@ -784,15 +779,15 @@ public abstract class BrightnessMappingStrategy { 
        public float getBrightness(float lux, String packageName,

                @ApplicationInfo.Category int category) {

            float nits = mBrightnessSpline.interpolate(lux);

            float backlight = mNitsToBacklightSpline.interpolate(nits);

            float brightness = mNitsToBrightnessSpline.interpolate(nits);

            // Correct the brightness according to the current application and its category, but

            // only if no user data point is set (as this will oevrride the user setting).

            // only if no user data point is set (as this will override the user setting).

            if (mUserLux == -1) {

                backlight = correctBrightness(backlight, packageName, category);

                brightness = correctBrightness(brightness, packageName, category);

            } else if (mLoggingEnabled) {

                Slog.d(TAG, "user point set, correction not applied");

            }

            return backlight;

            return brightness;

        }



        @Override
@@ -817,8 +812,8 @@ public abstract class BrightnessMappingStrategy { 
        }



        @Override

        public float convertToNits(int backlight) {

            return mBacklightToNitsSpline.interpolate(normalizeAbsoluteBrightness(backlight));

        public float convertToNits(float brightness) {

            return mBrightnessToNitsSpline.interpolate(brightness);

        }



        @Override
@@ -884,7 +879,8 @@ public abstract class BrightnessMappingStrategy { 
            pw.println("PhysicalMappingStrategy");

            pw.println("  mConfig=" + mConfig);

            pw.println("  mBrightnessSpline=" + mBrightnessSpline);

            pw.println("  mNitsToBacklightSpline=" + mNitsToBacklightSpline);

            pw.println("  mNitsToBrightnessSpline=" + mNitsToBrightnessSpline);

            pw.println("  mBrightnessToNitsSpline=" + mBrightnessToNitsSpline);

            pw.println("  mMaxGamma=" + mMaxGamma);

            pw.println("  mAutoBrightnessAdjustment=" + mAutoBrightnessAdjustment);

            pw.println("  mUserLux=" + mUserLux);
@@ -894,31 +890,25 @@ public abstract class BrightnessMappingStrategy { 
        }



        private void computeNitsBrightnessSplines(float[] nits) {

            final int len = nits.length;

            float[] normalizedBacklight = new float[len];

            for (int i = 0; i < len; i++) {

                normalizedBacklight[i] = normalizeAbsoluteBrightness(mBacklight[i]);

            }



            mNitsToBacklightSpline = Spline.createSpline(nits, normalizedBacklight);

            mBacklightToNitsSpline = Spline.createSpline(normalizedBacklight, nits);

            mNitsToBrightnessSpline = Spline.createSpline(nits, mBrightness);

            mBrightnessToNitsSpline = Spline.createSpline(mBrightness, nits);

        }



        private void computeSpline() {

            Pair<float[], float[]> defaultCurve = mConfig.getCurve();

            float[] defaultLux = defaultCurve.first;

            float[] defaultNits = defaultCurve.second;

            float[] defaultBacklight = new float[defaultNits.length];

            for (int i = 0; i < defaultBacklight.length; i++) {

                defaultBacklight[i] = mNitsToBacklightSpline.interpolate(defaultNits[i]);

            float[] defaultBrightness = new float[defaultNits.length];

            for (int i = 0; i < defaultBrightness.length; i++) {

                defaultBrightness[i] = mNitsToBrightnessSpline.interpolate(defaultNits[i]);

            }

            Pair<float[], float[]> curve = getAdjustedCurve(defaultLux, defaultBacklight, mUserLux,

            Pair<float[], float[]> curve = getAdjustedCurve(defaultLux, defaultBrightness, mUserLux,

                    mUserBrightness, mAutoBrightnessAdjustment, mMaxGamma);

            float[] lux = curve.first;

            float[] backlight = curve.second;

            float[] nits = new float[backlight.length];

            float[] brightness = curve.second;

            float[] nits = new float[brightness.length];

            for (int i = 0; i < nits.length; i++) {

                nits[i] = mBacklightToNitsSpline.interpolate(backlight[i]);

                nits[i] = mBrightnessToNitsSpline.interpolate(brightness[i]);

            }

            mBrightnessSpline = Spline.createSpline(lux, nits);

        }
@@ -926,7 +916,7 @@ public abstract class BrightnessMappingStrategy { 
        private float getUnadjustedBrightness(float lux) {

            Pair<float[], float[]> curve = mConfig.getCurve();

            Spline spline = Spline.createSpline(curve.first, curve.second);

            return mNitsToBacklightSpline.interpolate(spline.interpolate(lux));

            return mNitsToBrightnessSpline.interpolate(spline.interpolate(lux));

        }



        private float correctBrightness(float brightness, String packageName, int category) {

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

+196 −32

File changed.

Preview size limit exceeded, changes collapsed.

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

+20 −40
Original line number Diff line number Diff line
@@ -190,12 +190,6 @@ final class DisplayPowerController implements AutomaticBrightnessController.Call 
    // The dim screen brightness.

    private final float mScreenBrightnessDimConfig;



    // The minimum allowed brightness.

    private final float mScreenBrightnessRangeMinimum;



    // The maximum allowed brightness.

    private final float mScreenBrightnessRangeMaximum;



    private final float mScreenBrightnessDefault;



    // The minimum allowed brightness while in VR.
@@ -443,8 +437,6 @@ final class DisplayPowerController implements AutomaticBrightnessController.Call 


        final Resources resources = context.getResources();



        final float screenBrightnessSettingMinimumFloat = clampAbsoluteBrightness(

                pm.getBrightnessConstraint(PowerManager.BRIGHTNESS_CONSTRAINT_TYPE_MINIMUM));



        // DOZE AND DIM SETTINGS

        mScreenBrightnessDozeConfig = clampAbsoluteBrightness(
@@ -453,10 +445,6 @@ final class DisplayPowerController implements AutomaticBrightnessController.Call 
                pm.getBrightnessConstraint(PowerManager.BRIGHTNESS_CONSTRAINT_TYPE_DIM));



        // NORMAL SCREEN SETTINGS

        mScreenBrightnessRangeMinimum =

                Math.min(screenBrightnessSettingMinimumFloat, mScreenBrightnessDimConfig);

        mScreenBrightnessRangeMaximum = clampAbsoluteBrightness(

                pm.getBrightnessConstraint(PowerManager.BRIGHTNESS_CONSTRAINT_TYPE_MAXIMUM));

        mScreenBrightnessDefault = clampAbsoluteBrightness(

                mLogicalDisplay.getDisplayInfoLocked().brightnessDefault);
@@ -545,12 +533,14 @@ final class DisplayPowerController implements AutomaticBrightnessController.Call 
                    com.android.internal.R.string.config_displayLightSensorType);

            Sensor lightSensor = findDisplayLightSensor(lightSensorType);



            mBrightnessMapper = BrightnessMappingStrategy.create(resources);

            final DisplayDeviceConfig ddc =

                    logicalDisplay.getPrimaryDisplayDeviceLocked().getDisplayDeviceConfig();

            mBrightnessMapper = BrightnessMappingStrategy.create(resources, ddc);

            if (mBrightnessMapper != null) {

                mAutomaticBrightnessController = new AutomaticBrightnessController(this,

                        handler.getLooper(), sensorManager, lightSensor, mBrightnessMapper,

                        lightSensorWarmUpTimeConfig, mScreenBrightnessRangeMinimum,

                        mScreenBrightnessRangeMaximum, dozeScaleFactor, lightSensorRate,

                        lightSensorWarmUpTimeConfig, PowerManager.BRIGHTNESS_MIN,

                        PowerManager.BRIGHTNESS_MAX, dozeScaleFactor, lightSensorRate,

                        initialLightSensorRate, brighteningLightDebounce, darkeningLightDebounce,

                        autoBrightnessResetAmbientLuxAfterWarmUp, ambientBrightnessThresholds,

                        screenBrightnessThresholds, logicalDisplay, context);
@@ -838,9 +828,8 @@ final class DisplayPowerController implements AutomaticBrightnessController.Call 
        noteScreenBrightness(mPowerState.getScreenBrightness());



        // Initialize all of the brightness tracking state

        final float brightness = convertToNits(BrightnessSynchronizer.brightnessFloatToInt(

                mPowerState.getScreenBrightness()));

        if (brightness >= 0.0f) {

        final float brightness = convertToNits(mPowerState.getScreenBrightness());

        if (brightness >= PowerManager.BRIGHTNESS_MIN) {

            mBrightnessTracker.start(brightness);

        }
@@ -1151,10 +1140,10 @@ final class DisplayPowerController implements AutomaticBrightnessController.Call 
        // Apply dimming by at least some minimum amount when user activity

        // timeout is about to expire.

        if (mPowerRequest.policy == DisplayPowerRequest.POLICY_DIM) {

            if (brightnessState > mScreenBrightnessRangeMinimum) {

            if (brightnessState > PowerManager.BRIGHTNESS_MIN) {

                brightnessState = Math.max(Math.min(brightnessState

                                - SCREEN_DIM_MINIMUM_REDUCTION_FLOAT,

                        mScreenBrightnessDimConfig), mScreenBrightnessRangeMinimum);

                        mScreenBrightnessDimConfig), PowerManager.BRIGHTNESS_MIN);

                mBrightnessReasonTemp.addModifier(BrightnessReason.MODIFIER_DIMMED);

            }

            if (!mAppliedDimming) {
@@ -1168,12 +1157,11 @@ final class DisplayPowerController implements AutomaticBrightnessController.Call 
        // If low power mode is enabled, scale brightness by screenLowPowerBrightnessFactor

        // as long as it is above the minimum threshold.

        if (mPowerRequest.lowPowerMode) {

            if (brightnessState > mScreenBrightnessRangeMinimum) {

            if (brightnessState > PowerManager.BRIGHTNESS_MIN) {

                final float brightnessFactor =

                        Math.min(mPowerRequest.screenLowPowerBrightnessFactor, 1);

                final float lowPowerBrightnessFloat = (brightnessState * brightnessFactor);

                brightnessState = Math.max(lowPowerBrightnessFloat,

                        mScreenBrightnessRangeMinimum);

                brightnessState = Math.max(lowPowerBrightnessFloat, PowerManager.BRIGHTNESS_MIN);

                mBrightnessReasonTemp.addModifier(BrightnessReason.MODIFIER_LOW_POWER);

            }

            if (!mAppliedLowPower) {
@@ -1258,9 +1246,8 @@ final class DisplayPowerController implements AutomaticBrightnessController.Call 
                    // slider event so notify as if the system changed the brightness.

                    userInitiatedChange = false;

                }

                notifyBrightnessChanged(

                        BrightnessSynchronizer.brightnessFloatToInt(brightnessState),

                        userInitiatedChange, hadUserBrightnessPoint);

                notifyBrightnessChanged(brightnessState, userInitiatedChange,

                        hadUserBrightnessPoint);

            }



        }
@@ -1487,17 +1474,17 @@ final class DisplayPowerController implements AutomaticBrightnessController.Call 


    private float clampScreenBrightness(float value) {

        if (Float.isNaN(value)) {

            return mScreenBrightnessRangeMinimum;

            return PowerManager.BRIGHTNESS_MIN;

        }

        return MathUtils.constrain(

                value, mScreenBrightnessRangeMinimum, mScreenBrightnessRangeMaximum);

                value, PowerManager.BRIGHTNESS_MIN, PowerManager.BRIGHTNESS_MAX);

    }



    // Checks whether the brightness is within the valid brightness range, not including the off or

    // invalid states.

    private boolean isValidBrightnessValue(float brightnessState) {

        return brightnessState >= mScreenBrightnessRangeMinimum

                && brightnessState <= mScreenBrightnessRangeMaximum;

        return brightnessState >= PowerManager.BRIGHTNESS_MIN

                && brightnessState <= PowerManager.BRIGHTNESS_MAX;

    }



    private void animateScreenBrightness(float target, float rate) {
@@ -1874,7 +1861,7 @@ final class DisplayPowerController implements AutomaticBrightnessController.Call 
        return true;

    }



    private void notifyBrightnessChanged(int brightness, boolean userInitiated,

    private void notifyBrightnessChanged(float brightness, boolean userInitiated,

            boolean hadUserDataPoint) {

        final float brightnessInNits = convertToNits(brightness);

        if (mPowerRequest.useAutoBrightness && brightnessInNits >= 0.0f
@@ -1891,9 +1878,9 @@ final class DisplayPowerController implements AutomaticBrightnessController.Call 
        }

    }



    private float convertToNits(int backlight) {

    private float convertToNits(float brightness) {

        if (mBrightnessMapper != null) {

            return mBrightnessMapper.convertToNits(backlight);

            return mBrightnessMapper.convertToNits(brightness);

        } else {

            return -1.0f;

        }
@@ -1972,12 +1959,9 @@ final class DisplayPowerController implements AutomaticBrightnessController.Call 


        pw.println();

        pw.println("Display Power Controller Configuration:");

        pw.println("  mScreenBrightnessRangeMinimum=" + mScreenBrightnessRangeMinimum);

        pw.println("  mScreenBrightnessRangeMaximum=" + mScreenBrightnessRangeMaximum);

        pw.println("  mScreenBrightnessRangeDefault=" + mScreenBrightnessDefault);

        pw.println("  mScreenBrightnessDozeConfig=" + mScreenBrightnessDozeConfig);

        pw.println("  mScreenBrightnessDimConfig=" + mScreenBrightnessDimConfig);

        pw.println("  mScreenBrightnessDefault=" + mScreenBrightnessDefault);

        pw.println("  mScreenBrightnessForVrRangeMinimum=" + mScreenBrightnessForVrRangeMinimum);

        pw.println("  mScreenBrightnessForVrRangeMaximum=" + mScreenBrightnessForVrRangeMaximum);

        pw.println("  mScreenBrightnessForVrDefault=" + mScreenBrightnessForVrDefault);
@@ -2109,10 +2093,6 @@ final class DisplayPowerController implements AutomaticBrightnessController.Call 
        }

    }



    private static int clampAbsoluteBrightness(int value) {

        return MathUtils.constrain(value, PowerManager.BRIGHTNESS_OFF, PowerManager.BRIGHTNESS_ON);

    }



    private static float clampAbsoluteBrightness(float value) {

        return MathUtils.constrain(value, PowerManager.BRIGHTNESS_MIN,

                PowerManager.BRIGHTNESS_MAX);

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

+15 −72

File changed.

Preview size limit exceeded, changes collapsed.