काम से जुड़े अनुरोधों के बारे में बताना

शुरुआती निर्देश में आसान WorkRequest बनाने का तरीका बताया गया है और उसे कतार में लगाना.

इस गाइड में, आपको WorkRequest ऑब्जेक्ट को तय करने और पसंद के मुताबिक बनाने का तरीका पता चलेगा इस्तेमाल के सामान्य उदाहरण को हैंडल करने के लिए. जैसे:

• एक बार में किया जाने वाला और बार-बार होने वाला काम शेड्यूल करें
• वाई-फ़ाई या चार्ज करने जैसी काम से जुड़ी पाबंदियां सेट करें
• गारंटी के साथ, काम पूरा होने में कम से कम देरी हो
• फिर से कोशिश करने और बैक-ऑफ़ करने की रणनीतियां सेट करें
• इनपुट डेटा को ऑफ़िस में भेजें
• टैग का इस्तेमाल करके, ग्रुप में साथ मिलकर काम करने की सुविधा

खास जानकारी

WorkManager में WorkRequest की मदद से, ऑफ़िस के बारे में बताया गया है. कार्रवाई करने के लिए WorkManager के साथ किसी भी काम को शेड्यूल करने के लिए, पहले आपको WorkRequest ऑब्जेक्ट ढूंढें और उसे इंक्यू करें.

val myWorkRequest = ...
WorkManager.getInstance(myContext).enqueue(myWorkRequest)

WorkRequest myWorkRequest = ...
WorkManager.getInstance(myContext).enqueue(myWorkRequest);

WorkRequest ऑब्जेक्ट में, वह सारी जानकारी शामिल होती है जो WorkManager को इन कामों के लिए ज़रूरी होती है अपने काम को शेड्यूल करें और चलाएं. इसमें कुछ ऐसी पाबंदियां हैं जिन्हें आपके चलाने के लिए काम करें, देरी या दोहराए जाने वाले अंतराल जैसी जानकारी शेड्यूल करें, पुनः प्रयास करें कॉन्फ़िगरेशन में है और अगर आपका काम इस पर निर्भर करता है, तो इनपुट डेटा को शामिल किया जा सकता है.

WorkRequest खुद भी एक ऐब्स्ट्रैक्ट बेस क्लास है. दो इस क्लास के व्युत्पन्नों को लागू किया जाता है, जिसका इस्तेमाल करके अनुरोध बनाया जा सकता है, OneTimeWorkRequest और PeriodicWorkRequest. जैसा कि उनके नाम से पता चलता है, शेड्यूल करने के लिए OneTimeWorkRequest उपयोगी है बार-बार होने वाला काम नहीं है, जबकि PeriodicWorkRequest इसके लिए ज़्यादा सही है कुछ अंतराल पर दोहराया जाने वाला काम शेड्यूल करना.

एक बार किया जाने वाला काम शेड्यूल करें

आसान काम के लिए, जिसके लिए किसी अतिरिक्त कॉन्फ़िगरेशन की आवश्यकता नहीं होती, स्टैटिक का उपयोग करें तरीका from:

val myWorkRequest = OneTimeWorkRequest.from(MyWork::class.java)

WorkRequest myWorkRequest = OneTimeWorkRequest.from(MyWork.class);

ज़्यादा मुश्किल काम के लिए, बिल्डर का इस्तेमाल किया जा सकता है:

val uploadWorkRequest: WorkRequest =
   OneTimeWorkRequestBuilder<MyWork>()
       // Additional configuration
       .build()

WorkRequest uploadWorkRequest =
   new OneTimeWorkRequest.Builder(MyWork.class)
       // Additional configuration
       .build();

जल्द से जल्द किए जाने वाले काम शेड्यूल करें

WorkManager 2.7.0 ने तेज़ी से काम करने का सिद्धांत पेश किया. इससे आपको WorkManager, सिस्टम को बेहतर कंट्रोल देते हुए ज़रूरी काम पूरा करने के लिए करता है संसाधनों को ऐक्सेस करना.

