【Android JetPack系列】WorkManager

原创
2019/10/24 14:59
阅读数 196

一、前言

作用WorkManager 负责用来管理后台任务。

区别: 它和一个异步任务以及 Service 有什么区别呢?看完你就知道了

相关类

  • Worker:任务的执行者,是一个抽象类,需要继承它实现要执行的任务。

  • WorkRequest:指定让哪个 Woker 执行任务,指定执行的环境,执行的顺序等。要使用它的子类 OneTimeWorkRequestPeriodicWorkRequest

  • WorkManager:管理任务请求和任务队列,发起的 WorkRequest 会进入它的任务队列。

  • WorkStatus:包含有任务的状态和任务的信息,以 LiveData 的形式提供给观察者。

二、集成

build.gradle 中配置:

implementation "android.arch.work:work-runtime:$work_version"
implementation "android.arch.work:work-firebase:$work_version"

gradle.properties中配置:

work_version=1.0.0-alpha10

三、基本使用

1、使用步骤

第一步:定义 worker

我们定义 MainWorker 继承 Worker,发现需要重写 doWork 方法,并且需要返回任务的状态 WorkerResult

class MainWork(context: Context, workerParams: WorkerParameters) : Worker(context, workerParams) {
    override fun doWork(): Result {
      // todo  要执行的任务
       return Result.SUCCESS
    }
}

暂时什么都不做,直接返回任务执行完成 Result.SUCCESS

第二步:定义 WorkRequest

MainActivity 中定义 WorkRequest

 val request =OneTimeWorkRequest.Builder(MainWork::class.java)
                 .build()

OneTimeWorkRequest 意味着这个任务只需执行一遍。

第三步:加入任务队列

要让任务执行,需要将 WorkRequest 加入任务队列:

WorkManager.getInstance().enqueue(request)

现在加入任务队列后,任务会马上得到执行。 但需要注意的是,这句代码的作用是将任务加入任务队列,而不是执行任务。因为任务可能需要等到满足环境条件的情况才会执行

2、数据交互

后台任务少不了数据的交互,我们看一下数据是如何传入传出的。

2.1、input

  • 构造 Data对象:Data 的使用和 Bundle 差不多。
 val dateFormat = SimpleDateFormat("hh:mm:ss", Locale.getDefault())
      
// Data 对象       
 val data = Data.Builder() 
             .putString("time",dateFormat.format(Date())) 
             .build()
  • 使用 WorkRequestsetInputData 方法传递 Data
val request = OneTimeWorkRequest.Builder(MainWork::class.java)
                  .setInputData(data) // 传递data
                  .build()
  • 最后,在 Worker 中,从 inputData 可以取到数据:
class MainWork(context: Context, workerParams: WorkerParameters) : Worker(context, workerParams) {
    override fun doWork(): Result {
        // 获取传递的数据,inputdata 其实是 getInputData()
        val time = inputData.getString("time")
        return Result.SUCCESS
    }
}

2.2、output

当任务处理完了,需要将处理结果返回。

  • 构造Data并赋值给 outputData
class MainWork(context: Context, workerParams: WorkerParameters) : Worker(context, workerParams) {
    override fun doWork(): Result {
        val time = inputData.getString("time")

        // 传出
        outputData = Data.Builder()
            .putString("name","Hello Worker!")
            .build()



       return Result.SUCCESS
    }
}
  • 取出 Worker 传递出来的数据

每一个 WorkRequest 都会有一个 id,通过 id 可以获取到对应任务的 WorkStatus,并且是以 LiveData 形式提供的:

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        val dateFormat = SimpleDateFormat("hh:mm:ss", Locale.getDefault())
        val data = Data.Builder().putString("time", dateFormat.format(Date())).build()


        val request =
            OneTimeWorkRequest.Builder(MainWork::class.java)
                .setInputData(data)
                .build()

        WorkManager.getInstance().enqueue(request)

        WorkManager.getInstance()
            // 通过 id
            .getStatusByIdLiveData(request.id)
            .observe(this, Observer {
                if (it != null && it.state.isFinished) {

                    // 取出 outputData
                    val name = it.outputData.getString("name")
                    Log.e("eeee==>>",name)
                }
            })

    }
}

3、取消任务

如果需要取消一个在队列中的任务,也是通过 id 实现的:

WorkManager.getInstance().cancelWorkById(request.id)

四、WorkRequest详解

1、环境约束

WorkManager 允许我们指定任务执行的环境,比如网络已连接、电量充足时等,在满足条件的情况下任务才会执行。

val constraints = Constraints.Builder()  
 .setRequiredNetworkType(NetworkType.CONNECTED) // 网络状态
 .setRequiresBatteryNotLow(true) // 不在电量不足时执行 
 .setRequiresCharging(true) // 在充电时执行 
 .setRequiresStorageNotLow(true) // 不在存储容量不足时执行
 .setRequiresDeviceIdle(true) // 在待机状态下执行,需要 API 23 
 .build() 

val request = OneTimeWorkRequest.
                   Builder(MainWorker::class.java) 
                   .setConstraints(constraints)
                   .build()

网络状态可选值如下:

状态 说明
NOT_REQUIRED 没有要求
CONNECTED 网络连接
UNMETERED 连接无限流量的网络
METERED 连接按流量计费的网络
NOT_ROAMING 连接非漫游网络

