深入理解Android中View绘制的三大流程

概述前言最近对Android中View的绘制机制有了一些新的认识，所以想记录下来并分享给大家。View的工作流程主要是指measure、layout、draw这三大流程，即测量、布局和绘制，其中measure确定View的测量宽高，layout根据测量

前言

最近对AndroID中VIEw的绘制机制有了一些新的认识，所以想记录下来并分享给大家。VIEw的工作流程主要是指measure、layout、draw这三大流程，即测量、布局和绘制，其中measure确定VIEw的测量宽高，layout根据测量的宽高确定VIEw在其父VIEw中的四个顶点的位置，而draw则将VIEw绘制到屏幕上，这样通过VIEwGroup的递归遍历，一个VIEw树就展现在屏幕上了。

说的简单，下面带大家一步一步从源码中分析：

AndroID的VIEw是树形结构的：

基本概念

在介绍VIEw的三大流程之前，我们必须先介绍一些基本的概念，才能更好地理解这整个过程。

Window的概念

Window表示的是一个窗口的概念，它是站在WindowManagerService角度上的一个抽象的概念，AndroID中所有的视图都是通过Window来呈现的，不管是Activity、Dialog还是Toast，只要有VIEw的地方就一定有Window。

这里需要注意的是，这个抽象的Window概念和PhoneWindow这个类并不是同一个东西，PhoneWindow表示的是手机屏幕的抽象，它充当Activity和DecorVIEw之间的媒介，就算没有PhoneWindow也是可以展示VIEw的。

抛开一切，仅站在WindowManagerService的角度上，AndroID的界面就是由一个个Window层叠展现的，而Window又是一个抽象的概念，它并不是实际存在的，它是以VIEw的形式存在，这个VIEw就是DecorVIEw。

关于Window这方面的内容，我们这里先了解一个大概

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对象中。

WindowManagerGlobal.javaroot = new VIEwRootImpl(vIEw.getContext(),display); root.setVIEw(vIEw,wparams,panelParentVIEw);

VIEw的绘制流程是从VIEwRoot的performTraversals方法开始的，它经过measure、layout和draw三个过程才能最终将一个VIEw绘制出来，大致流程如下图：

Measure测量

为了更好地理解VIEw的测量过程，我们还需要理解MeasureSpec，它是VIEw的一个内部类，它表示对VIEw的测量规格。MeasureSpec代表一个32位int值，高2位代表SpecMode(测量模式)，低30位代表Specsize(测量大小)，我们可以看看它的具体实现：

