Draw过程

一、调用流程

1. ViewRootImpl # performTraversals()

performTraversals()调用了performDraw()，三大流程的起点都是performTraversals()。

// 没有取消draw也没有创建新的平面 第一次traversals时newSurface为true
if (!cancelDraw && !newSurface) {
    // ...
    // 开始draw流程
    performDraw();
} else {
    if (isViewVisible) {
        // Try again
        // 如果是可见的, 就再调用一次traversals
        scheduleTraversals();
        // ...
    }
    // ...
}

2. ViewRootImpl # performDraw()

调用到ViewRootImpl的draw()。

private void performDraw() {
    // ...
    // mFullRedrawNeeded表示是否需要完全重绘
    final boolean fullRedrawNeeded = mFullRedrawNeeded;
    mFullRedrawNeeded = false;
    mIsDrawing = true;
    Trace.traceBegin(Trace.TRACE_TAG_VIEW, "draw");
    try {
        // 调用draw()
        draw(fullRedrawNeeded);
    } finally {
        mIsDrawing = false;
        Trace.traceEnd(Trace.TRACE_TAG_VIEW);
    }
    // ...
}

3. ViewRootImpl # draw()

这个方法非常长，主要是去处理绘制区域、坐标等准备工作，之后调用drawSoftware()。

private void draw(boolean fullRedrawNeeded) {
    // ...
    // 获取需要绘制的区域
    final Rect dirty = mDirty;
    // ...
    // 判断是否需要完全绘制
    if (fullRedrawNeeded) {
        mAttachInfo.mIgnoreDirtyState = true;
        // 如果需要就将区域设置为屏幕的所有区域
        dirty.set(0, 0, (int) (mWidth * appScale + 0.5f), (int) (mHeight * appScale + 0.5f));
    }
    // ...
    if (!dirty.isEmpty() || mIsAnimating || accessibilityFocusDirty) {
        if (mAttachInfo.mThreadedRenderer != null && mAttachInfo.mThreadedRenderer.isEnabled()) {
            // ...
        } else {
            // ...
            // 调用drawSoftware()绘制
            if (!drawSoftware(surface, mAttachInfo, xOffset, yOffset, scalingRequired, dirty)) {
                return;
            }
        }
    }
    // ...
}

4. ViewRootImpl # drawSoftware()

• 初始canvas对象
• 调用DecorView的draw()

private boolean drawSoftware(Surface surface, AttachInfo attachInfo, int xoff, int yoff,
        boolean scalingRequired, Rect dirty) {
    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对象
        canvas = mSurface.lockCanvas(dirty);
        
        // 判断lockCanvas有没有改变dirty的顶点值
        if (left != dirty.left || top != dirty.top || right != dirty.right
                || bottom != dirty.bottom) {
            attachInfo.mIgnoreDirtyState = true;
        }
        // 设置画布密度
        canvas.setDensity(mDensity);
    } catch (Surface.OutOfResourcesException e) {
       // ...
    }
    try {
        // ...
        // 先清空画布
        if (!canvas.isOpaque() || yoff != 0 || xoff != 0) {
            canvas.drawColor(0, PorterDuff.Mode.CLEAR);
        }
        dirty.setEmpty();
        mIsAnimating = false;
        mView.mPrivateFlags |= View.PFLAG_DRAWN;
        
        try {
            // 设置画布偏移值
            canvas.translate(-xoff, -yoff);
            if (mTranslator != null) {
                mTranslator.translateCanvas(canvas);
            }
            canvas.setScreenDensity(scalingRequired ? mNoncompatDensity : 0);
            attachInfo.mSetIgnoreDirtyState = false;
            // 调用draw() 从DecorView开始绘制流程
            mView.draw(canvas);
            // ...
        }
        // ...
    } 
    // ...
    return true;
}

5. DecorView # draw()

• 先调用父类的draw()去绘制。
• 如果有菜单背景的drawable的画就画上。

