Firebase JobDispatcher से WorkManager पर माइग्रेट करना

WorkManager एक लाइब्रेरी है. इसकी मदद से, बैकग्राउंड में हो रहे काम को शेड्यूल किया जा सकता है और उसे लागू किया जा सकता है Android में. हम आपको Firebase JobDispatcher का इस्तेमाल करने का सुझाव देते हैं. कॉन्टेंट बनाने इस गाइड में, Firebase को माइग्रेट करने का तरीका बताया गया है WorkManager पर JobDispatcher लागू करना.

Gradle सेटअप

अपने Android प्रोजेक्ट में WorkManager लाइब्रेरी इंपोर्ट करने के लिए, यहां दी गई डिपेंडेंसी WorkManager का इस्तेमाल शुरू करना.

JobService से कर्मचारियों तक

FirebaseJobDispatcher इसकी सब-क्लास का इस्तेमाल करता है JobService इस टूल की मदद से, यह तय किया जा सकता है कि किस तरह का काम करना है. आप सीधे JobService का इस्तेमाल करके या इसका इस्तेमाल करके SimpleJobService.

JobService कुछ ऐसा दिखेगा:

Kotlin

import com.firebase.jobdispatcher.JobParameters
import com.firebase.jobdispatcher.JobService

class MyJobService : JobService() {
    override fun onStartJob(job: JobParameters): Boolean {
        // Do some work here
        return false // Answers the question: "Is there still work going on?"
    }
    override fun onStopJob(job: JobParameters): Boolean {
        return false // Answers the question: "Should this job be retried?"
    }
}

Java

import com.firebase.jobdispatcher.JobParameters;
import com.firebase.jobdispatcher.JobService;

public class MyJobService extends JobService {
    @Override
    public boolean onStartJob(JobParameters job) {
        // Do some work here

        return false; // Answers the question: "Is there still work going on?"
    }

    @Override
    public boolean onStopJob(JobParameters job) {
        return false; // Answers the question: "Should this job be retried?"
    }
}

अगर SimpleJobService का इस्तेमाल किया जा रहा है, तो onRunJob(), बदल जाएगा जो @JobResult int टाइप दिखाता है.

मुख्य अंतर यह है कि जब आप JobService, onStartJob() का सीधे इस्तेमाल करते हैं को मुख्य थ्रेड पर कॉल किया जाता है और नए यूआरएल को लोड करने की ज़िम्मेदारी ऐप्लिकेशन की होती है बैकग्राउंड थ्रेड पर काम करते हैं. दूसरी ओर, अगर आपको SimpleJobService, यह सेवा बैकग्राउंड थ्रेड.

WorkManager के कॉन्सेप्ट एक जैसे हैं. WorkManager के काम के लिए बुनियादी इकाई ListenableWorker. यहां हैं कर्मचारियों के अन्य उपयोगी उप-प्रकार भी शामिल हैं, जैसे Worker RxWorker और CoroutineWorker (जब Kotlin कोरूटीन इस्तेमाल करके).

LearnableWorker के लिए JobService मैप

अगर आप सीधे JobService का इस्तेमाल कर रहे हैं, तो यह जिस वर्कर को मैप करता है वह ListenableWorker. अगर आप SimpleJobService का इस्तेमाल कर रहे हैं, तो आपको अगर आपके पास इन फ़ॉर्मैट की फ़ाइल नहीं है, तो Worker बटन का इस्तेमाल करें.

आइए, ऊपर दिए गए उदाहरण (MyJobService) को देखते हैं. यह देखते हैं कि हम इसे कैसे बदल सकते हैं ListenableWorker के लिए.

Kotlin

import android.content.Context
import androidx.work.ListenableWorker
import androidx.work.ListenableWorker.Result
import androidx.work.WorkerParameters
import com.google.common.util.concurrent.ListenableFuture

