android下拉刷新功能---教你实现简单的ListView下拉刷新

古城微笑少年丶 2022-08-18 11:35 317阅读 0赞 
  1.    android中数据的更新需要用户很方便就能操作，其中下拉刷新就是很好的一种用户体验方式，这是郭林大神在网上的一个下拉刷新的demo，我做了一点小小的修改，然后加了一些注释，记录在博客中，以后开发中需要的时候，直接拿过来用。

效果图：

Center

页面布局

1、layout文件下有两个xml文件：

activity_main.xml中代码： 

  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.     android:paddingBottom="@dimen/activity_vertical_margin"
  6.     android:paddingLeft="@dimen/activity_horizontal_margin"
  7.     android:paddingRight="@dimen/activity_horizontal_margin"
  8.     android:paddingTop="@dimen/activity_vertical_margin"
  9.     tools:context=".MainActivity" >
  11.     <!-- 在项目中引入下拉刷新 -->
  13.     <com.demo.pullrefreshlistviewdemo.RefreshableView
  14.         android:id="@+id/refreshable_view"
  15.         android:layout_width="fill_parent"
  16.         android:layout_height="fill_parent" >
  18.         <ListView
  19.             android:id="@+id/list_view"
  20.             android:layout_width="fill_parent"
  21.             android:layout_height="fill_parent" >
  22.         </ListView>
  23.     </com.demo.pullrefreshlistviewdemo.RefreshableView>
  25. </RelativeLayout>

pull_refresh.xml中代码： 

  1. <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
  2.     xmlns:tools="http://schemas.android.com/tools"
  3.     android:id="@+id/pull_to_refresh_head"
  4.     android:layout_width="fill_parent"
  5.     android:layout_height="60dip" >
  7.     <LinearLayout
  8.         android:layout_width="200dip"
  9.         android:layout_height="60dip"
  10.         android:layout_centerInParent="true"
  11.         android:orientation="horizontal" >
  13.         <RelativeLayout
  14.             android:layout_width="0dip"
  15.             android:layout_height="60dip"
  16.             android:layout_weight="3" >
  18.             <ImageView
  19.                 android:id="@+id/arrow"
  20.                 android:layout_width="wrap_content"
  21.                 android:layout_height="wrap_content"
  22.                 android:layout_centerInParent="true"
  23.                 android:src="@drawable/arrow" />
  25.             <ProgressBar
  26.                 android:id="@+id/progress_bar"
  27.                 android:layout_width="30dip"
  28.                 android:layout_height="30dip"
  29.                 android:layout_centerInParent="true"
  30.                 android:visibility="gone" />
  31.         </RelativeLayout>
  33.         <LinearLayout
  34.             android:layout_width="0dip"
  35.             android:layout_height="60dip"
  36.             android:layout_weight="12"
  37.             android:orientation="vertical" >
  39.             <TextView
  40.                 android:id="@+id/description"
  41.                 android:layout_width="fill_parent"
  42.                 android:layout_height="0dip"
  43.                 android:layout_weight="1"
  44.                 android:gravity="center_horizontal|bottom"
  45.                 android:text="@string/pull_to_refresh" />
  47.             <TextView
  48.                 android:id="@+id/updated_at"
  49.                 android:layout_width="fill_parent"
  50.                 android:layout_height="0dip"
  51.                 android:layout_weight="1"
  52.                 android:gravity="center_horizontal|top"
  53.                 android:text="@string/updated_at" />
  54.         </LinearLayout>
  55.     </LinearLayout>
  57. </RelativeLayout>

java类：

