Listview部分源码分析

Listview在android开发中算是最常用的几个控件之一，由于要应付各种不同的需求，甚至有时候是奇怪且独特的需要，使用Listview就总会遇到些奇怪的问题，但是其实都没有什么捷径，看源码是最好的办法。而与Listview相关的源码至少有一万行，涉及到AbsListview、AdapterView、ListAdapter等，这里对部分的源码做分析。下面由于代码数量比较多，只要着重看有中文注释的部分就可以了。
1.与数据adapter相关的

setAdapter()




setAdapter source code

1 /**
2      * Sets the data behind this ListView.
3      *
4      * The adapter passed to this method may be wrapped by a {@link WrapperListAdapter},
5      * depending on the ListView features currently in use. For instance, adding
6      * headers and/or footers will cause the adapter to be wrapped.
7      *
8      * @param adapter The ListAdapter which is responsible for maintaining the
9      *        data backing this list and for producing a view to represent an
10      *        item in that data set.
11      *
12      * @see #getAdapter()
13      */
14     @Override
15     public void setAdapter(ListAdapter adapter) {
16         if (null != mAdapter) {
17             mAdapter.unregisterDataSetObserver(mDataSetObserver);    //移除了与当前listview的adapter绑定数据集观察者DataSetObserver
18         }
19
20         resetList();   //重置listview，主要是清除所有的view，改变header、footer的状态
21         mRecycler.clear();  //清除掉RecycleBin对象mRecycler中所有缓存的view，RecycleBin后面着重介绍，主要是关系到Listview中item的重用机制，它是AbsListview的一个内部类
22
23         if (mHeaderViewInfos.size() > 0|| mFooterViewInfos.size() > 0) {   //判断是否有header和footer
24             mAdapter = new HeaderViewListAdapter(mHeaderViewInfos, mFooterViewInfos, adapter);//假如有，用HeaderViewListAdapter包装一下adapter
25         } else {
26             mAdapter = adapter;
27         }
28
29         mOldSelectedPosition = INVALID_POSITION;
30         mOldSelectedRowId = INVALID_ROW_ID;
31         if (mAdapter != null) {
32             mAreAllItemsSelectable = mAdapter.areAllItemsEnabled();
33             mOldItemCount = mItemCount;
34             mItemCount = mAdapter.getCount();
35             checkFocus();
36
37             mDataSetObserver = new AdapterDataSetObserver();
38             //mAdapter注册一个数据集观察者DataSetObserver，DataSetObserver主要是负责侦听adapter中数据的变化，从而实现更新UI
39             mAdapter.registerDataSetObserver(mDataSetObserver);
40
41             /**mAdapter.getViewTypeCount()的作用其实是有判断item有多少种类型，
42              **一般情况下，item都是一样的只有一种，某些特殊需求中可能就需要多种,然后RecycleBin对象mRecycler记录下item类型的数量*/
43             mRecycler.setViewTypeCount(mAdapter.getViewTypeCount());
44
45             int position;
46             if (mStackFromBottom) { //根据mStackFromBottom变量，设置position究竟是顶部第一个还是底部最后一个是selected
47                 position = lookForSelectablePosition(mItemCount - 1, false);
48             } else {
49                 position = lookForSelectablePosition(0, true);
50             }
51             setSelectedPositionInt(position);//AdapterView中的方法，记录当前的position
52             setNextSelectedPositionInt(position);//AdapterView中的方法，记录下一个position
53
54             if (mItemCount == 0) {
55                 // Nothing selected
56                 checkSelectionChanged();
57             }
58
59         } else {
60             mAreAllItemsSelectable = true;
61             checkFocus();
62             // Nothing selected
63             checkSelectionChanged();
64         }
65
66         if (mCheckStates != null) {
67             mCheckStates.clear();//mCheckStates是一个SparseBooleanArray对象，用于保存item的checked状态，performItemClick()、setItemChecked()时，改变内部的值
68         }
69
70         //就英文吧，Called when something has changed which has invalidated the layout of a child of this view parent. This will schedule a layout pass of the view tree.
71         requestLayout();
72
73
74     }

ListAdapter是通过notifyDataSetChanged实现UI更新的，具体是怎样的呢？

先看registerDataSetObserver，因为registerDataSetObserver是接口Adapter定义的，所以需要实现该接口的类来实现，那么这里以BaseAdapter为例：

registerDataSetObserver()




registerDataSetObserver

1     public void registerDataSetObserver(DataSetObserver observer) {
2         mDataSetObservable.registerObserver(observer);
3     }

它作用就是调用DataSetObservable的registerDataSetObserver，而该方法是在Observable定义的：




registerObserver