कम समय में पूरे किए जाने वाले काम को इन विशेषताओं में खास तौर पर शामिल किया गया है:

• अहमियत: जल्द से जल्द काम करने के लिए वे टास्क पूरे किए जा सकते हैं जो उपयोगकर्ता के लिए ज़रूरी हैं या उपयोगकर्ता ने इसकी प्रोसेस शुरू की हो.
• स्पीड: कम समय में किए जाने वाले काम ऐसे छोटे टास्क के लिए सबसे सही होते हैं जो तुरंत शुरू हो जाते हैं और कुछ ही मिनटों में पूरा हो जाता है.
• कोटा: सिस्टम-लेवल का कोटा, जो फ़ोरग्राउंड एक्ज़ीक्यूशन के समय को सीमित करता है यह तय करता है कि जल्द से जल्द जॉब को शुरू किया जा सकता है या नहीं.
• पावर मैनेजमेंट: पावर मैनेजमेंट की पाबंदियां, जैसे कि बैटरी सेवर और बैटरी सेवर की सुविधा का इस्तेमाल करके, तेज़ी से किए जाने वाले काम पर असर पड़ने की संभावना कम होती है.
• इंतज़ार का समय: सिस्टम जल्द से जल्द काम को तुरंत पूरा कर देता है, बशर्ते सिस्टम के मौजूदा वर्कलोड की मदद से ऐसा किया जा सकता है. इसका मतलब है कि इसमें इंतज़ार का समय संवेदनशील होता है और उसे बाद में एक्ज़ीक्यूट करने के लिए शेड्यूल नहीं किया जा सकता.

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

कोटा

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

किसी ऐप्लिकेशन को लागू होने में लगने वाला समय, इस बात पर निर्भर करता है कि स्टैंडबाय बकेट और प्रोसेस का महत्व.

यह तय किया जा सकता है कि जब एक्ज़ीक्यूशन कोटा, जल्द चलने वाला काम तुरंत. ज़्यादा जानकारी के लिए, नीचे दिए गए स्निपेट देखें.

जल्द से जल्द किए जा रहे काम पूरे किए जा रहे हैं

WorkManager 2.7 से, आपका ऐप्लिकेशन setExpedited() को कॉल करके यह एलान कर सकता है जल्द से जल्द जॉब का इस्तेमाल करके, WorkRequest को जल्द से जल्द चलाना चाहिए. कॉन्टेंट बनाने इस कोड स्निपेट का इस्तेमाल करके, setExpedited() को इस्तेमाल करने का उदाहरण दिया गया है:

val request = OneTimeWorkRequestBuilder<SyncWorker>()
    .setExpedited(OutOfQuotaPolicy.RUN_AS_NON_EXPEDITED_WORK_REQUEST)
    .build()

WorkManager.getInstance(context)
    .enqueue(request)

OneTimeWorkRequest request = new OneTimeWorkRequestBuilder<T>()
    .setInputData(inputData)
    .setExpedited(OutOfQuotaPolicy.RUN_AS_NON_EXPEDITED_WORK_REQUEST)
    .build();

इस उदाहरण में, हम OneTimeWorkRequest के एक इंस्टेंस को शुरू करते हैं और setExpedited(). इसके बाद, यह अनुरोध तेज़ी से काम करने की सुविधा के तौर पर काम करता है. अगर कोटा अनुमति देता है, तो यह तुरंत बैकग्राउंड में चलने लगेगा. अगर कोटा में इस्तेमाल किया गया है, तो OutOfQuotaPolicy पैरामीटर से पता चलता है कि अनुरोध को सामान्य, गैर-जल्द काम को चलाया जा सके.

पुराने सिस्टम के साथ काम करने की सुविधा और फ़ोरग्राउंड सेवाएं

