Android之Window與WindowManager

 Window表示一個視窗的概念，在日常開發中直接接觸Window的機會並不多，但卻會經常用到Window，activity、toast、dialog、PopupWindow、狀態列等都是Window。在Android中Window是個抽象類，並且僅有一個實現類PhoneWindow。

1、Window

 Android中，Window有應用Window、子Window及系統Window三種型別，分別對應不同的層級範圍，層級越高，顯示越靠前，這裡的“靠前”是指層級大的Window會覆蓋在層級小的Window上面。

• 應用Window：對應層級範圍是1~99，每個activity就對應一個應用Window，如果在activity中建立了一個應用Window，那麼當跳轉到另外一個Activity時，該Window會被覆蓋。應用Window的高度不受狀態列影響。
• 子Window：對應層級範圍是1000~1999，PopupWindow預設就是一個子Window（可以修改PopupWindow的Window型別），如果在activity中建立了一個子Window，那麼當跳轉到另外一個Activity時，該Window也會被覆蓋。子Window的高度受狀態列影響。
• 系統Window：對應層級範圍是2000~2999，toast、狀態列等都是系統Window，如果建立了一個系統Window，那麼只有當該應用被銷燬時，該Window才被會關閉（排除主動關閉），所以可以用系統Window實現像360那樣的懸浮小球。系統Window需要設定<uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW" />許可權，否則會拋異常，在6.0以上需要動態申請。系統Window的高度不受狀態列影響。

 前面說了Window的層級，下面就來看一個示例。

    //程式碼參考了PopupWindow的原始碼。
    private void startWindow() {
        //拿到activity中的wm物件，在attach中建立，是一個WindowManagerImpl物件
        wm = (WindowManager) this.getSystemService(Context.WINDOW_SERVICE);
        frame = new PopupDecorView(this);
        frame.setLayoutParams(new ActivityzhoLayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.WRAP_CONTENT));
        View view = View.inflate(this, R.layout.window_layout, null);
        Button bt = view.findViewById(R.id.window_layout_button);
        bt.setOnClickListener(new OnClickListener() {
            @Override
            public void onClick(View v) {
                
                dismiss();
            }
        });
        //重新設定WindowManager.LayoutParams的值
        WindowManager.LayoutParams p = createPopupLayoutParams(frame.getWindowToken());
        frame.addView(view);
        wm.addView(frame, p);
    }

    private LayoutParams createPopupLayoutParams(IBinder windowToken) {
        final WindowManager.LayoutParams p = new WindowManager.LayoutParams();
        //設定Window gravity。gravity 表示居中，top表示位於頂部
        p.gravity = Gravity.CENTER|Gravity.TOP;
        p.flags = computeFlags(p.flags);
        //設定Window的型別，其實這裡我們也可以設定1~99、1000~1999、2000~2999之間的任意數字
        p.type = LayoutParams.TYPE_APPLICATION;
        //設定Window Token
        p.token = windowToken;
        //設定輸入法模式
        p.softInputMode = WindowManager.LayoutParams.SOFT_INPUT_STATE_UNCHANGED;
        //設定Window動畫
        p.windowAnimations = 0;
        //設定Window畫素格式
        p.format = PixelFormat.TRANSLUCENT;
        // Used for debugging.
        p.setTitle("PopupWindow:" + Integer.toHexString(hashCode()));
        //設定Window寬
        p.width = LayoutParams.MATCH_PARENT;
        //設定Window高
        p.height = LayoutParams.WRAP_CONTENT;
        return p;
    }

    private int computeFlags(int curFlags) {
        curFlags &= ~(
                WindowManager.LayoutParams.FLAG_IGNORE_CHEEK_PRESSES |
                        WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE |
                        WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE |
                        WindowManager.LayoutParams.FLAG_WATCH_OUTSIDE_TOUCH |
                        WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS |
                        WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM |
                        WindowManager.LayoutParams.FLAG_SPLIT_TOUCH);
        curFlags |= WindowManager.LayoutParams.FLAG_IGNORE_CHEEK_PRESSES;
        return curFlags;
    }
    //關閉Window
    private void dismiss() {
        wm.removeView(frame);
    }
    private class PopupDecorView extends FrameLayout {

        public PopupDecorView(Context context) {
            super(context);
        }
        @Override
        public boolean dispatchKeyEvent(KeyEvent event) {
            if (event.getKeyCode() == KeyEvent.KEYCODE_BACK) {
                if (getKeyDispatcherState() == null) {
                    return super.dispatchKeyEvent(event);
                }

                if (event.getAction() == KeyEvent.ACTION_DOWN && event.getRepeatCount() == 0) {
                    final KeyEvent.DispatcherState state = getKeyDispatcherState();
                    if (state != null) {
                        state.startTracking(event, this);
                    }
                    return true;
                } else if (event.getAction() == KeyEvent.ACTION_UP) {
                    final KeyEvent.DispatcherState state = getKeyDispatcherState();
                    if (state != null && state.isTracking(event) && !event.isCanceled()) {
                        dismiss();
                        return true;
                    }
                }
                return super.dispatchKeyEvent(event);
            } else {
                return super.dispatchKeyEvent(event);
            }
        }


        @Override
        public boolean dispatchTouchEvent(MotionEvent ev) {
//	            if (mTouchInterceptor != null && mTouchInterceptor.onTouch(this, ev)) {
//	                return true;
//	            }
            return super.dispatchTouchEvent(ev);
        }


    }
