Android添加系统级顶层窗口 和 WindowManager添加view的动画问题

Context applicationContext = mainActivity.getApplicationContext();
AlertDialog.Builder dlgBuilder = new AlertDialog.Builder(applicationContext);
AlertDialog dialog = dlgBuilder.create();
dialog.getWindow().setType(WindowManager.LayoutParams.TYPE_SYSTEM_ALERT);

public class Dialog implements DialogInterface, Window.Callback, KeyEvent.Callback, OnCreateContextMenuListener

/**
* Create a Dialog window that uses the default dialog frame style.
*
* @param context The Context the Dialog is to run it. In particular, it
* uses the window manager and theme in this context to
* present its UI.
*/
public Dialog(Context context) {
this(context, 0, true);
} /**
* Create a Dialog window that uses a custom dialog style.
*
* @param context The Context in which the Dialog should run. In particular, it
* uses the window manager and theme from this context to
* present its UI.
* @param theme A style resource describing the theme to use for the
* window. See <a href="{@docRoot}guide/topics/resources/available-resources.html#stylesandthemes">Style
* and Theme Resources</a> for more information about defining and using
* styles. This theme is applied on top of the current theme in
* <var>context</var>. If 0, the default dialog theme will be used.
*/
public Dialog(Context context, int theme) {
this(context, theme, true);
} Dialog(Context context, int theme, boolean createContextThemeWrapper) {
if (createContextThemeWrapper) {
if (theme == 0) {
TypedValue outValue = new TypedValue();
context.getTheme().resolveAttribute(com.android.internal.R.attr.dialogTheme,
outValue, true);
theme = outValue.resourceId;
}
mContext = new ContextThemeWrapper(context, theme);
} else {
mContext = context;
} mWindowManager = (WindowManager)context.getSystemService(Context.WINDOW_SERVICE);
Window w = PolicyManager.makeNewWindow(mContext);
mWindow = w;
w.setCallback(this);
w.setWindowManager(mWindowManager, null, null);
w.setGravity(Gravity.CENTER);
mListenersHandler = new ListenersHandler(this);
}

/**
* Start the dialog and display it on screen. The window is placed in the
* application layer and opaque. Note that you should not override this
* method to do initialization when the dialog is shown, instead implement
* that in {@link #onStart}.
*/
public void show() {
if (mShowing) {
if (mDecor != null) {
if (mWindow.hasFeature(Window.FEATURE_ACTION_BAR)) {
mWindow.invalidatePanelMenu(Window.FEATURE_ACTION_BAR);
}
mDecor.setVisibility(View.VISIBLE);
}
return;
} mCanceled = false; if (!mCreated) {
dispatchOnCreate(null);
} onStart();
mDecor = mWindow.getDecorView(); if (mActionBar == null && mWindow.hasFeature(Window.FEATURE_ACTION_BAR)) {
final ApplicationInfo info = mContext.getApplicationInfo();
mWindow.setDefaultIcon(info.icon);
mWindow.setDefaultLogo(info.logo);
mActionBar = new ActionBarImpl(this);
} WindowManager.LayoutParams l = mWindow.getAttributes();
if ((l.softInputMode
& WindowManager.LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION) == 0) {
WindowManager.LayoutParams nl = new WindowManager.LayoutParams();
nl.copyFrom(l);
nl.softInputMode |=
WindowManager.LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION;
l = nl;
} try {
mWindowManager.addView(mDecor, l);
mShowing = true; sendShowMessage();
} finally {
}
}

