Android WorkerManager 的使用

最新推荐文章于 2024-09-15 08:07:34 发布
最新推荐文章于 2024-09-15 08:07:34 发布
阅读量3.7k 收藏 11
点赞数 2
分类专栏： android 文章标签： android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cxmfzu/article/details/108174154
版权

简介

WorkerManager 适用于执行可以延迟（不需要精确时间）但是必须要稳定执行的的后台任务。适用于向后台同步应用数据，发送日志，应用检查更新等不需要及时完成的后台任务。在本文中这类型的后台任务，命名为延迟后台任务，方便理解。
在Android8.0以后Android系对后台的服务有了严格的限制，因此执行后台任务，需要通过系统调度的方式来执行，Google官方推荐使用JobScheduler 作业替换后台 Service。但是WorkerManager 是JetPack中的一个组成部分，并且完成能够胜任JobScheduler，并且有比JobScheduler 更加好用，因此推荐使用WorkerManager。文章除了介绍WorkerManager的用法，也会将WorkerManager 与 JobScheduler进行对比。

简要使用

后台延迟任务可以分为一次性任务和周期性任务。一次性任务，并不是只执行一次，如果任务没有执行成功，可以进行重试策略，重试策略WorkerManager 和 JobScheduler 的限制条件是一样的，最小的重试时间为10S，最大的重试时间为5小时。

一次性任务

WorkerManager 一次性任务

  1. 继承Worker。
public class MyWork extends Worker {
    private final String TAG = "SecondWork";
    public SecondWork(@NonNull Context context, @NonNull WorkerParameters workerParams) {
        super(context, workerParams);
    }
    @NonNull
    @Override
    public Result doWork() {
        Log.d(TAG,"thread id = "+Thread.currentThread().getId());
        Log.d(TAG,"执行时间  :"+ DateUtil.getCurrentTime("yyyy-MM-dd HH:mm:ss"));
        return Result.success();
    }
}
  1. 创建WorkerManager，并且将自定义的Worker添加到系统中，等待系统的调度
        OneTimeWorkRequest secondWork = new OneTimeWorkRequest.Builder(MyWork .class)
                .setInitialDelay(5000,TimeUnit.MILLISECONDS) // 在满足约束条件的前提下，初始延迟时间为5S
                .setBackoffCriteria(BackoffPolicy.LINEAR,10,TimeUnit.SECONDS) // 重试间隔时间为：curTime + 10 * 重试次数
                .build();
        WorkManager.getInstance(getContext()).enqueue(secondWork);
        Log.d(TAG,"SecondWork 添加到系统  "+ DateUtil.getCurrentTime("yyyy-MM-dd HH:mm:ss"));

JobScheduler 一次性任务

  1. 继承JobService。
public class MyService extends JobService{
    @Override
    public boolean onStartJob(JobParameters params) {
        Log.d(TAG,"ThirdService onStartJob="+DateUtil.getCurrentTime("yyyy-MM-dd HH:mm:ss"));
        return false;
    }
    @Override
    public boolean onStopJob(JobParameters params) {
        Log.d(TAG,"ThirdService onStopJob = "+DateUtil.getCurrentTime("yyyy-MM-dd HH:mm:ss"));
        return false;
    }
}
  1. 获取系统调度jobscheduler，将自定义的JobService，添加到系统中，开始系统调度。
JobScheduler scheduler = (JobScheduler) getContext().getSystemService(Context.JOB_SCHEDULER_SERVICE);
ComponentName jobService = new ComponentName(getContext(), ThirdService.class);
// 注意jobId
JobInfo.Builder builder = new JobInfo.Builder(1000, jobService);
JobInfo jobInfo = builder
                .setMinimumLatency(3*1000)
                .setOverrideDeadline(4*1000)
                .build();
 scheduler.schedule(jobInfo);

周期性任务

WorkerManager 周期性任务

  1. 继承Worker,这个一步跟一次性任务是一样的。
