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 metinlerini azaltır. Manuel bağımlılık ekleme işlemini gerçekleştirmek için her sınıfı ve sınıfın bağımlılarını manuel olarak oluşturmanız ve bağımlılıkları yeniden kullanmak ve yönetmek için kapsayıcıları kullanmanız gerekir.

Hilt, projenizdeki her Android sınıfı için container'lar sağlayıp bunların yaşam döngülerini otomatik olarak yöneterek uygulamanızda DI kullanımı için standart bir yol sağlar. Hilt, derleme zamanında doğruluk, çalışma zamanında performans, ölçeklenebilirlik ve Dagger'ın sunduğu Android Studio desteğinden yararlanmak için popüler DI kitaplığı Dagger üzerine inşa edilmiştir. Daha fazla bilgi için Kılıç ve hançer başlıklı makaleyi inceleyin.

Bu kılavuzda, Hilt ve oluşturulan kapsayıcılarının temel kavramları açıklanmaktadır. Ayrıca, Hilt'i kullanmak için mevcut bir uygulamanın nasıl önyükleneceğine dair bir tanıtım da bulunuyor.

Bağımlılıklar ekleme

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

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

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

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

...
plugins {
  id 'kotlin-kapt'
  id 'com.google.dagger.hilt.android'
}

android {
  ...
}

dependencies {
  implementation "com.google.dagger:hilt-android:2.51.1"
  kapt "com.google.dagger:hilt-compiler:2.51.1"
}

// Allow references to generated code
kapt {
  correctErrorTypes true
}

plugins {
  id("kotlin-kapt")
  id("com.google.dagger.hilt.android")
}

android {
  ...
}

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

// Allow references to generated code
kapt {
  correctErrorTypes = true
}

Hilt, Java 8 özelliklerini kullanır. Projenizde Java 8'i etkinleştirmek için app/build.gradle dosyasına aşağıdakileri ekleyin:

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

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

Hilt uygulama sınıfı

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

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

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

@HiltAndroidApp
public class ExampleApplication extends Application { ... }

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

Android sınıflarına bağımlılık ekleme

Hilt, Application sınıfınızda ayarlandıktan ve uygulama düzeyinde bir bileşen kullanıma sunulduktan sonra @AndroidEntryPoint ek açıklamasını içeren diğer Android sınıflarına bağımlılık sağlayabilir:

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

@AndroidEntryPoint
public class ExampleActivity extends AppCompatActivity { ... }

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

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

Bir Android sınıfına @AndroidEntryPoint ile ek açıklama eklerseniz bağımlı olan Android sınıflarına da not eklemeniz gerekir. Örneğin, bir snippet'e ek açıklama eklerseniz bu snippet'i kullandığınız tüm etkinliklere de ek açıklama eklemeniz gerekir.

@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ık alabilir.

Bir bileşenden bağımlılık elde etmek için alan ekleme işlemi yapmak üzere @Inject ek açıklamasını kullanın:

@AndroidEntryPoint
class ExampleActivity : AppCompatActivity() {

  @Inject lateinit var analytics: AnalyticsAdapter
  ...
}

@AndroidEntryPoint
public class ExampleActivity extends AppCompatActivity {

  @Inject
  AnalyticsAdapter analytics;
  ...
}

Hilt'in eklediği sınıflarda da ekleme kullanan başka temel sınıflar olabilir. Soyut sınıflar için @AndroidEntryPoint ek açıklamaya gerek yoktur.

Bir Android sınıfının hangi yaşam döngüsü geri çağırmasının yerleştirildiği hakkında daha fazla bilgi edinmek için Bileşen kullanım ömrü sayfasını inceleyin.

Hilt bağlamalarını tanımlama

Hilt'in alan ekleme işlemini gerçekleştirebilmesi için ilgili bileşendeki gerekli bağımlılık örneklerini 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 bilgilerini sağlamanın bir yolu yapıcı enjeksiyonudur. Hilt'e bir sınıfın örneklerini nasıl sağlayacağını söylemek için sınıfın kurucusundaki @Inject ek açıklamasını kullanın:

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

public class AnalyticsAdapter {

  private final AnalyticsService service;

  @Inject
  AnalyticsAdapter(AnalyticsService service) {
    this.service = service;
  }
  ...
}

Bir sınıfın ek açıklamalı kurucusunun parametreleri, söz konusu sınıfın bağımlılıklarıdır. Örnekte, AnalyticsAdapter boyutuna bağımlı öğe AnalyticsService'tir. Bu nedenle, Hilt'in AnalyticsService örneklerini nasıl sağlayacağını da bilmesi gerekir.

Hilt modülleri

