android view原理

 分三個階段來看

第一步需要 知道view的繪製過程

View繪製流程以及invalidate()等相關方法分析

整個View樹的繪圖流程是在ViewRoot.java類的performTraversals()函數展開的，該函數做的執行過程可簡單概況爲

 根據之前設置的狀態，判斷是否需要重新計算視圖大小(measure)、是否重新需要安置視圖的位置(layout)、以及是否需要重繪

 (draw)，其框架過程如下：

                                                                                                   步驟其實爲host.layout() 

           

 

 

      接下來溫習一下整個View樹的結構，對每個具體View對象的操作，其實就是個遞歸的實現。

 

                  

 

流程一：      mesarue()過程

        主要作用：爲整個View樹計算實際的大小，即設置實際的高(對應屬性:mMeasuredHeight)和寬(對應屬性:

  mMeasureWidth)，每個View的控件的實際寬高都是由父視圖和本身視圖決定的。

 

     具體的調用鏈如下：

          ViewRoot根對象地屬性mView(其類型一般爲ViewGroup類型)調用measure()方法去計算View樹的大小，回調

View/ViewGroup對象的onMeasure()方法，該方法實現的功能如下：    

         1、設置本View視圖的最終大小，該功能的實現通過調用setMeasuredDimension()方法去設置實際的高(對應屬性：  

                mMeasuredHeight)和寬(對應屬性：mMeasureWidth)   ；

         2 、如果該View對象是個ViewGroup類型，需要重寫該onMeasure()方法，對其子視圖進行遍歷的measure()過程。

              

               2.1  對每個子視圖的measure()過程，是通過調用父類ViewGroup.java類裏的measureChildWithMargins()方法去

          實現，該方法內部只是簡單地調用了View對象的measure()方法。(由於measureChildWithMargins()方法只是一個過渡

          層更簡單的做法是直接調用View對象的measure()方法)。

              

     整個measure調用流程就是個樹形的遞歸過程

 

     measure函數原型爲 View.java 該函數不能被重載

      

public final void measure(int widthMeasureSpec, int heightMeasureSpec) {
    //....

    //回調onMeasure()方法
    onMeasure(widthMeasureSpec, heightMeasureSpec);

    //more
}

     爲了大家更好的理解，採用“二B程序員”的方式利用僞代碼描述該measure流程

 

//回調View視圖裏的onMeasure過程
private void onMeasure(int height , int width){
 //設置該view的實際寬(mMeasuredWidth)高(mMeasuredHeight)
 //1、該方法必須在onMeasure調用，否者報異常。
 setMeasuredDimension(h , l) ;

 //2、如果該View是ViewGroup類型，則對它的每個子View進行measure()過程
 int childCount = getChildCount() ;

 for(int i=0 ;i<childCount ;i++){
  //2.1、獲得每個子View對象引用
  View child = getChildAt(i) ;

  //整個measure()過程就是個遞歸過程
  //該方法只是一個過濾器，最後會調用measure()過程 ;或者 measureChild(child , h, i)方法都
  measureChildWithMargins(child , h, i) ;

  //其實，對於我們自己寫的應用來說，最好的辦法是去掉框架裏的該方法，直接調用view.measure()，如下：
  //child.measure(h, l)
 }
}

//該方法具體實現在ViewGroup.java裏 。
protected  void measureChildWithMargins(View v, int height , int width){
 v.measure(h,l)
}

流程二、 layout佈局過程：

 

     主要作用 ：爲將整個根據子視圖的大小以及佈局參數將View樹放到合適的位置上。

 

     具體的調用鏈如下：

       host.layout()開始View樹的佈局，繼而回調給View/ViewGroup類中的layout()方法。具體流程如下

  

        1 、layout方法會設置該View視圖位於父視圖的座標軸，即mLeft，mTop，mLeft，mBottom(調用setFrame()函數去實現)

  接下來回調onLayout()方法(如果該View是ViewGroup對象，需要實現該方法，對每個子視圖進行佈局) ；

       

       2、如果該View是個ViewGroup類型，需要遍歷每個子視圖chiildView，調用該子視圖的layout()方法去設置它的座標值。

 

          layout函數原型爲 ，位於View.java

/* final 標識符 ， 不能被重載 ， 參數爲每個視圖位於父視圖的座標軸
 * @param l Left position, relative to parent
 * @param t Top position, relative to parent
 * @param r Right position, relative to parent
 * @param b Bottom position, relative to parent
 */
public final void layout(int l, int t, int r, int b) {
    boolean changed = setFrame(l, t, r, b); //設置每個視圖位於父視圖的座標軸
    if (changed || (mPrivateFlags & LAYOUT_REQUIRED) == LAYOUT_REQUIRED) {
        if (ViewDebug.TRACE_HIERARCHY) {
            ViewDebug.trace(this, ViewDebug.HierarchyTraceType.ON_LAYOUT);
        }

        onLayout(changed, l, t, r, b);//回調onLayout函數 ，設置每個子視圖的佈局
        mPrivateFlags &= ~LAYOUT_REQUIRED;
    }
    mPrivateFlags &= ~FORCE_LAYOUT;
}

    同樣地， 將上面layout調用流程，用僞代碼描述如下： 

// layout()過程  ViewRoot.java
// 發起layout()的"發號者"在ViewRoot.java裏的performTraversals()方法， mView.layout()

private void  performTraversals(){

    //...

    View mView  ;
       mView.layout(left,top,right,bottom) ;

    //....
}

//回調View視圖裏的onLayout過程 ,該方法只由ViewGroup類型實現
private void onLayout(int left , int top , right , bottom){

 //如果該View不是ViewGroup類型
 //調用setFrame()方法設置該控件的在父視圖上的座標軸

 setFrame(l ,t , r ,b) ;

 //--------------------------

 //如果該View是ViewGroup類型，則對它的每個子View進行layout()過程
 int childCount = getChildCount() ;

 for(int i=0 ;i<childCount ;i++){
  //2.1、獲得每個子View對象引用
  View child = getChildAt(i) ;
  //整個layout()過程就是個遞歸過程
  child.layout(l, t, r, b) ;
 }
}

   流程三、 draw()繪圖過程

     由ViewRoot對象的performTraversals()方法調用draw()方法發起繪製該View樹，值得注意的是每次發起繪圖時，並不

  會重新繪製每個View樹的視圖，而只會重新繪製那些“需要重繪”的視圖，View類內部變量包含了一個標誌位DRAWN，當該

視圖需要重繪時，就會爲該View添加該標誌位。

 

   調用流程 ：

     mView.draw()開始繪製，draw()方法實現的功能如下：

          1 、繪製該View的背景

          2 、爲顯示漸變框做一些準備操作(見5，大多數情況下，不需要改漸變框)          

          3、調用onDraw()方法繪製視圖本身   (每個View都需要重載該方法，ViewGroup不需要實現該方法)

          4、調用dispatchDraw ()方法繪製子視圖(如果該View類型不爲ViewGroup，即不包含子視圖，不需要重載該方法)

值得說明的是，ViewGroup類已經爲我們重寫了dispatchDraw ()的功能實現，應用程序一般不需要重寫該方法，但可以重載父類

  函數實現具體的功能。

 

            4.1 dispatchDraw()方法內部會遍歷每個子視圖，調用drawChild()去重新回調每個子視圖的draw()方法(注意，這個 

地方“需要重繪”的視圖纔會調用draw()方法)。值得說明的是，ViewGroup類已經爲我們重寫了dispatchDraw()的功能

實現，應用程序一般不需要重寫該方法，但可以重載父類函數實現具體的功能。

    

     5、繪製滾動條

 

  於是，整個調用鏈就這樣遞歸下去了。

    

     同樣地，使用僞代碼描述如下：

    

// draw()過程     ViewRoot.java
// 發起draw()的"發號者"在ViewRoot.java裏的performTraversals()方法， 該方法會繼續調用draw()方法開始繪圖
private void  draw(){

    //...
 View mView  ;
    mView.draw(canvas) ;

    //....
}

//回調View視圖裏的onLayout過程 ,該方法只由ViewGroup類型實現
private void draw(Canvas canvas){
 //該方法會做如下事情
 //1 、繪製該View的背景
 //2、爲繪製漸變框做一些準備操作
 //3、調用onDraw()方法繪製視圖本身
 //4、調用dispatchDraw()方法繪製每個子視圖，dispatchDraw()已經在Android框架中實現了，在ViewGroup方法中。
      // 應用程序程序一般不需要重寫該方法，但可以捕獲該方法的發生，做一些特別的事情。
 //5、繪製漸變框
}

//ViewGroup.java中的dispatchDraw()方法，應用程序一般不需要重寫該方法
@Override
protected void dispatchDraw(Canvas canvas) {
 //
 //其實現方法類似如下：
 int childCount = getChildCount() ;

 for(int i=0 ;i<childCount ;i++){
  View child = getChildAt(i) ;
  //調用drawChild完成
  drawChild(child,canvas) ;
 }
}
//ViewGroup.java中的dispatchDraw()方法，應用程序一般不需要重寫該方法
protected void drawChild(View child,Canvas canvas) {
 // ....
 //簡單的回調View對象的draw()方法，遞歸就這麼產生了。
 child.draw(canvas) ;

 //.........
}

   

View(視圖)繪製不同狀態背景圖片原理

1、View的幾種不同狀態屬性

           2、如何根據不同狀態去切換我們的背景圖片。

 

 

開篇介紹：android背景選擇器selector用法彙總

        對Android開發有經驗的同學，對 <selector>節點的使用一定很熟悉，該節點的作用就是定義一組狀態資源圖片，使其能夠

  在不同的狀態下更換某個View的背景圖片。例如，如下的hello_selection.xml文件定義：

<?xml version="1.0" encoding="utf-8" ?>
<selector xmlns:android="http://schemas.android.com/apk/res/android">
  <!-- 觸摸時並且當前窗口處於交互狀態 -->
  <item android:state_pressed="true" android:state_window_focused="true" android:drawable= "@drawable/pic1" />
  <!--  觸摸時並且沒有獲得焦點狀態 -->
  <item android:state_pressed="true" android:state_focused="false" android:drawable="@drawable/pic2" />
  <!--選中時的圖片背景-->
  <item android:state_selected="true" android:drawable="@drawable/pic3" />
  <!--獲得焦點時的圖片背景-->
  <item android:state_focused="true" android:drawable="@drawable/pic4" />
  <!-- 窗口沒有處於交互時的背景圖片 -->
  <item android:drawable="@drawable/pic5" />
</selector>

           更多關於 <selector>節點的使用請參考該博客<android背景選擇器selector用法彙總>

       其實，前面說的xml文件，最終會被Android框架解析成StateListDrawable類對象。

 

 

知識點一：StateListDrawable類介紹

    類功能說明：該類定義了不同狀態值下與之對應的圖片資源，即我們可以利用該類保存多種狀態值，多種圖片資源。

    常用方法爲：

       public void addState (int[] stateSet, Drawable drawable)

       功能： 給特定的狀態集合設置drawable圖片資源

       使用方式：參考前面的hello_selection.xml文件，我們利用代碼去構建一個相同的StateListDrawable類對象，如下：

//初始化一個空對象
StateListDrawable stalistDrawable = new StateListDrawable();
//獲取對應的屬性值 Android框架自帶的屬性 attr
int pressed = android.R.attr.state_pressed;
int window_focused = android.R.attr.state_window_focused;
int focused = android.R.attr.state_focused;
int selected = android.R.attr.state_selected;

