WindowManagerService.java revision 93884a5b35ec97a0f44795950363188d9a21137a 
1/*
2 * Copyright (C) 2007 The Android Open Source Project
3 *
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
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
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.
15 */
16
17package com.android.server.wm;
18
19import static android.view.WindowManager.LayoutParams.*;
20
21import static com.android.server.am.ActivityStackSupervisor.HOME_STACK_ID;
22
23import static android.view.WindowManagerPolicy.FINISH_LAYOUT_REDO_WALLPAPER;
24
25import android.app.AppOpsManager;
26import android.util.TimeUtils;
27import android.view.IWindowId;
28
29import com.android.internal.app.IBatteryStats;
30import com.android.internal.policy.PolicyManager;
31import com.android.internal.policy.impl.PhoneWindowManager;
32import com.android.internal.util.FastPrintWriter;
33import com.android.internal.view.IInputContext;
34import com.android.internal.view.IInputMethodClient;
35import com.android.internal.view.IInputMethodManager;
36import com.android.internal.view.WindowManagerPolicyThread;
37import com.android.server.AttributeCache;
38import com.android.server.EventLogTags;
39import com.android.server.UiThread;
40import com.android.server.Watchdog;
41import com.android.server.am.BatteryStatsService;
42import com.android.server.display.DisplayManagerService;
43import com.android.server.input.InputManagerService;
44import com.android.server.power.PowerManagerService;
45import com.android.server.power.ShutdownThread;
46
47import android.Manifest;
48import android.app.ActivityManagerNative;
49import android.app.IActivityManager;
50import android.app.StatusBarManager;
51import android.app.admin.DevicePolicyManager;
52import android.animation.ValueAnimator;
53import android.content.BroadcastReceiver;
54import android.content.Context;
55import android.content.Intent;
56import android.content.IntentFilter;
57import android.content.pm.ActivityInfo;
58import android.content.pm.PackageManager;
59import android.content.res.CompatibilityInfo;
60import android.content.res.Configuration;
61import android.graphics.Bitmap;
62import android.graphics.Bitmap.Config;
63import android.graphics.Canvas;
64import android.graphics.Matrix;
65import android.graphics.PixelFormat;
66import android.graphics.Point;
67import android.graphics.Rect;
68import android.graphics.RectF;
69import android.graphics.Region;
70import android.hardware.display.DisplayManager;
71import android.os.Binder;
72import android.os.Bundle;
73import android.os.Debug;
74import android.os.Handler;
75import android.os.IBinder;
76import android.os.IRemoteCallback;
77import android.os.Looper;
78import android.os.Message;
79import android.os.Parcel;
80import android.os.ParcelFileDescriptor;
81import android.os.PowerManager;
82import android.os.Process;
83import android.os.RemoteException;
84import android.os.ServiceManager;
85import android.os.StrictMode;
86import android.os.SystemClock;
87import android.os.SystemProperties;
88import android.os.Trace;
89import android.os.WorkSource;
90import android.provider.Settings;
91import android.util.DisplayMetrics;
92import android.util.EventLog;
93import android.util.FloatMath;
94import android.util.Log;
95import android.util.SparseArray;
96import android.util.Pair;
97import android.util.Slog;
98import android.util.SparseIntArray;
99import android.util.TypedValue;
100import android.view.Choreographer;
101import android.view.Display;
102import android.view.DisplayInfo;
103import android.view.Gravity;
104import android.view.IApplicationToken;
105import android.view.IInputFilter;
106import android.view.IMagnificationCallbacks;
107import android.view.IOnKeyguardExitResult;
108import android.view.IRotationWatcher;
109import android.view.IWindow;
110import android.view.IWindowManager;
111import android.view.IWindowSession;
112import android.view.InputChannel;
113import android.view.InputDevice;
114import android.view.InputEvent;
115import android.view.InputEventReceiver;
116import android.view.KeyEvent;
117import android.view.MagnificationSpec;
118import android.view.MotionEvent;
119import android.view.Surface.OutOfResourcesException;
120import android.view.Surface;
121import android.view.SurfaceControl;
122import android.view.SurfaceSession;
123import android.view.View;
124import android.view.ViewTreeObserver;
125import android.view.WindowManager;
126import android.view.WindowManagerGlobal;
127import android.view.WindowManagerPolicy;
128import android.view.WindowManager.LayoutParams;
129import android.view.WindowManagerPolicy.FakeWindow;
130import android.view.WindowManagerPolicy.PointerEventListener;
131import android.view.animation.Animation;
132import android.view.animation.AnimationUtils;
133import android.view.animation.Transformation;
134
135import java.io.BufferedWriter;
136import java.io.DataInputStream;
137import java.io.File;
138import java.io.FileDescriptor;
139import java.io.FileInputStream;
140import java.io.FileNotFoundException;
141import java.io.IOException;
142import java.io.OutputStream;
143import java.io.OutputStreamWriter;
144import java.io.PrintWriter;
145import java.io.StringWriter;
146import java.net.Socket;
147import java.text.DateFormat;
148import java.util.ArrayList;
149import java.util.Date;
150import java.util.HashMap;
151import java.util.HashSet;
152import java.util.Iterator;
153import java.util.List;
154
155/** {@hide} */
156public class WindowManagerService extends IWindowManager.Stub
157        implements Watchdog.Monitor, WindowManagerPolicy.WindowManagerFuncs,
158                DisplayManagerService.WindowManagerFuncs, DisplayManager.DisplayListener {
159    static final String TAG = "WindowManager";
160    static final boolean DEBUG = false;
161    static final boolean DEBUG_ADD_REMOVE = false;
162    static final boolean DEBUG_FOCUS = false;
163    static final boolean DEBUG_FOCUS_LIGHT = DEBUG_FOCUS || false;
164    static final boolean DEBUG_ANIM = false;
165    static final boolean DEBUG_LAYOUT = false;
166    static final boolean DEBUG_RESIZE = false;
167    static final boolean DEBUG_LAYERS = false;
168    static final boolean DEBUG_INPUT = false;
169    static final boolean DEBUG_INPUT_METHOD = false;
170    static final boolean DEBUG_VISIBILITY = false;
171    static final boolean DEBUG_WINDOW_MOVEMENT = false;
172    static final boolean DEBUG_TOKEN_MOVEMENT = false;
173    static final boolean DEBUG_ORIENTATION = false;
174    static final boolean DEBUG_APP_ORIENTATION = false;
175    static final boolean DEBUG_CONFIGURATION = false;
176    static final boolean DEBUG_APP_TRANSITIONS = false;
177    static final boolean DEBUG_STARTING_WINDOW = false;
178    static final boolean DEBUG_REORDER = false;
179    static final boolean DEBUG_WALLPAPER = false;
180    static final boolean DEBUG_WALLPAPER_LIGHT = false || DEBUG_WALLPAPER;
181    static final boolean DEBUG_DRAG = false;
182    static final boolean DEBUG_SCREEN_ON = false;
183    static final boolean DEBUG_SCREENSHOT = false;
184    static final boolean DEBUG_BOOT = false;
185    static final boolean DEBUG_LAYOUT_REPEATS = true;
186    static final boolean DEBUG_SURFACE_TRACE = false;
187    static final boolean DEBUG_WINDOW_TRACE = false;
188    static final boolean DEBUG_TASK_MOVEMENT = false;
189    static final boolean DEBUG_STACK = false;
190    static final boolean SHOW_SURFACE_ALLOC = false;
191    static final boolean SHOW_TRANSACTIONS = false;
192    static final boolean SHOW_LIGHT_TRANSACTIONS = false || SHOW_TRANSACTIONS;
193    static final boolean HIDE_STACK_CRAWLS = true;
194    static final int LAYOUT_REPEAT_THRESHOLD = 4;
195
196    static final boolean PROFILE_ORIENTATION = false;
197    static final boolean localLOGV = DEBUG;
198
199    /** How much to multiply the policy's type layer, to reserve room
200     * for multiple windows of the same type and Z-ordering adjustment
201     * with TYPE_LAYER_OFFSET. */
202    static final int TYPE_LAYER_MULTIPLIER = 10000;
203
204    /** Offset from TYPE_LAYER_MULTIPLIER for moving a group of windows above
205     * or below others in the same layer. */
206    static final int TYPE_LAYER_OFFSET = 1000;
207
208    /** How much to increment the layer for each window, to reserve room
209     * for effect surfaces between them.
210     */
211    static final int WINDOW_LAYER_MULTIPLIER = 5;
212
213    /**
214     * Dim surface layer is immediately below target window.
215     */
216    static final int LAYER_OFFSET_DIM = 1;
217
218    /**
219     * Blur surface layer is immediately below dim layer.
220     */
221    static final int LAYER_OFFSET_BLUR = 2;
222
223    /**
224     * FocusedStackFrame layer is immediately above focused window.
225     */
226    static final int LAYER_OFFSET_FOCUSED_STACK = 1;
227
228    /**
229     * Animation thumbnail is as far as possible below the window above
230     * the thumbnail (or in other words as far as possible above the window
231     * below it).
232     */
233    static final int LAYER_OFFSET_THUMBNAIL = WINDOW_LAYER_MULTIPLIER-1;
234
235    /**
236     * Layer at which to put the rotation freeze snapshot.
237     */
238    static final int FREEZE_LAYER = (TYPE_LAYER_MULTIPLIER * 200) + 1;
239
240    /**
241     * Layer at which to put the mask for emulated screen sizes.
242     */
243    static final int MASK_LAYER = TYPE_LAYER_MULTIPLIER * 200;
244
245    /** The maximum length we will accept for a loaded animation duration:
246     * this is 10 seconds.
247     */
248    static final int MAX_ANIMATION_DURATION = 10*1000;
249
250    /** Amount of time (in milliseconds) to animate the fade-in-out transition for
251     * compatible windows.
252     */
253    static final int DEFAULT_FADE_IN_OUT_DURATION = 400;
254
255    /** Amount of time (in milliseconds) to delay before declaring a window freeze timeout. */
256    static final int WINDOW_FREEZE_TIMEOUT_DURATION = 2000;
257
258    /** Amount of time (in milliseconds) to delay before declaring a starting window leaked. */
259    static final int STARTING_WINDOW_TIMEOUT_DURATION = 10000;
260
261    /**
262     * If true, the window manager will do its own custom freezing and general
263     * management of the screen during rotation.
264     */
265    static final boolean CUSTOM_SCREEN_ROTATION = true;
266
267    // Maximum number of milliseconds to wait for input devices to be enumerated before
268    // proceding with safe mode detection.
269    private static final int INPUT_DEVICES_READY_FOR_SAFE_MODE_DETECTION_TIMEOUT_MILLIS = 1000;
270
271    // Default input dispatching timeout in nanoseconds.
272    static final long DEFAULT_INPUT_DISPATCHING_TIMEOUT_NANOS = 5000 * 1000000L;
273
274    /** Minimum value for createStack and resizeStack weight value */
275    public static final float STACK_WEIGHT_MIN = 0.2f;
276
277    /** Maximum value for createStack and resizeStack weight value */
278    public static final float STACK_WEIGHT_MAX = 0.8f;
279
280    static final int UPDATE_FOCUS_NORMAL = 0;
281    static final int UPDATE_FOCUS_WILL_ASSIGN_LAYERS = 1;
282    static final int UPDATE_FOCUS_PLACING_SURFACES = 2;
283    static final int UPDATE_FOCUS_WILL_PLACE_SURFACES = 3;
284
285    private static final String SYSTEM_SECURE = "ro.secure";
286    private static final String SYSTEM_DEBUGGABLE = "ro.debuggable";
287
288    private static final String DENSITY_OVERRIDE = "ro.config.density_override";
289    private static final String SIZE_OVERRIDE = "ro.config.size_override";
290
291    private static final int MAX_SCREENSHOT_RETRIES = 3;
292
293    final private KeyguardDisableHandler mKeyguardDisableHandler;
294
295    final BroadcastReceiver mBroadcastReceiver = new BroadcastReceiver() {
296        @Override
297        public void onReceive(Context context, Intent intent) {
298            final String action = intent.getAction();
299            if (DevicePolicyManager.ACTION_DEVICE_POLICY_MANAGER_STATE_CHANGED.equals(action)) {
300                mKeyguardDisableHandler.sendEmptyMessage(
301                    KeyguardDisableHandler.KEYGUARD_POLICY_CHANGED);
302            }
303        }
304    };
305
306    // Current user when multi-user is enabled. Don't show windows of non-current user.
307    int mCurrentUserId;
308
309    final Context mContext;
310
311    final boolean mHaveInputMethods;
312
313    final boolean mAllowBootMessages;
314
315    final boolean mLimitedAlphaCompositing;
316
317    final WindowManagerPolicy mPolicy = PolicyManager.makeNewWindowManager();
318
319    final IActivityManager mActivityManager;
320
321    final IBatteryStats mBatteryStats;
322
323    final AppOpsManager mAppOps;
324
325    final DisplaySettings mDisplaySettings;
326
327    /**
328     * All currently active sessions with clients.
329     */
330    final HashSet<Session> mSessions = new HashSet<Session>();
331
332    /**
333     * Mapping from an IWindow IBinder to the server's Window object.
334     * This is also used as the lock for all of our state.
335     * NOTE: Never call into methods that lock ActivityManagerService while holding this object.
336     */
337    final HashMap<IBinder, WindowState> mWindowMap = new HashMap<IBinder, WindowState>();
338
339    /**
340     * Mapping from a token IBinder to a WindowToken object.
341     */
342    final HashMap<IBinder, WindowToken> mTokenMap = new HashMap<IBinder, WindowToken>();
343
344    /**
345     * List of window tokens that have finished starting their application,
346     * and now need to have the policy remove their windows.
347     */
348    final ArrayList<AppWindowToken> mFinishedStarting = new ArrayList<AppWindowToken>();
349
350    /**
351     * Fake windows added to the window manager.  Note: ordered from top to
352     * bottom, opposite of mWindows.
353     */
354    final ArrayList<FakeWindowImpl> mFakeWindows = new ArrayList<FakeWindowImpl>();
355
356    /**
357     * Windows that are being resized.  Used so we can tell the client about
358     * the resize after closing the transaction in which we resized the
359     * underlying surface.
360     */
361    final ArrayList<WindowState> mResizingWindows = new ArrayList<WindowState>();
362
363    /**
364     * Windows whose animations have ended and now must be removed.
365     */
366    final ArrayList<WindowState> mPendingRemove = new ArrayList<WindowState>();
367
368    /**
369     * Used when processing mPendingRemove to avoid working on the original array.
370     */
371    WindowState[] mPendingRemoveTmp = new WindowState[20];
372
373    /**
374     * Windows whose surface should be destroyed.
375     */
376    final ArrayList<WindowState> mDestroySurface = new ArrayList<WindowState>();
377
378    /**
379     * Windows that have lost input focus and are waiting for the new
380     * focus window to be displayed before they are told about this.
381     */
382    ArrayList<WindowState> mLosingFocus = new ArrayList<WindowState>();
383
384    /**
385     * This is set when we have run out of memory, and will either be an empty
386     * list or contain windows that need to be force removed.
387     */
388    ArrayList<WindowState> mForceRemoves;
389
390    /**
391     * Windows that clients are waiting to have drawn.
392     */
393    ArrayList<Pair<WindowState, IRemoteCallback>> mWaitingForDrawn
394            = new ArrayList<Pair<WindowState, IRemoteCallback>>();
395
396    /**
397     * Windows that have called relayout() while we were running animations,
398     * so we need to tell when the animation is done.
399     */
400    final ArrayList<WindowState> mRelayoutWhileAnimating = new ArrayList<WindowState>();
401
402    /**
403     * Used when rebuilding window list to keep track of windows that have
404     * been removed.
405     */
406    WindowState[] mRebuildTmp = new WindowState[20];
407
408    IInputMethodManager mInputMethodManager;
409
410    DisplayMagnifier mDisplayMagnifier;
411
412    final SurfaceSession mFxSession;
413    Watermark mWatermark;
414    StrictModeFlash mStrictModeFlash;
415    FocusedStackFrame mFocusedStackFrame;
416
417    int mFocusedStackLayer;
418
419    final float[] mTmpFloats = new float[9];
420    final Rect mTmpContentRect = new Rect();
421
422    boolean mDisplayReady;
423    boolean mSafeMode;
424    boolean mDisplayEnabled = false;
425    boolean mSystemBooted = false;
426    boolean mForceDisplayEnabled = false;
427    boolean mShowingBootMessages = false;
428
429    String mLastANRState;
430
431    /** All DisplayContents in the world, kept here */
432    SparseArray<DisplayContent> mDisplayContents = new SparseArray<DisplayContent>(2);
433
434    int mRotation = 0;
435    int mForcedAppOrientation = ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED;
436    boolean mAltOrientation = false;
437    ArrayList<IRotationWatcher> mRotationWatchers
438            = new ArrayList<IRotationWatcher>();
439    int mDeferredRotationPauseCount;
440
441    int mSystemDecorLayer = 0;
442    final Rect mScreenRect = new Rect();
443
444    boolean mTraversalScheduled = false;
445    boolean mDisplayFrozen = false;
446    long mDisplayFreezeTime = 0;
447    int mLastDisplayFreezeDuration = 0;
448    Object mLastFinishedFreezeSource = null;
449    boolean mWaitingForConfig = false;
450    boolean mWindowsFreezingScreen = false;
451    boolean mClientFreezingScreen = false;
452    int mAppsFreezingScreen = 0;
453    int mLastWindowForcedOrientation = ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED;
454
455    int mLayoutSeq = 0;
456
457    int mLastStatusBarVisibility = 0;
458
459    // State while inside of layoutAndPlaceSurfacesLocked().
460    boolean mFocusMayChange;
461
462    Configuration mCurConfiguration = new Configuration();
463
464    // This is held as long as we have the screen frozen, to give us time to
465    // perform a rotation animation when turning off shows the lock screen which
466    // changes the orientation.
467    private final PowerManager.WakeLock mScreenFrozenLock;
468
469    final AppTransition mAppTransition;
470    boolean mStartingIconInTransition = false;
471    boolean mSkipAppTransitionAnimation = false;
472
473    final ArrayList<AppWindowToken> mOpeningApps = new ArrayList<AppWindowToken>();
474    final ArrayList<AppWindowToken> mClosingApps = new ArrayList<AppWindowToken>();
475
476    boolean mIsTouchDevice;
477
478    final DisplayMetrics mDisplayMetrics = new DisplayMetrics();
479    final DisplayMetrics mRealDisplayMetrics = new DisplayMetrics();
480    final DisplayMetrics mTmpDisplayMetrics = new DisplayMetrics();
481    final DisplayMetrics mCompatDisplayMetrics = new DisplayMetrics();
482
483    final H mH = new H();
484
485    final Choreographer mChoreographer = Choreographer.getInstance();
486
487    WindowState mCurrentFocus = null;
488    WindowState mLastFocus = null;
489
490    /** This just indicates the window the input method is on top of, not
491     * necessarily the window its input is going to. */
492    WindowState mInputMethodTarget = null;
493
494    /** If true hold off on modifying the animation layer of mInputMethodTarget */
495    boolean mInputMethodTargetWaitingAnim;
496    int mInputMethodAnimLayerAdjustment;
497
498    WindowState mInputMethodWindow = null;
499    final ArrayList<WindowState> mInputMethodDialogs = new ArrayList<WindowState>();
500
501    boolean mHardKeyboardAvailable;
502    boolean mHardKeyboardEnabled;
503    OnHardKeyboardStatusChangeListener mHardKeyboardStatusChangeListener;
504
505    final ArrayList<WindowToken> mWallpaperTokens = new ArrayList<WindowToken>();
506
507    // If non-null, this is the currently visible window that is associated
508    // with the wallpaper.
509    WindowState mWallpaperTarget = null;
510    // If non-null, we are in the middle of animating from one wallpaper target
511    // to another, and this is the lower one in Z-order.
512    WindowState mLowerWallpaperTarget = null;
513    // If non-null, we are in the middle of animating from one wallpaper target
514    // to another, and this is the higher one in Z-order.
515    WindowState mUpperWallpaperTarget = null;
516    int mWallpaperAnimLayerAdjustment;
517    float mLastWallpaperX = -1;
518    float mLastWallpaperY = -1;
519    float mLastWallpaperXStep = -1;
520    float mLastWallpaperYStep = -1;
521    // This is set when we are waiting for a wallpaper to tell us it is done
522    // changing its scroll position.
523    WindowState mWaitingOnWallpaper;
524    // The last time we had a timeout when waiting for a wallpaper.
525    long mLastWallpaperTimeoutTime;
526    // We give a wallpaper up to 150ms to finish scrolling.
527    static final long WALLPAPER_TIMEOUT = 150;
528    // Time we wait after a timeout before trying to wait again.
529    static final long WALLPAPER_TIMEOUT_RECOVERY = 10000;
530    boolean mAnimateWallpaperWithTarget;
531
532    AppWindowToken mFocusedApp = null;
533
534    PowerManagerService mPowerManager;
535
536    float mWindowAnimationScale = 1.0f;
537    float mTransitionAnimationScale = 1.0f;
538    float mAnimatorDurationScale = 1.0f;
539
540    final InputManagerService mInputManager;
541    final DisplayManagerService mDisplayManagerService;
542    final DisplayManager mDisplayManager;
543
544    // Who is holding the screen on.
545    Session mHoldingScreenOn;
546    PowerManager.WakeLock mHoldingScreenWakeLock;
547
548    boolean mTurnOnScreen;
549
550    DragState mDragState = null;
551
552    // For frozen screen animations.
553    int mExitAnimId, mEnterAnimId;
554
555    /** Pulled out of performLayoutAndPlaceSurfacesLockedInner in order to refactor into multiple
556     * methods. */
557    class LayoutFields {
558        static final int SET_UPDATE_ROTATION                = 1 << 0;
559        static final int SET_WALLPAPER_MAY_CHANGE           = 1 << 1;
560        static final int SET_FORCE_HIDING_CHANGED           = 1 << 2;
561        static final int SET_ORIENTATION_CHANGE_COMPLETE    = 1 << 3;
562        static final int SET_TURN_ON_SCREEN                 = 1 << 4;
563        static final int SET_WALLPAPER_ACTION_PENDING       = 1 << 5;
564
565        boolean mWallpaperForceHidingChanged = false;
566        boolean mWallpaperMayChange = false;
567        boolean mOrientationChangeComplete = true;
568        Object mLastWindowFreezeSource = null;
569        private Session mHoldScreen = null;
570        private boolean mObscured = false;
571        private boolean mSyswin = false;
572        private float mScreenBrightness = -1;
573        private float mButtonBrightness = -1;
574        private long mUserActivityTimeout = -1;
575        private boolean mUpdateRotation = false;
576        boolean mWallpaperActionPending = false;
577
578        // Set to true when the display contains content to show the user.
579        // When false, the display manager may choose to mirror or blank the display.
580        boolean mDisplayHasContent = false;
581
582        // Only set while traversing the default display based on its content.
583        // Affects the behavior of mirroring on secondary displays.
584        boolean mObscureApplicationContentOnSecondaryDisplays = false;
585    }
586    final LayoutFields mInnerFields = new LayoutFields();
587
588    boolean mAnimationScheduled;
589
590    /** Skip repeated AppWindowTokens initialization. Note that AppWindowsToken's version of this
591     * is a long initialized to Long.MIN_VALUE so that it doesn't match this value on startup. */
592    private int mTransactionSequence;
593
594    /** Only do a maximum of 6 repeated layouts. After that quit */
595    private int mLayoutRepeatCount;
596
597    final WindowAnimator mAnimator;
598
599    SparseArray<Task> mTaskIdToTask = new SparseArray<Task>();
600    SparseArray<TaskStack> mStackIdToStack = new SparseArray<TaskStack>();
601
602    private final PointerEventDispatcher mPointerEventDispatcher;
603
604    final class DragInputEventReceiver extends InputEventReceiver {
605        public DragInputEventReceiver(InputChannel inputChannel, Looper looper) {
606            super(inputChannel, looper);
607        }
608
609        @Override
610        public void onInputEvent(InputEvent event) {
611            boolean handled = false;
612            try {
613                if (event instanceof MotionEvent
614                        && (event.getSource() & InputDevice.SOURCE_CLASS_POINTER) != 0
615                        && mDragState != null) {
616                    final MotionEvent motionEvent = (MotionEvent)event;
617                    boolean endDrag = false;
618                    final float newX = motionEvent.getRawX();
619                    final float newY = motionEvent.getRawY();
620
621                    switch (motionEvent.getAction()) {
622                    case MotionEvent.ACTION_DOWN: {
623                        if (DEBUG_DRAG) {
624                            Slog.w(TAG, "Unexpected ACTION_DOWN in drag layer");
625                        }
626                    } break;
627
628                    case MotionEvent.ACTION_MOVE: {
629                        synchronized (mWindowMap) {
630                            // move the surface and tell the involved window(s) where we are
631                            mDragState.notifyMoveLw(newX, newY);
632                        }
633                    } break;
634
635                    case MotionEvent.ACTION_UP: {
636                        if (DEBUG_DRAG) Slog.d(TAG, "Got UP on move channel; dropping at "
637                                + newX + "," + newY);
638                        synchronized (mWindowMap) {
639                            endDrag = mDragState.notifyDropLw(newX, newY);
640                        }
641                    } break;
642
643                    case MotionEvent.ACTION_CANCEL: {
644                        if (DEBUG_DRAG) Slog.d(TAG, "Drag cancelled!");
645                        endDrag = true;
646                    } break;
647                    }
648
649                    if (endDrag) {
650                        if (DEBUG_DRAG) Slog.d(TAG, "Drag ended; tearing down state");
651                        // tell all the windows that the drag has ended
652                        synchronized (mWindowMap) {
653                            mDragState.endDragLw();
654                        }
655                    }
656
657                    handled = true;
658                }
659            } catch (Exception e) {
660                Slog.e(TAG, "Exception caught by drag handleMotion", e);
661            } finally {
662                finishInputEvent(event, handled);
663            }
664        }
665    }
666
667    /**
668     * Whether the UI is currently running in touch mode (not showing
669     * navigational focus because the user is directly pressing the screen).
670     */
671    boolean mInTouchMode = true;
672
673    private ViewServer mViewServer;
674    private final ArrayList<WindowChangeListener> mWindowChangeListeners =
675        new ArrayList<WindowChangeListener>();
676    private boolean mWindowsChanged = false;
677
678    public interface WindowChangeListener {
679        public void windowsChanged();
680        public void focusChanged();
681    }
682
683    final Configuration mTempConfiguration = new Configuration();
684
685    // The desired scaling factor for compatible apps.
686    float mCompatibleScreenScale;
687
688    // If true, only the core apps and services are being launched because the device
689    // is in a special boot mode, such as being encrypted or waiting for a decryption password.
690    // For example, when this flag is true, there will be no wallpaper service.
691    final boolean mOnlyCore;
692
693    public static WindowManagerService main(final Context context,
694            final PowerManagerService pm, final DisplayManagerService dm,
695            final InputManagerService im, final Handler wmHandler,
696            final boolean haveInputMethods, final boolean showBootMsgs,
697            final boolean onlyCore) {
698        final WindowManagerService[] holder = new WindowManagerService[1];
699        wmHandler.runWithScissors(new Runnable() {
700            @Override
701            public void run() {
702                holder[0] = new WindowManagerService(context, pm, dm, im,
703                        haveInputMethods, showBootMsgs, onlyCore);
704            }
705        }, 0);
706        return holder[0];
707    }
708
709    private void initPolicy(Handler uiHandler) {
710        uiHandler.runWithScissors(new Runnable() {
711            @Override
712            public void run() {
713                WindowManagerPolicyThread.set(Thread.currentThread(), Looper.myLooper());
714
715                mPolicy.init(mContext, WindowManagerService.this, WindowManagerService.this);
716                mAnimator.mAboveUniverseLayer = mPolicy.getAboveUniverseLayer()
717                        * TYPE_LAYER_MULTIPLIER
718                        + TYPE_LAYER_OFFSET;
719            }
720        }, 0);
721    }
722
723    private WindowManagerService(Context context, PowerManagerService pm,
724            DisplayManagerService displayManager, InputManagerService inputManager,
725            boolean haveInputMethods, boolean showBootMsgs, boolean onlyCore) {
726        mContext = context;
727        mHaveInputMethods = haveInputMethods;
728        mAllowBootMessages = showBootMsgs;
729        mOnlyCore = onlyCore;
730        mLimitedAlphaCompositing = context.getResources().getBoolean(
731                com.android.internal.R.bool.config_sf_limitedAlpha);
732        mInputManager = inputManager; // Must be before createDisplayContentLocked.
733        mDisplayManagerService = displayManager;
734        mDisplaySettings = new DisplaySettings(context);
735        mDisplaySettings.readSettingsLocked();
736
737        mPointerEventDispatcher = new PointerEventDispatcher(mInputManager.monitorInput(TAG));
738
739        mFxSession = new SurfaceSession();
740        mDisplayManager = (DisplayManager)context.getSystemService(Context.DISPLAY_SERVICE);
741        mDisplayManager.registerDisplayListener(this, null);
742        Display[] displays = mDisplayManager.getDisplays();
743        for (Display display : displays) {
744            createDisplayContentLocked(display);
745        }
746
747        mKeyguardDisableHandler = new KeyguardDisableHandler(mContext, mPolicy);
748
749        mPowerManager = pm;
750        mPowerManager.setPolicy(mPolicy);
751        PowerManager pmc = (PowerManager)context.getSystemService(Context.POWER_SERVICE);
752        mScreenFrozenLock = pmc.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "SCREEN_FROZEN");
753        mScreenFrozenLock.setReferenceCounted(false);
754
755        mAppTransition = new AppTransition(context, mH);
756
757        mActivityManager = ActivityManagerNative.getDefault();
758        mBatteryStats = BatteryStatsService.getService();
759        mAppOps = (AppOpsManager)context.getSystemService(Context.APP_OPS_SERVICE);
760        mAppOps.startWatchingMode(AppOpsManager.OP_SYSTEM_ALERT_WINDOW, null,
761                new AppOpsManager.OnOpChangedInternalListener() {
762                    @Override
763                    public void onOpChanged(int op, String packageName) {
764                        updateAppOpsState();
765                    }
766                }
767        );
768
769        // Get persisted window scale setting
770        mWindowAnimationScale = Settings.Global.getFloat(context.getContentResolver(),
771                Settings.Global.WINDOW_ANIMATION_SCALE, mWindowAnimationScale);
772        mTransitionAnimationScale = Settings.Global.getFloat(context.getContentResolver(),
773                Settings.Global.TRANSITION_ANIMATION_SCALE, mTransitionAnimationScale);
774        setAnimatorDurationScale(Settings.Global.getFloat(context.getContentResolver(),
775                Settings.Global.ANIMATOR_DURATION_SCALE, mAnimatorDurationScale));
776
777        // Track changes to DevicePolicyManager state so we can enable/disable keyguard.
778        IntentFilter filter = new IntentFilter();
779        filter.addAction(DevicePolicyManager.ACTION_DEVICE_POLICY_MANAGER_STATE_CHANGED);
780        mContext.registerReceiver(mBroadcastReceiver, filter);
781
782        mHoldingScreenWakeLock = pmc.newWakeLock(PowerManager.SCREEN_BRIGHT_WAKE_LOCK
783                | PowerManager.ON_AFTER_RELEASE, TAG);
784        mHoldingScreenWakeLock.setReferenceCounted(false);
785
786        mAnimator = new WindowAnimator(this);
787
788        initPolicy(UiThread.getHandler());
789
790        // Add ourself to the Watchdog monitors.
791        Watchdog.getInstance().addMonitor(this);
792
793        SurfaceControl.openTransaction();
794        try {
795            createWatermarkInTransaction();
796            mFocusedStackFrame = new FocusedStackFrame(
797                    getDefaultDisplayContentLocked().getDisplay(), mFxSession);
798        } finally {
799            SurfaceControl.closeTransaction();
800        }
801    }
802
803    public InputMonitor getInputMonitor() {
804        return mInputMonitor;
805    }
806
807    @Override
808    public boolean onTransact(int code, Parcel data, Parcel reply, int flags)
809            throws RemoteException {
810        try {
811            return super.onTransact(code, data, reply, flags);
812        } catch (RuntimeException e) {
813            // The window manager only throws security exceptions, so let's
814            // log all others.
815            if (!(e instanceof SecurityException)) {
816                Slog.wtf(TAG, "Window Manager Crash", e);
817            }
818            throw e;
819        }
820    }
821
822    private void placeWindowAfter(WindowState pos, WindowState window) {
823        final WindowList windows = pos.getWindowList();
824        final int i = windows.indexOf(pos);
825        if (DEBUG_FOCUS || DEBUG_WINDOW_MOVEMENT || DEBUG_ADD_REMOVE) Slog.v(
826            TAG, "Adding window " + window + " at "
827            + (i+1) + " of " + windows.size() + " (after " + pos + ")");
828        windows.add(i+1, window);
829        mWindowsChanged = true;
830    }
831
832    private void placeWindowBefore(WindowState pos, WindowState window) {
833        final WindowList windows = pos.getWindowList();
834        int i = windows.indexOf(pos);
835        if (DEBUG_FOCUS || DEBUG_WINDOW_MOVEMENT || DEBUG_ADD_REMOVE) Slog.v(
836            TAG, "Adding window " + window + " at "
837            + i + " of " + windows.size() + " (before " + pos + ")");
838        if (i < 0) {
839            Slog.w(TAG, "placeWindowBefore: Unable to find " + pos + " in " + windows);
840            i = 0;
841        }
842        windows.add(i, window);
843        mWindowsChanged = true;
844    }
845
846    //This method finds out the index of a window that has the same app token as
847    //win. used for z ordering the windows in mWindows
848    private int findIdxBasedOnAppTokens(WindowState win) {
849        WindowList windows = win.getWindowList();
850        for(int j = windows.size() - 1; j >= 0; j--) {
851            WindowState wentry = windows.get(j);
852            if(wentry.mAppToken == win.mAppToken) {
853                return j;
854            }
855        }
856        return -1;
857    }
858
859    /**
860     * Return the list of Windows from the passed token on the given Display.
861     * @param token The token with all the windows.
862     * @param displayContent The display we are interested in.
863     * @return List of windows from token that are on displayContent.
864     */
865    WindowList getTokenWindowsOnDisplay(WindowToken token, DisplayContent displayContent) {
866        final WindowList windowList = new WindowList();
867        final int count = token.windows.size();
868        for (int i = 0; i < count; i++) {
869            final WindowState win = token.windows.get(i);
870            if (win.mDisplayContent == displayContent) {
871                windowList.add(win);
872            }
873        }
874        return windowList;
875    }
876
877    /**
878     * Recursive search through a WindowList and all of its windows' children.
879     * @param targetWin The window to search for.
880     * @param windows The list to search.
881     * @return The index of win in windows or of the window that is an ancestor of win.
882     */
883    private int indexOfWinInWindowList(WindowState targetWin, WindowList windows) {
884        for (int i = windows.size() - 1; i >= 0; i--) {
885            final WindowState w = windows.get(i);
886            if (w == targetWin) {
887                return i;
888            }
889            if (!w.mChildWindows.isEmpty()) {
890                if (indexOfWinInWindowList(targetWin, w.mChildWindows) >= 0) {
891                    return i;
892                }
893            }
894        }
895        return -1;
896    }
897
898    private int addAppWindowToListLocked(final WindowState win) {
899        final IWindow client = win.mClient;
900        final WindowToken token = win.mToken;
901        final DisplayContent displayContent = win.mDisplayContent;
902
903        final WindowList windows = win.getWindowList();
904        final int N = windows.size();
905        WindowList tokenWindowList = getTokenWindowsOnDisplay(token, displayContent);
906        int tokenWindowsPos = 0;
907        int windowListPos = tokenWindowList.size();
908        if (!tokenWindowList.isEmpty()) {
909            // If this application has existing windows, we
910            // simply place the new window on top of them... but
911            // keep the starting window on top.
912            if (win.mAttrs.type == TYPE_BASE_APPLICATION) {
913                // Base windows go behind everything else.
914                WindowState lowestWindow = tokenWindowList.get(0);
915                placeWindowBefore(lowestWindow, win);
916                tokenWindowsPos = indexOfWinInWindowList(lowestWindow, token.windows);
917            } else {
918                AppWindowToken atoken = win.mAppToken;
919                WindowState lastWindow = tokenWindowList.get(windowListPos - 1);
920                if (atoken != null && lastWindow == atoken.startingWindow) {
921                    placeWindowBefore(lastWindow, win);
922                    tokenWindowsPos = indexOfWinInWindowList(lastWindow, token.windows);
923                } else {
924                    int newIdx = findIdxBasedOnAppTokens(win);
925                    //there is a window above this one associated with the same
926                    //apptoken note that the window could be a floating window
927                    //that was created later or a window at the top of the list of
928                    //windows associated with this token.
929                    if (DEBUG_FOCUS_LIGHT || DEBUG_WINDOW_MOVEMENT || DEBUG_ADD_REMOVE) Slog.v(TAG,
930                            "not Base app: Adding window " + win + " at " + (newIdx + 1) + " of " +
931                            N);
932                    windows.add(newIdx + 1, win);
933                    if (newIdx < 0) {
934                        // No window from token found on win's display.
935                        tokenWindowsPos = 0;
936                    } else {
937                        tokenWindowsPos = indexOfWinInWindowList(
938                                windows.get(newIdx), token.windows) + 1;
939                    }
940                    mWindowsChanged = true;
941                }
942            }
943            return tokenWindowsPos;
944        }
945
946        // No windows from this token on this display
947        if (localLOGV) Slog.v(TAG, "Figuring out where to add app window " + client.asBinder()
948                + " (token=" + token + ")");
949        // Figure out where the window should go, based on the
950        // order of applications.
951        WindowState pos = null;
952
953        final ArrayList<Task> tasks = displayContent.getTasks();
954        int taskNdx;
955        int tokenNdx = -1;
956        for (taskNdx = tasks.size() - 1; taskNdx >= 0; --taskNdx) {
957            AppTokenList tokens = tasks.get(taskNdx).mAppTokens;
958            for (tokenNdx = tokens.size() - 1; tokenNdx >= 0; --tokenNdx) {
959                final AppWindowToken t = tokens.get(tokenNdx);
960                if (t == token) {
961                    --tokenNdx;
962                    if (tokenNdx < 0) {
963                        --taskNdx;
964                        if (taskNdx >= 0) {
965                            tokenNdx = tasks.get(taskNdx).mAppTokens.size() - 1;
966                        }
967                    }
968                    break;
969                }
970
971                // We haven't reached the token yet; if this token
972                // is not going to the bottom and has windows on this display, we can
973                // use it as an anchor for when we do reach the token.
974                tokenWindowList = getTokenWindowsOnDisplay(t, displayContent);
975                if (!t.sendingToBottom && tokenWindowList.size() > 0) {
976                    pos = tokenWindowList.get(0);
977                }
978            }
979            if (tokenNdx >= 0) {
980                // early exit
981                break;
982            }
983        }
984
985        // We now know the index into the apps.  If we found
986        // an app window above, that gives us the position; else
987        // we need to look some more.
988        if (pos != null) {
989            // Move behind any windows attached to this one.
990            WindowToken atoken = mTokenMap.get(pos.mClient.asBinder());
991            if (atoken != null) {
992                tokenWindowList =
993                        getTokenWindowsOnDisplay(atoken, displayContent);
994                final int NC = tokenWindowList.size();
995                if (NC > 0) {
996                    WindowState bottom = tokenWindowList.get(0);
997                    if (bottom.mSubLayer < 0) {
998                        pos = bottom;
999                    }
1000                }
1001            }
1002            placeWindowBefore(pos, win);
1003            return tokenWindowsPos;
1004        }
1005
1006        // Continue looking down until we find the first
1007        // token that has windows on this display.
1008        for ( ; taskNdx >= 0; --taskNdx) {
1009            AppTokenList tokens = tasks.get(taskNdx).mAppTokens;
1010            for ( ; tokenNdx >= 0; --tokenNdx) {
1011                final AppWindowToken t = tokens.get(tokenNdx);
1012                tokenWindowList = getTokenWindowsOnDisplay(t, displayContent);
1013                final int NW = tokenWindowList.size();
1014                if (NW > 0) {
1015                    pos = tokenWindowList.get(NW-1);
1016                    break;
1017                }
1018            }
1019            if (tokenNdx >= 0) {
1020                // found
1021                break;
1022            }
1023        }
1024
1025        if (pos != null) {
1026            // Move in front of any windows attached to this
1027            // one.
1028            WindowToken atoken = mTokenMap.get(pos.mClient.asBinder());
1029            if (atoken != null) {
1030                final int NC = atoken.windows.size();
1031                if (NC > 0) {
1032                    WindowState top = atoken.windows.get(NC-1);
1033                    if (top.mSubLayer >= 0) {
1034                        pos = top;
1035                    }
1036                }
1037            }
1038            placeWindowAfter(pos, win);
1039            return tokenWindowsPos;
1040        }
1041
1042        // Just search for the start of this layer.
1043        final int myLayer = win.mBaseLayer;
1044        int i;
1045        for (i = 0; i < N; i++) {
1046            WindowState w = windows.get(i);
1047            if (w.mBaseLayer > myLayer) {
1048                break;
1049            }
1050        }
1051        if (DEBUG_FOCUS_LIGHT || DEBUG_WINDOW_MOVEMENT || DEBUG_ADD_REMOVE) Slog.v(TAG,
1052                "Based on layer: Adding window " + win + " at " + i + " of " + N);
1053        windows.add(i, win);
1054        mWindowsChanged = true;
1055        return tokenWindowsPos;
1056    }
1057
1058    private void addFreeWindowToListLocked(final WindowState win) {
1059        final WindowList windows = win.getWindowList();
1060
1061        // Figure out where window should go, based on layer.
1062        final int myLayer = win.mBaseLayer;
1063        int i;
1064        for (i = windows.size() - 1; i >= 0; i--) {
1065            if (windows.get(i).mBaseLayer <= myLayer) {
1066                break;
1067            }
1068        }
1069        i++;
1070        if (DEBUG_FOCUS_LIGHT || DEBUG_WINDOW_MOVEMENT || DEBUG_ADD_REMOVE) Slog.v(TAG,
1071                "Free window: Adding window " + win + " at " + i + " of " + windows.size());
1072        windows.add(i, win);
1073        mWindowsChanged = true;
1074    }
1075
1076    private void addAttachedWindowToListLocked(final WindowState win, boolean addToToken) {
1077        final WindowToken token = win.mToken;
1078        final DisplayContent displayContent = win.mDisplayContent;
1079        final WindowState attached = win.mAttachedWindow;
1080
1081        WindowList tokenWindowList = getTokenWindowsOnDisplay(token, displayContent);
1082
1083        // Figure out this window's ordering relative to the window
1084        // it is attached to.
1085        final int NA = tokenWindowList.size();
1086        final int sublayer = win.mSubLayer;
1087        int largestSublayer = Integer.MIN_VALUE;
1088        WindowState windowWithLargestSublayer = null;
1089        int i;
1090        for (i = 0; i < NA; i++) {
1091            WindowState w = tokenWindowList.get(i);
1092            final int wSublayer = w.mSubLayer;
1093            if (wSublayer >= largestSublayer) {
1094                largestSublayer = wSublayer;
1095                windowWithLargestSublayer = w;
1096            }
1097            if (sublayer < 0) {
1098                // For negative sublayers, we go below all windows
1099                // in the same sublayer.
1100                if (wSublayer >= sublayer) {
1101                    if (addToToken) {
1102                        if (DEBUG_ADD_REMOVE) Slog.v(TAG, "Adding " + win + " to " + token);
1103                        token.windows.add(i, win);
1104                    }
1105                    placeWindowBefore(wSublayer >= 0 ? attached : w, win);
1106                    break;
1107                }
1108            } else {
1109                // For positive sublayers, we go above all windows
1110                // in the same sublayer.
1111                if (wSublayer > sublayer) {
1112                    if (addToToken) {
1113                        if (DEBUG_ADD_REMOVE) Slog.v(TAG, "Adding " + win + " to " + token);
1114                        token.windows.add(i, win);
1115                    }
1116                    placeWindowBefore(w, win);
1117                    break;
1118                }
1119            }
1120        }
1121        if (i >= NA) {
1122            if (addToToken) {
1123                if (DEBUG_ADD_REMOVE) Slog.v(TAG, "Adding " + win + " to " + token);
1124                token.windows.add(win);
1125            }
1126            if (sublayer < 0) {
1127                placeWindowBefore(attached, win);
1128            } else {
1129                placeWindowAfter(largestSublayer >= 0
1130                                 ? windowWithLargestSublayer
1131                                 : attached,
1132                                 win);
1133            }
1134        }
1135    }
1136
1137    private void addWindowToListInOrderLocked(final WindowState win, boolean addToToken) {
1138        if (DEBUG_FOCUS_LIGHT) Slog.d(TAG, "addWindowToListInOrderLocked: win=" + win +
1139                " Callers=" + Debug.getCallers(4));
1140        if (win.mAttachedWindow == null) {
1141            final WindowToken token = win.mToken;
1142            int tokenWindowsPos = 0;
1143            if (token.appWindowToken != null) {
1144                tokenWindowsPos = addAppWindowToListLocked(win);
1145            } else {
1146                addFreeWindowToListLocked(win);
1147            }
1148            if (addToToken) {
1149                if (DEBUG_ADD_REMOVE) Slog.v(TAG, "Adding " + win + " to " + token);
1150                token.windows.add(tokenWindowsPos, win);
1151            }
1152        } else {
1153            addAttachedWindowToListLocked(win, addToToken);
1154        }
1155
1156        if (win.mAppToken != null && addToToken) {
1157            win.mAppToken.allAppWindows.add(win);
1158        }
1159    }
1160
1161    static boolean canBeImeTarget(WindowState w) {
1162        final int fl = w.mAttrs.flags
1163                & (FLAG_NOT_FOCUSABLE|FLAG_ALT_FOCUSABLE_IM);
1164        if (fl == 0 || fl == (FLAG_NOT_FOCUSABLE|FLAG_ALT_FOCUSABLE_IM)
1165                || w.mAttrs.type == TYPE_APPLICATION_STARTING) {
1166            if (DEBUG_INPUT_METHOD) {
1167                Slog.i(TAG, "isVisibleOrAdding " + w + ": " + w.isVisibleOrAdding());
1168                if (!w.isVisibleOrAdding()) {
1169                    Slog.i(TAG, "  mSurface=" + w.mWinAnimator.mSurfaceControl
1170                            + " relayoutCalled=" + w.mRelayoutCalled + " viewVis=" + w.mViewVisibility
1171                            + " policyVis=" + w.mPolicyVisibility
1172                            + " policyVisAfterAnim=" + w.mPolicyVisibilityAfterAnim
1173                            + " attachHid=" + w.mAttachedHidden
1174                            + " exiting=" + w.mExiting + " destroying=" + w.mDestroying);
1175                    if (w.mAppToken != null) {
1176                        Slog.i(TAG, "  mAppToken.hiddenRequested=" + w.mAppToken.hiddenRequested);
1177                    }
1178                }
1179            }
1180            return w.isVisibleOrAdding();
1181        }
1182        return false;
1183    }
1184
1185    /**
1186     * Dig through the WindowStates and find the one that the Input Method will target.
1187     * @param willMove
1188     * @return The index+1 in mWindows of the discovered target.
1189     */
1190    int findDesiredInputMethodWindowIndexLocked(boolean willMove) {
1191        // TODO(multidisplay): Needs some serious rethought when the target and IME are not on the
1192        // same display. Or even when the current IME/target are not on the same screen as the next
1193        // IME/target. For now only look for input windows on the main screen.
1194        WindowList windows = getDefaultWindowListLocked();
1195        WindowState w = null;
1196        int i;
1197        for (i = windows.size() - 1; i >= 0; --i) {
1198            WindowState win = windows.get(i);
1199
1200            if (DEBUG_INPUT_METHOD && willMove) Slog.i(TAG, "Checking window @" + i
1201                    + " " + win + " fl=0x" + Integer.toHexString(win.mAttrs.flags));
1202            if (canBeImeTarget(win)) {
1203                w = win;
1204                //Slog.i(TAG, "Putting input method here!");
1205
1206                // Yet more tricksyness!  If this window is a "starting"
1207                // window, we do actually want to be on top of it, but
1208                // it is not -really- where input will go.  So if the caller
1209                // is not actually looking to move the IME, look down below
1210                // for a real window to target...
1211                if (!willMove
1212                        && w.mAttrs.type == TYPE_APPLICATION_STARTING
1213                        && i > 0) {
1214                    WindowState wb = windows.get(i-1);
1215                    if (wb.mAppToken == w.mAppToken && canBeImeTarget(wb)) {
1216                        i--;
1217                        w = wb;
1218                    }
1219                }
1220                break;
1221            }
1222        }
1223
1224        // Now w is either mWindows[0] or an IME (or null if mWindows is empty).
1225
1226        if (DEBUG_INPUT_METHOD && willMove) Slog.v(TAG, "Proposed new IME target: " + w);
1227
1228        // Now, a special case -- if the last target's window is in the
1229        // process of exiting, and is above the new target, keep on the
1230        // last target to avoid flicker.  Consider for example a Dialog with
1231        // the IME shown: when the Dialog is dismissed, we want to keep
1232        // the IME above it until it is completely gone so it doesn't drop
1233        // behind the dialog or its full-screen scrim.
1234        final WindowState curTarget = mInputMethodTarget;
1235        if (curTarget != null
1236                && curTarget.isDisplayedLw()
1237                && curTarget.isClosing()
1238                && (w == null || curTarget.mWinAnimator.mAnimLayer > w.mWinAnimator.mAnimLayer)) {
1239            if (DEBUG_INPUT_METHOD) Slog.v(TAG, "Current target higher, not changing");
1240            return windows.indexOf(curTarget) + 1;
1241        }
1242
1243        if (DEBUG_INPUT_METHOD) Slog.v(TAG, "Desired input method target="
1244                + w + " willMove=" + willMove);
1245
1246        if (willMove && w != null) {
1247            AppWindowToken token = curTarget == null ? null : curTarget.mAppToken;
1248            if (token != null) {
1249
1250                // Now some fun for dealing with window animations that
1251                // modify the Z order.  We need to look at all windows below
1252                // the current target that are in this app, finding the highest
1253                // visible one in layering.
1254                WindowState highestTarget = null;
1255                int highestPos = 0;
1256                if (token.mAppAnimator.animating || token.mAppAnimator.animation != null) {
1257                    WindowList curWindows = curTarget.getWindowList();
1258                    int pos = curWindows.indexOf(curTarget);
1259                    while (pos >= 0) {
1260                        WindowState win = curWindows.get(pos);
1261                        if (win.mAppToken != token) {
1262                            break;
1263                        }
1264                        if (!win.mRemoved) {
1265                            if (highestTarget == null || win.mWinAnimator.mAnimLayer >
1266                                    highestTarget.mWinAnimator.mAnimLayer) {
1267                                highestTarget = win;
1268                                highestPos = pos;
1269                            }
1270                        }
1271                        pos--;
1272                    }
1273                }
1274
1275                if (highestTarget != null) {
1276                    if (DEBUG_INPUT_METHOD) Slog.v(TAG, mAppTransition + " " + highestTarget
1277                            + " animating=" + highestTarget.mWinAnimator.isAnimating()
1278                            + " layer=" + highestTarget.mWinAnimator.mAnimLayer
1279                            + " new layer=" + w.mWinAnimator.mAnimLayer);
1280
1281                    if (mAppTransition.isTransitionSet()) {
1282                        // If we are currently setting up for an animation,
1283                        // hold everything until we can find out what will happen.
1284                        mInputMethodTargetWaitingAnim = true;
1285                        mInputMethodTarget = highestTarget;
1286                        return highestPos + 1;
1287                    } else if (highestTarget.mWinAnimator.isAnimating() &&
1288                            highestTarget.mWinAnimator.mAnimLayer > w.mWinAnimator.mAnimLayer) {
1289                        // If the window we are currently targeting is involved
1290                        // with an animation, and it is on top of the next target
1291                        // we will be over, then hold off on moving until
1292                        // that is done.
1293                        mInputMethodTargetWaitingAnim = true;
1294                        mInputMethodTarget = highestTarget;
1295                        return highestPos + 1;
1296                    }
1297                }
1298            }
1299        }
1300
1301        //Slog.i(TAG, "Placing input method @" + (i+1));
1302        if (w != null) {
1303            if (willMove) {
1304                if (DEBUG_INPUT_METHOD) Slog.w(TAG, "Moving IM target from " + curTarget + " to "
1305                        + w + (HIDE_STACK_CRAWLS ? "" : " Callers=" + Debug.getCallers(4)));
1306                mInputMethodTarget = w;
1307                mInputMethodTargetWaitingAnim = false;
1308                if (w.mAppToken != null) {
1309                    setInputMethodAnimLayerAdjustment(w.mAppToken.mAppAnimator.animLayerAdjustment);
1310                } else {
1311                    setInputMethodAnimLayerAdjustment(0);
1312                }
1313            }
1314            return i+1;
1315        }
1316        if (willMove) {
1317            if (DEBUG_INPUT_METHOD) Slog.w(TAG, "Moving IM target from " + curTarget + " to null."
1318                    + (HIDE_STACK_CRAWLS ? "" : " Callers=" + Debug.getCallers(4)));
1319            mInputMethodTarget = null;
1320            setInputMethodAnimLayerAdjustment(0);
1321        }
1322        return -1;
1323    }
1324
1325    void addInputMethodWindowToListLocked(WindowState win) {
1326        int pos = findDesiredInputMethodWindowIndexLocked(true);
1327        if (pos >= 0) {
1328            win.mTargetAppToken = mInputMethodTarget.mAppToken;
1329            if (DEBUG_WINDOW_MOVEMENT || DEBUG_ADD_REMOVE) Slog.v(
1330                    TAG, "Adding input method window " + win + " at " + pos);
1331            // TODO(multidisplay): IMEs are only supported on the default display.
1332            getDefaultWindowListLocked().add(pos, win);
1333            mWindowsChanged = true;
1334            moveInputMethodDialogsLocked(pos+1);
1335            return;
1336        }
1337        win.mTargetAppToken = null;
1338        addWindowToListInOrderLocked(win, true);
1339        moveInputMethodDialogsLocked(pos);
1340    }
1341
1342    void setInputMethodAnimLayerAdjustment(int adj) {
1343        if (DEBUG_LAYERS) Slog.v(TAG, "Setting im layer adj to " + adj);
1344        mInputMethodAnimLayerAdjustment = adj;
1345        WindowState imw = mInputMethodWindow;
1346        if (imw != null) {
1347            imw.mWinAnimator.mAnimLayer = imw.mLayer + adj;
1348            if (DEBUG_LAYERS) Slog.v(TAG, "IM win " + imw
1349                    + " anim layer: " + imw.mWinAnimator.mAnimLayer);
1350            int wi = imw.mChildWindows.size();
1351            while (wi > 0) {
1352                wi--;
1353                WindowState cw = imw.mChildWindows.get(wi);
1354                cw.mWinAnimator.mAnimLayer = cw.mLayer + adj;
1355                if (DEBUG_LAYERS) Slog.v(TAG, "IM win " + cw
1356                        + " anim layer: " + cw.mWinAnimator.mAnimLayer);
1357            }
1358        }
1359        int di = mInputMethodDialogs.size();
1360        while (di > 0) {
1361            di --;
1362            imw = mInputMethodDialogs.get(di);
1363            imw.mWinAnimator.mAnimLayer = imw.mLayer + adj;
1364            if (DEBUG_LAYERS) Slog.v(TAG, "IM win " + imw
1365                    + " anim layer: " + imw.mWinAnimator.mAnimLayer);
1366        }
1367    }
1368
1369    private int tmpRemoveWindowLocked(int interestingPos, WindowState win) {
1370        WindowList windows = win.getWindowList();
1371        int wpos = windows.indexOf(win);
1372        if (wpos >= 0) {
1373            if (wpos < interestingPos) interestingPos--;
1374            if (DEBUG_WINDOW_MOVEMENT) Slog.v(TAG, "Temp removing at " + wpos + ": " + win);
1375            windows.remove(wpos);
1376            mWindowsChanged = true;
1377            int NC = win.mChildWindows.size();
1378            while (NC > 0) {
1379                NC--;
1380                WindowState cw = win.mChildWindows.get(NC);
1381                int cpos = windows.indexOf(cw);
1382                if (cpos >= 0) {
1383                    if (cpos < interestingPos) interestingPos--;
1384                    if (DEBUG_WINDOW_MOVEMENT) Slog.v(TAG, "Temp removing child at "
1385                            + cpos + ": " + cw);
1386                    windows.remove(cpos);
1387                }
1388            }
1389        }
1390        return interestingPos;
1391    }
1392
1393    private void reAddWindowToListInOrderLocked(WindowState win) {
1394        addWindowToListInOrderLocked(win, false);
1395        // This is a hack to get all of the child windows added as well
1396        // at the right position.  Child windows should be rare and
1397        // this case should be rare, so it shouldn't be that big a deal.
1398        WindowList windows = win.getWindowList();
1399        int wpos = windows.indexOf(win);
1400        if (wpos >= 0) {
1401            if (DEBUG_WINDOW_MOVEMENT) Slog.v(TAG, "ReAdd removing from " + wpos + ": " + win);
1402            windows.remove(wpos);
1403            mWindowsChanged = true;
1404            reAddWindowLocked(wpos, win);
1405        }
1406    }
1407
1408    void logWindowList(final WindowList windows, String prefix) {
1409        int N = windows.size();
1410        while (N > 0) {
1411            N--;
1412            Slog.v(TAG, prefix + "#" + N + ": " + windows.get(N));
1413        }
1414    }
1415
1416    void moveInputMethodDialogsLocked(int pos) {
1417        ArrayList<WindowState> dialogs = mInputMethodDialogs;
1418
1419        // TODO(multidisplay): IMEs are only supported on the default display.
1420        WindowList windows = getDefaultWindowListLocked();
1421        final int N = dialogs.size();
1422        if (DEBUG_INPUT_METHOD) Slog.v(TAG, "Removing " + N + " dialogs w/pos=" + pos);
1423        for (int i=0; i<N; i++) {
1424            pos = tmpRemoveWindowLocked(pos, dialogs.get(i));
1425        }
1426        if (DEBUG_INPUT_METHOD) {
1427            Slog.v(TAG, "Window list w/pos=" + pos);
1428            logWindowList(windows, "  ");
1429        }
1430
1431        if (pos >= 0) {
1432            final AppWindowToken targetAppToken = mInputMethodTarget.mAppToken;
1433            if (pos < windows.size()) {
1434                WindowState wp = windows.get(pos);
1435                if (wp == mInputMethodWindow) {
1436                    pos++;
1437                }
1438            }
1439            if (DEBUG_INPUT_METHOD) Slog.v(TAG, "Adding " + N + " dialogs at pos=" + pos);
1440            for (int i=0; i<N; i++) {
1441                WindowState win = dialogs.get(i);
1442                win.mTargetAppToken = targetAppToken;
1443                pos = reAddWindowLocked(pos, win);
1444            }
1445            if (DEBUG_INPUT_METHOD) {
1446                Slog.v(TAG, "Final window list:");
1447                logWindowList(windows, "  ");
1448            }
1449            return;
1450        }
1451        for (int i=0; i<N; i++) {
1452            WindowState win = dialogs.get(i);
1453            win.mTargetAppToken = null;
1454            reAddWindowToListInOrderLocked(win);
1455            if (DEBUG_INPUT_METHOD) {
1456                Slog.v(TAG, "No IM target, final list:");
1457                logWindowList(windows, "  ");
1458            }
1459        }
1460    }
1461
1462    boolean moveInputMethodWindowsIfNeededLocked(boolean needAssignLayers) {
1463        final WindowState imWin = mInputMethodWindow;
1464        final int DN = mInputMethodDialogs.size();
1465        if (imWin == null && DN == 0) {
1466            return false;
1467        }
1468
1469        // TODO(multidisplay): IMEs are only supported on the default display.
1470        WindowList windows = getDefaultWindowListLocked();
1471
1472        int imPos = findDesiredInputMethodWindowIndexLocked(true);
1473        if (imPos >= 0) {
1474            // In this case, the input method windows are to be placed
1475            // immediately above the window they are targeting.
1476
1477            // First check to see if the input method windows are already
1478            // located here, and contiguous.
1479            final int N = windows.size();
1480            WindowState firstImWin = imPos < N
1481                    ? windows.get(imPos) : null;
1482
1483            // Figure out the actual input method window that should be
1484            // at the bottom of their stack.
1485            WindowState baseImWin = imWin != null
1486                    ? imWin : mInputMethodDialogs.get(0);
1487            if (baseImWin.mChildWindows.size() > 0) {
1488                WindowState cw = baseImWin.mChildWindows.get(0);
1489                if (cw.mSubLayer < 0) baseImWin = cw;
1490            }
1491
1492            if (firstImWin == baseImWin) {
1493                // The windows haven't moved...  but are they still contiguous?
1494                // First find the top IM window.
1495                int pos = imPos+1;
1496                while (pos < N) {
1497                    if (!(windows.get(pos)).mIsImWindow) {
1498                        break;
1499                    }
1500                    pos++;
1501                }
1502                pos++;
1503                // Now there should be no more input method windows above.
1504                while (pos < N) {
1505                    if ((windows.get(pos)).mIsImWindow) {
1506                        break;
1507                    }
1508                    pos++;
1509                }
1510                if (pos >= N) {
1511                    // Z order is good.
1512                    // The IM target window may be changed, so update the mTargetAppToken.
1513                    if (imWin != null) {
1514                        imWin.mTargetAppToken = mInputMethodTarget.mAppToken;
1515                    }
1516                    return false;
1517                }
1518            }
1519
1520            if (imWin != null) {
1521                if (DEBUG_INPUT_METHOD) {
1522                    Slog.v(TAG, "Moving IM from " + imPos);
1523                    logWindowList(windows, "  ");
1524                }
1525                imPos = tmpRemoveWindowLocked(imPos, imWin);
1526                if (DEBUG_INPUT_METHOD) {
1527                    Slog.v(TAG, "List after removing with new pos " + imPos + ":");
1528                    logWindowList(windows, "  ");
1529                }
1530                imWin.mTargetAppToken = mInputMethodTarget.mAppToken;
1531                reAddWindowLocked(imPos, imWin);
1532                if (DEBUG_INPUT_METHOD) {
1533                    Slog.v(TAG, "List after moving IM to " + imPos + ":");
1534                    logWindowList(windows, "  ");
1535                }
1536                if (DN > 0) moveInputMethodDialogsLocked(imPos+1);
1537            } else {
1538                moveInputMethodDialogsLocked(imPos);
1539            }
1540
1541        } else {
1542            // In this case, the input method windows go in a fixed layer,
1543            // because they aren't currently associated with a focus window.
1544
1545            if (imWin != null) {
1546                if (DEBUG_INPUT_METHOD) Slog.v(TAG, "Moving IM from " + imPos);
1547                tmpRemoveWindowLocked(0, imWin);
1548                imWin.mTargetAppToken = null;
1549                reAddWindowToListInOrderLocked(imWin);
1550                if (DEBUG_INPUT_METHOD) {
1551                    Slog.v(TAG, "List with no IM target:");
1552                    logWindowList(windows, "  ");
1553                }
1554                if (DN > 0) moveInputMethodDialogsLocked(-1);
1555            } else {
1556                moveInputMethodDialogsLocked(-1);
1557            }
1558
1559        }
1560
1561        if (needAssignLayers) {
1562            assignLayersLocked(windows);
1563        }
1564
1565        return true;
1566    }
1567
1568    final boolean isWallpaperVisible(WindowState wallpaperTarget) {
1569        if (DEBUG_WALLPAPER) Slog.v(TAG, "Wallpaper vis: target " + wallpaperTarget + ", obscured="
1570                + (wallpaperTarget != null ? Boolean.toString(wallpaperTarget.mObscured) : "??")
1571                + " anim=" + ((wallpaperTarget != null && wallpaperTarget.mAppToken != null)
1572                        ? wallpaperTarget.mAppToken.mAppAnimator.animation : null)
1573                + " upper=" + mUpperWallpaperTarget
1574                + " lower=" + mLowerWallpaperTarget);
1575        return (wallpaperTarget != null
1576                        && (!wallpaperTarget.mObscured || (wallpaperTarget.mAppToken != null
1577                                && wallpaperTarget.mAppToken.mAppAnimator.animation != null)))
1578                || mUpperWallpaperTarget != null
1579                || mLowerWallpaperTarget != null;
1580    }
1581
1582    static final int ADJUST_WALLPAPER_LAYERS_CHANGED = 1<<1;
1583    static final int ADJUST_WALLPAPER_VISIBILITY_CHANGED = 1<<2;
1584
1585    int adjustWallpaperWindowsLocked() {
1586        mInnerFields.mWallpaperMayChange = false;
1587        boolean targetChanged = false;
1588
1589        // TODO(multidisplay): Wallpapers on main screen only.
1590        final DisplayInfo displayInfo = getDefaultDisplayContentLocked().getDisplayInfo();
1591        final int dw = displayInfo.logicalWidth;
1592        final int dh = displayInfo.logicalHeight;
1593
1594        // First find top-most window that has asked to be on top of the
1595        // wallpaper; all wallpapers go behind it.
1596        final WindowList windows = getDefaultWindowListLocked();
1597        int N = windows.size();
1598        WindowState w = null;
1599        WindowState foundW = null;
1600        int foundI = 0;
1601        WindowState topCurW = null;
1602        int topCurI = 0;
1603        int windowDetachedI = -1;
1604        int i = N;
1605        while (i > 0) {
1606            i--;
1607            w = windows.get(i);
1608            if ((w.mAttrs.type == TYPE_WALLPAPER)) {
1609                if (topCurW == null) {
1610                    topCurW = w;
1611                    topCurI = i;
1612                }
1613                continue;
1614            }
1615            topCurW = null;
1616            if (w != mAnimator.mWindowDetachedWallpaper && w.mAppToken != null) {
1617                // If this window's app token is hidden and not animating,
1618                // it is of no interest to us.
1619                if (w.mAppToken.hidden && w.mAppToken.mAppAnimator.animation == null) {
1620                    if (DEBUG_WALLPAPER) Slog.v(TAG,
1621                            "Skipping hidden and not animating token: " + w);
1622                    continue;
1623                }
1624            }
1625            if (DEBUG_WALLPAPER) Slog.v(TAG, "Win #" + i + " " + w + ": isOnScreen="
1626                    + w.isOnScreen() + " mDrawState=" + w.mWinAnimator.mDrawState);
1627            if ((w.mAttrs.flags&FLAG_SHOW_WALLPAPER) != 0 && w.isOnScreen()
1628                    && (mWallpaperTarget == w || w.isDrawFinishedLw())) {
1629                if (DEBUG_WALLPAPER) Slog.v(TAG,
1630                        "Found wallpaper target: #" + i + "=" + w);
1631                foundW = w;
1632                foundI = i;
1633                if (w == mWallpaperTarget && w.mWinAnimator.isAnimating()) {
1634                    // The current wallpaper target is animating, so we'll
1635                    // look behind it for another possible target and figure
1636                    // out what is going on below.
1637                    if (DEBUG_WALLPAPER) Slog.v(TAG, "Win " + w
1638                            + ": token animating, looking behind.");
1639                    continue;
1640                }
1641                break;
1642            } else if (w == mAnimator.mWindowDetachedWallpaper) {
1643                windowDetachedI = i;
1644            }
1645        }
1646
1647        if (foundW == null && windowDetachedI >= 0) {
1648            if (DEBUG_WALLPAPER_LIGHT) Slog.v(TAG,
1649                    "Found animating detached wallpaper activity: #" + i + "=" + w);
1650            foundW = w;
1651            foundI = windowDetachedI;
1652        }
1653
1654        if (mWallpaperTarget != foundW
1655                && (mLowerWallpaperTarget == null || mLowerWallpaperTarget != foundW)) {
1656            if (DEBUG_WALLPAPER_LIGHT) {
1657                Slog.v(TAG, "New wallpaper target: " + foundW
1658                        + " oldTarget: " + mWallpaperTarget);
1659            }
1660
1661            mLowerWallpaperTarget = null;
1662            mUpperWallpaperTarget = null;
1663
1664            WindowState oldW = mWallpaperTarget;
1665            mWallpaperTarget = foundW;
1666            targetChanged = true;
1667
1668            // Now what is happening...  if the current and new targets are
1669            // animating, then we are in our super special mode!
1670            if (foundW != null && oldW != null) {
1671                boolean oldAnim = oldW.isAnimatingLw();
1672                boolean foundAnim = foundW.isAnimatingLw();
1673                if (DEBUG_WALLPAPER_LIGHT) {
1674                    Slog.v(TAG, "New animation: " + foundAnim
1675                            + " old animation: " + oldAnim);
1676                }
1677                if (foundAnim && oldAnim) {
1678                    int oldI = windows.indexOf(oldW);
1679                    if (DEBUG_WALLPAPER_LIGHT) {
1680                        Slog.v(TAG, "New i: " + foundI + " old i: " + oldI);
1681                    }
1682                    if (oldI >= 0) {
1683                        if (DEBUG_WALLPAPER_LIGHT) {
1684                            Slog.v(TAG, "Animating wallpapers: old#" + oldI
1685                                    + "=" + oldW + "; new#" + foundI
1686                                    + "=" + foundW);
1687                        }
1688
1689                        // Set the new target correctly.
1690                        if (foundW.mAppToken != null && foundW.mAppToken.hiddenRequested) {
1691                            if (DEBUG_WALLPAPER_LIGHT) {
1692                                Slog.v(TAG, "Old wallpaper still the target.");
1693                            }
1694                            mWallpaperTarget = oldW;
1695                            foundW = oldW;
1696                            foundI = oldI;
1697                        }
1698                        // Now set the upper and lower wallpaper targets
1699                        // correctly, and make sure that we are positioning
1700                        // the wallpaper below the lower.
1701                        else if (foundI > oldI) {
1702                            // The new target is on top of the old one.
1703                            if (DEBUG_WALLPAPER_LIGHT) {
1704                                Slog.v(TAG, "Found target above old target.");
1705                            }
1706                            mUpperWallpaperTarget = foundW;
1707                            mLowerWallpaperTarget = oldW;
1708                            foundW = oldW;
1709                            foundI = oldI;
1710                        } else {
1711                            // The new target is below the old one.
1712                            if (DEBUG_WALLPAPER_LIGHT) {
1713                                Slog.v(TAG, "Found target below old target.");
1714                            }
1715                            mUpperWallpaperTarget = oldW;
1716                            mLowerWallpaperTarget = foundW;
1717                        }
1718                    }
1719                }
1720            }
1721
1722        } else if (mLowerWallpaperTarget != null) {
1723            // Is it time to stop animating?
1724            if (!mLowerWallpaperTarget.isAnimatingLw() || !mUpperWallpaperTarget.isAnimatingLw()) {
1725                if (DEBUG_WALLPAPER_LIGHT) {
1726                    Slog.v(TAG, "No longer animating wallpaper targets!");
1727                }
1728                mLowerWallpaperTarget = null;
1729                mUpperWallpaperTarget = null;
1730                mWallpaperTarget = foundW;
1731                targetChanged = true;
1732            }
1733        }
1734
1735        boolean visible = foundW != null;
1736        if (visible) {
1737            // The window is visible to the compositor...  but is it visible
1738            // to the user?  That is what the wallpaper cares about.
1739            visible = isWallpaperVisible(foundW);
1740            if (DEBUG_WALLPAPER) Slog.v(TAG, "Wallpaper visibility: " + visible);
1741
1742            // If the wallpaper target is animating, we may need to copy
1743            // its layer adjustment.  Only do this if we are not transfering
1744            // between two wallpaper targets.
1745            mWallpaperAnimLayerAdjustment =
1746                    (mLowerWallpaperTarget == null && foundW.mAppToken != null)
1747                    ? foundW.mAppToken.mAppAnimator.animLayerAdjustment : 0;
1748
1749            final int maxLayer = mPolicy.getMaxWallpaperLayer()
1750                    * TYPE_LAYER_MULTIPLIER
1751                    + TYPE_LAYER_OFFSET;
1752
1753            // Now w is the window we are supposed to be behind...  but we
1754            // need to be sure to also be behind any of its attached windows,
1755            // AND any starting window associated with it, AND below the
1756            // maximum layer the policy allows for wallpapers.
1757            while (foundI > 0) {
1758                WindowState wb = windows.get(foundI-1);
1759                if (wb.mBaseLayer < maxLayer &&
1760                        wb.mAttachedWindow != foundW &&
1761                        (foundW.mAttachedWindow == null ||
1762                                wb.mAttachedWindow != foundW.mAttachedWindow) &&
1763                        (wb.mAttrs.type != TYPE_APPLICATION_STARTING ||
1764                                foundW.mToken == null || wb.mToken != foundW.mToken)) {
1765                    // This window is not related to the previous one in any
1766                    // interesting way, so stop here.
1767                    break;
1768                }
1769                foundW = wb;
1770                foundI--;
1771            }
1772        } else {
1773            if (DEBUG_WALLPAPER) Slog.v(TAG, "No wallpaper target");
1774        }
1775
1776        if (foundW == null && topCurW != null) {
1777            // There is no wallpaper target, so it goes at the bottom.
1778            // We will assume it is the same place as last time, if known.
1779            foundW = topCurW;
1780            foundI = topCurI+1;
1781        } else {
1782            // Okay i is the position immediately above the wallpaper.  Look at
1783            // what is below it for later.
1784            foundW = foundI > 0 ? windows.get(foundI-1) : null;
1785        }
1786
1787        if (visible) {
1788            if (mWallpaperTarget.mWallpaperX >= 0) {
1789                mLastWallpaperX = mWallpaperTarget.mWallpaperX;
1790                mLastWallpaperXStep = mWallpaperTarget.mWallpaperXStep;
1791            }
1792            if (mWallpaperTarget.mWallpaperY >= 0) {
1793                mLastWallpaperY = mWallpaperTarget.mWallpaperY;
1794                mLastWallpaperYStep = mWallpaperTarget.mWallpaperYStep;
1795            }
1796        }
1797
1798        // Start stepping backwards from here, ensuring that our wallpaper windows
1799        // are correctly placed.
1800        int changed = 0;
1801        int curTokenIndex = mWallpaperTokens.size();
1802        while (curTokenIndex > 0) {
1803            curTokenIndex--;
1804            WindowToken token = mWallpaperTokens.get(curTokenIndex);
1805            if (token.hidden == visible) {
1806                if (DEBUG_WALLPAPER_LIGHT) Slog.d(TAG,
1807                        "Wallpaper token " + token + " hidden=" + !visible);
1808                changed |= ADJUST_WALLPAPER_VISIBILITY_CHANGED;
1809                token.hidden = !visible;
1810                // Need to do a layout to ensure the wallpaper now has the
1811                // correct size.
1812                getDefaultDisplayContentLocked().layoutNeeded = true;
1813            }
1814
1815            int curWallpaperIndex = token.windows.size();
1816            while (curWallpaperIndex > 0) {
1817                curWallpaperIndex--;
1818                WindowState wallpaper = token.windows.get(curWallpaperIndex);
1819
1820                if (visible) {
1821                    updateWallpaperOffsetLocked(wallpaper, dw, dh, false);
1822                }
1823
1824                // First, make sure the client has the current visibility
1825                // state.
1826                dispatchWallpaperVisibility(wallpaper, visible);
1827
1828                wallpaper.mWinAnimator.mAnimLayer = wallpaper.mLayer + mWallpaperAnimLayerAdjustment;
1829                if (DEBUG_LAYERS || DEBUG_WALLPAPER_LIGHT) Slog.v(TAG, "adjustWallpaper win "
1830                        + wallpaper + " anim layer: " + wallpaper.mWinAnimator.mAnimLayer);
1831
1832                // First, if this window is at the current index, then all
1833                // is well.
1834                if (wallpaper == foundW) {
1835                    foundI--;
1836                    foundW = foundI > 0
1837                            ? windows.get(foundI-1) : null;
1838                    continue;
1839                }
1840
1841                // The window didn't match...  the current wallpaper window,
1842                // wherever it is, is in the wrong place, so make sure it is
1843                // not in the list.
1844                int oldIndex = windows.indexOf(wallpaper);
1845                if (oldIndex >= 0) {
1846                    if (DEBUG_WINDOW_MOVEMENT) Slog.v(TAG, "Wallpaper removing at "
1847                            + oldIndex + ": " + wallpaper);
1848                    windows.remove(oldIndex);
1849                    mWindowsChanged = true;
1850                    if (oldIndex < foundI) {
1851                        foundI--;
1852                    }
1853                }
1854
1855                // Now stick it in. For apps over wallpaper keep the wallpaper at the bottommost
1856                // layer. For keyguard over wallpaper put the wallpaper under the keyguard.
1857                int insertionIndex = 0;
1858                if (visible && foundW != null) {
1859                    final int type = foundW.mAttrs.type;
1860                    if (type == TYPE_KEYGUARD || type == TYPE_KEYGUARD_SCRIM) {
1861                        insertionIndex = windows.indexOf(foundW);
1862                    }
1863                }
1864                if (DEBUG_WALLPAPER_LIGHT || DEBUG_WINDOW_MOVEMENT || DEBUG_ADD_REMOVE) {
1865                    Slog.v(TAG, "Moving wallpaper " + wallpaper
1866                            + " from " + oldIndex + " to " + insertionIndex);
1867                }
1868
1869                windows.add(insertionIndex, wallpaper);
1870                mWindowsChanged = true;
1871                changed |= ADJUST_WALLPAPER_LAYERS_CHANGED;
1872            }
1873        }
1874
1875        /*
1876        final TaskStack targetStack =
1877                mWallpaperTarget == null ? null : mWallpaperTarget.getStack();
1878        if ((changed & ADJUST_WALLPAPER_LAYERS_CHANGED) != 0 &&
1879                targetStack != null && !targetStack.isHomeStack()) {
1880            // If the wallpaper target is not on the home stack then make sure that all windows
1881            // from other non-home stacks are above the wallpaper.
1882            for (i = foundI - 1; i >= 0; --i) {
1883                WindowState win = windows.get(i);
1884                if (!win.isVisibleLw()) {
1885                    continue;
1886                }
1887                final TaskStack winStack = win.getStack();
1888                if (winStack != null && !winStack.isHomeStack() && winStack != targetStack) {
1889                    windows.remove(i);
1890                    windows.add(foundI + 1, win);
1891                }
1892            }
1893        }
1894        */
1895
1896        if (targetChanged && DEBUG_WALLPAPER_LIGHT) {
1897            Slog.d(TAG, "New wallpaper: target=" + mWallpaperTarget
1898                    + " lower=" + mLowerWallpaperTarget + " upper="
1899                    + mUpperWallpaperTarget);
1900        }
1901
1902        return changed;
1903    }
1904
1905    void setWallpaperAnimLayerAdjustmentLocked(int adj) {
1906        if (DEBUG_LAYERS || DEBUG_WALLPAPER) Slog.v(TAG,
1907                "Setting wallpaper layer adj to " + adj);
1908        mWallpaperAnimLayerAdjustment = adj;
1909        int curTokenIndex = mWallpaperTokens.size();
1910        while (curTokenIndex > 0) {
1911            curTokenIndex--;
1912            WindowToken token = mWallpaperTokens.get(curTokenIndex);
1913            int curWallpaperIndex = token.windows.size();
1914            while (curWallpaperIndex > 0) {
1915                curWallpaperIndex--;
1916                WindowState wallpaper = token.windows.get(curWallpaperIndex);
1917                wallpaper.mWinAnimator.mAnimLayer = wallpaper.mLayer + adj;
1918                if (DEBUG_LAYERS || DEBUG_WALLPAPER) Slog.v(TAG, "setWallpaper win "
1919                        + wallpaper + " anim layer: " + wallpaper.mWinAnimator.mAnimLayer);
1920            }
1921        }
1922    }
1923
1924    boolean updateWallpaperOffsetLocked(WindowState wallpaperWin, int dw, int dh,
1925            boolean sync) {
1926        boolean changed = false;
1927        boolean rawChanged = false;
1928        float wpx = mLastWallpaperX >= 0 ? mLastWallpaperX : 0.5f;
1929        float wpxs = mLastWallpaperXStep >= 0 ? mLastWallpaperXStep : -1.0f;
1930        int availw = wallpaperWin.mFrame.right-wallpaperWin.mFrame.left-dw;
1931        int offset = availw > 0 ? -(int)(availw*wpx+.5f) : 0;
1932        changed = wallpaperWin.mXOffset != offset;
1933        if (changed) {
1934            if (DEBUG_WALLPAPER) Slog.v(TAG, "Update wallpaper "
1935                    + wallpaperWin + " x: " + offset);
1936            wallpaperWin.mXOffset = offset;
1937        }
1938        if (wallpaperWin.mWallpaperX != wpx || wallpaperWin.mWallpaperXStep != wpxs) {
1939            wallpaperWin.mWallpaperX = wpx;
1940            wallpaperWin.mWallpaperXStep = wpxs;
1941            rawChanged = true;
1942        }
1943
1944        float wpy = mLastWallpaperY >= 0 ? mLastWallpaperY : 0.5f;
1945        float wpys = mLastWallpaperYStep >= 0 ? mLastWallpaperYStep : -1.0f;
1946        int availh = wallpaperWin.mFrame.bottom-wallpaperWin.mFrame.top-dh;
1947        offset = availh > 0 ? -(int)(availh*wpy+.5f) : 0;
1948        if (wallpaperWin.mYOffset != offset) {
1949            if (DEBUG_WALLPAPER) Slog.v(TAG, "Update wallpaper "
1950                    + wallpaperWin + " y: " + offset);
1951            changed = true;
1952            wallpaperWin.mYOffset = offset;
1953        }
1954        if (wallpaperWin.mWallpaperY != wpy || wallpaperWin.mWallpaperYStep != wpys) {
1955            wallpaperWin.mWallpaperY = wpy;
1956            wallpaperWin.mWallpaperYStep = wpys;
1957            rawChanged = true;
1958        }
1959
1960        if (rawChanged && (wallpaperWin.mAttrs.privateFlags &
1961                    WindowManager.LayoutParams.PRIVATE_FLAG_WANTS_OFFSET_NOTIFICATIONS) != 0) {
1962            try {
1963                if (DEBUG_WALLPAPER) Slog.v(TAG, "Report new wp offset "
1964                        + wallpaperWin + " x=" + wallpaperWin.mWallpaperX
1965                        + " y=" + wallpaperWin.mWallpaperY);
1966                if (sync) {
1967                    mWaitingOnWallpaper = wallpaperWin;
1968                }
1969                wallpaperWin.mClient.dispatchWallpaperOffsets(
1970                        wallpaperWin.mWallpaperX, wallpaperWin.mWallpaperY,
1971                        wallpaperWin.mWallpaperXStep, wallpaperWin.mWallpaperYStep, sync);
1972                if (sync) {
1973                    if (mWaitingOnWallpaper != null) {
1974                        long start = SystemClock.uptimeMillis();
1975                        if ((mLastWallpaperTimeoutTime+WALLPAPER_TIMEOUT_RECOVERY)
1976                                < start) {
1977                            try {
1978                                if (DEBUG_WALLPAPER) Slog.v(TAG,
1979                                        "Waiting for offset complete...");
1980                                mWindowMap.wait(WALLPAPER_TIMEOUT);
1981                            } catch (InterruptedException e) {
1982                            }
1983                            if (DEBUG_WALLPAPER) Slog.v(TAG, "Offset complete!");
1984                            if ((start+WALLPAPER_TIMEOUT)
1985                                    < SystemClock.uptimeMillis()) {
1986                                Slog.i(TAG, "Timeout waiting for wallpaper to offset: "
1987                                        + wallpaperWin);
1988                                mLastWallpaperTimeoutTime = start;
1989                            }
1990                        }
1991                        mWaitingOnWallpaper = null;
1992                    }
1993                }
1994            } catch (RemoteException e) {
1995            }
1996        }
1997
1998        return changed;
1999    }
2000
2001    void wallpaperOffsetsComplete(IBinder window) {
2002        synchronized (mWindowMap) {
2003            if (mWaitingOnWallpaper != null &&
2004                    mWaitingOnWallpaper.mClient.asBinder() == window) {
2005                mWaitingOnWallpaper = null;
2006                mWindowMap.notifyAll();
2007            }
2008        }
2009    }
2010
2011    void updateWallpaperOffsetLocked(WindowState changingTarget, boolean sync) {
2012        final DisplayContent displayContent = changingTarget.mDisplayContent;
2013        final DisplayInfo displayInfo = displayContent.getDisplayInfo();
2014        final int dw = displayInfo.logicalWidth;
2015        final int dh = displayInfo.logicalHeight;
2016
2017        WindowState target = mWallpaperTarget;
2018        if (target != null) {
2019            if (target.mWallpaperX >= 0) {
2020                mLastWallpaperX = target.mWallpaperX;
2021            } else if (changingTarget.mWallpaperX >= 0) {
2022                mLastWallpaperX = changingTarget.mWallpaperX;
2023            }
2024            if (target.mWallpaperY >= 0) {
2025                mLastWallpaperY = target.mWallpaperY;
2026            } else if (changingTarget.mWallpaperY >= 0) {
2027                mLastWallpaperY = changingTarget.mWallpaperY;
2028            }
2029        }
2030
2031        int curTokenIndex = mWallpaperTokens.size();
2032        while (curTokenIndex > 0) {
2033            curTokenIndex--;
2034            WindowToken token = mWallpaperTokens.get(curTokenIndex);
2035            int curWallpaperIndex = token.windows.size();
2036            while (curWallpaperIndex > 0) {
2037                curWallpaperIndex--;
2038                WindowState wallpaper = token.windows.get(curWallpaperIndex);
2039                if (updateWallpaperOffsetLocked(wallpaper, dw, dh, sync)) {
2040                    WindowStateAnimator winAnimator = wallpaper.mWinAnimator;
2041                    winAnimator.computeShownFrameLocked();
2042                    // No need to lay out the windows - we can just set the wallpaper position
2043                    // directly.
2044                    winAnimator.setWallpaperOffset(wallpaper.mShownFrame);
2045                    // We only want to be synchronous with one wallpaper.
2046                    sync = false;
2047                }
2048            }
2049        }
2050    }
2051
2052    /**
2053     * Check wallpaper for visiblity change and notify window if so.
2054     * @param wallpaper The wallpaper to test and notify.
2055     * @param visible Current visibility.
2056     */
2057    void dispatchWallpaperVisibility(final WindowState wallpaper, final boolean visible) {
2058        if (wallpaper.mWallpaperVisible != visible) {
2059            wallpaper.mWallpaperVisible = visible;
2060            try {
2061                if (DEBUG_VISIBILITY || DEBUG_WALLPAPER_LIGHT) Slog.v(TAG,
2062                        "Updating vis of wallpaper " + wallpaper
2063                        + ": " + visible + " from:\n" + Debug.getCallers(4, "  "));
2064                wallpaper.mClient.dispatchAppVisibility(visible);
2065            } catch (RemoteException e) {
2066            }
2067        }
2068    }
2069
2070    void updateWallpaperVisibilityLocked() {
2071        final boolean visible = isWallpaperVisible(mWallpaperTarget);
2072        final DisplayContent displayContent = mWallpaperTarget.mDisplayContent;
2073        final DisplayInfo displayInfo = displayContent.getDisplayInfo();
2074        final int dw = displayInfo.logicalWidth;
2075        final int dh = displayInfo.logicalHeight;
2076
2077        int curTokenIndex = mWallpaperTokens.size();
2078        while (curTokenIndex > 0) {
2079            curTokenIndex--;
2080            WindowToken token = mWallpaperTokens.get(curTokenIndex);
2081            if (token.hidden == visible) {
2082                token.hidden = !visible;
2083                // Need to do a layout to ensure the wallpaper now has the
2084                // correct size.
2085                getDefaultDisplayContentLocked().layoutNeeded = true;
2086            }
2087
2088            int curWallpaperIndex = token.windows.size();
2089            while (curWallpaperIndex > 0) {
2090                curWallpaperIndex--;
2091                WindowState wallpaper = token.windows.get(curWallpaperIndex);
2092                if (visible) {
2093                    updateWallpaperOffsetLocked(wallpaper, dw, dh, false);
2094                }
2095
2096                dispatchWallpaperVisibility(wallpaper, visible);
2097            }
2098        }
2099    }
2100
2101    public int addWindow(Session session, IWindow client, int seq,
2102            WindowManager.LayoutParams attrs, int viewVisibility, int displayId,
2103            Rect outContentInsets, InputChannel outInputChannel) {
2104        int[] appOp = new int[1];
2105        int res = mPolicy.checkAddPermission(attrs, appOp);
2106        if (res != WindowManagerGlobal.ADD_OKAY) {
2107            return res;
2108        }
2109
2110        boolean reportNewConfig = false;
2111        WindowState attachedWindow = null;
2112        WindowState win = null;
2113        long origId;
2114        final int type = attrs.type;
2115
2116        synchronized(mWindowMap) {
2117            if (!mDisplayReady) {
2118                throw new IllegalStateException("Display has not been initialialized");
2119            }
2120
2121            final DisplayContent displayContent = getDisplayContentLocked(displayId);
2122            if (displayContent == null) {
2123                Slog.w(TAG, "Attempted to add window to a display that does not exist: "
2124                        + displayId + ".  Aborting.");
2125                return WindowManagerGlobal.ADD_INVALID_DISPLAY;
2126            }
2127            if (!displayContent.hasAccess(session.mUid)) {
2128                Slog.w(TAG, "Attempted to add window to a display for which the application "
2129                        + "does not have access: " + displayId + ".  Aborting.");
2130                return WindowManagerGlobal.ADD_INVALID_DISPLAY;
2131            }
2132
2133            if (mWindowMap.containsKey(client.asBinder())) {
2134                Slog.w(TAG, "Window " + client + " is already added");
2135                return WindowManagerGlobal.ADD_DUPLICATE_ADD;
2136            }
2137
2138            if (type >= FIRST_SUB_WINDOW && type <= LAST_SUB_WINDOW) {
2139                attachedWindow = windowForClientLocked(null, attrs.token, false);
2140                if (attachedWindow == null) {
2141                    Slog.w(TAG, "Attempted to add window with token that is not a window: "
2142                          + attrs.token + ".  Aborting.");
2143                    return WindowManagerGlobal.ADD_BAD_SUBWINDOW_TOKEN;
2144                }
2145                if (attachedWindow.mAttrs.type >= FIRST_SUB_WINDOW
2146                        && attachedWindow.mAttrs.type <= LAST_SUB_WINDOW) {
2147                    Slog.w(TAG, "Attempted to add window with token that is a sub-window: "
2148                            + attrs.token + ".  Aborting.");
2149                    return WindowManagerGlobal.ADD_BAD_SUBWINDOW_TOKEN;
2150                }
2151            }
2152
2153            if (type == TYPE_PRIVATE_PRESENTATION && !displayContent.isPrivate()) {
2154                Slog.w(TAG, "Attempted to add private presentation window to a non-private display.  Aborting.");
2155                return WindowManagerGlobal.ADD_PERMISSION_DENIED;
2156            }
2157
2158            boolean addToken = false;
2159            WindowToken token = mTokenMap.get(attrs.token);
2160            if (token == null) {
2161                if (type >= FIRST_APPLICATION_WINDOW && type <= LAST_APPLICATION_WINDOW) {
2162                    Slog.w(TAG, "Attempted to add application window with unknown token "
2163                          + attrs.token + ".  Aborting.");
2164                    return WindowManagerGlobal.ADD_BAD_APP_TOKEN;
2165                }
2166                if (type == TYPE_INPUT_METHOD) {
2167                    Slog.w(TAG, "Attempted to add input method window with unknown token "
2168                          + attrs.token + ".  Aborting.");
2169                    return WindowManagerGlobal.ADD_BAD_APP_TOKEN;
2170                }
2171                if (type == TYPE_WALLPAPER) {
2172                    Slog.w(TAG, "Attempted to add wallpaper window with unknown token "
2173                          + attrs.token + ".  Aborting.");
2174                    return WindowManagerGlobal.ADD_BAD_APP_TOKEN;
2175                }
2176                if (type == TYPE_DREAM) {
2177                    Slog.w(TAG, "Attempted to add Dream window with unknown token "
2178                          + attrs.token + ".  Aborting.");
2179                    return WindowManagerGlobal.ADD_BAD_APP_TOKEN;
2180                }
2181                token = new WindowToken(this, attrs.token, -1, false);
2182                addToken = true;
2183            } else if (type >= FIRST_APPLICATION_WINDOW && type <= LAST_APPLICATION_WINDOW) {
2184                AppWindowToken atoken = token.appWindowToken;
2185                if (atoken == null) {
2186                    Slog.w(TAG, "Attempted to add window with non-application token "
2187                          + token + ".  Aborting.");
2188                    return WindowManagerGlobal.ADD_NOT_APP_TOKEN;
2189                } else if (atoken.removed) {
2190                    Slog.w(TAG, "Attempted to add window with exiting application token "
2191                          + token + ".  Aborting.");
2192                    return WindowManagerGlobal.ADD_APP_EXITING;
2193                }
2194                if (type == TYPE_APPLICATION_STARTING && atoken.firstWindowDrawn) {
2195                    // No need for this guy!
2196                    if (localLOGV) Slog.v(
2197                            TAG, "**** NO NEED TO START: " + attrs.getTitle());
2198                    return WindowManagerGlobal.ADD_STARTING_NOT_NEEDED;
2199                }
2200            } else if (type == TYPE_INPUT_METHOD) {
2201                if (token.windowType != TYPE_INPUT_METHOD) {
2202                    Slog.w(TAG, "Attempted to add input method window with bad token "
2203                            + attrs.token + ".  Aborting.");
2204                      return WindowManagerGlobal.ADD_BAD_APP_TOKEN;
2205                }
2206            } else if (type == TYPE_WALLPAPER) {
2207                if (token.windowType != TYPE_WALLPAPER) {
2208                    Slog.w(TAG, "Attempted to add wallpaper window with bad token "
2209                            + attrs.token + ".  Aborting.");
2210                      return WindowManagerGlobal.ADD_BAD_APP_TOKEN;
2211                }
2212            } else if (type == TYPE_DREAM) {
2213                if (token.windowType != TYPE_DREAM) {
2214                    Slog.w(TAG, "Attempted to add Dream window with bad token "
2215                            + attrs.token + ".  Aborting.");
2216                      return WindowManagerGlobal.ADD_BAD_APP_TOKEN;
2217                }
2218            }
2219
2220            win = new WindowState(this, session, client, token,
2221                    attachedWindow, appOp[0], seq, attrs, viewVisibility, displayContent);
2222            if (win.mDeathRecipient == null) {
2223                // Client has apparently died, so there is no reason to
2224                // continue.
2225                Slog.w(TAG, "Adding window client " + client.asBinder()
2226                        + " that is dead, aborting.");
2227                return WindowManagerGlobal.ADD_APP_EXITING;
2228            }
2229
2230            mPolicy.adjustWindowParamsLw(win.mAttrs);
2231            win.setShowToOwnerOnlyLocked(mPolicy.checkShowToOwnerOnly(attrs));
2232
2233            res = mPolicy.prepareAddWindowLw(win, attrs);
2234            if (res != WindowManagerGlobal.ADD_OKAY) {
2235                return res;
2236            }
2237
2238            if (outInputChannel != null && (attrs.inputFeatures
2239                    & WindowManager.LayoutParams.INPUT_FEATURE_NO_INPUT_CHANNEL) == 0) {
2240                String name = win.makeInputChannelName();
2241                InputChannel[] inputChannels = InputChannel.openInputChannelPair(name);
2242                win.setInputChannel(inputChannels[0]);
2243                inputChannels[1].transferTo(outInputChannel);
2244
2245                mInputManager.registerInputChannel(win.mInputChannel, win.mInputWindowHandle);
2246            }
2247
2248            // From now on, no exceptions or errors allowed!
2249
2250            res = WindowManagerGlobal.ADD_OKAY;
2251
2252            origId = Binder.clearCallingIdentity();
2253
2254            if (addToken) {
2255                mTokenMap.put(attrs.token, token);
2256            }
2257            win.attach();
2258            mWindowMap.put(client.asBinder(), win);
2259            if (win.mAppOp != AppOpsManager.OP_NONE) {
2260                if (mAppOps.startOpNoThrow(win.mAppOp, win.getOwningUid(), win.getOwningPackage())
2261                        != AppOpsManager.MODE_ALLOWED) {
2262                    win.setAppOpVisibilityLw(false);
2263                }
2264            }
2265
2266            if (type == TYPE_APPLICATION_STARTING && token.appWindowToken != null) {
2267                token.appWindowToken.startingWindow = win;
2268                if (DEBUG_STARTING_WINDOW) Slog.v (TAG, "addWindow: " + token.appWindowToken
2269                        + " startingWindow=" + win);
2270                Message m = mH.obtainMessage(H.REMOVE_STARTING_TIMEOUT, token.appWindowToken);
2271                mH.sendMessageDelayed(m, STARTING_WINDOW_TIMEOUT_DURATION);
2272            }
2273
2274            boolean imMayMove = true;
2275
2276            if (type == TYPE_INPUT_METHOD) {
2277                win.mGivenInsetsPending = true;
2278                mInputMethodWindow = win;
2279                addInputMethodWindowToListLocked(win);
2280                imMayMove = false;
2281            } else if (type == TYPE_INPUT_METHOD_DIALOG) {
2282                mInputMethodDialogs.add(win);
2283                addWindowToListInOrderLocked(win, true);
2284                moveInputMethodDialogsLocked(findDesiredInputMethodWindowIndexLocked(true));
2285                imMayMove = false;
2286            } else {
2287                addWindowToListInOrderLocked(win, true);
2288                if (type == TYPE_WALLPAPER) {
2289                    mLastWallpaperTimeoutTime = 0;
2290                    displayContent.pendingLayoutChanges |= FINISH_LAYOUT_REDO_WALLPAPER;
2291                } else if ((attrs.flags&FLAG_SHOW_WALLPAPER) != 0) {
2292                    displayContent.pendingLayoutChanges |= FINISH_LAYOUT_REDO_WALLPAPER;
2293                } else if (mWallpaperTarget != null
2294                        && mWallpaperTarget.mLayer >= win.mBaseLayer) {
2295                    // If there is currently a wallpaper being shown, and
2296                    // the base layer of the new window is below the current
2297                    // layer of the target window, then adjust the wallpaper.
2298                    // This is to avoid a new window being placed between the
2299                    // wallpaper and its target.
2300                    displayContent.pendingLayoutChanges |= FINISH_LAYOUT_REDO_WALLPAPER;
2301                }
2302            }
2303
2304            win.mWinAnimator.mEnterAnimationPending = true;
2305
2306            if (displayContent.isDefaultDisplay) {
2307                mPolicy.getContentInsetHintLw(attrs, outContentInsets);
2308            } else {
2309                outContentInsets.setEmpty();
2310            }
2311
2312            if (mInTouchMode) {
2313                res |= WindowManagerGlobal.ADD_FLAG_IN_TOUCH_MODE;
2314            }
2315            if (win.mAppToken == null || !win.mAppToken.clientHidden) {
2316                res |= WindowManagerGlobal.ADD_FLAG_APP_VISIBLE;
2317            }
2318
2319            mInputMonitor.setUpdateInputWindowsNeededLw();
2320
2321            boolean focusChanged = false;
2322            if (win.canReceiveKeys()) {
2323                focusChanged = updateFocusedWindowLocked(UPDATE_FOCUS_WILL_ASSIGN_LAYERS,
2324                        false /*updateInputWindows*/);
2325                if (focusChanged) {
2326                    imMayMove = false;
2327                }
2328            }
2329
2330            if (imMayMove) {
2331                moveInputMethodWindowsIfNeededLocked(false);
2332            }
2333
2334            assignLayersLocked(displayContent.getWindowList());
2335            // Don't do layout here, the window must call
2336            // relayout to be displayed, so we'll do it there.
2337
2338            if (focusChanged) {
2339                finishUpdateFocusedWindowAfterAssignLayersLocked(false /*updateInputWindows*/);
2340            }
2341            mInputMonitor.updateInputWindowsLw(false /*force*/);
2342
2343            if (localLOGV) Slog.v(
2344                TAG, "New client " + client.asBinder()
2345                + ": window=" + win);
2346
2347            if (win.isVisibleOrAdding() && updateOrientationFromAppTokensLocked(false)) {
2348                reportNewConfig = true;
2349            }
2350        }
2351
2352        if (reportNewConfig) {
2353            sendNewConfiguration();
2354        }
2355
2356        Binder.restoreCallingIdentity(origId);
2357
2358        return res;
2359    }
2360
2361    public void removeWindow(Session session, IWindow client) {
2362        synchronized(mWindowMap) {
2363            WindowState win = windowForClientLocked(session, client, false);
2364            if (win == null) {
2365                return;
2366            }
2367            removeWindowLocked(session, win);
2368        }
2369    }
2370
2371    public void removeWindowLocked(Session session, WindowState win) {
2372        if (win.mAttrs.type == TYPE_APPLICATION_STARTING) {
2373            if (DEBUG_STARTING_WINDOW) Slog.d(TAG, "Starting window removed " + win);
2374            removeStartingWindowTimeout(win.mAppToken);
2375        }
2376
2377        if (localLOGV || DEBUG_FOCUS || DEBUG_FOCUS_LIGHT && win==mCurrentFocus) Slog.v(
2378                TAG, "Remove " + win + " client="
2379                + Integer.toHexString(System.identityHashCode(win.mClient.asBinder()))
2380                + ", surface=" + win.mWinAnimator.mSurfaceControl + " Callers="
2381                + Debug.getCallers(4));
2382
2383        final long origId = Binder.clearCallingIdentity();
2384
2385        win.disposeInputChannel();
2386
2387        if (DEBUG_APP_TRANSITIONS) Slog.v(
2388                TAG, "Remove " + win + ": mSurface=" + win.mWinAnimator.mSurfaceControl
2389                + " mExiting=" + win.mExiting
2390                + " isAnimating=" + win.mWinAnimator.isAnimating()
2391                + " app-animation="
2392                + (win.mAppToken != null ? win.mAppToken.mAppAnimator.animation : null)
2393                + " inPendingTransaction="
2394                + (win.mAppToken != null ? win.mAppToken.inPendingTransaction : false)
2395                + " mDisplayFrozen=" + mDisplayFrozen);
2396        // Visibility of the removed window. Will be used later to update orientation later on.
2397        boolean wasVisible = false;
2398        // First, see if we need to run an animation.  If we do, we have
2399        // to hold off on removing the window until the animation is done.
2400        // If the display is frozen, just remove immediately, since the
2401        // animation wouldn't be seen.
2402        if (win.mHasSurface && okToDisplay()) {
2403            // If we are not currently running the exit animation, we
2404            // need to see about starting one.
2405            wasVisible = win.isWinVisibleLw();
2406            if (wasVisible) {
2407
2408                int transit = WindowManagerPolicy.TRANSIT_EXIT;
2409                if (win.mAttrs.type == TYPE_APPLICATION_STARTING) {
2410                    transit = WindowManagerPolicy.TRANSIT_PREVIEW_DONE;
2411                }
2412                // Try starting an animation.
2413                if (win.mWinAnimator.applyAnimationLocked(transit, false)) {
2414                    win.mExiting = true;
2415                }
2416                //TODO (multidisplay): Magnification is supported only for the default display.
2417                if (mDisplayMagnifier != null
2418                        && win.getDisplayId() == Display.DEFAULT_DISPLAY) {
2419                    mDisplayMagnifier.onWindowTransitionLocked(win, transit);
2420                }
2421            }
2422            if (win.mExiting || win.mWinAnimator.isAnimating()) {
2423                // The exit animation is running... wait for it!
2424                //Slog.i(TAG, "*** Running exit animation...");
2425                win.mExiting = true;
2426                win.mRemoveOnExit = true;
2427                win.mDisplayContent.layoutNeeded = true;
2428                updateFocusedWindowLocked(UPDATE_FOCUS_WILL_PLACE_SURFACES,
2429                        false /*updateInputWindows*/);
2430                performLayoutAndPlaceSurfacesLocked();
2431                if (win.mAppToken != null) {
2432                    win.mAppToken.updateReportedVisibilityLocked();
2433                }
2434                //dump();
2435                Binder.restoreCallingIdentity(origId);
2436                return;
2437            }
2438        }
2439
2440        removeWindowInnerLocked(session, win);
2441        // Removing a visible window will effect the computed orientation
2442        // So just update orientation if needed.
2443        if (wasVisible && updateOrientationFromAppTokensLocked(false)) {
2444            mH.sendEmptyMessage(H.SEND_NEW_CONFIGURATION);
2445        }
2446        updateFocusedWindowLocked(UPDATE_FOCUS_NORMAL, true /*updateInputWindows*/);
2447        Binder.restoreCallingIdentity(origId);
2448    }
2449
2450    private void removeWindowInnerLocked(Session session, WindowState win) {
2451        if (win.mRemoved) {
2452            // Nothing to do.
2453            return;
2454        }
2455
2456        for (int i=win.mChildWindows.size()-1; i>=0; i--) {
2457            WindowState cwin = win.mChildWindows.get(i);
2458            Slog.w(TAG, "Force-removing child win " + cwin + " from container "
2459                    + win);
2460            removeWindowInnerLocked(cwin.mSession, cwin);
2461        }
2462
2463        win.mRemoved = true;
2464
2465        if (mInputMethodTarget == win) {
2466            moveInputMethodWindowsIfNeededLocked(false);
2467        }
2468
2469        if (false) {
2470            RuntimeException e = new RuntimeException("here");
2471            e.fillInStackTrace();
2472            Slog.w(TAG, "Removing window " + win, e);
2473        }
2474
2475        mPolicy.removeWindowLw(win);
2476        win.removeLocked();
2477
2478        if (DEBUG_ADD_REMOVE) Slog.v(TAG, "removeWindowInnerLocked: " + win);
2479        mWindowMap.remove(win.mClient.asBinder());
2480        if (win.mAppOp != AppOpsManager.OP_NONE) {
2481            mAppOps.finishOp(win.mAppOp, win.getOwningUid(), win.getOwningPackage());
2482        }
2483
2484        final WindowList windows = win.getWindowList();
2485        windows.remove(win);
2486        mPendingRemove.remove(win);
2487        mResizingWindows.remove(win);
2488        mWindowsChanged = true;
2489        if (DEBUG_WINDOW_MOVEMENT) Slog.v(TAG, "Final remove of window: " + win);
2490
2491        if (mInputMethodWindow == win) {
2492            mInputMethodWindow = null;
2493        } else if (win.mAttrs.type == TYPE_INPUT_METHOD_DIALOG) {
2494            mInputMethodDialogs.remove(win);
2495        }
2496
2497        final WindowToken token = win.mToken;
2498        final AppWindowToken atoken = win.mAppToken;
2499        if (DEBUG_ADD_REMOVE) Slog.v(TAG, "Removing " + win + " from " + token);
2500        token.windows.remove(win);
2501        if (atoken != null) {
2502            atoken.allAppWindows.remove(win);
2503        }
2504        if (localLOGV) Slog.v(
2505                TAG, "**** Removing window " + win + ": count="
2506                + token.windows.size());
2507        if (token.windows.size() == 0) {
2508            if (!token.explicit) {
2509                mTokenMap.remove(token.token);
2510            } else if (atoken != null) {
2511                atoken.firstWindowDrawn = false;
2512            }
2513        }
2514
2515        if (atoken != null) {
2516            if (atoken.startingWindow == win) {
2517                if (DEBUG_STARTING_WINDOW) Slog.v(TAG, "Nulling startingWindow " + win);
2518                removeStartingWindowTimeout(atoken);
2519                atoken.startingWindow = null;
2520            } else if (atoken.allAppWindows.size() == 0 && atoken.startingData != null) {
2521                // If this is the last window and we had requested a starting
2522                // transition window, well there is no point now.
2523                if (DEBUG_STARTING_WINDOW) Slog.v(TAG, "Nulling last startingWindow");
2524                atoken.startingData = null;
2525            } else if (atoken.allAppWindows.size() == 1 && atoken.startingView != null) {
2526                // If this is the last window except for a starting transition
2527                // window, we need to get rid of the starting transition.
2528                scheduleRemoveStartingWindow(atoken);
2529            }
2530        }
2531
2532        if (win.mAttrs.type == TYPE_WALLPAPER) {
2533            mLastWallpaperTimeoutTime = 0;
2534            getDefaultDisplayContentLocked().pendingLayoutChanges |=
2535                    WindowManagerPolicy.FINISH_LAYOUT_REDO_WALLPAPER;
2536        } else if ((win.mAttrs.flags&FLAG_SHOW_WALLPAPER) != 0) {
2537            getDefaultDisplayContentLocked().pendingLayoutChanges |=
2538                    WindowManagerPolicy.FINISH_LAYOUT_REDO_WALLPAPER;
2539        }
2540
2541        if (!mInLayout) {
2542            assignLayersLocked(windows);
2543            win.mDisplayContent.layoutNeeded = true;
2544            performLayoutAndPlaceSurfacesLocked();
2545            if (win.mAppToken != null) {
2546                win.mAppToken.updateReportedVisibilityLocked();
2547            }
2548        }
2549
2550        mInputMonitor.updateInputWindowsLw(true /*force*/);
2551    }
2552
2553    public void updateAppOpsState() {
2554        synchronized(mWindowMap) {
2555            final int numDisplays = mDisplayContents.size();
2556            for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) {
2557                final WindowList windows = mDisplayContents.valueAt(displayNdx).getWindowList();
2558                final int numWindows = windows.size();
2559                for (int winNdx = 0; winNdx < numWindows; ++winNdx) {
2560                    final WindowState win = windows.get(winNdx);
2561                    if (win.mAppOp != AppOpsManager.OP_NONE) {
2562                        final int mode = mAppOps.checkOpNoThrow(win.mAppOp, win.getOwningUid(),
2563                                win.getOwningPackage());
2564                        win.setAppOpVisibilityLw(mode == AppOpsManager.MODE_ALLOWED);
2565                    }
2566                }
2567            }
2568        }
2569    }
2570
2571    static void logSurface(WindowState w, String msg, RuntimeException where) {
2572        String str = "  SURFACE " + msg + ": " + w;
2573        if (where != null) {
2574            Slog.i(TAG, str, where);
2575        } else {
2576            Slog.i(TAG, str);
2577        }
2578    }
2579
2580    static void logSurface(SurfaceControl s, String title, String msg, RuntimeException where) {
2581        String str = "  SURFACE " + s + ": " + msg + " / " + title;
2582        if (where != null) {
2583            Slog.i(TAG, str, where);
2584        } else {
2585            Slog.i(TAG, str);
2586        }
2587    }
2588
2589    void setTransparentRegionWindow(Session session, IWindow client, Region region) {
2590        long origId = Binder.clearCallingIdentity();
2591        try {
2592            synchronized (mWindowMap) {
2593                WindowState w = windowForClientLocked(session, client, false);
2594                if ((w != null) && w.mHasSurface) {
2595                    w.mWinAnimator.setTransparentRegionHintLocked(region);
2596                }
2597            }
2598        } finally {
2599            Binder.restoreCallingIdentity(origId);
2600        }
2601    }
2602
2603    void setInsetsWindow(Session session, IWindow client,
2604            int touchableInsets, Rect contentInsets,
2605            Rect visibleInsets, Region touchableRegion) {
2606        long origId = Binder.clearCallingIdentity();
2607        try {
2608            synchronized (mWindowMap) {
2609                WindowState w = windowForClientLocked(session, client, false);
2610                if (w != null) {
2611                    w.mGivenInsetsPending = false;
2612                    w.mGivenContentInsets.set(contentInsets);
2613                    w.mGivenVisibleInsets.set(visibleInsets);
2614                    w.mGivenTouchableRegion.set(touchableRegion);
2615                    w.mTouchableInsets = touchableInsets;
2616                    if (w.mGlobalScale != 1) {
2617                        w.mGivenContentInsets.scale(w.mGlobalScale);
2618                        w.mGivenVisibleInsets.scale(w.mGlobalScale);
2619                        w.mGivenTouchableRegion.scale(w.mGlobalScale);
2620                    }
2621                    w.mDisplayContent.layoutNeeded = true;
2622                    performLayoutAndPlaceSurfacesLocked();
2623                }
2624            }
2625        } finally {
2626            Binder.restoreCallingIdentity(origId);
2627        }
2628    }
2629
2630    public void getWindowDisplayFrame(Session session, IWindow client,
2631            Rect outDisplayFrame) {
2632        synchronized(mWindowMap) {
2633            WindowState win = windowForClientLocked(session, client, false);
2634            if (win == null) {
2635                outDisplayFrame.setEmpty();
2636                return;
2637            }
2638            outDisplayFrame.set(win.mDisplayFrame);
2639        }
2640    }
2641
2642    public void setWindowWallpaperPositionLocked(WindowState window, float x, float y,
2643            float xStep, float yStep) {
2644        if (window.mWallpaperX != x || window.mWallpaperY != y)  {
2645            window.mWallpaperX = x;
2646            window.mWallpaperY = y;
2647            window.mWallpaperXStep = xStep;
2648            window.mWallpaperYStep = yStep;
2649            updateWallpaperOffsetLocked(window, true);
2650        }
2651    }
2652
2653    void wallpaperCommandComplete(IBinder window, Bundle result) {
2654        synchronized (mWindowMap) {
2655            if (mWaitingOnWallpaper != null &&
2656                    mWaitingOnWallpaper.mClient.asBinder() == window) {
2657                mWaitingOnWallpaper = null;
2658                mWindowMap.notifyAll();
2659            }
2660        }
2661    }
2662
2663    public Bundle sendWindowWallpaperCommandLocked(WindowState window,
2664            String action, int x, int y, int z, Bundle extras, boolean sync) {
2665        if (window == mWallpaperTarget || window == mLowerWallpaperTarget
2666                || window == mUpperWallpaperTarget) {
2667            boolean doWait = sync;
2668            int curTokenIndex = mWallpaperTokens.size();
2669            while (curTokenIndex > 0) {
2670                curTokenIndex--;
2671                WindowToken token = mWallpaperTokens.get(curTokenIndex);
2672                int curWallpaperIndex = token.windows.size();
2673                while (curWallpaperIndex > 0) {
2674                    curWallpaperIndex--;
2675                    WindowState wallpaper = token.windows.get(curWallpaperIndex);
2676                    try {
2677                        wallpaper.mClient.dispatchWallpaperCommand(action,
2678                                x, y, z, extras, sync);
2679                        // We only want to be synchronous with one wallpaper.
2680                        sync = false;
2681                    } catch (RemoteException e) {
2682                    }
2683                }
2684            }
2685
2686            if (doWait) {
2687                // XXX Need to wait for result.
2688            }
2689        }
2690
2691        return null;
2692    }
2693
2694    public void setUniverseTransformLocked(WindowState window, float alpha,
2695            float offx, float offy, float dsdx, float dtdx, float dsdy, float dtdy) {
2696        Transformation transform = window.mWinAnimator.mUniverseTransform;
2697        transform.setAlpha(alpha);
2698        Matrix matrix = transform.getMatrix();
2699        matrix.getValues(mTmpFloats);
2700        mTmpFloats[Matrix.MTRANS_X] = offx;
2701        mTmpFloats[Matrix.MTRANS_Y] = offy;
2702        mTmpFloats[Matrix.MSCALE_X] = dsdx;
2703        mTmpFloats[Matrix.MSKEW_Y] = dtdx;
2704        mTmpFloats[Matrix.MSKEW_X] = dsdy;
2705        mTmpFloats[Matrix.MSCALE_Y] = dtdy;
2706        matrix.setValues(mTmpFloats);
2707        final DisplayInfo displayInfo = window.mDisplayContent.getDisplayInfo();
2708        final RectF dispRect = new RectF(0, 0,
2709                displayInfo.logicalWidth, displayInfo.logicalHeight);
2710        matrix.mapRect(dispRect);
2711        window.mGivenTouchableRegion.set(0, 0,
2712                displayInfo.logicalWidth, displayInfo.logicalHeight);
2713        window.mGivenTouchableRegion.op((int)dispRect.left, (int)dispRect.top,
2714                (int)dispRect.right, (int)dispRect.bottom, Region.Op.DIFFERENCE);
2715        window.mTouchableInsets = ViewTreeObserver.InternalInsetsInfo.TOUCHABLE_INSETS_REGION;
2716        window.mDisplayContent.layoutNeeded = true;
2717        performLayoutAndPlaceSurfacesLocked();
2718    }
2719
2720    public void onRectangleOnScreenRequested(IBinder token, Rect rectangle, boolean immediate) {
2721        synchronized (mWindowMap) {
2722            if (mDisplayMagnifier != null) {
2723                WindowState window = mWindowMap.get(token);
2724                //TODO (multidisplay): Magnification is supported only for the default display.
2725                if (window != null && window.getDisplayId() == Display.DEFAULT_DISPLAY) {
2726                    mDisplayMagnifier.onRectangleOnScreenRequestedLocked(rectangle, immediate);
2727                }
2728            }
2729        }
2730    }
2731
2732    public IWindowId getWindowId(IBinder token) {
2733        synchronized (mWindowMap) {
2734            WindowState window = mWindowMap.get(token);
2735            return window != null ? window.mWindowId : null;
2736        }
2737    }
2738
2739    public int relayoutWindow(Session session, IWindow client, int seq,
2740            WindowManager.LayoutParams attrs, int requestedWidth,
2741            int requestedHeight, int viewVisibility, int flags,
2742            Rect outFrame, Rect outOverscanInsets, Rect outContentInsets,
2743            Rect outVisibleInsets, Configuration outConfig, Surface outSurface) {
2744        boolean toBeDisplayed = false;
2745        boolean inTouchMode;
2746        boolean configChanged;
2747        boolean surfaceChanged = false;
2748        boolean animating;
2749
2750        // if they don't have this permission, mask out the status bar bits
2751        int systemUiVisibility = 0;
2752        if (attrs != null) {
2753            systemUiVisibility = (attrs.systemUiVisibility|attrs.subtreeSystemUiVisibility);
2754            if ((systemUiVisibility & StatusBarManager.DISABLE_MASK) != 0) {
2755                if (mContext.checkCallingOrSelfPermission(android.Manifest.permission.STATUS_BAR)
2756                        != PackageManager.PERMISSION_GRANTED) {
2757                    systemUiVisibility &= ~StatusBarManager.DISABLE_MASK;
2758                }
2759            }
2760        }
2761        long origId = Binder.clearCallingIdentity();
2762
2763        synchronized(mWindowMap) {
2764            WindowState win = windowForClientLocked(session, client, false);
2765            if (win == null) {
2766                return 0;
2767            }
2768            WindowStateAnimator winAnimator = win.mWinAnimator;
2769            if (win.mRequestedWidth != requestedWidth
2770                    || win.mRequestedHeight != requestedHeight) {
2771                win.mLayoutNeeded = true;
2772                win.mRequestedWidth = requestedWidth;
2773                win.mRequestedHeight = requestedHeight;
2774            }
2775            if (attrs != null && seq == win.mSeq) {
2776                win.mSystemUiVisibility = systemUiVisibility;
2777            }
2778
2779            if (attrs != null) {
2780                mPolicy.adjustWindowParamsLw(attrs);
2781            }
2782
2783            winAnimator.mSurfaceDestroyDeferred =
2784                    (flags&WindowManagerGlobal.RELAYOUT_DEFER_SURFACE_DESTROY) != 0;
2785
2786            int attrChanges = 0;
2787            int flagChanges = 0;
2788            if (attrs != null) {
2789                if (win.mAttrs.type != attrs.type) {
2790                    throw new IllegalArgumentException(
2791                            "Window type can not be changed after the window is added.");
2792                }
2793                flagChanges = win.mAttrs.flags ^= attrs.flags;
2794                attrChanges = win.mAttrs.copyFrom(attrs);
2795                if ((attrChanges & (WindowManager.LayoutParams.LAYOUT_CHANGED
2796                        | WindowManager.LayoutParams.SYSTEM_UI_VISIBILITY_CHANGED)) != 0) {
2797                    win.mLayoutNeeded = true;
2798                }
2799            }
2800
2801            if (DEBUG_LAYOUT) Slog.v(TAG, "Relayout " + win + ": viewVisibility=" + viewVisibility
2802                    + " req=" + requestedWidth + "x" + requestedHeight + " " + win.mAttrs);
2803
2804            win.mEnforceSizeCompat =
2805                    (win.mAttrs.privateFlags & PRIVATE_FLAG_COMPATIBLE_WINDOW) != 0;
2806
2807            if ((attrChanges & WindowManager.LayoutParams.ALPHA_CHANGED) != 0) {
2808                winAnimator.mAlpha = attrs.alpha;
2809            }
2810
2811            final boolean scaledWindow =
2812                ((win.mAttrs.flags & WindowManager.LayoutParams.FLAG_SCALED) != 0);
2813
2814            if (scaledWindow) {
2815                // requested{Width|Height} Surface's physical size
2816                // attrs.{width|height} Size on screen
2817                win.mHScale = (attrs.width  != requestedWidth)  ?
2818                        (attrs.width  / (float)requestedWidth) : 1.0f;
2819                win.mVScale = (attrs.height != requestedHeight) ?
2820                        (attrs.height / (float)requestedHeight) : 1.0f;
2821            } else {
2822                win.mHScale = win.mVScale = 1;
2823            }
2824
2825            boolean imMayMove = (flagChanges & (FLAG_ALT_FOCUSABLE_IM | FLAG_NOT_FOCUSABLE)) != 0;
2826
2827            final boolean isDefaultDisplay = win.isDefaultDisplay();
2828            boolean focusMayChange = isDefaultDisplay && (win.mViewVisibility != viewVisibility
2829                    || ((flagChanges & FLAG_NOT_FOCUSABLE) != 0)
2830                    || (!win.mRelayoutCalled));
2831
2832            boolean wallpaperMayMove = win.mViewVisibility != viewVisibility
2833                    && (win.mAttrs.flags & FLAG_SHOW_WALLPAPER) != 0;
2834            wallpaperMayMove |= (flagChanges & FLAG_SHOW_WALLPAPER) != 0;
2835
2836            win.mRelayoutCalled = true;
2837            final int oldVisibility = win.mViewVisibility;
2838            win.mViewVisibility = viewVisibility;
2839            if (DEBUG_SCREEN_ON) {
2840                RuntimeException stack = new RuntimeException();
2841                stack.fillInStackTrace();
2842                Slog.i(TAG, "Relayout " + win + ": oldVis=" + oldVisibility
2843                        + " newVis=" + viewVisibility, stack);
2844            }
2845            if (viewVisibility == View.VISIBLE &&
2846                    (win.mAppToken == null || !win.mAppToken.clientHidden)) {
2847                toBeDisplayed = !win.isVisibleLw();
2848                if (win.mExiting) {
2849                    winAnimator.cancelExitAnimationForNextAnimationLocked();
2850                    win.mExiting = false;
2851                }
2852                if (win.mDestroying) {
2853                    win.mDestroying = false;
2854                    mDestroySurface.remove(win);
2855                }
2856                if (oldVisibility == View.GONE) {
2857                    winAnimator.mEnterAnimationPending = true;
2858                }
2859                if (toBeDisplayed) {
2860                    if (win.isDrawnLw() && okToDisplay()) {
2861                        winAnimator.applyEnterAnimationLocked();
2862                    }
2863                    if ((win.mAttrs.flags
2864                            & WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON) != 0) {
2865                        if (DEBUG_VISIBILITY) Slog.v(TAG,
2866                                "Relayout window turning screen on: " + win);
2867                        win.mTurnOnScreen = true;
2868                    }
2869                    if (win.isConfigChanged()) {
2870                        if (DEBUG_CONFIGURATION) Slog.i(TAG, "Window " + win
2871                                + " visible with new config: " + mCurConfiguration);
2872                        outConfig.setTo(mCurConfiguration);
2873                    }
2874                }
2875                if ((attrChanges&WindowManager.LayoutParams.FORMAT_CHANGED) != 0) {
2876                    // To change the format, we need to re-build the surface.
2877                    winAnimator.destroySurfaceLocked();
2878                    toBeDisplayed = true;
2879                    surfaceChanged = true;
2880                }
2881                try {
2882                    if (!win.mHasSurface) {
2883                        surfaceChanged = true;
2884                    }
2885                    SurfaceControl surfaceControl = winAnimator.createSurfaceLocked();
2886                    if (surfaceControl != null) {
2887                        outSurface.copyFrom(surfaceControl);
2888                        if (SHOW_TRANSACTIONS) Slog.i(TAG,
2889                                "  OUT SURFACE " + outSurface + ": copied");
2890                    } else {
2891                        // For some reason there isn't a surface.  Clear the
2892                        // caller's object so they see the same state.
2893                        outSurface.release();
2894                    }
2895                } catch (Exception e) {
2896                    mInputMonitor.updateInputWindowsLw(true /*force*/);
2897
2898                    Slog.w(TAG, "Exception thrown when creating surface for client "
2899                             + client + " (" + win.mAttrs.getTitle() + ")",
2900                             e);
2901                    Binder.restoreCallingIdentity(origId);
2902                    return 0;
2903                }
2904                if (toBeDisplayed) {
2905                    focusMayChange = isDefaultDisplay;
2906                }
2907                if (win.mAttrs.type == TYPE_INPUT_METHOD
2908                        && mInputMethodWindow == null) {
2909                    mInputMethodWindow = win;
2910                    imMayMove = true;
2911                }
2912                if (win.mAttrs.type == TYPE_BASE_APPLICATION
2913                        && win.mAppToken != null
2914                        && win.mAppToken.startingWindow != null) {
2915                    // Special handling of starting window over the base
2916                    // window of the app: propagate lock screen flags to it,
2917                    // to provide the correct semantics while starting.
2918                    final int mask =
2919                        WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED
2920                        | WindowManager.LayoutParams.FLAG_DISMISS_KEYGUARD
2921                        | WindowManager.LayoutParams.FLAG_ALLOW_LOCK_WHILE_SCREEN_ON;
2922                    WindowManager.LayoutParams sa = win.mAppToken.startingWindow.mAttrs;
2923                    sa.flags = (sa.flags&~mask) | (win.mAttrs.flags&mask);
2924                }
2925            } else {
2926                winAnimator.mEnterAnimationPending = false;
2927                if (winAnimator.mSurfaceControl != null) {
2928                    if (DEBUG_VISIBILITY) Slog.i(TAG, "Relayout invis " + win
2929                            + ": mExiting=" + win.mExiting);
2930                    // If we are not currently running the exit animation, we
2931                    // need to see about starting one.
2932                    if (!win.mExiting) {
2933                        surfaceChanged = true;
2934                        // Try starting an animation; if there isn't one, we
2935                        // can destroy the surface right away.
2936                        int transit = WindowManagerPolicy.TRANSIT_EXIT;
2937                        if (win.mAttrs.type == TYPE_APPLICATION_STARTING) {
2938                            transit = WindowManagerPolicy.TRANSIT_PREVIEW_DONE;
2939                        }
2940                        if (win.isWinVisibleLw() &&
2941                                winAnimator.applyAnimationLocked(transit, false)) {
2942                            focusMayChange = isDefaultDisplay;
2943                            win.mExiting = true;
2944                        } else if (win.mWinAnimator.isAnimating()) {
2945                            // Currently in a hide animation... turn this into
2946                            // an exit.
2947                            win.mExiting = true;
2948                        } else if (win == mWallpaperTarget) {
2949                            // If the wallpaper is currently behind this
2950                            // window, we need to change both of them inside
2951                            // of a transaction to avoid artifacts.
2952                            win.mExiting = true;
2953                            win.mWinAnimator.mAnimating = true;
2954                        } else {
2955                            if (mInputMethodWindow == win) {
2956                                mInputMethodWindow = null;
2957                            }
2958                            winAnimator.destroySurfaceLocked();
2959                        }
2960                        //TODO (multidisplay): Magnification is supported only for the default
2961                        if (mDisplayMagnifier != null
2962                                && win.getDisplayId() == Display.DEFAULT_DISPLAY) {
2963                            mDisplayMagnifier.onWindowTransitionLocked(win, transit);
2964                        }
2965                    }
2966                }
2967
2968                outSurface.release();
2969                if (DEBUG_VISIBILITY) Slog.i(TAG, "Releasing surface in: " + win);
2970            }
2971
2972            if (focusMayChange) {
2973                //System.out.println("Focus may change: " + win.mAttrs.getTitle());
2974                if (updateFocusedWindowLocked(UPDATE_FOCUS_WILL_PLACE_SURFACES,
2975                        false /*updateInputWindows*/)) {
2976                    imMayMove = false;
2977                }
2978                //System.out.println("Relayout " + win + ": focus=" + mCurrentFocus);
2979            }
2980
2981            // updateFocusedWindowLocked() already assigned layers so we only need to
2982            // reassign them at this point if the IM window state gets shuffled
2983            if (imMayMove && (moveInputMethodWindowsIfNeededLocked(false) || toBeDisplayed)) {
2984                // Little hack here -- we -should- be able to rely on the
2985                // function to return true if the IME has moved and needs
2986                // its layer recomputed.  However, if the IME was hidden
2987                // and isn't actually moved in the list, its layer may be
2988                // out of data so we make sure to recompute it.
2989                assignLayersLocked(win.getWindowList());
2990            }
2991
2992            if (wallpaperMayMove) {
2993                getDefaultDisplayContentLocked().pendingLayoutChanges |=
2994                        WindowManagerPolicy.FINISH_LAYOUT_REDO_WALLPAPER;
2995            }
2996
2997            win.mDisplayContent.layoutNeeded = true;
2998            win.mGivenInsetsPending = (flags&WindowManagerGlobal.RELAYOUT_INSETS_PENDING) != 0;
2999            configChanged = updateOrientationFromAppTokensLocked(false);
3000            performLayoutAndPlaceSurfacesLocked();
3001            if (toBeDisplayed && win.mIsWallpaper) {
3002                DisplayInfo displayInfo = getDefaultDisplayInfoLocked();
3003                updateWallpaperOffsetLocked(win,
3004                        displayInfo.logicalWidth, displayInfo.logicalHeight, false);
3005            }
3006            if (win.mAppToken != null) {
3007                win.mAppToken.updateReportedVisibilityLocked();
3008            }
3009            outFrame.set(win.mCompatFrame);
3010            outOverscanInsets.set(win.mOverscanInsets);
3011            outContentInsets.set(win.mContentInsets);
3012            outVisibleInsets.set(win.mVisibleInsets);
3013            if (localLOGV) Slog.v(
3014                TAG, "Relayout given client " + client.asBinder()
3015                + ", requestedWidth=" + requestedWidth
3016                + ", requestedHeight=" + requestedHeight
3017                + ", viewVisibility=" + viewVisibility
3018                + "\nRelayout returning frame=" + outFrame
3019                + ", surface=" + outSurface);
3020
3021            if (localLOGV || DEBUG_FOCUS) Slog.v(
3022                TAG, "Relayout of " + win + ": focusMayChange=" + focusMayChange);
3023
3024            inTouchMode = mInTouchMode;
3025            animating = mAnimator.mAnimating && win.mWinAnimator.isAnimating();
3026            if (animating && !mRelayoutWhileAnimating.contains(win)) {
3027                mRelayoutWhileAnimating.add(win);
3028            }
3029
3030            mInputMonitor.updateInputWindowsLw(true /*force*/);
3031
3032            if (DEBUG_LAYOUT) {
3033                Slog.v(TAG, "Relayout complete " + win + ": outFrame=" + outFrame.toShortString());
3034            }
3035        }
3036
3037        if (configChanged) {
3038            sendNewConfiguration();
3039        }
3040
3041        Binder.restoreCallingIdentity(origId);
3042
3043        return (inTouchMode ? WindowManagerGlobal.RELAYOUT_RES_IN_TOUCH_MODE : 0)
3044                | (toBeDisplayed ? WindowManagerGlobal.RELAYOUT_RES_FIRST_TIME : 0)
3045                | (surfaceChanged ? WindowManagerGlobal.RELAYOUT_RES_SURFACE_CHANGED : 0)
3046                | (animating ? WindowManagerGlobal.RELAYOUT_RES_ANIMATING : 0);
3047    }
3048
3049    public void performDeferredDestroyWindow(Session session, IWindow client) {
3050        long origId = Binder.clearCallingIdentity();
3051
3052        try {
3053            synchronized (mWindowMap) {
3054                WindowState win = windowForClientLocked(session, client, false);
3055                if (win == null) {
3056                    return;
3057                }
3058                win.mWinAnimator.destroyDeferredSurfaceLocked();
3059            }
3060        } finally {
3061            Binder.restoreCallingIdentity(origId);
3062        }
3063    }
3064
3065    public boolean outOfMemoryWindow(Session session, IWindow client) {
3066        long origId = Binder.clearCallingIdentity();
3067
3068        try {
3069            synchronized (mWindowMap) {
3070                WindowState win = windowForClientLocked(session, client, false);
3071                if (win == null) {
3072                    return false;
3073                }
3074                return reclaimSomeSurfaceMemoryLocked(win.mWinAnimator, "from-client", false);
3075            }
3076        } finally {
3077            Binder.restoreCallingIdentity(origId);
3078        }
3079    }
3080
3081    public void finishDrawingWindow(Session session, IWindow client) {
3082        final long origId = Binder.clearCallingIdentity();
3083        try {
3084            synchronized (mWindowMap) {
3085                WindowState win = windowForClientLocked(session, client, false);
3086                if (win != null && win.mWinAnimator.finishDrawingLocked()) {
3087                    if ((win.mAttrs.flags & FLAG_SHOW_WALLPAPER) != 0) {
3088                        getDefaultDisplayContentLocked().pendingLayoutChanges |=
3089                                WindowManagerPolicy.FINISH_LAYOUT_REDO_WALLPAPER;
3090                    }
3091                    win.mDisplayContent.layoutNeeded = true;
3092                    requestTraversalLocked();
3093                }
3094            }
3095        } finally {
3096            Binder.restoreCallingIdentity(origId);
3097        }
3098    }
3099
3100    @Override
3101    public void getWindowFrame(IBinder token, Rect outBounds) {
3102        if (!checkCallingPermission(android.Manifest.permission.RETRIEVE_WINDOW_INFO,
3103                "getWindowInfo()")) {
3104            throw new SecurityException("Requires RETRIEVE_WINDOW_INFO permission.");
3105        }
3106        synchronized (mWindowMap) {
3107            WindowState windowState = mWindowMap.get(token);
3108            if (windowState != null) {
3109                outBounds.set(windowState.mFrame);
3110            } else {
3111                outBounds.setEmpty();
3112            }
3113        }
3114    }
3115
3116    @Override
3117    public void setMagnificationSpec(MagnificationSpec spec) {
3118        if (!checkCallingPermission(android.Manifest.permission.MAGNIFY_DISPLAY,
3119                "setMagnificationSpec()")) {
3120            throw new SecurityException("Requires MAGNIFY_DISPLAY permission.");
3121        }
3122        synchronized (mWindowMap) {
3123            if (mDisplayMagnifier != null) {
3124                mDisplayMagnifier.setMagnificationSpecLocked(spec);
3125            } else {
3126                throw new IllegalStateException("Magnification callbacks not set!");
3127            }
3128        }
3129        if (Binder.getCallingPid() != android.os.Process.myPid()) {
3130            spec.recycle();
3131        }
3132    }
3133
3134    @Override
3135    public MagnificationSpec getCompatibleMagnificationSpecForWindow(IBinder windowToken) {
3136        if (!checkCallingPermission(android.Manifest.permission.MAGNIFY_DISPLAY,
3137                "getCompatibleMagnificationSpecForWindow()")) {
3138            throw new SecurityException("Requires MAGNIFY_DISPLAY permission.");
3139        }
3140        synchronized (mWindowMap) {
3141            WindowState windowState = mWindowMap.get(windowToken);
3142            if (windowState == null) {
3143                return null;
3144            }
3145            MagnificationSpec spec = null;
3146            if (mDisplayMagnifier != null) {
3147                spec = mDisplayMagnifier.getMagnificationSpecForWindowLocked(windowState);
3148            }
3149            if ((spec == null || spec.isNop()) && windowState.mGlobalScale == 1.0f) {
3150                return null;
3151            }
3152            spec = (spec == null) ? MagnificationSpec.obtain() : MagnificationSpec.obtain(spec);
3153            spec.scale *= windowState.mGlobalScale;
3154            return spec;
3155        }
3156    }
3157
3158    @Override
3159    public void setMagnificationCallbacks(IMagnificationCallbacks callbacks) {
3160        if (!checkCallingPermission(android.Manifest.permission.MAGNIFY_DISPLAY,
3161                "setMagnificationCallbacks()")) {
3162            throw new SecurityException("Requires MAGNIFY_DISPLAY permission.");
3163        }
3164        synchronized (mWindowMap) {
3165            if (mDisplayMagnifier == null) {
3166                mDisplayMagnifier = new DisplayMagnifier(this, callbacks);
3167            } else {
3168                if (callbacks == null) {
3169                    if (mDisplayMagnifier != null) {
3170                        mDisplayMagnifier.destroyLocked();
3171                        mDisplayMagnifier = null;
3172                    }
3173                } else {
3174                    throw new IllegalStateException("Magnification callbacks already set!");
3175                }
3176            }
3177        }
3178    }
3179
3180    private boolean applyAnimationLocked(AppWindowToken atoken,
3181            WindowManager.LayoutParams lp, int transit, boolean enter) {
3182        // Only apply an animation if the display isn't frozen.  If it is
3183        // frozen, there is no reason to animate and it can cause strange
3184        // artifacts when we unfreeze the display if some different animation
3185        // is running.
3186        if (okToDisplay()) {
3187            DisplayInfo displayInfo = getDefaultDisplayInfoLocked();
3188            final int width = displayInfo.appWidth;
3189            final int height = displayInfo.appHeight;
3190            if (DEBUG_APP_TRANSITIONS || DEBUG_ANIM) Slog.v(TAG, "applyAnimation: atoken="
3191                    + atoken);
3192            Animation a = mAppTransition.loadAnimation(lp, transit, enter, width, height);
3193            if (a != null) {
3194                if (DEBUG_ANIM) {
3195                    RuntimeException e = null;
3196                    if (!HIDE_STACK_CRAWLS) {
3197                        e = new RuntimeException();
3198                        e.fillInStackTrace();
3199                    }
3200                    Slog.v(TAG, "Loaded animation " + a + " for " + atoken, e);
3201                }
3202                atoken.mAppAnimator.setAnimation(a, width, height);
3203            }
3204        } else {
3205            atoken.mAppAnimator.clearAnimation();
3206        }
3207
3208        return atoken.mAppAnimator.animation != null;
3209    }
3210
3211    // -------------------------------------------------------------
3212    // Application Window Tokens
3213    // -------------------------------------------------------------
3214
3215    public void validateAppTokens(int stackId, List<TaskGroup> tasks) {
3216        synchronized (mWindowMap) {
3217            int t = tasks.size() - 1;
3218            if (t < 0) {
3219                Slog.w(TAG, "validateAppTokens: empty task list");
3220                return;
3221            }
3222
3223            TaskGroup task = tasks.get(0);
3224            int taskId = task.taskId;
3225            Task targetTask = mTaskIdToTask.get(taskId);
3226            DisplayContent displayContent = targetTask.getDisplayContent();
3227            if (displayContent == null) {
3228                Slog.w(TAG, "validateAppTokens: no Display for taskId=" + taskId);
3229                return;
3230            }
3231
3232            final ArrayList<Task> localTasks = mStackIdToStack.get(stackId).getTasks();
3233            int taskNdx;
3234            for (taskNdx = localTasks.size() - 1; taskNdx >= 0 && t >= 0; --taskNdx, --t) {
3235                AppTokenList localTokens = localTasks.get(taskNdx).mAppTokens;
3236                task = tasks.get(t);
3237                List<IApplicationToken> tokens = task.tokens;
3238
3239                DisplayContent lastDisplayContent = displayContent;
3240                displayContent = mTaskIdToTask.get(taskId).getDisplayContent();
3241                if (displayContent != lastDisplayContent) {
3242                    Slog.w(TAG, "validateAppTokens: displayContent changed in TaskGroup list!");
3243                    return;
3244                }
3245
3246                int tokenNdx;
3247                int v;
3248                for (tokenNdx = localTokens.size() - 1, v = task.tokens.size() - 1;
3249                        tokenNdx >= 0 && v >= 0; ) {
3250                    final AppWindowToken atoken = localTokens.get(tokenNdx);
3251                    if (atoken.removed) {
3252                        --tokenNdx;
3253                        continue;
3254                    }
3255                    if (tokens.get(v) != atoken.token) {
3256                        break;
3257                    }
3258                    --tokenNdx;
3259                    v--;
3260                }
3261
3262                if (tokenNdx >= 0 || v >= 0) {
3263                    break;
3264                }
3265            }
3266
3267            if (taskNdx >= 0 || t >= 0) {
3268                Slog.w(TAG, "validateAppTokens: Mismatch! ActivityManager=" + tasks);
3269                Slog.w(TAG, "validateAppTokens: Mismatch! WindowManager=" + localTasks);
3270                Slog.w(TAG, "validateAppTokens: Mismatch! Callers=" + Debug.getCallers(4));
3271            }
3272        }
3273    }
3274
3275    public void validateStackOrder(Integer[] remoteStackIds) {
3276        // TODO:
3277    }
3278
3279    boolean checkCallingPermission(String permission, String func) {
3280        // Quick check: if the calling permission is me, it's all okay.
3281        if (Binder.getCallingPid() == Process.myPid()) {
3282            return true;
3283        }
3284
3285        if (mContext.checkCallingPermission(permission)
3286                == PackageManager.PERMISSION_GRANTED) {
3287            return true;
3288        }
3289        String msg = "Permission Denial: " + func + " from pid="
3290                + Binder.getCallingPid()
3291                + ", uid=" + Binder.getCallingUid()
3292                + " requires " + permission;
3293        Slog.w(TAG, msg);
3294        return false;
3295    }
3296
3297    boolean okToDisplay() {
3298        return !mDisplayFrozen && mDisplayEnabled && mPolicy.isScreenOnFully();
3299    }
3300
3301    AppWindowToken findAppWindowToken(IBinder token) {
3302        WindowToken wtoken = mTokenMap.get(token);
3303        if (wtoken == null) {
3304            return null;
3305        }
3306        return wtoken.appWindowToken;
3307    }
3308
3309    @Override
3310    public void addWindowToken(IBinder token, int type) {
3311        if (!checkCallingPermission(android.Manifest.permission.MANAGE_APP_TOKENS,
3312                "addWindowToken()")) {
3313            throw new SecurityException("Requires MANAGE_APP_TOKENS permission");
3314        }
3315
3316        synchronized(mWindowMap) {
3317            WindowToken wtoken = mTokenMap.get(token);
3318            if (wtoken != null) {
3319                Slog.w(TAG, "Attempted to add existing input method token: " + token);
3320                return;
3321            }
3322            wtoken = new WindowToken(this, token, type, true);
3323            mTokenMap.put(token, wtoken);
3324            if (type == TYPE_WALLPAPER) {
3325                mWallpaperTokens.add(wtoken);
3326            }
3327        }
3328    }
3329
3330    @Override
3331    public void removeWindowToken(IBinder token) {
3332        if (!checkCallingPermission(android.Manifest.permission.MANAGE_APP_TOKENS,
3333                "removeWindowToken()")) {
3334            throw new SecurityException("Requires MANAGE_APP_TOKENS permission");
3335        }
3336
3337        final long origId = Binder.clearCallingIdentity();
3338        synchronized(mWindowMap) {
3339            DisplayContent displayContent = null;
3340            WindowToken wtoken = mTokenMap.remove(token);
3341            if (wtoken != null) {
3342                boolean delayed = false;
3343                if (!wtoken.hidden) {
3344                    final int N = wtoken.windows.size();
3345                    boolean changed = false;
3346
3347                    for (int i=0; i<N; i++) {
3348                        WindowState win = wtoken.windows.get(i);
3349                        displayContent = win.mDisplayContent;
3350
3351                        if (win.mWinAnimator.isAnimating()) {
3352                            delayed = true;
3353                        }
3354
3355                        if (win.isVisibleNow()) {
3356                            win.mWinAnimator.applyAnimationLocked(WindowManagerPolicy.TRANSIT_EXIT,
3357                                    false);
3358                            //TODO (multidisplay): Magnification is supported only for the default
3359                            if (mDisplayMagnifier != null && win.isDefaultDisplay()) {
3360                                mDisplayMagnifier.onWindowTransitionLocked(win,
3361                                        WindowManagerPolicy.TRANSIT_EXIT);
3362                            }
3363                            changed = true;
3364                            displayContent.layoutNeeded = true;
3365                        }
3366                    }
3367
3368                    wtoken.hidden = true;
3369
3370                    if (changed) {
3371                        performLayoutAndPlaceSurfacesLocked();
3372                        updateFocusedWindowLocked(UPDATE_FOCUS_NORMAL,
3373                                false /*updateInputWindows*/);
3374                    }
3375
3376                    if (delayed) {
3377                        displayContent.mExitingTokens.add(wtoken);
3378                    } else if (wtoken.windowType == TYPE_WALLPAPER) {
3379                        mWallpaperTokens.remove(wtoken);
3380                    }
3381                }
3382
3383                mInputMonitor.updateInputWindowsLw(true /*force*/);
3384            } else {
3385                Slog.w(TAG, "Attempted to remove non-existing token: " + token);
3386            }
3387        }
3388        Binder.restoreCallingIdentity(origId);
3389    }
3390
3391    private Task createTask(int taskId, int stackId, int userId, AppWindowToken atoken) {
3392        final TaskStack stack = mStackIdToStack.get(stackId);
3393        if (stack == null) {
3394            throw new IllegalArgumentException("addAppToken: invalid stackId=" + stackId);
3395        }
3396        EventLog.writeEvent(EventLogTags.WM_TASK_CREATED, taskId, stackId);
3397        Task task = new Task(atoken, stack, userId);
3398        mTaskIdToTask.put(taskId, task);
3399        stack.addTask(task, true);
3400        return task;
3401    }
3402
3403    @Override
3404    public void addAppToken(int addPos, IApplicationToken token, int taskId, int stackId,
3405            int requestedOrientation, boolean fullscreen, boolean showWhenLocked, int userId,
3406            int configChanges) {
3407        if (!checkCallingPermission(android.Manifest.permission.MANAGE_APP_TOKENS,
3408                "addAppToken()")) {
3409            throw new SecurityException("Requires MANAGE_APP_TOKENS permission");
3410        }
3411
3412        // Get the dispatching timeout here while we are not holding any locks so that it
3413        // can be cached by the AppWindowToken.  The timeout value is used later by the
3414        // input dispatcher in code that does hold locks.  If we did not cache the value
3415        // here we would run the chance of introducing a deadlock between the window manager
3416        // (which holds locks while updating the input dispatcher state) and the activity manager
3417        // (which holds locks while querying the application token).
3418        long inputDispatchingTimeoutNanos;
3419        try {
3420            inputDispatchingTimeoutNanos = token.getKeyDispatchingTimeout() * 1000000L;
3421        } catch (RemoteException ex) {
3422            Slog.w(TAG, "Could not get dispatching timeout.", ex);
3423            inputDispatchingTimeoutNanos = DEFAULT_INPUT_DISPATCHING_TIMEOUT_NANOS;
3424        }
3425
3426        synchronized(mWindowMap) {
3427            AppWindowToken atoken = findAppWindowToken(token.asBinder());
3428            if (atoken != null) {
3429                Slog.w(TAG, "Attempted to add existing app token: " + token);
3430                return;
3431            }
3432            atoken = new AppWindowToken(this, token);
3433            atoken.inputDispatchingTimeoutNanos = inputDispatchingTimeoutNanos;
3434            atoken.groupId = taskId;
3435            atoken.appFullscreen = fullscreen;
3436            atoken.showWhenLocked = showWhenLocked;
3437            atoken.requestedOrientation = requestedOrientation;
3438            atoken.layoutConfigChanges = (configChanges &
3439                    (ActivityInfo.CONFIG_SCREEN_SIZE | ActivityInfo.CONFIG_ORIENTATION)) != 0;
3440            if (DEBUG_TOKEN_MOVEMENT || DEBUG_ADD_REMOVE) Slog.v(TAG, "addAppToken: " + atoken
3441                    + " to stack=" + stackId + " task=" + taskId + " at " + addPos);
3442
3443            Task task = mTaskIdToTask.get(taskId);
3444            if (task == null) {
3445                task = createTask(taskId, stackId, userId, atoken);
3446            } else {
3447                task.addAppToken(addPos, atoken);
3448            }
3449
3450            mTokenMap.put(token.asBinder(), atoken);
3451
3452            // Application tokens start out hidden.
3453            atoken.hidden = true;
3454            atoken.hiddenRequested = true;
3455
3456            //dump();
3457        }
3458    }
3459
3460    @Override
3461    public void setAppGroupId(IBinder token, int groupId) {
3462        if (!checkCallingPermission(android.Manifest.permission.MANAGE_APP_TOKENS,
3463                "setAppGroupId()")) {
3464            throw new SecurityException("Requires MANAGE_APP_TOKENS permission");
3465        }
3466
3467        synchronized(mWindowMap) {
3468            final AppWindowToken atoken = findAppWindowToken(token);
3469            if (atoken == null) {
3470                Slog.w(TAG, "Attempted to set group id of non-existing app token: " + token);
3471                return;
3472            }
3473            Task oldTask = mTaskIdToTask.get(atoken.groupId);
3474            oldTask.removeAppToken(atoken);
3475
3476            atoken.groupId = groupId;
3477            Task newTask = mTaskIdToTask.get(groupId);
3478            if (newTask == null) {
3479                newTask = createTask(groupId, oldTask.mStack.mStackId, oldTask.mUserId, atoken);
3480            }
3481            newTask.mAppTokens.add(atoken);
3482        }
3483    }
3484
3485    public int getOrientationFromWindowsLocked() {
3486        if (mDisplayFrozen || mOpeningApps.size() > 0 || mClosingApps.size() > 0) {
3487            // If the display is frozen, some activities may be in the middle
3488            // of restarting, and thus have removed their old window.  If the
3489            // window has the flag to hide the lock screen, then the lock screen
3490            // can re-appear and inflict its own orientation on us.  Keep the
3491            // orientation stable until this all settles down.
3492            return mLastWindowForcedOrientation;
3493        }
3494
3495        // TODO(multidisplay): Change to the correct display.
3496        final WindowList windows = getDefaultWindowListLocked();
3497        int pos = windows.size() - 1;
3498        while (pos >= 0) {
3499            WindowState win = windows.get(pos);
3500            pos--;
3501            if (win.mAppToken != null) {
3502                // We hit an application window. so the orientation will be determined by the
3503                // app window. No point in continuing further.
3504                return (mLastWindowForcedOrientation=ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED);
3505            }
3506            if (!win.isVisibleLw() || !win.mPolicyVisibilityAfterAnim) {
3507                continue;
3508            }
3509            int req = win.mAttrs.screenOrientation;
3510            if((req == ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED) ||
3511                    (req == ActivityInfo.SCREEN_ORIENTATION_BEHIND)){
3512                continue;
3513            }
3514
3515            if (DEBUG_ORIENTATION) Slog.v(TAG, win + " forcing orientation to " + req);
3516            return (mLastWindowForcedOrientation=req);
3517        }
3518        return (mLastWindowForcedOrientation=ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED);
3519    }
3520
3521    public int getOrientationFromAppTokensLocked() {
3522        int lastOrientation = ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED;
3523        boolean findingBehind = false;
3524        boolean lastFullscreen = false;
3525        // TODO: Multi window.
3526        DisplayContent displayContent = getDefaultDisplayContentLocked();
3527        final ArrayList<Task> tasks = displayContent.getTasks();
3528        for (int taskNdx = tasks.size() - 1; taskNdx >= 0; --taskNdx) {
3529            AppTokenList tokens = tasks.get(taskNdx).mAppTokens;
3530            final int firstToken = tokens.size() - 1;
3531            for (int tokenNdx = firstToken; tokenNdx >= 0; --tokenNdx) {
3532                final AppWindowToken atoken = tokens.get(tokenNdx);
3533
3534                if (DEBUG_APP_ORIENTATION) Slog.v(TAG, "Checking app orientation: " + atoken);
3535
3536                // if we're about to tear down this window and not seek for
3537                // the behind activity, don't use it for orientation
3538                if (!findingBehind
3539                        && (!atoken.hidden && atoken.hiddenRequested)) {
3540                    if (DEBUG_ORIENTATION) Slog.v(TAG, "Skipping " + atoken
3541                            + " -- going to hide");
3542                    continue;
3543                }
3544
3545                if (tokenNdx == firstToken) {
3546                    // If we have hit a new Task, and the bottom
3547                    // of the previous group didn't explicitly say to use
3548                    // the orientation behind it, and the last app was
3549                    // full screen, then we'll stick with the
3550                    // user's orientation.
3551                    if (lastOrientation != ActivityInfo.SCREEN_ORIENTATION_BEHIND
3552                            && lastFullscreen) {
3553                        if (DEBUG_ORIENTATION) Slog.v(TAG, "Done at " + atoken
3554                                + " -- end of group, return " + lastOrientation);
3555                        return lastOrientation;
3556                    }
3557                }
3558
3559                // We ignore any hidden applications on the top.
3560                if (atoken.hiddenRequested || atoken.willBeHidden) {
3561                    if (DEBUG_ORIENTATION) Slog.v(TAG, "Skipping " + atoken
3562                            + " -- hidden on top");
3563                    continue;
3564                }
3565
3566                if (tokenNdx == 0) {
3567                    // Last token in this task.
3568                    lastOrientation = atoken.requestedOrientation;
3569                }
3570
3571                int or = atoken.requestedOrientation;
3572                // If this application is fullscreen, and didn't explicitly say
3573                // to use the orientation behind it, then just take whatever
3574                // orientation it has and ignores whatever is under it.
3575                lastFullscreen = atoken.appFullscreen;
3576                if (lastFullscreen
3577                        && or != ActivityInfo.SCREEN_ORIENTATION_BEHIND) {
3578                    if (DEBUG_ORIENTATION) Slog.v(TAG, "Done at " + atoken
3579                            + " -- full screen, return " + or);
3580                    return or;
3581                }
3582                // If this application has requested an explicit orientation,
3583                // then use it.
3584                if (or != ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED
3585                        && or != ActivityInfo.SCREEN_ORIENTATION_BEHIND) {
3586                    if (DEBUG_ORIENTATION) Slog.v(TAG, "Done at " + atoken
3587                            + " -- explicitly set, return " + or);
3588                    return or;
3589                }
3590                findingBehind |= (or == ActivityInfo.SCREEN_ORIENTATION_BEHIND);
3591            }
3592        }
3593        if (DEBUG_ORIENTATION) Slog.v(TAG, "No app is requesting an orientation");
3594        return ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED;
3595    }
3596
3597    @Override
3598    public Configuration updateOrientationFromAppTokens(
3599            Configuration currentConfig, IBinder freezeThisOneIfNeeded) {
3600        if (!checkCallingPermission(android.Manifest.permission.MANAGE_APP_TOKENS,
3601                "updateOrientationFromAppTokens()")) {
3602            throw new SecurityException("Requires MANAGE_APP_TOKENS permission");
3603        }
3604
3605        Configuration config = null;
3606        long ident = Binder.clearCallingIdentity();
3607
3608        synchronized(mWindowMap) {
3609            config = updateOrientationFromAppTokensLocked(currentConfig,
3610                    freezeThisOneIfNeeded);
3611        }
3612
3613        Binder.restoreCallingIdentity(ident);
3614        return config;
3615    }
3616
3617    private Configuration updateOrientationFromAppTokensLocked(
3618            Configuration currentConfig, IBinder freezeThisOneIfNeeded) {
3619        Configuration config = null;
3620
3621        if (updateOrientationFromAppTokensLocked(false)) {
3622            if (freezeThisOneIfNeeded != null) {
3623                AppWindowToken atoken = findAppWindowToken(freezeThisOneIfNeeded);
3624                if (atoken != null) {
3625                    startAppFreezingScreenLocked(atoken, ActivityInfo.CONFIG_ORIENTATION);
3626                }
3627            }
3628            config = computeNewConfigurationLocked();
3629
3630        } else if (currentConfig != null) {
3631            // No obvious action we need to take, but if our current
3632            // state mismatches the activity manager's, update it,
3633            // disregarding font scale, which should remain set to
3634            // the value of the previous configuration.
3635            mTempConfiguration.setToDefaults();
3636            mTempConfiguration.fontScale = currentConfig.fontScale;
3637            if (computeScreenConfigurationLocked(mTempConfiguration)) {
3638                if (currentConfig.diff(mTempConfiguration) != 0) {
3639                    mWaitingForConfig = true;
3640                    final DisplayContent displayContent = getDefaultDisplayContentLocked();
3641                    displayContent.layoutNeeded = true;
3642                    int anim[] = new int[2];
3643                    if (displayContent.isDimming()) {
3644                        anim[0] = anim[1] = 0;
3645                    } else {
3646                        mPolicy.selectRotationAnimationLw(anim);
3647                    }
3648                    startFreezingDisplayLocked(false, anim[0], anim[1]);
3649                    config = new Configuration(mTempConfiguration);
3650                }
3651            }
3652        }
3653
3654        return config;
3655    }
3656
3657    /*
3658     * Determine the new desired orientation of the display, returning
3659     * a non-null new Configuration if it has changed from the current
3660     * orientation.  IF TRUE IS RETURNED SOMEONE MUST CALL
3661     * setNewConfiguration() TO TELL THE WINDOW MANAGER IT CAN UNFREEZE THE
3662     * SCREEN.  This will typically be done for you if you call
3663     * sendNewConfiguration().
3664     *
3665     * The orientation is computed from non-application windows first. If none of
3666     * the non-application windows specify orientation, the orientation is computed from
3667     * application tokens.
3668     * @see android.view.IWindowManager#updateOrientationFromAppTokens(
3669     * android.os.IBinder)
3670     */
3671    boolean updateOrientationFromAppTokensLocked(boolean inTransaction) {
3672        long ident = Binder.clearCallingIdentity();
3673        try {
3674            int req = getOrientationFromWindowsLocked();
3675            if (req == ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED) {
3676                req = getOrientationFromAppTokensLocked();
3677            }
3678
3679            if (req != mForcedAppOrientation) {
3680                mForcedAppOrientation = req;
3681                //send a message to Policy indicating orientation change to take
3682                //action like disabling/enabling sensors etc.,
3683                mPolicy.setCurrentOrientationLw(req);
3684                if (updateRotationUncheckedLocked(inTransaction)) {
3685                    // changed
3686                    return true;
3687                }
3688            }
3689
3690            return false;
3691        } finally {
3692            Binder.restoreCallingIdentity(ident);
3693        }
3694    }
3695
3696    @Override
3697    public void setNewConfiguration(Configuration config) {
3698        if (!checkCallingPermission(android.Manifest.permission.MANAGE_APP_TOKENS,
3699                "setNewConfiguration()")) {
3700            throw new SecurityException("Requires MANAGE_APP_TOKENS permission");
3701        }
3702
3703        synchronized(mWindowMap) {
3704            mCurConfiguration = new Configuration(config);
3705            if (mWaitingForConfig) {
3706                mWaitingForConfig = false;
3707                mLastFinishedFreezeSource = "new-config";
3708            }
3709            performLayoutAndPlaceSurfacesLocked();
3710        }
3711    }
3712
3713    @Override
3714    public void setAppOrientation(IApplicationToken token, int requestedOrientation) {
3715        if (!checkCallingPermission(android.Manifest.permission.MANAGE_APP_TOKENS,
3716                "setAppOrientation()")) {
3717            throw new SecurityException("Requires MANAGE_APP_TOKENS permission");
3718        }
3719
3720        synchronized(mWindowMap) {
3721            AppWindowToken atoken = findAppWindowToken(token.asBinder());
3722            if (atoken == null) {
3723                Slog.w(TAG, "Attempted to set orientation of non-existing app token: " + token);
3724                return;
3725            }
3726
3727            atoken.requestedOrientation = requestedOrientation;
3728        }
3729    }
3730
3731    @Override
3732    public int getAppOrientation(IApplicationToken token) {
3733        synchronized(mWindowMap) {
3734            AppWindowToken wtoken = findAppWindowToken(token.asBinder());
3735            if (wtoken == null) {
3736                return ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED;
3737            }
3738
3739            return wtoken.requestedOrientation;
3740        }
3741    }
3742
3743    /** Call while in a Surface transaction. */
3744    void setFocusedStackLayer() {
3745        mFocusedStackLayer = 0;
3746        if (mFocusedApp != null) {
3747            final WindowList windows = mFocusedApp.allAppWindows;
3748            for (int i = windows.size() - 1; i >= 0; --i) {
3749                final WindowState win = windows.get(i);
3750                final int animLayer = win.mWinAnimator.mAnimLayer;
3751                if (win.mAttachedWindow == null && win.isVisibleLw() &&
3752                        animLayer > mFocusedStackLayer) {
3753                    mFocusedStackLayer = animLayer + LAYER_OFFSET_FOCUSED_STACK;
3754                }
3755            }
3756        }
3757        if (DEBUG_LAYERS) Slog.v(TAG, "Setting FocusedStackFrame to layer=" +
3758                mFocusedStackLayer);
3759        mFocusedStackFrame.setLayer(mFocusedStackLayer);
3760    }
3761
3762    void setFocusedStackFrame() {
3763        final TaskStack stack;
3764        if (mFocusedApp != null) {
3765            Task task = mTaskIdToTask.get(mFocusedApp.groupId);
3766            stack = task.mStack;
3767            task.getDisplayContent().setTouchExcludeRegion(stack);
3768        } else {
3769            stack = null;
3770        }
3771        if (SHOW_LIGHT_TRANSACTIONS) Slog.i(TAG, ">>> OPEN TRANSACTION setFocusedStackFrame");
3772        SurfaceControl.openTransaction();
3773        try {
3774            if (stack == null) {
3775                mFocusedStackFrame.setVisibility(false);
3776            } else {
3777                mFocusedStackFrame.setBounds(stack);
3778                final boolean multipleStacks = !stack.isFullscreen();
3779                mFocusedStackFrame.setVisibility(multipleStacks);
3780            }
3781        } finally {
3782            SurfaceControl.closeTransaction();
3783            if (SHOW_LIGHT_TRANSACTIONS) Slog.i(TAG, ">>> CLOSE TRANSACTION setFocusedStackFrame");
3784        }
3785    }
3786
3787    @Override
3788    public void setFocusedApp(IBinder token, boolean moveFocusNow) {
3789        if (!checkCallingPermission(android.Manifest.permission.MANAGE_APP_TOKENS,
3790                "setFocusedApp()")) {
3791            throw new SecurityException("Requires MANAGE_APP_TOKENS permission");
3792        }
3793
3794        synchronized(mWindowMap) {
3795            boolean changed = false;
3796            if (token == null) {
3797                if (DEBUG_FOCUS_LIGHT) Slog.v(TAG, "Clearing focused app, was " + mFocusedApp);
3798                changed = mFocusedApp != null;
3799                mFocusedApp = null;
3800                if (changed) {
3801                    mInputMonitor.setFocusedAppLw(null);
3802                }
3803            } else {
3804                AppWindowToken newFocus = findAppWindowToken(token);
3805                if (newFocus == null) {
3806                    Slog.w(TAG, "Attempted to set focus to non-existing app token: " + token);
3807                    return;
3808                }
3809                changed = mFocusedApp != newFocus;
3810                if (DEBUG_FOCUS_LIGHT) Slog.v(TAG, "Set focused app to: " + newFocus
3811                        + " old focus=" + mFocusedApp + " moveFocusNow=" + moveFocusNow);
3812                mFocusedApp = newFocus;
3813                if (changed) {
3814                    mInputMonitor.setFocusedAppLw(newFocus);
3815                }
3816            }
3817
3818            if (moveFocusNow && changed) {
3819                final long origId = Binder.clearCallingIdentity();
3820                updateFocusedWindowLocked(UPDATE_FOCUS_NORMAL, true /*updateInputWindows*/);
3821                Binder.restoreCallingIdentity(origId);
3822            }
3823        }
3824    }
3825
3826    @Override
3827    public void prepareAppTransition(int transit, boolean alwaysKeepCurrent) {
3828        if (!checkCallingPermission(android.Manifest.permission.MANAGE_APP_TOKENS,
3829                "prepareAppTransition()")) {
3830            throw new SecurityException("Requires MANAGE_APP_TOKENS permission");
3831        }
3832
3833        synchronized(mWindowMap) {
3834            if (DEBUG_APP_TRANSITIONS) Slog.v(
3835                    TAG, "Prepare app transition: transit=" + transit
3836                    + " " + mAppTransition
3837                    + " alwaysKeepCurrent=" + alwaysKeepCurrent
3838                    + " Callers=" + Debug.getCallers(3));
3839            if (okToDisplay()) {
3840                if (!mAppTransition.isTransitionSet() || mAppTransition.isTransitionNone()) {
3841                    mAppTransition.setAppTransition(transit);
3842                } else if (!alwaysKeepCurrent) {
3843                    if (transit == AppTransition.TRANSIT_TASK_OPEN
3844                            && mAppTransition.isTransitionEqual(
3845                                    AppTransition.TRANSIT_TASK_CLOSE)) {
3846                        // Opening a new task always supersedes a close for the anim.
3847                        mAppTransition.setAppTransition(transit);
3848                    } else if (transit == AppTransition.TRANSIT_ACTIVITY_OPEN
3849                            && mAppTransition.isTransitionEqual(
3850                                AppTransition.TRANSIT_ACTIVITY_CLOSE)) {
3851                        // Opening a new activity always supersedes a close for the anim.
3852                        mAppTransition.setAppTransition(transit);
3853                    }
3854                }
3855                mAppTransition.prepare();
3856                mStartingIconInTransition = false;
3857                mSkipAppTransitionAnimation = false;
3858                mH.removeMessages(H.APP_TRANSITION_TIMEOUT);
3859                mH.sendEmptyMessageDelayed(H.APP_TRANSITION_TIMEOUT, 5000);
3860            }
3861        }
3862    }
3863
3864    @Override
3865    public int getPendingAppTransition() {
3866        return mAppTransition.getAppTransition();
3867    }
3868
3869    @Override
3870    public void overridePendingAppTransition(String packageName,
3871            int enterAnim, int exitAnim, IRemoteCallback startedCallback) {
3872        synchronized(mWindowMap) {
3873            mAppTransition.overridePendingAppTransition(packageName, enterAnim, exitAnim,
3874                    startedCallback);
3875        }
3876    }
3877
3878    @Override
3879    public void overridePendingAppTransitionScaleUp(int startX, int startY, int startWidth,
3880            int startHeight) {
3881        synchronized(mWindowMap) {
3882            mAppTransition.overridePendingAppTransitionScaleUp(startX, startY, startWidth,
3883                    startHeight);
3884        }
3885    }
3886
3887    @Override
3888    public void overridePendingAppTransitionThumb(Bitmap srcThumb, int startX,
3889            int startY, IRemoteCallback startedCallback, boolean scaleUp) {
3890        synchronized(mWindowMap) {
3891            mAppTransition.overridePendingAppTransitionThumb(srcThumb, startX, startY,
3892                    startedCallback, scaleUp);
3893        }
3894    }
3895
3896    @Override
3897    public void executeAppTransition() {
3898        if (!checkCallingPermission(android.Manifest.permission.MANAGE_APP_TOKENS,
3899                "executeAppTransition()")) {
3900            throw new SecurityException("Requires MANAGE_APP_TOKENS permission");
3901        }
3902
3903        synchronized(mWindowMap) {
3904            if (DEBUG_APP_TRANSITIONS) {
3905                RuntimeException e = new RuntimeException("here");
3906                e.fillInStackTrace();
3907                Slog.w(TAG, "Execute app transition: " + mAppTransition, e);
3908            }
3909            if (mAppTransition.isTransitionSet()) {
3910                mAppTransition.setReady();
3911                final long origId = Binder.clearCallingIdentity();
3912                performLayoutAndPlaceSurfacesLocked();
3913                Binder.restoreCallingIdentity(origId);
3914            }
3915        }
3916    }
3917
3918    @Override
3919    public void setAppStartingWindow(IBinder token, String pkg,
3920            int theme, CompatibilityInfo compatInfo,
3921            CharSequence nonLocalizedLabel, int labelRes, int icon, int logo,
3922            int windowFlags, IBinder transferFrom, boolean createIfNeeded) {
3923        if (!checkCallingPermission(android.Manifest.permission.MANAGE_APP_TOKENS,
3924                "setAppStartingWindow()")) {
3925            throw new SecurityException("Requires MANAGE_APP_TOKENS permission");
3926        }
3927
3928        synchronized(mWindowMap) {
3929            if (DEBUG_STARTING_WINDOW) Slog.v(
3930                    TAG, "setAppStartingWindow: token=" + token + " pkg=" + pkg
3931                    + " transferFrom=" + transferFrom);
3932
3933            AppWindowToken wtoken = findAppWindowToken(token);
3934            if (wtoken == null) {
3935                Slog.w(TAG, "Attempted to set icon of non-existing app token: " + token);
3936                return;
3937            }
3938
3939            // If the display is frozen, we won't do anything until the
3940            // actual window is displayed so there is no reason to put in
3941            // the starting window.
3942            if (!okToDisplay()) {
3943                return;
3944            }
3945
3946            if (wtoken.startingData != null) {
3947                return;
3948            }
3949
3950            if (transferFrom != null) {
3951                AppWindowToken ttoken = findAppWindowToken(transferFrom);
3952                if (ttoken != null) {
3953                    WindowState startingWindow = ttoken.startingWindow;
3954                    if (startingWindow != null) {
3955                        if (mStartingIconInTransition) {
3956                            // In this case, the starting icon has already
3957                            // been displayed, so start letting windows get
3958                            // shown immediately without any more transitions.
3959                            mSkipAppTransitionAnimation = true;
3960                        }
3961                        if (DEBUG_STARTING_WINDOW) Slog.v(TAG,
3962                                "Moving existing starting " + startingWindow + " from " + ttoken
3963                                + " to " + wtoken);
3964                        final long origId = Binder.clearCallingIdentity();
3965
3966                        // Transfer the starting window over to the new
3967                        // token.
3968                        wtoken.startingData = ttoken.startingData;
3969                        wtoken.startingView = ttoken.startingView;
3970                        wtoken.startingDisplayed = ttoken.startingDisplayed;
3971                        ttoken.startingDisplayed = false;
3972                        wtoken.startingWindow = startingWindow;
3973                        wtoken.reportedVisible = ttoken.reportedVisible;
3974                        ttoken.startingData = null;
3975                        ttoken.startingView = null;
3976                        ttoken.startingWindow = null;
3977                        ttoken.startingMoved = true;
3978                        startingWindow.mToken = wtoken;
3979                        startingWindow.mRootToken = wtoken;
3980                        startingWindow.mAppToken = wtoken;
3981                        startingWindow.mWinAnimator.mAppAnimator = wtoken.mAppAnimator;
3982
3983                        if (DEBUG_WINDOW_MOVEMENT || DEBUG_ADD_REMOVE || DEBUG_STARTING_WINDOW) {
3984                            Slog.v(TAG, "Removing starting window: " + startingWindow);
3985                        }
3986                        removeStartingWindowTimeout(ttoken);
3987                        startingWindow.getWindowList().remove(startingWindow);
3988                        mWindowsChanged = true;
3989                        if (DEBUG_ADD_REMOVE) Slog.v(TAG,
3990                                "Removing starting " + startingWindow + " from " + ttoken);
3991                        ttoken.windows.remove(startingWindow);
3992                        ttoken.allAppWindows.remove(startingWindow);
3993                        addWindowToListInOrderLocked(startingWindow, true);
3994
3995                        // Propagate other interesting state between the
3996                        // tokens.  If the old token is displayed, we should
3997                        // immediately force the new one to be displayed.  If
3998                        // it is animating, we need to move that animation to
3999                        // the new one.
4000                        if (ttoken.allDrawn) {
4001                            wtoken.allDrawn = true;
4002                            wtoken.deferClearAllDrawn = ttoken.deferClearAllDrawn;
4003                        }
4004                        if (ttoken.firstWindowDrawn) {
4005                            wtoken.firstWindowDrawn = true;
4006                        }
4007                        if (!ttoken.hidden) {
4008                            wtoken.hidden = false;
4009                            wtoken.hiddenRequested = false;
4010                            wtoken.willBeHidden = false;
4011                        }
4012                        if (wtoken.clientHidden != ttoken.clientHidden) {
4013                            wtoken.clientHidden = ttoken.clientHidden;
4014                            wtoken.sendAppVisibilityToClients();
4015                        }
4016                        final AppWindowAnimator tAppAnimator = ttoken.mAppAnimator;
4017                        final AppWindowAnimator wAppAnimator = wtoken.mAppAnimator;
4018                        if (tAppAnimator.animation != null) {
4019                            wAppAnimator.animation = tAppAnimator.animation;
4020                            wAppAnimator.animating = tAppAnimator.animating;
4021                            wAppAnimator.animLayerAdjustment = tAppAnimator.animLayerAdjustment;
4022                            tAppAnimator.animation = null;
4023                            tAppAnimator.animLayerAdjustment = 0;
4024                            wAppAnimator.updateLayers();
4025                            tAppAnimator.updateLayers();
4026                        }
4027
4028                        updateFocusedWindowLocked(UPDATE_FOCUS_WILL_PLACE_SURFACES,
4029                                true /*updateInputWindows*/);
4030                        getDefaultDisplayContentLocked().layoutNeeded = true;
4031                        performLayoutAndPlaceSurfacesLocked();
4032                        Binder.restoreCallingIdentity(origId);
4033                        return;
4034                    } else if (ttoken.startingData != null) {
4035                        // The previous app was getting ready to show a
4036                        // starting window, but hasn't yet done so.  Steal it!
4037                        if (DEBUG_STARTING_WINDOW) Slog.v(TAG,
4038                                "Moving pending starting from " + ttoken
4039                                + " to " + wtoken);
4040                        wtoken.startingData = ttoken.startingData;
4041                        ttoken.startingData = null;
4042                        ttoken.startingMoved = true;
4043                        Message m = mH.obtainMessage(H.ADD_STARTING, wtoken);
4044                        // Note: we really want to do sendMessageAtFrontOfQueue() because we
4045                        // want to process the message ASAP, before any other queued
4046                        // messages.
4047                        mH.sendMessageAtFrontOfQueue(m);
4048                        return;
4049                    }
4050                    final AppWindowAnimator tAppAnimator = ttoken.mAppAnimator;
4051                    final AppWindowAnimator wAppAnimator = wtoken.mAppAnimator;
4052                    if (tAppAnimator.thumbnail != null) {
4053                        // The old token is animating with a thumbnail, transfer
4054                        // that to the new token.
4055                        if (wAppAnimator.thumbnail != null) {
4056                            wAppAnimator.thumbnail.destroy();
4057                        }
4058                        wAppAnimator.thumbnail = tAppAnimator.thumbnail;
4059                        wAppAnimator.thumbnailX = tAppAnimator.thumbnailX;
4060                        wAppAnimator.thumbnailY = tAppAnimator.thumbnailY;
4061                        wAppAnimator.thumbnailLayer = tAppAnimator.thumbnailLayer;
4062                        wAppAnimator.thumbnailAnimation = tAppAnimator.thumbnailAnimation;
4063                        tAppAnimator.thumbnail = null;
4064                    }
4065                }
4066            }
4067
4068            // There is no existing starting window, and the caller doesn't
4069            // want us to create one, so that's it!
4070            if (!createIfNeeded) {
4071                return;
4072            }
4073
4074            // If this is a translucent window, then don't
4075            // show a starting window -- the current effect (a full-screen
4076            // opaque starting window that fades away to the real contents
4077            // when it is ready) does not work for this.
4078            if (DEBUG_STARTING_WINDOW) Slog.v(TAG, "Checking theme of starting window: 0x"
4079                    + Integer.toHexString(theme));
4080            if (theme != 0) {
4081                AttributeCache.Entry ent = AttributeCache.instance().get(pkg, theme,
4082                        com.android.internal.R.styleable.Window, mCurrentUserId);
4083                if (ent == null) {
4084                    // Whoops!  App doesn't exist.  Um.  Okay.  We'll just
4085                    // pretend like we didn't see that.
4086                    return;
4087                }
4088                if (DEBUG_STARTING_WINDOW) Slog.v(TAG, "Translucent="
4089                        + ent.array.getBoolean(
4090                                com.android.internal.R.styleable.Window_windowIsTranslucent, false)
4091                        + " Floating="
4092                        + ent.array.getBoolean(
4093                                com.android.internal.R.styleable.Window_windowIsFloating, false)
4094                        + " ShowWallpaper="
4095                        + ent.array.getBoolean(
4096                                com.android.internal.R.styleable.Window_windowShowWallpaper, false));
4097                if (ent.array.getBoolean(
4098                        com.android.internal.R.styleable.Window_windowIsTranslucent, false)) {
4099                    return;
4100                }
4101                if (ent.array.getBoolean(
4102                        com.android.internal.R.styleable.Window_windowIsFloating, false)) {
4103                    return;
4104                }
4105                if (ent.array.getBoolean(
4106                        com.android.internal.R.styleable.Window_windowShowWallpaper, false)) {
4107                    if (mWallpaperTarget == null) {
4108                        // If this theme is requesting a wallpaper, and the wallpaper
4109                        // is not curently visible, then this effectively serves as
4110                        // an opaque window and our starting window transition animation
4111                        // can still work.  We just need to make sure the starting window
4112                        // is also showing the wallpaper.
4113                        windowFlags |= FLAG_SHOW_WALLPAPER;
4114                    } else {
4115                        return;
4116                    }
4117                }
4118            }
4119
4120            if (DEBUG_STARTING_WINDOW) Slog.v(TAG, "Creating StartingData");
4121            mStartingIconInTransition = true;
4122            wtoken.startingData = new StartingData(pkg, theme, compatInfo, nonLocalizedLabel,
4123                    labelRes, icon, logo, windowFlags);
4124            Message m = mH.obtainMessage(H.ADD_STARTING, wtoken);
4125            // Note: we really want to do sendMessageAtFrontOfQueue() because we
4126            // want to process the message ASAP, before any other queued
4127            // messages.
4128            if (DEBUG_STARTING_WINDOW) Slog.v(TAG, "Enqueueing ADD_STARTING");
4129            mH.sendMessageAtFrontOfQueue(m);
4130        }
4131    }
4132
4133    @Override
4134    public void setAppWillBeHidden(IBinder token) {
4135        if (!checkCallingPermission(android.Manifest.permission.MANAGE_APP_TOKENS,
4136                "setAppWillBeHidden()")) {
4137            throw new SecurityException("Requires MANAGE_APP_TOKENS permission");
4138        }
4139
4140        AppWindowToken wtoken;
4141
4142        synchronized(mWindowMap) {
4143            wtoken = findAppWindowToken(token);
4144            if (wtoken == null) {
4145                Slog.w(TAG, "Attempted to set will be hidden of non-existing app token: " + token);
4146                return;
4147            }
4148            wtoken.willBeHidden = true;
4149        }
4150    }
4151
4152    public void setAppFullscreen(IBinder token, boolean toOpaque) {
4153        AppWindowToken atoken = findAppWindowToken(token);
4154        if (atoken != null) {
4155            atoken.appFullscreen = toOpaque;
4156            requestTraversal();
4157        }
4158    }
4159
4160    boolean setTokenVisibilityLocked(AppWindowToken wtoken, WindowManager.LayoutParams lp,
4161            boolean visible, int transit, boolean performLayout) {
4162        boolean delayed = false;
4163
4164        if (wtoken.clientHidden == visible) {
4165            wtoken.clientHidden = !visible;
4166            wtoken.sendAppVisibilityToClients();
4167        }
4168
4169        wtoken.willBeHidden = false;
4170        if (wtoken.hidden == visible) {
4171            boolean changed = false;
4172            if (DEBUG_APP_TRANSITIONS) Slog.v(
4173                TAG, "Changing app " + wtoken + " hidden=" + wtoken.hidden
4174                + " performLayout=" + performLayout);
4175
4176            boolean runningAppAnimation = false;
4177
4178            if (transit != AppTransition.TRANSIT_UNSET) {
4179                if (wtoken.mAppAnimator.animation == AppWindowAnimator.sDummyAnimation) {
4180                    wtoken.mAppAnimator.animation = null;
4181                }
4182                if (applyAnimationLocked(wtoken, lp, transit, visible)) {
4183                    delayed = runningAppAnimation = true;
4184                }
4185                WindowState window = wtoken.findMainWindow();
4186                //TODO (multidisplay): Magnification is supported only for the default display.
4187                if (window != null && mDisplayMagnifier != null
4188                        && window.getDisplayId() == Display.DEFAULT_DISPLAY) {
4189                    mDisplayMagnifier.onAppWindowTransitionLocked(window, transit);
4190                }
4191                changed = true;
4192            }
4193
4194            final int N = wtoken.allAppWindows.size();
4195            for (int i=0; i<N; i++) {
4196                WindowState win = wtoken.allAppWindows.get(i);
4197                if (win == wtoken.startingWindow) {
4198                    continue;
4199                }
4200
4201                //Slog.i(TAG, "Window " + win + ": vis=" + win.isVisible());
4202                //win.dump("  ");
4203                if (visible) {
4204                    if (!win.isVisibleNow()) {
4205                        if (!runningAppAnimation) {
4206                            win.mWinAnimator.applyAnimationLocked(
4207                                    WindowManagerPolicy.TRANSIT_ENTER, true);
4208                            //TODO (multidisplay): Magnification is supported only for the default
4209                            if (mDisplayMagnifier != null
4210                                    && win.getDisplayId() == Display.DEFAULT_DISPLAY) {
4211                                mDisplayMagnifier.onWindowTransitionLocked(win,
4212                                        WindowManagerPolicy.TRANSIT_ENTER);
4213                            }
4214                        }
4215                        changed = true;
4216                        win.mDisplayContent.layoutNeeded = true;
4217                    }
4218                } else if (win.isVisibleNow()) {
4219                    if (!runningAppAnimation) {
4220                        win.mWinAnimator.applyAnimationLocked(
4221                                WindowManagerPolicy.TRANSIT_EXIT, false);
4222                        //TODO (multidisplay): Magnification is supported only for the default
4223                        if (mDisplayMagnifier != null
4224                                && win.getDisplayId() == Display.DEFAULT_DISPLAY) {
4225                            mDisplayMagnifier.onWindowTransitionLocked(win,
4226                                    WindowManagerPolicy.TRANSIT_EXIT);
4227                        }
4228                    }
4229                    changed = true;
4230                    win.mDisplayContent.layoutNeeded = true;
4231                }
4232            }
4233
4234            wtoken.hidden = wtoken.hiddenRequested = !visible;
4235            if (!visible) {
4236                unsetAppFreezingScreenLocked(wtoken, true, true);
4237            } else {
4238                // If we are being set visible, and the starting window is
4239                // not yet displayed, then make sure it doesn't get displayed.
4240                WindowState swin = wtoken.startingWindow;
4241                if (swin != null && !swin.isDrawnLw()) {
4242                    swin.mPolicyVisibility = false;
4243                    swin.mPolicyVisibilityAfterAnim = false;
4244                 }
4245            }
4246
4247            if (DEBUG_APP_TRANSITIONS) Slog.v(TAG, "setTokenVisibilityLocked: " + wtoken
4248                      + ": hidden=" + wtoken.hidden + " hiddenRequested="
4249                      + wtoken.hiddenRequested);
4250
4251            if (changed) {
4252                mInputMonitor.setUpdateInputWindowsNeededLw();
4253                if (performLayout) {
4254                    updateFocusedWindowLocked(UPDATE_FOCUS_WILL_PLACE_SURFACES,
4255                            false /*updateInputWindows*/);
4256                    performLayoutAndPlaceSurfacesLocked();
4257                }
4258                mInputMonitor.updateInputWindowsLw(false /*force*/);
4259            }
4260        }
4261
4262        if (wtoken.mAppAnimator.animation != null) {
4263            delayed = true;
4264        }
4265
4266        for (int i = wtoken.allAppWindows.size() - 1; i >= 0 && !delayed; i--) {
4267            if (wtoken.allAppWindows.get(i).mWinAnimator.isWindowAnimating()) {
4268                delayed = true;
4269            }
4270        }
4271
4272        return delayed;
4273    }
4274
4275    @Override
4276    public void setAppVisibility(IBinder token, boolean visible) {
4277        if (!checkCallingPermission(android.Manifest.permission.MANAGE_APP_TOKENS,
4278                "setAppVisibility()")) {
4279            throw new SecurityException("Requires MANAGE_APP_TOKENS permission");
4280        }
4281
4282        AppWindowToken wtoken;
4283
4284        synchronized(mWindowMap) {
4285            wtoken = findAppWindowToken(token);
4286            if (wtoken == null) {
4287                Slog.w(TAG, "Attempted to set visibility of non-existing app token: " + token);
4288                return;
4289            }
4290
4291            if (DEBUG_APP_TRANSITIONS || DEBUG_ORIENTATION) {
4292                RuntimeException e = null;
4293                if (!HIDE_STACK_CRAWLS) {
4294                    e = new RuntimeException();
4295                    e.fillInStackTrace();
4296                }
4297                Slog.v(TAG, "setAppVisibility(" + token + ", visible=" + visible
4298                        + "): " + mAppTransition
4299                        + " hidden=" + wtoken.hidden
4300                        + " hiddenRequested=" + wtoken.hiddenRequested, e);
4301            }
4302
4303            // If we are preparing an app transition, then delay changing
4304            // the visibility of this token until we execute that transition.
4305            if (okToDisplay() && mAppTransition.isTransitionSet()) {
4306                wtoken.hiddenRequested = !visible;
4307
4308                if (!wtoken.startingDisplayed) {
4309                    if (DEBUG_APP_TRANSITIONS) Slog.v(
4310                            TAG, "Setting dummy animation on: " + wtoken);
4311                    wtoken.mAppAnimator.setDummyAnimation();
4312                }
4313                mOpeningApps.remove(wtoken);
4314                mClosingApps.remove(wtoken);
4315                wtoken.waitingToShow = wtoken.waitingToHide = false;
4316                wtoken.inPendingTransaction = true;
4317                if (visible) {
4318                    mOpeningApps.add(wtoken);
4319                    wtoken.startingMoved = false;
4320
4321                    // If the token is currently hidden (should be the
4322                    // common case), then we need to set up to wait for
4323                    // its windows to be ready.
4324                    if (wtoken.hidden) {
4325                        wtoken.allDrawn = false;
4326                        wtoken.deferClearAllDrawn = false;
4327                        wtoken.waitingToShow = true;
4328
4329                        if (wtoken.clientHidden) {
4330                            // In the case where we are making an app visible
4331                            // but holding off for a transition, we still need
4332                            // to tell the client to make its windows visible so
4333                            // they get drawn.  Otherwise, we will wait on
4334                            // performing the transition until all windows have
4335                            // been drawn, they never will be, and we are sad.
4336                            wtoken.clientHidden = false;
4337                            wtoken.sendAppVisibilityToClients();
4338                        }
4339                    }
4340                } else {
4341                    mClosingApps.add(wtoken);
4342
4343                    // If the token is currently visible (should be the
4344                    // common case), then set up to wait for it to be hidden.
4345                    if (!wtoken.hidden) {
4346                        wtoken.waitingToHide = true;
4347                    }
4348                }
4349                return;
4350            }
4351
4352            final long origId = Binder.clearCallingIdentity();
4353            setTokenVisibilityLocked(wtoken, null, visible, AppTransition.TRANSIT_UNSET,
4354                    true);
4355            wtoken.updateReportedVisibilityLocked();
4356            Binder.restoreCallingIdentity(origId);
4357        }
4358    }
4359
4360    void unsetAppFreezingScreenLocked(AppWindowToken wtoken,
4361            boolean unfreezeSurfaceNow, boolean force) {
4362        if (wtoken.mAppAnimator.freezingScreen) {
4363            if (DEBUG_ORIENTATION) Slog.v(TAG, "Clear freezing of " + wtoken
4364                    + " force=" + force);
4365            final int N = wtoken.allAppWindows.size();
4366            boolean unfrozeWindows = false;
4367            for (int i=0; i<N; i++) {
4368                WindowState w = wtoken.allAppWindows.get(i);
4369                if (w.mAppFreezing) {
4370                    w.mAppFreezing = false;
4371                    if (w.mHasSurface && !w.mOrientationChanging) {
4372                        if (DEBUG_ORIENTATION) Slog.v(TAG, "set mOrientationChanging of " + w);
4373                        w.mOrientationChanging = true;
4374                        mInnerFields.mOrientationChangeComplete = false;
4375                    }
4376                    w.mLastFreezeDuration = 0;
4377                    unfrozeWindows = true;
4378                    w.mDisplayContent.layoutNeeded = true;
4379                }
4380            }
4381            if (force || unfrozeWindows) {
4382                if (DEBUG_ORIENTATION) Slog.v(TAG, "No longer freezing: " + wtoken);
4383                wtoken.mAppAnimator.freezingScreen = false;
4384                wtoken.mAppAnimator.lastFreezeDuration = (int)(SystemClock.elapsedRealtime()
4385                        - mDisplayFreezeTime);
4386                mAppsFreezingScreen--;
4387                mLastFinishedFreezeSource = wtoken;
4388            }
4389            if (unfreezeSurfaceNow) {
4390                if (unfrozeWindows) {
4391                    performLayoutAndPlaceSurfacesLocked();
4392                }
4393                stopFreezingDisplayLocked();
4394            }
4395        }
4396    }
4397
4398    public void startAppFreezingScreenLocked(AppWindowToken wtoken,
4399            int configChanges) {
4400        if (DEBUG_ORIENTATION) {
4401            RuntimeException e = null;
4402            if (!HIDE_STACK_CRAWLS) {
4403                e = new RuntimeException();
4404                e.fillInStackTrace();
4405            }
4406            Slog.i(TAG, "Set freezing of " + wtoken.appToken
4407                    + ": hidden=" + wtoken.hidden + " freezing="
4408                    + wtoken.mAppAnimator.freezingScreen, e);
4409        }
4410        if (!wtoken.hiddenRequested) {
4411            if (!wtoken.mAppAnimator.freezingScreen) {
4412                wtoken.mAppAnimator.freezingScreen = true;
4413                wtoken.mAppAnimator.lastFreezeDuration = 0;
4414                mAppsFreezingScreen++;
4415                if (mAppsFreezingScreen == 1) {
4416                    startFreezingDisplayLocked(false, 0, 0);
4417                    mH.removeMessages(H.APP_FREEZE_TIMEOUT);
4418                    mH.sendEmptyMessageDelayed(H.APP_FREEZE_TIMEOUT, 5000);
4419                }
4420            }
4421            final int N = wtoken.allAppWindows.size();
4422            for (int i=0; i<N; i++) {
4423                WindowState w = wtoken.allAppWindows.get(i);
4424                w.mAppFreezing = true;
4425            }
4426        }
4427    }
4428
4429    @Override
4430    public void startAppFreezingScreen(IBinder token, int configChanges) {
4431        if (!checkCallingPermission(android.Manifest.permission.MANAGE_APP_TOKENS,
4432                "setAppFreezingScreen()")) {
4433            throw new SecurityException("Requires MANAGE_APP_TOKENS permission");
4434        }
4435
4436        synchronized(mWindowMap) {
4437            if (configChanges == 0 && okToDisplay()) {
4438                if (DEBUG_ORIENTATION) Slog.v(TAG, "Skipping set freeze of " + token);
4439                return;
4440            }
4441
4442            AppWindowToken wtoken = findAppWindowToken(token);
4443            if (wtoken == null || wtoken.appToken == null) {
4444                Slog.w(TAG, "Attempted to freeze screen with non-existing app token: " + wtoken);
4445                return;
4446            }
4447            final long origId = Binder.clearCallingIdentity();
4448            startAppFreezingScreenLocked(wtoken, configChanges);
4449            Binder.restoreCallingIdentity(origId);
4450        }
4451    }
4452
4453    @Override
4454    public void stopAppFreezingScreen(IBinder token, boolean force) {
4455        if (!checkCallingPermission(android.Manifest.permission.MANAGE_APP_TOKENS,
4456                "setAppFreezingScreen()")) {
4457            throw new SecurityException("Requires MANAGE_APP_TOKENS permission");
4458        }
4459
4460        synchronized(mWindowMap) {
4461            AppWindowToken wtoken = findAppWindowToken(token);
4462            if (wtoken == null || wtoken.appToken == null) {
4463                return;
4464            }
4465            final long origId = Binder.clearCallingIdentity();
4466            if (DEBUG_ORIENTATION) Slog.v(TAG, "Clear freezing of " + token
4467                    + ": hidden=" + wtoken.hidden + " freezing=" + wtoken.mAppAnimator.freezingScreen);
4468            unsetAppFreezingScreenLocked(wtoken, true, force);
4469            Binder.restoreCallingIdentity(origId);
4470        }
4471    }
4472
4473    @Override
4474    public void removeAppToken(IBinder token) {
4475        if (!checkCallingPermission(android.Manifest.permission.MANAGE_APP_TOKENS,
4476                "removeAppToken()")) {
4477            throw new SecurityException("Requires MANAGE_APP_TOKENS permission");
4478        }
4479
4480        AppWindowToken wtoken = null;
4481        AppWindowToken startingToken = null;
4482        boolean delayed = false;
4483
4484        final long origId = Binder.clearCallingIdentity();
4485        synchronized(mWindowMap) {
4486            WindowToken basewtoken = mTokenMap.remove(token);
4487            if (basewtoken != null && (wtoken=basewtoken.appWindowToken) != null) {
4488                if (DEBUG_APP_TRANSITIONS) Slog.v(TAG, "Removing app token: " + wtoken);
4489                delayed = setTokenVisibilityLocked(wtoken, null, false,
4490                        AppTransition.TRANSIT_UNSET, true);
4491                wtoken.inPendingTransaction = false;
4492                mOpeningApps.remove(wtoken);
4493                wtoken.waitingToShow = false;
4494                if (mClosingApps.contains(wtoken)) {
4495                    delayed = true;
4496                } else if (mAppTransition.isTransitionSet()) {
4497                    mClosingApps.add(wtoken);
4498                    wtoken.waitingToHide = true;
4499                    delayed = true;
4500                }
4501                if (DEBUG_APP_TRANSITIONS) Slog.v(
4502                        TAG, "Removing app " + wtoken + " delayed=" + delayed
4503                        + " animation=" + wtoken.mAppAnimator.animation
4504                        + " animating=" + wtoken.mAppAnimator.animating);
4505                final Task task = mTaskIdToTask.get(wtoken.groupId);
4506                DisplayContent displayContent = task.getDisplayContent();
4507                if (delayed) {
4508                    // set the token aside because it has an active animation to be finished
4509                    if (DEBUG_ADD_REMOVE || DEBUG_TOKEN_MOVEMENT) Slog.v(TAG,
4510                            "removeAppToken make exiting: " + wtoken);
4511                    displayContent.mExitingAppTokens.add(wtoken);
4512                } else {
4513                    // Make sure there is no animation running on this token,
4514                    // so any windows associated with it will be removed as
4515                    // soon as their animations are complete
4516                    wtoken.mAppAnimator.clearAnimation();
4517                    wtoken.mAppAnimator.animating = false;
4518                }
4519                if (DEBUG_ADD_REMOVE || DEBUG_TOKEN_MOVEMENT) Slog.v(TAG,
4520                        "removeAppToken: " + wtoken);
4521
4522                if (task.removeAppToken(wtoken)) {
4523                    mTaskIdToTask.delete(wtoken.groupId);
4524                }
4525                wtoken.removed = true;
4526                if (wtoken.startingData != null) {
4527                    startingToken = wtoken;
4528                }
4529                unsetAppFreezingScreenLocked(wtoken, true, true);
4530                if (mFocusedApp == wtoken) {
4531                    if (DEBUG_FOCUS_LIGHT) Slog.v(TAG, "Removing focused app token:" + wtoken);
4532                    mFocusedApp = null;
4533                    updateFocusedWindowLocked(UPDATE_FOCUS_NORMAL, true /*updateInputWindows*/);
4534                    mInputMonitor.setFocusedAppLw(null);
4535                }
4536            } else {
4537                Slog.w(TAG, "Attempted to remove non-existing app token: " + token);
4538            }
4539
4540            if (!delayed && wtoken != null) {
4541                wtoken.updateReportedVisibilityLocked();
4542            }
4543        }
4544        Binder.restoreCallingIdentity(origId);
4545
4546        // Will only remove if startingToken non null.
4547        scheduleRemoveStartingWindow(startingToken);
4548    }
4549
4550    void removeStartingWindowTimeout(AppWindowToken wtoken) {
4551        if (wtoken != null) {
4552            if (DEBUG_STARTING_WINDOW) Slog.v(TAG, Debug.getCallers(1) +
4553                    ": Remove starting window timeout " + wtoken + (wtoken != null ?
4554                    " startingWindow=" + wtoken.startingWindow : ""));
4555            mH.removeMessages(H.REMOVE_STARTING_TIMEOUT, wtoken);
4556        }
4557    }
4558
4559    void scheduleRemoveStartingWindow(AppWindowToken wtoken) {
4560        if (wtoken != null && wtoken.startingWindow != null) {
4561            if (DEBUG_STARTING_WINDOW) Slog.v(TAG, Debug.getCallers(1) +
4562                    ": Schedule remove starting " + wtoken + (wtoken != null ?
4563                    " startingWindow=" + wtoken.startingWindow : ""));
4564            removeStartingWindowTimeout(wtoken);
4565            Message m = mH.obtainMessage(H.REMOVE_STARTING, wtoken);
4566            mH.sendMessage(m);
4567        }
4568    }
4569    private boolean tmpRemoveAppWindowsLocked(WindowToken token) {
4570        final int NW = token.windows.size();
4571        if (NW > 0) {
4572            mWindowsChanged = true;
4573        }
4574        for (int i=0; i<NW; i++) {
4575            WindowState win = token.windows.get(i);
4576            if (DEBUG_WINDOW_MOVEMENT) Slog.v(TAG, "Tmp removing app window " + win);
4577            win.getWindowList().remove(win);
4578            int j = win.mChildWindows.size();
4579            while (j > 0) {
4580                j--;
4581                WindowState cwin = win.mChildWindows.get(j);
4582                if (DEBUG_WINDOW_MOVEMENT) Slog.v(TAG,
4583                        "Tmp removing child window " + cwin);
4584                cwin.getWindowList().remove(cwin);
4585            }
4586        }
4587        return NW > 0;
4588    }
4589
4590    void dumpAppTokensLocked() {
4591        final int numDisplays = mDisplayContents.size();
4592        for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) {
4593            final DisplayContent displayContent = mDisplayContents.valueAt(displayNdx);
4594            Slog.v(TAG, "  Display " + displayContent.getDisplayId());
4595            final ArrayList<Task> tasks = displayContent.getTasks();
4596            int i = displayContent.numTokens();
4597            for (int taskNdx = tasks.size() - 1; taskNdx >= 0; --taskNdx) {
4598                AppTokenList tokens = tasks.get(taskNdx).mAppTokens;
4599                for (int tokenNdx = tokens.size() - 1; tokenNdx >= 0; --tokenNdx) {
4600                    final AppWindowToken wtoken = tokens.get(tokenNdx);
4601                    Slog.v(TAG, "  #" + --i + ": " + wtoken.token);
4602                }
4603            }
4604        }
4605    }
4606
4607    void dumpWindowsLocked() {
4608        int i = 0;
4609        final int numDisplays = mDisplayContents.size();
4610        for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) {
4611            final WindowList windows = mDisplayContents.valueAt(displayNdx).getWindowList();
4612            for (int winNdx = windows.size() - 1; winNdx >= 0; --winNdx) {
4613                Slog.v(TAG, "  #" + i++ + ": " + windows.get(winNdx));
4614            }
4615        }
4616    }
4617
4618    private int findAppWindowInsertionPointLocked(AppWindowToken target) {
4619        final int taskId = target.groupId;
4620        Task targetTask = mTaskIdToTask.get(taskId);
4621        if (targetTask == null) {
4622            Slog.w(TAG, "findAppWindowInsertionPointLocked: no Task for " + target + " taskId="
4623                    + taskId);
4624            return 0;
4625        }
4626        DisplayContent displayContent = targetTask.getDisplayContent();
4627        if (displayContent == null) {
4628            Slog.w(TAG, "findAppWindowInsertionPointLocked: no DisplayContent for " + target);
4629            return 0;
4630        }
4631        final WindowList windows = displayContent.getWindowList();
4632        final int NW = windows.size();
4633
4634        boolean found = false;
4635        final ArrayList<Task> tasks = displayContent.getTasks();
4636        for (int taskNdx = tasks.size() - 1; taskNdx >= 0; --taskNdx) {
4637            final Task task = tasks.get(taskNdx);
4638            if (!found && task.taskId != taskId) {
4639                continue;
4640            }
4641            AppTokenList tokens = task.mAppTokens;
4642            for (int tokenNdx = tokens.size() - 1; tokenNdx >= 0; --tokenNdx) {
4643                final AppWindowToken wtoken = tokens.get(tokenNdx);
4644                if (!found && wtoken == target) {
4645                    found = true;
4646                }
4647                if (found) {
4648                    // Find the first app token below the new position that has
4649                    // a window displayed.
4650                    if (DEBUG_REORDER) Slog.v(TAG, "Looking for lower windows in " + wtoken.token);
4651                    if (wtoken.sendingToBottom) {
4652                        if (DEBUG_REORDER) Slog.v(TAG, "Skipping token -- currently sending to bottom");
4653                        continue;
4654                    }
4655                    for (int i = wtoken.windows.size() - 1; i >= 0; --i) {
4656                        WindowState win = wtoken.windows.get(i);
4657                        for (int j = win.mChildWindows.size() - 1; j >= 0; --j) {
4658                            WindowState cwin = win.mChildWindows.get(j);
4659                            if (cwin.mSubLayer >= 0) {
4660                                for (int pos = NW - 1; pos >= 0; pos--) {
4661                                    if (windows.get(pos) == cwin) {
4662                                        if (DEBUG_REORDER) Slog.v(TAG,
4663                                                "Found child win @" + (pos + 1));
4664                                        return pos + 1;
4665                                    }
4666                                }
4667                            }
4668                        }
4669                        for (int pos = NW - 1; pos >= 0; pos--) {
4670                            if (windows.get(pos) == win) {
4671                                if (DEBUG_REORDER) Slog.v(TAG, "Found win @" + (pos + 1));
4672                                return pos + 1;
4673                            }
4674                        }
4675                    }
4676                }
4677            }
4678        }
4679        // Never put an app window underneath wallpaper.
4680        for (int pos = NW - 1; pos >= 0; pos--) {
4681            if (windows.get(pos).mIsWallpaper) {
4682                if (DEBUG_REORDER) Slog.v(TAG, "Found wallpaper @" + pos);
4683                return pos + 1;
4684            }
4685        }
4686        return 0;
4687    }
4688
4689    private final int reAddWindowLocked(int index, WindowState win) {
4690        final WindowList windows = win.getWindowList();
4691        final int NCW = win.mChildWindows.size();
4692        boolean added = false;
4693        for (int j=0; j<NCW; j++) {
4694            WindowState cwin = win.mChildWindows.get(j);
4695            if (!added && cwin.mSubLayer >= 0) {
4696                if (DEBUG_WINDOW_MOVEMENT) Slog.v(TAG, "Re-adding child window at "
4697                        + index + ": " + cwin);
4698                win.mRebuilding = false;
4699                windows.add(index, win);
4700                index++;
4701                added = true;
4702            }
4703            if (DEBUG_WINDOW_MOVEMENT) Slog.v(TAG, "Re-adding window at "
4704                    + index + ": " + cwin);
4705            cwin.mRebuilding = false;
4706            windows.add(index, cwin);
4707            index++;
4708        }
4709        if (!added) {
4710            if (DEBUG_WINDOW_MOVEMENT) Slog.v(TAG, "Re-adding window at "
4711                    + index + ": " + win);
4712            win.mRebuilding = false;
4713            windows.add(index, win);
4714            index++;
4715        }
4716        mWindowsChanged = true;
4717        return index;
4718    }
4719
4720    private final int reAddAppWindowsLocked(final DisplayContent displayContent, int index,
4721                                            WindowToken token) {
4722        final int NW = token.windows.size();
4723        for (int i=0; i<NW; i++) {
4724            final WindowState win = token.windows.get(i);
4725            if (win.mDisplayContent == displayContent) {
4726                index = reAddWindowLocked(index, win);
4727            }
4728        }
4729        return index;
4730    }
4731
4732    void moveStackWindowsLocked(DisplayContent displayContent) {
4733        // First remove all of the windows from the list.
4734        final ArrayList<Task> tasks = displayContent.getTasks();
4735        final int numTasks = tasks.size();
4736        for (int taskNdx = 0; taskNdx < numTasks; ++taskNdx) {
4737            AppTokenList tokens = tasks.get(taskNdx).mAppTokens;
4738            final int numTokens = tokens.size();
4739            for (int tokenNdx = numTokens - 1; tokenNdx >= 0; --tokenNdx) {
4740                tmpRemoveAppWindowsLocked(tokens.get(tokenNdx));
4741            }
4742        }
4743
4744        // And now add them back at the correct place.
4745        // Where to start adding?
4746        for (int taskNdx = 0; taskNdx < numTasks; ++taskNdx) {
4747            AppTokenList tokens = tasks.get(taskNdx).mAppTokens;
4748            int pos = findAppWindowInsertionPointLocked(tokens.get(0));
4749            final int numTokens = tokens.size();
4750            for (int tokenNdx = 0; tokenNdx < numTokens; ++tokenNdx) {
4751                final AppWindowToken wtoken = tokens.get(tokenNdx);
4752                if (wtoken != null) {
4753                    final int newPos = reAddAppWindowsLocked(displayContent, pos, wtoken);
4754                    if (newPos != pos) {
4755                        displayContent.layoutNeeded = true;
4756                    }
4757                    pos = newPos;
4758                }
4759            }
4760        }
4761
4762        if (!updateFocusedWindowLocked(UPDATE_FOCUS_WILL_PLACE_SURFACES,
4763                false /*updateInputWindows*/)) {
4764            assignLayersLocked(displayContent.getWindowList());
4765        }
4766
4767        mInputMonitor.setUpdateInputWindowsNeededLw();
4768        performLayoutAndPlaceSurfacesLocked();
4769        mInputMonitor.updateInputWindowsLw(false /*force*/);
4770
4771        //dump();
4772    }
4773
4774    public void moveTaskToTop(int taskId) {
4775        final long origId = Binder.clearCallingIdentity();
4776        try {
4777            synchronized(mWindowMap) {
4778                Task task = mTaskIdToTask.get(taskId);
4779                if (task == null) {
4780                    // Normal behavior, addAppToken will be called next and task will be created.
4781                    return;
4782                }
4783                final TaskStack stack = task.mStack;
4784                final DisplayContent displayContent = task.getDisplayContent();
4785                displayContent.moveStack(stack, true);
4786                if (displayContent.isDefaultDisplay) {
4787                    final TaskStack homeStack = displayContent.getHomeStack();
4788                    if (homeStack != stack) {
4789                        // When a non-home stack moves to the top, the home stack moves to the
4790                        // bottom.
4791                        displayContent.moveStack(homeStack, false);
4792                    }
4793                }
4794                stack.moveTaskToTop(task);
4795            }
4796        } finally {
4797            Binder.restoreCallingIdentity(origId);
4798        }
4799    }
4800
4801    public void moveTaskToBottom(int taskId) {
4802        final long origId = Binder.clearCallingIdentity();
4803        try {
4804            synchronized(mWindowMap) {
4805                Task task = mTaskIdToTask.get(taskId);
4806                if (task == null) {
4807                    Slog.e(TAG, "moveTaskToBottom: taskId=" + taskId
4808                            + " not found in mTaskIdToTask");
4809                    return;
4810                }
4811                final TaskStack stack = task.mStack;
4812                stack.moveTaskToBottom(task);
4813                moveStackWindowsLocked(stack.getDisplayContent());
4814            }
4815        } finally {
4816            Binder.restoreCallingIdentity(origId);
4817        }
4818    }
4819
4820    /**
4821     * Create a new TaskStack and place it on a DisplayContent.
4822     * @param stackId The unique identifier of the new stack.
4823     * @param displayId The unique identifier of the DisplayContent.
4824     */
4825    public void createStack(int stackId, int displayId) {
4826        final long origId = Binder.clearCallingIdentity();
4827        try {
4828            synchronized (mWindowMap) {
4829                final DisplayContent displayContent = mDisplayContents.get(displayId);
4830                if (displayContent != null) {
4831                    TaskStack stack = displayContent.createStack(stackId);
4832                    mStackIdToStack.put(stackId, stack);
4833                    performLayoutAndPlaceSurfacesLocked();
4834                }
4835            }
4836        } finally {
4837            Binder.restoreCallingIdentity(origId);
4838        }
4839    }
4840
4841    public int removeStack(int stackId) {
4842        synchronized (mWindowMap) {
4843            final TaskStack stack = mStackIdToStack.get(stackId);
4844            if (stack != null) {
4845                mStackIdToStack.delete(stackId);
4846                int nextStackId = stack.remove();
4847                stack.getDisplayContent().layoutNeeded = true;
4848                requestTraversalLocked();
4849                if (nextStackId > HOME_STACK_ID) {
4850                    return nextStackId;
4851                }
4852            }
4853            if (DEBUG_STACK) Slog.i(TAG, "removeStack: could not find stackId=" + stackId);
4854        }
4855        return HOME_STACK_ID;
4856    }
4857
4858    public void removeTask(int taskId) {
4859        synchronized (mWindowMap) {
4860            Task task = mTaskIdToTask.get(taskId);
4861            if (task == null) {
4862                if (DEBUG_STACK) Slog.i(TAG, "removeTask: could not find taskId=" + taskId);
4863                return;
4864            }
4865            final TaskStack stack = task.mStack;
4866            EventLog.writeEvent(EventLogTags.WM_TASK_REMOVED, taskId, "removeTask");
4867            stack.removeTask(task);
4868            stack.getDisplayContent().layoutNeeded = true;
4869        }
4870    }
4871
4872    public void addTask(int taskId, int stackId, boolean toTop) {
4873        synchronized (mWindowMap) {
4874            Task task = mTaskIdToTask.get(taskId);
4875            if (task == null) {
4876                return;
4877            }
4878            TaskStack stack = mStackIdToStack.get(stackId);
4879            stack.addTask(task, toTop);
4880            final DisplayContent displayContent = stack.getDisplayContent();
4881            displayContent.layoutNeeded = true;
4882            performLayoutAndPlaceSurfacesLocked();
4883        }
4884    }
4885
4886    public void resizeStack(int stackId, Rect bounds) {
4887        synchronized (mWindowMap) {
4888            final TaskStack stack = mStackIdToStack.get(stackId);
4889            if (stack == null) {
4890                throw new IllegalArgumentException("resizeStack: stackId " + stackId
4891                        + " not found.");
4892            }
4893            if (stack.setBounds(bounds)) {
4894                stack.getDisplayContent().layoutNeeded = true;
4895                performLayoutAndPlaceSurfacesLocked();
4896            }
4897        }
4898    }
4899
4900    public void getStackBounds(int stackId, Rect bounds) {
4901        final TaskStack stack = mStackIdToStack.get(stackId);
4902        if (stack != null) {
4903            stack.getBounds(bounds);
4904            return;
4905        }
4906        bounds.setEmpty();
4907    }
4908
4909    // -------------------------------------------------------------
4910    // Misc IWindowSession methods
4911    // -------------------------------------------------------------
4912
4913    @Override
4914    public void startFreezingScreen(int exitAnim, int enterAnim) {
4915        if (!checkCallingPermission(android.Manifest.permission.FREEZE_SCREEN,
4916                "startFreezingScreen()")) {
4917            throw new SecurityException("Requires FREEZE_SCREEN permission");
4918        }
4919
4920        synchronized(mWindowMap) {
4921            if (!mClientFreezingScreen) {
4922                mClientFreezingScreen = true;
4923                final long origId = Binder.clearCallingIdentity();
4924                try {
4925                    startFreezingDisplayLocked(false, exitAnim, enterAnim);
4926                    mH.removeMessages(H.CLIENT_FREEZE_TIMEOUT);
4927                    mH.sendEmptyMessageDelayed(H.CLIENT_FREEZE_TIMEOUT, 5000);
4928                } finally {
4929                    Binder.restoreCallingIdentity(origId);
4930                }
4931            }
4932        }
4933    }
4934
4935    @Override
4936    public void stopFreezingScreen() {
4937        if (!checkCallingPermission(android.Manifest.permission.FREEZE_SCREEN,
4938                "stopFreezingScreen()")) {
4939            throw new SecurityException("Requires FREEZE_SCREEN permission");
4940        }
4941
4942        synchronized(mWindowMap) {
4943            if (mClientFreezingScreen) {
4944                mClientFreezingScreen = false;
4945                mLastFinishedFreezeSource = "client";
4946                final long origId = Binder.clearCallingIdentity();
4947                try {
4948                    stopFreezingDisplayLocked();
4949                } finally {
4950                    Binder.restoreCallingIdentity(origId);
4951                }
4952            }
4953        }
4954    }
4955
4956    @Override
4957    public void disableKeyguard(IBinder token, String tag) {
4958        if (mContext.checkCallingOrSelfPermission(android.Manifest.permission.DISABLE_KEYGUARD)
4959            != PackageManager.PERMISSION_GRANTED) {
4960            throw new SecurityException("Requires DISABLE_KEYGUARD permission");
4961        }
4962
4963        mKeyguardDisableHandler.sendMessage(mKeyguardDisableHandler.obtainMessage(
4964                KeyguardDisableHandler.KEYGUARD_DISABLE, new Pair<IBinder, String>(token, tag)));
4965    }
4966
4967    @Override
4968    public void reenableKeyguard(IBinder token) {
4969        if (mContext.checkCallingOrSelfPermission(android.Manifest.permission.DISABLE_KEYGUARD)
4970            != PackageManager.PERMISSION_GRANTED) {
4971            throw new SecurityException("Requires DISABLE_KEYGUARD permission");
4972        }
4973
4974        mKeyguardDisableHandler.sendMessage(mKeyguardDisableHandler.obtainMessage(
4975                KeyguardDisableHandler.KEYGUARD_REENABLE, token));
4976    }
4977
4978    /**
4979     * @see android.app.KeyguardManager#exitKeyguardSecurely
4980     */
4981    @Override
4982    public void exitKeyguardSecurely(final IOnKeyguardExitResult callback) {
4983        if (mContext.checkCallingOrSelfPermission(android.Manifest.permission.DISABLE_KEYGUARD)
4984            != PackageManager.PERMISSION_GRANTED) {
4985            throw new SecurityException("Requires DISABLE_KEYGUARD permission");
4986        }
4987        mPolicy.exitKeyguardSecurely(new WindowManagerPolicy.OnKeyguardExitResult() {
4988            @Override
4989            public void onKeyguardExitResult(boolean success) {
4990                try {
4991                    callback.onKeyguardExitResult(success);
4992                } catch (RemoteException e) {
4993                    // Client has died, we don't care.
4994                }
4995            }
4996        });
4997    }
4998
4999    @Override
5000    public boolean inKeyguardRestrictedInputMode() {
5001        return mPolicy.inKeyguardRestrictedKeyInputMode();
5002    }
5003
5004    @Override
5005    public boolean isKeyguardLocked() {
5006        return mPolicy.isKeyguardLocked();
5007    }
5008
5009    @Override
5010    public boolean isKeyguardSecure() {
5011        return mPolicy.isKeyguardSecure();
5012    }
5013
5014    @Override
5015    public void dismissKeyguard() {
5016        if (mContext.checkCallingOrSelfPermission(android.Manifest.permission.DISABLE_KEYGUARD)
5017                != PackageManager.PERMISSION_GRANTED) {
5018            throw new SecurityException("Requires DISABLE_KEYGUARD permission");
5019        }
5020        synchronized(mWindowMap) {
5021            mPolicy.dismissKeyguardLw();
5022        }
5023    }
5024
5025    @Override
5026    public void closeSystemDialogs(String reason) {
5027        synchronized(mWindowMap) {
5028            final int numDisplays = mDisplayContents.size();
5029            for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) {
5030                final WindowList windows = mDisplayContents.valueAt(displayNdx).getWindowList();
5031                final int numWindows = windows.size();
5032                for (int winNdx = 0; winNdx < numWindows; ++winNdx) {
5033                    final WindowState w = windows.get(winNdx);
5034                    if (w.mHasSurface) {
5035                        try {
5036                            w.mClient.closeSystemDialogs(reason);
5037                        } catch (RemoteException e) {
5038                        }
5039                    }
5040                }
5041            }
5042        }
5043    }
5044
5045    static float fixScale(float scale) {
5046        if (scale < 0) scale = 0;
5047        else if (scale > 20) scale = 20;
5048        return Math.abs(scale);
5049    }
5050
5051    @Override
5052    public void setAnimationScale(int which, float scale) {
5053        if (!checkCallingPermission(android.Manifest.permission.SET_ANIMATION_SCALE,
5054                "setAnimationScale()")) {
5055            throw new SecurityException("Requires SET_ANIMATION_SCALE permission");
5056        }
5057
5058        scale = fixScale(scale);
5059        switch (which) {
5060            case 0: mWindowAnimationScale = scale; break;
5061            case 1: mTransitionAnimationScale = scale; break;
5062            case 2: mAnimatorDurationScale = scale; break;
5063        }
5064
5065        // Persist setting
5066        mH.sendEmptyMessage(H.PERSIST_ANIMATION_SCALE);
5067    }
5068
5069    @Override
5070    public void setAnimationScales(float[] scales) {
5071        if (!checkCallingPermission(android.Manifest.permission.SET_ANIMATION_SCALE,
5072                "setAnimationScale()")) {
5073            throw new SecurityException("Requires SET_ANIMATION_SCALE permission");
5074        }
5075
5076        if (scales != null) {
5077            if (scales.length >= 1) {
5078                mWindowAnimationScale = fixScale(scales[0]);
5079            }
5080            if (scales.length >= 2) {
5081                mTransitionAnimationScale = fixScale(scales[1]);
5082            }
5083            if (scales.length >= 3) {
5084                setAnimatorDurationScale(fixScale(scales[2]));
5085            }
5086        }
5087
5088        // Persist setting
5089        mH.sendEmptyMessage(H.PERSIST_ANIMATION_SCALE);
5090    }
5091
5092    private void setAnimatorDurationScale(float scale) {
5093        mAnimatorDurationScale = scale;
5094        ValueAnimator.setDurationScale(scale);
5095    }
5096
5097    @Override
5098    public float getAnimationScale(int which) {
5099        switch (which) {
5100            case 0: return mWindowAnimationScale;
5101            case 1: return mTransitionAnimationScale;
5102            case 2: return mAnimatorDurationScale;
5103        }
5104        return 0;
5105    }
5106
5107    @Override
5108    public float[] getAnimationScales() {
5109        return new float[] { mWindowAnimationScale, mTransitionAnimationScale,
5110                mAnimatorDurationScale };
5111    }
5112
5113    @Override
5114    public void registerPointerEventListener(PointerEventListener listener) {
5115        mPointerEventDispatcher.registerInputEventListener(listener);
5116    }
5117
5118    @Override
5119    public void unregisterPointerEventListener(PointerEventListener listener) {
5120        mPointerEventDispatcher.unregisterInputEventListener(listener);
5121    }
5122
5123    // Called by window manager policy. Not exposed externally.
5124    @Override
5125    public int getLidState() {
5126        int sw = mInputManager.getSwitchState(-1, InputDevice.SOURCE_ANY,
5127                InputManagerService.SW_LID);
5128        if (sw > 0) {
5129            // Switch state: AKEY_STATE_DOWN or AKEY_STATE_VIRTUAL.
5130            return LID_CLOSED;
5131        } else if (sw == 0) {
5132            // Switch state: AKEY_STATE_UP.
5133            return LID_OPEN;
5134        } else {
5135            // Switch state: AKEY_STATE_UNKNOWN.
5136            return LID_ABSENT;
5137        }
5138    }
5139
5140    // Called by window manager policy.  Not exposed externally.
5141    @Override
5142    public void switchKeyboardLayout(int deviceId, int direction) {
5143        mInputManager.switchKeyboardLayout(deviceId, direction);
5144    }
5145
5146    // Called by window manager policy.  Not exposed externally.
5147    @Override
5148    public void shutdown(boolean confirm) {
5149        ShutdownThread.shutdown(mContext, confirm);
5150    }
5151
5152    // Called by window manager policy.  Not exposed externally.
5153    @Override
5154    public void rebootSafeMode(boolean confirm) {
5155        ShutdownThread.rebootSafeMode(mContext, confirm);
5156    }
5157
5158    @Override
5159    public void setInputFilter(IInputFilter filter) {
5160        if (!checkCallingPermission(android.Manifest.permission.FILTER_EVENTS, "setInputFilter()")) {
5161            throw new SecurityException("Requires FILTER_EVENTS permission");
5162        }
5163        mInputManager.setInputFilter(filter);
5164    }
5165
5166    @Override
5167    public void setTouchExplorationEnabled(boolean enabled) {
5168        mPolicy.setTouchExplorationEnabled(enabled);
5169    }
5170
5171    public void setCurrentUser(final int newUserId) {
5172        synchronized (mWindowMap) {
5173            int oldUserId = mCurrentUserId;
5174            mCurrentUserId = newUserId;
5175            mAppTransition.setCurrentUser(newUserId);
5176            mPolicy.setCurrentUserLw(newUserId);
5177
5178            // Hide windows that should not be seen by the new user.
5179            final int numDisplays = mDisplayContents.size();
5180            for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) {
5181                final DisplayContent displayContent = mDisplayContents.valueAt(displayNdx);
5182                displayContent.switchUserStacks(oldUserId, newUserId);
5183                rebuildAppWindowListLocked(displayContent);
5184            }
5185            performLayoutAndPlaceSurfacesLocked();
5186        }
5187    }
5188
5189    public void enableScreenAfterBoot() {
5190        synchronized(mWindowMap) {
5191            if (DEBUG_BOOT) {
5192                RuntimeException here = new RuntimeException("here");
5193                here.fillInStackTrace();
5194                Slog.i(TAG, "enableScreenAfterBoot: mDisplayEnabled=" + mDisplayEnabled
5195                        + " mForceDisplayEnabled=" + mForceDisplayEnabled
5196                        + " mShowingBootMessages=" + mShowingBootMessages
5197                        + " mSystemBooted=" + mSystemBooted, here);
5198            }
5199            if (mSystemBooted) {
5200                return;
5201            }
5202            mSystemBooted = true;
5203            hideBootMessagesLocked();
5204            // If the screen still doesn't come up after 30 seconds, give
5205            // up and turn it on.
5206            mH.sendEmptyMessageDelayed(H.BOOT_TIMEOUT, 30*1000);
5207        }
5208
5209        mPolicy.systemBooted();
5210
5211        performEnableScreen();
5212    }
5213
5214    void enableScreenIfNeededLocked() {
5215        if (DEBUG_BOOT) {
5216            RuntimeException here = new RuntimeException("here");
5217            here.fillInStackTrace();
5218            Slog.i(TAG, "enableScreenIfNeededLocked: mDisplayEnabled=" + mDisplayEnabled
5219                    + " mForceDisplayEnabled=" + mForceDisplayEnabled
5220                    + " mShowingBootMessages=" + mShowingBootMessages
5221                    + " mSystemBooted=" + mSystemBooted, here);
5222        }
5223        if (mDisplayEnabled) {
5224            return;
5225        }
5226        if (!mSystemBooted && !mShowingBootMessages) {
5227            return;
5228        }
5229        mH.sendEmptyMessage(H.ENABLE_SCREEN);
5230    }
5231
5232    public void performBootTimeout() {
5233        synchronized(mWindowMap) {
5234            if (mDisplayEnabled) {
5235                return;
5236            }
5237            Slog.w(TAG, "***** BOOT TIMEOUT: forcing display enabled");
5238            mForceDisplayEnabled = true;
5239        }
5240        performEnableScreen();
5241    }
5242
5243    public void performEnableScreen() {
5244        synchronized(mWindowMap) {
5245            if (DEBUG_BOOT) {
5246                RuntimeException here = new RuntimeException("here");
5247                here.fillInStackTrace();
5248                Slog.i(TAG, "performEnableScreen: mDisplayEnabled=" + mDisplayEnabled
5249                        + " mForceDisplayEnabled=" + mForceDisplayEnabled
5250                        + " mShowingBootMessages=" + mShowingBootMessages
5251                        + " mSystemBooted=" + mSystemBooted
5252                        + " mOnlyCore=" + mOnlyCore, here);
5253            }
5254            if (mDisplayEnabled) {
5255                return;
5256            }
5257            if (!mSystemBooted && !mShowingBootMessages) {
5258                return;
5259            }
5260
5261            if (!mForceDisplayEnabled) {
5262                // Don't enable the screen until all existing windows
5263                // have been drawn.
5264                boolean haveBootMsg = false;
5265                boolean haveApp = false;
5266                // if the wallpaper service is disabled on the device, we're never going to have
5267                // wallpaper, don't bother waiting for it
5268                boolean haveWallpaper = false;
5269                boolean wallpaperEnabled = mContext.getResources().getBoolean(
5270                        com.android.internal.R.bool.config_enableWallpaperService)
5271                        && !mOnlyCore;
5272                boolean haveKeyguard = true;
5273                // TODO(multidisplay): Expand to all displays?
5274                final WindowList windows = getDefaultWindowListLocked();
5275                final int N = windows.size();
5276                for (int i=0; i<N; i++) {
5277                    WindowState w = windows.get(i);
5278                    if (w.mAttrs.type == TYPE_KEYGUARD) {
5279                        // Only if there is a keyguard attached to the window manager
5280                        // will we consider ourselves as having a keyguard.  If it
5281                        // isn't attached, we don't know if it wants to be shown or
5282                        // hidden.  If it is attached, we will say we have a keyguard
5283                        // if the window doesn't want to be visible, because in that
5284                        // case it explicitly doesn't want to be shown so we should
5285                        // not delay turning the screen on for it.
5286                        boolean vis = w.mViewVisibility == View.VISIBLE
5287                                && w.mPolicyVisibility;
5288                        haveKeyguard = !vis;
5289                    }
5290                    if (w.isVisibleLw() && !w.mObscured && !w.isDrawnLw()) {
5291                        return;
5292                    }
5293                    if (w.isDrawnLw()) {
5294                        if (w.mAttrs.type == TYPE_BOOT_PROGRESS) {
5295                            haveBootMsg = true;
5296                        } else if (w.mAttrs.type == TYPE_APPLICATION) {
5297                            haveApp = true;
5298                        } else if (w.mAttrs.type == TYPE_WALLPAPER) {
5299                            haveWallpaper = true;
5300                        } else if (w.mAttrs.type == TYPE_KEYGUARD) {
5301                            haveKeyguard = true;
5302                        }
5303                    }
5304                }
5305
5306                if (DEBUG_SCREEN_ON || DEBUG_BOOT) {
5307                    Slog.i(TAG, "******** booted=" + mSystemBooted + " msg=" + mShowingBootMessages
5308                            + " haveBoot=" + haveBootMsg + " haveApp=" + haveApp
5309                            + " haveWall=" + haveWallpaper + " wallEnabled=" + wallpaperEnabled
5310                            + " haveKeyguard=" + haveKeyguard);
5311                }
5312
5313                // If we are turning on the screen to show the boot message,
5314                // don't do it until the boot message is actually displayed.
5315                if (!mSystemBooted && !haveBootMsg) {
5316                    return;
5317                }
5318
5319                // If we are turning on the screen after the boot is completed
5320                // normally, don't do so until we have the application and
5321                // wallpaper.
5322                if (mSystemBooted && ((!haveApp && !haveKeyguard) ||
5323                        (wallpaperEnabled && !haveWallpaper))) {
5324                    return;
5325                }
5326            }
5327
5328            mDisplayEnabled = true;
5329            if (DEBUG_SCREEN_ON || DEBUG_BOOT) Slog.i(TAG, "******************** ENABLING SCREEN!");
5330            if (false) {
5331                StringWriter sw = new StringWriter();
5332                PrintWriter pw = new FastPrintWriter(sw, false, 1024);
5333                this.dump(null, pw, null);
5334                pw.flush();
5335                Slog.i(TAG, sw.toString());
5336            }
5337            try {
5338                IBinder surfaceFlinger = ServiceManager.getService("SurfaceFlinger");
5339                if (surfaceFlinger != null) {
5340                    //Slog.i(TAG, "******* TELLING SURFACE FLINGER WE ARE BOOTED!");
5341                    Parcel data = Parcel.obtain();
5342                    data.writeInterfaceToken("android.ui.ISurfaceComposer");
5343                    surfaceFlinger.transact(IBinder.FIRST_CALL_TRANSACTION, // BOOT_FINISHED
5344                                            data, null, 0);
5345                    data.recycle();
5346                }
5347            } catch (RemoteException ex) {
5348                Slog.e(TAG, "Boot completed: SurfaceFlinger is dead!");
5349            }
5350
5351            // Enable input dispatch.
5352            mInputMonitor.setEventDispatchingLw(mEventDispatchingEnabled);
5353        }
5354
5355        mPolicy.enableScreenAfterBoot();
5356
5357        // Make sure the last requested orientation has been applied.
5358        updateRotationUnchecked(false, false);
5359    }
5360
5361    public void showBootMessage(final CharSequence msg, final boolean always) {
5362        boolean first = false;
5363        synchronized(mWindowMap) {
5364            if (DEBUG_BOOT) {
5365                RuntimeException here = new RuntimeException("here");
5366                here.fillInStackTrace();
5367                Slog.i(TAG, "showBootMessage: msg=" + msg + " always=" + always
5368                        + " mAllowBootMessages=" + mAllowBootMessages
5369                        + " mShowingBootMessages=" + mShowingBootMessages
5370                        + " mSystemBooted=" + mSystemBooted, here);
5371            }
5372            if (!mAllowBootMessages) {
5373                return;
5374            }
5375            if (!mShowingBootMessages) {
5376                if (!always) {
5377                    return;
5378                }
5379                first = true;
5380            }
5381            if (mSystemBooted) {
5382                return;
5383            }
5384            mShowingBootMessages = true;
5385            mPolicy.showBootMessage(msg, always);
5386        }
5387        if (first) {
5388            performEnableScreen();
5389        }
5390    }
5391
5392    public void hideBootMessagesLocked() {
5393        if (DEBUG_BOOT) {
5394            RuntimeException here = new RuntimeException("here");
5395            here.fillInStackTrace();
5396            Slog.i(TAG, "hideBootMessagesLocked: mDisplayEnabled=" + mDisplayEnabled
5397                    + " mForceDisplayEnabled=" + mForceDisplayEnabled
5398                    + " mShowingBootMessages=" + mShowingBootMessages
5399                    + " mSystemBooted=" + mSystemBooted, here);
5400        }
5401        if (mShowingBootMessages) {
5402            mShowingBootMessages = false;
5403            mPolicy.hideBootMessages();
5404        }
5405    }
5406
5407    @Override
5408    public void setInTouchMode(boolean mode) {
5409        synchronized(mWindowMap) {
5410            mInTouchMode = mode;
5411        }
5412    }
5413
5414    // TODO: more accounting of which pid(s) turned it on, keep count,
5415    // only allow disables from pids which have count on, etc.
5416    @Override
5417    public void showStrictModeViolation(boolean on) {
5418        int pid = Binder.getCallingPid();
5419        mH.sendMessage(mH.obtainMessage(H.SHOW_STRICT_MODE_VIOLATION, on ? 1 : 0, pid));
5420    }
5421
5422    private void showStrictModeViolation(int arg, int pid) {
5423        final boolean on = arg != 0;
5424        synchronized(mWindowMap) {
5425            // Ignoring requests to enable the red border from clients
5426            // which aren't on screen.  (e.g. Broadcast Receivers in
5427            // the background..)
5428            if (on) {
5429                boolean isVisible = false;
5430                final int numDisplays = mDisplayContents.size();
5431                for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) {
5432                    final WindowList windows = mDisplayContents.valueAt(displayNdx).getWindowList();
5433                    final int numWindows = windows.size();
5434                    for (int winNdx = 0; winNdx < numWindows; ++winNdx) {
5435                        final WindowState ws = windows.get(winNdx);
5436                        if (ws.mSession.mPid == pid && ws.isVisibleLw()) {
5437                            isVisible = true;
5438                            break;
5439                        }
5440                    }
5441                }
5442                if (!isVisible) {
5443                    return;
5444                }
5445            }
5446
5447            if (SHOW_LIGHT_TRANSACTIONS) Slog.i(TAG,
5448                    ">>> OPEN TRANSACTION showStrictModeViolation");
5449            SurfaceControl.openTransaction();
5450            try {
5451                // TODO(multi-display): support multiple displays
5452                if (mStrictModeFlash == null) {
5453                    mStrictModeFlash = new StrictModeFlash(
5454                            getDefaultDisplayContentLocked().getDisplay(), mFxSession);
5455                }
5456                mStrictModeFlash.setVisibility(on);
5457            } finally {
5458                SurfaceControl.closeTransaction();
5459                if (SHOW_LIGHT_TRANSACTIONS) Slog.i(TAG,
5460                        "<<< CLOSE TRANSACTION showStrictModeViolation");
5461            }
5462        }
5463    }
5464
5465    @Override
5466    public void setStrictModeVisualIndicatorPreference(String value) {
5467        SystemProperties.set(StrictMode.VISUAL_PROPERTY, value);
5468    }
5469
5470    /**
5471     * Takes a snapshot of the screen.  In landscape mode this grabs the whole screen.
5472     * In portrait mode, it grabs the upper region of the screen based on the vertical dimension
5473     * of the target image.
5474     *
5475     * @param displayId the Display to take a screenshot of.
5476     * @param width the width of the target bitmap
5477     * @param height the height of the target bitmap
5478     * @param force565 if true the returned bitmap will be RGB_565, otherwise it
5479     *                 will be the same config as the surface
5480     */
5481    @Override
5482    public Bitmap screenshotApplications(IBinder appToken, int displayId, int width,
5483            int height, boolean force565) {
5484        if (!checkCallingPermission(android.Manifest.permission.READ_FRAME_BUFFER,
5485                "screenshotApplications()")) {
5486            throw new SecurityException("Requires READ_FRAME_BUFFER permission");
5487        }
5488
5489        Bitmap rawss = null;
5490
5491        int maxLayer = 0;
5492        final Rect frame = new Rect();
5493
5494        float scale = 0;
5495        int dw, dh;
5496        int rot = Surface.ROTATION_0;
5497
5498        boolean screenshotReady;
5499        int minLayer;
5500        if (appToken == null) {
5501            screenshotReady = true;
5502            minLayer = 0;
5503        } else {
5504            screenshotReady = false;
5505            minLayer = Integer.MAX_VALUE;
5506        }
5507
5508        int retryCount = 0;
5509        WindowState appWin = null;
5510
5511        do {
5512            if (retryCount++ > 0) {
5513                try {
5514                    Thread.sleep(100);
5515                } catch (InterruptedException e) {
5516                }
5517            }
5518            synchronized(mWindowMap) {
5519                final DisplayContent displayContent = getDisplayContentLocked(displayId);
5520                if (displayContent == null) {
5521                    return null;
5522                }
5523                final DisplayInfo displayInfo = displayContent.getDisplayInfo();
5524                dw = displayInfo.logicalWidth;
5525                dh = displayInfo.logicalHeight;
5526
5527                int aboveAppLayer = mPolicy.windowTypeToLayerLw(TYPE_APPLICATION)
5528                        * TYPE_LAYER_MULTIPLIER + TYPE_LAYER_OFFSET;
5529                aboveAppLayer += TYPE_LAYER_MULTIPLIER;
5530
5531                boolean isImeTarget = mInputMethodTarget != null
5532                        && mInputMethodTarget.mAppToken != null
5533                        && mInputMethodTarget.mAppToken.appToken != null
5534                        && mInputMethodTarget.mAppToken.appToken.asBinder() == appToken;
5535
5536                // Figure out the part of the screen that is actually the app.
5537                boolean including = false;
5538                appWin = null;
5539                final WindowList windows = displayContent.getWindowList();
5540                final Rect stackBounds = new Rect();
5541                for (int i = windows.size() - 1; i >= 0; i--) {
5542                    WindowState ws = windows.get(i);
5543                    if (!ws.mHasSurface) {
5544                        continue;
5545                    }
5546                    if (ws.mLayer >= aboveAppLayer) {
5547                        continue;
5548                    }
5549                    // When we will skip windows: when we are not including
5550                    // ones behind a window we didn't skip, and we are actually
5551                    // taking a screenshot of a specific app.
5552                    if (!including && appToken != null) {
5553                        // Also, we can possibly skip this window if it is not
5554                        // an IME target or the application for the screenshot
5555                        // is not the current IME target.
5556                        if (!ws.mIsImWindow || !isImeTarget) {
5557                            // And finally, this window is of no interest if it
5558                            // is not associated with the screenshot app.
5559                            if (ws.mAppToken == null || ws.mAppToken.token != appToken) {
5560                                continue;
5561                            }
5562                            appWin = ws;
5563                            ws.getStackBounds(stackBounds);
5564                        }
5565                    }
5566
5567                    // We keep on including windows until we go past a full-screen
5568                    // window.
5569                    including = !ws.mIsImWindow && !ws.isFullscreen(dw, dh);
5570
5571                    final WindowStateAnimator winAnim = ws.mWinAnimator;
5572                    if (maxLayer < winAnim.mSurfaceLayer) {
5573                        maxLayer = winAnim.mSurfaceLayer;
5574                    }
5575                    if (minLayer > winAnim.mSurfaceLayer) {
5576                        minLayer = winAnim.mSurfaceLayer;
5577                    }
5578
5579                    // Don't include wallpaper in bounds calculation
5580                    if (!ws.mIsWallpaper) {
5581                        final Rect wf = ws.mFrame;
5582                        final Rect cr = ws.mContentInsets;
5583                        int left = wf.left + cr.left;
5584                        int top = wf.top + cr.top;
5585                        int right = wf.right - cr.right;
5586                        int bottom = wf.bottom - cr.bottom;
5587                        frame.union(left, top, right, bottom);
5588                        frame.intersect(stackBounds);
5589                    }
5590
5591                    if (ws.mAppToken != null && ws.mAppToken.token == appToken &&
5592                            ws.isDisplayedLw()) {
5593                        screenshotReady = true;
5594                    }
5595                }
5596
5597                if (appToken != null && appWin == null) {
5598                    // Can't find a window to snapshot.
5599                    if (DEBUG_SCREENSHOT) Slog.i(TAG,
5600                            "Screenshot: Couldn't find a surface matching " + appToken);
5601                    return null;
5602                }
5603                if (!screenshotReady) {
5604                    // Delay and hope that window gets drawn.
5605                    if (DEBUG_SCREENSHOT) Slog.i(TAG, "Screenshot: No image ready for " + appToken
5606                            + ", " + appWin + " drawState=" + appWin.mWinAnimator.mDrawState);
5607                    continue;
5608                }
5609
5610                // Constrain frame to the screen size.
5611                frame.intersect(0, 0, dw, dh);
5612
5613                if (frame.isEmpty() || maxLayer == 0) {
5614                    if (DEBUG_SCREENSHOT) Slog.i(TAG, "Screenshot of " + appToken
5615                            + ": returning null frame=" + frame.toShortString() + " maxLayer="
5616                            + maxLayer);
5617                    return null;
5618                }
5619
5620                // The screenshot API does not apply the current screen rotation.
5621                rot = getDefaultDisplayContentLocked().getDisplay().getRotation();
5622                int fw = frame.width();
5623                int fh = frame.height();
5624
5625                // Constrain thumbnail to smaller of screen width or height. Assumes aspect
5626                // of thumbnail is the same as the screen (in landscape) or square.
5627                scale = Math.max(width / (float) fw, height / (float) fh);
5628                /*
5629                float targetWidthScale = width / (float) fw;
5630                float targetHeightScale = height / (float) fh;
5631                if (fw <= fh) {
5632                    scale = targetWidthScale;
5633                    // If aspect of thumbnail is the same as the screen (in landscape),
5634                    // select the slightly larger value so we fill the entire bitmap
5635                    if (targetHeightScale > scale && (int) (targetHeightScale * fw) == width) {
5636                        scale = targetHeightScale;
5637                    }
5638                } else {
5639                    scale = targetHeightScale;
5640                    // If aspect of thumbnail is the same as the screen (in landscape),
5641                    // select the slightly larger value so we fill the entire bitmap
5642                    if (targetWidthScale > scale && (int) (targetWidthScale * fh) == height) {
5643                        scale = targetWidthScale;
5644                    }
5645                }
5646                */
5647
5648                // The screen shot will contain the entire screen.
5649                dw = (int)(dw*scale);
5650                dh = (int)(dh*scale);
5651                if (rot == Surface.ROTATION_90 || rot == Surface.ROTATION_270) {
5652                    int tmp = dw;
5653                    dw = dh;
5654                    dh = tmp;
5655                    rot = (rot == Surface.ROTATION_90) ? Surface.ROTATION_270 : Surface.ROTATION_90;
5656                }
5657                if (DEBUG_SCREENSHOT) {
5658                    Slog.i(TAG, "Screenshot: " + dw + "x" + dh + " from " + minLayer + " to "
5659                            + maxLayer + " appToken=" + appToken);
5660                    for (int i = 0; i < windows.size(); i++) {
5661                        WindowState win = windows.get(i);
5662                        Slog.i(TAG, win + ": " + win.mLayer
5663                                + " animLayer=" + win.mWinAnimator.mAnimLayer
5664                                + " surfaceLayer=" + win.mWinAnimator.mSurfaceLayer);
5665                    }
5666                }
5667                rawss = SurfaceControl.screenshot(dw, dh, minLayer, maxLayer);
5668            }
5669        } while (!screenshotReady && retryCount <= MAX_SCREENSHOT_RETRIES);
5670        if (retryCount > MAX_SCREENSHOT_RETRIES)  Slog.i(TAG, "Screenshot max retries " +
5671                retryCount + " of " + appToken + " appWin=" + (appWin == null ?
5672                        "null" : (appWin + " drawState=" + appWin.mWinAnimator.mDrawState)));
5673
5674        if (rawss == null) {
5675            Slog.w(TAG, "Screenshot failure taking screenshot for (" + dw + "x" + dh
5676                    + ") to layer " + maxLayer);
5677            return null;
5678        }
5679
5680        Bitmap bm = Bitmap.createBitmap(width, height, force565 ? Config.RGB_565 : rawss.getConfig());
5681        frame.scale(scale);
5682        Matrix matrix = new Matrix();
5683        ScreenRotationAnimation.createRotationMatrix(rot, dw, dh, matrix);
5684        // TODO: Test for RTL vs. LTR and use frame.right-width instead of -frame.left
5685        matrix.postTranslate(-FloatMath.ceil(frame.left), -FloatMath.ceil(frame.top));
5686        Canvas canvas = new Canvas(bm);
5687        canvas.drawColor(0xFF000000);
5688        canvas.drawBitmap(rawss, matrix, null);
5689        canvas.setBitmap(null);
5690
5691        if (DEBUG_SCREENSHOT) {
5692            // TEST IF IT's ALL BLACK
5693            int[] buffer = new int[bm.getWidth() * bm.getHeight()];
5694            bm.getPixels(buffer, 0, bm.getWidth(), 0, 0, bm.getWidth(), bm.getHeight());
5695            boolean allBlack = true;
5696            final int firstColor = buffer[0];
5697            for (int i = 0; i < buffer.length; i++) {
5698                if (buffer[i] != firstColor) {
5699                    allBlack = false;
5700                    break;
5701                }
5702            }
5703            if (allBlack) {
5704                Slog.i(TAG, "Screenshot " + appWin + " was monochrome(" +
5705                        Integer.toHexString(firstColor) + ")! mSurfaceLayer=" +
5706                        (appWin != null ? appWin.mWinAnimator.mSurfaceLayer : "null") +
5707                        " minLayer=" + minLayer + " maxLayer=" + maxLayer);
5708            }
5709        }
5710
5711        rawss.recycle();
5712        return bm;
5713    }
5714
5715    /**
5716     * Freeze rotation changes.  (Enable "rotation lock".)
5717     * Persists across reboots.
5718     * @param rotation The desired rotation to freeze to, or -1 to use the
5719     * current rotation.
5720     */
5721    @Override
5722    public void freezeRotation(int rotation) {
5723        if (!checkCallingPermission(android.Manifest.permission.SET_ORIENTATION,
5724                "freezeRotation()")) {
5725            throw new SecurityException("Requires SET_ORIENTATION permission");
5726        }
5727        if (rotation < -1 || rotation > Surface.ROTATION_270) {
5728            throw new IllegalArgumentException("Rotation argument must be -1 or a valid "
5729                    + "rotation constant.");
5730        }
5731
5732        if (DEBUG_ORIENTATION) Slog.v(TAG, "freezeRotation: mRotation=" + mRotation);
5733
5734        long origId = Binder.clearCallingIdentity();
5735        try {
5736            mPolicy.setUserRotationMode(WindowManagerPolicy.USER_ROTATION_LOCKED,
5737                    rotation == -1 ? mRotation : rotation);
5738        } finally {
5739            Binder.restoreCallingIdentity(origId);
5740        }
5741
5742        updateRotationUnchecked(false, false);
5743    }
5744
5745    /**
5746     * Thaw rotation changes.  (Disable "rotation lock".)
5747     * Persists across reboots.
5748     */
5749    @Override
5750    public void thawRotation() {
5751        if (!checkCallingPermission(android.Manifest.permission.SET_ORIENTATION,
5752                "thawRotation()")) {
5753            throw new SecurityException("Requires SET_ORIENTATION permission");
5754        }
5755
5756        if (DEBUG_ORIENTATION) Slog.v(TAG, "thawRotation: mRotation=" + mRotation);
5757
5758        long origId = Binder.clearCallingIdentity();
5759        try {
5760            mPolicy.setUserRotationMode(WindowManagerPolicy.USER_ROTATION_FREE,
5761                    777); // rot not used
5762        } finally {
5763            Binder.restoreCallingIdentity(origId);
5764        }
5765
5766        updateRotationUnchecked(false, false);
5767    }
5768
5769    /**
5770     * Recalculate the current rotation.
5771     *
5772     * Called by the window manager policy whenever the state of the system changes
5773     * such that the current rotation might need to be updated, such as when the
5774     * device is docked or rotated into a new posture.
5775     */
5776    @Override
5777    public void updateRotation(boolean alwaysSendConfiguration, boolean forceRelayout) {
5778        updateRotationUnchecked(alwaysSendConfiguration, forceRelayout);
5779    }
5780
5781    /**
5782     * Temporarily pauses rotation changes until resumed.
5783     *
5784     * This can be used to prevent rotation changes from occurring while the user is
5785     * performing certain operations, such as drag and drop.
5786     *
5787     * This call nests and must be matched by an equal number of calls to
5788     * {@link #resumeRotationLocked}.
5789     */
5790    void pauseRotationLocked() {
5791        mDeferredRotationPauseCount += 1;
5792    }
5793
5794    /**
5795     * Resumes normal rotation changes after being paused.
5796     */
5797    void resumeRotationLocked() {
5798        if (mDeferredRotationPauseCount > 0) {
5799            mDeferredRotationPauseCount -= 1;
5800            if (mDeferredRotationPauseCount == 0) {
5801                boolean changed = updateRotationUncheckedLocked(false);
5802                if (changed) {
5803                    mH.sendEmptyMessage(H.SEND_NEW_CONFIGURATION);
5804                }
5805            }
5806        }
5807    }
5808
5809    public void updateRotationUnchecked(boolean alwaysSendConfiguration, boolean forceRelayout) {
5810        if(DEBUG_ORIENTATION) Slog.v(TAG, "updateRotationUnchecked("
5811                   + "alwaysSendConfiguration=" + alwaysSendConfiguration + ")");
5812
5813        long origId = Binder.clearCallingIdentity();
5814        boolean changed;
5815        synchronized(mWindowMap) {
5816            changed = updateRotationUncheckedLocked(false);
5817            if (!changed || forceRelayout) {
5818                getDefaultDisplayContentLocked().layoutNeeded = true;
5819                performLayoutAndPlaceSurfacesLocked();
5820            }
5821        }
5822
5823        if (changed || alwaysSendConfiguration) {
5824            sendNewConfiguration();
5825        }
5826
5827        Binder.restoreCallingIdentity(origId);
5828    }
5829
5830    // TODO(multidisplay): Rotate any display?
5831    /**
5832     * Updates the current rotation.
5833     *
5834     * Returns true if the rotation has been changed.  In this case YOU
5835     * MUST CALL sendNewConfiguration() TO UNFREEZE THE SCREEN.
5836     */
5837    public boolean updateRotationUncheckedLocked(boolean inTransaction) {
5838        if (mDeferredRotationPauseCount > 0) {
5839            // Rotation updates have been paused temporarily.  Defer the update until
5840            // updates have been resumed.
5841            if (DEBUG_ORIENTATION) Slog.v(TAG, "Deferring rotation, rotation is paused.");
5842            return false;
5843        }
5844
5845        ScreenRotationAnimation screenRotationAnimation =
5846                mAnimator.getScreenRotationAnimationLocked(Display.DEFAULT_DISPLAY);
5847        if (screenRotationAnimation != null && screenRotationAnimation.isAnimating()) {
5848            // Rotation updates cannot be performed while the previous rotation change
5849            // animation is still in progress.  Skip this update.  We will try updating
5850            // again after the animation is finished and the display is unfrozen.
5851            if (DEBUG_ORIENTATION) Slog.v(TAG, "Deferring rotation, animation in progress.");
5852            return false;
5853        }
5854
5855        if (!mDisplayEnabled) {
5856            // No point choosing a rotation if the display is not enabled.
5857            if (DEBUG_ORIENTATION) Slog.v(TAG, "Deferring rotation, display is not enabled.");
5858            return false;
5859        }
5860
5861        // TODO: Implement forced rotation changes.
5862        //       Set mAltOrientation to indicate that the application is receiving
5863        //       an orientation that has different metrics than it expected.
5864        //       eg. Portrait instead of Landscape.
5865
5866        int rotation = mPolicy.rotationForOrientationLw(mForcedAppOrientation, mRotation);
5867        boolean altOrientation = !mPolicy.rotationHasCompatibleMetricsLw(
5868                mForcedAppOrientation, rotation);
5869
5870        if (DEBUG_ORIENTATION) {
5871            Slog.v(TAG, "Application requested orientation "
5872                    + mForcedAppOrientation + ", got rotation " + rotation
5873                    + " which has " + (altOrientation ? "incompatible" : "compatible")
5874                    + " metrics");
5875        }
5876
5877        if (mRotation == rotation && mAltOrientation == altOrientation) {
5878            // No change.
5879            return false;
5880        }
5881
5882        if (DEBUG_ORIENTATION) {
5883            Slog.v(TAG,
5884                "Rotation changed to " + rotation + (altOrientation ? " (alt)" : "")
5885                + " from " + mRotation + (mAltOrientation ? " (alt)" : "")
5886                + ", forceApp=" + mForcedAppOrientation);
5887        }
5888
5889        mRotation = rotation;
5890        mAltOrientation = altOrientation;
5891        mPolicy.setRotationLw(mRotation);
5892
5893        mWindowsFreezingScreen = true;
5894        mH.removeMessages(H.WINDOW_FREEZE_TIMEOUT);
5895        mH.sendEmptyMessageDelayed(H.WINDOW_FREEZE_TIMEOUT, WINDOW_FREEZE_TIMEOUT_DURATION);
5896        mWaitingForConfig = true;
5897        final DisplayContent displayContent = getDefaultDisplayContentLocked();
5898        displayContent.layoutNeeded = true;
5899        final int[] anim = new int[2];
5900        if (displayContent.isDimming()) {
5901            anim[0] = anim[1] = 0;
5902        } else {
5903            mPolicy.selectRotationAnimationLw(anim);
5904        }
5905        startFreezingDisplayLocked(inTransaction, anim[0], anim[1]);
5906        // startFreezingDisplayLocked can reset the ScreenRotationAnimation.
5907        screenRotationAnimation =
5908                mAnimator.getScreenRotationAnimationLocked(Display.DEFAULT_DISPLAY);
5909
5910        // We need to update our screen size information to match the new
5911        // rotation.  Note that this is redundant with the later call to
5912        // sendNewConfiguration() that must be called after this function
5913        // returns...  however we need to do the screen size part of that
5914        // before then so we have the correct size to use when initializing
5915        // the rotation animation for the new rotation.
5916        computeScreenConfigurationLocked(null);
5917
5918        final DisplayInfo displayInfo = displayContent.getDisplayInfo();
5919        if (!inTransaction) {
5920            if (SHOW_TRANSACTIONS) {
5921                Slog.i(TAG, ">>> OPEN TRANSACTION setRotationUnchecked");
5922            }
5923            SurfaceControl.openTransaction();
5924        }
5925        try {
5926            // NOTE: We disable the rotation in the emulator because
5927            //       it doesn't support hardware OpenGL emulation yet.
5928            if (CUSTOM_SCREEN_ROTATION && screenRotationAnimation != null
5929                    && screenRotationAnimation.hasScreenshot()) {
5930                if (screenRotationAnimation.setRotationInTransaction(
5931                        rotation, mFxSession,
5932                        MAX_ANIMATION_DURATION, mTransitionAnimationScale,
5933                        displayInfo.logicalWidth, displayInfo.logicalHeight)) {
5934                    scheduleAnimationLocked();
5935                }
5936            }
5937
5938            mDisplayManagerService.performTraversalInTransactionFromWindowManager();
5939        } finally {
5940            if (!inTransaction) {
5941                SurfaceControl.closeTransaction();
5942                if (SHOW_LIGHT_TRANSACTIONS) {
5943                    Slog.i(TAG, "<<< CLOSE TRANSACTION setRotationUnchecked");
5944                }
5945            }
5946        }
5947
5948        final WindowList windows = displayContent.getWindowList();
5949        for (int i = windows.size() - 1; i >= 0; i--) {
5950            WindowState w = windows.get(i);
5951            if (w.mHasSurface) {
5952                if (DEBUG_ORIENTATION) Slog.v(TAG, "Set mOrientationChanging of " + w);
5953                w.mOrientationChanging = true;
5954                mInnerFields.mOrientationChangeComplete = false;
5955            }
5956            w.mLastFreezeDuration = 0;
5957        }
5958
5959        for (int i=mRotationWatchers.size()-1; i>=0; i--) {
5960            try {
5961                mRotationWatchers.get(i).onRotationChanged(rotation);
5962            } catch (RemoteException e) {
5963            }
5964        }
5965
5966        //TODO (multidisplay): Magnification is supported only for the default display.
5967        if (mDisplayMagnifier != null
5968                && displayContent.getDisplayId() == Display.DEFAULT_DISPLAY) {
5969            mDisplayMagnifier.onRotationChangedLocked(getDefaultDisplayContentLocked(), rotation);
5970        }
5971
5972        return true;
5973    }
5974
5975    @Override
5976    public int getRotation() {
5977        return mRotation;
5978    }
5979
5980    @Override
5981    public boolean isRotationFrozen() {
5982        return mPolicy.getUserRotationMode() == WindowManagerPolicy.USER_ROTATION_LOCKED;
5983    }
5984
5985    @Override
5986    public int watchRotation(IRotationWatcher watcher) {
5987        final IBinder watcherBinder = watcher.asBinder();
5988        IBinder.DeathRecipient dr = new IBinder.DeathRecipient() {
5989            @Override
5990            public void binderDied() {
5991                synchronized (mWindowMap) {
5992                    for (int i=0; i<mRotationWatchers.size(); i++) {
5993                        if (watcherBinder == mRotationWatchers.get(i).asBinder()) {
5994                            IRotationWatcher removed = mRotationWatchers.remove(i);
5995                            if (removed != null) {
5996                                removed.asBinder().unlinkToDeath(this, 0);
5997                            }
5998                            i--;
5999                        }
6000                    }
6001                }
6002            }
6003        };
6004
6005        synchronized (mWindowMap) {
6006            try {
6007                watcher.asBinder().linkToDeath(dr, 0);
6008                mRotationWatchers.add(watcher);
6009            } catch (RemoteException e) {
6010                // Client died, no cleanup needed.
6011            }
6012
6013            return mRotation;
6014        }
6015    }
6016
6017    @Override
6018    public void removeRotationWatcher(IRotationWatcher watcher) {
6019        final IBinder watcherBinder = watcher.asBinder();
6020        synchronized (mWindowMap) {
6021            for (int i=0; i<mRotationWatchers.size(); i++) {
6022                if (watcherBinder == mRotationWatchers.get(i).asBinder()) {
6023                    mRotationWatchers.remove(i);
6024                    i--;
6025                }
6026            }
6027        }
6028    }
6029
6030    /**
6031     * Apps that use the compact menu panel (as controlled by the panelMenuIsCompact
6032     * theme attribute) on devices that feature a physical options menu key attempt to position
6033     * their menu panel window along the edge of the screen nearest the physical menu key.
6034     * This lowers the travel distance between invoking the menu panel and selecting
6035     * a menu option.
6036     *
6037     * This method helps control where that menu is placed. Its current implementation makes
6038     * assumptions about the menu key and its relationship to the screen based on whether
6039     * the device's natural orientation is portrait (width < height) or landscape.
6040     *
6041     * The menu key is assumed to be located along the bottom edge of natural-portrait
6042     * devices and along the right edge of natural-landscape devices. If these assumptions
6043     * do not hold for the target device, this method should be changed to reflect that.
6044     *
6045     * @return A {@link Gravity} value for placing the options menu window
6046     */
6047    @Override
6048    public int getPreferredOptionsPanelGravity() {
6049        synchronized (mWindowMap) {
6050            final int rotation = getRotation();
6051
6052            // TODO(multidisplay): Assume that such devices physical keys are on the main screen.
6053            final DisplayContent displayContent = getDefaultDisplayContentLocked();
6054            if (displayContent.mInitialDisplayWidth < displayContent.mInitialDisplayHeight) {
6055                // On devices with a natural orientation of portrait
6056                switch (rotation) {
6057                    default:
6058                    case Surface.ROTATION_0:
6059                        return Gravity.CENTER_HORIZONTAL | Gravity.BOTTOM;
6060                    case Surface.ROTATION_90:
6061                        return Gravity.RIGHT | Gravity.BOTTOM;
6062                    case Surface.ROTATION_180:
6063                        return Gravity.CENTER_HORIZONTAL | Gravity.BOTTOM;
6064                    case Surface.ROTATION_270:
6065                        return Gravity.START | Gravity.BOTTOM;
6066                }
6067            }
6068
6069            // On devices with a natural orientation of landscape
6070            switch (rotation) {
6071                default:
6072                case Surface.ROTATION_0:
6073                    return Gravity.RIGHT | Gravity.BOTTOM;
6074                case Surface.ROTATION_90:
6075                    return Gravity.CENTER_HORIZONTAL | Gravity.BOTTOM;
6076                case Surface.ROTATION_180:
6077                    return Gravity.START | Gravity.BOTTOM;
6078                case Surface.ROTATION_270:
6079                    return Gravity.CENTER_HORIZONTAL | Gravity.BOTTOM;
6080            }
6081        }
6082    }
6083
6084    /**
6085     * Starts the view server on the specified port.
6086     *
6087     * @param port The port to listener to.
6088     *
6089     * @return True if the server was successfully started, false otherwise.
6090     *
6091     * @see com.android.server.wm.ViewServer
6092     * @see com.android.server.wm.ViewServer#VIEW_SERVER_DEFAULT_PORT
6093     */
6094    @Override
6095    public boolean startViewServer(int port) {
6096        if (isSystemSecure()) {
6097            return false;
6098        }
6099
6100        if (!checkCallingPermission(Manifest.permission.DUMP, "startViewServer")) {
6101            return false;
6102        }
6103
6104        if (port < 1024) {
6105            return false;
6106        }
6107
6108        if (mViewServer != null) {
6109            if (!mViewServer.isRunning()) {
6110                try {
6111                    return mViewServer.start();
6112                } catch (IOException e) {
6113                    Slog.w(TAG, "View server did not start");
6114                }
6115            }
6116            return false;
6117        }
6118
6119        try {
6120            mViewServer = new ViewServer(this, port);
6121            return mViewServer.start();
6122        } catch (IOException e) {
6123            Slog.w(TAG, "View server did not start");
6124        }
6125        return false;
6126    }
6127
6128    private boolean isSystemSecure() {
6129        return "1".equals(SystemProperties.get(SYSTEM_SECURE, "1")) &&
6130                "0".equals(SystemProperties.get(SYSTEM_DEBUGGABLE, "0"));
6131    }
6132
6133    /**
6134     * Stops the view server if it exists.
6135     *
6136     * @return True if the server stopped, false if it wasn't started or
6137     *         couldn't be stopped.
6138     *
6139     * @see com.android.server.wm.ViewServer
6140     */
6141    @Override
6142    public boolean stopViewServer() {
6143        if (isSystemSecure()) {
6144            return false;
6145        }
6146
6147        if (!checkCallingPermission(Manifest.permission.DUMP, "stopViewServer")) {
6148            return false;
6149        }
6150
6151        if (mViewServer != null) {
6152            return mViewServer.stop();
6153        }
6154        return false;
6155    }
6156
6157    /**
6158     * Indicates whether the view server is running.
6159     *
6160     * @return True if the server is running, false otherwise.
6161     *
6162     * @see com.android.server.wm.ViewServer
6163     */
6164    @Override
6165    public boolean isViewServerRunning() {
6166        if (isSystemSecure()) {
6167            return false;
6168        }
6169
6170        if (!checkCallingPermission(Manifest.permission.DUMP, "isViewServerRunning")) {
6171            return false;
6172        }
6173
6174        return mViewServer != null && mViewServer.isRunning();
6175    }
6176
6177    /**
6178     * Lists all availble windows in the system. The listing is written in the
6179     * specified Socket's output stream with the following syntax:
6180     * windowHashCodeInHexadecimal windowName
6181     * Each line of the ouput represents a different window.
6182     *
6183     * @param client The remote client to send the listing to.
6184     * @return False if an error occured, true otherwise.
6185     */
6186    boolean viewServerListWindows(Socket client) {
6187        if (isSystemSecure()) {
6188            return false;
6189        }
6190
6191        boolean result = true;
6192
6193        WindowList windows = new WindowList();
6194        synchronized (mWindowMap) {
6195            //noinspection unchecked
6196            final int numDisplays = mDisplayContents.size();
6197            for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) {
6198                final DisplayContent displayContent = mDisplayContents.valueAt(displayNdx);
6199                windows.addAll(displayContent.getWindowList());
6200            }
6201        }
6202
6203        BufferedWriter out = null;
6204
6205        // Any uncaught exception will crash the system process
6206        try {
6207            OutputStream clientStream = client.getOutputStream();
6208            out = new BufferedWriter(new OutputStreamWriter(clientStream), 8 * 1024);
6209
6210            final int count = windows.size();
6211            for (int i = 0; i < count; i++) {
6212                final WindowState w = windows.get(i);
6213                out.write(Integer.toHexString(System.identityHashCode(w)));
6214                out.write(' ');
6215                out.append(w.mAttrs.getTitle());
6216                out.write('\n');
6217            }
6218
6219            out.write("DONE.\n");
6220            out.flush();
6221        } catch (Exception e) {
6222            result = false;
6223        } finally {
6224            if (out != null) {
6225                try {
6226                    out.close();
6227                } catch (IOException e) {
6228                    result = false;
6229                }
6230            }
6231        }
6232
6233        return result;
6234    }
6235
6236    // TODO(multidisplay): Extend to multiple displays.
6237    /**
6238     * Returns the focused window in the following format:
6239     * windowHashCodeInHexadecimal windowName
6240     *
6241     * @param client The remote client to send the listing to.
6242     * @return False if an error occurred, true otherwise.
6243     */
6244    boolean viewServerGetFocusedWindow(Socket client) {
6245        if (isSystemSecure()) {
6246            return false;
6247        }
6248
6249        boolean result = true;
6250
6251        WindowState focusedWindow = getFocusedWindow();
6252
6253        BufferedWriter out = null;
6254
6255        // Any uncaught exception will crash the system process
6256        try {
6257            OutputStream clientStream = client.getOutputStream();
6258            out = new BufferedWriter(new OutputStreamWriter(clientStream), 8 * 1024);
6259
6260            if(focusedWindow != null) {
6261                out.write(Integer.toHexString(System.identityHashCode(focusedWindow)));
6262                out.write(' ');
6263                out.append(focusedWindow.mAttrs.getTitle());
6264            }
6265            out.write('\n');
6266            out.flush();
6267        } catch (Exception e) {
6268            result = false;
6269        } finally {
6270            if (out != null) {
6271                try {
6272                    out.close();
6273                } catch (IOException e) {
6274                    result = false;
6275                }
6276            }
6277        }
6278
6279        return result;
6280    }
6281
6282    /**
6283     * Sends a command to a target window. The result of the command, if any, will be
6284     * written in the output stream of the specified socket.
6285     *
6286     * The parameters must follow this syntax:
6287     * windowHashcode extra
6288     *
6289     * Where XX is the length in characeters of the windowTitle.
6290     *
6291     * The first parameter is the target window. The window with the specified hashcode
6292     * will be the target. If no target can be found, nothing happens. The extra parameters
6293     * will be delivered to the target window and as parameters to the command itself.
6294     *
6295     * @param client The remote client to sent the result, if any, to.
6296     * @param command The command to execute.
6297     * @param parameters The command parameters.
6298     *
6299     * @return True if the command was successfully delivered, false otherwise. This does
6300     *         not indicate whether the command itself was successful.
6301     */
6302    boolean viewServerWindowCommand(Socket client, String command, String parameters) {
6303        if (isSystemSecure()) {
6304            return false;
6305        }
6306
6307        boolean success = true;
6308        Parcel data = null;
6309        Parcel reply = null;
6310
6311        BufferedWriter out = null;
6312
6313        // Any uncaught exception will crash the system process
6314        try {
6315            // Find the hashcode of the window
6316            int index = parameters.indexOf(' ');
6317            if (index == -1) {
6318                index = parameters.length();
6319            }
6320            final String code = parameters.substring(0, index);
6321            int hashCode = (int) Long.parseLong(code, 16);
6322
6323            // Extract the command's parameter after the window description
6324            if (index < parameters.length()) {
6325                parameters = parameters.substring(index + 1);
6326            } else {
6327                parameters = "";
6328            }
6329
6330            final WindowState window = findWindow(hashCode);
6331            if (window == null) {
6332                return false;
6333            }
6334
6335            data = Parcel.obtain();
6336            data.writeInterfaceToken("android.view.IWindow");
6337            data.writeString(command);
6338            data.writeString(parameters);
6339            data.writeInt(1);
6340            ParcelFileDescriptor.fromSocket(client).writeToParcel(data, 0);
6341
6342            reply = Parcel.obtain();
6343
6344            final IBinder binder = window.mClient.asBinder();
6345            // TODO: GET THE TRANSACTION CODE IN A SAFER MANNER
6346            binder.transact(IBinder.FIRST_CALL_TRANSACTION, data, reply, 0);
6347
6348            reply.readException();
6349
6350            if (!client.isOutputShutdown()) {
6351                out = new BufferedWriter(new OutputStreamWriter(client.getOutputStream()));
6352                out.write("DONE\n");
6353                out.flush();
6354            }
6355
6356        } catch (Exception e) {
6357            Slog.w(TAG, "Could not send command " + command + " with parameters " + parameters, e);
6358            success = false;
6359        } finally {
6360            if (data != null) {
6361                data.recycle();
6362            }
6363            if (reply != null) {
6364                reply.recycle();
6365            }
6366            if (out != null) {
6367                try {
6368                    out.close();
6369                } catch (IOException e) {
6370
6371                }
6372            }
6373        }
6374
6375        return success;
6376    }
6377
6378    public void addWindowChangeListener(WindowChangeListener listener) {
6379        synchronized(mWindowMap) {
6380            mWindowChangeListeners.add(listener);
6381        }
6382    }
6383
6384    public void removeWindowChangeListener(WindowChangeListener listener) {
6385        synchronized(mWindowMap) {
6386            mWindowChangeListeners.remove(listener);
6387        }
6388    }
6389
6390    private void notifyWindowsChanged() {
6391        WindowChangeListener[] windowChangeListeners;
6392        synchronized(mWindowMap) {
6393            if(mWindowChangeListeners.isEmpty()) {
6394                return;
6395            }
6396            windowChangeListeners = new WindowChangeListener[mWindowChangeListeners.size()];
6397            windowChangeListeners = mWindowChangeListeners.toArray(windowChangeListeners);
6398        }
6399        int N = windowChangeListeners.length;
6400        for(int i = 0; i < N; i++) {
6401            windowChangeListeners[i].windowsChanged();
6402        }
6403    }
6404
6405    private void notifyFocusChanged() {
6406        WindowChangeListener[] windowChangeListeners;
6407        synchronized(mWindowMap) {
6408            if(mWindowChangeListeners.isEmpty()) {
6409                return;
6410            }
6411            windowChangeListeners = new WindowChangeListener[mWindowChangeListeners.size()];
6412            windowChangeListeners = mWindowChangeListeners.toArray(windowChangeListeners);
6413        }
6414        int N = windowChangeListeners.length;
6415        for(int i = 0; i < N; i++) {
6416            windowChangeListeners[i].focusChanged();
6417        }
6418    }
6419
6420    private WindowState findWindow(int hashCode) {
6421        if (hashCode == -1) {
6422            // TODO(multidisplay): Extend to multiple displays.
6423            return getFocusedWindow();
6424        }
6425
6426        synchronized (mWindowMap) {
6427            final int numDisplays = mDisplayContents.size();
6428            for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) {
6429                final WindowList windows = mDisplayContents.valueAt(displayNdx).getWindowList();
6430                final int numWindows = windows.size();
6431                for (int winNdx = 0; winNdx < numWindows; ++winNdx) {
6432                    final WindowState w = windows.get(winNdx);
6433                    if (System.identityHashCode(w) == hashCode) {
6434                        return w;
6435                    }
6436                }
6437            }
6438        }
6439
6440        return null;
6441    }
6442
6443    /*
6444     * Instruct the Activity Manager to fetch the current configuration and broadcast
6445     * that to config-changed listeners if appropriate.
6446     */
6447    void sendNewConfiguration() {
6448        try {
6449            mActivityManager.updateConfiguration(null);
6450        } catch (RemoteException e) {
6451        }
6452    }
6453
6454    public Configuration computeNewConfiguration() {
6455        synchronized (mWindowMap) {
6456            Configuration config = computeNewConfigurationLocked();
6457            if (config == null && mWaitingForConfig) {
6458                // Nothing changed but we are waiting for something... stop that!
6459                mWaitingForConfig = false;
6460                mLastFinishedFreezeSource = "new-config";
6461                performLayoutAndPlaceSurfacesLocked();
6462            }
6463            return config;
6464        }
6465    }
6466
6467    Configuration computeNewConfigurationLocked() {
6468        Configuration config = new Configuration();
6469        config.fontScale = 0;
6470        if (!computeScreenConfigurationLocked(config)) {
6471            return null;
6472        }
6473        return config;
6474    }
6475
6476    private void adjustDisplaySizeRanges(DisplayInfo displayInfo, int rotation, int dw, int dh) {
6477        // TODO: Multidisplay: for now only use with default display.
6478        final int width = mPolicy.getConfigDisplayWidth(dw, dh, rotation);
6479        if (width < displayInfo.smallestNominalAppWidth) {
6480            displayInfo.smallestNominalAppWidth = width;
6481        }
6482        if (width > displayInfo.largestNominalAppWidth) {
6483            displayInfo.largestNominalAppWidth = width;
6484        }
6485        final int height = mPolicy.getConfigDisplayHeight(dw, dh, rotation);
6486        if (height < displayInfo.smallestNominalAppHeight) {
6487            displayInfo.smallestNominalAppHeight = height;
6488        }
6489        if (height > displayInfo.largestNominalAppHeight) {
6490            displayInfo.largestNominalAppHeight = height;
6491        }
6492    }
6493
6494    private int reduceConfigLayout(int curLayout, int rotation, float density,
6495            int dw, int dh) {
6496        // TODO: Multidisplay: for now only use with default display.
6497        // Get the app screen size at this rotation.
6498        int w = mPolicy.getNonDecorDisplayWidth(dw, dh, rotation);
6499        int h = mPolicy.getNonDecorDisplayHeight(dw, dh, rotation);
6500
6501        // Compute the screen layout size class for this rotation.
6502        int longSize = w;
6503        int shortSize = h;
6504        if (longSize < shortSize) {
6505            int tmp = longSize;
6506            longSize = shortSize;
6507            shortSize = tmp;
6508        }
6509        longSize = (int)(longSize/density);
6510        shortSize = (int)(shortSize/density);
6511        return Configuration.reduceScreenLayout(curLayout, longSize, shortSize);
6512    }
6513
6514    private void computeSizeRangesAndScreenLayout(DisplayInfo displayInfo, boolean rotated,
6515                  int dw, int dh, float density, Configuration outConfig) {
6516        // TODO: Multidisplay: for now only use with default display.
6517
6518        // We need to determine the smallest width that will occur under normal
6519        // operation.  To this, start with the base screen size and compute the
6520        // width under the different possible rotations.  We need to un-rotate
6521        // the current screen dimensions before doing this.
6522        int unrotDw, unrotDh;
6523        if (rotated) {
6524            unrotDw = dh;
6525            unrotDh = dw;
6526        } else {
6527            unrotDw = dw;
6528            unrotDh = dh;
6529        }
6530        displayInfo.smallestNominalAppWidth = 1<<30;
6531        displayInfo.smallestNominalAppHeight = 1<<30;
6532        displayInfo.largestNominalAppWidth = 0;
6533        displayInfo.largestNominalAppHeight = 0;
6534        adjustDisplaySizeRanges(displayInfo, Surface.ROTATION_0, unrotDw, unrotDh);
6535        adjustDisplaySizeRanges(displayInfo, Surface.ROTATION_90, unrotDh, unrotDw);
6536        adjustDisplaySizeRanges(displayInfo, Surface.ROTATION_180, unrotDw, unrotDh);
6537        adjustDisplaySizeRanges(displayInfo, Surface.ROTATION_270, unrotDh, unrotDw);
6538        int sl = Configuration.resetScreenLayout(outConfig.screenLayout);
6539        sl = reduceConfigLayout(sl, Surface.ROTATION_0, density, unrotDw, unrotDh);
6540        sl = reduceConfigLayout(sl, Surface.ROTATION_90, density, unrotDh, unrotDw);
6541        sl = reduceConfigLayout(sl, Surface.ROTATION_180, density, unrotDw, unrotDh);
6542        sl = reduceConfigLayout(sl, Surface.ROTATION_270, density, unrotDh, unrotDw);
6543        outConfig.smallestScreenWidthDp = (int)(displayInfo.smallestNominalAppWidth / density);
6544        outConfig.screenLayout = sl;
6545    }
6546
6547    private int reduceCompatConfigWidthSize(int curSize, int rotation, DisplayMetrics dm,
6548            int dw, int dh) {
6549        // TODO: Multidisplay: for now only use with default display.
6550        dm.noncompatWidthPixels = mPolicy.getNonDecorDisplayWidth(dw, dh, rotation);
6551        dm.noncompatHeightPixels = mPolicy.getNonDecorDisplayHeight(dw, dh, rotation);
6552        float scale = CompatibilityInfo.computeCompatibleScaling(dm, null);
6553        int size = (int)(((dm.noncompatWidthPixels / scale) / dm.density) + .5f);
6554        if (curSize == 0 || size < curSize) {
6555            curSize = size;
6556        }
6557        return curSize;
6558    }
6559
6560    private int computeCompatSmallestWidth(boolean rotated, DisplayMetrics dm, int dw, int dh) {
6561        // TODO: Multidisplay: for now only use with default display.
6562        mTmpDisplayMetrics.setTo(dm);
6563        final DisplayMetrics tmpDm = mTmpDisplayMetrics;
6564        final int unrotDw, unrotDh;
6565        if (rotated) {
6566            unrotDw = dh;
6567            unrotDh = dw;
6568        } else {
6569            unrotDw = dw;
6570            unrotDh = dh;
6571        }
6572        int sw = reduceCompatConfigWidthSize(0, Surface.ROTATION_0, tmpDm, unrotDw, unrotDh);
6573        sw = reduceCompatConfigWidthSize(sw, Surface.ROTATION_90, tmpDm, unrotDh, unrotDw);
6574        sw = reduceCompatConfigWidthSize(sw, Surface.ROTATION_180, tmpDm, unrotDw, unrotDh);
6575        sw = reduceCompatConfigWidthSize(sw, Surface.ROTATION_270, tmpDm, unrotDh, unrotDw);
6576        return sw;
6577    }
6578
6579    boolean computeScreenConfigurationLocked(Configuration config) {
6580        if (!mDisplayReady) {
6581            return false;
6582        }
6583
6584        // TODO(multidisplay): For now, apply Configuration to main screen only.
6585        final DisplayContent displayContent = getDefaultDisplayContentLocked();
6586
6587        // Use the effective "visual" dimensions based on current rotation
6588        final boolean rotated = (mRotation == Surface.ROTATION_90
6589                || mRotation == Surface.ROTATION_270);
6590        final int realdw = rotated ?
6591                displayContent.mBaseDisplayHeight : displayContent.mBaseDisplayWidth;
6592        final int realdh = rotated ?
6593                displayContent.mBaseDisplayWidth : displayContent.mBaseDisplayHeight;
6594        int dw = realdw;
6595        int dh = realdh;
6596
6597        if (mAltOrientation) {
6598            if (realdw > realdh) {
6599                // Turn landscape into portrait.
6600                int maxw = (int)(realdh/1.3f);
6601                if (maxw < realdw) {
6602                    dw = maxw;
6603                }
6604            } else {
6605                // Turn portrait into landscape.
6606                int maxh = (int)(realdw/1.3f);
6607                if (maxh < realdh) {
6608                    dh = maxh;
6609                }
6610            }
6611        }
6612
6613        if (config != null) {
6614            config.orientation = (dw <= dh) ? Configuration.ORIENTATION_PORTRAIT :
6615                    Configuration.ORIENTATION_LANDSCAPE;
6616        }
6617
6618        // Update application display metrics.
6619        final int appWidth = mPolicy.getNonDecorDisplayWidth(dw, dh, mRotation);
6620        final int appHeight = mPolicy.getNonDecorDisplayHeight(dw, dh, mRotation);
6621        final DisplayInfo displayInfo = displayContent.getDisplayInfo();
6622        synchronized(displayContent.mDisplaySizeLock) {
6623            displayInfo.rotation = mRotation;
6624            displayInfo.logicalWidth = dw;
6625            displayInfo.logicalHeight = dh;
6626            displayInfo.logicalDensityDpi = displayContent.mBaseDisplayDensity;
6627            displayInfo.appWidth = appWidth;
6628            displayInfo.appHeight = appHeight;
6629            displayInfo.getLogicalMetrics(mRealDisplayMetrics,
6630                    CompatibilityInfo.DEFAULT_COMPATIBILITY_INFO, null);
6631            displayInfo.getAppMetrics(mDisplayMetrics);
6632            mDisplayManagerService.setDisplayInfoOverrideFromWindowManager(
6633                    displayContent.getDisplayId(), displayInfo);
6634        }
6635        if (false) {
6636            Slog.i(TAG, "Set app display size: " + appWidth + " x " + appHeight);
6637        }
6638
6639        final DisplayMetrics dm = mDisplayMetrics;
6640        mCompatibleScreenScale = CompatibilityInfo.computeCompatibleScaling(dm,
6641                mCompatDisplayMetrics);
6642
6643        if (config != null) {
6644            config.screenWidthDp = (int)(mPolicy.getConfigDisplayWidth(dw, dh, mRotation)
6645                    / dm.density);
6646            config.screenHeightDp = (int)(mPolicy.getConfigDisplayHeight(dw, dh, mRotation)
6647                    / dm.density);
6648            computeSizeRangesAndScreenLayout(displayInfo, rotated, dw, dh, dm.density, config);
6649
6650            config.compatScreenWidthDp = (int)(config.screenWidthDp / mCompatibleScreenScale);
6651            config.compatScreenHeightDp = (int)(config.screenHeightDp / mCompatibleScreenScale);
6652            config.compatSmallestScreenWidthDp = computeCompatSmallestWidth(rotated, dm, dw, dh);
6653            config.densityDpi = displayContent.mBaseDisplayDensity;
6654
6655            // Update the configuration based on available input devices, lid switch,
6656            // and platform configuration.
6657            config.touchscreen = Configuration.TOUCHSCREEN_NOTOUCH;
6658            config.keyboard = Configuration.KEYBOARD_NOKEYS;
6659            config.navigation = Configuration.NAVIGATION_NONAV;
6660
6661            int keyboardPresence = 0;
6662            int navigationPresence = 0;
6663            final InputDevice[] devices = mInputManager.getInputDevices();
6664            final int len = devices.length;
6665            for (int i = 0; i < len; i++) {
6666                InputDevice device = devices[i];
6667                if (!device.isVirtual()) {
6668                    final int sources = device.getSources();
6669                    final int presenceFlag = device.isExternal() ?
6670                            WindowManagerPolicy.PRESENCE_EXTERNAL :
6671                                    WindowManagerPolicy.PRESENCE_INTERNAL;
6672
6673                    if (mIsTouchDevice) {
6674                        if ((sources & InputDevice.SOURCE_TOUCHSCREEN) ==
6675                                InputDevice.SOURCE_TOUCHSCREEN) {
6676                            config.touchscreen = Configuration.TOUCHSCREEN_FINGER;
6677                        }
6678                    } else {
6679                        config.touchscreen = Configuration.TOUCHSCREEN_NOTOUCH;
6680                    }
6681
6682                    if ((sources & InputDevice.SOURCE_TRACKBALL) == InputDevice.SOURCE_TRACKBALL) {
6683                        config.navigation = Configuration.NAVIGATION_TRACKBALL;
6684                        navigationPresence |= presenceFlag;
6685                    } else if ((sources & InputDevice.SOURCE_DPAD) == InputDevice.SOURCE_DPAD
6686                            && config.navigation == Configuration.NAVIGATION_NONAV) {
6687                        config.navigation = Configuration.NAVIGATION_DPAD;
6688                        navigationPresence |= presenceFlag;
6689                    }
6690
6691                    if (device.getKeyboardType() == InputDevice.KEYBOARD_TYPE_ALPHABETIC) {
6692                        config.keyboard = Configuration.KEYBOARD_QWERTY;
6693                        keyboardPresence |= presenceFlag;
6694                    }
6695                }
6696            }
6697
6698            // Determine whether a hard keyboard is available and enabled.
6699            boolean hardKeyboardAvailable = config.keyboard != Configuration.KEYBOARD_NOKEYS;
6700            if (hardKeyboardAvailable != mHardKeyboardAvailable) {
6701                mHardKeyboardAvailable = hardKeyboardAvailable;
6702                mHardKeyboardEnabled = hardKeyboardAvailable;
6703                mH.removeMessages(H.REPORT_HARD_KEYBOARD_STATUS_CHANGE);
6704                mH.sendEmptyMessage(H.REPORT_HARD_KEYBOARD_STATUS_CHANGE);
6705            }
6706            if (!mHardKeyboardEnabled) {
6707                config.keyboard = Configuration.KEYBOARD_NOKEYS;
6708            }
6709
6710            // Let the policy update hidden states.
6711            config.keyboardHidden = Configuration.KEYBOARDHIDDEN_NO;
6712            config.hardKeyboardHidden = Configuration.HARDKEYBOARDHIDDEN_NO;
6713            config.navigationHidden = Configuration.NAVIGATIONHIDDEN_NO;
6714            mPolicy.adjustConfigurationLw(config, keyboardPresence, navigationPresence);
6715        }
6716
6717        return true;
6718    }
6719
6720    public boolean isHardKeyboardAvailable() {
6721        synchronized (mWindowMap) {
6722            return mHardKeyboardAvailable;
6723        }
6724    }
6725
6726    public boolean isHardKeyboardEnabled() {
6727        synchronized (mWindowMap) {
6728            return mHardKeyboardEnabled;
6729        }
6730    }
6731
6732    public void setHardKeyboardEnabled(boolean enabled) {
6733        synchronized (mWindowMap) {
6734            if (mHardKeyboardEnabled != enabled) {
6735                mHardKeyboardEnabled = enabled;
6736                mH.sendEmptyMessage(H.SEND_NEW_CONFIGURATION);
6737            }
6738        }
6739    }
6740
6741    public void setOnHardKeyboardStatusChangeListener(
6742            OnHardKeyboardStatusChangeListener listener) {
6743        synchronized (mWindowMap) {
6744            mHardKeyboardStatusChangeListener = listener;
6745        }
6746    }
6747
6748    void notifyHardKeyboardStatusChange() {
6749        final boolean available, enabled;
6750        final OnHardKeyboardStatusChangeListener listener;
6751        synchronized (mWindowMap) {
6752            listener = mHardKeyboardStatusChangeListener;
6753            available = mHardKeyboardAvailable;
6754            enabled = mHardKeyboardEnabled;
6755        }
6756        if (listener != null) {
6757            listener.onHardKeyboardStatusChange(available, enabled);
6758        }
6759    }
6760
6761    // -------------------------------------------------------------
6762    // Drag and drop
6763    // -------------------------------------------------------------
6764
6765    IBinder prepareDragSurface(IWindow window, SurfaceSession session,
6766            int flags, int width, int height, Surface outSurface) {
6767        if (DEBUG_DRAG) {
6768            Slog.d(TAG, "prepare drag surface: w=" + width + " h=" + height
6769                    + " flags=" + Integer.toHexString(flags) + " win=" + window
6770                    + " asbinder=" + window.asBinder());
6771        }
6772
6773        final int callerPid = Binder.getCallingPid();
6774        final long origId = Binder.clearCallingIdentity();
6775        IBinder token = null;
6776
6777        try {
6778            synchronized (mWindowMap) {
6779                try {
6780                    if (mDragState == null) {
6781                        // TODO(multi-display): support other displays
6782                        final DisplayContent displayContent = getDefaultDisplayContentLocked();
6783                        final Display display = displayContent.getDisplay();
6784                        SurfaceControl surface = new SurfaceControl(session, "drag surface",
6785                                width, height, PixelFormat.TRANSLUCENT, SurfaceControl.HIDDEN);
6786                        surface.setLayerStack(display.getLayerStack());
6787                        if (SHOW_TRANSACTIONS) Slog.i(TAG, "  DRAG "
6788                                + surface + ": CREATE");
6789                        outSurface.copyFrom(surface);
6790                        final IBinder winBinder = window.asBinder();
6791                        token = new Binder();
6792                        mDragState = new DragState(this, token, surface, /*flags*/ 0, winBinder);
6793                        token = mDragState.mToken = new Binder();
6794
6795                        // 5 second timeout for this window to actually begin the drag
6796                        mH.removeMessages(H.DRAG_START_TIMEOUT, winBinder);
6797                        Message msg = mH.obtainMessage(H.DRAG_START_TIMEOUT, winBinder);
6798                        mH.sendMessageDelayed(msg, 5000);
6799                    } else {
6800                        Slog.w(TAG, "Drag already in progress");
6801                    }
6802                } catch (OutOfResourcesException e) {
6803                    Slog.e(TAG, "Can't allocate drag surface w=" + width + " h=" + height, e);
6804                    if (mDragState != null) {
6805                        mDragState.reset();
6806                        mDragState = null;
6807                    }
6808                }
6809            }
6810        } finally {
6811            Binder.restoreCallingIdentity(origId);
6812        }
6813
6814        return token;
6815    }
6816
6817    // -------------------------------------------------------------
6818    // Input Events and Focus Management
6819    // -------------------------------------------------------------
6820
6821    final InputMonitor mInputMonitor = new InputMonitor(this);
6822    private boolean mEventDispatchingEnabled;
6823
6824    @Override
6825    public void pauseKeyDispatching(IBinder _token) {
6826        if (!checkCallingPermission(android.Manifest.permission.MANAGE_APP_TOKENS,
6827                "pauseKeyDispatching()")) {
6828            throw new SecurityException("Requires MANAGE_APP_TOKENS permission");
6829        }
6830
6831        synchronized (mWindowMap) {
6832            WindowToken token = mTokenMap.get(_token);
6833            if (token != null) {
6834                mInputMonitor.pauseDispatchingLw(token);
6835            }
6836        }
6837    }
6838
6839    @Override
6840    public void resumeKeyDispatching(IBinder _token) {
6841        if (!checkCallingPermission(android.Manifest.permission.MANAGE_APP_TOKENS,
6842                "resumeKeyDispatching()")) {
6843            throw new SecurityException("Requires MANAGE_APP_TOKENS permission");
6844        }
6845
6846        synchronized (mWindowMap) {
6847            WindowToken token = mTokenMap.get(_token);
6848            if (token != null) {
6849                mInputMonitor.resumeDispatchingLw(token);
6850            }
6851        }
6852    }
6853
6854    @Override
6855    public void setEventDispatching(boolean enabled) {
6856        if (!checkCallingPermission(android.Manifest.permission.MANAGE_APP_TOKENS,
6857                "setEventDispatching()")) {
6858            throw new SecurityException("Requires MANAGE_APP_TOKENS permission");
6859        }
6860
6861        synchronized (mWindowMap) {
6862            mEventDispatchingEnabled = enabled;
6863            if (mDisplayEnabled) {
6864                mInputMonitor.setEventDispatchingLw(enabled);
6865            }
6866            sendScreenStatusToClientsLocked();
6867        }
6868    }
6869
6870    @Override
6871    public IBinder getFocusedWindowToken() {
6872        if (!checkCallingPermission(android.Manifest.permission.RETRIEVE_WINDOW_INFO,
6873                "getFocusedWindowToken()")) {
6874            throw new SecurityException("Requires RETRIEVE_WINDOW_INFO permission.");
6875        }
6876        synchronized (mWindowMap) {
6877            WindowState windowState = getFocusedWindowLocked();
6878            if (windowState != null) {
6879                return windowState.mClient.asBinder();
6880            }
6881            return null;
6882        }
6883    }
6884
6885    private WindowState getFocusedWindow() {
6886        synchronized (mWindowMap) {
6887            return getFocusedWindowLocked();
6888        }
6889    }
6890
6891    private WindowState getFocusedWindowLocked() {
6892        return mCurrentFocus;
6893    }
6894
6895    public boolean detectSafeMode() {
6896        if (!mInputMonitor.waitForInputDevicesReady(
6897                INPUT_DEVICES_READY_FOR_SAFE_MODE_DETECTION_TIMEOUT_MILLIS)) {
6898            Slog.w(TAG, "Devices still not ready after waiting "
6899                   + INPUT_DEVICES_READY_FOR_SAFE_MODE_DETECTION_TIMEOUT_MILLIS
6900                   + " milliseconds before attempting to detect safe mode.");
6901        }
6902
6903        int menuState = mInputManager.getKeyCodeState(-1, InputDevice.SOURCE_ANY,
6904                KeyEvent.KEYCODE_MENU);
6905        int sState = mInputManager.getKeyCodeState(-1, InputDevice.SOURCE_ANY, KeyEvent.KEYCODE_S);
6906        int dpadState = mInputManager.getKeyCodeState(-1, InputDevice.SOURCE_DPAD,
6907                KeyEvent.KEYCODE_DPAD_CENTER);
6908        int trackballState = mInputManager.getScanCodeState(-1, InputDevice.SOURCE_TRACKBALL,
6909                InputManagerService.BTN_MOUSE);
6910        int volumeDownState = mInputManager.getKeyCodeState(-1, InputDevice.SOURCE_ANY,
6911                KeyEvent.KEYCODE_VOLUME_DOWN);
6912        mSafeMode = menuState > 0 || sState > 0 || dpadState > 0 || trackballState > 0
6913                || volumeDownState > 0;
6914        try {
6915            if (SystemProperties.getInt(ShutdownThread.REBOOT_SAFEMODE_PROPERTY, 0) != 0) {
6916                mSafeMode = true;
6917                SystemProperties.set(ShutdownThread.REBOOT_SAFEMODE_PROPERTY, "");
6918            }
6919        } catch (IllegalArgumentException e) {
6920        }
6921        if (mSafeMode) {
6922            Log.i(TAG, "SAFE MODE ENABLED (menu=" + menuState + " s=" + sState
6923                    + " dpad=" + dpadState + " trackball=" + trackballState + ")");
6924        } else {
6925            Log.i(TAG, "SAFE MODE not enabled");
6926        }
6927        mPolicy.setSafeMode(mSafeMode);
6928        return mSafeMode;
6929    }
6930
6931    public void displayReady() {
6932        displayReady(Display.DEFAULT_DISPLAY);
6933
6934        synchronized(mWindowMap) {
6935            final DisplayContent displayContent = getDefaultDisplayContentLocked();
6936            readForcedDisplaySizeAndDensityLocked(displayContent);
6937            mDisplayReady = true;
6938        }
6939
6940        try {
6941            mActivityManager.updateConfiguration(null);
6942        } catch (RemoteException e) {
6943        }
6944
6945        synchronized(mWindowMap) {
6946            mIsTouchDevice = mContext.getPackageManager().hasSystemFeature(
6947                    PackageManager.FEATURE_TOUCHSCREEN);
6948            configureDisplayPolicyLocked(getDefaultDisplayContentLocked());
6949        }
6950
6951        try {
6952            mActivityManager.updateConfiguration(null);
6953        } catch (RemoteException e) {
6954        }
6955    }
6956
6957    private void displayReady(int displayId) {
6958        synchronized(mWindowMap) {
6959            final DisplayContent displayContent = getDisplayContentLocked(displayId);
6960            if (displayContent != null) {
6961                mAnimator.addDisplayLocked(displayId);
6962                synchronized(displayContent.mDisplaySizeLock) {
6963                    // Bootstrap the default logical display from the display manager.
6964                    final DisplayInfo displayInfo = displayContent.getDisplayInfo();
6965                    DisplayInfo newDisplayInfo = mDisplayManagerService.getDisplayInfo(displayId);
6966                    if (newDisplayInfo != null) {
6967                        displayInfo.copyFrom(newDisplayInfo);
6968                    }
6969                    displayContent.mInitialDisplayWidth = displayInfo.logicalWidth;
6970                    displayContent.mInitialDisplayHeight = displayInfo.logicalHeight;
6971                    displayContent.mInitialDisplayDensity = displayInfo.logicalDensityDpi;
6972                    displayContent.mBaseDisplayWidth = displayContent.mInitialDisplayWidth;
6973                    displayContent.mBaseDisplayHeight = displayContent.mInitialDisplayHeight;
6974                    displayContent.mBaseDisplayDensity = displayContent.mInitialDisplayDensity;
6975                    displayContent.mBaseDisplayRect.set(0, 0,
6976                            displayContent.mBaseDisplayWidth, displayContent.mBaseDisplayHeight);
6977                }
6978            }
6979        }
6980    }
6981
6982    public void systemReady() {
6983        mPolicy.systemReady();
6984    }
6985
6986    // TODO(multidisplay): Call isScreenOn for each display.
6987    private void sendScreenStatusToClientsLocked() {
6988        final boolean on = mPowerManager.isScreenOn();
6989        final int numDisplays = mDisplayContents.size();
6990        for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) {
6991            final WindowList windows = mDisplayContents.valueAt(displayNdx).getWindowList();
6992            final int numWindows = windows.size();
6993            for (int winNdx = 0; winNdx < numWindows; ++winNdx) {
6994                try {
6995                    windows.get(winNdx).mClient.dispatchScreenState(on);
6996                } catch (RemoteException e) {
6997                    // Ignored
6998                }
6999            }
7000        }
7001    }
7002
7003    // -------------------------------------------------------------
7004    // Async Handler
7005    // -------------------------------------------------------------
7006
7007    final class H extends Handler {
7008        public static final int REPORT_FOCUS_CHANGE = 2;
7009        public static final int REPORT_LOSING_FOCUS = 3;
7010        public static final int DO_TRAVERSAL = 4;
7011        public static final int ADD_STARTING = 5;
7012        public static final int REMOVE_STARTING = 6;
7013        public static final int FINISHED_STARTING = 7;
7014        public static final int REPORT_APPLICATION_TOKEN_WINDOWS = 8;
7015        public static final int REPORT_APPLICATION_TOKEN_DRAWN = 9;
7016        public static final int WINDOW_FREEZE_TIMEOUT = 11;
7017
7018        public static final int APP_TRANSITION_TIMEOUT = 13;
7019        public static final int PERSIST_ANIMATION_SCALE = 14;
7020        public static final int FORCE_GC = 15;
7021        public static final int ENABLE_SCREEN = 16;
7022        public static final int APP_FREEZE_TIMEOUT = 17;
7023        public static final int SEND_NEW_CONFIGURATION = 18;
7024        public static final int REPORT_WINDOWS_CHANGE = 19;
7025        public static final int DRAG_START_TIMEOUT = 20;
7026        public static final int DRAG_END_TIMEOUT = 21;
7027        public static final int REPORT_HARD_KEYBOARD_STATUS_CHANGE = 22;
7028        public static final int BOOT_TIMEOUT = 23;
7029        public static final int WAITING_FOR_DRAWN_TIMEOUT = 24;
7030        public static final int SHOW_STRICT_MODE_VIOLATION = 25;
7031        public static final int DO_ANIMATION_CALLBACK = 26;
7032
7033        public static final int DO_DISPLAY_ADDED = 27;
7034        public static final int DO_DISPLAY_REMOVED = 28;
7035        public static final int DO_DISPLAY_CHANGED = 29;
7036
7037        public static final int CLIENT_FREEZE_TIMEOUT = 30;
7038        public static final int TAP_OUTSIDE_STACK = 31;
7039        public static final int NOTIFY_ACTIVITY_DRAWN = 32;
7040
7041        public static final int REMOVE_STARTING_TIMEOUT = 33;
7042
7043        @Override
7044        public void handleMessage(Message msg) {
7045            if (DEBUG_WINDOW_TRACE) {
7046                Slog.v(TAG, "handleMessage: entry what=" + msg.what);
7047            }
7048            switch (msg.what) {
7049                case REPORT_FOCUS_CHANGE: {
7050                    WindowState lastFocus;
7051                    WindowState newFocus;
7052
7053                    synchronized(mWindowMap) {
7054                        lastFocus = mLastFocus;
7055                        newFocus = mCurrentFocus;
7056                        if (lastFocus == newFocus) {
7057                            // Focus is not changing, so nothing to do.
7058                            return;
7059                        }
7060                        mLastFocus = newFocus;
7061                        if (DEBUG_FOCUS_LIGHT) Slog.i(TAG, "Focus moving from " + lastFocus +
7062                                " to " + newFocus);
7063                        if (newFocus != null && lastFocus != null
7064                                && !newFocus.isDisplayedLw()) {
7065                            //Slog.i(TAG, "Delaying loss of focus...");
7066                            mLosingFocus.add(lastFocus);
7067                            lastFocus = null;
7068                        }
7069                    }
7070
7071                    //System.out.println("Changing focus from " + lastFocus
7072                    //                   + " to " + newFocus);
7073                    if (newFocus != null) {
7074                        if (DEBUG_FOCUS_LIGHT) Slog.i(TAG, "Gaining focus: " + newFocus);
7075                        newFocus.reportFocusChangedSerialized(true, mInTouchMode);
7076                        notifyFocusChanged();
7077                    }
7078
7079                    if (lastFocus != null) {
7080                        if (DEBUG_FOCUS_LIGHT) Slog.i(TAG, "Losing focus: " + lastFocus);
7081                        lastFocus.reportFocusChangedSerialized(false, mInTouchMode);
7082                    }
7083                } break;
7084
7085                case REPORT_LOSING_FOCUS: {
7086                    ArrayList<WindowState> losers;
7087
7088                    synchronized(mWindowMap) {
7089                        losers = mLosingFocus;
7090                        mLosingFocus = new ArrayList<WindowState>();
7091                    }
7092
7093                    final int N = losers.size();
7094                    for (int i=0; i<N; i++) {
7095                        if (DEBUG_FOCUS_LIGHT) Slog.i(TAG, "Losing delayed focus: " +
7096                                losers.get(i));
7097                        losers.get(i).reportFocusChangedSerialized(false, mInTouchMode);
7098                    }
7099                } break;
7100
7101                case DO_TRAVERSAL: {
7102                    synchronized(mWindowMap) {
7103                        mTraversalScheduled = false;
7104                        performLayoutAndPlaceSurfacesLocked();
7105                    }
7106                } break;
7107
7108                case ADD_STARTING: {
7109                    final AppWindowToken wtoken = (AppWindowToken)msg.obj;
7110                    final StartingData sd = wtoken.startingData;
7111
7112                    if (sd == null) {
7113                        // Animation has been canceled... do nothing.
7114                        return;
7115                    }
7116
7117                    if (DEBUG_STARTING_WINDOW) Slog.v(TAG, "Add starting "
7118                            + wtoken + ": pkg=" + sd.pkg);
7119
7120                    View view = null;
7121                    try {
7122                        view = mPolicy.addStartingWindow(
7123                            wtoken.token, sd.pkg, sd.theme, sd.compatInfo,
7124                            sd.nonLocalizedLabel, sd.labelRes, sd.icon, sd.logo, sd.windowFlags);
7125                    } catch (Exception e) {
7126                        Slog.w(TAG, "Exception when adding starting window", e);
7127                    }
7128
7129                    if (view != null) {
7130                        boolean abort = false;
7131
7132                        synchronized(mWindowMap) {
7133                            if (wtoken.removed || wtoken.startingData == null) {
7134                                // If the window was successfully added, then
7135                                // we need to remove it.
7136                                if (wtoken.startingWindow != null) {
7137                                    if (DEBUG_STARTING_WINDOW) Slog.v(TAG,
7138                                            "Aborted starting " + wtoken
7139                                            + ": removed=" + wtoken.removed
7140                                            + " startingData=" + wtoken.startingData);
7141                                    removeStartingWindowTimeout(wtoken);
7142                                    wtoken.startingWindow = null;
7143                                    wtoken.startingData = null;
7144                                    abort = true;
7145                                }
7146                            } else {
7147                                wtoken.startingView = view;
7148                            }
7149                            if (DEBUG_STARTING_WINDOW && !abort) Slog.v(TAG,
7150                                    "Added starting " + wtoken
7151                                    + ": startingWindow="
7152                                    + wtoken.startingWindow + " startingView="
7153                                    + wtoken.startingView);
7154                        }
7155
7156                        if (abort) {
7157                            try {
7158                                mPolicy.removeStartingWindow(wtoken.token, view);
7159                            } catch (Exception e) {
7160                                Slog.w(TAG, "Exception when removing starting window", e);
7161                            }
7162                        }
7163                    }
7164                } break;
7165
7166                case REMOVE_STARTING_TIMEOUT: {
7167                    final AppWindowToken wtoken = (AppWindowToken)msg.obj;
7168                    Slog.e(TAG, "Starting window " + wtoken + " timed out");
7169                    // Fall through.
7170                }
7171                case REMOVE_STARTING: {
7172                    final AppWindowToken wtoken = (AppWindowToken)msg.obj;
7173                    IBinder token = null;
7174                    View view = null;
7175                    synchronized (mWindowMap) {
7176                        if (DEBUG_STARTING_WINDOW) Slog.v(TAG, "Remove starting "
7177                                + wtoken + ": startingWindow="
7178                                + wtoken.startingWindow + " startingView="
7179                                + wtoken.startingView);
7180                        if (wtoken.startingWindow != null) {
7181                            view = wtoken.startingView;
7182                            token = wtoken.token;
7183                            wtoken.startingData = null;
7184                            wtoken.startingView = null;
7185                            wtoken.startingWindow = null;
7186                            wtoken.startingDisplayed = false;
7187                        }
7188                    }
7189                    if (view != null) {
7190                        try {
7191                            mPolicy.removeStartingWindow(token, view);
7192                        } catch (Exception e) {
7193                            Slog.w(TAG, "Exception when removing starting window", e);
7194                        }
7195                    }
7196                } break;
7197
7198                case FINISHED_STARTING: {
7199                    IBinder token = null;
7200                    View view = null;
7201                    while (true) {
7202                        synchronized (mWindowMap) {
7203                            final int N = mFinishedStarting.size();
7204                            if (N <= 0) {
7205                                break;
7206                            }
7207                            AppWindowToken wtoken = mFinishedStarting.remove(N-1);
7208
7209                            if (DEBUG_STARTING_WINDOW) Slog.v(TAG,
7210                                    "Finished starting " + wtoken
7211                                    + ": startingWindow=" + wtoken.startingWindow
7212                                    + " startingView=" + wtoken.startingView);
7213
7214                            if (wtoken.startingWindow == null) {
7215                                continue;
7216                            }
7217
7218                            view = wtoken.startingView;
7219                            token = wtoken.token;
7220                            wtoken.startingData = null;
7221                            wtoken.startingView = null;
7222                            wtoken.startingWindow = null;
7223                            wtoken.startingDisplayed = false;
7224                        }
7225
7226                        try {
7227                            mPolicy.removeStartingWindow(token, view);
7228                        } catch (Exception e) {
7229                            Slog.w(TAG, "Exception when removing starting window", e);
7230                        }
7231                    }
7232                } break;
7233
7234                case REPORT_APPLICATION_TOKEN_DRAWN: {
7235                    final AppWindowToken wtoken = (AppWindowToken)msg.obj;
7236
7237                    try {
7238                        if (DEBUG_VISIBILITY) Slog.v(
7239                                TAG, "Reporting drawn in " + wtoken);
7240                        wtoken.appToken.windowsDrawn();
7241                    } catch (RemoteException ex) {
7242                    }
7243                } break;
7244
7245                case REPORT_APPLICATION_TOKEN_WINDOWS: {
7246                    final AppWindowToken wtoken = (AppWindowToken)msg.obj;
7247
7248                    boolean nowVisible = msg.arg1 != 0;
7249                    boolean nowGone = msg.arg2 != 0;
7250
7251                    try {
7252                        if (DEBUG_VISIBILITY) Slog.v(
7253                                TAG, "Reporting visible in " + wtoken
7254                                + " visible=" + nowVisible
7255                                + " gone=" + nowGone);
7256                        if (nowVisible) {
7257                            wtoken.appToken.windowsVisible();
7258                        } else {
7259                            wtoken.appToken.windowsGone();
7260                        }
7261                    } catch (RemoteException ex) {
7262                    }
7263                } break;
7264
7265                case WINDOW_FREEZE_TIMEOUT: {
7266                    // TODO(multidisplay): Can non-default displays rotate?
7267                    synchronized (mWindowMap) {
7268                        Slog.w(TAG, "Window freeze timeout expired.");
7269                        final WindowList windows = getDefaultWindowListLocked();
7270                        int i = windows.size();
7271                        while (i > 0) {
7272                            i--;
7273                            WindowState w = windows.get(i);
7274                            if (w.mOrientationChanging) {
7275                                w.mOrientationChanging = false;
7276                                w.mLastFreezeDuration = (int)(SystemClock.elapsedRealtime()
7277                                        - mDisplayFreezeTime);
7278                                Slog.w(TAG, "Force clearing orientation change: " + w);
7279                            }
7280                        }
7281                        performLayoutAndPlaceSurfacesLocked();
7282                    }
7283                    break;
7284                }
7285
7286                case APP_TRANSITION_TIMEOUT: {
7287                    synchronized (mWindowMap) {
7288                        if (mAppTransition.isTransitionSet()) {
7289                            if (DEBUG_APP_TRANSITIONS) Slog.v(TAG, "*** APP TRANSITION TIMEOUT");
7290                            mAppTransition.setTimeout();
7291                            performLayoutAndPlaceSurfacesLocked();
7292                        }
7293                    }
7294                    break;
7295                }
7296
7297                case PERSIST_ANIMATION_SCALE: {
7298                    Settings.Global.putFloat(mContext.getContentResolver(),
7299                            Settings.Global.WINDOW_ANIMATION_SCALE, mWindowAnimationScale);
7300                    Settings.Global.putFloat(mContext.getContentResolver(),
7301                            Settings.Global.TRANSITION_ANIMATION_SCALE, mTransitionAnimationScale);
7302                    Settings.Global.putFloat(mContext.getContentResolver(),
7303                            Settings.Global.ANIMATOR_DURATION_SCALE, mAnimatorDurationScale);
7304                    break;
7305                }
7306
7307                case FORCE_GC: {
7308                    synchronized (mWindowMap) {
7309                        // Since we're holding both mWindowMap and mAnimator we don't need to
7310                        // hold mAnimator.mLayoutToAnim.
7311                        if (mAnimator.mAnimating || mAnimationScheduled) {
7312                            // If we are animating, don't do the gc now but
7313                            // delay a bit so we don't interrupt the animation.
7314                            sendEmptyMessageDelayed(H.FORCE_GC, 2000);
7315                            return;
7316                        }
7317                        // If we are currently rotating the display, it will
7318                        // schedule a new message when done.
7319                        if (mDisplayFrozen) {
7320                            return;
7321                        }
7322                    }
7323                    Runtime.getRuntime().gc();
7324                    break;
7325                }
7326
7327                case ENABLE_SCREEN: {
7328                    performEnableScreen();
7329                    break;
7330                }
7331
7332                case APP_FREEZE_TIMEOUT: {
7333                    synchronized (mWindowMap) {
7334                        Slog.w(TAG, "App freeze timeout expired.");
7335                        DisplayContent displayContent = getDefaultDisplayContentLocked();
7336                        final ArrayList<Task> tasks = displayContent.getTasks();
7337                        for (int taskNdx = tasks.size() - 1; taskNdx >= 0; --taskNdx) {
7338                            AppTokenList tokens = tasks.get(taskNdx).mAppTokens;
7339                            for (int tokenNdx = tokens.size() - 1; tokenNdx >= 0; --tokenNdx) {
7340                                AppWindowToken tok = tokens.get(tokenNdx);
7341                                if (tok.mAppAnimator.freezingScreen) {
7342                                    Slog.w(TAG, "Force clearing freeze: " + tok);
7343                                    unsetAppFreezingScreenLocked(tok, true, true);
7344                                }
7345                            }
7346                        }
7347                    }
7348                    break;
7349                }
7350
7351                case CLIENT_FREEZE_TIMEOUT: {
7352                    synchronized (mWindowMap) {
7353                        if (mClientFreezingScreen) {
7354                            mClientFreezingScreen = false;
7355                            mLastFinishedFreezeSource = "client-timeout";
7356                            stopFreezingDisplayLocked();
7357                        }
7358                    }
7359                    break;
7360                }
7361
7362                case SEND_NEW_CONFIGURATION: {
7363                    removeMessages(SEND_NEW_CONFIGURATION);
7364                    sendNewConfiguration();
7365                    break;
7366                }
7367
7368                case REPORT_WINDOWS_CHANGE: {
7369                    if (mWindowsChanged) {
7370                        synchronized (mWindowMap) {
7371                            mWindowsChanged = false;
7372                        }
7373                        notifyWindowsChanged();
7374                    }
7375                    break;
7376                }
7377
7378                case DRAG_START_TIMEOUT: {
7379                    IBinder win = (IBinder)msg.obj;
7380                    if (DEBUG_DRAG) {
7381                        Slog.w(TAG, "Timeout starting drag by win " + win);
7382                    }
7383                    synchronized (mWindowMap) {
7384                        // !!! TODO: ANR the app that has failed to start the drag in time
7385                        if (mDragState != null) {
7386                            mDragState.unregister();
7387                            mInputMonitor.updateInputWindowsLw(true /*force*/);
7388                            mDragState.reset();
7389                            mDragState = null;
7390                        }
7391                    }
7392                    break;
7393                }
7394
7395                case DRAG_END_TIMEOUT: {
7396                    IBinder win = (IBinder)msg.obj;
7397                    if (DEBUG_DRAG) {
7398                        Slog.w(TAG, "Timeout ending drag to win " + win);
7399                    }
7400                    synchronized (mWindowMap) {
7401                        // !!! TODO: ANR the drag-receiving app
7402                        if (mDragState != null) {
7403                            mDragState.mDragResult = false;
7404                            mDragState.endDragLw();
7405                        }
7406                    }
7407                    break;
7408                }
7409
7410                case REPORT_HARD_KEYBOARD_STATUS_CHANGE: {
7411                    notifyHardKeyboardStatusChange();
7412                    break;
7413                }
7414
7415                case BOOT_TIMEOUT: {
7416                    performBootTimeout();
7417                    break;
7418                }
7419
7420                case WAITING_FOR_DRAWN_TIMEOUT: {
7421                    Pair<WindowState, IRemoteCallback> pair;
7422                    synchronized (mWindowMap) {
7423                        pair = (Pair<WindowState, IRemoteCallback>)msg.obj;
7424                        Slog.w(TAG, "Timeout waiting for drawn: " + pair.first);
7425                        if (!mWaitingForDrawn.remove(pair)) {
7426                            return;
7427                        }
7428                    }
7429                    try {
7430                        pair.second.sendResult(null);
7431                    } catch (RemoteException e) {
7432                    }
7433                    break;
7434                }
7435
7436                case SHOW_STRICT_MODE_VIOLATION: {
7437                    showStrictModeViolation(msg.arg1, msg.arg2);
7438                    break;
7439                }
7440
7441                case DO_ANIMATION_CALLBACK: {
7442                    try {
7443                        ((IRemoteCallback)msg.obj).sendResult(null);
7444                    } catch (RemoteException e) {
7445                    }
7446                    break;
7447                }
7448
7449                case DO_DISPLAY_ADDED:
7450                    synchronized (mWindowMap) {
7451                        handleDisplayAddedLocked(msg.arg1);
7452                    }
7453                    break;
7454
7455                case DO_DISPLAY_REMOVED:
7456                    synchronized (mWindowMap) {
7457                        handleDisplayRemovedLocked(msg.arg1);
7458                    }
7459                    break;
7460
7461                case DO_DISPLAY_CHANGED:
7462                    synchronized (mWindowMap) {
7463                        handleDisplayChangedLocked(msg.arg1);
7464                    }
7465                    break;
7466
7467                case TAP_OUTSIDE_STACK: {
7468                    int stackId;
7469                    synchronized (mWindowMap) {
7470                        stackId = ((DisplayContent)msg.obj).stackIdFromPoint(msg.arg1, msg.arg2);
7471                    }
7472                    if (stackId >= 0) {
7473                        try {
7474                            mActivityManager.setFocusedStack(stackId);
7475                        } catch (RemoteException e) {
7476                        }
7477                    }
7478                }
7479                break;
7480                case NOTIFY_ACTIVITY_DRAWN:
7481                    try {
7482                        mActivityManager.notifyActivityDrawn((IBinder) msg.obj);
7483                    } catch (RemoteException e) {
7484                    }
7485                    break;
7486            }
7487            if (DEBUG_WINDOW_TRACE) {
7488                Slog.v(TAG, "handleMessage: exit");
7489            }
7490        }
7491    }
7492
7493    // -------------------------------------------------------------
7494    // IWindowManager API
7495    // -------------------------------------------------------------
7496
7497    @Override
7498    public IWindowSession openSession(IInputMethodClient client,
7499            IInputContext inputContext) {
7500        if (client == null) throw new IllegalArgumentException("null client");
7501        if (inputContext == null) throw new IllegalArgumentException("null inputContext");
7502        Session session = new Session(this, client, inputContext);
7503        return session;
7504    }
7505
7506    @Override
7507    public boolean inputMethodClientHasFocus(IInputMethodClient client) {
7508        synchronized (mWindowMap) {
7509            // The focus for the client is the window immediately below
7510            // where we would place the input method window.
7511            int idx = findDesiredInputMethodWindowIndexLocked(false);
7512            if (idx > 0) {
7513                // TODO(multidisplay): IMEs are only supported on the default display.
7514                WindowState imFocus = getDefaultWindowListLocked().get(idx-1);
7515                if (DEBUG_INPUT_METHOD) {
7516                    Slog.i(TAG, "Desired input method target: " + imFocus);
7517                    Slog.i(TAG, "Current focus: " + mCurrentFocus);
7518                    Slog.i(TAG, "Last focus: " + mLastFocus);
7519                }
7520                if (imFocus != null) {
7521                    // This may be a starting window, in which case we still want
7522                    // to count it as okay.
7523                    if (imFocus.mAttrs.type == LayoutParams.TYPE_APPLICATION_STARTING
7524                            && imFocus.mAppToken != null) {
7525                        // The client has definitely started, so it really should
7526                        // have a window in this app token.  Let's look for it.
7527                        for (int i=0; i<imFocus.mAppToken.windows.size(); i++) {
7528                            WindowState w = imFocus.mAppToken.windows.get(i);
7529                            if (w != imFocus) {
7530                                Log.i(TAG, "Switching to real app window: " + w);
7531                                imFocus = w;
7532                                break;
7533                            }
7534                        }
7535                    }
7536                    if (DEBUG_INPUT_METHOD) {
7537                        Slog.i(TAG, "IM target client: " + imFocus.mSession.mClient);
7538                        if (imFocus.mSession.mClient != null) {
7539                            Slog.i(TAG, "IM target client binder: "
7540                                    + imFocus.mSession.mClient.asBinder());
7541                            Slog.i(TAG, "Requesting client binder: " + client.asBinder());
7542                        }
7543                    }
7544                    if (imFocus.mSession.mClient != null &&
7545                            imFocus.mSession.mClient.asBinder() == client.asBinder()) {
7546                        return true;
7547                    }
7548                }
7549            }
7550
7551            // Okay, how about this...  what is the current focus?
7552            // It seems in some cases we may not have moved the IM
7553            // target window, such as when it was in a pop-up window,
7554            // so let's also look at the current focus.  (An example:
7555            // go to Gmail, start searching so the keyboard goes up,
7556            // press home.  Sometimes the IME won't go down.)
7557            // Would be nice to fix this more correctly, but it's
7558            // way at the end of a release, and this should be good enough.
7559            if (mCurrentFocus != null && mCurrentFocus.mSession.mClient != null
7560                    && mCurrentFocus.mSession.mClient.asBinder() == client.asBinder()) {
7561                return true;
7562            }
7563        }
7564        return false;
7565    }
7566
7567    @Override
7568    public void getInitialDisplaySize(int displayId, Point size) {
7569        synchronized (mWindowMap) {
7570            final DisplayContent displayContent = getDisplayContentLocked(displayId);
7571            if (displayContent != null && displayContent.hasAccess(Binder.getCallingUid())) {
7572                synchronized(displayContent.mDisplaySizeLock) {
7573                    size.x = displayContent.mInitialDisplayWidth;
7574                    size.y = displayContent.mInitialDisplayHeight;
7575                }
7576            }
7577        }
7578    }
7579
7580    @Override
7581    public void getBaseDisplaySize(int displayId, Point size) {
7582        synchronized (mWindowMap) {
7583            final DisplayContent displayContent = getDisplayContentLocked(displayId);
7584            if (displayContent != null && displayContent.hasAccess(Binder.getCallingUid())) {
7585                synchronized(displayContent.mDisplaySizeLock) {
7586                    size.x = displayContent.mBaseDisplayWidth;
7587                    size.y = displayContent.mBaseDisplayHeight;
7588                }
7589            }
7590        }
7591    }
7592
7593    @Override
7594    public void setForcedDisplaySize(int displayId, int width, int height) {
7595        if (mContext.checkCallingOrSelfPermission(
7596                android.Manifest.permission.WRITE_SECURE_SETTINGS) !=
7597                PackageManager.PERMISSION_GRANTED) {
7598            throw new SecurityException("Must hold permission " +
7599                    android.Manifest.permission.WRITE_SECURE_SETTINGS);
7600        }
7601        if (displayId != Display.DEFAULT_DISPLAY) {
7602            throw new IllegalArgumentException("Can only set the default display");
7603        }
7604        final long ident = Binder.clearCallingIdentity();
7605        try {
7606            synchronized(mWindowMap) {
7607                // Set some sort of reasonable bounds on the size of the display that we
7608                // will try to emulate.
7609                final int MIN_WIDTH = 200;
7610                final int MIN_HEIGHT = 200;
7611                final int MAX_SCALE = 2;
7612                final DisplayContent displayContent = getDisplayContentLocked(displayId);
7613                if (displayContent != null) {
7614                    width = Math.min(Math.max(width, MIN_WIDTH),
7615                            displayContent.mInitialDisplayWidth * MAX_SCALE);
7616                    height = Math.min(Math.max(height, MIN_HEIGHT),
7617                            displayContent.mInitialDisplayHeight * MAX_SCALE);
7618                    setForcedDisplaySizeLocked(displayContent, width, height);
7619                    Settings.Global.putString(mContext.getContentResolver(),
7620                            Settings.Global.DISPLAY_SIZE_FORCED, width + "," + height);
7621                }
7622            }
7623        } finally {
7624            Binder.restoreCallingIdentity(ident);
7625        }
7626    }
7627
7628    private void readForcedDisplaySizeAndDensityLocked(final DisplayContent displayContent) {
7629        String sizeStr = Settings.Global.getString(mContext.getContentResolver(),
7630                Settings.Global.DISPLAY_SIZE_FORCED);
7631        if (sizeStr == null || sizeStr.length() == 0) {
7632            sizeStr = SystemProperties.get(SIZE_OVERRIDE, null);
7633        }
7634        if (sizeStr != null && sizeStr.length() > 0) {
7635            final int pos = sizeStr.indexOf(',');
7636            if (pos > 0 && sizeStr.lastIndexOf(',') == pos) {
7637                int width, height;
7638                try {
7639                    width = Integer.parseInt(sizeStr.substring(0, pos));
7640                    height = Integer.parseInt(sizeStr.substring(pos+1));
7641                    synchronized(displayContent.mDisplaySizeLock) {
7642                        if (displayContent.mBaseDisplayWidth != width
7643                                || displayContent.mBaseDisplayHeight != height) {
7644                            Slog.i(TAG, "FORCED DISPLAY SIZE: " + width + "x" + height);
7645                            displayContent.mBaseDisplayWidth = width;
7646                            displayContent.mBaseDisplayHeight = height;
7647                        }
7648                    }
7649                } catch (NumberFormatException ex) {
7650                }
7651            }
7652        }
7653        String densityStr = Settings.Global.getString(mContext.getContentResolver(),
7654                Settings.Global.DISPLAY_DENSITY_FORCED);
7655        if (densityStr == null || densityStr.length() == 0) {
7656            densityStr = SystemProperties.get(DENSITY_OVERRIDE, null);
7657        }
7658        if (densityStr != null && densityStr.length() > 0) {
7659            int density;
7660            try {
7661                density = Integer.parseInt(densityStr);
7662                synchronized(displayContent.mDisplaySizeLock) {
7663                    if (displayContent.mBaseDisplayDensity != density) {
7664                        Slog.i(TAG, "FORCED DISPLAY DENSITY: " + density);
7665                        displayContent.mBaseDisplayDensity = density;
7666                    }
7667                }
7668            } catch (NumberFormatException ex) {
7669            }
7670        }
7671    }
7672
7673    // displayContent must not be null
7674    private void setForcedDisplaySizeLocked(DisplayContent displayContent, int width, int height) {
7675        Slog.i(TAG, "Using new display size: " + width + "x" + height);
7676
7677        synchronized(displayContent.mDisplaySizeLock) {
7678            displayContent.mBaseDisplayWidth = width;
7679            displayContent.mBaseDisplayHeight = height;
7680        }
7681        reconfigureDisplayLocked(displayContent);
7682    }
7683
7684    @Override
7685    public void clearForcedDisplaySize(int displayId) {
7686        if (mContext.checkCallingOrSelfPermission(
7687                android.Manifest.permission.WRITE_SECURE_SETTINGS) !=
7688                PackageManager.PERMISSION_GRANTED) {
7689            throw new SecurityException("Must hold permission " +
7690                    android.Manifest.permission.WRITE_SECURE_SETTINGS);
7691        }
7692        if (displayId != Display.DEFAULT_DISPLAY) {
7693            throw new IllegalArgumentException("Can only set the default display");
7694        }
7695        final long ident = Binder.clearCallingIdentity();
7696        try {
7697            synchronized(mWindowMap) {
7698                final DisplayContent displayContent = getDisplayContentLocked(displayId);
7699                if (displayContent != null) {
7700                    setForcedDisplaySizeLocked(displayContent, displayContent.mInitialDisplayWidth,
7701                            displayContent.mInitialDisplayHeight);
7702                    Settings.Global.putString(mContext.getContentResolver(),
7703                            Settings.Global.DISPLAY_SIZE_FORCED, "");
7704                }
7705            }
7706        } finally {
7707            Binder.restoreCallingIdentity(ident);
7708        }
7709    }
7710
7711    @Override
7712    public int getInitialDisplayDensity(int displayId) {
7713        synchronized (mWindowMap) {
7714            final DisplayContent displayContent = getDisplayContentLocked(displayId);
7715            if (displayContent != null && displayContent.hasAccess(Binder.getCallingUid())) {
7716                synchronized(displayContent.mDisplaySizeLock) {
7717                    return displayContent.mInitialDisplayDensity;
7718                }
7719            }
7720        }
7721        return -1;
7722    }
7723
7724    @Override
7725    public int getBaseDisplayDensity(int displayId) {
7726        synchronized (mWindowMap) {
7727            final DisplayContent displayContent = getDisplayContentLocked(displayId);
7728            if (displayContent != null && displayContent.hasAccess(Binder.getCallingUid())) {
7729                synchronized(displayContent.mDisplaySizeLock) {
7730                    return displayContent.mBaseDisplayDensity;
7731                }
7732            }
7733        }
7734        return -1;
7735    }
7736
7737    @Override
7738    public void setForcedDisplayDensity(int displayId, int density) {
7739        if (mContext.checkCallingOrSelfPermission(
7740                android.Manifest.permission.WRITE_SECURE_SETTINGS) !=
7741                PackageManager.PERMISSION_GRANTED) {
7742            throw new SecurityException("Must hold permission " +
7743                    android.Manifest.permission.WRITE_SECURE_SETTINGS);
7744        }
7745        if (displayId != Display.DEFAULT_DISPLAY) {
7746            throw new IllegalArgumentException("Can only set the default display");
7747        }
7748        final long ident = Binder.clearCallingIdentity();
7749        try {
7750            synchronized(mWindowMap) {
7751                final DisplayContent displayContent = getDisplayContentLocked(displayId);
7752                if (displayContent != null) {
7753                    setForcedDisplayDensityLocked(displayContent, density);
7754                    Settings.Global.putString(mContext.getContentResolver(),
7755                            Settings.Global.DISPLAY_DENSITY_FORCED, Integer.toString(density));
7756                }
7757            }
7758        } finally {
7759            Binder.restoreCallingIdentity(ident);
7760        }
7761    }
7762
7763    // displayContent must not be null
7764    private void setForcedDisplayDensityLocked(DisplayContent displayContent, int density) {
7765        Slog.i(TAG, "Using new display density: " + density);
7766
7767        synchronized(displayContent.mDisplaySizeLock) {
7768            displayContent.mBaseDisplayDensity = density;
7769        }
7770        reconfigureDisplayLocked(displayContent);
7771    }
7772
7773    @Override
7774    public void clearForcedDisplayDensity(int displayId) {
7775        if (mContext.checkCallingOrSelfPermission(
7776                android.Manifest.permission.WRITE_SECURE_SETTINGS) !=
7777                PackageManager.PERMISSION_GRANTED) {
7778            throw new SecurityException("Must hold permission " +
7779                    android.Manifest.permission.WRITE_SECURE_SETTINGS);
7780        }
7781        if (displayId != Display.DEFAULT_DISPLAY) {
7782            throw new IllegalArgumentException("Can only set the default display");
7783        }
7784        final long ident = Binder.clearCallingIdentity();
7785        try {
7786            synchronized(mWindowMap) {
7787                final DisplayContent displayContent = getDisplayContentLocked(displayId);
7788                if (displayContent != null) {
7789                    setForcedDisplayDensityLocked(displayContent,
7790                            displayContent.mInitialDisplayDensity);
7791                    Settings.Global.putString(mContext.getContentResolver(),
7792                            Settings.Global.DISPLAY_DENSITY_FORCED, "");
7793                }
7794            }
7795        } finally {
7796            Binder.restoreCallingIdentity(ident);
7797        }
7798    }
7799
7800    // displayContent must not be null
7801    private void reconfigureDisplayLocked(DisplayContent displayContent) {
7802        // TODO: Multidisplay: for now only use with default display.
7803        configureDisplayPolicyLocked(displayContent);
7804        displayContent.layoutNeeded = true;
7805
7806        boolean configChanged = updateOrientationFromAppTokensLocked(false);
7807        mTempConfiguration.setToDefaults();
7808        mTempConfiguration.fontScale = mCurConfiguration.fontScale;
7809        if (computeScreenConfigurationLocked(mTempConfiguration)) {
7810            if (mCurConfiguration.diff(mTempConfiguration) != 0) {
7811                configChanged = true;
7812            }
7813        }
7814
7815        if (configChanged) {
7816            mWaitingForConfig = true;
7817            startFreezingDisplayLocked(false, 0, 0);
7818            mH.sendEmptyMessage(H.SEND_NEW_CONFIGURATION);
7819        }
7820
7821        performLayoutAndPlaceSurfacesLocked();
7822    }
7823
7824    private void configureDisplayPolicyLocked(DisplayContent displayContent) {
7825        mPolicy.setInitialDisplaySize(displayContent.getDisplay(),
7826                displayContent.mBaseDisplayWidth,
7827                displayContent.mBaseDisplayHeight,
7828                displayContent.mBaseDisplayDensity);
7829
7830        DisplayInfo displayInfo = displayContent.getDisplayInfo();
7831        mPolicy.setDisplayOverscan(displayContent.getDisplay(),
7832                displayInfo.overscanLeft, displayInfo.overscanTop,
7833                displayInfo.overscanRight, displayInfo.overscanBottom);
7834    }
7835
7836    @Override
7837    public void setOverscan(int displayId, int left, int top, int right, int bottom) {
7838        if (mContext.checkCallingOrSelfPermission(
7839                android.Manifest.permission.WRITE_SECURE_SETTINGS) !=
7840                PackageManager.PERMISSION_GRANTED) {
7841            throw new SecurityException("Must hold permission " +
7842                    android.Manifest.permission.WRITE_SECURE_SETTINGS);
7843        }
7844        final long ident = Binder.clearCallingIdentity();
7845        try {
7846            synchronized(mWindowMap) {
7847                DisplayContent displayContent = getDisplayContentLocked(displayId);
7848                if (displayContent != null) {
7849                    setOverscanLocked(displayContent, left, top, right, bottom);
7850                }
7851            }
7852        } finally {
7853            Binder.restoreCallingIdentity(ident);
7854        }
7855    }
7856
7857    private void setOverscanLocked(DisplayContent displayContent,
7858            int left, int top, int right, int bottom) {
7859        final DisplayInfo displayInfo = displayContent.getDisplayInfo();
7860        synchronized (displayContent.mDisplaySizeLock) {
7861            displayInfo.overscanLeft = left;
7862            displayInfo.overscanTop = top;
7863            displayInfo.overscanRight = right;
7864            displayInfo.overscanBottom = bottom;
7865        }
7866
7867        mDisplaySettings.setOverscanLocked(displayInfo.name, left, top, right, bottom);
7868        mDisplaySettings.writeSettingsLocked();
7869
7870        reconfigureDisplayLocked(displayContent);
7871    }
7872
7873    // -------------------------------------------------------------
7874    // Internals
7875    // -------------------------------------------------------------
7876
7877    final WindowState windowForClientLocked(Session session, IWindow client,
7878            boolean throwOnError) {
7879        return windowForClientLocked(session, client.asBinder(), throwOnError);
7880    }
7881
7882    final WindowState windowForClientLocked(Session session, IBinder client,
7883            boolean throwOnError) {
7884        WindowState win = mWindowMap.get(client);
7885        if (localLOGV) Slog.v(
7886            TAG, "Looking up client " + client + ": " + win);
7887        if (win == null) {
7888            RuntimeException ex = new IllegalArgumentException(
7889                    "Requested window " + client + " does not exist");
7890            if (throwOnError) {
7891                throw ex;
7892            }
7893            Slog.w(TAG, "Failed looking up window", ex);
7894            return null;
7895        }
7896        if (session != null && win.mSession != session) {
7897            RuntimeException ex = new IllegalArgumentException(
7898                    "Requested window " + client + " is in session " +
7899                    win.mSession + ", not " + session);
7900            if (throwOnError) {
7901                throw ex;
7902            }
7903            Slog.w(TAG, "Failed looking up window", ex);
7904            return null;
7905        }
7906
7907        return win;
7908    }
7909
7910    final void rebuildAppWindowListLocked() {
7911        // TODO: Multidisplay, when ActivityStacks and tasks exist on more than one display.
7912        rebuildAppWindowListLocked(getDefaultDisplayContentLocked());
7913    }
7914
7915    private void rebuildAppWindowListLocked(final DisplayContent displayContent) {
7916        final WindowList windows = displayContent.getWindowList();
7917        int NW = windows.size();
7918        int i;
7919        int lastBelow = -1;
7920        int numRemoved = 0;
7921
7922        if (mRebuildTmp.length < NW) {
7923            mRebuildTmp = new WindowState[NW+10];
7924        }
7925
7926        // First remove all existing app windows.
7927        i=0;
7928        while (i < NW) {
7929            WindowState w = windows.get(i);
7930            if (w.mAppToken != null) {
7931                WindowState win = windows.remove(i);
7932                win.mRebuilding = true;
7933                mRebuildTmp[numRemoved] = win;
7934                mWindowsChanged = true;
7935                if (DEBUG_WINDOW_MOVEMENT) Slog.v(TAG, "Rebuild removing window: " + win);
7936                NW--;
7937                numRemoved++;
7938                continue;
7939            } else if (lastBelow == i-1) {
7940                if (w.mAttrs.type == TYPE_WALLPAPER || w.mAttrs.type == TYPE_UNIVERSE_BACKGROUND) {
7941                    lastBelow = i;
7942                }
7943            }
7944            i++;
7945        }
7946
7947        // Keep whatever windows were below the app windows still below,
7948        // by skipping them.
7949        lastBelow++;
7950        i = lastBelow;
7951
7952        // First add all of the exiting app tokens...  these are no longer
7953        // in the main app list, but still have windows shown.  We put them
7954        // in the back because now that the animation is over we no longer
7955        // will care about them.
7956        AppTokenList exitingAppTokens = displayContent.mExitingAppTokens;
7957        int NT = exitingAppTokens.size();
7958        for (int j=0; j<NT; j++) {
7959            i = reAddAppWindowsLocked(displayContent, i, exitingAppTokens.get(j));
7960        }
7961
7962        // And add in the still active app tokens in Z order.
7963        final ArrayList<Task> tasks = displayContent.getTasks();
7964        final int numTasks = tasks.size();
7965        for (int taskNdx = 0; taskNdx < numTasks; ++taskNdx) {
7966            final AppTokenList tokens = tasks.get(taskNdx).mAppTokens;
7967            final int numTokens = tokens.size();
7968            for (int tokenNdx = 0; tokenNdx < numTokens; ++tokenNdx) {
7969                final AppWindowToken wtoken = tokens.get(tokenNdx);
7970                i = reAddAppWindowsLocked(displayContent, i, wtoken);
7971            }
7972        }
7973
7974        i -= lastBelow;
7975        if (i != numRemoved) {
7976            Slog.w(TAG, "Rebuild removed " + numRemoved + " windows but added " + i,
7977                    new RuntimeException("here").fillInStackTrace());
7978            for (i=0; i<numRemoved; i++) {
7979                WindowState ws = mRebuildTmp[i];
7980                if (ws.mRebuilding) {
7981                    StringWriter sw = new StringWriter();
7982                    PrintWriter pw = new FastPrintWriter(sw, false, 1024);
7983                    ws.dump(pw, "", true);
7984                    pw.flush();
7985                    Slog.w(TAG, "This window was lost: " + ws);
7986                    Slog.w(TAG, sw.toString());
7987                    ws.mWinAnimator.destroySurfaceLocked();
7988                }
7989            }
7990            Slog.w(TAG, "Current app token list:");
7991            dumpAppTokensLocked();
7992            Slog.w(TAG, "Final window list:");
7993            dumpWindowsLocked();
7994        }
7995    }
7996
7997    private final void assignLayersLocked(WindowList windows) {
7998        int N = windows.size();
7999        int curBaseLayer = 0;
8000        int curLayer = 0;
8001        int i;
8002
8003        if (DEBUG_LAYERS) Slog.v(TAG, "Assigning layers based on windows=" + windows,
8004                new RuntimeException("here").fillInStackTrace());
8005
8006        boolean anyLayerChanged = false;
8007
8008        for (i=0; i<N; i++) {
8009            final WindowState w = windows.get(i);
8010            final WindowStateAnimator winAnimator = w.mWinAnimator;
8011            boolean layerChanged = false;
8012            int oldLayer = w.mLayer;
8013            if (w.mBaseLayer == curBaseLayer || w.mIsImWindow
8014                    || (i > 0 && w.mIsWallpaper)) {
8015                curLayer += WINDOW_LAYER_MULTIPLIER;
8016                w.mLayer = curLayer;
8017            } else {
8018                curBaseLayer = curLayer = w.mBaseLayer;
8019                w.mLayer = curLayer;
8020            }
8021            if (w.mLayer != oldLayer) {
8022                layerChanged = true;
8023                anyLayerChanged = true;
8024            }
8025            final AppWindowToken wtoken = w.mAppToken;
8026            oldLayer = winAnimator.mAnimLayer;
8027            if (w.mTargetAppToken != null) {
8028                winAnimator.mAnimLayer =
8029                        w.mLayer + w.mTargetAppToken.mAppAnimator.animLayerAdjustment;
8030            } else if (wtoken != null) {
8031                winAnimator.mAnimLayer =
8032                        w.mLayer + wtoken.mAppAnimator.animLayerAdjustment;
8033            } else {
8034                winAnimator.mAnimLayer = w.mLayer;
8035            }
8036            if (w.mIsImWindow) {
8037                winAnimator.mAnimLayer += mInputMethodAnimLayerAdjustment;
8038            } else if (w.mIsWallpaper) {
8039                winAnimator.mAnimLayer += mWallpaperAnimLayerAdjustment;
8040            }
8041            if (winAnimator.mAnimLayer != oldLayer) {
8042                layerChanged = true;
8043                anyLayerChanged = true;
8044            }
8045            if (layerChanged && w.getStack().isDimming(winAnimator)) {
8046                // Force an animation pass just to update the mDimLayer layer.
8047                scheduleAnimationLocked();
8048            }
8049            if (DEBUG_LAYERS) Slog.v(TAG, "Assign layer " + w + ": "
8050                    + "mBase=" + w.mBaseLayer
8051                    + " mLayer=" + w.mLayer
8052                    + (wtoken == null ?
8053                            "" : " mAppLayer=" + wtoken.mAppAnimator.animLayerAdjustment)
8054                    + " =mAnimLayer=" + winAnimator.mAnimLayer);
8055            //System.out.println(
8056            //    "Assigned layer " + curLayer + " to " + w.mClient.asBinder());
8057        }
8058
8059        //TODO (multidisplay): Magnification is supported only for the default display.
8060        if (mDisplayMagnifier != null && anyLayerChanged
8061                && windows.get(windows.size() - 1).getDisplayId() == Display.DEFAULT_DISPLAY) {
8062            mDisplayMagnifier.onWindowLayersChangedLocked();
8063        }
8064    }
8065
8066    private final void performLayoutAndPlaceSurfacesLocked() {
8067        int loopCount = 6;
8068        do {
8069            mTraversalScheduled = false;
8070            performLayoutAndPlaceSurfacesLockedLoop();
8071            mH.removeMessages(H.DO_TRAVERSAL);
8072            loopCount--;
8073        } while (mTraversalScheduled && loopCount > 0);
8074        mInnerFields.mWallpaperActionPending = false;
8075    }
8076
8077    private boolean mInLayout = false;
8078    private final void performLayoutAndPlaceSurfacesLockedLoop() {
8079        if (mInLayout) {
8080            if (DEBUG) {
8081                throw new RuntimeException("Recursive call!");
8082            }
8083            Slog.w(TAG, "performLayoutAndPlaceSurfacesLocked called while in layout. Callers="
8084                    + Debug.getCallers(3));
8085            return;
8086        }
8087
8088        if (mWaitingForConfig) {
8089            // Our configuration has changed (most likely rotation), but we
8090            // don't yet have the complete configuration to report to
8091            // applications.  Don't do any window layout until we have it.
8092            return;
8093        }
8094
8095        if (!mDisplayReady) {
8096            // Not yet initialized, nothing to do.
8097            return;
8098        }
8099
8100        Trace.traceBegin(Trace.TRACE_TAG_WINDOW_MANAGER, "wmLayout");
8101        mInLayout = true;
8102        boolean recoveringMemory = false;
8103
8104        try {
8105            if (mForceRemoves != null) {
8106                recoveringMemory = true;
8107                // Wait a little bit for things to settle down, and off we go.
8108                for (int i=0; i<mForceRemoves.size(); i++) {
8109                    WindowState ws = mForceRemoves.get(i);
8110                    Slog.i(TAG, "Force removing: " + ws);
8111                    removeWindowInnerLocked(ws.mSession, ws);
8112                }
8113                mForceRemoves = null;
8114                Slog.w(TAG, "Due to memory failure, waiting a bit for next layout");
8115                Object tmp = new Object();
8116                synchronized (tmp) {
8117                    try {
8118                        tmp.wait(250);
8119                    } catch (InterruptedException e) {
8120                    }
8121                }
8122            }
8123        } catch (RuntimeException e) {
8124            Log.wtf(TAG, "Unhandled exception while force removing for memory", e);
8125        }
8126
8127        try {
8128            performLayoutAndPlaceSurfacesLockedInner(recoveringMemory);
8129
8130            mInLayout = false;
8131
8132            if (needsLayout()) {
8133                if (++mLayoutRepeatCount < 6) {
8134                    requestTraversalLocked();
8135                } else {
8136                    Slog.e(TAG, "Performed 6 layouts in a row. Skipping");
8137                    mLayoutRepeatCount = 0;
8138                }
8139            } else {
8140                mLayoutRepeatCount = 0;
8141            }
8142
8143            if (mWindowsChanged && !mWindowChangeListeners.isEmpty()) {
8144                mH.removeMessages(H.REPORT_WINDOWS_CHANGE);
8145                mH.sendEmptyMessage(H.REPORT_WINDOWS_CHANGE);
8146            }
8147        } catch (RuntimeException e) {
8148            mInLayout = false;
8149            Log.wtf(TAG, "Unhandled exception while laying out windows", e);
8150        }
8151
8152        Trace.traceEnd(Trace.TRACE_TAG_WINDOW_MANAGER);
8153    }
8154
8155    private final void performLayoutLockedInner(final DisplayContent displayContent,
8156                                    boolean initial, boolean updateInputWindows) {
8157        if (!displayContent.layoutNeeded) {
8158            return;
8159        }
8160        displayContent.layoutNeeded = false;
8161        WindowList windows = displayContent.getWindowList();
8162        boolean isDefaultDisplay = displayContent.isDefaultDisplay;
8163
8164        DisplayInfo displayInfo = displayContent.getDisplayInfo();
8165        final int dw = displayInfo.logicalWidth;
8166        final int dh = displayInfo.logicalHeight;
8167
8168        final int NFW = mFakeWindows.size();
8169        for (int i=0; i<NFW; i++) {
8170            mFakeWindows.get(i).layout(dw, dh);
8171        }
8172
8173        final int N = windows.size();
8174        int i;
8175
8176        if (DEBUG_LAYOUT) {
8177            Slog.v(TAG, "-------------------------------------");
8178            Slog.v(TAG, "performLayout: needed="
8179                    + displayContent.layoutNeeded + " dw=" + dw + " dh=" + dh);
8180        }
8181
8182        WindowStateAnimator universeBackground = null;
8183
8184        mPolicy.beginLayoutLw(isDefaultDisplay, dw, dh, mRotation);
8185        if (isDefaultDisplay) {
8186            // Not needed on non-default displays.
8187            mSystemDecorLayer = mPolicy.getSystemDecorLayerLw();
8188            mScreenRect.set(0, 0, dw, dh);
8189        }
8190
8191        mPolicy.getContentRectLw(mTmpContentRect);
8192        displayContent.resize(mTmpContentRect);
8193
8194        int seq = mLayoutSeq+1;
8195        if (seq < 0) seq = 0;
8196        mLayoutSeq = seq;
8197
8198        boolean behindDream = false;
8199
8200        // First perform layout of any root windows (not attached
8201        // to another window).
8202        int topAttached = -1;
8203        for (i = N-1; i >= 0; i--) {
8204            final WindowState win = windows.get(i);
8205
8206            // Don't do layout of a window if it is not visible, or
8207            // soon won't be visible, to avoid wasting time and funky
8208            // changes while a window is animating away.
8209            final boolean gone = (behindDream && mPolicy.canBeForceHidden(win, win.mAttrs))
8210                    || win.isGoneForLayoutLw();
8211
8212            if (DEBUG_LAYOUT && !win.mLayoutAttached) {
8213                Slog.v(TAG, "1ST PASS " + win
8214                        + ": gone=" + gone + " mHaveFrame=" + win.mHaveFrame
8215                        + " mLayoutAttached=" + win.mLayoutAttached
8216                        + " screen changed=" + win.isConfigChanged());
8217                final AppWindowToken atoken = win.mAppToken;
8218                if (gone) Slog.v(TAG, "  GONE: mViewVisibility="
8219                        + win.mViewVisibility + " mRelayoutCalled="
8220                        + win.mRelayoutCalled + " hidden="
8221                        + win.mRootToken.hidden + " hiddenRequested="
8222                        + (atoken != null && atoken.hiddenRequested)
8223                        + " mAttachedHidden=" + win.mAttachedHidden);
8224                else Slog.v(TAG, "  VIS: mViewVisibility="
8225                        + win.mViewVisibility + " mRelayoutCalled="
8226                        + win.mRelayoutCalled + " hidden="
8227                        + win.mRootToken.hidden + " hiddenRequested="
8228                        + (atoken != null && atoken.hiddenRequested)
8229                        + " mAttachedHidden=" + win.mAttachedHidden);
8230            }
8231
8232            // If this view is GONE, then skip it -- keep the current
8233            // frame, and let the caller know so they can ignore it
8234            // if they want.  (We do the normal layout for INVISIBLE
8235            // windows, since that means "perform layout as normal,
8236            // just don't display").
8237            if (!gone || !win.mHaveFrame || win.mLayoutNeeded
8238                    || ((win.isConfigChanged() || win.setInsetsChanged()) &&
8239                            (win.mAttrs.type == TYPE_KEYGUARD ||
8240                            win.mAppToken != null && win.mAppToken.layoutConfigChanges))
8241                    || win.mAttrs.type == TYPE_UNIVERSE_BACKGROUND) {
8242                if (!win.mLayoutAttached) {
8243                    if (initial) {
8244                        //Slog.i(TAG, "Window " + this + " clearing mContentChanged - initial");
8245                        win.mContentChanged = false;
8246                    }
8247                    if (win.mAttrs.type == TYPE_DREAM) {
8248                        // Don't layout windows behind a dream, so that if it
8249                        // does stuff like hide the status bar we won't get a
8250                        // bad transition when it goes away.
8251                        behindDream = true;
8252                    }
8253                    win.mLayoutNeeded = false;
8254                    win.prelayout();
8255                    mPolicy.layoutWindowLw(win, win.mAttrs, null);
8256                    win.mLayoutSeq = seq;
8257                    if (DEBUG_LAYOUT) Slog.v(TAG, "  LAYOUT: mFrame="
8258                            + win.mFrame + " mContainingFrame="
8259                            + win.mContainingFrame + " mDisplayFrame="
8260                            + win.mDisplayFrame);
8261                } else {
8262                    if (topAttached < 0) topAttached = i;
8263                }
8264            }
8265            if (win.mViewVisibility == View.VISIBLE
8266                    && win.mAttrs.type == TYPE_UNIVERSE_BACKGROUND
8267                    && universeBackground == null) {
8268                universeBackground = win.mWinAnimator;
8269            }
8270        }
8271
8272        if (mAnimator.mUniverseBackground  != universeBackground) {
8273            mFocusMayChange = true;
8274            mAnimator.mUniverseBackground = universeBackground;
8275        }
8276
8277        boolean attachedBehindDream = false;
8278
8279        // Now perform layout of attached windows, which usually
8280        // depend on the position of the window they are attached to.
8281        // XXX does not deal with windows that are attached to windows
8282        // that are themselves attached.
8283        for (i = topAttached; i >= 0; i--) {
8284            final WindowState win = windows.get(i);
8285
8286            if (win.mLayoutAttached) {
8287                if (DEBUG_LAYOUT) Slog.v(TAG, "2ND PASS " + win
8288                        + " mHaveFrame=" + win.mHaveFrame
8289                        + " mViewVisibility=" + win.mViewVisibility
8290                        + " mRelayoutCalled=" + win.mRelayoutCalled);
8291                // If this view is GONE, then skip it -- keep the current
8292                // frame, and let the caller know so they can ignore it
8293                // if they want.  (We do the normal layout for INVISIBLE
8294                // windows, since that means "perform layout as normal,
8295                // just don't display").
8296                if (attachedBehindDream && mPolicy.canBeForceHidden(win, win.mAttrs)) {
8297                    continue;
8298                }
8299                if ((win.mViewVisibility != View.GONE && win.mRelayoutCalled)
8300                        || !win.mHaveFrame || win.mLayoutNeeded) {
8301                    if (initial) {
8302                        //Slog.i(TAG, "Window " + this + " clearing mContentChanged - initial");
8303                        win.mContentChanged = false;
8304                    }
8305                    win.mLayoutNeeded = false;
8306                    win.prelayout();
8307                    mPolicy.layoutWindowLw(win, win.mAttrs, win.mAttachedWindow);
8308                    win.mLayoutSeq = seq;
8309                    if (DEBUG_LAYOUT) Slog.v(TAG, "  LAYOUT: mFrame="
8310                            + win.mFrame + " mContainingFrame="
8311                            + win.mContainingFrame + " mDisplayFrame="
8312                            + win.mDisplayFrame);
8313                }
8314            } else if (win.mAttrs.type == TYPE_DREAM) {
8315                // Don't layout windows behind a dream, so that if it
8316                // does stuff like hide the status bar we won't get a
8317                // bad transition when it goes away.
8318                attachedBehindDream = behindDream;
8319            }
8320        }
8321
8322        // Window frames may have changed.  Tell the input dispatcher about it.
8323        mInputMonitor.setUpdateInputWindowsNeededLw();
8324        if (updateInputWindows) {
8325            mInputMonitor.updateInputWindowsLw(false /*force*/);
8326        }
8327
8328        mPolicy.finishLayoutLw();
8329    }
8330
8331    void makeWindowFreezingScreenIfNeededLocked(WindowState w) {
8332        // If the screen is currently frozen or off, then keep
8333        // it frozen/off until this window draws at its new
8334        // orientation.
8335        if (!okToDisplay()) {
8336            if (DEBUG_ORIENTATION) Slog.v(TAG,
8337                    "Changing surface while display frozen: " + w);
8338            w.mOrientationChanging = true;
8339            w.mLastFreezeDuration = 0;
8340            mInnerFields.mOrientationChangeComplete = false;
8341            if (!mWindowsFreezingScreen) {
8342                mWindowsFreezingScreen = true;
8343                // XXX should probably keep timeout from
8344                // when we first froze the display.
8345                mH.removeMessages(H.WINDOW_FREEZE_TIMEOUT);
8346                mH.sendEmptyMessageDelayed(H.WINDOW_FREEZE_TIMEOUT,
8347                        WINDOW_FREEZE_TIMEOUT_DURATION);
8348            }
8349        }
8350    }
8351
8352    /**
8353     * Extracted from {@link #performLayoutAndPlaceSurfacesLockedInner} to reduce size of method.
8354     * @param windows List of windows on default display.
8355     * @return bitmap indicating if another pass through layout must be made.
8356     */
8357    public int handleAppTransitionReadyLocked(WindowList windows) {
8358        int changes = 0;
8359        int i;
8360        int NN = mOpeningApps.size();
8361        boolean goodToGo = true;
8362        if (DEBUG_APP_TRANSITIONS) Slog.v(TAG,
8363                "Checking " + NN + " opening apps (frozen="
8364                + mDisplayFrozen + " timeout="
8365                + mAppTransition.isTimeout() + ")...");
8366        if (!mDisplayFrozen && !mAppTransition.isTimeout()) {
8367            // If the display isn't frozen, wait to do anything until
8368            // all of the apps are ready.  Otherwise just go because
8369            // we'll unfreeze the display when everyone is ready.
8370            for (i=0; i<NN && goodToGo; i++) {
8371                AppWindowToken wtoken = mOpeningApps.get(i);
8372                if (DEBUG_APP_TRANSITIONS) Slog.v(TAG,
8373                        "Check opening app=" + wtoken + ": allDrawn="
8374                        + wtoken.allDrawn + " startingDisplayed="
8375                        + wtoken.startingDisplayed + " startingMoved="
8376                        + wtoken.startingMoved);
8377                if (!wtoken.allDrawn && !wtoken.startingDisplayed
8378                        && !wtoken.startingMoved) {
8379                    goodToGo = false;
8380                }
8381            }
8382        }
8383        if (goodToGo) {
8384            if (DEBUG_APP_TRANSITIONS) Slog.v(TAG, "**** GOOD TO GO");
8385            int transit = mAppTransition.getAppTransition();
8386            if (mSkipAppTransitionAnimation) {
8387                transit = AppTransition.TRANSIT_UNSET;
8388            }
8389            mAppTransition.goodToGo();
8390            mStartingIconInTransition = false;
8391            mSkipAppTransitionAnimation = false;
8392
8393            mH.removeMessages(H.APP_TRANSITION_TIMEOUT);
8394
8395            rebuildAppWindowListLocked();
8396
8397            // if wallpaper is animating in or out set oldWallpaper to null else to wallpaper
8398            WindowState oldWallpaper =
8399                    mWallpaperTarget != null && mWallpaperTarget.mWinAnimator.isAnimating()
8400                        && !mWallpaperTarget.mWinAnimator.isDummyAnimation()
8401                    ? null : mWallpaperTarget;
8402
8403            mInnerFields.mWallpaperMayChange = false;
8404
8405            // The top-most window will supply the layout params,
8406            // and we will determine it below.
8407            LayoutParams animLp = null;
8408            int bestAnimLayer = -1;
8409            boolean fullscreenAnim = false;
8410
8411            if (DEBUG_APP_TRANSITIONS) Slog.v(TAG,
8412                    "New wallpaper target=" + mWallpaperTarget
8413                    + ", oldWallpaper=" + oldWallpaper
8414                    + ", lower target=" + mLowerWallpaperTarget
8415                    + ", upper target=" + mUpperWallpaperTarget);
8416
8417            boolean openingAppHasWallpaper = false;
8418            boolean closingAppHasWallpaper = false;
8419            final AppWindowToken lowerWallpaperAppToken;
8420            final AppWindowToken upperWallpaperAppToken;
8421            if (mLowerWallpaperTarget == null) {
8422                lowerWallpaperAppToken = upperWallpaperAppToken = null;
8423            } else {
8424                lowerWallpaperAppToken = mLowerWallpaperTarget.mAppToken;
8425                upperWallpaperAppToken = mUpperWallpaperTarget.mAppToken;
8426            }
8427
8428            // Do a first pass through the tokens for two
8429            // things:
8430            // (1) Determine if both the closing and opening
8431            // app token sets are wallpaper targets, in which
8432            // case special animations are needed
8433            // (since the wallpaper needs to stay static
8434            // behind them).
8435            // (2) Find the layout params of the top-most
8436            // application window in the tokens, which is
8437            // what will control the animation theme.
8438            final int NC = mClosingApps.size();
8439            NN = NC + mOpeningApps.size();
8440            for (i=0; i<NN; i++) {
8441                final AppWindowToken wtoken;
8442                if (i < NC) {
8443                    wtoken = mClosingApps.get(i);
8444                    if (wtoken == lowerWallpaperAppToken || wtoken == upperWallpaperAppToken) {
8445                        closingAppHasWallpaper = true;
8446                    }
8447                } else {
8448                    wtoken = mOpeningApps.get(i - NC);
8449                    if (wtoken == lowerWallpaperAppToken || wtoken == upperWallpaperAppToken) {
8450                        openingAppHasWallpaper = true;
8451                    }
8452                }
8453
8454                if (wtoken.appFullscreen) {
8455                    WindowState ws = wtoken.findMainWindow();
8456                    if (ws != null) {
8457                        animLp = ws.mAttrs;
8458                        bestAnimLayer = ws.mLayer;
8459                        fullscreenAnim = true;
8460                    }
8461                } else if (!fullscreenAnim) {
8462                    WindowState ws = wtoken.findMainWindow();
8463                    if (ws != null) {
8464                        if (ws.mLayer > bestAnimLayer) {
8465                            animLp = ws.mAttrs;
8466                            bestAnimLayer = ws.mLayer;
8467                        }
8468                    }
8469                }
8470            }
8471
8472            mAnimateWallpaperWithTarget = false;
8473            if (closingAppHasWallpaper && openingAppHasWallpaper) {
8474                if (DEBUG_APP_TRANSITIONS) Slog.v(TAG, "Wallpaper animation!");
8475                switch (transit) {
8476                    case AppTransition.TRANSIT_ACTIVITY_OPEN:
8477                    case AppTransition.TRANSIT_TASK_OPEN:
8478                    case AppTransition.TRANSIT_TASK_TO_FRONT:
8479                        transit = AppTransition.TRANSIT_WALLPAPER_INTRA_OPEN;
8480                        break;
8481                    case AppTransition.TRANSIT_ACTIVITY_CLOSE:
8482                    case AppTransition.TRANSIT_TASK_CLOSE:
8483                    case AppTransition.TRANSIT_TASK_TO_BACK:
8484                        transit = AppTransition.TRANSIT_WALLPAPER_INTRA_CLOSE;
8485                        break;
8486                }
8487                if (DEBUG_APP_TRANSITIONS) Slog.v(TAG, "New transit: " + transit);
8488            } else if ((oldWallpaper != null) && !mOpeningApps.isEmpty()
8489                    && !mOpeningApps.contains(oldWallpaper.mAppToken)) {
8490                // We are transitioning from an activity with
8491                // a wallpaper to one without.
8492                transit = AppTransition.TRANSIT_WALLPAPER_CLOSE;
8493                if (DEBUG_APP_TRANSITIONS) Slog.v(TAG,
8494                        "New transit away from wallpaper: " + transit);
8495            } else if (mWallpaperTarget != null && mWallpaperTarget.isVisibleLw()) {
8496                // We are transitioning from an activity without
8497                // a wallpaper to now showing the wallpaper
8498                transit = AppTransition.TRANSIT_WALLPAPER_OPEN;
8499                if (DEBUG_APP_TRANSITIONS) Slog.v(TAG,
8500                        "New transit into wallpaper: " + transit);
8501            } else {
8502                mAnimateWallpaperWithTarget = true;
8503            }
8504
8505            // If all closing windows are obscured, then there is
8506            // no need to do an animation.  This is the case, for
8507            // example, when this transition is being done behind
8508            // the lock screen.
8509            if (!mPolicy.allowAppAnimationsLw()) {
8510                if (DEBUG_APP_TRANSITIONS) Slog.v(TAG,
8511                        "Animations disallowed by keyguard or dream.");
8512                animLp = null;
8513            }
8514
8515            AppWindowToken topOpeningApp = null;
8516            int topOpeningLayer = 0;
8517
8518            NN = mOpeningApps.size();
8519            for (i=0; i<NN; i++) {
8520                AppWindowToken wtoken = mOpeningApps.get(i);
8521                final AppWindowAnimator appAnimator = wtoken.mAppAnimator;
8522                if (DEBUG_APP_TRANSITIONS) Slog.v(TAG, "Now opening app" + wtoken);
8523                appAnimator.clearThumbnail();
8524                wtoken.inPendingTransaction = false;
8525                appAnimator.animation = null;
8526                setTokenVisibilityLocked(wtoken, animLp, true, transit, false);
8527                wtoken.updateReportedVisibilityLocked();
8528                wtoken.waitingToShow = false;
8529
8530                appAnimator.mAllAppWinAnimators.clear();
8531                final int N = wtoken.allAppWindows.size();
8532                for (int j = 0; j < N; j++) {
8533                    appAnimator.mAllAppWinAnimators.add(wtoken.allAppWindows.get(j).mWinAnimator);
8534                }
8535                mAnimator.mAnimating |= appAnimator.showAllWindowsLocked();
8536
8537                if (animLp != null) {
8538                    int layer = -1;
8539                    for (int j=0; j<wtoken.windows.size(); j++) {
8540                        WindowState win = wtoken.windows.get(j);
8541                        if (win.mWinAnimator.mAnimLayer > layer) {
8542                            layer = win.mWinAnimator.mAnimLayer;
8543                        }
8544                    }
8545                    if (topOpeningApp == null || layer > topOpeningLayer) {
8546                        topOpeningApp = wtoken;
8547                        topOpeningLayer = layer;
8548                    }
8549                }
8550            }
8551            NN = mClosingApps.size();
8552            for (i=0; i<NN; i++) {
8553                AppWindowToken wtoken = mClosingApps.get(i);
8554                if (DEBUG_APP_TRANSITIONS) Slog.v(TAG, "Now closing app " + wtoken);
8555                wtoken.mAppAnimator.clearThumbnail();
8556                wtoken.inPendingTransaction = false;
8557                wtoken.mAppAnimator.animation = null;
8558                setTokenVisibilityLocked(wtoken, animLp, false, transit, false);
8559                wtoken.updateReportedVisibilityLocked();
8560                wtoken.waitingToHide = false;
8561                // Force the allDrawn flag, because we want to start
8562                // this guy's animations regardless of whether it's
8563                // gotten drawn.
8564                wtoken.allDrawn = true;
8565                wtoken.deferClearAllDrawn = false;
8566            }
8567
8568            AppWindowAnimator appAnimator =
8569                    topOpeningApp == null ? null : topOpeningApp.mAppAnimator;
8570            Bitmap nextAppTransitionThumbnail = mAppTransition.getNextAppTransitionThumbnail();
8571            if (nextAppTransitionThumbnail != null && appAnimator != null
8572                    && appAnimator.animation != null) {
8573                // This thumbnail animation is very special, we need to have
8574                // an extra surface with the thumbnail included with the animation.
8575                Rect dirty = new Rect(0, 0, nextAppTransitionThumbnail.getWidth(),
8576                        nextAppTransitionThumbnail.getHeight());
8577                try {
8578                    // TODO(multi-display): support other displays
8579                    final DisplayContent displayContent = getDefaultDisplayContentLocked();
8580                    final Display display = displayContent.getDisplay();
8581                    SurfaceControl surfaceControl = new SurfaceControl(mFxSession,
8582                            "thumbnail anim",
8583                            dirty.width(), dirty.height(),
8584                            PixelFormat.TRANSLUCENT, SurfaceControl.HIDDEN);
8585                    surfaceControl.setLayerStack(display.getLayerStack());
8586                    appAnimator.thumbnail = surfaceControl;
8587                    if (SHOW_TRANSACTIONS) Slog.i(TAG, "  THUMBNAIL " + surfaceControl + ": CREATE");
8588                    Surface drawSurface = new Surface();
8589                    drawSurface.copyFrom(surfaceControl);
8590                    Canvas c = drawSurface.lockCanvas(dirty);
8591                    c.drawBitmap(nextAppTransitionThumbnail, 0, 0, null);
8592                    drawSurface.unlockCanvasAndPost(c);
8593                    drawSurface.release();
8594                    appAnimator.thumbnailLayer = topOpeningLayer;
8595                    DisplayInfo displayInfo = getDefaultDisplayInfoLocked();
8596                    Animation anim = mAppTransition.createThumbnailAnimationLocked(
8597                            transit, true, true, displayInfo.appWidth, displayInfo.appHeight);
8598                    appAnimator.thumbnailAnimation = anim;
8599                    anim.restrictDuration(MAX_ANIMATION_DURATION);
8600                    anim.scaleCurrentDuration(mTransitionAnimationScale);
8601                    Point p = new Point();
8602                    mAppTransition.getStartingPoint(p);
8603                    appAnimator.thumbnailX = p.x;
8604                    appAnimator.thumbnailY = p.y;
8605                } catch (OutOfResourcesException e) {
8606                    Slog.e(TAG, "Can't allocate thumbnail/Canvas surface w=" + dirty.width()
8607                            + " h=" + dirty.height(), e);
8608                    appAnimator.clearThumbnail();
8609                }
8610            }
8611
8612            mAppTransition.postAnimationCallback();
8613            mAppTransition.clear();
8614
8615            mOpeningApps.clear();
8616            mClosingApps.clear();
8617
8618            // This has changed the visibility of windows, so perform
8619            // a new layout to get them all up-to-date.
8620            changes |= WindowManagerPolicy.FINISH_LAYOUT_REDO_LAYOUT
8621                    | WindowManagerPolicy.FINISH_LAYOUT_REDO_CONFIG;
8622            getDefaultDisplayContentLocked().layoutNeeded = true;
8623
8624            // TODO(multidisplay): IMEs are only supported on the default display.
8625            if (windows == getDefaultWindowListLocked()
8626                    && !moveInputMethodWindowsIfNeededLocked(true)) {
8627                assignLayersLocked(windows);
8628            }
8629            updateFocusedWindowLocked(UPDATE_FOCUS_PLACING_SURFACES, false /*updateInputWindows*/);
8630            mFocusMayChange = false;
8631        }
8632
8633        return changes;
8634    }
8635
8636    /**
8637     * Extracted from {@link #performLayoutAndPlaceSurfacesLockedInner} to reduce size of method.
8638     * @return bitmap indicating if another pass through layout must be made.
8639     */
8640    private int handleAnimatingStoppedAndTransitionLocked() {
8641        int changes = 0;
8642
8643        mAppTransition.setIdle();
8644        // Restore window app tokens to the ActivityManager views
8645        final DisplayContent displayContent = getDefaultDisplayContentLocked();
8646        final ArrayList<Task> tasks = displayContent.getTasks();
8647        final int numTasks = tasks.size();
8648        for (int taskNdx = 0; taskNdx < numTasks; ++taskNdx) {
8649            final AppTokenList tokens = tasks.get(taskNdx).mAppTokens;
8650            final int numTokens = tokens.size();
8651            for (int tokenNdx = 0; tokenNdx < numTokens; ++tokenNdx) {
8652                final AppWindowToken wtoken = tokens.get(tokenNdx);
8653                wtoken.sendingToBottom = false;
8654            }
8655        }
8656        rebuildAppWindowListLocked();
8657
8658        changes |= PhoneWindowManager.FINISH_LAYOUT_REDO_LAYOUT;
8659        if (DEBUG_WALLPAPER_LIGHT) Slog.v(TAG,
8660                "Wallpaper layer changed: assigning layers + relayout");
8661        moveInputMethodWindowsIfNeededLocked(true);
8662        mInnerFields.mWallpaperMayChange = true;
8663        // Since the window list has been rebuilt, focus might
8664        // have to be recomputed since the actual order of windows
8665        // might have changed again.
8666        mFocusMayChange = true;
8667
8668        return changes;
8669    }
8670
8671    private void updateResizingWindows(final WindowState w) {
8672        final WindowStateAnimator winAnimator = w.mWinAnimator;
8673        if (w.mHasSurface && w.mLayoutSeq == mLayoutSeq) {
8674            w.setInsetsChanged();
8675            boolean configChanged = w.isConfigChanged();
8676            if (DEBUG_CONFIGURATION && configChanged) {
8677                Slog.v(TAG, "Win " + w + " config changed: "
8678                        + mCurConfiguration);
8679            }
8680            if (localLOGV) Slog.v(TAG, "Resizing " + w
8681                    + ": configChanged=" + configChanged
8682                    + " last=" + w.mLastFrame + " frame=" + w.mFrame);
8683            w.mLastFrame.set(w.mFrame);
8684            if (w.mContentInsetsChanged
8685                    || w.mVisibleInsetsChanged
8686                    || winAnimator.mSurfaceResized
8687                    || configChanged) {
8688                if (DEBUG_RESIZE || DEBUG_ORIENTATION) {
8689                    Slog.v(TAG, "Resize reasons for w=" + w + ": "
8690                            + " contentInsetsChanged=" + w.mContentInsetsChanged
8691                            + " " + w.mContentInsets.toShortString()
8692                            + " visibleInsetsChanged=" + w.mVisibleInsetsChanged
8693                            + " " + w.mVisibleInsets.toShortString()
8694                            + " surfaceResized=" + winAnimator.mSurfaceResized
8695                            + " configChanged=" + configChanged);
8696                }
8697
8698                w.mLastOverscanInsets.set(w.mOverscanInsets);
8699                w.mLastContentInsets.set(w.mContentInsets);
8700                w.mLastVisibleInsets.set(w.mVisibleInsets);
8701                makeWindowFreezingScreenIfNeededLocked(w);
8702                // If the orientation is changing, then we need to
8703                // hold off on unfreezing the display until this
8704                // window has been redrawn; to do that, we need
8705                // to go through the process of getting informed
8706                // by the application when it has finished drawing.
8707                if (w.mOrientationChanging) {
8708                    if (DEBUG_SURFACE_TRACE || DEBUG_ANIM || DEBUG_ORIENTATION) Slog.v(TAG,
8709                            "Orientation start waiting for draw mDrawState=DRAW_PENDING in "
8710                            + w + ", surface " + winAnimator.mSurfaceControl);
8711                    winAnimator.mDrawState = WindowStateAnimator.DRAW_PENDING;
8712                    if (w.mAppToken != null) {
8713                        w.mAppToken.allDrawn = false;
8714                        w.mAppToken.deferClearAllDrawn = false;
8715                    }
8716                }
8717                if (!mResizingWindows.contains(w)) {
8718                    if (DEBUG_RESIZE || DEBUG_ORIENTATION) Slog.v(TAG,
8719                            "Resizing window " + w + " to " + winAnimator.mSurfaceW
8720                            + "x" + winAnimator.mSurfaceH);
8721                    mResizingWindows.add(w);
8722                }
8723            } else if (w.mOrientationChanging) {
8724                if (w.isDrawnLw()) {
8725                    if (DEBUG_ORIENTATION) Slog.v(TAG,
8726                            "Orientation not waiting for draw in "
8727                            + w + ", surface " + winAnimator.mSurfaceControl);
8728                    w.mOrientationChanging = false;
8729                    w.mLastFreezeDuration = (int)(SystemClock.elapsedRealtime()
8730                            - mDisplayFreezeTime);
8731                }
8732            }
8733        }
8734    }
8735
8736    /**
8737     * Extracted from {@link #performLayoutAndPlaceSurfacesLockedInner} to reduce size of method.
8738     *
8739     * @param w WindowState this method is applied to.
8740     * @param currentTime The time which animations use for calculating transitions.
8741     * @param innerDw Width of app window.
8742     * @param innerDh Height of app window.
8743     */
8744    private void handleNotObscuredLocked(final WindowState w, final long currentTime,
8745                                         final int innerDw, final int innerDh) {
8746        final WindowManager.LayoutParams attrs = w.mAttrs;
8747        final int attrFlags = attrs.flags;
8748        final boolean canBeSeen = w.isDisplayedLw();
8749        final boolean opaqueDrawn = canBeSeen && w.isOpaqueDrawn();
8750
8751        if (opaqueDrawn && w.isFullscreen(innerDw, innerDh)) {
8752            // This window completely covers everything behind it,
8753            // so we want to leave all of them as undimmed (for
8754            // performance reasons).
8755            mInnerFields.mObscured = true;
8756        }
8757
8758        if (w.mHasSurface) {
8759            if ((attrFlags&FLAG_KEEP_SCREEN_ON) != 0) {
8760                mInnerFields.mHoldScreen = w.mSession;
8761            }
8762            if (!mInnerFields.mSyswin && w.mAttrs.screenBrightness >= 0
8763                    && mInnerFields.mScreenBrightness < 0) {
8764                mInnerFields.mScreenBrightness = w.mAttrs.screenBrightness;
8765            }
8766            if (!mInnerFields.mSyswin && w.mAttrs.buttonBrightness >= 0
8767                    && mInnerFields.mButtonBrightness < 0) {
8768                mInnerFields.mButtonBrightness = w.mAttrs.buttonBrightness;
8769            }
8770            if (!mInnerFields.mSyswin && w.mAttrs.userActivityTimeout >= 0
8771                    && mInnerFields.mUserActivityTimeout < 0) {
8772                mInnerFields.mUserActivityTimeout = w.mAttrs.userActivityTimeout;
8773            }
8774
8775            final int type = attrs.type;
8776            if (canBeSeen
8777                    && (type == TYPE_SYSTEM_DIALOG
8778                     || type == TYPE_RECENTS_OVERLAY
8779                     || type == TYPE_KEYGUARD
8780                     || type == TYPE_SYSTEM_ERROR)) {
8781                mInnerFields.mSyswin = true;
8782            }
8783
8784            if (canBeSeen) {
8785                // This function assumes that the contents of the default display are
8786                // processed first before secondary displays.
8787                final DisplayContent displayContent = w.mDisplayContent;
8788                if (displayContent.isDefaultDisplay) {
8789                    // While a dream or keyguard is showing, obscure ordinary application
8790                    // content on secondary displays (by forcibly enabling mirroring unless
8791                    // there is other content we want to show) but still allow opaque
8792                    // keyguard dialogs to be shown.
8793                    if (type == TYPE_DREAM || type == TYPE_KEYGUARD) {
8794                        mInnerFields.mObscureApplicationContentOnSecondaryDisplays = true;
8795                    }
8796                    mInnerFields.mDisplayHasContent = true;
8797                } else if (!mInnerFields.mObscureApplicationContentOnSecondaryDisplays
8798                        || (mInnerFields.mObscured && type == TYPE_KEYGUARD_DIALOG)) {
8799                    // Allow full screen keyguard presentation dialogs to be seen.
8800                    mInnerFields.mDisplayHasContent = true;
8801                }
8802            }
8803        }
8804    }
8805
8806    private void handleFlagDimBehind(WindowState w, int innerDw, int innerDh) {
8807        final WindowManager.LayoutParams attrs = w.mAttrs;
8808        if ((attrs.flags & FLAG_DIM_BEHIND) != 0
8809                && w.isDisplayedLw()
8810                && !w.mExiting) {
8811            final WindowStateAnimator winAnimator = w.mWinAnimator;
8812            final TaskStack stack = w.getStack();
8813            stack.setDimmingTag();
8814            if (!stack.isDimming(winAnimator)) {
8815                if (localLOGV) Slog.v(TAG, "Win " + w + " start dimming.");
8816                stack.startDimmingIfNeeded(winAnimator);
8817            }
8818        }
8819    }
8820
8821    private void updateAllDrawnLocked(DisplayContent displayContent) {
8822        // See if any windows have been drawn, so they (and others
8823        // associated with them) can now be shown.
8824        final ArrayList<Task> tasks = displayContent.getTasks();
8825        final int numTasks = tasks.size();
8826        for (int taskNdx = 0; taskNdx < numTasks; ++taskNdx) {
8827            final AppTokenList tokens = tasks.get(taskNdx).mAppTokens;
8828            final int numTokens = tokens.size();
8829            for (int tokenNdx = 0; tokenNdx < numTokens; ++tokenNdx) {
8830                final AppWindowToken wtoken = tokens.get(tokenNdx);
8831                if (!wtoken.allDrawn) {
8832                    int numInteresting = wtoken.numInterestingWindows;
8833                    if (numInteresting > 0 && wtoken.numDrawnWindows >= numInteresting) {
8834                        if (DEBUG_VISIBILITY) Slog.v(TAG,
8835                                "allDrawn: " + wtoken
8836                                + " interesting=" + numInteresting
8837                                + " drawn=" + wtoken.numDrawnWindows);
8838                        wtoken.allDrawn = true;
8839                        mH.obtainMessage(H.NOTIFY_ACTIVITY_DRAWN, wtoken.token).sendToTarget();
8840                    }
8841                }
8842            }
8843        }
8844    }
8845
8846    // "Something has changed!  Let's make it correct now."
8847    private final void performLayoutAndPlaceSurfacesLockedInner(boolean recoveringMemory) {
8848        if (DEBUG_WINDOW_TRACE) {
8849            Slog.v(TAG, "performLayoutAndPlaceSurfacesLockedInner: entry. Called by "
8850                    + Debug.getCallers(3));
8851        }
8852
8853        final long currentTime = SystemClock.uptimeMillis();
8854
8855        int i;
8856
8857        if (mFocusMayChange) {
8858            mFocusMayChange = false;
8859            updateFocusedWindowLocked(UPDATE_FOCUS_WILL_PLACE_SURFACES,
8860                    false /*updateInputWindows*/);
8861        }
8862
8863        // Initialize state of exiting tokens.
8864        final int numDisplays = mDisplayContents.size();
8865        for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) {
8866            final DisplayContent displayContent = mDisplayContents.valueAt(displayNdx);
8867            for (i=displayContent.mExitingTokens.size()-1; i>=0; i--) {
8868                displayContent.mExitingTokens.get(i).hasVisible = false;
8869            }
8870
8871            // Initialize state of exiting applications.
8872            for (i=displayContent.mExitingAppTokens.size()-1; i>=0; i--) {
8873                displayContent.mExitingAppTokens.get(i).hasVisible = false;
8874            }
8875        }
8876
8877        mInnerFields.mHoldScreen = null;
8878        mInnerFields.mScreenBrightness = -1;
8879        mInnerFields.mButtonBrightness = -1;
8880        mInnerFields.mUserActivityTimeout = -1;
8881        mInnerFields.mObscureApplicationContentOnSecondaryDisplays = false;
8882
8883        mTransactionSequence++;
8884
8885        final DisplayContent defaultDisplay = getDefaultDisplayContentLocked();
8886        final DisplayInfo defaultInfo = defaultDisplay.getDisplayInfo();
8887        final int defaultDw = defaultInfo.logicalWidth;
8888        final int defaultDh = defaultInfo.logicalHeight;
8889
8890        if (SHOW_LIGHT_TRANSACTIONS) Slog.i(TAG,
8891                ">>> OPEN TRANSACTION performLayoutAndPlaceSurfaces");
8892        SurfaceControl.openTransaction();
8893        try {
8894
8895            if (mWatermark != null) {
8896                mWatermark.positionSurface(defaultDw, defaultDh);
8897            }
8898            if (mStrictModeFlash != null) {
8899                mStrictModeFlash.positionSurface(defaultDw, defaultDh);
8900            }
8901
8902            boolean focusDisplayed = false;
8903
8904            for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) {
8905                final DisplayContent displayContent = mDisplayContents.valueAt(displayNdx);
8906                boolean updateAllDrawn = false;
8907                WindowList windows = displayContent.getWindowList();
8908                DisplayInfo displayInfo = displayContent.getDisplayInfo();
8909                final int displayId = displayContent.getDisplayId();
8910                final int dw = displayInfo.logicalWidth;
8911                final int dh = displayInfo.logicalHeight;
8912                final int innerDw = displayInfo.appWidth;
8913                final int innerDh = displayInfo.appHeight;
8914                final boolean isDefaultDisplay = (displayId == Display.DEFAULT_DISPLAY);
8915
8916                // Reset for each display.
8917                mInnerFields.mDisplayHasContent = false;
8918
8919                int repeats = 0;
8920                do {
8921                    repeats++;
8922                    if (repeats > 6) {
8923                        Slog.w(TAG, "Animation repeat aborted after too many iterations");
8924                        displayContent.layoutNeeded = false;
8925                        break;
8926                    }
8927
8928                    if (DEBUG_LAYOUT_REPEATS) debugLayoutRepeats("On entry to LockedInner",
8929                        displayContent.pendingLayoutChanges);
8930
8931                    if ((displayContent.pendingLayoutChanges &
8932                            WindowManagerPolicy.FINISH_LAYOUT_REDO_WALLPAPER) != 0 &&
8933                            (adjustWallpaperWindowsLocked() &
8934                                    ADJUST_WALLPAPER_LAYERS_CHANGED) != 0) {
8935                        assignLayersLocked(windows);
8936                        displayContent.layoutNeeded = true;
8937                    }
8938
8939                    if (isDefaultDisplay && (displayContent.pendingLayoutChanges
8940                            & WindowManagerPolicy.FINISH_LAYOUT_REDO_CONFIG) != 0) {
8941                        if (DEBUG_LAYOUT) Slog.v(TAG, "Computing new config from layout");
8942                        if (updateOrientationFromAppTokensLocked(true)) {
8943                            displayContent.layoutNeeded = true;
8944                            mH.sendEmptyMessage(H.SEND_NEW_CONFIGURATION);
8945                        }
8946                    }
8947
8948                    if ((displayContent.pendingLayoutChanges
8949                            & WindowManagerPolicy.FINISH_LAYOUT_REDO_LAYOUT) != 0) {
8950                        displayContent.layoutNeeded = true;
8951                    }
8952
8953                    // FIRST LOOP: Perform a layout, if needed.
8954                    if (repeats < 4) {
8955                        performLayoutLockedInner(displayContent, repeats == 1,
8956                                false /*updateInputWindows*/);
8957                    } else {
8958                        Slog.w(TAG, "Layout repeat skipped after too many iterations");
8959                    }
8960
8961                    // FIRST AND ONE HALF LOOP: Make WindowManagerPolicy think
8962                    // it is animating.
8963                    displayContent.pendingLayoutChanges = 0;
8964
8965                    if (DEBUG_LAYOUT_REPEATS) debugLayoutRepeats("loop number "
8966                            + mLayoutRepeatCount, displayContent.pendingLayoutChanges);
8967
8968                    if (isDefaultDisplay) {
8969                        mPolicy.beginPostLayoutPolicyLw(dw, dh);
8970                        for (i = windows.size() - 1; i >= 0; i--) {
8971                            WindowState w = windows.get(i);
8972                            if (w.mHasSurface) {
8973                                mPolicy.applyPostLayoutPolicyLw(w, w.mAttrs);
8974                            }
8975                        }
8976                        displayContent.pendingLayoutChanges |= mPolicy.finishPostLayoutPolicyLw();
8977                        if (DEBUG_LAYOUT_REPEATS) debugLayoutRepeats(
8978                            "after finishPostLayoutPolicyLw", displayContent.pendingLayoutChanges);
8979                    }
8980                } while (displayContent.pendingLayoutChanges != 0);
8981
8982                mInnerFields.mObscured = false;
8983                mInnerFields.mSyswin = false;
8984                displayContent.resetDimming();
8985
8986                // Only used if default window
8987                final boolean someoneLosingFocus = !mLosingFocus.isEmpty();
8988
8989                final int N = windows.size();
8990                for (i=N-1; i>=0; i--) {
8991                    WindowState w = windows.get(i);
8992                    final TaskStack stack = w.getStack();
8993                    if (stack == null) {
8994                        continue;
8995                    }
8996
8997                    final boolean obscuredChanged = w.mObscured != mInnerFields.mObscured;
8998
8999                    // Update effect.
9000                    w.mObscured = mInnerFields.mObscured;
9001                    if (!mInnerFields.mObscured) {
9002                        handleNotObscuredLocked(w, currentTime, innerDw, innerDh);
9003                    }
9004
9005                    if (!stack.testDimmingTag()) {
9006                        handleFlagDimBehind(w, innerDw, innerDh);
9007                    }
9008
9009                    if (isDefaultDisplay && obscuredChanged && (mWallpaperTarget == w)
9010                            && w.isVisibleLw()) {
9011                        // This is the wallpaper target and its obscured state
9012                        // changed... make sure the current wallaper's visibility
9013                        // has been updated accordingly.
9014                        updateWallpaperVisibilityLocked();
9015                    }
9016
9017                    final WindowStateAnimator winAnimator = w.mWinAnimator;
9018
9019                    // If the window has moved due to its containing
9020                    // content frame changing, then we'd like to animate
9021                    // it.
9022                    if (w.mHasSurface && w.shouldAnimateMove()) {
9023                        // Frame has moved, containing content frame
9024                        // has also moved, and we're not currently animating...
9025                        // let's do something.
9026                        Animation a = AnimationUtils.loadAnimation(mContext,
9027                                com.android.internal.R.anim.window_move_from_decor);
9028                        winAnimator.setAnimation(a);
9029                        winAnimator.mAnimDw = w.mLastFrame.left - w.mFrame.left;
9030                        winAnimator.mAnimDh = w.mLastFrame.top - w.mFrame.top;
9031                        try {
9032                            w.mClient.moved(w.mFrame.left, w.mFrame.top);
9033                        } catch (RemoteException e) {
9034                        }
9035                    }
9036
9037                    //Slog.i(TAG, "Window " + this + " clearing mContentChanged - done placing");
9038                    w.mContentChanged = false;
9039
9040                    // Moved from updateWindowsAndWallpaperLocked().
9041                    if (w.mHasSurface) {
9042                        // Take care of the window being ready to display.
9043                        final boolean committed =
9044                                winAnimator.commitFinishDrawingLocked(currentTime);
9045                        if (isDefaultDisplay && committed) {
9046                            if (w.mAttrs.type == TYPE_DREAM) {
9047                                // HACK: When a dream is shown, it may at that
9048                                // point hide the lock screen.  So we need to
9049                                // redo the layout to let the phone window manager
9050                                // make this happen.
9051                                displayContent.pendingLayoutChanges |=
9052                                        WindowManagerPolicy.FINISH_LAYOUT_REDO_LAYOUT;
9053                                if (DEBUG_LAYOUT_REPEATS) {
9054                                    debugLayoutRepeats(
9055                                        "dream and commitFinishDrawingLocked true",
9056                                        displayContent.pendingLayoutChanges);
9057                                }
9058                            }
9059                            if ((w.mAttrs.flags & FLAG_SHOW_WALLPAPER) != 0) {
9060                                if (DEBUG_WALLPAPER_LIGHT) Slog.v(TAG,
9061                                        "First draw done in potential wallpaper target " + w);
9062                                mInnerFields.mWallpaperMayChange = true;
9063                                displayContent.pendingLayoutChanges |=
9064                                        WindowManagerPolicy.FINISH_LAYOUT_REDO_WALLPAPER;
9065                                if (DEBUG_LAYOUT_REPEATS) {
9066                                    debugLayoutRepeats(
9067                                        "wallpaper and commitFinishDrawingLocked true",
9068                                        displayContent.pendingLayoutChanges);
9069                                }
9070                            }
9071                        }
9072
9073                        winAnimator.setSurfaceBoundariesLocked(recoveringMemory);
9074
9075                        final AppWindowToken atoken = w.mAppToken;
9076                        if (DEBUG_STARTING_WINDOW && atoken != null
9077                                && w == atoken.startingWindow) {
9078                            Slog.d(TAG, "updateWindows: starting " + w + " isOnScreen="
9079                                + w.isOnScreen() + " allDrawn=" + atoken.allDrawn
9080                                + " freezingScreen=" + atoken.mAppAnimator.freezingScreen);
9081                        }
9082                        if (atoken != null
9083                                && (!atoken.allDrawn || atoken.mAppAnimator.freezingScreen)) {
9084                            if (atoken.lastTransactionSequence != mTransactionSequence) {
9085                                atoken.lastTransactionSequence = mTransactionSequence;
9086                                atoken.numInterestingWindows = atoken.numDrawnWindows = 0;
9087                                atoken.startingDisplayed = false;
9088                            }
9089                            if ((w.isOnScreen() || winAnimator.mAttrType == TYPE_BASE_APPLICATION)
9090                                    && !w.mExiting && !w.mDestroying) {
9091                                if (DEBUG_VISIBILITY || DEBUG_ORIENTATION) {
9092                                    Slog.v(TAG, "Eval win " + w + ": isDrawn=" + w.isDrawnLw()
9093                                            + ", isAnimating=" + winAnimator.isAnimating());
9094                                    if (!w.isDrawnLw()) {
9095                                        Slog.v(TAG, "Not displayed: s=" + winAnimator.mSurfaceControl
9096                                                + " pv=" + w.mPolicyVisibility
9097                                                + " mDrawState=" + winAnimator.mDrawState
9098                                                + " ah=" + w.mAttachedHidden
9099                                                + " th=" + atoken.hiddenRequested
9100                                                + " a=" + winAnimator.mAnimating);
9101                                    }
9102                                }
9103                                if (w != atoken.startingWindow) {
9104                                    if (!atoken.mAppAnimator.freezingScreen || !w.mAppFreezing) {
9105                                        atoken.numInterestingWindows++;
9106                                        if (w.isDrawnLw()) {
9107                                            atoken.numDrawnWindows++;
9108                                            if (DEBUG_VISIBILITY || DEBUG_ORIENTATION) Slog.v(TAG,
9109                                                    "tokenMayBeDrawn: " + atoken
9110                                                    + " freezingScreen=" + atoken.mAppAnimator.freezingScreen
9111                                                    + " mAppFreezing=" + w.mAppFreezing);
9112                                            updateAllDrawn = true;
9113                                        }
9114                                    }
9115                                } else if (w.isDrawnLw()) {
9116                                    atoken.startingDisplayed = true;
9117                                }
9118                            }
9119                        }
9120                    }
9121
9122                    if (isDefaultDisplay && someoneLosingFocus && (w == mCurrentFocus)
9123                            && w.isDisplayedLw()) {
9124                        focusDisplayed = true;
9125                    }
9126
9127                    updateResizingWindows(w);
9128                }
9129
9130                mDisplayManagerService.setDisplayHasContent(displayId,
9131                        mInnerFields.mDisplayHasContent,
9132                        true /* inTraversal, must call performTraversalInTrans... below */);
9133
9134                getDisplayContentLocked(displayId).stopDimmingIfNeeded();
9135
9136                if (updateAllDrawn) {
9137                    updateAllDrawnLocked(displayContent);
9138                }
9139            }
9140
9141            if (focusDisplayed) {
9142                mH.sendEmptyMessage(H.REPORT_LOSING_FOCUS);
9143            }
9144
9145            // Give the display manager a chance to adjust properties
9146            // like display rotation if it needs to.
9147            mDisplayManagerService.performTraversalInTransactionFromWindowManager();
9148
9149        } catch (RuntimeException e) {
9150            Log.wtf(TAG, "Unhandled exception in Window Manager", e);
9151        } finally {
9152            SurfaceControl.closeTransaction();
9153            if (SHOW_LIGHT_TRANSACTIONS) Slog.i(TAG,
9154                    "<<< CLOSE TRANSACTION performLayoutAndPlaceSurfaces");
9155        }
9156
9157        final WindowList defaultWindows = defaultDisplay.getWindowList();
9158
9159        // If we are ready to perform an app transition, check through
9160        // all of the app tokens to be shown and see if they are ready
9161        // to go.
9162        if (mAppTransition.isReady()) {
9163            defaultDisplay.pendingLayoutChanges |= handleAppTransitionReadyLocked(defaultWindows);
9164            if (DEBUG_LAYOUT_REPEATS) debugLayoutRepeats("after handleAppTransitionReadyLocked",
9165                    defaultDisplay.pendingLayoutChanges);
9166        }
9167
9168        if (!mAnimator.mAnimating && mAppTransition.isRunning()) {
9169            // We have finished the animation of an app transition.  To do
9170            // this, we have delayed a lot of operations like showing and
9171            // hiding apps, moving apps in Z-order, etc.  The app token list
9172            // reflects the correct Z-order, but the window list may now
9173            // be out of sync with it.  So here we will just rebuild the
9174            // entire app window list.  Fun!
9175            defaultDisplay.pendingLayoutChanges |= handleAnimatingStoppedAndTransitionLocked();
9176            if (DEBUG_LAYOUT_REPEATS) debugLayoutRepeats("after handleAnimStopAndXitionLock",
9177                defaultDisplay.pendingLayoutChanges);
9178        }
9179
9180        if (mInnerFields.mWallpaperForceHidingChanged && defaultDisplay.pendingLayoutChanges == 0
9181                && !mAppTransition.isReady()) {
9182            // At this point, there was a window with a wallpaper that
9183            // was force hiding other windows behind it, but now it
9184            // is going away.  This may be simple -- just animate
9185            // away the wallpaper and its window -- or it may be
9186            // hard -- the wallpaper now needs to be shown behind
9187            // something that was hidden.
9188            defaultDisplay.pendingLayoutChanges |= WindowManagerPolicy.FINISH_LAYOUT_REDO_LAYOUT;
9189            if (DEBUG_LAYOUT_REPEATS) debugLayoutRepeats("after animateAwayWallpaperLocked",
9190                defaultDisplay.pendingLayoutChanges);
9191        }
9192        mInnerFields.mWallpaperForceHidingChanged = false;
9193
9194        if (mInnerFields.mWallpaperMayChange) {
9195            if (DEBUG_WALLPAPER_LIGHT) Slog.v(TAG, "Wallpaper may change!  Adjusting");
9196            defaultDisplay.pendingLayoutChanges |=
9197                    WindowManagerPolicy.FINISH_LAYOUT_REDO_WALLPAPER;
9198            if (DEBUG_LAYOUT_REPEATS) debugLayoutRepeats("WallpaperMayChange",
9199                    defaultDisplay.pendingLayoutChanges);
9200        }
9201
9202        if (mFocusMayChange) {
9203            mFocusMayChange = false;
9204            if (updateFocusedWindowLocked(UPDATE_FOCUS_PLACING_SURFACES,
9205                    false /*updateInputWindows*/)) {
9206                defaultDisplay.pendingLayoutChanges |= WindowManagerPolicy.FINISH_LAYOUT_REDO_ANIM;
9207            }
9208        }
9209
9210        if (needsLayout()) {
9211            defaultDisplay.pendingLayoutChanges |= WindowManagerPolicy.FINISH_LAYOUT_REDO_LAYOUT;
9212            if (DEBUG_LAYOUT_REPEATS) debugLayoutRepeats("mLayoutNeeded",
9213                    defaultDisplay.pendingLayoutChanges);
9214        }
9215
9216        for (i = mResizingWindows.size() - 1; i >= 0; i--) {
9217            WindowState win = mResizingWindows.get(i);
9218            if (win.mAppFreezing) {
9219                // Don't remove this window until rotation has completed.
9220                continue;
9221            }
9222            final WindowStateAnimator winAnimator = win.mWinAnimator;
9223            try {
9224                if (DEBUG_RESIZE || DEBUG_ORIENTATION) Slog.v(TAG,
9225                        "Reporting new frame to " + win + ": " + win.mCompatFrame);
9226                int diff = 0;
9227                boolean configChanged = win.isConfigChanged();
9228                if ((DEBUG_RESIZE || DEBUG_ORIENTATION || DEBUG_CONFIGURATION)
9229                        && configChanged) {
9230                    Slog.i(TAG, "Sending new config to window " + win + ": "
9231                            + winAnimator.mSurfaceW + "x" + winAnimator.mSurfaceH
9232                            + " / " + mCurConfiguration + " / 0x"
9233                            + Integer.toHexString(diff));
9234                }
9235                win.setConfiguration(mCurConfiguration);
9236                if (DEBUG_ORIENTATION &&
9237                        winAnimator.mDrawState == WindowStateAnimator.DRAW_PENDING) Slog.i(
9238                        TAG, "Resizing " + win + " WITH DRAW PENDING");
9239                final IWindow client = win.mClient;
9240                final Rect frame = win.mFrame;
9241                final Rect overscanInsets = win.mLastOverscanInsets;
9242                final Rect contentInsets = win.mLastContentInsets;
9243                final Rect visibleInsets = win.mLastVisibleInsets;
9244                final boolean reportDraw
9245                        = winAnimator.mDrawState == WindowStateAnimator.DRAW_PENDING;
9246                final Configuration newConfig = configChanged ? win.mConfiguration : null;
9247                if (win.mClient instanceof IWindow.Stub) {
9248                    // To prevent deadlock simulate one-way call if win.mClient is a local object.
9249                    mH.post(new Runnable() {
9250                        @Override
9251                        public void run() {
9252                            try {
9253                                client.resized(frame, overscanInsets, contentInsets,
9254                                        visibleInsets, reportDraw, newConfig);
9255                            } catch (RemoteException e) {
9256                                // Not a remote call, RemoteException won't be raised.
9257                            }
9258                        }
9259                    });
9260                } else {
9261                   client.resized(frame, overscanInsets, contentInsets, visibleInsets, reportDraw,
9262                           newConfig);
9263                }
9264                win.mOverscanInsetsChanged = false;
9265                win.mContentInsetsChanged = false;
9266                win.mVisibleInsetsChanged = false;
9267                winAnimator.mSurfaceResized = false;
9268            } catch (RemoteException e) {
9269                win.mOrientationChanging = false;
9270                win.mLastFreezeDuration = (int)(SystemClock.elapsedRealtime()
9271                        - mDisplayFreezeTime);
9272            }
9273            mResizingWindows.remove(i);
9274        }
9275
9276        if (DEBUG_ORIENTATION && mDisplayFrozen) Slog.v(TAG,
9277                "With display frozen, orientationChangeComplete="
9278                + mInnerFields.mOrientationChangeComplete);
9279        if (mInnerFields.mOrientationChangeComplete) {
9280            if (mWindowsFreezingScreen) {
9281                mWindowsFreezingScreen = false;
9282                mLastFinishedFreezeSource = mInnerFields.mLastWindowFreezeSource;
9283                mH.removeMessages(H.WINDOW_FREEZE_TIMEOUT);
9284            }
9285            stopFreezingDisplayLocked();
9286        }
9287
9288        // Destroy the surface of any windows that are no longer visible.
9289        boolean wallpaperDestroyed = false;
9290        i = mDestroySurface.size();
9291        if (i > 0) {
9292            do {
9293                i--;
9294                WindowState win = mDestroySurface.get(i);
9295                win.mDestroying = false;
9296                if (mInputMethodWindow == win) {
9297                    mInputMethodWindow = null;
9298                }
9299                if (win == mWallpaperTarget) {
9300                    wallpaperDestroyed = true;
9301                }
9302                win.mWinAnimator.destroySurfaceLocked();
9303            } while (i > 0);
9304            mDestroySurface.clear();
9305        }
9306
9307        // Time to remove any exiting tokens?
9308        for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) {
9309            final DisplayContent displayContent = mDisplayContents.valueAt(displayNdx);
9310            ArrayList<WindowToken> exitingTokens = displayContent.mExitingTokens;
9311            for (i = exitingTokens.size() - 1; i >= 0; i--) {
9312                WindowToken token = exitingTokens.get(i);
9313                if (!token.hasVisible) {
9314                    exitingTokens.remove(i);
9315                    if (token.windowType == TYPE_WALLPAPER) {
9316                        mWallpaperTokens.remove(token);
9317                    }
9318                }
9319            }
9320
9321            // Time to remove any exiting applications?
9322            AppTokenList exitingAppTokens = displayContent.mExitingAppTokens;
9323            for (i = exitingAppTokens.size() - 1; i >= 0; i--) {
9324                AppWindowToken token = exitingAppTokens.get(i);
9325                if (!token.hasVisible && !mClosingApps.contains(token)) {
9326                    // Make sure there is no animation running on this token,
9327                    // so any windows associated with it will be removed as
9328                    // soon as their animations are complete
9329                    token.mAppAnimator.clearAnimation();
9330                    token.mAppAnimator.animating = false;
9331                    if (DEBUG_ADD_REMOVE || DEBUG_TOKEN_MOVEMENT) Slog.v(TAG,
9332                            "performLayout: App token exiting now removed" + token);
9333                    final Task task = mTaskIdToTask.get(token.groupId);
9334                    if (task != null && task.removeAppToken(token)) {
9335                        mTaskIdToTask.delete(token.groupId);
9336                    }
9337                    exitingAppTokens.remove(i);
9338                }
9339            }
9340        }
9341
9342        if (!mAnimator.mAnimating && mRelayoutWhileAnimating.size() > 0) {
9343            for (int j=mRelayoutWhileAnimating.size()-1; j>=0; j--) {
9344                try {
9345                    mRelayoutWhileAnimating.get(j).mClient.doneAnimating();
9346                } catch (RemoteException e) {
9347                }
9348            }
9349            mRelayoutWhileAnimating.clear();
9350        }
9351
9352        if (wallpaperDestroyed) {
9353            defaultDisplay.pendingLayoutChanges |=
9354                    WindowManagerPolicy.FINISH_LAYOUT_REDO_WALLPAPER;
9355            defaultDisplay.layoutNeeded = true;
9356        }
9357
9358        for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) {
9359            final DisplayContent displayContent = mDisplayContents.valueAt(displayNdx);
9360            if (displayContent.pendingLayoutChanges != 0) {
9361                displayContent.layoutNeeded = true;
9362            }
9363        }
9364
9365        // Finally update all input windows now that the window changes have stabilized.
9366        mInputMonitor.updateInputWindowsLw(true /*force*/);
9367
9368        setHoldScreenLocked(mInnerFields.mHoldScreen);
9369        if (!mDisplayFrozen) {
9370            if (mInnerFields.mScreenBrightness < 0 || mInnerFields.mScreenBrightness > 1.0f) {
9371                mPowerManager.setScreenBrightnessOverrideFromWindowManager(-1);
9372            } else {
9373                mPowerManager.setScreenBrightnessOverrideFromWindowManager(
9374                        toBrightnessOverride(mInnerFields.mScreenBrightness));
9375            }
9376            if (mInnerFields.mButtonBrightness < 0 || mInnerFields.mButtonBrightness > 1.0f) {
9377                mPowerManager.setButtonBrightnessOverrideFromWindowManager(-1);
9378            } else {
9379                mPowerManager.setButtonBrightnessOverrideFromWindowManager(
9380                        toBrightnessOverride(mInnerFields.mButtonBrightness));
9381            }
9382            mPowerManager.setUserActivityTimeoutOverrideFromWindowManager(
9383                    mInnerFields.mUserActivityTimeout);
9384        }
9385
9386        if (mTurnOnScreen) {
9387            if (DEBUG_VISIBILITY) Slog.v(TAG, "Turning screen on after layout!");
9388            mPowerManager.wakeUp(SystemClock.uptimeMillis());
9389            mTurnOnScreen = false;
9390        }
9391
9392        if (mInnerFields.mUpdateRotation) {
9393            if (DEBUG_ORIENTATION) Slog.d(TAG, "Performing post-rotate rotation");
9394            if (updateRotationUncheckedLocked(false)) {
9395                mH.sendEmptyMessage(H.SEND_NEW_CONFIGURATION);
9396            } else {
9397                mInnerFields.mUpdateRotation = false;
9398            }
9399        }
9400
9401        if (mInnerFields.mOrientationChangeComplete && !defaultDisplay.layoutNeeded
9402                && !mInnerFields.mUpdateRotation) {
9403            checkDrawnWindowsLocked();
9404        }
9405
9406        final int N = mPendingRemove.size();
9407        if (N > 0) {
9408            if (mPendingRemoveTmp.length < N) {
9409                mPendingRemoveTmp = new WindowState[N+10];
9410            }
9411            mPendingRemove.toArray(mPendingRemoveTmp);
9412            mPendingRemove.clear();
9413            DisplayContentList displayList = new DisplayContentList();
9414            for (i = 0; i < N; i++) {
9415                WindowState w = mPendingRemoveTmp[i];
9416                removeWindowInnerLocked(w.mSession, w);
9417                if (!displayList.contains(w.mDisplayContent)) {
9418                    displayList.add(w.mDisplayContent);
9419                }
9420            }
9421
9422            for (DisplayContent displayContent : displayList) {
9423                assignLayersLocked(displayContent.getWindowList());
9424                displayContent.layoutNeeded = true;
9425            }
9426        }
9427
9428        setFocusedStackFrame();
9429
9430        // Check to see if we are now in a state where the screen should
9431        // be enabled, because the window obscured flags have changed.
9432        enableScreenIfNeededLocked();
9433
9434        scheduleAnimationLocked();
9435
9436        if (DEBUG_WINDOW_TRACE) {
9437            Slog.e(TAG, "performLayoutAndPlaceSurfacesLockedInner exit: animating="
9438                    + mAnimator.mAnimating);
9439        }
9440    }
9441
9442    private int toBrightnessOverride(float value) {
9443        return (int)(value * PowerManager.BRIGHTNESS_ON);
9444    }
9445
9446    void checkDrawnWindowsLocked() {
9447        if (mWaitingForDrawn.size() > 0) {
9448            for (int j=mWaitingForDrawn.size()-1; j>=0; j--) {
9449                Pair<WindowState, IRemoteCallback> pair = mWaitingForDrawn.get(j);
9450                WindowState win = pair.first;
9451                //Slog.i(TAG, "Waiting for drawn " + win + ": removed="
9452                //        + win.mRemoved + " visible=" + win.isVisibleLw()
9453                //        + " shown=" + win.mSurfaceShown);
9454                if (win.mRemoved) {
9455                    // Window has been removed; no draw will now happen, so stop waiting.
9456                    Slog.w(TAG, "Aborted waiting for drawn: " + pair.first);
9457                    try {
9458                        pair.second.sendResult(null);
9459                    } catch (RemoteException e) {
9460                    }
9461                    mWaitingForDrawn.remove(pair);
9462                    mH.removeMessages(H.WAITING_FOR_DRAWN_TIMEOUT, pair);
9463                } else if (win.mWinAnimator.mSurfaceShown) {
9464                    // Window is now drawn (and shown).
9465                    try {
9466                        pair.second.sendResult(null);
9467                    } catch (RemoteException e) {
9468                    }
9469                    mWaitingForDrawn.remove(pair);
9470                    mH.removeMessages(H.WAITING_FOR_DRAWN_TIMEOUT, pair);
9471                }
9472            }
9473        }
9474    }
9475
9476    @Override
9477    public boolean waitForWindowDrawn(IBinder token, IRemoteCallback callback) {
9478        if (token != null && callback != null) {
9479            synchronized (mWindowMap) {
9480                WindowState win = windowForClientLocked(null, token, true);
9481                if (win != null) {
9482                    Pair<WindowState, IRemoteCallback> pair =
9483                            new Pair<WindowState, IRemoteCallback>(win, callback);
9484                    Message m = mH.obtainMessage(H.WAITING_FOR_DRAWN_TIMEOUT, pair);
9485                    mH.sendMessageDelayed(m, 2000);
9486                    mWaitingForDrawn.add(pair);
9487                    checkDrawnWindowsLocked();
9488                    return true;
9489                }
9490                Slog.i(TAG, "waitForWindowDrawn: win null");
9491            }
9492        }
9493        return false;
9494    }
9495
9496    void setHoldScreenLocked(final Session newHoldScreen) {
9497        final boolean hold = newHoldScreen != null;
9498
9499        if (hold && mHoldingScreenOn != newHoldScreen) {
9500            mHoldingScreenWakeLock.setWorkSource(new WorkSource(newHoldScreen.mUid));
9501        }
9502        mHoldingScreenOn = newHoldScreen;
9503
9504        final boolean state = mHoldingScreenWakeLock.isHeld();
9505        if (hold != state) {
9506            if (hold) {
9507                mHoldingScreenWakeLock.acquire();
9508                mPolicy.keepScreenOnStartedLw();
9509            } else {
9510                mPolicy.keepScreenOnStoppedLw();
9511                mHoldingScreenWakeLock.release();
9512            }
9513        }
9514    }
9515
9516    @Override
9517    public void requestTraversal() {
9518        synchronized (mWindowMap) {
9519            requestTraversalLocked();
9520        }
9521    }
9522
9523    void requestTraversalLocked() {
9524        if (!mTraversalScheduled) {
9525            mTraversalScheduled = true;
9526            mH.sendEmptyMessage(H.DO_TRAVERSAL);
9527        }
9528    }
9529
9530    /** Note that Locked in this case is on mLayoutToAnim */
9531    void scheduleAnimationLocked() {
9532        if (!mAnimationScheduled) {
9533            mAnimationScheduled = true;
9534            mChoreographer.postCallback(
9535                    Choreographer.CALLBACK_ANIMATION, mAnimator.mAnimationRunnable, null);
9536        }
9537    }
9538
9539    private boolean needsLayout() {
9540        final int numDisplays = mDisplayContents.size();
9541        for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) {
9542            final DisplayContent displayContent = mDisplayContents.valueAt(displayNdx);
9543            if (displayContent.layoutNeeded) {
9544                return true;
9545            }
9546        }
9547        return false;
9548    }
9549
9550    boolean copyAnimToLayoutParamsLocked() {
9551        boolean doRequest = false;
9552
9553        final int bulkUpdateParams = mAnimator.mBulkUpdateParams;
9554        if ((bulkUpdateParams & LayoutFields.SET_UPDATE_ROTATION) != 0) {
9555            mInnerFields.mUpdateRotation = true;
9556            doRequest = true;
9557        }
9558        if ((bulkUpdateParams & LayoutFields.SET_WALLPAPER_MAY_CHANGE) != 0) {
9559            mInnerFields.mWallpaperMayChange = true;
9560            doRequest = true;
9561        }
9562        if ((bulkUpdateParams & LayoutFields.SET_FORCE_HIDING_CHANGED) != 0) {
9563            mInnerFields.mWallpaperForceHidingChanged = true;
9564            doRequest = true;
9565        }
9566        if ((bulkUpdateParams & LayoutFields.SET_ORIENTATION_CHANGE_COMPLETE) == 0) {
9567            mInnerFields.mOrientationChangeComplete = false;
9568        } else {
9569            mInnerFields.mOrientationChangeComplete = true;
9570            mInnerFields.mLastWindowFreezeSource = mAnimator.mLastWindowFreezeSource;
9571            if (mWindowsFreezingScreen) {
9572                doRequest = true;
9573            }
9574        }
9575        if ((bulkUpdateParams & LayoutFields.SET_TURN_ON_SCREEN) != 0) {
9576            mTurnOnScreen = true;
9577        }
9578        if ((bulkUpdateParams & LayoutFields.SET_WALLPAPER_ACTION_PENDING) != 0) {
9579            mInnerFields.mWallpaperActionPending = true;
9580        }
9581
9582        return doRequest;
9583    }
9584
9585    /** If a window that has an animation specifying a colored background and the current wallpaper
9586     * is visible, then the color goes *below* the wallpaper so we don't cause the wallpaper to
9587     * suddenly disappear. */
9588    int adjustAnimationBackground(WindowStateAnimator winAnimator) {
9589        WindowList windows = winAnimator.mWin.getWindowList();
9590        for (int i = windows.size() - 1; i >= 0; --i) {
9591            WindowState testWin = windows.get(i);
9592            if (testWin.mIsWallpaper && testWin.isVisibleNow()) {
9593                return testWin.mWinAnimator.mAnimLayer;
9594            }
9595        }
9596        return winAnimator.mAnimLayer;
9597    }
9598
9599    boolean reclaimSomeSurfaceMemoryLocked(WindowStateAnimator winAnimator, String operation,
9600                                           boolean secure) {
9601        final SurfaceControl surface = winAnimator.mSurfaceControl;
9602        boolean leakedSurface = false;
9603        boolean killedApps = false;
9604
9605        EventLog.writeEvent(EventLogTags.WM_NO_SURFACE_MEMORY, winAnimator.mWin.toString(),
9606                winAnimator.mSession.mPid, operation);
9607
9608        if (mForceRemoves == null) {
9609            mForceRemoves = new ArrayList<WindowState>();
9610        }
9611
9612        long callingIdentity = Binder.clearCallingIdentity();
9613        try {
9614            // There was some problem...   first, do a sanity check of the
9615            // window list to make sure we haven't left any dangling surfaces
9616            // around.
9617
9618            Slog.i(TAG, "Out of memory for surface!  Looking for leaks...");
9619            final int numDisplays = mDisplayContents.size();
9620            for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) {
9621                final WindowList windows = mDisplayContents.valueAt(displayNdx).getWindowList();
9622                final int numWindows = windows.size();
9623                for (int winNdx = 0; winNdx < numWindows; ++winNdx) {
9624                    final WindowState ws = windows.get(winNdx);
9625                    WindowStateAnimator wsa = ws.mWinAnimator;
9626                    if (wsa.mSurfaceControl != null) {
9627                        if (!mSessions.contains(wsa.mSession)) {
9628                            Slog.w(TAG, "LEAKED SURFACE (session doesn't exist): "
9629                                    + ws + " surface=" + wsa.mSurfaceControl
9630                                    + " token=" + ws.mToken
9631                                    + " pid=" + ws.mSession.mPid
9632                                    + " uid=" + ws.mSession.mUid);
9633                            if (SHOW_TRANSACTIONS) logSurface(ws, "LEAK DESTROY", null);
9634                            wsa.mSurfaceControl.destroy();
9635                            wsa.mSurfaceShown = false;
9636                            wsa.mSurfaceControl = null;
9637                            ws.mHasSurface = false;
9638                            mForceRemoves.add(ws);
9639                            leakedSurface = true;
9640                        } else if (ws.mAppToken != null && ws.mAppToken.clientHidden) {
9641                            Slog.w(TAG, "LEAKED SURFACE (app token hidden): "
9642                                    + ws + " surface=" + wsa.mSurfaceControl
9643                                    + " token=" + ws.mAppToken);
9644                            if (SHOW_TRANSACTIONS) logSurface(ws, "LEAK DESTROY", null);
9645                            wsa.mSurfaceControl.destroy();
9646                            wsa.mSurfaceShown = false;
9647                            wsa.mSurfaceControl = null;
9648                            ws.mHasSurface = false;
9649                            leakedSurface = true;
9650                        }
9651                    }
9652                }
9653            }
9654
9655            if (!leakedSurface) {
9656                Slog.w(TAG, "No leaked surfaces; killing applicatons!");
9657                SparseIntArray pidCandidates = new SparseIntArray();
9658                for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) {
9659                    final WindowList windows = mDisplayContents.valueAt(displayNdx).getWindowList();
9660                    final int numWindows = windows.size();
9661                    for (int winNdx = 0; winNdx < numWindows; ++winNdx) {
9662                        final WindowState ws = windows.get(winNdx);
9663                        if (mForceRemoves.contains(ws)) {
9664                            continue;
9665                        }
9666                        WindowStateAnimator wsa = ws.mWinAnimator;
9667                        if (wsa.mSurfaceControl != null) {
9668                            pidCandidates.append(wsa.mSession.mPid, wsa.mSession.mPid);
9669                        }
9670                    }
9671                    if (pidCandidates.size() > 0) {
9672                        int[] pids = new int[pidCandidates.size()];
9673                        for (int i=0; i<pids.length; i++) {
9674                            pids[i] = pidCandidates.keyAt(i);
9675                        }
9676                        try {
9677                            if (mActivityManager.killPids(pids, "Free memory", secure)) {
9678                                killedApps = true;
9679                            }
9680                        } catch (RemoteException e) {
9681                        }
9682                    }
9683                }
9684            }
9685
9686            if (leakedSurface || killedApps) {
9687                // We managed to reclaim some memory, so get rid of the trouble
9688                // surface and ask the app to request another one.
9689                Slog.w(TAG, "Looks like we have reclaimed some memory, clearing surface for retry.");
9690                if (surface != null) {
9691                    if (SHOW_TRANSACTIONS || SHOW_SURFACE_ALLOC) logSurface(winAnimator.mWin,
9692                            "RECOVER DESTROY", null);
9693                    surface.destroy();
9694                    winAnimator.mSurfaceShown = false;
9695                    winAnimator.mSurfaceControl = null;
9696                    winAnimator.mWin.mHasSurface = false;
9697                    scheduleRemoveStartingWindow(winAnimator.mWin.mAppToken);
9698                }
9699
9700                try {
9701                    winAnimator.mWin.mClient.dispatchGetNewSurface();
9702                } catch (RemoteException e) {
9703                }
9704            }
9705        } finally {
9706            Binder.restoreCallingIdentity(callingIdentity);
9707        }
9708
9709        return leakedSurface || killedApps;
9710    }
9711
9712    private boolean updateFocusedWindowLocked(int mode, boolean updateInputWindows) {
9713        WindowState newFocus = computeFocusedWindowLocked();
9714        if (mCurrentFocus != newFocus) {
9715            Trace.traceBegin(Trace.TRACE_TAG_WINDOW_MANAGER, "wmUpdateFocus");
9716            // This check makes sure that we don't already have the focus
9717            // change message pending.
9718            mH.removeMessages(H.REPORT_FOCUS_CHANGE);
9719            mH.sendEmptyMessage(H.REPORT_FOCUS_CHANGE);
9720            // TODO(multidisplay): Focused windows on default display only.
9721            final DisplayContent displayContent = getDefaultDisplayContentLocked();
9722            final boolean imWindowChanged = moveInputMethodWindowsIfNeededLocked(
9723                    mode != UPDATE_FOCUS_WILL_ASSIGN_LAYERS
9724                            && mode != UPDATE_FOCUS_WILL_PLACE_SURFACES);
9725            if (imWindowChanged) {
9726                displayContent.layoutNeeded = true;
9727                newFocus = computeFocusedWindowLocked();
9728            }
9729
9730            if (DEBUG_FOCUS_LIGHT || localLOGV) Slog.v(TAG, "Changing focus from " +
9731                    mCurrentFocus + " to " + newFocus + " Callers=" + Debug.getCallers(4));
9732            final WindowState oldFocus = mCurrentFocus;
9733            mCurrentFocus = newFocus;
9734            mLosingFocus.remove(newFocus);
9735            int focusChanged = mPolicy.focusChangedLw(oldFocus, newFocus);
9736
9737            if (imWindowChanged && oldFocus != mInputMethodWindow) {
9738                // Focus of the input method window changed. Perform layout if needed.
9739                if (mode == UPDATE_FOCUS_PLACING_SURFACES) {
9740                    performLayoutLockedInner(displayContent, true /*initial*/, updateInputWindows);
9741                    focusChanged &= ~WindowManagerPolicy.FINISH_LAYOUT_REDO_LAYOUT;
9742                } else if (mode == UPDATE_FOCUS_WILL_PLACE_SURFACES) {
9743                    // Client will do the layout, but we need to assign layers
9744                    // for handleNewWindowLocked() below.
9745                    assignLayersLocked(displayContent.getWindowList());
9746                }
9747            }
9748
9749            if ((focusChanged & WindowManagerPolicy.FINISH_LAYOUT_REDO_LAYOUT) != 0) {
9750                // The change in focus caused us to need to do a layout.  Okay.
9751                displayContent.layoutNeeded = true;
9752                if (mode == UPDATE_FOCUS_PLACING_SURFACES) {
9753                    performLayoutLockedInner(displayContent, true /*initial*/, updateInputWindows);
9754                }
9755            }
9756
9757            if (mode != UPDATE_FOCUS_WILL_ASSIGN_LAYERS) {
9758                // If we defer assigning layers, then the caller is responsible for
9759                // doing this part.
9760                finishUpdateFocusedWindowAfterAssignLayersLocked(updateInputWindows);
9761            }
9762
9763            Trace.traceEnd(Trace.TRACE_TAG_WINDOW_MANAGER);
9764            return true;
9765        }
9766        return false;
9767    }
9768
9769    private void finishUpdateFocusedWindowAfterAssignLayersLocked(boolean updateInputWindows) {
9770        mInputMonitor.setInputFocusLw(mCurrentFocus, updateInputWindows);
9771    }
9772
9773    private WindowState computeFocusedWindowLocked() {
9774        if (mAnimator.mUniverseBackground != null
9775                && mAnimator.mUniverseBackground.mWin.canReceiveKeys()) {
9776            return mAnimator.mUniverseBackground.mWin;
9777        }
9778
9779        final int displayCount = mDisplayContents.size();
9780        for (int i = 0; i < displayCount; i++) {
9781            final DisplayContent displayContent = mDisplayContents.valueAt(i);
9782            WindowState win = findFocusedWindowLocked(displayContent);
9783            if (win != null) {
9784                return win;
9785            }
9786        }
9787        return null;
9788    }
9789
9790    private WindowState findFocusedWindowLocked(DisplayContent displayContent) {
9791        final WindowList windows = displayContent.getWindowList();
9792        for (int i = windows.size() - 1; i >= 0; i--) {
9793            final WindowState win = windows.get(i);
9794
9795            if (localLOGV || DEBUG_FOCUS) Slog.v(
9796                TAG, "Looking for focus: " + i
9797                + " = " + win
9798                + ", flags=" + win.mAttrs.flags
9799                + ", canReceive=" + win.canReceiveKeys());
9800
9801            AppWindowToken wtoken = win.mAppToken;
9802
9803            // If this window's application has been removed, just skip it.
9804            if (wtoken != null && (wtoken.removed || wtoken.sendingToBottom)) {
9805                if (DEBUG_FOCUS) Slog.v(TAG, "Skipping " + wtoken + " because "
9806                        + (wtoken.removed ? "removed" : "sendingToBottom"));
9807                continue;
9808            }
9809
9810            if (!win.canReceiveKeys()) {
9811                continue;
9812            }
9813
9814            // Descend through all of the app tokens and find the first that either matches
9815            // win.mAppToken (return win) or mFocusedApp (return null).
9816            if (wtoken != null && win.mAttrs.type != TYPE_APPLICATION_STARTING &&
9817                    mFocusedApp != null) {
9818                ArrayList<Task> tasks = displayContent.getTasks();
9819                for (int taskNdx = tasks.size() - 1; taskNdx >= 0; --taskNdx) {
9820                    AppTokenList tokens = tasks.get(taskNdx).mAppTokens;
9821                    int tokenNdx = tokens.size() - 1;
9822                    for ( ; tokenNdx >= 0; --tokenNdx) {
9823                        final AppWindowToken token = tokens.get(tokenNdx);
9824                        if (wtoken == token) {
9825                            break;
9826                        }
9827                        if (mFocusedApp == token) {
9828                            // Whoops, we are below the focused app...  no focus for you!
9829                            if (localLOGV || DEBUG_FOCUS_LIGHT) Slog.v(TAG,
9830                                    "findFocusedWindow: Reached focused app=" + mFocusedApp);
9831                            return null;
9832                        }
9833                    }
9834                    if (tokenNdx >= 0) {
9835                        // Early exit from loop, must have found the matching token.
9836                        break;
9837                    }
9838                }
9839            }
9840
9841            if (DEBUG_FOCUS_LIGHT) Slog.v(TAG, "findFocusedWindow: Found new focus @ " + i +
9842                        " = " + win);
9843            return win;
9844        }
9845
9846        if (DEBUG_FOCUS_LIGHT) Slog.v(TAG, "findFocusedWindow: No focusable windows.");
9847        return null;
9848    }
9849
9850    private void startFreezingDisplayLocked(boolean inTransaction, int exitAnim, int enterAnim) {
9851        if (mDisplayFrozen) {
9852            return;
9853        }
9854
9855        if (!mDisplayReady || !mPolicy.isScreenOnFully()) {
9856            // No need to freeze the screen before the system is ready or if
9857            // the screen is off.
9858            return;
9859        }
9860
9861        mScreenFrozenLock.acquire();
9862
9863        mDisplayFrozen = true;
9864        mDisplayFreezeTime = SystemClock.elapsedRealtime();
9865        mLastFinishedFreezeSource = null;
9866
9867        mInputMonitor.freezeInputDispatchingLw();
9868
9869        // Clear the last input window -- that is just used for
9870        // clean transitions between IMEs, and if we are freezing
9871        // the screen then the whole world is changing behind the scenes.
9872        mPolicy.setLastInputMethodWindowLw(null, null);
9873
9874        if (mAppTransition.isTransitionSet()) {
9875            mAppTransition.freeze();
9876        }
9877
9878        if (PROFILE_ORIENTATION) {
9879            File file = new File("/data/system/frozen");
9880            Debug.startMethodTracing(file.toString(), 8 * 1024 * 1024);
9881        }
9882
9883        if (CUSTOM_SCREEN_ROTATION) {
9884            mExitAnimId = exitAnim;
9885            mEnterAnimId = enterAnim;
9886            final DisplayContent displayContent = getDefaultDisplayContentLocked();
9887            final int displayId = displayContent.getDisplayId();
9888            ScreenRotationAnimation screenRotationAnimation =
9889                    mAnimator.getScreenRotationAnimationLocked(displayId);
9890            if (screenRotationAnimation != null) {
9891                screenRotationAnimation.kill();
9892            }
9893
9894            // TODO(multidisplay): rotation on main screen only.
9895            screenRotationAnimation = new ScreenRotationAnimation(mContext, displayContent,
9896                    mFxSession, inTransaction, mPolicy.isDefaultOrientationForced());
9897            mAnimator.setScreenRotationAnimationLocked(displayId, screenRotationAnimation);
9898        }
9899    }
9900
9901    private void stopFreezingDisplayLocked() {
9902        if (!mDisplayFrozen) {
9903            return;
9904        }
9905
9906        if (mWaitingForConfig || mAppsFreezingScreen > 0 || mWindowsFreezingScreen
9907                || mClientFreezingScreen) {
9908            if (DEBUG_ORIENTATION) Slog.d(TAG,
9909                "stopFreezingDisplayLocked: Returning mWaitingForConfig=" + mWaitingForConfig
9910                + ", mAppsFreezingScreen=" + mAppsFreezingScreen
9911                + ", mWindowsFreezingScreen=" + mWindowsFreezingScreen
9912                + ", mClientFreezingScreen=" + mClientFreezingScreen);
9913            return;
9914        }
9915
9916        mDisplayFrozen = false;
9917        mLastDisplayFreezeDuration = (int)(SystemClock.elapsedRealtime() - mDisplayFreezeTime);
9918        StringBuilder sb = new StringBuilder(128);
9919        sb.append("Screen frozen for ");
9920        TimeUtils.formatDuration(mLastDisplayFreezeDuration, sb);
9921        if (mLastFinishedFreezeSource != null) {
9922            sb.append(" due to ");
9923            sb.append(mLastFinishedFreezeSource);
9924        }
9925        Slog.i(TAG, sb.toString());
9926        mH.removeMessages(H.APP_FREEZE_TIMEOUT);
9927        mH.removeMessages(H.CLIENT_FREEZE_TIMEOUT);
9928        if (PROFILE_ORIENTATION) {
9929            Debug.stopMethodTracing();
9930        }
9931
9932        boolean updateRotation = false;
9933
9934        final DisplayContent displayContent = getDefaultDisplayContentLocked();
9935        final int displayId = displayContent.getDisplayId();
9936        ScreenRotationAnimation screenRotationAnimation =
9937                mAnimator.getScreenRotationAnimationLocked(displayId);
9938        if (CUSTOM_SCREEN_ROTATION && screenRotationAnimation != null
9939                && screenRotationAnimation.hasScreenshot()) {
9940            if (DEBUG_ORIENTATION) Slog.i(TAG, "**** Dismissing screen rotation animation");
9941            // TODO(multidisplay): rotation on main screen only.
9942            DisplayInfo displayInfo = displayContent.getDisplayInfo();
9943            // Get rotation animation again, with new top window
9944            boolean isDimming = displayContent.isDimming();
9945            if (!mPolicy.validateRotationAnimationLw(mExitAnimId, mEnterAnimId, isDimming)) {
9946                mExitAnimId = mEnterAnimId = 0;
9947            }
9948            if (screenRotationAnimation.dismiss(mFxSession, MAX_ANIMATION_DURATION,
9949                    mTransitionAnimationScale, displayInfo.logicalWidth,
9950                        displayInfo.logicalHeight, mExitAnimId, mEnterAnimId)) {
9951                scheduleAnimationLocked();
9952            } else {
9953                screenRotationAnimation.kill();
9954                screenRotationAnimation = null;
9955                mAnimator.setScreenRotationAnimationLocked(displayId, screenRotationAnimation);
9956                updateRotation = true;
9957            }
9958        } else {
9959            if (screenRotationAnimation != null) {
9960                screenRotationAnimation.kill();
9961                screenRotationAnimation = null;
9962                mAnimator.setScreenRotationAnimationLocked(displayId, screenRotationAnimation);
9963            }
9964            updateRotation = true;
9965        }
9966
9967        mInputMonitor.thawInputDispatchingLw();
9968
9969        boolean configChanged;
9970
9971        // While the display is frozen we don't re-compute the orientation
9972        // to avoid inconsistent states.  However, something interesting
9973        // could have actually changed during that time so re-evaluate it
9974        // now to catch that.
9975        configChanged = updateOrientationFromAppTokensLocked(false);
9976
9977        // A little kludge: a lot could have happened while the
9978        // display was frozen, so now that we are coming back we
9979        // do a gc so that any remote references the system
9980        // processes holds on others can be released if they are
9981        // no longer needed.
9982        mH.removeMessages(H.FORCE_GC);
9983        mH.sendEmptyMessageDelayed(H.FORCE_GC, 2000);
9984
9985        mScreenFrozenLock.release();
9986
9987        if (updateRotation) {
9988            if (DEBUG_ORIENTATION) Slog.d(TAG, "Performing post-rotate rotation");
9989            configChanged |= updateRotationUncheckedLocked(false);
9990        }
9991
9992        if (configChanged) {
9993            mH.sendEmptyMessage(H.SEND_NEW_CONFIGURATION);
9994        }
9995    }
9996
9997    static int getPropertyInt(String[] tokens, int index, int defUnits, int defDps,
9998            DisplayMetrics dm) {
9999        if (index < tokens.length) {
10000            String str = tokens[index];
10001            if (str != null && str.length() > 0) {
10002                try {
10003                    int val = Integer.parseInt(str);
10004                    return val;
10005                } catch (Exception e) {
10006                }
10007            }
10008        }
10009        if (defUnits == TypedValue.COMPLEX_UNIT_PX) {
10010            return defDps;
10011        }
10012        int val = (int)TypedValue.applyDimension(defUnits, defDps, dm);
10013        return val;
10014    }
10015
10016    void createWatermarkInTransaction() {
10017        if (mWatermark != null) {
10018            return;
10019        }
10020
10021        File file = new File("/system/etc/setup.conf");
10022        FileInputStream in = null;
10023        DataInputStream ind = null;
10024        try {
10025            in = new FileInputStream(file);
10026            ind = new DataInputStream(in);
10027            String line = ind.readLine();
10028            if (line != null) {
10029                String[] toks = line.split("%");
10030                if (toks != null && toks.length > 0) {
10031                    mWatermark = new Watermark(getDefaultDisplayContentLocked().getDisplay(),
10032                            mRealDisplayMetrics, mFxSession, toks);
10033                }
10034            }
10035        } catch (FileNotFoundException e) {
10036        } catch (IOException e) {
10037        } finally {
10038            if (ind != null) {
10039                try {
10040                    ind.close();
10041                } catch (IOException e) {
10042                }
10043            } else if (in != null) {
10044                try {
10045                    in.close();
10046                } catch (IOException e) {
10047                }
10048            }
10049        }
10050    }
10051
10052    @Override
10053    public void statusBarVisibilityChanged(int visibility) {
10054        if (mContext.checkCallingOrSelfPermission(android.Manifest.permission.STATUS_BAR)
10055                != PackageManager.PERMISSION_GRANTED) {
10056            throw new SecurityException("Caller does not hold permission "
10057                    + android.Manifest.permission.STATUS_BAR);
10058        }
10059
10060        synchronized (mWindowMap) {
10061            mLastStatusBarVisibility = visibility;
10062            visibility = mPolicy.adjustSystemUiVisibilityLw(visibility);
10063            updateStatusBarVisibilityLocked(visibility);
10064        }
10065    }
10066
10067    // TOOD(multidisplay): StatusBar on multiple screens?
10068    void updateStatusBarVisibilityLocked(int visibility) {
10069        mInputManager.setSystemUiVisibility(visibility);
10070        final WindowList windows = getDefaultWindowListLocked();
10071        final int N = windows.size();
10072        for (int i = 0; i < N; i++) {
10073            WindowState ws = windows.get(i);
10074            try {
10075                int curValue = ws.mSystemUiVisibility;
10076                int diff = curValue ^ visibility;
10077                // We are only interested in differences of one of the
10078                // clearable flags...
10079                diff &= View.SYSTEM_UI_CLEARABLE_FLAGS;
10080                // ...if it has actually been cleared.
10081                diff &= ~visibility;
10082                int newValue = (curValue&~diff) | (visibility&diff);
10083                if (newValue != curValue) {
10084                    ws.mSeq++;
10085                    ws.mSystemUiVisibility = newValue;
10086                }
10087                if (newValue != curValue || ws.mAttrs.hasSystemUiListeners) {
10088                    ws.mClient.dispatchSystemUiVisibilityChanged(ws.mSeq,
10089                            visibility, newValue, diff);
10090                }
10091            } catch (RemoteException e) {
10092                // so sorry
10093            }
10094        }
10095    }
10096
10097    @Override
10098    public void reevaluateStatusBarVisibility() {
10099        synchronized (mWindowMap) {
10100            int visibility = mPolicy.adjustSystemUiVisibilityLw(mLastStatusBarVisibility);
10101            updateStatusBarVisibilityLocked(visibility);
10102            performLayoutAndPlaceSurfacesLocked();
10103        }
10104    }
10105
10106    @Override
10107    public FakeWindow addFakeWindow(Looper looper,
10108            InputEventReceiver.Factory inputEventReceiverFactory,
10109            String name, int windowType, int layoutParamsFlags, int layoutParamsPrivateFlags,
10110            boolean canReceiveKeys, boolean hasFocus, boolean touchFullscreen) {
10111        synchronized (mWindowMap) {
10112            FakeWindowImpl fw = new FakeWindowImpl(this, looper, inputEventReceiverFactory,
10113                    name, windowType,
10114                    layoutParamsFlags, layoutParamsPrivateFlags, canReceiveKeys,
10115                    hasFocus, touchFullscreen);
10116            int i=0;
10117            while (i<mFakeWindows.size()) {
10118                if (mFakeWindows.get(i).mWindowLayer <= fw.mWindowLayer) {
10119                    break;
10120                }
10121            }
10122            mFakeWindows.add(i, fw);
10123            mInputMonitor.updateInputWindowsLw(true);
10124            return fw;
10125        }
10126    }
10127
10128    boolean removeFakeWindowLocked(FakeWindow window) {
10129        synchronized (mWindowMap) {
10130            if (mFakeWindows.remove(window)) {
10131                mInputMonitor.updateInputWindowsLw(true);
10132                return true;
10133            }
10134            return false;
10135        }
10136    }
10137
10138    // It is assumed that this method is called only by InputMethodManagerService.
10139    public void saveLastInputMethodWindowForTransition() {
10140        synchronized (mWindowMap) {
10141            // TODO(multidisplay): Pass in the displayID.
10142            DisplayContent displayContent = getDefaultDisplayContentLocked();
10143            if (mInputMethodWindow != null) {
10144                mPolicy.setLastInputMethodWindowLw(mInputMethodWindow, mInputMethodTarget);
10145            }
10146        }
10147    }
10148
10149    @Override
10150    public boolean hasNavigationBar() {
10151        return mPolicy.hasNavigationBar();
10152    }
10153
10154    @Override
10155    public void lockNow(Bundle options) {
10156        mPolicy.lockNow(options);
10157    }
10158
10159    @Override
10160    public boolean isSafeModeEnabled() {
10161        return mSafeMode;
10162    }
10163
10164    void dumpPolicyLocked(PrintWriter pw, String[] args, boolean dumpAll) {
10165        pw.println("WINDOW MANAGER POLICY STATE (dumpsys window policy)");
10166        mPolicy.dump("    ", pw, args);
10167    }
10168
10169    void dumpAnimatorLocked(PrintWriter pw, String[] args, boolean dumpAll) {
10170        pw.println("WINDOW MANAGER ANIMATOR STATE (dumpsys window animator)");
10171        mAnimator.dumpLocked(pw, "    ", dumpAll);
10172    }
10173
10174    void dumpTokensLocked(PrintWriter pw, boolean dumpAll) {
10175        pw.println("WINDOW MANAGER TOKENS (dumpsys window tokens)");
10176        if (mTokenMap.size() > 0) {
10177            pw.println("  All tokens:");
10178            Iterator<WindowToken> it = mTokenMap.values().iterator();
10179            while (it.hasNext()) {
10180                WindowToken token = it.next();
10181                pw.print("  "); pw.print(token);
10182                if (dumpAll) {
10183                    pw.println(':');
10184                    token.dump(pw, "    ");
10185                } else {
10186                    pw.println();
10187                }
10188            }
10189        }
10190        if (mWallpaperTokens.size() > 0) {
10191            pw.println();
10192            pw.println("  Wallpaper tokens:");
10193            for (int i=mWallpaperTokens.size()-1; i>=0; i--) {
10194                WindowToken token = mWallpaperTokens.get(i);
10195                pw.print("  Wallpaper #"); pw.print(i);
10196                        pw.print(' '); pw.print(token);
10197                if (dumpAll) {
10198                    pw.println(':');
10199                    token.dump(pw, "    ");
10200                } else {
10201                    pw.println();
10202                }
10203            }
10204        }
10205        if (mFinishedStarting.size() > 0) {
10206            pw.println();
10207            pw.println("  Finishing start of application tokens:");
10208            for (int i=mFinishedStarting.size()-1; i>=0; i--) {
10209                WindowToken token = mFinishedStarting.get(i);
10210                pw.print("  Finished Starting #"); pw.print(i);
10211                        pw.print(' '); pw.print(token);
10212                if (dumpAll) {
10213                    pw.println(':');
10214                    token.dump(pw, "    ");
10215                } else {
10216                    pw.println();
10217                }
10218            }
10219        }
10220        if (mOpeningApps.size() > 0 || mClosingApps.size() > 0) {
10221            pw.println();
10222            if (mOpeningApps.size() > 0) {
10223                pw.print("  mOpeningApps="); pw.println(mOpeningApps);
10224            }
10225            if (mClosingApps.size() > 0) {
10226                pw.print("  mClosingApps="); pw.println(mClosingApps);
10227            }
10228        }
10229    }
10230
10231    void dumpSessionsLocked(PrintWriter pw, boolean dumpAll) {
10232        pw.println("WINDOW MANAGER SESSIONS (dumpsys window sessions)");
10233        if (mSessions.size() > 0) {
10234            Iterator<Session> it = mSessions.iterator();
10235            while (it.hasNext()) {
10236                Session s = it.next();
10237                pw.print("  Session "); pw.print(s); pw.println(':');
10238                s.dump(pw, "    ");
10239            }
10240        }
10241    }
10242
10243    void dumpDisplayContentsLocked(PrintWriter pw, boolean dumpAll) {
10244        pw.println("WINDOW MANAGER DISPLAY CONTENTS (dumpsys window displays)");
10245        if (mDisplayReady) {
10246            final int numDisplays = mDisplayContents.size();
10247            for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) {
10248                final DisplayContent displayContent = mDisplayContents.valueAt(displayNdx);
10249                displayContent.dump("  ", pw);
10250            }
10251        } else {
10252            pw.println("  NO DISPLAY");
10253        }
10254    }
10255
10256    void dumpWindowsLocked(PrintWriter pw, boolean dumpAll,
10257            ArrayList<WindowState> windows) {
10258        pw.println("WINDOW MANAGER WINDOWS (dumpsys window windows)");
10259        dumpWindowsNoHeaderLocked(pw, dumpAll, windows);
10260    }
10261
10262    void dumpWindowsNoHeaderLocked(PrintWriter pw, boolean dumpAll,
10263            ArrayList<WindowState> windows) {
10264        final int numDisplays = mDisplayContents.size();
10265        for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) {
10266            final WindowList windowList = mDisplayContents.valueAt(displayNdx).getWindowList();
10267            for (int winNdx = windowList.size() - 1; winNdx >= 0; --winNdx) {
10268                final WindowState w = windowList.get(winNdx);
10269                if (windows == null || windows.contains(w)) {
10270                    pw.print("  Window #"); pw.print(winNdx); pw.print(' ');
10271                            pw.print(w); pw.println(":");
10272                    w.dump(pw, "    ", dumpAll || windows != null);
10273                }
10274            }
10275        }
10276        if (mInputMethodDialogs.size() > 0) {
10277            pw.println();
10278            pw.println("  Input method dialogs:");
10279            for (int i=mInputMethodDialogs.size()-1; i>=0; i--) {
10280                WindowState w = mInputMethodDialogs.get(i);
10281                if (windows == null || windows.contains(w)) {
10282                    pw.print("  IM Dialog #"); pw.print(i); pw.print(": "); pw.println(w);
10283                }
10284            }
10285        }
10286        if (mPendingRemove.size() > 0) {
10287            pw.println();
10288            pw.println("  Remove pending for:");
10289            for (int i=mPendingRemove.size()-1; i>=0; i--) {
10290                WindowState w = mPendingRemove.get(i);
10291                if (windows == null || windows.contains(w)) {
10292                    pw.print("  Remove #"); pw.print(i); pw.print(' ');
10293                            pw.print(w);
10294                    if (dumpAll) {
10295                        pw.println(":");
10296                        w.dump(pw, "    ", true);
10297                    } else {
10298                        pw.println();
10299                    }
10300                }
10301            }
10302        }
10303        if (mForceRemoves != null && mForceRemoves.size() > 0) {
10304            pw.println();
10305            pw.println("  Windows force removing:");
10306            for (int i=mForceRemoves.size()-1; i>=0; i--) {
10307                WindowState w = mForceRemoves.get(i);
10308                pw.print("  Removing #"); pw.print(i); pw.print(' ');
10309                        pw.print(w);
10310                if (dumpAll) {
10311                    pw.println(":");
10312                    w.dump(pw, "    ", true);
10313                } else {
10314                    pw.println();
10315                }
10316            }
10317        }
10318        if (mDestroySurface.size() > 0) {
10319            pw.println();
10320            pw.println("  Windows waiting to destroy their surface:");
10321            for (int i=mDestroySurface.size()-1; i>=0; i--) {
10322                WindowState w = mDestroySurface.get(i);
10323                if (windows == null || windows.contains(w)) {
10324                    pw.print("  Destroy #"); pw.print(i); pw.print(' ');
10325                            pw.print(w);
10326                    if (dumpAll) {
10327                        pw.println(":");
10328                        w.dump(pw, "    ", true);
10329                    } else {
10330                        pw.println();
10331                    }
10332                }
10333            }
10334        }
10335        if (mLosingFocus.size() > 0) {
10336            pw.println();
10337            pw.println("  Windows losing focus:");
10338            for (int i=mLosingFocus.size()-1; i>=0; i--) {
10339                WindowState w = mLosingFocus.get(i);
10340                if (windows == null || windows.contains(w)) {
10341                    pw.print("  Losing #"); pw.print(i); pw.print(' ');
10342                            pw.print(w);
10343                    if (dumpAll) {
10344                        pw.println(":");
10345                        w.dump(pw, "    ", true);
10346                    } else {
10347                        pw.println();
10348                    }
10349                }
10350            }
10351        }
10352        if (mResizingWindows.size() > 0) {
10353            pw.println();
10354            pw.println("  Windows waiting to resize:");
10355            for (int i=mResizingWindows.size()-1; i>=0; i--) {
10356                WindowState w = mResizingWindows.get(i);
10357                if (windows == null || windows.contains(w)) {
10358                    pw.print("  Resizing #"); pw.print(i); pw.print(' ');
10359                            pw.print(w);
10360                    if (dumpAll) {
10361                        pw.println(":");
10362                        w.dump(pw, "    ", true);
10363                    } else {
10364                        pw.println();
10365                    }
10366                }
10367            }
10368        }
10369        if (mWaitingForDrawn.size() > 0) {
10370            pw.println();
10371            pw.println("  Clients waiting for these windows to be drawn:");
10372            for (int i=mWaitingForDrawn.size()-1; i>=0; i--) {
10373                Pair<WindowState, IRemoteCallback> pair = mWaitingForDrawn.get(i);
10374                pw.print("  Waiting #"); pw.print(i); pw.print(' '); pw.print(pair.first);
10375                        pw.print(": "); pw.println(pair.second);
10376            }
10377        }
10378        pw.println();
10379        pw.print("  mCurConfiguration="); pw.println(this.mCurConfiguration);
10380        pw.print("  mCurrentFocus="); pw.println(mCurrentFocus);
10381        if (mLastFocus != mCurrentFocus) {
10382            pw.print("  mLastFocus="); pw.println(mLastFocus);
10383        }
10384        pw.print("  mFocusedApp="); pw.println(mFocusedApp);
10385        if (mInputMethodTarget != null) {
10386            pw.print("  mInputMethodTarget="); pw.println(mInputMethodTarget);
10387        }
10388        pw.print("  mInTouchMode="); pw.print(mInTouchMode);
10389                pw.print(" mLayoutSeq="); pw.println(mLayoutSeq);
10390        pw.print("  mLastDisplayFreezeDuration=");
10391                TimeUtils.formatDuration(mLastDisplayFreezeDuration, pw);
10392                if ( mLastFinishedFreezeSource != null) {
10393                    pw.print(" due to ");
10394                    pw.print(mLastFinishedFreezeSource);
10395                }
10396                pw.println();
10397        if (dumpAll) {
10398            pw.print("  mSystemDecorLayer="); pw.print(mSystemDecorLayer);
10399                    pw.print(" mScreenRect="); pw.println(mScreenRect.toShortString());
10400            if (mLastStatusBarVisibility != 0) {
10401                pw.print("  mLastStatusBarVisibility=0x");
10402                        pw.println(Integer.toHexString(mLastStatusBarVisibility));
10403            }
10404            if (mInputMethodWindow != null) {
10405                pw.print("  mInputMethodWindow="); pw.println(mInputMethodWindow);
10406            }
10407            pw.print("  mWallpaperTarget="); pw.println(mWallpaperTarget);
10408            if (mLowerWallpaperTarget != null || mUpperWallpaperTarget != null) {
10409                pw.print("  mLowerWallpaperTarget="); pw.println(mLowerWallpaperTarget);
10410                pw.print("  mUpperWallpaperTarget="); pw.println(mUpperWallpaperTarget);
10411            }
10412            pw.print("  mLastWallpaperX="); pw.print(mLastWallpaperX);
10413                    pw.print(" mLastWallpaperY="); pw.println(mLastWallpaperY);
10414            if (mInputMethodAnimLayerAdjustment != 0 ||
10415                    mWallpaperAnimLayerAdjustment != 0) {
10416                pw.print("  mInputMethodAnimLayerAdjustment=");
10417                        pw.print(mInputMethodAnimLayerAdjustment);
10418                        pw.print("  mWallpaperAnimLayerAdjustment=");
10419                        pw.println(mWallpaperAnimLayerAdjustment);
10420            }
10421            pw.print("  mSystemBooted="); pw.print(mSystemBooted);
10422                    pw.print(" mDisplayEnabled="); pw.println(mDisplayEnabled);
10423            if (needsLayout()) {
10424                pw.print("  layoutNeeded on displays=");
10425                for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) {
10426                    final DisplayContent displayContent = mDisplayContents.valueAt(displayNdx);
10427                    if (displayContent.layoutNeeded) {
10428                        pw.print(displayContent.getDisplayId());
10429                    }
10430                }
10431                pw.println();
10432            }
10433            pw.print("  mTransactionSequence="); pw.println(mTransactionSequence);
10434            pw.print("  mDisplayFrozen="); pw.print(mDisplayFrozen);
10435                    pw.print(" windows="); pw.print(mWindowsFreezingScreen);
10436                    pw.print(" client="); pw.print(mClientFreezingScreen);
10437                    pw.print(" apps="); pw.print(mAppsFreezingScreen);
10438                    pw.print(" waitingForConfig="); pw.println(mWaitingForConfig);
10439            pw.print("  mRotation="); pw.print(mRotation);
10440                    pw.print(" mAltOrientation="); pw.println(mAltOrientation);
10441            pw.print("  mLastWindowForcedOrientation="); pw.print(mLastWindowForcedOrientation);
10442                    pw.print(" mForcedAppOrientation="); pw.println(mForcedAppOrientation);
10443            pw.print("  mDeferredRotationPauseCount="); pw.println(mDeferredRotationPauseCount);
10444            pw.print("  mWindowAnimationScale="); pw.print(mWindowAnimationScale);
10445                    pw.print(" mTransitionWindowAnimationScale="); pw.print(mTransitionAnimationScale);
10446                    pw.print(" mAnimatorDurationScale="); pw.println(mAnimatorDurationScale);
10447            pw.print("  mTraversalScheduled="); pw.println(mTraversalScheduled);
10448            pw.print("  mStartingIconInTransition="); pw.print(mStartingIconInTransition);
10449                    pw.print(" mSkipAppTransitionAnimation="); pw.println(mSkipAppTransitionAnimation);
10450            pw.println("  mLayoutToAnim:");
10451            mAppTransition.dump(pw);
10452        }
10453    }
10454
10455    boolean dumpWindows(PrintWriter pw, String name, String[] args,
10456            int opti, boolean dumpAll) {
10457        WindowList windows = new WindowList();
10458        if ("visible".equals(name)) {
10459            synchronized(mWindowMap) {
10460                final int numDisplays = mDisplayContents.size();
10461                for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) {
10462                    final WindowList windowList =
10463                            mDisplayContents.valueAt(displayNdx).getWindowList();
10464                    for (int winNdx = windowList.size() - 1; winNdx >= 0; --winNdx) {
10465                        final WindowState w = windowList.get(winNdx);
10466                        if (w.mWinAnimator.mSurfaceShown) {
10467                            windows.add(w);
10468                        }
10469                    }
10470                }
10471            }
10472        } else {
10473            int objectId = 0;
10474            // See if this is an object ID.
10475            try {
10476                objectId = Integer.parseInt(name, 16);
10477                name = null;
10478            } catch (RuntimeException e) {
10479            }
10480            synchronized(mWindowMap) {
10481                final int numDisplays = mDisplayContents.size();
10482                for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) {
10483                    final WindowList windowList =
10484                            mDisplayContents.valueAt(displayNdx).getWindowList();
10485                    for (int winNdx = windowList.size() - 1; winNdx >= 0; --winNdx) {
10486                        final WindowState w = windowList.get(winNdx);
10487                        if (name != null) {
10488                            if (w.mAttrs.getTitle().toString().contains(name)) {
10489                                windows.add(w);
10490                            }
10491                        } else if (System.identityHashCode(w) == objectId) {
10492                            windows.add(w);
10493                        }
10494                    }
10495                }
10496            }
10497        }
10498
10499        if (windows.size() <= 0) {
10500            return false;
10501        }
10502
10503        synchronized(mWindowMap) {
10504            dumpWindowsLocked(pw, dumpAll, windows);
10505        }
10506        return true;
10507    }
10508
10509    void dumpLastANRLocked(PrintWriter pw) {
10510        pw.println("WINDOW MANAGER LAST ANR (dumpsys window lastanr)");
10511        if (mLastANRState == null) {
10512            pw.println("  <no ANR has occurred since boot>");
10513        } else {
10514            pw.println(mLastANRState);
10515        }
10516    }
10517
10518    /**
10519     * Saves information about the state of the window manager at
10520     * the time an ANR occurred before anything else in the system changes
10521     * in response.
10522     *
10523     * @param appWindowToken The application that ANR'd, may be null.
10524     * @param windowState The window that ANR'd, may be null.
10525     * @param reason The reason for the ANR, may be null.
10526     */
10527    public void saveANRStateLocked(AppWindowToken appWindowToken, WindowState windowState,
10528            String reason) {
10529        StringWriter sw = new StringWriter();
10530        PrintWriter pw = new FastPrintWriter(sw, false, 1024);
10531        pw.println("  ANR time: " + DateFormat.getInstance().format(new Date()));
10532        if (appWindowToken != null) {
10533            pw.println("  Application at fault: " + appWindowToken.stringName);
10534        }
10535        if (windowState != null) {
10536            pw.println("  Window at fault: " + windowState.mAttrs.getTitle());
10537        }
10538        if (reason != null) {
10539            pw.println("  Reason: " + reason);
10540        }
10541        pw.println();
10542        dumpWindowsNoHeaderLocked(pw, true, null);
10543        pw.close();
10544        mLastANRState = sw.toString();
10545    }
10546
10547    @Override
10548    public void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
10549        if (mContext.checkCallingOrSelfPermission("android.permission.DUMP")
10550                != PackageManager.PERMISSION_GRANTED) {
10551            pw.println("Permission Denial: can't dump WindowManager from from pid="
10552                    + Binder.getCallingPid()
10553                    + ", uid=" + Binder.getCallingUid());
10554            return;
10555        }
10556
10557        boolean dumpAll = false;
10558
10559        int opti = 0;
10560        while (opti < args.length) {
10561            String opt = args[opti];
10562            if (opt == null || opt.length() <= 0 || opt.charAt(0) != '-') {
10563                break;
10564            }
10565            opti++;
10566            if ("-a".equals(opt)) {
10567                dumpAll = true;
10568            } else if ("-h".equals(opt)) {
10569                pw.println("Window manager dump options:");
10570                pw.println("  [-a] [-h] [cmd] ...");
10571                pw.println("  cmd may be one of:");
10572                pw.println("    l[astanr]: last ANR information");
10573                pw.println("    p[policy]: policy state");
10574                pw.println("    a[animator]: animator state");
10575                pw.println("    s[essions]: active sessions");
10576                pw.println("    d[isplays]: active display contents");
10577                pw.println("    t[okens]: token list");
10578                pw.println("    w[indows]: window list");
10579                pw.println("  cmd may also be a NAME to dump windows.  NAME may");
10580                pw.println("    be a partial substring in a window name, a");
10581                pw.println("    Window hex object identifier, or");
10582                pw.println("    \"all\" for all windows, or");
10583                pw.println("    \"visible\" for the visible windows.");
10584                pw.println("  -a: include all available server state.");
10585                return;
10586            } else {
10587                pw.println("Unknown argument: " + opt + "; use -h for help");
10588            }
10589        }
10590
10591        // Is the caller requesting to dump a particular piece of data?
10592        if (opti < args.length) {
10593            String cmd = args[opti];
10594            opti++;
10595            if ("lastanr".equals(cmd) || "l".equals(cmd)) {
10596                synchronized(mWindowMap) {
10597                    dumpLastANRLocked(pw);
10598                }
10599                return;
10600            } else if ("policy".equals(cmd) || "p".equals(cmd)) {
10601                synchronized(mWindowMap) {
10602                    dumpPolicyLocked(pw, args, true);
10603                }
10604                return;
10605            } else if ("animator".equals(cmd) || "a".equals(cmd)) {
10606                synchronized(mWindowMap) {
10607                    dumpAnimatorLocked(pw, args, true);
10608                }
10609                return;
10610            } else if ("sessions".equals(cmd) || "s".equals(cmd)) {
10611                synchronized(mWindowMap) {
10612                    dumpSessionsLocked(pw, true);
10613                }
10614                return;
10615            } else if ("displays".equals(cmd) || "d".equals(cmd)) {
10616                synchronized(mWindowMap) {
10617                    dumpDisplayContentsLocked(pw, true);
10618                }
10619                return;
10620            } else if ("tokens".equals(cmd) || "t".equals(cmd)) {
10621                synchronized(mWindowMap) {
10622                    dumpTokensLocked(pw, true);
10623                }
10624                return;
10625            } else if ("windows".equals(cmd) || "w".equals(cmd)) {
10626                synchronized(mWindowMap) {
10627                    dumpWindowsLocked(pw, true, null);
10628                }
10629                return;
10630            } else if ("all".equals(cmd) || "a".equals(cmd)) {
10631                synchronized(mWindowMap) {
10632                    dumpWindowsLocked(pw, true, null);
10633                }
10634                return;
10635            } else {
10636                // Dumping a single name?
10637                if (!dumpWindows(pw, cmd, args, opti, dumpAll)) {
10638                    pw.println("Bad window command, or no windows match: " + cmd);
10639                    pw.println("Use -h for help.");
10640                }
10641                return;
10642            }
10643        }
10644
10645        synchronized(mWindowMap) {
10646            pw.println();
10647            if (dumpAll) {
10648                pw.println("-------------------------------------------------------------------------------");
10649            }
10650            dumpLastANRLocked(pw);
10651            pw.println();
10652            if (dumpAll) {
10653                pw.println("-------------------------------------------------------------------------------");
10654            }
10655            dumpPolicyLocked(pw, args, dumpAll);
10656            pw.println();
10657            if (dumpAll) {
10658                pw.println("-------------------------------------------------------------------------------");
10659            }
10660            dumpAnimatorLocked(pw, args, dumpAll);
10661            pw.println();
10662            if (dumpAll) {
10663                pw.println("-------------------------------------------------------------------------------");
10664            }
10665            dumpSessionsLocked(pw, dumpAll);
10666            pw.println();
10667            if (dumpAll) {
10668                pw.println("-------------------------------------------------------------------------------");
10669            }
10670            dumpDisplayContentsLocked(pw, dumpAll);
10671            pw.println();
10672            if (dumpAll) {
10673                pw.println("-------------------------------------------------------------------------------");
10674            }
10675            dumpTokensLocked(pw, dumpAll);
10676            pw.println();
10677            if (dumpAll) {
10678                pw.println("-------------------------------------------------------------------------------");
10679            }
10680            dumpWindowsLocked(pw, dumpAll, null);
10681        }
10682    }
10683
10684    // Called by the heartbeat to ensure locks are not held indefnitely (for deadlock detection).
10685    @Override
10686    public void monitor() {
10687        synchronized (mWindowMap) { }
10688    }
10689
10690    public interface OnHardKeyboardStatusChangeListener {
10691        public void onHardKeyboardStatusChange(boolean available, boolean enabled);
10692    }
10693
10694    void debugLayoutRepeats(final String msg, int pendingLayoutChanges) {
10695        if (mLayoutRepeatCount >= LAYOUT_REPEAT_THRESHOLD) {
10696            Slog.v(TAG, "Layouts looping: " + msg + ", mPendingLayoutChanges = 0x" +
10697                    Integer.toHexString(pendingLayoutChanges));
10698        }
10699    }
10700
10701    private DisplayContent newDisplayContentLocked(final Display display) {
10702        DisplayContent displayContent = new DisplayContent(display, this);
10703        final int displayId = display.getDisplayId();
10704        mDisplayContents.put(displayId, displayContent);
10705
10706        DisplayInfo displayInfo = displayContent.getDisplayInfo();
10707        final Rect rect = new Rect();
10708        mDisplaySettings.getOverscanLocked(displayInfo.name, rect);
10709        synchronized (displayContent.mDisplaySizeLock) {
10710            displayInfo.overscanLeft = rect.left;
10711            displayInfo.overscanTop = rect.top;
10712            displayInfo.overscanRight = rect.right;
10713            displayInfo.overscanBottom = rect.bottom;
10714            mDisplayManagerService.setDisplayInfoOverrideFromWindowManager(
10715                    displayId, displayInfo);
10716        }
10717        configureDisplayPolicyLocked(displayContent);
10718
10719        // TODO: Create an input channel for each display with touch capability.
10720        if (displayId == Display.DEFAULT_DISPLAY) {
10721            displayContent.mTapDetector = new StackTapPointerEventListener(this, displayContent);
10722            registerPointerEventListener(displayContent.mTapDetector);
10723        }
10724
10725        return displayContent;
10726    }
10727
10728    public void createDisplayContentLocked(final Display display) {
10729        if (display == null) {
10730            throw new IllegalArgumentException("getDisplayContent: display must not be null");
10731        }
10732        getDisplayContentLocked(display.getDisplayId());
10733    }
10734
10735    /**
10736     * Retrieve the DisplayContent for the specified displayId. Will create a new DisplayContent if
10737     * there is a Display for the displayId.
10738     * @param displayId The display the caller is interested in.
10739     * @return The DisplayContent associated with displayId or null if there is no Display for it.
10740     */
10741    public DisplayContent getDisplayContentLocked(final int displayId) {
10742        DisplayContent displayContent = mDisplayContents.get(displayId);
10743        if (displayContent == null) {
10744            final Display display = mDisplayManager.getDisplay(displayId);
10745            if (display != null) {
10746                displayContent = newDisplayContentLocked(display);
10747            }
10748        }
10749        return displayContent;
10750    }
10751
10752    // There is an inherent assumption that this will never return null.
10753    public DisplayContent getDefaultDisplayContentLocked() {
10754        return getDisplayContentLocked(Display.DEFAULT_DISPLAY);
10755    }
10756
10757    public WindowList getDefaultWindowListLocked() {
10758        return getDefaultDisplayContentLocked().getWindowList();
10759    }
10760
10761    public DisplayInfo getDefaultDisplayInfoLocked() {
10762        return getDefaultDisplayContentLocked().getDisplayInfo();
10763    }
10764
10765    /**
10766     * Return the list of WindowStates associated on the passed display.
10767     * @param display The screen to return windows from.
10768     * @return The list of WindowStates on the screen, or null if the there is no screen.
10769     */
10770    public WindowList getWindowListLocked(final Display display) {
10771        return getWindowListLocked(display.getDisplayId());
10772    }
10773
10774    /**
10775     * Return the list of WindowStates associated on the passed display.
10776     * @param displayId The screen to return windows from.
10777     * @return The list of WindowStates on the screen, or null if the there is no screen.
10778     */
10779    public WindowList getWindowListLocked(final int displayId) {
10780        final DisplayContent displayContent = getDisplayContentLocked(displayId);
10781        return displayContent != null ? displayContent.getWindowList() : null;
10782    }
10783
10784    @Override
10785    public void onDisplayAdded(int displayId) {
10786        mH.sendMessage(mH.obtainMessage(H.DO_DISPLAY_ADDED, displayId, 0));
10787    }
10788
10789    private void handleDisplayAddedLocked(int displayId) {
10790        final Display display = mDisplayManager.getDisplay(displayId);
10791        if (display != null) {
10792            createDisplayContentLocked(display);
10793            displayReady(displayId);
10794        }
10795    }
10796
10797    @Override
10798    public void onDisplayRemoved(int displayId) {
10799        mH.sendMessage(mH.obtainMessage(H.DO_DISPLAY_REMOVED, displayId, 0));
10800    }
10801
10802    private void handleDisplayRemovedLocked(int displayId) {
10803        final DisplayContent displayContent = getDisplayContentLocked(displayId);
10804        if (displayContent != null) {
10805            mDisplayContents.delete(displayId);
10806            displayContent.close();
10807            if (displayId == Display.DEFAULT_DISPLAY) {
10808                unregisterPointerEventListener(displayContent.mTapDetector);
10809            }
10810            WindowList windows = displayContent.getWindowList();
10811            while (!windows.isEmpty()) {
10812                final WindowState win = windows.get(windows.size() - 1);
10813                removeWindowLocked(win.mSession, win);
10814            }
10815        }
10816        mAnimator.removeDisplayLocked(displayId);
10817    }
10818
10819    @Override
10820    public void onDisplayChanged(int displayId) {
10821        mH.sendMessage(mH.obtainMessage(H.DO_DISPLAY_CHANGED, displayId, 0));
10822    }
10823
10824    private void handleDisplayChangedLocked(int displayId) {
10825        final DisplayContent displayContent = getDisplayContentLocked(displayId);
10826        if (displayContent != null) {
10827            displayContent.updateDisplayInfo();
10828        }
10829    }
10830
10831    @Override
10832    public Object getWindowManagerLock() {
10833        return mWindowMap;
10834    }
10835}
10836