[go: nahoru, domu]
1/*
2 * Copyright (C) 2014 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.systemui.statusbar.phone;
18
19import android.content.ComponentCallbacks2;
20import android.content.Context;
21import android.os.Bundle;
22import android.os.SystemClock;
23import android.os.Trace;
24import android.view.KeyEvent;
25import android.view.View;
26import android.view.ViewGroup;
27import android.view.ViewRootImpl;
28import android.view.WindowManagerGlobal;
29
30import com.android.internal.widget.LockPatternUtils;
31import com.android.keyguard.KeyguardUpdateMonitor;
32import com.android.keyguard.ViewMediatorCallback;
33import com.android.systemui.SystemUIFactory;
34import com.android.systemui.statusbar.CommandQueue;
35import com.android.systemui.statusbar.RemoteInputController;
36
37import static com.android.keyguard.KeyguardHostView.OnDismissAction;
38
39/**
40 * Manages creating, showing, hiding and resetting the keyguard within the status bar. Calls back
41 * via {@link ViewMediatorCallback} to poke the wake lock and report that the keyguard is done,
42 * which is in turn, reported to this class by the current
43 * {@link com.android.keyguard.KeyguardViewBase}.
44 */
45public class StatusBarKeyguardViewManager implements RemoteInputController.Callback {
46
47    // When hiding the Keyguard with timing supplied from WindowManager, better be early than late.
48    private static final long HIDE_TIMING_CORRECTION_MS = -3 * 16;
49
50    // Delay for showing the navigation bar when the bouncer appears. This should be kept in sync
51    // with the appear animations of the PIN/pattern/password views.
52    private static final long NAV_BAR_SHOW_DELAY_BOUNCER = 320;
53
54    private static final long WAKE_AND_UNLOCK_SCRIM_FADEOUT_DURATION_MS = 200;
55
56    private static String TAG = "StatusBarKeyguardViewManager";
57
58    protected final Context mContext;
59
60    protected LockPatternUtils mLockPatternUtils;
61    protected ViewMediatorCallback mViewMediatorCallback;
62    protected PhoneStatusBar mPhoneStatusBar;
63    private ScrimController mScrimController;
64    private FingerprintUnlockController mFingerprintUnlockController;
65
66    private ViewGroup mContainer;
67    private StatusBarWindowManager mStatusBarWindowManager;
68
69    private boolean mDeviceInteractive = false;
70    private boolean mScreenTurnedOn;
71    protected KeyguardBouncer mBouncer;
72    protected boolean mShowing;
73    protected boolean mOccluded;
74    protected boolean mRemoteInputActive;
75
76    protected boolean mFirstUpdate = true;
77    protected boolean mLastShowing;
78    protected boolean mLastOccluded;
79    private boolean mLastBouncerShowing;
80    private boolean mLastBouncerDismissible;
81    protected boolean mLastRemoteInputActive;
82
83    private OnDismissAction mAfterKeyguardGoneAction;
84    private boolean mDeviceWillWakeUp;
85    private boolean mDeferScrimFadeOut;
86
87    public StatusBarKeyguardViewManager(Context context, ViewMediatorCallback callback,
88            LockPatternUtils lockPatternUtils) {
89        mContext = context;
90        mViewMediatorCallback = callback;
91        mLockPatternUtils = lockPatternUtils;
92    }
93
94    public void registerStatusBar(PhoneStatusBar phoneStatusBar,
95            ViewGroup container, StatusBarWindowManager statusBarWindowManager,
96            ScrimController scrimController,
97            FingerprintUnlockController fingerprintUnlockController) {
98        mPhoneStatusBar = phoneStatusBar;
99        mContainer = container;
100        mStatusBarWindowManager = statusBarWindowManager;
101        mScrimController = scrimController;
102        mFingerprintUnlockController = fingerprintUnlockController;
103        mBouncer = SystemUIFactory.getInstance().createKeyguardBouncer(mContext,
104                mViewMediatorCallback, mLockPatternUtils, mStatusBarWindowManager, container);
105    }
106
107    /**
108     * Show the keyguard.  Will handle creating and attaching to the view manager
109     * lazily.
110     */
111    public void show(Bundle options) {
112        mShowing = true;
113        mStatusBarWindowManager.setKeyguardShowing(true);
114        mScrimController.abortKeyguardFadingOut();
115        reset();
116    }
117
118    /**
119     * Shows the notification keyguard or the bouncer depending on
120     * {@link KeyguardBouncer#needsFullscreenBouncer()}.
121     */
122    protected void showBouncerOrKeyguard() {
123        if (mBouncer.needsFullscreenBouncer()) {
124
125            // The keyguard might be showing (already). So we need to hide it.
126            mPhoneStatusBar.hideKeyguard();
127            mBouncer.show(true /* resetSecuritySelection */);
128        } else {
129            mPhoneStatusBar.showKeyguard();
130            mBouncer.hide(false /* destroyView */);
131            mBouncer.prepare();
132        }
133    }
134
135    private void showBouncer() {
136        if (mShowing) {
137            mBouncer.show(false /* resetSecuritySelection */);
138        }
139        updateStates();
140    }
141
142    public void dismissWithAction(OnDismissAction r, Runnable cancelAction,
143            boolean afterKeyguardGone) {
144        if (mShowing) {
145            if (!afterKeyguardGone) {
146                mBouncer.showWithDismissAction(r, cancelAction);
147            } else {
148                mBouncer.show(false /* resetSecuritySelection */);
149                mAfterKeyguardGoneAction = r;
150            }
151        }
152        updateStates();
153    }
154
155    /**
156     * Reset the state of the view.
157     */
158    public void reset() {
159        if (mShowing) {
160            if (mOccluded) {
161                mPhoneStatusBar.hideKeyguard();
162                mPhoneStatusBar.stopWaitingForKeyguardExit();
163                mBouncer.hide(false /* destroyView */);
164            } else {
165                showBouncerOrKeyguard();
166            }
167            KeyguardUpdateMonitor.getInstance(mContext).sendKeyguardReset();
168            updateStates();
169        }
170    }
171
172    public void onStartedGoingToSleep() {
173        mPhoneStatusBar.onStartedGoingToSleep();
174    }
175
176    public void onFinishedGoingToSleep() {
177        mDeviceInteractive = false;
178        mPhoneStatusBar.onFinishedGoingToSleep();
179        mBouncer.onScreenTurnedOff();
180    }
181
182    public void onStartedWakingUp() {
183        mDeviceInteractive = true;
184        mDeviceWillWakeUp = false;
185        mPhoneStatusBar.onStartedWakingUp();
186    }
187
188    public void onScreenTurningOn() {
189        mPhoneStatusBar.onScreenTurningOn();
190    }
191
192    public boolean isScreenTurnedOn() {
193        return mScreenTurnedOn;
194    }
195
196    public void onScreenTurnedOn() {
197        mScreenTurnedOn = true;
198        if (mDeferScrimFadeOut) {
199            mDeferScrimFadeOut = false;
200            animateScrimControllerKeyguardFadingOut(0, WAKE_AND_UNLOCK_SCRIM_FADEOUT_DURATION_MS,
201                    true /* skipFirstFrame */);
202            updateStates();
203        }
204        mPhoneStatusBar.onScreenTurnedOn();
205    }
206
207    @Override
208    public void onRemoteInputActive(boolean active) {
209        mRemoteInputActive = active;
210        updateStates();
211    }
212
213    public void onScreenTurnedOff() {
214        mScreenTurnedOn = false;
215        mPhoneStatusBar.onScreenTurnedOff();
216    }
217
218    public void notifyDeviceWakeUpRequested() {
219        mDeviceWillWakeUp = !mDeviceInteractive;
220    }
221
222    public void verifyUnlock() {
223        dismiss();
224    }
225
226    public void setNeedsInput(boolean needsInput) {
227        mStatusBarWindowManager.setKeyguardNeedsInput(needsInput);
228    }
229
230    public boolean isUnlockWithWallpaper() {
231        return mStatusBarWindowManager.isShowingWallpaper();
232    }
233
234    public void setOccluded(boolean occluded) {
235        if (occluded && !mOccluded && mShowing) {
236            if (mPhoneStatusBar.isInLaunchTransition()) {
237                mOccluded = true;
238                mPhoneStatusBar.fadeKeyguardAfterLaunchTransition(null /* beforeFading */,
239                        new Runnable() {
240                            @Override
241                            public void run() {
242                                mStatusBarWindowManager.setKeyguardOccluded(mOccluded);
243                                reset();
244                            }
245                        });
246                return;
247            }
248        }
249        mOccluded = occluded;
250        mPhoneStatusBar.updateMediaMetaData(false, false);
251        mStatusBarWindowManager.setKeyguardOccluded(occluded);
252        reset();
253    }
254
255    public boolean isOccluded() {
256        return mOccluded;
257    }
258
259    /**
260     * Starts the animation before we dismiss Keyguard, i.e. an disappearing animation on the
261     * security view of the bouncer.
262     *
263     * @param finishRunnable the runnable to be run after the animation finished, or {@code null} if
264     *                       no action should be run
265     */
266    public void startPreHideAnimation(Runnable finishRunnable) {
267        if (mBouncer.isShowing()) {
268            mBouncer.startPreHideAnimation(finishRunnable);
269        } else if (finishRunnable != null) {
270            finishRunnable.run();
271        }
272    }
273
274    /**
275     * Hides the keyguard view
276     */
277    public void hide(long startTime, final long fadeoutDuration) {
278        mShowing = false;
279
280        long uptimeMillis = SystemClock.uptimeMillis();
281        long delay = Math.max(0, startTime + HIDE_TIMING_CORRECTION_MS - uptimeMillis);
282
283        if (mPhoneStatusBar.isInLaunchTransition() ) {
284            mPhoneStatusBar.fadeKeyguardAfterLaunchTransition(new Runnable() {
285                @Override
286                public void run() {
287                    mStatusBarWindowManager.setKeyguardShowing(false);
288                    mStatusBarWindowManager.setKeyguardFadingAway(true);
289                    mBouncer.hide(true /* destroyView */);
290                    updateStates();
291                    mScrimController.animateKeyguardFadingOut(
292                            PhoneStatusBar.FADE_KEYGUARD_START_DELAY,
293                            PhoneStatusBar.FADE_KEYGUARD_DURATION, null,
294                            false /* skipFirstFrame */);
295                }
296            }, new Runnable() {
297                @Override
298                public void run() {
299                    mPhoneStatusBar.hideKeyguard();
300                    mStatusBarWindowManager.setKeyguardFadingAway(false);
301                    mViewMediatorCallback.keyguardGone();
302                    executeAfterKeyguardGoneAction();
303                }
304            });
305        } else {
306            if (mFingerprintUnlockController.getMode()
307                    == FingerprintUnlockController.MODE_WAKE_AND_UNLOCK_PULSING) {
308                mFingerprintUnlockController.startKeyguardFadingAway();
309                mPhoneStatusBar.setKeyguardFadingAway(startTime, 0, 240);
310                mStatusBarWindowManager.setKeyguardFadingAway(true);
311                mPhoneStatusBar.fadeKeyguardWhilePulsing();
312                animateScrimControllerKeyguardFadingOut(0, 240, new Runnable() {
313                    @Override
314                    public void run() {
315                        mPhoneStatusBar.hideKeyguard();
316                    }
317                }, false /* skipFirstFrame */);
318            } else {
319                mFingerprintUnlockController.startKeyguardFadingAway();
320                mPhoneStatusBar.setKeyguardFadingAway(startTime, delay, fadeoutDuration);
321                boolean staying = mPhoneStatusBar.hideKeyguard();
322                if (!staying) {
323                    mStatusBarWindowManager.setKeyguardFadingAway(true);
324                    if (mFingerprintUnlockController.getMode()
325                            == FingerprintUnlockController.MODE_WAKE_AND_UNLOCK) {
326                        if (!mScreenTurnedOn) {
327                            mDeferScrimFadeOut = true;
328                        } else {
329
330                            // Screen is already on, don't defer with fading out.
331                            animateScrimControllerKeyguardFadingOut(0,
332                                    WAKE_AND_UNLOCK_SCRIM_FADEOUT_DURATION_MS,
333                                    true /* skipFirstFrame */);
334                        }
335                    } else {
336                        animateScrimControllerKeyguardFadingOut(delay, fadeoutDuration,
337                                false /* skipFirstFrame */);
338                    }
339                } else {
340                    mScrimController.animateGoingToFullShade(delay, fadeoutDuration);
341                    mPhoneStatusBar.finishKeyguardFadingAway();
342                }
343            }
344            mStatusBarWindowManager.setKeyguardShowing(false);
345            mBouncer.hide(true /* destroyView */);
346            mViewMediatorCallback.keyguardGone();
347            executeAfterKeyguardGoneAction();
348            updateStates();
349        }
350    }
351
352    public void onDensityOrFontScaleChanged() {
353        mBouncer.hide(true /* destroyView */);
354    }
355
356    private void animateScrimControllerKeyguardFadingOut(long delay, long duration,
357            boolean skipFirstFrame) {
358        animateScrimControllerKeyguardFadingOut(delay, duration, null /* endRunnable */,
359                skipFirstFrame);
360    }
361
362    private void animateScrimControllerKeyguardFadingOut(long delay, long duration,
363            final Runnable endRunnable, boolean skipFirstFrame) {
364        Trace.asyncTraceBegin(Trace.TRACE_TAG_VIEW, "Fading out", 0);
365        mScrimController.animateKeyguardFadingOut(delay, duration, new Runnable() {
366            @Override
367            public void run() {
368                if (endRunnable != null) {
369                    endRunnable.run();
370                }
371                mStatusBarWindowManager.setKeyguardFadingAway(false);
372                mPhoneStatusBar.finishKeyguardFadingAway();
373                mFingerprintUnlockController.finishKeyguardFadingAway();
374                WindowManagerGlobal.getInstance().trimMemory(
375                        ComponentCallbacks2.TRIM_MEMORY_UI_HIDDEN);
376                Trace.asyncTraceEnd(Trace.TRACE_TAG_VIEW, "Fading out", 0);
377            }
378        }, skipFirstFrame);
379    }
380
381    private void executeAfterKeyguardGoneAction() {
382        if (mAfterKeyguardGoneAction != null) {
383            mAfterKeyguardGoneAction.onDismiss();
384            mAfterKeyguardGoneAction = null;
385        }
386    }
387
388    /**
389     * Dismisses the keyguard by going to the next screen or making it gone.
390     */
391    public void dismiss() {
392        if (mDeviceInteractive || mDeviceWillWakeUp) {
393            showBouncer();
394        }
395    }
396
397    /**
398     * WARNING: This method might cause Binder calls.
399     */
400    public boolean isSecure() {
401        return mBouncer.isSecure();
402    }
403
404    /**
405     * @return Whether the keyguard is showing
406     */
407    public boolean isShowing() {
408        return mShowing;
409    }
410
411    /**
412     * Notifies this manager that the back button has been pressed.
413     *
414     * @return whether the back press has been handled
415     */
416    public boolean onBackPressed() {
417        if (mBouncer.isShowing()) {
418            mPhoneStatusBar.endAffordanceLaunch();
419            reset();
420            return true;
421        }
422        return false;
423    }
424
425    public boolean isBouncerShowing() {
426        return mBouncer.isShowing();
427    }
428
429    private long getNavBarShowDelay() {
430        if (mPhoneStatusBar.isKeyguardFadingAway()) {
431            return mPhoneStatusBar.getKeyguardFadingAwayDelay();
432        } else {
433
434            // Keyguard is not going away, thus we are showing the navigation bar because the
435            // bouncer is appearing.
436            return NAV_BAR_SHOW_DELAY_BOUNCER;
437        }
438    }
439
440    private Runnable mMakeNavigationBarVisibleRunnable = new Runnable() {
441        @Override
442        public void run() {
443            mPhoneStatusBar.getNavigationBarView().setVisibility(View.VISIBLE);
444        }
445    };
446
447    protected void updateStates() {
448        int vis = mContainer.getSystemUiVisibility();
449        boolean showing = mShowing;
450        boolean occluded = mOccluded;
451        boolean bouncerShowing = mBouncer.isShowing();
452        boolean bouncerDismissible = !mBouncer.isFullscreenBouncer();
453        boolean remoteInputActive = mRemoteInputActive;
454
455        if ((bouncerDismissible || !showing || remoteInputActive) !=
456                (mLastBouncerDismissible || !mLastShowing || mLastRemoteInputActive)
457                || mFirstUpdate) {
458            if (bouncerDismissible || !showing || remoteInputActive) {
459                mContainer.setSystemUiVisibility(vis & ~View.STATUS_BAR_DISABLE_BACK);
460            } else {
461                mContainer.setSystemUiVisibility(vis | View.STATUS_BAR_DISABLE_BACK);
462            }
463        }
464
465        boolean navBarVisible = isNavBarVisible();
466        boolean lastNavBarVisible = getLastNavBarVisible();
467        if (navBarVisible != lastNavBarVisible || mFirstUpdate) {
468            if (mPhoneStatusBar.getNavigationBarView() != null) {
469                if (navBarVisible) {
470                    long delay = getNavBarShowDelay();
471                    if (delay == 0) {
472                        mMakeNavigationBarVisibleRunnable.run();
473                    } else {
474                        mContainer.postOnAnimationDelayed(mMakeNavigationBarVisibleRunnable,
475                                delay);
476                    }
477                } else {
478                    mContainer.removeCallbacks(mMakeNavigationBarVisibleRunnable);
479                    mPhoneStatusBar.getNavigationBarView().setVisibility(View.GONE);
480                }
481            }
482        }
483
484        if (bouncerShowing != mLastBouncerShowing || mFirstUpdate) {
485            mStatusBarWindowManager.setBouncerShowing(bouncerShowing);
486            mPhoneStatusBar.setBouncerShowing(bouncerShowing);
487            mScrimController.setBouncerShowing(bouncerShowing);
488        }
489
490        KeyguardUpdateMonitor updateMonitor = KeyguardUpdateMonitor.getInstance(mContext);
491        if ((showing && !occluded) != (mLastShowing && !mLastOccluded) || mFirstUpdate) {
492            updateMonitor.onKeyguardVisibilityChanged(showing && !occluded);
493        }
494        if (bouncerShowing != mLastBouncerShowing || mFirstUpdate) {
495            updateMonitor.sendKeyguardBouncerChanged(bouncerShowing);
496        }
497
498        mFirstUpdate = false;
499        mLastShowing = showing;
500        mLastOccluded = occluded;
501        mLastBouncerShowing = bouncerShowing;
502        mLastBouncerDismissible = bouncerDismissible;
503        mLastRemoteInputActive = remoteInputActive;
504
505        mPhoneStatusBar.onKeyguardViewManagerStatesUpdated();
506    }
507
508    /**
509     * @return Whether the navigation bar should be made visible based on the current state.
510     */
511    protected boolean isNavBarVisible() {
512        return !(mShowing && !mOccluded) || mBouncer.isShowing() || mRemoteInputActive;
513    }
514
515    /**
516     * @return Whether the navigation bar was made visible based on the last known state.
517     */
518    protected boolean getLastNavBarVisible() {
519        return !(mLastShowing && !mLastOccluded) || mLastBouncerShowing || mLastRemoteInputActive;
520    }
521
522    public boolean shouldDismissOnMenuPressed() {
523        return mBouncer.shouldDismissOnMenuPressed();
524    }
525
526    public boolean interceptMediaKey(KeyEvent event) {
527        return mBouncer.interceptMediaKey(event);
528    }
529
530    public void onActivityDrawn() {
531        if (mPhoneStatusBar.isCollapsing()) {
532            mPhoneStatusBar.addPostCollapseAction(new Runnable() {
533                @Override
534                public void run() {
535                    mViewMediatorCallback.readyForKeyguardDone();
536                }
537            });
538        } else {
539            mViewMediatorCallback.readyForKeyguardDone();
540        }
541    }
542
543    public boolean shouldDisableWindowAnimationsForUnlock() {
544        return mPhoneStatusBar.isInLaunchTransition();
545    }
546
547    public boolean isGoingToNotificationShade() {
548        return mPhoneStatusBar.isGoingToNotificationShade();
549    }
550
551    public boolean isSecure(int userId) {
552        return mBouncer.isSecure() || mLockPatternUtils.isSecure(userId);
553    }
554
555    public boolean isInputRestricted() {
556        return mViewMediatorCallback.isInputRestricted();
557    }
558
559    public void keyguardGoingAway() {
560        mPhoneStatusBar.keyguardGoingAway();
561    }
562
563    public void animateCollapsePanels(float speedUpFactor) {
564        mPhoneStatusBar.animateCollapsePanels(CommandQueue.FLAG_EXCLUDE_NONE, true /* force */,
565                false /* delayed */, speedUpFactor);
566    }
567
568    /**
569     * Notifies that the user has authenticated by other means than using the bouncer, for example,
570     * fingerprint.
571     */
572    public void notifyKeyguardAuthenticated(boolean strongAuth) {
573        mBouncer.notifyKeyguardAuthenticated(strongAuth);
574    }
575
576    public void showBouncerMessage(String message, int color) {
577        mBouncer.showMessage(message, color);
578    }
579
580    public ViewRootImpl getViewRootImpl() {
581        return mPhoneStatusBar.getStatusBarView().getViewRootImpl();
582    }
583}
584