1         /**
2      * The list of observers.  An observer can be in the list at most
3      * once and will never be null.
4      */
5     protected final ArrayList<T> mObservers = new ArrayList<T>();
6
7     /**
8      * Adds an observer to the list. The observer cannot be null and it must not already
9      * be registered.
10      * @param observer the observer to register
11      * @throws IllegalArgumentException the observer is null
12      * @throws IllegalStateException the observer is already registered
13      */
14     public void registerObserver(T observer) {
15         if (observer == null) {
16             throw new IllegalArgumentException("The observer is null.");
17         }
18         synchronized(mObservers) {
19             if (mObservers.contains(observer)) {
20                 throw new IllegalStateException("Observer " + observer + " is already registered.");
21             }
22             mObservers.add(observer);    //把observer添加到mObservers数组中
23         }
24     }

可见registerDataSetObserver的作用其实就是简单的把传进去的mDataSetObserver存储起来。

当调用BaseAdapter的notifyDataSetChanged时，干了什么？




notifyDataSetChanged

1     /**
2      * Notifies the attached View that the underlying data has been changed
3      * and it should refresh itself.
4      */
5     public void notifyDataSetChanged() {
6         mDataSetObservable.notifyChanged();
7     }

看mDataSetObservable.notifyChanged()方法：




notifyChanged

1         /**
2      * Invokes onChanged on each observer. Called when the data set being observed has
3      * changed, and which when read contains the new state of the data.
4      */
5     public void notifyChanged() {
6         synchronized(mObservers) {
7             for (DataSetObserver observer : mObservers) {
8                 observer.onChanged();    //遍历所有的DataSetObserver调用它们的onChanged方法
9             }
10         }
11     }

DataSetObserver是一个接口，所以onChanged方法干什么要看具体实现该接口的类，在Listview中，关联的observer是AdapterDataSetObserver类型的，它实现了DataSetObserver，看它的onChanged方法：




onChanged

1             @Override
2         public void onChanged() {
3             mDataChanged = true;
4             mOldItemCount = mItemCount;
5             mItemCount = getAdapter().getCount();
6
7             // Detect the case where a cursor that was previously invalidated has
8             // been repopulated with new data.
9             if (AdapterView.this.getAdapter().hasStableIds() && mInstanceState != null
10                     && mOldItemCount == 0 && mItemCount > 0) {
11                 AdapterView.this.onRestoreInstanceState(mInstanceState);
12                 mInstanceState = null;
13             } else {
14                 rememberSyncState();
15             }
16             checkFocus();
17             requestLayout();    //onChanged的主要目的就是重布局
18         }

总结一下，上面看出，notifyDataSetChanged方法的目的就是要求Listview重布局，从而实现UI的更新。

既然说到布局，那么接下来就介绍Listview的布局相关的东西。

2.Listview的布局

说到布局，毫无疑问要从onLayout这个方法开始看：

onLayout()




onLayout

1         /**
2      * Subclasses should NOT override this method but子类不要重写这个方法，而要重写layoutChildren
3      *  {@link #layoutChildren()} instead.
4      */
5     @Override
6     protected void onLayout(boolean changed, int l, int t, int r, int b) {
7         super.onLayout(changed, l, t, r, b);
8         mInLayout = true;
9         if (changed) {
10             int childCount = getChildCount();
11             for (int i = 0; i < childCount; i++) {
12                 getChildAt(i).forceLayout();    //保证下一次布局事，子view要重新layout
13             }
14             mRecycler.markChildrenDirty();    //该方法作用时，保证mRecycler中scrapview在下一次布局时要重新布局（mRecycler后面介绍，可以先不管）
15         }
16
17         layoutChildren();    //这是关键的方法
18         mInLayout = false;
19
20         mOverscrollMax = (b - t) / OVERSCROLL_LIMIT_DIVISOR;
21     }

onLayout的关键在于layoutChildren()，所以接下来关键要看layoutChildren：

layoutChildren()




layoutChildren

