jectpack系列之WorkManager

目录

0.WM介绍
1.实现原理
2.使用方式
3.自我思考

WorkManager介绍

背景

安卓开发应该都听过保活，不过随着安卓系统不同版本对电量的优化，对于之前的保活策略基本都不可用了，比如之前的1像素、粘性服务、服务销毁时启动、多个进程互相拉活、监听广播、设置前台服务优先级等。现在比较靠谱的方案：厂商白名单（比如我们现在的APP，微信） 或者是通过修改zygote底层实现，比如鹅厂的某APP启动了大概4个组，每组两个进程，两两互相拉起。

官方在安卓12推出的加急作业 通过 setExpedited()来修饰workmanager

image.png

WorkManager简介

作用

1.确保重要的后台任务，一定会被执行，后台任务（上传，下载，同步数据 等）
2.内部对电量进行了优化，可以管理后台任务,通常是是可延迟的后台任务
3.WorkManager不能做保活操作
4.一个小细节，如果你设置执行时间小于15分钟，会被推迟到15分钟才会下次调度

按官方介绍：WorkManager会选择一种合适的方式来安排后台任务 - 具体取决于设备API级别和包
含的依赖项，WorkManager可能会使用 JobScheduler，Firebase JobDispatcher或
AlarmManager

1.使用方式

角色介绍：
官方文档：https://developer.android.com/about/versions/12/foreground-services?hl=zh-cn
1.Worker：需要执行的具体任务，
2.WorkRequest：可以这样理解，执行一项单一的任务，执行会有具体ID，可以通过ID取消

1.初始化

WorkManager.getInstance(this) // 各种初始化的工作

2.加入队列

.enqueue(oneTimeWorkRequest2); // 加入队列，触发后台任务工作

3.约束条件执行

我们可以执行该任务执行的时机。如下满足网络连接上，并且不在低电量状态。

   // 约束条件
        Constraints constraints = new Constraints.Builder()
                .setRequiredNetworkType(NetworkType.CONNECTED) // 约束条件，必须是网络连接
                .setRequiresBatteryNotLow(true)
                .build();

        // 构建Request
        OneTimeWorkRequest request = new OneTimeWorkRequest.Builder(MainWorker7.class)
                .setConstraints(constraints)
                .build();

        // 加入队列
        WorkManager.getInstance(this).enqueue(request);

2.执行具体任务如下

public class MainWorker extends Worker {

    public final static String TAG = MainWorker.class.getSimpleName();


    private Context mContext;
    private WorkerParameters workerParams;

    // 有构造函数
    public MainWorker(@NonNull Context context, @NonNull WorkerParameters workerParams) {
        super(context, workerParams);
        this.mContext = context;
        this.workerParams = workerParams;
    }

    @SuppressLint("RestrictedApi")
    @NonNull
    @Override
    public Result doWork() {
        Log.d(TAG, "MainWorker7 doWork: 后台任务执行了 started");
        //TODO
        try {
            Thread.sleep(8000);
        } catch (InterruptedException e) {
            e.printStackTrace();
            return Result.failure();  //执行任务失败
        }


        return new Result.Success(); // 本地执行 doWork 任务时 成功 执行任务完毕
    }


}

3.验证是否如官方说的 杀进程关机后重启也能执行

我们可以构造一个约束条件，只有在有网情况下执行，比如点击某个按钮，执行workmanager，在dowork中去创建一个名字叫测试的文件
我们先断开网络，点击，去查看是否生成，发现并没有生成。杀进程、关机后，恢复网络。进入APP，啥都不要做。再去查看，居然生成了文件。
你应该能想到他是怎么实现的，肯定是存储了，绝对不是存在内存的！！

源码分析

1.WorkManager.getInstance(this)

单例初始化了一个WorkManagerImpl对象，有个细节，这里我们调用不会走到if里面的逻辑，因为workmanager组件，也使用了contentprovider实现初始化

public static @NonNull WorkManagerImpl getInstance(@NonNull Context context) {
        synchronized (sLock) {
            WorkManagerImpl instance = getInstance();
            if (instance == null) {
                Context appContext = context.getApplicationContext();
                if (appContext instanceof Configuration.Provider) {
                    initialize(
                            appContext,
                            ((Configuration.Provider) appContext).getWorkManagerConfiguration());
                    instance = getInstance(appContext);
                } else {
                    throw new IllegalStateException("WorkManager is not initialized properly.  You "
                            + "have explicitly disabled WorkManagerInitializer in your manifest, "
                            + "have not manually called WorkManager#initialize at this point, and "
                            + "your Application does not implement Configuration.Provider.");
                }
            }

            return instance;
        }
    }

