am 9302251: Merge "Reduce screen on latency, eliminate flashes." into jb-mr1-dev

* commit '9302251e3a09810164895237a6a2e8ac4987c3c0':
  Reduce screen on latency, eliminate flashes.

Author: Jeff Brown

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

@@ -271,6 +271,12 @@ final class DisplayPowerController {
     // When the screen turns on again, we report user activity to the power manager.
     private boolean mScreenOffBecauseOfProximity;
 
+    // True if the screen on is being blocked.
+    private boolean mScreenOnWasBlocked;
+
+    // The elapsed real time when the screen on was blocked.
+    private long mScreenOnBlockStartRealTime;
+
     // Set to true if the light sensor is enabled.
     private boolean mLightSensorEnabled;
 
@@ -513,7 +519,7 @@ private void initialize() {
         final Executor executor = AsyncTask.THREAD_POOL_EXECUTOR;
         Display display = mDisplayManager.getDisplay(Display.DEFAULT_DISPLAY);
         mPowerState = new DisplayPowerState(
-                mElectronBeamAnimatesBacklightConfig ? null : new ElectronBeam(display),
+                new ElectronBeam(display),
                 new PhotonicModulator(executor,
                         mLights.getLight(LightsService.LIGHT_ID_BACKLIGHT),
                         mSuspendBlocker));
@@ -553,7 +559,6 @@ private void updatePowerState() {
         final boolean mustNotify;
         boolean mustInitialize = false;
         boolean updateAutoBrightness = mTwilightChanged;
-        boolean screenOnWasBlocked = false;
         mTwilightChanged = false;
 
         synchronized (mLock) {
@@ -662,18 +667,24 @@ private void updatePowerState() {
                 // It is relatively short but if we cancel it and switch to the
                 // on animation immediately then the results are pretty ugly.
                 if (!mElectronBeamOffAnimator.isStarted()) {
-                    if (mPowerRequest.blockScreenOn && !mPowerState.isScreenOn()) {
-                        if (DEBUG) {
-                            Slog.d(TAG, "Blocked screen on while screen currently off.");
-                        }
-                        screenOnWasBlocked = true;
+                    // Turn the screen on.  The contents of the screen may not yet
+                    // be visible if the electron beam has not been dismissed because
+                    // its last frame of animation is solid black.
+                    setScreenOn(true);
+
+                    if (mPowerRequest.blockScreenOn
+                            && mPowerState.getElectronBeamLevel() == 0.0f) {
+                        blockScreenOn();
                     } else {
-                        setScreenOn(true);
+                        unblockScreenOn();
                         if (USE_ELECTRON_BEAM_ON_ANIMATION) {
                             if (!mElectronBeamOnAnimator.isStarted()) {
                                 if (mPowerState.getElectronBeamLevel() == 1.0f) {
                                     mPowerState.dismissElectronBeam();
-                                } else if (mPowerState.prepareElectronBeam(true)) {
+                                } else if (mPowerState.prepareElectronBeam(
+                                        mElectronBeamAnimatesBacklightConfig ?
+                                                ElectronBeam.MODE_BLANK :
+                                                        ElectronBeam.MODE_WARM_UP)) {
                                     mElectronBeamOnAnimator.start();
                                 } else {
                                     mElectronBeamOnAnimator.end();
@@ -684,22 +695,6 @@ private void updatePowerState() {
                             mPowerState.dismissElectronBeam();
                         }
                     }
-                } else {
-                    // FIXME: If the electron beam off animation is playing then we have a bit
-                    // of a problem.  The window manager policy would only have requested
-                    // to block screen on if it was about to start preparing the keyguard.
-                    // It's already too late to do anything about that.  Ideally we would
-                    // let the animation play out first but that would require making
-                    // some pretty deep changes to the power manager and we don't have
-                    // time just now.  For now, short-circuit the animation and get ready.
-                    if (mPowerRequest.blockScreenOn) {
-                        if (DEBUG) {
-                            Slog.d(TAG, "Blocked screen on while screen off animation running.");
-                        }
-                        screenOnWasBlocked = true;
-                        setScreenOn(false);
-                        mElectronBeamOffAnimator.end();
-                    }
                 }
             } else {
                 // Want screen off.
@@ -708,7 +703,10 @@ private void updatePowerState() {
                     if (!mElectronBeamOffAnimator.isStarted()) {
                         if (mPowerState.getElectronBeamLevel() == 0.0f) {
                             setScreenOn(false);
-                        } else if (mPowerState.prepareElectronBeam(false)
+                        } else if (mPowerState.prepareElectronBeam(
+                                mElectronBeamAnimatesBacklightConfig ?
+                                        ElectronBeam.MODE_BLANK :
+                                                ElectronBeam.MODE_COOL_DOWN)
                                 && mPowerState.isScreenOn()) {
                             mElectronBeamOffAnimator.start();
                         } else {
@@ -723,7 +721,7 @@ private void updatePowerState() {
         // We mostly care about the screen state here, ignoring brightness changes
         // which will be handled asynchronously.
         if (mustNotify
-                && !screenOnWasBlocked
+                && !mScreenOnWasBlocked
                 && !mElectronBeamOnAnimator.isStarted()
                 && !mElectronBeamOffAnimator.isStarted()
                 && mPowerState.waitUntilClean(mCleanListener)) {
@@ -740,6 +738,26 @@ private void updatePowerState() {
         }
     }
 
+    private void blockScreenOn() {
+        if (!mScreenOnWasBlocked) {
+            mScreenOnWasBlocked = true;
+            if (DEBUG) {
+                Slog.d(TAG, "Blocked screen on.");
+                mScreenOnBlockStartRealTime = SystemClock.elapsedRealtime();
+            }
+        }
+    }
+
+    private void unblockScreenOn() {
+        if (mScreenOnWasBlocked) {
+            mScreenOnWasBlocked = false;
+            if (DEBUG) {
+                Slog.d(TAG, "Unblocked screen on after " +
+                        (SystemClock.elapsedRealtime() - mScreenOnBlockStartRealTime) + " ms");
+            }
+        }
+    }
+
     private void setScreenOn(boolean on) {
         if (!mPowerState.isScreenOn() == on) {
             mPowerState.setScreenOn(on);

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

@@ -52,11 +52,14 @@ final class DisplayPowerRequest {
     // If true, enables automatic brightness control.
     public boolean useAutoBrightness;
 
-    // If true, prevents the screen from turning on if it is currently off.
-    // The display does not enter a "ready" state if this flag is true and the screen
-    // is off and is being prevented from turning on.  The window manager policy blocks
-    // screen on while it prepares the keyguard to prevent the user from seeing
-    // intermediate updates.
+    // If true, prevents the screen from completely turning on if it is currently off.
+    // The display does not enter a "ready" state if this flag is true and screen on is
+    // blocked.  The window manager policy blocks screen on while it prepares the keyguard to
+    // prevent the user from seeing intermediate updates.
+    //
+    // Technically, we may not block the screen itself from turning on (because that introduces
+    // extra unnecessary latency) but we do prevent content on screen from becoming
+    // visible to the user.
     public boolean blockScreenOn;
 
     public DisplayPowerRequest() {

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

@@ -50,7 +50,7 @@ final class DisplayPowerState {
     private static final int DIRTY_BRIGHTNESS = 1 << 2;
 
     private final Choreographer mChoreographer;
-    private final ElectronBeam mElectronBeam; // may be null if only animating backlights
+    private final ElectronBeam mElectronBeam;
     private final PhotonicModulator mScreenBrightnessModulator;
 
     private int mDirty;
@@ -130,26 +130,19 @@ public boolean isScreenOn() {
      * This method should be called before starting an animation because it
      * can take a fair amount of time to prepare the electron beam surface.
      *
-     * @param warmUp True if the electron beam should start warming up.
+     * @param mode The electron beam animation mode to prepare.
      * @return True if the electron beam was prepared.
      */
-    public boolean prepareElectronBeam(boolean warmUp) {
-        if (mElectronBeam != null) {
-            boolean success = mElectronBeam.prepare(warmUp);
-            invalidate(DIRTY_ELECTRON_BEAM);
-            return success;
-        } else {
-            return true;
-        }
+    public boolean prepareElectronBeam(int mode) {
+        invalidate(DIRTY_ELECTRON_BEAM);
+        return mElectronBeam.prepare(mode);
     }
 
     /**
      * Dismisses the electron beam surface.
      */
     public void dismissElectronBeam() {
-        if (mElectronBeam != null) {
-            mElectronBeam.dismiss();
-        }
+        mElectronBeam.dismiss();
     }
 
     /**
@@ -230,9 +223,7 @@ public void dump(PrintWriter pw) {
         pw.println("  mScreenBrightness=" + mScreenBrightness);
         pw.println("  mElectronBeamLevel=" + mElectronBeamLevel);
 
-        if (mElectronBeam != null) {
-            mElectronBeam.dump(pw);
-        }
+        mElectronBeam.dump(pw);
     }
 
     private void invalidate(int dirty) {
@@ -251,7 +242,7 @@ private void apply() {
                 PowerManagerService.nativeSetScreenState(false);
             }
 
-            if ((mDirty & DIRTY_ELECTRON_BEAM) != 0 && mElectronBeam != null) {
+            if ((mDirty & DIRTY_ELECTRON_BEAM) != 0) {
                 mElectronBeam.draw(mElectronBeamLevel);
             }