1         @Override
2     protected void layoutChildren() {
3         final boolean blockLayoutRequests = mBlockLayoutRequests;
4         if (!blockLayoutRequests) {
5             mBlockLayoutRequests = true;
6         } else {
7             return;
8         }
9
10         try {
11             super.layoutChildren();
12
13             invalidate();    //重绘自己，onDraw()会被调用
14
15             if (mAdapter == null) {    //adapter空的话，直接返回，置空listview
16                 resetList();
17                 invokeOnItemScrollListener();
18                 return;
19             }
20
21             int childrenTop = mListPadding.top;
22             int childrenBottom = mBottom - mTop - mListPadding.bottom;
23
24             int childCount = getChildCount();
25             int index = 0;
26             int delta = 0;
27
28             View sel;
29             View oldSel = null;
30             View oldFirst = null;
31             View newSel = null;
32
33             View focusLayoutRestoreView = null;
34
35             // Remember stuff we will need down below
36             switch (mLayoutMode) {    //判断布局模式，根据不同模式，使用不同的布局方法，初始值为LAYOUT_NORMAL
37             case LAYOUT_SET_SELECTION:
38                 index = mNextSelectedPosition - mFirstPosition;
39                 if (index >= 0 && index < childCount) {
40                     newSel = getChildAt(index);
41                 }
42                 break;
43             case LAYOUT_FORCE_TOP:
44             case LAYOUT_FORCE_BOTTOM:
45             case LAYOUT_SPECIFIC:
46             case LAYOUT_SYNC:
47                 break;
48             case LAYOUT_MOVE_SELECTION:
49             default:
50                 // Remember the previously selected view
51                 index = mSelectedPosition - mFirstPosition;
52                 if (index >= 0 && index < childCount) {    //保存被select的view
53                     oldSel = getChildAt(index);
54                 }
55
56                 // Remember the previous first child
57                 oldFirst = getChildAt(0);    //保存第一个子view
58
59                 if (mNextSelectedPosition >= 0) {
60                     delta = mNextSelectedPosition - mSelectedPosition;
61                 }
62
63                 // Caution: newSel might be null
64                 newSel = getChildAt(index + delta);
65             }
66
67
68             boolean dataChanged = mDataChanged;
69             if (dataChanged) {
70                 handleDataChanged();
71             }
72
73             // Handle the empty set by removing all views that are visible
74             // and calling it a day
75             if (mItemCount == 0) {    //如果没有item直接返回
76                 resetList();
77                 invokeOnItemScrollListener();
78                 return;
79             } else if (mItemCount != mAdapter.getCount()) {
80                 throw new IllegalStateException("The content of the adapter has changed but "
81                         + "ListView did not receive a notification. Make sure the content of "
82                         + "your adapter is not modified from a background thread, but only "
83                         + "from the UI thread. [in ListView(" + getId() + ", " + getClass()
84                         + ") with Adapter(" + mAdapter.getClass() + ")]");
85             }
86
87             setSelectedPositionInt(mNextSelectedPosition);
88
89             // Pull all children into the RecycleBin.
90             // These views will be reused if possible
91             final int firstPosition = mFirstPosition;
92             final RecycleBin recycleBin = mRecycler;
93
94             // reset the focus restoration
95             View focusLayoutRestoreDirectChild = null;
96
97
98             // Don't put header or footer views into the Recycler. Those are
99             // already cached in mHeaderViews;
100             if (dataChanged) {    //如果数据改变了，把所有的子view放进recycleBin的Scrapview中（不包括foot和head）
101                 for (int i = 0; i < childCount; i++) {
102                     recycleBin.addScrapView(getChildAt(i));
103                     if (ViewDebug.TRACE_RECYCLER) {
104                         ViewDebug.trace(getChildAt(i),
105                                 ViewDebug.RecyclerTraceType.MOVE_TO_SCRAP_HEAP, index, i);
106                     }
107                 }
108             } else {    //如果没有改变，把所有子view，放进recycleBin的AcitveView（不包括foot和head）
109                 recycleBin.fillActiveViews(childCount, firstPosition);
110             }
111
112             // take focus back to us temporarily to avoid the eventual
113             // call to clear focus when removing the focused child below
114             // from messing things up when ViewRoot assigns focus back
115             // to someone else
116             final View focusedChild = getFocusedChild();
117             if (focusedChild != null) {
118                 // TODO: in some cases focusedChild.getParent() == null
119
120                 // we can remember the focused view to restore after relayout if the
121                 // data hasn't changed, or if the focused position is a header or footer
122                 if (!dataChanged || isDirectChildHeaderOrFooter(focusedChild)) {
123                     focusLayoutRestoreDirectChild = focusedChild;
124                     // remember the specific view that had focus
125                     focusLayoutRestoreView = findFocus();
126                     if (focusLayoutRestoreView != null) {
127                         // tell it we are going to mess with it
128                         focusLayoutRestoreView.onStartTemporaryDetach();
129                     }
130                 }
131                 requestFocus();
132             }
133
134             // Clear out old views
135             detachAllViewsFromParent();//清楚掉Listview中所有旧的view，等待attach新的view
136
137             //根据mLayoutMode不同，使用不同的布局item view的方式
138             switch (mLayoutMode) {
139             case LAYOUT_SET_SELECTION:
140                 if (newSel != null) {
141                     sel = fillFromSelection(newSel.getTop(), childrenTop, childrenBottom);
142                 } else {
143                     sel = fillFromMiddle(childrenTop, childrenBottom);
144                 }
145                 break;
146             case LAYOUT_SYNC:
147                 sel = fillSpecific(mSyncPosition, mSpecificTop);
148                 break;
149             case LAYOUT_FORCE_BOTTOM:
150                 sel = fillUp(mItemCount - 1, childrenBottom);
151                 adjustViewsUpOrDown();
152                 break;
153             case LAYOUT_FORCE_TOP:
154                 mFirstPosition = 0;
155                 sel = fillFromTop(childrenTop);
156                 adjustViewsUpOrDown();
157                 break;
158             case LAYOUT_SPECIFIC:
159                 sel = fillSpecific(reconcileSelectedPosition(), mSpecificTop);
160                 break;
161             case LAYOUT_MOVE_SELECTION:
162                 sel = moveSelection(oldSel, newSel, delta, childrenTop, childrenBottom);
163                 break;
164             default:
165                 if (childCount == 0) {
166                     if (!mStackFromBottom) {
167                         final int position = lookForSelectablePosition(0, true);
168                         setSelectedPositionInt(position);
169                         sel = fillFromTop(childrenTop);
170                     } else {
171                         final int position = lookForSelectablePosition(mItemCount - 1, false);
172                         setSelectedPositionInt(position);
173                         sel = fillUp(mItemCount - 1, childrenBottom);
174                     }
175                 } else {
176                     if (mSelectedPosition >= 0 && mSelectedPosition < mItemCount) {
177                         sel = fillSpecific(mSelectedPosition,
178                                 oldSel == null ? childrenTop : oldSel.getTop());
179                     } else if (mFirstPosition < mItemCount) {
180                         sel = fillSpecific(mFirstPosition,
181                                 oldFirst == null ? childrenTop : oldFirst.getTop());
182                     } else {
183                         sel = fillSpecific(0, childrenTop);
184                     }
185                 }
186                 break;
187             }
188
189             // Flush any cached views that did not get reused above
190             recycleBin.scrapActiveViews();    //清除掉recycleBin在上面没有被重用的缓存views
191
192             if (sel != null) {
193                 // the current selected item should get focus if items
194                 // are focusable
195                 if (mItemsCanFocus && hasFocus() && !sel.hasFocus()) {
196                     final boolean focusWasTaken = (sel == focusLayoutRestoreDirectChild &&
197                             focusLayoutRestoreView.requestFocus()) || sel.requestFocus();
198                     if (!focusWasTaken) {
199                         // selected item didn't take focus, fine, but still want
200                         // to make sure something else outside of the selected view
201                         // has focus
202                         final View focused = getFocusedChild();
203                         if (focused != null) {
204                             focused.clearFocus();
205                         }
206                         positionSelector(sel);
207                     } else {
208                         sel.setSelected(false);
209                         mSelectorRect.setEmpty();
210                     }
211                 } else {
212                     positionSelector(sel);
213                 }
214                 mSelectedTop = sel.getTop();
215             } else {
216                 if (mTouchMode > TOUCH_MODE_DOWN && mTouchMode < TOUCH_MODE_SCROLL) {
217                     View child = getChildAt(mMotionPosition - mFirstPosition);
218                     if (child != null) positionSelector(child);
219                 } else {
220                     mSelectedTop = 0;
221                     mSelectorRect.setEmpty();
222                 }
223
224                 // even if there is not selected position, we may need to restore
225                 // focus (i.e. something focusable in touch mode)
226                 if (hasFocus() && focusLayoutRestoreView != null) {
227                     focusLayoutRestoreView.requestFocus();
228                 }
229             }
230
231             // tell focus view we are done mucking with it, if it is still in
232             // our view hierarchy.
233             if (focusLayoutRestoreView != null
234                     && focusLayoutRestoreView.getWindowToken() != null) {
235                 focusLayoutRestoreView.onFinishTemporaryDetach();
236             }
237
238             mLayoutMode = LAYOUT_NORMAL;
239             mDataChanged = false;
240             mNeedSync = false;
241             setNextSelectedPositionInt(mSelectedPosition);
242
243             updateScrollIndicators();
244
245             if (mItemCount > 0) {
246                 checkSelectionChanged();
247             }
248
249             invokeOnItemScrollListener();
250         } finally {
251             if (!blockLayoutRequests) {
252                 mBlockLayoutRequests = false;
253             }
254         }
255     }

