Android探究之View的繪製流程

時間  2020-08-25
標籤 android 探究 view 繪製 流程 欄目 Android 简体版
原文   原文鏈接

Android中Activity是做爲應用程序的載體存在，表明着一個完整的用戶界面，提供了一個窗口來繪製各類視圖，當Activity啓動時，咱們會經過setContentView方法來設置一個內容視圖，這個內容視圖就是用戶看到的界面。
PhoneWindow是Android系統中最基本的窗口系統，每一個Activity會建立一個。PhoneWindow是Activity和View系統交互的接口。一個PhoneWindow對應一個DecorView跟一個ViewRootImpl，DecorView是ViewTree裏面的頂層佈局，是繼承於FrameLayout，是Activity中全部View的祖先。ViewRootImpl創建DecorView和Window之間的聯繫。
Activity與View的關係
下面介紹一些相關的概念：canvas

  • Window
    Window表示的是一個窗口，它是站在WindowManagerService角度上的一個抽象的概念，Android中全部的視圖都是經過Window來呈現的，不論是Activity、Dialog仍是Toast，只要有View的地方就必定有Window。
    這裏須要注意的是，這個抽象的Window概念和PhoneWindow這個類並非同一個東西，PhoneWindow表示的是手機屏幕的抽象，它充當Activity和DecorView之間的媒介，就算沒有PhoneWindow也是能夠展現View的。
    拋開一切，僅站在WindowManagerService的角度上，Android的界面就是由一個個Window層疊展示的，而Window又是一個抽象的概念，它並非實際存在的，它是以View的形式存在，這個View就是DecorView。
  • DecorView
    DecorView是整個Window界面的最頂層View，View的測量、佈局、繪製、事件分發都是由DecorView往下遍歷這個View樹。DecorView做爲頂級View，通常狀況下它內部會包含一個豎直方向的LinearLayout，在這個LinearLayout裏面有上下兩個部分(具體狀況和Android的版本及主題有關)，上面是標題欄，下面是內容欄。在Activity中咱們經過setContentView所設置的佈局文件其實就是被加載到內容欄中的，而內容欄的id是content，所以指定佈局的方法叫setContent()。
  • ViewRoot
    ViewRoot對應於ViewRootImpl類，它是鏈接WindowManager和DecorView的紐帶，View的三大流程均是經過ViewRoot來完成的。在ActivityThread中，當Activity對象被建立完以後，會將DecorView添加到Window中，同時會建立對應的ViewRootImpl，並將ViewRootImpl和DecorView創建關聯，並保存到WindowManagerGlobal對象中。

繪製的流程

當一個應用啓動時，會啓動一個主Activity，Android系統會根據Activity的佈局來對它進行繪製。繪製會從根視圖ViewRootImpl的performTraversals()方法開始，從上到下遍歷整個視圖樹，每一個View控制負責繪製本身，而ViewGroup還須要負責通知本身的子View進行繪製操做。View的繪製流程主要是指measure、layout、draw這三大流程，即測量、佈局和繪製，其中measure肯定View的測量寬高，layout根據測量的寬高肯定View在其父View中的四個頂點的位置，而draw則將View繪製到屏幕上。經過ViewGroup的遞歸遍歷，一個View樹就展示在屏幕上了。
View的繪製流程
performTraversals()方法在類ViewRootImpl內，其核心代碼以下：ide

int childWidthMeasureSpec = getRootMeasureSpec(mWidth, lp.width);
  int childHeightMeasureSpec = getRootMeasureSpec(mHeight, lp.height);
  ...
  // 測量
  performMeasure(childWidthMeasureSpec, childHeightMeasureSpec);
  ...
  // 佈局
  performLayout(lp, mWidth, mHeight);
  ...
  // 繪製
  performDraw();
  • measure：根據父View傳遞的MeasureSpec進行計算大小，肯定View的測量寬高。
  • layout：根據measure子View所獲得的佈局大小和佈局參數，肯定子View在其父View中的四個頂點的位置。
  • draw：把View繪製到屏幕上。

MeasureSpec

爲了更好地理解View的測量過程，咱們須要理解MeasureSpec，它是View的一個內部類，它表示對View的測量規格。
在Google官方文檔中是這麼定義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 comprised of a size and a mode.ui