@Override
public void draw(Canvas canvas) {
    super.draw(canvas);
    if (mMenuBackground != null) {
        mMenuBackground.draw(canvas);
    }
}

6. View # draw()

FrameLayout和ViewGroup都没有重写draw()，所以就调用到了View的draw()。View的draw()也很长，但是注释写的分步很清楚。

/*
 * 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)
 */

绘制背景、绘制自身、绘制子View、绘制阴影、绘制其它的装饰。到这里就调用到Draw向子View分发的过程了。下面就仔细的看看这个方法。

二、View的draw()的实现

根据注释可以将draw()分成六个阶段。

• 绘制背景
• 存储图层
• 绘制自身
• 绘制子View
• 绘制阴影并恢复图层
• 绘制滚动条等效果

1. 绘制背景

View # draw()

如果不为透明，就调用drawBackground()去绘制背景。

final boolean dirtyOpaque = (privateFlags & PFLAG_DIRTY_MASK) == PFLAG_DIRTY_OPAQUE &&
        (mAttachInfo == null || !mAttachInfo.mIgnoreDirtyState);

// 判断是否为透明
if (!dirtyOpaque) {
    // 调用drawBackgroud()去绘制背景
    drawBackground(canvas);
}

View # drawBackground()

• 设置背景图片边界
• 判断View是否有移动
  • N：直接绘制背景图片
  • Y：移动到View的偏移位置，绘制背景，再移动回来。

private void drawBackground(Canvas canvas) {
    final Drawable background = mBackground;
    if (background == null) {
        return;
    }
    // 设置背景图片的边界位置
    setBackgroundBounds();
    
    // 硬件加速相关......
    
    final int scrollX = mScrollX;
    final int scrollY = mScrollY;
    // 判断View是否滑动
    if ((scrollX | scrollY) == 0) {
        // 没有滑动就绘制背景图片
        background.draw(canvas);
    } else {
        // 如果移动了，就先移动canvas，绘制背景，canvas再移回
        canvas.translate(scrollX, scrollY);
        background.draw(canvas);
        canvas.translate(-scrollX, -scrollY);
    }
}

View # setBackgroundBounds()

调用drawable的setBounds()设置边界，传参是由layout过程中生成的顶点值组合的，就相当于是View的顶点。

void setBackgroundBounds() {
    if (mBackgroundSizeChanged && mBackground != null) {
        // 设置背景图的四个坐标，这四个值就是View的四个顶点值
        mBackground.setBounds(0, 0, mRight - mLeft, mBottom - mTop);
        mBackgroundSizeChanged = false;
        rebuildOutline();
    }
}

2. 绘制自身

View # draw()

• 如果不需要绘制阴影，就直接进入绘制自身的步骤。
• 如果View不是透明的，就调用onDraw()去绘制自身。

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

View # onDraw()

空实现，没有做统一实现，自定义View时需要自己去实现。

protected void onDraw(Canvas canvas) {
}

3. 绘制子View分发过程

View # draw()

在绘制自己完成后就去分发调用子View的绘制过程。

if (!verticalEdges && !horizontalEdges) {
    // ...
    dispatchDraw(canvas);
    // ...
}

ViewGroup # dispatchDraw()

在View中是空实现，所以来看ViewGroup中的实现。会遍历所有的子View，如果子View可见或是存在动画，就调用drawChld()。

@Override
protected void dispatchDraw(Canvas canvas) {
    boolean usingRenderNodeProperties = canvas.isRecordingFor(mRenderNode);
    final int childrenCount = mChildrenCount;
    final View[] children = mChildren;
    int flags = mGroupFlags;
    // ...
    // 遍历子View
    for (int i = 0; i < childrenCount; i++) {
        // ...
        final int childIndex = getAndVerifyPreorderedIndex(childrenCount, i, customOrder);
        final View child = getAndVerifyPreorderedView(preorderedList, children, childIndex);
        if ((child.mViewFlags & VISIBILITY_MASK) == VISIBLE || child.getAnimation() != null) {
            // 调用drawChild去传递
            more |= drawChild(canvas, child, drawingTime);
        }
    }
    // ...
}

