当前位置： 正文

Android Jetpack系列–7. WorkManager使用详解

2023-09-10 WorkManager 421 推广

相关知识

  • 交换空间：当系统内存资源已被耗尽，但是又有额外的内存资源请求的时候，内存中不活动的页面会被移动到交换空间。交换空间是磁盘上的一块区域，因此其访问速度比物理内存慢。
  • Android基于Linux内核，两者主要差别在于Android系统没有交换空间(Swap space)
  • 于是Android系统引入了OOM( Out Of Memory ) Killer 来解决内存资源被耗尽的问题。
  • 其作用是根据进程所消耗的内存大小以及进程的“visibility state”来决定是否杀死这个进程，从而达到释放内存的目的。
  • Activity Manager会给不同状态下的进程设置相对应的oom_adj 值：
# Define the oom_adj values for the classes of processes that can be
# killed by the kernel.  These are used in ActivityManagerService.
    setprop ro.FOREGROUND_APP_ADJ 0    //前台进程
    setprop ro.VISIBLE_APP_ADJ 1       //可见进程
    setprop ro.SECONDARY_SERVER_ADJ 2  //次要服务
    setprop ro.BACKUP_APP_ADJ 2        //备份进程
    setprop ro.HOME_APP_ADJ 4          //桌面进程
    setprop ro.HIDDEN_APP_MIN_ADJ 7    //后台进程
    setprop ro.CONTENT_PROVIDER_ADJ 14 //内容供应节点
    setprop ro.EMPTY_APP_ADJ 15        //空进程
  • 因此，1是应用占用内存越少，越可能存活下去；2是要合理设计后台任务进程

后台任务

  • Android开发基本都会用到后台任务，通常是不需要用户感知的耗时功能，任务完成后需要及时关闭任务回收资源，若使用不合理则可能造成电量大量消耗；
  • 之前我们处理后台任务一般使用service或线程池，尤其是service又不受Activity生命周期影响，被广泛用于数据缓存，统计及日志上传，消息推送，环境监听，进程保活拉起等，如此过于滥用给用户带来耗电快，被打扰，隱私泄露等问题，于是google在新的Android版本中逐渐增加限制，Doze机制，app Standby等，尤其是Android8.0不允许创建后台服务，无法在清单文件中注册隐式广播接收器; 所以我们所熟知的Servcie已经被弃用了，因为它不再被允许在后台执行长时间的操作，即便这是它最初被设计出来的目的, 除了ForegroundService之外，我们已经没有任何理由再去使用Service了；

Google推荐的不同场景后台任务的处理方案

  1. 需系统触发，不必完成：ThreadPool + Broadcast
  2. 需系统触发，必须完成，可推迟：WorkManager
  3. 需系统触发，必须完成，立即：ForegroundService + Broadcast
  4. 不需系统触发，不必完成：ThreadPool
  5. 不需系统触发，必须完成，可推迟：WorkManager
  6. 不需系统触发，必须完成，立即：ForegroundService

WorkManager简介

  • 一个可兼容，灵活，简单的延迟后台任务；
  • 能根据系统版本，选择不同实现方案，API高于23时采用JobScheduler，以帮助优化电池寿命和批处理作业，而在6.0以下系统版本则可自动切换为AlarmManager+Broadcast Receiver，最终都是交由Executor来执行；

WorkManager优点

  • 兼容性：兼容到api14
  • 可指定约束条件：如有网络才执行
  • 可指定执行次数和定时
  • 多个任务可使用任务链
  • 保证执行：如当前不满足或app挂掉后，下次满足条件再执行
  • 支持省电模式

WorkManager使用

导入依赖
implementation "androidx.work:work-runtime-ktx:2.5.0"
// optional - RxJava2 support
implementation "androidx.work:work-rxjava2:2.5.0"
// optional - Test helpers
androidTestImplementation "androidx.work:work-testing:2.5.0"
初始化配置
  • WorkManager 2.1.0以前的版本
// provide custom configuration
val myConfig = Configuration.Builder()
    .setMinimumLoggingLevel(android.util.Log.INFO)
    .build()

// initialize WorkManager
WorkManager.initialize(this, myConfig)
  • WorkManager 2.1.0及更高版本中已经默认使用provider进行初始化，通过ContentProvider初始化在之前的Android Jetpack系列–5. App Startup使用详解中有过介绍，通过查看其aar文件可以看到其AndroidManifest.xml中的provider配置如下
  • WorkManagerInitializer源码如下
@RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
public class WorkManagerInitializer extends ContentProvider {
    @Override
    public boolean onCreate() {
        // Initialize WorkManager with the default configuration.
        WorkManager.initialize(getContext(), new Configuration.Builder().build());
        return true;
    }

    @Nullable
    @Override
    public Cursor query(@NonNull Uri uri,
            @Nullable String[] projection,
            @Nullable String selection,
            @Nullable String[] selectionArgs,
            @Nullable String sortOrder) {
        return null;
    }

    @Nullable
    @Override
    public String getType(@NonNull Uri uri) {
        return null;
    }

    @Nullable
    @Override
    public Uri insert(@NonNull Uri uri, @Nullable ContentValues values) {
        return null;
    }

    @Override
    public int delete(@NonNull Uri uri,
            @Nullable String selection,
            @Nullable String[] selectionArgs) {
        return 0;
    }

    @Override
    public int update(@NonNull Uri uri,
            @Nullable ContentValues values,
            @Nullable String selection,
            @Nullable String[] selectionArgs) {
        return 0;
    }
}
  • 如果想要自定义初始化可以如下操作
//1. AndroidManifest.xml中覆盖其provider，并设置tools:node="remove"
//WorkManager 2.6以前版本

//WorkManager 2.6以后的版本

    
    


//2. Application实现Configuration.Provider接口
class MyApplication() : Application(), Configuration.Provider {
     override fun getWorkManagerConfiguration() =
           Configuration.Builder()
                .setMinimumLoggingLevel(android.util.Log.INFO)
                .build()
}
//You do not need to call `WorkManager.initialize()` yourself
//注意这里是实现Provider接口而不是像2.1版本一样手动调用initialize，
//当然如果我就要手动调用WorkManager.initialize也不会有报错，只是官方不推荐
//看看WorkManagerImpl.getInstance方法就知道了
public static @NonNull WorkManagerImpl getInstance(@NonNull Context context) {
    synchronized (sLock) {
        WorkManagerImpl instance = getInstance();
        if (instance == null) {
            Context appContext = context.getApplicationContext();
            //这里如果application没有实现Provider接口就直接抛出异常
            if (appContext instanceof Configuration.Provider) {
                initialize(
                        appContext,
                        ((Configuration.Provider) appContext).getWorkManagerConfiguration());
                instance = getInstance(appContext);
            } else {
                throw new IllegalStateException("WorkManager is not initialized properly.  You "
                        + "have explicitly disabled WorkManagerInitializer in your manifest, "
                        + "have not manually called WorkManager#initialize at this point, and "
                        + "your Application does not implement Configuration.Provider.");
            }
        }
        return instance;
    }
}
自定义Worker
  • 谷歌提供了四种Worker给我们使用，分别为：
    • 自动运行在后台线程的Worker
    • 结合协程的CoroutineWorker
    • 结合RxJava2的RxWorker
    • 以上三个类的基类的ListenableWorker
  • 我使用的是CoroutineWorker，然后重写doWork方法，其代码如下
class MyWorker(appContext: Context, workerParameters: WorkerParameters) :
    CoroutineWorker(appContext, workerParameters) {

    //执行在一个单独的后台线程里
    override suspend fun doWork(): Result {
        LjyLogUtil.d("doWork start")
        delay(5000)//模拟处理任务耗时
        LjyLogUtil.d("doWork end")
        return Result.success()
    }
}
  • doWork方法执行在一个单独的后台线程里
  • doWork的结果有三种，分别为：
    • Result.success()：工作成功完成。
    • Result.failure()：工作失败。
    • Result.retry()：工作失败，根据其重试政策在其他时间尝试。
执行单次任务
  • 单次任务使用OneTimeWorkRequestBuilder创建workRequest，再通过WorkManager对象的enqueue()方法将其提交到WorkManager
class WorkManagerActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_work_manager)
        //执行单次任务
        val workRequest = OneTimeWorkRequestBuilder().build()
        WorkManager.getInstance(this).enqueue(workRequest)
    }
}
定期循环任务
  • 可用于如定期上传日志，定期缓存预加载的数据，定期备份等
  • 使用PeriodicWorkRequest.Builder创建workRequest
val workRequest2 =
            PeriodicWorkRequest.Builder(MyWorker::class.java, 3, TimeUnit.SECONDS).build()