stalistDrawable.addState(new int []{pressed , window_focused}, getResources().getDrawable(R.drawable.pic1));
stalistDrawable.addState(new int []{pressed , -focused}, getResources().getDrawable(R.drawable.pic2);
stalistDrawable.addState(new int []{selected }, getResources().getDrawable(R.drawable.pic3);
stalistDrawable.addState(new int []{focused }, getResources().getDrawable(R.drawable.pic4);
//沒有任何狀態時顯示的圖片，我們給它設置我空集合
stalistDrawable.addState(new int []{}, getResources().getDrawable(R.drawable.pic5);

       

        上面的“-”負號表示對應的屬性值爲false

        當我們爲某個View使用其作爲背景色時，會根據狀態進行背景圖的轉換。

      public boolean isStateful ()

     功能： 表明該狀態改變了，對應的drawable圖片是否會改變。

     注：在StateListDrawable類中，該方法返回爲true，顯然狀態改變後，我們的圖片會跟着改變。

 

知識點二：View的五種狀態值

 

       一般來說，Android框架爲View定義了四種不同的狀態，這些狀態值的改變會引發View相關操作，例如：更換背景圖片、是否

   觸發點擊事件等；視

      視圖幾種不同狀態含義見下圖：

                             

     

   其中selected和focused的區別有如下幾點：

      1，我們通過查看setSelected()方法，來獲取相關信息。

        SDK中對setSelected()方法----對於與selected狀態有如下說明：

             public void setSelected (boolean selected)

             Since: APILevel 1

             Changes the selection state of this view. Aview can be selected or not. Note that selection is not the same as

        focus. Views are typically selected in the context of an AdapterView like ListView or GridView ;the selected view is 

        the view that is highlighted.

            Parameters selected   true if the view must be selected, false otherwise

           由以上可知：selected不同於focus狀態，通常在AdapterView類羣下例如ListView或者GridView會使某個View處於

     selected狀態，並且獲得該狀態的View處於高亮狀態。

 

    2、一個窗口只能有一個視圖獲得焦點(focus)，而一個窗口可以有多個視圖處於”selected”狀態中。

 

      總結：focused狀態一般是由按鍵操作引起的；

                pressed狀態是由觸摸消息引起的；

                selected則完全是由應用程序主動調用setSelected()進行控制。

 

      例如：當我們觸摸某個控件時，會導致pressed狀態改變；獲得焦點時，會導致focus狀態變化。於是，我們可以通過這種

   更新後狀態值去更新我們對應的Drawable對象了。

 

問題：如何根據狀態值的改變去繪製/顯示對應的背景圖？

       當View任何狀態值發生改變時，都會調用refreshDrawableList()方法去更新對應的背景Drawable對象。

       其整體調用流程如下： View.java類中

//路徑：\frameworks\base\core\java\android\view\View.java
    /* Call this to force a view to update its drawable state. This will cause
     * drawableStateChanged to be called on this view. Views that are interested
     * in the new state should call getDrawableState.
     */
    //主要功能是根據當前的狀態值去更換對應的背景Drawable對象
    public void refreshDrawableState() {
        mPrivateFlags |= DRAWABLE_STATE_DIRTY;
        //所有功能在這個函數裏去完成
        drawableStateChanged();
        ...
    }
    /* This function is called whenever the state of the view changes in such
     * a way that it impacts the state of drawables being shown.
     */
    // 獲得當前的狀態屬性--- 整型集合 ； 調用Drawable類的setState方法去獲取資源。
    protected void drawableStateChanged() {
        //該視圖對應的Drawable對象，通常對應於StateListDrawable類對象
        Drawable d = mBGDrawable;
        if (d != null && d.isStateful()) {  //通常都是成立的
            //getDrawableState()方法主要功能：會根據當前View的狀態屬性值，將其轉換爲一個整型集合
            //setState()方法主要功能：根據當前的獲取到的狀態，更新對應狀態下的Drawable對象。
            d.setState(getDrawableState());
        }
    }
    /*Return an array of resource IDs of the drawable states representing the
     * current state of the view.
     */
    public final int[] getDrawableState() {
        if ((mDrawableState != null) && ((mPrivateFlags & DRAWABLE_STATE_DIRTY) == 0)) {
            return mDrawableState;
        } else {
            //根據當前View的狀態屬性值，將其轉換爲一個整型集合，並返回
            mDrawableState = onCreateDrawableState(0);
            mPrivateFlags &= ~DRAWABLE_STATE_DIRTY;
            return mDrawableState;
        }
    }

       通過這段代碼我們可以明白View內部是如何獲取更細後的狀態值以及動態獲取對應的背景Drawable對象----setState()方法

去完成的。這兒我簡單的分析下Drawable類裏的setState()方法的功能，把流程給走一下：

    

         Step 1 、 setState()函數原型 ，

             函數位於：frameworks\base\graphics\java\android\graphics\drawable\StateListDrawable.java 類中

//如果狀態態值發生了改變，就回調onStateChange()方法。
public boolean setState(final int[] stateSet) {
    if (!Arrays.equals(mStateSet, stateSet)) {
        mStateSet = stateSet;
        return onStateChange(stateSet);
    }
    return false;
}

           該函數的主要功能： 判斷狀態值是否發生了變化，如果發生了變化，就調用onStateChange()方法進一步處理。

    

       Step 2 、onStateChange()函數原型：

            該函數位於 frameworks\base\graphics\java\android\graphics\drawable\StateListDrawable.java 類中

//狀態值發生了改變，我們需要找出第一個吻合的當前狀態的Drawable對象
protected boolean onStateChange(int[] stateSet) {
    //要找出第一個吻合的當前狀態的Drawable對象所在的索引位置， 具體匹配算法請自己深入源碼看看
    int idx = mStateListState.indexOfStateSet(stateSet);
    ...
    //獲取對應索引位置的Drawable對象
    if (selectDrawable(idx)) {
        return true;
    }
    ...
}

          該函數的主要功能： 根據新的狀態值，從StateListDrawable實例對象中，找到第一個完全吻合該新狀態值的索引下標處 ；

   繼而，調用selectDrawable()方法去獲取索引下標的當前Drawable對象。

         具體查找算法在 mStateListState.indexOfStateSet(stateSet) 裏實現了。基本思路是：查找第一個能完全吻合該新狀態值

   的索引下標，如果找到了，則立即返回。 具體實現過程，只好看看源碼咯。

  

       Step 3 、selectDrawable()函數原型：

            該函數位於 frameworks\base\graphics\java\android\graphics\drawable\StateListDrawable.java 類中

public boolean selectDrawable(int idx)
{
    if (idx >= 0 && idx < mDrawableContainerState.mNumChildren) {
        //獲取對應索引位置的Drawable對象
        Drawable d = mDrawableContainerState.mDrawables[idx];
        ...
        mCurrDrawable = d; //mCurrDrawable即使當前Drawable對象
        mCurIndex = idx;
        ...
    } else {
       ...
    }
    //請求該View刷新自己,這個方法我們稍後講解。
    invalidateSelf();
    return true;
}

             該函數的主要功能是選擇當前索引下標處的Drawable對象，並保存在mCurrDrawable中。

知識點三： 關於Drawable.Callback接口

   

    該接口定義瞭如下三個函數：     

//該函數位於 frameworks\base\graphics\java\android\graphics\drawable\Drawable.java 類中
public static interface Callback {
    //如果Drawable對象的狀態發生了變化，會請求View重新繪製，
    //因此我們對應於該View的背景Drawable對象能夠”繪製出來”.
    public void invalidateDrawable(Drawable who);
    //該函數目前還不懂
    public void scheduleDrawable(Drawable who, Runnable what, long when);
     //該函數目前還不懂
    public void unscheduleDrawable(Drawable who, Runnable what);
}

其中比較重要的函數爲：

      public voidinvalidateDrawable(Drawable who)

        函數功能：如果Drawable對象的狀態發生了變化，會請求View重新繪製，因此我們對應於該View的背景Drawable對象

   能夠重新”繪製“出來。

    Android框架View類繼承了該接口，同時實現了這三個函數的默認處理方式，其中invalidateDrawable()方法如下：

public class View implements Drawable.Callback, KeyEvent.Callback, AccessibilityEventSource
{
    ...
    //Invalidates the specified Drawable.
    //默認實現，重新繪製該視圖本身
    public void invalidateDrawable(Drawable drawable) {
        if (verifyDrawable(drawable)) { //是否是同一個Drawable對象，通常爲真
            final Rect dirty = drawable.getBounds();
            final int scrollX = mScrollX;
            final int scrollY = mScrollY;
            //重新請求繪製該View，即重新調用該View的draw()方法  ...
            invalidate(dirty.left + scrollX, dirty.top + scrollY,
                    dirty.right + scrollX, dirty.bottom + scrollY);
        }
    }
    ...
}

   因此，我們的Drawable類對象必須將View設置爲回調對象，否則，即使改變了狀態，也不會顯示對應的背景圖。 如下：

            Drawable d  ;                // 圖片資源                        

            d.setCallback(View v) ;  // 視圖v的背景資源爲 d 對象

 

知識點四：View繪製背景圖片過程

      在前面的博客中《Android中View繪製流程以及invalidate()等相關方法分析》，我們知道了一個視圖的背景繪製過程時在

  View類裏的draw()方法裏完成的，我們這兒在回顧下draw()的流程，同時重點講解下繪製背景的操作。

//方法所在路徑：frameworks\base\core\java\android\view\View.java
//draw()繪製過程
private void draw(Canvas canvas){
//該方法會做如下事情
  //1 、繪製該View的背景
    //其中背景圖片繪製過程如下：
    //是否透明， 視圖通常是透明的 ， 爲true
     if (!dirtyOpaque) {
       //開始繪製視圖的背景
       final Drawable background = mBGDrawable;
       if (background != null) {
           final int scrollX = mScrollX;  //獲取偏移值
           final int scrollY = mScrollY;
           //視圖的佈局座標是否發生了改變， 即是否重新layout了。
           if (mBackgroundSizeChanged) {
             //如果是，我們的Drawable對象需要重新設置大小了，即填充該View。
               background.setBounds(0, 0,  mRight - mLeft, mBottom - mTop);
               mBackgroundSizeChanged = false;
           }
           //View沒有發生偏移
           if ((scrollX | scrollY) == 0) {
               background.draw(canvas); //OK， 該方法會繪製當前StateListDrawable的當前背景Drawable
           } else {
             //View發生偏移，由於背景圖片值顯示在佈局座標中，即背景圖片不會發生偏移，只有視圖內容onDraw()會發生偏移
             //我們調整canvas對象的繪製區域，繪製完成後對canvas對象屬性調整回來
               canvas.translate(scrollX, scrollY);
               background.draw(canvas); //OK， 該方法會繪製當前StateListDrawable的當前背景Drawable
               canvas.translate(-scrollX, -scrollY);
           }
       }
   }
    ...
 //2、爲繪製漸變框做一些準備操作
 //3、調用onDraw()方法繪製視圖本身
 //4、調用dispatchDraw()方法繪製每個子視圖，dispatchDraw()已經在Android框架中實現了，在ViewGroup方法中。
 //5、繪製漸變框
}

      That's all ! 我們用到的知識點也就這麼多吧。 如果大家有絲絲不明白的話，可以去看下源代碼，具體去分析下這些流程到底

  是怎麼走下來的。

      我們從宏觀的角度分析了View繪製不同狀態背景的原理，View框架就是這麼做的。爲了易於理解性，

  下面我們通過一個小Demo來演示前面種種流程。

   

 Demo 說明：

          我們參照View框架中繪製不同背景圖的實現原理，自定義一個View類，通過給它設定StateListDrawable對象，使其能夠在

   不同狀態時能動態"繪製"背景圖片。 基本流程方法和View.java類實現過程一模一樣。

    截圖如下：

                      

                 初始背景圖                                                            觸摸後顯示的背景圖(pressed)

  一、主文件MainActivity.java如下：

/**
 *
 * @author http://http://blog.csdn.net/qinjuning
 */
public class MainActivity extends Activity
{

    @Override
    public void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);

        LinearLayout ll  =  new LinearLayout(MainActivity.this);
        CustomView customView = new CustomView(MainActivity.this);
        //簡單設置爲 width 200px - height 100px吧
        ViewGroup.LayoutParams lp = new ViewGroup.LayoutParams(200 , 100);
        customView.setLayoutParams(lp);
        //需要將該View設置爲可點擊/觸摸狀態，否則觸摸該View沒有效果。
        customView.setClickable(true);

        ll.addView(customView);
        setContentView(ll);
    }
}

   功能很簡單，爲Activity設置了視圖 。

二、 自定義View如下 ， CustomView.java :

/**
 * @author http://http://blog.csdn.net/qinjuning
 */
//自定義View
public class CustomView extends View   /*extends Button*/
{
    private static String TAG = "TackTextView";

    private Context mContext = null;
    private Drawable mBackground = null;
    private boolean mBGSizeChanged = true;;   //視圖View佈局(layout)大小是否發生變化

    public CustomView(Context context)
    {
        super(context);
        mContext = context;
        initStateListDrawable(); // 初始化圖片資源
    }

    // 初始化圖片資源
    private void initStateListDrawable()
    {
        //有兩種方式獲取我們的StateListDrawable對象：
        // 獲取方式一、手動構建一個StateListDrawable對象
        StateListDrawable statelistDrawable = new StateListDrawable();

        int pressed = android.R.attr.state_pressed;
        int windowfocused = android.R.attr.state_window_focused;
        int enabled = android.R.attr.state_enabled;
        int stateFoucesd = android.R.attr.state_focused;
        //匹配狀態時，是一種優先包含的關係。
        // "-"號表示該狀態值爲false .即不匹配
        statelistDrawable.addState(new int[] { pressed, windowfocused },
                mContext.getResources().getDrawable(R.drawable.btn_power_on_pressed));
        statelistDrawable.addState(new int[]{ -pressed, windowfocused },
                mContext.getResources().getDrawable(R.drawable.btn_power_on_nor));

        mBackground = statelistDrawable;

        //必須設置回調，當改變狀態時，會回掉該View進行invalidate()刷新操作.
        mBackground.setCallback(this);
        //取消默認的背景圖片，因爲我們設置了自己的背景圖片了，否則可能造成背景圖片重疊。
        this.setBackgroundDrawable(null);

        // 獲取方式二、、使用XML獲取StateListDrawable對象
        // mBackground = mContext.getResources().getDrawable(R.drawable.tv_background);
    }

    protected void drawableStateChanged()
    {
        Log.i(TAG, "drawableStateChanged");
        Drawable d = mBackground;
        if (d != null && d.isStateful())
        {
            d.setState(getDrawableState());
            Log.i(TAG, "drawableStateChanged  and is 111");
        }

       Log.i(TAG, "drawableStateChanged  and is 222");
       super.drawableStateChanged();
    }
    //驗證圖片是否相等 , 在invalidateDrawable()會調用此方法，我們需要重寫該方法。
    protected boolean verifyDrawable(Drawable who)
    {
        return who == mBackground || super.verifyDrawable(who);
    }
    //draw()過程，繪製背景圖片...
    public void draw(Canvas canvas)
    {
        Log.i(TAG, " draw -----");
        if (mBackground != null)
        {
            if(mBGSizeChanged)
            {
                //設置邊界範圍
                mBackground.setBounds(0, 0, getRight() - getLeft(), getBottom() - getTop());
                mBGSizeChanged = false ;
            }
            if ((getScrollX() | getScrollY()) == 0)  //是否偏移
            {
                mBackground.draw(canvas); //繪製當前狀態對應的圖片
            }
            else
            {
                canvas.translate(getScrollX(), getScrollY());
                mBackground.draw(canvas); //繪製當前狀態對應的圖片
                canvas.translate(-getScrollX(), -getScrollY());
            }
        }
        super.draw(canvas);
    }
    public void onDraw(Canvas canvas) {
        ...
    }
}

   將該View設置的背景圖片轉換爲節點xml，形式如下：

<selector xmlns:android="http://schemas.android.com/apk/res/android">
  <item android:state_pressed="true"
        android:state_window_focused="true"
        android:drawable="@drawable/btn_power_on_pressed"></item>
  <item android:state_pressed="false"
        android:state_window_focused="true"
        android:drawable="@drawable/btn_power_on_nor"></item>

</selector>

    強調一點的就是，在這三個流程中，Google已經幫我們把draw()過程框架已經寫好了，自定義的ViewGroup只需要實現

 measure()過程和layout()過程即可 。

     這三種情況，最終會直接或間接調用到三個函數，分別爲invalidate()，requsetLaytout()以及requestFocus() ，接着

這三個函數最終會調用到ViewRoot中的schedulTraversale()方法，該函數然後發起一個異步消息，消息處理中調用

performTraverser()方法對整個View進行遍歷。

 

 

    invalidate()方法 ：

 

   說明：請求重繪View樹，即draw()過程，假如視圖發生大小沒有變化就不會調用layout()過程，並且只繪製那些“需要重繪的”

視圖，即誰(View的話，只繪製該View ；ViewGroup，則繪製整個ViewGroup)請求invalidate()方法，就繪製該視圖。

 

     一般引起invalidate()操作的函數如下：

            1、直接調用invalidate()方法，請求重新draw()，但只會繪製調用者本身。

            2、setSelection()方法 ：請求重新draw()，但只會繪製調用者本身。

            3、setVisibility()方法 ： 當View可視狀態在INVISIBLE轉換VISIBLE時，會間接調用invalidate()方法，

                     繼而繪製該View。

            4 、setEnabled()方法 ： 請求重新draw()，但不會重新繪製任何視圖包括該調用者本身。

 

    requestLayout()方法 ：會導致調用measure()過程 和 layout()過程 。

 

           說明：只是對View樹重新佈局layout過程包括measure()和layout()過程，不會調用draw()過程，但不會重新繪製

任何視圖包括該調用者本身。

 

    一般引起invalidate()操作的函數如下：

         1、setVisibility()方法：

             當View的可視狀態在INVISIBLE/ VISIBLE 轉換爲GONE狀態時，會間接調用requestLayout() 和invalidate方法。

    同時，由於整個個View樹大小發生了變化，會請求measure()過程以及draw()過程，同樣地，只繪製需要“重新繪製”的視圖。

 

    requestFocus()函數說明：

 

          說明：請求View樹的draw()過程，但只繪製“需要重繪”的視圖。

 

 

    下面寫個簡單的小Demo吧，主要目的是給大家演示繪圖的過程以及每個流程裏該做的一些功能。截圖如下：

                                                

 1、    MyViewGroup.java  自定義ViewGroup類型

   

/**
 * @author http://http://blog.csdn.net/qinjuning
 */
//自定義ViewGroup 對象
public class MyViewGroup  extends ViewGroup{


    private static String TAG = "MyViewGroup" ;
    private Context mContext ;

    public MyViewGroup(Context context) {
        super(context);
        mContext = context ;
        init() ;
    }

    //xml定義的屬性,需要該構造函數
    public MyViewGroup(Context context , AttributeSet attrs){
        super(context,attrs) ;
        mContext = context ;
        init() ;
    }

    //爲MyViewGroup添加三個子View
    private void init(){
        //調用ViewGroup父類addView()方法添加子View

        //child 對象一 ： Button
        Button btn= new Button(mContext) ;
        btn.setText("I am Button") ;
        this.addView(btn) ;

        //child 對象二 : ImageView
        ImageView img = new ImageView(mContext) ;
        img.setBackgroundResource(R.drawable.icon) ;
        this.addView(img) ;

        //child 對象三 : TextView
        TextView txt = new TextView(mContext) ;
        txt.setText("Only Text") ;
        this.addView(txt) ;

        //child 對象四 ： 自定義View
        MyView myView = new MyView(mContext) ;
        this.addView(myView) ;
    }

    @Override
    //對每個子View進行measure():設置每子View的大小，即實際寬和高
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec){
        //通過init()方法，我們爲該ViewGroup對象添加了三個視圖 ， Button、 ImageView、TextView
        int childCount = getChildCount() ;
        Log.i(TAG, "the size of this ViewGroup is ----> " + childCount) ;

        Log.i(TAG, "**** onMeasure start *****") ;

        //獲取該ViewGroup的實際長和寬  涉及到MeasureSpec類的使用
        int specSize_Widht = MeasureSpec.getSize(widthMeasureSpec) ;
        int specSize_Heigth = MeasureSpec.getSize(heightMeasureSpec) ;

        Log.i(TAG, "**** specSize_Widht " + specSize_Widht+ " * specSize_Heigth   *****" + specSize_Heigth) ;

        //設置本ViewGroup的寬高
        setMeasuredDimension(specSize_Widht , specSize_Heigth) ;




        for(int i=0 ;i<childCount ; i++){
            View child = getChildAt(i) ;   //獲得每個對象的引用
            child.measure(50, 50) ;   //簡單的設置每個子View對象的寬高爲 50px , 50px
            //或者可以調用ViewGroup父類方法measureChild()或者measureChildWithMargins()方法
            //this.measureChild(child, widthMeasureSpec, heightMeasureSpec) ;
        }

    }

    @Override
    //對每個子View視圖進行佈局
    protected void onLayout(boolean changed, int l, int t, int r, int b) {
        // TODO Auto-generated method stub
        //通過init()方法，我們爲該ViewGroup對象添加了三個視圖 ， Button、 ImageView、TextView
        int childCount = getChildCount() ;

        int startLeft = 0 ;//設置每個子View的起始橫座標
        int startTop = 10 ; //每個子View距離父視圖的位置 ， 簡單設置爲10px吧 。 可以理解爲 android:margin=10px ;

        Log.i(TAG, "**** onLayout start ****") ;
        for(int i=0 ;i<childCount ; i++){
            View child = getChildAt(i) ;   //獲得每個對象的引用
            child.layout(startLeft, startTop, startLeft+child.getMeasuredWidth(), startTop+child.getMeasuredHeight()) ;
            startLeft =startLeft+child.getMeasuredWidth() + 10;  //校準startLeft值，View之間的間距設爲10px ;
            Log.i(TAG, "**** onLayout startLeft ****" +startLeft) ;
        }
    }
    //繪圖過程Android已經爲我們封裝好了 ,這兒只爲了觀察方法調用程
    protected void dispatchDraw(Canvas canvas){
        Log.i(TAG, "**** dispatchDraw start ****") ;

        super.dispatchDraw(canvas) ;
    }

    protected boolean drawChild(Canvas canvas , View child, long drawingTime){
        Log.i(TAG, "**** drawChild start ****") ;

        return super.drawChild(canvas, child, drawingTime) ;
    }
}

   

          2、MyView.java 自定義View類型，重寫onDraw()方法 ，

//自定義View對象
    public class MyView extends View{

        private Paint paint  = new Paint() ;

        public MyView(Context context) {
            super(context);
            // TODO Auto-generated constructor stub
        }
        public MyView(Context context , AttributeSet attrs){
            super(context,attrs);
        }

        protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec){
            //設置該View大小爲 80 80
            setMeasuredDimension(50 , 50) ;
        }



        //存在canvas對象，即存在默認的顯示區域
        @Override
        public void onDraw(Canvas canvas) {
            // TODO Auto-generated method stub
            super.onDraw(canvas);

            Log.i("MyViewGroup", "MyView is onDraw ") ;
            //加粗
            paint.setTypeface(Typeface.defaultFromStyle(Typeface.BOLD));
            paint.setColor(Color.RED);
            canvas.drawColor(Color.BLUE) ;
            canvas.drawRect(0, 0, 30, 30, paint);
            canvas.drawText("MyView", 10, 40, paint);
        }
    }

          主Activity只是顯示了該xml文件，在此也不羅嗦了。 大家可以查看該ViewGroup的Log仔細分析下View的繪製流程以及

相關方法的使用。第一次啓動後捕獲的Log如下，網上找了些資料，第一次View樹繪製過程會走幾遍，具體原因可能是某些

View 發生了改變，請求重新繪製，但這根本不影響我們的界面顯示效果 。

 

        總的來說： 整個繪製過程還是十分十分複雜地，每個具體方法的實現都是我輩難以立即的，感到悲劇啊。對Android提

 供的一些ViewGroup對象，比如LinearLayout、RelativeLayout佈局對象的實現也很有壓力。 本文重在介紹整個View樹的繪製

流程，希望大家在此基礎上，多接觸源代碼進行更深入地擴展。

 

 

詳解measure過程以及如何設置View寬高

今天，我着重講解下如下三個內容：

            1、 measure過程

            2、WRAP_CONTENT、MATCH_PARENT/FILL_PARENT屬性的原理說明

            3、xml佈局文件解析成View樹的流程分析。

     希望對大家能有幫助。- -  分析版本基於Android 2.3。

 1、WRAP_CONTENT、MATCH_PARENT/FILL_PARENT 

       初入Android殿堂的同學們，對這三個屬性一定又愛又恨。愛的是使用起來挺爽地---照葫蘆畫瓢即可，恨的

  卻是時常混淆這幾個屬性地意義，需要三思而後行。在帶着大家重溫下這幾個屬性的用法吧(希望我沒有囉嗦)。

      這三個屬性都用來適應視圖的水平或垂直大小，一個以視圖的內容或尺寸爲基礎的佈局比精確地指定視圖範圍

  更加方便。

        ①  fill_parent

                設置一個視圖的佈局爲fill_parent將強制性地使視圖擴展至父元素大小。

        ② match_parent

               Android 中match_parent和fill_parent意思一樣，但match_parent更貼切，於是從2.2開始兩個詞都可以

          用，但2.3版本後建議使用match_parent。

       ③ wrap_content

              自適應大小，強制性地使視圖擴展以便顯示其全部內容。以TextView和ImageView控件爲例，設置爲

         wrap_content將完整顯示其內部的文本和圖像。佈局元素將根據內容更改大小。

       

      可不要重複造輪子，以上摘自<<Android fill_parent、wrap_content和match_parent的區別>>。

      當然，我們可以設置View的確切寬高，而不是由以上屬性指定。

android:layout_weight="wrap_content"   //自適應大小
android:layout_weight="match_parent"   //與父視圖等高
android:layout_weight="fill_parent"    //與父視圖等高
android:layout_weight="100dip"         //精確設置高度值爲 100dip

      接下來，我們需要轉換下視角，看看ViewGroup.LayoutParams類及其派生類。

 2、ViewGroup.LayoutParams類及其派生類

    2.1、  ViewGroup.LayoutParams類說明

            Android API中如下介紹：

                LayoutParams are used by views to tell their parents how they want to be laid out.

     意思大概是說： View通過LayoutParams類告訴其父視圖它想要地大小(即，長度和寬度)。

    因此，每個View都包含一個ViewGroup.LayoutParams類或者其派生類，View類依賴於ViewGroup.LayoutParams。

       路徑：frameworks\base\core\java\android\view\View.java

public class View implements Drawable.Callback, KeyEvent.Callback, AccessibilityEventSource {
  ...
  /**
   * The layout parameters associated with this view and used by the parent
   * {@link android.view.ViewGroup} to determine how this view should be
   * laid out.
   * {@hide}
   */
  //該View擁有的 LayoutParams屬性，父試圖添加該View時，會爲其賦值，特別注意，其類型爲ViewGroup.LayoutParams。
  protected ViewGroup.LayoutParams mLayoutParams;
  ...
}

     2.2、  ViewGroup.LayoutParams源碼分析

      路徑位於：frameworks\base\core\java\android\view\ViewGroup.java

public abstract class ViewGroup extends View implements ViewParent, ViewManager {
    ...
     public static class LayoutParams {
        /**
         * Special value for the height or width requested by a View.
         * FILL_PARENT means that the view wants to be as big as its parent,
         * minus the parent's padding, if any. This value is deprecated
         * starting in API Level 8 and replaced by {@link #MATCH_PARENT}.
         */
        @Deprecated
        public static final int FILL_PARENT = -1;  // 注意值爲-1，Android2.2版本不建議使用
        /**
         * Special value for the height or width requested by a View.
         * MATCH_PARENT means that the view wants to be as big as its parent,
         * minus the parent's padding, if any. Introduced in API Level 8.
         */
        public static final int MATCH_PARENT = -1; // 注意值爲-1
        /**
         * Special value for the height or width requested by a View.
         * WRAP_CONTENT means that the view wants to be just large enough to fit
         * its own internal content, taking its own padding into account.
         */
        public static final int WRAP_CONTENT = -2; // 注意值爲-2
        /**
         * Information about how wide the view wants to be. Can be one of the
         * constants FILL_PARENT (replaced by MATCH_PARENT ,
         * in API Level 8) or WRAP_CONTENT. or an exact size.
         */
        public int width;  //該View的寬度，可以爲WRAP_CONTENT/MATCH_PARENT 或者一個具體值
        /**
         * Information about how tall the view wants to be. Can be one of the
         * constants FILL_PARENT (replaced by MATCH_PARENT ,
         * in API Level 8) or WRAP_CONTENT. or an exact size.
         */
        public int height; //該View的高度，可以爲WRAP_CONTENT/MATCH_PARENT 或者一個具體值
        /**
         * Used to animate layouts.
         */
        public LayoutAnimationController.AnimationParameters layoutAnimationParameters;
        /**
         * Creates a new set of layout parameters. The values are extracted from
         * the supplied attributes set and context. The XML attributes mapped
         * to this set of layout parameters are:、
         */
        public LayoutParams(Context c, AttributeSet attrs) {
            TypedArray a = c.obtainStyledAttributes(attrs, R.styleable.ViewGroup_Layout);
            setBaseAttributes(a,
                    R.styleable.ViewGroup_Layout_layout_width,
                    R.styleable.ViewGroup_Layout_layout_height);
            a.recycle();
        }

        /**
         * Creates a new set of layout parameters with the specified width
         * and height.
         */
        public LayoutParams(int width, int height) {
            this.width = width;
            this.height = height;
        }
        /**
         * Copy constructor. Clones the width and height values of the source.
         *
         * @param source The layout params to copy from.
         */
        public LayoutParams(LayoutParams source) {
            this.width = source.width;
            this.height = source.height;
        }
        /**
         * Used internally by MarginLayoutParams.
         * @hide
         */
        LayoutParams() {
        }
        /**
         * Extracts the layout parameters from the supplied attributes.
         *
         * @param a the style attributes to extract the parameters from
         * @param widthAttr the identifier of the width attribute
         * @param heightAttr the identifier of the height attribute
         */
        protected void setBaseAttributes(TypedArray a, int widthAttr, int heightAttr) {
            width = a.getLayoutDimension(widthAttr, "layout_width");
            height = a.getLayoutDimension(heightAttr, "layout_height");
        }
}

       我們發現FILL_PARENT/MATCH_PARENT值爲 -1 ，WRAP_CONETENT值爲-2，是不是有點詫異？ 將值

  設置爲負值的目的是爲了區別View的具體值(an exact size) 總是大於0的。

       ViewGroup子類可以實現自定義LayoutParams，自定義LayoutParams提供了更好地擴展性，例如LinearLayout

 就有LinearLayout. LayoutParams自定義類(見下文)。整個LayoutParams類家族還是挺複雜的。

      ViewGroup.LayoutParams及其常用派生類的類圖(部分類圖)如下：

                  

                             該類圖是在太龐大了，大家有興趣的去看看Android API吧。

           

      前面我們說過，每個View都包含一個ViewGroup.LayoutParams類或者其派生類，下面我們的疑問是Android框架

 中時如何爲View設置其LayoutParams屬性的。

     有兩種方法會設置View的LayoutParams屬性：

       1、 直接添加子View時，常見於如下幾種方法：ViewGroup.java

//Adds a child view.
void addView(View child, int index)
//Adds a child view with this ViewGroup's default layout parameters
//and the specified width and height.
void addView(View child, int width, int height)
//Adds a child view with the specified layout parameters.
void addView(View child, ViewGroup.LayoutParams params)

