elpa ecif toc metrics 通過 onf asset nali 一般來說

每一個View都需要依賴於窗口來顯示，而View和窗口的關系則是放在View.AttachInfo中,關於View.AttachInfo的文章少，因為這個是View的內部類而且不是公共的，在應用層用的很少，只有在ViewRootImpl等類中才用到了，不過我覺得這個還是有點學習的必要，因此在這篇文章中就從源碼入手學習下AttachInfo這個類。

AttachInfo 看到這個類名，我們就知道，他是代表著綁定的信息，View.AttachInfo 裏面的信息，就是View和Window之間的信息。每一個被添加到窗口上的View我們都會看到有一個AttachInfo，比如我們看DecorView和Window的綁定，可以在ViewRootImpl#perfromTraversals方法中看到：
[java] view plain copy

1. final View.AttachInfo attachInfo = mAttachInfo;
3. final int viewVisibility = getHostVisibility();
4. boolean viewVisibilityChanged = mViewVisibility != viewVisibility
5. || mNewSurfaceNeeded;
7. WindowManager.LayoutParams params = null;
8. if (mWindowAttributesChanged) {
9. mWindowAttributesChanged = false;
10. surfaceChanged = true;
11. params = lp;
12. }
13. CompatibilityInfo compatibilityInfo = mDisplayAdjustments.getCompatibilityInfo();
14. if (compatibilityInfo.supportsScreen() == mLastInCompatMode) {
15. params = lp;
16. mFullRedrawNeeded = true;
17. mLayoutRequested = true;
18. if (mLastInCompatMode) {
19. params.privateFlags &= ~WindowManager.LayoutParams.PRIVATE_FLAG_COMPATIBLE_WINDOW;
20. mLastInCompatMode = false;
21. } else {
22. params.privateFlags |= WindowManager.LayoutParams.PRIVATE_FLAG_COMPATIBLE_WINDOW;
23. mLastInCompatMode = true;
24. }
25. }
27. mWindowAttributesChangesFlag = 0;
29. Rect frame = mWinFrame;
30. if (mFirst) {
31. mFullRedrawNeeded = true;
32. mLayoutRequested = true;
34. if (lp.type == WindowManager.LayoutParams.TYPE_STATUS_BAR_PANEL
35. || lp.type == WindowManager.LayoutParams.TYPE_INPUT_METHOD) {
36. // NOTE -- system code, won‘t try to do compat mode.
37. Point size = new Point();
38. mDisplay.getRealSize(size);
39. desiredWindowWidth = size.x;
40. desiredWindowHeight = size.y;
41. } else {
42. DisplayMetrics packageMetrics =
43. mView.getContext().getResources().getDisplayMetrics();
44. desiredWindowWidth = packageMetrics.widthPixels;
45. desiredWindowHeight = packageMetrics.heightPixels;
46. }
48. // For the very first time, tell the view hierarchy that it
49. // is attached to the window. Note that at this point the surface
50. // object is not initialized to its backing store, but soon it
51. // will be (assuming the window is visible).
52. attachInfo.mSurface = mSurface;
53. // We used to use the following condition to choose 32 bits drawing caches:
54. // PixelFormat.hasAlpha(lp.format) || lp.format == PixelFormat.RGBX_8888
55. // However, windows are now always 32 bits by default, so choose 32 bits
56. attachInfo.mUse32BitDrawingCache = true;
57. attachInfo.mHasWindowFocus = false;
58. attachInfo.mWindowVisibility = viewVisibility;
59. attachInfo.mRecomputeGlobalAttributes = false;
60. viewVisibilityChanged = false;
61. mLastConfiguration.setTo(host.getResources().getConfiguration());
62. mLastSystemUiVisibility = mAttachInfo.mSystemUiVisibility;
63. // Set the layout direction if it has not been set before (inherit is the default)
64. if (mViewLayoutDirectionInitial == View.LAYOUT_DIRECTION_INHERIT) {
65. host.setLayoutDirection(mLastConfiguration.getLayoutDirection());
66. }
67. host.dispatchAttachedToWindow(attachInfo, 0);

AttachInfo 會通過View的diapatchAttachedTowWindow分發給View。如果是一個ViewGroup 那麽這個這個AttachInfo也會分發給所有子View，以引用的方式。 下面我們可以看下AttachInfo這個類，這個類是View的內部類，不是聲明為public的，所以只有view這個包中的類才用到。
[java] view plain copy

1. static class AttachInfo {
2. interface Callbacks {
3. void playSoundEffect(int effectId);
4. boolean performHapticFeedback(int effectId, boolean always);
5. }
7. /**
8. * InvalidateInfo is used to post invalidate(int, int, int, int) messages
9. * to a Handler. This class contains the target (View) to invalidate and
10. * the coordinates of the dirty rectangle.
11. *
12. * For performance purposes, this class also implements a pool of up to
13. * POOL_LIMIT objects that get reused. This reduces memory allocations
14. * whenever possible.
15. */
16. static class InvalidateInfo {
17. private static final int POOL_LIMIT = 10;
19. private static final SynchronizedPool<InvalidateInfo> sPool =
20. new SynchronizedPool<InvalidateInfo>(POOL_LIMIT);
22. View target;
24. int left;
25. int top;
26. int right;
27. int bottom;
29. public static InvalidateInfo obtain() {
30. InvalidateInfo instance = sPool.acquire();
31. return (instance != null) ? instance : new InvalidateInfo();
32. }
34. public void recycle() {
35. target = null;
36. sPool.release(this);
37. }
38. }
40. final IWindowSession mSession;
42. final IWindow mWindow;
44. final IBinder mWindowToken;
46. final Display mDisplay;
48. final Callbacks mRootCallbacks;
50. HardwareCanvas mHardwareCanvas;
52. IWindowId mIWindowId;
53. WindowId mWindowId;
55. /**
56. * The top view of the hierarchy.
57. */
58. View mRootView;
60. IBinder mPanelParentWindowToken;
61. Surface mSurface;
63. boolean mHardwareAccelerated;
64. boolean mHardwareAccelerationRequested;
65. HardwareRenderer mHardwareRenderer;
67. boolean mScreenOn;
69. /**
70. * Scale factor used by the compatibility mode
71. */
72. float mApplicationScale;
74. /**
75. * Indicates whether the application is in compatibility mode
76. */
77. boolean mScalingRequired;
79. /**
80. * If set, ViewRootImpl doesn‘t use its lame animation for when the window resizes.
81. */
82. boolean mTurnOffWindowResizeAnim;
84. /**
85. * Left position of this view‘s window
86. */
87. int mWindowLeft;
89. /**
90. * Top position of this view‘s window
91. */
92. int mWindowTop;
94. /**
95. * Indicates whether views need to use 32-bit drawing caches
96. */
97. boolean mUse32BitDrawingCache;
99. /**
100. * For windows that are full-screen but using insets to layout inside
101. * of the screen areas, these are the current insets to appear inside
102. * the overscan area of the display.
103. */
104. final Rect mOverscanInsets = new Rect();
106. /**
107. * For windows that are full-screen but using insets to layout inside
108. * of the screen decorations, these are the current insets for the
109. * content of the window.
110. */
111. final Rect mContentInsets = new Rect();
113. /**
114. * For windows that are full-screen but using insets to layout inside
115. * of the screen decorations, these are the current insets for the
116. * actual visible parts of the window.
117. */
118. final Rect mVisibleInsets = new Rect();
120. /**
121. * The internal insets given by this window. This value is
122. * supplied by the client (through
123. * [email protected] ViewTreeObserver.OnComputeInternalInsetsListener}) and will
124. * be given to the window manager when changed to be used in laying
125. * out windows behind it.
126. */
127. final ViewTreeObserver.InternalInsetsInfo mGivenInternalInsets
128. = new ViewTreeObserver.InternalInsetsInfo();
130. /**
131. * Set to true when mGivenInternalInsets is non-empty.
132. */
133. boolean mHasNonEmptyGivenInternalInsets;
135. /**
136. * All views in the window‘s hierarchy that serve as scroll containers,
137. * used to determine if the window can be resized or must be panned
138. * to adjust for a soft input area.
139. */
140. final ArrayList<View> mScrollContainers = new ArrayList<View>();
142. final KeyEvent.DispatcherState mKeyDispatchState
143. = new KeyEvent.DispatcherState();
145. /**
146. * Indicates whether the view‘s window currently has the focus.
147. */
148. boolean mHasWindowFocus;
150. /**
151. * The current visibility of the window.
152. */
153. int mWindowVisibility;
155. /**
156. * Indicates the time at which drawing started to occur.
157. */
158. long mDrawingTime;
160. /**
161. * Indicates whether or not ignoring the DIRTY_MASK flags.
162. */
163. boolean mIgnoreDirtyState;
165. /**
166. * This flag tracks when the mIgnoreDirtyState flag is set during draw(),
167. * to avoid clearing that flag prematurely.
168. */
169. boolean mSetIgnoreDirtyState = false;
171. /**
172. * Indicates whether the view‘s window is currently in touch mode.
173. */
174. boolean mInTouchMode;
176. /**
177. * Indicates that ViewAncestor should trigger a global layout change
178. * the next time it performs a traversal
179. */
180. boolean mRecomputeGlobalAttributes;
182. /**
183. * Always report new attributes at next traversal.
184. */
185. boolean mForceReportNewAttributes;
187. /**
188. * Set during a traveral if any views want to keep the screen on.
189. */
190. boolean mKeepScreenOn;
192. /**
193. * Bitwise-or of all of the values that views have passed to setSystemUiVisibility().
194. */
195. int mSystemUiVisibility;
197. /**
198. * Hack to force certain system UI visibility flags to be cleared.
199. */
200. int mDisabledSystemUiVisibility;
202. /**
203. * Last global system UI visibility reported by the window manager.
204. */
205. int mGlobalSystemUiVisibility;
207. /**
208. * True if a view in this hierarchy has an OnSystemUiVisibilityChangeListener
209. * attached.
210. */
211. boolean mHasSystemUiListeners;
213. /**
214. * Set if the window has requested to extend into the overscan region
215. * via WindowManager.LayoutParams.FLAG_LAYOUT_IN_OVERSCAN.
216. */
217. boolean mOverscanRequested;
219. /**
220. * Set if the visibility of any views has changed.
221. */
222. boolean mViewVisibilityChanged;
224. /**
225. * Set to true if a view has been scrolled.
226. */
227. boolean mViewScrollChanged;
229. /**
230. * Global to the view hierarchy used as a temporary for dealing with
231. * x/y points in the transparent region computations.
232. */
233. final int[] mTransparentLocation = new int[2];
235. /**
236. * Global to the view hierarchy used as a temporary for dealing with
237. * x/y points in the ViewGroup.invalidateChild implementation.
238. */
239. final int[] mInvalidateChildLocation = new int[2];
242. /**
243. * Global to the view hierarchy used as a temporary for dealing with
244. * x/y location when view is transformed.
245. */
246. final float[] mTmpTransformLocation = new float[2];
248. /**
249. * The view tree observer used to dispatch global events like
250. * layout, pre-draw, touch mode change, etc.
251. */
252. final ViewTreeObserver mTreeObserver = new ViewTreeObserver();
254. /**
255. * A Canvas used by the view hierarchy to perform bitmap caching.
256. */
257. Canvas mCanvas;
259. /**
260. * The view root impl.
261. */
262. final ViewRootImpl mViewRootImpl;
264. /**
265. * A Handler supplied by a view‘s [email protected] android.view.ViewRootImpl}. This
266. * handler can be used to pump events in the UI events queue.
267. */
268. final Handler mHandler;
270. /**
271. * Temporary for use in computing invalidate rectangles while
272. * calling up the hierarchy.
273. */
274. final Rect mTmpInvalRect = new Rect();
276. /**
277. * Temporary for use in computing hit areas with transformed views
278. */
279. final RectF mTmpTransformRect = new RectF();
281. /**
282. * Temporary for use in transforming invalidation rect
283. */
284. final Matrix mTmpMatrix = new Matrix();
286. /**
287. * Temporary for use in transforming invalidation rect
288. */
289. final Transformation mTmpTransformation = new Transformation();
291. /**
292. * Temporary list for use in collecting focusable descendents of a view.
293. */
294. final ArrayList<View> mTempArrayList = new ArrayList<View>(24);
296. /**
297. * The id of the window for accessibility purposes.
298. */
299. int mAccessibilityWindowId = View.NO_ID;
301. /**
302. * Flags related to accessibility processing.
303. *
304. * @see AccessibilityNodeInfo#FLAG_INCLUDE_NOT_IMPORTANT_VIEWS
305. * @see AccessibilityNodeInfo#FLAG_REPORT_VIEW_IDS
306. */
307. int mAccessibilityFetchFlags;
309. /**
310. * The drawable for highlighting accessibility focus.
311. */
312. Drawable mAccessibilityFocusDrawable;
314. /**
315. * Show where the margins, bounds and layout bounds are for each view.
316. */
317. boolean mDebugLayout = SystemProperties.getBoolean(DEBUG_LAYOUT_PROPERTY, false);
319. /**
320. * Point used to compute visible regions.
321. */
322. final Point mPoint = new Point();
324. /**
325. * Used to track which View originated a requestLayout() call, used when
326. * requestLayout() is called during layout.
327. */
328. View mViewRequestingLayout;
330. /**
331. * Creates a new set of attachment information with the specified
332. * events handler and thread.
333. *
334. * @param handler the events handler the view must use
335. */
336. AttachInfo(IWindowSession session, IWindow window, Display display,
337. ViewRootImpl viewRootImpl, Handler handler, Callbacks effectPlayer) {
338. mSession = session;
339. mWindow = window;
340. mWindowToken = window.asBinder();
341. mDisplay = display;
342. mViewRootImpl = viewRootImpl;
343. mHandler = handler;
344. mRootCallbacks = effectPlayer;
345. }
346. }

首先是聲明了回調接口類：callBacks 這個類第一個是playSoundEffect ,這個用於播放按鍵聲音，參數是這個點擊事件的類型，可以看SoundEffectConstants中的聲明，一般是SoundEffectConstants中幾個常量中的一個，在AttachInfo有一個CallBack對象 ：mRootCallBacks 這個的實現可以看ViewRootImpl類，ViewRootImpl中，我們可以看到：

[java] view plain copy

1. public void playSoundEffect(int effectId) {
2. checkThread();
4. if (mMediaDisabled) {
5. return;
6. }
8. try {
9. final AudioManager audioManager = getAudioManager();
11. switch (effectId) {
12. case SoundEffectConstants.CLICK:
13. audioManager.playSoundEffect(AudioManager.FX_KEY_CLICK);
14. return;
15. case SoundEffectConstants.NAVIGATION_DOWN:
16. audioManager.playSoundEffect(AudioManager.FX_FOCUS_NAVIGATION_DOWN);
17. return;
18. case SoundEffectConstants.NAVIGATION_LEFT:
19. audioManager.playSoundEffect(AudioManager.FX_FOCUS_NAVIGATION_LEFT);
20. return;
21. case SoundEffectConstants.NAVIGATION_RIGHT:
22. audioManager.playSoundEffect(AudioManager.FX_FOCUS_NAVIGATION_RIGHT);
23. return;
24. case SoundEffectConstants.NAVIGATION_UP:
25. audioManager.playSoundEffect(AudioManager.FX_FOCUS_NAVIGATION_UP);
26. return;
27. default:
28. throw new IllegalArgumentException("unknown effect id " + effectId +
29. " not defined in " + SoundEffectConstants.class.getCanonicalName());
30. }
31. } catch (IllegalStateException e) {
32. // Exception thrown by getAudioManager() when mView is null
33. Log.e(TAG, "FATAL EXCEPTION when attempting to play sound effect: " + e);
34. e.printStackTrace();
35. }
36. }

那麽我們在自定義的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相關的信息： [java] view plain copy

1. <span style="white-space:pre"> </span>final IWindowSession mSession;
2. <span style="white-space:pre"> </span>
3. final IWindow mWindow;
5. final IBinder mWindowToken;
6. 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，因為這個對話框是有父窗口的。

017.View與窗口：AttachInfo