listview工具类：上拉刷新+下拉刷新

最新推荐文章于 2018-10-11 21:38:12 发布
原创 最新推荐文章于 2018-10-11 21:38:12 发布 · 1.5k 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#listview #上拉刷新 #下拉刷新 #上下拉 #android

本文介绍了一个自定义的ListView组件，支持下拉刷新和上拉加载更多功能。通过改变头部视图的状态来提示用户操作，实现了不同状态间的平滑过渡。

用网上的下拉刷新+上拉更多改的，欢迎大家反馈问题，并一同完善，以后用的时候就方便了


package com.tts.dyq.util;

import java.text.SimpleDateFormat;
import java.util.Date;

import android.annotation.SuppressLint;
import android.content.Context;
import android.os.IInterface;
import android.provider.ContactsContract.CommonDataKinds.Event;
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.WindowManager;
import android.view.animation.Animation;
import android.view.animation.LinearInterpolator;
import android.view.animation.RotateAnimation;
import android.widget.AbsListView;
import android.widget.AbsListView.OnScrollListener;
import android.widget.BaseAdapter;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.ListView;
import android.widget.ProgressBar;
import android.widget.TextView;

import com.tts.dyq.R;

@SuppressLint("SimpleDateFormat")
public class PullToRefreshListView_Both extends ListView implements OnScrollListener {

	private static final String TAG = "listview";
	private final static int RELEASE_To_REFRESH = 0; // 释放
	private final static int PULL_To_REFRESH = 1;// 下拉刷新
	private final static int REFRESHING = 2; // 正在刷新
	private final static int DONE = 3; // 按下
	private final static int LOADING = 4;
	// 实际的padding的距离与界面上偏移距离的比例
	private final static int RATIO = 3;
	private LayoutInflater inflater;
	private LinearLayout headView;
	private TextView tipsTextview;
	private TextView lastUpdatedTextView;
	private ImageView arrowImageView;
	private ProgressBar progressBar;
	private RotateAnimation animation;
	private RotateAnimation reverseAnimation;
	// 用于保证startY的值在一个完整的touch事件中只被记录一次
	private boolean isRecored = false;
	private int headContentWidth;
	private int headContentHeight;
	private int firstItemIndex;
	private int state;
	private boolean isBack;
	private OnRefreshListener refreshListener;
	private boolean isRefreshable;

	private LinearLayout footView;
	private TextView m_tipsTextview;
	private TextView m_lastUpdatedTextView;
	private ImageView m_arrowImageView;
	private ProgressBar m_progressBar;
	private boolean m_isRecored = false;
	private int m_headContentWidth;
	private int m_headContentHeight;
	private int startY;
	private int m_firstItemIndex;
	private boolean m_isBack;
	private OnRefreshListener m_refreshListener;
	private boolean mRefreshHead;

	private int mTotalSize;

	public PullToRefreshListView_Both(Context context) {
		super(context);
		init(context);

	}

	private void init(Context context) {
		inflater = LayoutInflater.from(context);
		initHeadView(context);
		initFootView(context);
		initAnimation();
		state = DONE;
		isRefreshable = false;
		setOnScrollListener(this);
	}

	/**
	 * 初始化动画
	 */
	private void initAnimation() {
		animation = new RotateAnimation(0, -180, Animation.RELATIVE_TO_SELF, 0.5f, Animation.RELATIVE_TO_SELF, 0.5f);
		animation.setInterpolator(new LinearInterpolator());
		animation.setDuration(250);
		animation.setFillAfter(true);
		reverseAnimation = new RotateAnimation(0, -180, Animation.RELATIVE_TO_SELF, 0.5f, Animation.RELATIVE_TO_SELF,
				0.5f);
		reverseAnimation.setInterpolator(new LinearInterpolator());
		reverseAnimation.setDuration(200);
		reverseAnimation.setFillAfter(true);
	}

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

