自定义可扩展叠加头部的下拉控件

最近写了个下拉控件，和几个下拉的头部样式，下拉控件可以连续添加叠加几个头部视图

下面是没有添加任何头部尾部的视图下拉效果

一步一步来介绍，先介绍这个下拉效果，在介绍自定义的头部

首先在使用上，和普通的控件没有两样，拿recyclerview来做例子，因为recyclerview使用比较多，而且可以替代很多的列表控件

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:orientation="vertical">

    <com.fragmentapp.view.refresh.RefreshLayout
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        app:_height="@dimen/dp_60"
        android:id="@+id/refreshLayout" >

        <android.support.v7.widget.RecyclerView
            android:id="@+id/recyclerView"
            android:divider="@color/color_e1e1e1"
            android:dividerHeight="10dp"
            android:background="#ffffff"
            android:layout_width="match_parent"
            android:layout_height="match_parent" />
    </com.fragmentapp.view.refresh.RefreshLayout>

</LinearLayout>

protected void init() {
        for (int i = 0; i < 20; i++) {
            list.add("" + i);
        }

        recyclerView.setLayoutManager(new LinearLayoutManager(getActivity()));
        recyclerView.setAdapter(new HomeAdapter(getActivity(), R.layout.item_home, list));
        refreshLayout
                .setCallBack(new RefreshLayout.CallBack() {
                    @Override
                    public void refreshHeaderView(int state, String stateVal) {

                        switch (state) {
                            case RefreshLayout.DOWN_REFRESH: // 下拉刷新状态

                                break;
                            case RefreshLayout.RELEASE_REFRESH: // 松开刷新状态

                                break;
                            case RefreshLayout.LOADING: // 正在刷新中状态

                                break;
                        }
                    }

                    @Override
                    public void pullListener(int y) {

                    }
                });
    }

package com.fragmentapp.view.refresh;

import android.content.Context;
import android.content.res.TypedArray;
import android.graphics.Color;
import android.graphics.Rect;
import android.support.v4.view.ViewCompat;
import android.support.v7.widget.LinearLayoutManager;
import android.support.v7.widget.RecyclerView;
import android.support.v7.widget.StaggeredGridLayoutManager;
import android.util.AttributeSet;
import android.util.Log;
import android.view.Gravity;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewConfiguration;
import android.widget.AbsListView;
import android.widget.FrameLayout;

import com.fragmentapp.R;

import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.List;

/**
 * Created by LiuZhen on 2017/3/24.
 */
public class RefreshLayout extends FrameLayout {

    private String TAG = "tag";
    private int downY;// 按下时y轴的偏移量
    private final static float RATIO = 3f;
    //头部的高度
    protected int mHeadHeight = 120;
    //头部layout
    protected FrameLayout mHeadLayout,mFootLayout;//头部容器
    private List<IHeadView> heads = new ArrayList<>();//支持添加多个头部
    private List<IFootView> foots = new ArrayList<>();

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

    private View list;//子节点中的 recyclerview 视图
    private LayoutParams listParam,footParam;//用于控制下拉动画展示
    private boolean isLoadingMore = false;// 是否进入加载状态，防止多次重复的启动
    private boolean isStart = false;//表示正在加载刷新中，还没停止
    private boolean isTop = false,isBottom = false;
    private int mTouchSlop;
    private CallBack callBack;

    public RefreshLayout(Context context) {
        this(context, null, 0);
    }

    public RefreshLayout(Context context, AttributeSet attrs) {
        this(context, attrs, 0);
    }

    public RefreshLayout(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);

        TypedArray a = context.obtainStyledAttributes(attrs, R.styleable.RefreshLayout, defStyleAttr, 0);
        try {
            mHeadHeight = a.getDimensionPixelSize(R.styleable.RefreshLayout__height, 120);
        } finally {
            a.recycle();
        }
        mTouchSlop = ViewConfiguration.get(getContext()).getScaledTouchSlop();

