| /* |
| * 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.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> |
| */ |
| 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 SETTING_PATTERN = |
| Pattern.compile("(\\d+)x(\\d+)/(\\d+)(,[a-z]+)*"); |
| |
| // 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 matcher = SETTING_PATTERN.matcher(part); |
| if (matcher.matches()) { |
| if (count >= 4) { |
| Slog.w(TAG, "Too many overlay display devices specified: " + value); |
| break; |
| } |
| try { |
| int width = Integer.parseInt(matcher.group(1), 10); |
| int height = Integer.parseInt(matcher.group(2), 10); |
| int densityDpi = Integer.parseInt(matcher.group(3), 10); |
| String flagString = matcher.group(4); |
| if (width >= MIN_WIDTH && width <= MAX_WIDTH |
| && height >= MIN_HEIGHT && height <= MAX_HEIGHT |
| && densityDpi >= DisplayMetrics.DENSITY_LOW |
| && densityDpi <= DisplayMetrics.DENSITY_XXHIGH) { |
| 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 + ", width=" + width + ", height=" + height |
| + ", densityDpi=" + densityDpi + ", secure=" + secure); |
| |
| mOverlays.add(new OverlayDisplayHandle(name, |
| width, height, densityDpi, gravity, secure, number)); |
| continue; |
| } |
| } catch (NumberFormatException ex) { |
| } |
| } else if (part.isEmpty()) { |
| 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 final class OverlayDisplayDevice extends DisplayDevice { |
| private final String mName; |
| private final int mWidth; |
| private final int mHeight; |
| private final float mRefreshRate; |
| private final long mDisplayPresentationDeadlineNanos; |
| private final int mDensityDpi; |
| private final boolean mSecure; |
| |
| private int mState; |
| private SurfaceTexture mSurfaceTexture; |
| private Surface mSurface; |
| private DisplayDeviceInfo mInfo; |
| |
| public OverlayDisplayDevice(IBinder displayToken, String name, |
| int width, int height, float refreshRate, long presentationDeadlineNanos, |
| int densityDpi, boolean secure, int state, |
| SurfaceTexture surfaceTexture, int number) { |
| super(OverlayDisplayAdapter.this, displayToken, UNIQUE_ID_PREFIX + number); |
| mName = name; |
| mWidth = width; |
| mHeight = height; |
| mRefreshRate = refreshRate; |
| mDisplayPresentationDeadlineNanos = presentationDeadlineNanos; |
| mDensityDpi = densityDpi; |
| mSecure = secure; |
| mState = state; |
| mSurfaceTexture = surfaceTexture; |
| } |
| |
| public void destroyLocked() { |
| mSurfaceTexture = null; |
| if (mSurface != null) { |
| mSurface.release(); |
| mSurface = null; |
| } |
| SurfaceControl.destroyDisplay(getDisplayTokenLocked()); |
| } |
| |
| @Override |
| public void performTraversalInTransactionLocked() { |
| if (mSurfaceTexture != null) { |
| if (mSurface == null) { |
| mSurface = new Surface(mSurfaceTexture); |
| } |
| setSurfaceInTransactionLocked(mSurface); |
| } |
| } |
| |
| public void setStateLocked(int state) { |
| mState = state; |
| mInfo = null; |
| } |
| |
| @Override |
| public DisplayDeviceInfo getDisplayDeviceInfoLocked() { |
| if (mInfo == null) { |
| mInfo = new DisplayDeviceInfo(); |
| mInfo.name = mName; |
| mInfo.uniqueId = getUniqueId(); |
| mInfo.width = mWidth; |
| mInfo.height = mHeight; |
| mInfo.refreshRate = mRefreshRate; |
| mInfo.supportedRefreshRates = new float[] { mRefreshRate }; |
| mInfo.densityDpi = mDensityDpi; |
| mInfo.xDpi = mDensityDpi; |
| mInfo.yDpi = 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; |
| } |
| } |
| |
| /** |
| * 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 final String mName; |
| private final int mWidth; |
| private final int mHeight; |
| private final int mDensityDpi; |
| private final int mGravity; |
| private final boolean mSecure; |
| private final int mNumber; |
| |
| private OverlayDisplayWindow mWindow; |
| private OverlayDisplayDevice mDevice; |
| |
| public OverlayDisplayHandle(String name, int width, |
| int height, int densityDpi, int gravity, boolean secure, int number) { |
| mName = name; |
| mWidth = width; |
| mHeight = height; |
| mDensityDpi = densityDpi; |
| mGravity = gravity; |
| mSecure = secure; |
| mNumber = number; |
| |
| mUiHandler.post(mShowRunnable); |
| } |
| |
| public void dismissLocked() { |
| mUiHandler.removeCallbacks(mShowRunnable); |
| mUiHandler.post(mDismissRunnable); |
| } |
| |
| // 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, |
| mWidth, mHeight, refreshRate, presentationDeadlineNanos, |
| mDensityDpi, mSecure, state, surfaceTexture, mNumber); |
| |
| 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(" mWidth=" + mWidth); |
| pw.println(" mHeight=" + mHeight); |
| pw.println(" mDensityDpi=" + mDensityDpi); |
| 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() { |
| OverlayDisplayWindow window = new OverlayDisplayWindow(getContext(), |
| mName, mWidth, mHeight, 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(); |
| } |
| } |
| }; |
| } |
| } |