Merge "Add support for auto-brightness adjust, but leave it disabled." into jb-mr1-dev

Jeff Brown · Android (Google) Code Review · commit ae25108a7b71 · 2012-08-21T23:40:19.000-07:00
diff --git a/services/java/com/android/server/power/DisplayPowerController.java b/services/java/com/android/server/power/DisplayPowerController.java
@@ -32,7 +32,10 @@
 import android.os.Handler;
 import android.os.Looper;
 import android.os.Message;
+import android.os.PowerManager;
 import android.os.SystemClock;
+import android.text.format.DateUtils;
+import android.util.FloatMath;
 import android.util.Slog;
 import android.util.Spline;
 import android.util.TimeUtils;
@@ -78,6 +81,13 @@ final class DisplayPowerController {
     // screen state returns.  Playing the animation can also be somewhat slow.
     private static final boolean USE_ELECTRON_BEAM_ON_ANIMATION = false;
 
+    // If true, enables the use of the screen auto-brightness adjustment setting.
+    private static final boolean USE_SCREEN_AUTO_BRIGHTNESS_ADJUSTMENT = false;
+
+    // The maximum range of gamma adjustment possible using the screen
+    // auto-brightness adjustment setting.
+    private static final float SCREEN_AUTO_BRIGHTNESS_ADJUSTMENT_MAX_GAMMA = 3.0f;
+
     private static final int ELECTRON_BEAM_ON_ANIMATION_DURATION_MILLIS = 300;
     private static final int ELECTRON_BEAM_OFF_ANIMATION_DURATION_MILLIS = 600;
 
@@ -150,8 +160,11 @@ final class DisplayPowerController {
     // The dim screen brightness.
     private final int mScreenBrightnessDimConfig;
 
-    // Auto-brightness.
+    // True if auto-brightness should be used.
     private boolean mUseSoftwareAutoBrightnessConfig;
+
+    // The auto-brightness spline adjustment.
+    // The brightness values have been scaled to a range of 0..1.
     private Spline mScreenAutoBrightnessSpline;
 
     // Amount of time to delay auto-brightness after screen on while waiting for
@@ -266,6 +279,9 @@ final class DisplayPowerController {
     // Use -1 if there is no current auto-brightness value available.
     private int mScreenAutoBrightness = -1;
 
+    // The last screen auto-brightness gamma.  (For printing in dump() only.)
+    private float mLastScreenAutoBrightnessGamma = 1.0f;
+
     // True if the screen auto-brightness value is actually being used to
     // set the display brightness.
     private boolean mUsingScreenAutoBrightness;
@@ -335,10 +351,10 @@ private static Spline createAutoBrightnessSpline(int[] lux, int[] brightness) {
             final int n = brightness.length;
             float[] x = new float[n];
             float[] y = new float[n];
-            y[0] = brightness[0];
+            y[0] = (float)brightness[0] / PowerManager.BRIGHTNESS_ON;
             for (int i = 1; i < n; i++) {
                 x[i] = lux[i - 1];
-                y[i] = brightness[i];
+                y[i] = (float)brightness[i] / PowerManager.BRIGHTNESS_ON;
             }
 
             Spline spline = Spline.createMonotoneCubicSpline(x, y);
@@ -470,6 +486,8 @@ private void updatePowerState() {
         // Update the power state request.
         final boolean mustNotify;
         boolean mustInitialize = false;
+        boolean updateAutoBrightness = false;
+
         synchronized (mLock) {
             mPendingUpdatePowerStateLocked = false;
             if (mPendingRequestLocked == null) {
@@ -483,6 +501,10 @@ private void updatePowerState() {
                 mPendingRequestChangedLocked = false;
                 mustInitialize = true;
             } else if (mPendingRequestChangedLocked) {
+                if (mPowerRequest.screenAutoBrightnessAdjustment
+                        != mPendingRequestLocked.screenAutoBrightnessAdjustment) {
+                    updateAutoBrightness = true;
+                }
                 mPowerRequest.copyFrom(mPendingRequestLocked);
                 mWaitingForNegativeProximity |= mPendingWaitForNegativeProximityLocked;
                 mPendingWaitForNegativeProximityLocked = false;
@@ -530,19 +552,21 @@ private void updatePowerState() {
         // Turn on the light sensor if needed.
         if (mLightSensor != null) {
             setLightSensorEnabled(mPowerRequest.useAutoBrightness
-                    && wantScreenOn(mPowerRequest.screenState));
+                    && wantScreenOn(mPowerRequest.screenState), updateAutoBrightness);
         }
 
         // Set the screen brightness.
         if (mPowerRequest.screenState == DisplayPowerRequest.SCREEN_STATE_DIM) {
             // Screen is dimmed.  Overrides everything else.
-            animateScreenBrightness(mScreenBrightnessDimConfig, BRIGHTNESS_RAMP_RATE_FAST);
+            animateScreenBrightness(
+                    clampScreenBrightness(mScreenBrightnessDimConfig),
+                    BRIGHTNESS_RAMP_RATE_FAST);
             mUsingScreenAutoBrightness = false;
         } else if (mPowerRequest.screenState == DisplayPowerRequest.SCREEN_STATE_BRIGHT) {
             if (mScreenAutoBrightness >= 0 && mLightSensorEnabled) {
                 // Use current auto-brightness value.
                 animateScreenBrightness(
-                        Math.max(mScreenAutoBrightness, mScreenBrightnessDimConfig),
+                        clampScreenBrightness(mScreenAutoBrightness),
                         mUsingScreenAutoBrightness ? BRIGHTNESS_RAMP_RATE_SLOW :
                                 BRIGHTNESS_RAMP_RATE_FAST);
                 mUsingScreenAutoBrightness = true;
@@ -552,7 +576,7 @@ private void updatePowerState() {
                 // provide a nominal default value for the case where auto-brightness
                 // is not ready yet.
                 animateScreenBrightness(
-                        Math.max(mPowerRequest.screenBrightness, mScreenBrightnessDimConfig),
+                        clampScreenBrightness(mPowerRequest.screenBrightness),
                         BRIGHTNESS_RAMP_RATE_FAST);
                 mUsingScreenAutoBrightness = false;
             }
@@ -630,6 +654,10 @@ private void setScreenOn(boolean on) {
         }
     }
 
+    private int clampScreenBrightness(int value) {
+        return Math.min(Math.max(Math.max(value, mScreenBrightnessDimConfig), 0), 255);
+    }
+
     private void animateScreenBrightness(int target, int rate) {
         if (mScreenBrightnessRampAnimator.animateTo(target, rate)) {
             mNotifier.onScreenBrightness(target);
@@ -691,9 +719,10 @@ private void debounceProximitySensor() {
         }
     }
 
-    private void setLightSensorEnabled(boolean enable) {
+    private void setLightSensorEnabled(boolean enable, boolean updateAutoBrightness) {
         if (enable) {
             if (!mLightSensorEnabled) {
+                updateAutoBrightness = true;
                 mLightSensorEnabled = true;
                 mLightSensorEnableTime = SystemClock.uptimeMillis();
                 mSensorManager.registerListener(mLightSensorListener, mLightSensor,
@@ -703,11 +732,13 @@ private void setLightSensorEnabled(boolean enable) {
             if (mLightSensorEnabled) {
                 mLightSensorEnabled = false;
                 mLightMeasurementValid = false;
-                updateAutoBrightness(false);
                 mHandler.removeMessages(MSG_LIGHT_SENSOR_DEBOUNCED);
                 mSensorManager.unregisterListener(mLightSensorListener);
             }
         }
+        if (updateAutoBrightness) {
+            updateAutoBrightness(false);
+        }
     }
 
     private void handleLightSensorEvent(long time, float lux) {
@@ -818,26 +849,46 @@ private void updateAutoBrightness(boolean sendUpdate) {
             return;
         }
 
-        final int newScreenAutoBrightness = interpolateBrightness(
-                mScreenAutoBrightnessSpline, mLightMeasurement);
+        float value = mScreenAutoBrightnessSpline.interpolate(mLightMeasurement);
+        float gamma = 1.0f;
+
+        if (USE_SCREEN_AUTO_BRIGHTNESS_ADJUSTMENT
+                && mPowerRequest.screenAutoBrightnessAdjustment != 0.0f) {
+            final float adjGamma = FloatMath.pow(SCREEN_AUTO_BRIGHTNESS_ADJUSTMENT_MAX_GAMMA,
+                    Math.min(1.0f, Math.max(-1.0f,
+                            -mPowerRequest.screenAutoBrightnessAdjustment)));
+            gamma *= adjGamma;
+            if (DEBUG) {
+                Slog.d(TAG, "updateAutoBrightness: adjGamma=" + adjGamma);
+            }
+        }
+
+        if (gamma != 1.0f) {
+            final float in = value;
+            value = FloatMath.pow(value, gamma);
+            if (DEBUG) {
+                Slog.d(TAG, "updateAutoBrightness: gamma=" + gamma
+                        + ", in=" + in + ", out=" + value);
+            }
+        }
+
+        int newScreenAutoBrightness = clampScreenBrightness(
+                (int)Math.round(value * PowerManager.BRIGHTNESS_ON));
         if (mScreenAutoBrightness != newScreenAutoBrightness) {
             if (DEBUG) {
                 Slog.d(TAG, "updateAutoBrightness: mScreenAutoBrightness="
-                        + mScreenAutoBrightness + "newScreenAutoBrightness="
+                        + mScreenAutoBrightness + ", newScreenAutoBrightness="
                         + newScreenAutoBrightness);
             }
 
             mScreenAutoBrightness = newScreenAutoBrightness;
+            mLastScreenAutoBrightnessGamma = gamma;
             if (sendUpdate) {
                 sendUpdatePowerState();
             }
         }
     }
 
-    private static int interpolateBrightness(Spline spline, float lux) {
-        return Math.min(255, Math.max(0, (int)Math.round(spline.interpolate(lux))));
-    }
-
     private void sendOnStateChanged() {
         mCallbackHandler.post(mOnStateChangedRunnable);
     }
@@ -943,6 +994,7 @@ private void dumpLocal(PrintWriter pw) {
                 + TimeUtils.formatUptime(mPendingLightSensorDebounceTime));
         pw.println("  mScreenAutoBrightness=" + mScreenAutoBrightness);
         pw.println("  mUsingScreenAutoBrightness=" + mUsingScreenAutoBrightness);
+        pw.println("  mLastScreenAutoBrightnessGamma=" + mLastScreenAutoBrightnessGamma);
 
         if (mElectronBeamOnAnimator != null) {
             pw.println("  mElectronBeamOnAnimator.isStarted()=" +
diff --git a/services/java/com/android/server/power/DisplayPowerRequest.java b/services/java/com/android/server/power/DisplayPowerRequest.java
@@ -46,13 +46,17 @@ final class DisplayPowerRequest {
     // value to use while waiting for the light sensor to report enough data.
     public int screenBrightness;
 
+    // The screen auto-brightness adjustment factor in the range -1 (dimmer) to 1 (brighter).
+    public float screenAutoBrightnessAdjustment;
+
     // If true, enables automatic brightness control.
     public boolean useAutoBrightness;
 
     public DisplayPowerRequest() {
         screenState = SCREEN_STATE_BRIGHT;
         useProximitySensor = false;
         screenBrightness = PowerManager.BRIGHTNESS_ON;
+        screenAutoBrightnessAdjustment = 0.0f;
         useAutoBrightness = false;
     }
 
@@ -64,6 +68,7 @@ public void copyFrom(DisplayPowerRequest other) {
         screenState = other.screenState;
         useProximitySensor = other.useProximitySensor;
         screenBrightness = other.screenBrightness;
+        screenAutoBrightnessAdjustment = other.screenAutoBrightnessAdjustment;
         useAutoBrightness = other.useAutoBrightness;
     }
 
@@ -78,6 +83,7 @@ public boolean equals(DisplayPowerRequest other) {
                 && screenState == other.screenState
                 && useProximitySensor == other.useProximitySensor
                 && screenBrightness == other.screenBrightness
+                && screenAutoBrightnessAdjustment == other.screenAutoBrightnessAdjustment
                 && useAutoBrightness == other.useAutoBrightness;
     }
 
@@ -91,6 +97,7 @@ public String toString() {
         return "screenState=" + screenState
                 + ", useProximitySensor=" + useProximitySensor
                 + ", screenBrightness=" + screenBrightness
+                + ", screenAutoBrightnessAdjustment=" + screenAutoBrightnessAdjustment
                 + ", useAutoBrightness=" + useAutoBrightness;
     }
 }
diff --git a/services/java/com/android/server/power/PowerManagerService.java b/services/java/com/android/server/power/PowerManagerService.java
@@ -249,6 +249,10 @@ public final class PowerManagerService extends IPowerManager.Stub
     // Use -1 if no value has been set.
     private int mScreenBrightnessSetting;
 
+    // The screen auto-brightness adjustment setting, from -1 to 1.
+    // Use 0 if there is no adjustment.
+    private float mScreenAutoBrightnessAdjustmentSetting;
+
     // The screen brightness mode.
     // One of the Settings.System.SCREEN_BRIGHTNESS_MODE_* constants.
     private int mScreenBrightnessModeSetting;
@@ -263,6 +267,12 @@ public final class PowerManagerService extends IPowerManager.Stub
     // Use -1 to disable.
     private int mTemporaryScreenBrightnessSettingOverride = -1;
 
+    // The screen brightness adjustment setting override from the settings
+    // application to temporarily adjust the auto-brightness adjustment factor
+    // until next updated, in the range -1..1.
+    // Use NaN to disable.
+    private float mTemporaryScreenAutoBrightnessAdjustmentSettingOverride = Float.NaN;
+
     private native void nativeInit();
     private static native void nativeShutdown();
     private static native void nativeReboot(String reason) throws IOException;
@@ -389,6 +399,14 @@ private void updateSettingsLocked() {
             mTemporaryScreenBrightnessSettingOverride = -1;
         }
 
+        final float oldScreenAutoBrightnessAdjustmentSetting =
+                mScreenAutoBrightnessAdjustmentSetting;
+        mScreenAutoBrightnessAdjustmentSetting = Settings.System.getFloat(resolver,
+                Settings.System.SCREEN_AUTO_BRIGHTNESS_ADJ, 0.0f);
+        if (oldScreenAutoBrightnessAdjustmentSetting != mScreenAutoBrightnessAdjustmentSetting) {
+            mTemporaryScreenAutoBrightnessAdjustmentSettingOverride = -1;
+        }
+
         mScreenBrightnessModeSetting = Settings.System.getInt(resolver,
                 Settings.System.SCREEN_BRIGHTNESS_MODE,
                 Settings.System.SCREEN_BRIGHTNESS_MODE_MANUAL);
@@ -1275,6 +1293,7 @@ private void updateDisplayPowerStateLocked(int dirty) {
             }
 
             int screenBrightness = mScreenBrightnessSettingDefault;
+            float screenAutoBrightnessAdjustment = 0.0f;
             boolean autoBrightness = (mScreenBrightnessModeSetting ==
                     Settings.System.SCREEN_BRIGHTNESS_MODE_AUTOMATIC);
             if (isValidBrightness(mScreenBrightnessOverrideFromWindowManager)) {
@@ -1283,14 +1302,26 @@ private void updateDisplayPowerStateLocked(int dirty) {
             } else if (isValidBrightness(mTemporaryScreenBrightnessSettingOverride)) {
                 screenBrightness = mTemporaryScreenBrightnessSettingOverride;
             } else if (isValidBrightness(mScreenBrightnessSetting)) {
-                screenBrightness =  mScreenBrightnessSetting;
+                screenBrightness = mScreenBrightnessSetting;
             }
             if (autoBrightness) {
                 screenBrightness = mScreenBrightnessSettingDefault;
+                if (isValidAutoBrightnessAdjustment(
+                        mTemporaryScreenAutoBrightnessAdjustmentSettingOverride)) {
+                    screenAutoBrightnessAdjustment =
+                            mTemporaryScreenAutoBrightnessAdjustmentSettingOverride;
+                } else if (isValidAutoBrightnessAdjustment(
+                        mScreenAutoBrightnessAdjustmentSetting)) {
+                    screenAutoBrightnessAdjustment = mScreenAutoBrightnessAdjustmentSetting;
+                }
             }
             screenBrightness = Math.max(Math.min(screenBrightness,
                     mScreenBrightnessSettingMaximum), mScreenBrightnessSettingMinimum);
+            screenAutoBrightnessAdjustment = Math.max(Math.min(
+                    screenAutoBrightnessAdjustment, 1.0f), -1.0f);
             mDisplayPowerRequest.screenBrightness = screenBrightness;
+            mDisplayPowerRequest.screenAutoBrightnessAdjustment =
+                    screenAutoBrightnessAdjustment;
             mDisplayPowerRequest.useAutoBrightness = autoBrightness;
 
             mDisplayPowerRequest.useProximitySensor = shouldUseProximitySensorLocked();
@@ -1314,6 +1345,10 @@ private static boolean isValidBrightness(int value) {
         return value >= 0 && value <= 255;
     }
 
+    private static boolean isValidAutoBrightnessAdjustment(float value) {
+        return !Float.isNaN(value);
+    }
+
     private int getDesiredScreenPowerState() {
         if (mWakefulness == WAKEFULNESS_ASLEEP) {
             return DisplayPowerRequest.SCREEN_STATE_OFF;
@@ -1690,15 +1725,32 @@ private void setTemporaryScreenBrightnessSettingOverrideInternal(int brightness)
      *
      * The override will be canceled when the setting value is next updated.
      *
-     * @param adj The overridden brightness, or -1 to disable the override.
+     * @param adj The overridden brightness, or Float.NaN to disable the override.
      *
      * @see Settings.System#SCREEN_AUTO_BRIGHTNESS_ADJ
      */
     @Override // Binder call
     public void setTemporaryScreenAutoBrightnessAdjustmentSettingOverride(float adj) {
-        // Not implemented.
-        // The SCREEN_AUTO_BRIGHTNESS_ADJ setting is not currently supported.
         mContext.enforceCallingOrSelfPermission(android.Manifest.permission.DEVICE_POWER, null);
+
+        final long ident = Binder.clearCallingIdentity();
+        try {
+            setTemporaryScreenAutoBrightnessAdjustmentSettingOverrideInternal(adj);
+        } finally {
+            Binder.restoreCallingIdentity(ident);
+        }
+    }
+
+    private void setTemporaryScreenAutoBrightnessAdjustmentSettingOverrideInternal(float adj) {
+        synchronized (mLock) {
+            // Note: This condition handles NaN because NaN is not equal to any other
+            // value, including itself.
+            if (mTemporaryScreenAutoBrightnessAdjustmentSettingOverride != adj) {
+                mTemporaryScreenAutoBrightnessAdjustmentSettingOverride = adj;
+                mDirty |= DIRTY_SETTINGS;
+                updatePowerStateLocked();
+            }
+        }
     }
 
     /**
@@ -1774,11 +1826,15 @@ protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
                     + isMaximumScreenOffTimeoutFromDeviceAdminEnforcedLocked() + ")");
             pw.println("  mStayOnWhilePluggedInSetting=" + mStayOnWhilePluggedInSetting);
             pw.println("  mScreenBrightnessSetting=" + mScreenBrightnessSetting);
+            pw.println("  mScreenAutoBrightnessAdjustmentSetting="
+                    + mScreenAutoBrightnessAdjustmentSetting);
             pw.println("  mScreenBrightnessModeSetting=" + mScreenBrightnessModeSetting);
             pw.println("  mScreenBrightnessOverrideFromWindowManager="
                     + mScreenBrightnessOverrideFromWindowManager);
             pw.println("  mTemporaryScreenBrightnessSettingOverride="
                     + mTemporaryScreenBrightnessSettingOverride);
+            pw.println("  mTemporaryScreenAutoBrightnessAdjustmentSettingOverride="
+                    + mTemporaryScreenAutoBrightnessAdjustmentSettingOverride);
             pw.println("  mScreenBrightnessSettingMinimum=" + mScreenBrightnessSettingMinimum);
             pw.println("  mScreenBrightnessSettingMaximum=" + mScreenBrightnessSettingMaximum);
             pw.println("  mScreenBrightnessSettingDefault=" + mScreenBrightnessSettingDefault);
