认识一下Android中的Window

Window

  Window是个抽象类，PhoneWindow是Window唯一的实现类。PhoneWindow像是一个工具箱，封装了三种工具：DecorView、WindowManager.LayoutParams、WindowManager。其中DecorView和WindowManager.LayoutParams负责窗口的静态属性，比如窗口的标题、背景、输入法模式、屏幕方向等等。WindowManager负责窗口的动态操作，比如窗口的增、删、改。
  Window抽象类对WindowManager.LayoutParams相关的属性（如：输入法模式、屏幕方向）都提供了具体的方法。而对DecorView相关的属性（如：标题、背景），只提供了抽象方法，这些抽象方法由PhoneWindow实现。

public abstract class Window {
	
	// The current window attributes.
    private final WindowManager.LayoutParams mWindowAttributes =
        new WindowManager.LayoutParams();

	public void setLayout(int width, int height) {
        final WindowManager.LayoutParams attrs = getAttributes();
        attrs.width = width;
        attrs.height = height;
        dispatchWindowAttributesChanged(attrs);
    }

	public void setGravity(int gravity) {
        final WindowManager.LayoutParams attrs = getAttributes();
        attrs.gravity = gravity;
        dispatchWindowAttributesChanged(attrs);
    }

    public void setSoftInputMode(int mode) {
        final WindowManager.LayoutParams attrs = getAttributes();
        if (mode != WindowManager.LayoutParams.SOFT_INPUT_STATE_UNSPECIFIED) {
            attrs.softInputMode = mode;
            mHasSoftInputMode = true;
        } else {
            mHasSoftInputMode = false;
        }
        dispatchWindowAttributesChanged(attrs);
    }

	//下面三个抽象方法将由PhoneWindow实现
	public abstract void setTitle(CharSequence title);

	public abstract void setContentView(View view, ViewGroup.LayoutParams params);

	public abstract void setBackgroundDrawable(Drawable drawable);

}

public class PhoneWindow extends Window implements MenuBuilder.Callback {

	@Override
    public void setTitle(CharSequence title) {
        if (mTitleView != null) {
            mTitleView.setText(title);
        } else if (mDecorContentParent != null) {
            mDecorContentParent.setWindowTitle(title);
        }
        mTitle = title;
    }

    @Override
    public void setContentView(View view, ViewGroup.LayoutParams params) {
        // Note: FEATURE_CONTENT_TRANSITIONS may be set in the process of installing the window
        // decor, when theme attributes and the like are crystalized. Do not check the feature
        // before this happens.
        if (mContentParent == null) {
            installDecor();
        } else if (!hasFeature(FEATURE_CONTENT_TRANSITIONS)) {
            mContentParent.removeAllViews();
        }

        if (hasFeature(FEATURE_CONTENT_TRANSITIONS)) {
            view.setLayoutParams(params);
            final Scene newScene = new Scene(mContentParent, view);
            transitionTo(newScene);
        } else {
            mContentParent.addView(view, params);
        }
        mContentParent.requestApplyInsets();
        final Callback cb = getCallback();
        if (cb != null && !isDestroyed()) {
            cb.onContentChanged();
        }
    }

	    @Override
    public final void setBackgroundDrawable(Drawable drawable) {
        if (drawable != mBackgroundDrawable || mBackgroundResource != 0) {
            mBackgroundResource = 0;
            mBackgroundDrawable = drawable;
            if (mDecor != null) {
                mDecor.setWindowBackground(drawable);
            }
            if (mBackgroundFallbackResource != 0) {
                mDecor.setBackgroundFallback(drawable != null ? 0 : mBackgroundFallbackResource);
            }
        }
    }
}

Window分类

  Window 有三种类型，分别是应用 Window、子 Window 和系统 Window。
  应用Window，如：Activity和Dialog。
  子Window，如：PopupWindow。
  系统窗口，如：Toast，输入法，状态栏，导航栏。
  Window 是分层的，每个 Window 都有对应的 z-ordered，层级大的会覆盖在层级小的 Window 上面。在三种 Window 中，应用 Window 层级范围是 1~99，子 Window 层级范围是1000~1999，系统 Window 层级范围是 2000~2999，我们可以用一个表格来直观的表示：

