Android 自定义ListView——下拉刷新&上拉加载

转载请注明出处：http://blog.csdn.net/allen315410/article/details/39965327

1.简介

       无疑，在Android开发中，ListView是使用非常频繁的控件之一，ListView提供一个列表的容易，允许我们以列表的形式将数据展示到界面上，但是Google给我们提供的原生ListView的控件，虽然在功能上很强大，但是在用户体验和动态效果上，还是比较差劲的。为了改善用户体验，市面上纷纷出现了各种各样的自定义的ListView，他们功能强大，界面美观，使我们该需要学习的地方。其中，使用最频繁的功能无疑就是ListView的下拉刷新和上拉加载数据了，几乎在没一款内容型的App中都可以找到这种控件的身影，尤其是需要联网获取数据的模块，使用的就更为频繁了，so，我们很有必要了解下这种效果是怎么实现的。

2.开源组件PullToRefreshList介绍      

      既然Android和Java都是开源的，一些常见的功能或者效果就不难被找到。PullToRefresh就是一个典型的例子，PullToRefresh是老外写的一个开源ListView组件，这个项目在ListView的基础上扩展了ListView的功能，增强了Listview的用户体验，功能十分强大，而且很容易被集成到当前的项目中，你只需要调用简单的API，即可省去很多不必要的麻烦，非常棒。以上是项目在Github的链接，有兴趣的可以戳进去down下来，使用一下。这里不是我们的重点，不想废话了。

PullToRefresh的Github项目地址： https://github.com/chrisbanes/Android-PullToRefresh

3.自定义ListView——下拉刷新&上拉加载

     本博客的重点讲述一下自定义LisView，实现下拉刷新和上拉加载的功能，实现类似于开源项目PullToRefresh的效果。好，既然如此，先看看我实现后的效果图，再分析：

      

        好，效果图如上所示，下面逐步讲解下实现的过程。首先，来观察一下，ListView上方的布局，我这里称其为“头布局”，这个所谓的头布局，大致功能是这样的，一个ImageView显示上下拉动方向的状态的，ImageView相同的位置隐藏了一个ProgressBar，用来在数据刷新时给个提示作用的。还有两个TextView，上面用来显示下拉刷新时提醒用户是如何操作的，例如“下拉刷新”“松开刷新”“正在刷新”，另一个是用来显示本次刷新的时间的。比较简单的布局，下面是XML代码：

[html]  view plain  copy

 print ?

1. <?xml version="1.0" encoding="utf-8"?>  
2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"  
3.     android:layout_width="match_parent"  
4.     android:layout_height="wrap_content"  
5.     android:orientation="horizontal" >  
6.   
7.     <FrameLayout  
8.         android:layout_width="wrap_content"  
9.         android:layout_height="wrap_content"  
10.         android:layout_margin="10dip" >  
11.   
12.         <ImageView  
13.             android:id="@+id/iv_listview_header_arrow"  
14.             android:layout_width="wrap_content"  
15.             android:layout_height="wrap_content"  
16.             android:layout_gravity="center"  
17.             android:minWidth="30dip"  
18.             android:src="@drawable/common_listview_headview_red_arrow" />  
19.   
20.         <ProgressBar  
21.             android:id="@+id/pb_listview_header"  
22.             android:layout_width="wrap_content"  
23.             android:layout_height="wrap_content"  
24.             android:layout_gravity="center"  
25.             android:indeterminateDrawable="@drawable/common_progressbar"  
26.             android:visibility="gone" />  
27.     </FrameLayout>  
28.   
29.     <LinearLayout  
30.         android:layout_width="fill_parent"  
31.         android:layout_height="wrap_content"  
32.         android:layout_gravity="center_vertical"  
33.         android:gravity="center_horizontal"  
34.         android:orientation="vertical" >  
35.   
36.         <TextView  
37.             android:id="@+id/tv_listview_header_state"  
38.             android:layout_width="wrap_content"  
39.             android:layout_height="wrap_content"  
40.             android:text="下拉刷新"  
41.             android:textColor="#FF0000"  
42.             android:textSize="18sp" />  
43.   
44.         <TextView  
45.             android:id="@+id/tv_listview_header_last_update_time"  
46.             android:layout_width="wrap_content"  
47.             android:layout_height="wrap_content"  
48.             android:layout_marginTop="5dip"  
49.             android:text="最后刷新时间: 2014-10-10 12:56:12"  
50.             android:textColor="@android:color/white"  
51.             android:textSize="14sp" />  
52.     </LinearLayout>  
53.   
54. </LinearLayout>  

         下面讲解一下ListView下方的布局，我称其为“脚布局”，这个脚布局就更简单了，直接看XML代码好了：