        init();
    }

    private void initHeaderContainer() {
        mHeadLayout = new FrameLayout(getContext());
        LayoutParams layoutParams = new LayoutParams(LayoutParams.MATCH_PARENT,mHeadHeight);
        this.addView(mHeadLayout,layoutParams);
    }

    public void initFootContainer() {
        footParam = new LayoutParams(LayoutParams.MATCH_PARENT,mHeadHeight);
        mFootLayout = new FrameLayout(getContext());//底部布局
        mFootLayout.setBackgroundColor(Color.BLACK);
        footParam.gravity = Gravity.BOTTOM | Gravity.CENTER_HORIZONTAL;
        footParam.setMargins(0,0,0,-mHeadHeight);
        this.addView(mFootLayout,footParam);
    }

    private void init(){
        initHeaderContainer();
    }

    @Override
    protected void onFinishInflate() {//布局加载成xml时触发
        super.onFinishInflate();

        initFootContainer();
        if (list == null) {
            list = getChildAt(1);
            listParam = (LayoutParams) list.getLayoutParams();
            list.setOnTouchListener(new OnTouchListener() {
                @Override
                public boolean onTouch(View v, MotionEvent event) {
                    return onFingerTouch(event);
                }
            });
        }
    }

    /**
     * 设置头部View
     */
    public RefreshLayout setHeaderView(final IHeadView headView) {
        if (headView != null) {
            mHeadLayout.addView(headView.getView());
            heads.add(headView);
        }
        return this;
    }

    /**
     * 设置尾部View
     */
    public RefreshLayout setFootView(final IFootView footView) {
        if (footView != null) {
            mFootLayout.addView(footView.getView());
            foots.add(footView);
        }
        return this;
    }

    public boolean onFingerTouch(MotionEvent ev) {
        isTop = isViewToTop(list,mTouchSlop);
        isBottom = isViewToBottom(list,mTouchSlop);
//        Log.e(TAG,"isTop "+isTop+" isBottom "+isBottom);
        switch (ev.getAction()) {
            case MotionEvent.ACTION_DOWN :
                currentState = LOADING;
                downY = (int) ev.getY();
                break;
            case MotionEvent.ACTION_MOVE :
                if (!isTop && !isBottom)//没有到顶，无需计算操作
                    break;
                int moveY = (int) ev.getY();
                int diff = (int) (((float)moveY - (float)downY) / RATIO);
//                int paddingTop = -mHeadLayout.getHeight() + diff;
                int paddingTop = diff;
                if (paddingTop>0 && isTop) {
                    //向下滑动多少后开始启动刷新,Margin判断是为了限制快速用力滑动的时候导致头部侵入的高度不够就开始加载了
                    if (paddingTop >= mHeadHeight && (listParam.topMargin >= mHeadHeight) && currentState == DOWN_REFRESH) { // 完全显示了.
//                        Log.i(TAG, "松开刷新 RELEASE_REFRESH");
                        currentState = RELEASE_REFRESH;
                        refreshHeaderView();
                        start();
                    } else if (currentState == LOADING) { // 没有显示完全
//                        Log.i(TAG, "下拉刷新 DOWN_PULL_REFRESH");
                        currentState = DOWN_REFRESH;
                        refreshHeaderView();
                    }
                    if (paddingTop <= (mHeadHeight+10) && !isStart) {//已经处于运行刷新状态的时候禁止设置
                        listParam.setMargins(0, paddingTop, 0, 0);
                        list.setLayoutParams(listParam);
                        if (callBack != null)
                            callBack.pullListener(paddingTop);
                    }

                }else if (isBottom){
                    //限制上滑时不能超过底部的宽度，不然会超出边界
                    //mHeadHeight+20 上滑设置的margin要超过headheight，不然下面判断的大于headheight不成立，下面的margin基础上面设置后的参数
                    if (Math.abs(paddingTop) <= (mHeadHeight+10) && !isStart) {//已经处于运行刷新状态的时候禁止设置
                        listParam.setMargins(0, 0, 0, -paddingTop);
                        footParam.setMargins(0,0,0,-paddingTop-mHeadHeight);
                        list.setLayoutParams(listParam);
                    }
                    //如果滑动的距离大于头部或者底部的高度，并且设置的margin也大于headheight
                    //listParam用来限制recyclerview列表迅速滑动，footParam用来限制bottom foothead迅速滑动导致没有达到head的高度就开始加载了
                    if (Math.abs(paddingTop) >= mHeadHeight && (listParam.bottomMargin >= mHeadHeight || footParam.bottomMargin >= 0))
                        isLoadingMore = true;//头部是否拉取到位，然后执行加载动画

                }
//                Log.e(TAG,"paddingTop "+paddingTop +" mHeadHeight "+mHeadHeight+ " topMargin "+listParam.topMargin+" bottomMargin "+listParam.bottomMargin
//                        +" footParam bottom "+footParam.bottomMargin);
//                Log.i(TAG,"paddingTop "+paddingTop);
                break;
            case MotionEvent.ACTION_UP :
                currentState = LOADING;
                refreshHeaderView();
                if (isLoadingMore){
                    isLoadingMore = false;
                    isStart = true;//是否开始加载
                    postDelayed(new Runnable() {
                        @Override
                        public void run() {
//                            Log.i(TAG, "停止 END");
//                            currentState = END;
                            refreshHeaderView();
                            listParam.setMargins(0, 0, 0, 0);
                            footParam.setMargins(0,0,0,-mHeadHeight);
                            list.setLayoutParams(listParam);
                            stop();
                        }
                    },2000);
                }else{
                    if (!isStart){
                        // 隐藏头布局
                        listParam.setMargins(0, 0,0,0);
                        footParam.setMargins(0,0,0,-mHeadHeight);
                        list.setLayoutParams(listParam);
                    }
                }
//                Log.i(TAG, "松开 REFRESHING");
                break;
            default :
                break;
        }
        return super.onTouchEvent(ev);
    }

    /**
     * 根据currentState刷新头布局的状态
     */
    private void refreshHeaderView() {
        if (callBack == null || isStart)
            return;
        String val = "准备刷新";
        switch (currentState) {
            case DOWN_REFRESH : // 下拉刷新状态
                val = "下拉刷新";
                break;
            case RELEASE_REFRESH : // 松开刷新状态
                val = "开始刷新...";
                break;
            case LOADING : // 正在刷新中状态
                val = "正在刷新中...";
                break;
        }
        callBack.refreshHeaderView(currentState,val);
    }

    public static boolean isViewToTop(View view, int mTouchSlop){
        if (view instanceof AbsListView) return isAbsListViewToTop((AbsListView) view);
        if (view instanceof RecyclerView) return isRecyclerViewToTop((RecyclerView) view);
        return  (view != null && Math.abs(view.getScrollY()) <= 2 * mTouchSlop);
    }

    public static boolean isViewToBottom(View view, int mTouchSlop){
        if (view instanceof AbsListView) return isAbsListViewToBottom((AbsListView) view);
        if (view instanceof RecyclerView) return isRecyclerViewToBottom((RecyclerView) view);
//        if (view instanceof WebView) return isWebViewToBottom((WebView) view,mTouchSlop);
//        if (view instanceof ViewGroup) return isViewGroupToBottom((ViewGroup) view);
        return false;
    }

    public static boolean isAbsListViewToTop(AbsListView absListView) {
        if (absListView != null) {
            int firstChildTop = 0;
            if (absListView.getChildCount() > 0) {
                // 如果AdapterView的子控件数量不为0，获取第一个子控件的top
                firstChildTop = absListView.getChildAt(0).getTop() - absListView.getPaddingTop();
            }
            if (absListView.getFirstVisiblePosition() == 0 && firstChildTop == 0) {
                return true;
            }
        }
        return false;
    }

    public static boolean isRecyclerViewToTop(RecyclerView recyclerView) {
        if (recyclerView != null) {
            RecyclerView.LayoutManager manager = recyclerView.getLayoutManager();
            if (manager == null) {
                return true;
            }
            if (manager.getItemCount() == 0) {
                return true;
            }

            if (manager instanceof LinearLayoutManager) {
                LinearLayoutManager layoutManager = (LinearLayoutManager) manager;

                int firstChildTop = 0;
                if (recyclerView.getChildCount() > 0) {
                    // 处理item高度超过一屏幕时的情况
                    View firstVisibleChild = recyclerView.getChildAt(0);
                    if (firstVisibleChild != null && firstVisibleChild.getMeasuredHeight() >= recyclerView.getMeasuredHeight()) {
                        if (android.os.Build.VERSION.SDK_INT < 14) {
                            return !(ViewCompat.canScrollVertically(recyclerView, -1) || recyclerView.getScrollY() > 0);
                        } else {
                            return !ViewCompat.canScrollVertically(recyclerView, -1);
                        }
                    }

                    // 如果RecyclerView的子控件数量不为0，获取第一个子控件的top

                    // 解决item的topMargin不为0时不能触发下拉刷新
                    View firstChild = recyclerView.getChildAt(0);
                    RecyclerView.LayoutParams layoutParams = (RecyclerView.LayoutParams) firstChild.getLayoutParams();
                    firstChildTop = firstChild.getTop() - layoutParams.topMargin - getRecyclerViewItemTopInset(layoutParams) - recyclerView.getPaddingTop();
                }

                if (layoutManager.findFirstCompletelyVisibleItemPosition() < 1 && firstChildTop == 0) {
                    return true;
                }
            } else if (manager instanceof StaggeredGridLayoutManager) {
                StaggeredGridLayoutManager layoutManager = (StaggeredGridLayoutManager) manager;

                int[] out = layoutManager.findFirstCompletelyVisibleItemPositions(null);
                if (out[0] < 1) {
                    return true;
                }
            }
        }
        return false;
    }

    /**
     * 通过反射获取RecyclerView的item的topInset
     */
    private static int getRecyclerViewItemTopInset(RecyclerView.LayoutParams layoutParams) {
        try {
            Field field = RecyclerView.LayoutParams.class.getDeclaredField("mDecorInsets");
            field.setAccessible(true);
            // 开发者自定义的滚动监听器
            Rect decorInsets = (Rect) field.get(layoutParams);
            return decorInsets.top;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return 0;
    }

    public static boolean isAbsListViewToBottom(AbsListView absListView) {
        if (absListView != null && absListView.getAdapter() != null && absListView.getChildCount() > 0 && absListView.getLastVisiblePosition() == absListView.getAdapter().getCount() - 1) {
            View lastChild = absListView.getChildAt(absListView.getChildCount() - 1);

            return lastChild.getBottom() <= absListView.getMeasuredHeight();
        }
        return false;
    }

    public static boolean isRecyclerViewToBottom(RecyclerView recyclerView) {
        if (recyclerView != null) {
            RecyclerView.LayoutManager manager = recyclerView.getLayoutManager();
            if (manager == null || manager.getItemCount() == 0) {
                return false;
            }

            if (manager instanceof LinearLayoutManager) {
                // 处理item高度超过一屏幕时的情况
                View lastVisibleChild = recyclerView.getChildAt(recyclerView.getChildCount() - 1);
                if (lastVisibleChild != null && lastVisibleChild.getMeasuredHeight() >= recyclerView.getMeasuredHeight()) {
                    if (android.os.Build.VERSION.SDK_INT < 14) {
                        return !(ViewCompat.canScrollVertically(recyclerView, 1) || recyclerView.getScrollY() < 0);
                    } else {
                        return !ViewCompat.canScrollVertically(recyclerView, 1);
                    }
                }

                LinearLayoutManager layoutManager = (LinearLayoutManager) manager;
                if (layoutManager.findLastCompletelyVisibleItemPosition() == layoutManager.getItemCount() - 1) {
                    return true;
                }
            } else if (manager instanceof StaggeredGridLayoutManager) {
                StaggeredGridLayoutManager layoutManager = (StaggeredGridLayoutManager) manager;

                int[] out = layoutManager.findLastCompletelyVisibleItemPositions(null);
                int lastPosition = layoutManager.getItemCount() - 1;
                for (int position : out) {
                    if (position == lastPosition) {
                        return true;
                    }
                }
            }
        }
        return false;
    }

    public void start(){
        isLoadingMore = true;
        for (IHeadView head : heads) {
            head.startAnim();
        }
    }

    public void stop(){
        isLoadingMore = false;
        isStart = false;
        for (IHeadView head : heads) {
            head.stopAnim();
        }
    }

    public RefreshLayout setCallBack(CallBack callBack) {
        this.callBack = callBack;
        return this;
    }

    public interface CallBack{
        /**监听下拉时的状态*/
        void refreshHeaderView(int state,String stateVal);
        /**监听下拉时的距离*/
        void pullListener(int y);
    }


}