layoutChildren会根据mLayoutMode的值选用不同的方式返回一个item view，选择其中一种去介绍，这里选择fillDown，其他的其实差不多，大家可以自行研究:

fillDown()




fillDown

1         /**
2      * Fills the list from pos down to the end of the list view.从上往下渲染Listview
3      *
4      * @param pos The first position to put in the list
5      *
6      * @param nextTop The location where the top of the item associated with pos
7      *        should be drawn
8      *
9      * @return The view that is currently selected, if it happens to be in the
10      *         range that we draw.
11      */
12     private View fillDown(int pos, int nextTop) {
13         View selectedView = null;
14
15         int end = (mBottom - mTop) - mListPadding.bottom;
16
17         while (nextTop < end && pos < mItemCount) {
18             // is this the selected item?
19             boolean selected = pos == mSelectedPosition;
20             View child = makeAndAddView(pos, nextTop, true, mListPadding.left, selected);    //通过makeAndAddView返回一个view
21
22             nextTop = child.getBottom() + mDividerHeight;
23             if (selected) {
24                 selectedView = child;
25             }
26             pos++;
27         }
28
29         return selectedView;
30     }

其实fillDown中极其简单，就是调用了一下makeAndAddView返回一个view，makeAndAddView实现的是得到一个view并把它添加到Listview中去

那么，接下来介绍makeAndAddView()方法，它的作用是获得每一个item view对象，即Listview的每一行数据




makeAndAddView