MeasureSpec是一個32位二進制的整數，由SpecMode和SpecSize兩部分組成。其中，高2位爲SpecMode(測量模式)，低30位爲SpecSize(測量大小)。
SpecMode的取值可爲如下三種：this

  • UNSPECIFIED：不指定測量模式，父視圖沒有限制子視圖的大小，子視圖能夠是想要的任何尺寸，一般用於系統內部，應用開發中不多使用到。
  • EXACTLY：精確測量模式，表示父視圖已經決定了子視圖的精確大小，這種模式下View的測量值就是SpecSize的值。對應View的LayoutParams的match_parent或者精確數值。
  • AT_MOST：最大值模式，父視圖已經限制子視圖的大小，此時子視圖的尺寸能夠是不超過父視圖運行的最大尺寸的任何尺寸。對應View的LayoutParams的wrap_content。

Measure

ViewGroup的measure

ViewGroup在它的measureChild方法中傳遞給子View。ViewGroup經過遍歷自身全部的子View，並逐個調用子View的measure方法實現測量操做。ViewGroup在遍歷完子View後，須要根據子元素的測量結果來決定本身最終的測量大小，並調用setMeasuredDimension方法保存測量寬高值。spa

// 遍歷測量 ViewGroup 中全部的 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) {
              measureChild(child, widthMeasureSpec, heightMeasureSpec);
          }
      }
  }

//測量某個指定的View
protected void measureChild(View child, int parentWidthMeasureSpec,
         int parentHeightMeasureSpec) {
     final LayoutParams lp = child.getLayoutParams();

     final int childWidthMeasureSpec = getChildMeasureSpec(parentWidthMeasureSpec,
             mPaddingLeft + mPaddingRight, lp.width);
     final int childHeightMeasureSpec = getChildMeasureSpec(parentHeightMeasureSpec,
             mPaddingTop + mPaddingBottom, lp.height);

     child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
 }

View的MeasureSpec是由父容器的MeasureSpec和本身的LayoutParams決定的，可是對於DecorView來講有點不一樣，由於它沒有父類。在ViewRootImpl中的measureHierarchy方法中有以下一段代碼展現了DecorView的MeasureSpec的建立過程，其中desiredWindowWidth和desireWindowHeight是屏幕的尺寸大小。rest

private boolean measureHierarchy(final View host, final WindowManager.LayoutParams lp,
            final Resources res, final int desiredWindowWidth, final int desiredWindowHeight) {
              ...
              childWidthMeasureSpec = getRootMeasureSpec(desiredWindowWidth, lp.width);
                          childHeightMeasureSpec = getRootMeasureSpec(desiredWindowHeight, lp.height);
              performMeasure(childWidthMeasureSpec, childHeightMeasureSpec);
              ...
            }

private static 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;
 }

DecorView是FrameLyaout的子類，屬於ViewGroup，對於ViewGroup來講，除了完成本身的measure過程外，還會遍歷去調用全部子元素的measure方法，各個子元素再遞歸去執行這個過程。和View不一樣的是，ViewGroup是一個抽象類，他沒有重寫View的onMeasure方法，這裏很好理解，由於每一個具體的ViewGroup實現類的功能是不一樣的，如何測量應該讓它本身決定，好比LinearLayout和RelativeLayout。
所以在具體的ViewGroup中須要遍歷去測量子View，這裏咱們看看ViewGroup中提供的測量子View的measureChildWithMargins方法：code

