जेटपैक नेविगेशन को नेविगेशन के लिए लिखने की सुविधा पर माइग्रेट करें

Navigation Compose API की मदद से, Compose ऐप्लिकेशन में कंपोज़ेबल के बीच नेविगेट किया जा सकता है. साथ ही, Jetpack Navigation के कॉम्पोनेंट, इन्फ़्रास्ट्रक्चर, और सुविधाओं का फ़ायदा लिया जा सकता है.

इस पेज पर, फ़्रैगमेंट पर आधारित Jetpack Navigation से Navigation Compose पर माइग्रेट करने का तरीका बताया गया है. यह Jetpack Compose में, व्यू पर आधारित यूज़र इंटरफ़ेस (यूआई) के बड़े माइग्रेशन का हिस्सा है.

माइग्रेशन के लिए ज़रूरी शर्तें

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

माइग्रेट करने का तरीका

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

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

Navigation Compose पर माइग्रेट करने के लिए, यह तरीका अपनाएं:

  1. अपने ऐप्लिकेशन में Navigation Compose डिपेंडेंसी जोड़ें.
  2. एक App-level कंपोज़ेबल बनाएं और उसे Compose के एंट्री पॉइंट के तौर पर अपने Activity में जोड़ें. साथ ही, व्यू लेआउट के सेटअप को बदलें:

    class SampleActivity : ComponentActivity() {
    
        override fun onCreate(savedInstanceState: Bundle?) {
            super.onCreate(savedInstanceState)
            // setContentView<ActivitySampleBinding>(this, R.layout.activity_sample)
            setContent {
                SampleApp(/* ... */)
            }
        }
    }

  3. हर नेविगेशन डेस्टिनेशन के लिए टाइप बनाएं. ऐसे डेस्टिनेशन के लिए data object का इस्तेमाल करें जिनके लिए किसी डेटा की ज़रूरत नहीं होती. साथ ही, ऐसे डेस्टिनेशन के लिए data class या class का इस्तेमाल करें जिनके लिए डेटा की ज़रूरत होती है.

    @Serializable data object First
    @Serializable data class Second(val id: String)
    @Serializable data object Third
    

  4. NavController को ऐसी जगह पर सेट अप करें जहां से इसे रेफ़रंस के तौर पर इस्तेमाल करने वाले सभी कंपोज़ेबल इसे ऐक्सेस कर सकें. आम तौर पर, यह आपके App कंपोज़ेबल के अंदर होता है. यह तरीका, स्टेट होइस्टिंग के सिद्धांतों का पालन करता है. साथ ही, इसकी मदद से NavController को सोर्स ऑफ़ ट्रुथ के तौर पर इस्तेमाल किया जा सकता है. इससे कंपोज़ेबल स्क्रीन के बीच नेविगेट करने और पिछली गतिविधियों को बनाए रखने में मदद मिलती है:

    @Composable
    fun SampleApp() {
        val navController = rememberNavController()
        // ...
    }

  5. App कंपोज़ेबल के अंदर अपने ऐप्लिकेशन का NavHost बनाएं और navController पास करें:

    @Composable
    fun SampleApp() {
        val navController = rememberNavController()
    
        SampleNavHost(navController = navController)
    }
    
    @Composable
    fun SampleNavHost(
        navController: NavHostController
    ) {
        NavHost(navController = navController, startDestination = First) {
            // ...
        }
    }

  6. अपना नेविगेशन ग्राफ़ बनाने के लिए, composable डेस्टिनेशन जोड़ें. अगर हर स्क्रीन को पहले ही Compose पर माइग्रेट कर दिया गया है, तो इस चरण में सिर्फ़ इन स्क्रीन कंपोज़ेबल को आपके फ़्रैगमेंट से composable डेस्टिनेशन में एक्सट्रैक्ट करना शामिल है:

    class FirstFragment : Fragment() {
    
        override fun onCreateView(
            inflater: LayoutInflater,
            container: ViewGroup?,
            savedInstanceState: Bundle?
        ): View {
            return ComposeView(requireContext()).apply {
                setContent {
                    // FirstScreen(...) EXTRACT FROM HERE
                }
            }
        }
    }
    
    @Composable
    fun SampleNavHost(
        navController: NavHostController
    ) {
        NavHost(navController = navController, startDestination = First) {
            composable<First> {
                FirstScreen(/* ... */) // EXTRACT TO HERE
            }
            composable<Second> {
                SecondScreen(/* ... */)
            }
            // ...
        }
    }

  7. अगर आपने Compose यूज़र इंटरफ़ेस (यूआई) को आर्किटेक्ट करने के बारे में दिए गए दिशा-निर्देशों का पालन किया है, तो आपको पता होगा कि ViewModel और नेविगेशन इवेंट को कंपोज़ेबल में कैसे पास किया जाना चाहिए. इसके बाद, आपको हर स्क्रीन कंपोज़ेबल को ViewModel उपलब्ध कराने के तरीके में बदलाव करना होगा. अक्सर, hiltViewModel का इस्तेमाल करके, Compose और Navigation के साथ Hilt इंजेक्शन और उसके इंटिग्रेशन पॉइंट का इस्तेमाल किया जा सकता है:

    @Composable
    fun FirstScreen(
        // viewModel: FirstViewModel = viewModel(),
        viewModel: FirstViewModel = hiltViewModel(),
        onButtonClick: () -> Unit = {},
    ) {
        // ...
    }

  8. सभी findNavController() नेविगेशन कॉल को navController वाले कॉल से बदलें. साथ ही, इन्हें पूरे navController को पास करने के बजाय, हर कंपोज़ेबल स्क्रीन पर नेविगेशन इवेंट के तौर पर पास करें. यह तरीका, कंपोज़ेबल फ़ंक्शन से कॉलर को इवेंट दिखाने के सबसे सही तरीकों का पालन करता है. साथ ही, navController को एकमात्र भरोसेमंद सोर्स के तौर पर बनाए रखता है.

    किसी डेस्टिनेशन के लिए तय की गई रूट क्लास का इंस्टेंस बनाकर, उस डेस्टिनेशन को डेटा भेजा जा सकता है. इसके बाद, इसे डेस्टिनेशन पर पिछली गतिविधियों की एंट्री से सीधे तौर पर या SavedStateHandle.toRoute() का इस्तेमाल करके, ViewModel से हासिल किया जा सकता है.

    @Composable
    fun SampleNavHost(
        navController: NavHostController
    ) {
        NavHost(navController = navController, startDestination = First) {
            composable<First> {
                FirstScreen(
                    onButtonClick = {
                        // findNavController().navigate(firstScreenToSecondScreenAction)
                        navController.navigate(Second(id = "ABC"))
                    }
                )
            }
            composable<Second> { backStackEntry ->
                val secondRoute = backStackEntry.toRoute<Second>()
                SecondScreen(
                    id = secondRoute.id,
                    onIconClick = {
                        // findNavController().navigate(secondScreenToThirdScreenAction)
                        navController.navigate(Third)
                    }
                )
            }
            // ...
        }
    }

  9. सभी फ़्रैगमेंट, काम के एक्सएमएल लेआउट, ग़ैर-ज़रूरी नेविगेशन, और अन्य संसाधन हटाएं. साथ ही, पुराने फ़्रैगमेंट और Jetpack नेविगेशन डिपेंडेंसी हटाएं.

