Android视图重绘，使用invalidate还是requestLayout

概述

在我们在进行自定义View的相关开发中，当我们更改了当前View的状态，比如大小，位置等，我们需要重新刷新整个界面，保证显示最新的状态。在Android中，让当前的视图重绘有两种方式，invalidate和requestLayout，今天我们看看这两种方式的原理以及区别。

分析

invalidate的原理

public void invalidate() {
        invalidate(true);
}

最后会调用到invalidateInternal这个方法

 void invalidateInternal(int l, int t, int r, int b, boolean invalidateCache,
             boolean fullInvalidate) {
         if (mGhostView != null) {
             mGhostView.invalidate(true);
             return;
         }

         if (skipInvalidate()) {
             return;
         }

         if ((mPrivateFlags & (PFLAG_DRAWN | PFLAG_HAS_BOUNDS)) == (PFLAG_DRAWN | PFLAG_HAS_BOUNDS)
                 || (invalidateCache && (mPrivateFlags & PFLAG_DRAWING_CACHE_VALID) == PFLAG_DRAWING_CACHE_VALID)
                 || (mPrivateFlags & PFLAG_INVALIDATED) != PFLAG_INVALIDATED
                 || (fullInvalidate && isOpaque() != mLastIsOpaque)) {
             if (fullInvalidate) {
                 mLastIsOpaque = isOpaque();
                 mPrivateFlags &= ~PFLAG_DRAWN;
             }

             mPrivateFlags |= PFLAG_DIRTY;

             if (invalidateCache) {
                 mPrivateFlags |= PFLAG_INVALIDATED;
                 mPrivateFlags &= ~PFLAG_DRAWING_CACHE_VALID;
             }

             // Propagate the damage rectangle to the parent view.
             final AttachInfo ai = mAttachInfo;
             final ViewParent p = mParent;
             if (p != null && ai != null && l < r && t < b) {
                 final Rect damage = ai.mTmpInvalRect;
                 damage.set(l, t, r, b);
                 p.invalidateChild(this, damage);
             }
             .....

我们看到方法的最后调用了ViewParent的invalidateChild方法，因为ViewParent是个接口，invalidateChild是空实现，我们去看看它的实现类ViewRootImpl中的invalidateChild是如何做的

 @Override
    public void invalidateChild(View child, Rect dirty) {
        invalidateChildInParent(null, dirty);
    }

  @Override
     public ViewParent invalidateChildInParent(int[] location, Rect dirty) {
         checkThread();
         if (DEBUG_DRAW) Log.v(TAG, "Invalidate child: " + dirty);

         if (dirty == null) {
             invalidate();
             return null;
         } else if (dirty.isEmpty() && !mIsAnimating) {
             return null;
         }

         if (mCurScrollY !=  || mTranslator != null) {
             mTempRect.set(dirty);
             dirty = mTempRect;
             if (mCurScrollY != ) {
                 dirty.offset(, -mCurScrollY);
             }
             if (mTranslator != null) {
                 mTranslator.translateRectInAppWindowToScreen(dirty);
             }
             if (mAttachInfo.mScalingRequired) {
                 dirty.inset(-, -);
             }
         }

         invalidateRectOnScreen(dirty);

         return null;
     }

又会调用ViewRootImpl中的invalidate方法

void invalidate() {
        mDirty.set(, , mWidth, mHeight);
        if (!mWillDrawSoon) {
            scheduleTraversals();
        }
    }

这里调用了scheduleTraversals重新开始了View的绘制，我们知道View的绘制是从ViewRootImpl的performTraversals方法开始的。我们看看scheduleTraversals是不是触发了performTraversals。

void scheduleTraversals() {
        if (!mTraversalScheduled) {
            mTraversalScheduled = true;
            mTraversalBarrier = mHandler.getLooper().getQueue().postSyncBarrier();
            mChoreographer.postCallback(
                    Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null);
            if (!mUnbufferedInputDispatch) {
                scheduleConsumeBatchedInput();
            }
            notifyRendererOfFramePending();
            pokeDrawLockIfNeeded();
        }
    }

在scheduleTraversals方法中我们发现了一个mTraversalRunnable对象，这个对象就是我们要观察的重点

final class TraversalRunnable implements Runnable {
        @Override
        public void run() {
            doTraversal();
        }
    }
    final TraversalRunnable mTraversalRunnable = new TraversalRunnable();

我们发现这个对象就是一个Runnable对象，我们在scheduleTraversals方法中传入mTraversalRunnable 就会执行run方法，其中又调用了doTraversal这个方法

 void doTraversal() {
        if (mTraversalScheduled) {
            mTraversalScheduled = false;
            mHandler.getLooper().getQueue().removeSyncBarrier(mTraversalBarrier);

            if (mProfile) {
                Debug.startMethodTracing("ViewAncestor");
            }

            performTraversals();

            if (mProfile) {
                Debug.stopMethodTracing();
                mProfile = false;
            }
        }
    }

最后我们发现在doTraversal方法中调用了performTraversals开始了View的重新绘制，这就是invalidate的整个过程。

requestLayout的原理

public void requestLayout() {
        if (mMeasureCache != null) mMeasureCache.clear();

        if (mAttachInfo != null && mAttachInfo.mViewRequestingLayout == null) {
            // Only trigger request-during-layout logic if this is the view requesting it,
            // not the views in its parent hierarchy
            ViewRootImpl viewRoot = getViewRootImpl();
            if (viewRoot != null && viewRoot.isInLayout()) {
                if (!viewRoot.requestLayoutDuringLayout(this)) {
                    return;
                }
            }
            mAttachInfo.mViewRequestingLayout = this;
        }

        mPrivateFlags |= PFLAG_FORCE_LAYOUT;
        mPrivateFlags |= PFLAG_INVALIDATED;

        if (mParent != null && !mParent.isLayoutRequested()) {
            mParent.requestLayout();
        }
        if (mAttachInfo != null && mAttachInfo.mViewRequestingLayout == this) {
            mAttachInfo.mViewRequestingLayout = null;
        }
    }

其中会调用ViewParent的requestLayout方法，同样，我们去看ViewRootImpl中的requestLayout方法。

Override
    public void requestLayout() {
        if (!mHandlingLayoutInLayoutRequest) {
            checkThread();
            mLayoutRequested = true;
            scheduleTraversals();
        }
    }

这里调用了scheduleTraversals，后面的步骤就和上面invalidate时一样了。相对来说，requestLayout的流程还是比较简单的。

区别

既然两种方式都可以完成View的重绘，那么有什么区别呢？ 
使用invalidate重绘当前视图是不会再次执行measure和layout流程的。因为视图没有强制重新测量的标志位，而且大小也没有发生过变化，所以这时只有draw流程可以得到执行。 
如果你希望视图的绘制流程可以完完整整地重新走一遍，就不能使用invalidate()方法，而应该调用requestLayout()了