public class MyWork extends Worker {
    private final String TAG = "SecondWork";
    public SecondWork(@NonNull Context context, @NonNull WorkerParameters workerParams) {
        super(context, workerParams);
    }
    @NonNull
    @Override
    public Result doWork() {
        Log.d(TAG,"thread id = "+Thread.currentThread().getId());
        Log.d(TAG,"执行时间  :"+ DateUtil.getCurrentTime("yyyy-MM-dd HH:mm:ss"));
        return Result.success();
    }
}
  1. 创建WorkerManager，并且将自定义的Worker添加到系统中，等待系统的调度。
PeriodicWorkRequest thirdWork = new PeriodicWorkRequest.Builder(SecondWork.class,
                15,TimeUnit.MINUTES) // 周期性任务的间隔时间最小为15分钟
                .build();
        WorkManager.getInstance(getContext()).enqueue(thirdWork);
        Log.d(TAG,"thirdWork 添加到系统  "+ DateUtil.getCurrentTime("yyyy-MM-dd HH:mm:ss"));

注意，repeatInterval 和 flexInterval 的区别。

JobScheduler 周期性任务

  1. 继承JobService。
public class MyService extends JobService{
    @Override
    public boolean onStartJob(JobParameters params) {
        Log.d(TAG,"ThirdService onStartJob="+DateUtil.getCurrentTime("yyyy-MM-dd HH:mm:ss"));
        return false;
    }
    @Override
    public boolean onStopJob(JobParameters params) {
        Log.d(TAG,"ThirdService onStopJob = "+DateUtil.getCurrentTime("yyyy-MM-dd HH:mm:ss"));
        return false;
    }
}
  1. 获取系统调度jobscheduler，将自定义的JobService，添加到系统中，开始系统调度。
JobScheduler scheduler = (JobScheduler) getContext().getSystemService(Context.JOB_SCHEDULER_SERVICE);
ComponentName jobService = new ComponentName(getContext(), ThirdService.class);
// 注意jobId
JobInfo.Builder builder = new JobInfo.Builder(1000, jobService);
JobInfo jobInfo = builder
                .setPeriodic(3*1000)
                .build();
 scheduler.schedule(jobInfo);

不同点

  1. 使用WorkerManager 的语义话程度比JobScheduler 语义程度高，WorkerManager有明确的区分一次性任务还是周期性任务，JobScheduler 只能通过约束条件设置，任务最大的延迟来，执行一次性任务。周期性任务与和非周期性任务是互斥的，在WorkerManager 中通过两个明确的类将两者进行区别，在JobScheduler 是通过设置约束条件时抛出异常来体现，因此WorkerManager 的易用性更强。
  2. 自定义Worker 中的doWork 是在线程中的，可以执行耗时操作。自定义的JobService 中的onStartJob,onStopJob在UI线程，不能执行耗时任务。
  3. WorkerManager的时间约束条件setInitialDelay，含义是在满足约束条件的前提下，初始延迟时间，如果没有满足约束条件会一直等到约束条件满足，再次判断是否满足时间约束条件，如果满足约束条件则只需Worker。JobScheduler 的时间约束条件setOverrideDeadline的含义是到了最大延迟时间后，即使不满足约束条件也会只需JobService。
  4. WorkerManager 中的自定义Worker返回值有着明确的含义，成功Result.success();失败Result.failure()；重试Result.retry()；JobScheduler 中的JobService 需要通过jobFinished来确定，是否需要重试，jobFinished中第二个参数为true，需要重试，否则不需要重试。
  5. WorkerManager 和 JobScheduler的兼容性不同，WorkerManager兼容到Android14，但是JobScheduler 最低的版本要求是21。因此WorkerManager的兼容范围更广。

JobId

  1. 在JobScheduler 中构建JobInfo 需要指定JobId，并且这个JobId必须是系统唯一的。这一个要求想要达到是有很大的难度的，在应用中使用代码很难获取到其他应用创建的JobId，因此很难保证JobId的唯一性。同时如果JobId不唯一，在Android 7.0 的某些机型测试时发现会造成调度时间的混乱，这个可能会被其人利用，这时候出现的错误是很难发现和排查的。
  2. 在WorkerManager 中取消了JobId的概念，取而代之的是使用UUID，并且UUID是系统来生成，这个做的好处是可以最大程度的规避JobScheduler 遇到的问题。是一个可喜的变化。

