चेन बनाने का काम

WorkManager की मदद से, एक-दूसरे पर निर्भर कई टास्क बनाए जा सकते हैं और उन्हें सूची में जोड़ा जा सकता है. साथ ही, यह तय किया जा सकता है कि उन्हें किस क्रम में चलाया जाए. यह सुविधा खास तौर पर तब काम आती है, जब आपको किसी खास क्रम में कई टास्क चलाने हों.

काम की चेन बनाने के लिए, WorkManager.beginWith(OneTimeWorkRequest) या WorkManager.beginWith(List<OneTimeWorkRequest>) का इस्तेमाल किया जा सकता है. इनमें से हर एक, WorkContinuation का एक इंस्टेंस दिखाता है.

इसके बाद, WorkContinuation का इस्तेमाल करके, then(OneTimeWorkRequest) या then(List<OneTimeWorkRequest>) की मदद से, डिपेंडेंट OneTimeWorkRequest इंस्टेंस जोड़े जा सकते हैं.

WorkContinuation.then(...) को हर बार कॉल करने पर, WorkContinuation का एक नया इंस्टेंस मिलता है. अगर OneTimeWorkRequest इंस्टेंस का List जोड़ा जाता है, तो ये अनुरोध एक साथ चल सकते हैं.

आखिर में, WorkContinuation.enqueue() तरीके का इस्तेमाल करके, WorkContinuation की चेन को enqueue() किया जा सकता है.

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

WorkManager.getInstance(myContext)
    // Candidates to run in parallel.
    .beginWith(listOf(plantName1, plantName2, plantName3))
    // Dependent work (only runs after all previous work in chain).
    .then(cache)
    .then(upload)
    // Call enqueue to kick things off.
    .enqueue()

इनपुट मर्जर

OneTimeWorkRequest इंस्टेंस को चेन करने पर, पैरंट वर्क रिक्वेस्ट का आउटपुट, चिल्ड्रन वर्क रिक्वेस्ट के इनपुट के तौर पर पास किया जाता है. इसलिए, ऊपर दिए गए उदाहरण में, plantName1, plantName2, और plantName3 के आउटपुट, cache अनुरोध के इनपुट के तौर पर पास किए जाएंगे.

एक से ज़्यादा पैरंट वर्क रिक्वेस्ट से मिले इनपुट को मैनेज करने के लिए, WorkManager InputMerger का इस्तेमाल करता है.

WorkManager दो तरह के InputMerger उपलब्ध कराता है:

  • OverwritingInputMerger सभी इनपुट की सभी कुंजियों को आउटपुट में जोड़ने की कोशिश करता है. अगर कोई समस्या आती है, तो यह पहले से सेट की गई कुंजियों को ओवरराइट कर देता है.

  • ArrayCreatingInputMerger इनपुट को मर्ज करने की कोशिश करता है. साथ ही, ज़रूरत पड़ने पर अरे बनाता है.

अगर आपके पास इस्तेमाल का कोई खास उदाहरण है, तो InputMerger की सबक्लास बनाकर, अपना कोड लिखा जा सकता है.

OverwritingInputMerger

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

उदाहरण के लिए, अगर प्लांट के हर इनपुट में एक ऐसी कुंजी है जो उनके संबंधित वैरिएबल के नामों ("plantName1", "plantName2", और "plantName3") से मेल खाती है, तो cache वर्कर को पास किए गए डेटा में तीन कुंजी-वैल्यू पेयर होंगे.

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

अगर कोई समस्या आती है, तो टास्क पूरा करने वाला आखिरी वर्कर “जीतता है” और उसकी वैल्यू cache को पास कर दी जाती है.

इस डायग्राम में तीन जॉब दिखाए गए हैं. इनमें से हर जॉब, चेन में मौजूद अगले जॉब को आउटपुट पास कर रहा है. इस मामले में, दो जॉब एक ही कुंजी के साथ आउटपुट जनरेट करते हैं. इस वजह से, अगले जॉब को दो की/वैल्यू पेयर मिलते हैं. इनमें से एक आउटपुट को हटा दिया जाता है.

आपके काम के अनुरोध एक साथ चलते हैं. इसलिए, इस बात की कोई गारंटी नहीं है कि वे किस क्रम में चलेंगे. ऊपर दिए गए उदाहरण में, plantName1 में "tulip" या "elm" में से कोई एक वैल्यू हो सकती है. यह इस बात पर निर्भर करता है कि कौनसी वैल्यू आखिर में लिखी गई है. अगर आपको लगता है कि कुंजी का कोई विरोध हो सकता है और आपको मर्ज किए गए डेटा में सभी आउटपुट डेटा को सुरक्षित रखना है, तो ArrayCreatingInputMerger एक बेहतर विकल्प हो सकता है.