MeasureSpec.javapublic static class MeasureSpec {  private static final int MODE_SHIFT = 30; private static final int MODE_MASK = 0x3 << MODE_SHIFT; /**  * UnspecIFIED 模式：  * 父VIEw不对子VIEw有任何限制，子VIEw需要多大就多大  */  public static final int UnspecIFIED = 0 << MODE_SHIFT; /**  * EXACTYLY 模式：  * 父VIEw已经测量出子Viwe所需要的精确大小，这时候VIEw的最终大小  * 就是Specsize所指定的值。对应于match_parent和精确数值这两种模式  */  public static final int EXACTLY = 1 << MODE_SHIFT; /**  * AT_MOST 模式：  * 子VIEw的最终大小是父VIEw指定的Specsize值，并且子VIEw的大小不能大于这个值，  * 即对应wrap_content这种模式  */  public static final int AT_MOST = 2 << MODE_SHIFT; //将size和mode打包成一个32位的int型数值 //高2位表示SpecMode，测量模式，低30位表示Specsize，某种测量模式下的规格大小 public static int makeMeasureSpec(int size,int mode) {  if (sUsebrokenMakeMeasureSpec) {  return size + mode;  } else {  return (size & ~MODE_MASK) | (mode & MODE_MASK);  } } //将32位的MeasureSpec解包，返回SpecMode,测量模式 public static int getMode(int measureSpec) {  return (measureSpec & MODE_MASK); } //将32位的MeasureSpec解包，返回Specsize，某种测量模式下的规格大小 public static int getSize(int measureSpec) {  return (measureSpec & ~MODE_MASK); } //... }

MeasureSpec通过将SpecMode和Specsize打包成一个int值来避免过多的对象内存分配，并提供了打包和解包的方法。

SpecMode有三种类型,每一类都表示特殊的含义：

UnspecIFIED

父容器不对VIEw有任何限制，要多大就给多大，这种情况一般用于系统内部，表示一种测量的状态；

EXACTLY

父容器已经检测出VIEw所需的精确大小，这个时候VIEw的最终打消就是Specsize所指定的值。它对应于LayoutParams中的match_parent和具体数值这两种模式。

AT_MOST

父容器指定了一个可用大小即Specsize，VIEw的大小不能大于这个值，具体是什么值要看不同VIEw的具体实现。它对应于LayoutParams中wrap_content。

VIEw的MeasureSpec是由父容器的MeasureSpec和自己的LayoutParams决定的，但是对于DecorVIEw来说有点不同，因为它没有父类。在VIEwRootImpl中的measureHIErarchy方法中有如下一段代码展示了DecorVIEw的MeasureSpec的创建过程，其中desireDWindowWIDth和desireWindowHeight是屏幕的尺寸大小：

VIEwGroup的measure

chilDWIDthMeasureSpec = getRootMeasureSpec(desireDWindowWIDth,lp.wIDth); childHeightmeasureSpec = getRootMeasureSpec(desireDWindowHeight,lp.height); performMeasure(chilDWIDthMeasureSpec,childHeightmeasureSpec); 

再看看getRootMeasureSpec方法：

 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的MeasureSpec的产生过程就很明确了，因为DecorVIEw是FrameLyaout的子类，属于VIEwGroup，对于VIEwGroup来说，除了完成自己的measure过程外，还会遍历去调用所有子元素的measure方法，各个子元素再递归去执行这个过程。和VIEw不同的是，VIEwGroup是一个抽象类，他没有重写VIEw的onMeasure方法，这里很好理解，因为每个具体的VIEwGroup实现类的功能是不同的，如何测量应该让它自己决定，比如linearLayout和relativeLayout。

因此在具体的VIEwGroup中需要遍历去测量子VIEw，这里我们看看VIEwGroup中提供的测量子VIEw的measureChilDWithmargins方法：

 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的具体实现：

VIEwGroup.javapublic 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);}

上述代码根据父类的MeasureSpec和自身的LayoutParams创建子元素的MeasureSpec，具体过程同学们自行分析，最终的创建规则如下表：

VIEwGroup在遍历完子VIEw后，需要根据子元素的测量结果来决定自己最终的测量大小，并调用setMeasuredDimension方法保存测量宽高值。

setMeasuredDimension(resolveSizeAndState(maxWIDth,wIDthMeasureSpec,childState),heightSizeAndState); 

这里调用了resolveSizeAndState来确定最终的大小，主要是保证测量的大小不能超过父容器的最大剩余空间maxWIDth，这里我们看看它里面的实现：

 public static int resolveSizeAndState(int size,int measureSpec,int childMeasuredState) { final int specMode = MeasureSpec.getMode(measureSpec); final int specsize = MeasureSpec.getSize(measureSpec); final int result; switch (specMode) {  case MeasureSpec.AT_MOST:  if (specsize < size) {   result = specsize | MEASURED_STATE_TOO_SMALL;  } else {   result = size;  }  break;  case MeasureSpec.EXACTLY:  result = specsize;  break;  case MeasureSpec.UnspecIFIED:  default:  result = size; } return result | (childMeasuredState & MEASURED_STATE_MASK); }

关于具体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.java protected voID onMeasure(int wIDthMeasureSpec,int heightmeasureSpec) { setMeasuredDimension(getDefaultSize(getSuggestedMinimumWIDth(),wIDthMeasureSpec),getDefaultSize(getSuggestedMinimumHeight(),heightmeasureSpec)); }

代码很简单，我们继续看看getDefaultSize方法的实现：

