Dagger hilt android gradle

Quick Start Guide

Introduction

Hilt makes it easy to add dependency injection to your Android app. This tutorial will guide you through bootstrapping an existing app to use Hilt.

For more on the basic concepts of Hilt’s components, check out Hilt Components.

Gradle vs non-Gradle users

For Gradle users, the Hilt Gradle plugin makes usages of some Hilt annotations easier by avoiding references to Hilt generated classes.

Without the Gradle plugin, the base class must be specified in the annotation and the annotated class must extend the generated class:

With the Gradle plugin the annotated class can extend the base class directly:

Further examples assume usage of the Hilt Gradle plugin.

Hilt Application

All apps using Hilt must contain an Application class annotated with @HiltAndroidApp . @HiltAndroidApp kicks off the code generation of the Hilt components and also generates a base class for your application that uses those generated components. Because the code generation needs access to all of your modules, the target that compiles your Application class also needs to have all of your Dagger modules in its transitive dependencies.

Just like other Hilt Android entry points, Applications are members injected as well. This means you can use injected fields in the Application after super.onCreate() has been called.

For example, take the class called MyApplication that extends MyBaseApplication and has a member variable Bar :

With Hilt’s members injection, the above code becomes:

@AndroidEntryPoint

Once you have enabled members injection in your Application , you can start enabling members injection in your other Android classes using the @AndroidEntryPoint annotation. You can use @AndroidEntryPoint on the following types:

Note that ViewModels are supported via a separate API @HiltViewModel . The following example shows how to add the annotation to an activity, but the process is the same for other types.

To enable members injection in your activity, annotate your class with @AndroidEntryPoint .

Note: Hilt currently only supports activities that extend ComponentActivity and fragments that extend androidx library Fragment , not the (now deprecated) Fragment in the Android platform.

Hilt Modules

Hilt modules are standard Dagger modules that have an additional @InstallIn annotation that determines which Hilt component(s) to install the module into.

When the Hilt components are generated, the modules annotated with @InstallIn will be installed into the corresponding component or subcomponent via @Component#modules or @Subcomponent#modules respectively. Just like in Dagger, installing a module into a component allows that binding to be accessed as a dependency of other bindings in that component or any child component(s) below it in the component hierarchy. They can also be accessed from the corresponding @AndroidEntryPoint classes. Being installed in a component also allows that binding to be scoped to that component.

Using @InstallIn

A module is installed in a Hilt Component by annotating the module with the @InstallIn annotation. These annotations are required on all Dagger modules when using Hilt, but this check may be optionally disabled.

Note: If a module does not have an @InstallIn annotation, the module will not be part of the component and may result in compilation errors.

Specify which Hilt Component to install the module in by passing in the appropriate Component type(s) to the @InstallIn annotation. For example, to install a module so that anything in the application can use it, use SingletonComponent :

Источник

Практическое руководство по использованию Hilt с Kotlin

А также делимся переводом полезной статьи.

Простой способ использовать внедрение зависимостей в приложениях для Android

Hilt — это новая библиотека для внедрения зависимостей, построенная на основе Dagger. Она позволяет использовать возможности Dagger в приложениях для Android упрощенным способом. В этом руководстве описаны основные функциональные возможности библиотеки и приведено несколько фрагментов кода, которые помогут вам начать использовать Hilt в своих проектах.

Настройка Hilt

Чтобы настроить Hilt в своем приложении, сначала выполните указания из руководства: Установка Gradle Build.

После установки всех необходимых элементов и подключаемых модулей, чтобы использовать Hilt, задайте своему классу Application аннотацию @HiltAndroidApp. Больше ничего делать не нужно, а также не нужно вызывать Hilt напрямую.

Определение и внедрение зависимостей

При написании кода, в котором используется внедрение зависимостей, есть два основных компонента, которые следует учитывать:

Классы, имеющие зависимости, которые вы собираетесь внедрить.

Классы, которые могут быть внедрены как зависимости.

Они не являются взаимоисключающими: во многих случаях класс одновременно является внедряемым и имеет зависимости.

Как сделать зависимость внедряемой

Чтобы в Hilt сделать объект внедряемым, необходимо указать для Hilt способ создания экземпляра этого объекта. Такие инструкции называются привязками.

Есть три способа определения привязки в Hilt.

Добавить к конструктору аннотацию @Inject

Использовать @Binds в модуле

Использовать @Provides в модуле

⮕ Добавление к конструктору аннотации @Inject

У любого класса может быть конструктор с аннотацией @Inject , что позволяет использовать его в качестве зависимости в любом месте проекта.

⮕ Использование модуля

Два других способа преобразования объектов во внедряемые в Hilt связаны с использованием модулей.

Модуль Hilt можно считать набором «рецептов», указывающих Hilt, как создать экземпляр того или иного объекта, у которого нет конструктора, — например, интерфейса или системной службы.

Кроме того, в тестах любой модуль можно заменить другим модулем. Например, это позволяет легко заменять реализации интерфейсов мок-объектами.

Модули устанавливаются в компонент Hilt, который указывается с помощью аннотации @InstallIn . Я дам более подробное объяснение ниже.

