每一个View都需要依赖于窗口来显示，而View和窗口的关系则是放在View.AttachInfo中,关于View.AttachInfo的文章少，因为这个是View的内部类而且不是公共的，在应用层用的很少，只有在ViewRootImpl等类中才用到了，不过我觉得这个还是有点学习的必要，因此在这篇文章中就从源码入手学习下AttachInfo这个类。

    AttachInfo 看到这个类名，我们就知道，他是代表着绑定的信息，View.AttachInfo 里面的信息，就是View和Window之间的信息。每一个被添加到窗口上的View我们都会看到有一个AttachInfo，比如我们看DecorView和Window的绑定，可以在ViewRootImpl#perfromTraversals方法中看到：

final View.AttachInfo attachInfo = mAttachInfo;

       final int viewVisibility = getHostVisibility();
       boolean viewVisibilityChanged = mViewVisibility != viewVisibility
               || mNewSurfaceNeeded;

       WindowManager.LayoutParams params = null;
       if (mWindowAttributesChanged) {
           mWindowAttributesChanged = false;
           surfaceChanged = true;
           params = lp;
       }
       CompatibilityInfo compatibilityInfo = mDisplayAdjustments.getCompatibilityInfo();
       if (compatibilityInfo.supportsScreen() == mLastInCompatMode) {
           params = lp;
           mFullRedrawNeeded = true;
           mLayoutRequested = true;
           if (mLastInCompatMode) {
               params.privateFlags &= ~WindowManager.LayoutParams.PRIVATE_FLAG_COMPATIBLE_WINDOW;
               mLastInCompatMode = false;
           } else {
               params.privateFlags |= WindowManager.LayoutParams.PRIVATE_FLAG_COMPATIBLE_WINDOW;
               mLastInCompatMode = true;
           }
       }

       mWindowAttributesChangesFlag = 0;

       Rect frame = mWinFrame;
       if (mFirst) {
           mFullRedrawNeeded = true;
           mLayoutRequested = true;

           if (lp.type == WindowManager.LayoutParams.TYPE_STATUS_BAR_PANEL
                   || lp.type == WindowManager.LayoutParams.TYPE_INPUT_METHOD) {
               // NOTE -- system code, won't try to do compat mode.
               Point size = new Point();
               mDisplay.getRealSize(size);
               desiredWindowWidth = size.x;
               desiredWindowHeight = size.y;
           } else {
               DisplayMetrics packageMetrics =
                   mView.getContext().getResources().getDisplayMetrics();
               desiredWindowWidth = packageMetrics.widthPixels;
               desiredWindowHeight = packageMetrics.heightPixels;
           }

           // For the very first time, tell the view hierarchy that it
           // is attached to the window.  Note that at this point the surface
           // object is not initialized to its backing store, but soon it
           // will be (assuming the window is visible).
           attachInfo.mSurface = mSurface;
           // We used to use the following condition to choose 32 bits drawing caches:
           // PixelFormat.hasAlpha(lp.format) || lp.format == PixelFormat.RGBX_8888
           // However, windows are now always 32 bits by default, so choose 32 bits
           attachInfo.mUse32BitDrawingCache = true;
           attachInfo.mHasWindowFocus = false;
           attachInfo.mWindowVisibility = viewVisibility;
           attachInfo.mRecomputeGlobalAttributes = false;
           viewVisibilityChanged = false;
           mLastConfiguration.setTo(host.getResources().getConfiguration());
           mLastSystemUiVisibility = mAttachInfo.mSystemUiVisibility;
           // Set the layout direction if it has not been set before (inherit is the default)
           if (mViewLayoutDirectionInitial == View.LAYOUT_DIRECTION_INHERIT) {
               host.setLayoutDirection(mLastConfiguration.getLayoutDirection());
           }
           host.dispatchAttachedToWindow(attachInfo, 0);

AttachInfo 会通过View的diapatchAttachedTowWindow分发给View。如果是一个ViewGroup 那么这个这个AttachInfo也会分发给所有子View，以引用的方式。

下面我们可以看下AttachInfo这个类，这个类是View的内部类，不是声明为public的，所以只有view这个包中的类才用到。

static class AttachInfo {
        interface Callbacks {
            void playSoundEffect(int effectId);
            boolean performHapticFeedback(int effectId, boolean always);
        }

        /**
         * InvalidateInfo is used to post invalidate(int, int, int, int) messages
         * to a Handler. This class contains the target (View) to invalidate and
         * the coordinates of the dirty rectangle.
         *
         * For performance purposes, this class also implements a pool of up to
         * POOL_LIMIT objects that get reused. This reduces memory allocations
         * whenever possible.
         */
        static class InvalidateInfo {
            private static final int POOL_LIMIT = 10;

            private static final SynchronizedPool<InvalidateInfo> sPool =
                    new SynchronizedPool<InvalidateInfo>(POOL_LIMIT);

            View target;

            int left;
            int top;
            int right;
            int bottom;

            public static InvalidateInfo obtain() {
                InvalidateInfo instance = sPool.acquire();
                return (instance != null) ? instance : new InvalidateInfo();
            }

            public void recycle() {
                target = null;
                sPool.release(this);
            }
        }

        final IWindowSession mSession;

        final IWindow mWindow;

        final IBinder mWindowToken;

        final Display mDisplay;

        final Callbacks mRootCallbacks;

        HardwareCanvas mHardwareCanvas;

        IWindowId mIWindowId;
        WindowId mWindowId;

        /**
         * The top view of the hierarchy.
         */
        View mRootView;

        IBinder mPanelParentWindowToken;
        Surface mSurface;

        boolean mHardwareAccelerated;
        boolean mHardwareAccelerationRequested;
        HardwareRenderer mHardwareRenderer;

        boolean mScreenOn;

        /**
         * Scale factor used by the compatibility mode
         */
        float mApplicationScale;

        /**
         * Indicates whether the application is in compatibility mode
         */
        boolean mScalingRequired;

        /**
         * If set, ViewRootImpl doesn't use its lame animation for when the window resizes.
         */
        boolean mTurnOffWindowResizeAnim;

        /**
         * Left position of this view's window
         */
        int mWindowLeft;

        /**
         * Top position of this view's window
         */
        int mWindowTop;

        /**
         * Indicates whether views need to use 32-bit drawing caches
         */
        boolean mUse32BitDrawingCache;

        /**
         * For windows that are full-screen but using insets to layout inside
         * of the screen areas, these are the current insets to appear inside
         * the overscan area of the display.
         */
        final Rect mOverscanInsets = new Rect();

        /**
         * For windows that are full-screen but using insets to layout inside
         * of the screen decorations, these are the current insets for the
         * content of the window.
         */
        final Rect mContentInsets = new Rect();

        /**
         * For windows that are full-screen but using insets to layout inside
         * of the screen decorations, these are the current insets for the
         * actual visible parts of the window.
         */
        final Rect mVisibleInsets = new Rect();

        /**
         * The internal insets given by this window.  This value is
         * supplied by the client (through
         * {@link ViewTreeObserver.OnComputeInternalInsetsListener}) and will
         * be given to the window manager when changed to be used in laying
         * out windows behind it.
         */
        final ViewTreeObserver.InternalInsetsInfo mGivenInternalInsets
                = new ViewTreeObserver.InternalInsetsInfo();

        /**
         * Set to true when mGivenInternalInsets is non-empty.
         */
        boolean mHasNonEmptyGivenInternalInsets;

        /**
         * All views in the window's hierarchy that serve as scroll containers,
         * used to determine if the window can be resized or must be panned
         * to adjust for a soft input area.
         */
        final ArrayList<View> mScrollContainers = new ArrayList<View>();

        final KeyEvent.DispatcherState mKeyDispatchState
                = new KeyEvent.DispatcherState();

        /**
         * Indicates whether the view's window currently has the focus.
         */
        boolean mHasWindowFocus;

        /**
         * The current visibility of the window.
         */
        int mWindowVisibility;

        /**
         * Indicates the time at which drawing started to occur.
         */
        long mDrawingTime;

        /**
         * Indicates whether or not ignoring the DIRTY_MASK flags.
         */
        boolean mIgnoreDirtyState;

        /**
         * This flag tracks when the mIgnoreDirtyState flag is set during draw(),
         * to avoid clearing that flag prematurely.
         */
        boolean mSetIgnoreDirtyState = false;

        /**
         * Indicates whether the view's window is currently in touch mode.
         */
        boolean mInTouchMode;

        /**
         * Indicates that ViewAncestor should trigger a global layout change
         * the next time it performs a traversal
         */
        boolean mRecomputeGlobalAttributes;

        /**
         * Always report new attributes at next traversal.
         */
        boolean mForceReportNewAttributes;

        /**
         * Set during a traveral if any views want to keep the screen on.
         */
        boolean mKeepScreenOn;

        /**
         * Bitwise-or of all of the values that views have passed to setSystemUiVisibility().
         */
        int mSystemUiVisibility;

        /**
         * Hack to force certain system UI visibility flags to be cleared.
         */
        int mDisabledSystemUiVisibility;

        /**
         * Last global system UI visibility reported by the window manager.
         */
        int mGlobalSystemUiVisibility;

        /**
         * True if a view in this hierarchy has an OnSystemUiVisibilityChangeListener
         * attached.
         */
        boolean mHasSystemUiListeners;

        /**
         * Set if the window has requested to extend into the overscan region
         * via WindowManager.LayoutParams.FLAG_LAYOUT_IN_OVERSCAN.
         */
        boolean mOverscanRequested;

        /**
         * Set if the visibility of any views has changed.
         */
        boolean mViewVisibilityChanged;

        /**
         * Set to true if a view has been scrolled.
         */
        boolean mViewScrollChanged;

        /**
         * Global to the view hierarchy used as a temporary for dealing with
         * x/y points in the transparent region computations.
         */
        final int[] mTransparentLocation = new int[2];

        /**
         * Global to the view hierarchy used as a temporary for dealing with
         * x/y points in the ViewGroup.invalidateChild implementation.
         */
        final int[] mInvalidateChildLocation = new int[2];


        /**
         * Global to the view hierarchy used as a temporary for dealing with
         * x/y location when view is transformed.
         */
        final float[] mTmpTransformLocation = new float[2];

        /**
         * The view tree observer used to dispatch global events like
         * layout, pre-draw, touch mode change, etc.
         */
        final ViewTreeObserver mTreeObserver = new ViewTreeObserver();

        /**
         * A Canvas used by the view hierarchy to perform bitmap caching.
         */
        Canvas mCanvas;

        /**
         * The view root impl.
         */
        final ViewRootImpl mViewRootImpl;

        /**
         * A Handler supplied by a view's {@link android.view.ViewRootImpl}. This
         * handler can be used to pump events in the UI events queue.
         */
        final Handler mHandler;

        /**
         * Temporary for use in computing invalidate rectangles while
         * calling up the hierarchy.
         */
        final Rect mTmpInvalRect = new Rect();

        /**
         * Temporary for use in computing hit areas with transformed views
         */
        final RectF mTmpTransformRect = new RectF();

        /**
         * Temporary for use in transforming invalidation rect
         */
        final Matrix mTmpMatrix = new Matrix();

        /**
         * Temporary for use in transforming invalidation rect
         */
        final Transformation mTmpTransformation = new Transformation();

        /**
         * Temporary list for use in collecting focusable descendents of a view.
         */
        final ArrayList<View> mTempArrayList = new ArrayList<View>(24);

        /**
         * The id of the window for accessibility purposes.
         */
        int mAccessibilityWindowId = View.NO_ID;

        /**
         * Flags related to accessibility processing.
         *
         * @see AccessibilityNodeInfo#FLAG_INCLUDE_NOT_IMPORTANT_VIEWS
         * @see AccessibilityNodeInfo#FLAG_REPORT_VIEW_IDS
         */
        int mAccessibilityFetchFlags;

        /**
         * The drawable for highlighting accessibility focus.
         */
        Drawable mAccessibilityFocusDrawable;

        /**
         * Show where the margins, bounds and layout bounds are for each view.
         */
        boolean mDebugLayout = SystemProperties.getBoolean(DEBUG_LAYOUT_PROPERTY, false);

        /**
         * Point used to compute visible regions.
         */
        final Point mPoint = new Point();

        /**
         * Used to track which View originated a requestLayout() call, used when
         * requestLayout() is called during layout.
         */
        View mViewRequestingLayout;

        /**
         * Creates a new set of attachment information with the specified
         * events handler and thread.
         *
         * @param handler the events handler the view must use
         */
        AttachInfo(IWindowSession session, IWindow window, Display display,
                ViewRootImpl viewRootImpl, Handler handler, Callbacks effectPlayer) {
            mSession = session;
            mWindow = window;
            mWindowToken = window.asBinder();
            mDisplay = display;
            mViewRootImpl = viewRootImpl;
            mHandler = handler;
            mRootCallbacks = effectPlayer;
        }
    }

首先是声明了回调接口类：callBacks 这个类第一个是playSoundEffect ,这个用于播放按键声音，参数是这个点击事件的类型，可以看SoundEffectConstants中的声明，一般是SoundEffectConstants中几个常量中的一个，在AttachInfo有一个CallBack对象 ：mRootCallBacks 这个的实现可以看ViewRootImpl类，ViewRootImpl中，我们可以看到：

public void playSoundEffect(int effectId) {
      checkThread();

      if (mMediaDisabled) {
          return;
      }

      try {
          final AudioManager audioManager = getAudioManager();

          switch (effectId) {
              case SoundEffectConstants.CLICK:
                  audioManager.playSoundEffect(AudioManager.FX_KEY_CLICK);
                  return;
              case SoundEffectConstants.NAVIGATION_DOWN:
                  audioManager.playSoundEffect(AudioManager.FX_FOCUS_NAVIGATION_DOWN);
                  return;
              case SoundEffectConstants.NAVIGATION_LEFT:
                  audioManager.playSoundEffect(AudioManager.FX_FOCUS_NAVIGATION_LEFT);
                  return;
              case SoundEffectConstants.NAVIGATION_RIGHT:
                  audioManager.playSoundEffect(AudioManager.FX_FOCUS_NAVIGATION_RIGHT);
                  return;
              case SoundEffectConstants.NAVIGATION_UP:
                  audioManager.playSoundEffect(AudioManager.FX_FOCUS_NAVIGATION_UP);
                  return;
              default:
                  throw new IllegalArgumentException("unknown effect id " + effectId +
                          " not defined in " + SoundEffectConstants.class.getCanonicalName());
          }
      } catch (IllegalStateException e) {
          // Exception thrown by getAudioManager() when mView is null
          Log.e(TAG, "FATAL EXCEPTION when attempting to play sound effect: " + e);
          e.printStackTrace();
      }
  }

那么我们在自定义的View上，重写playSoundEffect方法就可以了。每一个View都有playSoundEffect方法，我们可以改动这个方法。

CallBack中还有一个方法：

performHapticFeedback这个意思就是触感反馈，参数可以看HapticFeedBack这个类，当用户在系统打开触感反馈选项，我们View的

performHapticFeedback(int feedBackContants )这个方法，当然，如果我们调用performHapticFeedback(int feedbackConstant, int flags) 的时候，把参数FLAG_IGNORE_GLOBAL_SETTING 就可以忽略全局设置，而如果我们HapticFeedbackConstants.FLAG_IGNORE_VIEW_SETTING 就可以忽略我们在View里面设置的android:hapticFeedbackEnabled 

关于CallBack就讲到这里，接下来我们继续往下看InvalidateInfo。InvalidateInfo用于刷新UI，当我们刷新UI的时候，会生成一个新的InvalidateInfo对象，然后根据这个来刷新UI。这个比较简单，就不详细说了。

在AttachInfo中，还有其他的信息，在这边，我们可以拿到和Window相关的信息：

<span style="white-space:pre">    </span>final IWindowSession mSession;
<span style="white-space:pre">    </span>
        final IWindow mWindow;

        final IBinder mWindowToken;
        IBinder   mPanelParentWindowToken ；

一般来说，IWinodwSession是通过：

WindowManagerGlobal.peekWindowSession() 或者是WindowManagerGlobal.getWindowSession() 来获取的

两者一般来说是差不多的，就是peek返回的可能为空 get一般返回是不为空的。另外，IWindowSession 、IWindow 、mWindowToken 都是从IWindowManager.Stub.asInterface(ServiceManager.getService("window"))获取到IWindowManager来获取的。

相关的可以看前面的第10篇：Binder进阶：系统服务中的Binder 以及ServiceManager的源码来看。

mPanelParentWindowToken 如果该窗口时子窗口，那么该值就是父窗口的W对象，如果mWindowToken不为空，则说明没有父窗口…嗯，和mWindowToken有点相对的意思。比如说Activity 的DecorView 的AttachInfo这个值就是null,而我们弹出了一个对话框，这个对话框的这个就不为null，因为这个对话框是有父窗口的。