WorkManager.getInstance(this).enqueue(workRequest2)
  • 还可以定义具有灵活时间段的定期工作，如在每小时的最后 15 分钟内运行定期工作
val workRequest2: WorkRequest = PeriodicWorkRequest.Builder(
        MyWorker::class.java,
        1, TimeUnit.HOURS,
        15, TimeUnit.MINUTES
    ).build()
WorkManager.getInstance(this).enqueue(workRequest2)
设置任务约束条件
  • 如果不满足某个约束,WorkManager将停止工作，并且系统将在满足所有约束后重试工作
val constraints = Constraints.Builder()
            //设备空闲状态时运行
            .setRequiresDeviceIdle(true)
            //特定的网络状态运行
            //NOT_REQUIRED  不需要网络
            //CONNECTED 任何可用网络
            //UNMETERED 需要不计量网络，如WiFi
            //NOT_ROAMING   需要非漫游网络
            //METERED   需要计量网络，如4G
            .setRequiredNetworkType(NetworkType.CONNECTED)
            //电量充足时运行
            .setRequiresBatteryNotLow(true)
            //充电时执行
            .setRequiresCharging(true)
            //存储空间足够时运行
            .setRequiresStorageNotLow(true)
            //指定是否在(Uri指定的)内容更新时执行本次任务
            .addContentUriTrigger(Uri.EMPTY, true)
            .build()
val workRequest = OneTimeWorkRequestBuilder()
        .setConstraints(constraints)
        .build()
WorkManager.getInstance(this).enqueue(workRequest)
分配输入数据
//1. 传入数据
val inputData = Data.Builder().putString("name", "ljy").build()
val workRequest = OneTimeWorkRequestBuilder()
        .setInputData(inputData)
        .build()
WorkManager.getInstance(this).enqueue(workRequest)
//2.接收数据
class MyWorker(appContext: Context, workerParameters: WorkerParameters) :
        CoroutineWorker(appContext, workerParameters) {
    override suspend fun doWork(): Result {
        val name = inputData.getString("name")
        LjyLogUtil.d("doWork start:name=$name")
        delay(5000)
        LjyLogUtil.d("doWork end")
        return Result.success()
    }
}
延时执行
val workRequest = OneTimeWorkRequestBuilder()
        .setInitialDelay(1, TimeUnit.SECONDS)
        .build()
WorkManager.getInstance(this).enqueue(workRequest)
设置tag
  • 可以用于取消工作或观察其进度,或者对任务进行分组
  • 如果有一组在逻辑上相关的工作，对这些工作项进行标记可能也会很有帮助
val workRequest = OneTimeWorkRequestBuilder()
        .addTag("myWorker")
        .build()
WorkManager.getInstance(this).enqueue(workRequest)
重试和退避政策
  • 工作器返回 Result.retry()，系统将根据退避延迟时间和退避政策重新调度工作;
  • 退避延迟时间:指定了首次尝试后重试工作前的最短等待时间;
  • 退避政策: 定义了在后续重试过程中，退避延迟时间随时间以怎样的方式增长,WorkManager 支持 2 个退避政策，即 LINEAR 和 EXPONENTIAL;
  • 每个工作请求都有退避政策和退避延迟时间, 默认政策是 EXPONENTIAL，延迟时间为 10 秒，开发者可以在工作请求配置中替换此默认设置。
val workRequest4: WorkRequest = OneTimeWorkRequest.Builder(MyWorker::class.java)
    .setBackoffCriteria(
        BackoffPolicy.LINEAR,
        OneTimeWorkRequest.MIN_BACKOFF_MILLIS,
        TimeUnit.MILLISECONDS
    )
    .build()
创建任务链
  • 例如先执行任务1，再执行任务2和任务5，任务2执行完后执行任务3，任务4
val request1 = OneTimeWorkRequest.Builder(MyWorker::class.java).build()
val request2 = OneTimeWorkRequest.Builder(MyWorker::class.java).build()
val request3 = OneTimeWorkRequest.Builder(MyWorker::class.java).build()
val request4 = OneTimeWorkRequest.Builder(MyWorker::class.java).build()
val request5 = OneTimeWorkRequest.Builder(MyWorker::class.java).build()
val workConstraints = WorkManager.getInstance(this).beginWith(request1)
workConstraints.then(request2).then(listOf(request3, request4)).enqueue()
workConstraints.then(request5).enqueue()
唯一链
  • 同一时间内队列里不能存在相同名称的任务
    • WorkManager.enqueueUniqueWork()：用于一次性工作
    • WorkManager.enqueueUniquePeriodicWork()：用于定期工作
  • 应用场景：多次请求接口数据，如下单，更换头像等
  • 例如替换头像要经历本地文件读取，压缩，上传三个任务，下面组成一个串行的任务连，并且设置唯一标识，则代码如下：
val requestLoadFromFile = OneTimeWorkRequest.Builder(MyWorker::class.java).build()
val requestZip = OneTimeWorkRequest.Builder(MyWorker::class.java)
    .setInputData(createInputDataForUri()).build()
val requestSubmitToService = OneTimeWorkRequest.Builder(MyWorker::class.java).build()
WorkManager.getInstance(this).beginUniqueWork(
    "tagChangeImageHeader",
    ExistingWorkPolicy.REPLACE,
    requestLoadFromFile
)
    .then(requestZip)
    .then(requestSubmitToService)
    .enqueue()
  • 其中参数existingWorkPolicy有三种可选：
    • REPLACE：若相同，删除已有的任务，添加现有的任务；
    • KEEP：若相同，让已有的继续执行，不添加新任务；
    • APPEND：若相同，则添加新任务到已有任务链最末端；
Work状态
  • 当WorkManager把任务加入队列后，会为每个WorkRequest对象提供一个LiveData;
  • LiveData持有WorkStatus,通过观察该 LiveData, 我们可以确定任务的当前状态, 并在任务完成后获取所有返回的值；
ENQUEUED,//已加入队列
RUNNING,//运行中
SUCCEEDED,//已成功
FAILED,//已失败
BLOCKED,//已挂起
CANCELLED;//已取消
  • 状态的更改分为一次性任务的状态和周期性任务的状态:
    • 一次性任务状态：初始状态为 ENQUEUED，在满足其 Constraints 和初始延迟计时要求后立即运行，转为 RUNNING,
      根据工作的结果转为 SUCCEEDED、FAILED 状态, 如果结果是Result.retry() ,它可能会回到 ENQUEUED 状态;
      SUCCEEDED、FAILED 和 CANCELLED 均表示此工作的终止状态,WorkInfo.State.isFinished() 都将返回 true;
      在此过程中，随时都可以取消工作，取消后工作将进入 CANCELLED 状态;
    • 定期任务状态：因为是循环执行的，所以终止状态只有一个CANCELLED，其他和一次性任务状态是一样;
状态监听
// by id
WorkManager.getInstance(this).getWorkInfoById(request1.id)
WorkManager.getInstance(this).getWorkInfoByIdLiveData(request1.id)
// by name
WorkManager.getInstance(this).getWorkInfosForUniqueWork("sync");
WorkManager.getInstance(this).getWorkInfosForUniqueWorkLiveData("sync");
// by tag
WorkManager.getInstance(this).getWorkInfosByTag("syncTag")
WorkManager.getInstance(this).getWorkInfosByTagLiveData("syncTag")
WorkQuery
  • WorkManager 2.4.0 及更高版本还支持使用 WorkQuery 对象对已加入队列的作业进行复杂查询，
  • WorkQuery 支持按工作的标记、状态和唯一工作名称的组合进行查询
val workQuery = WorkQuery.Builder
    .fromTags(listOf("syncTag"))
    .addStates(listOf(WorkInfo.State.FAILED, WorkInfo.State.CANCELLED))
    .addUniqueWorkNames(
        listOf("preProcess", "sync")
    )
    .build()
val workInfos: ListenableFuture> =
    WorkManager.getInstance(this).getWorkInfos(workQuery)
更新进度 和 观察进度
  • Java: 使用Worker.setProgressAsync()更新进度
  • Kotlin：使用 CoroutineWorker.setProgress()更新进度，代码如下
class MyWorker(appContext: Context, workerParameters: WorkerParameters) :
        CoroutineWorker(appContext, workerParameters) {
        
    override suspend fun doWork(): Result {
        val name = inputData.getString("name")
        LjyLogUtil.d("doWork start:name=$name")
        val p0 = workDataOf("progressValue" to 0)
        val p1 = workDataOf("progressValue" to 20)
        val p2 = workDataOf("progressValue" to 40)
        val p3 = workDataOf("progressValue" to 60)
        val p4 = workDataOf("progressValue" to 80)
        val p5 = workDataOf("progressValue" to 100)
        setProgress(p0)
        delay(1000)
        setProgress(p1)
        delay(1000)
        setProgress(p2)
        delay(1000)
        setProgress(p3)
        delay(1000)
        setProgress(p4)
        delay(1000)
        setProgress(p5)
        LjyLogUtil.d("doWork end")
        return Result.success()
    }
}
  • 观察进度：和上面的监听任务状态是一样的，使用 getWorkInfoBy…() 或 getWorkInfoBy…LiveData(),代码如下
