Wstrzykiwanie zależności za pomocą Hilt

Hilt to biblioteka do wstrzykiwania zależności na Androida, która zmniejsza ilość kodu stałego w przypadku ręcznego wstrzykiwania zależności w projekcie. Ręczne wstrzyknięcie zależności wymaga ręcznego tworzenia każdej klasy i jej zależności oraz używania kontenerów do ponownego używania i zarządzania zależnościami.

Hilt udostępnia standardowy sposób korzystania z DI w aplikacji, zapewniając kontenery dla każdej klasy Androida w projekcie i automatycznie zarządzając ich cyklem życia. Hilt jest oparty na popularnej bibliotece DI Dagger, aby korzystać z prawidłowego działania w czasie kompilacji, wydajności w czasie wykonywania, skalowalności i obsługi Android Studio. Więcej informacji znajdziesz w artykule Hilt and Dagger.

Ten przewodnik zawiera podstawowe informacje o Hilt i generowanych przez niego kontenerach. Znajdziesz w nim też demonstrację uruchamiania istniejącej aplikacji za pomocą Hilt.

Dodawanie zależności

Najpierw dodaj wtyczkę hilt-android-gradle-plugin do pliku build.gradle w katalogu głównym projektu:

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
}

Następnie zastosuj wtyczkę Gradle i dodaj te zależności do pliku app/build.gradle:

...
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 korzysta z funkcji Java 8. Aby włączyć w projekcie wersję Java 8, dodaj do pliku app/build.gradle następujący wiersz:

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

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

Klasa aplikacji Hilt

Wszystkie aplikacje korzystające z Hilt muszą zawierać klasę Application, która jest opatrzona adnotacjami @HiltAndroidApp.

@HiltAndroidApp powoduje wygenerowanie kodu przez Hilta, w tym klasy podstawowej aplikacji, która służy jako kontener zależności na poziomie aplikacji.

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

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

Ten wygenerowany komponent Hilt jest dołączony do cyklu życia obiektu Application i zawiera jego zależności. Jest też nadrzędnym komponentem aplikacji, co oznacza, że inne komponenty mogą uzyskiwać dostęp do zależności, które ona udostępnia.

Wstrzykiwanie zależności do klas Androida

Gdy Hilt zostanie skonfigurowany w klasie Application i będzie dostępny komponent na poziomie aplikacji, Hilt może udostępniać zależności innym klasom Androida, które mają adnotację @AndroidEntryPoint:

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

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

Hilt obsługuje obecnie te klasy Androida:

• Application (za pomocą @HiltAndroidApp)
• ViewModel (za pomocą @HiltViewModel)
• Activity
• Fragment
• View
• Service
• BroadcastReceiver

Jeśli dodasz adnotację do klasy Androida za pomocą @AndroidEntryPoint, musisz też dodać adnotacje do klas Androida, które od niej zależą. Jeśli np. dodasz adnotację do fragmentu, musisz też dodać adnotacje do wszystkich aktywności, w których używasz tego fragmentu.

@AndroidEntryPoint generuje osobny komponent Hilt dla każdej klasy Androida w projekcie. Te komponenty mogą otrzymywać zależności z odpowiednich klas nadrzędnych zgodnie z opisem w hierarchii komponentów.

Aby uzyskać zależności od komponentu, użyj adnotacji @Inject do wykonania wstrzyknięcia pola:

@AndroidEntryPoint
class ExampleActivity : AppCompatActivity() {

  @Inject lateinit var analytics: AnalyticsAdapter
  ...
}

@AndroidEntryPoint
public class ExampleActivity extends AppCompatActivity {

  @Inject
  AnalyticsAdapter analytics;
  ...
}

Klasy, które Hilt wstrzykuje, mogą mieć inne klasy bazowe, które również korzystają z wstrzykiwania. Te klasy nie wymagają adnotacji @AndroidEntryPoint, jeśli są abstrakcyjne.

Aby dowiedzieć się więcej o tym, do którego wywołania zwrotnego cyklu życia jest wstrzykiwana klasa Androida, zapoznaj się z artykułem Cykl życia komponentu.

Definiowanie powiązań Hilt

Aby wykonać wstrzyknięcie pola, Hilt musi wiedzieć, jak udostępnić wystąpienia niezbędnych zależności z odpowiedniego komponentu. Binding zawiera informacje potrzebne do udostępnienia instancji typu jako zależności.

Jednym ze sposobów przekazywania informacji do Hilta jest wstrzyknięcie konstruktora. Użyj adnotacji @Inject w konstruktorze klasy, aby powiedzieć Hiltowi, jak udostępniać instancje tej klasy:

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

public class AnalyticsAdapter {

