本來是要講 activity 的window建立過程，但首先得先了解一些 window 的知識，然後才來介紹會比較好點。

一 . Window 介紹

在我們日常開發中，Window 看似接觸的不多，實際上，Android 中所有的視圖都是通過 Window 來呈現的，不管是 Activity，Dialog、Taost 還是 PupopWindow ，它們的視圖其實都是附加在 Window 上的。

Window 是一個抽象類，它的建立類是 PhoneWindow，它的具體實作類位于 WindowManagerService中；

每個 window 都對應一個 View 和一個 ViewRootImpl， window 和 view 是通過 ViewRootImpl來來建立聯系的，是以 window 并不是實際存在，它是以 view 的形式存在。

這點從 windowmanager 的定義也能看出來，它的三個接口方法，addView，updateView，removeView 都是針對 view 的，這說明 view 才是 window 的實體。

1.1. Window 和 WindowManager

上面說到，建立一個 window 可以通過 WindowManager 來實作，比如簡單添加一個 TextView：

TextView textView = new TextView(this);
        textView.setText("測試");
        WindowManager wm = (WindowManager) getSystemService(Context.WINDOW_SERVICE);
        WindowManager.LayoutParams params = new WindowManager.LayoutParams();
        params.flags = WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL|
                WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE|
                WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED;
        params.type = WindowManager.LayoutParams.TYPE_SYSTEM_ALERT;
        params.format = PixelFormat.TRANSLUCENT;
        params.width = 200;
        params.height = 200;
        params.gravity = Gravity.START|Gravity.TOP;
        wm.addView(textView,params);

上面将一個 textview 放到左上角的位置，并規定大小為 200x200；

其中，params 中，flags 和 type 比較重要。

1.1.1 flags

其中，flags 參數表示 window 的屬性，它有很多屬性，這裡隻簡單介紹幾個，其他請自行檢視官方文檔：

FLAG_NOT_TOUCH_MODAL: 觸摸事件在 window 的區域内，區域外的傳遞給底層的 window。
FLAG_NOT_FOCUSABLE：表示 window 不需要擷取焦點，也不需要接受各種輸入事件，次标記會同時啟用 FLAG_NOT_TOUCH_MODAL ，最終事件會傳遞給下層的具有焦點的 window；這個要特别注意的，如果你需要點選事件，不要使用該标志。
FLAG_SHOW_WHEN_LOCKED：開啟次模式可以讓 Window 顯示在鎖屏的界面上

1.1.1 type

Type 表示 Window 的類型，window 分為3中類型，分别是

應用 window ：比如 activity
子 window：子 window 不能單獨存在，比如 dialog
系統 window ：需要申明權限才能建立的window，比如在service 中，彈出一個dialog，就需要配置 WindowManager.LayoutParams 的 type 為系統級别的；Toast 也是個系統級别的 window。

window 也是分層的，每個window都有一個 z-ordered，層級大的覆寫在層級小的window上面。其中：

應用 window：層級範圍 1-99
子 window ：層級範圍為 1000~1999
系統 window：基層範圍是 2000~2999

如果想要 Window 位于所有 Window 的最頂層，那麼采用較大的層級即可。很顯然，系統的 window 的層級是最大的，一般我們可以使用 TYPE_SYSTEM_OVERLAY 或者其他的，但是要記得權重限：

<uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW"/>
    <uses-permission android:name="android.permission.SYSTEM_OVERLAY_WINDOW" />

不然系統 window 會報錯的。

二、Window 的内部實作

Window 是一個抽象的概念，每一個 Window 都對應一個 View 和一個 ViewRootImpl，Window 和 View 是通過 ViewRootImpl 來建立聯系的，是以 Window 并不存在，而是以 View 的形式存在的。

2.1 Window 的添加過程

在實際使用中，我們無法通路 window，隻能通過 WindowManager，它是window 通路的入口。WindowManager 是一個接口，它的具體實作類是 WindwoManagerImpl 類中，其中添加View addView()、更新View updateViewLayout()、删除View removeView() 的方法如下：

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

    @Override
    public void updateViewLayout(@NonNull View view, @NonNull ViewGroup.LayoutParams params) {
        applyDefaultToken(params);
        mGlobal.updateViewLayout(view, params);
    }

    @Override
    public void removeView(View view) {
        mGlobal.removeView(view, false);
    }