         三個重載方法的區別只是添加View時構造LayoutParams對象的方式不同而已，稍後我們探尋一下它們的源碼。

     2、 通過xml佈局文件指定某個View的屬性爲：android:layout_heigth=””以及android:layout_weight=”” 時。

    總的來說，這兩種方式都會設定View的LayoutParams屬性值----指定的或者Default值。

  方式1流程分析：

     直接添加子View時，比較容易理解，我們先來看看這種方式設置LayoutParams的過程：

         路徑：\frameworks\base\core\java\android\view\ViewGroup.java

public abstract class ViewGroup extends View implements ViewParent, ViewManager {
    ...
    /**
     * Adds a child view. If no layout parameters are already set on the child, the
     * default parameters for this ViewGroup are set on the child.
     *
     * @param child the child view to add
     *
     * @see #generateDefaultLayoutParams()
     */
    public void addView(View child) {
        addView(child, -1);
    }
    /**
     * Adds a child view. If no layout parameters are already set on the child, the
     * default parameters for this ViewGroup are set on the child.
     *
     * @param child the child view to add
     * @param index the position at which to add the child
     *
     * @see #generateDefaultLayoutParams()
     */
    public void addView(View child, int index) {
        LayoutParams params = child.getLayoutParams();
        if (params == null) {
            params = generateDefaultLayoutParams(); //返回默認地LayoutParams類，作爲該View的屬性值
            if (params == null) {//如果不能獲取到LayoutParams對象，則拋出異常。
                throw new IllegalArgumentException("generateDefaultLayoutParams() cannot return null");
            }
        }
        addView(child, index, params);
    }
    /**
     * Adds a child view with this ViewGroup's default layout parameters and the
     * specified width and height.
     *
     * @param child the child view to add
     */
    public void addView(View child, int width, int height) {
        //返回默認地LayoutParams類，作爲該View的屬性值
        final LayoutParams params = generateDefaultLayoutParams();
        params.width = width;   //重新設置width值
        params.height = height; //重新設置height值
        addView(child, -1, params); //這兒，我們有指定width、height的大小了。
    }
    /**
     * Adds a child view with the specified layout parameters.
     *
     * @param child the child view to add
     * @param params the layout parameters to set on the child
     */
    public void addView(View child, LayoutParams params) {
        addView(child, -1, params);
    }
    /**
     * Adds a child view with the specified layout parameters.
     *
     * @param child the child view to add
     * @param index the position at which to add the child
     * @param params the layout parameters to set on the child
     */
    public void addView(View child, int index, LayoutParams params) {
        ...
        // addViewInner() will call child.requestLayout() when setting the new LayoutParams
        // therefore, we call requestLayout() on ourselves before, so that the child's request
        // will be blocked at our level
        requestLayout();
        invalidate();
        addViewInner(child, index, params, false);
    }
    /**
     * Returns a set of default layout parameters. These parameters are requested
     * when the View passed to {@link #addView(View)} has no layout parameters
     * already set. If null is returned, an exception is thrown from addView.
     *
     * @return a set of default layout parameters or null
     */
    protected LayoutParams generateDefaultLayoutParams() {
        //width 爲 WRAP_CONTENT大小 ， height 爲WRAP_CONTENT
        //ViewGroup的子類可以重寫該方法，達到其特定要求。稍後會以LinearLayout類爲例說明。
        return new LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT);
    }
    private void addViewInner(View child, int index, LayoutParams params,
            boolean preventRequestLayout) {

        if (!checkLayoutParams(params)) { //params對象是否爲null
            params = generateLayoutParams(params); //如果params對象是爲null，重新構造個LayoutParams對象
        }
        //preventRequestLayout值爲false
        if (preventRequestLayout) {
            child.mLayoutParams = params; //爲View的mLayoutParams屬性賦值
        } else {
            child.setLayoutParams(params);//爲View的mLayoutParams屬性賦值，但會調用requestLayout()請求重新佈局
        }
        //if else 語句會設置View爲mLayoutParams屬性賦值
        ...
    }
    ...
}

      主要功能就是在添加子View時爲其構建了一個LayoutParams對象。但更重要的是，ViewGroup的子類可以重載

 上面的幾個方法，返回特定的LayoutParams對象，例如：對於LinearLayout而言，則是LinearLayout.LayoutParams

 對象。這麼做地目的是，能在其他需要它的地方，可以將其強制轉換成LinearLayout.LayoutParams對象。

      LinearLayout重寫函數地實現爲：

public class LinearLayout extends ViewGroup {
    ...
    @Override
    public LayoutParams generateLayoutParams(AttributeSet attrs) {
        return new LinearLayout.LayoutParams(getContext(), attrs);
    }
    @Override
    protected LayoutParams generateDefaultLayoutParams() {
        //該LinearLayout是水平方向還是垂直方向
        if (mOrientation == HORIZONTAL) {
            return new LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT);
        } else if (mOrientation == VERTICAL) {
            return new LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT);
        }
        return null;
    }
    @Override
    protected LayoutParams generateLayoutParams(ViewGroup.LayoutParams p) {
        return new LayoutParams(p);
    }
    /**
     * Per-child layout information associated with ViewLinearLayout.
     *
     * @attr ref android.R.styleable#LinearLayout_Layout_layout_weight
     * @attr ref android.R.styleable#LinearLayout_Layout_layout_gravity
     */ //自定義的LayoutParams類
    public static class LayoutParams extends ViewGroup.MarginLayoutParams {
        /**
         * Indicates how much of the extra space in the LinearLayout will be
         * allocated to the view associated with these LayoutParams. Specify
         * 0 if the view should not be stretched. Otherwise the extra pixels
         * will be pro-rated among all views whose weight is greater than 0.
         */
        @ViewDebug.ExportedProperty(category = "layout")
        public float weight;      //  見於屬性，android:layout_weight=""  ;
        /**
         * Gravity for the view associated with these LayoutParams.
         *
         * @see android.view.Gravity
         */
        public int gravity = -1;  // 見於屬性， android:layout_gravity=""  ;
        /**
         * {@inheritDoc}
         */
        public LayoutParams(Context c, AttributeSet attrs) {
            super(c, attrs);
            TypedArray a =c.obtainStyledAttributes(attrs, com.android.internal.R.styleable.LinearLayout_Layout);
            weight = a.getFloat(com.android.internal.R.styleable.LinearLayout_Layout_layout_weight, 0);
            gravity = a.getInt(com.android.internal.R.styleable.LinearLayout_Layout_layout_gravity, -1);

            a.recycle();
        }
        /**
         * {@inheritDoc}
         */
        public LayoutParams(int width, int height) {
            super(width, height);
            weight = 0;
        }
        /**
         * Creates a new set of layout parameters with the specified width, height
         * and weight.
         *
         * @param width the width, either {@link #MATCH_PARENT},
         *        {@link #WRAP_CONTENT} or a fixed size in pixels
         * @param height the height, either {@link #MATCH_PARENT},
         *        {@link #WRAP_CONTENT} or a fixed size in pixels
         * @param weight the weight
         */
        public LayoutParams(int width, int height, float weight) {
            super(width, height);
            this.weight = weight;
        }
        public LayoutParams(ViewGroup.LayoutParams p) {
            super(p);
        }
        public LayoutParams(MarginLayoutParams source) {
            super(source);
        }
    }
    ...
}

       LinearLayout.LayoutParams類繼承至ViewGroup.MarginLayoutParams類，添加了對android:layout_weight以及

   android:layout_gravity這兩個屬性的獲取和保存。而且它的重寫函數返回的都是LinearLayout.LayoutParams

   類型。這樣，我們可以再對子View進行其他操作時，可以將將其強制轉換成LinearLayout.LayoutParams對象進行

   使用。

         例如，LinearLayout進行measure過程，使用了LinearLayout.LayoutParam對象，有如下代碼：

public class LinearLayout extends ViewGroup {
    ...
    @Override  //onMeasure方法。
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        //判斷是垂直方向還是水平方向，這兒我們假設是VERTICAL垂直方向，
        if (mOrientation == VERTICAL) {
            measureVertical(widthMeasureSpec, heightMeasureSpec);
        } else {
            measureHorizontal(widthMeasureSpec, heightMeasureSpec);
        }
    }
     /**
     * Measures the children when the orientation of this LinearLayout is set
     * to {@link #VERTICAL}.
     *
     * @param widthMeasureSpec Horizontal space requirements as imposed by the parent.
     * @param heightMeasureSpec Vertical space requirements as imposed by the parent.
     *
     * @see #getOrientation()
     * @see #setOrientation(int)
     * @see #onMeasure(int, int)
     */
      void measureVertical(int widthMeasureSpec, int heightMeasureSpec) {
            mTotalLength = 0;
            ...
            // See how tall everyone is. Also remember max width.
            for (int i = 0; i < count; ++i) {
                final View child = getVirtualChildAt(i); //獲得索引處爲i的子VIew
                ...
                //注意，我們將類型爲 ViewGroup.LayoutParams的實例對象強制轉換爲了LinearLayout.LayoutParams，
                //即父對象轉換爲了子對象，能這樣做的原因就是LinearLayout的所有子View的LayoutParams類型都爲
                //LinearLayout.LayoutParams
                LinearLayout.LayoutParams lp = (LinearLayout.LayoutParams) child.getLayoutParams();
                ...
        }
    ...
}

        超類ViewGroup.LayoutParams強制轉換爲了子類LinearLayout.LayoutParams，因爲LinearLayout的每個

  ”直接“子View的LayoutParams屬性都是LinearLayout.LayoutParams類型，因此可以安全轉換。

       PS : Android 2.3源碼Launcher2中也實現了自定義的LayoutParams類，在IDLE界面的每個View至少包含如下

  信息：所在X方向的單元格索引和高度、所在Y方向的單元格索引和高度等。

            路徑: packages\apps\Launcher2\src\com\android\launcher2\CellLayout.java

public class CellLayout extends ViewGroup {
    ...
    public static class LayoutParams extends ViewGroup.MarginLayoutParams {
            /**
             * Horizontal location of the item in the grid.
             */
            public int cellX;   //X方向的單元格索引
            /**
             * Vertical location of the item in the grid.
             */
            public int cellY;   //Y方向的單元格索引
            /**
             * Number of cells spanned horizontally by the item.
             */
            public int cellHSpan;  //水平方向所佔高度
            /**
             * Number of cells spanned vertically by the item.
             */
            public int cellVSpan;  //垂直方向所佔高度
            ...
            public LayoutParams(Context c, AttributeSet attrs) {
                super(c, attrs);
                cellHSpan = 1;  //默認爲高度 1
                cellVSpan = 1;
            }

            public LayoutParams(ViewGroup.LayoutParams source) {
                super(source); //默認爲高度 1
                cellHSpan = 1;
                cellVSpan = 1;
            }

            public LayoutParams(int cellX, int cellY, int cellHSpan, int cellVSpan) {
                super(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT);
                this.cellX = cellX;
                this.cellY = cellY;
                this.cellHSpan = cellHSpan;
                this.cellVSpan = cellVSpan;
            }
            ...
        }
    ...
}

     對該自定義CellLayout.LayoutParams類的使用可以參考LinearLayout.LayoutParams類，我也不再贅述了。

 方法2流程分析：

        使用屬性android:layout_heigth=””以及android:layout_weight=”” 時，爲某個View設置LayoutParams值。

 

       其實這種賦值方法其實也如同前面那種，只不過它需要一個前期孵化過程---需要利用XML解析將佈局文件

  解析成一個完整的View樹，可別小看它了，所有Xxx.xml的佈局文件都需要解析成一個完整的View樹。下面，

  我們就來仔細走這個過程，重點關注如下兩個方面

         ①、xml佈局是如何解析成View樹的 ;

         ②、android:layout_heigth=””和android:layout_weight=””的解析。

        PS： 一直以來，我都想當然android:layout_heigth以及android:layout_weight這兩個屬性的解析過程是在

   View.java內部完成的，但當我真正去找尋時，卻一直沒有在View.java類或者ViewGroup.java類找到。直到一位

   網友的一次提問，才發現它們的藏身之地。

3、佈局文件解析流程分析

       解析佈局文件時，使用的類爲LayoutInflater。 關於該類的使用請參考如下博客：

                            <android中LayoutInflater的使用 >>

      主要有如下API方法：

        public View inflate (XmlPullParser parser, ViewGroup root, boolean attachToRoot)

          public View inflate (int resource, ViewGroup root)

          public View inflate (int resource, ViewGroup root, boolean attachToRoot)

     這三個類主要迷惑之處在於地三個參數attachToRoot，即是否將該View樹添加到root中去。具體可看這篇博客：

                                     <<關於inflate的第3個參數>>

    當然還有LayoutInflater的inflate()的其他重載方法，大家可以自行了解下。

     

    我利用下面的例子給大家走走這個流程 ：

public class MainActivity extends Activity {
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        //1、該方法最終也會調用到 LayoutInflater的inflate()方法中去解析。
        setContentView(R.layout.main);

        //2、使用常見的API方法去解析xml佈局文件，
        LayoutInflater layoutInflater = (LayoutInflater)getSystemService();
        View root = layoutInflater.inflate(R.layout.main, null);
    }
}

   Step 1、獲得LayoutInflater的引用。

         路徑：\frameworks\base\core\java\android\app\ContextImpl.java

/**
 * Common implementation of Context API, which provides the base
 * context object for Activity and other application components.
 */
class ContextImpl extends Context {
    if (WINDOW_SERVICE.equals(name)) {
        return WindowManagerImpl.getDefault();
    } else if (LAYOUT_INFLATER_SERVICE.equals(name)) {
        synchronized (mSync) {
            LayoutInflater inflater = mLayoutInflater;
            //是否已經賦值，如果是，直接返回引用
            if (inflater != null) {
                return inflater;
            }
            //返回一個LayoutInflater對象，getOuterContext()指的是我們的Activity、Service或者Application引用
            mLayoutInflater = inflater = PolicyManager.makeNewLayoutInflater(getOuterContext());
            return inflater;
        }
    } else if (ACTIVITY_SERVICE.equals(name)) {
        return getActivityManager();
    }...
}

         繼續去PolicyManager查詢對應函數，看看內部實現。    

           路徑：frameworks\base\core\java\com\android\internal\policy\PolicyManager.java

public final class PolicyManager {
    private static final String POLICY_IMPL_CLASS_NAME = "com.android.internal.policy.impl.Policy";
    private static final IPolicy sPolicy;   // 這可不是Binder機制額，這只是是一個接口，別想多啦
    static {
        // Pull in the actual implementation of the policy at run-time
        try {
            Class policyClass = Class.forName(POLICY_IMPL_CLASS_NAME);
            sPolicy = (IPolicy)policyClass.newInstance();
        }
        ...
    }
    ...
    public static LayoutInflater makeNewLayoutInflater(Context context) {
        return sPolicy.makeNewLayoutInflater(context); //繼續去實現類中去查找
    }
}

    IPolicy接口的實現對爲Policy類。路徑：/frameworks/base/policy/src/com/android/internal/policy/impl/Policy.java

//Simple implementation of the policy interface that spawns the right
//set of objects
public class Policy implements IPolicy{
    ...
    public PhoneLayoutInflater makeNewLayoutInflater(Context context) {
        //實際上返回的是PhoneLayoutInflater類。
        return new PhoneLayoutInflater(context);
    }
}
//PhoneLayoutInflater繼承至LayoutInflater類
public class PhoneLayoutInflater extends LayoutInflater {
    ...
    /**
     * Instead of instantiating directly, you should retrieve an instance
     * through {@link Context#getSystemService}
     *
     * @param context The Context in which in which to find resources and other
     *                application-specific things.
     *
     * @see Context#getSystemService
     */
    public PhoneLayoutInflater(Context context) {
        super(context);
    }
    ...
}

       LayoutInflater是個抽象類，實際上我們返回的是PhoneLayoutInflater類，但解析過程的操作基本上是在

  LayoutInflater中完成地。

   Step 2、調用inflate()方法去解析佈局文件。

public abstract class LayoutInflater {
    ...
    public View inflate(int resource, ViewGroup root) {
        //繼續看下個函數，注意root爲null
        return inflate(resource, root, root != null);
    }

    public View inflate(int resource, ViewGroup root, boolean attachToRoot) {
        //獲取一個XmlResourceParser來解析XML文件---佈局文件。
        //XmlResourceParser類以及xml是如何解析的，大家自己有興趣找找。
        XmlResourceParser parser = getContext().getResources().getLayout(resource);
        try {
            return inflate(parser, root, attachToRoot);
        } finally {
            parser.close();
        }
    }
}
/**
 * The XML parsing interface returned for an XML resource.  This is a standard
 * XmlPullParser interface, as well as an extended AttributeSet interface and
 * an additional close() method on this interface for the client to indicate
 * when it is done reading the resource.
 */
public interface XmlResourceParser extends XmlPullParser, AttributeSet {
    /**
     * Close this interface to the resource.  Calls on the interface are no
     * longer value after this call.
     */
    public void close();
}

      我們獲得了一個當前應用程序環境的XmlResourceParser對象，該對象的主要作用就是來解析xml佈局文件的。

  XmlResourceParser類是個接口類，更多關於XML解析的，大家可以參考下面博客：

                             <<android之XmlResourceParser類使用實例>>

                                   <<android解析xml文件的方式(其一)>>

                                   <<android解析xml文件的方式(其二)>>

                                   <<android解析xml文件的方式(其三)>>

   Step 3、真正地開始解析工作 。

public abstract class LayoutInflater {
    ...
    /**
     * Inflate a new view hierarchy from the specified XML node. Throws
     * {@link InflateException} if there is an error.
     */
    //我們傳遞過來的參數如下： root 爲null ， attachToRoot爲false 。
    public View inflate(XmlPullParser parser, ViewGroup root, boolean attachToRoot) {
        synchronized (mConstructorArgs) {
            final AttributeSet attrs = Xml.asAttributeSet(parser);
            Context lastContext = (Context)mConstructorArgs[0];
            mConstructorArgs[0] = mContext;  //該mConstructorArgs屬性最後會作爲參數傳遞給View的構造函數
            View result = root;  //根View

            try {
                // Look for the root node.
                int type;
                while ((type = parser.next()) != XmlPullParser.START_TAG &&
                        type != XmlPullParser.END_DOCUMENT) {
                    // Empty
                }
                ...
                final String name = parser.getName();  //節點名，即API中的控件或者自定義View完整限定名。
                if (TAG_MERGE.equals(name)) { // 處理<merge />標籤
                    if (root == null || !attachToRoot) {
                        throw new InflateException("<merge /> can be used only with a valid "
                                + "ViewGroup root and attachToRoot=true");
                    }
                    //將<merge />標籤的View樹添加至root中，該函數稍後講到。
                    rInflate(parser, root, attrs);
                } else {
                    // Temp is the root view that was found in the xml
                    //創建該xml佈局文件所對應的根View。
                    View temp = createViewFromTag(name, attrs);

                    ViewGroup.LayoutParams params = null;

                    if (root != null) {
                        // Create layout params that match root, if supplied
                        //根據AttributeSet屬性獲得一個LayoutParams實例，記住調用者爲root。
                        params = root.generateLayoutParams(attrs);
                        if (!attachToRoot) { //重新設置temp的LayoutParams
                            // Set the layout params for temp if we are not
                            // attaching. (If we are, we use addView, below)
                            temp.setLayoutParams(params);
                        }
                    }
                    // Inflate all children under temp
                    //添加所有其子節點，即添加所有字View
                    rInflate(parser, temp, attrs);

                    // We are supposed to attach all the views we found (int temp)
                    // to root. Do that now.
                    if (root != null && attachToRoot) {
                        root.addView(temp, params);
                    }
                    // Decide whether to return the root that was passed in or the
                    // top view found in xml.
                    if (root == null || !attachToRoot) {
                        result = temp;
                    }
                }
            }
            ...
            return result;
        }
    }

    /*
     * default visibility so the BridgeInflater can override it.
     */
    View createViewFromTag(String name, AttributeSet attrs) {
        //節點是否爲View，如果是將其重新賦值，形如 <View class="com.qin.xxxView"></View>
        if (name.equals("view")) {
            name = attrs.getAttributeValue(null, "class");
        }
        try {
            View view = (mFactory == null) ? null : mFactory.onCreateView(name,
                    mContext, attrs);  //沒有設置工廠方法

            if (view == null) {
                //通過這個判斷是Android API的View，還是自定義View
                if (-1 == name.indexOf('.')) {
                    view = onCreateView(name, attrs); //創建Android API的View實例
                } else {
                    view = createView(name, null, attrs);//創建一個自定義View實例
                }
            }
            return view;
        }
        ...
    }
    //獲得具體視圖的實例對象
    public final View createView(String name, String prefix, AttributeSet attrs) {
        Constructor constructor = sConstructorMap.get(name);
        Class clazz = null;
        //以下功能主要是獲取如下三個類對象：
        //1、類加載器  ClassLoader
        //2、Class對象
        //3、類的構造方法句柄 Constructor
        try {
            if (constructor == null) {
            // Class not found in the cache, see if it's real, and try to add it
            clazz = mContext.getClassLoader().loadClass(prefix != null ? (prefix + name) : name);
            ...
            constructor = clazz.getConstructor(mConstructorSignature);
            sConstructorMap.put(name, constructor);
        } else {
            // If we have a filter, apply it to cached constructor
            if (mFilter != null) {
                ...
            }
        }
            //傳遞參數獲得該View實例對象
            Object[] args = mConstructorArgs;
            args[1] = attrs;
            return (View) constructor.newInstance(args);
        }
        ...
    }

}

     這段代碼的作用是獲取xml佈局文件的root View，做了如下兩件事情

          1、獲取xml佈局的View實例，通過createViewFromTag()方法獲取，該方法會判斷節點名是API 控件

            還是自定義控件，繼而調用合適的方法去實例化View。

          2、判斷root以及attachToRoot參數，重新設置root View值以及temp變量的LayoutParams值。

        如果仔細看着段代碼，不知大家心裏有沒有疑惑：當root爲null時，我們的temp變量的LayoutParams值是爲

  null的，即它不會被賦值？有個View的LayoutParams值爲空，那麼，在系統中不會報異常嗎？見下面部分

  代碼：

