Merge changes I76513387,I335fb671 into gingerbread (ba799098) · Commits · e / os / android_frameworks_base

core/res/res/values/config.xml

+6 −0

Original line number	Diff line number	Diff line
		@@ -149,9 +149,15 @@
		Software implementation will be used if config_hardware_auto_brightness_available is not set -->
		<bool name="config_automatic_brightness_available">false</bool>

		<!-- Don't name config resources like this. It should look like config_annoyDianne -->
		<bool name="config_annoy_dianne">true</bool>

		<!-- If this is true, the screen will come on when you unplug usb/power/whatever. -->
		<bool name="config_unplugTurnsOnScreen">false</bool>

		<!-- If this is true, the screen will fade off. -->
		<bool name="config_animateScreenLights">true</bool>

		<!-- XXXXXX END OF RESOURCES USING WRONG NAMING CONVENTION -->

		<!-- The number of degrees to rotate the display when the keyboard is open. -->

include/surfaceflinger/ISurfaceComposer.h

+4 −1

Original line number	Diff line number	Diff line
		@@ -118,6 +118,8 @@ public:
		uint32_t* width, uint32_t* height, PixelFormat* format,
		uint32_t reqWidth, uint32_t reqHeight) = 0;

		virtual status_t turnElectronBeamOff(int32_t mode) = 0;

		/* Signal surfaceflinger that there might be some work to do
		* This is an ASYNCHRONOUS call.
		*/
		@@ -142,7 +144,8 @@ public:
		FREEZE_DISPLAY,
		UNFREEZE_DISPLAY,
		SIGNAL,
		CAPTURE_SCREEN
		CAPTURE_SCREEN,
		TURN_ELECTRON_BEAM_OFF
		};

		virtual status_t onTransact( uint32_t code,

libs/surfaceflinger_client/ISurfaceComposer.cpp

+15 −0

Original line number	Diff line number	Diff line
		@@ -142,6 +142,15 @@ public:
		return reply.readInt32();
		}

		virtual status_t turnElectronBeamOff(int32_t mode)
		{
		Parcel data, reply;
		data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
		data.writeInt32(mode);
		remote()->transact(BnSurfaceComposer::TURN_ELECTRON_BEAM_OFF, data, &reply);
		return reply.readInt32();
		}

		virtual void signal() const
		{
		Parcel data, reply;
		@@ -224,6 +233,12 @@ status_t BnSurfaceComposer::onTransact(
		reply->writeInt32(f);
		reply->writeInt32(res);
		} break;
		case TURN_ELECTRON_BEAM_OFF: {
		CHECK_INTERFACE(ISurfaceComposer, data, reply);
		int32_t mode = data.readInt32();
		status_t res = turnElectronBeamOff(mode);
		reply->writeInt32(res);
		}
		default:
		return BBinder::onTransact(code, data, reply, flags);
		}

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

+168 −212