protected void measureChildWithMargins(View child,
         int parentWidthMeasureSpec, int widthUsed,
         int parentHeightMeasureSpec, int heightUsed) {
     final MarginLayoutParams lp = (MarginLayoutParams) child.getLayoutParams();

     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，在調用子元素的measure方法以前會先經過getChildMeasureSpec方法來獲得子元素的MeasureSpec。從代碼上看，子元素的MeasureSpec的建立與父容器的MeasureSpec和自己的LayoutParams有關，此外和View的margin和父類的padding有關，如今看看getChildMeasureSpec的具體實現：orm

public static int getChildMeasureSpec(int spec, int padding, int childDimension) {
 int specMode = MeasureSpec.getMode(spec);
 int specSize = MeasureSpec.getSize(spec);

 int size = Math.max(0, specSize - padding);

 int resultSize = 0;
 int resultMode = 0;

 switch (specMode) {
 // Parent has imposed an exact size on us
 case MeasureSpec.EXACTLY:
     if (childDimension >= 0) {
         resultSize = childDimension;
         resultMode = MeasureSpec.EXACTLY;
     } else if (childDimension == LayoutParams.MATCH_PARENT) {
         // Child wants to be our size. So be it.
         resultSize = size;
         resultMode = MeasureSpec.EXACTLY;
     } else if (childDimension == LayoutParams.WRAP_CONTENT) {
         // Child wants to determine its own size. It can't be
         // bigger than us.
         resultSize = size;
         resultMode = MeasureSpec.AT_MOST;
     }
     break;

 // Parent has imposed a maximum size on us
 case MeasureSpec.AT_MOST:
     if (childDimension >= 0) {
         // Child wants a specific size... so be it
         resultSize = childDimension;
         resultMode = MeasureSpec.EXACTLY;
     } 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;
         resultMode = MeasureSpec.AT_MOST;
     } else if (childDimension == LayoutParams.WRAP_CONTENT) {
         // Child wants to determine its own size. It can't be
         // bigger than us.
         resultSize = size;
         resultMode = MeasureSpec.AT_MOST;
     }
     break;

 // Parent asked to see how big we want to be
 case MeasureSpec.UNSPECIFIED:
     if (childDimension >= 0) {
         // Child wants a specific size... let him have it
         resultSize = childDimension;
         resultMode = MeasureSpec.EXACTLY;
     } else if (childDimension == LayoutParams.MATCH_PARENT) {
         // Child wants to be our size... find out how big it should
         // be
         resultSize = View.sUseZeroUnspecifiedMeasureSpec ? 0 : size;
         resultMode = MeasureSpec.UNSPECIFIED;
     } else if (childDimension == LayoutParams.WRAP_CONTENT) {
         // Child wants to determine its own size.... find out how
         // big it should be
         resultSize = View.sUseZeroUnspecifiedMeasureSpec ? 0 : size;
         resultMode = MeasureSpec.UNSPECIFIED;
     }
     break;
 }
 //noinspection ResourceType
 return MeasureSpec.makeMeasureSpec(resultSize, resultMode);
}

  • 當父View的mode是EXACTLY的時候：說明父View的size是肯定的。
    子View的寬或高是具體數值：子view的size已經固定了，子View的size就是固定這個數值，mode=EXACTLY。
    子View的寬或高是MATCH_PARENT：子View的size=父View的size，mode=EXACTLY。
    子View的寬或高是WRAP_CONTENT：子View是包裹布局，說明子View的size還不肯定，因此子View的size最大不能超過父View的size，mode=AT_MOST。對象

  • 當父View的mode是AT_MOST的時候：說明父View的size是不肯定的。
    子View的寬或高是具體數值：子view的size已經固定了，子View的size就是固定這個數值，mode=EXACTLY。
    子View的寬或高是MATCH_PARENT：父View的size是不肯定的，子View是填充佈局狀況，也不能肯定size，因此子View的size不能超過父View的size，mode=AT_MOST。
    子View的寬或高是WRAP_CONTENT：子View是包裹布局，size不能超過父View的size，mode=AT_MOST。

  • 當父View的mode是UNSPECIFIED的時候：說明父View不指定測量模式，父View沒有限制子視圖的大小，子View能夠是想要的任何尺寸。
    子View的寬或高是具體數值：子view的size已經固定了，子View的size就是固定這個數值，mode=EXACTLY。
    子View的寬或高是MATCH_PARENT：子視圖能夠是想要的任何尺寸，mode=UNSPECIFIED。
    子View的寬或高是WRAP_CONTENT：子視圖能夠是想要的任何尺寸，mode=UNSPECIFIED。
    子View的MeasureSpec建立規則
    須要注意一點就是，此時的MeasureSpec並非View真正的大小，只有setMeasuredDimension以後才能真正肯定View的大小。
    關於具體ViewGroup的onMeasure過程這裏不作分析，因爲每種佈局的測量方式不同，不可能逐個分析，但在它們的onMeasure裏面的步驟是有必定規律的：
    1.根據各自的測量規則遍歷Children元素，調用getChildMeasureSpec方法獲得Child的measureSpec;
    2.調用Child的measure方法;
    3.調用setMeasuredDimension肯定最終的大小。

View的measure

View的measure過程由其measure方法來完成，measure方法是一個final類型的方法，這意味着子類不能重寫此方法，在View的measure方法裏面會去調用onMeasure方法，咱們能夠經過複寫onMeasure()方法去測量設置View的大小。以下：

public final void measure(int widthMeasureSpec, int heightMeasureSpec) {
  ...
  onMeasure(widthMeasureSpec, heightMeasureSpec);
  ....
}

//若是須要自定義測量，子類需重寫這個方法
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
  setMeasuredDimension(getDefaultSize(getSuggestedMinimumWidth(), widthMeasureSpec),
  getDefaultSize(getSuggestedMinimumHeight(), heightMeasureSpec));
}