可以看到，windowmanagerlmpl 并沒有直接實作 window 的三大操作，而是交給了 WindowManagerGlobal ：

private final WindowManagerGlobal mGlobal = WindowManagerGlobal.getInstance();

進入mGlobal 的 addview() 檢視:

public void addView(View view, ViewGroup.LayoutParams params,
            Display display, Window parentWindow) {
        if (view == null) {
            throw new IllegalArgumentException("view must not be null");
        }
        if (display == null) {
            throw new IllegalArgumentException("display must not be null");
        }
        if (!(params instanceof WindowManager.LayoutParams)) {
            throw new IllegalArgumentException("Params must be WindowManager.LayoutParams");
        }

        final WindowManager.LayoutParams wparams = (WindowManager.LayoutParams) params;
        if (parentWindow != null) {
            parentWindow.adjustLayoutParamsForSubWindow(wparams);
        }
	....

            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.
                if (index >= 0) {
                    removeViewLocked(index, true);
                }
                throw e;
            }
        }
    }

可以看到，如果是子window ，還需要調整一些參數布局：

final WindowManager.LayoutParams wparams = (WindowManager.LayoutParams) params;
        if (parentWindow != null) {
            parentWindow.adjustLayoutParamsForSubWindow(wparams);
        }

接着最重要的一點是，建立 ViewRootImpl，并将 view 添加到清單中。

Android了解 Window 與 WindowManager一 . Window 介紹二、Window 的内部實作

那麼 mViews 、mRoots 是什麼意思呢？在 WindowManagerGlobal 中，有幾個比較重要的清單，如下：

private final ArrayList<View> mViews = new ArrayList<View>();
    private final ArrayList<ViewRootImpl> mRoots = new ArrayList<ViewRootImpl>();
    private final ArrayList<WindowManager.LayoutParams> mParams =
            new ArrayList<WindowManager.LayoutParams>();
    private final ArraySet<View> mDyingViews = new ArraySet<View>();

其中

mViews 存儲所有 window 所對應的 view
mRoots 存儲的是所有 window 所對應的 ViewRootImpl
mParams 存儲所有 window 對應的布局參數
mDyingViews 則存儲了哪些正在啊被删除的 View 對象。

我們都知道，View 的繪制過程是由 ViewRootImpl 來完成的，這裡也不例外，在 setView() 中，會完成異步繪制的流程，setView 的代碼比較多，它裡面會對參數進行判斷，并可以通過 requestLayout() 方法完成異步重新整理請求：

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

scheduleTraversals 才是 View 的繪制入口，會執行 mChoreographer.postCallback 繪制;

下一次的垂直信号過來的時候，執行 mTraversalRunnable ，它的實作類為 TraversalRunnable ，在 run 方法中執行 doTraversal()

