Android 轻松实现仿QQ空间下拉刷新

（本文讲解了在Android中实现列表下拉刷新的动态效果的过程，文末附有源码。）

看完本文，您可以学到：

1.下拉刷新的实现原理

2.自定义Android控件,重写其ListView

3.ScrollListener滚动监听

4.Adapter适配器的使用

话不多说，先来看看效果图:

接下来我们一步一步地实现以上的效果。

一、图文并茂的ListViewItem

看一下这一步的效果图：  

首先，我们要实现的是带下拉刷新效果的ListView。所以我们选择自己重写原生控件ListView。只需要写一个类继承它就可以了，先不添加任何的具体实现。

RefreshListView.java:

[java] view plain copy

1. public class RefreshListView extends ListView {  
2.     public RefreshListView(Context context) {  
3.         super(context);  
4.         // TODO Auto-generated constructor stub  
5.     }  
6.   
7.     public RefreshListView(Context context, AttributeSet attrs) {  
8.         super(context, attrs);  
9.         // TODO Auto-generated constructor stub  
10.     }  
11.   
12.     public RefreshListView(Context context, AttributeSet attrs, int defStyle) {  
13.         super(context, attrs, defStyle);  
14.         // TODO Auto-generated constructor stub  
15.     }  
16. }  

要实现图文并茂的ListViewItem,接下去就要自己定义它Item的布局，这个可以无限发挥，我这里就只取图和文做一个简单的实现：

listview_item.xml:

[html] view plain copy

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="match_parent"  
5.     android:gravity="center_vertical"  
6.     android:orientation="horizontal" >  
7.   
8.     <ImageView  
9.         android:id="@+id/image"  
10.         android:layout_width="wrap_content"  
11.         android:layout_height="wrap_content"  
12.         android:layout_marginLeft="10dp" />  
13.   
14.     <TextView  
15.         android:id="@+id/text"  
16.         android:layout_width="wrap_content"  
17.         android:layout_height="wrap_content"  
18.         android:layout_marginLeft="10dp"  
19.         android:textSize="25sp" />  
20.   
21. </LinearLayout>  

在这个布局中，我就只放了一个Image和一个Text。您可以自己定义地更复杂。

然后需要我们注意的是，既然我们自己定义了ListView，那我们主界面的布局也要响应地修改了:

activity_main.xml:

[html] view plain copy

1. <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"  
2.     xmlns:tools="http://schemas.android.com/tools"  
3.     android:layout_width="match_parent"  
4.     android:layout_height="match_parent"  
5.     tools:context=".MainActivity" >  
6.   
7.     <com.example.mylistviewrefresh.RefreshListView  
8.         android:id="@+id/listview"  
9.         android:layout_width="fill_parent"  
10.         android:layout_height="wrap_content"  
11.         android:cacheColorHint="#00000000"  
12.         android:dividerHeight="5dip" />  
13.   
14. </RelativeLayout>  

可以一眼看出我们修改了它的控件标签，改为我们自己定义的类的完全路径。

最后是主角MainActivity.java,里面的一些代码我详细地给了注释。这里要注意的是适配器的使用。

[java] view plain copy

1. public class MainActivity extends Activity {  
2.     private RefreshListView listView;  
3.     private SimpleAdapter simple_adapter;  
4.     private List<Map<String, Object>> list;  
5.   
6.     @Override  
7.     protected void onCreate(Bundle savedInstanceState) {  
8.         super.onCreate(savedInstanceState);  
9.         setContentView(R.layout.activity_main);  
10.         listView = (RefreshListView) findViewById(R.id.listview);  
11.         iniData();   //初始化数据，我们给它加20条Item  
12.         // 设置SimpleAdapter监听器  
13.         /** 
14.          * SimpleAdapter的五个参数的含义： 
15.          * 第一个：context上下文 
16.          * 第二个：用于显示的数据，map的list 
17.          * 第三个：Item的布局，即我们自定义的那个文件 
18.          * 第四个：与第二个参数紧密联系，与第五个紧密联系，是在map中的键值 
19.          * 第五个：我们看到是id（int类型）的数组，这个数组里的东西是哪里来的？是我们自己在布局文件中定义的，忘记的读者可以回过头去看一下 
20.          * 这几个参数独立开来可能不知道是干吗的，但是我觉得联合在一起就挺好理解了。 
21.          */  
22.         simple_adapter = new SimpleAdapter(MainActivity.this, list,  
23.                 R.layout.listview_item, new String[] { "image", "text" },  
24.                 new int[] { R.id.image, R.id.text });  
25.         //设置适配器  
26.         listView.setAdapter(simple_adapter);  
27.   
28.     }  
29.   
30.     // 初始化SimpleAdapter数据集  
31.     private List<Map<String, Object>> iniData() {  
32.         list = new ArrayList<Map<String, Object>>();  
33.         for (int i = 0; i < 20; i++) {  
34.             Map<String, Object> map = new HashMap<String, Object>();  
35.             //解释下这里的数据，key对应SimpleAdapter的第三个参数，必须都包含它们。值对应第五个参数，分别是图片和文字  
36.             map.put("text", i);  
37.             map.put("image", R.drawable.ic_launcher);  
38.             list.add(map);  
39.         }  
40.   
41.         return list;  
42.     }  
43.   
44.     @Override  
45.     public boolean onCreateOptionsMenu(Menu menu) {  
46.         // Inflate the menu; this adds items to the action bar if it is present.  
47.         getMenuInflater().inflate(R.menu.main, menu);  
48.         return true;  
49.     }  
50.   
51. }  