//我們傳遞過來的參數如下： root 爲null ， attachToRoot爲false 。
public View inflate(XmlPullParser parser, ViewGroup root, boolean attachToRoot) {
    synchronized (mConstructorArgs) {
        ...
        try {

            ...
            if (TAG_MERGE.equals(name)) { // 處理<merge />標籤
                ...
            } else {
                // Temp is the root view that was found in the xml
                //創建該xml佈局文件所對應的根View。
                View temp = createViewFromTag(name, attrs);
                ViewGroup.LayoutParams params = null;

                //注意！！！ root爲null時，temp變量的LayoutParams屬性不會被賦值的。
                if (root != null) {
                    // Create layout params that match root, if supplied
                    //根據AttributeSet屬性獲得一個LayoutParams實例，記住調用者爲root。
                    params = root.generateLayoutParams(attrs);
                    if (!attachToRoot) { //重新設置temp的LayoutParams
                        // Set the layout params for temp if we are not
                        // attaching. (If we are, we use addView, below)
                        temp.setLayoutParams(params);
                    }
                }
                ...
            }
        }
        ...
    }
}

        關於這個問題的詳細答案，我會在後面講到。這兒我簡單說下，任何View樹的頂層View被添加至窗口時，

  一般調用WindowManager.addView()添加至窗口時，在這個方法中去做進一步處理。即使，LayoutParams

  值爲空，UI框架每次measure()時都忽略該View的LayoutParams值，而是直接傳遞MeasureSpec值至View樹。

       接下來，我們關注另外一個函數，rInflate()，該方法會遞歸調用每個View下的子節點，以當前View作爲根View

 形成一個View樹。

/**
 * Recursive method used to descend down the xml hierarchy and instantiate
 * views, instantiate their children, and then call onFinishInflate().
 */
//遞歸調用每個字節點
private void rInflate(XmlPullParser parser, View parent, final AttributeSet attrs)
        throws XmlPullParserException, IOException {

    final int depth = parser.getDepth();
    int type;

    while (((type = parser.next()) != XmlPullParser.END_TAG ||
            parser.getDepth() > depth) && type != XmlPullParser.END_DOCUMENT) {

        if (type != XmlPullParser.START_TAG) {
            continue;
        }
        final String name = parser.getName();

        if (TAG_REQUEST_FOCUS.equals(name)) { //處理<requestFocus />標籤
            parseRequestFocus(parser, parent);
        } else if (TAG_INCLUDE.equals(name)) { //處理<include />標籤
            if (parser.getDepth() == 0) {
                throw new InflateException("<include /> cannot be the root element");
            }
            parseInclude(parser, parent, attrs);//解析<include />節點
        } else if (TAG_MERGE.equals(name)) { //處理<merge />標籤
            throw new InflateException("<merge /> must be the root element");
        } else {
            //根據節點名構建一個View實例對象
            final View view = createViewFromTag(name, attrs);
            final ViewGroup viewGroup = (ViewGroup) parent;
            //調用generateLayoutParams()方法返回一個LayoutParams實例對象，
            final ViewGroup.LayoutParams params = viewGroup.generateLayoutParams(attrs);
            rInflate(parser, view, attrs); //繼續遞歸調用
            viewGroup.addView(view, params); //OK，將該View以特定LayoutParams值添加至父View中
        }
    }
    parent.onFinishInflate();  //完成了解析過程，通知....
}

          值得注意的是，每次addView前都調用了viewGroup.generateLayoutParams(attrs)去構建一個LayoutParams

  實例，然後在addView()方法中爲其賦值。參見如下代碼：ViewGroup.java

  

public abstract class ViewGroup extends View implements ViewParent, ViewManager {
    ...

    public LayoutParams generateLayoutParams(AttributeSet attrs) {
        return new LayoutParams(getContext(), attrs);
    }
    public static class LayoutParams {
        ... //會調用這個構造函數
        public LayoutParams(Context c, AttributeSet attrs) {
            TypedArray a = c.obtainStyledAttributes(attrs, R.styleable.ViewGroup_Layout);
            setBaseAttributes(a,
                    R.styleable.ViewGroup_Layout_layout_width,
                    R.styleable.ViewGroup_Layout_layout_height);
            a.recycle();
        }
        protected void setBaseAttributes(TypedArray a, int widthAttr, int heightAttr) {
            width = a.getLayoutDimension(widthAttr, "layout_width");
            height = a.getLayoutDimension(heightAttr, "layout_height");
        }

}

    好吧 ~~ 我們還是探尋根底，去TypeArray類的getLayoutDimension()看看。

        路徑：/frameworks/base/core/java/android/content/res/TypedArray.java

public class TypedArray {
    ...
    /**
     * Special version of {@link #getDimensionPixelSize} for retrieving
     * {@link android.view.ViewGroup}'s layout_width and layout_height
     * attributes.  This is only here for performance reasons; applications
     * should use {@link #getDimensionPixelSize}.
     *
     * @param index Index of the attribute to retrieve.
     * @param name Textual name of attribute for error reporting.
     *
     * @return Attribute dimension value multiplied by the appropriate
     * metric and truncated to integer pixels.
     */
    public int getLayoutDimension(int index, String name) {
        index *= AssetManager.STYLE_NUM_ENTRIES;
        final int[] data = mData;
        //獲得屬性對應的標識符 ， Identifies，目前還沒有仔細研究相關類。
        final int type = data[index+AssetManager.STYLE_TYPE];
        if (type >= TypedValue.TYPE_FIRST_INT
                && type <= TypedValue.TYPE_LAST_INT) {
            return data[index+AssetManager.STYLE_DATA];
        } else if (type == TypedValue.TYPE_DIMENSION) { //類型爲dimension類型
            return TypedValue.complexToDimensionPixelSize(
                data[index+AssetManager.STYLE_DATA], mResources.mMetrics);
        }
        //沒有提供layout_weight和layout_height會來到此處 ，這兒會報異常！
        //因此佈局文件中的View包括自定義View必須加上屬性layout_weight和layout_height。
        throw new RuntimeException(getPositionDescription()
                + ": You must supply a " + name + " attribute.");
    }
    ...
}

         從上面得知，  我們將View的AttributeSet屬性傳遞給generateLayoutParams()方法，讓其構建合適地

   LayoutParams對象，並且初始化屬性值weight和height。同時我們也得知 佈局文件中的View包括自定義View

   必須加上屬性layout_weight和layout_height，否則會報異常。

    Step 3 主要做了如下事情：
       首先，獲得了了佈局文件地root View，即佈局文件中最頂層的View。

       其次，通過遞歸調用，我們形成了整個View樹以及設置了每個View的LayoutParams對象。

    

主要知識點如下：
                 1、MeasureSpc類說明
                 2、measure過程詳解(揭祕其細節);
                 3、root View被添加至窗口時，UI框架是如何設置其LayoutParams值得。

       在講解measure過程前，我們非常有必要理解MeasureSpc類的使用，否則理解起來也只能算是囫圇吞棗。

 1、MeasureSpc類說明

   1.1  SDK 說明如下

              A MeasureSpec encapsulates the layout requirements passed from parent to child. Each MeasureSpec

         represents a requirement for either the width or the height. A MeasureSpec is comprised of a size and

         a mode. 

        即：
             MeasureSpc類封裝了父View傳遞給子View的佈局(layout)要求。每個MeasureSpc實例代表寬度或者高度

   (只能是其一)要求。 它有三種模式：

            ①、UNSPECIFIED(未指定)，父元素部隊自元素施加任何束縛，子元素可以得到任意想要的大小；

            ②、EXACTLY(完全)，父元素決定自元素的確切大小，子元素將被限定在給定的邊界裏而忽略它本身大小；

            ③、AT_MOST(至多)，子元素至多達到指定大小的值。

   常用的三個函數：

　 static int getMode(int measureSpec)  :  根據提供的測量值(格式)提取模式(上述三個模式之一)

     static int getSize(int measureSpec) : 根據提供的測量值(格式)提取大小值(這個大小也就是我們通常所說的大小)

     static int makeMeasureSpec(int size,int mode)  :  根據提供的大小值和模式創建一個測量值(格式)

             以上摘取自:  <<MeasureSpec介紹及使用詳解>>

   1.2   MeasureSpc類源碼分析   其爲View.java類的內部類，路徑：\frameworks\base\core\java\android\view\View.java

public class View implements ... {
     ...
     public static class MeasureSpec {
        private static final int MODE_SHIFT = 30; //移位位數爲30
        //int類型佔32位，向右移位30位，該屬性表示掩碼值，用來與size和mode進行"&"運算，獲取對應值。
        private static final int MODE_MASK  = 0x3 << MODE_SHIFT;

        //向右移位30位，其值爲00 + (30位0)  , 即 0x0000(16進製表示)
        public static final int UNSPECIFIED = 0 << MODE_SHIFT;
        //向右移位30位，其值爲01 + (30位0)  , 即0x1000(16進製表示)
        public static final int EXACTLY     = 1 << MODE_SHIFT;
        //向右移位30位，其值爲02 + (30位0)  , 即0x2000(16進製表示)
        public static final int AT_MOST     = 2 << MODE_SHIFT;

        //創建一個整形值，其高兩位代表mode類型，其餘30位代表長或寬的實際值。可以是WRAP_CONTENT、MATCH_PARENT或具體大小exactly size
        public static int makeMeasureSpec(int size, int mode) {
            return size + mode;
        }
        //獲取模式  ，與運算
        public static int getMode(int measureSpec) {
            return (measureSpec & MODE_MASK);
        }
        //獲取長或寬的實際值 ，與運算
        public static int getSize(int measureSpec) {
            return (measureSpec & ~MODE_MASK);
        }

    }
    ...
}

    MeasureSpec類的處理思路是：

      ①、右移運算，使int 類型的高兩位表示模式的實際值，其餘30位表示其餘30位代表長或寬的實際值----可以是

         WRAP_CONTENT、MATCH_PARENT或具體大小exactly size。

      ②、通過掩碼MODE_MASK進行與運算 “&”，取得模式(mode)以及長或寬(value)的實際值。

 2、measure過程詳解

 
   2.1  measure過程深入分析

       之前的一篇博文<< Android中View繪製流程以及invalidate()等相關方法分析>>，我們從”二B程序員”的角度簡單    解了measure過程的調用過程。過了這麼多，我們也該升級了，- - 。現在請開始從”普通程序員”角度去理解這個

 過程。我們重點查看measure過程中地相關方法。

     我們說過，當UI框架開始繪製時，皆是從ViewRoot.java類開始繪製的。

      ViewRoot類簡要說明: 任何顯示在設備中的窗口，例如：Activity、Dialog等，都包含一個ViewRoot實例，該

  類主要用來與遠端 WindowManagerService交互以及控制(開始/銷燬)繪製。

     Step 1、 開始UI繪製 ， 具體繪製方法則是：

路徑：\frameworks\base\core\java\android\view\ViewRoot.java
public final class ViewRoot extends Handler implements ViewParent,View.AttachInfo.Callbacks {
    ...
    //mView對象指添加至窗口的root View ，對Activity窗口而言，則是DecorView對象。
    View mView;

    //開始View繪製流程
    private void performTraversals(){
        ...
        //這兩個值我們在後面討論時，在回過頭來看看是怎麼賦值的。現在只需要記住其值MeasureSpec.makeMeasureSpec()構建的。
        int childWidthMeasureSpec; //其值由MeasureSpec類構建 , makeMeasureSpec
        int childHeightMeasureSpec;//其值由MeasureSpec類構建 , makeMeasureSpec


        // Ask host how big it wants to be
        host.measure(childWidthMeasureSpec, childHeightMeasureSpec);
        ...
    }
    ...
}

   

      這兒，我並沒有說出childWidthMeasureSpec和childHeightMeasureSpec類的來由(爲了避免額外地開銷，等到

 第三部分時我們在來攻克它，現在只需要記住其值MeasureSpec.makeMeasureSpec()構建的。

    Step 2 、調用measure()方法去做一些前期準備

       measure()方法原型定義在View.java類中，final修飾符修飾，其不能被重載：

    

public class View implements ... {
    ...
    /**
     * This is called to find out how big a view should be. The parent
     * supplies constraint information in the width and height parameters.
     *
     * @param widthMeasureSpec Horizontal space requirements as imposed by the
     *        parent
     * @param heightMeasureSpec Vertical space requirements as imposed by the
     *        parent
     * @see #onMeasure(int, int)
     */
    public final void measure(int widthMeasureSpec, int heightMeasureSpec) {
        //判斷是否爲強制佈局，即帶有“FORCE_LAYOUT”標記 以及 widthMeasureSpec或heightMeasureSpec發生了改變
        if ((mPrivateFlags & FORCE_LAYOUT) == FORCE_LAYOUT ||
                widthMeasureSpec != mOldWidthMeasureSpec ||
                heightMeasureSpec != mOldHeightMeasureSpec) {

            // first clears the measured dimension flag
            //清除MEASURED_DIMENSION_SET標記   ，該標記會在onMeasure()方法後被設置
            mPrivateFlags &= ~MEASURED_DIMENSION_SET;

            // measure ourselves, this should set the measured dimension flag back
            // 1、 測量該View本身的大小 ； 2 、 設置MEASURED_DIMENSION_SET標記，否則接寫來會報異常。
            onMeasure(widthMeasureSpec, heightMeasureSpec);

            // flag not set, setMeasuredDimension() was not invoked, we raise
            // an exception to warn the developer
            if ((mPrivateFlags & MEASURED_DIMENSION_SET) != MEASURED_DIMENSION_SET) {
                throw new IllegalStateException("onMeasure() did not set the"
                        + " measured dimension by calling" + " setMeasuredDimension()");
            }

            mPrivateFlags |= LAYOUT_REQUIRED;  //下一步是layout了，添加LAYOUT_REQUIRED標記
        }

        mOldWidthMeasureSpec = widthMeasureSpec;   //保存值
        mOldHeightMeasureSpec = heightMeasureSpec; //保存值
    }
    ...
}

      參數widthMeasureSpec和heightMeasureSpec 由父View構建，表示父View給子View的測量要求。其值地構建

 會在下面步驟中詳解。  

   measure()方法顯示判斷是否需要重新調用設置改View大小，即調用onMeasure()方法，然後操作兩個標識符：

            ①、重置MEASURED_DIMENSION_SET   ： onMeasure()方法中，需要添加該標識符，否則，會報異常；    

       ②、添加LAYOUT_REQUIRED： 表示需要進行layout操作。

    最後，保存當前的widthMeasureSpec和heightMeasureSpec值。

   Step 3 、調用onMeasure()方法去真正設置View的長寬值，其默認實現爲：

/**
   * Measure the view and its content to determine the measured width and the
   * measured height. This method is invoked by {@link #measure(int, int)} and
   * should be overriden by subclasses to provide accurate and efficient
   * measurement of their contents.
   *
   * @param widthMeasureSpec horizontal space requirements as imposed by the parent.
   *                         The requirements are encoded with
   * @param heightMeasureSpec vertical space requirements as imposed by the parent.
   *                         The requirements are encoded with
   */
  //設置該View本身地大小
  protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
      setMeasuredDimension(getDefaultSize(getSuggestedMinimumWidth(), widthMeasureSpec),
              getDefaultSize(getSuggestedMinimumHeight(), heightMeasureSpec));
  }

  /**
   * Utility to return a default size. Uses the supplied size if the
   * MeasureSpec imposed no contraints. Will get larger if allowed
   * by the MeasureSpec.
   *
   * @param size Default size for this view
   * @param measureSpec Constraints imposed by the parent
   * @return The size this view should be.
   */
  //@param size參數一般表示設置了android:minHeight屬性或者該View背景圖片的大小值
  public static int getDefaultSize(int size, int measureSpec) {
      int result = size;
      int specMode = MeasureSpec.getMode(measureSpec);
      int specSize =  MeasureSpec.getSize(measureSpec);

      //根據不同的mode值，取得寬和高的實際值。
      switch (specMode) {
      case MeasureSpec.UNSPECIFIED:  //表示該View的大小父視圖未定，設置爲默認值
          result = size;
          break;
      case MeasureSpec.AT_MOST:      //表示該View的大小由父視圖指定了
      case MeasureSpec.EXACTLY:
          result = specSize;
          break;
      }
      return result;
  }
  //獲得設置了android:minHeight屬性或者該View背景圖片的大小值， 最爲該View的參考值
  protected int getSuggestedMinimumWidth() {
      int suggestedMinWidth = mMinWidth;  //  android:minHeight

      if (mBGDrawable != null) { // 背景圖片對應地Width。
          final int bgMinWidth = mBGDrawable.getMinimumWidth();
          if (suggestedMinWidth < bgMinWidth) {
              suggestedMinWidth = bgMinWidth;
          }
      }

      return suggestedMinWidth;
  }
  //設置View在measure過程中寬和高
  protected final void setMeasuredDimension(int measuredWidth, int measuredHeight) {
      mMeasuredWidth = measuredWidth;
      mMeasuredHeight = measuredHeight;

      mPrivateFlags |= MEASURED_DIMENSION_SET;  //設置了MEASURED_DIMENSION_SET標記
  }

       主要功能就是根據該View屬性(android:minWidth和背景圖片大小)和父View對該子View的"測量要求"，設置該      View的 mMeasuredWidth 和 mMeasuredHeight 值。

       這兒只是一般的View類型地實現方法。一般來說，父View，也就是ViewGroup類型，都需要在重寫onMeasure()   方法，遍歷所有子View，設置每個子View的大小。基本思想如下：遍歷所有子View，設置每個子View的大小。僞

  代碼錶示爲：

//某個ViewGroup類型的視圖
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
  //必須調用super.ononMeasure()或者直接調用setMeasuredDimension()方法設置該View大小，否則會報異常。
  super.onMeasure(widthMeasureSpec , heightMeasureSpec)
     //setMeasuredDimension(getDefaultSize(getSuggestedMinimumWidth(), widthMeasureSpec),
     //        getDefaultSize(getSuggestedMinimumHeight(), heightMeasureSpec));

  //遍歷每個子View
  for(int i = 0 ; i < getChildCount() ; i++){
    View child = getChildAt(i);
    //調用子View的onMeasure，設置他們的大小。childWidthMeasureSpec ， childHeightMeasureSpec ?
    child.onMeasure(childWidthMeasureSpec, childHeightMeasureSpec);
  }
}

      Step 2、Step 3 代碼也比較好理解，但問題是我們示例代碼中widthMeasureSpec、heightMeasureSpec是如何

 確定的呢？父View是如何設定其值的？

  

      要想回答這個問題，我們看是去源代碼裏找找答案吧。在ViewGroup.java類中，爲我們提供了三個方法，去設置

每個子View的大小，基本思想也如同我們之前描述的思想：遍歷所有子View，設置每個子View的大小。

     主要有如下方法：

/**
 * Ask all of the children of this view to measure themselves, taking into
 * account both the MeasureSpec requirements for this view and its padding.
 * We skip children that are in the GONE state The heavy lifting is done in
 * getChildMeasureSpec.
 */
//widthMeasureSpec 和  heightMeasureSpec 表示該父View的佈局要求
//遍歷每個子View，然後調用measureChild()方法去實現每個子View大小
protected void measureChildren(int widthMeasureSpec, int heightMeasureSpec) {
    final int size = mChildrenCount;
    final View[] children = mChildren;
    for (int i = 0; i < size; ++i) {
        final View child = children[i];
        if ((child.mViewFlags & VISIBILITY_MASK) != GONE) { // 不處於 “GONE” 狀態
            measureChild(child, widthMeasureSpec, heightMeasureSpec);
        }
    }
}

/**
 * Ask one of the children of this view to measure itself, taking into
 * account both the MeasureSpec requirements for this view and its padding.
 * The heavy lifting is done in getChildMeasureSpec.
 *
 * @param child The child to measure
 * @param parentWidthMeasureSpec The width requirements for this view
 * @param parentHeightMeasureSpec The height requirements for this view
 */
//測量每個子View高寬時，清楚了該View本身的邊距大小，即android:padding屬性 或android:paddingLeft等屬性標記
protected void measureChild(View child, int parentWidthMeasureSpec,
        int parentHeightMeasureSpec) {
    final LayoutParams lp = child.getLayoutParams(); // LayoutParams屬性
    //設置子View的childWidthMeasureSpec屬性，去除了該父View的邊距值  mPaddingLeft + mPaddingRight
    final int childWidthMeasureSpec = getChildMeasureSpec(parentWidthMeasureSpec,
            mPaddingLeft + mPaddingRight, lp.width);
    //設置子View的childHeightMeasureSpec屬性，去除了該父View的邊距值  mPaddingTop + mPaddingBottom
    final int childHeightMeasureSpec = getChildMeasureSpec(parentHeightMeasureSpec,
            mPaddingTop + mPaddingBottom, lp.height);

    child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
}

  

     measureChildren()方法：遍歷所有子View，調用measureChild()方法去設置該子View的屬性值。

     measureChild()  方法   ： 獲取特定子View的widthMeasureSpec、heightMeasureSpec，調用measure()方法

 設置子View的實際寬高值。

    getChildMeasureSpec()就是獲取子View的widthMeasureSpec、heightMeasureSpec值。

  