[html]  view plain  copy

 print ?

1. <?xml version="1.0" encoding="utf-8"?>  
2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"  
3.     android:layout_width="match_parent"  
4.     android:layout_height="wrap_content"  
5.     android:orientation="vertical" >  
6.   
7.     <LinearLayout  
8.         android:layout_width="wrap_content"  
9.         android:layout_height="wrap_content"  
10.         android:layout_gravity="center_horizontal"  
11.         android:layout_margin="10dip"  
12.         android:gravity="center_vertical"  
13.         android:orientation="horizontal" >  
14.   
15.         <ProgressBar  
16.             android:layout_width="wrap_content"  
17.             android:layout_height="wrap_content"  
18.             android:layout_gravity="center"  
19.             android:indeterminateDrawable="@drawable/common_progressbar" />  
20.   
21.         <TextView  
22.             android:layout_width="wrap_content"  
23.             android:layout_height="wrap_content"  
24.             android:layout_marginLeft="10dip"  
25.             android:text="加载更多..."  
26.             android:textColor="#FF0000"  
27.             android:textSize="18sp" />  
28.     </LinearLayout>  
29.   
30. </LinearLayout>  

此外，两个布局都用到一个ProgressBar的背景，其XML如下：

[html]  view plain  copy

 print ?

1. <?xml version="1.0" encoding="utf-8"?>  
2. <rotate xmlns:android="http://schemas.android.com/apk/res/android"  
3.     android:fromDegrees="0"  
4.     android:pivotX="50%"  
5.     android:pivotY="50%"  
6.     android:toDegrees="360" >  
7.   
8.     <shape  
9.         android:innerRadiusRatio="3"  
10.         android:shape="ring"  
11.         android:useLevel="false" >  
12.         <gradient  
13.             android:centerColor="#FF6666"  
14.             android:endColor="#FF0000"  
15.             android:startColor="#FFFFFF"  
16.             android:type="sweep" />  
17.     </shape>  
18.   
19. </rotate>  

        ListView的头布局和脚布局已经做好了，那么接下来该怎么集成到ListView上去呢？首先我们来看看ListView的部分源代码，很轻松能找到这两个方法： addHeaderView(View v)； addFooterView(View v)，通过字面的意思就可以理解，这两个方法分别是向ListView顶部添加一个View和向ListView的底部添加View的，有了这两个方法，那么上面的头布局和脚布局就很容易被添加到ListView上了，并且成为ListView的一体。

       其实，再看会发现，简单的使用这两个方法分别往ListView上添加头布局和脚布局是不合理，添加上去的头布局和脚布局会被显示出来，并没有被隐藏掉，为了实现下拉和上拉时能够将头布局和脚布局都“拉出来”并且还可以松开时，再次隐藏起来，我们可以使用View下的一个方法 setPadding(int left, int top, int right, int bottom)，这个方法设置View的Padding属性，这里，我们不必管left、right、bottom，只要设置top的值为头布局或者脚布局的高度即可“隐藏”这两个布局，而且还可以在手指滑动屏幕的时候，动态的设置这个top的值，来实现头布局和脚布局的显示-隐藏-显示。

       还有一个非常重要的话题，就是这个top的值还设定为多少合适？上面说了，我们来头布局来说明一下，隐藏这个头布局需要将top值设置成top=- 头布局高度，那么这个头布局的高度怎么求得呢？很显然，使用 getHeight()是得不到头布局高度的，因为 getHeight()方法是先控件在屏幕上展示完毕后得到的高度，显然在这里，这个ListView还在构建中，并没有展示到屏幕上。所以注意了，我们先调用View下的 measure(int widthMeasureSpec, int heightMeasureSpec)方法，将widthMeasureSpec和heightMeasureSpec分别设置为0，这里的widthMeasureSpec和heightMeasureSpec并不是一个准备的值，而且指定一个规格或者标准让系统帮我们测量View的宽高，当我们指定widthMeasureSpec和heightMeasureSpec分别为0的时候，系统将不采用这个规格去测量，而是根据实际情况去测量。之后，我们可以调用View下的 getMeasuredHeight()方法获取真实的头布局的高度，然后设置top = - 头布局实际高度，实现隐藏头布局。