class MyWorker(appContext: Context, params: WorkerParameters) :
    ListenableWorker(appContext, params) {

    override fun startWork(): ListenableFuture<ListenableWorker.Result> {
        // Do your work here.
        TODO("Return a ListenableFuture<Result>")
    }

    override fun onStopped() {
        // Cleanup because you are being stopped.
    }
}

Java

import android.content.Context;
import androidx.work.ListenableWorker;
import androidx.work.ListenableWorker.Result;
import androidx.work.WorkerParameters;
import com.google.common.util.concurrent.ListenableFuture;

class MyWorker extends ListenableWorker {

  public MyWorker(@NonNull Context appContext, @NonNull WorkerParameters params) {
    super(appContext, params);
  }

  @Override
  public ListenableFuture<ListenableWorker.Result> startWork() {
    // Do your work here.
    Data input = getInputData();

    // Return a ListenableFuture<>
  }

  @Override
  public void onStopped() {
    // Cleanup because you are being stopped.
  }
}

WorkManager में काम करने की मूल यूनिट, ListenableWorker है. बिलकुल उसी तरह JobService.onStartJob(), startWork() को मुख्य थ्रेड में कॉल किया गया है. यहां MyWorker, ListenableWorker को लागू करता है और इसका इंस्टेंस दिखाता है ListenableFuture, इसका इस्तेमाल, एसिंक्रोनस तरीके से काम पूरा होने का सिग्नल देने के लिए किया जाता है. आपको अपना यहां अपनी थ्रेडिंग रणनीति बनाई जा सकती है.

यहां ListenableFuture, नतीजे के तौर पर ListenableWorker.Result टाइप दिखाता है जो Result.success(), Result.success(Data outputData), Result.retry(), Result.failure() या Result.failure(Data outputData). इसके लिए ज़्यादा जानकारी के लिए, ListenableWorker.Result.

onStopped() को यह बताने के लिए कॉल किया जाता है कि ListenableWorker को बंद करना होगा, ऐसा इसलिए, क्योंकि अब कंस्ट्रेंट पूरा नहीं किया जा रहा है. उदाहरण के लिए, नेटवर्क अब उपलब्ध नहीं है) या WorkManager.cancel…() तरीका कॉल किया गया. अगर ओएस आपके डिवाइस को शट डाउन करता है, तब भी onStopped() को कॉल किया जा सकता है किसी वजह से काम करते हैं.

एक वर्कर के लिए Simple JobService मैप

SimpleJobService का इस्तेमाल करते समय, ऊपर दिया गया वर्कर ऐसा दिखेगा:

Kotlin

import android.content.Context;
import androidx.work.Data;
import androidx.work.ListenableWorker.Result;
import androidx.work.Worker;
import androidx.work.WorkerParameters;


class MyWorker(context: Context, params: WorkerParameters) : Worker(context, params) {
    override fun doWork(): Result {
        TODO("Return a Result")
    }

    override fun onStopped() {
        super.onStopped()
        TODO("Cleanup, because you are being stopped")
    }
}

Java

import android.content.Context;
import androidx.work.Data;
import androidx.work.ListenableWorker.Result;
import androidx.work.Worker;
import androidx.work.WorkerParameters;

class MyWorker extends Worker {

  public MyWorker(@NonNull Context appContext, @NonNull WorkerParameters params) {
    super(appContext, params);
  }

  @Override
  public Result doWork() {
    // Do your work here.
    Data input = getInputData();

    // Return a ListenableWorker.Result
    Data outputData = new Data.Builder()
        .putString(“Key”, “value”)
        .build();
    return Result.success(outputData);
  }

  @Override
  public void onStopped() {
    // Cleanup because you are being stopped.
  }
}

यहां doWork(), काम करने का सिग्नल देने के लिए ListenableWorker.Result का इंस्टेंस दिखाता है सिंक्रोनस रूप से पूरा होता है. यह SimpleJobService से मिलता-जुलता है, जो जॉब को बैकग्राउंड के थ्रेड पर ले जाते हैं.