举例:

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        val dateFormat = SimpleDateFormat("hh:mm:ss", Locale.getDefault())
        val data = Data.Builder().putString("time", dateFormat.format(Date())).build()

        val constraints =
            Constraints.Builder()
                .setRequiredNetworkType(NetworkType.CONNECTED)
                .build()

        val request =
            OneTimeWorkRequest.Builder(MainWork::class.java)
                // 添加约束条件
                .setConstraints(constraints)
                .setInputData(data)
                .build()

        WorkManager.getInstance().enqueue(request)

        WorkManager.getInstance()
            // 通过 id
            .getStatusByIdLiveData(request.id)
            .observe(this, Observer {
                if (it != null && it.state.isFinished) {
                    val name = it.outputData.getString("name")
                    Log.e("eeee==>>", name)
                }
            })

    }
}

观察,当有网络的时候,才会打印 E/eeee==>>: Hello Worker!

2、直接子类

2.1、OneTimeWorkRequest

任务只需要执行一遍

2.2、PeriodicWorkRequest

可以发起一个多次执行的定时任务。

如:

val request = PeriodicWorkRequest
    .Builder(MainWorker::class.java, 15, TimeUnit.MINUTES)
    .setConstraints(constraints)
    .setInputData(data)
    .build()

这样,发起的任务就会每隔 15 分钟执行一次。

除了需要传入间隔时间,使用起来跟 OneTimeWorkRequest 是没有区别的。

你可能会想更频繁的去执行一个任务,比如几秒钟执行一遍,但很遗憾,最小时间间隔就是 15 分钟,看一下源码就知道了。

还有需要注意的是,定时任务并不是说经过指定时间后它就马上执行,而是经过这一段时间后,等到满足约束条件等情况时,它才执行

五、其它特点

1、强大的生命力

先看代码:

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        val dateFormat = SimpleDateFormat("hh:mm:ss", Locale.getDefault())
        val data = Data.Builder().putString("time", dateFormat.format(Date())).build()

        val constraints =
            Constraints.Builder()
                .setRequiredNetworkType(NetworkType.CONNECTED)
                .build()

        val request =
            OneTimeWorkRequest.Builder(MainWork::class.java)
                // 添加约束条件
                .setConstraints(constraints)
                .setInputData(data)
                .build()

        WorkManager.getInstance().enqueue(request)

        WorkManager.getInstance()
            // 通过 id
            .getStatusByIdLiveData(request.id)
            .observe(this, Observer {
                if (it != null && it.state.isFinished) {
                    val name = it.outputData.getString("name")
                    Log.e("eeee==>>", name)
                }
            })

    }
}

操作步骤: 断网 -> 将进程杀掉 ->联网 ->再次运行

不出意外的话,这时候你会看到有两个时间的打印,而且两个时间还不一样,这是为什么呢?

  • 第一个时间是第一次运行后,加入了任务队列,但还没有执行的任务。
  • 第二个则是本次执行的任务打印的。

这说明了,就算进程被杀掉,任务还是存在,甚至如果重启手机,任务依然会在满足条件的情况下得到执行。

这是 WorkManager 的另一个特点:

一旦发起一个任务,任务是可以保证一定会被执行的,就算退出应用,甚至重启手机都阻止不了他。但可能由于添加了环境约束等原因,它执行的时间是不确定的。

当应用正在运行时,它会在当前的进程中启用一个子线程执行。应用没有运行的情况下启用,它则会自己选择一种合适的方式在后台运行。具体是什么方式和 Android 的版本和依赖环境有关:

2、任务链

WorkManager 允许我们按照一定的顺序执行任务,比如我想 ABC 三个任务按先后顺序执行:

可以这样写,把它们组成一条任务链:

 WorkManager.getInstance()
      .beginWith(workA)
      .then(workB)
      .then(workC)
      .enqueue()

这样的话,上一个任务的 outputData 会成为下一个任务的 inputData

再更复杂一点,我想 AB 同时执行,它们都执行完之后,再执行 C

也是可以实现的:

 WorkManager.getInstance()
    .beginWith(workA,workB)
    .then(workC)
    .enqueue()

再更更复杂一点,如果我想这样:

这样就需要先把 A、B 和 C、D 分别组成一条任务链,再进行联结:

val chain1 = WorkManager.getInstance()
    .beginWith(workA)
    .then(workB)
val chain2 = WorkManager.getInstance()
    .beginWith(workC)
    .then(workD)
val chain3 = WorkContinuation
    .combine(chain1, chain2)
    .then(workE)
chain3.enqueue()

再更更更复杂一点,如果我把定时任务放进去会怎样? 不好意思,链式任务只支持 OneTimeWorkRequest

使用任务链,我们可以将各种任务进行模块化。同样的,任务链不保证每个任务执行的时间,但是保证它们执行的先后顺序

任务唯一性

很多情况下,我们希望在任务队列里,同一个任务只存在一个,避免任务的重复执行,这时候可以用到 beginUniqueWork 这个方法:

WorkManager.getInstance()
   .beginUniqueWork("unique", ExistingWorkPolicy.REPLACE, request)
   .enqueue()

需要传入一个任务的标签,和重复任务的执行方式,可取值如下:

状态 说明
REPLACE 删除已有的任务,添加现有的任务
KEEP 什么都不做,不添加新任务,让已有的继续执行
APPEND 加入已有任务的任务链最末端。追加,旧任务执行之后再执行新的任务。

但这种方式也是只支持 OneTimeWorkRequest。如果是 PeriodicWorkRequest,我想到的办法是每次执行之前,根据标签去取消已有的任务。

展开阅读全文
打赏
0
0 收藏
分享
加载中
更多评论
打赏
0 评论
0 收藏
0
分享
返回顶部
顶部