VIEw.java public static int getDefaultSize(int size,int measureSpec) { int result = size; int specMode = MeasureSpec.getMode(measureSpec); int specsize = MeasureSpec.getSize(measureSpec); switch (specMode) { case MeasureSpec.UnspecIFIED:  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布局

Layout的作用是VIEwGroup用来确定子元素的位置，当VIEwGroup的位置被确定后，它在onLayout中会遍历所有的子元素并调用其layout方法。简单的来说就是，layout方法确定VIEw本身的位置，而onLayout方法则会确定所有子元素的位置。

先看看VIEw的layout方法：

 public voID layout(int l,int t,int r,int b) {  if ((mPrivateFlags3 & PFLAG3_MEASURE_NEEDED_BEFORE_LAYOUT) != 0) {   onMeasure(molDWIDthMeasureSpec,moldHeightmeasureSpec);   mPrivateFlags3 &= ~PFLAG3_MEASURE_NEEDED_BEFORE_LAYOUT;  }  int oldL = mleft;  int oldT = mtop;  int oldB = mBottom;  int oldR = mRight;  boolean changed = isLayoutModeOptical(mParent) ?    setopticalFrame(l,t,r,b) : setFrame(l,b);  if (changed || (mPrivateFlags & PFLAG_LAYOUT_required) == PFLAG_LAYOUT_required) {   onLayout(changed,l,b);   if (shouldDrawRoundScrollbar()) {    if(mRoundScrollbarRenderer == null) {     mRoundScrollbarRenderer = new RoundScrollbarRenderer(this);    }   } else {    mRoundScrollbarRenderer = null;   }   mPrivateFlags &= ~PFLAG_LAYOUT_required;   ListenerInfo li = mListenerInfo;   if (li != null && li.mOnLayoutchangelisteners != null) {    ArrayList<OnLayoutchangelistener> Listenerscopy =      (ArrayList<OnLayoutchangelistener>)li.mOnLayoutchangelisteners.clone();    int numListeners = Listenerscopy.size();    for (int i = 0; i < numListeners; ++i) {     Listenerscopy.get(i).onLayoutChange(this,b,oldL,oldT,oldR,oldB);    }   }  }  mPrivateFlags &= ~PFLAG_FORCE_LAYOUT;  mPrivateFlags3 |= PFLAG3_IS_LAID_OUT; }

主要看到这里：

boolean changed = isLayoutModeOptical(mParent) ?setopticalFrame(l,b); 

isLayoutModeOptical方法判断是否显示边界布局(这个东西不知道是啥，暂时不理会)，setopticalFrame方法内部最终也是调用setFrame方法，这里我们看setFrame方法就可以了：

 protected boolean setFrame(int left,int top,int right,int bottom) {  boolean changed = false;  if (DBG) {   Log.d("VIEw",this + " VIEw.setFrame(" + left + "," + top + ","  + right + "," + bottom + ")");  }  //1、如果有一个值发生了改变，那么就需要重新调用onLayout方法了，后面会分析到  if (mleft != left || mRight != right || mtop != top || mBottom != bottom) {   changed = true;   // Remember our drawn bit   int drawn = mPrivateFlags & PFLAG_DRAWN;   //2、保存旧的宽和高   int olDWIDth = mRight - mleft;   int oldHeight = mBottom - mtop;   //计算新的宽和高   int newWIDth = right - left;   int newHeight = bottom - top;   //3、判断宽高是否有分生变化   boolean sizeChanged = (newWIDth != olDWIDth) || (newHeight != oldHeight);   //InvalIDate our old position   //4、如果大小变化了，在已绘制了的情况下就请求重新绘制   invalIDate(sizeChanged);   //5、存储新的值   mleft = left;   mtop = top;   mRight = right;   mBottom = bottom;   mRenderNode.setlefttopRightBottom(mleft,mtop,mRight,mBottom);   mPrivateFlags |= PFLAG_HAS_BOUNDS;   if (sizeChanged) {   //6、大小变化时进行处理   sizeChange(newWIDth,newHeight,olDWIDth,oldHeight);   }   if ((mVIEwFlags & VISIBIliTY_MASK) == VISIBLE || mGhostVIEw != null) {   //7、如果此时VIEw是可见状态下，立即执行绘制 *** 作   invalIDate(sizeChanged);   }   mPrivateFlags |= drawn;   mBackgroundSizeChanged = true;   if (mForegroundInfo != null) {   mForegroundInfo.mBoundsChanged = true;   }   notifySubtreeAccessibilityStateChangedIfNeeded();  }  return changed; }

首先判断四个顶点的位置是否有变化； 判断宽高是否有变化，如果变化了则请求重新绘制； 保存新的值top、left、BottOM、RIGHT。

可以看到changed的值只与四个点是否发生了变化有关。同时，我们还发现，在setframe方法后，就可以获得某个vIEw的top、left、right、bottom的值了。

回到layout方法中，继续执行会调用onLayout方法，我们看看其代码：

protected voID onLayout(boolean changed,int left,int bottom) {} 

可以看到这是一个空实现，和onMeasure方法类似，onLayout的实现和具体的布局有关，具体VIEwGroup的子类需要重写onLayout方法，并根据具体布局规则遍历调用Children的layout方法。

通过上面的分析，可以得到两个结论：

VIEw通过layout方法来确认自己在父容器中的位置 VIEwGroup通过onLayout 方法来确定VIEw在容器中的位置

接下来我们看看FrameLayout的onLayout方法是怎么实现的：

 @OverrIDe protected voID onLayout(boolean changed,int bottom) {  layoutChildren(left,top,right,bottom,false /* no force left gravity */); } voID layoutChildren(int left,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);   }  } }