//將測量好的寬跟高進行存儲
protected final void setMeasuredDimension(int measuredWidth, int measuredHeight) {
    boolean optical = isLayoutModeOptical(this);
    if (optical != isLayoutModeOptical(mParent)) {
        Insets insets = getOpticalInsets();
        int opticalWidth  = insets.left + insets.right;
        int opticalHeight = insets.top  + insets.bottom;

        measuredWidth  += optical ? opticalWidth  : -opticalWidth;
        measuredHeight += optical ? opticalHeight : -opticalHeight;
    }
    setMeasuredDimensionRaw(measuredWidth, measuredHeight);
}

//若是View沒有重寫onMeasure方法，默認會直接調用getDefaultSize
 public static int getDefaultSize(int size, int measureSpec) {
   int result = size;
   //獲取父View傳遞過來的模式
   int specMode = MeasureSpec.getMode(measureSpec);
   //獲取父View傳遞過來的大小
   int specSize = MeasureSpec.getSize(measureSpec);

   switch (specMode) {
     case MeasureSpec.UNSPECIFIED:
     //View的大小父View未定，設置爲建議最小值
        result = size;
        break;
     case MeasureSpec.AT_MOST:
     case MeasureSpec.EXACTLY:
        result = specSize;
        break;
    }
    return result;
 }

從上述代碼能夠得出，View的寬/高由specSize決定，直接繼承View的自定義控件須要重寫onMeasure方法並設置wrap_content時的自身大小，不然在佈局中使用wrap_content就至關於使用match_parent。
上述就是View的measure大體過程，在measure完成以後，經過getMeasuredWidth/Height方法就能夠得到測量後的寬高，這個寬高通常狀況下就等於View的最終寬高，由於View的layout佈局的時候就是根據measureWidth/Height來設置寬高的，除非在layout中修改了measure值。

Layout

measure()方法中咱們已經測量出View的大小，根據這些大小，咱們接下來就要肯定View在父View的佈局位置。Layout的做用是ViewGroup用來肯定子元素的位置，當ViewGroup的位置被肯定後，它在onLayout中會遍歷全部的子元素並調用其layout方法。簡單的來講就是，layout方法肯定View自己的位置，而onLayout方法則會肯定全部子元素的位置。

  • View的layout方法代碼：

    public void layout(int l, int t, int r, int b) {
  ...
  onLayout(changed, l, t, r, b);
  ...
}

//空方法，子類若是是ViewGroup類型，則重寫這個方法，實現ViewGroup中全部View控件佈局
protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
}

能夠看到這是一個空實現，和onMeasure方法相似，onLayout的實現和具體的佈局有關，具體ViewGroup的子類須要重寫onLayout方法，並根據具體佈局規則遍歷調用Children的layout方法。
經過上面的分析，能夠獲得兩個結論：
View經過layout方法來確認本身在父容器中的位置。
ViewGroup經過onLayout方法來肯定View在容器中的位置。

  • FrameLayout的onLayout方法代碼：

    @Override
protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
    layoutChildren(left, top, right, bottom, false);
}

void layoutChildren(int left, int top, int right, int bottom, boolean forceLeftGravity) {
    final int count = getChildCount();

    final int parentLeft = getPaddingLeftWithForeground();
    final int parentRight = right - left - getPaddingRightWithForeground();

    final int parentTop = getPaddingTopWithForeground();
    final int parentBottom = bottom - top - getPaddingBottomWithForeground();

    for (int i = 0; i < count; i++) {
        final View child = getChildAt(i);
        if (child.getVisibility() != GONE) {
            final LayoutParams lp = (LayoutParams) child.getLayoutParams();

            final int width = child.getMeasuredWidth();
            final int height = child.getMeasuredHeight();

            int childLeft;
            int childTop;

            int gravity = lp.gravity;
            if (gravity == -1) {
                gravity = DEFAULT_CHILD_GRAVITY;
            }

            final int layoutDirection = getLayoutDirection();
            final int absoluteGravity = Gravity.getAbsoluteGravity(gravity, layoutDirection);
            final int verticalGravity = gravity & Gravity.VERTICAL_GRAVITY_MASK;

            switch (absoluteGravity & Gravity.HORIZONTAL_GRAVITY_MASK) {
                case Gravity.CENTER_HORIZONTAL:
                    childLeft = parentLeft + (parentRight - parentLeft - width) / 2 +
                    lp.leftMargin - lp.rightMargin;
                    break;
                case Gravity.RIGHT:
                    if (!forceLeftGravity) {
                        childLeft = parentRight - width - lp.rightMargin;
                        break;
                    }
                case Gravity.LEFT:
                default:
                    childLeft = parentLeft + lp.leftMargin;
            }

            switch (verticalGravity) {
                case Gravity.TOP:
                    childTop = parentTop + lp.topMargin;
                    break;
                case Gravity.CENTER_VERTICAL:
                    childTop = parentTop + (parentBottom - parentTop - height) / 2 +
                    lp.topMargin - lp.bottomMargin;
                    break;
                case Gravity.BOTTOM:
                    childTop = parentBottom - height - lp.bottomMargin;
                    break;
                default:
                    childTop = parentTop + lp.topMargin;
            }

            child.layout(childLeft, childTop, childLeft + width, childTop + height);
        }
    }
}

