Hilt का इस्तेमाल अन्य Jetpack लाइब्रेरी के साथ करें

Hilt में, Jetpack की अन्य लाइब्रेरी से क्लास उपलब्ध कराने के लिए एक्सटेंशन शामिल होते हैं. फ़िलहाल, Hilt इन Jetpack कॉम्पोनेंट के साथ काम करता है:

• लिखें
• ViewModel
• नेविगेशन
• WorkManager

इन इंटिग्रेशन का फ़ायदा पाने के लिए, आपको Hilt डिपेंडेंसी जोड़नी होंगी. डिपेंडेंसी जोड़ने के बारे में ज़्यादा जानने के लिए, Hilt की मदद से डिपेंडेंसी इंजेक्शन लेख पढ़ें.

Jetpack Compose के साथ इंटिग्रेशन

Hilt को Jetpack Compose के साथ इंटिग्रेट करने का तरीका जानने के लिए, Compose और अन्य लाइब्रेरी के Hilt सेक्शन पर जाएं.

Hilt की मदद से ViewModel ऑब्जेक्ट इंजेक्ट करना

@HiltViewModel का इस्तेमाल करके, ViewModel को एनोटेट करें. साथ ही, ViewModel ऑब्जेक्ट के कंस्ट्रक्टर में @Inject एनोटेशन का इस्तेमाल करें.

@HiltViewModel
class ExampleViewModel @Inject constructor(
  private val savedStateHandle: SavedStateHandle,
  private val repository: ExampleRepository
) : ViewModel() {
  ...
}

इसके बाद, @AndroidEntryPoint के साथ एनोटेट की गई कोई गतिविधि, ViewModelProvider या by viewModels() KTX एक्सटेंशन का इस्तेमाल करके, ViewModel इंस्टेंस को सामान्य तरीके से पा सकती है:

@AndroidEntryPoint
class ExampleActivity : AppCompatActivity() {
  private val exampleViewModel: ExampleViewModel by viewModels()
  ...
}

ViewModels के साथ असिस्टेड इंजेक्शन का इस्तेमाल करना

Hilt, ViewModels के लिए असिस्टेड इंजेक्शन की सुविधा देता है. सहायता से किए जाने वाले इंजेक्शन की मदद से, Hilt से मैनेज की जाने वाली डिपेंडेंसी के साथ-साथ, डाइनैमिक रनटाइम आर्ग्युमेंट इंजेक्ट किए जा सकते हैं. असिस्टेड इंजेक्शन का इस्तेमाल करने के लिए, अपने ViewModel कंस्ट्रक्टर को @AssistedInject से एनोटेट करें. साथ ही, डाइनैमिक पैरामीटर को @Assisted से मार्क करें. आपको एक @AssistedFactory इंटरफ़ेस भी तय करना होगा. यह इंटरफ़ेस, Hilt के लिए एक ब्रिज की तरह काम करता है, ताकि ज़रूरी @ViewModelProvider.Factory अपने-आप जनरेट हो सकें.

@HiltViewModel(assistedFactory = MyViewModel.Factory::class)
class MyViewModel @AssistedInject constructor(
    @Assisted val userId: String,
    private val repository: MyRepository
) : ViewModel() {
    @AssistedFactory interface Factory {
        fun create(userId: String): MyViewModel
    }
}

Compose में, नेविगेशन या स्क्रीन शुरू करने के दौरान, hiltViewModel फ़ंक्शन में पास करके, असिस्टेड फ़ैक्ट्री का इस्तेमाल किया जा सकता है. इस तरीके से, मैन्युअल तरीके से फ़ैक्ट्री बॉयलरप्लेट की ज़रूरत नहीं पड़ती. साथ ही, आपकी ViewModel को नेविगेशन बैक स्टैक के हिसाब से सही स्कोप में रखा जाता है. ज़्यादा जानकारी के लिए, सहायता से जुड़े इंजेक्शन के बारे में Hilt का दस्तावेज़ देखें.

@ViewModelScoped

सभी Hilt ViewModels, ViewModelComponent से मिलते हैं. यह ViewModel की तरह ही लाइफ़साइकल को फ़ॉलो करता है. इसलिए, कॉन्फ़िगरेशन में बदलाव होने पर भी यह बना रहता है. किसी डिपेंडेंसी को ViewModel के स्कोप में लाने के लिए, @ViewModelScoped एनोटेशन का इस्तेमाल करें.