/**
 * Does the hard part of measureChildren: figuring out the MeasureSpec to
 * pass to a particular child. This method figures out the right MeasureSpec
 * for one dimension (height or width) of one child view.
 *
 * The goal is to combine information from our MeasureSpec with the
 * LayoutParams of the child to get the best possible results.
 */
// spec參數                                    表示該父View本身所佔的widthMeasureSpec 或  heightMeasureSpec值
// padding參數                          表示該父View的邊距大小，見於android:padding屬性 或android:paddingLeft等屬性標記
// childDimension參數  表示該子View內部LayoutParams屬性的值，可以是wrap_content、match_parent、一個精確指(an exactly size),
//           例如：由android:width指定等。
public static int getChildMeasureSpec(int spec, int padding, int childDimension) {
    int specMode = MeasureSpec.getMode(spec);  //獲得父View的mode
    int specSize = MeasureSpec.getSize(spec);  //獲得父View的實際值

    int size = Math.max(0, specSize - padding); //父View爲子View設定的大小，減去邊距值，

    int resultSize = 0;    //子View對應地 size 實際值 ，由下面的邏輯條件賦值
    int resultMode = 0;    //子View對應地 mode 值 ， 由下面的邏輯條件賦值

    switch (specMode) {
    // Parent has imposed an exact size on us
    //1、父View是EXACTLY的 ！
    case MeasureSpec.EXACTLY:
        //1.1、子View的width或height是個精確值 (an exactly size)
        if (childDimension >= 0) {
            resultSize = childDimension;         //size爲精確值
            resultMode = MeasureSpec.EXACTLY;    //mode爲 EXACTLY 。
        }
        //1.2、子View的width或height爲 MATCH_PARENT/FILL_PARENT
        else if (childDimension == LayoutParams.MATCH_PARENT) {
            // Child wants to be our size. So be it.
            resultSize = size;                   //size爲父視圖大小
            resultMode = MeasureSpec.EXACTLY;    //mode爲 EXACTLY 。
        }
        //1.3、子View的width或height爲 WRAP_CONTENT
        else if (childDimension == LayoutParams.WRAP_CONTENT) {
            // Child wants to determine its own size. It can't be
            // bigger than us.
            resultSize = size;                   //size爲父視圖大小
            resultMode = MeasureSpec.AT_MOST;    //mode爲AT_MOST 。
        }
        break;

    // Parent has imposed a maximum size on us
    //2、父View是AT_MOST的 ！
    case MeasureSpec.AT_MOST:
        //2.1、子View的width或height是個精確值 (an exactly size)
        if (childDimension >= 0) {
            // Child wants a specific size... so be it
            resultSize = childDimension;        //size爲精確值
            resultMode = MeasureSpec.EXACTLY;   //mode爲 EXACTLY 。
        }
        //2.2、子View的width或height爲 MATCH_PARENT/FILL_PARENT
        else if (childDimension == LayoutParams.MATCH_PARENT) {
            // Child wants to be our size, but our size is not fixed.
            // Constrain child to not be bigger than us.
            resultSize = size;                  //size爲父視圖大小
            resultMode = MeasureSpec.AT_MOST;   //mode爲AT_MOST
        }
        //2.3、子View的width或height爲 WRAP_CONTENT
        else if (childDimension == LayoutParams.WRAP_CONTENT) {
            // Child wants to determine its own size. It can't be
            // bigger than us.
            resultSize = size;                  //size爲父視圖大小
            resultMode = MeasureSpec.AT_MOST;   //mode爲AT_MOST
        }
        break;

    // Parent asked to see how big we want to be
    //3、父View是UNSPECIFIED的 ！
    case MeasureSpec.UNSPECIFIED:
        //3.1、子View的width或height是個精確值 (an exactly size)
        if (childDimension >= 0) {
            // Child wants a specific size... let him have it
            resultSize = childDimension;        //size爲精確值
            resultMode = MeasureSpec.EXACTLY;   //mode爲 EXACTLY
        }
        //3.2、子View的width或height爲 MATCH_PARENT/FILL_PARENT
        else if (childDimension == LayoutParams.MATCH_PARENT) {
            // Child wants to be our size... find out how big it should
            // be
            resultSize = 0;                        //size爲0！ ,其值未定
            resultMode = MeasureSpec.UNSPECIFIED;  //mode爲 UNSPECIFIED
        }
        //3.3、子View的width或height爲 WRAP_CONTENT
        else if (childDimension == LayoutParams.WRAP_CONTENT) {
            // Child wants to determine its own size.... find out how
            // big it should be
            resultSize = 0;                        //size爲0! ，其值未定
            resultMode = MeasureSpec.UNSPECIFIED;  //mode爲 UNSPECIFIED
        }
        break;
    }
    //根據上面邏輯條件獲取的mode和size構建MeasureSpec對象。
    return MeasureSpec.makeMeasureSpec(resultSize, resultMode);
}

       爲了便於分析，我將上面的邏輯判斷語句使用列表項進行了說明.

  getChildMeasureSpec()方法的主要功能如下：

        根據父View的measureSpec值(widthMeasureSpec,heightMeasureSpec)值以及子View的子View內部

  LayoutParams屬性值，共同決定子View的measureSpec值的大小。主要判斷條件主要爲MeasureSpec的mode

 類型以及LayoutParams的寬高實際值(lp.width,lp.height)，見於以上所貼代碼中的列表項： 1、 1.1 ; 1.2 ; 1.3 ; 

  2、2.1等。

        例如，分析列表3：假設當父View爲MeasureSpec.UNSPECIFIED類型，即未定義時，只有當子View的width

 或height指定時，其mode才爲MeasureSpec.EXACTLY，否者該View size爲 0 ，mode爲MeasureSpec.UNSPECIFIED時

 ，即處於未指定狀態。

      由此可以得出， 每個View大小的設定都事由其父View以及該View共同決定的。但這只是一個期望的大小，每個

 View在測量時最終大小的設定是由setMeasuredDimension()最終決定的。因此，最終確定一個View的“測量長寬“是

 由以下幾個方面影響：

        1、父View的MeasureSpec屬性；

        2、子View的LayoutParams屬性 ；

        3、setMeasuredDimension()或者其它類似設定 mMeasuredWidth 和 mMeasuredHeight 值的方法。

                setMeasuredDimension()原型：

//設置View在measure過程中寬和高
protected final void setMeasuredDimension(int measuredWidth, int measuredHeight) {
    mMeasuredWidth = measuredWidth;
    mMeasuredHeight = measuredHeight;

    mPrivateFlags |= MEASURED_DIMENSION_SET;  //設置了MEASURED_DIMENSION_SET標記
}

  將上面列表項轉換爲表格爲：

                              

   這張表格更能幫助我們分析View的MeasureSpec的確定條件關係。

   爲了幫助大家理解，下面我們分析某個窗口使用地xml佈局文件，我們弄清楚該xml佈局文件中每個View的

MeasureSpec值的組成。

    

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/llayout"
       android:orientation="vertical"
    android:layout_width="match_parent"
       android:layout_height="match_parent">


    <TextView android:id="@+id/tv"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="@string/hello" />

</LinearLayout>

     該佈局文件共有兩個View：  ①、id爲llayout的LinearLayout佈局控件 ;

                                                   ②、id爲tv的TextView控件。

      假設LinearLayout的父View對應地widthSpec和heightSpec值皆爲MeasureSpec.EXACTLY類型(Activity窗口

  的父View爲DecorView，具體原因見第三部分說明)。

       對LinearLayout而言比較簡單，由於android:layout_width="match_parent"，因此其width對應地widthSpec 

  mode值爲MeasureSpec.EXACTLY ， size由父視圖大小指定 ;  由於android:layout_height = "match_parent"，

  因此其height對應地heightSpec mode值爲MeasureSpec.EXACTLY，size由父視圖大小指定 ;

       對TextView而言 ，其父View爲LinearLayout的widthSpec和heightSpec值皆爲MeasureSpec.EXACTLY類型，

 由於android:layout_width="match_parent" ， 因此其width對應地widthSpec mode值爲MeasureSpec.EXACTLY，

 size由父視圖大小指定 ;  由於android:layout_width="wrap_content" ， 因此其height對應地widthSpec mode值爲

 MeasureSpec.AT_MOST，size由父視圖大小指定 。

    我們繼續窺測下LinearLayout類是如何進行measure過程的：

 public class LinearLayout extends ViewGroup {
...
@Override  //onMeasure方法。
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
    //判斷是垂直方向還是水平方向，這兒我們假設是VERTICAL垂直方向，
    if (mOrientation == VERTICAL) {
        measureVertical(widthMeasureSpec, heightMeasureSpec);
    } else {
        measureHorizontal(widthMeasureSpec, heightMeasureSpec);
    }
}
//垂直方向佈局
   void measureVertical(int widthMeasureSpec, int heightMeasureSpec) {
       mTotalLength = 0;         //該LinearLayout測量子View時的總高度。
    float totalWeight = 0;    //所有子View的權重和 , android:layout_weight
    int maxWidth = 0;         //保存子View中最大width值
       ...
       final int count = getVirtualChildCount();  //子View的個數

       final int widthMode = MeasureSpec.getMode(widthMeasureSpec);
       final int heightMode = MeasureSpec.getMode(heightMeasureSpec);
          ...
       // See how tall everyone is. Also remember max width.
       for (int i = 0; i < count; ++i) {
           final View child = getVirtualChildAt(i);
              ...
           LinearLayout.LayoutParams lp = (LinearLayout.LayoutParams) child.getLayoutParams();

           totalWeight += lp.weight;
           //滿足該條件地View會在該LinearLayout有剩餘高度時，才真正調用measure()
           if (heightMode == MeasureSpec.EXACTLY && lp.height == 0 && lp.weight > 0) {
               ...
           } else {
               int oldHeight = Integer.MIN_VALUE;
               //如果View的hight值爲0，並且設置了android:layout_weight屬性，重新糾正其height值爲WRAP_CONTENT
               if (lp.height == 0 && lp.weight > 0) {
                   oldHeight = 0;
                   lp.height = LayoutParams.WRAP_CONTENT;
               }
               // Determine how big this child would like to be. If this or
               // previous children have given a weight, then we allow it to
               // use all available space (and we will shrink things later
               // if needed).
               //對每個子View調用measure()方法
               measureChildBeforeLayout(
                      child, i, widthMeasureSpec, 0, heightMeasureSpec,
                      totalWeight == 0 ? mTotalLength : 0);

               //這三行代碼做了如下兩件事情：
               //1、獲得該View的measuredHeight值，每個View都會根據他們地屬性正確設置值  > 0 ;
               //2、更新mTotalLength值：取當前高度mTotalLength值與mTotalLength + childHeight 的最大值
               // 於是對於android:layout_height="wrap_height"屬性地LinearLayout控件也就知道了它的確切高度值了。
               final int childHeight = child.getMeasuredHeight();
               final int totalLength = mTotalLength;
               mTotalLength = Math.max(totalLength, totalLength + childHeight + lp.topMargin +
                      lp.bottomMargin + getNextLocationOffset(child));
               ...
           }
           final int margin = lp.leftMargin + lp.rightMargin;
           final int measuredWidth = child.getMeasuredWidth() + margin;
           maxWidth = Math.max(maxWidth, measuredWidth);
           ...
       }
          //後續還有很多處理，包括繼續measure()某些符合條件地子View
       ...
   }
   void measureChildBeforeLayout(View child, int childIndex,
           int widthMeasureSpec, int totalWidth, int heightMeasureSpec,
           int totalHeight) {
    //調用measureChildWithMargins()方法去設置子View大小
       measureChildWithMargins(child, widthMeasureSpec, totalWidth,
               heightMeasureSpec, totalHeight);
   }
...

          

        繼續看看measureChildWithMargins()方法，該方法定義在ViewGroup.java內，基本流程同於measureChild()方法，但添加了對子View Margin的處理，即：android:margin屬性或者android:marginLeft等屬性的處理。

      [e-mail] 

/**
 * Ask one of the children of this view to measure itself, taking into
 * account both the MeasureSpec requirements for this view and its padding
 * and margins. The child must have MarginLayoutParams The heavy lifting is
 * done in getChildMeasureSpec.
 */
//基本流程同於measureChild()方法，但添加了對子View Margin的處理，即：android:margin屬性或者android:marginLeft等屬性的處理
//widthUsed參數  表示該父View已經使用的寬度
//heightUsed參數  表示該父View已經使用的高度
protected void measureChildWithMargins(View child,
        int parentWidthMeasureSpec, int widthUsed,
        int parentHeightMeasureSpec, int heightUsed) {
    final MarginLayoutParams lp = (MarginLayoutParams) child.getLayoutParams();

    //獲得子View的childWidthMeasureSpec和childHeightMeasureSpec值
    final int childWidthMeasureSpec = getChildMeasureSpec(parentWidthMeasureSpec,
            mPaddingLeft + mPaddingRight + lp.leftMargin + lp.rightMargin
                    + widthUsed, lp.width);
    final int childHeightMeasureSpec = getChildMeasureSpec(parentHeightMeasureSpec,
            mPaddingTop + mPaddingBottom + lp.topMargin + lp.bottomMargin
                    + heightUsed, lp.height);

    child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
}

    measure()過程時，LinearLayout類做了如下事情 ：

            1、遍歷每個子View，對其調用measure()方法；

            2、子View measure()完成後，需要取得該子View地寬高實際值，繼而做處理(例如：LinearLayout屬性爲

       android:widht="wrap_content"時，LinearLayout的實際width值則是每個子View的width值的累加值)。

     

  2.2 WRAP_CONTENT、MATCH_PARENT以及measure動機揭祕

        子View地寬高實際值 ，即child.getMeasuredWidth()值得返回最終會是一個確定值？  難道WRAP_CONTENT(

其值爲-2) 、MATCH_PARENT(值爲-1)或者說一個具體值(an exactly size > 0)。前面我們說過,View最終“測量”值的

確定是有三個部分組成地：

         ①、父View的MeasureSpec屬性；

         ②、子View的LayoutParams屬性 ；

         ③、setMeasuredDimension()或者其它類似設定 mMeasuredWidth 和 mMeasuredHeight 值的方法。

   因此，一個View必須以某種合適地方法確定它地最終大小。例如，如下自定義View：

//自定義View
public Class MyView extends View {

     //針對不同地mode值，設置本View地大小
     protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec){
         //獲得父View傳遞給我們地測量需求
         int widthMode = MeasureSpec.getMode(widthMeasureSpec);
         int heightMode = MeasureSpec.getMode(heightMeasureSpec);

         int width = 0 ;
         int height = 0 ;
         //對UNSPECIFIED 則拋出異常
         if(widthMode == MeasureSpec.UNSPECIFIED || heightMode == MeasureSpec.UNSPECIFIED)
             throw new RuntimeException("widthMode or heightMode cannot be UNSPECIFIED");

         //精確指定
         if(widthMode == MeasureSpec.EXACTLY){
             width = 100 ;
         }
         //模糊指定
         else if(widthMode == MeasureSpec.AT_MOST )
             width = 50 ;

          //精確指定
         if(heightMode == MeasureSpec.EXACTLY){
             height = 100 ;
         }
         //模糊指定
         else if(heightMode == MeasureSpec.AT_MOST )
             height = 50 ;

         setMeasuredDimension(width , height) ;
     }
}

         該自定義View重寫了onMeasure()方法，根據傳遞過來的widthMeasureSpec和heightMeasureSpec簡單設置了

 該View的mMeasuredWidth 和 mMeasuredHeight值。

      對於TextView而言，如果它地mode不是Exactly類型 ， 它會根據一些屬性，例如：android:textStyle

  、android:textSizeandroid:typeface等去確定TextView類地需要佔用地長和寬。

   

     因此，如果你地自定義View必須手動對不同mode做出處理。否則，則是mode對你而言是無效的。

   

      Android框架中提供地一系列View/ViewGroup都需要去進行這個measure()過程地 ，因爲在layout()過程中，父

  View需要調用getMeasuredWidth()或getMeasuredHeight()去爲每個子View設置他們地佈局座標，只有確定佈局

  座標後，才能真正地將該View 繪製(draw)出來，否則該View的layout大小爲0，得不到期望效果。我們繼續看看

  LinearLayout的layout佈局過程：

public class LinearLayout extends ViewGroup {
    ...
    @Override  //layout 過程
    protected void onLayout(boolean changed, int l, int t, int r, int b) {
        //假定是垂直方向佈局
        if (mOrientation == VERTICAL) {
            layoutVertical();
        } else {
            layoutHorizontal();
        }
    }
    //對每個子View調用layout過程
    void layoutVertical() {
        ...
        final int count = getVirtualChildCount();
        ...
        for (int i = 0; i < count; i++) {
            final View child = getVirtualChildAt(i);
            if (child == null) {  //一般爲非null
                childTop += measureNullChild(i);
            } else if (child.getVisibility() != GONE) {
                //獲得子View測量時的實際寬高值，
                final int childWidth = child.getMeasuredWidth();
                final int childHeight = child.getMeasuredHeight();

                ...
                //  封裝了child.layout()方法，見如下
                setChildFrame(child, childLeft, childTop + getLocationOffset(child),
                        childWidth, childHeight);
                childTop += childHeight + lp.bottomMargin + getNextLocationOffset(child);

                i += getChildrenSkipCount(child, i);
            }
        }
    }
    //width = getMeasuredWidth() ; height = childHeight(); View的大小就是測量大小
    private void setChildFrame(View child, int left, int top, int width, int height) {

        child.layout(left, top, left + width, top + height);
    }
    ...
}

      對一個View進行measure操作地主要目的就是爲了確定該View地佈局大小，見上面所示代碼。但measure操作

 通常是耗時的，因此對自定義ViewGroup而言，我們可以自由控制measure、layout過程，如果我們知道如何layout

 一個View，我們可以跳過該ViewGroup地measure操作(onMeasure()方法中measure所有子View地)，直接去layout

      在前面一篇博客<<Android中滑屏初探 ---- scrollTo 以及 scrollBy方法使用說明>>中，我們自定義了一個     ViewGroup,  並且重寫了onMeasure()和onLayout()方法去分別操作每個View。就該ViewGroup而言，我們只需要

  重寫onLayout()操作即可，因爲我們知道如何layout每個子View。如下代碼所示：

//自定義ViewGroup ， 包含了三個LinearLayout控件，存放在不同的佈局位置
public class MultiViewGroup extends ViewGroup {
    private void init() {
        // 初始化3個 LinearLayout控件
        LinearLayout oneLL = new LinearLayout(mContext);
        oneLL.setBackgroundColor(Color.RED);
        addView(oneLL);
        ...
    }
    @Override
    // 我們知曉每個子View的layout佈局大小，因此我們不需要爲每個子View進行measure()操作了。
//  protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
//      setMeasuredDimension(width, height);
//      // 設置該ViewGroup的大小
//      int width = MeasureSpec.getSize(widthMeasureSpec);
//      int height = MeasureSpec.getSize(heightMeasureSpec);
//      int childCount = getChildCount();
//      for (int i = 0; i < childCount; i++) {
//          View child = getChildAt(i);
//          // 設置每個子視圖的大小 ， 即全屏
//          child.measure(MultiScreenActivity.screenWidth, MultiScreenActivity.scrrenHeight);
//      }
    }

    // layout過程
    @Override
    protected void onLayout(boolean changed, int l, int t, int r, int b) {
        // TODO Auto-generated method stub
        Log.i(TAG, "--- start onLayout --");
        int startLeft = 0; // 每個子視圖的起始佈局座標
        int startTop = 10; // 間距設置爲10px 相當於 android：marginTop= "10px"
        int childCount = getChildCount();
        Log.i(TAG, "--- onLayout childCount is -->" + childCount);
        for (int i = 0; i < childCount; i++) {
            View child = getChildAt(i);
            child.layout(startLeft, startTop,
                    startLeft + MultiScreenActivity.screenWidth,
                    startTop + MultiScreenActivity.scrrenHeight);
            startLeft = startLeft + MultiScreenActivity.screenWidth ; //校準每個子View的起始佈局位置
            //三個子視圖的在屏幕中的分佈如下 [0 , 320] / [320,640] / [640,960]
        }
    }
}

     更多關於自定義ViewGroup無須重寫measure動作的，可以參考 Android API ：

               <<Optimizing the View >>

     中文翻譯見於：<< Android中View繪製優化之三---- 優化View>>

 3、root View被添加至窗口時，UI框架是如何設置其LayoutParams值

         老子道德經有言：“道生一，一生二，二生三，三生萬物。”  UI繪製也就是個遞歸過程。理解其基本架構後，

 也就“掌握了一箇中心點”了。在第一節中，我們沒有說明開始UI繪製時 ，沒有說明mView.measure()參數地由來，

 參數也就是我們本節需要弄懂的“道” --- root View的widthMeasureSpec和heightMeasureSpec 是如何確定的。

   對於如下佈局文件： main.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    >
<TextView
    android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:text="@string/hello"
    />
</LinearLayout>

  

    當使用LayoutInflater類解析成View時 ，LinearLayout對象的LayoutParams參數爲null 。具體原因請參考上篇博文

    任何一個View被添加至窗口時，都需要利用WindowManager類去操作。例如，如下代碼：

 

