From b76eebff47653daf0c98119aeb68b57cb9a46f9d Mon Sep 17 00:00:00 2001 From: Jeff Brown Date: Fri, 5 Oct 2012 22:26:44 -0700 Subject: [PATCH] Allow the dim brightness to be brighter than the minimum. Defines the lower end of the allowable screen brightness range as the lesser of the dim level, the user brightness setting minimum value and the lowest auto-brightness level. Bug: 7295909 Change-Id: I7a72b4611631f9e51578205ff12898c5bae02b1b --- .../server/power/DisplayPowerController.java | 83 ++++++++++++++----- 1 file changed, 63 insertions(+), 20 deletions(-) diff --git a/services/java/com/android/server/power/DisplayPowerController.java b/services/java/com/android/server/power/DisplayPowerController.java index 23df7011a7663..a1c1fa6cf7eec 100644 --- a/services/java/com/android/server/power/DisplayPowerController.java +++ b/services/java/com/android/server/power/DisplayPowerController.java @@ -89,6 +89,9 @@ final class DisplayPowerController { // auto-brightness adjustment setting. private static final float SCREEN_AUTO_BRIGHTNESS_ADJUSTMENT_MAX_GAMMA = 3.0f; + // The minimum reduction in brightness when dimmed. + private static final int SCREEN_DIM_MINIMUM_REDUCTION = 10; + // If true, enables the use of the current time as an auto-brightness adjustment. // The basic idea here is to expand the dynamic range of auto-brightness // when it is especially dark outside. The light sensor tends to perform @@ -185,6 +188,12 @@ final class DisplayPowerController { // The dim screen brightness. private final int mScreenBrightnessDimConfig; + // The minimum allowed brightness. + private final int mScreenBrightnessRangeMinimum; + + // The maximum allowed brightness. + private final int mScreenBrightnessRangeMaximum; + // True if auto-brightness should be used. private boolean mUseSoftwareAutoBrightnessConfig; @@ -343,8 +352,14 @@ final class DisplayPowerController { mDisplayManager = (DisplayManager)context.getSystemService(Context.DISPLAY_SERVICE); final Resources resources = context.getResources(); - mScreenBrightnessDimConfig = resources.getInteger( - com.android.internal.R.integer.config_screenBrightnessDim); + + mScreenBrightnessDimConfig = clampAbsoluteBrightness(resources.getInteger( + com.android.internal.R.integer.config_screenBrightnessDim)); + + int screenBrightnessMinimum = Math.min(resources.getInteger( + com.android.internal.R.integer.config_screenBrightnessSettingMinimum), + mScreenBrightnessDimConfig); + mUseSoftwareAutoBrightnessConfig = resources.getBoolean( com.android.internal.R.bool.config_automatic_brightness_available); if (mUseSoftwareAutoBrightnessConfig) { @@ -362,12 +377,19 @@ final class DisplayPowerController { + "which must be strictly increasing. " + "Auto-brightness will be disabled."); mUseSoftwareAutoBrightnessConfig = false; + } else { + if (screenBrightness[0] < screenBrightnessMinimum) { + screenBrightnessMinimum = screenBrightness[0]; + } } mLightSensorWarmUpTimeConfig = resources.getInteger( com.android.internal.R.integer.config_lightSensorWarmupTime); } + mScreenBrightnessRangeMinimum = clampAbsoluteBrightness(screenBrightnessMinimum); + mScreenBrightnessRangeMaximum = PowerManager.BRIGHTNESS_ON; + mElectronBeamAnimatesBacklightConfig = resources.getBoolean( com.android.internal.R.bool.config_animateScreenLights); @@ -394,14 +416,14 @@ final class DisplayPowerController { final int n = brightness.length; float[] x = new float[n]; float[] y = new float[n]; - y[0] = (float)brightness[0] / PowerManager.BRIGHTNESS_ON; + y[0] = normalizeAbsoluteBrightness(brightness[0]); for (int i = 1; i < n; i++) { x[i] = lux[i - 1]; - y[i] = (float)brightness[i] / PowerManager.BRIGHTNESS_ON; + y[i] = normalizeAbsoluteBrightness(brightness[i]); } Spline spline = Spline.createMonotoneCubicSpline(x, y); - if (false) { + if (DEBUG) { Slog.d(TAG, "Auto-brightness spline: " + spline); for (float v = 1f; v < lux[lux.length - 1] * 1.25f; v *= 1.25f) { Slog.d(TAG, String.format(" %7.1f: %7.1f", v, spline.interpolate(v))); @@ -602,30 +624,31 @@ final class DisplayPowerController { } // Set the screen brightness. - if (mPowerRequest.screenState == DisplayPowerRequest.SCREEN_STATE_DIM) { - // Screen is dimmed. Overrides everything else. - animateScreenBrightness( - clampScreenBrightness(mScreenBrightnessDimConfig), - BRIGHTNESS_RAMP_RATE_FAST); - mUsingScreenAutoBrightness = false; - } else if (mPowerRequest.screenState == DisplayPowerRequest.SCREEN_STATE_BRIGHT) { + if (wantScreenOn(mPowerRequest.screenState)) { + int target; + boolean slow; if (mScreenAutoBrightness >= 0 && mLightSensorEnabled) { // Use current auto-brightness value. - animateScreenBrightness( - clampScreenBrightness(mScreenAutoBrightness), - mUsingScreenAutoBrightness ? BRIGHTNESS_RAMP_RATE_SLOW : - BRIGHTNESS_RAMP_RATE_FAST); + target = mScreenAutoBrightness; + slow = mUsingScreenAutoBrightness; mUsingScreenAutoBrightness = true; } else { // Light sensor is disabled or not ready yet. // Use the current brightness setting from the request, which is expected // provide a nominal default value for the case where auto-brightness // is not ready yet. - animateScreenBrightness( - clampScreenBrightness(mPowerRequest.screenBrightness), - BRIGHTNESS_RAMP_RATE_FAST); + target = mPowerRequest.screenBrightness; + slow = false; mUsingScreenAutoBrightness = false; } + if (mPowerRequest.screenState == DisplayPowerRequest.SCREEN_STATE_DIM) { + // Screen is dimmed. Sets an upper bound on everything else. + target = Math.min(target - SCREEN_DIM_MINIMUM_REDUCTION, + mScreenBrightnessDimConfig); + slow = false; + } + animateScreenBrightness(clampScreenBrightness(target), + slow ? BRIGHTNESS_RAMP_RATE_SLOW : BRIGHTNESS_RAMP_RATE_FAST); } else { // Screen is off. Don't bother changing the brightness. mUsingScreenAutoBrightness = false; @@ -729,7 +752,25 @@ final class DisplayPowerController { } private int clampScreenBrightness(int value) { - return Math.min(Math.max(Math.max(value, mScreenBrightnessDimConfig), 0), 255); + return clamp(value, mScreenBrightnessRangeMinimum, mScreenBrightnessRangeMaximum); + } + + private static int clampAbsoluteBrightness(int value) { + return clamp(value, PowerManager.BRIGHTNESS_OFF, PowerManager.BRIGHTNESS_ON); + } + + private static int clamp(int value, int min, int max) { + if (value <= min) { + return min; + } + if (value >= max) { + return max; + } + return value; + } + + private static float normalizeAbsoluteBrightness(int value) { + return (float)clampAbsoluteBrightness(value) / PowerManager.BRIGHTNESS_ON; } private void animateScreenBrightness(int target, int rate) { @@ -1055,6 +1096,8 @@ final class DisplayPowerController { pw.println(); pw.println("Display Controller Configuration:"); pw.println(" mScreenBrightnessDimConfig=" + mScreenBrightnessDimConfig); + pw.println(" mScreenBrightnessRangeMinimum=" + mScreenBrightnessRangeMinimum); + pw.println(" mScreenBrightnessRangeMaximum=" + mScreenBrightnessRangeMaximum); pw.println(" mUseSoftwareAutoBrightnessConfig=" + mUseSoftwareAutoBrightnessConfig); pw.println(" mScreenAutoBrightnessSpline=" + mScreenAutoBrightnessSpline);