Android源码解析

Android应用层View绘制流程之DecorView与ViewRootImpl

Android
阅读次数: 0
本文字数: 2.7k 阅读时长: 13 分钟

概述

一直对Android中View的整个绘制流程不是很了解，View是怎么添加到Activity当中去的？当View中的内容发生改变的时候是怎样执行界面的刷新的？因此，今天准备从源码的角度来对View的整个绘制流程来进行分析，源码基于API25。由于篇幅限制，这篇文章只分析顶层视图DecorView的显示逻辑，具体的View树绘制三部曲:measure,layout,draw将在下篇博文进行深入剖析。

从Activity的setContentView方法说起

我们都知道给Activity设置布局通常就是调用其setContentView方法，这个方法有几个重载的方法，如下所示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public void setContentView(@LayoutRes int layoutResID) {
     getWindow().setContentView(layoutResID);
     initWindowDecorActionBar();
 }

 public void setContentView(View view) {
       getWindow().setContentView(view);
       initWindowDecorActionBar();
   }

public void setContentView(View view, ViewGroup.LayoutParams params) {
       getWindow().setContentView(view, params);
       initWindowDecorActionBar();
}

从上面的三个方法可以看出其均调用了getWindow()的相对应的方法，我们来看getWindow()方法：

1
2
3
public Window getWindow() {
       return mWindow;
   }

可以看出这个方法返回的是一个Window类型的变量mWindow，那么这个mWindow肯定是在Activity某个地方进行初始化,如下所示在attach方法里面进行了初始化：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
final void attach(Context context, ActivityThread aThread,
           Instrumentation instr, IBinder token, int ident,
           Application application, Intent intent, ActivityInfo info,
           CharSequence title, Activity parent, String id,
           NonConfigurationInstances lastNonConfigurationInstances,
           Configuration config, String referrer, IVoiceInteractor voiceInteractor,
           Window window) {
       attachBaseContext(context);

       mFragments.attachHost(null /*parent*/);

       mWindow = new PhoneWindow(this, window);
       mWindow.setWindowControllerCallback(this);
       mWindow.setCallback(this);
       mWindow.setOnWindowDismissedCallback(this);
       mWindow.getLayoutInflater().setPrivateFactory(this);
       ..........
       ..........
   }

mWindow是一个PhoneWindow类型的变量，其实我们通过查看抽象类Window最开始的简介可以知道，PhoneWindow是Window的唯一子类！

1
2
3
4
5
6
7
8
9
10
11
/**
 * Abstract base class for a top-level window look and behavior policy.  An
 * instance of this class should be used as the top-level view added to the
 * window manager. It provides standard UI policies such as a background, title
 * area, default key processing, etc.
 *
 * <p>The only existing implementation of this abstract class is
 * android.view.PhoneWindow, which you should instantiate when needing a
 * Window.
 */
public abstract class Window {

接下来查看PhoneWindow的setContentView方法，跟Activity对应，也有三个重载的方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
 @Override
public void setContentView(int layoutResID) {
    // Note: FEATURE_CONTENT_TRANSITIONS may be set in the process of installing the window
    // decor, when theme attributes and the like are crystalized. Do not check the feature
    // before this happens.
    if (mContentParent == null) {
        installDecor();
    } else if (!hasFeature(FEATURE_CONTENT_TRANSITIONS)) {
        mContentParent.removeAllViews();
    }

    if (hasFeature(FEATURE_CONTENT_TRANSITIONS)) {
        final Scene newScene = Scene.getSceneForLayout(mContentParent, layoutResID,
                getContext());
        transitionTo(newScene);
    } else {
        mLayoutInflater.inflate(layoutResID, mContentParent);
    }
    mContentParent.requestApplyInsets();
    final Callback cb = getCallback();
    if (cb != null && !isDestroyed()) {
        cb.onContentChanged();
    }
    mContentParentExplicitlySet = true;
}

@Override
public void setContentView(View view) {
    setContentView(view, new ViewGroup.LayoutParams(MATCH_PARENT, MATCH_PARENT));
}

@Override
public void setContentView(View view, ViewGroup.LayoutParams params) {
    // Note: FEATURE_CONTENT_TRANSITIONS may be set in the process of installing the window
    // decor, when theme attributes and the like are crystalized. Do not check the feature
    // before this happens.
    if (mContentParent == null) {
        installDecor();
    } else if (!hasFeature(FEATURE_CONTENT_TRANSITIONS)) {
        mContentParent.removeAllViews();
    }

    if (hasFeature(FEATURE_CONTENT_TRANSITIONS)) {
        view.setLayoutParams(params);
        final Scene newScene = new Scene(mContentParent, view);
        transitionTo(newScene);
    } else {
        mContentParent.addView(view, params);
    }
    mContentParent.requestApplyInsets();
    final Callback cb = getCallback();
    if (cb != null && !isDestroyed()) {
        cb.onContentChanged();
    }
    mContentParentExplicitlySet = true;
}

对setContentView(View view,ViewGroup.LayoutParams)方法进行分析：

