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

    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();}
    }

//获取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 (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);
}

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

        if (!drawSoftware(surface, mAttachInfo, xOffset, yOffset, scalingRequired, dirty)) {
            return;}
    }
}

if (animating) {
    mFullRedrawNeeded = true;scheduleTraversals();
}

/**
 * @return true if drawing was successful, false if an error occurred
 * 如果绘图成功则为true，如果出现错误，则为false
 */
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;}

        // 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;  //正式开始绘制
            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;
}