More improvements to the display manager.

Added more complete support for logical displays with
support for mirroring, rotation and scaling.

Improved the overlay display adapter's touch interactions.

A big change here is that the display manager no longer relies
on a single-threaded model to maintain its synchronization
invariants.  Unfortunately we had to change this so as to play
nice with the fact that the window manager wants to own
the surface flinger transaction around display and surface
manipulations.  As a result, the display manager has to be able
to update displays from the context of any thread.

It would be nice to make this process more cooperative.
There are already several components competing to perform
surface flinger transactions including the window manager,
display manager, electron beam, overlay display window,
and mouse pointer.  They are not manipulating the same surfaces
but they can collide with one another when they make global
changes to the displays.

Change-Id: I04f448594241f2004f6f3d1a81ccd12c566bf296

Author: Jeff Brown

api/current.txt

@@ -23473,6 +23473,7 @@ package android.view {
     method public int getDisplayId();
     method public deprecated int getHeight();
     method public void getMetrics(android.util.DisplayMetrics);
+    method public java.lang.String getName();
     method public deprecated int getOrientation();
     method public deprecated int getPixelFormat();
     method public void getRealMetrics(android.util.DisplayMetrics);

core/java/android/hardware/display/DisplayManagerGlobal.java

@@ -42,6 +42,16 @@ public final class DisplayManagerGlobal {
     private static final String TAG = "DisplayManager";
     private static final boolean DEBUG = false;
 
+    // True if display info and display ids should be cached.
+    //
+    // FIXME: The cache is currently disabled because it's unclear whether we have the
+    // necessary guarantees that the caches will always be flushed before clients
+    // attempt to observe their new state.  For example, depending on the order
+    // in which the binder transactions take place, we might have a problem where
+    // an application could start processing a configuration change due to a display
+    // orientation change before the display info cache has actually been invalidated.
+    private static final boolean USE_CACHE = false;
+
     public static final int EVENT_DISPLAY_ADDED = 1;
     public static final int EVENT_DISPLAY_CHANGED = 2;
     public static final int EVENT_DISPLAY_REMOVED = 3;
@@ -91,21 +101,27 @@ public static DisplayManagerGlobal getInstance() {
     public DisplayInfo getDisplayInfo(int displayId) {
         try {
             synchronized (mLock) {
-                DisplayInfo info = mDisplayInfoCache.get(displayId);
-                if (info != null) {
-                    return info;
+                DisplayInfo info;
+                if (USE_CACHE) {
+                    info = mDisplayInfoCache.get(displayId);
+                    if (info != null) {
+                        return info;
+                    }
                 }
 
                 info = mDm.getDisplayInfo(displayId);
                 if (info == null) {
                     return null;
                 }
+
+                if (USE_CACHE) {
+                    mDisplayInfoCache.put(displayId, info);
+                }
+                registerCallbackIfNeededLocked();
+
                 if (DEBUG) {
                     Log.d(TAG, "getDisplayInfo: displayId=" + displayId + ", info=" + info);
                 }
-
-                mDisplayInfoCache.put(displayId, info);
-                registerCallbackIfNeededLocked();
                 return info;
             }
         } catch (RemoteException ex) {
@@ -122,11 +138,18 @@ public DisplayInfo getDisplayInfo(int displayId) {
     public int[] getDisplayIds() {
         try {
             synchronized (mLock) {
-                if (mDisplayIdCache == null) {
-                    mDisplayIdCache = mDm.getDisplayIds();
-                    registerCallbackIfNeededLocked();
+                if (USE_CACHE) {
+                    if (mDisplayIdCache != null) {
+                        return mDisplayIdCache;
+                    }
+                }
+
+                int[] displayIds = mDm.getDisplayIds();
+                if (USE_CACHE) {
+                    mDisplayIdCache = displayIds;
                 }
-                return mDisplayIdCache;
+                registerCallbackIfNeededLocked();
+                return displayIds;
             }
         } catch (RemoteException ex) {
             Log.e(TAG, "Could not get display ids from display manager.", ex);
@@ -215,10 +238,12 @@ private void registerCallbackIfNeededLocked() {
 
     private void handleDisplayEvent(int displayId, int event) {
         synchronized (mLock) {
-            mDisplayInfoCache.remove(displayId);
+            if (USE_CACHE) {
+                mDisplayInfoCache.remove(displayId);
 
-            if (event == EVENT_DISPLAY_ADDED || event == EVENT_DISPLAY_REMOVED) {
-                mDisplayIdCache = null;
+                if (event == EVENT_DISPLAY_ADDED || event == EVENT_DISPLAY_REMOVED) {
+                    mDisplayIdCache = null;
+                }
             }
 
             final int numListeners = mDisplayListeners.size();

core/java/android/os/Handler.java

@@ -431,7 +431,12 @@ public final boolean postAtFrontOfQueue(Runnable r)
      * set up a Handler thread and need to perform some initialization steps on
      * it before continuing execution.
      *
+     * If timeout occurs then this method returns <code>false</code> but the runnable
+     * will remain posted on the handler and may already be in progress or
+     * complete at a later time.
+     *
      * @param r The Runnable that will be executed synchronously.
+     * @param timeout The timeout in milliseconds, or 0 to wait indefinitely.
      *
      * @return Returns true if the Runnable was successfully executed.
      *         Returns false on failure, usually because the
@@ -441,18 +446,21 @@ public final boolean postAtFrontOfQueue(Runnable r)
      * If we ever do make it part of the API, we might want to rename it to something
      * less funny like runUnsafe().
      */
-    public final boolean runWithScissors(final Runnable r) {
+    public final boolean runWithScissors(final Runnable r, long timeout) {
         if (r == null) {
             throw new IllegalArgumentException("runnable must not be null");
         }
+        if (timeout < 0) {
+            throw new IllegalArgumentException("timeout must be non-negative");
+        }
 
         if (Looper.myLooper() == mLooper) {
             r.run();
             return true;
         }
 
         BlockingRunnable br = new BlockingRunnable(r);
-        return br.postAndWait(this);
+        return br.postAndWait(this, timeout);
     }
 
     /**
@@ -743,16 +751,30 @@ public void run() {
             }
         }
 
-        public boolean postAndWait(Handler handler) {
+        public boolean postAndWait(Handler handler, long timeout) {
             if (!handler.post(this)) {
                 return false;
             }
 
             synchronized (this) {
-                while (!mDone) {
-                    try {
-                        wait();
-                    } catch (InterruptedException ex) {
+                if (timeout > 0) {
+                    final long expirationTime = SystemClock.uptimeMillis() + timeout;
+                    while (!mDone) {
+                        long delay = expirationTime - SystemClock.uptimeMillis();
+                        if (delay <= 0) {
+                            return false; // timeout
+                        }
+                        try {
+                            wait(delay);
+                        } catch (InterruptedException ex) {
+                        }
+                    }
+                } else {
+                    while (!mDone) {
+                        try {
+                            wait();
+                        } catch (InterruptedException ex) {
+                        }
                     }
                 }
             }

core/java/android/view/Display.java

@@ -53,6 +53,8 @@ public final class Display {
 
     private final DisplayManagerGlobal mGlobal;
     private final int mDisplayId;
+    private final int mLayerStack;
+    private final String mName;
     private final CompatibilityInfoHolder mCompatibilityInfo;
 
     private DisplayInfo mDisplayInfo; // never null
@@ -90,6 +92,8 @@ public Display(DisplayManagerGlobal global,
         mGlobal = global;
         mDisplayId = displayId;
         mDisplayInfo = displayInfo;
+        mLayerStack = displayInfo.layerStack; // can never change as long as the display is valid
+        mName = displayInfo.name; // cannot change as long as the display is valid
         mCompatibilityInfo = compatibilityInfo;
         mIsValid = true;
     }
@@ -146,13 +150,11 @@ public boolean getDisplayInfo(DisplayInfo outDisplayInfo) {
      * Each display has its own independent layer stack upon which surfaces
      * are placed to be managed by surface flinger.
      *
-     * @return The layer stack number.
+     * @return The display's layer stack number.
      * @hide
      */
     public int getLayerStack() {
-        // Note: This is the current convention but there is no requirement that
-        // the display id and layer stack id be the same.
-        return mDisplayId;
+        return mLayerStack;
     }
 
     /**
@@ -165,6 +167,14 @@ public CompatibilityInfoHolder getCompatibilityInfo() {
         return mCompatibilityInfo;
     }
 
+    /**
+     * Gets the name of the display.
+     * @return The display's name.
+     */
+    public String getName() {
+        return mName;
+    }
+
     /**
      * Gets the size of the display, in pixels.
      * <p>

core/java/android/view/DisplayInfo.java

@@ -21,11 +21,23 @@
 import android.os.Parcelable;
 import android.util.DisplayMetrics;
 
+import libcore.util.Objects;
+
 /**
  * Describes the characteristics of a particular logical display.
  * @hide
  */
 public final class DisplayInfo implements Parcelable {
+    /**
+     * The surface flinger layer stack associated with this logical display.
+     */
+    public int layerStack;
+
+    /**
+     * The human-readable name of the display.
+     */
+    public String name;
+
     /**
      * The width of the portion of the display that is available to applications, in pixels.
      * Represents the size of the display minus any system decorations.
@@ -147,11 +159,37 @@ private DisplayInfo(Parcel source) {
     }
 
     @Override
-    public int describeContents() {
-        return 0;
+    public boolean equals(Object o) {
+        return o instanceof DisplayInfo && equals((DisplayInfo)o);
+    }
+
+    public boolean equals(DisplayInfo other) {
+        return other != null
+                && layerStack == other.layerStack
+                && Objects.equal(name, other.name)
+                && appWidth == other.appWidth
+                && appHeight == other.appHeight
+                && smallestNominalAppWidth == other.smallestNominalAppWidth
+                && smallestNominalAppHeight == other.smallestNominalAppHeight
+                && largestNominalAppWidth == other.largestNominalAppWidth
+                && largestNominalAppHeight == other.largestNominalAppHeight
+                && logicalWidth == other.logicalWidth
+                && logicalHeight == other.logicalHeight
+                && rotation == other.rotation
+                && refreshRate == other.refreshRate
+                && logicalDensityDpi == other.logicalDensityDpi
+                && physicalXDpi == other.physicalXDpi
+                && physicalYDpi == other.physicalYDpi;
+    }
+
+    @Override
+    public int hashCode() {
+        return 0; // don't care
     }
 
     public void copyFrom(DisplayInfo other) {
+        layerStack = other.layerStack;
+        name = other.name;
         appWidth = other.appWidth;
         appHeight = other.appHeight;
         smallestNominalAppWidth = other.smallestNominalAppWidth;
@@ -168,6 +206,8 @@ public void copyFrom(DisplayInfo other) {
     }
 
     public void readFromParcel(Parcel source) {
+        layerStack = source.readInt();
+        name = source.readString();
         appWidth = source.readInt();
         appHeight = source.readInt();
         smallestNominalAppWidth = source.readInt();
@@ -185,6 +225,8 @@ public void readFromParcel(Parcel source) {
 
     @Override
     public void writeToParcel(Parcel dest, int flags) {
+        dest.writeInt(layerStack);
+        dest.writeString(name);
         dest.writeInt(appWidth);
         dest.writeInt(appHeight);
         dest.writeInt(smallestNominalAppWidth);
@@ -200,6 +242,11 @@ public void writeToParcel(Parcel dest, int flags) {
         dest.writeFloat(physicalYDpi);
     }
 
+    @Override
+    public int describeContents() {
+        return 0;
+    }
+
     public void getAppMetrics(DisplayMetrics outMetrics, CompatibilityInfoHolder cih) {
         getMetricsWithSize(outMetrics, cih, appWidth, appHeight);
     }
@@ -231,13 +278,14 @@ private void getMetricsWithSize(DisplayMetrics outMetrics, CompatibilityInfoHold
     // For debugging purposes
     @Override
     public String toString() {
-        return "app " + appWidth + " x " + appHeight
+        return "DisplayInfo{\"" + name + "\", app " + appWidth + " x " + appHeight
                 + ", real " + logicalWidth + " x " + logicalHeight
                 + ", largest app " + largestNominalAppWidth + " x " + largestNominalAppHeight
                 + ", smallest app " + smallestNominalAppWidth + " x " + smallestNominalAppHeight
                 + ", " + refreshRate + " fps"
                 + ", rotation " + rotation
                 + ", density " + logicalDensityDpi
-                + ", " + physicalXDpi + " x " + physicalYDpi + " dpi";
+                + ", " + physicalXDpi + " x " + physicalYDpi + " dpi"
+                + ", layerStack " + layerStack + "}";
     }
 }

core/java/android/view/Surface.java

@@ -743,17 +743,59 @@ public OutOfResourcesException(String name) {
     }
 
     /**
-     * Describes the properties of a physical display.
+     * Describes the properties of a physical display known to surface flinger.
      * @hide
      */
     public static final class PhysicalDisplayInfo {
-        // TODO: redesign this
         public int width;
         public int height;
         public float refreshRate;
         public float density;
         public float xDpi;
         public float yDpi;
+
+        public PhysicalDisplayInfo() {
+        }
+
+        public PhysicalDisplayInfo(PhysicalDisplayInfo other) {
+            copyFrom(other);
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            return o instanceof PhysicalDisplayInfo && equals((PhysicalDisplayInfo)o);
+        }
+
+        public boolean equals(PhysicalDisplayInfo other) {
+            return other != null
+                    && width == other.width
+                    && height == other.height
+                    && refreshRate == other.refreshRate
+                    && density == other.density
+                    && xDpi == other.xDpi
+                    && yDpi == other.yDpi;
+        }
+
+        @Override
+        public int hashCode() {
+            return 0; // don't care
+        }
+
+        public void copyFrom(PhysicalDisplayInfo other) {
+            width = other.width;
+            height = other.height;
+            refreshRate = other.refreshRate;
+            density = other.density;
+            xDpi = other.xDpi;
+            yDpi = other.yDpi;
+        }
+
+        // For debugging purposes
+        @Override
+        public String toString() {
+            return "PhysicalDisplayInfo{" + width + " x " + height + ", " + refreshRate + " fps, "
+                    + "density " + density + ", " + xDpi + " x " + yDpi + " dpi}";
+        }
     }
 
     /**