WorkerManager 详细使用

下面记录WorkerManager的使用方式。

Worker状态

使用WorkerManager中最为重要的一步是继承Worker，其中Worker是具有状态，并且状态可以监控的，因此可以根据Worker的状态灵活对其进行控制。
Worker状态其实和线程的状态非常像，Worker状态如下：

  • ENQUEUED 排队（就绪）状态，这时候自定义的Worker已进入队列，在等待约束条件满足。
  • RUNNING 运行状态。
  • SUCCEEDED 成功结束状态
  • FAILED 失败结束状态
  • BLOCKED 阻塞状态
  • CANCELLED 取消状态

监听Worker状态源码，在必要的情况下面可以根据不同的状态获取数据，进行自定义的数据变化如下：

WorkManager.getInstance(getContext()).getWorkInfoByIdLiveData(firstWork.getId())
                .observe(getViewLifecycleOwner(), new Observer<WorkInfo>() {
                    @Override
                    public void onChanged(WorkInfo workInfo) {
                        if (workInfo != null){
                            switch (workInfo.getState()){
                                case RUNNING:
                                    Log.d(TAG,"运行状态");
                                    break;
                                case SUCCEEDED:
                                    Log.d(TAG,"成功");
                                    break;
                                    ...
                                default:
                                    break;
                            }
                        }
                    }
                });

构建任务

构建一次性任务参数

构建一次性任务参数源码如下

OneTimeWorkRequest firstWork = new OneTimeWorkRequest.Builder(FirstWork.class)
                .setInitialDelay(3000, TimeUnit.MILLISECONDS)// 设置任务初始延时
                .setConstraints(new Constraints.Builder().build())// 设置约束条件
                //.setInputMerger(new InputMerger()) //在工作链的时候使用
                .setInputData(new Data.Builder().build()) // 设置输入数据
                .setBackoffCriteria(BackoffPolicy.LINEAR, 11, TimeUnit.SECONDS)// 设置重试策略
                .addTag("first_work") // 添加tag,方便使用
                .keepResultsForAtLeast(10,TimeUnit.SECONDS) // Worker 运行结果保留时间
                //.setInitialRunAttemptCount() 设置任务运行的次数（测试重试策略的时候使用），测试使用
                //.setInitialState()// 设置Worker的状态，也是测试使用，应用不能调用
                //.setScheduleRequestedAt() // android 做测试使用，应用是一般不调用
                //.setPeriodStartTime(3000, TimeUnit.MILLISECONDS)// android 做测试使用，应用是一般不调用
                .build();

构建周期性任务参数

构建周期性任务参数如下

PeriodicWorkRequest thirdWork = new PeriodicWorkRequest.Builder(SecondWork.class,
                    15, TimeUnit.MINUTES, 15, TimeUnit.MINUTES)
                    .setInputData(new Data.Builder().putInt("number",i).build())
                    //.setInitialDelay(10,TimeUnit.SECONDS)// 周期性任务的初始延迟时间，不设置，在满足条件后立即执行.
                    .setConstraints(new Constraints.Builder().build())// 设置约束条件
                    //.setInputMerger(new InputMerger()) //在工作链的时候使用
                    .setInputData(new Data.Builder().build()) // 设置输入数据
                    .setBackoffCriteria(BackoffPolicy.LINEAR, 11, TimeUnit.SECONDS)// 设置重试策略
                    .addTag("first_work") // 添加tag,方便使用
                    .keepResultsForAtLeast(10,TimeUnit.SECONDS) // Worker 运行结果保留时间
                    .build();

比较一次性任务和周期性任务约束参数

