Hilt ile bağımlı yerleştirme

Hilt, Android için bir bağımlılık ekleme kitaplığıdır. Projenizde manuel bağımlılık ekleme işleminin ortak metin kodlarını azaltır. Manuel bağımlılık ekleme işlemi için her sınıfı ve bağımlılıklarını manuel olarak oluşturmanız, bağımlılıkları yeniden kullanmak ve yönetmek için de kapsayıcıları kullanmanız gerekir.

Hilt, projenizdeki her Android sınıfı için kapsayıcılar sağlayarak ve yaşam döngülerini otomatik olarak yöneterek uygulamanızda bağımlılık eklemeyi kullanmanın standart bir yolunu sunar. Hilt, Dagger'ın sağladığı Android Studio desteği, ölçeklenebilirlik, çalışma zamanı performansı ve derleme zamanı doğruluğundan yararlanmak için popüler DI kitaplığı Dagger'ın üzerine kurulmuştur. Daha fazla bilgi için Hilt ve Dagger başlıklı makaleyi inceleyin.

Bu kılavuzda, Hilt'in temel kavramları ve oluşturulan kapsayıcıları açıklanmaktadır. Ayrıca, mevcut bir uygulamayı Hilt kullanacak şekilde başlatma işleminin nasıl yapılacağına dair bir gösterim de içerir.

Bağımlılık ekleme

Öncelikle hilt-android-gradle-plugin eklentisini projenizin kök build.gradle dosyasına ekleyin:

plugins {
  ...
  id("com.google.dagger.hilt.android") version "2.57.1" apply false
}

plugins {
  ...
  id 'com.google.dagger.hilt.android' version '2.57.1' apply false
}

Ardından, Gradle eklentisini uygulayın ve bu bağımlılıkları app/build.gradle dosyanıza ekleyin:

plugins {
  id("com.google.devtools.ksp")
  id("com.google.dagger.hilt.android")
}

android {
  ...
}

dependencies {
  implementation("com.google.dagger:hilt-android:2.57.1")
  ksp("com.google.dagger:hilt-android-compiler:2.57.1")
}

...
plugins {
  id 'com.google.devtools.ksp'
  id 'com.google.dagger.hilt.android'
}

android {
  ...
}

dependencies {
  implementation "com.google.dagger:hilt-android:2.57.1"
  ksp "com.google.dagger:hilt-compiler:2.57.1"
}

Projenizin, Jetpack Compose ve Hilt sürümleri için gerekli olan Java 17'ye göre yapılandırıldığından emin olmak için app/build.gradle dosyasına aşağıdakileri ekleyin:

android {
  ...
  compileOptions {
    sourceCompatibility = JavaVersion.VERSION_17
    targetCompatibility = JavaVersion.VERSION_17
  }
}

android {
  ...
  compileOptions {
    sourceCompatibility JavaVersion.VERSION_17
    targetCompatibility JavaVersion.VERSION_17
  }
}

Hilt uygulama sınıfı

Hilt'i kullanan tüm uygulamalar, @HiltAndroidApp ile açıklama eklenmiş bir Application sınıfı içermelidir.

@HiltAndroidApp, Hilt'in kod oluşturma işlemini tetikler. Bu işlem, uygulamanız için uygulama düzeyinde bağımlılık kapsayıcısı olarak işlev gören bir temel sınıfı da içerir.

@HiltAndroidApp
class ExampleApplication : Application() { ... }

Bu oluşturulan Hilt bileşeni, Application nesnesinin yaşam döngüsüne eklenir ve bu nesneye bağımlılıklar sağlar. Ayrıca, uygulamanın üst bileşenidir. Bu nedenle, diğer bileşenler sağladığı bağımlılıklara erişebilir.

Bağımlılıkları Android sınıflarına yerleştirme

Hilt, Application sınıfınızda ayarlandıktan ve uygulama düzeyinde bir bileşen kullanılabilir hale geldikten sonra @AndroidEntryPoint ek açıklamasına sahip diğer Android sınıflarına bağımlılıklar sağlayabilir:

@AndroidEntryPoint
class ExampleActivity : ComponentActivity() { ... }

Hilt şu anda aşağıdaki Android sınıflarını desteklemektedir:

• Application (@HiltAndroidApp kullanılarak)
• ViewModel (@HiltViewModel kullanılarak)
• Activity
• Service
• BroadcastReceiver

