Refactor DisplayManagerService to be functional. (4f67ba6b) · Commits · e / os / android_frameworks_base

core/java/android/view/Display.java

+6 −0

Original line number	Diff line number	Diff line
		@@ -72,6 +72,12 @@ public final class Display {
		*/
		public static final int DEFAULT_DISPLAY = 0;

		/**
		* Uninitialized display.
		* @hide
		*/
		public static final int NO_DISPLAY = -1;

		/**
		* Internal method to create a display.
		* Applications should use {@link android.view.WindowManager#getDefaultDisplay()}

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

+20 −2

Original line number	Diff line number	Diff line
		@@ -16,14 +16,32 @@

		package com.android.server.display;

		import android.view.Display;

		/**
		* A display adapter makes one or more display devices available to the system.
		* A display adapter makes a single display devices available to the system.
		* <p>
		* For now, all display adapters are registered in the system server but
		* in principle it could be done from other processes.
		* </p>
		*/
		public abstract class DisplayAdapter {
		/** The current logical Display assignment for this adapter. Will change if other logical
		* display is assigned to this adapter */
		private int mDisplayId = Display.NO_DISPLAY;

		/** Assign the displayId
		* @hide */
		public void setDisplayId(int displayId) {
		mDisplayId = displayId;
		}

		/** Retrieve the displayId
		* @hide */
		public int getDisplayId() {
		return mDisplayId;
		}

		/**
		* Gets the display adapter name.
		* @return The display adapter name.
		@@ -31,5 +49,5 @@ public abstract class DisplayAdapter {
		public abstract String getName();

		// TODO: dynamically register display devices
		public abstract DisplayDevice[] getDisplayDevices();
		public abstract DisplayDevice getDisplayDevice();
		}

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

+200 −57

Original line number	Diff line number	Diff line
		@@ -22,6 +22,8 @@ import android.content.pm.PackageManager;
		import android.hardware.display.IDisplayManager;
		import android.os.Binder;
		import android.os.SystemProperties;
		import android.util.Slog;
		import android.util.SparseArray;
		import android.view.Display;
		import android.view.DisplayInfo;
		import android.view.Surface;
		@@ -47,28 +49,34 @@ public final class DisplayManagerService extends IDisplayManager.Stub {

		private Context mContext;
		private final boolean mHeadless;

		private int mDisplayIdSeq = Display.DEFAULT_DISPLAY;

		/** All registered DisplayAdapters. */
		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;
		/** All the DisplayAdapters showing the given displayId. */
		private final SparseArray<ArrayList<DisplayAdapter>> mLogicalToPhysicals =
		new SparseArray<ArrayList<DisplayAdapter>>();

		/** All the DisplayInfos in the system indexed by deviceId */
		private final SparseArray<DisplayInfo> mDisplayInfos = new SparseArray<DisplayInfo>();

		public DisplayManagerService() {
		mHeadless = SystemProperties.get(SYSTEM_HEADLESS).equals("1");
		registerDisplayAdapters();
		initializeDefaultDisplay();
		registerDefaultDisplayAdapter();
		}

		public void setContext(Context context) {
		mContext = context;
		private void registerDefaultDisplayAdapter() {
		if (mHeadless) {
		registerDisplayAdapter(new HeadlessDisplayAdapter());
		} else {
		registerDisplayAdapter(new SurfaceFlingerDisplayAdapter());
		}

		// FIXME: this isn't the right API for the long term
		public void setDefaultDisplayInfo(DisplayInfo info) {
		synchronized (mLock) {
		mDefaultDisplayInfo.copyFrom(info);
		}

		public void setContext(Context context) {
		mContext = context;
		}

		// FIXME: this isn't the right API for the long term
		@@ -83,15 +91,185 @@ public final class DisplayManagerService extends IDisplayManager.Stub {
		return mHeadless;
		}

		/**
		* Save away new DisplayInfo data.
		* @param displayId The local DisplayInfo to store the new data in.
		* @param info The new data to be stored.
		*/
		public void setDisplayInfo(int displayId, DisplayInfo info) {
		synchronized (mLock) {
		DisplayInfo localInfo = mDisplayInfos.get(displayId);
		if (localInfo == null) {
		localInfo = new DisplayInfo();
		mDisplayInfos.put(displayId, localInfo);
		}
		localInfo.copyFrom(info);
		}
		}

		/**
		* Return requested DisplayInfo.
		* @param displayId The data to retrieve.
		* @param outInfo The structure to receive the data.
		*/
		@Override // Binder call
		public boolean getDisplayInfo(int displayId, DisplayInfo outInfo) {
		synchronized (mLock) {
		if (displayId == Display.DEFAULT_DISPLAY) {
		outInfo.copyFrom(mDefaultDisplayInfo);
		DisplayInfo localInfo = mDisplayInfos.get(displayId);
		if (localInfo == null) {
		return false;
		}
		outInfo.copyFrom(localInfo);
		return true;
		}
		return false;
		}

		/**
		* Inform the service of a new physical display. A new logical displayId is created and the new
		* physical display is immediately bound to it. Use removeAdapterFromDisplay to disconnect it.
		*
		* @param adapter The wrapper for information associated with the physical display.
		*/
		public void registerDisplayAdapter(DisplayAdapter adapter) {
		synchronized (mLock) {
		int displayId = mDisplayIdSeq++;
		adapter.setDisplayId(displayId);

		createDisplayInfoLocked(displayId, adapter);

		ArrayList<DisplayAdapter> list = new ArrayList<DisplayAdapter>();
		list.add(adapter);
		mLogicalToPhysicals.put(displayId, list);

		mDisplayAdapters.add(adapter);
		}

		// TODO: Notify SurfaceFlinger of new addition.
		}

		/**
		* Connect a logical display to a physical display. Will remove the physical display from any
		* logical display it is currently attached to.
		*
		* @param displayId The logical display. Will be created if it does not already exist.
		* @param adapter The physical display.
		*/
		public void addAdapterToDisplay(int displayId, DisplayAdapter adapter) {
		if (adapter == null) {
		// TODO: Or throw NPE?
		Slog.e(TAG, "addDeviceToDisplay: Attempt to add null adapter");
		return;
		}

		synchronized (mLock) {
		if (!mDisplayAdapters.contains(adapter)) {
		// TOOD: Handle unregistered adapter with exception or return value.
		Slog.e(TAG, "addDeviceToDisplay: Attempt to add an unregistered adapter");
		return;
		}

		DisplayInfo displayInfo = mDisplayInfos.get(displayId);
		if (displayInfo == null) {
		createDisplayInfoLocked(displayId, adapter);
		}

		Integer oldDisplayId = adapter.getDisplayId();
		if (oldDisplayId != Display.NO_DISPLAY) {
		if (oldDisplayId == displayId) {
		// adapter already added to displayId.
		return;
		}

		removeAdapterLocked(adapter);
		}

		ArrayList<DisplayAdapter> list = mLogicalToPhysicals.get(displayId);
		if (list == null) {
		list = new ArrayList<DisplayAdapter>();
		mLogicalToPhysicals.put(displayId, list);
		}

		list.add(adapter);
		adapter.setDisplayId(displayId);
		}

		// TODO: Notify SurfaceFlinger of new addition.
		}

		/**
		* Disconnect the physical display from whichever logical display it is attached to.
		* @param adapter The physical display to detach.
		*/
		public void removeAdapterFromDisplay(DisplayAdapter adapter) {
		if (adapter == null) {
		// TODO: Or throw NPE?
		return;
		}

		synchronized (mLock) {
		if (!mDisplayAdapters.contains(adapter)) {
		// TOOD: Handle unregistered adapter with exception or return value.
		Slog.e(TAG, "removeDeviceFromDisplay: Attempt to remove an unregistered adapter");
		return;
		}

		removeAdapterLocked(adapter);
		}

		// TODO: Notify SurfaceFlinger of removal.
		}

		/**
		* Create a new logical DisplayInfo and fill it in with information from the physical display.
		* @param displayId The logical identifier.
		* @param adapter The physical display for initial values.
		*/
		private void createDisplayInfoLocked(int displayId, DisplayAdapter adapter) {
		DisplayInfo displayInfo = new DisplayInfo();
		DisplayDeviceInfo deviceInfo = new DisplayDeviceInfo();
		adapter.getDisplayDevice().getInfo(deviceInfo);
		copyDisplayInfoFromDeviceInfo(displayInfo, deviceInfo);
		mDisplayInfos.put(displayId, displayInfo);
		}

		/**
		* Disconnect a physical display from its logical display. If there are no more physical
		* displays attached to the logical display, delete the logical display.
		* @param adapter The physical display to detach.
		*/
		void removeAdapterLocked(DisplayAdapter adapter) {
		int displayId = adapter.getDisplayId();
		adapter.setDisplayId(Display.NO_DISPLAY);

		ArrayList<DisplayAdapter> list = mLogicalToPhysicals.get(displayId);
		if (list != null) {
		list.remove(adapter);
		if (list.isEmpty()) {
		mLogicalToPhysicals.remove(displayId);
		// TODO: Keep count of Windows attached to logical display and don't delete if
		// there are any outstanding. Also, what keeps the WindowManager from continuing
		// to use the logical display?
		mDisplayInfos.remove(displayId);
		}
		}
		}

		private void copyDisplayInfoFromDeviceInfo(DisplayInfo displayInfo,
		DisplayDeviceInfo deviceInfo) {
		// Bootstrap the logical display using the physical display.
		displayInfo.appWidth = deviceInfo.width;
		displayInfo.appHeight = deviceInfo.height;
		displayInfo.logicalWidth = deviceInfo.width;
		displayInfo.logicalHeight = deviceInfo.height;
		displayInfo.rotation = Surface.ROTATION_0;
		displayInfo.refreshRate = deviceInfo.refreshRate;
		displayInfo.logicalDensityDpi = deviceInfo.densityDpi;
		displayInfo.physicalXDpi = deviceInfo.xDpi;
		displayInfo.physicalYDpi = deviceInfo.yDpi;
		displayInfo.smallestNominalAppWidth = deviceInfo.width;
		displayInfo.smallestNominalAppHeight = deviceInfo.height;
		displayInfo.largestNominalAppWidth = deviceInfo.width;
		displayInfo.largestNominalAppHeight = deviceInfo.height;
		}

		@Override // Binder call
		@@ -110,46 +288,11 @@ public final class DisplayManagerService extends IDisplayManager.Stub {

		DisplayDeviceInfo info = new DisplayDeviceInfo();
		for (DisplayAdapter adapter : mDisplayAdapters) {
		pw.println("Displays for adapter " + adapter.getName());
		for (DisplayDevice device : adapter.getDisplayDevices()) {
		device.getInfo(info);
		pw.println("Display for adapter " + adapter.getName());
		DisplayDevice device = adapter.getDisplayDevice();
		pw.print(" ");
		device.getInfo(info);
		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.logicalDensityDpi = mDefaultDisplayDeviceInfo.densityDpi;
		mDefaultDisplayInfo.physicalXDpi = mDefaultDisplayDeviceInfo.xDpi;
		mDefaultDisplayInfo.physicalYDpi = mDefaultDisplayDeviceInfo.yDpi;
		mDefaultDisplayInfo.smallestNominalAppWidth = mDefaultDisplayDeviceInfo.width;
		mDefaultDisplayInfo.smallestNominalAppHeight = mDefaultDisplayDeviceInfo.height;
		mDefaultDisplayInfo.largestNominalAppWidth = mDefaultDisplayDeviceInfo.width;
		mDefaultDisplayInfo.largestNominalAppHeight = mDefaultDisplayDeviceInfo.height;
		}
		}

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

+2 −2

Original line number	Diff line number	Diff line
		@@ -40,7 +40,7 @@ public final class HeadlessDisplayAdapter extends DisplayAdapter {
		}

		@Override
		public DisplayDevice[] getDisplayDevices() {
		return new DisplayDevice[] { mDefaultDisplay };
		public DisplayDevice getDisplayDevice() {
		return mDefaultDisplay;
		}
		}

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

+2 −2

Original line number	Diff line number	Diff line
		@@ -35,7 +35,7 @@ public final class SurfaceFlingerDisplayAdapter extends DisplayAdapter {
		}

		@Override
		public DisplayDevice[] getDisplayDevices() {
		return new DisplayDevice[] { mDefaultDisplay };
		public DisplayDevice getDisplayDevice() {
		return mDefaultDisplay;
		}
		}