Android 带你从源码的角度解析Scroller的滚动实现原理

今天给大家讲解的是Scroller类的滚动实现原理，可能很多朋友不太了解该类是用来干嘛的，但是研究Launcher的朋友应该对他很熟悉，Scroller类是滚动的一个封装类，可以实现View的平滑滚动效果，什么是实现View的平滑滚动效果呢，举个简单的例子，一个View从在我们指定的时间内从一个位置滚动到另外一个位置，我们利用Scroller类可以实现匀速滚动，可以先加速后减速，可以先减速后加速等等效果，而不是瞬间的移动的效果，所以Scroller可以帮我们实现很多滑动的效果。

在介绍Scroller类之前，我们先去了解View的scrollBy() 和scrollTo()方法的区别，在区分这两个方法的之前，我们要先理解View 里面的两个成员变量mScrollX， mScrollY，X轴方向的偏移量和Y轴方向的偏移量，这个是一个相对距离，相对的不是屏幕的原点，而是View的左边缘，举个通俗易懂的例子，一列火车从吉安到深圳，途中经过赣州，那么原点就是赣州，偏移量就是 负的吉安到赣州的距离，大家从getScrollX()方法中的注释中就能看出答案来


1

2

3

4

5

6

7

8

9

10

11

/**

    * Return the scrolled left position of this view. This is the left edge of

    * the displayed part of your view. You do not need to draw any pixels

    * farther left, since those are outside of the frame of your view on

    * screen.

    *

    * @return The left edge of the displayed part of your view, in pixels.

    */

   public final int getScrollX() { 

       return mScrollX; 

   } 

　　现在我们知道了向右滑动 mScrollX就为负数，向左滑动mScrollX为正数，接下来我们先来看看 scrollTo()方法的源码


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

/**

   * Set the scrolled position of your view. This will cause a call to

   * {@link #onScrollChanged(int, int, int, int)} and the view will be

   * invalidated.

   * @param x the x position to scroll to

   * @param y the y position to scroll to

   */

  public void scrollTo(int x, int y) { 

      if (mScrollX != x || mScrollY != y) { 

          int oldX = mScrollX; 

          int oldY = mScrollY; 

          mScrollX = x; 

          mScrollY = y; 

          onScrollChanged(mScrollX, mScrollY, oldX, oldY); 

          if (!awakenScrollBars()) { 

              invalidate(); 

          } 

      } 

  }

　　从该方法中我们可以看出，先判断传进来的(x, y)值是否和View的X, Y偏移量相等，如果不相等，就调用onScrollChanged()方法来通知界面发生改变，然后重绘界面，所以这样子就实现了移动效果啦， 现在我们知道了scrollTo()方法是滚动到(x, y)这个偏移量的点，他是相对于View的开始位置来滚动的。在看看scrollBy()这个方法的代码


1

2

3

4

5

6

7

8

9

10

/**

    * Move the scrolled position of your view. This will cause a call to

    * {@link #onScrollChanged(int, int, int, int)} and the view will be

    * invalidated.

    * @param x the amount of pixels to scroll by horizontally

    * @param y the amount of pixels to scroll by vertically

    */

   public void scrollBy(int x, int y) { 

       scrollTo(mScrollX + x, mScrollY + y); 

   }

　　

原来他里面调用了scrollTo()方法，那就好办了，他就是相对于View上一个位置根据(x, y)来进行滚动，可能大家脑海中对这两个方法还有点模糊，没关系，还是举个通俗的例子帮大家理解下，假如一个View,调用两次scrollTo(-10, 0)，第一次向右滚动10，第二次就不滚动了，因为mScrollX和x相等了，当我们调用两次scrollBy(-10, 0),第一次向右滚动10，第二次再向右滚动10，他是相对View的上一个位置来滚动的。

对于scrollTo()和scrollBy()方法还有一点需要注意，这点也很重要，假如你给一个LinearLayout调用scrollTo()方法，并不是LinearLayout滚动，而是LinearLayout里面的内容进行滚动，比如你想对一个按钮进行滚动，直接用Button调用scrollTo()一定达不到你的需求，大家可以试一试，如果真要对某个按钮进行scrollTo()滚动的话，我们可以在Button外面包裹一层Layout，然后对Layout调用scrollTo()方法。

了解了scrollTo()和scrollBy()方法之后我们就了解下Scroller类了，先看其构造方法


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