複製程式碼

 WindowManager.LayoutParams用於描述Window的引數，關於其詳細引數可以參考Android Activity應用視窗的建立過程分析這篇文章。  先來看WindowManager.LayoutParams的引數type，也就是Window型別。下面來看不同Window型別的顯示效果

 粉色部分就是建立的Window，可以看出系統及應用Window不受狀態列影響，而子Window卻因為狀態列導致按鈕超出Window範圍。所以可以認為子Window的高度被被狀態列佔去一部分，而其他型別Window則不受此影響，讓WIndow居中時，子Window在手機中的位置也會比其他型別Window的位置高一些，這裡就不驗證了，至於子Window為什麼在狀態列的下面，那是因為狀態列的層級比子Window層級要高。

 WindowManager.LayoutParams的flags也是一個非常重要的引數，由於型別比較多，這裡就主要介紹以下幾個型別。

• FLAG_NOT_TOUCH_MODAL：在此模式下，系統會將當前Window區域以外的單擊事件傳遞給底層的Window，當前Window區域內的單擊事件則自己處理。一般都需要開啟此標記
• FLAG_NOT_FOCUSABLE：在此模式下，Window不能獲取焦點，也不能接受各種輸入事件，此標記會同時開啟FLAG_NOT_TOUCH_MODAL，最終事件會直接傳遞給下層的具有焦點的Window。所以如果Window中有EditText等輸入控制元件時，就不應該啟用此標記。
• FLAG_SHOW_WHEN_LOCKED：開啟此模式可以讓Window顯示在鎖屏的介面。

 WindowManager.LayoutParams中比較常用的引數就上面兩個，當然也可以設定Window的寬高、動畫、token等等，這裡就不一一敘述了。  從上面示例可以看出，Window並不實際存在，它是以一個View的形式展示在螢幕上。

2、WindowManager

 WindowManager的主要功能是提供簡單的API使得使用者可以方便地將一個View作為一個視窗新增到系統中，它是一個介面，繼承自ViewManager介面，ViewManager介面比較簡單，只有以下三個方法。

public interface ViewManager
{
    public void addView(View view, ViewGroup.LayoutParams params);
    public void updateViewLayout(View view, ViewGroup.LayoutParams params);
    public void removeView(View view);
}
複製程式碼

 從方法名也可以看出對Window的增刪改就是針對View的增刪改。方法雖然只有三個，但已經完全夠用了。WindowManager的具體實現是WindowManagerImpl。

public final class WindowManagerImpl implements WindowManager {
    private final WindowManagerGlobal mGlobal = WindowManagerGlobal.getInstance();
    private final Context mContext;
    //父Window
    private final Window mParentWindow;
    private IBinder mDefaultToken;
    ...
    //新增View
    @Override
    public void addView(@NonNull View view, @NonNull ViewGroup.LayoutParams params) {
        applyDefaultToken(params);
        mGlobal.addView(view, params, mContext.getDisplay(), mParentWindow);
    }
    //更新View
    @Override
    public void updateViewLayout(@NonNull View view, @NonNull ViewGroup.LayoutParams params) {
        applyDefaultToken(params);
        mGlobal.updateViewLayout(view, params);
    }
    ...
    //非同步移除View
    @Override
    public void removeView(View view) {
        mGlobal.removeView(view, false);
    }
    //同步移除View
    @Override
    public void removeViewImmediate(View view) {
        mGlobal.removeView(view, true);
    }
    ...
}
複製程式碼

 這裡採用了代理模式，將所有操作交給WindowManagerGlobal來執行。首先來看Window的新增。

