packages/SystemUI/src/com/android/systemui/recents/views/TaskStackViewScroller.java

   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.recents.views;
  18
  19 import android.animation.Animator;
  20 import android.animation.AnimatorListenerAdapter;
  21 import android.animation.ObjectAnimator;
  22 import android.animation.ValueAnimator;
  23 import android.content.Context;
  24 import android.widget.OverScroller;
  25 import com.android.systemui.recents.RecentsConfiguration;
  26 import com.android.systemui.recents.misc.Utilities;
  27
  28 /* The scrolling logic for a TaskStackView */
  29 public class TaskStackViewScroller {
  30     public interface TaskStackViewScrollerCallbacks {
  31         public void onScrollChanged(float p);
  32     }
  33
  34     RecentsConfiguration mConfig;
  35     TaskStackViewLayoutAlgorithm mLayoutAlgorithm;
  36     TaskStackViewScrollerCallbacks mCb;
  37
  38     float mStackScrollP;
  39
  40     OverScroller mScroller;
  41     ObjectAnimator mScrollAnimator;
  42     float mFinalAnimatedScroll;
  43
  44     public TaskStackViewScroller(Context context, RecentsConfiguration config, TaskStackViewLayoutAlgorithm layoutAlgorithm) {
  45         mConfig = config;
  46         mScroller = new OverScroller(context);
  47         mLayoutAlgorithm = layoutAlgorithm;
  48         setStackScroll(getStackScroll());
  49     }
  50
  51     /** Resets the task scroller. */
  52     void reset() {
  53         mStackScrollP = 0f;
  54     }
  55
  56     /** Sets the callbacks */
  57     void setCallbacks(TaskStackViewScrollerCallbacks cb) {
  58         mCb = cb;
  59     }
  60
  61     /** Gets the current stack scroll */
  62     public float getStackScroll() {
  63         return mStackScrollP;
  64     }
  65
  66     /** Sets the current stack scroll */
  67     public void setStackScroll(float s) {
  68         mStackScrollP = s;
  69         if (mCb != null) {
  70             mCb.onScrollChanged(mStackScrollP);
  71         }
  72     }
  73
  74     /** Sets the current stack scroll without calling the callback. */
  75     void setStackScrollRaw(float s) {
  76         mStackScrollP = s;
  77     }
  78
  79     /**
  80      * Sets the current stack scroll to the initial state when you first enter recents.
  81      * @return whether the stack progress changed.
  82      */
  83     public boolean setStackScrollToInitialState() {
  84         float prevStackScrollP = mStackScrollP;
  85         setStackScroll(getBoundedStackScroll(mLayoutAlgorithm.mInitialScrollP));
  86         return Float.compare(prevStackScrollP, mStackScrollP) != 0;
  87     }
  88
  89     /** Bounds the current scroll if necessary */
  90     public boolean boundScroll() {
  91         float curScroll = getStackScroll();
  92         float newScroll = getBoundedStackScroll(curScroll);
  93         if (Float.compare(newScroll, curScroll) != 0) {
  94             setStackScroll(newScroll);
  95             return true;
  96         }
  97         return false;
  98     }
  99     /** Bounds the current scroll if necessary, but does not synchronize the stack view with the model. */
 100     public boolean boundScrollRaw() {
 101         float curScroll = getStackScroll();
 102         float newScroll = getBoundedStackScroll(curScroll);
 103         if (Float.compare(newScroll, curScroll) != 0) {
 104             setStackScrollRaw(newScroll);
 105             return true;
 106         }
 107         return false;
 108     }
 109
 110     /** Returns the bounded stack scroll */
 111     float getBoundedStackScroll(float scroll) {
 112         return Math.max(mLayoutAlgorithm.mMinScrollP, Math.min(mLayoutAlgorithm.mMaxScrollP, scroll));
 113     }
 114
 115     /** Returns the amount that the absolute value of how much the scroll is out of bounds. */
 116     float getScrollAmountOutOfBounds(float scroll) {
 117         if (scroll < mLayoutAlgorithm.mMinScrollP) {
 118             return Math.abs(scroll - mLayoutAlgorithm.mMinScrollP);
 119         } else if (scroll > mLayoutAlgorithm.mMaxScrollP) {
 120             return Math.abs(scroll - mLayoutAlgorithm.mMaxScrollP);
 121         }
 122         return 0f;
 123     }
 124
 125     /** Returns whether the specified scroll is out of bounds */
 126     boolean isScrollOutOfBounds() {
 127         return Float.compare(getScrollAmountOutOfBounds(mStackScrollP), 0f) != 0;
 128     }
 129
 130     /** Animates the stack scroll into bounds */
 131     ObjectAnimator animateBoundScroll() {
 132         float curScroll = getStackScroll();
 133         float newScroll = getBoundedStackScroll(curScroll);
 134         if (Float.compare(newScroll, curScroll) != 0) {
 135             // Start a new scroll animation
 136             animateScroll(curScroll, newScroll, null);
 137         }
 138         return mScrollAnimator;
 139     }
 140
 141     /** Animates the stack scroll */
 142     void animateScroll(float curScroll, float newScroll, final Runnable postRunnable) {
 143         // Finish any current scrolling animations
 144         if (mScrollAnimator != null && mScrollAnimator.isRunning()) {
 145             setStackScroll(mFinalAnimatedScroll);
 146             mScroller.startScroll(0, progressToScrollRange(mFinalAnimatedScroll), 0, 0, 0);
 147         }
 148         stopScroller();
 149         stopBoundScrollAnimation();
 150
 151         mFinalAnimatedScroll = newScroll;
 152         mScrollAnimator = ObjectAnimator.ofFloat(this, "stackScroll", curScroll, newScroll);
 153         mScrollAnimator.setDuration(mConfig.taskStackScrollDuration);
 154         mScrollAnimator.setInterpolator(mConfig.linearOutSlowInInterpolator);
 155         mScrollAnimator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
 156             @Override
 157             public void onAnimationUpdate(ValueAnimator animation) {
 158                 setStackScroll((Float) animation.getAnimatedValue());
 159             }
 160         });
 161         mScrollAnimator.addListener(new AnimatorListenerAdapter() {
 162             @Override
 163             public void onAnimationEnd(Animator animation) {
 164                 if (postRunnable != null) {
 165                     postRunnable.run();
 166                 }
 167                 mScrollAnimator.removeAllListeners();
 168             }
 169         });
 170         mScrollAnimator.start();
 171     }
 172
 173     /** Aborts any current stack scrolls */
 174     void stopBoundScrollAnimation() {
 175         Utilities.cancelAnimationWithoutCallbacks(mScrollAnimator);
 176     }
 177
 178     /**** OverScroller ****/
 179
 180     int progressToScrollRange(float p) {
 181         return (int) (p * mLayoutAlgorithm.mStackVisibleRect.height());
 182     }
 183
 184     float scrollRangeToProgress(int s) {
 185         return (float) s / mLayoutAlgorithm.mStackVisibleRect.height();
 186     }
 187
 188     /** Called from the view draw, computes the next scroll. */
 189     boolean computeScroll() {
 190         if (mScroller.computeScrollOffset()) {
 191             float scroll = scrollRangeToProgress(mScroller.getCurrY());
 192             setStackScrollRaw(scroll);
 193             if (mCb != null) {
 194                 mCb.onScrollChanged(scroll);
 195             }
 196             return true;
 197         }
 198         return false;
 199     }
 200
 201     /** Returns whether the overscroller is scrolling. */
 202     boolean isScrolling() {
 203         return !mScroller.isFinished();
 204     }
 205
 206     /** Stops the scroller and any current fling. */
 207     void stopScroller() {
 208         if (!mScroller.isFinished()) {
 209             mScroller.abortAnimation();
 210         }
 211     }
 212 }