[java]  view plain  copy

 print ?

1. public class RefreshListView extends ListView implements OnScrollListener {  
2.   
3.     private static final String TAG = "RefreshListView";  
4.     private int firstVisibleItemPosition; // 屏幕显示在第一个的item的索引  
5.     private int downY; // 按下时y轴的偏移量  
6.     private int headerViewHeight; // 头布局的高度  
7.     private View headerView; // 头布局的对象  
8.   
9.     private final int DOWN_PULL_REFRESH = 0; // 下拉刷新状态  
10.     private final int RELEASE_REFRESH = 1; // 松开刷新  
11.     private final int REFRESHING = 2; // 正在刷新中  
12.     private int currentState = DOWN_PULL_REFRESH; // 头布局的状态: 默认为下拉刷新状态  
13.   
14.     private Animation upAnimation; // 向上旋转的动画  
15.     private Animation downAnimation; // 向下旋转的动画  
16.   
17.     private ImageView ivArrow; // 头布局的剪头  
18.     private ProgressBar mProgressBar; // 头布局的进度条  
19.     private TextView tvState; // 头布局的状态  
20.     private TextView tvLastUpdateTime; // 头布局的最后更新时间  
21.   
22.     private OnRefreshListener mOnRefershListener;  
23.     private boolean isScrollToBottom; // 是否滑动到底部  
24.     private View footerView; // 脚布局的对象  
25.     private int footerViewHeight; // 脚布局的高度  
26.     private boolean isLoadingMore = false; // 是否正在加载更多中  
27.   
28.     public RefreshListView(Context context, AttributeSet attrs) {  
29.         super(context, attrs);  
30.         initHeaderView();  
31.         initFooterView();  
32.         this.setOnScrollListener(this);  
33.     }  
34.   
35.     /** 
36.      * 初始化脚布局 
37.      */  
38.     private void initFooterView() {  
39.         footerView = View.inflate(getContext(), R.layout.listview_footer, null);  
40.         footerView.measure(0, 0);  
41.         footerViewHeight = footerView.getMeasuredHeight();  
42.         footerView.setPadding(0, -footerViewHeight, 0, 0);  
43.         this.addFooterView(footerView);  
44.     }  
45.   
46.     /** 
47.      * 初始化头布局 
48.      */  
49.     private void initHeaderView() {  
50.         headerView = View.inflate(getContext(), R.layout.listview_header, null);  
51.         ivArrow = (ImageView) headerView  
52.                 .findViewById(R.id.iv_listview_header_arrow);  
53.         mProgressBar = (ProgressBar) headerView  
54.                 .findViewById(R.id.pb_listview_header);  
55.         tvState = (TextView) headerView  
56.                 .findViewById(R.id.tv_listview_header_state);  
57.         tvLastUpdateTime = (TextView) headerView  
58.                 .findViewById(R.id.tv_listview_header_last_update_time);  
59.   
60.         // 设置最后刷新时间  
61.         tvLastUpdateTime.setText("最后刷新时间: " + getLastUpdateTime());  
62.   
63.         headerView.measure(0, 0); // 系统会帮我们测量出headerView的高度  
64.         headerViewHeight = headerView.getMeasuredHeight();  
65.         headerView.setPadding(0, -headerViewHeight, 0, 0);  
66.         this.addHeaderView(headerView); // 向ListView的顶部添加一个view对象  
67.         initAnimation();  
68.     }  
69.   
70.     /** 
71.      * 获得系统的最新时间 
72.      *  
73.      * @return 
74.      */  
75.     private String getLastUpdateTime() {  
76.         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  
77.         return sdf.format(System.currentTimeMillis());  
78.     }  
79.   
80.     /** 
81.      * 初始化动画 
82.      */  
83.     private void initAnimation() {  
84.         upAnimation = new RotateAnimation(0f, -180f,  
85.                 Animation.RELATIVE_TO_SELF, 0.5f, Animation.RELATIVE_TO_SELF,  
86.                 0.5f);  
87.         upAnimation.setDuration(500);  
88.         upAnimation.setFillAfter(true); // 动画结束后, 停留在结束的位置上  
89.   
90.         downAnimation = new RotateAnimation(-180f, -360f,  
91.                 Animation.RELATIVE_TO_SELF, 0.5f, Animation.RELATIVE_TO_SELF,  
92.                 0.5f);  
93.         downAnimation.setDuration(500);  
94.         downAnimation.setFillAfter(true); // 动画结束后, 停留在结束的位置上  
95.     }  
96.   
97.     @Override  
98.     public boolean onTouchEvent(MotionEvent ev) {  
99.         switch (ev.getAction()) {  
100.             case MotionEvent.ACTION_DOWN :  
101.                 downY = (int) ev.getY();  
102.                 break;  
103.             case MotionEvent.ACTION_MOVE :  
104.                 int moveY = (int) ev.getY();  
105.                 // 移动中的y - 按下的y = 间距.  
106.                 int diff = (moveY - downY) / 2;  
107.                 // -头布局的高度 + 间距 = paddingTop  
108.                 int paddingTop = -headerViewHeight + diff;  
109.                 // 如果: -头布局的高度 > paddingTop的值 执行super.onTouchEvent(ev);  
110.                 if (firstVisibleItemPosition == 0  
111.                         && -headerViewHeight < paddingTop) {  
112.                     if (paddingTop > 0 && currentState == DOWN_PULL_REFRESH) { // 完全显示了.  
113.                         Log.i(TAG, "松开刷新");  
114.                         currentState = RELEASE_REFRESH;  
115.                         refreshHeaderView();  
116.                     } else if (paddingTop < 0  
117.                             && currentState == RELEASE_REFRESH) { // 没有显示完全  
118.                         Log.i(TAG, "下拉刷新");  
119.                         currentState = DOWN_PULL_REFRESH;  
120.                         refreshHeaderView();  
121.                     }  
122.                     // 下拉头布局  
123.                     headerView.setPadding(0, paddingTop, 0, 0);  
124.                     return true;  
125.                 }  
126.                 break;  
127.             case MotionEvent.ACTION_UP :  
128.                 // 判断当前的状态是松开刷新还是下拉刷新  
129.                 if (currentState == RELEASE_REFRESH) {  
130.                     Log.i(TAG, "刷新数据.");  
131.                     // 把头布局设置为完全显示状态  
132.                     headerView.setPadding(0, 0, 0, 0);  
133.                     // 进入到正在刷新中状态  
134.                     currentState = REFRESHING;  
135.                     refreshHeaderView();  
136.   
137.                     if (mOnRefershListener != null) {  
138.                         mOnRefershListener.onDownPullRefresh(); // 调用使用者的监听方法  
139.                     }  
140.                 } else if (currentState == DOWN_PULL_REFRESH) {  
141.                     // 隐藏头布局  
142.                     headerView.setPadding(0, -headerViewHeight, 0, 0);  
143.                 }  
144.                 break;  
145.             default :  
146.                 break;  
147.         }  
148.         return super.onTouchEvent(ev);  
149.     }  
150.   
151.     /** 
152.      * 根据currentState刷新头布局的状态 
153.      */  
154.     private void refreshHeaderView() {  
155.         switch (currentState) {  
156.             case DOWN_PULL_REFRESH : // 下拉刷新状态  
157.                 tvState.setText("下拉刷新");  
158.                 ivArrow.startAnimation(downAnimation); // 执行向下旋转  
159.                 break;  
160.             case RELEASE_REFRESH : // 松开刷新状态  
161.                 tvState.setText("松开刷新");  
162.                 ivArrow.startAnimation(upAnimation); // 执行向上旋转  
163.                 break;  
164.             case REFRESHING : // 正在刷新中状态  
165.                 ivArrow.clearAnimation();  
166.                 ivArrow.setVisibility(View.GONE);  
167.                 mProgressBar.setVisibility(View.VISIBLE);  
168.                 tvState.setText("正在刷新中...");  
169.                 break;  
170.             default :  
171.                 break;  
172.         }  
173.     }  
174.   
175.     /** 
176.      * 当滚动状态改变时回调 
177.      */  
178.     @Override  
179.     public void onScrollStateChanged(AbsListView view, int scrollState) {  
180.   
181.         if (scrollState == SCROLL_STATE_IDLE  
182.                 || scrollState == SCROLL_STATE_FLING) {  
183.             // 判断当前是否已经到了底部  
184.             if (isScrollToBottom && !isLoadingMore) {  
185.                 isLoadingMore = true;  
186.                 // 当前到底部  
187.                 Log.i(TAG, "加载更多数据");  
188.                 footerView.setPadding(0, 0, 0, 0);  
189.                 this.setSelection(this.getCount());  
190.   
191.                 if (mOnRefershListener != null) {  
192.                     mOnRefershListener.onLoadingMore();  
193.                 }  
194.             }  
195.         }  
196.     }  
197.   
198.     /** 
199.      * 当滚动时调用 
200.      *  
201.      * @param firstVisibleItem 
202.      *            当前屏幕显示在顶部的item的position 
203.      * @param visibleItemCount 
204.      *            当前屏幕显示了多少个条目的总数 
205.      * @param totalItemCount 
206.      *            ListView的总条目的总数 
207.      */  
208.     @Override  
209.     public void onScroll(AbsListView view, int firstVisibleItem,  
210.             int visibleItemCount, int totalItemCount) {  
211.         firstVisibleItemPosition = firstVisibleItem;  
212.   
213.         if (getLastVisiblePosition() == (totalItemCount - 1)) {  
214.             isScrollToBottom = true;  
215.         } else {  
216.             isScrollToBottom = false;  
217.         }  
218.     }  
219.   
220.     /** 
221.      * 设置刷新监听事件 
222.      *  
223.      * @param listener 
224.      */  
225.     public void setOnRefreshListener(OnRefreshListener listener) {  
226.         mOnRefershListener = listener;  
227.     }  
228.   
229.     /** 
230.      * 隐藏头布局 
231.      */  
232.     public void hideHeaderView() {  
233.         headerView.setPadding(0, -headerViewHeight, 0, 0);  
234.         ivArrow.setVisibility(View.VISIBLE);  
235.         mProgressBar.setVisibility(View.GONE);  
236.         tvState.setText("下拉刷新");  
237.         tvLastUpdateTime.setText("最后刷新时间: " + getLastUpdateTime());  
238.         currentState = DOWN_PULL_REFRESH;  
239.     }  
240.   
241.     /** 
242.      * 隐藏脚布局 
243.      */  
244.     public void hideFooterView() {  
245.         footerView.setPadding(0, -footerViewHeight, 0, 0);  
246.         isLoadingMore = false;  
247.     }  
248. }  

        还有2个重要的问题就是，1.我们如何知道这个头布局的状态什么时候改变？显示，当我们将头布局完全拉下的时候，我们就应该改变头布局上面的一些描述的信息。那么，怎么判断这个头布局什么时候刷新状态呢？提供如下的算法供参考：

