Obserwuj postęp pośredniej instancji roboczej

WorkManager zapewnia najwyższej klasy obsługę ustawiania i obserwowania zdarzeń średnio zaawansowanych i postępu pracowników. Jeśli instancja robocza była uruchomiona, gdy aplikacja była w na pierwszym planie, te informacje mogą być też wyświetlane za pomocą interfejsów API, zwraca LiveData WorkInfo

ListenableWorker obsługuje teraz makra setProgressAsync() API, który pozwala zachować postęp pośredni. Te interfejsy API pozwalają programistów, aby ustawić pośredni postęp, który będzie można śledzić w interfejsie. Postęp jest reprezentowany przez typ Data, który jest serializowalnym kontenerem właściwości (podobnym do input i output i podlegają tym samym ograniczeniom).

Informacje o postępach można obserwować i aktualizować tylko wtedy, gdy Aplikacja ListenableWorker jest uruchomiona. Próby ustawienia postępu na urządzeniu ListenableWorker po jego zakończeniu są ignorowane. Możesz też obserwować postępy za pomocą biblioteki getWorkInfoBy…() lub getWorkInfoBy…LiveData() . Te metody zwracają wystąpienia WorkInfo, który ma nowy Metoda getProgress() , która zwraca Data.

Postęp aktualizacji

Informacje dla programistów Javy korzystających z ListenableWorker lub Worker, setProgressAsync() Interfejs API zwraca ListenableFuture<Void>; postęp aktualizacji jest asynchroniczny, biorąc pod uwagę, że proces aktualizacji obejmuje przechowywanie informacji o postępach w bazie danych. W Kotlin możesz użyć narzędzia CoroutineWorker, setProgress() obiektu .

Ten przykład pokazuje prosty ProgressWorker. Worker ustawia postęp na Wartość 0 po rozpoczęciu, a po zakończeniu zmienia wartość postępu na 100.

Kotlin

import android.content.Context
import androidx.work.CoroutineWorker
import androidx.work.Data
import androidx.work.WorkerParameters
import kotlinx.coroutines.delay

class ProgressWorker(context: Context, parameters: WorkerParameters) :
    CoroutineWorker(context, parameters) {

    companion object {
        const val Progress = "Progress"
        private const val delayDuration = 1L
    }

    override suspend fun doWork(): Result {
        val firstUpdate = workDataOf(Progress to 0)
        val lastUpdate = workDataOf(Progress to 100)
        setProgress(firstUpdate)
        delay(delayDuration)
        setProgress(lastUpdate)
        return Result.success()
    }
}

Java

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, 0).build());
    }

    @NonNull
    @Override
    public Result doWork() {
        try {
            // Doing work.
            Thread.sleep(DELAY);
        } catch (InterruptedException exception) {
            // ... handle exception
        }
        // Set progress to 100 after you are done doing your work.
        setProgressAsync(new Data.Builder().putInt(PROGRESS, 100).build());
        return Result.success();
    }
}

Obserwowanie postępów

Obserwowanie informacji o postępach również jest proste. Za pomocą getWorkInfoBy…() lub getWorkInfoBy…LiveData() i uzyskać odwołanie do WorkInfo.

Oto przykład, który korzysta z interfejsu API getWorkInfoByIdLiveData.

Kotlin

WorkManager.getInstance(applicationContext)
    // requestId is the WorkRequest id
    .getWorkInfoByIdLiveData(requestId)
    .observe(observer, Observer { workInfo: WorkInfo? ->
            if (workInfo != null) {
                val progress = workInfo.progress
                val value = progress.getInt(Progress, 0)
                // Do something with progress information
            }
    })

Java

WorkManager.getInstance(getApplicationContext())
     // requestId is the WorkRequest id
     .getWorkInfoByIdLiveData(requestId)
     .observe(lifecycleOwner, new Observer<WorkInfo>() {
             @Override
             public void onChanged(@Nullable WorkInfo workInfo) {
                 if (workInfo != null) {
                     Data progress = workInfo.getProgress();
                     int value = progress.getInt(PROGRESS, 0)
                     // Do something with progress
             }
      }
});

Więcej informacji o obserwowaniu obiektów Worker znajdziesz w artykule Obszary pracy i obserwacja pracy.