val workRequest10 = OneTimeWorkRequestBuilder().build()
WorkManager.getInstance(this).enqueue(workRequest10)
WorkManager.getInstance(this)
    .getWorkInfoByIdLiveData(workRequest10.id)
    .observe(this, {
        if (it != null) {
            LjyLogUtil.d("workRequest10:state=${it.state}")
            val progress = it.progress;
            val value = progress.getInt("progressValue", 0)
            LjyLogUtil.d("workRequest10:progress=$value")
        }
    })
取消任务
//取消所有任务
WorkManager.getInstance(this).cancelAllWork()
//取消一组带有相同标签的任务
WorkManager.getInstance(this).cancelAllWorkByTag("tagName")
//根据name取消任务
WorkManager.getInstance(this).cancelUniqueWork("uniqueWorkName")
//根据id取消任务
WorkManager.getInstance(this).cancelWorkById(workRequest.id)
任务停止
  • 正在运行的任务可能因为某些原因而停止运行，主要的原因有以下一些：
1. 明确要求取消它，可以调用WorkManager.cancelWorkById(UUID)方法。
2. 如果是唯一任务，将 ExistingWorkPolicy 为 REPLACE 的新 WorkRequest 加入到了队列中时，旧的 WorkRequest 会立即被视为已取消。
3. 添加的任务约束条件不再适合。
4. 系统出于某种原因指示应用停止工作。
5. 当任务停止后，WorkManager 会立即调用 ListenableWorker.onStopped()关闭可能保留的所有资源。
下载说明：
1、本站所有资源均从互联网上收集整理而来，仅供学习交流之用，因此不包含技术服务请大家谅解！
2、本站不提供任何实质性的付费和支付资源，所有需要积分下载的资源均为网站运营赞助费用或者线下劳务费用！
3、本站所有资源仅用于学习及研究使用，您必须在下载后的24小时内删除所下载资源，切勿用于商业用途，否则由此引发的法律纠纷及连带责任本站和发布者概不承担！
4、本站站内提供的所有可下载资源，本站保证未做任何负面改动（不包含修复bug和完善功能等正面优化或二次开发），但本站不保证资源的准确性、安全性和完整性，用户下载后自行斟酌，我们以交流学习为目的，并不是所有的源码都100%无错或无bug！如有链接无法下载、失效或广告，请联系客服处理！
5、本站资源除标明原创外均来自网络整理，版权归原作者或本站特约原创作者所有，如侵犯到您的合法权益，请立即告知本站，本站将及时予与删除并致以最深的歉意！
6、如果您也有好的资源或教程，您可以投稿发布，成功分享后有站币奖励和额外收入！
7、如果您喜欢该资源，请支持官方正版资源，以得到更好的正版服务！
8、请您认真阅读上述内容，注册本站用户或下载本站资源即您同意上述内容！
原文链接：https://www.dandroid.cn/19307，转载请注明出处。
赏 0

猜你喜欢

Jetpack Compose屏幕适配

开始 和之前一样，阅读这篇文章，了解一下适配的思路 ：一种极低成本的Android屏幕...
2023-12-20 453
Android Compose 新闻App

网络数据Compose UI显示加载、Room和DataStore使用
2023-11-17 488免费
免费
Android | Compose 状态管理

前言 应用中的状态指的是可以随时间变化的任何值。这个定义非常广泛，例如从数...
2023-11-17 635
Android Jetpack Compose 动画速查表

Android Jetpack Compose 提供了和原来的 View 系统完全不一样的动画机制和 AP...
2023-11-17 533
Android Compose 生命周期和附带效应

前言 可组合项 应该没有附带效应，但是，如果在对应用状态进行转变时需要...
2023-11-17 448
Android | Compose 初上手

简介 Jetpack Compose 是用于构建原生 Andorid 界面的新工具包，Compose 使用...
2023-11-17 586

评论0

取消

首页 推荐 教程 我的
显示验证码
没有账号？注册  忘记密码？