जल्द से जल्द जॉब के लिए, पुराने सिस्टम के साथ काम करने की सुविधा को बनाए रखने के लिए, WorkManager Android 12 से पुराने प्लैटफ़ॉर्म के वर्शन पर फ़ोरग्राउंड सेवा चला सकता है. फ़ोरग्राउंड सेवाएं, उपयोगकर्ता को सूचना दिखा सकती हैं.

आपके वर्कर में मौजूद getForegroundInfoAsync() और getForegroundInfo() तरीके WorkManager को setExpedited() को कॉल करने पर सूचना दिखाने की सुविधा को चालू करें Android 12 से पहले वाला था.

किसी भी ListenableWorker को getForegroundInfo तरीका लागू करना होगा, अगर यह अनुरोध करना चाहता है कि यह टास्क, जल्द से जल्द वाले जॉब के तौर पर चले.

Android 12 या उसके बाद के वर्शन को टारगेट करने पर, फ़ोरग्राउंड सेवाएं इन देशों के लिए उपलब्ध रहेंगी setForeground तरीके का इस्तेमाल करके.

वर्कर

कामगारों को यह पता नहीं होता कि वे जो काम कर रहे हैं वह जल्दी हो रहा है या नहीं. लेकिन कर्मचारी Android के कुछ वर्शन पर नोटिफ़िकेशन दिखा सकते हैं, जब WorkRequest को प्रोसेस कर दिया गया है.

इसे चालू करने के लिए, WorkManager getForegroundInfoAsync() तरीका उपलब्ध कराता है, इसे लागू करना ज़रूरी होता है, ताकि WorkManager जहां ज़रूरी हो वहां आपके लिए ForegroundService.

कोरूटीन वर्कर

अगर CoroutineWorker का इस्तेमाल किया जाता है, तो आपको getForegroundInfo() लागू करनी होगी. आप फिर इसे doWork() के अंदर setForeground() को पास करें. ऐसा करने से Android के वर्शन 12 से पहले के वर्शन में मिलने वाली सूचनाओं के लिए.

यह उदाहरण देखें:

  class ExpeditedWorker(appContext: Context, workerParams: WorkerParameters):
   CoroutineWorker(appContext, workerParams) {

   override suspend fun getForegroundInfo(): ForegroundInfo {
       return ForegroundInfo(
           NOTIFICATION_ID, createNotification()
       )
   }

   override suspend fun doWork(): Result {
       TODO()
   }

    private fun createNotification() : Notification {
       TODO()
    }

}

कोटा से जुड़ी नीतियां

आपके पास यह कंट्रोल करने का विकल्प है कि जब आपका ऐप्लिकेशन एक्ज़ीक्यूशन कोटा. जारी रखने के लिए, setExpedited() को पास किया जा सकता है:

• OutOfQuotaPolicy.RUN_AS_NON_EXPEDITED_WORK_REQUEST, जिसकी वजह से जॉब उसे सामान्य काम के अनुरोध के तौर पर चलाया जाता है. ऊपर दिया गया स्निपेट इसे दिखाता है.
• OutOfQuotaPolicy.DROP_WORK_REQUEST: इस वजह से अनुरोध रद्द हो जाता है, अगर: काफ़ी कोटा नहीं है.

सैंपल ऐप्लिकेशन

WorkManager 2.7.0, तेज़ी से किए जाने वाले काम का इस्तेमाल कैसे करता है, इसका पूरा उदाहरण देखने के लिए, GitHub पर WorkManagerSample के ज़रिए.

रुका हुआ काम

सिस्टम दिए गए तेज़ काम को जल्द से जल्द पूरा करने की कोशिश करता है. जॉब शुरू हो जाता है. हालांकि, अन्य तरह की नौकरियों की तरह ही, यह सिस्टम जल्द से जल्द किए जाने वाले नए काम की शुरुआत को टाला जा सकता है, जैसा कि इन मामलों में होता है:

• लोड करें: सिस्टम पर बहुत ज़्यादा लोड है. ऐसा तब हो सकता है, जब बहुत सारे जॉब पर का उपयोग कर रहा है, या जब सिस्टम में पर्याप्त मेमोरी नहीं है.
• कोटा: तेज़ी से काम करने की तय सीमा पार हो गई है. जल्द से जल्द काम करने की सुविधा जो ऐप स्टैंडबाय बकेट पर आधारित कोटा सिस्टम का इस्तेमाल करता है और रोलिंग टाइम विंडो में, प्रोसेस करने में लगने वाला ज़्यादा से ज़्यादा समय. इसके लिए इस्तेमाल किए गए कोटा दूसरी तरह के कामों में इस्तेमाल होने वाले कामों की तुलना में जल्दी किए जाने वाले काम ज़्यादा पाबंदी वाले होते हैं बैकग्राउंड वाली नौकरियां.

समय-समय पर होने वाला काम शेड्यूल करें

आपके ऐप्लिकेशन के लिए, कभी-कभी कुछ काम को समय-समय पर चलाने की ज़रूरत पड़ सकती है. उदाहरण के लिए, हो सकता है कि आप समय-समय पर अपने डेटा का बैकअप लेना चाहें, तो के ऐप्लिकेशन का इस्तेमाल करने या सर्वर पर लॉग अपलोड करने का विकल्प होता है.

यहाँ बताया गया है कि PeriodicWorkRequest का इस्तेमाल करके WorkRequest ऑब्जेक्ट जो समय-समय पर एक्ज़ीक्यूट होता रहता है:

val saveRequest =
       PeriodicWorkRequestBuilderS<aveImageToFileWorker(>1, TimeUnit.HOURS)
    // Additional configuration
           .build()

PeriodicWorkRequest saveRequest =
       new PeriodicWorkRequest.Builder(SaveImageToFileWorker.class, 1, TimeUnit.HOURS)
           // Constraints
           .build();

इस उदाहरण में, काम को एक घंटे के अंतराल में शेड्यूल किया गया है.

इंटरवल पीरियड को, दोहराव के बीच के कम से कम समय के तौर पर जाना जाता है. कॉन्टेंट बनाने वर्कर के काम करने का सटीक समय, कंस्ट्रेंट पर निर्भर करता है जिसे आप अपने WorkRequest ऑब्जेक्ट में इस्तेमाल कर रहे हैं. साथ ही, इसका इस्तेमाल किए गए ऑप्टिमाइज़ेशन के लिए भी किया जा रहा है को ट्रैक करने की सुविधा मिलती है.

ज़रूरत के हिसाब से रन इंटरवल

अगर आपके काम की वजह से, दौड़ने का समय आसान है, तो फ़्लेक्स के अंदर चलने के लिए, आपका PeriodicWorkRequest पीरियड में, जैसा कि पहली इमेज में दिखाया गया है.

पहला डायग्राम. डायग्राम में दोहराव वाले इंटरवल दिखाए गए हैं, जिनमें फ़्लेक्सिबल पीरियड है किस तरह का काम चलाया जा सकता है.

समय-समय पर होने वाले काम को फ़्लेक्सिबल पीरियड के साथ तय करने के लिए, आप flexInterval के साथ PeriodicWorkRequest बनाते समय repeatInterval. फ़्लेक्स पीरियड repeatInterval - flexInterval पर शुरू होता है और इंटरवल के आखिर तक चलता है.

नीचे पिछले 15 महीनों में चलने वाले काम का एक उदाहरण दिया गया है मिनट हर एक घंटे में.

val myUploadWork = PeriodicWorkRequestBuilderS<aveImageToFileWorker(>
       1, TimeUnit.HOURS, // repeatInterval (the period cycle)
       15, TimeUnit.MINUTES) // flexInterval
    .build()

WorkRequest saveRequest =
       new PeriodicWorkRequest.Builder(SaveImageToFileWorker.class,
               1, TimeUnit.HOURS,
               15, TimeUnit.MINUTES)
           .build();

दोहराने का अंतराल इससे ज़्यादा या उसके बराबर होना चाहिए PeriodicWorkRequest.MIN_PERIODIC_INTERVAL_MILLIS और फ़्लेक्स अंतराल इससे ज़्यादा या इसके बराबर होना चाहिए PeriodicWorkRequest.MIN_PERIODIC_FLEX_MILLIS.

