Android View 绘制流程(Draw)全面解析

前言

前几篇文章，笔者分别讲述了decorview，measure，layout流程等，接下来将详细分析三大工作流程的最后一个流程——绘制流程。测量流程决定了view的大小，布局流程决定了view的位置，那么绘制流程将决定view的样子，一个view该显示什么由绘制流程完成。以下源码均取自android api 21。

从performdraw说起

前面几篇文章提到，三大工作流程始于viewrootimpl#performtraversals,在这个方法内部会分别调用performmeasure，performlayout，performdraw三个方法来分别完成测量，布局，绘制流程。那么我们现在先从performdraw方法看起，viewrootimpl#performdraw:

private void performdraw() {
 //...
 final boolean fullredrawneeded = mfullredrawneeded;
 try {
  draw(fullredrawneeded);
 } finally {
  misdrawing = false;
  trace.traceend(trace.trace_tag_view);
 }

 //省略...
}

里面又调用了viewrootimpl#draw方法，并传递了fullredrawneeded参数，而该参数由mfullredrawneeded成员变量获取，它的作用是判断是否需要重新绘制全部视图，如果是第一次绘制视图，那么显然应该绘制所以的视图，如果由于某些原因，导致了视图重绘，那么就没有必要绘制所有视图。我们来看看viewrootimpl#draw：

private void draw(boolean fullredrawneeded) {
 ...
 //获取mdirty，该值表示需要重绘的区域
 final rect dirty = mdirty;
 if (msurfaceholder != null) {
  // the app owns the surface, we won't draw.
  dirty.setempty();
  if (animating) {
   if (mscroller != null) {
    mscroller.abortanimation();
   }
   disposeresizebuffer();
  }
  return;
 }

 //如果fullredrawneeded为真，则把dirty区域置为整个屏幕，表示整个视图都需要绘制
 //第一次绘制流程，需要绘制所有视图
 if (fullredrawneeded) {
  mattachinfo.mignoredirtystate = true;
  dirty.set(0, 0, (int) (mwidth * appscale + 0.5f), (int) (mheight * appscale + 0.5f));
 }

 //省略...

 if (!drawsoftware(surface, mattachinfo, xoffset, yoffset, scalingrequired, dirty)) {
    return;
  }
}

这里省略了一部分代码，我们只看关键代码，首先是先获取了mdirty值，该值保存了需要重绘的区域的信息，关于视图重绘，后面会有文章专门叙述，这里先熟悉一下。接着根据fullredrawneeded来判断是否需要重置dirty区域，最后调用了viewrootimpl#drawsoftware方法，并把相关参数传递进去，包括dirty区域，我们接着看该方法的源码：

private boolean drawsoftware(surface surface, attachinfo attachinfo, int xoff, int yoff,
   boolean scalingrequired, rect dirty) {

 // draw with software renderer.
 final canvas canvas;
 try {
  final int left = dirty.left;
  final int top = dirty.top;
  final int right = dirty.right;
  final int bottom = dirty.bottom;

  //锁定canvas区域，由dirty区域决定
  canvas = msurface.lockcanvas(dirty);

  // the dirty rectangle can be modified by surface.lockcanvas()
  //noinspection constantconditions
  if (left != dirty.left || top != dirty.top || right != dirty.right
    || bottom != dirty.bottom) {
   attachinfo.mignoredirtystate = true;
  }

  canvas.setdensity(mdensity);
 }

 try {

  if (!canvas.isopaque() || yoff != 0 || xoff != 0) {
   canvas.drawcolor(0, porterduff.mode.clear);
  }

  dirty.setempty();
  misanimating = false;
  attachinfo.mdrawingtime = systemclock.uptimemillis();
  mview.mprivateflags |= view.pflag_drawn;

  try {
   canvas.translate(-xoff, -yoff);
   if (mtranslator != null) {
    mtranslator.translatecanvas(canvas);
   }
   canvas.setscreendensity(scalingrequired ? mnoncompatdensity : 0);
   attachinfo.msetignoredirtystate = false;

   //正式开始绘制
   mview.draw(canvas);

  }
 } 
 return true;
}

可以看书，首先是实例化了canvas对象，然后锁定该canvas的区域，由dirty区域决定，接着对canvas进行一系列的属性赋值，最后调用了mview.draw(canvas)方法，前面分析过，mview就是decorview，也就是说从decorview开始绘制，前面所做的一切工作都是准备工作，而现在则是正式开始绘制流程。

view的绘制

由于viewgroup没有重写draw方法，因此所有的view都是调用view#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;
 }
 ...
}

可以看到，draw过程比较复杂，但是逻辑十分清晰，而官方注释也清楚地说明了每一步的做法。我们首先来看一开始的标记位dirtyopaque，该标记位的作用是判断当前view是否是透明的，如果view是透明的，那么根据下面的逻辑可以看出，将不会执行一些步骤，比如绘制背景、绘制内容等。这样很容易理解，因为一个view既然是透明的，那就没必要绘制它了。接着是绘制流程的六个步骤，这里先小结这六个步骤分别是什么，然后再展开来讲。

绘制流程的六个步骤：
1、对view的背景进行绘制
2、保存当前的图层信息(可跳过)
3、绘制view的内容
4、对view的子view进行绘制(如果有子view)
5、绘制view的褪色的边缘，类似于阴影效果(可跳过)
6、绘制view的装饰（例如：滚动条）
其中第2步和第5步是可以跳过的，我们这里不做分析，我们重点来分析其它步骤。

skip 1:绘制背景

这里调用了view#drawbackground方法，我们看它的源码：

private void drawbackground(canvas canvas) {

 //mbackground是该view的背景参数，比如背景颜色
 final drawable background = mbackground;
 if (background == null) {
  return;
 }

 //根据view四个布局参数来确定背景的边界
 setbackgroundbounds();

 ...

 //获取当前view的mscrollx和mscrolly值
 final int scrollx = mscrollx;
 final int scrolly = mscrolly;
 if ((scrollx | scrolly) == 0) {
  background.draw(canvas);
 } else {
  //如果scrollx和scrolly有值，则对canvas的坐标进行偏移，再绘制背景
  canvas.translate(scrollx, scrolly);
  background.draw(canvas);
  canvas.translate(-scrollx, -scrolly);
 }
}

可以看出，这里考虑到了view的偏移参数,scrollx和scrolly，绘制背景在偏移后的view中绘制。

skip 3:绘制内容

这里调用了view#ondraw方法，view中该方法是一个空实现，因为不同的view有着不同的内容，这需要我们自己去实现，即在自定义view中重写该方法来实现。

skip 4: 绘制子view

如果当前的view是一个viewgroup类型，那么就需要绘制它的子view，这里调用了dispatchdraw，而view中该方法是空实现，实际是viewgroup重写了这个方法，那么我们来看看，viewgroup#dispatchdraw:

protected void dispatchdraw(canvas canvas) {
 boolean usingrendernodeproperties = canvas.isrecordingfor(mrendernode);
 final int childrencount = mchildrencount;
 final view[] children = mchildren;
 int flags = mgroupflags;

 for (int i = 0; i < childrencount; i++) {
  while (transientindex >= 0 && mtransientindices.get(transientindex) == i) {
   final view transientchild = mtransientviews.get(transientindex);
   if ((transientchild.mviewflags & visibility_mask) == visible ||
     transientchild.getanimation() != null) {
    more |= drawchild(canvas, transientchild, drawingtime);
   }
   transientindex++;
   if (transientindex >= transientcount) {
    transientindex = -1;
   }
  }
  int childindex = customorder ? getchilddrawingorder(childrencount, i) : i;
  final view child = (preorderedlist == null)
    ? children[childindex] : preorderedlist.get(childindex);
  if ((child.mviewflags & visibility_mask) == visible || child.getanimation() != null) {
   more |= drawchild(canvas, child, drawingtime);
  }
 }
 //省略...

}

