今天，在做專案的過程中，實現了一個浮動視窗的功能，大致思路是這樣的：通過例項化一個ImageButton並給這個Button設定監聽，然後將這個Button傳遞給WindowManager的addView方法，在ListView滑動過程中，通過監聽ListView的滑動狀態，利用WindowManager的updateViewLayout方法，控制浮動視窗的顯示和隱藏。功能實現很簡單，但是，一直有一個疑問：android是如何控制視窗的呢？這就得看看Android Window的內部機制

在Android裡Window是一個抽象的概念，它是指螢幕上的一個顯示區域。系統是通過系統服務WindowManagerService來統一對Window實施管理的。在FrameWork層，提供了WindowManager類來使用WindowManagerService提供的服務，對Window實施操作。在WindowManagerService裡，對應一個WindState，這個WindowState就是Window的具體存在。

對於開發者來說，可以看到的window的存在是Android 提供的Window類，這個類是一個抽象類，代表一個使用者可以見的window。這個類的唯一實現類是PhoneWindow，該類裡封裝了一個DecorView物件，這就是使用者可見的View。在Activity的時候，會給其例項化一個Window，最後通過WindowManger將DecorView加到WindowManagerService中。

WindowManager是開發者和系統維護的window的入口，WindowManager和WindowManagerService 的互動是一個IPC的過程。

下面就從原始碼的角度分析一下Android Window的內部實現機制。

Window的內部機制

Window是一個抽象概念，每一個Window都對應一個View和ViewRootImpl，Window和View之間通過ViewRootImpl之間建立聯絡，Window並不可見，它是以View為存在形式的。

Window由WindowManagerService統一維護，外界需要操作Window必須通過WindowManager提供的介面實現，它提供了Window的新增、更新和刪除的操作。下面結合原始碼，分析一下Window的新增 更新和刪除的原理。

Window的新增

Wind的新增時通過WindowManager的addView來完成的。

public interface WindowManager extends ViewManager 
 

它是一個繼承自ViewManager的介面

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);
}

WindowManager的實現類是WindowManagerImpl

public final class WindowManagerImpl implements WindowManager

它對WindowManager三大方法的實現如下：

 @Override
public void addView(View view, ViewGroup.LayoutParams params) {
    mGlobal.addView(view, params, mDisplay, mParentWindow);
}

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

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

mGlobal的定義是這樣的

private final WindowManagerGlobal mGlobal = WindowManagerGlobal.getInstance();

可以看出，WindowManagerImpl通過橋接模式，利用WindowManagerGlobal 來實現了WindowManager的功能。

WindowManagerGlobal是用來管理Window的全域性類，它裡面維護了幾個全域性的列表。

//儲存所有Window所對應的View
private final ArrayList<View> mViews = new ArrayList<View>();

//儲存所有Window對應的ViewRootImpl
private final ArrayList<ViewRootImpl> mRoots = new ArrayList<ViewRootImpl>();

//儲存所有Window對應的佈局引數
private final ArrayList<WindowManager.LayoutParams> mParams =
        new ArrayList<WindowManager.LayoutParams>();
//儲存所有將要被刪除的View,即Window
private final ArraySet<View> mDyingViews = new ArraySet<View>();

下面分析一下新增WindowManagerGlobal Window的過程

1. 檢查引數是否合法，如果是子Window，需要調整佈局引數

   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) {//如果是子View還得調整引數
       parentWindow.adjustLayoutParamsForSubWindow(wparams);
   } else {
       // If there's no parent and we're running on L or above (or in the
       // system context), assume we want hardware acceleration.
       final Context context = view.getContext();
       if (context != null
               && context.getApplicationInfo().targetSdkVersion >= Build.VERSION_CODES.LOLLIPOP) {
           wparams.flags |= WindowManager.LayoutParams.FLAG_HARDWARE_ACCELERATED;
       }
   }
   

2. 建立ViewRootImpl，並將其和View新增到列表中

   //建立ViewRootImpl root = new ViewRootImpl(view.getContext(), display);

   view.setLayoutParams(wparams);

   //將view新增到list中去 mViews.add(view); mRoots.add(root); mParams.add(wparams);

3. 使用ViewRootImpl更新介面完成window的新增過程

完成以上任務後，由ViewRootImpl通過setView（）方法來實現Window的新增。

//由ViewRootImpl實現View的繪製
root.setView(view, wparams, panelParentView);

在setView（）內部，會呼叫requestLayout()，這個方法是一個非同步方法，來完成View的繪製工作。這個方法如下：

 @Override
public void requestLayout() {
    if (!mHandlingLayoutInLayoutRequest) {
        //檢查是否是主執行緒
        checkThread();
        mLayoutRequested = true;
        //繪製View的入口
        scheduleTraversals();
    }
}

在這個方法裡主要執行兩個方法，一個是檢查當前執行緒是不是View的建立的執行緒，另外一個是繪製View。

在執行完requestLayout（）後，完成Window的新增過程。