注释估计也没有我写的这么详细的了，相信不是完全不懂的话肯定一眼就看懂了

至于 refreshLayout 这个下拉控件里面的代码是完整的，没有去截取，不过写了非常非常详细的注释，但是还是大致的讲下实现的流程

首先是继承一个布局，方面添加各种节点，比较直接view的话很难实现，代码量也多，伤不起，也没时间

实现构造函数后初始化各种操作，这里给头部的下拉提供一个容器，因为需要叠加添加头部，所以需要一个父容器去控制子头部的一个添加和删除的控制，有了这个布局，那么就可以控制这个容器去做一些下拉的效果，还有往里面添加一些头部效果了

初始化后我们需要获取recyclerview控件了，因为需要监听它的一些操作和状态，这里不让它传进去，因为这样依赖性太强了，不传进来也可以很好的获取，比较是子view视图，可以直接通过getChildAt获取

获取到recyclerview那么可以监听它的一个touch事件，而这里的list是一个view类型，至于为什么不是recycyclerview类型我想就不用多说了，如果直接是recyclerview类型的话那我跟直接传参数进来就没什么两样了，这样的做法就没意义了

重点就是这个监听事件了，想想也知道，下拉上拉所有的效果都需要去监听它的一个滑动状态来判断的，所以核心的操作基本在这里面了

public boolean onFingerTouch(MotionEvent ev) {
        isTop = isViewToTop(list, mTouchSlop);
        isBottom = isViewToBottom(list, mTouchSlop);
//        Log.e(TAG,"isTop "+isTop+" isBottom "+isBottom);
        switch (ev.getAction()) {
            case MotionEvent.ACTION_DOWN:
                currentState = LOADING;
                downY = (int) ev.getY();
                break;
            case MotionEvent.ACTION_MOVE:
                if (!isTop && !isBottom)//没有到顶，无需计算操作
                    break;
                int moveY = (int) ev.getY();
                /**
                 * 得到滑动的距离，可以打印出日志查看，如果滑动的速度很快，那么得到距离的跨度会很大，比如快速滑动，可能只得到三个数据，50，400，700，而如果缓慢的
                 * 滑动，则30，35，39，41...696,700,显然我们想得到的是后面的数据，否则跨度很大会出现闪速的现象
                 * */
                int diff = moveY - downY;
                /**这里是为了降低跨度存在的，尽量的让数值跨度不要那么大*/
                int paddingTop = diff  / RATIO;

                if (paddingTop > 0 && isTop) {
                    //向下滑动多少后开始启动刷新,Margin判断是为了限制快速用力滑动的时候导致头部侵入的高度不够就开始加载了
                    if (paddingTop >= mHeadHeight && (listParam.topMargin >= mHeadHeight) && currentState == DOWN_REFRESH) { // 完全显示了.
//                        Log.i(TAG, "松开刷新 RELEASE_REFRESH");
                        currentState = RELEASE_REFRESH;
                        refreshHeaderView();
                        start();
                    } else if (currentState == LOADING) { // 没有显示完全
//                        Log.i(TAG, "下拉刷新 DOWN_PULL_REFRESH");
                        currentState = DOWN_REFRESH;
                        refreshHeaderView();
                    }
                    if (paddingTop <= (mHeadHeight + 10) && !isStart) {//已经处于运行刷新状态的时候禁止设置
                        listParam.setMargins(0, paddingTop, 0, 0);
                        list.setLayoutParams(listParam);
                        if (callBack != null)
                            callBack.pullListener(paddingTop);
                    }
                } else if (isBottom) {
                    //限制上滑时不能超过底部的宽度，不然会超出边界
                    //mHeadHeight+20 上滑设置的margin要超过headheight，不然下面判断的大于headheight不成立，下面的margin基础上面设置后的参数
                    if (Math.abs(paddingTop) <= (mHeadHeight + 10) && !isStart) {//已经处于运行刷新状态的时候禁止设置
                        listParam.setMargins(0, 0, 0, -paddingTop);
                        footParam.setMargins(0, 0, 0, -paddingTop - mHeadHeight);
                        list.setLayoutParams(listParam);
                    }
                    //如果滑动的距离大于头部或者底部的高度，并且设置的margin也大于headheight
                    //listParam用来限制recyclerview列表迅速滑动，footParam用来限制bottom foothead迅速滑动导致没有达到head的高度就开始加载了
                    if (Math.abs(paddingTop) >= mHeadHeight && (listParam.bottomMargin >= mHeadHeight || footParam.bottomMargin >= 0))
                        isLoadingMore = true;//头部是否拉取到位，然后执行加载动画

                }
                break;
            case MotionEvent.ACTION_UP:
                if (isLoadingMore) {//是否开始加载
                    currentState = LOADING;
                    refreshHeaderView();
                    isLoadingMore = false;
                    isStart = true;//是否开始加载
//                    postDelayed(new Runnable() {//没有网络访问时固定2秒加载完成
//                        @Override
//                        public void run() {
////                            Log.i(TAG, "停止 END");
////                            currentState = END;
//                            stop();
//                        }
//                    },2000);
                } else {
                    if (!isStart) {
                        // 隐藏头布局
                        listParam.setMargins(0, 0, 0, 0);
                        footParam.setMargins(0, 0, 0, -mHeadHeight);
                        list.setLayoutParams(listParam);
                    }
                }
//                Log.i(TAG, "松开 REFRESHING");
                break;
            default:
                break;
        }
        return super.onTouchEvent(ev);
    }

注释没得说，大致的一个流程就是分下拉和下拉的判断

1：按下后获取getY，就是y轴坐标，也就是起点，后面用来计算滑动的距离

