Window顾名思义就是窗口，Android Window的实现类是PhoneWindow。WindowManager是访问Window的入口，通过它可以创建Window，WindowManager的具体实现在WindowService中，Window与WindowService之间的交互是一种IPC过程。Android中的界面都是通过Window来呈现的，比如Activity、Dialog和Toast等，他们的界面都是附加在Window上的，因此View的实际管理者是Window。
1.Window与WindowManager
在了解Window的工作机制之前我们先来看下如何使用WindowManager添加一个Window。
WindowManager windowManager = getWindowManager();
Button btAdd = new Button(this);
btAdd.setText("手动添加按钮");
WindowManager.LayoutParams layoutParams = new WindowManager.LayoutParams(WindowManager.LayoutParams.WRAP_CONTENT,
WindowManager.LayoutParams.WRAP_CONTENT, 0, 0, PixelFormat.TRANSPARENT);
layoutParams.flags = WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL;
layoutParams.gravity = Gravity.LEFT;
layoutParams.x = 100;
layoutParams.y = 200;
windowManager.addView(btAdd,layoutParams);
上面代码是将一个Button添加到坐标（100，200）的位置。下面简单介绍下WindowManager.LayoutParams中的flags与type这两个参数。
flags表示的是Window的属性，有很多选择项，简单介绍几种。
FLAG_NOT_FOCUSABLE：
表示Window不需要获取焦点，又不需要接受任何输入事件，次标记还会同时启用FLAG_NOT_TOUCH_MODAL，最终事件会传递给下层有焦点的Window。
FLAG_NOT_TOUCH_MODAL：
此模式下系统会将当前Window区域以外的单击事件传递给底层的Window，当前区域以内的单击事件则自己处理。
FLAG_SHOW_WHEN_LOCKED：
开启当前模式，可以让Window显示在锁屏界面上。
如果了解其他的属性，建议还是看下源码：
/** Window flag: as long as this window is visible to the user, allow
* the lock screen to activate while the screen is on.
* This can be used independently, or in combination with
* {@link #FLAG_KEEP_SCREEN_ON} and/or {@link #FLAG_SHOW_WHEN_LOCKED} */
public static final int FLAG_ALLOW_LOCK_WHILE_SCREEN_ON = 0x00000001;
/** Window flag: everything behind this window will be dimmed.
* Use {@link #dimAmount} to control the amount of dim. */
public static final int FLAG_DIM_BEHIND = 0x00000002;
/** Window flag: blur everything behind this window.
* @deprecated Blurring is no longer supported. */
@Deprecated
public static final int FLAG_BLUR_BEHIND = 0x00000004;
type表示Window的类型，一般Window有三种类型：应用Window、子Window和系统Window。应用类的Window对应着一个Activity。子Window是不能单独存在的，他需要在特定的父Window之中，比如常见的Dialog就是一个子Window。系统Window需要声明特殊的权限才能创建，比如Toast跟系统状态栏等。
Window是分层的，每个Window都有对应的z-ordered，层级大的会覆盖在层级小的Window的上面，这和HTML中的z-index的概念是完全一致的。在三类Window中，应用Window的层级范围是1~99，子Window的层级范围是1000～1999，系统Window的层级范围是2000～2999，这些层级范围对应着WindowManager.LayoutParams的type参数。如果想要Window位于所有Window的最顶层，那么采用较大的层级即可。很显然系统Window的层级是最大的，而且系统层级有很多值，一般我们可以选用TYPE_SYSTEM_OVERLAY或者TYPE_SYSTEM_ERROR，如果采用TYPE_SYSTEM_ERROR，只需要为type参数指定这个层级即可：mLayoutParams.type = LayoutParams.TYPE_SYSTEM_ERROR；同时声明权限：<uses-permissionandroid: name= “android.permission .SYSTEM_ALERT_WINDOW”/>。因为系统类型的Window是需要检查权限的，如果不在AndroidManifest 中使用相应的权限，那么创建Window的时候就会报错。
WindowManager的功能比较简单，常用的就是三个方法：addView、updateViewLayout和removeView，这三个方法都定义在ViewManager中，WindowManager继承了ViewManager。
/** Interface to let you add and remove child views to an Activity. To get an instance
* of this class, call {@link android.content.Context#getSystemService(java.lang.String) Context.getSystemService()}.
*/
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常用的就只有这三个功能，当然这三个方法也就足够用了。WindowManager操作Window其实就是在操作里面的View。通过这些方法，我们可以实现诸如随意拖拽位置的Window等效果。
2.Window的内部机制
Window是一个抽象类，每个Window都对应一个View跟一个ViewRootImpl，Window跟View是通过ViewRootImpl建立联系的，因此Window并不实际存在，它是以View的形式存在的。从WindowManager的定义跟主要方法也能看出，View是Window存在的实体。下面就具体介绍下Window的addView、updateViewLayout和removeView。
2.1Window的添加过程。
Window的添加过程需要通过WindowManager的addView来实现，不过WindowManager是一个接口，真正实现是在WindowManagerImpl中，三个主要操作，先上源码：
@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);
}
上面的源码很明显，WindowManagerImpl也没有直接实现Window的三大操作，而是由WindowManagerGlobal来处理的，代码段：private final WindowManagerGlobal mGlobal = WindowManagerGlobal.getInstance(); 可以看出，WindowManagerGlobal以工厂的形式向外提供自己的实例。WindowManagerImpl这种工作模式是典型的桥接模式，将所有的操作委托给WindowManagerGlobal来实现。具体看下addView的源码：
1.检查参数是否合法，子Window还需要调整布局：
......
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);
} else {
// If there's no parent, then hardware acceleration for this view is
// set from the application's hardware acceleration setting.
final Context context = view.getContext();
if (context != null
&& (context.getApplicationInfo().flags
& ApplicationInfo.FLAG_HARDWARE_ACCELERATED) != 0) {
wparams.flags |= WindowManager.LayoutParams.FLAG_HARDWARE_ACCELERATED;
}
}
......
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则是对应的布局。mDyingViews存储的是正在被删除的View。
......
root = new ViewRootImpl(view.getContext(), display);
view.setLayoutParams(wparams);
mViews.add(view);
mRoots.add(root);
mParams.add(wparams);
......
上面源码表示了addView添加View的过程。
3.通过ViewRootImpl来更新界面，完成Window的添加过程
......
// 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的setView方法在界面View的时候有说到，在setView内部，通过requestLayout方法实现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();
......
接着通过WindowSession来完成Window的添加过程。下面的源码中，mWindowSession是IWindowSession的实例，这是一个Binder对象，真正的实现类是Session，也就是说Window的添加过程是一次IPC调用。
try {
mOrigWindowType = mWindowAttributes.type;
mAttachInfo.mRecomputeGlobalAttributes = true;
collectViewAttributes();
res = mWindowSession.addToDisplay(mWindow, mSeq, mWindowAttributes,
getHostVisibility(), mDisplay.getDisplayId(),
mAttachInfo.mContentInsets, mAttachInfo.mStableInsets,
mAttachInfo.mOutsets, 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();
}
}
Session内部会通过WindowManagerService来实现Window的添加过程。
介绍到这里，各位就发现，Window的添加请求是交给WindowManagerService去处理的，WindowManagerService内部会为每一个应用保留一个单独的Session。具体的代码的逻辑大家看下源码，这里主要介绍部分源码，还是以流程为主。
2.2Window的删除过程
Window的删除过程与添加过程一样，都是先通过WindowManagerImpl然后通过WindowManagerGlobal来实现的：
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的索引，这个索引是上面说的ArrayList mViews的index，然后删除掉这个就可以了。
private int findViewLocked(View view, boolean required) {
final int index = mViews.indexOf(view);
if (required && index < 0) {
throw new IllegalArgumentException("View=" + view + " not attached to window manager");
}
return index;
}
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);
}
}
}
在WindowManager中提供了两种删除的接口：removeView跟removeViewImmediate，他们分别表示异步跟同步删除，removeViewImmediate方法一般不会使用，以免删除Window发生意外错误。我们重点看下异步删除的情况。代码段6可以看到，删除操作是通过ViewRootImpl的die方法完成的，具体看下这个方法：
/**
* @param immediate True, do now if not in traversal. False, put on queue and do later.
* @return True, request has been queued. False, request has been completed.
*/
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;
}
看上面的代码，你会发现，die方法只是发了一个请求，然后就返回了，再看代码段6，View被加到mDyingViews中了。异步删除可以看到发送了一个message，MSG_DIE，然后ViewRootImpl的handler会处理此消息然后调用die方法，同步的话就直接删除了。这也是这两种删除方式的区别。真正删除View的逻辑在doDie方法的dispatchDetachedFromWindow方法中。
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) {
}
}
mSurface.release();
}
}
mAdded = false;
}
WindowManagerGlobal.getInstance().doRemoveView(this);
}
void dispatchDetachedFromWindow() {
if (mView != null && mView.mAttachInfo != null) {
mAttachInfo.mTreeObserver.dispatchOnWindowAttachedChange(false);
mView.dispatchDetachedFromWindow();
}
mAccessibilityInteractionConnectionManager.ensureNoConnection();
mAccessibilityManager.removeAccessibilityStateChangeListener(
mAccessibilityInteractionConnectionManager);
mAccessibilityManager.removeHighTextContrastStateChangeListener(
mHighContrastTextManager);
removeSendWindowContentChangedCallback();
destroyHardwareRenderer();
setAccessibilityFocus(null, null);
mView.assignParent(null);
mView = null;
mAttachInfo.mRootView = null;
mSurface.release();
if (mInputQueueCallback != null && mInputQueue != null) {
mInputQueueCallback.onInputQueueDestroyed(mInputQueue);
mInputQueue.dispose();
mInputQueueCallback = null;
mInputQueue = null;
}
if (mInputEventReceiver != null) {
mInputEventReceiver.dispose();
mInputEventReceiver = null;
}
try {
mWindowSession.remove(mWindow);
} catch (RemoteException e) {
}
// Dispose the input channel after removing the window so the Window Manager
// doesn't interpret the input channel being closed as an abnormal termination.
if (mInputChannel != null) {
mInputChannel.dispose();
mInputChannel = null;
}
mDisplayManager.unregisterDisplayListener(mDisplayListener);
unscheduleTraversals();
}
从上面的源码可以看到，dispatchDetachedFromWindow主要做了3件事：
（1）垃圾回收相关工作
（2）通过Session的remove方法删除Window
（3）调用View的dispatchDetachedFromWindow方法，内部调用View的onDetachedFromWindow方法，这个也是做一些资源回收比较合适的时机，比如终止动画、停止线程等。
最终doDie方法调用WindowManagerGlobal的doRemoveView刷新数据。
2.3Window的更新过程
介绍完Window的删除，Window的更新过程直接上源码：
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);
}
}
看源码还是很简单的，首先更新LayoutParams，然后通过ViewRootImpl的setLayoutParams更新ViewRootImpl中的LayoutParams，然后ViewRootImpl通过scheduleTraversals对View重新布局，包括测量，布局，绘制这三个过程。除了View本身重绘之外，ViewRootImpl会通过Session来更新Window视图，同样也是有WindowManagerService的relayoutWindow来实现的，也是一个IPC过程。