1，计算手指在屏幕中滑动的间距。

      移动中的Y轴坐标 - 按下的Y轴坐标 = 间距

2，计算头布局距离顶部的距离

      -头布局的高度 + 间距 = paddingTop

3，如果: -头布局的高度 > paddingTop的值 执行super.onTouchEvent(ev);手指继续滑动，头布局状态为“松开刷新”；

      如果：-头布局的高度 < paddingTop的值，返回true，头布局状态为“下拉刷新”

4，手指抬起的时候，刷新

       问题2是如何知道，脚布局滑动到了ListView的底部，即最后一个可见的item。我们可以借助 android.widget.AbsListView.OnScrollListener接口下的两个方法 onScrollStateChanged(AbsListView view, int scrollState)和 onScroll(AbsListView view, int firstVisibleItem,int visibleItemCount, int totalItemCount)，现在ListView滚动时被调用的onScroll()方法中，判断当前的Item是不是最后一个Item，如果是的话就标记一个boolean的状态值，然后在监听ListView滑动状态onScrollStateChanged方法中，判断状态 scrollState == SCROLL_STATE_IDLE|| scrollState == SCROLL_STATE_FLING；若是，就说明ListView滑动到了底部了，这是需要上拉加载更多的数据。详细请参考上面贴出的代码，带上注释去看，也很好理解。