2：手指滑动，同样在获取getY，然后相减，得到滑动的距离Y，然后上面recyclerview对象的作用来了，这里的上滑还是下滑不采用手指滑动计算来判断，而是用recyclerview来判断是否到顶，如果到top顶点，那么就开始下拉，反之就是上拉操作，毕竟手势的判断不是很精确，这样核心的判断出来，一个上，一个下，至于具体的逻辑看着代码根据注释看了，因为那部分的注释特别详细，而值得一说的就是这里的下拉上拉是采用设置margin来做的

3：手指滑动完毕，抬起操作，到这里基本就是收尾的工作了，这里因为是写死的数据，没有网络访问，所以就是定死，设置拉下时长两秒，然后完成下拉操作后就还原起点

上拉过程中提供对外的监听回调，这里有两个回调，第一个回调是带有状态和状态值的一个参数，第二个回调就是拉下的一个坐标距离，在后面的头部视图会用到，这个可以自行扩展

 

然后就是头部的添加操作，之前说的容器用来放下拉视图，而要叠加效果添加多个头部就需要一个集合存放了，用来控制每个头部

接下来就是addview的操作了

因为每个头部都需要继承head接口，这是为了减低耦合度，不直接依赖头部，可以自行扩展，建造者模式返回本身对象，这样方便扩展

 这里提供了三个控制方法，getView，这个必须的，可以获取到每个头部的实例，然后操作，然后每个头部可以添加动画，所以有开始动画和关闭动画的方法

public interface IHeadView {

    View getView();
    void startAnim();
    void stopAnim();

}

这样在每个头部如果有动画的话就能在回调接口里实现了

而启动和停止动画肯定是跟随着下拉的状态变化而启动的，所以调用都在touch监听里面，至于什么时候调用可以根据具体需求去调用

然后现在开始定义头部效果，说到头部效果，扇形的下拉回弹首选了，因为已经有很多例子了，所以我也模仿做了一个，还有一个原因是为了后面的头部做铺垫，叠加头部，那么最先添加的头部肯定要有当背景的觉悟了，先看效果图

 上代码，同样是非常非常详细的注释

package com.fragmentapp.view.refresh;

import android.animation.ValueAnimator;
import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.graphics.Path;
import android.util.AttributeSet;
import android.view.View;
import android.view.animation.DecelerateInterpolator;
import android.view.animation.OvershootInterpolator;

import com.fragmentapp.R;

/**
 * Created by liuzhen on 2017/11/29.
 */

public class DownHeadView extends View implements IHeadView{

    private int pull_height;
    private Path mPath;
    private Paint mBackPaint;
    private int backColor;
    private int mWidth;
    private int mHeight;
    private DecelerateInterpolator decelerateInterpolator = new DecelerateInterpolator(10);

    public DownHeadView(Context context) {
        this(context, null);
    }

    public DownHeadView(Context context, AttributeSet attrs) {
        this(context, attrs, 0);
    }

    public DownHeadView(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        init();
    }

    private void init(){
        setWillNotDraw(false);
        backColor = getResources().getColor(R.color.color_8b90af);
        mPath = new Path();
        mBackPaint = new Paint();
        mBackPaint.setAntiAlias(true);
        mBackPaint.setStyle(Paint.Style.FILL);
        mBackPaint.setColor(backColor);
    }

    @Override
    protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
        super.onLayout(changed, left, top, right, bottom);
        if (changed) {
            mWidth = getWidth();
            mHeight = getHeight();
        }
    }

    @Override
    protected void onDraw(Canvas canvas) {
        canvas.drawRect(0, 0, mWidth, pull_height, mBackPaint);

        mPath.reset();
        mPath.moveTo(0, pull_height);//起点
        mPath.quadTo(mWidth/2,pull_height*2,mWidth,pull_height);//控制点和终点

        canvas.drawPath(mPath, mBackPaint);//绘制二级贝塞尔弧形
        invalidate();
    }

    @Override
    public View getView() {
        return this;
    }


    @Override
    public void startAnim() {
        backColor = getResources().getColor(R.color.color_8babaf);
        mBackPaint.setColor(backColor);
        ValueAnimator va = ValueAnimator.ofFloat(mHeight, mHeight/2);
        va.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
            @Override
            public void onAnimationUpdate(ValueAnimator animation) {
                float val = (float) animation.getAnimatedValue();
                val = decelerateInterpolator.getInterpolation(val / mHeight) * val;
                pull_height = (int)val;
                requestLayout();
            }
        });
        va.setInterpolator(new OvershootInterpolator(3));//甩动差值器
        va.setDuration(500);
        va.start();
    }

    @Override
    public void stopAnim() {
        backColor = getResources().getColor(R.color.color_8b90af);
        mBackPaint.setColor(backColor);
    }
    /**改变控制点*/
    public void setPull_height(int y){
        pull_height = y;
        invalidate();
    }

}

扇形下拉头部实现流程也比较简单

首先抛开动画，是先绘制出一个矩形，然后下面的扇形利用二级的杯赛二线绘制，以y抽为控制点，达到拉伸变长的一个效果

然后拉到最低的时候在开启一个回弹动画或者甩动的动画

 

使用也是很简单的一两行代码

只需要添加一个头部和在回调中把拉伸的值传进去就可以了，到这里背景头部就好了，下面就是继续叠加头部效果了

 

看起来好像是一个视图，其实是两个，第二个头部的效果也是比较简单的一个效果，绘制了一个粘性的回弹效果

package com.fragmentapp.view.refresh;

import android.animation.ValueAnimator;
import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.Path;
import android.graphics.PointF;
import android.support.annotation.Nullable;
import android.util.AttributeSet;
import android.util.Log;
import android.view.View;
import android.view.animation.OvershootInterpolator;

import com.fragmentapp.R;

/**
 * Created by liuzhen on 2017/12/4.
 */

public class StickyHeadView extends View implements IHeadView {

    private Paint mPaint;
    private int bg;
    private float mStaicRadius = 20f;// 直径
    private float mMoveRadius = 20f;// 直径

    // 存储静态的两个点
    private PointF[] mStaticPointFs = new PointF[2];
    // 存储移动的两个点
    private PointF[] mMovewPointFs = new PointF[2];
    // 控制点
    private PointF mControlPointF = new PointF();
    // 静态点
    private PointF staticCenterPointF = null;
    // 移动点
    private PointF movewCenterPointF = null;

    public StickyHeadView(Context context) {
        this(context, null, 0);
    }

    public StickyHeadView(Context context, @Nullable AttributeSet attrs) {
        this(context, attrs, 0);
    }

    public StickyHeadView(Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        init();
    }

    private void init() {
        mPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
        bg = getResources().getColor(R.color.color_8babaf);
        mPaint.setColor(bg);
    }