一、獲取父View的內邊距padding的值。
二、遍歷子View，處理子View的layout_gravity屬性、根據View測量後的寬和高、父View的padding值、來肯定子View的佈局參數。
三、調用child.layout方法，對子View進行佈局。

Draw

通過前面的測量和佈局以後，接下來就是繪製了，也就是真正把View繪製在屏幕可見視圖上。Draw操做用來將控件繪製出來，繪製的流程從performDraw()方法開始。performDraw()方法在類ViewRootImpl內，其核心代碼以下：

private void performDraw() {
  ...
  boolean canUseAsync = draw(fullRedrawNeeded);
  ...
}

private boolean draw(boolean fullRedrawNeeded) {
  ...
  if (!drawSoftware(surface, mAttachInfo, xOffset, yOffset,
                      scalingRequired, dirty, surfaceInsets)) {
    return false;
  }
  ...
}

private boolean drawSoftware(Surface surface, AttachInfo attachInfo, int xoff, int yoff,
          boolean scalingRequired, Rect dirty, Rect surfaceInsets) {
   ...
   mView.draw(canvas);
   ...
}

最終調用到View的draw方法繪製每一個具體的View，繪製基本上能夠分爲七個步驟。

public void draw(Canvas canvas) {
    ...
    // Step 1, draw the background, if needed
    int saveCount;
    if (!dirtyOpaque) {
        drawBackground(canvas);
    }
    ...
    // Step 2, If necessary, save the canvas' layers to prepare for fading
    saveCount = canvas.getSaveCount();
    canvas.saveUnclippedLayer(left, top, right, top + length);
    ...
    // Step 3, draw the content
    if (!dirtyOpaque) onDraw(canvas);
    ...
    // Step 4, draw the children
    dispatchDraw(canvas);
    ...
    // Step 5, If necessary, draw the fading edges and restore layers
    canvas.drawRect(left, top, right, top + length, p);
    ...
    canvas.restoreToCount(saveCount);
    ...
    // Step 6, draw decorations (foreground, scrollbars)
    onDrawForeground(canvas);
    ...
    // Step 7, draw the default focus highlight
    drawDefaultFocusHighlight(canvas);
    ...
  }

第一步：drawBackground(canvas)：做用就是繪製View的背景。
第二步：saveUnclippedLayer：保存畫布的圖層。
第三步：onDraw(canvas)：繪製View的內容。View的內容是根據本身需求本身繪製的，因此方法是一個空方法，View的繼承類本身複寫實現繪製內容。
第四步：dispatchDraw（canvas）：遍歷子View進行繪製內容。在View裏面是一個空實現，ViewGroup裏面纔會有實現。View的繪製過程的傳遞經過dispatchDraw來實現的，dispatchDraw會遍歷調用全部子元素的draw方法，如此draw事件就一層層地傳遞了下去。在自定義ViewGroup通常不用複寫這個方法，由於它在裏面的實現幫咱們實現了子View的繪製過程，基本知足需求。
第五步：drawRect：繪製邊緣和恢復畫布的圖層。
第六步：onDrawForeground(canvas)：對前景色跟滾動條進行繪製。
第七步：drawDefaultFocusHighlight(canvas)：繪製默認焦點高亮。

總結

若是是自定義ViewGroup的話，須要重寫onMeasure方法，在onMeasure方法裏面遍歷測量子元素，同理onLayout方法也是同樣，最後實現onDraw方法繪製本身； 若是自定義View的話，則須要從寫onMeasure方法，處理wrap_content的狀況，不須要處理onLayout，最後實現onDraw方法繪製本身。

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