1         /**
2      * Obtain the view and add it to our list of children. The view can be made
3      * fresh, converted from an unused view, or used as is if it was in the
4      * recycle bin.获得view并把它们添加到存放子view的list中去。这个view可以是新构造出来的，可以通过从没有用过的view转过来（翻译不怎么合适）或者如果recycle bin中存在可以重用view
5      *
6      * @param position Logical position in the list
7      * @param y Top or bottom edge of the view to add
8      * @param flow If flow is true, align top edge to y. If false, align bottom
9      *        edge to y.
10      * @param childrenLeft Left edge where children should be positioned
11      * @param selected Is this position selected?
12      * @return View that was added
13      */
14     private View makeAndAddView(int position, int y, boolean flow, int childrenLeft,
15             boolean selected) {
16         View child;
17
18         //mDataChanged表示的是最后一次layout是否有“数据”更新，数据的意思包含AdapterDataSetObserver中监测的数据、size的变化、view的重绘和重建、click，checked事件的发生。
19         //只有layoutChildren后mDataChanged会置为false
20         if (!mDataChanged) {
21             // Try to use an exsiting view for this position
22             child = mRecycler.getActiveView(position);//从mRecycler中获取一个当前活动的view来重用，mRecycler（AbsListView.RecycleBin对象）会后面介绍
23             if (child != null) {
24                 if (ViewDebug.TRACE_RECYCLER) {//debug时候跟踪输出信息（可忽略）
25                     ViewDebug.trace(child, ViewDebug.RecyclerTraceType.RECYCLE_FROM_ACTIVE_HEAP,
26                             position, getChildCount());
27                 }
28
29                 // Found it -- we're using an existing child
30                 // This just needs to be positioned
31                 setupChild(child, position, y, flow, childrenLeft, selected, true);//添加该view到Listview中去，这里只需要找到位置而不需要measure  view的大小
32
33                 return child;
34             }
35         }
36
37         // Make a new view for this position, or convert an unused view if possible
38         child = obtainView(position, mIsScrap);//获取一个新的view或者从一个没有用的view转换过来，AbsListview的方法,涉及到Listview中item的重用，和RecycleBin相关
39
40         // This needs to be positioned and measured
41         setupChild(child, position, y, flow, childrenLeft, selected, mIsScrap[0]);//添加该view到Listview中去，这里只需要找到位置而且需要measure  view的大小
42
43         return child;//返回该view对象
44     }

在makeAndAddView中，我们看到mRecycler对象，究竟该对象是什么，为什么可以从这个对象中获得一个item view去渲染Listview本身？

mRecycler是一个RecycleBin对象，从mRecycler的命名可以略知一二，它是一个回收器，回收什么？既然可以从里面获得view，那毫无疑问，回收的肯定有item view，那进一步看看该对象，它是Listview的item重用机制的重要对象，它是一个AbsListview的一个内部类：

