理解 View 的绘制流程——View 绘制开始

在自定义 View 的时候一般要重写父类的 onMeasure()、onLayout()、onDraw() 三个方法，来完成视图的展示过程。这三个暴露给开发者重写的方法不过是整个绘制流程的冰山一角，更多复杂的幕后工作，都让系统代劳了。一个完整的绘制流程包括 measure、layout、draw 三个步骤。其中：
measure：测量。系统会先根据 xml 布局文件和代码中对控件属性的设置，来获取或者计算出每个 View 和 ViewGroup 的尺寸，并将这些尺寸保存下来。
layout：布局。根据测量出的结果以及对应的参数，来确定每一个控件应该显示的位置。
draw：绘制。确定好位置后，就将这些控件绘制到屏幕上。

Android 视图层次结构

了解 View 绘制流程，需要先了解一下 Android 视图层次结构以及 DecorView，因为 View 的绘制流程的入口和 DecorView 有着密切的联系。可以通过 Android Studio 的 Layout Inspector 功能查看当前 Activity 的视图层次结构。
如下：

Layout Inspector.png

通过查看具体的视图层次结构，我们可以得到下面的层次关系：

Android 视图层次结构.jpg

其中值得说明的是：
PhoneWindow
PhoneWindow 是 Window 抽象类的唯一实现类。而在 Android 中不管是 Activity、Toast、ActionBar 还是 Dialog，他们的视图都是附加到 Window 上，基本上所有的 View 同时通过 Window 来呈现。因此 Window 可以理解为是 View 的承载者和管理者。Window 有三种类型，分别是应用 Window、子 Window 和系统 Window。应用类 Window 通常对应一个 Acitivity 内；子 Window 不能单独存在，需要依附在特定的父 Window 中，比如常见的一些 Dialog 就是一个子 Window；系统 Window是需要声明权限才能创建的 Window，比如 Toast 和系统状态栏都是系统 Window。
DecorView
DecorView 是 Window 中最顶层的 View。其实 DecorView 是 FrameLayout 的子类，它里面包含了一个LinearLayout、和底部虚拟导航栏相关的 navigationBarBackground。其中当我们在系统设置中比如选择隐藏底部虚拟导航栏，使用手势时，navigationBarBackground 便不会再层次结构中出现。
Content
Content 其实就是应用根布局，即 android.R.id.content。Activity 中的 setContentView 其实就是通过 LayoutInflater 将 XML 布局转换成 View 并添加到 mContentParent中。

所以，我们可以通过 Layout Inspector 查看具体某个 Activity 的布局的层次关系。这里的示例中，DecorView 是整个界面的根视图，在 Activity 中一般为整个屏幕大小。DecorView 下面有 LinearLayout 和 navigationBarBackground。navigationBarBackground 即虚拟导航栏相关。LinearLayout 包含了 action_mode_bar_stub 和一个 FrameLayout。而 FrameLayout 中包含了 action_mode_bar_stub 和 content。 content 即 ContentView 部分，即主要页面部分。具体实例可能不尽相同，但 PhoneWindow、DecorView 和 Content 的层次关系大体都是一致的。

View 绘制的开始

Activity 的启动过程会在 ActivityThread.java 类中完成，在启动 Activity 的过程中，会调用 handleResumeActivity 方法，关于视图的绘制过程最初就是从这个方法开始。

1、handleResumeActivity 方法中的部分代码

