Android4.0 Launcher 源码分析系列（三）

时间：2021-08-30 03:53:44

 这一篇研究一下整个桌面的左右滑动是如何实现的。 首先傻蛋先画了个图来再来阐述一下WorkSpace的结构。如下图：

 

onTouchEvent方法，详细见代码注释：

 

最后有个小知识点要搞清楚，不少网友都问到过我。就是scrollTo和scrollBy的区别。我们查看View类的源代码如下所示，mScrollX记录的是当前View针对屏幕坐标在水平方向上的偏移量，而mScrollY则是记录的时当前View针对屏幕在竖值方向上的偏移量。

      从以下代码我们可以得知，scrollTo就是把View移动到屏幕的X和Y位置，也就是绝对位置。而scrollBy其实就是调用的 scrollTo，但是参数是当前mScrollX和mScrollY加上X和Y的位置，所以ScrollBy调用的是相对于mScrollX和mScrollY的位置。我们在上面的代码中可以看到当我们手指不放移动屏幕时，就会调用scrollBy来移动一段相对的距离。而当我们手指松开后，会调用 mScroller.startScroll(mUnboundedScrollX, 0, delta, 0, duration); 来产生一段动画来移动到相应的页面，在这个过程中系统回不断调用computeScroll()，我们再使用scrollTo来把View移动到当前Scroller所在的绝对位置。

 

  
  
    

  1. /** 
    2. 
   
   
  2.      * Set the scrolled position of your view. This will cause a call to 
    3. 
   
   
  3.      * {@link #onScrollChanged(int, int, int, int)} and the view will be 
    4. 
   
   
  4.      * invalidated. 
    5. 
   
   
  5.      * @param x the x position to scroll to 
    6. 
   
   
  6.      * @param y the y position to scroll to 
    7. 
   
   
  7.      */ 
    8. 
   
   
  8.     public void scrollTo(int x, int y) { 
    9. 
   
   
  9.         if (mScrollX != x || mScrollY != y) { 
    10. 
   
   
  10.             int oldX = mScrollX; 
    11. 
   
   
  11.             int oldY = mScrollY; 
    12. 
   
   
  12.             mScrollX = x; 
    13. 
   
   
  13.             mScrollY = y; 
    14. 
   
   
  14.             invalidateParentCaches(); 
    15. 
   
   
  15.             onScrollChanged(mScrollX, mScrollY, oldX, oldY); 
    16. 
   
   
  16.             if (!awakenScrollBars()) { 
    17. 
   
   
  17.                 invalidate(true); 
    18. 
   
   
  18.             } 
    19. 
   
   
  19.         } 
    20. 
   
   
  20.     } 
    21. 
   
   
  21.     /** 
    22. 
   
   
  22.      * Move the scrolled position of your view. This will cause a call to 
    23. 
   
   
  23.      * {@link #onScrollChanged(int, int, int, int)} and the view will be 
    24. 
   
   
  24.      * invalidated. 
    25. 
   
   
  25.      * @param x the amount of pixels to scroll by horizontally 
    26. 
   
   
  26.      * @param y the amount of pixels to scroll by vertically 
    27. 
   
   
  27.      */ 
    28. 
   
   
  28.     public void scrollBy(int x, int y) { 
    29. 
   
   
  29.         scrollTo(mScrollX + x, mScrollY + y); 
    30. 
   
   
  30.     } 
    31. 
  
  
 

 

 
 
    

  1. @Override 
    2. 
  
  
  2. public boolean onTouchEvent(MotionEvent ev) { 
    3. 
  
  
  3.     // Skip touch handling if there are no pages to swipe 
    4. 
  
  
  4.     // 如果没有子页面，就直接跳过 
    5. 
  
  
  5.     if (getChildCount() <= 0) return super.onTouchEvent(ev); 
    6. 
  
  
  6.  
    7. 
  
  
  7.     acquireVelocityTrackerAndAddMovement(ev); 
    8. 
  
  
  8.  
    9. 
  
  
  9.     final int action = ev.getAction(); 
    10. 
  
  
  10.  
    11. 
  
  
  11.     switch (action & MotionEvent.ACTION_MASK) { 
    12. 
  
  
  12.     case MotionEvent.ACTION_DOWN: 
    13. 
  
  
  13.         /* 
    14. 
  
  
  14.          * If being flinged and user touches, stop the fling. isFinished 
    15. 
  
  
  15.          * will be false if being flinged. 
    16. 
  
  
  16.          * 如果在滑动的过程中下用户又点击桌面，则取消滑动，从而响应当前的点击。 
    17. 
  
  
  17.          * 在滑动的isFinished将返回false. 
    18. 
  
  
  18.          */ 
    19. 
  
  
  19.         if (!mScroller.isFinished()) { 
    20. 
  
  
  20.             mScroller.abortAnimation(); 
    21. 
  
  
  21.         } 
    22. 
  
  
  22.  
    23. 
  
  
  23.         // Remember where the motion event started 
    24. 
  
  
  24.         mDownMotionX = mLastMotionX = ev.getX(); 
    25. 
  
  
  25.         mLastMotionXRemainder = 0; 
    26. 
  
  
  26.         mTotalMotionX = 0; 
    27. 
  
  
  27.         mActivePointerId = ev.getPointerId(0); 
    28. 
  
  
  28.         //主要用来显示滚动条，表明要开始滚动了，这里可以进行调整，滚动条时逐渐显示还是立刻显示。 
    29. 
  
  
  29.         if (mTouchState == TOUCH_STATE_SCROLLING) { 
    30. 
  
  
  30.             pageBeginMoving(); 
    31. 
  
  
  31.         } 
    32. 
  
  
  32.         break; 
    33. 
  
  
  33.  
    34. 
  
  
  34.     case MotionEvent.ACTION_MOVE: 
    35. 
  
  
  35.         if (mTouchState == TOUCH_STATE_SCROLLING) { 
    36. 
  
  
  36.             // Scroll to follow the motion event 
    37. 
  
  
  37.             final int pointerIndex = ev.findPointerIndex(mActivePointerId); 
    38. 
  
  
  38.             final float x = ev.getX(pointerIndex); 
    39. 
  
  
  39.             final float deltaX = mLastMotionX + mLastMotionXRemainder - x; 
    40. 
  
  
  40.             //总共移动的距离 
    41. 
  
  
  41.             mTotalMotionX += Math.abs(deltaX); 
    42. 
  
  
  42.  
    43. 
  
  
  43.             // Only scroll and update mLastMotionX if we have moved some discrete amount.  We 
    44. 
  
  
  44.             // keep the remainder because we are actually testing if we've moved from the last 
    45. 
  
  
  45.             // scrolled position (which is discrete). 
    46. 
  
  
  46.             // 如果我们移动了一小段距离，我们则移动和更新mLastMotionX 。我们保存Remainder变量是因为会检测我们 
    47. 
  
  
  47.             //是否是从最后的滚动点位移动的。                
    48. 
  
  
  48.             if (Math.abs(deltaX) >= 1.0f) { 
    49. 
  
  
  49.                 mTouchX += deltaX; 
    50. 
  
  
  50.                 mSmoothingTime = System.nanoTime() / NANOTIME_DIV; 
    51. 
  
  
  51.                 if (!mDeferScrollUpdate) { 
    52. 
  
  
  52.                     scrollBy((int) deltaX, 0); 
    53. 
  
  
  53.                     if (DEBUG) Log.d(TAG, "onTouchEvent().Scrolling: " + deltaX); 
    54. 
  
  
  54.                 } else { 
    55. 
  
  
  55.                     invalidate(); 
    56. 
  
  
  56.                 } 
    57. 
  
  
  57.                 mLastMotionX = x; 
    58. 
  
  
  58.                 mLastMotionXRemainder = deltaX - (int) deltaX; 
    59. 
  
  
  59.             } else { 
    60. 
  
  
  60.             //Trigger the scrollbars to draw. When invoked this method starts an animation to fade the  
    61. 
  
  
  61.             //scrollbars out after a default delay. If a subclass provides animated scrolling,  
    62. 
  
  
  62.             //the start delay should equal the duration of the scrolling animation. 
    63. 
  
  
  63.             //触发scrollbar进行绘制。 使用这个方法来启动一个动画来使scrollbars经过一段时间淡出。如果子类提供了滚动的动画，则 
    64. 
  
  
  64.             //延迟的时间等于动画滚动的时间。 
    65. 
  
  
  65.                 awakenScrollBars(); 
    66. 
  
  
  66.             } 
    67. 
  
  
  67.         } else { 
    68. 
  
  
  68.             determineScrollingStart(ev); 
    69. 
  
  
  69.         } 
    70. 
  
  
  70.         break; 
    71. 
  
  
  71.  
    72. 
  
  
  72.     case MotionEvent.ACTION_UP: 
    73. 
  
  
  73.         if (mTouchState == TOUCH_STATE_SCROLLING) { 
    74. 
  
  
  74.             final int activePointerId = mActivePointerId; 
    75. 
  
  
  75.             final int pointerIndex = ev.findPointerIndex(activePointerId); 
    76. 
  
  
  76.             final float x = ev.getX(pointerIndex); 
    77. 
  
  
  77.             final VelocityTracker velocityTracker = mVelocityTracker; 
    78. 
  
  
  78.             velocityTracker.computeCurrentVelocity(1000, mMaximumVelocity); 
    79. 
  
  
  79.             int velocityX = (int) velocityTracker.getXVelocity(activePointerId); 
    80. 
  
  
  80.             final int deltaX = (int) (x - mDownMotionX); 
    81. 
  
  
  81.             final int pageWidth = getScaledMeasuredWidth(getPageAt(mCurrentPage)); 
    82. 
  
  
  82.             // 屏幕的宽度*0.4f 
    83. 
  
  
  83.             boolean isSignificantMove = Math.abs(deltaX) > pageWidth * 
    84. 
  
  
  84.                     SIGNIFICANT_MOVE_THRESHOLD; 
    85. 
  
  
  85.             final int snapVelocity = mSnapVelocity; 
    86. 
  
  
  86.  
    87. 
  
  
  87.             mTotalMotionX += Math.abs(mLastMotionX + mLastMotionXRemainder - x); 
    88. 
  
  
  88.  
    89. 
  
  
  89.             boolean isFling = mTotalMotionX > MIN_LENGTH_FOR_FLING && 
    90. 
  
  
  90.                     Math.abs(velocityX) > snapVelocity; 
    91. 
  
  
  91.  
    92. 
  
  
  92.             // In the case that the page is moved far to one direction and then is flung 
    93. 
  
  
  93.             // in the opposite direction, we use a threshold to determine whether we should 
    94. 
  
  
  94.             // just return to the starting page, or if we should skip one further. 
    95. 
  
  
  95.             // 这钟情况是页面朝一个方向移动了一段距离，然后又弹回去了。我们使用一个阀值来判断是进行翻页还是返回到初始页面         
    96. 
  
  
  96.             boolean returnToOriginalPage = false; 
    97. 
  
  
  97.             if (Math.abs(deltaX) > pageWidth * RETURN_TO_ORIGINAL_PAGE_THRESHOLD && 
    98. 
  
  
  98.                     Math.signum(velocityX) != Math.signum(deltaX) && isFling) { 
    99. 
  
  
  99.                 returnToOriginalPage = true; 
    100. 
  
  
  100.             } 
    101. 
  
  
  101.  
    102. 
  
  
  102.             int finalPage; 
    103. 
  
  
  103.             // We give flings precedence over large moves, which is why we short-circuit our 
    104. 
  
  
  104.             // test for a large move if a fling has been registered. That is, a large 
    105. 
  
  
  105.             // move to the left and fling to the right will register as a fling to the right. 
    106. 
  
  
  106.             //朝右移动 
    107. 
  
  
  107.             if (((isSignificantMove && deltaX > 0 && !isFling) || 
    108. 
  
  
  108.                     (isFling && velocityX > 0)) && mCurrentPage > 0) { 
    109. 
  
  
  109.                 finalPage = returnToOriginalPage ? mCurrentPage : mCurrentPage - 1; 
    110. 
  
  
  110.                 snapToPageWithVelocity(finalPage, velocityX); 
    111. 
  
  
  111.             //朝左移动 
    112. 
  
  
  112.             } else if (((isSignificantMove && deltaX < 0 && !isFling) || 
    113. 
  
  
  113.                     (isFling && velocityX < 0)) && 
    114. 
  
  
  114.                     mCurrentPage < getChildCount() - 1) { 
    115. 
  
  
  115.                 finalPage = returnToOriginalPage ? mCurrentPage : mCurrentPage + 1; 
    116. 
  
  
  116.                 snapToPageWithVelocity(finalPage, velocityX); 
    117. 
  
  
  117.             //寻找离屏幕中心最近的页面移动 
    118. 
  
  
  118.             } else { 
    119. 
  
  
  119.                 snapToDestination(); 
    120. 
  
  
  120.             } 
    121. 
  
  
  121.         } 
    122. 
  
  
  122.          //直接移动到前一页 
    123. 
  
  
  123.          else if (mTouchState == TOUCH_STATE_PREV_PAGE) { 
    124. 
  
  
  124.             // at this point we have not moved beyond the touch slop 
    125. 
  
  
  125.             // (otherwise mTouchState would be TOUCH_STATE_SCROLLING), so 
    126. 
  
  
  126.             // we can just page 
    127. 
  
  
  127.             int nextPage = Math.max(0, mCurrentPage - 1); 
    128. 
  
  
  128.             if (nextPage != mCurrentPage) { 
    129. 
  
  
  129.                 snapToPage(nextPage); 
    130. 
  
  
  130.             } else { 
    131. 
  
  
  131.                 snapToDestination(); 
    132. 
  
  
  132.             } 
    133. 
  
  
  133.         } 
    134. 
  
  
  134.          //直接移动到下一页 
    135. 
  
  
  135.          else if (mTouchState == TOUCH_STATE_NEXT_PAGE) { 
    136. 
  
  
  136.             // at this point we have not moved beyond the touch slop 
    137. 
  
  
  137.             // (otherwise mTouchState would be TOUCH_STATE_SCROLLING), so 
    138. 
  
  
  138.             // we can just page 
    139. 
  
  
  139.             int nextPage = Math.min(getChildCount() - 1, mCurrentPage + 1); 
    140. 
  
  
  140.             if (nextPage != mCurrentPage) { 
    141. 
  
  
  141.                 snapToPage(nextPage); 
    142. 
  
  
  142.             } else { 
    143. 
  
  
  143.                 snapToDestination(); 
    144. 
  
  
  144.             } 
    145. 
  
  
  145.         } else { 
    146. 
  
  
  146.             onUnhandledTap(ev); 
    147. 
  
  
  147.         } 
    148. 
  
  
  148.         mTouchState = TOUCH_STATE_REST; 
    149. 
  
  
  149.         mActivePointerId = INVALID_POINTER; 
    150. 
  
  
  150.         releaseVelocityTracker(); 
    151. 
  
  
  151.         break; 
    152. 
  
  
  152.      //对事件不响应 
    153. 
  
  
  153.     case MotionEvent.ACTION_CANCEL: 
    154. 
  
  
  154.         if (mTouchState == TOUCH_STATE_SCROLLING) { 
    155. 
  
  
  155.             snapToDestination(); 
    156. 
  
  
  156.         } 
    157. 
  
  
  157.         mTouchState = TOUCH_STATE_REST; 
    158. 
  
  
  158.         mActivePointerId = INVALID_POINTER; 
    159. 
  
  
  159.         releaseVelocityTracker(); 
    160. 
  
  
  160.         break; 
    161. 
  
  
  161.  
    162. 
  
  
  162.     case MotionEvent.ACTION_POINTER_UP: 
    163. 
  
  
  163.         onSecondaryPointerUp(ev); 
    164. 
  
  
  164.         break; 
    165. 
  
  
  165.     } 
    166. 
  
  
  166.  
    167. 
  
  
  167.     return true; 
    168. 
  
  
  168. } 
    169.

