天天看點
傳回

Android 4.0 Launcher源碼分析系列(三)

首先傻蛋先畫了個圖來再來闡述一下WorkSpace的結構。如下圖：

Android 4.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.      acquireVelocityTrackerAndAddMovement(ev);        
    12.           
  12.      // Skip touch handling if there are no pages to swipe        
    13.       
  13.      // 如果沒有頁面，則跳過操作。        
    14.       
  14.      if (getChildCount() <= 0) return super.onInterceptTouchEvent(ev);        
    15.           
  15.      /*        
    16.       
  16.       * Shortcut the most recurring case: the user is in the dragging        
    17.       
  17.       * state and he is moving his finger.  We want to intercept this        
    18.       
  18.       * motion.        
    19.       
  19.       * shortcut最常見的情況是：使用者處于拖動的狀态下，同時在移動它的手指，這時候我們需要攔截這個動作。        
    20.       
  20.       *         
    21.       
  21.       */        
    22.       
  22.      final int action = ev.getAction();        
    23.       
  23.      //如果是在MOVE的情況下，則進行Touch事件攔截        
    24.       
  24.      if ((action == MotionEvent.ACTION_MOVE) &&                      
    25.       
  25.              (mTouchState == TOUCH_STATE_SCROLLING)) {        
    26.       
  26.          return true;        
    27.       
  27.      }        
    28.           
  28.      switch (action & MotionEvent.ACTION_MASK) {        
    29.       
  29.          case MotionEvent.ACTION_MOVE: {        
    30.       
  30.              /*        
    31.       
  31.               * mIsBeingDragged == false, otherwise the shortcut would have caught it. Check        
    32.       
  32.               * whether the user has moved far enough from his original down touch.        
    33.       
  33.               * 如果mIsBeingDragged==false ,否則快捷方式應該捕獲到該事件，檢查一下使用者從它點選的地方位移是否足夠        
    34.       
  34.               */        
    35.       
  35.              if (mActivePointerId != INVALID_POINTER) {        
    36.       
  36.                  //根據移動的距離判斷是翻頁還是移動一段位移，同時設定lastMotionX或者mTouchState這些值。同時取消桌面長按事件。        
    37.       
  37.                  determineScrollingStart(ev);        
    38.       
  38.                  break;        
    39.       
  39.              }        
    40.       
  40.              // if mActivePointerId is INVALID_POINTER, then we must have missed an ACTION_DOWN        
    41.       
  41.              // event. in that case, treat the first occurence of a move event as a ACTION_DOWN        
    42.       
  42.              // i.e. fall through to the next case (don't break)        
    43.       
  43.              // (We sometimes miss ACTION_DOWN events in Workspace because it ignores all events        
    44.       
  44.              // while it's small- this was causing a crash before we checked for INVALID_POINTER)        
    45.       
  45.              // 如果mActivePointerId 是 INVALID_POINTER，這時候我們應該已經錯過了ACTION_DOWN事件。在這種情況下，把        
    46.       
  46.              // 第一次發生移動的事件當作ACTION——DOWN事件，直接進入下一個情況下。        
    47.       
  47.              // 我們有時候會錯過workspace中的ACTION_DOWN事件，因為在workspace變小的時候會忽略掉所有的事件。                        
    48.       
  48.          }        
    49.           
  49.          case MotionEvent.ACTION_DOWN: {        
    50.       
  50.              final float x = ev.getX();        
    51.       
  51.              final float y = ev.getY();        
    52.       
  52.              // Remember location of down touch        
    53.       
  53.              // 記錄按下的位置        
    54.       
  54.              mDownMotionX = x;        
    55.       
  55.              mLastMotionX = x;        
    56.       
  56.              mLastMotionY = y;        
    57.       
  57.              mLastMotionXRemainder = 0;        
    58.       
  58.              mTotalMotionX = 0;        
    59.       
  59.              //Return the pointer identifier associated with a particular pointer data index is this event.         
    60.       
  60.              //The identifier tells you the actual pointer number associated with the data,         
    61.       
  61.              //accounting for individual pointers going up and down since the start of the current gesture.        
    62.       
  62.              //傳回和這個事件關聯的觸點資料id，計算單獨點的id會上下浮動，因為手勢的起始位置揮發聲改變。        
    63.       
  63.              mActivePointerId = ev.getPointerId(0);        
    64.       
  64.              mAllowLongPress = true;        
    65.           
  65.              /*        
    66.       
  66.               * If being flinged and user touches the screen, initiate drag;        
    67.       
  67.               * otherwise don't.  mScroller.isFinished should be false when        
    68.       
  68.               * being flinged.        
    69.       
  69.               * 如果被拖動同時使用者觸摸到了螢幕，就開始初始化拖動，否則便不會。        
    70.       
  70.               * 當拖動完成後mScroller.isFinished就應該設定為false.        
    71.       
  71.               *         
    72.       
  72.               */        
    73.       
  73.              final int xDist = Math.abs(mScroller.getFinalX() - mScroller.getCurrX());        
    74.           
  74.              final boolean finishedScrolling = (mScroller.isFinished() || xDist < mTouchSlop);        
    75.       
  75.              if (finishedScrolling) {        
    76.       
  76.                  //标記為TOUCH_STATE_REST狀态        
    77.       
  77.                  mTouchState = TOUCH_STATE_REST;        
    78.       
  78.                  //取消滾動動畫        
    79.       
  79.                  mScroller.abortAnimation();        
    80.       
  80.              } else {        
    81.       
  81.                  //狀态為TOUCH_STATE_SCROLLING        
    82.       
  82.                  mTouchState = TOUCH_STATE_SCROLLING;        
    83.       
  83.              }        
    84.           
  84.              // check if this can be the beginning of a tap on the side of the pages        
    85.       
  85.              // to scroll the current page        
    86.       
  86.              // 檢測此事件是不是開始于點選頁面的邊緣來對目前頁面進行滾動。                        
    87.       
  87.              if (mTouchState != TOUCH_STATE_PREV_PAGE && mTouchState != TOUCH_STATE_NEXT_PAGE) {        
    88.       
  88.                  if (getChildCount() > 0) {        
    89.       
  89.                      //根據觸點的點位來判斷是否點選到上一頁，進而更新相應的狀态        
    90.       
  90.                      if (hitsPreviousPage(x, y)) {        
    91.       
  91.                          mTouchState = TOUCH_STATE_PREV_PAGE;        
    92.       
  92.                      } else if (hitsNextPage(x, y)) {        
    93.       
  93.                          mTouchState = TOUCH_STATE_NEXT_PAGE;        
    94.       
  94.                      }        
    95.       
  95.                  }        
    96.       
  96.              }        
    97.       
  97.              break;        
    98.       
  98.          }        
    99.           
  99.          case MotionEvent.ACTION_UP:        
    100.       
  100.          case MotionEvent.ACTION_CANCEL:        
    101.       
  101.              //觸點不被相應時，所做的動作        
    102.       
  102.              mTouchState = TOUCH_STATE_REST;        
    103.       
  103.              mAllowLongPress = false;        
    104.       
  104.              mActivePointerId = INVALID_POINTER;        
    105.       
  105.              //釋放速率跟蹤        
    106.       
  106.              releaseVelocityTracker();        
    107.       
  107.              break;        
    108.           
  108.          case MotionEvent.ACTION_POINTER_UP:        
    109.       
  109.              onSecondaryPointerUp(ev);        
    110.       
  110.              releaseVelocityTracker();        
    111.       
  111.              break;        
    112.       
  112.      }        
    113.           
  113.      /*        
    114.       
  114.       * The only time we want to intercept motion events is if we are in the        
    115.       
  115.       * drag mode.        
    116.       
  116.       * 我們唯一會去對移動事件進行攔截的情況時我們在拖動模式下        
    117.       
  117.       */        
    118.       
  118.      if(DEBUG) Log.d(TAG, "onInterceptTouchEvent "+(mTouchState != TOUCH_STATE_REST));        
    119.       
  119.      //隻要是mTouchState的狀态不為TOUCH_STATE_REST,那麼就進行事件攔截        
    120.       
  120.      return mTouchState != TOUCH_STATE_REST;        
    121.       
  121.  }        
    122.