	private void initHeadView(Context context) {
		headView = (LinearLayout) inflater.inflate(R.layout.head, null);
		arrowImageView = (ImageView) headView.findViewById(R.id.head_arrowImageView);
		progressBar = (ProgressBar) headView.findViewById(R.id.head_progressBar);
		tipsTextview = (TextView) headView.findViewById(R.id.head_tipsTextView);
		lastUpdatedTextView = (TextView) headView.findViewById(R.id.head_lastUpdatedTextView);
		measureView(headView);
		headContentHeight = headView.getMeasuredHeight();
		headContentWidth = headView.getMeasuredWidth();
		headView.setPadding(0, -1 * headContentHeight, 0, 0);
		headView.invalidate();
		Log.v("size", "width:" + headContentWidth + " height:" + headContentHeight);
		addHeaderView(headView, null, false);

	}

	private void initFootView(Context context) {
		footView = (LinearLayout) inflater.inflate(R.layout.foot, null);
		m_arrowImageView = (ImageView) footView.findViewById(R.id.foot_arrowImageView);
		m_progressBar = (ProgressBar) footView.findViewById(R.id.foot_progressBar);
		m_tipsTextview = (TextView) footView.findViewById(R.id.foot_tipsTextView);
		m_lastUpdatedTextView = (TextView) footView.findViewById(R.id.foot_lastUpdatedTextView);
		measureView(footView);
		m_headContentHeight = footView.getMeasuredHeight();
		m_headContentWidth = footView.getMeasuredWidth();
		footView.setPadding(0, -1 * m_headContentHeight, 0, 0);
		footView.invalidate();
		Log.v("size", "width:" + m_headContentWidth + " height:" + m_headContentHeight);
		addFooterView(footView, null, false);
	}

	@Override
	public void onScroll(AbsListView arg0, int firstVisiableItem, int visibleItemCount, int totalItemCount) {
		firstItemIndex = firstVisiableItem;
		mTotalSize = totalItemCount;
		m_firstItemIndex = totalItemCount;

		mIsLast = (firstVisiableItem + visibleItemCount) == totalItemCount ? true : false;
//		Log.e(TAG, "-------onScroll-------mIsLastItemVisible=" + mIsLast);
	}

	private boolean mIsLast = false;

	@Override
	public void onScrollStateChanged(AbsListView arg0, int arg1) {
	}

	@Override
	public boolean onTouchEvent(MotionEvent event) {
		// Log.e(TAG, "isRefreshable=" + isRefreshable);
		if (getAdapter() == null)
			return false;

		if (isRefreshable) {
			switch (event.getAction()) {
			// 在down时候记录当前Y的位置
			case MotionEvent.ACTION_DOWN:
				startY = (int) event.getY();
				// Log.e(TAG, "------x-----startY=" + startY);
				break;
			case MotionEvent.ACTION_UP:
//				Log.e(TAG, "-------------------ACTION_UP-------------------");
				if (mRefreshHead) {
					updateHeadOnUp();
				} else {
					updateFootViewOnUp(event);
				}

			case MotionEvent.ACTION_MOVE:
				int tempY = (int) event.getY();
				// Log.e(TAG, "------ACTION_MOVE-----tempY=" + tempY +
				// " ;startY=" + startY);
				if (tempY > startY) {
					mRefreshHead = true;
					if (firstItemIndex == 0) {
						updateHeadViewOnMove(tempY);
					}

				} else {
					mRefreshHead = false;
					if (mIsLast) {
						updateFootViewOnMove(tempY);
					}
				}

				break;
			}
		}
		return super.onTouchEvent(event);
	}

	private void updateFootViewOnUp(MotionEvent event) {
		Log.e(TAG, "---------foot----up------------status-----------" + state);

		if (state != REFRESHING && state != LOADING) {
			if (state == DONE) {
				// 什么都不做
//				Log.e(TAG, "--------foot---up-----0------");
				footView.setPadding(0, -1 * m_headContentHeight, 0, 0);
				headView.setPadding(0, -1 * headContentHeight, 0, 0);
			}
			// 由下拉刷新状态，到done状态
			if (state == PULL_To_REFRESH) {
//				Log.e(TAG, "--------foot---up-----1------");
				state = DONE;
				changeHeaderViewByState();
				Log.v(TAG, "由上拉刷新状态，到done状态");
			}

			if (state == RELEASE_To_REFRESH) {
//				Log.e(TAG, "--------foot---up-----2------");
				state = REFRESHING;
				changeHeaderViewByState();
				onRefresh();
				Log.v(TAG, "由松开刷新状态，到done状态");
			}
		}
		m_isRecored = false;
		m_isBack = false;
	}

