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