Compose'da tek tek composable'lara ek açıklama eklemeniz gerekmez. Bunun yerine, kök ComponentActivity öğenizi @AndroidEntryPoint ile açıklama ekleyin. Bu, kullanıcı arayüzü hiyerarşinizin tamamı için tek DI giriş noktası olarak işlev görür. Böylece, Hilt ile yerleştirilmiş ViewModel'lere doğrudan composable işlevlerinizden erişebilirsiniz.

@AndroidEntryPoint, projenizdeki her Android sınıfı için ayrı bir Hilt bileşeni oluşturur. Bu bileşenler, Bileşen hiyerarşisi bölümünde açıklandığı gibi, ilgili üst sınıflarından bağımlılıklar alabilir.

Bir bileşenden bağımlılıkları almak için alan yerleştirme işlemini gerçekleştirmek üzere @Inject ek açıklamasını kullanın:

@AndroidEntryPoint
class ExampleActivity : ComponentActivity() {

  @Inject lateinit var analytics: AnalyticsAdapter
  ...
}

Hilt'in yerleştirdiği sınıfların, yerleştirme kullanan başka temel sınıfları olabilir. Bu sınıflar soyutsa @AndroidEntryPoint ek açıklamasına gerek yoktur.

Bir Android sınıfına hangi yaşam döngüsü geri çağırma yönteminin eklendiği hakkında daha fazla bilgi edinmek için Bileşen ömürleri başlıklı makaleyi inceleyin.

Hilt bağlamalarını tanımlama

Alan yerleştirme işlemini gerçekleştirmek için Hilt'in, gerekli bağımlılıkların örneklerini ilgili bileşenden nasıl sağlayacağını bilmesi gerekir. Bağlama, bir türün örneklerini bağımlılık olarak sağlamak için gereken bilgileri içerir.

Hilt'e bağlama bilgileri sağlamanın bir yolu oluşturucu ekleme'dir. Hilt'e bu sınıfın örneklerini nasıl sağlayacağını bildirmek için sınıfın oluşturucusunda @Inject ek açıklamasını kullanın:

class AnalyticsAdapter @Inject constructor(
  private val service: AnalyticsService
) { ... }

Bir sınıfın açıklama eklenmiş oluşturucusunun parametreleri, o sınıfın bağımlılıklarıdır. Örnekte, AnalyticsAdapter öğesinin bağımlılığı AnalyticsService'dir. Bu nedenle, Hilt'in AnalyticsService örneklerini nasıl sağlayacağını da bilmesi gerekir.

Hilt modülleri

Bazen bir tür, oluşturucuya yerleştirilemez. Bunun birden fazla nedeni olabilir. Örneğin, bir arayüzü oluşturucuya yerleştiremezsiniz. Ayrıca, harici bir kitaplıktaki sınıf gibi sahip olmadığınız bir türü oluşturucu olarak ekleyemezsiniz. Bu durumlarda, Hilt modüllerini kullanarak Hilt'e bağlama bilgileri sağlayabilirsiniz.

Hilt modülü, @Module ile açıklama eklenmiş bir sınıftır. Hilt'e, arayüzler veya üçüncü taraf sınıfları gibi oluşturucu ekleme yoluyla sağlanamayan türlerin örneklerinin nasıl oluşturulacağıyla ilgili talimatlar verir. Ayrıca, her modülü @InstallIn ile açıklama ekleyerek Hilt'e her modülün hangi Android sınıfında kullanılacağını veya yükleneceğini bildirmeniz gerekir.

Hilt modüllerinde sağladığınız bağımlılıklar, Hilt modülünü yüklediğiniz Android sınıfıyla ilişkili tüm oluşturulan bileşenlerde kullanılabilir.

@Binds ile arayüz örneklerini yerleştirme

AnalyticsService örneğini inceleyin. AnalyticsService bir arayüzse oluşturucu ekleme işlemi yapamazsınız. Bunun yerine, bir Hilt modülünde @Binds ile açıklama eklenmiş soyut bir işlev oluşturarak Hilt'e bağlama bilgilerini sağlayın.

@Binds ek açıklaması, Hilt'in bir arayüz örneği sağlaması gerektiğinde hangi uygulamayı kullanacağını belirtir.

Açıklama eklenmiş işlev, Hilt'e aşağıdaki bilgileri sağlar:

• İşlevin dönüş türü, Hilt'e işlevin hangi arayüz örneklerini sağladığını bildirir.
• İşlev parametresi, Hilt'e hangi uygulamayı sağlayacağını söyler.