    @Override
    protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
        super.onLayout(changed, left, top, right, bottom);
        if (changed) {
            staticCenterPointF = new PointF(getWidth() / 2, getHeight()/4);
            movewCenterPointF = new PointF(getWidth() / 2, getHeight()/4);
        }
    }

    @Override
    protected void onDraw(Canvas canvas) {
        // 1、获得偏移量
        float yOffset = staticCenterPointF.y - movewCenterPointF.y;
        float xOffset = staticCenterPointF.x - movewCenterPointF.x;
        // 2、有了偏移量就可以求出两点斜率了
        Double lineK = 0.0;
        if (xOffset != 0f) {
            lineK = (double) (yOffset / xOffset);
        }
        // 3、通过工具求得两个点的集合
        mMovewPointFs = getIntersectionPoints(movewCenterPointF, mMoveRadius, lineK);
        mStaticPointFs = getIntersectionPoints(staticCenterPointF, mStaicRadius, lineK);
        // 4、通过公式求得控制点
        mControlPointF = getMiddlePoint(staticCenterPointF, movewCenterPointF);

        // 保存画布状态，保存方法之后的代码，能够调用Canvas的平移、放缩、旋转、裁剪等操作
//        canvas.save();

        // 工型绘制
        Path path = new Path();
        // 左上角点
        path.moveTo(mStaticPointFs[0].x, mStaticPointFs[0].y);
        // 上一边的弯度和右上角点
        path.quadTo(mControlPointF.x, mControlPointF.y, mMovewPointFs[0].x, mMovewPointFs[0].y);
        // 右下角点
        path.lineTo(mMovewPointFs[1].x, mMovewPointFs[1].y);
        // 下一边的弯度和左下角点
        path.quadTo(mControlPointF.x, mControlPointF.y, mStaticPointFs[1].x, mStaticPointFs[1].y);
        // 关闭后，会回到最开始的地方，形成封闭的图形
        path.close();

        canvas.drawPath(path, mPaint);

        canvas.drawCircle(staticCenterPointF.x, staticCenterPointF.y, mStaicRadius, mPaint);
//        // 画移动的大圆
        canvas.drawCircle(movewCenterPointF.x, movewCenterPointF.y, mMoveRadius, mPaint);

        // 恢复上次的保存状态
//        canvas.restore();

    }
    /**拉扯移动点*/
    public void move(float downY) {
        //以中间点为定点
        updateMoveCenter(getWidth() / 2 + downY, movewCenterPointF.y);
        updateStaticCenter(getWidth() / 2 - downY, staticCenterPointF.y);
    }


    /**
     * 更新移动的点
     */
    private void updateMoveCenter(float downX, float downY) {
        movewCenterPointF.set(downX, downY);
        invalidate();
    }

    private void updateStaticCenter(float downX, float downY) {
        staticCenterPointF.set(downX, downY);
        invalidate();
    }

    @Override
    public View getView() {
        return this;
    }

    @Override
    public void startAnim() {
        bg = getResources().getColor(R.color.color_8b90af);
        mPaint.setColor(bg);
        //甩动动画
        ValueAnimator vAnim = ValueAnimator.ofFloat(-30,0,50,0);
        vAnim.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
            @Override
            public void onAnimationUpdate(ValueAnimator animation) {
//                float percent = animation.getAnimatedFraction();
                float val = (float)animation.getAnimatedValue();
//                Log.e("tag","percent "+percent + " percent*val "+percent*val);
                updateMoveCenter(getWidth() / 2 + val, movewCenterPointF.y);
                updateStaticCenter(getWidth() / 2 - val, staticCenterPointF.y);
            }
        });
        vAnim.setInterpolator(new OvershootInterpolator(2));//甩动差值器
        vAnim.setDuration(1000);
        vAnim.start();
    }

    @Override
    public void stopAnim() {
        bg = getResources().getColor(R.color.color_8babaf);
        mPaint.setColor(bg);
    }

    /**
     * Get the point of intersection between circle and line. 获取
     * 通过指定圆心，斜率为lineK的直线与圆的交点。
     */
    private PointF[] getIntersectionPoints(PointF pMiddle, float radius, Double lineK) {
        PointF[] points = new PointF[2];

        float radian, xOffset = 0, yOffset = 0;
        if (lineK != null) {
            radian = (float) Math.atan(lineK);
            xOffset = (float) (Math.sin(radian) * radius);
            yOffset = (float) (Math.cos(radian) * radius);
        } else {
            xOffset = radius;
            yOffset = 0;
        }
        points[0] = new PointF(pMiddle.x + xOffset, pMiddle.y - yOffset);
        points[1] = new PointF(pMiddle.x - xOffset, pMiddle.y + yOffset);

        return points;
    }


    /**
     * Get middle point between p1 and p2. 获得两点连线的中点
     */
    private PointF getMiddlePoint(PointF p1, PointF p2) {
        return new PointF((p1.x + p2.x) / 2.0f, (p1.y + p2.y) / 2.0f);
    }

}

而粘性效果会随着拉伸而左右拉扯，这里就是利用我们之前的回调接口去控制了，在头部写控制方法，然后在回调接口里把坐标传进去，就达到拉伸拉扯的效果了

 粘性的动画其实是两个圆形，加上一个工型的贝塞尔线，然后也是通过回调获取拉伸的距离坐标，通过坐标，来达到控制两个圆的拉扯，下拉到底的时候在启动甩动动画，因为加入了贝塞尔的缘故，所以看起来就像是两个球有引力一般相互拉扯

工型贝塞尔的绘制也有详细的注释，工的两头都是一样的长度，所以圆也是一样的大小，拉伸的时候改变两个的圆的距离

到这里核心的功能就介绍完了，接下来还有一些收尾的操作，我们的尾部，然后在定义一个我们的头部叠加进去，当然，尾部如果有需要也能做成叠加的一个容器，上面也的确是这么做的，不过一般的尾部都是比较简单的，所以没有做过多的一个样式，这里只是做了一个简单的progress效果

下面看看最终的一个效果

 这里我们的头部一共添加了三个，最底层是扇形的下拉头部，第二层是一个圆形的拉扯粘性效果，第三层是一排小圆点左右晃动的效果，三层叠加

使用上一样

而尾部基本没有什么逻辑代码，就是一个xml的展示

package com.fragmentapp.view.refresh;

import android.content.Context;
import android.util.AttributeSet;
import android.view.View;
import android.widget.ProgressBar;

/**
 * Created by liuzhen on 2017/11/24.
 */

public class DefFootView extends ProgressBar implements IFootView{

    public DefFootView(Context context) {
        this(context,null,android.R.attr.progressBarStyleSmallInverse);
    }

    public DefFootView(Context context, AttributeSet attrs) {
        this(context, attrs,0);
    }

    public DefFootView(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        init();
    }

    private void init(){

    }

    @Override
    public View getView() {
        return this;
    }

    @Override
    public void startAnim() {

    }

    @Override
    public void stopAnim() {

    }
}

接下来是添加实际的网络访问和分页的操作了，还是先看效果图

效果图上是正式的接口访问，然后上拉后加载下一页的数据

 由于原来的加载是固定的两秒，现在加上网络接口，那么时间就成了不确定了，快的话很快，慢的话很满，所以需要限定一下，不然太快的时候会导致一闪就完了，着显然不太好

那么这里需要固定一个最小的加载时间，如果因为太快而导致接口完了那么这时候需要延长一点时间，比如正常网速很好，500毫秒加载完毕了，这样会导致一闪而过，体验不太好，这里我们需要申明一个最小加载时间，假设是2000毫秒，接口加载了500毫秒，

我们需要延长的时间 = 最小的加载时间2000毫秒 - 接口的实际加载时间500毫秒 ，反过来，如果接口加载时间很慢，大于了2000毫秒，那么就不用理会，正常停止

开始和介绍计算的过程都放在了自定义的控件里，自动去完成

这里添加了一个时间计算的辅助类

package com.fragmentapp.helper;

import com.orhanobut.logger.Logger;

import java.util.Date;

/**
 * Created by liuzhen on 2018/1/5.
 */

