3

我试图观察我的workers，但他们总是处于queued状态，或者有时是，RUNNING但从来SUCCEED没有FAILED。

是workStatus.state从返回doWork()还是不同？

这是我的工作脚本：

package com.mockie.daikokuten.sync.workers

import androidx.work.Worker


class TestWorker:Worker()
{

override fun doWork():Worker.Result
{
    return Worker.Result.SUCCESS
}

}

这是观察工人的脚本：

 val test = PeriodicWorkRequest.Builder(
            TestWorker::class.java,
            PeriodicWorkRequest.MIN_PERIODIC_INTERVAL_MILLIS,
            TimeUnit.MILLISECONDS)
            .addTag("test_worker")
            .build()

    WorkManager.getInstance()?.enqueueUniquePeriodicWork("test_worker", ExistingPeriodicWorkPolicy.KEEP, test)

    WorkManager.getInstance()!!.getStatusesByTag("test_worker")
            .observe(this, Observer { workStatus ->
                if (workStatus != null)
                {
                    for(ws in workStatus)
                    {
                        Log.d(":dump2 id ", ws.id.toString())
                        Log.d(":dump2 tag", ws.tags.toString())
                        Log.d(":dump2 state", ws.state.toString())
                    }
                }
            })

这是 Logcat 中的结果：

 07-23 17:12:30.901 29740-29740/com.mockie.daikokuten D/:dump2 id: 5c6297f7-11d8-4f2f-a327-773672a7435c
 07-23 17:12:30.901 29740-29740/com.mockie.daikokuten D/:dump2 tag: [test_worker, com.mockie.daikokuten.sync.workers.TestWorker]
 07-23 17:12:30.901 29740-29740/com.mockie.daikokuten D/:dump2 state: ENQUEUED
4

3 回答 3

4

对于您的定期工作请求，您应该看到

ENQUEUED - RUNNING - ENQUEUED

其中后者 ENQUEUED 是下一个工作请求的状态。

您可能会在 RUNNING 和 ENQUEUED 之间获得非常短暂的 SUCCEEDED，但我从未见过。

对于一次性工作请求，您会看到

ENQUEUED - RUNNING - SUCCEEDED

或者你在 doWork() 中返回的任何内容。

（Android 8.1 API 27、1.0.0-alpha04）

于 2018-07-23T15:36:04.577 回答
0

上面的答案是正确的。对于 PeriodicWork，您应该看到：

ENQUEUED -> RUNNING -> ENQUEUED

但是，有一个错误alpha04导致PeriodicWork无法在 API >= 23 上运行。这将在alpha05. 有关更多信息，请查看https://issuetracker.google.com/issues/111195153。

重要提示：截至几天前：alpha05已发货。这个错误是固定的。

于 2018-07-23T23:52:40.297 回答
0

这适用于任何无法从定期工作中获取输出数据的人。这更像是一个黑客。在您的 Worker 中，只需定义一个静态可变的 Live Data。在您观察工作状态的地方，当您的状态变为“RUNNING”时，观察此实时数据。

这是一个模板：

  1. 实际工人：
public class SomeWorker extends Worker{

   //This live data can be of any type. I'm setting Boolean
   Public static MutableLiveData<Boolean> outputObservable = new MutableLiveData();
   private boolean output_boolean;
   try{
       //Do you work here post your result to the live data
       output_boolean = SomeTaskThatReturnsABoolean();
       outputObservable.postValue(output_boolean);
       return Result.Success();
   }catch(Exception e){
       e.printStackTrace();
       outputObservable.postValue(!output_boolean);
       return Result.Failure();
    }
}
  1. 您观察此工作人员信息的活动：
//In YourActivity class inside OnCreate
mWorkManager.getWorkInfoForUniqueWorkLiveData(YOUR_TAG).observe (this,
   new Observer<List<WorkInfo>>(){
       @Override
       public void onChanged(@Nullable List<WorkInfo> workInfos) {
          if(workInfos!=null && (!(workInfos.isEmpty()))) {
             WorkInfo info = workInfos.get(0);
             switch(info.getState()){
               case ENQUEUED:
                   break;
               case RUNNING:
                   SomeWorker.outputObservable.observe(YourActivity.this,
                      new Observer<Boolean>(){
                      @Override
                       public void onChanged(@Nullable Boolean aBoolean) {
                           //EDIT: Remove the observer of the worker otherwise 
                           //before execution of your below code, the observation might switch
                           mWorkManager.getWorkInfoForUniqueWorkLiveData(YOUR_TAG).removeObservers(YourActivity.this);
                           if(aBoolean)
                             //Do whatever you have to if it's true
                           else
                             //Do whatever you have to if it's false
                           }
                      }
                   );
             }
          }
       }
   }
);

通过这种方式，您可以在工作状态正在运行时观察结果，然后再将其切换回入队状态。

于 2019-05-28T09:56:44.003 回答