	private void updateHeadOnUp() {
//		Log.e(TAG, "---------head----up-------------------status-----------" + state);
		if (state != REFRESHING && state != LOADING) {
			if (state == DONE) {
//				Log.e(TAG, "----head----up----------0-----");
				// 什么都不做
				footView.setPadding(0, -1 * m_headContentHeight, 0, 0);
				headView.setPadding(0, -1 * headContentHeight, 0, 0);
			}
			// 由下拉刷新状态，到done状态
			if (state == PULL_To_REFRESH) {
//				Log.e(TAG, "----head----up---------1------");
				state = DONE;
				changeHeaderViewByState();
				Log.v(TAG, "由下拉刷新状态，到done状态");
			}

			if (state == RELEASE_To_REFRESH) {
//				Log.e(TAG, "----head----up--------2-------");
				state = REFRESHING;
				changeHeaderViewByState();
				onRefresh();
				Log.v(TAG, "由松开刷新状态，到done状态");
			}
		}
		isRecored = false;
		isBack = false;
	}

	private void changeHeaderViewByState() {
		// Log.e(TAG, "---------changeHeaderViewByState------in----");
		switch (state) {
		// 松开刷新状态
		case RELEASE_To_REFRESH:
			if (mRefreshHead) {
				arrowImageView.setVisibility(View.VISIBLE);
				progressBar.setVisibility(View.GONE);
				tipsTextview.setVisibility(View.VISIBLE);
				lastUpdatedTextView.setVisibility(View.VISIBLE);
				arrowImageView.clearAnimation();
				arrowImageView.startAnimation(animation);
				tipsTextview.setText("松开刷新");
				Log.v(TAG, "当前状态，松开刷新");
			} else {
				// Log.e(TAG, "---------changeHeaderViewByState-----1-----");
				m_arrowImageView.setVisibility(View.VISIBLE);
				m_progressBar.setVisibility(View.GONE);
				m_tipsTextview.setVisibility(View.VISIBLE);
				m_lastUpdatedTextView.setVisibility(View.VISIBLE);
				m_arrowImageView.clearAnimation();
				m_arrowImageView.startAnimation(animation);
				m_tipsTextview.setText("松开刷新");
				Log.v(TAG, "当前状态，松开刷新");
			}

			break;
		// 下拉刷新
		case PULL_To_REFRESH:
			if (mRefreshHead) {
				progressBar.setVisibility(View.GONE);
				tipsTextview.setVisibility(View.VISIBLE);
				lastUpdatedTextView.setVisibility(View.VISIBLE);
				arrowImageView.clearAnimation();
				arrowImageView.setVisibility(View.VISIBLE);
				// 是由RELEASE_To_REFRESH状态转变来的
				// 箭头反转向上
				if (isBack) {
					isBack = false;
					arrowImageView.clearAnimation();
					arrowImageView.startAnimation(reverseAnimation);
					tipsTextview.setText("下拉刷新");
				} else {
					tipsTextview.setText("下拉刷新");
				}

				footView.setPadding(0, -1 * m_headContentHeight, 0, 0);
			} else {
				// Log.e(TAG, "---------changeHeaderViewByState---2-------");
				m_progressBar.setVisibility(View.GONE);
				m_tipsTextview.setVisibility(View.VISIBLE);
				m_lastUpdatedTextView.setVisibility(View.VISIBLE);
				m_arrowImageView.clearAnimation();
				m_arrowImageView.setVisibility(View.VISIBLE);
				// 是由RELEASE_To_REFRESH状态转变来的
				// 箭头反转向上
				if (m_isBack) {
					m_isBack = false;
					m_arrowImageView.clearAnimation();
					m_arrowImageView.startAnimation(reverseAnimation);
					m_tipsTextview.setText("上拉刷新");
				} else {
					m_tipsTextview.setText("上拉刷新");
				}
				headView.setPadding(0, -1 * headContentHeight, 0, 0);
			}

			Log.v(TAG, "当前状态，下拉刷新");
			break;
		// 刷新中 状态
		case REFRESHING:
			if (mRefreshHead) {

				headView.setPadding(0, 0, 0, 0);
				progressBar.setVisibility(View.VISIBLE);
				arrowImageView.clearAnimation();
				arrowImageView.setVisibility(View.GONE);
				tipsTextview.setText("正在刷新...");
				lastUpdatedTextView.setVisibility(View.VISIBLE);
			} else {
				// Log.e(TAG, "---------changeHeaderViewByState---3-------");
				footView.setPadding(0, 0, 0, 0);
				m_progressBar.setVisibility(View.VISIBLE);
				m_arrowImageView.clearAnimation();
				m_arrowImageView.setVisibility(View.GONE);
				m_tipsTextview.setText("正在刷新...");
				m_lastUpdatedTextView.setVisibility(View.VISIBLE);
			}
			Log.v(TAG, "当前状态,正在刷新...");
			break;
		// 刷新完毕
		case DONE:
			if (mRefreshHead) {
				firstItemIndex = 0;
				headView.setPadding(0, -1 * headContentHeight, 0, 0);
				progressBar.setVisibility(View.GONE);
				arrowImageView.clearAnimation();
				arrowImageView.setImageResource(R.drawable.goicon);
				tipsTextview.setText("下拉刷新");
				lastUpdatedTextView.setVisibility(View.VISIBLE);
			} else {
				// Log.e(TAG, "---------changeHeaderViewByState---4-------");
				m_firstItemIndex = mTotalSize;
				footView.setPadding(0, -1 * m_headContentHeight, 0, 0);
				m_progressBar.setVisibility(View.GONE);
				m_arrowImageView.clearAnimation();
				m_arrowImageView.setImageResource(R.drawable.ic_pulltorefresh_arrow_up);
				m_tipsTextview.setText("上拉刷新");
				m_lastUpdatedTextView.setVisibility(View.VISIBLE);

			}
			Log.v(TAG, "当前状态，done");
			break;
		}
	}

