Android 理解Window和WindowManager

Android 理解Window和WindowManager

Window表示的是一个窗口的概念，它是一个抽象类，具体实现是PhoneWindow。
创建一个Window只需要通过WindowManager即可完成，WindowManager是外界访问Window的入口。Window的具体实现是在WindowManagerService中，WindowManager与WindowManagerService的交互是一个IPC的过程。
Android中的所有视图都是通过Window来实现的，不管是Activity，Dialog还是Toast，它们的视图都是附加在Window上的，因此Window是View的直接管理者，在事件分发中提到过，View的事件是通过Window传递给DecorView，然后DecorView传递给我们的View，就连Activity的setContentView在底层也是通过Window完成的。

Window和WindowManager

为了分析Window的工作机制，需要先了解如果使用WindowManager来添加一个Window：

mFloatButton = new Button(this);
mFloatButton.setText("button");
mLayoutParams = new WindowManager.LayoutParams(
    LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT, 0, 0, PixelFormat.TRANSLUCENT);
mLayoutParams.flags = LayoutParams.FLAG_NOT_TOUCH_MODAL
        | LayoutParams.FLAG_NOT_FOCUSABLE
        | LayoutParams.FLAG_SHOW_WHEN_LOCKED;
mLayoutParams.gravity = Gravity.LEFT | Gravity.TOP;
mLayoutParams.x = 100;
mLayoutParams.y = 300;
mWindowManager.addView(mFloatButton, mLayoutParams);

上述代码可以将一个Button添加到屏幕坐标为（100,300）的位置上。

WindowManager.LayoutParams中的type和flags参数比较重要，下面对其说明。

Flag：

Flag参数表示window的属性用于控制Window的显示特性，这里介绍比较常用的：

• FLAG_NOT_FOCUSABLE
  表示窗口不需要获取焦点，也不需要接收各种输入事件，此标记会同时启用FLAG_NOT_TOUCH_MODAL，最终事件会传递给下层的具有焦点的window

• FLAG_NOT_TOUCH_MODAL
  在此模式下，系统会将当前window区域以外的单击事件传递给底层的Window，当前Window区域以内的单击事件则自己处理。这个标记很重要，一般来说都需要开启，否则其他window将无法获取单击事件

• FLAG_SHOW_WHEN_LOCKED
  开启此模式可以让window显示在锁屏上

type:

Type参数表示window的类型，window有三种类型，分别是应用Window，子Window，系统Window。应用类window对应一个Activity，子Window不能单独存在，需要依附在一个父Window中，比如常见的Dialog就是子Window，系统Window需要声明权限，比如Toast和系统状态栏都是系统Window。

Window是分层的，每个Window对应着z-ordered，层级大的会覆盖在层级小的Window上面，这和HTML中的z-index的概念是一致的。在三类Window中，应用是层级范围是1-99，子window的层级是1000-1999，系统的层级是2000-2999。这些范围对应着WindowManager.LayoutParams的type参数，如果想要window位于最顶层，那么采用较大层级即可，很显然系统层级是最大的，并且系统层级的有很多值，一般可以选择TYPE_SYSTEM_OVERLAY或TYPE_SYSTEM_ERROR。
如果采用TYPE_SYSTEM_ERROR，则为type参数指定层级：layout.type = WindowManager.LayoutParams.TYPE_PHONE;，同时声明权限：<uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW"/>。

WindowManager功能

WindowManager所提供的功能很简单，常用的只有三个方法，即添加View、更新View和删除View，这三个方法定义在ViewManager中，而WindowManager继承于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);
}

对开发者来说，WindowManager常用的这三个功能已经足够使用了，比如要实现可以拖动的Window效果只需要根据手指位置来设定LayoutParams的x和y的值即可改变Window的位置：

mFloatingButton.setOnTouchListener(new View.OnTouchListener() {
    @Override
    public boolean onTouch(View v, MotionEvent event) {
        int rawX = (int) event.getRawX();
        int rawY = (int) event.getRawY();
        switch (event.getAction()) {
            case MotionEvent.ACTION_MOVE:
                mLayoutParams.x = rawX;
                mLayoutParams.y = rawY;
                mWindowManager.updateViewLayout(mFloatingButton,mLayoutParams);
                break;
        }
        return false;
    }
});

Window的内部机制

Window是一个抽象的概念，每一个Window都对应着一个View和一个ViewRootImpl，Window和View通过ViewRootImpl建立联系。
在实际使用中无法直接访问Window，必须通过WindowManager定义的相关接口才能将操作传递给View。

为了分析Window的内部机制，这里从Window的添加、删除以及更新说起。

Window的添加过程

Window的添加是通过WindowManager的addView来实现的，WindowManager是一个接口，真正实现是WindowManagerImpl类。在WindowManagerImpl中Window的三大操作如下：

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

可以发现，WindowManagerImpl将操作交给了WindowManagerGlobal来处理，在WindowManagerGlobal中有一段如下的代码：

private final WindowManagerGlobal mGlobal = WindowManagerGlobal.getInstance();