也就是在他的provider中，就会执行以下代码

 public boolean onCreate() {
        // Initialize WorkManager with the default configuration.
        WorkManager.initialize(getContext(), new Configuration.Builder().build());
        return true;
    }

image.png

2.workmanageImpl构造方法

    public WorkManagerImpl(
            @NonNull Context context,
            @NonNull Configuration configuration,
            @NonNull TaskExecutor workTaskExecutor,
            @NonNull WorkDatabase database) {
        Context applicationContext = context.getApplicationContext();
        Logger.setLogger(new Logger.LogcatLogger(configuration.getMinimumLoggingLevel()));
        List<Scheduler> schedulers = createSchedulers(applicationContext, workTaskExecutor); //重点1
        Processor processor = new Processor(
                context,
                configuration,
                workTaskExecutor,
                database,
                schedulers);
        internalInit(context, configuration, workTaskExecutor, database, schedulers, processor); //重点2
    }

3.创建调度器

上面的重点1中创建一个调度的List集合，细节来了，Arrays,aslist这个不能增删😄，要么包装一层，要么用collections集合的方法。里面重点是创建一个贪吃的调度器

public List<Scheduler> createSchedulers(
            @NonNull Context context,
            @NonNull TaskExecutor taskExecutor) {

        return Arrays.asList(
                Schedulers.createBestAvailableBackgroundScheduler(context, this),
                // Specify the task executor directly here as this happens before internalInit.
                // GreedyScheduler creates ConstraintTrackers and controllers eagerly.
                new GreedyScheduler(context, taskExecutor, this)); //创建一个贪吃的调度器
    }

里面构建了各种调度控制器,

    public WorkConstraintsTracker(
            @NonNull Context context,
            @NonNull TaskExecutor taskExecutor,
            @Nullable WorkConstraintsCallback callback) {

        Context appContext = context.getApplicationContext();
        mCallback = callback;
        mConstraintControllers = new ConstraintController[] {
                new BatteryChargingController(appContext, taskExecutor),
                new BatteryNotLowController(appContext, taskExecutor),
                new StorageNotLowController(appContext, taskExecutor),
                new NetworkConnectedController(appContext, taskExecutor),
                new NetworkUnmeteredController(appContext, taskExecutor),
                new NetworkNotRoamingController(appContext, taskExecutor),
                new NetworkMeteredController(appContext, taskExecutor)
        };
        mLock = new Object();
    }

同时，在WorkmanagerImpl的构造中还创建了Processor，然后调用internalInit方法

mWorkTaskExecutor.executeOnBackgroundThread(new ForceStopRunnable(context, this));

里面就是判断APP是否应该执行任务

public void run() {
        // Migrate the database to the no-backup directory if necessary.
        WorkDatabasePathHelper.migrateDatabase(mContext);
        // Clean invalid jobs attributed to WorkManager, and Workers that might have been
        // interrupted because the application crashed (RUNNING state).
        Logger.get().debug(TAG, "Performing cleanup operations.");
        try {
            boolean needsScheduling = cleanUp();
            if (shouldRescheduleWorkers()) {
                Logger.get().debug(TAG, "Rescheduling Workers.");
                mWorkManager.rescheduleEligibleWork();
                // Mark the jobs as migrated.
                mWorkManager.getPreferenceUtils().setNeedsReschedule(false);
            } else if (isForceStopped()) {
                Logger.get().debug(TAG, "Application was force-stopped, rescheduling.");
                mWorkManager.rescheduleEligibleWork();
            } else if (needsScheduling) {
                Logger.get().debug(TAG, "Found unfinished work, scheduling it.");
                Schedulers.schedule(
                        mWorkManager.getConfiguration(),
                        mWorkManager.getWorkDatabase(),
                        mWorkManager.getSchedulers());
            }
            mWorkManager.onForceStopRunnableCompleted();
        } catch (SQLiteCantOpenDatabaseException
                | SQLiteDatabaseCorruptException
                | SQLiteAccessPermException exception) {
            // ForceStopRunnable is usually the first thing that accesses a database (or an app's
            // internal data directory). This means that weird PackageManager bugs are attributed
            // to ForceStopRunnable, which is unfortunate. This gives the developer a better error
            // message.
            String message =
                    "The file system on the device is in a bad state. WorkManager cannot access "
                            + "the app's internal data store.";
            Logger.get().error(TAG, message, exception);
            throw new IllegalStateException(message, exception);
        }
    }

4.再执行enqueue(request)方法

