9de4936c99
Added Surface.setDisplayId(). Added callbacks to DisplayManagerService. Change-Id: Idd3f85f8ca1f1208962f1196efd6a3ab51c8c259
338 lines
12 KiB
Java
338 lines
12 KiB
Java
/*
|
|
* 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.util.Slog;
|
|
import android.util.SparseArray;
|
|
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 int mDisplayIdSeq = Display.DEFAULT_DISPLAY;
|
|
|
|
/** All registered DisplayAdapters. */
|
|
private final ArrayList<DisplayAdapter> mDisplayAdapters = new ArrayList<DisplayAdapter>();
|
|
|
|
/** 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>();
|
|
|
|
private final ArrayList<DisplayCallback> mCallbacks =
|
|
new ArrayList<DisplayManagerService.DisplayCallback>();
|
|
|
|
public DisplayManagerService() {
|
|
mHeadless = SystemProperties.get(SYSTEM_HEADLESS).equals("1");
|
|
registerDefaultDisplayAdapter();
|
|
}
|
|
|
|
private void registerDefaultDisplayAdapter() {
|
|
if (mHeadless) {
|
|
registerDisplayAdapter(new HeadlessDisplayAdapter());
|
|
} else {
|
|
registerDisplayAdapter(new SurfaceFlingerDisplayAdapter());
|
|
}
|
|
}
|
|
|
|
public void setContext(Context context) {
|
|
mContext = context;
|
|
}
|
|
|
|
// 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;
|
|
}
|
|
|
|
/**
|
|
* 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) {
|
|
DisplayInfo localInfo = mDisplayInfos.get(displayId);
|
|
if (localInfo == null) {
|
|
return false;
|
|
}
|
|
outInfo.copyFrom(localInfo);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 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) {
|
|
|
|
int displayId;
|
|
DisplayCallback[] callbacks;
|
|
|
|
synchronized (mLock) {
|
|
displayId = mDisplayIdSeq;
|
|
do {
|
|
// Find the next unused displayId. (Pretend like it might ever wrap around).
|
|
mDisplayIdSeq++;
|
|
if (mDisplayIdSeq < 0) {
|
|
mDisplayIdSeq = Display.DEFAULT_DISPLAY + 1;
|
|
}
|
|
} while (mDisplayInfos.get(mDisplayIdSeq) != null);
|
|
|
|
adapter.setDisplayId(displayId);
|
|
|
|
createDisplayInfoLocked(displayId, adapter);
|
|
|
|
ArrayList<DisplayAdapter> list = new ArrayList<DisplayAdapter>();
|
|
list.add(adapter);
|
|
mLogicalToPhysicals.put(displayId, list);
|
|
|
|
mDisplayAdapters.add(adapter);
|
|
callbacks = mCallbacks.toArray(new DisplayCallback[mCallbacks.size()]);
|
|
}
|
|
|
|
for (int i = callbacks.length - 1; i >= 0; i--) {
|
|
callbacks[i].displayAdded(displayId);
|
|
}
|
|
|
|
// 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.
|
|
}
|
|
|
|
public void registerDisplayCallback(final DisplayCallback callback) {
|
|
synchronized (mLock) {
|
|
if (!mCallbacks.contains(callback)) {
|
|
mCallbacks.add(callback);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void unregisterDisplayCallback(final DisplayCallback callback) {
|
|
synchronized (mLock) {
|
|
mCallbacks.remove(callback);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 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
|
|
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("Display for adapter " + adapter.getName()
|
|
+ " assigned to Display " + adapter.getDisplayId());
|
|
DisplayDevice device = adapter.getDisplayDevice();
|
|
pw.print(" ");
|
|
device.getInfo(info);
|
|
pw.println(info);
|
|
}
|
|
}
|
|
|
|
public interface DisplayCallback {
|
|
public void displayAdded(int displayId);
|
|
public void displayRemoved(int displayId);
|
|
}
|
|
}
|