Android Window 启动过程

不管是 Activity 还是 Dialog 都有一个 window 对象，对应的 view 属于 window，用户对于界面最直接的感知就是 window，理解和掌握 window 的启动过程对于开发者而言尤为重要，以下主要分析 Activity 的 window 启动过程。

注，以下代码都是基于 api=26。

我们从 Activity.attach 方法开始讲，在这个方法里，完成 window 实例的创建。（该方法在什么时候调用的，在这里不分析，有兴趣的朋友可以看另一篇文章: https://www.jianshu.com/p/7a904184afc6）

final void attach(Context context, ActivityThread aThread,... {
...
    mWindow = new PhoneWindow(this, window, activityConfigCallback);
    mWindow.setWindowControllerCallback(this);
    mWindow.setCallback(this);
    mWindow.setOnWindowDismissedCallback(this);
    mWindow.getLayoutInflater().setPrivateFactory(this);
    if (info.softInputMode != WindowManager.LayoutParams.SOFT_INPUT_STATE_UNSPECIFIED) {
        mWindow.setSoftInputMode(info.softInputMode);
    }
    if (info.uiOptions != 0) {
        mWindow.setUiOptions(info.uiOptions);
    }
...
    mWindow.setWindowManager(
    (WindowManager)context.getSystemService(Context.WINDOW_SERVICE),
    mToken, mComponent.flattenToString(),
    (info.flags & ActivityInfo.FLAG_HARDWARE_ACCELERATED) != 0);
    if (mParent != null) {
        mWindow.setContainer(mParent.getWindow());
    }
    mWindowManager = mWindow.getWindowManager();
...
}

我们可以看到 window 的实例其实就是 PhoneWindow，还有一点值得注意的是 mWindowManager 的赋值，这里的 context 实际是 ContextImpl，通过 context.getSystemService(Context.WINDOW_SERVICE) 获取到的实际是 WindowManagerImpl，是 app 进程的一个实例，不属于系统进程，我们可以随便看一下该类的方法

WindowManagerImpl
    @Override
    public void addView(@NonNull View view, @NonNull ViewGroup.LayoutParams params) {
        applyDefaultToken(params);
        mGlobal.addView(view, params, mContext.getDisplay(), mParentWindow);
    }

WindowManagerImpl 只是一个代理类，实际操作都是由 WindowManagerGlobal 来完成，后续所有 window 相关操作都与这个类有关，我们先继续往下走。

Activity.attch 我们直接跳到 Activity.setContentView 方法

    // Activity.java
    public void setContentView(@LayoutRes int layoutResID) {
        getWindow().setContentView(layoutResID);
        initWindowDecorActionBar();
    }

Activity.setContentView 直接调用的是 window 的方法

// PhoneWindow
public void setContentView(int layoutResID) {
...
installDecor();
...
mLayoutInflater.inflate(layoutResID, mContentParent);
...
}

installDecor() 方法主要完成 DecorView 的创建、为 DecorView 添加 ContentView、设置背景、从style中提取对应的属性...

// PhoneWindow
private void installDecor() {
...
    mDecor = generateDecor(-1);
...
}

protected ViewGroup generateLayout(DecorView decor) {
...
    mDecor.onResourcesLoaded(mLayoutInflater, layoutResource); // 在这里添加的 layout
...
}

// DecorView
void onResourcesLoaded(LayoutInflater inflater, int layoutResource) {
...
    final View root = inflater.inflate(layoutResource, null);
    if (mDecorCaptionView != null) {
        if (mDecorCaptionView.getParent() == null) {
            addView(mDecorCaptionView,
                    new ViewGroup.LayoutParams(MATCH_PARENT, MATCH_PARENT));
        }
        mDecorCaptionView.addView(root,
                new ViewGroup.MarginLayoutParams(MATCH_PARENT, MATCH_PARENT));
    } else {

        // Put it below the color views.
        addView(root, 0, new ViewGroup.LayoutParams(MATCH_PARENT, MATCH_PARENT));
    }
...
}

这里我们看到代码中多次使用 LayoutInflater.inflate 和 ViewGroup.addView 方法，前者最终也是调用 ViewGroup.addView，我们来看一下 ViewGroup.addView 方法主要干了些什么

// ViewGroup
public void addView(View child, int index, LayoutParams params) {
...
    requestLayout(); // 核心方法
    invalidate(true);
    addViewInner(child, index, params, false); // 完成添加 view 到数据结构等操作...
...
}

主要看下 ViewGroup.requestLayout

// ViewGroup
public void requestLayout() {
...
    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;
    }
...
}

