对所有Activity和Fragment统一添加下拉刷新和上拉加载

本文链接：https://blog.youkuaiyun.com/h_u_a_/article/details/53871306

本文介绍了如何通过自定义的MyRefreshLayout，为所有Activity和Fragment实现下拉刷新和上拉加载功能。内容包括：允许仅实现刷新功能，支持ListView子项的左右滑动，设置刷新和加载的最小间隔时间。使用方法包括让Fragment继承BaseRefreshFragment并实现加载更多数据的方法，初始化刷新控件，以及成功和失败时的数据处理回调。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

利用自定义的MyRefreshLayout定义带有下拉刷新和上拉加载的Activity和Fragment父类:

允许只实现刷新
允许ListView子条目左右滑动
可以设置刷新或者加载时的最小时间间隔

使用时

使Fragment继承BaseRefreshFragment，泛型为子条目需要的数据类型，实现加载更多条目的方法
在获取到MyRefreshLayout对象之后，调用initRefresh();
在获取到数据后先后调用setLoadData(loadDatas); dealData();,完成数据处理

在获取数据失败时调用onRefreshError();

public abstract class BaseRefreshFragment<T> extends MyBaseFragment {
    private long currentTimeMillis;
    private long lastRefreshTime;
    private RefreshLayout refreshLayout;
    private boolean isRefresh;
    private long currLoadTime;
    private double lastLoadTime;
    private boolean isLoad;
    //  当前加载页码
    protected int page = 1;
    //    总的数据源
    protected List<T> datas = new ArrayList<>();
    //   上次加载得到的数据
    private List<T> preDatas = new ArrayList<>();
    //  上次加载得到的数据个数
    private int preSize;

    /**
     * 初始化刷新/加载功能
     *
     * @param refreshLayout  用来实现刷新和加载的MyRefreshLayout
     * @param isNeedLoad    是否需要上拉加载
     * @param isDrag        子条目是否可以左右拖动
     */
    public void initRefresh(RefreshLayout refreshLayout, boolean isNeedLoad, boolean isDrag) {
        this.refreshLayout = refreshLayout;
        this.refreshLayout.setIsDrag(isDrag);
        // 设置下拉刷新时SwipeRefreshLayout显示的颜色变化
        this.refreshLayout.setColorSchemeResources(android.R.color.holo_blue_light, android.R.color.holo_red_light, android.R.color.holo_orange_light,
                android.R.color.holo_green_light);
         // 设置刷新监听
        this.refreshLayout.setOnRefreshListener(new SwipeRefreshLayout.OnRefreshListener() {
            @Override
            public void onRefresh() {
                // 当前时间
                currentTimeMillis = System.currentTimeMillis();
                //  两次刷新时间需要大于1分钟
                if (currentTimeMillis - lastRefreshTime < SpKey.TIME_SPACE) {
                // 伪刷新
                    sleepRefresh();
                } else {
                    // 设置状态为可刷新
                    isRefresh = true;
                    // 移除原有刷机
                    datas.removeAll(preDatas);
                    // 不执行加载更多方法
                    load(false);
                    // 记录上次加载时间
                    lastRefreshTime = currentTimeMillis;
                }
            }
        });
        if (isNeedLoad)  //  如果需要实现上拉加载
            this.refreshLayout.setOnLoadListener(new RefreshLayout.OnLoadListener() {
                @Override
                public void onLoad() {
                    currLoadTime = System.currentTimeMillis();
                    if (preSize == 0) {
                    //两次加载时间需要大于1分钟
                        if (currLoadTime - lastLoadTime < SpKey.TIME_SPACE) {
                    //伪刷新
                            sleepLoad();
                        } else {
                            isLoad = true;
                            // 执行加载更多方法
                            load(true);
                            lastLoadTime = currLoadTime;
                        }
                    } else {
                        isLoad = true;
                        load(true);
                        lastLoadTime = currLoadTime;
                    }
                }
            });
    }

    /**
     * 伪刷新
     */
    private void sleepRefresh() {
        ThreadUtils.runOnBackThread(new Runnable() {
            @Override
            public void run() {
                SystemClock.sleep(SpKey.FAKE_TIME);
                ThreadUtils.runOnUiThread(new Runnable() {
                    @Override
                    public void run() {
                        refreshLayout.setRefreshing(false);
                    }
                });
            }
        });
    }

    /**
     * 伪加载
     */
    private void sleepLoad() {
        ThreadUtils.runOnBackThread(new Runnable() {
            @Override
            public void run() {
                SystemClock.sleep(SpKey.FAKE_TIME);
                ThreadUtils.runOnUiThread(new Runnable() {
                    @Override
                    public void run() {
                        refreshLayout.setLoading(false);
                    }
                });
            }
        });
    }


    /**
     * 设置加载到的数据
     */
    protected void setLoadData(List<T> preDatas) {
       if (preDatas == null) //如果加载数据失败则返回
            return;
       if (preDatas.size() > 0) //如果加载到新数据，则记录下来
       this.preDatas = preDatas;
       preSize = preDatas.size(); // 记录下加载到的数据
    }

    /**
     * 刷新完成
     */
    protected void setRefreshDone() {
        if (isRefresh) {
            isRefresh = false;
            refreshLayout.setRefreshing(false);
        }
    }

    /**
     * 处理load时，对数据结果的刷新/加载处理
     */
    public void dealData() {
        if (page == 1) { //如果当前为第一页，则清空数据
            datas.clear();
        }
        setRefreshDone(); //设置刷新完成
        dealLoad(); // 处理加载结果
        if (preSize > 0) //如果加载到数据，则添加到数据集
            datas.addAll(preDatas);
    }

    /**
     * 加载或者刷新失败
     */
    public void onRefreshError() {
        setRefreshDone();
        dealLoadError();
    }

    /**
     * 处理上拉加载失败情况
     */
    protected void dealLoadError() {
        if (isLoad) {
            isLoad = false;
            if (page > 1)
                page--;
            refreshLayout.setLoading(false);
        }
    }

    /**
     * 处理上拉加载成功情况
     */
    protected void dealLoad() {
        if (isLoad) {
            if (preSize == 0) {
                refreshLayout.setLoading(false);
                if (page > 1)  // 如果没返回更多数据，则page--;
                    page--;
            } else {
                refreshLayout.setLoading(true);
            }
            isLoad = false;
        }
    }

    /**
     * 加载数据
     */
    public abstract void load(boolean isLoad);
}