MainActivity.java中代码： 

  1. package com.demo.pullrefreshlistviewdemo;
  3. import java.util.ArrayList;
  4. import java.util.List;
  6. import android.app.Activity;
  7. import android.os.Bundle;
  8. import android.util.Log;
  9. import android.view.Window;
  10. import android.widget.ArrayAdapter;
  11. import android.widget.ListView;
  13. import com.demo.pullrefreshlistviewdemo.RefreshableView.PullToRefreshListener;
  15. /**
  16.  * 在项目中引入ListView下拉刷新功能需三步： 
  17.  * 1.在Activity的布局文件中加入自定义的RefreshableView，并让ListView包含在其中。 
  18.  * 2.在Activity中调用RefreshableView的setOnRefreshListener方法注册回调接口。
  19.  *  3.在onRefresh方法的最后，记得调用RefreshableView的finishRefreshing方法，通知刷新结束。
  20.  * 从此以后，在项目的任何地方，一分钟引入下拉刷新功能妥妥的。
  21.  */
  22. public class MainActivity extends Activity {
  23.     RefreshableView refreshableView;
  24.     ListView listView;
  25.     ArrayAdapter<String> adapter;
  26.     private static final String TAG = "MainActivity";
  27.     List list = new ArrayList();
  28.     private int count = 1;// 记录更新的次数
  30.     public List initDatas() {
  31.         for (int i = 0; i < 10; i++) {
  32.             list.add("数据" + i);
  33.         }
  34.         return list;
  35.     }
  37.     @Override
  38.     protected void onCreate(Bundle savedInstanceState) {
  39.         super.onCreate(savedInstanceState);
  40.         requestWindowFeature(Window.FEATURE_NO_TITLE);
  41.         setContentView(R.layout.activity_main);
  42.         /**
  43.          * 获得自定义刷新功能布局对象实例
  44.          */
  45.         refreshableView = (RefreshableView) findViewById(R.id.refreshable_view);
  46.         /**
  47.          * 获得ListView控件对象实例
  48.          */
  49.         listView = (ListView) findViewById(R.id.list_view);
  50.         initDatas();
  51.         /**
  52.          * 实例化适配器，将子项布局和数据放到适配器中
  53.          */
  54.         adapter = new ArrayAdapter<String>(this,
  55.                 android.R.layout.simple_list_item_1, list);
  56.         /**
  57.          * 将适配器加载到ListView列表控件中
  58.          */
  59.         listView.setAdapter(adapter);
  60.         /**
  61.          * 将adapter对象传到refreshableView中，方便更新新数据到适配器中
  62.          */
  63.         refreshableView.initAdapter(adapter);
  64.         /**
  65.          * 监听自定义刷新功能布局事件
  66.          */
  67.         refreshableView.setOnRefreshListener(new PullToRefreshListener() {
  68.             @Override
  69.             public void onRefresh() {
  70.                 try {
  71.                     Log.d("RefreshableView",
  72.                             "--进入refreshableView.setOnRefreshListener回调方法");
  73.                     Thread.sleep(3000);
  74.                 } catch (InterruptedException e) {
  75.                     e.printStackTrace();
  76.                 }
  77.                 Log.d("RefreshableView",
  78.                         "--MainActivity中执行refreshableView.finishRefreshing()方法");
  79.                 refreshableView.finishRefreshing();
  81.             }
  82.         }, 0);
  84.     }
  85. }

