Android的Window底层原理

1.概述 

Window是一个抽象类，他的实现是PhoneWindow。Window通过WindowManager创建，是访问Window的入口。Window的具体实现位于WindowManagerService中，WIndowManager与WindowManagerService的交互是一个IPC的过程。

WindowManager中的Layoutparam中的Type表示Window的类型，Window有三种类型，分别是应用Window、子Window和系统Window。应用类Window对应着一个Activity。子Window不能单独存在，他需要附属在特定的父Window，例如Dialog。系统Window是需要在声明权限在能创建Window，比如Toast。

Window的层级范围是1-99，子Window的层级范围是1000-1999，系统Window的层级范围是2000-2999。对应着LayoutParams的type参数。层级大的会覆盖在层级小的Window上面。

Layoutparams

  public static final int FIRST_SUB_WINDOW = 1000;

  public static final int FIRST_SYSTEM_WINDOW = 2000;

2.Window的内部实现机制

2.1Window、PhoneWindow、DecorView

window是一个抽象类，提供一组通用的绘制窗口API，可抽象理解为一个载体，各种View在这个载体上显示

PhoneWindow是window类的实现，类内部包含一个DecorView，

DecorView是一个FragmeLayout的子类，该DecorView对象时所有应用窗口的根View

Activity的setContentView调用到PhoneView的setConteView，如果没有DecorView，那么就创建他，将View添加到DecorView的mContentParent中，回调Activity的onContentChanged方法通知Activity视图已经发生改变

  

@Override
  public void setContentView(int layoutResID) {
  // 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();//创建DecorView
  } else if (!hasFeature(FEATURE_CONTENT_TRANSITIONS)) {//所以Activity可以多次的setContetView-
  mContentParent.removeAllViews();
  }

  if (hasFeature(FEATURE_CONTENT_TRANSITIONS)) {
  final Scene newScene = Scene.getSceneForLayout(mContentParent, layoutResID,
  getContext());
  transitionTo(newScene);
  } else {
  mLayoutInflater.inflate(layoutResID, mContentParent);
  }
  mContentParent.requestApplyInsets();
  final Callback cb = getCallback();
  if (cb != null && !isDestroyed()) {
  cb.onContentChanged();
  }
  }

  private void installDecor() {
  if (mDecor == null) {
  mDecor = generateDecor();
  mDecor.setDescendantFocusability(ViewGroup.FOCUS_AFTER_DESCENDANTS);
  mDecor.setIsRootNamespace(true);
  if (!mInvalidatePanelMenuPosted && mInvalidatePanelMenuFeatures != 0) {
  mDecor.postOnAnimation(mInvalidatePanelMenuRunnable);
  }
  }
  if (mContentParent == null) {
  mContentParent = generateLayout(mDecor);

  // Set up decor part of UI to ignore fitsSystemWindows if appropriate.
  mDecor.makeOptionalFitsSystemWindows();

  final DecorContentParent decorContentParent = (DecorContentParent) mDecor.findViewById(
  R.id.decor_content_parent);

  if (decorContentParent != null) {
  mDecorContentParent = decorContentParent;
  mDecorContentParent.setWindowCallback(getCallback());
  if (mDecorContentParent.getTitle() == null) {
  mDecorContentParent.setWindowTitle(mTitle);
  }

  final int localFeatures = getLocalFeatures();
  for (int i = 0; i < FEATURE_MAX; i++) {
  if ((localFeatures & (1 << i)) != 0) {
  mDecorContentParent.initFeature(i);
  }
  }

  mDecorContentParent.setUiOptions(mUiOptions);

  if ((mResourcesSetFlags & FLAG_RESOURCE_SET_ICON) != 0 ||
  (mIconRes != 0 && !mDecorContentParent.hasIcon())) {
  mDecorContentParent.setIcon(mIconRes);
  } else if ((mResourcesSetFlags & FLAG_RESOURCE_SET_ICON) == 0 &&
  mIconRes == 0 && !mDecorContentParent.hasIcon()) {
  mDecorContentParent.setIcon(
  getContext().getPackageManager().getDefaultActivityIcon());
  mResourcesSetFlags |= FLAG_RESOURCE_SET_ICON_FALLBACK;
  }
  if ((mResourcesSetFlags & FLAG_RESOURCE_SET_LOGO) != 0 ||
  (mLogoRes != 0 && !mDecorContentParent.hasLogo())) {
  mDecorContentParent.setLogo(mLogoRes);
  }

  // Invalidate if the panel menu hasn't been created before this.
  // Panel menu invalidation is deferred avoiding application onCreateOptionsMenu
  // being called in the middle of onCreate or similar.
  // A pending invalidation will typically be resolved before the posted message
  // would run normally in order to satisfy instance state restoration.
  PanelFeatureState st = getPanelState(FEATURE_OPTIONS_PANEL, false);
  if (!isDestroyed() && (st == null || st.menu == null) && !mIsStartingWindow) {
  invalidatePanelMenu(FEATURE_ACTION_BAR);
  }
  } else {
  mTitleView = (TextView)findViewById(R.id.title);
  if (mTitleView != null) {
  mTitleView.setLayoutDirection(mDecor.getLayoutDirection());
  if ((getLocalFeatures() & (1 << FEATURE_NO_TITLE)) != 0) {
  View titleContainer = findViewById(
  R.id.title_container);
  if (titleContainer != null) {
  titleContainer.setVisibility(View.GONE);
  } else {
  mTitleView.setVisibility(View.GONE);
  }
  if (mContentParent instanceof FrameLayout) {
  ((FrameLayout)mContentParent).setForeground(null);
  }
  } else {
  mTitleView.setText(mTitle);
  }
  }
  }

  if (mDecor.getBackground() == null && mBackgroundFallbackResource != 0) {
  mDecor.setBackgroundFallback(mBackgroundFallbackResource);
  }

  // Only inflate or create a new TransitionManager if the caller hasn't
  // already set a custom one.
  if (hasFeature(FEATURE_ACTIVITY_TRANSITIONS)) {
  if (mTransitionManager == null) {
  final int transitionRes = getWindowStyle().getResourceId(
  R.styleable.Window_windowContentTransitionManager,
  0);
  if (transitionRes != 0) {
  final TransitionInflater inflater = TransitionInflater.from(getContext());
  mTransitionManager = inflater.inflateTransitionManager(transitionRes,
  mContentParent);
  } else {
  mTransitionManager = new TransitionManager();
  }
  }

  mEnterTransition = getTransition(mEnterTransition, null,
  R.styleable.Window_windowEnterTransition);
  mReturnTransition = getTransition(mReturnTransition, USE_DEFAULT_TRANSITION,
  R.styleable.Window_windowReturnTransition);
  mExitTransition = getTransition(mExitTransition, null,
  R.styleable.Window_windowExitTransition);
  mReenterTransition = getTransition(mReenterTransition, USE_DEFAULT_TRANSITION,
  R.styleable.Window_windowReenterTransition);
  mSharedElementEnterTransition = getTransition(mSharedElementEnterTransition, null,
  R.styleable.Window_windowSharedElementEnterTransition);
  mSharedElementReturnTransition = getTransition(mSharedElementReturnTransition,
  USE_DEFAULT_TRANSITION,
  R.styleable.Window_windowSharedElementReturnTransition);
  mSharedElementExitTransition = getTransition(mSharedElementExitTransition, null,
  R.styleable.Window_windowSharedElementExitTransition);
  mSharedElementReenterTransition = getTransition(mSharedElementReenterTransition,
  USE_DEFAULT_TRANSITION,
  R.styleable.Window_windowSharedElementReenterTransition);
  if (mAllowEnterTransitionOverlap == null) {
  mAllowEnterTransitionOverlap = getWindowStyle().getBoolean(
  R.styleable.Window_windowAllowEnterTransitionOverlap, true);
  }
  if (mAllowReturnTransitionOverlap == null) {
  mAllowReturnTransitionOverlap = getWindowStyle().getBoolean(
  R.styleable.Window_windowAllowReturnTransitionOverlap, true);
  }
  if (mBackgroundFadeDurationMillis < 0) {
  mBackgroundFadeDurationMillis = getWindowStyle().getInteger(
  R.styleable.Window_windowTransitionBackgroundFadeDuration,
  DEFAULT_BACKGROUND_FADE_DURATION_MS);
  }
  if (mSharedElementsUseOverlay == null) {
  mSharedElementsUseOverlay = getWindowStyle().getBoolean(
  R.styleable.Window_windowSharedElementsUseOverlay, true);
  }
  }
  }
  }

