WindowManagerService.java revision 04a0ea60ac7e20369e63edc4f3f8cedf8425a439 
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    public void createStack(int stackId, int displayId) {
4821        mH.sendMessage(mH.obtainMessage(H.CREATE_STACK, stackId, displayId));
4822    }
4823
4824    /**
4825     * Create a new TaskStack and place it next to an existing stack.
4826     * @param stackId The unique identifier of the new stack.
4827     */
4828    private void createStackLocked(int stackId, int displayId) {
4829        final long origId = Binder.clearCallingIdentity();
4830        try {
4831            synchronized (mWindowMap) {
4832                final int numDisplays = mDisplayContents.size();
4833                for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) {
4834                    final DisplayContent displayContent = mDisplayContents.valueAt(displayNdx);
4835                    if (displayContent.getDisplayId() == displayId) {
4836                        TaskStack stack = displayContent.createStack(stackId);
4837                        mStackIdToStack.put(stackId, stack);
4838                        performLayoutAndPlaceSurfacesLocked();
4839                        return;
4840                    }
4841                }
4842            }
4843        } finally {
4844            Binder.restoreCallingIdentity(origId);
4845        }
4846    }
4847
4848    public void removeTask(int taskId) {
4849        synchronized (mWindowMap) {
4850            Task task = mTaskIdToTask.get(taskId);
4851            if (task == null) {
4852                if (DEBUG_STACK) Slog.i(TAG, "removeTask: could not find taskId=" + taskId);
4853                return;
4854            }
4855            final TaskStack stack = task.mStack;
4856            EventLog.writeEvent(EventLogTags.WM_TASK_REMOVED, taskId, "removeTask");
4857            stack.removeTask(task);
4858        }
4859    }
4860
4861    public void addTask(int taskId, int stackId, boolean toTop) {
4862        synchronized (mWindowMap) {
4863            Task task = mTaskIdToTask.get(taskId);
4864            if (task == null) {
4865                return;
4866            }
4867            TaskStack stack = mStackIdToStack.get(stackId);
4868            stack.addTask(task, toTop);
4869            final DisplayContent displayContent = stack.getDisplayContent();
4870            displayContent.layoutNeeded = true;
4871            performLayoutAndPlaceSurfacesLocked();
4872        }
4873    }
4874
4875    public void resizeStack(int stackId, Rect bounds) {
4876        synchronized (mWindowMap) {
4877            final TaskStack stack = mStackIdToStack.get(stackId);
4878            if (stack == null) {
4879                throw new IllegalArgumentException("resizeStack: stackId " + stackId
4880                        + " not found.");
4881            }
4882            if (stack.setBounds(bounds)) {
4883                stack.getDisplayContent().layoutNeeded = true;
4884                performLayoutAndPlaceSurfacesLocked();
4885            }
4886        }
4887    }
4888
4889    public void getStackBounds(int stackId, Rect bounds) {
4890        final TaskStack stack = mStackIdToStack.get(stackId);
4891        if (stack != null) {
4892            stack.getBounds(bounds);
4893            return;
4894        }
4895        bounds.setEmpty();
4896    }
4897
4898    // -------------------------------------------------------------
4899    // Misc IWindowSession methods
4900    // -------------------------------------------------------------
4901
4902    @Override
4903    public void startFreezingScreen(int exitAnim, int enterAnim) {
4904        if (!checkCallingPermission(android.Manifest.permission.FREEZE_SCREEN,
4905                "startFreezingScreen()")) {
4906            throw new SecurityException("Requires FREEZE_SCREEN permission");
4907        }
4908
4909        synchronized(mWindowMap) {
4910            if (!mClientFreezingScreen) {
4911                mClientFreezingScreen = true;
4912                final long origId = Binder.clearCallingIdentity();
4913                try {
4914                    startFreezingDisplayLocked(false, exitAnim, enterAnim);
4915                    mH.removeMessages(H.CLIENT_FREEZE_TIMEOUT);
4916                    mH.sendEmptyMessageDelayed(H.CLIENT_FREEZE_TIMEOUT, 5000);
4917                } finally {
4918                    Binder.restoreCallingIdentity(origId);
4919                }
4920            }
4921        }
4922    }
4923
4924    @Override
4925    public void stopFreezingScreen() {
4926        if (!checkCallingPermission(android.Manifest.permission.FREEZE_SCREEN,
4927                "stopFreezingScreen()")) {
4928            throw new SecurityException("Requires FREEZE_SCREEN permission");
4929        }
4930
4931        synchronized(mWindowMap) {
4932            if (mClientFreezingScreen) {
4933                mClientFreezingScreen = false;
4934                mLastFinishedFreezeSource = "client";
4935                final long origId = Binder.clearCallingIdentity();
4936                try {
4937                    stopFreezingDisplayLocked();
4938                } finally {
4939                    Binder.restoreCallingIdentity(origId);
4940                }
4941            }
4942        }
4943    }
4944
4945    @Override
4946    public void disableKeyguard(IBinder token, String tag) {
4947        if (mContext.checkCallingOrSelfPermission(android.Manifest.permission.DISABLE_KEYGUARD)
4948            != PackageManager.PERMISSION_GRANTED) {
4949            throw new SecurityException("Requires DISABLE_KEYGUARD permission");
4950        }
4951
4952        mKeyguardDisableHandler.sendMessage(mKeyguardDisableHandler.obtainMessage(
4953                KeyguardDisableHandler.KEYGUARD_DISABLE, new Pair<IBinder, String>(token, tag)));
4954    }
4955
4956    @Override
4957    public void reenableKeyguard(IBinder token) {
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_REENABLE, token));
4965    }
4966
4967    /**
4968     * @see android.app.KeyguardManager#exitKeyguardSecurely
4969     */
4970    @Override
4971    public void exitKeyguardSecurely(final IOnKeyguardExitResult callback) {
4972        if (mContext.checkCallingOrSelfPermission(android.Manifest.permission.DISABLE_KEYGUARD)
4973            != PackageManager.PERMISSION_GRANTED) {
4974            throw new SecurityException("Requires DISABLE_KEYGUARD permission");
4975        }
4976        mPolicy.exitKeyguardSecurely(new WindowManagerPolicy.OnKeyguardExitResult() {
4977            @Override
4978            public void onKeyguardExitResult(boolean success) {
4979                try {
4980                    callback.onKeyguardExitResult(success);
4981                } catch (RemoteException e) {
4982                    // Client has died, we don't care.
4983                }
4984            }
4985        });
4986    }
4987
4988    @Override
4989    public boolean inKeyguardRestrictedInputMode() {
4990        return mPolicy.inKeyguardRestrictedKeyInputMode();
4991    }
4992
4993    @Override
4994    public boolean isKeyguardLocked() {
4995        return mPolicy.isKeyguardLocked();
4996    }
4997
4998    @Override
4999    public boolean isKeyguardSecure() {
5000        return mPolicy.isKeyguardSecure();
5001    }
5002
5003    @Override
5004    public void dismissKeyguard() {
5005        if (mContext.checkCallingOrSelfPermission(android.Manifest.permission.DISABLE_KEYGUARD)
5006                != PackageManager.PERMISSION_GRANTED) {
5007            throw new SecurityException("Requires DISABLE_KEYGUARD permission");
5008        }
5009        synchronized(mWindowMap) {
5010            mPolicy.dismissKeyguardLw();
5011        }
5012    }
5013
5014    @Override
5015    public void closeSystemDialogs(String reason) {
5016        synchronized(mWindowMap) {
5017            final int numDisplays = mDisplayContents.size();
5018            for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) {
5019                final WindowList windows = mDisplayContents.valueAt(displayNdx).getWindowList();
5020                final int numWindows = windows.size();
5021                for (int winNdx = 0; winNdx < numWindows; ++winNdx) {
5022                    final WindowState w = windows.get(winNdx);
5023                    if (w.mHasSurface) {
5024                        try {
5025                            w.mClient.closeSystemDialogs(reason);
5026                        } catch (RemoteException e) {
5027                        }
5028                    }
5029                }
5030            }
5031        }
5032    }
5033
5034    static float fixScale(float scale) {
5035        if (scale < 0) scale = 0;
5036        else if (scale > 20) scale = 20;
5037        return Math.abs(scale);
5038    }
5039
5040    @Override
5041    public void setAnimationScale(int which, float scale) {
5042        if (!checkCallingPermission(android.Manifest.permission.SET_ANIMATION_SCALE,
5043                "setAnimationScale()")) {
5044            throw new SecurityException("Requires SET_ANIMATION_SCALE permission");
5045        }
5046
5047        scale = fixScale(scale);
5048        switch (which) {
5049            case 0: mWindowAnimationScale = scale; break;
5050            case 1: mTransitionAnimationScale = scale; break;
5051            case 2: mAnimatorDurationScale = scale; break;
5052        }
5053
5054        // Persist setting
5055        mH.sendEmptyMessage(H.PERSIST_ANIMATION_SCALE);
5056    }
5057
5058    @Override
5059    public void setAnimationScales(float[] scales) {
5060        if (!checkCallingPermission(android.Manifest.permission.SET_ANIMATION_SCALE,
5061                "setAnimationScale()")) {
5062            throw new SecurityException("Requires SET_ANIMATION_SCALE permission");
5063        }
5064
5065        if (scales != null) {
5066            if (scales.length >= 1) {
5067                mWindowAnimationScale = fixScale(scales[0]);
5068            }
5069            if (scales.length >= 2) {
5070                mTransitionAnimationScale = fixScale(scales[1]);
5071            }
5072            if (scales.length >= 3) {
5073                setAnimatorDurationScale(fixScale(scales[2]));
5074            }
5075        }
5076
5077        // Persist setting
5078        mH.sendEmptyMessage(H.PERSIST_ANIMATION_SCALE);
5079    }
5080
5081    private void setAnimatorDurationScale(float scale) {
5082        mAnimatorDurationScale = scale;
5083        ValueAnimator.setDurationScale(scale);
5084    }
5085
5086    @Override
5087    public float getAnimationScale(int which) {
5088        switch (which) {
5089            case 0: return mWindowAnimationScale;
5090            case 1: return mTransitionAnimationScale;
5091            case 2: return mAnimatorDurationScale;
5092        }
5093        return 0;
5094    }
5095
5096    @Override
5097    public float[] getAnimationScales() {
5098        return new float[] { mWindowAnimationScale, mTransitionAnimationScale,
5099                mAnimatorDurationScale };
5100    }
5101
5102    @Override
5103    public void registerPointerEventListener(PointerEventListener listener) {
5104        mPointerEventDispatcher.registerInputEventListener(listener);
5105    }
5106
5107    @Override
5108    public void unregisterPointerEventListener(PointerEventListener listener) {
5109        mPointerEventDispatcher.unregisterInputEventListener(listener);
5110    }
5111
5112    // Called by window manager policy. Not exposed externally.
5113    @Override
5114    public int getLidState() {
5115        int sw = mInputManager.getSwitchState(-1, InputDevice.SOURCE_ANY,
5116                InputManagerService.SW_LID);
5117        if (sw > 0) {
5118            // Switch state: AKEY_STATE_DOWN or AKEY_STATE_VIRTUAL.
5119            return LID_CLOSED;
5120        } else if (sw == 0) {
5121            // Switch state: AKEY_STATE_UP.
5122            return LID_OPEN;
5123        } else {
5124            // Switch state: AKEY_STATE_UNKNOWN.
5125            return LID_ABSENT;
5126        }
5127    }
5128
5129    // Called by window manager policy.  Not exposed externally.
5130    @Override
5131    public void switchKeyboardLayout(int deviceId, int direction) {
5132        mInputManager.switchKeyboardLayout(deviceId, direction);
5133    }
5134
5135    // Called by window manager policy.  Not exposed externally.
5136    @Override
5137    public void shutdown(boolean confirm) {
5138        ShutdownThread.shutdown(mContext, confirm);
5139    }
5140
5141    // Called by window manager policy.  Not exposed externally.
5142    @Override
5143    public void rebootSafeMode(boolean confirm) {
5144        ShutdownThread.rebootSafeMode(mContext, confirm);
5145    }
5146
5147    @Override
5148    public void setInputFilter(IInputFilter filter) {
5149        if (!checkCallingPermission(android.Manifest.permission.FILTER_EVENTS, "setInputFilter()")) {
5150            throw new SecurityException("Requires FILTER_EVENTS permission");
5151        }
5152        mInputManager.setInputFilter(filter);
5153    }
5154
5155    @Override
5156    public void setTouchExplorationEnabled(boolean enabled) {
5157        mPolicy.setTouchExplorationEnabled(enabled);
5158    }
5159
5160    public void setCurrentUser(final int newUserId) {
5161        synchronized (mWindowMap) {
5162            int oldUserId = mCurrentUserId;
5163            mCurrentUserId = newUserId;
5164            mAppTransition.setCurrentUser(newUserId);
5165            mPolicy.setCurrentUserLw(newUserId);
5166
5167            // Hide windows that should not be seen by the new user.
5168            final int numDisplays = mDisplayContents.size();
5169            for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) {
5170                final DisplayContent displayContent = mDisplayContents.valueAt(displayNdx);
5171                displayContent.switchUserStacks(oldUserId, newUserId);
5172                rebuildAppWindowListLocked(displayContent);
5173            }
5174            performLayoutAndPlaceSurfacesLocked();
5175        }
5176    }
5177
5178    public void enableScreenAfterBoot() {
5179        synchronized(mWindowMap) {
5180            if (DEBUG_BOOT) {
5181                RuntimeException here = new RuntimeException("here");
5182                here.fillInStackTrace();
5183                Slog.i(TAG, "enableScreenAfterBoot: mDisplayEnabled=" + mDisplayEnabled
5184                        + " mForceDisplayEnabled=" + mForceDisplayEnabled
5185                        + " mShowingBootMessages=" + mShowingBootMessages
5186                        + " mSystemBooted=" + mSystemBooted, here);
5187            }
5188            if (mSystemBooted) {
5189                return;
5190            }
5191            mSystemBooted = true;
5192            hideBootMessagesLocked();
5193            // If the screen still doesn't come up after 30 seconds, give
5194            // up and turn it on.
5195            mH.sendEmptyMessageDelayed(H.BOOT_TIMEOUT, 30*1000);
5196        }
5197
5198        mPolicy.systemBooted();
5199
5200        performEnableScreen();
5201    }
5202
5203    void enableScreenIfNeededLocked() {
5204        if (DEBUG_BOOT) {
5205            RuntimeException here = new RuntimeException("here");
5206            here.fillInStackTrace();
5207            Slog.i(TAG, "enableScreenIfNeededLocked: mDisplayEnabled=" + mDisplayEnabled
5208                    + " mForceDisplayEnabled=" + mForceDisplayEnabled
5209                    + " mShowingBootMessages=" + mShowingBootMessages
5210                    + " mSystemBooted=" + mSystemBooted, here);
5211        }
5212        if (mDisplayEnabled) {
5213            return;
5214        }
5215        if (!mSystemBooted && !mShowingBootMessages) {
5216            return;
5217        }
5218        mH.sendEmptyMessage(H.ENABLE_SCREEN);
5219    }
5220
5221    public void performBootTimeout() {
5222        synchronized(mWindowMap) {
5223            if (mDisplayEnabled) {
5224                return;
5225            }
5226            Slog.w(TAG, "***** BOOT TIMEOUT: forcing display enabled");
5227            mForceDisplayEnabled = true;
5228        }
5229        performEnableScreen();
5230    }
5231
5232    public void performEnableScreen() {
5233        synchronized(mWindowMap) {
5234            if (DEBUG_BOOT) {
5235                RuntimeException here = new RuntimeException("here");
5236                here.fillInStackTrace();
5237                Slog.i(TAG, "performEnableScreen: mDisplayEnabled=" + mDisplayEnabled
5238                        + " mForceDisplayEnabled=" + mForceDisplayEnabled
5239                        + " mShowingBootMessages=" + mShowingBootMessages
5240                        + " mSystemBooted=" + mSystemBooted
5241                        + " mOnlyCore=" + mOnlyCore, here);
5242            }
5243            if (mDisplayEnabled) {
5244                return;
5245            }
5246            if (!mSystemBooted && !mShowingBootMessages) {
5247                return;
5248            }
5249
5250            if (!mForceDisplayEnabled) {
5251                // Don't enable the screen until all existing windows
5252                // have been drawn.
5253                boolean haveBootMsg = false;
5254                boolean haveApp = false;
5255                // if the wallpaper service is disabled on the device, we're never going to have
5256                // wallpaper, don't bother waiting for it
5257                boolean haveWallpaper = false;
5258                boolean wallpaperEnabled = mContext.getResources().getBoolean(
5259                        com.android.internal.R.bool.config_enableWallpaperService)
5260                        && !mOnlyCore;
5261                boolean haveKeyguard = true;
5262                // TODO(multidisplay): Expand to all displays?
5263                final WindowList windows = getDefaultWindowListLocked();
5264                final int N = windows.size();
5265                for (int i=0; i<N; i++) {
5266                    WindowState w = windows.get(i);
5267                    if (w.mAttrs.type == TYPE_KEYGUARD) {
5268                        // Only if there is a keyguard attached to the window manager
5269                        // will we consider ourselves as having a keyguard.  If it
5270                        // isn't attached, we don't know if it wants to be shown or
5271                        // hidden.  If it is attached, we will say we have a keyguard
5272                        // if the window doesn't want to be visible, because in that
5273                        // case it explicitly doesn't want to be shown so we should
5274                        // not delay turning the screen on for it.
5275                        boolean vis = w.mViewVisibility == View.VISIBLE
5276                                && w.mPolicyVisibility;
5277                        haveKeyguard = !vis;
5278                    }
5279                    if (w.isVisibleLw() && !w.mObscured && !w.isDrawnLw()) {
5280                        return;
5281                    }
5282                    if (w.isDrawnLw()) {
5283                        if (w.mAttrs.type == TYPE_BOOT_PROGRESS) {
5284                            haveBootMsg = true;
5285                        } else if (w.mAttrs.type == TYPE_APPLICATION) {
5286                            haveApp = true;
5287                        } else if (w.mAttrs.type == TYPE_WALLPAPER) {
5288                            haveWallpaper = true;
5289                        } else if (w.mAttrs.type == TYPE_KEYGUARD) {
5290                            haveKeyguard = true;
5291                        }
5292                    }
5293                }
5294
5295                if (DEBUG_SCREEN_ON || DEBUG_BOOT) {
5296                    Slog.i(TAG, "******** booted=" + mSystemBooted + " msg=" + mShowingBootMessages
5297                            + " haveBoot=" + haveBootMsg + " haveApp=" + haveApp
5298                            + " haveWall=" + haveWallpaper + " wallEnabled=" + wallpaperEnabled
5299                            + " haveKeyguard=" + haveKeyguard);
5300                }
5301
5302                // If we are turning on the screen to show the boot message,
5303                // don't do it until the boot message is actually displayed.
5304                if (!mSystemBooted && !haveBootMsg) {
5305                    return;
5306                }
5307
5308                // If we are turning on the screen after the boot is completed
5309                // normally, don't do so until we have the application and
5310                // wallpaper.
5311                if (mSystemBooted && ((!haveApp && !haveKeyguard) ||
5312                        (wallpaperEnabled && !haveWallpaper))) {
5313                    return;
5314                }
5315            }
5316
5317            mDisplayEnabled = true;
5318            if (DEBUG_SCREEN_ON || DEBUG_BOOT) Slog.i(TAG, "******************** ENABLING SCREEN!");
5319            if (false) {
5320                StringWriter sw = new StringWriter();
5321                PrintWriter pw = new FastPrintWriter(sw, false, 1024);
5322                this.dump(null, pw, null);
5323                pw.flush();
5324                Slog.i(TAG, sw.toString());
5325            }
5326            try {
5327                IBinder surfaceFlinger = ServiceManager.getService("SurfaceFlinger");
5328                if (surfaceFlinger != null) {
5329                    //Slog.i(TAG, "******* TELLING SURFACE FLINGER WE ARE BOOTED!");
5330                    Parcel data = Parcel.obtain();
5331                    data.writeInterfaceToken("android.ui.ISurfaceComposer");
5332                    surfaceFlinger.transact(IBinder.FIRST_CALL_TRANSACTION, // BOOT_FINISHED
5333                                            data, null, 0);
5334                    data.recycle();
5335                }
5336            } catch (RemoteException ex) {
5337                Slog.e(TAG, "Boot completed: SurfaceFlinger is dead!");
5338            }
5339
5340            // Enable input dispatch.
5341            mInputMonitor.setEventDispatchingLw(mEventDispatchingEnabled);
5342        }
5343
5344        mPolicy.enableScreenAfterBoot();
5345
5346        // Make sure the last requested orientation has been applied.
5347        updateRotationUnchecked(false, false);
5348    }
5349
5350    public void showBootMessage(final CharSequence msg, final boolean always) {
5351        boolean first = false;
5352        synchronized(mWindowMap) {
5353            if (DEBUG_BOOT) {
5354                RuntimeException here = new RuntimeException("here");
5355                here.fillInStackTrace();
5356                Slog.i(TAG, "showBootMessage: msg=" + msg + " always=" + always
5357                        + " mAllowBootMessages=" + mAllowBootMessages
5358                        + " mShowingBootMessages=" + mShowingBootMessages
5359                        + " mSystemBooted=" + mSystemBooted, here);
5360            }
5361            if (!mAllowBootMessages) {
5362                return;
5363            }
5364            if (!mShowingBootMessages) {
5365                if (!always) {
5366                    return;
5367                }
5368                first = true;
5369            }
5370            if (mSystemBooted) {
5371                return;
5372            }
5373            mShowingBootMessages = true;
5374            mPolicy.showBootMessage(msg, always);
5375        }
5376        if (first) {
5377            performEnableScreen();
5378        }
5379    }
5380
5381    public void hideBootMessagesLocked() {
5382        if (DEBUG_BOOT) {
5383            RuntimeException here = new RuntimeException("here");
5384            here.fillInStackTrace();
5385            Slog.i(TAG, "hideBootMessagesLocked: mDisplayEnabled=" + mDisplayEnabled
5386                    + " mForceDisplayEnabled=" + mForceDisplayEnabled
5387                    + " mShowingBootMessages=" + mShowingBootMessages
5388                    + " mSystemBooted=" + mSystemBooted, here);
5389        }
5390        if (mShowingBootMessages) {
5391            mShowingBootMessages = false;
5392            mPolicy.hideBootMessages();
5393        }
5394    }
5395
5396    @Override
5397    public void setInTouchMode(boolean mode) {
5398        synchronized(mWindowMap) {
5399            mInTouchMode = mode;
5400        }
5401    }
5402
5403    // TODO: more accounting of which pid(s) turned it on, keep count,
5404    // only allow disables from pids which have count on, etc.
5405    @Override
5406    public void showStrictModeViolation(boolean on) {
5407        int pid = Binder.getCallingPid();
5408        mH.sendMessage(mH.obtainMessage(H.SHOW_STRICT_MODE_VIOLATION, on ? 1 : 0, pid));
5409    }
5410
5411    private void showStrictModeViolation(int arg, int pid) {
5412        final boolean on = arg != 0;
5413        synchronized(mWindowMap) {
5414            // Ignoring requests to enable the red border from clients
5415            // which aren't on screen.  (e.g. Broadcast Receivers in
5416            // the background..)
5417            if (on) {
5418                boolean isVisible = false;
5419                final int numDisplays = mDisplayContents.size();
5420                for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) {
5421                    final WindowList windows = mDisplayContents.valueAt(displayNdx).getWindowList();
5422                    final int numWindows = windows.size();
5423                    for (int winNdx = 0; winNdx < numWindows; ++winNdx) {
5424                        final WindowState ws = windows.get(winNdx);
5425                        if (ws.mSession.mPid == pid && ws.isVisibleLw()) {
5426                            isVisible = true;
5427                            break;
5428                        }
5429                    }
5430                }
5431                if (!isVisible) {
5432                    return;
5433                }
5434            }
5435
5436            if (SHOW_LIGHT_TRANSACTIONS) Slog.i(TAG,
5437                    ">>> OPEN TRANSACTION showStrictModeViolation");
5438            SurfaceControl.openTransaction();
5439            try {
5440                // TODO(multi-display): support multiple displays
5441                if (mStrictModeFlash == null) {
5442                    mStrictModeFlash = new StrictModeFlash(
5443                            getDefaultDisplayContentLocked().getDisplay(), mFxSession);
5444                }
5445                mStrictModeFlash.setVisibility(on);
5446            } finally {
5447                SurfaceControl.closeTransaction();
5448                if (SHOW_LIGHT_TRANSACTIONS) Slog.i(TAG,
5449                        "<<< CLOSE TRANSACTION showStrictModeViolation");
5450            }
5451        }
5452    }
5453
5454    @Override
5455    public void setStrictModeVisualIndicatorPreference(String value) {
5456        SystemProperties.set(StrictMode.VISUAL_PROPERTY, value);
5457    }
5458
5459    /**
5460     * Takes a snapshot of the screen.  In landscape mode this grabs the whole screen.
5461     * In portrait mode, it grabs the upper region of the screen based on the vertical dimension
5462     * of the target image.
5463     *
5464     * @param displayId the Display to take a screenshot of.
5465     * @param width the width of the target bitmap
5466     * @param height the height of the target bitmap
5467     * @param force565 if true the returned bitmap will be RGB_565, otherwise it
5468     *                 will be the same config as the surface
5469     */
5470    @Override
5471    public Bitmap screenshotApplications(IBinder appToken, int displayId, int width,
5472            int height, boolean force565) {
5473        if (!checkCallingPermission(android.Manifest.permission.READ_FRAME_BUFFER,
5474                "screenshotApplications()")) {
5475            throw new SecurityException("Requires READ_FRAME_BUFFER permission");
5476        }
5477
5478        Bitmap rawss = null;
5479
5480        int maxLayer = 0;
5481        final Rect frame = new Rect();
5482
5483        float scale = 0;
5484        int dw, dh;
5485        int rot = Surface.ROTATION_0;
5486
5487        boolean screenshotReady;
5488        int minLayer;
5489        if (appToken == null) {
5490            screenshotReady = true;
5491            minLayer = 0;
5492        } else {
5493            screenshotReady = false;
5494            minLayer = Integer.MAX_VALUE;
5495        }
5496
5497        int retryCount = 0;
5498        WindowState appWin = null;
5499
5500        do {
5501            if (retryCount++ > 0) {
5502                try {
5503                    Thread.sleep(100);
5504                } catch (InterruptedException e) {
5505                }
5506            }
5507            synchronized(mWindowMap) {
5508                final DisplayContent displayContent = getDisplayContentLocked(displayId);
5509                if (displayContent == null) {
5510                    return null;
5511                }
5512                final DisplayInfo displayInfo = displayContent.getDisplayInfo();
5513                dw = displayInfo.logicalWidth;
5514                dh = displayInfo.logicalHeight;
5515
5516                int aboveAppLayer = mPolicy.windowTypeToLayerLw(TYPE_APPLICATION)
5517                        * TYPE_LAYER_MULTIPLIER + TYPE_LAYER_OFFSET;
5518                aboveAppLayer += TYPE_LAYER_MULTIPLIER;
5519
5520                boolean isImeTarget = mInputMethodTarget != null
5521                        && mInputMethodTarget.mAppToken != null
5522                        && mInputMethodTarget.mAppToken.appToken != null
5523                        && mInputMethodTarget.mAppToken.appToken.asBinder() == appToken;
5524
5525                // Figure out the part of the screen that is actually the app.
5526                boolean including = false;
5527                appWin = null;
5528                final WindowList windows = displayContent.getWindowList();
5529                final Rect stackBounds = new Rect();
5530                for (int i = windows.size() - 1; i >= 0; i--) {
5531                    WindowState ws = windows.get(i);
5532                    if (!ws.mHasSurface) {
5533                        continue;
5534                    }
5535                    if (ws.mLayer >= aboveAppLayer) {
5536                        continue;
5537                    }
5538                    // When we will skip windows: when we are not including
5539                    // ones behind a window we didn't skip, and we are actually
5540                    // taking a screenshot of a specific app.
5541                    if (!including && appToken != null) {
5542                        // Also, we can possibly skip this window if it is not
5543                        // an IME target or the application for the screenshot
5544                        // is not the current IME target.
5545                        if (!ws.mIsImWindow || !isImeTarget) {
5546                            // And finally, this window is of no interest if it
5547                            // is not associated with the screenshot app.
5548                            if (ws.mAppToken == null || ws.mAppToken.token != appToken) {
5549                                continue;
5550                            }
5551                            appWin = ws;
5552                            ws.getStackBounds(stackBounds);
5553                        }
5554                    }
5555
5556                    // We keep on including windows until we go past a full-screen
5557                    // window.
5558                    including = !ws.mIsImWindow && !ws.isFullscreen(dw, dh);
5559
5560                    final WindowStateAnimator winAnim = ws.mWinAnimator;
5561                    if (maxLayer < winAnim.mSurfaceLayer) {
5562                        maxLayer = winAnim.mSurfaceLayer;
5563                    }
5564                    if (minLayer > winAnim.mSurfaceLayer) {
5565                        minLayer = winAnim.mSurfaceLayer;
5566                    }
5567
5568                    // Don't include wallpaper in bounds calculation
5569                    if (!ws.mIsWallpaper) {
5570                        final Rect wf = ws.mFrame;
5571                        final Rect cr = ws.mContentInsets;
5572                        int left = wf.left + cr.left;
5573                        int top = wf.top + cr.top;
5574                        int right = wf.right - cr.right;
5575                        int bottom = wf.bottom - cr.bottom;
5576                        frame.union(left, top, right, bottom);
5577                        frame.intersect(stackBounds);
5578                    }
5579
5580                    if (ws.mAppToken != null && ws.mAppToken.token == appToken &&
5581                            ws.isDisplayedLw()) {
5582                        screenshotReady = true;
5583                    }
5584                }
5585
5586                if (appToken != null && appWin == null) {
5587                    // Can't find a window to snapshot.
5588                    if (DEBUG_SCREENSHOT) Slog.i(TAG,
5589                            "Screenshot: Couldn't find a surface matching " + appToken);
5590                    return null;
5591                }
5592                if (!screenshotReady) {
5593                    // Delay and hope that window gets drawn.
5594                    if (DEBUG_SCREENSHOT) Slog.i(TAG, "Screenshot: No image ready for " + appToken
5595                            + ", " + appWin + " drawState=" + appWin.mWinAnimator.mDrawState);
5596                    continue;
5597                }
5598
5599                // Constrain frame to the screen size.
5600                frame.intersect(0, 0, dw, dh);
5601
5602                if (frame.isEmpty() || maxLayer == 0) {
5603                    if (DEBUG_SCREENSHOT) Slog.i(TAG, "Screenshot of " + appToken
5604                            + ": returning null frame=" + frame.toShortString() + " maxLayer="
5605                            + maxLayer);
5606                    return null;
5607                }
5608
5609                // The screenshot API does not apply the current screen rotation.
5610                rot = getDefaultDisplayContentLocked().getDisplay().getRotation();
5611                int fw = frame.width();
5612                int fh = frame.height();
5613
5614                // Constrain thumbnail to smaller of screen width or height. Assumes aspect
5615                // of thumbnail is the same as the screen (in landscape) or square.
5616                scale = Math.max(width / (float) fw, height / (float) fh);
5617                /*
5618                float targetWidthScale = width / (float) fw;
5619                float targetHeightScale = height / (float) fh;
5620                if (fw <= fh) {
5621                    scale = targetWidthScale;
5622                    // If aspect of thumbnail is the same as the screen (in landscape),
5623                    // select the slightly larger value so we fill the entire bitmap
5624                    if (targetHeightScale > scale && (int) (targetHeightScale * fw) == width) {
5625                        scale = targetHeightScale;
5626                    }
5627                } else {
5628                    scale = targetHeightScale;
5629                    // If aspect of thumbnail is the same as the screen (in landscape),
5630                    // select the slightly larger value so we fill the entire bitmap
5631                    if (targetWidthScale > scale && (int) (targetWidthScale * fh) == height) {
5632                        scale = targetWidthScale;
5633                    }
5634                }
5635                */
5636
5637                // The screen shot will contain the entire screen.
5638                dw = (int)(dw*scale);
5639                dh = (int)(dh*scale);
5640                if (rot == Surface.ROTATION_90 || rot == Surface.ROTATION_270) {
5641                    int tmp = dw;
5642                    dw = dh;
5643                    dh = tmp;
5644                    rot = (rot == Surface.ROTATION_90) ? Surface.ROTATION_270 : Surface.ROTATION_90;
5645                }
5646                if (DEBUG_SCREENSHOT) {
5647                    Slog.i(TAG, "Screenshot: " + dw + "x" + dh + " from " + minLayer + " to "
5648                            + maxLayer + " appToken=" + appToken);
5649                    for (int i = 0; i < windows.size(); i++) {
5650                        WindowState win = windows.get(i);
5651                        Slog.i(TAG, win + ": " + win.mLayer
5652                                + " animLayer=" + win.mWinAnimator.mAnimLayer
5653                                + " surfaceLayer=" + win.mWinAnimator.mSurfaceLayer);
5654                    }
5655                }
5656                rawss = SurfaceControl.screenshot(dw, dh, minLayer, maxLayer);
5657            }
5658        } while (!screenshotReady && retryCount <= MAX_SCREENSHOT_RETRIES);
5659        if (retryCount > MAX_SCREENSHOT_RETRIES)  Slog.i(TAG, "Screenshot max retries " +
5660                retryCount + " of " + appToken + " appWin=" + (appWin == null ?
5661                        "null" : (appWin + " drawState=" + appWin.mWinAnimator.mDrawState)));
5662
5663        if (rawss == null) {
5664            Slog.w(TAG, "Screenshot failure taking screenshot for (" + dw + "x" + dh
5665                    + ") to layer " + maxLayer);
5666            return null;
5667        }
5668
5669        Bitmap bm = Bitmap.createBitmap(width, height, force565 ? Config.RGB_565 : rawss.getConfig());
5670        frame.scale(scale);
5671        Matrix matrix = new Matrix();
5672        ScreenRotationAnimation.createRotationMatrix(rot, dw, dh, matrix);
5673        // TODO: Test for RTL vs. LTR and use frame.right-width instead of -frame.left
5674        matrix.postTranslate(-FloatMath.ceil(frame.left), -FloatMath.ceil(frame.top));
5675        Canvas canvas = new Canvas(bm);
5676        canvas.drawColor(0xFF000000);
5677        canvas.drawBitmap(rawss, matrix, null);
5678        canvas.setBitmap(null);
5679
5680        if (DEBUG_SCREENSHOT) {
5681            // TEST IF IT's ALL BLACK
5682            int[] buffer = new int[bm.getWidth() * bm.getHeight()];
5683            bm.getPixels(buffer, 0, bm.getWidth(), 0, 0, bm.getWidth(), bm.getHeight());
5684            boolean allBlack = true;
5685            final int firstColor = buffer[0];
5686            for (int i = 0; i < buffer.length; i++) {
5687                if (buffer[i] != firstColor) {
5688                    allBlack = false;
5689                    break;
5690                }
5691            }
5692            if (allBlack) {
5693                Slog.i(TAG, "Screenshot " + appWin + " was monochrome(" +
5694                        Integer.toHexString(firstColor) + ")! mSurfaceLayer=" +
5695                        (appWin != null ? appWin.mWinAnimator.mSurfaceLayer : "null") +
5696                        " minLayer=" + minLayer + " maxLayer=" + maxLayer);
5697            }
5698        }
5699
5700        rawss.recycle();
5701        return bm;
5702    }
5703
5704    /**
5705     * Freeze rotation changes.  (Enable "rotation lock".)
5706     * Persists across reboots.
5707     * @param rotation The desired rotation to freeze to, or -1 to use the
5708     * current rotation.
5709     */
5710    @Override
5711    public void freezeRotation(int rotation) {
5712        if (!checkCallingPermission(android.Manifest.permission.SET_ORIENTATION,
5713                "freezeRotation()")) {
5714            throw new SecurityException("Requires SET_ORIENTATION permission");
5715        }
5716        if (rotation < -1 || rotation > Surface.ROTATION_270) {
5717            throw new IllegalArgumentException("Rotation argument must be -1 or a valid "
5718                    + "rotation constant.");
5719        }
5720
5721        if (DEBUG_ORIENTATION) Slog.v(TAG, "freezeRotation: mRotation=" + mRotation);
5722
5723        long origId = Binder.clearCallingIdentity();
5724        try {
5725            mPolicy.setUserRotationMode(WindowManagerPolicy.USER_ROTATION_LOCKED,
5726                    rotation == -1 ? mRotation : rotation);
5727        } finally {
5728            Binder.restoreCallingIdentity(origId);
5729        }
5730
5731        updateRotationUnchecked(false, false);
5732    }
5733
5734    /**
5735     * Thaw rotation changes.  (Disable "rotation lock".)
5736     * Persists across reboots.
5737     */
5738    @Override
5739    public void thawRotation() {
5740        if (!checkCallingPermission(android.Manifest.permission.SET_ORIENTATION,
5741                "thawRotation()")) {
5742            throw new SecurityException("Requires SET_ORIENTATION permission");
5743        }
5744
5745        if (DEBUG_ORIENTATION) Slog.v(TAG, "thawRotation: mRotation=" + mRotation);
5746
5747        long origId = Binder.clearCallingIdentity();
5748        try {
5749            mPolicy.setUserRotationMode(WindowManagerPolicy.USER_ROTATION_FREE,
5750                    777); // rot not used
5751        } finally {
5752            Binder.restoreCallingIdentity(origId);
5753        }
5754
5755        updateRotationUnchecked(false, false);
5756    }
5757
5758    /**
5759     * Recalculate the current rotation.
5760     *
5761     * Called by the window manager policy whenever the state of the system changes
5762     * such that the current rotation might need to be updated, such as when the
5763     * device is docked or rotated into a new posture.
5764     */
5765    @Override
5766    public void updateRotation(boolean alwaysSendConfiguration, boolean forceRelayout) {
5767        updateRotationUnchecked(alwaysSendConfiguration, forceRelayout);
5768    }
5769
5770    /**
5771     * Temporarily pauses rotation changes until resumed.
5772     *
5773     * This can be used to prevent rotation changes from occurring while the user is
5774     * performing certain operations, such as drag and drop.
5775     *
5776     * This call nests and must be matched by an equal number of calls to
5777     * {@link #resumeRotationLocked}.
5778     */
5779    void pauseRotationLocked() {
5780        mDeferredRotationPauseCount += 1;
5781    }
5782
5783    /**
5784     * Resumes normal rotation changes after being paused.
5785     */
5786    void resumeRotationLocked() {
5787        if (mDeferredRotationPauseCount > 0) {
5788            mDeferredRotationPauseCount -= 1;
5789            if (mDeferredRotationPauseCount == 0) {
5790                boolean changed = updateRotationUncheckedLocked(false);
5791                if (changed) {
5792                    mH.sendEmptyMessage(H.SEND_NEW_CONFIGURATION);
5793                }
5794            }
5795        }
5796    }
5797
5798    public void updateRotationUnchecked(boolean alwaysSendConfiguration, boolean forceRelayout) {
5799        if(DEBUG_ORIENTATION) Slog.v(TAG, "updateRotationUnchecked("
5800                   + "alwaysSendConfiguration=" + alwaysSendConfiguration + ")");
5801
5802        long origId = Binder.clearCallingIdentity();
5803        boolean changed;
5804        synchronized(mWindowMap) {
5805            changed = updateRotationUncheckedLocked(false);
5806            if (!changed || forceRelayout) {
5807                getDefaultDisplayContentLocked().layoutNeeded = true;
5808                performLayoutAndPlaceSurfacesLocked();
5809            }
5810        }
5811
5812        if (changed || alwaysSendConfiguration) {
5813            sendNewConfiguration();
5814        }
5815
5816        Binder.restoreCallingIdentity(origId);
5817    }
5818
5819    // TODO(multidisplay): Rotate any display?
5820    /**
5821     * Updates the current rotation.
5822     *
5823     * Returns true if the rotation has been changed.  In this case YOU
5824     * MUST CALL sendNewConfiguration() TO UNFREEZE THE SCREEN.
5825     */
5826    public boolean updateRotationUncheckedLocked(boolean inTransaction) {
5827        if (mDeferredRotationPauseCount > 0) {
5828            // Rotation updates have been paused temporarily.  Defer the update until
5829            // updates have been resumed.
5830            if (DEBUG_ORIENTATION) Slog.v(TAG, "Deferring rotation, rotation is paused.");
5831            return false;
5832        }
5833
5834        ScreenRotationAnimation screenRotationAnimation =
5835                mAnimator.getScreenRotationAnimationLocked(Display.DEFAULT_DISPLAY);
5836        if (screenRotationAnimation != null && screenRotationAnimation.isAnimating()) {
5837            // Rotation updates cannot be performed while the previous rotation change
5838            // animation is still in progress.  Skip this update.  We will try updating
5839            // again after the animation is finished and the display is unfrozen.
5840            if (DEBUG_ORIENTATION) Slog.v(TAG, "Deferring rotation, animation in progress.");
5841            return false;
5842        }
5843
5844        if (!mDisplayEnabled) {
5845            // No point choosing a rotation if the display is not enabled.
5846            if (DEBUG_ORIENTATION) Slog.v(TAG, "Deferring rotation, display is not enabled.");
5847            return false;
5848        }
5849
5850        // TODO: Implement forced rotation changes.
5851        //       Set mAltOrientation to indicate that the application is receiving
5852        //       an orientation that has different metrics than it expected.
5853        //       eg. Portrait instead of Landscape.
5854
5855        int rotation = mPolicy.rotationForOrientationLw(mForcedAppOrientation, mRotation);
5856        boolean altOrientation = !mPolicy.rotationHasCompatibleMetricsLw(
5857                mForcedAppOrientation, rotation);
5858
5859        if (DEBUG_ORIENTATION) {
5860            Slog.v(TAG, "Application requested orientation "
5861                    + mForcedAppOrientation + ", got rotation " + rotation
5862                    + " which has " + (altOrientation ? "incompatible" : "compatible")
5863                    + " metrics");
5864        }
5865
5866        if (mRotation == rotation && mAltOrientation == altOrientation) {
5867            // No change.
5868            return false;
5869        }
5870
5871        if (DEBUG_ORIENTATION) {
5872            Slog.v(TAG,
5873                "Rotation changed to " + rotation + (altOrientation ? " (alt)" : "")
5874                + " from " + mRotation + (mAltOrientation ? " (alt)" : "")
5875                + ", forceApp=" + mForcedAppOrientation);
5876        }
5877
5878        mRotation = rotation;
5879        mAltOrientation = altOrientation;
5880        mPolicy.setRotationLw(mRotation);
5881
5882        mWindowsFreezingScreen = true;
5883        mH.removeMessages(H.WINDOW_FREEZE_TIMEOUT);
5884        mH.sendEmptyMessageDelayed(H.WINDOW_FREEZE_TIMEOUT, WINDOW_FREEZE_TIMEOUT_DURATION);
5885        mWaitingForConfig = true;
5886        final DisplayContent displayContent = getDefaultDisplayContentLocked();
5887        displayContent.layoutNeeded = true;
5888        final int[] anim = new int[2];
5889        if (displayContent.isDimming()) {
5890            anim[0] = anim[1] = 0;
5891        } else {
5892            mPolicy.selectRotationAnimationLw(anim);
5893        }
5894        startFreezingDisplayLocked(inTransaction, anim[0], anim[1]);
5895        // startFreezingDisplayLocked can reset the ScreenRotationAnimation.
5896        screenRotationAnimation =
5897                mAnimator.getScreenRotationAnimationLocked(Display.DEFAULT_DISPLAY);
5898
5899        // We need to update our screen size information to match the new
5900        // rotation.  Note that this is redundant with the later call to
5901        // sendNewConfiguration() that must be called after this function
5902        // returns...  however we need to do the screen size part of that
5903        // before then so we have the correct size to use when initializing
5904        // the rotation animation for the new rotation.
5905        computeScreenConfigurationLocked(null);
5906
5907        final DisplayInfo displayInfo = displayContent.getDisplayInfo();
5908        if (!inTransaction) {
5909            if (SHOW_TRANSACTIONS) {
5910                Slog.i(TAG, ">>> OPEN TRANSACTION setRotationUnchecked");
5911            }
5912            SurfaceControl.openTransaction();
5913        }
5914        try {
5915            // NOTE: We disable the rotation in the emulator because
5916            //       it doesn't support hardware OpenGL emulation yet.
5917            if (CUSTOM_SCREEN_ROTATION && screenRotationAnimation != null
5918                    && screenRotationAnimation.hasScreenshot()) {
5919                if (screenRotationAnimation.setRotationInTransaction(
5920                        rotation, mFxSession,
5921                        MAX_ANIMATION_DURATION, mTransitionAnimationScale,
5922                        displayInfo.logicalWidth, displayInfo.logicalHeight)) {
5923                    scheduleAnimationLocked();
5924                }
5925            }
5926
5927            mDisplayManagerService.performTraversalInTransactionFromWindowManager();
5928        } finally {
5929            if (!inTransaction) {
5930                SurfaceControl.closeTransaction();
5931                if (SHOW_LIGHT_TRANSACTIONS) {
5932                    Slog.i(TAG, "<<< CLOSE TRANSACTION setRotationUnchecked");
5933                }
5934            }
5935        }
5936
5937        final WindowList windows = displayContent.getWindowList();
5938        for (int i = windows.size() - 1; i >= 0; i--) {
5939            WindowState w = windows.get(i);
5940            if (w.mHasSurface) {
5941                if (DEBUG_ORIENTATION) Slog.v(TAG, "Set mOrientationChanging of " + w);
5942                w.mOrientationChanging = true;
5943                mInnerFields.mOrientationChangeComplete = false;
5944            }
5945            w.mLastFreezeDuration = 0;
5946        }
5947
5948        for (int i=mRotationWatchers.size()-1; i>=0; i--) {
5949            try {
5950                mRotationWatchers.get(i).onRotationChanged(rotation);
5951            } catch (RemoteException e) {
5952            }
5953        }
5954
5955        //TODO (multidisplay): Magnification is supported only for the default display.
5956        if (mDisplayMagnifier != null
5957                && displayContent.getDisplayId() == Display.DEFAULT_DISPLAY) {
5958            mDisplayMagnifier.onRotationChangedLocked(getDefaultDisplayContentLocked(), rotation);
5959        }
5960
5961        return true;
5962    }
5963
5964    @Override
5965    public int getRotation() {
5966        return mRotation;
5967    }
5968
5969    @Override
5970    public boolean isRotationFrozen() {
5971        return mPolicy.getUserRotationMode() == WindowManagerPolicy.USER_ROTATION_LOCKED;
5972    }
5973
5974    @Override
5975    public int watchRotation(IRotationWatcher watcher) {
5976        final IBinder watcherBinder = watcher.asBinder();
5977        IBinder.DeathRecipient dr = new IBinder.DeathRecipient() {
5978            @Override
5979            public void binderDied() {
5980                synchronized (mWindowMap) {
5981                    for (int i=0; i<mRotationWatchers.size(); i++) {
5982                        if (watcherBinder == mRotationWatchers.get(i).asBinder()) {
5983                            IRotationWatcher removed = mRotationWatchers.remove(i);
5984                            if (removed != null) {
5985                                removed.asBinder().unlinkToDeath(this, 0);
5986                            }
5987                            i--;
5988                        }
5989                    }
5990                }
5991            }
5992        };
5993
5994        synchronized (mWindowMap) {
5995            try {
5996                watcher.asBinder().linkToDeath(dr, 0);
5997                mRotationWatchers.add(watcher);
5998            } catch (RemoteException e) {
5999                // Client died, no cleanup needed.
6000            }
6001
6002            return mRotation;
6003        }
6004    }
6005
6006    @Override
6007    public void removeRotationWatcher(IRotationWatcher watcher) {
6008        final IBinder watcherBinder = watcher.asBinder();
6009        synchronized (mWindowMap) {
6010            for (int i=0; i<mRotationWatchers.size(); i++) {
6011                if (watcherBinder == mRotationWatchers.get(i).asBinder()) {
6012                    mRotationWatchers.remove(i);
6013                    i--;
6014                }
6015            }
6016        }
6017    }
6018
6019    /**
6020     * Apps that use the compact menu panel (as controlled by the panelMenuIsCompact
6021     * theme attribute) on devices that feature a physical options menu key attempt to position
6022     * their menu panel window along the edge of the screen nearest the physical menu key.
6023     * This lowers the travel distance between invoking the menu panel and selecting
6024     * a menu option.
6025     *
6026     * This method helps control where that menu is placed. Its current implementation makes
6027     * assumptions about the menu key and its relationship to the screen based on whether
6028     * the device's natural orientation is portrait (width < height) or landscape.
6029     *
6030     * The menu key is assumed to be located along the bottom edge of natural-portrait
6031     * devices and along the right edge of natural-landscape devices. If these assumptions
6032     * do not hold for the target device, this method should be changed to reflect that.
6033     *
6034     * @return A {@link Gravity} value for placing the options menu window
6035     */
6036    @Override
6037    public int getPreferredOptionsPanelGravity() {
6038        synchronized (mWindowMap) {
6039            final int rotation = getRotation();
6040
6041            // TODO(multidisplay): Assume that such devices physical keys are on the main screen.
6042            final DisplayContent displayContent = getDefaultDisplayContentLocked();
6043            if (displayContent.mInitialDisplayWidth < displayContent.mInitialDisplayHeight) {
6044                // On devices with a natural orientation of portrait
6045                switch (rotation) {
6046                    default:
6047                    case Surface.ROTATION_0:
6048                        return Gravity.CENTER_HORIZONTAL | Gravity.BOTTOM;
6049                    case Surface.ROTATION_90:
6050                        return Gravity.RIGHT | Gravity.BOTTOM;
6051                    case Surface.ROTATION_180:
6052                        return Gravity.CENTER_HORIZONTAL | Gravity.BOTTOM;
6053                    case Surface.ROTATION_270:
6054                        return Gravity.START | Gravity.BOTTOM;
6055                }
6056            }
6057
6058            // On devices with a natural orientation of landscape
6059            switch (rotation) {
6060                default:
6061                case Surface.ROTATION_0:
6062                    return Gravity.RIGHT | Gravity.BOTTOM;
6063                case Surface.ROTATION_90:
6064                    return Gravity.CENTER_HORIZONTAL | Gravity.BOTTOM;
6065                case Surface.ROTATION_180:
6066                    return Gravity.START | Gravity.BOTTOM;
6067                case Surface.ROTATION_270:
6068                    return Gravity.CENTER_HORIZONTAL | Gravity.BOTTOM;
6069            }
6070        }
6071    }
6072
6073    /**
6074     * Starts the view server on the specified port.
6075     *
6076     * @param port The port to listener to.
6077     *
6078     * @return True if the server was successfully started, false otherwise.
6079     *
6080     * @see com.android.server.wm.ViewServer
6081     * @see com.android.server.wm.ViewServer#VIEW_SERVER_DEFAULT_PORT
6082     */
6083    @Override
6084    public boolean startViewServer(int port) {
6085        if (isSystemSecure()) {
6086            return false;
6087        }
6088
6089        if (!checkCallingPermission(Manifest.permission.DUMP, "startViewServer")) {
6090            return false;
6091        }
6092
6093        if (port < 1024) {
6094            return false;
6095        }
6096
6097        if (mViewServer != null) {
6098            if (!mViewServer.isRunning()) {
6099                try {
6100                    return mViewServer.start();
6101                } catch (IOException e) {
6102                    Slog.w(TAG, "View server did not start");
6103                }
6104            }
6105            return false;
6106        }
6107
6108        try {
6109            mViewServer = new ViewServer(this, port);
6110            return mViewServer.start();
6111        } catch (IOException e) {
6112            Slog.w(TAG, "View server did not start");
6113        }
6114        return false;
6115    }
6116
6117    private boolean isSystemSecure() {
6118        return "1".equals(SystemProperties.get(SYSTEM_SECURE, "1")) &&
6119                "0".equals(SystemProperties.get(SYSTEM_DEBUGGABLE, "0"));
6120    }
6121
6122    /**
6123     * Stops the view server if it exists.
6124     *
6125     * @return True if the server stopped, false if it wasn't started or
6126     *         couldn't be stopped.
6127     *
6128     * @see com.android.server.wm.ViewServer
6129     */
6130    @Override
6131    public boolean stopViewServer() {
6132        if (isSystemSecure()) {
6133            return false;
6134        }
6135
6136        if (!checkCallingPermission(Manifest.permission.DUMP, "stopViewServer")) {
6137            return false;
6138        }
6139
6140        if (mViewServer != null) {
6141            return mViewServer.stop();
6142        }
6143        return false;
6144    }
6145
6146    /**
6147     * Indicates whether the view server is running.
6148     *
6149     * @return True if the server is running, false otherwise.
6150     *
6151     * @see com.android.server.wm.ViewServer
6152     */
6153    @Override
6154    public boolean isViewServerRunning() {
6155        if (isSystemSecure()) {
6156            return false;
6157        }
6158
6159        if (!checkCallingPermission(Manifest.permission.DUMP, "isViewServerRunning")) {
6160            return false;
6161        }
6162
6163        return mViewServer != null && mViewServer.isRunning();
6164    }
6165
6166    /**
6167     * Lists all availble windows in the system. The listing is written in the
6168     * specified Socket's output stream with the following syntax:
6169     * windowHashCodeInHexadecimal windowName
6170     * Each line of the ouput represents a different window.
6171     *
6172     * @param client The remote client to send the listing to.
6173     * @return False if an error occured, true otherwise.
6174     */
6175    boolean viewServerListWindows(Socket client) {
6176        if (isSystemSecure()) {
6177            return false;
6178        }
6179
6180        boolean result = true;
6181
6182        WindowList windows = new WindowList();
6183        synchronized (mWindowMap) {
6184            //noinspection unchecked
6185            final int numDisplays = mDisplayContents.size();
6186            for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) {
6187                final DisplayContent displayContent = mDisplayContents.valueAt(displayNdx);
6188                windows.addAll(displayContent.getWindowList());
6189            }
6190        }
6191
6192        BufferedWriter out = null;
6193
6194        // Any uncaught exception will crash the system process
6195        try {
6196            OutputStream clientStream = client.getOutputStream();
6197            out = new BufferedWriter(new OutputStreamWriter(clientStream), 8 * 1024);
6198
6199            final int count = windows.size();
6200            for (int i = 0; i < count; i++) {
6201                final WindowState w = windows.get(i);
6202                out.write(Integer.toHexString(System.identityHashCode(w)));
6203                out.write(' ');
6204                out.append(w.mAttrs.getTitle());
6205                out.write('\n');
6206            }
6207
6208            out.write("DONE.\n");
6209            out.flush();
6210        } catch (Exception e) {
6211            result = false;
6212        } finally {
6213            if (out != null) {
6214                try {
6215                    out.close();
6216                } catch (IOException e) {
6217                    result = false;
6218                }
6219            }
6220        }
6221
6222        return result;
6223    }
6224
6225    // TODO(multidisplay): Extend to multiple displays.
6226    /**
6227     * Returns the focused window in the following format:
6228     * windowHashCodeInHexadecimal windowName
6229     *
6230     * @param client The remote client to send the listing to.
6231     * @return False if an error occurred, true otherwise.
6232     */
6233    boolean viewServerGetFocusedWindow(Socket client) {
6234        if (isSystemSecure()) {
6235            return false;
6236        }
6237
6238        boolean result = true;
6239
6240        WindowState focusedWindow = getFocusedWindow();
6241
6242        BufferedWriter out = null;
6243
6244        // Any uncaught exception will crash the system process
6245        try {
6246            OutputStream clientStream = client.getOutputStream();
6247            out = new BufferedWriter(new OutputStreamWriter(clientStream), 8 * 1024);
6248
6249            if(focusedWindow != null) {
6250                out.write(Integer.toHexString(System.identityHashCode(focusedWindow)));
6251                out.write(' ');
6252                out.append(focusedWindow.mAttrs.getTitle());
6253            }
6254            out.write('\n');
6255            out.flush();
6256        } catch (Exception e) {
6257            result = false;
6258        } finally {
6259            if (out != null) {
6260                try {
6261                    out.close();
6262                } catch (IOException e) {
6263                    result = false;
6264                }
6265            }
6266        }
6267
6268        return result;
6269    }
6270
6271    /**
6272     * Sends a command to a target window. The result of the command, if any, will be
6273     * written in the output stream of the specified socket.
6274     *
6275     * The parameters must follow this syntax:
6276     * windowHashcode extra
6277     *
6278     * Where XX is the length in characeters of the windowTitle.
6279     *
6280     * The first parameter is the target window. The window with the specified hashcode
6281     * will be the target. If no target can be found, nothing happens. The extra parameters
6282     * will be delivered to the target window and as parameters to the command itself.
6283     *
6284     * @param client The remote client to sent the result, if any, to.
6285     * @param command The command to execute.
6286     * @param parameters The command parameters.
6287     *
6288     * @return True if the command was successfully delivered, false otherwise. This does
6289     *         not indicate whether the command itself was successful.
6290     */
6291    boolean viewServerWindowCommand(Socket client, String command, String parameters) {
6292        if (isSystemSecure()) {
6293            return false;
6294        }
6295
6296        boolean success = true;
6297        Parcel data = null;
6298        Parcel reply = null;
6299
6300        BufferedWriter out = null;
6301
6302        // Any uncaught exception will crash the system process
6303        try {
6304            // Find the hashcode of the window
6305            int index = parameters.indexOf(' ');
6306            if (index == -1) {
6307                index = parameters.length();
6308            }
6309            final String code = parameters.substring(0, index);
6310            int hashCode = (int) Long.parseLong(code, 16);
6311
6312            // Extract the command's parameter after the window description
6313            if (index < parameters.length()) {
6314                parameters = parameters.substring(index + 1);
6315            } else {
6316                parameters = "";
6317            }
6318
6319            final WindowState window = findWindow(hashCode);
6320            if (window == null) {
6321                return false;
6322            }
6323
6324            data = Parcel.obtain();
6325            data.writeInterfaceToken("android.view.IWindow");
6326            data.writeString(command);
6327            data.writeString(parameters);
6328            data.writeInt(1);
6329            ParcelFileDescriptor.fromSocket(client).writeToParcel(data, 0);
6330
6331            reply = Parcel.obtain();
6332
6333            final IBinder binder = window.mClient.asBinder();
6334            // TODO: GET THE TRANSACTION CODE IN A SAFER MANNER
6335            binder.transact(IBinder.FIRST_CALL_TRANSACTION, data, reply, 0);
6336
6337            reply.readException();
6338
6339            if (!client.isOutputShutdown()) {
6340                out = new BufferedWriter(new OutputStreamWriter(client.getOutputStream()));
6341                out.write("DONE\n");
6342                out.flush();
6343            }
6344
6345        } catch (Exception e) {
6346            Slog.w(TAG, "Could not send command " + command + " with parameters " + parameters, e);
6347            success = false;
6348        } finally {
6349            if (data != null) {
6350                data.recycle();
6351            }
6352            if (reply != null) {
6353                reply.recycle();
6354            }
6355            if (out != null) {
6356                try {
6357                    out.close();
6358                } catch (IOException e) {
6359
6360                }
6361            }
6362        }
6363
6364        return success;
6365    }
6366
6367    public void addWindowChangeListener(WindowChangeListener listener) {
6368        synchronized(mWindowMap) {
6369            mWindowChangeListeners.add(listener);
6370        }
6371    }
6372
6373    public void removeWindowChangeListener(WindowChangeListener listener) {
6374        synchronized(mWindowMap) {
6375            mWindowChangeListeners.remove(listener);
6376        }
6377    }
6378
6379    private void notifyWindowsChanged() {
6380        WindowChangeListener[] windowChangeListeners;
6381        synchronized(mWindowMap) {
6382            if(mWindowChangeListeners.isEmpty()) {
6383                return;
6384            }
6385            windowChangeListeners = new WindowChangeListener[mWindowChangeListeners.size()];
6386            windowChangeListeners = mWindowChangeListeners.toArray(windowChangeListeners);
6387        }
6388        int N = windowChangeListeners.length;
6389        for(int i = 0; i < N; i++) {
6390            windowChangeListeners[i].windowsChanged();
6391        }
6392    }
6393
6394    private void notifyFocusChanged() {
6395        WindowChangeListener[] windowChangeListeners;
6396        synchronized(mWindowMap) {
6397            if(mWindowChangeListeners.isEmpty()) {
6398                return;
6399            }
6400            windowChangeListeners = new WindowChangeListener[mWindowChangeListeners.size()];
6401            windowChangeListeners = mWindowChangeListeners.toArray(windowChangeListeners);
6402        }
6403        int N = windowChangeListeners.length;
6404        for(int i = 0; i < N; i++) {
6405            windowChangeListeners[i].focusChanged();
6406        }
6407    }
6408
6409    private WindowState findWindow(int hashCode) {
6410        if (hashCode == -1) {
6411            // TODO(multidisplay): Extend to multiple displays.
6412            return getFocusedWindow();
6413        }
6414
6415        synchronized (mWindowMap) {
6416            final int numDisplays = mDisplayContents.size();
6417            for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) {
6418                final WindowList windows = mDisplayContents.valueAt(displayNdx).getWindowList();
6419                final int numWindows = windows.size();
6420                for (int winNdx = 0; winNdx < numWindows; ++winNdx) {
6421                    final WindowState w = windows.get(winNdx);
6422                    if (System.identityHashCode(w) == hashCode) {
6423                        return w;
6424                    }
6425                }
6426            }
6427        }
6428
6429        return null;
6430    }
6431
6432    /*
6433     * Instruct the Activity Manager to fetch the current configuration and broadcast
6434     * that to config-changed listeners if appropriate.
6435     */
6436    void sendNewConfiguration() {
6437        try {
6438            mActivityManager.updateConfiguration(null);
6439        } catch (RemoteException e) {
6440        }
6441    }
6442
6443    public Configuration computeNewConfiguration() {
6444        synchronized (mWindowMap) {
6445            Configuration config = computeNewConfigurationLocked();
6446            if (config == null && mWaitingForConfig) {
6447                // Nothing changed but we are waiting for something... stop that!
6448                mWaitingForConfig = false;
6449                mLastFinishedFreezeSource = "new-config";
6450                performLayoutAndPlaceSurfacesLocked();
6451            }
6452            return config;
6453        }
6454    }
6455
6456    Configuration computeNewConfigurationLocked() {
6457        Configuration config = new Configuration();
6458        config.fontScale = 0;
6459        if (!computeScreenConfigurationLocked(config)) {
6460            return null;
6461        }
6462        return config;
6463    }
6464
6465    private void adjustDisplaySizeRanges(DisplayInfo displayInfo, int rotation, int dw, int dh) {
6466        // TODO: Multidisplay: for now only use with default display.
6467        final int width = mPolicy.getConfigDisplayWidth(dw, dh, rotation);
6468        if (width < displayInfo.smallestNominalAppWidth) {
6469            displayInfo.smallestNominalAppWidth = width;
6470        }
6471        if (width > displayInfo.largestNominalAppWidth) {
6472            displayInfo.largestNominalAppWidth = width;
6473        }
6474        final int height = mPolicy.getConfigDisplayHeight(dw, dh, rotation);
6475        if (height < displayInfo.smallestNominalAppHeight) {
6476            displayInfo.smallestNominalAppHeight = height;
6477        }
6478        if (height > displayInfo.largestNominalAppHeight) {
6479            displayInfo.largestNominalAppHeight = height;
6480        }
6481    }
6482
6483    private int reduceConfigLayout(int curLayout, int rotation, float density,
6484            int dw, int dh) {
6485        // TODO: Multidisplay: for now only use with default display.
6486        // Get the app screen size at this rotation.
6487        int w = mPolicy.getNonDecorDisplayWidth(dw, dh, rotation);
6488        int h = mPolicy.getNonDecorDisplayHeight(dw, dh, rotation);
6489
6490        // Compute the screen layout size class for this rotation.
6491        int longSize = w;
6492        int shortSize = h;
6493        if (longSize < shortSize) {
6494            int tmp = longSize;
6495            longSize = shortSize;
6496            shortSize = tmp;
6497        }
6498        longSize = (int)(longSize/density);
6499        shortSize = (int)(shortSize/density);
6500        return Configuration.reduceScreenLayout(curLayout, longSize, shortSize);
6501    }
6502
6503    private void computeSizeRangesAndScreenLayout(DisplayInfo displayInfo, boolean rotated,
6504                  int dw, int dh, float density, Configuration outConfig) {
6505        // TODO: Multidisplay: for now only use with default display.
6506
6507        // We need to determine the smallest width that will occur under normal
6508        // operation.  To this, start with the base screen size and compute the
6509        // width under the different possible rotations.  We need to un-rotate
6510        // the current screen dimensions before doing this.
6511        int unrotDw, unrotDh;
6512        if (rotated) {
6513            unrotDw = dh;
6514            unrotDh = dw;
6515        } else {
6516            unrotDw = dw;
6517            unrotDh = dh;
6518        }
6519        displayInfo.smallestNominalAppWidth = 1<<30;
6520        displayInfo.smallestNominalAppHeight = 1<<30;
6521        displayInfo.largestNominalAppWidth = 0;
6522        displayInfo.largestNominalAppHeight = 0;
6523        adjustDisplaySizeRanges(displayInfo, Surface.ROTATION_0, unrotDw, unrotDh);
6524        adjustDisplaySizeRanges(displayInfo, Surface.ROTATION_90, unrotDh, unrotDw);
6525        adjustDisplaySizeRanges(displayInfo, Surface.ROTATION_180, unrotDw, unrotDh);
6526        adjustDisplaySizeRanges(displayInfo, Surface.ROTATION_270, unrotDh, unrotDw);
6527        int sl = Configuration.resetScreenLayout(outConfig.screenLayout);
6528        sl = reduceConfigLayout(sl, Surface.ROTATION_0, density, unrotDw, unrotDh);
6529        sl = reduceConfigLayout(sl, Surface.ROTATION_90, density, unrotDh, unrotDw);
6530        sl = reduceConfigLayout(sl, Surface.ROTATION_180, density, unrotDw, unrotDh);
6531        sl = reduceConfigLayout(sl, Surface.ROTATION_270, density, unrotDh, unrotDw);
6532        outConfig.smallestScreenWidthDp = (int)(displayInfo.smallestNominalAppWidth / density);
6533        outConfig.screenLayout = sl;
6534    }
6535
6536    private int reduceCompatConfigWidthSize(int curSize, int rotation, DisplayMetrics dm,
6537            int dw, int dh) {
6538        // TODO: Multidisplay: for now only use with default display.
6539        dm.noncompatWidthPixels = mPolicy.getNonDecorDisplayWidth(dw, dh, rotation);
6540        dm.noncompatHeightPixels = mPolicy.getNonDecorDisplayHeight(dw, dh, rotation);
6541        float scale = CompatibilityInfo.computeCompatibleScaling(dm, null);
6542        int size = (int)(((dm.noncompatWidthPixels / scale) / dm.density) + .5f);
6543        if (curSize == 0 || size < curSize) {
6544            curSize = size;
6545        }
6546        return curSize;
6547    }
6548
6549    private int computeCompatSmallestWidth(boolean rotated, DisplayMetrics dm, int dw, int dh) {
6550        // TODO: Multidisplay: for now only use with default display.
6551        mTmpDisplayMetrics.setTo(dm);
6552        final DisplayMetrics tmpDm = mTmpDisplayMetrics;
6553        final int unrotDw, unrotDh;
6554        if (rotated) {
6555            unrotDw = dh;
6556            unrotDh = dw;
6557        } else {
6558            unrotDw = dw;
6559            unrotDh = dh;
6560        }
6561        int sw = reduceCompatConfigWidthSize(0, Surface.ROTATION_0, tmpDm, unrotDw, unrotDh);
6562        sw = reduceCompatConfigWidthSize(sw, Surface.ROTATION_90, tmpDm, unrotDh, unrotDw);
6563        sw = reduceCompatConfigWidthSize(sw, Surface.ROTATION_180, tmpDm, unrotDw, unrotDh);
6564        sw = reduceCompatConfigWidthSize(sw, Surface.ROTATION_270, tmpDm, unrotDh, unrotDw);
6565        return sw;
6566    }
6567
6568    boolean computeScreenConfigurationLocked(Configuration config) {
6569        if (!mDisplayReady) {
6570            return false;
6571        }
6572
6573        // TODO(multidisplay): For now, apply Configuration to main screen only.
6574        final DisplayContent displayContent = getDefaultDisplayContentLocked();
6575
6576        // Use the effective "visual" dimensions based on current rotation
6577        final boolean rotated = (mRotation == Surface.ROTATION_90
6578                || mRotation == Surface.ROTATION_270);
6579        final int realdw = rotated ?
6580                displayContent.mBaseDisplayHeight : displayContent.mBaseDisplayWidth;
6581        final int realdh = rotated ?
6582                displayContent.mBaseDisplayWidth : displayContent.mBaseDisplayHeight;
6583        int dw = realdw;
6584        int dh = realdh;
6585
6586        if (mAltOrientation) {
6587            if (realdw > realdh) {
6588                // Turn landscape into portrait.
6589                int maxw = (int)(realdh/1.3f);
6590                if (maxw < realdw) {
6591                    dw = maxw;
6592                }
6593            } else {
6594                // Turn portrait into landscape.
6595                int maxh = (int)(realdw/1.3f);
6596                if (maxh < realdh) {
6597                    dh = maxh;
6598                }
6599            }
6600        }
6601
6602        if (config != null) {
6603            config.orientation = (dw <= dh) ? Configuration.ORIENTATION_PORTRAIT :
6604                    Configuration.ORIENTATION_LANDSCAPE;
6605        }
6606
6607        // Update application display metrics.
6608        final int appWidth = mPolicy.getNonDecorDisplayWidth(dw, dh, mRotation);
6609        final int appHeight = mPolicy.getNonDecorDisplayHeight(dw, dh, mRotation);
6610        final DisplayInfo displayInfo = displayContent.getDisplayInfo();
6611        synchronized(displayContent.mDisplaySizeLock) {
6612            displayInfo.rotation = mRotation;
6613            displayInfo.logicalWidth = dw;
6614            displayInfo.logicalHeight = dh;
6615            displayInfo.logicalDensityDpi = displayContent.mBaseDisplayDensity;
6616            displayInfo.appWidth = appWidth;
6617            displayInfo.appHeight = appHeight;
6618            displayInfo.getLogicalMetrics(mRealDisplayMetrics,
6619                    CompatibilityInfo.DEFAULT_COMPATIBILITY_INFO, null);
6620            displayInfo.getAppMetrics(mDisplayMetrics);
6621            mDisplayManagerService.setDisplayInfoOverrideFromWindowManager(
6622                    displayContent.getDisplayId(), displayInfo);
6623        }
6624        if (false) {
6625            Slog.i(TAG, "Set app display size: " + appWidth + " x " + appHeight);
6626        }
6627
6628        final DisplayMetrics dm = mDisplayMetrics;
6629        mCompatibleScreenScale = CompatibilityInfo.computeCompatibleScaling(dm,
6630                mCompatDisplayMetrics);
6631
6632        if (config != null) {
6633            config.screenWidthDp = (int)(mPolicy.getConfigDisplayWidth(dw, dh, mRotation)
6634                    / dm.density);
6635            config.screenHeightDp = (int)(mPolicy.getConfigDisplayHeight(dw, dh, mRotation)
6636                    / dm.density);
6637            computeSizeRangesAndScreenLayout(displayInfo, rotated, dw, dh, dm.density, config);
6638
6639            config.compatScreenWidthDp = (int)(config.screenWidthDp / mCompatibleScreenScale);
6640            config.compatScreenHeightDp = (int)(config.screenHeightDp / mCompatibleScreenScale);
6641            config.compatSmallestScreenWidthDp = computeCompatSmallestWidth(rotated, dm, dw, dh);
6642            config.densityDpi = displayContent.mBaseDisplayDensity;
6643
6644            // Update the configuration based on available input devices, lid switch,
6645            // and platform configuration.
6646            config.touchscreen = Configuration.TOUCHSCREEN_NOTOUCH;
6647            config.keyboard = Configuration.KEYBOARD_NOKEYS;
6648            config.navigation = Configuration.NAVIGATION_NONAV;
6649
6650            int keyboardPresence = 0;
6651            int navigationPresence = 0;
6652            final InputDevice[] devices = mInputManager.getInputDevices();
6653            final int len = devices.length;
6654            for (int i = 0; i < len; i++) {
6655                InputDevice device = devices[i];
6656                if (!device.isVirtual()) {
6657                    final int sources = device.getSources();
6658                    final int presenceFlag = device.isExternal() ?
6659                            WindowManagerPolicy.PRESENCE_EXTERNAL :
6660                                    WindowManagerPolicy.PRESENCE_INTERNAL;
6661
6662                    if (mIsTouchDevice) {
6663                        if ((sources & InputDevice.SOURCE_TOUCHSCREEN) ==
6664                                InputDevice.SOURCE_TOUCHSCREEN) {
6665                            config.touchscreen = Configuration.TOUCHSCREEN_FINGER;
6666                        }
6667                    } else {
6668                        config.touchscreen = Configuration.TOUCHSCREEN_NOTOUCH;
6669                    }
6670
6671                    if ((sources & InputDevice.SOURCE_TRACKBALL) == InputDevice.SOURCE_TRACKBALL) {
6672                        config.navigation = Configuration.NAVIGATION_TRACKBALL;
6673                        navigationPresence |= presenceFlag;
6674                    } else if ((sources & InputDevice.SOURCE_DPAD) == InputDevice.SOURCE_DPAD
6675                            && config.navigation == Configuration.NAVIGATION_NONAV) {
6676                        config.navigation = Configuration.NAVIGATION_DPAD;
6677                        navigationPresence |= presenceFlag;
6678                    }
6679
6680                    if (device.getKeyboardType() == InputDevice.KEYBOARD_TYPE_ALPHABETIC) {
6681                        config.keyboard = Configuration.KEYBOARD_QWERTY;
6682                        keyboardPresence |= presenceFlag;
6683                    }
6684                }
6685            }
6686
6687            // Determine whether a hard keyboard is available and enabled.
6688            boolean hardKeyboardAvailable = config.keyboard != Configuration.KEYBOARD_NOKEYS;
6689            if (hardKeyboardAvailable != mHardKeyboardAvailable) {
6690                mHardKeyboardAvailable = hardKeyboardAvailable;
6691                mHardKeyboardEnabled = hardKeyboardAvailable;
6692                mH.removeMessages(H.REPORT_HARD_KEYBOARD_STATUS_CHANGE);
6693                mH.sendEmptyMessage(H.REPORT_HARD_KEYBOARD_STATUS_CHANGE);
6694            }
6695            if (!mHardKeyboardEnabled) {
6696                config.keyboard = Configuration.KEYBOARD_NOKEYS;
6697            }
6698
6699            // Let the policy update hidden states.
6700            config.keyboardHidden = Configuration.KEYBOARDHIDDEN_NO;
6701            config.hardKeyboardHidden = Configuration.HARDKEYBOARDHIDDEN_NO;
6702            config.navigationHidden = Configuration.NAVIGATIONHIDDEN_NO;
6703            mPolicy.adjustConfigurationLw(config, keyboardPresence, navigationPresence);
6704        }
6705
6706        return true;
6707    }
6708
6709    public boolean isHardKeyboardAvailable() {
6710        synchronized (mWindowMap) {
6711            return mHardKeyboardAvailable;
6712        }
6713    }
6714
6715    public boolean isHardKeyboardEnabled() {
6716        synchronized (mWindowMap) {
6717            return mHardKeyboardEnabled;
6718        }
6719    }
6720
6721    public void setHardKeyboardEnabled(boolean enabled) {
6722        synchronized (mWindowMap) {
6723            if (mHardKeyboardEnabled != enabled) {
6724                mHardKeyboardEnabled = enabled;
6725                mH.sendEmptyMessage(H.SEND_NEW_CONFIGURATION);
6726            }
6727        }
6728    }
6729
6730    public void setOnHardKeyboardStatusChangeListener(
6731            OnHardKeyboardStatusChangeListener listener) {
6732        synchronized (mWindowMap) {
6733            mHardKeyboardStatusChangeListener = listener;
6734        }
6735    }
6736
6737    void notifyHardKeyboardStatusChange() {
6738        final boolean available, enabled;
6739        final OnHardKeyboardStatusChangeListener listener;
6740        synchronized (mWindowMap) {
6741            listener = mHardKeyboardStatusChangeListener;
6742            available = mHardKeyboardAvailable;
6743            enabled = mHardKeyboardEnabled;
6744        }
6745        if (listener != null) {
6746            listener.onHardKeyboardStatusChange(available, enabled);
6747        }
6748    }
6749
6750    // -------------------------------------------------------------
6751    // Drag and drop
6752    // -------------------------------------------------------------
6753
6754    IBinder prepareDragSurface(IWindow window, SurfaceSession session,
6755            int flags, int width, int height, Surface outSurface) {
6756        if (DEBUG_DRAG) {
6757            Slog.d(TAG, "prepare drag surface: w=" + width + " h=" + height
6758                    + " flags=" + Integer.toHexString(flags) + " win=" + window
6759                    + " asbinder=" + window.asBinder());
6760        }
6761
6762        final int callerPid = Binder.getCallingPid();
6763        final long origId = Binder.clearCallingIdentity();
6764        IBinder token = null;
6765
6766        try {
6767            synchronized (mWindowMap) {
6768                try {
6769                    if (mDragState == null) {
6770                        // TODO(multi-display): support other displays
6771                        final DisplayContent displayContent = getDefaultDisplayContentLocked();
6772                        final Display display = displayContent.getDisplay();
6773                        SurfaceControl surface = new SurfaceControl(session, "drag surface",
6774                                width, height, PixelFormat.TRANSLUCENT, SurfaceControl.HIDDEN);
6775                        surface.setLayerStack(display.getLayerStack());
6776                        if (SHOW_TRANSACTIONS) Slog.i(TAG, "  DRAG "
6777                                + surface + ": CREATE");
6778                        outSurface.copyFrom(surface);
6779                        final IBinder winBinder = window.asBinder();
6780                        token = new Binder();
6781                        mDragState = new DragState(this, token, surface, /*flags*/ 0, winBinder);
6782                        token = mDragState.mToken = new Binder();
6783
6784                        // 5 second timeout for this window to actually begin the drag
6785                        mH.removeMessages(H.DRAG_START_TIMEOUT, winBinder);
6786                        Message msg = mH.obtainMessage(H.DRAG_START_TIMEOUT, winBinder);
6787                        mH.sendMessageDelayed(msg, 5000);
6788                    } else {
6789                        Slog.w(TAG, "Drag already in progress");
6790                    }
6791                } catch (OutOfResourcesException e) {
6792                    Slog.e(TAG, "Can't allocate drag surface w=" + width + " h=" + height, e);
6793                    if (mDragState != null) {
6794                        mDragState.reset();
6795                        mDragState = null;
6796                    }
6797                }
6798            }
6799        } finally {
6800            Binder.restoreCallingIdentity(origId);
6801        }
6802
6803        return token;
6804    }
6805
6806    // -------------------------------------------------------------
6807    // Input Events and Focus Management
6808    // -------------------------------------------------------------
6809
6810    final InputMonitor mInputMonitor = new InputMonitor(this);
6811    private boolean mEventDispatchingEnabled;
6812
6813    @Override
6814    public void pauseKeyDispatching(IBinder _token) {
6815        if (!checkCallingPermission(android.Manifest.permission.MANAGE_APP_TOKENS,
6816                "pauseKeyDispatching()")) {
6817            throw new SecurityException("Requires MANAGE_APP_TOKENS permission");
6818        }
6819
6820        synchronized (mWindowMap) {
6821            WindowToken token = mTokenMap.get(_token);
6822            if (token != null) {
6823                mInputMonitor.pauseDispatchingLw(token);
6824            }
6825        }
6826    }
6827
6828    @Override
6829    public void resumeKeyDispatching(IBinder _token) {
6830        if (!checkCallingPermission(android.Manifest.permission.MANAGE_APP_TOKENS,
6831                "resumeKeyDispatching()")) {
6832            throw new SecurityException("Requires MANAGE_APP_TOKENS permission");
6833        }
6834
6835        synchronized (mWindowMap) {
6836            WindowToken token = mTokenMap.get(_token);
6837            if (token != null) {
6838                mInputMonitor.resumeDispatchingLw(token);
6839            }
6840        }
6841    }
6842
6843    @Override
6844    public void setEventDispatching(boolean enabled) {
6845        if (!checkCallingPermission(android.Manifest.permission.MANAGE_APP_TOKENS,
6846                "setEventDispatching()")) {
6847            throw new SecurityException("Requires MANAGE_APP_TOKENS permission");
6848        }
6849
6850        synchronized (mWindowMap) {
6851            mEventDispatchingEnabled = enabled;
6852            if (mDisplayEnabled) {
6853                mInputMonitor.setEventDispatchingLw(enabled);
6854            }
6855            sendScreenStatusToClientsLocked();
6856        }
6857    }
6858
6859    @Override
6860    public IBinder getFocusedWindowToken() {
6861        if (!checkCallingPermission(android.Manifest.permission.RETRIEVE_WINDOW_INFO,
6862                "getFocusedWindowToken()")) {
6863            throw new SecurityException("Requires RETRIEVE_WINDOW_INFO permission.");
6864        }
6865        synchronized (mWindowMap) {
6866            WindowState windowState = getFocusedWindowLocked();
6867            if (windowState != null) {
6868                return windowState.mClient.asBinder();
6869            }
6870            return null;
6871        }
6872    }
6873
6874    private WindowState getFocusedWindow() {
6875        synchronized (mWindowMap) {
6876            return getFocusedWindowLocked();
6877        }
6878    }
6879
6880    private WindowState getFocusedWindowLocked() {
6881        return mCurrentFocus;
6882    }
6883
6884    public boolean detectSafeMode() {
6885        if (!mInputMonitor.waitForInputDevicesReady(
6886                INPUT_DEVICES_READY_FOR_SAFE_MODE_DETECTION_TIMEOUT_MILLIS)) {
6887            Slog.w(TAG, "Devices still not ready after waiting "
6888                   + INPUT_DEVICES_READY_FOR_SAFE_MODE_DETECTION_TIMEOUT_MILLIS
6889                   + " milliseconds before attempting to detect safe mode.");
6890        }
6891
6892        int menuState = mInputManager.getKeyCodeState(-1, InputDevice.SOURCE_ANY,
6893                KeyEvent.KEYCODE_MENU);
6894        int sState = mInputManager.getKeyCodeState(-1, InputDevice.SOURCE_ANY, KeyEvent.KEYCODE_S);
6895        int dpadState = mInputManager.getKeyCodeState(-1, InputDevice.SOURCE_DPAD,
6896                KeyEvent.KEYCODE_DPAD_CENTER);
6897        int trackballState = mInputManager.getScanCodeState(-1, InputDevice.SOURCE_TRACKBALL,
6898                InputManagerService.BTN_MOUSE);
6899        int volumeDownState = mInputManager.getKeyCodeState(-1, InputDevice.SOURCE_ANY,
6900                KeyEvent.KEYCODE_VOLUME_DOWN);
6901        mSafeMode = menuState > 0 || sState > 0 || dpadState > 0 || trackballState > 0
6902                || volumeDownState > 0;
6903        try {
6904            if (SystemProperties.getInt(ShutdownThread.REBOOT_SAFEMODE_PROPERTY, 0) != 0) {
6905                mSafeMode = true;
6906                SystemProperties.set(ShutdownThread.REBOOT_SAFEMODE_PROPERTY, "");
6907            }
6908        } catch (IllegalArgumentException e) {
6909        }
6910        if (mSafeMode) {
6911            Log.i(TAG, "SAFE MODE ENABLED (menu=" + menuState + " s=" + sState
6912                    + " dpad=" + dpadState + " trackball=" + trackballState + ")");
6913        } else {
6914            Log.i(TAG, "SAFE MODE not enabled");
6915        }
6916        mPolicy.setSafeMode(mSafeMode);
6917        return mSafeMode;
6918    }
6919
6920    public void displayReady() {
6921        displayReady(Display.DEFAULT_DISPLAY);
6922
6923        synchronized(mWindowMap) {
6924            final DisplayContent displayContent = getDefaultDisplayContentLocked();
6925            readForcedDisplaySizeAndDensityLocked(displayContent);
6926            mDisplayReady = true;
6927        }
6928
6929        try {
6930            mActivityManager.updateConfiguration(null);
6931        } catch (RemoteException e) {
6932        }
6933
6934        synchronized(mWindowMap) {
6935            mIsTouchDevice = mContext.getPackageManager().hasSystemFeature(
6936                    PackageManager.FEATURE_TOUCHSCREEN);
6937            configureDisplayPolicyLocked(getDefaultDisplayContentLocked());
6938        }
6939
6940        try {
6941            mActivityManager.updateConfiguration(null);
6942        } catch (RemoteException e) {
6943        }
6944    }
6945
6946    private void displayReady(int displayId) {
6947        synchronized(mWindowMap) {
6948            final DisplayContent displayContent = getDisplayContentLocked(displayId);
6949            if (displayContent != null) {
6950                mAnimator.addDisplayLocked(displayId);
6951                synchronized(displayContent.mDisplaySizeLock) {
6952                    // Bootstrap the default logical display from the display manager.
6953                    final DisplayInfo displayInfo = displayContent.getDisplayInfo();
6954                    DisplayInfo newDisplayInfo = mDisplayManagerService.getDisplayInfo(displayId);
6955                    if (newDisplayInfo != null) {
6956                        displayInfo.copyFrom(newDisplayInfo);
6957                    }
6958                    displayContent.mInitialDisplayWidth = displayInfo.logicalWidth;
6959                    displayContent.mInitialDisplayHeight = displayInfo.logicalHeight;
6960                    displayContent.mInitialDisplayDensity = displayInfo.logicalDensityDpi;
6961                    displayContent.mBaseDisplayWidth = displayContent.mInitialDisplayWidth;
6962                    displayContent.mBaseDisplayHeight = displayContent.mInitialDisplayHeight;
6963                    displayContent.mBaseDisplayDensity = displayContent.mInitialDisplayDensity;
6964                    displayContent.mBaseDisplayRect.set(0, 0,
6965                            displayContent.mBaseDisplayWidth, displayContent.mBaseDisplayHeight);
6966                }
6967            }
6968        }
6969    }
6970
6971    public void systemReady() {
6972        mPolicy.systemReady();
6973    }
6974
6975    // TODO(multidisplay): Call isScreenOn for each display.
6976    private void sendScreenStatusToClientsLocked() {
6977        final boolean on = mPowerManager.isScreenOn();
6978        final int numDisplays = mDisplayContents.size();
6979        for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) {
6980            final WindowList windows = mDisplayContents.valueAt(displayNdx).getWindowList();
6981            final int numWindows = windows.size();
6982            for (int winNdx = 0; winNdx < numWindows; ++winNdx) {
6983                try {
6984                    windows.get(winNdx).mClient.dispatchScreenState(on);
6985                } catch (RemoteException e) {
6986                    // Ignored
6987                }
6988            }
6989        }
6990    }
6991
6992    // -------------------------------------------------------------
6993    // Async Handler
6994    // -------------------------------------------------------------
6995
6996    final class H extends Handler {
6997        public static final int REPORT_FOCUS_CHANGE = 2;
6998        public static final int REPORT_LOSING_FOCUS = 3;
6999        public static final int DO_TRAVERSAL = 4;
7000        public static final int ADD_STARTING = 5;
7001        public static final int REMOVE_STARTING = 6;
7002        public static final int FINISHED_STARTING = 7;
7003        public static final int REPORT_APPLICATION_TOKEN_WINDOWS = 8;
7004        public static final int REPORT_APPLICATION_TOKEN_DRAWN = 9;
7005        public static final int WINDOW_FREEZE_TIMEOUT = 11;
7006
7007        public static final int APP_TRANSITION_TIMEOUT = 13;
7008        public static final int PERSIST_ANIMATION_SCALE = 14;
7009        public static final int FORCE_GC = 15;
7010        public static final int ENABLE_SCREEN = 16;
7011        public static final int APP_FREEZE_TIMEOUT = 17;
7012        public static final int SEND_NEW_CONFIGURATION = 18;
7013        public static final int REPORT_WINDOWS_CHANGE = 19;
7014        public static final int DRAG_START_TIMEOUT = 20;
7015        public static final int DRAG_END_TIMEOUT = 21;
7016        public static final int REPORT_HARD_KEYBOARD_STATUS_CHANGE = 22;
7017        public static final int BOOT_TIMEOUT = 23;
7018        public static final int WAITING_FOR_DRAWN_TIMEOUT = 24;
7019        public static final int SHOW_STRICT_MODE_VIOLATION = 25;
7020        public static final int DO_ANIMATION_CALLBACK = 26;
7021
7022        public static final int DO_DISPLAY_ADDED = 27;
7023        public static final int DO_DISPLAY_REMOVED = 28;
7024        public static final int DO_DISPLAY_CHANGED = 29;
7025
7026        public static final int CLIENT_FREEZE_TIMEOUT = 30;
7027        public static final int TAP_OUTSIDE_STACK = 31;
7028        public static final int NOTIFY_ACTIVITY_DRAWN = 32;
7029
7030        public static final int REMOVE_STARTING_TIMEOUT = 33;
7031
7032        public static final int CREATE_STACK = 34;
7033
7034        @Override
7035        public void handleMessage(Message msg) {
7036            if (DEBUG_WINDOW_TRACE) {
7037                Slog.v(TAG, "handleMessage: entry what=" + msg.what);
7038            }
7039            switch (msg.what) {
7040                case REPORT_FOCUS_CHANGE: {
7041                    WindowState lastFocus;
7042                    WindowState newFocus;
7043
7044                    synchronized(mWindowMap) {
7045                        lastFocus = mLastFocus;
7046                        newFocus = mCurrentFocus;
7047                        if (lastFocus == newFocus) {
7048                            // Focus is not changing, so nothing to do.
7049                            return;
7050                        }
7051                        mLastFocus = newFocus;
7052                        if (DEBUG_FOCUS_LIGHT) Slog.i(TAG, "Focus moving from " + lastFocus +
7053                                " to " + newFocus);
7054                        if (newFocus != null && lastFocus != null
7055                                && !newFocus.isDisplayedLw()) {
7056                            //Slog.i(TAG, "Delaying loss of focus...");
7057                            mLosingFocus.add(lastFocus);
7058                            lastFocus = null;
7059                        }
7060                    }
7061
7062                    //System.out.println("Changing focus from " + lastFocus
7063                    //                   + " to " + newFocus);
7064                    if (newFocus != null) {
7065                        if (DEBUG_FOCUS_LIGHT) Slog.i(TAG, "Gaining focus: " + newFocus);
7066                        newFocus.reportFocusChangedSerialized(true, mInTouchMode);
7067                        notifyFocusChanged();
7068                    }
7069
7070                    if (lastFocus != null) {
7071                        if (DEBUG_FOCUS_LIGHT) Slog.i(TAG, "Losing focus: " + lastFocus);
7072                        lastFocus.reportFocusChangedSerialized(false, mInTouchMode);
7073                    }
7074                } break;
7075
7076                case REPORT_LOSING_FOCUS: {
7077                    ArrayList<WindowState> losers;
7078
7079                    synchronized(mWindowMap) {
7080                        losers = mLosingFocus;
7081                        mLosingFocus = new ArrayList<WindowState>();
7082                    }
7083
7084                    final int N = losers.size();
7085                    for (int i=0; i<N; i++) {
7086                        if (DEBUG_FOCUS_LIGHT) Slog.i(TAG, "Losing delayed focus: " +
7087                                losers.get(i));
7088                        losers.get(i).reportFocusChangedSerialized(false, mInTouchMode);
7089                    }
7090                } break;
7091
7092                case DO_TRAVERSAL: {
7093                    synchronized(mWindowMap) {
7094                        mTraversalScheduled = false;
7095                        performLayoutAndPlaceSurfacesLocked();
7096                    }
7097                } break;
7098
7099                case ADD_STARTING: {
7100                    final AppWindowToken wtoken = (AppWindowToken)msg.obj;
7101                    final StartingData sd = wtoken.startingData;
7102
7103                    if (sd == null) {
7104                        // Animation has been canceled... do nothing.
7105                        return;
7106                    }
7107
7108                    if (DEBUG_STARTING_WINDOW) Slog.v(TAG, "Add starting "
7109                            + wtoken + ": pkg=" + sd.pkg);
7110
7111                    View view = null;
7112                    try {
7113                        view = mPolicy.addStartingWindow(
7114                            wtoken.token, sd.pkg, sd.theme, sd.compatInfo,
7115                            sd.nonLocalizedLabel, sd.labelRes, sd.icon, sd.logo, sd.windowFlags);
7116                    } catch (Exception e) {
7117                        Slog.w(TAG, "Exception when adding starting window", e);
7118                    }
7119
7120                    if (view != null) {
7121                        boolean abort = false;
7122
7123                        synchronized(mWindowMap) {
7124                            if (wtoken.removed || wtoken.startingData == null) {
7125                                // If the window was successfully added, then
7126                                // we need to remove it.
7127                                if (wtoken.startingWindow != null) {
7128                                    if (DEBUG_STARTING_WINDOW) Slog.v(TAG,
7129                                            "Aborted starting " + wtoken
7130                                            + ": removed=" + wtoken.removed
7131                                            + " startingData=" + wtoken.startingData);
7132                                    removeStartingWindowTimeout(wtoken);
7133                                    wtoken.startingWindow = null;
7134                                    wtoken.startingData = null;
7135                                    abort = true;
7136                                }
7137                            } else {
7138                                wtoken.startingView = view;
7139                            }
7140                            if (DEBUG_STARTING_WINDOW && !abort) Slog.v(TAG,
7141                                    "Added starting " + wtoken
7142                                    + ": startingWindow="
7143                                    + wtoken.startingWindow + " startingView="
7144                                    + wtoken.startingView);
7145                        }
7146
7147                        if (abort) {
7148                            try {
7149                                mPolicy.removeStartingWindow(wtoken.token, view);
7150                            } catch (Exception e) {
7151                                Slog.w(TAG, "Exception when removing starting window", e);
7152                            }
7153                        }
7154                    }
7155                } break;
7156
7157                case REMOVE_STARTING_TIMEOUT: {
7158                    final AppWindowToken wtoken = (AppWindowToken)msg.obj;
7159                    Slog.e(TAG, "Starting window " + wtoken + " timed out");
7160                    // Fall through.
7161                }
7162                case REMOVE_STARTING: {
7163                    final AppWindowToken wtoken = (AppWindowToken)msg.obj;
7164                    IBinder token = null;
7165                    View view = null;
7166                    synchronized (mWindowMap) {
7167                        if (DEBUG_STARTING_WINDOW) Slog.v(TAG, "Remove starting "
7168                                + wtoken + ": startingWindow="
7169                                + wtoken.startingWindow + " startingView="
7170                                + wtoken.startingView);
7171                        if (wtoken.startingWindow != null) {
7172                            view = wtoken.startingView;
7173                            token = wtoken.token;
7174                            wtoken.startingData = null;
7175                            wtoken.startingView = null;
7176                            wtoken.startingWindow = null;
7177                            wtoken.startingDisplayed = false;
7178                        }
7179                    }
7180                    if (view != null) {
7181                        try {
7182                            mPolicy.removeStartingWindow(token, view);
7183                        } catch (Exception e) {
7184                            Slog.w(TAG, "Exception when removing starting window", e);
7185                        }
7186                    }
7187                } break;
7188
7189                case FINISHED_STARTING: {
7190                    IBinder token = null;
7191                    View view = null;
7192                    while (true) {
7193                        synchronized (mWindowMap) {
7194                            final int N = mFinishedStarting.size();
7195                            if (N <= 0) {
7196                                break;
7197                            }
7198                            AppWindowToken wtoken = mFinishedStarting.remove(N-1);
7199
7200                            if (DEBUG_STARTING_WINDOW) Slog.v(TAG,
7201                                    "Finished starting " + wtoken
7202                                    + ": startingWindow=" + wtoken.startingWindow
7203                                    + " startingView=" + wtoken.startingView);
7204
7205                            if (wtoken.startingWindow == null) {
7206                                continue;
7207                            }
7208
7209                            view = wtoken.startingView;
7210                            token = wtoken.token;
7211                            wtoken.startingData = null;
7212                            wtoken.startingView = null;
7213                            wtoken.startingWindow = null;
7214                            wtoken.startingDisplayed = false;
7215                        }
7216
7217                        try {
7218                            mPolicy.removeStartingWindow(token, view);
7219                        } catch (Exception e) {
7220                            Slog.w(TAG, "Exception when removing starting window", e);
7221                        }
7222                    }
7223                } break;
7224
7225                case REPORT_APPLICATION_TOKEN_DRAWN: {
7226                    final AppWindowToken wtoken = (AppWindowToken)msg.obj;
7227
7228                    try {
7229                        if (DEBUG_VISIBILITY) Slog.v(
7230                                TAG, "Reporting drawn in " + wtoken);
7231                        wtoken.appToken.windowsDrawn();
7232                    } catch (RemoteException ex) {
7233                    }
7234                } break;
7235
7236                case REPORT_APPLICATION_TOKEN_WINDOWS: {
7237                    final AppWindowToken wtoken = (AppWindowToken)msg.obj;
7238
7239                    boolean nowVisible = msg.arg1 != 0;
7240                    boolean nowGone = msg.arg2 != 0;
7241
7242                    try {
7243                        if (DEBUG_VISIBILITY) Slog.v(
7244                                TAG, "Reporting visible in " + wtoken
7245                                + " visible=" + nowVisible
7246                                + " gone=" + nowGone);
7247                        if (nowVisible) {
7248                            wtoken.appToken.windowsVisible();
7249                        } else {
7250                            wtoken.appToken.windowsGone();
7251                        }
7252                    } catch (RemoteException ex) {
7253                    }
7254                } break;
7255
7256                case WINDOW_FREEZE_TIMEOUT: {
7257                    // TODO(multidisplay): Can non-default displays rotate?
7258                    synchronized (mWindowMap) {
7259                        Slog.w(TAG, "Window freeze timeout expired.");
7260                        final WindowList windows = getDefaultWindowListLocked();
7261                        int i = windows.size();
7262                        while (i > 0) {
7263                            i--;
7264                            WindowState w = windows.get(i);
7265                            if (w.mOrientationChanging) {
7266                                w.mOrientationChanging = false;
7267                                w.mLastFreezeDuration = (int)(SystemClock.elapsedRealtime()
7268                                        - mDisplayFreezeTime);
7269                                Slog.w(TAG, "Force clearing orientation change: " + w);
7270                            }
7271                        }
7272                        performLayoutAndPlaceSurfacesLocked();
7273                    }
7274                    break;
7275                }
7276
7277                case APP_TRANSITION_TIMEOUT: {
7278                    synchronized (mWindowMap) {
7279                        if (mAppTransition.isTransitionSet()) {
7280                            if (DEBUG_APP_TRANSITIONS) Slog.v(TAG, "*** APP TRANSITION TIMEOUT");
7281                            mAppTransition.setTimeout();
7282                            performLayoutAndPlaceSurfacesLocked();
7283                        }
7284                    }
7285                    break;
7286                }
7287
7288                case PERSIST_ANIMATION_SCALE: {
7289                    Settings.Global.putFloat(mContext.getContentResolver(),
7290                            Settings.Global.WINDOW_ANIMATION_SCALE, mWindowAnimationScale);
7291                    Settings.Global.putFloat(mContext.getContentResolver(),
7292                            Settings.Global.TRANSITION_ANIMATION_SCALE, mTransitionAnimationScale);
7293                    Settings.Global.putFloat(mContext.getContentResolver(),
7294                            Settings.Global.ANIMATOR_DURATION_SCALE, mAnimatorDurationScale);
7295                    break;
7296                }
7297
7298                case FORCE_GC: {
7299                    synchronized (mWindowMap) {
7300                        // Since we're holding both mWindowMap and mAnimator we don't need to
7301                        // hold mAnimator.mLayoutToAnim.
7302                        if (mAnimator.mAnimating || mAnimationScheduled) {
7303                            // If we are animating, don't do the gc now but
7304                            // delay a bit so we don't interrupt the animation.
7305                            sendEmptyMessageDelayed(H.FORCE_GC, 2000);
7306                            return;
7307                        }
7308                        // If we are currently rotating the display, it will
7309                        // schedule a new message when done.
7310                        if (mDisplayFrozen) {
7311                            return;
7312                        }
7313                    }
7314                    Runtime.getRuntime().gc();
7315                    break;
7316                }
7317
7318                case ENABLE_SCREEN: {
7319                    performEnableScreen();
7320                    break;
7321                }
7322
7323                case APP_FREEZE_TIMEOUT: {
7324                    synchronized (mWindowMap) {
7325                        Slog.w(TAG, "App freeze timeout expired.");
7326                        DisplayContent displayContent = getDefaultDisplayContentLocked();
7327                        final ArrayList<Task> tasks = displayContent.getTasks();
7328                        for (int taskNdx = tasks.size() - 1; taskNdx >= 0; --taskNdx) {
7329                            AppTokenList tokens = tasks.get(taskNdx).mAppTokens;
7330                            for (int tokenNdx = tokens.size() - 1; tokenNdx >= 0; --tokenNdx) {
7331                                AppWindowToken tok = tokens.get(tokenNdx);
7332                                if (tok.mAppAnimator.freezingScreen) {
7333                                    Slog.w(TAG, "Force clearing freeze: " + tok);
7334                                    unsetAppFreezingScreenLocked(tok, true, true);
7335                                }
7336                            }
7337                        }
7338                    }
7339                    break;
7340                }
7341
7342                case CLIENT_FREEZE_TIMEOUT: {
7343                    synchronized (mWindowMap) {
7344                        if (mClientFreezingScreen) {
7345                            mClientFreezingScreen = false;
7346                            mLastFinishedFreezeSource = "client-timeout";
7347                            stopFreezingDisplayLocked();
7348                        }
7349                    }
7350                    break;
7351                }
7352
7353                case SEND_NEW_CONFIGURATION: {
7354                    removeMessages(SEND_NEW_CONFIGURATION);
7355                    sendNewConfiguration();
7356                    break;
7357                }
7358
7359                case REPORT_WINDOWS_CHANGE: {
7360                    if (mWindowsChanged) {
7361                        synchronized (mWindowMap) {
7362                            mWindowsChanged = false;
7363                        }
7364                        notifyWindowsChanged();
7365                    }
7366                    break;
7367                }
7368
7369                case DRAG_START_TIMEOUT: {
7370                    IBinder win = (IBinder)msg.obj;
7371                    if (DEBUG_DRAG) {
7372                        Slog.w(TAG, "Timeout starting drag by win " + win);
7373                    }
7374                    synchronized (mWindowMap) {
7375                        // !!! TODO: ANR the app that has failed to start the drag in time
7376                        if (mDragState != null) {
7377                            mDragState.unregister();
7378                            mInputMonitor.updateInputWindowsLw(true /*force*/);
7379                            mDragState.reset();
7380                            mDragState = null;
7381                        }
7382                    }
7383                    break;
7384                }
7385
7386                case DRAG_END_TIMEOUT: {
7387                    IBinder win = (IBinder)msg.obj;
7388                    if (DEBUG_DRAG) {
7389                        Slog.w(TAG, "Timeout ending drag to win " + win);
7390                    }
7391                    synchronized (mWindowMap) {
7392                        // !!! TODO: ANR the drag-receiving app
7393                        if (mDragState != null) {
7394                            mDragState.mDragResult = false;
7395                            mDragState.endDragLw();
7396                        }
7397                    }
7398                    break;
7399                }
7400
7401                case REPORT_HARD_KEYBOARD_STATUS_CHANGE: {
7402                    notifyHardKeyboardStatusChange();
7403                    break;
7404                }
7405
7406                case BOOT_TIMEOUT: {
7407                    performBootTimeout();
7408                    break;
7409                }
7410
7411                case WAITING_FOR_DRAWN_TIMEOUT: {
7412                    Pair<WindowState, IRemoteCallback> pair;
7413                    synchronized (mWindowMap) {
7414                        pair = (Pair<WindowState, IRemoteCallback>)msg.obj;
7415                        Slog.w(TAG, "Timeout waiting for drawn: " + pair.first);
7416                        if (!mWaitingForDrawn.remove(pair)) {
7417                            return;
7418                        }
7419                    }
7420                    try {
7421                        pair.second.sendResult(null);
7422                    } catch (RemoteException e) {
7423                    }
7424                    break;
7425                }
7426
7427                case SHOW_STRICT_MODE_VIOLATION: {
7428                    showStrictModeViolation(msg.arg1, msg.arg2);
7429                    break;
7430                }
7431
7432                case DO_ANIMATION_CALLBACK: {
7433                    try {
7434                        ((IRemoteCallback)msg.obj).sendResult(null);
7435                    } catch (RemoteException e) {
7436                    }
7437                    break;
7438                }
7439
7440                case DO_DISPLAY_ADDED:
7441                    synchronized (mWindowMap) {
7442                        handleDisplayAddedLocked(msg.arg1);
7443                    }
7444                    break;
7445
7446                case DO_DISPLAY_REMOVED:
7447                    synchronized (mWindowMap) {
7448                        handleDisplayRemovedLocked(msg.arg1);
7449                    }
7450                    break;
7451
7452                case DO_DISPLAY_CHANGED:
7453                    synchronized (mWindowMap) {
7454                        handleDisplayChangedLocked(msg.arg1);
7455                    }
7456                    break;
7457
7458                case TAP_OUTSIDE_STACK: {
7459                    int stackId;
7460                    synchronized (mWindowMap) {
7461                        stackId = ((DisplayContent)msg.obj).stackIdFromPoint(msg.arg1, msg.arg2);
7462                    }
7463                    if (stackId >= 0) {
7464                        try {
7465                            mActivityManager.setFocusedStack(stackId);
7466                        } catch (RemoteException e) {
7467                        }
7468                    }
7469                }
7470                break;
7471                case NOTIFY_ACTIVITY_DRAWN:
7472                    try {
7473                        mActivityManager.notifyActivityDrawn((IBinder) msg.obj);
7474                    } catch (RemoteException e) {
7475                    }
7476                    break;
7477                case CREATE_STACK:
7478                    synchronized (mWindowMap) {
7479                        createStackLocked(msg.arg1, msg.arg2);
7480                    }
7481                    break;
7482            }
7483            if (DEBUG_WINDOW_TRACE) {
7484                Slog.v(TAG, "handleMessage: exit");
7485            }
7486        }
7487    }
7488
7489    // -------------------------------------------------------------
7490    // IWindowManager API
7491    // -------------------------------------------------------------
7492
7493    @Override
7494    public IWindowSession openSession(IInputMethodClient client,
7495            IInputContext inputContext) {
7496        if (client == null) throw new IllegalArgumentException("null client");
7497        if (inputContext == null) throw new IllegalArgumentException("null inputContext");
7498        Session session = new Session(this, client, inputContext);
7499        return session;
7500    }
7501
7502    @Override
7503    public boolean inputMethodClientHasFocus(IInputMethodClient client) {
7504        synchronized (mWindowMap) {
7505            // The focus for the client is the window immediately below
7506            // where we would place the input method window.
7507            int idx = findDesiredInputMethodWindowIndexLocked(false);
7508            if (idx > 0) {
7509                // TODO(multidisplay): IMEs are only supported on the default display.
7510                WindowState imFocus = getDefaultWindowListLocked().get(idx-1);
7511                if (DEBUG_INPUT_METHOD) {
7512                    Slog.i(TAG, "Desired input method target: " + imFocus);
7513                    Slog.i(TAG, "Current focus: " + mCurrentFocus);
7514                    Slog.i(TAG, "Last focus: " + mLastFocus);
7515                }
7516                if (imFocus != null) {
7517                    // This may be a starting window, in which case we still want
7518                    // to count it as okay.
7519                    if (imFocus.mAttrs.type == LayoutParams.TYPE_APPLICATION_STARTING
7520                            && imFocus.mAppToken != null) {
7521                        // The client has definitely started, so it really should
7522                        // have a window in this app token.  Let's look for it.
7523                        for (int i=0; i<imFocus.mAppToken.windows.size(); i++) {
7524                            WindowState w = imFocus.mAppToken.windows.get(i);
7525                            if (w != imFocus) {
7526                                Log.i(TAG, "Switching to real app window: " + w);
7527                                imFocus = w;
7528                                break;
7529                            }
7530                        }
7531                    }
7532                    if (DEBUG_INPUT_METHOD) {
7533                        Slog.i(TAG, "IM target client: " + imFocus.mSession.mClient);
7534                        if (imFocus.mSession.mClient != null) {
7535                            Slog.i(TAG, "IM target client binder: "
7536                                    + imFocus.mSession.mClient.asBinder());
7537                            Slog.i(TAG, "Requesting client binder: " + client.asBinder());
7538                        }
7539                    }
7540                    if (imFocus.mSession.mClient != null &&
7541                            imFocus.mSession.mClient.asBinder() == client.asBinder()) {
7542                        return true;
7543                    }
7544                }
7545            }
7546
7547            // Okay, how about this...  what is the current focus?
7548            // It seems in some cases we may not have moved the IM
7549            // target window, such as when it was in a pop-up window,
7550            // so let's also look at the current focus.  (An example:
7551            // go to Gmail, start searching so the keyboard goes up,
7552            // press home.  Sometimes the IME won't go down.)
7553            // Would be nice to fix this more correctly, but it's
7554            // way at the end of a release, and this should be good enough.
7555            if (mCurrentFocus != null && mCurrentFocus.mSession.mClient != null
7556                    && mCurrentFocus.mSession.mClient.asBinder() == client.asBinder()) {
7557                return true;
7558            }
7559        }
7560        return false;
7561    }
7562
7563    @Override
7564    public void getInitialDisplaySize(int displayId, Point size) {
7565        synchronized (mWindowMap) {
7566            final DisplayContent displayContent = getDisplayContentLocked(displayId);
7567            if (displayContent != null && displayContent.hasAccess(Binder.getCallingUid())) {
7568                synchronized(displayContent.mDisplaySizeLock) {
7569                    size.x = displayContent.mInitialDisplayWidth;
7570                    size.y = displayContent.mInitialDisplayHeight;
7571                }
7572            }
7573        }
7574    }
7575
7576    @Override
7577    public void getBaseDisplaySize(int displayId, Point size) {
7578        synchronized (mWindowMap) {
7579            final DisplayContent displayContent = getDisplayContentLocked(displayId);
7580            if (displayContent != null && displayContent.hasAccess(Binder.getCallingUid())) {
7581                synchronized(displayContent.mDisplaySizeLock) {
7582                    size.x = displayContent.mBaseDisplayWidth;
7583                    size.y = displayContent.mBaseDisplayHeight;
7584                }
7585            }
7586        }
7587    }
7588
7589    @Override
7590    public void setForcedDisplaySize(int displayId, int width, int height) {
7591        if (mContext.checkCallingOrSelfPermission(
7592                android.Manifest.permission.WRITE_SECURE_SETTINGS) !=
7593                PackageManager.PERMISSION_GRANTED) {
7594            throw new SecurityException("Must hold permission " +
7595                    android.Manifest.permission.WRITE_SECURE_SETTINGS);
7596        }
7597        if (displayId != Display.DEFAULT_DISPLAY) {
7598            throw new IllegalArgumentException("Can only set the default display");
7599        }
7600        final long ident = Binder.clearCallingIdentity();
7601        try {
7602            synchronized(mWindowMap) {
7603                // Set some sort of reasonable bounds on the size of the display that we
7604                // will try to emulate.
7605                final int MIN_WIDTH = 200;
7606                final int MIN_HEIGHT = 200;
7607                final int MAX_SCALE = 2;
7608                final DisplayContent displayContent = getDisplayContentLocked(displayId);
7609                if (displayContent != null) {
7610                    width = Math.min(Math.max(width, MIN_WIDTH),
7611                            displayContent.mInitialDisplayWidth * MAX_SCALE);
7612                    height = Math.min(Math.max(height, MIN_HEIGHT),
7613                            displayContent.mInitialDisplayHeight * MAX_SCALE);
7614                    setForcedDisplaySizeLocked(displayContent, width, height);
7615                    Settings.Global.putString(mContext.getContentResolver(),
7616                            Settings.Global.DISPLAY_SIZE_FORCED, width + "," + height);
7617                }
7618            }
7619        } finally {
7620            Binder.restoreCallingIdentity(ident);
7621        }
7622    }
7623
7624    private void readForcedDisplaySizeAndDensityLocked(final DisplayContent displayContent) {
7625        String sizeStr = Settings.Global.getString(mContext.getContentResolver(),
7626                Settings.Global.DISPLAY_SIZE_FORCED);
7627        if (sizeStr == null || sizeStr.length() == 0) {
7628            sizeStr = SystemProperties.get(SIZE_OVERRIDE, null);
7629        }
7630        if (sizeStr != null && sizeStr.length() > 0) {
7631            final int pos = sizeStr.indexOf(',');
7632            if (pos > 0 && sizeStr.lastIndexOf(',') == pos) {
7633                int width, height;
7634                try {
7635                    width = Integer.parseInt(sizeStr.substring(0, pos));
7636                    height = Integer.parseInt(sizeStr.substring(pos+1));
7637                    synchronized(displayContent.mDisplaySizeLock) {
7638                        if (displayContent.mBaseDisplayWidth != width
7639                                || displayContent.mBaseDisplayHeight != height) {
7640                            Slog.i(TAG, "FORCED DISPLAY SIZE: " + width + "x" + height);
7641                            displayContent.mBaseDisplayWidth = width;
7642                            displayContent.mBaseDisplayHeight = height;
7643                        }
7644                    }
7645                } catch (NumberFormatException ex) {
7646                }
7647            }
7648        }
7649        String densityStr = Settings.Global.getString(mContext.getContentResolver(),
7650                Settings.Global.DISPLAY_DENSITY_FORCED);
7651        if (densityStr == null || densityStr.length() == 0) {
7652            densityStr = SystemProperties.get(DENSITY_OVERRIDE, null);
7653        }
7654        if (densityStr != null && densityStr.length() > 0) {
7655            int density;
7656            try {
7657                density = Integer.parseInt(densityStr);
7658                synchronized(displayContent.mDisplaySizeLock) {
7659                    if (displayContent.mBaseDisplayDensity != density) {
7660                        Slog.i(TAG, "FORCED DISPLAY DENSITY: " + density);
7661                        displayContent.mBaseDisplayDensity = density;
7662                    }
7663                }
7664            } catch (NumberFormatException ex) {
7665            }
7666        }
7667    }
7668
7669    // displayContent must not be null
7670    private void setForcedDisplaySizeLocked(DisplayContent displayContent, int width, int height) {
7671        Slog.i(TAG, "Using new display size: " + width + "x" + height);
7672
7673        synchronized(displayContent.mDisplaySizeLock) {
7674            displayContent.mBaseDisplayWidth = width;
7675            displayContent.mBaseDisplayHeight = height;
7676        }
7677        reconfigureDisplayLocked(displayContent);
7678    }
7679
7680    @Override
7681    public void clearForcedDisplaySize(int displayId) {
7682        if (mContext.checkCallingOrSelfPermission(
7683                android.Manifest.permission.WRITE_SECURE_SETTINGS) !=
7684                PackageManager.PERMISSION_GRANTED) {
7685            throw new SecurityException("Must hold permission " +
7686                    android.Manifest.permission.WRITE_SECURE_SETTINGS);
7687        }
7688        if (displayId != Display.DEFAULT_DISPLAY) {
7689            throw new IllegalArgumentException("Can only set the default display");
7690        }
7691        final long ident = Binder.clearCallingIdentity();
7692        try {
7693            synchronized(mWindowMap) {
7694                final DisplayContent displayContent = getDisplayContentLocked(displayId);
7695                if (displayContent != null) {
7696                    setForcedDisplaySizeLocked(displayContent, displayContent.mInitialDisplayWidth,
7697                            displayContent.mInitialDisplayHeight);
7698                    Settings.Global.putString(mContext.getContentResolver(),
7699                            Settings.Global.DISPLAY_SIZE_FORCED, "");
7700                }
7701            }
7702        } finally {
7703            Binder.restoreCallingIdentity(ident);
7704        }
7705    }
7706
7707    @Override
7708    public int getInitialDisplayDensity(int displayId) {
7709        synchronized (mWindowMap) {
7710            final DisplayContent displayContent = getDisplayContentLocked(displayId);
7711            if (displayContent != null && displayContent.hasAccess(Binder.getCallingUid())) {
7712                synchronized(displayContent.mDisplaySizeLock) {
7713                    return displayContent.mInitialDisplayDensity;
7714                }
7715            }
7716        }
7717        return -1;
7718    }
7719
7720    @Override
7721    public int getBaseDisplayDensity(int displayId) {
7722        synchronized (mWindowMap) {
7723            final DisplayContent displayContent = getDisplayContentLocked(displayId);
7724            if (displayContent != null && displayContent.hasAccess(Binder.getCallingUid())) {
7725                synchronized(displayContent.mDisplaySizeLock) {
7726                    return displayContent.mBaseDisplayDensity;
7727                }
7728            }
7729        }
7730        return -1;
7731    }
7732
7733    @Override
7734    public void setForcedDisplayDensity(int displayId, int density) {
7735        if (mContext.checkCallingOrSelfPermission(
7736                android.Manifest.permission.WRITE_SECURE_SETTINGS) !=
7737                PackageManager.PERMISSION_GRANTED) {
7738            throw new SecurityException("Must hold permission " +
7739                    android.Manifest.permission.WRITE_SECURE_SETTINGS);
7740        }
7741        if (displayId != Display.DEFAULT_DISPLAY) {
7742            throw new IllegalArgumentException("Can only set the default display");
7743        }
7744        final long ident = Binder.clearCallingIdentity();
7745        try {
7746            synchronized(mWindowMap) {
7747                final DisplayContent displayContent = getDisplayContentLocked(displayId);
7748                if (displayContent != null) {
7749                    setForcedDisplayDensityLocked(displayContent, density);
7750                    Settings.Global.putString(mContext.getContentResolver(),
7751                            Settings.Global.DISPLAY_DENSITY_FORCED, Integer.toString(density));
7752                }
7753            }
7754        } finally {
7755            Binder.restoreCallingIdentity(ident);
7756        }
7757    }
7758
7759    // displayContent must not be null
7760    private void setForcedDisplayDensityLocked(DisplayContent displayContent, int density) {
7761        Slog.i(TAG, "Using new display density: " + density);
7762
7763        synchronized(displayContent.mDisplaySizeLock) {
7764            displayContent.mBaseDisplayDensity = density;
7765        }
7766        reconfigureDisplayLocked(displayContent);
7767    }
7768
7769    @Override
7770    public void clearForcedDisplayDensity(int displayId) {
7771        if (mContext.checkCallingOrSelfPermission(
7772                android.Manifest.permission.WRITE_SECURE_SETTINGS) !=
7773                PackageManager.PERMISSION_GRANTED) {
7774            throw new SecurityException("Must hold permission " +
7775                    android.Manifest.permission.WRITE_SECURE_SETTINGS);
7776        }
7777        if (displayId != Display.DEFAULT_DISPLAY) {
7778            throw new IllegalArgumentException("Can only set the default display");
7779        }
7780        final long ident = Binder.clearCallingIdentity();
7781        try {
7782            synchronized(mWindowMap) {
7783                final DisplayContent displayContent = getDisplayContentLocked(displayId);
7784                if (displayContent != null) {
7785                    setForcedDisplayDensityLocked(displayContent,
7786                            displayContent.mInitialDisplayDensity);
7787                    Settings.Global.putString(mContext.getContentResolver(),
7788                            Settings.Global.DISPLAY_DENSITY_FORCED, "");
7789                }
7790            }
7791        } finally {
7792            Binder.restoreCallingIdentity(ident);
7793        }
7794    }
7795
7796    // displayContent must not be null
7797    private void reconfigureDisplayLocked(DisplayContent displayContent) {
7798        // TODO: Multidisplay: for now only use with default display.
7799        configureDisplayPolicyLocked(displayContent);
7800        displayContent.layoutNeeded = true;
7801
7802        boolean configChanged = updateOrientationFromAppTokensLocked(false);
7803        mTempConfiguration.setToDefaults();
7804        mTempConfiguration.fontScale = mCurConfiguration.fontScale;
7805        if (computeScreenConfigurationLocked(mTempConfiguration)) {
7806            if (mCurConfiguration.diff(mTempConfiguration) != 0) {
7807                configChanged = true;
7808            }
7809        }
7810
7811        if (configChanged) {
7812            mWaitingForConfig = true;
7813            startFreezingDisplayLocked(false, 0, 0);
7814            mH.sendEmptyMessage(H.SEND_NEW_CONFIGURATION);
7815        }
7816
7817        performLayoutAndPlaceSurfacesLocked();
7818    }
7819
7820    private void configureDisplayPolicyLocked(DisplayContent displayContent) {
7821        mPolicy.setInitialDisplaySize(displayContent.getDisplay(),
7822                displayContent.mBaseDisplayWidth,
7823                displayContent.mBaseDisplayHeight,
7824                displayContent.mBaseDisplayDensity);
7825
7826        DisplayInfo displayInfo = displayContent.getDisplayInfo();
7827        mPolicy.setDisplayOverscan(displayContent.getDisplay(),
7828                displayInfo.overscanLeft, displayInfo.overscanTop,
7829                displayInfo.overscanRight, displayInfo.overscanBottom);
7830    }
7831
7832    @Override
7833    public void setOverscan(int displayId, int left, int top, int right, int bottom) {
7834        if (mContext.checkCallingOrSelfPermission(
7835                android.Manifest.permission.WRITE_SECURE_SETTINGS) !=
7836                PackageManager.PERMISSION_GRANTED) {
7837            throw new SecurityException("Must hold permission " +
7838                    android.Manifest.permission.WRITE_SECURE_SETTINGS);
7839        }
7840        final long ident = Binder.clearCallingIdentity();
7841        try {
7842            synchronized(mWindowMap) {
7843                DisplayContent displayContent = getDisplayContentLocked(displayId);
7844                if (displayContent != null) {
7845                    setOverscanLocked(displayContent, left, top, right, bottom);
7846                }
7847            }
7848        } finally {
7849            Binder.restoreCallingIdentity(ident);
7850        }
7851    }
7852
7853    private void setOverscanLocked(DisplayContent displayContent,
7854            int left, int top, int right, int bottom) {
7855        final DisplayInfo displayInfo = displayContent.getDisplayInfo();
7856        synchronized (displayContent.mDisplaySizeLock) {
7857            displayInfo.overscanLeft = left;
7858            displayInfo.overscanTop = top;
7859            displayInfo.overscanRight = right;
7860            displayInfo.overscanBottom = bottom;
7861        }
7862
7863        mDisplaySettings.setOverscanLocked(displayInfo.name, left, top, right, bottom);
7864        mDisplaySettings.writeSettingsLocked();
7865
7866        reconfigureDisplayLocked(displayContent);
7867    }
7868
7869    // -------------------------------------------------------------
7870    // Internals
7871    // -------------------------------------------------------------
7872
7873    final WindowState windowForClientLocked(Session session, IWindow client,
7874            boolean throwOnError) {
7875        return windowForClientLocked(session, client.asBinder(), throwOnError);
7876    }
7877
7878    final WindowState windowForClientLocked(Session session, IBinder client,
7879            boolean throwOnError) {
7880        WindowState win = mWindowMap.get(client);
7881        if (localLOGV) Slog.v(
7882            TAG, "Looking up client " + client + ": " + win);
7883        if (win == null) {
7884            RuntimeException ex = new IllegalArgumentException(
7885                    "Requested window " + client + " does not exist");
7886            if (throwOnError) {
7887                throw ex;
7888            }
7889            Slog.w(TAG, "Failed looking up window", ex);
7890            return null;
7891        }
7892        if (session != null && win.mSession != session) {
7893            RuntimeException ex = new IllegalArgumentException(
7894                    "Requested window " + client + " is in session " +
7895                    win.mSession + ", not " + session);
7896            if (throwOnError) {
7897                throw ex;
7898            }
7899            Slog.w(TAG, "Failed looking up window", ex);
7900            return null;
7901        }
7902
7903        return win;
7904    }
7905
7906    final void rebuildAppWindowListLocked() {
7907        // TODO: Multidisplay, when ActivityStacks and tasks exist on more than one display.
7908        rebuildAppWindowListLocked(getDefaultDisplayContentLocked());
7909    }
7910
7911    private void rebuildAppWindowListLocked(final DisplayContent displayContent) {
7912        final WindowList windows = displayContent.getWindowList();
7913        int NW = windows.size();
7914        int i;
7915        int lastBelow = -1;
7916        int numRemoved = 0;
7917
7918        if (mRebuildTmp.length < NW) {
7919            mRebuildTmp = new WindowState[NW+10];
7920        }
7921
7922        // First remove all existing app windows.
7923        i=0;
7924        while (i < NW) {
7925            WindowState w = windows.get(i);
7926            if (w.mAppToken != null) {
7927                WindowState win = windows.remove(i);
7928                win.mRebuilding = true;
7929                mRebuildTmp[numRemoved] = win;
7930                mWindowsChanged = true;
7931                if (DEBUG_WINDOW_MOVEMENT) Slog.v(TAG, "Rebuild removing window: " + win);
7932                NW--;
7933                numRemoved++;
7934                continue;
7935            } else if (lastBelow == i-1) {
7936                if (w.mAttrs.type == TYPE_WALLPAPER || w.mAttrs.type == TYPE_UNIVERSE_BACKGROUND) {
7937                    lastBelow = i;
7938                }
7939            }
7940            i++;
7941        }
7942
7943        // Keep whatever windows were below the app windows still below,
7944        // by skipping them.
7945        lastBelow++;
7946        i = lastBelow;
7947
7948        // First add all of the exiting app tokens...  these are no longer
7949        // in the main app list, but still have windows shown.  We put them
7950        // in the back because now that the animation is over we no longer
7951        // will care about them.
7952        AppTokenList exitingAppTokens = displayContent.mExitingAppTokens;
7953        int NT = exitingAppTokens.size();
7954        for (int j=0; j<NT; j++) {
7955            i = reAddAppWindowsLocked(displayContent, i, exitingAppTokens.get(j));
7956        }
7957
7958        // And add in the still active app tokens in Z order.
7959        final ArrayList<Task> tasks = displayContent.getTasks();
7960        final int numTasks = tasks.size();
7961        for (int taskNdx = 0; taskNdx < numTasks; ++taskNdx) {
7962            final AppTokenList tokens = tasks.get(taskNdx).mAppTokens;
7963            final int numTokens = tokens.size();
7964            for (int tokenNdx = 0; tokenNdx < numTokens; ++tokenNdx) {
7965                final AppWindowToken wtoken = tokens.get(tokenNdx);
7966                i = reAddAppWindowsLocked(displayContent, i, wtoken);
7967            }
7968        }
7969
7970        i -= lastBelow;
7971        if (i != numRemoved) {
7972            Slog.w(TAG, "Rebuild removed " + numRemoved + " windows but added " + i,
7973                    new RuntimeException("here").fillInStackTrace());
7974            for (i=0; i<numRemoved; i++) {
7975                WindowState ws = mRebuildTmp[i];
7976                if (ws.mRebuilding) {
7977                    StringWriter sw = new StringWriter();
7978                    PrintWriter pw = new FastPrintWriter(sw, false, 1024);
7979                    ws.dump(pw, "", true);
7980                    pw.flush();
7981                    Slog.w(TAG, "This window was lost: " + ws);
7982                    Slog.w(TAG, sw.toString());
7983                    ws.mWinAnimator.destroySurfaceLocked();
7984                }
7985            }
7986            Slog.w(TAG, "Current app token list:");
7987            dumpAppTokensLocked();
7988            Slog.w(TAG, "Final window list:");
7989            dumpWindowsLocked();
7990        }
7991    }
7992
7993    private final void assignLayersLocked(WindowList windows) {
7994        int N = windows.size();
7995        int curBaseLayer = 0;
7996        int curLayer = 0;
7997        int i;
7998
7999        if (DEBUG_LAYERS) Slog.v(TAG, "Assigning layers based on windows=" + windows,
8000                new RuntimeException("here").fillInStackTrace());
8001
8002        boolean anyLayerChanged = false;
8003
8004        for (i=0; i<N; i++) {
8005            final WindowState w = windows.get(i);
8006            final WindowStateAnimator winAnimator = w.mWinAnimator;
8007            boolean layerChanged = false;
8008            int oldLayer = w.mLayer;
8009            if (w.mBaseLayer == curBaseLayer || w.mIsImWindow
8010                    || (i > 0 && w.mIsWallpaper)) {
8011                curLayer += WINDOW_LAYER_MULTIPLIER;
8012                w.mLayer = curLayer;
8013            } else {
8014                curBaseLayer = curLayer = w.mBaseLayer;
8015                w.mLayer = curLayer;
8016            }
8017            if (w.mLayer != oldLayer) {
8018                layerChanged = true;
8019                anyLayerChanged = true;
8020            }
8021            final AppWindowToken wtoken = w.mAppToken;
8022            oldLayer = winAnimator.mAnimLayer;
8023            if (w.mTargetAppToken != null) {
8024                winAnimator.mAnimLayer =
8025                        w.mLayer + w.mTargetAppToken.mAppAnimator.animLayerAdjustment;
8026            } else if (wtoken != null) {
8027                winAnimator.mAnimLayer =
8028                        w.mLayer + wtoken.mAppAnimator.animLayerAdjustment;
8029            } else {
8030                winAnimator.mAnimLayer = w.mLayer;
8031            }
8032            if (w.mIsImWindow) {
8033                winAnimator.mAnimLayer += mInputMethodAnimLayerAdjustment;
8034            } else if (w.mIsWallpaper) {
8035                winAnimator.mAnimLayer += mWallpaperAnimLayerAdjustment;
8036            }
8037            if (winAnimator.mAnimLayer != oldLayer) {
8038                layerChanged = true;
8039                anyLayerChanged = true;
8040            }
8041            if (layerChanged && w.getStack().isDimming(winAnimator)) {
8042                // Force an animation pass just to update the mDimLayer layer.
8043                scheduleAnimationLocked();
8044            }
8045            if (DEBUG_LAYERS) Slog.v(TAG, "Assign layer " + w + ": "
8046                    + "mBase=" + w.mBaseLayer
8047                    + " mLayer=" + w.mLayer
8048                    + (wtoken == null ?
8049                            "" : " mAppLayer=" + wtoken.mAppAnimator.animLayerAdjustment)
8050                    + " =mAnimLayer=" + winAnimator.mAnimLayer);
8051            //System.out.println(
8052            //    "Assigned layer " + curLayer + " to " + w.mClient.asBinder());
8053        }
8054
8055        //TODO (multidisplay): Magnification is supported only for the default display.
8056        if (mDisplayMagnifier != null && anyLayerChanged
8057                && windows.get(windows.size() - 1).getDisplayId() == Display.DEFAULT_DISPLAY) {
8058            mDisplayMagnifier.onWindowLayersChangedLocked();
8059        }
8060    }
8061
8062    private final void performLayoutAndPlaceSurfacesLocked() {
8063        int loopCount = 6;
8064        do {
8065            mTraversalScheduled = false;
8066            performLayoutAndPlaceSurfacesLockedLoop();
8067            mH.removeMessages(H.DO_TRAVERSAL);
8068            loopCount--;
8069        } while (mTraversalScheduled && loopCount > 0);
8070        mInnerFields.mWallpaperActionPending = false;
8071    }
8072
8073    private boolean mInLayout = false;
8074    private final void performLayoutAndPlaceSurfacesLockedLoop() {
8075        if (mInLayout) {
8076            if (DEBUG) {
8077                throw new RuntimeException("Recursive call!");
8078            }
8079            Slog.w(TAG, "performLayoutAndPlaceSurfacesLocked called while in layout. Callers="
8080                    + Debug.getCallers(3));
8081            return;
8082        }
8083
8084        if (mWaitingForConfig) {
8085            // Our configuration has changed (most likely rotation), but we
8086            // don't yet have the complete configuration to report to
8087            // applications.  Don't do any window layout until we have it.
8088            return;
8089        }
8090
8091        if (!mDisplayReady) {
8092            // Not yet initialized, nothing to do.
8093            return;
8094        }
8095
8096        Trace.traceBegin(Trace.TRACE_TAG_WINDOW_MANAGER, "wmLayout");
8097        mInLayout = true;
8098        boolean recoveringMemory = false;
8099
8100        try {
8101            if (mForceRemoves != null) {
8102                recoveringMemory = true;
8103                // Wait a little bit for things to settle down, and off we go.
8104                for (int i=0; i<mForceRemoves.size(); i++) {
8105                    WindowState ws = mForceRemoves.get(i);
8106                    Slog.i(TAG, "Force removing: " + ws);
8107                    removeWindowInnerLocked(ws.mSession, ws);
8108                }
8109                mForceRemoves = null;
8110                Slog.w(TAG, "Due to memory failure, waiting a bit for next layout");
8111                Object tmp = new Object();
8112                synchronized (tmp) {
8113                    try {
8114                        tmp.wait(250);
8115                    } catch (InterruptedException e) {
8116                    }
8117                }
8118            }
8119        } catch (RuntimeException e) {
8120            Log.wtf(TAG, "Unhandled exception while force removing for memory", e);
8121        }
8122
8123        try {
8124            performLayoutAndPlaceSurfacesLockedInner(recoveringMemory);
8125
8126            mInLayout = false;
8127
8128            if (needsLayout()) {
8129                if (++mLayoutRepeatCount < 6) {
8130                    requestTraversalLocked();
8131                } else {
8132                    Slog.e(TAG, "Performed 6 layouts in a row. Skipping");
8133                    mLayoutRepeatCount = 0;
8134                }
8135            } else {
8136                mLayoutRepeatCount = 0;
8137            }
8138
8139            if (mWindowsChanged && !mWindowChangeListeners.isEmpty()) {
8140                mH.removeMessages(H.REPORT_WINDOWS_CHANGE);
8141                mH.sendEmptyMessage(H.REPORT_WINDOWS_CHANGE);
8142            }
8143        } catch (RuntimeException e) {
8144            mInLayout = false;
8145            Log.wtf(TAG, "Unhandled exception while laying out windows", e);
8146        }
8147
8148        Trace.traceEnd(Trace.TRACE_TAG_WINDOW_MANAGER);
8149    }
8150
8151    private final void performLayoutLockedInner(final DisplayContent displayContent,
8152                                    boolean initial, boolean updateInputWindows) {
8153        if (!displayContent.layoutNeeded) {
8154            return;
8155        }
8156        displayContent.layoutNeeded = false;
8157        WindowList windows = displayContent.getWindowList();
8158        boolean isDefaultDisplay = displayContent.isDefaultDisplay;
8159
8160        DisplayInfo displayInfo = displayContent.getDisplayInfo();
8161        final int dw = displayInfo.logicalWidth;
8162        final int dh = displayInfo.logicalHeight;
8163
8164        final int NFW = mFakeWindows.size();
8165        for (int i=0; i<NFW; i++) {
8166            mFakeWindows.get(i).layout(dw, dh);
8167        }
8168
8169        final int N = windows.size();
8170        int i;
8171
8172        if (DEBUG_LAYOUT) {
8173            Slog.v(TAG, "-------------------------------------");
8174            Slog.v(TAG, "performLayout: needed="
8175                    + displayContent.layoutNeeded + " dw=" + dw + " dh=" + dh);
8176        }
8177
8178        WindowStateAnimator universeBackground = null;
8179
8180        mPolicy.beginLayoutLw(isDefaultDisplay, dw, dh, mRotation);
8181        if (isDefaultDisplay) {
8182            // Not needed on non-default displays.
8183            mSystemDecorLayer = mPolicy.getSystemDecorLayerLw();
8184            mScreenRect.set(0, 0, dw, dh);
8185        }
8186
8187        mPolicy.getContentRectLw(mTmpContentRect);
8188        displayContent.resize(mTmpContentRect);
8189
8190        int seq = mLayoutSeq+1;
8191        if (seq < 0) seq = 0;
8192        mLayoutSeq = seq;
8193
8194        boolean behindDream = false;
8195
8196        // First perform layout of any root windows (not attached
8197        // to another window).
8198        int topAttached = -1;
8199        for (i = N-1; i >= 0; i--) {
8200            final WindowState win = windows.get(i);
8201
8202            // Don't do layout of a window if it is not visible, or
8203            // soon won't be visible, to avoid wasting time and funky
8204            // changes while a window is animating away.
8205            final boolean gone = (behindDream && mPolicy.canBeForceHidden(win, win.mAttrs))
8206                    || win.isGoneForLayoutLw();
8207
8208            if (DEBUG_LAYOUT && !win.mLayoutAttached) {
8209                Slog.v(TAG, "1ST PASS " + win
8210                        + ": gone=" + gone + " mHaveFrame=" + win.mHaveFrame
8211                        + " mLayoutAttached=" + win.mLayoutAttached
8212                        + " screen changed=" + win.isConfigChanged());
8213                final AppWindowToken atoken = win.mAppToken;
8214                if (gone) Slog.v(TAG, "  GONE: mViewVisibility="
8215                        + win.mViewVisibility + " mRelayoutCalled="
8216                        + win.mRelayoutCalled + " hidden="
8217                        + win.mRootToken.hidden + " hiddenRequested="
8218                        + (atoken != null && atoken.hiddenRequested)
8219                        + " mAttachedHidden=" + win.mAttachedHidden);
8220                else Slog.v(TAG, "  VIS: mViewVisibility="
8221                        + win.mViewVisibility + " mRelayoutCalled="
8222                        + win.mRelayoutCalled + " hidden="
8223                        + win.mRootToken.hidden + " hiddenRequested="
8224                        + (atoken != null && atoken.hiddenRequested)
8225                        + " mAttachedHidden=" + win.mAttachedHidden);
8226            }
8227
8228            // If this view is GONE, then skip it -- keep the current
8229            // frame, and let the caller know so they can ignore it
8230            // if they want.  (We do the normal layout for INVISIBLE
8231            // windows, since that means "perform layout as normal,
8232            // just don't display").
8233            if (!gone || !win.mHaveFrame || win.mLayoutNeeded
8234                    || ((win.isConfigChanged() || win.setInsetsChanged()) &&
8235                            (win.mAttrs.type == TYPE_KEYGUARD ||
8236                            win.mAppToken != null && win.mAppToken.layoutConfigChanges))
8237                    || win.mAttrs.type == TYPE_UNIVERSE_BACKGROUND) {
8238                if (!win.mLayoutAttached) {
8239                    if (initial) {
8240                        //Slog.i(TAG, "Window " + this + " clearing mContentChanged - initial");
8241                        win.mContentChanged = false;
8242                    }
8243                    if (win.mAttrs.type == TYPE_DREAM) {
8244                        // Don't layout windows behind a dream, so that if it
8245                        // does stuff like hide the status bar we won't get a
8246                        // bad transition when it goes away.
8247                        behindDream = true;
8248                    }
8249                    win.mLayoutNeeded = false;
8250                    win.prelayout();
8251                    mPolicy.layoutWindowLw(win, win.mAttrs, null);
8252                    win.mLayoutSeq = seq;
8253                    if (DEBUG_LAYOUT) Slog.v(TAG, "  LAYOUT: mFrame="
8254                            + win.mFrame + " mContainingFrame="
8255                            + win.mContainingFrame + " mDisplayFrame="
8256                            + win.mDisplayFrame);
8257                } else {
8258                    if (topAttached < 0) topAttached = i;
8259                }
8260            }
8261            if (win.mViewVisibility == View.VISIBLE
8262                    && win.mAttrs.type == TYPE_UNIVERSE_BACKGROUND
8263                    && universeBackground == null) {
8264                universeBackground = win.mWinAnimator;
8265            }
8266        }
8267
8268        if (mAnimator.mUniverseBackground  != universeBackground) {
8269            mFocusMayChange = true;
8270            mAnimator.mUniverseBackground = universeBackground;
8271        }
8272
8273        boolean attachedBehindDream = false;
8274
8275        // Now perform layout of attached windows, which usually
8276        // depend on the position of the window they are attached to.
8277        // XXX does not deal with windows that are attached to windows
8278        // that are themselves attached.
8279        for (i = topAttached; i >= 0; i--) {
8280            final WindowState win = windows.get(i);
8281
8282            if (win.mLayoutAttached) {
8283                if (DEBUG_LAYOUT) Slog.v(TAG, "2ND PASS " + win
8284                        + " mHaveFrame=" + win.mHaveFrame
8285                        + " mViewVisibility=" + win.mViewVisibility
8286                        + " mRelayoutCalled=" + win.mRelayoutCalled);
8287                // If this view is GONE, then skip it -- keep the current
8288                // frame, and let the caller know so they can ignore it
8289                // if they want.  (We do the normal layout for INVISIBLE
8290                // windows, since that means "perform layout as normal,
8291                // just don't display").
8292                if (attachedBehindDream && mPolicy.canBeForceHidden(win, win.mAttrs)) {
8293                    continue;
8294                }
8295                if ((win.mViewVisibility != View.GONE && win.mRelayoutCalled)
8296                        || !win.mHaveFrame || win.mLayoutNeeded) {
8297                    if (initial) {
8298                        //Slog.i(TAG, "Window " + this + " clearing mContentChanged - initial");
8299                        win.mContentChanged = false;
8300                    }
8301                    win.mLayoutNeeded = false;
8302                    win.prelayout();
8303                    mPolicy.layoutWindowLw(win, win.mAttrs, win.mAttachedWindow);
8304                    win.mLayoutSeq = seq;
8305                    if (DEBUG_LAYOUT) Slog.v(TAG, "  LAYOUT: mFrame="
8306                            + win.mFrame + " mContainingFrame="
8307                            + win.mContainingFrame + " mDisplayFrame="
8308                            + win.mDisplayFrame);
8309                }
8310            } else if (win.mAttrs.type == TYPE_DREAM) {
8311                // Don't layout windows behind a dream, so that if it
8312                // does stuff like hide the status bar we won't get a
8313                // bad transition when it goes away.
8314                attachedBehindDream = behindDream;
8315            }
8316        }
8317
8318        // Window frames may have changed.  Tell the input dispatcher about it.
8319        mInputMonitor.setUpdateInputWindowsNeededLw();
8320        if (updateInputWindows) {
8321            mInputMonitor.updateInputWindowsLw(false /*force*/);
8322        }
8323
8324        mPolicy.finishLayoutLw();
8325    }
8326
8327    void makeWindowFreezingScreenIfNeededLocked(WindowState w) {
8328        // If the screen is currently frozen or off, then keep
8329        // it frozen/off until this window draws at its new
8330        // orientation.
8331        if (!okToDisplay()) {
8332            if (DEBUG_ORIENTATION) Slog.v(TAG,
8333                    "Changing surface while display frozen: " + w);
8334            w.mOrientationChanging = true;
8335            w.mLastFreezeDuration = 0;
8336            mInnerFields.mOrientationChangeComplete = false;
8337            if (!mWindowsFreezingScreen) {
8338                mWindowsFreezingScreen = true;
8339                // XXX should probably keep timeout from
8340                // when we first froze the display.
8341                mH.removeMessages(H.WINDOW_FREEZE_TIMEOUT);
8342                mH.sendEmptyMessageDelayed(H.WINDOW_FREEZE_TIMEOUT,
8343                        WINDOW_FREEZE_TIMEOUT_DURATION);
8344            }
8345        }
8346    }
8347
8348    /**
8349     * Extracted from {@link #performLayoutAndPlaceSurfacesLockedInner} to reduce size of method.
8350     * @param windows List of windows on default display.
8351     * @return bitmap indicating if another pass through layout must be made.
8352     */
8353    public int handleAppTransitionReadyLocked(WindowList windows) {
8354        int changes = 0;
8355        int i;
8356        int NN = mOpeningApps.size();
8357        boolean goodToGo = true;
8358        if (DEBUG_APP_TRANSITIONS) Slog.v(TAG,
8359                "Checking " + NN + " opening apps (frozen="
8360                + mDisplayFrozen + " timeout="
8361                + mAppTransition.isTimeout() + ")...");
8362        if (!mDisplayFrozen && !mAppTransition.isTimeout()) {
8363            // If the display isn't frozen, wait to do anything until
8364            // all of the apps are ready.  Otherwise just go because
8365            // we'll unfreeze the display when everyone is ready.
8366            for (i=0; i<NN && goodToGo; i++) {
8367                AppWindowToken wtoken = mOpeningApps.get(i);
8368                if (DEBUG_APP_TRANSITIONS) Slog.v(TAG,
8369                        "Check opening app=" + wtoken + ": allDrawn="
8370                        + wtoken.allDrawn + " startingDisplayed="
8371                        + wtoken.startingDisplayed + " startingMoved="
8372                        + wtoken.startingMoved);
8373                if (!wtoken.allDrawn && !wtoken.startingDisplayed
8374                        && !wtoken.startingMoved) {
8375                    goodToGo = false;
8376                }
8377            }
8378        }
8379        if (goodToGo) {
8380            if (DEBUG_APP_TRANSITIONS) Slog.v(TAG, "**** GOOD TO GO");
8381            int transit = mAppTransition.getAppTransition();
8382            if (mSkipAppTransitionAnimation) {
8383                transit = AppTransition.TRANSIT_UNSET;
8384            }
8385            mAppTransition.goodToGo();
8386            mStartingIconInTransition = false;
8387            mSkipAppTransitionAnimation = false;
8388
8389            mH.removeMessages(H.APP_TRANSITION_TIMEOUT);
8390
8391            rebuildAppWindowListLocked();
8392
8393            // if wallpaper is animating in or out set oldWallpaper to null else to wallpaper
8394            WindowState oldWallpaper =
8395                    mWallpaperTarget != null && mWallpaperTarget.mWinAnimator.isAnimating()
8396                        && !mWallpaperTarget.mWinAnimator.isDummyAnimation()
8397                    ? null : mWallpaperTarget;
8398
8399            mInnerFields.mWallpaperMayChange = false;
8400
8401            // The top-most window will supply the layout params,
8402            // and we will determine it below.
8403            LayoutParams animLp = null;
8404            int bestAnimLayer = -1;
8405            boolean fullscreenAnim = false;
8406
8407            if (DEBUG_APP_TRANSITIONS) Slog.v(TAG,
8408                    "New wallpaper target=" + mWallpaperTarget
8409                    + ", oldWallpaper=" + oldWallpaper
8410                    + ", lower target=" + mLowerWallpaperTarget
8411                    + ", upper target=" + mUpperWallpaperTarget);
8412
8413            boolean openingAppHasWallpaper = false;
8414            boolean closingAppHasWallpaper = false;
8415            final AppWindowToken lowerWallpaperAppToken;
8416            final AppWindowToken upperWallpaperAppToken;
8417            if (mLowerWallpaperTarget == null) {
8418                lowerWallpaperAppToken = upperWallpaperAppToken = null;
8419            } else {
8420                lowerWallpaperAppToken = mLowerWallpaperTarget.mAppToken;
8421                upperWallpaperAppToken = mUpperWallpaperTarget.mAppToken;
8422            }
8423
8424            // Do a first pass through the tokens for two
8425            // things:
8426            // (1) Determine if both the closing and opening
8427            // app token sets are wallpaper targets, in which
8428            // case special animations are needed
8429            // (since the wallpaper needs to stay static
8430            // behind them).
8431            // (2) Find the layout params of the top-most
8432            // application window in the tokens, which is
8433            // what will control the animation theme.
8434            final int NC = mClosingApps.size();
8435            NN = NC + mOpeningApps.size();
8436            for (i=0; i<NN; i++) {
8437                final AppWindowToken wtoken;
8438                if (i < NC) {
8439                    wtoken = mClosingApps.get(i);
8440                    if (wtoken == lowerWallpaperAppToken || wtoken == upperWallpaperAppToken) {
8441                        closingAppHasWallpaper = true;
8442                    }
8443                } else {
8444                    wtoken = mOpeningApps.get(i - NC);
8445                    if (wtoken == lowerWallpaperAppToken || wtoken == upperWallpaperAppToken) {
8446                        openingAppHasWallpaper = true;
8447                    }
8448                }
8449
8450                if (wtoken.appFullscreen) {
8451                    WindowState ws = wtoken.findMainWindow();
8452                    if (ws != null) {
8453                        animLp = ws.mAttrs;
8454                        bestAnimLayer = ws.mLayer;
8455                        fullscreenAnim = true;
8456                    }
8457                } else if (!fullscreenAnim) {
8458                    WindowState ws = wtoken.findMainWindow();
8459                    if (ws != null) {
8460                        if (ws.mLayer > bestAnimLayer) {
8461                            animLp = ws.mAttrs;
8462                            bestAnimLayer = ws.mLayer;
8463                        }
8464                    }
8465                }
8466            }
8467
8468            mAnimateWallpaperWithTarget = false;
8469            if (closingAppHasWallpaper && openingAppHasWallpaper) {
8470                if (DEBUG_APP_TRANSITIONS) Slog.v(TAG, "Wallpaper animation!");
8471                switch (transit) {
8472                    case AppTransition.TRANSIT_ACTIVITY_OPEN:
8473                    case AppTransition.TRANSIT_TASK_OPEN:
8474                    case AppTransition.TRANSIT_TASK_TO_FRONT:
8475                        transit = AppTransition.TRANSIT_WALLPAPER_INTRA_OPEN;
8476                        break;
8477                    case AppTransition.TRANSIT_ACTIVITY_CLOSE:
8478                    case AppTransition.TRANSIT_TASK_CLOSE:
8479                    case AppTransition.TRANSIT_TASK_TO_BACK:
8480                        transit = AppTransition.TRANSIT_WALLPAPER_INTRA_CLOSE;
8481                        break;
8482                }
8483                if (DEBUG_APP_TRANSITIONS) Slog.v(TAG, "New transit: " + transit);
8484            } else if ((oldWallpaper != null) && !mOpeningApps.isEmpty()
8485                    && !mOpeningApps.contains(oldWallpaper.mAppToken)) {
8486                // We are transitioning from an activity with
8487                // a wallpaper to one without.
8488                transit = AppTransition.TRANSIT_WALLPAPER_CLOSE;
8489                if (DEBUG_APP_TRANSITIONS) Slog.v(TAG,
8490                        "New transit away from wallpaper: " + transit);
8491            } else if (mWallpaperTarget != null && mWallpaperTarget.isVisibleLw()) {
8492                // We are transitioning from an activity without
8493                // a wallpaper to now showing the wallpaper
8494                transit = AppTransition.TRANSIT_WALLPAPER_OPEN;
8495                if (DEBUG_APP_TRANSITIONS) Slog.v(TAG,
8496                        "New transit into wallpaper: " + transit);
8497            } else {
8498                mAnimateWallpaperWithTarget = true;
8499            }
8500
8501            // If all closing windows are obscured, then there is
8502            // no need to do an animation.  This is the case, for
8503            // example, when this transition is being done behind
8504            // the lock screen.
8505            if (!mPolicy.allowAppAnimationsLw()) {
8506                if (DEBUG_APP_TRANSITIONS) Slog.v(TAG,
8507                        "Animations disallowed by keyguard or dream.");
8508                animLp = null;
8509            }
8510
8511            AppWindowToken topOpeningApp = null;
8512            int topOpeningLayer = 0;
8513
8514            NN = mOpeningApps.size();
8515            for (i=0; i<NN; i++) {
8516                AppWindowToken wtoken = mOpeningApps.get(i);
8517                final AppWindowAnimator appAnimator = wtoken.mAppAnimator;
8518                if (DEBUG_APP_TRANSITIONS) Slog.v(TAG, "Now opening app" + wtoken);
8519                appAnimator.clearThumbnail();
8520                wtoken.inPendingTransaction = false;
8521                appAnimator.animation = null;
8522                setTokenVisibilityLocked(wtoken, animLp, true, transit, false);
8523                wtoken.updateReportedVisibilityLocked();
8524                wtoken.waitingToShow = false;
8525
8526                appAnimator.mAllAppWinAnimators.clear();
8527                final int N = wtoken.allAppWindows.size();
8528                for (int j = 0; j < N; j++) {
8529                    appAnimator.mAllAppWinAnimators.add(wtoken.allAppWindows.get(j).mWinAnimator);
8530                }
8531                mAnimator.mAnimating |= appAnimator.showAllWindowsLocked();
8532
8533                if (animLp != null) {
8534                    int layer = -1;
8535                    for (int j=0; j<wtoken.windows.size(); j++) {
8536                        WindowState win = wtoken.windows.get(j);
8537                        if (win.mWinAnimator.mAnimLayer > layer) {
8538                            layer = win.mWinAnimator.mAnimLayer;
8539                        }
8540                    }
8541                    if (topOpeningApp == null || layer > topOpeningLayer) {
8542                        topOpeningApp = wtoken;
8543                        topOpeningLayer = layer;
8544                    }
8545                }
8546            }
8547            NN = mClosingApps.size();
8548            for (i=0; i<NN; i++) {
8549                AppWindowToken wtoken = mClosingApps.get(i);
8550                if (DEBUG_APP_TRANSITIONS) Slog.v(TAG, "Now closing app " + wtoken);
8551                wtoken.mAppAnimator.clearThumbnail();
8552                wtoken.inPendingTransaction = false;
8553                wtoken.mAppAnimator.animation = null;
8554                setTokenVisibilityLocked(wtoken, animLp, false, transit, false);
8555                wtoken.updateReportedVisibilityLocked();
8556                wtoken.waitingToHide = false;
8557                // Force the allDrawn flag, because we want to start
8558                // this guy's animations regardless of whether it's
8559                // gotten drawn.
8560                wtoken.allDrawn = true;
8561                wtoken.deferClearAllDrawn = false;
8562            }
8563
8564            AppWindowAnimator appAnimator =
8565                    topOpeningApp == null ? null : topOpeningApp.mAppAnimator;
8566            Bitmap nextAppTransitionThumbnail = mAppTransition.getNextAppTransitionThumbnail();
8567            if (nextAppTransitionThumbnail != null && appAnimator != null
8568                    && appAnimator.animation != null) {
8569                // This thumbnail animation is very special, we need to have
8570                // an extra surface with the thumbnail included with the animation.
8571                Rect dirty = new Rect(0, 0, nextAppTransitionThumbnail.getWidth(),
8572                        nextAppTransitionThumbnail.getHeight());
8573                try {
8574                    // TODO(multi-display): support other displays
8575                    final DisplayContent displayContent = getDefaultDisplayContentLocked();
8576                    final Display display = displayContent.getDisplay();
8577                    SurfaceControl surfaceControl = new SurfaceControl(mFxSession,
8578                            "thumbnail anim",
8579                            dirty.width(), dirty.height(),
8580                            PixelFormat.TRANSLUCENT, SurfaceControl.HIDDEN);
8581                    surfaceControl.setLayerStack(display.getLayerStack());
8582                    appAnimator.thumbnail = surfaceControl;
8583                    if (SHOW_TRANSACTIONS) Slog.i(TAG, "  THUMBNAIL " + surfaceControl + ": CREATE");
8584                    Surface drawSurface = new Surface();
8585                    drawSurface.copyFrom(surfaceControl);
8586                    Canvas c = drawSurface.lockCanvas(dirty);
8587                    c.drawBitmap(nextAppTransitionThumbnail, 0, 0, null);
8588                    drawSurface.unlockCanvasAndPost(c);
8589                    drawSurface.release();
8590                    appAnimator.thumbnailLayer = topOpeningLayer;
8591                    DisplayInfo displayInfo = getDefaultDisplayInfoLocked();
8592                    Animation anim = mAppTransition.createThumbnailAnimationLocked(
8593                            transit, true, true, displayInfo.appWidth, displayInfo.appHeight);
8594                    appAnimator.thumbnailAnimation = anim;
8595                    anim.restrictDuration(MAX_ANIMATION_DURATION);
8596                    anim.scaleCurrentDuration(mTransitionAnimationScale);
8597                    Point p = new Point();
8598                    mAppTransition.getStartingPoint(p);
8599                    appAnimator.thumbnailX = p.x;
8600                    appAnimator.thumbnailY = p.y;
8601                } catch (OutOfResourcesException e) {
8602                    Slog.e(TAG, "Can't allocate thumbnail/Canvas surface w=" + dirty.width()
8603                            + " h=" + dirty.height(), e);
8604                    appAnimator.clearThumbnail();
8605                }
8606            }
8607
8608            mAppTransition.postAnimationCallback();
8609            mAppTransition.clear();
8610
8611            mOpeningApps.clear();
8612            mClosingApps.clear();
8613
8614            // This has changed the visibility of windows, so perform
8615            // a new layout to get them all up-to-date.
8616            changes |= WindowManagerPolicy.FINISH_LAYOUT_REDO_LAYOUT
8617                    | WindowManagerPolicy.FINISH_LAYOUT_REDO_CONFIG;
8618            getDefaultDisplayContentLocked().layoutNeeded = true;
8619
8620            // TODO(multidisplay): IMEs are only supported on the default display.
8621            if (windows == getDefaultWindowListLocked()
8622                    && !moveInputMethodWindowsIfNeededLocked(true)) {
8623                assignLayersLocked(windows);
8624            }
8625            updateFocusedWindowLocked(UPDATE_FOCUS_PLACING_SURFACES, false /*updateInputWindows*/);
8626            mFocusMayChange = false;
8627        }
8628
8629        return changes;
8630    }
8631
8632    /**
8633     * Extracted from {@link #performLayoutAndPlaceSurfacesLockedInner} to reduce size of method.
8634     * @return bitmap indicating if another pass through layout must be made.
8635     */
8636    private int handleAnimatingStoppedAndTransitionLocked() {
8637        int changes = 0;
8638
8639        mAppTransition.setIdle();
8640        // Restore window app tokens to the ActivityManager views
8641        final DisplayContent displayContent = getDefaultDisplayContentLocked();
8642        final ArrayList<Task> tasks = displayContent.getTasks();
8643        final int numTasks = tasks.size();
8644        for (int taskNdx = 0; taskNdx < numTasks; ++taskNdx) {
8645            final AppTokenList tokens = tasks.get(taskNdx).mAppTokens;
8646            final int numTokens = tokens.size();
8647            for (int tokenNdx = 0; tokenNdx < numTokens; ++tokenNdx) {
8648                final AppWindowToken wtoken = tokens.get(tokenNdx);
8649                wtoken.sendingToBottom = false;
8650            }
8651        }
8652        rebuildAppWindowListLocked();
8653
8654        changes |= PhoneWindowManager.FINISH_LAYOUT_REDO_LAYOUT;
8655        if (DEBUG_WALLPAPER_LIGHT) Slog.v(TAG,
8656                "Wallpaper layer changed: assigning layers + relayout");
8657        moveInputMethodWindowsIfNeededLocked(true);
8658        mInnerFields.mWallpaperMayChange = true;
8659        // Since the window list has been rebuilt, focus might
8660        // have to be recomputed since the actual order of windows
8661        // might have changed again.
8662        mFocusMayChange = true;
8663
8664        return changes;
8665    }
8666
8667    private void updateResizingWindows(final WindowState w) {
8668        final WindowStateAnimator winAnimator = w.mWinAnimator;
8669        if (w.mHasSurface && w.mLayoutSeq == mLayoutSeq) {
8670            w.setInsetsChanged();
8671            boolean configChanged = w.isConfigChanged();
8672            if (DEBUG_CONFIGURATION && configChanged) {
8673                Slog.v(TAG, "Win " + w + " config changed: "
8674                        + mCurConfiguration);
8675            }
8676            if (localLOGV) Slog.v(TAG, "Resizing " + w
8677                    + ": configChanged=" + configChanged
8678                    + " last=" + w.mLastFrame + " frame=" + w.mFrame);
8679            w.mLastFrame.set(w.mFrame);
8680            if (w.mContentInsetsChanged
8681                    || w.mVisibleInsetsChanged
8682                    || winAnimator.mSurfaceResized
8683                    || configChanged) {
8684                if (DEBUG_RESIZE || DEBUG_ORIENTATION) {
8685                    Slog.v(TAG, "Resize reasons for w=" + w + ": "
8686                            + " contentInsetsChanged=" + w.mContentInsetsChanged
8687                            + " " + w.mContentInsets.toShortString()
8688                            + " visibleInsetsChanged=" + w.mVisibleInsetsChanged
8689                            + " " + w.mVisibleInsets.toShortString()
8690                            + " surfaceResized=" + winAnimator.mSurfaceResized
8691                            + " configChanged=" + configChanged);
8692                }
8693
8694                w.mLastOverscanInsets.set(w.mOverscanInsets);
8695                w.mLastContentInsets.set(w.mContentInsets);
8696                w.mLastVisibleInsets.set(w.mVisibleInsets);
8697                makeWindowFreezingScreenIfNeededLocked(w);
8698                // If the orientation is changing, then we need to
8699                // hold off on unfreezing the display until this
8700                // window has been redrawn; to do that, we need
8701                // to go through the process of getting informed
8702                // by the application when it has finished drawing.
8703                if (w.mOrientationChanging) {
8704                    if (DEBUG_SURFACE_TRACE || DEBUG_ANIM || DEBUG_ORIENTATION) Slog.v(TAG,
8705                            "Orientation start waiting for draw mDrawState=DRAW_PENDING in "
8706                            + w + ", surface " + winAnimator.mSurfaceControl);
8707                    winAnimator.mDrawState = WindowStateAnimator.DRAW_PENDING;
8708                    if (w.mAppToken != null) {
8709                        w.mAppToken.allDrawn = false;
8710                        w.mAppToken.deferClearAllDrawn = false;
8711                    }
8712                }
8713                if (!mResizingWindows.contains(w)) {
8714                    if (DEBUG_RESIZE || DEBUG_ORIENTATION) Slog.v(TAG,
8715                            "Resizing window " + w + " to " + winAnimator.mSurfaceW
8716                            + "x" + winAnimator.mSurfaceH);
8717                    mResizingWindows.add(w);
8718                }
8719            } else if (w.mOrientationChanging) {
8720                if (w.isDrawnLw()) {
8721                    if (DEBUG_ORIENTATION) Slog.v(TAG,
8722                            "Orientation not waiting for draw in "
8723                            + w + ", surface " + winAnimator.mSurfaceControl);
8724                    w.mOrientationChanging = false;
8725                    w.mLastFreezeDuration = (int)(SystemClock.elapsedRealtime()
8726                            - mDisplayFreezeTime);
8727                }
8728            }
8729        }
8730    }
8731
8732    /**
8733     * Extracted from {@link #performLayoutAndPlaceSurfacesLockedInner} to reduce size of method.
8734     *
8735     * @param w WindowState this method is applied to.
8736     * @param currentTime The time which animations use for calculating transitions.
8737     * @param innerDw Width of app window.
8738     * @param innerDh Height of app window.
8739     */
8740    private void handleNotObscuredLocked(final WindowState w, final long currentTime,
8741                                         final int innerDw, final int innerDh) {
8742        final WindowManager.LayoutParams attrs = w.mAttrs;
8743        final int attrFlags = attrs.flags;
8744        final boolean canBeSeen = w.isDisplayedLw();
8745        final boolean opaqueDrawn = canBeSeen && w.isOpaqueDrawn();
8746
8747        if (opaqueDrawn && w.isFullscreen(innerDw, innerDh)) {
8748            // This window completely covers everything behind it,
8749            // so we want to leave all of them as undimmed (for
8750            // performance reasons).
8751            mInnerFields.mObscured = true;
8752        }
8753
8754        if (w.mHasSurface) {
8755            if ((attrFlags&FLAG_KEEP_SCREEN_ON) != 0) {
8756                mInnerFields.mHoldScreen = w.mSession;
8757            }
8758            if (!mInnerFields.mSyswin && w.mAttrs.screenBrightness >= 0
8759                    && mInnerFields.mScreenBrightness < 0) {
8760                mInnerFields.mScreenBrightness = w.mAttrs.screenBrightness;
8761            }
8762            if (!mInnerFields.mSyswin && w.mAttrs.buttonBrightness >= 0
8763                    && mInnerFields.mButtonBrightness < 0) {
8764                mInnerFields.mButtonBrightness = w.mAttrs.buttonBrightness;
8765            }
8766            if (!mInnerFields.mSyswin && w.mAttrs.userActivityTimeout >= 0
8767                    && mInnerFields.mUserActivityTimeout < 0) {
8768                mInnerFields.mUserActivityTimeout = w.mAttrs.userActivityTimeout;
8769            }
8770
8771            final int type = attrs.type;
8772            if (canBeSeen
8773                    && (type == TYPE_SYSTEM_DIALOG
8774                     || type == TYPE_RECENTS_OVERLAY
8775                     || type == TYPE_KEYGUARD
8776                     || type == TYPE_SYSTEM_ERROR)) {
8777                mInnerFields.mSyswin = true;
8778            }
8779
8780            if (canBeSeen) {
8781                // This function assumes that the contents of the default display are
8782                // processed first before secondary displays.
8783                final DisplayContent displayContent = w.mDisplayContent;
8784                if (displayContent.isDefaultDisplay) {
8785                    // While a dream or keyguard is showing, obscure ordinary application
8786                    // content on secondary displays (by forcibly enabling mirroring unless
8787                    // there is other content we want to show) but still allow opaque
8788                    // keyguard dialogs to be shown.
8789                    if (type == TYPE_DREAM || type == TYPE_KEYGUARD) {
8790                        mInnerFields.mObscureApplicationContentOnSecondaryDisplays = true;
8791                    }
8792                    mInnerFields.mDisplayHasContent = true;
8793                } else if (!mInnerFields.mObscureApplicationContentOnSecondaryDisplays
8794                        || (mInnerFields.mObscured && type == TYPE_KEYGUARD_DIALOG)) {
8795                    // Allow full screen keyguard presentation dialogs to be seen.
8796                    mInnerFields.mDisplayHasContent = true;
8797                }
8798            }
8799        }
8800    }
8801
8802    private void handleFlagDimBehind(WindowState w, int innerDw, int innerDh) {
8803        final WindowManager.LayoutParams attrs = w.mAttrs;
8804        if ((attrs.flags & FLAG_DIM_BEHIND) != 0
8805                && w.isDisplayedLw()
8806                && !w.mExiting) {
8807            final WindowStateAnimator winAnimator = w.mWinAnimator;
8808            final TaskStack stack = w.getStack();
8809            stack.setDimmingTag();
8810            if (!stack.isDimming(winAnimator)) {
8811                if (localLOGV) Slog.v(TAG, "Win " + w + " start dimming.");
8812                stack.startDimmingIfNeeded(winAnimator);
8813            }
8814        }
8815    }
8816
8817    private void updateAllDrawnLocked(DisplayContent displayContent) {
8818        // See if any windows have been drawn, so they (and others
8819        // associated with them) can now be shown.
8820        final ArrayList<Task> tasks = displayContent.getTasks();
8821        final int numTasks = tasks.size();
8822        for (int taskNdx = 0; taskNdx < numTasks; ++taskNdx) {
8823            final AppTokenList tokens = tasks.get(taskNdx).mAppTokens;
8824            final int numTokens = tokens.size();
8825            for (int tokenNdx = 0; tokenNdx < numTokens; ++tokenNdx) {
8826                final AppWindowToken wtoken = tokens.get(tokenNdx);
8827                if (!wtoken.allDrawn) {
8828                    int numInteresting = wtoken.numInterestingWindows;
8829                    if (numInteresting > 0 && wtoken.numDrawnWindows >= numInteresting) {
8830                        if (DEBUG_VISIBILITY) Slog.v(TAG,
8831                                "allDrawn: " + wtoken
8832                                + " interesting=" + numInteresting
8833                                + " drawn=" + wtoken.numDrawnWindows);
8834                        wtoken.allDrawn = true;
8835                        mH.obtainMessage(H.NOTIFY_ACTIVITY_DRAWN, wtoken.token).sendToTarget();
8836                    }
8837                }
8838            }
8839        }
8840    }
8841
8842    // "Something has changed!  Let's make it correct now."
8843    private final void performLayoutAndPlaceSurfacesLockedInner(boolean recoveringMemory) {
8844        if (DEBUG_WINDOW_TRACE) {
8845            Slog.v(TAG, "performLayoutAndPlaceSurfacesLockedInner: entry. Called by "
8846                    + Debug.getCallers(3));
8847        }
8848
8849        final long currentTime = SystemClock.uptimeMillis();
8850
8851        int i;
8852
8853        if (mFocusMayChange) {
8854            mFocusMayChange = false;
8855            updateFocusedWindowLocked(UPDATE_FOCUS_WILL_PLACE_SURFACES,
8856                    false /*updateInputWindows*/);
8857        }
8858
8859        // Initialize state of exiting tokens.
8860        final int numDisplays = mDisplayContents.size();
8861        for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) {
8862            final DisplayContent displayContent = mDisplayContents.valueAt(displayNdx);
8863            for (i=displayContent.mExitingTokens.size()-1; i>=0; i--) {
8864                displayContent.mExitingTokens.get(i).hasVisible = false;
8865            }
8866
8867            // Initialize state of exiting applications.
8868            for (i=displayContent.mExitingAppTokens.size()-1; i>=0; i--) {
8869                displayContent.mExitingAppTokens.get(i).hasVisible = false;
8870            }
8871        }
8872
8873        mInnerFields.mHoldScreen = null;
8874        mInnerFields.mScreenBrightness = -1;
8875        mInnerFields.mButtonBrightness = -1;
8876        mInnerFields.mUserActivityTimeout = -1;
8877        mInnerFields.mObscureApplicationContentOnSecondaryDisplays = false;
8878
8879        mTransactionSequence++;
8880
8881        final DisplayContent defaultDisplay = getDefaultDisplayContentLocked();
8882        final DisplayInfo defaultInfo = defaultDisplay.getDisplayInfo();
8883        final int defaultDw = defaultInfo.logicalWidth;
8884        final int defaultDh = defaultInfo.logicalHeight;
8885
8886        if (SHOW_LIGHT_TRANSACTIONS) Slog.i(TAG,
8887                ">>> OPEN TRANSACTION performLayoutAndPlaceSurfaces");
8888        SurfaceControl.openTransaction();
8889        try {
8890
8891            if (mWatermark != null) {
8892                mWatermark.positionSurface(defaultDw, defaultDh);
8893            }
8894            if (mStrictModeFlash != null) {
8895                mStrictModeFlash.positionSurface(defaultDw, defaultDh);
8896            }
8897
8898            boolean focusDisplayed = false;
8899
8900            for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) {
8901                final DisplayContent displayContent = mDisplayContents.valueAt(displayNdx);
8902                boolean updateAllDrawn = false;
8903                WindowList windows = displayContent.getWindowList();
8904                DisplayInfo displayInfo = displayContent.getDisplayInfo();
8905                final int displayId = displayContent.getDisplayId();
8906                final int dw = displayInfo.logicalWidth;
8907                final int dh = displayInfo.logicalHeight;
8908                final int innerDw = displayInfo.appWidth;
8909                final int innerDh = displayInfo.appHeight;
8910                final boolean isDefaultDisplay = (displayId == Display.DEFAULT_DISPLAY);
8911
8912                // Reset for each display.
8913                mInnerFields.mDisplayHasContent = false;
8914
8915                int repeats = 0;
8916                do {
8917                    repeats++;
8918                    if (repeats > 6) {
8919                        Slog.w(TAG, "Animation repeat aborted after too many iterations");
8920                        displayContent.layoutNeeded = false;
8921                        break;
8922                    }
8923
8924                    if (DEBUG_LAYOUT_REPEATS) debugLayoutRepeats("On entry to LockedInner",
8925                        displayContent.pendingLayoutChanges);
8926
8927                    if ((displayContent.pendingLayoutChanges &
8928                            WindowManagerPolicy.FINISH_LAYOUT_REDO_WALLPAPER) != 0 &&
8929                            (adjustWallpaperWindowsLocked() &
8930                                    ADJUST_WALLPAPER_LAYERS_CHANGED) != 0) {
8931                        assignLayersLocked(windows);
8932                        displayContent.layoutNeeded = true;
8933                    }
8934
8935                    if (isDefaultDisplay && (displayContent.pendingLayoutChanges
8936                            & WindowManagerPolicy.FINISH_LAYOUT_REDO_CONFIG) != 0) {
8937                        if (DEBUG_LAYOUT) Slog.v(TAG, "Computing new config from layout");
8938                        if (updateOrientationFromAppTokensLocked(true)) {
8939                            displayContent.layoutNeeded = true;
8940                            mH.sendEmptyMessage(H.SEND_NEW_CONFIGURATION);
8941                        }
8942                    }
8943
8944                    if ((displayContent.pendingLayoutChanges
8945                            & WindowManagerPolicy.FINISH_LAYOUT_REDO_LAYOUT) != 0) {
8946                        displayContent.layoutNeeded = true;
8947                    }
8948
8949                    // FIRST LOOP: Perform a layout, if needed.
8950                    if (repeats < 4) {
8951                        performLayoutLockedInner(displayContent, repeats == 1,
8952                                false /*updateInputWindows*/);
8953                    } else {
8954                        Slog.w(TAG, "Layout repeat skipped after too many iterations");
8955                    }
8956
8957                    // FIRST AND ONE HALF LOOP: Make WindowManagerPolicy think
8958                    // it is animating.
8959                    displayContent.pendingLayoutChanges = 0;
8960
8961                    if (DEBUG_LAYOUT_REPEATS) debugLayoutRepeats("loop number "
8962                            + mLayoutRepeatCount, displayContent.pendingLayoutChanges);
8963
8964                    if (isDefaultDisplay) {
8965                        mPolicy.beginPostLayoutPolicyLw(dw, dh);
8966                        for (i = windows.size() - 1; i >= 0; i--) {
8967                            WindowState w = windows.get(i);
8968                            if (w.mHasSurface) {
8969                                mPolicy.applyPostLayoutPolicyLw(w, w.mAttrs);
8970                            }
8971                        }
8972                        displayContent.pendingLayoutChanges |= mPolicy.finishPostLayoutPolicyLw();
8973                        if (DEBUG_LAYOUT_REPEATS) debugLayoutRepeats(
8974                            "after finishPostLayoutPolicyLw", displayContent.pendingLayoutChanges);
8975                    }
8976                } while (displayContent.pendingLayoutChanges != 0);
8977
8978                mInnerFields.mObscured = false;
8979                mInnerFields.mSyswin = false;
8980                displayContent.resetDimming();
8981
8982                // Only used if default window
8983                final boolean someoneLosingFocus = !mLosingFocus.isEmpty();
8984
8985                final int N = windows.size();
8986                for (i=N-1; i>=0; i--) {
8987                    WindowState w = windows.get(i);
8988                    final TaskStack stack = w.getStack();
8989                    if (stack == null) {
8990                        continue;
8991                    }
8992
8993                    final boolean obscuredChanged = w.mObscured != mInnerFields.mObscured;
8994
8995                    // Update effect.
8996                    w.mObscured = mInnerFields.mObscured;
8997                    if (!mInnerFields.mObscured) {
8998                        handleNotObscuredLocked(w, currentTime, innerDw, innerDh);
8999                    }
9000
9001                    if (!stack.testDimmingTag()) {
9002                        handleFlagDimBehind(w, innerDw, innerDh);
9003                    }
9004
9005                    if (isDefaultDisplay && obscuredChanged && (mWallpaperTarget == w)
9006                            && w.isVisibleLw()) {
9007                        // This is the wallpaper target and its obscured state
9008                        // changed... make sure the current wallaper's visibility
9009                        // has been updated accordingly.
9010                        updateWallpaperVisibilityLocked();
9011                    }
9012
9013                    final WindowStateAnimator winAnimator = w.mWinAnimator;
9014
9015                    // If the window has moved due to its containing
9016                    // content frame changing, then we'd like to animate
9017                    // it.
9018                    if (w.mHasSurface && w.shouldAnimateMove()) {
9019                        // Frame has moved, containing content frame
9020                        // has also moved, and we're not currently animating...
9021                        // let's do something.
9022                        Animation a = AnimationUtils.loadAnimation(mContext,
9023                                com.android.internal.R.anim.window_move_from_decor);
9024                        winAnimator.setAnimation(a);
9025                        winAnimator.mAnimDw = w.mLastFrame.left - w.mFrame.left;
9026                        winAnimator.mAnimDh = w.mLastFrame.top - w.mFrame.top;
9027                        try {
9028                            w.mClient.moved(w.mFrame.left, w.mFrame.top);
9029                        } catch (RemoteException e) {
9030                        }
9031                    }
9032
9033                    //Slog.i(TAG, "Window " + this + " clearing mContentChanged - done placing");
9034                    w.mContentChanged = false;
9035
9036                    // Moved from updateWindowsAndWallpaperLocked().
9037                    if (w.mHasSurface) {
9038                        // Take care of the window being ready to display.
9039                        final boolean committed =
9040                                winAnimator.commitFinishDrawingLocked(currentTime);
9041                        if (isDefaultDisplay && committed) {
9042                            if (w.mAttrs.type == TYPE_DREAM) {
9043                                // HACK: When a dream is shown, it may at that
9044                                // point hide the lock screen.  So we need to
9045                                // redo the layout to let the phone window manager
9046                                // make this happen.
9047                                displayContent.pendingLayoutChanges |=
9048                                        WindowManagerPolicy.FINISH_LAYOUT_REDO_LAYOUT;
9049                                if (DEBUG_LAYOUT_REPEATS) {
9050                                    debugLayoutRepeats(
9051                                        "dream and commitFinishDrawingLocked true",
9052                                        displayContent.pendingLayoutChanges);
9053                                }
9054                            }
9055                            if ((w.mAttrs.flags & FLAG_SHOW_WALLPAPER) != 0) {
9056                                if (DEBUG_WALLPAPER_LIGHT) Slog.v(TAG,
9057                                        "First draw done in potential wallpaper target " + w);
9058                                mInnerFields.mWallpaperMayChange = true;
9059                                displayContent.pendingLayoutChanges |=
9060                                        WindowManagerPolicy.FINISH_LAYOUT_REDO_WALLPAPER;
9061                                if (DEBUG_LAYOUT_REPEATS) {
9062                                    debugLayoutRepeats(
9063                                        "wallpaper and commitFinishDrawingLocked true",
9064                                        displayContent.pendingLayoutChanges);
9065                                }
9066                            }
9067                        }
9068
9069                        winAnimator.setSurfaceBoundariesLocked(recoveringMemory);
9070
9071                        final AppWindowToken atoken = w.mAppToken;
9072                        if (DEBUG_STARTING_WINDOW && atoken != null
9073                                && w == atoken.startingWindow) {
9074                            Slog.d(TAG, "updateWindows: starting " + w + " isOnScreen="
9075                                + w.isOnScreen() + " allDrawn=" + atoken.allDrawn
9076                                + " freezingScreen=" + atoken.mAppAnimator.freezingScreen);
9077                        }
9078                        if (atoken != null
9079                                && (!atoken.allDrawn || atoken.mAppAnimator.freezingScreen)) {
9080                            if (atoken.lastTransactionSequence != mTransactionSequence) {
9081                                atoken.lastTransactionSequence = mTransactionSequence;
9082                                atoken.numInterestingWindows = atoken.numDrawnWindows = 0;
9083                                atoken.startingDisplayed = false;
9084                            }
9085                            if ((w.isOnScreen() || winAnimator.mAttrType == TYPE_BASE_APPLICATION)
9086                                    && !w.mExiting && !w.mDestroying) {
9087                                if (DEBUG_VISIBILITY || DEBUG_ORIENTATION) {
9088                                    Slog.v(TAG, "Eval win " + w + ": isDrawn=" + w.isDrawnLw()
9089                                            + ", isAnimating=" + winAnimator.isAnimating());
9090                                    if (!w.isDrawnLw()) {
9091                                        Slog.v(TAG, "Not displayed: s=" + winAnimator.mSurfaceControl
9092                                                + " pv=" + w.mPolicyVisibility
9093                                                + " mDrawState=" + winAnimator.mDrawState
9094                                                + " ah=" + w.mAttachedHidden
9095                                                + " th=" + atoken.hiddenRequested
9096                                                + " a=" + winAnimator.mAnimating);
9097                                    }
9098                                }
9099                                if (w != atoken.startingWindow) {
9100                                    if (!atoken.mAppAnimator.freezingScreen || !w.mAppFreezing) {
9101                                        atoken.numInterestingWindows++;
9102                                        if (w.isDrawnLw()) {
9103                                            atoken.numDrawnWindows++;
9104                                            if (DEBUG_VISIBILITY || DEBUG_ORIENTATION) Slog.v(TAG,
9105                                                    "tokenMayBeDrawn: " + atoken
9106                                                    + " freezingScreen=" + atoken.mAppAnimator.freezingScreen
9107                                                    + " mAppFreezing=" + w.mAppFreezing);
9108                                            updateAllDrawn = true;
9109                                        }
9110                                    }
9111                                } else if (w.isDrawnLw()) {
9112                                    atoken.startingDisplayed = true;
9113                                }
9114                            }
9115                        }
9116                    }
9117
9118                    if (isDefaultDisplay && someoneLosingFocus && (w == mCurrentFocus)
9119                            && w.isDisplayedLw()) {
9120                        focusDisplayed = true;
9121                    }
9122
9123                    updateResizingWindows(w);
9124                }
9125
9126                mDisplayManagerService.setDisplayHasContent(displayId,
9127                        mInnerFields.mDisplayHasContent,
9128                        true /* inTraversal, must call performTraversalInTrans... below */);
9129
9130                getDisplayContentLocked(displayId).stopDimmingIfNeeded();
9131
9132                if (updateAllDrawn) {
9133                    updateAllDrawnLocked(displayContent);
9134                }
9135            }
9136
9137            if (focusDisplayed) {
9138                mH.sendEmptyMessage(H.REPORT_LOSING_FOCUS);
9139            }
9140
9141            // Give the display manager a chance to adjust properties
9142            // like display rotation if it needs to.
9143            mDisplayManagerService.performTraversalInTransactionFromWindowManager();
9144
9145        } catch (RuntimeException e) {
9146            Log.wtf(TAG, "Unhandled exception in Window Manager", e);
9147        } finally {
9148            SurfaceControl.closeTransaction();
9149            if (SHOW_LIGHT_TRANSACTIONS) Slog.i(TAG,
9150                    "<<< CLOSE TRANSACTION performLayoutAndPlaceSurfaces");
9151        }
9152
9153        final WindowList defaultWindows = defaultDisplay.getWindowList();
9154
9155        // If we are ready to perform an app transition, check through
9156        // all of the app tokens to be shown and see if they are ready
9157        // to go.
9158        if (mAppTransition.isReady()) {
9159            defaultDisplay.pendingLayoutChanges |= handleAppTransitionReadyLocked(defaultWindows);
9160            if (DEBUG_LAYOUT_REPEATS) debugLayoutRepeats("after handleAppTransitionReadyLocked",
9161                    defaultDisplay.pendingLayoutChanges);
9162        }
9163
9164        if (!mAnimator.mAnimating && mAppTransition.isRunning()) {
9165            // We have finished the animation of an app transition.  To do
9166            // this, we have delayed a lot of operations like showing and
9167            // hiding apps, moving apps in Z-order, etc.  The app token list
9168            // reflects the correct Z-order, but the window list may now
9169            // be out of sync with it.  So here we will just rebuild the
9170            // entire app window list.  Fun!
9171            defaultDisplay.pendingLayoutChanges |= handleAnimatingStoppedAndTransitionLocked();
9172            if (DEBUG_LAYOUT_REPEATS) debugLayoutRepeats("after handleAnimStopAndXitionLock",
9173                defaultDisplay.pendingLayoutChanges);
9174        }
9175
9176        if (mInnerFields.mWallpaperForceHidingChanged && defaultDisplay.pendingLayoutChanges == 0
9177                && !mAppTransition.isReady()) {
9178            // At this point, there was a window with a wallpaper that
9179            // was force hiding other windows behind it, but now it
9180            // is going away.  This may be simple -- just animate
9181            // away the wallpaper and its window -- or it may be
9182            // hard -- the wallpaper now needs to be shown behind
9183            // something that was hidden.
9184            defaultDisplay.pendingLayoutChanges |= WindowManagerPolicy.FINISH_LAYOUT_REDO_LAYOUT;
9185            if (DEBUG_LAYOUT_REPEATS) debugLayoutRepeats("after animateAwayWallpaperLocked",
9186                defaultDisplay.pendingLayoutChanges);
9187        }
9188        mInnerFields.mWallpaperForceHidingChanged = false;
9189
9190        if (mInnerFields.mWallpaperMayChange) {
9191            if (DEBUG_WALLPAPER_LIGHT) Slog.v(TAG, "Wallpaper may change!  Adjusting");
9192            defaultDisplay.pendingLayoutChanges |=
9193                    WindowManagerPolicy.FINISH_LAYOUT_REDO_WALLPAPER;
9194            if (DEBUG_LAYOUT_REPEATS) debugLayoutRepeats("WallpaperMayChange",
9195                    defaultDisplay.pendingLayoutChanges);
9196        }
9197
9198        if (mFocusMayChange) {
9199            mFocusMayChange = false;
9200            if (updateFocusedWindowLocked(UPDATE_FOCUS_PLACING_SURFACES,
9201                    false /*updateInputWindows*/)) {
9202                defaultDisplay.pendingLayoutChanges |= WindowManagerPolicy.FINISH_LAYOUT_REDO_ANIM;
9203            }
9204        }
9205
9206        if (needsLayout()) {
9207            defaultDisplay.pendingLayoutChanges |= WindowManagerPolicy.FINISH_LAYOUT_REDO_LAYOUT;
9208            if (DEBUG_LAYOUT_REPEATS) debugLayoutRepeats("mLayoutNeeded",
9209                    defaultDisplay.pendingLayoutChanges);
9210        }
9211
9212        for (i = mResizingWindows.size() - 1; i >= 0; i--) {
9213            WindowState win = mResizingWindows.get(i);
9214            if (win.mAppFreezing) {
9215                // Don't remove this window until rotation has completed.
9216                continue;
9217            }
9218            final WindowStateAnimator winAnimator = win.mWinAnimator;
9219            try {
9220                if (DEBUG_RESIZE || DEBUG_ORIENTATION) Slog.v(TAG,
9221                        "Reporting new frame to " + win + ": " + win.mCompatFrame);
9222                int diff = 0;
9223                boolean configChanged = win.isConfigChanged();
9224                if ((DEBUG_RESIZE || DEBUG_ORIENTATION || DEBUG_CONFIGURATION)
9225                        && configChanged) {
9226                    Slog.i(TAG, "Sending new config to window " + win + ": "
9227                            + winAnimator.mSurfaceW + "x" + winAnimator.mSurfaceH
9228                            + " / " + mCurConfiguration + " / 0x"
9229                            + Integer.toHexString(diff));
9230                }
9231                win.setConfiguration(mCurConfiguration);
9232                if (DEBUG_ORIENTATION &&
9233                        winAnimator.mDrawState == WindowStateAnimator.DRAW_PENDING) Slog.i(
9234                        TAG, "Resizing " + win + " WITH DRAW PENDING");
9235                final IWindow client = win.mClient;
9236                final Rect frame = win.mFrame;
9237                final Rect overscanInsets = win.mLastOverscanInsets;
9238                final Rect contentInsets = win.mLastContentInsets;
9239                final Rect visibleInsets = win.mLastVisibleInsets;
9240                final boolean reportDraw
9241                        = winAnimator.mDrawState == WindowStateAnimator.DRAW_PENDING;
9242                final Configuration newConfig = configChanged ? win.mConfiguration : null;
9243                if (win.mClient instanceof IWindow.Stub) {
9244                    // To prevent deadlock simulate one-way call if win.mClient is a local object.
9245                    mH.post(new Runnable() {
9246                        @Override
9247                        public void run() {
9248                            try {
9249                                client.resized(frame, overscanInsets, contentInsets,
9250                                        visibleInsets, reportDraw, newConfig);
9251                            } catch (RemoteException e) {
9252                                // Not a remote call, RemoteException won't be raised.
9253                            }
9254                        }
9255                    });
9256                } else {
9257                   client.resized(frame, overscanInsets, contentInsets, visibleInsets, reportDraw,
9258                           newConfig);
9259                }
9260                win.mOverscanInsetsChanged = false;
9261                win.mContentInsetsChanged = false;
9262                win.mVisibleInsetsChanged = false;
9263                winAnimator.mSurfaceResized = false;
9264            } catch (RemoteException e) {
9265                win.mOrientationChanging = false;
9266                win.mLastFreezeDuration = (int)(SystemClock.elapsedRealtime()
9267                        - mDisplayFreezeTime);
9268            }
9269            mResizingWindows.remove(i);
9270        }
9271
9272        if (DEBUG_ORIENTATION && mDisplayFrozen) Slog.v(TAG,
9273                "With display frozen, orientationChangeComplete="
9274                + mInnerFields.mOrientationChangeComplete);
9275        if (mInnerFields.mOrientationChangeComplete) {
9276            if (mWindowsFreezingScreen) {
9277                mWindowsFreezingScreen = false;
9278                mLastFinishedFreezeSource = mInnerFields.mLastWindowFreezeSource;
9279                mH.removeMessages(H.WINDOW_FREEZE_TIMEOUT);
9280            }
9281            stopFreezingDisplayLocked();
9282        }
9283
9284        // Destroy the surface of any windows that are no longer visible.
9285        boolean wallpaperDestroyed = false;
9286        i = mDestroySurface.size();
9287        if (i > 0) {
9288            do {
9289                i--;
9290                WindowState win = mDestroySurface.get(i);
9291                win.mDestroying = false;
9292                if (mInputMethodWindow == win) {
9293                    mInputMethodWindow = null;
9294                }
9295                if (win == mWallpaperTarget) {
9296                    wallpaperDestroyed = true;
9297                }
9298                win.mWinAnimator.destroySurfaceLocked();
9299            } while (i > 0);
9300            mDestroySurface.clear();
9301        }
9302
9303        // Time to remove any exiting tokens?
9304        for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) {
9305            final DisplayContent displayContent = mDisplayContents.valueAt(displayNdx);
9306            ArrayList<WindowToken> exitingTokens = displayContent.mExitingTokens;
9307            for (i = exitingTokens.size() - 1; i >= 0; i--) {
9308                WindowToken token = exitingTokens.get(i);
9309                if (!token.hasVisible) {
9310                    exitingTokens.remove(i);
9311                    if (token.windowType == TYPE_WALLPAPER) {
9312                        mWallpaperTokens.remove(token);
9313                    }
9314                }
9315            }
9316
9317            // Time to remove any exiting applications?
9318            AppTokenList exitingAppTokens = displayContent.mExitingAppTokens;
9319            for (i = exitingAppTokens.size() - 1; i >= 0; i--) {
9320                AppWindowToken token = exitingAppTokens.get(i);
9321                if (!token.hasVisible && !mClosingApps.contains(token)) {
9322                    // Make sure there is no animation running on this token,
9323                    // so any windows associated with it will be removed as
9324                    // soon as their animations are complete
9325                    token.mAppAnimator.clearAnimation();
9326                    token.mAppAnimator.animating = false;
9327                    if (DEBUG_ADD_REMOVE || DEBUG_TOKEN_MOVEMENT) Slog.v(TAG,
9328                            "performLayout: App token exiting now removed" + token);
9329                    final Task task = mTaskIdToTask.get(token.groupId);
9330                    if (task != null && task.removeAppToken(token)) {
9331                        mTaskIdToTask.delete(token.groupId);
9332                    }
9333                    exitingAppTokens.remove(i);
9334                }
9335            }
9336        }
9337
9338        if (!mAnimator.mAnimating && mRelayoutWhileAnimating.size() > 0) {
9339            for (int j=mRelayoutWhileAnimating.size()-1; j>=0; j--) {
9340                try {
9341                    mRelayoutWhileAnimating.get(j).mClient.doneAnimating();
9342                } catch (RemoteException e) {
9343                }
9344            }
9345            mRelayoutWhileAnimating.clear();
9346        }
9347
9348        if (wallpaperDestroyed) {
9349            defaultDisplay.pendingLayoutChanges |=
9350                    WindowManagerPolicy.FINISH_LAYOUT_REDO_WALLPAPER;
9351            defaultDisplay.layoutNeeded = true;
9352        }
9353
9354        for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) {
9355            final DisplayContent displayContent = mDisplayContents.valueAt(displayNdx);
9356            if (displayContent.pendingLayoutChanges != 0) {
9357                displayContent.layoutNeeded = true;
9358            }
9359        }
9360
9361        // Finally update all input windows now that the window changes have stabilized.
9362        mInputMonitor.updateInputWindowsLw(true /*force*/);
9363
9364        setHoldScreenLocked(mInnerFields.mHoldScreen);
9365        if (!mDisplayFrozen) {
9366            if (mInnerFields.mScreenBrightness < 0 || mInnerFields.mScreenBrightness > 1.0f) {
9367                mPowerManager.setScreenBrightnessOverrideFromWindowManager(-1);
9368            } else {
9369                mPowerManager.setScreenBrightnessOverrideFromWindowManager(
9370                        toBrightnessOverride(mInnerFields.mScreenBrightness));
9371            }
9372            if (mInnerFields.mButtonBrightness < 0 || mInnerFields.mButtonBrightness > 1.0f) {
9373                mPowerManager.setButtonBrightnessOverrideFromWindowManager(-1);
9374            } else {
9375                mPowerManager.setButtonBrightnessOverrideFromWindowManager(
9376                        toBrightnessOverride(mInnerFields.mButtonBrightness));
9377            }
9378            mPowerManager.setUserActivityTimeoutOverrideFromWindowManager(
9379                    mInnerFields.mUserActivityTimeout);
9380        }
9381
9382        if (mTurnOnScreen) {
9383            if (DEBUG_VISIBILITY) Slog.v(TAG, "Turning screen on after layout!");
9384            mPowerManager.wakeUp(SystemClock.uptimeMillis());
9385            mTurnOnScreen = false;
9386        }
9387
9388        if (mInnerFields.mUpdateRotation) {
9389            if (DEBUG_ORIENTATION) Slog.d(TAG, "Performing post-rotate rotation");
9390            if (updateRotationUncheckedLocked(false)) {
9391                mH.sendEmptyMessage(H.SEND_NEW_CONFIGURATION);
9392            } else {
9393                mInnerFields.mUpdateRotation = false;
9394            }
9395        }
9396
9397        if (mInnerFields.mOrientationChangeComplete && !defaultDisplay.layoutNeeded
9398                && !mInnerFields.mUpdateRotation) {
9399            checkDrawnWindowsLocked();
9400        }
9401
9402        final int N = mPendingRemove.size();
9403        if (N > 0) {
9404            if (mPendingRemoveTmp.length < N) {
9405                mPendingRemoveTmp = new WindowState[N+10];
9406            }
9407            mPendingRemove.toArray(mPendingRemoveTmp);
9408            mPendingRemove.clear();
9409            DisplayContentList displayList = new DisplayContentList();
9410            for (i = 0; i < N; i++) {
9411                WindowState w = mPendingRemoveTmp[i];
9412                removeWindowInnerLocked(w.mSession, w);
9413                if (!displayList.contains(w.mDisplayContent)) {
9414                    displayList.add(w.mDisplayContent);
9415                }
9416            }
9417
9418            for (DisplayContent displayContent : displayList) {
9419                assignLayersLocked(displayContent.getWindowList());
9420                displayContent.layoutNeeded = true;
9421            }
9422        }
9423
9424        setFocusedStackFrame();
9425
9426        // Check to see if we are now in a state where the screen should
9427        // be enabled, because the window obscured flags have changed.
9428        enableScreenIfNeededLocked();
9429
9430        scheduleAnimationLocked();
9431
9432        if (DEBUG_WINDOW_TRACE) {
9433            Slog.e(TAG, "performLayoutAndPlaceSurfacesLockedInner exit: animating="
9434                    + mAnimator.mAnimating);
9435        }
9436    }
9437
9438    private int toBrightnessOverride(float value) {
9439        return (int)(value * PowerManager.BRIGHTNESS_ON);
9440    }
9441
9442    void checkDrawnWindowsLocked() {
9443        if (mWaitingForDrawn.size() > 0) {
9444            for (int j=mWaitingForDrawn.size()-1; j>=0; j--) {
9445                Pair<WindowState, IRemoteCallback> pair = mWaitingForDrawn.get(j);
9446                WindowState win = pair.first;
9447                //Slog.i(TAG, "Waiting for drawn " + win + ": removed="
9448                //        + win.mRemoved + " visible=" + win.isVisibleLw()
9449                //        + " shown=" + win.mSurfaceShown);
9450                if (win.mRemoved) {
9451                    // Window has been removed; no draw will now happen, so stop waiting.
9452                    Slog.w(TAG, "Aborted waiting for drawn: " + pair.first);
9453                    try {
9454                        pair.second.sendResult(null);
9455                    } catch (RemoteException e) {
9456                    }
9457                    mWaitingForDrawn.remove(pair);
9458                    mH.removeMessages(H.WAITING_FOR_DRAWN_TIMEOUT, pair);
9459                } else if (win.mWinAnimator.mSurfaceShown) {
9460                    // Window is now drawn (and shown).
9461                    try {
9462                        pair.second.sendResult(null);
9463                    } catch (RemoteException e) {
9464                    }
9465                    mWaitingForDrawn.remove(pair);
9466                    mH.removeMessages(H.WAITING_FOR_DRAWN_TIMEOUT, pair);
9467                }
9468            }
9469        }
9470    }
9471
9472    @Override
9473    public boolean waitForWindowDrawn(IBinder token, IRemoteCallback callback) {
9474        if (token != null && callback != null) {
9475            synchronized (mWindowMap) {
9476                WindowState win = windowForClientLocked(null, token, true);
9477                if (win != null) {
9478                    Pair<WindowState, IRemoteCallback> pair =
9479                            new Pair<WindowState, IRemoteCallback>(win, callback);
9480                    Message m = mH.obtainMessage(H.WAITING_FOR_DRAWN_TIMEOUT, pair);
9481                    mH.sendMessageDelayed(m, 2000);
9482                    mWaitingForDrawn.add(pair);
9483                    checkDrawnWindowsLocked();
9484                    return true;
9485                }
9486                Slog.i(TAG, "waitForWindowDrawn: win null");
9487            }
9488        }
9489        return false;
9490    }
9491
9492    void setHoldScreenLocked(final Session newHoldScreen) {
9493        final boolean hold = newHoldScreen != null;
9494
9495        if (hold && mHoldingScreenOn != newHoldScreen) {
9496            mHoldingScreenWakeLock.setWorkSource(new WorkSource(newHoldScreen.mUid));
9497        }
9498        mHoldingScreenOn = newHoldScreen;
9499
9500        final boolean state = mHoldingScreenWakeLock.isHeld();
9501        if (hold != state) {
9502            if (hold) {
9503                mHoldingScreenWakeLock.acquire();
9504                mPolicy.keepScreenOnStartedLw();
9505            } else {
9506                mPolicy.keepScreenOnStoppedLw();
9507                mHoldingScreenWakeLock.release();
9508            }
9509        }
9510    }
9511
9512    @Override
9513    public void requestTraversal() {
9514        synchronized (mWindowMap) {
9515            requestTraversalLocked();
9516        }
9517    }
9518
9519    void requestTraversalLocked() {
9520        if (!mTraversalScheduled) {
9521            mTraversalScheduled = true;
9522            mH.sendEmptyMessage(H.DO_TRAVERSAL);
9523        }
9524    }
9525
9526    /** Note that Locked in this case is on mLayoutToAnim */
9527    void scheduleAnimationLocked() {
9528        if (!mAnimationScheduled) {
9529            mAnimationScheduled = true;
9530            mChoreographer.postCallback(
9531                    Choreographer.CALLBACK_ANIMATION, mAnimator.mAnimationRunnable, null);
9532        }
9533    }
9534
9535    private boolean needsLayout() {
9536        final int numDisplays = mDisplayContents.size();
9537        for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) {
9538            final DisplayContent displayContent = mDisplayContents.valueAt(displayNdx);
9539            if (displayContent.layoutNeeded) {
9540                return true;
9541            }
9542        }
9543        return false;
9544    }
9545
9546    boolean copyAnimToLayoutParamsLocked() {
9547        boolean doRequest = false;
9548
9549        final int bulkUpdateParams = mAnimator.mBulkUpdateParams;
9550        if ((bulkUpdateParams & LayoutFields.SET_UPDATE_ROTATION) != 0) {
9551            mInnerFields.mUpdateRotation = true;
9552            doRequest = true;
9553        }
9554        if ((bulkUpdateParams & LayoutFields.SET_WALLPAPER_MAY_CHANGE) != 0) {
9555            mInnerFields.mWallpaperMayChange = true;
9556            doRequest = true;
9557        }
9558        if ((bulkUpdateParams & LayoutFields.SET_FORCE_HIDING_CHANGED) != 0) {
9559            mInnerFields.mWallpaperForceHidingChanged = true;
9560            doRequest = true;
9561        }
9562        if ((bulkUpdateParams & LayoutFields.SET_ORIENTATION_CHANGE_COMPLETE) == 0) {
9563            mInnerFields.mOrientationChangeComplete = false;
9564        } else {
9565            mInnerFields.mOrientationChangeComplete = true;
9566            mInnerFields.mLastWindowFreezeSource = mAnimator.mLastWindowFreezeSource;
9567            if (mWindowsFreezingScreen) {
9568                doRequest = true;
9569            }
9570        }
9571        if ((bulkUpdateParams & LayoutFields.SET_TURN_ON_SCREEN) != 0) {
9572            mTurnOnScreen = true;
9573        }
9574        if ((bulkUpdateParams & LayoutFields.SET_WALLPAPER_ACTION_PENDING) != 0) {
9575            mInnerFields.mWallpaperActionPending = true;
9576        }
9577
9578        return doRequest;
9579    }
9580
9581    /** If a window that has an animation specifying a colored background and the current wallpaper
9582     * is visible, then the color goes *below* the wallpaper so we don't cause the wallpaper to
9583     * suddenly disappear. */
9584    int adjustAnimationBackground(WindowStateAnimator winAnimator) {
9585        WindowList windows = winAnimator.mWin.getWindowList();
9586        for (int i = windows.size() - 1; i >= 0; --i) {
9587            WindowState testWin = windows.get(i);
9588            if (testWin.mIsWallpaper && testWin.isVisibleNow()) {
9589                return testWin.mWinAnimator.mAnimLayer;
9590            }
9591        }
9592        return winAnimator.mAnimLayer;
9593    }
9594
9595    boolean reclaimSomeSurfaceMemoryLocked(WindowStateAnimator winAnimator, String operation,
9596                                           boolean secure) {
9597        final SurfaceControl surface = winAnimator.mSurfaceControl;
9598        boolean leakedSurface = false;
9599        boolean killedApps = false;
9600
9601        EventLog.writeEvent(EventLogTags.WM_NO_SURFACE_MEMORY, winAnimator.mWin.toString(),
9602                winAnimator.mSession.mPid, operation);
9603
9604        if (mForceRemoves == null) {
9605            mForceRemoves = new ArrayList<WindowState>();
9606        }
9607
9608        long callingIdentity = Binder.clearCallingIdentity();
9609        try {
9610            // There was some problem...   first, do a sanity check of the
9611            // window list to make sure we haven't left any dangling surfaces
9612            // around.
9613
9614            Slog.i(TAG, "Out of memory for surface!  Looking for leaks...");
9615            final int numDisplays = mDisplayContents.size();
9616            for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) {
9617                final WindowList windows = mDisplayContents.valueAt(displayNdx).getWindowList();
9618                final int numWindows = windows.size();
9619                for (int winNdx = 0; winNdx < numWindows; ++winNdx) {
9620                    final WindowState ws = windows.get(winNdx);
9621                    WindowStateAnimator wsa = ws.mWinAnimator;
9622                    if (wsa.mSurfaceControl != null) {
9623                        if (!mSessions.contains(wsa.mSession)) {
9624                            Slog.w(TAG, "LEAKED SURFACE (session doesn't exist): "
9625                                    + ws + " surface=" + wsa.mSurfaceControl
9626                                    + " token=" + ws.mToken
9627                                    + " pid=" + ws.mSession.mPid
9628                                    + " uid=" + ws.mSession.mUid);
9629                            if (SHOW_TRANSACTIONS) logSurface(ws, "LEAK DESTROY", null);
9630                            wsa.mSurfaceControl.destroy();
9631                            wsa.mSurfaceShown = false;
9632                            wsa.mSurfaceControl = null;
9633                            ws.mHasSurface = false;
9634                            mForceRemoves.add(ws);
9635                            leakedSurface = true;
9636                        } else if (ws.mAppToken != null && ws.mAppToken.clientHidden) {
9637                            Slog.w(TAG, "LEAKED SURFACE (app token hidden): "
9638                                    + ws + " surface=" + wsa.mSurfaceControl
9639                                    + " token=" + ws.mAppToken);
9640                            if (SHOW_TRANSACTIONS) logSurface(ws, "LEAK DESTROY", null);
9641                            wsa.mSurfaceControl.destroy();
9642                            wsa.mSurfaceShown = false;
9643                            wsa.mSurfaceControl = null;
9644                            ws.mHasSurface = false;
9645                            leakedSurface = true;
9646                        }
9647                    }
9648                }
9649            }
9650
9651            if (!leakedSurface) {
9652                Slog.w(TAG, "No leaked surfaces; killing applicatons!");
9653                SparseIntArray pidCandidates = new SparseIntArray();
9654                for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) {
9655                    final WindowList windows = mDisplayContents.valueAt(displayNdx).getWindowList();
9656                    final int numWindows = windows.size();
9657                    for (int winNdx = 0; winNdx < numWindows; ++winNdx) {
9658                        final WindowState ws = windows.get(winNdx);
9659                        if (mForceRemoves.contains(ws)) {
9660                            continue;
9661                        }
9662                        WindowStateAnimator wsa = ws.mWinAnimator;
9663                        if (wsa.mSurfaceControl != null) {
9664                            pidCandidates.append(wsa.mSession.mPid, wsa.mSession.mPid);
9665                        }
9666                    }
9667                    if (pidCandidates.size() > 0) {
9668                        int[] pids = new int[pidCandidates.size()];
9669                        for (int i=0; i<pids.length; i++) {
9670                            pids[i] = pidCandidates.keyAt(i);
9671                        }
9672                        try {
9673                            if (mActivityManager.killPids(pids, "Free memory", secure)) {
9674                                killedApps = true;
9675                            }
9676                        } catch (RemoteException e) {
9677                        }
9678                    }
9679                }
9680            }
9681
9682            if (leakedSurface || killedApps) {
9683                // We managed to reclaim some memory, so get rid of the trouble
9684                // surface and ask the app to request another one.
9685                Slog.w(TAG, "Looks like we have reclaimed some memory, clearing surface for retry.");
9686                if (surface != null) {
9687                    if (SHOW_TRANSACTIONS || SHOW_SURFACE_ALLOC) logSurface(winAnimator.mWin,
9688                            "RECOVER DESTROY", null);
9689                    surface.destroy();
9690                    winAnimator.mSurfaceShown = false;
9691                    winAnimator.mSurfaceControl = null;
9692                    winAnimator.mWin.mHasSurface = false;
9693                    scheduleRemoveStartingWindow(winAnimator.mWin.mAppToken);
9694                }
9695
9696                try {
9697                    winAnimator.mWin.mClient.dispatchGetNewSurface();
9698                } catch (RemoteException e) {
9699                }
9700            }
9701        } finally {
9702            Binder.restoreCallingIdentity(callingIdentity);
9703        }
9704
9705        return leakedSurface || killedApps;
9706    }
9707
9708    private boolean updateFocusedWindowLocked(int mode, boolean updateInputWindows) {
9709        WindowState newFocus = computeFocusedWindowLocked();
9710        if (mCurrentFocus != newFocus) {
9711            Trace.traceBegin(Trace.TRACE_TAG_WINDOW_MANAGER, "wmUpdateFocus");
9712            // This check makes sure that we don't already have the focus
9713            // change message pending.
9714            mH.removeMessages(H.REPORT_FOCUS_CHANGE);
9715            mH.sendEmptyMessage(H.REPORT_FOCUS_CHANGE);
9716            // TODO(multidisplay): Focused windows on default display only.
9717            final DisplayContent displayContent = getDefaultDisplayContentLocked();
9718            final boolean imWindowChanged = moveInputMethodWindowsIfNeededLocked(
9719                    mode != UPDATE_FOCUS_WILL_ASSIGN_LAYERS
9720                            && mode != UPDATE_FOCUS_WILL_PLACE_SURFACES);
9721            if (imWindowChanged) {
9722                displayContent.layoutNeeded = true;
9723                newFocus = computeFocusedWindowLocked();
9724            }
9725
9726            if (DEBUG_FOCUS_LIGHT || localLOGV) Slog.v(TAG, "Changing focus from " +
9727                    mCurrentFocus + " to " + newFocus + " Callers=" + Debug.getCallers(4));
9728            final WindowState oldFocus = mCurrentFocus;
9729            mCurrentFocus = newFocus;
9730            mLosingFocus.remove(newFocus);
9731            int focusChanged = mPolicy.focusChangedLw(oldFocus, newFocus);
9732
9733            if (imWindowChanged && oldFocus != mInputMethodWindow) {
9734                // Focus of the input method window changed. Perform layout if needed.
9735                if (mode == UPDATE_FOCUS_PLACING_SURFACES) {
9736                    performLayoutLockedInner(displayContent, true /*initial*/, updateInputWindows);
9737                    focusChanged &= ~WindowManagerPolicy.FINISH_LAYOUT_REDO_LAYOUT;
9738                } else if (mode == UPDATE_FOCUS_WILL_PLACE_SURFACES) {
9739                    // Client will do the layout, but we need to assign layers
9740                    // for handleNewWindowLocked() below.
9741                    assignLayersLocked(displayContent.getWindowList());
9742                }
9743            }
9744
9745            if ((focusChanged & WindowManagerPolicy.FINISH_LAYOUT_REDO_LAYOUT) != 0) {
9746                // The change in focus caused us to need to do a layout.  Okay.
9747                displayContent.layoutNeeded = true;
9748                if (mode == UPDATE_FOCUS_PLACING_SURFACES) {
9749                    performLayoutLockedInner(displayContent, true /*initial*/, updateInputWindows);
9750                }
9751            }
9752
9753            if (mode != UPDATE_FOCUS_WILL_ASSIGN_LAYERS) {
9754                // If we defer assigning layers, then the caller is responsible for
9755                // doing this part.
9756                finishUpdateFocusedWindowAfterAssignLayersLocked(updateInputWindows);
9757            }
9758
9759            Trace.traceEnd(Trace.TRACE_TAG_WINDOW_MANAGER);
9760            return true;
9761        }
9762        return false;
9763    }
9764
9765    private void finishUpdateFocusedWindowAfterAssignLayersLocked(boolean updateInputWindows) {
9766        mInputMonitor.setInputFocusLw(mCurrentFocus, updateInputWindows);
9767    }
9768
9769    private WindowState computeFocusedWindowLocked() {
9770        if (mAnimator.mUniverseBackground != null
9771                && mAnimator.mUniverseBackground.mWin.canReceiveKeys()) {
9772            return mAnimator.mUniverseBackground.mWin;
9773        }
9774
9775        final int displayCount = mDisplayContents.size();
9776        for (int i = 0; i < displayCount; i++) {
9777            final DisplayContent displayContent = mDisplayContents.valueAt(i);
9778            WindowState win = findFocusedWindowLocked(displayContent);
9779            if (win != null) {
9780                return win;
9781            }
9782        }
9783        return null;
9784    }
9785
9786    private WindowState findFocusedWindowLocked(DisplayContent displayContent) {
9787        final WindowList windows = displayContent.getWindowList();
9788        for (int i = windows.size() - 1; i >= 0; i--) {
9789            final WindowState win = windows.get(i);
9790
9791            if (localLOGV || DEBUG_FOCUS) Slog.v(
9792                TAG, "Looking for focus: " + i
9793                + " = " + win
9794                + ", flags=" + win.mAttrs.flags
9795                + ", canReceive=" + win.canReceiveKeys());
9796
9797            AppWindowToken wtoken = win.mAppToken;
9798
9799            // If this window's application has been removed, just skip it.
9800            if (wtoken != null && (wtoken.removed || wtoken.sendingToBottom)) {
9801                if (DEBUG_FOCUS) Slog.v(TAG, "Skipping " + wtoken + " because "
9802                        + (wtoken.removed ? "removed" : "sendingToBottom"));
9803                continue;
9804            }
9805
9806            if (!win.canReceiveKeys()) {
9807                continue;
9808            }
9809
9810            // Descend through all of the app tokens and find the first that either matches
9811            // win.mAppToken (return win) or mFocusedApp (return null).
9812            if (wtoken != null && win.mAttrs.type != TYPE_APPLICATION_STARTING &&
9813                    mFocusedApp != null) {
9814                ArrayList<Task> tasks = displayContent.getTasks();
9815                for (int taskNdx = tasks.size() - 1; taskNdx >= 0; --taskNdx) {
9816                    AppTokenList tokens = tasks.get(taskNdx).mAppTokens;
9817                    int tokenNdx = tokens.size() - 1;
9818                    for ( ; tokenNdx >= 0; --tokenNdx) {
9819                        final AppWindowToken token = tokens.get(tokenNdx);
9820                        if (wtoken == token) {
9821                            break;
9822                        }
9823                        if (mFocusedApp == token) {
9824                            // Whoops, we are below the focused app...  no focus for you!
9825                            if (localLOGV || DEBUG_FOCUS_LIGHT) Slog.v(TAG,
9826                                    "findFocusedWindow: Reached focused app=" + mFocusedApp);
9827                            return null;
9828                        }
9829                    }
9830                    if (tokenNdx >= 0) {
9831                        // Early exit from loop, must have found the matching token.
9832                        break;
9833                    }
9834                }
9835            }
9836
9837            if (DEBUG_FOCUS_LIGHT) Slog.v(TAG, "findFocusedWindow: Found new focus @ " + i +
9838                        " = " + win);
9839            return win;
9840        }
9841
9842        if (DEBUG_FOCUS_LIGHT) Slog.v(TAG, "findFocusedWindow: No focusable windows.");
9843        return null;
9844    }
9845
9846    private void startFreezingDisplayLocked(boolean inTransaction, int exitAnim, int enterAnim) {
9847        if (mDisplayFrozen) {
9848            return;
9849        }
9850
9851        if (!mDisplayReady || !mPolicy.isScreenOnFully()) {
9852            // No need to freeze the screen before the system is ready or if
9853            // the screen is off.
9854            return;
9855        }
9856
9857        mScreenFrozenLock.acquire();
9858
9859        mDisplayFrozen = true;
9860        mDisplayFreezeTime = SystemClock.elapsedRealtime();
9861        mLastFinishedFreezeSource = null;
9862
9863        mInputMonitor.freezeInputDispatchingLw();
9864
9865        // Clear the last input window -- that is just used for
9866        // clean transitions between IMEs, and if we are freezing
9867        // the screen then the whole world is changing behind the scenes.
9868        mPolicy.setLastInputMethodWindowLw(null, null);
9869
9870        if (mAppTransition.isTransitionSet()) {
9871            mAppTransition.freeze();
9872        }
9873
9874        if (PROFILE_ORIENTATION) {
9875            File file = new File("/data/system/frozen");
9876            Debug.startMethodTracing(file.toString(), 8 * 1024 * 1024);
9877        }
9878
9879        if (CUSTOM_SCREEN_ROTATION) {
9880            mExitAnimId = exitAnim;
9881            mEnterAnimId = enterAnim;
9882            final DisplayContent displayContent = getDefaultDisplayContentLocked();
9883            final int displayId = displayContent.getDisplayId();
9884            ScreenRotationAnimation screenRotationAnimation =
9885                    mAnimator.getScreenRotationAnimationLocked(displayId);
9886            if (screenRotationAnimation != null) {
9887                screenRotationAnimation.kill();
9888            }
9889
9890            // TODO(multidisplay): rotation on main screen only.
9891            screenRotationAnimation = new ScreenRotationAnimation(mContext, displayContent,
9892                    mFxSession, inTransaction, mPolicy.isDefaultOrientationForced());
9893            mAnimator.setScreenRotationAnimationLocked(displayId, screenRotationAnimation);
9894        }
9895    }
9896
9897    private void stopFreezingDisplayLocked() {
9898        if (!mDisplayFrozen) {
9899            return;
9900        }
9901
9902        if (mWaitingForConfig || mAppsFreezingScreen > 0 || mWindowsFreezingScreen
9903                || mClientFreezingScreen) {
9904            if (DEBUG_ORIENTATION) Slog.d(TAG,
9905                "stopFreezingDisplayLocked: Returning mWaitingForConfig=" + mWaitingForConfig
9906                + ", mAppsFreezingScreen=" + mAppsFreezingScreen
9907                + ", mWindowsFreezingScreen=" + mWindowsFreezingScreen
9908                + ", mClientFreezingScreen=" + mClientFreezingScreen);
9909            return;
9910        }
9911
9912        mDisplayFrozen = false;
9913        mLastDisplayFreezeDuration = (int)(SystemClock.elapsedRealtime() - mDisplayFreezeTime);
9914        StringBuilder sb = new StringBuilder(128);
9915        sb.append("Screen frozen for ");
9916        TimeUtils.formatDuration(mLastDisplayFreezeDuration, sb);
9917        if (mLastFinishedFreezeSource != null) {
9918            sb.append(" due to ");
9919            sb.append(mLastFinishedFreezeSource);
9920        }
9921        Slog.i(TAG, sb.toString());
9922        mH.removeMessages(H.APP_FREEZE_TIMEOUT);
9923        mH.removeMessages(H.CLIENT_FREEZE_TIMEOUT);
9924        if (PROFILE_ORIENTATION) {
9925            Debug.stopMethodTracing();
9926        }
9927
9928        boolean updateRotation = false;
9929
9930        final DisplayContent displayContent = getDefaultDisplayContentLocked();
9931        final int displayId = displayContent.getDisplayId();
9932        ScreenRotationAnimation screenRotationAnimation =
9933                mAnimator.getScreenRotationAnimationLocked(displayId);
9934        if (CUSTOM_SCREEN_ROTATION && screenRotationAnimation != null
9935                && screenRotationAnimation.hasScreenshot()) {
9936            if (DEBUG_ORIENTATION) Slog.i(TAG, "**** Dismissing screen rotation animation");
9937            // TODO(multidisplay): rotation on main screen only.
9938            DisplayInfo displayInfo = displayContent.getDisplayInfo();
9939            // Get rotation animation again, with new top window
9940            boolean isDimming = displayContent.isDimming();
9941            if (!mPolicy.validateRotationAnimationLw(mExitAnimId, mEnterAnimId, isDimming)) {
9942                mExitAnimId = mEnterAnimId = 0;
9943            }
9944            if (screenRotationAnimation.dismiss(mFxSession, MAX_ANIMATION_DURATION,
9945                    mTransitionAnimationScale, displayInfo.logicalWidth,
9946                        displayInfo.logicalHeight, mExitAnimId, mEnterAnimId)) {
9947                scheduleAnimationLocked();
9948            } else {
9949                screenRotationAnimation.kill();
9950                screenRotationAnimation = null;
9951                mAnimator.setScreenRotationAnimationLocked(displayId, screenRotationAnimation);
9952                updateRotation = true;
9953            }
9954        } else {
9955            if (screenRotationAnimation != null) {
9956                screenRotationAnimation.kill();
9957                screenRotationAnimation = null;
9958                mAnimator.setScreenRotationAnimationLocked(displayId, screenRotationAnimation);
9959            }
9960            updateRotation = true;
9961        }
9962
9963        mInputMonitor.thawInputDispatchingLw();
9964
9965        boolean configChanged;
9966
9967        // While the display is frozen we don't re-compute the orientation
9968        // to avoid inconsistent states.  However, something interesting
9969        // could have actually changed during that time so re-evaluate it
9970        // now to catch that.
9971        configChanged = updateOrientationFromAppTokensLocked(false);
9972
9973        // A little kludge: a lot could have happened while the
9974        // display was frozen, so now that we are coming back we
9975        // do a gc so that any remote references the system
9976        // processes holds on others can be released if they are
9977        // no longer needed.
9978        mH.removeMessages(H.FORCE_GC);
9979        mH.sendEmptyMessageDelayed(H.FORCE_GC, 2000);
9980
9981        mScreenFrozenLock.release();
9982
9983        if (updateRotation) {
9984            if (DEBUG_ORIENTATION) Slog.d(TAG, "Performing post-rotate rotation");
9985            configChanged |= updateRotationUncheckedLocked(false);
9986        }
9987
9988        if (configChanged) {
9989            mH.sendEmptyMessage(H.SEND_NEW_CONFIGURATION);
9990        }
9991    }
9992
9993    static int getPropertyInt(String[] tokens, int index, int defUnits, int defDps,
9994            DisplayMetrics dm) {
9995        if (index < tokens.length) {
9996            String str = tokens[index];
9997            if (str != null && str.length() > 0) {
9998                try {
9999                    int val = Integer.parseInt(str);
10000                    return val;
10001                } catch (Exception e) {
10002                }
10003            }
10004        }
10005        if (defUnits == TypedValue.COMPLEX_UNIT_PX) {
10006            return defDps;
10007        }
10008        int val = (int)TypedValue.applyDimension(defUnits, defDps, dm);
10009        return val;
10010    }
10011
10012    void createWatermarkInTransaction() {
10013        if (mWatermark != null) {
10014            return;
10015        }
10016
10017        File file = new File("/system/etc/setup.conf");
10018        FileInputStream in = null;
10019        DataInputStream ind = null;
10020        try {
10021            in = new FileInputStream(file);
10022            ind = new DataInputStream(in);
10023            String line = ind.readLine();
10024            if (line != null) {
10025                String[] toks = line.split("%");
10026                if (toks != null && toks.length > 0) {
10027                    mWatermark = new Watermark(getDefaultDisplayContentLocked().getDisplay(),
10028                            mRealDisplayMetrics, mFxSession, toks);
10029                }
10030            }
10031        } catch (FileNotFoundException e) {
10032        } catch (IOException e) {
10033        } finally {
10034            if (ind != null) {
10035                try {
10036                    ind.close();
10037                } catch (IOException e) {
10038                }
10039            } else if (in != null) {
10040                try {
10041                    in.close();
10042                } catch (IOException e) {
10043                }
10044            }
10045        }
10046    }
10047
10048    @Override
10049    public void statusBarVisibilityChanged(int visibility) {
10050        if (mContext.checkCallingOrSelfPermission(android.Manifest.permission.STATUS_BAR)
10051                != PackageManager.PERMISSION_GRANTED) {
10052            throw new SecurityException("Caller does not hold permission "
10053                    + android.Manifest.permission.STATUS_BAR);
10054        }
10055
10056        synchronized (mWindowMap) {
10057            mLastStatusBarVisibility = visibility;
10058            visibility = mPolicy.adjustSystemUiVisibilityLw(visibility);
10059            updateStatusBarVisibilityLocked(visibility);
10060        }
10061    }
10062
10063    // TOOD(multidisplay): StatusBar on multiple screens?
10064    void updateStatusBarVisibilityLocked(int visibility) {
10065        mInputManager.setSystemUiVisibility(visibility);
10066        final WindowList windows = getDefaultWindowListLocked();
10067        final int N = windows.size();
10068        for (int i = 0; i < N; i++) {
10069            WindowState ws = windows.get(i);
10070            try {
10071                int curValue = ws.mSystemUiVisibility;
10072                int diff = curValue ^ visibility;
10073                // We are only interested in differences of one of the
10074                // clearable flags...
10075                diff &= View.SYSTEM_UI_CLEARABLE_FLAGS;
10076                // ...if it has actually been cleared.
10077                diff &= ~visibility;
10078                int newValue = (curValue&~diff) | (visibility&diff);
10079                if (newValue != curValue) {
10080                    ws.mSeq++;
10081                    ws.mSystemUiVisibility = newValue;
10082                }
10083                if (newValue != curValue || ws.mAttrs.hasSystemUiListeners) {
10084                    ws.mClient.dispatchSystemUiVisibilityChanged(ws.mSeq,
10085                            visibility, newValue, diff);
10086                }
10087            } catch (RemoteException e) {
10088                // so sorry
10089            }
10090        }
10091    }
10092
10093    @Override
10094    public void reevaluateStatusBarVisibility() {
10095        synchronized (mWindowMap) {
10096            int visibility = mPolicy.adjustSystemUiVisibilityLw(mLastStatusBarVisibility);
10097            updateStatusBarVisibilityLocked(visibility);
10098            performLayoutAndPlaceSurfacesLocked();
10099        }
10100    }
10101
10102    @Override
10103    public FakeWindow addFakeWindow(Looper looper,
10104            InputEventReceiver.Factory inputEventReceiverFactory,
10105            String name, int windowType, int layoutParamsFlags, int layoutParamsPrivateFlags,
10106            boolean canReceiveKeys, boolean hasFocus, boolean touchFullscreen) {
10107        synchronized (mWindowMap) {
10108            FakeWindowImpl fw = new FakeWindowImpl(this, looper, inputEventReceiverFactory,
10109                    name, windowType,
10110                    layoutParamsFlags, layoutParamsPrivateFlags, canReceiveKeys,
10111                    hasFocus, touchFullscreen);
10112            int i=0;
10113            while (i<mFakeWindows.size()) {
10114                if (mFakeWindows.get(i).mWindowLayer <= fw.mWindowLayer) {
10115                    break;
10116                }
10117            }
10118            mFakeWindows.add(i, fw);
10119            mInputMonitor.updateInputWindowsLw(true);
10120            return fw;
10121        }
10122    }
10123
10124    boolean removeFakeWindowLocked(FakeWindow window) {
10125        synchronized (mWindowMap) {
10126            if (mFakeWindows.remove(window)) {
10127                mInputMonitor.updateInputWindowsLw(true);
10128                return true;
10129            }
10130            return false;
10131        }
10132    }
10133
10134    // It is assumed that this method is called only by InputMethodManagerService.
10135    public void saveLastInputMethodWindowForTransition() {
10136        synchronized (mWindowMap) {
10137            // TODO(multidisplay): Pass in the displayID.
10138            DisplayContent displayContent = getDefaultDisplayContentLocked();
10139            if (mInputMethodWindow != null) {
10140                mPolicy.setLastInputMethodWindowLw(mInputMethodWindow, mInputMethodTarget);
10141            }
10142        }
10143    }
10144
10145    @Override
10146    public boolean hasNavigationBar() {
10147        return mPolicy.hasNavigationBar();
10148    }
10149
10150    @Override
10151    public void lockNow(Bundle options) {
10152        mPolicy.lockNow(options);
10153    }
10154
10155    @Override
10156    public boolean isSafeModeEnabled() {
10157        return mSafeMode;
10158    }
10159
10160    void dumpPolicyLocked(PrintWriter pw, String[] args, boolean dumpAll) {
10161        pw.println("WINDOW MANAGER POLICY STATE (dumpsys window policy)");
10162        mPolicy.dump("    ", pw, args);
10163    }
10164
10165    void dumpAnimatorLocked(PrintWriter pw, String[] args, boolean dumpAll) {
10166        pw.println("WINDOW MANAGER ANIMATOR STATE (dumpsys window animator)");
10167        mAnimator.dumpLocked(pw, "    ", dumpAll);
10168    }
10169
10170    void dumpTokensLocked(PrintWriter pw, boolean dumpAll) {
10171        pw.println("WINDOW MANAGER TOKENS (dumpsys window tokens)");
10172        if (mTokenMap.size() > 0) {
10173            pw.println("  All tokens:");
10174            Iterator<WindowToken> it = mTokenMap.values().iterator();
10175            while (it.hasNext()) {
10176                WindowToken token = it.next();
10177                pw.print("  "); pw.print(token);
10178                if (dumpAll) {
10179                    pw.println(':');
10180                    token.dump(pw, "    ");
10181                } else {
10182                    pw.println();
10183                }
10184            }
10185        }
10186        if (mWallpaperTokens.size() > 0) {
10187            pw.println();
10188            pw.println("  Wallpaper tokens:");
10189            for (int i=mWallpaperTokens.size()-1; i>=0; i--) {
10190                WindowToken token = mWallpaperTokens.get(i);
10191                pw.print("  Wallpaper #"); pw.print(i);
10192                        pw.print(' '); pw.print(token);
10193                if (dumpAll) {
10194                    pw.println(':');
10195                    token.dump(pw, "    ");
10196                } else {
10197                    pw.println();
10198                }
10199            }
10200        }
10201        if (mFinishedStarting.size() > 0) {
10202            pw.println();
10203            pw.println("  Finishing start of application tokens:");
10204            for (int i=mFinishedStarting.size()-1; i>=0; i--) {
10205                WindowToken token = mFinishedStarting.get(i);
10206                pw.print("  Finished Starting #"); pw.print(i);
10207                        pw.print(' '); pw.print(token);
10208                if (dumpAll) {
10209                    pw.println(':');
10210                    token.dump(pw, "    ");
10211                } else {
10212                    pw.println();
10213                }
10214            }
10215        }
10216        if (mOpeningApps.size() > 0 || mClosingApps.size() > 0) {
10217            pw.println();
10218            if (mOpeningApps.size() > 0) {
10219                pw.print("  mOpeningApps="); pw.println(mOpeningApps);
10220            }
10221            if (mClosingApps.size() > 0) {
10222                pw.print("  mClosingApps="); pw.println(mClosingApps);
10223            }
10224        }
10225    }
10226
10227    void dumpSessionsLocked(PrintWriter pw, boolean dumpAll) {
10228        pw.println("WINDOW MANAGER SESSIONS (dumpsys window sessions)");
10229        if (mSessions.size() > 0) {
10230            Iterator<Session> it = mSessions.iterator();
10231            while (it.hasNext()) {
10232                Session s = it.next();
10233                pw.print("  Session "); pw.print(s); pw.println(':');
10234                s.dump(pw, "    ");
10235            }
10236        }
10237    }
10238
10239    void dumpDisplayContentsLocked(PrintWriter pw, boolean dumpAll) {
10240        pw.println("WINDOW MANAGER DISPLAY CONTENTS (dumpsys window displays)");
10241        if (mDisplayReady) {
10242            final int numDisplays = mDisplayContents.size();
10243            for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) {
10244                final DisplayContent displayContent = mDisplayContents.valueAt(displayNdx);
10245                displayContent.dump("  ", pw);
10246            }
10247        } else {
10248            pw.println("  NO DISPLAY");
10249        }
10250    }
10251
10252    void dumpWindowsLocked(PrintWriter pw, boolean dumpAll,
10253            ArrayList<WindowState> windows) {
10254        pw.println("WINDOW MANAGER WINDOWS (dumpsys window windows)");
10255        dumpWindowsNoHeaderLocked(pw, dumpAll, windows);
10256    }
10257
10258    void dumpWindowsNoHeaderLocked(PrintWriter pw, boolean dumpAll,
10259            ArrayList<WindowState> windows) {
10260        final int numDisplays = mDisplayContents.size();
10261        for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) {
10262            final WindowList windowList = mDisplayContents.valueAt(displayNdx).getWindowList();
10263            for (int winNdx = windowList.size() - 1; winNdx >= 0; --winNdx) {
10264                final WindowState w = windowList.get(winNdx);
10265                if (windows == null || windows.contains(w)) {
10266                    pw.print("  Window #"); pw.print(winNdx); pw.print(' ');
10267                            pw.print(w); pw.println(":");
10268                    w.dump(pw, "    ", dumpAll || windows != null);
10269                }
10270            }
10271        }
10272        if (mInputMethodDialogs.size() > 0) {
10273            pw.println();
10274            pw.println("  Input method dialogs:");
10275            for (int i=mInputMethodDialogs.size()-1; i>=0; i--) {
10276                WindowState w = mInputMethodDialogs.get(i);
10277                if (windows == null || windows.contains(w)) {
10278                    pw.print("  IM Dialog #"); pw.print(i); pw.print(": "); pw.println(w);
10279                }
10280            }
10281        }
10282        if (mPendingRemove.size() > 0) {
10283            pw.println();
10284            pw.println("  Remove pending for:");
10285            for (int i=mPendingRemove.size()-1; i>=0; i--) {
10286                WindowState w = mPendingRemove.get(i);
10287                if (windows == null || windows.contains(w)) {
10288                    pw.print("  Remove #"); pw.print(i); pw.print(' ');
10289                            pw.print(w);
10290                    if (dumpAll) {
10291                        pw.println(":");
10292                        w.dump(pw, "    ", true);
10293                    } else {
10294                        pw.println();
10295                    }
10296                }
10297            }
10298        }
10299        if (mForceRemoves != null && mForceRemoves.size() > 0) {
10300            pw.println();
10301            pw.println("  Windows force removing:");
10302            for (int i=mForceRemoves.size()-1; i>=0; i--) {
10303                WindowState w = mForceRemoves.get(i);
10304                pw.print("  Removing #"); pw.print(i); pw.print(' ');
10305                        pw.print(w);
10306                if (dumpAll) {
10307                    pw.println(":");
10308                    w.dump(pw, "    ", true);
10309                } else {
10310                    pw.println();
10311                }
10312            }
10313        }
10314        if (mDestroySurface.size() > 0) {
10315            pw.println();
10316            pw.println("  Windows waiting to destroy their surface:");
10317            for (int i=mDestroySurface.size()-1; i>=0; i--) {
10318                WindowState w = mDestroySurface.get(i);
10319                if (windows == null || windows.contains(w)) {
10320                    pw.print("  Destroy #"); pw.print(i); pw.print(' ');
10321                            pw.print(w);
10322                    if (dumpAll) {
10323                        pw.println(":");
10324                        w.dump(pw, "    ", true);
10325                    } else {
10326                        pw.println();
10327                    }
10328                }
10329            }
10330        }
10331        if (mLosingFocus.size() > 0) {
10332            pw.println();
10333            pw.println("  Windows losing focus:");
10334            for (int i=mLosingFocus.size()-1; i>=0; i--) {
10335                WindowState w = mLosingFocus.get(i);
10336                if (windows == null || windows.contains(w)) {
10337                    pw.print("  Losing #"); pw.print(i); pw.print(' ');
10338                            pw.print(w);
10339                    if (dumpAll) {
10340                        pw.println(":");
10341                        w.dump(pw, "    ", true);
10342                    } else {
10343                        pw.println();
10344                    }
10345                }
10346            }
10347        }
10348        if (mResizingWindows.size() > 0) {
10349            pw.println();
10350            pw.println("  Windows waiting to resize:");
10351            for (int i=mResizingWindows.size()-1; i>=0; i--) {
10352                WindowState w = mResizingWindows.get(i);
10353                if (windows == null || windows.contains(w)) {
10354                    pw.print("  Resizing #"); pw.print(i); pw.print(' ');
10355                            pw.print(w);
10356                    if (dumpAll) {
10357                        pw.println(":");
10358                        w.dump(pw, "    ", true);
10359                    } else {
10360                        pw.println();
10361                    }
10362                }
10363            }
10364        }
10365        if (mWaitingForDrawn.size() > 0) {
10366            pw.println();
10367            pw.println("  Clients waiting for these windows to be drawn:");
10368            for (int i=mWaitingForDrawn.size()-1; i>=0; i--) {
10369                Pair<WindowState, IRemoteCallback> pair = mWaitingForDrawn.get(i);
10370                pw.print("  Waiting #"); pw.print(i); pw.print(' '); pw.print(pair.first);
10371                        pw.print(": "); pw.println(pair.second);
10372            }
10373        }
10374        pw.println();
10375        pw.print("  mCurConfiguration="); pw.println(this.mCurConfiguration);
10376        pw.print("  mCurrentFocus="); pw.println(mCurrentFocus);
10377        if (mLastFocus != mCurrentFocus) {
10378            pw.print("  mLastFocus="); pw.println(mLastFocus);
10379        }
10380        pw.print("  mFocusedApp="); pw.println(mFocusedApp);
10381        if (mInputMethodTarget != null) {
10382            pw.print("  mInputMethodTarget="); pw.println(mInputMethodTarget);
10383        }
10384        pw.print("  mInTouchMode="); pw.print(mInTouchMode);
10385                pw.print(" mLayoutSeq="); pw.println(mLayoutSeq);
10386        pw.print("  mLastDisplayFreezeDuration=");
10387                TimeUtils.formatDuration(mLastDisplayFreezeDuration, pw);
10388                if ( mLastFinishedFreezeSource != null) {
10389                    pw.print(" due to ");
10390                    pw.print(mLastFinishedFreezeSource);
10391                }
10392                pw.println();
10393        if (dumpAll) {
10394            pw.print("  mSystemDecorLayer="); pw.print(mSystemDecorLayer);
10395                    pw.print(" mScreenRect="); pw.println(mScreenRect.toShortString());
10396            if (mLastStatusBarVisibility != 0) {
10397                pw.print("  mLastStatusBarVisibility=0x");
10398                        pw.println(Integer.toHexString(mLastStatusBarVisibility));
10399            }
10400            if (mInputMethodWindow != null) {
10401                pw.print("  mInputMethodWindow="); pw.println(mInputMethodWindow);
10402            }
10403            pw.print("  mWallpaperTarget="); pw.println(mWallpaperTarget);
10404            if (mLowerWallpaperTarget != null || mUpperWallpaperTarget != null) {
10405                pw.print("  mLowerWallpaperTarget="); pw.println(mLowerWallpaperTarget);
10406                pw.print("  mUpperWallpaperTarget="); pw.println(mUpperWallpaperTarget);
10407            }
10408            pw.print("  mLastWallpaperX="); pw.print(mLastWallpaperX);
10409                    pw.print(" mLastWallpaperY="); pw.println(mLastWallpaperY);
10410            if (mInputMethodAnimLayerAdjustment != 0 ||
10411                    mWallpaperAnimLayerAdjustment != 0) {
10412                pw.print("  mInputMethodAnimLayerAdjustment=");
10413                        pw.print(mInputMethodAnimLayerAdjustment);
10414                        pw.print("  mWallpaperAnimLayerAdjustment=");
10415                        pw.println(mWallpaperAnimLayerAdjustment);
10416            }
10417            pw.print("  mSystemBooted="); pw.print(mSystemBooted);
10418                    pw.print(" mDisplayEnabled="); pw.println(mDisplayEnabled);
10419            if (needsLayout()) {
10420                pw.print("  layoutNeeded on displays=");
10421                for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) {
10422                    final DisplayContent displayContent = mDisplayContents.valueAt(displayNdx);
10423                    if (displayContent.layoutNeeded) {
10424                        pw.print(displayContent.getDisplayId());
10425                    }
10426                }
10427                pw.println();
10428            }
10429            pw.print("  mTransactionSequence="); pw.println(mTransactionSequence);
10430            pw.print("  mDisplayFrozen="); pw.print(mDisplayFrozen);
10431                    pw.print(" windows="); pw.print(mWindowsFreezingScreen);
10432                    pw.print(" client="); pw.print(mClientFreezingScreen);
10433                    pw.print(" apps="); pw.print(mAppsFreezingScreen);
10434                    pw.print(" waitingForConfig="); pw.println(mWaitingForConfig);
10435            pw.print("  mRotation="); pw.print(mRotation);
10436                    pw.print(" mAltOrientation="); pw.println(mAltOrientation);
10437            pw.print("  mLastWindowForcedOrientation="); pw.print(mLastWindowForcedOrientation);
10438                    pw.print(" mForcedAppOrientation="); pw.println(mForcedAppOrientation);
10439            pw.print("  mDeferredRotationPauseCount="); pw.println(mDeferredRotationPauseCount);
10440            pw.print("  mWindowAnimationScale="); pw.print(mWindowAnimationScale);
10441                    pw.print(" mTransitionWindowAnimationScale="); pw.print(mTransitionAnimationScale);
10442                    pw.print(" mAnimatorDurationScale="); pw.println(mAnimatorDurationScale);
10443            pw.print("  mTraversalScheduled="); pw.println(mTraversalScheduled);
10444            pw.print("  mStartingIconInTransition="); pw.print(mStartingIconInTransition);
10445                    pw.print(" mSkipAppTransitionAnimation="); pw.println(mSkipAppTransitionAnimation);
10446            pw.println("  mLayoutToAnim:");
10447            mAppTransition.dump(pw);
10448        }
10449    }
10450
10451    boolean dumpWindows(PrintWriter pw, String name, String[] args,
10452            int opti, boolean dumpAll) {
10453        WindowList windows = new WindowList();
10454        if ("visible".equals(name)) {
10455            synchronized(mWindowMap) {
10456                final int numDisplays = mDisplayContents.size();
10457                for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) {
10458                    final WindowList windowList =
10459                            mDisplayContents.valueAt(displayNdx).getWindowList();
10460                    for (int winNdx = windowList.size() - 1; winNdx >= 0; --winNdx) {
10461                        final WindowState w = windowList.get(winNdx);
10462                        if (w.mWinAnimator.mSurfaceShown) {
10463                            windows.add(w);
10464                        }
10465                    }
10466                }
10467            }
10468        } else {
10469            int objectId = 0;
10470            // See if this is an object ID.
10471            try {
10472                objectId = Integer.parseInt(name, 16);
10473                name = null;
10474            } catch (RuntimeException e) {
10475            }
10476            synchronized(mWindowMap) {
10477                final int numDisplays = mDisplayContents.size();
10478                for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) {
10479                    final WindowList windowList =
10480                            mDisplayContents.valueAt(displayNdx).getWindowList();
10481                    for (int winNdx = windowList.size() - 1; winNdx >= 0; --winNdx) {
10482                        final WindowState w = windowList.get(winNdx);
10483                        if (name != null) {
10484                            if (w.mAttrs.getTitle().toString().contains(name)) {
10485                                windows.add(w);
10486                            }
10487                        } else if (System.identityHashCode(w) == objectId) {
10488                            windows.add(w);
10489                        }
10490                    }
10491                }
10492            }
10493        }
10494
10495        if (windows.size() <= 0) {
10496            return false;
10497        }
10498
10499        synchronized(mWindowMap) {
10500            dumpWindowsLocked(pw, dumpAll, windows);
10501        }
10502        return true;
10503    }
10504
10505    void dumpLastANRLocked(PrintWriter pw) {
10506        pw.println("WINDOW MANAGER LAST ANR (dumpsys window lastanr)");
10507        if (mLastANRState == null) {
10508            pw.println("  <no ANR has occurred since boot>");
10509        } else {
10510            pw.println(mLastANRState);
10511        }
10512    }
10513
10514    /**
10515     * Saves information about the state of the window manager at
10516     * the time an ANR occurred before anything else in the system changes
10517     * in response.
10518     *
10519     * @param appWindowToken The application that ANR'd, may be null.
10520     * @param windowState The window that ANR'd, may be null.
10521     * @param reason The reason for the ANR, may be null.
10522     */
10523    public void saveANRStateLocked(AppWindowToken appWindowToken, WindowState windowState,
10524            String reason) {
10525        StringWriter sw = new StringWriter();
10526        PrintWriter pw = new FastPrintWriter(sw, false, 1024);
10527        pw.println("  ANR time: " + DateFormat.getInstance().format(new Date()));
10528        if (appWindowToken != null) {
10529            pw.println("  Application at fault: " + appWindowToken.stringName);
10530        }
10531        if (windowState != null) {
10532            pw.println("  Window at fault: " + windowState.mAttrs.getTitle());
10533        }
10534        if (reason != null) {
10535            pw.println("  Reason: " + reason);
10536        }
10537        pw.println();
10538        dumpWindowsNoHeaderLocked(pw, true, null);
10539        pw.close();
10540        mLastANRState = sw.toString();
10541    }
10542
10543    @Override
10544    public void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
10545        if (mContext.checkCallingOrSelfPermission("android.permission.DUMP")
10546                != PackageManager.PERMISSION_GRANTED) {
10547            pw.println("Permission Denial: can't dump WindowManager from from pid="
10548                    + Binder.getCallingPid()
10549                    + ", uid=" + Binder.getCallingUid());
10550            return;
10551        }
10552
10553        boolean dumpAll = false;
10554
10555        int opti = 0;
10556        while (opti < args.length) {
10557            String opt = args[opti];
10558            if (opt == null || opt.length() <= 0 || opt.charAt(0) != '-') {
10559                break;
10560            }
10561            opti++;
10562            if ("-a".equals(opt)) {
10563                dumpAll = true;
10564            } else if ("-h".equals(opt)) {
10565                pw.println("Window manager dump options:");
10566                pw.println("  [-a] [-h] [cmd] ...");
10567                pw.println("  cmd may be one of:");
10568                pw.println("    l[astanr]: last ANR information");
10569                pw.println("    p[policy]: policy state");
10570                pw.println("    a[animator]: animator state");
10571                pw.println("    s[essions]: active sessions");
10572                pw.println("    d[isplays]: active display contents");
10573                pw.println("    t[okens]: token list");
10574                pw.println("    w[indows]: window list");
10575                pw.println("  cmd may also be a NAME to dump windows.  NAME may");
10576                pw.println("    be a partial substring in a window name, a");
10577                pw.println("    Window hex object identifier, or");
10578                pw.println("    \"all\" for all windows, or");
10579                pw.println("    \"visible\" for the visible windows.");
10580                pw.println("  -a: include all available server state.");
10581                return;
10582            } else {
10583                pw.println("Unknown argument: " + opt + "; use -h for help");
10584            }
10585        }
10586
10587        // Is the caller requesting to dump a particular piece of data?
10588        if (opti < args.length) {
10589            String cmd = args[opti];
10590            opti++;
10591            if ("lastanr".equals(cmd) || "l".equals(cmd)) {
10592                synchronized(mWindowMap) {
10593                    dumpLastANRLocked(pw);
10594                }
10595                return;
10596            } else if ("policy".equals(cmd) || "p".equals(cmd)) {
10597                synchronized(mWindowMap) {
10598                    dumpPolicyLocked(pw, args, true);
10599                }
10600                return;
10601            } else if ("animator".equals(cmd) || "a".equals(cmd)) {
10602                synchronized(mWindowMap) {
10603                    dumpAnimatorLocked(pw, args, true);
10604                }
10605                return;
10606            } else if ("sessions".equals(cmd) || "s".equals(cmd)) {
10607                synchronized(mWindowMap) {
10608                    dumpSessionsLocked(pw, true);
10609                }
10610                return;
10611            } else if ("displays".equals(cmd) || "d".equals(cmd)) {
10612                synchronized(mWindowMap) {
10613                    dumpDisplayContentsLocked(pw, true);
10614                }
10615                return;
10616            } else if ("tokens".equals(cmd) || "t".equals(cmd)) {
10617                synchronized(mWindowMap) {
10618                    dumpTokensLocked(pw, true);
10619                }
10620                return;
10621            } else if ("windows".equals(cmd) || "w".equals(cmd)) {
10622                synchronized(mWindowMap) {
10623                    dumpWindowsLocked(pw, true, null);
10624                }
10625                return;
10626            } else if ("all".equals(cmd) || "a".equals(cmd)) {
10627                synchronized(mWindowMap) {
10628                    dumpWindowsLocked(pw, true, null);
10629                }
10630                return;
10631            } else {
10632                // Dumping a single name?
10633                if (!dumpWindows(pw, cmd, args, opti, dumpAll)) {
10634                    pw.println("Bad window command, or no windows match: " + cmd);
10635                    pw.println("Use -h for help.");
10636                }
10637                return;
10638            }
10639        }
10640
10641        synchronized(mWindowMap) {
10642            pw.println();
10643            if (dumpAll) {
10644                pw.println("-------------------------------------------------------------------------------");
10645            }
10646            dumpLastANRLocked(pw);
10647            pw.println();
10648            if (dumpAll) {
10649                pw.println("-------------------------------------------------------------------------------");
10650            }
10651            dumpPolicyLocked(pw, args, dumpAll);
10652            pw.println();
10653            if (dumpAll) {
10654                pw.println("-------------------------------------------------------------------------------");
10655            }
10656            dumpAnimatorLocked(pw, args, dumpAll);
10657            pw.println();
10658            if (dumpAll) {
10659                pw.println("-------------------------------------------------------------------------------");
10660            }
10661            dumpSessionsLocked(pw, dumpAll);
10662            pw.println();
10663            if (dumpAll) {
10664                pw.println("-------------------------------------------------------------------------------");
10665            }
10666            dumpDisplayContentsLocked(pw, dumpAll);
10667            pw.println();
10668            if (dumpAll) {
10669                pw.println("-------------------------------------------------------------------------------");
10670            }
10671            dumpTokensLocked(pw, dumpAll);
10672            pw.println();
10673            if (dumpAll) {
10674                pw.println("-------------------------------------------------------------------------------");
10675            }
10676            dumpWindowsLocked(pw, dumpAll, null);
10677        }
10678    }
10679
10680    // Called by the heartbeat to ensure locks are not held indefnitely (for deadlock detection).
10681    @Override
10682    public void monitor() {
10683        synchronized (mWindowMap) { }
10684    }
10685
10686    public interface OnHardKeyboardStatusChangeListener {
10687        public void onHardKeyboardStatusChange(boolean available, boolean enabled);
10688    }
10689
10690    void debugLayoutRepeats(final String msg, int pendingLayoutChanges) {
10691        if (mLayoutRepeatCount >= LAYOUT_REPEAT_THRESHOLD) {
10692            Slog.v(TAG, "Layouts looping: " + msg + ", mPendingLayoutChanges = 0x" +
10693                    Integer.toHexString(pendingLayoutChanges));
10694        }
10695    }
10696
10697    private DisplayContent newDisplayContentLocked(final Display display) {
10698        DisplayContent displayContent = new DisplayContent(display, this);
10699        final int displayId = display.getDisplayId();
10700        mDisplayContents.put(displayId, displayContent);
10701
10702        DisplayInfo displayInfo = displayContent.getDisplayInfo();
10703        final Rect rect = new Rect();
10704        mDisplaySettings.getOverscanLocked(displayInfo.name, rect);
10705        synchronized (displayContent.mDisplaySizeLock) {
10706            displayInfo.overscanLeft = rect.left;
10707            displayInfo.overscanTop = rect.top;
10708            displayInfo.overscanRight = rect.right;
10709            displayInfo.overscanBottom = rect.bottom;
10710            mDisplayManagerService.setDisplayInfoOverrideFromWindowManager(
10711                    displayId, displayInfo);
10712        }
10713        configureDisplayPolicyLocked(displayContent);
10714
10715        // TODO: Create an input channel for each display with touch capability.
10716        if (displayId == Display.DEFAULT_DISPLAY) {
10717            displayContent.mTapDetector = new StackTapPointerEventListener(this, displayContent);
10718            registerPointerEventListener(displayContent.mTapDetector);
10719        }
10720
10721        return displayContent;
10722    }
10723
10724    public void createDisplayContentLocked(final Display display) {
10725        if (display == null) {
10726            throw new IllegalArgumentException("getDisplayContent: display must not be null");
10727        }
10728        getDisplayContentLocked(display.getDisplayId());
10729    }
10730
10731    /**
10732     * Retrieve the DisplayContent for the specified displayId. Will create a new DisplayContent if
10733     * there is a Display for the displayId.
10734     * @param displayId The display the caller is interested in.
10735     * @return The DisplayContent associated with displayId or null if there is no Display for it.
10736     */
10737    public DisplayContent getDisplayContentLocked(final int displayId) {
10738        DisplayContent displayContent = mDisplayContents.get(displayId);
10739        if (displayContent == null) {
10740            final Display display = mDisplayManager.getDisplay(displayId);
10741            if (display != null) {
10742                displayContent = newDisplayContentLocked(display);
10743            }
10744        }
10745        return displayContent;
10746    }
10747
10748    // There is an inherent assumption that this will never return null.
10749    public DisplayContent getDefaultDisplayContentLocked() {
10750        return getDisplayContentLocked(Display.DEFAULT_DISPLAY);
10751    }
10752
10753    public WindowList getDefaultWindowListLocked() {
10754        return getDefaultDisplayContentLocked().getWindowList();
10755    }
10756
10757    public DisplayInfo getDefaultDisplayInfoLocked() {
10758        return getDefaultDisplayContentLocked().getDisplayInfo();
10759    }
10760
10761    /**
10762     * Return the list of WindowStates associated on the passed display.
10763     * @param display The screen to return windows from.
10764     * @return The list of WindowStates on the screen, or null if the there is no screen.
10765     */
10766    public WindowList getWindowListLocked(final Display display) {
10767        return getWindowListLocked(display.getDisplayId());
10768    }
10769
10770    /**
10771     * Return the list of WindowStates associated on the passed display.
10772     * @param displayId The screen to return windows from.
10773     * @return The list of WindowStates on the screen, or null if the there is no screen.
10774     */
10775    public WindowList getWindowListLocked(final int displayId) {
10776        final DisplayContent displayContent = getDisplayContentLocked(displayId);
10777        return displayContent != null ? displayContent.getWindowList() : null;
10778    }
10779
10780    @Override
10781    public void onDisplayAdded(int displayId) {
10782        mH.sendMessage(mH.obtainMessage(H.DO_DISPLAY_ADDED, displayId, 0));
10783    }
10784
10785    private void handleDisplayAddedLocked(int displayId) {
10786        final Display display = mDisplayManager.getDisplay(displayId);
10787        if (display != null) {
10788            createDisplayContentLocked(display);
10789            displayReady(displayId);
10790        }
10791    }
10792
10793    @Override
10794    public void onDisplayRemoved(int displayId) {
10795        mH.sendMessage(mH.obtainMessage(H.DO_DISPLAY_REMOVED, displayId, 0));
10796    }
10797
10798    private void handleDisplayRemovedLocked(int displayId) {
10799        final DisplayContent displayContent = getDisplayContentLocked(displayId);
10800        if (displayContent != null) {
10801            mDisplayContents.delete(displayId);
10802            displayContent.close();
10803            if (displayId == Display.DEFAULT_DISPLAY) {
10804                unregisterPointerEventListener(displayContent.mTapDetector);
10805            }
10806            WindowList windows = displayContent.getWindowList();
10807            while (!windows.isEmpty()) {
10808                final WindowState win = windows.get(windows.size() - 1);
10809                removeWindowLocked(win.mSession, win);
10810            }
10811        }
10812        mAnimator.removeDisplayLocked(displayId);
10813    }
10814
10815    @Override
10816    public void onDisplayChanged(int displayId) {
10817        mH.sendMessage(mH.obtainMessage(H.DO_DISPLAY_CHANGED, displayId, 0));
10818    }
10819
10820    private void handleDisplayChangedLocked(int displayId) {
10821        final DisplayContent displayContent = getDisplayContentLocked(displayId);
10822        if (displayContent != null) {
10823            displayContent.updateDisplayInfo();
10824        }
10825    }
10826
10827    @Override
10828    public Object getWindowManagerLock() {
10829        return mWindowMap;
10830    }
10831}
10832