सेटअप से जुड़े दस्तावेज़ में, आपको Navigation Compose से जुड़ी ज़्यादा जानकारी के साथ-साथ, यही तरीका भी मिलेगा.

इस्तेमाल के सामान्य उदाहरण

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

माइग्रेट करते समय, आम तौर पर ये काम किए जाते हैं:

इस्तेमाल के इन उदाहरणों के बारे में ज़्यादा जानकारी के लिए, Compose की मदद से नेविगेट करना लेख पढ़ें.

नेविगेट करते समय मुश्किल डेटा को वापस पाना

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

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

सीमाएं

इस सेक्शन में, Navigation Compose की मौजूदा सीमाओं के बारे में बताया गया है.

Navigation Compose पर धीरे-धीरे माइग्रेट करना

फ़िलहाल, अपने कोड में डेस्टिनेशन के तौर पर फ़्रैगमेंट का इस्तेमाल करते समय, Navigation Compose का इस्तेमाल नहीं किया जा सकता. Navigation Compose का इस्तेमाल शुरू करने के लिए, आपके सभी डेस्टिनेशन कंपोज़ेबल होने चाहिए. आप इस सुविधा के अनुरोध को Issue Tracker पर ट्रैक कर सकते हैं.

ट्रांज़िशन ऐनिमेशन

Navigation 2.7.0-alpha01 से, कस्टम ट्रांज़िशन सेट करने की सुविधा अब सीधे NavHost में काम करती है. पहले यह सुविधा AnimatedNavHost में काम करती थी. ज़्यादा जानकारी के लिए, रिलीज़ नोट पढ़ें.

ज़्यादा जानें

Navigation Compose पर माइग्रेट करने के बारे में ज़्यादा जानने के लिए, ये संसाधन देखें:

  • Navigation Compose कोडलैब: कोडलैब की मदद से, Navigation Compose के बारे में बुनियादी जानकारी पाएं.
  • Now in Android रिपॉज़िटरी: यह पूरी तरह से काम करने वाला Android ऐप्लिकेशन है. इसे Kotlin और Jetpack Compose का इस्तेमाल करके बनाया गया है. यह Android डिज़ाइन और डेवलपमेंट के सबसे सही तरीकों का पालन करता है. इसमें Navigation Compose भी शामिल है.
  • Sunflower को Jetpack Compose पर माइग्रेट करना: यह एक ब्‍लॉग पोस्‍ट है, जिसमें Sunflower सैंपल के तौर पर मिले ऐप्लिकेशन को व्यू से Compose पर माइग्रेट करने की प्रोसेस के बारे में बताया गया है. इसमें Navigation Compose पर माइग्रेट करने की प्रोसेस भी शामिल है.
  • हर स्क्रीन के लिए Jetnews: यह एक ब्लॉग पोस्ट है, जिसमें Jetnews के सैंपल को Jetpack Compose और Navigation Compose की मदद से, सभी स्क्रीन पर काम करने के लिए, रीफ़ैक्टर करने और माइग्रेट करने के बारे में बताया गया है.