4.为ListView添加回调函数

       上面的效果是实现了，主要就讲解了UI的实现，接下来，我们了解一下逻辑方法的东西。显然，这个ListView还不能动态的“下来刷新”和“上拉加载”，为什么呢？很简单啊，暂时还没有向外界暴露出一个设置数据的方法。为了实现这个能够动态实施数据更新的功能，我们需要写一个回调提供给其它的类使用，首先看一下这个回调的接口：

[java]  view plain  copy

 print ?

1. public interface OnRefreshListener {  
2.   
3.     /** 
4.      * 下拉刷新 
5.      */  
6.     void onDownPullRefresh();  
7.   
8.     /** 
9.      * 上拉加载更多 
10.      */  
11.     void onLoadingMore();  
12. }  

这个回调的接口定义了两个方法，分别是“下拉刷新”和“上拉加载”，然后还必须在ListView中暴露一个接口与外面的类链接，最好的方法就暴露公共方法，例如：

[java]  view plain  copy

 print ?

1. public void setOnRefreshListener(OnRefreshListener listener) {  
2.         mOnRefershListener = listener;  
3.     }  

这样这个接口的对象就在ListView中建立了，我们只要拿着这个对象，就可以在相应的位置上调用该对象的“下拉刷新”“上拉加载”的方法了，不必在乎方法体是什么，因为具体实现的方式，具体的数据结构都是其他类中定义的，我们只要提供实现的方式即可。