समय-समय पर होने वाले काम पर पाबंदियों का असर

समय-समय पर किए जाने वाले काम पर पाबंदियां लागू की जा सकती हैं. उदाहरण के लिए, अपने काम के अनुरोध पर इस तरह से रोक लगाएं कि काम सिर्फ़ तब चले, जब उपयोगकर्ता डिवाइस चार्ज हो रहा है. इस मामले में, भले ही तय किया गया दोहराव वाला इंटरवल पास हो, जब तक यह शर्त पूरी नहीं हो जाती, तब तक PeriodicWorkRequest नहीं चलेगा. यह काम कर सका आपके काम की किसी खास प्रोसेस में देरी हो सकती है या उसे स्किप भी किया जा सकता है, दौड़ने के इंटरवल में शर्तें पूरी नहीं होती हैं.

काम से जुड़े कंस्ट्रेंट

कंस्ट्रेंट से यह पक्का होता है कि सही शर्तें पूरी होने तक काम टाला जाए. WorkManager पर ये सीमाएं लागू होती हैं.

कंस्ट्रेंट का एक सेट बनाने और उसे कुछ काम से जोड़ने के लिए, Contraints.Builder() का इस्तेमाल करके, Constraints इंस्टेंस को अपने WorkRequest.Builder().

उदाहरण के लिए, नीचे दिया गया कोड काम का अनुरोध बनाता है, जो सिर्फ़ तब काम करता है, जब उपयोगकर्ता का डिवाइस चार्ज हो रहा हो और वाई-फ़ाई से कनेक्ट हो:

val constraints = Constraints.Builder()
   .setRequiredNetworkType(NetworkType.UNMETERED)
   .setRequiresCharging(true)
   .build()

val myWorkRequest: WorkRequest =
   OneTimeWorkRequestBuilderM<yWork(>)
       .setConstraints(constraints)
       .build()

Constraints constraints = new Constraints.Builder()
       .setRequiredNetworkType(NetworkType.UNMETERED)
       .setRequiresCharging(true)
       .build();

WorkRequest myWorkRequest =
       new OneTimeWorkRequest.Builder(MyWork.class)
               .setConstraints(constraints)
               .build();

जब एक से ज़्यादा कंस्ट्रेंट मौजूद हों, तो आपका काम सिर्फ़ तब चलेगा, जब शर्तें पूरी की गईं.

अगर आपका काम चलने के दौरान कंस्ट्रेंट पूरा नहीं हो पाता है, तो WorkManager आपके कर्मचारी को काम करने से रोक देगा. उसके बाद काम को फिर से करने की कोशिश की जाएगी जब सभी शर्तें पूरी की गईं.

देरी से हुआ काम

ऐसी स्थिति में जब आपके काम में कोई कंस्ट्रेंट न हो या सभी कंस्ट्रेंट जब आपका काम कतार में लगा हो, तब सिस्टम काम को चलाने का विकल्प चुन सकता है तुरंत. अगर आपको काम तुरंत नहीं चलाना है, तो आपका काम कम से कम शुरुआती देरी के बाद शुरू हो.

यहां एक उदाहरण दिया गया है. इसमें बताया गया है कि अपने काम को उसके कम से कम 10 मिनट बाद चलाने के लिए कैसे सेट किया जा सकता है कतार में रखा गया है.

val myWorkRequest = OneTimeWorkRequestBuilderM<yWork(>)
   .setInitialDelay(10, TimeUnit.MINUTES)
   .build()

WorkRequest myWorkRequest =
      new OneTimeWorkRequest.Builder(MyWork.class)
               .setInitialDelay(10, TimeUnit.MINUTES)
               .build();

उदाहरण में बताया गया है कि OneTimeWorkRequest, आप PeriodicWorkRequest. इस मामले में, समय-समय पर किए जाने वाले आपके काम का सिर्फ़ पहला बार देरी हो सकती है.