// ActivityThread.java 
@Override
public void handleResumeActivity(IBinder token, boolean finalStateRequest, boolean isForward,
        String reason) {
    ...
    if (r.window == null && !a.mFinished && willBeVisible) {
        // r 为 ActivityClientRecord 实例，用来保存 Activity 相关的数据
        // activity.getWindow() 从 Activity 中获取 Window
        // 跟踪代码可以发现此 window 的初试赋值为：
        // mWindow = new PhoneWindow(this, window, activityConfigCallback);
        // 所以这里是拿到了一个 PhoneWindow 实例。
        r.window = r.activity.getWindow();
        // window.getDecorView() 方法从 PhoneWindow 中获取 DecorView 实例。
        View decor = r.window.getDecorView();
        decor.setVisibility(View.INVISIBLE);
        // a.getWindowManager() 从 Activity 中获取 WindowManger 类型的 wm。
        ViewManager wm = a.getWindowManager();
        WindowManager.LayoutParams l = r.window.getAttributes();// l 为 PhoneWindow 的布局参数
        a.mDecor = decor;// 将 Activity 的 mDecor 全局变量赋值为该 decor
        l.type = WindowManager.LayoutParams.TYPE_BASE_APPLICATION;
        l.softInputMode |= forwardBit;
        if (r.mPreserveWindow) {
            a.mWindowAdded = true;
            r.mPreserveWindow = false;
            // Normally the ViewRoot sets up callbacks with the Activity
            // in addView->ViewRootImpl#setView. If we are instead reusing
            // the decor view we have to notify the view root that the
            // callbacks may have changed.
            // 注释说通常使用下方的 addView 方法，然后一直调用到 ViewRootImpl 的 setView 方法的方式
            // 如果采用重用 decor view 的方式的话，就必须通知视图根回调可能已经发生更改
            // 这边可以不用深究，我们需要看的还是通常情况下的方式。
            ViewRootImpl impl = decor.getViewRootImpl();
            if (impl != null) {
                impl.notifyChildRebuilt();
            }
        }
        if (a.mVisibleFromClient) {
            if (!a.mWindowAdded) {
                a.mWindowAdded = true;
                // 添加 View
                // 由上文内容可知，decor 参数表示的是 DecorView 实例，所以它是 Window 的顶级视图
                // 参数 l 表示的是 PhoneWindow 的 LayoutParams 属性
                // 其 width 和 height 值均为 LayoutParams.MATCH_PARENT。
                wm.addView(decor, l);
            } else {
                // The activity will get a callback for this {@link LayoutParams} change
                // earlier. However, at that time the decor will not be set (this is set
                // in this method), so no action will be taken. This call ensures the
                // callback occurs with the decor set.
                a.onWindowAttributesChanged(l);
            }
        }

        // If the window has already been added, but during resume
        // we started another activity, then don't yet make the
        // window visible.
    }
    ...
}

2、WindowManagerImpl 的 addView 方法

// WindowManagerImpl.java
@Override
public void addView(@NonNull View view, @NonNull ViewGroup.LayoutParams params) {
    applyDefaultToken(params);
    // mGlobal 是一个 WindowManagerGlobal 实例
    mGlobal.addView(view, params, mContext.getDisplay(), mParentWindow);
}

WindowManager 也是一个接口类，真正的实现类为 WindowManagerImpl，在它的 addView 方法里调用了 mGlobal 的 addView 方法。

3、WindowManagerGlobal 的 addView 方法

// WindowManagerGlobal.java
public void addView(View view, ViewGroup.LayoutParams params,
        Display display, Window parentWindow) {
    ...        
    ViewRootImpl root;
    View panelParentView = null;

    synchronized (mLock) {
        ...
        // If this is a panel window, then find the window it is being
        // attached to for future reference.
        if (wparams.type >= WindowManager.LayoutParams.FIRST_SUB_WINDOW &&
                wparams.type <= WindowManager.LayoutParams.LAST_SUB_WINDOW) {
            final int count = mViews.size();
            for (int i = 0; i < count; i++) {
                if (mRoots.get(i).mWindow.asBinder() == wparams.token) {
                    panelParentView = mViews.get(i);
                }
            }
        }
        // ViewRootImpl 的实例 root 在此初始化
        root = new ViewRootImpl(view.getContext(), display);

        view.setLayoutParams(wparams);

        mViews.add(view);
        mRoots.add(root);
        mParams.add(wparams);

        // do this last because it fires off messages to start doing things
        try {
            // 调用 ViewRootImpl 的 setView 方法将 DecorView 的实例作为参数传入
            root.setView(view, wparams, panelParentView);
        } catch (RuntimeException e) {
            // BadTokenException or InvalidDisplayException, clean up.
            if (index >= 0) {
                removeViewLocked(index, true);
            }
            throw e;
        }
    }
}