	public void setOnRefreshListener(OnRefreshListener headViewRefreshListener,
			OnRefreshListener footViewRefreshListener) {
		this.refreshListener = headViewRefreshListener;
		this.m_refreshListener = footViewRefreshListener;
		isRefreshable = true;
	}

	public void updateFootViewOnMove(int tempY) {
		Log.e(TAG, "---------------------updateFootViewOnMove------------------------------");

		if (!m_isRecored && m_firstItemIndex == mTotalSize) {
			Log.v(TAG, "在move时候记录下位置");
			m_isRecored = true;
			startY = tempY;
		}
		if (state != REFRESHING && m_isRecored && state != LOADING) {
			// 保证在设置padding的过程中，当前的位置一直是在head，否则如果当列表超出屏幕的话，当在上推的时候，列表会同时进行滚动
			// 可以松手去刷新了
			if (state == RELEASE_To_REFRESH) {
				setSelection(mTotalSize);
				// 往上推了，推到了屏幕足够掩盖head的程度，但是还没有推到全部掩盖的地步
				if (((startY - tempY) / RATIO < m_headContentHeight) && (startY - tempY) > 0) {
					state = PULL_To_REFRESH;
					changeHeaderViewByState();
					Log.e(TAG, "由松开刷新状态转变到上拉刷新状态");
				}
				// 一下子推到顶了
				else if (startY - tempY <= 0) {
					state = DONE;
					changeHeaderViewByState();
					Log.e(TAG, "由松开刷新状态转变到done状态");
				}
				// 往下拉了，或者还没有上推到屏幕顶部掩盖head的地步
				else {
					// 不用进行特别的操作，只用更新paddingTop的值就行了
				}
			}
			// 还没有到达显示松开刷新的时候,DONE或者是PULL_To_REFRESH状态
			if (state == PULL_To_REFRESH) {
				setSelection(mTotalSize);
				// 下拉到可以进入RELEASE_TO_REFRESH的状态
				if ((startY - tempY) / RATIO >= m_headContentHeight) {
					state = RELEASE_To_REFRESH;
					m_isBack = true;
					changeHeaderViewByState();
					Log.e(TAG, "由done或者上拉刷新状态转变到松开刷新");
				}
				// 上推到顶了
				else if (startY - tempY <= 0) {
					state = DONE;
					changeHeaderViewByState();
					Log.e(TAG, "由DOne或者上拉刷新状态转变到done状态");
				}
			}
			// done状态下
			if (state == DONE) {
				if (startY - tempY > 0) {
					state = PULL_To_REFRESH;
					changeHeaderViewByState();
				}
			}
			// 更新headView的size
			if (state == PULL_To_REFRESH) {
				footView.setPadding(0, -1 * m_headContentHeight + (startY - tempY) / RATIO, 0, 0);
			}
			// 更新headView的paddingTop
			if (state == RELEASE_To_REFRESH) {
				footView.setPadding(0, 10, 0, 0);
			}
		}
		headView.setPadding(0, -1 * headContentHeight , 0, 0);
	}

