[Android FrameWork 6.0源码学习] View的重绘过程之Draw _Framework

登山则情满于山，观海则意溢于海。这篇文章主要讲述[Android FrameWork 6.0源码学习] View的重绘过程之Draw相关的知识，希望能为你提供帮助。
View绘制的三部曲，测量，布局，绘画
现在我们分析绘画部分
测量和布局在前两篇文章中已经分析过了。不了解的可以去我的博客里找一下

下面进入正题，开始分析调用以及函数原理

private void performDraw() { if (mAttachInfo.mDisplayState == Display.STATE_OFF & & !mReportNextDraw) { return; }final boolean fullRedrawNeeded = mFullRedrawNeeded; mFullRedrawNeeded = false; mIsDrawing = true; Trace.traceBegin(Trace.TRACE_TAG_VIEW, "draw"); try { //调用内部实现方法，来实现分发绘画的工作 draw(fullRedrawNeeded); } finally { mIsDrawing = false; Trace.traceEnd(Trace.TRACE_TAG_VIEW); }//... }

这个函数调用内部draw方法去处理绘画前的工作,来继续完成绘制工作

private void draw(boolean fullRedrawNeeded) { Surface surface = mSurface; if (!surface.isValid()) { return; }if (DEBUG_FPS) { trackFPS(); } //出发绘制监听 if (!sFirstDrawComplete) { synchronized (sFirstDrawHandlers) { sFirstDrawComplete = true; final int count = sFirstDrawHandlers.size(); for (int i = 0; i< count; i++) { mHandler.post(sFirstDrawHandlers.get(i)); } } } //当界面需要滚动的时候，这个方法会触发Scroller类下的startScroll函数 scrollToRectOrFocus(null, false); //如果界面发生了滚动，就分发滚动监听 if (mAttachInfo.mViewScrollChanged) { mAttachInfo.mViewScrollChanged = false; mAttachInfo.mTreeObserver.dispatchOnScrollChanged(); }boolean animating = mScroller != null & & mScroller.computeScrollOffset(); final int curScrollY; if (animating) { curScrollY = mScroller.getCurrY(); } else { curScrollY = mScrollY; } if (mCurScrollY != curScrollY) { mCurScrollY = curScrollY; fullRedrawNeeded = true; if (mView instanceof RootViewSurfaceTaker) { ((RootViewSurfaceTaker) mView).onRootViewScrollYChanged(mCurScrollY); } }final float appScale = mAttachInfo.mApplicationScale; final boolean scalingRequired = mAttachInfo.mScalingRequired; int resizeAlpha = 0; if (mResizeBuffer != null) { long deltaTime = SystemClock.uptimeMillis() - mResizeBufferStartTime; if (deltaTime < mResizeBufferDuration) { float amt = deltaTime/(float) mResizeBufferDuration; amt = mResizeInterpolator.getInterpolation(amt); animating = true; resizeAlpha = 255 - (int)(amt*255); } else { disposeResizeBuffer(); } }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; }if (fullRedrawNeeded) { mAttachInfo.mIgnoreDirtyState = true; dirty.set(0, 0, (int) (mWidth * appScale + 0.5f), (int) (mHeight * appScale + 0.5f)); }if (DEBUG_ORIENTATION || DEBUG_DRAW) { Log.v(TAG, "Draw " + mView + "/" + mWindowAttributes.getTitle() + ": dirty={" + dirty.left + "," + dirty.top + "," + dirty.right + "," + dirty.bottom + "} surface=" + surface + " surface.isValid()=" + surface.isValid() + ", appScale:" + appScale + ", width=" + mWidth + ", height=" + mHeight); } //如果有注册TreeObserver下的监听，在调用onDraw之前会触发 mAttachInfo.mTreeObserver.dispatchOnDraw(); int xOffset = 0; int yOffset = curScrollY; final WindowManager.LayoutParams params = mWindowAttributes; final Rect surfaceInsets = params != null ? params.surfaceInsets : null; if (surfaceInsets != null) { xOffset -= surfaceInsets.left; yOffset -= surfaceInsets.top; // Offset dirty rect for surface insets. dirty.offset(surfaceInsets.left, surfaceInsets.right); }boolean accessibilityFocusDirty = false; final Drawable drawable = mAttachInfo.mAccessibilityFocusDrawable; if (drawable != null) { final Rect bounds = mAttachInfo.mTmpInvalRect; final boolean hasFocus = getAccessibilityFocusedRect(bounds); if (!hasFocus) { bounds.setEmpty(); } if (!bounds.equals(drawable.getBounds())) { accessibilityFocusDirty = true; } }mAttachInfo.mDrawingTime = mChoreographer.getFrameTimeNanos() / TimeUtils.NANOS_PER_MS; if (!dirty.isEmpty() || mIsAnimating || accessibilityFocusDirty) { if (mAttachInfo.mHardwareRenderer != null & & mAttachInfo.mHardwareRenderer.isEnabled()) { // If accessibility focus moved, always invalidate the root. boolean invalidateRoot = accessibilityFocusDirty; // Draw with hardware renderer. mIsAnimating = false; if (mHardwareYOffset != yOffset || mHardwareXOffset != xOffset) { mHardwareYOffset = yOffset; mHardwareXOffset = xOffset; invalidateRoot = true; } mResizeAlpha = resizeAlpha; if (invalidateRoot) { mAttachInfo.mHardwareRenderer.invalidateRoot(); }dirty.setEmpty(); mBlockResizeBuffer = false; mAttachInfo.mHardwareRenderer.draw(mView, mAttachInfo, this); } else { // If we get here with a disabled & requested hardware renderer, something went // wrong (an invalidate posted right before we destroyed the hardware surface // for instance) so we should just bail out. Locking the surface with software // rendering at this point would lock it forever and prevent hardware renderer // from doing its job when it comes back. // Before we request a new frame we must however attempt to reinitiliaze the // hardware renderer if it‘s in requested state. This would happen after an // eglTerminate() for instance. if (mAttachInfo.mHardwareRenderer != null & & !mAttachInfo.mHardwareRenderer.isEnabled() & & mAttachInfo.mHardwareRenderer.isRequested()) {try { mAttachInfo.mHardwareRenderer.initializeIfNeeded( mWidth, mHeight, mAttachInfo, mSurface, surfaceInsets); } catch (OutOfResourcesException e) { handleOutOfResourcesException(e); return; }mFullRedrawNeeded = true; scheduleTraversals(); return; }//在这个drawSOftWare方法中会调用view的draw方法，之后整个绘画流程就跑起来了 if (!drawSoftware(surface, mAttachInfo, xOffset, yOffset, scalingRequired, dirty)) { return; } } }if (animating) { mFullRedrawNeeded = true; scheduleTraversals(); } }

这个函数在调用view的draw之前做了很多处理，大概总结一下就是view的滚动设置和硬件加速功能绘画还有一些比较深入的属性比如插图之类，这些我们不怎么关心
我们最关心的是 drawSoftWare 方法

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; //获取一块画布，这块画布会传递到各个onDraw方法中 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; }// TODO: Do this in native canvas.setDensity(mDensity); } catch (Surface.OutOfResourcesException e) { handleOutOfResourcesException(e); return false; } catch (IllegalArgumentException e) { Log.e(TAG, "Could not lock surface", e); // Don‘t assume this is due to out of memory, it could be // something else, and if it is something else then we could // kill stuff (or ourself) for no reason. mLayoutRequested = true; // ask wm for a new surface next time. return false; }try { if (DEBUG_ORIENTATION || DEBUG_DRAW) { Log.v(TAG, "Surface " + surface + " drawing to bitmap w=" + canvas.getWidth() + ", h=" + canvas.getHeight()); //canvas.drawARGB(255, 255, 0, 0); }// If this bitmap‘s format includes an alpha channel, we // need to clear it before drawing so that the child will // properly re-composite its drawing on a transparent // background. This automatically respects the clip/dirty region // or // If we are applying an offset, we need to clear the area // where the offset doesn‘t appear to avoid having garbage // left in the blank areas. if (!canvas.isOpaque() || yoff != 0 || xoff != 0) { canvas.drawColor(0, PorterDuff.Mode.CLEAR); }dirty.setEmpty(); mIsAnimating = false; mView.mPrivateFlags |= View.PFLAG_DRAWN; if (DEBUG_DRAW) { Context cxt = mView.getContext(); Log.i(TAG, "Drawing: package:" + cxt.getPackageName() + ", metrics=" + cxt.getResources().getDisplayMetrics() + ", compatibilityInfo=" + cxt.getResources().getCompatibilityInfo()); } try { canvas.translate(-xoff, -yoff); if (mTranslator != null) { mTranslator.translateCanvas(canvas); } canvas.setScreenDensity(scalingRequired ? mNoncompatDensity : 0); attachInfo.mSetIgnoreDirtyState = false; //从这开始触发整个view树的绘制 mView.draw(canvas); drawAccessibilityFocusedDrawableIfNeeded(canvas); } finally { if (!attachInfo.mSetIgnoreDirtyState) { // Only clear the flag if it was not set during the mView.draw() call attachInfo.mIgnoreDirtyState = false; } } } finally { try { surface.unlockCanvasAndPost(canvas); } catch (IllegalArgumentException e) { Log.e(TAG, "Could not unlock surface", e); mLayoutRequested = true; // ask wm for a new surface next time. //noinspection ReturnInsideFinallyBlock return false; }if (LOCAL_LOGV) { Log.v(TAG, "Surface " + surface + " unlockCanvasAndPost"); } } return true; }

这个方法的作用就是先从系统的Surface中获取一块画布，设置好画布的属性后传递到DecorView的draw方法中，从而激活整个view的绘画流程

@CallSuper 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) *///第一步，绘制背景 //在第一步中，在drawBackground中会根据不同类型的背景，去调用不同类型下的draw方法 //比如，背景是一个BitmapDrawable，那么就会调用BitmapDrawable的draw方法，这些都是用Drawable这个抽象类编写的 //每种不同的背景都是集成自Drawable,这也就是面向抽象/面向接口编程的好处，可以处理很多种情况 int saveCount; if (!dirtyOpaque) { drawBackground(canvas); }// Fading Edge是View很神奇的一个效果，大家可以自己尝试一下 final int viewFlags = mViewFlags; boolean horizontalEdges = (viewFlags & FADING_EDGE_HORIZONTAL) != 0; boolean verticalEdges = (viewFlags & FADING_EDGE_VERTICAL) != 0; if (!verticalEdges & & !horizontalEdges) { // 绘制自身，调用自身的onDraw方法 if (!dirtyOpaque) onDraw(canvas); // 调用ViewGroup的dispatchDraw方法，让ViewGroup遍历并调用所有的onDraw方法，整个view绘画流程被激活 dispatchDraw(canvas); // 如果设置了 Overlay ，就调用并绘制 Overlay if (mOverlay != null & & !mOverlay.isEmpty()) { mOverlay.getOverlayView().dispatchDraw(canvas); }// 绘制前景图 onDrawForeground(canvas); // we‘re done... return; }/* *后边是对于Fading Edge效果的设置，这次就不再分析了，有兴趣的朋友可以自己看一下这个效果 * */ }

剩下的流程就是view树中各个子view自己的绘制流程了，然后ViewRootImpl在拿着绘制好的画布
View的三部曲到此就分析完了，分析的不是那么细致，但是最少大体流程还是抛出来了。
【[Android FrameWork 6.0源码学习] View的重绘过程之Draw】在那遥远的ViewRootImpl中定义了一个叫做performTraversals函数，这个函数负责屏幕的显示工作
首先是由PhoneWindow来制作一个DecorView出来，在由WindowManager创建所对应的ViewRootImpl出来，然后调用ViewRootImpl下的setView函数
setView函数会触发requestLayout函数，这个函数会触发performTraversals函数，最终我们view的onMeasure onLayout onDraw都会被调用，从而完成了整个view的重绘过程

当屏幕上的任何一个地方发生变化。都是调用performTraversals来完成了。比如：钟表的分钟发生改变等等....有兴趣的朋友最好是自己在研读一遍源码，能学到很多有意思的功能