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