<!-- Variant of {@link #Theme_Translucent} that has no title bar and
no status bar -->
<style name="Theme.Translucent.NoTitleBar.Fullscreen">
<item name="android:windowFullscreen">true</item>
</style> <!-- Default theme for activities that don't actually display a UI; that
is, they finish themselves before being resumed. -->
<style name="Theme.NoDisplay">
<item name="android:windowBackground">@null</item>
<item name="android:windowContentOverlay">@null</item>
<item name="android:windowIsTranslucent">true</item>
<item name="android:windowAnimationStyle">@null</item>
<item name="android:windowDisablePreview">true</item>
<item name="android:windowNoDisplay">true</item>
</style> <!-- Default theme for dialog windows and activities (on API level 10 and lower),
which is used by the
{@link android.app.Dialog} class. This changes the window to be
floating (not fill the entire screen), and puts a frame around its
contents. You can set this theme on an activity if you would like to
make an activity that looks like a Dialog. -->
<style name="Theme.Dialog">
<item name="android:windowFrame">@null</item>
<item name="android:windowTitleStyle">@android:style/DialogWindowTitle</item>
<item name="android:windowBackground">@android:drawable/panel_background</item>
<item name="android:windowIsFloating">true</item>
<item name="android:windowContentOverlay">@null</item>
<item name="android:windowAnimationStyle">@android:style/Animation.Dialog</item>
<item name="android:windowSoftInputMode">stateUnspecified|adjustPan</item>
<item name="android:windowCloseOnTouchOutside">@bool/config_closeDialogWhenTouchOutside</item>
<item name="android:windowActionModeOverlay">true</item> <item name="android:colorBackgroundCacheHint">@null</item> <item name="textAppearance">@android:style/TextAppearance</item>
<item name="textAppearanceInverse">@android:style/TextAppearance.Inverse</item> <item name="textColorPrimary">@android:color/primary_text_dark</item>
<item name="textColorSecondary">@android:color/secondary_text_dark</item>
<item name="textColorTertiary">@android:color/tertiary_text_dark</item>
<item name="textColorPrimaryInverse">@android:color/primary_text_light</item>
<item name="textColorSecondaryInverse">@android:color/secondary_text_light</item>
<item name="textColorTertiaryInverse">@android:color/tertiary_text_light</item>
<item name="textColorPrimaryDisableOnly">@android:color/primary_text_dark_disable_only</item>
<item name="textColorPrimaryInverseDisableOnly">@android:color/primary_text_light_disable_only</item>
<item name="textColorPrimaryNoDisable">@android:color/primary_text_dark_nodisable</item>
<item name="textColorSecondaryNoDisable">@android:color/secondary_text_dark_nodisable</item>
<item name="textColorPrimaryInverseNoDisable">@android:color/primary_text_light_nodisable</item>
<item name="textColorSecondaryInverseNoDisable">@android:color/secondary_text_light_nodisable</item>
<item name="textColorHint">@android:color/hint_foreground_dark</item>
<item name="textColorHintInverse">@android:color/hint_foreground_light</item>
<item name="textColorSearchUrl">@android:color/search_url_text</item> <item name="textAppearanceLarge">@android:style/TextAppearance.Large</item>
<item name="textAppearanceMedium">@android:style/TextAppearance.Medium</item>
<item name="textAppearanceSmall">@android:style/TextAppearance.Small</item>
<item name="textAppearanceLargeInverse">@android:style/TextAppearance.Large.Inverse</item>
<item name="textAppearanceMediumInverse">@android:style/TextAppearance.Medium.Inverse</item>
<item name="textAppearanceSmallInverse">@android:style/TextAppearance.Small.Inverse</item> <item name="listPreferredItemPaddingLeft">10dip</item>
<item name="listPreferredItemPaddingRight">10dip</item>
<item name="listPreferredItemPaddingStart">10dip</item>
<item name="listPreferredItemPaddingEnd">10dip</item> <item name="preferencePanelStyle">@style/PreferencePanel.Dialog</item>
</style> <!-- Variant of {@link Theme_Dialog} that does not include a frame (or background).
The view hierarchy of the dialog is responsible for drawing all of
its pixels. -->
<style name="Theme.Dialog.NoFrame">
<item name="windowBackground">@android:color/transparent</item>
<item name="android:windowFrame">@null</item>
<item name="windowContentOverlay">@null</item>
<item name="android:windowAnimationStyle">@null</item>
<item name="android:backgroundDimEnabled">false</item>
<item name="android:windowIsTranslucent">true</item>
<item name="android:windowNoTitle">true</item>
<item name="android:windowCloseOnTouchOutside">false</item>
</style> <!-- Default theme for alert dialog windows (on API level 10 and lower), which is used by the
{@link android.app.AlertDialog} class. This is basically a dialog
but sets the background to empty so it can do two-tone backgrounds. -->
<style name="Theme.Dialog.Alert">
<item name="windowBackground">@android:color/transparent</item>
<item name="windowTitleStyle">@android:style/DialogWindowTitle</item>
<item name="windowContentOverlay">@null</item>
<item name="itemTextAppearance">@android:style/TextAppearance.Large.Inverse</item>
<item name="textAppearanceListItem">@android:style/TextAppearance.Large.Inverse</item>
<item name="textAppearanceListItemSmall">@android:style/TextAppearance.Large.Inverse</item>
</style>

<activity
android:name=".AlertActivity"
android:excludeFromRecents="true"
android:finishOnTaskLaunch="true"
android:launchMode="singleInstance"
android:theme="@*android:style/Theme.Dialog.Alert" >
</activity>

package com.android.autologin;import android.app.Activity;
import android.content.DialogInterface;
import android.content.DialogInterface.OnDismissListener;
import android.os.Bundle;/**
* This is the dialog Activity used as an AlertDialog for the user to interact.
* Requires android:launchMode="singleInstance" in your AndroidManifest to work
* properly.
* <p/>
* 当Dialog有编辑框时如果选择会弹菜单窗口就不要用 AlertDialog(Application)
* 再添加WindowManager.LayoutParams. TYPE_SYSTEM_ALERT，
* <pre>
* Context applicationContext = mainActivity.getApplicationContext();
* AlertDialog.Builder dlgBuilder = new AlertDialog.Builder(applicationContext);
* EditText et = new EditText(mainActivity);
* dlgBuilder.setTitle(mainActivity.getTitle());
* dlgBuilder.setPositiveButton(android.R.string.ok, null);
* dlgBuilder.setNegativeButton(android.R.string.cancel, null);
* dlgBuilder.setIcon(android.R.drawable.ic_dialog_alert);
* dlgBuilder.setView(et);
* AlertDialog dialog = dlgBuilder.create();
* dialog.getWindow().setType(WindowManager.LayoutParams.TYPE_SYSTEM_ALERT);
* dialog.show();
* </pre>
* 防止报错
* attrs.token = null,
* BadTokenException("Unable to add window -- token " + attrs.token + " is not for an application")
*
* @usage
*
* <i>.java</i>
*
* <code><pre>
* Intent dialogIntent = new Intent(mContext, AlertActivity.class);
* dialogIntent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
* mContext.startActivity(dialogIntent);
* </pre></code>
*
* <i>AndroidManifest.xml</i>
*
* <pre>
* < activity
* android:name=".AlertActivity"
* android:excludeFromRecents="true"
* android:finishOnTaskLaunch="true"
* android:launchMode="singleInstance"
* android:theme="@android:style/Theme.Dialog" >
* < /activity>
* </pre>
*
* @author Sansan
**/
public class AlertActivity extends Activity implements DialogInterface.OnClickListener, OnDismissListener { @Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState); // setContentView(R.layout.alertactivity); // Get root view from current activity
// @see http://stackoverflow.com/questions/4486034/get-root-view-from-current-activity // //rootview
//// check layouts in hierarchyviewer. // findViewById(android.R.id.content) is giving me the root view
// findViewById(android.R.id.content).getRootView()
//getWindow().getDecorView().findViewById(android.R.id.content) // //-------------------------------------------------------------------------------------------
// //This is what I use to get the root view as found in the XML file assigned with setContentView
// //This answer gave the view without the status bar - which is what I wanted. I was looking for
// //the pixel width + height of the visible part of the activity. This one works, thanks!
//
//This excludes ActionBar!
//final ViewGroup viewGroup = (ViewGroup) ((ViewGroup) this.findViewById(android.R.id.content)).getChildAt(0);
// //------------------------------------------------------------------------------------------- // //-------------------------------------------------------------------------------------------
// //I tested this in android 4.0.3, only:
//
// getWindow().getDecorView().getRootView();
//
// //give the same view what we get from
//
// anyview.getRootView(); == com.android.internal.policy.impl.PhoneWindow$DecorView@#########
//
// //and
//
// getWindow().getDecorView().findViewById(android.R.id.content) // //giving child of its == android.widget.FrameLayout@#######
// //Please confirm.
// //------------------------------------------------------------------------------------------- //setVisible(true);
//requestWindowFeature(Window.FEATURE_NO_TITLE);//去掉标题栏 // //Error, if select any text to pop up a system menu view, such as
// paste in
// // the Dialog.
// //@see android/view/ViewRootImpl.java
// //case WindowManagerGlobal.ADD_NOT_APP_TOKEN: throw new
// //WindowManager.BadTokenException("Unable to add window -- token " +
// //attrs.token + " is not for an application");
// Context applicationContext = this.getApplicationContext();
// AlertDialog.Builder dlgBuilder = new
// AlertDialog.Builder(applicationContext); //AlertDialog.Builder dlgBuilder = new AlertDialog.Builder(this);
//EditText et = new EditText(this); //dlgBuilder.setTitle(this.getTitle());
//dlgBuilder.setPositiveButton(android.R.string.ok, AlertActivity.this);
//dlgBuilder.setNegativeButton(android.R.string.cancel, AlertActivity.this);
//dlgBuilder.setIcon(android.R.drawable.ic_dialog_alert);
//dlgBuilder.setView(et);
//AlertDialog dialog = dlgBuilder.create();
//dialog.getWindow().setType(WindowManager.LayoutParams.TYPE_SYSTEM_ALERT);
//dialog.setCanceledOnTouchOutside(false);
//dialog.setOnDismissListener(this);
//dialog.show(); // //DialogFragment
// FragmentTransaction ft = getFragmentManager().beginTransaction();
// DialogFragment newFragment = MyDialogFragment.newInstance();
// ft.add(android.R.id.content, newFragment);
// ft.commit();
} //// @TargetApi(Build.VERSION_CODES.HONEYCOMB)
// public static class MyDialogFragment extends DialogFragment {
// static MyDialogFragment newInstance() {
// return new MyDialogFragment();
// }
//
// @Override
// public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
// //View v = inflater.inflate(R.layout.alertdialog, container, false);
// getActivity().getWindow().setType(WindowManager.LayoutParams.TYPE_SYSTEM_ALERT);
// return new EditText(getActivity());
// }
// } /**
* meanwhile, finish the AlertActivity.
*/
@Override
public void onDismiss(DialogInterface dialog) {
//finish();
} @Override
public void onClick(DialogInterface dialog, int which) { }
}