1 RecycleBin
2      /**
3      * The RecycleBin facilitates reuse of views across layouts. The RecycleBin has two levels of
4      * storage: ActiveViews and ScrapViews. ActiveViews are those views which were onscreen at the
5      * start of a layout. By construction, they are displaying current information. At the end of
6      * layout, all views in ActiveViews are demoted to ScrapViews. ScrapViews are old views that
7      * could potentially be used by the adapter to avoid allocating views unnecessarily.
8      *
9      *解释：Recyclebin实现跨layout的view重用。在RecycleBin中，存储两种不同的view，ActiveViews 和 ScrapViews。
10      *ActiveViews保存布局开始时屏幕中显示的views。在布局结束时，所有的ActiveViews变成ScrapViews。
11      *ScrapViews是那些可以被adapter使用，避免重新分配新的view的旧views。
12      *
13      * @see android.widget.AbsListView#setRecyclerListener(android.widget.AbsListView.RecyclerListener)
14      * @see android.widget.AbsListView.RecyclerListener
15      */
16     class RecycleBin {
17         private RecyclerListener mRecyclerListener;
18
19         /**
20          * The position of the first view stored in mActiveViews.
21          */
22         private int mFirstActivePosition;
23
24         /**
25          * Views that were on screen at the start of layout. This array is populated at the start of
26          * layout, and at the end of layout all view in mActiveViews are moved to mScrapViews.
27          * Views in mActiveViews represent a contiguous range of Views, with position of the first
28          * view store in mFirstActivePosition.
29          *
30          *mActiveViews 包含当前屏幕中的item views，它是一个数组，在一开始布局时会被填充，在布局结束时，它里面的view
31          *会移动到mScrapViews中。在mActiveViews 中的views代表连续范围内的views。
32          */
33         private View[] mActiveViews = new View[0];
34
35         /**
36          * Unsorted views that can be used by the adapter as a convert view.
37          */
38         private ArrayList<View>[] mScrapViews;    //存储scrapviews的地方，一个ArrayList数组，一个元素对应一种类型的scrapviews，它可以被adapter作为一个convert view使用
39
40         private int mViewTypeCount;    //item view类型的总数(listview可以包含不同类型的item views)
41
42         private ArrayList<View> mCurrentScrap;
43
44         public void setViewTypeCount(int viewTypeCount) {
45             if (viewTypeCount < 1) {
46                 throw new IllegalArgumentException("Can't have a viewTypeCount < 1");
47             }
48             //noinspection unchecked
49             //根据view类型数量，设置scrapviews的存储结构，每一种类型的scrapviews用一个ArrayList去存储，多个类型狗就有多个ArrayList
50             ArrayList<View>[] scrapViews = new ArrayList[viewTypeCount];
51             for (int i = 0; i < viewTypeCount; i++) {
52                 scrapViews[i] = new ArrayList<View>();
53             }
54             mViewTypeCount = viewTypeCount;
55             mCurrentScrap = scrapViews[0];
56             mScrapViews = scrapViews;
57         }
58
59         //设置mCurrentScrap中存储的views在下一次layout时必须重新layout
60         public void markChildrenDirty() {
61             if (mViewTypeCount == 1) {    //如果只有一种类型的item
62                 final ArrayList<View> scrap = mCurrentScrap;
63                 final int scrapCount = scrap.size();
64                 for (int i = 0; i < scrapCount; i++) {
65                     scrap.get(i).forceLayout();
66                 }
67             } else {
68                 final int typeCount = mViewTypeCount;
69                 for (int i = 0; i < typeCount; i++) {
70                     final ArrayList<View> scrap = mScrapViews[i];
71                     final int scrapCount = scrap.size();
72                     for (int j = 0; j < scrapCount; j++) {
73                         scrap.get(j).forceLayout();
74                     }
75                 }
76             }
77         }
78
79         public boolean shouldRecycleViewType(int viewType) {
80             return viewType >= 0;
81         }
82
83         /**
84          * Clears the scrap heap.清楚掉mScrapViews中的views
85          */
86         void clear() {
87             if (mViewTypeCount == 1) {
88                 final ArrayList<View> scrap = mCurrentScrap;
89                 final int scrapCount = scrap.size();
90                 for (int i = 0; i < scrapCount; i++) {
91                     removeDetachedView(scrap.remove(scrapCount - 1 - i), false);
92                 }
93             } else {
94                 final int typeCount = mViewTypeCount;
95                 for (int i = 0; i < typeCount; i++) {
96                     final ArrayList<View> scrap = mScrapViews[i];
97                     final int scrapCount = scrap.size();
98                     for (int j = 0; j < scrapCount; j++) {
99                         removeDetachedView(scrap.remove(scrapCount - 1 - j), false);
100                     }
101                 }
102             }
103         }
104
105         /**
106          * Fill ActiveViews with all of the children of the AbsListView.把AbsListview中的所以子view添加到ActiveViews中
107          *
108          * @param childCount The minimum number of views mActiveViews should hold
109          * @param firstActivePosition The position of the first view that will be stored in
110          *        mActiveViews
111          */
112         void fillActiveViews(int childCount, int firstActivePosition) {
113             if (mActiveViews.length < childCount) {
114                 mActiveViews = new View[childCount];
115             }
116             mFirstActivePosition = firstActivePosition;
117
118             final View[] activeViews = mActiveViews;
119             for (int i = 0; i < childCount; i++) {
120                 View child = getChildAt(i);//这里注意是把当前listview的item作为active view，也就是当前的active view会作为重用的view，第一次加载的时候，没有子view，所以第一次时，listview的所有view都不是重用的
121                 AbsListView.LayoutParams lp = (AbsListView.LayoutParams) child.getLayoutParams();
122                 // Don't put header or footer views into the scrap heap
123                 if (lp != null && lp.viewType != ITEM_VIEW_TYPE_HEADER_OR_FOOTER) {
124                     // Note:  We do place AdapterView.ITEM_VIEW_TYPE_IGNORE in active views.
125                     //        However, we will NOT place them into scrap views.
126                     activeViews[i] = child;
127                 }
128             }
129         }
130
131         /**
132          * Get the view corresponding to the specified position. The view will be removed from
133          * mActiveViews if it is found.从ActiveViews指定位置获得一个view，获得后，这个view会从ActiveViews中去掉
134          *
135          * @param position The position to look up in mActiveViews
136          * @return The view if it is found, null otherwise
137          */
138         View getActiveView(int position) {
139             int index = position - mFirstActivePosition;
140             final View[] activeViews = mActiveViews;
141             if (index >=0 && index < activeViews.length) {
142                 final View match = activeViews[index];
143                 activeViews[index] = null;
144                 return match;
145             }
146             return null;
147         }
148
149         /**
150          * @return A view from the ScrapViews collection. These are unordered.从ScrapViews中获得一个view
151          */
152         View getScrapView(int position) {
153             ArrayList<View> scrapViews;
154             if (mViewTypeCount == 1) {
155                 scrapViews = mCurrentScrap;
156                 int size = scrapViews.size();
157                 if (size > 0) {
158                     return scrapViews.remove(size - 1);
159                 } else {
160                     return null;
161                 }
162             } else {
163                 int whichScrap = mAdapter.getItemViewType(position);
164                 if (whichScrap >= 0 && whichScrap < mScrapViews.length) {
165                     scrapViews = mScrapViews[whichScrap];
166                     int size = scrapViews.size();
167                     if (size > 0) {
168                         return scrapViews.remove(size - 1);
169                     }
170                 }
171             }
172             return null;
173         }
174
175         /**
176          * Put a view into the ScapViews list. These views are unordered.把一个view存储到ScrapViews中
177          *
178          * @param scrap The view to add
179          */
180         void addScrapView(View scrap) {
181             AbsListView.LayoutParams lp = (AbsListView.LayoutParams) scrap.getLayoutParams();
182             if (lp == null) {
183                 return;
184             }
185
186             // Don't put header or footer views or views that should be ignored
187             // into the scrap heap
188             int viewType = lp.viewType;
189             if (!shouldRecycleViewType(viewType)) {
190                 if (viewType != ITEM_VIEW_TYPE_HEADER_OR_FOOTER) {
191                     removeDetachedView(scrap, false);
192                 }
193                 return;
194             }
195
196             if (mViewTypeCount == 1) {
197                 scrap.dispatchStartTemporaryDetach();
198                 mCurrentScrap.add(scrap);
199             } else {
200                 scrap.dispatchStartTemporaryDetach();
201                 mScrapViews[viewType].add(scrap);
202             }
203
204             if (mRecyclerListener != null) {
205                 mRecyclerListener.onMovedToScrapHeap(scrap);
206             }
207         }
208
209         /**
210          * Move all views remaining in mActiveViews to mScrapViews.把所以的activeviews变成scrapviews
211          */
212         void scrapActiveViews() {
213             final View[] activeViews = mActiveViews;
214             final boolean hasListener = mRecyclerListener != null;
215             final boolean multipleScraps = mViewTypeCount > 1;
216
217             ArrayList<View> scrapViews = mCurrentScrap;
218             final int count = activeViews.length;
219             for (int i = count - 1; i >= 0; i--) {
220                 final View victim = activeViews[i];
221                 if (victim != null) {
222                     int whichScrap = ((AbsListView.LayoutParams) victim.getLayoutParams()).viewType;
223
224                     activeViews[i] = null;
225
226                     if (!shouldRecycleViewType(whichScrap)) {
227                         // Do not move views that should be ignored
228                         if (whichScrap != ITEM_VIEW_TYPE_HEADER_OR_FOOTER) {
229                             removeDetachedView(victim, false);
230                         }
231                         continue;
232                     }
233
234                     if (multipleScraps) {
235                         scrapViews = mScrapViews[whichScrap];
236                     }
237                     victim.dispatchStartTemporaryDetach();
238                     scrapViews.add(victim);
239
240                     if (hasListener) {
241                         mRecyclerListener.onMovedToScrapHeap(victim);
242                     }
243
244                     if (ViewDebug.TRACE_RECYCLER) {
245                         ViewDebug.trace(victim,
246                                 ViewDebug.RecyclerTraceType.MOVE_FROM_ACTIVE_TO_SCRAP_HEAP,
247                                 mFirstActivePosition + i, -1);
248                     }
249                 }
250             }
251
252             pruneScrapViews();
253         }
254
255         /**
256          * Makes sure that the size of mScrapViews does not exceed the size of mActiveViews.
257          * (This can happen if an adapter does not recycle its views).保证mScrapViews中view数量始终小于等于mActiveViews中view的数量
258          */
259         private void pruneScrapViews() {
260             final int maxViews = mActiveViews.length;
261             final int viewTypeCount = mViewTypeCount;
262             final ArrayList<View>[] scrapViews = mScrapViews;
263             for (int i = 0; i < viewTypeCount; ++i) {
264                 final ArrayList<View> scrapPile = scrapViews[i];
265                 int size = scrapPile.size();
266                 final int extras = size - maxViews;
267                 size--;
268                 for (int j = 0; j < extras; j++) {
269                     removeDetachedView(scrapPile.remove(size--), false);
270                 }
271             }
272         }
273
274         /**
275          * Puts all views in the scrap heap into the supplied list.把所有的mScrapViews发到自己传进去的List中
276          */
277         void reclaimScrapViews(List<View> views) {
278             if (mViewTypeCount == 1) {
279                 views.addAll(mCurrentScrap);
280             } else {
281                 final int viewTypeCount = mViewTypeCount;
282                 final ArrayList<View>[] scrapViews = mScrapViews;
283                 for (int i = 0; i < viewTypeCount; ++i) {
284                     final ArrayList<View> scrapPile = scrapViews[i];
285                     views.addAll(scrapPile);
286                 }
287             }
288         }
289
290         /**
291          * Updates the cache color hint of all known views.
292          *
293          * @param color The new cache color hint.
294          */
295         void setCacheColorHint(int color) {
296             if (mViewTypeCount == 1) {
297                 final ArrayList<View> scrap = mCurrentScrap;
298                 final int scrapCount = scrap.size();
299                 for (int i = 0; i < scrapCount; i++) {
300                     scrap.get(i).setDrawingCacheBackgroundColor(color);
301                 }
302             } else {
303                 final int typeCount = mViewTypeCount;
304                 for (int i = 0; i < typeCount; i++) {
305                     final ArrayList<View> scrap = mScrapViews[i];
306                     final int scrapCount = scrap.size();
307                     for (int j = 0; j < scrapCount; j++) {
308                         scrap.get(i).setDrawingCacheBackgroundColor(color);
309                     }
310                 }
311             }
312             // Just in case this is called during a layout pass
313             final View[] activeViews = mActiveViews;
314             final int count = activeViews.length;
315             for (int i = 0; i < count; ++i) {
316                 final View victim = activeViews[i];
317                 if (victim != null) {
318                     victim.setDrawingCacheBackgroundColor(color);
319                 }
320             }
321         }
322     }