到了这一步，应该能够实现图片+文字的listview了吧，喝口茶，我们继续看下去。

二、加入隐藏的Header

这里我们要说一下下拉刷新的实现思路了：

首先，我们平常用到的下拉刷新，都是在下拉后屏幕上方显示出一些之前被隐藏的控件，类似下拉的箭头、progress bar等等。

那我们可以直接把它们设置为不可见吗？显然是不可以的。因为这些空间的显示与否，有一个渐变的过程，不是刷一下就出来的。

所以我们应该这样做：

加入一个隐藏的布局，放在屏幕上方。根据下拉的范围来显示响应的控件。

这一步，我们要实现的是加入隐藏的布局，具体怎样根据下拉的状态来实时调整Header的显示状态，我们在下文细说。

我们为了需要隐藏的header再自定义个新的布局，header.xml:

[plain] view plain copy

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.     <RelativeLayout  
8.         android:layout_width="match_parent"  
9.         android:layout_height="wrap_content"  
10.         android:paddingBottom="10dip"  
11.         android:paddingTop="10dip" >  
12.   
13.         <LinearLayout  
14.             android:id="@+id/layout"  
15.             android:layout_width="wrap_content"  
16.             android:layout_height="wrap_content"  
17.             android:layout_centerInParent="true"  
18.             android:gravity="center"  
19.             android:orientation="vertical" >  
20.   
21.             <TextView  
22.                 android:id="@+id/tip"  
23.                 android:layout_width="wrap_content"  
24.                 android:layout_height="wrap_content"  
25.                 android:text="下拉可以刷新！" />  
26.   
27.             <TextView  
28.                 android:id="@+id/lastupdate_time"  
29.                 android:layout_width="wrap_content"  
30.                 android:layout_height="wrap_content" />  
31.         </LinearLayout>  
32.   
33.         <ImageView  
34.             android:id="@+id/arrow"  
35.             android:layout_width="wrap_content"  
36.             android:layout_height="wrap_content"  
37.             android:layout_toLeftOf="@id/layout"  
38.             android:layout_marginRight="20dip"  
39.             android:src="@drawable/pull_to_refresh_arrow" />  
40.   
41.         <ProgressBar  
42.             android:id="@+id/progress"  
43.             style="?android:attr/progressBarStyleSmall"  
44.             android:layout_width="wrap_content"  
45.             android:layout_height="wrap_content"  
46.             android:layout_toLeftOf="@id/layout"  
47.             android:layout_marginRight="20dip"  
48.             android:visibility="gone" />  
49.     </RelativeLayout>  
50.   
51. </LinearLayout>  