	public void updateHeadViewOnMove(int tempY) {
		Log.e(TAG, "-------Head----OnMove-----------");

		if (!isRecored && firstItemIndex == 0) {
			Log.v(TAG, "在move时候记录下位置");
			isRecored = true;
			startY = tempY;
		}
		if (state != REFRESHING && isRecored && state != LOADING) {
			// 保证在设置padding的过程中，当前的位置一直是在head，否则如果当列表超出屏幕的话，当在上推的时候，列表会同时进行滚动
			// 可以松手去刷新了
			if (state == RELEASE_To_REFRESH) {
				setSelection(0);
				// 往上推了，推到了屏幕足够掩盖head的程度，但是还没有推到全部掩盖的地步
				if (((tempY - startY) / RATIO < headContentHeight) && (tempY - startY) > 0) {
					state = PULL_To_REFRESH;
					changeHeaderViewByState();
					Log.v(TAG, "由松开刷新状态转变到下拉刷新状态");
				}
				// 一下子推到顶了
				else if (tempY - startY <= 0) {
					state = DONE;
					changeHeaderViewByState();
					Log.v(TAG, "由松开刷新状态转变到done状态");
				}
				// 往下拉了，或者还没有上推到屏幕顶部掩盖head的地步
				else {
					// 不用进行特别的操作，只用更新paddingTop的值就行了
				}
			}
			// 还没有到达显示松开刷新的时候,DONE或者是PULL_To_REFRESH状态
			if (state == PULL_To_REFRESH) {
				setSelection(0);
				// 下拉到可以进入RELEASE_TO_REFRESH的状态
				if ((tempY - startY) / RATIO >= headContentHeight) {
					state = RELEASE_To_REFRESH;
					isBack = true;
					changeHeaderViewByState();
					Log.v(TAG, "由done或者下拉刷新状态转变到松开刷新");
				}
				// 上推到顶了
				else if (tempY - startY <= 0) {
					state = DONE;
					changeHeaderViewByState();
					Log.v(TAG, "由DOne或者下拉刷新状态转变到done状态");
				}
			}
			// done状态下
			if (state == DONE) {
				if (tempY - startY > 0) {
					state = PULL_To_REFRESH;
					changeHeaderViewByState();
				}
			}
			// 更新headView的size
			if (state == PULL_To_REFRESH) {
				headView.setPadding(0, -1 * headContentHeight + (tempY - startY) / RATIO, 0, 0);
			}
			// 更新headView的paddingTop
			if (state == RELEASE_To_REFRESH) {
				headView.setPadding(0, 10, 0, 0);
			}
		}
		footView.setPadding(0, -1 * m_headContentHeight, 0, 0);
	}

	public interface OnRefreshListener {
		public void onRefresh();
	}

	public void onRefreshComplete() {
		if (mRefreshHead) {
			state = DONE;
			SimpleDateFormat format = new SimpleDateFormat("yyyy年MM月dd日  HH:mm");
			String date = format.format(new Date());
			lastUpdatedTextView.setText("最近更新:" + date);
		} else {
			state = DONE;
			SimpleDateFormat format = new SimpleDateFormat("yyyy年MM月dd日  HH:mm");
			String date = format.format(new Date());
			m_lastUpdatedTextView.setText("最近更新:" + date);
		}
		changeHeaderViewByState();
	}

	private void onRefresh() {
		if (mRefreshHead) {
			if (refreshListener != null) {
				refreshListener.onRefresh();
			}
		} else {
			if (m_refreshListener != null) {
				m_refreshListener.onRefresh();
			}
		}
	}