RefreshableView.java中代码： 

  1. /**
  2.  * @author honey 项目启动执行顺序： 1、首先执行RefreshableView构造方法
  3.  *         2、执行setOnRefreshListener(PullToRefreshListener, int)方法
  4.  *         3、执行onLayout(boolean, int, int, int, int)方法
  5.  *         4、滑动时，执行onTouch(View, MotionEvent)方法
  6.  */
  7. public class RefreshableView extends LinearLayout implements OnTouchListener {
  9.     public String TAG = "RefreshableView";
  11.     public ArrayAdapter<String> adapter;
  12.     public int count = 0;// 记录更新的数据次数
  13.     /**
  14.      * 下拉状态
  15.      */
  16.     public static final int STATUS_PULL_TO_REFRESH = 0;
  17.     /**
  18.      * 释放立即刷新状态
  19.      */
  20.     public static final int STATUS_RELEASE_TO_REFRESH = 1;
  21.     /**
  22.      * 正在刷新状态
  23.      */
  24.     public static final int STATUS_REFRESHING = 2;
  25.     /**
  26.      * 刷新完成或未刷新状态
  27.      */
  28.     public static final int STATUS_REFRESH_FINISHED = 3;
  29.     /**
  30.      * 下拉头部回滚的速度
  31.      */
  32.     public static final int SCROLL_SPEED = -20;
  33.     /**
  34.      * 一分钟的毫秒值，用于判断上次的更新时间
  35.      */
  36.     public static final long ONE_MINUTE = 60 * 1000;
  37.     /**
  38.      * 一小时的毫秒值，用于判断上次的更新时间
  39.      */
  40.     public static final long ONE_HOUR = 60 * ONE_MINUTE;
  41.     /**
  42.      * 一天的毫秒值，用于判断上次的更新时间
  43.      */
  44.     public static final long ONE_DAY = 24 * ONE_HOUR;
  45.     /**
  46.      * 一月的毫秒值，用于判断上次的更新时间
  47.      */
  48.     public static final long ONE_MONTH = 30 * ONE_DAY;
  49.     /**
  50.      * 一年的毫秒值，用于判断上次的更新时间
  51.      */
  52.     public static final long ONE_YEAR = 12 * ONE_MONTH;
  53.     /**
  54.      * 上次更新时间的字符串常量，用于作为SharedPreferences的键值
  55.      */
  56.     private static final String UPDATED_AT = "updated_at";
  57.     /**
  58.      * 下拉刷新的回调接口
  59.      */
  60.     private PullToRefreshListener mListener;
  61.     /**
  62.      * 用于存储上次更新时间
  63.      */
  64.     private SharedPreferences preferences;
  65.     /**
  66.      * 下拉头的View
  67.      */
  68.     private View header;
  69.     /**
  70.      * 需要去下拉刷新的ListView
  71.      */
  72.     private ListView listView;
  73.     /**
  74.      * 刷新时显示的进度条
  75.      */
  76.     private ProgressBar progressBar;
  77.     /**
  78.      * 指示下拉和释放的箭头
  79.      */
  80.     private ImageView arrow;
  81.     /**
  82.      * 指示下拉和释放的文字描述
  83.      */
  84.     private TextView description;
  85.     /**
  86.      * 上次更新时间的文字描述
  87.      */
  88.     private TextView updateAt;
  89.     /**
  90.      * 下拉头的布局参数
  91.      */
  92.     private MarginLayoutParams headerLayoutParams;
  93.     /**
  94.      * 上次更新时间的毫秒值
  95.      */
  96.     private long lastUpdateTime;
  97.     /**
  98.      * 为了防止不同界面的下拉刷新在上次更新时间上互相有冲突，使用id来做区分
  99.      */
  100.     private int mId = -1;
  101.     /**
  102.      * 下拉头的高度
  103.      */
  104.     private int hideHeaderHeight;
  105.     /**
  106.      * 当前处理什么状态，可选值有STATUS_PULL_TO_REFRESH, STATUS_RELEASE_TO_REFRESH,
  107.      * STATUS_REFRESHING 和 STATUS_REFRESH_FINISHED
  108.      */
  109.     private int currentStatus = STATUS_REFRESH_FINISHED;;
  110.     /**
  111.      * 记录上一次的状态是什么，避免进行重复操作
  112.      */
  113.     private int lastStatus = currentStatus;
  114.     /**
  115.      * 手指按下时的屏幕纵坐标
  116.      */
  117.     private float yDown;
  118.     /**
  119.      * 在被判定为滚动之前用户手指可以移动的最大值。
  120.      */
  121.     private int touchSlop;
  122.     /**
  123.      * 是否已加载过一次layout，这里onLayout中的初始化只需加载一次
  124.      */
  125.     private boolean loadOnce;
  126.     /**
  127.      * 当前是否可以下拉，只有ListView滚动到头的时候才允许下拉
  128.      */
  129.     private boolean ableToPull;
  131.     /**
  132.      * 下拉刷新控件的构造函数，会在运行时动态添加一个下拉头的布局。 项目启动首先进入这个构造方法
  133.      * 
  134.      * @param context
  135.      * @param attrs
  136.      */
  137.     public RefreshableView(Context context, AttributeSet attrs) {
  138.         super(context, attrs);
  139.         Log.d(TAG, "进入RefreshableView构造方法");
  140.         /**
  141.          * 获得SharedPreferences对象
  142.          */
  143.         preferences = PreferenceManager.getDefaultSharedPreferences(context);
  144.         header = LayoutInflater.from(context).inflate(R.layout.pull_refresh,
  145.                 null, true);
  146.         progressBar = (ProgressBar) header.findViewById(R.id.progress_bar);
  147.         arrow = (ImageView) header.findViewById(R.id.arrow);
  148.         description = (TextView) header.findViewById(R.id.description);
  149.         updateAt = (TextView) header.findViewById(R.id.updated_at);
  150.         /**
  151.          * getScaledTouchSlop是一个距离，表示滑动的时候，手的移动要大于这个距离才开始移动控件
  152.          */
  153.         touchSlop = ViewConfiguration.get(context).getScaledTouchSlop();
  154.         refreshUpdatedAtValue();
  155.         setOrientation(VERTICAL);
  156.         /**
  157.          * addView 动态给Activity添加View组件
  158.          */
  159.         addView(header, 0);
  160.         Log.d(TAG, "离开RefreshableView构造方法");
  161.     }
  163.     /**
  164.      * 1、onLayout()是ViewGroup类的抽象方法，子类中必须重写，作用：
  165.      * 通过调用其children的layout函数来设置子视图相对与父视图中的位置。
  166.      * 2、进行一些关键性的初始化操作，比如：将下拉头向上偏移进行隐藏，给ListView注册touch事件。
  167.      */
  168.     @Override
  169.     protected void onLayout(boolean changed, int l, int t, int r, int b) {
  170.         super.onLayout(changed, l, t, r, b);
  171.         Log.d(TAG, "进入onLayout方法");
  172.         if (changed && !loadOnce) {
  173.             Log.d(TAG, "进入onLayout方法中的if语句");
  174.             hideHeaderHeight = -header.getHeight();
  175.             headerLayoutParams = (MarginLayoutParams) header.getLayoutParams();
  176.             headerLayoutParams.topMargin = hideHeaderHeight;
  177.             /**
  178.              * getChildAt(index)是获取某个指定position的view。
  179.              * 注意：在ListView中，使用getChildAt(index)的取值，只能是当前可见区域（列表可滚动）的子项！
  180.              */
  181.             listView = (ListView) getChildAt(1);
  182.             /**
  183.              * 监听用户触摸屏事件
  184.              */
  185.             listView.setOnTouchListener(this);
  186.             loadOnce = true;
  187.             Log.d(TAG, "离开onLayout方法中的if语句");
  188.         }
  189.         Log.d(TAG, "离开onLayout方法");
  190.     }
  192.     /**
  193.      * 当ListView被触摸时调用，其中处理了各种下拉刷新的具体逻辑。
  194.      */
  195.     @Override
  196.     public boolean onTouch(View v, MotionEvent event) {
  197.         Log.d(TAG, "进入onTouch方法");
  198.         setIsAbleToPull(event);
  199.         if (ableToPull) {
  200.             switch (event.getAction()) {
  201.             case MotionEvent.ACTION_DOWN:
  202.                 yDown = event.getRawY();
  203.                 Log.d(TAG, "进入MotionEvent.ACTION_DOWN，yDown：" + yDown);
  204.                 break;
  205.             case MotionEvent.ACTION_MOVE:
  206.                 float yMove = event.getRawY();
  207.                 int distance = (int) (yMove - yDown);
  208.                 Log.d(TAG, "进入MotionEvent.ACTION_MOVE，yMove：" + yMove);
  209.                 // 如果手指是下滑状态，并且下拉头是完全隐藏的，就屏蔽下拉事件
  210.                 if (distance <= 0
  211.                         && headerLayoutParams.topMargin <= hideHeaderHeight) {
  212.                     return false;
  213.                 }
  214.                 Log.d(TAG, "touchSlop：" + touchSlop);
  215.                 if (distance < touchSlop) {
  216.                     return false;
  217.                 }
  218.                 if (currentStatus != STATUS_REFRESHING) {
  219.                     if (headerLayoutParams.topMargin > 0) {
  220.                         currentStatus = STATUS_RELEASE_TO_REFRESH;
  221.                     } else {
  222.                         currentStatus = STATUS_PULL_TO_REFRESH;
  223.                     }
  224.                     // 通过偏移下拉头的topMargin值，来实现下拉效果
  225.                     headerLayoutParams.topMargin = (distance / 2)
  226.                             + hideHeaderHeight;
  227.                     header.setLayoutParams(headerLayoutParams);
  228.                 }
  229.                 break;
  230.             case MotionEvent.ACTION_UP:
  231.             default:
  232.                 Log.d(TAG, "进入MotionEvent.ACTION_UP或者是default中");
  233.                 if (currentStatus == STATUS_RELEASE_TO_REFRESH) {
  234.                     // 松手时如果是释放立即刷新状态，就去调用正在刷新的任务
  235.                     new RefreshingTask().execute();
  236.                 } else if (currentStatus == STATUS_PULL_TO_REFRESH) {
  237.                     // 松手时如果是下拉状态，就去调用隐藏下拉头的任务
  238.                     new HideHeaderTask().execute();
  239.                 }
  240.                 break;
  241.             }
  242.             // 时刻记得更新下拉头中的信息
  243.             if (currentStatus == STATUS_PULL_TO_REFRESH
  244.                     || currentStatus == STATUS_RELEASE_TO_REFRESH) {
  245.                 Log.d(TAG, "进入“时刻记得更新下拉头中的信息”的if语句");
  246.                 updateHeaderView();
  247.                 // 当前正处于下拉或释放状态，要让ListView失去焦点，否则被点击的那一项会一直处于选中状态
  248.                 listView.setPressed(false);
  249.                 listView.setFocusable(false);
  250.                 listView.setFocusableInTouchMode(false);
  251.                 lastStatus = currentStatus;
  252.                 // 当前正处于下拉或释放状态，通过返回true屏蔽掉ListView的滚动事件
  253.                 Log.d(TAG, "离开“时刻记得更新下拉头中的信息”的if语句");
  254.                 return true;
  255.             }
  256.         }
  257.         Log.d(TAG, "离开onTouch");
  258.         return false;
  259.     }
  261.     /**
  262.      * 给下拉刷新控件注册一个监听器。 RefreshableView构造方法执行完成之后，紧接着就执行这个方法
  263.      * 
  264.      * @param listener
  265.      *            监听器的实现。
  266.      * @param id
  267.      *            为了防止不同界面的下拉刷新在上次更新时间上互相有冲突， 请不同界面在注册下拉刷新监听器时一定要传入不同的id。
  268.      */
  269.     public void setOnRefreshListener(PullToRefreshListener listener, int id) {
  270.         Log.d(TAG, "进入setOnRefreshListener方法");
  271.         mListener = listener;
  272.         Log.d(TAG, "离开setOnRefreshListener方法");
  273.         mId = id;
  274.     }
  276.     /**
  277.      * 当所有的刷新逻辑完成后，记录调用一下，否则你的ListView将一直处于正在刷新状态。
  278.      */
  279.     public void finishRefreshing() {
  280.         Log.d(TAG, "进入finishRefreshing方法");
  282.         currentStatus = STATUS_REFRESH_FINISHED;
  283.         preferences.edit()
  284.                 .putLong(UPDATED_AT + mId, System.currentTimeMillis()).commit();
  285.         new HideHeaderTask().execute();
  286.         Log.d(TAG, "离开finishRefreshing方法");
  287.     }
  289.     /**
  290.      * 根据当前ListView的滚动状态来设定ableToPull的值，
  291.      * 每次都需要在onTouch中第一个执行，这样可以判断出当前应该是滚动ListView，还是应该进行下拉。
  292.      */
  293.     private void setIsAbleToPull(MotionEvent event) {
  294.         Log.d(TAG, "进入setIsAbleToPull方法");
  295.         View firstChild = listView.getChildAt(0);
  296.         if (firstChild != null) {
  297.             int firstVisiblePos = listView.getFirstVisiblePosition();
  298.             if (firstVisiblePos == 0 && firstChild.getTop() == 0) {
  299.                 if (!ableToPull) {
  300.                     yDown = event.getRawY();
  301.                 }
  302.                 // 如果首个元素的上边缘，距离父布局值为0，就说明ListView滚动到了最顶部，此时应该允许下拉刷新
  303.                 ableToPull = true;
  304.             } else {
  305.                 if (headerLayoutParams.topMargin != hideHeaderHeight) {
  306.                     headerLayoutParams.topMargin = hideHeaderHeight;
  307.                     header.setLayoutParams(headerLayoutParams);
  308.                 }
  309.                 ableToPull = false;
  310.             }
  311.         } else {
  312.             // 如果ListView中没有元素，也应该允许下拉刷新
  313.             ableToPull = true;
  314.         }
  315.         Log.d(TAG, "离开setIsAbleToPull方法");
  316.     }
  318.     /**
  319.      * 更新下拉头中的信息。
  320.      */
  321.     private void updateHeaderView() {
  322.         Log.d(TAG, "进入updateHeaderView方法");
  323.         if (lastStatus != currentStatus) {
  324.             if (currentStatus == STATUS_PULL_TO_REFRESH) {
  325.                 description.setText(getResources().getString(
  326.                         R.string.pull_to_refresh));
  327.                 arrow.setVisibility(View.VISIBLE);
  328.                 progressBar.setVisibility(View.GONE);
  329.                 rotateArrow();
  330.             } else if (currentStatus == STATUS_RELEASE_TO_REFRESH) {
  331.                 description.setText(getResources().getString(
  332.                         R.string.release_to_refresh));
  333.                 arrow.setVisibility(View.VISIBLE);
  334.                 progressBar.setVisibility(View.GONE);
  335.                 rotateArrow();
  336.             } else if (currentStatus == STATUS_REFRESHING) {
  337.                 description.setText(getResources().getString(
  338.                         R.string.refreshing));
  339.                 progressBar.setVisibility(View.VISIBLE);
  340.                 arrow.clearAnimation();
  341.                 arrow.setVisibility(View.GONE);
  342.             }
  343.             refreshUpdatedAtValue();
  344.             Log.d(TAG, "离开updateHeaderView方法");
  345.         }
  346.     }
  348.     /**
  349.      * 根据当前的状态来旋转箭头。
  350.      */
  351.     private void rotateArrow() {
  352.         Log.d(TAG, "进入rotateArrow方法");
  353.         float pivotX = arrow.getWidth() / 2f;
  354.         float pivotY = arrow.getHeight() / 2f;
  355.         float fromDegrees = 0f;
  356.         float toDegrees = 0f;
  357.         if (currentStatus == STATUS_PULL_TO_REFRESH) {
  358.             fromDegrees = 180f;
  359.             toDegrees = 360f;
  360.         } else if (currentStatus == STATUS_RELEASE_TO_REFRESH) {
  361.             fromDegrees = 0f;
  362.             toDegrees = 180f;
  363.         }
  364.         RotateAnimation animation = new RotateAnimation(fromDegrees, toDegrees,
  365.                 pivotX, pivotY);
  366.         animation.setDuration(100);
  367.         animation.setFillAfter(true);
  368.         arrow.startAnimation(animation);
  369.         Log.d(TAG, "离开rotateArrow方法");
  370.     }
  372.     /**
  373.      * 刷新下拉头中上次更新时间的文字描述。
  374.      */
  375.     private void refreshUpdatedAtValue() {
  376.         Log.d(TAG, "进入refreshUpdatedAtValue方法");
  377.         /**
  378.          * 从SharedPreferences存储文件中取出上次保存的更新时间
  379.          */
  380.         lastUpdateTime = preferences.getLong(UPDATED_AT + mId, -1);
  381.         /**
  382.          * 获得当前时间
  383.          */
  384.         long currentTime = System.currentTimeMillis();
  385.         /**
  386.          * 获得当前更新时间和上次更新时间的时间差
  387.          */
  388.         long timePassed = currentTime - lastUpdateTime;
  390.         long timeIntoFormat;
  391.         /**
  392.          * 此次更新显示的提示信息（如，暂未更新过，或者，5分钟前更新过）
  393.          */
  394.         String updateAtValue;
  395.         if (lastUpdateTime == -1) {
  396.             // lastUpdateTime =-1指的是还没有更新（暂未更新过），否则就是更新过，判断具体更新的时间
  397.             /**
  398.              * getResources()得到Resources对象 ,通过该对象可以获得res文件夹下所有的资源，如图片，字符串，布局文件
  399.              */
  400.             updateAtValue = getResources().getString(R.string.not_updated_yet);
  401.         } else if (timePassed < 0) {
  402.             updateAtValue = getResources().getString(R.string.time_error);
  403.         } else if (timePassed < ONE_MINUTE) {
  404.             updateAtValue = getResources().getString(R.string.updated_just_now);
  405.         } else if (timePassed < ONE_HOUR) {
  406.             /**
  407.              * %n$ms：代表输出的是字符串，n代表是第几个参数，设置m的值可以在输出之前放置空格 也可简单写成： %s （表示字符串）【
  408.              * 扩展：%d （表示整数） %f （表示浮点数）】 String str = "上次更新于%1$s前" ; String
  409.              * string= String.format(str,"23分钟") 就是指将字符串中，第一个要替换的字符，替换为23
  410.              * string的结果就是：上次更新于23分钟前
  411.              */
  412.             timeIntoFormat = timePassed / ONE_MINUTE;
  413.             String value = timeIntoFormat + "分钟";
  414.             updateAtValue = String.format(
  415.                     getResources().getString(R.string.updated_at), value);
  416.         } else if (timePassed < ONE_DAY) {
  417.             timeIntoFormat = timePassed / ONE_HOUR;
  418.             String value = timeIntoFormat + "小时";
  419.             updateAtValue = String.format(
  420.                     getResources().getString(R.string.updated_at), value);
  421.         } else if (timePassed < ONE_MONTH) {
  422.             timeIntoFormat = timePassed / ONE_DAY;
  423.             String value = timeIntoFormat + "天";
  424.             updateAtValue = String.format(
  425.                     getResources().getString(R.string.updated_at), value);
  426.         } else if (timePassed < ONE_YEAR) {
  427.             timeIntoFormat = timePassed / ONE_MONTH;
  428.             String value = timeIntoFormat + "个月";
  429.             updateAtValue = String.format(
  430.                     getResources().getString(R.string.updated_at), value);
  431.         } else {
  432.             timeIntoFormat = timePassed / ONE_YEAR;
  433.             String value = timeIntoFormat + "年";
  434.             updateAtValue = String.format(
  435.                     getResources().getString(R.string.updated_at), value);
  436.         }
  437.         updateAt.setText(updateAtValue);
  438.         Log.d(TAG, "离开refreshUpdatedAtValue方法");
  439.     }
  441.     /**
  442.      * 正在刷新的任务，在此任务中会去回调注册进来的下拉刷新监听器。
  443.      */
  444.     class RefreshingTask extends AsyncTask<Void, Integer, Void> {
  445.         @Override
  446.         protected Void doInBackground(Void... params) {
  447.             Log.d(TAG, "---进入RefreshingTask的doInBackground方法");
  448.             int topMargin = headerLayoutParams.topMargin;
  449.             while (true) {
  450.                 topMargin = topMargin + SCROLL_SPEED;
  451.                 if (topMargin <= 0) {
  452.                     topMargin = 0;
  453.                     break;
  454.                 }
  455.                 publishProgress(topMargin);
  456.                 sleep(10);
  457.             }
  458.             currentStatus = STATUS_REFRESHING;
  459.             /**
  460.              * 调用publishProgress(0);方法后，紧接着会执行onProgressUpdate这个方法
  461.              */
  462.             publishProgress(0);
  463.             if (mListener != null) {
  464.                 mListener.onRefresh();
  465.             }
  466.             Log.d(TAG, "离开doInBackground方法");
  467.             return null;
  468.         }
  470.         @Override
  471.         protected void onProgressUpdate(Integer... topMargin) {
  472.             Log.d(TAG, "---进入RefreshingTask的onProgressUpdate方法");
  474.             updateHeaderView();
  475.             headerLayoutParams.topMargin = topMargin[0];
  476.             header.setLayoutParams(headerLayoutParams);
  477.             Log.d(TAG, "离开onProgressUpdate方法");
  478.         }
  480.         @Override
  481.         protected void onPostExecute(Void result) {
  482.             // TODO Auto-generated method stub
  483.             Log.d(TAG, "---进入RefreshingTask的onPostExecute方法");
  484.             /**
  485.              * 向adapter适配器中添加新的数据
  486.              */
  487.             if (adapter != null) {
  488.                 adapter.insert("新数据_" + count++, 0);
  489.             }
  490.         }
  491.     }
  493.     /**
  494.      * 隐藏下拉头的任务，当未进行下拉刷新或下拉刷新完成后，此任务将会使下拉头重新隐藏。
  495.      */
  496.     class HideHeaderTask extends AsyncTask<Void, Integer, Integer> {
  497.         @Override
  498.         protected Integer doInBackground(Void... params) {
  499.             Log.d(TAG, "------进入HideHeaderTask的doInBackground方法");
  500.             int topMargin = headerLayoutParams.topMargin;
  501.             while (true) {
  502.                 topMargin = topMargin + SCROLL_SPEED;
  503.                 if (topMargin <= hideHeaderHeight) {
  504.                     topMargin = hideHeaderHeight;
  505.                     break;
  506.                 }
  507.                 publishProgress(topMargin);
  508.                 sleep(10);
  509.             }
  510.             Log.d(TAG, "离开doInBackground方法");
  511.             return topMargin;
  512.         }
  514.         @Override
  515.         protected void onProgressUpdate(Integer... topMargin) {
  516.             Log.d(TAG, "------进入HideHeaderTask的onProgressUpdate方法");
  517.             headerLayoutParams.topMargin = topMargin[0];
  518.             header.setLayoutParams(headerLayoutParams);
  519.             Log.d(TAG, "离开onProgressUpdate方法");
  520.         }
  522.         @Override
  523.         protected void onPostExecute(Integer topMargin) {
  524.             Log.d(TAG, "-----进入HideHeaderTask的onPostExecute方法");
  525.             /**
  526.              * 刷新适配器中数据
  527.              */
  528.             if (adapter != null) {
  529.                 adapter.notifyDataSetChanged();
  530.             }
  531.             headerLayoutParams.topMargin = topMargin;
  532.             header.setLayoutParams(headerLayoutParams);
  533.             currentStatus = STATUS_REFRESH_FINISHED;
  534.             Log.d(TAG, "离开onPostExecute方法");
  535.         }
  536.     }
  538.     /**
  539.      * 使当前线程睡眠指定的毫秒数。
  540.      * 
  541.      * @param time
  542.      *            指定当前线程睡眠多久，以毫秒为单位
  543.      */
  544.     private void sleep(int time) {
  545.         try {
  546.             Thread.sleep(time);
  547.         } catch (InterruptedException e) {
  548.             e.printStackTrace();
  549.         }
  550.     }
  552.     /**
  553.      * 下拉刷新的监听器，使用下拉刷新的地方应该注册此监听器来获取刷新回调。
  554.      */
  555.     public interface PullToRefreshListener {
  556.         /**
  557.          * 刷新时会去回调此方法，在方法内编写具体的刷新逻辑。注意此方法是在子线程中调用的， 你可以不必另开线程来进行耗时操作。
  558.          */
  559.         void onRefresh();
  560.     }
  562.     /**
  563.      * 将adapter对象传到refreshableView中，方便更新新数据到适配器中
  564.      * @param adapter
  565.      */
  566.     public void initAdapter(ArrayAdapter<String> adapter) {
  567.         // TODO Auto-generated method stub
  568.         this.adapter = adapter;
  569.     }
  570. }

