1  /**
 2      * Call this when you want to know the new location. If it returns true,
 3      * the animation is not yet finished. loc will be altered to provide the
 4      * new location.
 5      */
 6     public boolean computeScrollOffset() {
 7         if (mFinished) {
 8             return false; //已经完成了本次动画，直接返回为false  
 9         }
10         int timePassed = (int)(AnimationUtils.currentAnimationTimeMillis() - mStartTime);
11    
12         if (timePassed < mDuration) {
13             switch (mMode) {
14             case SCROLL_MODE:
15                 float x = timePassed * mDurationReciprocal;
16    
17                 if (mInterpolator == null)
18                     x = viscousFluid(x);
19                 else
20                     x = mInterpolator.getInterpolation(x);
21    
22                 mCurrX = mStartX + Math.round(x * mDeltaX);
23                 mCurrY = mStartY + Math.round(x * mDeltaY);
24                 break;
25             case FLING_MODE:
26                 final float t = (float) timePassed / mDuration;
27                 final int index = (int) (NB_SAMPLES * t);
28                 float distanceCoef = 1.f;
29                 float velocityCoef = 0.f;
30                 if (index < NB_SAMPLES) {
31                     final float t_inf = (float) index / NB_SAMPLES;
32                     final float t_sup = (float) (index + 1) / NB_SAMPLES;
33                     final float d_inf = SPLINE_POSITION[index];
34                     final float d_sup = SPLINE_POSITION[index + 1];
35                     velocityCoef = (d_sup - d_inf) / (t_sup - t_inf);
36                     distanceCoef = d_inf + (t - t_inf) * velocityCoef;
37                 }
38                 mCurrVelocity = velocityCoef * mDistance / mDuration * 1000.0f;
39                
40                 mCurrX = mStartX + Math.round(distanceCoef * (mFinalX - mStartX));
41                 // Pin to mMinX <= mCurrX <= mMaxX
42                 mCurrX = Math.min(mCurrX, mMaxX);
43                 mCurrX = Math.max(mCurrX, mMinX);
44                
45                 mCurrY = mStartY + Math.round(distanceCoef * (mFinalY - mStartY));
46                 // Pin to mMinY <= mCurrY <= mMaxY
47                 mCurrY = Math.min(mCurrY, mMaxY);
48                 mCurrY = Math.max(mCurrY, mMinY);
49                 if (mCurrX == mFinalX && mCurrY == mFinalY) {
50                     mFinished = true;
51                 }
52                 break;
53             }
54         }
55         else {
56             mCurrX = mFinalX;
57             mCurrY = mFinalY;
58             mFinished = true;
59         }
60         return true;
61     }

1     /**
2      * Called by a parent to request that a child update its values for mScrollX
3      * and mScrollY if necessary. This will typically be done if the child is
4      * animating a scroll using a {@link android.widget.Scroller Scroller}
5      * object.
6      */由父视图调用用来请求子视图根据偏移值 mScrollX,mScrollY重新绘制  
7     public void computeScroll() {
8     }

 1 @Override
 2     public void computeScroll() {
 3         if (mScroller.computeScrollOffset()) {
 4             scrollTo(mScroller.getCurrX(), mScroller.getCurrY());
 5             // 更新界面
 6             postInvalidate();
 7             isMoving = true;
 8         } else {
 9             isMoving = false;
10         }
11         super.computeScroll();
12     }

 1  /**
 2      * Start scrolling by providing a starting point and the distance to travel.
 3      *
 4      * @param startX  //水平方向滚动的偏移值，以像素为单位。正值表明滚动将向左滚动
 5      * @param startY  //垂直方向滚动的偏移值，以像素为单位。正值表明滚动将向上滚动
 6      * @param dx //水平方向滑动的距离，正值会使滚动向左滚动
 7      * @param dy //垂直方向滑动的距离，正值会使滚动向上滚动
 8      * @param duration //滚动持续时间
 9      */
10     public void startScroll(int startX, int startY, int dx, int dy, int duration) {
11         mMode = SCROLL_MODE;
12         mFinished = false;
13         mDuration = duration;
14         mStartTime = AnimationUtils.currentAnimationTimeMillis();
15         mStartX = startX;
16         mStartY = startY;
17         mFinalX = startX + dx;
18         mFinalY = startY + dy;
19         mDeltaX = dx;
20         mDeltaY = dy;
21         mDurationReciprocal = 1.0f / (float) mDuration;
22     }