  private final AnalyticsService service;

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

Parametry adnotowanego konstruktora klasy to zależności tej klasy. W tym przykładzie element AnalyticsAdapter ma element AnalyticsService jako zależność. Dlatego Hilt musi też wiedzieć, jak udostępniać instancje AnalyticsService.

Moduły Hilt

Czasami nie można wstrzyknąć typu za pomocą konstruktora. Może się tak zdarzyć z wielu powodów. Nie można na przykład wstrzyknąć interfejsu za pomocą konstruktora. Nie możesz też stosować konstruktora do wstrzykiwania typu, którego nie posiadasz, np. klasy z biblioteki zewnętrznej. W takich przypadkach możesz przekazać Hiltowi informacje wiążące, korzystając z modułów Hilt.

Moduł Hilt to klasa oznaczona @Module. Podobnie jak moduł Dagger informuje Hilt, jak udostępniać instancje określonych typów. W przeciwieństwie do modułów Dagger musisz opatrzyć moduły Hilt adnotacjami @InstallIn, aby poinformować Hilt, w której klasie Androida ma być używany lub instalowany każdy moduł.

Zależność określona w modułach Hilt jest dostępna we wszystkich wygenerowanych komponentach powiązanych z klasą Androida, w której instalujesz moduł Hilt.

Wstrzykiwanie instancji interfejsu za pomocą @Binds

Rozważ przykład AnalyticsService. Jeśli AnalyticsService jest interfejsem, nie możesz go wstrzyknąć za pomocą konstruktora. Zamiast tego podaj Hilt informacje o wiązaniu, tworząc funkcję abstrakcyjną z annotacjami @Binds w module Hilt.

Adnotacja @Binds informuje Hilt, której implementacji użyć, gdy musi udostępnić instancję interfejsu.

Oznaczona funkcja przekazuje Hiltowi te informacje:

• Typ zwracany przez funkcję informuje Hilt, jakie interfejsy udostępnia funkcja.
• Parametr funkcji wskazuje Hilt, jaką implementację należy podać.

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

Moduł Hilt AnalyticsModule jest opatrzony adnotacją @InstallIn(ActivityComponent.class), ponieważ chcesz, aby Hilt wstrzyknął tę zależność do ExampleActivity. Ta adnotacja oznacza, że wszystkie zależności w AnalyticsModule są dostępne we wszystkich aktywnościach aplikacji.

Wstrzykiwanie instancji za pomocą @Provides

Interfejsy to nie jedyny przypadek, w którym nie można wstrzyknąć typu za pomocą konstruktora. Wstrzyknięcie konstruktora nie jest też możliwe, jeśli nie jesteś właścicielem klasy, ponieważ pochodzi ona z biblioteki zewnętrznej (klasy takie jak Retrofit, OkHttpClient lub bazy danych Room) lub jeśli instancje muszą być tworzone za pomocą schematu budowania.

Przyjrzyj się poprzedniemu przykładowi. Jeśli nie jesteś właścicielem klasy AnalyticsService, możesz poinformować Hilta, jak udostępniać instancje tego typu, tworząc funkcję w module Hilt i oznaczając ją adnotacją @Provides.

Oznaczona funkcja przekazuje Hiltowi te informacje:

• Typ zwracany przez funkcję informuje Hilt, jakiego typu są instancje funkcji.
• Parametry funkcji podają Hilt zależności odpowiedniego typu.
• Ciało funkcji określa, jak Hilt ma podać wystąpienie odpowiedniego typu. Hilt wykonuje ciało funkcji za każdym razem, gdy musi dostarczyć instancję tego typu.

@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);
  }
}

Podawanie wielu powiązań tego samego typu

Jeśli potrzebujesz Hilta do udostępniania różnych implementacji tego samego typu jako zależności, musisz przekazać mu wiele powiązań. Za pomocą kwalifikatorów możesz zdefiniować wiele powiązań tego samego typu.

Kwalifikator to adnotacja, która służy do identyfikowania określonego powiązania typu, gdy dany typ ma zdefiniowane liczne powiązania.

Rozważ ten przykład. Jeśli chcesz przechwytywać wywołania do AnalyticsService, możesz użyć obiektu OkHttpClient z przechwytywaczem. W przypadku innych usług może być konieczne przechwytywanie połączeń w inny sposób. W takim przypadku musisz podać Hiltowi informacje o tym, jak udostępnić 2 różne implementacje funkcji OkHttpClient.

Najpierw zdefiniuj kwalifikatory, których użyjesz do adnotacji metod @Binds lub @Provides:

@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 {}

Następnie Hilt musi wiedzieć, jak podać instancję typu, która odpowiada każdemu ograniczeniu. W takim przypadku możesz użyć modułu Hilt z @Provides. Obie metody mają ten sam typ zwracanej wartości, ale kwalifikatory oznaczają je jako 2 różne typy powiązań:

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