ViewGroup # drawChild()

直接调用了子View的draw()，实现了传递。

protected boolean drawChild(Canvas canvas, View child, long drawingTime) {
    return child.draw(canvas, this, drawingTime);
}

View # draw()

这个draw()有三个参数，和之前分析的一个参数的draw()不同，注释上说得很清楚，这个draw()是ViewGroup.drawChild()调用去绘制子View的。和一个参数最大不同是，这个draw()判断了是绘制缓存内容还是去调用一个参数的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;
                // 如果需要跳过，就直接去调用分发给这个View的子View的方法
                dispatchDraw(canvas);
            } else {
                // 调用普通的draw()
                draw(canvas);
            }
        }
    } else if (cache != null) {
        // 如果使用缓存并且缓存不为空
        mPrivateFlags &= ~PFLAG_DIRTY_MASK;
        if (layerType == LAYER_TYPE_NONE || mLayerPaint == null) {
            // 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();
            if (alpha < 1) {
                mLayerPaint.setAlpha((int) (alpha * layerPaintAlpha));
            }
            // 使用图层的Paint去绘制缓存内容
            canvas.drawBitmap(cache, 0.0f, 0.0f, mLayerPaint);
            if (alpha < 1) {
                mLayerPaint.setAlpha(layerPaintAlpha);
            }
        }
    }
    // ...
}

4. 绘制装饰物

View # draw()

if (!verticalEdges && !horizontalEdges) {
    // ...
    onDrawForeground(canvas);
    // ...
}

View # onDrawForeground()

public void onDrawForeground(Canvas canvas) {
    // 绘制滚动指示器
    onDrawScrollIndicators(canvas);
    // 绘制滚动条
    onDrawScrollBars(canvas);
    final Drawable foreground = mForegroundInfo != null ? mForegroundInfo.mDrawable : null;
    if (foreground != null) {
        // ...
        // 如果有前景图片，就绘制它
        foreground.draw(canvas);
    }
}

5. 如果需要绘制边框阴影

前面那些步骤走完后就能直接return了。如果需要绘制阴影的话，则不会进入前面分析的方法块。而是执行下面的步骤。注释上说这种情况不常见。

View # draw()

• 同样地绘制背景
• 去计算阴影带来的变量影响，对阴影分类去保存图层
• 同样地绘制自身
• 同样地分发绘制流程
• 分类去绘制阴影
• 加载保存的图层
• 同样地绘制装饰

// 共同的步骤，绘制背景图片
if (!dirtyOpaque) {
    drawBackground(canvas);
}
// 不需要绘制阴影的情况
if (!verticalEdges && !horizontalEdges) {
    // ...
    return;
}

// 如果需要绘制阴影

// 根据阴影情况去改变参数......

if (solidColor == 0) {
    final int flags = Canvas.HAS_ALPHA_LAYER_SAVE_FLAG;
    // 保存图层
    if (drawTop) {
        canvas.saveLayer(left, top, right, top + length, null, flags);
    }
    // ...
} else {
    scrollabilityCache.setFadeColor(solidColor);
}
// 绘制自身
if (!dirtyOpaque) onDraw(canvas);
// 绘制子View
dispatchDraw(canvas);
// ...
// 绘制阴影
if (drawTop) {
    matrix.setScale(1, fadeHeight * topFadeStrength);
    matrix.postTranslate(left, top);
    fade.setLocalMatrix(matrix);
    p.setShader(fade);
    canvas.drawRect(left, top, right, top + length, p);
}
// ...
// 取出保存的图层
canvas.restoreToCount(saveCount);
// ...
// 绘制装饰
onDrawForeground(canvas);