interface AnalyticsService {
  fun analyticsMethods()
}

// Constructor-injected, because Hilt needs to know how to
// provide instances of AnalyticsServiceImpl, too.
class AnalyticsServiceImpl @Inject constructor(
  ...
) : AnalyticsService { ... }

@Module
@InstallIn(ActivityComponent::class)
abstract class AnalyticsModule {

  @Binds
  abstract fun bindAnalyticsService(
    analyticsServiceImpl: AnalyticsServiceImpl
  ): AnalyticsService
}

Hilt modülü AnalyticsModule, @InstallIn(ActivityComponent.class) ile açıklama eklenir. Bunun nedeni, Hilt'in bu bağımlılığı ExampleActivity içine yerleştirmesini istemenizdir. Bu açıklama, AnalyticsModule içindeki tüm bağımlılıkların uygulamanın tüm etkinliklerinde kullanılabildiği anlamına gelir.

@Provides ile örnekleri yerleştirme

Arayüzler, bir türü oluşturucuya yerleştiremeyeceğiniz tek durum değildir. Sınıf size ait değilse (Retrofit, OkHttpClient veya Room veritabanları gibi sınıflar harici bir kitaplıktan geliyorsa) ya da örneklerin oluşturucu deseni ile oluşturulması gerekiyorsa oluşturucu ekleme de mümkün değildir.

Önceki örneği inceleyelim. AnalyticsService sınıfının doğrudan sahibi değilseniz Hilt modülünde bir işlev oluşturup bu işlevi @Provides ile açıklama ekleyerek Hilt'e bu türün örneklerini nasıl sağlayacağını söyleyebilirsiniz.

Açıklama eklenmiş işlev, Hilt'e aşağıdaki bilgileri sağlar:

• İşlevin dönüş türü, Hilt'e işlevin hangi türde örnekler sağladığını bildirir.
• İşlev parametreleri, Hilt'e ilgili türün bağımlılıklarını bildirir.
• İşlev gövdesi, Hilt'e ilgili türün bir örneğini nasıl sağlayacağını söyler. Hilt, bu türün bir örneğini sağlaması gerektiğinde işlev gövdesini her seferinde yürütür.

@Module
@InstallIn(ActivityComponent::class)
object AnalyticsModule {

  @Provides
  fun provideAnalyticsService(
    // Potential dependencies of this type
  ): AnalyticsService {
      return Retrofit.Builder()
               .baseUrl("https://example.com")
               .build()
               .create(AnalyticsService::class.java)
  }
}

Aynı tür için birden fazla bağlama sağlama

Hilt'in aynı türün farklı uygulamalarını bağımlılık olarak sağlaması gerektiği durumlarda Hilt'e birden fazla bağlama sağlamanız gerekir. Aynı tür için nitelendiricilerle birden fazla bağlama tanımlayabilirsiniz.

Niteleyici, bir tür için birden fazla bağlama tanımlandığında bu türün belirli bir bağlamasını tanımlamak üzere kullandığınız bir ek açıklamadır.

Örneği inceleyin. AnalyticsService'ya yapılan aramaları engellemeniz gerekiyorsa interceptor içeren bir OkHttpClient nesnesi kullanabilirsiniz. Diğer hizmetler için aramaları farklı bir şekilde engellemeniz gerekebilir. Bu durumda, Hilt'e OkHttpClient için iki farklı uygulama sağlamayı nasıl yapacağını söylemeniz gerekir.

Öncelikle, @Binds veya @Provides yöntemlerini açıklama eklemek için kullanacağınız niteleyicileri tanımlayın:

@Qualifier
@Retention(AnnotationRetention.BINARY)
annotation class AuthInterceptorOkHttpClient

@Qualifier
@Retention(AnnotationRetention.BINARY)
annotation class OtherInterceptorOkHttpClient

Ardından, Hilt'in her niteleyiciye karşılık gelen türün bir örneğini nasıl sağlayacağını bilmesi gerekir. Bu durumda, @Provides ile bir Hilt modülü kullanabilirsiniz. Her iki yöntemin de dönüş türü aynıdır ancak niteleyiciler bunları iki farklı bağlama olarak etiketler:

@Module
@InstallIn(SingletonComponent::class)
object NetworkModule {

  @AuthInterceptorOkHttpClient
  @Provides
  fun provideAuthInterceptorOkHttpClient(
    authInterceptor: AuthInterceptor
  ): OkHttpClient {
      return OkHttpClient.Builder()
               .addInterceptor(authInterceptor)
               .build()
  }