ViewRootImpl 实例 root 在此初始化，并调用 root.setView 方法将 DecorView 作为参数传入。

4、ViewRootImpl 中的 setView 方法
调用了 requestLayout 方法。

5、ViewRootImpl 中的 requestLayout 方法

// ViewRootImpl.java
@Override
public void requestLayout() {
    if (!mHandlingLayoutInLayoutRequest) {
        checkThread();
        mLayoutRequested = true;
        scheduleTraversals();
    }
}

调用了 scheduleTraversals 方法。

6、ViewRootImpl 中的 scheduleTraversals 方法

// ViewRootImpl.java
@UnsupportedAppUsage
void scheduleTraversals() {
    if (!mTraversalScheduled) {
        mTraversalScheduled = true;
        mTraversalBarrier = mHandler.getLooper().getQueue().postSyncBarrier();// 先 post 了同步障碍器消息
        // 可深入查看代码，mChoreographer 的 postCallback 最终也是使用 handler 发送了消息
        // 而 mTraversalRunnable 为 TraversalRunnable 的实例，其实现了 Runnable 接口
        // 从而移步 TraversalRunnable 的 run 方法
        mChoreographer.postCallback(
                Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null);
        if (!mUnbufferedInputDispatch) {
            scheduleConsumeBatchedInput();
        }
        notifyRendererOfFramePending();
        pokeDrawLockIfNeeded();
    }
}

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

利用 Handler post 了一个 TraversalRunnable。而 TraversalRunnable 的 run 方法中调用了 doTraversal 方法。

7、ViewRootImpl 中的 doTraversal 方法

void doTraversal() {
    if (mTraversalScheduled) {
        mTraversalScheduled = false;
        // 移除同步障碍器消息
        mHandler.getLooper().getQueue().removeSyncBarrier(mTraversalBarrier);

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

        // 进入 performTraversals 方法
        performTraversals();

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

调用了 performTraversals 方法。

8、ViewRootImpl 中的 performTraversals 方法

private void performTraversals() {
    ...
    WindowManager.LayoutParams lp = mWindowAttributes;
    ...
    // !!FIXME!! This next section handles the case where we did not get the
    // window size we asked for. We should avoid this by getting a maximum size from
    // the window session beforehand.
    if (mWidth != frame.width() || mHeight != frame.height()) {
        mWidth = frame.width();
        mHeight = frame.height();
    }
    ...
    int childWidthMeasureSpec = getRootMeasureSpec(mWidth, lp.width);
    int childHeightMeasureSpec = getRootMeasureSpec(mHeight, lp.height);
    ...
     // Ask host how big it wants to be
    performMeasure(childWidthMeasureSpec, childHeightMeasureSpec);
    ...
    performLayout(lp, mWidth, mHeight);
    ...
    performDraw();
    ...
}

performTraversals 方法的代码是真的多，不过只是理解 View 的绘制流程的话，抓住关键的这些代码就好了。该方法中依次执行了下面三个方法，先说他们干了什么：
performMeasure：从根节点向下遍历 View 树，完成所有 ViewGroup 和 View 的测量工作，计算出所有 ViewGroup 和 View 显示出来需要的高度和宽度；
performLayout：从根节点向下遍历 View 树，完成所有 ViewGroup 和 View 的布局计算工作，根据测量出来的宽高及自身属性，计算出所有 ViewGroup 和 View 显示在屏幕上的区域；
performDraw：从根节点向下遍历 View 树，完成所有 ViewGroup 和 View 的绘制工作，根据布局过程计算出的显示区域，将所有 View 的当前需显示的内容画到屏幕上。
即，通过 performMeasure 方法开始了 View 的测量过程，performLayout 方法开始了 View 的布局过程，最后通过 performDraw 方法开始 View 的绘制。

由此，我们便可以知道，绘制流程开始的地方，就是这里的 performTraversals 方法。而 View 的绘制主要依次经历了 measure、layout、draw 三个过程。后续将依次详细介绍这三个过程。