public class TimeUtil {

    private static long defaultTime = 2000;
    private static Date startTime = null,endTime = null;

    public static void startTime(){
        clear();
        Logger.d("tag","startTime");
        if (startTime == null)
            startTime = new Date();
    }

    public static void endTime(){
        Logger.d("tag","endTime");
        if (endTime == null)
            endTime = new Date();
    }

    /**获取时间差毫秒数**/
    public static long getDateMillis() {
        if (startTime == null || endTime == null)
            return 0;
        long nd = 1000 * 24 * 60 * 60;
        long nh = 1000 * 60 * 60;
        long nm = 1000 * 60;
        long ns = 1000;
        // 获得两个时间的毫秒时间差异
        long diff = endTime.getTime() - startTime.getTime();
//        // 计算差多少天
//        long day = diff / nd;
//        // 计算差多少小时
//        long hour = diff % nd / nh;
//        // 计算差多少分钟
//        long min = diff % nd % nh / nm;
        // 计算差多少秒//输出结果
        long sec = diff % nd % nh % nm;
        clear();
        return defaultTime - sec;
    }

    private static void clear(){
        startTime = null;
        endTime = null;
    }

}

最后在获取完时间后把时间clear了一下，一来释放内存，二来重置时间

 现在可以发现以前是直接在up手势抬起的时候直接postDelayed 2000毫秒的，现在是统一调用stop方法来停止的，最终的代码如下

package com.fragmentapp.view.refresh;

import android.content.Context;
import android.content.res.TypedArray;
import android.graphics.Color;
import android.graphics.Rect;
import android.support.v4.view.ViewCompat;
import android.support.v7.widget.LinearLayoutManager;
import android.support.v7.widget.RecyclerView;
import android.support.v7.widget.StaggeredGridLayoutManager;
import android.util.AttributeSet;
import android.util.Log;
import android.view.Gravity;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewConfiguration;
import android.widget.AbsListView;
import android.widget.FrameLayout;
import android.widget.Toast;

import com.fragmentapp.R;
import com.fragmentapp.helper.TimeUtil;

import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.List;

/**
 * Created by LiuZhen on 2017/3/24.
 */
public class RefreshLayout extends FrameLayout {

    private String TAG = "tag";
    private int downY;// 按下时y轴的偏移量
    private final static float RATIO = 2f;
    //头部的高度
    protected int mHeadHeight = 120;
    //头部layout
    protected FrameLayout mHeadLayout, mFootLayout;//头部容器
    private List<IHeadView> heads = new ArrayList<>();//支持添加多个头部
    private List<IFootView> foots = new ArrayList<>();

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

    private View list;//子节点中的 recyclerview 视图
    private LayoutParams listParam, footParam;//用于控制下拉动画展示
    private boolean isLoadingMore = false;// 是否进入加载状态，防止多次重复的启动
    private boolean isStart = false;//表示正在加载刷新中，还没停止
    private boolean isTop = false, isBottom = false;
    private int mTouchSlop;
    private CallBack callBack;

    public RefreshLayout(Context context) {
        this(context, null, 0);
    }

    public RefreshLayout(Context context, AttributeSet attrs) {
        this(context, attrs, 0);
    }

    public RefreshLayout(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);

        TypedArray a = context.obtainStyledAttributes(attrs, R.styleable.RefreshLayout, defStyleAttr, 0);
        try {
            mHeadHeight = a.getDimensionPixelSize(R.styleable.RefreshLayout__height, 120);
        } finally {
            a.recycle();
        }
        mTouchSlop = ViewConfiguration.get(getContext()).getScaledTouchSlop();

