private void openNewWindow() {
    Button button = new Button(this);    
    button.setText("Button On New Window");
    WindowManager.LayoutParams params
            = new WindowManager.LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT,
            ViewGroup.LayoutParams.WRAP_CONTENT);
    params.gravity = Gravity.LEFT | Gravity.TOP;
    params.x = 220;
    params.y = 320;
    params.type = WindowManager.LayoutParams.TYPE_SYSTEM_ALERT;
    params.flags = WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL;
    WindowManager windowManager = (WindowManager) getSystemService(WINDOW_SERVICE);
    windowManager.addView(button, params);
}

public abstract class Window {
  // 一系列的FEATURE_xx常量，還記得在Activity中requestWindowFeature方法嗎？
  public static final int FEATURE_xxx

  /**
   * API from a Window back to its caller.
   * This allows the client to intercept key
   * dispatching, panels and menus, etc.
   */
  private Callback mCallback;
  // The interface that apps use to talk to the window manager.
  private WindowManager mWindowManager;

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

  /**
   * The ID that the main layout in the XML layout file should have.
   */
  public static final int ID_ANDROID_CONTENT = com.android.internal.R.id.content;

  /**
   * API from a Window back to its caller.  This allows the client to
   * intercept key dispatching, panels and menus, etc.
   */
  public interface Callback {
    public boolean dispatchTouchEvent(MotionEvent event);
    public void onAttachedToWindow();
    // ...
  }
  public abstract LayoutInflater getLayoutInflater();
  public abstract void setContentView(View view, ViewGroup.LayoutParams params);

  /**
   * Retrieve the top-level window decor view (containing the standard
   * window frame/decorations and the client's content inside of that), which
   * can be added as a window to the window manager.
   *
   * <p><em>Note that calling this function for the first time "locks in"
   * various window characteristics as described in
   * {@link #setContentView(View, android.view.ViewGroup.LayoutParams)}.</em></p>
   *
   * @return Returns the top-level window decor view.
   */
  public abstract View getDecorView();

  public abstract void setTitle(CharSequence title);
  public void setIcon(@DrawableRes int resId) { }
}

public class PhoneWindow extends Window {
  // This is the top-level view of the window, containing the window decor.
  private DecorView mDecor;

  // This is the view in which the window contents are placed. It is either
  // mDecor itself, or a child of mDecor where the contents go.
  private ViewGroup mContentParent;

  private TextView mTitleView;
  private ImageView mLeftIconView;
  private ActionBarView mActionBar;

  @Override
  public void injectInputEvent(InputEvent event) {
      getViewRootImpl().dispatchInputEvent(event);
  }

  private ViewRootImpl getViewRootImpl() {
      if (mDecor != null) {
          ViewRootImpl viewRootImpl = mDecor.getViewRootImpl();
          if (viewRootImpl != null) {
              return viewRootImpl;
          }
      }
      throw new IllegalStateException("view not added");
  }

  private final class DecorView extends FrameLayout {
    // ...
  }
}

/**
 * The top of a view hierarchy, implementing the needed protocol between View
 * and the WindowManager.  This is for the most part an internal implementation
 * detail of {@link WindowManagerGlobal}.
 *
 * {@hide}
 */
@SuppressWarnings({"EmptyCatchBlock", "PointlessBooleanExpression"})
public final class ViewRootImpl implements ViewParent {
  // ...
}

/** 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.
  public void addView(View view, ViewGroup.LayoutParams params);
  public void updateViewLayout(View view, ViewGroup.LayoutParams params);
  public void removeView(View view);
}

public interface WindowManager extends ViewManager {
  public static class LayoutParams extends ViewGroup.LayoutParams
            implements Parcelable {
      // View的left,top
      public int x, y;
      /**
       * The general type of window.  There are three main classes of
       * window types:Application windows、System windows、Sub-windows。
       */
      public int type;

      // Various behavioral options/flags.
      public int flags;

      // ...
  }
}

/**
 * Provides low-level communication with the system window manager for
 * operations that are bound to a particular context, display or parent window.
 * Instances of this object are sensitive to the compatibility info associated
 * with the running application.
 *
 * This object implements the {@link ViewManager} interface,
 * allowing you to add any View subclass as a top-level window on the screen.
 * Additional window manager specific layout parameters are defined for
 * control over how windows are displayed.  It also implements the {@link WindowManager}
 * interface, allowing you to control the displays attached to the device.
 *
 * <p>Applications will not normally use WindowManager directly, instead relying
 * on the higher-level facilities in {@link android.app.Activity} and
 * {@link android.app.Dialog}.
 *
 * <p>Even for low-level window manager access, it is almost never correct to use
 * this class.  For example, {@link android.app.Activity#getWindowManager}
 * provides a window manager for adding windows that are associated with that
 * activity -- the window manager will not normally allow you to add arbitrary
 * windows that are not associated with an activity.
 *
 * @see WindowManager
 * @see WindowManagerGlobal
 * @hide
 */
public final class WindowManagerImpl implements WindowManager {
  private final WindowManagerGlobal mGlobal = WindowManagerGlobal.getInstance();

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

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

  // ...
}

public final class 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>();

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

         ViewRootImpl root;
         View panelParentView = null;

         synchronized (mLock) {
             // Start watching for system property changes.
             if (mSystemPropertyUpdater == null) {
                 mSystemPropertyUpdater = new Runnable() {
                     @Override public void run() {
                         synchronized (mLock) {
                             for (int i = mRoots.size() - 1; i >= 0; --i) {
                                 mRoots.get(i).loadSystemProperties();
                             }
                         }
                     }
                 };
                 SystemProperties.addChangeCallback(mSystemPropertyUpdater);
             }

             int index = findViewLocked(view, false);
             if (index >= 0) {
                 if (mDyingViews.contains(view)) {
                     // Don't wait for MSG_DIE to make it's way through root's queue.
                     mRoots.get(index).doDie();
                 } else {
                     throw new IllegalStateException("View " + view
                             + " has already been added to the window manager.");
                 }
                 // The previous removeView() had not completed executing. Now it has.
             }

             // If this is a panel window, then find the window it is being
             // attached to for future reference.
             if (wparams.type >= WindowManager.LayoutParams.FIRST_SUB_WINDOW &&
                     wparams.type <= WindowManager.LayoutParams.LAST_SUB_WINDOW) {
                 final int count = mViews.size();
                 for (int i = 0; i < count; i++) {
                     if (mRoots.get(i).mWindow.asBinder() == wparams.token) {
                         panelParentView = mViews.get(i);
                     }
                 }
             }

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

             view.setLayoutParams(wparams);

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

         // 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.
             synchronized (mLock) {
                 final int index = findViewLocked(view, false);
                 if (index >= 0) {
                     removeViewLocked(index, true);
                 }
             }
             throw e;
         }
     }


  // ...
}

// ViewRootImpl.java
public void setView(View view, WindowManager.LayoutParams attrs, View panelParentView) {
  // ...
  requestLayout();
  // ...
  res = mWindowSession.addToDisplay(mWindow, mSeq, mWindowAttributes,
                            getHostVisibility(), mDisplay.getDisplayId(),
                            mAttachInfo.mContentInsets, mInputChannel);
  // ...
}

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

void onAttachedToWindow();
void setContentView(int layoutResID);
Window getWindow();
WindowManager getWindowManager();
void onDetachedFromWindow();