Add display manager skeleton.

The purpose of this change is to remove direct reliance on
SurfaceFlinger for describing the size and characteristics of
displays.

This patch also starts to make a distinction between logical displays
and physical display devices.  Currently, the window manager owns
the concept of a logical display whereas the new display
manager owns the concept of a physical display device.

Change-Id: I7e0761f83f033be6c06fd1041280c21500bcabc0

1 files changed, 155 insertions, 0 deletions

diff --git a/services/java/com/android/server/display/DisplayManagerService.java b/services/java/com/android/server/display/DisplayManagerService.java
new file mode 100644
index 0000000..082d28f
--- /dev/null
+++ b/services/java/com/android/server/display/DisplayManagerService.java
@@ -0,0 +1,155 @@
+/*
+ * 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.display;
+
+import android.Manifest;
+import android.content.Context;
+import android.content.pm.PackageManager;
+import android.hardware.display.IDisplayManager;
+import android.os.Binder;
+import android.os.SystemProperties;
+import android.view.Display;
+import android.view.DisplayInfo;
+import android.view.Surface;
+
+import java.io.FileDescriptor;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+
+/**
+ * Manages the properties, media routing and power state of attached displays.
+ * <p>
+ * The display manager service does not own or directly control the displays.
+ * Instead, other components in the system register their display adapters with the
+ * display manager service which acts as a central controller.
+ * </p>
+ */
+public final class DisplayManagerService extends IDisplayManager.Stub {
+    private static final String TAG = "DisplayManagerService";
+
+    private static final String SYSTEM_HEADLESS = "ro.config.headless";
+
+    private final Object mLock = new Object();
+
+    private Context mContext;
+    private final boolean mHeadless;
+    private final ArrayList<DisplayAdapter> mDisplayAdapters = new ArrayList<DisplayAdapter>();
+
+    // TODO: represent this as a map between logical and physical devices
+    private DisplayInfo mDefaultDisplayInfo;
+    private DisplayDevice mDefaultDisplayDevice;
+    private DisplayDeviceInfo mDefaultDisplayDeviceInfo;
+
+    public DisplayManagerService() {
+        mHeadless = SystemProperties.get(SYSTEM_HEADLESS).equals("1");
+        registerDisplayAdapters();
+        initializeDefaultDisplay();
+    }
+
+    public void setContext(Context context) {
+        mContext = context;
+    }
+
+    // FIXME: this isn't the right API for the long term
+    public void setDefaultDisplayInfo(DisplayInfo info) {
+        synchronized (mLock) {
+            mDefaultDisplayInfo.copyFrom(info);
+        }
+    }
+
+    // FIXME: this isn't the right API for the long term
+    public void getDefaultExternalDisplayDeviceInfo(DisplayDeviceInfo info) {
+        // hardcoded assuming 720p touch screen plugged into HDMI and USB
+        // need to redesign this
+        info.width = 1280;
+        info.height = 720;
+    }
+
+    public boolean isHeadless() {
+        return mHeadless;
+    }
+
+    @Override // Binder call
+    public boolean getDisplayInfo(int displayId, DisplayInfo outInfo) {
+        synchronized (mLock) {
+            if (displayId == Display.DEFAULT_DISPLAY) {
+                outInfo.copyFrom(mDefaultDisplayInfo);
+                return true;
+            }
+            return false;
+        }
+    }
+
+    @Override // Binder call
+    public void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
+        if (mContext == null
+                || mContext.checkCallingOrSelfPermission(Manifest.permission.DUMP)
+                        != PackageManager.PERMISSION_GRANTED) {
+            pw.println("Permission Denial: can't dump DisplayManager from from pid="
+                    + Binder.getCallingPid() + ", uid=" + Binder.getCallingUid());
+            return;
+        }
+
+        pw.println("DISPLAY MANAGER (dumpsys display)\n");
+
+        pw.println("Headless: " + mHeadless);
+
+        DisplayDeviceInfo info = new DisplayDeviceInfo();
+        for (DisplayAdapter adapter : mDisplayAdapters) {
+            pw.println("Displays for adapter " + adapter.getName());
+            for (DisplayDevice device : adapter.getDisplayDevices()) {
+                device.getInfo(info);
+                pw.print("  ");
+                pw.println(info);
+            }
+        }
+    }
+
+    private void registerDisplayAdapters() {
+        if (mHeadless) {
+            registerDisplayAdapter(new HeadlessDisplayAdapter());
+        } else {
+            registerDisplayAdapter(new SurfaceFlingerDisplayAdapter());
+        }
+    }
+
+    private void registerDisplayAdapter(DisplayAdapter adapter) {
+        // TODO: do this dynamically
+        mDisplayAdapters.add(adapter);
+        mDefaultDisplayDevice = adapter.getDisplayDevices()[0];
+        mDefaultDisplayDeviceInfo = new DisplayDeviceInfo();
+        mDefaultDisplayDevice.getInfo(mDefaultDisplayDeviceInfo);
+    }
+
+    private void initializeDefaultDisplay() {
+        // Bootstrap the default logical display using the default physical display.
+        mDefaultDisplayInfo = new DisplayInfo();
+        mDefaultDisplayInfo.appWidth = mDefaultDisplayDeviceInfo.width;
+        mDefaultDisplayInfo.appHeight = mDefaultDisplayDeviceInfo.height;
+        mDefaultDisplayInfo.logicalWidth = mDefaultDisplayDeviceInfo.width;
+        mDefaultDisplayInfo.logicalHeight = mDefaultDisplayDeviceInfo.height;
+        mDefaultDisplayInfo.rotation = Surface.ROTATION_0;
+        mDefaultDisplayInfo.refreshRate = mDefaultDisplayDeviceInfo.refreshRate;
+        mDefaultDisplayInfo.logicalDensity = mDefaultDisplayDeviceInfo.density;
+        mDefaultDisplayInfo.physicalXDpi = mDefaultDisplayDeviceInfo.xDpi;
+        mDefaultDisplayInfo.physicalYDpi = mDefaultDisplayDeviceInfo.yDpi;
+        mDefaultDisplayInfo.smallestNominalAppWidth = mDefaultDisplayDeviceInfo.width;
+        mDefaultDisplayInfo.smallestNominalAppHeight = mDefaultDisplayDeviceInfo.height;
+        mDefaultDisplayInfo.largestNominalAppWidth = mDefaultDisplayDeviceInfo.width;
+        mDefaultDisplayInfo.largestNominalAppHeight = mDefaultDisplayDeviceInfo.height;
+    }
+}