WorkRequest पर JobBuilder से जुड़ा मैप

Firebase JobBuilder, Job मेटाडेटा को दिखाने के लिए Job.Builder का इस्तेमाल करते हैं. वर्कमैनेजर इस भूमिका को भरने के लिए, WorkRequest का इस्तेमाल करता है.

WorkManager के पास दो तरह के WorkRequest होते हैं: OneTimeWorkRequest और PeriodicWorkRequest.

अगर आप अभी Job.Builder.setRecurring(true) का इस्तेमाल कर रहे हैं, तो आपको यह करना चाहिए नया PeriodicWorkRequest बनाएं. अगर ऐसा नहीं है, तो आपको OneTimeWorkRequest.

आइए, देखते हैं कि FirebaseJobDispatcher के साथ कॉम्प्लेक्स Job को शेड्यूल करने पर क्या हो सकता है ऐसा दिखेगा:

Kotlin

val input: Bundle = Bundle().apply {
    putString("some_key", "some_value")
}

val job = dispatcher.newJobBuilder()
    // the JobService that will be called
    .setService(MyService::class.java)
    // uniquely identifies the job
    .setTag("my-unique-tag")
    // one-off job
    .setRecurring(false)
    // don't persist past a device reboot
    .setLifetime(Lifetime.UNTIL_NEXT_BOOT)
    // start between 0 and 60 seconds from now
    .setTrigger(Trigger.executionWindow(0, 60))
    // don't overwrite an existing job with the same tag
    .setReplaceCurrent(false)
    // retry with exponential backoff
    .setRetryStrategy(RetryStrategy.DEFAULT_EXPONENTIAL)

    .setConstraints(
        // only run on an unmetered network
        Constraint.ON_UNMETERED_NETWORK,
        // // only run when the device is charging
        Constraint.DEVICE_CHARGING
    )
    .setExtras(input)
    .build()

dispatcher.mustSchedule(job)

Java

Bundle input = new Bundle();
input.putString("some_key", "some_value");

Job myJob = dispatcher.newJobBuilder()
    // the JobService that will be called
    .setService(MyJobService.class)
    // uniquely identifies the job
    .setTag("my-unique-tag")
    // one-off job
    .setRecurring(false)
    // don't persist past a device reboot
    .setLifetime(Lifetime.UNTIL_NEXT_BOOT)
    // start between 0 and 60 seconds from now
    .setTrigger(Trigger.executionWindow(0, 60))
    // don't overwrite an existing job with the same tag
    .setReplaceCurrent(false)
    // retry with exponential backoff
    .setRetryStrategy(RetryStrategy.DEFAULT_EXPONENTIAL)
    // constraints that need to be satisfied for the job to run
    .setConstraints(
        // only run on an unmetered network
        Constraint.ON_UNMETERED_NETWORK,
        // only run when the device is charging
        Constraint.DEVICE_CHARGING
    )
    .setExtras(input)
    .build();

dispatcher.mustSchedule(myJob);

ऐसा ही WorkManager के साथ काम करने के लिए:

• ऐसा इनपुट डेटा बनाएं जिसका इस्तेमाल Worker के इनपुट के तौर पर किया जा सके.
• मिलते-जुलते इनपुट डेटा और कंस्ट्रेंट के साथ WorkRequest बनाएं FirebaseJobDispatcher के लिए ऊपर परिभाषित किया गया है.
• WorkRequest को कतार में लगाएं.

वर्कर के लिए इनपुट सेट अप करना

FirebaseJobDispatcher, JobService को इनपुट डेटा भेजने के लिए Bundle का इस्तेमाल करता है. WorkManager इसके बजाय Data का इस्तेमाल करता है. तो जो बन जाता है:

Kotlin

import androidx.work.workDataOf
val data = workDataOf("some_key" to "some_val")

Java

import androidx.work.Data;
Data input = new Data.Builder()
    .putString("some_key", "some_value")
    .build();