里面调用new WorkContinuationImpl(this, workRequests).enqueue(); 然后执行一个runnable,

public @NonNull Operation enqueue() {
        // Only enqueue if not already enqueued.
        if (!mEnqueued) {
            // The runnable walks the hierarchy of the continuations
            // and marks them enqueued using the markEnqueued() method, parent first.
            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;
    }

5.异步任务执行

里面有两个比较重要的逻辑。首先是处理了数据库相关的，这里就是存储的位置。

 public EnqueueRunnable(@NonNull WorkContinuationImpl workContinuation) {
        mWorkContinuation = workContinuation;
        mOperation = new OperationImpl();
    }

    @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));
        }
    }

可以看到还是比较严谨，开启事物处理数据库逻辑。

    public boolean addToDatabase() {
        WorkManagerImpl workManagerImpl = mWorkContinuation.getWorkManagerImpl();
        WorkDatabase workDatabase = workManagerImpl.getWorkDatabase();
        workDatabase.beginTransaction();
        try {
            boolean needsScheduling = processContinuation(mWorkContinuation);
            workDatabase.setTransactionSuccessful();
            return needsScheduling;
        } finally {
            workDatabase.endTransaction();
        }
    }

6.会执行调度的方法，schedule

public static void schedule(
            @NonNull Configuration configuration,
            @NonNull WorkDatabase workDatabase,
            List<Scheduler> schedulers) {
        if (schedulers == null || schedulers.size() == 0) {
            return;
        }

        WorkSpecDao workSpecDao = workDatabase.workSpecDao();
        List<WorkSpec> eligibleWorkSpecs;

        workDatabase.beginTransaction();
        try {
            eligibleWorkSpecs = workSpecDao.getEligibleWorkForScheduling(
                    configuration.getMaxSchedulerLimit());
            if (eligibleWorkSpecs != null && eligibleWorkSpecs.size() > 0) {
                long now = System.currentTimeMillis();

                // Mark all the WorkSpecs as scheduled.
                // Calls to Scheduler#schedule() could potentially result in more schedules
                // on a separate thread. Therefore, this needs to be done first.
                for (WorkSpec workSpec : eligibleWorkSpecs) {
                    workSpecDao.markWorkSpecScheduled(workSpec.id, now);
                }
            }
            workDatabase.setTransactionSuccessful();
        } finally {
            workDatabase.endTransaction();
        }

        if (eligibleWorkSpecs != null && eligibleWorkSpecs.size() > 0) {
            WorkSpec[] eligibleWorkSpecsArray = eligibleWorkSpecs.toArray(new WorkSpec[0]);
            // Delegate to the underlying scheduler.
            for (Scheduler scheduler : schedulers) {
                scheduler.schedule(eligibleWorkSpecsArray);
            }
        }
    }

里面同样是开启事物从数据库中取

7.贪吃调度器的调度

里面就处理了约束相关逻辑

8. mWorkManagerImpl.startWork(workSpec.id);

无约束的直接启动 mWorkManagerImpl.startWork(workSpec.id);，

public boolean startWork(
            @NonNull String id,
            @Nullable WorkerParameters.RuntimeExtras runtimeExtras) {

        WorkerWrapper workWrapper;
        synchronized (mLock) {
            // Work may get triggered multiple times if they have passing constraints
            // and new work with those constraints are added.
            if (mEnqueuedWorkMap.containsKey(id)) {
                Logger.get().debug(
                        TAG,
                        String.format("Work %s is already enqueued for processing", id));
                return false;
            }

            workWrapper =
                    new WorkerWrapper.Builder(
                            mAppContext,
                            mConfiguration,
                            mWorkTaskExecutor,
                            this,
                            mWorkDatabase,
                            id)
                            .withSchedulers(mSchedulers)
                            .withRuntimeExtras(runtimeExtras)
                            .build();
            ListenableFuture<Boolean> future = workWrapper.getFuture();
            future.addListener(
                    new FutureListener(this, id, future),
                    mWorkTaskExecutor.getMainThreadExecutor());
            mEnqueuedWorkMap.put(id, workWrapper);
        }
        mWorkTaskExecutor.getBackgroundExecutor().execute(workWrapper);
        Logger.get().debug(TAG, String.format("%s: processing %s", getClass().getSimpleName(), id));
        return true;
    }

最后调到我们自己的doWork方法

 @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;
    }

有条件约束的逻辑

代码太多，就不贴了，大概说下流程，比如网络限制的，是通过连网的广播，开启SystemAlarmService，切换action，然后还是调用没有约束的逻辑执行。