//顯示一個懸浮窗吧 ， just so so
public void showView()
{
    //解析佈局文件
    LayoutInflater layoutInflater = (LayoutInflater)getSystemService(Context.LAYOUT_INFLATER_SERVICE);
    //rootView對應地LayoutParams屬性值爲null，將會在UI繪製時設定其值
    View rootView = layoutInflater.inflate(R.layout.main, null);

    WindowManager windowManager = (WindowManager)getSystemService(Context.WINDOW_SERVICE);
    //設置WindowManager.LayoutParams參數值，作爲該窗口的各種屬性
    WindowManager.LayoutParams winparams = WindowManager.LayoutParams();
     // 以屏幕左上角爲原點，設置x、y初始值
    winparams.x = 0;
    winparams.y = 0;

    //設置懸浮窗口長寬數據
    winparams.width = WindowManager.LayoutParams.WRAP_CONTENT;;
    winparams.height = WindowManager.LayoutParams.WRAP_CONTENT;;

    windowManager.addView(rootView, winparams);
}

       關於WindowManager的使用請看如下博客 ：

                               <<android學習---- WindowManager 接口 >>

                              <<在Android中使用WindowManager實現懸浮窗口>>

      關於WindowManager.LayoutParams類說明請看如下博客： 

                              << android學習---- WindowManager.LayoutParams>>

       下面，我們從獲得WindowManager對象引用開始，一步步觀察addView()做了一些什麼事情。

   Step 1 、獲得WindowManager對象服務 ，具體實現類在ContextImpl.java內中

          路徑： /frameworks/base/core/java/android/app/ContextImpl.java        

@Override
public Object getSystemService(String name) {
    if (WINDOW_SERVICE.equals(name)) {
        return WindowManagerImpl.getDefault();
    }
    ...
}

        WindowManager是個接口，具體返回對象則是WindowManagerImpl的單例對象。

 Step 2 、 獲得WindowManagerImpl的單例對象，以及部分源碼分析

          路徑： /frameworks/base/core/java/android/view/WindowManagerImpl.java 

public class WindowManagerImpl implements WindowManager{

   public static WindowManagerImpl getDefault()
   {
       return mWindowManager;
   }
   //以特定Window屬性添加一個窗口
   public void addView(View view, ViewGroup.LayoutParams params)
   {
       addView(view, params, false);
   }
   //參數nest表示該窗口是不是一個字窗口
   private void addView(View view, ViewGroup.LayoutParams params, boolean nest)
   {   ...
       final WindowManager.LayoutParams wparams = (WindowManager.LayoutParams)params;

       ViewRoot root;
       View panelParentView = null;    //該子窗口對應地父窗口View

       synchronized (this) {

           ...//需要對傳遞過來地參數進行檢測...

           //對每個窗口皆構建一個ViewRoot對象
           root = new ViewRoot(view.getContext());
           root.mAddNesting = 1;
           //設置root View 的LayoutParams爲wparams，即WindowManager.LayoutParams類型
           view.setLayoutParams(wparams);
           ...//對參數檢測，以及拷貝原有數組...

           //將窗口對應地view、root、wparams保存在屬性集合中
           mViews[index] = view;
           mRoots[index] = root;
           mParams[index] = wparams;
       }
       // do this last because it fires off messages to start doing things
       // 調用ViewRoot對象去通知系統添加一個窗口
       root.setView(view, wparams, panelParentView);
   }
   ...
   //這三個數組分別保存了一個窗口對應地屬性
   private View[] mViews;         //root View對象 ， View類型
   private ViewRoot[] mRoots;     //ViewRoot類型 ， 與WMS通信
   private WindowManager.LayoutParams[] mParams;  //窗口屬性

   //WindowManagerImpl實現了單例模式
   private static WindowManagerImpl mWindowManager = new WindowManagerImpl();
}

      WindowManagerImpl類的三個數組集合保存了每個窗口相關屬性，這樣我們可以通過這些屬性去操作特定的

 窗口(例如，可以根據View去更新/銷燬該窗口)。當參數檢查成功時，構建一個ViewRoot對象，並且設置設置root

 View 的LayoutParams爲wparams，即WindowManager.LayoutParams類型。最後調用root.setView()方法去通知

 系統需要創建該窗口。我們接下來往下看看ViewRoot類相關操作。

  

    Step 3、

   

public final class ViewRoot extends Handler implements ViewParent,View.AttachInfo.Callbacks {

    View mView;   //所有窗口地root View
    final WindowManager.LayoutParams mWindowAttributes = new WindowManager.LayoutParams();

    ...
     /**
     * We have one child
     */
    public void setView(View view, WindowManager.LayoutParams attrs,
            View panelParentView) {
        synchronized (this) {
            if (mView == null) {
                mView = view;
                mWindowAttributes.copyFrom(attrs); //保存WindowManager.LayoutParams屬性值
                attrs = mWindowAttributes;
                ...

                mAdded = true;
                int res; /* = WindowManagerImpl.ADD_OKAY; */

                // Schedule the first layout -before- adding to the window
                // manager, to make sure we do the relayout before receiving
                // any other events from the system.
                requestLayout();   //請求UI開始繪製。
                mInputChannel = new InputChannel();  //創建一個InputChannel對象，接受消息
                try {
                    //通知WindowManagerService添加一個窗口
                    res = sWindowSession.add(mWindow, mWindowAttributes,
                            getHostVisibility(), mAttachInfo.mContentInsets,
                            mInputChannel);
                }
                ...
                view.assignParent(this);  //將root View的父View設置爲該ViewRoot對象(實現了ViewParent接口)
                ...
            }
        }
    }
}

           說明：ViewRoot類繼承了Handler，實現了ViewParent接口

  setView()方法地主要功能如下：
        1、保存相關屬性值，例如：mView、mWindowAttributes等；
        2、調用requestLayout()方法請求UI繪製，由於ViewRoot是個Handler對象，異步請求；
        3、通知WindowManagerService添加一個窗口；
        4、註冊一個事件監聽管道，用來監聽：按鍵(KeyEvent)和觸摸(MotionEvent)事件。

  我們這兒重點關注 requestLayout()方法請求UI繪製地流程。

  Step 4、異步調用請求UI繪製

   

/**
 * {@inheritDoc}
 */
public void requestLayout() {
    checkThread();        //檢查是不是UI線程調用，如果不是UI線程，會報異常
    mLayoutRequested = true;   //置爲真，表示需要進行measure和layout過程
    scheduleTraversals();
}
//開始UI繪製流程
public void scheduleTraversals() {
    if (!mTraversalScheduled) {
        mTraversalScheduled = true;       //防止多次調用
        sendEmptyMessage(DO_TRAVERSAL);   //異步請求UI繪製
    }
}
@Override
public void handleMessage(Message msg) {
 switch (msg.what) {
        case DO_TRAVERSAL:
             performTraversals();  //開始UI繪製
             break;
 }
}

   

          由於performTraversals()方法比較複雜，我們側重於第一次設置root View的widhtSpecSize以及    

  heightSpecSize值。

private void performTraversals() {
    // cache mView since it is used so much below...
    final View host = mView;

    mTraversalScheduled = false;
    boolean surfaceChanged = false;
    WindowManager.LayoutParams lp = mWindowAttributes;

    int desiredWindowWidth;              //表示該窗口期望width值
    int desiredWindowHeight;             //表示該窗口期望width值
    int childWidthMeasureSpec;           //保存root View的widthMeasureSpec
    int childHeightMeasureSpec;          //保存root View的heightMeasureSpec

    final View.AttachInfo attachInfo = mAttachInfo;

    final int viewVisibility = getHostVisibility();
    boolean viewVisibilityChanged = mViewVisibility != viewVisibility
            || mNewSurfaceNeeded;

    float appScale = mAttachInfo.mApplicationScale;

    WindowManager.LayoutParams params = null;
    if (mWindowAttributesChanged) {
        mWindowAttributesChanged = false;
        surfaceChanged = true;
        params = lp;
    }
    Rect frame = mWinFrame;
    if (mFirst) {   //mFirst表示是否是第一次繪製該Window
        fullRedrawNeeded = true;
        mLayoutRequested = true;

        DisplayMetrics packageMetrics =
            mView.getContext().getResources().getDisplayMetrics();
        //第一次繪製時desiredWindowWidth，desiredWindowHeight 值大小爲屏幕大小
        desiredWindowWidth = packageMetrics.widthPixels;
        desiredWindowHeight = packageMetrics.heightPixels;
        ...
    } else {   //不是第一次繪製，則desiredWindowWidth值爲frame保存大小，frame值會由WMS填充
        desiredWindowWidth = frame.width();
        desiredWindowHeight = frame.height();
        ...
    }
    ...
    boolean insetsChanged = false;

    if (mLayoutRequested) {
        ...//獲得root View的widthMeasureSpec 和 heightMeasureSpec值
        childWidthMeasureSpec = getRootMeasureSpec(desiredWindowWidth, lp.width);
        childHeightMeasureSpec = getRootMeasureSpec(desiredWindowHeight, lp.height);
        //開始measure過程
        host.measure(childWidthMeasureSpec, childHeightMeasureSpec);
    }
    ...
    final boolean didLayout = mLayoutRequested;

    boolean triggerGlobalLayoutListener = didLayout
            || attachInfo.mRecomputeGlobalAttributes;
    if (didLayout) {
        ... //layout過程
       host.layout(0, 0, host.mMeasuredWidth, host.mMeasuredHeight);
        ...
    }
    ...
    if (!cancelDraw && !newSurface) {
        mFullRedrawNeeded = false;
        draw(fullRedrawNeeded);
        ...
}

/**
  * @param windowSize  The available width or height of the window
  *
  * @param rootDimension The layout params for one dimension (width or height) of the window.
 */
 private int getRootMeasureSpec(int windowSize, int rootDimension) {
     int measureSpec;
     switch (rootDimension) {
     case ViewGroup.LayoutParams.MATCH_PARENT:
         // Window can't resize. Force root view to be windowSize.
         measureSpec = MeasureSpec.makeMeasureSpec(windowSize, MeasureSpec.EXACTLY);
         break;
     case ViewGroup.LayoutParams.WRAP_CONTENT:
         // Window can resize. Set max size for root view.
         measureSpec = MeasureSpec.makeMeasureSpec(windowSize, MeasureSpec.AT_MOST);
         break;
     default:
         // Window wants to be an exact size. Force root view to be that size.
         measureSpec = MeasureSpec.makeMeasureSpec(rootDimension, MeasureSpec.EXACTLY);
         break;
     }
     return measureSpec;
 }

      調用root View的measure()方法時，其參數是由getRootMeasureSpec()設置的

第二步我們看measure與onmeasure

android中onMeasure

有兩個對佈局界面影響很的方法,onDraw(),和onMeasure().

onDraw()比較好理解.onMeasure()就比較難理解一些,也更復雜些 ,引用文檔中的說法就是:

onMeasure() is a little more involved.

其實還有另一個方面的原因就是我對這個單詞measure不是很知道,然後果了下詞典,就放了下心,確實是測量的意思.

實現onMeasure()方法基本需要完成下面三個方面的事情(最終結果是你自己寫相應代碼得出測量值並調用view的一個方法進行設置,告訴給你的view安排位置大小的父容器你要多大的空間.):

1.傳遞進來的參數,widthMeasureSpec,和heightMeasureSpec是你對你應該得出來的測量值的限制.

 

The overidden onMeasure() method is called with width and height measure specifications(widthMeasureSpec and heightMeasureSpec parameters,both are integer codes representing dimensions) which should be treated as requirements for the restrictions on the width and height measurements you should produce.

2. 你在onMeasure計算出來設置的width和height將被用來渲染組件.應當儘量在傳遞進來的width和height 聲明之間.

雖然你也可以選擇你設置的尺寸超過傳遞進來的聲明.但是這樣的話,父容器可以選擇,如clipping,scrolling,或者拋出異常,或者(也許是用新的聲明參數)再次調用onMeasure()

Your component's onMeasure() method should calculate a measurement width and height which will be required to render the component.it should try to stay within the specified passed in.although it can choose to exceed them(in this case,the parent can choose what to do,including clipping,scrolling,throwing an excption,or asking the onMeasure to try again,perhaps with different measurement specifications).

3.一但width和height計算好了,就應該調用View.setMeasuredDimension(int width,int height)方法,否則將導致拋出異常.

Once the width and height are calculated,the setMeasureDimension(int width,int height) method must be called with the calculated measurements.Failure to do this will result in an exceptiion being thrown

   

在Android提提供的一個自定義View示例中(在API demos 中的 view/LabelView)可以看到一個重寫onMeasure()方法的

實例,也比較好理解.

01

/**

02	* @see android.view.View#measure(int, int)

03

*/

04

@Override

05	protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {

06	setMeasuredDimension(measureWidth(widthMeasureSpec),

07	measureHeight(heightMeasureSpec));

08

}

09

10

/**

11	* Determines the width of this view

12	* @param measureSpec A measureSpec packed into an int

13	* @return The width of the view, honoring constraints from measureSpec

14

*/

15	private int measureWidth(int measureSpec) {

16	int result = 0;

17	int specMode = MeasureSpec.getMode(measureSpec);

18	int specSize = MeasureSpec.getSize(measureSpec);

19

20	if (specMode == MeasureSpec.EXACTLY) {

21	// We were told how big to be

22	result = specSize;

23

} else {

24	// Measure the text

25	result = (int) mTextPaint.measureText(mText) + getPaddingLeft()

26	+ getPaddingRight();

27	if (specMode == MeasureSpec.AT_MOST) {

28	// Respect AT_MOST value if that was what is called for by measureSpec

29	result = Math.min(result, specSize);

30

}

31

}

32

33	return result;

34

}

 

直接看measureWidth()

首先看到的是參數,分別代表寬度和高度的MeasureSpec

android2.2文檔中對於MeasureSpec中的說明是:

一個MeasureSpec封裝了從父容器傳遞給子容器的佈局需求.

每一個MeasureSpec代表了一個寬度,或者高度的說明.

一個MeasureSpec是一個大小跟模式的組合值.一共有三種模式.

A MeasureSpec encapsulates the layout requirements passed from parent to child Each MeasureSpec represents a requirement for either the width or the height.A MeasureSpec is compsized of a size and a mode.There are three possible modes:

 (1)UPSPECIFIED :父容器對於子容器沒有任何限制,子容器想要多大就多大.

UNSPECIFIED The parent has not imposed any constraint on the child.It can be whatever size it wants

 (2) EXACTLY

 父容器已經爲子容器設置了尺寸,子容器應當服從這些邊界,不論子容器想要多大的空間.

EXACTLY The parent has determined and exact size for the child.The child is going to be given those bounds regardless of how big it wants to be.

(3) AT_MOST

 子容器可以是聲明大小內的任意大小.

AT_MOST The child can be as large as it wants up to the specified size

MeasureSpec是View類下的靜態公開類,MeasureSpec中的值作爲一個整型是爲了減少對象的分配開支.此類用於

將size和mode打包或者解包爲一個整型.

MeasureSpecs are implemented as ints to reduce object allocation.This class is provided to pack and unpack the size,mode tuple into the int

我比較好奇的是怎麼樣將兩個值打包到一個int中,又如何解包.

MeasureSpec類代碼如下 :(註釋已經被我刪除了,因爲在上面說明了.)

01	public static class MeasureSpec {

02	private static final int MODE_SHIFT = 30;

03	private static final int MODE_MASK  = 0x3 << MODE_SHIFT;

04

05	public static final int UNSPECIFIED = 0 << MODE_SHIFT;

06	public static final int EXACTLY     = 1 << MODE_SHIFT;

07	public static final int AT_MOST     = 2 << MODE_SHIFT;

08

09	public static int makeMeasureSpec(int size, int mode) {

10	return size + mode;

11

}

12	public static int getMode(int measureSpec) {

13	return (measureSpec & MODE_MASK);

14

}

15	public static int getSize(int measureSpec) {

16	return (measureSpec & ~MODE_MASK);

17

}  }

我無聊的將他們的十進制值打印出來了:

mode_shift=30,mode_mask=-1073741824,UNSPECIFIED=0,EXACTLY=1073741824,AT_MOST=-2147483648

然後覺得也應該將他們的二進制值打印出來,如下:

mode_shift=11110, // 30

mode_mask=11000000000000000000000000000000,

UNSPECIFIED=0, 

EXACTLY=1000000000000000000000000000000, 

AT_MOST=10000000000000000000000000000000

 

1	MODE_MASK  = 0x3 << MODE_SHIFT //也就是說MODE_MASK是由11左移30位得到的.因爲Java用補碼錶示數值.最後得到的值最高位是1所以就是負數了

1

對於上面的數值我們應該這樣想,不要把0x3看成3而要看成二進制的11,

而把MODE_SHIFF就看成30.那爲什麼是二進制 的11呢?

呢,因爲只有三各模式,如果有四種模式就是111了因爲111三個位纔可以有四種組合對吧.

我們這樣來看,

UNSPECIFIED=00000000000000000000000000000000, 

      EXACTLY=01000000000000000000000000000000, 

    AT_MOST=10000000000000000000000000000000

也就是說,0,1,2

對應   00,01,10

當跟11想與時  00 &11 還是得到 00,11&01 -> 01,10&

我覺得到了這個份上相信,看我博客的也都理解了.

 return (measureSpec & ~MODE_MASK);應該是 return (measureSpec & (~MODE_MASK));

第二步這裏我補充幾點

measure()方法是final類型的，onmeasure()方法可以重寫

measure方法裏面會調用onmeasure方法

onmeasure方法裏面確定寬高

如果是ViewGroup則再次調用measure方法，然後onmeasure確定寬高


layout()方法也如此即layout是final的,onlayout是可以重寫的

繼承自GroupView的時候得重寫onLayout方法，調用layout(l,t,r,b)佈局子View視圖座標

第三步我們看draw方法--------->>總結如下幾點：

     draw()方法與上面不同的是他可以重寫

    View的draw()方法調用了ondraw(),dispatchDraw()方法

第四步我們看dispatchDraw()方法

         * 繪製VIew本身的內容，通過調用View.onDraw(canvas)函數實現,繪製自己的child通過dispatchDraw（canvas）實現
         * 繪製自己的孩子通過dispatchDraw（canvas）實現 當它沒有背景時直接調用的是dispatchDraw()方法,
         * 而繞過了draw()方法，當它有背景的時候就調用draw()方法，而draw()方法裏包含了dispatchDraw()方法的調用。
         * 因此要在ViewGroup上繪製東西的時候往往重寫的是dispatchDraw()方法而不是onDraw()方法
         * 注意此處有三個方法一個draw 一個ondraw() 一個dispatchdraw
        

接下來我們進入第二個階段 研究onInterceptTouchEvent

onInterceptTouchEvent和onTouchEvent調用時序

onInterceptTouchEvent()是ViewGroup的一個方法，目的是在系統向該ViewGroup及其各個childView觸發onTouchEvent()之前對相關事件進行一次攔截，Android這麼設計的想法也很好理解，由於ViewGroup會包含若干childView,因此需要能夠統一監控各種touch事件的機會，因此純粹的不能包含子view的控件是沒有這個方法的，如LinearLayout就有，TextView就沒有。 

onInterceptTouchEvent()使用也很簡單，如果在ViewGroup裏覆寫了該方法，那麼就可以對各種touch事件加以攔截。但是如何攔截，是否所有的touch事件都需要攔截則是比較複雜的，touch事件在onInterceptTouchEvent()和onTouchEvent以及各個childView間的傳遞機制完全取決於onInterceptTouchEvent()和onTouchEvent()的返回值。並且，針對down事件處理的返回值直接影響到後續move和up事件的接收和傳遞。 

關於返回值的問題，基本規則很清楚，如果return true,那麼表示該方法消費了此次事件，如果return false，那麼表示該方法並未處理完全，該事件仍然需要以某種方式傳遞下去繼續等待處理。

SDK給出的說明如下：

·  You will receive the down event here.

·  The down event will be handled either by a child of this view group, or given to your own onTouchEvent() method to handle; this means you should implement onTouchEvent() to return true, so you will continue to see the rest of the gesture (instead of looking for a parent view to handle it). Also, by returning true from onTouchEvent(), you will not receive any following events in onInterceptTouchEvent() and all touch processing must happen in onTouchEvent() like normal.

·  For as long as you return false from this function, each following event (up to and including the final up) will be delivered first here and then to the target's onTouchEvent().

·  If you return true from here, you will not receive any following events: the target view will receive the same event but with the action ACTION_CANCEL, and all further events will be delivered to your onTouchEvent() method and no longer appear here.

 

由於onInterceptTouchEvent()的機制比較複雜，上面的說明寫的也比較複雜，總結一下，基本的規則是：

1.       down事件首先會傳遞到onInterceptTouchEvent()方法

2.       如果該ViewGroup的onInterceptTouchEvent()在接收到down事件處理完成之後return false，那麼後續的move, up等事件將繼續會先傳遞給該ViewGroup，之後才和down事件一樣傳遞給最終的目標view的onTouchEvent()處理。

3.       如果該ViewGroup的onInterceptTouchEvent()在接收到down事件處理完成之後return true，那麼後續的move, up等事件將不再傳遞給onInterceptTouchEvent()，而是和down事件一樣傳遞給該ViewGroup的onTouchEvent()處理，注意，目標view將接收不到任何事件。

4.       如果最終需要處理事件的view的onTouchEvent()返回了false，那麼該事件將被傳遞至其上一層次的view的onTouchEvent()處理。

5.       如果最終需要處理事件的view 的onTouchEvent()返回了true，那麼後續事件將可以繼續傳遞給該view的onTouchEvent()處理。

 

下面用一個簡單的實驗說明上述複雜的規則。視圖自底向上共3層，其中LayoutView1和LayoutView2就是LinearLayout， MyTextView就是TextView：

對應的xml佈局文件如下：

<?xml version="1.0" encoding="utf-8"?>

<com.touchstudy.LayoutView1 xmlns:android="http://schemas.android.com/apk/res/android"

    android:orientation="vertical"

    android:layout_width="fill_parent"

    android:layout_height="fill_parent" >

    <com.touchstudy.LayoutView2

        android:orientation="vertical"

        android:layout_width="fill_parent"

        android:layout_height="fill_parent"

        android:gravity="center">

       <com.touchstudy.MyTextView 

            android:layout_width="wrap_content"

            android:layout_height="wrap_content"

            android:id="@+id/tv"

            android:text="AB"

            android:textSize="40sp"

            android:textStyle="bold"

            android:background="#FFFFFF"

            android:textColor="#0000FF"/>

   </com.touchstudy.LayoutView2>

</com.touchstudy.LayoutView1>

 

下面看具體情況：

1.       onInterceptTouchEvent()處理down事件均返回false，onTouchEvent()處理事件均返回true

------------------------------------------------------------------------------------------------------------------------------

04-11 03:58:42.620: DEBUG/LayoutView1(614): onInterceptTouchEvent action:ACTION_DOWN

04-11 03:58:42.620: DEBUG/LayoutView2(614): onInterceptTouchEvent action:ACTION_DOWN

04-11 03:58:42.620: DEBUG/MyTextView(614): onTouchEvent action:ACTION_DOWN

04-11 03:58:42.800: DEBUG/LayoutView1(614): onInterceptTouchEvent action:ACTION_MOVE

04-11 03:58:42.800: DEBUG/LayoutView2(614): onInterceptTouchEvent action:ACTION_MOVE

04-11 03:58:42.800: DEBUG/MyTextView(614): onTouchEvent action:ACTION_MOVE

…… //省略過多的ACTION_MOVE

04-11 03:58:43.130: DEBUG/LayoutView1(614): onInterceptTouchEvent action:ACTION_UP

04-11 03:58:43.130: DEBUG/LayoutView2(614): onInterceptTouchEvent action:ACTION_UP

04-11 03:58:43.150: DEBUG/MyTextView(614): onTouchEvent action:ACTION_UP

------------------------------------------------------------------------------------------------------------------------------

這是最常見的情況，onInterceptTouchEvent並沒有做任何改變事件傳遞時序的操作，效果上和沒有覆寫該方法是一樣的。可以看到，各種事件的傳遞本身是自底向上的，次序是：LayoutView1->LayoutView2->MyTextView。注意，在onInterceptTouchEvent均返回false時，LayoutView1和LayoutView2的onTouchEvent並不會收到事件，而是最終傳遞給了MyTextView。

 

2.     LayoutView1的onInterceptTouchEvent()處理down事件返回true，

MyTextView的onTouchEvent()處理事件返回true

------------------------------------------------------------------------------------------------------------------------------

04-11 03:09:27.589: DEBUG/LayoutView1(446): onInterceptTouchEvent action:ACTION_DOWN

04-11 03:09:27.589: DEBUG/LayoutView1(446): onTouchEvent action:ACTION_DOWN

04-11 03:09:27.629: DEBUG/LayoutView1(446): onTouchEvent action:ACTION_MOVE

04-11 03:09:27.689: DEBUG/LayoutView1(446): onTouchEvent action:ACTION_MOVE

…… //省略過多的ACTION_MOVE

04-11 03:09:27.959: DEBUG/LayoutView1(446): onTouchEvent action:ACTION_UP

------------------------------------------------------------------------------------------------------------------------------

從Log可以看到，由於LayoutView1在攔截第一次down事件時return true，所以後續的事件（包括第一次的down）將由LayoutView1本身處理，事件不再傳遞下去。

 

3.       LayoutView1，LayoutView2的onInterceptTouchEvent()處理down事件返回false，

MyTextView的onTouchEvent()處理事件返回false

LayoutView2的onTouchEvent()處理事件返回true

----------------------------------------------------------------------------------------------------------------------------

04-11 09:50:21.147: DEBUG/LayoutView1(301): onInterceptTouchEvent action:ACTION_DOWN

04-11 09:50:21.147: DEBUG/LayoutView2(301): onInterceptTouchEvent action:ACTION_DOWN

04-11 09:50:21.147: DEBUG/MyTextView(301): onTouchEvent action:ACTION_DOWN

04-11 09:50:21.147: DEBUG/LayoutView2(301): onTouchEvent action:ACTION_DOWN

04-11 09:50:21.176: DEBUG/LayoutView1(301): onInterceptTouchEvent action:ACTION_MOVE

04-11 09:50:21.176: DEBUG/LayoutView2(301): onTouchEvent action:ACTION_MOVE

04-11 09:50:21.206: DEBUG/LayoutView1(301): onInterceptTouchEvent action:ACTION_MOVE

04-11 09:50:21.217: DEBUG/LayoutView2(301): onTouchEvent action:ACTION_MOVE

…… //省略過多的ACTION_MOVE

04-11 09:50:21.486: DEBUG/LayoutView1(301): onInterceptTouchEvent action:ACTION_UP

04-11 09:50:21.486: DEBUG/LayoutView2(301): onTouchEvent action:ACTION_UP

----------------------------------------------------------------------------------------------------------------------------

可以看到，由於MyTextView在onTouchEvent()中return false，down事件被傳遞給其父view，即LayoutView2的onTouchEvent()方法處理，由於在LayoutView2的onTouchEvent()中return true，所以down事件傳遞並沒有上傳到LayoutView1。注意，後續的move和up事件均被傳遞給LayoutView2的onTouchEvent()處理，而沒有傳遞給MyTextView。

 

----------------------------------------------------------------------------------------------------------------

應大家的要求，我把源代碼貼上，其實很簡單，就是基礎文件，主要是用來觀察事件的傳遞。

 

主Activity: InterceptTouchStudyActivity.java：

 

public class InterceptTouchStudyActivityextends Activity {

    static final String TAG = "ITSActivity";

    TextView tv;

   

    /** Calledwhen the activity is first created. */

    @Override

    public void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        setContentView(R.layout.layers_touch_pass_test);

     }

 }

 

      LayoutView1.java：

      public class LayoutView1 extends LinearLayout {

     private final String TAG = "LayoutView1";

       public LayoutView1(Context context, AttributeSet attrs) {

         super(context, attrs);

         Log.d(TAG,TAG);

     }

 

     @Override

     public boolean onInterceptTouchEvent(MotionEvent ev) {

         int action = ev.getAction();

         switch(action){

         case MotionEvent.ACTION_DOWN:

              Log.d(TAG,"onInterceptTouchEventaction:ACTION_DOWN");

//            return true;

              break;

         case MotionEvent.ACTION_MOVE:

              Log.d(TAG,"onInterceptTouchEventaction:ACTION_MOVE");

              break;

         case MotionEvent.ACTION_UP:

              Log.d(TAG,"onInterceptTouchEventaction:ACTION_UP");

              break;

         case MotionEvent.ACTION_CANCEL:

              Log.d(TAG,"onInterceptTouchEventaction:ACTION_CANCEL");

              break;

         }

        

         return false;

     }

 

     @Override

     public boolean onTouchEvent(MotionEvent ev) {

         int action = ev.getAction();

         switch(action){

         case MotionEvent.ACTION_DOWN:

              Log.d(TAG,"onTouchEventaction:ACTION_DOWN");

              break;

         case MotionEvent.ACTION_MOVE:

              Log.d(TAG,"onTouchEventaction:ACTION_MOVE");

              break;

         case MotionEvent.ACTION_UP:

              Log.d(TAG,"onTouchEventaction:ACTION_UP");

              break;

         case MotionEvent.ACTION_CANCEL:

              Log.d(TAG,"onTouchEventaction:ACTION_CANCEL");

              break;

         }

        

         return true;

     }

 

     @Override

     protected void onLayout(boolean changed, int l, int t, int r, int b) {

         // TODO Auto-generatedmethod stub

         super.onLayout(changed, l, t, r, b);

     }

 

     @Override

     protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {

         // TODO Auto-generatedmethod stub

         super.onMeasure(widthMeasureSpec, heightMeasureSpec);

     }

}

