Blank or unblank all displays as need.

Ensures that both the internal display and HDMI are blanked
or unblanked in tandem.

Bug: 7309812
Change-Id: Ie8b96d393e8bb20d23c92f3320142d9f7cf42aff

Author: Jeff Brown

core/java/android/view/Surface.java

@@ -266,6 +266,8 @@ private static native void nativeSetDisplayProjection(
             IBinder displayToken, int orientation, Rect layerStackRect, Rect displayRect);
     private static native boolean nativeGetDisplayInfo(
             IBinder displayToken, PhysicalDisplayInfo outInfo);
+    private static native void nativeBlankDisplay(IBinder displayToken);
+    private static native void nativeUnblankDisplay(IBinder displayToken);
 
     private native void nativeCopyFrom(Surface other);
     private native void nativeTransferFrom(Surface other);
@@ -638,6 +640,22 @@ public static boolean getDisplayInfo(IBinder displayToken, PhysicalDisplayInfo o
         return nativeGetDisplayInfo(displayToken, outInfo);
     }
 
+    /** @hide */
+    public static void blankDisplay(IBinder displayToken) {
+        if (displayToken == null) {
+            throw new IllegalArgumentException("displayToken must not be null");
+        }
+        nativeBlankDisplay(displayToken);
+    }
+
+    /** @hide */
+    public static void unblankDisplay(IBinder displayToken) {
+        if (displayToken == null) {
+            throw new IllegalArgumentException("displayToken must not be null");
+        }
+        nativeUnblankDisplay(displayToken);
+    }
+
     /**
      * Copy another surface to this one.  This surface now holds a reference
      * to the same data as the original surface, and is -not- the owner.

core/jni/android_view_Surface.cpp

@@ -48,6 +48,7 @@
 #include <android_runtime/android_view_SurfaceSession.h>
 #include <android_runtime/android_graphics_SurfaceTexture.h>
 #include <utils/misc.h>
+#include <utils/Log.h>
 
 #include <ScopedUtfChars.h>
 
@@ -710,6 +711,22 @@ static jboolean nativeGetDisplayInfo(JNIEnv* env, jclass clazz,
     return JNI_TRUE;
 }
 
+static void nativeBlankDisplay(JNIEnv* env, jclass clazz, jobject tokenObj) {
+    sp<IBinder> token(ibinderForJavaObject(env, tokenObj));
+    if (token == NULL) return;
+
+    ALOGD_IF_SLOW(100, "Excessive delay in blankDisplay() while turning screen off");
+    SurfaceComposerClient::blankDisplay(token);
+}
+
+static void nativeUnblankDisplay(JNIEnv* env, jclass clazz, jobject tokenObj) {
+    sp<IBinder> token(ibinderForJavaObject(env, tokenObj));
+    if (token == NULL) return;
+
+    ALOGD_IF_SLOW(100, "Excessive delay in unblankDisplay() while turning screen on");
+    SurfaceComposerClient::unblankDisplay(token);
+}
+
 // ----------------------------------------------------------------------------
 
 static void nativeCopyFrom(JNIEnv* env, jobject surfaceObj, jobject otherObj) {
@@ -832,6 +849,10 @@ static JNINativeMethod gSurfaceMethods[] = {
             (void*)nativeSetDisplayProjection },
     {"nativeGetDisplayInfo", "(Landroid/os/IBinder;Landroid/view/Surface$PhysicalDisplayInfo;)Z",
             (void*)nativeGetDisplayInfo },
+    {"nativeBlankDisplay", "(Landroid/os/IBinder;)V",
+            (void*)nativeBlankDisplay },
+    {"nativeUnblankDisplay", "(Landroid/os/IBinder;)V",
+            (void*)nativeUnblankDisplay },
     {"nativeCopyFrom", "(Landroid/view/Surface;)V",
             (void*)nativeCopyFrom },
     {"nativeTransferFrom", "(Landroid/view/Surface;)V",

services/java/com/android/server/display/DisplayDevice.java

@@ -104,6 +104,18 @@ public void applyPendingDisplayDeviceInfoChangesLocked() {
     public void performTraversalInTransactionLocked() {
     }
 
+    /**
+     * Blanks the display, if supported.
+     */
+    public void blankLocked() {
+    }
+
+    /**
+     * Unblanks the display, if supported.
+     */
+    public void unblankLocked() {
+    }
+
     /**
      * Sets the display layer stack while in a transaction.
      */

services/java/com/android/server/display/DisplayManagerService.java