फिर से कोशिश करने और बैकऑफ़ की नीति

अगर आप चाहते हैं कि WorkManager आपके काम को फिर से करे, तो आपके पास वापस करने का विकल्प होता है आपके वर्कर से Result.retry(). तब आपका काम बैकऑफ़ में देरी और बैकऑफ़ की नीति के हिसाब से, फिर से शेड्यूल किया गया.

• बैकऑफ़ में देरी से पता चलता है कि फिर से कोशिश करने से पहले, कम से कम कितने समय तक इंतज़ार करना पड़ सकता है का जवाब देने की कोशिश करेंगे. यह वैल्यू 10 सेकंड से कम की नहीं हो सकती (या MIN_BACKOFF_MILLIS).

• बैकऑफ़ से जुड़ी नीति बताती है कि फिर से कोशिश करनी होगी. WorkManager, बैकऑफ़ से जुड़ी दो नीतियों के साथ काम करता है. LINEAR और EXPONENTIAL.

काम के हर अनुरोध में, बैकऑफ़ की नीति और बैकऑफ़ में देरी होती है. डिफ़ॉल्ट नीति 30 सेकंड की देरी से EXPONENTIAL है, लेकिन आप इसे काम के अनुरोध का कॉन्फ़िगरेशन.

यहां बैकऑफ़ में देरी और नीति को पसंद के मुताबिक बनाने का एक उदाहरण दिया गया है.

val myWorkRequest = OneTimeWorkRequestBuilderM<yWork(>)
   .setBackoffCriteria(
       BackoffPolicy.LINEAR,
       OneTimeWorkRequest.MIN_BACKOFF_MILLIS,
       TimeUnit.MILLISECONDS)
   .build()

WorkRequest myWorkRequest =
       new OneTimeWorkRequest.Builder(MyWork.class)
               .setBackoffCriteria(
                       BackoffPolicy.LINEAR,
                       OneTimeWorkRequest.MIN_BACKOFF_MILLIS,
                       TimeUnit.MILLISECONDS)
               .build();

इस उदाहरण में, बैकऑफ़ के लिए तय की गई कम से कम देरी को, अनुमति वाली कम से कम वैल्यू पर सेट किया गया है. 10 सेकंड. नीति LINEAR है, इसलिए फिर से कोशिश करने का इंटरवल इतना बढ़ जाएगा हर नई कोशिश के साथ करीब 10 सेकंड का समय लगेगा. उदाहरण के लिए, पहली बार Result.retry() को पूरा करने के 10 सेकंड बाद, फिर से कोशिश की जाएगी, अगर काम लगातार जारी रहता है, तो 20, 30, 40 वगैरह. फिर से कोशिश करने के बाद, आपको Result.retry() देने होंगे. अगर बैकऑफ़ नीति को इस पर सेट किया गया था EXPONENTIAL, फिर से कोशिश करने की अवधि 20, 40, 80 वगैरह के करीब होगी चालू करें.

ऑफ़िस का पता टैग करें

काम के हर अनुरोध का एक यूनीक आइडेंटिफ़ायर होता है, जिसका इस्तेमाल जो बाद में उस काम को रद्द करने या उसकी प्रोग्रेस की निगरानी करने के लिए काम करे.

अगर आपके पास तार्किक रूप से संबंधित काम का एक समूह है, तो आपको यह काम करने में भी मदद मिल सकती है: टैग करते हैं. टैगिंग आपको काम के एक ग्रुप के साथ काम करने की सुविधा देती है अनुरोध किए जा सकते हैं.

उदाहरण के लिए, WorkManager.cancelAllWorkByTag(String) रद्द करता है किसी खास टैग वाले सभी काम के अनुरोध, और WorkManager.getWorkInfosByTag(String), WorkInfo ऑब्जेक्ट जिसका इस्तेमाल काम की मौजूदा स्थिति का पता लगाने के लिए किया जा सकता है.

