PhoneWindowManager.java revision c5e73bf9f8a3434571b407f0f1abd701a8e69131 
1/*
2 * Copyright (C) 2006 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.policy;
18
19import android.app.ActivityManager;
20import android.app.ActivityManagerNative;
21import android.app.AppOpsManager;
22import android.app.IUiModeManager;
23import android.app.ProgressDialog;
24import android.app.SearchManager;
25import android.app.StatusBarManager;
26import android.app.UiModeManager;
27import android.content.ActivityNotFoundException;
28import android.content.BroadcastReceiver;
29import android.content.ComponentName;
30import android.content.ContentResolver;
31import android.content.Context;
32import android.content.Intent;
33import android.content.IntentFilter;
34import android.content.ServiceConnection;
35import android.content.pm.ActivityInfo;
36import android.content.pm.PackageManager;
37import android.content.pm.ResolveInfo;
38import android.content.res.CompatibilityInfo;
39import android.content.res.Configuration;
40import android.content.res.Resources;
41import android.content.res.TypedArray;
42import android.database.ContentObserver;
43import android.graphics.PixelFormat;
44import android.graphics.Rect;
45import android.media.AudioAttributes;
46import android.media.AudioManager;
47import android.media.AudioSystem;
48import android.media.IAudioService;
49import android.media.Ringtone;
50import android.media.RingtoneManager;
51import android.media.session.MediaSessionLegacyHelper;
52import android.os.Build;
53import android.os.Bundle;
54import android.os.Debug;
55import android.os.FactoryTest;
56import android.os.Handler;
57import android.os.IBinder;
58import android.os.Looper;
59import android.os.Message;
60import android.os.Messenger;
61import android.os.PowerManager;
62import android.os.RemoteException;
63import android.os.ServiceManager;
64import android.os.SystemClock;
65import android.os.SystemProperties;
66import android.os.UEventObserver;
67import android.os.UserHandle;
68import android.os.Vibrator;
69import android.provider.MediaStore;
70import android.provider.Settings;
71import android.service.dreams.DreamManagerInternal;
72import android.service.dreams.DreamService;
73import android.service.dreams.IDreamManager;
74import android.speech.RecognizerIntent;
75import android.telecom.TelecomManager;
76import android.util.DisplayMetrics;
77import android.util.EventLog;
78import android.util.Log;
79import android.util.Slog;
80import android.util.SparseArray;
81import android.view.Display;
82import android.view.Gravity;
83import android.view.HapticFeedbackConstants;
84import android.view.IApplicationToken;
85import android.view.IWindowManager;
86import android.view.InputChannel;
87import android.view.InputDevice;
88import android.view.InputEvent;
89import android.view.InputEventReceiver;
90import android.view.KeyCharacterMap;
91import android.view.KeyCharacterMap.FallbackAction;
92import android.view.KeyEvent;
93import android.view.MotionEvent;
94import android.view.PhoneWindow;
95import android.view.Surface;
96import android.view.View;
97import android.view.ViewConfiguration;
98import android.view.ViewRootImpl;
99import android.view.Window;
100import android.view.WindowManager;
101import android.view.WindowManagerGlobal;
102import android.view.WindowManagerInternal;
103import android.view.WindowManagerPolicy;
104import android.view.accessibility.AccessibilityEvent;
105import android.view.accessibility.AccessibilityManager;
106import android.view.animation.Animation;
107import android.view.animation.AnimationSet;
108import android.view.animation.AnimationUtils;
109import com.android.internal.R;
110import com.android.internal.statusbar.IStatusBarService;
111import com.android.internal.widget.PointerLocationView;
112import com.android.server.LocalServices;
113import com.android.server.policy.keyguard.KeyguardServiceDelegate;
114import com.android.server.policy.keyguard.KeyguardServiceDelegate.ShowListener;
115
116import java.io.File;
117import java.io.FileReader;
118import java.io.IOException;
119import java.io.PrintWriter;
120import java.util.HashSet;
121import java.util.List;
122
123import static android.view.WindowManager.LayoutParams.*;
124import static android.view.WindowManagerPolicy.WindowManagerFuncs.LID_ABSENT;
125import static android.view.WindowManagerPolicy.WindowManagerFuncs.LID_OPEN;
126import static android.view.WindowManagerPolicy.WindowManagerFuncs.LID_CLOSED;
127import static android.view.WindowManagerPolicy.WindowManagerFuncs.CAMERA_LENS_COVER_ABSENT;
128import static android.view.WindowManagerPolicy.WindowManagerFuncs.CAMERA_LENS_UNCOVERED;
129import static android.view.WindowManagerPolicy.WindowManagerFuncs.CAMERA_LENS_COVERED;
130
131/**
132 * WindowManagerPolicy implementation for the Android phone UI.  This
133 * introduces a new method suffix, Lp, for an internal lock of the
134 * PhoneWindowManager.  This is used to protect some internal state, and
135 * can be acquired with either the Lw and Li lock held, so has the restrictions
136 * of both of those when held.
137 */
138public class PhoneWindowManager implements WindowManagerPolicy {
139    static final String TAG = "WindowManager";
140    static final boolean DEBUG = false;
141    static final boolean localLOGV = false;
142    static final boolean DEBUG_INPUT = false;
143    static final boolean DEBUG_KEYGUARD = false;
144    static final boolean DEBUG_LAYOUT = false;
145    static final boolean DEBUG_STARTING_WINDOW = false;
146    static final boolean DEBUG_WAKEUP = false;
147    static final boolean SHOW_STARTING_ANIMATIONS = true;
148    static final boolean SHOW_PROCESSES_ON_ALT_MENU = false;
149
150    // Whether to allow dock apps with METADATA_DOCK_HOME to temporarily take over the Home key.
151    // No longer recommended for desk docks; still useful in car docks.
152    static final boolean ENABLE_CAR_DOCK_HOME_CAPTURE = true;
153    static final boolean ENABLE_DESK_DOCK_HOME_CAPTURE = false;
154
155    static final int SHORT_PRESS_POWER_NOTHING = 0;
156    static final int SHORT_PRESS_POWER_GO_TO_SLEEP = 1;
157    static final int SHORT_PRESS_POWER_REALLY_GO_TO_SLEEP = 2;
158    static final int SHORT_PRESS_POWER_REALLY_GO_TO_SLEEP_AND_GO_HOME = 3;
159    static final int SHORT_PRESS_POWER_GO_HOME = 4;
160
161    static final int LONG_PRESS_POWER_NOTHING = 0;
162    static final int LONG_PRESS_POWER_GLOBAL_ACTIONS = 1;
163    static final int LONG_PRESS_POWER_SHUT_OFF = 2;
164    static final int LONG_PRESS_POWER_SHUT_OFF_NO_CONFIRM = 3;
165
166    static final int MULTI_PRESS_POWER_NOTHING = 0;
167    static final int MULTI_PRESS_POWER_THEATER_MODE = 1;
168    static final int MULTI_PRESS_POWER_BRIGHTNESS_BOOST = 2;
169
170    // These need to match the documentation/constant in
171    // core/res/res/values/config.xml
172    static final int LONG_PRESS_HOME_NOTHING = 0;
173    static final int LONG_PRESS_HOME_RECENT_SYSTEM_UI = 1;
174    static final int LONG_PRESS_HOME_ASSIST = 2;
175
176    static final int DOUBLE_TAP_HOME_NOTHING = 0;
177    static final int DOUBLE_TAP_HOME_RECENT_SYSTEM_UI = 1;
178
179    static final int SHORT_PRESS_SLEEP_GO_TO_SLEEP = 0;
180    static final int SHORT_PRESS_SLEEP_GO_TO_SLEEP_AND_GO_HOME = 1;
181
182    static final int APPLICATION_MEDIA_SUBLAYER = -2;
183    static final int APPLICATION_MEDIA_OVERLAY_SUBLAYER = -1;
184    static final int APPLICATION_PANEL_SUBLAYER = 1;
185    static final int APPLICATION_SUB_PANEL_SUBLAYER = 2;
186    static final int APPLICATION_ABOVE_SUB_PANEL_SUBLAYER = 3;
187
188    static public final String SYSTEM_DIALOG_REASON_KEY = "reason";
189    static public final String SYSTEM_DIALOG_REASON_GLOBAL_ACTIONS = "globalactions";
190    static public final String SYSTEM_DIALOG_REASON_RECENT_APPS = "recentapps";
191    static public final String SYSTEM_DIALOG_REASON_HOME_KEY = "homekey";
192    static public final String SYSTEM_DIALOG_REASON_ASSIST = "assist";
193
194    /**
195     * These are the system UI flags that, when changing, can cause the layout
196     * of the screen to change.
197     */
198    static final int SYSTEM_UI_CHANGING_LAYOUT =
199              View.SYSTEM_UI_FLAG_HIDE_NAVIGATION
200            | View.SYSTEM_UI_FLAG_FULLSCREEN
201            | View.STATUS_BAR_TRANSLUCENT
202            | View.NAVIGATION_BAR_TRANSLUCENT
203            | View.SYSTEM_UI_TRANSPARENT;
204
205    private static final AudioAttributes VIBRATION_ATTRIBUTES = new AudioAttributes.Builder()
206            .setContentType(AudioAttributes.CONTENT_TYPE_SONIFICATION)
207            .setUsage(AudioAttributes.USAGE_ASSISTANCE_SONIFICATION)
208            .build();
209
210    /**
211     * Keyguard stuff
212     */
213    private WindowState mKeyguardScrim;
214    private boolean mKeyguardHidden;
215    private boolean mKeyguardDrawnOnce;
216
217    /* Table of Application Launch keys.  Maps from key codes to intent categories.
218     *
219     * These are special keys that are used to launch particular kinds of applications,
220     * such as a web browser.  HID defines nearly a hundred of them in the Consumer (0x0C)
221     * usage page.  We don't support quite that many yet...
222     */
223    static SparseArray<String> sApplicationLaunchKeyCategories;
224    static {
225        sApplicationLaunchKeyCategories = new SparseArray<String>();
226        sApplicationLaunchKeyCategories.append(
227                KeyEvent.KEYCODE_EXPLORER, Intent.CATEGORY_APP_BROWSER);
228        sApplicationLaunchKeyCategories.append(
229                KeyEvent.KEYCODE_ENVELOPE, Intent.CATEGORY_APP_EMAIL);
230        sApplicationLaunchKeyCategories.append(
231                KeyEvent.KEYCODE_CONTACTS, Intent.CATEGORY_APP_CONTACTS);
232        sApplicationLaunchKeyCategories.append(
233                KeyEvent.KEYCODE_CALENDAR, Intent.CATEGORY_APP_CALENDAR);
234        sApplicationLaunchKeyCategories.append(
235                KeyEvent.KEYCODE_MUSIC, Intent.CATEGORY_APP_MUSIC);
236        sApplicationLaunchKeyCategories.append(
237                KeyEvent.KEYCODE_CALCULATOR, Intent.CATEGORY_APP_CALCULATOR);
238    }
239
240    /** Amount of time (in milliseconds) to wait for windows drawn before powering on. */
241    static final int WAITING_FOR_DRAWN_TIMEOUT = 1000;
242
243    /**
244     * Lock protecting internal state.  Must not call out into window
245     * manager with lock held.  (This lock will be acquired in places
246     * where the window manager is calling in with its own lock held.)
247     */
248    private final Object mLock = new Object();
249
250    Context mContext;
251    IWindowManager mWindowManager;
252    WindowManagerFuncs mWindowManagerFuncs;
253    WindowManagerInternal mWindowManagerInternal;
254    PowerManager mPowerManager;
255    DreamManagerInternal mDreamManagerInternal;
256    IStatusBarService mStatusBarService;
257    boolean mPreloadedRecentApps;
258    final Object mServiceAquireLock = new Object();
259    Vibrator mVibrator; // Vibrator for giving feedback of orientation changes
260    SearchManager mSearchManager;
261    AccessibilityManager mAccessibilityManager;
262    BurnInProtectionHelper mBurnInProtectionHelper;
263
264    // Vibrator pattern for haptic feedback of a long press.
265    long[] mLongPressVibePattern;
266
267    // Vibrator pattern for haptic feedback of virtual key press.
268    long[] mVirtualKeyVibePattern;
269
270    // Vibrator pattern for a short vibration.
271    long[] mKeyboardTapVibePattern;
272
273    // Vibrator pattern for a short vibration when tapping on an hour/minute tick of a Clock.
274    long[] mClockTickVibePattern;
275
276    // Vibrator pattern for a short vibration when tapping on a day/month/year date of a Calendar.
277    long[] mCalendarDateVibePattern;
278
279    // Vibrator pattern for haptic feedback during boot when safe mode is disabled.
280    long[] mSafeModeDisabledVibePattern;
281
282    // Vibrator pattern for haptic feedback during boot when safe mode is enabled.
283    long[] mSafeModeEnabledVibePattern;
284
285    /** If true, hitting shift & menu will broadcast Intent.ACTION_BUG_REPORT */
286    boolean mEnableShiftMenuBugReports = false;
287
288    boolean mSafeMode;
289    WindowState mStatusBar = null;
290    int mStatusBarHeight;
291    WindowState mNavigationBar = null;
292    boolean mHasNavigationBar = false;
293    boolean mCanHideNavigationBar = false;
294    boolean mNavigationBarCanMove = false; // can the navigation bar ever move to the side?
295    boolean mNavigationBarOnBottom = true; // is the navigation bar on the bottom *right now*?
296    int[] mNavigationBarHeightForRotation = new int[4];
297    int[] mNavigationBarWidthForRotation = new int[4];
298
299    boolean mBootMessageNeedsHiding;
300    KeyguardServiceDelegate mKeyguardDelegate;
301    final Runnable mWindowManagerDrawCallback = new Runnable() {
302        @Override
303        public void run() {
304            if (DEBUG_WAKEUP) Slog.i(TAG, "All windows ready for display!");
305            mHandler.sendEmptyMessage(MSG_WINDOW_MANAGER_DRAWN_COMPLETE);
306        }
307    };
308    final ShowListener mKeyguardDelegateCallback = new ShowListener() {
309        @Override
310        public void onShown(IBinder windowToken) {
311            if (DEBUG_WAKEUP) Slog.d(TAG, "mKeyguardDelegate.ShowListener.onShown.");
312            mHandler.sendEmptyMessage(MSG_KEYGUARD_DRAWN_COMPLETE);
313        }
314    };
315
316    GlobalActions mGlobalActions;
317    Handler mHandler;
318    WindowState mLastInputMethodWindow = null;
319    WindowState mLastInputMethodTargetWindow = null;
320
321    // FIXME This state is shared between the input reader and handler thread.
322    // Technically it's broken and buggy but it has been like this for many years
323    // and we have not yet seen any problems.  Someday we'll rewrite this logic
324    // so that only one thread is involved in handling input policy.  Unfortunately
325    // it's on a critical path for power management so we can't just post the work to the
326    // handler thread.  We'll need to resolve this someday by teaching the input dispatcher
327    // to hold wakelocks during dispatch and eliminating the critical path.
328    volatile boolean mPowerKeyHandled;
329    volatile boolean mBeganFromNonInteractive;
330    volatile int mPowerKeyPressCounter;
331    volatile boolean mEndCallKeyHandled;
332
333    boolean mRecentsVisible;
334    int mRecentAppsHeldModifiers;
335    boolean mLanguageSwitchKeyPressed;
336
337    int mLidState = LID_ABSENT;
338    int mCameraLensCoverState = CAMERA_LENS_COVER_ABSENT;
339    boolean mHaveBuiltInKeyboard;
340
341    boolean mSystemReady;
342    boolean mSystemBooted;
343    boolean mHdmiPlugged;
344    IUiModeManager mUiModeManager;
345    int mUiMode;
346    int mDockMode = Intent.EXTRA_DOCK_STATE_UNDOCKED;
347    int mLidOpenRotation;
348    int mCarDockRotation;
349    int mDeskDockRotation;
350    int mUndockedHdmiRotation;
351    int mDemoHdmiRotation;
352    boolean mDemoHdmiRotationLock;
353    int mDemoRotation;
354    boolean mDemoRotationLock;
355
356    boolean mWakeGestureEnabledSetting;
357    MyWakeGestureListener mWakeGestureListener;
358
359    // Default display does not rotate, apps that require non-default orientation will have to
360    // have the orientation emulated.
361    private boolean mForceDefaultOrientation = false;
362
363    int mUserRotationMode = WindowManagerPolicy.USER_ROTATION_FREE;
364    int mUserRotation = Surface.ROTATION_0;
365    boolean mAccelerometerDefault;
366
367    boolean mSupportAutoRotation;
368    int mAllowAllRotations = -1;
369    boolean mCarDockEnablesAccelerometer;
370    boolean mDeskDockEnablesAccelerometer;
371    int mLidKeyboardAccessibility;
372    int mLidNavigationAccessibility;
373    boolean mLidControlsSleep;
374    int mShortPressOnPowerBehavior;
375    int mLongPressOnPowerBehavior;
376    int mDoublePressOnPowerBehavior;
377    int mTriplePressOnPowerBehavior;
378    int mShortPressOnSleepBehavior;
379    boolean mAwake;
380    boolean mScreenOnEarly;
381    boolean mScreenOnFully;
382    ScreenOnListener mScreenOnListener;
383    boolean mKeyguardDrawComplete;
384    boolean mWindowManagerDrawComplete;
385    boolean mOrientationSensorEnabled = false;
386    int mCurrentAppOrientation = ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED;
387    boolean mHasSoftInput = false;
388    boolean mTranslucentDecorEnabled = true;
389    boolean mUseTvRouting;
390
391    int mPointerLocationMode = 0; // guarded by mLock
392
393    // The last window we were told about in focusChanged.
394    WindowState mFocusedWindow;
395    IApplicationToken mFocusedApp;
396
397    PointerLocationView mPointerLocationView;
398
399    // The current size of the screen; really; extends into the overscan area of
400    // the screen and doesn't account for any system elements like the status bar.
401    int mOverscanScreenLeft, mOverscanScreenTop;
402    int mOverscanScreenWidth, mOverscanScreenHeight;
403    // The current visible size of the screen; really; (ir)regardless of whether the status
404    // bar can be hidden but not extending into the overscan area.
405    int mUnrestrictedScreenLeft, mUnrestrictedScreenTop;
406    int mUnrestrictedScreenWidth, mUnrestrictedScreenHeight;
407    // Like mOverscanScreen*, but allowed to move into the overscan region where appropriate.
408    int mRestrictedOverscanScreenLeft, mRestrictedOverscanScreenTop;
409    int mRestrictedOverscanScreenWidth, mRestrictedOverscanScreenHeight;
410    // The current size of the screen; these may be different than (0,0)-(dw,dh)
411    // if the status bar can't be hidden; in that case it effectively carves out
412    // that area of the display from all other windows.
413    int mRestrictedScreenLeft, mRestrictedScreenTop;
414    int mRestrictedScreenWidth, mRestrictedScreenHeight;
415    // During layout, the current screen borders accounting for any currently
416    // visible system UI elements.
417    int mSystemLeft, mSystemTop, mSystemRight, mSystemBottom;
418    // For applications requesting stable content insets, these are them.
419    int mStableLeft, mStableTop, mStableRight, mStableBottom;
420    // For applications requesting stable content insets but have also set the
421    // fullscreen window flag, these are the stable dimensions without the status bar.
422    int mStableFullscreenLeft, mStableFullscreenTop;
423    int mStableFullscreenRight, mStableFullscreenBottom;
424    // During layout, the current screen borders with all outer decoration
425    // (status bar, input method dock) accounted for.
426    int mCurLeft, mCurTop, mCurRight, mCurBottom;
427    // During layout, the frame in which content should be displayed
428    // to the user, accounting for all screen decoration except for any
429    // space they deem as available for other content.  This is usually
430    // the same as mCur*, but may be larger if the screen decor has supplied
431    // content insets.
432    int mContentLeft, mContentTop, mContentRight, mContentBottom;
433    // During layout, the frame in which voice content should be displayed
434    // to the user, accounting for all screen decoration except for any
435    // space they deem as available for other content.
436    int mVoiceContentLeft, mVoiceContentTop, mVoiceContentRight, mVoiceContentBottom;
437    // During layout, the current screen borders along which input method
438    // windows are placed.
439    int mDockLeft, mDockTop, mDockRight, mDockBottom;
440    // During layout, the layer at which the doc window is placed.
441    int mDockLayer;
442    // During layout, this is the layer of the status bar.
443    int mStatusBarLayer;
444    int mLastSystemUiFlags;
445    // Bits that we are in the process of clearing, so we want to prevent
446    // them from being set by applications until everything has been updated
447    // to have them clear.
448    int mResettingSystemUiFlags = 0;
449    // Bits that we are currently always keeping cleared.
450    int mForceClearedSystemUiFlags = 0;
451    // What we last reported to system UI about whether the compatibility
452    // menu needs to be displayed.
453    boolean mLastFocusNeedsMenu = false;
454
455    FakeWindow mHideNavFakeWindow = null;
456
457    static final Rect mTmpParentFrame = new Rect();
458    static final Rect mTmpDisplayFrame = new Rect();
459    static final Rect mTmpOverscanFrame = new Rect();
460    static final Rect mTmpContentFrame = new Rect();
461    static final Rect mTmpVisibleFrame = new Rect();
462    static final Rect mTmpDecorFrame = new Rect();
463    static final Rect mTmpStableFrame = new Rect();
464    static final Rect mTmpNavigationFrame = new Rect();
465
466    WindowState mTopFullscreenOpaqueWindowState;
467    WindowState mTopFullscreenOpaqueOrDimmingWindowState;
468    HashSet<IApplicationToken> mAppsToBeHidden = new HashSet<IApplicationToken>();
469    HashSet<IApplicationToken> mAppsThatDismissKeyguard = new HashSet<IApplicationToken>();
470    boolean mTopIsFullscreen;
471    boolean mForceStatusBar;
472    boolean mForceStatusBarFromKeyguard;
473    boolean mHideLockScreen;
474    boolean mForcingShowNavBar;
475    int mForcingShowNavBarLayer;
476
477    // States of keyguard dismiss.
478    private static final int DISMISS_KEYGUARD_NONE = 0; // Keyguard not being dismissed.
479    private static final int DISMISS_KEYGUARD_START = 1; // Keyguard needs to be dismissed.
480    private static final int DISMISS_KEYGUARD_CONTINUE = 2; // Keyguard has been dismissed.
481    int mDismissKeyguard = DISMISS_KEYGUARD_NONE;
482
483    /** The window that is currently dismissing the keyguard. Dismissing the keyguard must only
484     * be done once per window. */
485    private WindowState mWinDismissingKeyguard;
486
487    /** The window that is currently showing "over" the keyguard. If there is an app window
488     * belonging to another app on top of this the keyguard shows. If there is a fullscreen
489     * app window under this, still dismiss the keyguard but don't show the app underneath. Show
490     * the wallpaper. */
491    private WindowState mWinShowWhenLocked;
492
493    boolean mShowingLockscreen;
494    boolean mShowingDream;
495    boolean mDreamingLockscreen;
496    boolean mKeyguardSecure;
497    boolean mKeyguardSecureIncludingHidden;
498    volatile boolean mKeyguardOccluded;
499    boolean mHomePressed;
500    boolean mHomeConsumed;
501    boolean mHomeDoubleTapPending;
502    Intent mHomeIntent;
503    Intent mCarDockIntent;
504    Intent mDeskDockIntent;
505    boolean mSearchKeyShortcutPending;
506    boolean mConsumeSearchKeyUp;
507    boolean mAssistKeyLongPressed;
508    boolean mPendingMetaAction;
509
510    // support for activating the lock screen while the screen is on
511    boolean mAllowLockscreenWhenOn;
512    int mLockScreenTimeout;
513    boolean mLockScreenTimerActive;
514
515    // Behavior of ENDCALL Button.  (See Settings.System.END_BUTTON_BEHAVIOR.)
516    int mEndcallBehavior;
517
518    // Behavior of POWER button while in-call and screen on.
519    // (See Settings.Secure.INCALL_POWER_BUTTON_BEHAVIOR.)
520    int mIncallPowerBehavior;
521
522    Display mDisplay;
523
524    int mLandscapeRotation = 0;  // default landscape rotation
525    int mSeascapeRotation = 0;   // "other" landscape rotation, 180 degrees from mLandscapeRotation
526    int mPortraitRotation = 0;   // default portrait rotation
527    int mUpsideDownRotation = 0; // "other" portrait rotation
528
529    int mOverscanLeft = 0;
530    int mOverscanTop = 0;
531    int mOverscanRight = 0;
532    int mOverscanBottom = 0;
533
534    // What we do when the user long presses on home
535    private int mLongPressOnHomeBehavior;
536
537    // What we do when the user double-taps on home
538    private int mDoubleTapOnHomeBehavior;
539
540    // Allowed theater mode wake actions
541    private boolean mAllowTheaterModeWakeFromKey;
542    private boolean mAllowTheaterModeWakeFromPowerKey;
543    private boolean mAllowTheaterModeWakeFromMotion;
544    private boolean mAllowTheaterModeWakeFromMotionWhenNotDreaming;
545    private boolean mAllowTheaterModeWakeFromCameraLens;
546    private boolean mAllowTheaterModeWakeFromLidSwitch;
547    private boolean mAllowTheaterModeWakeFromWakeGesture;
548
549    // Whether to support long press from power button in non-interactive mode
550    private boolean mSupportLongPressPowerWhenNonInteractive;
551
552    // Whether to go to sleep entering theater mode from power button
553    private boolean mGoToSleepOnButtonPressTheaterMode;
554
555    // Screenshot trigger states
556    // Time to volume and power must be pressed within this interval of each other.
557    private static final long SCREENSHOT_CHORD_DEBOUNCE_DELAY_MILLIS = 150;
558    // Increase the chord delay when taking a screenshot from the keyguard
559    private static final float KEYGUARD_SCREENSHOT_CHORD_DELAY_MULTIPLIER = 2.5f;
560    private boolean mScreenshotChordEnabled;
561    private boolean mScreenshotChordVolumeDownKeyTriggered;
562    private long mScreenshotChordVolumeDownKeyTime;
563    private boolean mScreenshotChordVolumeDownKeyConsumed;
564    private boolean mScreenshotChordVolumeUpKeyTriggered;
565    private boolean mScreenshotChordPowerKeyTriggered;
566    private long mScreenshotChordPowerKeyTime;
567
568    /* The number of steps between min and max brightness */
569    private static final int BRIGHTNESS_STEPS = 10;
570
571    SettingsObserver mSettingsObserver;
572    ShortcutManager mShortcutManager;
573    PowerManager.WakeLock mBroadcastWakeLock;
574    PowerManager.WakeLock mPowerKeyWakeLock;
575    boolean mHavePendingMediaKeyRepeatWithWakeLock;
576
577    private int mCurrentUserId;
578
579    // Maps global key codes to the components that will handle them.
580    private GlobalKeyManager mGlobalKeyManager;
581
582    // Fallback actions by key code.
583    private final SparseArray<KeyCharacterMap.FallbackAction> mFallbackActions =
584            new SparseArray<KeyCharacterMap.FallbackAction>();
585
586    private final LogDecelerateInterpolator mLogDecelerateInterpolator
587            = new LogDecelerateInterpolator(100, 0);
588
589    private static final int MSG_ENABLE_POINTER_LOCATION = 1;
590    private static final int MSG_DISABLE_POINTER_LOCATION = 2;
591    private static final int MSG_DISPATCH_MEDIA_KEY_WITH_WAKE_LOCK = 3;
592    private static final int MSG_DISPATCH_MEDIA_KEY_REPEAT_WITH_WAKE_LOCK = 4;
593    private static final int MSG_KEYGUARD_DRAWN_COMPLETE = 5;
594    private static final int MSG_KEYGUARD_DRAWN_TIMEOUT = 6;
595    private static final int MSG_WINDOW_MANAGER_DRAWN_COMPLETE = 7;
596    private static final int MSG_DISPATCH_SHOW_RECENTS = 9;
597    private static final int MSG_DISPATCH_SHOW_GLOBAL_ACTIONS = 10;
598    private static final int MSG_HIDE_BOOT_MESSAGE = 11;
599    private static final int MSG_LAUNCH_VOICE_ASSIST_WITH_WAKE_LOCK = 12;
600    private static final int MSG_POWER_DELAYED_PRESS = 13;
601    private static final int MSG_POWER_LONG_PRESS = 14;
602
603    private class PolicyHandler extends Handler {
604        @Override
605        public void handleMessage(Message msg) {
606            switch (msg.what) {
607                case MSG_ENABLE_POINTER_LOCATION:
608                    enablePointerLocation();
609                    break;
610                case MSG_DISABLE_POINTER_LOCATION:
611                    disablePointerLocation();
612                    break;
613                case MSG_DISPATCH_MEDIA_KEY_WITH_WAKE_LOCK:
614                    dispatchMediaKeyWithWakeLock((KeyEvent)msg.obj);
615                    break;
616                case MSG_DISPATCH_MEDIA_KEY_REPEAT_WITH_WAKE_LOCK:
617                    dispatchMediaKeyRepeatWithWakeLock((KeyEvent)msg.obj);
618                    break;
619                case MSG_DISPATCH_SHOW_RECENTS:
620                    showRecentApps(false);
621                    break;
622                case MSG_DISPATCH_SHOW_GLOBAL_ACTIONS:
623                    showGlobalActionsInternal();
624                    break;
625                case MSG_KEYGUARD_DRAWN_COMPLETE:
626                    if (DEBUG_WAKEUP) Slog.w(TAG, "Setting mKeyguardDrawComplete");
627                    finishKeyguardDrawn();
628                    break;
629                case MSG_KEYGUARD_DRAWN_TIMEOUT:
630                    Slog.w(TAG, "Keyguard drawn timeout. Setting mKeyguardDrawComplete");
631                    finishKeyguardDrawn();
632                    break;
633                case MSG_WINDOW_MANAGER_DRAWN_COMPLETE:
634                    if (DEBUG_WAKEUP) Slog.w(TAG, "Setting mWindowManagerDrawComplete");
635                    finishWindowsDrawn();
636                    break;
637                case MSG_HIDE_BOOT_MESSAGE:
638                    handleHideBootMessage();
639                    break;
640                case MSG_LAUNCH_VOICE_ASSIST_WITH_WAKE_LOCK:
641                    launchVoiceAssistWithWakeLock(msg.arg1 != 0);
642                    break;
643                case MSG_POWER_DELAYED_PRESS:
644                    powerPress((Long)msg.obj, msg.arg1 != 0, msg.arg2);
645                    finishPowerKeyPress();
646                    break;
647                case MSG_POWER_LONG_PRESS:
648                    powerLongPress();
649                    break;
650            }
651        }
652    }
653
654    private UEventObserver mHDMIObserver = new UEventObserver() {
655        @Override
656        public void onUEvent(UEventObserver.UEvent event) {
657            setHdmiPlugged("1".equals(event.get("SWITCH_STATE")));
658        }
659    };
660
661    class SettingsObserver extends ContentObserver {
662        SettingsObserver(Handler handler) {
663            super(handler);
664        }
665
666        void observe() {
667            // Observe all users' changes
668            ContentResolver resolver = mContext.getContentResolver();
669            resolver.registerContentObserver(Settings.System.getUriFor(
670                    Settings.System.END_BUTTON_BEHAVIOR), false, this,
671                    UserHandle.USER_ALL);
672            resolver.registerContentObserver(Settings.Secure.getUriFor(
673                    Settings.Secure.INCALL_POWER_BUTTON_BEHAVIOR), false, this,
674                    UserHandle.USER_ALL);
675            resolver.registerContentObserver(Settings.Secure.getUriFor(
676                    Settings.Secure.WAKE_GESTURE_ENABLED), false, this,
677                    UserHandle.USER_ALL);
678            resolver.registerContentObserver(Settings.System.getUriFor(
679                    Settings.System.ACCELEROMETER_ROTATION), false, this,
680                    UserHandle.USER_ALL);
681            resolver.registerContentObserver(Settings.System.getUriFor(
682                    Settings.System.USER_ROTATION), false, this,
683                    UserHandle.USER_ALL);
684            resolver.registerContentObserver(Settings.System.getUriFor(
685                    Settings.System.SCREEN_OFF_TIMEOUT), false, this,
686                    UserHandle.USER_ALL);
687            resolver.registerContentObserver(Settings.System.getUriFor(
688                    Settings.System.POINTER_LOCATION), false, this,
689                    UserHandle.USER_ALL);
690            resolver.registerContentObserver(Settings.Secure.getUriFor(
691                    Settings.Secure.DEFAULT_INPUT_METHOD), false, this,
692                    UserHandle.USER_ALL);
693            resolver.registerContentObserver(Settings.Secure.getUriFor(
694                    Settings.Secure.IMMERSIVE_MODE_CONFIRMATIONS), false, this,
695                    UserHandle.USER_ALL);
696            resolver.registerContentObserver(Settings.Global.getUriFor(
697                    Settings.Global.POLICY_CONTROL), false, this,
698                    UserHandle.USER_ALL);
699            updateSettings();
700        }
701
702        @Override public void onChange(boolean selfChange) {
703            updateSettings();
704            updateRotation(false);
705        }
706    }
707
708    class MyWakeGestureListener extends WakeGestureListener {
709        MyWakeGestureListener(Context context, Handler handler) {
710            super(context, handler);
711        }
712
713        @Override
714        public void onWakeUp() {
715            synchronized (mLock) {
716                if (shouldEnableWakeGestureLp()) {
717                    performHapticFeedbackLw(null, HapticFeedbackConstants.VIRTUAL_KEY, false);
718                    wakeUp(SystemClock.uptimeMillis(), mAllowTheaterModeWakeFromWakeGesture);
719                }
720            }
721        }
722    }
723
724    class MyOrientationListener extends WindowOrientationListener {
725        MyOrientationListener(Context context, Handler handler) {
726            super(context, handler);
727        }
728
729        @Override
730        public void onProposedRotationChanged(int rotation) {
731            if (localLOGV) Slog.v(TAG, "onProposedRotationChanged, rotation=" + rotation);
732            updateRotation(false);
733        }
734    }
735    MyOrientationListener mOrientationListener;
736
737    private final StatusBarController mStatusBarController = new StatusBarController();
738
739    private final BarController mNavigationBarController = new BarController("NavigationBar",
740            View.NAVIGATION_BAR_TRANSIENT,
741            View.NAVIGATION_BAR_UNHIDE,
742            View.NAVIGATION_BAR_TRANSLUCENT,
743            StatusBarManager.WINDOW_NAVIGATION_BAR,
744            WindowManager.LayoutParams.FLAG_TRANSLUCENT_NAVIGATION);
745
746    private ImmersiveModeConfirmation mImmersiveModeConfirmation;
747
748    private SystemGesturesPointerEventListener mSystemGestures;
749
750    IStatusBarService getStatusBarService() {
751        synchronized (mServiceAquireLock) {
752            if (mStatusBarService == null) {
753                mStatusBarService = IStatusBarService.Stub.asInterface(
754                        ServiceManager.getService("statusbar"));
755            }
756            return mStatusBarService;
757        }
758    }
759
760    /*
761     * We always let the sensor be switched on by default except when
762     * the user has explicitly disabled sensor based rotation or when the
763     * screen is switched off.
764     */
765    boolean needSensorRunningLp() {
766        if (mSupportAutoRotation) {
767            if (mCurrentAppOrientation == ActivityInfo.SCREEN_ORIENTATION_SENSOR
768                    || mCurrentAppOrientation == ActivityInfo.SCREEN_ORIENTATION_FULL_SENSOR
769                    || mCurrentAppOrientation == ActivityInfo.SCREEN_ORIENTATION_SENSOR_PORTRAIT
770                    || mCurrentAppOrientation == ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE) {
771                // If the application has explicitly requested to follow the
772                // orientation, then we need to turn the sensor on.
773                return true;
774            }
775        }
776        if ((mCarDockEnablesAccelerometer && mDockMode == Intent.EXTRA_DOCK_STATE_CAR) ||
777                (mDeskDockEnablesAccelerometer && (mDockMode == Intent.EXTRA_DOCK_STATE_DESK
778                        || mDockMode == Intent.EXTRA_DOCK_STATE_LE_DESK
779                        || mDockMode == Intent.EXTRA_DOCK_STATE_HE_DESK))) {
780            // enable accelerometer if we are docked in a dock that enables accelerometer
781            // orientation management,
782            return true;
783        }
784        if (mUserRotationMode == USER_ROTATION_LOCKED) {
785            // If the setting for using the sensor by default is enabled, then
786            // we will always leave it on.  Note that the user could go to
787            // a window that forces an orientation that does not use the
788            // sensor and in theory we could turn it off... however, when next
789            // turning it on we won't have a good value for the current
790            // orientation for a little bit, which can cause orientation
791            // changes to lag, so we'd like to keep it always on.  (It will
792            // still be turned off when the screen is off.)
793            return false;
794        }
795        return mSupportAutoRotation;
796    }
797
798    /*
799     * Various use cases for invoking this function
800     * screen turning off, should always disable listeners if already enabled
801     * screen turned on and current app has sensor based orientation, enable listeners
802     * if not already enabled
803     * screen turned on and current app does not have sensor orientation, disable listeners if
804     * already enabled
805     * screen turning on and current app has sensor based orientation, enable listeners if needed
806     * screen turning on and current app has nosensor based orientation, do nothing
807     */
808    void updateOrientationListenerLp() {
809        if (!mOrientationListener.canDetectOrientation()) {
810            // If sensor is turned off or nonexistent for some reason
811            return;
812        }
813        //Could have been invoked due to screen turning on or off or
814        //change of the currently visible window's orientation
815        if (localLOGV) Slog.v(TAG, "mScreenOnEarly=" + mScreenOnEarly
816                + ", mAwake=" + mAwake + ", mCurrentAppOrientation=" + mCurrentAppOrientation
817                + ", mOrientationSensorEnabled=" + mOrientationSensorEnabled);
818        boolean disable = true;
819        if (mScreenOnEarly && mAwake) {
820            if (needSensorRunningLp()) {
821                disable = false;
822                //enable listener if not already enabled
823                if (!mOrientationSensorEnabled) {
824                    mOrientationListener.enable();
825                    if(localLOGV) Slog.v(TAG, "Enabling listeners");
826                    mOrientationSensorEnabled = true;
827                }
828            }
829        }
830        //check if sensors need to be disabled
831        if (disable && mOrientationSensorEnabled) {
832            mOrientationListener.disable();
833            if(localLOGV) Slog.v(TAG, "Disabling listeners");
834            mOrientationSensorEnabled = false;
835        }
836    }
837
838    private void interceptPowerKeyDown(KeyEvent event, boolean interactive) {
839        // Hold a wake lock until the power key is released.
840        if (!mPowerKeyWakeLock.isHeld()) {
841            mPowerKeyWakeLock.acquire();
842        }
843
844        // Cancel multi-press detection timeout.
845        if (mPowerKeyPressCounter != 0) {
846            mHandler.removeMessages(MSG_POWER_DELAYED_PRESS);
847        }
848
849        // Detect user pressing the power button in panic when an application has
850        // taken over the whole screen.
851        boolean panic = mImmersiveModeConfirmation.onPowerKeyDown(interactive,
852                SystemClock.elapsedRealtime(), isImmersiveMode(mLastSystemUiFlags));
853        if (panic) {
854            mHandler.post(mRequestTransientNav);
855        }
856
857        // Latch power key state to detect screenshot chord.
858        if (interactive && !mScreenshotChordPowerKeyTriggered
859                && (event.getFlags() & KeyEvent.FLAG_FALLBACK) == 0) {
860            mScreenshotChordPowerKeyTriggered = true;
861            mScreenshotChordPowerKeyTime = event.getDownTime();
862            interceptScreenshotChord();
863        }
864
865        // Stop ringing or end call if configured to do so when power is pressed.
866        TelecomManager telecomManager = getTelecommService();
867        boolean hungUp = false;
868        if (telecomManager != null) {
869            if (telecomManager.isRinging()) {
870                // Pressing Power while there's a ringing incoming
871                // call should silence the ringer.
872                telecomManager.silenceRinger();
873            } else if ((mIncallPowerBehavior
874                    & Settings.Secure.INCALL_POWER_BUTTON_BEHAVIOR_HANGUP) != 0
875                    && telecomManager.isInCall() && interactive) {
876                // Otherwise, if "Power button ends call" is enabled,
877                // the Power button will hang up any current active call.
878                hungUp = telecomManager.endCall();
879            }
880        }
881
882        // If the power key has still not yet been handled, then detect short
883        // press, long press, or multi press and decide what to do.
884        mPowerKeyHandled = hungUp || mScreenshotChordVolumeDownKeyTriggered
885                || mScreenshotChordVolumeUpKeyTriggered;
886        if (!mPowerKeyHandled) {
887            if (interactive) {
888                // When interactive, we're already awake.
889                // Wait for a long press or for the button to be released to decide what to do.
890                if (hasLongPressOnPowerBehavior()) {
891                    Message msg = mHandler.obtainMessage(MSG_POWER_LONG_PRESS);
892                    msg.setAsynchronous(true);
893                    mHandler.sendMessageDelayed(msg,
894                            ViewConfiguration.get(mContext).getDeviceGlobalActionKeyTimeout());
895                }
896            } else {
897                wakeUpFromPowerKey(event.getDownTime());
898
899                if (mSupportLongPressPowerWhenNonInteractive && hasLongPressOnPowerBehavior()) {
900                    Message msg = mHandler.obtainMessage(MSG_POWER_LONG_PRESS);
901                    msg.setAsynchronous(true);
902                    mHandler.sendMessageDelayed(msg,
903                            ViewConfiguration.get(mContext).getDeviceGlobalActionKeyTimeout());
904                    mBeganFromNonInteractive = true;
905                } else {
906                    final int maxCount = getMaxMultiPressPowerCount();
907
908                    if (maxCount <= 1) {
909                        mPowerKeyHandled = true;
910                    } else {
911                        mBeganFromNonInteractive = true;
912                    }
913                }
914            }
915        }
916    }
917
918    private void interceptPowerKeyUp(KeyEvent event, boolean interactive, boolean canceled) {
919        final boolean handled = canceled || mPowerKeyHandled;
920        mScreenshotChordPowerKeyTriggered = false;
921        cancelPendingScreenshotChordAction();
922        cancelPendingPowerKeyAction();
923
924        if (!handled) {
925            // Figure out how to handle the key now that it has been released.
926            mPowerKeyPressCounter += 1;
927
928            final int maxCount = getMaxMultiPressPowerCount();
929            final long eventTime = event.getDownTime();
930            if (mPowerKeyPressCounter < maxCount) {
931                // This could be a multi-press.  Wait a little bit longer to confirm.
932                // Continue holding the wake lock.
933                Message msg = mHandler.obtainMessage(MSG_POWER_DELAYED_PRESS,
934                        interactive ? 1 : 0, mPowerKeyPressCounter, eventTime);
935                msg.setAsynchronous(true);
936                mHandler.sendMessageDelayed(msg, ViewConfiguration.getDoubleTapTimeout());
937                return;
938            }
939
940            // No other actions.  Handle it immediately.
941            powerPress(eventTime, interactive, mPowerKeyPressCounter);
942        }
943
944        // Done.  Reset our state.
945        finishPowerKeyPress();
946    }
947
948    private void finishPowerKeyPress() {
949        mBeganFromNonInteractive = false;
950        mPowerKeyPressCounter = 0;
951        if (mPowerKeyWakeLock.isHeld()) {
952            mPowerKeyWakeLock.release();
953        }
954    }
955
956    private void cancelPendingPowerKeyAction() {
957        if (!mPowerKeyHandled) {
958            mPowerKeyHandled = true;
959            mHandler.removeMessages(MSG_POWER_LONG_PRESS);
960        }
961    }
962
963    private void powerPress(long eventTime, boolean interactive, int count) {
964        if (mScreenOnEarly && !mScreenOnFully) {
965            Slog.i(TAG, "Suppressed redundant power key press while "
966                    + "already in the process of turning the screen on.");
967            return;
968        }
969
970        if (count == 2) {
971            powerMultiPressAction(eventTime, interactive, mDoublePressOnPowerBehavior);
972        } else if (count == 3) {
973            powerMultiPressAction(eventTime, interactive, mTriplePressOnPowerBehavior);
974        } else if (interactive && !mBeganFromNonInteractive) {
975            switch (mShortPressOnPowerBehavior) {
976                case SHORT_PRESS_POWER_NOTHING:
977                    break;
978                case SHORT_PRESS_POWER_GO_TO_SLEEP:
979                    mPowerManager.goToSleep(eventTime,
980                            PowerManager.GO_TO_SLEEP_REASON_POWER_BUTTON, 0);
981                    break;
982                case SHORT_PRESS_POWER_REALLY_GO_TO_SLEEP:
983                    mPowerManager.goToSleep(eventTime,
984                            PowerManager.GO_TO_SLEEP_REASON_POWER_BUTTON,
985                            PowerManager.GO_TO_SLEEP_FLAG_NO_DOZE);
986                    break;
987                case SHORT_PRESS_POWER_REALLY_GO_TO_SLEEP_AND_GO_HOME:
988                    mPowerManager.goToSleep(eventTime,
989                            PowerManager.GO_TO_SLEEP_REASON_POWER_BUTTON,
990                            PowerManager.GO_TO_SLEEP_FLAG_NO_DOZE);
991                    launchHomeFromHotKey();
992                    break;
993                case SHORT_PRESS_POWER_GO_HOME:
994                    launchHomeFromHotKey(true /* awakenFromDreams */, false /*respectKeyguard*/);
995                    break;
996            }
997        }
998    }
999
1000    private void powerMultiPressAction(long eventTime, boolean interactive, int behavior) {
1001        switch (behavior) {
1002            case MULTI_PRESS_POWER_NOTHING:
1003                break;
1004            case MULTI_PRESS_POWER_THEATER_MODE:
1005                if (isTheaterModeEnabled()) {
1006                    Slog.i(TAG, "Toggling theater mode off.");
1007                    Settings.Global.putInt(mContext.getContentResolver(),
1008                            Settings.Global.THEATER_MODE_ON, 0);
1009                    if (!interactive) {
1010                        wakeUpFromPowerKey(eventTime);
1011                    }
1012                } else {
1013                    Slog.i(TAG, "Toggling theater mode on.");
1014                    Settings.Global.putInt(mContext.getContentResolver(),
1015                            Settings.Global.THEATER_MODE_ON, 1);
1016
1017                    if (mGoToSleepOnButtonPressTheaterMode && interactive) {
1018                        mPowerManager.goToSleep(eventTime,
1019                                PowerManager.GO_TO_SLEEP_REASON_POWER_BUTTON, 0);
1020                    }
1021                }
1022                break;
1023            case MULTI_PRESS_POWER_BRIGHTNESS_BOOST:
1024                Slog.i(TAG, "Starting brightness boost.");
1025                if (!interactive) {
1026                    wakeUpFromPowerKey(eventTime);
1027                }
1028                mPowerManager.boostScreenBrightness(eventTime);
1029                break;
1030        }
1031    }
1032
1033    private int getMaxMultiPressPowerCount() {
1034        if (mTriplePressOnPowerBehavior != MULTI_PRESS_POWER_NOTHING) {
1035            return 3;
1036        }
1037        if (mDoublePressOnPowerBehavior != MULTI_PRESS_POWER_NOTHING) {
1038            return 2;
1039        }
1040        return 1;
1041    }
1042
1043    private void powerLongPress() {
1044        final int behavior = getResolvedLongPressOnPowerBehavior();
1045        switch (behavior) {
1046        case LONG_PRESS_POWER_NOTHING:
1047            break;
1048        case LONG_PRESS_POWER_GLOBAL_ACTIONS:
1049            mPowerKeyHandled = true;
1050            if (!performHapticFeedbackLw(null, HapticFeedbackConstants.LONG_PRESS, false)) {
1051                performAuditoryFeedbackForAccessibilityIfNeed();
1052            }
1053            showGlobalActionsInternal();
1054            break;
1055        case LONG_PRESS_POWER_SHUT_OFF:
1056        case LONG_PRESS_POWER_SHUT_OFF_NO_CONFIRM:
1057            mPowerKeyHandled = true;
1058            performHapticFeedbackLw(null, HapticFeedbackConstants.LONG_PRESS, false);
1059            sendCloseSystemWindows(SYSTEM_DIALOG_REASON_GLOBAL_ACTIONS);
1060            mWindowManagerFuncs.shutdown(behavior == LONG_PRESS_POWER_SHUT_OFF);
1061            break;
1062        }
1063    }
1064
1065    private void sleepPress(KeyEvent event) {
1066        switch (mShortPressOnSleepBehavior) {
1067            case SHORT_PRESS_SLEEP_GO_TO_SLEEP:
1068                mPowerManager.goToSleep(event.getEventTime(),
1069                        PowerManager.GO_TO_SLEEP_REASON_SLEEP_BUTTON, 0);
1070                break;
1071            case SHORT_PRESS_SLEEP_GO_TO_SLEEP_AND_GO_HOME:
1072                launchHomeFromHotKey(false /* awakenDreams */, true /*respectKeyguard*/);
1073                mPowerManager.goToSleep(event.getEventTime(),
1074                        PowerManager.GO_TO_SLEEP_REASON_SLEEP_BUTTON, 0);
1075                break;
1076        }
1077    }
1078
1079    private int getResolvedLongPressOnPowerBehavior() {
1080        if (FactoryTest.isLongPressOnPowerOffEnabled()) {
1081            return LONG_PRESS_POWER_SHUT_OFF_NO_CONFIRM;
1082        }
1083        return mLongPressOnPowerBehavior;
1084    }
1085
1086    private boolean hasLongPressOnPowerBehavior() {
1087        return getResolvedLongPressOnPowerBehavior() != LONG_PRESS_POWER_NOTHING;
1088    }
1089
1090    private void interceptScreenshotChord() {
1091        if (mScreenshotChordEnabled
1092                && mScreenshotChordVolumeDownKeyTriggered && mScreenshotChordPowerKeyTriggered
1093                && !mScreenshotChordVolumeUpKeyTriggered) {
1094            final long now = SystemClock.uptimeMillis();
1095            if (now <= mScreenshotChordVolumeDownKeyTime + SCREENSHOT_CHORD_DEBOUNCE_DELAY_MILLIS
1096                    && now <= mScreenshotChordPowerKeyTime
1097                            + SCREENSHOT_CHORD_DEBOUNCE_DELAY_MILLIS) {
1098                mScreenshotChordVolumeDownKeyConsumed = true;
1099                cancelPendingPowerKeyAction();
1100
1101                mHandler.postDelayed(mScreenshotRunnable, getScreenshotChordLongPressDelay());
1102            }
1103        }
1104    }
1105
1106    private long getScreenshotChordLongPressDelay() {
1107        if (mKeyguardDelegate.isShowing()) {
1108            // Double the time it takes to take a screenshot from the keyguard
1109            return (long) (KEYGUARD_SCREENSHOT_CHORD_DELAY_MULTIPLIER *
1110                    ViewConfiguration.get(mContext).getDeviceGlobalActionKeyTimeout());
1111        }
1112        return ViewConfiguration.get(mContext).getDeviceGlobalActionKeyTimeout();
1113    }
1114
1115    private void cancelPendingScreenshotChordAction() {
1116        mHandler.removeCallbacks(mScreenshotRunnable);
1117    }
1118
1119    private final Runnable mEndCallLongPress = new Runnable() {
1120        @Override
1121        public void run() {
1122            mEndCallKeyHandled = true;
1123            if (!performHapticFeedbackLw(null, HapticFeedbackConstants.LONG_PRESS, false)) {
1124                performAuditoryFeedbackForAccessibilityIfNeed();
1125            }
1126            showGlobalActionsInternal();
1127        }
1128    };
1129
1130    private final Runnable mScreenshotRunnable = new Runnable() {
1131        @Override
1132        public void run() {
1133            takeScreenshot();
1134        }
1135    };
1136
1137    @Override
1138    public void showGlobalActions() {
1139        mHandler.removeMessages(MSG_DISPATCH_SHOW_GLOBAL_ACTIONS);
1140        mHandler.sendEmptyMessage(MSG_DISPATCH_SHOW_GLOBAL_ACTIONS);
1141    }
1142
1143    void showGlobalActionsInternal() {
1144        sendCloseSystemWindows(SYSTEM_DIALOG_REASON_GLOBAL_ACTIONS);
1145        if (mGlobalActions == null) {
1146            mGlobalActions = new GlobalActions(mContext, mWindowManagerFuncs);
1147        }
1148        final boolean keyguardShowing = isKeyguardShowingAndNotOccluded();
1149        mGlobalActions.showDialog(keyguardShowing, isDeviceProvisioned());
1150        if (keyguardShowing) {
1151            // since it took two seconds of long press to bring this up,
1152            // poke the wake lock so they have some time to see the dialog.
1153            mPowerManager.userActivity(SystemClock.uptimeMillis(), false);
1154        }
1155    }
1156
1157    boolean isDeviceProvisioned() {
1158        return Settings.Global.getInt(
1159                mContext.getContentResolver(), Settings.Global.DEVICE_PROVISIONED, 0) != 0;
1160    }
1161
1162    boolean isUserSetupComplete() {
1163        return Settings.Secure.getIntForUser(mContext.getContentResolver(),
1164                Settings.Secure.USER_SETUP_COMPLETE, 0, UserHandle.USER_CURRENT) != 0;
1165    }
1166
1167    private void handleShortPressOnHome() {
1168        // If there's a dream running then use home to escape the dream
1169        // but don't actually go home.
1170        if (mDreamManagerInternal != null && mDreamManagerInternal.isDreaming()) {
1171            mDreamManagerInternal.stopDream(false /*immediate*/);
1172            return;
1173        }
1174
1175        // Go home!
1176        launchHomeFromHotKey();
1177    }
1178
1179    private void handleLongPressOnHome() {
1180        if (mLongPressOnHomeBehavior != LONG_PRESS_HOME_NOTHING) {
1181            mHomeConsumed = true;
1182            performHapticFeedbackLw(null, HapticFeedbackConstants.LONG_PRESS, false);
1183
1184            if (mLongPressOnHomeBehavior == LONG_PRESS_HOME_RECENT_SYSTEM_UI) {
1185                toggleRecentApps();
1186            } else if (mLongPressOnHomeBehavior == LONG_PRESS_HOME_ASSIST) {
1187                launchAssistAction();
1188            }
1189        }
1190    }
1191
1192    private void handleDoubleTapOnHome() {
1193        if (mDoubleTapOnHomeBehavior == DOUBLE_TAP_HOME_RECENT_SYSTEM_UI) {
1194            mHomeConsumed = true;
1195            toggleRecentApps();
1196        }
1197    }
1198
1199    private final Runnable mHomeDoubleTapTimeoutRunnable = new Runnable() {
1200        @Override
1201        public void run() {
1202            if (mHomeDoubleTapPending) {
1203                mHomeDoubleTapPending = false;
1204                handleShortPressOnHome();
1205            }
1206        }
1207    };
1208
1209    private boolean isRoundWindow() {
1210        return mContext.getResources().getBoolean(com.android.internal.R.bool.config_windowIsRound)
1211                || (Build.HARDWARE.contains("goldfish")
1212                && SystemProperties.getBoolean(ViewRootImpl.PROPERTY_EMULATOR_CIRCULAR, false));
1213    }
1214
1215    /** {@inheritDoc} */
1216    @Override
1217    public void init(Context context, IWindowManager windowManager,
1218            WindowManagerFuncs windowManagerFuncs) {
1219        mContext = context;
1220        mWindowManager = windowManager;
1221        mWindowManagerFuncs = windowManagerFuncs;
1222        mWindowManagerInternal = LocalServices.getService(WindowManagerInternal.class);
1223        mDreamManagerInternal = LocalServices.getService(DreamManagerInternal.class);
1224
1225        // Init display burn-in protection
1226        boolean burnInProtectionEnabled = context.getResources().getBoolean(
1227                com.android.internal.R.bool.config_enableBurnInProtection);
1228        // Allow a system property to override this. Used by developer settings.
1229        boolean burnInProtectionDevMode =
1230                SystemProperties.getBoolean("persist.debug.force_burn_in", false);
1231        if (burnInProtectionEnabled || burnInProtectionDevMode) {
1232            final int minHorizontal;
1233            final int maxHorizontal;
1234            final int minVertical;
1235            final int maxVertical;
1236            final int maxRadius;
1237            if (burnInProtectionDevMode) {
1238                minHorizontal = -8;
1239                maxHorizontal = 8;
1240                minVertical = -8;
1241                maxVertical = -4;
1242                maxRadius = (isRoundWindow()) ? 6 : -1;
1243            } else {
1244                Resources resources = context.getResources();
1245                minHorizontal = resources.getInteger(
1246                        com.android.internal.R.integer.config_burnInProtectionMinHorizontalOffset);
1247                maxHorizontal = resources.getInteger(
1248                        com.android.internal.R.integer.config_burnInProtectionMaxHorizontalOffset);
1249                minVertical = resources.getInteger(
1250                        com.android.internal.R.integer.config_burnInProtectionMinVerticalOffset);
1251                maxVertical = resources.getInteger(
1252                        com.android.internal.R.integer.config_burnInProtectionMaxVerticalOffset);
1253                maxRadius = resources.getInteger(
1254                        com.android.internal.R.integer.config_burnInProtectionMaxRadius);
1255            }
1256            mBurnInProtectionHelper = new BurnInProtectionHelper(
1257                    context, minHorizontal, maxHorizontal, minVertical, maxVertical, maxRadius);
1258        }
1259
1260        mHandler = new PolicyHandler();
1261        mWakeGestureListener = new MyWakeGestureListener(mContext, mHandler);
1262        mOrientationListener = new MyOrientationListener(mContext, mHandler);
1263        try {
1264            mOrientationListener.setCurrentRotation(windowManager.getRotation());
1265        } catch (RemoteException ex) { }
1266        mSettingsObserver = new SettingsObserver(mHandler);
1267        mSettingsObserver.observe();
1268        mShortcutManager = new ShortcutManager(context);
1269        mUiMode = context.getResources().getInteger(
1270                com.android.internal.R.integer.config_defaultUiModeType);
1271        mHomeIntent =  new Intent(Intent.ACTION_MAIN, null);
1272        mHomeIntent.addCategory(Intent.CATEGORY_HOME);
1273        mHomeIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK
1274                | Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED);
1275        mCarDockIntent =  new Intent(Intent.ACTION_MAIN, null);
1276        mCarDockIntent.addCategory(Intent.CATEGORY_CAR_DOCK);
1277        mCarDockIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK
1278                | Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED);
1279        mDeskDockIntent =  new Intent(Intent.ACTION_MAIN, null);
1280        mDeskDockIntent.addCategory(Intent.CATEGORY_DESK_DOCK);
1281        mDeskDockIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK
1282                | Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED);
1283
1284        mPowerManager = (PowerManager)context.getSystemService(Context.POWER_SERVICE);
1285        mBroadcastWakeLock = mPowerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK,
1286                "PhoneWindowManager.mBroadcastWakeLock");
1287        mPowerKeyWakeLock = mPowerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK,
1288                "PhoneWindowManager.mPowerKeyWakeLock");
1289        mEnableShiftMenuBugReports = "1".equals(SystemProperties.get("ro.debuggable"));
1290        mSupportAutoRotation = mContext.getResources().getBoolean(
1291                com.android.internal.R.bool.config_supportAutoRotation);
1292        mLidOpenRotation = readRotation(
1293                com.android.internal.R.integer.config_lidOpenRotation);
1294        mCarDockRotation = readRotation(
1295                com.android.internal.R.integer.config_carDockRotation);
1296        mDeskDockRotation = readRotation(
1297                com.android.internal.R.integer.config_deskDockRotation);
1298        mUndockedHdmiRotation = readRotation(
1299                com.android.internal.R.integer.config_undockedHdmiRotation);
1300        mCarDockEnablesAccelerometer = mContext.getResources().getBoolean(
1301                com.android.internal.R.bool.config_carDockEnablesAccelerometer);
1302        mDeskDockEnablesAccelerometer = mContext.getResources().getBoolean(
1303                com.android.internal.R.bool.config_deskDockEnablesAccelerometer);
1304        mLidKeyboardAccessibility = mContext.getResources().getInteger(
1305                com.android.internal.R.integer.config_lidKeyboardAccessibility);
1306        mLidNavigationAccessibility = mContext.getResources().getInteger(
1307                com.android.internal.R.integer.config_lidNavigationAccessibility);
1308        mLidControlsSleep = mContext.getResources().getBoolean(
1309                com.android.internal.R.bool.config_lidControlsSleep);
1310        mTranslucentDecorEnabled = mContext.getResources().getBoolean(
1311                com.android.internal.R.bool.config_enableTranslucentDecor);
1312
1313        mAllowTheaterModeWakeFromKey = mContext.getResources().getBoolean(
1314                com.android.internal.R.bool.config_allowTheaterModeWakeFromKey);
1315        mAllowTheaterModeWakeFromPowerKey = mAllowTheaterModeWakeFromKey
1316                || mContext.getResources().getBoolean(
1317                    com.android.internal.R.bool.config_allowTheaterModeWakeFromPowerKey);
1318        mAllowTheaterModeWakeFromMotion = mContext.getResources().getBoolean(
1319                com.android.internal.R.bool.config_allowTheaterModeWakeFromMotion);
1320        mAllowTheaterModeWakeFromMotionWhenNotDreaming = mContext.getResources().getBoolean(
1321                com.android.internal.R.bool.config_allowTheaterModeWakeFromMotionWhenNotDreaming);
1322        mAllowTheaterModeWakeFromCameraLens = mContext.getResources().getBoolean(
1323                com.android.internal.R.bool.config_allowTheaterModeWakeFromCameraLens);
1324        mAllowTheaterModeWakeFromLidSwitch = mContext.getResources().getBoolean(
1325                com.android.internal.R.bool.config_allowTheaterModeWakeFromLidSwitch);
1326        mAllowTheaterModeWakeFromWakeGesture = mContext.getResources().getBoolean(
1327                com.android.internal.R.bool.config_allowTheaterModeWakeFromGesture);
1328
1329        mGoToSleepOnButtonPressTheaterMode = mContext.getResources().getBoolean(
1330                com.android.internal.R.bool.config_goToSleepOnButtonPressTheaterMode);
1331
1332        mSupportLongPressPowerWhenNonInteractive = mContext.getResources().getBoolean(
1333                com.android.internal.R.bool.config_supportLongPressPowerWhenNonInteractive);
1334
1335        mShortPressOnPowerBehavior = mContext.getResources().getInteger(
1336                com.android.internal.R.integer.config_shortPressOnPowerBehavior);
1337        mLongPressOnPowerBehavior = mContext.getResources().getInteger(
1338                com.android.internal.R.integer.config_longPressOnPowerBehavior);
1339        mDoublePressOnPowerBehavior = mContext.getResources().getInteger(
1340                com.android.internal.R.integer.config_doublePressOnPowerBehavior);
1341        mTriplePressOnPowerBehavior = mContext.getResources().getInteger(
1342                com.android.internal.R.integer.config_triplePressOnPowerBehavior);
1343        mShortPressOnSleepBehavior = mContext.getResources().getInteger(
1344                com.android.internal.R.integer.config_shortPressOnSleepBehavior);
1345
1346        mUseTvRouting = AudioSystem.getPlatformType(mContext) == AudioSystem.PLATFORM_TELEVISION;
1347
1348        readConfigurationDependentBehaviors();
1349
1350        mAccessibilityManager = (AccessibilityManager) context.getSystemService(
1351                Context.ACCESSIBILITY_SERVICE);
1352
1353        // register for dock events
1354        IntentFilter filter = new IntentFilter();
1355        filter.addAction(UiModeManager.ACTION_ENTER_CAR_MODE);
1356        filter.addAction(UiModeManager.ACTION_EXIT_CAR_MODE);
1357        filter.addAction(UiModeManager.ACTION_ENTER_DESK_MODE);
1358        filter.addAction(UiModeManager.ACTION_EXIT_DESK_MODE);
1359        filter.addAction(Intent.ACTION_DOCK_EVENT);
1360        Intent intent = context.registerReceiver(mDockReceiver, filter);
1361        if (intent != null) {
1362            // Retrieve current sticky dock event broadcast.
1363            mDockMode = intent.getIntExtra(Intent.EXTRA_DOCK_STATE,
1364                    Intent.EXTRA_DOCK_STATE_UNDOCKED);
1365        }
1366
1367        // register for dream-related broadcasts
1368        filter = new IntentFilter();
1369        filter.addAction(Intent.ACTION_DREAMING_STARTED);
1370        filter.addAction(Intent.ACTION_DREAMING_STOPPED);
1371        context.registerReceiver(mDreamReceiver, filter);
1372
1373        // register for multiuser-relevant broadcasts
1374        filter = new IntentFilter(Intent.ACTION_USER_SWITCHED);
1375        context.registerReceiver(mMultiuserReceiver, filter);
1376
1377        // monitor for system gestures
1378        mSystemGestures = new SystemGesturesPointerEventListener(context,
1379                new SystemGesturesPointerEventListener.Callbacks() {
1380                    @Override
1381                    public void onSwipeFromTop() {
1382                        if (mStatusBar != null) {
1383                            requestTransientBars(mStatusBar);
1384                        }
1385                    }
1386                    @Override
1387                    public void onSwipeFromBottom() {
1388                        if (mNavigationBar != null && mNavigationBarOnBottom) {
1389                            requestTransientBars(mNavigationBar);
1390                        }
1391                    }
1392                    @Override
1393                    public void onSwipeFromRight() {
1394                        if (mNavigationBar != null && !mNavigationBarOnBottom) {
1395                            requestTransientBars(mNavigationBar);
1396                        }
1397                    }
1398                    @Override
1399                    public void onDebug() {
1400                        // no-op
1401                    }
1402                    @Override
1403                    public void onDown() {
1404                        mOrientationListener.onTouchStart();
1405                    }
1406                    @Override
1407                    public void onUpOrCancel() {
1408                        mOrientationListener.onTouchEnd();
1409                    }
1410                });
1411        mImmersiveModeConfirmation = new ImmersiveModeConfirmation(mContext);
1412        mWindowManagerFuncs.registerPointerEventListener(mSystemGestures);
1413
1414        mVibrator = (Vibrator)context.getSystemService(Context.VIBRATOR_SERVICE);
1415        mLongPressVibePattern = getLongIntArray(mContext.getResources(),
1416                com.android.internal.R.array.config_longPressVibePattern);
1417        mVirtualKeyVibePattern = getLongIntArray(mContext.getResources(),
1418                com.android.internal.R.array.config_virtualKeyVibePattern);
1419        mKeyboardTapVibePattern = getLongIntArray(mContext.getResources(),
1420                com.android.internal.R.array.config_keyboardTapVibePattern);
1421        mClockTickVibePattern = getLongIntArray(mContext.getResources(),
1422                com.android.internal.R.array.config_clockTickVibePattern);
1423        mCalendarDateVibePattern = getLongIntArray(mContext.getResources(),
1424                com.android.internal.R.array.config_calendarDateVibePattern);
1425        mSafeModeDisabledVibePattern = getLongIntArray(mContext.getResources(),
1426                com.android.internal.R.array.config_safeModeDisabledVibePattern);
1427        mSafeModeEnabledVibePattern = getLongIntArray(mContext.getResources(),
1428                com.android.internal.R.array.config_safeModeEnabledVibePattern);
1429
1430        mScreenshotChordEnabled = mContext.getResources().getBoolean(
1431                com.android.internal.R.bool.config_enableScreenshotChord);
1432
1433        mGlobalKeyManager = new GlobalKeyManager(mContext);
1434
1435        // Controls rotation and the like.
1436        initializeHdmiState();
1437
1438        // Match current screen state.
1439        if (!mPowerManager.isInteractive()) {
1440            goingToSleep(WindowManagerPolicy.OFF_BECAUSE_OF_USER);
1441        }
1442
1443        mWindowManagerInternal.registerAppTransitionListener(
1444                mStatusBarController.getAppTransitionListener());
1445    }
1446
1447    /**
1448     * Read values from config.xml that may be overridden depending on
1449     * the configuration of the device.
1450     * eg. Disable long press on home goes to recents on sw600dp.
1451     */
1452    private void readConfigurationDependentBehaviors() {
1453        mLongPressOnHomeBehavior = mContext.getResources().getInteger(
1454                com.android.internal.R.integer.config_longPressOnHomeBehavior);
1455        if (mLongPressOnHomeBehavior < LONG_PRESS_HOME_NOTHING ||
1456                mLongPressOnHomeBehavior > LONG_PRESS_HOME_ASSIST) {
1457            mLongPressOnHomeBehavior = LONG_PRESS_HOME_NOTHING;
1458        }
1459
1460        mDoubleTapOnHomeBehavior = mContext.getResources().getInteger(
1461                com.android.internal.R.integer.config_doubleTapOnHomeBehavior);
1462        if (mDoubleTapOnHomeBehavior < DOUBLE_TAP_HOME_NOTHING ||
1463                mDoubleTapOnHomeBehavior > DOUBLE_TAP_HOME_RECENT_SYSTEM_UI) {
1464            mDoubleTapOnHomeBehavior = LONG_PRESS_HOME_NOTHING;
1465        }
1466    }
1467
1468    @Override
1469    public void setInitialDisplaySize(Display display, int width, int height, int density) {
1470        // This method might be called before the policy has been fully initialized
1471        // or for other displays we don't care about.
1472        if (mContext == null || display.getDisplayId() != Display.DEFAULT_DISPLAY) {
1473            return;
1474        }
1475        mDisplay = display;
1476
1477        final Resources res = mContext.getResources();
1478        int shortSize, longSize;
1479        if (width > height) {
1480            shortSize = height;
1481            longSize = width;
1482            mLandscapeRotation = Surface.ROTATION_0;
1483            mSeascapeRotation = Surface.ROTATION_180;
1484            if (res.getBoolean(com.android.internal.R.bool.config_reverseDefaultRotation)) {
1485                mPortraitRotation = Surface.ROTATION_90;
1486                mUpsideDownRotation = Surface.ROTATION_270;
1487            } else {
1488                mPortraitRotation = Surface.ROTATION_270;
1489                mUpsideDownRotation = Surface.ROTATION_90;
1490            }
1491        } else {
1492            shortSize = width;
1493            longSize = height;
1494            mPortraitRotation = Surface.ROTATION_0;
1495            mUpsideDownRotation = Surface.ROTATION_180;
1496            if (res.getBoolean(com.android.internal.R.bool.config_reverseDefaultRotation)) {
1497                mLandscapeRotation = Surface.ROTATION_270;
1498                mSeascapeRotation = Surface.ROTATION_90;
1499            } else {
1500                mLandscapeRotation = Surface.ROTATION_90;
1501                mSeascapeRotation = Surface.ROTATION_270;
1502            }
1503        }
1504
1505        mStatusBarHeight =
1506                res.getDimensionPixelSize(com.android.internal.R.dimen.status_bar_height);
1507
1508        // Height of the navigation bar when presented horizontally at bottom
1509        mNavigationBarHeightForRotation[mPortraitRotation] =
1510        mNavigationBarHeightForRotation[mUpsideDownRotation] =
1511                res.getDimensionPixelSize(com.android.internal.R.dimen.navigation_bar_height);
1512        mNavigationBarHeightForRotation[mLandscapeRotation] =
1513        mNavigationBarHeightForRotation[mSeascapeRotation] = res.getDimensionPixelSize(
1514                com.android.internal.R.dimen.navigation_bar_height_landscape);
1515
1516        // Width of the navigation bar when presented vertically along one side
1517        mNavigationBarWidthForRotation[mPortraitRotation] =
1518        mNavigationBarWidthForRotation[mUpsideDownRotation] =
1519        mNavigationBarWidthForRotation[mLandscapeRotation] =
1520        mNavigationBarWidthForRotation[mSeascapeRotation] =
1521                res.getDimensionPixelSize(com.android.internal.R.dimen.navigation_bar_width);
1522
1523        // SystemUI (status bar) layout policy
1524        int shortSizeDp = shortSize * DisplayMetrics.DENSITY_DEFAULT / density;
1525        int longSizeDp = longSize * DisplayMetrics.DENSITY_DEFAULT / density;
1526
1527        // Allow the navigation bar to move on non-square small devices (phones).
1528        mNavigationBarCanMove = width != height && shortSizeDp < 600;
1529
1530        mHasNavigationBar = res.getBoolean(com.android.internal.R.bool.config_showNavigationBar);
1531        // Allow a system property to override this. Used by the emulator.
1532        // See also hasNavigationBar().
1533        String navBarOverride = SystemProperties.get("qemu.hw.mainkeys");
1534        if ("1".equals(navBarOverride)) {
1535            mHasNavigationBar = false;
1536        } else if ("0".equals(navBarOverride)) {
1537            mHasNavigationBar = true;
1538        }
1539
1540        // For demo purposes, allow the rotation of the HDMI display to be controlled.
1541        // By default, HDMI locks rotation to landscape.
1542        if ("portrait".equals(SystemProperties.get("persist.demo.hdmirotation"))) {
1543            mDemoHdmiRotation = mPortraitRotation;
1544        } else {
1545            mDemoHdmiRotation = mLandscapeRotation;
1546        }
1547        mDemoHdmiRotationLock = SystemProperties.getBoolean("persist.demo.hdmirotationlock", false);
1548
1549        // For demo purposes, allow the rotation of the remote display to be controlled.
1550        // By default, remote display locks rotation to landscape.
1551        if ("portrait".equals(SystemProperties.get("persist.demo.remoterotation"))) {
1552            mDemoRotation = mPortraitRotation;
1553        } else {
1554            mDemoRotation = mLandscapeRotation;
1555        }
1556        mDemoRotationLock = SystemProperties.getBoolean(
1557                "persist.demo.rotationlock", false);
1558
1559        // Only force the default orientation if the screen is xlarge, at least 960dp x 720dp, per
1560        // http://developer.android.com/guide/practices/screens_support.html#range
1561        mForceDefaultOrientation = longSizeDp >= 960 && shortSizeDp >= 720 &&
1562                res.getBoolean(com.android.internal.R.bool.config_forceDefaultOrientation) &&
1563                // For debug purposes the next line turns this feature off with:
1564                // $ adb shell setprop config.override_forced_orient true
1565                // $ adb shell wm size reset
1566                !"true".equals(SystemProperties.get("config.override_forced_orient"));
1567    }
1568
1569    /**
1570     * @return whether the navigation bar can be hidden, e.g. the device has a
1571     *         navigation bar and touch exploration is not enabled
1572     */
1573    private boolean canHideNavigationBar() {
1574        return mHasNavigationBar
1575                && !mAccessibilityManager.isTouchExplorationEnabled();
1576    }
1577
1578    @Override
1579    public boolean isDefaultOrientationForced() {
1580        return mForceDefaultOrientation;
1581    }
1582
1583    @Override
1584    public void setDisplayOverscan(Display display, int left, int top, int right, int bottom) {
1585        if (display.getDisplayId() == Display.DEFAULT_DISPLAY) {
1586            mOverscanLeft = left;
1587            mOverscanTop = top;
1588            mOverscanRight = right;
1589            mOverscanBottom = bottom;
1590        }
1591    }
1592
1593    public void updateSettings() {
1594        ContentResolver resolver = mContext.getContentResolver();
1595        boolean updateRotation = false;
1596        synchronized (mLock) {
1597            mEndcallBehavior = Settings.System.getIntForUser(resolver,
1598                    Settings.System.END_BUTTON_BEHAVIOR,
1599                    Settings.System.END_BUTTON_BEHAVIOR_DEFAULT,
1600                    UserHandle.USER_CURRENT);
1601            mIncallPowerBehavior = Settings.Secure.getIntForUser(resolver,
1602                    Settings.Secure.INCALL_POWER_BUTTON_BEHAVIOR,
1603                    Settings.Secure.INCALL_POWER_BUTTON_BEHAVIOR_DEFAULT,
1604                    UserHandle.USER_CURRENT);
1605
1606            // Configure wake gesture.
1607            boolean wakeGestureEnabledSetting = Settings.Secure.getIntForUser(resolver,
1608                    Settings.Secure.WAKE_GESTURE_ENABLED, 0,
1609                    UserHandle.USER_CURRENT) != 0;
1610            if (mWakeGestureEnabledSetting != wakeGestureEnabledSetting) {
1611                mWakeGestureEnabledSetting = wakeGestureEnabledSetting;
1612                updateWakeGestureListenerLp();
1613            }
1614
1615            // Configure rotation lock.
1616            int userRotation = Settings.System.getIntForUser(resolver,
1617                    Settings.System.USER_ROTATION, Surface.ROTATION_0,
1618                    UserHandle.USER_CURRENT);
1619            if (mUserRotation != userRotation) {
1620                mUserRotation = userRotation;
1621                updateRotation = true;
1622            }
1623            int userRotationMode = Settings.System.getIntForUser(resolver,
1624                    Settings.System.ACCELEROMETER_ROTATION, 0, UserHandle.USER_CURRENT) != 0 ?
1625                            WindowManagerPolicy.USER_ROTATION_FREE :
1626                                    WindowManagerPolicy.USER_ROTATION_LOCKED;
1627            if (mUserRotationMode != userRotationMode) {
1628                mUserRotationMode = userRotationMode;
1629                updateRotation = true;
1630                updateOrientationListenerLp();
1631            }
1632
1633            if (mSystemReady) {
1634                int pointerLocation = Settings.System.getIntForUser(resolver,
1635                        Settings.System.POINTER_LOCATION, 0, UserHandle.USER_CURRENT);
1636                if (mPointerLocationMode != pointerLocation) {
1637                    mPointerLocationMode = pointerLocation;
1638                    mHandler.sendEmptyMessage(pointerLocation != 0 ?
1639                            MSG_ENABLE_POINTER_LOCATION : MSG_DISABLE_POINTER_LOCATION);
1640                }
1641            }
1642            // use screen off timeout setting as the timeout for the lockscreen
1643            mLockScreenTimeout = Settings.System.getIntForUser(resolver,
1644                    Settings.System.SCREEN_OFF_TIMEOUT, 0, UserHandle.USER_CURRENT);
1645            String imId = Settings.Secure.getStringForUser(resolver,
1646                    Settings.Secure.DEFAULT_INPUT_METHOD, UserHandle.USER_CURRENT);
1647            boolean hasSoftInput = imId != null && imId.length() > 0;
1648            if (mHasSoftInput != hasSoftInput) {
1649                mHasSoftInput = hasSoftInput;
1650                updateRotation = true;
1651            }
1652            if (mImmersiveModeConfirmation != null) {
1653                mImmersiveModeConfirmation.loadSetting(mCurrentUserId);
1654            }
1655            PolicyControl.reloadFromSetting(mContext);
1656        }
1657        if (updateRotation) {
1658            updateRotation(true);
1659        }
1660    }
1661
1662    private void updateWakeGestureListenerLp() {
1663        if (shouldEnableWakeGestureLp()) {
1664            mWakeGestureListener.requestWakeUpTrigger();
1665        } else {
1666            mWakeGestureListener.cancelWakeUpTrigger();
1667        }
1668    }
1669
1670    private boolean shouldEnableWakeGestureLp() {
1671        return mWakeGestureEnabledSetting && !mAwake
1672                && (!mLidControlsSleep || mLidState != LID_CLOSED)
1673                && mWakeGestureListener.isSupported();
1674    }
1675
1676    private void enablePointerLocation() {
1677        if (mPointerLocationView == null) {
1678            mPointerLocationView = new PointerLocationView(mContext);
1679            mPointerLocationView.setPrintCoords(false);
1680            WindowManager.LayoutParams lp = new WindowManager.LayoutParams(
1681                    WindowManager.LayoutParams.MATCH_PARENT,
1682                    WindowManager.LayoutParams.MATCH_PARENT);
1683            lp.type = WindowManager.LayoutParams.TYPE_SECURE_SYSTEM_OVERLAY;
1684            lp.flags = WindowManager.LayoutParams.FLAG_FULLSCREEN
1685                    | WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE
1686                    | WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE
1687                    | WindowManager.LayoutParams.FLAG_LAYOUT_IN_SCREEN;
1688            if (ActivityManager.isHighEndGfx()) {
1689                lp.flags |= WindowManager.LayoutParams.FLAG_HARDWARE_ACCELERATED;
1690                lp.privateFlags |=
1691                        WindowManager.LayoutParams.PRIVATE_FLAG_FORCE_HARDWARE_ACCELERATED;
1692            }
1693            lp.format = PixelFormat.TRANSLUCENT;
1694            lp.setTitle("PointerLocation");
1695            WindowManager wm = (WindowManager)
1696                    mContext.getSystemService(Context.WINDOW_SERVICE);
1697            lp.inputFeatures |= WindowManager.LayoutParams.INPUT_FEATURE_NO_INPUT_CHANNEL;
1698            wm.addView(mPointerLocationView, lp);
1699            mWindowManagerFuncs.registerPointerEventListener(mPointerLocationView);
1700        }
1701    }
1702
1703    private void disablePointerLocation() {
1704        if (mPointerLocationView != null) {
1705            mWindowManagerFuncs.unregisterPointerEventListener(mPointerLocationView);
1706            WindowManager wm = (WindowManager) mContext.getSystemService(Context.WINDOW_SERVICE);
1707            wm.removeView(mPointerLocationView);
1708            mPointerLocationView = null;
1709        }
1710    }
1711
1712    private int readRotation(int resID) {
1713        try {
1714            int rotation = mContext.getResources().getInteger(resID);
1715            switch (rotation) {
1716                case 0:
1717                    return Surface.ROTATION_0;
1718                case 90:
1719                    return Surface.ROTATION_90;
1720                case 180:
1721                    return Surface.ROTATION_180;
1722                case 270:
1723                    return Surface.ROTATION_270;
1724            }
1725        } catch (Resources.NotFoundException e) {
1726            // fall through
1727        }
1728        return -1;
1729    }
1730
1731    /** {@inheritDoc} */
1732    @Override
1733    public int checkAddPermission(WindowManager.LayoutParams attrs, int[] outAppOp) {
1734        int type = attrs.type;
1735
1736        outAppOp[0] = AppOpsManager.OP_NONE;
1737
1738        if (!((type >= FIRST_APPLICATION_WINDOW && type <= LAST_APPLICATION_WINDOW)
1739                || (type >= FIRST_SUB_WINDOW && type <= LAST_SUB_WINDOW)
1740                || (type >= FIRST_SYSTEM_WINDOW && type <= LAST_SYSTEM_WINDOW))) {
1741            return WindowManagerGlobal.ADD_INVALID_TYPE;
1742        }
1743
1744        if (type < FIRST_SYSTEM_WINDOW || type > LAST_SYSTEM_WINDOW) {
1745            // Window manager will make sure these are okay.
1746            return WindowManagerGlobal.ADD_OKAY;
1747        }
1748        String permission = null;
1749        switch (type) {
1750            case TYPE_TOAST:
1751                // XXX right now the app process has complete control over
1752                // this...  should introduce a token to let the system
1753                // monitor/control what they are doing.
1754                outAppOp[0] = AppOpsManager.OP_TOAST_WINDOW;
1755                break;
1756            case TYPE_DREAM:
1757            case TYPE_INPUT_METHOD:
1758            case TYPE_WALLPAPER:
1759            case TYPE_PRIVATE_PRESENTATION:
1760            case TYPE_VOICE_INTERACTION:
1761            case TYPE_ACCESSIBILITY_OVERLAY:
1762                // The window manager will check these.
1763                break;
1764            case TYPE_PHONE:
1765            case TYPE_PRIORITY_PHONE:
1766            case TYPE_SYSTEM_ALERT:
1767            case TYPE_SYSTEM_ERROR:
1768            case TYPE_SYSTEM_OVERLAY:
1769                permission = android.Manifest.permission.SYSTEM_ALERT_WINDOW;
1770                outAppOp[0] = AppOpsManager.OP_SYSTEM_ALERT_WINDOW;
1771                break;
1772            default:
1773                permission = android.Manifest.permission.INTERNAL_SYSTEM_WINDOW;
1774        }
1775        if (permission != null) {
1776            if (mContext.checkCallingOrSelfPermission(permission)
1777                    != PackageManager.PERMISSION_GRANTED) {
1778                return WindowManagerGlobal.ADD_PERMISSION_DENIED;
1779            }
1780        }
1781        return WindowManagerGlobal.ADD_OKAY;
1782    }
1783
1784    @Override
1785    public boolean checkShowToOwnerOnly(WindowManager.LayoutParams attrs) {
1786
1787        // If this switch statement is modified, modify the comment in the declarations of
1788        // the type in {@link WindowManager.LayoutParams} as well.
1789        switch (attrs.type) {
1790            default:
1791                // These are the windows that by default are shown only to the user that created
1792                // them. If this needs to be overridden, set
1793                // {@link WindowManager.LayoutParams.PRIVATE_FLAG_SHOW_FOR_ALL_USERS} in
1794                // {@link WindowManager.LayoutParams}. Note that permission
1795                // {@link android.Manifest.permission.INTERNAL_SYSTEM_WINDOW} is required as well.
1796                if ((attrs.privateFlags & PRIVATE_FLAG_SHOW_FOR_ALL_USERS) == 0) {
1797                    return true;
1798                }
1799                break;
1800
1801            // These are the windows that by default are shown to all users. However, to
1802            // protect against spoofing, check permissions below.
1803            case TYPE_APPLICATION_STARTING:
1804            case TYPE_BOOT_PROGRESS:
1805            case TYPE_DISPLAY_OVERLAY:
1806            case TYPE_HIDDEN_NAV_CONSUMER:
1807            case TYPE_KEYGUARD_SCRIM:
1808            case TYPE_KEYGUARD_DIALOG:
1809            case TYPE_MAGNIFICATION_OVERLAY:
1810            case TYPE_NAVIGATION_BAR:
1811            case TYPE_NAVIGATION_BAR_PANEL:
1812            case TYPE_PHONE:
1813            case TYPE_POINTER:
1814            case TYPE_PRIORITY_PHONE:
1815            case TYPE_SEARCH_BAR:
1816            case TYPE_STATUS_BAR:
1817            case TYPE_STATUS_BAR_PANEL:
1818            case TYPE_STATUS_BAR_SUB_PANEL:
1819            case TYPE_SYSTEM_DIALOG:
1820            case TYPE_VOLUME_OVERLAY:
1821            case TYPE_PRIVATE_PRESENTATION:
1822                break;
1823        }
1824
1825        // Check if third party app has set window to system window type.
1826        return mContext.checkCallingOrSelfPermission(
1827                android.Manifest.permission.INTERNAL_SYSTEM_WINDOW)
1828                        != PackageManager.PERMISSION_GRANTED;
1829    }
1830
1831    @Override
1832    public void adjustWindowParamsLw(WindowManager.LayoutParams attrs) {
1833        switch (attrs.type) {
1834            case TYPE_SYSTEM_OVERLAY:
1835            case TYPE_SECURE_SYSTEM_OVERLAY:
1836                // These types of windows can't receive input events.
1837                attrs.flags |= WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE
1838                        | WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE;
1839                attrs.flags &= ~WindowManager.LayoutParams.FLAG_WATCH_OUTSIDE_TOUCH;
1840                break;
1841            case TYPE_STATUS_BAR:
1842
1843                // If the Keyguard is in a hidden state (occluded by another window), we force to
1844                // remove the wallpaper and keyguard flag so that any change in-flight after setting
1845                // the keyguard as occluded wouldn't set these flags again.
1846                // See {@link #processKeyguardSetHiddenResultLw}.
1847                if (mKeyguardHidden) {
1848                    attrs.flags &= ~WindowManager.LayoutParams.FLAG_SHOW_WALLPAPER;
1849                    attrs.privateFlags &= ~WindowManager.LayoutParams.PRIVATE_FLAG_KEYGUARD;
1850                }
1851                break;
1852        }
1853
1854        if (attrs.type != TYPE_STATUS_BAR) {
1855            // The status bar is the only window allowed to exhibit keyguard behavior.
1856            attrs.privateFlags &= ~WindowManager.LayoutParams.PRIVATE_FLAG_KEYGUARD;
1857        }
1858
1859        if (ActivityManager.isHighEndGfx()
1860                && (attrs.flags & FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS) != 0) {
1861            attrs.subtreeSystemUiVisibility |= View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
1862                    | View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION;
1863        }
1864    }
1865
1866    void readLidState() {
1867        mLidState = mWindowManagerFuncs.getLidState();
1868    }
1869
1870    private void readCameraLensCoverState() {
1871        mCameraLensCoverState = mWindowManagerFuncs.getCameraLensCoverState();
1872    }
1873
1874    private boolean isHidden(int accessibilityMode) {
1875        switch (accessibilityMode) {
1876            case 1:
1877                return mLidState == LID_CLOSED;
1878            case 2:
1879                return mLidState == LID_OPEN;
1880            default:
1881                return false;
1882        }
1883    }
1884
1885    /** {@inheritDoc} */
1886    @Override
1887    public void adjustConfigurationLw(Configuration config, int keyboardPresence,
1888            int navigationPresence) {
1889        mHaveBuiltInKeyboard = (keyboardPresence & PRESENCE_INTERNAL) != 0;
1890
1891        readConfigurationDependentBehaviors();
1892        readLidState();
1893        applyLidSwitchState();
1894
1895        if (config.keyboard == Configuration.KEYBOARD_NOKEYS
1896                || (keyboardPresence == PRESENCE_INTERNAL
1897                        && isHidden(mLidKeyboardAccessibility))) {
1898            config.hardKeyboardHidden = Configuration.HARDKEYBOARDHIDDEN_YES;
1899            if (!mHasSoftInput) {
1900                config.keyboardHidden = Configuration.KEYBOARDHIDDEN_YES;
1901            }
1902        }
1903
1904        if (config.navigation == Configuration.NAVIGATION_NONAV
1905                || (navigationPresence == PRESENCE_INTERNAL
1906                        && isHidden(mLidNavigationAccessibility))) {
1907            config.navigationHidden = Configuration.NAVIGATIONHIDDEN_YES;
1908        }
1909    }
1910
1911    /** {@inheritDoc} */
1912    @Override
1913    public int windowTypeToLayerLw(int type) {
1914        if (type >= FIRST_APPLICATION_WINDOW && type <= LAST_APPLICATION_WINDOW) {
1915            return 2;
1916        }
1917        switch (type) {
1918        case TYPE_PRIVATE_PRESENTATION:
1919            return 2;
1920        case TYPE_WALLPAPER:
1921            // wallpaper is at the bottom, though the window manager may move it.
1922            return 2;
1923        case TYPE_PHONE:
1924            return 3;
1925        case TYPE_SEARCH_BAR:
1926        case TYPE_VOICE_INTERACTION_STARTING:
1927            return 4;
1928        case TYPE_VOICE_INTERACTION:
1929            // voice interaction layer is almost immediately above apps.
1930            return 5;
1931        case TYPE_SYSTEM_DIALOG:
1932            return 6;
1933        case TYPE_TOAST:
1934            // toasts and the plugged-in battery thing
1935            return 7;
1936        case TYPE_PRIORITY_PHONE:
1937            // SIM errors and unlock.  Not sure if this really should be in a high layer.
1938            return 8;
1939        case TYPE_DREAM:
1940            // used for Dreams (screensavers with TYPE_DREAM windows)
1941            return 9;
1942        case TYPE_SYSTEM_ALERT:
1943            // like the ANR / app crashed dialogs
1944            return 10;
1945        case TYPE_INPUT_METHOD:
1946            // on-screen keyboards and other such input method user interfaces go here.
1947            return 11;
1948        case TYPE_INPUT_METHOD_DIALOG:
1949            // on-screen keyboards and other such input method user interfaces go here.
1950            return 12;
1951        case TYPE_KEYGUARD_SCRIM:
1952            // the safety window that shows behind keyguard while keyguard is starting
1953            return 13;
1954        case TYPE_STATUS_BAR_SUB_PANEL:
1955            return 14;
1956        case TYPE_STATUS_BAR:
1957            return 15;
1958        case TYPE_STATUS_BAR_PANEL:
1959            return 16;
1960        case TYPE_KEYGUARD_DIALOG:
1961            return 17;
1962        case TYPE_VOLUME_OVERLAY:
1963            // the on-screen volume indicator and controller shown when the user
1964            // changes the device volume
1965            return 18;
1966        case TYPE_SYSTEM_OVERLAY:
1967            // the on-screen volume indicator and controller shown when the user
1968            // changes the device volume
1969            return 19;
1970        case TYPE_NAVIGATION_BAR:
1971            // the navigation bar, if available, shows atop most things
1972            return 20;
1973        case TYPE_NAVIGATION_BAR_PANEL:
1974            // some panels (e.g. search) need to show on top of the navigation bar
1975            return 21;
1976        case TYPE_SYSTEM_ERROR:
1977            // system-level error dialogs
1978            return 22;
1979        case TYPE_MAGNIFICATION_OVERLAY:
1980            // used to highlight the magnified portion of a display
1981            return 23;
1982        case TYPE_DISPLAY_OVERLAY:
1983            // used to simulate secondary display devices
1984            return 24;
1985        case TYPE_DRAG:
1986            // the drag layer: input for drag-and-drop is associated with this window,
1987            // which sits above all other focusable windows
1988            return 25;
1989        case TYPE_ACCESSIBILITY_OVERLAY:
1990            // overlay put by accessibility services to intercept user interaction
1991            return 26;
1992        case TYPE_SECURE_SYSTEM_OVERLAY:
1993            return 27;
1994        case TYPE_BOOT_PROGRESS:
1995            return 28;
1996        case TYPE_POINTER:
1997            // the (mouse) pointer layer
1998            return 29;
1999        case TYPE_HIDDEN_NAV_CONSUMER:
2000            return 30;
2001        }
2002        Log.e(TAG, "Unknown window type: " + type);
2003        return 2;
2004    }
2005
2006    /** {@inheritDoc} */
2007    @Override
2008    public int subWindowTypeToLayerLw(int type) {
2009        switch (type) {
2010        case TYPE_APPLICATION_PANEL:
2011        case TYPE_APPLICATION_ATTACHED_DIALOG:
2012            return APPLICATION_PANEL_SUBLAYER;
2013        case TYPE_APPLICATION_MEDIA:
2014            return APPLICATION_MEDIA_SUBLAYER;
2015        case TYPE_APPLICATION_MEDIA_OVERLAY:
2016            return APPLICATION_MEDIA_OVERLAY_SUBLAYER;
2017        case TYPE_APPLICATION_SUB_PANEL:
2018            return APPLICATION_SUB_PANEL_SUBLAYER;
2019        case TYPE_APPLICATION_ABOVE_SUB_PANEL:
2020            return APPLICATION_ABOVE_SUB_PANEL_SUBLAYER;
2021        }
2022        Log.e(TAG, "Unknown sub-window type: " + type);
2023        return 0;
2024    }
2025
2026    @Override
2027    public int getMaxWallpaperLayer() {
2028        return windowTypeToLayerLw(TYPE_STATUS_BAR);
2029    }
2030
2031    @Override
2032    public int getNonDecorDisplayWidth(int fullWidth, int fullHeight, int rotation) {
2033        if (mHasNavigationBar) {
2034            // For a basic navigation bar, when we are in landscape mode we place
2035            // the navigation bar to the side.
2036            if (mNavigationBarCanMove && fullWidth > fullHeight) {
2037                return fullWidth - mNavigationBarWidthForRotation[rotation];
2038            }
2039        }
2040        return fullWidth;
2041    }
2042
2043    @Override
2044    public int getNonDecorDisplayHeight(int fullWidth, int fullHeight, int rotation) {
2045        if (mHasNavigationBar) {
2046            // For a basic navigation bar, when we are in portrait mode we place
2047            // the navigation bar to the bottom.
2048            if (!mNavigationBarCanMove || fullWidth < fullHeight) {
2049                return fullHeight - mNavigationBarHeightForRotation[rotation];
2050            }
2051        }
2052        return fullHeight;
2053    }
2054
2055    @Override
2056    public int getConfigDisplayWidth(int fullWidth, int fullHeight, int rotation) {
2057        return getNonDecorDisplayWidth(fullWidth, fullHeight, rotation);
2058    }
2059
2060    @Override
2061    public int getConfigDisplayHeight(int fullWidth, int fullHeight, int rotation) {
2062        // There is a separate status bar at the top of the display.  We don't count that as part
2063        // of the fixed decor, since it can hide; however, for purposes of configurations,
2064        // we do want to exclude it since applications can't generally use that part
2065        // of the screen.
2066        return getNonDecorDisplayHeight(fullWidth, fullHeight, rotation) - mStatusBarHeight;
2067    }
2068
2069    @Override
2070    public boolean isForceHiding(WindowManager.LayoutParams attrs) {
2071        return (attrs.privateFlags & PRIVATE_FLAG_KEYGUARD) != 0 ||
2072                (isKeyguardHostWindow(attrs) &&
2073                        (mKeyguardDelegate != null && mKeyguardDelegate.isShowing())) ||
2074                (attrs.type == TYPE_KEYGUARD_SCRIM);
2075    }
2076
2077    @Override
2078    public boolean isKeyguardHostWindow(WindowManager.LayoutParams attrs) {
2079        return attrs.type == TYPE_STATUS_BAR;
2080    }
2081
2082    @Override
2083    public boolean canBeForceHidden(WindowState win, WindowManager.LayoutParams attrs) {
2084        switch (attrs.type) {
2085            case TYPE_STATUS_BAR:
2086            case TYPE_NAVIGATION_BAR:
2087            case TYPE_WALLPAPER:
2088            case TYPE_DREAM:
2089            case TYPE_KEYGUARD_SCRIM:
2090                return false;
2091            default:
2092                return true;
2093        }
2094    }
2095
2096    @Override
2097    public WindowState getWinShowWhenLockedLw() {
2098        return mWinShowWhenLocked;
2099    }
2100
2101    /** {@inheritDoc} */
2102    @Override
2103    public View addStartingWindow(IBinder appToken, String packageName, int theme,
2104            CompatibilityInfo compatInfo, CharSequence nonLocalizedLabel, int labelRes,
2105            int icon, int logo, int windowFlags) {
2106        if (!SHOW_STARTING_ANIMATIONS) {
2107            return null;
2108        }
2109        if (packageName == null) {
2110            return null;
2111        }
2112
2113        WindowManager wm = null;
2114        View view = null;
2115
2116        try {
2117            Context context = mContext;
2118            if (DEBUG_STARTING_WINDOW) Slog.d(TAG, "addStartingWindow " + packageName
2119                    + ": nonLocalizedLabel=" + nonLocalizedLabel + " theme="
2120                    + Integer.toHexString(theme));
2121            if (theme != context.getThemeResId() || labelRes != 0) {
2122                try {
2123                    context = context.createPackageContext(packageName, 0);
2124                    context.setTheme(theme);
2125                } catch (PackageManager.NameNotFoundException e) {
2126                    // Ignore
2127                }
2128            }
2129
2130            Window win = new PhoneWindow(context);
2131            final TypedArray ta = win.getWindowStyle();
2132            if (ta.getBoolean(
2133                        com.android.internal.R.styleable.Window_windowDisablePreview, false)
2134                || ta.getBoolean(
2135                        com.android.internal.R.styleable.Window_windowShowWallpaper,false)) {
2136                return null;
2137            }
2138
2139            Resources r = context.getResources();
2140            win.setTitle(r.getText(labelRes, nonLocalizedLabel));
2141
2142            win.setType(
2143                WindowManager.LayoutParams.TYPE_APPLICATION_STARTING);
2144            // Force the window flags: this is a fake window, so it is not really
2145            // touchable or focusable by the user.  We also add in the ALT_FOCUSABLE_IM
2146            // flag because we do know that the next window will take input
2147            // focus, so we want to get the IME window up on top of us right away.
2148            win.setFlags(
2149                windowFlags|
2150                WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE|
2151                WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE|
2152                WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM,
2153                windowFlags|
2154                WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE|
2155                WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE|
2156                WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM);
2157
2158            win.setDefaultIcon(icon);
2159            win.setDefaultLogo(logo);
2160
2161            win.setLayout(WindowManager.LayoutParams.MATCH_PARENT,
2162                    WindowManager.LayoutParams.MATCH_PARENT);
2163
2164            final WindowManager.LayoutParams params = win.getAttributes();
2165            params.token = appToken;
2166            params.packageName = packageName;
2167            params.windowAnimations = win.getWindowStyle().getResourceId(
2168                    com.android.internal.R.styleable.Window_windowAnimationStyle, 0);
2169            params.privateFlags |=
2170                    WindowManager.LayoutParams.PRIVATE_FLAG_FAKE_HARDWARE_ACCELERATED;
2171            params.privateFlags |= WindowManager.LayoutParams.PRIVATE_FLAG_SHOW_FOR_ALL_USERS;
2172
2173            if (!compatInfo.supportsScreen()) {
2174                params.privateFlags |= WindowManager.LayoutParams.PRIVATE_FLAG_COMPATIBLE_WINDOW;
2175            }
2176
2177            params.setTitle("Starting " + packageName);
2178
2179            wm = (WindowManager)context.getSystemService(Context.WINDOW_SERVICE);
2180            view = win.getDecorView();
2181
2182            if (win.isFloating()) {
2183                // Whoops, there is no way to display an animation/preview
2184                // of such a thing!  After all that work...  let's skip it.
2185                // (Note that we must do this here because it is in
2186                // getDecorView() where the theme is evaluated...  maybe
2187                // we should peek the floating attribute from the theme
2188                // earlier.)
2189                return null;
2190            }
2191
2192            if (DEBUG_STARTING_WINDOW) Slog.d(
2193                TAG, "Adding starting window for " + packageName
2194                + " / " + appToken + ": "
2195                + (view.getParent() != null ? view : null));
2196
2197            wm.addView(view, params);
2198
2199            // Only return the view if it was successfully added to the
2200            // window manager... which we can tell by it having a parent.
2201            return view.getParent() != null ? view : null;
2202        } catch (WindowManager.BadTokenException e) {
2203            // ignore
2204            Log.w(TAG, appToken + " already running, starting window not displayed. " +
2205                    e.getMessage());
2206        } catch (RuntimeException e) {
2207            // don't crash if something else bad happens, for example a
2208            // failure loading resources because we are loading from an app
2209            // on external storage that has been unmounted.
2210            Log.w(TAG, appToken + " failed creating starting window", e);
2211        } finally {
2212            if (view != null && view.getParent() == null) {
2213                Log.w(TAG, "view not successfully added to wm, removing view");
2214                wm.removeViewImmediate(view);
2215            }
2216        }
2217
2218        return null;
2219    }
2220
2221    /** {@inheritDoc} */
2222    @Override
2223    public void removeStartingWindow(IBinder appToken, View window) {
2224        if (DEBUG_STARTING_WINDOW) Slog.v(TAG, "Removing starting window for " + appToken + ": "
2225                + window + " Callers=" + Debug.getCallers(4));
2226
2227        if (window != null) {
2228            WindowManager wm = (WindowManager)mContext.getSystemService(Context.WINDOW_SERVICE);
2229            wm.removeView(window);
2230        }
2231    }
2232
2233    /**
2234     * Preflight adding a window to the system.
2235     *
2236     * Currently enforces that three window types are singletons:
2237     * <ul>
2238     * <li>STATUS_BAR_TYPE</li>
2239     * <li>KEYGUARD_TYPE</li>
2240     * </ul>
2241     *
2242     * @param win The window to be added
2243     * @param attrs Information about the window to be added
2244     *
2245     * @return If ok, WindowManagerImpl.ADD_OKAY.  If too many singletons,
2246     * WindowManagerImpl.ADD_MULTIPLE_SINGLETON
2247     */
2248    @Override
2249    public int prepareAddWindowLw(WindowState win, WindowManager.LayoutParams attrs) {
2250        switch (attrs.type) {
2251            case TYPE_STATUS_BAR:
2252                mContext.enforceCallingOrSelfPermission(
2253                        android.Manifest.permission.STATUS_BAR_SERVICE,
2254                        "PhoneWindowManager");
2255                if (mStatusBar != null) {
2256                    if (mStatusBar.isAlive()) {
2257                        return WindowManagerGlobal.ADD_MULTIPLE_SINGLETON;
2258                    }
2259                }
2260                mStatusBar = win;
2261                mStatusBarController.setWindow(win);
2262                break;
2263            case TYPE_NAVIGATION_BAR:
2264                mContext.enforceCallingOrSelfPermission(
2265                        android.Manifest.permission.STATUS_BAR_SERVICE,
2266                        "PhoneWindowManager");
2267                if (mNavigationBar != null) {
2268                    if (mNavigationBar.isAlive()) {
2269                        return WindowManagerGlobal.ADD_MULTIPLE_SINGLETON;
2270                    }
2271                }
2272                mNavigationBar = win;
2273                mNavigationBarController.setWindow(win);
2274                if (DEBUG_LAYOUT) Slog.i(TAG, "NAVIGATION BAR: " + mNavigationBar);
2275                break;
2276            case TYPE_NAVIGATION_BAR_PANEL:
2277            case TYPE_STATUS_BAR_PANEL:
2278            case TYPE_STATUS_BAR_SUB_PANEL:
2279            case TYPE_VOICE_INTERACTION_STARTING:
2280                mContext.enforceCallingOrSelfPermission(
2281                        android.Manifest.permission.STATUS_BAR_SERVICE,
2282                        "PhoneWindowManager");
2283                break;
2284            case TYPE_KEYGUARD_SCRIM:
2285                if (mKeyguardScrim != null) {
2286                    return WindowManagerGlobal.ADD_MULTIPLE_SINGLETON;
2287                }
2288                mKeyguardScrim = win;
2289                break;
2290        }
2291        return WindowManagerGlobal.ADD_OKAY;
2292    }
2293
2294    /** {@inheritDoc} */
2295    @Override
2296    public void removeWindowLw(WindowState win) {
2297        if (mStatusBar == win) {
2298            mStatusBar = null;
2299            mStatusBarController.setWindow(null);
2300            mKeyguardDelegate.showScrim();
2301        } else if (mKeyguardScrim == win) {
2302            Log.v(TAG, "Removing keyguard scrim");
2303            mKeyguardScrim = null;
2304        } if (mNavigationBar == win) {
2305            mNavigationBar = null;
2306            mNavigationBarController.setWindow(null);
2307        }
2308    }
2309
2310    static final boolean PRINT_ANIM = false;
2311
2312    /** {@inheritDoc} */
2313    @Override
2314    public int selectAnimationLw(WindowState win, int transit) {
2315        if (PRINT_ANIM) Log.i(TAG, "selectAnimation in " + win
2316              + ": transit=" + transit);
2317        if (win == mStatusBar) {
2318            boolean isKeyguard = (win.getAttrs().privateFlags & PRIVATE_FLAG_KEYGUARD) != 0;
2319            if (transit == TRANSIT_EXIT
2320                    || transit == TRANSIT_HIDE) {
2321                return isKeyguard ? -1 : R.anim.dock_top_exit;
2322            } else if (transit == TRANSIT_ENTER
2323                    || transit == TRANSIT_SHOW) {
2324                return isKeyguard ? -1 : R.anim.dock_top_enter;
2325            }
2326        } else if (win == mNavigationBar) {
2327            // This can be on either the bottom or the right.
2328            if (mNavigationBarOnBottom) {
2329                if (transit == TRANSIT_EXIT
2330                        || transit == TRANSIT_HIDE) {
2331                    return R.anim.dock_bottom_exit;
2332                } else if (transit == TRANSIT_ENTER
2333                        || transit == TRANSIT_SHOW) {
2334                    return R.anim.dock_bottom_enter;
2335                }
2336            } else {
2337                if (transit == TRANSIT_EXIT
2338                        || transit == TRANSIT_HIDE) {
2339                    return R.anim.dock_right_exit;
2340                } else if (transit == TRANSIT_ENTER
2341                        || transit == TRANSIT_SHOW) {
2342                    return R.anim.dock_right_enter;
2343                }
2344            }
2345        }
2346
2347        if (transit == TRANSIT_PREVIEW_DONE) {
2348            if (win.hasAppShownWindows()) {
2349                if (PRINT_ANIM) Log.i(TAG, "**** STARTING EXIT");
2350                return com.android.internal.R.anim.app_starting_exit;
2351            }
2352        } else if (win.getAttrs().type == TYPE_DREAM && mDreamingLockscreen
2353                && transit == TRANSIT_ENTER) {
2354            // Special case: we are animating in a dream, while the keyguard
2355            // is shown.  We don't want an animation on the dream, because
2356            // we need it shown immediately with the keyguard animating away
2357            // to reveal it.
2358            return -1;
2359        }
2360
2361        return 0;
2362    }
2363
2364    @Override
2365    public void selectRotationAnimationLw(int anim[]) {
2366        if (PRINT_ANIM) Slog.i(TAG, "selectRotationAnimation mTopFullscreen="
2367                + mTopFullscreenOpaqueWindowState + " rotationAnimation="
2368                + (mTopFullscreenOpaqueWindowState == null ?
2369                        "0" : mTopFullscreenOpaqueWindowState.getAttrs().rotationAnimation));
2370        if (mTopFullscreenOpaqueWindowState != null && mTopIsFullscreen) {
2371            switch (mTopFullscreenOpaqueWindowState.getAttrs().rotationAnimation) {
2372                case ROTATION_ANIMATION_CROSSFADE:
2373                    anim[0] = R.anim.rotation_animation_xfade_exit;
2374                    anim[1] = R.anim.rotation_animation_enter;
2375                    break;
2376                case ROTATION_ANIMATION_JUMPCUT:
2377                    anim[0] = R.anim.rotation_animation_jump_exit;
2378                    anim[1] = R.anim.rotation_animation_enter;
2379                    break;
2380                case ROTATION_ANIMATION_ROTATE:
2381                default:
2382                    anim[0] = anim[1] = 0;
2383                    break;
2384            }
2385        } else {
2386            anim[0] = anim[1] = 0;
2387        }
2388    }
2389
2390    @Override
2391    public boolean validateRotationAnimationLw(int exitAnimId, int enterAnimId,
2392            boolean forceDefault) {
2393        switch (exitAnimId) {
2394            case R.anim.rotation_animation_xfade_exit:
2395            case R.anim.rotation_animation_jump_exit:
2396                // These are the only cases that matter.
2397                if (forceDefault) {
2398                    return false;
2399                }
2400                int anim[] = new int[2];
2401                selectRotationAnimationLw(anim);
2402                return (exitAnimId == anim[0] && enterAnimId == anim[1]);
2403            default:
2404                return true;
2405        }
2406    }
2407
2408    @Override
2409    public Animation createForceHideEnterAnimation(boolean onWallpaper,
2410            boolean goingToNotificationShade) {
2411        if (goingToNotificationShade) {
2412            return AnimationUtils.loadAnimation(mContext, R.anim.lock_screen_behind_enter_fade_in);
2413        }
2414
2415        AnimationSet set = (AnimationSet) AnimationUtils.loadAnimation(mContext, onWallpaper ?
2416                    R.anim.lock_screen_behind_enter_wallpaper :
2417                    R.anim.lock_screen_behind_enter);
2418
2419        // TODO: Use XML interpolators when we have log interpolators available in XML.
2420        final List<Animation> animations = set.getAnimations();
2421        for (int i = animations.size() - 1; i >= 0; --i) {
2422            animations.get(i).setInterpolator(mLogDecelerateInterpolator);
2423        }
2424
2425        return set;
2426    }
2427
2428
2429    @Override
2430    public Animation createForceHideWallpaperExitAnimation(boolean goingToNotificationShade) {
2431        if (goingToNotificationShade) {
2432            return null;
2433        } else {
2434            return AnimationUtils.loadAnimation(mContext, R.anim.lock_screen_wallpaper_exit);
2435        }
2436    }
2437
2438    private static void awakenDreams() {
2439        IDreamManager dreamManager = getDreamManager();
2440        if (dreamManager != null) {
2441            try {
2442                dreamManager.awaken();
2443            } catch (RemoteException e) {
2444                // fine, stay asleep then
2445            }
2446        }
2447    }
2448
2449    static IDreamManager getDreamManager() {
2450        return IDreamManager.Stub.asInterface(
2451                ServiceManager.checkService(DreamService.DREAM_SERVICE));
2452    }
2453
2454    TelecomManager getTelecommService() {
2455        return (TelecomManager) mContext.getSystemService(Context.TELECOM_SERVICE);
2456    }
2457
2458    static IAudioService getAudioService() {
2459        IAudioService audioService = IAudioService.Stub.asInterface(
2460                ServiceManager.checkService(Context.AUDIO_SERVICE));
2461        if (audioService == null) {
2462            Log.w(TAG, "Unable to find IAudioService interface.");
2463        }
2464        return audioService;
2465    }
2466
2467    boolean keyguardOn() {
2468        return isKeyguardShowingAndNotOccluded() || inKeyguardRestrictedKeyInputMode();
2469    }
2470
2471    private static final int[] WINDOW_TYPES_WHERE_HOME_DOESNT_WORK = {
2472            WindowManager.LayoutParams.TYPE_SYSTEM_ALERT,
2473            WindowManager.LayoutParams.TYPE_SYSTEM_ERROR,
2474        };
2475
2476    /** {@inheritDoc} */
2477    @Override
2478    public long interceptKeyBeforeDispatching(WindowState win, KeyEvent event, int policyFlags) {
2479        final boolean keyguardOn = keyguardOn();
2480        final int keyCode = event.getKeyCode();
2481        final int repeatCount = event.getRepeatCount();
2482        final int metaState = event.getMetaState();
2483        final int flags = event.getFlags();
2484        final boolean down = event.getAction() == KeyEvent.ACTION_DOWN;
2485        final boolean canceled = event.isCanceled();
2486
2487        if (DEBUG_INPUT) {
2488            Log.d(TAG, "interceptKeyTi keyCode=" + keyCode + " down=" + down + " repeatCount="
2489                    + repeatCount + " keyguardOn=" + keyguardOn + " mHomePressed=" + mHomePressed
2490                    + " canceled=" + canceled);
2491        }
2492
2493        // If we think we might have a volume down & power key chord on the way
2494        // but we're not sure, then tell the dispatcher to wait a little while and
2495        // try again later before dispatching.
2496        if (mScreenshotChordEnabled && (flags & KeyEvent.FLAG_FALLBACK) == 0) {
2497            if (mScreenshotChordVolumeDownKeyTriggered && !mScreenshotChordPowerKeyTriggered) {
2498                final long now = SystemClock.uptimeMillis();
2499                final long timeoutTime = mScreenshotChordVolumeDownKeyTime
2500                        + SCREENSHOT_CHORD_DEBOUNCE_DELAY_MILLIS;
2501                if (now < timeoutTime) {
2502                    return timeoutTime - now;
2503                }
2504            }
2505            if (keyCode == KeyEvent.KEYCODE_VOLUME_DOWN
2506                    && mScreenshotChordVolumeDownKeyConsumed) {
2507                if (!down) {
2508                    mScreenshotChordVolumeDownKeyConsumed = false;
2509                }
2510                return -1;
2511            }
2512        }
2513
2514        // Cancel any pending meta actions if we see any other keys being pressed between the down
2515        // of the meta key and its corresponding up.
2516        if (mPendingMetaAction && !KeyEvent.isMetaKey(keyCode)) {
2517            mPendingMetaAction = false;
2518        }
2519
2520        // First we always handle the home key here, so applications
2521        // can never break it, although if keyguard is on, we do let
2522        // it handle it, because that gives us the correct 5 second
2523        // timeout.
2524        if (keyCode == KeyEvent.KEYCODE_HOME) {
2525
2526            // If we have released the home key, and didn't do anything else
2527            // while it was pressed, then it is time to go home!
2528            if (!down) {
2529                cancelPreloadRecentApps();
2530
2531                mHomePressed = false;
2532                if (mHomeConsumed) {
2533                    mHomeConsumed = false;
2534                    return -1;
2535                }
2536
2537                if (canceled) {
2538                    Log.i(TAG, "Ignoring HOME; event canceled.");
2539                    return -1;
2540                }
2541
2542                // If an incoming call is ringing, HOME is totally disabled.
2543                // (The user is already on the InCallUI at this point,
2544                // and his ONLY options are to answer or reject the call.)
2545                TelecomManager telecomManager = getTelecommService();
2546                if (telecomManager != null && telecomManager.isRinging()) {
2547                    Log.i(TAG, "Ignoring HOME; there's a ringing incoming call.");
2548                    return -1;
2549                }
2550
2551                // Delay handling home if a double-tap is possible.
2552                if (mDoubleTapOnHomeBehavior != DOUBLE_TAP_HOME_NOTHING) {
2553                    mHandler.removeCallbacks(mHomeDoubleTapTimeoutRunnable); // just in case
2554                    mHomeDoubleTapPending = true;
2555                    mHandler.postDelayed(mHomeDoubleTapTimeoutRunnable,
2556                            ViewConfiguration.getDoubleTapTimeout());
2557                    return -1;
2558                }
2559
2560                handleShortPressOnHome();
2561                return -1;
2562            }
2563
2564            // If a system window has focus, then it doesn't make sense
2565            // right now to interact with applications.
2566            WindowManager.LayoutParams attrs = win != null ? win.getAttrs() : null;
2567            if (attrs != null) {
2568                final int type = attrs.type;
2569                if (type == WindowManager.LayoutParams.TYPE_KEYGUARD_SCRIM
2570                        || type == WindowManager.LayoutParams.TYPE_KEYGUARD_DIALOG
2571                        || (attrs.privateFlags & PRIVATE_FLAG_KEYGUARD) != 0) {
2572                    // the "app" is keyguard, so give it the key
2573                    return 0;
2574                }
2575                final int typeCount = WINDOW_TYPES_WHERE_HOME_DOESNT_WORK.length;
2576                for (int i=0; i<typeCount; i++) {
2577                    if (type == WINDOW_TYPES_WHERE_HOME_DOESNT_WORK[i]) {
2578                        // don't do anything, but also don't pass it to the app
2579                        return -1;
2580                    }
2581                }
2582            }
2583
2584            // Remember that home is pressed and handle special actions.
2585            if (repeatCount == 0) {
2586                mHomePressed = true;
2587                if (mHomeDoubleTapPending) {
2588                    mHomeDoubleTapPending = false;
2589                    mHandler.removeCallbacks(mHomeDoubleTapTimeoutRunnable);
2590                    handleDoubleTapOnHome();
2591                } else if (mLongPressOnHomeBehavior == LONG_PRESS_HOME_RECENT_SYSTEM_UI
2592                        || mDoubleTapOnHomeBehavior == DOUBLE_TAP_HOME_RECENT_SYSTEM_UI) {
2593                    preloadRecentApps();
2594                }
2595            } else if ((event.getFlags() & KeyEvent.FLAG_LONG_PRESS) != 0) {
2596                if (!keyguardOn) {
2597                    handleLongPressOnHome();
2598                }
2599            }
2600            return -1;
2601        } else if (keyCode == KeyEvent.KEYCODE_MENU) {
2602            // Hijack modified menu keys for debugging features
2603            final int chordBug = KeyEvent.META_SHIFT_ON;
2604
2605            if (down && repeatCount == 0) {
2606                if (mEnableShiftMenuBugReports && (metaState & chordBug) == chordBug) {
2607                    Intent intent = new Intent(Intent.ACTION_BUG_REPORT);
2608                    mContext.sendOrderedBroadcastAsUser(intent, UserHandle.CURRENT,
2609                            null, null, null, 0, null, null);
2610                    return -1;
2611                } else if (SHOW_PROCESSES_ON_ALT_MENU &&
2612                        (metaState & KeyEvent.META_ALT_ON) == KeyEvent.META_ALT_ON) {
2613                    Intent service = new Intent();
2614                    service.setClassName(mContext, "com.android.server.LoadAverageService");
2615                    ContentResolver res = mContext.getContentResolver();
2616                    boolean shown = Settings.Global.getInt(
2617                            res, Settings.Global.SHOW_PROCESSES, 0) != 0;
2618                    if (!shown) {
2619                        mContext.startService(service);
2620                    } else {
2621                        mContext.stopService(service);
2622                    }
2623                    Settings.Global.putInt(
2624                            res, Settings.Global.SHOW_PROCESSES, shown ? 0 : 1);
2625                    return -1;
2626                }
2627            }
2628        } else if (keyCode == KeyEvent.KEYCODE_SEARCH) {
2629            if (down) {
2630                if (repeatCount == 0) {
2631                    mSearchKeyShortcutPending = true;
2632                    mConsumeSearchKeyUp = false;
2633                }
2634            } else {
2635                mSearchKeyShortcutPending = false;
2636                if (mConsumeSearchKeyUp) {
2637                    mConsumeSearchKeyUp = false;
2638                    return -1;
2639                }
2640            }
2641            return 0;
2642        } else if (keyCode == KeyEvent.KEYCODE_APP_SWITCH) {
2643            if (!keyguardOn) {
2644                if (down && repeatCount == 0) {
2645                    preloadRecentApps();
2646                } else if (!down) {
2647                    toggleRecentApps();
2648                }
2649            }
2650            return -1;
2651        } else if (keyCode == KeyEvent.KEYCODE_ASSIST) {
2652            if (down) {
2653                if (repeatCount == 0) {
2654                    mAssistKeyLongPressed = false;
2655                } else if (repeatCount == 1) {
2656                    mAssistKeyLongPressed = true;
2657                    if (!keyguardOn) {
2658                         launchAssistLongPressAction();
2659                    }
2660                }
2661            } else {
2662                if (mAssistKeyLongPressed) {
2663                    mAssistKeyLongPressed = false;
2664                } else {
2665                    if (!keyguardOn) {
2666                        launchAssistAction();
2667                    }
2668                }
2669            }
2670            return -1;
2671        } else if (keyCode == KeyEvent.KEYCODE_VOICE_ASSIST) {
2672            if (!down) {
2673                Intent voiceIntent;
2674                if (!keyguardOn) {
2675                    voiceIntent = new Intent(RecognizerIntent.ACTION_WEB_SEARCH);
2676                } else {
2677                    voiceIntent = new Intent(RecognizerIntent.ACTION_VOICE_SEARCH_HANDS_FREE);
2678                    voiceIntent.putExtra(RecognizerIntent.EXTRA_SECURE, true);
2679                }
2680                startActivityAsUser(voiceIntent, UserHandle.CURRENT_OR_SELF);
2681            }
2682        } else if (keyCode == KeyEvent.KEYCODE_SYSRQ) {
2683            if (down && repeatCount == 0) {
2684                mHandler.post(mScreenshotRunnable);
2685            }
2686            return -1;
2687        } else if (keyCode == KeyEvent.KEYCODE_BRIGHTNESS_UP
2688                || keyCode == KeyEvent.KEYCODE_BRIGHTNESS_DOWN) {
2689            if (down) {
2690                int direction = keyCode == KeyEvent.KEYCODE_BRIGHTNESS_UP ? 1 : -1;
2691
2692                // Disable autobrightness if it's on
2693                int auto = Settings.System.getIntForUser(
2694                        mContext.getContentResolver(),
2695                        Settings.System.SCREEN_BRIGHTNESS_MODE,
2696                        Settings.System.SCREEN_BRIGHTNESS_MODE_MANUAL,
2697                        UserHandle.USER_CURRENT_OR_SELF);
2698                if (auto != 0) {
2699                    Settings.System.putIntForUser(mContext.getContentResolver(),
2700                            Settings.System.SCREEN_BRIGHTNESS_MODE,
2701                            Settings.System.SCREEN_BRIGHTNESS_MODE_MANUAL,
2702                            UserHandle.USER_CURRENT_OR_SELF);
2703                }
2704
2705                int min = mPowerManager.getMinimumScreenBrightnessSetting();
2706                int max = mPowerManager.getMaximumScreenBrightnessSetting();
2707                int step = (max - min + BRIGHTNESS_STEPS - 1) / BRIGHTNESS_STEPS * direction;
2708                int brightness = Settings.System.getIntForUser(mContext.getContentResolver(),
2709                        Settings.System.SCREEN_BRIGHTNESS,
2710                        mPowerManager.getDefaultScreenBrightnessSetting(),
2711                        UserHandle.USER_CURRENT_OR_SELF);
2712                brightness += step;
2713                // Make sure we don't go beyond the limits.
2714                brightness = Math.min(max, brightness);
2715                brightness = Math.max(min, brightness);
2716
2717                Settings.System.putIntForUser(mContext.getContentResolver(),
2718                        Settings.System.SCREEN_BRIGHTNESS, brightness,
2719                        UserHandle.USER_CURRENT_OR_SELF);
2720                startActivityAsUser(new Intent(Intent.ACTION_SHOW_BRIGHTNESS_DIALOG),
2721                        UserHandle.CURRENT_OR_SELF);
2722            }
2723            return -1;
2724        } else if (KeyEvent.isMetaKey(keyCode)) {
2725            if (down) {
2726                mPendingMetaAction = true;
2727            } else if (mPendingMetaAction) {
2728                launchAssistAction(Intent.EXTRA_ASSIST_INPUT_HINT_KEYBOARD);
2729            }
2730            return -1;
2731        }
2732
2733        // Shortcuts are invoked through Search+key, so intercept those here
2734        // Any printing key that is chorded with Search should be consumed
2735        // even if no shortcut was invoked.  This prevents text from being
2736        // inadvertently inserted when using a keyboard that has built-in macro
2737        // shortcut keys (that emit Search+x) and some of them are not registered.
2738        if (mSearchKeyShortcutPending) {
2739            final KeyCharacterMap kcm = event.getKeyCharacterMap();
2740            if (kcm.isPrintingKey(keyCode)) {
2741                mConsumeSearchKeyUp = true;
2742                mSearchKeyShortcutPending = false;
2743                if (down && repeatCount == 0 && !keyguardOn) {
2744                    Intent shortcutIntent = mShortcutManager.getIntent(kcm, keyCode, metaState);
2745                    if (shortcutIntent != null) {
2746                        shortcutIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
2747                        try {
2748                            startActivityAsUser(shortcutIntent, UserHandle.CURRENT);
2749                        } catch (ActivityNotFoundException ex) {
2750                            Slog.w(TAG, "Dropping shortcut key combination because "
2751                                    + "the activity to which it is registered was not found: "
2752                                    + "SEARCH+" + KeyEvent.keyCodeToString(keyCode), ex);
2753                        }
2754                    } else {
2755                        Slog.i(TAG, "Dropping unregistered shortcut key combination: "
2756                                + "SEARCH+" + KeyEvent.keyCodeToString(keyCode));
2757                    }
2758                }
2759                return -1;
2760            }
2761        }
2762
2763        // Invoke shortcuts using Meta.
2764        if (down && repeatCount == 0 && !keyguardOn
2765                && (metaState & KeyEvent.META_META_ON) != 0) {
2766            final KeyCharacterMap kcm = event.getKeyCharacterMap();
2767            if (kcm.isPrintingKey(keyCode)) {
2768                Intent shortcutIntent = mShortcutManager.getIntent(kcm, keyCode,
2769                        metaState & ~(KeyEvent.META_META_ON
2770                                | KeyEvent.META_META_LEFT_ON | KeyEvent.META_META_RIGHT_ON));
2771                if (shortcutIntent != null) {
2772                    shortcutIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
2773                    try {
2774                        startActivityAsUser(shortcutIntent, UserHandle.CURRENT);
2775                    } catch (ActivityNotFoundException ex) {
2776                        Slog.w(TAG, "Dropping shortcut key combination because "
2777                                + "the activity to which it is registered was not found: "
2778                                + "META+" + KeyEvent.keyCodeToString(keyCode), ex);
2779                    }
2780                    return -1;
2781                }
2782            }
2783        }
2784
2785        // Handle application launch keys.
2786        if (down && repeatCount == 0 && !keyguardOn) {
2787            String category = sApplicationLaunchKeyCategories.get(keyCode);
2788            if (category != null) {
2789                Intent intent = Intent.makeMainSelectorActivity(Intent.ACTION_MAIN, category);
2790                intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
2791                try {
2792                    startActivityAsUser(intent, UserHandle.CURRENT);
2793                } catch (ActivityNotFoundException ex) {
2794                    Slog.w(TAG, "Dropping application launch key because "
2795                            + "the activity to which it is registered was not found: "
2796                            + "keyCode=" + keyCode + ", category=" + category, ex);
2797                }
2798                return -1;
2799            }
2800        }
2801
2802        // Display task switcher for ALT-TAB.
2803        if (down && repeatCount == 0 && keyCode == KeyEvent.KEYCODE_TAB) {
2804            if (mRecentAppsHeldModifiers == 0 && !keyguardOn) {
2805                final int shiftlessModifiers = event.getModifiers() & ~KeyEvent.META_SHIFT_MASK;
2806                if (KeyEvent.metaStateHasModifiers(shiftlessModifiers, KeyEvent.META_ALT_ON)) {
2807                    mRecentAppsHeldModifiers = shiftlessModifiers;
2808                    showRecentApps(true);
2809                    return -1;
2810                }
2811            }
2812        } else if (!down && mRecentAppsHeldModifiers != 0
2813                && (metaState & mRecentAppsHeldModifiers) == 0) {
2814            mRecentAppsHeldModifiers = 0;
2815            hideRecentApps(true, false);
2816        }
2817
2818        // Handle keyboard language switching.
2819        if (down && repeatCount == 0
2820                && (keyCode == KeyEvent.KEYCODE_LANGUAGE_SWITCH
2821                        || (keyCode == KeyEvent.KEYCODE_SPACE
2822                                && (metaState & KeyEvent.META_CTRL_MASK) != 0))) {
2823            int direction = (metaState & KeyEvent.META_SHIFT_MASK) != 0 ? -1 : 1;
2824            mWindowManagerFuncs.switchKeyboardLayout(event.getDeviceId(), direction);
2825            return -1;
2826        }
2827        if (mLanguageSwitchKeyPressed && !down
2828                && (keyCode == KeyEvent.KEYCODE_LANGUAGE_SWITCH
2829                        || keyCode == KeyEvent.KEYCODE_SPACE)) {
2830            mLanguageSwitchKeyPressed = false;
2831            return -1;
2832        }
2833
2834        if (isValidGlobalKey(keyCode)
2835                && mGlobalKeyManager.handleGlobalKey(mContext, keyCode, event)) {
2836            return -1;
2837        }
2838
2839        // Reserve all the META modifier combos for system behavior
2840        if ((metaState & KeyEvent.META_META_ON) != 0) {
2841            return -1;
2842        }
2843
2844        // Let the application handle the key.
2845        return 0;
2846    }
2847
2848    /** {@inheritDoc} */
2849    @Override
2850    public KeyEvent dispatchUnhandledKey(WindowState win, KeyEvent event, int policyFlags) {
2851        // Note: This method is only called if the initial down was unhandled.
2852        if (DEBUG_INPUT) {
2853            Slog.d(TAG, "Unhandled key: win=" + win + ", action=" + event.getAction()
2854                    + ", flags=" + event.getFlags()
2855                    + ", keyCode=" + event.getKeyCode()
2856                    + ", scanCode=" + event.getScanCode()
2857                    + ", metaState=" + event.getMetaState()
2858                    + ", repeatCount=" + event.getRepeatCount()
2859                    + ", policyFlags=" + policyFlags);
2860        }
2861
2862        KeyEvent fallbackEvent = null;
2863        if ((event.getFlags() & KeyEvent.FLAG_FALLBACK) == 0) {
2864            final KeyCharacterMap kcm = event.getKeyCharacterMap();
2865            final int keyCode = event.getKeyCode();
2866            final int metaState = event.getMetaState();
2867            final boolean initialDown = event.getAction() == KeyEvent.ACTION_DOWN
2868                    && event.getRepeatCount() == 0;
2869
2870            // Check for fallback actions specified by the key character map.
2871            final FallbackAction fallbackAction;
2872            if (initialDown) {
2873                fallbackAction = kcm.getFallbackAction(keyCode, metaState);
2874            } else {
2875                fallbackAction = mFallbackActions.get(keyCode);
2876            }
2877
2878            if (fallbackAction != null) {
2879                if (DEBUG_INPUT) {
2880                    Slog.d(TAG, "Fallback: keyCode=" + fallbackAction.keyCode
2881                            + " metaState=" + Integer.toHexString(fallbackAction.metaState));
2882                }
2883
2884                final int flags = event.getFlags() | KeyEvent.FLAG_FALLBACK;
2885                fallbackEvent = KeyEvent.obtain(
2886                        event.getDownTime(), event.getEventTime(),
2887                        event.getAction(), fallbackAction.keyCode,
2888                        event.getRepeatCount(), fallbackAction.metaState,
2889                        event.getDeviceId(), event.getScanCode(),
2890                        flags, event.getSource(), null);
2891
2892                if (!interceptFallback(win, fallbackEvent, policyFlags)) {
2893                    fallbackEvent.recycle();
2894                    fallbackEvent = null;
2895                }
2896
2897                if (initialDown) {
2898                    mFallbackActions.put(keyCode, fallbackAction);
2899                } else if (event.getAction() == KeyEvent.ACTION_UP) {
2900                    mFallbackActions.remove(keyCode);
2901                    fallbackAction.recycle();
2902                }
2903            }
2904        }
2905
2906        if (DEBUG_INPUT) {
2907            if (fallbackEvent == null) {
2908                Slog.d(TAG, "No fallback.");
2909            } else {
2910                Slog.d(TAG, "Performing fallback: " + fallbackEvent);
2911            }
2912        }
2913        return fallbackEvent;
2914    }
2915
2916    private boolean interceptFallback(WindowState win, KeyEvent fallbackEvent, int policyFlags) {
2917        int actions = interceptKeyBeforeQueueing(fallbackEvent, policyFlags);
2918        if ((actions & ACTION_PASS_TO_USER) != 0) {
2919            long delayMillis = interceptKeyBeforeDispatching(
2920                    win, fallbackEvent, policyFlags);
2921            if (delayMillis == 0) {
2922                return true;
2923            }
2924        }
2925        return false;
2926    }
2927
2928    private void launchAssistLongPressAction() {
2929        performHapticFeedbackLw(null, HapticFeedbackConstants.LONG_PRESS, false);
2930        sendCloseSystemWindows(SYSTEM_DIALOG_REASON_ASSIST);
2931
2932        // launch the search activity
2933        Intent intent = new Intent(Intent.ACTION_SEARCH_LONG_PRESS);
2934        intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
2935        try {
2936            // TODO: This only stops the factory-installed search manager.
2937            // Need to formalize an API to handle others
2938            SearchManager searchManager = getSearchManager();
2939            if (searchManager != null) {
2940                searchManager.stopSearch();
2941            }
2942            startActivityAsUser(intent, UserHandle.CURRENT);
2943        } catch (ActivityNotFoundException e) {
2944            Slog.w(TAG, "No activity to handle assist long press action.", e);
2945        }
2946    }
2947
2948    private void launchAssistAction() {
2949        launchAssistAction(null);
2950    }
2951
2952    private void launchAssistAction(String hint) {
2953        sendCloseSystemWindows(SYSTEM_DIALOG_REASON_ASSIST);
2954        Intent intent = ((SearchManager) mContext.getSystemService(Context.SEARCH_SERVICE))
2955                .getAssistIntent(mContext, true, UserHandle.USER_CURRENT);
2956        if (intent != null) {
2957            if (hint != null) {
2958                intent.putExtra(hint, true);
2959            }
2960            intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK
2961                    | Intent.FLAG_ACTIVITY_SINGLE_TOP
2962                    | Intent.FLAG_ACTIVITY_CLEAR_TOP);
2963            try {
2964                startActivityAsUser(intent, UserHandle.CURRENT);
2965            } catch (ActivityNotFoundException e) {
2966                Slog.w(TAG, "No activity to handle assist action.", e);
2967            }
2968        }
2969    }
2970
2971    private void startActivityAsUser(Intent intent, UserHandle handle) {
2972        if (isUserSetupComplete()) {
2973            mContext.startActivityAsUser(intent, handle);
2974        } else {
2975            Slog.i(TAG, "Not starting activity because user setup is in progress: " + intent);
2976        }
2977    }
2978
2979    private SearchManager getSearchManager() {
2980        if (mSearchManager == null) {
2981            mSearchManager = (SearchManager) mContext.getSystemService(Context.SEARCH_SERVICE);
2982        }
2983        return mSearchManager;
2984    }
2985
2986    private void preloadRecentApps() {
2987        mPreloadedRecentApps = true;
2988        try {
2989            IStatusBarService statusbar = getStatusBarService();
2990            if (statusbar != null) {
2991                statusbar.preloadRecentApps();
2992            }
2993        } catch (RemoteException e) {
2994            Slog.e(TAG, "RemoteException when preloading recent apps", e);
2995            // re-acquire status bar service next time it is needed.
2996            mStatusBarService = null;
2997        }
2998    }
2999
3000    private void cancelPreloadRecentApps() {
3001        if (mPreloadedRecentApps) {
3002            mPreloadedRecentApps = false;
3003            try {
3004                IStatusBarService statusbar = getStatusBarService();
3005                if (statusbar != null) {
3006                    statusbar.cancelPreloadRecentApps();
3007                }
3008            } catch (RemoteException e) {
3009                Slog.e(TAG, "RemoteException when cancelling recent apps preload", e);
3010                // re-acquire status bar service next time it is needed.
3011                mStatusBarService = null;
3012            }
3013        }
3014    }
3015
3016    private void toggleRecentApps() {
3017        mPreloadedRecentApps = false; // preloading no longer needs to be canceled
3018        try {
3019            IStatusBarService statusbar = getStatusBarService();
3020            if (statusbar != null) {
3021                statusbar.toggleRecentApps();
3022            }
3023        } catch (RemoteException e) {
3024            Slog.e(TAG, "RemoteException when toggling recent apps", e);
3025            // re-acquire status bar service next time it is needed.
3026            mStatusBarService = null;
3027        }
3028    }
3029
3030    @Override
3031    public void showRecentApps() {
3032        mHandler.removeMessages(MSG_DISPATCH_SHOW_RECENTS);
3033        mHandler.sendEmptyMessage(MSG_DISPATCH_SHOW_RECENTS);
3034    }
3035
3036    private void showRecentApps(boolean triggeredFromAltTab) {
3037        mPreloadedRecentApps = false; // preloading no longer needs to be canceled
3038        try {
3039            IStatusBarService statusbar = getStatusBarService();
3040            if (statusbar != null) {
3041                statusbar.showRecentApps(triggeredFromAltTab);
3042            }
3043        } catch (RemoteException e) {
3044            Slog.e(TAG, "RemoteException when showing recent apps", e);
3045            // re-acquire status bar service next time it is needed.
3046            mStatusBarService = null;
3047        }
3048    }
3049
3050    private void hideRecentApps(boolean triggeredFromAltTab, boolean triggeredFromHome) {
3051        mPreloadedRecentApps = false; // preloading no longer needs to be canceled
3052        try {
3053            IStatusBarService statusbar = getStatusBarService();
3054            if (statusbar != null) {
3055                statusbar.hideRecentApps(triggeredFromAltTab, triggeredFromHome);
3056            }
3057        } catch (RemoteException e) {
3058            Slog.e(TAG, "RemoteException when closing recent apps", e);
3059            // re-acquire status bar service next time it is needed.
3060            mStatusBarService = null;
3061        }
3062    }
3063
3064    void launchHomeFromHotKey() {
3065        launchHomeFromHotKey(true /* awakenFromDreams */, true /*respectKeyguard*/);
3066    }
3067
3068    /**
3069     * A home key -> launch home action was detected.  Take the appropriate action
3070     * given the situation with the keyguard.
3071     */
3072    void launchHomeFromHotKey(final boolean awakenFromDreams, final boolean respectKeyguard) {
3073        if (respectKeyguard) {
3074            if (isKeyguardShowingAndNotOccluded()) {
3075                // don't launch home if keyguard showing
3076                return;
3077            }
3078
3079            if (!mHideLockScreen && mKeyguardDelegate.isInputRestricted()) {
3080                // when in keyguard restricted mode, must first verify unlock
3081                // before launching home
3082                mKeyguardDelegate.verifyUnlock(new OnKeyguardExitResult() {
3083                    @Override
3084                    public void onKeyguardExitResult(boolean success) {
3085                        if (success) {
3086                            try {
3087                                ActivityManagerNative.getDefault().stopAppSwitches();
3088                            } catch (RemoteException e) {
3089                            }
3090                            sendCloseSystemWindows(SYSTEM_DIALOG_REASON_HOME_KEY);
3091                            startDockOrHome(true /*fromHomeKey*/, awakenFromDreams);
3092                        }
3093                    }
3094                });
3095                return;
3096            }
3097        }
3098
3099        // no keyguard stuff to worry about, just launch home!
3100        try {
3101            ActivityManagerNative.getDefault().stopAppSwitches();
3102        } catch (RemoteException e) {
3103        }
3104        if (mRecentsVisible) {
3105            // Hide Recents and notify it to launch Home
3106            if (awakenFromDreams) {
3107                awakenDreams();
3108            }
3109            sendCloseSystemWindows(SYSTEM_DIALOG_REASON_HOME_KEY);
3110            hideRecentApps(false, true);
3111        } else {
3112            // Otherwise, just launch Home
3113            sendCloseSystemWindows(SYSTEM_DIALOG_REASON_HOME_KEY);
3114            startDockOrHome(true /*fromHomeKey*/, awakenFromDreams);
3115        }
3116    }
3117
3118    private final Runnable mClearHideNavigationFlag = new Runnable() {
3119        @Override
3120        public void run() {
3121            synchronized (mWindowManagerFuncs.getWindowManagerLock()) {
3122                // Clear flags.
3123                mForceClearedSystemUiFlags &=
3124                        ~View.SYSTEM_UI_FLAG_HIDE_NAVIGATION;
3125            }
3126            mWindowManagerFuncs.reevaluateStatusBarVisibility();
3127        }
3128    };
3129
3130    /**
3131     * Input handler used while nav bar is hidden.  Captures any touch on the screen,
3132     * to determine when the nav bar should be shown and prevent applications from
3133     * receiving those touches.
3134     */
3135    final class HideNavInputEventReceiver extends InputEventReceiver {
3136        public HideNavInputEventReceiver(InputChannel inputChannel, Looper looper) {
3137            super(inputChannel, looper);
3138        }
3139
3140        @Override
3141        public void onInputEvent(InputEvent event) {
3142            boolean handled = false;
3143            try {
3144                if (event instanceof MotionEvent
3145                        && (event.getSource() & InputDevice.SOURCE_CLASS_POINTER) != 0) {
3146                    final MotionEvent motionEvent = (MotionEvent)event;
3147                    if (motionEvent.getAction() == MotionEvent.ACTION_DOWN) {
3148                        // When the user taps down, we re-show the nav bar.
3149                        boolean changed = false;
3150                        synchronized (mWindowManagerFuncs.getWindowManagerLock()) {
3151                            // Any user activity always causes us to show the
3152                            // navigation controls, if they had been hidden.
3153                            // We also clear the low profile and only content
3154                            // flags so that tapping on the screen will atomically
3155                            // restore all currently hidden screen decorations.
3156                            int newVal = mResettingSystemUiFlags |
3157                                    View.SYSTEM_UI_FLAG_HIDE_NAVIGATION |
3158                                    View.SYSTEM_UI_FLAG_LOW_PROFILE |
3159                                    View.SYSTEM_UI_FLAG_FULLSCREEN;
3160                            if (mResettingSystemUiFlags != newVal) {
3161                                mResettingSystemUiFlags = newVal;
3162                                changed = true;
3163                            }
3164                            // We don't allow the system's nav bar to be hidden
3165                            // again for 1 second, to prevent applications from
3166                            // spamming us and keeping it from being shown.
3167                            newVal = mForceClearedSystemUiFlags |
3168                                    View.SYSTEM_UI_FLAG_HIDE_NAVIGATION;
3169                            if (mForceClearedSystemUiFlags != newVal) {
3170                                mForceClearedSystemUiFlags = newVal;
3171                                changed = true;
3172                                mHandler.postDelayed(mClearHideNavigationFlag, 1000);
3173                            }
3174                        }
3175                        if (changed) {
3176                            mWindowManagerFuncs.reevaluateStatusBarVisibility();
3177                        }
3178                    }
3179                }
3180            } finally {
3181                finishInputEvent(event, handled);
3182            }
3183        }
3184    }
3185    final InputEventReceiver.Factory mHideNavInputEventReceiverFactory =
3186            new InputEventReceiver.Factory() {
3187        @Override
3188        public InputEventReceiver createInputEventReceiver(
3189                InputChannel inputChannel, Looper looper) {
3190            return new HideNavInputEventReceiver(inputChannel, looper);
3191        }
3192    };
3193
3194    @Override
3195    public int adjustSystemUiVisibilityLw(int visibility) {
3196        mStatusBarController.adjustSystemUiVisibilityLw(mLastSystemUiFlags, visibility);
3197        mNavigationBarController.adjustSystemUiVisibilityLw(mLastSystemUiFlags, visibility);
3198        mRecentsVisible = (visibility & View.RECENT_APPS_VISIBLE) > 0;
3199
3200        // Reset any bits in mForceClearingStatusBarVisibility that
3201        // are now clear.
3202        mResettingSystemUiFlags &= visibility;
3203        // Clear any bits in the new visibility that are currently being
3204        // force cleared, before reporting it.
3205        return visibility & ~mResettingSystemUiFlags
3206                & ~mForceClearedSystemUiFlags;
3207    }
3208
3209    @Override
3210    public void getInsetHintLw(WindowManager.LayoutParams attrs, Rect outContentInsets,
3211            Rect outStableInsets) {
3212        final int fl = PolicyControl.getWindowFlags(null, attrs);
3213        final int sysuiVis = PolicyControl.getSystemUiVisibility(null, attrs);
3214        final int systemUiVisibility = (sysuiVis | attrs.subtreeSystemUiVisibility);
3215
3216        if ((fl & (FLAG_LAYOUT_IN_SCREEN | FLAG_LAYOUT_INSET_DECOR))
3217                == (FLAG_LAYOUT_IN_SCREEN | FLAG_LAYOUT_INSET_DECOR)) {
3218            int availRight, availBottom;
3219            if (canHideNavigationBar() &&
3220                    (systemUiVisibility & View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION) != 0) {
3221                availRight = mUnrestrictedScreenLeft + mUnrestrictedScreenWidth;
3222                availBottom = mUnrestrictedScreenTop + mUnrestrictedScreenHeight;
3223            } else {
3224                availRight = mRestrictedScreenLeft + mRestrictedScreenWidth;
3225                availBottom = mRestrictedScreenTop + mRestrictedScreenHeight;
3226            }
3227            if ((systemUiVisibility & View.SYSTEM_UI_FLAG_LAYOUT_STABLE) != 0) {
3228                if ((fl & FLAG_FULLSCREEN) != 0) {
3229                    outContentInsets.set(mStableFullscreenLeft, mStableFullscreenTop,
3230                            availRight - mStableFullscreenRight,
3231                            availBottom - mStableFullscreenBottom);
3232                } else {
3233                    outContentInsets.set(mStableLeft, mStableTop,
3234                            availRight - mStableRight, availBottom - mStableBottom);
3235                }
3236            } else if ((fl & FLAG_FULLSCREEN) != 0 || (fl & FLAG_LAYOUT_IN_OVERSCAN) != 0) {
3237                outContentInsets.setEmpty();
3238            } else if ((systemUiVisibility & (View.SYSTEM_UI_FLAG_FULLSCREEN
3239                        | View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN)) == 0) {
3240                outContentInsets.set(mCurLeft, mCurTop,
3241                        availRight - mCurRight, availBottom - mCurBottom);
3242            } else {
3243                outContentInsets.set(mCurLeft, mCurTop,
3244                        availRight - mCurRight, availBottom - mCurBottom);
3245            }
3246
3247            outStableInsets.set(mStableLeft, mStableTop,
3248                    availRight - mStableRight, availBottom - mStableBottom);
3249            return;
3250        }
3251        outContentInsets.setEmpty();
3252        outStableInsets.setEmpty();
3253    }
3254
3255    /** {@inheritDoc} */
3256    @Override
3257    public void beginLayoutLw(boolean isDefaultDisplay, int displayWidth, int displayHeight,
3258                              int displayRotation) {
3259        final int overscanLeft, overscanTop, overscanRight, overscanBottom;
3260        if (isDefaultDisplay) {
3261            switch (displayRotation) {
3262                case Surface.ROTATION_90:
3263                    overscanLeft = mOverscanTop;
3264                    overscanTop = mOverscanRight;
3265                    overscanRight = mOverscanBottom;
3266                    overscanBottom = mOverscanLeft;
3267                    break;
3268                case Surface.ROTATION_180:
3269                    overscanLeft = mOverscanRight;
3270                    overscanTop = mOverscanBottom;
3271                    overscanRight = mOverscanLeft;
3272                    overscanBottom = mOverscanTop;
3273                    break;
3274                case Surface.ROTATION_270:
3275                    overscanLeft = mOverscanBottom;
3276                    overscanTop = mOverscanLeft;
3277                    overscanRight = mOverscanTop;
3278                    overscanBottom = mOverscanRight;
3279                    break;
3280                default:
3281                    overscanLeft = mOverscanLeft;
3282                    overscanTop = mOverscanTop;
3283                    overscanRight = mOverscanRight;
3284                    overscanBottom = mOverscanBottom;
3285                    break;
3286            }
3287        } else {
3288            overscanLeft = 0;
3289            overscanTop = 0;
3290            overscanRight = 0;
3291            overscanBottom = 0;
3292        }
3293        mOverscanScreenLeft = mRestrictedOverscanScreenLeft = 0;
3294        mOverscanScreenTop = mRestrictedOverscanScreenTop = 0;
3295        mOverscanScreenWidth = mRestrictedOverscanScreenWidth = displayWidth;
3296        mOverscanScreenHeight = mRestrictedOverscanScreenHeight = displayHeight;
3297        mSystemLeft = 0;
3298        mSystemTop = 0;
3299        mSystemRight = displayWidth;
3300        mSystemBottom = displayHeight;
3301        mUnrestrictedScreenLeft = overscanLeft;
3302        mUnrestrictedScreenTop = overscanTop;
3303        mUnrestrictedScreenWidth = displayWidth - overscanLeft - overscanRight;
3304        mUnrestrictedScreenHeight = displayHeight - overscanTop - overscanBottom;
3305        mRestrictedScreenLeft = mUnrestrictedScreenLeft;
3306        mRestrictedScreenTop = mUnrestrictedScreenTop;
3307        mRestrictedScreenWidth = mSystemGestures.screenWidth = mUnrestrictedScreenWidth;
3308        mRestrictedScreenHeight = mSystemGestures.screenHeight = mUnrestrictedScreenHeight;
3309        mDockLeft = mContentLeft = mVoiceContentLeft = mStableLeft = mStableFullscreenLeft
3310                = mCurLeft = mUnrestrictedScreenLeft;
3311        mDockTop = mContentTop = mVoiceContentTop = mStableTop = mStableFullscreenTop
3312                = mCurTop = mUnrestrictedScreenTop;
3313        mDockRight = mContentRight = mVoiceContentRight = mStableRight = mStableFullscreenRight
3314                = mCurRight = displayWidth - overscanRight;
3315        mDockBottom = mContentBottom = mVoiceContentBottom = mStableBottom = mStableFullscreenBottom
3316                = mCurBottom = displayHeight - overscanBottom;
3317        mDockLayer = 0x10000000;
3318        mStatusBarLayer = -1;
3319
3320        // start with the current dock rect, which will be (0,0,displayWidth,displayHeight)
3321        final Rect pf = mTmpParentFrame;
3322        final Rect df = mTmpDisplayFrame;
3323        final Rect of = mTmpOverscanFrame;
3324        final Rect vf = mTmpVisibleFrame;
3325        final Rect dcf = mTmpDecorFrame;
3326        pf.left = df.left = of.left = vf.left = mDockLeft;
3327        pf.top = df.top = of.top = vf.top = mDockTop;
3328        pf.right = df.right = of.right = vf.right = mDockRight;
3329        pf.bottom = df.bottom = of.bottom = vf.bottom = mDockBottom;
3330        dcf.setEmpty();  // Decor frame N/A for system bars.
3331
3332        if (isDefaultDisplay) {
3333            // For purposes of putting out fake window up to steal focus, we will
3334            // drive nav being hidden only by whether it is requested.
3335            final int sysui = mLastSystemUiFlags;
3336            boolean navVisible = (sysui & View.SYSTEM_UI_FLAG_HIDE_NAVIGATION) == 0;
3337            boolean navTranslucent = (sysui
3338                    & (View.NAVIGATION_BAR_TRANSLUCENT | View.SYSTEM_UI_TRANSPARENT)) != 0;
3339            boolean immersive = (sysui & View.SYSTEM_UI_FLAG_IMMERSIVE) != 0;
3340            boolean immersiveSticky = (sysui & View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY) != 0;
3341            boolean navAllowedHidden = immersive || immersiveSticky;
3342            navTranslucent &= !immersiveSticky;  // transient trumps translucent
3343            boolean isKeyguardShowing = isStatusBarKeyguard() && !mHideLockScreen;
3344            if (!isKeyguardShowing) {
3345                navTranslucent &= areTranslucentBarsAllowed();
3346            }
3347
3348            // When the navigation bar isn't visible, we put up a fake
3349            // input window to catch all touch events.  This way we can
3350            // detect when the user presses anywhere to bring back the nav
3351            // bar and ensure the application doesn't see the event.
3352            if (navVisible || navAllowedHidden) {
3353                if (mHideNavFakeWindow != null) {
3354                    mHideNavFakeWindow.dismiss();
3355                    mHideNavFakeWindow = null;
3356                }
3357            } else if (mHideNavFakeWindow == null) {
3358                mHideNavFakeWindow = mWindowManagerFuncs.addFakeWindow(
3359                        mHandler.getLooper(), mHideNavInputEventReceiverFactory,
3360                        "hidden nav", WindowManager.LayoutParams.TYPE_HIDDEN_NAV_CONSUMER, 0,
3361                        0, false, false, true);
3362            }
3363
3364            // For purposes of positioning and showing the nav bar, if we have
3365            // decided that it can't be hidden (because of the screen aspect ratio),
3366            // then take that into account.
3367            navVisible |= !canHideNavigationBar();
3368
3369            boolean updateSysUiVisibility = false;
3370            if (mNavigationBar != null) {
3371                boolean transientNavBarShowing = mNavigationBarController.isTransientShowing();
3372                // Force the navigation bar to its appropriate place and
3373                // size.  We need to do this directly, instead of relying on
3374                // it to bubble up from the nav bar, because this needs to
3375                // change atomically with screen rotations.
3376                mNavigationBarOnBottom = (!mNavigationBarCanMove || displayWidth < displayHeight);
3377                if (mNavigationBarOnBottom) {
3378                    // It's a system nav bar or a portrait screen; nav bar goes on bottom.
3379                    int top = displayHeight - overscanBottom
3380                            - mNavigationBarHeightForRotation[displayRotation];
3381                    mTmpNavigationFrame.set(0, top, displayWidth, displayHeight - overscanBottom);
3382                    mStableBottom = mStableFullscreenBottom = mTmpNavigationFrame.top;
3383                    if (transientNavBarShowing) {
3384                        mNavigationBarController.setBarShowingLw(true);
3385                    } else if (navVisible) {
3386                        mNavigationBarController.setBarShowingLw(true);
3387                        mDockBottom = mTmpNavigationFrame.top;
3388                        mRestrictedScreenHeight = mDockBottom - mRestrictedScreenTop;
3389                        mRestrictedOverscanScreenHeight = mDockBottom - mRestrictedOverscanScreenTop;
3390                    } else {
3391                        // We currently want to hide the navigation UI.
3392                        mNavigationBarController.setBarShowingLw(false);
3393                    }
3394                    if (navVisible && !navTranslucent && !navAllowedHidden
3395                            && !mNavigationBar.isAnimatingLw()
3396                            && !mNavigationBarController.wasRecentlyTranslucent()) {
3397                        // If the opaque nav bar is currently requested to be visible,
3398                        // and not in the process of animating on or off, then
3399                        // we can tell the app that it is covered by it.
3400                        mSystemBottom = mTmpNavigationFrame.top;
3401                    }
3402                } else {
3403                    // Landscape screen; nav bar goes to the right.
3404                    int left = displayWidth - overscanRight
3405                            - mNavigationBarWidthForRotation[displayRotation];
3406                    mTmpNavigationFrame.set(left, 0, displayWidth - overscanRight, displayHeight);
3407                    mStableRight = mStableFullscreenRight = mTmpNavigationFrame.left;
3408                    if (transientNavBarShowing) {
3409                        mNavigationBarController.setBarShowingLw(true);
3410                    } else if (navVisible) {
3411                        mNavigationBarController.setBarShowingLw(true);
3412                        mDockRight = mTmpNavigationFrame.left;
3413                        mRestrictedScreenWidth = mDockRight - mRestrictedScreenLeft;
3414                        mRestrictedOverscanScreenWidth = mDockRight - mRestrictedOverscanScreenLeft;
3415                    } else {
3416                        // We currently want to hide the navigation UI.
3417                        mNavigationBarController.setBarShowingLw(false);
3418                    }
3419                    if (navVisible && !navTranslucent && !mNavigationBar.isAnimatingLw()
3420                            && !mNavigationBarController.wasRecentlyTranslucent()) {
3421                        // If the nav bar is currently requested to be visible,
3422                        // and not in the process of animating on or off, then
3423                        // we can tell the app that it is covered by it.
3424                        mSystemRight = mTmpNavigationFrame.left;
3425                    }
3426                }
3427                // Make sure the content and current rectangles are updated to
3428                // account for the restrictions from the navigation bar.
3429                mContentTop = mVoiceContentTop = mCurTop = mDockTop;
3430                mContentBottom = mVoiceContentBottom = mCurBottom = mDockBottom;
3431                mContentLeft = mVoiceContentLeft = mCurLeft = mDockLeft;
3432                mContentRight = mVoiceContentRight = mCurRight = mDockRight;
3433                mStatusBarLayer = mNavigationBar.getSurfaceLayer();
3434                // And compute the final frame.
3435                mNavigationBar.computeFrameLw(mTmpNavigationFrame, mTmpNavigationFrame,
3436                        mTmpNavigationFrame, mTmpNavigationFrame, mTmpNavigationFrame, dcf,
3437                        mTmpNavigationFrame);
3438                if (DEBUG_LAYOUT) Slog.i(TAG, "mNavigationBar frame: " + mTmpNavigationFrame);
3439                if (mNavigationBarController.checkHiddenLw()) {
3440                    updateSysUiVisibility = true;
3441                }
3442            }
3443            if (DEBUG_LAYOUT) Slog.i(TAG, String.format("mDock rect: (%d,%d - %d,%d)",
3444                    mDockLeft, mDockTop, mDockRight, mDockBottom));
3445
3446            // decide where the status bar goes ahead of time
3447            if (mStatusBar != null) {
3448                // apply any navigation bar insets
3449                pf.left = df.left = of.left = mUnrestrictedScreenLeft;
3450                pf.top = df.top = of.top = mUnrestrictedScreenTop;
3451                pf.right = df.right = of.right = mUnrestrictedScreenWidth + mUnrestrictedScreenLeft;
3452                pf.bottom = df.bottom = of.bottom = mUnrestrictedScreenHeight
3453                        + mUnrestrictedScreenTop;
3454                vf.left = mStableLeft;
3455                vf.top = mStableTop;
3456                vf.right = mStableRight;
3457                vf.bottom = mStableBottom;
3458
3459                mStatusBarLayer = mStatusBar.getSurfaceLayer();
3460
3461                // Let the status bar determine its size.
3462                mStatusBar.computeFrameLw(pf, df, vf, vf, vf, dcf, vf);
3463
3464                // For layout, the status bar is always at the top with our fixed height.
3465                mStableTop = mUnrestrictedScreenTop + mStatusBarHeight;
3466
3467                boolean statusBarTransient = (sysui & View.STATUS_BAR_TRANSIENT) != 0;
3468                boolean statusBarTranslucent = (sysui
3469                        & (View.STATUS_BAR_TRANSLUCENT | View.SYSTEM_UI_TRANSPARENT)) != 0;
3470                if (!isKeyguardShowing) {
3471                    statusBarTranslucent &= areTranslucentBarsAllowed();
3472                }
3473
3474                // If the status bar is hidden, we don't want to cause
3475                // windows behind it to scroll.
3476                if (mStatusBar.isVisibleLw() && !statusBarTransient) {
3477                    // Status bar may go away, so the screen area it occupies
3478                    // is available to apps but just covering them when the
3479                    // status bar is visible.
3480                    mDockTop = mUnrestrictedScreenTop + mStatusBarHeight;
3481
3482                    mContentTop = mVoiceContentTop = mCurTop = mDockTop;
3483                    mContentBottom = mVoiceContentBottom = mCurBottom = mDockBottom;
3484                    mContentLeft = mVoiceContentLeft = mCurLeft = mDockLeft;
3485                    mContentRight = mVoiceContentRight = mCurRight = mDockRight;
3486
3487                    if (DEBUG_LAYOUT) Slog.v(TAG, "Status bar: " +
3488                        String.format(
3489                            "dock=[%d,%d][%d,%d] content=[%d,%d][%d,%d] cur=[%d,%d][%d,%d]",
3490                            mDockLeft, mDockTop, mDockRight, mDockBottom,
3491                            mContentLeft, mContentTop, mContentRight, mContentBottom,
3492                            mCurLeft, mCurTop, mCurRight, mCurBottom));
3493                }
3494                if (mStatusBar.isVisibleLw() && !mStatusBar.isAnimatingLw()
3495                        && !statusBarTransient && !statusBarTranslucent
3496                        && !mStatusBarController.wasRecentlyTranslucent()) {
3497                    // If the opaque status bar is currently requested to be visible,
3498                    // and not in the process of animating on or off, then
3499                    // we can tell the app that it is covered by it.
3500                    mSystemTop = mUnrestrictedScreenTop + mStatusBarHeight;
3501                }
3502                if (mStatusBarController.checkHiddenLw()) {
3503                    updateSysUiVisibility = true;
3504                }
3505            }
3506            if (updateSysUiVisibility) {
3507                updateSystemUiVisibilityLw();
3508            }
3509        }
3510    }
3511
3512    /** {@inheritDoc} */
3513    @Override
3514    public int getSystemDecorLayerLw() {
3515        if (mStatusBar != null && mStatusBar.isVisibleLw()) {
3516            return mStatusBar.getSurfaceLayer();
3517        }
3518
3519        if (mNavigationBar != null && mNavigationBar.isVisibleLw()) {
3520            return mNavigationBar.getSurfaceLayer();
3521        }
3522
3523        return 0;
3524    }
3525
3526    @Override
3527    public void getContentRectLw(Rect r) {
3528        r.set(mContentLeft, mContentTop, mContentRight, mContentBottom);
3529    }
3530
3531    void setAttachedWindowFrames(WindowState win, int fl, int adjust, WindowState attached,
3532            boolean insetDecors, Rect pf, Rect df, Rect of, Rect cf, Rect vf) {
3533        if (win.getSurfaceLayer() > mDockLayer && attached.getSurfaceLayer() < mDockLayer) {
3534            // Here's a special case: if this attached window is a panel that is
3535            // above the dock window, and the window it is attached to is below
3536            // the dock window, then the frames we computed for the window it is
3537            // attached to can not be used because the dock is effectively part
3538            // of the underlying window and the attached window is floating on top
3539            // of the whole thing.  So, we ignore the attached window and explicitly
3540            // compute the frames that would be appropriate without the dock.
3541            df.left = of.left = cf.left = vf.left = mDockLeft;
3542            df.top = of.top = cf.top = vf.top = mDockTop;
3543            df.right = of.right = cf.right = vf.right = mDockRight;
3544            df.bottom = of.bottom = cf.bottom = vf.bottom = mDockBottom;
3545        } else {
3546            // The effective display frame of the attached window depends on
3547            // whether it is taking care of insetting its content.  If not,
3548            // we need to use the parent's content frame so that the entire
3549            // window is positioned within that content.  Otherwise we can use
3550            // the overscan frame and let the attached window take care of
3551            // positioning its content appropriately.
3552            if (adjust != SOFT_INPUT_ADJUST_RESIZE) {
3553                // Set the content frame of the attached window to the parent's decor frame
3554                // (same as content frame when IME isn't present) if specifically requested by
3555                // setting {@link WindowManager.LayoutParams#FLAG_LAYOUT_ATTACHED_IN_DECOR} flag.
3556                // Otherwise, use the overscan frame.
3557                cf.set((fl & FLAG_LAYOUT_ATTACHED_IN_DECOR) != 0
3558                        ? attached.getContentFrameLw() : attached.getOverscanFrameLw());
3559            } else {
3560                // If the window is resizing, then we want to base the content
3561                // frame on our attached content frame to resize...  however,
3562                // things can be tricky if the attached window is NOT in resize
3563                // mode, in which case its content frame will be larger.
3564                // Ungh.  So to deal with that, make sure the content frame
3565                // we end up using is not covering the IM dock.
3566                cf.set(attached.getContentFrameLw());
3567                if (attached.isVoiceInteraction()) {
3568                    if (cf.left < mVoiceContentLeft) cf.left = mVoiceContentLeft;
3569                    if (cf.top < mVoiceContentTop) cf.top = mVoiceContentTop;
3570                    if (cf.right > mVoiceContentRight) cf.right = mVoiceContentRight;
3571                    if (cf.bottom > mVoiceContentBottom) cf.bottom = mVoiceContentBottom;
3572                } else if (attached.getSurfaceLayer() < mDockLayer) {
3573                    if (cf.left < mContentLeft) cf.left = mContentLeft;
3574                    if (cf.top < mContentTop) cf.top = mContentTop;
3575                    if (cf.right > mContentRight) cf.right = mContentRight;
3576                    if (cf.bottom > mContentBottom) cf.bottom = mContentBottom;
3577                }
3578            }
3579            df.set(insetDecors ? attached.getDisplayFrameLw() : cf);
3580            of.set(insetDecors ? attached.getOverscanFrameLw() : cf);
3581            vf.set(attached.getVisibleFrameLw());
3582        }
3583        // The LAYOUT_IN_SCREEN flag is used to determine whether the attached
3584        // window should be positioned relative to its parent or the entire
3585        // screen.
3586        pf.set((fl & FLAG_LAYOUT_IN_SCREEN) == 0
3587                ? attached.getFrameLw() : df);
3588    }
3589
3590    private void applyStableConstraints(int sysui, int fl, Rect r) {
3591        if ((sysui & View.SYSTEM_UI_FLAG_LAYOUT_STABLE) != 0) {
3592            // If app is requesting a stable layout, don't let the
3593            // content insets go below the stable values.
3594            if ((fl & FLAG_FULLSCREEN) != 0) {
3595                if (r.left < mStableFullscreenLeft) r.left = mStableFullscreenLeft;
3596                if (r.top < mStableFullscreenTop) r.top = mStableFullscreenTop;
3597                if (r.right > mStableFullscreenRight) r.right = mStableFullscreenRight;
3598                if (r.bottom > mStableFullscreenBottom) r.bottom = mStableFullscreenBottom;
3599            } else {
3600                if (r.left < mStableLeft) r.left = mStableLeft;
3601                if (r.top < mStableTop) r.top = mStableTop;
3602                if (r.right > mStableRight) r.right = mStableRight;
3603                if (r.bottom > mStableBottom) r.bottom = mStableBottom;
3604            }
3605        }
3606    }
3607
3608    /** {@inheritDoc} */
3609    @Override
3610    public void layoutWindowLw(WindowState win, WindowState attached) {
3611        // we've already done the status bar
3612        final WindowManager.LayoutParams attrs = win.getAttrs();
3613        if ((win == mStatusBar && (attrs.privateFlags & PRIVATE_FLAG_KEYGUARD) == 0) ||
3614                win == mNavigationBar) {
3615            return;
3616        }
3617        final boolean isDefaultDisplay = win.isDefaultDisplay();
3618        final boolean needsToOffsetInputMethodTarget = isDefaultDisplay &&
3619                (win == mLastInputMethodTargetWindow && mLastInputMethodWindow != null);
3620        if (needsToOffsetInputMethodTarget) {
3621            if (DEBUG_LAYOUT) Slog.i(TAG, "Offset ime target window by the last ime window state");
3622            offsetInputMethodWindowLw(mLastInputMethodWindow);
3623        }
3624
3625        final int fl = PolicyControl.getWindowFlags(win, attrs);
3626        final int sim = attrs.softInputMode;
3627        final int sysUiFl = PolicyControl.getSystemUiVisibility(win, null);
3628
3629        final Rect pf = mTmpParentFrame;
3630        final Rect df = mTmpDisplayFrame;
3631        final Rect of = mTmpOverscanFrame;
3632        final Rect cf = mTmpContentFrame;
3633        final Rect vf = mTmpVisibleFrame;
3634        final Rect dcf = mTmpDecorFrame;
3635        final Rect sf = mTmpStableFrame;
3636        dcf.setEmpty();
3637
3638        final boolean hasNavBar = (isDefaultDisplay && mHasNavigationBar
3639                && mNavigationBar != null && mNavigationBar.isVisibleLw());
3640
3641        final int adjust = sim & SOFT_INPUT_MASK_ADJUST;
3642
3643        if (isDefaultDisplay) {
3644            sf.set(mStableLeft, mStableTop, mStableRight, mStableBottom);
3645        } else {
3646            sf.set(mOverscanLeft, mOverscanTop, mOverscanRight, mOverscanBottom);
3647        }
3648
3649        if (!isDefaultDisplay) {
3650            if (attached != null) {
3651                // If this window is attached to another, our display
3652                // frame is the same as the one we are attached to.
3653                setAttachedWindowFrames(win, fl, adjust, attached, true, pf, df, of, cf, vf);
3654            } else {
3655                // Give the window full screen.
3656                pf.left = df.left = of.left = cf.left = mOverscanScreenLeft;
3657                pf.top = df.top = of.top = cf.top = mOverscanScreenTop;
3658                pf.right = df.right = of.right = cf.right
3659                        = mOverscanScreenLeft + mOverscanScreenWidth;
3660                pf.bottom = df.bottom = of.bottom = cf.bottom
3661                        = mOverscanScreenTop + mOverscanScreenHeight;
3662            }
3663        } else if (attrs.type == TYPE_INPUT_METHOD) {
3664            pf.left = df.left = of.left = cf.left = vf.left = mDockLeft;
3665            pf.top = df.top = of.top = cf.top = vf.top = mDockTop;
3666            pf.right = df.right = of.right = cf.right = vf.right = mDockRight;
3667            // IM dock windows layout below the nav bar...
3668            pf.bottom = df.bottom = of.bottom = mUnrestrictedScreenTop + mUnrestrictedScreenHeight;
3669            // ...with content insets above the nav bar
3670            cf.bottom = vf.bottom = mStableBottom;
3671            // IM dock windows always go to the bottom of the screen.
3672            attrs.gravity = Gravity.BOTTOM;
3673            mDockLayer = win.getSurfaceLayer();
3674        } else if (attrs.type == TYPE_VOICE_INTERACTION) {
3675            pf.left = df.left = of.left = cf.left = vf.left = mUnrestrictedScreenLeft;
3676            pf.top = df.top = of.top = mUnrestrictedScreenTop;
3677            pf.right = df.right = of.right = cf.right = vf.right = mUnrestrictedScreenLeft
3678                    + mUnrestrictedScreenWidth;
3679            pf.bottom = df.bottom = of.bottom = cf.bottom = mUnrestrictedScreenTop
3680                    + mUnrestrictedScreenHeight;
3681            cf.bottom = vf.bottom = mStableBottom;
3682            cf.top = vf.top = mStableTop;
3683        } else if (win == mStatusBar && (attrs.privateFlags & PRIVATE_FLAG_KEYGUARD) != 0) {
3684            pf.left = df.left = of.left = mUnrestrictedScreenLeft;
3685            pf.top = df.top = of.top = mUnrestrictedScreenTop;
3686            pf.right = df.right = of.right = mUnrestrictedScreenWidth + mUnrestrictedScreenLeft;
3687            pf.bottom = df.bottom = of.bottom = mUnrestrictedScreenHeight + mUnrestrictedScreenTop;
3688            cf.left = vf.left = mStableLeft;
3689            cf.top = vf.top = mStableTop;
3690            cf.right = vf.right = mStableRight;
3691            vf.bottom = mStableBottom;
3692            cf.bottom = mContentBottom;
3693        } else {
3694
3695            // Default policy decor for the default display
3696            dcf.left = mSystemLeft;
3697            dcf.top = mSystemTop;
3698            dcf.right = mSystemRight;
3699            dcf.bottom = mSystemBottom;
3700            final boolean inheritTranslucentDecor = (attrs.privateFlags
3701                    & WindowManager.LayoutParams.PRIVATE_FLAG_INHERIT_TRANSLUCENT_DECOR) != 0;
3702            final boolean isAppWindow =
3703                    attrs.type >= WindowManager.LayoutParams.FIRST_APPLICATION_WINDOW &&
3704                    attrs.type <= WindowManager.LayoutParams.LAST_APPLICATION_WINDOW;
3705            final boolean topAtRest =
3706                    win == mTopFullscreenOpaqueWindowState && !win.isAnimatingLw();
3707            if (isAppWindow && !inheritTranslucentDecor && !topAtRest) {
3708                if ((sysUiFl & View.SYSTEM_UI_FLAG_FULLSCREEN) == 0
3709                        && (fl & WindowManager.LayoutParams.FLAG_FULLSCREEN) == 0
3710                        && (fl & WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS) == 0
3711                        && (fl & WindowManager.LayoutParams.
3712                                FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS) == 0) {
3713                    // Ensure policy decor includes status bar
3714                    dcf.top = mStableTop;
3715                }
3716                if ((fl & WindowManager.LayoutParams.FLAG_TRANSLUCENT_NAVIGATION) == 0
3717                        && (sysUiFl & View.SYSTEM_UI_FLAG_HIDE_NAVIGATION) == 0
3718                        && (fl & WindowManager.LayoutParams.
3719                                FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS) == 0) {
3720                    // Ensure policy decor includes navigation bar
3721                    dcf.bottom = mStableBottom;
3722                    dcf.right = mStableRight;
3723                }
3724            }
3725
3726            if ((fl & (FLAG_LAYOUT_IN_SCREEN | FLAG_LAYOUT_INSET_DECOR))
3727                    == (FLAG_LAYOUT_IN_SCREEN | FLAG_LAYOUT_INSET_DECOR)) {
3728                if (DEBUG_LAYOUT) Slog.v(TAG, "layoutWindowLw(" + attrs.getTitle()
3729                            + "): IN_SCREEN, INSET_DECOR");
3730                // This is the case for a normal activity window: we want it
3731                // to cover all of the screen space, and it can take care of
3732                // moving its contents to account for screen decorations that
3733                // intrude into that space.
3734                if (attached != null) {
3735                    // If this window is attached to another, our display
3736                    // frame is the same as the one we are attached to.
3737                    setAttachedWindowFrames(win, fl, adjust, attached, true, pf, df, of, cf, vf);
3738                } else {
3739                    if (attrs.type == TYPE_STATUS_BAR_PANEL
3740                            || attrs.type == TYPE_STATUS_BAR_SUB_PANEL) {
3741                        // Status bar panels are the only windows who can go on top of
3742                        // the status bar.  They are protected by the STATUS_BAR_SERVICE
3743                        // permission, so they have the same privileges as the status
3744                        // bar itself.
3745                        //
3746                        // However, they should still dodge the navigation bar if it exists.
3747
3748                        pf.left = df.left = of.left = hasNavBar
3749                                ? mDockLeft : mUnrestrictedScreenLeft;
3750                        pf.top = df.top = of.top = mUnrestrictedScreenTop;
3751                        pf.right = df.right = of.right = hasNavBar
3752                                ? mRestrictedScreenLeft+mRestrictedScreenWidth
3753                                : mUnrestrictedScreenLeft + mUnrestrictedScreenWidth;
3754                        pf.bottom = df.bottom = of.bottom = hasNavBar
3755                                ? mRestrictedScreenTop+mRestrictedScreenHeight
3756                                : mUnrestrictedScreenTop + mUnrestrictedScreenHeight;
3757
3758                        if (DEBUG_LAYOUT) Slog.v(TAG, String.format(
3759                                        "Laying out status bar window: (%d,%d - %d,%d)",
3760                                        pf.left, pf.top, pf.right, pf.bottom));
3761                    } else if ((fl & FLAG_LAYOUT_IN_OVERSCAN) != 0
3762                            && attrs.type >= WindowManager.LayoutParams.FIRST_APPLICATION_WINDOW
3763                            && attrs.type <= WindowManager.LayoutParams.LAST_SUB_WINDOW) {
3764                        // Asking to layout into the overscan region, so give it that pure
3765                        // unrestricted area.
3766                        pf.left = df.left = of.left = mOverscanScreenLeft;
3767                        pf.top = df.top = of.top = mOverscanScreenTop;
3768                        pf.right = df.right = of.right = mOverscanScreenLeft + mOverscanScreenWidth;
3769                        pf.bottom = df.bottom = of.bottom = mOverscanScreenTop
3770                                + mOverscanScreenHeight;
3771                    } else if (canHideNavigationBar()
3772                            && (sysUiFl & View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION) != 0
3773                            && attrs.type >= WindowManager.LayoutParams.FIRST_APPLICATION_WINDOW
3774                            && attrs.type <= WindowManager.LayoutParams.LAST_SUB_WINDOW) {
3775                        // Asking for layout as if the nav bar is hidden, lets the
3776                        // application extend into the unrestricted overscan screen area.  We
3777                        // only do this for application windows to ensure no window that
3778                        // can be above the nav bar can do this.
3779                        pf.left = df.left = mOverscanScreenLeft;
3780                        pf.top = df.top = mOverscanScreenTop;
3781                        pf.right = df.right = mOverscanScreenLeft + mOverscanScreenWidth;
3782                        pf.bottom = df.bottom = mOverscanScreenTop + mOverscanScreenHeight;
3783                        // We need to tell the app about where the frame inside the overscan
3784                        // is, so it can inset its content by that amount -- it didn't ask
3785                        // to actually extend itself into the overscan region.
3786                        of.left = mUnrestrictedScreenLeft;
3787                        of.top = mUnrestrictedScreenTop;
3788                        of.right = mUnrestrictedScreenLeft + mUnrestrictedScreenWidth;
3789                        of.bottom = mUnrestrictedScreenTop + mUnrestrictedScreenHeight;
3790                    } else {
3791                        pf.left = df.left = mRestrictedOverscanScreenLeft;
3792                        pf.top = df.top = mRestrictedOverscanScreenTop;
3793                        pf.right = df.right = mRestrictedOverscanScreenLeft
3794                                + mRestrictedOverscanScreenWidth;
3795                        pf.bottom = df.bottom = mRestrictedOverscanScreenTop
3796                                + mRestrictedOverscanScreenHeight;
3797                        // We need to tell the app about where the frame inside the overscan
3798                        // is, so it can inset its content by that amount -- it didn't ask
3799                        // to actually extend itself into the overscan region.
3800                        of.left = mUnrestrictedScreenLeft;
3801                        of.top = mUnrestrictedScreenTop;
3802                        of.right = mUnrestrictedScreenLeft + mUnrestrictedScreenWidth;
3803                        of.bottom = mUnrestrictedScreenTop + mUnrestrictedScreenHeight;
3804                    }
3805
3806                    if ((fl & FLAG_FULLSCREEN) == 0) {
3807                        if (win.isVoiceInteraction()) {
3808                            cf.left = mVoiceContentLeft;
3809                            cf.top = mVoiceContentTop;
3810                            cf.right = mVoiceContentRight;
3811                            cf.bottom = mVoiceContentBottom;
3812                        } else {
3813                            if (adjust != SOFT_INPUT_ADJUST_RESIZE) {
3814                                cf.left = mDockLeft;
3815                                cf.top = mDockTop;
3816                                cf.right = mDockRight;
3817                                cf.bottom = mDockBottom;
3818                            } else {
3819                                cf.left = mContentLeft;
3820                                cf.top = mContentTop;
3821                                cf.right = mContentRight;
3822                                cf.bottom = mContentBottom;
3823                            }
3824                        }
3825                    } else {
3826                        // Full screen windows are always given a layout that is as if the
3827                        // status bar and other transient decors are gone.  This is to avoid
3828                        // bad states when moving from a window that is not hding the
3829                        // status bar to one that is.
3830                        cf.left = mRestrictedScreenLeft;
3831                        cf.top = mRestrictedScreenTop;
3832                        cf.right = mRestrictedScreenLeft + mRestrictedScreenWidth;
3833                        cf.bottom = mRestrictedScreenTop + mRestrictedScreenHeight;
3834                    }
3835                    applyStableConstraints(sysUiFl, fl, cf);
3836                    if (adjust != SOFT_INPUT_ADJUST_NOTHING) {
3837                        vf.left = mCurLeft;
3838                        vf.top = mCurTop;
3839                        vf.right = mCurRight;
3840                        vf.bottom = mCurBottom;
3841                    } else {
3842                        vf.set(cf);
3843                    }
3844                }
3845            } else if ((fl & FLAG_LAYOUT_IN_SCREEN) != 0 || (sysUiFl
3846                    & (View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
3847                            | View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION)) != 0) {
3848                if (DEBUG_LAYOUT) Slog.v(TAG, "layoutWindowLw(" + attrs.getTitle() +
3849                        "): IN_SCREEN");
3850                // A window that has requested to fill the entire screen just
3851                // gets everything, period.
3852                if (attrs.type == TYPE_STATUS_BAR_PANEL
3853                        || attrs.type == TYPE_STATUS_BAR_SUB_PANEL) {
3854                    pf.left = df.left = of.left = cf.left = hasNavBar
3855                            ? mDockLeft : mUnrestrictedScreenLeft;
3856                    pf.top = df.top = of.top = cf.top = mUnrestrictedScreenTop;
3857                    pf.right = df.right = of.right = cf.right = hasNavBar
3858                                        ? mRestrictedScreenLeft+mRestrictedScreenWidth
3859                                        : mUnrestrictedScreenLeft + mUnrestrictedScreenWidth;
3860                    pf.bottom = df.bottom = of.bottom = cf.bottom = hasNavBar
3861                                          ? mRestrictedScreenTop+mRestrictedScreenHeight
3862                                          : mUnrestrictedScreenTop + mUnrestrictedScreenHeight;
3863                    if (DEBUG_LAYOUT) Slog.v(TAG, String.format(
3864                                    "Laying out IN_SCREEN status bar window: (%d,%d - %d,%d)",
3865                                    pf.left, pf.top, pf.right, pf.bottom));
3866                } else if (attrs.type == TYPE_NAVIGATION_BAR
3867                        || attrs.type == TYPE_NAVIGATION_BAR_PANEL) {
3868                    // The navigation bar has Real Ultimate Power.
3869                    pf.left = df.left = of.left = mUnrestrictedScreenLeft;
3870                    pf.top = df.top = of.top = mUnrestrictedScreenTop;
3871                    pf.right = df.right = of.right = mUnrestrictedScreenLeft
3872                            + mUnrestrictedScreenWidth;
3873                    pf.bottom = df.bottom = of.bottom = mUnrestrictedScreenTop
3874                            + mUnrestrictedScreenHeight;
3875                    if (DEBUG_LAYOUT) Slog.v(TAG, String.format(
3876                                    "Laying out navigation bar window: (%d,%d - %d,%d)",
3877                                    pf.left, pf.top, pf.right, pf.bottom));
3878                } else if ((attrs.type == TYPE_SECURE_SYSTEM_OVERLAY
3879                                || attrs.type == TYPE_BOOT_PROGRESS)
3880                        && ((fl & FLAG_FULLSCREEN) != 0)) {
3881                    // Fullscreen secure system overlays get what they ask for.
3882                    pf.left = df.left = of.left = cf.left = mOverscanScreenLeft;
3883                    pf.top = df.top = of.top = cf.top = mOverscanScreenTop;
3884                    pf.right = df.right = of.right = cf.right = mOverscanScreenLeft
3885                            + mOverscanScreenWidth;
3886                    pf.bottom = df.bottom = of.bottom = cf.bottom = mOverscanScreenTop
3887                            + mOverscanScreenHeight;
3888                } else if (attrs.type == TYPE_BOOT_PROGRESS) {
3889                    // Boot progress screen always covers entire display.
3890                    pf.left = df.left = of.left = cf.left = mOverscanScreenLeft;
3891                    pf.top = df.top = of.top = cf.top = mOverscanScreenTop;
3892                    pf.right = df.right = of.right = cf.right = mOverscanScreenLeft
3893                            + mOverscanScreenWidth;
3894                    pf.bottom = df.bottom = of.bottom = cf.bottom = mOverscanScreenTop
3895                            + mOverscanScreenHeight;
3896                } else if (attrs.type == TYPE_WALLPAPER) {
3897                    // The wallpaper also has Real Ultimate Power, but we want to tell
3898                    // it about the overscan area.
3899                    pf.left = df.left = mOverscanScreenLeft;
3900                    pf.top = df.top = mOverscanScreenTop;
3901                    pf.right = df.right = mOverscanScreenLeft + mOverscanScreenWidth;
3902                    pf.bottom = df.bottom = mOverscanScreenTop + mOverscanScreenHeight;
3903                    of.left = cf.left = mUnrestrictedScreenLeft;
3904                    of.top = cf.top = mUnrestrictedScreenTop;
3905                    of.right = cf.right = mUnrestrictedScreenLeft + mUnrestrictedScreenWidth;
3906                    of.bottom = cf.bottom = mUnrestrictedScreenTop + mUnrestrictedScreenHeight;
3907                } else if ((fl & FLAG_LAYOUT_IN_OVERSCAN) != 0
3908                        && attrs.type >= WindowManager.LayoutParams.FIRST_APPLICATION_WINDOW
3909                        && attrs.type <= WindowManager.LayoutParams.LAST_SUB_WINDOW) {
3910                    // Asking to layout into the overscan region, so give it that pure
3911                    // unrestricted area.
3912                    pf.left = df.left = of.left = cf.left = mOverscanScreenLeft;
3913                    pf.top = df.top = of.top = cf.top = mOverscanScreenTop;
3914                    pf.right = df.right = of.right = cf.right
3915                            = mOverscanScreenLeft + mOverscanScreenWidth;
3916                    pf.bottom = df.bottom = of.bottom = cf.bottom
3917                            = mOverscanScreenTop + mOverscanScreenHeight;
3918                } else if (canHideNavigationBar()
3919                        && (sysUiFl & View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION) != 0
3920                        && (attrs.type == TYPE_STATUS_BAR
3921                            || attrs.type == TYPE_TOAST
3922                            || attrs.type == TYPE_VOICE_INTERACTION_STARTING
3923                            || (attrs.type >= WindowManager.LayoutParams.FIRST_APPLICATION_WINDOW
3924                            && attrs.type <= WindowManager.LayoutParams.LAST_SUB_WINDOW))) {
3925                    // Asking for layout as if the nav bar is hidden, lets the
3926                    // application extend into the unrestricted screen area.  We
3927                    // only do this for application windows (or toasts) to ensure no window that
3928                    // can be above the nav bar can do this.
3929                    // XXX This assumes that an app asking for this will also
3930                    // ask for layout in only content.  We can't currently figure out
3931                    // what the screen would be if only laying out to hide the nav bar.
3932                    pf.left = df.left = of.left = cf.left = mUnrestrictedScreenLeft;
3933                    pf.top = df.top = of.top = cf.top = mUnrestrictedScreenTop;
3934                    pf.right = df.right = of.right = cf.right = mUnrestrictedScreenLeft
3935                            + mUnrestrictedScreenWidth;
3936                    pf.bottom = df.bottom = of.bottom = cf.bottom = mUnrestrictedScreenTop
3937                            + mUnrestrictedScreenHeight;
3938                } else {
3939                    pf.left = df.left = of.left = cf.left = mRestrictedScreenLeft;
3940                    pf.top = df.top = of.top = cf.top = mRestrictedScreenTop;
3941                    pf.right = df.right = of.right = cf.right = mRestrictedScreenLeft
3942                            + mRestrictedScreenWidth;
3943                    pf.bottom = df.bottom = of.bottom = cf.bottom = mRestrictedScreenTop
3944                            + mRestrictedScreenHeight;
3945                }
3946
3947                applyStableConstraints(sysUiFl, fl, cf);
3948
3949                if (adjust != SOFT_INPUT_ADJUST_NOTHING) {
3950                    vf.left = mCurLeft;
3951                    vf.top = mCurTop;
3952                    vf.right = mCurRight;
3953                    vf.bottom = mCurBottom;
3954                } else {
3955                    vf.set(cf);
3956                }
3957            } else if (attached != null) {
3958                if (DEBUG_LAYOUT) Slog.v(TAG, "layoutWindowLw(" + attrs.getTitle() +
3959                        "): attached to " + attached);
3960                // A child window should be placed inside of the same visible
3961                // frame that its parent had.
3962                setAttachedWindowFrames(win, fl, adjust, attached, false, pf, df, of, cf, vf);
3963            } else {
3964                if (DEBUG_LAYOUT) Slog.v(TAG, "layoutWindowLw(" + attrs.getTitle() +
3965                        "): normal window");
3966                // Otherwise, a normal window must be placed inside the content
3967                // of all screen decorations.
3968                if (attrs.type == TYPE_STATUS_BAR_PANEL) {
3969                    // Status bar panels are the only windows who can go on top of
3970                    // the status bar.  They are protected by the STATUS_BAR_SERVICE
3971                    // permission, so they have the same privileges as the status
3972                    // bar itself.
3973                    pf.left = df.left = of.left = cf.left = mRestrictedScreenLeft;
3974                    pf.top = df.top = of.top = cf.top = mRestrictedScreenTop;
3975                    pf.right = df.right = of.right = cf.right = mRestrictedScreenLeft
3976                            + mRestrictedScreenWidth;
3977                    pf.bottom = df.bottom = of.bottom = cf.bottom = mRestrictedScreenTop
3978                            + mRestrictedScreenHeight;
3979                } else if (attrs.type == TYPE_TOAST || attrs.type == TYPE_SYSTEM_ALERT
3980                        || attrs.type == TYPE_VOLUME_OVERLAY) {
3981                    // These dialogs are stable to interim decor changes.
3982                    pf.left = df.left = of.left = cf.left = mStableLeft;
3983                    pf.top = df.top = of.top = cf.top = mStableTop;
3984                    pf.right = df.right = of.right = cf.right = mStableRight;
3985                    pf.bottom = df.bottom = of.bottom = cf.bottom = mStableBottom;
3986                } else {
3987                    pf.left = mContentLeft;
3988                    pf.top = mContentTop;
3989                    pf.right = mContentRight;
3990                    pf.bottom = mContentBottom;
3991                    if (win.isVoiceInteraction()) {
3992                        df.left = of.left = cf.left = mVoiceContentLeft;
3993                        df.top = of.top = cf.top = mVoiceContentTop;
3994                        df.right = of.right = cf.right = mVoiceContentRight;
3995                        df.bottom = of.bottom = cf.bottom = mVoiceContentBottom;
3996                    } else if (adjust != SOFT_INPUT_ADJUST_RESIZE) {
3997                        df.left = of.left = cf.left = mDockLeft;
3998                        df.top = of.top = cf.top = mDockTop;
3999                        df.right = of.right = cf.right = mDockRight;
4000                        df.bottom = of.bottom = cf.bottom = mDockBottom;
4001                    } else {
4002                        df.left = of.left = cf.left = mContentLeft;
4003                        df.top = of.top = cf.top = mContentTop;
4004                        df.right = of.right = cf.right = mContentRight;
4005                        df.bottom = of.bottom = cf.bottom = mContentBottom;
4006                    }
4007                    if (adjust != SOFT_INPUT_ADJUST_NOTHING) {
4008                        vf.left = mCurLeft;
4009                        vf.top = mCurTop;
4010                        vf.right = mCurRight;
4011                        vf.bottom = mCurBottom;
4012                    } else {
4013                        vf.set(cf);
4014                    }
4015                }
4016            }
4017        }
4018
4019        // TYPE_SYSTEM_ERROR is above the NavigationBar so it can't be allowed to extend over it.
4020        if ((fl & FLAG_LAYOUT_NO_LIMITS) != 0 && attrs.type != TYPE_SYSTEM_ERROR) {
4021            df.left = df.top = -10000;
4022            df.right = df.bottom = 10000;
4023            if (attrs.type != TYPE_WALLPAPER) {
4024                of.left = of.top = cf.left = cf.top = vf.left = vf.top = -10000;
4025                of.right = of.bottom = cf.right = cf.bottom = vf.right = vf.bottom = 10000;
4026            }
4027        }
4028
4029        if (DEBUG_LAYOUT) Slog.v(TAG, "Compute frame " + attrs.getTitle()
4030                + ": sim=#" + Integer.toHexString(sim)
4031                + " attach=" + attached + " type=" + attrs.type
4032                + String.format(" flags=0x%08x", fl)
4033                + " pf=" + pf.toShortString() + " df=" + df.toShortString()
4034                + " of=" + of.toShortString()
4035                + " cf=" + cf.toShortString() + " vf=" + vf.toShortString()
4036                + " dcf=" + dcf.toShortString()
4037                + " sf=" + sf.toShortString());
4038
4039        win.computeFrameLw(pf, df, of, cf, vf, dcf, sf);
4040
4041        // Dock windows carve out the bottom of the screen, so normal windows
4042        // can't appear underneath them.
4043        if (attrs.type == TYPE_INPUT_METHOD && win.isVisibleOrBehindKeyguardLw()
4044                && !win.getGivenInsetsPendingLw()) {
4045            setLastInputMethodWindowLw(null, null);
4046            offsetInputMethodWindowLw(win);
4047        }
4048        if (attrs.type == TYPE_VOICE_INTERACTION && win.isVisibleOrBehindKeyguardLw()
4049                && !win.getGivenInsetsPendingLw()) {
4050            offsetVoiceInputWindowLw(win);
4051        }
4052    }
4053
4054    private void offsetInputMethodWindowLw(WindowState win) {
4055        int top = Math.max(win.getDisplayFrameLw().top, win.getContentFrameLw().top);
4056        top += win.getGivenContentInsetsLw().top;
4057        if (mContentBottom > top) {
4058            mContentBottom = top;
4059        }
4060        if (mVoiceContentBottom > top) {
4061            mVoiceContentBottom = top;
4062        }
4063        top = win.getVisibleFrameLw().top;
4064        top += win.getGivenVisibleInsetsLw().top;
4065        if (mCurBottom > top) {
4066            mCurBottom = top;
4067        }
4068        if (DEBUG_LAYOUT) Slog.v(TAG, "Input method: mDockBottom="
4069                + mDockBottom + " mContentBottom="
4070                + mContentBottom + " mCurBottom=" + mCurBottom);
4071    }
4072
4073    private void offsetVoiceInputWindowLw(WindowState win) {
4074        int top = Math.max(win.getDisplayFrameLw().top, win.getContentFrameLw().top);
4075        top += win.getGivenContentInsetsLw().top;
4076        if (mVoiceContentBottom > top) {
4077            mVoiceContentBottom = top;
4078        }
4079    }
4080
4081    /** {@inheritDoc} */
4082    @Override
4083    public void finishLayoutLw() {
4084        return;
4085    }
4086
4087    /** {@inheritDoc} */
4088    @Override
4089    public void beginPostLayoutPolicyLw(int displayWidth, int displayHeight) {
4090        mTopFullscreenOpaqueWindowState = null;
4091        mTopFullscreenOpaqueOrDimmingWindowState = null;
4092        mAppsToBeHidden.clear();
4093        mAppsThatDismissKeyguard.clear();
4094        mForceStatusBar = false;
4095        mForceStatusBarFromKeyguard = false;
4096        mForcingShowNavBar = false;
4097        mForcingShowNavBarLayer = -1;
4098
4099        mHideLockScreen = false;
4100        mAllowLockscreenWhenOn = false;
4101        mDismissKeyguard = DISMISS_KEYGUARD_NONE;
4102        mShowingLockscreen = false;
4103        mShowingDream = false;
4104        mWinShowWhenLocked = null;
4105        mKeyguardSecure = isKeyguardSecure();
4106        mKeyguardSecureIncludingHidden = mKeyguardSecure
4107                && (mKeyguardDelegate != null && mKeyguardDelegate.isShowing());
4108    }
4109
4110    /** {@inheritDoc} */
4111    @Override
4112    public void applyPostLayoutPolicyLw(WindowState win, WindowManager.LayoutParams attrs) {
4113        if (DEBUG_LAYOUT) Slog.i(TAG, "Win " + win + ": isVisibleOrBehindKeyguardLw="
4114                + win.isVisibleOrBehindKeyguardLw());
4115        final int fl = PolicyControl.getWindowFlags(win, attrs);
4116        if (mTopFullscreenOpaqueWindowState == null
4117                && win.isVisibleLw() && attrs.type == TYPE_INPUT_METHOD) {
4118            mForcingShowNavBar = true;
4119            mForcingShowNavBarLayer = win.getSurfaceLayer();
4120        }
4121        if (attrs.type == TYPE_STATUS_BAR && (attrs.privateFlags & PRIVATE_FLAG_KEYGUARD) != 0) {
4122            mForceStatusBarFromKeyguard = true;
4123        }
4124        if (mTopFullscreenOpaqueWindowState == null &&
4125                win.isVisibleOrBehindKeyguardLw() && !win.isGoneForLayoutLw()) {
4126            if ((fl & FLAG_FORCE_NOT_FULLSCREEN) != 0) {
4127                if ((attrs.privateFlags & PRIVATE_FLAG_KEYGUARD) != 0) {
4128                    mForceStatusBarFromKeyguard = true;
4129                } else {
4130                    mForceStatusBar = true;
4131                }
4132            }
4133            if ((attrs.privateFlags & PRIVATE_FLAG_KEYGUARD) != 0) {
4134                mShowingLockscreen = true;
4135            }
4136            boolean appWindow = attrs.type >= FIRST_APPLICATION_WINDOW
4137                    && attrs.type < FIRST_SYSTEM_WINDOW;
4138            if (attrs.type == TYPE_DREAM) {
4139                // If the lockscreen was showing when the dream started then wait
4140                // for the dream to draw before hiding the lockscreen.
4141                if (!mDreamingLockscreen
4142                        || (win.isVisibleLw() && win.hasDrawnLw())) {
4143                    mShowingDream = true;
4144                    appWindow = true;
4145                }
4146            }
4147
4148            final boolean showWhenLocked = (fl & FLAG_SHOW_WHEN_LOCKED) != 0;
4149            final boolean dismissKeyguard = (fl & FLAG_DISMISS_KEYGUARD) != 0;
4150            if (appWindow) {
4151                final IApplicationToken appToken = win.getAppToken();
4152                if (showWhenLocked) {
4153                    // Remove any previous windows with the same appToken.
4154                    mAppsToBeHidden.remove(appToken);
4155                    mAppsThatDismissKeyguard.remove(appToken);
4156                    if (mAppsToBeHidden.isEmpty()) {
4157                        if (dismissKeyguard && !mKeyguardSecure) {
4158                            mAppsThatDismissKeyguard.add(appToken);
4159                        } else {
4160                            mWinShowWhenLocked = win;
4161                            mHideLockScreen = true;
4162                            mForceStatusBarFromKeyguard = false;
4163                        }
4164                    }
4165                } else if (dismissKeyguard) {
4166                    if (mKeyguardSecure) {
4167                        mAppsToBeHidden.add(appToken);
4168                    } else {
4169                        mAppsToBeHidden.remove(appToken);
4170                    }
4171                    mAppsThatDismissKeyguard.add(appToken);
4172                } else {
4173                    mAppsToBeHidden.add(appToken);
4174                }
4175                if (attrs.x == 0 && attrs.y == 0
4176                        && attrs.width == WindowManager.LayoutParams.MATCH_PARENT
4177                        && attrs.height == WindowManager.LayoutParams.MATCH_PARENT) {
4178                    if (DEBUG_LAYOUT) Slog.v(TAG, "Fullscreen window: " + win);
4179                    mTopFullscreenOpaqueWindowState = win;
4180                    if (mTopFullscreenOpaqueOrDimmingWindowState == null) {
4181                        mTopFullscreenOpaqueOrDimmingWindowState = win;
4182                    }
4183                    if (!mAppsThatDismissKeyguard.isEmpty() &&
4184                            mDismissKeyguard == DISMISS_KEYGUARD_NONE) {
4185                        if (DEBUG_LAYOUT) Slog.v(TAG,
4186                                "Setting mDismissKeyguard true by win " + win);
4187                        mDismissKeyguard = mWinDismissingKeyguard == win ?
4188                                DISMISS_KEYGUARD_CONTINUE : DISMISS_KEYGUARD_START;
4189                        mWinDismissingKeyguard = win;
4190                        mForceStatusBarFromKeyguard = mShowingLockscreen && mKeyguardSecure;
4191                    } else if (mAppsToBeHidden.isEmpty() && showWhenLocked) {
4192                        if (DEBUG_LAYOUT) Slog.v(TAG,
4193                                "Setting mHideLockScreen to true by win " + win);
4194                        mHideLockScreen = true;
4195                        mForceStatusBarFromKeyguard = false;
4196                    }
4197                    if ((fl & FLAG_ALLOW_LOCK_WHILE_SCREEN_ON) != 0) {
4198                        mAllowLockscreenWhenOn = true;
4199                    }
4200                }
4201
4202                if (mWinShowWhenLocked != null &&
4203                        mWinShowWhenLocked.getAppToken() != win.getAppToken()) {
4204                    win.hideLw(false);
4205                }
4206            }
4207        }
4208        if (mTopFullscreenOpaqueOrDimmingWindowState == null
4209                && win.isVisibleOrBehindKeyguardLw() && !win.isGoneForLayoutLw()
4210                && win.isDimming()) {
4211            mTopFullscreenOpaqueOrDimmingWindowState = win;
4212        }
4213    }
4214
4215    /** {@inheritDoc} */
4216    @Override
4217    public int finishPostLayoutPolicyLw() {
4218        if (mWinShowWhenLocked != null && mTopFullscreenOpaqueWindowState != null &&
4219                mWinShowWhenLocked.getAppToken() != mTopFullscreenOpaqueWindowState.getAppToken()
4220                && isKeyguardLocked()) {
4221            // A dialog is dismissing the keyguard. Put the wallpaper behind it and hide the
4222            // fullscreen window.
4223            // TODO: Make sure FLAG_SHOW_WALLPAPER is restored when dialog is dismissed. Or not.
4224            mWinShowWhenLocked.getAttrs().flags |= FLAG_SHOW_WALLPAPER;
4225            mTopFullscreenOpaqueWindowState.hideLw(false);
4226            mTopFullscreenOpaqueWindowState = mWinShowWhenLocked;
4227        }
4228
4229        int changes = 0;
4230        boolean topIsFullscreen = false;
4231
4232        final WindowManager.LayoutParams lp = (mTopFullscreenOpaqueWindowState != null)
4233                ? mTopFullscreenOpaqueWindowState.getAttrs()
4234                : null;
4235
4236        // If we are not currently showing a dream then remember the current
4237        // lockscreen state.  We will use this to determine whether the dream
4238        // started while the lockscreen was showing and remember this state
4239        // while the dream is showing.
4240        if (!mShowingDream) {
4241            mDreamingLockscreen = mShowingLockscreen;
4242        }
4243
4244        if (mStatusBar != null) {
4245            if (DEBUG_LAYOUT) Slog.i(TAG, "force=" + mForceStatusBar
4246                    + " forcefkg=" + mForceStatusBarFromKeyguard
4247                    + " top=" + mTopFullscreenOpaqueWindowState);
4248            if (mForceStatusBar || mForceStatusBarFromKeyguard) {
4249                if (DEBUG_LAYOUT) Slog.v(TAG, "Showing status bar: forced");
4250                if (mStatusBarController.setBarShowingLw(true)) {
4251                    changes |= FINISH_LAYOUT_REDO_LAYOUT;
4252                }
4253                // Maintain fullscreen layout until incoming animation is complete.
4254                topIsFullscreen = mTopIsFullscreen && mStatusBar.isAnimatingLw();
4255                // Transient status bar on the lockscreen is not allowed
4256                if (mForceStatusBarFromKeyguard && mStatusBarController.isTransientShowing()) {
4257                    mStatusBarController.updateVisibilityLw(false /*transientAllowed*/,
4258                            mLastSystemUiFlags, mLastSystemUiFlags);
4259                }
4260            } else if (mTopFullscreenOpaqueWindowState != null) {
4261                final int fl = PolicyControl.getWindowFlags(null, lp);
4262                if (localLOGV) {
4263                    Slog.d(TAG, "frame: " + mTopFullscreenOpaqueWindowState.getFrameLw()
4264                            + " shown frame: " + mTopFullscreenOpaqueWindowState.getShownFrameLw());
4265                    Slog.d(TAG, "attr: " + mTopFullscreenOpaqueWindowState.getAttrs()
4266                            + " lp.flags=0x" + Integer.toHexString(fl));
4267                }
4268                topIsFullscreen = (fl & WindowManager.LayoutParams.FLAG_FULLSCREEN) != 0
4269                        || (mLastSystemUiFlags & View.SYSTEM_UI_FLAG_FULLSCREEN) != 0;
4270                // The subtle difference between the window for mTopFullscreenOpaqueWindowState
4271                // and mTopIsFullscreen is that mTopIsFullscreen is set only if the window
4272                // has the FLAG_FULLSCREEN set.  Not sure if there is another way that to be the
4273                // case though.
4274                if (mStatusBarController.isTransientShowing()) {
4275                    if (mStatusBarController.setBarShowingLw(true)) {
4276                        changes |= FINISH_LAYOUT_REDO_LAYOUT;
4277                    }
4278                } else if (topIsFullscreen) {
4279                    if (DEBUG_LAYOUT) Slog.v(TAG, "** HIDING status bar");
4280                    if (mStatusBarController.setBarShowingLw(false)) {
4281                        changes |= FINISH_LAYOUT_REDO_LAYOUT;
4282                    } else {
4283                        if (DEBUG_LAYOUT) Slog.v(TAG, "Status bar already hiding");
4284                    }
4285                } else {
4286                    if (DEBUG_LAYOUT) Slog.v(TAG, "** SHOWING status bar: top is not fullscreen");
4287                    if (mStatusBarController.setBarShowingLw(true)) {
4288                        changes |= FINISH_LAYOUT_REDO_LAYOUT;
4289                    }
4290                }
4291            }
4292        }
4293
4294        if (mTopIsFullscreen != topIsFullscreen) {
4295            if (!topIsFullscreen) {
4296                // Force another layout when status bar becomes fully shown.
4297                changes |= FINISH_LAYOUT_REDO_LAYOUT;
4298            }
4299            mTopIsFullscreen = topIsFullscreen;
4300        }
4301
4302        // Hide the key guard if a visible window explicitly specifies that it wants to be
4303        // displayed when the screen is locked.
4304        if (mKeyguardDelegate != null && mStatusBar != null) {
4305            if (localLOGV) Slog.v(TAG, "finishPostLayoutPolicyLw: mHideKeyguard="
4306                    + mHideLockScreen);
4307            if (mDismissKeyguard != DISMISS_KEYGUARD_NONE && !mKeyguardSecure) {
4308                mKeyguardHidden = true;
4309                if (setKeyguardOccludedLw(true)) {
4310                    changes |= FINISH_LAYOUT_REDO_LAYOUT
4311                            | FINISH_LAYOUT_REDO_CONFIG
4312                            | FINISH_LAYOUT_REDO_WALLPAPER;
4313                }
4314                if (mKeyguardDelegate.isShowing()) {
4315                    mHandler.post(new Runnable() {
4316                        @Override
4317                        public void run() {
4318                            mKeyguardDelegate.keyguardDone(false, false);
4319                        }
4320                    });
4321                }
4322            } else if (mHideLockScreen) {
4323                mKeyguardHidden = true;
4324                if (setKeyguardOccludedLw(true)) {
4325                    changes |= FINISH_LAYOUT_REDO_LAYOUT
4326                            | FINISH_LAYOUT_REDO_CONFIG
4327                            | FINISH_LAYOUT_REDO_WALLPAPER;
4328                }
4329            } else if (mDismissKeyguard != DISMISS_KEYGUARD_NONE) {
4330                // This is the case of keyguard isSecure() and not mHideLockScreen.
4331                if (mDismissKeyguard == DISMISS_KEYGUARD_START) {
4332                    // Only launch the next keyguard unlock window once per window.
4333                    mKeyguardHidden = false;
4334                    if (setKeyguardOccludedLw(false)) {
4335                        changes |= FINISH_LAYOUT_REDO_LAYOUT
4336                                | FINISH_LAYOUT_REDO_CONFIG
4337                                | FINISH_LAYOUT_REDO_WALLPAPER;
4338                    }
4339                    mHandler.post(new Runnable() {
4340                        @Override
4341                        public void run() {
4342                            mKeyguardDelegate.dismiss();
4343                        }
4344                    });
4345                }
4346            } else {
4347                mWinDismissingKeyguard = null;
4348                mKeyguardHidden = false;
4349                if (setKeyguardOccludedLw(false)) {
4350                    changes |= FINISH_LAYOUT_REDO_LAYOUT
4351                            | FINISH_LAYOUT_REDO_CONFIG
4352                            | FINISH_LAYOUT_REDO_WALLPAPER;
4353                }
4354            }
4355        }
4356
4357        if ((updateSystemUiVisibilityLw()&SYSTEM_UI_CHANGING_LAYOUT) != 0) {
4358            // If the navigation bar has been hidden or shown, we need to do another
4359            // layout pass to update that window.
4360            changes |= FINISH_LAYOUT_REDO_LAYOUT;
4361        }
4362
4363        // update since mAllowLockscreenWhenOn might have changed
4364        updateLockScreenTimeout();
4365        return changes;
4366    }
4367
4368    /**
4369     * Updates the occluded state of the Keyguard.
4370     *
4371     * @return Whether the flags have changed and we have to redo the layout.
4372     */
4373    private boolean setKeyguardOccludedLw(boolean isOccluded) {
4374        boolean wasOccluded = mKeyguardOccluded;
4375        boolean showing = mKeyguardDelegate.isShowing();
4376        if (wasOccluded && !isOccluded && showing) {
4377            mKeyguardOccluded = false;
4378            mKeyguardDelegate.setOccluded(false);
4379            mStatusBar.getAttrs().privateFlags |= PRIVATE_FLAG_KEYGUARD;
4380            mStatusBar.getAttrs().flags |= FLAG_SHOW_WALLPAPER;
4381            return true;
4382        } else if (!wasOccluded && isOccluded && showing) {
4383            mKeyguardOccluded = true;
4384            mKeyguardDelegate.setOccluded(true);
4385            mStatusBar.getAttrs().privateFlags &= ~PRIVATE_FLAG_KEYGUARD;
4386            mStatusBar.getAttrs().flags &= ~FLAG_SHOW_WALLPAPER;
4387            return true;
4388        } else {
4389            return false;
4390        }
4391    }
4392
4393    private boolean isStatusBarKeyguard() {
4394        return mStatusBar != null
4395                && (mStatusBar.getAttrs().privateFlags & PRIVATE_FLAG_KEYGUARD) != 0;
4396    }
4397
4398    @Override
4399    public boolean allowAppAnimationsLw() {
4400        if (isStatusBarKeyguard() || mShowingDream) {
4401            // If keyguard or dreams is currently visible, no reason to animate behind it.
4402            return false;
4403        }
4404        return true;
4405    }
4406
4407    @Override
4408    public int focusChangedLw(WindowState lastFocus, WindowState newFocus) {
4409        mFocusedWindow = newFocus;
4410        if ((updateSystemUiVisibilityLw()&SYSTEM_UI_CHANGING_LAYOUT) != 0) {
4411            // If the navigation bar has been hidden or shown, we need to do another
4412            // layout pass to update that window.
4413            return FINISH_LAYOUT_REDO_LAYOUT;
4414        }
4415        return 0;
4416    }
4417
4418    /** {@inheritDoc} */
4419    @Override
4420    public void notifyLidSwitchChanged(long whenNanos, boolean lidOpen) {
4421        // lid changed state
4422        final int newLidState = lidOpen ? LID_OPEN : LID_CLOSED;
4423        if (newLidState == mLidState) {
4424            return;
4425        }
4426
4427        mLidState = newLidState;
4428        applyLidSwitchState();
4429        updateRotation(true);
4430
4431        if (lidOpen) {
4432            wakeUp(SystemClock.uptimeMillis(), mAllowTheaterModeWakeFromLidSwitch);
4433        } else if (!mLidControlsSleep) {
4434            mPowerManager.userActivity(SystemClock.uptimeMillis(), false);
4435        }
4436    }
4437
4438    @Override
4439    public void notifyCameraLensCoverSwitchChanged(long whenNanos, boolean lensCovered) {
4440        int lensCoverState = lensCovered ? CAMERA_LENS_COVERED : CAMERA_LENS_UNCOVERED;
4441        if (mCameraLensCoverState == lensCoverState) {
4442            return;
4443        }
4444        if (mCameraLensCoverState == CAMERA_LENS_COVERED &&
4445                lensCoverState == CAMERA_LENS_UNCOVERED) {
4446            Intent intent;
4447            final boolean keyguardActive = mKeyguardDelegate == null ? false :
4448                    mKeyguardDelegate.isShowing();
4449            if (keyguardActive) {
4450                intent = new Intent(MediaStore.INTENT_ACTION_STILL_IMAGE_CAMERA_SECURE);
4451            } else {
4452                intent = new Intent(MediaStore.INTENT_ACTION_STILL_IMAGE_CAMERA);
4453            }
4454            wakeUp(whenNanos / 1000000, mAllowTheaterModeWakeFromCameraLens);
4455            startActivityAsUser(intent, UserHandle.CURRENT_OR_SELF);
4456        }
4457        mCameraLensCoverState = lensCoverState;
4458    }
4459
4460    void setHdmiPlugged(boolean plugged) {
4461        if (mHdmiPlugged != plugged) {
4462            mHdmiPlugged = plugged;
4463            updateRotation(true, true);
4464            Intent intent = new Intent(ACTION_HDMI_PLUGGED);
4465            intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT);
4466            intent.putExtra(EXTRA_HDMI_PLUGGED_STATE, plugged);
4467            mContext.sendStickyBroadcastAsUser(intent, UserHandle.ALL);
4468        }
4469    }
4470
4471    void initializeHdmiState() {
4472        boolean plugged = false;
4473        // watch for HDMI plug messages if the hdmi switch exists
4474        if (new File("/sys/devices/virtual/switch/hdmi/state").exists()) {
4475            mHDMIObserver.startObserving("DEVPATH=/devices/virtual/switch/hdmi");
4476
4477            final String filename = "/sys/class/switch/hdmi/state";
4478            FileReader reader = null;
4479            try {
4480                reader = new FileReader(filename);
4481                char[] buf = new char[15];
4482                int n = reader.read(buf);
4483                if (n > 1) {
4484                    plugged = 0 != Integer.parseInt(new String(buf, 0, n-1));
4485                }
4486            } catch (IOException ex) {
4487                Slog.w(TAG, "Couldn't read hdmi state from " + filename + ": " + ex);
4488            } catch (NumberFormatException ex) {
4489                Slog.w(TAG, "Couldn't read hdmi state from " + filename + ": " + ex);
4490            } finally {
4491                if (reader != null) {
4492                    try {
4493                        reader.close();
4494                    } catch (IOException ex) {
4495                    }
4496                }
4497            }
4498        }
4499        // This dance forces the code in setHdmiPlugged to run.
4500        // Always do this so the sticky intent is stuck (to false) if there is no hdmi.
4501        mHdmiPlugged = !plugged;
4502        setHdmiPlugged(!mHdmiPlugged);
4503    }
4504
4505    final Object mScreenshotLock = new Object();
4506    ServiceConnection mScreenshotConnection = null;
4507
4508    final Runnable mScreenshotTimeout = new Runnable() {
4509        @Override public void run() {
4510            synchronized (mScreenshotLock) {
4511                if (mScreenshotConnection != null) {
4512                    mContext.unbindService(mScreenshotConnection);
4513                    mScreenshotConnection = null;
4514                }
4515            }
4516        }
4517    };
4518
4519    // Assume this is called from the Handler thread.
4520    private void takeScreenshot() {
4521        synchronized (mScreenshotLock) {
4522            if (mScreenshotConnection != null) {
4523                return;
4524            }
4525            ComponentName cn = new ComponentName("com.android.systemui",
4526                    "com.android.systemui.screenshot.TakeScreenshotService");
4527            Intent intent = new Intent();
4528            intent.setComponent(cn);
4529            ServiceConnection conn = new ServiceConnection() {
4530                @Override
4531                public void onServiceConnected(ComponentName name, IBinder service) {
4532                    synchronized (mScreenshotLock) {
4533                        if (mScreenshotConnection != this) {
4534                            return;
4535                        }
4536                        Messenger messenger = new Messenger(service);
4537                        Message msg = Message.obtain(null, 1);
4538                        final ServiceConnection myConn = this;
4539                        Handler h = new Handler(mHandler.getLooper()) {
4540                            @Override
4541                            public void handleMessage(Message msg) {
4542                                synchronized (mScreenshotLock) {
4543                                    if (mScreenshotConnection == myConn) {
4544                                        mContext.unbindService(mScreenshotConnection);
4545                                        mScreenshotConnection = null;
4546                                        mHandler.removeCallbacks(mScreenshotTimeout);
4547                                    }
4548                                }
4549                            }
4550                        };
4551                        msg.replyTo = new Messenger(h);
4552                        msg.arg1 = msg.arg2 = 0;
4553                        if (mStatusBar != null && mStatusBar.isVisibleLw())
4554                            msg.arg1 = 1;
4555                        if (mNavigationBar != null && mNavigationBar.isVisibleLw())
4556                            msg.arg2 = 1;
4557                        try {
4558                            messenger.send(msg);
4559                        } catch (RemoteException e) {
4560                        }
4561                    }
4562                }
4563                @Override
4564                public void onServiceDisconnected(ComponentName name) {}
4565            };
4566            if (mContext.bindServiceAsUser(
4567                    intent, conn, Context.BIND_AUTO_CREATE, UserHandle.CURRENT)) {
4568                mScreenshotConnection = conn;
4569                mHandler.postDelayed(mScreenshotTimeout, 10000);
4570            }
4571        }
4572    }
4573
4574    /** {@inheritDoc} */
4575    @Override
4576    public int interceptKeyBeforeQueueing(KeyEvent event, int policyFlags) {
4577        if (!mSystemBooted) {
4578            // If we have not yet booted, don't let key events do anything.
4579            return 0;
4580        }
4581
4582        final boolean interactive = (policyFlags & FLAG_INTERACTIVE) != 0;
4583        final boolean down = event.getAction() == KeyEvent.ACTION_DOWN;
4584        final boolean canceled = event.isCanceled();
4585        final int keyCode = event.getKeyCode();
4586
4587        final boolean isInjected = (policyFlags & WindowManagerPolicy.FLAG_INJECTED) != 0;
4588
4589        // If screen is off then we treat the case where the keyguard is open but hidden
4590        // the same as if it were open and in front.
4591        // This will prevent any keys other than the power button from waking the screen
4592        // when the keyguard is hidden by another activity.
4593        final boolean keyguardActive = (mKeyguardDelegate == null ? false :
4594                                            (interactive ?
4595                                                isKeyguardShowingAndNotOccluded() :
4596                                                mKeyguardDelegate.isShowing()));
4597
4598        if (DEBUG_INPUT) {
4599            Log.d(TAG, "interceptKeyTq keycode=" + keyCode
4600                    + " interactive=" + interactive + " keyguardActive=" + keyguardActive
4601                    + " policyFlags=" + Integer.toHexString(policyFlags));
4602        }
4603
4604        // Basic policy based on interactive state.
4605        int result;
4606        boolean isWakeKey = (policyFlags & WindowManagerPolicy.FLAG_WAKE) != 0
4607                || event.isWakeKey();
4608        if (interactive || (isInjected && !isWakeKey)) {
4609            // When the device is interactive or the key is injected pass the
4610            // key to the application.
4611            result = ACTION_PASS_TO_USER;
4612            isWakeKey = false;
4613        } else if (!interactive && shouldDispatchInputWhenNonInteractive()) {
4614            // If we're currently dozing with the screen on and the keyguard showing, pass the key
4615            // to the application but preserve its wake key status to make sure we still move
4616            // from dozing to fully interactive if we would normally go from off to fully
4617            // interactive.
4618            result = ACTION_PASS_TO_USER;
4619        } else {
4620            // When the screen is off and the key is not injected, determine whether
4621            // to wake the device but don't pass the key to the application.
4622            result = 0;
4623            if (isWakeKey && (!down || !isWakeKeyWhenScreenOff(keyCode))) {
4624                isWakeKey = false;
4625            }
4626        }
4627
4628        // If the key would be handled globally, just return the result, don't worry about special
4629        // key processing.
4630        if (isValidGlobalKey(keyCode)
4631                && mGlobalKeyManager.shouldHandleGlobalKey(keyCode, event)) {
4632            if (isWakeKey) {
4633                wakeUp(event.getEventTime(), mAllowTheaterModeWakeFromKey);
4634            }
4635            return result;
4636        }
4637
4638        boolean useHapticFeedback = down
4639                && (policyFlags & WindowManagerPolicy.FLAG_VIRTUAL) != 0
4640                && event.getRepeatCount() == 0;
4641
4642        // Handle special keys.
4643        switch (keyCode) {
4644            case KeyEvent.KEYCODE_VOLUME_DOWN:
4645            case KeyEvent.KEYCODE_VOLUME_UP:
4646            case KeyEvent.KEYCODE_VOLUME_MUTE: {
4647                if (mUseTvRouting) {
4648                    // On TVs volume keys never go to the foreground app
4649                    result &= ~ACTION_PASS_TO_USER;
4650                }
4651                if (keyCode == KeyEvent.KEYCODE_VOLUME_DOWN) {
4652                    if (down) {
4653                        if (interactive && !mScreenshotChordVolumeDownKeyTriggered
4654                                && (event.getFlags() & KeyEvent.FLAG_FALLBACK) == 0) {
4655                            mScreenshotChordVolumeDownKeyTriggered = true;
4656                            mScreenshotChordVolumeDownKeyTime = event.getDownTime();
4657                            mScreenshotChordVolumeDownKeyConsumed = false;
4658                            cancelPendingPowerKeyAction();
4659                            interceptScreenshotChord();
4660                        }
4661                    } else {
4662                        mScreenshotChordVolumeDownKeyTriggered = false;
4663                        cancelPendingScreenshotChordAction();
4664                    }
4665                } else if (keyCode == KeyEvent.KEYCODE_VOLUME_UP) {
4666                    if (down) {
4667                        if (interactive && !mScreenshotChordVolumeUpKeyTriggered
4668                                && (event.getFlags() & KeyEvent.FLAG_FALLBACK) == 0) {
4669                            mScreenshotChordVolumeUpKeyTriggered = true;
4670                            cancelPendingPowerKeyAction();
4671                            cancelPendingScreenshotChordAction();
4672                        }
4673                    } else {
4674                        mScreenshotChordVolumeUpKeyTriggered = false;
4675                        cancelPendingScreenshotChordAction();
4676                    }
4677                }
4678                if (down) {
4679                    TelecomManager telecomManager = getTelecommService();
4680                    if (telecomManager != null) {
4681                        if (telecomManager.isRinging()) {
4682                            // If an incoming call is ringing, either VOLUME key means
4683                            // "silence ringer".  We handle these keys here, rather than
4684                            // in the InCallScreen, to make sure we'll respond to them
4685                            // even if the InCallScreen hasn't come to the foreground yet.
4686                            // Look for the DOWN event here, to agree with the "fallback"
4687                            // behavior in the InCallScreen.
4688                            Log.i(TAG, "interceptKeyBeforeQueueing:"
4689                                  + " VOLUME key-down while ringing: Silence ringer!");
4690
4691                            // Silence the ringer.  (It's safe to call this
4692                            // even if the ringer has already been silenced.)
4693                            telecomManager.silenceRinger();
4694
4695                            // And *don't* pass this key thru to the current activity
4696                            // (which is probably the InCallScreen.)
4697                            result &= ~ACTION_PASS_TO_USER;
4698                            break;
4699                        }
4700                        if (telecomManager.isInCall()
4701                                && (result & ACTION_PASS_TO_USER) == 0) {
4702                            // If we are in call but we decided not to pass the key to
4703                            // the application, just pass it to the session service.
4704
4705                            MediaSessionLegacyHelper.getHelper(mContext)
4706                                    .sendVolumeKeyEvent(event, false);
4707                            break;
4708                        }
4709                    }
4710
4711                    if ((result & ACTION_PASS_TO_USER) == 0) {
4712                        if (mUseTvRouting) {
4713                            dispatchDirectAudioEvent(event);
4714                        } else {
4715                            // If we aren't passing to the user and no one else
4716                            // handled it send it to the session manager to
4717                            // figure out.
4718                            MediaSessionLegacyHelper.getHelper(mContext)
4719                                    .sendVolumeKeyEvent(event, true);
4720                        }
4721                        break;
4722                    }
4723                }
4724                break;
4725            }
4726
4727            case KeyEvent.KEYCODE_ENDCALL: {
4728                result &= ~ACTION_PASS_TO_USER;
4729                if (down) {
4730                    TelecomManager telecomManager = getTelecommService();
4731                    boolean hungUp = false;
4732                    if (telecomManager != null) {
4733                        hungUp = telecomManager.endCall();
4734                    }
4735                    if (interactive && !hungUp) {
4736                        mEndCallKeyHandled = false;
4737                        mHandler.postDelayed(mEndCallLongPress,
4738                                ViewConfiguration.get(mContext).getDeviceGlobalActionKeyTimeout());
4739                    } else {
4740                        mEndCallKeyHandled = true;
4741                    }
4742                } else {
4743                    if (!mEndCallKeyHandled) {
4744                        mHandler.removeCallbacks(mEndCallLongPress);
4745                        if (!canceled) {
4746                            if ((mEndcallBehavior
4747                                    & Settings.System.END_BUTTON_BEHAVIOR_HOME) != 0) {
4748                                if (goHome()) {
4749                                    break;
4750                                }
4751                            }
4752                            if ((mEndcallBehavior
4753                                    & Settings.System.END_BUTTON_BEHAVIOR_SLEEP) != 0) {
4754                                mPowerManager.goToSleep(event.getEventTime(),
4755                                        PowerManager.GO_TO_SLEEP_REASON_POWER_BUTTON, 0);
4756                                isWakeKey = false;
4757                            }
4758                        }
4759                    }
4760                }
4761                break;
4762            }
4763
4764            case KeyEvent.KEYCODE_POWER: {
4765                result &= ~ACTION_PASS_TO_USER;
4766                isWakeKey = false; // wake-up will be handled separately
4767                if (down) {
4768                    interceptPowerKeyDown(event, interactive);
4769                } else {
4770                    interceptPowerKeyUp(event, interactive, canceled);
4771                }
4772                break;
4773            }
4774
4775            case KeyEvent.KEYCODE_SLEEP: {
4776                result &= ~ACTION_PASS_TO_USER;
4777                isWakeKey = false;
4778                if (!mPowerManager.isInteractive()) {
4779                    useHapticFeedback = false; // suppress feedback if already non-interactive
4780                }
4781                sleepPress(event);
4782                break;
4783            }
4784
4785            case KeyEvent.KEYCODE_WAKEUP: {
4786                result &= ~ACTION_PASS_TO_USER;
4787                isWakeKey = true;
4788                break;
4789            }
4790
4791            case KeyEvent.KEYCODE_MEDIA_PLAY:
4792            case KeyEvent.KEYCODE_MEDIA_PAUSE:
4793            case KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE:
4794            case KeyEvent.KEYCODE_HEADSETHOOK:
4795            case KeyEvent.KEYCODE_MUTE:
4796            case KeyEvent.KEYCODE_MEDIA_STOP:
4797            case KeyEvent.KEYCODE_MEDIA_NEXT:
4798            case KeyEvent.KEYCODE_MEDIA_PREVIOUS:
4799            case KeyEvent.KEYCODE_MEDIA_REWIND:
4800            case KeyEvent.KEYCODE_MEDIA_RECORD:
4801            case KeyEvent.KEYCODE_MEDIA_FAST_FORWARD:
4802            case KeyEvent.KEYCODE_MEDIA_AUDIO_TRACK: {
4803                if (MediaSessionLegacyHelper.getHelper(mContext).isGlobalPriorityActive()) {
4804                    // If the global session is active pass all media keys to it
4805                    // instead of the active window.
4806                    result &= ~ACTION_PASS_TO_USER;
4807                }
4808                if ((result & ACTION_PASS_TO_USER) == 0) {
4809                    // Only do this if we would otherwise not pass it to the user. In that
4810                    // case, the PhoneWindow class will do the same thing, except it will
4811                    // only do it if the showing app doesn't process the key on its own.
4812                    // Note that we need to make a copy of the key event here because the
4813                    // original key event will be recycled when we return.
4814                    mBroadcastWakeLock.acquire();
4815                    Message msg = mHandler.obtainMessage(MSG_DISPATCH_MEDIA_KEY_WITH_WAKE_LOCK,
4816                            new KeyEvent(event));
4817                    msg.setAsynchronous(true);
4818                    msg.sendToTarget();
4819                }
4820                break;
4821            }
4822
4823            case KeyEvent.KEYCODE_CALL: {
4824                if (down) {
4825                    TelecomManager telecomManager = getTelecommService();
4826                    if (telecomManager != null) {
4827                        if (telecomManager.isRinging()) {
4828                            Log.i(TAG, "interceptKeyBeforeQueueing:"
4829                                  + " CALL key-down while ringing: Answer the call!");
4830                            telecomManager.acceptRingingCall();
4831
4832                            // And *don't* pass this key thru to the current activity
4833                            // (which is presumably the InCallScreen.)
4834                            result &= ~ACTION_PASS_TO_USER;
4835                        }
4836                    }
4837                }
4838                break;
4839            }
4840            case KeyEvent.KEYCODE_VOICE_ASSIST: {
4841                // Only do this if we would otherwise not pass it to the user. In that case,
4842                // interceptKeyBeforeDispatching would apply a similar but different policy in
4843                // order to invoke voice assist actions. Note that we need to make a copy of the
4844                // key event here because the original key event will be recycled when we return.
4845                if ((result & ACTION_PASS_TO_USER) == 0 && !down) {
4846                    mBroadcastWakeLock.acquire();
4847                    Message msg = mHandler.obtainMessage(MSG_LAUNCH_VOICE_ASSIST_WITH_WAKE_LOCK,
4848                            keyguardActive ? 1 : 0, 0);
4849                    msg.setAsynchronous(true);
4850                    msg.sendToTarget();
4851                }
4852            }
4853        }
4854
4855        if (useHapticFeedback) {
4856            performHapticFeedbackLw(null, HapticFeedbackConstants.VIRTUAL_KEY, false);
4857        }
4858
4859        if (isWakeKey) {
4860            wakeUp(event.getEventTime(), mAllowTheaterModeWakeFromKey);
4861        }
4862
4863        return result;
4864    }
4865
4866    /**
4867     * Returns true if the key can have global actions attached to it.
4868     * We reserve all power management keys for the system since they require
4869     * very careful handling.
4870     */
4871    private static boolean isValidGlobalKey(int keyCode) {
4872        switch (keyCode) {
4873            case KeyEvent.KEYCODE_POWER:
4874            case KeyEvent.KEYCODE_WAKEUP:
4875            case KeyEvent.KEYCODE_SLEEP:
4876                return false;
4877            default:
4878                return true;
4879        }
4880    }
4881
4882    /**
4883     * When the screen is off we ignore some keys that might otherwise typically
4884     * be considered wake keys.  We filter them out here.
4885     *
4886     * {@link KeyEvent#KEYCODE_POWER} is notably absent from this list because it
4887     * is always considered a wake key.
4888     */
4889    private boolean isWakeKeyWhenScreenOff(int keyCode) {
4890        switch (keyCode) {
4891            // ignore volume keys unless docked
4892            case KeyEvent.KEYCODE_VOLUME_UP:
4893            case KeyEvent.KEYCODE_VOLUME_DOWN:
4894            case KeyEvent.KEYCODE_VOLUME_MUTE:
4895                return mDockMode != Intent.EXTRA_DOCK_STATE_UNDOCKED;
4896
4897            // ignore media and camera keys
4898            case KeyEvent.KEYCODE_MUTE:
4899            case KeyEvent.KEYCODE_HEADSETHOOK:
4900            case KeyEvent.KEYCODE_MEDIA_PLAY:
4901            case KeyEvent.KEYCODE_MEDIA_PAUSE:
4902            case KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE:
4903            case KeyEvent.KEYCODE_MEDIA_STOP:
4904            case KeyEvent.KEYCODE_MEDIA_NEXT:
4905            case KeyEvent.KEYCODE_MEDIA_PREVIOUS:
4906            case KeyEvent.KEYCODE_MEDIA_REWIND:
4907            case KeyEvent.KEYCODE_MEDIA_RECORD:
4908            case KeyEvent.KEYCODE_MEDIA_FAST_FORWARD:
4909            case KeyEvent.KEYCODE_MEDIA_AUDIO_TRACK:
4910            case KeyEvent.KEYCODE_CAMERA:
4911                return false;
4912        }
4913        return true;
4914    }
4915
4916
4917    /** {@inheritDoc} */
4918    @Override
4919    public int interceptMotionBeforeQueueingNonInteractive(long whenNanos, int policyFlags) {
4920        if ((policyFlags & FLAG_WAKE) != 0) {
4921            if (wakeUp(whenNanos / 1000000, mAllowTheaterModeWakeFromMotion)) {
4922                return 0;
4923            }
4924        }
4925
4926        if (shouldDispatchInputWhenNonInteractive()) {
4927            return ACTION_PASS_TO_USER;
4928        }
4929
4930        // If we have not passed the action up and we are in theater mode without dreaming,
4931        // there will be no dream to intercept the touch and wake into ambient.  The device should
4932        // wake up in this case.
4933        if (isTheaterModeEnabled() && (policyFlags & FLAG_WAKE) != 0) {
4934            wakeUp(whenNanos / 1000000, mAllowTheaterModeWakeFromMotionWhenNotDreaming);
4935        }
4936
4937        return 0;
4938    }
4939
4940    private boolean shouldDispatchInputWhenNonInteractive() {
4941        // Send events to keyguard while the screen is on.
4942        if (isKeyguardShowingAndNotOccluded() && mDisplay != null
4943                && mDisplay.getState() != Display.STATE_OFF) {
4944            return true;
4945        }
4946
4947        // Send events to a dozing dream even if the screen is off since the dream
4948        // is in control of the state of the screen.
4949        IDreamManager dreamManager = getDreamManager();
4950
4951        try {
4952            if (dreamManager != null && dreamManager.isDreaming()) {
4953                return true;
4954            }
4955        } catch (RemoteException e) {
4956            Slog.e(TAG, "RemoteException when checking if dreaming", e);
4957        }
4958
4959        // Otherwise, consume events since the user can't see what is being
4960        // interacted with.
4961        return false;
4962    }
4963
4964    private void dispatchDirectAudioEvent(KeyEvent event) {
4965        if (event.getAction() != KeyEvent.ACTION_DOWN) {
4966            return;
4967        }
4968        int keyCode = event.getKeyCode();
4969        int flags = AudioManager.FLAG_SHOW_UI | AudioManager.FLAG_PLAY_SOUND
4970                | AudioManager.FLAG_FROM_KEY;
4971        String pkgName = mContext.getOpPackageName();
4972        switch (keyCode) {
4973            case KeyEvent.KEYCODE_VOLUME_UP:
4974                try {
4975                    getAudioService().adjustSuggestedStreamVolume(AudioManager.ADJUST_RAISE,
4976                            AudioManager.USE_DEFAULT_STREAM_TYPE, flags, pkgName, TAG);
4977                } catch (RemoteException e) {
4978                    Log.e(TAG, "Error dispatching volume up in dispatchTvAudioEvent.", e);
4979                }
4980                break;
4981            case KeyEvent.KEYCODE_VOLUME_DOWN:
4982                try {
4983                    getAudioService().adjustSuggestedStreamVolume(AudioManager.ADJUST_LOWER,
4984                            AudioManager.USE_DEFAULT_STREAM_TYPE, flags, pkgName, TAG);
4985                } catch (RemoteException e) {
4986                    Log.e(TAG, "Error dispatching volume down in dispatchTvAudioEvent.", e);
4987                }
4988                break;
4989            case KeyEvent.KEYCODE_VOLUME_MUTE:
4990                try {
4991                    if (event.getRepeatCount() == 0) {
4992                        getAudioService().adjustSuggestedStreamVolume(
4993                                AudioManager.ADJUST_TOGGLE_MUTE,
4994                                AudioManager.USE_DEFAULT_STREAM_TYPE, flags, pkgName, TAG);
4995                    }
4996                } catch (RemoteException e) {
4997                    Log.e(TAG, "Error dispatching mute in dispatchTvAudioEvent.", e);
4998                }
4999                break;
5000        }
5001    }
5002
5003    void dispatchMediaKeyWithWakeLock(KeyEvent event) {
5004        if (DEBUG_INPUT) {
5005            Slog.d(TAG, "dispatchMediaKeyWithWakeLock: " + event);
5006        }
5007
5008        if (mHavePendingMediaKeyRepeatWithWakeLock) {
5009            if (DEBUG_INPUT) {
5010                Slog.d(TAG, "dispatchMediaKeyWithWakeLock: canceled repeat");
5011            }
5012
5013            mHandler.removeMessages(MSG_DISPATCH_MEDIA_KEY_REPEAT_WITH_WAKE_LOCK);
5014            mHavePendingMediaKeyRepeatWithWakeLock = false;
5015            mBroadcastWakeLock.release(); // pending repeat was holding onto the wake lock
5016        }
5017
5018        dispatchMediaKeyWithWakeLockToAudioService(event);
5019
5020        if (event.getAction() == KeyEvent.ACTION_DOWN
5021                && event.getRepeatCount() == 0) {
5022            mHavePendingMediaKeyRepeatWithWakeLock = true;
5023
5024            Message msg = mHandler.obtainMessage(
5025                    MSG_DISPATCH_MEDIA_KEY_REPEAT_WITH_WAKE_LOCK, event);
5026            msg.setAsynchronous(true);
5027            mHandler.sendMessageDelayed(msg, ViewConfiguration.getKeyRepeatTimeout());
5028        } else {
5029            mBroadcastWakeLock.release();
5030        }
5031    }
5032
5033    void dispatchMediaKeyRepeatWithWakeLock(KeyEvent event) {
5034        mHavePendingMediaKeyRepeatWithWakeLock = false;
5035
5036        KeyEvent repeatEvent = KeyEvent.changeTimeRepeat(event,
5037                SystemClock.uptimeMillis(), 1, event.getFlags() | KeyEvent.FLAG_LONG_PRESS);
5038        if (DEBUG_INPUT) {
5039            Slog.d(TAG, "dispatchMediaKeyRepeatWithWakeLock: " + repeatEvent);
5040        }
5041
5042        dispatchMediaKeyWithWakeLockToAudioService(repeatEvent);
5043        mBroadcastWakeLock.release();
5044    }
5045
5046    void dispatchMediaKeyWithWakeLockToAudioService(KeyEvent event) {
5047        if (ActivityManagerNative.isSystemReady()) {
5048            MediaSessionLegacyHelper.getHelper(mContext).sendMediaButtonEvent(event, true);
5049        }
5050    }
5051
5052    void launchVoiceAssistWithWakeLock(boolean keyguardActive) {
5053        Intent voiceIntent =
5054            new Intent(RecognizerIntent.ACTION_VOICE_SEARCH_HANDS_FREE);
5055        voiceIntent.putExtra(RecognizerIntent.EXTRA_SECURE, keyguardActive);
5056        startActivityAsUser(voiceIntent, UserHandle.CURRENT_OR_SELF);
5057        mBroadcastWakeLock.release();
5058    }
5059
5060    BroadcastReceiver mDockReceiver = new BroadcastReceiver() {
5061        @Override
5062        public void onReceive(Context context, Intent intent) {
5063            if (Intent.ACTION_DOCK_EVENT.equals(intent.getAction())) {
5064                mDockMode = intent.getIntExtra(Intent.EXTRA_DOCK_STATE,
5065                        Intent.EXTRA_DOCK_STATE_UNDOCKED);
5066            } else {
5067                try {
5068                    IUiModeManager uiModeService = IUiModeManager.Stub.asInterface(
5069                            ServiceManager.getService(Context.UI_MODE_SERVICE));
5070                    mUiMode = uiModeService.getCurrentModeType();
5071                } catch (RemoteException e) {
5072                }
5073            }
5074            updateRotation(true);
5075            synchronized (mLock) {
5076                updateOrientationListenerLp();
5077            }
5078        }
5079    };
5080
5081    BroadcastReceiver mDreamReceiver = new BroadcastReceiver() {
5082        @Override
5083        public void onReceive(Context context, Intent intent) {
5084            if (Intent.ACTION_DREAMING_STARTED.equals(intent.getAction())) {
5085                if (mKeyguardDelegate != null) {
5086                    mKeyguardDelegate.onDreamingStarted();
5087                }
5088            } else if (Intent.ACTION_DREAMING_STOPPED.equals(intent.getAction())) {
5089                if (mKeyguardDelegate != null) {
5090                    mKeyguardDelegate.onDreamingStopped();
5091                }
5092            }
5093        }
5094    };
5095
5096    BroadcastReceiver mMultiuserReceiver = new BroadcastReceiver() {
5097        @Override
5098        public void onReceive(Context context, Intent intent) {
5099            if (Intent.ACTION_USER_SWITCHED.equals(intent.getAction())) {
5100                // tickle the settings observer: this first ensures that we're
5101                // observing the relevant settings for the newly-active user,
5102                // and then updates our own bookkeeping based on the now-
5103                // current user.
5104                mSettingsObserver.onChange(false);
5105
5106                // force a re-application of focused window sysui visibility.
5107                // the window may never have been shown for this user
5108                // e.g. the keyguard when going through the new-user setup flow
5109                synchronized (mWindowManagerFuncs.getWindowManagerLock()) {
5110                    mLastSystemUiFlags = 0;
5111                    updateSystemUiVisibilityLw();
5112                }
5113            }
5114        }
5115    };
5116
5117    private final Runnable mRequestTransientNav = new Runnable() {
5118        @Override
5119        public void run() {
5120            requestTransientBars(mNavigationBar);
5121        }
5122    };
5123
5124    private void requestTransientBars(WindowState swipeTarget) {
5125        synchronized (mWindowManagerFuncs.getWindowManagerLock()) {
5126            if (!isUserSetupComplete()) {
5127                // Swipe-up for navigation bar is disabled during setup
5128                return;
5129            }
5130            boolean sb = mStatusBarController.checkShowTransientBarLw();
5131            boolean nb = mNavigationBarController.checkShowTransientBarLw();
5132            if (sb || nb) {
5133                // Don't show status bar when swiping on already visible navigation bar
5134                if (!nb && swipeTarget == mNavigationBar) {
5135                    if (DEBUG) Slog.d(TAG, "Not showing transient bar, wrong swipe target");
5136                    return;
5137                }
5138                if (sb) mStatusBarController.showTransient();
5139                if (nb) mNavigationBarController.showTransient();
5140                mImmersiveModeConfirmation.confirmCurrentPrompt();
5141                updateSystemUiVisibilityLw();
5142            }
5143        }
5144    }
5145
5146    // Called on the PowerManager's Notifier thread.
5147    @Override
5148    public void goingToSleep(int why) {
5149        EventLog.writeEvent(70000, 0);
5150        if (DEBUG_WAKEUP) Slog.i(TAG, "Going to sleep...");
5151
5152        // We must get this work done here because the power manager will drop
5153        // the wake lock and let the system suspend once this function returns.
5154        synchronized (mLock) {
5155            mAwake = false;
5156            mKeyguardDrawComplete = false;
5157            updateWakeGestureListenerLp();
5158            updateOrientationListenerLp();
5159            updateLockScreenTimeout();
5160        }
5161
5162        if (mKeyguardDelegate != null) {
5163            mKeyguardDelegate.onScreenTurnedOff(why);
5164        }
5165    }
5166
5167    private void wakeUpFromPowerKey(long eventTime) {
5168        wakeUp(eventTime, mAllowTheaterModeWakeFromPowerKey);
5169    }
5170
5171    private boolean wakeUp(long wakeTime, boolean wakeInTheaterMode) {
5172        if (!wakeInTheaterMode && isTheaterModeEnabled()) {
5173            return false;
5174        }
5175
5176        mPowerManager.wakeUp(wakeTime);
5177        return true;
5178    }
5179
5180    // Called on the PowerManager's Notifier thread.
5181    @Override
5182    public void wakingUp() {
5183        EventLog.writeEvent(70000, 1);
5184        if (DEBUG_WAKEUP) Slog.i(TAG, "Waking up...");
5185
5186        // Since goToSleep performs these functions synchronously, we must
5187        // do the same here.  We cannot post this work to a handler because
5188        // that might cause it to become reordered with respect to what
5189        // may happen in a future call to goToSleep.
5190        synchronized (mLock) {
5191            mAwake = true;
5192            mKeyguardDrawComplete = false;
5193            if (mKeyguardDelegate != null) {
5194                mHandler.removeMessages(MSG_KEYGUARD_DRAWN_TIMEOUT);
5195                mHandler.sendEmptyMessageDelayed(MSG_KEYGUARD_DRAWN_TIMEOUT, 1000);
5196            }
5197
5198            updateWakeGestureListenerLp();
5199            updateOrientationListenerLp();
5200            updateLockScreenTimeout();
5201        }
5202
5203        if (mKeyguardDelegate != null) {
5204            mKeyguardDelegate.onScreenTurnedOn(mKeyguardDelegateCallback);
5205            // ... eventually calls finishKeyguardDrawn
5206        } else {
5207            if (DEBUG_WAKEUP) Slog.d(TAG, "null mKeyguardDelegate: setting mKeyguardDrawComplete.");
5208            finishKeyguardDrawn();
5209        }
5210    }
5211
5212    private void finishKeyguardDrawn() {
5213        synchronized (mLock) {
5214            if (!mAwake || mKeyguardDrawComplete) {
5215                return; // spurious
5216            }
5217
5218            mKeyguardDrawComplete = true;
5219            if (mKeyguardDelegate != null) {
5220                mHandler.removeMessages(MSG_KEYGUARD_DRAWN_TIMEOUT);
5221            }
5222        }
5223
5224        finishScreenTurningOn();
5225    }
5226
5227    // Called on the DisplayManager's DisplayPowerController thread.
5228    @Override
5229    public void screenTurnedOff() {
5230        if (DEBUG_WAKEUP) Slog.i(TAG, "Screen turned off...");
5231
5232        synchronized (mLock) {
5233            mScreenOnEarly = false;
5234            mScreenOnFully = false;
5235            mWindowManagerDrawComplete = false;
5236            mScreenOnListener = null;
5237            updateOrientationListenerLp();
5238        }
5239    }
5240
5241    // Called on the DisplayManager's DisplayPowerController thread.
5242    @Override
5243    public void screenTurningOn(final ScreenOnListener screenOnListener) {
5244        if (DEBUG_WAKEUP) Slog.i(TAG, "Screen turning on...");
5245
5246        synchronized (mLock) {
5247            mScreenOnEarly = true;
5248            mScreenOnFully = false;
5249            mWindowManagerDrawComplete = false;
5250            mScreenOnListener = screenOnListener;
5251            updateOrientationListenerLp();
5252        }
5253
5254        mWindowManagerInternal.waitForAllWindowsDrawn(mWindowManagerDrawCallback,
5255                WAITING_FOR_DRAWN_TIMEOUT);
5256        // ... eventually calls finishWindowsDrawn
5257    }
5258
5259    private void finishWindowsDrawn() {
5260        synchronized (mLock) {
5261            if (!mScreenOnEarly || mWindowManagerDrawComplete) {
5262                return; // spurious
5263            }
5264
5265            mWindowManagerDrawComplete = true;
5266        }
5267
5268        finishScreenTurningOn();
5269    }
5270
5271    private void finishScreenTurningOn() {
5272        final ScreenOnListener listener;
5273        final boolean enableScreen;
5274        synchronized (mLock) {
5275            if (DEBUG_WAKEUP) Slog.d(TAG,
5276                    "finishScreenTurningOn: mAwake=" + mAwake
5277                            + ", mScreenOnEarly=" + mScreenOnEarly
5278                            + ", mScreenOnFully=" + mScreenOnFully
5279                            + ", mKeyguardDrawComplete=" + mKeyguardDrawComplete
5280                            + ", mWindowManagerDrawComplete=" + mWindowManagerDrawComplete);
5281
5282            if (mScreenOnFully || !mScreenOnEarly || !mWindowManagerDrawComplete
5283                    || (mAwake && !mKeyguardDrawComplete)) {
5284                return; // spurious or not ready yet
5285            }
5286
5287            if (DEBUG_WAKEUP) Slog.i(TAG, "Finished screen turning on...");
5288            listener = mScreenOnListener;
5289            mScreenOnListener = null;
5290            mScreenOnFully = true;
5291
5292            // Remember the first time we draw the keyguard so we know when we're done with
5293            // the main part of booting and can enable the screen and hide boot messages.
5294            if (!mKeyguardDrawnOnce && mAwake) {
5295                mKeyguardDrawnOnce = true;
5296                enableScreen = true;
5297                if (mBootMessageNeedsHiding) {
5298                    mBootMessageNeedsHiding = false;
5299                    hideBootMessages();
5300                }
5301            } else {
5302                enableScreen = false;
5303            }
5304        }
5305
5306        if (listener != null) {
5307            listener.onScreenOn();
5308        }
5309
5310        if (enableScreen) {
5311            try {
5312                mWindowManager.enableScreenIfNeeded();
5313            } catch (RemoteException unhandled) {
5314            }
5315        }
5316    }
5317
5318    private void handleHideBootMessage() {
5319        synchronized (mLock) {
5320            if (!mKeyguardDrawnOnce) {
5321                mBootMessageNeedsHiding = true;
5322                return; // keyguard hasn't drawn the first time yet, not done booting
5323            }
5324        }
5325
5326        if (mBootMsgDialog != null) {
5327            if (DEBUG_WAKEUP) Slog.d(TAG, "handleHideBootMessage: dismissing");
5328            mBootMsgDialog.dismiss();
5329            mBootMsgDialog = null;
5330        }
5331    }
5332
5333    @Override
5334    public boolean isScreenOn() {
5335        return mScreenOnFully;
5336    }
5337
5338    /** {@inheritDoc} */
5339    @Override
5340    public void enableKeyguard(boolean enabled) {
5341        if (mKeyguardDelegate != null) {
5342            mKeyguardDelegate.setKeyguardEnabled(enabled);
5343        }
5344    }
5345
5346    /** {@inheritDoc} */
5347    @Override
5348    public void exitKeyguardSecurely(OnKeyguardExitResult callback) {
5349        if (mKeyguardDelegate != null) {
5350            mKeyguardDelegate.verifyUnlock(callback);
5351        }
5352    }
5353
5354    private boolean isKeyguardShowingAndNotOccluded() {
5355        if (mKeyguardDelegate == null) return false;
5356        return mKeyguardDelegate.isShowing() && !mKeyguardOccluded;
5357    }
5358
5359    /** {@inheritDoc} */
5360    @Override
5361    public boolean isKeyguardLocked() {
5362        return keyguardOn();
5363    }
5364
5365    /** {@inheritDoc} */
5366    @Override
5367    public boolean isKeyguardSecure() {
5368        if (mKeyguardDelegate == null) return false;
5369        return mKeyguardDelegate.isSecure();
5370    }
5371
5372    /** {@inheritDoc} */
5373    @Override
5374    public boolean inKeyguardRestrictedKeyInputMode() {
5375        if (mKeyguardDelegate == null) return false;
5376        return mKeyguardDelegate.isInputRestricted();
5377    }
5378
5379    @Override
5380    public void dismissKeyguardLw() {
5381        if (mKeyguardDelegate != null && mKeyguardDelegate.isShowing()) {
5382            if (DEBUG_KEYGUARD) Slog.d(TAG, "PWM.dismissKeyguardLw");
5383            mHandler.post(new Runnable() {
5384                @Override
5385                public void run() {
5386                    // ask the keyguard to prompt the user to authenticate if necessary
5387                    mKeyguardDelegate.dismiss();
5388                }
5389            });
5390        }
5391    }
5392
5393    public void notifyActivityDrawnForKeyguardLw() {
5394        if (mKeyguardDelegate != null) {
5395            mHandler.post(new Runnable() {
5396                @Override
5397                public void run() {
5398                    mKeyguardDelegate.onActivityDrawn();
5399                }
5400            });
5401        }
5402    }
5403
5404    @Override
5405    public boolean isKeyguardDrawnLw() {
5406        synchronized (mLock) {
5407            return mKeyguardDrawnOnce;
5408        }
5409    }
5410
5411    @Override
5412    public void startKeyguardExitAnimation(long startTime, long fadeoutDuration) {
5413        if (mKeyguardDelegate != null) {
5414            if (DEBUG_KEYGUARD) Slog.d(TAG, "PWM.startKeyguardExitAnimation");
5415            mKeyguardDelegate.startKeyguardExitAnimation(startTime, fadeoutDuration);
5416        }
5417    }
5418
5419    void sendCloseSystemWindows() {
5420        PhoneWindow.sendCloseSystemWindows(mContext, null);
5421    }
5422
5423    void sendCloseSystemWindows(String reason) {
5424        PhoneWindow.sendCloseSystemWindows(mContext, reason);
5425    }
5426
5427    @Override
5428    public int rotationForOrientationLw(int orientation, int lastRotation) {
5429        if (false) {
5430            Slog.v(TAG, "rotationForOrientationLw(orient="
5431                        + orientation + ", last=" + lastRotation
5432                        + "); user=" + mUserRotation + " "
5433                        + ((mUserRotationMode == WindowManagerPolicy.USER_ROTATION_LOCKED)
5434                            ? "USER_ROTATION_LOCKED" : "")
5435                        );
5436        }
5437
5438        if (mForceDefaultOrientation) {
5439            return Surface.ROTATION_0;
5440        }
5441
5442        synchronized (mLock) {
5443            int sensorRotation = mOrientationListener.getProposedRotation(); // may be -1
5444            if (sensorRotation < 0) {
5445                sensorRotation = lastRotation;
5446            }
5447
5448            final int preferredRotation;
5449            if (mLidState == LID_OPEN && mLidOpenRotation >= 0) {
5450                // Ignore sensor when lid switch is open and rotation is forced.
5451                preferredRotation = mLidOpenRotation;
5452            } else if (mDockMode == Intent.EXTRA_DOCK_STATE_CAR
5453                    && (mCarDockEnablesAccelerometer || mCarDockRotation >= 0)) {
5454                // Ignore sensor when in car dock unless explicitly enabled.
5455                // This case can override the behavior of NOSENSOR, and can also
5456                // enable 180 degree rotation while docked.
5457                preferredRotation = mCarDockEnablesAccelerometer
5458                        ? sensorRotation : mCarDockRotation;
5459            } else if ((mDockMode == Intent.EXTRA_DOCK_STATE_DESK
5460                    || mDockMode == Intent.EXTRA_DOCK_STATE_LE_DESK
5461                    || mDockMode == Intent.EXTRA_DOCK_STATE_HE_DESK)
5462                    && (mDeskDockEnablesAccelerometer || mDeskDockRotation >= 0)) {
5463                // Ignore sensor when in desk dock unless explicitly enabled.
5464                // This case can override the behavior of NOSENSOR, and can also
5465                // enable 180 degree rotation while docked.
5466                preferredRotation = mDeskDockEnablesAccelerometer
5467                        ? sensorRotation : mDeskDockRotation;
5468            } else if (mHdmiPlugged && mDemoHdmiRotationLock) {
5469                // Ignore sensor when plugged into HDMI when demo HDMI rotation lock enabled.
5470                // Note that the dock orientation overrides the HDMI orientation.
5471                preferredRotation = mDemoHdmiRotation;
5472            } else if (mHdmiPlugged && mDockMode == Intent.EXTRA_DOCK_STATE_UNDOCKED
5473                    && mUndockedHdmiRotation >= 0) {
5474                // Ignore sensor when plugged into HDMI and an undocked orientation has
5475                // been specified in the configuration (only for legacy devices without
5476                // full multi-display support).
5477                // Note that the dock orientation overrides the HDMI orientation.
5478                preferredRotation = mUndockedHdmiRotation;
5479            } else if (mDemoRotationLock) {
5480                // Ignore sensor when demo rotation lock is enabled.
5481                // Note that the dock orientation and HDMI rotation lock override this.
5482                preferredRotation = mDemoRotation;
5483            } else if (orientation == ActivityInfo.SCREEN_ORIENTATION_LOCKED) {
5484                // Application just wants to remain locked in the last rotation.
5485                preferredRotation = lastRotation;
5486            } else if (!mSupportAutoRotation) {
5487                // If we don't support auto-rotation then bail out here and ignore
5488                // the sensor and any rotation lock settings.
5489                preferredRotation = -1;
5490            } else if ((mUserRotationMode == WindowManagerPolicy.USER_ROTATION_FREE
5491                            && (orientation == ActivityInfo.SCREEN_ORIENTATION_USER
5492                                    || orientation == ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED
5493                                    || orientation == ActivityInfo.SCREEN_ORIENTATION_USER_LANDSCAPE
5494                                    || orientation == ActivityInfo.SCREEN_ORIENTATION_USER_PORTRAIT
5495                                    || orientation == ActivityInfo.SCREEN_ORIENTATION_FULL_USER))
5496                    || orientation == ActivityInfo.SCREEN_ORIENTATION_SENSOR
5497                    || orientation == ActivityInfo.SCREEN_ORIENTATION_FULL_SENSOR
5498                    || orientation == ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE
5499                    || orientation == ActivityInfo.SCREEN_ORIENTATION_SENSOR_PORTRAIT) {
5500                // Otherwise, use sensor only if requested by the application or enabled
5501                // by default for USER or UNSPECIFIED modes.  Does not apply to NOSENSOR.
5502                if (mAllowAllRotations < 0) {
5503                    // Can't read this during init() because the context doesn't
5504                    // have display metrics at that time so we cannot determine
5505                    // tablet vs. phone then.
5506                    mAllowAllRotations = mContext.getResources().getBoolean(
5507                            com.android.internal.R.bool.config_allowAllRotations) ? 1 : 0;
5508                }
5509                if (sensorRotation != Surface.ROTATION_180
5510                        || mAllowAllRotations == 1
5511                        || orientation == ActivityInfo.SCREEN_ORIENTATION_FULL_SENSOR
5512                        || orientation == ActivityInfo.SCREEN_ORIENTATION_FULL_USER) {
5513                    preferredRotation = sensorRotation;
5514                } else {
5515                    preferredRotation = lastRotation;
5516                }
5517            } else if (mUserRotationMode == WindowManagerPolicy.USER_ROTATION_LOCKED
5518                    && orientation != ActivityInfo.SCREEN_ORIENTATION_NOSENSOR) {
5519                // Apply rotation lock.  Does not apply to NOSENSOR.
5520                // The idea is that the user rotation expresses a weak preference for the direction
5521                // of gravity and as NOSENSOR is never affected by gravity, then neither should
5522                // NOSENSOR be affected by rotation lock (although it will be affected by docks).
5523                preferredRotation = mUserRotation;
5524            } else {
5525                // No overriding preference.
5526                // We will do exactly what the application asked us to do.
5527                preferredRotation = -1;
5528            }
5529
5530            switch (orientation) {
5531                case ActivityInfo.SCREEN_ORIENTATION_PORTRAIT:
5532                    // Return portrait unless overridden.
5533                    if (isAnyPortrait(preferredRotation)) {
5534                        return preferredRotation;
5535                    }
5536                    return mPortraitRotation;
5537
5538                case ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE:
5539                    // Return landscape unless overridden.
5540                    if (isLandscapeOrSeascape(preferredRotation)) {
5541                        return preferredRotation;
5542                    }
5543                    return mLandscapeRotation;
5544
5545                case ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT:
5546                    // Return reverse portrait unless overridden.
5547                    if (isAnyPortrait(preferredRotation)) {
5548                        return preferredRotation;
5549                    }
5550                    return mUpsideDownRotation;
5551
5552                case ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE:
5553                    // Return seascape unless overridden.
5554                    if (isLandscapeOrSeascape(preferredRotation)) {
5555                        return preferredRotation;
5556                    }
5557                    return mSeascapeRotation;
5558
5559                case ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE:
5560                case ActivityInfo.SCREEN_ORIENTATION_USER_LANDSCAPE:
5561                    // Return either landscape rotation.
5562                    if (isLandscapeOrSeascape(preferredRotation)) {
5563                        return preferredRotation;
5564                    }
5565                    if (isLandscapeOrSeascape(lastRotation)) {
5566                        return lastRotation;
5567                    }
5568                    return mLandscapeRotation;
5569
5570                case ActivityInfo.SCREEN_ORIENTATION_SENSOR_PORTRAIT:
5571                case ActivityInfo.SCREEN_ORIENTATION_USER_PORTRAIT:
5572                    // Return either portrait rotation.
5573                    if (isAnyPortrait(preferredRotation)) {
5574                        return preferredRotation;
5575                    }
5576                    if (isAnyPortrait(lastRotation)) {
5577                        return lastRotation;
5578                    }
5579                    return mPortraitRotation;
5580
5581                default:
5582                    // For USER, UNSPECIFIED, NOSENSOR, SENSOR and FULL_SENSOR,
5583                    // just return the preferred orientation we already calculated.
5584                    if (preferredRotation >= 0) {
5585                        return preferredRotation;
5586                    }
5587                    return Surface.ROTATION_0;
5588            }
5589        }
5590    }
5591
5592    @Override
5593    public boolean rotationHasCompatibleMetricsLw(int orientation, int rotation) {
5594        switch (orientation) {
5595            case ActivityInfo.SCREEN_ORIENTATION_PORTRAIT:
5596            case ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT:
5597            case ActivityInfo.SCREEN_ORIENTATION_SENSOR_PORTRAIT:
5598                return isAnyPortrait(rotation);
5599
5600            case ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE:
5601            case ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE:
5602            case ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE:
5603                return isLandscapeOrSeascape(rotation);
5604
5605            default:
5606                return true;
5607        }
5608    }
5609
5610    @Override
5611    public void setRotationLw(int rotation) {
5612        mOrientationListener.setCurrentRotation(rotation);
5613    }
5614
5615    private boolean isLandscapeOrSeascape(int rotation) {
5616        return rotation == mLandscapeRotation || rotation == mSeascapeRotation;
5617    }
5618
5619    private boolean isAnyPortrait(int rotation) {
5620        return rotation == mPortraitRotation || rotation == mUpsideDownRotation;
5621    }
5622
5623    @Override
5624    public int getUserRotationMode() {
5625        return Settings.System.getIntForUser(mContext.getContentResolver(),
5626                Settings.System.ACCELEROMETER_ROTATION, 0, UserHandle.USER_CURRENT) != 0 ?
5627                        WindowManagerPolicy.USER_ROTATION_FREE :
5628                                WindowManagerPolicy.USER_ROTATION_LOCKED;
5629    }
5630
5631    // User rotation: to be used when all else fails in assigning an orientation to the device
5632    @Override
5633    public void setUserRotationMode(int mode, int rot) {
5634        ContentResolver res = mContext.getContentResolver();
5635
5636        // mUserRotationMode and mUserRotation will be assigned by the content observer
5637        if (mode == WindowManagerPolicy.USER_ROTATION_LOCKED) {
5638            Settings.System.putIntForUser(res,
5639                    Settings.System.USER_ROTATION,
5640                    rot,
5641                    UserHandle.USER_CURRENT);
5642            Settings.System.putIntForUser(res,
5643                    Settings.System.ACCELEROMETER_ROTATION,
5644                    0,
5645                    UserHandle.USER_CURRENT);
5646        } else {
5647            Settings.System.putIntForUser(res,
5648                    Settings.System.ACCELEROMETER_ROTATION,
5649                    1,
5650                    UserHandle.USER_CURRENT);
5651        }
5652    }
5653
5654    @Override
5655    public void setSafeMode(boolean safeMode) {
5656        mSafeMode = safeMode;
5657        performHapticFeedbackLw(null, safeMode
5658                ? HapticFeedbackConstants.SAFE_MODE_ENABLED
5659                : HapticFeedbackConstants.SAFE_MODE_DISABLED, true);
5660    }
5661
5662    static long[] getLongIntArray(Resources r, int resid) {
5663        int[] ar = r.getIntArray(resid);
5664        if (ar == null) {
5665            return null;
5666        }
5667        long[] out = new long[ar.length];
5668        for (int i=0; i<ar.length; i++) {
5669            out[i] = ar[i];
5670        }
5671        return out;
5672    }
5673
5674    /** {@inheritDoc} */
5675    @Override
5676    public void systemReady() {
5677        mKeyguardDelegate = new KeyguardServiceDelegate(mContext);
5678        mKeyguardDelegate.onSystemReady();
5679
5680        readCameraLensCoverState();
5681        updateUiMode();
5682        synchronized (mLock) {
5683            updateOrientationListenerLp();
5684            mSystemReady = true;
5685            mHandler.post(new Runnable() {
5686                @Override
5687                public void run() {
5688                    updateSettings();
5689                }
5690            });
5691        }
5692    }
5693
5694    /** {@inheritDoc} */
5695    @Override
5696    public void systemBooted() {
5697        if (mKeyguardDelegate != null) {
5698            mKeyguardDelegate.bindService(mContext);
5699            mKeyguardDelegate.onBootCompleted();
5700        }
5701        synchronized (mLock) {
5702            mSystemBooted = true;
5703        }
5704        wakingUp();
5705        screenTurningOn(null);
5706    }
5707
5708    ProgressDialog mBootMsgDialog = null;
5709
5710    /** {@inheritDoc} */
5711    @Override
5712    public void showBootMessage(final CharSequence msg, final boolean always) {
5713        mHandler.post(new Runnable() {
5714            @Override public void run() {
5715                if (mBootMsgDialog == null) {
5716                    int theme;
5717                    if (mContext.getPackageManager().hasSystemFeature(
5718                            PackageManager.FEATURE_WATCH)) {
5719                        theme = com.android.internal.R.style.Theme_Micro_Dialog_Alert;
5720                    } else if (mContext.getPackageManager().hasSystemFeature(
5721                            PackageManager.FEATURE_TELEVISION)) {
5722                        theme = com.android.internal.R.style.Theme_Leanback_Dialog_Alert;
5723                    } else {
5724                        theme = 0;
5725                    }
5726
5727                    mBootMsgDialog = new ProgressDialog(mContext, theme) {
5728                        // This dialog will consume all events coming in to
5729                        // it, to avoid it trying to do things too early in boot.
5730                        @Override public boolean dispatchKeyEvent(KeyEvent event) {
5731                            return true;
5732                        }
5733                        @Override public boolean dispatchKeyShortcutEvent(KeyEvent event) {
5734                            return true;
5735                        }
5736                        @Override public boolean dispatchTouchEvent(MotionEvent ev) {
5737                            return true;
5738                        }
5739                        @Override public boolean dispatchTrackballEvent(MotionEvent ev) {
5740                            return true;
5741                        }
5742                        @Override public boolean dispatchGenericMotionEvent(MotionEvent ev) {
5743                            return true;
5744                        }
5745                        @Override public boolean dispatchPopulateAccessibilityEvent(
5746                                AccessibilityEvent event) {
5747                            return true;
5748                        }
5749                    };
5750                    if (mContext.getPackageManager().isUpgrade()) {
5751                        mBootMsgDialog.setTitle(R.string.android_upgrading_title);
5752                    } else {
5753                        mBootMsgDialog.setTitle(R.string.android_start_title);
5754                    }
5755                    mBootMsgDialog.setProgressStyle(ProgressDialog.STYLE_SPINNER);
5756                    mBootMsgDialog.setIndeterminate(true);
5757                    mBootMsgDialog.getWindow().setType(
5758                            WindowManager.LayoutParams.TYPE_BOOT_PROGRESS);
5759                    mBootMsgDialog.getWindow().addFlags(
5760                            WindowManager.LayoutParams.FLAG_DIM_BEHIND
5761                            | WindowManager.LayoutParams.FLAG_LAYOUT_IN_SCREEN);
5762                    mBootMsgDialog.getWindow().setDimAmount(1);
5763                    WindowManager.LayoutParams lp = mBootMsgDialog.getWindow().getAttributes();
5764                    lp.screenOrientation = ActivityInfo.SCREEN_ORIENTATION_NOSENSOR;
5765                    mBootMsgDialog.getWindow().setAttributes(lp);
5766                    mBootMsgDialog.setCancelable(false);
5767                    mBootMsgDialog.show();
5768                }
5769                mBootMsgDialog.setMessage(msg);
5770            }
5771        });
5772    }
5773
5774    /** {@inheritDoc} */
5775    @Override
5776    public void hideBootMessages() {
5777        mHandler.sendEmptyMessage(MSG_HIDE_BOOT_MESSAGE);
5778    }
5779
5780    /** {@inheritDoc} */
5781    @Override
5782    public void userActivity() {
5783        // ***************************************
5784        // NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE
5785        // ***************************************
5786        // THIS IS CALLED FROM DEEP IN THE POWER MANAGER
5787        // WITH ITS LOCKS HELD.
5788        //
5789        // This code must be VERY careful about the locks
5790        // it acquires.
5791        // In fact, the current code acquires way too many,
5792        // and probably has lurking deadlocks.
5793
5794        synchronized (mScreenLockTimeout) {
5795            if (mLockScreenTimerActive) {
5796                // reset the timer
5797                mHandler.removeCallbacks(mScreenLockTimeout);
5798                mHandler.postDelayed(mScreenLockTimeout, mLockScreenTimeout);
5799            }
5800        }
5801    }
5802
5803    class ScreenLockTimeout implements Runnable {
5804        Bundle options;
5805
5806        @Override
5807        public void run() {
5808            synchronized (this) {
5809                if (localLOGV) Log.v(TAG, "mScreenLockTimeout activating keyguard");
5810                if (mKeyguardDelegate != null) {
5811                    mKeyguardDelegate.doKeyguardTimeout(options);
5812                }
5813                mLockScreenTimerActive = false;
5814                options = null;
5815            }
5816        }
5817
5818        public void setLockOptions(Bundle options) {
5819            this.options = options;
5820        }
5821    }
5822
5823    ScreenLockTimeout mScreenLockTimeout = new ScreenLockTimeout();
5824
5825    @Override
5826    public void lockNow(Bundle options) {
5827        mContext.enforceCallingOrSelfPermission(android.Manifest.permission.DEVICE_POWER, null);
5828        mHandler.removeCallbacks(mScreenLockTimeout);
5829        if (options != null) {
5830            // In case multiple calls are made to lockNow, we don't wipe out the options
5831            // until the runnable actually executes.
5832            mScreenLockTimeout.setLockOptions(options);
5833        }
5834        mHandler.post(mScreenLockTimeout);
5835    }
5836
5837    private void updateLockScreenTimeout() {
5838        synchronized (mScreenLockTimeout) {
5839            boolean enable = (mAllowLockscreenWhenOn && mAwake &&
5840                    mKeyguardDelegate != null && mKeyguardDelegate.isSecure());
5841            if (mLockScreenTimerActive != enable) {
5842                if (enable) {
5843                    if (localLOGV) Log.v(TAG, "setting lockscreen timer");
5844                    mHandler.postDelayed(mScreenLockTimeout, mLockScreenTimeout);
5845                } else {
5846                    if (localLOGV) Log.v(TAG, "clearing lockscreen timer");
5847                    mHandler.removeCallbacks(mScreenLockTimeout);
5848                }
5849                mLockScreenTimerActive = enable;
5850            }
5851        }
5852    }
5853
5854    /** {@inheritDoc} */
5855    @Override
5856    public void enableScreenAfterBoot() {
5857        readLidState();
5858        applyLidSwitchState();
5859        updateRotation(true);
5860    }
5861
5862    private void applyLidSwitchState() {
5863        if (mLidState == LID_CLOSED && mLidControlsSleep) {
5864            mPowerManager.goToSleep(SystemClock.uptimeMillis(),
5865                    PowerManager.GO_TO_SLEEP_REASON_LID_SWITCH,
5866                    PowerManager.GO_TO_SLEEP_FLAG_NO_DOZE);
5867        }
5868
5869        synchronized (mLock) {
5870            updateWakeGestureListenerLp();
5871        }
5872    }
5873
5874    void updateUiMode() {
5875        if (mUiModeManager == null) {
5876            mUiModeManager = IUiModeManager.Stub.asInterface(
5877                    ServiceManager.getService(Context.UI_MODE_SERVICE));
5878        }
5879        try {
5880            mUiMode = mUiModeManager.getCurrentModeType();
5881        } catch (RemoteException e) {
5882        }
5883    }
5884
5885    void updateRotation(boolean alwaysSendConfiguration) {
5886        try {
5887            //set orientation on WindowManager
5888            mWindowManager.updateRotation(alwaysSendConfiguration, false);
5889        } catch (RemoteException e) {
5890            // Ignore
5891        }
5892    }
5893
5894    void updateRotation(boolean alwaysSendConfiguration, boolean forceRelayout) {
5895        try {
5896            //set orientation on WindowManager
5897            mWindowManager.updateRotation(alwaysSendConfiguration, forceRelayout);
5898        } catch (RemoteException e) {
5899            // Ignore
5900        }
5901    }
5902
5903    /**
5904     * Return an Intent to launch the currently active dock app as home.  Returns
5905     * null if the standard home should be launched, which is the case if any of the following is
5906     * true:
5907     * <ul>
5908     *  <li>The device is not in either car mode or desk mode
5909     *  <li>The device is in car mode but ENABLE_CAR_DOCK_HOME_CAPTURE is false
5910     *  <li>The device is in desk mode but ENABLE_DESK_DOCK_HOME_CAPTURE is false
5911     *  <li>The device is in car mode but there's no CAR_DOCK app with METADATA_DOCK_HOME
5912     *  <li>The device is in desk mode but there's no DESK_DOCK app with METADATA_DOCK_HOME
5913     * </ul>
5914     * @return A dock intent.
5915     */
5916    Intent createHomeDockIntent() {
5917        Intent intent = null;
5918
5919        // What home does is based on the mode, not the dock state.  That
5920        // is, when in car mode you should be taken to car home regardless
5921        // of whether we are actually in a car dock.
5922        if (mUiMode == Configuration.UI_MODE_TYPE_CAR) {
5923            if (ENABLE_CAR_DOCK_HOME_CAPTURE) {
5924                intent = mCarDockIntent;
5925            }
5926        } else if (mUiMode == Configuration.UI_MODE_TYPE_DESK) {
5927            if (ENABLE_DESK_DOCK_HOME_CAPTURE) {
5928                intent = mDeskDockIntent;
5929            }
5930        } else if (mUiMode == Configuration.UI_MODE_TYPE_WATCH
5931                && (mDockMode == Intent.EXTRA_DOCK_STATE_DESK
5932                        || mDockMode == Intent.EXTRA_DOCK_STATE_HE_DESK
5933                        || mDockMode == Intent.EXTRA_DOCK_STATE_LE_DESK)) {
5934            // Always launch dock home from home when watch is docked, if it exists.
5935            intent = mDeskDockIntent;
5936        }
5937
5938        if (intent == null) {
5939            return null;
5940        }
5941
5942        ActivityInfo ai = null;
5943        ResolveInfo info = mContext.getPackageManager().resolveActivityAsUser(
5944                intent,
5945                PackageManager.MATCH_DEFAULT_ONLY | PackageManager.GET_META_DATA,
5946                mCurrentUserId);
5947        if (info != null) {
5948            ai = info.activityInfo;
5949        }
5950        if (ai != null
5951                && ai.metaData != null
5952                && ai.metaData.getBoolean(Intent.METADATA_DOCK_HOME)) {
5953            intent = new Intent(intent);
5954            intent.setClassName(ai.packageName, ai.name);
5955            return intent;
5956        }
5957
5958        return null;
5959    }
5960
5961    void startDockOrHome(boolean fromHomeKey, boolean awakenFromDreams) {
5962        if (awakenFromDreams) {
5963            awakenDreams();
5964        }
5965
5966        Intent dock = createHomeDockIntent();
5967        if (dock != null) {
5968            try {
5969                if (fromHomeKey) {
5970                    dock.putExtra(WindowManagerPolicy.EXTRA_FROM_HOME_KEY, fromHomeKey);
5971                }
5972                startActivityAsUser(dock, UserHandle.CURRENT);
5973                return;
5974            } catch (ActivityNotFoundException e) {
5975            }
5976        }
5977
5978        Intent intent;
5979
5980        if (fromHomeKey) {
5981            intent = new Intent(mHomeIntent);
5982            intent.putExtra(WindowManagerPolicy.EXTRA_FROM_HOME_KEY, fromHomeKey);
5983        } else {
5984            intent = mHomeIntent;
5985        }
5986
5987        startActivityAsUser(intent, UserHandle.CURRENT);
5988    }
5989
5990    /**
5991     * goes to the home screen
5992     * @return whether it did anything
5993     */
5994    boolean goHome() {
5995        if (!isUserSetupComplete()) {
5996            Slog.i(TAG, "Not going home because user setup is in progress.");
5997            return false;
5998        }
5999        if (false) {
6000            // This code always brings home to the front.
6001            try {
6002                ActivityManagerNative.getDefault().stopAppSwitches();
6003            } catch (RemoteException e) {
6004            }
6005            sendCloseSystemWindows();
6006            startDockOrHome(false /*fromHomeKey*/, true /* awakenFromDreams */);
6007        } else {
6008            // This code brings home to the front or, if it is already
6009            // at the front, puts the device to sleep.
6010            try {
6011                if (SystemProperties.getInt("persist.sys.uts-test-mode", 0) == 1) {
6012                    /// Roll back EndcallBehavior as the cupcake design to pass P1 lab entry.
6013                    Log.d(TAG, "UTS-TEST-MODE");
6014                } else {
6015                    ActivityManagerNative.getDefault().stopAppSwitches();
6016                    sendCloseSystemWindows();
6017                    Intent dock = createHomeDockIntent();
6018                    if (dock != null) {
6019                        int result = ActivityManagerNative.getDefault()
6020                                .startActivityAsUser(null, null, dock,
6021                                        dock.resolveTypeIfNeeded(mContext.getContentResolver()),
6022                                        null, null, 0,
6023                                        ActivityManager.START_FLAG_ONLY_IF_NEEDED,
6024                                        null, null, UserHandle.USER_CURRENT);
6025                        if (result == ActivityManager.START_RETURN_INTENT_TO_CALLER) {
6026                            return false;
6027                        }
6028                    }
6029                }
6030                int result = ActivityManagerNative.getDefault()
6031                        .startActivityAsUser(null, null, mHomeIntent,
6032                                mHomeIntent.resolveTypeIfNeeded(mContext.getContentResolver()),
6033                                null, null, 0,
6034                                ActivityManager.START_FLAG_ONLY_IF_NEEDED,
6035                                null, null, UserHandle.USER_CURRENT);
6036                if (result == ActivityManager.START_RETURN_INTENT_TO_CALLER) {
6037                    return false;
6038                }
6039            } catch (RemoteException ex) {
6040                // bummer, the activity manager, which is in this process, is dead
6041            }
6042        }
6043        return true;
6044    }
6045
6046    @Override
6047    public void setCurrentOrientationLw(int newOrientation) {
6048        synchronized (mLock) {
6049            if (newOrientation != mCurrentAppOrientation) {
6050                mCurrentAppOrientation = newOrientation;
6051                updateOrientationListenerLp();
6052            }
6053        }
6054    }
6055
6056    private void performAuditoryFeedbackForAccessibilityIfNeed() {
6057        if (!isGlobalAccessibilityGestureEnabled()) {
6058            return;
6059        }
6060        AudioManager audioManager = (AudioManager) mContext.getSystemService(
6061                Context.AUDIO_SERVICE);
6062        if (audioManager.isSilentMode()) {
6063            return;
6064        }
6065        Ringtone ringTone = RingtoneManager.getRingtone(mContext,
6066                Settings.System.DEFAULT_NOTIFICATION_URI);
6067        ringTone.setStreamType(AudioManager.STREAM_MUSIC);
6068        ringTone.play();
6069    }
6070
6071    private boolean isTheaterModeEnabled() {
6072        return Settings.Global.getInt(mContext.getContentResolver(),
6073                Settings.Global.THEATER_MODE_ON, 0) == 1;
6074    }
6075
6076    private boolean isGlobalAccessibilityGestureEnabled() {
6077        return Settings.Global.getInt(mContext.getContentResolver(),
6078                Settings.Global.ENABLE_ACCESSIBILITY_GLOBAL_GESTURE_ENABLED, 0) == 1;
6079    }
6080
6081    @Override
6082    public boolean performHapticFeedbackLw(WindowState win, int effectId, boolean always) {
6083        if (!mVibrator.hasVibrator()) {
6084            return false;
6085        }
6086        final boolean hapticsDisabled = Settings.System.getIntForUser(mContext.getContentResolver(),
6087                Settings.System.HAPTIC_FEEDBACK_ENABLED, 0, UserHandle.USER_CURRENT) == 0;
6088        if (hapticsDisabled && !always) {
6089            return false;
6090        }
6091        long[] pattern = null;
6092        switch (effectId) {
6093            case HapticFeedbackConstants.LONG_PRESS:
6094                pattern = mLongPressVibePattern;
6095                break;
6096            case HapticFeedbackConstants.VIRTUAL_KEY:
6097                pattern = mVirtualKeyVibePattern;
6098                break;
6099            case HapticFeedbackConstants.KEYBOARD_TAP:
6100                pattern = mKeyboardTapVibePattern;
6101                break;
6102            case HapticFeedbackConstants.CLOCK_TICK:
6103                pattern = mClockTickVibePattern;
6104                break;
6105            case HapticFeedbackConstants.CALENDAR_DATE:
6106                pattern = mCalendarDateVibePattern;
6107                break;
6108            case HapticFeedbackConstants.SAFE_MODE_DISABLED:
6109                pattern = mSafeModeDisabledVibePattern;
6110                break;
6111            case HapticFeedbackConstants.SAFE_MODE_ENABLED:
6112                pattern = mSafeModeEnabledVibePattern;
6113                break;
6114            default:
6115                return false;
6116        }
6117        int owningUid;
6118        String owningPackage;
6119        if (win != null) {
6120            owningUid = win.getOwningUid();
6121            owningPackage = win.getOwningPackage();
6122        } else {
6123            owningUid = android.os.Process.myUid();
6124            owningPackage = mContext.getOpPackageName();
6125        }
6126        if (pattern.length == 1) {
6127            // One-shot vibration
6128            mVibrator.vibrate(owningUid, owningPackage, pattern[0], VIBRATION_ATTRIBUTES);
6129        } else {
6130            // Pattern vibration
6131            mVibrator.vibrate(owningUid, owningPackage, pattern, -1, VIBRATION_ATTRIBUTES);
6132        }
6133        return true;
6134    }
6135
6136    @Override
6137    public void keepScreenOnStartedLw() {
6138    }
6139
6140    @Override
6141    public void keepScreenOnStoppedLw() {
6142        if (isKeyguardShowingAndNotOccluded()) {
6143            mPowerManager.userActivity(SystemClock.uptimeMillis(), false);
6144        }
6145    }
6146
6147    private int updateSystemUiVisibilityLw() {
6148        // If there is no window focused, there will be nobody to handle the events
6149        // anyway, so just hang on in whatever state we're in until things settle down.
6150        final WindowState win = mFocusedWindow != null ? mFocusedWindow
6151                : mTopFullscreenOpaqueWindowState;
6152        if (win == null) {
6153            return 0;
6154        }
6155        if ((win.getAttrs().privateFlags & PRIVATE_FLAG_KEYGUARD) != 0 && mHideLockScreen == true) {
6156            // We are updating at a point where the keyguard has gotten
6157            // focus, but we were last in a state where the top window is
6158            // hiding it.  This is probably because the keyguard as been
6159            // shown while the top window was displayed, so we want to ignore
6160            // it here because this is just a very transient change and it
6161            // will quickly lose focus once it correctly gets hidden.
6162            return 0;
6163        }
6164
6165        int tmpVisibility = PolicyControl.getSystemUiVisibility(win, null)
6166                & ~mResettingSystemUiFlags
6167                & ~mForceClearedSystemUiFlags;
6168        if (mForcingShowNavBar && win.getSurfaceLayer() < mForcingShowNavBarLayer) {
6169            tmpVisibility &= ~PolicyControl.adjustClearableFlags(win, View.SYSTEM_UI_CLEARABLE_FLAGS);
6170        }
6171        tmpVisibility = updateLightStatusBarLw(tmpVisibility);
6172        final int visibility = updateSystemBarsLw(win, mLastSystemUiFlags, tmpVisibility);
6173        final int diff = visibility ^ mLastSystemUiFlags;
6174        final boolean needsMenu = win.getNeedsMenuLw(mTopFullscreenOpaqueWindowState);
6175        if (diff == 0 && mLastFocusNeedsMenu == needsMenu
6176                && mFocusedApp == win.getAppToken()) {
6177            return 0;
6178        }
6179        mLastSystemUiFlags = visibility;
6180        mLastFocusNeedsMenu = needsMenu;
6181        mFocusedApp = win.getAppToken();
6182        mHandler.post(new Runnable() {
6183                @Override
6184                public void run() {
6185                    try {
6186                        IStatusBarService statusbar = getStatusBarService();
6187                        if (statusbar != null) {
6188                            statusbar.setSystemUiVisibility(visibility, 0xffffffff, win.toString());
6189                            statusbar.topAppWindowChanged(needsMenu);
6190                        }
6191                    } catch (RemoteException e) {
6192                        // re-acquire status bar service next time it is needed.
6193                        mStatusBarService = null;
6194                    }
6195                }
6196            });
6197        return diff;
6198    }
6199
6200    private int updateLightStatusBarLw(int vis) {
6201        WindowState statusColorWin = isStatusBarKeyguard() && !mHideLockScreen
6202                ? mStatusBar
6203                : mTopFullscreenOpaqueOrDimmingWindowState;
6204
6205        if (statusColorWin != null) {
6206            if (statusColorWin == mTopFullscreenOpaqueWindowState) {
6207                // If the top fullscreen-or-dimming window is also the top fullscreen, respect
6208                // its light flag.
6209                vis &= ~View.SYSTEM_UI_FLAG_LIGHT_STATUS_BAR;
6210                vis |= PolicyControl.getSystemUiVisibility(statusColorWin, null)
6211                        & View.SYSTEM_UI_FLAG_LIGHT_STATUS_BAR;
6212            } else if (statusColorWin != null && statusColorWin.isDimming()) {
6213                // Otherwise if it's dimming, clear the light flag.
6214                vis &= ~View.SYSTEM_UI_FLAG_LIGHT_STATUS_BAR;
6215            }
6216        }
6217        return vis;
6218    }
6219
6220    private int updateSystemBarsLw(WindowState win, int oldVis, int vis) {
6221        // apply translucent bar vis flags
6222        WindowState transWin = isStatusBarKeyguard() && !mHideLockScreen
6223                ? mStatusBar
6224                : mTopFullscreenOpaqueWindowState;
6225        vis = mStatusBarController.applyTranslucentFlagLw(transWin, vis, oldVis);
6226        vis = mNavigationBarController.applyTranslucentFlagLw(transWin, vis, oldVis);
6227
6228        // prevent status bar interaction from clearing certain flags
6229        boolean statusBarHasFocus = win.getAttrs().type == TYPE_STATUS_BAR;
6230        if (statusBarHasFocus && !isStatusBarKeyguard()) {
6231            int flags = View.SYSTEM_UI_FLAG_FULLSCREEN
6232                    | View.SYSTEM_UI_FLAG_HIDE_NAVIGATION
6233                    | View.SYSTEM_UI_FLAG_IMMERSIVE
6234                    | View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY
6235                    | View.SYSTEM_UI_FLAG_LIGHT_STATUS_BAR;
6236            if (mHideLockScreen) {
6237                flags |= View.STATUS_BAR_TRANSLUCENT | View.NAVIGATION_BAR_TRANSLUCENT;
6238            }
6239            vis = (vis & ~flags) | (oldVis & flags);
6240        }
6241
6242        if (!areTranslucentBarsAllowed() && transWin != mStatusBar) {
6243            vis &= ~(View.NAVIGATION_BAR_TRANSLUCENT | View.STATUS_BAR_TRANSLUCENT
6244                    | View.SYSTEM_UI_TRANSPARENT);
6245        }
6246
6247        // update status bar
6248        boolean immersiveSticky =
6249                (vis & View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY) != 0;
6250        boolean hideStatusBarWM =
6251                mTopFullscreenOpaqueWindowState != null &&
6252                (PolicyControl.getWindowFlags(mTopFullscreenOpaqueWindowState, null)
6253                        & WindowManager.LayoutParams.FLAG_FULLSCREEN) != 0;
6254        boolean hideStatusBarSysui =
6255                (vis & View.SYSTEM_UI_FLAG_FULLSCREEN) != 0;
6256        boolean hideNavBarSysui =
6257                (vis & View.SYSTEM_UI_FLAG_HIDE_NAVIGATION) != 0;
6258
6259        boolean transientStatusBarAllowed =
6260                mStatusBar != null && (
6261                hideStatusBarWM
6262                || (hideStatusBarSysui && immersiveSticky)
6263                || statusBarHasFocus);
6264
6265        boolean transientNavBarAllowed =
6266                mNavigationBar != null &&
6267                hideNavBarSysui && immersiveSticky;
6268
6269        boolean denyTransientStatus = mStatusBarController.isTransientShowRequested()
6270                && !transientStatusBarAllowed && hideStatusBarSysui;
6271        boolean denyTransientNav = mNavigationBarController.isTransientShowRequested()
6272                && !transientNavBarAllowed;
6273        if (denyTransientStatus || denyTransientNav) {
6274            // clear the clearable flags instead
6275            clearClearableFlagsLw();
6276            vis &= ~View.SYSTEM_UI_CLEARABLE_FLAGS;
6277        }
6278
6279        vis = mStatusBarController.updateVisibilityLw(transientStatusBarAllowed, oldVis, vis);
6280
6281        // update navigation bar
6282        boolean oldImmersiveMode = isImmersiveMode(oldVis);
6283        boolean newImmersiveMode = isImmersiveMode(vis);
6284        if (win != null && oldImmersiveMode != newImmersiveMode) {
6285            final String pkg = win.getOwningPackage();
6286            mImmersiveModeConfirmation.immersiveModeChanged(pkg, newImmersiveMode,
6287                    isUserSetupComplete());
6288        }
6289
6290        vis = mNavigationBarController.updateVisibilityLw(transientNavBarAllowed, oldVis, vis);
6291
6292        return vis;
6293    }
6294
6295    private void clearClearableFlagsLw() {
6296        int newVal = mResettingSystemUiFlags | View.SYSTEM_UI_CLEARABLE_FLAGS;
6297        if (newVal != mResettingSystemUiFlags) {
6298            mResettingSystemUiFlags = newVal;
6299            mWindowManagerFuncs.reevaluateStatusBarVisibility();
6300        }
6301    }
6302
6303    private boolean isImmersiveMode(int vis) {
6304        final int flags = View.SYSTEM_UI_FLAG_IMMERSIVE | View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY;
6305        return mNavigationBar != null
6306                && (vis & View.SYSTEM_UI_FLAG_HIDE_NAVIGATION) != 0
6307                && (vis & flags) != 0
6308                && canHideNavigationBar();
6309    }
6310
6311    /**
6312     * @return whether the navigation or status bar can be made translucent
6313     *
6314     * This should return true unless touch exploration is not enabled or
6315     * R.boolean.config_enableTranslucentDecor is false.
6316     */
6317    private boolean areTranslucentBarsAllowed() {
6318        return mTranslucentDecorEnabled
6319                && !mAccessibilityManager.isTouchExplorationEnabled();
6320    }
6321
6322    // Use this instead of checking config_showNavigationBar so that it can be consistently
6323    // overridden by qemu.hw.mainkeys in the emulator.
6324    @Override
6325    public boolean hasNavigationBar() {
6326        return mHasNavigationBar;
6327    }
6328
6329    @Override
6330    public void setLastInputMethodWindowLw(WindowState ime, WindowState target) {
6331        mLastInputMethodWindow = ime;
6332        mLastInputMethodTargetWindow = target;
6333    }
6334
6335    @Override
6336    public int getInputMethodWindowVisibleHeightLw() {
6337        return mDockBottom - mCurBottom;
6338    }
6339
6340    @Override
6341    public void setCurrentUserLw(int newUserId) {
6342        mCurrentUserId = newUserId;
6343        if (mKeyguardDelegate != null) {
6344            mKeyguardDelegate.setCurrentUser(newUserId);
6345        }
6346        if (mStatusBarService != null) {
6347            try {
6348                mStatusBarService.setCurrentUser(newUserId);
6349            } catch (RemoteException e) {
6350                // oh well
6351            }
6352        }
6353        setLastInputMethodWindowLw(null, null);
6354    }
6355
6356    @Override
6357    public boolean canMagnifyWindow(int windowType) {
6358        switch (windowType) {
6359            case WindowManager.LayoutParams.TYPE_INPUT_METHOD:
6360            case WindowManager.LayoutParams.TYPE_INPUT_METHOD_DIALOG:
6361            case WindowManager.LayoutParams.TYPE_NAVIGATION_BAR:
6362            case WindowManager.LayoutParams.TYPE_MAGNIFICATION_OVERLAY: {
6363                return false;
6364            }
6365        }
6366        return true;
6367    }
6368
6369    @Override
6370    public boolean isTopLevelWindow(int windowType) {
6371        if (windowType >= WindowManager.LayoutParams.FIRST_SUB_WINDOW
6372                && windowType <= WindowManager.LayoutParams.LAST_SUB_WINDOW) {
6373            return (windowType == WindowManager.LayoutParams.TYPE_APPLICATION_ATTACHED_DIALOG);
6374        }
6375        return true;
6376    }
6377
6378    @Override
6379    public void dump(String prefix, PrintWriter pw, String[] args) {
6380        pw.print(prefix); pw.print("mSafeMode="); pw.print(mSafeMode);
6381                pw.print(" mSystemReady="); pw.print(mSystemReady);
6382                pw.print(" mSystemBooted="); pw.println(mSystemBooted);
6383        pw.print(prefix); pw.print("mLidState="); pw.print(mLidState);
6384                pw.print(" mLidOpenRotation="); pw.print(mLidOpenRotation);
6385                pw.print(" mCameraLensCoverState="); pw.print(mCameraLensCoverState);
6386                pw.print(" mHdmiPlugged="); pw.println(mHdmiPlugged);
6387        if (mLastSystemUiFlags != 0 || mResettingSystemUiFlags != 0
6388                || mForceClearedSystemUiFlags != 0) {
6389            pw.print(prefix); pw.print("mLastSystemUiFlags=0x");
6390                    pw.print(Integer.toHexString(mLastSystemUiFlags));
6391                    pw.print(" mResettingSystemUiFlags=0x");
6392                    pw.print(Integer.toHexString(mResettingSystemUiFlags));
6393                    pw.print(" mForceClearedSystemUiFlags=0x");
6394                    pw.println(Integer.toHexString(mForceClearedSystemUiFlags));
6395        }
6396        if (mLastFocusNeedsMenu) {
6397            pw.print(prefix); pw.print("mLastFocusNeedsMenu=");
6398                    pw.println(mLastFocusNeedsMenu);
6399        }
6400        pw.print(prefix); pw.print("mWakeGestureEnabledSetting=");
6401                pw.println(mWakeGestureEnabledSetting);
6402
6403        pw.print(prefix); pw.print("mSupportAutoRotation="); pw.println(mSupportAutoRotation);
6404        pw.print(prefix); pw.print("mUiMode="); pw.print(mUiMode);
6405                pw.print(" mDockMode="); pw.print(mDockMode);
6406                pw.print(" mCarDockRotation="); pw.print(mCarDockRotation);
6407                pw.print(" mDeskDockRotation="); pw.println(mDeskDockRotation);
6408        pw.print(prefix); pw.print("mUserRotationMode="); pw.print(mUserRotationMode);
6409                pw.print(" mUserRotation="); pw.print(mUserRotation);
6410                pw.print(" mAllowAllRotations="); pw.println(mAllowAllRotations);
6411        pw.print(prefix); pw.print("mCurrentAppOrientation="); pw.println(mCurrentAppOrientation);
6412        pw.print(prefix); pw.print("mCarDockEnablesAccelerometer=");
6413                pw.print(mCarDockEnablesAccelerometer);
6414                pw.print(" mDeskDockEnablesAccelerometer=");
6415                pw.println(mDeskDockEnablesAccelerometer);
6416        pw.print(prefix); pw.print("mLidKeyboardAccessibility=");
6417                pw.print(mLidKeyboardAccessibility);
6418                pw.print(" mLidNavigationAccessibility="); pw.print(mLidNavigationAccessibility);
6419                pw.print(" mLidControlsSleep="); pw.println(mLidControlsSleep);
6420        pw.print(prefix);
6421                pw.print("mShortPressOnPowerBehavior="); pw.print(mShortPressOnPowerBehavior);
6422                pw.print(" mLongPressOnPowerBehavior="); pw.println(mLongPressOnPowerBehavior);
6423        pw.print(prefix);
6424                pw.print("mDoublePressOnPowerBehavior="); pw.print(mDoublePressOnPowerBehavior);
6425                pw.print(" mTriplePressOnPowerBehavior="); pw.println(mTriplePressOnPowerBehavior);
6426        pw.print(prefix); pw.print("mHasSoftInput="); pw.println(mHasSoftInput);
6427        pw.print(prefix); pw.print("mAwake="); pw.println(mAwake);
6428        pw.print(prefix); pw.print("mScreenOnEarly="); pw.print(mScreenOnEarly);
6429                pw.print(" mScreenOnFully="); pw.println(mScreenOnFully);
6430        pw.print(prefix); pw.print("mKeyguardDrawComplete="); pw.print(mKeyguardDrawComplete);
6431                pw.print(" mWindowManagerDrawComplete="); pw.println(mWindowManagerDrawComplete);
6432        pw.print(prefix); pw.print("mOrientationSensorEnabled=");
6433                pw.println(mOrientationSensorEnabled);
6434        pw.print(prefix); pw.print("mOverscanScreen=("); pw.print(mOverscanScreenLeft);
6435                pw.print(","); pw.print(mOverscanScreenTop);
6436                pw.print(") "); pw.print(mOverscanScreenWidth);
6437                pw.print("x"); pw.println(mOverscanScreenHeight);
6438        if (mOverscanLeft != 0 || mOverscanTop != 0
6439                || mOverscanRight != 0 || mOverscanBottom != 0) {
6440            pw.print(prefix); pw.print("mOverscan left="); pw.print(mOverscanLeft);
6441                    pw.print(" top="); pw.print(mOverscanTop);
6442                    pw.print(" right="); pw.print(mOverscanRight);
6443                    pw.print(" bottom="); pw.println(mOverscanBottom);
6444        }
6445        pw.print(prefix); pw.print("mRestrictedOverscanScreen=(");
6446                pw.print(mRestrictedOverscanScreenLeft);
6447                pw.print(","); pw.print(mRestrictedOverscanScreenTop);
6448                pw.print(") "); pw.print(mRestrictedOverscanScreenWidth);
6449                pw.print("x"); pw.println(mRestrictedOverscanScreenHeight);
6450        pw.print(prefix); pw.print("mUnrestrictedScreen=("); pw.print(mUnrestrictedScreenLeft);
6451                pw.print(","); pw.print(mUnrestrictedScreenTop);
6452                pw.print(") "); pw.print(mUnrestrictedScreenWidth);
6453                pw.print("x"); pw.println(mUnrestrictedScreenHeight);
6454        pw.print(prefix); pw.print("mRestrictedScreen=("); pw.print(mRestrictedScreenLeft);
6455                pw.print(","); pw.print(mRestrictedScreenTop);
6456                pw.print(") "); pw.print(mRestrictedScreenWidth);
6457                pw.print("x"); pw.println(mRestrictedScreenHeight);
6458        pw.print(prefix); pw.print("mStableFullscreen=("); pw.print(mStableFullscreenLeft);
6459                pw.print(","); pw.print(mStableFullscreenTop);
6460                pw.print(")-("); pw.print(mStableFullscreenRight);
6461                pw.print(","); pw.print(mStableFullscreenBottom); pw.println(")");
6462        pw.print(prefix); pw.print("mStable=("); pw.print(mStableLeft);
6463                pw.print(","); pw.print(mStableTop);
6464                pw.print(")-("); pw.print(mStableRight);
6465                pw.print(","); pw.print(mStableBottom); pw.println(")");
6466        pw.print(prefix); pw.print("mSystem=("); pw.print(mSystemLeft);
6467                pw.print(","); pw.print(mSystemTop);
6468                pw.print(")-("); pw.print(mSystemRight);
6469                pw.print(","); pw.print(mSystemBottom); pw.println(")");
6470        pw.print(prefix); pw.print("mCur=("); pw.print(mCurLeft);
6471                pw.print(","); pw.print(mCurTop);
6472                pw.print(")-("); pw.print(mCurRight);
6473                pw.print(","); pw.print(mCurBottom); pw.println(")");
6474        pw.print(prefix); pw.print("mContent=("); pw.print(mContentLeft);
6475                pw.print(","); pw.print(mContentTop);
6476                pw.print(")-("); pw.print(mContentRight);
6477                pw.print(","); pw.print(mContentBottom); pw.println(")");
6478        pw.print(prefix); pw.print("mVoiceContent=("); pw.print(mVoiceContentLeft);
6479                pw.print(","); pw.print(mVoiceContentTop);
6480                pw.print(")-("); pw.print(mVoiceContentRight);
6481                pw.print(","); pw.print(mVoiceContentBottom); pw.println(")");
6482        pw.print(prefix); pw.print("mDock=("); pw.print(mDockLeft);
6483                pw.print(","); pw.print(mDockTop);
6484                pw.print(")-("); pw.print(mDockRight);
6485                pw.print(","); pw.print(mDockBottom); pw.println(")");
6486        pw.print(prefix); pw.print("mDockLayer="); pw.print(mDockLayer);
6487                pw.print(" mStatusBarLayer="); pw.println(mStatusBarLayer);
6488        pw.print(prefix); pw.print("mShowingLockscreen="); pw.print(mShowingLockscreen);
6489                pw.print(" mShowingDream="); pw.print(mShowingDream);
6490                pw.print(" mDreamingLockscreen="); pw.println(mDreamingLockscreen);
6491        if (mLastInputMethodWindow != null) {
6492            pw.print(prefix); pw.print("mLastInputMethodWindow=");
6493                    pw.println(mLastInputMethodWindow);
6494        }
6495        if (mLastInputMethodTargetWindow != null) {
6496            pw.print(prefix); pw.print("mLastInputMethodTargetWindow=");
6497                    pw.println(mLastInputMethodTargetWindow);
6498        }
6499        if (mStatusBar != null) {
6500            pw.print(prefix); pw.print("mStatusBar=");
6501                    pw.print(mStatusBar); pw.print(" isStatusBarKeyguard=");
6502                    pw.println(isStatusBarKeyguard());
6503        }
6504        if (mNavigationBar != null) {
6505            pw.print(prefix); pw.print("mNavigationBar=");
6506                    pw.println(mNavigationBar);
6507        }
6508        if (mFocusedWindow != null) {
6509            pw.print(prefix); pw.print("mFocusedWindow=");
6510                    pw.println(mFocusedWindow);
6511        }
6512        if (mFocusedApp != null) {
6513            pw.print(prefix); pw.print("mFocusedApp=");
6514                    pw.println(mFocusedApp);
6515        }
6516        if (mWinDismissingKeyguard != null) {
6517            pw.print(prefix); pw.print("mWinDismissingKeyguard=");
6518                    pw.println(mWinDismissingKeyguard);
6519        }
6520        if (mTopFullscreenOpaqueWindowState != null) {
6521            pw.print(prefix); pw.print("mTopFullscreenOpaqueWindowState=");
6522                    pw.println(mTopFullscreenOpaqueWindowState);
6523        }
6524        if (mTopFullscreenOpaqueOrDimmingWindowState != null) {
6525            pw.print(prefix); pw.print("mTopFullscreenOpaqueOrDimmingWindowState=");
6526                    pw.println(mTopFullscreenOpaqueOrDimmingWindowState);
6527        }
6528        if (mForcingShowNavBar) {
6529            pw.print(prefix); pw.print("mForcingShowNavBar=");
6530                    pw.println(mForcingShowNavBar); pw.print( "mForcingShowNavBarLayer=");
6531                    pw.println(mForcingShowNavBarLayer);
6532        }
6533        pw.print(prefix); pw.print("mTopIsFullscreen="); pw.print(mTopIsFullscreen);
6534                pw.print(" mHideLockScreen="); pw.println(mHideLockScreen);
6535        pw.print(prefix); pw.print("mForceStatusBar="); pw.print(mForceStatusBar);
6536                pw.print(" mForceStatusBarFromKeyguard=");
6537                pw.println(mForceStatusBarFromKeyguard);
6538        pw.print(prefix); pw.print("mDismissKeyguard="); pw.print(mDismissKeyguard);
6539                pw.print(" mWinDismissingKeyguard="); pw.print(mWinDismissingKeyguard);
6540                pw.print(" mHomePressed="); pw.println(mHomePressed);
6541        pw.print(prefix); pw.print("mAllowLockscreenWhenOn="); pw.print(mAllowLockscreenWhenOn);
6542                pw.print(" mLockScreenTimeout="); pw.print(mLockScreenTimeout);
6543                pw.print(" mLockScreenTimerActive="); pw.println(mLockScreenTimerActive);
6544        pw.print(prefix); pw.print("mEndcallBehavior="); pw.print(mEndcallBehavior);
6545                pw.print(" mIncallPowerBehavior="); pw.print(mIncallPowerBehavior);
6546                pw.print(" mLongPressOnHomeBehavior="); pw.println(mLongPressOnHomeBehavior);
6547        pw.print(prefix); pw.print("mLandscapeRotation="); pw.print(mLandscapeRotation);
6548                pw.print(" mSeascapeRotation="); pw.println(mSeascapeRotation);
6549        pw.print(prefix); pw.print("mPortraitRotation="); pw.print(mPortraitRotation);
6550                pw.print(" mUpsideDownRotation="); pw.println(mUpsideDownRotation);
6551        pw.print(prefix); pw.print("mDemoHdmiRotation="); pw.print(mDemoHdmiRotation);
6552                pw.print(" mDemoHdmiRotationLock="); pw.println(mDemoHdmiRotationLock);
6553        pw.print(prefix); pw.print("mUndockedHdmiRotation="); pw.println(mUndockedHdmiRotation);
6554
6555        mGlobalKeyManager.dump(prefix, pw);
6556        mStatusBarController.dump(pw, prefix);
6557        mNavigationBarController.dump(pw, prefix);
6558        PolicyControl.dump(prefix, pw);
6559
6560        if (mWakeGestureListener != null) {
6561            mWakeGestureListener.dump(pw, prefix);
6562        }
6563        if (mOrientationListener != null) {
6564            mOrientationListener.dump(pw, prefix);
6565        }
6566        if (mBurnInProtectionHelper != null) {
6567            mBurnInProtectionHelper.dump(prefix, pw);
6568        }
6569    }
6570}
6571