PullToRefreshListView.java

package com.lgq.rssreader.controls;

import com.lgq.rssreader.R;
import android.content.Context;
import android.util.AttributeSet;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewGroup;
import android.view.animation.LinearInterpolator;
import android.view.animation.RotateAnimation;
import android.widget.AbsListView;
import android.widget.AbsListView.OnScrollListener;
import android.widget.ImageView;
import android.widget.ListAdapter;
import android.widget.ListView;
import android.widget.ProgressBar;
import android.widget.RelativeLayout;
import android.widget.TextView;

/**
 * ��дListView�ؼ���������ͷ����״̬���ȿؼ���
 * (�˿ؼ�����Ϊjohannilsson��Ϊ����ijλ���߶��ο���������������һ�����޸ģ���лԭ���ߺͶ��ο������ߵ������Ͷ�)
 * @author johannilsson
 * https://github.com/johannilsson/android-pulltorefresh
 */
public class PullToRefreshListView extends ListView implements OnScrollListener {

	// ״̬
	private static final int TAP_TO_REFRESH = 1;
	private static final int PULL_TO_REFRESH = 2;
	private static final int RELEASE_TO_REFRESH = 3;
	private static final int REFRESHING = 4;
	private static final int LOADING = 5;

	// ��������
	private int itemRowCount = 0;
	// ��ҳ����
	private int pageSize = 0;

	private OnRefreshListener mOnRefreshListener;
	private OnLoadListener mOnLoadListener;

	// ������ListView�Ļ�������
	private OnScrollListener mOnScrollListener;
	private LayoutInflater mInflater;

	// ����ˢ��ʱ���ֵĿؼ�
	private RelativeLayout mRefreshView;
	private TextView mRefreshViewText;
	private ImageView mRefreshViewImage;
	private ProgressBar mRefreshViewProgress;
	private TextView mRefreshViewLastUpdated;
	
	//�ײ�ˢ��ʱ���ֵĿؼ�
	private RelativeLayout mLoadView;
	private TextView mLoadViewLabel;
	private ImageView mLoadViewImage;
	private ProgressBar mLoadViewProgress;
	private TextView mLoadViewLastUpdated;

	private int mCurrentScrollState;// ��ǰ����״̬
	private int mRefreshState;// ��ǰˢ��״̬

	private RotateAnimation mFlipAnimation;
	private RotateAnimation mReverseFlipAnimation;

	private int mRefreshViewHeight;
	private int mLoadViewHeight;
	private int mRefreshOriginalTopPadding;
	private int mLoadOriginalTopPadding;
	private int mLastMotionY;

	private boolean mBounceHack;

	public PullToRefreshListView(Context context) {
		super(context);
		init(context);
	}

	public PullToRefreshListView(Context context, AttributeSet attrs) {
		super(context, attrs);
		init(context);
	}

	public PullToRefreshListView(Context context, AttributeSet attrs, int defStyle) {
		super(context, attrs, defStyle);
		init(context);
	}

	/**
	 * ��ʼ���ؼ��Ͷ���
	 * 
	 * @param context
	 */
	private void init(Context context) {
		mFlipAnimation = new RotateAnimation(0, -180,
				RotateAnimation.RELATIVE_TO_SELF, 0.5f,
				RotateAnimation.RELATIVE_TO_SELF, 0.5f);
		mFlipAnimation.setInterpolator(new LinearInterpolator());
		mFlipAnimation.setDuration(250);
		mFlipAnimation.setFillAfter(true);
		mReverseFlipAnimation = new RotateAnimation(-180, 0,
				RotateAnimation.RELATIVE_TO_SELF, 0.5f,
				RotateAnimation.RELATIVE_TO_SELF, 0.5f);
		mReverseFlipAnimation.setInterpolator(new LinearInterpolator());
		mReverseFlipAnimation.setDuration(250);
		mReverseFlipAnimation.setFillAfter(true);

		mInflater = (LayoutInflater) context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);

		mRefreshView = (RelativeLayout) mInflater.inflate(R.layout.pull_to_refresh_header, this, false);
		mRefreshViewText = (TextView) mRefreshView.findViewById(R.id.pull_to_refresh_text);
		mRefreshViewImage = (ImageView) mRefreshView.findViewById(R.id.pull_to_refresh_image);
		mRefreshViewProgress = (ProgressBar) mRefreshView.findViewById(R.id.pull_to_refresh_progress);
		mRefreshViewLastUpdated = (TextView) mRefreshView.findViewById(R.id.pull_to_refresh_updated_at);

		mRefreshViewImage.setMinimumHeight(50);
		mRefreshView.setOnClickListener(new OnClickRefreshListener());
		mRefreshOriginalTopPadding = mRefreshView.getPaddingTop();

		mRefreshState = TAP_TO_REFRESH;
		
