Merge "Add support for auto-brightness adjust, but leave it disabled." into jb-mr1-dev (ae25108a) · Commits · e / os / android_frameworks_base

services/java/com/android/server/power/DisplayPowerController.java

+68 −16

Original line number	Diff line number	Diff line
		@@ -32,7 +32,10 @@ import android.os.AsyncTask;
		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 @@ final class DisplayPowerController {
		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 @@ final class DisplayPowerController {
		// 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 @@ final class DisplayPowerController {
		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 @@ final class DisplayPowerController {
		// 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 @@ final class DisplayPowerController {
		// 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 @@ final class DisplayPowerController {
		}
		}

		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 @@ final class DisplayPowerController {
		}
		}

		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 @@ final class DisplayPowerController {
		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 @@ final class DisplayPowerController {
		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 @@ final class DisplayPowerController {
		+ TimeUtils.formatUptime(mPendingLightSensorDebounceTime));
		pw.println(" mScreenAutoBrightness=" + mScreenAutoBrightness);
		pw.println(" mUsingScreenAutoBrightness=" + mUsingScreenAutoBrightness);
		pw.println(" mLastScreenAutoBrightnessGamma=" + mLastScreenAutoBrightnessGamma);

		if (mElectronBeamOnAnimator != null) {
		pw.println(" mElectronBeamOnAnimator.isStarted()=" +

services/java/com/android/server/power/DisplayPowerRequest.java

+7 −0

Original line number	Diff line number	Diff line
		@@ -46,6 +46,9 @@ 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;

		@@ -53,6 +56,7 @@ final class DisplayPowerRequest {
		screenState = SCREEN_STATE_BRIGHT;
		useProximitySensor = false;
		screenBrightness = PowerManager.BRIGHTNESS_ON;
		screenAutoBrightnessAdjustment = 0.0f;
		useAutoBrightness = false;
		}

		@@ -64,6 +68,7 @@ final class DisplayPowerRequest {
		screenState = other.screenState;
		useProximitySensor = other.useProximitySensor;
		screenBrightness = other.screenBrightness;
		screenAutoBrightnessAdjustment = other.screenAutoBrightnessAdjustment;
		useAutoBrightness = other.useAutoBrightness;
		}

		@@ -78,6 +83,7 @@ final class DisplayPowerRequest {
		&& screenState == other.screenState
		&& useProximitySensor == other.useProximitySensor
		&& screenBrightness == other.screenBrightness
		&& screenAutoBrightnessAdjustment == other.screenAutoBrightnessAdjustment
		&& useAutoBrightness == other.useAutoBrightness;
		}

		@@ -91,6 +97,7 @@ final class DisplayPowerRequest {
		return "screenState=" + screenState
		+ ", useProximitySensor=" + useProximitySensor
		+ ", screenBrightness=" + screenBrightness
		+ ", screenAutoBrightnessAdjustment=" + screenAutoBrightnessAdjustment
		+ ", useAutoBrightness=" + useAutoBrightness;
		}
		}

services/java/com/android/server/power/PowerManagerService.java

+60 −4

Original line number	Diff line number	Diff line
		@@ -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 @@ public final class PowerManagerService extends IPowerManager.Stub
		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 @@ public final class PowerManagerService extends IPowerManager.Stub
		}

		int screenBrightness = mScreenBrightnessSettingDefault;
		float screenAutoBrightnessAdjustment = 0.0f;
		boolean autoBrightness = (mScreenBrightnessModeSetting ==
		Settings.System.SCREEN_BRIGHTNESS_MODE_AUTOMATIC);
		if (isValidBrightness(mScreenBrightnessOverrideFromWindowManager)) {
		@@ -1287,10 +1306,22 @@ public final class PowerManagerService extends IPowerManager.Stub
		}
		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 @@ public final class PowerManagerService extends IPowerManager.Stub
		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 @@ public final class PowerManagerService extends IPowerManager.Stub
		*
		* 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 @@ public final class PowerManagerService extends IPowerManager.Stub
		+ 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);