/*
* 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 com.android.internal.util.DumpUtils;
import com.android.internal.util.IndentingPrintWriter;
import android.content.Context;
import android.database.ContentObserver;
import android.graphics.SurfaceTexture;
import android.os.Handler;
import android.os.IBinder;
import android.provider.Settings;
import android.util.DisplayMetrics;
import android.util.Slog;
import android.view.Display;
import android.view.Gravity;
import android.view.Surface;
import android.view.SurfaceControl;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* A display adapter that uses overlay windows to simulate secondary displays
* for development purposes. Use Development Settings to enable one or more
* overlay displays.
* <p>
* This object has two different handlers (which may be the same) which must not
* get confused. The main handler is used to posting messages to the display manager
* service as usual. The UI handler is only used by the {@link OverlayDisplayWindow}.
* </p><p>
* Display adapters are guarded by the {@link DisplayManagerService.SyncRoot} lock.
* </p><p>
* This adapter is configured via the
* {@link android.provider.Settings.Global#OVERLAY_DISPLAY_DEVICES} setting. This setting should be
* formatted as follows:
* <pre>
* [mode1]|[mode2]|...,[flag1],[flag2],...
* </pre>
* with each mode specified as:
* <pre>
* [width]x[height]/[densityDpi]
* </pre>
* Supported flags:
* <ul>
* <li><pre>secure</pre>: creates a secure display</li>
* </ul>
* </p>
*/
final class OverlayDisplayAdapter extends DisplayAdapter {
static final String TAG = "OverlayDisplayAdapter";
static final boolean DEBUG = false;
private static final int MIN_WIDTH = 100;
private static final int MIN_HEIGHT = 100;
private static final int MAX_WIDTH = 4096;
private static final int MAX_HEIGHT = 4096;
private static final Pattern DISPLAY_PATTERN =
Pattern.compile("([^,]+)(,[a-z]+)*");
private static final Pattern MODE_PATTERN =
Pattern.compile("(\\d+)x(\\d+)/(\\d+)");
// Unique id prefix for overlay displays.
private static final String UNIQUE_ID_PREFIX = "overlay:";
private final Handler mUiHandler;
private final ArrayList<OverlayDisplayHandle> mOverlays =
new ArrayList<OverlayDisplayHandle>();
private String mCurrentOverlaySetting = "";
// Called with SyncRoot lock held.
public OverlayDisplayAdapter(DisplayManagerService.SyncRoot syncRoot,
Context context, Handler handler, Listener listener, Handler uiHandler) {
super(syncRoot, context, handler, listener, TAG);
mUiHandler = uiHandler;
}
@Override
public void dumpLocked(PrintWriter pw) {
super.dumpLocked(pw);
pw.println("mCurrentOverlaySetting=" + mCurrentOverlaySetting);
pw.println("mOverlays: size=" + mOverlays.size());
for (OverlayDisplayHandle overlay : mOverlays) {
overlay.dumpLocked(pw);
}
}
@Override
public void registerLocked() {
super.registerLocked();
getHandler().post(new Runnable() {
@Override
public void run() {
getContext().getContentResolver().registerContentObserver(
Settings.Global.getUriFor(Settings.Global.OVERLAY_DISPLAY_DEVICES),
true, new ContentObserver(getHandler()) {
@Override
public void onChange(boolean selfChange) {
updateOverlayDisplayDevices();
}
});
updateOverlayDisplayDevices();
}
});
}
private void updateOverlayDisplayDevices() {
synchronized (getSyncRoot()) {
updateOverlayDisplayDevicesLocked();
}
}
private void updateOverlayDisplayDevicesLocked() {
String value = Settings.Global.getString(getContext().getContentResolver(),
Settings.Global.OVERLAY_DISPLAY_DEVICES);
if (value == null) {
value = "";
}
if (value.equals(mCurrentOverlaySetting)) {
return;
}
mCurrentOverlaySetting = value;
if (!mOverlays.isEmpty()) {
Slog.i(TAG, "Dismissing all overlay display devices.");
for (OverlayDisplayHandle overlay : mOverlays) {
overlay.dismissLocked();
}
mOverlays.clear();
}
int count = 0;
for (String part : value.split(";")) {
Matcher displayMatcher = DISPLAY_PATTERN.matcher(part);
if (displayMatcher.matches()) {
if (count >= 4) {
Slog.w(TAG, "Too many overlay display devices specified: " + value);
break;
}
String modeString = displayMatcher.group(1);
String flagString = displayMatcher.group(2);
ArrayList<OverlayMode> modes = new ArrayList<>();
for (String mode : modeString.split("\\|")) {
Matcher modeMatcher = MODE_PATTERN.matcher(mode);
if (modeMatcher.matches()) {
try {
int width = Integer.parseInt(modeMatcher.group(1), 10);
int height = Integer.parseInt(modeMatcher.group(2), 10);
int densityDpi = Integer.parseInt(modeMatcher.group(3), 10);
if (width >= MIN_WIDTH && width <= MAX_WIDTH
&& height >= MIN_HEIGHT && height <= MAX_HEIGHT
&& densityDpi >= DisplayMetrics.DENSITY_LOW
&& densityDpi <= DisplayMetrics.DENSITY_XXXHIGH) {
modes.add(new OverlayMode(width, height, densityDpi));
continue;
} else {
Slog.w(TAG, "Ignoring out-of-range overlay display mode: " + mode);
}
} catch (NumberFormatException ex) {
}
} else if (mode.isEmpty()) {
continue;
}
}
if (!modes.isEmpty()) {
int number = ++count;
String name = getContext().getResources().getString(
com.android.internal.R.string.display_manager_overlay_display_name,
number);
int gravity = chooseOverlayGravity(number);
boolean secure = flagString != null && flagString.contains(",secure");
Slog.i(TAG, "Showing overlay display device #" + number
+ ": name=" + name + ", modes=" + Arrays.toString(modes.toArray()));
mOverlays.add(new OverlayDisplayHandle(name, modes, gravity, secure, number));
continue;
}
}
Slog.w(TAG, "Malformed overlay display devices setting: " + value);
}
}
private static int chooseOverlayGravity(int overlayNumber) {
switch (overlayNumber) {
case 1:
return Gravity.TOP | Gravity.LEFT;
case 2:
return Gravity.BOTTOM | Gravity.RIGHT;
case 3:
return Gravity.TOP | Gravity.RIGHT;
case 4:
default:
return Gravity.BOTTOM | Gravity.LEFT;
}
}
private abstract class OverlayDisplayDevice extends DisplayDevice {
private final String mName;
private final float mRefreshRate;
private final long mDisplayPresentationDeadlineNanos;
private final boolean mSecure;
private final List<OverlayMode> mRawModes;
private final Display.Mode[] mModes;
private final int mDefaultMode;
private int mState;
private SurfaceTexture mSurfaceTexture;
private Surface mSurface;
private DisplayDeviceInfo mInfo;
private int mActiveMode;
public OverlayDisplayDevice(IBinder displayToken, String name,
List<OverlayMode> modes, int activeMode, int defaultMode,
float refreshRate, long presentationDeadlineNanos,
boolean secure, int state,
SurfaceTexture surfaceTexture, int number) {
super(OverlayDisplayAdapter.this, displayToken, UNIQUE_ID_PREFIX + number);
mName = name;
mRefreshRate = refreshRate;
mDisplayPresentationDeadlineNanos = presentationDeadlineNanos;
mSecure = secure;
mState = state;
mSurfaceTexture = surfaceTexture;
mRawModes = modes;
mModes = new Display.Mode[modes.size()];
for (int i = 0; i < modes.size(); i++) {
OverlayMode mode = modes.get(i);
mModes[i] = createMode(mode.mWidth, mode.mHeight, refreshRate);
}
mActiveMode = activeMode;
mDefaultMode = defaultMode;
}
public void destroyLocked() {
mSurfaceTexture = null;
if (mSurface != null) {
mSurface.release();
mSurface = null;
}
SurfaceControl.destroyDisplay(getDisplayTokenLocked());
}
@Override
public boolean hasStableUniqueId() {
return false;
}
@Override
public void performTraversalLocked(SurfaceControl.Transaction t) {
if (mSurfaceTexture != null) {
if (mSurface == null) {
mSurface = new Surface(mSurfaceTexture);
}
setSurfaceLocked(t, mSurface);
}
}
public void setStateLocked(int state) {
mState = state;
mInfo = null;
}
@Override
public DisplayDeviceInfo getDisplayDeviceInfoLocked() {
if (mInfo == null) {
Display.Mode mode = mModes[mActiveMode];
OverlayMode rawMode = mRawModes.get(mActiveMode);
mInfo = new DisplayDeviceInfo();
mInfo.name = mName;
mInfo.uniqueId = getUniqueId();
mInfo.width = mode.getPhysicalWidth();
mInfo.height = mode.getPhysicalHeight();
mInfo.modeId = mode.getModeId();
mInfo.defaultModeId = mModes[0].getModeId();
mInfo.supportedModes = mModes;
mInfo.densityDpi = rawMode.mDensityDpi;
mInfo.xDpi = rawMode.mDensityDpi;
mInfo.yDpi = rawMode.mDensityDpi;
mInfo.presentationDeadlineNanos = mDisplayPresentationDeadlineNanos +
1000000000L / (int) mRefreshRate; // display's deadline + 1 frame
mInfo.flags = DisplayDeviceInfo.FLAG_PRESENTATION;
if (mSecure) {
mInfo.flags |= DisplayDeviceInfo.FLAG_SECURE;
}
mInfo.type = Display.TYPE_OVERLAY;
mInfo.touch = DisplayDeviceInfo.TOUCH_NONE;
mInfo.state = mState;
}
return mInfo;
}
@Override
public void requestDisplayModesLocked(int color, int id) {
int index = -1;
if (id == 0) {
// Use the default.
index = 0;
} else {
for (int i = 0; i < mModes.length; i++) {
if (mModes[i].getModeId() == id) {
index = i;
break;
}
}
}
if (index == -1) {
Slog.w(TAG, "Unable to locate mode " + id + ", reverting to default.");
index = mDefaultMode;
}
if (mActiveMode == index) {
return;
}
mActiveMode = index;
mInfo = null;
sendDisplayDeviceEventLocked(this, DISPLAY_DEVICE_EVENT_CHANGED);
onModeChangedLocked(index);
}
/**
* Called when the device switched to a new mode.
*
* @param index index of the mode in the list of modes
*/
public abstract void onModeChangedLocked(int index);
}
/**
* Functions as a handle for overlay display devices which are created and
* destroyed asynchronously.
*
* Guarded by the {@link DisplayManagerService.SyncRoot} lock.
*/
private final class OverlayDisplayHandle implements OverlayDisplayWindow.Listener {
private static final int DEFAULT_MODE_INDEX = 0;
private final String mName;
private final List<OverlayMode> mModes;
private final int mGravity;
private final boolean mSecure;
private final int mNumber;
private OverlayDisplayWindow mWindow;
private OverlayDisplayDevice mDevice;
private int mActiveMode;
public OverlayDisplayHandle(String name, List<OverlayMode> modes, int gravity,
boolean secure, int number) {
mName = name;
mModes = modes;
mGravity = gravity;
mSecure = secure;
mNumber = number;
mActiveMode = 0;
showLocked();
}
private void showLocked() {
mUiHandler.post(mShowRunnable);
}
public void dismissLocked() {
mUiHandler.removeCallbacks(mShowRunnable);
mUiHandler.post(mDismissRunnable);
}
private void onActiveModeChangedLocked(int index) {
mUiHandler.removeCallbacks(mResizeRunnable);
mActiveMode = index;
if (mWindow != null) {
mUiHandler.post(mResizeRunnable);
}
}
// Called on the UI thread.
@Override
public void onWindowCreated(SurfaceTexture surfaceTexture, float refreshRate,
long presentationDeadlineNanos, int state) {
synchronized (getSyncRoot()) {
IBinder displayToken = SurfaceControl.createDisplay(mName, mSecure);
mDevice = new OverlayDisplayDevice(displayToken, mName, mModes, mActiveMode,
DEFAULT_MODE_INDEX, refreshRate, presentationDeadlineNanos,
mSecure, state, surfaceTexture, mNumber) {
@Override
public void onModeChangedLocked(int index) {
onActiveModeChangedLocked(index);
}
};
sendDisplayDeviceEventLocked(mDevice, DISPLAY_DEVICE_EVENT_ADDED);
}
}
// Called on the UI thread.
@Override
public void onWindowDestroyed() {
synchronized (getSyncRoot()) {
if (mDevice != null) {
mDevice.destroyLocked();
sendDisplayDeviceEventLocked(mDevice, DISPLAY_DEVICE_EVENT_REMOVED);
}
}
}
// Called on the UI thread.
@Override
public void onStateChanged(int state) {
synchronized (getSyncRoot()) {
if (mDevice != null) {
mDevice.setStateLocked(state);
sendDisplayDeviceEventLocked(mDevice, DISPLAY_DEVICE_EVENT_CHANGED);
}
}
}
public void dumpLocked(PrintWriter pw) {
pw.println(" " + mName + ":");
pw.println(" mModes=" + Arrays.toString(mModes.toArray()));
pw.println(" mActiveMode=" + mActiveMode);
pw.println(" mGravity=" + mGravity);
pw.println(" mSecure=" + mSecure);
pw.println(" mNumber=" + mNumber);
// Try to dump the window state.
if (mWindow != null) {
final IndentingPrintWriter ipw = new IndentingPrintWriter(pw, " ");
ipw.increaseIndent();
DumpUtils.dumpAsync(mUiHandler, mWindow, ipw, "", 200);
}
}
// Runs on the UI thread.
private final Runnable mShowRunnable = new Runnable() {
@Override
public void run() {
OverlayMode mode = mModes.get(mActiveMode);
OverlayDisplayWindow window = new OverlayDisplayWindow(getContext(),
mName, mode.mWidth, mode.mHeight, mode.mDensityDpi, mGravity, mSecure,
OverlayDisplayHandle.this);
window.show();
synchronized (getSyncRoot()) {
mWindow = window;
}
}
};
// Runs on the UI thread.
private final Runnable mDismissRunnable = new Runnable() {
@Override
public void run() {
OverlayDisplayWindow window;
synchronized (getSyncRoot()) {
window = mWindow;
mWindow = null;
}
if (window != null) {
window.dismiss();
}
}
};
// Runs on the UI thread.
private final Runnable mResizeRunnable = new Runnable() {
@Override
public void run() {
OverlayMode mode;
OverlayDisplayWindow window;
synchronized (getSyncRoot()) {
if (mWindow == null) {
return;
}
mode = mModes.get(mActiveMode);
window = mWindow;
}
window.resize(mode.mWidth, mode.mHeight, mode.mDensityDpi);
}
};
}
/**
* A display mode for an overlay display.
*/
private static final class OverlayMode {
final int mWidth;
final int mHeight;
final int mDensityDpi;
OverlayMode(int width, int height, int densityDpi) {
mWidth = width;
mHeight = height;
mDensityDpi = densityDpi;
}
@Override
public String toString() {
return new StringBuilder("{")
.append("width=").append(mWidth)
.append(", height=").append(mHeight)
.append(", densityDpi=").append(mDensityDpi)
.append("}")
.toString();
}
}
}