@@ -103,6 +103,10 @@ public final class DisplayManagerService extends IDisplayManager.Stub {
     private static final int MSG_REQUEST_TRAVERSAL = 4;
     private static final int MSG_UPDATE_VIEWPORT = 5;
 
+    private static final int DISPLAY_BLANK_STATE_UNKNOWN = 0;
+    private static final int DISPLAY_BLANK_STATE_BLANKED = 1;
+    private static final int DISPLAY_BLANK_STATE_UNBLANKED = 2;
+
     private final Context mContext;
     private final boolean mHeadless;
     private final DisplayManagerHandler mHandler;
@@ -141,6 +145,9 @@ public final class DisplayManagerService extends IDisplayManager.Stub {
             new SparseArray<LogicalDisplay>();
     private int mNextNonDefaultDisplayId = Display.DEFAULT_DISPLAY + 1;
 
+    // Set to true if all displays have been blanked by the power manager.
+    private int mAllDisplayBlankStateFromPowerManager;
+
     // Set to true when there are pending display changes that have yet to be applied
     // to the surface flinger state.
     private boolean mPendingTraversal;
@@ -285,6 +292,40 @@ public void performTraversalInTransactionFromWindowManager() {
         }
     }
 
+    /**
+     * Called by the power manager to blank all displays.
+     */
+    public void blankAllDisplaysFromPowerManager() {
+        synchronized (mSyncRoot) {
+            if (mAllDisplayBlankStateFromPowerManager != DISPLAY_BLANK_STATE_BLANKED) {
+                mAllDisplayBlankStateFromPowerManager = DISPLAY_BLANK_STATE_BLANKED;
+
+                final int count = mDisplayDevices.size();
+                for (int i = 0; i < count; i++) {
+                    DisplayDevice device = mDisplayDevices.get(i);
+                    device.blankLocked();
+                }
+            }
+        }
+    }
+
+    /**
+     * Called by the power manager to unblank all displays.
+     */
+    public void unblankAllDisplaysFromPowerManager() {
+        synchronized (mSyncRoot) {
+            if (mAllDisplayBlankStateFromPowerManager != DISPLAY_BLANK_STATE_UNBLANKED) {
+                mAllDisplayBlankStateFromPowerManager = DISPLAY_BLANK_STATE_UNBLANKED;
+
+                final int count = mDisplayDevices.size();
+                for (int i = 0; i < count; i++) {
+                    DisplayDevice device = mDisplayDevices.get(i);
+                    device.unblankLocked();
+                }
+            }
+        }
+    }
+
     /**
      * Returns information about the specified logical display.
      *
@@ -528,6 +569,17 @@ private void handleDisplayDeviceAdded(DisplayDevice device) {
             mDisplayDevices.add(device);
             addLogicalDisplayLocked(device);
             scheduleTraversalLocked(false);
+
+            // Blank or unblank the display immediately to match the state requested
+            // by the power manager (if known).
+            switch (mAllDisplayBlankStateFromPowerManager) {
+                case DISPLAY_BLANK_STATE_BLANKED:
+                    device.blankLocked();
+                    break;
+                case DISPLAY_BLANK_STATE_UNBLANKED:
+                    device.unblankLocked();
+                    break;
+            }
         }
     }
 
@@ -788,9 +840,18 @@ public void dump(FileDescriptor fd, final PrintWriter pw, String[] args) {
         }
 
         pw.println("DISPLAY MANAGER (dumpsys display)");
-        pw.println("  mHeadless=" + mHeadless);
 
         synchronized (mSyncRoot) {
+            pw.println("  mHeadless=" + mHeadless);
+            pw.println("  mOnlyCode=" + mOnlyCore);
+            pw.println("  mSafeMode=" + mSafeMode);
+            pw.println("  mPendingTraversal=" + mPendingTraversal);
+            pw.println("  mAllDisplayBlankStateFromPowerManager="
+                    + mAllDisplayBlankStateFromPowerManager);
+            pw.println("  mNextNonDefaultDisplayId=" + mNextNonDefaultDisplayId);
+            pw.println("  mDefaultViewport=" + mDefaultViewport);
+            pw.println("  mExternalTouchViewport=" + mExternalTouchViewport);
+
             IndentingPrintWriter ipw = new IndentingPrintWriter(pw, "    ");
             ipw.increaseIndent();
 
@@ -817,10 +878,6 @@ public void dump(FileDescriptor fd, final PrintWriter pw, String[] args) {
                 pw.println("  Display " + displayId + ":");
                 display.dumpLocked(ipw);
             }
-
-            pw.println();
-            pw.println("Default viewport: " + mDefaultViewport);
-            pw.println("External touch viewport: " + mExternalTouchViewport);
         }
     }
 

services/java/com/android/server/display/LocalDisplayAdapter.java

@@ -92,6 +92,7 @@ private final class LocalDisplayDevice extends DisplayDevice {
 
         private DisplayDeviceInfo mInfo;
         private boolean mHavePendingChanges;
+        private boolean mBlanked;
 
         public LocalDisplayDevice(IBinder displayToken, int builtInDisplayId,
                 PhysicalDisplayInfo phys) {
@@ -149,11 +150,24 @@ public DisplayDeviceInfo getDisplayDeviceInfoLocked() {
             return mInfo;
         }
 
+        @Override
+        public void blankLocked() {
+            mBlanked = true;
+            Surface.blankDisplay(getDisplayTokenLocked());
+        }
+
+        @Override
+        public void unblankLocked() {
+            mBlanked = false;
+            Surface.unblankDisplay(getDisplayTokenLocked());
+        }
+
         @Override
         public void dumpLocked(PrintWriter pw) {
             super.dumpLocked(pw);
             pw.println("mBuiltInDisplayId=" + mBuiltInDisplayId);
             pw.println("mPhys=" + mPhys);
+            pw.println("mBlanked=" + mBlanked);
         }
     }
 

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

@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.server.power;
+
+/**
+ * Blanks or unblanks all displays.
+ */
+interface DisplayBlanker {
+    public void blankAllDisplays();
+    public void unblankAllDisplays();
+}

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

@@ -159,6 +159,9 @@ final class DisplayPowerController {
     // A suspend blocker.
     private final SuspendBlocker mSuspendBlocker;
 
+    // The display blanker.
+    private final DisplayBlanker mDisplayBlanker;
+
     // Our handler.
     private final DisplayControllerHandler mHandler;
 
@@ -343,10 +346,12 @@ final class DisplayPowerController {
      */
     public DisplayPowerController(Looper looper, Context context, Notifier notifier,
             LightsService lights, TwilightService twilight, SuspendBlocker suspendBlocker,
+            DisplayBlanker displayBlanker,
             Callbacks callbacks, Handler callbackHandler) {
         mHandler = new DisplayControllerHandler(looper);
         mNotifier = notifier;
         mSuspendBlocker = suspendBlocker;
+        mDisplayBlanker = displayBlanker;
         mCallbacks = callbacks;
         mCallbackHandler = callbackHandler;
 
@@ -520,7 +525,8 @@ private void initialize() {
                 new ElectronBeam(display),
                 new PhotonicModulator(executor,
                         mLights.getLight(LightsService.LIGHT_ID_BACKLIGHT),
-                        mSuspendBlocker));
+                        mSuspendBlocker),
+                mDisplayBlanker);
 
         mElectronBeamOnAnimator = ObjectAnimator.ofFloat(
                 mPowerState, DisplayPowerState.ELECTRON_BEAM_LEVEL, 0.0f, 1.0f);

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

@@ -51,7 +51,8 @@ final class DisplayPowerState {
 
     private final Choreographer mChoreographer;
     private final ElectronBeam mElectronBeam;
-    private final PhotonicModulator mScreenBrightnessModulator;
+    private final PhotonicModulator mPhotonicModulator;
+    private final DisplayBlanker mDisplayBlanker;
 
     private int mDirty;
     private boolean mScreenOn;
@@ -61,10 +62,11 @@ final class DisplayPowerState {
     private Runnable mCleanListener;
 
     public DisplayPowerState(ElectronBeam electronBean,
-            PhotonicModulator screenBrightnessModulator) {
+            PhotonicModulator photonicModulator, DisplayBlanker displayBlanker) {
         mChoreographer = Choreographer.getInstance();
         mElectronBeam = electronBean;
-        mScreenBrightnessModulator = screenBrightnessModulator;
+        mPhotonicModulator = photonicModulator;
+        mDisplayBlanker = displayBlanker;
 
         // At boot time, we know that the screen is on and the electron beam
         // animation is not playing.  We don't know the screen's brightness though,
@@ -238,21 +240,21 @@ private void invalidate(int dirty) {
     private void apply() {
         if (mDirty != 0) {
             if ((mDirty & DIRTY_SCREEN_ON) != 0 && !mScreenOn) {
-                mScreenBrightnessModulator.setBrightness(0, true /*sync*/);
-                PowerManagerService.nativeSetScreenState(false);
+                mPhotonicModulator.setBrightness(0, true /*sync*/);
+                mDisplayBlanker.blankAllDisplays();
             }
 
             if ((mDirty & DIRTY_ELECTRON_BEAM) != 0) {
                 mElectronBeam.draw(mElectronBeamLevel);
             }
 
             if ((mDirty & DIRTY_SCREEN_ON) != 0 && mScreenOn) {
-                PowerManagerService.nativeSetScreenState(true);
+                mDisplayBlanker.unblankAllDisplays();
             }
 
             if ((mDirty & (DIRTY_BRIGHTNESS | DIRTY_SCREEN_ON | DIRTY_ELECTRON_BEAM)) != 0
                     && mScreenOn) {
-                mScreenBrightnessModulator.setBrightness(
+                mPhotonicModulator.setBrightness(
                         (int)(mScreenBrightness * mElectronBeamLevel), false /*sync*/);
             }