  @OtherInterceptorOkHttpClient
  @Provides
  fun provideOtherInterceptorOkHttpClient(
    otherInterceptor: OtherInterceptor
  ): OkHttpClient {
      return OkHttpClient.Builder()
               .addInterceptor(otherInterceptor)
               .build()
  }
}

Alanı veya parametreyi ilgili niteleyiciyle açıklama ekleyerek ihtiyacınız olan belirli türü ekleyebilirsiniz:

// As a dependency of another class.
@Module
@InstallIn(ActivityComponent::class)
object AnalyticsModule {

  @Provides
  fun provideAnalyticsService(
    @AuthInterceptorOkHttpClient okHttpClient: OkHttpClient
  ): AnalyticsService {
      return Retrofit.Builder()
               .baseUrl("https://example.com")
               .client(okHttpClient)
               .build()
               .create(AnalyticsService::class.java)
  }
}

// As a dependency of a constructor-injected class.
class ExampleServiceImpl @Inject constructor(
  @AuthInterceptorOkHttpClient private val okHttpClient: OkHttpClient
) : ...

// At field injection.
@AndroidEntryPoint
class ExampleActivity: ComponentActivity() {

  @AuthInterceptorOkHttpClient
  @Inject lateinit var okHttpClient: OkHttpClient
}

En iyi uygulama olarak, bir türe niteleyici ekliyorsanız bu bağımlılığı sağlamanın olası tüm yollarına niteleyiciler ekleyin. Temel veya ortak uygulamayı niteleyici olmadan bırakmak hataya neden olabilir ve Hilt'in yanlış bağımlılığı yerleştirmesine yol açabilir.

Hilt'te önceden tanımlanmış niteleyiciler

Hilt, önceden tanımlanmış bazı niteleyiciler sağlar. Örneğin, uygulamadan veya etkinlikten Context sınıfına ihtiyacınız olabileceğinden Hilt, @ApplicationContext ve @ActivityContext niteleyicilerini sağlar.

Örnekteki AnalyticsAdapter sınıfının etkinliğin bağlamına ihtiyacı olduğunu varsayalım. Aşağıdaki kodda, etkinliğin AnalyticsAdapter bağlamının nasıl sağlanacağı gösterilmektedir:

class AnalyticsAdapter @Inject constructor(
    @ActivityContext private val context: Context,
    private val service: AnalyticsService
) { ... }

Hilt'te kullanılabilen diğer önceden tanımlanmış bağlamalar için Bileşen varsayılan bağlamaları başlıklı makaleyi inceleyin.

Android sınıfları için oluşturulan bileşenler

Alan yerleştirme işlemi gerçekleştirebileceğiniz her Android sınıfı için @InstallIn ek açıklamasında başvurabileceğiniz ilişkili bir Hilt bileşeni vardır. Her Hilt bileşeni, bağlamalarını ilgili Android sınıfına yerleştirmekten sorumludur.

Önceki örneklerde Hilt modüllerinde ActivityComponent kullanımı gösterilmişti.

Hilt aşağıdaki bileşenleri sağlar:

Bileşen ömürleri

Hilt, oluşturulan bileşen sınıflarının örneklerini, ilgili Android sınıflarının yaşam döngüsüne göre otomatik olarak oluşturur ve yok eder.

Bileşen kapsamları

Varsayılan olarak, Hilt'teki tüm bağlamalar kapsamsızdır. Bu, uygulamanız her bağlama isteğinde bulunduğunda Hilt'in gerekli türün yeni bir örneğini oluşturduğu anlamına gelir.

Örnekte, Hilt AnalyticsAdapter öğesini başka bir tür için veya alan yerleştirme yoluyla (ExampleActivity örneğinde olduğu gibi) bağımlılık olarak her sağladığında AnalyticsAdapter öğesinin yeni bir örneğini sağlar.

Ancak Hilt, bağlamanın belirli bir bileşene de kapsamlandırılmasına olanak tanır. Hilt, kapsamı belirlenmiş bağlamanın kapsamının belirlendiği bileşenin örneği başına yalnızca bir kez kapsamı belirlenmiş bağlama oluşturur ve bu bağlama için yapılan tüm istekler aynı örneği paylaşır.

Aşağıdaki tabloda, oluşturulan her bileşen için kapsam ek açıklamaları listelenmiştir:

