第十章：WorkManager任务使用

• 引入

    //workmanager
    api 'androidx.work:work-runtime:2.3.4'

• 创建工作处理器

public class UploadFileWorker extends Worker {
    public UploadFileWorker(@NonNull Context context, @NonNull WorkerParameters workerParams) {
        super(context, workerParams);
    }

    String restUrl;

    @NonNull
    @Override
    public Result doWork() {
        //当前为子线程
        Data inputData = getInputData();
        String file = inputData.getString("file");

        Log.e("TTT", "file============" + file);

        Map<String, Object> map = new ArrayMap<>();
        map.put("searchContent", "");
        map.put("size", 15);
        map.put("current", 1);
        PagingHttpClient.getInstance()
                .get("home/paintingList", map, new PagingHttpCallback<Teacher>() {
                    @Override
                    protected void onNext(Teacher data) {
                        restUrl = data.toString();
                        Log.e("TTT", "restUrl============" + restUrl);
                    }

                    @Override
                    protected void onFail(int code, String message) {
                        restUrl = message;
                    }
                });
        if (TextUtils.isEmpty(restUrl)) {
            return Result.failure();
        } else {
            Data outputData = new Data.Builder().putString("fileUrl", restUrl).build();
            return Result.success(outputData);
        }
    }
}

• 调用

public class WorkManagerActivity extends AppCompatActivity {

    private UUID mId1;
    private UUID mId2;

