风色年代
风色年代

Android ListView 实现下拉刷新上拉加载

转载请注明出处：http://blog.csdn.net/allen315410/article/details/39965327

1.简介

       无疑，在Android开发中，ListView是使用非常频繁的控件之一，ListView提供一个列表的容易，允许我们以列表的形式将数据展示到界面上，但是Google给我们提供的原生ListView的控件，虽然在功能上很强大，但是在用户体验和动态效果上，还是比较差劲的。为了改善用户体验，市面上纷纷出现了各种各样的自定义的ListView，他们功能强大，界面美观，使我们该需要学习的地方。其中，使用最频繁的功能无疑就是ListView的下拉刷新和上拉加载数据了，几乎在没一款内容型的App中都可以找到这种控件的身影，尤其是需要联网获取数据的模块，使用的就更为频繁了，so，我们很有必要了解下这种效果是怎么实现的。

2.开源组件PullToRefreshList介绍      

      既然Android和Java都是开源的，一些常见的功能或者效果就不难被找到。PullToRefresh就是一个典型的例子，PullToRefresh是老外写的一个开源ListView组件，这个项目在ListView的基础上扩展了ListView的功能，增强了Listview的用户体验，功能十分强大，而且很容易被集成到当前的项目中，你只需要调用简单的API，即可省去很多不必要的麻烦，非常棒。以上是项目在Github的链接，有兴趣的可以戳进去down下来，使用一下。这里不是我们的重点，不想废话了。
PullToRefresh的Github项目地址： https://github.com/chrisbanes/Android-PullToRefresh

3.自定义ListView——下拉刷新&上拉加载

     本博客的重点讲述一下自定义LisView，实现下拉刷新和上拉加载的功能，实现类似于开源项目PullToRefresh的效果。好，既然如此，先看看我实现后的效果图，再分析：
      
        好，效果图如上所示，下面逐步讲解下实现的过程。首先，来观察一下，ListView上方的布局，我这里称其为“头布局”，这个所谓的头布局，大致功能是这样的，一个ImageView显示上下拉动方向的状态的，ImageView相同的位置隐藏了一个ProgressBar，用来在数据刷新时给个提示作用的。还有两个TextView，上面用来显示下拉刷新时提醒用户是如何操作的，例如“下拉刷新”“松开刷新”“正在刷新”，另一个是用来显示本次刷新的时间的。比较简单的布局，下面是XML代码：
[html] view plain copy print ?
  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="horizontal" >  
  6.   
  7.     <FrameLayout  
  8.         android:layout_width="wrap_content"  
  9.         android:layout_height="wrap_content"  
  10.         android:layout_margin="10dip" >  
  11.   
  12.         <ImageView  
  13.             android:id="@+id/iv_listview_header_arrow"  
  14.             android:layout_width="wrap_content"  
  15.             android:layout_height="wrap_content"  
  16.             android:layout_gravity="center"  
  17.             android:minWidth="30dip"  
  18.             android:src="@drawable/common_listview_headview_red_arrow" />  
  19.   
  20.         <ProgressBar  
  21.             android:id="@+id/pb_listview_header"  
  22.             android:layout_width="wrap_content"  
  23.             android:layout_height="wrap_content"  
  24.             android:layout_gravity="center"  
  25.             android:indeterminateDrawable="@drawable/common_progressbar"  
  26.             android:visibility="gone" />  
  27.     FrameLayout>  
  28.   
  29.     <LinearLayout  
  30.         android:layout_width="fill_parent"  
  31.         android:layout_height="wrap_content"  
  32.         android:layout_gravity="center_vertical"  
  33.         android:gravity="center_horizontal"  
  34.         android:orientation="vertical" >  
  35.   
  36.         <TextView  
  37.             android:id="@+id/tv_listview_header_state"  
  38.             android:layout_width="wrap_content"  
  39.             android:layout_height="wrap_content"  
  40.             android:text="下拉刷新"  
  41.             android:textColor="#FF0000"  
  42.             android:textSize="18sp" />  
  43.   
  44.         <TextView  
  45.             android:id="@+id/tv_listview_header_last_update_time"  
  46.             android:layout_width="wrap_content"  
  47.             android:layout_height="wrap_content"  
  48.             android:layout_marginTop="5dip"  
  49.             android:text="最后刷新时间: 2014-10-10 12:56:12"  
  50.             android:textColor="@android:color/white"  
  51.             android:textSize="14sp" />  
  52.     LinearLayout>  
  53.   
  54. LinearLayout>  
         下面讲解一下ListView下方的布局，我称其为“脚布局”，这个脚布局就更简单了，直接看XML代码好了：
[html] view plain copy print ?
  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.     <LinearLayout  
  8.         android:layout_width="wrap_content"  
  9.         android:layout_height="wrap_content"  
  10.         android:layout_gravity="center_horizontal"  
  11.         android:layout_margin="10dip"  
  12.         android:gravity="center_vertical"  
  13.         android:orientation="horizontal" >  
  14.   
  15.         <ProgressBar  
  16.             android:layout_width="wrap_content"  
  17.             android:layout_height="wrap_content"  
  18.             android:layout_gravity="center"  
  19.             android:indeterminateDrawable="@drawable/common_progressbar" />  
  20.   
  21.         <TextView  
  22.             android:layout_width="wrap_content"  
  23.             android:layout_height="wrap_content"  
  24.             android:layout_marginLeft="10dip"  
  25.             android:text="加载更多..."  
  26.             android:textColor="#FF0000"  
  27.             android:textSize="18sp" />  
  28.     LinearLayout>  
  29.   
  30. LinearLayout>  
此外，两个布局都用到一个ProgressBar的背景，其XML如下：
[html] view plain copy print ?
  1. xml version="1.0" encoding="utf-8"?>  
  2. <rotate xmlns:android="http://schemas.android.com/apk/res/android"  
  3.     android:fromDegrees="0"  
  4.     android:pivotX="50%"  
  5.     android:pivotY="50%"  
  6.     android:toDegrees="360" >  
  7.   
  8.     <shape  
  9.         android:innerRadiusRatio="3"  
  10.         android:shape="ring"  
  11.         android:useLevel="false" >  
  12.         <gradient  
  13.             android:centerColor="#FF6666"  
  14.             android:endColor="#FF0000"  
  15.             android:startColor="#FFFFFF"  
  16.             android:type="sweep" />  
  17.     shape>  
  18.   
  19. rotate>  
        ListView的头布局和脚布局已经做好了，那么接下来该怎么集成到ListView上去呢？首先我们来看看ListView的部分源代码，很轻松能找到这两个方法： addHeaderView(View v)； addFooterView(View v)，通过字面的意思就可以理解，这两个方法分别是向ListView顶部添加一个View和向ListView的底部添加View的，有了这两个方法，那么上面的头布局和脚布局就很容易被添加到ListView上了，并且成为ListView的一体。
       其实，再看会发现，简单的使用这两个方法分别往ListView上添加头布局和脚布局是不合理，添加上去的头布局和脚布局会被显示出来，并没有被隐藏掉，为了实现下拉和上拉时能够将头布局和脚布局都“拉出来”并且还可以松开时，再次隐藏起来，我们可以使用View下的一个方法 setPadding(int left, int top, int right, int bottom)，这个方法设置View的Padding属性，这里，我们不必管left、right、bottom，只要设置top的值为头布局或者脚布局的高度即可“隐藏”这两个布局，而且还可以在手指滑动屏幕的时候，动态的设置这个top的值，来实现头布局和脚布局的显示-隐藏-显示。
       还有一个非常重要的话题，就是这个top的值还设定为多少合适？上面说了，我们来头布局来说明一下，隐藏这个头布局需要将top值设置成top=- 头布局高度，那么这个头布局的高度怎么求得呢？很显然，使用 getHeight()是得不到头布局高度的，因为 getHeight()方法是先控件在屏幕上展示完毕后得到的高度，显然在这里，这个ListView还在构建中，并没有展示到屏幕上。所以注意了，我们先调用View下的 measure(int widthMeasureSpec, int heightMeasureSpec)方法，将widthMeasureSpec和heightMeasureSpec分别设置为0，这里的widthMeasureSpec和heightMeasureSpec并不是一个准备的值，而且指定一个规格或者标准让系统帮我们测量View的宽高，当我们指定widthMeasureSpec和heightMeasureSpec分别为0的时候，系统将不采用这个规格去测量，而是根据实际情况去测量。之后，我们可以调用View下的 getMeasuredHeight()方法获取真实的头布局的高度，然后设置top = - 头布局实际高度，实现隐藏头布局。
[java] view plain copy print ?
  1. public class RefreshListView extends ListView implements OnScrollListener {  
  2.   
  3.     private static final String TAG = "RefreshListView";  
  4.     private int firstVisibleItemPosition; // 屏幕显示在第一个的item的索引  
  5.     private int downY; // 按下时y轴的偏移量  
  6.     private int headerViewHeight; // 头布局的高度  
  7.     private View headerView; // 头布局的对象  
  8.   
  9.     private final int DOWN_PULL_REFRESH = 0; // 下拉刷新状态  
  10.     private final int RELEASE_REFRESH = 1; // 松开刷新  
  11.     private final int REFRESHING = 2; // 正在刷新中  
  12.     private int currentState = DOWN_PULL_REFRESH; // 头布局的状态: 默认为下拉刷新状态  
  13.   
  14.     private Animation upAnimation; // 向上旋转的动画  
  15.     private Animation downAnimation; // 向下旋转的动画  
  16.   
  17.     private ImageView ivArrow; // 头布局的剪头  
  18.     private ProgressBar mProgressBar; // 头布局的进度条  
  19.     private TextView tvState; // 头布局的状态  
  20.     private TextView tvLastUpdateTime; // 头布局的最后更新时间  
  21.   
  22.     private OnRefreshListener mOnRefershListener;  
  23.     private boolean isScrollToBottom; // 是否滑动到底部  
  24.     private View footerView; // 脚布局的对象  
  25.     private int footerViewHeight; // 脚布局的高度  
  26.     private boolean isLoadingMore = false; // 是否正在加载更多中  
  27.   
  28.     public RefreshListView(Context context, AttributeSet attrs) {  
  29.         super(context, attrs);  
  30.         initHeaderView();  
  31.         initFooterView();  
  32.         this.setOnScrollListener(this);  
  33.     }  
  34.   
  35.     /** 
  36.      * 初始化脚布局 
  37.      */  
  38.     private void initFooterView() {  
  39.         footerView = View.inflate(getContext(), R.layout.listview_footer, null);  
  40.         footerView.measure(0, 0);  
  41.         footerViewHeight = footerView.getMeasuredHeight();  
  42.         footerView.setPadding(0, -footerViewHeight, 0, 0);  
  43.         this.addFooterView(footerView);  
  44.     }  
  45.   
  46.     /** 
  47.      * 初始化头布局 
  48.      */  
  49.     private void initHeaderView() {  
  50.         headerView = View.inflate(getContext(), R.layout.listview_header, null);  
  51.         ivArrow = (ImageView) headerView  
  52.                 .findViewById(R.id.iv_listview_header_arrow);  
  53.         mProgressBar = (ProgressBar) headerView  
  54.                 .findViewById(R.id.pb_listview_header);  
  55.         tvState = (TextView) headerView  
  56.                 .findViewById(R.id.tv_listview_header_state);  
  57.         tvLastUpdateTime = (TextView) headerView  
  58.                 .findViewById(R.id.tv_listview_header_last_update_time);  
  59.   
  60.         // 设置最后刷新时间  
  61.         tvLastUpdateTime.setText("最后刷新时间: " + getLastUpdateTime());  
  62.   
  63.         headerView.measure(0, 0); // 系统会帮我们测量出headerView的高度  
  64.         headerViewHeight = headerView.getMeasuredHeight();  
  65.         headerView.setPadding(0, -headerViewHeight, 0, 0);  
  66.         this.addHeaderView(headerView); // 向ListView的顶部添加一个view对象  
  67.         initAnimation();  
  68.     }  
  69.   
  70.     /** 
  71.      * 获得系统的最新时间 
  72.      *  
  73.      * @return 
  74.      */  
  75.     private String getLastUpdateTime() {  
  76.         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  
  77.         return sdf.format(System.currentTimeMillis());  
  78.     }  
  79.   
  80.     /** 
  81.      * 初始化动画 
  82.      */  
  83.     private void initAnimation() {  
  84.         upAnimation = new RotateAnimation(0f, -180f,  
  85.                 Animation.RELATIVE_TO_SELF, 0.5f, Animation.RELATIVE_TO_SELF,  
  86.                 0.5f);  
  87.         upAnimation.setDuration(500);  
  88.         upAnimation.setFillAfter(true); // 动画结束后, 停留在结束的位置上  
  89.   
  90.         downAnimation = new RotateAnimation(-180f, -360f,  
  91.                 Animation.RELATIVE_TO_SELF, 0.5f, Animation.RELATIVE_TO_SELF,  
  92.                 0.5f);  
  93.         downAnimation.setDuration(500);  
  94.         downAnimation.setFillAfter(true); // 动画结束后, 停留在结束的位置上  
  95.     }  
  96.   
  97.     @Override  
  98.     public boolean onTouchEvent(MotionEvent ev) {  
  99.         switch (ev.getAction()) {  
  100.             case MotionEvent.ACTION_DOWN :  
  101.                 downY = (int) ev.getY();  
  102.                 break;  
  103.             case MotionEvent.ACTION_MOVE :  
  104.                 int moveY = (int) ev.getY();  
  105.                 // 移动中的y - 按下的y = 间距.  
  106.                 int diff = (moveY - downY) / 2;  
  107.                 // -头布局的高度 + 间距 = paddingTop  
  108.                 int paddingTop = -headerViewHeight + diff;  
  109.                 // 如果: -头布局的高度 > paddingTop的值 执行super.onTouchEvent(ev);  
  110.                 if (firstVisibleItemPosition == 0  
  111.                         && -headerViewHeight < paddingTop) {  
  112.                     if (paddingTop > 0 && currentState == DOWN_PULL_REFRESH) { // 完全显示了.  
  113.                         Log.i(TAG, "松开刷新");  
  114.                         currentState = RELEASE_REFRESH;  
  115.                         refreshHeaderView();  
  116.                     } else if (paddingTop < 0  
  117.                             && currentState == RELEASE_REFRESH) { // 没有显示完全  
  118.                         Log.i(TAG, "下拉刷新");  
  119.                         currentState = DOWN_PULL_REFRESH;  
  120.                         refreshHeaderView();  
  121.                     }  
  122.                     // 下拉头布局  
  123.                     headerView.setPadding(0, paddingTop, 0, 0);  
  124.                     return true;  
  125.                 }  
  126.                 break;  
  127.             case MotionEvent.ACTION_UP :  
  128.                 // 判断当前的状态是松开刷新还是下拉刷新  
  129.                 if (currentState == RELEASE_REFRESH) {  
  130.                     Log.i(TAG, "刷新数据.");  
  131.                     // 把头布局设置为完全显示状态  
  132.                     headerView.setPadding(0, 0, 0, 0);  
  133.                     // 进入到正在刷新中状态  
  134.                     currentState = REFRESHING;  
  135.                     refreshHeaderView();  
  136.   
  137.                     if (mOnRefershListener != null) {  
  138.                         mOnRefershListener.onDownPullRefresh(); // 调用使用者的监听方法  
  139.                     }  
  140.                 } else if (currentState == DOWN_PULL_REFRESH) {  
  141.                     // 隐藏头布局  
  142.                     headerView.setPadding(0, -headerViewHeight, 0, 0);  
  143.                 }  
  144.                 break;  
  145.             default :  
  146.                 break;  
  147.         }  
  148.         return super.onTouchEvent(ev);  
  149.     }  
  150.   
  151.     /** 
  152.      * 根据currentState刷新头布局的状态 
  153.      */  
  154.     private void refreshHeaderView() {  
  155.         switch (currentState) {  
  156.             case DOWN_PULL_REFRESH : // 下拉刷新状态  
  157.                 tvState.setText("下拉刷新");  
  158.                 ivArrow.startAnimation(downAnimation); // 执行向下旋转  
  159.                 break;  
  160.             case RELEASE_REFRESH : // 松开刷新状态  
  161.                 tvState.setText("松开刷新");  
  162.                 ivArrow.startAnimation(upAnimation); // 执行向上旋转  
  163.                 break;  
  164.             case REFRESHING : // 正在刷新中状态  
  165.                 ivArrow.clearAnimation();  
  166.                 ivArrow.setVisibility(View.GONE);  
  167.                 mProgressBar.setVisibility(View.VISIBLE);  
  168.                 tvState.setText("正在刷新中...");  
  169.                 break;  
  170.             default :  
  171.                 break;  
  172.         }  
  173.     }  
  174.   
  175.     /** 
  176.      * 当滚动状态改变时回调 
  177.      */  
  178.     @Override  
  179.     public void onScrollStateChanged(AbsListView view, int scrollState) {  
  180.   
  181.         if (scrollState == SCROLL_STATE_IDLE  
  182.                 || scrollState == SCROLL_STATE_FLING) {  
  183.             // 判断当前是否已经到了底部  
  184.             if (isScrollToBottom && !isLoadingMore) {  
  185.                 isLoadingMore = true;  
  186.                 // 当前到底部  
  187.                 Log.i(TAG, "加载更多数据");  
  188.                 footerView.setPadding(0, 0, 0, 0);  
  189.                 this.setSelection(this.getCount());  
  190.   
  191.                 if (mOnRefershListener != null) {  
  192.                     mOnRefershListener.onLoadingMore();  
  193.                 }  
  194.             }  
  195.         }  
  196.     }  
  197.   
  198.     /** 
  199.      * 当滚动时调用 
  200.      *  
  201.      * @param firstVisibleItem 
  202.      *            当前屏幕显示在顶部的item的position 
  203.      * @param visibleItemCount 
  204.      *            当前屏幕显示了多少个条目的总数 
  205.      * @param totalItemCount 
  206.      *            ListView的总条目的总数 
  207.      */  
  208.     @Override  
  209.     public void onScroll(AbsListView view, int firstVisibleItem,  
  210.             int visibleItemCount, int totalItemCount) {  
  211.         firstVisibleItemPosition = firstVisibleItem;  
  212.   
  213.         if (getLastVisiblePosition() == (totalItemCount - 1)) {  
  214.             isScrollToBottom = true;  
  215.         } else {  
  216.             isScrollToBottom = false;  
  217.         }  
  218.     }  
  219.   
  220.     /** 
  221.      * 设置刷新监听事件 
  222.      *  
  223.      * @param listener 
  224.      */  
  225.     public void setOnRefreshListener(OnRefreshListener listener) {  
  226.         mOnRefershListener = listener;  
  227.     }  
  228.   
  229.     /** 
  230.      * 隐藏头布局 
  231.      */  
  232.     public void hideHeaderView() {  
  233.         headerView.setPadding(0, -headerViewHeight, 0, 0);  
  234.         ivArrow.setVisibility(View.VISIBLE);  
  235.         mProgressBar.setVisibility(View.GONE);  
  236.         tvState.setText("下拉刷新");  
  237.         tvLastUpdateTime.setText("最后刷新时间: " + getLastUpdateTime());  
  238.         currentState = DOWN_PULL_REFRESH;  
  239.     }  
  240.   
  241.     /** 
  242.      * 隐藏脚布局 
  243.      */  
  244.     public void hideFooterView() {  
  245.         footerView.setPadding(0, -footerViewHeight, 0, 0);  
  246.         isLoadingMore = false;  
  247.     }  
  248. }  
public class RefreshListView extends ListView implements OnScrollListener {

	private static final String TAG = "RefreshListView";
	private int firstVisibleItemPosition; // 屏幕显示在第一个的item的索引
	private int downY; // 按下时y轴的偏移量
	private int headerViewHeight; // 头布局的高度
	private View headerView; // 头布局的对象

	private final int DOWN_PULL_REFRESH = 0; // 下拉刷新状态
	private final int RELEASE_REFRESH = 1; // 松开刷新
	private final int REFRESHING = 2; // 正在刷新中
	private int currentState = DOWN_PULL_REFRESH; // 头布局的状态: 默认为下拉刷新状态

	private Animation upAnimation; // 向上旋转的动画
	private Animation downAnimation; // 向下旋转的动画

	private ImageView ivArrow; // 头布局的剪头
	private ProgressBar mProgressBar; // 头布局的进度条
	private TextView tvState; // 头布局的状态
	private TextView tvLastUpdateTime; // 头布局的最后更新时间

	private OnRefreshListener mOnRefershListener;
	private boolean isScrollToBottom; // 是否滑动到底部
	private View footerView; // 脚布局的对象
	private int footerViewHeight; // 脚布局的高度
	private boolean isLoadingMore = false; // 是否正在加载更多中

	public RefreshListView(Context context, AttributeSet attrs) {
		super(context, attrs);
		initHeaderView();
		initFooterView();
		this.setOnScrollListener(this);
	}

	/**
	 * 初始化脚布局
	 */
	private void initFooterView() {
		footerView = View.inflate(getContext(), R.layout.listview_footer, null);
		footerView.measure(0, 0);
		footerViewHeight = footerView.getMeasuredHeight();
		footerView.setPadding(0, -footerViewHeight, 0, 0);
		this.addFooterView(footerView);
	}

	/**
	 * 初始化头布局
	 */
	private void initHeaderView() {
		headerView = View.inflate(getContext(), R.layout.listview_header, null);
		ivArrow = (ImageView) headerView
				.findViewById(R.id.iv_listview_header_arrow);
		mProgressBar = (ProgressBar) headerView
				.findViewById(R.id.pb_listview_header);
		tvState = (TextView) headerView
				.findViewById(R.id.tv_listview_header_state);
		tvLastUpdateTime = (TextView) headerView
				.findViewById(R.id.tv_listview_header_last_update_time);

		// 设置最后刷新时间
		tvLastUpdateTime.setText("最后刷新时间: " + getLastUpdateTime());

		headerView.measure(0, 0); // 系统会帮我们测量出headerView的高度
		headerViewHeight = headerView.getMeasuredHeight();
		headerView.setPadding(0, -headerViewHeight, 0, 0);
		this.addHeaderView(headerView); // 向ListView的顶部添加一个view对象
		initAnimation();
	}

	/**
	 * 获得系统的最新时间
	 * 
	 * @return
	 */
	private String getLastUpdateTime() {
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		return sdf.format(System.currentTimeMillis());
	}

	/**
	 * 初始化动画
	 */
	private void initAnimation() {
		upAnimation = new RotateAnimation(0f, -180f,
				Animation.RELATIVE_TO_SELF, 0.5f, Animation.RELATIVE_TO_SELF,
				0.5f);
		upAnimation.setDuration(500);
		upAnimation.setFillAfter(true); // 动画结束后, 停留在结束的位置上

		downAnimation = new RotateAnimation(-180f, -360f,
				Animation.RELATIVE_TO_SELF, 0.5f, Animation.RELATIVE_TO_SELF,
				0.5f);
		downAnimation.setDuration(500);
		downAnimation.setFillAfter(true); // 动画结束后, 停留在结束的位置上
	}

	@Override
	public boolean onTouchEvent(MotionEvent ev) {
		switch (ev.getAction()) {
			case MotionEvent.ACTION_DOWN :
				downY = (int) ev.getY();
				break;
			case MotionEvent.ACTION_MOVE :
				int moveY = (int) ev.getY();
				// 移动中的y - 按下的y = 间距.
				int diff = (moveY - downY) / 2;
				// -头布局的高度 + 间距 = paddingTop
				int paddingTop = -headerViewHeight + diff;
				// 如果: -头布局的高度 > paddingTop的值 执行super.onTouchEvent(ev);
				if (firstVisibleItemPosition == 0
						&& -headerViewHeight < paddingTop) {
					if (paddingTop > 0 && currentState == DOWN_PULL_REFRESH) { // 完全显示了.
						Log.i(TAG, "松开刷新");
						currentState = RELEASE_REFRESH;
						refreshHeaderView();
					} else if (paddingTop < 0
							&& currentState == RELEASE_REFRESH) { // 没有显示完全
						Log.i(TAG, "下拉刷新");
						currentState = DOWN_PULL_REFRESH;
						refreshHeaderView();
					}
					// 下拉头布局
					headerView.setPadding(0, paddingTop, 0, 0);
					return true;
				}
				break;
			case MotionEvent.ACTION_UP :
				// 判断当前的状态是松开刷新还是下拉刷新
				if (currentState == RELEASE_REFRESH) {
					Log.i(TAG, "刷新数据.");
					// 把头布局设置为完全显示状态
					headerView.setPadding(0, 0, 0, 0);
					// 进入到正在刷新中状态
					currentState = REFRESHING;
					refreshHeaderView();

					if (mOnRefershListener != null) {
						mOnRefershListener.onDownPullRefresh(); // 调用使用者的监听方法
					}
				} else if (currentState == DOWN_PULL_REFRESH) {
					// 隐藏头布局
					headerView.setPadding(0, -headerViewHeight, 0, 0);
				}
				break;
			default :
				break;
		}
		return super.onTouchEvent(ev);
	}

	/**
	 * 根据currentState刷新头布局的状态
	 */
	private void refreshHeaderView() {
		switch (currentState) {
			case DOWN_PULL_REFRESH : // 下拉刷新状态
				tvState.setText("下拉刷新");
				ivArrow.startAnimation(downAnimation); // 执行向下旋转
				break;
			case RELEASE_REFRESH : // 松开刷新状态
				tvState.setText("松开刷新");
				ivArrow.startAnimation(upAnimation); // 执行向上旋转
				break;
			case REFRESHING : // 正在刷新中状态
				ivArrow.clearAnimation();
				ivArrow.setVisibility(View.GONE);
				mProgressBar.setVisibility(View.VISIBLE);
				tvState.setText("正在刷新中...");
				break;
			default :
				break;
		}
	}

