一、介绍

通过前面两篇，我们基本掌握了组件的workmanager的接入，以及api的使用等。但是一个框架如果运用在复杂的项目中，肯定需要有其他额外的支持，介绍来我们将会介绍高级概念，以及对前面的知识点进行回顾与拓展。

高级概念

一、配置和初始化

默认情况下，当您的应用启动时，WorkManager 使用适合大多数应用的合理选项自动进行配置。如果您需要进一步控制 WorkManager 管理和调度工作的方式，可以通过自行初始化 WorkManager 来自定义 WorkManager 配置

移除默认初始化程序

如需提供自己的配置，必须先移除默认初始化程序。为此，请使用合并规则tools:node="remove"

从 WorkManager 2.6 开始，应用启动功能便已在 WorkManager 内部使用。如需提供自定义初始化程序，您需要移除androidx.startup节点

如果您不在应用中使用应用启动功能，则可以将其彻底移除。

否则，仅移除WorkManagerInitializer节点即可。

如果您使用的 WorkManager 是 2.6 之前的版本，请改为移除workmanager-init：

二、实现 Configuration.Provider

让项目Application 类实现 Configuration.Provider 接口，并提供您自己的 Configuration.Provider.getWorkManagerConfiguration() 实现。当您需要使用 WorkManager 时，请务必调用方法 WorkManager.getInstance(Context)。WorkManager 会调用应用的自定义 getWorkManagerConfiguration() 方法来发现其 Configuration

public class MyApp extends Application implements Configuration.Provider {    @NonNull    @Override    public Configuration getWorkManagerConfiguration() {        Configuration.Builder builder= new Configuration.Builder();        builder.setMinimumLoggingLevel(android.util.Log.DEBUG);        return builder.build();    }}

三、WorkManager 2.1.0 之前版本的自定义初始化

在您的应用启动时，WorkManager 会使用自定义ContentProvider自行初始化。此代码位于内部类androidx.work.impl.WorkManagerInitializer中，并使用默认Configuration。自动使用默认初始化程序（除非明确停用它）。默认初始化程序适合大多数应用

自定义初始化：

val myConfig = Configuration.Builder()    .setMinimumLoggingLevel(android.util.Log.INFO)    .build()// initialize WorkManagerWorkManager.initialize(this, myConfig)

四、WorkManager中的线程处理

在 WorkManager 使用入门中，我们提到 WorkManager 可以代表您异步执行后台工作。该基本实现可满足大多数应用的需求。关于更高级的用例（例如正确处理正在停止的工作），您应了解 WorkManager 中的线程处理和并发机制。

WorkManager 提供了四种不同类型的工作基元：

• Worker是最简单的实现，我们已在前面几节进行了介绍。WorkManager 会在后台线程中自动运行该基元（您可以将它替换掉）。请参阅工作器中的线程处理，详细了解Worker实例中的线程处理。
• CoroutineWorker是为 Kotlin 用户建议的实现。CoroutineWorker实例公开了后台工作的一个挂起函数。默认情况下，这些实例运行默认的Dispatcher，但您可以进行自定义。请参阅CoroutineWorker 中的线程处理，详细了解CoroutineWorker实例中的线程处理。
• RxWorker是为 RxJava 用户建议的实现。如果您有很多现有异步代码是用 RxJava 建模的，则应使用 RxWorker。与所有 RxJava 概念一样，您可以自由选择所需的线程处理策略。请参阅RxWorker 中的线程处理，详细了解RxWorker实例中的线程处理。
• ListenableWorker是Worker、CoroutineWorker和RxWorker的基类。这个类专为需要与基于回调的异步 API（例如FusedLocationProviderClient）进行交互并且不使用 RxJava 的 Java 开发者而设计。请参阅ListenableWorker 中的线程处理，详细了解ListenableWorker实例中的线程处理。

五、工作器中的线程处理

当您使用 Worker 时，WorkManager 会自动在后台线程中调用 Worker.doWork()。该后台线程来自于 WorkManager 的 Configuration 中指定的 Executor。默认情况下，WorkManager 会为您设置 Executor，但您也可以自己进行自定义。例如，您可以在应用中共享现有的后台 Executor，也可以创建单线程 Executor 以确保所有后台工作都按顺序执行，甚至可以指定一个自定义 Executor

在手动配置 WorkManager 时，您可以按以下方式指定Executor：