5.使用这个自定义的ListView

       使用这个自定义的ListView特别简单的，这里不多说了，看代码：

[java]  view plain  copy

 print ?

1. public class MainActivity extends Activity implements OnRefreshListener {  
2.   
3.     private List<String> textList;  
4.     private MyAdapter adapter;  
5.     private RefreshListView rListView;  
6.   
7.     @Override  
8.     protected void onCreate(Bundle savedInstanceState) {  
9.         super.onCreate(savedInstanceState);  
10.         setContentView(R.layout.activity_main);  
11.   
12.         rListView = (RefreshListView) findViewById(R.id.refreshlistview);  
13.         textList = new ArrayList<String>();  
14.         for (int i = 0; i < 25; i++) {  
15.             textList.add("这是一条ListView的数据" + i);  
16.         }  
17.         adapter = new MyAdapter();  
18.         rListView.setAdapter(adapter);  
19.         rListView.setOnRefreshListener(this);  
20.     }  
21.   
22.     private class MyAdapter extends BaseAdapter {  
23.   
24.         @Override  
25.         public int getCount() {  
26.             // TODO Auto-generated method stub  
27.             return textList.size();  
28.         }  
29.   
30.         @Override  
31.         public Object getItem(int position) {  
32.             // TODO Auto-generated method stub  
33.             return textList.get(position);  
34.         }  
35.   
36.         @Override  
37.         public long getItemId(int position) {  
38.             // TODO Auto-generated method stub  
39.             return position;  
40.         }  
41.   
42.         @Override  
43.         public View getView(int position, View convertView, ViewGroup parent) {  
44.             // TODO Auto-generated method stub  
45.             TextView textView = new TextView(MainActivity.this);  
46.             textView.setText(textList.get(position));  
47.             textView.setTextColor(Color.WHITE);  
48.             textView.setTextSize(18.0f);  
49.             return textView;  
50.         }  
51.   
52.     }  
53.   
54.     @Override  
55.     public void onDownPullRefresh() {  
56.         new AsyncTask<Void, Void, Void>() {  
57.   
58.             @Override  
59.             protected Void doInBackground(Void... params) {  
60.                 SystemClock.sleep(2000);  
61.                 for (int i = 0; i < 2; i++) {  
62.                     textList.add(0, "这是下拉刷新出来的数据" + i);  
63.                 }  
64.                 return null;  
65.             }  
66.   
67.             @Override  
68.             protected void onPostExecute(Void result) {  
69.                 adapter.notifyDataSetChanged();  
70.                 rListView.hideHeaderView();  
71.             }  
72.         }.execute(new Void[]{});  
73.     }  
74.   
75.     @Override  
76.     public void onLoadingMore() {  
77.         new AsyncTask<Void, Void, Void>() {  
78.   
79.             @Override  
80.             protected Void doInBackground(Void... params) {  
81.                 SystemClock.sleep(5000);  
82.   
83.                 textList.add("这是加载更多出来的数据1");  
84.                 textList.add("这是加载更多出来的数据2");  
85.                 textList.add("这是加载更多出来的数据3");  
86.                 return null;  
87.             }  
88.   
89.             @Override  
90.             protected void onPostExecute(Void result) {  
91.                 adapter.notifyDataSetChanged();  
92.   
93.                 // 控制脚布局隐藏  
94.                 rListView.hideFooterView();  
95.             }  
96.         }.execute(new Void[]{});  
97.     }  
98.   
99. }  

