Jetpack-WorkManager

今天我们来讲以下google推荐我们使用jetpack进行后台任务处理的组件：workManager。
参考：
https://mp.weixin.qq.com/s/OorUNDO3GVHATJrZOijh_A

workmanager是什么？

我们在开头就说了，workManager是一个可以用来进行后台任务的组件。我们都知道通常在android中进行后台任务我们都用service,既然已经有了service,那为什么还要出一个workManager呢？因为workManager比service强大太多，它可以在应用程序退出或者其他原因中止后，依然执行(本地任务如:本地图片的读取展示)或者应用程序打开后继续执行任务(网络请求)。
也就是说workmanager适用于:我一定要求至少执行一次的功能,不会因为程序终止，我这次任务就无法执行了。

workmanager与其他后台任务方式

除了serverice可以执行后台任务，还有alarmManager,jobScheduler及firebase的jobDispatcher,那么workManager与它们是什么关系呢？
我用一张图片说明以下:

调用流程

看懂上面图片的意思了吧,翻译一下就是workManager发起一个任务，如果当前程序正在运行，它就会再开一个工作线程去处理，如果当前程序退出或者在后台，它就会选择一个合适的方案去执行，这就包括了alarmManager；jobScheduler；jobDispatcher。

workmanager相关类

• worker
  一个抽象类，需要继承worker并重写doWork()方法来进行具体的逻辑代码。

• workRequest
  抽象类，有两个具体的子类:oneTimeWorkRequest和periodicWorkRequest,
  一个来执行单次任务，一个来执行周期任务。可以设置worker的执行顺序或者运行环境等。
  periodicWorkRequest最低的时间间隔是15分钟执行一次。

• workManager
  管理workRequest的队列，全局唯一。

• workStatus
  包含任务的状态和信息，以LiveData的形式提供给观察者。

• data
  在worker中用来存储数据，建造者模式，通过builder()来设置值，键值对存储。

• constraints
  指定任务运行的环境(触发条件)，比如：在待机状态下执行或在充电状态下执行，所以你的worker只有符合上述条件才能触发运行。所以这也是一种优化，可以为用户节约电量。

workmanager的代码实现

先添加依赖:

    implementation 'android.arch.work:work-runtime:1.0.1'
    implementation 'android.arch.work:work-firebase:1.0.0-alpha11'

创建自己的worker来执行具体的逻辑,比如：网络请求

class RequestWorker (context: Context, workerParams: WorkerParameters) :
    Worker(context, workerParams) {

    override fun doWork(): Result {
        //获取OneTimeWorkManager设置的数据(是否进行网络请求)
      val isRequest = this.inputData.getBoolean("isRequest",false)
        var responseString = "网络请求失败"
        lateinit var outputData : Data
        if (isRequest){
            System.out.println("睡眠之前-------------"+Thread.currentThread())
          //担心网络请求响应过快,所以先睡会在请求
            Thread.sleep(5000)
            System.out.println("睡眠后请求-------------"+Thread.currentThread())
            //创建协程作用域执行网络请求，runBlocking会阻塞当前线程直到结果完成
            runBlocking {
                responseString =  retrofitRequest()
                //responseString+"${System.currentTimeMillis()}"
                outputData = Data.Builder().putString("data",responseString).build()
            }
            return Result.success(outputData)
        }
        outputData = Data.Builder().putString("data",responseString).build()
        return Result.failure(outputData)
    }

    /**
     * Retrofit执行网络请求
     */
    private  suspend fun retrofitRequest() : String {
        val retrofit = Retrofit.Builder().baseUrl(MainActivity.baseUrl)
            .build()
        var apiService =  retrofit.create(ApiService ::class.java)

        val requestData : Response<ResponseBody> =apiService.requestApi()
        val jsonString = String((requestData.body())?.bytes()!!)
        return  jsonString
    }
}

网络请求用的是kotlin中的协程，api接口是网络上随便找的。
mainActivity中的代码：

class MainActivity : AppCompatActivity() {

    companion object{
        const  val baseUrl = "http://qqlykm.cn/"
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        doWork.setOnClickListener {
            doWork()
            show(this,showContent)
        }
        cancelWork.setOnClickListener {
            cancelWork()
        }
        //再次进入直接根据id获取之前成功的内容
        show(this,showContent)
    }

    /**
     * 执行任务
     */
    fun doWork(){
        //创建单工作请求对象:OneTimeWorkRequest
        val worker =  OneTimeWorkRequest.Builder(RequestWorker :: class.java)
                //设置允许进行网络请求的标识
            .setInputData(Data.Builder().putBoolean("isRequest",true).build())
            .setConstraints(myConstraints)
                .build()
        //WorkManager执行任务
        WorkManager.getInstance().enqueue(worker)
        //用sharePreference保存任务ID
        val adRequestId = worker.id
        var arid by Preference("requestId", "")
        arid = adRequestId.toString()
    }

    /**
     * 任务取消
     */
    fun cancelWork(){
        //获取用sharePreference保存的任务ID
        var arid by Preference("requestId", "")
        if (!arid.equals("")) {
            val uuid = UUID.fromString(arid)
            WorkManager.getInstance().cancelWorkById(uuid)
        }
    }

    /**
     * 根据id,展示网络请求到的内容
     */
    fun show(owner: LifecycleOwner, view: TextView) {
        var arid by Preference("requestId", "")
        if (!arid.equals("")) {
            val uuid = UUID.fromString(arid)
            //livedata实时监听任务状态
            WorkManager.getInstance().getWorkInfoByIdLiveData(uuid)
                .observe(owner, Observer {
                    if (it.state == WorkInfo.State.SUCCEEDED) {
                        val adResult = it.outputData.getString("data")
                        view.text = adResult
                    }
                })
        }
    }
    //这是约束条件
    @RequiresApi(Build.VERSION_CODES.M)
    val myConstraints = Constraints.Builder()
        //网络连接时执行
        .setRequiredNetworkType(NetworkType.CONNECTED)
        // 在待机状态下执行，需要 API 23
        //.setRequiresDeviceIdle(true)
        // 在充电时执行
       .setRequiresCharging(true)
        .build()
}

注:中途退出，再次进入，work会继续执行，但是可以所需时间较久
其余部分的代码就不展示了，文末会给出github的链接。

链式调用

   val mutable = mutableListOf<OneTimeWorkRequest>(workerA1,workerA2,workerA3)
   val mutableC = mutableListOf<OneTimeWorkRequest>(workerC1,workerC2)
WorkManager.getInstance().beginWith(mutable).then(workerB).then(mutableC).enqueue()

workManager还可以链式调用，比如上面的写法。上面的意思是

链式调用

链式调用的方式有多种，可以让多个任务按顺序执行，也可以多个任务并行，上个任务的数据可以传递到下一个任务里等，这里就不具体展开说了。

WorkContinuation

这个WorkContinuation就比较复杂一点了，这里也不说了，想了解的小伙伴，推荐看官方实例。
本Demo地址