这种工作模式是典型的桥接模式，将所有的操作全部委托给WindowManagerGlobal去实现，WindowManagerGlobal的addView方法主要分如下几步：

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) {
    parentWindow.adjustLayoutParamsForSubWindow(wparams);
}

2. 创建ViewRootImpl并将View添加到列表中

在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。

在addView中通过如下方式将Window的一系列对象添加到列表中：

root = new ViewRootImpl(view.getContext(), display);
view.setLayoutParams(wparams);

mViews.add(view);
mRoots.add(root);
mParams.add(wparams);

3. 通过ViewRootImpl来更新界面并完成Window的添加

这个步骤由ViewRootImpl的setView完成。

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

在setView内部会调用requstLayout，在requstLayout中，scheduleTraversals实际就是View绘制的入口，发送异步刷新请求：

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

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

然后会通过mWindowSession.addToDisplay最终来完成Window的添加过程，mWindowSession是一个Binder对象，在addToDiaplay内部通过IPC调用WindowManagerService的addWindow接口，将Window的添加请求交给WindowManagerService处理。

res = mWindowSession.addToDisplay(mWindow, mSeq, mWindowAttributes,
                            getHostVisibility(), mDisplay.getDisplayId(), mWinFrame,
                            mAttachInfo.mContentInsets, mAttachInfo.mStableInsets,
                            mAttachInfo.mOutsets, mAttachInfo.mDisplayCutout, mInputChannel);

Window的添加过程流程图

Window的删除过程

Window的删除过程和添加过程一样，都是先通过WindowManagerImpl将操作交给WindowManagerGlobal来实现的。
在windowManager中提供了两种接口removeView和removeViewImmediate，分别表示异步删除和同步删除，其中同步删除使用起来要格外注意，一般来说不需要使用此方法来删除Window以免发生意外的错误。这里主要说明异步删除，下面是WindowManagerGlobal的removeView实现：

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

removeView的代码很清晰，首先通过findViewLocked来查找待删除View的索引，查找过程就是遍历view数组，然后调用removeViewLocked进行删除：

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

removeViewLocked通过ViewRootImpl的die方法来完成删除操作。在同步情况下直接调用doDie方法，在异步删除情况下，die方法内通过mHandler发送一个MSG_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(TAG, "Attempting to destroy the window while drawing!\n" +
                "  window=" + this + ", title=" + mWindowAttributes.getTitle());
    }
    mHandler.sendEmptyMessage(MSG_DIE);
    return true;
}

然后在ViewRootImpl的handler内的handleMessage中处理此消息并调用doDie方法，看一下doDie实现：

void doDie() {
    ...
    synchronized (this) {
        if (mRemoved) {
            return;
        }
        mRemoved = true;
        if (mAdded) {
            dispatchDetachedFromWindow();
        }

        ...

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

上面是doDie中的主要代码，首先调用dispatchDetachedFromWindow来从Window中删除View，最后调用doRemoveView来清理mRoots、mParams、mViews以及mDyingViews中的数据，看一下dispatchDetachedFromWindow的主要代码：

void dispatchDetachedFromWindow() {
    ...
    if (mView != null && mView.mAttachInfo != null) {
        mAttachInfo.mTreeObserver.dispatchOnWindowAttachedChange(false);
        mView.dispatchDetachedFromWindow();
    }

    ...

    mView.assignParent(null);
    mView = null;
    mAttachInfo.mRootView = null;

    ...

    try {
        mWindowSession.remove(mWindow);
    } catch (RemoteException e) {
    }

    ...

    mDisplayManager.unregisterDisplayListener(mDisplayListener);

    unscheduleTraversals();
}

dispatchDetachedFromWindow主要做了下面几件事：

• 调用view的dispatchDetachedFromWindow方法，内部会调用onDetachedFromWindow，在应用层可以做一些资源回收工作比如停止动画、终止线程等操作
• 通过mWindowSession的remove方法来删除window，同样是一个IPC的过程，最终会调用WindowManagerService的removeWindow方法
• 垃圾回收相关的工作，比如清除数据和消息，移除回调等
• 调用unscheduleTraversals，在刷新布局方面与scheduleTraversals一样，最后都会执行mTraversalRunnable，从而实现View布局刷新

Window的删除过程流程图

Window的更新过程

Window的更新过程要看WindowManagerGlobal的updateViewLayout方法，它做的事情比较简单，首先更新View的LayoutParams并替换老的LayoutParams，接着再通过ViewRootImpl的setLayoutParams方法更新LayoutParams：

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中会通过scheduleTraversals方法来对View刷新布局，实现重新测量，布局，重绘三个过程。

Window的更新过程流程图

关于scheduleTraversals最后补充一下，它的执行流程是：scheduleTraversals() -> 调用 mTraversalRunnable -> doTraversal() -> performTraversals()，最后会执行到performTraversals，performTraversals在View 工作原理基础中有提到过会依次完成测量，布局，重绘三个过程，但是在这三个过程之前会先通过mWindowSession.relayout来刷新Window的布局，这个过程最终由WindowManagerService的relayoutWindow来实现的，同样是一个IPC的过程。