डिस्पैचर सेट अप करना

बेहतर नेविगेशन सिस्टम लागू करने के लिए, आपके ऐप्लिकेशन को बैक जेस्चर और अन्य नेविगेशन सिग्नल को मैनेज करने के लिए, एक सेंट्रलाइज़्ड तरीके की ज़रूरत होती है. इस पेज पर, NavigationEventDispatcher का इस्तेमाल करके, अपने ऐप्लिकेशन में इन नेविगेशन इवेंट को मैनेज करने और डिस्ट्रिब्यूट करने का तरीका बताया गया है.

NavigationEventDispatcher का एलान करना

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

आपको NavigationEventDispatcherOwner के ज़रिए NavigationEventDispatcher इंस्टेंस देने चाहिए. इससे यह पक्का होता है कि आपके ऐप्लिकेशन के अलग-अलग हिस्से, एक ही डिस्पैचर को ऐक्सेस कर सकते हैं. साथ ही, नेविगेशन इवेंट को एक जैसे और व्यवस्थित तरीके से देख सकते हैं.

class MyComponent: NavigationEventDispatcherOwner {
    override val navigationEventDispatcher: NavigationEventDispatcher =
        NavigationEventDispatcher()
}
NavEventSnippets.kt

अगर आप किसी ComponentActivity में हैं, तो अपने डिस्पैचर को लागू करने के बजाय, आपको उपलब्ध कराया गया डिस्पैचर वापस पाया जा सकता है.

class MyCustomActivity : ComponentActivity() {
    fun addMyHandler() {
        // navigationEventDispatcher provided by the ComponentActivity
        navigationEventDispatcher.addHandler(myNavigationEventHandler)
    }
}
NavEventSnippets.kt

NavigationEventInput जोड़ें

हैंडलर को रजिस्टर करने के बाद, अब आपको इवेंट मिलने लगेंगे. हालांकि, आपको वह सोर्स देना होगा जिससे NavigationEventInput के साथ इवेंट जनरेट किए जाते हैं.

NavigationEventInput, प्लैटफ़ॉर्म के हिसाब से काम करने वाला कॉम्पोनेंट है. यह सिस्टम से मिले रॉ इनपुट को लेता है और उसे स्टैंडर्ड NavigationEvent में बदलता है, ताकि उसे NavigationEventDispatcher को भेजा जा सके.

यहां दिए गए उदाहरण में, NavigationEventInput को कस्टम तरीके से लागू करने का तरीका बताया गया है:

public class MyInput : NavigationEventInput() {
    @MainThread
    public fun backStarted(event: NavigationEvent) {
        dispatchOnBackStarted(event)
    }

    @MainThread
    public fun backProgressed(event: NavigationEvent) {
        dispatchOnBackProgressed(event)
    }

    @MainThread
    public fun backCancelled() {
        dispatchOnBackCancelled()
    }

    @MainThread
    public fun backCompleted() {
        dispatchOnBackCompleted()
    }
}
NavEventSnippets.kt

इसके बाद, अपने डिस्पैचर को यह इनपुट दें:

navigationEventDispatcher.addInput(MyInput())
NavEventSnippets.kt

dispose() की मदद से संसाधन मिटाना

डाइनैमिक यूज़र इंटरफ़ेस (यूआई) में मेमोरी लीक को रोकने के लिए, बनाए गए हर NavigationEventDispatcher इंस्टेंस को, dispose() तरीके का इस्तेमाल करके, हाइरार्की से साफ़ तौर पर हटाना होगा. ऐसा तब करना होगा, जब उससे जुड़ा कॉम्पोनेंट डिस्ट्रॉय हो जाए:

navigationEventDispatcher.dispose()
NavEventSnippets.kt

dispose() तरीके से, कैस्केडिंग क्लीनअप किया जाता है. इसमें डिसपैचर और उसके सभी डिसेंडेंट (बच्चे और पोते-पोतियां) को बार-बार हटाया जाता है. इससे यह पक्का किया जाता है कि शेयर किए गए सिस्टम से जुड़े सभी हैंडलर अनरजिस्टर हो जाएं.

डिस्पैचर का क्रम और कंट्रोल

NavigationEventDispatcher में पैरंट-चाइल्ड हैरारकी काम करती है. इससे यूज़र इंटरफ़ेस (यूआई) में गहराई से नेस्ट किए गए कॉम्पोनेंट (जैसे कि नेस्ट किए गए NavHost या डायलॉग) को नेविगेशन इवेंट हैंडलिंग में हिस्सा लेने की अनुमति मिलती है.

चाइल्ड डिस्पैचर बनाना

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

क्रम के हिसाब से चालू करना

डिसपैचर में एक isEnabled प्रॉपर्टी होती है. इसकी मदद से डेवलपर, हैंडलर के पूरे सबट्री को एक साथ चालू या बंद कर सकते हैं.

जब पैरंट डिस्पैचर बंद (isEnabled = false) होता है, तो उस पैरंट और उसके किसी भी चाइल्ड से जुड़े सभी हैंडलर को अनदेखा कर दिया जाएगा. भले ही, वे अलग-अलग तौर पर चालू हों.