2.2WindowManager、WindowManagerGlobal、ViewRootImpl、WindowManagerService

    

    1）WindowManagerImpl是客户端WindowManager管理接口的实现，WindowManagerImpl内部维护一个单例的WindowManagerGlobal对象，WindowManagerImpl通过该对象转发客户端的窗口管理请求。客户端在创建窗口时首先调用getWindowManager获得本地窗口管理对象，并调用其addView、removeView、UpdateViewLayout为窗口进行布局控制

  2）ViewManagerImp是Viewmanager的实现，该类并没有直接实现Window的操作，而是由WindowmanagerGlobal进行操作。

  3）  WindowManagerGlobal对象内部维护一个ViewRootImpl实例数组和一个View视图对象数组，WindowmanagerGlobal的addView函数首先查看要添加的视图是否已经存在，若不存在则实例化一个ViewRootImpl对象，并把view和ViewRootImpl对象及布局参数保存到本地数组中，接着调用ViewRootImpl对象的setView函数；removeView通过调用ViewRootImpl的die方法进行，最终调用dispatchDetachedFromWindow进行移除;updateViewLayout首先更新View的LayoutParams并替换掉老的LayoutParams，接着更新ViewRootImpl的Layoutparams,通过调用scheduleTraversals对View重新布局

  

private final ArrayList mViews = new ArrayList();
  private final ArrayList mRoots = new ArrayList();
  private final ArrayList mParams =
  new ArrayList();
  private final ArraySet mDyingViews = new ArraySet();

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

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

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

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