#ViewRootImpl#pokeDrawLockIfNeeded
    void scheduleTraversals() {
        if (!mTraversalScheduled) {
            mTraversalScheduled = true;
            mTraversalBarrier = mHandler.getLooper().getQueue().postSyncBarrier();
            mChoreographer.postCallback(
                    Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null);
         	... 
    }
#ViewRootImpl#TraversalRunnable 
    final class TraversalRunnable implements Runnable {
        @Override
        public void run() {
            doTraversal();
        }
    }
#ViewRootImpl#doTraversal
    void doTraversal() {
        if (mTraversalScheduled) {
            mTraversalScheduled = false;
            mHandler.getLooper().getQueue().removeSyncBarrier(mTraversalBarrier);

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

            performTraversals();

		....
    }

其中 performTraversals 函數比較多，這裡列出它的主要工作好了，具體細節看源碼：

當第一次調用時，執行 dispatchAttachedToWindow -> view.onAttachedToWindow
拿到 window 的參數，通過調用 relayoutWindow -> mWindowSession.relayout()，請求 WindowManaagerService 來計算視窗大小，内容區域大小等。
調用 performMessure -> mView.measure() -> onMeasuse() 遞歸測量 View 的大小
performLayout -> mView.layout -> onLayout ，遞歸執行布局
performDraw -> mView.draw -> onDraw ，遞歸執行繪制

在 setView 執行完 requestLayout()之後，會調用以下代碼：

try {
	   mOrigWindowType = mWindowAttributes.type;
	    mAttachInfo.mRecomputeGlobalAttributes = true;
	    collectViewAttributes();
	    res = mWindowSession.addToDisplay(mWindow, mSeq, mWindowAttributes,
	            getHostVisibility(), mDisplay.getDisplayId(), mTmpFrame,
	            mAttachInfo.mContentInsets, mAttachInfo.mStableInsets,
	            mAttachInfo.mOutsets, mAttachInfo.mDisplayCutout, mInputChannel,
	            mTempInsets);
	    setFrame(mTmpFrame);
	} catch (RemoteException e) {
	    mAdded = false;
	    mView = null;
	    mAttachInfo.mRootView = null;
	    mInputChannel = null;
	    mFallbackEventHandler.setView(null);
	    unscheduleTraversals();
	    setAccessibilityFocus(null, null);
	    throw new RuntimeException("Adding window failed", e);
	} finally {
	    if (restore) {
	        attrs.restore();
	    }
}

可以可以看到，window 的最後顯示，是通過 mWindowSession.addToDisplay() 去實作的，而 mWindowSession 的實作類為 Session ，是典型的Binder機制：

@Override
    public int addToDisplay(IWindow window, int seq, WindowManager.LayoutParams attrs,
            int viewVisibility, int displayId, Rect outFrame, Rect outContentInsets,
            Rect outStableInsets, Rect outOutsets,
            DisplayCutout.ParcelableWrapper outDisplayCutout, InputChannel outInputChannel,
            InsetsState outInsetsState) {
        return mService.addWindow(this, window, seq, attrs, viewVisibility, displayId, outFrame,
                outContentInsets, outStableInsets, outOutsets, outDisplayCutout, outInputChannel,
                outInsetsState);
    }

mService 為 WindowmanagerService，它會調用 addWindow 方法實作 window 的添加。

是以，window 的最終實作，還是在 WindwoManagerService；通過上面的源碼觀察，我們也可以發現，Window 和 View 的關聯是通過 ViewRootImpl 去實作的，而 WindwoManagerService 并不關心具體的 UI 内容，而是關心 Window 的層級，大小等資訊。

2.2 Window 的删除

window 的删除與添加類似，也是通過 WindowManagerGlobal 來實作的，來看看 removeView方法：

@UnsupportedAppUsage
    public void removeView(View view, boolean immediate) {
        if (view == null) {
            throw new IllegalArgumentException("view must not be null");
        }

        synchronized (mLock) {
            int index = findViewLocked(view, true);
            View curView = mRoots.get(index).getView();
            removeViewLocked(index, immediate);
            if (curView == view) {
                return;
            }

            throw new IllegalStateException("Calling with view " + view
                    + " but the ViewAncestor is attached to " + curView);
        }
    }

當 view 不為null，則通過 findViewLocked() 找到下标，然後通過 mRoots 找到目前的 view，并通過 removeViewLocked() 方來實作删除：

private void removeViewLocked(int index, boolean immediate) {
        ViewRootImpl root = mRoots.get(index);
        View view = root.getView();

        if (view != null) {
            InputMethodManager imm = view.getContext().getSystemService(InputMethodManager.class);
            if (imm != null) {
                imm.windowDismissed(mViews.get(index).getWindowToken());
            }
        }
        boolean deferred = root.die(immediate);
        if (view != null) {
            view.assignParent(null);
            if (deferred) {
                mDyingViews.add(view);
            }
        }
    }

它主要做以下幾個動作：

如果能找到view，關閉軟鍵盤
通過 root.die(immediate) 來進行同步删除，或者異步删除，這個後面一起分析
通過 mDyingViews 添加要移除的view

上面說到 root.die(immediate) 删除是同步還是異步的，它的 die() 方法如下：

boolean die(boolean immediate) {
        // Make sure we do execute immediately if we are in the middle of a traversal or the damage
        // done by dispatchDetachedFromWindow will cause havoc on return.
        if (immediate && !mIsInTraversal) {
            doDie();
            return false;
        }

        if (!mIsDrawing) {
            destroyHardwareRenderer();
        } else {
            Log.e(mTag, "Attempting to destroy the window while drawing!\n" +
                    "  window=" + this + ", title=" + mWindowAttributes.getTitle());
        }
        mHandler.sendEmptyMessage(MSG_DIE);
        return true;
    }

可以看到，如果是同步的，直接通過 doDie() 方法去删除，如果是異步的，則通過 mHandler.sendEmptyMessage(MSG_DIE); 發送一個消息，在handleMessage 也是執行 doDIe() 方法；

doDie() 的實作是怎麼樣的呢？如下：

void doDie() {
        checkThread();
        if (LOCAL_LOGV) Log.v(mTag, "DIE in " + this + " of " + mSurface);
        synchronized (this) {
            if (mRemoved) {
                return;
            }
            mRemoved = true;
            if (mAdded) {
                dispatchDetachedFromWindow();
            }

            if (mAdded && !mFirst) {
                destroyHardwareRenderer();

                if (mView != null) {
                    int viewVisibility = mView.getVisibility();
                    boolean viewVisibilityChanged = mViewVisibility != viewVisibility;
                    if (mWindowAttributesChanged || viewVisibilityChanged) {
                        // If layout params have been changed, first give them
                        // to the window manager to make sure it has the correct
                        // animation info.
                        try {
                            if ((relayoutWindow(mWindowAttributes, viewVisibility, false)
                                    & WindowManagerGlobal.RELAYOUT_RES_FIRST_TIME) != 0) {
                                mWindowSession.finishDrawing(mWindow);
                            }
                        } catch (RemoteException e) {
                        }
                    }

                    destroySurface();
                }
            }

            mAdded = false;
        }
        WindowManagerGlobal.getInstance().doRemoveView(this);
    }

如果有被添加，調用dispatchDetachedFromWindow() ，它是實作 view 删除的主要功能：

mView.dispatchDetachedFromWindow(),進而回調 View 的 onDetachedFromWindow() 方法；
删除硬體渲染、清除回調，銷毀 surface
通過 mWindowSession.remove(mWindow)，從 WindowManagerService 删除 window。

然後通過 WindowManagerGlobal.getInstance().doRemoveView(this) 從 mRoots 等删除這個 view 的索引：

void doRemoveView(ViewRootImpl root) {
        synchronized (mLock) {
            final int index = mRoots.indexOf(root);
            if (index >= 0) {
                mRoots.remove(index);
                mParams.remove(index);
                final View view = mViews.remove(index);
                mDyingViews.remove(view);
            }
        }
        if (ThreadedRenderer.sTrimForeground && ThreadedRenderer.isAvailable()) {
            doTrimForeground();
        }
    }

2.3 Window 的更新

Window 的更新也是通過 WindowmanagerGlobal ，來看看updateViewLayout():

public void updateViewLayout(View view, ViewGroup.LayoutParams params) {
        if (view == null) {
            throw new IllegalArgumentException("view must not be null");
        }
        if (!(params instanceof WindowManager.LayoutParams)) {
            throw new IllegalArgumentException("Params must be WindowManager.LayoutParams");
        }

        final WindowManager.LayoutParams wparams = (WindowManager.LayoutParams)params;

        view.setLayoutParams(wparams);

        synchronized (mLock) {
            int index = findViewLocked(view, true);
            ViewRootImpl root = mRoots.get(index);
            mParams.remove(index);
            mParams.add(index, wparams);
            root.setLayoutParams(wparams, false);
        }
    }

首先，會通過 view.setLayoutParams(wparams); 更新 view 的 params ，接着會通過 root.setLayoutParams(wparams, false) 方法，ViewRootImpl 會通過 scheduleTraversals() 重新對 view 進行測量，布局，繪制的工作。

這樣，我們就學習完 window 與 View，ViewRootImpl 等關系了。

參考Android藝術開發探索

Android了解 Window 與 WindowManager一 . Window 介紹二、Window 的内部實作

一 . Window 介紹

1.1. Window 和 WindowManager

1.1.1 flags

1.1.1 type

二、Window 的内部實作

2.1 Window 的添加過程

2.2 Window 的删除

2.3 Window 的更新

繼續閱讀

如何從apk中得到version code

深入了解View知識系列二- View底層工作原理以及View的繪制流程

View 和ViewGroup 的draw流程 View 的draw流程

DecorView與window的建立前言window的建立建立DecorView将DecorView添加至Window

Android 中Handler、Message、Looper機制詳解

Android Handler之更新ui使用分析

Android 應用程式建立與WMS服務之間的通信過程

Android開發之Camera分析(一)

Activity、Window、View、ViewRootImpl的了解

Android中EventBus介紹、使用及源碼分析

Window删除過程分析

最新源碼分析Android windowManager（懸浮視窗）的實作

Android 11 Service啟動流程分析Android 11 Service啟動流程分析

Window的更新過程分析

Window的建立過程分析

LeakCanary源碼解析之檢測篇