Window	层级
应用 Window	1~99
子Window	1000~1999
系统 Window	2000~2999

  这些层级范围对应着 WindowManager.LayoutParams 的 type 参数，如果想要 Window 位于所有 Window 的最顶层，那么采用较大的层级即可，很显然系统 Window 的层级是最大的。当我们采用系统层级时，一般选用TYPE_SYSTEM_ERROR或者TYPE_SYSTEM_OVERLAY，还需要声明权限。

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

Window并不存在

  Window并不是真实地存在着的，而是以View的形式存在。好吧，我知道这句话听起来有点矛盾。Window本身就只是一个抽象的概念，而View是Window的表现形式，也就是说View是Window的代表。当我们在谈论Window时其实是在谈论Window的根View。
  要想显示窗口，就必须调用WindowManager.addView(View view, ViewGroup.LayoutParams params)。参数view就代表着一个窗口。在Activity和Dialog的显示过程中都会调用到wm.addView(decor, l);所以Activity和Dialog的DecorView就代表着各自的窗口。

子窗口

  上文中提到Dialog也是应用窗口，不知道大家对此是否有疑惑。一开始的时候，我一直以为Dialog是子窗口，至少从直观上来说Dialog应该是个子窗口。

  但实际上Dialog的确是一个应用窗口。我们看下Dialog的show()方法就知道了。

    public void show() {
        ……
        if (!mCreated) {
            dispatchOnCreate(null);
        }

        onStart();
        mDecor = mWindow.getDecorView();
		……
        WindowManager.LayoutParams l = mWindow.getAttributes();
		……
        try {
            mWindowManager.addView(mDecor, l);
            mShowing = true;
    
            sendShowMessage();
        } finally {
        }
    }

public abstract class Window {

	// The current window attributes.
    private final WindowManager.LayoutParams mWindowAttributes =
        new WindowManager.LayoutParams();

	/**
     * Retrieve the current window attributes associated with this panel.
     *
     * @return WindowManager.LayoutParams Either the existing window
     *         attributes object, or a freshly created one if there is none.
     */
    public final WindowManager.LayoutParams getAttributes() {
        return mWindowAttributes;
    }
}

public interface WindowManager extends ViewManager {

	public static class LayoutParams extends ViewGroup.LayoutParams
            implements Parcelable {

		public LayoutParams() {
            super(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT);
            type = TYPE_APPLICATION;
            format = PixelFormat.OPAQUE;
        }
	}
}

  从代码中可以看到Dialog的WindowManager.LayoutParams是从Window中直接取出来的。而Window.getAttributes()返回的LayoutParams是用无参构造函数创建的，这时LayoutParams.type的值为TYPE_APPLICATION（TYPE_APPLICATION = 2），位于应用Window的层级范围内，所以Dialog属于应用窗口。
  那么应用窗口和子窗口就仅仅只是LayoutParams.type的差别？在UI方面就没有直观的差别了吗？
  要搞清楚上面的问题，就得先回顾下控件与子控件的关系。将子控件加入父控件时需要为子控件设置一个布局参数，即LayoutParams。这个布局参数是指子控件相对于父控件的布局参数。例如：当父控件B为FrameLayout时，为子控件C设置布局参数FrameLayout.LayoutParams(WRAP_CONTENT, WRAP_CONTENT, Gravity.TOP)。这里的Gravity.TOP是指父控件的顶部，也就是相对于控件B的位置。所以控件C位于控件B顶部，而不是控件A的顶部。

  Window也有布局参数，即WindowManager.LayoutParams。同理，WindowManager.LayoutParams也应该是窗口相对于父窗口的布局参数。经过观察，我得出了这样一个结论：应用窗口的WindowManager.LayoutParams是相对于屏幕，而子窗口的WindowManager.LayoutParams相对于应用窗口。
  下面我们通过一个Demo来验证一下。下面的代码中先将WindowTestActivity的窗口高度设置成屏幕的一半，然后再弹出一个应用窗口，且该应用窗口在纵向上偏移屏幕高度的一半。

public class WindowTestActivity extends Activity {

