2 * Copyright (C) 2012 The Android Open Source Project
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
19 import android.animation.ValueAnimator;
20 import android.app.ActivityManager;
21 import android.content.ComponentCallbacks2;
22 import android.content.Context;
23 import android.content.pm.ApplicationInfo;
24 import android.content.res.Configuration;
25 import android.os.IBinder;
26 import android.os.RemoteException;
27 import android.os.ServiceManager;
28 import android.os.SystemProperties;
29 import android.util.AndroidRuntimeException;
30 import android.util.ArraySet;
31 import android.util.Log;
32 import android.view.inputmethod.InputMethodManager;
34 import com.android.internal.util.FastPrintWriter;
36 import java.io.FileDescriptor;
37 import java.io.FileOutputStream;
38 import java.io.PrintWriter;
39 import java.util.ArrayList;
42 * Provides low-level communication with the system window manager for
43 * operations that are not associated with any particular context.
45 * This class is only used internally to implement global functions where
46 * the caller already knows the display and relevant compatibility information
47 * for the operation. For most purposes, you should use {@link WindowManager} instead
48 * since it is bound to a context.
50 * @see WindowManagerImpl
53 public final class WindowManagerGlobal {
54 private static final String TAG = "WindowManager";
57 * The user is navigating with keys (not the touch screen), so
58 * navigational focus should be shown.
60 public static final int RELAYOUT_RES_IN_TOUCH_MODE = 0x1;
63 * This is the first time the window is being drawn,
64 * so the client must call drawingFinished() when done
66 public static final int RELAYOUT_RES_FIRST_TIME = 0x2;
69 * The window manager has changed the surface from the last call.
71 public static final int RELAYOUT_RES_SURFACE_CHANGED = 0x4;
74 * The window is being resized by dragging on the docked divider. The client should render
75 * at (0, 0) and extend its background to the background frame passed into
76 * {@link IWindow#resized}.
78 public static final int RELAYOUT_RES_DRAG_RESIZING_DOCKED = 0x8;
81 * The window is being resized by dragging one of the window corners,
82 * in this case the surface would be fullscreen-sized. The client should
83 * render to the actual frame location (instead of (0,curScrollY)).
85 public static final int RELAYOUT_RES_DRAG_RESIZING_FREEFORM = 0x10;
88 * The window manager has changed the size of the surface from the last call.
90 public static final int RELAYOUT_RES_SURFACE_RESIZED = 0x20;
93 * In multi-window we force show the navigation bar. Because we don't want that the surface size
94 * changes in this mode, we instead have a flag whether the navigation bar size should always be
95 * consumed, so the app is treated like there is no virtual navigation bar at all.
97 public static final int RELAYOUT_RES_CONSUME_ALWAYS_NAV_BAR = 0x40;
100 * Flag for relayout: the client will be later giving
101 * internal insets; as a result, the window will not impact other window
102 * layouts until the insets are given.
104 public static final int RELAYOUT_INSETS_PENDING = 0x1;
107 * Flag for relayout: the client may be currently using the current surface,
108 * so if it is to be destroyed as a part of the relayout the destroy must
109 * be deferred until later. The client will call performDeferredDestroy()
112 public static final int RELAYOUT_DEFER_SURFACE_DESTROY = 0x2;
114 public static final int ADD_FLAG_APP_VISIBLE = 0x2;
115 public static final int ADD_FLAG_IN_TOUCH_MODE = RELAYOUT_RES_IN_TOUCH_MODE;
118 * Like {@link #RELAYOUT_RES_CONSUME_ALWAYS_NAV_BAR}, but as a "hint" when adding the window.
120 public static final int ADD_FLAG_ALWAYS_CONSUME_NAV_BAR = 0x4;
122 public static final int ADD_OKAY = 0;
123 public static final int ADD_BAD_APP_TOKEN = -1;
124 public static final int ADD_BAD_SUBWINDOW_TOKEN = -2;
125 public static final int ADD_NOT_APP_TOKEN = -3;
126 public static final int ADD_APP_EXITING = -4;
127 public static final int ADD_DUPLICATE_ADD = -5;
128 public static final int ADD_STARTING_NOT_NEEDED = -6;
129 public static final int ADD_MULTIPLE_SINGLETON = -7;
130 public static final int ADD_PERMISSION_DENIED = -8;
131 public static final int ADD_INVALID_DISPLAY = -9;
132 public static final int ADD_INVALID_TYPE = -10;
134 private static WindowManagerGlobal sDefaultWindowManager;
135 private static IWindowManager sWindowManagerService;
136 private static IWindowSession sWindowSession;
138 private final Object mLock = new Object();
140 private final ArrayList<View> mViews = new ArrayList<View>();
141 private final ArrayList<ViewRootImpl> mRoots = new ArrayList<ViewRootImpl>();
142 private final ArrayList<WindowManager.LayoutParams> mParams =
143 new ArrayList<WindowManager.LayoutParams>();
144 private final ArraySet<View> mDyingViews = new ArraySet<View>();
146 private Runnable mSystemPropertyUpdater;
148 private WindowManagerGlobal() {
151 public static void initialize() {
152 getWindowManagerService();
155 public static WindowManagerGlobal getInstance() {
156 synchronized (WindowManagerGlobal.class) {
157 if (sDefaultWindowManager == null) {
158 sDefaultWindowManager = new WindowManagerGlobal();
160 return sDefaultWindowManager;
164 public static IWindowManager getWindowManagerService() {
165 synchronized (WindowManagerGlobal.class) {
166 if (sWindowManagerService == null) {
167 sWindowManagerService = IWindowManager.Stub.asInterface(
168 ServiceManager.getService("window"));
170 sWindowManagerService = getWindowManagerService();
171 ValueAnimator.setDurationScale(sWindowManagerService.getCurrentAnimatorScale());
172 } catch (RemoteException e) {
173 throw e.rethrowFromSystemServer();
176 return sWindowManagerService;
180 public static IWindowSession getWindowSession() {
181 synchronized (WindowManagerGlobal.class) {
182 if (sWindowSession == null) {
184 InputMethodManager imm = InputMethodManager.getInstance();
185 IWindowManager windowManager = getWindowManagerService();
186 sWindowSession = windowManager.openSession(
187 new IWindowSessionCallback.Stub() {
189 public void onAnimatorScaleChanged(float scale) {
190 ValueAnimator.setDurationScale(scale);
193 imm.getClient(), imm.getInputContext());
194 } catch (RemoteException e) {
195 throw e.rethrowFromSystemServer();
198 return sWindowSession;
202 public static IWindowSession peekWindowSession() {
203 synchronized (WindowManagerGlobal.class) {
204 return sWindowSession;
208 public String[] getViewRootNames() {
209 synchronized (mLock) {
210 final int numRoots = mRoots.size();
211 String[] mViewRoots = new String[numRoots];
212 for (int i = 0; i < numRoots; ++i) {
213 mViewRoots[i] = getWindowName(mRoots.get(i));
219 public ArrayList<ViewRootImpl> getRootViews(IBinder token) {
220 ArrayList<ViewRootImpl> views = new ArrayList<>();
221 synchronized (mLock) {
222 final int numRoots = mRoots.size();
223 for (int i = 0; i < numRoots; ++i) {
224 WindowManager.LayoutParams params = mParams.get(i);
225 if (params.token == null) {
228 if (params.token != token) {
229 boolean isChild = false;
230 if (params.type >= WindowManager.LayoutParams.FIRST_SUB_WINDOW
231 && params.type <= WindowManager.LayoutParams.LAST_SUB_WINDOW) {
232 for (int j = 0 ; j < numRoots; ++j) {
233 View viewj = mViews.get(j);
234 WindowManager.LayoutParams paramsj = mParams.get(j);
235 if (params.token == viewj.getWindowToken()
236 && paramsj.token == token) {
246 views.add(mRoots.get(i));
252 public View getRootView(String name) {
253 synchronized (mLock) {
254 for (int i = mRoots.size() - 1; i >= 0; --i) {
255 final ViewRootImpl root = mRoots.get(i);
256 if (name.equals(getWindowName(root))) return root.getView();
263 public void addView(View view, ViewGroup.LayoutParams params,
264 Display display, Window parentWindow) {
266 throw new IllegalArgumentException("view must not be null");
268 if (display == null) {
269 throw new IllegalArgumentException("display must not be null");
271 if (!(params instanceof WindowManager.LayoutParams)) {
272 throw new IllegalArgumentException("Params must be WindowManager.LayoutParams");
275 final WindowManager.LayoutParams wparams = (WindowManager.LayoutParams) params;
276 if (parentWindow != null) {
277 parentWindow.adjustLayoutParamsForSubWindow(wparams);
279 // If there's no parent, then hardware acceleration for this view is
280 // set from the application's hardware acceleration setting.
281 final Context context = view.getContext();
283 && (context.getApplicationInfo().flags
284 & ApplicationInfo.FLAG_HARDWARE_ACCELERATED) != 0) {
285 wparams.flags |= WindowManager.LayoutParams.FLAG_HARDWARE_ACCELERATED;
290 View panelParentView = null;
292 synchronized (mLock) {
293 // Start watching for system property changes.
294 if (mSystemPropertyUpdater == null) {
295 mSystemPropertyUpdater = new Runnable() {
296 @Override public void run() {
297 synchronized (mLock) {
298 for (int i = mRoots.size() - 1; i >= 0; --i) {
299 mRoots.get(i).loadSystemProperties();
304 SystemProperties.addChangeCallback(mSystemPropertyUpdater);
307 int index = findViewLocked(view, false);
309 if (mDyingViews.contains(view)) {
310 // Don't wait for MSG_DIE to make it's way through root's queue.
311 mRoots.get(index).doDie();
313 throw new IllegalStateException("View " + view
314 + " has already been added to the window manager.");
316 // The previous removeView() had not completed executing. Now it has.
319 // If this is a panel window, then find the window it is being
320 // attached to for future reference.
321 if (wparams.type >= WindowManager.LayoutParams.FIRST_SUB_WINDOW &&
322 wparams.type <= WindowManager.LayoutParams.LAST_SUB_WINDOW) {
323 final int count = mViews.size();
324 for (int i = 0; i < count; i++) {
325 if (mRoots.get(i).mWindow.asBinder() == wparams.token) {
326 panelParentView = mViews.get(i);
331 root = new ViewRootImpl(view.getContext(), display);
333 view.setLayoutParams(wparams);
337 mParams.add(wparams);
340 // do this last because it fires off messages to start doing things
342 root.setView(view, wparams, panelParentView);
343 } catch (RuntimeException e) {
344 // BadTokenException or InvalidDisplayException, clean up.
345 synchronized (mLock) {
346 final int index = findViewLocked(view, false);
348 removeViewLocked(index, true);
355 public void updateViewLayout(View view, ViewGroup.LayoutParams params) {
357 throw new IllegalArgumentException("view must not be null");
359 if (!(params instanceof WindowManager.LayoutParams)) {
360 throw new IllegalArgumentException("Params must be WindowManager.LayoutParams");
363 final WindowManager.LayoutParams wparams = (WindowManager.LayoutParams)params;
365 view.setLayoutParams(wparams);
367 synchronized (mLock) {
368 int index = findViewLocked(view, true);
369 ViewRootImpl root = mRoots.get(index);
370 mParams.remove(index);
371 mParams.add(index, wparams);
372 root.setLayoutParams(wparams, false);
376 public void removeView(View view, boolean immediate) {
378 throw new IllegalArgumentException("view must not be null");
381 synchronized (mLock) {
382 int index = findViewLocked(view, true);
383 View curView = mRoots.get(index).getView();
384 removeViewLocked(index, immediate);
385 if (curView == view) {
389 throw new IllegalStateException("Calling with view " + view
390 + " but the ViewAncestor is attached to " + curView);
394 public void closeAll(IBinder token, String who, String what) {
395 synchronized (mLock) {
396 int count = mViews.size();
397 //Log.i("foo", "Closing all windows of " + token);
398 for (int i = 0; i < count; i++) {
399 //Log.i("foo", "@ " + i + " token " + mParams[i].token
400 // + " view " + mRoots[i].getView());
401 if (token == null || mParams.get(i).token == token) {
402 ViewRootImpl root = mRoots.get(i);
404 //Log.i("foo", "Force closing " + root);
406 WindowLeaked leak = new WindowLeaked(
407 what + " " + who + " has leaked window "
408 + root.getView() + " that was originally added here");
409 leak.setStackTrace(root.getLocation().getStackTrace());
410 Log.e(TAG, "", leak);
413 removeViewLocked(i, false);
419 private void removeViewLocked(int index, boolean immediate) {
420 ViewRootImpl root = mRoots.get(index);
421 View view = root.getView();
424 InputMethodManager imm = InputMethodManager.getInstance();
426 imm.windowDismissed(mViews.get(index).getWindowToken());
429 boolean deferred = root.die(immediate);
431 view.assignParent(null);
433 mDyingViews.add(view);
438 void doRemoveView(ViewRootImpl root) {
439 synchronized (mLock) {
440 final int index = mRoots.indexOf(root);
442 mRoots.remove(index);
443 mParams.remove(index);
444 final View view = mViews.remove(index);
445 mDyingViews.remove(view);
448 if (ThreadedRenderer.sTrimForeground && ThreadedRenderer.isAvailable()) {
453 private int findViewLocked(View view, boolean required) {
454 final int index = mViews.indexOf(view);
455 if (required && index < 0) {
456 throw new IllegalArgumentException("View=" + view + " not attached to window manager");
461 public static boolean shouldDestroyEglContext(int trimLevel) {
462 // On low-end gfx devices we trim when memory is moderate;
463 // on high-end devices we do this when low.
464 if (trimLevel >= ComponentCallbacks2.TRIM_MEMORY_COMPLETE) {
467 if (trimLevel >= ComponentCallbacks2.TRIM_MEMORY_MODERATE
468 && !ActivityManager.isHighEndGfx()) {
474 public void trimMemory(int level) {
475 if (ThreadedRenderer.isAvailable()) {
476 if (shouldDestroyEglContext(level)) {
477 // Destroy all hardware surfaces and resources associated to
479 synchronized (mLock) {
480 for (int i = mRoots.size() - 1; i >= 0; --i) {
481 mRoots.get(i).destroyHardwareResources();
484 // Force a full memory flush
485 level = ComponentCallbacks2.TRIM_MEMORY_COMPLETE;
488 ThreadedRenderer.trimMemory(level);
490 if (ThreadedRenderer.sTrimForeground) {
496 public static void trimForeground() {
497 if (ThreadedRenderer.sTrimForeground && ThreadedRenderer.isAvailable()) {
498 WindowManagerGlobal wm = WindowManagerGlobal.getInstance();
499 wm.doTrimForeground();
503 private void doTrimForeground() {
504 boolean hasVisibleWindows = false;
505 synchronized (mLock) {
506 for (int i = mRoots.size() - 1; i >= 0; --i) {
507 final ViewRootImpl root = mRoots.get(i);
508 if (root.mView != null && root.getHostVisibility() == View.VISIBLE
509 && root.mAttachInfo.mHardwareRenderer != null) {
510 hasVisibleWindows = true;
512 root.destroyHardwareResources();
516 if (!hasVisibleWindows) {
517 ThreadedRenderer.trimMemory(
518 ComponentCallbacks2.TRIM_MEMORY_COMPLETE);
522 public void dumpGfxInfo(FileDescriptor fd, String[] args) {
523 FileOutputStream fout = new FileOutputStream(fd);
524 PrintWriter pw = new FastPrintWriter(fout);
526 synchronized (mLock) {
527 final int count = mViews.size();
529 pw.println("Profile data in ms:");
531 for (int i = 0; i < count; i++) {
532 ViewRootImpl root = mRoots.get(i);
533 String name = getWindowName(root);
534 pw.printf("\n\t%s (visibility=%d)", name, root.getHostVisibility());
536 ThreadedRenderer renderer =
537 root.getView().mAttachInfo.mHardwareRenderer;
538 if (renderer != null) {
539 renderer.dumpGfxInfo(pw, fd, args);
543 pw.println("\nView hierarchy:\n");
546 int displayListsSize = 0;
547 int[] info = new int[2];
549 for (int i = 0; i < count; i++) {
550 ViewRootImpl root = mRoots.get(i);
551 root.dumpGfxInfo(info);
553 String name = getWindowName(root);
554 pw.printf(" %s\n %d views, %.2f kB of display lists",
555 name, info[0], info[1] / 1024.0f);
558 viewsCount += info[0];
559 displayListsSize += info[1];
562 pw.printf("\nTotal ViewRootImpl: %d\n", count);
563 pw.printf("Total Views: %d\n", viewsCount);
564 pw.printf("Total DisplayList: %.2f kB\n\n", displayListsSize / 1024.0f);
571 private static String getWindowName(ViewRootImpl root) {
572 return root.mWindowAttributes.getTitle() + "/" +
573 root.getClass().getName() + '@' + Integer.toHexString(root.hashCode());
576 public void setStoppedState(IBinder token, boolean stopped) {
577 synchronized (mLock) {
578 int count = mViews.size();
579 for (int i = 0; i < count; i++) {
580 if (token == null || mParams.get(i).token == token) {
581 ViewRootImpl root = mRoots.get(i);
582 root.setWindowStopped(stopped);
588 public void reportNewConfiguration(Configuration config) {
589 synchronized (mLock) {
590 int count = mViews.size();
591 config = new Configuration(config);
592 for (int i=0; i < count; i++) {
593 ViewRootImpl root = mRoots.get(i);
594 root.requestUpdateConfiguration(config);
600 public void changeCanvasOpacity(IBinder token, boolean opaque) {
604 synchronized (mLock) {
605 for (int i = mParams.size() - 1; i >= 0; --i) {
606 if (mParams.get(i).token == token) {
607 mRoots.get(i).changeCanvasOpacity(opaque);
615 final class WindowLeaked extends AndroidRuntimeException {
616 public WindowLeaked(String msg) {