由此可见，构建一次性任务参数和周期性任务参数处理Builder传入的参数不同，其他的约束参数是相同的。这也跟 OneTimeWorkRequest与PeriodicWorkRequest都继承与WorkRequest相关。相同的约束参数都是封装在WorkRequest，特殊的参数封装在子类中。后续有自定义的任务可以继承WorkRequest，实现自定义化。

构建约束条件

在JobScheduler的约束条件在构建JobInfo中设置，在WorkerManager中有单独的设置类Constraints，可配置的约束条件如下

Constraints constraints = new Constraints.Builder()
                .setRequiredNetworkType(NetworkType.CONNECTED)
                .setRequiresCharging(true)
                .setRequiresStorageNotLow(true)
                .setRequiresDeviceIdle(true)
                .setRequiresBatteryNotLow(true)
                //.addContentUriTrigger(new Uri(),false)
                .build()

任务具有可管理性

WorkerManager 比 JobScheduler 更为友好的一方面是可以更好管理Worker。WokerManager通过以下接口，对Worker进行管理

public abstract @NonNull LiveData<WorkInfo> getWorkInfoByIdLiveData(@NonNull UUID id);
public abstract @NonNull ListenableFuture<WorkInfo> getWorkInfoById(@NonNull UUID id);
public abstract @NonNull LiveData<List<WorkInfo>> getWorkInfosByTagLiveData(@NonNull String tag);
public abstract @NonNull ListenableFuture<List<WorkInfo>> getWorkInfosByTag( @NonNull String tag);
...

观察任务的状态

WorkerManger支持对任务状态的监控，使用代码如下

WorkManager.getInstance(getContext()).getWorkInfoByIdLiveData(firstWork.getId())
                .observe(getViewLifecycleOwner(), new Observer<WorkInfo>() {
                    @Override
                    public void onChanged(WorkInfo workInfo) {
                        if (workInfo != null) {
                            switch (workInfo.getState()) {
                                case RUNNING:
                                    Log.d(TAG, "进度 = " + workInfo.getProgress().getInt("progress", 0));
                                    break;
                                case SUCCEEDED:
                                    Log.d(TAG, "成功");
                                    break;
                                default:
                                    break;
                            }
                        }
                    }
                });

任务的参数

WorkerManager可以方便的在调用者，和Woker之间传递参数。示例如下

  1. Woker可以向WorkerManager传递运行过程中的参数和运行结果的参数。
public class FirstWork extends Worker{
public Result doWork() {
        Log.d(TAG,"thread id = "+Thread.currentThread().getId());
        Log.d(TAG,"执行时间  :"+ DateUtil.getCurrentTime("yyyy-MM-dd HH:mm:ss"));
        String number = getInputData().getString("number");
        // 向调用者（WorkManager）传递中间过程参数，
	    setProgressAsync(new Data.Builder().putInt("progress", 100).build());
        int aa = Integer.parseInt(number);
        // 构建返回值
        Data outputData = new Data.Builder()
                .putString("number",String.valueOf(aa))
                .build();
        // 向调用者（WorkManager）传递执行结果。      
        return Result.success(outputData);
    }
}
  1. 在调用Woker时，可以传递运行时需要的参数，以及监听Woker回传的参数。示例代码如下
Data data = new Data.Builder()
                .putString("number", "1")
                .build();
 OneTimeWorkRequest firstWork = new OneTimeWorkRequest.Builder(FirstWork.class)
                .setInitialDelay(3000, TimeUnit.MILLISECONDS)
                .setInputData(data)// 传入Worker运行时需要的参数。
                .setBackoffCriteria(BackoffPolicy.LINEAR, 11, TimeUnit.SECONDS)
                .addTag("first_work")
                .build();

监听Worker回传的参数

WorkManager.getInstance(getContext()).getWorkInfoByIdLiveData(firstWork.getId())
                .observe(getViewLifecycleOwner(), new Observer<WorkInfo>() {
                    @Override
                    public void onChanged(WorkInfo workInfo) {
                        if (workInfo != null) {
                            switch (workInfo.getState()) {
                                case RUNNING:
                                    Log.d(TAG, "进度 = " + workInfo.getProgress().getInt("progress", 0));
                                    break;
                                case SUCCEEDED:
                                    Log.d(TAG, "成功");
                                    break;
                                default:
                                    break;
                            }
                        }
                    }
                });