RecycleBin

这个类很简单，就是一些相关的add、get之类的方法。ListView是通过该类的对象实例mRecycler缓存view，当滚动Listview时，即不可视view变成可视时，Listview就有可能使用mRecycler里面的view实现重用，而不需要重新创建一个view，避免资源的浪费。

回头看一下makeAndAddView两种获得view的方式，一个是mRecycler.getActiveView(position)，一个是obtainView(position, mIsScrap)，前者已经介绍，看完RecycleBin就知道，它就是重用了ActiveViews中的view，后者是怎么样的呢？




obtainView

1     --->AbsListview.java
2         /**
3      * Get a view and have it show the data associated with the specified
4      * position. This is called when we have already discovered that the view is
5      * not available for reuse in the recycle bin. The only choices left are
6      * converting an old view or making a new one.这个方法会什么时候调用？就是当view不能通过recycle bin（其实就是mRecycler对象）
7      *重用的时候调用。那么这个时候的唯一方法就是转换一个旧的view或者创建一个新的view
8      *
9      * @param position The position to display
10      * @param isScrap Array of at least 1 boolean, the first entry will become true if
11      *                the returned view was taken from the scrap heap, false if otherwise.如果返回的view是从scrap heap中获得的，isScrap第一个元素将会是true，如果是自己创建的新view，它就是true
12      *
13      * @return A view displaying the data associated with the specified position
14      */
15     View obtainView(int position, boolean[] isScrap) {
16         isScrap[0] = false;
17         View scrapView;
18
19         scrapView = mRecycler.getScrapView(position);    //在Scrapview中获取view
20
21         View child;
22         if (scrapView != null) {    //如果有这个view，我们就通过old view去转换
23             if (ViewDebug.TRACE_RECYCLER) {
24                 ViewDebug.trace(scrapView, ViewDebug.RecyclerTraceType.RECYCLE_FROM_SCRAP_HEAP,
25                         position, -1);
26             }
27
28             //通过把scrapView作为参数传进去getView方法，这样就可以实现通过mAdapter转换成一个新view（推荐mAdapter要使用holder的那种写法）
29             child = mAdapter.getView(position, scrapView, this);
30
31             if (ViewDebug.TRACE_RECYCLER) {
32                 ViewDebug.trace(child, ViewDebug.RecyclerTraceType.BIND_VIEW,
33                         position, getChildCount());
34             }
35
36             if (child != scrapView) {    //如果你的getView方法返回的view是自己重新创建的view，那么scrapView就与它不是相等的
37                 mRecycler.addScrapView(scrapView);    //mRecycler存储这个scrapView
38                 if (mCacheColorHint != 0) {
39                     child.setDrawingCacheBackgroundColor(mCacheColorHint);
40                 }
41                 if (ViewDebug.TRACE_RECYCLER) {
42                     ViewDebug.trace(scrapView, ViewDebug.RecyclerTraceType.MOVE_TO_SCRAP_HEAP,
43                             position, -1);
44                 }
45             } else {
46                 isScrap[0] = true;    //设置isScrap的第一个元素为true，表明是通过old view转换获取view的
47                 child.dispatchFinishTemporaryDetach();
48             }
49         } else {
50             child = mAdapter.getView(position, null, this);    //第二个参数为null，那么只能创建一个新的view了
51             if (mCacheColorHint != 0) {
52                 child.setDrawingCacheBackgroundColor(mCacheColorHint);
53             }
54             if (ViewDebug.TRACE_RECYCLER) {
55                 ViewDebug.trace(child, ViewDebug.RecyclerTraceType.NEW_VIEW,
56                         position, getChildCount());
57             }
58         }
59
60         return child;
61     }

介绍到这里，可以总结一下Listview是怎么重用item view的了：

如果数据没有变化，那么直接从ActiveViews中取到view，然后去布局，ActiveViews保存的就是当前可视的views，这种情况下相当于，缓存下来的view还是被布局会原来的位置，什么也没有变化；

如果数据变化了，那么可能会从SrapViews中去到view去完成布局，ScrapVews其实就缓存的是上一次可视的views，这种情况的好处是，即使数据已经变化了，但依然不需要去创建一个新的view，避免耗费移动设备可怜少的资源。

这里说的数据变化其中的“数据”并不是仅仅是adapter中的真实数据，而是包括：AdapterDataSetObserver中监测的数据、size的变化、view的重绘和重建、click，checked等事件的发生。