菜鳥進階Android Touch事件傳遞（四）

時間  2019-11-13
標籤 菜鳥 進階 android touch 事件 傳遞 欄目 Android 简体版
原文   原文鏈接

尊重他人勞動成果，轉載請說明出處：http://blog.csdn.net/bingospunky/article/details/44343477java

在該系列文章第四篇。我準備介紹一下viewpager的touch事件處理。android

假設想了解touch和click的那些事，請瀏覽touch事件傳遞系列的第一篇http://blog.csdn.net/bingospunky/article/details/43603397
ide

假設想了解touch事件一步一步傳遞的路線，請瀏覽touch事件傳遞系列的第二篇http://blog.csdn.net/bingospunky/article/details/43735497
post

假設想從源代碼角度什麼理解viewgroup的dispatchTouchEvent、onInterceptTouchEvent、onTouchEvent怎樣實現。請瀏覽touch事件傳遞系列的第二篇http://blog.csdn.net/bingospunky/article/details/44156771學習

源代碼

代碼A：boolean android.support.v4.view.ViewPager.onInterceptTouchEvent(MotionEvent ev)
this

[java]  view plain copy print ?
  1. public boolean onInterceptTouchEvent(MotionEvent ev) {  
  2.         /* 
  3.          * This method JUST determines whether we want to intercept the motion. 
  4.          * If we return true, onMotionEvent will be called and we do the actual 
  5.          * scrolling there. 
  6.          */  
  7.   
  8.         final int action = ev.getAction() & MotionEventCompat.ACTION_MASK;  
  9.   
  10.         // Always take care of the touch gesture being complete.  
  11.         if (action == MotionEvent.ACTION_CANCEL || action == MotionEvent.ACTION_UP) {  
  12.             // Release the drag.  
  13.             if (DEBUG) Log.v(TAG, "Intercept done!");  
  14.             mIsBeingDragged = false;  
  15.             mIsUnableToDrag = false;  
  16.             mActivePointerId = INVALID_POINTER;  
  17.             if (mVelocityTracker != null) {  
  18.                 mVelocityTracker.recycle();  
  19.                 mVelocityTracker = null;  
  20.             }  
  21.             return false;  
  22.         }  
  23.   
  24.         // Nothing more to do here if we have decided whether or not we  
  25.         // are dragging.  
  26.         if (action != MotionEvent.ACTION_DOWN) {  
  27.             if (mIsBeingDragged) {  
  28.                 if (DEBUG) Log.v(TAG, "Intercept returning true!");  
  29.                 return true;  
  30.             }  
  31.             if (mIsUnableToDrag) {  
  32.                 if (DEBUG) Log.v(TAG, "Intercept returning false!");  
  33.                 return false;  
  34.             }  
  35.         }  
  36.   
  37.         switch (action) {  
  38.             case MotionEvent.ACTION_MOVE: {  
  39.                 /* 
  40.                  * mIsBeingDragged == false, otherwise the shortcut would have caught it. Check 
  41.                  * whether the user has moved far enough from his original down touch. 
  42.                  */  
  43.   
  44.                 /* 
  45.                 * Locally do absolute value. mLastMotionY is set to the y value 
  46.                 * of the down event. 
  47.                 */  
  48.                 final int activePointerId = mActivePointerId;  
  49.                 if (activePointerId == INVALID_POINTER) {  
  50.                     // If we don't have a valid id, the touch down wasn't on content.  
  51.                     break;  
  52.                 }  
  53.   
  54.                 final int pointerIndex = MotionEventCompat.findPointerIndex(ev, activePointerId);  
  55.                 final float x = MotionEventCompat.getX(ev, pointerIndex);  
  56.                 final float dx = x - mLastMotionX;  
  57.                 final float xDiff = Math.abs(dx);  
  58.                 final float y = MotionEventCompat.getY(ev, pointerIndex);  
  59.                 final float yDiff = Math.abs(y - mInitialMotionY);  
  60.                 if (DEBUG) Log.v(TAG, "Moved x to " + x + "," + y + " diff=" + xDiff + "," + yDiff);  
  61.   
  62.                 if (dx != 0 && !isGutterDrag(mLastMotionX, dx) &&  
  63.                         canScroll(this, false, (int) dx, (int) x, (int) y)) {  
  64.                     // Nested view has scrollable area under this point. Let it be handled there.  
  65.                     mLastMotionX = x;  
  66.                     mLastMotionY = y;  
  67.                     mIsUnableToDrag = true;  
  68.                     return false;  
  69.                 }  
  70.                 if (xDiff > mTouchSlop && xDiff * 0.5f > yDiff) {  
  71.                     if (DEBUG) Log.v(TAG, "Starting drag!");  
  72.                     mIsBeingDragged = true;  
  73.                     requestParentDisallowInterceptTouchEvent(true);  
  74.                     setScrollState(SCROLL_STATE_DRAGGING);  
  75.                     mLastMotionX = dx > 0 ? mInitialMotionX + mTouchSlop :  
  76.                             mInitialMotionX - mTouchSlop;  
  77.                     mLastMotionY = y;  
  78.                     setScrollingCacheEnabled(true);  
  79.                 } else if (yDiff > mTouchSlop) {  
  80.                     // The finger has moved enough in the vertical  
  81.                     // direction to be counted as a drag...  abort  
  82.                     // any attempt to drag horizontally, to work correctly  
  83.                     // with children that have scrolling containers.  
  84.                     if (DEBUG) Log.v(TAG, "Starting unable to drag!");  
  85.                     mIsUnableToDrag = true;  
  86.                 }  
  87.                 if (mIsBeingDragged) {  
  88.                     // Scroll to follow the motion event  
  89.                     if (performDrag(x)) {  
  90.                         ViewCompat.postInvalidateOnAnimation(this);  
  91.                     }  
  92.                 }  
  93.                 break;  
  94.             }  
  95.   
  96.             case MotionEvent.ACTION_DOWN: {  
  97.                 /* 
  98.                  * Remember location of down touch. 
  99.                  * ACTION_DOWN always refers to pointer index 0. 
  100.                  */  
  101.                 mLastMotionX = mInitialMotionX = ev.getX();  
  102.                 mLastMotionY = mInitialMotionY = ev.getY();  
  103.                 mActivePointerId = MotionEventCompat.getPointerId(ev, 0);  
  104.                 mIsUnableToDrag = false;  
  105.   
  106.                 mScroller.computeScrollOffset();  
  107.                 if (mScrollState == SCROLL_STATE_SETTLING &&  
  108.                         Math.abs(mScroller.getFinalX() - mScroller.getCurrX()) > mCloseEnough) {  
  109.                     // Let the user 'catch' the pager as it animates.  
  110.                     mScroller.abortAnimation();  
  111.                     mPopulatePending = false;  
  112.                     populate();  
  113.                     mIsBeingDragged = true;  
  114.                     requestParentDisallowInterceptTouchEvent(true);  
  115.                     setScrollState(SCROLL_STATE_DRAGGING);  
  116.                 } else {  
  117.                     completeScroll(false);  
  118.                     mIsBeingDragged = false;  
  119.                 }  
  120.   
  121.                 if (DEBUG) Log.v(TAG, "Down at " + mLastMotionX + "," + mLastMotionY  
  122.                         + " mIsBeingDragged=" + mIsBeingDragged  
  123.                         + "mIsUnableToDrag=" + mIsUnableToDrag);  
  124.                 break;  
  125.             }  
  126.   
  127.             case MotionEventCompat.ACTION_POINTER_UP:  
  128.                 onSecondaryPointerUp(ev);  
  129.                 break;  
  130.         }  
  131.   
  132.         if (mVelocityTracker == null) {  
  133.             mVelocityTracker = VelocityTracker.obtain();  
  134.         }  
  135.         mVelocityTracker.addMovement(ev);  
  136.   
  137.         /* 
  138.          * The only time we want to intercept motion events is if we are in the 
  139.          * drag mode. 
  140.          */  
  141.         return mIsBeingDragged;  
  142.     }  