        init();
    }

    private void initHeaderContainer() {
        mHeadLayout = new FrameLayout(getContext());
        LayoutParams layoutParams = new LayoutParams(LayoutParams.MATCH_PARENT, mHeadHeight);
        this.addView(mHeadLayout, layoutParams);
    }

    public void initFootContainer() {
        footParam = new LayoutParams(LayoutParams.MATCH_PARENT, mHeadHeight);
        mFootLayout = new FrameLayout(getContext());//底部布局
        mFootLayout.setBackgroundColor(Color.BLACK);
        footParam.gravity = Gravity.BOTTOM | Gravity.CENTER_HORIZONTAL;
        footParam.setMargins(0, 0, 0, -mHeadHeight);
        this.addView(mFootLayout, footParam);
    }

    private void init() {
        initHeaderContainer();
    }

    @Override
    protected void onFinishInflate() {//布局加载成xml时触发
        super.onFinishInflate();

        initFootContainer();
        if (list == null) {
            list = getChildAt(1);
            listParam = (LayoutParams) list.getLayoutParams();
            list.setOnTouchListener(new OnTouchListener() {
                @Override
                public boolean onTouch(View v, MotionEvent event) {
                    return onFingerTouch(event);
                }
            });
        }
    }

    /**
     * 设置头部View
     */
    public RefreshLayout setHeaderView(final IHeadView headView) {
        if (headView != null) {
            mHeadLayout.addView(headView.getView());
            heads.add(headView);
        }
        return this;
    }

    /**
     * 设置尾部View
     */
    public RefreshLayout setFootView(final IFootView footView) {
        if (footView != null) {
            mFootLayout.addView(footView.getView());
            foots.add(footView);
        }
        return this;
    }

    public boolean onFingerTouch(MotionEvent ev) {
        isTop = isViewToTop(list, mTouchSlop);
        isBottom = isViewToBottom(list, mTouchSlop);
//        Log.e(TAG,"isTop "+isTop+" isBottom "+isBottom);
        switch (ev.getAction()) {
            case MotionEvent.ACTION_DOWN:
                currentState = LOADING;
                downY = (int) ev.getY();
                break;
            case MotionEvent.ACTION_MOVE:
                if (!isTop && !isBottom)//没有到顶，无需计算操作
                    break;
                int moveY = (int) ev.getY();
                int diff = (int) (((float) moveY - (float) downY) / RATIO);
                int paddingTop = diff;
                if (paddingTop > 0 && isTop) {
                    //向下滑动多少后开始启动刷新,Margin判断是为了限制快速用力滑动的时候导致头部侵入的高度不够就开始加载了
                    if (paddingTop >= mHeadHeight && (listParam.topMargin >= mHeadHeight) && currentState == DOWN_REFRESH) { // 完全显示了.
//                        Log.i(TAG, "松开刷新 RELEASE_REFRESH");
                        currentState = RELEASE_REFRESH;
                        refreshHeaderView();
                        start();
                    } else if (currentState == LOADING) { // 没有显示完全
//                        Log.i(TAG, "下拉刷新 DOWN_PULL_REFRESH");
                        currentState = DOWN_REFRESH;
                        refreshHeaderView();
                    }
                    if (paddingTop <= (mHeadHeight + 10) && !isStart) {//已经处于运行刷新状态的时候禁止设置
                        listParam.setMargins(0, paddingTop, 0, 0);
                        list.setLayoutParams(listParam);
                        if (callBack != null)
                            callBack.pullListener(paddingTop);
                    }

                } else if (isBottom) {
                    //限制上滑时不能超过底部的宽度，不然会超出边界
                    //mHeadHeight+20 上滑设置的margin要超过headheight，不然下面判断的大于headheight不成立，下面的margin基础上面设置后的参数
                    if (Math.abs(paddingTop) <= (mHeadHeight + 10) && !isStart) {//已经处于运行刷新状态的时候禁止设置
                        listParam.setMargins(0, 0, 0, -paddingTop);
                        footParam.setMargins(0, 0, 0, -paddingTop - mHeadHeight);
                        list.setLayoutParams(listParam);
                    }
                    //如果滑动的距离大于头部或者底部的高度，并且设置的margin也大于headheight
                    //listParam用来限制recyclerview列表迅速滑动，footParam用来限制bottom foothead迅速滑动导致没有达到head的高度就开始加载了
                    if (Math.abs(paddingTop) >= mHeadHeight && (listParam.bottomMargin >= mHeadHeight || footParam.bottomMargin >= 0))
                        isLoadingMore = true;//头部是否拉取到位，然后执行加载动画

                }
                break;
            case MotionEvent.ACTION_UP:
                if (isLoadingMore) {//是否开始加载
                    currentState = LOADING;
                    refreshHeaderView();
                    isLoadingMore = false;
                    isStart = true;//是否开始加载
//                    postDelayed(new Runnable() {//没有网络访问时固定2秒加载完成
//                        @Override
//                        public void run() {
////                            Log.i(TAG, "停止 END");
////                            currentState = END;
//                            stop();
//                        }
//                    },2000);
                } else {
                    if (!isStart) {
                        // 隐藏头布局
                        listParam.setMargins(0, 0, 0, 0);
                        footParam.setMargins(0, 0, 0, -mHeadHeight);
                        list.setLayoutParams(listParam);
                    }
                }
//                Log.i(TAG, "松开 REFRESHING");
                break;
            default:
                break;
        }
        return super.onTouchEvent(ev);
    }

    /**
     * 根据currentState刷新头布局的状态
     */
    private void refreshHeaderView() {
        if (callBack == null || isStart)
            return;
        String val = "准备";
        switch (currentState) {
            case DOWN_REFRESH: // 下拉刷新状态
                val = "下拉";
                break;
            case RELEASE_REFRESH: // 松开刷新状态
                val = "开始...";
                break;
            case LOADING: // 正在刷新中状态
                val = "刷新中...";
                TimeUtil.startTime();
                break;
        }
        callBack.refreshHeaderView(currentState, val);
    }

    public static boolean isViewToTop(View view, int mTouchSlop) {
        if (view instanceof AbsListView) return isAbsListViewToTop((AbsListView) view);
        if (view instanceof RecyclerView) return isRecyclerViewToTop((RecyclerView) view);
        return (view != null && Math.abs(view.getScrollY()) <= 2 * mTouchSlop);
    }

    public static boolean isViewToBottom(View view, int mTouchSlop) {
        if (view instanceof AbsListView) return isAbsListViewToBottom((AbsListView) view);
        if (view instanceof RecyclerView) return isRecyclerViewToBottom((RecyclerView) view);
//        if (view instanceof WebView) return isWebViewToBottom((WebView) view,mTouchSlop);
//        if (view instanceof ViewGroup) return isViewGroupToBottom((ViewGroup) view);
        return false;
    }

    public static boolean isAbsListViewToTop(AbsListView absListView) {
        if (absListView != null) {
            int firstChildTop = 0;
            if (absListView.getChildCount() > 0) {
                // 如果AdapterView的子控件数量不为0，获取第一个子控件的top
                firstChildTop = absListView.getChildAt(0).getTop() - absListView.getPaddingTop();
            }
            if (absListView.getFirstVisiblePosition() == 0 && firstChildTop == 0) {
                return true;
            }
        }
        return false;
    }

    public static boolean isRecyclerViewToTop(RecyclerView recyclerView) {
        if (recyclerView != null) {
            RecyclerView.LayoutManager manager = recyclerView.getLayoutManager();
            if (manager == null) {
                return true;
            }
            if (manager.getItemCount() == 0) {
                return true;
            }

            if (manager instanceof LinearLayoutManager) {
                LinearLayoutManager layoutManager = (LinearLayoutManager) manager;

                int firstChildTop = 0;
                if (recyclerView.getChildCount() > 0) {
                    // 处理item高度超过一屏幕时的情况
                    View firstVisibleChild = recyclerView.getChildAt(0);
                    if (firstVisibleChild != null && firstVisibleChild.getMeasuredHeight() >= recyclerView.getMeasuredHeight()) {
                        if (android.os.Build.VERSION.SDK_INT < 14) {
                            return !(ViewCompat.canScrollVertically(recyclerView, -1) || recyclerView.getScrollY() > 0);
                        } else {
                            return !ViewCompat.canScrollVertically(recyclerView, -1);
                        }
                    }

                    // 如果RecyclerView的子控件数量不为0，获取第一个子控件的top

                    // 解决item的topMargin不为0时不能触发下拉刷新
                    View firstChild = recyclerView.getChildAt(0);
                    RecyclerView.LayoutParams layoutParams = (RecyclerView.LayoutParams) firstChild.getLayoutParams();
                    firstChildTop = firstChild.getTop() - layoutParams.topMargin - getRecyclerViewItemTopInset(layoutParams) - recyclerView.getPaddingTop();
                }

                if (layoutManager.findFirstCompletelyVisibleItemPosition() < 1 && firstChildTop == 0) {
                    return true;
                }
            } else if (manager instanceof StaggeredGridLayoutManager) {
                StaggeredGridLayoutManager layoutManager = (StaggeredGridLayoutManager) manager;

                int[] out = layoutManager.findFirstCompletelyVisibleItemPositions(null);
                if (out[0] < 1) {
                    return true;
                }
            }
        }
        return false;
    }

    /**
     * 通过反射获取RecyclerView的item的topInset
     */
    private static int getRecyclerViewItemTopInset(RecyclerView.LayoutParams layoutParams) {
        try {
            Field field = RecyclerView.LayoutParams.class.getDeclaredField("mDecorInsets");
            field.setAccessible(true);
            // 开发者自定义的滚动监听器
            Rect decorInsets = (Rect) field.get(layoutParams);
            return decorInsets.top;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return 0;
    }

    public static boolean isAbsListViewToBottom(AbsListView absListView) {
        if (absListView != null && absListView.getAdapter() != null && absListView.getChildCount() > 0 && absListView.getLastVisiblePosition() == absListView.getAdapter().getCount() - 1) {
            View lastChild = absListView.getChildAt(absListView.getChildCount() - 1);

            return lastChild.getBottom() <= absListView.getMeasuredHeight();
        }
        return false;
    }

    public static boolean isRecyclerViewToBottom(RecyclerView recyclerView) {
        if (recyclerView != null) {
            RecyclerView.LayoutManager manager = recyclerView.getLayoutManager();
            if (manager == null || manager.getItemCount() == 0) {
                return false;
            }

            if (manager instanceof LinearLayoutManager) {
                // 处理item高度超过一屏幕时的情况
                View lastVisibleChild = recyclerView.getChildAt(recyclerView.getChildCount() - 1);
                if (lastVisibleChild != null && lastVisibleChild.getMeasuredHeight() >= recyclerView.getMeasuredHeight()) {
                    if (android.os.Build.VERSION.SDK_INT < 14) {
                        return !(ViewCompat.canScrollVertically(recyclerView, 1) || recyclerView.getScrollY() < 0);
                    } else {
                        return !ViewCompat.canScrollVertically(recyclerView, 1);
                    }
                }

                LinearLayoutManager layoutManager = (LinearLayoutManager) manager;
                if (layoutManager.findLastCompletelyVisibleItemPosition() == layoutManager.getItemCount() - 1) {
                    return true;
                }
            } else if (manager instanceof StaggeredGridLayoutManager) {
                StaggeredGridLayoutManager layoutManager = (StaggeredGridLayoutManager) manager;

                int[] out = layoutManager.findLastCompletelyVisibleItemPositions(null);
                int lastPosition = layoutManager.getItemCount() - 1;
                for (int position : out) {
                    if (position == lastPosition) {
                        return true;
                    }
                }
            }
        }
        return false;
    }

    /**
     * 是否下拉操作
     **/
    public boolean isBottom() {
        return isBottom;
    }

    /**
     * 开始加载
     **/
    public void start() {
        isLoadingMore = true;
        for (IHeadView head : heads) {
            head.startAnim();
        }
    }

    /**
     * 结束加载
     **/
    public void stop() {
        TimeUtil.endTime();
        long loadTime = TimeUtil.getDateMillis();//大于0表示小于默认的加载时间
        Toast.makeText(getContext(), loadTime + "毫秒", Toast.LENGTH_SHORT).show();
        if (loadTime > 0) {//最小限制2秒的动画加载效果
            postDelayed(new Runnable() {//没有网络访问时固定2秒加载完成
                @Override
                public void run() {
                    refreshHeaderView();
                    listParam.setMargins(0, 0, 0, 0);
                    footParam.setMargins(0, 0, 0, -mHeadHeight);
                    list.setLayoutParams(listParam);
                    isLoadingMore = false;
                    isStart = false;
                    for (IHeadView head : heads) {
                        head.stopAnim();
                    }
                }
            }, loadTime);
        }else{
            refreshHeaderView();
            listParam.setMargins(0, 0, 0, 0);
            footParam.setMargins(0, 0, 0, -mHeadHeight);
            list.setLayoutParams(listParam);
            isLoadingMore = false;
            isStart = false;
            for (IHeadView head : heads) {
                head.stopAnim();
            }
        }

    }

    public RefreshLayout setCallBack(CallBack callBack) {
        this.callBack = callBack;
        return this;
    }

    public interface CallBack {
        /**
         * 监听下拉时的状态
         */
        void refreshHeaderView(int state, String stateVal);

        /**
         * 监听下拉时的距离
         */
        void pullListener(int y);
    }


}

 接下来在使用也是很小的改动