LayoutView2.java：

 

public class LayoutView2 extends LinearLayout {

    private final String TAG = "LayoutView2";

   

    public LayoutView2(Context context, AttributeSet attrs) {

       super(context, attrs);

       Log.d(TAG,TAG);

    }

 

    @Override

    public boolean onInterceptTouchEvent(MotionEvent ev) {

       int action = ev.getAction();

       switch(action){

       case MotionEvent.ACTION_DOWN:

           Log.d(TAG,"onInterceptTouchEventaction:ACTION_DOWN");

           break;

       case MotionEvent.ACTION_MOVE:

           Log.d(TAG,"onInterceptTouchEventaction:ACTION_MOVE");

           break;

       case MotionEvent.ACTION_UP:

           Log.d(TAG,"onInterceptTouchEventaction:ACTION_UP");

           break;

       case MotionEvent.ACTION_CANCEL:

           Log.d(TAG,"onInterceptTouchEventaction:ACTION_CANCEL");

           break;

       }

      

       return false;

    }

 

    @Override

    public boolean onTouchEvent(MotionEvent ev) {

       int action = ev.getAction();

       switch(action){

       case MotionEvent.ACTION_DOWN:

           Log.d(TAG,"onTouchEventaction:ACTION_DOWN");

           break;

       case MotionEvent.ACTION_MOVE:

           Log.d(TAG,"onTouchEventaction:ACTION_MOVE");

           break;

       case MotionEvent.ACTION_UP:

           Log.d(TAG,"onTouchEventaction:ACTION_UP");

           break;

       case MotionEvent.ACTION_CANCEL:

           Log.d(TAG,"onTouchEventaction:ACTION_CANCEL");

           break;

       }

      

       return true;

    } 

}

MyTextView.java:

public class MyTextView extends TextView {

    private final String TAG = "MyTextView";

   

    public MyTextView(Context context, AttributeSet attrs) {

       super(context, attrs);

       Log.d(TAG,TAG);

    }

 

    @Override

    public boolean onTouchEvent(MotionEvent ev) {

       int action = ev.getAction();

       switch(action){

       case MotionEvent.ACTION_DOWN:

           Log.d(TAG,"onTouchEventaction:ACTION_DOWN");

           break;

       case MotionEvent.ACTION_MOVE:

           Log.d(TAG,"onTouchEventaction:ACTION_MOVE");

           break;

       case MotionEvent.ACTION_UP:

           Log.d(TAG,"onTouchEventaction:ACTION_UP");

           break;

       case MotionEvent.ACTION_CANCEL:

           Log.d(TAG,"onTouchEventaction:ACTION_CANCEL");

           break;

       }

      

       return false;

    }

   

    public void onClick(View v) {

       Log.d(TAG, "onClick");

    }

   

    public boolean onLongClick(View v) {

       Log.d(TAG, "onLongClick");

       return false;

    }

}

最後我們來研究Scroller與computeScroll

Scroller這個類理解起來有一定的困難，剛開始接觸Scroller類的程序員可能無法理解Scroller和View系統是怎麼樣聯繫起來的。我經過自己的學習和實踐，對Scroller的用法和工作原理有了一定的理解，在這裏和大家分享一下，希望大家多多指教。

      首先從源碼開始分析：

        View.java

 

  /**
 * 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()
{
}

 

    computeScroll是一個空函數，很明顯我們需要去實現它，至於做什麼，就由我們自己來決定了。

    因爲View的子類很多，在下面的例子中，我會在一個自定義的類MyLinearLayout中去實現它。

 

    ViewGroup.java

   

@Override
protected void dispatchDraw(Canvas canvas) {

            .......

            .......

            .......

            .......

            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);
            }

            .......

            .......

            .......

從dispatchDraw函數可以看出，ViewGroup會對它的每個孩子調用drawChild(),  在下面的例子中， ContentLinearLayout的孩子有2個，是2個MyLinearLayout類型的實例。

再看看drawChild函數：

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

            ................

            ................

           child.computeScroll();

            ................

            ................

}

 

看到這裏，我想大家應該就明白了，在父容器重畫自己的孩子時，它會調用孩子的computScroll方法，也就是說例程中的ContentLinearLayout在調用dispatchDraw（）函數時會調用MyLinearLayout的computeScroll方法。

     這個computeScroll（）函數正是我們大展身手的地方，在這個函數裏我們可以去取得事先設置好的成員變量mScroller中的位置信息、速度信息等等，用這些參數來做我們想做的事情。

    看到這裏大家一定迫不及待的想看代碼了，代碼如下：

    

package com.yulongfei.scroller;

import android.widget.LinearLayout;
import android.widget.Scroller;
import android.app.Activity;
import android.content.Context;
import android.graphics.Canvas;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.view.View.OnClickListener;

public class TestScrollerActivity extends Activity {
 private static final String TAG = "TestScrollerActivity";
    LinearLayout lay1,lay2,lay0;
     private Scroller mScroller;
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mScroller = new Scroller(this);
        lay1 = new MyLinearLayout(this);
        lay2 = new MyLinearLayout(this);

        lay1.setBackgroundColor(this.getResources().getColor(android.R.color.darker_gray));
        lay2.setBackgroundColor(this.getResources().getColor(android.R.color.white));
        lay0 = new ContentLinearLayout(this);
        lay0.setOrientation(LinearLayout.VERTICAL);
        LinearLayout.LayoutParams p0 = new LinearLayout.LayoutParams
        (LinearLayout.LayoutParams.FILL_PARENT,LinearLayout.LayoutParams.FILL_PARENT);
        this.setContentView(lay0, p0);

        LinearLayout.LayoutParams p1 = new LinearLayout.LayoutParams
        (LinearLayout.LayoutParams.FILL_PARENT,LinearLayout.LayoutParams.FILL_PARENT);
        p1.weight=1;
        lay0.addView(lay1,p1);
        LinearLayout.LayoutParams p2 = new LinearLayout.LayoutParams
        (LinearLayout.LayoutParams.FILL_PARENT,LinearLayout.LayoutParams.FILL_PARENT);
        p2.weight=1;
        lay0.addView(lay2,p2);
        MyButton btn1 = new MyButton(this);
        MyButton btn2 = new MyButton(this);
        btn1.setText("btn in layout1");
        btn2.setText("btn in layout2");
        btn1.setOnClickListener(new OnClickListener(){
            @Override
            public void onClick(View v) {
                    mScroller.startScroll(0, 0, -30, -30, 50);
                }
        });
        btn2.setOnClickListener(new OnClickListener(){
            @Override
            public void onClick(View v) {
                    mScroller.startScroll(20, 20, -50, -50, 50);
                }
        });
        lay1.addView(btn1);
        lay2.addView(btn2);
    }
    class MyButton extends Button
    {
     public MyButton(Context ctx)
     {
      super(ctx);
     }
     @Override
     protected void onDraw(Canvas canvas)
     {
      super.onDraw(canvas);
      Log.d("MyButton", this.toString() + " onDraw------");
     }
    }

    class MyLinearLayout extends LinearLayout
    {
     public MyLinearLayout(Context ctx)
     {
      super(ctx);
     }

     @Override
        /**
         * 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()
     {
    Log.d(TAG, this.toString() + " computeScroll-----------");
    if (mScroller.computeScrollOffset())//如果mScroller沒有調用startScroll，這裏將會返回false。
    {
        //因爲調用computeScroll函數的是MyLinearLayout實例，
     //所以調用scrollTo移動的將是該實例的孩子，也就是MyButton實例
        scrollTo(mScroller.getCurrX(), 0);
        Log.d(TAG, "getCurrX = " +  mScroller.getCurrX());

        //繼續讓系統重繪
        getChildAt(0).invalidate();
    }
     }
    }

    class ContentLinearLayout extends LinearLayout
    {
     public ContentLinearLayout(Context ctx)
     {
      super(ctx);
     }

     @Override
     protected void dispatchDraw(Canvas canvas)
     {
      Log.d("ContentLinearLayout", "contentview dispatchDraw");
      super.dispatchDraw(canvas);
     }
    }
}

    對代碼做一個簡單介紹：

    例子中定義了2個MyButton實例btn1和btn2，它們將被其父容器MyLinearLayout實例lay1和lay2通過調用scrollTo來移動。

  ContentLinearLayout實例lay0爲Activity的contentview，它有2個孩子，分別是lay1和lay2。

   mScroller是一個封裝位置和速度等信息的變量，startScroll（）函數只是對它的一些成員變量做一些設置，這個設置的唯一效果就是導致mScroller.computeScrollOffset()    返回true。

      這裏大家可能有個疑問，既然startScroll（）只是虛晃一槍，那scroll的動態效果到底是誰觸發的呢？

後面我將給出答案。

 

運行程序，我們來看看Log

點擊btn1：

 

 

點擊btn2：

   對照Log，我從button被點擊開始，對整個繪製流程進行分析，首先button被點擊（這裏將回答上文的問題），button的背景將發生變化，這時button將調用invalidate（）請求重繪，這就是View系統重繪的源頭，即scroll動態效果的觸發者。與此同時，mScroller.startScroll被調用了，mScroller在此時被設置了一些有效值。

   好了，既然重繪請求已發出了，那麼整個View系統就會來一次自上而下的繪製了，首先輸出的Log就是“contentview dispatchDraw”了，它將繪製需要重繪的孩子（lay1和lay2中的一個）,接着會調用drawChild，使得computeScroll函數被觸發（drawChild裏面會調用child.computeScroll()）,於是，lay1或者lay2就會以mScroller的位置信息爲依據來調用scrollTo了，它的孩子btn1或者btn2就會被移動了。之後又調用了getChildAt(0).invalidate()，這將導致系統不斷重繪，直到startScroll中設置的時間耗盡mScroller.computeScrollOffset()返回false才停下來。

   好了，現在整個流程都分析完了，相信大家應該清楚了Scroller類與View系統的關係了吧。理解了Scroller的工作原理，你會發現原來Scroller類並不神祕，甚至有點被動，它除了儲存一些數值，什麼其他的事情都沒做，Scroller類中的一些變量mStartX, mFinalX, mDuration等等的意義也很好理解。

注意：

1、之前有朋友反饋button點擊不能移動，這是因爲android 4.0默認打開了硬件加速，如果想讓button移動，請在AndroidManifest的Application標籤或者activity標籤中加入：android:hardwareAccelerated="false"

2、代碼中的 getChildAt(0).invalidate(); 是多餘的，可以不寫，多謝網友指出這一點。

scroller講解

1、掌握View(視圖)的"視圖座標"以及"佈局座標"，以及scrollTo()和scrollBy()方法的作用 ----- 必須理解

                      如果對這方面知識不太清楚的話，建議先看看我的這篇博客

                         <Android中滑屏初探 ---- scrollTo 以及 scrollBy方法使用說明>， 

                   不誇張地說，這篇博客理論上來說是我們這篇博文的基礎。

             2、知道onInterceptTouchEvent()以及onTouchEvent()對觸摸事件的分發流程         ---- 不是必須

             3、知道怎麼繪製自定義ViewGroup即可                                        ---- 不是必須

 

 

     OK。 繼續往下看，請一定有所準備 。大家跟着我一步一步來咯。

 

 知識點一：  關於scrollTo()和scrollBy()以及偏移座標的設置/取值問題

        在前面一篇博文中《Android中滑屏初探 ---- scrollTo 以及 scrollBy方法使用說明》，我們掌握了scrollTo()和

scrollBy()方法的作用，這兩個方法的主要作用是將View/ViewGroup移至指定的座標中，並且將偏移量保存起來。另外：

                  mScrollX 代表X軸方向的偏移座標

                  mScrollY 代表Y軸方向的偏移座標

          關於偏移量的設置我們可以參看下源碼：

package com.qin.customviewgroup;

public class View {
    ....
    protected int mScrollX;   //該視圖內容相當於視圖起始座標的偏移量   ， X軸 方向
    protected int mScrollY;   //該視圖內容相當於視圖起始座標的偏移量   ， Y軸方向
    //返回值
    public final int getScrollX() {
        return mScrollX;
    }
    public final int getScrollY() {
        return mScrollY;
    }
    public void scrollTo(int x, int y) {
        //偏移位置發生了改變
        if (mScrollX != x || mScrollY != y) {
            int oldX = mScrollX;
            int oldY = mScrollY;
            mScrollX = x;  //賦新值，保存當前便宜量
            mScrollY = y;
            //回調onScrollChanged方法
            onScrollChanged(mScrollX, mScrollY, oldX, oldY);
            if (!awakenScrollBars()) {
                invalidate();  //一般都引起重繪
            }
        }
    }
    // 看出原因了吧 。。 mScrollX 與 mScrollY 代表我們當前偏移的位置 ， 在當前位置繼續偏移(x ,y)個單位
    public void scrollBy(int x, int y) {
        scrollTo(mScrollX + x, mScrollY + y);
    }
    //...
}

     於是，在任何時刻我們都可以獲取該View/ViewGroup的偏移位置了，即調用getScrollX()方法和getScrollY()方法

 

 知識點二： Scroller類的介紹

         在初次看Launcher滑屏的時候，我就對Scroller類的學習感到非常蛋疼，完全失去了繼續研究的慾望。如今，沒得辦法，

  得重新看Launcher模塊，基本上將Launcher大部分類以及功能給掌握了。當然，也花了一天時間來學習Launcher裏的滑屏實現

 ，基本上業是撥開雲霧見真知了。

     

       我們知道想把一個View偏移至指定座標(x,y)處，利用scrollTo()方法直接調用就OK了，但我們不能忽視的是，該方法本身

   來的的副作用：非常迅速的將View/ViewGroup偏移至目標點，而沒有對這個偏移過程有任何控制，對用戶而言可能是不太

   友好的。於是，基於這種偏移控制，Scroller類被設計出來了，該類的主要作用是爲偏移過程制定一定的控制流程(後面我們會

   知道的更多)，從而使偏移更流暢，更完美。

   

     可能上面說的比較懸乎，道理也沒有講透。下面我就根據特定情景幫助大家分析下：

        情景： 從上海如何到武漢？

            普通的人可能會想，so easy : 飛機、輪船、11路公交車...

            文藝的人可能會想,  小 case ： 時空忍術(火影的招數)、翻個筋斗(孫大聖的招數)...

     不管怎麼樣，我們想出來的套路可能有兩種：

               1、有個時間控制過程才能抵達(緩慢的前進)                              -----     對應於Scroller的作用

                      假設做火車,這個過程可能包括: 火車速率，花費週期等；

               2、瞬間抵達(超神太快了，都眩暈了，用戶體驗不太好)                     ------   對應於scrollTo()的作用

 

    模擬Scroller類的實現功能：

        假設從上海做動車到武漢需要10個小時，行進距離爲1000km ，火車速率200/h 。採用第一種時間控制方法到達武漢的

   整個配合過程可能如下:

        我們每隔一段時間(例如1小時)，計算火車應該行進的距離，然後調用scrollTo()方法，行進至該處。10小時過完後，

    我們也就達到了目的地了。

 

    相信大家心裏應該有個感覺了。我們就分析下源碼裏去看看Scroller類的相關方法.

 

     其源代碼(部分)如下： 路徑位於 \frameworks\base\core\java\android\widget\Scroller.java

public class Scroller  {

    private int mStartX;    //起始座標點 ,  X軸方向
    private int mStartY;    //起始座標點 ,  Y軸方向
    private int mCurrX;     //當前座標點  X軸， 即調用startScroll函數後,經過一定時間所達到的值
    private int mCurrY;     //當前座標點  Y軸， 即調用startScroll函數後,經過一定時間所達到的值

    private float mDeltaX;  //應該繼續滑動的距離， X軸方向
    private float mDeltaY;  //應該繼續滑動的距離， Y軸方向
    private boolean mFinished;  //是否已經完成本次滑動操作， 如果完成則爲 true

    //構造函數
    public Scroller(Context context) {
        this(context, null);
    }
    public final boolean isFinished() {
        return mFinished;
    }
    //強制結束本次滑屏操作
    public final void forceFinished(boolean finished) {
        mFinished = finished;
    }
    public final int getCurrX() {
        return mCurrX;
    }
     /* 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. */
    //根據當前已經消逝的時間計算當前的座標點，保存在mCurrX和mCurrY值中
    public boolean computeScrollOffset() {
        if (mFinished) {  //已經完成了本次動畫控制，直接返回爲false
            return false;
        }
        int timePassed = (int)(AnimationUtils.currentAnimationTimeMillis() - mStartTime);
        if (timePassed < mDuration) {
            switch (mMode) {
            case SCROLL_MODE:
                float x = (float)timePassed * mDurationReciprocal;
                ...
                mCurrX = mStartX + Math.round(x * mDeltaX);
                mCurrY = mStartY + Math.round(x * mDeltaY);
                break;
            ...
        }
        else {
            mCurrX = mFinalX;
            mCurrY = mFinalY;
            mFinished = true;
        }
        return true;
    }
    //開始一個動畫控制，由(startX , startY)在duration時間內前進(dx,dy)個單位，即到達座標爲(startX+dx , startY+dy)出
    public void startScroll(int startX, int startY, int dx, int dy, int duration) {
        mFinished = false;
        mDuration = duration;
        mStartTime = AnimationUtils.currentAnimationTimeMillis();
        mStartX = startX;       mStartY = startY;
        mFinalX = startX + dx;  mFinalY = startY + dy;
        mDeltaX = dx;            mDeltaY = dy;
        ...
    }
}

     其中比較重要的兩個方法爲：

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

                   函數功能說明：根據當前已經消逝的時間計算當前的座標點，保存在mCurrX和mCurrY值中

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

                  函數功能說明：開始一個動畫控制，由(startX , startY)在duration時間內前進(dx,dy)個單位，到達座標爲

                      (startX+dx , startY+dy)處。

        PS ： 強烈建議大家看看該類的源碼，便於後續理解。