वर्कर के लिए कंस्ट्रेंट सेट अप करना

FirebaseJobDispatcher का इस्तेमाल Job.Builder.setConstaints(...) का इस्तेमाल करके जॉब पर पाबंदियां लगाई जा सकती हैं. WorkManager, इस्तेमाल की अनुमति देता है इसके बजाय, Constraints का इस्तेमाल करें.

Kotlin

import androidx.work.*

val constraints: Constraints = Constraints.Builder().apply {
    setRequiredNetworkType(NetworkType.CONNECTED)
    setRequiresCharging(true)
}.build()

Java

import androidx.work.Constraints;
import androidx.work.Constraints.Builder;
import androidx.work.NetworkType;

Constraints constraints = new Constraints.Builder()
    // The Worker needs Network connectivity
    .setRequiredNetworkType(NetworkType.CONNECTED)
    // Needs the device to be charging
    .setRequiresCharging(true)
    .build();

WorkRequest बनाना (एक बार या एक से ज़्यादा बार के लिए)

OneTimeWorkRequest और PeriodicWorkRequest बनाने के लिए, आपको इनका इस्तेमाल करना चाहिए OneTimeWorkRequest.Builder और PeriodicWorkRequest.Builder.

ऊपर दिए गए Job से मिलता-जुलता OneTimeWorkRequest बनाने के लिए, आपको यह करना चाहिए ये काम करें:

Kotlin

import androidx.work.*
import java.util.concurrent.TimeUnit

val constraints: Constraints = TODO("Define constraints as above")
val request: OneTimeWorkRequest =
     // Tell which work to execute
     OneTimeWorkRequestBuilder<MyWorker>()
         // Sets the input data for the ListenableWorker
        .setInputData(input)
        // If you want to delay the start of work by 60 seconds
        .setInitialDelay(60, TimeUnit.SECONDS)
        // Set a backoff criteria to be used when retry-ing
        .setBackoffCriteria(BackoffPolicy.EXPONENTIAL, 30000, TimeUnit.MILLISECONDS)
        // Set additional constraints
        .setConstraints(constraints)
        .build()

Java

import androidx.work.BackoffCriteria;
import androidx.work.Constraints;
import androidx.work.Constraints.Builder;
import androidx.work.NetworkType;
import androidx.work.OneTimeWorkRequest;
import androidx.work.OneTimeWorkRequest.Builder;
import androidx.work.Data;

// Define constraints (as above)
Constraints constraints = ...
OneTimeWorkRequest request =
    // Tell which work to execute
    new OneTimeWorkRequest.Builder(MyWorker.class)
        // Sets the input data for the ListenableWorker
        .setInputData(inputData)
        // If you want to delay the start of work by 60 seconds
        .setInitialDelay(60, TimeUnit.SECONDS)
        // Set a backoff criteria to be used when retry-ing
        .setBackoffCriteria(BackoffCriteria.EXPONENTIAL, 30000, TimeUnit.MILLISECONDS)
        // Set additional constraints
        .setConstraints(constraints)
        .build();

यहां मुख्य अंतर यह है कि WorkManager की जॉब हमेशा सभी डिवाइस अपने-आप फिर से चालू हो जाएगा.

अगर आपको PeriodicWorkRequest बनाना है, तो कुछ ऐसा करें:

Kotlin

val constraints: Constraints = TODO("Define constraints as above")
val request: PeriodicWorkRequest =
PeriodicWorkRequestBuilder<MyWorker>(15, TimeUnit.MINUTES)
    // Sets the input data for the ListenableWorker
    .setInputData(input)
    // Other setters
    .build()

Java

import androidx.work.BackoffCriteria;
import androidx.work.Constraints;
import androidx.work.Constraints.Builder;
import androidx.work.NetworkType;
import androidx.work.PeriodicWorkRequest;
import androidx.work.PeriodicWorkRequest.Builder;
import androidx.work.Data;

// Define constraints (as above)
Constraints constraints = ...

