How to Observer Android WorkManager Workers

My current Android Application employs

archWorkerRuntimeVersion = '2.3.0-beta02'

api "androidx.work:work-runtime:$archWorkerRuntimeVersion"
api "androidx.work:work-runtime-ktx:$archWorkerRuntimeVersion"

to process background work.

While the worker is running I display a toolbar progress spinner to signal to my users that the App is "Busy".

My App consists of multiple activities and I employ Android JetPack ViewModels to manage the Worker.

I start the work as follows:-

val myWorkRequest: OneTimeWorkRequest =
    OneTimeWorkRequest.Builder(MyWorker::class.java)
        .addTag(WORK_IN_PROGRESS_TAG + "${UUID.randomUUID()}").build()

    WorkManager.getInstance(applicationContext)
        .beginUniqueWork(
            UNIQUE_WORK_NAME,
            ExistingWorkPolicy.KEEP,
            myWorkRequest
        )
        .enqueue()

I have an observer defined as follows:-

private val observer = Observer<WorkInfo> { workInfo ->

    when(workInfo.state) {
        WorkInfo.State.RUNNING -> Log.e("OBSERVING", "${UUID.randomUUID()} :: show Progress Spinner")
        WorkInfo.State.ENQUEUED -> Log.e("OBSERVING", "${UUID.randomUUID()} :: show Progress Spinner")
        WorkInfo.State.SUCCEEDED -> Log.e("OBSERVING", "${UUID.randomUUID()} :: stop showing Progress Spinner")
        WorkInfo.State.FAILED -> Log.e("OBSERVING", "${UUID.randomUUID()} :: stop showing Progress Spinner")
        WorkInfo.State.BLOCKED -> Log.e("OBSERVING", "${UUID.randomUUID()} :: show Progress Spinner")
        WorkInfo.State.CANCELLED -> Log.e("OBSERVING", "${UUID.randomUUID()} :: stop showing Progress Spinner")
    }

}

I observe the work as follows:-

 WorkManager.getInstance(applicationContext)
            .getWorkInfoByIdLiveData(myWorkRequest.id)
            .observe(lifeCycleOwner, observer)

and remember the current workId in my view model

class MyViewModel : ViewModel() {

    private var currentWorkInfoId: UUID? = null


  fun startWorkTags(lifeCycleOwner: LifecycleOwner, applicationContext: Context) {

        val myWorkRequest: OneTimeWorkRequest =
    OneTimeWorkRequest.Builder(MyWorker::class.java)
        .addTag(WORK_IN_PROGRESS_TAG + "${UUID.randomUUID()}").build()

    WorkManager.getInstance(applicationContext)
        .beginUniqueWork(
            UNIQUE_WORK_NAME,
            ExistingWorkPolicy.KEEP,
            myWorkRequest
        )
        .enqueue()

        currentWorkInfoId = myWorkRequest.id
   }
}

I have the following issues

1). As I am using ExistingWorkPolicy.KEEP, I need to know when there is already background work active so that I do not remember the wrong work id. Currently I unconditionally remember the last work id I attempted to enqueue(). Is there any way I can detect when ExistingWorkPolicy.KEEP results in no new work being started?

2). As I am storing the current work id in my viewModel when the user exits my app I lose this id. How can I discover if I have an active worker when my users re enter my App?

For issue 2). I have tried using

 WorkManager.getInstance(applicationContext)
            .getWorkInfosForUniqueWorkLiveData(UNIQUE_WORK_NAME)
            .observe(lifeCycleOwner, observerUnique)

However this approach "sees" all previous worker executions, how am I to identify the latest worker instance?

Given that you just want to show a progress spinner when the Worker is running, you may implement a simpler solution, where your observer just check if there's one Worker in a non-final state.

observe(this, listOfWorkInfo -> {
    // If there are no matching work info, do nothing
    if (listOfWorkInfo == null || listOfWorkInfo.isEmpty()) {
        return;
    }

    boolean showProgress = false;
    for (WorkInfo workInfo : listOfWorkInfo) {
        if (!(workInfo.getState().isFinished())) {
            showProgress = true;
        }
    }

    if (showProgress) {
        showSpinner();
    } else {
        hideSpinner();
    }

}

Where you get the list of WorkInfos with getWorkInfosForUniqueWorkLiveData().

An alternative solution is also to use the new Progress API introduced in WorkManager v2.3.0 that you're already using.

The idea is that you publish a progress as soon as your worker starts (in the constructor):

import android.content.Context;
import androidx.annotation.NonNull;
import androidx.work.Data;
import androidx.work.Worker;
import androidx.work.WorkerParameters;

public class ProgressWorker extends Worker {

    private static final String PROGRESS = "PROGRESS";
    private static final long DELAY = 1000L;

    public ProgressWorker(
        @NonNull Context context,
        @NonNull WorkerParameters parameters) {
        super(context, parameters);
        // Set initial progress to 0
        setProgressAsync(new Data.Builder().putInt(PROGRESS, 1).build());
    }

    @NonNull
    @Override
    public Result doWork() {
        try {
            // Doing work.
            Thread.sleep(DELAY);
        } catch (InterruptedException exception) {
            // ... handle exception
        }
        return Result.success();
    }
}

You can retrieve the progress in the observer you already have using workInfo.getProgress(). The benefit in this case is coming from the fact that the progress information is only available as long as the worker is running.
You can still request all the WorkInfos from the UniqueWorkName, but you're going to have a progress only if the worker is running.

WorkManager will take care of removing the progress information when the worker is in a final state.