workstatus observer always in enqueued state

问题

I am trying to observe my workers but they are always in queued state or sometime it's RUNNING but never SUCCEED or FAILED.

is workStatus.state from return in doWork() or it's different?

this is my worker script:

package com.mockie.daikokuten.sync.workers

import androidx.work.Worker


class TestWorker:Worker()
{

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

}

this is script to observe the workers :

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

this is the result in 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

回答1:

For your periodic work request you should see

ENQUEUED - RUNNING - ENQUEUED

where the latter ENQUEUED is the state of the next work request.

You might get very briefly a SUCCEEDED between RUNNING and ENQUEUED, but I have never seen that.

For a onetime work request you see

ENQUEUED - RUNNING - SUCCEEDED

or whatever you return in doWork().

(Android 8.1 API 27, 1.0.0-alpha04)

回答2:

The above answer is correct. For PeriodicWork you should see:

ENQUEUED -> RUNNING -> ENQUEUED

However, there is a bug in alpha04 which causes PeriodicWork to not run on API >= 23. This will be fixed in alpha05. For more info take a look at https://issuetracker.google.com/issues/111195153.

IMPORTANT: As of a couple of days ago: alpha05 has shipped. This bug is fixed.

回答3:

This is for anyone who is having trouble getting their output data from periodic work. It's more like a hack. In your Worker, just define a static mutable Live Data. At the place where you observe your work's state, observe this live data when your state turns to "RUNNING".

Here's a template :

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

Your activity that observes this worker's info:

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

In this way you can observe your results when the state of the work is under running, before it gets switched back to enqueued.

来源：https://stackoverflow.com/questions/51476480/workstatus-observer-always-in-enqueued-state

标签

android

android-studio

kotlin

android-workmanager