  • 首先判断mContentParent是否为null，如果为null的话就执行方法installDecor，这个mContentParent是一个ViewGroup类型，这个方法如下所示：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
     private void installDecor() {
            mForceDecorInstall = false;
            if (mDecor == null) {
                mDecor = generateDecor(-1);
                mDecor.setDescendantFocusability(ViewGroup.FOCUS_AFTER_DESCENDANTS);
                mDecor.setIsRootNamespace(true);
                if (!mInvalidatePanelMenuPosted && mInvalidatePanelMenuFeatures != 0) {
                    mDecor.postOnAnimation(mInvalidatePanelMenuRunnable);
                }
            } else {
                mDecor.setWindow(this);
            }
            if (mContentParent == null) {
                mContentParent = generateLayout(mDecor);
            ........
            .......
    }

    generateDecor用于产生mDecor,mDecor是DecorView类型，是整个Activity的顶层视图，DecorView是FrameLayout的子类，有兴趣的可以看看DecorView源码，这里只是给个结论。
    然后是generateLayout方法，这个方法很长，看关键代码：

    1
    2
    3
    4
    5
    6
     ViewGroup contentParent = (ViewGroup)findViewById(ID_ANDROID_CONTENT);
          if (contentParent == null) {
              throw new RuntimeException("Window couldn't find content container view");
          }
    ....
    return contentParent;

从上述代码可以看出，上面讲到的mContentParent是顶层视图mDecor中的一个子View，这个子View的id为：

1
2
3
4
/**
  * The ID that the main layout in the XML layout file should have.
  */
 public static final int ID_ANDROID_CONTENT = com.android.internal.R.id.content;
  • 因此，执行了installDecor方法之后就得到了mDecor和mContentParent，然后是一句很关键的代码，如下所示：
    1
    mContentParent.addView(view, params);

通过这句代码就把我们在Activity当中设置的布局视图加入了mContentParent里面。
** 层次关系为：DecorView > contentParent > Activity中的布局。**
由于mContentParent是ViewGroup类型，查看ViewGroup#addView方法，如下所示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
/**
    * Adds a child view with the specified layout parameters.
    *
    * <p><strong>Note:</strong> do not invoke this method from
    * {@link #draw(android.graphics.Canvas)}, {@link #onDraw(android.graphics.Canvas)},
    * {@link #dispatchDraw(android.graphics.Canvas)} or any related method.</p>
    *
    * @param child the child view to add
    * @param index the position at which to add the child or -1 to add last
    * @param params the layout parameters to set on the child
    */
   public void addView(View child, int index, LayoutParams params) {
       if (DBG) {
           System.out.println(this + " addView");
       }

       if (child == null) {
           throw new IllegalArgumentException("Cannot add a null child view to a ViewGroup");
       }

       // addViewInner() will call child.requestLayout() when setting the new LayoutParams
       // therefore, we call requestLayout() on ourselves before, so that the child's request
       // will be blocked at our level
       requestLayout();
       invalidate(true);
       addViewInner(child, index, params, false);
   }

这个addView方法最后会调用requestLayout()和invalidate()方法，这两个方法会导致整个View树进行重新绘制，这样就把我们在Activity当中自定义的布局文件给显示出来了！

整个过程总结如下：
Activity.setContentView -> PhoneWindow.setContentView ->初始化PhoneWindow中的mDecor和mContentParent -> 把Activity当中的布局视图加入mContentParent -> 导致整个View树进行重新绘制，从而把布局文件显示出来！

DecorView是怎么显示出来的

前面说了DecorView是整个Activity的顶层视图，那么这个DecorView是怎么显示出来了的呢？主要实现过程在ActivityThread的handleResumeActivity方法里面，如下所示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
final void handleResumeActivity(IBinder token,
        boolean clearHide, boolean isForward, boolean reallyResume, int seq, String reason) {
    ActivityClientRecord r = mActivities.get(token);
    if (!checkAndUpdateLifecycleSeq(seq, r, "resumeActivity")) {
        return;
    }

    // If we are getting ready to gc after going to the background, well
    // we are back active so skip it.
    unscheduleGcIdler();
    mSomeActivitiesChanged = true;

    // TODO Push resumeArgs into the activity for consideration
    r = performResumeActivity(token, clearHide, reason);

    if (r != null) {
        final Activity a = r.activity;

        if (localLOGV) Slog.v(
            TAG, "Resume " + r + " started activity: " +
            a.mStartedActivity + ", hideForNow: " + r.hideForNow
            + ", finished: " + a.mFinished);

        final int forwardBit = isForward ?
                WindowManager.LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION : 0;

        // If the window hasn't yet been added to the window manager,
        // and this guy didn't finish itself or start another activity,
        // then go ahead and add the window.
        boolean willBeVisible = !a.mStartedActivity;
        if (!willBeVisible) {
            try {
                willBeVisible = ActivityManagerNative.getDefault().willActivityBeVisible(
                        a.getActivityToken());
            } catch (RemoteException e) {
                throw e.rethrowFromSystemServer();
            }
        }
        if (r.window == null && !a.mFinished && willBeVisible) {
            r.window = r.activity.getWindow();
            View decor = r.window.getDecorView();
            decor.setVisibility(View.INVISIBLE);
            ViewManager wm = a.getWindowManager();
            WindowManager.LayoutParams l = r.window.getAttributes();
            a.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.
                ViewRootImpl impl = decor.getViewRootImpl();
                if (impl != null) {
                    impl.notifyChildRebuilt();
                }
            }
            if (a.mVisibleFromClient && !a.mWindowAdded) {
                a.mWindowAdded = true;
                wm.addView(decor, l);
            }

        ................................
    }
}

如上述方法所示，首先从ActivityThread保存的mActivities列表里面得到一个ActivityClientRecord对象，这个对象保存了Activity的一些信息。

  • 得到Activity之后调用View decor = r.window.getDecorView();方法得到顶层视图DecorView，这个视图前面说过是保存在PhoneWindow里面，也就是一个Activity对应一个 PhoneWindow，从而对应一个DecorView。
  • 然后是调用ViewManager wm = a.getWindowManager();方法得到Activity当中的WindowManager对象，那为什么返回的是ViewManager对象呢？查看WindowManager接口，如下所示，发现WindowManager是继承自ViewManager接口的。
1
public interface WindowManager extends ViewManager {

ViewManager接口如下所示，从注释可以看出这个接口主要是用来往Activity当中添加或者移除View。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/** Interface to let you add and remove child views to an Activity. To get an instance
  * of this class, call {@link android.content.Context#getSystemService(java.lang.String) Context.getSystemService()}.
  */
public interface ViewManager
{
    /**
     * Assign the passed LayoutParams to the passed View and add the view to the window.
     * <p>Throws {@link android.view.WindowManager.BadTokenException} for certain programming
     * errors, such as adding a second view to a window without removing the first view.
     * <p>Throws {@link android.view.WindowManager.InvalidDisplayException} if the window is on a
     * secondary {@link Display} and the specified display can't be found
     * (see {@link android.app.Presentation}).
     * @param view The view to be added to this window.
     * @param params The LayoutParams to assign to view.
     */
    public void addView(View view, ViewGroup.LayoutParams params);
    public void updateViewLayout(View view, ViewGroup.LayoutParams params);
    public void removeView(View view);
}
  • 得到Activity当中的WindowManager之后，调用wm.addView(decor, l);方法，就把DecorView加入了WindowManager。我们知道WindowManager只是一个接口，具体的实现类是WindowManagerImpl,看下其addView方法：
1
2
3
4
5
@Override
   public void addView(@NonNull View view, @NonNull ViewGroup.LayoutParams params) {
       applyDefaultToken(params);
       mGlobal.addView(view, params, mContext.getDisplay(), mParentWindow);
   }

发现这个addView方法其实是调用了成员变量mGlobal的addVeiw方法，mGlobal是WindowManagerGlobal类型，我们来看下其addView方法，如下所示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
public void addView(View view, ViewGroup.LayoutParams params,
           Display display, Window parentWindow) {
       ........................
       ViewRootImpl root;
       View panelParentView = null;

      .........................
           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 {
           root.setView(view, wparams, panelParentView);
       } catch (RuntimeException e) {
           // BadTokenException or InvalidDisplayException, clean up.
           synchronized (mLock) {
               final int index = findViewLocked(view, false);
               if (index >= 0) {
                   removeViewLocked(index, true);
               }
           }
           throw e;
       }
   }

通过上述代码可以发现顶层视图DecorView最终被加入到了ViewRootImpl里面，且应该是在其setView方法里面执行了某些操作，导致DecorView被显示出来。这个方法比较长，大家可以自行查看，在里面有一句关键的代码：

1
2
3
4
// Schedule the first layout -before- adding to the window
// manager, to make sure we do the relayout before receiving
// any other events from the system.
requestLayout();

requestLayout方法如下：

1
2
3
4
5
6
7
8
@Override
public void requestLayout() {
    if (!mHandlingLayoutInLayoutRequest) {
        checkThread();
        mLayoutRequested = true;
        scheduleTraversals();
    }
}

在这个方法当中调用了scheduleTraversals方法，如下所示：

1
2
3
4
5
6
7
8
9
10
11
12
13
void scheduleTraversals() {
       if (!mTraversalScheduled) {
           mTraversalScheduled = true;
           mTraversalBarrier = mHandler.getLooper().getQueue().postSyncBarrier();
           mChoreographer.postCallback(
                   Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null);
           if (!mUnbufferedInputDispatch) {
               scheduleConsumeBatchedInput();
           }
           notifyRendererOfFramePending();
           pokeDrawLockIfNeeded();
       }
   }

在这个方法当中把mTraversalRunnable给post到了消息队列里面，来看看这个Runnable里面执行了什么操作：

1
2
3
4
5
6
7
final class TraversalRunnable implements Runnable {
       @Override
       public void run() {
           doTraversal();
       }
   }
   final TraversalRunnable mTraversalRunnable = new TraversalRunnable();

从上面可以看出在TraversalRunnable里面执行了doTraversal方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
void doTraversal() {
       if (mTraversalScheduled) {
           mTraversalScheduled = false;
           mHandler.getLooper().getQueue().removeSyncBarrier(mTraversalBarrier);

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

           performTraversals();

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

在这个方法当中又执行了performTraversals方法，这个方法最终负责整个View树的绘制流程，因此这个方法比较关键。这个方法比较长，其负责绘制的View树的核心语句如下，其中mView就是顶层视图DecorView。

1
2
3
4
5
6
7
8
9
10
11
12
private void performTraversals() {
        ......
        int childWidthMeasureSpec = getRootMeasureSpec(mWidth, lp.width);
        int childHeightMeasureSpec = getRootMeasureSpec(mHeight, lp.height);
        ......
        mView.measure(childWidthMeasureSpec, childHeightMeasureSpec);
        ......
        mView.layout(0, 0, mView.getMeasuredWidth(), mView.getMeasuredHeight());
        ......
        mView.draw(canvas);
        ......
    }

上面对顶层视图DecorView的显示机制进行了深入剖析，通过一层层分析，最终得出ViewRootImpl负责整个View树的绘制。measure,layout,draw是View树绘制三个主要流程，只有理解了这三个基本流程的原理，在自定义View的时候才能做到游刃有余（当然还有View事件分发机制也很关键）！关于这三个流程的具体细节剖析将在下一篇博客中进行讲解。感谢大家的阅读！