इंटरमीडिएट वर्कर की प्रोग्रेस पर नज़र रखें

WorkManager में, वर्कर के लिए इंटरमीडिएट प्रोग्रेस सेट करने और उसे मॉनिटर करने की सुविधा पहले से मौजूद होती है. अगर ऐप्लिकेशन के फ़ोरग्राउंड में होने के दौरान वर्कर चल रहा था, तो इस जानकारी को उपयोगकर्ता को भी दिखाया जा सकता है. इसके लिए, ऐसे एपीआई का इस्तेमाल किया जा सकता है जो WorkInfo का LiveData दिखाते हैं.

ListenableWorker अब setProgressAsync() एपीआई के साथ काम करता है. इससे, बीच में किए गए बदलावों को सेव किया जा सकता है. इन एपीआई की मदद से, डेवलपर प्रोग्रेस को बीच में ही सेट कर सकते हैं. इसे यूज़र इंटरफ़ेस (यूआई) से देखा जा सकता है. प्रोग्रेस को Data टाइप से दिखाया जाता है. यह प्रॉपर्टी का ऐसा कंटेनर होता है जिसे क्रम से लगाया जा सकता है. यह input और output की तरह होता है और इस पर भी वही पाबंदियां लागू होती हैं.

ListenableWorker के चालू होने पर ही, प्रोग्रेस की जानकारी देखी और अपडेट की जा सकती है. ListenableWorker के पूरा होने के बाद, उसकी प्रोग्रेस सेट करने की कोशिशों को अनदेखा कर दिया जाता है.

getWorkInfoBy…() या getWorkInfoBy…LiveData() में से किसी एक तरीके का इस्तेमाल करके, प्रोग्रेस की जानकारी भी देखी जा सकती है. ये तरीके, WorkInfo के इंस्टेंस दिखाते हैं. इसमें एक नया getProgress() तरीका है, जो Data दिखाता है.

अपडेट की स्थिति

ListenableWorker या Worker का इस्तेमाल करने वाले Java डेवलपर के लिए, setProgressAsync() API, ListenableFuture<Void> दिखाता है. अपडेट करने की प्रोसेस एसिंक्रोनस होती है, क्योंकि अपडेट करने की प्रोसेस में प्रोग्रेस की जानकारी को डेटाबेस में सेव करना होता है. Kotlin में, प्रोग्रेस की जानकारी को अपडेट करने के लिए, CoroutineWorker object's setProgress() extension फ़ंक्शन का इस्तेमाल किया जा सकता है.

इस उदाहरण में ProgressWorker दिखाया गया है. Worker शुरू होने पर, इसकी प्रोग्रेस 0 पर सेट हो जाती है. पूरा होने पर, प्रोग्रेस की वैल्यू 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();
    }
}

प्रोग्रेस देखना

प्रोग्रेस की जानकारी देखने के लिए, getWorkInfoById तरीकों का इस्तेमाल करें. साथ ही, WorkInfo का रेफ़रंस पाएं.

यहां एक उदाहरण दिया गया है, जिसमें Kotlin के लिए getWorkInfoByIdFlow और Java के लिए getWorkInfoByIdLiveData का इस्तेमाल किया गया है.

Kotlin

WorkManager.getInstance(applicationContext)
      // requestId is the WorkRequest id
      .getWorkInfoByIdFlow(requestId)
      .collect { 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
             }
      }
});

रोकने की वजह का स्टेटस देखना

Worker के रुकने की वजह का पता लगाने के लिए, WorkInfo.getStopReason() को कॉल करके, रुकने की वजह को लॉग किया जा सकता है:

Kotlin

workManager.getWorkInfoByIdFlow(syncWorker.id)
  .collect { workInfo ->
      if (workInfo != null) {
        val stopReason = workInfo.stopReason
        logStopReason(syncWorker.id, stopReason)
      }
  }

Java

  workManager.getWorkInfoByIdLiveData(syncWorker.id)
    .observe(getViewLifecycleOwner(), workInfo -> {
        if (workInfo != null) {
          int stopReason = workInfo.getStopReason();
          logStopReason(syncWorker.id, workInfo.getStopReason());
        }
  });

Worker ऑब्जेक्ट के लाइफ़साइकल और स्थितियों के बारे में ज़्यादा दस्तावेज़ के लिए, काम की स्थितियां पढ़ें.