Örnekte, AnalyticsAdapter kapsamını ActivityComponent olarak belirlerseniz @ActivityScoped kullanılarak Hilt, AnalyticsAdapter öğesinin aynı örneğini ilgili etkinliğin yaşam süresi boyunca sağlar:

@ActivityScoped
class AnalyticsAdapter @Inject constructor(
  private val service: AnalyticsService
) { ... }

AnalyticsService'nın, yalnızca ExampleActivity içinde değil, uygulamanın herhangi bir yerinde her seferinde aynı örneğin kullanılmasını gerektiren bir dahili durumu olduğunu varsayalım. Bu durumda, AnalyticsService'nın kapsamını SingletonComponent olarak belirlemek uygundur. Sonuç olarak, bileşenin AnalyticsService örneği sağlaması gerektiğinde her seferinde aynı örneği sağlar.

Aşağıdaki örnekte, Hilt modülündeki bir bileşene bağlamanın nasıl kapsamlandırılacağı gösterilmektedir. Bir bağlamanın kapsamı, yüklendiği bileşenin kapsamıyla eşleşmelidir. Bu nedenle, bu örnekte ActivityComponent yerine SingletonComponent içine AnalyticsService yüklemeniz gerekir:

// If AnalyticsService is an interface.
@Module
@InstallIn(SingletonComponent::class)
abstract class AnalyticsModule {

  @Singleton
  @Binds
  abstract fun bindAnalyticsService(
    analyticsServiceImpl: AnalyticsServiceImpl
  ): AnalyticsService
}

// If you don't own AnalyticsService.
@Module
@InstallIn(SingletonComponent::class)
object AnalyticsModule {

  @Singleton
  @Provides
  fun provideAnalyticsService(): AnalyticsService {
      return Retrofit.Builder()
               .baseUrl("https://example.com")
               .build()
               .create(AnalyticsService::class.java)
  }
}

Hilt bileşen kapsamları hakkında daha fazla bilgi edinmek için Android ve Hilt'te Kapsam başlıklı makaleyi inceleyin.

Bileşen hiyerarşisi

Bir bileşene modül yüklemek, bu modülün bağlamalarının, söz konusu bileşendeki veya bileşen hiyerarşisinde bu bileşenin altındaki herhangi bir alt bileşendeki diğer bağlamaların bağımlılığı olarak erişilmesine olanak tanır.

Bileşen varsayılan bağlamaları

Her Hilt bileşeni, Hilt'in kendi özel bağlamalarınıza bağımlılık olarak yerleştirebileceği bir dizi varsayılan bağlama ile birlikte gelir. Bu bağlamaların belirli bir alt sınıfa değil, genel etkinlik türüne karşılık geldiğini unutmayın. Bunun nedeni, Hilt'in tüm etkinlikleri yerleştirmek için tek bir etkinlik bileşeni tanımı kullanmasıdır. Her etkinlikte bu bileşenin farklı bir örneği bulunur.

Uygulama bağlamı bağlama işlemi @ApplicationContext kullanılarak da yapılabilir. Örneğin:

class AnalyticsServiceImpl @Inject constructor(
  @ApplicationContext context: Context
) : AnalyticsService { ... }

// The Application binding is available without qualifiers.
class AnalyticsServiceImpl @Inject constructor(
  application: Application
) : AnalyticsService { ... }

Etkinlik bağlamı bağlama işlemi @ActivityContext kullanılarak da yapılabilir. Örneğin:

class AnalyticsAdapter @Inject constructor(
  @ActivityContext context: Context
) { ... }

// The Activity binding is available without qualifiers.
class AnalyticsAdapter @Inject constructor(
  activity: ComponentActivity
) { ... }

Hilt tarafından desteklenmeyen sınıflara bağımlılık ekleme

Compose'da standart kalıp, bağımlılıkları oluşturucu ekleme kullanarak bir @HiltViewModel içine yerleştirmek ve ardından ViewModel'e erişmek için composable'ınızda hiltViewModel() kullanmaktır. Hilt, en yaygın Android sınıflarını desteklese de alan ekleme yapmanız gereken desteklenmeyen sınıflarla karşılaşabilirsiniz.

Bu durumlarda, @EntryPoint ek açıklamasını kullanarak bir giriş noktası oluşturabilirsiniz. Giriş noktası, Hilt tarafından yönetilen kod ile yönetilmeyen kod arasındaki sınırdır. Bu, kodun Hilt'in yönettiği nesne grafiğine ilk kez girdiği noktadır. Giriş noktaları, Hilt'in bağımlılık grafiğinde bağımlılıklar sağlamak için Hilt'in yönetmediği kodu kullanmasına olanak tanır.