任务的取消

取消worker代码如下

WorkManager.getInstance(getContext()).cancelAllWork()
WorkManager.getInstance(getContext()).cancelWorkById()
WorkManager.getInstance(getContext()).cancelAllWorkByTag()
cxmfzu
关注
专栏目录
Android WorkManager 实战讲解
菜鸟博客
02-23 1003
WorkManager实战讲解WorkManager实战实例1、 定义工作，创建Worker对象2、链接工作3、定义工作请求WorkRequest4、WorkManager、ViewModel、LiveData结合 本篇博文以Android 官方demo WorkManagerSample为例，分析WorkManager的使用方法和相关知识点。通过本篇博文你可以理解和掌握以下知识点： 1、WorkManager的基本用法 2、多个Worker先后执行的链接方式。 3、WorkManager和ViewMode
Android WorkManager使用介绍
fjnu_se的博客
12-05 4290
  WorkManager 是google提供的异步执行任务的管理框架，是 Android Jetpack 的一部分，会根据手机的API版本和应用程序的状态来选择适当的方式执行任务。   在后台执行任务的需求是非常常见的，Android也提供了多种解决方案，如JobScheduler、Loader、Service等，如果这些API没有被恰当使用，则可能会消耗大量电量。Android在解决应用程序耗电问题上做了各种尝试，从Doze到App Standby，通过各种方式限制和管理应用程序，以保证应用程序不会在后
