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 cancelled
2.   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)