		mLoadView = (RelativeLayout) mInflater.inflate(R.layout.listview_footer, this, false);
		mLoadViewLabel = (TextView) mLoadView.findViewById(R.id.pull_to_load_text_more);
		mLoadViewImage = (ImageView) mLoadView.findViewById(R.id.pull_to_load_text_more);
		mLoadViewProgress = (ProgressBar) mLoadView.findViewById(R.id.pull_to_load_progress);
		mLoadViewLastUpdated = (TextView) mLoadView.findViewById(R.id.pull_to_load_updated_at);

		mLoadViewImage.setMinimumHeight(50);
		mLoadView.setOnClickListener(new OnClickRefreshListener());
		mLoadOriginalTopPadding = mLoadView.getPaddingTop();

		mRefreshState = TAP_TO_REFRESH;

		// ΪListViewͷ�����view
		addHeaderView(mRefreshView);
		
		// ΪListViewͷ�����view
		addFooterView(mLoadView);

		super.setOnScrollListener(this);

		measureView(mRefreshView);		
		measureView(mLoadView);

		mRefreshViewHeight = mRefreshView.getMeasuredHeight();
		mLoadViewHeight = mLoadView.getMeasuredHeight();
	}

	@Override
	protected void onAttachedToWindow() {
		super.onAttachedToWindow();
		setSelection(1);
	}

	@Override
	public void setAdapter(ListAdapter adapter) {
		super.setAdapter(adapter);

		setSelection(1);
	}

	@Override
	public void setOnScrollListener(AbsListView.OnScrollListener l) {
		mOnScrollListener = l;
	}

	public void setOnRefreshListener(OnRefreshListener onRefreshListener) {
		mOnRefreshListener = onRefreshListener;
	}
	
	public void setOnLoadListener(OnLoadListener onLoadListener) {
		mOnLoadListener = onLoadListener;
	}

	public void setLastUpdated(CharSequence lastUpdated) {
		if (lastUpdated != null) {
			mRefreshViewLastUpdated.setVisibility(View.VISIBLE);
			mRefreshViewLastUpdated.setText(lastUpdated);
		} else {
			mRefreshViewLastUpdated.setVisibility(View.GONE);
		}
	}
	/**
	 * ����
	 */
	@Override
	public boolean onTouchEvent(MotionEvent event) {
		final int y = (int) event.getY();
		mBounceHack = false;

		switch (event.getAction()) {
			case MotionEvent.ACTION_UP :
				if (!isVerticalScrollBarEnabled()) {
					setVerticalScrollBarEnabled(true);
				}
				if (getFirstVisiblePosition() == 0 && mRefreshState != REFRESHING) {
					if ((mRefreshView.getBottom() >= mRefreshViewHeight || mRefreshView.getTop() >= 0)
							&& mRefreshState == RELEASE_TO_REFRESH) {
						mRefreshState = REFRESHING;
						prepareForRefresh();// ׼��ˢ��
						onRefresh();// ˢ��
					} else if (mRefreshView.getBottom() < mRefreshViewHeight || mRefreshView.getTop() <= 0) {
						resetHeader();// ��ֹˢ��
						setSelection(1);
					}
				}
				break;
			case MotionEvent.ACTION_DOWN :
				mLastMotionY = y;// ��ð���y��λ��
				break;
			case MotionEvent.ACTION_MOVE :
				// ����߾�
				applyHeaderPadding(event);
				break;
		}
		return super.onTouchEvent(event);
	}

	private void applyHeaderPadding(MotionEvent ev) {
		int pointerCount = ev.getHistorySize();

		for (int p = 0; p < pointerCount; p++) {
			if (mRefreshState == RELEASE_TO_REFRESH) {
				if (isVerticalFadingEdgeEnabled()) {
					setVerticalScrollBarEnabled(false);
				}

				int historicalY = (int) ev.getHistoricalY(p);

				int topPadding = (int) (((historicalY - mLastMotionY) - mRefreshViewHeight) / 1.7);

				mRefreshView.setPadding(mRefreshView.getPaddingLeft(),
						topPadding, mRefreshView.getPaddingRight(),
						mRefreshView.getPaddingBottom());
			}
		}
	}

	private void resetHeaderPadding() {
		mRefreshView.setPadding(mRefreshView.getPaddingLeft(),
				mRefreshOriginalTopPadding, mRefreshView.getPaddingRight(),
				mRefreshView.getPaddingBottom());
	}

	private void resetHeader() {
		if (mRefreshState != TAP_TO_REFRESH) {
			mRefreshState = TAP_TO_REFRESH;
			resetHeaderPadding();
			mRefreshViewText.setText(R.string.pull_to_refresh_tap_label);
			mRefreshViewImage.setImageResource(R.drawable.ic_pulltorefresh_arrow);// ���ɼ�ͷ
			mRefreshViewImage.clearAnimation();// �������
			mRefreshViewImage.setVisibility(View.GONE);// ����ͼ��
			mRefreshViewProgress.setVisibility(View.GONE);// ���ؽ�����
		}
	}

	private void measureView(View child) {
		ViewGroup.LayoutParams p = child.getLayoutParams();
		if (p == null) {
			p = new ViewGroup.LayoutParams(ViewGroup.LayoutParams.FILL_PARENT,
					ViewGroup.LayoutParams.WRAP_CONTENT);
		}

		int childWidthSpec = ViewGroup.getChildMeasureSpec(0, 0 + 0, p.width);
		int lpHeight = p.height;
		int childHeightSpec;
		if (lpHeight > 0) {
			childHeightSpec = MeasureSpec.makeMeasureSpec(lpHeight, MeasureSpec.EXACTLY);
		} else {
			childHeightSpec = MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED);
		}
		child.measure(childWidthSpec, childHeightSpec);
	}

	@Override
	public void onScroll(AbsListView view, int firstVisibleItem,
			int visibleItemCount, int totalItemCount) {
		if (mCurrentScrollState == SCROLL_STATE_TOUCH_SCROLL && mRefreshState != REFRESHING) {
			if (firstVisibleItem == 0) {
				mRefreshViewImage.setVisibility(View.VISIBLE);
				if ((mRefreshView.getBottom() >= mRefreshViewHeight + 20 || mRefreshView
						.getTop() >= 0) && mRefreshState != RELEASE_TO_REFRESH) {
					mRefreshViewText.setText(R.string.pull_to_refresh_release_label);
					mRefreshViewImage.clearAnimation();
					mRefreshViewImage.startAnimation(mFlipAnimation);
					mRefreshState = RELEASE_TO_REFRESH;
				} else if (mRefreshView.getBottom() < mRefreshViewHeight + 20
						&& mRefreshState != PULL_TO_REFRESH) {
					mRefreshViewText.setText(R.string.pull_to_refresh_pull_label);
					if (mRefreshState != TAP_TO_REFRESH) {
						mRefreshViewImage.clearAnimation();
						mRefreshViewImage.startAnimation(mReverseFlipAnimation);
					}
					mRefreshState = PULL_TO_REFRESH;
				}
			} else {
				mRefreshViewImage.setVisibility(View.GONE);
				resetHeader();
			}
		} else if (mCurrentScrollState == SCROLL_STATE_FLING
				&& firstVisibleItem == 0 && mRefreshState != REFRESHING) {
			setSelection(1);
			mBounceHack = true;
		} else if (mBounceHack && mCurrentScrollState == SCROLL_STATE_FLING) {
			setSelection(1);
		}

		if (mOnScrollListener != null) {
			mOnScrollListener.onScroll(view, firstVisibleItem,
					visibleItemCount, totalItemCount);
		}
	}

	@Override
	public void onScrollStateChanged(AbsListView view, int scrollState) {
		mCurrentScrollState = scrollState;

		if (mCurrentScrollState == SCROLL_STATE_IDLE) {
			mBounceHack = false;
		}

		if (mOnScrollListener != null) {
			mOnScrollListener.onScrollStateChanged(view, scrollState);
		}
	}

	public void prepareForRefresh() {
		resetHeaderPadding();
		mRefreshViewImage.setVisibility(View.GONE);
		mRefreshViewImage.setImageDrawable(null);
		mRefreshViewProgress.setVisibility(View.VISIBLE);
		mRefreshViewText.setText(R.string.pull_to_refresh_refreshing_label);
		mRefreshViewLastUpdated.setVisibility(View.VISIBLE);
		mRefreshState = REFRESHING;
	}

	public void onRefresh() {
		if (mOnRefreshListener != null) {
			mOnRefreshListener.onRefresh();
		}
	}

	public void onRefreshComplete(CharSequence lastUpdated) {
		setLastUpdated(lastUpdated);
		onRefreshComplete();
	}

	public void onRefreshComplete() {
		resetHeader();
		int bottomPosition = mRefreshView.getBottom();
		Log.i("bottom", "pull:rows:" + String.valueOf(itemRowCount)
				+ ",pageSize:" + String.valueOf(pageSize));
		if (bottomPosition > 0) {
			invalidateViews();
			setSelection(1);// ѡ��ڶ���
		}
		// ����������С�ڱ��η�ҳ�����������ض����͵ײ��ؼ�
		if (pageSize > 0 && itemRowCount < pageSize) {
			removeHeaderView(mRefreshView);
		}
	}

	private class OnClickRefreshListener implements OnClickListener {

		@Override
		public void onClick(View v) {
			if (mRefreshState != REFRESHING) {
				prepareForRefresh();
				onRefresh();
			}
		}
	}
	public void SetDataRow(int row) {
		itemRowCount = row;
	}
	public void SetPageSize(int size) {
		pageSize = size;
	}
	public interface OnRefreshListener {
		public void onRefresh();
	}
	public interface OnLoadListener {
		public void onLoad();
	}
}