Android WorkManager浅谈

@Override  public void run() {    try {      if (mWorkContinuation.hasCycles()) {        throw new IllegalStateException(            String.format("WorkContinuation has cycles (%s)", mWorkContinuation));      }      boolean needsScheduling = addToDatabase();      if (needsScheduling) {              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));    }  }  /**   * Schedules work on the background scheduler.   */  @VisibleForTesting  public void scheduleWorkInBackground() {    WorkManagerImpl workManager = mWorkContinuation.getWorkManagerImpl();    Schedulers.schedule(        workManager.getConfiguration(),        workManager.getWorkDatabase(),        workManager.getSchedulers());  }

/**   * Schedules {@link WorkSpec}s while honoring the {@link Scheduler#MAX_SCHEDULER_LIMIT}.   *   * @param workDatabase The {@link WorkDatabase}.   * @param schedulers  The {@link List} of {@link Scheduler}s to delegate to.   */  public static void schedule(      @NonNull Configuration configuration,      @NonNull WorkDatabase workDatabase,      List<Scheduler> schedulers) {    if (schedulers == null || schedulers.size() == 0) {      return;    }    ...    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);      }    }  }

@WorkerThread  @Override  public void run() {    mTags = mWorkTagDao.getTagsForWorkSpecId(mWorkSpecId);    mWorkDescription = createWorkDescription(mTags);    runWorker();  }  private void runWorker() {    if (tryCheckForInterruptionAndResolve()) {      return;    }    mWorkDatabase.beginTransaction();    try {      mWorkSpec = mWorkSpecDao.getWorkSpec(mWorkSpecId);      if (mWorkSpec == null) {        Logger.get().error(            TAG,            String.format("Didn't find WorkSpec for id %s", mWorkSpecId));        resolve(false);        return;      }      // running, finished, or is blocked.      if (mWorkSpec.state != ENQUEUED) {        resolveIncorrectStatus();        mWorkDatabase.setTransactionSuccessful();        return;      }      // Case 1:      // Ensure that Workers that are backed off are only executed when they are supposed to.      // GreedyScheduler can schedule WorkSpecs that have already been backed off because      // it is holding on to snapshots of WorkSpecs. So WorkerWrapper needs to determine      // if the ListenableWorker is actually eligible to execute at this point in time.      // Case 2:      // On API 23, we double scheduler Workers because JobScheduler prefers batching.      // So is the Work is periodic, we only need to execute it once per interval.      // Also potential bugs in the platform may cause a Job to run more than once.      if (mWorkSpec.isPeriodic() || mWorkSpec.isBackedOff()) {        long now = System.currentTimeMillis();        if (now < mWorkSpec.calculateNextRunTime()) {          resolve(false);          return;        }      }      mWorkDatabase.setTransactionSuccessful();    } finally {      mWorkDatabase.endTransaction();    }    // Merge inputs. This can be potentially expensive code, so this should not be done inside    // a database transaction.    Data input;    if (mWorkSpec.isPeriodic()) {      input = mWorkSpec.input;    } else {      InputMerger inputMerger = InputMerger.fromClassName(mWorkSpec.inputMergerClassName);      if (inputMerger == null) {        Logger.get().error(TAG, String.format("Could not create Input Merger %s",            mWorkSpec.inputMergerClassName));        setFailedAndResolve();        return;      }      List<Data> inputs = new ArrayList<>();      inputs.add(mWorkSpec.input);      inputs.addAll(mWorkSpecDao.getInputsFromPrerequisites(mWorkSpecId));      input = inputMerger.merge(inputs);    }    WorkerParameters params = new WorkerParameters(        UUID.fromString(mWorkSpecId),        input,        mTags,        mRuntimeExtras,        mWorkSpec.runAttemptCount,        mConfiguration.getExecutor(),        mWorkTaskExecutor,        mConfiguration.getWorkerFactory());    // Not always creating a worker here, as the WorkerWrapper.Builder can set a worker override    // in test mode.    if (mWorker == null) {      mWorker = mConfiguration.getWorkerFactory().createWorkerWithDefaultFallback(          mAppContext,          mWorkSpec.workerClassName,          params);    }    if (mWorker == null) {      Logger.get().error(TAG,          String.format("Could not create Worker %s", mWorkSpec.workerClassName));      setFailedAndResolve();      return;    }    if (mWorker.isUsed()) {      Logger.get().error(TAG,          String.format("Received an already-used Worker %s; WorkerFactory should return "              + "new instances",              mWorkSpec.workerClassName));      setFailedAndResolve();      return;    }    mWorker.setUsed();    // Try to set the work to the running state. Note that this may fail because another thread    // may have modified the DB since we checked last at the top of this function.    if (trySetRunning()) {      if (tryCheckForInterruptionAndResolve()) {        return;      }      final SettableFuture<ListenableWorker.Result> future = SettableFuture.create();      // Call mWorker.startWork() on the main thread.      mWorkTaskExecutor.getMainThreadExecutor()          .execute(new Runnable() {            @Override            public void run() {              try {                mInnerFuture = mWorker.startWork();                future.setFuture(mInnerFuture);              } catch (Throwable e) {                future.setException(e);              }            }          });      // Avoid synthetic accessors.      final String workDescription = mWorkDescription;      future.addListener(new Runnable() {        @Override        @SuppressLint("SyntheticAccessor")        public void run() {          try {            // If the ListenableWorker returns a null result treat it as a failure.            ListenableWorker.Result result = future.get();            if (result == null) {              Logger.get().error(TAG, String.format(                  "%s returned a null result. Treating it as a failure.",                  mWorkSpec.workerClassName));            } else {              mResult = result;            }          } catch (CancellationException exception) {            // Cancellations need to be treated with care here because innerFuture            // cancellations will bubble up, and we need to gracefully handle that.            Logger.get().info(TAG, String.format("%s was cancelled", workDescription),                exception);          } catch (InterruptedException | ExecutionException exception) {            Logger.get().error(TAG,                String.format("%s failed because it threw an exception/error",                    workDescription), exception);          } finally {            onWorkFinished();          }        }      }, mWorkTaskExecutor.getBackgroundExecutor());    } else {      resolveIncorrectStatus();    }  }

future.addListener(new Runnable() {        @Override        @SuppressLint("SyntheticAccessor")        public void run() {          try {            // If the ListenableWorker returns a null result treat it as a failure.            ListenableWorker.Result result = future.get();            if (result == null) {              Logger.get().error(TAG, String.format(                  "%s returned a null result. Treating it as a failure.",                  mWorkSpec.workerClassName));            } else {              mResult = result;            }          } catch (CancellationException exception) {            // Cancellations need to be treated with care here because innerFuture            // cancellations will bubble up, and we need to gracefully handle that.            Logger.get().info(TAG, String.format("%s was cancelled", workDescription),                exception);          } catch (InterruptedException | ExecutionException exception) {            Logger.get().error(TAG,                String.format("%s failed because it threw an exception/error",                    workDescription), exception);          } finally {            onWorkFinished();          }        }      }, mWorkTaskExecutor.getBackgroundExecutor());

@Override  public final @NonNull ListenableFuture<Result> startWork() {    mFuture = SettableFuture.create();    getBackgroundExecutor().execute(new Runnable() {      @Override      public void run() {        Result result = doWork();        mFuture.set(result);      }    });    return mFuture;  }

1. 2019-02-02 15:35:41.682 30526-30542/com.outman.study.workmanagerdemo I/WM-WorkerWrapper: Work [ id=3d775394-e0d7-44e3-a670-c3527a3245ee, tags={ com.outman.study.workmanagerdemo.SimpleWorker } ] was cancelled2.   java.util.concurrent.CancellationException: Task was cancelled.3.     at androidx.work.impl.utils.futures.AbstractFuture.cancellationExceptionWithCause(AbstractFuture.java:1184)4.     at androidx.work.impl.utils.futures.AbstractFuture.getDoneValue(AbstractFuture.java:514)5.     at androidx.work.impl.utils.futures.AbstractFuture.get(AbstractFuture.java:475)6.     at androidx.work.impl.WorkerWrapper$2.run(WorkerWrapper.java:264)7.     at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1167)8.     at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:641)9.     at java.lang.Thread.run(Thread.java:764)