4）ViewRootImpl是视图处理类，是客户端视图的处理类，客户端的视图通过该类与窗口管理服务交互，因此ViewRootImpl是一个中介类。ViewRootImpl内部包含一个从IWindow.Stub派生的内部类（ViewRootImpl.W），窗口管理服务通过该对象可以与客户端反向通讯。

setView内部通过requestLayout来完成异步刷新请求，scheduleTraversals实际是View绘制的入口，通过调用performTraversals对View进行measure、layout、draw，最后通过 pokeDrawLockIfNeeded进行IPC。

  public void setView(View view, WindowManager.LayoutParams attrs, View panelParentView) {
  synchronized (this) {
  if (mView == null) {
  mView = view;

  mAttachInfo.mDisplayState = mDisplay.getState();
  mDisplayManager.registerDisplayListener(mDisplayListener, mHandler);

  mViewLayoutDirectionInitial = mView.getRawLayoutDirection();
  mFallbackEventHandler.setView(view);
  mWindowAttributes.copyFrom(attrs);
  if (mWindowAttributes.packageName == null) {
  mWindowAttributes.packageName = mBasePackageName;
  }
  attrs = mWindowAttributes;
  // Keep track of the actual window flags supplied by the client.
  mClientWindowLayoutFlags = attrs.flags;

  setAccessibilityFocus(null, null);

  if (view instanceof RootViewSurfaceTaker) {
  mSurfaceHolderCallback =
  ((RootViewSurfaceTaker)view).willYouTakeTheSurface();
  if (mSurfaceHolderCallback != null) {
  mSurfaceHolder = new TakenSurfaceHolder();
  mSurfaceHolder.setFormat(PixelFormat.UNKNOWN);
  }
  }

  // Compute surface insets required to draw at specified Z value.
  // TODO: Use real shadow insets for a constant max Z.
  if (!attrs.hasManualSurfaceInsets) {
  final int surfaceInset = (int) Math.ceil(view.getZ() * 2);
  attrs.surfaceInsets.set(surfaceInset, surfaceInset, surfaceInset, surfaceInset);
  }

  CompatibilityInfo compatibilityInfo = mDisplayAdjustments.getCompatibilityInfo();
  mTranslator = compatibilityInfo.getTranslator();

  // If the application owns the surface, don't enable hardware acceleration
  if (mSurfaceHolder == null) {
  enableHardwareAcceleration(attrs);
  }

  boolean restore = false;
  if (mTranslator != null) {
  mSurface.setCompatibilityTranslator(mTranslator);
  restore = true;
  attrs.backup();
  mTranslator.translateWindowLayout(attrs);
  }
  if (DEBUG_LAYOUT) Log.d(TAG, "WindowLayout in setView:" + attrs);

  if (!compatibilityInfo.supportsScreen()) {
  attrs.privateFlags |= WindowManager.LayoutParams.PRIVATE_FLAG_COMPATIBLE_WINDOW;
  mLastInCompatMode = true;
  }

  mSoftInputMode = attrs.softInputMode;
  mWindowAttributesChanged = true;
  mWindowAttributesChangesFlag = WindowManager.LayoutParams.EVERYTHING_CHANGED;
  mAttachInfo.mRootView = view;
  mAttachInfo.mScalingRequired = mTranslator != null;
  mAttachInfo.mApplicationScale =
  mTranslator == null ? 1.0f : mTranslator.applicationScale;
  if (panelParentView != null) {
  mAttachInfo.mPanelParentWindowToken
  = panelParentView.getApplicationWindowToken();
  }
  mAdded = true;
  int res; /* = WindowManagerImpl.ADD_OKAY; */

  // 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();
  if ((mWindowAttributes.inputFeatures
  & WindowManager.LayoutParams.INPUT_FEATURE_NO_INPUT_CHANNEL) == 0) {
  mInputChannel = new InputChannel();
  }
  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();
  }
  }

  if (mTranslator != null) {
  mTranslator.translateRectInScreenToAppWindow(mAttachInfo.mContentInsets);
  }
  mPendingOverscanInsets.set(0, 0, 0, 0);
  mPendingContentInsets.set(mAttachInfo.mContentInsets);
  mPendingStableInsets.set(mAttachInfo.mStableInsets);
  mPendingVisibleInsets.set(0, 0, 0, 0);
  if (DEBUG_LAYOUT) Log.v(TAG, "Added window " + mWindow);
  if (res < WindowManagerGlobal.ADD_OKAY) {
  mAttachInfo.mRootView = null;
  mAdded = false;
  mFallbackEventHandler.setView(null);
  unscheduleTraversals();
  setAccessibilityFocus(null, null);
  switch (res) {
  case WindowManagerGlobal.ADD_BAD_APP_TOKEN:
  case WindowManagerGlobal.ADD_BAD_SUBWINDOW_TOKEN:
  throw new WindowManager.BadTokenException(
  "Unable to add window -- token " + attrs.token
  + " is not valid; is your activity running?");
  case WindowManagerGlobal.ADD_NOT_APP_TOKEN:
  throw new WindowManager.BadTokenException(
  "Unable to add window -- token " + attrs.token
  + " is not for an application");
  case WindowManagerGlobal.ADD_APP_EXITING:
  throw new WindowManager.BadTokenException(
  "Unable to add window -- app for token " + attrs.token
  + " is exiting");
  case WindowManagerGlobal.ADD_DUPLICATE_ADD:
  throw new WindowManager.BadTokenException(
  "Unable to add window -- window " + mWindow
  + " has already been added");
  case WindowManagerGlobal.ADD_STARTING_NOT_NEEDED:
  // Silently ignore -- we would have just removed it
  // right away, anyway.
  return;
  case WindowManagerGlobal.ADD_MULTIPLE_SINGLETON:
  throw new WindowManager.BadTokenException(
  "Unable to add window " + mWindow +
  " -- another window of this type already exists");
  case WindowManagerGlobal.ADD_PERMISSION_DENIED:
  throw new WindowManager.BadTokenException(
  "Unable to add window " + mWindow +
  " -- permission denied for this window type");
  case WindowManagerGlobal.ADD_INVALID_DISPLAY:
  throw new WindowManager.InvalidDisplayException(
  "Unable to add window " + mWindow +
  " -- the specified display can not be found");
  case WindowManagerGlobal.ADD_INVALID_TYPE:
  throw new WindowManager.InvalidDisplayException(
  "Unable to add window " + mWindow
  + " -- the specified window type is not valid");
  }
  throw new RuntimeException(
  "Unable to add window -- unknown error code " + res);
  }

  if (view instanceof RootViewSurfaceTaker) {
  mInputQueueCallback =
  ((RootViewSurfaceTaker)view).willYouTakeTheInputQueue();
  }
  if (mInputChannel != null) {
  if (mInputQueueCallback != null) {
  mInputQueue = new InputQueue();
  mInputQueueCallback.onInputQueueCreated(mInputQueue);
  }
  mInputEventReceiver = new WindowInputEventReceiver(mInputChannel,
  Looper.myLooper());
  }

  view.assignParent(this);
  mAddedTouchMode = (res & WindowManagerGlobal.ADD_FLAG_IN_TOUCH_MODE) != 0;
  mAppVisible = (res & WindowManagerGlobal.ADD_FLAG_APP_VISIBLE) != 0;

  if (mAccessibilityManager.isEnabled()) {
  mAccessibilityInteractionConnectionManager.ensureConnection();
  }

  if (view.getImportantForAccessibility() == View.IMPORTANT_FOR_ACCESSIBILITY_AUTO) {
  view.setImportantForAccessibility(View.IMPORTANT_FOR_ACCESSIBILITY_YES);
  }

  // Set up the input pipeline.
  CharSequence counterSuffix = attrs.getTitle();
  mSyntheticInputStage = new SyntheticInputStage();
  InputStage viewPostImeStage = new ViewPostImeInputStage(mSyntheticInputStage);
  InputStage nativePostImeStage = new NativePostImeInputStage(viewPostImeStage,
  "aq:native-post-ime:" + counterSuffix);
  InputStage earlyPostImeStage = new EarlyPostImeInputStage(nativePostImeStage);
  InputStage imeStage = new ImeInputStage(earlyPostImeStage,
  "aq:ime:" + counterSuffix);
  InputStage viewPreImeStage = new ViewPreImeInputStage(imeStage);
  InputStage nativePreImeStage = new NativePreImeInputStage(viewPreImeStage,
  "aq:native-pre-ime:" + counterSuffix);

  mFirstInputStage = nativePreImeStage;
  mFirstPostImeInputStage = earlyPostImeStage;
  mPendingInputEventQueueLengthCounterName = "aq:pending:" + counterSuffix;
  }
  }
  }
     
 @Override
  public void requestLayout() {
  if (!mHandlingLayoutInLayoutRequest) {
  checkThread();
  mLayoutRequested = true;
  scheduleTraversals();
  }
  }

 void scheduleTraversals() {
  if (!mTraversalScheduled) {
  mTraversalScheduled = true;
  mTraversalBarrier = mHandler.getLooper().getQueue().postSyncBarrier();
  mChoreographer.postCallback(
  Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null);
  if (!mUnbufferedInputDispatch) {
  scheduleConsumeBatchedInput();
  }
  notifyRendererOfFramePending();
  pokeDrawLockIfNeeded();
  }
  }