Android4.0 Launcher 源码分析系列（三）

    桌面的左右滑动功能主要是在PagedView类中实现的，而WorkSpace是PagedView类的子类，所以会继承PagedView中的方法。当我们的手指点击WorkSpace时，首先就会触发PageView中的onInterceptTouchEvent()方法，会根据相应的条件来判断是否对Touch事件进行拦截，如果onInterceptTouchEvent()方法返回为true，则会对Touch事件进行拦截，PageView类的onTouch方法会进行响应从而得到调用。如果返回false，就分两钟情况：（1）我们是点击在它的子控键上进行滑动时，比如我们是点击在桌面的图标上进行左右滑动的，workspace则会把Touch事件分发给它的子控件。（2）而如果仅仅是点击到桌面的空白出Touch事件就不会发生响应。

       在我们手指第一次触摸到屏幕时，首先会对onInterceptTouchEvent中的事件进行判断，如果是按下事件（MotionEvent.ACTION_DOWN）, 则会记录按下时的X坐标、Y坐标等等数据，同时改变现在Workspace的状态为滚动状态（OUCH_STATE_SCROLLING），这时会返回ture，把事件交给onTouchEvent函数来处理，onTouchEvent中同样会对事件类型进行判断，当事件方法为（otionEvent.ACTION_DOWN）的时候，就可以开始显示滚动的指示条了（就是Hotseat上显示第几屏的屏点）。当我们按着屏幕不放进行滑动的时候，又会在onInterceptTouchEvent进行事件拦截，但是现在的事件类型变为了 MotionEvent.ACTION_MOVE，因为是移动的操作，所以会在拦截的时候取消桌面长按的事件的响应，同时转到onTouchEvent中对ACTION_MOVE事件的响应中，判断我们移动了多少距离，使用scrollBy方法来对桌面进行移动，并刷新屏幕。最后我们放开手后会触发onTouchEvent中的MotionEvent.ACTION_UP事件，这时会根据滑动的情况来判断是朝左滑动还是朝右滑动，如果手指只滑动了屏幕宽度的少一半距离，则会弹回原来的页面，滑动多于屏幕宽度的一半则会进行翻页。同时要注意无论在什么情况下触发了WorkSpace滑动的事件，则系统会不断调用computeScroll()方法，我们重写这个方法同时在这个方法中调用刷新界面等操作。

       滑动过程中所要注意的主要方法如下，具体见代码注释。    

 

 
 
    

  1. //对Touch事件进行拦截   主要用于在拦截各种Touch事件时，设置mTouchState的各种状态 
    2. 
  
  
  2. @Override 
    3. 
  
  
  3. public boolean onInterceptTouchEvent(MotionEvent ev) { 
    4. 
  
  
  4.     /* 
    5. 
  
  
  5.      * This method JUST determines whether we want to intercept the motion. 
    6. 
  
  
  6.      * If we return true, onTouchEvent will be called and we do the actual 
    7. 
  
  
  7.      * scrolling there. 
    8. 
  
  
  8.      * 这个方法仅仅决定了我们是否愿意去对滑动事件进行拦截，如果返回为true,则会调用onTouchEvent我们将会在那里进行事件处理 
    9. 
  
  
  9.      */ 
    10. 
  
  
  10.     //对滑动的速率进行跟踪。 
    11. 
  
  
  11.  
    12. 
  
  
  12.     acquireVelocityTrackerAndAddMovement(ev); 
    13. 
  
  
  13.  
    14. 
  
  
  14.     // Skip touch handling if there are no pages to swipe 
    15. 
  
  
  15.     // 如果没有页面，则跳过操作。 
    16. 
  
  
  16.     if (getChildCount() <= 0) return super.onInterceptTouchEvent(ev); 
    17. 
  
  
  17.  
    18. 
  
  
  18.     /* 
    19. 
  
  
  19.      * Shortcut the most recurring case: the user is in the dragging 
    20. 
  
  
  20.      * state and he is moving his finger.  We want to intercept this 
    21. 
  
  
  21.      * motion. 
    22. 
  
  
  22.      * shortcut最常见的情况是：用户处于拖动的状态下，同时在移动它的手指，这时候我们需要拦截这个动作。 
    23. 
  
  
  23.      *  
    24. 
  
  
  24.      */ 
    25. 
  
  
  25.     final int action = ev.getAction(); 
    26. 
  
  
  26.     //如果是在MOVE的情况下，则进行Touch事件拦截 
    27. 
  
  
  27.     if ((action == MotionEvent.ACTION_MOVE) &&               
    28. 
  
  
  28.             (mTouchState == TOUCH_STATE_SCROLLING)) { 
    29. 
  
  
  29.         return true; 
    30. 
  
  
  30.     } 
    31. 
  
  
  31.  
    32. 
  
  
  32.     switch (action & MotionEvent.ACTION_MASK) { 
    33. 
  
  
  33.         case MotionEvent.ACTION_MOVE: { 
    34. 
  
  
  34.             /* 
    35. 
  
  
  35.              * mIsBeingDragged == false, otherwise the shortcut would have caught it. Check 
    36. 
  
  
  36.              * whether the user has moved far enough from his original down touch. 
    37. 
  
  
  37.              * 如果mIsBeingDragged==false ,否则快捷方式应该捕获到该事件，检查一下用户从它点击的地方位移是否足够 
    38. 
  
  
  38.              */ 
    39. 
  
  
  39.             if (mActivePointerId != INVALID_POINTER) { 
    40. 
  
  
  40.                 //根据移动的距离判断是翻页还是移动一段位移，同时设置lastMotionX或者mTouchState这些值。同时取消桌面长按事件。 
    41. 
  
  
  41.                 determineScrollingStart(ev); 
    42. 
  
  
  42.                 break; 
    43. 
  
  
  43.             } 
    44. 
  
  
  44.             // if mActivePointerId is INVALID_POINTER, then we must have missed an ACTION_DOWN 
    45. 
  
  
  45.             // event. in that case, treat the first occurence of a move event as a ACTION_DOWN 
    46. 
  
  
  46.             // i.e. fall through to the next case (don't break) 
    47. 
  
  
  47.             // (We sometimes miss ACTION_DOWN events in Workspace because it ignores all events 
    48. 
  
  
  48.             // while it's small- this was causing a crash before we checked for INVALID_POINTER) 
    49. 
  
  
  49.             // 如果mActivePointerId 是 INVALID_POINTER，这时候我们应该已经错过了ACTION_DOWN事件。在这种情况下，把 
    50. 
  
  
  50.             // 第一次发生移动的事件当作ACTION——DOWN事件，直接进入下一个情况下。 
    51. 
  
  
  51.             // 我们有时候会错过workspace中的ACTION_DOWN事件，因为在workspace变小的时候会忽略掉所有的事件。                 
    52. 
  
  
  52.         } 
    53. 
  
  
  53.  
    54. 
  
  
  54.         case MotionEvent.ACTION_DOWN: { 
    55. 
  
  
  55.             final float x = ev.getX(); 
    56. 
  
  
  56.             final float y = ev.getY(); 
    57. 
  
  
  57.             // Remember location of down touch 
    58. 
  
  
  58.             // 记录按下的位置 
    59. 
  
  
  59.             mDownMotionX = x; 
    60. 
  
  
  60.             mLastMotionX = x; 
    61. 
  
  
  61.             mLastMotionY = y; 
    62. 
  
  
  62.             mLastMotionXRemainder = 0; 
    63. 
  
  
  63.             mTotalMotionX = 0; 
    64. 
  
  
  64.             //Return the pointer identifier associated with a particular pointer data index is this event.  
    65. 
  
  
  65.             //The identifier tells you the actual pointer number associated with the data,  
    66. 
  
  
  66.             //accounting for individual pointers going up and down since the start of the current gesture. 
    67. 
  
  
  67.             //返回和这个事件关联的触点数据id，计算单独点的id会上下浮动，因为手势的起始位置挥发声改变。 
    68. 
  
  
  68.             mActivePointerId = ev.getPointerId(0); 
    69. 
  
  
  69.             mAllowLongPress = true; 
    70. 
  
  
  70.  
    71. 
  
  
  71.             /* 
    72. 
  
  
  72.              * If being flinged and user touches the screen, initiate drag; 
    73. 
  
  
  73.              * otherwise don't.  mScroller.isFinished should be false when 
    74. 
  
  
  74.              * being flinged. 
    75. 
  
  
  75.              * 如果被拖动同时用户触摸到了屏幕，就开始初始化拖动，否则便不会。 
    76. 
  
  
  76.              * 当拖动完成后mScroller.isFinished就应该设置为false. 
    77. 
  
  
  77.              *  
    78. 
  
  
  78.              */ 
    79. 
  
  
  79.             final int xDist = Math.abs(mScroller.getFinalX() - mScroller.getCurrX()); 
    80. 
  
  
  80.              
    81. 
  
  
  81.             final boolean finishedScrolling = (mScroller.isFinished() || xDist < mTouchSlop); 
    82. 
  
  
  82.             if (finishedScrolling) { 
    83. 
  
  
  83.                 //标记为TOUCH_STATE_REST状态 
    84. 
  
  
  84.                 mTouchState = TOUCH_STATE_REST; 
    85. 
  
  
  85.                 //取消滚动动画 
    86. 
  
  
  86.                 mScroller.abortAnimation(); 
    87. 
  
  
  87.             } else { 
    88. 
  
  
  88.                 //状态为TOUCH_STATE_SCROLLING 
    89. 
  
  
  89.                 mTouchState = TOUCH_STATE_SCROLLING; 
    90. 
  
  
  90.             } 
    91. 
  
  
  91.  
    92. 
  
  
  92.             // check if this can be the beginning of a tap on the side of the pages 
    93. 
  
  
  93.             // to scroll the current page 
    94. 
  
  
  94.             // 检测此事件是不是开始于点击页面的边缘来对当前页面进行滚动。                 
    95. 
  
  
  95.             if (mTouchState != TOUCH_STATE_PREV_PAGE && mTouchState != TOUCH_STATE_NEXT_PAGE) { 
    96. 
  
  
  96.                 if (getChildCount() > 0) { 
    97. 
  
  
  97.                     //根据触点的点位来判断是否点击到上一页，从而更新相应的状态 
    98. 
  
  
  98.                     if (hitsPreviousPage(x, y)) { 
    99. 
  
  
  99.                         mTouchState = TOUCH_STATE_PREV_PAGE; 
    100. 
  
  
  100.                     } else if (hitsNextPage(x, y)) { 
    101. 
  
  
  101.                         mTouchState = TOUCH_STATE_NEXT_PAGE; 
    102. 
  
  
  102.                     } 
    103. 
  
  
  103.                 } 
    104. 
  
  
  104.             } 
    105. 
  
  
  105.             break; 
    106. 
  
  
  106.         } 
    107. 
  
  
  107.  
    108. 
  
  
  108.         case MotionEvent.ACTION_UP: 
    109. 
  
  
  109.         case MotionEvent.ACTION_CANCEL: 
    110. 
  
  
  110.             //触点不被相应时，所做的动作 
    111. 
  
  
  111.             mTouchState = TOUCH_STATE_REST; 
    112. 
  
  
  112.             mAllowLongPress = false; 
    113. 
  
  
  113.             mActivePointerId = INVALID_POINTER; 
    114. 
  
  
  114.             //释放速率跟踪 
    115. 
  
  
  115.             releaseVelocityTracker(); 
    116. 
  
  
  116.             break; 
    117. 
  
  
  117.  
    118. 
  
  
  118.         case MotionEvent.ACTION_POINTER_UP: 
    119. 
  
  
  119.             onSecondaryPointerUp(ev); 
    120. 
  
  
  120.             releaseVelocityTracker(); 
    121. 
  
  
  121.             break; 
    122. 
  
  
  122.     } 
    123. 
  
  
  123.  
    124. 
  
  
  124.     /* 
    125. 
  
  
  125.      * The only time we want to intercept motion events is if we are in the 
    126. 
  
  
  126.      * drag mode. 
    127. 
  
  
  127.      * 我们唯一会去对移动事件进行拦截的情况时我们在拖动模式下 
    128. 
  
  
  128.      */ 
    129. 
  
  
  129.     if(DEBUG) Log.d(TAG, "onInterceptTouchEvent "+(mTouchState != TOUCH_STATE_REST)); 
    130. 
  
  
  130.     //只要是mTouchState的状态不为TOUCH_STATE_REST,那么就进行事件拦截 
    131. 
  
  
  131.     return mTouchState != TOUCH_STATE_REST; 
    132. 
  
  
  132. } 
    133.

本文出自 “最牛傻蛋的博客” 博客，请务必保留此出处http://zuiniuwang.blog.51cto.com/3709988/779859

标签：

相关文章