代碼B：boolean android.support.v4.view.ViewPager.onTouchEvent(MotionEvent ev)

[java]  view plain copy print ?

  1. public boolean onTouchEvent(MotionEvent ev) {  
  2.         if (mFakeDragging) {  
  3.             // A fake drag is in progress already, ignore this real one  
  4.             // but still eat the touch events.  
  5.             // (It is likely that the user is multi-touching the screen.)  
  6.             return true;  
  7.         }  
  8.   
  9.         if (ev.getAction() == MotionEvent.ACTION_DOWN && ev.getEdgeFlags() != 0) {  
  10.             // Don't handle edge touches immediately -- they may actually belong to one of our  
  11.             // descendants.  
  12.             return false;  
  13.         }  
  14.   
  15.         if (mAdapter == null || mAdapter.getCount() == 0) {  
  16.             // Nothing to present or scroll; nothing to touch.  
  17.             return false;  
  18.         }  
  19.   
  20.         if (mVelocityTracker == null) {  
  21.             mVelocityTracker = VelocityTracker.obtain();  
  22.         }  
  23.         mVelocityTracker.addMovement(ev);  
  24.   
  25.         final int action = ev.getAction();  
  26.         boolean needsInvalidate = false;  
  27.   
  28.         switch (action & MotionEventCompat.ACTION_MASK) {  
  29.             case MotionEvent.ACTION_DOWN: {  
  30.                 mScroller.abortAnimation();  
  31.                 mPopulatePending = false;  
  32.                 populate();  
  33.   
  34.                 // Remember where the motion event started  
  35.                 mLastMotionX = mInitialMotionX = ev.getX();  
  36.                 mLastMotionY = mInitialMotionY = ev.getY();  
  37.                 mActivePointerId = MotionEventCompat.getPointerId(ev, 0);  
  38.                 break;  
  39.             }  
  40.             case MotionEvent.ACTION_MOVE:  
  41.                 if (!mIsBeingDragged) {  
  42.                     final int pointerIndex = MotionEventCompat.findPointerIndex(ev, mActivePointerId);  
  43.                     final float x = MotionEventCompat.getX(ev, pointerIndex);  
  44.                     final float xDiff = Math.abs(x - mLastMotionX);  
  45.                     final float y = MotionEventCompat.getY(ev, pointerIndex);  
  46.                     final float yDiff = Math.abs(y - mLastMotionY);  
  47.                     if (DEBUG) Log.v(TAG, "Moved x to " + x + "," + y + " diff=" + xDiff + "," + yDiff);  
  48.                     if (xDiff > mTouchSlop && xDiff > yDiff) {  
  49.                         if (DEBUG) Log.v(TAG, "Starting drag!");  
  50.                         mIsBeingDragged = true;  
  51.                         requestParentDisallowInterceptTouchEvent(true);  
  52.                         mLastMotionX = x - mInitialMotionX > 0 ? mInitialMotionX + mTouchSlop :  
  53.                                 mInitialMotionX - mTouchSlop;  
  54.                         mLastMotionY = y;  
  55.                         setScrollState(SCROLL_STATE_DRAGGING);  
  56.                         setScrollingCacheEnabled(true);  
  57.   
  58.                         // Disallow Parent Intercept, just in case  
  59.                         ViewParent parent = getParent();  
  60.                         if (parent != null) {  
  61.                             parent.requestDisallowInterceptTouchEvent(true);  
  62.                         }  
  63.                     }  
  64.                 }  
  65.                 // Not else! Note that mIsBeingDragged can be set above.  
  66.                 if (mIsBeingDragged) {  
  67.                     // Scroll to follow the motion event  
  68.                     final int activePointerIndex = MotionEventCompat.findPointerIndex(  
  69.                             ev, mActivePointerId);  
  70.                     final float x = MotionEventCompat.getX(ev, activePointerIndex);  
  71.                     needsInvalidate |= performDrag(x);  
  72.                 }  
  73.                 break;  
  74.             case MotionEvent.ACTION_UP:  
  75.                 if (mIsBeingDragged) {  
  76.                     final VelocityTracker velocityTracker = mVelocityTracker;  
  77.                     velocityTracker.computeCurrentVelocity(1000, mMaximumVelocity);  
  78.                     int initialVelocity = (int) VelocityTrackerCompat.getXVelocity(  
  79.                             velocityTracker, mActivePointerId);  
  80.                     mPopulatePending = true;  
  81.                     final int width = getClientWidth();  
  82.                     final int scrollX = getScrollX();  
  83.                     final ItemInfo ii = infoForCurrentScrollPosition();  
  84.                     final int currentPage = ii.position;  
  85.                     final float pageOffset = (((float) scrollX / width) - ii.offset) / ii.widthFactor;  
  86.                     final int activePointerIndex =  
  87.                             MotionEventCompat.findPointerIndex(ev, mActivePointerId);  
  88.                     final float x = MotionEventCompat.getX(ev, activePointerIndex);  
  89.                     final int totalDelta = (int) (x - mInitialMotionX);  
  90.                     int nextPage = determineTargetPage(currentPage, pageOffset, initialVelocity,  
  91.                             totalDelta);  
  92.                     setCurrentItemInternal(nextPage, true, true, initialVelocity);  
  93.   
  94.                     mActivePointerId = INVALID_POINTER;  
  95.                     endDrag();  
  96.                     needsInvalidate = mLeftEdge.onRelease() | mRightEdge.onRelease();  
  97.                 }  
  98.                 break;  
  99.             case MotionEvent.ACTION_CANCEL:  
  100.                 if (mIsBeingDragged) {  
  101.                     scrollToItem(mCurItem, true, 0, false);  
  102.                     mActivePointerId = INVALID_POINTER;  
  103.                     endDrag();  
  104.                     needsInvalidate = mLeftEdge.onRelease() | mRightEdge.onRelease();  
  105.                 }  
  106.                 break;  
  107.             case MotionEventCompat.ACTION_POINTER_DOWN: {  
  108.                 final int index = MotionEventCompat.getActionIndex(ev);  
  109.                 final float x = MotionEventCompat.getX(ev, index);  
  110.                 mLastMotionX = x;  
  111.                 mActivePointerId = MotionEventCompat.getPointerId(ev, index);  
  112.                 break;  
  113.             }  
  114.             case MotionEventCompat.ACTION_POINTER_UP:  
  115.                 onSecondaryPointerUp(ev);  
  116.                 mLastMotionX = MotionEventCompat.getX(ev,  
  117.                         MotionEventCompat.findPointerIndex(ev, mActivePointerId));  
  118.                 break;  
  119.         }  
  120.         if (needsInvalidate) {  
  121.             ViewCompat.postInvalidateOnAnimation(this);  
  122.         }  
  123.         return true;  
  124.     }  