在die方法内部只是简单做了判断，如果是异步删除，那个发送MSG_DIE的消息，ViewRootImpl中的Handle会处理并调用doDie，如果为同步直接调用doDie,doDie内部会调用dispatchDetachedFromWIndow，进行IPC

  /**
  * @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(TAG, "Attempting to destroy the window while drawing!\n" +
  " window=" + this + ", title=" + mWindowAttributes.getTitle());
  }
  mHandler.sendEmptyMessage(MSG_DIE);
  return true;
  }

  void doDie() {
  checkThread();
  if (LOCAL_LOGV) Log.v(TAG, "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();
  }

  void unscheduleTraversals() {
  if (mTraversalScheduled) {
  mTraversalScheduled = false;
  mHandler.getLooper().getQueue().removeSyncBarrier(mTraversalBarrier);
  mChoreographer.removeCallbacks(
  Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null);
  }
  }

5）Session对象也是一个服务端的桩对象，用来为客户端提供交互接口（IWindowSession），包括窗口的创建、销毁、布局等接口。每个与窗口管理服务交互的进程通常都需要打开一个Session对象来实现交互，用来保证一个Session会话期间窗口状态的一致。Session对象在一个进程新建第一个视图时使用窗口管理服务的的openSession接口函数创建，第一个视图新建期间也创建一个SurfaceSession对象用来实现视图的绘制操作。SurfaceSession对象用来与SurfaceFliger服务建立连接，实现视图及包含的子视图在显示硬件上的实际输出工作。

  6）  WindowManagerService服务是一个系统服务类，是整个窗口管理机制实现的核心。

3.Window的创建

View是Android中的视图的呈现方式，但是View不能单独存在，必须依赖于Window这个抽象的概念上，因此有视图的地方就有Window。

3.1应用Window-Activity的创建

1）ActivityThread的performLaunchActivity

 private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
  // System.out.println("##### [" + System.currentTimeMillis() + "] ActivityThread.performLaunchActivity(" + r + ")");

  ActivityInfo aInfo = r.activityInfo;
  if (r.packageInfo == null) {
  r.packageInfo = getPackageInfo(aInfo.applicationInfo, r.compatInfo,
  Context.CONTEXT_INCLUDE_CODE);
  }

  ComponentName component = r.intent.getComponent();
  if (component == null) {
  component = r.intent.resolveActivity(
  mInitialApplication.getPackageManager());
  r.intent.setComponent(component);
  }

  if (r.activityInfo.targetActivity != null) {
  component = new ComponentName(r.activityInfo.packageName,
  r.activityInfo.targetActivity);
  }

  Activity activity = null;
  try {
  java.lang.ClassLoader cl = r.packageInfo.getClassLoader();
  activity = mInstrumentation.newActivity(
  cl, component.getClassName(), r.intent);
  StrictMode.incrementExpectedActivityCount(activity.getClass());
  r.intent.setExtrasClassLoader(cl);
  r.intent.prepareToEnterProcess();
  if (r.state != null) {
  r.state.setClassLoader(cl);
  }
  } catch (Exception e) {
  if (!mInstrumentation.onException(activity, e)) {
  throw new RuntimeException(
  "Unable to instantiate activity " + component
  + ": " + e.toString(), e);
  }
  }

  try {
  Application app = r.packageInfo.makeApplication(false, mInstrumentation);

  if (localLOGV) Slog.v(TAG, "Performing launch of " + r);
  if (localLOGV) Slog.v(
  TAG, r + ": app=" + app
  + ", appName=" + app.getPackageName()
  + ", pkg=" + r.packageInfo.getPackageName()
  + ", comp=" + r.intent.getComponent().toShortString()
  + ", dir=" + r.packageInfo.getAppDir());

  if (activity != null) {
  Context appContext = createBaseContextForActivity(r, activity);
  CharSequence title = r.activityInfo.loadLabel(appContext.getPackageManager());
  Configuration config = new Configuration(mCompatConfiguration);
  if (DEBUG_CONFIGURATION) Slog.v(TAG, "Launching activity "
  + r.activityInfo.name + " with config " + config);
  activity.attach(appContext, this, getInstrumentation(), r.token,
  r.ident, app, r.intent, r.activityInfo, title, r.parent,
  r.embeddedID, r.lastNonConfigurationInstances, config,
  r.referrer, r.voiceInteractor);

  if (customIntent != null) {
  activity.mIntent = customIntent;
  }
  r.lastNonConfigurationInstances = null;
  activity.mStartedActivity = false;
  int theme = r.activityInfo.getThemeResource();
  if (theme != 0) {
  activity.setTheme(theme);
  }

  activity.mCalled = false;
  if (r.isPersistable()) {
  mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
  } else {
  mInstrumentation.callActivityOnCreate(activity, r.state);
  }
  if (!activity.mCalled) {
  throw new SuperNotCalledException(
  "Activity " + r.intent.getComponent().toShortString() +
  " did not call through to super.onCreate()");
  }
  r.activity = activity;
  r.stopped = true;
  if (!r.activity.mFinished) {
  activity.performStart();
  r.stopped = false;
  }
  if (!r.activity.mFinished) {
  if (r.isPersistable()) {
  if (r.state != null || r.persistentState != null) {
  mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state,
  r.persistentState);
  }
  } else if (r.state != null) {
  mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state);
  }
  }
  if (!r.activity.mFinished) {
  activity.mCalled = false;
  if (r.isPersistable()) {
  mInstrumentation.callActivityOnPostCreate(activity, r.state,
  r.persistentState);
  } else {
  mInstrumentation.callActivityOnPostCreate(activity, r.state);
  }
  if (!activity.mCalled) {
  throw new SuperNotCalledException(
  "Activity " + r.intent.getComponent().toShortString() +
  " did not call through to super.onPostCreate()");
  }
  }
  }
  r.paused = true;

  mActivities.put(r.token, r);

  } catch (SuperNotCalledException e) {
  throw e;

  } catch (Exception e) {
  if (!mInstrumentation.onException(activity, e)) {
  throw new RuntimeException(
  "Unable to start activity " + component
  + ": " + e.toString(), e);
  }
  }

  return activity;
  }

2）Activity的attach

 final void attach(Context context, ActivityThread aThread,
  Instrumentation instr, IBinder token, int ident,
  Application application, Intent intent, ActivityInfo info,
  CharSequence title, Activity parent, String id,
  NonConfigurationInstances lastNonConfigurationInstances,
  Configuration config, String referrer, IVoiceInteractor voiceInteractor) {
  attachBaseContext(context);

  mFragments.attachHost(null /*parent*/);

  mWindow = new PhoneWindow(this);
  mWindow.setCallback(this);
  mWindow.setOnWindowDismissedCallback(this);
  mWindow.getLayoutInflater().setPrivateFactory(this);
  if (info.softInputMode != WindowManager.LayoutParams.SOFT_INPUT_STATE_UNSPECIFIED) {
  mWindow.setSoftInputMode(info.softInputMode);
  }
  if (info.uiOptions != 0) {
  mWindow.setUiOptions(info.uiOptions);
  }
  mUiThread = Thread.currentThread();

  mMainThread = aThread;
  mInstrumentation = instr;
  mToken = token;
  mIdent = ident;
  mApplication = application;
  mIntent = intent;
  mReferrer = referrer;
  mComponent = intent.getComponent();
  mActivityInfo = info;
  mTitle = title;
  mParent = parent;
  mEmbeddedID = id;
  mLastNonConfigurationInstances = lastNonConfigurationInstances;
  if (voiceInteractor != null) {
  if (lastNonConfigurationInstances != null) {
  mVoiceInteractor = lastNonConfigurationInstances.voiceInteractor;
  } else {
  mVoiceInteractor = new VoiceInteractor(voiceInteractor, this, this,
  Looper.myLooper());
  }
  }

  mWindow.setWindowManager(
  (WindowManager)context.getSystemService(Context.WINDOW_SERVICE),
  mToken, mComponent.flattenToString(),
  (info.flags & ActivityInfo.FLAG_HARDWARE_ACCELERATED) != 0);
  if (mParent != null) {
  mWindow.setContainer(mParent.getWindow());
  }
  mWindowManager = mWindow.getWindowManager();
  mCurrentConfig = config;
  }

