Android Jetpack架构组件之WorkManager入门

时间 2020-03-06

标签 android jetpack 架构组件 workmanager 入门栏目 Android 繁體版

原文原文链接

——你能够失望，但不能绝望。累的时候能够慢一点，千万不要后退，你尚未拼劲全力。怎么知道没有奇迹。android

前言

——最近抽空又学了一个Jetpack组件 —— WorkManager，因为工做繁忙，要学的东西还有不少，任务重，时间紧。虽然只学到了点皮毛，可是仍是要花点时间作个总结。由于人们常说：学而不思则罔，思而不学则殆。不思不学则网贷。因此要想致富，好的学习方法是必要的。也跟你们分享一下所学的知识。少走的点弯路。数据库

1、简介

（1）是什么

—— WorkManager是Android Jetpack 中管理后台任务的组件。
—— 常见的使用场景：1.向后端服务发送日志或分析数据 2.按期将应用数据与服务器同步后端

（2）有什么用

—— 使用 WorkManager API 能够轻松地调度后台任务。可延迟运行（即不须要当即运行）而且在应用退出（进程未关闭）或应用重启时可以可靠运行的任务。数组

（3）有什么优势

1.兼容JobScheduler与BroadcastReceiver 和 AlarmManager
2.工做约束知足多种状况
3.可以使用一次性或周期性执行的任务
4.监控和管理计划任务
5.提供API将任务连接起来
6.遵循低电耗模式等省电功能

2、基本使用

（1）添加依赖bash

implementation android.arch.work:work-runtime:1.0.1复制代码

（2）建立后台任务（自定义类继承 Worker 并重写doWork()）服务器

public static class MyWorker extends Worker {

    public MyWorker(@NonNull Context context, @NonNull WorkerParameters params) {
        super(context, params);
    }

    @Override
    public Result doWork() {
        return Result.success();//返回成功
//      return Result.failure();//返回失败
//      return Result.retry();//重试
    }
}复制代码

（3）建立请求架构

// 对于一次性 WorkRequest，请使用 OneTimeWorkRequest，对于周期性工做，请使用 PeriodicWorkRequest.
// 构建一次性请求
// OneTimeWorkRequest request = new OneTimeWorkRequest.Builder(MyWorker.class).build();
// 构建周期性请求
// PeriodicWorkRequest request = new PeriodicWorkRequest.Builder(MyWorker.class,1, TimeUnit.HOURS).build();复制代码

（4）执行请求（若是没有设置约束条件则会当即执行）app

WorkManager.getInstance().enqueue(request);复制代码

（5）取消和中止工做dom

WorkManager.getInstance().cancelWorkById(request.getId());复制代码

总结：1.建立任务——2.配置请求——3.执行请求ide

3、进阶

（1）进阶1：构建约束条件：

Uri uri = Uri.parse("xxxxx");
Constraints constraints = new Constraints.Builder()
        .setRequiredNetworkType(NetworkType.CONNECTED) //指定须要在有网的状况下
        .setRequiresBatteryNotLow(true)//指定电量在可接受范围内运行
        .setRequiresStorageNotLow(true)//指定在存储量在可接受范围内运行
        .addContentUriTrigger(uri,true)//当Uri发生变化的时候运行
        .setRequiresDeviceIdle(true)//当设备处于空闲状态时运行
        .setRequiresCharging(true)//当设备处于充电状态时运行
        .build();
//在请求
OneTimeWorkRequest request = new OneTimeWorkRequest.Builder(MyWorker.class)
                .setConstraints(constraints)//添加约束
				.build();
//当知足约束条件后才会执行该任务
WorkManager.getInstance().enqueue(request);复制代码

（2）进阶2：延迟执行

OneTimeWorkRequest request = new OneTimeWorkRequest.Builder(MyWorker.class)
				.setInitialDelay(1,TimeUnit.HOURS)//延迟1小时执行
				.build();复制代码

（3）进阶3：设置回退/重试的策略当doWork()返回 Result.retry()时启用指定重试间隔时长

OneTimeWorkRequest request = new OneTimeWorkRequest.Builder(MyWorker.class)
				//第一个参数：设置策略模式。
				//第二个参数：设置第一次重试时长
				//第三个参数：设置时间单位
                .setBackoffCriteria(BackoffPolicy.LINEAR,
                        OneTimeWorkRequest.MIN_BACKOFF_MILLIS,
                        TimeUnit.MILLISECONDS)
                .build();复制代码