这个布局中包含了提示语“下拉可以刷新”、最新更新时间、下拉箭头的图片（已经预先放在drawable文件夹中了,读者可以自己找个图片放进去，命名为pull_to_refresh_arrow.phg）、一个更新时才显示的progressbar(现在是隐藏的）。

为了把这个布局加到我们定义的List，我们需要改写之前自定义的RefreshLIstview控件：

[java] view plain copy

1. public class RefreshListView extends ListView {  
2.     View header;// 顶部布局文件；  
3.     int headerHeight;// 顶部布局文件的高度；  
4.     public RefreshListView(Context context) {  
5.         super(context);  
6.         // TODO Auto-generated constructor stub  
7.         initView(context);  
8.     }  
9.   
10.     public RefreshListView(Context context, AttributeSet attrs) {  
11.         super(context, attrs);  
12.         // TODO Auto-generated constructor stub  
13.         initView(context);  
14.     }  
15.   
16.     public RefreshListView(Context context, AttributeSet attrs, int defStyle) {  
17.         super(context, attrs, defStyle);  
18.         // TODO Auto-generated constructor stub  
19.         initView(context);  
20.     }  
21.   
22.     /** 
23.      * 初始化界面，添加顶部布局文件到 listview 
24.      */  
25.     private void initView(Context context) {  
26.         LayoutInflater inflater = LayoutInflater.from(context);  
27.         header = inflater.inflate(R.layout.header, null);  
28.         measureView(header);  
29.         headerHeight = header.getMeasuredHeight();  
30.         Log.i("tag", "headerHeight = " + headerHeight);  
31.         //topPadding(-headerHeight);   //这一行被我注释了，如果你去除注释，就可以显示出来了  
32.         this.addHeaderView(header);  
33.     }  
34.   
35.     /** 
36.      * 通知父布局，占用的宽，高； 
37.      */  
38.     private void measureView(View view) {  
39.         ViewGroup.LayoutParams p = view.getLayoutParams();  
40.         if (p == null) {  
41.             p = new ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT,  
42.                     ViewGroup.LayoutParams.WRAP_CONTENT);  
43.         }  
44.         int width = ViewGroup.getChildMeasureSpec(0, 0, p.width);  
45.         int height;  
46.         int tempHeight = p.height;  
47.         if (tempHeight > 0) {  
48.             height = MeasureSpec.makeMeasureSpec(tempHeight,  
49.                     MeasureSpec.EXACTLY);  
50.         } else {  
51.             height = MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED);  
52.         }  
53.         view.measure(width, height);  
54.     }  
55.   
56.     /** 
57.      * 设置header布局 上边距； 
58.      */  
59.     private void topPadding(int topPadding) {  
60.         header.setPadding(header.getPaddingLeft(), topPadding,  
61.                 header.getPaddingRight(), header.getPaddingBottom());  
62.         header.invalidate();  
63.     }  
64. }  

主要实现的是把新的header加入进去，同时把它隐藏。现在我把隐藏header的那行代码注释了，我们看看现在的效果：

如果去除注释，header就被隐藏。

三、加入滚动监听实时调整Header显示状态以及刷新后添加数据

思路：

添加屏幕触摸监听和屏幕滚动监听。

触摸监听尤其重要：  

在触摸时记录下触摸坐标的Y值即startY，然后在移动过程中监听当前的Y值，根据两者的插值判断当前的移动距离，与一些临界值做比较。

比较之后得出当前的状态：提示下拉状态、提示释放状态、刷新状态。根据当前的状态来刷新header布局的显示情况。

滚动监听的作用是判断当前是否是列表的顶端（通过判断当前可见的第一个item的position是否为0），以及在之后判断屏幕的滚动状态。

另外在自定义的Listview类中定义了一个接口，在mainactivity中实现这个接口，用来对数据进行刷新。我们在刷新的时候用了Handler延迟了两秒，以清晰地看到刷新的效果。

修改后的MainActivity以及ListView：

ListView:  （里面很多注释，自己看着应该很好理解）

[java] view plain copy