知識點二： computeScroll(）方法介紹

       爲了易於控制滑屏控制，Android框架提供了 computeScroll()方法去控制這個流程。在繪製View時，會在draw()過程調用該

  方法。因此， 再配合使用Scroller實例，我們就可以獲得當前應該的偏移座標，手動使View/ViewGroup偏移至該處。

     computeScroll()方法原型如下，該方法位於ViewGroup.java類中      

/**
     * 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.
     */由父視圖調用用來請求子視圖根據偏移值 mScrollX,mScrollY重新繪製
    public void computeScroll() { //空方法 ，自定義ViewGroup必須實現方法體

    }

          爲了實現偏移控制，一般自定義View/ViewGroup都需要重載該方法 。

 

     其調用過程位於View繪製流程draw()過程中，如下：

@Override
protected void dispatchDraw(Canvas canvas){
    ...

    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);
        }
    }
}
protected boolean drawChild(Canvas canvas, View child, long drawingTime) {
    ...
    child.computeScroll();
    ...
}

   Demo說明:

           我們簡單的複用了之前寫的一個自定義ViewGroup，與以前一次有區別的是，我們沒有調用scrollTo()方法去進行瞬間

       偏移。 本次做法如下：

                   第一、調用Scroller實例去產生一個偏移控制(對應於startScroll()方法)

                   第二、手動調用invalid()方法去重新繪製，剩下的就是在 computeScroll()里根據當前已經逝去的時間，獲取當前

                       應該偏移的座標(由Scroller實例對應的computeScrollOffset()計算而得)，

                   第三、當前應該偏移的座標，調用scrollBy()方法去緩慢移動至該座標處。

 

  截圖如下：

                                                         

                                         原始界面                                     點擊按鈕或者觸摸屏之後的顯示界面

        附：由於滑動截屏很難，只是簡單的截取了兩個個靜態圖片，觸摸的話可以實現左右滑動切屏了。

           更多知識點，請看代碼註釋。。

 

//自定義ViewGroup ， 包含了三個LinearLayout控件，存放在不同的佈局位置，通過scrollBy或者scrollTo方法切換
public class MultiViewGroup extends ViewGroup {
    ...
    //startScroll開始移至下一屏
    public void startMove(){
        curScreen ++ ;
        Log.i(TAG, "----startMove---- curScreen " + curScreen);

        //使用動畫控制偏移過程 , 3s內到位
        mScroller.startScroll((curScreen-1) * getWidth(), 0, getWidth(), 0,3000);
        //其實點擊按鈕的時候，系統會自動重新繪製View，我們還是手動加上吧。
        invalidate();
        //使用scrollTo一步到位
        //scrollTo(curScreen * MultiScreenActivity.screenWidth, 0);
    }
    // 由父視圖調用用來請求子視圖根據偏移值 mScrollX,mScrollY重新繪製
    @Override
    public void computeScroll() {
        // TODO Auto-generated method stub
        Log.e(TAG, "computeScroll");
        // 如果返回true，表示動畫還沒有結束
        // 因爲前面startScroll，所以只有在startScroll完成時 纔會爲false
        if (mScroller.computeScrollOffset()) {
            Log.e(TAG, mScroller.getCurrX() + "======" + mScroller.getCurrY());
            // 產生了動畫效果，根據當前值 每次滾動一點
            scrollTo(mScroller.getCurrX(), mScroller.getCurrY());

            Log.e(TAG, "### getleft is " + getLeft() + " ### getRight is " + getRight());
            //此時同樣也需要刷新View ，否則效果可能有誤差
            postInvalidate();
        }
        else
            Log.i(TAG, "have done the scoller -----");
    }
    //馬上停止移動，如果已經超過了下一屏的一半，我們強制滑到下一個屏幕
    public void stopMove(){

        Log.v(TAG, "----stopMove ----");

        if(mScroller != null){
            //如果動畫還沒結束，我們就按下了結束的按鈕，那我們就結束該動畫，即馬上滑動指定位置
            if(!mScroller.isFinished()){

                int scrollCurX= mScroller.getCurrX() ;
                //判斷是否超過下一屏的中間位置，如果達到就抵達下一屏，否則保持在原屏幕
                // 這樣的一個簡單公式意思是：假設當前滑屏偏移值即 scrollCurX 加上每個屏幕一半的寬度，除以每個屏幕的寬度就是
                //  我們目標屏所在位置了。 假如每個屏幕寬度爲320dip, 我們滑到了500dip處，很顯然我們應該到達第二屏,索引值爲1
                //即(500 + 320/2)/320 = 1
                int descScreen = ( scrollCurX + getWidth() / 2) / getWidth() ;

                Log.i(TAG, "-mScroller.is not finished scrollCurX +" + scrollCurX);
                Log.i(TAG, "-mScroller.is not finished descScreen +" + descScreen);
                mScroller.abortAnimation();

                //停止了動畫，我們馬上滑倒目標位置
                scrollTo(descScreen *getWidth() , 0);
                curScreen = descScreen ; //糾正目標屏位置
            }
            else
                Log.i(TAG, "----OK mScroller.is  finished ---- ");
        }
    }
    ...
}

 如何實現觸摸滑屏？ 

      其實網上有很多關於Launcher實現滑屏的博文，基本上也把道理闡釋的比較明白了 。我這兒也是基於自己的理解，將一些

 重要方面的知識點給補充下，希望能幫助大家理解。

      想要實現滑屏操作，值得考慮的事情包括如下幾個方面：

        其中：onInterceptTouchEvent()主要功能是控制觸摸事件的分發，例如是子視圖的點擊事件還是滑動事件。

        其他所有處理過程均在onTouchEvent()方法裏實現了。

            1、屏幕的滑動要根據手指的移動而移動  ---- 主要實現在onTouchEvent()方法中

            2、當手指鬆開時，可能我們並沒有完全滑動至某個屏幕上，這是我們需要手動判斷當前偏移至去計算目標屏(當前屏或者

               前後屏)，並且優雅的偏移到目標屏(當然是用Scroller實例咯)。

           3、調用computeScroll ()去實現緩慢移動過程。

 

  知識點介紹：              

    VelocityTracker類

           功能：  根據觸摸位置計算每像素的移動速率。

           常用方法有：     

                     public void addMovement (MotionEvent ev)

                   功能：添加觸摸對象MotionEvent ， 用於計算觸摸速率。   

            public void computeCurrentVelocity (int units)

                   功能：以每像素units單位考覈移動速率。額，其實我也不太懂，賦予值1000即可。

                   參照源碼 該units的意思如下：

                           參數 units ： The units you would like the velocity in.  A value of 1
                             provides pixels per millisecond, 1000 provides pixels per second, etc.

            public float getXVelocity ()

                           功能：獲得X軸方向的移動速率。

    ViewConfiguration類

           功能： 獲得一些關於timeouts(時間)、sizes(大小)、distances(距離)的標準常量值 。

           常用方法：

                  public int getScaledEdgeSlop()

                      說明：獲得一個觸摸移動的最小像素值。也就是說，只有超過了這個值，才代表我們該滑屏處理了。

                 public static int getLongPressTimeout()

                     說明：獲得一個執行長按事件監聽(onLongClickListener)的值。也就是說，對某個View按下觸摸時，只有超過了

         這個時間值在，才表示我們該對該View回調長按事件了；否則，小於這個時間點鬆開手指，只執行onClick監聽

 

 

        我能寫下來的也就這麼多了，更多的東西參考代碼註釋吧。 在掌握了上面我羅列的知識後(重點scrollTo、Scroller類)，

    其他方面的知識都是關於點與點之間的計算了以及觸摸事件的分發了。這方面感覺也沒啥可寫的。

//自定義ViewGroup ， 包含了三個LinearLayout控件，存放在不同的佈局位置，通過scrollBy或者scrollTo方法切換
public class MultiViewGroup extends ViewGroup {

    private static String TAG = "MultiViewGroup";

    private int curScreen = 0 ;  //當前屏幕
    private Scroller mScroller = null ; //Scroller對象實例

    public MultiViewGroup(Context context) {
        super(context);
        mContext = context;
        init();
    }
    public MultiViewGroup(Context context, AttributeSet attrs) {
        super(context, attrs);
        mContext = context;
        init();
    }
    //初始化
    private void init() {
        ...
        //初始化Scroller實例
        mScroller = new Scroller(mContext);
        // 初始化3個 LinearLayout控件
        ...
        //初始化一個最小滑動距離
        mTouchSlop = ViewConfiguration.get(getContext()).getScaledTouchSlop();
    }
    // 由父視圖調用用來請求子視圖根據偏移值 mScrollX,mScrollY重新繪製
    @Override
    public void computeScroll() {
        // TODO Auto-generated method stub
        Log.e(TAG, "computeScroll");
        // 如果返回true，表示動畫還沒有結束
        // 因爲前面startScroll，所以只有在startScroll完成時 纔會爲false
        if (mScroller.computeScrollOffset()) {
            Log.e(TAG, mScroller.getCurrX() + "======" + mScroller.getCurrY());
            // 產生了動畫效果，根據當前值 每次滾動一點
            scrollTo(mScroller.getCurrX(), mScroller.getCurrY());

            Log.e(TAG, "### getleft is " + getLeft() + " ### getRight is " + getRight());
            //此時同樣也需要刷新View ，否則效果可能有誤差
            postInvalidate();
        }
        else
            Log.i(TAG, "have done the scoller -----");
    }
    //兩種狀態: 是否處於滑屏狀態
    private static final int TOUCH_STATE_REST = 0;  //什麼都沒做的狀態
    private static final int TOUCH_STATE_SCROLLING = 1;  //開始滑屏的狀態
    private int mTouchState = TOUCH_STATE_REST; //默認是什麼都沒做的狀態
    //--------------------------
    //處理觸摸事件 ~
    public static int  SNAP_VELOCITY = 600 ;  //最小的滑動速率
    private int mTouchSlop = 0 ;              //最小滑動距離，超過了，才認爲開始滑動
    private float mLastionMotionX = 0 ;       //記住上次觸摸屏的位置
    //處理觸摸的速率
    private VelocityTracker mVelocityTracker = null ;

    // 這個感覺沒什麼作用 不管true還是false 都是會執行onTouchEvent的 因爲子view裏面onTouchEvent返回false了
    @Override
    public boolean onInterceptTouchEvent(MotionEvent ev) {
        // TODO Auto-generated method stub
        Log.e(TAG, "onInterceptTouchEvent-slop:" + mTouchSlop);

        final int action = ev.getAction();
        //表示已經開始滑動了，不需要走該Action_MOVE方法了(第一次時可能調用)。
        //該方法主要用於用戶快速鬆開手指，又快速按下的行爲。此時認爲是出於滑屏狀態的。
        if ((action == MotionEvent.ACTION_MOVE) && (mTouchState != TOUCH_STATE_REST)) {
            return true;
        }

        final float x = ev.getX();
        final float y = ev.getY();

        switch (action) {
        case MotionEvent.ACTION_MOVE:
            Log.e(TAG, "onInterceptTouchEvent move");
            final int xDiff = (int) Math.abs(mLastionMotionX - x);
            //超過了最小滑動距離，就可以認爲開始滑動了
            if (xDiff > mTouchSlop) {
                mTouchState = TOUCH_STATE_SCROLLING;
            }
            break;

        case MotionEvent.ACTION_DOWN:
            Log.e(TAG, "onInterceptTouchEvent down");
            mLastionMotionX = x;
            mLastMotionY = y;
            Log.e(TAG, mScroller.isFinished() + "");
            mTouchState = mScroller.isFinished() ? TOUCH_STATE_REST : TOUCH_STATE_SCROLLING;

            break;

        case MotionEvent.ACTION_CANCEL:
        case MotionEvent.ACTION_UP:
            Log.e(TAG, "onInterceptTouchEvent up or cancel");
            mTouchState = TOUCH_STATE_REST;
            break;
        }
        Log.e(TAG, mTouchState + "====" + TOUCH_STATE_REST);
        return mTouchState != TOUCH_STATE_REST;
    }
    public boolean onTouchEvent(MotionEvent event){

        super.onTouchEvent(event);

        Log.i(TAG, "--- onTouchEvent--> " );

        // TODO Auto-generated method stub
        Log.e(TAG, "onTouchEvent start");
        //獲得VelocityTracker對象，並且添加滑動對象
        if (mVelocityTracker == null) {
            mVelocityTracker = VelocityTracker.obtain();
        }
        mVelocityTracker.addMovement(event);

        //觸摸點
        float x = event.getX();
        float y = event.getY();
        switch(event.getAction()){
        case MotionEvent.ACTION_DOWN:
            //如果屏幕的動畫還沒結束，你就按下了，我們就結束上一次動畫，即開始這次新ACTION_DOWN的動畫
            if(mScroller != null){
                if(!mScroller.isFinished()){
                    mScroller.abortAnimation();
                }
            }
            mLastionMotionX = x ; //記住開始落下的屏幕點
            break ;
        case MotionEvent.ACTION_MOVE:
            int detaX = (int)(mLastionMotionX - x ); //每次滑動屏幕，屏幕應該移動的距離
            scrollBy(detaX, 0);//開始緩慢滑屏咯。 detaX > 0 向右滑動 ， detaX < 0 向左滑動 ，

            Log.e(TAG, "--- MotionEvent.ACTION_MOVE--> detaX is " + detaX );
            mLastionMotionX = x ;
            break ;
        case MotionEvent.ACTION_UP:

            final VelocityTracker velocityTracker = mVelocityTracker  ;
            velocityTracker.computeCurrentVelocity(1000);
            //計算速率
            int velocityX = (int) velocityTracker.getXVelocity() ;
            Log.e(TAG , "---velocityX---" + velocityX);

            //滑動速率達到了一個標準(快速向右滑屏，返回上一個屏幕) 馬上進行切屏處理
            if (velocityX > SNAP_VELOCITY && curScreen > 0) {
                // Fling enough to move left
                Log.e(TAG, "snap left");
                snapToScreen(curScreen - 1);
            }
            //快速向左滑屏，返回下一個屏幕)
            else if(velocityX < -SNAP_VELOCITY && curScreen < (getChildCount()-1)){
                Log.e(TAG, "snap right");
                snapToScreen(curScreen + 1);
            }
            //以上爲快速移動的 ，強制切換屏幕
            else{
                //我們是緩慢移動的，因此先判斷是保留在本屏幕還是到下一屏幕
                snapToDestination();
            }
            //回收VelocityTracker對象
            if (mVelocityTracker != null) {
                mVelocityTracker.recycle();
                mVelocityTracker = null;
            }
            //修正mTouchState值
            mTouchState = TOUCH_STATE_REST ;

            break;
        case MotionEvent.ACTION_CANCEL:
            mTouchState = TOUCH_STATE_REST ;
            break;
        }

        return true ;
    }
    ////我們是緩慢移動的，因此需要根據偏移值判斷目標屏是哪個？
    private void snapToDestination(){
        //當前的偏移位置
        int scrollX = getScrollX() ;
        int scrollY = getScrollY() ;

        Log.e(TAG, "### onTouchEvent snapToDestination ### scrollX is " + scrollX);
        //判斷是否超過下一屏的中間位置，如果達到就抵達下一屏，否則保持在原屏幕
        //直接使用這個公式判斷是哪一個屏幕 前後或者自己
        //判斷是否超過下一屏的中間位置，如果達到就抵達下一屏，否則保持在原屏幕
        // 這樣的一個簡單公式意思是：假設當前滑屏偏移值即 scrollCurX 加上每個屏幕一半的寬度，除以每個屏幕的寬度就是
        //  我們目標屏所在位置了。 假如每個屏幕寬度爲320dip, 我們滑到了500dip處，很顯然我們應該到達第二屏
        int destScreen = (getScrollX() + MultiScreenActivity.screenWidth / 2 ) / MultiScreenActivity.screenWidth ;

        Log.e(TAG, "### onTouchEvent  ACTION_UP### dx destScreen " + destScreen);

        snapToScreen(destScreen);
    }
    //真正的實現跳轉屏幕的方法
    private void snapToScreen(int whichScreen){
        //簡單的移到目標屏幕，可能是當前屏或者下一屏幕
        //直接跳轉過去，不太友好
        //scrollTo(mLastScreen * MultiScreenActivity.screenWidth, 0);
        //爲了友好性，我們在增加一個動畫效果
        //需要再次滑動的距離 屏或者下一屏幕的繼續滑動距離

        curScreen = whichScreen ;
        //防止屏幕越界，即超過屏幕數
        if(curScreen > getChildCount() - 1)
            curScreen = getChildCount() - 1 ;
        //爲了達到下一屏幕或者當前屏幕，我們需要繼續滑動的距離.根據dx值，可能想左滑動，也可能像又滑動
        int dx = curScreen * getWidth() - getScrollX() ;

        Log.e(TAG, "### onTouchEvent  ACTION_UP### dx is " + dx);

        mScroller.startScroll(getScrollX(), 0, dx, 0,Math.abs(dx) * 2);

        //由於觸摸事件不會重新繪製View，所以此時需要手動刷新View 否則沒效果
        invalidate();
    }
    //開始滑動至下一屏
    public void startMove(){
        ...
    }
    //理解停止滑動
    public void stopMove(){
        ...
    }
    // measure過程
    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
       ...
    }
    // layout過程
    @Override
    protected void onLayout(boolean changed, int l, int t, int r, int b) {
        ...
    }
}