一、WorkManager 特点及适用场景
特点
- 保证任务一定会被执行
WorkManager 有自己的数据库，每一个任务的信息与任务状态，都会保存在本地数据库中。所以即使程序没有在运行，或者在设备重启等情况下，WorkManager 依然可以保证任务的执行，只是不保证任务立即被执行。 - 合理使用设备资源
在执行很多周期性或非立即执行的任务时，WorkManager 提供我们 API，帮助我们合理利用设备资源，避免不必要的内存，流量，电量等消耗。
适用场景
- 可延迟进行的任务
a. 满足某些条件才执行的任务，如需要在充电时才执行的任务。
b. 用户无感知或可延迟感知的任务，如同步配置信息，同步资源，同步通讯录等。 - 定期重复性任务，但时效性要求不高的，如定期log上传，数据备份等。
- 退出应用后还应继续执行的未完成任务。
二、WorkManager 的各个角色
Worker
需要执行的任务，这是一个抽象类我们需要继承它，在doWork()方法中实现我们自己的业务逻辑。-
WorkRequest
工作请求，每个 Worker 想要被执行都需要向 WorkManager 发出一个 WorkRequest，同时在 WorkRequest 中指定 Worker 执行的条件。- WorkRequest对象必须指定Work执行的任务
- WorkRequest都有一个自动生成的唯一ID，可以使用ID执行取消
排队任务 或 获取任务状态等操作 - WorkRequest是一个抽象的类；系统默认实现子类 OneTimeWorkRequest 或 PeriodicWorkRequest
- WorkRequest.Builder 创建 WorkRequest 对象；相应的子类：
OneTimeWorkRequest.Builder 或 PeriodicWorkRequest.Builder - Constraints：指定对任务运行时间的限制（任务约束）；使用
Constraints.Builder 创建 Constraints 对象 ，并传递给 WorkRequest.Builder
WorkManager的简述
WorkManager：排队和管理工作请求；将WorkRequest 对象传递WorkManager的任务队列（注意：如果未指定任何约束， WorkManager立即运行任务）
三、WorkManager 使用
首先需要添加依赖
def work_version = "2.4.0"
implementation "androidx.work:work-runtime:$work_version"
WorkManager 最新版本查看Google 官方地址： WorkManager 最新版本地址
WorkManager的使用步骤：
- 创建一个后台任务Worker。
- 定义WorkRequest，配置运行任务的方式和时间。
- 将任务提交给系统处理。
- 观察Worker的进度或状态。
然后介绍 WorkManager 的几种使用方式：
- 基本使用
- 数据互相传递
- 多个任务 顺序执行
- 重复执行后台任务
- 约束条件，约束后台任务执行
1. WorkManager 基本使用
继承 Worker 类，覆盖 doWork() 方法，所有需要在任务中执行的代码都在该方法中编写。
WorkManager 提供了四种 Worker 的创建模式：
- Worker：最简单的实现，WorkManager 会在后台线程上自动运行它。
- CoroutineWorker：CoroutineWorker 针对后台工作公开挂起函数。默认情况下，它们运行默认的 Dispatcher。
- RxWorker：如果有很多现有异步代码是用 RxJava 建模的建议使用。与所有 RxJava2 概念一样，可以自由选择所需的线程处理策略。
- ListenableWorker：是 Worker，CoroutineWorker，RxWorker 的基类，为需要与基于回调的异步 API 进行交互并且不使用 RxJava2 的 Java 开发者而设计。
Worker的创建示例：
//新建一个继承 Worker 的类
public class MainWorker1 extends Worker {
private final static String TAG = MainWorker1.class.getSimpleName();
public MainWorker1(@NonNull Context context, @NonNull WorkerParameters workerParams) {
super(context, workerParams);
}
@NonNull @Override public Result doWork() {
Log.d(TAG, "MainWorker1 doWork: run started ... ");
try {
Thread.sleep(8000); // 睡眠
} catch (Exception e) {
e.printStackTrace();
return Result.failure(); // 本次任务失败
} finally {
Log.d(TAG, "MainWorker1 doWork: run end ... ");
}
/**
* 返回值一共有五种
* 基础的有是三种
* Result.success() // 执行成功
* Result.retry() // 执行失败
* Result.failure() // 重新执行
* 剩下两种是带有输出数据
* Result.success(Data outputData)
* Result.failure(Data outputData)
*/
return Result.success();// 本次任务成功
}
}
// 构建一个请求，只执行一次的 OneTimeWorkRequest
OneTimeWorkRequest oneTimeWorkRequest = new OneTimeWorkRequest.Builder(MainWorker1.class).build();
// 将任务提交给系统。WorkManager.enqueue()方法会将你配置好的WorkRequest交给系统来执行。
WorkManager.getInstance(this).enqueue(oneTimeWorkRequest);
运行结果：
2. WorkManager 数据互相传递
public class MainWorker2 extends Worker {
public final static String TAG = MainWorker2.class.getSimpleName();
private WorkerParameters workerParams;
public MainWorker2(@NonNull Context context, @NonNull WorkerParameters workerParams) {
super(context, workerParams);
this.workerParams = workerParams;
}
@SuppressLint("RestrictedApi")
@NonNull
@Override
public Result doWork() {
Log.d(TAG, "MainWorker2 doWork: 后台任务执行了");
// 接收 MainActivity 传递过来的数据
String dataString = workerParams.getInputData().getString("key");
Log.d(TAG, "MainWorker2 doWork: 接收Activity传递过来的数据:" + dataString);
// 反馈数据 给 MainActivity
// 把任务中的数据回传到activity中
Data outputData = new Data.Builder().putString("key", "数据反馈").build();
Result.Success success = new Result.Success(outputData);
return success;
}
}
/**
* 数据 互相传递
* 测试后台任务 2
*
* @param view
*/
public void testBackgroundWork2(View view) {
// 数据
Data data = new Data.Builder().putString("key", "数据传递").build();
// 请求对象初始化
OneTimeWorkRequest oneTimeWorkRequest = new OneTimeWorkRequest.Builder(MainWorker2.class)
.setInputData(data) // 数据的携带
.build();
// 通过LiveData，可以在任务状态发生变化的时候，收到通知。
WorkManager.getInstance(this).getWorkInfoByIdLiveData(oneTimeWorkRequest.getId())
.observe(this, new Observer<WorkInfo>() {
@Override public void onChanged(WorkInfo workInfo) {
Log.d(MainWorker2.TAG, "状态：" + workInfo.getState().name());
if (workInfo.getState().isFinished()) {
// 知道 本次任务执行的时候 各种状态 （SUCCEEDED，isFinished=true， 我再接收 任何回馈给我的数据）
// 状态机 成功的时候 才去打印
Log.d(MainWorker2.TAG, "Activity取到了任务回传的数据: " + workInfo.getOutputData().getString("key"));
Log.d(MainWorker2.TAG, "状态：isFinished=true 注意：后台任务已经完成了...");
}
}
});
WorkManager.getInstance(this).enqueue(oneTimeWorkRequest);
}
运行结果：
3. WorkManager 多个任务 顺序执行
创建 MainWorker3、MainWorker4、MainWorker5、MainWorker6 继承 Worker 的类。
public class MainWorker3 extends Worker {
public final static String TAG = MainWorker3.class.getSimpleName();
public MainWorker3(@NonNull Context context, @NonNull WorkerParameters workerParams) {
super(context, workerParams);
}
@SuppressLint("RestrictedApi")
@NonNull
@Override
public Result doWork() {
Log.d(TAG, "MainWorker3 doWork: 后台任务执行了");
return new Result.Success(); // 本地执行 doWork 任务时 成功 执行任务完毕
}
}
/**
* 多个任务 顺序执行
* 测试后台任务 3
*
* @param view
*/
public void testBackgroundWork3(View view) {
// 单一的任务 一次
OneTimeWorkRequest oneTimeWorkRequest3 = new OneTimeWorkRequest.Builder(MainWorker3.class).build();
OneTimeWorkRequest oneTimeWorkRequest4 = new OneTimeWorkRequest.Builder(MainWorker4.class).build();
OneTimeWorkRequest oneTimeWorkRequest5 = new OneTimeWorkRequest.Builder(MainWorker5.class).build();
OneTimeWorkRequest oneTimeWorkRequest6 = new OneTimeWorkRequest.Builder(MainWorker6.class).build();
// 顺序执行 3 4 5 6
WorkManager.getInstance(this)
.beginWith(oneTimeWorkRequest3) // 检查的任务
.then(oneTimeWorkRequest4) // 业务1任务
.then(oneTimeWorkRequest5) // 业务2任务
.then(oneTimeWorkRequest6) // 最后检查工作任务
.enqueue();
// 需求：先执行 3 4 最后执行 6
List<OneTimeWorkRequest> oneTimeWorkRequests = new ArrayList<>();
oneTimeWorkRequests.add(oneTimeWorkRequest3);// 先同步日志信息
oneTimeWorkRequests.add(oneTimeWorkRequest4);// 先更新服务器数据信息
WorkManager.getInstance(this)
.beginWith(oneTimeWorkRequests)
.then(oneTimeWorkRequest6)// 最后再 检查同步
.enqueue();
}
运行结果：
顺序执行结果图
合并执行
4. WorkManager 重复执行后台任务
/**
* 重复执行后台任务 非单个任务，多个任务
* 测试后台任务 4
*
* @param view
*/
public void testBackgroundWork4(View view) {
// 重复的任务 多次/循环/轮询 , 哪怕设置为 10秒 轮询一次, 那么最少轮询/循环一次 15分钟（Google规定的）
// 不能小于15分钟，否则默认修改成 15分钟
PeriodicWorkRequest periodicWorkRequest = new PeriodicWorkRequest
.Builder(MainWorker3.class, 10, TimeUnit.SECONDS).build();
// 【状态机】 为什么一直都是 ENQUEUE，因为 你是轮询的任务，所以你看不到 SUCCESS [如果你是单个任务，就会看到SUCCESS]
// 监听状态
WorkManager.getInstance(this).getWorkInfoByIdLiveData(periodicWorkRequest.getId())
.observe(this, new Observer<WorkInfo>() {
@Override public void onChanged(WorkInfo workInfo) {
Log.d(MainWorker3.TAG, "状态：" + workInfo.getState().name()); // ENQUEEN SUCCESS
if (workInfo.getState().isFinished()) {
Log.d(MainWorker3.TAG, "状态：isFinished=true 注意：后台任务已经完成了...");
}
}
});
WorkManager.getInstance(this).enqueue(periodicWorkRequest);
// 取消 任务的执行
// WorkManager.getInstance(this).cancelWorkById(periodicWorkRequest.getId());
}
5. WorkManager 约束条件，约束后台任务执行
/**
* 约束条件，约束后台任务执行
* 测试后台任务 5
*
* @param view
*/
public void testBackgroundWork5(View view) {
// 约束条件，必须满足我的条件，才能执行后台任务 （在连接网络，插入电源 并且 处于空闲时）
Constraints constraints = new Constraints.Builder()
.setRequiredNetworkType(NetworkType.CONNECTED) // 网络链接中...
/*.setRequiresCharging(true) // 充电中..
.setRequiresDeviceIdle(true) // 空闲时.. (例如：你没有玩游戏，你没有看片)*/
.build();
/*
* 除了上面设置的约束外，WorkManger还提供了以下的约束作为Work执行的条件：
* setRequiredNetworkType：网络连接设置
* setRequiresBatteryNotLow：是否为低电量时运行 默认false
* setRequiresCharging：是否要插入设备（接入电源），默认false
* setRequiresDeviceIdle：设备是否为空闲，默认false
* setRequiresStorageNotLow：设备可用存储是否不低于临界阈值
*/
// 请求对象
OneTimeWorkRequest request = new OneTimeWorkRequest.Builder(MainWorker3.class)
.setConstraints(constraints) // Request关联 约束条件
.build();
// 加入队列
WorkManager.getInstance(this).enqueue(request);
}