可以看出 requestLayout 操作机制是逐步往上级请求，直到能受理该操作的实例，只有 DecorView 才有 ViewRootImpl，所以实际上最终是有 ViewRootImpl 来完成 requestLayout操作的，但是这里需要注意此时的 DecorView mAttachInfo 和 mParent 都等于 null，所以实际上没有进行任何操作。

下一个与 Window 相关的逻辑在 ActivityThread.handleResumeActivity，注意此时已经跑过了 Activity.onCreate

// ActivityThread
final void handleResumeActivity(IBinder token,
        boolean clearHide, boolean isForward, boolean reallyResume, int seq, String reason) {
...
r = performResumeActivity(token, clearHide, reason);  // 这句话会回调 Activity.onResume
...
                        a.mWindowAdded = true;
                        wm.addView(decor, l);
...
}

wm 即是 WindowManagerImpl，上文已经说过了 WindowManagerImpl 操作都交由 WindowManagerGlobal，所以我们直接看 WindowManagerGlobal.addView

// WindowManagerGlobal
public void addView(View view, ViewGroup.LayoutParams params,
        Display display, Window parentWindow) {
...
            root = new ViewRootImpl(view.getContext(), display); // 创建 ViewRootImpl 实例，每个 window 只有一个 ViewRootImpl
            view.setLayoutParams(wparams);

            // 将 view 添加到对应的集合中，记录
            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.
                if (index >= 0) {
                    removeViewLocked(index, true);
                }
                throw e;
            }
...
}

ViewRootImpl 构造方法也值得一看

public ViewRootImpl(Context context, Display display) {
...
mWindowSession = WindowManagerGlobal.getWindowSession(); // 获取的是系统进程的远程对象，通过它与 WindowManagerService 连接
...
mAttachInfo = new View.AttachInfo(mWindowSession, mWindow, display, this, mHandler, this,
                context);
...
}

WindowManagerGlobal.addView 主要完成了 ViewRootImpl 创建，DecorView 与 ViewRootImpl 建立关系是在 ViewRootImpl.setView 方法中完成

// ViewRootImpl
public void setView(View view, WindowManager.LayoutParams attrs, View panelParentView) {
...
    requestLayout();
...
            // 通过 mWindowSession 对象最终会调用 WindowManagerService.addView
            res = mWindowSession.addToDisplay(mWindow, mSeq, mWindowAttributes,
                    getHostVisibility(), mDisplay.getDisplayId(),
                    mAttachInfo.mContentInsets, mAttachInfo.mStableInsets,
                    mAttachInfo.mOutsets, mInputChannel);
...
    view.assignParent(this); // 将 DecorView mParent = this
}

我们先看下 ViewRootImpl.requestLayout()

// ViewRootImpl
    public void requestLayout() {
        if (!mHandlingLayoutInLayoutRequest) {
            checkThread();
            mLayoutRequested = true;
            // 最终会启动 TraversalRunnable -> run -> doTraversal() - >performTraversals()
            scheduleTraversals(); 
        }
    }

private void performTraversals() {
...
    if (mFirst) {
        ...
        // 通过 ViewGroup.dispatchAttachedToWindow 最终响应每个子 View 的 dispatchAttachedToWindow 方法，响应每个监听 listener.onViewAttachedToWindow
        host.dispatchAttachedToWindow(mAttachInfo, 0);
        ...
    }
...
}

我们可以看到在 performTraversals 方法中触发 dispatchAttachedToWindow 事件，到这一步已经完成了 window 的添加。

总结

一个 window 对应一个 ViewRootImpl，一个 ViewRootImpl 对应 一个 DecorView，与 wms 发生关联操作是由 ViewRootImpl 完成的，requestLayout 是由 ViewRootImpl 完成，dispatchAttachedToWindow 也是由 ViewRootImpl 触发，依次往下走，用 Context 获取的 WindowManager 调用 addView 并不是直接调用 wms.addView 方法，而是存在于 app 进程的 WindowMnagerGlobal.addView()方法。