PhoneWindowManager.java revision 56b53b597f015fa73ca339deff62eadf287297ae 
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.internal.policy.impl;
18
19import android.app.Activity;
20import android.app.ActivityManagerNative;
21import android.app.IActivityManager;
22import android.app.IUiModeManager;
23import android.app.ProgressDialog;
24import android.app.UiModeManager;
25import android.content.ActivityNotFoundException;
26import android.content.BroadcastReceiver;
27import android.content.ComponentName;
28import android.content.ContentResolver;
29import android.content.Context;
30import android.content.Intent;
31import android.content.IntentFilter;
32import android.content.ServiceConnection;
33import android.content.pm.ActivityInfo;
34import android.content.pm.PackageManager;
35import android.content.res.CompatibilityInfo;
36import android.content.res.Configuration;
37import android.content.res.Resources;
38import android.database.ContentObserver;
39import android.graphics.PixelFormat;
40import android.graphics.Rect;
41import android.graphics.RectF;
42import android.os.Binder;
43import android.os.Bundle;
44import android.os.Handler;
45import android.os.IBinder;
46import android.os.IRemoteCallback;
47import android.os.LocalPowerManager;
48import android.os.Message;
49import android.os.Messenger;
50import android.os.PowerManager;
51import android.os.RemoteException;
52import android.os.ServiceManager;
53import android.os.SystemClock;
54import android.os.SystemProperties;
55import android.os.UEventObserver;
56import android.os.Vibrator;
57import android.provider.Settings;
58
59import com.android.internal.R;
60import com.android.internal.app.ShutdownThread;
61import com.android.internal.policy.PolicyManager;
62import com.android.internal.statusbar.IStatusBarService;
63import com.android.internal.telephony.ITelephony;
64import com.android.internal.view.BaseInputHandler;
65import com.android.internal.widget.PointerLocationView;
66
67import android.util.DisplayMetrics;
68import android.util.EventLog;
69import android.util.Log;
70import android.util.Slog;
71import android.view.Gravity;
72import android.view.HapticFeedbackConstants;
73import android.view.IWindowManager;
74import android.view.InputChannel;
75import android.view.InputDevice;
76import android.view.InputQueue;
77import android.view.InputHandler;
78import android.view.KeyCharacterMap;
79import android.view.KeyEvent;
80import android.view.MotionEvent;
81import android.view.WindowOrientationListener;
82import android.view.Surface;
83import android.view.View;
84import android.view.ViewConfiguration;
85import android.view.Window;
86import android.view.WindowManager;
87import static android.view.WindowManager.LayoutParams.FIRST_APPLICATION_WINDOW;
88import static android.view.WindowManager.LayoutParams.FLAG_FORCE_NOT_FULLSCREEN;
89import static android.view.WindowManager.LayoutParams.FLAG_FULLSCREEN;
90import static android.view.WindowManager.LayoutParams.FLAG_LAYOUT_IN_SCREEN;
91import static android.view.WindowManager.LayoutParams.FLAG_LAYOUT_INSET_DECOR;
92import static android.view.WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS;
93import static android.view.WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED;
94import static android.view.WindowManager.LayoutParams.FLAG_DISMISS_KEYGUARD;
95import static android.view.WindowManager.LayoutParams.FLAG_ALLOW_LOCK_WHILE_SCREEN_ON;
96import static android.view.WindowManager.LayoutParams.SOFT_INPUT_MASK_ADJUST;
97import static android.view.WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE;
98import static android.view.WindowManager.LayoutParams.SOFT_INPUT_ADJUST_NOTHING;
99import static android.view.WindowManager.LayoutParams.LAST_APPLICATION_WINDOW;
100import static android.view.WindowManager.LayoutParams.TYPE_APPLICATION_MEDIA;
101import static android.view.WindowManager.LayoutParams.TYPE_APPLICATION_MEDIA_OVERLAY;
102import static android.view.WindowManager.LayoutParams.TYPE_APPLICATION_PANEL;
103import static android.view.WindowManager.LayoutParams.TYPE_APPLICATION_SUB_PANEL;
104import static android.view.WindowManager.LayoutParams.TYPE_APPLICATION_ATTACHED_DIALOG;
105import static android.view.WindowManager.LayoutParams.TYPE_DRAG;
106import static android.view.WindowManager.LayoutParams.TYPE_HIDDEN_NAV_CONSUMER;
107import static android.view.WindowManager.LayoutParams.TYPE_KEYGUARD;
108import static android.view.WindowManager.LayoutParams.TYPE_KEYGUARD_DIALOG;
109import static android.view.WindowManager.LayoutParams.TYPE_PHONE;
110import static android.view.WindowManager.LayoutParams.TYPE_PRIORITY_PHONE;
111import static android.view.WindowManager.LayoutParams.TYPE_SEARCH_BAR;
112import static android.view.WindowManager.LayoutParams.TYPE_SECURE_SYSTEM_OVERLAY;
113import static android.view.WindowManager.LayoutParams.TYPE_STATUS_BAR;
114import static android.view.WindowManager.LayoutParams.TYPE_STATUS_BAR_PANEL;
115import static android.view.WindowManager.LayoutParams.TYPE_STATUS_BAR_SUB_PANEL;
116import static android.view.WindowManager.LayoutParams.TYPE_SYSTEM_DIALOG;
117import static android.view.WindowManager.LayoutParams.TYPE_SYSTEM_ALERT;
118import static android.view.WindowManager.LayoutParams.TYPE_SYSTEM_ERROR;
119import static android.view.WindowManager.LayoutParams.TYPE_INPUT_METHOD;
120import static android.view.WindowManager.LayoutParams.TYPE_INPUT_METHOD_DIALOG;
121import static android.view.WindowManager.LayoutParams.TYPE_SYSTEM_OVERLAY;
122import static android.view.WindowManager.LayoutParams.TYPE_TOAST;
123import static android.view.WindowManager.LayoutParams.TYPE_VOLUME_OVERLAY;
124import static android.view.WindowManager.LayoutParams.TYPE_WALLPAPER;
125import static android.view.WindowManager.LayoutParams.TYPE_POINTER;
126import static android.view.WindowManager.LayoutParams.TYPE_NAVIGATION_BAR;
127import static android.view.WindowManager.LayoutParams.TYPE_BOOT_PROGRESS;
128import android.view.WindowManagerImpl;
129import android.view.WindowManagerPolicy;
130import android.view.KeyCharacterMap.FallbackAction;
131import android.view.accessibility.AccessibilityEvent;
132import android.view.animation.Animation;
133import android.view.animation.AnimationUtils;
134import android.media.IAudioService;
135import android.media.AudioManager;
136
137import java.io.File;
138import java.io.FileDescriptor;
139import java.io.FileReader;
140import java.io.IOException;
141import java.io.PrintWriter;
142import java.util.ArrayList;
143
144/**
145 * WindowManagerPolicy implementation for the Android phone UI.  This
146 * introduces a new method suffix, Lp, for an internal lock of the
147 * PhoneWindowManager.  This is used to protect some internal state, and
148 * can be acquired with either thw Lw and Li lock held, so has the restrictions
149 * of both of those when held.
150 */
151public class PhoneWindowManager implements WindowManagerPolicy {
152    static final String TAG = "WindowManager";
153    static final boolean DEBUG = false;
154    static final boolean localLOGV = false;
155    static final boolean DEBUG_LAYOUT = false;
156    static final boolean DEBUG_FALLBACK = false;
157    static final boolean SHOW_STARTING_ANIMATIONS = true;
158    static final boolean SHOW_PROCESSES_ON_ALT_MENU = false;
159
160    static final int LONG_PRESS_POWER_NOTHING = 0;
161    static final int LONG_PRESS_POWER_GLOBAL_ACTIONS = 1;
162    static final int LONG_PRESS_POWER_SHUT_OFF = 2;
163
164    // These need to match the documentation/constant in
165    // core/res/res/values/config.xml
166    static final int LONG_PRESS_HOME_NOTHING = 0;
167    static final int LONG_PRESS_HOME_RECENT_DIALOG = 1;
168    static final int LONG_PRESS_HOME_RECENT_SYSTEM_UI = 2;
169
170    // wallpaper is at the bottom, though the window manager may move it.
171    static final int WALLPAPER_LAYER = 2;
172    static final int APPLICATION_LAYER = 2;
173    static final int PHONE_LAYER = 3;
174    static final int SEARCH_BAR_LAYER = 4;
175    static final int SYSTEM_DIALOG_LAYER = 5;
176    // toasts and the plugged-in battery thing
177    static final int TOAST_LAYER = 6;
178    // SIM errors and unlock.  Not sure if this really should be in a high layer.
179    static final int PRIORITY_PHONE_LAYER = 7;
180    // like the ANR / app crashed dialogs
181    static final int SYSTEM_ALERT_LAYER = 8;
182    // on-screen keyboards and other such input method user interfaces go here.
183    static final int INPUT_METHOD_LAYER = 9;
184    // on-screen keyboards and other such input method user interfaces go here.
185    static final int INPUT_METHOD_DIALOG_LAYER = 10;
186    // the keyguard; nothing on top of these can take focus, since they are
187    // responsible for power management when displayed.
188    static final int KEYGUARD_LAYER = 11;
189    static final int KEYGUARD_DIALOG_LAYER = 12;
190    static final int STATUS_BAR_SUB_PANEL_LAYER = 13;
191    static final int STATUS_BAR_LAYER = 14;
192    static final int STATUS_BAR_PANEL_LAYER = 15;
193    // the on-screen volume indicator and controller shown when the user
194    // changes the device volume
195    static final int VOLUME_OVERLAY_LAYER = 16;
196    // things in here CAN NOT take focus, but are shown on top of everything else.
197    static final int SYSTEM_OVERLAY_LAYER = 17;
198    // the navigation bar, if available, shows atop most things
199    static final int NAVIGATION_BAR_LAYER = 18;
200    // system-level error dialogs
201    static final int SYSTEM_ERROR_LAYER = 19;
202    // the drag layer: input for drag-and-drop is associated with this window,
203    // which sits above all other focusable windows
204    static final int DRAG_LAYER = 20;
205    static final int SECURE_SYSTEM_OVERLAY_LAYER = 21;
206    static final int BOOT_PROGRESS_LAYER = 22;
207    // the (mouse) pointer layer
208    static final int POINTER_LAYER = 23;
209    static final int HIDDEN_NAV_CONSUMER_LAYER = 24;
210
211    static final int APPLICATION_MEDIA_SUBLAYER = -2;
212    static final int APPLICATION_MEDIA_OVERLAY_SUBLAYER = -1;
213    static final int APPLICATION_PANEL_SUBLAYER = 1;
214    static final int APPLICATION_SUB_PANEL_SUBLAYER = 2;
215
216    static public final String SYSTEM_DIALOG_REASON_KEY = "reason";
217    static public final String SYSTEM_DIALOG_REASON_GLOBAL_ACTIONS = "globalactions";
218    static public final String SYSTEM_DIALOG_REASON_RECENT_APPS = "recentapps";
219    static public final String SYSTEM_DIALOG_REASON_HOME_KEY = "homekey";
220
221    // Useful scan codes.
222    private static final int SW_LID = 0x00;
223    private static final int BTN_MOUSE = 0x110;
224
225    /**
226     * Lock protecting internal state.  Must not call out into window
227     * manager with lock held.  (This lock will be acquired in places
228     * where the window manager is calling in with its own lock held.)
229     */
230    final Object mLock = new Object();
231
232    Context mContext;
233    IWindowManager mWindowManager;
234    WindowManagerFuncs mWindowManagerFuncs;
235    LocalPowerManager mPowerManager;
236    IStatusBarService mStatusBarService;
237    Vibrator mVibrator; // Vibrator for giving feedback of orientation changes
238
239    // Vibrator pattern for haptic feedback of a long press.
240    long[] mLongPressVibePattern;
241
242    // Vibrator pattern for haptic feedback of virtual key press.
243    long[] mVirtualKeyVibePattern;
244
245    // Vibrator pattern for a short vibration.
246    long[] mKeyboardTapVibePattern;
247
248    // Vibrator pattern for haptic feedback during boot when safe mode is disabled.
249    long[] mSafeModeDisabledVibePattern;
250
251    // Vibrator pattern for haptic feedback during boot when safe mode is enabled.
252    long[] mSafeModeEnabledVibePattern;
253
254    /** If true, hitting shift & menu will broadcast Intent.ACTION_BUG_REPORT */
255    boolean mEnableShiftMenuBugReports = false;
256
257    boolean mSafeMode;
258    WindowState mStatusBar = null;
259    boolean mStatusBarCanHide;
260    int mStatusBarHeight;
261    final ArrayList<WindowState> mStatusBarPanels = new ArrayList<WindowState>();
262    WindowState mNavigationBar = null;
263    boolean mHasNavigationBar = false;
264    int mNavigationBarWidth = 0, mNavigationBarHeight = 0;
265
266    WindowState mKeyguard = null;
267    KeyguardViewMediator mKeyguardMediator;
268    GlobalActions mGlobalActions;
269    volatile boolean mPowerKeyHandled; // accessed from input reader and handler thread
270    boolean mPendingPowerKeyUpCanceled;
271    RecentApplicationsDialog mRecentAppsDialog;
272    Handler mHandler;
273
274    private static final int LID_ABSENT = -1;
275    private static final int LID_CLOSED = 0;
276    private static final int LID_OPEN = 1;
277
278    int mLidOpen = LID_ABSENT;
279
280    boolean mSystemReady;
281    boolean mSystemBooted;
282    boolean mHdmiPlugged;
283    int mUiMode = Configuration.UI_MODE_TYPE_NORMAL;
284    int mDockMode = Intent.EXTRA_DOCK_STATE_UNDOCKED;
285    int mLidOpenRotation;
286    int mCarDockRotation;
287    int mDeskDockRotation;
288    int mHdmiRotation;
289
290    int mUserRotationMode = WindowManagerPolicy.USER_ROTATION_FREE;
291    int mUserRotation = Surface.ROTATION_0;
292
293    int mAllowAllRotations = -1;
294    boolean mCarDockEnablesAccelerometer;
295    boolean mDeskDockEnablesAccelerometer;
296    int mLidKeyboardAccessibility;
297    int mLidNavigationAccessibility;
298    int mLongPressOnPowerBehavior = -1;
299    boolean mScreenOnEarly = false;
300    boolean mScreenOnFully = false;
301    boolean mOrientationSensorEnabled = false;
302    int mCurrentAppOrientation = ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED;
303    static final int DEFAULT_ACCELEROMETER_ROTATION = 0;
304    int mAccelerometerDefault = DEFAULT_ACCELEROMETER_ROTATION;
305    boolean mHasSoftInput = false;
306
307    int mPointerLocationMode = 0;
308    PointerLocationView mPointerLocationView = null;
309    InputChannel mPointerLocationInputChannel;
310
311    // The last window we were told about in focusChanged.
312    WindowState mFocusedWindow;
313
314    private final InputHandler mPointerLocationInputHandler = new BaseInputHandler() {
315        @Override
316        public void handleMotion(MotionEvent event, InputQueue.FinishedCallback finishedCallback) {
317            boolean handled = false;
318            try {
319                if ((event.getSource() & InputDevice.SOURCE_CLASS_POINTER) != 0) {
320                    synchronized (mLock) {
321                        if (mPointerLocationView != null) {
322                            mPointerLocationView.addPointerEvent(event);
323                            handled = true;
324                        }
325                    }
326                }
327            } finally {
328                finishedCallback.finished(handled);
329            }
330        }
331    };
332
333    // The current size of the screen; really; (ir)regardless of whether the status
334    // bar can be hidden or not
335    int mUnrestrictedScreenLeft, mUnrestrictedScreenTop;
336    int mUnrestrictedScreenWidth, mUnrestrictedScreenHeight;
337    // The current size of the screen; these may be different than (0,0)-(dw,dh)
338    // if the status bar can't be hidden; in that case it effectively carves out
339    // that area of the display from all other windows.
340    int mRestrictedScreenLeft, mRestrictedScreenTop;
341    int mRestrictedScreenWidth, mRestrictedScreenHeight;
342    // During layout, the current screen borders with all outer decoration
343    // (status bar, input method dock) accounted for.
344    int mCurLeft, mCurTop, mCurRight, mCurBottom;
345    // During layout, the frame in which content should be displayed
346    // to the user, accounting for all screen decoration except for any
347    // space they deem as available for other content.  This is usually
348    // the same as mCur*, but may be larger if the screen decor has supplied
349    // content insets.
350    int mContentLeft, mContentTop, mContentRight, mContentBottom;
351    // During layout, the current screen borders along which input method
352    // windows are placed.
353    int mDockLeft, mDockTop, mDockRight, mDockBottom;
354    // During layout, the layer at which the doc window is placed.
355    int mDockLayer;
356    int mLastSystemUiFlags;
357    // Bits that we are in the process of clearing, so we want to prevent
358    // them from being set by applications until everything has been updated
359    // to have them clear.
360    int mResettingSystemUiFlags = 0;
361    // Bits that we are currently always keeping cleared.
362    int mForceClearedSystemUiFlags = 0;
363
364    FakeWindow mHideNavFakeWindow = null;
365
366    static final Rect mTmpParentFrame = new Rect();
367    static final Rect mTmpDisplayFrame = new Rect();
368    static final Rect mTmpContentFrame = new Rect();
369    static final Rect mTmpVisibleFrame = new Rect();
370    static final Rect mTmpNavigationFrame = new Rect();
371
372    WindowState mTopFullscreenOpaqueWindowState;
373    WindowState mTopAppWindowState;
374    WindowState mLastTopAppWindowState;
375    boolean mTopIsFullscreen;
376    boolean mForceStatusBar;
377    boolean mHideLockScreen;
378    boolean mDismissKeyguard;
379    boolean mHomePressed;
380    Intent mHomeIntent;
381    Intent mCarDockIntent;
382    Intent mDeskDockIntent;
383    int mShortcutKeyPressed = -1;
384    boolean mConsumeShortcutKeyUp;
385
386    // support for activating the lock screen while the screen is on
387    boolean mAllowLockscreenWhenOn;
388    int mLockScreenTimeout;
389    boolean mLockScreenTimerActive;
390
391    // visual screen saver support
392    int mScreenSaverTimeout = 0;
393    boolean mScreenSaverEnabled = true;
394
395    // Behavior of ENDCALL Button.  (See Settings.System.END_BUTTON_BEHAVIOR.)
396    int mEndcallBehavior;
397
398    // Behavior of POWER button while in-call and screen on.
399    // (See Settings.Secure.INCALL_POWER_BUTTON_BEHAVIOR.)
400    int mIncallPowerBehavior;
401
402    int mLandscapeRotation = 0;  // default landscape rotation
403    int mSeascapeRotation = 0;   // "other" landscape rotation, 180 degrees from mLandscapeRotation
404    int mPortraitRotation = 0;   // default portrait rotation
405    int mUpsideDownRotation = 0; // "other" portrait rotation
406
407    // What we do when the user long presses on home
408    private int mLongPressOnHomeBehavior = -1;
409
410    // Screenshot trigger states
411    // Time to volume and power must be pressed within this interval of each other.
412    private static final long SCREENSHOT_CHORD_DEBOUNCE_DELAY_MILLIS = 150;
413    private boolean mVolumeDownKeyTriggered;
414    private long mVolumeDownKeyTime;
415    private boolean mVolumeDownKeyConsumedByScreenshotChord;
416    private boolean mVolumeUpKeyTriggered;
417    private boolean mPowerKeyTriggered;
418    private long mPowerKeyTime;
419
420    ShortcutManager mShortcutManager;
421    PowerManager.WakeLock mBroadcastWakeLock;
422
423    final KeyCharacterMap.FallbackAction mFallbackAction = new KeyCharacterMap.FallbackAction();
424
425    private UEventObserver mHDMIObserver = new UEventObserver() {
426        @Override
427        public void onUEvent(UEventObserver.UEvent event) {
428            setHdmiPlugged("1".equals(event.get("SWITCH_STATE")));
429        }
430    };
431
432    class SettingsObserver extends ContentObserver {
433        SettingsObserver(Handler handler) {
434            super(handler);
435        }
436
437        void observe() {
438            ContentResolver resolver = mContext.getContentResolver();
439            resolver.registerContentObserver(Settings.System.getUriFor(
440                    Settings.System.END_BUTTON_BEHAVIOR), false, this);
441            resolver.registerContentObserver(Settings.Secure.getUriFor(
442                    Settings.Secure.INCALL_POWER_BUTTON_BEHAVIOR), false, this);
443            resolver.registerContentObserver(Settings.System.getUriFor(
444                    Settings.System.ACCELEROMETER_ROTATION), false, this);
445            resolver.registerContentObserver(Settings.System.getUriFor(
446                    Settings.System.USER_ROTATION), false, this);
447            resolver.registerContentObserver(Settings.System.getUriFor(
448                    Settings.System.SCREEN_OFF_TIMEOUT), false, this);
449            resolver.registerContentObserver(Settings.System.getUriFor(
450                    Settings.System.WINDOW_ORIENTATION_LISTENER_LOG), false, this);
451            resolver.registerContentObserver(Settings.System.getUriFor(
452                    Settings.System.POINTER_LOCATION), false, this);
453            resolver.registerContentObserver(Settings.Secure.getUriFor(
454                    Settings.Secure.DEFAULT_INPUT_METHOD), false, this);
455            resolver.registerContentObserver(Settings.System.getUriFor(
456                    "fancy_rotation_anim"), false, this);
457            resolver.registerContentObserver(Settings.Secure.getUriFor(
458                    Settings.Secure.DREAM_TIMEOUT), false, this);
459            updateSettings();
460        }
461
462        @Override public void onChange(boolean selfChange) {
463            updateSettings();
464            updateRotation(false);
465        }
466    }
467
468    class MyOrientationListener extends WindowOrientationListener {
469        MyOrientationListener(Context context) {
470            super(context);
471        }
472
473        @Override
474        public void onProposedRotationChanged(int rotation) {
475            if (localLOGV) Log.v(TAG, "onProposedRotationChanged, rotation=" + rotation);
476            updateRotation(false);
477        }
478    }
479    MyOrientationListener mOrientationListener;
480
481    /*
482     * We always let the sensor be switched on by default except when
483     * the user has explicitly disabled sensor based rotation or when the
484     * screen is switched off.
485     */
486    boolean needSensorRunningLp() {
487        if (mCurrentAppOrientation == ActivityInfo.SCREEN_ORIENTATION_SENSOR
488                || mCurrentAppOrientation == ActivityInfo.SCREEN_ORIENTATION_FULL_SENSOR
489                || mCurrentAppOrientation == ActivityInfo.SCREEN_ORIENTATION_SENSOR_PORTRAIT
490                || mCurrentAppOrientation == ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE) {
491            // If the application has explicitly requested to follow the
492            // orientation, then we need to turn the sensor or.
493            return true;
494        }
495        if ((mCarDockEnablesAccelerometer && mDockMode == Intent.EXTRA_DOCK_STATE_CAR) ||
496                (mDeskDockEnablesAccelerometer && (mDockMode == Intent.EXTRA_DOCK_STATE_DESK
497                        || mDockMode == Intent.EXTRA_DOCK_STATE_LE_DESK
498                        || mDockMode == Intent.EXTRA_DOCK_STATE_HE_DESK))) {
499            // enable accelerometer if we are docked in a dock that enables accelerometer
500            // orientation management,
501            return true;
502        }
503        if (mAccelerometerDefault == 0) {
504            // If the setting for using the sensor by default is enabled, then
505            // we will always leave it on.  Note that the user could go to
506            // a window that forces an orientation that does not use the
507            // sensor and in theory we could turn it off... however, when next
508            // turning it on we won't have a good value for the current
509            // orientation for a little bit, which can cause orientation
510            // changes to lag, so we'd like to keep it always on.  (It will
511            // still be turned off when the screen is off.)
512            return false;
513        }
514        return true;
515    }
516
517    /*
518     * Various use cases for invoking this function
519     * screen turning off, should always disable listeners if already enabled
520     * screen turned on and current app has sensor based orientation, enable listeners
521     * if not already enabled
522     * screen turned on and current app does not have sensor orientation, disable listeners if
523     * already enabled
524     * screen turning on and current app has sensor based orientation, enable listeners if needed
525     * screen turning on and current app has nosensor based orientation, do nothing
526     */
527    void updateOrientationListenerLp() {
528        if (!mOrientationListener.canDetectOrientation()) {
529            // If sensor is turned off or nonexistent for some reason
530            return;
531        }
532        //Could have been invoked due to screen turning on or off or
533        //change of the currently visible window's orientation
534        if (localLOGV) Log.v(TAG, "Screen status="+mScreenOnEarly+
535                ", current orientation="+mCurrentAppOrientation+
536                ", SensorEnabled="+mOrientationSensorEnabled);
537        boolean disable = true;
538        if (mScreenOnEarly) {
539            if (needSensorRunningLp()) {
540                disable = false;
541                //enable listener if not already enabled
542                if (!mOrientationSensorEnabled) {
543                    mOrientationListener.enable();
544                    if(localLOGV) Log.v(TAG, "Enabling listeners");
545                    mOrientationSensorEnabled = true;
546                }
547            }
548        }
549        //check if sensors need to be disabled
550        if (disable && mOrientationSensorEnabled) {
551            mOrientationListener.disable();
552            if(localLOGV) Log.v(TAG, "Disabling listeners");
553            mOrientationSensorEnabled = false;
554        }
555    }
556
557    private void interceptPowerKeyDown(boolean handled) {
558        mPowerKeyHandled = handled;
559        if (!handled) {
560            mHandler.postDelayed(mPowerLongPress, ViewConfiguration.getGlobalActionKeyTimeout());
561        }
562    }
563
564    private boolean interceptPowerKeyUp(boolean canceled) {
565        if (!mPowerKeyHandled) {
566            mHandler.removeCallbacks(mPowerLongPress);
567            return !canceled;
568        }
569        return false;
570    }
571
572    private void cancelPendingPowerKeyAction() {
573        if (!mPowerKeyHandled) {
574            mHandler.removeCallbacks(mPowerLongPress);
575        }
576        if (mPowerKeyTriggered) {
577            mPendingPowerKeyUpCanceled = true;
578        }
579    }
580
581    private void interceptScreenshotChord() {
582        if (mVolumeDownKeyTriggered && mPowerKeyTriggered && !mVolumeUpKeyTriggered) {
583            final long now = SystemClock.uptimeMillis();
584            if (now <= mVolumeDownKeyTime + SCREENSHOT_CHORD_DEBOUNCE_DELAY_MILLIS
585                    && now <= mPowerKeyTime + SCREENSHOT_CHORD_DEBOUNCE_DELAY_MILLIS) {
586                mVolumeDownKeyConsumedByScreenshotChord = true;
587                cancelPendingPowerKeyAction();
588
589                mHandler.postDelayed(mScreenshotChordLongPress,
590                        ViewConfiguration.getGlobalActionKeyTimeout());
591            }
592        }
593    }
594
595    private void cancelPendingScreenshotChordAction() {
596        mHandler.removeCallbacks(mScreenshotChordLongPress);
597    }
598
599    private final Runnable mPowerLongPress = new Runnable() {
600        public void run() {
601            // The context isn't read
602            if (mLongPressOnPowerBehavior < 0) {
603                mLongPressOnPowerBehavior = mContext.getResources().getInteger(
604                        com.android.internal.R.integer.config_longPressOnPowerBehavior);
605            }
606            switch (mLongPressOnPowerBehavior) {
607            case LONG_PRESS_POWER_NOTHING:
608                break;
609            case LONG_PRESS_POWER_GLOBAL_ACTIONS:
610                mPowerKeyHandled = true;
611                performHapticFeedbackLw(null, HapticFeedbackConstants.LONG_PRESS, false);
612                sendCloseSystemWindows(SYSTEM_DIALOG_REASON_GLOBAL_ACTIONS);
613                showGlobalActionsDialog();
614                break;
615            case LONG_PRESS_POWER_SHUT_OFF:
616                mPowerKeyHandled = true;
617                performHapticFeedbackLw(null, HapticFeedbackConstants.LONG_PRESS, false);
618                sendCloseSystemWindows(SYSTEM_DIALOG_REASON_GLOBAL_ACTIONS);
619                ShutdownThread.shutdown(mContext, true);
620                break;
621            }
622        }
623    };
624
625    private final Runnable mScreenshotChordLongPress = new Runnable() {
626        public void run() {
627            takeScreenshot();
628        }
629    };
630
631    void showGlobalActionsDialog() {
632        if (mGlobalActions == null) {
633            mGlobalActions = new GlobalActions(mContext);
634        }
635        final boolean keyguardShowing = mKeyguardMediator.isShowingAndNotHidden();
636        mGlobalActions.showDialog(keyguardShowing, isDeviceProvisioned());
637        if (keyguardShowing) {
638            // since it took two seconds of long press to bring this up,
639            // poke the wake lock so they have some time to see the dialog.
640            mKeyguardMediator.pokeWakelock();
641        }
642    }
643
644    boolean isDeviceProvisioned() {
645        return Settings.Secure.getInt(
646                mContext.getContentResolver(), Settings.Secure.DEVICE_PROVISIONED, 0) != 0;
647    }
648
649    private void handleLongPressOnHome() {
650        // We can't initialize this in init() since the configuration hasn't been loaded yet.
651        if (mLongPressOnHomeBehavior < 0) {
652            mLongPressOnHomeBehavior
653                    = mContext.getResources().getInteger(R.integer.config_longPressOnHomeBehavior);
654            if (mLongPressOnHomeBehavior < LONG_PRESS_HOME_NOTHING ||
655                    mLongPressOnHomeBehavior > LONG_PRESS_HOME_RECENT_SYSTEM_UI) {
656                mLongPressOnHomeBehavior = LONG_PRESS_HOME_NOTHING;
657            }
658        }
659
660        if (mLongPressOnHomeBehavior != LONG_PRESS_HOME_NOTHING) {
661            performHapticFeedbackLw(null, HapticFeedbackConstants.LONG_PRESS, false);
662            sendCloseSystemWindows(SYSTEM_DIALOG_REASON_RECENT_APPS);
663
664            // Eat the longpress so it won't dismiss the recent apps dialog when
665            // the user lets go of the home key
666            mHomePressed = false;
667        }
668
669        if (mLongPressOnHomeBehavior == LONG_PRESS_HOME_RECENT_DIALOG) {
670            showOrHideRecentAppsDialog(0, true /*dismissIfShown*/);
671        } else if (mLongPressOnHomeBehavior == LONG_PRESS_HOME_RECENT_SYSTEM_UI) {
672            try {
673                mStatusBarService.toggleRecentApps();
674            } catch (RemoteException e) {
675                Slog.e(TAG, "RemoteException when showing recent apps", e);
676            }
677        }
678    }
679
680    /**
681     * Create (if necessary) and launch the recent apps dialog, or hide it if it is
682     * already shown.
683     */
684    void showOrHideRecentAppsDialog(final int heldModifiers, final boolean dismissIfShown) {
685        mHandler.post(new Runnable() {
686            @Override
687            public void run() {
688                if (mRecentAppsDialog == null) {
689                    mRecentAppsDialog = new RecentApplicationsDialog(mContext);
690                }
691                if (mRecentAppsDialog.isShowing()) {
692                    if (dismissIfShown) {
693                        mRecentAppsDialog.dismiss();
694                    }
695                } else {
696                    mRecentAppsDialog.setHeldModifiers(heldModifiers);
697                    mRecentAppsDialog.show();
698                }
699            }
700        });
701    }
702
703    /** {@inheritDoc} */
704    public void init(Context context, IWindowManager windowManager,
705            WindowManagerFuncs windowManagerFuncs,
706            LocalPowerManager powerManager) {
707        mContext = context;
708        mWindowManager = windowManager;
709        mWindowManagerFuncs = windowManagerFuncs;
710        mPowerManager = powerManager;
711        mKeyguardMediator = new KeyguardViewMediator(context, this, powerManager);
712        mHandler = new Handler();
713        mOrientationListener = new MyOrientationListener(mContext);
714        try {
715            mOrientationListener.setCurrentRotation(windowManager.getRotation());
716        } catch (RemoteException ex) { }
717        SettingsObserver settingsObserver = new SettingsObserver(mHandler);
718        settingsObserver.observe();
719        mShortcutManager = new ShortcutManager(context, mHandler);
720        mShortcutManager.observe();
721        mHomeIntent =  new Intent(Intent.ACTION_MAIN, null);
722        mHomeIntent.addCategory(Intent.CATEGORY_HOME);
723        mHomeIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK
724                | Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED);
725        mCarDockIntent =  new Intent(Intent.ACTION_MAIN, null);
726        mCarDockIntent.addCategory(Intent.CATEGORY_CAR_DOCK);
727        mCarDockIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK
728                | Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED);
729        mDeskDockIntent =  new Intent(Intent.ACTION_MAIN, null);
730        mDeskDockIntent.addCategory(Intent.CATEGORY_DESK_DOCK);
731        mDeskDockIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK
732                | Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED);
733
734        PowerManager pm = (PowerManager)context.getSystemService(Context.POWER_SERVICE);
735        mBroadcastWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK,
736                "PhoneWindowManager.mBroadcastWakeLock");
737        mEnableShiftMenuBugReports = "1".equals(SystemProperties.get("ro.debuggable"));
738        mLidOpenRotation = readRotation(
739                com.android.internal.R.integer.config_lidOpenRotation);
740        mCarDockRotation = readRotation(
741                com.android.internal.R.integer.config_carDockRotation);
742        mDeskDockRotation = readRotation(
743                com.android.internal.R.integer.config_deskDockRotation);
744        mCarDockEnablesAccelerometer = mContext.getResources().getBoolean(
745                com.android.internal.R.bool.config_carDockEnablesAccelerometer);
746        mDeskDockEnablesAccelerometer = mContext.getResources().getBoolean(
747                com.android.internal.R.bool.config_deskDockEnablesAccelerometer);
748        mLidKeyboardAccessibility = mContext.getResources().getInteger(
749                com.android.internal.R.integer.config_lidKeyboardAccessibility);
750        mLidNavigationAccessibility = mContext.getResources().getInteger(
751                com.android.internal.R.integer.config_lidNavigationAccessibility);
752        // register for dock events
753        IntentFilter filter = new IntentFilter();
754        filter.addAction(UiModeManager.ACTION_ENTER_CAR_MODE);
755        filter.addAction(UiModeManager.ACTION_EXIT_CAR_MODE);
756        filter.addAction(UiModeManager.ACTION_ENTER_DESK_MODE);
757        filter.addAction(UiModeManager.ACTION_EXIT_DESK_MODE);
758        filter.addAction(Intent.ACTION_DOCK_EVENT);
759        Intent intent = context.registerReceiver(mDockReceiver, filter);
760        if (intent != null) {
761            // Retrieve current sticky dock event broadcast.
762            mDockMode = intent.getIntExtra(Intent.EXTRA_DOCK_STATE,
763                    Intent.EXTRA_DOCK_STATE_UNDOCKED);
764        }
765        mVibrator = new Vibrator();
766        mLongPressVibePattern = getLongIntArray(mContext.getResources(),
767                com.android.internal.R.array.config_longPressVibePattern);
768        mVirtualKeyVibePattern = getLongIntArray(mContext.getResources(),
769                com.android.internal.R.array.config_virtualKeyVibePattern);
770        mKeyboardTapVibePattern = getLongIntArray(mContext.getResources(),
771                com.android.internal.R.array.config_keyboardTapVibePattern);
772        mSafeModeDisabledVibePattern = getLongIntArray(mContext.getResources(),
773                com.android.internal.R.array.config_safeModeDisabledVibePattern);
774        mSafeModeEnabledVibePattern = getLongIntArray(mContext.getResources(),
775                com.android.internal.R.array.config_safeModeEnabledVibePattern);
776
777        // Controls rotation and the like.
778        initializeHdmiState();
779
780        // Match current screen state.
781        if (mPowerManager.isScreenOn()) {
782            screenTurningOn(null);
783        } else {
784            screenTurnedOff(WindowManagerPolicy.OFF_BECAUSE_OF_USER);
785        }
786    }
787
788    public void setInitialDisplaySize(int width, int height) {
789        int shortSize;
790        if (width > height) {
791            shortSize = height;
792            mLandscapeRotation = Surface.ROTATION_0;
793            mSeascapeRotation = Surface.ROTATION_180;
794            if (mContext.getResources().getBoolean(
795                    com.android.internal.R.bool.config_reverseDefaultRotation)) {
796                mPortraitRotation = Surface.ROTATION_90;
797                mUpsideDownRotation = Surface.ROTATION_270;
798            } else {
799                mPortraitRotation = Surface.ROTATION_270;
800                mUpsideDownRotation = Surface.ROTATION_90;
801            }
802        } else {
803            shortSize = width;
804            mPortraitRotation = Surface.ROTATION_0;
805            mUpsideDownRotation = Surface.ROTATION_180;
806            if (mContext.getResources().getBoolean(
807                    com.android.internal.R.bool.config_reverseDefaultRotation)) {
808                mLandscapeRotation = Surface.ROTATION_270;
809                mSeascapeRotation = Surface.ROTATION_90;
810            } else {
811                mLandscapeRotation = Surface.ROTATION_90;
812                mSeascapeRotation = Surface.ROTATION_270;
813            }
814        }
815
816        // Determine whether the status bar can hide based on the size
817        // of the screen.  We assume sizes > 600dp are tablets where we
818        // will use the system bar.
819        int shortSizeDp = shortSize
820                * DisplayMetrics.DENSITY_DEFAULT
821                / DisplayMetrics.DENSITY_DEVICE;
822        mStatusBarCanHide = shortSizeDp < 600;
823        mStatusBarHeight = mContext.getResources().getDimensionPixelSize(
824                mStatusBarCanHide
825                ? com.android.internal.R.dimen.status_bar_height
826                : com.android.internal.R.dimen.system_bar_height);
827
828        mHasNavigationBar = mContext.getResources().getBoolean(
829                com.android.internal.R.bool.config_showNavigationBar);
830        // Allow a system property to override this. Used by the emulator.
831        // See also hasNavigationBar().
832        String navBarOverride = SystemProperties.get("qemu.hw.mainkeys");
833        if (! "".equals(navBarOverride)) {
834            if      (navBarOverride.equals("1")) mHasNavigationBar = false;
835            else if (navBarOverride.equals("0")) mHasNavigationBar = true;
836        }
837
838        mNavigationBarHeight = mHasNavigationBar
839                ? mContext.getResources().getDimensionPixelSize(
840                    com.android.internal.R.dimen.navigation_bar_height)
841                : 0;
842        mNavigationBarWidth = mHasNavigationBar
843                ? mContext.getResources().getDimensionPixelSize(
844                    com.android.internal.R.dimen.navigation_bar_width)
845                : 0;
846
847        if ("portrait".equals(SystemProperties.get("persist.demo.hdmirotation"))) {
848            mHdmiRotation = mPortraitRotation;
849        } else {
850            mHdmiRotation = mLandscapeRotation;
851        }
852    }
853
854    public void updateSettings() {
855        ContentResolver resolver = mContext.getContentResolver();
856        boolean updateRotation = false;
857        View addView = null;
858        View removeView = null;
859        synchronized (mLock) {
860            mEndcallBehavior = Settings.System.getInt(resolver,
861                    Settings.System.END_BUTTON_BEHAVIOR,
862                    Settings.System.END_BUTTON_BEHAVIOR_DEFAULT);
863            mIncallPowerBehavior = Settings.Secure.getInt(resolver,
864                    Settings.Secure.INCALL_POWER_BUTTON_BEHAVIOR,
865                    Settings.Secure.INCALL_POWER_BUTTON_BEHAVIOR_DEFAULT);
866            int accelerometerDefault = Settings.System.getInt(resolver,
867                    Settings.System.ACCELEROMETER_ROTATION, DEFAULT_ACCELEROMETER_ROTATION);
868
869            // set up rotation lock state
870            mUserRotationMode = (accelerometerDefault == 0)
871                ? WindowManagerPolicy.USER_ROTATION_LOCKED
872                : WindowManagerPolicy.USER_ROTATION_FREE;
873            mUserRotation = Settings.System.getInt(resolver,
874                    Settings.System.USER_ROTATION,
875                    Surface.ROTATION_0);
876
877            if (mAccelerometerDefault != accelerometerDefault) {
878                mAccelerometerDefault = accelerometerDefault;
879                updateOrientationListenerLp();
880            }
881
882            mOrientationListener.setLogEnabled(
883                    Settings.System.getInt(resolver,
884                            Settings.System.WINDOW_ORIENTATION_LISTENER_LOG, 0) != 0);
885
886            if (mSystemReady) {
887                int pointerLocation = Settings.System.getInt(resolver,
888                        Settings.System.POINTER_LOCATION, 0);
889                if (mPointerLocationMode != pointerLocation) {
890                    mPointerLocationMode = pointerLocation;
891                    if (pointerLocation != 0) {
892                        if (mPointerLocationView == null) {
893                            mPointerLocationView = new PointerLocationView(mContext);
894                            mPointerLocationView.setPrintCoords(false);
895                            addView = mPointerLocationView;
896                        }
897                    } else {
898                        removeView = mPointerLocationView;
899                        mPointerLocationView = null;
900                    }
901                }
902            }
903            // use screen off timeout setting as the timeout for the lockscreen
904            mLockScreenTimeout = Settings.System.getInt(resolver,
905                    Settings.System.SCREEN_OFF_TIMEOUT, 0);
906            String imId = Settings.Secure.getString(resolver,
907                    Settings.Secure.DEFAULT_INPUT_METHOD);
908            boolean hasSoftInput = imId != null && imId.length() > 0;
909            if (mHasSoftInput != hasSoftInput) {
910                mHasSoftInput = hasSoftInput;
911                updateRotation = true;
912            }
913
914            mScreenSaverTimeout = Settings.Secure.getInt(resolver,
915                    Settings.Secure.DREAM_TIMEOUT, 0);
916            updateScreenSaverTimeoutLocked();
917        }
918        if (updateRotation) {
919            updateRotation(true);
920        }
921        if (addView != null) {
922            WindowManager.LayoutParams lp = new WindowManager.LayoutParams(
923                    WindowManager.LayoutParams.MATCH_PARENT,
924                    WindowManager.LayoutParams.MATCH_PARENT);
925            lp.type = WindowManager.LayoutParams.TYPE_SECURE_SYSTEM_OVERLAY;
926            lp.flags = WindowManager.LayoutParams.FLAG_FULLSCREEN
927                    | WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE
928                    | WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE
929                    | WindowManager.LayoutParams.FLAG_LAYOUT_IN_SCREEN;
930            lp.format = PixelFormat.TRANSLUCENT;
931            lp.setTitle("PointerLocation");
932            WindowManager wm = (WindowManager)
933                    mContext.getSystemService(Context.WINDOW_SERVICE);
934            lp.inputFeatures |= WindowManager.LayoutParams.INPUT_FEATURE_NO_INPUT_CHANNEL;
935            wm.addView(addView, lp);
936
937            if (mPointerLocationInputChannel == null) {
938                try {
939                    mPointerLocationInputChannel =
940                        mWindowManager.monitorInput("PointerLocationView");
941                    InputQueue.registerInputChannel(mPointerLocationInputChannel,
942                            mPointerLocationInputHandler, mHandler.getLooper().getQueue());
943                } catch (RemoteException ex) {
944                    Slog.e(TAG, "Could not set up input monitoring channel for PointerLocation.",
945                            ex);
946                }
947            }
948        }
949        if (removeView != null) {
950            if (mPointerLocationInputChannel != null) {
951                InputQueue.unregisterInputChannel(mPointerLocationInputChannel);
952                mPointerLocationInputChannel.dispose();
953                mPointerLocationInputChannel = null;
954            }
955
956            WindowManager wm = (WindowManager)
957                    mContext.getSystemService(Context.WINDOW_SERVICE);
958            wm.removeView(removeView);
959        }
960    }
961
962    private int readRotation(int resID) {
963        try {
964            int rotation = mContext.getResources().getInteger(resID);
965            switch (rotation) {
966                case 0:
967                    return Surface.ROTATION_0;
968                case 90:
969                    return Surface.ROTATION_90;
970                case 180:
971                    return Surface.ROTATION_180;
972                case 270:
973                    return Surface.ROTATION_270;
974            }
975        } catch (Resources.NotFoundException e) {
976            // fall through
977        }
978        return -1;
979    }
980
981    /** {@inheritDoc} */
982    public int checkAddPermission(WindowManager.LayoutParams attrs) {
983        int type = attrs.type;
984
985        if (type < WindowManager.LayoutParams.FIRST_SYSTEM_WINDOW
986                || type > WindowManager.LayoutParams.LAST_SYSTEM_WINDOW) {
987            return WindowManagerImpl.ADD_OKAY;
988        }
989        String permission = null;
990        switch (type) {
991            case TYPE_TOAST:
992                // XXX right now the app process has complete control over
993                // this...  should introduce a token to let the system
994                // monitor/control what they are doing.
995                break;
996            case TYPE_INPUT_METHOD:
997            case TYPE_WALLPAPER:
998                // The window manager will check these.
999                break;
1000            case TYPE_PHONE:
1001            case TYPE_PRIORITY_PHONE:
1002            case TYPE_SYSTEM_ALERT:
1003            case TYPE_SYSTEM_ERROR:
1004            case TYPE_SYSTEM_OVERLAY:
1005                permission = android.Manifest.permission.SYSTEM_ALERT_WINDOW;
1006                break;
1007            default:
1008                permission = android.Manifest.permission.INTERNAL_SYSTEM_WINDOW;
1009        }
1010        if (permission != null) {
1011            if (mContext.checkCallingOrSelfPermission(permission)
1012                    != PackageManager.PERMISSION_GRANTED) {
1013                return WindowManagerImpl.ADD_PERMISSION_DENIED;
1014            }
1015        }
1016        return WindowManagerImpl.ADD_OKAY;
1017    }
1018
1019    public void adjustWindowParamsLw(WindowManager.LayoutParams attrs) {
1020        switch (attrs.type) {
1021            case TYPE_SYSTEM_OVERLAY:
1022            case TYPE_SECURE_SYSTEM_OVERLAY:
1023            case TYPE_TOAST:
1024                // These types of windows can't receive input events.
1025                attrs.flags |= WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE
1026                        | WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE;
1027                attrs.flags &= ~WindowManager.LayoutParams.FLAG_WATCH_OUTSIDE_TOUCH;
1028                break;
1029        }
1030    }
1031
1032    void readLidState() {
1033        try {
1034            int sw = mWindowManager.getSwitchState(SW_LID);
1035            if (sw > 0) {
1036                mLidOpen = LID_OPEN;
1037            } else if (sw == 0) {
1038                mLidOpen = LID_CLOSED;
1039            } else {
1040                mLidOpen = LID_ABSENT;
1041            }
1042        } catch (RemoteException e) {
1043            // Ignore
1044        }
1045    }
1046
1047    private int determineHiddenState(int mode, int hiddenValue, int visibleValue) {
1048        if (mLidOpen != LID_ABSENT) {
1049            switch (mode) {
1050                case 1:
1051                    return mLidOpen == LID_OPEN ? visibleValue : hiddenValue;
1052                case 2:
1053                    return mLidOpen == LID_OPEN ? hiddenValue : visibleValue;
1054            }
1055        }
1056        return visibleValue;
1057    }
1058
1059    /** {@inheritDoc} */
1060    public void adjustConfigurationLw(Configuration config) {
1061        readLidState();
1062        updateKeyboardVisibility();
1063
1064        if (config.keyboard == Configuration.KEYBOARD_NOKEYS) {
1065            config.hardKeyboardHidden = Configuration.HARDKEYBOARDHIDDEN_YES;
1066        } else {
1067            config.hardKeyboardHidden = determineHiddenState(mLidKeyboardAccessibility,
1068                    Configuration.HARDKEYBOARDHIDDEN_YES, Configuration.HARDKEYBOARDHIDDEN_NO);
1069        }
1070
1071        if (config.navigation == Configuration.NAVIGATION_NONAV) {
1072            config.navigationHidden = Configuration.NAVIGATIONHIDDEN_YES;
1073        } else {
1074            config.navigationHidden = determineHiddenState(mLidNavigationAccessibility,
1075                    Configuration.NAVIGATIONHIDDEN_YES, Configuration.NAVIGATIONHIDDEN_NO);
1076        }
1077
1078        if (mHasSoftInput || config.hardKeyboardHidden == Configuration.HARDKEYBOARDHIDDEN_NO) {
1079            config.keyboardHidden = Configuration.KEYBOARDHIDDEN_NO;
1080        } else {
1081            config.keyboardHidden = Configuration.KEYBOARDHIDDEN_YES;
1082        }
1083    }
1084
1085    /** {@inheritDoc} */
1086    public int windowTypeToLayerLw(int type) {
1087        if (type >= FIRST_APPLICATION_WINDOW && type <= LAST_APPLICATION_WINDOW) {
1088            return APPLICATION_LAYER;
1089        }
1090        switch (type) {
1091        case TYPE_STATUS_BAR:
1092            return STATUS_BAR_LAYER;
1093        case TYPE_STATUS_BAR_PANEL:
1094            return STATUS_BAR_PANEL_LAYER;
1095        case TYPE_STATUS_BAR_SUB_PANEL:
1096            return STATUS_BAR_SUB_PANEL_LAYER;
1097        case TYPE_SYSTEM_DIALOG:
1098            return SYSTEM_DIALOG_LAYER;
1099        case TYPE_SEARCH_BAR:
1100            return SEARCH_BAR_LAYER;
1101        case TYPE_PHONE:
1102            return PHONE_LAYER;
1103        case TYPE_KEYGUARD:
1104            return KEYGUARD_LAYER;
1105        case TYPE_KEYGUARD_DIALOG:
1106            return KEYGUARD_DIALOG_LAYER;
1107        case TYPE_SYSTEM_ALERT:
1108            return SYSTEM_ALERT_LAYER;
1109        case TYPE_SYSTEM_ERROR:
1110            return SYSTEM_ERROR_LAYER;
1111        case TYPE_INPUT_METHOD:
1112            return INPUT_METHOD_LAYER;
1113        case TYPE_INPUT_METHOD_DIALOG:
1114            return INPUT_METHOD_DIALOG_LAYER;
1115        case TYPE_VOLUME_OVERLAY:
1116            return VOLUME_OVERLAY_LAYER;
1117        case TYPE_SYSTEM_OVERLAY:
1118            return SYSTEM_OVERLAY_LAYER;
1119        case TYPE_SECURE_SYSTEM_OVERLAY:
1120            return SECURE_SYSTEM_OVERLAY_LAYER;
1121        case TYPE_PRIORITY_PHONE:
1122            return PRIORITY_PHONE_LAYER;
1123        case TYPE_TOAST:
1124            return TOAST_LAYER;
1125        case TYPE_WALLPAPER:
1126            return WALLPAPER_LAYER;
1127        case TYPE_DRAG:
1128            return DRAG_LAYER;
1129        case TYPE_POINTER:
1130            return POINTER_LAYER;
1131        case TYPE_NAVIGATION_BAR:
1132            return NAVIGATION_BAR_LAYER;
1133        case TYPE_BOOT_PROGRESS:
1134            return BOOT_PROGRESS_LAYER;
1135        case TYPE_HIDDEN_NAV_CONSUMER:
1136            return HIDDEN_NAV_CONSUMER_LAYER;
1137        }
1138        Log.e(TAG, "Unknown window type: " + type);
1139        return APPLICATION_LAYER;
1140    }
1141
1142    /** {@inheritDoc} */
1143    public int subWindowTypeToLayerLw(int type) {
1144        switch (type) {
1145        case TYPE_APPLICATION_PANEL:
1146        case TYPE_APPLICATION_ATTACHED_DIALOG:
1147            return APPLICATION_PANEL_SUBLAYER;
1148        case TYPE_APPLICATION_MEDIA:
1149            return APPLICATION_MEDIA_SUBLAYER;
1150        case TYPE_APPLICATION_MEDIA_OVERLAY:
1151            return APPLICATION_MEDIA_OVERLAY_SUBLAYER;
1152        case TYPE_APPLICATION_SUB_PANEL:
1153            return APPLICATION_SUB_PANEL_SUBLAYER;
1154        }
1155        Log.e(TAG, "Unknown sub-window type: " + type);
1156        return 0;
1157    }
1158
1159    public int getMaxWallpaperLayer() {
1160        return STATUS_BAR_LAYER;
1161    }
1162
1163    public boolean canStatusBarHide() {
1164        return mStatusBarCanHide;
1165    }
1166
1167    public int getNonDecorDisplayWidth(int fullWidth, int fullHeight, int rotation) {
1168        // Assumes that the navigation bar appears on the side of the display in landscape.
1169        if (fullWidth > fullHeight) {
1170            return fullWidth - mNavigationBarWidth;
1171        }
1172        return fullWidth;
1173    }
1174
1175    public int getNonDecorDisplayHeight(int fullWidth, int fullHeight, int rotation) {
1176        // Assumes the navigation bar appears on the bottom of the display in portrait.
1177        return fullHeight
1178            - (mStatusBarCanHide ? 0 : mStatusBarHeight)
1179            - ((fullWidth > fullHeight) ? 0 : mNavigationBarHeight);
1180    }
1181
1182    public int getConfigDisplayWidth(int fullWidth, int fullHeight, int rotation) {
1183        return getNonDecorDisplayWidth(fullWidth, fullHeight, rotation);
1184    }
1185
1186    public int getConfigDisplayHeight(int fullWidth, int fullHeight, int rotation) {
1187        // This is the same as getNonDecorDisplayHeight, unless the status bar
1188        // can hide.  If the status bar can hide, we don't count that as part
1189        // of the decor; however for purposes of configurations, we do want to
1190        // exclude it since applications can't generally use that part of the
1191        // screen.
1192        return getNonDecorDisplayHeight(fullWidth, fullHeight, rotation)
1193                - (mStatusBarCanHide ? mStatusBarHeight : 0);
1194    }
1195
1196    public boolean doesForceHide(WindowState win, WindowManager.LayoutParams attrs) {
1197        return attrs.type == WindowManager.LayoutParams.TYPE_KEYGUARD;
1198    }
1199
1200    public boolean canBeForceHidden(WindowState win, WindowManager.LayoutParams attrs) {
1201        return attrs.type != WindowManager.LayoutParams.TYPE_STATUS_BAR
1202                && attrs.type != WindowManager.LayoutParams.TYPE_WALLPAPER;
1203    }
1204
1205    /** {@inheritDoc} */
1206    public View addStartingWindow(IBinder appToken, String packageName, int theme,
1207            CompatibilityInfo compatInfo, CharSequence nonLocalizedLabel, int labelRes,
1208            int icon, int windowFlags) {
1209        if (!SHOW_STARTING_ANIMATIONS) {
1210            return null;
1211        }
1212        if (packageName == null) {
1213            return null;
1214        }
1215
1216        try {
1217            Context context = mContext;
1218            //Log.i(TAG, "addStartingWindow " + packageName + ": nonLocalizedLabel="
1219            //        + nonLocalizedLabel + " theme=" + Integer.toHexString(theme));
1220            if (theme != context.getThemeResId() || labelRes != 0) {
1221                try {
1222                    context = context.createPackageContext(packageName, 0);
1223                    context.setTheme(theme);
1224                } catch (PackageManager.NameNotFoundException e) {
1225                    // Ignore
1226                }
1227            }
1228
1229            Window win = PolicyManager.makeNewWindow(context);
1230            if (win.getWindowStyle().getBoolean(
1231                    com.android.internal.R.styleable.Window_windowDisablePreview, false)) {
1232                return null;
1233            }
1234
1235            Resources r = context.getResources();
1236            win.setTitle(r.getText(labelRes, nonLocalizedLabel));
1237
1238            win.setType(
1239                WindowManager.LayoutParams.TYPE_APPLICATION_STARTING);
1240            // Force the window flags: this is a fake window, so it is not really
1241            // touchable or focusable by the user.  We also add in the ALT_FOCUSABLE_IM
1242            // flag because we do know that the next window will take input
1243            // focus, so we want to get the IME window up on top of us right away.
1244            win.setFlags(
1245                windowFlags|
1246                WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE|
1247                WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE|
1248                WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM,
1249                windowFlags|
1250                WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE|
1251                WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE|
1252                WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM);
1253
1254            if (!compatInfo.supportsScreen()) {
1255                win.addFlags(WindowManager.LayoutParams.FLAG_COMPATIBLE_WINDOW);
1256            }
1257
1258            win.setLayout(WindowManager.LayoutParams.MATCH_PARENT,
1259                    WindowManager.LayoutParams.MATCH_PARENT);
1260
1261            final WindowManager.LayoutParams params = win.getAttributes();
1262            params.token = appToken;
1263            params.packageName = packageName;
1264            params.windowAnimations = win.getWindowStyle().getResourceId(
1265                    com.android.internal.R.styleable.Window_windowAnimationStyle, 0);
1266            params.privateFlags |=
1267                    WindowManager.LayoutParams.PRIVATE_FLAG_FAKE_HARDWARE_ACCELERATED;
1268            params.setTitle("Starting " + packageName);
1269
1270            WindowManager wm = (WindowManager)context.getSystemService(Context.WINDOW_SERVICE);
1271            View view = win.getDecorView();
1272
1273            if (win.isFloating()) {
1274                // Whoops, there is no way to display an animation/preview
1275                // of such a thing!  After all that work...  let's skip it.
1276                // (Note that we must do this here because it is in
1277                // getDecorView() where the theme is evaluated...  maybe
1278                // we should peek the floating attribute from the theme
1279                // earlier.)
1280                return null;
1281            }
1282
1283            if (localLOGV) Log.v(
1284                TAG, "Adding starting window for " + packageName
1285                + " / " + appToken + ": "
1286                + (view.getParent() != null ? view : null));
1287
1288            wm.addView(view, params);
1289
1290            // Only return the view if it was successfully added to the
1291            // window manager... which we can tell by it having a parent.
1292            return view.getParent() != null ? view : null;
1293        } catch (WindowManagerImpl.BadTokenException e) {
1294            // ignore
1295            Log.w(TAG, appToken + " already running, starting window not displayed");
1296        } catch (RuntimeException e) {
1297            // don't crash if something else bad happens, for example a
1298            // failure loading resources because we are loading from an app
1299            // on external storage that has been unmounted.
1300            Log.w(TAG, appToken + " failed creating starting window", e);
1301        }
1302
1303        return null;
1304    }
1305
1306    /** {@inheritDoc} */
1307    public void removeStartingWindow(IBinder appToken, View window) {
1308        // RuntimeException e = new RuntimeException();
1309        // Log.i(TAG, "remove " + appToken + " " + window, e);
1310
1311        if (localLOGV) Log.v(
1312            TAG, "Removing starting window for " + appToken + ": " + window);
1313
1314        if (window != null) {
1315            WindowManager wm = (WindowManager)mContext.getSystemService(Context.WINDOW_SERVICE);
1316            wm.removeView(window);
1317        }
1318    }
1319
1320    /**
1321     * Preflight adding a window to the system.
1322     *
1323     * Currently enforces that three window types are singletons:
1324     * <ul>
1325     * <li>STATUS_BAR_TYPE</li>
1326     * <li>KEYGUARD_TYPE</li>
1327     * </ul>
1328     *
1329     * @param win The window to be added
1330     * @param attrs Information about the window to be added
1331     *
1332     * @return If ok, WindowManagerImpl.ADD_OKAY.  If too many singletons, WindowManagerImpl.ADD_MULTIPLE_SINGLETON
1333     */
1334    public int prepareAddWindowLw(WindowState win, WindowManager.LayoutParams attrs) {
1335        switch (attrs.type) {
1336            case TYPE_STATUS_BAR:
1337                mContext.enforceCallingOrSelfPermission(
1338                        android.Manifest.permission.STATUS_BAR_SERVICE,
1339                        "PhoneWindowManager");
1340                // TODO: Need to handle the race condition of the status bar proc
1341                // dying and coming back before the removeWindowLw cleanup has happened.
1342                if (mStatusBar != null) {
1343                    return WindowManagerImpl.ADD_MULTIPLE_SINGLETON;
1344                }
1345                mStatusBar = win;
1346                break;
1347            case TYPE_NAVIGATION_BAR:
1348                mContext.enforceCallingOrSelfPermission(
1349                        android.Manifest.permission.STATUS_BAR_SERVICE,
1350                        "PhoneWindowManager");
1351                mNavigationBar = win;
1352                if (DEBUG_LAYOUT) Log.i(TAG, "NAVIGATION BAR: " + mNavigationBar);
1353                break;
1354            case TYPE_STATUS_BAR_PANEL:
1355                mContext.enforceCallingOrSelfPermission(
1356                        android.Manifest.permission.STATUS_BAR_SERVICE,
1357                        "PhoneWindowManager");
1358                mStatusBarPanels.add(win);
1359                break;
1360            case TYPE_STATUS_BAR_SUB_PANEL:
1361                mContext.enforceCallingOrSelfPermission(
1362                        android.Manifest.permission.STATUS_BAR_SERVICE,
1363                        "PhoneWindowManager");
1364                mStatusBarPanels.add(win);
1365                break;
1366            case TYPE_KEYGUARD:
1367                if (mKeyguard != null) {
1368                    return WindowManagerImpl.ADD_MULTIPLE_SINGLETON;
1369                }
1370                mKeyguard = win;
1371                break;
1372        }
1373        return WindowManagerImpl.ADD_OKAY;
1374    }
1375
1376    /** {@inheritDoc} */
1377    public void removeWindowLw(WindowState win) {
1378        if (mStatusBar == win) {
1379            mStatusBar = null;
1380        } else if (mKeyguard == win) {
1381            mKeyguard = null;
1382        } else if (mNavigationBar == win) {
1383            mNavigationBar = null;
1384        } else {
1385            mStatusBarPanels.remove(win);
1386        }
1387    }
1388
1389    static final boolean PRINT_ANIM = false;
1390
1391    /** {@inheritDoc} */
1392    public int selectAnimationLw(WindowState win, int transit) {
1393        if (PRINT_ANIM) Log.i(TAG, "selectAnimation in " + win
1394              + ": transit=" + transit);
1395        if (transit == TRANSIT_PREVIEW_DONE) {
1396            if (win.hasAppShownWindows()) {
1397                if (PRINT_ANIM) Log.i(TAG, "**** STARTING EXIT");
1398                return com.android.internal.R.anim.app_starting_exit;
1399            }
1400        }
1401
1402        return 0;
1403    }
1404
1405    public Animation createForceHideEnterAnimation() {
1406        return AnimationUtils.loadAnimation(mContext,
1407                com.android.internal.R.anim.lock_screen_behind_enter);
1408    }
1409
1410    static ITelephony getTelephonyService() {
1411        ITelephony telephonyService = ITelephony.Stub.asInterface(
1412                ServiceManager.checkService(Context.TELEPHONY_SERVICE));
1413        if (telephonyService == null) {
1414            Log.w(TAG, "Unable to find ITelephony interface.");
1415        }
1416        return telephonyService;
1417    }
1418
1419    static IAudioService getAudioService() {
1420        IAudioService audioService = IAudioService.Stub.asInterface(
1421                ServiceManager.checkService(Context.AUDIO_SERVICE));
1422        if (audioService == null) {
1423            Log.w(TAG, "Unable to find IAudioService interface.");
1424        }
1425        return audioService;
1426    }
1427
1428    boolean keyguardOn() {
1429        return keyguardIsShowingTq() || inKeyguardRestrictedKeyInputMode();
1430    }
1431
1432    private static final int[] WINDOW_TYPES_WHERE_HOME_DOESNT_WORK = {
1433            WindowManager.LayoutParams.TYPE_SYSTEM_ALERT,
1434            WindowManager.LayoutParams.TYPE_SYSTEM_ERROR,
1435        };
1436
1437    /** {@inheritDoc} */
1438    @Override
1439    public long interceptKeyBeforeDispatching(WindowState win, KeyEvent event, int policyFlags) {
1440        final boolean keyguardOn = keyguardOn();
1441        final int keyCode = event.getKeyCode();
1442        final int repeatCount = event.getRepeatCount();
1443        final int metaState = event.getMetaState();
1444        final int flags = event.getFlags();
1445        final boolean down = event.getAction() == KeyEvent.ACTION_DOWN;
1446        final boolean canceled = event.isCanceled();
1447
1448        if (false) {
1449            Log.d(TAG, "interceptKeyTi keyCode=" + keyCode + " down=" + down + " repeatCount="
1450                    + repeatCount + " keyguardOn=" + keyguardOn + " mHomePressed=" + mHomePressed);
1451        }
1452
1453        // If we think we might have a volume down & power key chord on the way
1454        // but we're not sure, then tell the dispatcher to wait a little while and
1455        // try again later before dispatching.
1456        if ((flags & KeyEvent.FLAG_FALLBACK) == 0) {
1457            if (mVolumeDownKeyTriggered && !mPowerKeyTriggered) {
1458                final long now = SystemClock.uptimeMillis();
1459                final long timeoutTime = mVolumeDownKeyTime + SCREENSHOT_CHORD_DEBOUNCE_DELAY_MILLIS;
1460                if (now < timeoutTime) {
1461                    return timeoutTime - now;
1462                }
1463            }
1464            if (keyCode == KeyEvent.KEYCODE_VOLUME_DOWN
1465                    && mVolumeDownKeyConsumedByScreenshotChord) {
1466                if (!down) {
1467                    mVolumeDownKeyConsumedByScreenshotChord = false;
1468                }
1469                return -1;
1470            }
1471        }
1472
1473        // First we always handle the home key here, so applications
1474        // can never break it, although if keyguard is on, we do let
1475        // it handle it, because that gives us the correct 5 second
1476        // timeout.
1477        if (keyCode == KeyEvent.KEYCODE_HOME) {
1478            // If we have released the home key, and didn't do anything else
1479            // while it was pressed, then it is time to go home!
1480            if (mHomePressed && !down) {
1481                mHomePressed = false;
1482                if (!canceled) {
1483                    // If an incoming call is ringing, HOME is totally disabled.
1484                    // (The user is already on the InCallScreen at this point,
1485                    // and his ONLY options are to answer or reject the call.)
1486                    boolean incomingRinging = false;
1487                    try {
1488                        ITelephony telephonyService = getTelephonyService();
1489                        if (telephonyService != null) {
1490                            incomingRinging = telephonyService.isRinging();
1491                        }
1492                    } catch (RemoteException ex) {
1493                        Log.w(TAG, "RemoteException from getPhoneInterface()", ex);
1494                    }
1495
1496                    if (incomingRinging) {
1497                        Log.i(TAG, "Ignoring HOME; there's a ringing incoming call.");
1498                    } else {
1499                        launchHomeFromHotKey();
1500                    }
1501                } else {
1502                    Log.i(TAG, "Ignoring HOME; event canceled.");
1503                }
1504                return -1;
1505            }
1506
1507            // If a system window has focus, then it doesn't make sense
1508            // right now to interact with applications.
1509            WindowManager.LayoutParams attrs = win != null ? win.getAttrs() : null;
1510            if (attrs != null) {
1511                final int type = attrs.type;
1512                if (type == WindowManager.LayoutParams.TYPE_KEYGUARD
1513                        || type == WindowManager.LayoutParams.TYPE_KEYGUARD_DIALOG) {
1514                    // the "app" is keyguard, so give it the key
1515                    return 0;
1516                }
1517                final int typeCount = WINDOW_TYPES_WHERE_HOME_DOESNT_WORK.length;
1518                for (int i=0; i<typeCount; i++) {
1519                    if (type == WINDOW_TYPES_WHERE_HOME_DOESNT_WORK[i]) {
1520                        // don't do anything, but also don't pass it to the app
1521                        return -1;
1522                    }
1523                }
1524            }
1525
1526            if (down) {
1527                if (repeatCount == 0) {
1528                    mHomePressed = true;
1529                } else if ((event.getFlags() & KeyEvent.FLAG_LONG_PRESS) != 0) {
1530                    if (!keyguardOn) {
1531                        handleLongPressOnHome();
1532                    }
1533                }
1534            }
1535            return -1;
1536        } else if (keyCode == KeyEvent.KEYCODE_MENU) {
1537            // Hijack modified menu keys for debugging features
1538            final int chordBug = KeyEvent.META_SHIFT_ON;
1539
1540            if (down && repeatCount == 0) {
1541                if (mEnableShiftMenuBugReports && (metaState & chordBug) == chordBug) {
1542                    Intent intent = new Intent(Intent.ACTION_BUG_REPORT);
1543                    mContext.sendOrderedBroadcast(intent, null);
1544                    return -1;
1545                } else if (SHOW_PROCESSES_ON_ALT_MENU &&
1546                        (metaState & KeyEvent.META_ALT_ON) == KeyEvent.META_ALT_ON) {
1547                    Intent service = new Intent();
1548                    service.setClassName(mContext, "com.android.server.LoadAverageService");
1549                    ContentResolver res = mContext.getContentResolver();
1550                    boolean shown = Settings.System.getInt(
1551                            res, Settings.System.SHOW_PROCESSES, 0) != 0;
1552                    if (!shown) {
1553                        mContext.startService(service);
1554                    } else {
1555                        mContext.stopService(service);
1556                    }
1557                    Settings.System.putInt(
1558                            res, Settings.System.SHOW_PROCESSES, shown ? 0 : 1);
1559                    return -1;
1560                }
1561            }
1562        } else if (keyCode == KeyEvent.KEYCODE_SEARCH) {
1563            if (down) {
1564                if (repeatCount == 0) {
1565                    mShortcutKeyPressed = keyCode;
1566                    mConsumeShortcutKeyUp = false;
1567                }
1568            } else if (keyCode == mShortcutKeyPressed) {
1569                mShortcutKeyPressed = -1;
1570                if (mConsumeShortcutKeyUp) {
1571                    mConsumeShortcutKeyUp = false;
1572                    return -1;
1573                }
1574            }
1575            return 0;
1576        } else if (keyCode == KeyEvent.KEYCODE_APP_SWITCH) {
1577            if (down && repeatCount == 0) {
1578                showOrHideRecentAppsDialog(0, true /*dismissIfShown*/);
1579            }
1580            return -1;
1581        }
1582
1583        // Shortcuts are invoked through Search+key, so intercept those here
1584        // Any printing key that is chorded with Search should be consumed
1585        // even if no shortcut was invoked.  This prevents text from being
1586        // inadvertently inserted when using a keyboard that has built-in macro
1587        // shortcut keys (that emit Search+x) and some of them are not registered.
1588        if (mShortcutKeyPressed != -1) {
1589            final KeyCharacterMap kcm = event.getKeyCharacterMap();
1590            if (kcm.isPrintingKey(keyCode)) {
1591                mConsumeShortcutKeyUp = true;
1592                if (down && repeatCount == 0 && !keyguardOn) {
1593                    Intent shortcutIntent = mShortcutManager.getIntent(kcm, keyCode, metaState);
1594                    if (shortcutIntent != null) {
1595                        shortcutIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
1596                        try {
1597                            mContext.startActivity(shortcutIntent);
1598                        } catch (ActivityNotFoundException ex) {
1599                            Slog.w(TAG, "Dropping shortcut key combination because "
1600                                    + "the activity to which it is registered was not found: "
1601                                    + KeyEvent.keyCodeToString(mShortcutKeyPressed)
1602                                    + "+" + KeyEvent.keyCodeToString(keyCode), ex);
1603                        }
1604                    } else {
1605                        Slog.i(TAG, "Dropping unregistered shortcut key combination: "
1606                                + KeyEvent.keyCodeToString(mShortcutKeyPressed)
1607                                + "+" + KeyEvent.keyCodeToString(keyCode));
1608                    }
1609                }
1610                return -1;
1611            }
1612        }
1613
1614        return 0;
1615    }
1616
1617    /** {@inheritDoc} */
1618    @Override
1619    public KeyEvent dispatchUnhandledKey(WindowState win, KeyEvent event, int policyFlags) {
1620        // Note: This method is only called if the initial down was unhandled.
1621        if (DEBUG_FALLBACK) {
1622            Slog.d(TAG, "Unhandled key: win=" + win + ", action=" + event.getAction()
1623                    + ", flags=" + event.getFlags()
1624                    + ", keyCode=" + event.getKeyCode()
1625                    + ", scanCode=" + event.getScanCode()
1626                    + ", metaState=" + event.getMetaState()
1627                    + ", repeatCount=" + event.getRepeatCount()
1628                    + ", policyFlags=" + policyFlags);
1629        }
1630
1631        if ((event.getFlags() & KeyEvent.FLAG_FALLBACK) == 0) {
1632            final KeyCharacterMap kcm = event.getKeyCharacterMap();
1633            final int keyCode = event.getKeyCode();
1634            final int metaState = event.getMetaState();
1635            final boolean initialDown = event.getAction() == KeyEvent.ACTION_DOWN
1636                    && event.getRepeatCount() == 0;
1637
1638            if (initialDown) {
1639                // Invoke shortcuts using Meta as a fallback.
1640                if ((metaState & KeyEvent.META_META_ON) != 0) {
1641                    Intent shortcutIntent = mShortcutManager.getIntent(kcm, keyCode,
1642                            metaState & ~(KeyEvent.META_META_ON
1643                                    | KeyEvent.META_META_LEFT_ON | KeyEvent.META_META_RIGHT_ON));
1644                    if (shortcutIntent != null) {
1645                        shortcutIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
1646                        try {
1647                            mContext.startActivity(shortcutIntent);
1648                        } catch (ActivityNotFoundException ex) {
1649                            Slog.w(TAG, "Dropping shortcut key combination because "
1650                                    + "the activity to which it is registered was not found: "
1651                                    + "META+" + KeyEvent.keyCodeToString(keyCode), ex);
1652                        }
1653                        return null;
1654                    }
1655                }
1656
1657                // Display task switcher for ALT-TAB or Meta-TAB.
1658                if (keyCode == KeyEvent.KEYCODE_TAB) {
1659                    final int shiftlessModifiers = event.getModifiers() & ~KeyEvent.META_SHIFT_MASK;
1660                    if (KeyEvent.metaStateHasModifiers(shiftlessModifiers, KeyEvent.META_ALT_ON)
1661                            || KeyEvent.metaStateHasModifiers(
1662                                    shiftlessModifiers, KeyEvent.META_META_ON)) {
1663                        showOrHideRecentAppsDialog(shiftlessModifiers, false /*dismissIfShown*/);
1664                        return null;
1665                    }
1666                }
1667            }
1668
1669            // Check for fallback actions specified by the key character map.
1670            if (getFallbackAction(kcm, keyCode, metaState, mFallbackAction)) {
1671                if (DEBUG_FALLBACK) {
1672                    Slog.d(TAG, "Fallback: keyCode=" + mFallbackAction.keyCode
1673                            + " metaState=" + Integer.toHexString(mFallbackAction.metaState));
1674                }
1675
1676                int flags = event.getFlags() | KeyEvent.FLAG_FALLBACK;
1677                KeyEvent fallbackEvent = KeyEvent.obtain(
1678                        event.getDownTime(), event.getEventTime(),
1679                        event.getAction(), mFallbackAction.keyCode,
1680                        event.getRepeatCount(), mFallbackAction.metaState,
1681                        event.getDeviceId(), event.getScanCode(),
1682                        flags, event.getSource(), null);
1683                int actions = interceptKeyBeforeQueueing(fallbackEvent, policyFlags, true);
1684                if ((actions & ACTION_PASS_TO_USER) != 0) {
1685                    long delayMillis = interceptKeyBeforeDispatching(
1686                            win, fallbackEvent, policyFlags);
1687                    if (delayMillis == 0) {
1688                        if (DEBUG_FALLBACK) {
1689                            Slog.d(TAG, "Performing fallback.");
1690                        }
1691                        return fallbackEvent;
1692                    }
1693                }
1694                fallbackEvent.recycle();
1695            }
1696        }
1697
1698        if (DEBUG_FALLBACK) {
1699            Slog.d(TAG, "No fallback.");
1700        }
1701        return null;
1702    }
1703
1704    private boolean getFallbackAction(KeyCharacterMap kcm, int keyCode, int metaState,
1705            FallbackAction outFallbackAction) {
1706        // Consult the key character map for specific fallback actions.
1707        // For example, map NUMPAD_1 to MOVE_HOME when NUMLOCK is not pressed.
1708        return kcm.getFallbackAction(keyCode, metaState, outFallbackAction);
1709    }
1710
1711    /**
1712     * A home key -> launch home action was detected.  Take the appropriate action
1713     * given the situation with the keyguard.
1714     */
1715    void launchHomeFromHotKey() {
1716        if (mKeyguardMediator.isShowingAndNotHidden()) {
1717            // don't launch home if keyguard showing
1718        } else if (!mHideLockScreen && mKeyguardMediator.isInputRestricted()) {
1719            // when in keyguard restricted mode, must first verify unlock
1720            // before launching home
1721            mKeyguardMediator.verifyUnlock(new OnKeyguardExitResult() {
1722                public void onKeyguardExitResult(boolean success) {
1723                    if (success) {
1724                        try {
1725                            ActivityManagerNative.getDefault().stopAppSwitches();
1726                        } catch (RemoteException e) {
1727                        }
1728                        sendCloseSystemWindows(SYSTEM_DIALOG_REASON_HOME_KEY);
1729                        startDockOrHome();
1730                    }
1731                }
1732            });
1733        } else {
1734            // no keyguard stuff to worry about, just launch home!
1735            try {
1736                ActivityManagerNative.getDefault().stopAppSwitches();
1737            } catch (RemoteException e) {
1738            }
1739            sendCloseSystemWindows(SYSTEM_DIALOG_REASON_HOME_KEY);
1740            startDockOrHome();
1741        }
1742    }
1743
1744    /**
1745     * A delayed callback use to determine when it is okay to re-allow applications
1746     * to use certain system UI flags.  This is used to prevent applications from
1747     * spamming system UI changes that prevent the navigation bar from being shown.
1748     */
1749    final Runnable mAllowSystemUiDelay = new Runnable() {
1750        @Override public void run() {
1751        }
1752    };
1753
1754    /**
1755     * Input handler used while nav bar is hidden.  Captures any touch on the screen,
1756     * to determine when the nav bar should be shown and prevent applications from
1757     * receiving those touches.
1758     */
1759    final InputHandler mHideNavInputHandler = new BaseInputHandler() {
1760        @Override
1761        public void handleMotion(MotionEvent event, InputQueue.FinishedCallback finishedCallback) {
1762            boolean handled = false;
1763            try {
1764                if ((event.getSource() & InputDevice.SOURCE_CLASS_POINTER) != 0) {
1765                    if (event.getAction() == MotionEvent.ACTION_DOWN) {
1766                        // When the user taps down, we re-show the nav bar.
1767                        boolean changed = false;
1768                        synchronized (mLock) {
1769                            // Any user activity always causes us to show the navigation controls,
1770                            // if they had been hidden.
1771                            int newVal = mResettingSystemUiFlags
1772                                    | View.SYSTEM_UI_FLAG_HIDE_NAVIGATION;
1773                            if (mResettingSystemUiFlags != newVal) {
1774                                mResettingSystemUiFlags = newVal;
1775                                changed = true;
1776                            }
1777                            // We don't allow the system's nav bar to be hidden
1778                            // again for 1 second, to prevent applications from
1779                            // spamming us and keeping it from being shown.
1780                            newVal = mForceClearedSystemUiFlags
1781                                    | View.SYSTEM_UI_FLAG_HIDE_NAVIGATION;
1782                            if (mForceClearedSystemUiFlags != newVal) {
1783                                mForceClearedSystemUiFlags = newVal;
1784                                changed = true;
1785                                mHandler.postDelayed(new Runnable() {
1786                                    @Override public void run() {
1787                                        synchronized (mLock) {
1788                                            mForceClearedSystemUiFlags &=
1789                                                    ~View.SYSTEM_UI_FLAG_HIDE_NAVIGATION;
1790                                        }
1791                                        mWindowManagerFuncs.reevaluateStatusBarVisibility();
1792                                    }
1793                                }, 1000);
1794                            }
1795                        }
1796                        if (changed) {
1797                            mWindowManagerFuncs.reevaluateStatusBarVisibility();
1798                        }
1799                    }
1800                }
1801            } finally {
1802                finishedCallback.finished(handled);
1803            }
1804        }
1805    };
1806
1807    @Override
1808    public int adjustSystemUiVisibilityLw(int visibility) {
1809        // Reset any bits in mForceClearingStatusBarVisibility that
1810        // are now clear.
1811        mResettingSystemUiFlags &= visibility;
1812        // Clear any bits in the new visibility that are currently being
1813        // force cleared, before reporting it.
1814        return visibility & ~mResettingSystemUiFlags
1815                & ~mForceClearedSystemUiFlags;
1816    }
1817
1818    public void getContentInsetHintLw(WindowManager.LayoutParams attrs, Rect contentInset) {
1819        final int fl = attrs.flags;
1820
1821        if ((fl & (FLAG_LAYOUT_IN_SCREEN | FLAG_FULLSCREEN | FLAG_LAYOUT_INSET_DECOR))
1822                == (FLAG_LAYOUT_IN_SCREEN | FLAG_LAYOUT_INSET_DECOR)) {
1823            contentInset.set(mCurLeft, mCurTop,
1824                    (mRestrictedScreenLeft+mRestrictedScreenWidth) - mCurRight,
1825                    (mRestrictedScreenTop+mRestrictedScreenHeight) - mCurBottom);
1826        } else {
1827            contentInset.setEmpty();
1828        }
1829    }
1830
1831    /** {@inheritDoc} */
1832    public void beginLayoutLw(int displayWidth, int displayHeight, int displayRotation) {
1833        mUnrestrictedScreenLeft = mUnrestrictedScreenTop = 0;
1834        mUnrestrictedScreenWidth = displayWidth;
1835        mUnrestrictedScreenHeight = displayHeight;
1836        mRestrictedScreenLeft = mRestrictedScreenTop = 0;
1837        mRestrictedScreenWidth = displayWidth;
1838        mRestrictedScreenHeight = displayHeight;
1839        mDockLeft = mContentLeft = mCurLeft = 0;
1840        mDockTop = mContentTop = mCurTop = 0;
1841        mDockRight = mContentRight = mCurRight = displayWidth;
1842        mDockBottom = mContentBottom = mCurBottom = displayHeight;
1843        mDockLayer = 0x10000000;
1844
1845        // start with the current dock rect, which will be (0,0,displayWidth,displayHeight)
1846        final Rect pf = mTmpParentFrame;
1847        final Rect df = mTmpDisplayFrame;
1848        final Rect vf = mTmpVisibleFrame;
1849        pf.left = df.left = vf.left = mDockLeft;
1850        pf.top = df.top = vf.top = mDockTop;
1851        pf.right = df.right = vf.right = mDockRight;
1852        pf.bottom = df.bottom = vf.bottom = mDockBottom;
1853
1854        final boolean navVisible = (mNavigationBar == null || mNavigationBar.isVisibleLw()) &&
1855                (mLastSystemUiFlags&View.SYSTEM_UI_FLAG_HIDE_NAVIGATION) == 0;
1856
1857        // When the navigation bar isn't visible, we put up a fake
1858        // input window to catch all touch events.  This way we can
1859        // detect when the user presses anywhere to bring back the nav
1860        // bar and ensure the application doesn't see the event.
1861        if (navVisible) {
1862            if (mHideNavFakeWindow != null) {
1863                mHideNavFakeWindow.dismiss();
1864                mHideNavFakeWindow = null;
1865            }
1866        } else if (mHideNavFakeWindow == null) {
1867            mHideNavFakeWindow = mWindowManagerFuncs.addFakeWindow(
1868                    mHandler.getLooper(), mHideNavInputHandler,
1869                    "hidden nav", WindowManager.LayoutParams.TYPE_HIDDEN_NAV_CONSUMER,
1870                    0, false, false, true);
1871        }
1872
1873        // decide where the status bar goes ahead of time
1874        if (mStatusBar != null) {
1875            if (mNavigationBar != null) {
1876                // Force the navigation bar to its appropriate place and
1877                // size.  We need to do this directly, instead of relying on
1878                // it to bubble up from the nav bar, because this needs to
1879                // change atomically with screen rotations.
1880                if (displayWidth < displayHeight) {
1881                    // Portrait screen; nav bar goes on bottom.
1882                    mTmpNavigationFrame.set(0, displayHeight-mNavigationBarHeight,
1883                            displayWidth, displayHeight);
1884                    if (navVisible) {
1885                        mDockBottom = mTmpNavigationFrame.top;
1886                        mRestrictedScreenHeight = mDockBottom - mDockTop;
1887                    } else {
1888                        // We currently want to hide the navigation UI.  Do this by just
1889                        // moving it off the screen, so it can still receive input events
1890                        // to know when to be re-shown.
1891                        mTmpNavigationFrame.offset(0, mNavigationBarHeight);
1892                    }
1893                } else {
1894                    // Landscape screen; nav bar goes to the right.
1895                    mTmpNavigationFrame.set(displayWidth-mNavigationBarWidth, 0,
1896                            displayWidth, displayHeight);
1897                    if (navVisible) {
1898                        mDockRight = mTmpNavigationFrame.left;
1899                        mRestrictedScreenWidth = mDockRight - mDockLeft;
1900                    } else {
1901                        // We currently want to hide the navigation UI.  Do this by just
1902                        // moving it off the screen, so it can still receive input events
1903                        // to know when to be re-shown.
1904                        mTmpNavigationFrame.offset(mNavigationBarWidth, 0);
1905                    }
1906                }
1907                // And compute the final frame.
1908                mNavigationBar.computeFrameLw(mTmpNavigationFrame, mTmpNavigationFrame,
1909                        mTmpNavigationFrame, mTmpNavigationFrame);
1910                if (DEBUG_LAYOUT) Log.i(TAG, "mNavigationBar frame: " + mTmpNavigationFrame);
1911            }
1912            if (DEBUG_LAYOUT) Log.i(TAG, String.format("mDock rect: (%d,%d - %d,%d)",
1913                    mDockLeft, mDockTop, mDockRight, mDockBottom));
1914
1915            // apply navigation bar insets
1916            pf.left = df.left = vf.left = mDockLeft;
1917            pf.top = df.top = vf.top = mDockTop;
1918            pf.right = df.right = vf.right = mDockRight;
1919            pf.bottom = df.bottom = vf.bottom = mDockBottom;
1920
1921            mStatusBar.computeFrameLw(pf, df, vf, vf);
1922
1923            if (mStatusBar.isVisibleLw()) {
1924                // If the status bar is hidden, we don't want to cause
1925                // windows behind it to scroll.
1926                final Rect r = mStatusBar.getFrameLw();
1927                if (mStatusBarCanHide) {
1928                    // Status bar may go away, so the screen area it occupies
1929                    // is available to apps but just covering them when the
1930                    // status bar is visible.
1931                    if (mDockTop == r.top) mDockTop = r.bottom;
1932                    else if (mDockBottom == r.bottom) mDockBottom = r.top;
1933
1934                    mContentTop = mCurTop = mDockTop;
1935                    mContentBottom = mCurBottom = mDockBottom;
1936                    mContentLeft = mCurLeft = mDockLeft;
1937                    mContentRight = mCurRight = mDockRight;
1938
1939                    if (DEBUG_LAYOUT) Log.v(TAG, "Status bar: " +
1940                        String.format(
1941                            "dock=[%d,%d][%d,%d] content=[%d,%d][%d,%d] cur=[%d,%d][%d,%d]",
1942                            mDockLeft, mDockTop, mDockRight, mDockBottom,
1943                            mContentLeft, mContentTop, mContentRight, mContentBottom,
1944                            mCurLeft, mCurTop, mCurRight, mCurBottom));
1945                } else {
1946                    // Status bar can't go away; the part of the screen it
1947                    // covers does not exist for anything behind it.
1948                    if (mRestrictedScreenTop == r.top) {
1949                        mRestrictedScreenTop = r.bottom;
1950                        mRestrictedScreenHeight -= (r.bottom-r.top);
1951                    } else if ((mRestrictedScreenHeight-mRestrictedScreenTop) == r.bottom) {
1952                        mRestrictedScreenHeight -= (r.bottom-r.top);
1953                    }
1954
1955                    mContentTop = mCurTop = mDockTop = mRestrictedScreenTop;
1956                    mContentBottom = mCurBottom = mDockBottom
1957                            = mRestrictedScreenTop + mRestrictedScreenHeight;
1958                    if (DEBUG_LAYOUT) Log.v(TAG, "Status bar: restricted screen area: ("
1959                            + mRestrictedScreenLeft + ","
1960                            + mRestrictedScreenTop + ","
1961                            + (mRestrictedScreenLeft + mRestrictedScreenWidth) + ","
1962                            + (mRestrictedScreenTop + mRestrictedScreenHeight) + ")");
1963                }
1964            }
1965        }
1966    }
1967
1968    void setAttachedWindowFrames(WindowState win, int fl, int adjust,
1969            WindowState attached, boolean insetDecors, Rect pf, Rect df, Rect cf, Rect vf) {
1970        if (win.getSurfaceLayer() > mDockLayer && attached.getSurfaceLayer() < mDockLayer) {
1971            // Here's a special case: if this attached window is a panel that is
1972            // above the dock window, and the window it is attached to is below
1973            // the dock window, then the frames we computed for the window it is
1974            // attached to can not be used because the dock is effectively part
1975            // of the underlying window and the attached window is floating on top
1976            // of the whole thing.  So, we ignore the attached window and explicitly
1977            // compute the frames that would be appropriate without the dock.
1978            df.left = cf.left = vf.left = mDockLeft;
1979            df.top = cf.top = vf.top = mDockTop;
1980            df.right = cf.right = vf.right = mDockRight;
1981            df.bottom = cf.bottom = vf.bottom = mDockBottom;
1982        } else {
1983            // The effective display frame of the attached window depends on
1984            // whether it is taking care of insetting its content.  If not,
1985            // we need to use the parent's content frame so that the entire
1986            // window is positioned within that content.  Otherwise we can use
1987            // the display frame and let the attached window take care of
1988            // positioning its content appropriately.
1989            if (adjust != SOFT_INPUT_ADJUST_RESIZE) {
1990                cf.set(attached.getDisplayFrameLw());
1991            } else {
1992                // If the window is resizing, then we want to base the content
1993                // frame on our attached content frame to resize...  however,
1994                // things can be tricky if the attached window is NOT in resize
1995                // mode, in which case its content frame will be larger.
1996                // Ungh.  So to deal with that, make sure the content frame
1997                // we end up using is not covering the IM dock.
1998                cf.set(attached.getContentFrameLw());
1999                if (attached.getSurfaceLayer() < mDockLayer) {
2000                    if (cf.left < mContentLeft) cf.left = mContentLeft;
2001                    if (cf.top < mContentTop) cf.top = mContentTop;
2002                    if (cf.right > mContentRight) cf.right = mContentRight;
2003                    if (cf.bottom > mContentBottom) cf.bottom = mContentBottom;
2004                }
2005            }
2006            df.set(insetDecors ? attached.getDisplayFrameLw() : cf);
2007            vf.set(attached.getVisibleFrameLw());
2008        }
2009        // The LAYOUT_IN_SCREEN flag is used to determine whether the attached
2010        // window should be positioned relative to its parent or the entire
2011        // screen.
2012        pf.set((fl & FLAG_LAYOUT_IN_SCREEN) == 0
2013                ? attached.getFrameLw() : df);
2014    }
2015
2016    /** {@inheritDoc} */
2017    public void layoutWindowLw(WindowState win, WindowManager.LayoutParams attrs,
2018            WindowState attached) {
2019        // we've already done the status bar
2020        if (win == mStatusBar || win == mNavigationBar) {
2021            return;
2022        }
2023
2024        final int fl = attrs.flags;
2025        final int sim = attrs.softInputMode;
2026
2027        final Rect pf = mTmpParentFrame;
2028        final Rect df = mTmpDisplayFrame;
2029        final Rect cf = mTmpContentFrame;
2030        final Rect vf = mTmpVisibleFrame;
2031
2032        final boolean hasNavBar = (mHasNavigationBar
2033                && mNavigationBar != null && mNavigationBar.isVisibleLw());
2034
2035        if (attrs.type == TYPE_INPUT_METHOD) {
2036            pf.left = df.left = cf.left = vf.left = mDockLeft;
2037            pf.top = df.top = cf.top = vf.top = mDockTop;
2038            pf.right = df.right = cf.right = vf.right = mDockRight;
2039            pf.bottom = df.bottom = cf.bottom = vf.bottom = mDockBottom;
2040            // IM dock windows always go to the bottom of the screen.
2041            attrs.gravity = Gravity.BOTTOM;
2042            mDockLayer = win.getSurfaceLayer();
2043        } else {
2044            final int adjust = sim & SOFT_INPUT_MASK_ADJUST;
2045
2046            if ((fl & (FLAG_LAYOUT_IN_SCREEN | FLAG_FULLSCREEN | FLAG_LAYOUT_INSET_DECOR))
2047                    == (FLAG_LAYOUT_IN_SCREEN | FLAG_LAYOUT_INSET_DECOR)) {
2048                if (DEBUG_LAYOUT)
2049                    Log.v(TAG, "layoutWindowLw(" + attrs.getTitle()
2050                            + "): IN_SCREEN, INSET_DECOR, !FULLSCREEN");
2051                // This is the case for a normal activity window: we want it
2052                // to cover all of the screen space, and it can take care of
2053                // moving its contents to account for screen decorations that
2054                // intrude into that space.
2055                if (attached != null) {
2056                    // If this window is attached to another, our display
2057                    // frame is the same as the one we are attached to.
2058                    setAttachedWindowFrames(win, fl, sim, attached, true, pf, df, cf, vf);
2059                } else {
2060                    if (attrs.type == TYPE_STATUS_BAR_PANEL
2061                            || attrs.type == TYPE_STATUS_BAR_SUB_PANEL) {
2062                        // Status bar panels are the only windows who can go on top of
2063                        // the status bar.  They are protected by the STATUS_BAR_SERVICE
2064                        // permission, so they have the same privileges as the status
2065                        // bar itself.
2066                        //
2067                        // However, they should still dodge the navigation bar if it exists.
2068
2069                        pf.left = df.left = hasNavBar ? mDockLeft : mUnrestrictedScreenLeft;
2070                        pf.top = df.top = mUnrestrictedScreenTop;
2071                        pf.right = df.right = hasNavBar
2072                                            ? mRestrictedScreenLeft+mRestrictedScreenWidth
2073                                            : mUnrestrictedScreenLeft+mUnrestrictedScreenWidth;
2074                        pf.bottom = df.bottom = hasNavBar
2075                                              ? mRestrictedScreenTop+mRestrictedScreenHeight
2076                                              : mUnrestrictedScreenTop+mUnrestrictedScreenHeight;
2077
2078                        if (DEBUG_LAYOUT) {
2079                            Log.v(TAG, String.format(
2080                                        "Laying out status bar window: (%d,%d - %d,%d)",
2081                                        pf.left, pf.top, pf.right, pf.bottom));
2082                        }
2083                    } else {
2084                        pf.left = df.left = mRestrictedScreenLeft;
2085                        pf.top = df.top = mRestrictedScreenTop;
2086                        pf.right = df.right = mRestrictedScreenLeft+mRestrictedScreenWidth;
2087                        pf.bottom = df.bottom = mRestrictedScreenTop+mRestrictedScreenHeight;
2088                    }
2089                    if (adjust != SOFT_INPUT_ADJUST_RESIZE) {
2090                        cf.left = mDockLeft;
2091                        cf.top = mDockTop;
2092                        cf.right = mDockRight;
2093                        cf.bottom = mDockBottom;
2094                    } else {
2095                        cf.left = mContentLeft;
2096                        cf.top = mContentTop;
2097                        cf.right = mContentRight;
2098                        cf.bottom = mContentBottom;
2099                    }
2100                    if (adjust != SOFT_INPUT_ADJUST_NOTHING) {
2101                        vf.left = mCurLeft;
2102                        vf.top = mCurTop;
2103                        vf.right = mCurRight;
2104                        vf.bottom = mCurBottom;
2105                    } else {
2106                        vf.set(cf);
2107                    }
2108                }
2109            } else if ((fl & FLAG_LAYOUT_IN_SCREEN) != 0) {
2110                if (DEBUG_LAYOUT)
2111                    Log.v(TAG, "layoutWindowLw(" + attrs.getTitle() + "): IN_SCREEN");
2112                // A window that has requested to fill the entire screen just
2113                // gets everything, period.
2114                if (attrs.type == TYPE_STATUS_BAR_PANEL
2115                        || attrs.type == TYPE_STATUS_BAR_SUB_PANEL) {
2116                    pf.left = df.left = cf.left = hasNavBar ? mDockLeft : mUnrestrictedScreenLeft;
2117                    pf.top = df.top = cf.top = mUnrestrictedScreenTop;
2118                    pf.right = df.right = cf.right = hasNavBar
2119                                        ? mRestrictedScreenLeft+mRestrictedScreenWidth
2120                                        : mUnrestrictedScreenLeft+mUnrestrictedScreenWidth;
2121                    pf.bottom = df.bottom = cf.bottom = hasNavBar
2122                                          ? mRestrictedScreenTop+mRestrictedScreenHeight
2123                                          : mUnrestrictedScreenTop+mUnrestrictedScreenHeight;
2124
2125                    if (DEBUG_LAYOUT) {
2126                        Log.v(TAG, String.format(
2127                                    "Laying out IN_SCREEN status bar window: (%d,%d - %d,%d)",
2128                                    pf.left, pf.top, pf.right, pf.bottom));
2129                    }
2130                } else if (attrs.type == TYPE_NAVIGATION_BAR) {
2131                    // The navigation bar has Real Ultimate Power.
2132                    pf.left = df.left = mUnrestrictedScreenLeft;
2133                    pf.top = df.top = mUnrestrictedScreenTop;
2134                    pf.right = df.right = mUnrestrictedScreenLeft+mUnrestrictedScreenWidth;
2135                    pf.bottom = df.bottom = mUnrestrictedScreenTop+mUnrestrictedScreenHeight;
2136                    if (DEBUG_LAYOUT) {
2137                        Log.v(TAG, String.format(
2138                                    "Laying out navigation bar window: (%d,%d - %d,%d)",
2139                                    pf.left, pf.top, pf.right, pf.bottom));
2140                    }
2141                } else if (attrs.type == TYPE_SECURE_SYSTEM_OVERLAY
2142                        && ((fl & FLAG_FULLSCREEN) != 0)) {
2143                    // Fullscreen secure system overlays get what they ask for.
2144                    pf.left = df.left = mUnrestrictedScreenLeft;
2145                    pf.top = df.top = mUnrestrictedScreenTop;
2146                    pf.right = df.right = mUnrestrictedScreenLeft+mUnrestrictedScreenWidth;
2147                    pf.bottom = df.bottom = mUnrestrictedScreenTop+mUnrestrictedScreenHeight;
2148                } else {
2149                    pf.left = df.left = cf.left = mRestrictedScreenLeft;
2150                    pf.top = df.top = cf.top = mRestrictedScreenTop;
2151                    pf.right = df.right = cf.right = mRestrictedScreenLeft+mRestrictedScreenWidth;
2152                    pf.bottom = df.bottom = cf.bottom
2153                            = mRestrictedScreenTop+mRestrictedScreenHeight;
2154                }
2155                if (adjust != SOFT_INPUT_ADJUST_NOTHING) {
2156                    vf.left = mCurLeft;
2157                    vf.top = mCurTop;
2158                    vf.right = mCurRight;
2159                    vf.bottom = mCurBottom;
2160                } else {
2161                    vf.set(cf);
2162                }
2163            } else if (attached != null) {
2164                if (DEBUG_LAYOUT)
2165                    Log.v(TAG, "layoutWindowLw(" + attrs.getTitle() + "): attached to " + attached);
2166                // A child window should be placed inside of the same visible
2167                // frame that its parent had.
2168                setAttachedWindowFrames(win, fl, adjust, attached, false, pf, df, cf, vf);
2169            } else {
2170                if (DEBUG_LAYOUT)
2171                    Log.v(TAG, "layoutWindowLw(" + attrs.getTitle() + "): normal window");
2172                // Otherwise, a normal window must be placed inside the content
2173                // of all screen decorations.
2174                if (attrs.type == TYPE_STATUS_BAR_PANEL) {
2175                    // Status bar panels are the only windows who can go on top of
2176                    // the status bar.  They are protected by the STATUS_BAR_SERVICE
2177                    // permission, so they have the same privileges as the status
2178                    // bar itself.
2179                    pf.left = df.left = cf.left = mRestrictedScreenLeft;
2180                    pf.top = df.top = cf.top = mRestrictedScreenTop;
2181                    pf.right = df.right = cf.right = mRestrictedScreenLeft+mRestrictedScreenWidth;
2182                    pf.bottom = df.bottom = cf.bottom
2183                            = mRestrictedScreenTop+mRestrictedScreenHeight;
2184                } else {
2185                    pf.left = mContentLeft;
2186                    pf.top = mContentTop;
2187                    pf.right = mContentRight;
2188                    pf.bottom = mContentBottom;
2189                    if (adjust != SOFT_INPUT_ADJUST_RESIZE) {
2190                        df.left = cf.left = mDockLeft;
2191                        df.top = cf.top = mDockTop;
2192                        df.right = cf.right = mDockRight;
2193                        df.bottom = cf.bottom = mDockBottom;
2194                    } else {
2195                        df.left = cf.left = mContentLeft;
2196                        df.top = cf.top = mContentTop;
2197                        df.right = cf.right = mContentRight;
2198                        df.bottom = cf.bottom = mContentBottom;
2199                    }
2200                    if (adjust != SOFT_INPUT_ADJUST_NOTHING) {
2201                        vf.left = mCurLeft;
2202                        vf.top = mCurTop;
2203                        vf.right = mCurRight;
2204                        vf.bottom = mCurBottom;
2205                    } else {
2206                        vf.set(cf);
2207                    }
2208                }
2209            }
2210        }
2211
2212        if ((fl & FLAG_LAYOUT_NO_LIMITS) != 0) {
2213            df.left = df.top = cf.left = cf.top = vf.left = vf.top = -10000;
2214            df.right = df.bottom = cf.right = cf.bottom = vf.right = vf.bottom = 10000;
2215        }
2216
2217        if (DEBUG_LAYOUT) Log.v(TAG, "Compute frame " + attrs.getTitle()
2218                + ": sim=#" + Integer.toHexString(sim)
2219                + " attach=" + attached + " type=" + attrs.type
2220                + String.format(" flags=0x%08x", fl)
2221                + " pf=" + pf.toShortString() + " df=" + df.toShortString()
2222                + " cf=" + cf.toShortString() + " vf=" + vf.toShortString());
2223
2224        win.computeFrameLw(pf, df, cf, vf);
2225
2226        // Dock windows carve out the bottom of the screen, so normal windows
2227        // can't appear underneath them.
2228        if (attrs.type == TYPE_INPUT_METHOD && !win.getGivenInsetsPendingLw()) {
2229            int top = win.getContentFrameLw().top;
2230            top += win.getGivenContentInsetsLw().top;
2231            if (mContentBottom > top) {
2232                mContentBottom = top;
2233            }
2234            top = win.getVisibleFrameLw().top;
2235            top += win.getGivenVisibleInsetsLw().top;
2236            if (mCurBottom > top) {
2237                mCurBottom = top;
2238            }
2239            if (DEBUG_LAYOUT) Log.v(TAG, "Input method: mDockBottom="
2240                    + mDockBottom + " mContentBottom="
2241                    + mContentBottom + " mCurBottom=" + mCurBottom);
2242        }
2243    }
2244
2245    /** {@inheritDoc} */
2246    public int finishLayoutLw() {
2247        return 0;
2248    }
2249
2250    /** {@inheritDoc} */
2251    public void beginAnimationLw(int displayWidth, int displayHeight) {
2252        mTopFullscreenOpaqueWindowState = null;
2253        mTopAppWindowState = null;
2254        mForceStatusBar = false;
2255
2256        mHideLockScreen = false;
2257        mAllowLockscreenWhenOn = false;
2258        mDismissKeyguard = false;
2259    }
2260
2261    /** {@inheritDoc} */
2262    public void animatingWindowLw(WindowState win,
2263                                WindowManager.LayoutParams attrs) {
2264        if (DEBUG_LAYOUT) Slog.i(TAG, "Win " + win + ": isVisibleOrBehindKeyguardLw="
2265                + win.isVisibleOrBehindKeyguardLw());
2266        if (mTopFullscreenOpaqueWindowState == null &&
2267                win.isVisibleOrBehindKeyguardLw()) {
2268            if ((attrs.flags & FLAG_FORCE_NOT_FULLSCREEN) != 0) {
2269                mForceStatusBar = true;
2270            }
2271            if (attrs.type >= FIRST_APPLICATION_WINDOW
2272                    && attrs.type <= LAST_APPLICATION_WINDOW
2273                    && attrs.x == 0 && attrs.y == 0
2274                    && attrs.width == WindowManager.LayoutParams.MATCH_PARENT
2275                    && attrs.height == WindowManager.LayoutParams.MATCH_PARENT) {
2276                if (DEBUG_LAYOUT) Log.v(TAG, "Fullscreen window: " + win);
2277                mTopFullscreenOpaqueWindowState = win;
2278                if ((attrs.flags & FLAG_SHOW_WHEN_LOCKED) != 0) {
2279                    if (localLOGV) Log.v(TAG, "Setting mHideLockScreen to true by win " + win);
2280                    mHideLockScreen = true;
2281                }
2282                if ((attrs.flags & FLAG_DISMISS_KEYGUARD) != 0) {
2283                    if (localLOGV) Log.v(TAG, "Setting mDismissKeyguard to true by win " + win);
2284                    mDismissKeyguard = true;
2285                }
2286                if ((attrs.flags & FLAG_ALLOW_LOCK_WHILE_SCREEN_ON) != 0) {
2287                    mAllowLockscreenWhenOn = true;
2288                }
2289            }
2290        }
2291        if (mTopAppWindowState == null && win.isVisibleOrBehindKeyguardLw()) {
2292            if (attrs.type >= FIRST_APPLICATION_WINDOW
2293                    && attrs.type <= LAST_APPLICATION_WINDOW) {
2294                mTopAppWindowState = win;
2295            }
2296        }
2297    }
2298
2299    /** {@inheritDoc} */
2300    public int finishAnimationLw() {
2301        int changes = 0;
2302        boolean topIsFullscreen = false;
2303
2304        final WindowManager.LayoutParams lp = (mTopFullscreenOpaqueWindowState != null)
2305                ? mTopFullscreenOpaqueWindowState.getAttrs()
2306                : null;
2307
2308        if (mStatusBar != null) {
2309            if (DEBUG_LAYOUT) Log.i(TAG, "force=" + mForceStatusBar
2310                    + " top=" + mTopFullscreenOpaqueWindowState);
2311            if (mForceStatusBar) {
2312                if (DEBUG_LAYOUT) Log.v(TAG, "Showing status bar: forced");
2313                if (mStatusBar.showLw(true)) changes |= FINISH_LAYOUT_REDO_LAYOUT;
2314            } else if (mTopFullscreenOpaqueWindowState != null) {
2315                if (localLOGV) {
2316                    Log.d(TAG, "frame: " + mTopFullscreenOpaqueWindowState.getFrameLw()
2317                            + " shown frame: " + mTopFullscreenOpaqueWindowState.getShownFrameLw());
2318                    Log.d(TAG, "attr: " + mTopFullscreenOpaqueWindowState.getAttrs()
2319                            + " lp.flags=0x" + Integer.toHexString(lp.flags));
2320                }
2321                topIsFullscreen = (lp.flags & WindowManager.LayoutParams.FLAG_FULLSCREEN) != 0;
2322                // The subtle difference between the window for mTopFullscreenOpaqueWindowState
2323                // and mTopIsFullscreen is that that mTopIsFullscreen is set only if the window
2324                // has the FLAG_FULLSCREEN set.  Not sure if there is another way that to be the
2325                // case though.
2326                if (topIsFullscreen) {
2327                    if (mStatusBarCanHide) {
2328                        if (DEBUG_LAYOUT) Log.v(TAG, "Hiding status bar");
2329                        if (mStatusBar.hideLw(true)) {
2330                            changes |= FINISH_LAYOUT_REDO_LAYOUT;
2331
2332                            mHandler.post(new Runnable() { public void run() {
2333                                if (mStatusBarService != null) {
2334                                    try {
2335                                        mStatusBarService.collapse();
2336                                    } catch (RemoteException ex) {}
2337                                }
2338                            }});
2339                        }
2340                    } else if (DEBUG_LAYOUT) {
2341                        Log.v(TAG, "Preventing status bar from hiding by policy");
2342                    }
2343                } else {
2344                    if (DEBUG_LAYOUT) Log.v(TAG, "Showing status bar: top is not fullscreen");
2345                    if (mStatusBar.showLw(true)) changes |= FINISH_LAYOUT_REDO_LAYOUT;
2346                }
2347            }
2348        }
2349
2350        mTopIsFullscreen = topIsFullscreen;
2351
2352        if (mTopAppWindowState != null && mTopAppWindowState != mLastTopAppWindowState) {
2353            mLastTopAppWindowState = mTopAppWindowState;
2354
2355            final boolean topNeedsMenu = (mTopAppWindowState.getAttrs().flags
2356                    & WindowManager.LayoutParams.FLAG_NEEDS_MENU_KEY) != 0;
2357
2358            mHandler.post(new Runnable() {
2359                    public void run() {
2360                        if (mStatusBarService == null) {
2361                            // This is the one that can not go away, but it doesn't come up
2362                            // before the window manager does, so don't fail if it doesn't
2363                            // exist. This works as long as no fullscreen windows come up
2364                            // before the status bar service does.
2365                            mStatusBarService = IStatusBarService.Stub.asInterface(
2366                                    ServiceManager.getService("statusbar"));
2367                        }
2368                        final IStatusBarService sbs = mStatusBarService;
2369                        if (mStatusBarService != null) {
2370                            try {
2371                                sbs.topAppWindowChanged(topNeedsMenu);
2372                            } catch (RemoteException e) {
2373                                // This should be impossible because we're in the same process.
2374                                mStatusBarService = null;
2375                            }
2376                        }
2377                    }
2378                });
2379        }
2380
2381        // Hide the key guard if a visible window explicitly specifies that it wants to be displayed
2382        // when the screen is locked
2383        if (mKeyguard != null) {
2384            if (localLOGV) Log.v(TAG, "finishAnimationLw::mHideKeyguard="+mHideLockScreen);
2385            if (mDismissKeyguard && !mKeyguardMediator.isSecure()) {
2386                if (mKeyguard.hideLw(true)) {
2387                    changes |= FINISH_LAYOUT_REDO_LAYOUT
2388                            | FINISH_LAYOUT_REDO_CONFIG
2389                            | FINISH_LAYOUT_REDO_WALLPAPER;
2390                }
2391                if (mKeyguardMediator.isShowing()) {
2392                    mHandler.post(new Runnable() {
2393                        public void run() {
2394                            mKeyguardMediator.keyguardDone(false, false);
2395                        }
2396                    });
2397                }
2398            } else if (mHideLockScreen) {
2399                if (mKeyguard.hideLw(true)) {
2400                    changes |= FINISH_LAYOUT_REDO_LAYOUT
2401                            | FINISH_LAYOUT_REDO_CONFIG
2402                            | FINISH_LAYOUT_REDO_WALLPAPER;
2403                }
2404                mKeyguardMediator.setHidden(true);
2405            } else {
2406                if (mKeyguard.showLw(true)) {
2407                    changes |= FINISH_LAYOUT_REDO_LAYOUT
2408                            | FINISH_LAYOUT_REDO_CONFIG
2409                            | FINISH_LAYOUT_REDO_WALLPAPER;
2410                }
2411                mKeyguardMediator.setHidden(false);
2412            }
2413        }
2414
2415        if ((updateSystemUiVisibilityLw()&View.SYSTEM_UI_FLAG_HIDE_NAVIGATION) != 0) {
2416            // If the navigation bar has been hidden or shown, we need to do another
2417            // layout pass to update that window.
2418            changes |= FINISH_LAYOUT_REDO_LAYOUT;
2419        }
2420
2421        // update since mAllowLockscreenWhenOn might have changed
2422        updateLockScreenTimeout();
2423        return changes;
2424    }
2425
2426    public boolean allowAppAnimationsLw() {
2427        if (mKeyguard != null && mKeyguard.isVisibleLw()) {
2428            // If keyguard is currently visible, no reason to animate
2429            // behind it.
2430            return false;
2431        }
2432        if (false) {
2433            // Don't do this on the tablet, since the system bar never completely
2434            // covers the screen, and with all its transparency this will
2435            // incorrectly think it does cover it when it doesn't.  We'll revisit
2436            // this later when we re-do the phone status bar.
2437            if (mStatusBar != null && mStatusBar.isVisibleLw()) {
2438                RectF rect = new RectF(mStatusBar.getShownFrameLw());
2439                for (int i=mStatusBarPanels.size()-1; i>=0; i--) {
2440                    WindowState w = mStatusBarPanels.get(i);
2441                    if (w.isVisibleLw()) {
2442                        rect.union(w.getShownFrameLw());
2443                    }
2444                }
2445                final int insetw = mRestrictedScreenWidth/10;
2446                final int inseth = mRestrictedScreenHeight/10;
2447                if (rect.contains(insetw, inseth, mRestrictedScreenWidth-insetw,
2448                            mRestrictedScreenHeight-inseth)) {
2449                    // All of the status bar windows put together cover the
2450                    // screen, so the app can't be seen.  (Note this test doesn't
2451                    // work if the rects of these windows are at off offsets or
2452                    // sizes, causing gaps in the rect union we have computed.)
2453                    return false;
2454                }
2455            }
2456        }
2457        return true;
2458    }
2459
2460    public int focusChangedLw(WindowState lastFocus, WindowState newFocus) {
2461        mFocusedWindow = newFocus;
2462        if ((updateSystemUiVisibilityLw()&View.SYSTEM_UI_FLAG_HIDE_NAVIGATION) != 0) {
2463            // If the navigation bar has been hidden or shown, we need to do another
2464            // layout pass to update that window.
2465            return FINISH_LAYOUT_REDO_LAYOUT;
2466        }
2467        return 0;
2468    }
2469
2470    /** {@inheritDoc} */
2471    public void notifyLidSwitchChanged(long whenNanos, boolean lidOpen) {
2472        // lid changed state
2473        mLidOpen = lidOpen ? LID_OPEN : LID_CLOSED;
2474        updateKeyboardVisibility();
2475
2476        boolean awakeNow = mKeyguardMediator.doLidChangeTq(lidOpen);
2477        updateRotation(true);
2478        if (awakeNow) {
2479            // If the lid is opening and we don't have to keep the
2480            // keyguard up, then we can turn on the screen
2481            // immediately.
2482            mKeyguardMediator.pokeWakelock();
2483        } else if (keyguardIsShowingTq()) {
2484            if (lidOpen) {
2485                // If we are opening the lid and not hiding the
2486                // keyguard, then we need to have it turn on the
2487                // screen once it is shown.
2488                mKeyguardMediator.onWakeKeyWhenKeyguardShowingTq(
2489                        KeyEvent.KEYCODE_POWER);
2490            }
2491        } else {
2492            // Light up the keyboard if we are sliding up.
2493            if (lidOpen) {
2494                mPowerManager.userActivity(SystemClock.uptimeMillis(), false,
2495                        LocalPowerManager.BUTTON_EVENT);
2496            } else {
2497                mPowerManager.userActivity(SystemClock.uptimeMillis(), false,
2498                        LocalPowerManager.OTHER_EVENT);
2499            }
2500        }
2501    }
2502
2503    void setHdmiPlugged(boolean plugged) {
2504        if (mHdmiPlugged != plugged) {
2505            mHdmiPlugged = plugged;
2506            updateRotation(true);
2507            Intent intent = new Intent(ACTION_HDMI_PLUGGED);
2508            intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT);
2509            intent.putExtra(EXTRA_HDMI_PLUGGED_STATE, plugged);
2510            mContext.sendStickyBroadcast(intent);
2511        }
2512    }
2513
2514    void initializeHdmiState() {
2515        boolean plugged = false;
2516        // watch for HDMI plug messages if the hdmi switch exists
2517        if (new File("/sys/devices/virtual/switch/hdmi/state").exists()) {
2518            mHDMIObserver.startObserving("DEVPATH=/devices/virtual/switch/hdmi");
2519
2520            final String filename = "/sys/class/switch/hdmi/state";
2521            FileReader reader = null;
2522            try {
2523                reader = new FileReader(filename);
2524                char[] buf = new char[15];
2525                int n = reader.read(buf);
2526                if (n > 1) {
2527                    plugged = 0 != Integer.parseInt(new String(buf, 0, n-1));
2528                }
2529            } catch (IOException ex) {
2530                Slog.w(TAG, "Couldn't read hdmi state from " + filename + ": " + ex);
2531            } catch (NumberFormatException ex) {
2532                Slog.w(TAG, "Couldn't read hdmi state from " + filename + ": " + ex);
2533            } finally {
2534                if (reader != null) {
2535                    try {
2536                        reader.close();
2537                    } catch (IOException ex) {
2538                    }
2539                }
2540            }
2541        }
2542        // This dance forces the code in setHdmiPlugged to run.
2543        // Always do this so the sticky intent is stuck (to false) if there is no hdmi.
2544        mHdmiPlugged = !plugged;
2545        setHdmiPlugged(!mHdmiPlugged);
2546    }
2547
2548    /**
2549     * @return Whether music is being played right now.
2550     */
2551    boolean isMusicActive() {
2552        final AudioManager am = (AudioManager)mContext.getSystemService(Context.AUDIO_SERVICE);
2553        if (am == null) {
2554            Log.w(TAG, "isMusicActive: couldn't get AudioManager reference");
2555            return false;
2556        }
2557        return am.isMusicActive();
2558    }
2559
2560    /**
2561     * Tell the audio service to adjust the volume appropriate to the event.
2562     * @param keycode
2563     */
2564    void handleVolumeKey(int stream, int keycode) {
2565        IAudioService audioService = getAudioService();
2566        if (audioService == null) {
2567            return;
2568        }
2569        try {
2570            // since audio is playing, we shouldn't have to hold a wake lock
2571            // during the call, but we do it as a precaution for the rare possibility
2572            // that the music stops right before we call this
2573            // TODO: Actually handle MUTE.
2574            mBroadcastWakeLock.acquire();
2575            audioService.adjustStreamVolume(stream,
2576                keycode == KeyEvent.KEYCODE_VOLUME_UP
2577                            ? AudioManager.ADJUST_RAISE
2578                            : AudioManager.ADJUST_LOWER,
2579                    0);
2580        } catch (RemoteException e) {
2581            Log.w(TAG, "IAudioService.adjustStreamVolume() threw RemoteException " + e);
2582        } finally {
2583            mBroadcastWakeLock.release();
2584        }
2585    }
2586
2587    final Object mScreenshotLock = new Object();
2588    ServiceConnection mScreenshotConnection = null;
2589
2590    final Runnable mScreenshotTimeout = new Runnable() {
2591        @Override public void run() {
2592            synchronized (mScreenshotLock) {
2593                if (mScreenshotConnection != null) {
2594                    mContext.unbindService(mScreenshotConnection);
2595                    mScreenshotConnection = null;
2596                }
2597            }
2598        }
2599    };
2600
2601    // Assume this is called from the Handler thread.
2602    private void takeScreenshot() {
2603        synchronized (mScreenshotLock) {
2604            if (mScreenshotConnection != null) {
2605                return;
2606            }
2607            ComponentName cn = new ComponentName("com.android.systemui",
2608                    "com.android.systemui.screenshot.TakeScreenshotService");
2609            Intent intent = new Intent();
2610            intent.setComponent(cn);
2611            ServiceConnection conn = new ServiceConnection() {
2612                @Override
2613                public void onServiceConnected(ComponentName name, IBinder service) {
2614                    synchronized (mScreenshotLock) {
2615                        if (mScreenshotConnection != this) {
2616                            return;
2617                        }
2618                        Messenger messenger = new Messenger(service);
2619                        Message msg = Message.obtain(null, 1);
2620                        final ServiceConnection myConn = this;
2621                        Handler h = new Handler(mHandler.getLooper()) {
2622                            @Override
2623                            public void handleMessage(Message msg) {
2624                                synchronized (mScreenshotLock) {
2625                                    if (mScreenshotConnection == myConn) {
2626                                        mContext.unbindService(mScreenshotConnection);
2627                                        mScreenshotConnection = null;
2628                                        mHandler.removeCallbacks(mScreenshotTimeout);
2629                                    }
2630                                }
2631                            }
2632                        };
2633                        msg.replyTo = new Messenger(h);
2634                        msg.arg1 = msg.arg2 = 0;
2635                        if (mStatusBar != null && mStatusBar.isVisibleLw())
2636                            msg.arg1 = 1;
2637                        if (mNavigationBar != null && mNavigationBar.isVisibleLw())
2638                            msg.arg2 = 1;
2639                        try {
2640                            messenger.send(msg);
2641                        } catch (RemoteException e) {
2642                        }
2643                    }
2644                }
2645                @Override
2646                public void onServiceDisconnected(ComponentName name) {}
2647            };
2648            if (mContext.bindService(intent, conn, Context.BIND_AUTO_CREATE)) {
2649                mScreenshotConnection = conn;
2650                mHandler.postDelayed(mScreenshotTimeout, 10000);
2651            }
2652        }
2653    }
2654
2655    /** {@inheritDoc} */
2656    @Override
2657    public int interceptKeyBeforeQueueing(KeyEvent event, int policyFlags, boolean isScreenOn) {
2658        final boolean down = event.getAction() == KeyEvent.ACTION_DOWN;
2659        final boolean canceled = event.isCanceled();
2660        final int keyCode = event.getKeyCode();
2661
2662        final boolean isInjected = (policyFlags & WindowManagerPolicy.FLAG_INJECTED) != 0;
2663
2664        // If screen is off then we treat the case where the keyguard is open but hidden
2665        // the same as if it were open and in front.
2666        // This will prevent any keys other than the power button from waking the screen
2667        // when the keyguard is hidden by another activity.
2668        final boolean keyguardActive = (isScreenOn ?
2669                                        mKeyguardMediator.isShowingAndNotHidden() :
2670                                        mKeyguardMediator.isShowing());
2671
2672        if (!mSystemBooted) {
2673            // If we have not yet booted, don't let key events do anything.
2674            return 0;
2675        }
2676
2677        if (false) {
2678            Log.d(TAG, "interceptKeyTq keycode=" + keyCode
2679                  + " screenIsOn=" + isScreenOn + " keyguardActive=" + keyguardActive);
2680        }
2681
2682        if (down && (policyFlags & WindowManagerPolicy.FLAG_VIRTUAL) != 0
2683                && event.getRepeatCount() == 0) {
2684            performHapticFeedbackLw(null, HapticFeedbackConstants.VIRTUAL_KEY, false);
2685        }
2686
2687        // Basic policy based on screen state and keyguard.
2688        // FIXME: This policy isn't quite correct.  We shouldn't care whether the screen
2689        //        is on or off, really.  We should care about whether the device is in an
2690        //        interactive state or is in suspend pretending to be "off".
2691        //        The primary screen might be turned off due to proximity sensor or
2692        //        because we are presenting media on an auxiliary screen or remotely controlling
2693        //        the device some other way (which is why we have an exemption here for injected
2694        //        events).
2695        int result;
2696        if (isScreenOn || isInjected) {
2697            // When the screen is on or if the key is injected pass the key to the application.
2698            result = ACTION_PASS_TO_USER;
2699        } else {
2700            // When the screen is off and the key is not injected, determine whether
2701            // to wake the device but don't pass the key to the application.
2702            result = 0;
2703
2704            final boolean isWakeKey = (policyFlags
2705                    & (WindowManagerPolicy.FLAG_WAKE | WindowManagerPolicy.FLAG_WAKE_DROPPED)) != 0;
2706            if (down && isWakeKey) {
2707                if (keyguardActive) {
2708                    // If the keyguard is showing, let it decide what to do with the wake key.
2709                    mKeyguardMediator.onWakeKeyWhenKeyguardShowingTq(keyCode);
2710                } else {
2711                    // Otherwise, wake the device ourselves.
2712                    result |= ACTION_POKE_USER_ACTIVITY;
2713                }
2714            }
2715        }
2716
2717        // Handle special keys.
2718        switch (keyCode) {
2719            case KeyEvent.KEYCODE_VOLUME_DOWN:
2720            case KeyEvent.KEYCODE_VOLUME_UP:
2721            case KeyEvent.KEYCODE_VOLUME_MUTE: {
2722                if (keyCode == KeyEvent.KEYCODE_VOLUME_DOWN) {
2723                    if (down) {
2724                        if (isScreenOn && !mVolumeDownKeyTriggered
2725                                && (event.getFlags() & KeyEvent.FLAG_FALLBACK) == 0) {
2726                            mVolumeDownKeyTriggered = true;
2727                            mVolumeDownKeyTime = event.getDownTime();
2728                            mVolumeDownKeyConsumedByScreenshotChord = false;
2729                            cancelPendingPowerKeyAction();
2730                            interceptScreenshotChord();
2731                        }
2732                    } else {
2733                        mVolumeDownKeyTriggered = false;
2734                        cancelPendingScreenshotChordAction();
2735                    }
2736                } else if (keyCode == KeyEvent.KEYCODE_VOLUME_UP) {
2737                    if (down) {
2738                        if (isScreenOn && !mVolumeUpKeyTriggered
2739                                && (event.getFlags() & KeyEvent.FLAG_FALLBACK) == 0) {
2740                            mVolumeUpKeyTriggered = true;
2741                            cancelPendingPowerKeyAction();
2742                            cancelPendingScreenshotChordAction();
2743                        }
2744                    } else {
2745                        mVolumeUpKeyTriggered = false;
2746                        cancelPendingScreenshotChordAction();
2747                    }
2748                }
2749                if (down) {
2750                    ITelephony telephonyService = getTelephonyService();
2751                    if (telephonyService != null) {
2752                        try {
2753                            if (telephonyService.isRinging()) {
2754                                // If an incoming call is ringing, either VOLUME key means
2755                                // "silence ringer".  We handle these keys here, rather than
2756                                // in the InCallScreen, to make sure we'll respond to them
2757                                // even if the InCallScreen hasn't come to the foreground yet.
2758                                // Look for the DOWN event here, to agree with the "fallback"
2759                                // behavior in the InCallScreen.
2760                                Log.i(TAG, "interceptKeyBeforeQueueing:"
2761                                      + " VOLUME key-down while ringing: Silence ringer!");
2762
2763                                // Silence the ringer.  (It's safe to call this
2764                                // even if the ringer has already been silenced.)
2765                                telephonyService.silenceRinger();
2766
2767                                // And *don't* pass this key thru to the current activity
2768                                // (which is probably the InCallScreen.)
2769                                result &= ~ACTION_PASS_TO_USER;
2770                                break;
2771                            }
2772                            if (telephonyService.isOffhook()
2773                                    && (result & ACTION_PASS_TO_USER) == 0) {
2774                                // If we are in call but we decided not to pass the key to
2775                                // the application, handle the volume change here.
2776                                handleVolumeKey(AudioManager.STREAM_VOICE_CALL, keyCode);
2777                                break;
2778                            }
2779                        } catch (RemoteException ex) {
2780                            Log.w(TAG, "ITelephony threw RemoteException", ex);
2781                        }
2782                    }
2783
2784                    if (isMusicActive() && (result & ACTION_PASS_TO_USER) == 0) {
2785                        // If music is playing but we decided not to pass the key to the
2786                        // application, handle the volume change here.
2787                        handleVolumeKey(AudioManager.STREAM_MUSIC, keyCode);
2788                        break;
2789                    }
2790                }
2791                break;
2792            }
2793
2794            case KeyEvent.KEYCODE_ENDCALL: {
2795                result &= ~ACTION_PASS_TO_USER;
2796                if (down) {
2797                    ITelephony telephonyService = getTelephonyService();
2798                    boolean hungUp = false;
2799                    if (telephonyService != null) {
2800                        try {
2801                            hungUp = telephonyService.endCall();
2802                        } catch (RemoteException ex) {
2803                            Log.w(TAG, "ITelephony threw RemoteException", ex);
2804                        }
2805                    }
2806                    interceptPowerKeyDown(!isScreenOn || hungUp);
2807                } else {
2808                    if (interceptPowerKeyUp(canceled)) {
2809                        if ((mEndcallBehavior
2810                                & Settings.System.END_BUTTON_BEHAVIOR_HOME) != 0) {
2811                            if (goHome()) {
2812                                break;
2813                            }
2814                        }
2815                        if ((mEndcallBehavior
2816                                & Settings.System.END_BUTTON_BEHAVIOR_SLEEP) != 0) {
2817                            result = (result & ~ACTION_POKE_USER_ACTIVITY) | ACTION_GO_TO_SLEEP;
2818                        }
2819                    }
2820                }
2821                break;
2822            }
2823
2824            case KeyEvent.KEYCODE_POWER: {
2825                result &= ~ACTION_PASS_TO_USER;
2826                if (down) {
2827                    if (isScreenOn && !mPowerKeyTriggered
2828                            && (event.getFlags() & KeyEvent.FLAG_FALLBACK) == 0) {
2829                        mPowerKeyTriggered = true;
2830                        mPowerKeyTime = event.getDownTime();
2831                        interceptScreenshotChord();
2832                    }
2833
2834                    ITelephony telephonyService = getTelephonyService();
2835                    boolean hungUp = false;
2836                    if (telephonyService != null) {
2837                        try {
2838                            if (telephonyService.isRinging()) {
2839                                // Pressing Power while there's a ringing incoming
2840                                // call should silence the ringer.
2841                                telephonyService.silenceRinger();
2842                            } else if ((mIncallPowerBehavior
2843                                    & Settings.Secure.INCALL_POWER_BUTTON_BEHAVIOR_HANGUP) != 0
2844                                    && telephonyService.isOffhook()) {
2845                                // Otherwise, if "Power button ends call" is enabled,
2846                                // the Power button will hang up any current active call.
2847                                hungUp = telephonyService.endCall();
2848                            }
2849                        } catch (RemoteException ex) {
2850                            Log.w(TAG, "ITelephony threw RemoteException", ex);
2851                        }
2852                    }
2853                    interceptPowerKeyDown(!isScreenOn || hungUp
2854                            || mVolumeDownKeyTriggered || mVolumeUpKeyTriggered);
2855                } else {
2856                    mPowerKeyTriggered = false;
2857                    cancelPendingScreenshotChordAction();
2858                    if (interceptPowerKeyUp(canceled || mPendingPowerKeyUpCanceled)) {
2859                        result = (result & ~ACTION_POKE_USER_ACTIVITY) | ACTION_GO_TO_SLEEP;
2860                    }
2861                    mPendingPowerKeyUpCanceled = false;
2862                }
2863                break;
2864            }
2865
2866            case KeyEvent.KEYCODE_MEDIA_PLAY:
2867            case KeyEvent.KEYCODE_MEDIA_PAUSE:
2868            case KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE:
2869                if (down) {
2870                    ITelephony telephonyService = getTelephonyService();
2871                    if (telephonyService != null) {
2872                        try {
2873                            if (!telephonyService.isIdle()) {
2874                                // Suppress PLAY/PAUSE toggle when phone is ringing or in-call
2875                                // to avoid music playback.
2876                                break;
2877                            }
2878                        } catch (RemoteException ex) {
2879                            Log.w(TAG, "ITelephony threw RemoteException", ex);
2880                        }
2881                    }
2882                }
2883            case KeyEvent.KEYCODE_HEADSETHOOK:
2884            case KeyEvent.KEYCODE_MUTE:
2885            case KeyEvent.KEYCODE_MEDIA_STOP:
2886            case KeyEvent.KEYCODE_MEDIA_NEXT:
2887            case KeyEvent.KEYCODE_MEDIA_PREVIOUS:
2888            case KeyEvent.KEYCODE_MEDIA_REWIND:
2889            case KeyEvent.KEYCODE_MEDIA_RECORD:
2890            case KeyEvent.KEYCODE_MEDIA_FAST_FORWARD: {
2891                if ((result & ACTION_PASS_TO_USER) == 0) {
2892                    // Only do this if we would otherwise not pass it to the user. In that
2893                    // case, the PhoneWindow class will do the same thing, except it will
2894                    // only do it if the showing app doesn't process the key on its own.
2895                    mBroadcastWakeLock.acquire();
2896                    mHandler.post(new PassHeadsetKey(new KeyEvent(event)));
2897                }
2898                break;
2899            }
2900
2901            case KeyEvent.KEYCODE_CALL: {
2902                if (down) {
2903                    ITelephony telephonyService = getTelephonyService();
2904                    if (telephonyService != null) {
2905                        try {
2906                            if (telephonyService.isRinging()) {
2907                                Log.i(TAG, "interceptKeyBeforeQueueing:"
2908                                      + " CALL key-down while ringing: Answer the call!");
2909                                telephonyService.answerRingingCall();
2910
2911                                // And *don't* pass this key thru to the current activity
2912                                // (which is presumably the InCallScreen.)
2913                                result &= ~ACTION_PASS_TO_USER;
2914                            }
2915                        } catch (RemoteException ex) {
2916                            Log.w(TAG, "ITelephony threw RemoteException", ex);
2917                        }
2918                    }
2919                }
2920                break;
2921            }
2922        }
2923        return result;
2924    }
2925
2926    /** {@inheritDoc} */
2927    @Override
2928    public int interceptMotionBeforeQueueingWhenScreenOff(int policyFlags) {
2929        int result = 0;
2930
2931        final boolean isWakeMotion = (policyFlags
2932                & (WindowManagerPolicy.FLAG_WAKE | WindowManagerPolicy.FLAG_WAKE_DROPPED)) != 0;
2933        if (isWakeMotion) {
2934            if (mKeyguardMediator.isShowing()) {
2935                // If the keyguard is showing, let it decide what to do with the wake motion.
2936                mKeyguardMediator.onWakeMotionWhenKeyguardShowingTq();
2937            } else {
2938                // Otherwise, wake the device ourselves.
2939                result |= ACTION_POKE_USER_ACTIVITY;
2940            }
2941        }
2942        return result;
2943    }
2944
2945    class PassHeadsetKey implements Runnable {
2946        KeyEvent mKeyEvent;
2947
2948        PassHeadsetKey(KeyEvent keyEvent) {
2949            mKeyEvent = keyEvent;
2950        }
2951
2952        public void run() {
2953            if (ActivityManagerNative.isSystemReady()) {
2954                Intent intent = new Intent(Intent.ACTION_MEDIA_BUTTON, null);
2955                intent.putExtra(Intent.EXTRA_KEY_EVENT, mKeyEvent);
2956                mContext.sendOrderedBroadcast(intent, null, mBroadcastDone,
2957                        mHandler, Activity.RESULT_OK, null, null);
2958            }
2959        }
2960    }
2961
2962    BroadcastReceiver mBroadcastDone = new BroadcastReceiver() {
2963        public void onReceive(Context context, Intent intent) {
2964            mBroadcastWakeLock.release();
2965        }
2966    };
2967
2968    BroadcastReceiver mDockReceiver = new BroadcastReceiver() {
2969        public void onReceive(Context context, Intent intent) {
2970            if (Intent.ACTION_DOCK_EVENT.equals(intent.getAction())) {
2971                mDockMode = intent.getIntExtra(Intent.EXTRA_DOCK_STATE,
2972                        Intent.EXTRA_DOCK_STATE_UNDOCKED);
2973            } else {
2974                try {
2975                    IUiModeManager uiModeService = IUiModeManager.Stub.asInterface(
2976                            ServiceManager.getService(Context.UI_MODE_SERVICE));
2977                    mUiMode = uiModeService.getCurrentModeType();
2978                } catch (RemoteException e) {
2979                }
2980            }
2981            updateRotation(true);
2982            updateOrientationListenerLp();
2983        }
2984    };
2985
2986    /** {@inheritDoc} */
2987    public void screenTurnedOff(int why) {
2988        EventLog.writeEvent(70000, 0);
2989        synchronized (mLock) {
2990            mScreenOnEarly = false;
2991            mScreenOnFully = false;
2992        }
2993        mKeyguardMediator.onScreenTurnedOff(why);
2994        synchronized (mLock) {
2995            updateOrientationListenerLp();
2996            updateLockScreenTimeout();
2997            updateScreenSaverTimeoutLocked();
2998        }
2999    }
3000
3001    /** {@inheritDoc} */
3002    public void screenTurningOn(final ScreenOnListener screenOnListener) {
3003        EventLog.writeEvent(70000, 1);
3004        if (false) {
3005            RuntimeException here = new RuntimeException("here");
3006            here.fillInStackTrace();
3007            Slog.i(TAG, "Screen turning on...", here);
3008        }
3009        if (screenOnListener != null) {
3010            mKeyguardMediator.onScreenTurnedOn(new KeyguardViewManager.ShowListener() {
3011                @Override public void onShown(IBinder windowToken) {
3012                    if (windowToken != null) {
3013                        try {
3014                            mWindowManager.waitForWindowDrawn(windowToken,
3015                                    new IRemoteCallback.Stub() {
3016                                @Override public void sendResult(Bundle data) {
3017                                    Slog.i(TAG, "Lock screen displayed!");
3018                                    screenOnListener.onScreenOn();
3019                                    synchronized (mLock) {
3020                                        mScreenOnFully = true;
3021                                    }
3022                                }
3023                            });
3024                        } catch (RemoteException e) {
3025                        }
3026                    } else {
3027                        Slog.i(TAG, "No lock screen!");
3028                        screenOnListener.onScreenOn();
3029                        synchronized (mLock) {
3030                            mScreenOnFully = true;
3031                        }
3032                    }
3033                }
3034            });
3035        } else {
3036            synchronized (mLock) {
3037                mScreenOnFully = true;
3038            }
3039        }
3040        synchronized (mLock) {
3041            mScreenOnEarly = true;
3042            updateOrientationListenerLp();
3043            updateLockScreenTimeout();
3044            updateScreenSaverTimeoutLocked();
3045        }
3046    }
3047
3048    /** {@inheritDoc} */
3049    public boolean isScreenOnEarly() {
3050        return mScreenOnEarly;
3051    }
3052
3053    /** {@inheritDoc} */
3054    public boolean isScreenOnFully() {
3055        return mScreenOnFully;
3056    }
3057
3058    /** {@inheritDoc} */
3059    public void enableKeyguard(boolean enabled) {
3060        mKeyguardMediator.setKeyguardEnabled(enabled);
3061    }
3062
3063    /** {@inheritDoc} */
3064    public void exitKeyguardSecurely(OnKeyguardExitResult callback) {
3065        mKeyguardMediator.verifyUnlock(callback);
3066    }
3067
3068    private boolean keyguardIsShowingTq() {
3069        return mKeyguardMediator.isShowingAndNotHidden();
3070    }
3071
3072
3073    /** {@inheritDoc} */
3074    public boolean isKeyguardLocked() {
3075        return keyguardOn();
3076    }
3077
3078    /** {@inheritDoc} */
3079    public boolean isKeyguardSecure() {
3080        return mKeyguardMediator.isSecure();
3081    }
3082
3083    /** {@inheritDoc} */
3084    public boolean inKeyguardRestrictedKeyInputMode() {
3085        return mKeyguardMediator.isInputRestricted();
3086    }
3087
3088    public void dismissKeyguardLw() {
3089        if (!mKeyguardMediator.isSecure()) {
3090            if (mKeyguardMediator.isShowing()) {
3091                mHandler.post(new Runnable() {
3092                    public void run() {
3093                        mKeyguardMediator.keyguardDone(false, true);
3094                    }
3095                });
3096            }
3097        }
3098    }
3099
3100    void sendCloseSystemWindows() {
3101        sendCloseSystemWindows(mContext, null);
3102    }
3103
3104    void sendCloseSystemWindows(String reason) {
3105        sendCloseSystemWindows(mContext, reason);
3106    }
3107
3108    static void sendCloseSystemWindows(Context context, String reason) {
3109        if (ActivityManagerNative.isSystemReady()) {
3110            try {
3111                ActivityManagerNative.getDefault().closeSystemDialogs(reason);
3112            } catch (RemoteException e) {
3113            }
3114        }
3115    }
3116
3117    @Override
3118    public int rotationForOrientationLw(int orientation, int lastRotation) {
3119        if (false) {
3120            Slog.v(TAG, "rotationForOrientationLw(orient="
3121                        + orientation + ", last=" + lastRotation
3122                        + "); user=" + mUserRotation + " "
3123                        + ((mUserRotationMode == WindowManagerPolicy.USER_ROTATION_LOCKED)
3124                            ? "USER_ROTATION_LOCKED" : "")
3125                        );
3126        }
3127
3128        synchronized (mLock) {
3129            int sensorRotation = mOrientationListener.getProposedRotation(); // may be -1
3130            if (sensorRotation < 0) {
3131                sensorRotation = lastRotation;
3132            }
3133
3134            int preferredRotation = -1;
3135            if (mHdmiPlugged) {
3136                // Ignore sensor when plugged into HDMI.
3137                preferredRotation = mHdmiRotation;
3138            } else if (mLidOpen == LID_OPEN && mLidOpenRotation >= 0) {
3139                // Ignore sensor when lid switch is open and rotation is forced.
3140                preferredRotation = mLidOpenRotation;
3141            } else if (mDockMode == Intent.EXTRA_DOCK_STATE_CAR
3142                    && (mCarDockEnablesAccelerometer || mCarDockRotation >= 0)) {
3143                // Ignore sensor when in car dock unless explicitly enabled.
3144                // This case can override the behavior of NOSENSOR, and can also
3145                // enable 180 degree rotation while docked.
3146                preferredRotation = mCarDockEnablesAccelerometer
3147                        ? sensorRotation : mCarDockRotation;
3148            } else if ((mDockMode == Intent.EXTRA_DOCK_STATE_DESK
3149                    || mDockMode == Intent.EXTRA_DOCK_STATE_LE_DESK
3150                    || mDockMode == Intent.EXTRA_DOCK_STATE_HE_DESK)
3151                    && (mDeskDockEnablesAccelerometer || mDeskDockRotation >= 0)) {
3152                // Ignore sensor when in desk dock unless explicitly enabled.
3153                // This case can override the behavior of NOSENSOR, and can also
3154                // enable 180 degree rotation while docked.
3155                preferredRotation = mDeskDockEnablesAccelerometer
3156                        ? sensorRotation : mDeskDockRotation;
3157            } else if ((mAccelerometerDefault != 0 /* implies not rotation locked */
3158                            && (orientation == ActivityInfo.SCREEN_ORIENTATION_USER
3159                                    || orientation == ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED))
3160                    || orientation == ActivityInfo.SCREEN_ORIENTATION_SENSOR
3161                    || orientation == ActivityInfo.SCREEN_ORIENTATION_FULL_SENSOR
3162                    || orientation == ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE
3163                    || orientation == ActivityInfo.SCREEN_ORIENTATION_SENSOR_PORTRAIT) {
3164                // Otherwise, use sensor only if requested by the application or enabled
3165                // by default for USER or UNSPECIFIED modes.  Does not apply to NOSENSOR.
3166                if (mAllowAllRotations < 0) {
3167                    // Can't read this during init() because the context doesn't
3168                    // have display metrics at that time so we cannot determine
3169                    // tablet vs. phone then.
3170                    mAllowAllRotations = mContext.getResources().getBoolean(
3171                            com.android.internal.R.bool.config_allowAllRotations) ? 1 : 0;
3172                }
3173                if (sensorRotation != Surface.ROTATION_180
3174                        || mAllowAllRotations == 1
3175                        || orientation == ActivityInfo.SCREEN_ORIENTATION_FULL_SENSOR) {
3176                    preferredRotation = sensorRotation;
3177                } else {
3178                    preferredRotation = lastRotation;
3179                }
3180            } else if (mUserRotationMode == WindowManagerPolicy.USER_ROTATION_LOCKED) {
3181                // Apply rotation lock.
3182                preferredRotation = mUserRotation;
3183            }
3184
3185            // TODO: Sometimes, we might want to override the application-requested
3186            //       orientation, such as when HDMI is plugged in or when docked.
3187            //       We can do that by modifying the appropriate cases above to return
3188            //       the preferred orientation directly instead of continuing on down here.
3189
3190            switch (orientation) {
3191                case ActivityInfo.SCREEN_ORIENTATION_PORTRAIT:
3192                    // Always return portrait if orientation set to portrait.
3193                    return mPortraitRotation;
3194
3195                case ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE:
3196                    // Always return landscape if orientation set to landscape.
3197                    return mLandscapeRotation;
3198
3199                case ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT:
3200                    // Always return portrait if orientation set to portrait.
3201                    return mUpsideDownRotation;
3202
3203                case ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE:
3204                    // Always return seascape if orientation set to reverse landscape.
3205                    return mSeascapeRotation;
3206
3207                case ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE:
3208                    // Return either landscape rotation.
3209                    if (isLandscapeOrSeascape(preferredRotation)) {
3210                        return preferredRotation;
3211                    }
3212                    if (isLandscapeOrSeascape(lastRotation)) {
3213                        return lastRotation;
3214                    }
3215                    return mLandscapeRotation;
3216
3217                case ActivityInfo.SCREEN_ORIENTATION_SENSOR_PORTRAIT:
3218                    // Return either portrait rotation.
3219                    if (isAnyPortrait(preferredRotation)) {
3220                        return preferredRotation;
3221                    }
3222                    if (isAnyPortrait(lastRotation)) {
3223                        return lastRotation;
3224                    }
3225                    return mPortraitRotation;
3226
3227                default:
3228                    // For USER, UNSPECIFIED, NOSENSOR, SENSOR and FULL_SENSOR,
3229                    // just return the preferred orientation we already calculated.
3230                    if (preferredRotation >= 0) {
3231                        return preferredRotation;
3232                    }
3233                    return Surface.ROTATION_0;
3234            }
3235        }
3236    }
3237
3238    @Override
3239    public boolean rotationHasCompatibleMetricsLw(int orientation, int rotation) {
3240        switch (orientation) {
3241            case ActivityInfo.SCREEN_ORIENTATION_PORTRAIT:
3242            case ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT:
3243            case ActivityInfo.SCREEN_ORIENTATION_SENSOR_PORTRAIT:
3244                return isAnyPortrait(rotation);
3245
3246            case ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE:
3247            case ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE:
3248            case ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE:
3249                return isLandscapeOrSeascape(rotation);
3250
3251            default:
3252                return true;
3253        }
3254    }
3255
3256    @Override
3257    public void setRotationLw(int rotation) {
3258        mOrientationListener.setCurrentRotation(rotation);
3259    }
3260
3261    private boolean isLandscapeOrSeascape(int rotation) {
3262        return rotation == mLandscapeRotation || rotation == mSeascapeRotation;
3263    }
3264
3265    private boolean isAnyPortrait(int rotation) {
3266        return rotation == mPortraitRotation || rotation == mUpsideDownRotation;
3267    }
3268
3269
3270    // User rotation: to be used when all else fails in assigning an orientation to the device
3271    public void setUserRotationMode(int mode, int rot) {
3272        ContentResolver res = mContext.getContentResolver();
3273
3274        // mUserRotationMode and mUserRotation will be assigned by the content observer
3275        if (mode == WindowManagerPolicy.USER_ROTATION_LOCKED) {
3276            Settings.System.putInt(res,
3277                    Settings.System.USER_ROTATION,
3278                    rot);
3279            Settings.System.putInt(res,
3280                    Settings.System.ACCELEROMETER_ROTATION,
3281                    0);
3282        } else {
3283            Settings.System.putInt(res,
3284                    Settings.System.ACCELEROMETER_ROTATION,
3285                    1);
3286        }
3287    }
3288
3289    public boolean detectSafeMode() {
3290        try {
3291            int menuState = mWindowManager.getKeycodeState(KeyEvent.KEYCODE_MENU);
3292            int sState = mWindowManager.getKeycodeState(KeyEvent.KEYCODE_S);
3293            int dpadState = mWindowManager.getDPadKeycodeState(KeyEvent.KEYCODE_DPAD_CENTER);
3294            int trackballState = mWindowManager.getTrackballScancodeState(BTN_MOUSE);
3295            int volumeDownState = mWindowManager.getKeycodeState(KeyEvent.KEYCODE_VOLUME_DOWN);
3296            mSafeMode = menuState > 0 || sState > 0 || dpadState > 0 || trackballState > 0
3297                    || volumeDownState > 0;
3298            performHapticFeedbackLw(null, mSafeMode
3299                    ? HapticFeedbackConstants.SAFE_MODE_ENABLED
3300                    : HapticFeedbackConstants.SAFE_MODE_DISABLED, true);
3301            if (mSafeMode) {
3302                Log.i(TAG, "SAFE MODE ENABLED (menu=" + menuState + " s=" + sState
3303                        + " dpad=" + dpadState + " trackball=" + trackballState + ")");
3304            } else {
3305                Log.i(TAG, "SAFE MODE not enabled");
3306            }
3307            return mSafeMode;
3308        } catch (RemoteException e) {
3309            // Doom! (it's also local)
3310            throw new RuntimeException("window manager dead");
3311        }
3312    }
3313
3314    static long[] getLongIntArray(Resources r, int resid) {
3315        int[] ar = r.getIntArray(resid);
3316        if (ar == null) {
3317            return null;
3318        }
3319        long[] out = new long[ar.length];
3320        for (int i=0; i<ar.length; i++) {
3321            out[i] = ar[i];
3322        }
3323        return out;
3324    }
3325
3326    /** {@inheritDoc} */
3327    public void systemReady() {
3328        // tell the keyguard
3329        mKeyguardMediator.onSystemReady();
3330        android.os.SystemProperties.set("dev.bootcomplete", "1");
3331        synchronized (mLock) {
3332            updateOrientationListenerLp();
3333            mSystemReady = true;
3334            mHandler.post(new Runnable() {
3335                public void run() {
3336                    updateSettings();
3337                }
3338            });
3339        }
3340    }
3341
3342    /** {@inheritDoc} */
3343    public void systemBooted() {
3344        synchronized (mLock) {
3345            mSystemBooted = true;
3346        }
3347    }
3348
3349    ProgressDialog mBootMsgDialog = null;
3350
3351    /** {@inheritDoc} */
3352    public void showBootMessage(final CharSequence msg, final boolean always) {
3353        mHandler.post(new Runnable() {
3354            @Override public void run() {
3355                if (mBootMsgDialog == null) {
3356                    mBootMsgDialog = new ProgressDialog(mContext) {
3357                        // This dialog will consume all events coming in to
3358                        // it, to avoid it trying to do things too early in boot.
3359                        @Override public boolean dispatchKeyEvent(KeyEvent event) {
3360                            return true;
3361                        }
3362                        @Override public boolean dispatchKeyShortcutEvent(KeyEvent event) {
3363                            return true;
3364                        }
3365                        @Override public boolean dispatchTouchEvent(MotionEvent ev) {
3366                            return true;
3367                        }
3368                        @Override public boolean dispatchTrackballEvent(MotionEvent ev) {
3369                            return true;
3370                        }
3371                        @Override public boolean dispatchGenericMotionEvent(MotionEvent ev) {
3372                            return true;
3373                        }
3374                        @Override public boolean dispatchPopulateAccessibilityEvent(
3375                                AccessibilityEvent event) {
3376                            return true;
3377                        }
3378                    };
3379                    mBootMsgDialog.setTitle(R.string.android_upgrading_title);
3380                    mBootMsgDialog.setProgressStyle(ProgressDialog.STYLE_SPINNER);
3381                    mBootMsgDialog.setIndeterminate(true);
3382                    mBootMsgDialog.getWindow().setType(
3383                            WindowManager.LayoutParams.TYPE_BOOT_PROGRESS);
3384                    mBootMsgDialog.getWindow().addFlags(
3385                            WindowManager.LayoutParams.FLAG_DIM_BEHIND
3386                            | WindowManager.LayoutParams.FLAG_LAYOUT_IN_SCREEN);
3387                    mBootMsgDialog.getWindow().setDimAmount(1);
3388                    mBootMsgDialog.setCancelable(false);
3389                    mBootMsgDialog.show();
3390                }
3391                mBootMsgDialog.setMessage(msg);
3392            }
3393        });
3394    }
3395
3396    /** {@inheritDoc} */
3397    public void hideBootMessages() {
3398        mHandler.post(new Runnable() {
3399            @Override public void run() {
3400                if (mBootMsgDialog != null) {
3401                    mBootMsgDialog.dismiss();
3402                    mBootMsgDialog = null;
3403                }
3404            }
3405        });
3406    }
3407
3408    /** {@inheritDoc} */
3409    public void userActivity() {
3410        // ***************************************
3411        // NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE
3412        // ***************************************
3413        // THIS IS CALLED FROM DEEP IN THE POWER MANAGER
3414        // WITH ITS LOCKS HELD.
3415        //
3416        // This code must be VERY careful about the locks
3417        // it acquires.
3418        // In fact, the current code acquires way too many,
3419        // and probably has lurking deadlocks.
3420
3421        synchronized (mScreenLockTimeout) {
3422            if (mLockScreenTimerActive) {
3423                // reset the timer
3424                mHandler.removeCallbacks(mScreenLockTimeout);
3425                mHandler.postDelayed(mScreenLockTimeout, mLockScreenTimeout);
3426            }
3427        }
3428
3429        synchronized (mLock) {
3430            // Only posts messages; holds no additional locks.
3431            updateScreenSaverTimeoutLocked();
3432        }
3433    }
3434
3435    Runnable mScreenSaverActivator = new Runnable() {
3436        public void run() {
3437            if (!(mScreenSaverEnabled && mScreenOnEarly)) {
3438                Log.w(TAG, "mScreenSaverActivator ran, but the screensaver should not be showing. Who's driving this thing?");
3439                return;
3440            }
3441
3442            if (localLOGV) Log.v(TAG, "mScreenSaverActivator entering dreamland");
3443            try {
3444                String component = Settings.Secure.getString(
3445                        mContext.getContentResolver(), Settings.Secure.DREAM_COMPONENT);
3446                if (component != null) {
3447                    ComponentName cn = ComponentName.unflattenFromString(component);
3448                    Intent intent = new Intent(Intent.ACTION_MAIN)
3449                        .setComponent(cn)
3450                        .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK
3451                            | Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS
3452                            | Intent.FLAG_ACTIVITY_NO_USER_ACTION
3453                            );
3454                    mContext.startActivity(intent);
3455                } else {
3456                    Log.e(TAG, "Couldn't start screen saver: none selected");
3457                }
3458            } catch (android.content.ActivityNotFoundException exc) {
3459                // no screensaver? give up
3460                Log.e(TAG, "Couldn't start screen saver: none installed");
3461            }
3462        }
3463    };
3464
3465    // Must call while holding mLock
3466    private void updateScreenSaverTimeoutLocked() {
3467        if (mScreenSaverActivator == null) return;
3468
3469        mHandler.removeCallbacks(mScreenSaverActivator);
3470        if (mScreenSaverEnabled && mScreenOnEarly && mScreenSaverTimeout > 0) {
3471            if (localLOGV)
3472                Log.v(TAG, "scheduling screensaver for " + mScreenSaverTimeout + "ms from now");
3473            mHandler.postDelayed(mScreenSaverActivator, mScreenSaverTimeout);
3474        } else {
3475            if (localLOGV) {
3476                if (mScreenSaverTimeout == 0)
3477                    Log.v(TAG, "screen saver disabled by user");
3478                else if (!mScreenOnEarly)
3479                    Log.v(TAG, "screen saver disabled while screen off");
3480                else
3481                    Log.v(TAG, "screen saver disabled by wakelock");
3482            }
3483        }
3484    }
3485
3486    Runnable mScreenLockTimeout = new Runnable() {
3487        public void run() {
3488            synchronized (this) {
3489                if (localLOGV) Log.v(TAG, "mScreenLockTimeout activating keyguard");
3490                mKeyguardMediator.doKeyguardTimeout();
3491                mLockScreenTimerActive = false;
3492            }
3493        }
3494    };
3495
3496    private void updateLockScreenTimeout() {
3497        synchronized (mScreenLockTimeout) {
3498            boolean enable = (mAllowLockscreenWhenOn && mScreenOnEarly && mKeyguardMediator.isSecure());
3499            if (mLockScreenTimerActive != enable) {
3500                if (enable) {
3501                    if (localLOGV) Log.v(TAG, "setting lockscreen timer");
3502                    mHandler.postDelayed(mScreenLockTimeout, mLockScreenTimeout);
3503                } else {
3504                    if (localLOGV) Log.v(TAG, "clearing lockscreen timer");
3505                    mHandler.removeCallbacks(mScreenLockTimeout);
3506                }
3507                mLockScreenTimerActive = enable;
3508            }
3509        }
3510    }
3511
3512    /** {@inheritDoc} */
3513    public void enableScreenAfterBoot() {
3514        readLidState();
3515        updateKeyboardVisibility();
3516
3517        updateRotation(true);
3518    }
3519
3520    private void updateKeyboardVisibility() {
3521        mPowerManager.setKeyboardVisibility(mLidOpen == LID_OPEN);
3522    }
3523
3524    void updateRotation(boolean alwaysSendConfiguration) {
3525        try {
3526            //set orientation on WindowManager
3527            mWindowManager.updateRotation(alwaysSendConfiguration);
3528        } catch (RemoteException e) {
3529            // Ignore
3530        }
3531    }
3532
3533    /**
3534     * Return an Intent to launch the currently active dock as home.  Returns
3535     * null if the standard home should be launched.
3536     * @return
3537     */
3538    Intent createHomeDockIntent() {
3539        Intent intent;
3540
3541        // What home does is based on the mode, not the dock state.  That
3542        // is, when in car mode you should be taken to car home regardless
3543        // of whether we are actually in a car dock.
3544        if (mUiMode == Configuration.UI_MODE_TYPE_CAR) {
3545            intent = mCarDockIntent;
3546        } else if (mUiMode == Configuration.UI_MODE_TYPE_DESK) {
3547            intent = mDeskDockIntent;
3548        } else {
3549            return null;
3550        }
3551
3552        ActivityInfo ai = intent.resolveActivityInfo(
3553                mContext.getPackageManager(), PackageManager.GET_META_DATA);
3554        if (ai == null) {
3555            return null;
3556        }
3557
3558        if (ai.metaData != null && ai.metaData.getBoolean(Intent.METADATA_DOCK_HOME)) {
3559            intent = new Intent(intent);
3560            intent.setClassName(ai.packageName, ai.name);
3561            return intent;
3562        }
3563
3564        return null;
3565    }
3566
3567    void startDockOrHome() {
3568        Intent dock = createHomeDockIntent();
3569        if (dock != null) {
3570            try {
3571                mContext.startActivity(dock);
3572                return;
3573            } catch (ActivityNotFoundException e) {
3574            }
3575        }
3576        mContext.startActivity(mHomeIntent);
3577    }
3578
3579    /**
3580     * goes to the home screen
3581     * @return whether it did anything
3582     */
3583    boolean goHome() {
3584        if (false) {
3585            // This code always brings home to the front.
3586            try {
3587                ActivityManagerNative.getDefault().stopAppSwitches();
3588            } catch (RemoteException e) {
3589            }
3590            sendCloseSystemWindows();
3591            startDockOrHome();
3592        } else {
3593            // This code brings home to the front or, if it is already
3594            // at the front, puts the device to sleep.
3595            try {
3596                if (SystemProperties.getInt("persist.sys.uts-test-mode", 0) == 1) {
3597                    /// Roll back EndcallBehavior as the cupcake design to pass P1 lab entry.
3598                    Log.d(TAG, "UTS-TEST-MODE");
3599                } else {
3600                    ActivityManagerNative.getDefault().stopAppSwitches();
3601                    sendCloseSystemWindows();
3602                    Intent dock = createHomeDockIntent();
3603                    if (dock != null) {
3604                        int result = ActivityManagerNative.getDefault()
3605                                .startActivity(null, dock,
3606                                        dock.resolveTypeIfNeeded(mContext.getContentResolver()),
3607                                        null, 0, null, null, 0, true /* onlyIfNeeded*/, false,
3608                                        null, null, false);
3609                        if (result == IActivityManager.START_RETURN_INTENT_TO_CALLER) {
3610                            return false;
3611                        }
3612                    }
3613                }
3614                int result = ActivityManagerNative.getDefault()
3615                        .startActivity(null, mHomeIntent,
3616                                mHomeIntent.resolveTypeIfNeeded(mContext.getContentResolver()),
3617                                null, 0, null, null, 0, true /* onlyIfNeeded*/, false,
3618                                null, null, false);
3619                if (result == IActivityManager.START_RETURN_INTENT_TO_CALLER) {
3620                    return false;
3621                }
3622            } catch (RemoteException ex) {
3623                // bummer, the activity manager, which is in this process, is dead
3624            }
3625        }
3626        return true;
3627    }
3628
3629    public void setCurrentOrientationLw(int newOrientation) {
3630        synchronized (mLock) {
3631            if (newOrientation != mCurrentAppOrientation) {
3632                mCurrentAppOrientation = newOrientation;
3633                updateOrientationListenerLp();
3634            }
3635        }
3636    }
3637
3638    public boolean performHapticFeedbackLw(WindowState win, int effectId, boolean always) {
3639        final boolean hapticsDisabled = Settings.System.getInt(mContext.getContentResolver(),
3640                Settings.System.HAPTIC_FEEDBACK_ENABLED, 0) == 0;
3641        if (!always && (hapticsDisabled || mKeyguardMediator.isShowingAndNotHidden())) {
3642            return false;
3643        }
3644        long[] pattern = null;
3645        switch (effectId) {
3646            case HapticFeedbackConstants.LONG_PRESS:
3647                pattern = mLongPressVibePattern;
3648                break;
3649            case HapticFeedbackConstants.VIRTUAL_KEY:
3650                pattern = mVirtualKeyVibePattern;
3651                break;
3652            case HapticFeedbackConstants.KEYBOARD_TAP:
3653                pattern = mKeyboardTapVibePattern;
3654                break;
3655            case HapticFeedbackConstants.SAFE_MODE_DISABLED:
3656                pattern = mSafeModeDisabledVibePattern;
3657                break;
3658            case HapticFeedbackConstants.SAFE_MODE_ENABLED:
3659                pattern = mSafeModeEnabledVibePattern;
3660                break;
3661            default:
3662                return false;
3663        }
3664        if (pattern.length == 1) {
3665            // One-shot vibration
3666            mVibrator.vibrate(pattern[0]);
3667        } else {
3668            // Pattern vibration
3669            mVibrator.vibrate(pattern, -1);
3670        }
3671        return true;
3672    }
3673
3674    public void screenOnStartedLw() {
3675        // The window manager has just grabbed a wake lock. This is our cue to disable the screen
3676        // saver.
3677        synchronized (mLock) {
3678            mScreenSaverEnabled = false;
3679        }
3680    }
3681
3682    public void screenOnStoppedLw() {
3683        if (mPowerManager.isScreenOn()) {
3684            if (!mKeyguardMediator.isShowingAndNotHidden()) {
3685                long curTime = SystemClock.uptimeMillis();
3686                mPowerManager.userActivity(curTime, false, LocalPowerManager.OTHER_EVENT);
3687            }
3688
3689            synchronized (mLock) {
3690                // even if the keyguard is up, now that all the wakelocks have been released, we
3691                // should re-enable the screen saver
3692                mScreenSaverEnabled = true;
3693                updateScreenSaverTimeoutLocked();
3694            }
3695        }
3696    }
3697
3698    public boolean allowKeyRepeat() {
3699        // disable key repeat when screen is off
3700        return mScreenOnEarly;
3701    }
3702
3703    private int updateSystemUiVisibilityLw() {
3704        // If there is no window focused, there will be nobody to handle the events
3705        // anyway, so just hang on in whatever state we're in until things settle down.
3706        if (mFocusedWindow == null) {
3707            return 0;
3708        }
3709        final int visibility = mFocusedWindow.getSystemUiVisibility()
3710                & ~mResettingSystemUiFlags
3711                & ~mForceClearedSystemUiFlags;
3712        int diff = visibility ^ mLastSystemUiFlags;
3713        if (diff == 0) {
3714            return 0;
3715        }
3716        mLastSystemUiFlags = visibility;
3717        mHandler.post(new Runnable() {
3718                public void run() {
3719                    if (mStatusBarService == null) {
3720                        mStatusBarService = IStatusBarService.Stub.asInterface(
3721                                ServiceManager.getService("statusbar"));
3722                    }
3723                    if (mStatusBarService != null) {
3724                        try {
3725                            mStatusBarService.setSystemUiVisibility(visibility);
3726                        } catch (RemoteException e) {
3727                            // not much to be done
3728                            mStatusBarService = null;
3729                        }
3730                    }
3731                }
3732            });
3733        return diff;
3734    }
3735
3736    // Use this instead of checking config_showNavigationBar so that it can be consistently
3737    // overridden by qemu.hw.mainkeys in the emulator.
3738    public boolean hasNavigationBar() {
3739        return mHasNavigationBar;
3740    }
3741
3742    public void dump(String prefix, FileDescriptor fd, PrintWriter pw, String[] args) {
3743        pw.print(prefix); pw.print("mSafeMode="); pw.print(mSafeMode);
3744                pw.print(" mSystemReady="); pw.print(mSystemReady);
3745                pw.print(" mSystemBooted="); pw.println(mSystemBooted);
3746        pw.print(prefix); pw.print("mLidOpen="); pw.print(mLidOpen);
3747                pw.print(" mLidOpenRotation="); pw.print(mLidOpenRotation);
3748                pw.print(" mHdmiPlugged="); pw.println(mHdmiPlugged);
3749        if (mLastSystemUiFlags != 0 || mResettingSystemUiFlags != 0
3750                || mForceClearedSystemUiFlags != 0) {
3751            pw.print(prefix); pw.print("mLastSystemUiFlags=0x");
3752                    pw.print(Integer.toHexString(mLastSystemUiFlags));
3753                    pw.print(" mResettingSystemUiFlags=0x");
3754                    pw.print(Integer.toHexString(mResettingSystemUiFlags));
3755                    pw.print(" mForceClearedSystemUiFlags=0x");
3756                    pw.println(Integer.toHexString(mForceClearedSystemUiFlags));
3757        }
3758        pw.print(prefix); pw.print("mUiMode="); pw.print(mUiMode);
3759                pw.print(" mDockMode="); pw.print(mDockMode);
3760                pw.print(" mCarDockRotation="); pw.print(mCarDockRotation);
3761                pw.print(" mDeskDockRotation="); pw.println(mDeskDockRotation);
3762        pw.print(prefix); pw.print("mUserRotationMode="); pw.print(mUserRotationMode);
3763                pw.print(" mUserRotation="); pw.print(mUserRotation);
3764                pw.print(" mAllowAllRotations="); pw.println(mAllowAllRotations);
3765        pw.print(prefix); pw.print("mAccelerometerDefault="); pw.print(mAccelerometerDefault);
3766                pw.print(" mCurrentAppOrientation="); pw.println(mCurrentAppOrientation);
3767        pw.print(prefix); pw.print("mCarDockEnablesAccelerometer=");
3768                pw.print(mCarDockEnablesAccelerometer);
3769                pw.print(" mDeskDockEnablesAccelerometer=");
3770                pw.println(mDeskDockEnablesAccelerometer);
3771        pw.print(prefix); pw.print("mLidKeyboardAccessibility=");
3772                pw.print(mLidKeyboardAccessibility);
3773                pw.print(" mLidNavigationAccessibility="); pw.print(mLidNavigationAccessibility);
3774                pw.print(" mLongPressOnPowerBehavior="); pw.println(mLongPressOnPowerBehavior);
3775        pw.print(prefix); pw.print("mScreenOnEarly="); pw.print(mScreenOnEarly);
3776                pw.print(" mScreenOnFully="); pw.print(mScreenOnFully);
3777                pw.print(" mOrientationSensorEnabled="); pw.print(mOrientationSensorEnabled);
3778                pw.print(" mHasSoftInput="); pw.println(mHasSoftInput);
3779        pw.print(prefix); pw.print("mUnrestrictedScreen=("); pw.print(mUnrestrictedScreenLeft);
3780                pw.print(","); pw.print(mUnrestrictedScreenTop);
3781                pw.print(") "); pw.print(mUnrestrictedScreenWidth);
3782                pw.print("x"); pw.println(mUnrestrictedScreenHeight);
3783        pw.print(prefix); pw.print("mRestrictedScreen=("); pw.print(mRestrictedScreenLeft);
3784                pw.print(","); pw.print(mRestrictedScreenTop);
3785                pw.print(") "); pw.print(mRestrictedScreenWidth);
3786                pw.print("x"); pw.println(mRestrictedScreenHeight);
3787        pw.print(prefix); pw.print("mCur=("); pw.print(mCurLeft);
3788                pw.print(","); pw.print(mCurTop);
3789                pw.print(")-("); pw.print(mCurRight);
3790                pw.print(","); pw.print(mCurBottom); pw.println(")");
3791        pw.print(prefix); pw.print("mContent=("); pw.print(mContentLeft);
3792                pw.print(","); pw.print(mContentTop);
3793                pw.print(")-("); pw.print(mContentRight);
3794                pw.print(","); pw.print(mContentBottom); pw.println(")");
3795        pw.print(prefix); pw.print("mDock=("); pw.print(mDockLeft);
3796                pw.print(","); pw.print(mDockTop);
3797                pw.print(")-("); pw.print(mDockRight);
3798                pw.print(","); pw.print(mDockBottom); pw.println(")");
3799        pw.print(prefix); pw.print("mDockLayer="); pw.println(mDockLayer);
3800        pw.print(prefix); pw.print("mTopFullscreenOpaqueWindowState=");
3801                pw.println(mTopFullscreenOpaqueWindowState);
3802        pw.print(prefix); pw.print("mTopIsFullscreen="); pw.print(mTopIsFullscreen);
3803                pw.print(" mForceStatusBar="); pw.print(mForceStatusBar);
3804                pw.print(" mHideLockScreen="); pw.println(mHideLockScreen);
3805        pw.print(prefix); pw.print("mDismissKeyguard="); pw.print(mDismissKeyguard);
3806                pw.print(" mHomePressed="); pw.println(mHomePressed);
3807        pw.print(prefix); pw.print("mAllowLockscreenWhenOn="); pw.print(mAllowLockscreenWhenOn);
3808                pw.print(" mLockScreenTimeout="); pw.print(mLockScreenTimeout);
3809                pw.print(" mLockScreenTimerActive="); pw.println(mLockScreenTimerActive);
3810        pw.print(prefix); pw.print("mEndcallBehavior="); pw.print(mEndcallBehavior);
3811                pw.print(" mIncallPowerBehavior="); pw.print(mIncallPowerBehavior);
3812                pw.print(" mLongPressOnHomeBehavior="); pw.println(mLongPressOnHomeBehavior);
3813        pw.print(prefix); pw.print("mLandscapeRotation="); pw.print(mLandscapeRotation);
3814                pw.print(" mSeascapeRotation="); pw.println(mSeascapeRotation);
3815        pw.print(prefix); pw.print("mPortraitRotation="); pw.print(mPortraitRotation);
3816                pw.print(" mUpsideDownRotation="); pw.println(mUpsideDownRotation);
3817    }
3818}
3819