Bazen bir tür, kurucu tarafından eklenemez. Bunun birden fazla nedeni olabilir. Örneğin, bir arayüze kurucu enjeksiyonu yapamazsınız. Ayrıca, harici kitaplıktaki bir sınıf gibi sahibi olmadığınız bir türü de kurucu ekleyemezsiniz. Bu gibi durumlarda, Hilt modüllerini kullanarak Hilt'e bağlama bilgileri sağlayabilirsiniz.

Hilt modülü, @Module ile ek açıklama eklenmiş bir sınıftır. Dagger modülü gibi, Hilt'e de belirli türlerin örneklerini nasıl sağlayacağını bildirir. Dagger modüllerinden farklı olarak, Hilt modüllerini @InstallIn ile 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ılar, Hilt modülünü yüklediğiniz Android sınıfıyla ilişkili olarak oluşturulan tüm bileşenlerde kullanılabilir.

Arayüz örneklerini @Binds ile ekleyin

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

@Binds ek açıklaması, Hilt'e bir arayüz örneği sağlaması gerektiğinde hangi uygulamanın kullanılacağını bildirir.

Ek açıklamalı işlev, Hilt'e aşağıdaki bilgileri sağlar:

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

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
}

public interface AnalyticsService {
  void analyticsMethods();
}

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

@Module
@InstallIn(ActivityComponent.class)
public abstract class AnalyticsModule {

  @Binds
  public abstract AnalyticsService bindAnalyticsService(
    AnalyticsServiceImpl analyticsServiceImpl
  );
}

Hilt'in bu bağımlılığı ExampleActivity içine enjekte etmesini istediğiniz için Hilt modülü AnalyticsModule, @InstallIn(ActivityComponent.class) ile ek açıklamaya sahiptir. Bu ek açıklama, AnalyticsModule içindeki tüm bağımlılıkların uygulamanın tüm etkinliklerinde kullanılabileceği anlamına gelir.

@Provides ile örnek yerleştirme

Bir tür kurucu ekleyemeyeceğiniz tek durum arayüz değildir. Sınıf harici bir kitaplıktan geldiği için (Retrofit, OkHttpClient veya Room veritabanları gibi sınıflar) sınıfın sahibi değilseniz veya örneklerin geliştirici kalıbıyla oluşturulması gerekiyorsa da yapıcı ekleme yapılamaz.

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

Ek açıklamalı işlev, Hilt'e aşağıdaki bilgileri sağlar:

• İşlev dönüş türü, Hilt'e, işlevin hangi tür örneklerini 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ğinin nasıl sağlanacağını söyler. Hilt, bu türden bir örnek sağlaması gerektiğinde her zaman işlev gövdesini 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)
  }
}

@Module
@InstallIn(ActivityComponent.class)
public class AnalyticsModule {

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

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

Hilt'in, bağımlılıklarla aynı türde farklı uygulamalar sağlaması gerektiğinde Hilt'e birden fazla bağlama sağlamanız gerekir. Sınıflandırıcılar ile aynı tür için birden fazla bağlama tanımlayabilirsiniz.

Niteleyici, bir tür için tanımlanmış birden fazla bağlama olduğunda belirli bir bağlamayı tanımlamak üzere kullandığınız ek açıklamadır.

Aşağıdaki örneği inceleyin. AnalyticsService çağrılarına müdahale etmeniz gerekirse bir arayıcı ile OkHttpClient nesnesi kullanabilirsiniz. Diğer hizmetler için aramaları farklı bir şekilde müdahale etmeniz gerekebilir. Bu durumda, Hilt'e OkHttpClient öğesinin iki farklı uygulamasını nasıl sağlayacağını bildirmeniz gerekir.

Öncelikle, @Binds veya @Provides yöntemlerine ek 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

@Qualifier
@Retention(RetentionPolicy.RUNTIME)
private @interface AuthInterceptorOkHttpClient {}

@Qualifier
@Retention(RetentionPolicy.RUNTIME)
private @interface 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 Hilt modülü kullanabilirsiniz. Her iki yöntem de aynı döndürme türüne sahiptir 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()
  }
}

@Module
@InstallIn(ActivityComponent.class)
public class NetworkModule {

  @AuthInterceptorOkHttpClient
  @Provides
  public static OkHttpClient provideAuthInterceptorOkHttpClient(
    AuthInterceptor authInterceptor
  ) {
      return new OkHttpClient.Builder()
                   .addInterceptor(authInterceptor)
                   .build();
  }

  @OtherInterceptorOkHttpClient
  @Provides
  public static OkHttpClient provideOtherInterceptorOkHttpClient(
    OtherInterceptor otherInterceptor
  ) {
      return new OkHttpClient.Builder()
                   .addInterceptor(otherInterceptor)
                   .build();
  }
}

