Coordinate screen on with the window manager.

Bug: 7267457
Change-Id: Ic2c322253639e1f0b2e4e72a7b145025d0240f93

Author: Jeff Brown

core/java/android/view/IWindowManager.aidl

@@ -201,8 +201,9 @@ interface IWindowManager
 
     /**
      * Block until the given window has been drawn to the screen.
+     * Returns true if really waiting, false if the window does not exist.
      */
-    void waitForWindowDrawn(IBinder token, in IRemoteCallback callback);
+    boolean waitForWindowDrawn(IBinder token, in IRemoteCallback callback);
 
     /**
      * Device has a software navigation bar (separate from the status bar).

core/java/android/view/WindowManagerPolicy.java

@@ -1058,18 +1058,13 @@ interface OnKeyguardExitResult {
      * Called when we have started keeping the screen on because a window
      * requesting this has become visible.
      */
-    public void screenOnStartedLw();
+    public void keepScreenOnStartedLw();
 
     /**
      * Called when we have stopped keeping the screen on because the last window
      * requesting this is no longer visible.
      */
-    public void screenOnStoppedLw();
-
-    /**
-     * Return false to disable key repeat events from being generated.
-     */
-    public boolean allowKeyRepeat();
+    public void keepScreenOnStoppedLw();
 
     /**
      * Inform the policy that the user has chosen a preferred orientation ("rotation lock"). 

policy/src/com/android/internal/policy/impl/PhoneWindowManager.java

@@ -3580,7 +3580,7 @@ public void onReceive(Context context, Intent intent) {
         }
     };
 
-    /** {@inheritDoc} */
+    @Override
     public void screenTurnedOff(int why) {
         EventLog.writeEvent(70000, 0);
         synchronized (mLock) {
@@ -3596,72 +3596,91 @@ public void screenTurnedOff(int why) {
         }
     }
 
-    /** {@inheritDoc} */
+    @Override
     public void screenTurningOn(final ScreenOnListener screenOnListener) {
         EventLog.writeEvent(70000, 1);
         if (false) {
             RuntimeException here = new RuntimeException("here");
             here.fillInStackTrace();
             Slog.i(TAG, "Screen turning on...", here);
         }
-        if (screenOnListener != null) {
-            if (mKeyguardMediator != null) {
-                try {
-                    mWindowManager.setEventDispatching(true);
-                } catch (RemoteException unhandled) {
-                }
+
+        synchronized (mLock) {
+            mScreenOnEarly = true;
+            updateOrientationListenerLp();
+            updateLockScreenTimeout();
+        }
+
+        try {
+            mWindowManager.setEventDispatching(true);
+        } catch (RemoteException unhandled) {
+        }
+
+        waitForKeyguard(screenOnListener);
+    }
+
+    private void waitForKeyguard(final ScreenOnListener screenOnListener) {
+        if (mKeyguardMediator != null) {
+            if (screenOnListener != null) {
                 mKeyguardMediator.onScreenTurnedOn(new KeyguardViewManager.ShowListener() {
-                    @Override public void onShown(IBinder windowToken) {
-                        if (windowToken != null) {
-                            try {
-                                mWindowManager.waitForWindowDrawn(windowToken,
-                                        new IRemoteCallback.Stub() {
-                                    @Override public void sendResult(Bundle data) {
-                                        Slog.i(TAG, "Lock screen displayed!");
-                                        screenOnListener.onScreenOn();
-                                        synchronized (mLock) {
-                                            mScreenOnFully = true;
-                                        }
-                                    }
-                                });
-                            } catch (RemoteException e) {
-                            }
-                        } else {
-                            Slog.i(TAG, "No lock screen!");
-                            screenOnListener.onScreenOn();
-                            synchronized (mLock) {
-                                mScreenOnFully = true;
-                            }
-                        }
+                    @Override
+                    public void onShown(IBinder windowToken) {
+                        waitForKeyguardWindowDrawn(windowToken, screenOnListener);
                     }
                 });
-            }
-        } else {
-            if (mKeyguardMediator != null) {
-                // Must set mScreenOn = true.
+                return;
+            } else {
                 mKeyguardMediator.onScreenTurnedOn(null);
             }
-            synchronized (mLock) {
-                mScreenOnFully = true;
+        } else {
+            Slog.i(TAG, "No keyguard mediator!");
+        }
+        finishScreenTurningOn(screenOnListener);
+    }
+
+    private void waitForKeyguardWindowDrawn(IBinder windowToken,
+            final ScreenOnListener screenOnListener) {
+        if (windowToken != null) {
+            try {
+                if (mWindowManager.waitForWindowDrawn(
+                        windowToken, new IRemoteCallback.Stub() {
+                    @Override
+                    public void sendResult(Bundle data) {
+                        Slog.i(TAG, "Lock screen displayed!");
+                        finishScreenTurningOn(screenOnListener);
+                    }
+                })) {
+                    return;
+                }
+            } catch (RemoteException ex) {
+                // Can't happen in system process.
             }
         }
+
+        Slog.i(TAG, "No lock screen!");
+        finishScreenTurningOn(screenOnListener);
+    }
+
+    private void finishScreenTurningOn(ScreenOnListener screenOnListener) {
         synchronized (mLock) {
-            mScreenOnEarly = true;
-            updateOrientationListenerLp();
-            updateLockScreenTimeout();
+            mScreenOnFully = true;
+        }
+
+        if (screenOnListener != null) {
+            screenOnListener.onScreenOn();
         }
     }
 
-    /** {@inheritDoc} */
+    @Override
     public boolean isScreenOnEarly() {
         return mScreenOnEarly;
     }
-    
-    /** {@inheritDoc} */
+
+    @Override
     public boolean isScreenOnFully() {
         return mScreenOnFully;
     }
-    
+
     /** {@inheritDoc} */
     public void enableKeyguard(boolean enabled) {
         if (mKeyguardMediator != null) {
@@ -4236,22 +4255,17 @@ public boolean performHapticFeedbackLw(WindowState win, int effectId, boolean al
         }
         return true;
     }
-    
-    public void screenOnStartedLw() {
-    }
 
-    public void screenOnStoppedLw() {
-        if (mPowerManager.isScreenOn()) {
-            if (mKeyguardMediator != null && !mKeyguardMediator.isShowingAndNotHidden()) {
-                long curTime = SystemClock.uptimeMillis();
-                mPowerManager.userActivity(curTime, false);
-            }
-        }
+    @Override
+    public void keepScreenOnStartedLw() {
     }
 
-    public boolean allowKeyRepeat() {
-        // disable key repeat when screen is off
-        return mScreenOnEarly;
+    @Override
+    public void keepScreenOnStoppedLw() {
+        if (mKeyguardMediator != null && !mKeyguardMediator.isShowingAndNotHidden()) {
+            long curTime = SystemClock.uptimeMillis();
+            mPowerManager.userActivity(curTime, false);
+        }
     }
 
     private int updateSystemUiVisibilityLw() {

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

@@ -531,6 +531,7 @@ private void updatePowerState() {
         final boolean mustNotify;
         boolean mustInitialize = false;
         boolean updateAutoBrightness = mTwilightChanged;
+        boolean screenOnWasBlocked = false;
         mTwilightChanged = false;
 
         synchronized (mLock) {
@@ -588,7 +589,6 @@ private void updatePowerState() {
             if (mScreenOffBecauseOfProximity
                     && mProximity != PROXIMITY_POSITIVE) {
                 mScreenOffBecauseOfProximity = false;
-                setScreenOn(true);
                 sendOnProximityNegative();
             }
         } else {
@@ -639,20 +639,43 @@ 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()) {
-                    setScreenOn(true);
-                    if (USE_ELECTRON_BEAM_ON_ANIMATION) {
-                        if (!mElectronBeamOnAnimator.isStarted()) {
-                            if (mPowerState.getElectronBeamLevel() == 1.0f) {
-                                mPowerState.dismissElectronBeam();
-                            } else if (mPowerState.prepareElectronBeam(true)) {
-                                mElectronBeamOnAnimator.start();
-                            } else {
-                                mElectronBeamOnAnimator.end();
-                            }
+                    if (mPowerRequest.blockScreenOn && !mPowerState.isScreenOn()) {
+                        if (DEBUG) {
+                            Slog.d(TAG, "Blocked screen on while screen currently off.");
                         }
+                        screenOnWasBlocked = true;
                     } else {
-                        mPowerState.setElectronBeamLevel(1.0f);
-                        mPowerState.dismissElectronBeam();
+                        setScreenOn(true);
+                        if (USE_ELECTRON_BEAM_ON_ANIMATION) {
+                            if (!mElectronBeamOnAnimator.isStarted()) {
+                                if (mPowerState.getElectronBeamLevel() == 1.0f) {
+                                    mPowerState.dismissElectronBeam();
+                                } else if (mPowerState.prepareElectronBeam(true)) {
+                                    mElectronBeamOnAnimator.start();
+                                } else {
+                                    mElectronBeamOnAnimator.end();
+                                }
+                            }
+                        } else {
+                            mPowerState.setElectronBeamLevel(1.0f);
+                            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 {
@@ -677,12 +700,17 @@ private void updatePowerState() {
         // We mostly care about the screen state here, ignoring brightness changes
         // which will be handled asynchronously.
         if (mustNotify
+                && !screenOnWasBlocked
                 && !mElectronBeamOnAnimator.isStarted()
                 && !mElectronBeamOffAnimator.isStarted()
                 && mPowerState.waitUntilClean(mCleanListener)) {
             synchronized (mLock) {
                 if (!mPendingRequestChangedLocked) {
                     mDisplayReadyLocked = true;
+
+                    if (DEBUG) {
+                        Slog.d(TAG, "Display ready!");
+                    }
                 }
             }
             sendOnStateChanged();

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

@@ -52,12 +52,20 @@ 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.
+    public boolean blockScreenOn;
+
     public DisplayPowerRequest() {
         screenState = SCREEN_STATE_BRIGHT;
         useProximitySensor = false;
         screenBrightness = PowerManager.BRIGHTNESS_ON;
         screenAutoBrightnessAdjustment = 0.0f;
         useAutoBrightness = false;
+        blockScreenOn = false;
     }
 
     public DisplayPowerRequest(DisplayPowerRequest other) {
@@ -70,6 +78,7 @@ public void copyFrom(DisplayPowerRequest other) {
         screenBrightness = other.screenBrightness;
         screenAutoBrightnessAdjustment = other.screenAutoBrightnessAdjustment;
         useAutoBrightness = other.useAutoBrightness;
+        blockScreenOn = other.blockScreenOn;
     }
 
     @Override
@@ -84,7 +93,8 @@ public boolean equals(DisplayPowerRequest other) {
                 && useProximitySensor == other.useProximitySensor
                 && screenBrightness == other.screenBrightness
                 && screenAutoBrightnessAdjustment == other.screenAutoBrightnessAdjustment
-                && useAutoBrightness == other.useAutoBrightness;
+                && useAutoBrightness == other.useAutoBrightness
+                && blockScreenOn == other.blockScreenOn;
     }
 
     @Override
@@ -98,6 +108,7 @@ public String toString() {
                 + ", useProximitySensor=" + useProximitySensor
                 + ", screenBrightness=" + screenBrightness
                 + ", screenAutoBrightnessAdjustment=" + screenAutoBrightnessAdjustment
-                + ", useAutoBrightness=" + useAutoBrightness;
+                + ", useAutoBrightness=" + useAutoBrightness
+                + ", blockScreenOn=" + blockScreenOn;
     }
 }