    private Button popupWin;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_window_test);//布局文件中就只有几个按钮而已，所以就不贴出来了。
    }

    boolean isFirst = true;
    @Override
    public void onWindowFocusChanged(boolean hasFocus) {
        super.onWindowFocusChanged(hasFocus);
        if (hasFocus && isFirst) {
            isFirst = false;
            DisplayMetrics dm = getResources().getDisplayMetrics();
            WindowManager.LayoutParams wmLp = getWindow().getAttributes();
            wmLp.height = dm.heightPixels/2;//将Activity的窗口高度设置为屏幕的一半
            wmLp.gravity = Gravity.TOP;//Activity的窗口位于屏幕顶部
//            wmLp.y = 100;//Activity的窗口位置在纵向上偏移屏幕顶部100个像素
            getWindow().setAttributes(wmLp);
        }
    }

    /**
     * 弹出应用窗口
     * @param view
     */
    public void onClickPopupApplicationWindow(View view) {
        DisplayMetrics dm = getResources().getDisplayMetrics();
        //调用无参构造函数，wLayoutParams.type = TYPE_APPLICATION，说明该窗口是应用窗口
        WindowManager.LayoutParams wLayoutParams = new WindowManager.LayoutParams();
        wLayoutParams.width = dm.widthPixels/2;//窗口的宽度设置成屏幕宽度的一半
        wLayoutParams.height = dm.heightPixels/4;//窗口的高度设置成屏幕高度的四分之一
        wLayoutParams.gravity = Gravity.CENTER_HORIZONTAL|Gravity.TOP;//窗口水平居中且位于屏幕顶部
        wLayoutParams.y = dm.heightPixels/2;//窗口的位置在纵向上偏移屏幕高度的一半
        wLayoutParams.dimAmount = 0.4f;//当前窗口后方增加阴影时阴影的透明度
        /*
        WindowManager.LayoutParams.flags中增加WindowManager.LayoutParams.FLAG_DIM_BEHIND
        表示当前窗口后方增加阴影；其余三个flag是为了将窗口外围的点击事件透传到后方的窗口
         */
        wLayoutParams.flags = WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE
                |WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL
                | WindowManager.LayoutParams.FLAG_LAYOUT_IN_SCREEN
                |WindowManager.LayoutParams.FLAG_DIM_BEHIND;
        popupWin = new Button(this);
        popupWin.setGravity(Gravity.CENTER);
        popupWin.setText("这里是弹出的应用窗口");
        popupWin.setBackgroundResource(R.color.colorAccent);
        popupWin.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                getWindowManager().removeView(popupWin);//移除应用窗口
                popupWin = null;
            }
        });
        getWindowManager().addView(popupWin, wLayoutParams);//弹出应用窗口

    }
}

  上图中，我们可以看到Activity的DecorView的高度只占了屏幕高度的一半，且弹出的应用窗口紧接在它的正下方。那么现在将代码中wmLp.y = 100;的注释去掉，令Activity的DecorView在纵向上偏移100个像素。看看效果是怎么样的。

  从图中可以看到Activity的DecorView虽然纵向偏移了100个像素，但是弹出的应用窗口的位置却没有变，即并没有随着Activity的DecorView一起偏移。这说明了这个应用窗口的WindowManager.LayoutParams是相对于屏幕的，而不是相对于Activity的DecorView。
  PopupWindow.showAtLocation(View parent, int gravity, int x, int y)是相对于整个窗口来显示PopupWindow的。至于相对于哪个窗口，就取决于参数parent属于哪个窗口。在上面的代码中，再新增如下显示PopupWindow的代码。

public class WindowTestActivity extends Activity {

	private Button popupWin;
	……
	/**
     * 在Activity的DecorView上弹出PopupWindow
     * @param view
     */
    public void onClickOnDecorViewPopupSubWindow(View view) {
        Button btn = new Button(this);
        btn.setGravity(Gravity.CENTER);
        btn.setAllCaps(false);
        btn.setText("在DecorView上弹出的PopupWindow");
        btn.setBackgroundResource(R.color.colorPrimary);
        PopupWindow popupWindow = new PopupWindow(btn, ViewGroup.LayoutParams.MATCH_PARENT, 200, true);
        popupWindow.setBackgroundDrawable(new BitmapDrawable());
        popupWindow.showAtLocation(view, Gravity.BOTTOM, 0, 0);
    }