1. public class RefreshListView extends ListView implements OnScrollListener {  
2.     View header;// 顶部布局文件；  
3.     int headerHeight;// 顶部布局文件的高度；  
4.     int firstVisibleItem;// 当前第一个可见的item的位置；  
5.     int scrollState;// listview 当前滚动状态；  
6.     boolean isRemark;// 标记，当前是在listview最顶端摁下的；  
7.     int startY;// 摁下时的Y值；  
8.   
9.     int state;// 当前的状态；  
10.     final int NONE = 0;// 正常状态；  
11.     final int PULL = 1;// 提示下拉状态；  
12.     final int RELEASE = 2;// 提示释放状态；  
13.     final int REFRESHING = 3;// 刷新状态；  
14.     IRefreshListener iRefreshListener;//刷新数据的接口  
15.     public RefreshListView(Context context) {  
16.         super(context);  
17.         // TODO Auto-generated constructor stub  
18.         initView(context);  
19.     }  
20.   
21.     public RefreshListView(Context context, AttributeSet attrs) {  
22.         super(context, attrs);  
23.         // TODO Auto-generated constructor stub  
24.         initView(context);  
25.     }  
26.   
27.     public RefreshListView(Context context, AttributeSet attrs, int defStyle) {  
28.         super(context, attrs, defStyle);  
29.         // TODO Auto-generated constructor stub  
30.         initView(context);  
31.     }  
32.   
33.     /** 
34.      * 初始化界面，添加顶部布局文件到 listview 
35.      *  
36.      * @param context 
37.      */  
38.     private void initView(Context context) {  
39.         LayoutInflater inflater = LayoutInflater.from(context);  
40.         header = inflater.inflate(R.layout.header, null);  
41.         measureView(header);  
42.         headerHeight = header.getMeasuredHeight();  
43.         Log.i("tag", "headerHeight = " + headerHeight);  
44.         topPadding(-headerHeight);  
45.         this.addHeaderView(header);  
46.         this.setOnScrollListener(this);  
47.     }  
48.   
49.     /** 
50.      * 通知父布局，占用的宽，高； 
51.      *  
52.      * @param view 
53.      */  
54.     private void measureView(View view) {  
55.         ViewGroup.LayoutParams p = view.getLayoutParams();  
56.         if (p == null) {  
57.             p = new ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT,  
58.                     ViewGroup.LayoutParams.WRAP_CONTENT);  
59.         }  
60.         int width = ViewGroup.getChildMeasureSpec(0, 0, p.width);  
61.         int height;  
62.         int tempHeight = p.height;  
63.         if (tempHeight > 0) {  
64.             height = MeasureSpec.makeMeasureSpec(tempHeight,  
65.                     MeasureSpec.EXACTLY);  
66.         } else {  
67.             height = MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED);  
68.         }  
69.         view.measure(width, height);  
70.     }  
71.   
72.     /** 
73.      * 设置header 布局 上边距； 
74.      *  
75.      * @param topPadding 
76.      */  
77.     private void topPadding(int topPadding) {  
78.         header.setPadding(header.getPaddingLeft(), topPadding,  
79.                 header.getPaddingRight(), header.getPaddingBottom());  
80.         header.invalidate();  
81.     }  
82.   
83.     @Override  
84.     public void onScroll(AbsListView view, int firstVisibleItem,  
85.             int visibleItemCount, int totalItemCount) {  
86.         // TODO Auto-generated method stub  
87.         this.firstVisibleItem = firstVisibleItem;  
88.     }  
89.   
90.     @Override  
91.     public void onScrollStateChanged(AbsListView view, int scrollState) {  
92.         // TODO Auto-generated method stub  
93.         this.scrollState = scrollState;  
94.     }  
95.       
96.     /** 
97.      * 对屏幕触摸的监控， 
98.      * 先判断当前是否是在顶端。如果是在最顶端，记录下你开始滑动的Y值 
99.      * 然后在滑动过程中（监听到的是ACTION_MOVE)，不断地判断当前滑动的范围是否到达应该刷新的程度。 
100.      * (根据当前的Y-之前的startY的值 与我们的控件的高度之间关系来判断） 
101.      * 然后在监听到手指松开时，根据当前的状态（我们在onmove（）中计算的），做相应的操作。 
102.      */  
103.     @Override  
104.     public boolean onTouchEvent(MotionEvent ev) {  
105.         // TODO Auto-generated method stub  
106.         switch (ev.getAction()) {  
107.         case MotionEvent.ACTION_DOWN:  
108.             if (firstVisibleItem == 0) {  
109.                 isRemark = true;  
110.                 startY = (int) ev.getY();  
111.             }  
112.             break;  
113.   
114.         case MotionEvent.ACTION_MOVE:  
115.             onMove(ev);  
116.             break;  
117.         case MotionEvent.ACTION_UP:  
118.             if (state == RELEASE) {  
119.                 //即提示松开刷新的状态，一旦松开，进入到正在刷新；这时候就可以加载数据了！  
120.                 state = REFRESHING;  
121.                 // 加载最新数据；  
122.                 refreshViewByState();  
123.                 iRefreshListener.onRefresh();  
124.             } else if (state == PULL) {  
125.                 //提示下拉状态状态，如果放掉的话，把一切还原，什么都没有做  
126.                 state = NONE;  
127.                 isRemark = false;  
128.                 refreshViewByState();  
129.             }  
130.             break;  
131.         }  
132.         return super.onTouchEvent(ev);  
133.     }  
134.   
135.     /** 
136.      * 判断移动过程操作： 
137.      * 如果不是顶端，不需要做任何的操作 
138.      * 否则就获取当前的Y值，与开始的Y值做比较。 
139.      * 判断下拉的高度，与我们定义的一些临界值做判断（其实这个临界值你可以自己定义） 
140.      *  
141.      * @param ev 
142.      */  
143.     private void onMove(MotionEvent ev) {  
144.         if (!isRemark) {  
145.             return;  
146.         }  
147.         int tempY = (int) ev.getY();  
148.         int space = tempY - startY;  
149.         int topPadding = space - headerHeight;  
150.         switch (state) {  
151.         case NONE:  
152.             if (space > 0) {     
153.                 state = PULL;  //正在下拉  
154.                 refreshViewByState();  
155.             }  
156.             break;  
157.         case PULL:  
158.             topPadding(topPadding);  
159.             //如果大于一定高度，并且滚动状态是正在滚动时，就到了松开可以刷新的状态  
160.             if (space > headerHeight + 30  
161.                     && scrollState == SCROLL_STATE_TOUCH_SCROLL) {  
162.                 state = RELEASE;  
163.                 refreshViewByState();  
164.             }  
165.             break;  
166.         case RELEASE:  
167.             topPadding(topPadding);  
168.             //在提示松开刷新时，如果你往上拖，距离小于一定高度时，提示下拉可以刷新  
169.             if (space < headerHeight + 30) {    
170.                 state = PULL;  
171.                 refreshViewByState();  
172.             }   
173.             break;  
174.         }  
175.     }  
176.   
177.     /** 
178.      * 根据当前状态，改变界面显示； 
179.      */  
180.     private void refreshViewByState() {  
181.         //如果要提高性能，这些应该在oncreate中写，但是。。那里面参数太多了，为了大家读代码更舒服，就写在这里了。  
182.         TextView tip = (TextView) header.findViewById(R.id.tip);  
183.         ImageView arrow = (ImageView) header.findViewById(R.id.arrow);  
184.         ProgressBar progress = (ProgressBar) header.findViewById(R.id.progress);  
185.         RotateAnimation anim = new RotateAnimation(0, 180,  
186.                 RotateAnimation.RELATIVE_TO_SELF, 0.5f,  
187.                 RotateAnimation.RELATIVE_TO_SELF, 0.5f);  
188.         anim.setDuration(500);  
189.         anim.setFillAfter(true);  
190.         RotateAnimation anim1 = new RotateAnimation(180, 0,  
191.                 RotateAnimation.RELATIVE_TO_SELF, 0.5f,  
192.                 RotateAnimation.RELATIVE_TO_SELF, 0.5f);  
193.         anim1.setDuration(500);  
194.         anim1.setFillAfter(true);  
195.         switch (state) {  
196.         case NONE:     //正常状态不显示  
197.             arrow.clearAnimation();  
198.             topPadding(-headerHeight);  
199.             break;  
200.   
201.         case PULL:     //下拉状态显示箭头，隐藏进度条，以下的状态也类似。自己根据实际情况去修改。  
202.             arrow.setVisibility(View.VISIBLE);  
203.             progress.setVisibility(View.GONE);  
204.             tip.setText("下拉可以刷新！");  
205.             arrow.clearAnimation();  
206.             arrow.setAnimation(anim1);  
207.             break;  
208.         case RELEASE:    
209.             arrow.setVisibility(View.VISIBLE);  
210.             progress.setVisibility(View.GONE);  
211.             tip.setText("松开可以刷新！");  
212.             arrow.clearAnimation();  
213.             arrow.setAnimation(anim);  
214.             break;  
215.         case REFRESHING:  
216.             topPadding(50);  
217.             arrow.setVisibility(View.GONE);  
218.             progress.setVisibility(View.VISIBLE);  
219.             tip.setText("正在刷新...");  
220.             arrow.clearAnimation();  
221.             break;  
222.         }  
223.     }  
224.   
225.     /** 
226.      * 获取完数据之后 
227.      */  
228.     public void refreshComplete() {  
229.         state = NONE;  
230.         isRemark = false;  
231.         refreshViewByState();  
232.         TextView lastupdatetime = (TextView) header  
233.                 .findViewById(R.id.lastupdate_time);  
234.         SimpleDateFormat format = new SimpleDateFormat("yyyy年MM月dd日 hh:mm:ss");  
235.         Date date = new Date(System.currentTimeMillis());  
236.         String time = format.format(date);  
237.         lastupdatetime.setText(time);  
238.     }  
239.       
240.     public void setInterface(IRefreshListener iRefreshListener){  
241.         this.iRefreshListener = iRefreshListener;  
242.     }  
243.       
244.     /** 
245.      * 刷新数据接口 
246.      * @author Administrator 
247.      */  
248.     public interface IRefreshListener{  
249.         public void onRefresh();  
250.     }  
251. }  

