| /* |
| * 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_VIRTUAL; |
| 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(); |
| } |
| } |
| } |