下拉刷新原理：

  1. /**
  2.  * 首先在RefreshableView的构造函数中动态添加了刚刚定义的pull_refresh这个布局作为下拉头，
  3.  * 然后在onLayout方法中将下拉头向上偏移出了屏幕，
  4.  * 再给ListView注册了touch事件。
  5.  * 之后每当手指在ListView上滑动时，onTouch方法就会执行。
  6.  * 在onTouch方法中的第一行就调用了setIsAbleToPull方法来判断ListView是否滚动到了最顶部，
  7.  * 只有滚动到了最顶部才会执行后面的代码，否则就视为正常的ListView滚动，不做任何处理。
  8.  * 当ListView滚动到了最顶部时，如果手指还在向下拖动，就会改变下拉头的偏移值，
  9.  * 让下拉头显示出来，下拉的距离设定为手指移动距离的1/2，这样才会有拉力的感觉。
  10.  * 如果下拉的距离足够大，在松手的时候就会执行刷新操作，如果距离不够大，就仅仅重新隐藏下拉头。
  11.  *  具体的刷新操作会在RefreshingTask中进行，
  12.  *  其中在doInBackground方法中回调了PullToRefreshListener接口的onRefresh方法，
  13.  *  这也是大家在使用RefreshableView时必须要去实现的一个接口，
  14.  *  因为具体刷新的逻辑就应该写在onRefresh方法中，后面会演示使用的方法。
  15.  * 另外每次在下拉的时候都还会调用updateHeaderView方法来改变下拉头中的数据，
  16.  * 比如箭头方向的旋转，下拉文字描述的改变等。
  17.  * 
  18.  */

项目下载：

android下拉刷新功能demo下载

发表评论

表情：
评论列表 （有 0 条评论，317人围观）

还没有评论，来说两句吧...

相关阅读

    相关 Android ListView下拉刷新

    ListView的重要性我就不多说了，下拉刷新的功能以前一直用的别人的，这两天参考一些资料自己写了个ListView下拉刷新的控件，自己会写才能掌握在自己手里，以后扩展什么的，

    短命女短命女/ 0 赞/ 300 阅读