Вариант 1: использовать @Binds, чтобы создать привязку для интерфейса

Если вы хотите использовать в своем коде OatMilk, когда требуется Milk, создайте абстрактный метод внутри модуля и задайте ему аннотацию @Binds . Обращаю внимание, чтобы этот вариант работал, сам OatMilk должен быть внедряемым. Для этого его конструктору необходимо задать аннотацию @Inject .

Вариант 2: создать функцию-фабрику с помощью @Provides

Когда экземпляр нельзя сконструировать напрямую, можно создать поставщик. Поставщик — это функция-фабрика, которая возвращает экземпляр объекта.

В качестве примера можно привести системную службу, скажем ConnectivityManager, которую необходимо получить из контекста.

Объект Context является внедряемым по умолчанию, если задать ему аннотацию @ApplicationContext либо @ActivityContext .

Внедрение зависимости

После того как вы сделали нужные зависимости внедряемыми, их можно внедрять с помощью Hilt двумя способами.

Как параметры конструктора

⮕ Как параметры конструктора

Если пометить конструктор аннотацией @Inject , Hilt внедрит все параметры в соответствии с привязками, которые вы определили для этих типов.

⮕ Как поля

Если класс является точкой входа, указанной с использованием аннотации @AndroidEntryPoint (подробнее об этом рассказано в следующем разделе), внедрены будут все поля, помеченные аннотацией @Inject .

Поля, помеченные аннотацией @Inject , должны быть общедоступными. Также удобно пометить их модификатором lateinit, чтобы не пришлось обеспечивать поддержку ими пустого значения, поскольку перед внедрением они имеют исходное значение null .

Обратите внимание, внедрять зависимости как поля стоит только тогда, когда у класса должен быть конструктор без параметров, например Activity . В большинстве случаев рекомендуется внедрять зависимости посредством параметров конструктора.

Прочие важные понятия

Точка входа

Помните, я сказал, что во многих случаях класс создается путем внедрения и имеет зависимости, внедренные в него? В некоторых случаях у вас будет класс, который не создается путем внедрения зависимости, но имеет зависимости, внедренные в него. Хорошим примером этого являются активности, которые в стандартной ситуации создаются платформой Android, а не библиотекой Hilt.

Эти классы являются точками входа в график зависимостей Hilt, а Hilt необходимо знать, что у них есть зависимости, требующие внедрения.

⮕ Точка входа Android

Большинство ваших точек входа будут так называемыми точками входа Android:

Если это так, такой точке входа следует задать аннотацию @AndroidEntryPoint .

⮕ Другие точки входа

Большинству приложений обычно нужны только точки входа Android, но если вы взаимодействуете с библиотеками, не работающими с Dagger, или с компонентами Android, которые пока не поддерживаются в Hilt, то вам может потребоваться создать собственную точку входа для доступа к графику Hilt вручную. Можете ознакомиться с инструкциями по преобразованию произвольных классов в точки входа.

ViewModel

ViewModel — это особый случай: экземпляры этого класса не создаются напрямую, так как они должны создаваться платформой, при этом он также не является точкой входа Android. Вместо этого с классами ViewModel используют специальную аннотацию @ViewModelInject , которая позволяет Hilt внедрять в них зависимости, когда они создаются с помощью выражения by viewModels() . Это похоже на то, как @Inject работает для других классов.

Если вам требуется доступ к состоянию, сохраняемому в классе ViewModel , внедрите SavedStateHandle в качестве параметра конструктора, добавив аннотацию @Assisted .

Чтобы использовать @ViewModelInject , вам нужно будет добавить еще несколько зависимостей. Дополнительные сведения см. в статье: Интеграции Hilt и Jetpack.

Компоненты

Каждый модуль устанавливается внутри компонента Hilt, который указывается с помощью аннотации @InstallIn ( ). Компонент модуля используется главным образом для предотвращения случайного внедрения зависимости не в том месте. Например, аннотация @InstallIn ( ServiceComponent.class ) не позволит использовать привязки и поставщики, имеющиеся в соответствующем модуле, внутри активности.

Кроме того, использование привязки можно ограничить пределами компонента, в котором находится модуль. Что приводит меня к…

Области

По умолчанию у привязок нет областей. В приведенном выше примере это означает, что каждый раз, когда вы внедряете Milk, вы получаете новый экземпляр OatMilk. Если добавить аннотацию @ActivityScoped , область использования привязки будет ограничена пределами ActivityComponent .

Теперь, когда у модуля есть область действия, Hilt будет создавать только один OatMilk на экземпляр активности. Кроме того, этот экземпляр OatMilk будет привязан к жизненному циклу этой активности — он будет создаваться при вызове onCreate() активности и уничтожаться при вызове onDestroy() активности.

В этом случае и milk, и moreMilk будут указывать на один и тот же экземпляр OatMilk. Однако, если у вас несколько экземпляров LatteActivity, у каждого из них будет собственный экземпляр OatMilk.

Соответственно, у других зависимостей, внедренных в эту активность, будет та же область, поэтому они тоже будут использовать тот же экземпляр OatMilk:

Область зависит от компонента, в который установлен ваш модуль. Например, @ActivityScoped можно применить только к привязкам, находящимся внутри модуля, который установлен внутри ActivityComponent .

Область также определяет жизненный цикл внедренных экземпляров: в данном случае одиночный экземпляр Milk, используемый Fridge и LatteActivity, создается, когда onCreate() вызывается для LatteActivity, — и уничтожается в его onDestroy() . Это также означает, что наш Milk не «переживет» изменение конфигурации, поскольку при этом вызывается onDestroy() для активности. Преодолеть это можно путем использования области с более длительным жизненным циклом, например @ActivityRetainedScope .

Список имеющихся областей, компонентов, которым они соответствуют, и жизненных циклов, которым они следуют, приведен в статье: Компоненты Hilt.

Внедрение поставщика

Иногда требуется более прямой контроль над созданием внедренных экземпляров. Например, вам требуется, чтобы один или несколько экземпляров какого-то объекта внедрялись только тогда, когда они нужны, в соответствии с бизнес-логикой. В этом случае можно использовать dagger.Provider.

Внедрение поставщика можно использовать независимо от того, чем является зависимость и как она внедряется. Любой объект, который можно внедрить, можно обернуть в Provider , чтобы для него использовалось внедрение поставщика.

Фреймворки внедрения зависимостей (такие как Dagger и Guice) обычно применяются в крупномасштабных, сложных проектах. В то же время библиотека Hilt, будучи простой в освоении и настройке, предоставляет все возможности Dagger в пакете, который можно использовать в приложениях любого типа, независимо от размеров кодовой базы.

Если хотите поближе познакомиться с библиотекой Hilt и принципами ее работы, а также узнать о других ее возможностях, которые могут оказаться вам полезными, отправляйтесь на ее официальный веб-сайт, где приведен подробный обзор и справочная документация.

Прямо сейчас в OTUS стартовала новогодняя распродажа. Скидка распространяется абсолютно на все курсы. Сделайте подарок себе или близким — переходите на сайт и забирайте курс со скидкой. А в качестве бонуса предлагаем зарегистрироваться на абсолютно бесплатные демо-уроки :

Источник

Dagger hilt android gradle

A fast dependency injector for Java and Android.

Dagger is a compile-time framework for dependency injection. It uses no reflection or runtime bytecode generation, does all its analysis at compile-time, and generates plain Java source code.

Dagger is actively maintained by the same team that works on Guava. Snapshot releases are auto-deployed to Sonatype’s central Maven repository on every clean build with the version HEAD-SNAPSHOT . The current version builds upon previous work done at Square.

You can find the dagger documentation here which has extended usage instructions and other useful information. More detailed information can be found in the API documentation.

First, import the Dagger repository into your WORKSPACE file using http_archive .

Note: The http_archive must point to a tagged release of Dagger, not just any commit. The version of the Dagger artifacts will match the version of the tagged release.

Next you will need to setup targets that export the proper dependencies and plugins. Follow the sections below to setup the dependencies you need.

First, load the Dagger artifacts and repositories, and add them to your list of maven_install artifacts.

Next, load and call dagger_rules in your top-level BUILD file:

This will add the following Dagger build targets: (Note that these targets already export all of the dependencies and processors they need).

Dagger Android Setup

First, load the Dagger Android artifacts and repositories, and add them to your list of maven_install artifacts.

Next, load and call dagger_android_rules in your top-level BUILD file:

This will add the following Dagger Android build targets: (Note that these targets already export all of the dependencies and processors they need).

Hilt Android Setup

First, load the Hilt Android artifacts and repositories, and add them to your list of maven_install artifacts.

Next, load and call hilt_android_rules in your top-level BUILD file:

This will add the following Hilt Android build targets: (Note that these targets already export all of the dependencies and processors they need).

Other build systems

You will need to include the dagger-2.x.jar in your application’s runtime. In order to activate code generation and generate implementations to manage your graph you will need to include dagger-compiler-2.x.jar in your build at compile time.

In a Maven project, include the dagger artifact in the dependencies section of your pom.xml and the dagger-compiler artifact as an annotationProcessorPaths value of the maven-compiler-plugin :

If you are using a version of the maven-compiler-plugin lower than 3.5 , add the dagger-compiler artifact with the provided scope:

If you use the beta dagger-producers extension (which supplies parallelizable execution graphs), then add this to your maven configuration:

If you’re using classes in dagger.android you’ll also want to include:

• We use implementation instead of api for better compilation performance.
  • See the Gradle documentation for more information on how to select appropriately, and the Android Gradle plugin documentation for Android projects.
• For Kotlin projects, use kapt in place of annotationProcessor .

If you’re using the Android Databinding library, you may want to increase the number of errors that javac will print. When Dagger prints an error, databinding compilation will halt and sometimes print more than 100 errors, which is the default amount for javac . For more information, see Issue 306.

If you do not use maven, gradle, ivy, or other build systems that consume maven-style binary artifacts, they can be downloaded directly via the Maven Central Repository.

Developer snapshots are available from Sonatype’s snapshot repository, and are built on a clean build of the GitHub project’s master branch.

Источник