Możesz wstrzyknąć konkretny typ, którego potrzebujesz, oznaczając pole lub parametr odpowiednim ogranicznikiem:

// 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;
  ...
}

Sprawdzoną metodą jest dodawanie ograniczeń do wszystkich możliwych sposobów określenia zależności. Pozostawienie implementacji podstawowej lub wspólnej bez kwalifikatora może powodować błędy i prowadzić do wstrzyknięcia przez Hilta nieprawidłowej zależności.

Wstępnie zdefiniowane kwalifikatory w Hilt

Hilt udostępnia kilka wstępnie zdefiniowanych predyktorów. Ponieważ na przykład może Ci być potrzebna klasa Context z aplikacji lub aktywności, Hilt udostępnia kwalifikatory @ApplicationContext i @ActivityContext.

Załóżmy, że klasa AnalyticsAdapter z przykładu potrzebuje kontekstu czynności. Poniższy kod pokazuje, jak podać kontekst aktywności funkcji AnalyticsAdapter:

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;
  }
}

Inne wstępnie zdefiniowane powiązania dostępne w Hilt znajdziesz w sekcji Domyślne powiązania komponentów.

Wygenerowane komponenty dla klas Android

W przypadku każdej klasy Androida, w której można wykonywać wstrzykiwanie pól, istnieje powiązany komponent Hilt, do którego można się odwoływać w adnotacji @InstallIn. Każdy komponent Hilt odpowiada za wstrzyknięcie swoich powiązań do odpowiedniej klasy Androida.

W poprzednich przykładach pokazano użycie ActivityComponent w modułach Hilt.

Hilt udostępnia te komponenty:

Czas życia komponentów

Hilt automatycznie tworzy i niszczy instancje wygenerowanych klas komponentów zgodnie z cyklem życia odpowiednich klas Androida.

Zakresy komponentów

Domyślnie wszystkie powiązania w Hilt są nieskoordynowane. Oznacza to, że za każdym razem, gdy aplikacja żąda powiązania, Hilt tworzy nową instancję odpowiedniego typu.

W tym przykładzie za każdym razem, gdy Hilt udostępnia AnalyticsAdapter jako zależność innego typu lub za pomocą wstrzyknięcia pola (jak w ExampleActivity), udostępnia nowy egzemplarz AnalyticsAdapter.

Hilt umożliwia też ograniczenie zakresu powiązania do konkretnego komponentu. Hilt tworzy ograniczone wiązanie tylko raz na instancję komponentu, do którego jest ono ograniczone, a wszystkie żądania tego wiązania korzystają z tej samej instancji.

Tabela poniżej zawiera adnotacje zakresu dla każdego wygenerowanego komponentu:

W tym przykładzie, jeśli zawęzisz zakres AnalyticsAdapter do ActivityComponent za pomocą @ActivityScoped, Hilt udostępnia tę samą instancję AnalyticsAdapter przez cały czas trwania odpowiedniej czynności:

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

@ActivityScoped
public class AnalyticsAdapter {

  private final AnalyticsService service;

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

Załóżmy, że AnalyticsService ma stan wewnętrzny, który wymaga, aby za każdym razem używano tego samego wystąpienia, nie tylko w ExampleActivity, ale w dowolnym miejscu w aplikacji. W tym przypadku odpowiednie jest ograniczenie zakresu AnalyticsService do SingletonComponent. W rezultacie, gdy komponent musi udostępnić instancję AnalyticsService, zawsze udostępnia tę samą instancję.

Ten przykład pokazuje, jak określić zakres powiązania z komponentem w module Hilt. Zakres powiązania musi być zgodny z zakresem komponentu, w którym jest zainstalowany. W tym przykładzie musisz zainstalować AnalyticsService w SingletonComponent zamiast ActivityComponent:

// 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);
  }
}

Więcej informacji o zakresie działania komponentów Hilt znajdziesz w artykule Zapisywanie zakresu działania w Androidzie i Hilt.

Hierarchia komponentów

Instalowanie modułu w komponencie umożliwia dostęp do jego powiązań jako zależności innych powiązań w tym komponencie lub w dowolnym podrzędnym komponencie w hierarchii komponentów:

Powiązania domyślne komponentów

Każdy komponent Hilt jest dostarczany z zestawem domyślnych powiązań, które Hilt może wstrzyknąć jako zależności do własnych niestandardowych powiązań. Pamiętaj, że te powiązania odpowiadają ogólnym typom aktywności i fragmentów, a nie poszczególnym podklasom. Dzieje się tak, ponieważ Hilt używa jednej definicji komponentu aktywności do wstrzykiwania wszystkich aktywności. Każda aktywność ma inne wystąpienie tego komponentu.