（4）进阶4:传入参数/标记请求任务

Data imageData = new Data.Builder()
        .putString(DateKey, "开始执行")
        .build();
OneTimeWorkRequest request = new OneTimeWorkRequest.Builder(MyWorker.class)
				//传入参数
                .setInputData(imageData)
                .build();
@Override
public Result doWork() {
	//获取传入的参数
    String data = getInputData().getString(DateKey);
    LogUtils.e("data："+data);
    //建立输出结果
    Data outputData = new Data.Builder()
            .putString(DateKey,"已经开始充电")
            .build();
    return Result.success(outputData);
}复制代码

（5）进阶5:标记请求任务

OneTimeWorkRequest request = new OneTimeWorkRequest.Builder(MyWorker.class)
				.addTag(TAG)
                .build();
				//取消使用特定标记的全部任务
//        WorkManager.getInstance().cancelAllWorkByTag(TAG);
//会返回 LiveData 和具备该标记的全部任务的状态列表
//        WorkManager.getInstance().getWorkInfosByTagLiveData(TAG); 复制代码

（6）进阶6:监听工做状态

WorkManager.getInstance().getWorkInfoByIdLiveData(request1.getId())
                .observe(this, new Observer<WorkInfo>() {
                    @Override
                    public void onChanged(@Nullable WorkInfo workInfo) {
                        if (workInfo != null && (workInfo.getState() == WorkInfo.State.SUCCEEDED)){
                            //获取成功返回的结果
                            tvText.setText(workInfo.getOutputData().getString(DateKey));
                        }
                    }
                });复制代码

（7）进阶7:连接工做：用于指定多个关联任务并定义这些任务的运行顺序（能够执行多个任务）

OneTimeWorkRequest request = new OneTimeWorkRequest.Builder(MyWorker.class).build();
OneTimeWorkRequest request1 = new OneTimeWorkRequest.Builder(MyWorker.class).build();
OneTimeWorkRequest request2 = new OneTimeWorkRequest.Builder(MyWorker.class).build();
OneTimeWorkRequest request3 = new OneTimeWorkRequest.Builder(MyWorker.class).setInputMerger(OverwritingInputMerger.class).build();
OneTimeWorkRequest request4 = new OneTimeWorkRequest.Builder(MyWorker.class).build();
//        为了管理来自多个父级 OneTimeWorkRequest 的输入，WorkManager 使用 InputMerger。
//        WorkManager 提供两种不一样类型的 InputMerger：
//        OverwritingInputMerger 会尝试将全部输入中的全部键添加到输出中。若是发生冲突，它会覆盖先前设置的键。
//        ArrayCreatingInputMerger 会尝试合并输入，并在必要时建立数组。

WorkManager.getInstance()
		//使用beginWith()能够并行执行request、request一、request2 
        .beginWith(Arrays.asList(request, request1, request2)).
		//使用then()能够按顺序执行任务
        .then(request3)//在执行request3
        .then(request4)//在执行request4
        .enqueue();复制代码

4、源码分析

大致流程：
1.初始化时建立了WorkManager任务执行器管理线程：里面建立了一个单线程池管理后台任务与拿到主线程的handle执行UI更新
2.在Worker封装了一个线程，经过继承方式把咱们的后台任务交给该线程
3.使用WorkRequest配置该任务线程的执行条件
4.最终将WorkManager与WorkRequest绑定在一块儿。实际是把任务线程及配置信息交给WorkManager处理。
5.也就是调用了WorkManager任务执行器来运行线程与更新UI。

@ 基于依赖implementation android.arch.work:work-runtime:1.0.1 源码分析

（1）组件的初始化

WorkManager的初始化在ContentProvider中，不须要手动添加。WorkManager是一个抽象类，它的大部分方法都是交给他的子类WorkManagerImpl实现的。

/**
* @Function workManager初始化
*/
public class WorkManagerInitializer extends ContentProvider {
    @Override
    public boolean onCreate() {
        // Initialize WorkManager with the default configuration.
        WorkManager.initialize(getContext(), new Configuration.Builder().build());
        return true;
    }
......
}

/**
* @Function WorkManager.initialize()最终使用单例模式建立WorkManagerImpl对象。
*/
public static void initialize(@NonNull Context context, @NonNull Configuration configuration) {
    WorkManagerImpl.initialize(context, configuration);
}

@RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
public static void initialize(@NonNull Context context, @NonNull Configuration configuration) {
    synchronized (sLock) {
        ...
        if (sDelegatedInstance == null) {
            context = context.getApplicationContext();
            if (sDefaultInstance == null) {
		//建立了WorkManagerImpl
                sDefaultInstance = new WorkManagerImpl(
                        context,
                        configuration,
			//建立了WorkManagerTaskExecutor
                        new WorkManagerTaskExecutor());
            }
            sDelegatedInstance = sDefaultInstance;
        }
    }
}复制代码

核心类：WorkManagerTaskExecutor ：主要是管理后台线程与UI线程的执行。复制代码

//经过该类 咱们能够执行UI线程上的任务与后台任务
@RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
public class WorkManagerTaskExecutor implements TaskExecutor {
    
    //获取达到UI线程的handler 
    private final Handler mMainThreadHandler = new Handler(Looper.getMainLooper());
    //建立一个Executor 绑定到UI线程上 再经过调用该Executor能够在UI线程上进行操做
    private final Executor mMainThreadExecutor = new Executor() {
        @Override
        public void execute(@NonNull Runnable command) {
            postToMainThread(command);
        }
    };

    @Override
    public void postToMainThread(Runnable r) {
        mMainThreadHandler.post(r);
    }
    ...

    //建立了一个单线程池 管理workManager的后台线程
    private final ExecutorService mBackgroundExecutor =
            Executors.newSingleThreadExecutor(mBackgroundThreadFactory);

    ... //省略部分调用方法
}复制代码

接下去咱们看下核心类：WorkManagerImpl

//按照执行顺序，咱们先看下它的构造函数 作了哪些准备工做。
   public WorkManagerImpl(
            @NonNull Context context,
            @NonNull Configuration configuration,
            @NonNull TaskExecutor workTaskExecutor,
            boolean useTestDatabase) {

        Context applicationContext = context.getApplicationContext();
        // 建立了一个room 数据库用于保存 任务线程的配置信息
        WorkDatabase database = WorkDatabase.create(applicationContext, useTestDatabase);
        Logger.setLogger(new Logger.LogcatLogger(configuration.getMinimumLoggingLevel()));
        // 建立Scheduler根据返回一个List<Scheduler>, 
        //里面包含两个Scheduler:GreedyScheduler，SystemJobScheduler/SystemAlarmScheduler
        List<Scheduler> schedulers = createSchedulers(applicationContext);
        //建Processor，Scheduler最后都调用Processor.startWork()去执行Worker中的逻辑,也就是咱们重写的doWork()。
        Processor processor = new Processor(
                context,
                configuration,
                workTaskExecutor,
                database,
                schedulers);
        //启动APP时检查APP是以前否强制中止退出或有未执行完的任务，是的话重启WorkManager，保证任务能够继续执行。
        internalInit(context, configuration, workTaskExecutor, database, schedulers, processor);
    }复制代码

因为源码太多这里就不一一摘录了，小弟不才，文采有限。写不出通俗易懂的句子。你们将就看看大致过程就好。初始化阶段就介绍到这里。

回顾一下初始化过程：

1.首先建立了WorkManagerImpl类，并持有WorkManagerTaskExecutor类，该类是后台线程与UI线程的主要执行者。

2.在WorkManagerImpl构造方法中建立了数据库保存任务线程的信息，主要用于App重启时保证任务能够继续执行。

3.又建立了Schedulers，用来知足不一样条件的状况下执行特定的任务。

4.启动APP时从数据库中获取任务列表判断是否由未执行的任务，并启动。保证在知足条件的状况下能够继续执行。

分析到了这里。咱们就回发现这里还缺乏一个主要的组成部分。那就是咱们的任务。如何把咱们的后台任务交给workManager处理呢。这就是咱们须要收到操做的部分。也就是咱们使用WorkManger的过程。

（2）建立后台任务：Worker

//这是一个抽象类，因此须要自定义一个类来继承该类并重写 doWork()方法来编写后台任务
public abstract class Worker extends ListenableWorker {
    ...
    //从该方法中能够看出dowork()在一个线程中执行。getBackgroundExecutor()则是调用了单线程池来管理该线程。
    @Override
    public final @NonNull ListenableFuture<Result> startWork() {
        mFuture = SettableFuture.create();
        getBackgroundExecutor().execute(new Runnable() {
            @Override
            public void run() {
                try {
                    Result result = doWork();
                    mFuture.set(result);
                } catch (Throwable throwable) {
                    mFuture.setException(throwable);
                }

            }
        });
        return mFuture;
    }
}复制代码