添加两个变量控制分页

刷新的状态里调用接口

在接口数据返回时控制填充刷新数据

首页的代码如下

package com.fragmentapp.home.fragment;

import android.support.v7.widget.LinearLayoutManager;
import android.support.v7.widget.RecyclerView;
import android.util.Log;
import android.view.View;
import android.view.ViewGroup;
import android.widget.Toast;

import com.fragmentapp.R;
import com.fragmentapp.base.LazyFragment;
import com.fragmentapp.helper.EmptyLayout;
import com.fragmentapp.home.adapter.ArticleAdapter;
import com.fragmentapp.home.bean.ArticleDataBean;
import com.fragmentapp.home.imple.IArticleView;
import com.fragmentapp.home.presenter.ArticlePresenter;
import com.fragmentapp.view.refresh.DefFootView;
import com.fragmentapp.view.refresh.DefHeaderView;
import com.fragmentapp.view.refresh.DownHeadView;
import com.fragmentapp.view.refresh.RefreshLayout;
import com.fragmentapp.view.refresh.StickyHeadView;
import com.fragmentapp.view.refresh.TextHeadView;
import com.fragmentapp.view.sticky.DividerDecoration;
import com.orhanobut.logger.Logger;

import java.util.ArrayList;
import java.util.List;

import butterknife.BindView;
import butterknife.OnClick;

/**
 * Created by liuzhen on 2017/11/8.
 */

public class HomeFragment extends LazyFragment implements IArticleView {

    @BindView(R.id.root)
    View root;
    @BindView(R.id.recyclerView)
    RecyclerView recyclerView;
    @BindView(R.id.refreshLayout)
    RefreshLayout refreshLayout;
    private TextHeadView textHeadView;
    private DownHeadView downHeadView;//扇形头部
    private StickyHeadView stickyHeadView;//粘性头部
    private List<ArticleDataBean.ListBean> list = new ArrayList<>();
    private ArticleAdapter adapter;

    private ArticlePresenter presenter;
    private int page = 1,lastPage = -1;

    @Override
    protected int getLayoutId() {
        return R.layout.fragment_home;
    }

    @Override
    protected void init() {
        presenter = new ArticlePresenter(this);
        page = 1;
        presenter.getArticleList(page);

        adapter = new ArticleAdapter(getActivity(), R.layout.item_home, list);
        recyclerView.setLayoutManager(new LinearLayoutManager(getActivity()));
        recyclerView.setAdapter(adapter);
        recyclerView.addItemDecoration(new DividerDecoration(getActivity()));

        textHeadView = new TextHeadView(getActivity());
        downHeadView = new DownHeadView(getActivity());
        stickyHeadView = new StickyHeadView(getActivity());
        refreshLayout
                .setHeaderView(downHeadView)
                .setHeaderView(textHeadView)
                .setHeaderView(new DefHeaderView(getActivity()))
                .setHeaderView(stickyHeadView)
//                .setHeaderView(new WaterHeadView(getActivity()))
                .setFootView(new DefFootView(getActivity()))
                .setCallBack(new RefreshLayout.CallBack() {
                    @Override
                    public void refreshHeaderView(int state, String stateVal) {
                        textHeadView.setText(stateVal);
                        switch (state) {
                            case RefreshLayout.DOWN_REFRESH: // 下拉刷新状态
                                break;
                            case RefreshLayout.RELEASE_REFRESH: // 松开刷新状态
                                break;
                            case RefreshLayout.LOADING: // 正在刷新中状态
                                if (refreshLayout.isBottom() == false) {
                                    page = 1;
                                    lastPage = -1;
                                }
                                presenter.getArticleList(page);
                                Logger.e("----------loading");
                                break;
                        }
                    }

                    @Override
                    public void pullListener(int y) {
                        int pullHeight = y / 2;
                        downHeadView.setPull_height(pullHeight);
                        stickyHeadView.move(pullHeight);
//                        Log.e("tag", pullHeight + "");
                    }
                });

        emptyLayout.setCallBack(new EmptyLayout.CallBack() {
            @Override
            public void click() {
                presenter.getArticleList(page);
            }
        });
    }

    @OnClick({R.id.search})
    public void search(View view) {
        new SearchFragment().show(getFragmentManager(), TAG);
    }

    @Override
    public void success(List<ArticleDataBean.ListBean> list) {
        if (list.size() == 0){
            emptyLayout.showEmpty((ViewGroup) getView(),"empty");
        }else {
            page++;//如果有数据则+1下一页
            if (lastPage != page) {
                if (refreshLayout.isBottom())
                    adapter.addList(list);
                else
                    adapter.setList(list);
            }
            lastPage = page;
            Toast.makeText(getActivity(), "success"+adapter.getItemCount(), Toast.LENGTH_SHORT).show();
        }
    }

    @Override
    public void error() {
        emptyLayout.showEmpty((ViewGroup) root,"error");
        Toast.makeText(getActivity(),"error",Toast.LENGTH_SHORT).show();
    }

    @Override
    public void loadStop() {
        refreshLayout.stop();
    }
}

本人在github上也上传了demo，可以提供下载，如果能让你有点感悟，请 star

GitHub：https://github.com/1024477951/FragmentApp