Context applicationContext = mainActivity.getApplicationContext();
WindowManager applicationWindowManager = (WindowManager) applicationContext.getSystemService(Context.WINDOW_SERVICE);
AlertDialog.Builder dlgBuilder = new AlertDialog.Builder(mainActivity);
EditText et = new EditText(mainActivity); // Dialog界面
dlgBuilder.setTitle(mainActivity.getTitle());
dlgBuilder.setPositiveButton(android.R.string.ok, null);
dlgBuilder.setNegativeButton(android.R.string.cancel, null);
dlgBuilder.setIcon(android.R.drawable.ic_dialog_alert);
dlgBuilder.setView(et);
AlertDialog dialog = dlgBuilder.create();
// dialog.getWindow().getAttributes().token = mainActivity.getWindow().getAttributes().token;
//
try {
Field mWindowManagerField = Dialog.class.getDeclaredField("mWindowManager");
mWindowManagerField.setAccessible(true);
mWindowManagerField.set(dialog, applicationWindowManager);
} catch (NoSuchFieldException e) {
// TODO Auto-generated catch block
Alog.w(TAG, e.toString());
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
Alog.w(TAG, e.toString());
} catch (IllegalArgumentException e) {
// TODO Auto-generated catch block
Alog.w(TAG, e.toString());
} dialog.getWindow().setType(WindowManager.LayoutParams.TYPE_SYSTEM_ALERT);
// dialog.getWindow().addFlags(android.R.attr.windowIsFloating);
dialog.show();