@ViewModelScoped टाइप का इस्तेमाल करने पर, स्कोप किए गए टाइप का एक इंस्टेंस, ViewModel में इंजेक्ट की गई सभी डिपेंडेंसी में उपलब्ध कराया जाएगा. ViewModel के अन्य इंस्टेंस, स्कोप किए गए इंस्टेंस का अनुरोध करते हैं. हालांकि, उन्हें एक अलग इंस्टेंस मिलेगा.

अगर किसी एक इंस्टेंस को अलग-अलग ViewModels के साथ शेयर करना है, तो उसे @ActivityRetainedScoped या @Singleton का इस्तेमाल करके स्कोप किया जाना चाहिए.

Jetpack नेविगेशन लाइब्रेरी के साथ इंटिग्रेशन

अपनी Gradle फ़ाइल में ये अतिरिक्त डिपेंडेंसी जोड़ें:

app/build.gradle

dependencies {
    ...
    implementation("androidx.hilt:hilt-lifecycle-viewmodel-compose:1.3.0")
}

dependencies {
    ...
    implementation 'androidx.hilt:hilt-lifecycle-viewmodel-compose:1.3.0'
}

Jetpack Compose में, Navigation Compose और Navigation 3 लाइब्रेरी, दोनों ही hiltViewModel फ़ंक्शन का इस्तेमाल करती हैं. इससे, मौजूदा नेविगेशन डेस्टिनेशन के स्कोप में मौजूद ViewModel को अपने-आप वापस पाया जा सकता है.

Navigation 3 में, नेविगेशन की मंज़िलों को NavEntry के तौर पर दिखाया जाता है. rememberViewModelStoreNavEntryDecorator का इस्तेमाल करके, ViewModels को NavEntrys के स्कोप में रखें. उस NavEntry के लिए, प्रोवाइडर के अंदर hiltViewModel का इस्तेमाल करें, ताकि उससे जुड़ा ViewModel वापस पाया जा सके.

NavDisplay(...,
  entryDecorators = listOf(..., rememberViewModelStoreNavEntryDecorator()),
  entryProvider = entryProvider {
    entry { key ->
      val viewModel = hiltViewModel()
      MyScreen(viewModel = viewModel)
    }
  }
)

Navigation Compose में, ViewModels को नेविगेशन डेस्टिनेशन के हिसाब से अपने-आप स्कोप किया जाता है. ज़्यादा जानकारी के लिए, Hilt और नेविगेशन देखें.

val viewModel = hiltViewModel()

Hilt की मदद से WorkManager को इंजेक्ट करना

अपनी Gradle फ़ाइल में ये अतिरिक्त डिपेंडेंसी जोड़ें. ध्यान दें कि लाइब्रेरी के अलावा, आपको एक और एनोटेशन प्रोसेसर शामिल करना होगा. यह Hilt एनोटेशन प्रोसेसर के साथ काम करता है:

app/build.gradle

dependencies {
    implementation("androidx.hilt:hilt-work:1.0.0")
    // When using Kotlin.
    ksp("androidx.hilt:hilt-compiler:1.4.0")
}

dependencies {
  ...
  implementation 'androidx.hilt:hilt-work:1.0.0'
  // When using Kotlin.
  ksp 'androidx.hilt:hilt-compiler:1.4.0'
}

क्लास में @HiltWorker एनोटेशन और Worker ऑब्जेक्ट के कंस्ट्रक्टर में @AssistedInject का इस्तेमाल करके, Worker इंजेक्ट करें. Worker ऑब्जेक्ट में, सिर्फ़ @Singleton या बिना स्कोप वाली बाइंडिंग का इस्तेमाल किया जा सकता है. आपको Context और WorkerParameters डिपेंडेंसी को @Assisted के साथ एनोटेट करना होगा:

@HiltWorker
class ExampleWorker @AssistedInject constructor(
  @Assisted appContext: Context,
  @Assisted workerParams: WorkerParameters,
  workerDependency: WorkerDependency
) : Worker(appContext, workerParams) { ... }

इसके बाद, अपनी Application क्लास में Configuration.Provider इंटरफ़ेस लागू करें, HiltWorkFactory का इंस्टेंस डालें, और उसे WorkManager कॉन्फ़िगरेशन में इस तरह पास करें:

@HiltAndroidApp
class ExampleApplication : Application(), Configuration.Provider {

  @Inject lateinit var workerFactory: HiltWorkerFactory

  override fun getWorkManagerConfiguration() =
      Configuration.Builder()
            .setWorkerFactory(workerFactory)
            .build()
}