2.1、新增Window

 在前面的例子中可以看到，建立一個Window就是向WindowManagerImpl中新增一個View，而WindowManagerImpl又將操作交給了WindowManagerGlobal來處理，下面就來看看WindowManagerGlobal中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");
        }
        //拿到Window的寬高、type等佈局引數
        final WindowManager.LayoutParams wparams = (WindowManager.LayoutParams) params;
        ...
        ViewRootImpl root;
        View panelParentView = null;

        synchronized (mLock) {
            ...
            //查詢View是否已經存在，WindowManager不允許同一個View被新增兩次
            int index = findViewLocked(view, false);
            if (index >= 0) {
                //如果View已在被銷燬的列表中，那麼就先銷燬列表中存在的View
                if (mDyingViews.contains(view)) {
                    // Don't wait for MSG_DIE to make it's way through root's queue.
                    mRoots.get(index).doDie();
                } else {
                    //很常見的一個異常，表示不能重複新增同一View
                    throw new IllegalStateException("View " + view
                            + " has already been added to the window manager.");
                }
                // The previous removeView() had not completed executing. Now it has.
            }

            //如果是子Window則需要先找到它的父View
            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 = new ViewRootImpl(view.getContext(), display);
            //給View設定引數
            view.setLayoutParams(wparams);
            //儲存View
            mViews.add(view);
            //儲存ViewRootImpl
            mRoots.add(root);
            //儲存引數
            mParams.add(wparams);

            //繪製View、新增Window
            try {
                // 將作為視窗的控制元件設定給ViewRootImpl。這個動作將導致ViewRootImpl向WMS新增新的視窗、申請Surface以及託管控制元件在Surface上的重繪動作。這才是真正意義上完成了視窗的新增操作
                root.setView(view, wparams, panelParentView);
            } catch (RuntimeException e) {
                // BadTokenException or InvalidDisplayException, clean up.
                if (index >= 0) {
                    removeViewLocked(index, true);
                }
                throw e;
            }
        }
    }
複製程式碼

 在addView方法中主要做了引數檢查、查詢子Window的父View、建立ViewRootImpl物件並通過ViewRootImpl的setView方法來實現View的繪製及Window新增操作。下面來看ViewRootImpl中setView方法的實現。

    public void setView(View view, WindowManager.LayoutParams attrs, View panelParentView) {
        synchronized (this) {
            if (mView == null) {
                //儲存當前View
                mView = view;
                ...
                //儲存引數
                attrs = mWindowAttributes;
                ...

                //繪製View。
                requestLayout();
                ...
                try {
                    ...
                    res = mWindowSession.addToDisplay(mWindow, mSeq, mWindowAttributes,
                            getHostVisibility(), mDisplay.getDisplayId(),
                            mAttachInfo.mContentInsets, mAttachInfo.mStableInsets,
                            mAttachInfo.mOutsets, mInputChannel);
                } catch (RemoteException e) {
                    ....
                } finally {
                    if (restore) {
                        attrs.restore();
                    }
                }
                ...
                //新增失敗
                if (res < WindowManagerGlobal.ADD_OKAY) {
                    mAttachInfo.mRootView = null;
                    //新增失敗
                    mAdded = false;
                    mFallbackEventHandler.setView(null);
                    unscheduleTraversals();
                    setAccessibilityFocus(null, null);
                    //返回錯誤的原因，相比很多錯誤資訊大家都會遇到過
                    switch (res) {
                        //token出錯
                        case WindowManagerGlobal.ADD_BAD_APP_TOKEN:
                        case WindowManagerGlobal.ADD_BAD_SUBWINDOW_TOKEN:
                            throw new WindowManager.BadTokenException(
                                    "Unable to add window -- token " + attrs.token
                                    + " is not valid; is your activity running?");
                        case WindowManagerGlobal.ADD_NOT_APP_TOKEN:
                            throw new WindowManager.BadTokenException(
                                    "Unable to add window -- token " + attrs.token
                                    + " is not for an application");
                        case WindowManagerGlobal.ADD_APP_EXITING:
                            throw new WindowManager.BadTokenException(
                                    "Unable to add window -- app for token " + attrs.token
                                    + " is exiting");
                        //新增Window已存在
                        case WindowManagerGlobal.ADD_DUPLICATE_ADD:
                            throw new WindowManager.BadTokenException(
                                    "Unable to add window -- window " + mWindow
                                    + " has already been added");
                        case WindowManagerGlobal.ADD_STARTING_NOT_NEEDED:
                            // Silently ignore -- we would have just removed it
                            // right away, anyway.
                            return;
                        case WindowManagerGlobal.ADD_MULTIPLE_SINGLETON:
                            throw new WindowManager.BadTokenException("Unable to add window "
                                    + mWindow + " -- another window of type "
                                    + mWindowAttributes.type + " already exists");
                        //未申請許可權，當建立系統Window時是需要申請許可權的
                        case WindowManagerGlobal.ADD_PERMISSION_DENIED:
                            throw new WindowManager.BadTokenException("Unable to add window "
                                    + mWindow + " -- permission denied for window type "
                                    + mWindowAttributes.type);
                        case WindowManagerGlobal.ADD_INVALID_DISPLAY:
                            throw new WindowManager.InvalidDisplayException("Unable to add window "
                                    + mWindow + " -- the specified display can not be found");
                        //window型別未在1~99，1000~1999,2000~2999這個範圍內。
                        case WindowManagerGlobal.ADD_INVALID_TYPE:
                            throw new WindowManager.InvalidDisplayException("Unable to add window "
                                    + mWindow + " -- the specified window type "
                                    + mWindowAttributes.type + " is not valid");
                    }
                    throw new RuntimeException(
                            "Unable to add window -- unknown error code " + res);
                }
                ...
            }
        }
    }