Original line number	Diff line number	Diff line
		@@ -141,9 +141,7 @@ class PowerManagerService extends IPowerManager.Stub
		// used for noChangeLights in setPowerState()
		private static final int LIGHTS_MASK = SCREEN_BRIGHT_BIT \| BUTTON_BRIGHT_BIT \| KEYBOARD_BRIGHT_BIT;

		static final boolean ANIMATE_SCREEN_LIGHTS = true;
		static final boolean ANIMATE_BUTTON_LIGHTS = false;
		static final boolean ANIMATE_KEYBOARD_LIGHTS = false;
		boolean mAnimateScreenLights = true;

		static final int ANIM_STEPS = 60/4;
		// Slower animation for autobrightness changes
		@@ -201,15 +199,12 @@ class PowerManagerService extends IPowerManager.Stub
		private UnsynchronizedWakeLock mPreventScreenOnPartialLock;
		private UnsynchronizedWakeLock mProximityPartialLock;
		private HandlerThread mHandlerThread;
		private HandlerThread mScreenOffThread;
		private Handler mScreenOffHandler;
		private Handler mHandler;
		private final TimeoutTask mTimeoutTask = new TimeoutTask();
		private final LightAnimator mLightAnimator = new LightAnimator();
		private final BrightnessState mScreenBrightness
		= new BrightnessState(SCREEN_BRIGHT_BIT);
		private final BrightnessState mKeyboardBrightness
		= new BrightnessState(KEYBOARD_BRIGHT_BIT);
		private final BrightnessState mButtonBrightness
		= new BrightnessState(BUTTON_BRIGHT_BIT);
		private boolean mStillNeedSleepNotification;
		private boolean mIsPowered = false;
		private IActivityManager mActivityService;
		@@ -261,6 +256,7 @@ class PowerManagerService extends IPowerManager.Stub

		private native void nativeInit();
		private native void nativeSetPowerState(boolean screenOn, boolean screenBright);
		private native void nativeStartSurfaceFlingerAnimation();

		/*
		static PrintStream mLog;
		@@ -485,6 +481,35 @@ class PowerManagerService extends IPowerManager.Stub
		mKeyboardLight = lights.getLight(LightsService.LIGHT_ID_KEYBOARD);
		mAttentionLight = lights.getLight(LightsService.LIGHT_ID_ATTENTION);

		nativeInit();
		synchronized (mLocks) {
		updateNativePowerStateLocked();
		}

		mInitComplete = false;
		mScreenOffThread = new HandlerThread("PowerManagerService.mScreenOffThread") {
		@Override
		protected void onLooperPrepared() {
		mScreenOffHandler = new Handler();
		synchronized (mScreenOffThread) {
		mInitComplete = true;
		mScreenOffThread.notifyAll();
		}
		}
		};
		mScreenOffThread.start();

		synchronized (mScreenOffThread) {
		while (!mInitComplete) {
		try {
		mScreenOffThread.wait();
		} catch (InterruptedException e) {
		// Ignore
		}
		}
		}

		mInitComplete = false;
		mHandlerThread = new HandlerThread("PowerManagerService") {
		@Override
		protected void onLooperPrepared() {
		@@ -531,6 +556,9 @@ class PowerManagerService extends IPowerManager.Stub

		Resources resources = mContext.getResources();

		mAnimateScreenLights = resources.getBoolean(
		com.android.internal.R.bool.config_animateScreenLights);

		mUnplugTurnsOnScreen = resources.getBoolean(
		com.android.internal.R.bool.config_unplugTurnsOnScreen);

		@@ -1093,8 +1121,6 @@ class PowerManagerService extends IPowerManager.Stub
		pw.println(" mUseSoftwareAutoBrightness=" + mUseSoftwareAutoBrightness);
		pw.println(" mAutoBrightessEnabled=" + mAutoBrightessEnabled);
		mScreenBrightness.dump(pw, " mScreenBrightness: ");
		mKeyboardBrightness.dump(pw, " mKeyboardBrightness: ");
		mButtonBrightness.dump(pw, " mButtonBrightness: ");

		int N = mLocks.size();
		pw.println();
		@@ -1724,7 +1750,8 @@ class PowerManagerService extends IPowerManager.Stub
		// I don't think we need to check the current state here because all of these
		// Power.setScreenState and sendNotificationLocked can both handle being
		// called multiple times in the same state. -joeo
		EventLog.writeEvent(EventLogTags.POWER_SCREEN_STATE, 0, reason, mTotalTouchDownTime, mTouchCycles);
		EventLog.writeEvent(EventLogTags.POWER_SCREEN_STATE, 0, reason, mTotalTouchDownTime,
		mTouchCycles);
		mLastTouchDown = 0;
		int err = setScreenStateLocked(false);
		if (err == 0) {
		@@ -1754,52 +1781,24 @@ class PowerManagerService extends IPowerManager.Stub
		int onMask = 0;

		int preferredBrightness = getPreferredBrightness();
		boolean startAnimation = false;

		if ((difference & KEYBOARD_BRIGHT_BIT) != 0) {
		if (ANIMATE_KEYBOARD_LIGHTS) {
		if ((newState & KEYBOARD_BRIGHT_BIT) == 0) {
		mKeyboardBrightness.setTargetLocked(Power.BRIGHTNESS_OFF,
		ANIM_STEPS, INITIAL_KEYBOARD_BRIGHTNESS,
		Power.BRIGHTNESS_ON);
		} else {
		mKeyboardBrightness.setTargetLocked(Power.BRIGHTNESS_ON,
		ANIM_STEPS, INITIAL_KEYBOARD_BRIGHTNESS,
		Power.BRIGHTNESS_OFF);
		}
		startAnimation = true;
		} else {
		if ((newState & KEYBOARD_BRIGHT_BIT) == 0) {
		offMask \|= KEYBOARD_BRIGHT_BIT;
		} else {
		onMask \|= KEYBOARD_BRIGHT_BIT;
		}
		}
		}

		if ((difference & BUTTON_BRIGHT_BIT) != 0) {
		if (ANIMATE_BUTTON_LIGHTS) {
		if ((newState & BUTTON_BRIGHT_BIT) == 0) {
		mButtonBrightness.setTargetLocked(Power.BRIGHTNESS_OFF,
		ANIM_STEPS, INITIAL_BUTTON_BRIGHTNESS,
		Power.BRIGHTNESS_ON);
		} else {
		mButtonBrightness.setTargetLocked(Power.BRIGHTNESS_ON,
		ANIM_STEPS, INITIAL_BUTTON_BRIGHTNESS,
		Power.BRIGHTNESS_OFF);
		}
		startAnimation = true;
		} else {
		if ((newState & BUTTON_BRIGHT_BIT) == 0) {
		offMask \|= BUTTON_BRIGHT_BIT;
		} else {
		onMask \|= BUTTON_BRIGHT_BIT;
		}
		}
		}

		if ((difference & (SCREEN_ON_BIT \| SCREEN_BRIGHT_BIT)) != 0) {
		if (ANIMATE_SCREEN_LIGHTS) {
		int nominalCurrentValue = -1;
		// If there was an actual difference in the light state, then
		// figure out the "ideal" current value based on the previous
		@@ -1869,30 +1868,8 @@ class PowerManagerService extends IPowerManager.Stub
		} finally {
		Binder.restoreCallingIdentity(identity);
		}
		if (mScreenBrightness.setTargetLocked(brightness,
		steps, INITIAL_SCREEN_BRIGHTNESS, nominalCurrentValue)) {
		startAnimation = true;
		}
		} else {
		if ((newState & SCREEN_BRIGHT_BIT) == 0) {
		// dim or turn off backlight, depending on if the screen is on
		if ((newState & SCREEN_ON_BIT) == 0) {
		offMask \|= SCREEN_BRIGHT_BIT;
		} else {
		dimMask \|= SCREEN_BRIGHT_BIT;
		}
		} else {
		onMask \|= SCREEN_BRIGHT_BIT;
		}
		}
		}

		if (startAnimation) {
		if (mSpew) {
		Slog.i(TAG, "Scheduling light animator!");
		}
		mHandler.removeCallbacks(mLightAnimator);
		mHandler.post(mLightAnimator);
		mScreenBrightness.setTargetLocked(brightness, steps,
		INITIAL_SCREEN_BRIGHTNESS, nominalCurrentValue);
		}

		if (offMask != 0) {
		@@ -1934,7 +1911,7 @@ class PowerManagerService extends IPowerManager.Stub
		}
		}

		class BrightnessState {
		class BrightnessState implements Runnable {
		final int mask;

		boolean initialized;
		@@ -1954,13 +1931,13 @@ class PowerManagerService extends IPowerManager.Stub
		+ " delta=" + delta);
		}

		boolean setTargetLocked(int target, int stepsToTarget, int initialValue,
		void setTargetLocked(int target, int stepsToTarget, int initialValue,
		int nominalCurrentValue) {
		if (!initialized) {
		initialized = true;
		curValue = (float)initialValue;
		} else if (targetValue == target) {
		return false;
		return;
		}
		targetValue = target;
		delta = (targetValue -
		@@ -1974,7 +1951,12 @@ class PowerManagerService extends IPowerManager.Stub
		+ noticeMe);
		}
		animating = true;
		return true;

		if (mSpew) {
		Slog.i(TAG, "scheduling light animator");
		}
		mScreenOffHandler.removeCallbacks(this);
		mScreenOffHandler.post(this);
		}

		boolean stepLocked() {
		@@ -2000,32 +1982,50 @@ class PowerManagerService extends IPowerManager.Stub
		more = false;
		}
		}
		//Slog.i(TAG, "Animating brightess " + curIntValue + ": " + mask);
		if (mSpew) Slog.d(TAG, "Animating curIntValue=" + curIntValue + ": " + mask);
		setLightBrightness(mask, curIntValue);
		finishAnimation(more, curIntValue);
		return more;
		}

		void jumpToTarget() {
		if (mSpew) Slog.d(TAG, "jumpToTarget targetValue=" + targetValue + ": " + mask);
		setLightBrightness(mask, targetValue);
		final int tv = targetValue;
		curValue = tv;
		targetValue = -1;
		finishAnimation(false, tv);
		}

		private void finishAnimation(boolean more, int curIntValue) {
		animating = more;
		if (!more) {
		if (mask == SCREEN_BRIGHT_BIT && curIntValue == Power.BRIGHTNESS_OFF) {
		screenOffFinishedAnimatingLocked(mScreenOffReason);
		}
		}
		return more;
		}
		}

		private class LightAnimator implements Runnable {
		public void run() {
		if (mAnimateScreenLights) {
		synchronized (mLocks) {
		long now = SystemClock.uptimeMillis();
		boolean more = mScreenBrightness.stepLocked();
		if (mKeyboardBrightness.stepLocked()) {
		more = true;
		if (more) {
		mScreenOffHandler.postAtTime(this, now+(1000/60));
		}
		if (mButtonBrightness.stepLocked()) {
		more = true;
		}
		if (more) {
		mHandler.postAtTime(mLightAnimator, now+(1000/60));
		} else {
		boolean animate;
		boolean jump;
		synchronized (mLocks) {
		jump = animating; // we haven't already run this animation
		animate = jump && targetValue == Power.BRIGHTNESS_OFF; // we're turning off
		}
		if (animate) {
		nativeStartSurfaceFlingerAnimation();
		}
		mScreenBrightness.jumpToTarget();
		}
		}
		}
		@@ -2343,51 +2343,17 @@ class PowerManagerService extends IPowerManager.Stub
		Slog.d(TAG, "keyboardValue " + keyboardValue);
		}

		boolean startAnimation = false;
		if (mAutoBrightessEnabled && mScreenBrightnessOverride < 0) {
		if (ANIMATE_SCREEN_LIGHTS) {
		if (mScreenBrightness.setTargetLocked(lcdValue,
		AUTOBRIGHTNESS_ANIM_STEPS, INITIAL_SCREEN_BRIGHTNESS,
		(int)mScreenBrightness.curValue)) {
		startAnimation = true;
		}
		} else {
		int brightnessMode = (mAutoBrightessEnabled
		? LightsService.BRIGHTNESS_MODE_SENSOR
		: LightsService.BRIGHTNESS_MODE_USER);
		mLcdLight.setBrightness(lcdValue, brightnessMode);
		}
		mScreenBrightness.setTargetLocked(lcdValue, AUTOBRIGHTNESS_ANIM_STEPS,
		INITIAL_SCREEN_BRIGHTNESS, (int)mScreenBrightness.curValue);
		}
		if (mButtonBrightnessOverride < 0) {
		if (ANIMATE_BUTTON_LIGHTS) {
		if (mButtonBrightness.setTargetLocked(buttonValue,
		AUTOBRIGHTNESS_ANIM_STEPS, INITIAL_BUTTON_BRIGHTNESS,
		(int)mButtonBrightness.curValue)) {
		startAnimation = true;
		}
		} else {
		mButtonLight.setBrightness(buttonValue);
		}
		}
		if (mButtonBrightnessOverride < 0 \|\| !mKeyboardVisible) {
		if (ANIMATE_KEYBOARD_LIGHTS) {
		if (mKeyboardBrightness.setTargetLocked(keyboardValue,
		AUTOBRIGHTNESS_ANIM_STEPS, INITIAL_BUTTON_BRIGHTNESS,
		(int)mKeyboardBrightness.curValue)) {
		startAnimation = true;
		}
		} else {
		mKeyboardLight.setBrightness(keyboardValue);
		}
		}
		if (startAnimation) {
		if (mDebugLightSensor) {
		Slog.i(TAG, "lightSensorChangedLocked scheduling light animator");
		}
		mHandler.removeCallbacks(mLightAnimator);
		mHandler.post(mLightAnimator);
		}
		}
		}
		}

		@@ -2753,6 +2719,7 @@ class PowerManagerService extends IPowerManager.Stub
		}
		}

		// for watchdog
		public void monitor() {
		synchronized (mLocks) { }
		}
		@@ -2772,6 +2739,7 @@ class PowerManagerService extends IPowerManager.Stub
		public void setBacklightBrightness(int brightness) {
		mContext.enforceCallingOrSelfPermission(android.Manifest.permission.DEVICE_POWER, null);
		// Don't let applications turn the screen all the way off
		synchronized (mLocks) {
		brightness = Math.max(brightness, Power.BRIGHTNESS_DIM);
		mLcdLight.setBrightness(brightness);
		mKeyboardLight.setBrightness(mKeyboardVisible ? brightness : 0);
		@@ -2786,20 +2754,8 @@ class PowerManagerService extends IPowerManager.Stub
		}

		// update our animation state
		if (ANIMATE_SCREEN_LIGHTS) {
		mScreenBrightness.curValue = brightness;
		mScreenBrightness.animating = false;
		mScreenBrightness.targetValue = -1;
		}
		if (ANIMATE_KEYBOARD_LIGHTS) {
		mKeyboardBrightness.curValue = brightness;
		mKeyboardBrightness.animating = false;
		mKeyboardBrightness.targetValue = -1;
		}
		if (ANIMATE_BUTTON_LIGHTS) {
		mButtonBrightness.curValue = brightness;
		mButtonBrightness.animating = false;
		mButtonBrightness.targetValue = -1;
		mScreenBrightness.targetValue = brightness;
		mScreenBrightness.jumpToTarget();
		}
		}

services/jni/Android.mk

+2 −1

Original line number	Diff line number	Diff line
		@@ -23,7 +23,8 @@ LOCAL_SHARED_LIBRARIES := \
		libnativehelper \
		libsystem_server \
		libutils \
		libui
		libui \
		libsurfaceflinger_client

		ifeq ($(TARGET_SIMULATOR),true)
		ifeq ($(TARGET_OS),linux)