代碼C：void android.support.v4.view.ViewPager.onSecondaryPointerUp(MotionEvent ev)

[java]  view plain copy print ?
  1. private void onSecondaryPointerUp(MotionEvent ev) {  
  2.         final int pointerIndex = MotionEventCompat.getActionIndex(ev);  
  3.         final int pointerId = MotionEventCompat.getPointerId(ev, pointerIndex);  
  4.         if (pointerId == mActivePointerId) {  
  5.             // This was our active pointer going up. Choose a new  
  6.             // active pointer and adjust accordingly.  
  7.             final int newPointerIndex = pointerIndex == 0 ? 1 : 0;  
  8.             mLastMotionX = MotionEventCompat.getX(ev, newPointerIndex);  
  9.             mActivePointerId = MotionEventCompat.getPointerId(ev, newPointerIndex);  
  10.             if (mVelocityTracker != null) {  
  11.                 mVelocityTracker.clear();  
  12.             }  
  13.         }  
  14.     }  

總結

在這裏就不想上篇文章那樣分各類狀況去討論了。那樣有些無聊。這裏就重要點的說明一下個人理解，最後附一個我寫的demo供你們參考學習。spa

一、viewpager處理touch的思路：不截斷touch。假設touch移動知足了必定的條件，再截斷touch由該viewgroup處理。.net

二、咱們可以看到onInterceptTouchEvent和onTouchEvent方法裏的方法很是類似。對於一個touch事件。這兩個方法基本不會被都運行。僅僅有很是少的狀況下這兩個方法都會被運行。orm

三、viewpager有趣的現象。操做：單點操做viewpager。使viewpager響應事件，再加一個點觸碰viewpager。如此不斷加點，可以看到viewpager響應後加上去點的事件，這是爲何呢？代碼B第108--111行已經告訴咱們了，再也不解釋。blog

四、viewpager有趣的現象。操做：對於前面不不斷加上去的觸點，假設現在一共同擁有4個觸點。現在響應第4個觸點的事件，假設第4個觸點擡起，那麼viewpager響應哪一個觸點的事件呢？答案是第一個。

規律是什麼呢？擡起的觸點不是當前響應的。那麼沒影響；假設是當前響應的：假設擡起的觸點的pointerIndex不是0，那麼由pointerIndex最小的觸點來響應，因此由第一個來響應。代碼C已經很是明顯告訴咱們了。

假設這裏你看不懂，那麼你要學習一下android是怎麼處理多觸點事件的就會明確了。

Demo

下載地址：http://download.csdn.net/detail/u011647962/8507523

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程