Home | History | Annotate | Download | only in launcher3 
      1 /*
      2  * Copyright (C) 2015 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.launcher3;
     18 
     19 import android.animation.Animator;
     20 import android.animation.AnimatorListenerAdapter;
     21 import android.animation.AnimatorSet;
     22 import android.animation.ObjectAnimator;
     23 import android.animation.TimeInterpolator;
     24 import android.animation.ValueAnimator;
     25 import android.content.Context;
     26 import android.content.res.Resources;
     27 import android.view.View;
     28 import android.view.ViewGroup;
     29 import android.view.accessibility.AccessibilityManager;
     30 import android.view.accessibility.AccessibilityNodeInfo;
     31 import android.view.animation.DecelerateInterpolator;
     32 
     33 import com.android.launcher3.util.Thunk;
     34 
     35 import java.util.HashMap;
     36 
     37 /**
     38  * A convenience class to update a view's visibility state after an alpha animation.
     39  */
     40 class AlphaUpdateListener extends AnimatorListenerAdapter implements ValueAnimator.AnimatorUpdateListener {
     41     private static final float ALPHA_CUTOFF_THRESHOLD = 0.01f;
     42 
     43     private View mView;
     44     private boolean mAccessibilityEnabled;
     45 
     46     public AlphaUpdateListener(View v, boolean accessibilityEnabled) {
     47         mView = v;
     48         mAccessibilityEnabled = accessibilityEnabled;
     49     }
     50 
     51     @Override
     52     public void onAnimationUpdate(ValueAnimator arg0) {
     53         updateVisibility(mView, mAccessibilityEnabled);
     54     }
     55 
     56     public static void updateVisibility(View view, boolean accessibilityEnabled) {
     57         // We want to avoid the extra layout pass by setting the views to GONE unless
     58         // accessibility is on, in which case not setting them to GONE causes a glitch.
     59         int invisibleState = accessibilityEnabled ? View.GONE : View.INVISIBLE;
     60         if (view.getAlpha() < ALPHA_CUTOFF_THRESHOLD && view.getVisibility() != invisibleState) {
     61             view.setVisibility(invisibleState);
     62         } else if (view.getAlpha() > ALPHA_CUTOFF_THRESHOLD
     63                 && view.getVisibility() != View.VISIBLE) {
     64             view.setVisibility(View.VISIBLE);
     65         }
     66     }
     67 
     68     @Override
     69     public void onAnimationEnd(Animator arg0) {
     70         updateVisibility(mView, mAccessibilityEnabled);
     71     }
     72 
     73     @Override
     74     public void onAnimationStart(Animator arg0) {
     75         // We want the views to be visible for animation, so fade-in/out is visible
     76         mView.setVisibility(View.VISIBLE);
     77     }
     78 }
     79 
     80 /**
     81  * This interpolator emulates the rate at which the perceived scale of an object changes
     82  * as its distance from a camera increases. When this interpolator is applied to a scale
     83  * animation on a view, it evokes the sense that the object is shrinking due to moving away
     84  * from the camera.
     85  */
     86 class ZInterpolator implements TimeInterpolator {
     87     private float focalLength;
     88 
     89     public ZInterpolator(float foc) {
     90         focalLength = foc;
     91     }
     92 
     93     public float getInterpolation(float input) {
     94         return (1.0f - focalLength / (focalLength + input)) /
     95                 (1.0f - focalLength / (focalLength + 1.0f));
     96     }
     97 }
     98 
     99 /**
    100  * The exact reverse of ZInterpolator.
    101  */
    102 class InverseZInterpolator implements TimeInterpolator {
    103     private ZInterpolator zInterpolator;
    104     public InverseZInterpolator(float foc) {
    105         zInterpolator = new ZInterpolator(foc);
    106     }
    107     public float getInterpolation(float input) {
    108         return 1 - zInterpolator.getInterpolation(1 - input);
    109     }
    110 }
    111 
    112 /**
    113  * InverseZInterpolator compounded with an ease-out.
    114  */
    115 class ZoomInInterpolator implements TimeInterpolator {
    116     private final InverseZInterpolator inverseZInterpolator = new InverseZInterpolator(0.35f);
    117     private final DecelerateInterpolator decelerate = new DecelerateInterpolator(3.0f);
    118 
    119     public float getInterpolation(float input) {
    120         return decelerate.getInterpolation(inverseZInterpolator.getInterpolation(input));
    121     }
    122 }
    123 
    124 /**
    125  * Stores the transition states for convenience.
    126  */
    127 class TransitionStates {
    128 
    129     // Raw states
    130     final boolean oldStateIsNormal;
    131     final boolean oldStateIsSpringLoaded;
    132     final boolean oldStateIsNormalHidden;
    133     final boolean oldStateIsOverviewHidden;
    134     final boolean oldStateIsOverview;
    135 
    136     final boolean stateIsNormal;
    137     final boolean stateIsSpringLoaded;
    138     final boolean stateIsNormalHidden;
    139     final boolean stateIsOverviewHidden;
    140     final boolean stateIsOverview;
    141 
    142     // Convenience members
    143     final boolean workspaceToAllApps;
    144     final boolean overviewToAllApps;
    145     final boolean allAppsToWorkspace;
    146     final boolean workspaceToOverview;
    147     final boolean overviewToWorkspace;
    148 
    149     public TransitionStates(final Workspace.State fromState, final Workspace.State toState) {
    150         oldStateIsNormal = (fromState == Workspace.State.NORMAL);
    151         oldStateIsSpringLoaded = (fromState == Workspace.State.SPRING_LOADED);
    152         oldStateIsNormalHidden = (fromState == Workspace.State.NORMAL_HIDDEN);
    153         oldStateIsOverviewHidden = (fromState == Workspace.State.OVERVIEW_HIDDEN);
    154         oldStateIsOverview = (fromState == Workspace.State.OVERVIEW);
    155 
    156         stateIsNormal = (toState == Workspace.State.NORMAL);
    157         stateIsSpringLoaded = (toState == Workspace.State.SPRING_LOADED);
    158         stateIsNormalHidden = (toState == Workspace.State.NORMAL_HIDDEN);
    159         stateIsOverviewHidden = (toState == Workspace.State.OVERVIEW_HIDDEN);
    160         stateIsOverview = (toState == Workspace.State.OVERVIEW);
    161 
    162         workspaceToOverview = (oldStateIsNormal && stateIsOverview);
    163         workspaceToAllApps = (oldStateIsNormal && stateIsNormalHidden);
    164         overviewToWorkspace = (oldStateIsOverview && stateIsNormal);
    165         overviewToAllApps = (oldStateIsOverview && stateIsOverviewHidden);
    166         allAppsToWorkspace = (stateIsNormalHidden && stateIsNormal);
    167     }
    168 }
    169 
    170 /**
    171  * Manages the animations between each of the workspace states.
    172  */
    173 public class WorkspaceStateTransitionAnimation {
    174 
    175     public static final String TAG = "WorkspaceStateTransitionAnimation";
    176 
    177     public static final int SCROLL_TO_CURRENT_PAGE = -1;
    178     @Thunk static final int BACKGROUND_FADE_OUT_DURATION = 350;
    179 
    180     final @Thunk Launcher mLauncher;
    181     final @Thunk Workspace mWorkspace;
    182 
    183     @Thunk AnimatorSet mStateAnimator;
    184     @Thunk float[] mOldBackgroundAlphas;
    185     @Thunk float[] mOldAlphas;
    186     @Thunk float[] mNewBackgroundAlphas;
    187     @Thunk float[] mNewAlphas;
    188     @Thunk int mLastChildCount = -1;
    189 
    190     @Thunk float mCurrentScale;
    191     @Thunk float mNewScale;
    192 
    193     @Thunk final ZoomInInterpolator mZoomInInterpolator = new ZoomInInterpolator();
    194 
    195     @Thunk float mSpringLoadedShrinkFactor;
    196     @Thunk float mOverviewModeShrinkFactor;
    197     @Thunk float mWorkspaceScrimAlpha;
    198     @Thunk int mAllAppsTransitionTime;
    199     @Thunk int mOverviewTransitionTime;
    200     @Thunk int mOverlayTransitionTime;
    201     @Thunk boolean mWorkspaceFadeInAdjacentScreens;
    202 
    203     public WorkspaceStateTransitionAnimation(Launcher launcher, Workspace workspace) {
    204         mLauncher = launcher;
    205         mWorkspace = workspace;
    206 
    207         DeviceProfile grid = mLauncher.getDeviceProfile();
    208         Resources res = launcher.getResources();
    209         mAllAppsTransitionTime = res.getInteger(R.integer.config_allAppsTransitionTime);
    210         mOverviewTransitionTime = res.getInteger(R.integer.config_overviewTransitionTime);
    211         mOverlayTransitionTime = res.getInteger(R.integer.config_overlayTransitionTime);
    212         mSpringLoadedShrinkFactor =
    213                 res.getInteger(R.integer.config_workspaceSpringLoadShrinkPercentage) / 100f;
    214         mWorkspaceScrimAlpha = res.getInteger(R.integer.config_workspaceScrimAlpha) / 100f;
    215         mOverviewModeShrinkFactor = grid.getOverviewModeScale(Utilities.isRtl(res));
    216         mWorkspaceFadeInAdjacentScreens = grid.shouldFadeAdjacentWorkspaceScreens();
    217     }
    218 
    219     public AnimatorSet getAnimationToState(Workspace.State fromState, Workspace.State toState,
    220             int toPage, boolean animated, boolean hasOverlaySearchBar,
    221             HashMap<View, Integer> layerViews) {
    222         AccessibilityManager am = (AccessibilityManager)
    223                 mLauncher.getSystemService(Context.ACCESSIBILITY_SERVICE);
    224         final boolean accessibilityEnabled = am.isEnabled();
    225         TransitionStates states = new TransitionStates(fromState, toState);
    226         int duration = getAnimationDuration(states);
    227         animateWorkspace(states, toPage, animated, duration, layerViews,
    228                 accessibilityEnabled);
    229         animateSearchBar(states, animated, duration, hasOverlaySearchBar, layerViews,
    230                 accessibilityEnabled);
    231         animateBackgroundGradient(states, animated, BACKGROUND_FADE_OUT_DURATION);
    232         return mStateAnimator;
    233     }
    234 
    235     public float getFinalScale() {
    236         return mNewScale;
    237     }
    238 
    239     /**
    240      * Reinitializes the arrays that we need for the animations on each page.
    241      */
    242     private void reinitializeAnimationArrays() {
    243         final int childCount = mWorkspace.getChildCount();
    244         if (mLastChildCount == childCount) return;
    245 
    246         mOldBackgroundAlphas = new float[childCount];
    247         mOldAlphas = new float[childCount];
    248         mNewBackgroundAlphas = new float[childCount];
    249         mNewAlphas = new float[childCount];
    250     }
    251 
    252     /**
    253      * Returns the proper animation duration for a transition.
    254      */
    255     private int getAnimationDuration(TransitionStates states) {
    256         if (states.workspaceToAllApps || states.overviewToAllApps) {
    257             return mAllAppsTransitionTime;
    258         } else if (states.workspaceToOverview || states.overviewToWorkspace) {
    259             return mOverviewTransitionTime;
    260         } else {
    261             return mOverlayTransitionTime;
    262         }
    263     }
    264 
    265     /**
    266      * Starts a transition animation for the workspace.
    267      */
    268     private void animateWorkspace(final TransitionStates states, int toPage, final boolean animated,
    269                                   final int duration, final HashMap<View, Integer> layerViews,
    270                                   final boolean accessibilityEnabled) {
    271         // Reinitialize animation arrays for the current workspace state
    272         reinitializeAnimationArrays();
    273 
    274         // Cancel existing workspace animations and create a new animator set if requested
    275         cancelAnimation();
    276         if (animated) {
    277             mStateAnimator = LauncherAnimUtils.createAnimatorSet();
    278         }
    279 
    280         // Update the workspace state
    281         float finalBackgroundAlpha = (states.stateIsSpringLoaded || states.stateIsOverview) ?
    282                 1.0f : 0f;
    283         float finalHotseatAndPageIndicatorAlpha = (states.stateIsNormal || states.stateIsSpringLoaded) ?
    284                 1f : 0f;
    285         float finalOverviewPanelAlpha = states.stateIsOverview ? 1f : 0f;
    286         float finalWorkspaceTranslationY = states.stateIsOverview || states.stateIsOverviewHidden ?
    287                 mWorkspace.getOverviewModeTranslationY() : 0;
    288 
    289         final int childCount = mWorkspace.getChildCount();
    290         final int customPageCount = mWorkspace.numCustomPages();
    291 
    292         mNewScale = 1.0f;
    293 
    294         if (states.oldStateIsOverview) {
    295             mWorkspace.disableFreeScroll();
    296         } else if (states.stateIsOverview) {
    297             mWorkspace.enableFreeScroll();
    298         }
    299 
    300         if (!states.stateIsNormal) {
    301             if (states.stateIsSpringLoaded) {
    302                 mNewScale = mSpringLoadedShrinkFactor;
    303             } else if (states.stateIsOverview || states.stateIsOverviewHidden) {
    304                 mNewScale = mOverviewModeShrinkFactor;
    305             }
    306         }
    307 
    308         if (toPage == SCROLL_TO_CURRENT_PAGE) {
    309             toPage = mWorkspace.getPageNearestToCenterOfScreen();
    310         }
    311         mWorkspace.snapToPage(toPage, duration, mZoomInInterpolator);
    312 
    313         for (int i = 0; i < childCount; i++) {
    314             final CellLayout cl = (CellLayout) mWorkspace.getChildAt(i);
    315             boolean isCurrentPage = (i == toPage);
    316             float initialAlpha = cl.getShortcutsAndWidgets().getAlpha();
    317             float finalAlpha;
    318             if (states.stateIsNormalHidden || states.stateIsOverviewHidden) {
    319                 finalAlpha = 0f;
    320             } else if (states.stateIsNormal && mWorkspaceFadeInAdjacentScreens) {
    321                 finalAlpha = (i == toPage || i < customPageCount) ? 1f : 0f;
    322             } else {
    323                 finalAlpha = 1f;
    324             }
    325 
    326             // If we are animating to/from the small state, then hide the side pages and fade the
    327             // current page in
    328             if (!mWorkspace.isSwitchingState()) {
    329                 if (states.workspaceToAllApps || states.allAppsToWorkspace) {
    330                     if (states.allAppsToWorkspace && isCurrentPage) {
    331                         initialAlpha = 0f;
    332                     } else if (!isCurrentPage) {
    333                         initialAlpha = finalAlpha = 0f;
    334                     }
    335                     cl.setShortcutAndWidgetAlpha(initialAlpha);
    336                 }
    337             }
    338 
    339             mOldAlphas[i] = initialAlpha;
    340             mNewAlphas[i] = finalAlpha;
    341             if (animated) {
    342                 mOldBackgroundAlphas[i] = cl.getBackgroundAlpha();
    343                 mNewBackgroundAlphas[i] = finalBackgroundAlpha;
    344             } else {
    345                 cl.setBackgroundAlpha(finalBackgroundAlpha);
    346                 cl.setShortcutAndWidgetAlpha(finalAlpha);
    347             }
    348         }
    349 
    350         final ViewGroup overviewPanel = mLauncher.getOverviewPanel();
    351         final View hotseat = mLauncher.getHotseat();
    352         final View pageIndicator = mWorkspace.getPageIndicator();
    353         if (animated) {
    354             LauncherViewPropertyAnimator scale = new LauncherViewPropertyAnimator(mWorkspace);
    355             scale.scaleX(mNewScale)
    356                     .scaleY(mNewScale)
    357                     .translationY(finalWorkspaceTranslationY)
    358                     .setDuration(duration)
    359                     .setInterpolator(mZoomInInterpolator);
    360             mStateAnimator.play(scale);
    361             for (int index = 0; index < childCount; index++) {
    362                 final int i = index;
    363                 final CellLayout cl = (CellLayout) mWorkspace.getChildAt(i);
    364                 float currentAlpha = cl.getShortcutsAndWidgets().getAlpha();
    365                 if (mOldAlphas[i] == 0 && mNewAlphas[i] == 0) {
    366                     cl.setBackgroundAlpha(mNewBackgroundAlphas[i]);
    367                     cl.setShortcutAndWidgetAlpha(mNewAlphas[i]);
    368                 } else {
    369                     if (layerViews != null) {
    370                         layerViews.put(cl, LauncherStateTransitionAnimation.BUILD_LAYER);
    371                     }
    372                     if (mOldAlphas[i] != mNewAlphas[i] || currentAlpha != mNewAlphas[i]) {
    373                         LauncherViewPropertyAnimator alphaAnim =
    374                                 new LauncherViewPropertyAnimator(cl.getShortcutsAndWidgets());
    375                         alphaAnim.alpha(mNewAlphas[i])
    376                                 .setDuration(duration)
    377                                 .setInterpolator(mZoomInInterpolator);
    378                         mStateAnimator.play(alphaAnim);
    379                     }
    380                     if (mOldBackgroundAlphas[i] != 0 ||
    381                             mNewBackgroundAlphas[i] != 0) {
    382                         ValueAnimator bgAnim = ObjectAnimator.ofFloat(cl, "backgroundAlpha",
    383                                 mOldBackgroundAlphas[i], mNewBackgroundAlphas[i]);
    384                                 LauncherAnimUtils.ofFloat(cl, 0f, 1f);
    385                         bgAnim.setInterpolator(mZoomInInterpolator);
    386                         bgAnim.setDuration(duration);
    387                         mStateAnimator.play(bgAnim);
    388                     }
    389                 }
    390             }
    391             Animator pageIndicatorAlpha;
    392             if (pageIndicator != null) {
    393                 pageIndicatorAlpha = new LauncherViewPropertyAnimator(pageIndicator)
    394                         .alpha(finalHotseatAndPageIndicatorAlpha).withLayer();
    395                 pageIndicatorAlpha.addListener(new AlphaUpdateListener(pageIndicator,
    396                         accessibilityEnabled));
    397             } else {
    398                 // create a dummy animation so we don't need to do null checks later
    399                 pageIndicatorAlpha = ValueAnimator.ofFloat(0, 0);
    400             }
    401 
    402             LauncherViewPropertyAnimator hotseatAlpha = new LauncherViewPropertyAnimator(hotseat)
    403                     .alpha(finalHotseatAndPageIndicatorAlpha);
    404             hotseatAlpha.addListener(new AlphaUpdateListener(hotseat, accessibilityEnabled));
    405 
    406             LauncherViewPropertyAnimator overviewPanelAlpha =
    407                     new LauncherViewPropertyAnimator(overviewPanel).alpha(finalOverviewPanelAlpha);
    408             overviewPanelAlpha.addListener(new AlphaUpdateListener(overviewPanel,
    409                     accessibilityEnabled));
    410 
    411             // For animation optimations, we may need to provide the Launcher transition
    412             // with a set of views on which to force build layers in certain scenarios.
    413             hotseat.setLayerType(View.LAYER_TYPE_HARDWARE, null);
    414             overviewPanel.setLayerType(View.LAYER_TYPE_HARDWARE, null);
    415             if (layerViews != null) {
    416                 // If layerViews is not null, we add these views, and indicate that
    417                 // the caller can manage layer state.
    418                 layerViews.put(hotseat, LauncherStateTransitionAnimation.BUILD_AND_SET_LAYER);
    419                 layerViews.put(overviewPanel, LauncherStateTransitionAnimation.BUILD_AND_SET_LAYER);
    420             } else {
    421                 // Otherwise let the animator handle layer management.
    422                 hotseatAlpha.withLayer();
    423                 overviewPanelAlpha.withLayer();
    424             }
    425 
    426             if (states.workspaceToOverview) {
    427                 pageIndicatorAlpha.setInterpolator(new DecelerateInterpolator(2));
    428                 hotseatAlpha.setInterpolator(new DecelerateInterpolator(2));
    429                 overviewPanelAlpha.setInterpolator(null);
    430             } else if (states.overviewToWorkspace) {
    431                 pageIndicatorAlpha.setInterpolator(null);
    432                 hotseatAlpha.setInterpolator(null);
    433                 overviewPanelAlpha.setInterpolator(new DecelerateInterpolator(2));
    434             }
    435 
    436             overviewPanelAlpha.setDuration(duration);
    437             pageIndicatorAlpha.setDuration(duration);
    438             hotseatAlpha.setDuration(duration);
    439 
    440             mStateAnimator.play(overviewPanelAlpha);
    441             mStateAnimator.play(hotseatAlpha);
    442             mStateAnimator.play(pageIndicatorAlpha);
    443             mStateAnimator.addListener(new AnimatorListenerAdapter() {
    444                 @Override
    445                 public void onAnimationEnd(Animator animation) {
    446                     mStateAnimator = null;
    447 
    448                     if (accessibilityEnabled && overviewPanel.getVisibility() == View.VISIBLE) {
    449                         overviewPanel.getChildAt(0).performAccessibilityAction(
    450                                 AccessibilityNodeInfo.ACTION_ACCESSIBILITY_FOCUS, null);
    451                     }
    452                 }
    453             });
    454         } else {
    455             overviewPanel.setAlpha(finalOverviewPanelAlpha);
    456             AlphaUpdateListener.updateVisibility(overviewPanel, accessibilityEnabled);
    457             hotseat.setAlpha(finalHotseatAndPageIndicatorAlpha);
    458             AlphaUpdateListener.updateVisibility(hotseat, accessibilityEnabled);
    459             if (pageIndicator != null) {
    460                 pageIndicator.setAlpha(finalHotseatAndPageIndicatorAlpha);
    461                 AlphaUpdateListener.updateVisibility(pageIndicator, accessibilityEnabled);
    462             }
    463             mWorkspace.updateCustomContentVisibility();
    464             mWorkspace.setScaleX(mNewScale);
    465             mWorkspace.setScaleY(mNewScale);
    466             mWorkspace.setTranslationY(finalWorkspaceTranslationY);
    467 
    468             if (accessibilityEnabled && overviewPanel.getVisibility() == View.VISIBLE) {
    469                 overviewPanel.getChildAt(0).performAccessibilityAction(
    470                         AccessibilityNodeInfo.ACTION_ACCESSIBILITY_FOCUS, null);
    471             }
    472         }
    473     }
    474 
    475     /**
    476      * Coordinates with the workspace animation to animate the search bar.
    477      *
    478      * TODO: This should really be coordinated with the SearchDropTargetBar, otherwise the
    479      *       bar has no idea that it is hidden, and this has no idea what state the bar is
    480      *       actually in.
    481      */
    482     private void animateSearchBar(TransitionStates states, boolean animated, int duration,
    483             boolean hasOverlaySearchBar, final HashMap<View, Integer> layerViews,
    484             final boolean accessibilityEnabled) {
    485 
    486         // The search bar is only visible in the workspace
    487         final View searchBar = mLauncher.getOrCreateQsbBar();
    488         if (searchBar != null) {
    489             final boolean searchBarWillBeShown = states.stateIsNormal;
    490             final float finalSearchBarAlpha = searchBarWillBeShown ? 1f : 0f;
    491             if (animated) {
    492                 if (hasOverlaySearchBar) {
    493                     // If there is an overlay search bar, then we will coordinate with it.
    494                     mStateAnimator.addListener(new AnimatorListenerAdapter() {
    495                         @Override
    496                         public void onAnimationStart(Animator animation) {
    497                             // If we are transitioning to a visible search bar, show it immediately
    498                             // and let the overlay search bar has faded out
    499                             if (searchBarWillBeShown) {
    500                                 searchBar.setAlpha(finalSearchBarAlpha);
    501                                 AlphaUpdateListener.updateVisibility(searchBar, accessibilityEnabled);
    502                             }
    503                         }
    504 
    505                         @Override
    506                         public void onAnimationEnd(Animator animation) {
    507                             // If we are transitioning to a hidden search bar, hide it only after
    508                             // the overlay search bar has faded in
    509                             if (!searchBarWillBeShown) {
    510                                 searchBar.setAlpha(finalSearchBarAlpha);
    511                                 AlphaUpdateListener.updateVisibility(searchBar, accessibilityEnabled);
    512                             }
    513                         }
    514                     });
    515                 } else {
    516                     // Otherwise, we can just do the normal animation
    517                     LauncherViewPropertyAnimator searchBarAlpha =
    518                             new LauncherViewPropertyAnimator(searchBar).alpha(finalSearchBarAlpha);
    519                     searchBarAlpha.addListener(new AlphaUpdateListener(searchBar,
    520                             accessibilityEnabled));
    521                     searchBar.setLayerType(View.LAYER_TYPE_HARDWARE, null);
    522                     if (layerViews != null) {
    523                         // If layerViews is not null, we add these views, and indicate that
    524                         // the caller can manage layer state.
    525                         layerViews.put(searchBar, LauncherStateTransitionAnimation.BUILD_AND_SET_LAYER);
    526                     } else {
    527                         // Otherwise let the animator handle layer management.
    528                         searchBarAlpha.withLayer();
    529                     }
    530                     searchBarAlpha.setDuration(duration);
    531                     mStateAnimator.play(searchBarAlpha);
    532                 }
    533             } else {
    534                 // Set the search bar state immediately
    535                 searchBar.setAlpha(finalSearchBarAlpha);
    536                 AlphaUpdateListener.updateVisibility(searchBar, accessibilityEnabled);
    537             }
    538         }
    539     }
    540 
    541     /**
    542      * Animates the background scrim. Add to the state animator to prevent jankiness.
    543      *
    544      * @param finalAlpha the final alpha for the background scrim
    545      * @param animated whether or not to set the background alpha immediately
    546      * @duration duration of the animation
    547      */
    548     private void animateBackgroundGradient(TransitionStates states,
    549             boolean animated, int duration) {
    550 
    551         final DragLayer dragLayer = mLauncher.getDragLayer();
    552         final float startAlpha = dragLayer.getBackgroundAlpha();
    553         float finalAlpha = states.stateIsNormal ? 0 : mWorkspaceScrimAlpha;
    554 
    555         if (finalAlpha != startAlpha) {
    556             if (animated) {
    557                 // These properties refer to the background protection gradient used for AllApps
    558                 // and Widget tray.
    559                 ValueAnimator bgFadeOutAnimation =
    560                         LauncherAnimUtils.ofFloat(mWorkspace, startAlpha, finalAlpha);
    561                 bgFadeOutAnimation.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
    562                     @Override
    563                     public void onAnimationUpdate(ValueAnimator animation) {
    564                         dragLayer.setBackgroundAlpha(
    565                                 ((Float)animation.getAnimatedValue()).floatValue());
    566                     }
    567                 });
    568                 bgFadeOutAnimation.setInterpolator(new DecelerateInterpolator(1.5f));
    569                 bgFadeOutAnimation.setDuration(duration);
    570                 mStateAnimator.play(bgFadeOutAnimation);
    571             } else {
    572                 dragLayer.setBackgroundAlpha(finalAlpha);
    573             }
    574         }
    575     }
    576 
    577     /**
    578      * Cancels the current animation.
    579      */
    580     private void cancelAnimation() {
    581         if (mStateAnimator != null) {
    582             mStateAnimator.setDuration(0);
    583             mStateAnimator.cancel();
    584         }
    585         mStateAnimator = null;
    586     }
    587 }