我们模拟的是联网更新数据，所以必须要开启新的线程去获取数据，联网获取数据的方式有很多种，我这里使用的Android为我们提供好的AsyncTask轻量型的框架，关于这个框架，在下面有一些简单的介绍。

6.AsyncTask简单介绍

先来看看AsyncTask的定义：

[java]  view plain  copy

 print ?

1. public abstract class AsyncTask<Params, Progress, Result> {  

三种泛型类型分别代表

Params ：“启动任务执行的输入参数”，Progress：“后台任务执行的进度”，Result：“后台计算结果的类型”。在特定场合下，并不是所有类型都被使用，如果没有被使用，可以用Java.lang.Void类型代替。

一个异步任务的执行一般包括以下几个步骤：

1.execute(Params... params)，执行一个异步任务，需要我们在代码中调用此方法，触发异步任务的执行。

2.onPreExecute()，在execute(Params... params)被调用后立即执行，一般用来在执行后台任务前对UI做一些标记。

3.doInBackground(Params... params)，在onPreExecute()完成后立即执行，用于执行较为费时的操作，此方法将接收输入参数和返回计算结果。在执行过程中可以调用publishProgress(Progress... values)来更新进度信息。

4.onProgressUpdate(Progress... values)，在调用publishProgress(Progress... values)时，此方法被执行，直接将进度信息更新到UI组件上。

5.onPostExecute(Result result)，当后台操作结束时，此方法将会被调用，计算结果将做为参数传递到此方法中，直接将结果显示到UI组件上。

下面是一个图解：

通过这个草图，我们可以分析出AsyncTask三个泛型参数的用处，1，第一个泛型参数Params就是execute()方法中的参数，这二者要保持一致，因为这个参数Params会直接传递给doInBackground(Params...params)方法中，作为这个方法的参数存在。2，第二个参数Progress代表任务执行的进度，通常设定为Void类型，不使用它。3，第三个参数Result代表的是doInBackground()方法的返回值类型，这个返回值类型决定该方法在子线程中获取的是什么类型的数据，并且获取到的数据将被传递给onPostExecute()方法中作为参数，就是程序执行的结果，在该方法中拿到这个结果在UI上实现数据更新。

       以上是对AsyncTask的简单介绍，没有深入，想要深入了解AsyncTask，请移步到以下这两篇博客中。

详解Android中AsyncTask的使用

Android AsyncTask完全解析，带你从源码的角度彻底理解

源码请在这里下载

http://download.csdn.net/detail/lee_tianya/8022247