try {
    mOrigWindowType = mWindowAttributes.type;
    mAttachInfo.mRecomputeGlobalAttributes = true;
    collectViewAttributes();

    //通過WindowSession完成Window的新增
    res = mWindowSession.addToDisplay(mWindow, mSeq, mWindowAttributes,
            getHostVisibility(), mDisplay.getDisplayId(),
            mAttachInfo.mContentInsets, mInputChannel);

} 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();
    }
}

新增的過程是通過mWindowSession.addToDisplay（）完成的。mWindowSession的定義如下：

final IWindowSession mWindowSession;

它是一個IWindowSession型別，在Android原始碼裡，被定義為一個AIDL型別，Session 對其功能進行了實現:

final class Session extends IWindowSession.Stub

mWindowSession是在ViewRootImpl例項化的：

 public ViewRootImpl(Context context, Display display) {
    mContext = context;
    mWindowSession = WindowManagerGlobal.getWindowSession();

再看看WindowManagerGlobal.getWindowSession();

 public static IWindowSession getWindowSession() {
    synchronized (WindowManagerGlobal.class) {
        if (sWindowSession == null) {
            try {
                InputMethodManager imm = InputMethodManager.getInstance();

                //獲得與WindowMangerService通訊的IBinder介面
                IWindowManager windowManager = getWindowManagerService();

                sWindowSession = windowManager.openSession(
                        new IWindowSessionCallback.Stub() {
                            @Override
                            public void onAnimatorScaleChanged(float scale) {
                                ValueAnimator.setDurationScale(scale);
                            }
                        },
                        imm.getClient(), imm.getInputContext());
                ValueAnimator.setDurationScale(windowManager.getCurrentAnimatorScale());
            } catch (RemoteException e) {
                Log.e(TAG, "Failed to open window session", e);
            }
        }
        return sWindowSession;
    }
}

在看看getWindowManagerService（）

public static IWindowManager getWindowManagerService() {
    synchronized (WindowManagerGlobal.class) {
        if (sWindowManagerService == null) {
            sWindowManagerService = IWindowManager.Stub.asInterface(
                    ServiceManager.getService("window"));
        }
        return sWindowManagerService;
    }
}

它獲得的其實是與WindowMangerService通訊的IBinder介面，看看WindowMangerService的實現就知道了：

public class WindowManagerService extends IWindowManager.Stub

WindowMangerService就是IWindowManager的實現類，同時它實現了openSession（）方法：

 @Override
public IWindowSession openSession(IWindowSessionCallback callback, IInputMethodClient client,
        IInputContext inputContext) {
    if (client == null) throw new IllegalArgumentException("null client");
    if (inputContext == null) throw new IllegalArgumentException("null inputContext");
    Session session = new Session(this, callback, client, inputContext);
    return session;
}

再看看Session的addToDisplay（）

 @Override
public int addToDisplay(IWindow window, int seq, WindowManager.LayoutParams attrs,
        int viewVisibility, int displayId, Rect outContentInsets,
        InputChannel outInputChannel) {
    return mService.addWindow(this, window, seq, attrs, viewVisibility, displayId,
            outContentInsets, outInputChannel);
}

其實，新增Window的過程就是通過Session和WindowManagerService通訊的過程。由此，新增Window就交給WindowManagerService完成。

Window的刪除

Window的刪除和新增一樣，最終是通過WindowManagerGlobal.removeView()實現的，它的思路很簡單：

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

    synchronized (mLock) {
        //查詢要刪除哪個View
        int index = findViewLocked(view, true);
        View curView = mRoots.get(index).getView();
        //刪除View
        removeViewLocked(index, immediate);
        if (curView == view) {
            return;
        }

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

刪除是通過 removeViewLocked（）實現的，其實最終是通過ViewRootImpl實現的

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) {
            imm.windowDismissed(mViews.get(index).getWindowToken());
        }
    }
    boolean deferred = root.die(immediate);
    if (view != null) {
        view.assignParent(null);
        if (deferred) {
            mDyingViews.add(view);
        }
    }
}

下面看看 root.die(immediate)方法：

 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(TAG, "Attempting to destroy the window while drawing!\n" +
                "  window=" + this + ", title=" + mWindowAttributes.getTitle());
    }
    mHandler.sendEmptyMessage(MSG_DIE);
    return true;
}

它主要是通過呼叫doDie()實現的。

void doDie() {
    checkThread();
    if (LOCAL_LOGV) Log.v(TAG, "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) {
                    }
                }

                mSurface.release();
            }
        }

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

主要是完成一些清理工作。

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);
    }
}

不難發現，最終也是通過ViewRootImpl來實現的，setLayoutParams（）方法最終會呼叫

 scheduleTraversals();

而這個方法，最終會導致View的重新測量、佈局和重繪。

到此windw的新增、更新和刪除的內部實現機制就分析完畢，不難發現，ViewRootImpl是控制View的測量、佈局和重繪的。