Alanı veya parametreyi ilgili nitelikle 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: AppCompatActivity() {

  @AuthInterceptorOkHttpClient
  @Inject lateinit var okHttpClient: OkHttpClient
}

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

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

// As a dependency of a constructor-injected class.
public class ExampleServiceImpl ... {

  private final OkHttpClient okHttpClient;

  @Inject
  ExampleServiceImpl(@AuthInterceptorOkHttpClient OkHttpClient okHttpClient) {
    this.okHttpClient = okHttpClient;
  }
}

// At field injection.
@AndroidEntryPoint
public class ExampleActivity extends AppCompatActivity {

  @AuthInterceptorOkHttpClient
  @Inject
  OkHttpClient okHttpClient;
  ...
}

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

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 sınıflandırıcılarını sağlar.

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

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

public class AnalyticsAdapter {

  private final Context context;
  private final AnalyticsService service;

  @Inject
  AnalyticsAdapter(
    @ActivityContext Context context,
    AnalyticsService service
  ) {
    this.context = context;
    this.service = service;
  }
}

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 enjekte etmekten sorumludur.

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

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

Bileşen kullanım ömrü

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ı

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

Örnekte, Hilt her AnalyticsAdapter türünü başka bir türe bağımlı olarak veya alan ekleme yoluyla (ExampleActivity'te olduğu gibi) sağladığında yeni bir AnalyticsAdapter örneği sağlar.

Ancak Hilt, bağlamanın belirli bir bileşenle sınırlandırılmasına da olanak tanır. Hilt, bağlamanın kapsamına alındığı bileşen örneği başına yalnızca bir kez kapsamlı bağlama oluşturur ve bu bağlama yönelik 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, @ActivityScoped kullanarak AnalyticsAdapter'ü ActivityComponent'e göre kapsamlandırırsanız Hilt, ilgili etkinliğin ömrü boyunca aynı AnalyticsAdapter örneğini sağlar:

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

@ActivityScoped
public class AnalyticsAdapter {

  private final AnalyticsService service;

  @Inject
  AnalyticsAdapter(AnalyticsService service) {
    this.service = service;
  }
  ...
}

AnalyticsService işlevinin, aynı örneğin yalnızca ExampleActivity ürününde değil, uygulamanın herhangi bir yerinde her seferinde kullanılmasını gerektiren bir dahili duruma sahip olduğunu varsayalım. Bu durumda, AnalyticsService kapsamının SingletonComponent içine alınması uygundur. Sonuç olarak, bileşenin AnalyticsService örneği sağlaması gerektiğinde her zaman aynı örneği sağlar.

Aşağıdaki örnekte, Hilt modülündeki bir bileşene bağlamanın kapsamının nasıl belirleneceği gösterilmektedir. Bağlantının kapsamı, yüklendiği bileşenin kapsamıyla eşleşmelidir. Bu nedenle, bu örnekte AnalyticsService'ü ActivityComponent yerine SingletonComponent içine 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)
  }
}

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

  @Singleton
  @Binds
  public abstract AnalyticsService bindAnalyticsService(
    AnalyticsServiceImpl analyticsServiceImpl
  );
}

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

  @Singleton
  @Provides
  public static AnalyticsService provideAnalyticsService() {
      return new Retrofit.Builder()
               .baseUrl("https://example.com")
               .build()
               .create(AnalyticsService.class);
  }
}

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 modülü bir bileşene yüklediğinizde, bu modülün bağlamalarına, bileşen hiyerarşisinde bu bileşendeki veya altındaki herhangi bir alt bileşendeki diğer bağlamaların bağımlılığı olarak erişilebilir:

Bileşen varsayılan bağlamaları

Her Hilt bileşeni, Hilt'in kendi özel bağlamalarınıza bağımlılık olarak ekleyebildiği bir dizi varsayılan bağlama ile birlikte gelir. Bu bağlamaların herhangi bir belirli alt sınıfa değil, genel etkinliğe ve parça türlerine karşılık geldiğini unutmayın. Bunun nedeni, Hilt'in tüm etkinlikleri eklemek için tek bir etkinlik bileşeni tanımı kullanmasıdır. Her etkinliğin bu bileşenin farklı bir örneği vardır.

Uygulama bağlamı bağlama özelliği @ApplicationContext kullanılarak da kullanılabilir. Örnek:

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

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

public class AnalyticsServiceImpl implements AnalyticsService {

  private final Context context;

  @Inject
  AnalyticsAdapter(@ApplicationContext Context context) {
    this.context = context;
  }
}