Örneğin, Hilt, content providers'ı doğrudan desteklemez. Bir içerik sağlayıcının bazı bağımlılıkları almak için Hilt'i kullanmasını istiyorsanız istediğiniz her bağlama türü için @EntryPoint ile açıklama eklenmiş bir arayüz tanımlamanız ve niteleyiciler eklemeniz gerekir. Ardından, giriş noktasının yükleneceği bileşeni belirtmek için @InstallIn ekleyin:

class ExampleContentProvider : ContentProvider() {

  @EntryPoint
  @InstallIn(SingletonComponent::class)
  interface ExampleContentProviderEntryPoint {
    fun analyticsService(): AnalyticsService
  }

  ...
}

Bir giriş noktasına erişmek için EntryPointAccessors içindeki uygun statik yöntemi kullanın. Parametre, bileşen örneği veya bileşen tutucu görevi gören @AndroidEntryPoint nesnesi olmalıdır. Parametre olarak ilettiğiniz bileşenin ve EntryPointAccessors statik yönteminin, @EntryPoint arayüzündeki @InstallIn ek açıklamasında Android sınıfıyla eşleştiğinden emin olun:

class ExampleContentProvider: ContentProvider() {
    ...

  override fun query(...): Cursor {
    val appContext = context?.applicationContext ?: throw IllegalStateException()
    val hiltEntryPoint =
      EntryPointAccessors.fromApplication(appContext, ExampleContentProviderEntryPoint::class.java)

    val analyticsService = hiltEntryPoint.analyticsService()
    ...
  }
}

Bu örnekte, giriş noktası SingletonComponent içine yüklendiğinden giriş noktasını almak için ApplicationContext kullanmanız gerekir. Almak istediğiniz bağlama ActivityComponent içinde olsaydı bunun yerine ActivityContext kullanırdınız.

Hilt ve Dagger

Hilt, Android'de bağımlılık ekleme için resmi olarak önerilen kitaplıktır. Bu kitaplık, uygulamanızda bağımlılık eklemeyi standart, belirli bir görüşe dayalı ve verimli bir şekilde uygulamanızı sağlar. Özellikle Jetpack Compose ve tek etkinlikli mimariler için optimize edilmiştir.

Hilt'in hedefleri şunlardır:

• Kurulumu, okunabilirliği ve uygulamalar arasında kod paylaşımını kolaylaştırmak için standart bir bileşen ve kapsam grubu oluşturmak.
• Farklı bağlamaları çeşitli derleme türlerine (ör. test, hata ayıklama veya yayın) kolayca sağlama

Android işletim sistemi kendi çerçeve sınıflarının çoğunu oluşturduğundan, bir Android uygulamasında Dagger'ı kullanmak için önemli miktarda standart kod yazmanız gerekir. Hilt, bir Android uygulamasında Dagger'ı kullanırken gereken ortak metin kodunu azaltır. Hilt, aşağıdakileri otomatik olarak oluşturur ve sağlar:

• Android çerçeve sınıflarını Dagger ile entegre etmek için bileşenler. Bu bileşenleri aksi takdirde manuel olarak oluşturmanız gerekir.
• Hilt'in otomatik olarak oluşturduğu bileşenlerle kullanılacak kapsam ek açıklamaları.
• Application veya Activity gibi Android sınıflarını temsil eden önceden tanımlanmış bağlamalar.
• @ApplicationContext ve @ActivityContext'ı temsil eden önceden tanımlanmış niteleyiciler.

Dagger ve Hilt kodu aynı kod tabanında birlikte bulunabilir. Ancak çoğu durumda, Android'de Dagger kullanımınızın tamamını yönetmek için Hilt'i kullanmak en iyisidir. Dagger kullanan bir projeyi Hilt'e taşımak için taşıma kılavuzuna bakın.

Ek kaynaklar

Hilt hakkında daha fazla bilgi edinmek için aşağıdaki ek kaynaklara bakın.

Örnekler

Bloglar

• Hilt ile Android'de Bağımlılık Ekleme
• Android ve Hilt'te kapsam belirleme
• Hilt hiyerarşisine bileşen ekleme
• Google I/O uygulamasını Hilt'e taşıma

İçeriği görüntüleme

• Hilt ile bağımlılık yerleştirme (Görünümler)