前几天看了github上面的例子，参照它的实现，自己又稍微改了一点，往项目里面增加了一个上拉加载更多功能。具体的实现如下：
首先要重写ListView：
2
3 import android.content.Context;
4 import android.util.AttributeSet;
5 import android.widget.AbsListView;
6 import android.widget.HeaderViewListAdapter;
7 import android.widget.ListAdapter;
8 import android.widget.ListView;
9
10 import java.util.List;
11
12 import njucm.edu.loadmore.activities.LoadingView;
13 import njucm.edu.loadmore.adapters.PagingBaseAdapter;
14
15 /**
16 * Created by Mesogene on 10/9/15.
17 */
18 public class LoadListView extends ListView {
19
20 private OnScrollListener onScrollListener = null;
21 private PageEnableListener pageEnableListener = null;
22 LoadingView loadListView = null;
23 private boolean isLoading;
24 private boolean hasMoreItem;
25 private int lastVisibleItem; //最后一个可见的项
26 private int totalItemCount; //总的项数
27
28
29 public LoadListView(Context context) {
30 super(context);
31 init();
32 }
33
34 public LoadListView(Context context, AttributeSet attrs) {
35 super(context, attrs);
36 init();
37 }
38
39 public LoadListView(Context context, AttributeSet attrs, int defStyleAttr) {
40 super(context, attrs, defStyleAttr);
41 init();
42 }
43
44 public void setPageEnableListener(PageEnableListener pageEnableListener) {
45 this.pageEnableListener = pageEnableListener;
46 }
47
48 public boolean isLoading() {
49 return isLoading;
50 }
51
52 public void setIsLoading(boolean isLoading) {
53 this.isLoading = isLoading;
54 }
55
56 public boolean isHasMoreItem() {
57 return hasMoreItem;
58 }
59
60 public void setHasMoreItem(boolean hasMoreItem) {
61 this.hasMoreItem = hasMoreItem;
62 if(!this.hasMoreItem){ //如果没有更多项，移除底部
63 removeFooterView(loadListView);
64 }
65 else if(findViewById(R.id.loading_view) == null){
66 addFooterView(loadListView);
67 ListAdapter adapter = ((HeaderViewListAdapter) getAdapter()).getWrappedAdapter();
68 setAdapter(adapter);
69 }
70 }
71
72 /**
73 * 在下载任务完成之后去调用这个方法
74 * @param hasMoreItem 是否还有更多项
75 * @param newItems 新的项
76 */
77 public void onFinsihLoading(boolean hasMoreItem, List<? extends Object> newItems){
78 setHasMoreItem(hasMoreItem);
79 setIsLoading(false); //下载任务完成后，把loading设置成false
80 if(newItems != null && newItems.size() >0){
81 ListAdapter adapter = ((HeaderViewListAdapter)getAdapter()).getWrappedAdapter(); //获取这个listview的adapter
82 if(adapter instanceof PagingBaseAdapter){
83 ((PagingBaseAdapter) adapter).addMoreItems(newItems); //添加项目，包含notify方法
84 }
85 }
86 }
87 /**
88 * 初始化listview的操作
89 */
90 private void init(){
91 isLoading = false;
92 loadListView = new LoadingView(getContext());
93 addFooterView(loadListView);
94 super.setOnScrollListener(new OnScrollListener() {
95 @Override
96 public void onScrollStateChanged(AbsListView absListView, int scrollState) {
97 if(onScrollListener != null){
98 onScrollListener.onScrollStateChanged(absListView, scrollState);
99 }
100 /**
101 * 当你的listview移动到底部的时候，即你看到的最后一项等于总的项数，已经停止滚动 没有正在加载并且还有更多项
102 * 的时候会被执行
103 */
104 if(lastVisibleItem == totalItemCount && scrollState == SCROLL_STATE_IDLE && !isLoading && hasMoreItem){
105 if(pageEnableListener != null){
106 isLoading = true; //执行之后的状态就是loading
107 pageEnableListener.onLoadMoreItems(); //调用回调方法
108 }
109 }
110 }
111
112 @Override
113 public void onScroll(AbsListView absListView, int firstVisibleItem, int visibleItemCount, int totleItem) {
114 //Dispatch to child OnScrollListener
115 if (onScrollListener != null) {
116 onScrollListener.onScroll(absListView, firstVisibleItem, visibleItemCount, totleItem);
117 }
118 lastVisibleItem = firstVisibleItem + visibleItemCount; //最后看到的一项
119 totalItemCount = totleItem; //总的项数
120 }
121 });
122
123 }
124
125 @Override
126 public void setOnScrollListener(OnScrollListener onScrollListener) {
127 this.onScrollListener = onScrollListener;
128 }
129
130 public interface PageEnableListener{
131 public void onLoadMoreItems();
132 }
133
134 }我们可以看到还要加一个loadingview的，就是你的正在加载界面，这个界面会被动态添加到你的footview里面的：
1 package njucm.edu.loadmore.activities;
2
3 import android.content.Context;
4 import android.util.AttributeSet;
5 import android.widget.LinearLayout;
6
7 import njucm.edu.loadmore.R;
8
9 /**
10 * Created by Mesogene on 10/10/15.
11 */
12 public class LoadingView extends LinearLayout {
13
14 public LoadingView(Context context) {
15 super(context);
16 init();
17 }
18
19 public LoadingView(Context context, AttributeSet attrs) {
20 super(context, attrs);
21 init();
22 }
23
24 public LoadingView(Context context, AttributeSet attrs, int defStyleAttr) {
25 super(context, attrs, defStyleAttr);
26 init();
27 }
28
29 public void init(){
30 inflate(getContext(), R.layout.loadinflinear, this);
31 }
32
33 }只是简单重写了一下LinearLayout, 下面只要写一个loading的不局文件就行了
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="horizontal" android:layout_width="match_parent"
android:layout_height="match_parent"
android:gravity="center"
android:layout_margin="@dimen/dp_10"
android:id="@+id/loading_view">
<ProgressBar
android:id="@+id/video_item_image"
style="?android:progressBarStyle"
android:layout_width="@dimen/loading_view_progress_size"
android:layout_height="@dimen/loading_view_progress_size"
android:layout_marginRight="@dimen/loading_view_margin_right"
android:indeterminate="true"/>
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@string/loading"
android:layout_gravity="center"
android:textColor="@color/material_blue_grey_800"
android:textSize="@dimen/sp_18"/>
</LinearLayout>这样基本就已经好了，那么还有一个listview的父类的适配器要自己写一下：
1 import android.widget.BaseAdapter;
2 import android.widget.ListAdapter;
3
4 import java.util.ArrayList;
5 import java.util.List;
6
7 import njucm.edu.loadmore.LoadListView;
8
9 /**
10 * Created by Mesogene on 10/12/15.
11 */
12 public abstract class PagingBaseAdapter<T> extends BaseAdapter {
13
14 protected List<T> items = null;
15
16 public PagingBaseAdapter(List<T> items) {
17 this.items = items;
18 }
19
20 public PagingBaseAdapter(){
21 this.items = new ArrayList<>();
22 }
23
24 public void addMoreItems(List<T> items){
25 this.items.addAll(items); //把新的项添加到listview里面
26 notifyDataSetChanged(); //更新布局
27 }
28
29 }这样之后，你自己的listviewAdapter就可以继承这个类，你的adapter拥有绘制每一个listitem的功能和添加下一页数据项的功能。
1 package njucm.edu.loadmore.adapters;
2
3 import android.view.LayoutInflater;
4 import android.view.View;
5 import android.view.ViewGroup;
6 import android.widget.TextView;
7
8 import java.util.List;
9
10 /**
11 * Created by Mesogene on 10/12/15.
12 */
13 public class MyListAdapter extends PagingBaseAdapter<String> {
14
15 @Override
16 public int getCount() {
17 return items.size();
18 }
19
20 @Override
21 public String getItem(int position) {
22 return items.get(position);
23 }
24
25 @Override
26 public long getItemId(int position) {
27 return position;
28 }
29
30 @Override
31 public View getView(int position, View view, ViewGroup viewGroup) {
32 TextView textView;
33 String text = getItem(position);
34 if(view != null){
35 textView = (TextView) view;
36 }else {
37 textView = (TextView) LayoutInflater.from(viewGroup.getContext()).inflate(android.R.layout.simple_list_item_1, null);
38 }
39 textView.setText(text);
40 return textView;
41 }
42 }最后就是如何使用了，再onCreate() 或者 onCreateView() 添加如下代码，我们发现它有一个异步加载的过程，使用到了线程
1 li.setAdapter(adapter);
2 li.setHasMoreItem(true);
3 li.setPageEnableListener(new LoadListView.PageEnableListener() {
4 @Override
5 public void onLoadMoreItems() {
6 if(pager < 3){
7 new CountryAsyncTask().execute();
8 }else{
9 li.onFinsihLoading(false, null);
10 }
11 }
12 });1 private class CountryAsyncTask extends SafeAsyncTask<List<String>>{
2 @Override
3 public List<String> call() throws Exception { //模拟后台下载数据
4 List result = null;
5 switch (pager){
6 case 0:
7 result = firstList;
8 break;
9 case 1:
10 result = secondList;
11 break;
12 case 2:
13 result = thirdList;
14 break;
15 }
16 Thread.sleep(3000);
17 return result;
18 }
19
20 @Override
21 protected void onSuccess(List<String> strings) throws Exception {
22 super.onSuccess(strings);
23 pager++;
24 li.onFinsihLoading(true, strings); //下载成功之后调用的方法，更新UI
25 }
26 }这里面可能要自己添加一些数据在firstlist等里面。 还有下面是这个类似于AsyncTask但又不是的，这个类的代码如下
1 package njucm.edu.loadmore.activities;
2
3 import android.os.Handler;
4 import android.os.Looper;
5 import android.util.Log;
6
7 import java.io.InterruptedIOException;
8 import java.util.ArrayList;
9 import java.util.Arrays;
10 import java.util.concurrent.Callable;
11 import java.util.concurrent.CountDownLatch;
12 import java.util.concurrent.Executor;
13 import java.util.concurrent.Executors;
14 import java.util.concurrent.FutureTask;
15
16
17 /**
18 * A class similar but unrelated to android's {@link android.os.AsyncTask}.
19 * <p/>
20 * Unlike AsyncTask, this class properly propagates exceptions.
21 * <p/>
22 * If you're familiar with AsyncTask and are looking for {@link android.os.AsyncTask#doInBackground(Object[])},
23 * we've named it {@link #call()} here to conform with java 1.5's {@link java.util.concurrent.Callable} interface.
24 * <p/>
25 * Current limitations: does not yet handle progress, although it shouldn't be
26 * hard to add.
27 * <p/>
28 * If using your own executor, you must call future() to get a runnable you can execute.
29 *
30 * @param <ResultT>
31 */
32 public abstract class SafeAsyncTask<ResultT> implements Callable<ResultT> { //Callable可以返回任意类型。1.5 以后加入
33 public static final int DEFAULT_POOL_SIZE = 25; //默认的线程池的大小是25
34 protected static final Executor DEFAULT_EXECUTOR = Executors.newFixedThreadPool(DEFAULT_POOL_SIZE); //利用线程池
35
36 protected Handler handler;
37 protected Executor executor;
38 protected StackTraceElement[] launchLocation;
39 protected FutureTask<Void> future;
40
41
42 /**
43 * Sets executor to Executors.newFixedThreadPool(DEFAULT_POOL_SIZE) and
44 * Handler to new Handler()
45 */
46 public SafeAsyncTask() {
47 this.executor = DEFAULT_EXECUTOR;
48 }
49
50 /**
51 * Sets executor to Executors.newFixedThreadPool(DEFAULT_POOL_SIZE)
52 */
53 public SafeAsyncTask(Handler handler) {
54 this.handler = handler;
55 this.executor = DEFAULT_EXECUTOR; //线程池用默认的设置
56 }
57
58 /**
59 * Sets Handler to new Handler()
60 */
61 public SafeAsyncTask(Executor executor) {
62 this.executor = executor;
63 }
64
65 public SafeAsyncTask(Handler handler, Executor executor) {
66 this.handler = handler;
67 this.executor = executor;
68 }
69
70
71 public FutureTask<Void> future() {
72 future = new FutureTask<Void>(newTask());
73 return future;
74 }
75
76 public SafeAsyncTask<ResultT> executor(Executor executor) {
77 this.executor = executor;
78 return this;
79 }
80
81 public Executor executor() {
82 return executor;
83 }
84
85 public SafeAsyncTask<ResultT> handler(Handler handler) {
86 this.handler = handler;
87 return this;
88 }
89
90 public Handler handler() {
91 return handler;
92 }
93
94 public void execute() {
95 execute(Thread.currentThread().getStackTrace());
96 }
97
98 protected void execute(StackTraceElement[] launchLocation) {
99 this.launchLocation = launchLocation;
100 executor.execute(future());
101 }
102
103 public boolean cancel(boolean mayInterruptIfRunning) {
104 if (future == null) throw new UnsupportedOperationException("You cannot cancel this task before calling future()");
105
106 return future.cancel(mayInterruptIfRunning);
107 }
108
109
110 /**
111 * @throws Exception, captured on passed to onException() if present.
112 */
113 protected void onPreExecute() throws Exception {
114 }
115
116 /**
117 * @param t the result of {@link #call()}
118 * @throws Exception, captured on passed to onException() if present.
119 */
120 @SuppressWarnings({"UnusedDeclaration"})
121 protected void onSuccess(ResultT t) throws Exception {
122 }
123
124 /**
125 * Called when the thread has been interrupted, likely because
126 * the task was canceled.
127 * <p/>
128 * By default, calls {@link #onException(Exception)}, but this method
129 * may be overridden to handle interruptions differently than other
130 * exceptions.
131 *
132 * @param e an InterruptedException or InterruptedIOException
133 */
134 protected void onInterrupted(Exception e) {
135 onException(e);
136 }
137
138 /**
139 * Logs the exception as an Error by default, but this method may
140 * be overridden by subclasses.
141 *
142 * @param e the exception thrown from {@link #onPreExecute()}, {@link #call()}, or {@link #onSuccess(Object)}
143 * @throws RuntimeException, ignored
144 */
145 protected void onException(Exception e) throws RuntimeException {
146 onThrowable(e);
147 }
148
149 protected void onThrowable(Throwable t) throws RuntimeException {
150 Log.e("roboguice", "Throwable caught during background processing", t);
151 }
152
153 /**
154 * @throws RuntimeException, ignored
155 */
156 protected void onFinally() throws RuntimeException {
157 }
158
159
160 protected Task<ResultT> newTask() {
161 return new Task<ResultT>(this);
162 }
163
164
165 public static class Task<ResultT> implements Callable<Void> {
166 protected SafeAsyncTask<ResultT> parent;
167 protected Handler handler;
168
169 public Task(SafeAsyncTask<ResultT> parent) {
170 this.parent = parent;
171 this.handler = parent.handler != null ? parent.handler : new Handler(Looper.getMainLooper());
172 }
173
174 public Void call() throws Exception {
175 try {
176 doPreExecute();
177 doSuccess(doCall());
178
179 } catch (final Exception e) {
180 try {
181 doException(e);
182 } catch (Exception f) {
183 // logged but ignored
184 Log.e("BACKGROUND_TASK", "Exception in", f);
185 }
186
187 } catch (final Throwable t) {
188 try {
189 doThrowable(t);
190 } catch (Exception f) {
191 // logged but ignored
192 Log.e("BACKGROUND_TASK", "Exception in", f);
193 }
194 } finally {
195 doFinally();
196 }
197
198 return null;
199 }
200
201 protected void doPreExecute() throws Exception {
202 postToUiThreadAndWait(new Callable<Object>() {
203 public Object call() throws Exception {
204 parent.onPreExecute();
205 return null;
206 }
207 });
208 }
209
210 protected ResultT doCall() throws Exception {
211 return parent.call();
212 }
213
214 protected void doSuccess(final ResultT r) throws Exception {
215 postToUiThreadAndWait(new Callable<Object>() {
216 public Object call() throws Exception {
217 parent.onSuccess(r);
218 return null;
219 }
220 });
221 }
222
223 protected void doException(final Exception e) throws Exception {
224 if (parent.launchLocation != null) {
225 final ArrayList<StackTraceElement> stack = new ArrayList<StackTraceElement>(Arrays.asList(e.getStackTrace()));
226 stack.addAll(Arrays.asList(parent.launchLocation));
227 e.setStackTrace(stack.toArray(new StackTraceElement[stack.size()]));
228 }
229 postToUiThreadAndWait(new Callable<Object>() {
230 public Object call() throws Exception {
231 if (e instanceof InterruptedException || e instanceof InterruptedIOException) parent.onInterrupted(e);
232 else parent.onException(e);
233 return null;
234 }
235 });
236 }
237
238 protected void doThrowable(final Throwable e) throws Exception {
239 if (parent.launchLocation != null) {
240 final ArrayList<StackTraceElement> stack = new ArrayList<StackTraceElement>(Arrays.asList(e.getStackTrace()));
241 stack.addAll(Arrays.asList(parent.launchLocation));
242 e.setStackTrace(stack.toArray(new StackTraceElement[stack.size()]));
243 }
244 postToUiThreadAndWait(new Callable<Object>() {
245 public Object call() throws Exception {
246 parent.onThrowable(e);
247 return null;
248 }
249 });
250 }
251
252 protected void doFinally() throws Exception {
253 postToUiThreadAndWait(new Callable<Object>() {
254 public Object call() throws Exception {
255 parent.onFinally();
256 return null;
257 }
258 });
259 }
260
261
262 /**
263 * Posts the specified runnable to the UI thread using a handler,
264 * and waits for operation to finish. If there's an exception,
265 * it captures it and rethrows it.
266 *
267 * @param c the callable to post
268 * @throws Exception on error
269 */
270 protected void postToUiThreadAndWait(final Callable c) throws Exception {
271 final CountDownLatch latch = new CountDownLatch(1);
272 final Exception[] exceptions = new Exception[1];
273
274 // Execute onSuccess in the UI thread, but wait
275 // for it to complete.
276 // If it throws an exception, capture that exception
277 // and rethrow it later.
278 handler.post(new Runnable() {
279 public void run() {
280 try {
281 c.call();
282 } catch (Exception e) {
283 exceptions[0] = e;
284 } finally {
285 latch.countDown();
286 }
287 }
288 });
289
290 // Wait for onSuccess to finish
291 latch.await();
292
293 if (exceptions[0] != null) throw exceptions[0];
294
295 }
296
297 }
298
299 }好了，最简单的上拉加载就是这个样子了。我已经把它集成进了自己的项目里面。
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