Android架构组件-WorkManager，来自阿里巴巴佛系Android程序员的指南
2201_75604341的博客
03-16 980
更有可能的是，它会希望每隔一段时间检查一次照片，并查看是否有任何新的或改变的图像需要压缩，这个循环任务可以压缩它找到的图像，或者它可以启动新的“压缩图像”任务。假设我们正在开发一个照片库应用，并且该应用程序需要定期压缩其存储的图像，我们想使用 WorkManager API 调度图像压缩任务，在这种情况下，我们并不需要关心压缩发生在何时，我们只需要设置这个任务然后就可以忘记它。：指定我们需要执行的任务。”，想要写出优秀的代码，最重要的一点还是自身的技术水平，不然用再好的工具也不能发挥出它的全部实力。
Android WorkManager 实战指南
最新发布
gitblog_00050的博客
09-15 913
Android WorkManager 实战指南 codelab-android-workmanager 项目地址: https://gitcode.com/gh_mirrors/an/android-workmanager ...
android——workermanager
wy313622821的博客
08-22 308
Android Jetpack WorkManager是一个库，它简化了后台任务管理和异步工作处理，使得开发者可以编写更易于管理、可靠且响应用户交互的应用。WorkManager可以帮助你在合适的时间执行长时间运行的任务，比如定期数据同步、清理缓存等，而不会影响用户体验。。
Android中的WorkManager
虎哥LoveDroid
06-02 1596
在后台运行任务会消耗设备有限的资源，如RAM和电池。这可能会导致用户体验不佳。例如，后台任务可能会降低设备的电池寿命或用户在观看视频、玩游戏、使用相机等时可能会遇到设备性能不佳的情况。为了提高电池性能，Android在早期版本中发布了一些资源，如Doze模式、应用程序待机、限制位置访问和其他一些内容。
Android - WorkManager
m0_59482482的博客
04-20 1036
1、WorkManager很适合用于处理一些要求定时执行的任务，它可以根据操作系统的版本自动选择 底层是使用AlarmManager实现还是JobScheduler实现，从而降低了我们的使用成本。另外， 它还支持周期性任务、链式任务处理等功能，是一个非常强大的工具。2、WorkManager和Service并不相同，也没有直接的联系。Service是Android系统的四大组件之一，它在没有被销毁的情况下是一直保持在后台运行的。
Android使用 WorkManager 调度任务
yingaizhu的博客
04-22 8759
一、前言     WorkManager属于Android Jetpack的一部分，通过WorkManager API可以轻松第调度可延迟的任务，即使是那些在应用退出或者设备重启时仍需要运行的任务。 WorkManager的主要功能 最高可向后兼容到 API 14 在 API 23 及以上级别的设备上运行使用 JobScheduler实现 在 API ...
Kotlin：lifecycleScope与GlobalScope以及MainScope的区别，详细分析为什么在Android中推荐使用lifecycleScope！
热门推荐
Pumpkin's Blog
08-29 1万+
目录简要GlobalScopeMainScope()lifecycleScopelifecycleScope剩余问题分析（感兴趣的可以继续看） 简要 首先简要介绍一下kotlin协程作用域的三种类型。 类型 产生方式 异常传播特征 顶级作用域 GlobalScope创建 异常不向外传播。异常到达顶级作用域后，如果还没有被处理，会抛给当前的exceptionHandler，如果没有则给当前线程的uncaughtExceptionHandler 协同作用域 Job嵌套、coroutineSc
android倒计时服务,Android倒计时器——CountDownTimer
weixin_42133415的博客
05-26 1921
倒计时器 CountDownTimer使用介绍 开发中经常会遇到一些和倒计时有关的场景,比如发送验证码的按钮,会在点击发送后,显示倒计时间,倒计时结束后才能够刷新按钮,再次允许点击.为了不阻塞软件的运行,又要实时刷新界面,我们通常会用到 ...Android Wear计时器开发记得在2013年12月的时候,有系列文章是介绍怎么开发一个智能手表的App,让用户可以在足球比赛中记录停表时间.随着An...
Android体系架构：WorkManager
2401_84122760的博客
04-23 1100
由于本文罗列的知识点是根据我自身总结出来的，并且由于本人水平有限，无法全部提及，欢迎大神们能补充~将来我会对上面的知识点一个一个深入学习，也希望有童鞋跟我一起学习，一起进阶。提升架构认知不是一蹴而就的，它离不开刻意学习和思考。**这里，笔者分享一份从架构哲学的层面来剖析的视频及资料分享给大家，**梳理了多年的架构经验，筹备近1个月最新录制的，相信这份视频能给你带来不一样的启发、收获。，第一时间获取最新知识点Android架构师之路很漫长，一起共勉吧！
Android架构组件JetPack之WorkManager完全解析（五），快速上手
m0_65146105的博客
12-22 354
@NonNull @Override public Worker.Result doWork() { Context applicationContext = getApplicationContext(); try { Bitmap picture = BitmapFactory.decodeResource( applicationContext.getResources(), R.drawable.test); return Worker.Result.SUCCESS; } catch (Throwa
使用Android WorkManager
weixin_26739079的博客
09-30 1004
Nowadays, WorkManager is one of the Android Architecture Components and also a part of Android Jetpack as a new approach for developing modern Android apps. As a matter of fact, the WorkManager API is...
Android WorkManager使用
qq_32898021的博客
11-28 786
1.添加依赖 api 'androidx.work:work-runtime:2.3.4' 或者 def work_version = "1.0.0-alpha11" // optional - Firebase JobDispatcher support api "android.arch.work:work-firebase:$work_version" // optional - Test helpers androidTestImplementation "and
【Android】WorkManager的使用
每天不是在写bug就是在写bug的路上
07-06 965
WorkManager的使用
Android 的 WorkManager 简单使用
Bai HongHua的博客
03-19 1247
Android 的 WorkManager 是一个用于安排和管理后台任务的 API，它可以让你轻松地执行延迟、定时、重复和约束任务，同时还能够在不同的 Android 平台版本中提供最佳的执行方式。
Android WorkManage 基本使用
star_nwe的博客
04-22 612
重新执行失败的任务 如果任务执行失败，还可以重新执行。 首先需要将任务执行结果返回为 `retry`。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值