	/**
	 * 当滚动状态改变时回调
	 */
	@Override
	public void onScrollStateChanged(AbsListView view, int scrollState) {

		if (scrollState == SCROLL_STATE_IDLE
				|| scrollState == SCROLL_STATE_FLING) {
			// 判断当前是否已经到了底部
			if (isScrollToBottom && !isLoadingMore) {
				isLoadingMore = true;
				// 当前到底部
				Log.i(TAG, "加载更多数据");
				footerView.setPadding(0, 0, 0, 0);
				this.setSelection(this.getCount());

				if (mOnRefershListener != null) {
					mOnRefershListener.onLoadingMore();
				}
			}
		}
	}

	/**
	 * 当滚动时调用
	 * 
	 * @param firstVisibleItem
	 *            当前屏幕显示在顶部的item的position
	 * @param visibleItemCount
	 *            当前屏幕显示了多少个条目的总数
	 * @param totalItemCount
	 *            ListView的总条目的总数
	 */
	@Override
	public void onScroll(AbsListView view, int firstVisibleItem,
			int visibleItemCount, int totalItemCount) {
		firstVisibleItemPosition = firstVisibleItem;

		if (getLastVisiblePosition() == (totalItemCount - 1)) {
			isScrollToBottom = true;
		} else {
			isScrollToBottom = false;
		}
	}

	/**
	 * 设置刷新监听事件
	 * 
	 * @param listener
	 */
	public void setOnRefreshListener(OnRefreshListener listener) {
		mOnRefershListener = listener;
	}

	/**
	 * 隐藏头布局
	 */
	public void hideHeaderView() {
		headerView.setPadding(0, -headerViewHeight, 0, 0);
		ivArrow.setVisibility(View.VISIBLE);
		mProgressBar.setVisibility(View.GONE);
		tvState.setText("下拉刷新");
		tvLastUpdateTime.setText("最后刷新时间: " + getLastUpdateTime());
		currentState = DOWN_PULL_REFRESH;
	}

	/**
	 * 隐藏脚布局
	 */
	public void hideFooterView() {
		footerView.setPadding(0, -footerViewHeight, 0, 0);
		isLoadingMore = false;
	}
}
        还有2个重要的问题就是，1.我们如何知道这个头布局的状态什么时候改变？显示，当我们将头布局完全拉下的时候，我们就应该改变头布局上面的一些描述的信息。那么，怎么判断这个头布局什么时候刷新状态呢？提供如下的算法供参考：
1，计算手指在屏幕中滑动的间距。
      移动中的Y轴坐标 - 按下的Y轴坐标 = 间距
2，计算头布局距离顶部的距离
      -头布局的高度 + 间距 = paddingTop
3，如果: -头布局的高度 > paddingTop的值 执行super.onTouchEvent(ev);手指继续滑动，头布局状态为“松开刷新”；
      如果：-头布局的高度 < paddingTop的值，返回true，头布局状态为“下拉刷新”
4，手指抬起的时候，刷新
       问题2是如何知道，脚布局滑动到了ListView的底部，即最后一个可见的item。我们可以借助 android.widget.AbsListView.OnScrollListener接口下的两个方法 onScrollStateChanged(AbsListView view, int scrollState)和 onScroll(AbsListView view, int firstVisibleItem,int visibleItemCount, int totalItemCount)，现在ListView滚动时被调用的onScroll()方法中，判断当前的Item是不是最后一个Item，如果是的话就标记一个boolean的状态值，然后在监听ListView滑动状态onScrollStateChanged方法中，判断状态 scrollState == SCROLL_STATE_IDLE|| scrollState == SCROLL_STATE_FLING；若是，就说明ListView滑动到了底部了，这是需要上拉加载更多的数据。详细请参考上面贴出的代码，带上注释去看，也很好理解。

4.为ListView添加回调函数

       上面的效果是实现了，主要就讲解了UI的实现，接下来，我们了解一下逻辑方法的东西。显然，这个ListView还不能动态的“下来刷新”和“上拉加载”，为什么呢？很简单啊，暂时还没有向外界暴露出一个设置数据的方法。为了实现这个能够动态实施数据更新的功能，我们需要写一个回调提供给其它的类使用，首先看一下这个回调的接口：
[java] view plain copy print ?
  1. public interface OnRefreshListener {  
  2.   
  3.     /** 
  4.      * 下拉刷新 
  5.      */  
  6.     void onDownPullRefresh();  
  7.   
  8.     /** 
  9.      * 上拉加载更多 
  10.      */  
  11.     void onLoadingMore();  
  12. }  
public interface OnRefreshListener {

	/**
	 * 下拉刷新
	 */
	void onDownPullRefresh();

	/**
	 * 上拉加载更多
	 */
	void onLoadingMore();
}
这个回调的接口定义了两个方法，分别是“下拉刷新”和“上拉加载”，然后还必须在ListView中暴露一个接口与外面的类链接，最好的方法就暴露公共方法，例如：
[java] view plain copy print ?
  1. public void setOnRefreshListener(OnRefreshListener listener) {  
  2.         mOnRefershListener = listener;  
  3.     }  
public void setOnRefreshListener(OnRefreshListener listener) {
		mOnRefershListener = listener;
	}
这样这个接口的对象就在ListView中建立了，我们只要拿着这个对象，就可以在相应的位置上调用该对象的“下拉刷新”“上拉加载”的方法了，不必在乎方法体是什么，因为具体实现的方式，具体的数据结构都是其他类中定义的，我们只要提供实现的方式即可。

5.使用这个自定义的ListView

       使用这个自定义的ListView特别简单的，这里不多说了，看代码：
[java] view plain copy print ?
  1. public class MainActivity extends Activity implements OnRefreshListener {  
  2.   
  3.     private List textList;  
  4.     private MyAdapter adapter;  
  5.     private RefreshListView rListView;  
  6.   
  7.     @Override  
  8.     protected void onCreate(Bundle savedInstanceState) {  
  9.         super.onCreate(savedInstanceState);  
  10.         setContentView(R.layout.activity_main);  
  11.   
  12.         rListView = (RefreshListView) findViewById(R.id.refreshlistview);  
  13.         textList = new ArrayList();  
  14.         for (int i = 0; i < 25; i++) {  
  15.             textList.add("这是一条ListView的数据" + i);  
  16.         }  
  17.         adapter = new MyAdapter();  
  18.         rListView.setAdapter(adapter);  
  19.         rListView.setOnRefreshListener(this);  
  20.     }  
  21.   
  22.     private class MyAdapter extends BaseAdapter {  
  23.   
  24.         @Override  
  25.         public int getCount() {  
  26.             // TODO Auto-generated method stub  
  27.             return textList.size();  
  28.         }  
  29.   
  30.         @Override  
  31.         public Object getItem(int position) {  
  32.             // TODO Auto-generated method stub  
  33.             return textList.get(position);  
  34.         }  
  35.   
  36.         @Override  
  37.         public long getItemId(int position) {  
  38.             // TODO Auto-generated method stub  
  39.             return position;  
  40.         }  
  41.   
  42.         @Override  
  43.         public View getView(int position, View convertView, ViewGroup parent) {  
  44.             // TODO Auto-generated method stub  
  45.             TextView textView = new TextView(MainActivity.this);  
  46.             textView.setText(textList.get(position));  
  47.             textView.setTextColor(Color.WHITE);  
  48.             textView.setTextSize(18.0f);  
  49.             return textView;  
  50.         }  
  51.   
  52.     }  
  53.   
  54.     @Override  
  55.     public void onDownPullRefresh() {  
  56.         new AsyncTask() {  
  57.   
  58.             @Override  
  59.             protected Void doInBackground(Void... params) {  
  60.                 SystemClock.sleep(2000);  
  61.                 for (int i = 0; i < 2; i++) {  
  62.                     textList.add(0, "这是下拉刷新出来的数据" + i);  
  63.                 }  
  64.                 return null;  
  65.             }  
  66.   
  67.             @Override  
  68.             protected void onPostExecute(Void result) {  
  69.                 adapter.notifyDataSetChanged();  
  70.                 rListView.hideHeaderView();  
  71.             }  
  72.         }.execute(new Void[]{});  
  73.     }  
  74.   
  75.     @Override  
  76.     public void onLoadingMore() {  
  77.         new AsyncTask() {  
  78.   
  79.             @Override  
  80.             protected Void doInBackground(Void... params) {  
  81.                 SystemClock.sleep(5000);  
  82.   
  83.                 textList.add("这是加载更多出来的数据1");  
  84.                 textList.add("这是加载更多出来的数据2");  
  85.                 textList.add("这是加载更多出来的数据3");  
  86.                 return null;  
  87.             }  
  88.   
  89.             @Override  
  90.             protected void onPostExecute(Void result) {  
  91.                 adapter.notifyDataSetChanged();  
  92.   
  93.                 // 控制脚布局隐藏  
  94.                 rListView.hideFooterView();  
  95.             }  
  96.         }.execute(new Void[]{});  
  97.     }  
  98.   
  99. }  
public class MainActivity extends Activity implements OnRefreshListener {

	private List textList;
	private MyAdapter adapter;
	private RefreshListView rListView;

	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);

		rListView = (RefreshListView) findViewById(R.id.refreshlistview);
		textList = new ArrayList();
		for (int i = 0; i < 25; i++) {
			textList.add("这是一条ListView的数据" + i);
		}
		adapter = new MyAdapter();
		rListView.setAdapter(adapter);
		rListView.setOnRefreshListener(this);
	}

	private class MyAdapter extends BaseAdapter {

		@Override
		public int getCount() {
			// TODO Auto-generated method stub
			return textList.size();
		}

		@Override
		public Object getItem(int position) {
			// TODO Auto-generated method stub
			return textList.get(position);
		}

		@Override
		public long getItemId(int position) {
			// TODO Auto-generated method stub
			return position;
		}

		@Override
		public View getView(int position, View convertView, ViewGroup parent) {
			// TODO Auto-generated method stub
			TextView textView = new TextView(MainActivity.this);
			textView.setText(textList.get(position));
			textView.setTextColor(Color.WHITE);
			textView.setTextSize(18.0f);
			return textView;
		}

	}

	@Override
	public void onDownPullRefresh() {
		new AsyncTask() {

			@Override
			protected Void doInBackground(Void... params) {
				SystemClock.sleep(2000);
				for (int i = 0; i < 2; i++) {
					textList.add(0, "这是下拉刷新出来的数据" + i);
				}
				return null;
			}

			@Override
			protected void onPostExecute(Void result) {
				adapter.notifyDataSetChanged();
				rListView.hideHeaderView();
			}
		}.execute(new Void[]{});
	}

	@Override
	public void onLoadingMore() {
		new AsyncTask() {

			@Override
			protected Void doInBackground(Void... params) {
				SystemClock.sleep(5000);

				textList.add("这是加载更多出来的数据1");
				textList.add("这是加载更多出来的数据2");
				textList.add("这是加载更多出来的数据3");
				return null;
			}

			@Override
			protected void onPostExecute(Void result) {
				adapter.notifyDataSetChanged();

				// 控制脚布局隐藏
				rListView.hideFooterView();
			}
		}.execute(new Void[]{});
	}

}
我们模拟的是联网更新数据，所以必须要开启新的线程去获取数据，联网获取数据的方式有很多种，我这里使用的Android为我们提供好的AsyncTask轻量型的框架，关于这个框架，在下面有一些简单的介绍。

6.AsyncTask简单介绍