/**
* Return whether this window is being displayed with a floating style
* (based on the {@link android.R.attr#windowIsFloating} attribute in
* the style/theme).
*
* @return Returns true if the window is configured to be displayed floating
* on top of whatever is behind it.
*/
public abstract boolean isFloating(); /**
* Set the width and height layout parameters of the window. The default
* for both of these is MATCH_PARENT; you can change them to WRAP_CONTENT
* or an absolute value to make a window that is not full-screen.
*
* @param width The desired layout width of the window.
* @param height The desired layout height of the window.
*
* @see ViewGroup.LayoutParams#height
* @see ViewGroup.LayoutParams#width
*/
public void setLayout(int width, int height) {
final WindowManager.LayoutParams attrs = getAttributes();
attrs.width = width;
attrs.height = height;
if (mCallback != null) {
mCallback.onWindowAttributesChanged(attrs);
}
} /**
* Set the gravity of the window, as per the Gravity constants. This
* controls how the window manager is positioned in the overall window; it
* is only useful when using WRAP_CONTENT for the layout width or height.
*
* @param gravity The desired gravity constant.
*
* @see Gravity
* @see #setLayout
*/
public void setGravity(int gravity)
{
final WindowManager.LayoutParams attrs = getAttributes();
attrs.gravity = gravity;
if (mCallback != null) {
mCallback.onWindowAttributesChanged(attrs);
}
} /**
* Set the type of the window, as per the WindowManager.LayoutParams
* types.
*
* @param type The new window type (see WindowManager.LayoutParams).
*/
public void setType(int type) {
final WindowManager.LayoutParams attrs = getAttributes();
attrs.type = type;
if (mCallback != null) {
mCallback.onWindowAttributesChanged(attrs);
}
} /**
* Set the format of window, as per the PixelFormat types. This overrides
* the default format that is selected by the Window based on its
* window decorations.
*
* @param format The new window format (see PixelFormat). Use
* PixelFormat.UNKNOWN to allow the Window to select
* the format.
*
* @see PixelFormat
*/
public void setFormat(int format) {
final WindowManager.LayoutParams attrs = getAttributes();
if (format != PixelFormat.UNKNOWN) {
attrs.format = format;
mHaveWindowFormat = true;
} else {
attrs.format = mDefaultWindowFormat;
mHaveWindowFormat = false;
}
if (mCallback != null) {
mCallback.onWindowAttributesChanged(attrs);
}
} /**
* Specify custom animations to use for the window, as per
* {@link WindowManager.LayoutParams#windowAnimations
* WindowManager.LayoutParams.windowAnimations}. Providing anything besides
* 0 here will override the animations the window would
* normally retrieve from its theme.
*/
public void setWindowAnimations(int resId) {
final WindowManager.LayoutParams attrs = getAttributes();
attrs.windowAnimations = resId;
if (mCallback != null) {
mCallback.onWindowAttributesChanged(attrs);
}
} /**
* Specify an explicit soft input mode to use for the window, as per
* {@link WindowManager.LayoutParams#softInputMode
* WindowManager.LayoutParams.softInputMode}. Providing anything besides
* "unspecified" here will override the input mode the window would
* normally retrieve from its theme.
*/
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;
}
if (mCallback != null) {
mCallback.onWindowAttributesChanged(attrs);
}
} /**
* Convenience function to set the flag bits as specified in flags, as
* per {@link #setFlags}.
* @param flags The flag bits to be set.
* @see #setFlags
* @see #clearFlags
*/
public void addFlags(int flags) {
setFlags(flags, flags);
} /** @hide */
public void addPrivateFlags(int flags) {
setPrivateFlags(flags, flags);
} /**
* Convenience function to clear the flag bits as specified in flags, as
* per {@link #setFlags}.
* @param flags The flag bits to be cleared.
* @see #setFlags
* @see #addFlags
*/
public void clearFlags(int flags) {
setFlags(0, flags);
} /**
* Set the flags of the window, as per the
* {@link WindowManager.LayoutParams WindowManager.LayoutParams}
* flags.
*
* <p>Note that some flags must be set before the window decoration is
* created (by the first call to
* {@link #setContentView(View, android.view.ViewGroup.LayoutParams)} or
* {@link #getDecorView()}:
* {@link WindowManager.LayoutParams#FLAG_LAYOUT_IN_SCREEN} and
* {@link WindowManager.LayoutParams#FLAG_LAYOUT_INSET_DECOR}. These
* will be set for you based on the {@link android.R.attr#windowIsFloating}
* attribute.
*
* @param flags The new window flags (see WindowManager.LayoutParams).
* @param mask Which of the window flag bits to modify.
* @see #addFlags
* @see #clearFlags
*/
public void setFlags(int flags, int mask) {
final WindowManager.LayoutParams attrs = getAttributes();
attrs.flags = (attrs.flags&~mask) | (flags&mask);
if ((mask&WindowManager.LayoutParams.FLAG_NEEDS_MENU_KEY) != 0) {
attrs.privateFlags |= WindowManager.LayoutParams.PRIVATE_FLAG_SET_NEEDS_MENU_KEY;
}
mForcedWindowFlags |= mask;
if (mCallback != null) {
mCallback.onWindowAttributesChanged(attrs);
}
} private void setPrivateFlags(int flags, int mask) {
final WindowManager.LayoutParams attrs = getAttributes();
attrs.privateFlags = (attrs.privateFlags & ~mask) | (flags & mask);
if (mCallback != null) {
mCallback.onWindowAttributesChanged(attrs);
}
} /**
* Set the amount of dim behind the window when using
* {@link WindowManager.LayoutParams#FLAG_DIM_BEHIND}. This overrides
* the default dim amount of that is selected by the Window based on
* its theme.
*
* @param amount The new dim amount, from 0 for no dim to 1 for full dim.
*/
public void setDimAmount(float amount) {
final WindowManager.LayoutParams attrs = getAttributes();
attrs.dimAmount = amount;
mHaveDimAmount = true;
if (mCallback != null) {
mCallback.onWindowAttributesChanged(attrs);
}
} /**
* Specify custom window attributes. <strong>PLEASE NOTE:</strong> the
* layout params you give here should generally be from values previously
* retrieved with {@link #getAttributes()}; you probably do not want to
* blindly create and apply your own, since this will blow away any values
* set by the framework that you are not interested in.
*
* @param a The new window attributes, which will completely override any
* current values.
*/
public void setAttributes(WindowManager.LayoutParams a) {
mWindowAttributes.copyFrom(a);
if (mCallback != null) {
mCallback.onWindowAttributesChanged(mWindowAttributes);
}
} /**
* 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;
}

WindowManager.LayoutParams 是 WindowManager 接口的嵌套类；它继承于 ViewGroup.LayoutParams； 它用于向WindowManager描述Window的管理策略。

final Window win = getWindow();
win.addFlags(WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED);//覆盖在屏幕锁之上。
PowerManager pm = (PowerManager) getSystemService(Context.POWER_SERVICE);
if (!pm.isScreenOn()) {//屏幕时候保持高亮
win.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON
| WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON
| WindowManager.LayoutParams.FLAG_ALLOW_LOCK_WHILE_SCREEN_ON
| WindowManager.LayoutParams.FLAG_LAYOUT_INSET_DECOR);
}

type 的取值：
      应用程序窗口。
      public static final int FIRST_APPLICATION_WINDOW = 1;   
 
      所有程序窗口的“基地”窗口，其他应用程序窗口都显示在它上面。    
      public static final int TYPE_BASE_APPLICATION   =1;
        
      普通应用功能程序窗口。token必须设置为Activity的token，以指出该窗口属谁。
      public static final int TYPE_APPLICATION       = 2;
 
       用于应用程序启动时所显示的窗口。应用本身不要使用这种类型。
      它用于让系统显示些信息，直到应用程序可以开启自己的窗口。  
      public static final int TYPE_APPLICATION_STARTING = 3;
      
      应用程序窗口结束。
      public static final int LAST_APPLICATION_WINDOW = 99;
 
      子窗口。子窗口的Z序和坐标空间都依赖于他们的宿主窗口。
      public static final int FIRST_SUB_WINDOW       = 1000;
 
      面板窗口，显示于宿主窗口上层。
      public static final int TYPE_APPLICATION_PANEL  = FIRST_SUB_WINDOW;
 
      媒体窗口，例如视频。显示于宿主窗口下层。
      public static final int TYPE_APPLICATION_MEDIA  = FIRST_SUB_WINDOW+1;
 
      应用程序窗口的子面板。显示于所有面板窗口的上层。（GUI的一般规律，越“子”越靠上）
      public static final int TYPE_APPLICATION_SUB_PANEL = FIRST_SUB_WINDOW +2;
 
      对话框。类似于面板窗口，绘制类似于顶层窗口，而不是宿主的子窗口。
      public static final int TYPE_APPLICATION_ATTACHED_DIALOG = FIRST_SUB_WINDOW +3;
 
      媒体信息。显示在媒体层和程序窗口之间，需要实现透明（半透明）效果。（例如显示字幕）
      public static final int TYPE_APPLICATION_MEDIA_OVERLAY  = FIRST_SUB_WINDOW +4;
 
      子窗口结束。（ End of types of sub-windows ）
      public static final int LAST_SUB_WINDOW        = 1999;
 
      系统窗口。非应用程序创建。
      public static final int FIRST_SYSTEM_WINDOW    = 2000;
 
      状态栏。只能有一个状态栏；它位于屏幕顶端，其他窗口都位于它下方。
      public static final int TYPE_STATUS_BAR        =  FIRST_SYSTEM_WINDOW;
 
      搜索栏。只能有一个搜索栏；它位于屏幕上方。
      public static final int TYPE_SEARCH_BAR        = FIRST_SYSTEM_WINDOW+1;
 
      电话窗口。它用于电话交互（特别是呼入）。它置于所有应用程序之上，状态栏之下。
      public static final int TYPE_PHONE            = FIRST_SYSTEM_WINDOW+2;
 
      系统提示。它总是出现在应用程序窗口之上。
      public static final int TYPE_SYSTEM_ALERT      =  FIRST_SYSTEM_WINDOW +3;
 
      锁屏窗口。
      public static final int TYPE_KEYGUARD          = FIRST_SYSTEM_WINDOW +4;
 
      信息窗口。用于显示toast。
      public static final int TYPE_TOAST            = FIRST_SYSTEM_WINDOW +5;
 
      系统顶层窗口。显示在其他一切内容之上。此窗口不能获得输入焦点，否则影响锁屏。
      public static final int TYPE_SYSTEM_OVERLAY    =  FIRST_SYSTEM_WINDOW +6;
 
      电话优先，当锁屏时显示。此窗口不能获得输入焦点，否则影响锁屏。
      public static final int TYPE_PRIORITY_PHONE    =  FIRST_SYSTEM_WINDOW +7;
 
      系统对话框。（例如音量调节框）。
      public static final int TYPE_SYSTEM_DIALOG     =  FIRST_SYSTEM_WINDOW +8;
 
      锁屏时显示的对话框。
      public static final int TYPE_KEYGUARD_DIALOG   =  FIRST_SYSTEM_WINDOW +9;
 
      系统内部错误提示，显示于所有内容之上。
      public static final int TYPE_SYSTEM_ERROR      =  FIRST_SYSTEM_WINDOW +10;
 
      内部输入法窗口，显示于普通UI之上。应用程序可重新布局以免被此窗口覆盖。
      public static final int TYPE_INPUT_METHOD      =  FIRST_SYSTEM_WINDOW +11;
 
      内部输入法对话框，显示于当前输入法窗口之上。
      public static final int TYPE_INPUT_METHOD_DIALOG= FIRST_SYSTEM_WINDOW +12;
 
      墙纸窗口。
      public static final int TYPE_WALLPAPER         = FIRST_SYSTEM_WINDOW +13;
 
      状态栏的滑动面板。
      public static final int TYPE_STATUS_BAR_PANEL   = FIRST_SYSTEM_WINDOW +14;
 
      系统窗口结束。
      public static final int LAST_SYSTEM_WINDOW     = 2999;