源码很长，这里简单说明一下，里面主要遍历了所以子view，每个子view都调用了drawchild这个方法，我们找到这个方法，viewgroup#drawchild：

protected boolean drawchild(canvas canvas, view child, long drawingtime) {
  return child.draw(canvas, this, drawingtime);
}

可以看出，这里调用了view的draw方法，但这个方法并不是上面所说的，因为参数不同，我们来看看这个方法，view#draw：

boolean draw(canvas canvas, viewgroup parent, long drawingtime) {

 //省略...

 if (!drawingwithdrawingcache) {
  if (drawingwithrendernode) {
   mprivateflags &= ~pflag_dirty_mask;
   ((displaylistcanvas) canvas).drawrendernode(rendernode);
  } else {
   // fast path for layouts with no backgrounds
   if ((mprivateflags & pflag_skip_draw) == pflag_skip_draw) {
    mprivateflags &= ~pflag_dirty_mask;
    dispatchdraw(canvas);
   } else {
    draw(canvas);
   }
  }
 } else if (cache != null) {
  mprivateflags &= ~pflag_dirty_mask;
  if (layertype == layer_type_none) {
   // no layer paint, use temporary paint to draw bitmap
   paint cachepaint = parent.mcachepaint;
   if (cachepaint == null) {
    cachepaint = new paint();
    cachepaint.setdither(false);
    parent.mcachepaint = cachepaint;
   }
   cachepaint.setalpha((int) (alpha * 255));
   canvas.drawbitmap(cache, 0.0f, 0.0f, cachepaint);
  } else {
   // use layer paint to draw the bitmap, merging the two alphas, but also restore
   int layerpaintalpha = mlayerpaint.getalpha();
   mlayerpaint.setalpha((int) (alpha * layerpaintalpha));
   canvas.drawbitmap(cache, 0.0f, 0.0f, mlayerpaint);
   mlayerpaint.setalpha(layerpaintalpha);
  }
 }

}

我们主要来看核心部分，首先判断是否已经有缓存，即之前是否已经绘制过一次了，如果没有，则会调用draw(canvas)方法，开始正常的绘制，即上面所说的六个步骤，否则利用缓存来显示。
这一步也可以归纳为viewgroup绘制过程，它对子view进行了绘制，而子view又会调用自身的draw方法来绘制自身，这样不断遍历子view及子view的不断对自身的绘制，从而使得view树完成绘制。

skip 6 绘制装饰

所谓的绘制装饰，就是指view除了背景、内容、子view的其余部分，例如滚动条等，我们看view#ondrawforeground:

public void ondrawforeground(canvas canvas) {
 ondrawscrollindicators(canvas);
 ondrawscrollbars(canvas);

 final drawable foreground = mforegroundinfo != null ? mforegroundinfo.mdrawable : null;
 if (foreground != null) {
  if (mforegroundinfo.mboundschanged) {
   mforegroundinfo.mboundschanged = false;
   final rect selfbounds = mforegroundinfo.mselfbounds;
   final rect overlaybounds = mforegroundinfo.moverlaybounds;

   if (mforegroundinfo.minsidepadding) {
    selfbounds.set(0, 0, getwidth(), getheight());
   } else {
    selfbounds.set(getpaddingleft(), getpaddingtop(),
      getwidth() - getpaddingright(), getheight() - getpaddingbottom());
   }

   final int ld = getlayoutdirection();
   gravity.apply(mforegroundinfo.mgravity, foreground.getintrinsicwidth(),
     foreground.getintrinsicheight(), selfbounds, overlaybounds, ld);
   foreground.setbounds(overlaybounds);
  }

  foreground.draw(canvas);
 }
}

可以看出，逻辑很清晰，和一般的绘制流程非常相似，都是先设定绘制区域，然后利用canvas进行绘制，这里就不展开详细地说了，有兴趣的可以继续了解下去。

那么，到目前为止，view的绘制流程也讲述完毕了，希望这篇文章对你们起到帮助作用，谢谢你们的阅读。

更多阅读
android view 测量流程(measure)全面解析
android view 布局流程(layout)全面解析

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。