Android 上拉加载更多功能

前几天看了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];

         }

     }

 }

好了，最简单的上拉加载就是这个样子了。我已经把它集成进了自己的项目里面。