标签：
先看一下效果(因为模拟器的原因,看不到进度条,大家可以下载demo,进行查看)
demo地址
package yuan.kuo.yu.view;
import android.animation.ValueAnimator;
import android.content.Context;
import android.os.Handler;
import android.util.AttributeSet;
import android.view.Gravity;
import android.view.View;
import android.view.ViewGroup;
import android.view.animation.Animation;
import android.view.animation.RotateAnimation;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.TextView;
import yuan.kuo.yu.R;
import yuan.kuo.yu.load.CircleLoadingView;
/**
* Created by yukuo on 2016/4/29.
* 这是一个recycleview的刷新的头布局
*/
public class YRecycleviewRefreshHeadView extends LinearLayout {
//刷新头布局
LinearLayout mContentView;
//这是一个旋转动画
private RotateAnimation mRotateUpAnim;
private RotateAnimation mRotateDownAnim;
//旋转默认的动画时间
private static final int ROTATE_ANIM_DURATION = 180;
private int mMeasuredHeight;
private int mStatus;
//正在刷新的状态
public final static int STATE_REFRESHING = 2;
//刷新结束的状态
public final static int STATE_DONE = 3;
//没有任何的状态
public final static int STATE_NORMAL = 0;
//准备刷新的状态
private final int STATE_RELEASE_TO_REFRESH = 1;
private ImageView iv_y_recycleview_head_refresh_status;
private CircleLoadingView pb_y_recycleview_head_refresh_progressbar;
private TextView tv_y_recycleview_head_refresh_status;
public YRecycleviewRefreshHeadView(Context context) {
super(context);
initView(context);
}
public YRecycleviewRefreshHeadView(Context context, AttributeSet attrs) {
super(context, attrs);
initView(context);
}
/**
* 初始化
*/
private void initView(Context context) {
mContentView = (LinearLayout) View.inflate(context, R.layout.head_recycleview_refresh, null);
//宽高
LayoutParams lp = new LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT);
//距离父布局的距离
lp.setMargins(0, 0, 0, 0);
//设置布局的宽高的属性
this.setLayoutParams(lp);
//设置内容距离布局的边界的尺寸
this.setPadding(0, 0, 0, 0);
//添加内容布局并且设置宽是屏幕的宽.高为0
addView(mContentView, new LayoutParams(LayoutParams.MATCH_PARENT, 0));
//设置内容位于布局的下方
setGravity(Gravity.BOTTOM);
//查找头布局控件
//刷新状态字体
tv_y_recycleview_head_refresh_status = (TextView) findViewById(R.id.tv_y_recycleview_head_refresh_status);
//刷新状态的箭头
iv_y_recycleview_head_refresh_status = (ImageView) findViewById(R.id.iv_y_recycleview_head_refresh_status);
//正在刷新的进度条
pb_y_recycleview_head_refresh_progressbar = (CircleLoadingView) findViewById(R.id.pb_y_recycleview_head_refresh_progressbar);
//定义一个向上旋转动画
mRotateUpAnim = new RotateAnimation(0.0f, -180.0f,
Animation.RELATIVE_TO_SELF, 0.5f, Animation.RELATIVE_TO_SELF, 0.5f);
mRotateUpAnim.setDuration(ROTATE_ANIM_DURATION);
//设置旋转之后保持旋转后的状态
mRotateUpAnim.setFillAfter(true);
//定义一个向下旋转的动画
mRotateDownAnim = new RotateAnimation(-180.0f, 0.0f,
Animation.RELATIVE_TO_SELF, 0.5f, Animation.RELATIVE_TO_SELF, 0.5f);
mRotateDownAnim.setDuration(ROTATE_ANIM_DURATION);
mRotateDownAnim.setFillAfter(true);
//测量
measure(ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.WRAP_CONTENT);
//获取高度
mMeasuredHeight = getMeasuredHeight();
}
/**
* 设置这个刷新状态的方法
*/
public void setState(int status) {
//如果状态一致就不要更改
if (status == mStatus) {
return;
}
/**
* 设置当前布局格局状态隐藏和显示
*/
//设置刷新状态
if (status == STATE_REFRESHING) {
//清除箭头的动画效果并且隐藏
iv_y_recycleview_head_refresh_status.clearAnimation();
iv_y_recycleview_head_refresh_status.setVisibility(View.INVISIBLE);
//展示进度条
pb_y_recycleview_head_refresh_progressbar.setVisibility(View.VISIBLE);
} else if (status == STATE_DONE) {
//刷新结束状态
iv_y_recycleview_head_refresh_status.setVisibility(View.INVISIBLE);
pb_y_recycleview_head_refresh_progressbar.setVisibility(View.INVISIBLE);
} else {
//正常状态隐藏进度条显示箭头
iv_y_recycleview_head_refresh_status.setVisibility(View.VISIBLE);
pb_y_recycleview_head_refresh_progressbar.setVisibility(View.INVISIBLE);
}
/**
* 根据状态进行动画的调整
*/
switch (status) {
case STATE_NORMAL:
//如果当前状态是准备做刷新就开始动画
if (mStatus == STATE_RELEASE_TO_REFRESH) {
iv_y_recycleview_head_refresh_status.startAnimation(mRotateDownAnim);
}
//如果当前状态正在刷新,就停止动画
if (mStatus == STATE_REFRESHING) {
iv_y_recycleview_head_refresh_status.clearAnimation();
}
tv_y_recycleview_head_refresh_status.setText("下拉刷新");
break;
case STATE_RELEASE_TO_REFRESH:
//如果当前状态不是准备去刷新
if (mStatus != STATE_RELEASE_TO_REFRESH) {
iv_y_recycleview_head_refresh_status.clearAnimation();
iv_y_recycleview_head_refresh_status.startAnimation(mRotateUpAnim);
tv_y_recycleview_head_refresh_status.setText("松开刷新");
}
break;
case STATE_REFRESHING:
tv_y_recycleview_head_refresh_status.setText("正在刷新");
break;
case STATE_DONE:
tv_y_recycleview_head_refresh_status.setText("刷新完成");
break;
default:
}
mStatus = status;
}
/**
* 返回当前的状态
* @return
*/
public int getStatus() {
return mStatus;
}
/**
* 释放意图
*
* @return
*/
public boolean releaseAction() {
//是否在刷新
boolean isOnRefresh = false;
//获取显示的高度
int height = getVisibleHeight();
if (height == 0) // not visible.
isOnRefresh = false;//没有刷新
if (getVisibleHeight() > mMeasuredHeight && mStatus < STATE_REFRESHING) {
setState(STATE_REFRESHING);
isOnRefresh = true;//正在刷新
}
// refreshing and header isn‘t shown fully. do nothing.
if (mStatus == STATE_REFRESHING && height <= mMeasuredHeight) {
//return;
}
int destHeight = 0; // default: scroll back to dismiss header.
// is refreshing, just scroll back to show all the header.
if (mStatus == STATE_REFRESHING) {
destHeight = mMeasuredHeight;
}
smoothScrollTo(destHeight);
return isOnRefresh;
}
/**
* 移动距离
*
* @param delta
*/
public void onMove(float delta) {
if (getVisibleHeight() > 0 || delta > 0) {
setVisibleHeight((int) delta + getVisibleHeight());
if (mStatus <= STATE_RELEASE_TO_REFRESH) { // 未处于刷新状态，更新箭头
if (getVisibleHeight() > mMeasuredHeight) {
setState(STATE_RELEASE_TO_REFRESH);
} else {
setState(STATE_NORMAL);
}
}
}
}
/**
* 这是一个让布局高度改变的方法
*/
public void smoothScrollTo(int Height) {
ValueAnimator animator = ValueAnimator.ofInt(getVisibleHeight(), Height);
animator.setDuration(300).start();
animator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
@Override
public void onAnimationUpdate(ValueAnimator animation) {
setVisibleHeight((int) animation.getAnimatedValue());
}
});
animator.start();
}
/**
* 设置布局高度为0,并设置状态为正常状态
*/
public void reset() {
smoothScrollTo(0);
new Handler().postDelayed(new Runnable() {
public void run() {
setState(STATE_NORMAL);
}
}, 500);
}
/**
* 刷新完成
*/
public void refreshComplete() {
setState(STATE_DONE);
new Handler().postDelayed(new Runnable() {
public void run() {
reset();
}
}, 200);
}
/**
* 获取显示的高度
*
* @return
*/
public int getVisibleHeight() {
LayoutParams lp = (LayoutParams) mContentView.getLayoutParams();
return lp.height;
}
/**
* 设置显示的高度
*
* @param height
*/
public void setVisibleHeight(int height) {
if (height < 0) height = 0;
LayoutParams lp = (LayoutParams) mContentView.getLayoutParams();
lp.height = height;
mContentView.setLayoutParams(lp);
}
}
package yuan.kuo.yu.view;
import android.content.Context;
import android.util.AttributeSet;
import android.view.Gravity;
import android.view.View;
import android.view.ViewGroup;
import android.widget.LinearLayout;
import android.widget.TextView;
import yuan.kuo.yu.R;
import yuan.kuo.yu.load.CircleLoadingView;
/**
* Created by yukuo on 2016/4/30.
*/
public class YRecycleviewRefreshFootView extends LinearLayout {
private CircleLoadingView pb_y_recycleview_foot_loadmore_progressbar;
private TextView tv_y_recycleview_foot_loadmore_status;
/**
* 加载中
*/
public final static int STATE_LOADING = 0;
/**
* 加载完成
*/
public final static int STATE_COMPLETE = 1;
/**
* 正常状态
*/
public final static int STATE_NOMORE = 2;
public YRecycleviewRefreshFootView(Context context) {
super(context);
initView(context);
}
public YRecycleviewRefreshFootView(Context context, AttributeSet attrs) {
super(context, attrs);
initView(context);
}
/**
* 初始化
*/
private void initView(Context context) {
//设置内部内容居中
setGravity(Gravity.CENTER);
//设置宽高
setLayoutParams(new ViewGroup.LayoutParams(
ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.WRAP_CONTENT));
//底部布局
View mContentView = View.inflate(context, R.layout.foot_recycleview_loadmore, null);
pb_y_recycleview_foot_loadmore_progressbar = (CircleLoadingView) mContentView.findViewById(R.id.pb_y_recycleview_foot_loadmore_progressbar);
tv_y_recycleview_foot_loadmore_status = (TextView) mContentView.findViewById(R.id.tv_y_recycleview_foot_loadmore_status);
addView(mContentView);
}
/**
* 设置当前状态
*
* @param state
*/
public void setState(int state) {
switch (state) {
case STATE_LOADING:
pb_y_recycleview_foot_loadmore_progressbar.setVisibility(View.VISIBLE);
tv_y_recycleview_foot_loadmore_status.setText("加载中...");
this.setVisibility(View.VISIBLE);
break;
case STATE_COMPLETE:
tv_y_recycleview_foot_loadmore_status.setText("加载中...");
this.setVisibility(View.GONE);
break;
case STATE_NOMORE:
tv_y_recycleview_foot_loadmore_status.setText("没有更多了..");
pb_y_recycleview_foot_loadmore_progressbar.setVisibility(View.GONE);
this.setVisibility(View.VISIBLE);
break;
}
}
}
然后就是我们最重要的自定义recycleview了
package yuan.kuo.yu.view;
import android.content.Context;
import android.support.annotation.Nullable;
import android.support.v7.widget.GridLayoutManager;
import android.support.v7.widget.LinearLayoutManager;
import android.support.v7.widget.RecyclerView;
import android.support.v7.widget.StaggeredGridLayoutManager;
import android.util.AttributeSet;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewGroup;
import java.util.ArrayList;
import java.util.List;
/**
* Created by yukuo on 2016/4/29.
* 这是一个带下拉刷新和上拉加载的revycleview
*/
public class YRecycleview extends RecyclerView {
/**
* 是否可以刷新的常量
*/
private boolean pullRefreshEnabled = true;
/**
* 是否可以加载更多的常量
*/
private boolean loadMoreEnabled = true;
/**
* 头布局集合
*/
private ArrayList<View> mHeaderViews = new ArrayList<>();
/**
* 脚布局集合
*/
private ArrayList<View> mFootViews = new ArrayList<>();
//当前的头布局
private YRecycleviewRefreshHeadView mHeadView;
//监听器
private OnRefreshAndLoadMoreListener refreshAndLoadMoreListener;
//加载数据中的状态
private boolean isLoadingData = false;
//adapter没有数据的时候显示,类似于listView的emptyView
private View mEmptyView;
//没有数据的状态
private boolean isNoMore = false;
//阻率
private static final float DRAG_RATE = 2;
/**
* 数据观察者
*/
private final RecyclerView.AdapterDataObserver mDataObserver = new DataObserver();
/**
* 最后的y坐标
*/
private float mLastY = -1;
private boolean onTop;
private WrapAdapter mWrapAdapter;
private static final int TYPE_REFRESH_HEADER = -5;
private static final int TYPE_NORMAL = 0;
private static final int TYPE_FOOTER = -3;
private static List<Integer> sHeaderTypes = new ArrayList<>();
private static final int HEADER_INIT_INDEX = 10000;
public YRecycleview(Context context) {
this(context, null);
}
public YRecycleview(Context context, @Nullable AttributeSet attrs) {
this(context, attrs, 0);
}
public YRecycleview(Context context, @Nullable AttributeSet attrs, int defStyle) {
super(context, attrs, defStyle);
init();
}
/**
* 这是一个初始化的方法
*/
private void init() {
//可以进行刷新
if (pullRefreshEnabled) {
//获取头布局
YRecycleviewRefreshHeadView refreshHeader = new YRecycleviewRefreshHeadView(getContext());
//添加进去
mHeaderViews.add(0, refreshHeader);
mHeadView = refreshHeader;
}
YRecycleviewRefreshFootView footView = new YRecycleviewRefreshFootView(getContext());
addFootView(footView);
mFootViews.get(0).setVisibility(GONE);
}
/**
* 当滚动状态改变的时候
*
* @param state
*/
@Override
public void onScrollStateChanged(int state) {
super.onScrollStateChanged(state);
if (state == RecyclerView.SCROLL_STATE_IDLE && refreshAndLoadMoreListener != null && !isLoadingData && loadMoreEnabled) {
LayoutManager layoutManager = getLayoutManager();
int lastVisibleItemPosition;
if (layoutManager instanceof GridLayoutManager) {
lastVisibleItemPosition = ((GridLayoutManager) layoutManager).findLastVisibleItemPosition();
} else if (layoutManager instanceof StaggeredGridLayoutManager) {
int[] into = new int[((StaggeredGridLayoutManager) layoutManager).getSpanCount()];
((StaggeredGridLayoutManager) layoutManager).findLastVisibleItemPositions(into);
lastVisibleItemPosition = findMax(into);
} else {
lastVisibleItemPosition = ((LinearLayoutManager) layoutManager).findLastVisibleItemPosition();
}
if (layoutManager.getChildCount() > 0
&& lastVisibleItemPosition >= layoutManager.getItemCount() - 1 && layoutManager.getItemCount() > layoutManager.getChildCount()
&& !isNoMore && mHeadView.getStatus() < YRecycleviewRefreshHeadView.STATE_REFRESHING) {
View footView = mFootViews.get(0);
isLoadingData = true;
if (footView instanceof YRecycleviewRefreshFootView) {
((YRecycleviewRefreshFootView) footView).setState(YRecycleviewRefreshFootView.STATE_LOADING);
} else {
footView.setVisibility(View.VISIBLE);
}
refreshAndLoadMoreListener.onLoadMore();
}
}
}
private int findMax(int[] into) {
int max = into[0];
for (int value : into) {
if (value > max) {
max = value;
}
}
return max;
}
/**
* 控件的触摸事件的监听
*
* @param e
* @return
*/
@Override
public boolean onTouchEvent(MotionEvent e) {
if (mLastY == -1) {
mLastY = e.getRawY();
}
switch (e.getAction()) {
case MotionEvent.ACTION_DOWN:
mLastY = e.getRawY();
break;
case MotionEvent.ACTION_MOVE:
final float deltaY = e.getRawY() - mLastY;
mLastY = e.getRawY();
if (isOnTop() && pullRefreshEnabled) {
mHeadView.onMove(deltaY / DRAG_RATE);
if (mHeadView.getVisibleHeight() > 0 && mHeadView.getStatus() < mHeadView.STATE_REFRESHING) {
return false;
}
}
break;
default:
//复位
mLastY = -1; // reset
if (isOnTop() && pullRefreshEnabled) {
if (mHeadView.releaseAction()) {
if (refreshAndLoadMoreListener != null) {
refreshAndLoadMoreListener.onRefresh();
}
}
}
break;
}
return super.onTouchEvent(e);
}
/**
* 是否是顶部
*
* @return
*/
public boolean isOnTop() {
return !(mHeaderViews == null || mHeaderViews.isEmpty()) && mHeaderViews.get(0).getParent() != null;
}
@Override
public void setAdapter(Adapter adapter) {
mWrapAdapter = new WrapAdapter(adapter);
super.setAdapter(mWrapAdapter);
adapter.registerAdapterDataObserver(mDataObserver);
mDataObserver.onChanged();
}
/**
* 包装的适配器
*/
private class WrapAdapter extends RecyclerView.Adapter<ViewHolder> {
private RecyclerView.Adapter adapter;
private int mCurrentPosition;
private int headerPosition = 1;
public WrapAdapter(Adapter adapter) {
this.adapter = adapter;
}
@Override
public int getItemViewType(int position) {
if (isRefreshHeader(position)) {
return TYPE_REFRESH_HEADER;
}
if (isHeader(position)) {
position = position - 1;
return sHeaderTypes.get(position);
}
if (isFooter(position)) {
return TYPE_FOOTER;
}
int adjPosition = position - getHeadersCount();
int adapterCount;
if (adapter != null) {
adapterCount = adapter.getItemCount();
if (adjPosition < adapterCount) {
return adapter.getItemViewType(adjPosition);
}
}
return TYPE_NORMAL;
}
@Override
public void onAttachedToRecyclerView(RecyclerView recyclerView) {
super.onAttachedToRecyclerView(recyclerView);
RecyclerView.LayoutManager manager = recyclerView.getLayoutManager();
if (manager instanceof GridLayoutManager) {
final GridLayoutManager gridManager = ((GridLayoutManager) manager);
gridManager.setSpanSizeLookup(new GridLayoutManager.SpanSizeLookup() {
@Override
public int getSpanSize(int position) {
return (isHeader(position) || isFooter(position))
? gridManager.getSpanCount() : 1;
}
});
}
}
public boolean isHeader(int position) {
return position >= 0 && position < mHeaderViews.size();
}
public boolean isContentHeader(int position) {
return position >= 1 && position < mHeaderViews.size();
}
public boolean isFooter(int position) {
return position < getItemCount() && position >= getItemCount() - mFootViews.size();
}
public boolean isRefreshHeader(int position) {
return position == 0;
}
public int getHeadersCount() {
return mHeaderViews.size();
}
public int getFootersCount() {
return mFootViews.size();
}
@Override
public void onViewAttachedToWindow(ViewHolder holder) {
super.onViewAttachedToWindow(holder);
ViewGroup.LayoutParams lp = holder.itemView.getLayoutParams();
if (lp != null
&& lp instanceof StaggeredGridLayoutManager.LayoutParams
&& (isHeader(holder.getLayoutPosition()) || isFooter(holder.getLayoutPosition()))) {
StaggeredGridLayoutManager.LayoutParams p = (StaggeredGridLayoutManager.LayoutParams) lp;
p.setFullSpan(true);
}
}
@Override
public ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
if (viewType == TYPE_REFRESH_HEADER) {
mCurrentPosition++;
return new SimpleViewHolder(mHeaderViews.get(0));
} else if (isContentHeader(mCurrentPosition)) {
if (viewType == sHeaderTypes.get(mCurrentPosition - 1)) {
mCurrentPosition++;
return new SimpleViewHolder(mHeaderViews.get(headerPosition++));
}
} else if (viewType == TYPE_FOOTER) {
return new SimpleViewHolder(mFootViews.get(0));
}
return adapter.onCreateViewHolder(parent, viewType);
}
@Override
public void onBindViewHolder(ViewHolder holder, int position) {
if (isHeader(position)) {
return;
}
int adjPosition = position - getHeadersCount();
int adapterCount;
if (adapter != null) {
adapterCount = adapter.getItemCount();
if (adjPosition < adapterCount) {
adapter.onBindViewHolder(holder, adjPosition);
return;
}
}
}
@Override
public int getItemCount() {
if (adapter != null) {
return getHeadersCount() + getFootersCount() + adapter.getItemCount();
} else {
return getHeadersCount() + getFootersCount();
}
}
@Override
public long getItemId(int position) {
if (adapter != null && position >= getHeadersCount()) {
int adjPosition = position - getHeadersCount();
int adapterCount = adapter.getItemCount();
if (adjPosition < adapterCount) {
return adapter.getItemId(adjPosition);
}
}
return -1;
}
@Override
public void registerAdapterDataObserver(AdapterDataObserver observer) {
if (adapter != null) {
adapter.registerAdapterDataObserver(observer);
}
}
@Override
public void unregisterAdapterDataObserver(AdapterDataObserver observer) {
if (adapter != null) {
adapter.unregisterAdapterDataObserver(observer);
}
}
private class SimpleViewHolder extends RecyclerView.ViewHolder {
public SimpleViewHolder(View itemView) {
super(itemView);
}
}
}
/**
* 这是一个数据观察者
*/
private class DataObserver extends RecyclerView.AdapterDataObserver {
@Override
public void onChanged() {
Adapter<?> adapter = getAdapter();
if (adapter != null && mEmptyView != null) {
int emptyCount = 0;
if (pullRefreshEnabled) {
emptyCount++;
}
if (loadMoreEnabled) {
emptyCount++;
}
if (adapter.getItemCount() == emptyCount) {
mEmptyView.setVisibility(View.VISIBLE);
YRecycleview.this.setVisibility(View.GONE);
} else {
mEmptyView.setVisibility(View.GONE);
YRecycleview.this.setVisibility(View.VISIBLE);
}
}
if (mWrapAdapter != null) {
mWrapAdapter.notifyDataSetChanged();
}
}
@Override
public void onItemRangeInserted(int positionStart, int itemCount) {
mWrapAdapter.notifyItemRangeInserted(positionStart, itemCount);
}
@Override
public void onItemRangeChanged(int positionStart, int itemCount) {
mWrapAdapter.notifyItemRangeChanged(positionStart, itemCount);
}
@Override
public void onItemRangeChanged(int positionStart, int itemCount, Object payload) {
mWrapAdapter.notifyItemRangeChanged(positionStart, itemCount, payload);
}
@Override
public void onItemRangeRemoved(int positionStart, int itemCount) {
mWrapAdapter.notifyItemRangeRemoved(positionStart, itemCount);
}
@Override
public void onItemRangeMoved(int fromPosition, int toPosition, int itemCount) {
mWrapAdapter.notifyItemMoved(fromPosition, toPosition);
}
}
/**
* 设置没有更多数据了
*
* @param noMore
*/
public void setNoMoreData(boolean noMore) {
this.isNoMore = noMore;
View footView = mFootViews.get(0);
((YRecycleviewRefreshFootView) footView).setState(isNoMore ? YRecycleviewRefreshFootView.STATE_NOMORE : YRecycleviewRefreshFootView.STATE_COMPLETE);
}
/**
* 获取一个空布局
*
* @return
*/
public View getmEmptyView() {
return mEmptyView;
}
/**
* 设置空布局
*/
public void setEmptyView(View emptyView) {
mEmptyView = emptyView;
//数据改变
mDataObserver.onChanged();
}
/**
* 还原所有的状态
*/
public void reSetStatus() {
setloadMoreComplete();
refreshComplete();
}
/**
* 设置刷新完成
*/
private void refreshComplete() {
mHeadView.refreshComplete();
}
/**
* 设置加载更多完成
*/
public void setloadMoreComplete() {
//设置加载数据为false
isLoadingData = false;
View footView = mFootViews.get(0);
if (footView instanceof YRecycleviewRefreshFootView) {
((YRecycleviewRefreshFootView) footView).setState(YRecycleviewRefreshFootView.STATE_COMPLETE);
} else {
footView.setVisibility(View.GONE);
}
}
/**
* 设置刷新和加载更多的监听器
*
* @param refreshAndLoadMoreListener 监听器
*/
public void setRefreshAndLoadMoreListener(OnRefreshAndLoadMoreListener refreshAndLoadMoreListener) {
this.refreshAndLoadMoreListener = refreshAndLoadMoreListener;
}
/**
* 刷新和加载更多的监听器
*/
public interface OnRefreshAndLoadMoreListener {
void onRefresh();
void onLoadMore();
}
/**
* 设置是否启用下拉刷新功能
*
* @param isEnabled
*/
public void setReFreshEnabled(boolean isEnabled) {
pullRefreshEnabled = isEnabled;
}
/**
* 设置刷新完成
*/
public void setReFreshComplete() {
mHeadView.refreshComplete();
}
/**
* 设置是否启用上拉加载功能
*
* @param isEnabled
*/
public void setLoadMoreEnabled(boolean isEnabled) {
loadMoreEnabled = isEnabled;
//如果不启用加载更多功能,就隐藏脚布局
if (!isEnabled && mFootViews.size() > 0) {
mFootViews.get(0).setVisibility(GONE);
}
}
/**
* 设置是否刷新ing状态
*
* @param refreshing
*/
public void setRefreshing(boolean refreshing) {
if (refreshing && pullRefreshEnabled && refreshAndLoadMoreListener != null) {
mHeadView.setState(YRecycleviewRefreshHeadView.STATE_REFRESHING);
mHeadView.onMove(mHeadView.getMeasuredHeight());
refreshAndLoadMoreListener.onRefresh();
}
}
/**
* 添加头布局
*
* @param headView 刷新头布局
*/
public void addHeadView(View headView) {
if (pullRefreshEnabled && !(mHeaderViews.get(0) instanceof YRecycleviewRefreshHeadView)) {
YRecycleviewRefreshHeadView refreshHeader = new YRecycleviewRefreshHeadView(getContext());
mHeaderViews.add(0, refreshHeader);
mHeadView = refreshHeader;
}
mHeaderViews.add(headView);
sHeaderTypes.add(HEADER_INIT_INDEX + mHeaderViews.size());
}
/**
* 添加底部布局
*
* @param footView
*/
private void addFootView(YRecycleviewRefreshFootView footView) {
mFootViews.clear();
mFootViews.add(footView);
}
}
使用方式很简单,直接布局引用就可以了,其他的适配器等 与原生的一样,没有任何改变
<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent">
<yuan.kuo.yu.view.YRecycleview
android:id="@+id/ycl"
android:layout_width="match_parent"
android:layout_height="match_parent" />
</RelativeLayout>
Demo地址:github
欢迎fork和star,谢谢
标签：
原文地址：http://blog.csdn.net/easkshark/article/details/51363292