ArrayCreatingInputMerger

ऊपर दिए गए उदाहरण के लिए, मान लें कि हमें पौधे के नाम वाले सभी वर्कर के आउटपुट को सुरक्षित रखना है. इसके लिए, हमें ArrayCreatingInputMerger का इस्तेमाल करना चाहिए.

val cache: OneTimeWorkRequest = OneTimeWorkRequestBuilder<PlantWorker>()
    .setInputMerger(ArrayCreatingInputMerger::class)
    .setConstraints(constraints)
    .build()

ArrayCreatingInputMerger हर कुंजी को एक कलेक्शन के साथ जोड़ता है. अगर हर कुंजी यूनीक है, तो आपका नतीजा एक एलिमेंट वाले कलेक्शन की सीरीज़ होगी.

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

अगर कोई की (कुंजी) आपस में टकराती है, तो उससे जुड़ी वैल्यू को एक कलेक्शन में एक साथ ग्रुप किया जाता है.

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

चेनिंग और काम करने की स्थितियां

OneTimeWorkRequest की चेन, क्रम से तब तक चलती हैं, जब तक उनका काम पूरा नहीं हो जाता. इसका मतलब है कि वे Result.success() दिखाती हैं. काम के अनुरोध, चलने के दौरान फ़ेल हो सकते हैं या रद्द किए जा सकते हैं. इसका असर, उन पर निर्भर काम के अनुरोधों पर पड़ता है.

जब काम के अनुरोधों की चेन में पहला OneTimeWorkRequest सूची में शामिल किया जाता है, तो काम के बाद के सभी अनुरोध तब तक ब्लॉक रहते हैं, जब तक कि पहले अनुरोध का काम पूरा नहीं हो जाता.

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

सूची में शामिल होने और काम से जुड़ी सभी शर्तें पूरी होने के बाद, काम का पहला अनुरोध शुरू होता है. अगर रूट OneTimeWorkRequest या List<OneTimeWorkRequest> में काम पूरा हो जाता है (यानी कि यह Result.success() दिखाता है), तो डिपेंडेंट वर्क रिक्वेस्ट के अगले सेट को सूची में जोड़ दिया जाएगा.

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

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

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

जॉब की चेन दिखाने वाला डायग्राम. कोई जॉब पूरी नहीं हो सकी, लेकिन उसके लिए बैकऑफ़ नीति तय की गई थी. कुछ समय बाद, वह जॉब फिर से चलाया जाएगा. चेन में इसके बाद वाले जॉब तब तक ब्लॉक रहते हैं, जब तक यह जॉब पूरा नहीं हो जाता.

फिर से कोशिश करने की कस्टम रणनीतियों को तय करने के बारे में ज़्यादा जानने के लिए, फिर से कोशिश करने और बैकऑफ़ करने की नीति देखें.

अगर फिर से कोशिश करने की नीति तय नहीं की गई है या खत्म हो गई है या फिर किसी वजह से OneTimeWorkRequest, Result.failure() दिखाता है, तो उस काम के अनुरोध और उस पर निर्भर सभी अनुरोधों को FAILED. के तौर पर मार्क कर दिया जाता है

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

OneTimeWorkRequest को रद्द करने पर भी यही लॉजिक लागू होता है. किसी भी डिपेंडेंट वर्क रिक्वेस्ट को भी CANCELLED के तौर पर मार्क किया जाता है और उनका काम पूरा नहीं किया जाएगा.

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

ध्यान दें कि अगर आपने काम के अनुरोधों की ऐसी चेन में और अनुरोध जोड़े हैं जो पूरी नहीं हो पाई है या जिसमें काम के अनुरोध रद्द कर दिए गए हैं, तो जोड़े गए नए अनुरोध को भी क्रमशः FAILED या CANCELLED के तौर पर मार्क किया जाएगा. अगर आपको किसी मौजूदा चेन के काम को आगे बढ़ाना है, तो ExistingWorkPolicy में APPEND_OR_REPLACE देखें.

काम के अनुरोधों की चेन बनाते समय, एक-दूसरे पर निर्भर काम के अनुरोधों के लिए, फिर से कोशिश करने की नीतियां तय की जानी चाहिए. इससे यह पक्का किया जा सकेगा कि काम हमेशा समय पर पूरा हो. काम के अनुरोध पूरे न होने पर, चेन अधूरी रह सकती हैं और/या अनचाही स्थिति पैदा हो सकती है.

ज़्यादा जानकारी के लिए, काम को रद्द करना और रोकना लेख पढ़ें.