PeriodicWorkRequest request =
    // Executes MyWorker every 15 minutes
    new PeriodicWorkRequest.Builder(MyWorker.class, 15, TimeUnit.MINUTES)
        // Sets the input data for the ListenableWorker
        .setInputData(input)
        . // other setters (as above)
        .build();

काम शेड्यूल किया जा रहा है

Worker और WorkRequest तय करने के बाद, अब आप ये काम करने के लिए तैयार हैं काम शेड्यूल करो.

FirebaseJobDispatcher के साथ तय किए गए हर Job में एक tag होता था. इसका इस्तेमाल इन कामों के लिए किया जाता था Job की खास पहचान करें. साथ ही, इससे आवेदन को यह भी बताया गया कि अगर Job का यह इंस्टेंस, setReplaceCurrent पर कॉल करके Job.

Kotlin

val job = dispatcher.newJobBuilder()
    // the JobService that will be called
    .setService(MyService::class.java)
    // uniquely identifies the job
    .setTag("my-unique-tag")
    // don't overwrite an existing job with the same tag
    .setRecurring(false)
    // Other setters...
    .build()

Java

Job myJob = dispatcher.newJobBuilder()
    // the JobService that will be called
    .setService(MyJobService.class)
    // uniquely identifies the job
    .setTag("my-unique-tag")
    // don't overwrite an existing job with the same tag
    .setReplaceCurrent(false)
    // other setters
    // ...

dispatcher.mustSchedule(myJob);

WorkManager का इस्तेमाल करते समय, वही नतीजा मिलता है. इसके लिए, enqueueUniqueWork() और enqueueUniquePeriodicWork() एपीआई (किसी OneTimeWorkRequest और एक PeriodicWorkRequest). ज़्यादा के लिए जानकारी के लिए, WorkManager.enqueueUniqueWork() और WorkManager.enqueueUniquePeriodicWork().

यह कुछ ऐसा दिखेगा:

Kotlin

import androidx.work.*

val request: OneTimeWorkRequest = TODO("A WorkRequest")
WorkManager.getInstance(myContext)
    .enqueueUniqueWork("my-unique-name", ExistingWorkPolicy.KEEP, request)

Java

import androidx.work.ExistingWorkPolicy;
import androidx.work.OneTimeWorkRequest;
import androidx.work.WorkManager;

OneTimeWorkRequest workRequest = // a WorkRequest;
WorkManager.getInstance(myContext)
    // Use ExistingWorkPolicy.REPLACE to cancel and delete any existing pending
    // (uncompleted) work with the same unique name. Then, insert the newly-specified
    // work.
    .enqueueUniqueWork("my-unique-name", ExistingWorkPolicy.KEEP, workRequest);

ध्यान दें: Firebase JobDispatcher में Job टैग, WorkRequest के name में मैप होता है WorkManager के लिए.

काम रद्द किया जा रहा है

FirebaseJobDispatcher के साथ काम रद्द करने के लिए, इनका इस्तेमाल किया जा सकता है:

Kotlin

dispatcher.cancel("my-unique-tag")

Java

dispatcher.cancel("my-unique-tag");

WorkManager का इस्तेमाल करते समय, इनका इस्तेमाल किया जा सकता है:

Kotlin

import androidx.work.WorkManager
WorkManager.getInstance(myContext).cancelUniqueWork("my-unique-name")

Java

import androidx.work.WorkManager;
WorkManager.getInstance(myContext).cancelUniqueWork("my-unique-name");

WorkManager को शुरू किया जा रहा है

आम तौर पर, WorkManager ContentProvider का इस्तेमाल करके अपने-आप शुरू होता है. अगर आपको इस बात पर ज़्यादा कंट्रोल चाहिए कि WorkManager कैसे काम करता है और शेड्यूल कैसे करता है, तो WorkManager के कॉन्फ़िगरेशन और शुरू करने की प्रोसेस को पसंद के मुताबिक किया जा सकता है.