3）Window创建完成后，通过setContentView将视图附加在Window上

 public void setContentView(@LayoutRes int layoutResID) {
  getWindow().setContentView(layoutResID);
  initWindowDecorActionBar();
  }

4）虽然在attach方法中Window就已经被创建，但这个时候还未被Windowmanager识别。在ActivityThread的handleResumeActvity中，调用了Activity的performResume方法，接着调用Activity的makeVisible方法。此时，DecorView才真正的被添加和显示。

 final void handleResumeActivity(IBinder token,
  boolean clearHide, boolean isForward, boolean reallyResume) {
  // If we are getting ready to gc after going to the background, well
  // we are back active so skip it.
  unscheduleGcIdler();
  mSomeActivitiesChanged = true;

  // TODO Push resumeArgs into the activity for consideration
  ActivityClientRecord r = performResumeActivity(token, clearHide);

  if (r != null) {
  final Activity a = r.activity;

  if (localLOGV) Slog.v(
  TAG, "Resume " + r + " started activity: " +
  a.mStartedActivity + ", hideForNow: " + r.hideForNow
  + ", finished: " + a.mFinished);

  final int forwardBit = isForward ?
  WindowManager.LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION : 0;

  // If the window hasn't yet been added to the window manager,
  // and this guy didn't finish itself or start another activity,
  // then go ahead and add the window.
  boolean willBeVisible = !a.mStartedActivity;
  if (!willBeVisible) {
  try {
  willBeVisible = ActivityManagerNative.getDefault().willActivityBeVisible(
  a.getActivityToken());
  } catch (RemoteException e) {
  }
  }
  if (r.window == null && !a.mFinished && willBeVisible) {
  r.window = r.activity.getWindow();
  View decor = r.window.getDecorView();
  decor.setVisibility(View.INVISIBLE);
  ViewManager wm = a.getWindowManager();
  WindowManager.LayoutParams l = r.window.getAttributes();
  a.mDecor = decor;
  l.type = WindowManager.LayoutParams.TYPE_BASE_APPLICATION;
  l.softInputMode |= forwardBit;
  if (a.mVisibleFromClient) {
  a.mWindowAdded = true;
  wm.addView(decor, l);
  }

  // If the window has already been added, but during resume
  // we started another activity, then don't yet make the
  // window visible.
  } else if (!willBeVisible) {
  if (localLOGV) Slog.v(
  TAG, "Launch " + r + " mStartedActivity set");
  r.hideForNow = true;
  }

  // Get rid of anything left hanging around.
  cleanUpPendingRemoveWindows(r);

  // The window is now visible if it has been added, we are not
  // simply finishing, and we are not starting another activity.
  if (!r.activity.mFinished && willBeVisible
  && r.activity.mDecor != null && !r.hideForNow) {
  if (r.newConfig != null) {
  r.tmpConfig.setTo(r.newConfig);
  if (r.overrideConfig != null) {
  r.tmpConfig.updateFrom(r.overrideConfig);
  }
  if (DEBUG_CONFIGURATION) Slog.v(TAG, "Resuming activity "
  + r.activityInfo.name + " with newConfig " + r.tmpConfig);
  performConfigurationChanged(r.activity, r.tmpConfig);
  freeTextLayoutCachesIfNeeded(r.activity.mCurrentConfig.diff(r.tmpConfig));
  r.newConfig = null;
  }
  if (localLOGV) Slog.v(TAG, "Resuming " + r + " with isForward="
  + isForward);
  WindowManager.LayoutParams l = r.window.getAttributes();
  if ((l.softInputMode
  & WindowManager.LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION)
  != forwardBit) {
  l.softInputMode = (l.softInputMode
  & (~WindowManager.LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION))
  | forwardBit;
  if (r.activity.mVisibleFromClient) {
  ViewManager wm = a.getWindowManager();
  View decor = r.window.getDecorView();
  wm.updateViewLayout(decor, l);
  }
  }
  r.activity.mVisibleFromServer = true;
  mNumVisibleActivities++;
  if (r.activity.mVisibleFromClient) {
  r.activity.makeVisible();
  }
  }

  if (!r.onlyLocalRequest) {
  r.nextIdle = mNewActivities;
  mNewActivities = r;
  if (localLOGV) Slog.v(
  TAG, "Scheduling idle handler for " + r);
  Looper.myQueue().addIdleHandler(new Idler());
  }
  r.onlyLocalRequest = false;

  // Tell the activity manager we have resumed.
  if (reallyResume) {
  try {
  ActivityManagerNative.getDefault().activityResumed(token);
  } catch (RemoteException ex) {
  }
  }

  } else {
  // If an exception was thrown when trying to resume, then
  // just end this activity.
  try {
  ActivityManagerNative.getDefault()
  .finishActivity(token, Activity.RESULT_CANCELED, null, false);
  } catch (RemoteException ex) {
  }
  }
  }

  void makeVisible() {
  if (!mWindowAdded) {
  ViewManager wm = getWindowManager();
  wm.addView(mDecor, getWindow().getAttributes());
  mWindowAdded = true;
  }
  mDecor.setVisibility(View.VISIBLE);
  }