onTouchEvent方法，詳細見代碼注釋：

     
  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.      acquireVelocityTrackerAndAddMovement(ev);        
    7.           
  7.      final int action = ev.getAction();        
    8.           
  8.      switch (action & MotionEvent.ACTION_MASK) {        
    9.       
  9.      case MotionEvent.ACTION_DOWN:        
    10.       
  10.          /*        
    11.       
  11.           * If being flinged and user touches, stop the fling. isFinished        
    12.       
  12.           * will be false if being flinged.        
    13.       
  13.           * 如果在滑動的過程中下使用者又點選桌面，則取消滑動，進而響應目前的點選。        
    14.       
  14.           * 在滑動的isFinished将傳回false.        
    15.       
  15.           */        
    16.       
  16.          if (!mScroller.isFinished()) {        
    17.       
  17.              mScroller.abortAnimation();        
    18.       
  18.          }        
    19.           
  19.          // Remember where the motion event started        
    20.       
  20.          mDownMotionX = mLastMotionX = ev.getX();        
    21.       
  21.          mLastMotionXRemainder = 0;        
    22.       
  22.          mTotalMotionX = 0;        
    23.       
  23.          mActivePointerId = ev.getPointerId(0);        
    24.       
  24.          //主要用來顯示滾動條，表明要開始滾動了，這裡可以進行調整，滾動條時逐漸顯示還是立刻顯示。        
    25.       
  25.          if (mTouchState == TOUCH_STATE_SCROLLING) {        
    26.       
  26.              pageBeginMoving();        
    27.       
  27.          }        
    28.       
  28.          break;        
    29.           
  29.      case MotionEvent.ACTION_MOVE:        
    30.       
  30.          if (mTouchState == TOUCH_STATE_SCROLLING) {        
    31.       
  31.              // Scroll to follow the motion event        
    32.       
  32.              final int pointerIndex = ev.findPointerIndex(mActivePointerId);        
    33.       
  33.              final float x = ev.getX(pointerIndex);        
    34.       
  34.              final float deltaX = mLastMotionX + mLastMotionXRemainder - x;        
    35.       
  35.              //總共移動的距離        
    36.       
  36.              mTotalMotionX += Math.abs(deltaX);        
    37.           
  37.              // Only scroll and update mLastMotionX if we have moved some discrete amount.  We        
    38.       
  38.              // keep the remainder because we are actually testing if we've moved from the last        
    39.       
  39.              // scrolled position (which is discrete).        
    40.       
  40.              // 如果我們移動了一小段距離，我們則移動和更新mLastMotionX 。我們儲存Remainder變量是因為會檢測我們        
    41.           
  41.              //是否是從最後的滾動點位移動的。                       
    42.       
  42.              if (Math.abs(deltaX) >= 1.0f) {        
    43.       
  43.                  mTouchX += deltaX;        
    44.       
  44.                  mSmoothingTime = System.nanoTime() / NANOTIME_DIV;        
    45.       
  45.                  if (!mDeferScrollUpdate) {        
    46.       
  46.                      scrollBy((int) deltaX, 0);        
    47.       
  47.                      if (DEBUG) Log.d(TAG, "onTouchEvent().Scrolling: " + deltaX);        
    48.       
  48.                  } else {        
    49.       
  49.                      invalidate();        
    50.       
  50.                  }        
    51.       
  51.                  mLastMotionX = x;        
    52.       
  52.                  mLastMotionXRemainder = deltaX - (int) deltaX;        
    53.       
  53.              } else {        
    54.       
  54.              //Trigger the scrollbars to draw. When invoked this method starts an animation to fade the         
    55.       
  55.              //scrollbars out after a default delay. If a subclass provides animated scrolling,         
    56.       
  56.              //the start delay should equal the duration of the scrolling animation.        
    57.       
  57.              //觸發scrollbar進行繪制。 使用這個方法來啟動一個動畫來使scrollbars經過一段時間淡出。如果子類提供了滾動的動畫，則        
    58.       
  58.              //延遲的時間等于動畫滾動的時間。        
    59.       
  59.                  awakenScrollBars();        
    60.       
  60.              }        
    61.       
  61.          } else {        
    62.       
  62.              determineScrollingStart(ev);        
    63.       
  63.          }        
    64.       
  64.          break;        
    65.           
  65.      case MotionEvent.ACTION_UP:        
    66.       
  66.          if (mTouchState == TOUCH_STATE_SCROLLING) {        
    67.       
  67.              final int activePointerId = mActivePointerId;        
    68.       
  68.              final int pointerIndex = ev.findPointerIndex(activePointerId);        
    69.       
  69.              final float x = ev.getX(pointerIndex);        
    70.       
  70.              final VelocityTracker velocityTracker = mVelocityTracker;        
    71.       
  71.              velocityTracker.computeCurrentVelocity(1000, mMaximumVelocity);        
    72.       
  72.              int velocityX = (int) velocityTracker.getXVelocity(activePointerId);        
    73.       
  73.              final int deltaX = (int) (x - mDownMotionX);        
    74.       
  74.              final int pageWidth = getScaledMeasuredWidth(getPageAt(mCurrentPage));        
    75.       
  75.              // 螢幕的寬度*0.4f        
    76.       
  76.              boolean isSignificantMove = Math.abs(deltaX) > pageWidth *        
    77.       
  77.                      SIGNIFICANT_MOVE_THRESHOLD;        
    78.       
  78.              final int snapVelocity = mSnapVelocity;        
    79.           
  79.              mTotalMotionX += Math.abs(mLastMotionX + mLastMotionXRemainder - x);        
    80.           
  80.              boolean isFling = mTotalMotionX > MIN_LENGTH_FOR_FLING &&        
    81.       
  81.                      Math.abs(velocityX) > snapVelocity;        
    82.           
  82.              // In the case that the page is moved far to one direction and then is flung        
    83.       
  83.              // in the opposite direction, we use a threshold to determine whether we should        
    84.       
  84.              // just return to the starting page, or if we should skip one further.        
    85.       
  85.              // 這鐘情況是頁面朝一個方向移動了一段距離，然後又彈回去了。我們使用一個閥值來判斷是進行翻頁還是傳回到初始頁面                
    86.       
  86.              boolean returnToOriginalPage = false;        
    87.       
  87.              if (Math.abs(deltaX) > pageWidth * RETURN_TO_ORIGINAL_PAGE_THRESHOLD &&        
    88.       
  88.                      Math.signum(velocityX) != Math.signum(deltaX) && isFling) {        
    89.       
  89.                  returnToOriginalPage = true;        
    90.       
  90.              }        
    91.           
  91.              int finalPage;        
    92.       
  92.              // We give flings precedence over large moves, which is why we short-circuit our        
    93.       
  93.              // test for a large move if a fling has been registered. That is, a large        
    94.       
  94.              // move to the left and fling to the right will register as a fling to the right.        
    95.       
  95.              //朝右移動        
    96.       
  96.              if (((isSignificantMove && deltaX > 0 && !isFling) ||        
    97.       
  97.                      (isFling && velocityX > 0)) && mCurrentPage > 0) {        
    98.       
  98.                  finalPage = returnToOriginalPage ? mCurrentPage : mCurrentPage - 1;        
    99.       
  99.                  snapToPageWithVelocity(finalPage, velocityX);        
    100.       
  100.              //朝左移動        
    101.       
  101.              } else if (((isSignificantMove && deltaX < 0 && !isFling) ||        
    102.       
  102.                      (isFling && velocityX < 0)) &&        
    103.       
  103.                      mCurrentPage < getChildCount() - 1) {        
    104.       
  104.                  finalPage = returnToOriginalPage ? mCurrentPage : mCurrentPage + 1;        
    105.       
  105.                  snapToPageWithVelocity(finalPage, velocityX);        
    106.       
  106.              //尋找離螢幕中心最近的頁面移動        
    107.       
  107.              } else {        
    108.       
  108.                  snapToDestination();        
    109.       
  109.              }        
    110.       
  110.          }        
    111.       
  111.           //直接移動到前一頁        
    112.       
  112.           else if (mTouchState == TOUCH_STATE_PREV_PAGE) {        
    113.       
  113.              // at this point we have not moved beyond the touch slop        
    114.       
  114.              // (otherwise mTouchState would be TOUCH_STATE_SCROLLING), so        
    115.       
  115.              // we can just page        
    116.       
  116.              int nextPage = Math.max(0, mCurrentPage - 1);        
    117.       
  117.              if (nextPage != mCurrentPage) {        
    118.       
  118.                  snapToPage(nextPage);        
    119.       
  119.              } else {        
    120.       
  120.                  snapToDestination();        
    121.       
  121.              }        
    122.       
  122.          }        
    123.       
  123.           //直接移動到下一頁        
    124.       
  124.           else if (mTouchState == TOUCH_STATE_NEXT_PAGE) {        
    125.       
  125.              // at this point we have not moved beyond the touch slop        
    126.       
  126.              // (otherwise mTouchState would be TOUCH_STATE_SCROLLING), so        
    127.       
  127.              // we can just page        
    128.       
  128.              int nextPage = Math.min(getChildCount() - 1, mCurrentPage + 1);        
    129.       
  129.              if (nextPage != mCurrentPage) {        
    130.       
  130.                  snapToPage(nextPage);        
    131.       
  131.              } else {        
    132.       
  132.                  snapToDestination();        
    133.       
  133.              }        
    134.       
  134.          } else {        
    135.       
  135.              onUnhandledTap(ev);        
    136.       
  136.          }        
    137.       
  137.          mTouchState = TOUCH_STATE_REST;        
    138.       
  138.          mActivePointerId = INVALID_POINTER;        
    139.       
  139.          releaseVelocityTracker();        
    140.       
  140.          break;        
    141.       
  141.       //對事件不響應        
    142.       
  142.      case MotionEvent.ACTION_CANCEL:        
    143.       
  143.          if (mTouchState == TOUCH_STATE_SCROLLING) {        
    144.       
  144.              snapToDestination();        
    145.       
  145.          }        
    146.       
  146.          mTouchState = TOUCH_STATE_REST;        
    147.       
  147.          mActivePointerId = INVALID_POINTER;        
    148.       
  148.          releaseVelocityTracker();        
    149.       
  149.          break;        
    150.           
  150.      case MotionEvent.ACTION_POINTER_UP:        
    151.       
  151.          onSecondaryPointerUp(ev);        
    152.       
  152.          break;        
    153.       
  153.      }        
    154.           
  154.      return true;        
    155.       
  155.  }        
    156.

最後有個小知識點要搞清楚，不少網友都問到過我。就是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.
android Launcher
上一篇: Android Studio如何更改icon圖示
下一篇: 古城“重制”，是這樣幹出來的（傳承之光）

繼續閱讀