017.View与窗口：AttachInfo
每一个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 sPool =
new SynchronizedPool(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 mScrollContainers = new ArrayList();
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 mTempArrayList = new ArrayList(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;
}
} 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();
}
} 是的，这个就是控制AudioManager来播放我们系统的点击声音，如果我们需要修改按钮的点击声音，就有如下几个方法，
如果是修改Framework 那么我们可以修改AudioManager的这个playSoundEffect方法，修改对应类型，也可以直接修改ViewRootImpl中这个方法（不建议），不过最后一个改动 基本上就是改动全局，如果我们自定义控件想要触发点击声音不同呢？
那么我们在自定义的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相关的信息：
final IWindowSession mSession;
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，因为这个对话框是有父窗口的。