c652de8141
The window manager now keeps track of the overscan of each display, with an API to set it. The overscan impacts how it positions windows in the display. There is a new set of APIs for windows to say they would like to go into the overscan region. There is a call into the window manager to set the overscan region for a display, and it now has a concept of display settings that it stores presistently. Also added a new "wm" command, moving the window manager specific commands from the "am" command to there and adding a new now to set the overscan region. Change-Id: Id2c8092db64fd0a982274fedac7658d82f30f9ff
370 lines
12 KiB
Java
370 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.wm;
|
|
|
|
import static com.android.server.wm.WindowManagerService.FORWARD_ITERATOR;
|
|
import static com.android.server.wm.WindowManagerService.REVERSE_ITERATOR;
|
|
|
|
import android.graphics.Rect;
|
|
import android.os.Debug;
|
|
import android.util.Slog;
|
|
import android.util.SparseArray;
|
|
import android.view.Display;
|
|
import android.view.DisplayInfo;
|
|
|
|
import java.io.PrintWriter;
|
|
import java.util.ArrayList;
|
|
import java.util.Iterator;
|
|
import java.util.NoSuchElementException;
|
|
|
|
class DisplayContentList extends ArrayList<DisplayContent> {
|
|
}
|
|
|
|
/**
|
|
* Utility class for keeping track of the WindowStates and other pertinent contents of a
|
|
* particular Display.
|
|
*
|
|
* IMPORTANT: No method from this class should ever be used without holding
|
|
* WindowManagerService.mWindowMap.
|
|
*/
|
|
class DisplayContent {
|
|
// private final static String TAG = "DisplayContent";
|
|
|
|
/** Unique identifier of this stack. */
|
|
private final int mDisplayId;
|
|
|
|
/** Z-ordered (bottom-most first) list of all Window objects. Assigned to an element
|
|
* from mDisplayWindows; */
|
|
private WindowList mWindows = new WindowList();
|
|
|
|
// This protects the following display size properties, so that
|
|
// getDisplaySize() doesn't need to acquire the global lock. This is
|
|
// needed because the window manager sometimes needs to use ActivityThread
|
|
// while it has its global state locked (for example to load animation
|
|
// resources), but the ActivityThread also needs get the current display
|
|
// size sometimes when it has its package lock held.
|
|
//
|
|
// These will only be modified with both mWindowMap and mDisplaySizeLock
|
|
// held (in that order) so the window manager doesn't need to acquire this
|
|
// lock when needing these values in its normal operation.
|
|
final Object mDisplaySizeLock = new Object();
|
|
int mInitialDisplayWidth = 0;
|
|
int mInitialDisplayHeight = 0;
|
|
int mInitialDisplayDensity = 0;
|
|
int mBaseDisplayWidth = 0;
|
|
int mBaseDisplayHeight = 0;
|
|
int mBaseDisplayDensity = 0;
|
|
private final DisplayInfo mDisplayInfo = new DisplayInfo();
|
|
private final Display mDisplay;
|
|
|
|
// Accessed directly by all users.
|
|
boolean layoutNeeded;
|
|
int pendingLayoutChanges;
|
|
final boolean isDefaultDisplay;
|
|
|
|
/**
|
|
* Window tokens that are in the process of exiting, but still
|
|
* on screen for animations.
|
|
*/
|
|
final ArrayList<WindowToken> mExitingTokens = new ArrayList<WindowToken>();
|
|
|
|
/**
|
|
* Application tokens that are in the process of exiting, but still
|
|
* on screen for animations.
|
|
*/
|
|
final AppTokenList mExitingAppTokens = new AppTokenList();
|
|
|
|
/**
|
|
* Sorted most recent at top, oldest at [0].
|
|
*/
|
|
ArrayList<TaskList> mTaskLists = new ArrayList<TaskList>();
|
|
SparseArray<TaskList> mTaskIdToTaskList = new SparseArray<TaskList>();
|
|
|
|
private final AppTokenIterator mTmpAppIterator = new AppTokenIterator();
|
|
|
|
/**
|
|
* @param display May not be null.
|
|
*/
|
|
DisplayContent(Display display) {
|
|
mDisplay = display;
|
|
mDisplayId = display.getDisplayId();
|
|
display.getDisplayInfo(mDisplayInfo);
|
|
isDefaultDisplay = mDisplayId == Display.DEFAULT_DISPLAY;
|
|
}
|
|
|
|
int getDisplayId() {
|
|
return mDisplayId;
|
|
}
|
|
|
|
WindowList getWindowList() {
|
|
return mWindows;
|
|
}
|
|
|
|
Display getDisplay() {
|
|
return mDisplay;
|
|
}
|
|
|
|
DisplayInfo getDisplayInfo() {
|
|
return mDisplayInfo;
|
|
}
|
|
|
|
public void updateDisplayInfo() {
|
|
mDisplay.getDisplayInfo(mDisplayInfo);
|
|
}
|
|
|
|
/**
|
|
* Find the location to insert a new AppWindowToken into the window-ordered app token list.
|
|
* @param addPos The location the token was inserted into in mAppTokens.
|
|
* @param wtoken The token to insert.
|
|
*/
|
|
void addAppToken(final int addPos, final AppWindowToken wtoken) {
|
|
TaskList task = mTaskIdToTaskList.get(wtoken.groupId);
|
|
if (task == null) {
|
|
task = new TaskList(wtoken, this);
|
|
mTaskIdToTaskList.put(wtoken.groupId, task);
|
|
mTaskLists.add(task);
|
|
} else {
|
|
task.mAppTokens.add(wtoken);
|
|
}
|
|
}
|
|
|
|
void removeAppToken(final AppWindowToken wtoken) {
|
|
final int taskId = wtoken.groupId;
|
|
final TaskList task = mTaskIdToTaskList.get(taskId);
|
|
if (task != null) {
|
|
AppTokenList appTokens = task.mAppTokens;
|
|
appTokens.remove(wtoken);
|
|
if (appTokens.size() == 0) {
|
|
mTaskLists.remove(task);
|
|
mTaskIdToTaskList.delete(taskId);
|
|
}
|
|
}
|
|
}
|
|
|
|
void setAppTaskId(AppWindowToken wtoken, int newTaskId) {
|
|
final int taskId = wtoken.groupId;
|
|
TaskList task = mTaskIdToTaskList.get(taskId);
|
|
if (task != null) {
|
|
AppTokenList appTokens = task.mAppTokens;
|
|
appTokens.remove(wtoken);
|
|
if (appTokens.size() == 0) {
|
|
mTaskIdToTaskList.delete(taskId);
|
|
}
|
|
}
|
|
|
|
task = mTaskIdToTaskList.get(newTaskId);
|
|
if (task == null) {
|
|
task = new TaskList(wtoken, this);
|
|
mTaskIdToTaskList.put(newTaskId, task);
|
|
} else {
|
|
task.mAppTokens.add(wtoken);
|
|
}
|
|
|
|
wtoken.groupId = newTaskId;
|
|
}
|
|
|
|
/**
|
|
* Return the utility iterator so we don't have to construct new iterators every time we
|
|
* iterate.
|
|
* NOTE: Do not ever nest this call or you will have a bad time!
|
|
* @param reverse Direction of iterator.
|
|
* @return The utility iterator.
|
|
*/
|
|
AppTokenIterator getTmpAppIterator(boolean reverse) {
|
|
mTmpAppIterator.reset(reverse);
|
|
return mTmpAppIterator;
|
|
}
|
|
|
|
class TaskListsIterator implements Iterator<TaskList> {
|
|
private int mCur;
|
|
private boolean mReverse;
|
|
|
|
TaskListsIterator() {
|
|
this(false);
|
|
}
|
|
|
|
TaskListsIterator(boolean reverse) {
|
|
reset(reverse);
|
|
}
|
|
|
|
void reset(boolean reverse) {
|
|
mReverse = reverse;
|
|
mCur = reverse ? mTaskLists.size() - 1 : 0;
|
|
}
|
|
|
|
@Override
|
|
public boolean hasNext() {
|
|
if (mReverse) {
|
|
return mCur >= 0;
|
|
}
|
|
return mCur < mTaskLists.size();
|
|
}
|
|
|
|
@Override
|
|
public TaskList next() {
|
|
if (hasNext()) {
|
|
TaskList taskList = mTaskLists.get(mCur);
|
|
mCur += (mReverse ? -1 : 1);
|
|
return taskList;
|
|
}
|
|
throw new NoSuchElementException();
|
|
}
|
|
|
|
@Override
|
|
public void remove() {
|
|
throw new IllegalArgumentException();
|
|
}
|
|
}
|
|
|
|
class AppTokenIterator implements Iterator<AppWindowToken> {
|
|
final TaskListsIterator mIterator = new TaskListsIterator();
|
|
boolean mReverse;
|
|
int mCur;
|
|
TaskList mTaskList;
|
|
|
|
public AppTokenIterator() {
|
|
this(FORWARD_ITERATOR);
|
|
}
|
|
|
|
public AppTokenIterator(boolean reverse) {
|
|
reset(reverse);
|
|
}
|
|
|
|
void reset(boolean reverse) {
|
|
mReverse = reverse;
|
|
mIterator.reset(reverse);
|
|
getNextTaskList();
|
|
}
|
|
|
|
private void getNextTaskList() {
|
|
if (mIterator.hasNext()) {
|
|
mTaskList = mIterator.next();
|
|
mCur = mReverse ? mTaskList.mAppTokens.size() - 1 : 0;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean hasNext() {
|
|
if (mTaskList == null) {
|
|
return false;
|
|
}
|
|
if (mReverse) {
|
|
return mCur >= 0;
|
|
}
|
|
return mCur < mTaskList.mAppTokens.size();
|
|
}
|
|
|
|
@Override
|
|
public AppWindowToken next() {
|
|
if (hasNext()) {
|
|
AppWindowToken wtoken = mTaskList.mAppTokens.get(mCur);
|
|
mCur += mReverse ? -1 : 1;
|
|
if (!hasNext()) {
|
|
getNextTaskList();
|
|
}
|
|
return wtoken;
|
|
}
|
|
throw new NoSuchElementException();
|
|
}
|
|
|
|
@Override
|
|
public void remove() {
|
|
throw new IllegalArgumentException();
|
|
}
|
|
|
|
int size() {
|
|
int size = 0;
|
|
final TaskListsIterator iterator = new TaskListsIterator();
|
|
while (iterator.hasNext()) {
|
|
size += iterator.next().mAppTokens.size();
|
|
}
|
|
return size;
|
|
}
|
|
}
|
|
|
|
public void dump(String prefix, PrintWriter pw) {
|
|
pw.print(prefix); pw.print("Display: mDisplayId="); pw.println(mDisplayId);
|
|
final String subPrefix = " " + prefix;
|
|
pw.print(subPrefix); pw.print("init="); pw.print(mInitialDisplayWidth); pw.print("x");
|
|
pw.print(mInitialDisplayHeight); pw.print(" "); pw.print(mInitialDisplayDensity);
|
|
pw.print("dpi");
|
|
if (mInitialDisplayWidth != mBaseDisplayWidth
|
|
|| mInitialDisplayHeight != mBaseDisplayHeight
|
|
|| mInitialDisplayDensity != mBaseDisplayDensity) {
|
|
pw.print(" base=");
|
|
pw.print(mBaseDisplayWidth); pw.print("x"); pw.print(mBaseDisplayHeight);
|
|
pw.print(" "); pw.print(mBaseDisplayDensity); pw.print("dpi");
|
|
}
|
|
pw.print(" cur=");
|
|
pw.print(mDisplayInfo.logicalWidth);
|
|
pw.print("x"); pw.print(mDisplayInfo.logicalHeight);
|
|
pw.print(" app=");
|
|
pw.print(mDisplayInfo.appWidth);
|
|
pw.print("x"); pw.print(mDisplayInfo.appHeight);
|
|
pw.print(" rng="); pw.print(mDisplayInfo.smallestNominalAppWidth);
|
|
pw.print("x"); pw.print(mDisplayInfo.smallestNominalAppHeight);
|
|
pw.print("-"); pw.print(mDisplayInfo.largestNominalAppWidth);
|
|
pw.print("x"); pw.println(mDisplayInfo.largestNominalAppHeight);
|
|
pw.print(subPrefix); pw.print("layoutNeeded="); pw.println(layoutNeeded);
|
|
AppTokenIterator iterator = getTmpAppIterator(REVERSE_ITERATOR);
|
|
int ndx = iterator.size() - 1;
|
|
if (ndx >= 0) {
|
|
pw.println();
|
|
pw.println(" Application tokens in Z order:");
|
|
while (iterator.hasNext()) {
|
|
AppWindowToken wtoken = iterator.next();
|
|
pw.print(" App #"); pw.print(ndx--);
|
|
pw.print(' '); pw.print(wtoken); pw.println(":");
|
|
wtoken.dump(pw, " ");
|
|
}
|
|
}
|
|
if (mExitingTokens.size() > 0) {
|
|
pw.println();
|
|
pw.println(" Exiting tokens:");
|
|
for (int i=mExitingTokens.size()-1; i>=0; i--) {
|
|
WindowToken token = mExitingTokens.get(i);
|
|
pw.print(" Exiting #"); pw.print(i);
|
|
pw.print(' '); pw.print(token);
|
|
pw.println(':');
|
|
token.dump(pw, " ");
|
|
}
|
|
}
|
|
if (mExitingAppTokens.size() > 0) {
|
|
pw.println();
|
|
pw.println(" Exiting application tokens:");
|
|
for (int i=mExitingAppTokens.size()-1; i>=0; i--) {
|
|
WindowToken token = mExitingAppTokens.get(i);
|
|
pw.print(" Exiting App #"); pw.print(i);
|
|
pw.print(' '); pw.print(token);
|
|
pw.println(':');
|
|
token.dump(pw, " ");
|
|
}
|
|
}
|
|
if (mTaskIdToTaskList.size() > 0) {
|
|
pw.println();
|
|
for (int i = 0; i < mTaskIdToTaskList.size(); ++i) {
|
|
pw.print(" TaskList #"); pw.print(i);
|
|
pw.print(" taskId="); pw.println(mTaskIdToTaskList.keyAt(i));
|
|
pw.print(" mAppTokens=");
|
|
pw.println(mTaskIdToTaskList.valueAt(i).mAppTokens);
|
|
pw.println();
|
|
}
|
|
}
|
|
pw.println();
|
|
}
|
|
}
|