Wiązanie kontekstu aplikacji jest też dostępne za pomocą @ApplicationContext. Przykład:

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;
  }
}

Wiązanie kontekstu aktywności jest też dostępne za pomocą @ActivityContext. Na przykład:

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;
  }
}

Wstrzykiwanie zależności w klasach, które nie są obsługiwane przez Hilt

Hilt obsługuje większość typowych klas Androida. Może jednak być konieczne wykonanie wstrzyknięcia pola w klasach, których Hilt nie obsługuje.

W takich przypadkach możesz utworzyć punkt wejścia za pomocą adnotacji @EntryPoint. Punkt wejścia to granica między kodem zarządzanym przez Hilta a kodem, który nie jest zarządzany przez Hilta. Jest to punkt, w którym kod po raz pierwszy wchodzi do grafu obiektów zarządzanych przez Hilt. Punkty wejścia umożliwiają Hiltowi korzystanie z kodu, który nie jest w stanie zapewnić zależności w grafu zależności.

Na przykład Hilt nie obsługuje bezpośrednio dostawców treści. Jeśli chcesz, aby dostawca treści używał Hilt do uzyskiwania niektórych zależności, musisz zdefiniować interfejs z adnotacjami @EntryPoint dla każdego typu powiązania, którego chcesz użyć, oraz uwzględnić ograniczniki. Następnie dodaj @InstallIn, aby określić komponent, w którym chcesz zainstalować punkt wejścia:

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

Aby uzyskać dostęp do punktu wejścia, użyj odpowiedniej metody statycznej z EntryPointAccessors. Parametr powinien być wystąpieniem komponentu lub obiektem @AndroidEntryPoint, który pełni rolę uchwytu komponentu. Upewnij się, że komponent przekazywany jako parametr i statyczna metoda EntryPointAccessors pasują do klasy Androida w adnotacji @InstallIn w interfejsie @EntryPoint:

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

W tym przykładzie musisz użyć funkcji ApplicationContext, aby pobrać punkt wejścia, ponieważ jest on zainstalowany w komponencie SingletonComponent. Jeśli binding, które chcesz pobrać, znajduje się w ActivityComponent, użyj polecenia ActivityContext.

Hilt and Dagger

Hilt jest oparty na bibliotece do wstrzykiwania zależności Dagger i stanowi standardowy sposób włączania Daggera do aplikacji na Androida.

W odniesieniu do Daggera cele Hilta są następujące:

• uproszczenie infrastruktury związanej z Daggerem w przypadku aplikacji na Androida;
• Aby utworzyć standardowy zestaw komponentów i zakresów, który ułatwia konfigurację, czytelność i udostępnianie kodu między aplikacjami.
• Aby ułatwić tworzenie różnych powiązań dla różnych typów kompilacji, takich jak testowanie, debugowanie czy wersja produkcyjna.

System operacyjny Android tworzy wiele własnych klas frameworka, więc korzystanie z Daggera w aplikacji na Androida wymaga napisania dużej ilości kodu stałego. Hilt zmniejsza ilość kodu stałego używanego do korzystania z Daggera w aplikacji na Androida. Hilt automatycznie generuje i udostępnia te funkcje:

• Komponenty do integracji klas frameworka Androida z Daggerem, które w przeciwnym razie trzeba by utworzyć ręcznie.
• Adnotacje zakresu do stosowania w przypadku komponentów generowanych automatycznie przez Hilt.
• Wstępnie zdefiniowane powiązania reprezentujące klasy Androida, takie jak Application lub Activity.
• Wstępnie zdefiniowane kwalifikatory reprezentujące @ApplicationContext i @ActivityContext.

Kod Dagger i Hilt mogą współistnieć w tej samej bazie kodu. W większości przypadków najlepiej jednak używać Hilt do zarządzania wszystkimi zastosowaniami Daggera na Androidzie. Aby przenieść projekt korzystający z Dagger do Hilt, zapoznaj się z przewodnikiem i z ćwiczeniem kodowania dotyczącym przenoszenia aplikacji Dagger do Hilt.

Dodatkowe materiały

Więcej informacji o Hilt znajdziesz w tych dodatkowych materiałach.

Próbki

Ćwiczenia z programowania

• Korzystanie z Hilt w aplikacji na Androida
• Migracja aplikacji Dagger do Hilt

Blogi

• Wstrzykiwanie zależności na Androidzie za pomocą Hiltu
• Zakres działania w Androidzie i Hilt
• Dodawanie komponentów do hierarchii Hilt
• Migracja aplikacji Google I/O do Hilta