Home | History | Annotate | Download | only in phone 
      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 
     17 package com.android.systemui.statusbar.phone;
     18 
     19 import android.animation.Animator;
     20 import android.animation.AnimatorListenerAdapter;
     21 import android.animation.ValueAnimator;
     22 import android.annotation.NonNull;
     23 import android.content.Context;
     24 import android.graphics.Color;
     25 import android.util.Log;
     26 import android.view.View;
     27 import android.view.ViewTreeObserver;
     28 import android.view.animation.AnimationUtils;
     29 import android.view.animation.DecelerateInterpolator;
     30 import android.view.animation.Interpolator;
     31 
     32 import com.android.systemui.R;
     33 import com.android.systemui.doze.DozeHost;
     34 import com.android.systemui.doze.DozeLog;
     35 import com.android.systemui.statusbar.BackDropView;
     36 import com.android.systemui.statusbar.ScrimView;
     37 
     38 /**
     39  * Controls both the scrim behind the notifications and in front of the notifications (when a
     40  * security method gets shown).
     41  */
     42 public class ScrimController implements ViewTreeObserver.OnPreDrawListener {
     43     private static final String TAG = "ScrimController";
     44     private static final boolean DEBUG = Log.isLoggable(TAG, Log.DEBUG);
     45 
     46     public static final long ANIMATION_DURATION = 220;
     47 
     48     private static final float SCRIM_BEHIND_ALPHA = 0.62f;
     49     private static final float SCRIM_BEHIND_ALPHA_KEYGUARD = 0.55f;
     50     private static final float SCRIM_BEHIND_ALPHA_UNLOCKING = 0.2f;
     51     private static final float SCRIM_IN_FRONT_ALPHA = 0.75f;
     52     private static final int TAG_KEY_ANIM = R.id.scrim;
     53 
     54     private final ScrimView mScrimBehind;
     55     private final ScrimView mScrimInFront;
     56     private final UnlockMethodCache mUnlockMethodCache;
     57     private final DozeParameters mDozeParameters;
     58 
     59     private boolean mKeyguardShowing;
     60     private float mFraction;
     61 
     62     private boolean mDarkenWhileDragging;
     63     private boolean mBouncerShowing;
     64     private boolean mAnimateChange;
     65     private boolean mUpdatePending;
     66     private boolean mExpanding;
     67     private boolean mAnimateKeyguardFadingOut;
     68     private long mDurationOverride = -1;
     69     private long mAnimationDelay;
     70     private Runnable mOnAnimationFinished;
     71     private boolean mAnimationStarted;
     72     private boolean mDozing;
     73     private DozeHost.PulseCallback mPulseCallback;
     74     private final Interpolator mInterpolator = new DecelerateInterpolator();
     75     private final Interpolator mLinearOutSlowInInterpolator;
     76     private BackDropView mBackDropView;
     77     private boolean mScrimSrcEnabled;
     78 
     79     public ScrimController(ScrimView scrimBehind, ScrimView scrimInFront, boolean scrimSrcEnabled) {
     80         mScrimBehind = scrimBehind;
     81         mScrimInFront = scrimInFront;
     82         final Context context = scrimBehind.getContext();
     83         mUnlockMethodCache = UnlockMethodCache.getInstance(context);
     84         mLinearOutSlowInInterpolator = AnimationUtils.loadInterpolator(context,
     85                 android.R.interpolator.linear_out_slow_in);
     86         mDozeParameters = new DozeParameters(context);
     87         mScrimSrcEnabled = scrimSrcEnabled;
     88     }
     89 
     90     public void setKeyguardShowing(boolean showing) {
     91         mKeyguardShowing = showing;
     92         scheduleUpdate();
     93     }
     94 
     95     public void onTrackingStarted() {
     96         mExpanding = true;
     97         mDarkenWhileDragging = !mUnlockMethodCache.isMethodInsecure();
     98     }
     99 
    100     public void onExpandingFinished() {
    101         mExpanding = false;
    102     }
    103 
    104     public void setPanelExpansion(float fraction) {
    105         if (mFraction != fraction) {
    106             mFraction = fraction;
    107             scheduleUpdate();
    108         }
    109     }
    110 
    111     public void setBouncerShowing(boolean showing) {
    112         mBouncerShowing = showing;
    113         mAnimateChange = !mExpanding;
    114         scheduleUpdate();
    115     }
    116 
    117     public void animateKeyguardFadingOut(long delay, long duration, Runnable onAnimationFinished) {
    118         mAnimateKeyguardFadingOut = true;
    119         mDurationOverride = duration;
    120         mAnimationDelay = delay;
    121         mAnimateChange = true;
    122         mOnAnimationFinished = onAnimationFinished;
    123         scheduleUpdate();
    124     }
    125 
    126     public void animateGoingToFullShade(long delay, long duration) {
    127         mDurationOverride = duration;
    128         mAnimationDelay = delay;
    129         mAnimateChange = true;
    130         scheduleUpdate();
    131     }
    132 
    133     public void setDozing(boolean dozing) {
    134         if (mDozing == dozing) return;
    135         mDozing = dozing;
    136         if (!mDozing) {
    137             cancelPulsing();
    138             mAnimateChange = true;
    139         } else {
    140             mAnimateChange = false;
    141         }
    142         scheduleUpdate();
    143     }
    144 
    145     /** When dozing, fade screen contents in and out using the front scrim. */
    146     public void pulse(@NonNull DozeHost.PulseCallback callback) {
    147         if (callback == null) {
    148             throw new IllegalArgumentException("callback must not be null");
    149         }
    150 
    151         if (!mDozing || mPulseCallback != null) {
    152             // Pulse suppressed.
    153             callback.onPulseFinished();
    154             return;
    155         }
    156 
    157         // Begin pulse.  Note that it's very important that the pulse finished callback
    158         // be invoked when we're done so that the caller can drop the pulse wakelock.
    159         mPulseCallback = callback;
    160         mScrimInFront.post(mPulseIn);
    161     }
    162 
    163     public boolean isPulsing() {
    164         return mPulseCallback != null;
    165     }
    166 
    167     private void cancelPulsing() {
    168         if (DEBUG) Log.d(TAG, "Cancel pulsing");
    169 
    170         if (mPulseCallback != null) {
    171             mScrimInFront.removeCallbacks(mPulseIn);
    172             mScrimInFront.removeCallbacks(mPulseOut);
    173             pulseFinished();
    174         }
    175     }
    176 
    177     private void pulseStarted() {
    178         if (mPulseCallback != null) {
    179             mPulseCallback.onPulseStarted();
    180         }
    181     }
    182 
    183     private void pulseFinished() {
    184         if (mPulseCallback != null) {
    185             mPulseCallback.onPulseFinished();
    186             mPulseCallback = null;
    187         }
    188     }
    189 
    190     private void scheduleUpdate() {
    191         if (mUpdatePending) return;
    192 
    193         // Make sure that a frame gets scheduled.
    194         mScrimBehind.invalidate();
    195         mScrimBehind.getViewTreeObserver().addOnPreDrawListener(this);
    196         mUpdatePending = true;
    197     }
    198 
    199     private void updateScrims() {
    200         if (mAnimateKeyguardFadingOut) {
    201             setScrimInFrontColor(0f);
    202             setScrimBehindColor(0f);
    203         } else if (!mKeyguardShowing && !mBouncerShowing) {
    204             updateScrimNormal();
    205             setScrimInFrontColor(0);
    206         } else {
    207             updateScrimKeyguard();
    208         }
    209         mAnimateChange = false;
    210     }
    211 
    212     private void updateScrimKeyguard() {
    213         if (mExpanding && mDarkenWhileDragging) {
    214             float behindFraction = Math.max(0, Math.min(mFraction, 1));
    215             float fraction = 1 - behindFraction;
    216             fraction = (float) Math.pow(fraction, 0.8f);
    217             behindFraction = (float) Math.pow(behindFraction, 0.8f);
    218             setScrimInFrontColor(fraction * SCRIM_IN_FRONT_ALPHA);
    219             setScrimBehindColor(behindFraction * SCRIM_BEHIND_ALPHA_KEYGUARD);
    220         } else if (mBouncerShowing) {
    221             setScrimInFrontColor(SCRIM_IN_FRONT_ALPHA);
    222             setScrimBehindColor(0f);
    223         } else if (mDozing) {
    224             setScrimInFrontColor(1);
    225         } else {
    226             float fraction = Math.max(0, Math.min(mFraction, 1));
    227             setScrimInFrontColor(0f);
    228             setScrimBehindColor(fraction
    229                     * (SCRIM_BEHIND_ALPHA_KEYGUARD - SCRIM_BEHIND_ALPHA_UNLOCKING)
    230                     + SCRIM_BEHIND_ALPHA_UNLOCKING);
    231         }
    232     }
    233 
    234     private void updateScrimNormal() {
    235         float frac = mFraction;
    236         // let's start this 20% of the way down the screen
    237         frac = frac * 1.2f - 0.2f;
    238         if (frac <= 0) {
    239             setScrimBehindColor(0);
    240         } else {
    241             // woo, special effects
    242             final float k = (float)(1f-0.5f*(1f-Math.cos(3.14159f * Math.pow(1f-frac, 2f))));
    243             setScrimBehindColor(k * SCRIM_BEHIND_ALPHA);
    244         }
    245     }
    246 
    247     private void setScrimBehindColor(float alpha) {
    248         setScrimColor(mScrimBehind, alpha);
    249     }
    250 
    251     private void setScrimInFrontColor(float alpha) {
    252         setScrimColor(mScrimInFront, alpha);
    253         if (alpha == 0f) {
    254             mScrimInFront.setClickable(false);
    255         } else {
    256 
    257             // Eat touch events (unless dozing).
    258             mScrimInFront.setClickable(!mDozing);
    259         }
    260     }
    261 
    262     private void setScrimColor(ScrimView scrim, float alpha) {
    263         Object runningAnim = scrim.getTag(TAG_KEY_ANIM);
    264         if (runningAnim instanceof ValueAnimator) {
    265             ((ValueAnimator) runningAnim).cancel();
    266             scrim.setTag(TAG_KEY_ANIM, null);
    267         }
    268         int color = Color.argb((int) (alpha * 255), 0, 0, 0);
    269         if (mAnimateChange) {
    270             startScrimAnimation(scrim, color);
    271         } else {
    272             scrim.setScrimColor(color);
    273         }
    274     }
    275 
    276     private void startScrimAnimation(final ScrimView scrim, int targetColor) {
    277         int current = Color.alpha(scrim.getScrimColor());
    278         int target = Color.alpha(targetColor);
    279         if (current == targetColor) {
    280             return;
    281         }
    282         ValueAnimator anim = ValueAnimator.ofInt(current, target);
    283         anim.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
    284             @Override
    285             public void onAnimationUpdate(ValueAnimator animation) {
    286                 int value = (int) animation.getAnimatedValue();
    287                 scrim.setScrimColor(Color.argb(value, 0, 0, 0));
    288             }
    289         });
    290         anim.setInterpolator(mAnimateKeyguardFadingOut
    291                 ? mLinearOutSlowInInterpolator
    292                 : mInterpolator);
    293         anim.setStartDelay(mAnimationDelay);
    294         anim.setDuration(mDurationOverride != -1 ? mDurationOverride : ANIMATION_DURATION);
    295         anim.addListener(new AnimatorListenerAdapter() {
    296             @Override
    297             public void onAnimationEnd(Animator animation) {
    298                 if (mOnAnimationFinished != null) {
    299                     mOnAnimationFinished.run();
    300                     mOnAnimationFinished = null;
    301                 }
    302                 scrim.setTag(TAG_KEY_ANIM, null);
    303             }
    304         });
    305         anim.start();
    306         scrim.setTag(TAG_KEY_ANIM, anim);
    307         mAnimationStarted = true;
    308     }
    309 
    310     @Override
    311     public boolean onPreDraw() {
    312         mScrimBehind.getViewTreeObserver().removeOnPreDrawListener(this);
    313         mUpdatePending = false;
    314         updateScrims();
    315         mAnimateKeyguardFadingOut = false;
    316         mDurationOverride = -1;
    317         mAnimationDelay = 0;
    318 
    319         // Make sure that we always call the listener even if we didn't start an animation.
    320         if (!mAnimationStarted && mOnAnimationFinished != null) {
    321             mOnAnimationFinished.run();
    322             mOnAnimationFinished = null;
    323         }
    324         mAnimationStarted = false;
    325         return true;
    326     }
    327 
    328     private final Runnable mPulseIn = new Runnable() {
    329         @Override
    330         public void run() {
    331             if (DEBUG) Log.d(TAG, "Pulse in, mDozing=" + mDozing);
    332             if (!mDozing) return;
    333             DozeLog.tracePulseStart();
    334             mDurationOverride = mDozeParameters.getPulseInDuration();
    335             mAnimationDelay = 0;
    336             mAnimateChange = true;
    337             mOnAnimationFinished = mPulseInFinished;
    338             setScrimColor(mScrimInFront, 0);
    339 
    340             // Signal that the pulse is ready to turn the screen on and draw.
    341             pulseStarted();
    342         }
    343     };
    344 
    345     private final Runnable mPulseInFinished = new Runnable() {
    346         @Override
    347         public void run() {
    348             if (DEBUG) Log.d(TAG, "Pulse in finished, mDozing=" + mDozing);
    349             if (!mDozing) return;
    350             mScrimInFront.postDelayed(mPulseOut, mDozeParameters.getPulseVisibleDuration());
    351         }
    352     };
    353 
    354     private final Runnable mPulseOut = new Runnable() {
    355         @Override
    356         public void run() {
    357             if (DEBUG) Log.d(TAG, "Pulse out, mDozing=" + mDozing);
    358             if (!mDozing) return;
    359             mDurationOverride = mDozeParameters.getPulseOutDuration();
    360             mAnimationDelay = 0;
    361             mAnimateChange = true;
    362             mOnAnimationFinished = mPulseOutFinished;
    363             setScrimColor(mScrimInFront, 1);
    364         }
    365     };
    366 
    367     private final Runnable mPulseOutFinished = new Runnable() {
    368         @Override
    369         public void run() {
    370             if (DEBUG) Log.d(TAG, "Pulse out finished");
    371             DozeLog.tracePulseFinish();
    372 
    373             // Signal that the pulse is all finished so we can turn the screen off now.
    374             pulseFinished();
    375         }
    376     };
    377 
    378     public void setBackDropView(BackDropView backDropView) {
    379         mBackDropView = backDropView;
    380         mBackDropView.setOnVisibilityChangedRunnable(new Runnable() {
    381             @Override
    382             public void run() {
    383                 updateScrimBehindDrawingMode();
    384             }
    385         });
    386         updateScrimBehindDrawingMode();
    387     }
    388 
    389     private void updateScrimBehindDrawingMode() {
    390         boolean asSrc = mBackDropView.getVisibility() != View.VISIBLE && mScrimSrcEnabled;
    391         mScrimBehind.setDrawAsSrc(asSrc);
    392     }
    393 }
    394