	// 此方法直接照搬自网络上的一个下拉刷新的demo，此处是“估计”headView的width以及height
	private void measureView(View child) {
		ViewGroup.LayoutParams p = child.getLayoutParams();
		if (p == null) {
			p = new ViewGroup.LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT, 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);
	}

	public void setAdapter(BaseAdapter adapter) {
		SimpleDateFormat format = new SimpleDateFormat("yyyy年MM月dd日  HH:mm");
		String date = format.format(new Date());
		if (mRefreshHead) {
			lastUpdatedTextView.setText("最近更新:" + date);
		} else {
			m_lastUpdatedTextView.setText("最近更新:" + date);
		}

		super.setAdapter(adapter);
	}
}


Android——ListView上拉刷新与下拉刷新
weixin_44288786的博客
03-23 852
本文记述ListView的上拉与下拉的刷新数据 首先需要自定义一个MyListView,继承于ListView public class MyListView extends ListView implements AbsListView.OnScrollListener { private View bottomview; //尾文件 private View headview; //头文件 private int totaItemCounts;//用于表示是下拉还是上拉
listView官方上拉加载，下拉刷新
05-14
开发项目过程中基本都会用到listView的下拉刷新和上滑加载更多，之前大家最常用的应该是pull to refresh或它的变种版吧，google官方在最新的android.support.v4包中增加了一个新类SwipeRefreshLayout，地址 这个类的作用就是提供官方的下拉刷新，并且效果相当不错，而上拉加载更多则用我们自定义的listview，也是相当简单。
Android listView的上拉刷新（加载更多）
08-24
以前也实现过，ListView的上拉刷新，不过用的是开源代码，由于本人比较懒吧，源码也没怎么研究，所以现在写出来还不是那么流利。还好本人发现了自己的这些特点，所以写出来个Demo，基本实现了ListView的上拉说新，当做练习了，可能还不是那么完美，以后根据开源代码的研究，会写出更好的并且简单易懂的下拉说新Demo来发表。
ListView 上拉刷新
weixin_30781107的博客
09-19 116
在Android 开发中ListView 是常用控件，主要目的是为显示大批量数据。而 大批量数据一次加载显示容易造成内存溢出，需要分批加载。 而分批加载需要在加载下一页数据时提示用户等待更新，为此我参照网络上的资料。自行封装了一个带上拉更新的ListView。首先自定义的 ListView需要继承至ListView 并实现OnScrollListener接口。废话不多说，直接上源码。主要看My...
ListView上拉加载和下拉刷新多种实现方式
茅屋
05-19 3万+
ListView上拉加载和下拉刷新多种实现方式该篇为ListView下拉刷新和上拉加载实现的各种方法大合集。可能在具体的细节逻辑上处理不太到位，但基本上完成逻辑的实现。细节方面，个人可以根据自己的需求进行完善。该博客将以四种思路来完成下拉刷新和上拉加载 自定义View实现上拉加载和下拉刷新 使用PullToRefresh 实现上拉加载和下拉刷新 使用Ultra-Pull-To-Refresh实现上拉
微信小程序listview组件：实现上拉刷新与下拉加载
微信小程序内置listview组件除了基础的列表展示功能外，还特别增强了上拉刷新和下拉加载更多数据的功能，使得数据的动态更新变得更加流畅和自然。 首先，我们需要了解上拉刷新（pull-to-refresh）与下拉加载更多...
优化ListView体验：实现无缝上拉加载与下拉刷新
标题和描述中提到的“listview 上拉加载 下拉刷新”，是指在移动应用或网页中常见的一个交互模式，用于提高用户体验和数据加载效率。通过该模式，用户可以通过简单的上拉或下拉动作，在无需额外点击“更多”按钮的...
Android自定义ListView深入实践：下拉刷新与上拉加载
根据标题和描述，此demo通过自定义ListView实现了下拉刷新、滑动操作以及上拉加载更多功能。这一功能集合通常被称作"下拉刷新上拉加载更多"模式，它已经成为一种标准的列表交互模式。 自定义ListView组件时，需要...
PullSwipe工具类：封装侧滑删除与下拉刷新功能
综上所述，PullSwipe工具类是一个功能强大且易于集成的组件，它极大地简化了侧滑删除和下拉刷新功能在Android应用中的实现。开发者可以通过使用这个工具类快速提升他们的应用交互体验，同时保持代码的清晰和易于维护...
XListView上拉下拉刷新工具类Android源码
从描述“一个listview上拉下拉刷新的工具类”可以看出，该项目的核心目标是提供一套完整、可复用、易于集成的刷新机制解决方案，适用于需要频繁加载或更新列表数据的应用场景，如新闻客户端、社交软件动态流、电商...
Listview(上拉更多 下拉刷新)
09-11
结合网上的部分资源,进行了部分删改,实现下拉刷新,上拉更多的功能,相信足够用了
Android中ListView下拉刷新和上拉加载更多的实现
07-24
http://blog.youkuaiyun.com/qq_32673327/article/details/52012327 这是关于Demo实现的博客
ListView 上拉和下拉刷新控件
a346254964的博客
05-17 412
这个博客好想不能提供下载代码啊, 我只能把代码贴出来了... 其实你只需看用法, 不用关心具体实现,demo非常容易看懂 [java] view plaincopyprint? public class CustomListViewActivity extends Activity {      private CustomListView listview;
ListView实现上拉加载&下拉刷新
@CJZ啊的博客
10-11 5206
上拉加载&amp;下拉刷新 思路详解： 自定义的带有下拉刷新和上拉加载的ListView开始时，跟系统的ListView一样。不过多了个header和footer只不过这两个布局以不同的方式隐藏起来了而已。（header是在手机屏幕外的上面，footer是直接隐藏起来了。因为下拉和上拉加载不同，下拉加载有手势判断，要出现动画效果，根据下拉的各种手势，来设置具体的操作。如果直接跟footer一样...
ListView下拉刷新，上拉自动加载更多
热门推荐
SunnyCoffee Blog
02-03 6万+
下拉刷新，Android中非常普遍的功能。为了方便便重写的ListView来实现下拉刷新，同时添加了上拉自动加载更多的功能。设计最初是参考开源中国的Android客户端源码。先看示例图。 重写后的listview动画效果来源于添加的头部和尾部。
ListView上拉加载更多(分页加载)
hard work
06-18 1896
实现方法： 1 在自定义ListView中对滑动事件进行监听，当滑动在最底部时，调用加载的方法。 2. 自定义ListView的加载方法使用接口回调的方式实现，在主Activity实现这个接口，进行回调 是对该课程的笔记，需要的同学可直接观看该视频 http://www.imooc.com/learn/136
自定义ListView实现下拉刷新上拉加载功能
u013131305的博客
05-18 630
1，概述 本案例主要继承自ListView，通过添加"头布局"以及"尾布局"，然后再监听onTouchEvent事件，实现AbsListView.OnScrollListener接口，来监听滑动到顶部以及底部等状态来隐藏与显示view来达到效果的，Github地址：PullRefreshListView 2,实现步骤 1，创建“头布局”与“尾布局” HeaderView: <L
简单实用XlistView实现下拉刷新，上拉加载网络数据
Do_the_best_的博客
08-16 558
使用之前先导入XlistView的包： 下载地址：https://github.com/Maxwin-z/XListView-Android 由于XlistView不是最新的技术，在导入之后会报错，我们只需要更改XlistView中的 build.gradle 把里边支持的sdk版本改成我们目前项目所对应的sdk版本 编译之后没有问题就可以愉快的使用啦~~ xml文件 在导入包后，便可...
android ListView下拉刷新及上拉加载 （自定义ListView，可直接使用）
gys19921114的博客
05-10 541
今天同事提到要做列表的刷新和加载更多我想到现在项目上的ListView的加载当初为了赶项目直接借鉴别人的Ctrl+C and Ctrl+V做出来的，体验不是很好。所以我就再次查看了原来的代码，并参考后自己写了一个。 ListView是android项目常用到的控件之一，刷新和加载也难倒了很多项我一样的菜鸟。很多人会觉得重写ListView会很麻烦，所以我今天试着写了一个。 列表滑动监听AbsL
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

flying_vip_521

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值