3.2子Window-Dialog的创建

1）初始化

Dialog(@NonNull Context context, @StyleRes int themeResId, boolean createContextThemeWrapper) {
  if (createContextThemeWrapper) {
  if (themeResId == 0) {
  final TypedValue outValue = new TypedValue();
  context.getTheme().resolveAttribute(R.attr.dialogTheme, outValue, true);
  themeResId = outValue.resourceId;
  }
  mContext = new ContextThemeWrapper(context, themeResId);
  } else {
  mContext = context;
  }

  mWindowManager = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);

  final Window w = new PhoneWindow(mContext);
  mWindow = w;
  w.setCallback(this);
  w.setOnWindowDismissedCallback(this);
  w.setWindowManager(mWindowManager, null, null);
  w.setGravity(Gravity.CENTER);

  mListenersHandler = new ListenersHandler(this);
  }

2）设置View

 /**
  * Set the screen content to an explicit view. This view is placed
  * directly into the screen's view hierarchy. It can itself be a complex
  * view hierarchy.
  *
  * @param view The desired content to display.
  */
  public void setContentView(View view) {
  mWindow.setContentView(view);
  }

3）显示

/**
  * 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 WindowDecorActionBar(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 {
  }
  }

4）取消

void dismissDialog() {
  if (mDecor == null || !mShowing) {
  return;
  }

  if (mWindow.isDestroyed()) {
  Log.e(TAG, "Tried to dismissDialog() but the Dialog's window was already destroyed!");
  return;
  }

  try {
  mWindowManager.removeViewImmediate(mDecor);
  } finally {
  if (mActionMode != null) {
  mActionMode.finish();
  }
  mDecor = null;
  mWindow.closeAllPanels();
  onStop();
  mShowing = false;

  sendDismissMessage();
  }
  }

3.3系统Window-Toast的创建

Toast属于系统Window，内部的视图有2种指定方式，一种是系统默认样式，另外一种是通过setView方法来指定一个自定义的View。由于Toast具有定时取消的功能，所以系统采用了Handler。Toast的显示及隐藏都是通过NotificationmanagerService进行控制

 /**
  * Show the view for the specified duration.
  */
  public void show() {
  if (mNextView == null) {
  throw new RuntimeException("setView must have been called");
  }

  INotificationManager service = getService();
  String pkg = mContext.getOpPackageName();
  TN tn = mTN;
  tn.mNextView = mNextView;

  try {
  service.enqueueToast(pkg, tn, mDuration);
  } catch (RemoteException e) {
  // Empty
  }
  }

  /**
  * Close the view if it's showing, or don't show it if it isn't showing yet.
  * You do not normally have to call this. Normally view will disappear on its own
  * after the appropriate duration.
  */
  public void cancel() {
  mTN.hide();

  try {
  getService().cancelToast(mContext.getPackageName(), mTN);
  } catch (RemoteException e) {
  // Empty
  }
  }

 主要在TN中进行Window操作

 private static class TN extends ITransientNotification.Stub {
  final Runnable mShow = new Runnable() {
  @Override
  public void run() {
  handleShow();
  }
  };

  final Runnable mHide = new Runnable() {
  @Override
  public void run() {
  handleHide();
  // Don't do this in handleHide() because it is also invoked by handleShow()
  mNextView = null;
  }
  };

  private final WindowManager.LayoutParams mParams = new WindowManager.LayoutParams();
  final Handler mHandler = new Handler();

  int mGravity;
  int mX, mY;
  float mHorizontalMargin;
  float mVerticalMargin;


  View mView;
  View mNextView;

  WindowManager mWM;

  TN() {
  // XXX This should be changed to use a Dialog, with a Theme.Toast
  // defined that sets up the layout params appropriately.
  final WindowManager.LayoutParams params = mParams;
  params.height = WindowManager.LayoutParams.WRAP_CONTENT;
  params.width = WindowManager.LayoutParams.WRAP_CONTENT;
  params.format = PixelFormat.TRANSLUCENT;
  params.windowAnimations = com.android.internal.R.style.Animation_Toast;
  params.type = WindowManager.LayoutParams.TYPE_TOAST;
  params.setTitle("Toast");
  params.flags = WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON
  | WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE
  | WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE;
  }

  /**
  * schedule handleShow into the right thread
  */
  @Override
  public void show() {
  if (localLOGV) Log.v(TAG, "SHOW: " + this);
  mHandler.post(mShow);
  }

  /**
  * schedule handleHide into the right thread
  */
  @Override
  public void hide() {
  if (localLOGV) Log.v(TAG, "HIDE: " + this);
  mHandler.post(mHide);
  }

  public void handleShow() {
  if (localLOGV) Log.v(TAG, "HANDLE SHOW: " + this + " mView=" + mView
  + " mNextView=" + mNextView);
  if (mView != mNextView) {
  // remove the old view if necessary
  handleHide();
  mView = mNextView;
  Context context = mView.getContext().getApplicationContext();
  String packageName = mView.getContext().getOpPackageName();
  if (context == null) {
  context = mView.getContext();
  }
  mWM = (WindowManager)context.getSystemService(Context.WINDOW_SERVICE);
  // We can resolve the Gravity here by using the Locale for getting
  // the layout direction
  final Configuration config = mView.getContext().getResources().getConfiguration();
  final int gravity = Gravity.getAbsoluteGravity(mGravity, config.getLayoutDirection());
  mParams.gravity = gravity;
  if ((gravity & Gravity.HORIZONTAL_GRAVITY_MASK) == Gravity.FILL_HORIZONTAL) {
  mParams.horizontalWeight = 1.0f;
  }
  if ((gravity & Gravity.VERTICAL_GRAVITY_MASK) == Gravity.FILL_VERTICAL) {
  mParams.verticalWeight = 1.0f;
  }
  mParams.x = mX;
  mParams.y = mY;
  mParams.verticalMargin = mVerticalMargin;
  mParams.horizontalMargin = mHorizontalMargin;
  mParams.packageName = packageName;
  if (mView.getParent() != null) {
  if (localLOGV) Log.v(TAG, "REMOVE! " + mView + " in " + this);
  mWM.removeView(mView);
  }
  if (localLOGV) Log.v(TAG, "ADD! " + mView + " in " + this);
  mWM.addView(mView, mParams);
  trySendAccessibilityEvent();
  }
  }

  private void trySendAccessibilityEvent() {
  AccessibilityManager accessibilityManager =
  AccessibilityManager.getInstance(mView.getContext());
  if (!accessibilityManager.isEnabled()) {
  return;
  }
  // treat toasts as notifications since they are used to
  // announce a transient piece of information to the user
  AccessibilityEvent event = AccessibilityEvent.obtain(
  AccessibilityEvent.TYPE_NOTIFICATION_STATE_CHANGED);
  event.setClassName(getClass().getName());
  event.setPackageName(mView.getContext().getPackageName());
  mView.dispatchPopulateAccessibilityEvent(event);
  accessibilityManager.sendAccessibilityEvent(event);
  }

  public void handleHide() {
  if (localLOGV) Log.v(TAG, "HANDLE HIDE: " + this + " mView=" + mView);
  if (mView != null) {
  // note: checking parent() just to make sure the view has
  // been added... i have seen cases where we get here when
  // the view isn't yet added, so let's try not to crash.
  if (mView.getParent() != null) {
  if (localLOGV) Log.v(TAG, "REMOVE! " + mView + " in " + this);
  mWM.removeView(mView);
  }

  mView = null;
  }
  }
  }
}