1、获取父VIEw的内边距padding的值

2、遍历子VIEw，处理子VIEw的layout_gravity属性、根据VIEw测量后的宽和高、父VIEw的padding值、来确定子VIEw的布局参数，

3、调用child.layout方法，对子VIEw进行布局

draw绘制

Draw过程就比较简单了，它的作用是将VIEw绘制到屏幕上面。VIEw的绘制过程遵循如下几部：

绘制背景background.draw(canvas); 绘制自己onDraw; 绘制children：dispatchDraw; 绘制装饰onDrawForeground;

这里我们看看draw方法：

 public voID draw(Canvas canvas) {  final int privateFlags = mPrivateFlags;  final boolean dirtyOpaque = (privateFlags & PFLAG_DIRTY_MASK) == PFLAG_DIRTY_OPAQUE &&    (mAttachInfo == null || !mAttachInfo.mIgnoreDirtyState);  mPrivateFlags = (privateFlags & ~PFLAG_DIRTY_MASK) | PFLAG_DRAWN;  /*   * Draw traversal performs several drawing steps which must be executed   * in the appropriate order:   *   *  1. Draw the background   *  2. If necessary,save the canvas' layers to prepare for fading   *  3. Draw vIEw's content   *  4. Draw children   *  5. If necessary,draw the fading edges and restore layers   *  6. Draw decorations (scrollbars for instance)   */  // Step 1,draw the background,if needed  int saveCount;  if (!dirtyOpaque) {   drawBackground(canvas);  }  // skip step 2 & 5 if possible (common case)  final int vIEwFlags = mVIEwFlags;  boolean horizontalEdges = (vIEwFlags & FADING_EDGE_HORIZONTAL) != 0;  boolean verticalEdges = (vIEwFlags & FADING_EDGE_VERTICAL) != 0;  if (!verticalEdges && !horizontalEdges) {   // Step 3,draw the content   if (!dirtyOpaque) onDraw(canvas);   // Step 4,draw the children   dispatchDraw(canvas);   // Overlay is part of the content and draws beneath Foreground   if (mOverlay != null && !mOverlay.isEmpty()) {    mOverlay.getoverlayVIEw().dispatchDraw(canvas);   }   // Step 6,draw decorations (foreground,scrollbars)   onDrawForeground(canvas);   // we're done...   return;  }   ... ... }

VIEw的绘制过程的传递是通过dispatchDraw来实现的，dispatchDraw会遍历调用所有子元素的draw方法，如此draw事件就一层层地传递了下去。

总结

到这里，VIEw的measure、layout、draw三大流程就说完了，这里做一下总结：

如果是自定义viewGroup的话，需要重写onMeasure方法，在onMeasure方法里面遍历测量子元素，同理onLayout方法也是一样，最后实现onDraw方法绘制自己；

如果自定义view的话，则需要从写onMeasure方法，处理wrap_content的情况，不需要处理onLayout，最后实现onDraw方法绘制自己；

好了，以上就是这篇文章的全部内容，希望本文的内容对大家的学习或者工作能带来一定的帮助，如果有疑问大家可以留言交流，谢谢大家对编程小技巧的支持。

引用[AndroID开发艺术探索]

总结

以上是内存溢出为你收集整理的深入理解Android中View绘制的三大流程全部内容，希望文章能够帮你解决深入理解Android中View绘制的三大流程所遇到的程序开发问题。

如果觉得内存溢出网站内容还不错，欢迎将内存溢出网站推荐给程序员好友。