    private String fileUrl1;
    private String fileUrl2;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_work_manager);
    }

    /**
     * WorkerManager使用
     * 

     * PeriodicWorkRequest可以周期性的执行任务，OneTimeWorkRequest执行一次
     *
     * @param view
     */
    @SuppressLint("RestrictedApi")
    public void onWorkManagerStartClick(View view) {

        List<OneTimeWorkRequest> workRequests = new ArrayList<>();


        OneTimeWorkRequest request1 = getOneTimeWorkRequest("我是任务1");
        mId1 = request1.getId();
        workRequests.add(request1);


        OneTimeWorkRequest request2 = getOneTimeWorkRequest("我是任务2");
        mId2 = request2.getId();
        workRequests.add(request2);

        WorkContinuation workContinuation = WorkManager.getInstance(this).beginWith(workRequests);
        workContinuation.enqueue();
        /**
         * 接收回调
         */
//        WorkManager.getInstance(this).getWorkInfoByIdLiveData(mId1)
        workContinuation.getWorkInfosLiveData().observe(this, new Observer<List<WorkInfo>>() {
            @Override
            public void onChanged(List<WorkInfo> workInfos) {
                //block runing enuqued failed susscess finish
                int completedCount = 0;
                for (WorkInfo workInfo : workInfos) {
                    WorkInfo.State state = workInfo.getState();
                    UUID id = workInfo.getId();
                    if (state == WorkInfo.State.FAILED) {
                        if (id.equals(mId1)) {
                            Toast.makeText(AppGlobals.getApplication(), "任务1失败", Toast.LENGTH_LONG).show();
                        } else if (id.equals(mId2)) {
                            Toast.makeText(AppGlobals.getApplication(), "任务2失败", Toast.LENGTH_LONG).show();
                        }
                    } else if (state == WorkInfo.State.SUCCEEDED) {
                        Data outputData = workInfo.getOutputData();
                        String fileUrl = outputData.getString("fileUrl");
                        Log.e("TTT", fileUrl);
                        if (id.equals(mId1)) {
                            fileUrl1 = fileUrl;
                        } else if (id.equals(mId2)) {
                            fileUrl2 = fileUrl;
                        }
                        completedCount++;
                    }
                }
                if (completedCount >= workInfos.size()) {
                    Toast.makeText(AppGlobals.getApplication(), "任务完成了，可以干其他的活了", Toast.LENGTH_LONG).show();
                }
            }
        });

    }

    /**
     * WorkerManager使用
     * 

     * PeriodicWorkRequest可以周期性的执行任务，OneTimeWorkRequest执行一次
     * 一般处理像闹钟一样的任务
     *
     * @param view
     */
    public void onPeriodicWorkManagerStartClick(View view) {

        PeriodicWorkRequest request = getPeriodicWorkRequest("我是定时任务");
        mId1 = request.getId();
        WorkManager.getInstance(this).enqueue(request);
    }

    @SuppressLint("RestrictedApi")
    private OneTimeWorkRequest getOneTimeWorkRequest(String filePath) {
        //Data本质是HashMap 但是大小为10kb，这也说明了，只能传递基本数据类型和Array集合
        Data inputData = new Data.Builder()
                .putString("file", filePath)
                .build();

        Constraints constraints = new Constraints();
        //设备存储空间充足的时候 才能执行 ,>15%
        constraints.setRequiresStorageNotLow(true);
        //必须在执行的网络条件下才能好执行,不计流量 ,wifi
        constraints.setRequiredNetworkType(NetworkType.UNMETERED);
        //设备的充电量充足的才能执行 >15%
        constraints.setRequiresBatteryNotLow(true);
        //只有设备在充电的情况下 才能允许执行
        constraints.setRequiresCharging(true);
        //只有设备在空闲的情况下才能被执行 比如息屏，cpu利用率不高
        constraints.setRequiresDeviceIdle(true);
        //workmanager利用contentObserver监控传递进来的这个uri对应的内容是否发生变化,当且仅当它发生变化了
        //我们的任务才会被触发执行，以下三个api是关联的
        constraints.setContentUriTriggers(null);
        //设置从content变化到被执行中间的延迟时间，如果在这期间。content发生了变化，延迟时间会被重新计算
        //这个content就是指 我们设置的setContentUriTriggers uri对应的内容
        constraints.setTriggerContentUpdateDelay(0);
        //设置从content变化到被执行中间的最大延迟时间
        //这个content就是指 我们设置的setContentUriTriggers uri对应的内容
        constraints.setTriggerMaxContentDelay(0);


        OneTimeWorkRequest request = new OneTimeWorkRequest
                .Builder(UploadFileWorker.class)
                .setInputData(inputData)
//                .setConstraints(constraints)
                //设置一个拦截器，在任务执行之前 可以做一次拦截，去修改入参的数据然后返回新的数据交由worker使用
//                .setInputMerger(null)
                //当一个任务被调度失败后，所要采取的重试策略，可以通过BackoffPolicy来执行具体的策略
                //BackoffPolicy.EXPONENTIAL：指数级增长，BackoffPolicy.LINEAR:线性增长
//                .setBackoffCriteria(BackoffPolicy.EXPONENTIAL, 10, TimeUnit.SECONDS)
                //任务被调度执行的延迟时间
//                .setInitialDelay(10, TimeUnit.SECONDS)
                //设置该任务尝试执行的最大次数
//                .setInitialRunAttemptCount(2)
                //设置这个任务开始执行的时间
                //System.currentTimeMillis()
//                .setPeriodStartTime(0, TimeUnit.SECONDS)
                //指定该任务被调度的时间
//                .setScheduleRequestedAt(0, TimeUnit.SECONDS)
                //当一个任务执行状态编程finish时，又没有后续的观察者来消费这个结果，难么workamnager会在
                //内存中保留一段时间的该任务的结果。超过这个时间，这个结果就会被存储到数据库中
                //下次想要查询该任务的结果时，会触发workmanager的数据库查询操作，可以通过uuid来查询任务的状态
//                .keepResultsForAtLeast(10, TimeUnit.SECONDS)
                .build();
        return request;
    }

    @SuppressLint("RestrictedApi")
    private PeriodicWorkRequest getPeriodicWorkRequest(String filePath) {
        //Data本质是HashMap 但是大小为10kb，这也说明了，只能传递基本数据类型和Array集合
        Data inputData = new Data.Builder()
                .putString("file", filePath)
                .build();

        /**
         * PeriodicWorkRequest可以周期性的执行任务，OneTimeWorkRequest执行一次
         * repeatInterval 必须大于或等于 MIN_PERIODIC_INTERVAL_MILLIS = 15 * 60 * 1000L; // 15 minutes.
         */
        PeriodicWorkRequest build = new PeriodicWorkRequest
                .Builder(UploadFileWorker.class, 15, TimeUnit.MINUTES)
                .setInputData(inputData)
                .build();

        return build;
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        WorkManager.getInstance(this).cancelAllWork();
//        WorkManager.getInstance(this).cancelWorkById(mId1);
//        WorkManager.getInstance(this).cancelWorkById(mId2);
    }


}

demo地址：https://gitee.com/huangxiaoguo/jetpackandrxjava