Question

我正在尝试观察我的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

Answer 1

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

ENQUEUED - RUNNING - ENQUEUED

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

在运行和排队之间，您可能会很快获得成功，但我从未见过。

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

ENQUEUED - RUNNING - SUCCEEDED

或您在doWork（）中返回的任何内容。

（Android 8.1 API 27，1.0.0-alpha04）

Answer 2

以上答案正确。对于定期工作，您应该看到：

ENQUEUED -> RUNNING -> ENQUEUED

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

重要提示：几天前：alpha05已发货。此错误已修复。

Answer 3

这适用于在定期工作中无法获取其输出数据的任何人。更像是骇客。在您的Worker中，只需定义静态可变的实时数据即可。在您观察工作状态的地方，当状态变为“正在运行”时，请观察此实时数据。

这是模板：

实际工人：

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

您观察该工人信息的活动：

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

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

工作状态观察者始终处于排队状态

3 个答案: