Android开发之无痕过渡下拉刷新控件的实现思路详解

public boolean dispatchtouchevent(motionevent ev) { 
boolean consume = false;
if(onintercepttouchevent(ev)) { 
consume = ontouchevent(ev);
} else { 
consume = child.dispatchtouchevent(ev); 
}
return consume; 
}

public class refreshlayout extends linearlayout {
// 隐藏的状态
private static final int hide = 0;
// 下拉刷新的状态
private static final int pull_to_refresh = 1;
// 松开刷新的状态
private static final int release_to_refresh = 2;
// 正在刷新的状态
private static final int refreshing = 3;
// 正在隐藏的状态
private static final int hiding = 4;
// 当前状态
private int mcurrentstate = hide;
// 头部动画的默认时间（单位：毫秒）
public static final int default_duration = 200;
// 头部高度
private int mheaderheight;
// 内容控件的滑动距离
private int mcontentviewoffset;
// 记录上次的y坐标
private int mlasty;
// 最小滑动响应距离
private int mscaledtouchslop;
// 滑动的偏移量
private int mtotaldeltay;
// 是否在处理头部
private boolean misheaderhandling;
// 是否可以下拉刷新
private boolean misrefreshable = true;
// 内容控件是否可以滑动，不能滑动的控件会做触摸事件的优化
private boolean mcontentviewscrollable = true;
// 头部，为了方便演示选取了textview
private textview mheader;
// 容器要承载的内容控件，在xml里面要放置好
private view mcontentview;
// 值动画，由于头部显示隐藏
private valueanimator mheaderanimator;
// 刷新的监听器
private onrefreshlistener monrefreshlistener;

public refreshlayout(context context, attributeset attrs, int defstyleattr) {
super(context, attrs, defstyleattr);
init();
addheader(context);
}
private void init() {
mscaledtouchslop = viewconfiguration.get(getcontext()).getscaledtouchslop();
mheaderanimator = valueanimator.ofint(0).setduration(default_duration);
mheaderanimator.addupdatelistener(new valueanimator.animatorupdatelistener() {
@override
public void onanimationupdate(valueanimator valueanimator) {
if (getcontext() == null) {
// 若是退出activity了，动画结束不必执行头部动作
return;
}
// 通过设置paddingtop实现显示或者隐藏头部
int offset = (integer) valueanimator.getanimatedvalue();
mheader.setpadding(0, offset, 0, 0);
}
});
mheaderanimator.addlistener(new animatorlisteneradapter() {
@override
public void onanimationend(animator animation) {
if (getcontext() == null) {
// 若是退出activity了，动画结束不必执行头部动作
return;
}
if (mcurrentstate == release_to_refresh) {
// 释放刷新状态执行的动画结束，意味接下来就是刷新了，改状态并且调用刷新的监听
mheader.settext("正在刷新...");
mcurrentstate = refreshing;
if (monrefreshlistener != null) {
monrefreshlistener.onrefresh();
}
} else if (mcurrentstate == hiding) {
// 下拉状态执行的动画结束，隐藏头部，改状态
mheader.settext("我是头部");
mcurrentstate = hide;
}
}
});
}
// 头部的创建
private void addheader(context context) {
// 强制垂直方法
setorientation(linearlayout.vertical);
mheader = new textview(context);
mheader.setbackgroundcolor(color.gray);
mheader.settextcolor(color.white);
mheader.settext("我是头部");
mheader.settextsize(typedvalue.complex_unit_sp, 25);
mheader.setgravity(gravity.center);
addview(mheader, layoutparams.match_parent, layoutparams.wrap_content);
mheader.getviewtreeobserver().addongloballayoutlistener(new viewtreeobserver.ongloballayoutlistener() {
@override
public void ongloballayout() {
// 算出头部高度
mheaderheight = mheader.getmeasuredheight();
// 移除监听
if (build.version.sdk_int >= build.version_codes.jelly_bean) {
mheader.getviewtreeobserver().removeongloballayoutlistener(this);
} else {
mheader.getviewtreeobserver().removeglobalonlayoutlistener(this);
}
// 设置paddingtop为-mheaderheight,刚好把头部隐藏掉了
mheader.setpadding(0, -mheaderheight, 0, 0);
}
});
}

@override
protected void onfinishinflate() {
super.onfinishinflate();
// 设置长点击或者短点击都能消耗事件，要不这样做，若孩子都不消耗，最终点击事件会被它的上级消耗掉，后面一系列的事件都只给它的上级处理了
setlongclickable(true);
// 获取内容控件
mcontentview = getchildat(1);
if (mcontentview == null) {
// 为空抛异常，强制要求在xml设置内容控件
throw new illegalargumentexception("you must add a content view!");
}
if (!(mcontentview instanceof scrollingview 
|| mcontentview instanceof webview 
|| mcontentview instanceof scrollview 
|| mcontentview instanceof abslistview)) {
// 不是具有滚动的控件，这里设置标志位
mcontentviewscrollable = false;
}
}

@override
public boolean dispatchtouchevent(final motionevent event) {
if (!misrefreshable) {
// 禁止下拉刷新，直接把事件分发
return super.dispatchtouchevent(event);
}
if ((mcurrentstate == refreshing 
|| mcurrentstate == release_to_refresh 
|| mcurrentstate == hiding) 
&& mheaderanimator.isrunning()) {
// 正在刷新，正在释放，正在隐藏头部都不处理事件，并且不分发下去
return true;
}
int y = (int) event.gety();
switch (event.getaction()) {
case motionevent.action_down:
break;
case motionevent.action_move: {
int deltay = y - mlasty;
if (mcontentviewoffset == 0 && (deltay > 0 || (deltay < 0 && isheadershowing()))) {
// 偏移值为0时，下拉或者在头部还在显示的时候上滑时，交由自己处理滑动事件
mtotaldeltay += deltay;
if (mtotaldeltay > 0 
&& mtotaldeltay <= mscaledtouchslop
&& !isheadershowing()) {
// 优化下拉头部，不要稍微一点位移就响应
mlasty = y;
return super.dispatchtouchevent(event);
}
// 处理事件
onhandletouchevent(event);
// 正在处理事件
misheaderhandling = true;
if (mcurrentstate == refreshing) {
// 正在刷新，不让contentview响应滑动
event.setaction(motionevent.action_cancel);
}
} else if (misheaderhandling) {
// 在头部隐藏的那一瞬间的事件特殊处理
if (mcontentviewscrollable) {
// 1.可滑动的view，由于之前处理头部，之前的move事件没有传递到内容页，这里
// 需要要action_down来重新告知滑动的起点，不然会瞬间滑动一段距离
// 2.对于不滑动的view设置了点击事件，若这里给它一个action_down事件，在手指
// 抬起时action_up事件会触发点击，因此这里做了处理
event.setaction(motionevent.action_down);
}
misheaderhandling = false;
}
break;
}
case motionevent.action_cancel:
case motionevent.action_up: {
if (mcontentviewoffset == 0 && isheadershowing()) {
// 处理手指抬起或取消事件
onhandletouchevent(event);
}
mtotaldeltay = 0;
break;
}
default:
break;
}
mlasty = y;
if (mcurrentstate != refreshing 
&& isheadershowing() 
&& event.getaction() != motionevent.action_up) {
// 不是在刷新的时候，并且头部在显示， 不让contentview响应事件
event.setaction(motionevent.action_cancel);
}
return super.dispatchtouchevent(event);
}

// 自己处理事件
public boolean onhandletouchevent(motionevent event) {
int y = (int) event.gety();
switch (event.getaction()) {
case motionevent.action_move: {
// 拿到y方向位移
int deltay = y - mlasty;
// 除以3相当于阻尼值
deltay /= 3;
// 计算出移动后的头部位置
int top = deltay + mheader.getpaddingtop();
// 控制头部位置最大不超过-mheaderheight
if (top < -mheaderheight) {
mheader.setpadding(0, -mheaderheight, 0, 0);
} else {
mheader.setpadding(0, top, 0, 0);
}
if (mcurrentstate == refreshing) {
// 之前还在刷新状态，继续维持刷新状态
mheader.settext("正在刷新...");
break;
}
if (mheader.getpaddingtop() > mheaderheight / 2) {
// 大于mheaderheight / 2时可以刷新了
mheader.settext("可以释放刷新...");
mcurrentstate = release_to_refresh;
} else {
// 下拉状态
mheader.settext("正在下拉...");
mcurrentstate = pull_to_refresh;
}
break;
}
case motionevent.action_up: {
if (mcurrentstate == release_to_refresh) {
// 释放刷新状态，手指抬起，通过动画实现头部回到（0，0）位置
mheaderanimator.setintvalues(mheader.getpaddingtop(), 0);
mheaderanimator.setduration(default_duration);
mheaderanimator.start();
mheader.settext("正在释放...");
} else if (mcurrentstate == pull_to_refresh || mcurrentstate == refreshing) {
// 下拉状态或者正在刷新状态，通过动画隐藏头部
mheaderanimator.setintvalues(mheader.getpaddingtop(), -mheaderheight);
if (mheader.getpaddingtop() <= 0) {
mheaderanimator.setduration((long) (default_duration * 1.0 / 
mheaderheight * (mheader.getpaddingtop() + mheaderheight)));
} else {
mheaderanimator.setduration(default_duration);
}
mheaderanimator.start();
if (mcurrentstate == pull_to_refresh) {
// 下拉状态的话，把状态改为正在隐藏头部状态
mcurrentstate = hiding;
mheader.settext("收回头部...");
}
}
break;
}
default:
break;
}
mlasty = y;
return super.ontouchevent(event);
}

// 设置内容页滑动距离
public void setcontentviewoffset(int offset) {
mcontentviewoffset = offset;
}
/**
* 根据不同类型的view采取不同类型策略去计算滑动距离
*
* @param view 内容view
*/
public void handletargetoffset(view view) {
if (view instanceof recyclerview) {
((recyclerview) view).addonscrolllistener(new recyclerviewonscrolllistener());
} else if (view instanceof nestedscrollview) {
((nestedscrollview) view).setonscrollchangelistener(new nestedscrollviewonscrollchangelistener());
} else if (view instanceof webview) {
view.setontouchlistener(new webviewontouchlistener());
} else if (view instanceof scrollview) {
view.setontouchlistener(new scrollviewontouchlistener());
} else if (view instanceof listview) {
((listview) view).setonscrolllistener(new listviewonscrolllistener());
}
}
/**
* 适用于recyclerview的滑动距离监听
*/
public class recyclerviewonscrolllistener extends recyclerview.onscrolllistener {
int offset = 0;
@override
public void onscrolled(recyclerview recyclerview, int dx, int dy) {
super.onscrolled(recyclerview, dx, dy);
offset += dy;
setcontentviewoffset(offset);
}
}
/**
* 适用于nestedscrollview的滑动距离监听
*/
public class nestedscrollviewonscrollchangelistener implements nestedscrollview.onscrollchangelistener {
@override
public void onscrollchange(nestedscrollview v, int scrollx, int scrolly, int oldscrollx, int oldscrolly) {
setcontentviewoffset(scrolly);
}
}
/**
* 适用于webview的滑动距离监听
*/
public class webviewontouchlistener implements view.ontouchlistener {
@override
public boolean ontouch(view view, motionevent motionevent) {
setcontentviewoffset(view.getscrolly());
return false;
}
}
/**
* 适用于scrollview的滑动距离监听
*/
public class scrollviewontouchlistener extends webviewontouchlistener {
}
/**
* 适用于listview的滑动距离监听
*/
public class listviewonscrolllistener implements abslistview.onscrolllistener {
@override
public void onscrollstatechanged(abslistview abslistview, int i) {
}
@override
public void onscroll(abslistview view, int firstvisibleitem, int visibleitemcount, int totalitemcount) {
if (firstvisibleitem == 0) {
view c = view.getchildat(0);
if (c == null) {
return;
}
int firstvisibleposition = view.getfirstvisibleposition();
int top = c.gettop();
int scrolledy = -top + firstvisibleposition * c.getheight();
setcontentviewoffset(scrolledy);
} else {
setcontentviewoffset(1);
}
}
}

public void setrefreshing(boolean refreshing) {
if (refreshing && mcurrentstate != refreshing) {
// 强开刷新头部
openheader();
} else if (!refreshing) {
closeheader();
}
}
private void openheader() {
post(new runnable() {
@override
public void run() {
mcurrentstate = release_to_refresh;
mheaderanimator.setduration((long) (default_duration * 2.5));
mheaderanimator.setintvalues(mheader.getpaddingtop(), 0);
mheaderanimator.start();
}
});
}
private void closeheader() {
mheader.settext("刷新完毕，收回头部...");
mcurrentstate = hiding;
mheaderanimator.setintvalues(mheader.getpaddingtop(), -mheaderheight);
// 0~-mheaderheight用时default_duration
mheaderanimator.setduration(default_duration);
mheaderanimator.start();
}