    /**
     * 在弹出的应用窗口上弹出PopupWindow
     * @param view
     */
    public void onClickOnPopupAppWinPopupSubWin(View view) {
        if (popupWin != null) {
            Button btn = new Button(this);
            btn.setGravity(Gravity.CENTER);
            btn.setAllCaps(false);
            btn.setText("在已弹出的应用窗口上弹出的PopupWindow");
            btn.setBackgroundResource(R.color.colorPrimary);
            PopupWindow popupWindow = new PopupWindow(btn, ViewGroup.LayoutParams.MATCH_PARENT, 200, true);
            popupWindow.setBackgroundDrawable(new BitmapDrawable());
            popupWindow.showAtLocation(popupWin, Gravity.BOTTOM, 0, 0);//以弹出的应用窗口作为parent
        }
    }
}

  从代码和效果图中可以看出来，只因为参数parent不同，就使得PopupWindow的相对位置不同。而PopupWindow是一个子窗口，所以子窗口的WindowManager.LayoutParams是相对于应用窗口的。

LayoutParams.token

  WindowManager.LayoutParams.token在代码中的注释是指标识窗口。

 /**
 * Identifier for this window.  This will usually be filled in for
 * you.
 */
 public IBinder token = null;

  那为什么要标识窗口呢。我们先来看看应用窗口和子窗口的token分别是什么。
  不论是Activity还是Dialog的WindowManager.LayoutParams.token都是被赋值了ActivityRecord.appToken。而ActivityRecord.appToken就是Activity的一个标识。所以应用窗口的token是为了标识该应用窗口属于哪个Activity。
  如果不了解Activity与Dialog的WindowManager.LayoutParams.token赋值过程的同学，可以看看下面这两篇文章
ActivityRecord、ActivityClientRecord、Activity的关系
Android窗口机制（五）最终章：WindowManager.LayoutParams和Token以及其他窗口Dialog，Toast

  接着再来看看PopupWindow

public class PopupWindow {
	private int mWindowLayoutType = WindowManager.LayoutParams.TYPE_APPLICATION_PANEL;

	public void showAtLocation(View parent, int gravity, int x, int y) {
        showAtLocation(parent.getWindowToken(), gravity, x, y);
    }

	public void showAtLocation(IBinder token, int gravity, int x, int y) {
        if (isShowing() || mContentView == null) {
            return;
        }
        ……
        final WindowManager.LayoutParams p = createPopupLayoutParams(token);
        ……
        invokePopup(p);
    }
	private WindowManager.LayoutParams createPopupLayoutParams(IBinder token) {
        final WindowManager.LayoutParams p = new WindowManager.LayoutParams();

        // These gravity settings put the view at the top left corner of the
        // screen. The view is then positioned to the appropriate location by
        // setting the x and y offsets to match the anchor's bottom-left
        // corner.
        p.gravity = Gravity.START | Gravity.TOP;
        p.flags = computeFlags(p.flags);
        p.type = mWindowLayoutType;
        p.token = token;
        ……
        return p;
    }
}

  从代码中可以看到PopupWindow中WindowManager.LayoutParams.type = WindowManager.LayoutParams.TYPE_APPLICATION_PANEL。TYPE_APPLICATION_PANEL = 1000，属于子窗口层级。所以PopupWindow是子窗口。
  另外我们还发现PopupWindow中WindowManager.LayoutParams.token的值并不是ActivityRecord.appToken，而是View…getWindowToken()，也就是AttachInfo.mWindowToken。

public class View {

	/**
     * Retrieve a unique token identifying the window this view is attached to.
     * @return Return the window's token for use in
     * {@link WindowManager.LayoutParams#token WindowManager.LayoutParams.token}.
     */
    public IBinder getWindowToken() {
        return mAttachInfo != null ? mAttachInfo.mWindowToken : null;
    }
}

  一个根View及其下的所有子View都拥有相同的AttachInfo，mWindowToken自然也就相同。而根View又代表着一个窗口，所以mWindowToken可以标识一个窗口。对此不了解的同学可以查看这篇文章
Android窗口机制（五）最终章：WindowManager.LayoutParams和Token以及其他窗口Dialog，Toast
  由此得出一个结论：子窗口的token是为了标识哪一个应用窗口是它的父窗口。