/**

 * Create a Scroller with the default duration and interpolator.

 */

public Scroller(Context context) { 

    this(context, null); 

} 

  

/**

 * Create a Scroller with the specified interpolator. If the interpolator is

 * null, the default (viscous) interpolator will be used.

 */

public Scroller(Context context, Interpolator interpolator) { 

    mFinished = true; 

    mInterpolator = interpolator; 

    float ppi = context.getResources().getDisplayMetrics().density * 160.0f; 

    mDeceleration = SensorManager.GRAVITY_EARTH   // g (m/s^2) 

                  * 39.37f                        // inch/meter 

                  * ppi                           // pixels per inch 

                  * ViewConfiguration.getScrollFriction(); 

　　只有两个构造方法，第一个只有一个Context参数，第二个构造方法中指定了Interpolator，什么Interpolator呢？中文意思插补器，了解Android动画的朋友都应该熟悉
Interpolator，他指定了动画的变化率，比如说匀速变化，先加速后减速，正弦变化等等，不同的Interpolator可以做出不同的效果出来，第一个使用默认的Interpolator(viscous)

接下来我们就要在Scroller类里面找滚动的方法，我们从名字上面可以看出startScroll()应该是个滚动的方法，我们来看看其源码吧


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

public void startScroll(int startX, int startY, int dx, int dy, int duration) { 

    mMode = SCROLL_MODE; 

    mFinished = false; 

    mDuration = duration; 

    mStartTime = AnimationUtils.currentAnimationTimeMillis(); 

    mStartX = startX; 

    mStartY = startY; 

    mFinalX = startX + dx; 

    mFinalY = startY + dy; 

    mDeltaX = dx; 

    mDeltaY = dy; 

    mDurationReciprocal = 1.0f / (float) mDuration; 

    // This controls the viscous fluid effect (how much of it) 

    mViscousFluidScale = 8.0f; 

    // must be set to 1.0 (used in viscousFluid()) 

    mViscousFluidNormalize = 1.0f; 

    mViscousFluidNormalize = 1.0f / viscousFluid(1.0f); 

}

　　在这个方法中我们只看到了对一些滚动的基本设置动作，比如设置滚动模式，开始时间，持续时间等等，并没有任何对View的滚动操作，也许你正纳闷，不是滚动的方法干嘛还叫做startScroll(),稍安勿躁，既然叫开始滚动，那就是对滚动的滚动之前的基本设置咯。


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

/**

 * Call this when you want to know the new location.  If it returns true,

 * the animation is not yet finished.  loc will be altered to provide the

 * new location.

 */

public boolean computeScrollOffset() { 

    if (mFinished) { 

        return false; 

    } 

  

    int timePassed = (int)(AnimationUtils.currentAnimationTimeMillis() - mStartTime); 

  

    if (timePassed < mDuration) { 

        switch (mMode) { 

        case SCROLL_MODE: 

            float x = (float)timePassed * mDurationReciprocal; 

  

            if (mInterpolator == null) 

                x = viscousFluid(x);  

            else

                x = mInterpolator.getInterpolation(x); 

  

            mCurrX = mStartX + Math.round(x * mDeltaX); 

            mCurrY = mStartY + Math.round(x * mDeltaY); 

            break; 

        case FLING_MODE: 

            float timePassedSeconds = timePassed / 1000.0f; 

            float distance = (mVelocity * timePassedSeconds) 

                    - (mDeceleration * timePassedSeconds * timePassedSeconds / 2.0f); 

              

            mCurrX = mStartX + Math.round(distance * mCoeffX); 

            // Pin to mMinX <= mCurrX <= mMaxX 

            mCurrX = Math.min(mCurrX, mMaxX); 

            mCurrX = Math.max(mCurrX, mMinX); 

              

            mCurrY = mStartY + Math.round(distance * mCoeffY); 

            // Pin to mMinY <= mCurrY <= mMaxY 

            mCurrY = Math.min(mCurrY, mMaxY); 

            mCurrY = Math.max(mCurrY, mMinY); 

              

            break; 

        } 

    } 

    else { 

        mCurrX = mFinalX; 

        mCurrY = mFinalY; 

        mFinished = true; 

    } 

    return true; 

} 

　　我们在startScroll()方法的时候获取了当前的动画毫秒赋值给了mStartTime，在computeScrollOffset()中再一次调用AnimationUtils.currentAnimationTimeMillis()来获取动画
毫秒减去mStartTime就是持续时间了，然后进去if判断，如果动画持续时间小于我们设置的滚动持续时间mDuration，进去switch的SCROLL_MODE，然后根据Interpolator来计算出在该时间段里面移动的距离，赋值给mCurrX， mCurrY， 所以该方法的作用是，计算在0到mDuration时间段内滚动的偏移量，并且判断滚动是否结束，true代表还没结束，false则表示滚动介绍了，Scroller类的其他的方法我就不提了，大都是一些get(), set()方法。

看了这么多，到底要怎么才能触发滚动，你心里肯定有很多疑惑，在说滚动之前我要先提另外一个方法computeScroll()，该方法是滑动的控制方法，在绘制View时，会在draw()过程调用该方法。我们先看看computeScroll()的源码


1

2

3

4

5

6

7

8

/**

    * Called by a parent to request that a child update its values for mScrollX

    * and mScrollY if necessary. This will typically be done if the child is

    * animating a scroll using a {@link android.widget.Scroller Scroller}

    * object.

    */

   public void computeScroll() { 

   }

　　没错，他是一个空的方法，需要子类去重写该方法来实现逻辑，到底该方法在哪里被触发呢。我们继续看看View的绘制方法draw()


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

public void draw(Canvas canvas) { 

       final int privateFlags = mPrivateFlags; 

       final boolean dirtyOpaque = (privateFlags & PFLAG_DIRTY_MASK) == PFLAG_DIRTY_OPAQUE && 

               (mAttachInfo == null || !mAttachInfo.mIgnoreDirtyState); 

       mPrivateFlags = (privateFlags & ~PFLAG_DIRTY_MASK) | PFLAG_DRAWN; 

  

       /*

        * Draw traversal performs several drawing steps which must be executed

        * in the appropriate order:

        *

        *      1. Draw the background

        *      2. If necessary, save the canvas‘ layers to prepare for fading

        *      3. Draw view‘s content

        *      4. Draw children

        *      5. If necessary, draw the fading edges and restore layers

        *      6. Draw decorations (scrollbars for instance)

        */

  

       // Step 1, draw the background, if needed 

       int saveCount; 

  

       if (!dirtyOpaque) { 

           final Drawable background = mBackground; 

           if (background != null) { 

               final int scrollX = mScrollX; 

               final int scrollY = mScrollY; 

  

               if (mBackgroundSizeChanged) { 

                   background.setBounds(0, 0,  mRight - mLeft, mBottom - mTop); 

                   mBackgroundSizeChanged = false; 

               } 

  

               if ((scrollX | scrollY) == 0) { 

                   background.draw(canvas); 

               } else { 

                   canvas.translate(scrollX, scrollY); 

                   background.draw(canvas); 

                   canvas.translate(-scrollX, -scrollY); 

               } 

           } 

       } 

  

       // skip step 2 & 5 if possible (common case) 

       final int viewFlags = mViewFlags; 

       boolean horizontalEdges = (viewFlags & FADING_EDGE_HORIZONTAL) != 0; 

       boolean verticalEdges = (viewFlags & FADING_EDGE_VERTICAL) != 0; 

       if (!verticalEdges && !horizontalEdges) { 

           // Step 3, draw the content 

           if (!dirtyOpaque) onDraw(canvas); 

  

           // Step 4, draw the children 

           dispatchDraw(canvas); 

  

           // Step 6, draw decorations (scrollbars) 

           onDrawScrollBars(canvas); 

  

           // we‘re done... 

           return; 

       } 

  

       ...... 

       ...... 

       ......

　　我们只截取了draw()的部分代码，这上面11-16行为我们写出了绘制一个View的几个步骤，我们看看第四步绘制孩子的时候会触发dispatchDraw()这个方法，来看看源码是什么内容


1

2

3

4

5

6

7

8

9

/**

    * Called by draw to draw the child views. This may be overridden

    * by derived classes to gain control just before its children are drawn

    * (but after its own view has been drawn).

    * @param canvas the canvas on which to draw the view

    */

   protected void dispatchDraw(Canvas canvas) { 

  

   }

　　好吧，又是定义的一个空方法，给子类来重写的方法,所以我们找到View的子类ViewGroup来看看该方法的具体实现逻辑


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

@Override

protected void dispatchDraw(Canvas canvas) { 

    final int count = mChildrenCount; 

    final View[] children = mChildren; 

    int flags = mGroupFlags; 

  

    if ((flags & FLAG_RUN_ANIMATION) != 0 && canAnimate()) { 

        final boolean cache = (mGroupFlags & FLAG_ANIMATION_CACHE) == FLAG_ANIMATION_CACHE; 

  

        final boolean buildCache = !isHardwareAccelerated(); 

        for (int i = 0; i < count; i++) { 

            final View child = children[i]; 

            if ((child.mViewFlags & VISIBILITY_MASK) == VISIBLE) { 

                final LayoutParams params = child.getLayoutParams(); 

                attachLayoutAnimationParameters(child, params, i, count); 

                bindLayoutAnimation(child); 

                if (cache) { 

                    child.setDrawingCacheEnabled(true); 

                    if (buildCache) {                         

                        child.buildDrawingCache(true); 

                    } 

                } 

            } 

        } 

  

        final LayoutAnimationController controller = mLayoutAnimationController; 

        if (controller.willOverlap()) { 

            mGroupFlags |= FLAG_OPTIMIZE_INVALIDATE; 

        } 

  

        controller.start(); 

  

        mGroupFlags &= ~FLAG_RUN_ANIMATION; 

        mGroupFlags &= ~FLAG_ANIMATION_DONE; 

  

        if (cache) { 

            mGroupFlags |= FLAG_CHILDREN_DRAWN_WITH_CACHE; 

        } 

  

        if (mAnimationListener != null) { 

            mAnimationListener.onAnimationStart(controller.getAnimation()); 

        } 

    } 

  

    int saveCount = 0; 

    final boolean clipToPadding = (flags & CLIP_TO_PADDING_MASK) == CLIP_TO_PADDING_MASK; 

    if (clipToPadding) { 

        saveCount = canvas.save(); 

        canvas.clipRect(mScrollX + mPaddingLeft, mScrollY + mPaddingTop, 

                mScrollX + mRight - mLeft - mPaddingRight, 

                mScrollY + mBottom - mTop - mPaddingBottom); 

  

    } 

  

    // We will draw our child‘s animation, let‘s reset the flag 

    mPrivateFlags &= ~PFLAG_DRAW_ANIMATION; 

    mGroupFlags &= ~FLAG_INVALIDATE_REQUIRED; 

  

    boolean more = false; 

    final long drawingTime = getDrawingTime(); 

  

    if ((flags & FLAG_USE_CHILD_DRAWING_ORDER) == 0) { 

        for (int i = 0; i < count; i++) { 

            final View child = children[i]; 

            if ((child.mViewFlags & VISIBILITY_MASK) == VISIBLE || child.getAnimation() != null) { 

                more |= drawChild(canvas, child, drawingTime); 

            } 

        } 

    } else { 

        for (int i = 0; i < count; i++) { 

            final View child = children[getChildDrawingOrder(count, i)]; 

            if ((child.mViewFlags & VISIBILITY_MASK) == VISIBLE || child.getAnimation() != null) { 

                more |= drawChild(canvas, child, drawingTime); 

            } 

        } 

    } 

  

    // Draw any disappearing views that have animations 

    if (mDisappearingChildren != null) { 

        final ArrayList<View> disappearingChildren = mDisappearingChildren; 

        final int disappearingCount = disappearingChildren.size() - 1; 

        // Go backwards -- we may delete as animations finish 

        for (int i = disappearingCount; i >= 0; i--) { 

            final View child = disappearingChildren.get(i); 

            more |= drawChild(canvas, child, drawingTime); 

        } 

    } 

  

    if (debugDraw()) { 

        onDebugDraw(canvas); 

    } 

  

    if (clipToPadding) { 

        canvas.restoreToCount(saveCount); 

    } 

  

    // mGroupFlags might have been updated by drawChild() 

    flags = mGroupFlags; 

  

    if ((flags & FLAG_INVALIDATE_REQUIRED) == FLAG_INVALIDATE_REQUIRED) { 

        invalidate(true); 

    } 

  

    if ((flags & FLAG_ANIMATION_DONE) == 0 && (flags & FLAG_NOTIFY_ANIMATION_LISTENER) == 0 && 

            mLayoutAnimationController.isDone() && !more) { 

        // We want to erase the drawing cache and notify the listener after the 

        // next frame is drawn because one extra invalidate() is caused by 

        // drawChild() after the animation is over 

        mGroupFlags |= FLAG_NOTIFY_ANIMATION_LISTENER; 

        final Runnable end = new Runnable() { 

           public void run() { 

               notifyAnimationListener(); 

           } 

        }; 

        post(end); 

    } 

}

　　这个方法代码有点多，但是我们还是挑重点看吧，从65-79行可以看出 在dispatchDraw()里面会对ViewGroup里面的子View调用drawChild()来进行绘制，接下来我们来看看drawChild()方法的代码


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

protected boolean drawChild(Canvas canvas, View child, long drawingTime) { 

    ...... 

    ...... 

  

    if (!concatMatrix && canvas.quickReject(cl, ct, cr, cb, Canvas.EdgeType.BW) && 

                (child.mPrivateFlags & DRAW_ANIMATION) == 0) { 

            return more; 

        } 

  

        child.computeScroll(); 

  

        final int sx = child.mScrollX; 

        final int sy = child.mScrollY; 

  

        boolean scalingRequired = false; 

        Bitmap cache = null; 

  

    ...... 

    ...... 

  

}

　　只截取了部分代码，看到child.computeScroll()你大概明白什么了吧，转了老半天终于找到了computeScroll()方法被触发，就是ViewGroup在分发绘制自己的孩子的时候，会对其子View调用computeScroll()方法

整理下思路，来看看View滚动的实现原理，我们先调用Scroller的startScroll()方法来进行一些滚动的初始化设置，然后迫使View进行绘制，我们调用View的invalidate()或postInvalidate()就可以重新绘制View，绘制View的时候会触发computeScroll()方法，我们重写computeScroll()，在computeScroll()里面先调用Scroller的computeScrollOffset()方法来判断滚动有没有结束，如果滚动没有结束我们就调用scrollTo()方法来进行滚动，该scrollTo()方法虽然会重新绘制View,但是我们还是要手动调用下invalidate()或者postInvalidate()来触发界面重绘，重新绘制View又触发computeScroll()，所以就进入一个循环阶段，这样子就实现了在某个时间段里面滚动某段距离的一个平滑的滚动效果
也许有人会问，干嘛还要调用来调用去最后在调用scrollTo()方法，还不如直接调用scrollTo()方法来实现滚动，其实直接调用是可以，只不过scrollTo()是瞬间滚动的，给人的用户体验不太好，所以Android提供了Scroller类实现平滑滚动的效果。为了方面大家理解，我画了一个简单的调用示意图

好了，讲到这里就已经讲完了Scroller类的滚动实现原理啦，不知道大家理解了没有，Scroller能实现很多滚动的效果，由于考虑到这篇文章的篇幅有点长，所以这篇文章就不带领大家来使用Scroller类了，我将在下一篇文章将会带来Scroller类的使用，希望大家到时候关注下，有疑问的同学在下面留言，我会为大家解答的！

很荣幸我能够成为CSDN 2013年度博客之星评选的候选人，希望继续得到大家的支持与鼓励,看到的朋友帮我投上宝贵的一票吧！

  投票地址：http://vote.blog.csdn.net/blogstaritem/blogstar2013/xiaanming

时间： 2024-10-30 04:41:32

Android 带你从源码的角度解析Scroller的滚动实现原理的相关文章

【转】Android 带你从源码的角度解析Scroller的滚动实现原理

今天给大家讲解的是Scroller类的滚动实现原理,可能很多朋友不太了解该类是用来干嘛的,但是研究Launcher的朋友应该对他很熟悉,Scroller类是滚动的一个封装类,可以实现View的平滑滚动效果,什么是实现View的平滑滚动效果呢,举个简单的例子,一个View从在我们指定的时间内从一个位置滚动到另外一个位置,我们利用Scroller类可以实现匀速滚动,可以先加速后减速,可以先减速后加速等等效果,而不是瞬间的移动的效果,所以Scroller可以帮我们实现很多滑动的效果. 在介绍Scrol

Android AsyncTask完全解析，带你从源码的角度彻底理解

转载请注明出处:http://blog.csdn.net/guolin_blog/article/details/11711405 我们都知道,Android UI是线程不安全的,如果想要在子线程里进行UI操作,就需要借助Android的异步消息处理机制.之前我也写过了一篇文章从源码层面分析了Android的异步消息处理机制,感兴趣的朋友可以参考 Android Handler.Message完全解析,带你从源码的角度彻底理解 . 不过为了更加方便我们在子线程中更新UI元素,Android从1.

Android事件分发机制完全解析，带你从源码的角度彻底理解(上)

转载请注明出处:http://blog.csdn.net/guolin_blog/article/details/9097463 其实我一直准备写一篇关于Android事件分发机制的文章,从我的第一篇博客开始,就零零散散在好多地方使用到了Android事件分发的知识.也有好多朋友问过我各种问题,比如:onTouch和onTouchEvent有什么区别,又该如何使用?为什么给ListView引入了一个滑动菜单的功能,ListView就不能滚动了?为什么图片轮播器里的图片使用Button而不用Ima

[学习总结]7、Android AsyncTask完全解析，带你从源码的角度彻底理解

我们都知道,Android UI是线程不安全的,如果想要在子线程里进行UI操作,就需要借助Android的异步消息处理机制.之前我也写过了一篇文章从源码层面分析了Android的异步消息处理机制,感兴趣的朋友可以参考 Android Handler.Message完全解析,带你从源码的角度彻底理解 . 不过为了更加方便我们在子线程中更新UI元素,Android从1.5版本就引入了一个AsyncTask类,使用它就可以非常灵活方便地从子线程切换到UI线程,我们本篇文章的主角也就正是它了. Asyn

[学习总结]6、Android异步消息处理机制完全解析，带你从源码的角度彻底理解

开始进入正题,我们都知道,Android UI是线程不安全的,如果在子线程中尝试进行UI操作,程序就有可能会崩溃.相信大家在日常的工作当中都会经常遇到这个问题,解决的方案应该也是早已烂熟于心,即创建一个Message对象,然后借助Handler发送出去,之后在Handler的handleMessage()方法中获得刚才发送的Message对象,然后在这里进行UI操作就不会再出现崩溃了. 这种处理方式被称为异步消息处理线程,虽然我相信大家都会用,可是你知道它背后的原理是什么样的吗?今天我们就来一起

[转]Android事件分发机制完全解析，带你从源码的角度彻底理解(上)

Android事件分发机制 该篇文章出处:http://blog.csdn.net/guolin_blog/article/details/9097463 其实我一直准备写一篇关于Android事件分发机制的文章,从我的第一篇博客开始,就零零散散在好多地方使用到了Android事件分发的知识. 也有好多朋友问过我各种问题,比如:onTouch和onTouchEvent有什么区别,又该如何使用?为什么给ListView引入了一个滑动菜单的 功能,ListView就不能滚动了?为什么图片轮播器里的图

（转） Android事件分发机制完全解析，带你从源码的角度彻底理解(上)

转载请注明出处:http://blog.csdn.net/guolin_blog/article/details/9097463 其实我一直准备写一篇关于Android事件分发机制的文章,从我的第一篇博客开始,就零零散散在好多地方使用到了Android事件分发的知识.也有好多朋友问过我各种问题,比如:onTouch和onTouchEvent有什么区别,又该如何使用?为什么给ListView引入了一个滑动菜单的功能,ListView就不能滚动了?为什么图片轮播器里的图片使用Button而不用Ima

【转】Android事件分发机制完全解析，带你从源码的角度彻底理解(下)

转载请注明出处:http://blog.csdn.net/guolin_blog/article/details/9153761 记得在前面的文章中,我带大家一起从源码的角度分析了Android中View的事件分发机制,相信阅读过的朋友对View的事件分发已经有比较深刻的理解了. 还未阅读过的朋友,请先参考 Android事件分发机制完全解析,带你从源码的角度彻底理解(上) . 那么今天我们将继续上次未完成的话题,从源码的角度分析ViewGruop的事件分发. 首先我们来探讨一下,什么是View

Android Volley完全解析(四)，带你从源码的角度理解Volley

转载请注明出处:http://blog.csdn.net/guolin_blog/article/details/17656437 经过前三篇文章的学习,Volley的用法我们已经掌握的差不多了,但是对于Volley的工作原理,恐怕有很多朋友还不是很清楚.因此,本篇文章中我们就来一起阅读一下Volley的源码,将它的工作流程整体地梳理一遍.同时,这也是Volley系列的最后一篇文章了. 其实,Volley的官方文档中本身就附有了一张Volley的工作流程图,如下图所示. 多数朋友突然看到一张这样