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

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

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

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

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

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

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

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

@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 ViewModel, ViewModelComponent से उपलब्ध कराए जाते हैं. यह ViewModel की तरह ही लाइफ़साइकल का पालन करता है. इसलिए, कॉन्फ़िगरेशन में होने वाले बदलावों के बाद भी यह काम करता रहता है. किसी डिपेंडेंसी को ViewModel तक सीमित करने के लिए, @ViewModelScoped एनोटेशन का इस्तेमाल करें.

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

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

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

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

app/build.gradle

Kotlin

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

Groovy

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

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

नेविगेशन 3 में, नेविगेशन की जगहों को NavEntry से दिखाया गया है. rememberViewModelStoreNavEntryDecorator का इस्तेमाल करके, ViewModel को NavEntry पर स्कोप करें. उस 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

Kotlin

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

Groovy

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()
}