（3）配置后台任务的执行条件：WorkRequest

——WorkRequest配置后台任务的执行条件，该类是一个抽象类，有WorkManager有两种具体的实现OneTimeWorkRequest/PeriodicWorkRequest。

new OneTimeWorkRequest.Builder(MyWorker.class)
                .setConstraints(constraints)//添加约束
                .setInitialDelay(1,TimeUnit.HOURS)//进阶2：延迟执行
                .setBackoffCriteria(BackoffPolicy.LINEAR,
                        OneTimeWorkRequest.MIN_BACKOFF_MILLIS,
                        TimeUnit.MILLISECONDS)//进阶3：退避政策：当doWork()返回 Result.retry()时 启用
                .setInputData(imageData)//进阶4:传入参数
                .addTag(TAG)//进阶4:标记请求任务
                .build();

//建立了配置信息类WorkSpec ，将执行条件和参数都保存到WorkSpec中
public abstract static class Builder<B extends Builder, W extends WorkRequest> {
   ...
		
   Builder(@NonNull Class<? extends ListenableWorker> workerClass) {
         mId = UUID.randomUUID();
         mWorkSpec = new WorkSpec(mId.toString(), workerClass.getName());
         addTag(workerClass.getName());
   }

   public final @NonNull B setBackoffCriteria(
            @NonNull BackoffPolicy backoffPolicy,
            long backoffDelay,
            @NonNull TimeUnit timeUnit) {
        mBackoffCriteriaSet = true;
        mWorkSpec.backoffPolicy = backoffPolicy;
        mWorkSpec.setBackoffDelayDuration(timeUnit.toMillis(backoffDelay));
        return getThis();
    }
	...
    public final @NonNull B setConstraints(@NonNull Constraints constraints) {
          mWorkSpec.constraints = constraints;
          return getThis();
    }
	...
}复制代码

（4）执行任务

// WorkManager.getInstance().enqueue(request1)

    @Override
    @NonNull
    public Operation enqueue(
            @NonNull List<? extends WorkRequest> workRequests) {
        ...
        return new WorkContinuationImpl(this, workRequests).enqueue();
    }

    @Override
    public @NonNull Operation enqueue() {
        if (!mEnqueued) {
            //调用单线程池执行EnqueueRunnable   后面详细分析下EnqueueRunnable
            EnqueueRunnable runnable = new EnqueueRunnable(this);
            mWorkManagerImpl.getWorkTaskExecutor().executeOnBackgroundThread(runnable);
            mOperation = runnable.getOperation();
        } else {
            Logger.get().warning(TAG,
                    String.format("Already enqueued work ids (%s)", TextUtils.join(", ", mIds)));
        }
        return mOperation;
    }复制代码

//该线程会执行run()方法 并执行两个重要的方法addToDatabase(), scheduleWorkInBackground();
 public class EnqueueRunnable implements Runnable {
     ...

    @Override
    public void run() {
        try {
            if (mWorkContinuation.hasCycles()) {
                throw new IllegalStateException(
                        String.format("WorkContinuation has cycles (%s)", mWorkContinuation));
            }
            //将后台任务及配置信息存到数据库 并返回是否须要执行任务
            boolean needsScheduling = addToDatabase();
            if (needsScheduling) {
                // Enable RescheduleReceiver, only when there are Worker's that need scheduling. final Context context = mWorkContinuation.getWorkManagerImpl().getApplicationContext(); PackageManagerHelper.setComponentEnabled(context, RescheduleReceiver.class, true); scheduleWorkInBackground(); } mOperation.setState(Operation.SUCCESS); } catch (Throwable exception) { mOperation.setState(new Operation.State.FAILURE(exception)); } } //最后会启用 初始化时建立的GreedyScheduler，SystemJobScheduler/SystemAlarmScheduler等调度类来执行工做. @VisibleForTesting public void scheduleWorkInBackground() { WorkManagerImpl workManager = mWorkContinuation.getWorkManagerImpl(); Schedulers.schedule( workManager.getConfiguration(), workManager.getWorkDatabase(), workManager.getSchedulers()); }复制代码

更详细的代码就不贴了，你们要是脑补不了。在按流程仔细看一遍源码会了解的更深。

本想画个图加深一下印象，结果发现是个手残党，对不住你们。

5、内容推荐

若您发现文章中存在错误或不足的地方，但愿您能指出！