何时调用getView？——从源码的角度给出解答

先来看ListView类中的makeAndAddView方法：

没有数据变化：从mRecycler中取得可视的view

数据有变化：obtainView

 1 /**
 2      * 获取视图填充到列表的item中去，视图可以是从未使用过的视图转换过来，也可以是从回收站复用的视图。
 3      * 在该方法中，先查找是否有可重用视图，如果有，使用可重用视图。
 4      * 然后通过obtainView方法获取一个view（有可能是从未使用视图转换过来
 5      * （obtainView方法是在AbsListView方法中定义）），再重新测量和定位View。
 6      */
 7     private View makeAndAddView(int position, int y, boolean flow, int childrenLeft,
 8             boolean selected) {
 9         View child;
10         // 没有数据变化：从mRecycler中取得可视的view
11         if (!mDataChanged) {
12             // Try to use an existing view for this position
13             child = mRecycler.getActiveView(position);
14             ...
15         }
16         // 生成view，回收旧view和调用mApapter.getView的地方(AbsListView)
17         child = obtainView(position, mIsScrap);
18         ...
19         return child;
20     }

第11行调用了obtainView方法，该方法的实现是在package android.widget;的AbsListView类中

 1        View obtainView(int position, boolean[] isScrap) {
 2            Trace.traceBegin(Trace.TRACE_TAG_VIEW, "obtainView");
 3    
 4            isScrap[0] = false;
 5            View scrapView;
 6            
 7            scrapView = mRecycler.getTransientStateView(position);
 8            if (scrapView == null) {
 9                // 从回收站回收一个View
10               scrapView = mRecycler.getScrapView(position);
11           }
12   
13           View child;
14           if (scrapView != null) {
15               // 这里调用了getView!注意，第二个参数也就是convertView，传入的是刚才从回收站中回收的View(如果有的话)
16               child = mAdapter.getView(position, scrapView, this);
17           ...
18           return child;
19       }

第16行调用了getView！根据Java多态的特性，实际执行的getView将会是我们自定义BaseAdapter中的那个getView方法。

好，现在虽然找到getView的直接调用者了，问题来了，何时去触发makeAndAddView并调用getView呢？

我们首先来看ListView中的fillDown：自顶至底去填充ListView

 1  /**
 2      填充从pos到list底部所有的item。里面调用到了makeAndAddView方法：
 3       */
 4      private View fillDown(int pos, int nextTop) {
 5         ... 
 6         // 这里调用到了makeAndAddView方法
 7         View child = makeAndAddView(pos, nextTop, true, mListPadding.left, selected);
 8         ...
 9         return selectedView;
10      }

有fillDown自然就有fillUp：

1      private View fillUp(int pos, int nextBottom) {
2          View selectedView = null;
3          ...
4          // 调用makeAndAddView
5          View child = makeAndAddView(pos, nextBottom, false, mListPadding.left, selected);
6          ...
7          return selectedView;
8      }

还有fillFromTop、fillFromMiddle、fillAboveAndBelow、fillFromSelection等，这些方法都是用来进行子元素布局的，区别是布局模式不同而已。

好了，现在布局子元素的方法有了，那么谁来触发这些方法呢？

通过查找ListView源码，发现刚才的那些方法在layoutChildren()中基本上都出现了。

 1     @Override
 2     protected void layoutChildren() {
 3             ...
 4             // 根据mLayoutMode的值来决定布局模式
 5             switch (mLayoutMode) {
 6             case LAYOUT_SET_SELECTION:
 7                 if (newSel != null) {
 8                     sel = fillFromSelection(newSel.getTop(), childrenTop, childrenBottom);
 9                 } else {
10                     sel = fillFromMiddle(childrenTop, childrenBottom);
11                 }
12                 break;
13             case LAYOUT_SYNC:
14                 sel = fillSpecific(mSyncPosition, mSpecificTop);
15                 break;
16             case LAYOUT_FORCE_BOTTOM:
17                 sel = fillUp(mItemCount - 1, childrenBottom);
18                 adjustViewsUpOrDown();
19                 break;
20             case LAYOUT_FORCE_TOP:
21                 mFirstPosition = 0;
22                 sel = fillFromTop(childrenTop);
23                 adjustViewsUpOrDown();
24                 break;
25             case LAYOUT_SPECIFIC:
26                 sel = fillSpecific(reconcileSelectedPosition(), mSpecificTop);
27                 break;
28             case LAYOUT_MOVE_SELECTION:
29                 sel = moveSelection(oldSel, newSel, delta, childrenTop, childrenBottom);
30                 break;
31             default:// 默认的布局顺序是从上往下
32                 if (childCount == 0) {
33                     if (!mStackFromBottom) {
34                         final int position = lookForSelectablePosition(0, true);
35                         setSelectedPositionInt(position);
36                         sel = fillFromTop(childrenTop);
37                     } else {
38                         final int position = lookForSelectablePosition(mItemCount - 1, false);
39                         setSelectedPositionInt(position);
40                         sel = fillUp(mItemCount - 1, childrenBottom);
41                     }
42                 } else {
43                     if (mSelectedPosition >= 0 && mSelectedPosition < mItemCount) {
44                         sel = fillSpecific(mSelectedPosition,
45                                 oldSel == null ? childrenTop : oldSel.getTop());
46                     } else if (mFirstPosition < mItemCount) {
47                         sel = fillSpecific(mFirstPosition,
48                                 oldFirst == null ? childrenTop : oldFirst.getTop());
49                     } else {
50                         sel = fillSpecific(0, childrenTop);
51                     }
52                 }
53                 break;
54             }
55 
56             ...
57     }

继续查找，我们发现layoutChildren的调用者是onFocusChanged、setSelectionInt、父类AbsListView中的onTouchMove、onLayout（这个比较特殊，后文会说明）等，说明当ListView的焦点发生变化时、选中某一项、或者滑动ListView时都会触发ListView的layoutChildren()去布局子元素。

到此为止我们已经很清楚getView的调用时机了，根据掌握的知识点，我们很自然能想到，当初始化一个ListView时，getView的调用也是避免不了的。这是因为ListView在初始化时肯定会绑定一个adapter，即调用语句listview.setAdapter(adapter)，我们看一下setAdapter的源码：

 1 @Override
 2     public void setAdapter(ListAdapter adapter) {
 3         if (mAdapter != null && mDataSetObserver != null) {
 4             mAdapter.unregisterDataSetObserver(mDataSetObserver);
 5         }
 6         // 去除原有adapter、观察者、选中项等信息
 7         resetList();
 8         mRecycler.clear();
 9         // 包装adapter，加header或footer，并绑定到当前ListView
10         if (mHeaderViewInfos.size() > 0|| mFooterViewInfos.size() > 0) {
11             mAdapter = new HeaderViewListAdapter(mHeaderViewInfos, mFooterViewInfos, adapter);
12         } else {
13             mAdapter = adapter;
14         }
15         // 重置选中项信息
16         mOldSelectedPosition = INVALID_POSITION;
17         mOldSelectedRowId = INVALID_ROW_ID;
18 
19         // AbsListView#setAdapter will update choice mode states.
20         super.setAdapter(adapter);
21         
22         if (mAdapter != null) {
23             mAreAllItemsSelectable = mAdapter.areAllItemsEnabled();
24             mOldItemCount = mItemCount;
25             mItemCount = mAdapter.getCount();
26             checkFocus();
27             // 重新注册观察者
28             mDataSetObserver = new AdapterDataSetObserver();
29             mAdapter.registerDataSetObserver(mDataSetObserver);
30             // 设置回收器中类型不同的View数目，这里与getView的回收机制紧密相关，值得深究
31             mRecycler.setViewTypeCount(mAdapter.getViewTypeCount());
32             // 设置初始选中项
33             int position;
34             if (mStackFromBottom) {
35                 position = lookForSelectablePosition(mItemCount - 1, false);
36             } else {
37                 position = lookForSelectablePosition(0, true);
38             }
39             setSelectedPositionInt(position);
40             setNextSelectedPositionInt(position);
41 
42             if (mItemCount == 0) {
43                 // Nothing selected
44                 checkSelectionChanged();
45             }
46         } else {
47             mAreAllItemsSelectable = true;
48             checkFocus();
49             // Nothing selected
50             checkSelectionChanged();
51         }
52         // 请求布局重绘
53         requestLayout();
54     }

通读setAdapter源码，我们发现其中并未出现生成新子视图，即调用mAdapter.getView的语句或相关方法，说明此时ListView并未包含子视图。那么疑问来了，ListView是如何在初始化的时候生成子视图的，也就是说第一屏的视图是如何加载到屏幕上的？往后看，我们发现在第53行调用了requestLayout请求布局重绘，我们知道requestLayout最终会去调用onMeasure、onLayout、onDraw方法，因此我们猜测会不会是在onMeasure、onLayout、onDraw某个方法中生成了子视图？

答案是肯定的，AbsListVIew.onLayout过程与普通视图的layout过程完全不同，如下：

1 protected void onLayout(boolean changed, int l, int t, int r, int b) {
2         super.onLayout(changed, l, t, r, b);
3         ...
4         layoutChildren();
5         ...
6     }

该方法调用了layoutChildren();，即重新布局ListView列表视图。

由此说明调用requestLayout可以实现ListView列表视图的重新布局，这里联想到adapter.notifyDataSetChanged也会调用requestLayout，从而都能实现ListView的刷新。

以上过程只是个人探索，并非绝对正确，如有差错敬请批评指正，谢谢。

参考文献：

Android ListView初始化简单分析

Android ListView工作原理完全解析，带你从源码的角度彻底理解

android源码解析--ListView（上）

ListView源代码分析