fun initConfig(){        WorkManager.initialize(            application,            Configuration.Builder()                // Uses a fixed thread pool of size 8 threads.                .setExecutor(Executors.newFixedThreadPool(8))                .build()) }

接下来我们会执行一个64次的重复，需要重写work

class MyWork(context: Context, workerParams: WorkerParameters) : Worker(context, workerParams) {    var count = 1;    override fun doWork(): Result {//        TODO("Not yet implemented")        repeat(64) {            Log.e("Mywork", "" + count++)            return Result.success()        }        return Result.success()    }}

只需要在doWork中，进行repeat的即可。填入重复项。

repeat方法：

@kotlin.internal.InlineOnlypublic inline fun repeat(times: Int, action: (Int) -> Unit) {    contract { callsInPlace(action) }    for (index in 0 until times) {        action(index)    }}

就是一个不停调用action的执行方法。

注意：

第一点：

Worker.doWork() 是同步调用 – 您应以阻塞方式完成整个后台工作，并在方法退出时完成工作。如果您在 doWork() 中调用异步 API 并返回 Result，那么回调可能无法正常运行。如果您遇到这种情况，请考虑使用 ListenableWorker

第二点：

如果当前正在运行的 Worker 因任何原因而停止，它就会收到对 Worker.onStopped() 的调用。在必要的情况下，只需替换此方法或调用 Worker.isStopped()，即可对代码进行检查点处理并释放资源。当上述示例中的 Worker 被停止时，内容的下载可能才完成了一半；但即使该工作器被停止，下载也会继续。

如果想同步，在执行时，需要对isStop进行拦截

    override fun doWork(): Result {//        TODO("Not yet implemented")        repeat(64) {            if (!isStopped) {                Log.e("Mywork", "" + count++)            }        }        return Result.success()    }

六、CoroutineWorker 中的线程处理

WorkManager 为协程提供了一流的支持。如要开始使用，请将 work-runtime-ktx 包含到您的 gradle 文件中。继承CoroutineWorker，包含 doWork() 的挂起版本

class MyCoroutineWorker(    appContext: Context,    params: WorkerParameters) : CoroutineWorker(appContext, params) {    override suspend fun doWork(): Result {}}

CoroutineWorker.doWork() 是一个“挂起”函数。不同于 Worker，不会在 Configuration 中指定的 Executor 中运行，而是默认为 Dispatchers.Default。

您可以提供自己的CoroutineContext来自定义这个行为。在上面的示例中，您可能希望在Dispatchers.Main上完成此操作。

    override suspend fun doWork(): Result {        withContext(Dispatchers.Main){                    }        return Result.Success.success()    }

CoroutineDispatcher提供了如下：

Dispatchers.DefaultDispatchers.IODispatchers.MainDispatchers.Unconfined

CoroutineWorker 通过取消协程并传播取消信号来自动处理停工情况，无需执行任何特殊操作来处理停工情况。

七、在其他进程中运行 CoroutineWorker

使用RemoteCoroutineWorker（ListenableWorker的实现）将工作器绑定到特定进程。

RemoteCoroutineWorker会使用您在构建工作请求时于输入数据中提供的两个额外参数绑定到特定进程：ARGUMENT_CLASS_NAME和ARGUMENT_PACKAGE_NAME

    fun BindWorkRequest() :WorkRequest{        val PACKAGE_NAME = packageName        val serviceName = RemoteWorkerService::class.java.name        val componentName = ComponentName(PACKAGE_NAME, serviceName)        val data: Data = Data.Builder()            .putString(RemoteListenableWorker.ARGUMENT_PACKAGE_NAME, componentName.packageName)            .putString(RemoteListenableWorker.ARGUMENT_CLASS_NAME, componentName.className)            .build()        return OneTimeWorkRequest.Builder(MyCoroutineWorker::class.java)            .setInputData(data)            .build()    }

还需要在AndroidManifest.xml文件中添加服务定义：

RemoteWorkerService2是一个空service，需要我们自己去创建。

八、RxWorker 中的线程处理

在 WorkManager 与 RxJava 之间提供互操作性。如需开始使用这种互操作性，除了在您的 gradle 文件中包含 work-runtime 之外，还应包含 work-rxjava3 依赖项。而且还有一个支持 rxjava2 的 work-rxjava2 依赖项，您可以根据情况使用。

需要定义自己的RxWorker，替换 RxWorker.createWork() 方法以返回 Single，用于表示代码执行的 Result。

class MyRxWork( appContext:Context, workerParams:WorkerParameters ) : RxWorker(appContext, workerParams) {    override fun createWork(): Single {        return Observable.range(0,100).toList().map { Result.Success }    }}

注意：

RxWorker.createWork() 在主线程上调用，但默认情况下会在后台线程上订阅返回值。您可以替换 RxWorker.getBackgroundScheduler() 来更改订阅线程。

当 RxWorker 为 onStopped() 时，系统会处理订阅，因此您无需以任何特殊方式处理停工情况。

    override fun getBackgroundScheduler(): Scheduler {        return super.getBackgroundScheduler()    }

九、ListenableWorker 中的线程处理

在某些情况下，需要提供自定义线程处理策略，需要处理基于回调的异步操作。在这种情况下，不能只依靠 Worker 来完成操作，因为它无法以阻塞方式完成这项工作。WorkManager 通过 ListenableWorker 支持该用例。ListenableWorker 是最基本的工作器 API；Worker、CoroutineWorker 和 RxWorker 都是从这个类衍生而来的。ListenableWorker 只会发出信号以表明应该开始和停止工作，而线程处理则完全交您决定。开始工作信号在主线程上调用，因此请务必手动转到您选择的后台线程。

抽象方法 ListenableWorker.startWork() 会返回一个将使用操作的 Result 设置的 ListenableFuture。ListenableFuture 是一个轻量级接口：它是一个 Future，用于提供附加监听器和传播异常的功能。在 startWork 方法中，应该返回 ListenableFuture，完成操作后，您需要使用操作的 Result 设置这个返回结果

1. 如果您使用的是 Guava，请使用ListeningExecutorService。
2. 否则，请将councurrent-futures包含到您的 gradle 文件中并使用CallbackToFutureAdapter

使用CallBackToFutureAdapter，需要引入依赖

implementation("androidx.concurrent:concurrent-futures-ktx:1.1.0")

implementation("androidx.concurrent:concurrent-futures:1.1.0")

class MyListenableWorker(        context: Context,        params: WorkerParameters) : ListenableWorker(context, params) {    override fun startWork(): ListenableFuture {        return CallbackToFutureAdapter.getFuture { completer ->            val callback = object : Callback {                var successes = 0                override fun onFailure(call: Call, e: IOException) {                    completer.setException(e)                }                override fun onResponse(call: Call, response: Response) {                    successes++                    if (successes == 100) {                        completer.set(Result.success())                    }                }            }            repeat(100) {                Log("info","infosssss")            }            callback        }    }}

如果您的工作停止会发生什么？如果预计工作会停止，则始终会取消ListenableWorker的ListenableFuture。通过使用CallbackToFutureAdapter,您只需添加一个取消监听器即可

completer.addCancellationListener(Runnable runable,Executor executor)

十、在其他进程中运行 ListenableWorker

和CoroutineWorker 用法一样，因为CoroutineWorker 也是ListenableWorker的派生类。可参考上面资料

十一、长时间运行的 worker

WorkManager 为长时间运行的 worker 提供内置支持。在这种情况下，WorkManager 可以向操作系统提供一个信号，指示在此项工作执行期间应尽可能让进程保持活跃状态。这些 worker 可以运行超过 10 分钟。

在后台，WorkManager 会代表您管理和运行前台服务以执行 WorkRequest，同时还会显示可配置的通知。

ListenableWorker 现在支持 setForegroundAsync() API，而 CoroutineWorker 则支持挂起 setForeground() API。这些 API 允许开发者指定此 WorkRequest 是“重要的”（从用户的角度来看）或“长时间运行的”任务。

从 2.3.0-alpha03 开始，WorkManager 还允许您创建 PendingIntent，此 Intent 可用于取消 worker，而不必使用 createCancelPendingIntent() API 注册新的 Android 组件。此方法与 setForegroundAsync() 或 setForeground() API 一起使用时特别有用，可用于添加一个取消 Worker 的通知操作。

步骤：

1、我们需要定义一个CoroutineWorker类

2、早doWork()方法中，调用=setForeground（info:ForegroundInfo）

3、这个ForegroundInfo需要我们去构建

    private fun createForegroundInfo(progress: String): ForegroundInfo {        val id = applicationContext.getString(R.string.notification_channel_id)        val title = applicationContext.getString(R.string.notification_title)        val cancel = applicationContext.getString(R.string.cancel_download)        // This PendingIntent can be used to cancel the worker        val intent = WorkManager.getInstance(applicationContext)            .createCancelPendingIntent(getId())        // Create a Notification channel if necessary        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {            createChannel()        }        val notification = NotificationCompat.Builder(applicationContext, id)            .setContentTitle(title)            .setTicker(title)            .setContentText(progress)            .setSmallIcon(R.drawable.ic_work_notification)            .setOngoing(true)            // Add the cancel action to the notification which can            // be used to cancel the worker            .addAction(android.R.drawable.ic_delete, cancel, intent)            .build()        val notificationId= Random.nextInt(1,Int.MAX_VALUE)        return ForegroundInfo(notificationId, notification)    }    @RequiresApi(Build.VERSION_CODES.O)    private fun createChannel() {        // Create a Notification channel    }

ForegroundInfo是一个持有通知对象的前景info。

十二、将前台服务类型添加到长时间运行的 worker

如果您的应用以 API 级别 29或更高版本为目标平台，且包含需要位置信息访问权限的长时间运行的 worker，请指明该 worker 使用location的前台服务类型。此外，如果您的应用以 Android API 级别 30或更高版本为目标平台，且包含需要访问摄像头或麦克风的长时间运行的 worker，请分别声明camera或microphone前台服务类型。

如需添加这些前台服务类型，在应用清单中声明前台服务类型

在运行时指定前台服务类型

当您调用 setForeground() 或 setForegroundAsync() 时，请指定前台服务类型 FOREGROUND_SERVICE_TYPE_LOCATION、FOREGROUND_SERVICE_TYPE_CAMERA 或 FOREGROUND_SERVICE_TYPE_MICROPHONE

创建：ForegroundInfo

ForegroundInfo(NOTIFICATION_ID, notification,FOREGROUND_SERVICE_TYPE_LOCATION orFOREGROUND_SERVICE_TYPE_MICROPHONE)

十三、总结

通过以上三篇文章，已完全分析完WorkManager的工作机制，以及场景的使用。我们在自己的项目中，或者需求中，可以运用workmanager来完成一些复杂的工作，提高我们的应用交互的便捷性。