前几天看了github上面的例子，参照它的实现，自己又稍微改了一点，往项目里面增加了一个上拉加载更多功能。具体的实现如下：
首先要重写ListView：
import android.content.Context;
import android.util.AttributeSet;
import android.widget.AbsListView;
import android.widget.HeaderViewListAdapter;
import android.widget.ListAdapter;
import android.widget.ListView; import java.util.List; import njucm.edu.loadmore.activities.LoadingView;
import njucm.edu.loadmore.adapters.PagingBaseAdapter; /**
* Created by Mesogene on 10/9/15.
*/
public class LoadListView extends ListView { private OnScrollListener onScrollListener = null;
private PageEnableListener pageEnableListener = null;
LoadingView loadListView = null;
private boolean isLoading;
private boolean hasMoreItem;
private int lastVisibleItem; //最后一个可见的项
private int totalItemCount; //总的项数 public LoadListView(Context context) {
super(context);
init();
} public LoadListView(Context context, AttributeSet attrs) {
super(context, attrs);
init();
} public LoadListView(Context context, AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);
init();
} public void setPageEnableListener(PageEnableListener pageEnableListener) {
this.pageEnableListener = pageEnableListener;
} public boolean isLoading() {
return isLoading;
} public void setIsLoading(boolean isLoading) {
this.isLoading = isLoading;
} public boolean isHasMoreItem() {
return hasMoreItem;
} public void setHasMoreItem(boolean hasMoreItem) {
this.hasMoreItem = hasMoreItem;
if(!this.hasMoreItem){ //如果没有更多项，移除底部
removeFooterView(loadListView);
}
else if(findViewById(R.id.loading_view) == null){
addFooterView(loadListView);
ListAdapter adapter = ((HeaderViewListAdapter) getAdapter()).getWrappedAdapter();
setAdapter(adapter);
}
} /**
* 在下载任务完成之后去调用这个方法
* @param hasMoreItem 是否还有更多项
* @param newItems 新的项
*/
public void onFinsihLoading(boolean hasMoreItem, List<? extends Object> newItems){
setHasMoreItem(hasMoreItem);
setIsLoading(false); //下载任务完成后，把loading设置成false
if(newItems != null && newItems.size() >0){
ListAdapter adapter = ((HeaderViewListAdapter)getAdapter()).getWrappedAdapter(); //获取这个listview的adapter
if(adapter instanceof PagingBaseAdapter){
((PagingBaseAdapter) adapter).addMoreItems(newItems); //添加项目，包含notify方法
}
}
}
/**
* 初始化listview的操作
*/
private void init(){
isLoading = false;
loadListView = new LoadingView(getContext());
addFooterView(loadListView);
super.setOnScrollListener(new OnScrollListener() {
@Override
public void onScrollStateChanged(AbsListView absListView, int scrollState) {
if(onScrollListener != null){
onScrollListener.onScrollStateChanged(absListView, scrollState);
}
/**
* 当你的listview移动到底部的时候，即你看到的最后一项等于总的项数，已经停止滚动 没有正在加载并且还有更多项
* 的时候会被执行
*/
if(lastVisibleItem == totalItemCount && scrollState == SCROLL_STATE_IDLE && !isLoading && hasMoreItem){
if(pageEnableListener != null){
isLoading = true; //执行之后的状态就是loading
pageEnableListener.onLoadMoreItems(); //调用回调方法
}
}
} @Override
public void onScroll(AbsListView absListView, int firstVisibleItem, int visibleItemCount, int totleItem) {
//Dispatch to child OnScrollListener
if (onScrollListener != null) {
onScrollListener.onScroll(absListView, firstVisibleItem, visibleItemCount, totleItem);
}
lastVisibleItem = firstVisibleItem + visibleItemCount; //最后看到的一项
totalItemCount = totleItem; //总的项数
}
}); } @Override
public void setOnScrollListener(OnScrollListener onScrollListener) {
this.onScrollListener = onScrollListener;
} public interface PageEnableListener{
public void onLoadMoreItems();
} }
我们可以看到还要加一个loadingview的，就是你的正在加载界面，这个界面会被动态添加到你的footview里面的：
package njucm.edu.loadmore.activities; import android.content.Context;
import android.util.AttributeSet;
import android.widget.LinearLayout; import njucm.edu.loadmore.R; /**
* Created by Mesogene on 10/10/15.
*/
public class LoadingView extends LinearLayout { public LoadingView(Context context) {
super(context);
init();
} public LoadingView(Context context, AttributeSet attrs) {
super(context, attrs);
init();
} public LoadingView(Context context, AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);
init();
} public void init(){
inflate(getContext(), R.layout.loadinflinear, this);
} }
只是简单重写了一下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的父类的适配器要自己写一下：
import android.widget.BaseAdapter;
import android.widget.ListAdapter; import java.util.ArrayList;
import java.util.List; import njucm.edu.loadmore.LoadListView; /**
* Created by Mesogene on 10/12/15.
*/
public abstract class PagingBaseAdapter<T> extends BaseAdapter { protected List<T> items = null; public PagingBaseAdapter(List<T> items) {
this.items = items;
} public PagingBaseAdapter(){
this.items = new ArrayList<>();
} public void addMoreItems(List<T> items){
this.items.addAll(items); //把新的项添加到listview里面
notifyDataSetChanged(); //更新布局
} }
这样之后，你自己的listviewAdapter就可以继承这个类，你的adapter拥有绘制每一个listitem的功能和添加下一页数据项的功能。
package njucm.edu.loadmore.adapters; import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.TextView; import java.util.List; /**
* Created by Mesogene on 10/12/15.
*/
public class MyListAdapter extends PagingBaseAdapter<String> { @Override
public int getCount() {
return items.size();
} @Override
public String getItem(int position) {
return items.get(position);
} @Override
public long getItemId(int position) {
return position;
} @Override
public View getView(int position, View view, ViewGroup viewGroup) {
TextView textView;
String text = getItem(position);
if(view != null){
textView = (TextView) view;
}else {
textView = (TextView) LayoutInflater.from(viewGroup.getContext()).inflate(android.R.layout.simple_list_item_1, null);
}
textView.setText(text);
return textView;
}
}
最后就是如何使用了，再onCreate() 或者 onCreateView() 添加如下代码，我们发现它有一个异步加载的过程，使用到了线程
li.setAdapter(adapter);
li.setHasMoreItem(true);
li.setPageEnableListener(new LoadListView.PageEnableListener() {
@Override
public void onLoadMoreItems() {
if(pager < 3){
new CountryAsyncTask().execute();
}else{
li.onFinsihLoading(false, null);
}
}
});
private class CountryAsyncTask extends SafeAsyncTask<List<String>>{
@Override
public List<String> call() throws Exception { //模拟后台下载数据
List result = null;
switch (pager){
case 0:
result = firstList;
break;
case 1:
result = secondList;
break;
case 2:
result = thirdList;
break;
}
Thread.sleep(3000);
return result;
}
@Override
protected void onSuccess(List<String> strings) throws Exception {
super.onSuccess(strings);
pager++;
li.onFinsihLoading(true, strings); //下载成功之后调用的方法，更新UI
}
}
这里面可能要自己添加一些数据在firstlist等里面。 还有下面是这个类似于AsyncTask但又不是的，这个类的代码如下
package njucm.edu.loadmore.activities; import android.os.Handler;
import android.os.Looper;
import android.util.Log; import java.io.InterruptedIOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.concurrent.Callable;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.Executor;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask; /**
* A class similar but unrelated to android's {@link android.os.AsyncTask}.
* <p/>
* Unlike AsyncTask, this class properly propagates exceptions.
* <p/>
* If you're familiar with AsyncTask and are looking for {@link android.os.AsyncTask#doInBackground(Object[])},
* we've named it {@link #call()} here to conform with java 1.5's {@link java.util.concurrent.Callable} interface.
* <p/>
* Current limitations: does not yet handle progress, although it shouldn't be
* hard to add.
* <p/>
* If using your own executor, you must call future() to get a runnable you can execute.
*
* @param <ResultT>
*/
public abstract class SafeAsyncTask<ResultT> implements Callable<ResultT> { //Callable可以返回任意类型。1.5 以后加入
public static final int DEFAULT_POOL_SIZE = 25; //默认的线程池的大小是25
protected static final Executor DEFAULT_EXECUTOR = Executors.newFixedThreadPool(DEFAULT_POOL_SIZE); //利用线程池 protected Handler handler;
protected Executor executor;
protected StackTraceElement[] launchLocation;
protected FutureTask<Void> future; /**
* Sets executor to Executors.newFixedThreadPool(DEFAULT_POOL_SIZE) and
* Handler to new Handler()
*/
public SafeAsyncTask() {
this.executor = DEFAULT_EXECUTOR;
} /**
* Sets executor to Executors.newFixedThreadPool(DEFAULT_POOL_SIZE)
*/
public SafeAsyncTask(Handler handler) {
this.handler = handler;
this.executor = DEFAULT_EXECUTOR; //线程池用默认的设置
} /**
* Sets Handler to new Handler()
*/
public SafeAsyncTask(Executor executor) {
this.executor = executor;
} public SafeAsyncTask(Handler handler, Executor executor) {
this.handler = handler;
this.executor = executor;
} public FutureTask<Void> future() {
future = new FutureTask<Void>(newTask());
return future;
} public SafeAsyncTask<ResultT> executor(Executor executor) {
this.executor = executor;
return this;
} public Executor executor() {
return executor;
} public SafeAsyncTask<ResultT> handler(Handler handler) {
this.handler = handler;
return this;
} public Handler handler() {
return handler;
} public void execute() {
execute(Thread.currentThread().getStackTrace());
} protected void execute(StackTraceElement[] launchLocation) {
this.launchLocation = launchLocation;
executor.execute(future());
} public boolean cancel(boolean mayInterruptIfRunning) {
if (future == null) throw new UnsupportedOperationException("You cannot cancel this task before calling future()"); return future.cancel(mayInterruptIfRunning);
} /**
* @throws Exception, captured on passed to onException() if present.
*/
protected void onPreExecute() throws Exception {
} /**
* @param t the result of {@link #call()}
* @throws Exception, captured on passed to onException() if present.
*/
@SuppressWarnings({"UnusedDeclaration"})
protected void onSuccess(ResultT t) throws Exception {
} /**
* Called when the thread has been interrupted, likely because
* the task was canceled.
* <p/>
* By default, calls {@link #onException(Exception)}, but this method
* may be overridden to handle interruptions differently than other
* exceptions.
*
* @param e an InterruptedException or InterruptedIOException
*/
protected void onInterrupted(Exception e) {
onException(e);
} /**
* Logs the exception as an Error by default, but this method may
* be overridden by subclasses.
*
* @param e the exception thrown from {@link #onPreExecute()}, {@link #call()}, or {@link #onSuccess(Object)}
* @throws RuntimeException, ignored
*/
protected void onException(Exception e) throws RuntimeException {
onThrowable(e);
} protected void onThrowable(Throwable t) throws RuntimeException {
Log.e("roboguice", "Throwable caught during background processing", t);
} /**
* @throws RuntimeException, ignored
*/
protected void onFinally() throws RuntimeException {
} protected Task<ResultT> newTask() {
return new Task<ResultT>(this);
} public static class Task<ResultT> implements Callable<Void> {
protected SafeAsyncTask<ResultT> parent;
protected Handler handler; public Task(SafeAsyncTask<ResultT> parent) {
this.parent = parent;
this.handler = parent.handler != null ? parent.handler : new Handler(Looper.getMainLooper());
} public Void call() throws Exception {
try {
doPreExecute();
doSuccess(doCall()); } catch (final Exception e) {
try {
doException(e);
} catch (Exception f) {
// logged but ignored
Log.e("BACKGROUND_TASK", "Exception in", f);
} } catch (final Throwable t) {
try {
doThrowable(t);
} catch (Exception f) {
// logged but ignored
Log.e("BACKGROUND_TASK", "Exception in", f);
}
} finally {
doFinally();
} return null;
} protected void doPreExecute() throws Exception {
postToUiThreadAndWait(new Callable<Object>() {
public Object call() throws Exception {
parent.onPreExecute();
return null;
}
});
} protected ResultT doCall() throws Exception {
return parent.call();
} protected void doSuccess(final ResultT r) throws Exception {
postToUiThreadAndWait(new Callable<Object>() {
public Object call() throws Exception {
parent.onSuccess(r);
return null;
}
});
} protected void doException(final Exception e) throws Exception {
if (parent.launchLocation != null) {
final ArrayList<StackTraceElement> stack = new ArrayList<StackTraceElement>(Arrays.asList(e.getStackTrace()));
stack.addAll(Arrays.asList(parent.launchLocation));
e.setStackTrace(stack.toArray(new StackTraceElement[stack.size()]));
}
postToUiThreadAndWait(new Callable<Object>() {
public Object call() throws Exception {
if (e instanceof InterruptedException || e instanceof InterruptedIOException) parent.onInterrupted(e);
else parent.onException(e);
return null;
}
});
} protected void doThrowable(final Throwable e) throws Exception {
if (parent.launchLocation != null) {
final ArrayList<StackTraceElement> stack = new ArrayList<StackTraceElement>(Arrays.asList(e.getStackTrace()));
stack.addAll(Arrays.asList(parent.launchLocation));
e.setStackTrace(stack.toArray(new StackTraceElement[stack.size()]));
}
postToUiThreadAndWait(new Callable<Object>() {
public Object call() throws Exception {
parent.onThrowable(e);
return null;
}
});
} protected void doFinally() throws Exception {
postToUiThreadAndWait(new Callable<Object>() {
public Object call() throws Exception {
parent.onFinally();
return null;
}
});
} /**
* Posts the specified runnable to the UI thread using a handler,
* and waits for operation to finish. If there's an exception,
* it captures it and rethrows it.
*
* @param c the callable to post
* @throws Exception on error
*/
protected void postToUiThreadAndWait(final Callable c) throws Exception {
final CountDownLatch latch = new CountDownLatch(1);
final Exception[] exceptions = new Exception[1]; // Execute onSuccess in the UI thread, but wait
// for it to complete.
// If it throws an exception, capture that exception
// and rethrow it later.
handler.post(new Runnable() {
public void run() {
try {
c.call();
} catch (Exception e) {
exceptions[0] = e;
} finally {
latch.countDown();
}
}
}); // Wait for onSuccess to finish
latch.await(); if (exceptions[0] != null) throw exceptions[0]; } } }
好了，最简单的上拉加载就是这个样子了。我已经把它集成进了自己的项目里面。