नीचे दिया गया कोड दिखाता है कि "क्लीनअप" कैसे जोड़ा जा सकता है अपने काम में टैग करें:

val myWorkRequest = OneTimeWorkRequestBuilderM<yWork(>)
   .addTag("cleanup")
   .build()

WorkRequest myWorkRequest =
       new OneTimeWorkRequest.Builder(MyWork.class)
       .addTag("cleanup")
       .build();

आखिर में, एक ही काम के अनुरोध में कई टैग जोड़े जा सकते हैं. आंतरिक रूप से ये टैग, स्ट्रिंग के सेट के तौर पर सेव किए जाते हैं. से संबद्ध टैग का सेट पाने के लिए WorkRequest पर जाकर, WorkInfo.getTag() का इस्तेमाल किया जा सकता है.

अपनी Worker क्लास से, आप इसके टैग का सेट इसके ज़रिए वापस ला सकते हैं ListenableWorker.getTag().

इनपुट डेटा असाइन करें

आपके काम को पूरा होने के लिए इनपुट डेटा की ज़रूरत हो सकती है. उदाहरण के लिए, मौजूदा इमेज अपलोड करने वाले हैंडल के लिए, इमेज के यूआरआई को इस फ़ॉर्मैट में अपलोड करना पड़ सकता है इनपुट.

इनपुट वैल्यू, Data ऑब्जेक्ट में की-वैल्यू पेयर के तौर पर स्टोर की जाती हैं इसे काम के अनुरोध पर सेट किया जा सकता है. WorkManager, इनपुट Data को इस पते पर डिलीवर करेगा आपके काम को उस समय लागू करता है जब वह काम को पूरा करता है. Worker क्लास ऐक्सेस कर सकती है Worker.getInputData() को कॉल करके इनपुट आर्ग्युमेंट को जोड़ा जा सकता है. कॉन्टेंट बनाने नीचे दिए गए कोड से पता चलता है कि Worker इंस्टेंस कैसे बनाया जा सकता है के लिए इनपुट डेटा और उसे आपके काम के अनुरोध में भेजने का तरीका ज़रूरी है.

// Define the Worker requiring input
class UploadWork(appContext: Context, workerParams: WorkerParameters)
   : Worker(appContext, workerParams) {

   override fun doWork(): Result {
       val imageUriInput =
           inputData.getString("IMAGE_URI") ?: return Result.failure()

       uploadFile(imageUriInput)
       return Result.success()
   }
   ...
}

// Create a WorkRequest for your Worker and sending it input
val myUploadWork = OneTimeWorkRequestBuilderU<ploadWork(>)
   .setInputData(workDataOf(
       "IMAGE_URI" to "http://..."
   ))
   .build()

// Define the Worker requiring input
public class UploadWork extends Worker {

   public UploadWork(Context appContext, WorkerParameters workerParams) {
       super(appContext, workerParams);
   }

   @NonNull
   @Override
   public Result doWork() {
       String imageUriInput = getInputData().getString("IMAGE_URI");
       if(imageUriInput == null) {
           return Result.failure();
       }

       uploadFile(imageUriInput);
       return Result.success();
   }
   ...
}

// Create a WorkRequest for your Worker and sending it input
WorkRequest myUploadWork =
      new OneTimeWorkRequest.Builder(UploadWork.class)
           .setInputData(
               new Data.Builder()
                   .putString("IMAGE_URI", "http://...")
                   .build()
           )
           .build();

इसी तरह, Data क्लास का इस्तेमाल रिटर्न वैल्यू पाने के लिए किया जा सकता है. इनपुट और आउटपुट डेटा के बारे में ज़्यादा जानकारी सेक्शन इनपुट पैरामीटर और वैल्यू दिखाई गई हों.

अगले चरण

राज्य और निगरानी पेज पर, आपको काम की स्थितियों के बारे में ज़्यादा जानकारी मिलेगी साथ ही, अपने काम की प्रोग्रेस को मॉनिटर करने का तरीका भी जानें.