当一个View超出我们屏幕大小的时候，肯定只能显示View的一部分，这个时候必然涉及到移动一个View。在View的源码中，有两个这样子的方法：
1 /**
2 * Set the scrolled position of your view. This will cause a call to
3 * {@link #onScrollChanged(int, int, int, int)} and the view will be
4 * invalidated.
5 * @param x the x position to scroll to
6 * @param y the y position to scroll to
7 */
8 public void scrollTo(int x, int y) {
9 if (mScrollX != x || mScrollY != y) {
10 int oldX = mScrollX;
11 int oldY = mScrollY;
12 mScrollX = x;
13 mScrollY = y;
14 onScrollChanged(mScrollX, mScrollY, oldX, oldY);
15 if (!awakenScrollBars()) {
16 invalidate();
17 }
18 }
19 }
20
21 /**
22 * Move the scrolled position of your view. This will cause a call to
23 * {@link #onScrollChanged(int, int, int, int)} and the view will be
24 * invalidated.
25 * @param x the amount of pixels to scroll by horizontally
26 * @param y the amount of pixels to scroll by vertically
27 */
28 public void scrollBy(int x, int y) {
29 scrollTo(mScrollX + x, mScrollY + y);
30 }
归根结底，这两个方法调用的都是下面这个方法：
1 /**
2 * This is called in response to an internal scroll in this view (i.e., the
3 * view scrolled its own contents). This is typically as a result of
4 * {@link #scrollBy(int, int)} or {@link #scrollTo(int, int)} having been
5 * called.
6 *
7 * @param l Current horizontal scroll origin.
8 * @param t Current vertical scroll origin.
9 * @param oldl Previous horizontal scroll origin.
10 * @param oldt Previous vertical scroll origin.
11 */
12 protected void onScrollChanged(int l, int t, int oldl, int oldt) {
13 mBackgroundSizeChanged = true;
14
15 final AttachInfo ai = mAttachInfo;
16 if (ai != null) {
17 ai.mViewScrollChanged = true;
18 }
19 }
这里具体发生了什么事情，不得而知，但是我们可以基本认为：View是提供给外部滚动自己内容的方式的（好吧，这里弱爆了。。。）
当我们去滚动一个View的时候，我们有两种方式去滚动一个View，第一种是瞬间移动到我们想要移动到的地方，第二种则是，以动画方式移动，并且设定一定的时长。当然第二种方式更加用户友好。我们需要手动控制这个过程。时刻了解一些信息，比如：
1）滚动过了多长时间；
2）现在滚动了多少距离了；
3）滚动是否结束了；
在Android中有一个类，其源码如下：
1 /*
2 * Copyright (C) 2006 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 android.widget;
18
19 import android.content.Context;
20 import android.hardware.SensorManager;
21 import android.view.ViewConfiguration;
22 import android.view.animation.AnimationUtils;
23 import android.view.animation.Interpolator;
24
25
26 /**
27 * This class encapsulates scrolling. The duration of the scroll
28 * can be passed in the constructor and specifies the maximum time that
29 * the scrolling animation should take. Past this time, the scrolling is
30 * automatically moved to its final stage and computeScrollOffset()
31 * will always return false to indicate that scrolling is over.
32 */
33 public class Scroller {
34 private int mMode;
35
36 private int mStartX;
37 private int mStartY;
38 private int mFinalX;
39 private int mFinalY;
40
41 private int mMinX;
42 private int mMaxX;
43 private int mMinY;
44 private int mMaxY;
45
46 private int mCurrX;
47 private int mCurrY;
48 private long mStartTime;
49 private int mDuration;
50 private float mDurationReciprocal;
51 private float mDeltaX;
52 private float mDeltaY;
53 private float mViscousFluidScale;
54 private float mViscousFluidNormalize;
55 private boolean mFinished;
56 private Interpolator mInterpolator;
57
58 private float mCoeffX = 0.0f;
59 private float mCoeffY = 1.0f;
60 private float mVelocity;
61
62 private static final int DEFAULT_DURATION = 250;
63 private static final int SCROLL_MODE = 0;
64 private static final int FLING_MODE = 1;
65
66 private final float mDeceleration;
67
68 /**
69 * Create a Scroller with the default duration and interpolator.
70 */
71 public Scroller(Context context) {
72 this(context, null);
73 }
74
75 /**
76 * Create a Scroller with the specified interpolator. If the interpolator is
77 * null, the default (viscous) interpolator will be used.
78 */
79 public Scroller(Context context, Interpolator interpolator) {
80 mFinished = true;
81 mInterpolator = interpolator;
82 float ppi = context.getResources().getDisplayMetrics().density * 160.0f;
83 mDeceleration = SensorManager.GRAVITY_EARTH // g (m/s^2)
84 * 39.37f // inch/meter
85 * ppi // pixels per inch
86 * ViewConfiguration.getScrollFriction();
87 }
88
89 /**
90 *
91 * Returns whether the scroller has finished scrolling.
92 *
93 * @return True if the scroller has finished scrolling, false otherwise.
94 */
95 public final boolean isFinished() {
96 return mFinished;
97 }
98
99 /**
100 * Force the finished field to a particular value.
101 *
102 * @param finished The new finished value.
103 */
104 public final void forceFinished(boolean finished) {
105 mFinished = finished;
106 }
107
108 /**
109 * Returns how long the scroll event will take, in milliseconds.
110 *
111 * @return The duration of the scroll in milliseconds.
112 */
113 public final int getDuration() {
114 return mDuration;
115 }
116
117 /**
118 * Returns the current X offset in the scroll.
119 *
120 * @return The new X offset as an absolute distance from the origin.
121 */
122 public final int getCurrX() {
123 return mCurrX;
124 }
125
126 /**
127 * Returns the current Y offset in the scroll.
128 *
129 * @return The new Y offset as an absolute distance from the origin.
130 */
131 public final int getCurrY() {
132 return mCurrY;
133 }
134
135 /**
136 * @hide
137 * Returns the current velocity.
138 *
139 * @return The original velocity less the deceleration. Result may be
140 * negative.
141 */
142 public float getCurrVelocity() {
143 return mVelocity - mDeceleration * timePassed() / 2000.0f;
144 }
145
146 /**
147 * Returns the start X offset in the scroll.
148 *
149 * @return The start X offset as an absolute distance from the origin.
150 */
151 public final int getStartX() {
152 return mStartX;
153 }
154
155 /**
156 * Returns the start Y offset in the scroll.
157 *
158 * @return The start Y offset as an absolute distance from the origin.
159 */
160 public final int getStartY() {
161 return mStartY;
162 }
163
164 /**
165 * Returns where the scroll will end. Valid only for "fling" scrolls.
166 *
167 * @return The final X offset as an absolute distance from the origin.
168 */
169 public final int getFinalX() {
170 return mFinalX;
171 }
172
173 /**
174 * Returns where the scroll will end. Valid only for "fling" scrolls.
175 *
176 * @return The final Y offset as an absolute distance from the origin.
177 */
178 public final int getFinalY() {
179 return mFinalY;
180 }
181
182 /**
183 * Call this when you want to know the new location. If it returns true,
184 * the animation is not yet finished. loc will be altered to provide the
185 * new location.
186 */
187 public boolean computeScrollOffset() {
188 if (mFinished) {
189 return false;
190 }
191
192 int timePassed = (int)(AnimationUtils.currentAnimationTimeMillis() - mStartTime);
193
194 if (timePassed < mDuration) {
195 switch (mMode) {
196 case SCROLL_MODE:
197 float x = (float)timePassed * mDurationReciprocal;
198
199 if (mInterpolator == null)
200 x = viscousFluid(x);
201 else
202 x = mInterpolator.getInterpolation(x);
203
204 mCurrX = mStartX + Math.round(x * mDeltaX);
205 mCurrY = mStartY + Math.round(x * mDeltaY);
206 break;
207 case FLING_MODE:
208 float timePassedSeconds = timePassed / 1000.0f;
209 float distance = (mVelocity * timePassedSeconds)
210 - (mDeceleration * timePassedSeconds * timePassedSeconds / 2.0f);
211
212 mCurrX = mStartX + Math.round(distance * mCoeffX);
213 // Pin to mMinX <= mCurrX <= mMaxX
214 mCurrX = Math.min(mCurrX, mMaxX);
215 mCurrX = Math.max(mCurrX, mMinX);
216
217 mCurrY = mStartY + Math.round(distance * mCoeffY);
218 // Pin to mMinY <= mCurrY <= mMaxY
219 mCurrY = Math.min(mCurrY, mMaxY);
220 mCurrY = Math.max(mCurrY, mMinY);
221
222 break;
223 }
224 }
225 else {
226 mCurrX = mFinalX;
227 mCurrY = mFinalY;
228 mFinished = true;
229 }
230 return true;
231 }
232
233 /**
234 * Start scrolling by providing a starting point and the distance to travel.
235 * The scroll will use the default value of 250 milliseconds for the
236 * duration.
237 *
238 * @param startX Starting horizontal scroll offset in pixels. Positive
239 * numbers will scroll the content to the left.
240 * @param startY Starting vertical scroll offset in pixels. Positive numbers
241 * will scroll the content up.
242 * @param dx Horizontal distance to travel. Positive numbers will scroll the
243 * content to the left.
244 * @param dy Vertical distance to travel. Positive numbers will scroll the
245 * content up.
246 */
247 public void startScroll(int startX, int startY, int dx, int dy) {
248 startScroll(startX, startY, dx, dy, DEFAULT_DURATION);
249 }
250
251 /**
252 * Start scrolling by providing a starting point and the distance to travel.
253 *
254 * @param startX Starting horizontal scroll offset in pixels. Positive
255 * numbers will scroll the content to the left.
256 * @param startY Starting vertical scroll offset in pixels. Positive numbers
257 * will scroll the content up.
258 * @param dx Horizontal distance to travel. Positive numbers will scroll the
259 * content to the left.
260 * @param dy Vertical distance to travel. Positive numbers will scroll the
261 * content up.
262 * @param duration Duration of the scroll in milliseconds.
263 */
264 public void startScroll(int startX, int startY, int dx, int dy, int duration) {
265 mMode = SCROLL_MODE;
266 mFinished = false;
267 mDuration = duration;
268 mStartTime = AnimationUtils.currentAnimationTimeMillis();
269 mStartX = startX;
270 mStartY = startY;
271 mFinalX = startX + dx;
272 mFinalY = startY + dy;
273 mDeltaX = dx;
274 mDeltaY = dy;
275 mDurationReciprocal = 1.0f / (float) mDuration;
276 // This controls the viscous fluid effect (how much of it)
277 mViscousFluidScale = 8.0f;
278 // must be set to 1.0 (used in viscousFluid())
279 mViscousFluidNormalize = 1.0f;
280 mViscousFluidNormalize = 1.0f / viscousFluid(1.0f);
281 }
282
283 /**
284 * Start scrolling based on a fling gesture. The distance travelled will
285 * depend on the initial velocity of the fling.
286 *
287 * @param startX Starting point of the scroll (X)
288 * @param startY Starting point of the scroll (Y)
289 * @param velocityX Initial velocity of the fling (X) measured in pixels per
290 * second.
291 * @param velocityY Initial velocity of the fling (Y) measured in pixels per
292 * second
293 * @param minX Minimum X value. The scroller will not scroll past this
294 * point.
295 * @param maxX Maximum X value. The scroller will not scroll past this
296 * point.
297 * @param minY Minimum Y value. The scroller will not scroll past this
298 * point.
299 * @param maxY Maximum Y value. The scroller will not scroll past this
300 * point.
301 */
302 public void fling(int startX, int startY, int velocityX, int velocityY,
303 int minX, int maxX, int minY, int maxY) {
304 mMode = FLING_MODE;
305 mFinished = false;
306
307 float velocity = (float)Math.hypot(velocityX, velocityY);
308
309 mVelocity = velocity;
310 mDuration = (int) (1000 * velocity / mDeceleration); // Duration is in
311 // milliseconds
312 mStartTime = AnimationUtils.currentAnimationTimeMillis();
313 mStartX = startX;
314 mStartY = startY;
315
316 mCoeffX = velocity == 0 ? 1.0f : velocityX / velocity;
317 mCoeffY = velocity == 0 ? 1.0f : velocityY / velocity;
318
319 int totalDistance = (int) ((velocity * velocity) / (2 * mDeceleration));
320
321 mMinX = minX;
322 mMaxX = maxX;
323 mMinY = minY;
324 mMaxY = maxY;
325
326
327 mFinalX = startX + Math.round(totalDistance * mCoeffX);
328 // Pin to mMinX <= mFinalX <= mMaxX
329 mFinalX = Math.min(mFinalX, mMaxX);
330 mFinalX = Math.max(mFinalX, mMinX);
331
332 mFinalY = startY + Math.round(totalDistance * mCoeffY);
333 // Pin to mMinY <= mFinalY <= mMaxY
334 mFinalY = Math.min(mFinalY, mMaxY);
335 mFinalY = Math.max(mFinalY, mMinY);
336 }
337
338
339
340 private float viscousFluid(float x)
341 {
342 x *= mViscousFluidScale;
343 if (x < 1.0f) {
344 x -= (1.0f - (float)Math.exp(-x));
345 } else {
346 float start = 0.36787944117f; // 1/e == exp(-1)
347 x = 1.0f - (float)Math.exp(1.0f - x);
348 x = start + x * (1.0f - start);
349 }
350 x *= mViscousFluidNormalize;
351 return x;
352 }
353
354 /**
355 * Stops the animation. Contrary to {@link #forceFinished(boolean)},
356 * aborting the animating cause the scroller to move to the final x and y
357 * position
358 *
359 * @see #forceFinished(boolean)
360 */
361 public void abortAnimation() {
362 mCurrX = mFinalX;
363 mCurrY = mFinalY;
364 mFinished = true;
365 }
366
367 /**
368 * Extend the scroll animation. This allows a running animation to scroll
369 * further and longer, when used with {@link #setFinalX(int)} or {@link #setFinalY(int)}.
370 *
371 * @param extend Additional time to scroll in milliseconds.
372 * @see #setFinalX(int)
373 * @see #setFinalY(int)
374 */
375 public void extendDuration(int extend) {
376 int passed = timePassed();
377 mDuration = passed + extend;
378 mDurationReciprocal = 1.0f / (float)mDuration;
379 mFinished = false;
380 }
381
382 /**
383 * Returns the time elapsed since the beginning of the scrolling.
384 *
385 * @return The elapsed time in milliseconds.
386 */
387 public int timePassed() {
388 return (int)(AnimationUtils.currentAnimationTimeMillis() - mStartTime);
389 }
390
391 /**
392 * Sets the final position (X) for this scroller.
393 *
394 * @param newX The new X offset as an absolute distance from the origin.
395 * @see #extendDuration(int)
396 * @see #setFinalY(int)
397 */
398 public void setFinalX(int newX) {
399 mFinalX = newX;
400 mDeltaX = mFinalX - mStartX;
401 mFinished = false;
402 }
403
404 /**
405 * Sets the final position (Y) for this scroller.
406 *
407 * @param newY The new Y offset as an absolute distance from the origin.
408 * @see #extendDuration(int)
409 * @see #setFinalX(int)
410 */
411 public void setFinalY(int newY) {
412 mFinalY = newY;
413 mDeltaY = mFinalY - mStartY;
414 mFinished = false;
415 }
416 }
这个类可以精确记录我们滚动过程中的所有信息，并且通过它，我们可以实现相应的动画。下面解释这个类的几个重要方面：
1）新建这个类的时候，可以传入加速器，这个加速器可以被用来计算滚动过程中的已经滚动的距离；
1 /**
2 * Create a Scroller with the specified interpolator. If the interpolator is
3 * null, the default (viscous) interpolator will be used.
4 */
5 public Scroller(Context context, Interpolator interpolator) {
6 mFinished = true;
7 mInterpolator = interpolator;
8 float ppi = context.getResources().getDisplayMetrics().density * 160.0f;
9 mDeceleration = SensorManager.GRAVITY_EARTH // g (m/s^2)
10 * 39.37f // inch/meter
11 * ppi // pixels per inch
12 * ViewConfiguration.getScrollFriction();
13 }
上面是构造方法，其中有一个比较复杂的计算，源码中毫无注释，先不管；
2）最重要的方法就是下面这个：
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;
9 }
10
11 int timePassed = (int)(AnimationUtils.currentAnimationTimeMillis() - mStartTime);
12
13 if (timePassed < mDuration) {
14 switch (mMode) {
15 case SCROLL_MODE:
16 float x = (float)timePassed * mDurationReciprocal;
17
18 if (mInterpolator == null)
19 x = viscousFluid(x);
20 else
21 x = mInterpolator.getInterpolation(x);
22
23 mCurrX = mStartX + Math.round(x * mDeltaX);
24 mCurrY = mStartY + Math.round(x * mDeltaY);
25 break;
26 case FLING_MODE:
27 float timePassedSeconds = timePassed / 1000.0f;
28 float distance = (mVelocity * timePassedSeconds)
29 - (mDeceleration * timePassedSeconds * timePassedSeconds / 2.0f);
30
31 mCurrX = mStartX + Math.round(distance * mCoeffX);
32 // Pin to mMinX <= mCurrX <= mMaxX
33 mCurrX = Math.min(mCurrX, mMaxX);
34 mCurrX = Math.max(mCurrX, mMinX);
35
36 mCurrY = mStartY + Math.round(distance * mCoeffY);
37 // Pin to mMinY <= mCurrY <= mMaxY
38 mCurrY = Math.min(mCurrY, mMaxY);
39 mCurrY = Math.max(mCurrY, mMinY);
40
41 break;
42 }
43 }
44 else {
45 mCurrX = mFinalX;
46 mCurrY = mFinalY;
47 mFinished = true;
48 }
49 return true;
50 }
只要在滚动，也就是mFinished=false的时候，这个方法就会不停的计算当前应该处于的位置！
3）第三个是启动滚动的类：
1 /**
2 * Start scrolling by providing a starting point and the distance to travel.
3 * The scroll will use the default value of 250 milliseconds for the
4 * duration.
5 *
6 * @param startX Starting horizontal scroll offset in pixels. Positive
7 * numbers will scroll the content to the left.
8 * @param startY Starting vertical scroll offset in pixels. Positive numbers
9 * will scroll the content up.
10 * @param dx Horizontal distance to travel. Positive numbers will scroll the
11 * content to the left.
12 * @param dy Vertical distance to travel. Positive numbers will scroll the
13 * content up.
14 */
15 public void startScroll(int startX, int startY, int dx, int dy) {
16 startScroll(startX, startY, dx, dy, DEFAULT_DURATION);
17 }
18
19 /**
20 * Start scrolling by providing a starting point and the distance to travel.
21 *
22 * @param startX Starting horizontal scroll offset in pixels. Positive
23 * numbers will scroll the content to the left.
24 * @param startY Starting vertical scroll offset in pixels. Positive numbers
25 * will scroll the content up.
26 * @param dx Horizontal distance to travel. Positive numbers will scroll the
27 * content to the left.
28 * @param dy Vertical distance to travel. Positive numbers will scroll the
29 * content up.
30 * @param duration Duration of the scroll in milliseconds.
31 */
32 public void startScroll(int startX, int startY, int dx, int dy, int duration) {
33 mMode = SCROLL_MODE;
34 mFinished = false;
35 mDuration = duration;
36 mStartTime = AnimationUtils.currentAnimationTimeMillis();
37 mStartX = startX;
38 mStartY = startY;
39 mFinalX = startX + dx;
40 mFinalY = startY + dy;
41 mDeltaX = dx;
42 mDeltaY = dy;
43 mDurationReciprocal = 1.0f / (float) mDuration;
44 // This controls the viscous fluid effect (how much of it)
45 mViscousFluidScale = 8.0f;
46 // must be set to 1.0 (used in viscousFluid())
47 mViscousFluidNormalize = 1.0f;
48 mViscousFluidNormalize = 1.0f / viscousFluid(1.0f);
49 }
其实这个方法只是设置一些初始的参数，以便于用于计算。
我想，之所以Scroller难以理解，其实是因为很多人以为Scroller类控制View的滚动，其实不是这个样子的！Scroller类只是当你告诉它你要在一定的时间（默认250ms）内将View滚动一定距离，任何时刻View存在的位置！具体的滚动，其实是View调用自己的ScrollTo和ScrollBy方法实现的！
讲到这里，我想读者一定有一些想法了，假设我现在调用Scroller的startScroll方法，我就可实时获得该动画在任何时刻的位置，那么，假设我在View上要施加一个动画移动，那么我只要产生一个循环，不停去问Scroller View应该存在的位置，然后将View移动到需要移动到的地方，自然就成为动画移动了！
在View的源码中，有方法如下：
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 */
7 public void computeScroll() {
8 }
是个空方法，应该是被用来覆盖的。并且明确提出经典用法是通过Scroller方法来滚动一个view。OK，我们来看看到底如何实现上面的循环。现在我们先离开上面，来看看ViewGroup里面的一个方法：
1 /**
2 * Draw one child of this View Group. This method is responsible for getting
3 * the canvas in the right state. This includes clipping, translating so
4 * that the child's scrolled origin is at 0, 0, and applying any animation
5 * transformations.
6 *
7 * @param canvas The canvas on which to draw the child
8 * @param child Who to draw
9 * @param drawingTime The time at which draw is occuring
10 * @return True if an invalidate() was issued
11 */
12 protected boolean drawChild(Canvas canvas, View child, long drawingTime) {
13 boolean more = false;
14
15 final int cl = child.mLeft;
16 final int ct = child.mTop;
17 final int cr = child.mRight;
18 final int cb = child.mBottom;
19
20 final int flags = mGroupFlags;
21
22 if ((flags & FLAG_CLEAR_TRANSFORMATION) == FLAG_CLEAR_TRANSFORMATION) {
23 if (mChildTransformation != null) {
24 mChildTransformation.clear();
25 }
26 mGroupFlags &= ~FLAG_CLEAR_TRANSFORMATION;
27 }
28
29 Transformation transformToApply = null;
30 final Animation a = child.getAnimation();
31 boolean concatMatrix = false;
32
33 if (a != null) {
34 if (mInvalidateRegion == null) {
35 mInvalidateRegion = new RectF();
36 }
37 final RectF region = mInvalidateRegion;
38
39 final boolean initialized = a.isInitialized();
40 if (!initialized) {
41 a.initialize(cr - cl, cb - ct, getWidth(), getHeight());
42 a.initializeInvalidateRegion(0, 0, cr - cl, cb - ct);
43 child.onAnimationStart();
44 }
45
46 if (mChildTransformation == null) {
47 mChildTransformation = new Transformation();
48 }
49 more = a.getTransformation(drawingTime, mChildTransformation);
50 transformToApply = mChildTransformation;
51
52 concatMatrix = a.willChangeTransformationMatrix();
53
54 if (more) {
55 if (!a.willChangeBounds()) {
56 if ((flags & (FLAG_OPTIMIZE_INVALIDATE | FLAG_ANIMATION_DONE)) ==
57 FLAG_OPTIMIZE_INVALIDATE) {
58 mGroupFlags |= FLAG_INVALIDATE_REQUIRED;
59 } else if ((flags & FLAG_INVALIDATE_REQUIRED) == 0) {
60 // The child need to draw an animation, potentially offscreen, so
61 // make sure we do not cancel invalidate requests
62 mPrivateFlags |= DRAW_ANIMATION;
63 invalidate(cl, ct, cr, cb);
64 }
65 } else {
66 a.getInvalidateRegion(0, 0, cr - cl, cb - ct, region, transformToApply);
67
68 // The child need to draw an animation, potentially offscreen, so
69 // make sure we do not cancel invalidate requests
70 mPrivateFlags |= DRAW_ANIMATION;
71
72 final int left = cl + (int) region.left;
73 final int top = ct + (int) region.top;
74 invalidate(left, top, left + (int) region.width(), top + (int) region.height());
75 }
76 }
77 } else if ((flags & FLAG_SUPPORT_STATIC_TRANSFORMATIONS) ==
78 FLAG_SUPPORT_STATIC_TRANSFORMATIONS) {
79 if (mChildTransformation == null) {
80 mChildTransformation = new Transformation();
81 }
82 final boolean hasTransform = getChildStaticTransformation(child, mChildTransformation);
83 if (hasTransform) {
84 final int transformType = mChildTransformation.getTransformationType();
85 transformToApply = transformType != Transformation.TYPE_IDENTITY ?
86 mChildTransformation : null;
87 concatMatrix = (transformType & Transformation.TYPE_MATRIX) != 0;
88 }
89 }
90
91 // Sets the flag as early as possible to allow draw() implementations
92 // to call invalidate() successfully when doing animations
93 child.mPrivateFlags |= DRAWN;
94
95 if (!concatMatrix && canvas.quickReject(cl, ct, cr, cb, Canvas.EdgeType.BW) &&
96 (child.mPrivateFlags & DRAW_ANIMATION) == 0) {
97 return more;
98 }
99
100 child.computeScroll();
101
102 final int sx = child.mScrollX;
103 final int sy = child.mScrollY;
104
105 boolean scalingRequired = false;
106 Bitmap cache = null;
107 if ((flags & FLAG_CHILDREN_DRAWN_WITH_CACHE) == FLAG_CHILDREN_DRAWN_WITH_CACHE ||
108 (flags & FLAG_ALWAYS_DRAWN_WITH_CACHE) == FLAG_ALWAYS_DRAWN_WITH_CACHE) {
109 cache = child.getDrawingCache(true);
110 if (mAttachInfo != null) scalingRequired = mAttachInfo.mScalingRequired;
111 }
112
113 final boolean hasNoCache = cache == null;
114
115 final int restoreTo = canvas.save();
116 if (hasNoCache) {
117 canvas.translate(cl - sx, ct - sy);
118 } else {
119 canvas.translate(cl, ct);
120 if (scalingRequired) {
121 // mAttachInfo cannot be null, otherwise scalingRequired == false
122 final float scale = 1.0f / mAttachInfo.mApplicationScale;
123 canvas.scale(scale, scale);
124 }
125 }
126
127 float alpha = 1.0f;
128
129 if (transformToApply != null) {
130 if (concatMatrix) {
131 int transX = 0;
132 int transY = 0;
133 if (hasNoCache) {
134 transX = -sx;
135 transY = -sy;
136 }
137 // Undo the scroll translation, apply the transformation matrix,
138 // then redo the scroll translate to get the correct result.
139 canvas.translate(-transX, -transY);
140 canvas.concat(transformToApply.getMatrix());
141 canvas.translate(transX, transY);
142 mGroupFlags |= FLAG_CLEAR_TRANSFORMATION;
143 }
144
145 alpha = transformToApply.getAlpha();
146 if (alpha < 1.0f) {
147 mGroupFlags |= FLAG_CLEAR_TRANSFORMATION;
148 }
149
150 if (alpha < 1.0f && hasNoCache) {
151 final int multipliedAlpha = (int) (255 * alpha);
152 if (!child.onSetAlpha(multipliedAlpha)) {
153 canvas.saveLayerAlpha(sx, sy, sx + cr - cl, sy + cb - ct, multipliedAlpha,
154 Canvas.HAS_ALPHA_LAYER_SAVE_FLAG | Canvas.CLIP_TO_LAYER_SAVE_FLAG);
155 } else {
156 child.mPrivateFlags |= ALPHA_SET;
157 }
158 }
159 } else if ((child.mPrivateFlags & ALPHA_SET) == ALPHA_SET) {
160 child.onSetAlpha(255);
161 }
162
163 if ((flags & FLAG_CLIP_CHILDREN) == FLAG_CLIP_CHILDREN) {
164 if (hasNoCache) {
165 canvas.clipRect(sx, sy, sx + (cr - cl), sy + (cb - ct));
166 } else {
167 if (!scalingRequired) {
168 canvas.clipRect(0, 0, cr - cl, cb - ct);
169 } else {
170 canvas.clipRect(0, 0, cache.getWidth(), cache.getHeight());
171 }
172 }
173 }
174
175 if (hasNoCache) {
176 // Fast path for layouts with no backgrounds
177 if ((child.mPrivateFlags & SKIP_DRAW) == SKIP_DRAW) {
178 if (ViewDebug.TRACE_HIERARCHY) {
179 ViewDebug.trace(this, ViewDebug.HierarchyTraceType.DRAW);
180 }
181 child.mPrivateFlags &= ~DIRTY_MASK;
182 child.dispatchDraw(canvas);
183 } else {
184 child.draw(canvas);
185 }
186 } else {
187 final Paint cachePaint = mCachePaint;
188 if (alpha < 1.0f) {
189 cachePaint.setAlpha((int) (alpha * 255));
190 mGroupFlags |= FLAG_ALPHA_LOWER_THAN_ONE;
191 } else if ((flags & FLAG_ALPHA_LOWER_THAN_ONE) == FLAG_ALPHA_LOWER_THAN_ONE) {
192 cachePaint.setAlpha(255);
193 mGroupFlags &= ~FLAG_ALPHA_LOWER_THAN_ONE;
194 }
195 if (Config.DEBUG && ViewDebug.profileDrawing) {
196 EventLog.writeEvent(60003, hashCode());
197 }
198 canvas.drawBitmap(cache, 0.0f, 0.0f, cachePaint);
199 }
200
201 canvas.restoreToCount(restoreTo);
202
203 if (a != null && !more) {
204 child.onSetAlpha(255);
205 finishAnimatingView(child, a);
206 }
207
208 return more;
209 }
这个方法是ViewGroup用来绘制子View的，第100行！调用了子View的computeScroll()方法，从Android的View树来看，我们会知道，所有的View的computeScroll方法一定会被调用，而在View被刷新（也就是Draw()方法被调用的时候）也会调用这个方法（这里有待探究，我在源码里面追踪了很久没有找到很直接的方法调用路径）（当我们执行ontouch或invalidate(）或postInvalidate()都会导致这个方法的执行所以我们像下面这样调用，postInvalidate执行后，会去调computeScroll 方法，而这个方法里再去调postInvalidate，这样就可以不断地去调用scrollTo方法了，直到mScroller动画结束，当然第一次时，我们需要手动去调用一次postInvalidate才会去调用 ），所以，假设我们存在一个方法可以调用Scroller的startScroll方法，然后立刻调用invalidate方法，这个时候就回去调用computeScroll方法，而在覆盖这个方法的时候，我们如下操作：
1 @Override
2 public void computeScroll() {
3 if (mScroller.computeScrollOffset()) { // 如果返回true，表示动画还没有结束
4 scrollTo(mScroller.getCurrX(), mScroller.getCurrY());
5 postInvalidate();
6 } else { //如果返回false，表示startScroll完成
7 Log.i(tag, " scoller has finished -----");
8 }
这个方法一方面调用scrollTo方法，一方面，我们调用postInvalidate方法形成循环，直到MScroller.computeScrollOffset方法返回false，表示滚动结束的时候，我们停止刷新！另一个方法大致如下：
1 public void scroll(){
2 mScroller.startScroll(0, 0, menuItemWidth, 0,3000);
3 invalidate();
4 }
这样就可以通过View本身的滚动方法和Scroller配合，实现View的动画滚动。完整的例子：
1 import android.content.Context;
2 import android.util.AttributeSet;
3 import android.view.View;
4 import android.view.ViewGroup;
5 import android.widget.LinearLayout;
6 import android.widget.Scroller;
7
8 public class MyViewGroup extends LinearLayout {
9 private boolean s1=true;
10 Scroller mScroller=null;
11 public MyViewGroup(Context context, AttributeSet attrs) {
12 super(context, attrs);
13 mScroller=new Scroller(context);
14 // TODO Auto-generated constructor stub
15 }
16 @Override
17 public void computeScroll() {
18 if (mScroller.computeScrollOffset()) {
19 scrollTo(mScroller.getCurrX(), 0);
20 postInvalidate();
21 }
22 }
23 public void beginScroll(){
24 if (!s1) {
25 mScroller.startScroll(0, 0, 0, 0, 1000);
26 s1 = true;
27 } else {
28 mScroller.startScroll(0, 0, -500, 0, 1000);
29 s1 = false;
30 }
31 invalidate();
32 }
33 }
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