複製程式碼

 該方法真正意義上完成了View的繪製及Window的新增操作，來看requestLayout與mWindowSession.addToDisplay這兩個方法。前者主要是申請Surface以及託管控制元件在Surface上的重繪動作，即View的測量、佈局、繪製流程。關於該方法詳細內容可以參考Android原始碼分析之View繪製流程、《深入理解Android 卷III》第六章 深入理解控制元件（ViewRoot）系統這兩篇文章。後者主要向WindowManagerService(WMS)新增新的視窗。  總體來說，WindowManagerGlobal通過父視窗調整了佈局引數之後，將新建的ViewRootImpl、控制元件以及佈局引數儲存在mRoots，mViews及mParams這三個陣列中，然後將View交給新建的ViewRootImpl進行處理，從而完成了視窗的新增。  WindowManagerGlobal管理視窗的原理如下圖所示。

    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的佈局引數
        view.setLayoutParams(wparams);

        synchronized (mLock) {
            int index = findViewLocked(view, true);
            //查詢view對應的ViewRootImpl
            ViewRootImpl root = mRoots.get(index);
            //移除舊的佈局引數
            mParams.remove(index);
            //新增新的佈局引數
            mParams.add(index, wparams);
            //更新佈局引數
            root.setLayoutParams(wparams, false);
        }
    }

複製程式碼

    void setLayoutParams(WindowManager.LayoutParams attrs, boolean newView) {
        synchronized (this) {
            //修改佈局引數的操作
            ...
            //對View進行重新測量、佈局、繪製
            mWindowAttributesChanged = true;
            scheduleTraversals();
        }
    }
複製程式碼

    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
    private void removeViewLocked(int index, boolean immediate) {
        ViewRootImpl root = mRoots.get(index);
        View view = root.getView();

        if (view != null) {
            //拿到輸入法管理
            InputMethodManager imm = InputMethodManager.getInstance();
            if (imm != null) {
                //關閉輸入法Window
                imm.windowDismissed(mViews.get(index).getWindowToken());
            }
        }
        //返回true表示非同步刪除，false表示同步刪除
        boolean deferred = root.die(immediate);
        if (view != null) {
            view.assignParent(null);
            if (deferred) {
                //非同步刪除只是將view新增到mDyingViews這個集合即可。
                mDyingViews.add(view);
            }
        }
    }
    //該方法在ViewRootImpl中
    boolean die(boolean immediate) {
        //立即移除View
        if (immediate && !mIsInTraversal) {
            doDie();
            return false;
        }
        ...
        //非同步移除View，
        mHandler.sendEmptyMessage(MSG_DIE);
        return true;
    }
複製程式碼

    void doDie() {
        //如果在非UI執行緒則報錯
        checkThread();
        ...
        synchronized (this) {
            if (mRemoved) {
                return;
            }
            mRemoved = true;
            if (mAdded) {
                //資源釋放
                dispatchDetachedFromWindow();
            }

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

            mAdded = false;
        }
        //從mRoots、mViews及mParams這三個陣列中移除資訊
        WindowManagerGlobal.getInstance().doRemoveView(this);
    }
複製程式碼