MainActivity: （添加了接口回调，即在listview中调用main的添加数据的方法）

[java] view plain copy

1. public class MainActivity extends Activity  implements IRefreshListener {  
2.     private RefreshListView listView;  
3.     private SimpleAdapter simple_adapter;  
4.     private List<Map<String, Object>> list;  
5.   
6.     @Override  
7.     protected void onCreate(Bundle savedInstanceState) {  
8.         super.onCreate(savedInstanceState);  
9.         setContentView(R.layout.activity_main);  
10.         listView = (RefreshListView) findViewById(R.id.listview);  
11.         iniData();   //初始化数据，我们给它加20条Item  
12.         // 设置SimpleAdapter监听器  
13.         /** 
14.          * SimpleAdapter的五个参数的含义： 
15.          * 第一个：context上下文 
16.          * 第二个：用于显示的数据，map的list 
17.          * 第三个：Item的布局，即我们自定义的那个文件 
18.          * 第四个：与第二个参数紧密联系，与第五个紧密联系，是在map中的键值 
19.          * 第五个：我们看到是id（int类型）的数组，这个数组里的东西是哪里来的？是我们自己在布局文件中定义的，忘记的读者可以回过头去看一下 
20.          * 这几个参数独立开来可能不知道是干吗的，但是我觉得联合在一起就挺好理解了。 
21.          */  
22.         simple_adapter = new SimpleAdapter(MainActivity.this, list,  
23.                 R.layout.listview_item, new String[] { "image", "text" },  
24.                 new int[] { R.id.image, R.id.text });  
25.         //设置适配器  
26.         listView.setAdapter(simple_adapter);  
27.         //设置更新数据的接口  
28.         listView.setInterface(this);  
29.     }  
30.   
31.     // 初始化SimpleAdapter数据集  
32.     private List<Map<String, Object>> iniData() {  
33.         list = new ArrayList<Map<String, Object>>();  
34.         for (int i = 0; i < 20; i++) {  
35.             Map<String, Object> map = new HashMap<String, Object>();  
36.             //解释下这里的数据，key对应SimpleAdapter的第三个参数，必须都包含它们。值对应第五个参数，分别是图片和文字  
37.             map.put("text", i);  
38.             map.put("image", R.drawable.ic_launcher);  
39.             list.add(map);  
40.         }  
41.   
42.         return list;  
43.     }  
44.   
45.     @Override  
46.     public boolean onCreateOptionsMenu(Menu menu) {  
47.         // Inflate the menu; this adds items to the action bar if it is present.  
48.         getMenuInflater().inflate(R.menu.main, menu);  
49.         return true;  
50.     }  
51.       
52.     /** 
53.      * 接口回调，在RefreshListView中可以调用此方法进行数据添加。 
54.      */  
55.     @Override  
56.     public void onRefresh() {  
57.         // TODO 自动生成的方法存根  
58.         Handler handler = new Handler();  
59.         handler.postDelayed(new Runnable() {  
60.             @Override  
61.             public void run() {  
62.                 // TODO Auto-generated method stub  
63.                 Map<String, Object> map = new HashMap<String, Object>();  
64.                 map.put("text", "滚动添加 ");  
65.                 map.put("image", R.drawable.ic_launcher);  
66.                 list.add(0, map);  
67.                 listView.setAdapter(simple_adapter);  
68.                 simple_adapter.notifyDataSetChanged();  
69.                 listView.refreshComplete();  
70.             }  
71.         }, 2000);  
72.     }  
73.   
74. }