9 |
10 | -----
11 |
12 | ##### 概要说明：
13 |
14 | * 已发布文章 发表已经整理好的文章，读者可以阅读学习！
15 |
16 | * 认领方式 可以在 issues 提你要认领什么内容。
17 |
18 | ~~* 已认领文章 如果你喜欢的文章被认领，你想参与,你还是可以分析认领，我们选择好的发布，也可以作为校对者。认领方式：可以在 Issues 提你要认领什么内容~~
19 |
20 | ~~* 待认领文章 是想参与的的同学可以参与进来，如被认领，也可以做校对者，若想解析的内容不在表格，可以联系我们添加分析的内容，方式：在 Issues 提你要认领什么内容~~
21 |
22 | ##### 校对发布说明：
23 | 分析完成后可直接在对应 issue 下回复，可直接原文回复也可是原文链接，校对通过后会直接进行发布。（这样大家可以更灵活自由的安排，同时也可以更快的发布校对好的文章）
24 |
25 | ##### 转载说明：
26 | 这里每一篇文章我们都或多或少的付出了时间、精力分析校对，第一次搞这种源码解析，可能有很多地方做的不好，但是我们用心做了！所以，如果你想转载，至少文章开头写下来源地址：
27 |
28 | [https://github.com/LittleFriendsGroup/AndroidSdkSourceAnalysis](https://github.com/LittleFriendsGroup/AndroidSdkSourceAnalysis)
29 |
30 | ,还有写下分析者名字！请尊重每一篇文章的劳动成果，谢谢！
31 |
32 | ## 已发布文章
33 |
34 | ### 第三期
35 | Class | 分析者 | 校对者 | 版本 | 发布时间
36 | :------------- | :------------- | :------------- | :------------- | :-------------
37 | [ViewGroup 源码解析](https://github.com/LittleFriendsGroup/AndroidSdkSourceAnalysis/blob/master/article/ViewGroup%20%E6%BA%90%E7%A0%81%E8%A7%A3%E6%9E%90.md) | [7heaven](https://github.com/7heaven) | [Nukc](https://github.com/nukc) | branch nougat-mr2-release | 2017/4/17
38 | [StaticLayout 源码解析](http://jaeger.itscoder.com/android/2016/08/05/staticlayout-source-analyse.html) | [laobie](https://github.com/laobie) | [7heaven](https://github.com/7heaven) | android api 23 | 2017/4/17
39 | [AtomicFile 源码解析](https://github.com/GcsSloop/AndroidNote/blob/master/SourceAnalysis/AtomicFile.md) | [GcsSloop](https://github.com/GcsSloop) | [Nukc](https://github.com/nukc) | android api 25 | 2017/4/17
40 | [Spannable 源码解析](https://github.com/lber19535/SourceAnalysis/blob/master/Spannable%20%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90.md) | [lber19535](https://github.com/lber19535) | [Nukc](https://github.com/nukc) | android api 24 | 2017/4/17
41 | [Notification 源码解析](http://www.jianshu.com/p/0cb97db7090c) | [huanglongyu](https://github.com/huanglongyu) | [Nukc](https://github.com/nukc) | android api 21 (cm) | 2017/4/17
42 | [SparseArray 源码解析](http://sonaive.me/2016/05/04/sparse-array-analysis/) | [taoliuh](https://github.com/taoliuh) | [Nukc](https://github.com/nukc) | android api 22 | 2017/4/17
43 | [ViewStub 源码解析](https://github.com/LittleFriendsGroup/AndroidSdkSourceAnalysis/blob/master/article/ViewStub%20%E6%BA%90%E7%A0%81%E8%A7%A3%E6%9E%90.md) | [Nukc](https://github.com/nukc) | [7heaven](https://github.com/7heaven) | android api 25 | 2017/4/17
44 |
45 | ### 第二期
46 | Class | 分析者 | 校对者 | 版本 | 发布时间
47 | :------------- | :------------- | :------------- | :------------- | :-------------
48 | [MediaPlayer源码解析](https://github.com/lber19535/SourceAnalysis/blob/master/Media%20Player%20%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90.md) | [lber19535](https://github.com/lber19535) | [android-cjj](https://github.com/android-cjj) | android api 22 | 2016/7/25
49 | [NavigationView源码解析](https://github.com/hongyangAndroid/AndroidSdkSourceAnalysis/blob/master/article/NavigationView%E6%BA%90%E7%A0%81%E8%A7%A3%E6%9E%90.md) | [hongyangAndroid](https://github.com/hongyangAndroid) | [android-cjj](https://github.com/android-cjj) | support-v7-23.1.0 | 2016/7/25
50 | [Service源码解析](https://github.com/asLody/SourceAnalysis/blob/master/Service%E6%BA%90%E7%A0%81%E8%A7%A3%E6%9E%90.md) | [asLody](https://github.com/asLody) | [liaohuqiu](https://github.com/liaohuqiu) | android api 23 | 2016/7/25
51 | [SharePreferences源码解析](http://blog.csdn.net/yanbober/article/details/47866369) | [yanbober](https://github.com/yanbober) | [android-cjj](https://github.com/android-cjj) | android api 22 | 2016/7/25
52 | [ScrollView源码分析](https://github.com/Skykai521/AndroidSdkSourceAnalysis/blob/master/article/ScrollView%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90.md) | [Skykai521](https://github.com/Skykai521) | [android-cjj](https://github.com/android-cjj) | android api 23 | 2016/7/25
53 | [Handler源码解析](https://github.com/maoruibin/HandlerAnalysis) | [maoruibin](https://github.com/maoruibin) | [android-cjj](https://github.com/android-cjj) | android api 23 | 2016/7/25
54 | [NestedScrollView源码解析](https://github.com/xmuSistone/android-source-analysis/blob/master/NestedScrollView.md) | [xmuSistone](https://github.com/xmuSistone) | [android-cjj](https://github.com/android-cjj) | support-v4-23.1.0 | 2016/7/25
55 | [SQLiteOpenHelper/...源码解析](https://github.com/YZHIWEN/AndroidSdkSourceAnalysis/blob/master/SQLite_Android.md) | [YZHIWEN](https://github.com/YZHIWEN) | [CaMnter](https://github.com/CaMnter) | android api 23 | 2016/7/25
56 | [Bundle源码解析](https://github.com/ASPOOK/BundleAnalysis) | [ASPOOK](https://github.com/ASPOOK) | [CaMnter](https://github.com/CaMnter) | android api 23 | 2016/7/25
57 | [LocalBroadcastManager源码解析](https://github.com/czhzero/AndroidSdkSourceAnalysis/blob/master/article/LocalBroadcastManager%E6%BA%90%E7%A0%81%E8%A7%A3%E6%9E%90.md) | [czhzero](https://github.com/czhzero) | [CaMnter](https://github.com/CaMnter) | support-v4-23.4.0 | 2016/7/25
58 | [Toast源码解析](https://github.com/WuXiaolong/AndroidSdkSourceAnalysis/blob/master/article/Toast%E6%BA%90%E7%A0%81%E8%A7%A3%E6%9E%90.md) | [Wuxiaolong](https://github.com/WuXiaolong) | [Nukc](https://github.com/nukc) | android api 23 | 2016/7/25
59 | [TextInputLayout源码解析](https://github.com/wbersaty/TextInputLayout-24) | [wbersaty](https://github.com/wbersaty) | [android-cjj](https://github.com/android-cjj) | design-24.0.0-alpha2 | 2016/7/25
60 | [LayoutInflater...源码解析](https://github.com/peerless2012/SourceAnalysis/blob/master/Android/FrameWork/LayoutInflater%26LayoutInflaterCompat%E6%BA%90%E7%A0%81%E8%A7%A3%E6%9E%90.md) | [peerless2012](https://github.com/peerless2012) | [android-cjj](https://github.com/android-cjj) | android api 23 | 2016/7/25
61 | [NestedScrolling事件机制源码解析](http://www.jianshu.com/p/6547ec3202bd) | [android-cjj](https://github.com/android-cjj) | [android-cjj](https://github.com/android-cjj/) | design-24.0.0 | 2016/7/25
62 |
63 | ### 第一期
64 |
65 | Class | 分析者 | 校对者 | 版本 | 发布时间
66 | :------------- | :------------- | :------------- | :------------- | :-------------
67 | [Binder源码解析](https://github.com/xdtianyu/SourceAnalysis/blob/master/Binder%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90.md) | [xdtianyu](https://github.com/xdtianyu) |[xdtianyu](https://github.com/xdtianyu) |android api 23| 2016/5/8
68 | [TextView源码解析](https://github.com/7heaven/AndroidSdkSourceAnalysis/blob/master/article/textview%E6%BA%90%E7%A2%BC%E8%A7%A3%E6%9E%90.md) | [7heaven](https://github.com/7heaven) |[7heaven](https://github.com/7heaven) |android api 23| 2016/5/8
69 | [CoordinatorLayout源码解析](https://github.com/desmond1121/AndroidSdkSourceAnalysis/blob/master/article/CoordinatorLayout%E6%BA%90%E7%A0%81%E8%A7%A3%E6%9E%90.md) | [Desmond Yao](https://github.com/desmond1121) |[轻微](https://github.com/zzz40500) | support-v7-23.2.1| 2016/5/8
70 | [Scroller源码解析](https://github.com/Skykai521/AndroidSdkSourceAnalysis/blob/master/article/Scroller%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90.md) | [Skykai521](https://github.com/Skykai521) |[子墨](https://github.com/zimoguo) | android api 22 | 2016/5/8
71 | [SwipeRefreshLayout 源码解析](https://github.com/hanks-zyh/SwipeRefreshLayout/blob/master/README.md) | [hanks-zyh](https://github.com/hanks-zyh) |[android-cjj](https://github.com/android-cjj/) | support-v7-23.2.1| 2016/5/8
72 | [FloatingActionButton源码解析](https://github.com/Rowandjj/my_awesome_blog/blob/master/fab_anlysis/README.md) | [Rowandjj](https://github.com/Rowandjj) |[CaMnter](https://github.com/CaMnter) | support-v7-23.2.1| 2016/5/8
73 | [AsyncTask源码解析](https://github.com/white37/AndroidSdkSourceAnalysis/blob/master/article/AsyncTask%E5%92%8CAsyncTaskCompat%E6%BA%90%E7%A0%81%E8%A7%A3%E6%9E%90.md) | [white37](https://github.com/white37) |[android-cjj](https://github.com/android-cjj/) | android api 23 | 2016/5/8
74 | [TabLayout源码解析](https://github.com/Aspsine/AndroidSdkSourceAnalysis/blob/master/article/TabLayout%E6%BA%90%E7%A0%81%E8%A7%A3%E6%9E%90.md) | [Aspsine](https://github.com/Aspsine) |[android-cjj](https://github.com/android-cjj/) | design-23.2.0 | 2016/5/8
75 | [CompoundButton源码解析](https://github.com/Tikitoo/AndroidSdkSourceAnalysis/blob/master/article/CompoundButton%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90.md) | [Tikitoo](https://github.com/Tikitoo) |[android-cjj](https://github.com/android-cjj/) | android api 23 | 2016/5/8
76 | [LinearLayout源码解析](https://github.com/razerdp/AndroidSourceAnalysis/blob/master/LinearLayout/android_widget_LinearLayout.md) | [razerdp](https://github.com/razerdp) |[android-cjj](https://github.com/android-cjj/) | support-v7-23.2.1 | 2016/5/8
77 | [SearchView源码解析](https://github.com/nukc/SearchViewAnalysis/blob/master/README.md) | [Nukc](https://github.com/nukc) |[android-cjj](https://github.com/android-cjj/) | support-v7-23.2.1 | 2016/5/7
78 | [LruCache源码解析](https://github.com/LittleFriendsGroup/AndroidSdkSourceAnalysis/blob/master/article/LruCache%E6%BA%90%E7%A0%81%E8%A7%A3%E6%9E%90.md) | [CaMnter](https://github.com/CaMnter)| [alafighting](https://github.com/alafighting)|support-v4-23.2.1 | 2016/4/24
79 | [ViewDragHelper源码解析](https://github.com/LittleFriendsGroup/AndroidSdkSourceAnalysis/blob/master/article/ViewDragHelper%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90.md) | [达庆凯](https://github.com/Skykai521)| [android-cjj](https://github.com/android-cjj/)|support-v4-21.0 | 2016/4/21
80 | [BottomSheets源码解析](https://github.com/android-cjj/SourceAnalysis) | [android-cjj](https://github.com/android-cjj/)| [轻微](https://github.com/zzz40500)|design-23.2.0 | 2016/4/20
81 |
82 |
83 |
84 | ## 已认领文章
85 | (写好的童鞋可以加 QQ 群:369144556做校对)
86 | 
241 |
242 | *// Relink e as tail*
243 | 
244 |
245 | LinkedHashMap 是双向循环链表，然后此次 **LruCache.get -> LinkedHashMap.get** 的数据就被放到最末尾了。
246 |
247 | **以上就是 LruCache 核心工作原理**。
248 |
249 | ---
250 |
251 | 接下来介绍 **LruCache 的容量溢出策略**。
252 |
253 |
254 |
255 | ### 4.6 LruCache.put(K key, V value)
256 | ```java
257 | public final V put(K key, V value) {
258 | ...
259 | synchronized (this) {
260 | ...
261 | // 拿到键值对，计算出在容量中的相对长度，然后加上
262 | size += safeSizeOf(key, value);
263 | ...
264 | }
265 | ...
266 | trimToSize(maxSize);
267 | return previous;
268 | }
269 | ```
270 | 记住几点：
271 | - **1.**put 开始的时候确实是把值放入 LinkedHashMap 了，**不管超不超过你设定的缓存容量**。
272 | - **2.**然后根据 `safeSizeOf` 方法计算 此次添加数据的容量是多少，并且加到 `size` 里 。
273 | - **3.**说到 `safeSizeOf` 就要讲到 `sizeOf(K key, V value)` 会计算出此次添加数据的大小 。
274 | - **4.**直到 put 要结束时，进行了 `trimToSize` 才判断 `size` 是否 大于 `maxSize` 然后进行最近很少访问数据的移除。
275 |
276 | ### 4.7 LruCache.trimToSize(int maxSize)
277 | ```java
278 | public void trimToSize(int maxSize) {
279 | /*
280 | * 这是一个死循环，
281 | * 1.只有 扩容 的情况下能立即跳出
282 | * 2.非扩容的情况下，map的数据会一个一个删除，直到map里没有值了，就会跳出
283 | */
284 | while (true) {
285 | K key;
286 | V value;
287 | synchronized (this) {
288 | // 在重新调整容量大小前，本身容量就为空的话，会出异常的。
289 | if (size < 0 || (map.isEmpty() && size != 0)) {
290 | throw new IllegalStateException(
291 | getClass().getName() + ".sizeOf() is reporting inconsistent results!");
292 | }
293 | // 如果是 扩容 或者 map为空了，就会中断，因为扩容不会涉及到丢弃数据的情况
294 | if (size <= maxSize || map.isEmpty()) {
295 | break;
296 | }
297 |
298 | Map.Entry
15 |
16 | 用法也非常简单，只需要在布局文件中声明即可：
17 |
18 | ```xml
19 | 
266 |
267 | 简单数一下，怎么好像是4种，恩，其实上图2，4都是`NavigationMenuTextItem `，只不过4中传入的item的`hasSubMenu=true`.
268 |
269 | 这样的话，我们就分析完成了数据源的初始化。
270 |
271 | 那么Adapter有了数据源，并且调用了`notifyDataSetChanged`，接下来应该看的代码就是Adapter内部的`onCreateViewHolder和onCreateViewHolder`等代码了。
272 |
273 | ###（3）NavigationMenuAdapter
274 |
275 | 因为我们涉及到多个item type，所以重点看三个方法，分别为：`getItemViewType`，`onCreateViewHolder`,`onBindViewHolder`。
276 |
277 | * getItemViewType
278 |
279 | ```java
280 | #NavigationMenuPresenter.NavigationMenuAdapter
281 | @Override
282 | public int getItemViewType(int position) {
283 | NavigationMenuItem item = mItems.get(position);
284 | if (item instanceof NavigationMenuSeparatorItem) {
285 | return VIEW_TYPE_SEPARATOR;
286 | } else if (item instanceof NavigationMenuHeaderItem) {
287 | return VIEW_TYPE_HEADER;
288 | } else if (item instanceof NavigationMenuTextItem) {
289 | NavigationMenuTextItem textItem = (NavigationMenuTextItem) item;
290 | if (textItem.getMenuItem().hasSubMenu()) {
291 | return VIEW_TYPE_SUBHEADER;
292 | } else {
293 | return VIEW_TYPE_NORMAL;
294 | }
295 | }
296 | throw new RuntimeException("Unknown item type.");
297 | }
298 | ```
299 | 根据item的类型去决定ItemViewType，那么我们上面已经进行了详细的分析，一种有3种item类型，其中`NavigationMenuTextItem `分为`hasSubMenu() `为true,false两种情况。刚好对应上述代码。
300 |
301 | * onCreateViewHolder
302 |
303 | ```java
304 | #NavigationMenuPresenter.NavigationMenuAdapter
305 | @Override
306 | public ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
307 | switch (viewType) {
308 | case VIEW_TYPE_NORMAL:
309 | return new NormalViewHolder(mLayoutInflater, parent, mOnClickListener);
310 | case VIEW_TYPE_SUBHEADER:
311 | return new SubheaderViewHolder(mLayoutInflater, parent);
312 | case VIEW_TYPE_SEPARATOR:
313 | return new SeparatorViewHolder(mLayoutInflater, parent);
314 | case VIEW_TYPE_HEADER:
315 | return new HeaderViewHolder(mHeaderLayout);
316 | }
317 | return null;
318 | }
319 | ```
320 |
321 | 根据不同的itemViewType，返回不同的ViewHolder，每个viewholder也对应一个布局文件，分别为：
322 |
323 | * SubheaderViewHolder 对应的布局文件为一个TextView
324 | * SeparatorViewHolder 对应一个FrameLayout，其内部是`height=1dp`的View
325 | * HeaderViewHolder 对应mHeaderLayout，其实就是LinearLayout包裹我们设置的headerLayout
326 | * NormalViewHolder 这个对应于一个`NavigationMenuItemView`
327 |
328 |
329 | 那么大概知道每个itemViewType对应的布局文件之后，就可以看onBindViewHolder了
330 |
331 | * onBindViewHolder
332 |
333 | ```java
334 | @Override
335 | #NavigationMenuPresenter.NavigationMenuAdapter
336 | public void onBindViewHolder(ViewHolder holder, int position) {
337 | switch (getItemViewType(position)) {
338 | case VIEW_TYPE_NORMAL: {
339 | NavigationMenuItemView itemView = (NavigationMenuItemView) holder.itemView;
340 | itemView.setIconTintList(mIconTintList);
341 | if (mTextAppearanceSet) {
342 | itemView.setTextAppearance(itemView.getContext(), mTextAppearance);
343 | }
344 | if (mTextColor != null) {
345 | itemView.setTextColor(mTextColor);
346 | }
347 | itemView.setBackgroundDrawable(mItemBackground != null ?
348 | mItemBackground.getConstantState().newDrawable() : null);
349 | NavigationMenuTextItem item = (NavigationMenuTextItem) mItems.get(position);
350 | itemView.initialize(item.getMenuItem(), 0);
351 | break;
352 | }
353 | case VIEW_TYPE_SUBHEADER: {
354 | TextView subHeader = (TextView) holder.itemView;
355 | NavigationMenuTextItem item = (NavigationMenuTextItem) mItems.get(position);
356 | subHeader.setText(item.getMenuItem().getTitle());
357 | break;
358 | }
359 | case VIEW_TYPE_SEPARATOR: {
360 | NavigationMenuSeparatorItem item =
361 | (NavigationMenuSeparatorItem) mItems.get(position);
362 | holder.itemView.setPadding(0, item.getPaddingTop(), 0,
363 | item.getPaddingBottom());
364 | break;
365 | }
366 | case VIEW_TYPE_HEADER: {
367 | break;
368 | }
369 | }
370 |
371 | }
372 | ```
373 |
374 | 恩，这里主要就是为4中itemTypeView所对应的item进行控件的赋值了，从简单到难来看：
375 |
376 | * `VIEW_TYPE_HEADER` 什么都不管，只要把我们设置的headerLayout显示即可
377 | * `VIEW_TYPE_SEPARATOR`首先拿到`NavigationMenuSeparatorItem `，主要是为了拿到padding的值，然后调用`holder.itemView`设置上下的padding，这个padding默认值为8dp。
378 | * `VIEW_TYPE_SUBHEADER`拿到TextView设置下title即可。
379 | * `VIEW_TYPE_NORMAL `
380 |
381 | 最后这个呢，对应`NavigationMenuItemView`，通过它呢去设置字体，图标，字体颜色，图标颜色，以及根据`item.getMenuItem`设置各种状态。
382 |
383 | 那么到这里呢，我们就学习完成了`NavigationMenuAdapter `它的内部的处理，那么我们的`NavigationView`已经能够正常的显示了。
384 |
385 | 显示完了之后，还有个问题，`NavigationView`的Item是可以点击了，如果大家有印象的话，`RecyclerView`自身是没有提供Item点击的回调的，那么`NavigationView`是如何做的。
386 |
387 | ###（3）Item点击[onNavigationItemSelected]
388 |
389 | 对于接受Item点击，只有`VIEW_TYPE_NORMAL`的itemViewType才可以，那么我们回顾下`onCreateViewHolder `方法
390 |
391 | ```java
392 | #NavigationMenuPresenter.NavigationMenuAdapter
393 | public ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
394 | switch (viewType) {
395 | case VIEW_TYPE_NORMAL:
396 | return new NormalViewHolder(mLayoutInflater, parent, mOnClickListener);
397 | //...
398 | return null ;
399 | }
400 | ```
401 | 注意当为`VIEW_TYPE_NORMAL `的时候创建的ViewHolder传入了一个`mOnClickListener `.
402 |
403 | ```java
404 | #NavigationMenuPresenter.NavigationMenuAdapter
405 | private static class NormalViewHolder extends ViewHolder {
406 |
407 | public NormalViewHolder(LayoutInflater inflater, ViewGroup parent,
408 | View.OnClickListener listener) {
409 | super(inflater.inflate(R.layout.design_navigation_item, parent, false));
410 | itemView.setOnClickListener(listener);
411 | }
412 |
413 | }
414 | ```
415 |
416 | 可以看到，直接调用了`itemView.setOnClickListener `。那么我们看下这个listener
417 |
418 | ```java
419 | #NavigationMenuPresenter
420 | private final View.OnClickListener mOnClickListener = new View.OnClickListener() {
421 |
422 | @Override
423 | public void onClick(View v) {
424 | NavigationMenuItemView itemView = (NavigationMenuItemView) v;
425 | MenuItemImpl item = itemView.getItemData();
426 | boolean result = mMenu.performItemAction(item, NavigationMenuPresenter.this, 0);
427 | if (item != null && item.isCheckable() && result) {
428 | mAdapter.setCheckedItem(item);
429 | }
430 | updateMenuView(false);
431 | }
432 | };
433 | ```
434 |
435 | 代码不多，经过扫描，应该关注`mMenu.performItemAction`方法：
436 |
437 | ```java
438 | #MenuBuilder
439 | public boolean performItemAction(MenuItem item, MenuPresenter preferredPresenter, int flags) {
440 | MenuItemImpl itemImpl = (MenuItemImpl) item;
441 | //省略了一些代码
442 | boolean invoked = itemImpl.invoke();
443 | return invoked;
444 | }
445 | ```
446 | 继续跟进去
447 |
448 | ```java
449 | #MenuItemImpl
450 | public boolean invoke() {
451 | //省略了一些代码
452 | if (mMenu.dispatchMenuItemSelected(mMenu.getRootMenu(), this)) {
453 | return true;
454 | }
455 | return false;
456 | }
457 | ```
458 |
459 | 那么主要是`mMenu.dispatchMenuItemSelected `了
460 |
461 | ```java
462 | #MenuBuilder
463 | boolean dispatchMenuItemSelected(MenuBuilder menu, MenuItem item) {
464 | return mCallback != null && mCallback.onMenuItemSelected(menu, item);
465 | }
466 | ```
467 | 终于看到mCallback了，回顾下，在onCreateViewHolder的时候，给我们的itemView添加了clicklistener,当我们点击的时候会辗转调用至`mCallback.onMenuItemSelected(menu, item);`。
468 |
469 | 而这个`mCallback`正是在`NavigationView`构造方法中设置的。
470 |
471 | ```java
472 | #NavigationView
473 | mMenu.setCallback(new MenuBuilder.Callback() {
474 | @Override
475 | public boolean onMenuItemSelected(MenuBuilder menu, MenuItem item) {
476 | return mListener != null && mListener.onNavigationItemSelected(item);
477 | }
478 |
479 | @Override
480 | public void onMenuModeChange(MenuBuilder menu) {}
481 | });
482 | ```
483 |
484 | ok，到这我们就理清楚了onMenuItemSelected的回调。
485 |
486 | 还有个问题，当我们点击的时候，如果添加监听，并且在`onMenuItemSelected `直接`return true`，我们的选中的Item会被高亮显示。
487 |
488 | 这个其实也在刚才的`mOnClickListener `里面
489 |
490 |
491 | ```java
492 | private final View.OnClickListener mOnClickListener = new View.OnClickListener() {
493 |
494 | @Override
495 | public void onClick(View v) {
496 | NavigationMenuItemView itemView = (NavigationMenuItemView) v;
497 | MenuItemImpl item = itemView.getItemData();
498 | boolean result = mMenu.performItemAction(item, NavigationMenuPresenter.this, 0);
499 | if (item != null && item.isCheckable() && result) {
500 | mAdapter.setCheckedItem(item);
501 | }
502 | updateMenuView(false);
503 | }
504 | };
505 | ```
506 |
507 | 当我们回调返回true，也就意味着`result = true`，那么正常情况下(`checkable=true`)会调用` mAdapter.setCheckedItem(item);`
508 |
509 | ```java
510 | #NavigationMenuAdapter
511 | public void setCheckedItem(MenuItemImpl checkedItem) {
512 | if (mCheckedItem == checkedItem || !checkedItem.isCheckable()) {
513 | return;
514 | }
515 | if (mCheckedItem != null) {
516 | mCheckedItem.setChecked(false);
517 | }
518 | mCheckedItem = checkedItem;
519 | checkedItem.setChecked(true);
520 | }
521 | ```
522 | 在这里的对上一次选择的item调用了`setChecked(false);`对本次的选中的item调用了`setChecked(true);`从而得到状态切换的效果。
523 |
524 | 如下图：
525 |
526 | 
527 |
528 | ps:早起的版本中，对于`setCheckedItem `的操作，是需要我们自行处理的，建议对于desgin库，尽可能使用最新的版本。
529 |
530 | 到这里，我们的整个分析就结束了，整个分析从寻找RecylerView，数据源的初始化与设置，Item点击的设置3个点进行展开，源码并不复杂，希望大家可以通过本文加深对`NavigationView`的理解，从而进一步加深对`RecyclerView`用法的理解。
531 |
--------------------------------------------------------------------------------
/article/ViewDragHelper源码分析.md:
--------------------------------------------------------------------------------
1 | ViewDragHelper源码解析
2 | =========
3 |
4 | ### 1.简介
5 | 我们了解了`ViewDragHelper`是可以帮助我们处理各种拖拽事件的类.使用好`ViewDragHelper`能帮助我们做出各种酷炫的交互,今天我们就来分析一下`ViewDragHelper`的使用与实现:
6 |
7 | ### 2.使用方法
8 |
9 | 我们这里就以[翔总的这篇文章](http://blog.csdn.net/lmj623565791/article/details/46858663)中的例子来介绍一下`ViewDragHelper`的使用.另外,本文中的demo可以在
10 | [这里找到](https://github.com/Skykai521/ViewDragHelperDemo)
11 |
12 | 首先我们创建一个`DragLayout`类并继承自`LinearLayout`,然后我们准备在`DragLayout`放置三个`View`第一个用来被我们拖动然后停止在松手的位置,第二个可以被我们拖动,松手的时候滑动到指定位置,第三个只可以通过触摸边缘来进行拖动,
13 |
14 | ```java
15 |
16 | public class DragLayout extends LinearLayout {
17 |
18 | private ViewDragHelper mDragger;
19 | private View mDragView;
20 | private View mAutoBackView;
21 | private View mEdgeTrackerView;
22 |
23 | private Point mAutoBackOriginPos = new Point();
24 |
25 | public DragLayout(Context context) {
26 | this(context, null);
27 | }
28 |
29 | public DragLayout(Context context, AttributeSet attrs) {
30 | this(context, attrs, 0);
31 | }
32 |
33 | public DragLayout(Context context, AttributeSet attrs, int defStyleAttr) {
34 | super(context, attrs, defStyleAttr);
35 | initViewDragHelper();
36 | }
37 |
38 | private void initViewDragHelper() {
39 | mDragger = ViewDragHelper.create(this,myCallback);
40 | mDragger.setEdgeTrackingEnabled(ViewDragHelper.EDGE_ALL);
41 | }
42 |
43 | ViewDragHelper.Callback myCallback = new ViewDragHelper.Callback() {
44 | @Override
45 | //child为当前触摸区域下的View,如果返回true,就可以拖拽.
46 | public boolean tryCaptureView(View child, int pointerId) {
47 | return child == mDragView || child == mAutoBackView;
48 | }
49 |
50 | //松手时的回调
51 | @Override
52 | public void onViewReleased(View releasedChild, float xvel, float yvel) {
53 | if (releasedChild == mAutoBackView) {
54 | mDragger.settleCapturedViewAt(mAutoBackOriginPos.x, mAutoBackOriginPos.y);
55 | invalidate();
56 | }
57 | }
58 |
59 | //边缘触摸开始时的回调
60 | @Override
61 | public void onEdgeDragStarted(int edgeFlags, int pointerId) {
62 | mDragger.captureChildView(mEdgeTrackerView, pointerId);
63 | }
64 |
65 | //获取水平方向允许拖拽的区域,这里是父布局的宽-子控件的宽
66 | @Override
67 | public int getViewHorizontalDragRange(View child) {
68 | return getMeasuredWidth() - child.getMeasuredWidth();
69 | }
70 |
71 | //获取垂直方向允许拖拽的范围
72 | @Override
73 | public int getViewVerticalDragRange(View child) {
74 | return getMeasuredHeight() - child.getMeasuredHeight();
75 | }
76 |
77 | //left为child即将移动到的水平位置的值,但是返回值会最终决定移动到的值
78 | //这里直接返回了left
79 | @Override
80 | public int clampViewPositionHorizontal(View child, int left, int dx) {
81 | return left;
82 | }
83 | //同上只是这里是垂直方向
84 | @Override
85 | public int clampViewPositionVertical(View child, int top, int dy) {
86 | return top;
87 | }
88 | };
89 |
90 | @Override
91 | public void computeScroll() {
92 | if (mDragger.continueSettling(true)) {
93 | invalidate();
94 | }
95 | }
96 |
97 | @Override
98 | public boolean onInterceptTouchEvent(MotionEvent ev) {
99 | return mDragger.shouldInterceptTouchEvent(ev);
100 | }
101 |
102 | @Override
103 | public boolean onTouchEvent(MotionEvent event) {
104 | mDragger.processTouchEvent(event);
105 | return true;
106 | }
107 |
108 | @Override
109 | protected void onFinishInflate() {
110 | super.onFinishInflate();
111 | mDragView = getChildAt(0);
112 | mAutoBackView = getChildAt(1);
113 | mEdgeTrackerView = getChildAt(2);
114 | }
115 |
116 | @Override
117 | protected void onLayout(boolean changed, int l, int t, int r, int b) {
118 | super.onLayout(changed, l, t, r, b);
119 | mAutoBackOriginPos.x = mAutoBackView.getLeft();
120 | mAutoBackOriginPos.y = mAutoBackView.getTop();
121 | }
122 | }
123 |
124 | ```
125 | 1. 我们首先在构造方法里传入了当前类的对象和我们定义的`ViewDragHelper.Callback`对象初始化了我们的`ViewDragHelper`,然后我们希望所有的边缘触摸都能触发`mEdgeTrackerView`的拖动,所以我们紧接着调用了`mDragger.setEdgeTrackingEnabled(ViewDragHelper.EDGE_ALL);`方法.
126 | 2. 在我们定义的`Callback`中,有多个回调方法,每个回调方法都有它的作用,在代码里注释比较清楚了，我们下面也会解析每一个`Callback`中回调方法的作用.
127 | 3. 第三步我们需要在`onInterceptTouchEvent()`方法和`onTouchEvent()`将事件委托给`ViewDragHelper`去处理,这样`ViewDragHelper`才能根据响应的事件并回调我们自己编写的`Callback`接口来进行响应的处理,
128 | 4. 由于`ViewDragHelper`中的滑动是交给`Srcoller`类来处理的所以这里我们要重写`computeScroll()`方法,配合`Scroller`完成滚动动画.
129 | 5. 最后在`onFinishInflate()`里获取到我们的`View`对象即可.
130 |
131 | ### 3.类关系图
132 |
133 | 由于就一个类类图我们就不画了,但是作为一个强迫症患者,这个标题必须有...
134 |
135 | ### 4.源码分析
136 | #### 1.ViewDragHelper.Callback的实现
137 | 在分析`ViewDragHelper`之前,我们先来分析一下`Callback`的定义,看看`Callback`都定义了哪些方法:
138 | ```java
139 |
140 | public static abstract class Callback {
141 |
142 | //当View的拖拽状态改变时回调,state为STATE_IDLE,STATE_DRAGGING,STATE_SETTLING的一种
143 | //STATE_IDLE: 当前未被拖拽
144 | //STATE_DRAGGING：正在被拖拽
145 | //STATE_SETTLING: 被拖拽后需要被安放到一个位置中的状态
146 | public void onViewDragStateChanged(int state) {}
147 |
148 | //当View被拖拽位置发生改变时回调
149 | //changedView ：被拖拽的View
150 | //left : 被拖拽后View的left边缘坐标
151 | //top : 被拖拽后View的top边缘坐标
152 | //dx : 拖动的x偏移量
153 | //dy : 拖动的y偏移量
154 | public void onViewPositionChanged(View changedView, int left, int top, int dx, int dy) {}
155 |
156 | //当一个View被捕获到准备开始拖动时回调,
157 | //capturedChild : 捕获的View
158 | //activePointerId : 对应的PointerId
159 | public void onViewCaptured(View capturedChild, int activePointerId) {}
160 |
161 | //当被捕获拖拽的View被释放是回调
162 | //releasedChild : 被释放的View
163 | //xvel : 释放View的x方向上的加速度
164 | //yvel : 释放View的y方向上的加速度
165 | public void onViewReleased(View releasedChild, float xvel, float yvel) {}
166 |
167 | //如果parentView订阅了边缘触摸,则如果有边缘触摸就回调的接口
168 | //edgeFlags : 当前触摸的flag 有: EDGE_LEFT,EDGE_TOP,EDGE_RIGHT,EDGE_BOTTOM
169 | //pointerId : 用来描述边缘触摸操作的id
170 | public void onEdgeTouched(int edgeFlags, int pointerId) {}
171 |
172 | //是否锁定该边缘的触摸,默认返回false,返回true表示锁定
173 | public boolean onEdgeLock(int edgeFlags) {
174 | return false;
175 | }
176 |
177 | //边缘触摸开始时回调
178 | //edgeFlags : 当前触摸的flag 有: EDGE_LEFT,EDGE_TOP,EDGE_RIGHT,EDGE_BOTTOM
179 | //pointerId : 用来描述边缘触摸操作的id
180 | public void onEdgeDragStarted(int edgeFlags, int pointerId) {}
181 |
182 | //在寻找当前触摸点下的子View时会调用此方法，寻找到的View会提供给tryCaptureViewForDrag()来尝试捕获。
183 | //如果需要改变子View的遍历查询顺序可改写此方法，例如让下层的View优先于上层的View被选中。
184 | public int getOrderedChildIndex(int index) {
185 | return index;
186 | }
187 |
188 | //获取被拖拽View child 的水平拖拽范围,返回0表示无法被水平拖拽
189 | public int getViewHorizontalDragRange(View child) {
190 | return 0;
191 | }
192 |
193 | //获取被拖拽View child 的垂直拖拽范围,返回0表示无法被水平拖拽
194 | public int getViewVerticalDragRange(View child) {
195 | return 0;
196 | }
197 |
198 | //尝试捕获被拖拽的View
199 | public abstract boolean tryCaptureView(View child, int pointerId);
200 |
201 | //决定拖拽View在水平方向上应该移动到的位置
202 | //child : 被拖拽的View
203 | //left : 期望移动到位置的View的left值
204 | //dx : 移动的水平距离
205 | //返回值 : 直接决定View在水平方向的位置
206 | public int clampViewPositionHorizontal(View child, int left, int dx) {
207 | return 0;
208 | }
209 |
210 | //决定拖拽View在垂直方向上应该移动到的位置
211 | //child : 被拖拽的View
212 | //top : 期望移动到位置的View的top值
213 | //dy : 移动的垂直距离
214 | //返回值 : 直接决定View在垂直方向的位置
215 | public int clampViewPositionVertical(View child, int top, int dy) {
216 | return 0;
217 | }
218 | }
219 |
220 | ```
221 | 想必注释已经很清楚了,正是这些回调方法,再结合`ViewDragHelper`中的各种方法,来帮助我们实现各种各样的拖拽的效果。
222 |
223 | #### 2.shouldInterceptTouchEvent()方法的实现
224 |
225 | 在这里我们假设大家都清楚了`Android`的事件分发机制,如果不清楚请看[这里](http://blog.csdn.net/guolin_blog/article/details/9097463),要想处理触摸事件,我们需要在`onInterceptTouchEvent(MotionEvent ev)`方法里判断是否需要拦截这次触摸事件,如果此方法返回`true`则触摸事件将会交给`onTouchEvent(MotionEvent event)`处理,这样我们就能处理触摸事件了,所以我们在上面的使用方法里会这样写:
226 |
227 | ```java
228 |
229 | @Override
230 | public boolean onInterceptTouchEvent(MotionEvent ev) {
231 | return mDragger.shouldInterceptTouchEvent(ev);
232 | }
233 |
234 | @Override
235 | public boolean onTouchEvent(MotionEvent event) {
236 | mDragger.processTouchEvent(event);
237 | return true;
238 | }
239 | ```
240 | 这样就将是否拦截触摸事件,以及处理触摸事件委托给`ViewDragHelper`来处理了,所以我们先来看看`ViewDragHelper`中`shouldInterceptTouchEvent();`方法的实现:
241 |
242 | ```java
243 |
244 | public boolean shouldInterceptTouchEvent(MotionEvent ev) {
245 | //获取action
246 | final int action = MotionEventCompat.getActionMasked(ev);
247 | //获取action对应的index
248 | final int actionIndex = MotionEventCompat.getActionIndex(ev);
249 |
250 | //如果是按下的action则重置一些信息,包括各种事件点的数组
251 | if (action == MotionEvent.ACTION_DOWN) {
252 | // Reset things for a new event stream, just in case we didn't get
253 | // the whole previous stream.
254 | cancel();
255 | }
256 | //初始化mVelocityTracker
257 | if (mVelocityTracker == null) {
258 | mVelocityTracker = VelocityTracker.obtain();
259 | }
260 | mVelocityTracker.addMovement(ev);
261 |
262 | //根据action来做相应的处理
263 | switch (action) {
264 | case MotionEvent.ACTION_DOWN: {
265 | final float x = ev.getX();
266 | final float y = ev.getY();
267 | //获取这个事件对应的pointerId,一般情况下只有一个手指触摸时为0
268 | //两个手指触摸时第二个手指触摸返回的pointerId为1，以此类推
269 | final int pointerId = MotionEventCompat.getPointerId(ev, 0);
270 | //保存点的数据
271 | //TODO (1)
272 | saveInitialMotion(x, y, pointerId);
273 | //获取当前触摸点下最顶层的子View
274 | //TODO (2)
275 | final View toCapture = findTopChildUnder((int) x, (int) y);
276 |
277 | //如果toCapture是已经捕获的View,而且正在处于被释放状态
278 | //那么就重新捕获
279 | if (toCapture == mCapturedView && mDragState == STATE_SETTLING) {
280 | tryCaptureViewForDrag(toCapture, pointerId);
281 | }
282 |
283 | //如果触摸了边缘,回调callback的onEdgeTouched()方法
284 | final int edgesTouched = mInitialEdgesTouched[pointerId];
285 | if ((edgesTouched & mTrackingEdges) != 0) {
286 | mCallback.onEdgeTouched(edgesTouched & mTrackingEdges, pointerId);
287 | }
288 | break;
289 | }
290 |
291 | //当又有一个手指触摸时
292 | case MotionEventCompat.ACTION_POINTER_DOWN: {
293 | final int pointerId = MotionEventCompat.getPointerId(ev, actionIndex);
294 | final float x = MotionEventCompat.getX(ev, actionIndex);
295 | final float y = MotionEventCompat.getY(ev, actionIndex);
296 |
297 | //保存触摸信息
298 | saveInitialMotion(x, y, pointerId);
299 |
300 | //因为同一时间ViewDragHelper只能操控一个View,所以当有新的手指触摸时
301 | //只讨论当无触摸发生时,回调边缘触摸的callback
302 | //或者正在处于释放状态时重新捕获View
303 | if (mDragState == STATE_IDLE) {
304 | final int edgesTouched = mInitialEdgesTouched[pointerId];
305 | if ((edgesTouched & mTrackingEdges) != 0) {
306 | mCallback.onEdgeTouched(edgesTouched & mTrackingEdges, pointerId);
307 | }
308 | } else if (mDragState == STATE_SETTLING) {
309 | // Catch a settling view if possible.
310 | final View toCapture = findTopChildUnder((int) x, (int) y);
311 | if (toCapture == mCapturedView) {
312 | tryCaptureViewForDrag(toCapture, pointerId);
313 | }
314 | }
315 | break;
316 | }
317 |
318 | //当手指移动时
319 | case MotionEvent.ACTION_MOVE: {
320 | if (mInitialMotionX == null || mInitialMotionY == null) break;
321 |
322 | // First to cross a touch slop over a draggable view wins. Also report edge drags.
323 | //得到触摸点的数量,并循环处理,只处理第一个发生了拖拽的事件
324 | final int pointerCount = MotionEventCompat.getPointerCount(ev);
325 | for (int i = 0; i < pointerCount; i++) {
326 | final int pointerId = MotionEventCompat.getPointerId(ev, i);
327 | final float x = MotionEventCompat.getX(ev, i);
328 | final float y = MotionEventCompat.getY(ev, i);
329 | //获得拖拽偏移量
330 | final float dx = x - mInitialMotionX[pointerId];
331 | final float dy = y - mInitialMotionY[pointerId];
332 | //获取当前触摸点下最顶层的子View
333 | final View toCapture = findTopChildUnder((int) x, (int) y);
334 | //如果找到了最顶层View,并且产生了拖动(checkTouchSlop()返回true)
335 | //TODO (3)
336 | final boolean pastSlop = toCapture != null && checkTouchSlop(toCapture, dx, dy);
337 | if (pastSlop) {
338 | //根据callback的四个方法getView[Horizontal|Vertical]DragRange和
339 | //clampViewPosition[Horizontal|Vertical]来检查是否可以拖动
340 | final int oldLeft = toCapture.getLeft();
341 | final int targetLeft = oldLeft + (int) dx;
342 | final int newLeft = mCallback.clampViewPositionHorizontal(toCapture,
343 | targetLeft, (int) dx);
344 | final int oldTop = toCapture.getTop();
345 | final int targetTop = oldTop + (int) dy;
346 | final int newTop = mCallback.clampViewPositionVertical(toCapture, targetTop,
347 | (int) dy);
348 | final int horizontalDragRange = mCallback.getViewHorizontalDragRange(
349 | toCapture);
350 | final int verticalDragRange = mCallback.getViewVerticalDragRange(toCapture);
351 | //如果都不允许移动则跳出循环
352 | if ((horizontalDragRange == 0 || horizontalDragRange > 0
353 | && newLeft == oldLeft) && (verticalDragRange == 0
354 | || verticalDragRange > 0 && newTop == oldTop)) {
355 | break;
356 | }
357 | }
358 | //记录并回调是否有边缘触摸
359 | reportNewEdgeDrags(dx, dy, pointerId);
360 | if (mDragState == STATE_DRAGGING) {
361 | // Callback might have started an edge drag
362 | break;
363 | }
364 | //如果产生了拖动则调用tryCaptureViewForDrag()
365 | //TODO (4)
366 | if (pastSlop && tryCaptureViewForDrag(toCapture, pointerId)) {
367 | break;
368 | }
369 | }
370 | //保存触摸点的信息
371 | saveLastMotion(ev);
372 | break;
373 | }
374 |
375 | //当有一个手指抬起时,清除这个手指的触摸数据
376 | case MotionEventCompat.ACTION_POINTER_UP: {
377 | final int pointerId = MotionEventCompat.getPointerId(ev, actionIndex);
378 | clearMotionHistory(pointerId);
379 | break;
380 | }
381 |
382 | //清除所有触摸数据
383 | case MotionEvent.ACTION_UP:
384 | case MotionEvent.ACTION_CANCEL: {
385 | cancel();
386 | break;
387 | }
388 | }
389 |
390 | //如果mDragState等于正在拖拽则返回true
391 | return mDragState == STATE_DRAGGING;
392 | }
393 |
394 | ```
395 | 上面就是整个`shouldInterceptTouchEvent()`的实现,上面的注释也足够清楚了,我们这里就先不分析某一种触摸事件,大家可以看到我上面留了几个TODO,下文会一起分析,这里我假设大家都已经对触摸事件分发处理都有充分的理解了,我们下面就直接看`ViewDragHelper`里`processTouchEvent()`方法的实现.
396 |
397 | #### 3.processTouchEvent()方法的实现
398 |
399 | ```java
400 |
401 | public void processTouchEvent(MotionEvent ev) {
402 | final int action = MotionEventCompat.getActionMasked(ev);
403 | final int actionIndex = MotionEventCompat.getActionIndex(ev);
404 |
405 | ...（省去部分代码）
406 | switch (action) {
407 | case MotionEvent.ACTION_DOWN: {
408 | ...（省去部分代码）
409 | break;
410 | }
411 |
412 | case MotionEventCompat.ACTION_POINTER_DOWN: {
413 | ...（省去部分代码）
414 | break;
415 | }
416 |
417 | case MotionEvent.ACTION_MOVE: {
418 | //如果现在已经是拖拽状态
419 | if (mDragState == STATE_DRAGGING) {
420 | final int index = MotionEventCompat.findPointerIndex(ev, mActivePointerId);
421 | final float x = MotionEventCompat.getX(ev, index);
422 | final float y = MotionEventCompat.getY(ev, index);
423 | final int idx = (int) (x - mLastMotionX[mActivePointerId]);
424 | final int idy = (int) (y - mLastMotionY[mActivePointerId]);
425 |
426 | //拖拽至指定位置
427 | //TODO (5)
428 | dragTo(mCapturedView.getLeft() + idx, mCapturedView.getTop() + idy, idx, idy);
429 |
430 | saveLastMotion(ev);
431 | } else {
432 | // Check to see if any pointer is now over a draggable view.
433 | //如果还不是拖拽状态,就检测是否经过了一个View
434 | final int pointerCount = MotionEventCompat.getPointerCount(ev);
435 | for (int i = 0; i < pointerCount; i++) {
436 | final int pointerId = MotionEventCompat.getPointerId(ev, i);
437 | final float x = MotionEventCompat.getX(ev, i);
438 | final float y = MotionEventCompat.getY(ev, i);
439 | final float dx = x - mInitialMotionX[pointerId];
440 | final float dy = y - mInitialMotionY[pointerId];
441 |
442 | reportNewEdgeDrags(dx, dy, pointerId);
443 | if (mDragState == STATE_DRAGGING) {
444 | // Callback might have started an edge drag.
445 | break;
446 | }
447 |
448 | final View toCapture = findTopChildUnder((int) x, (int) y);
449 | if (checkTouchSlop(toCapture, dx, dy) &&
450 | tryCaptureViewForDrag(toCapture, pointerId)) {
451 | break;
452 | }
453 | }
454 | saveLastMotion(ev);
455 | }
456 | break;
457 | }
458 | //当多个手指中的一个手机松开时
459 | case MotionEventCompat.ACTION_POINTER_UP: {
460 | final int pointerId = MotionEventCompat.getPointerId(ev, actionIndex);
461 | //如果当前点正在被拖拽,则再剩余还在触摸的点钟寻找是否正在View上
462 | if (mDragState == STATE_DRAGGING && pointerId == mActivePointerId) {
463 | // Try to find another pointer that's still holding on to the captured view.
464 | int newActivePointer = INVALID_POINTER;
465 | final int pointerCount = MotionEventCompat.getPointerCount(ev);
466 | for (int i = 0; i < pointerCount; i++) {
467 | final int id = MotionEventCompat.getPointerId(ev, i);
468 | if (id == mActivePointerId) {
469 | // This one's going away, skip.
470 | continue;
471 | }
472 |
473 | final float x = MotionEventCompat.getX(ev, i);
474 | final float y = MotionEventCompat.getY(ev, i);
475 | if (findTopChildUnder((int) x, (int) y) == mCapturedView &&
476 | tryCaptureViewForDrag(mCapturedView, id)) {
477 | newActivePointer = mActivePointerId;
478 | break;
479 | }
480 | }
481 |
482 | if (newActivePointer == INVALID_POINTER) {
483 | // We didn't find another pointer still touching the view, release it.
484 | //如果没找到则释放View
485 | //TODO (6)
486 | releaseViewForPointerUp();
487 | }
488 | }
489 | clearMotionHistory(pointerId);
490 | break;
491 | }
492 |
493 | case MotionEvent.ACTION_UP: {
494 | //如果是拖拽状态的释放则调用
495 | //releaseViewForPointerUp()
496 | if (mDragState == STATE_DRAGGING) {
497 | releaseViewForPointerUp();
498 | }
499 | cancel();
500 | break;
501 | }
502 |
503 | case MotionEvent.ACTION_CANCEL: {
504 | if (mDragState == STATE_DRAGGING) {
505 | dispatchViewReleased(0, 0);
506 | }
507 | cancel();
508 | break;
509 | }
510 | }
511 | }
512 |
513 | ```
514 |
515 | 上面就是`processTouchEvent()`方法的实现,我们省去了部分大致与`shouldInterceptTouchEvent()`相同的逻辑代码,通过事件传递机制我们知道,如果程序已经进入到`processTouchEvent()`中,也就意味着触摸事件就不会再向下传递,都会交给此方法处理,所以在这里我们就需要处理拖拽事件了,通过上面的注释,我们也看到了在`MotionEvent.ACTION_MOVE`,`MotionEventCompat.ACTION_POINTER_UP`,`MotionEvent.ACTION_UP`和`MotionEvent.ACTION_CANCEL`都分别进行了处理 ,我们知道触摸事件大致的流程是:
516 |
517 | ACTION_DOWN -> ACTION_MOVE -> ... -> ACTION_MOVE -> ACTION_UP
518 |
519 | 再配合事件的分发机制,我们就能很清晰的分析出一次完整的事件调用过程,所以整个`ViewDragHelper`的拖拽过程也能很清晰的分为三个步骤:
520 |
521 | 捕获拖拽目标View -> 拖拽目标View -> 处理目标View释放操作
522 |
523 | 最后我们再分析上面两段代码的6个TODO:
524 |
525 | #### 4.saveInitialMotion()方法
526 |
527 | ```java
528 | private void saveInitialMotion(float x, float y, int pointerId) {
529 | //确保各个数组的大小足够存放数据
530 | ensureMotionHistorySizeForId(pointerId);
531 | //保存x坐标
532 | mInitialMotionX[pointerId] = mLastMotionX[pointerId] = x;
533 | //保存y坐标
534 | mInitialMotionY[pointerId] = mLastMotionY[pointerId] = y;
535 | //保存是否触摸到边缘
536 | mInitialEdgesTouched[pointerId] = getEdgesTouched((int) x, (int) y);
537 | //保存当前id是否在触摸,用于后续验证
538 | mPointersDown |= 1 << pointerId;
539 | }
540 |
541 | ```
542 | #### 5.findTopChildUnder()方法
543 |
544 | ```java
545 | public View findTopChildUnder(int x, int y) {
546 | final int childCount = mParentView.getChildCount();
547 | for (int i = childCount - 1; i >= 0; i--) {
548 | final View child = mParentView.getChildAt(mCallback.getOrderedChildIndex(i));
549 | if (x >= child.getLeft() && x < child.getRight() &&
550 | y >= child.getTop() && y < child.getBottom()) {
551 | return child;
552 | }
553 | }
554 | return null;
555 | }
556 | ```
557 | 代码很简单就是根据`x`和`y`坐标和来找到指定`View`,注意这里回调了`callback`中的`getOrderedChildIndex()`方法,所以我们可以在这里返回指定的`View`的`index`.
558 |
559 | #### 6.checkTouchSlop()方法
560 |
561 | ```java
562 | private boolean checkTouchSlop(View child, float dx, float dy) {
563 | if (child == null) {
564 | return false;
565 | }
566 | final boolean checkHorizontal = mCallback.getViewHorizontalDragRange(child) > 0;
567 | final boolean checkVertical = mCallback.getViewVerticalDragRange(child) > 0;
568 |
569 | if (checkHorizontal && checkVertical) {
570 | return dx * dx + dy * dy > mTouchSlop * mTouchSlop;
571 | } else if (checkHorizontal) {
572 | return Math.abs(dx) > mTouchSlop;
573 | } else if (checkVertical) {
574 | return Math.abs(dy) > mTouchSlop;
575 | }
576 | return false;
577 | }
578 | ```
579 | 用来根据`mTouchSlop`最小拖动的距离来判断是否属于拖动,`mTouchSlop`根据我们设定的灵敏度决定.
580 |
581 | #### 7.tryCaptureViewForDrag()方法
582 |
583 | ```java
584 |
585 | boolean tryCaptureViewForDrag(View toCapture, int pointerId) {
586 | //如果已经捕获该View 直接返回true
587 | if (toCapture == mCapturedView && mActivePointerId == pointerId) {
588 | // Already done!
589 | return true;
590 | }
591 | //根据mCallback.tryCaptureView()方法来最终决定是否可以捕获View
592 | if (toCapture != null && mCallback.tryCaptureView(toCapture, pointerId)) {
593 | mActivePointerId = pointerId;
594 | //如果可以则调用captureChildView(),并返回true
595 | captureChildView(toCapture, pointerId);
596 | return true;
597 | }
598 | return false;
599 | }
600 |
601 | ```
602 | 可以看到如果可以捕获`View`则调用了`captureChildView()`方法:
603 |
604 | ```java
605 |
606 | public void captureChildView(View childView, int activePointerId) {
607 | if (childView.getParent() != mParentView) {
608 | throw new IllegalArgumentException("captureChildView: parameter must be a descendant " +
609 | "of the ViewDragHelper's tracked parent view (" + mParentView + ")");
610 | }
611 | //赋值mCapturedView
612 | mCapturedView = childView;
613 | mActivePointerId = activePointerId;
614 | //回调callback
615 | mCallback.onViewCaptured(childView, activePointerId);
616 | //设定mDragState的状态为STATE_DRAGGING
617 | setDragState(STATE_DRAGGING);
618 | }
619 |
620 | ```
621 | 如果程序执行到这里,就证明`View`已经处于拖拽状态了,后续的触摸操作,将直接根据`mDragState`为`STATE_DRAGGING`的状态处理.
622 |
623 | #### 8.dragTo()方法的实现
624 |
625 | ```java
626 |
627 | private void dragTo(int left, int top, int dx, int dy) {
628 | int clampedX = left;
629 | int clampedY = top;
630 | final int oldLeft = mCapturedView.getLeft();
631 | final int oldTop = mCapturedView.getTop();
632 | if (dx != 0) {
633 | //回调callback来决定View最终被拖拽的x方向上的偏移量
634 | clampedX = mCallback.clampViewPositionHorizontal(mCapturedView, left, dx);
635 | //移动View
636 | ViewCompat.offsetLeftAndRight(mCapturedView, clampedX - oldLeft);
637 | }
638 | if (dy != 0) {
639 | //回调callback来决定View最终被拖拽的y方向上的偏移量
640 | clampedY = mCallback.clampViewPositionVertical(mCapturedView, top, dy);
641 | //移动View
642 | ViewCompat.offsetTopAndBottom(mCapturedView, clampedY - oldTop);
643 | }
644 |
645 | if (dx != 0 || dy != 0) {
646 | final int clampedDx = clampedX - oldLeft;
647 | final int clampedDy = clampedY - oldTop;
648 | //回调callback
649 | mCallback.onViewPositionChanged(mCapturedView, clampedX, clampedY,
650 | clampedDx, clampedDy);
651 | }
652 | }
653 |
654 | ```
655 | 因为`dragTo()`方法是在`processTouchEvent()`中的`MotionEvent.ACTION_MOVE case`被调用所以当程序运行到这里时`View`就会不断的被拖动了。如果一旦手指释放则最终会调用`releaseViewForPointerUp()`方法
656 |
657 | #### 8.releaseViewForPointerUp()方法的实现
658 |
659 | ```java
660 |
661 | private void releaseViewForPointerUp() {
662 | //计算出当前x和y方向上的加速度
663 | mVelocityTracker.computeCurrentVelocity(1000, mMaxVelocity);
664 | final float xvel = clampMag(
665 | VelocityTrackerCompat.getXVelocity(mVelocityTracker, mActivePointerId),
666 | mMinVelocity, mMaxVelocity);
667 | final float yvel = clampMag(
668 | VelocityTrackerCompat.getYVelocity(mVelocityTracker, mActivePointerId),
669 | mMinVelocity, mMaxVelocity);
670 | dispatchViewReleased(xvel, yvel);
671 | }
672 |
673 | ```
674 | 计算完加速度后就调用了`dispatchViewReleased()`:
675 |
676 | ```java
677 |
678 | private void dispatchViewReleased(float xvel, float yvel) {
679 | //设定当前正处于释放阶段
680 | mReleaseInProgress = true;
681 | //回调callback的onViewReleased()方法
682 | mCallback.onViewReleased(mCapturedView, xvel, yvel);
683 | mReleaseInProgress = false;
684 |
685 | //设定状态
686 | if (mDragState == STATE_DRAGGING) {
687 | // onViewReleased didn't call a method that would have changed this. Go idle.
688 | //如果onViewReleased()中没有调用任何方法,则状态设定为STATE_IDLE
689 | setDragState(STATE_IDLE);
690 | }
691 | }
692 |
693 | ```
694 | 所以最后释放后的处理交给了`callback`中的`onViewReleased()`方法,如果我们什么都不做,那么这个被拖拽的`View`就是停止在当前位置,或者我们可以调用`ViewDragHelper`提供给我们的这几个方法:
695 |
696 | - settleCapturedViewAt(int finalLeft, int finalTop)
697 | 以松手前的滑动速度为初速动，让捕获到的View自动滚动到指定位置。只能在Callback的onViewReleased()中调用。
698 | - flingCapturedView(int minLeft, int minTop, int maxLeft, int maxTop)
699 | 以松手前的滑动速度为初速动，让捕获到的View在指定范围内fling。只能在Callback的onViewReleased()中调用。
700 | - smoothSlideViewTo(View child, int finalLeft, int finalTop)
701 | 指定某个View自动滚动到指定的位置，初速度为0，可在任何地方调用。
702 |
703 | 引用自[这篇文章](http://www.cnphp6.com/archives/87727),具体释放后的原理我们就不分析了,其实就是配合`Scroller`这个类来实现,具体也可以参照上面这篇文章。好,我们关于`ViewDragHelper`的源码分析就到这里.
704 |
705 | ### 5.开源项目中的使用
706 |
707 | `ViewDragHelper`在各种关于拖拽和各种手势动画的开源库中使用广泛,我这里就简要列出一些,大家可以多去看看是如何使用`ViewDragHelper`的:
708 |
709 | - [SwipeBackLayout](https://github.com/ikew0ng/SwipeBackLayout)
710 | - [android-card-slide-panel](https://github.com/xmuSistone/android-card-slide-panel)
711 | - [FlowingDrawer](https://github.com/mxn21/FlowingDrawer)
712 |
713 | ### 6.个人评价
714 | `ViewDragHelper`的出现,大大简化了我们开发相关触摸和拖拽功能的复杂度和代码量,帮助我们比较容易的实现各种效果,让我们开发酷炫的交互更加容易了。但是从一些开源项目中发现,`ViewDragHelper`中还是有一些不足之处,比如给`Scroller`提供了一个固定的`Interpolator`,导致如果我们想实现例如反弹效果的话,还要把`ViewDragHelper`的代码拷贝一份并修改`Interpolator`,这样做肯定是不太好的.当然建议我们自己修改一个`ViewDragHelper`后如果项目里有多处使用,可以包装成一个提供给我们自己项目的模块使用,防止出现更多的多余代码.
715 |
--------------------------------------------------------------------------------
/article/ViewGroup 源码解析.md:
--------------------------------------------------------------------------------
1 | # ViewGroup 源码解析
2 |
3 | ViewGroup应该算是日常Android开发中最常涉及到，但是也最少直接使用到的View子类。我们平时所谈论的触摸事件的传递、测量和布局的过程等，其实都源自ViewGroup。同时也是各种其他事件，比如onAttachedToWindow、onDetacheFromWindow、onConfigurationChanged等的中间人。
4 |
5 |
6 |
7 | ## ViewGroup生命周期
8 |
9 | 
10 |
11 | 可以看到ViewGroup也是和View一样在onAttachedToWindow以后，经理测量(onMeasure)、布局(onLayout)、然后才是绘制(ViewGroup默认不绘制自身，而是调用dispatchDraw来绘制子View)。和View不同的是，这每一步都需要对子View进行相同的操作。
12 |
13 |
14 |
15 | #### 测量和布局过程
16 |
17 | ViewGroup由于需要兼顾子View的测量和布局，以及在部分情况下子View的测量反过来影响ViewGroup的测量(例如ViewGroup的宽高为WRAP_CONTENT的时候)，整体的测量和布局需要经历比较复杂的过程。
18 |
19 |
20 |
21 | 首先从onMeasure方法开始，onMeasure传入了两个作为测量依据的参数,widthMeasureSpec, heightMeasureSpec。这两个参数表面上是int，但实际上是测量模式和父View要求的尺寸两个值组成的。这个int值的最高两位被用来储存测量模式，剩下的30位才是尺寸。测量模式有以下三种：
22 |
23 | * UNSPECIFIED 父View并没有强制要求当前ViewGroup遵从某个规范，当前ViewGroup可以是任何尺寸
24 | * EXACTLY 父View要求当前ViewGroup的宽度或者高度必须等于MeasureSpec传入的尺寸
25 | * AT_MOST 父View要求当前ViewGroup的宽度或者高度不能超过MeasureSpec传入的尺寸
26 |
27 | 然后ViewGroup根据传入的MeasureSpec以及自身对子View的排版规则对子View进行测量，在对子View的测量中又涉及到另一个类：LayoutParams。这个类相信大家都不陌生，不同的布局控件（RelativeLayout、LinearLayout、FrameLayout等)都有自己的一个LayoutParams。里面包含了针对当前布局的一些参数，这些参数影响了ViewGroup对子View的测量。
28 |
29 |
30 |
31 | LayoutParams和MeasureSpec是比较容易搞混的，两个都是和测量布局有关的参数，每个控件都有针对于父View的LayoutParams成员变量，但父View对自身进行测量的时候又要传入MeasureSpec。这两个参数的区别是什么呢？可以简单地理解为：LayoutParams是View自己对自己的布局要求，而MeasureSpec是父View参考了View的LayoutParams后，提出来的对View的布局要求。这就像孩子吵着要跟父母拿钱买十颗糖吃（LayoutParams），父母经过深思熟虑后，决定只给孩子买五颗糖（MeasureSpec）。
32 |
33 |
34 |
35 | ViewGroup内部并没有真正处理子View的测量，因为ViewGroup本身并没有针对子View的规则限制。只有在具体的布局中，比如RelativeLayout、LinearLayout，由于有子View的排版规则才会对子View进行测量。但是ViewGroup本身提供了默认的测量子View的方法：
36 |
37 | * measureChildren 根据ViewGroup自身onMeasure传入的MeasureSpec对所有子View进行测量，实际是遍历子View并调用了measureChild方法:
38 |
39 | ```java
40 | protected void measureChildren(int widthMeasureSpec, int heightMeasureSpec) {
41 | final int size = mChildrenCount;
42 | final View[] children = mChildren;
43 | // 遍历子View
44 | for (int i = 0; i < size; ++i) {
45 | final View child = children[i];
46 | // 检测当前子View的Visibility状态，如果是GONE则跳过
47 | if ((child.mViewFlags & VISIBILITY_MASK) != GONE) {
48 | measureChild(child, widthMeasureSpec, heightMeasureSpec);
49 | }
50 | }
51 | }
52 | ```
53 |
54 |
55 |
56 | * measureChild 根据ViewGroup自身onMeasure传入的MeasureSpec对某一个子View进行测量
57 |
58 | ```java
59 | protected void measureChild(View child, int parentWidthMeasureSpec,
60 | int parentHeightMeasureSpec) {
61 | // 获取子View的LayoutParams
62 | final LayoutParams lp = child.getLayoutParams();
63 |
64 | // 计算并返回子View的widthMeasureSpec
65 | final int childWidthMeasureSpec = getChildMeasureSpec(parentWidthMeasureSpec,
66 | mPaddingLeft + mPaddingRight, lp.width);
67 | // 计算并返回子View的heightMeasureSpec
68 | final int childHeightMeasureSpec = getChildMeasureSpec(parentHeightMeasureSpec,
69 | mPaddingTop + mPaddingBottom, lp.height);
70 |
71 | // 调用子View的measure方法，measure方法最终会调用子View的onMeasure，具体的实现在View内
72 | child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
73 | }
74 | ```
75 |
76 |
77 |
78 | 这里面实际核心的是getChildMeasureSpec方法，这是一个ViewGroup提供的根据ViewGroup自身的MeasureSpec，ViewGroup的padding以及子View的LayoutParams的width/height返回子View的MeasureSpec的方法：
79 |
80 | ```java
81 | public static int getChildMeasureSpec(int spec, int padding, int childDimension) {
82 | // 用MeasureSpec提供的方法来获取具体的模式和尺寸
83 | // (实际上是把高2位和低30位分开, mode = spec & 0xC0000000, size = spec & 0x3FFFFFFF)
84 | int specMode = MeasureSpec.getMode(spec);
85 | int specSize = MeasureSpec.getSize(spec);
86 |
87 | // 由于上一步获取的是ViewGroup自身的specSize，
88 | // 而ViewGroup留给子View的区域是要扣除padding的，这边需要减去padding
89 | int size = Math.max(0, specSize - padding);
90 |
91 | int resultSize = 0;
92 | int resultMode = 0;
93 |
94 | switch (specMode) {
95 | // ViewGroup自身的MeasureSpec为EXACTLY的时候
96 | case MeasureSpec.EXACTLY:
97 | if (childDimension >= 0) {
98 | // 子View的LayoutParams传入的尺寸既不是MATCH_PARENT也不是WRAP_CONTENT的时候，
99 | // 直接让子View的尺寸固定为传入的值
100 | resultSize = childDimension;
101 | resultMode = MeasureSpec.EXACTLY;
102 | } else if (childDimension == LayoutParams.MATCH_PARENT) {
103 | // 子View的LayoutParams传入的为MATCH_PARENT，即是和父View同样尺寸，
104 | // 直接给ViewGroup的size值
105 | resultSize = size;
106 | resultMode = MeasureSpec.EXACTLY;
107 | } else if (childDimension == LayoutParams.WRAP_CONTENT) {
108 | // 子View的LayoutParams传入的为WRAP_CONTENT，但是ViewGroup自身是固定的尺寸，
109 | // 这时候让子View在不超出ViewGroup的size的情况下自行决定大小
110 | resultSize = size;
111 | resultMode = MeasureSpec.AT_MOST;
112 | }
113 | break;
114 |
115 | // 传入的ViewGroup的MeasureSpec规定在给定的尺寸范围内自行决定大小，
116 | // 这通常是在ViewGroup本身的尺寸设置为WRAP_CONTENT的情况下传入
117 | // (参考上面MeasureSpec.EXACTLY的case里面childDimension == LayoutParams.WRAP_CONTNET的情况)
118 | case MeasureSpec.AT_MOST:
119 | if (childDimension >= 0) {
120 | //子View的LayoutParams传入的尺寸既不是MATCH_PARENT也不是WRAP_CONTENT的时候，
121 | //直接让子View的尺寸固定为传入的值
122 | resultSize = childDimension;
123 | resultMode = MeasureSpec.EXACTLY;
124 | } else if (childDimension == LayoutParams.MATCH_PARENT) {
125 | // 子View的LayoutParams传入的为MATCH_PARENT，但是ViewGroup自身的尺寸还未确定，
126 | //只能让子View在ViewGroup的size范围内自行决定大小
127 | resultSize = size;
128 | resultMode = MeasureSpec.AT_MOST;
129 | } else if (childDimension == LayoutParams.WRAP_CONTENT) {
130 | // 子View的LayoutParams传入的为WRAP_CONTENT，
131 | // 这时候让子View在不超出ViewGroup的size的情况下自行决定大小
132 | resultSize = size;
133 | resultMode = MeasureSpec.AT_MOST;
134 | }
135 | break;
136 |
137 | case MeasureSpec.UNSPECIFIED:
138 | if (childDimension >= 0) {
139 | //子View的LayoutParams传入的尺寸既不是MATCH_PARENT也不是WRAP_CONTENT的时候，
140 | //直接让子View的尺寸固定为传入的值
141 | resultSize = childDimension;
142 | resultMode = MeasureSpec.EXACTLY;
143 | } else if (childDimension == LayoutParams.MATCH_PARENT) {
144 | // 在ViewGroup自身的MeasureSpec未定义的情况下(UNSPECIFIED)，
145 | // 给子View也传未定义mode(这边sUseZeroUnspecifiedMeasureSpec)
146 | resultSize = View.sUseZeroUnspecifiedMeasureSpec ? 0 : size;
147 | resultMode = MeasureSpec.UNSPECIFIED;
148 | } else if (childDimension == LayoutParams.WRAP_CONTENT) {
149 | resultSize = View.sUseZeroUnspecifiedMeasureSpec ? 0 : size;
150 | resultMode = MeasureSpec.UNSPECIFIED;
151 | }
152 | break;
153 | }
154 | // 用MeasureSpec类的makeMeasureSpec把size和mode拼装成一个int并返回
155 | return MeasureSpec.makeMeasureSpec(resultSize, resultMode);
156 | }
157 | ```
158 |
159 |
160 |
161 | 
162 |
163 |
164 |
165 | 当然这只是ViewGroup提供的默认的方法，并不是强制的要求以这个规则返回子View的MeasureSpec。一些布局控件例如RelativeLayout会使用自己的子View的MeasureSpec生成规则。根据子View的LayoutParams来生成MeasureSpec，并对子View进行测量后，ViewGroup(继承自ViewGroup的类)就可以进行布局了。(布局对应的方法onLayout是一个抽象方法，在不同的ViewGroup的子类中有不一样的实现)
166 |
167 |
168 |
169 | ### 子View的添加和删除
170 |
171 |
172 |
173 | ViewGroup添加子View的方法有多个，但是最终都会调addView(child, index, params)方法，并在这个方法内调用私有方法addViewInner来实现的。
174 |
175 |
176 |
177 | 我们前面知道了每个子View都需要有一个LayoutParams来告诉ViewGroup它布局的时候需要的一些参数，而当添加View的时候，View没有LayoutParams，或者我们调用了没有LayoutParams作为形参的addView方法的时候，ViewGroup会调用自身的generatedDefaultLayoutParams来帮子View生成一个默认的LayoutParams：
178 |
179 | ```java
180 | public void addView(View child, int index) {
181 | if (child == null) {
182 | throw new IllegalArgumentException("Cannot add a null child view to a ViewGroup");
183 | }
184 | LayoutParams params = child.getLayoutParams();
185 | if (params == null) {
186 | // params为空的情况，调用generateDefaultLayoutParams方法生成LayoutParams
187 | params = generateDefaultLayoutParams();
188 | if (params == null) {
189 | throw new IllegalArgumentException("generateDefaultLayoutParams() cannot return null");
190 | }
191 | }
192 | addView(child, index, params);
193 | }
194 |
195 | public void addView(View child, int width, int height) {
196 | // 调用这个方法的时候，会直接无视子View原来的LayoutParams，
197 | // 直接调用generateDefaultLayoutParams生成新的LayoutParams
198 | final LayoutParams params = generateDefaultLayoutParams();
199 | params.width = width;
200 | params.height = height;
201 | addView(child, -1, params);
202 | }
203 | ```
204 |
205 |
206 |
207 | 然后是私有方法addViewInner：
208 |
209 | ```java
210 | private void addViewInner(View child, int index, LayoutParams params,
211 | boolean preventRequestLayout) {
212 | ...
213 |
214 | // 子View的parent不为空，说明子View已经被添加到其他ViewGroup了。直接抛出异常。
215 | // 也就是说子View是不允许同时被添加到多个ViewGroup中的。这边挺好理解的，因为子View的布局相关参数都是唯一的，
216 | // 如果同时被添加到多个ViewGroup，而ViewGroup的布局规则各不相同，会导致我们从某一个ViewGroup获取子View的时候，没法得到它正确的尺寸等相关信息
217 | if (child.getParent() != null) {
218 | throw new IllegalStateException("The specified child already has a parent. " +
219 | "You must call removeView() on the child's parent first.");
220 | }
221 |
222 | // 调用checkLayoutParams判断当前的params是不是我们需要的LayoutParams，
223 | // 很多继承自ViewGroup的布局都会用自己的LayoutParams，并有独立的一些布局属性。
224 | // 如果不是当前布局所需的LayoutParams则调用generateLayoutParams来转换
225 | if (!checkLayoutParams(params)) {
226 | params = generateLayoutParams(params);
227 | }
228 |
229 | // 给子View设置LayoutParams
230 | if (preventRequestLayout) {
231 | child.mLayoutParams = params;
232 | } else {
233 | child.setLayoutParams(params);
234 | }
235 |
236 | if (index < 0) {
237 | index = mChildrenCount;
238 | }
239 |
240 | // 添加到子View的数组中
241 | addInArray(child, index);
242 |
243 | // 给子View设置parent
244 | if (preventRequestLayout) {
245 | child.assignParent(this);
246 | } else {
247 | child.mParent = this;
248 | }
249 |
250 | // 判断并设置焦点
251 | if (child.hasFocus()) {
252 | requestChildFocus(child, child.findFocus());
253 | }
254 |
255 | // 判断AttachInfo是否为空，AttachInfo不为空说明当前的ViewGroup是已经添加到Window上了。
256 | // 调用子View的dispatchAttachedToWindow。通知当前子View已经被添加到Window
257 | AttachInfo ai = mAttachInfo;
258 | if (ai != null && (mGroupFlags & FLAG_PREVENT_DISPATCH_ATTACHED_TO_WINDOW) == 0) {
259 | boolean lastKeepOn = ai.mKeepScreenOn;
260 | ai.mKeepScreenOn = false;
261 | child.dispatchAttachedToWindow(mAttachInfo, (mViewFlags&VISIBILITY_MASK));
262 | if (ai.mKeepScreenOn) {
263 | needGlobalAttributesUpdate(true);
264 | }
265 | ai.mKeepScreenOn = lastKeepOn;
266 | }
267 |
268 | if (child.isLayoutDirectionInherited()) {
269 | child.resetRtlProperties();
270 | }
271 |
272 | dispatchViewAdded(child);
273 |
274 | // 判断是否需要通知子View状态改变(state这边指按下、放开、选中等状态)
275 | if ((child.mViewFlags & DUPLICATE_PARENT_STATE) == DUPLICATE_PARENT_STATE) {
276 | mGroupFlags |= FLAG_NOTIFY_CHILDREN_ON_DRAWABLE_STATE_CHANGE;
277 | }
278 |
279 | ...
280 | }
281 | ```
282 |
283 |
284 |
285 | 子View的移除则是最终调用了私有方法removeViewInternal：
286 |
287 |
288 |
289 | ```java
290 | private void removeViewInternal(int index, View view) {
291 | if (mTransition != null) {
292 | mTransition.removeChild(this, view);
293 | }
294 |
295 | boolean clearChildFocus = false;
296 |
297 | // 判断并清除焦点
298 | if (view == mFocused) {
299 | view.unFocus(null);
300 | clearChildFocus = true;
301 | }
302 |
303 | view.clearAccessibilityFocus();
304 |
305 | // 取消相关的事件Target
306 | cancelTouchTarget(view);
307 | cancelHoverTarget(view);
308 |
309 | // 当子View自身还有动画没有结束的时候，把子View添加到disappearingChildren列表中，
310 | // 在disappearingChildren列表中的子View会在动画结束后被移除
311 | if (view.getAnimation() != null ||
312 | (mTransitioningViews != null && mTransitioningViews.contains(view))) {
313 | addDisappearingView(view);
314 | } else if (view.mAttachInfo != null) {
315 | // 子View自身没有动画在执行中，通知子View从Window中脱离
316 | view.dispatchDetachedFromWindow();
317 | }
318 |
319 | if (view.hasTransientState()) {
320 | childHasTransientStateChanged(view, false);
321 | }
322 |
323 | needGlobalAttributesUpdate(false);
324 |
325 | // 把子View移出子View数组
326 | removeFromArray(index);
327 |
328 | if (clearChildFocus) {
329 | clearChildFocus(view);
330 | if (!rootViewRequestFocus()) {
331 | notifyGlobalFocusCleared(this);
332 | }
333 | }
334 |
335 | dispatchViewRemoved(view);
336 |
337 | if (view.getVisibility() != View.GONE) {
338 | notifySubtreeAccessibilityStateChangedIfNeeded();
339 | }
340 |
341 | ...
342 | }
343 | ```
344 |
345 |
346 |
347 |
348 |
349 | ### 绘制
350 |
351 | ViewGroup在默认的情况下自身并不绘制内容，而是调用dispatchDraw方法来安排子View绘制自身，我们来看看这个方法具体做了什么：
352 |
353 |
354 |
355 | ```java
356 | protected void dispatchDraw(Canvas canvas) {
357 | boolean usingRenderNodeProperties = canvas.isRecordingFor(mRenderNode);
358 | final int childrenCount = mChildrenCount;
359 | final View[] children = mChildren;
360 | int flags = mGroupFlags;
361 |
362 | // 检测是否有布局动画
363 | if ((flags & FLAG_RUN_ANIMATION) != 0 && canAnimate()) {
364 | final boolean buildCache = !isHardwareAccelerated();
365 |
366 | // 给所有当前可见的子View绑定布局动画
367 | for (int i = 0; i < childrenCount; i++) {
368 | final View child = children[i];
369 | if ((child.mViewFlags & VISIBILITY_MASK) == VISIBLE) {
370 | final LayoutParams params = child.getLayoutParams();
371 | attachLayoutAnimationParameters(child, params, i, childrenCount);
372 | bindLayoutAnimation(child);
373 | }
374 | }
375 |
376 | final LayoutAnimationController controller = mLayoutAnimationController;
377 | if (controller.willOverlap()) {
378 | mGroupFlags |= FLAG_OPTIMIZE_INVALIDATE;
379 | }
380 |
381 | // 启动布局动画
382 | controller.start();
383 |
384 | mGroupFlags &= ~FLAG_RUN_ANIMATION;
385 | mGroupFlags &= ~FLAG_ANIMATION_DONE;
386 |
387 | if (mAnimationListener != null) {
388 | mAnimationListener.onAnimationStart(controller.getAnimation());
389 | }
390 | }
391 |
392 | // 处理clipToPadding的情况，这边是直接调用canvas的clipRect方法来剪切出除去padding的区域
393 | int clipSaveCount = 0;
394 | final boolean clipToPadding = (flags & CLIP_TO_PADDING_MASK) == CLIP_TO_PADDING_MASK;
395 | if (clipToPadding) {
396 | clipSaveCount = canvas.save();
397 | canvas.clipRect(mScrollX + mPaddingLeft, mScrollY + mPaddingTop,
398 | mScrollX + mRight - mLeft - mPaddingRight,
399 | mScrollY + mBottom - mTop - mPaddingBottom);
400 | }
401 |
402 | ...
403 |
404 | for (int i = 0; i < childrenCount; i++) {
405 | ...
406 |
407 | final int childIndex = getAndVerifyPreorderedIndex(childrenCount, i, customOrder);
408 | final View child = getAndVerifyPreorderedView(preorderedList, children, childIndex);
409 | if ((child.mViewFlags & VISIBILITY_MASK) == VISIBLE || child.getAnimation() != null) {
410 | // 子View是可见状态或者子View的动画还在运行的时候，调用drawChild来绘制子View，
411 | // drawChild方法内部则是直接调用子View的draw(canvas, parent, draingTime)方法让子View对自身进行绘制
412 | more |= drawChild(canvas, child, drawingTime);
413 | }
414 | }
415 | ...
416 | if (preorderedList != null) preorderedList.clear();
417 |
418 | // 绘制那些即将消失的View，
419 | // 所有被移除或者Visibility不是VISIBLE但是自身还有动画没有完成的子View，
420 | // 都会被添加到mDisappearingChildren里面，等动画完成后才被移除。
421 | if (mDisappearingChildren != null) {
422 | final ArrayList