नेविगेशन कोड को मॉड्यूल में बांटना

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

खास जानकारी

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

अपने नेविगेशन कोड को मॉड्यूल में बांटने के लिए, यह तरीका अपनाएं:

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

एपीआई और लागू करने के सबमॉड्यूल में सुविधाओं को अलग-अलग करें

अपने ऐप्लिकेशन की हर सुविधा के लिए, api और impl नाम के दो सबमॉड्यूल बनाएं. का मतलब "लागू करना" है. यहां दी गई टेबल की मदद से तय करें कि नेविगेशन कोड को कहां रखना है.

इस तरीके से, एक सुविधा से दूसरी सुविधा पर नेविगेट किया जा सकता है. इसके लिए, पहली सुविधा के impl मॉड्यूल में मौजूद कॉन्टेंट को दूसरी सुविधा के api मॉड्यूल में मौजूद नेविगेशन कुंजियों पर निर्भर रहने की अनुमति दी जाती है.

एक्सटेंशन फ़ंक्शन का इस्तेमाल करके, नेविगेशन एंट्री को अलग करना

नेविगेशन 3 में, नेविगेशन एंट्री का इस्तेमाल करके नेविगेट किए जा सकने वाले कॉन्टेंट को तय किया जाता है. इन एंट्री को अलग-अलग मॉड्यूल में बांटने के लिए, EntryProviderScope पर एक्सटेंशन फ़ंक्शन बनाएं और उन्हें उस सुविधा के लिए impl मॉड्यूल में ले जाएं. इन्हें एंट्री बिल्डर कहा जाता है.

यहां दिए गए कोड के उदाहरण में, एंट्री बिल्डर दिखाया गया है. यह दो नेविगेशन एंट्री बनाता है.

// import androidx.navigation3.runtime.EntryProviderScope
// import androidx.navigation3.runtime.NavKey

fun EntryProviderScope<NavKey>.featureAEntryBuilder() {
    entry<KeyA> {
        ContentRed("Screen A") {
            // Content for screen A
        }
    }
    entry<KeyA2> {
        ContentGreen("Screen A2") {
            // Content for screen A2
        }
    }
}
ModularizationSnippets.kt

अपने मुख्य ऐप्लिकेशन मॉड्यूल में entryProvider को तय करते समय, entryProvider DSL का इस्तेमाल करके उस फ़ंक्शन को कॉल करें.

// import androidx.navigation3.runtime.entryProvider
// import androidx.navigation3.ui.NavDisplay
NavDisplay(
    entryProvider = entryProvider {
        featureAEntryBuilder()
    },
    // ...
)
ModularizationSnippets.kt

मुख्य ऐप्लिकेशन में एंट्री जोड़ने के लिए, डिपेंडेंसी इंजेक्शन का इस्तेमाल करना

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

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

उदाहरण के लिए, इस कोड में Dagger multibindings का इस्तेमाल किया गया है. खास तौर पर, @IntoSet का इस्तेमाल करके एंट्री बिल्डर को Set में इंजेक्ट किया गया है. इस का मालिकाना हक MainActivity के पास है. इसके बाद, इन्हें entryProvider में बार-बार कॉल किया जाता है. इससे, एंट्री बिल्डर के कई फ़ंक्शन को साफ़ तौर पर कॉल करने की ज़रूरत नहीं पड़ती.

फ़ीचर मॉड्यूल

// import dagger.Module
// import dagger.Provides
// import dagger.hilt.InstallIn
// import dagger.hilt.android.components.ActivityRetainedComponent
// import dagger.multibindings.IntoSet

@Module
@InstallIn(ActivityRetainedComponent::class)
object FeatureAModule {

    @IntoSet
    @Provides
    fun provideFeatureAEntryBuilder() : EntryProviderScope<NavKey>.() -> Unit = {
        featureAEntryBuilder()
    }
}
ModularizationSnippets.kt

ऐप्लिकेशन मॉड्यूल

// import android.os.Bundle
// import androidx.activity.ComponentActivity
// import androidx.activity.compose.setContent
// import androidx.navigation3.runtime.EntryProviderScope
// import androidx.navigation3.runtime.NavKey
// import androidx.navigation3.runtime.entryProvider
// import androidx.navigation3.ui.NavDisplay
// import javax.inject.Inject

class MainActivity : ComponentActivity() {

    @Inject
    lateinit var entryBuilders: Set<@JvmSuppressWildcards EntryProviderScope<NavKey>.() -> Unit>

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            NavDisplay(
                entryProvider = entryProvider {
                    entryBuilders.forEach { builder -> this.builder() }
                },
                // ...
            )
        }
    }
}
ModularizationSnippets.kt

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

डीप लिंक मैच करने वाले फ़ंक्शन को मॉड्यूल के हिसाब से व्यवस्थित करना

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

अपने ऐप्लिकेशन के सभी मैचर्स को एक साथ इकट्ठा करने के लिए, डिपेंडेंसी इंजेक्शन मल्टीबाइंडिंग का इस्तेमाल किया जा सकता है. उदाहरण के लिए, हर फ़ीचर मॉड्यूल, Dagger @IntoSet मल्टीबाइंडिंग में अपने मैचर्स जोड़ सकता है:

फ़ीचर मॉड्यूल

@Module
@InstallIn(ActivityRetainedComponent::class)
object FeatureADeepLinkModule {
    @IntoSet
    @Provides
    fun provideUserMatcher(): DeepLinkMatcher<*, *> {
        return UriDeepLinkMatcher(
            DeepLinkUri("www.example.com/users/{id}"),
            serializer<UserProfileKey>()
        )
    }
}
ModularizationSnippets.kt

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

ऐप्लिकेशन मॉड्यूल

@AndroidEntryPoint
class MainActivityWithDI : ComponentActivity() {
    @Inject
    lateinit var deepLinkMatchers: Set<@JvmSuppressWildcards DeepLinkMatcher<*, *>>

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        val request = DeepLinkRequest(intent = intent)
        val matchResult = deepLinkMatchers
            .mapNotNull { it.match(request) }
            .maxOrNull()

        val backStack = when (matchResult) {
            null -> listOf(HomeKey)
            is BackStackMatchResult<*, *> -> {
                @Suppress("UNCHECKED_CAST")
                matchResult.backStack as List<NavKey>
            }
            else -> listOf(matchResult.key)
        }
    }
}
ModularizationSnippets.kt

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

संसाधन

Navigation 3 के कोड को मॉड्यूल में बांटने का तरीका बताने वाले कोड सैंपल के लिए, यहां जाएं:

• Navigation 3 के आर्किटेक्चर के कोड रेसिपी
• Now in Android ऐप्लिकेशन से, मॉड्यूलर बनाने के बारे में सीखने की प्रोसेस
• Androidify