// The Application binding is available without qualifiers.
public class AnalyticsServiceImpl implements AnalyticsService {

  private final Application application;

  @Inject
  AnalyticsAdapter(Application application) {
    this.application = application;
  }
}

Etkinlik bağlamı bağlama özelliği @ActivityContext kullanılarak da kullanılabilir. Örneğin:

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

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

public class AnalyticsAdapter {

  private final Context context;

  @Inject
  AnalyticsAdapter(@ActivityContext Context context) {
    this.context = context;
  }
}

// The Activity binding is available without qualifiers.
public class AnalyticsAdapter {

  private final FragmentActivity activity;

  @Inject
  AnalyticsAdapter(FragmentActivity activity) {
    this.activity = activity;
  }
}

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

Hilt, en yaygın Android sınıfları için destek içerir. Ancak, Hilt'in desteklemediği sınıflarda alan yerleştirme işlemi gerçekleştirmeniz gerekebilir.

Bu gibi 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 nesnelerin grafiğine ilk girdiği noktadır. Giriş noktaları, Hilt'in bağımlılık grafiğinde bağımlılık sağlayamadığı kodu kullanmasına olanak tanır.

Örneğin, Hilt içerik sağlayıcıları 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 ek açıklama eklenmiş ve nitelikler içeren bir arayüz tanımlamanız gerekir. Ardından, giriş noktasının yükleneceği bileşeni belirtmek için @InstallIn öğesini aşağıdaki şekilde ekleyin:

class ExampleContentProvider : ContentProvider() {

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

  ...
}

public class ExampleContentProvider extends ContentProvider {

  @EntryPoint
  @InstallIn(SingletonComponent.class)
  interface ExampleContentProviderEntryPoint {
    public AnalyticsService analyticsService();
  }
  ...
}

Bir giriş noktasına erişmek için EntryPointAccessors'den uygun statik yöntemi kullanın. Parametre, bileşen örneği veya bileşen tutucusu olarak işlev 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çıklamalarındaki 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()
    ...
  }
}

public class ExampleContentProvider extends ContentProvider {

  @Override
  public Cursor query(...) {
    Context appContext = getContext().getApplicationContext();
    ExampleContentProviderEntryPoint hiltEntryPoint =
      EntryPointAccessors.fromApplication(appContext, ExampleContentProviderEntryPoint.class);
    AnalyticsService analyticsService = hiltEntryPoint.analyticsService();
  }
}

Bu örnekte, giriş noktası SingletonComponent üzerinde yüklü olduğundan giriş noktasını almak için ApplicationContext kullanmanız gerekir. Almak istediğiniz bağlama ActivityComponent içinde yer verilecekse bunun yerine ActivityContext kullanılır.

Kılıç sapı ve hançer

Hilt, Dagger bağımlılık enjeksiyon kitaplığının üzerine inşa edilmiştir ve Dagger'ı Android uygulamasına dahil etmenin standart bir yolunu sunar.

Dagger ile ilgili olarak, Hilt'in hedefleri aşağıdaki gibidir:

• Android uygulamaları için Dagger ile ilgili altyapıyı basitleştirmek.
• 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.
• Test, hata ayıklama veya sürüm gibi çeşitli derleme türlerine farklı bağlamalar sağlamanın kolay bir yolunu sunmak amacıyla.

Android işletim sistemi kendi çerçeve sınıflarının çoğunu örneklendirdiğinden, bir Android uygulamasında Dagger'ı kullanmak için yüksek miktarda standart metin yazmanız gerekir. Hilt, bir Android uygulamasında Dagger kullanımında kullanılan standart kodu azaltmıştır. Hilt, aşağıdakileri otomatik olarak oluşturur ve sağlar:

• Normalde elle oluşturmanız gerekeceği Android çerçeve sınıflarını Dagger ile entegre etmeye yönelik bileşenler.
• 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 etmek için önceden tanımlanmış bağlamalar.
• @ApplicationContext ve @ActivityContext'ı temsil eden önceden tanımlanmış nitelikler.

Dagger ve Hilt kodu aynı kod tabanında birlikte bulunabilir. Ancak çoğu durumda, Dagger'ı Android'deki tüm kullanımınızı yönetmek için Hilt'i kullanmanız en iyisidir. Dagger kullanan bir projeyi Hilt'e taşımak için taşıma rehberini ve Dagger uygulamanızı Hilt codelab'e taşıma başlıklı makaleleri inceleyin.

Ek kaynaklar

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

Örnekler

Codelab uygulamaları

• Android uygulamanızda Hilt'i kullanma
• Dagger uygulamanızı Hilt'e taşıma

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