Reduce screen on latency, eliminate flashes.

Always use the ElectronBeam now, even when we are only animating
the backlight so that we will have a black surface remaining
on the screen after the screen turns off.

When turning on the screen, keep the black surface showing until
we unblock screen on then dismiss it as usual.

This change eliminates the flashing of old display content when
the screen is turned on.  It also helps to conceal some of the
latency of turning the screen on.  We always turn the screen on
immediately (even when screen on has nominally been blocked) and
rely on the black surface to hide the screen contents until the
last moment.  Dismissing the black surface is practically
instantaneous compared to turning the screen on.

Bug: 7299370
Bug: 7139924
Change-Id: I57d13287acd05bd0a48811095bb02dc7bc7cbeb6

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);
             }