Kotlin DSL और नेविगेशन कंपोज़ में सुरक्षा टाइप करें

नेविगेशन ग्राफ़ के लिए कंपाइल-टाइम टाइप सेफ़्टी देने के लिए, पहले से मौजूद टाइप सेफ़ एपीआई का इस्तेमाल किया जा सकता है. ये एपीआई तब उपलब्ध होते हैं, जब आपका ऐप्लिकेशन Navigation Compose या Navigation Kotlin DSL का इस्तेमाल करता हो. ये Navigation 2.8.0 से उपलब्ध हैं.

ये एपीआई, Safe Args के बराबर हैं. Safe Args, एक्सएमएल का इस्तेमाल करके बनाए गए नेविगेशन ग्राफ़ के लिए उपलब्ध होता है.

रास्ते तय करना

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

सीरियलाइज़ किए जा सकने वाले ऑब्जेक्ट तय करने के लिए, @Serializable एनोटेशन का इस्तेमाल करें. यह एनोटेशन, Kotlin Serialization प्लगिन से मिलता है. इन डिपेंडेंसी को जोड़कर, इस प्लगिन को अपने प्रोजेक्ट में जोड़ा जा सकता है.

अपने रास्ते के लिए किस तरह के मोड का इस्तेमाल करना है, यह तय करने के लिए यहां दिए गए नियमों का पालन करें:

  • ऑब्जेक्ट: बिना किसी तर्क के रास्तों के लिए ऑब्जेक्ट का इस्तेमाल करें.
  • क्लास: आर्ग्युमेंट वाली राउटिंग के लिए, क्लास या डेटा क्लास का इस्तेमाल करें.
  • KClass<T>: इसका इस्तेमाल तब करें, जब आपको आर्ग्युमेंट पास करने की ज़रूरत न हो. जैसे, पैरामीटर के बिना कोई क्लास या ऐसी क्लास जहां सभी पैरामीटर की डिफ़ॉल्ट वैल्यू हों
    1. उदाहरण के लिए: Profile::class

सभी मामलों में, ऑब्जेक्ट या क्लास को क्रम से लगाया जा सकता है.

उदाहरण:

// Define a home route that doesn't take any arguments
@Serializable
object Home

// Define a profile route that takes an ID
@Serializable
data class Profile(val id: String)

अपना ग्राफ़ बनाना

इसके बाद, आपको नेविगेशन ग्राफ़ तय करना होगा. अपने नेविगेशन ग्राफ़ में कंपोज़ेबल को डेस्टिनेशन के तौर पर तय करने के लिए, composable() फ़ंक्शन का इस्तेमाल करें.

NavHost(navController, startDestination = Home) {
     composable<Home> {
         HomeScreen(onNavigateToProfile = { id ->
             navController.navigate(Profile(id))
         })
     }
     composable<Profile> { backStackEntry ->
         val profile: Profile = backStackEntry.toRoute()
         ProfileScreen(profile.id)
     }
}

इस उदाहरण में, इन बातों का ध्यान रखें:

  • composable() एक टाइप पैरामीटर लेता है. इसका मतलब है कि composable<Profile>.
  • डेस्टिनेशन का टाइप तय करना, composable("profile") में route string पास करने से ज़्यादा बेहतर तरीका है.
  • रूट क्लास, हर नेविगेशन आर्ग्युमेंट के टाइप को val id: String के तौर पर तय करता है. इसलिए, NavArgument की ज़रूरत नहीं होती.
  • प्रोफ़ाइल रूट के लिए, toRoute() एक्सटेंशन मेथड, NavBackStackEntry और उसके आर्ग्युमेंट से Profile ऑब्जेक्ट को फिर से बनाता है.

अपने ग्राफ़ को डिज़ाइन करने के बारे में ज़्यादा जानने के लिए, नेविगेशन ग्राफ़ डिज़ाइन करना पेज देखें.

ViewModel में आर्ग्युमेंट ऐक्सेस करना

ViewModel में टाइप से सुरक्षित किसी रूट से आर्ग्युमेंट ऐक्सेस करने के लिए, SavedStateHandle से रूट को वापस पाया जा सकता है. इसके लिए, SavedStateHandle.toRoute<T>() को कॉल करें. यहां T आपकी रूट क्लास है:

class ProfileViewModel(
    savedStateHandle: SavedStateHandle
) : ViewModel() {
    private val profile = savedStateHandle.toRoute<Profile>()
    private val userInfo: Flow<UserInfo> = userInfoRepository.getUserInfo(profile.id)
}

आखिर में, रूट का इंस्टेंस पास करके, navigate() फ़ंक्शन का इस्तेमाल करके, कंपोज़ेबल पर नेविगेट किया जा सकता है:

navController.navigate(Profile(id = 123))

इससे उपयोगकर्ता, नेविगेशन ग्राफ़ में मौजूद composable<Profile> डेस्टिनेशन पर पहुंच जाता है. नेविगेशन के किसी भी आर्ग्युमेंट, जैसे कि id को NavBackStackEntry.toRoute का इस्तेमाल करके Profile को फिर से बनाकर और उसकी प्रॉपर्टी पढ़कर हासिल किया जा सकता है.

अन्य संसाधन