先来看看AsyncTask的定义：
[java] view plain copy print ?
  1. public abstract class AsyncTask {  
public abstract class AsyncTask {

三种泛型类型分别代表

Params ：“启动任务执行的输入参数”，Progress：“后台任务执行的进度”，Result：“后台计算结果的类型”。在特定场合下，并不是所有类型都被使用，如果没有被使用，可以用java.lang.Void类型代替。

一个异步任务的执行一般包括以下几个步骤：

1.execute(Params... params)，执行一个异步任务，需要我们在代码中调用此方法，触发异步任务的执行。

2.onPreExecute()，在execute(Params... params)被调用后立即执行，一般用来在执行后台任务前对UI做一些标记。

3.doInBackground(Params... params)，在onPreExecute()完成后立即执行，用于执行较为费时的操作，此方法将接收输入参数和返回计算结果。在执行过程中可以调用publishProgress(Progress... values)来更新进度信息。

4.onProgressUpdate(Progress... values)，在调用publishProgress(Progress... values)时，此方法被执行，直接将进度信息更新到UI组件上。

5.onPostExecute(Result result)，当后台操作结束时，此方法将会被调用，计算结果将做为参数传递到此方法中，直接将结果显示到UI组件上。

下面是一个图解：



通过这个草图，我们可以分析出AsyncTask三个泛型参数的用处，1，第一个泛型参数Params就是execute()方法中的参数，这二者要保持一致，因为这个参数Params会直接传递给doInBackground(Params...params)方法中，作为这个方法的参数存在。2，第二个参数Progress代表任务执行的进度，通常设定为Void类型，不使用它。3，第三个参数Result代表的是doInBackground()方法的返回值类型，这个返回值类型决定该方法在子线程中获取的是什么类型的数据，并且获取到的数据将被传递给onPostExecute()方法中作为参数，就是程序执行的结果，在该方法中拿到这个结果在UI上实现数据更新。
       以上是对AsyncTask的简单介绍，没有深入，想要深入了解AsyncTask，请移步到以下这两篇博客中。
详解Android中AsyncTask的使用
Android AsyncTask完全解析，带你从源码的角度彻底理解

源码请在这里下载
 
http://blog.csdn.net/leehong2005/article/details/12567757

前段时间项目中用到了下拉刷新功能，之前在网上也找到过类似的demo，但这些demo的质量参差不齐，用户体验也不好，接口设计也不行。最张没办法，终于忍不了了，自己就写了一个下拉刷新的框架，这个框架是一个通用的框架，效果和设计感觉都还不错，现在分享给各位看官。

致谢：

1. 感谢lk6233160同学提出的问题，旋转View时调用setRotation方法只能是在API Level11（3.0）以上才能用，这个问题的解决办法是给ImageView设置一个Matrix，把Matrix上面作用一个旋转矩阵，但是如果不是ImageView的话，可能实现起来比较麻烦，再次谢谢lk6233160同学。

2. 谢谢如毛毛风提出的问题，向下滑动后，再向上滑动到头，只能再松手后才能再次下拉。这个问题的回复请参考评论。

技术交流群：

QQ：197990971（人员已满）


1. 关于下拉刷新

下拉刷新这种用户交互最早由twitter创始人洛伦•布里切特(Loren Brichter)发明， 有理论认为，下拉刷新是一种适用于按照从新到旧的时间顺序排列feeds的应用，在这种应用场景中看完旧的内容时，用户会很自然地下拉查找更新的内容，因此下拉刷新就显得非常合理。大家可以参考这篇文章： 有趣的下拉刷新，下面我贴出一个有趣的下拉刷新的案例。

图一、有趣的下拉刷新案例（一）


图一、有趣的下拉刷新案例（二）


2. 实现原理

上面这些例子，外观做得再好看，他的本质上都一样，那就是一个下拉刷新控件通常由以下几部分组成：
【1】Header
Header通常有下拉箭头，文字，进度条等元素，根据下拉的距离来改变它的状态，从而显示不同的样式
【2】Content
这部分是内容区域，网上有很多例子都是直接在ListView里面添加Header，但这就有局限性，因为好多情况下并不一定是用ListView来显示数据。我们把要显示内容的View放置在我们的一个容器中，如果你想实现一个用ListView显示数据的下拉刷新，你需要创建一个ListView旋转到我的容器中。我们处理这个容器的事件（down, move, up），如果向下拉，则把整个布局向下滑动，从而把header显示出来。
【3】Footer
Footer可以用来显示向上拉的箭头，自动加载更多的进度条等。

以上三部分总结的说来，就是如下图所示的这种布局结构：
图三，下拉刷新的布局结构

关于上图，需要说明几点：
1、这个布局扩展于 LinearLayout，垂直排列
2、从上到下的顺序是：Header, Content, Footer
3、Content填充满父控件，通过设置top, bottom的padding来使Header和Footer不可见，也就是让它超出屏幕外
4、下拉时，调用scrollTo方法来将整个布局向下滑动，从而把Header显示出来，上拉正好与下拉相反。
5、派生类需要实现的是：将Content View填充到父容器中，比如，如果你要使用的话，那么你需要把ListView, ScrollView, WebView等添加到容器中。
6、上图中的红色区域就是屏的大小（严格来说，这里说屏幕大小并不准确，应该说成内容区域更加准确）

3. 具体实现

明白了实现原理与过程，我们尝试来具体实现，首先，为了以后更好地扩展，设计更加合理，我们把下拉刷新的功能抽象成一个接口：

1、IPullToRefresh

它具体的定义方法如下：
[java] view plain copy print ?
  1. public interface IPullToRefreshextends View> {  
  2.     public void setPullRefreshEnabled(boolean pullRefreshEnabled);  
  3.     public void setPullLoadEnabled(boolean pullLoadEnabled);  
  4.     public void setScrollLoadEnabled(boolean scrollLoadEnabled);  
  5.     public boolean isPullRefreshEnabled();  
  6.     public boolean isPullLoadEnabled();  
  7.     public boolean isScrollLoadEnabled();  
  8.     public void setOnRefreshListener(OnRefreshListener refreshListener);  
  9.     public void onPullDownRefreshComplete();  
  10.     public void onPullUpRefreshComplete();  
  11.     public T getRefreshableView();  
  12.     public LoadingLayout getHeaderLoadingLayout();  
  13.     public LoadingLayout getFooterLoadingLayout();  
  14.     public void setLastUpdatedLabel(CharSequence label);  
  15. }  
public interface IPullToRefresh {
    public void setPullRefreshEnabled(boolean pullRefreshEnabled);
    public void setPullLoadEnabled(boolean pullLoadEnabled);
    public void setScrollLoadEnabled(boolean scrollLoadEnabled);
    public boolean isPullRefreshEnabled();
    public boolean isPullLoadEnabled();
    public boolean isScrollLoadEnabled();
    public void setOnRefreshListener(OnRefreshListener refreshListener);
    public void onPullDownRefreshComplete();
    public void onPullUpRefreshComplete();
    public T getRefreshableView();
    public LoadingLayout getHeaderLoadingLayout();
    public LoadingLayout getFooterLoadingLayout();
    public void setLastUpdatedLabel(CharSequence label);
}
这个接口是一个泛型的，它接受View的派生类， 因为要放到我们的容器中的不就是一个View吗？

2、PullToRefreshBase
这个类实现了IPullToRefresh接口，它是从LinearLayout继承过来，作为下拉刷新的一个 抽象基类，如果你想实现ListView的下拉刷新，只需要扩展这个类，实现一些必要的方法就可以了。这个类的职责主要有以下几点：
  • 处理onInterceptTouchEvent()和onTouchEvent()中的事件：当内容的View（比如ListView）正如处于最顶部，此时再向下拉，我们必须截断事件，然后move事件就会把后续的事件传递到onTouchEvent()方法中，然后再在这个方法中，我们根据move的距离再进行scroll整个View。
  • 负责创建Header、Footer和Content View：在构造方法中调用方法去创建这三个部分的View，派生类可以重写这些方法，以提供不同式样的Header和Footer，它会调用createHeaderLoadingLayout和createFooterLoadingLayout方法来创建Header和Footer创建Content View的方法是一个抽象方法，必须让派生类来实现，返回一个非null的View，然后容器再把这个View添加到自己里面。
  • 设置各种状态：这里面有很多状态，如下拉、上拉、刷新、加载中、释放等，它会根据用户拉动的距离来更改状态，状态的改变，它也会把Header和Footer的状态改变，然后Header和Footer会根据状态去显示相应的界面式样。
3、PullToRefreshBase继承关系
这里我实现了三个下拉刷新的派生类，分别是ListView、ScrollView、WebView三个，它们的继承关系如下：

图四、PullToRefreshBase类的继承关系

关于PullToRefreshBase类及其派和类，有几点需要说明：
  • 对于ListView，ScrollView，WebView这三种情况，他们是否滑动到最顶部或是最底部的实现是不一样的，所以，在PullToRefreshBase类中需要调用两个抽象方法来判断当前的位置是否在顶部或底部，而其派生类必须要实现这两个方法。比如对于ListView，它滑动到最顶部的条件就是第一个child完全可见并且first postion是0。这两个抽象方法是：
[java] view plain copy print ?
  1. /** 
  2.  * 判断刷新的View是否滑动到顶部 
  3.  *  
  4.  * @return true表示已经滑动到顶部，否则false 
  5.  */  
  6. protected abstract boolean isReadyForPullDown();  
  7.   
  8. /** 
  9.  * 判断刷新的View是否滑动到底 
  10.  *  
  11.  * @return true表示已经滑动到底部，否则false 
  12.  */  
  13. protected abstract boolean isReadyForPullUp();  
    /**
     * 判断刷新的View是否滑动到顶部
     * 
     * @return true表示已经滑动到顶部，否则false
     */
    protected abstract boolean isReadyForPullDown();
    
    /**
     * 判断刷新的View是否滑动到底
     * 
     * @return true表示已经滑动到底部，否则false
     */
    protected abstract boolean isReadyForPullUp();
  • 创建可下拉刷新的View（也就是content view）的抽象方法是
[java] view plain copy print ?
  1. /** 
  2.  * 创建可以刷新的View 
  3.  *  
  4.  * @param context context 
  5.  * @param attrs 属性 
  6.  * @return View 
  7.  */  
  8. protected abstract T createRefreshableView(Context context, AttributeSet attrs);  
    /**
     * 创建可以刷新的View
     * 
     * @param context context
     * @param attrs 属性
     * @return View
     */
    protected abstract T createRefreshableView(Context context, AttributeSet attrs);
4、LoadingLayout
LoadingLayout是刷新Layout的一个抽象，它是一个抽象基类。Header和Footer都扩展于这个类。这类抽象类，提供了两个抽象方法：
  • getContentSize
这个方法返回当前这个刷新Layout的大小，通常返回的是布局的高度，为了以后可以扩展为水平拉动，所以方法名字没有取成getLayoutHeight()之类的，这个返回值，将会作为松手后是否可以刷新的临界值，如果下拉的偏移值大于这个值，就认为可以刷新，否则不刷新，这个方法必须由派生类来实现。
  • setState
这个方法用来设置当前刷新Layout的状态，PullToRefreshBase类会调用这个方法，当进入下拉，松手等动作时，都会调用这个方法，派生类里面只需要根据这些状态实现不同的界面显示，如下拉状态时，就显示出箭头，刷新状态时，就显示loading的图标。
可能的状态值有： RESET, PULL_TO_REFRESH, RELEASE_TO_REFRESH, REFRESHING, NO_MORE_DATA

LoadingLayout及其派生类的继承关系如下图所示：

图五、LoadingLayout及其派生类的类图

我们可以随意地制定自己的Header和Footer，我们也可以实现如图一和图二中显示的各种下拉刷新案例中的Header和Footer，只要重写上述两个方法getContentSize()和setState()就行了。HeaderLoadingLayout，它默认是显示箭头式样的布局，而RotateLoadingLayout则是显示一个旋转图标的式样。

5、事件处理
我们必须重写PullToRefreshBase类的两个事件相关的方法 onInterceptTouchEvent()和onTouchEvent()方法。由于ListView，ScrollView，WebView它们是放到PullToRefreshBase内部的，所在事件先是传递到PullToRefreshBase#onInterceptTouchEvent()方法中，所以我们应该在这个方法中去处理ACTION_MOVE事件，判断如果当前ListView，ScrollView，WebView是否在最顶部或最底部，如果是，则开始截断事件，一旦事件被截断，后续的事件就会传递到PullToRefreshBase#onInterceptTouchEvent()方法中，我们再在ACTION_MOVE事件中去移动整个布局，从而实现下拉或上拉动作。

6、滚动布局(scrollTo)
如图三的布局结构可知，默认情况下Header和Footer是放置在Content View的最上面和最下面，通过设置padding来让他跑到屏幕外面去了，如果我们将整个布局向下滚动(scrollTo)一定距离，那么Header就会被显示出来，基于这种情况，所以在我的实现中，最终我是调用 scrollTo来实现下拉动作的。

总的说来，实现的重要的点就这些，具体的一些细节在实现在会碰到很多，可以参考代码。

4. 如何使用

使用下拉刷新的代码如下
[java] view plain copy print ?
  1. @Override  
  2.     public void onCreate(Bundle savedInstanceState) {  
  3.         super.onCreate(savedInstanceState);  
  4.           
  5.         mPullListView = new PullToRefreshListView(this);  
  6.         setContentView(mPullListView);  
  7.           
  8.         // 上拉加载不可用  
  9.         mPullListView.setPullLoadEnabled(false);  
  10.         // 滚动到底自动加载可用  
  11.         mPullListView.setScrollLoadEnabled(true);  
  12.           
  13.         mCurIndex = mLoadDataCount;  
  14.         mListItems = new LinkedList();  
  15.         mListItems.addAll(Arrays.asList(mStrings).subList(0, mCurIndex));  
  16.         mAdapter = new ArrayAdapter(this, android.R.layout.simple_list_item_1, mListItems);  
  17.           
  18.         // 得到实际的ListView  
  19.         mListView = mPullListView.getRefreshableView();  
  20.         // 绑定数据  
  21.         mListView.setAdapter(mAdapter);         
  22.         // 设置下拉刷新的listener  
  23.         mPullListView.setOnRefreshListener(new OnRefreshListener() {  
  24.             @Override  
  25.             public void onPullDownToRefresh(PullToRefreshBase refreshView) {  
  26.                 mIsStart = true;  
  27.                 new GetDataTask().execute();  
  28.             }  
  29.   
  30.             @Override  
  31.             public void onPullUpToRefresh(PullToRefreshBase refreshView) {  
  32.                 mIsStart = false;  
  33.                 new GetDataTask().execute();  
  34.             }  
  35.         });  
  36.         setLastUpdateTime();  
  37.           
  38.         // 自动刷新  
  39.         mPullListView.doPullRefreshing(true, 500);  
  40.     }  
@Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        
        mPullListView = new PullToRefreshListView(this);
        setContentView(mPullListView);
        
        // 上拉加载不可用
        mPullListView.setPullLoadEnabled(false);
        // 滚动到底自动加载可用
        mPullListView.setScrollLoadEnabled(true);
        
        mCurIndex = mLoadDataCount;
        mListItems = new LinkedList();
        mListItems.addAll(Arrays.asList(mStrings).subList(0, mCurIndex));
        mAdapter = new ArrayAdapter(this, android.R.layout.simple_list_item_1, mListItems);
        
        // 得到实际的ListView
        mListView = mPullListView.getRefreshableView();
        // 绑定数据
        mListView.setAdapter(mAdapter);       
        // 设置下拉刷新的listener
        mPullListView.setOnRefreshListener(new OnRefreshListener() {
            @Override
            public void onPullDownToRefresh(PullToRefreshBase refreshView) {
                mIsStart = true;
                new GetDataTask().execute();
            }

            @Override
            public void onPullUpToRefresh(PullToRefreshBase refreshView) {
                mIsStart = false;
                new GetDataTask().execute();
            }
        });
        setLastUpdateTime();
        
        // 自动刷新
        mPullListView.doPullRefreshing(true, 500);
    }
这是初始化一个下拉刷新的布局，并且调用setContentView来设置到Activity中。
在下拉刷新完成后，我们可以调用 onPullDownRefreshComplete()和onPullUpRefreshComplete()方法来停止刷新和加载

5. 运行效果

这里列出了demo的运行效果图。

图六、ListView下拉刷新，注意Header和Footer的样式


图七、WebView和ScrollView的下拉刷新效果图


6. 源码下载

实现这个下拉刷新的框架，并不是我的原创，我也是参考了很多开源的，把我认为比较好的东西借鉴过来，从而形成我的东西，我主要是参考了下面这个demo：
https://github.com/chrisbanes/Android-PullToRefresh 这个demo写得不错，不过他这个太复杂了，我们都知道，一旦复杂了，万一我们要添加一些需要，自然也要费劲一些，我其实就是把他的简化再简化，以满足我们自己的需要。

源码下载请猛点我

转载请说明出处
http://blog.csdn.net/leehong2005/article/details/12567757 
谢谢！！！


7. Bug修复
已知bug修复情况如下，发现了代码bug的看官也可以给我反馈，谢谢~~~

1，对于ListView的下拉刷新，当启用滚动到底自动加载时，如果footer由隐藏变为显示时，出现显示异常的情况
这个问题已经修复了，修正的代码如下：
  • PullToRefreshListView#setScrollLoadEnabled方法，修正后的代码如下：
[java] view plain copy print ?
  1. @Override  
  2. public void setScrollLoadEnabled(boolean scrollLoadEnabled) {  
  3.     if (isScrollLoadEnabled() == scrollLoadEnabled) {  
  4.         return;  
  5.     }  
  6.       
  7.     super.setScrollLoadEnabled(scrollLoadEnabled);  
  8.       
  9.     if (scrollLoadEnabled) {  
  10.         // 设置Footer  
  11.         if (null == mLoadMoreFooterLayout) {  
  12.             mLoadMoreFooterLayout = new FooterLoadingLayout(getContext());  
  13.             mListView.addFooterView(mLoadMoreFooterLayout, null, false);  
  14.         }  
  15.           
  16.         mLoadMoreFooterLayout.show(true);  
  17.     } else {  
  18.         if (null != mLoadMoreFooterLayout) {  
  19.             mLoadMoreFooterLayout.show(false);  
  20.         }  
  21.     }  
  22. }  
    @Override
    public void setScrollLoadEnabled(boolean scrollLoadEnabled) {
        if (isScrollLoadEnabled() == scrollLoadEnabled) {
            return;
        }
        
        super.setScrollLoadEnabled(scrollLoadEnabled);
        
        if (scrollLoadEnabled) {
            // 设置Footer
            if (null == mLoadMoreFooterLayout) {
                mLoadMoreFooterLayout = new FooterLoadingLayout(getContext());
                mListView.addFooterView(mLoadMoreFooterLayout, null, false);
            }
            
            mLoadMoreFooterLayout.show(true);
        } else {
            if (null != mLoadMoreFooterLayout) {
                mLoadMoreFooterLayout.show(false);
            }
        }
    }
  • LoadingLayout#show方法，修正后的代码如下：
[java] view plain copy print ?
  1. /** 
  2.  * 显示或隐藏这个布局 
  3.  *  
  4.  * @param show flag 
  5.  */  
  6. public void show(boolean show) {  
  7.     // If is showing, do nothing.  
  8.     if (show == (View.VISIBLE == getVisibility())) {  
  9.         return;  
  10.     }  
  11.       
  12.     ViewGroup.LayoutParams params = mContainer.getLayoutParams();  
  13.     if (null != params) {  
  14.         if (show) {  
  15.             params.height = ViewGroup.LayoutParams.WRAP_CONTENT;  
  16.         } else {  
  17.             params.height = 0;  
  18.         }  
  19.           
  20.         requestLayout();  
  21.         setVisibility(show ? View.VISIBLE : View.INVISIBLE);  
  22.     }  
  23. }  
    /**
     * 显示或隐藏这个布局
     * 
     * @param show flag
     */
    public void show(boolean show) {
        // If is showing, do nothing.
        if (show == (View.VISIBLE == getVisibility())) {
            return;
        }
        
        ViewGroup.LayoutParams params = mContainer.getLayoutParams();
        if (null != params) {
            if (show) {
                params.height = ViewGroup.LayoutParams.WRAP_CONTENT;
            } else {
                params.height = 0;
            }
            
            requestLayout();
            setVisibility(show ? View.VISIBLE : View.INVISIBLE);
        }
    }
在更改LayoutParameter后，调用requestLayout()方法。
  • 图片旋转兼容2.x系统
我之前想的是这个只需要兼容3.x以上的系统，但发现有很多网友在使用过程中遇到过兼容性问题，这次抽空将这个兼容性一并实现了。
       onPull的修改如下：
[java] view plain copy print ?
  1. @Override  
  2. public void onPull(float scale) {  
  3.     if (null == mRotationHelper) {  
  4.         mRotationHelper = new ImageViewRotationHelper(mArrowImageView);  
  5.     }  
  6.       
  7.     float angle = scale * 180f; // SUPPRESS CHECKSTYLE  
  8.     mRotationHelper.setRotation(angle);  
  9. }  
    @Override
    public void onPull(float scale) {
        if (null == mRotationHelper) {
            mRotationHelper = new ImageViewRotationHelper(mArrowImageView);
        }
        
        float angle = scale * 180f; // SUPPRESS CHECKSTYLE
        mRotationHelper.setRotation(angle);
    }

ImageViewRotationHelper主要的作用就是实现了ImageView的旋转功能，内部作了版本的区分，实现代码如下：

[java] view plain copy print ?
  1. /** 
  2.      * The image view rotation helper 
  3.      *  
  4.      * @author lihong06 
  5.      * @since 2014-5-2 
  6.      */  
  7.     static class ImageViewRotationHelper {  
  8.         /** The imageview */  
  9.         private final ImageView mImageView;  
  10.         /** The matrix */  
  11.         private Matrix mMatrix;  
  12.         /** Pivot X */  
  13.         private float mRotationPivotX;  
  14.         /** Pivot Y */  
  15.         private float mRotationPivotY;  
  16.           
  17.         /** 
  18.          * The constructor method. 
  19.          *  
  20.          * @param imageView the image view 
  21.          */  
  22.         public ImageViewRotationHelper(ImageView imageView) {  
  23.             mImageView = imageView;  
  24.         }  
  25.           
  26.         /** 
  27.          * Sets the degrees that the view is rotated around the pivot point. Increasing values 
  28.          * result in clockwise rotation. 
  29.          * 
  30.          * @param rotation The degrees of rotation. 
  31.          * 
  32.          * @see #getRotation() 
  33.          * @see #getPivotX() 
  34.          * @see #getPivotY() 
  35.          * @see #setRotationX(float) 
  36.          * @see #setRotationY(float) 
  37.          * 
  38.          * @attr ref android.R.styleable#View_rotation 
  39.          */  
  40.         public void setRotation(float rotation) {  
  41.             if (APIUtils.hasHoneycomb()) {  
  42.                 mImageView.setRotation(rotation);  
  43.             } else {  
  44.                 if (null == mMatrix) {  
  45.                     mMatrix = new Matrix();  
  46.                       
  47.                     // 计算旋转的中心点  
  48.                     Drawable imageDrawable = mImageView.getDrawable();  
  49.                     if (null != imageDrawable) {  
  50.                         mRotationPivotX = Math.round(imageDrawable.getIntrinsicWidth() / 2f);  
  51.                         mRotationPivotY = Math.round(imageDrawable.getIntrinsicHeight() / 2f);  
  52.                     }  
  53.                 }  
  54.                   
  55.                 mMatrix.setRotate(rotation, mRotationPivotX, mRotationPivotY);  
  56.                 mImageView.setImageMatrix(mMatrix);  
  57.             }  
  58.         }  
  59.     }  
/**
     * The image view rotation helper
     * 
     * @author lihong06
     * @since 2014-5-2
     */
    static class ImageViewRotationHelper {
        /** The imageview */
        private final ImageView mImageView;
        /** The matrix */
        private Matrix mMatrix;
        /** Pivot X */
        private float mRotationPivotX;
        /** Pivot Y */
        private float mRotationPivotY;
        
        /**
         * The constructor method.
         * 
         * @param imageView the image view
         */
        public ImageViewRotationHelper(ImageView imageView) {
            mImageView = imageView;
        }
        
        /**
         * Sets the degrees that the view is rotated around the pivot point. Increasing values
         * result in clockwise rotation.
         *
         * @param rotation The degrees of rotation.
         *
         * @see #getRotation()
         * @see #getPivotX()
         * @see #getPivotY()
         * @see #setRotationX(float)
         * @see #setRotationY(float)
         *
         * @attr ref android.R.styleable#View_rotation
         */
        public void setRotation(float rotation) {
            if (APIUtils.hasHoneycomb()) {
                mImageView.setRotation(rotation);
            } else {
                if (null == mMatrix) {
                    mMatrix = new Matrix();
                    
                    // 计算旋转的中心点
                    Drawable imageDrawable = mImageView.getDrawable();
                    if (null != imageDrawable) {
                        mRotationPivotX = Math.round(imageDrawable.getIntrinsicWidth() / 2f);
                        mRotationPivotY = Math.round(imageDrawable.getIntrinsicHeight() / 2f);
                    }
                }
                
                mMatrix.setRotate(rotation, mRotationPivotX, mRotationPivotY);
                mImageView.setImageMatrix(mMatrix);
            }
        }
    }

最核心的就是，如果在2.x的版本上，旋转ImageView使用Matrix。

  • PullToRefreshBase构造方法兼容2.x
在三个参数的构造方法声明如下标注：
    @SuppressLint("NewApi")
    @TargetApi(Build.VERSION_CODES.HONEYCOMB)
 
 

转载请注明出处：http://blog.csdn.net/guolin_blog/article/details/9255575

最近项目中需要用到ListView下拉刷新的功能，一开始想图省事，在网上直接找一个现成的，可是尝试了网上多个版本的下拉刷新之后发现效果都不怎么理想。有些是因为功能不完整或有Bug，有些是因为使用起来太复杂，十全十美的还真没找到。因此我也是放弃了在网上找现成代码的想法，自己花功夫编写了一种非常简单的下拉刷新实现方案，现在拿出来和大家分享一下。相信在阅读完本篇文章之后，大家都可以在自己的项目中一分钟引入下拉刷新功能。

首先讲一下实现原理。这里我们将采取的方案是使用组合View的方式，先自定义一个布局继承自LinearLayout，然后在这个布局中加入下拉头和ListView这两个子元素，并让这两个子元素纵向排列。初始化的时候，让下拉头向上偏移出屏幕，这样我们看到的就只有ListView了。然后对ListView的touch事件进行监听，如果当前ListView已经滚动到顶部并且手指还在向下拉的话，那就将下拉头显示出来，松手后进行刷新操作，并将下拉头隐藏。原理示意图如下：

                            

那我们现在就来动手实现一下，新建一个项目起名叫PullToRefreshTest，先在项目中定义一个下拉头的布局文件pull_to_refresh.xml，代码如下所示：

[html] view plain copy print ?
  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" >  
  6.   
  7.     <LinearLayout  
  8.         android:layout_width="200dip"  
  9.         android:layout_height="60dip"  
  10.         android:layout_centerInParent="true"  
  11.         android:orientation="horizontal" >  
  12.   
  13.         <RelativeLayout  
  14.             android:layout_width="0dip"  
  15.             android:layout_height="60dip"  
  16.             android:layout_weight="3"  
  17.             >  
  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"  
  24.                 />  
  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.                 />  
  32.         RelativeLayout>  
  33.   
  34.         <LinearLayout  
  35.             android:layout_width="0dip"  
  36.             android:layout_height="60dip"  
  37.             android:layout_weight="12"  
  38.             android:orientation="vertical" >  
  39.   
  40.             <TextView  
  41.                 android:id="@+id/description"  
  42.                 android:layout_width="fill_parent"  
  43.                 android:layout_height="0dip"  
  44.                 android:layout_weight="1"  
  45.                 android:gravity="center_horizontal|bottom"  
  46.                 android:text="@string/pull_to_refresh" />  
  47.   
  48.             <TextView  
  49.                 android:id="@+id/updated_at"  
  50.                 android:layout_width="fill_parent"  
  51.                 android:layout_height="0dip"  
  52.                 android:layout_weight="1"  
  53.                 android:gravity="center_horizontal|top"  
  54.                 android:text="@string/updated_at" />  
  55.         LinearLayout>  
  56.     LinearLayout>  
  57.   
  58. RelativeLayout>  
在这个布局中，我们包含了一个下拉指示箭头，一个下拉状态文字提示，和一个上次更新的时间。当然，还有一个隐藏的旋转进度条，只有正在刷新的时候我们才会将它显示出来。
布局中所有引用的字符串我们都放在strings.xml中，如下所示:
[html] view plain copy print ?
  1. xml version="1.0" encoding="utf-8"?>  
  2. <resources>  
  3.   
  4.     <string name="app_name">PullToRefreshTeststring>  
  5.     <string name="pull_to_refresh">下拉可以刷新string>  
  6.     <string name="release_to_refresh">释放立即刷新string>  
  7.     <string name="refreshing">正在刷新…string>  
  8.     <string name="not_updated_yet">暂未更新过string>  
  9.     <string name="updated_at">上次更新于%1$s前string>  
  10.     <string name="updated_just_now">刚刚更新string>  
  11.     <string name="time_error">时间有问题string>  
  12.       
  13. resources>  



    PullToRefreshTest
	下拉可以刷新
	释放立即刷新
	正在刷新…
	暂未更新过
	上次更新于%1$s前
	刚刚更新
	时间有问题
然后新建一个RefreshableView继承自LinearLayout，代码如下所示：
[java] view plain copy print ?
  1. public class RefreshableView extends LinearLayout implements OnTouchListener {  
  2.   
  3.     /** 
  4.      * 下拉状态 
  5.      */  
  6.     public static final int STATUS_PULL_TO_REFRESH = 0;  
  7.   
  8.     /** 
  9.      * 释放立即刷新状态 
  10.      */  
  11.     public static final int STATUS_RELEASE_TO_REFRESH = 1;  
  12.   
  13.     /** 
  14.      * 正在刷新状态 
  15.      */  
  16.     public static final int STATUS_REFRESHING = 2;  
  17.   
  18.     /** 
  19.      * 刷新完成或未刷新状态 
  20.      */  
  21.     public static final int STATUS_REFRESH_FINISHED = 3;  
  22.   
  23.     /** 
  24.      * 下拉头部回滚的速度 
  25.      */  
  26.     public static final int SCROLL_SPEED = -20;  
  27.   
  28.     /** 
  29.      * 一分钟的毫秒值，用于判断上次的更新时间 
  30.      */  
  31.     public static final long ONE_MINUTE = 60 * 1000;  
  32.   
  33.     /** 
  34.      * 一小时的毫秒值，用于判断上次的更新时间 
  35.      */  
  36.     public static final long ONE_HOUR = 60 * ONE_MINUTE;  
  37.   
  38.     /** 
  39.      * 一天的毫秒值，用于判断上次的更新时间 
  40.      */  
  41.     public static final long ONE_DAY = 24 * ONE_HOUR;  
  42.   
  43.     /** 
  44.      * 一月的毫秒值，用于判断上次的更新时间 
  45.      */  
  46.     public static final long ONE_MONTH = 30 * ONE_DAY;  
  47.   
  48.     /** 
  49.      * 一年的毫秒值，用于判断上次的更新时间 
  50.      */  
  51.     public static final long ONE_YEAR = 12 * ONE_MONTH;  
  52.   
  53.     /** 
  54.      * 上次更新时间的字符串常量，用于作为SharedPreferences的键值 
  55.      */  
  56.     private static final String UPDATED_AT = "updated_at";  
  57.   
  58.     /** 
  59.      * 下拉刷新的回调接口 
  60.      */  
  61.     private PullToRefreshListener mListener;  
  62.   
  63.     /** 
  64.      * 用于存储上次更新时间 
  65.      */  
  66.     private SharedPreferences preferences;  
  67.   
  68.     /** 
  69.      * 下拉头的View 
  70.      */  
  71.     private View header;  
  72.   
  73.     /** 
  74.      * 需要去下拉刷新的ListView 
  75.      */  
  76.     private ListView listView;  
  77.   
  78.     /** 
  79.      * 刷新时显示的进度条 
  80.      */  
  81.     private ProgressBar progressBar;  
  82.   
  83.     /** 
  84.      * 指示下拉和释放的箭头 
  85.      */  
  86.     private ImageView arrow;  
  87.   
  88.     /** 
  89.      * 指示下拉和释放的文字描述 
  90.      */  
  91.     private TextView description;  
  92.   
  93.     /** 
  94.      * 上次更新时间的文字描述 
  95.      */  
  96.     private TextView updateAt;  
  97.   
  98.     /** 
  99.      * 下拉头的布局参数 
  100.      */  
  101.     private MarginLayoutParams headerLayoutParams;  
  102.   
  103.     /** 
  104.      * 上次更新时间的毫秒值 
  105.      */  
  106.     private long lastUpdateTime;  
  107.   
  108.     /** 
  109.      * 为了防止不同界面的下拉刷新在上次更新时间上互相有冲突，使用id来做区分 
  110.      */  
  111.     private int mId = -1;  
  112.   
  113.     /** 
  114.      * 下拉头的高度 
  115.      */  
  116.     private int hideHeaderHeight;  
  117.   
  118.     /** 
  119.      * 当前处理什么状态，可选值有STATUS_PULL_TO_REFRESH, STATUS_RELEASE_TO_REFRESH, 
  120.      * STATUS_REFRESHING 和 STATUS_REFRESH_FINISHED 
  121.      */  
  122.     private int currentStatus = STATUS_REFRESH_FINISHED;;  
  123.   
  124.     /** 
  125.      * 记录上一次的状态是什么，避免进行重复操作 
  126.      */  
  127.     private int lastStatus = currentStatus;  
  128.   
  129.     /** 
  130.      * 手指按下时的屏幕纵坐标 
  131.      */  
  132.     private float yDown;  
  133.   
  134.     /** 
  135.      * 在被判定为滚动之前用户手指可以移动的最大值。 
  136.      */  
  137.     private int touchSlop;  
  138.   
  139.     /** 
  140.      * 是否已加载过一次layout，这里onLayout中的初始化只需加载一次 
  141.      */  
  142.     private boolean loadOnce;  
  143.   
  144.     /** 
  145.      * 当前是否可以下拉，只有ListView滚动到头的时候才允许下拉 
  146.      */  
  147.     private boolean ableToPull;  
  148.   
  149.     /** 
  150.      * 下拉刷新控件的构造函数，会在运行时动态添加一个下拉头的布局。 
  151.      *  
  152.      * @param context 
  153.      * @param attrs 
  154.      */  
  155.     public RefreshableView(Context context, AttributeSet attrs) {  
  156.         super(context, attrs);  
  157.         preferences = PreferenceManager.getDefaultSharedPreferences(context);  
  158.         header = LayoutInflater.from(context).inflate(R.layout.pull_to_refresh, null, true);  
  159.         progressBar = (ProgressBar) header.findViewById(R.id.progress_bar);  
  160.         arrow = (ImageView) header.findViewById(R.id.arrow);  
  161.         description = (TextView) header.findViewById(R.id.description);  
  162.         updateAt = (TextView) header.findViewById(R.id.updated_at);  
  163.         touchSlop = ViewConfiguration.get(context).getScaledTouchSlop();  
  164.         refreshUpdatedAtValue();  
  165.         setOrientation(VERTICAL);  
  166.         addView(header, 0);  
  167.     }  
  168.   
  169.     /** 
  170.      * 进行一些关键性的初始化操作，比如：将下拉头向上偏移进行隐藏，给ListView注册touch事件。 
  171.      */  
  172.     @Override  
  173.     protected void onLayout(boolean changed, int l, int t, int r, int b) {  
  174.         super.onLayout(changed, l, t, r, b);  
  175.         if (changed && !loadOnce) {  
  176.             hideHeaderHeight = -header.getHeight();  
  177.             headerLayoutParams = (MarginLayoutParams) header.getLayoutParams();  
  178.             headerLayoutParams.topMargin = hideHeaderHeight;  
  179.             listView = (ListView) getChildAt(1);  
  180.             listView.setOnTouchListener(this);  
  181.             loadOnce = true;  
  182.         }  
  183.     }  
  184.   
  185.     /** 
  186.      * 当ListView被触摸时调用，其中处理了各种下拉刷新的具体逻辑。 
  187.      */  
  188.     @Override  
  189.     public boolean onTouch(View v, MotionEvent event) {  
  190.         setIsAbleToPull(event);  
  191.         if (ableToPull) {  
  192.             switch (event.getAction()) {  
  193.             case MotionEvent.ACTION_DOWN:  
  194.                 yDown = event.getRawY();  
  195.                 break;  
  196.             case MotionEvent.ACTION_MOVE:  
  197.                 float yMove = event.getRawY();  
  198.                 int distance = (int) (yMove - yDown);  
  199.                 // 如果手指是下滑状态，并且下拉头是完全隐藏的，就屏蔽下拉事件  
  200.                 if (distance <= 0 && headerLayoutParams.topMargin <= hideHeaderHeight) {  
  201.                     return false;  
  202.                 }  
  203.                 if (distance < touchSlop) {  
  204.                     return false;  
  205.                 }  
  206.                 if (currentStatus != STATUS_REFRESHING) {  
  207.                     if (headerLayoutParams.topMargin > 0) {  
  208.                         currentStatus = STATUS_RELEASE_TO_REFRESH;  
  209.                     } else {  
  210.                         currentStatus = STATUS_PULL_TO_REFRESH;  
  211.                     }  
  212.                     // 通过偏移下拉头的topMargin值，来实现下拉效果  
  213.                     headerLayoutParams.topMargin = (distance / 2) + hideHeaderHeight;  
  214.                     header.setLayoutParams(headerLayoutParams);  
  215.                 }  
  216.                 break;  
  217.             case MotionEvent.ACTION_UP:  
  218.             default:  
  219.                 if (currentStatus == STATUS_RELEASE_TO_REFRESH) {  
  220.                     // 松手时如果是释放立即刷新状态，就去调用正在刷新的任务  
  221.                     new RefreshingTask().execute();  
  222.                 } else if (currentStatus == STATUS_PULL_TO_REFRESH) {  
  223.                     // 松手时如果是下拉状态，就去调用隐藏下拉头的任务  
  224.                     new HideHeaderTask().execute();  
  225.                 }  
  226.                 break;  
  227.             }  
  228.             // 时刻记得更新下拉头中的信息  
  229.             if (currentStatus == STATUS_PULL_TO_REFRESH  
  230.                     || currentStatus == STATUS_RELEASE_TO_REFRESH) {  
  231.                 updateHeaderView();  
  232.                 // 当前正处于下拉或释放状态，要让ListView失去焦点，否则被点击的那一项会一直处于选中状态  
  233.                 listView.setPressed(false);  
  234.                 listView.setFocusable(false);  %N�;#F����vӡFʿ�

你可能感兴趣的:(Android)

  • android系统selinux中添加新属性property 辉色投像
    1.定位/android/system/sepolicy/private/property_contexts声明属性开头：persist.charge声明属性类型：u:object_r:system_prop:s0图12.定位到android/system/sepolicy/public/domain.te删除neverallow{domain-init}default_prop:property
  • 2.2.6 通知类控件 Toast、Menu 常思行
    本文例程下载：WillFlow_Toast、WillFlowMenu一、什么是Toast？Toast也被叫做吐司，是Android系统提供的一种非常好的提醒方式，在程序中可以使用它将一些短小的信息通知给用户，它有如下两个特点：Toast是没有焦点的Toast显示的时间有限过一定的时间就会自动消失所以一般来讲Toast的使用并不会影响我们的正常操作，并且它通常不会占用太大的屏幕空间，有着良好的用户体
  • mac 备份android 手机通讯录导入iphone,iphone如何导出通讯录（轻松教你iPhone备份通讯录的方法）... weixin_39762838 mac备份android手机通讯录导入iphone
    在日新月异的手机更替中，换手机已经成为一个非常稀松平常的事情，但将旧手机上面的通讯录导入到新手机还是让不少小伙伴为难，本篇将给大家详细讲解这方面的知识：“苹果手机通讯录怎么导入到新手机”及“安卓手机通讯录导入到新手机”的方法。一、苹果手机通讯录导入到新手机常用方法(SIM卡导入)在苹果手机主频幕上找到“设置”，单击进入设置菜单，下拉菜单列表，点击“邮件、通讯录、日历”，然后找到“导入SIM卡通讯录
  • android 更改窗口的层次,浮窗开发之窗口层级 Ms.Bu android更改窗口的层次
    最近在项目中遇到了这样的需求：需要在特定的其他应用之上悬浮自己的UI交互(拖动、输入等复杂的UI交互)，和九游的浮窗类似，不过我们的比九游的体验更好，我们越过了很多授权的限制。浮窗效果很多人都知道如何去实现一个简单的浮窗，但是却很少有人去深入的研究背后的流程机制，由于项目中浮窗交互比较复杂，遇到了些坑查看了很多资料，故总结浮窗涉及到的知识点：窗口层级关系(浮窗是如何“浮”的)？浮窗有哪些限制，如何
  • Android应用性能优化 轻口味 Android
    Android手机由于其本身的后台机制和硬件特点，性能上一直被诟病，所以软件开发者对软件本身的性能优化就显得尤为重要；本文将对Android开发过程中性能优化的各个方面做一个回顾与总结。Cache优化ListView缓存：ListView中有一个回收器，Item滑出界面的时候View会回收到这里，需要显示新的Item的时候，就尽量重用回收器里面的View；每次在getView函数中inflate新
  • Android实现监听事件的方法 Amy木婉清
    1.通过内部类实现2.通过匿名内部类实现3.通过事件源所在类实现4.通过外部类实现5.布局文件中onclick属性(针对点击事件)1.通过内部类实现代码:privateButtonmBtnEvent;//oncreate中mBtnEvent.setOnClickListener(newOnClick());//内部类实现监听classOnClickimplementsView.OnClickLis
  • 高级UI<第二十四篇>：Android中用到的矩阵常识 NoBugException
    （1）定义在数学中，矩阵（Matrix）是一个按照长方阵列排列的复数或实数集合。由m×n个数aij排成的m行n列的数表称为m行n列的矩阵，简称m×n矩阵。记作：图片.png这m×n个数称为矩阵A的元素，简称为元，数aij位于矩阵A的第i行第j列，称为矩阵A的(i,j)元，以数aij为(i,j)元的矩阵可记为(aij)或(aij)m×n，m×n矩阵A也记作Amn。元素是实数的矩阵称为实矩阵，元素是复
  • RK3229_Android9.0_Box 4G模块EC200A调试 suifen_ 网络
    0、kernel修改这部分完全可以参考Linux的移植：RK3588EC200A-CN【4G模块】调试_rkec200a-cn-CSDN博客1、修改device/rockchip/rk322xdiff--gita/device.mkb/device.mkindexec6bfaa..e7c32d1100755---a/device.mk+++b/device.mk@@-105,6+105,8@@en
  • kt文件和java文件_Java与Kotlin之间怎样进行互操作 铭空间 kt文件和java文件
    Java与Kotlin之间怎样进行互操作发布时间：2021-02-0210:50:43来源：亿速云阅读：98作者：小新这篇文章主要介绍了Java与Kotlin之间怎样进行互操作，具有一定借鉴价值，感兴趣的朋友可以参考下，希望大家阅读完这篇文章之后大有收获，下面让小编带着大家一起了解一下。前言目前kotlin是谷歌首推的开发Android的语言，但由于历史原因，我们绝大部分项目依旧还是以Java为主
  • Android shell 常用 debug 命令 晨春计 Audiodebugandroidlinux
    目录1、查看版本2、am命令3、pm命令4、dumpsys命令5、sed命令6、log定位查看APK进程号7、log定位使用场景1、查看版本1.1、Android串口终端执行getpropro.build.version.release#获取Android版本uname-a#查看linux内核版本信息uname-r#单独查看内核版本1.2、linux服务器执行lsb_release-a#查看Lin
  • 2024年最全Flutter如何和Native通信-Android视角，Electron开发Android界面 2401_84544531 程序员android面试学习
    总结【Android详细知识点思维脑图（技能树）】其实Android开发的知识点就那么多，面试问来问去还是那么点东西。所以面试没有其他的诀窍，只看你对这些知识点准备的充分程度。so，出去面试时先看看自己复习到了哪个阶段就好。虽然Android没有前几年火热了，已经过去了会四大组件就能找到高薪职位的时代了。这只能说明Android中级以下的岗位饱和了，现在高级工程师还是比较缺少的，很多高级职位给的薪
  • 分享一个基于python的电子书数据采集与可视化分析 hadoop电子书数据分析与推荐系统 spark大数据毕设项目（源码、调试、LW、开题、PPT) 计算机源码社 Python项目大数据大数据pythonhadoop计算机毕业设计选题计算机毕业设计源码数据分析spark毕设
    作者：计算机源码社个人简介：本人八年开发经验，擅长Java、Python、PHP、.NET、Node.js、Android、微信小程序、爬虫、大数据、机器学习等，大家有这一块的问题可以一起交流！学习资料、程序开发、技术解答、文档报告如需要源码，可以扫取文章下方二维码联系咨询Java项目微信小程序项目Android项目Python项目PHP项目ASP.NET项目Node.js项目选题推荐项目实战|p
  • android ndk 开发jni调用对象方法，数组参数 wulongkou 开发问题安卓的事ndkandroidstudiojni
    一、JNI和NDK关系JNI是Java语言提供的Java和C/C++相互沟通的机制，Java可以通过JNI调用本地的C/C++代码，本地的C/C++的代码也可以调用java代码。JNI是本地编程接口，Java和C/C++互相通过的接口。Java通过C/C++使用本地的代码的一个关键性原因在于C/C++代码的高效性。NDK是一系列工具的集合。它提供了一系列的工具，帮助开发者快速开发C（或C++）的动
  • Android jni中数组参数的传递方式 lokeyme Andriodandroid开发JNINDKjavac语言
    1、背景今天调试了一下Androidjni关于Java中调用C代码的程序，发现我的数组参数传递方式不对，导致值传递不正确，我的方法是：C代码，入口函数#include#includejintJava_sony_MedicalRecordDemo_MainActivity_decryptionSuccess(JNIEnv*env,jobjectthiz,jintAttr[]){returnAttr[
  • 1-1.Jetpack 之 Navigation 简单编码模板 我命由我12345 Android-Jetpack简化编程javajava-eeandroid-studioandroidstudio安卓androidjetpack
    一、Navigation1、Navigation概述Navigation是Jetpack中的一个重要成员，它主要是结合导航图（NavigationGraph）来控制和简化Fragment之间的导航，即往哪里走，该怎么走2、Navigate引入在模块级build.gradle中引入相关依赖implementation'androidx.navigation:navigation-fragment:2
  • Android JetPack架构——结合记事本Demo一篇打通对Sqlite的增删改查结合常用jetpack架构应用 erhtre 程序员androidjetpack架构sqlite
    为什么要用Jetpack?========================================================================关于为什么要用Jetpack，我参考了许多的博客和官方文档，开阔了我对Android生态圈的理解和认识，在Jetpack推出前出现的许许多多强大的第三方框架与语言，典型代表无疑是强大的RxJava在Jetpack仍然有许多粉丝在一
  • Android干净架构MVI模板使用指南 井美婵Toby
    Android干净架构MVI模板使用指南android-clean-architecture-mvi-boilerplateAforkofourcleanarchitectureboilerplateusingtheModel-View-Intentpattern项目地址:https://gitcode.com/gh_mirrors/an/android-clean-architecture-mv
  • ⭐Unity 安卓环境中正确地读取和处理 XML 文件 惊鸿醉 Unityunityandroidxml
    写了一个选择题Demo，电脑包和编辑器内无问题，但是打包安卓手机之后题目无法正常使用，想到的是安卓环境中正确地读取文件的问题改进方案：1.由于XmlDocument.Load方法在Android上的路径问题（由于文件位于APK内部，无法像在文件系统中那样直接访问），需要先使用UnityWebRequest来异步加载文件内容，然后再解析XML。2.异步处理：修改你的代码，以支持异步文件加载和处理，这
  • 《Android进阶之光》读书笔记 soleil雪寂 读书笔记#Android进阶之光
    文章目录第1章Android新特性1.1.Android5.0新特性1.2.RecyclerView1.1.4.3种Notification1.1.5.Toolbar与Palette1.1.6.Palette1.2.Android6.0新特性1.2.2.运行时权限机制1.3.Android7.0新特性第2章MaterialDesign2.2.DesignSupportLibrary常用控件详解第3
  • 《Android进阶之光》— Android 书籍 王睿丶 Android永无止境《Android进阶之光》Android书籍Androidphoenix移动开发
    文章目录第1章Android新特性1第2章MaterialDesign48第3章View体系与自定义View87第4章多线程编程165第5章网络编程与网络框架204第6章设计模式271第7章事件总线308第8章函数响应式编程333第9章注解与依赖注入框架382第10章应用架构设计422第11章系统架构与MediaPlayer框架460出版年:2017-7简介：《Android进阶之光》是一本And
  • 《android进阶之光》——多线程编程（上） TAING要一直努力 读书笔记
    今天了解了下多线程编程，知识点如下：进程与线程：进程是什么？线程是什么？进程可以看作是程序的实体，是线程的容器，是受操作系统管理的基本运行单元，例如exe文件就是一个进程。线程是进程运行的一些子任务，是操作系统调度的最小单元，各线程拥有自己的计数器，堆栈，局部变量等，也可以访问线程间共享的内存。线程的状态有哪些？新创建，可运行，等待，超时等待，阻塞，终止怎么创建一个线程？-三种方法第一种，MyTr
  • android进阶之光！Android面试必备的集合源码详解，系列篇 程序员Sunbu 程序员Android
    前言面试：如果不准备充分的面试，完全是浪费时间，更是对自己的不负责。文末会给大家分享下我整理的Android面试专题及答案其中大部分都是大企业面试常问的面试题，可以对照这查漏补缺，当然了，这里所列的肯定不可能覆盖全部方式，不过对大家找工作肯定是有帮助！本月飞机到达上海，到今天第6天了，四家大公司华为，小米，映客，抖音，还有二家中小型公司。有几家已经面了几轮，下周还要面，挂了几家，不过目前已经选择了
  • Android-悬浮窗功能的实现（附Java、KT实现源码）(1) egrhef 程序员androidjava开发语言
    //获取服务的操作对象valbinder=serviceasFloatWinfowServices.MyBinderbinder.service}overridefunonServiceDisconnected(name:ComponentName){}}overridefunonActivityResult(requestCode:Int,resultCode:Int,data:Intent){
  • Visual Studio中的Android模拟器使用详解 wurui8 androidandroidstudioandroidandroid应用
    关注微信号：javalearns随时随地学Java或扫一扫随时随地学JavaMicrosoft本周发布了VisualStudio2015预览版,里面包含Android开发工具.安装的时候,如果选Android开发,VisualStudio会把调试Android应用程序用的VisualStudio模拟器也装上.在介绍这个新模拟器之前,我们先来聊一聊,为什么需要一个新的Android模拟器–当然,你也
  • Unity 热更 之 【HybirdCLR】+【YooAsset】 [安卓 Android端] [代码 + 资源热更] 功能的 简单实现演示 仙魁XAN Unity进阶unityHybirdCLRYooAssetHotUpdate热更新
    Unity热更之【HybirdCLR】+【YooAsset】[安卓Android端][代码+资源热更]功能的简单实现演示目录Unity热更之【HybirdCLR】+【YooAsset】[安卓Android端][代码+资源热更]功能的简单实现演示一、简单介绍二、HybridCLR三、YooAsset四、HybirdCLR引入工程五、YooAsset引入工程六、Python服务器简单构建七、Hybir
  • Android 用线程池实现一个简单的任务队列(Kotlin) 深海呐 Android#Android进阶#Kotlinandroidkotlin线程池延时任务队列线程池延时任务
    关于线程池,Kotlin和java的使用方式一样在Android中,很多人喜欢用Handler的postDelayed()去实现延时任务.要使用postDelayed(),去实现延时任务队列,就不可避免要使用递归.但是这样做,代码的简洁性,和书写的简易,就远不如使用线程池.使用线程池的简单程度:privatevalmThreadPool=Executors.newSingleThreadSched
  • （小白入门）Windows环境下搭建React Native Android开发环境 码农老黑 前端ReactNative移动开发Androidstudio
    ReactNative(简称RN)是Facebook于2015年4月开源的跨平台移动应用开发框架，是Facebook早先开源的UI框架React在原生移动应用平台的衍生产物，目前支持iOS和Android两大平台。RN的环境搭建在RN的中文社区有所介绍，但是对于小白来说还是有些太过简略了。RN中文社区详见参考，本文不涉及的问题也许在其中能够有所解答。ReactNative思想底层引擎是JavaSc
  • Android Dialog圆角设置无效的问题 ly969434341 android
    一，参考AndroidDialog圆角设置无效的问题https://blog.csdn.net/woshi_awei/article/details/99664527Android自定义Dialog实现通用圆角对话框https://cloud.tencent.com/developer/article/1740956二，原因Diallog的默认背景是白色（直角背景），我自定义的Dialog背景也是
  • MultiSnapRecyclerView：让Android RecyclerView的滚动停靠更灵活 技术无疆 Androidandroiduiandroidstudioandroid-studiojavaandroidx
    在Android应用开发中，RecyclerView是一个强大且灵活的组件，用于展示大量数据集合。然而，标准的RecyclerView只支持单一的滚动停靠点，这在某些场景下可能不够灵活。为了解决这个问题，TakuSemba开发了一个名为MultiSnapRecyclerView的库，它允许开发者在RecyclerView中实现多个滚动停靠点。文章目录什么是MultiSnapRecyclerView
  • Android界面特效全汇总 小飞鹤 Android开发详解android
    （一）Activity页面切换的效果Android2.0之后有了overridePendingTransition（），其中里面两个参数，一个是前一个activity的退出两一个activity的进入，Java代码1.@OverridepublicvoidonCreate(BundlesavedInstanceState){2.super.onCreate(savedInstanceState);
  • [星球大战]阿纳金的背叛 comsci
          本来杰迪圣殿的长老是不同意让阿纳金接受训练的.........     但是由于政治原因,长老会妥协了...这给邪恶的力量带来了机会     所以......现代的地球联邦接受了这个教训...绝对不让某些年轻人进入学院    
  • 看懂它，你就可以任性的玩耍了！ aijuans JavaScript
              javascript作为前端开发的标配技能，如果不掌握好它的三大特点：1.原型 2.作用域 3. 闭包 ,又怎么可以说你学好了这门语言呢？如果标配的技能都没有撑握好，怎么可以任性的玩耍呢？怎么验证自己学好了以上三个基本点呢，我找到一段不错的代码，稍加改动，如果能够读懂它，那么你就可以任性了。 function jClass(b
  • Java常用工具包 Jodd Kai_Ge javajodd
    Jodd 是一个开源的 Java 工具集， 包含一些实用的工具类和小型框架。简单，却很强大！ 写道 Jodd = Tools + IoC + MVC + DB + AOP + TX + JSON + HTML < 1.5 Mb Jodd 被分成众多模块，按需选择，其中 工具类模块有： jodd-core    &nb
  • SpringMvc下载 120153216 springMVC
    @RequestMapping(value = WebUrlConstant.DOWNLOAD) public void download(HttpServletRequest request,HttpServletResponse response,String fileName) { OutputStream os = null; InputStream is = null;
  • Python 标准异常总结 2002wmj python
    Python标准异常总结 AssertionError 断言语句（assert）失败 AttributeError 尝试访问未知的对象属性 EOFError 用户输入文件末尾标志EOF（Ctrl+d） FloatingPointError 浮点计算错误 GeneratorExit generator.close()方法被调用的时候 ImportError 导入模块失
  • SQL函数返回临时表结构的数据用于查询 357029540 SQL Server
    这两天在做一个查询的SQL，这个SQL的一个条件是通过游标实现另外两张表查询出一个多条数据，这些数据都是INT类型，然后用IN条件进行查询，并且查询这两张表需要通过外部传入参数才能查询出所需数据，于是想到了用SQL函数返回值，并且也这样做了，由于是返回多条数据，所以把查询出来的INT类型值都拼接为了字符串，这时就遇到问题了，在查询SQL中因为条件是INT值，SQL函数的CAST和CONVERST都
  • java 时间格式化 | 比较大小| 时区 个人笔记 7454103 javaeclipsetomcatcMyEclipse
    个人总结！ 不当之处多多包含！ 引用 1.0 如何设置 tomcat 的时区：          位置：(catalina.bat---JAVA_OPTS  下面加上)          set JAVA_OPT
  • 时间获取Clander的用法 adminjun Clander时间
    /**    * 得到几天前的时间    * @param d    * @param day    * @return    */   public static Date getDateBefore(Date d,int day){    Calend
  • JVM初探与设置 aijuans java
    JVM是Java Virtual Machine（Java虚拟机）的缩写，JVM是一种用于计算设备的规范，它是一个虚构出来的计算机，是通过在实际的计算机上仿真模拟各种计算机功能来实现的。Java虚拟机包括一套字节码指令集、一组寄存器、一个栈、一个垃圾回收堆和一个存储方法域。 JVM屏蔽了与具体操作系统平台相关的信息，使Java程序只需生成在Java虚拟机上运行的目标代码（字节码）,就可以在多种平台
  • SQL中ON和WHERE的区别 avords
    SQL中ON和WHERE的区别   数据库在通过连接两张或多张表来返回记录时，都会生成一张中间的临时表，然后再将这张临时表返回给用户。   www.2cto.com   在使用left jion时，on和where条件的区别如下：  1、 on条件是在生成临时表时使用的条件，它不管on中的条件是否为真，都会返回左边表中的记录。 
  • 说说自信 houxinyou 工作生活
    自信的来源分为两种,一种是源于实力,一种源于头脑.实力是一个综合的评定,有自身的能力,能利用的资源等.比如我想去月亮上,要身体素质过硬,还要有飞船等等一系列的东西.这些都属于实力的一部分.而头脑不同,只要你头脑够简单就可以了!同样要上月亮上,你想,我一跳,1米,我多跳几下,跳个几年,应该就到了!什么?你说我会往下掉?你笨呀你!找个东西踩一下不就行了吗?     无论工作还
  • WEBLOGIC事务超时设置 bijian1013 weblogicjta事务超时
            系统中统计数据，由于调用统计过程，执行时间超过了weblogic设置的时间，提示如下错误： 统计数据出错! 原因：The transaction is no longer active - status: 'Rolling Back. [Reason=weblogic.transaction.internal
  • 两年已过去，再看该如何快速融入新团队 bingyingao java互联网融入架构新团队
    偶得的空闲，翻到了两年前的帖子 该如何快速融入一个新团队，有所感触，就记下来，为下一个两年后的今天做参考。     时隔两年半之后的今天，再来看当初的这个博客，别有一番滋味。而我已经于今年三月份离开了当初所在的团队，加入另外的一个项目组，2011年的这篇博客之后的时光，我很好的融入了那个团队，而直到现在和同事们关系都特别好。大家在短短一年半的时间离一起经历了一
  • 【Spark七十七】Spark分析Nginx和Apache的access.log bit1129 apache
    Spark分析Nginx和Apache的access.log，第一个问题是要对Nginx和Apache的access.log文件进行按行解析，按行解析就的方法是正则表达式：   Nginx的access.log解析正则表达式   val PATTERN = """([^ ]*) ([^ ]*) ([^ ]*) (\\[.*\\]) (\&q
  • Erlang patch bookjovi erlang
    Totally five patchs committed to erlang otp, just small patchs. IMO, erlang really is a interesting programming language, I really like its concurrency feature. but the functional programming style
  • log4j日志路径中加入日期 bro_feng javalog4j
    要用log4j使用记录日志，日志路径有每日的日期，文件大小5M新增文件。 实现方式 log4j: <appender name="serviceLog" class="org.apache.log4j.RollingFileAppender"> <param name="Encoding" v
  • 读《研磨设计模式》-代码笔记-桥接模式 bylijinnan java设计模式
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ /** * 个人觉得关于桥接模式的例子，蜡笔和毛笔这个例子是最贴切的：http://www.cnblogs.com/zhenyulu/articles/67016.html * 笔和颜色是可分离的，蜡笔把两者耦合在一起了：一支蜡笔只有一种
  • windows7下SVN和Eclipse插件安装 chenyu19891124 eclipse插件
    今天花了一天时间弄SVN和Eclipse插件的安装，今天弄好了。svn插件和Eclipse整合有两种方式，一种是直接下载插件包，二种是通过Eclipse在线更新。由于之前Eclipse版本和svn插件版本有差别，始终是没装上。最后在网上找到了适合的版本。所用的环境系统：windows7JDK：1.7svn插件包版本：1.8.16Eclipse：3.7.2工具下载地址：Eclipse下在地址：htt
  • [转帖]工作流引擎设计思路 comsci 设计模式工作应用服务器workflow企业应用
    作为国内的同行，我非常希望在流程设计方面和大家交流，刚发现篇好文(那么好的文章，现在才发现，可惜)，关于流程设计的一些原理，个人觉得本文站得高，看得远，比俺的文章有深度，转载如下 ================================================================================= 自开博以来不断有朋友来探讨工作流引擎该如何
  • Linux 查看内存，CPU及硬盘大小的方法 daizj linuxcpu内存硬盘大小
    一、查看CPU信息的命令 [root@R4 ~]# cat /proc/cpuinfo |grep "model name" && cat /proc/cpuinfo |grep "physical id" model name : Intel(R) Xeon(R) CPU X5450 @ 3.00GHz model name :
  • linux 踢出在线用户 dongwei_6688 linux
    两个步骤： 1.用w命令找到要踢出的用户，比如下面：   [root@localhost ~]# w 18:16:55 up 39 days, 8:27, 3 users, load average: 0.03, 0.03, 0.00 USER TTY FROM LOGIN@ IDLE JCPU PCPU WHAT
  • 放手吧,就像不曾拥有过一样 dcj3sjt126com
    内容提要： 静悠悠编著的《放手吧就像不曾拥有过一样》集结“全球华语世界最舒缓心灵”的精华故事，触碰生命最深层次的感动，献给全世界亿万读者。《放手吧就像不曾拥有过一样》的作者衷心地祝愿每一位读者都给自己一个重新出发的理由，将那些令你痛苦的、扛起的、背负的，一并都放下吧！把憔悴的面容换做一种清淡的微笑，把沉重的步伐调节成春天五线谱上的音符，让自己踏着轻快的节奏，在人生的海面上悠然漂荡，享受宁静与
  • php二进制安全的含义 dcj3sjt126com PHP
    PHP里，有string的概念。 string里，每个字符的大小为byte（与PHP相比，Java的每个字符为Character，是UTF8字符，C语言的每个字符可以在编译时选择）。 byte里，有ASCII代码的字符，例如ABC，123，abc，也有一些特殊字符，例如回车，退格之类的。 特殊字符很多是不能显示的。或者说，他们的显示方式没有标准，例如编码65到哪儿都是字母A，编码97到哪儿都是字符
  • Linux下禁用T440s，X240的一体化触摸板(touchpad) gashero linuxThinkPad触摸板
    自打1月买了Thinkpad T440s就一直很火大，其中最让人恼火的莫过于触摸板。   Thinkpad的经典就包括用了小红点(TrackPoint)。但是小红点只能定位，还是需要鼠标的左右键的。但是自打T440s等开始启用了一体化触摸板，不再有实体的按键了。问题是要是好用也行。   实际使用中，触摸板一堆问题，比如定位有抖动，以及按键时会有飘逸。这就导致了单击经常就
  • graph_dfs hcx2013 Graph
    package edu.xidian.graph; class MyStack { private final int SIZE = 20; private int[] st; private int top; public MyStack() { st = new int[SIZE]; top = -1; } public void push(i
  • Spring4.1新特性——Spring核心部分及其他 jinnianshilongnian spring 4.1
    目录 Spring4.1新特性——综述 Spring4.1新特性——Spring核心部分及其他 Spring4.1新特性——Spring缓存框架增强 Spring4.1新特性——异步调用和事件机制的异常处理 Spring4.1新特性——数据库集成测试脚本初始化 Spring4.1新特性——Spring MVC增强 Spring4.1新特性——页面自动化测试框架Spring MVC T
  • 配置HiveServer2的安全策略之自定义用户名密码验证 liyonghui160com
        具体从网上看   http://doc.mapr.com/display/MapR/Using+HiveServer2#UsingHiveServer2-ConfiguringCustomAuthentication   LDAP Authentication using OpenLDAP Setting
  • 一位30多的程序员生涯经验总结 pda158 编程工作生活咨询
    1.客户在接触到产品之后，才会真正明白自己的需求。 　　这是我在我的第一份工作上面学来的。只有当我们给客户展示产品的时候，他们才会意识到哪些是必须的。给出一个功能性原型设计远远比一张长长的文字表格要好。 2.只要有充足的时间，所有安全防御系统都将失败。 　　安全防御现如今是全世界都在关注的大课题、大挑战。我们必须时时刻刻积极完善它，因为黑客只要有一次成功，就可以彻底打败你。   3.
  • 分布式web服务架构的演变 自由的奴隶 linuxWeb应用服务器互联网
    最开始，由于某些想法，于是在互联网上搭建了一个网站，这个时候甚至有可能主机都是租借的，但由于这篇文章我们只关注架构的演变历程，因此就假设这个时候已经是托管了一台主机，并且有一定的带宽了，这个时候由于网站具备了一定的特色，吸引了部分人访问，逐渐你发现系统的压力越来越高，响应速度越来越慢，而这个时候比较明显的是数据库和应用互相影响，应用出问题了，数据库也很容易出现问题，而数据库出问题的时候，应用也容易
  • 初探Druid连接池之二——慢SQL日志记录 xingsan_zhang 日志连接池druid慢SQL
    由于工作原因，这里先不说连接数据库部分的配置，后面会补上，直接进入慢SQL日志记录。   1.applicationContext.xml中增加如下配置： <bean abstract="true" id="mysql_database" class="com.alibaba.druid.pool.DruidDataSourc
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他