- 依赖
implementation "androidx.swiperefreshlayout:swiperefreshlayout:1.0.0" 常用方法
- setOnRefreshListener：设置刷新监听器。需要重写监听器OnRefreshListener的onRefresh方法，该方法在下拉松开时触发。
- setRefreshing：设置刷新的状态。true表示正在刷新，false表示结束刷新。
- isRefreshing：判断是否正在刷新。
- setColorSchemeColors：设置进度圆圈的圆环颜色。
- setProgressBackgroundColorSchemeColor：设置进度圆圈的背景颜色。
- setProgressViewOffset：设置进度圆圈的偏移量。第一个参数表示进度圈是否缩放，第二个参数表示进度圈开始出现时距顶端的偏移，第三个参数表示进度圈拉到最大时距顶端的偏移。
- setDistanceToTriggerSync：设置手势向下滑动多少距离才会触发刷新操作。
一、 基本使用
- 布局
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
xmlns:app="http://schemas.android.com/apk/res-auto"
android:layout_width="match_parent"
android:layout_height="match_parent"
tools:context=".MainActivity">
<androidx.swiperefreshlayout.widget.SwipeRefreshLayout
android:id="@+id/swipeRefreshLayout"
android:layout_width="match_parent"
android:layout_height="match_parent">
<TextView
android:id="@+id/swipe_text"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="要刷新的布局"
/>
</androidx.swiperefreshlayout.widget.SwipeRefreshLayout>
</LinearLayout>- MainActivity
public class MainActivity extends AppCompatActivity {
private SwipeRefreshLayout swipeRefreshLayout;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
swipeRefreshLayout=findViewById(R.id.swipeRefreshLayout);
swipeRefreshLayout.setColorSchemeColors(getResources().getColor(R.color.teal_200));//设置刷新转圈的颜色
swipeRefreshLayout.setProgressBackgroundColorSchemeColor(getResources().getColor(R.color.purple_200));//设置刷新的背景颜色
swipeRefreshLayout.setOnRefreshListener(new SwipeRefreshLayout.OnRefreshListener() {
@Override
public void onRefresh(){//刷新的处理事件
//假设两秒后停止刷新
//开启子线程
new Thread(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(2000);
swipeRefreshLayout.setRefreshing(false);//停止刷新
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}).start();
}
});
}
}- 结束
二、 加上枚举耗时使用
- 布局和上面都一样
- 不同的是对 刷新侦听器的处理
- 定义用到的参数
public static final int STATE_LOADING = 0;//加载中
public static final int STATE_ERROR = 1;//错误
public static final int STATE_SUCCESS = 2;//成功
public static final int STATE_EMPTY = 3;//空
public int mCurState = STATE_LOADING;//默认是加载中的情况
private LoadDataTask mLoadDataTask;//定义一个初始化的加载状态为null//刷新侦听器的处理
swipeRefreshLayout.setOnRefreshListener(new SwipeRefreshLayout.OnRefreshListener() {
@Override
public void onRefresh() {
//触发加载数据
triggerLoadData();
}
});
private void triggerLoadData() {
if (mCurState!=STATE_SUCCESS){
if (mLoadDataTask==null){
//异步加载
mLoadDataTask = new LoadDataTask();
ThreadPoolProxyFactory.getNormalThreadPoolProxy().submit(mLoadDataTask);//线程池
}
}
}
//定义个耗时线程
private class LoadDataTask implements Runnable{
@Override
public void run() {
//真正的在子线程中加载具体的数据-->得到数据(为了得到的状态值只有3个，创一个枚举)
LoadedResult loadedResult=initData();
mCurState=loadedResult.getState();
//UI刷新
runOnUiThread(new Runnable() {
@Override
public void run() {
initOnUi();
}
});
//置空任务
mLoadDataTask = null;
}
}
private LoadedResult initData() { //做耗时的操作
//处理耗时的数据请求 两秒后停止
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//获取http请求 或者 其他耗时请求 得到结果result
//如果结果为空 return LoadedResult.EMPTY;
//如果结果请求失败 return LoadedResult.ERROR;
//如果结果成功 return LoadedResult.SUCCESS;
return LoadedResult.SUCCESS;
}
//标识数据加载结果的枚举类
public enum LoadedResult {
/**
* STATE_ERROR = 1;//错误
* STATE_SUCCESS = 2;//成功
* STATE_EMPTY = 3;//空
*/
SUCCESS(STATE_SUCCESS), ERROR(STATE_ERROR), EMPTY(STATE_EMPTY);
private int state;
LoadedResult(int state) {
this.state = state;
}
public int getState() {
return state;
}
}
//主线程的处理，刷新UI
private void initOnUi() {
if (mCurState==STATE_LOADING){
swipeText.setText("加载中");
swipe.setRefreshing(true);//加载中
}
if (mCurState==STATE_ERROR){
swipeText.setText("加载失败");
swipe.setRefreshing(false);//加载失败
}
if (mCurState==STATE_SUCCESS){
swipeText.setText("加载成功");
mCurState = STATE_LOADING;//回复初始状态
swipe.setRefreshing(false);//加载成功
}
}- ThreadPoolProxyFactory 工厂类,封装对ThreadPoolProxy创建
/**
* 工厂类,封装对ThreadPoolProxy创建
*/
public class ThreadPoolProxyFactory {
//普通类型的线程池代理
static ThreadPoolProxy mNormalThreadPoolProxy;
//下载类型的线程池代理
static ThreadPoolProxy mDownLoadThreadPoolProxy;
/**
* 得到普通类型的线程池代理
*/
public static ThreadPoolProxy getNormalThreadPoolProxy(){
if (mNormalThreadPoolProxy==null){
synchronized (ThreadPoolProxyFactory.class){
if (mNormalThreadPoolProxy==null){
mNormalThreadPoolProxy=new ThreadPoolProxy(5,5);
}
}
}
return mNormalThreadPoolProxy;
}
/**
* 得到下载类型的线程池代理
*/
public static ThreadPoolProxy getDownLoadThreadPoolProxy(){
if (mDownLoadThreadPoolProxy==null){
synchronized (ThreadPoolProxyFactory.class){
if (mDownLoadThreadPoolProxy==null){
mDownLoadThreadPoolProxy=new ThreadPoolProxy(3,3);
}
}
}
return mDownLoadThreadPoolProxy;
}
}- ThreadPoolProxy
线程池代理类,替线程池完成相关操作
1.代理模式就是多一个代理类出来，替原对象进行一些操作
2.只需提供使用原对象时候真正关心的方法(提交任务,执行任务,移除任务)
3.可以对原对象方法进行增强
public class ThreadPoolProxy {
ThreadPoolExecutor mExecutor;
private int mCorePoolSize;//核心池的大小
private int mMaximumPoolSize;//线程最大线程数
public ThreadPoolProxy(int mCorePoolSize, int mMaximumPoolSize) {
this.mCorePoolSize = mCorePoolSize;
this.mMaximumPoolSize = mMaximumPoolSize;
}
//创建线程池
private void initThreadPoolExecutor() {
//双重检查加锁 : 只有第一次实例化的时候才启用同步机制,提高了性能
if (mExecutor == null || mExecutor.isShutdown() || mExecutor.isTerminated()){
synchronized (ThreadPoolProxy.class){
if (mExecutor == null || mExecutor.isShutdown() || mExecutor.isTerminated()){
long keepAliveTime = 0;
TimeUnit unit = TimeUnit.MILLISECONDS;
BlockingQueue<Runnable> workQueue = new LinkedBlockingQueue();
ThreadFactory threadFactory = Executors.defaultThreadFactory();
RejectedExecutionHandler handler = new ThreadPoolExecutor.DiscardPolicy();
mExecutor=new ThreadPoolExecutor(mCorePoolSize,mMaximumPoolSize,keepAliveTime,unit,workQueue,threadFactory,handler);
}
}
}
}
/**
* 提交任务
*/
public Future submit(Runnable task){
initThreadPoolExecutor();
Future<?> future=mExecutor.submit(task);
return future;
}
/**
* 执行任务
*/
public void execute(Runnable task){
initThreadPoolExecutor();
mExecutor.execute(task);
}
/**
* 移除任务
*/
public void remove(Runnable task){
initThreadPoolExecutor();
mExecutor.remove(task);
}
}- 结束
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
