How to Use Hilt in Android? A Comprehensive Guide


What is dependency injection (DI)?

Dependency Injection (DI) is a design pattern and a software development technique used in object-oriented programming to manage the dependencies between different components or objects in a more flexible and maintainable way.

In a software application, various classes or components often need to collaborate and interact with each other. These interactions create dependencies, which can make the code less modular and harder to maintain. Dependency Injection aims to address this issue by externalizing the dependencies of a class and providing them from the outside rather than having the class create them internally.

  1. Dependency: A dependency is any object that another object depends on to perform its work. For example, in a web application, a database connection, an HTTP client, or a configuration object can be dependencies.
  2. Injection: Instead of a class creating its own dependencies, they are injected or provided to the class from the outside. This is typically done through constructor injection, method injection, or property injection.
    • Constructor Injection: Dependencies are passed to a class through its constructor when an instance of the class is created.
    • Method Injection: Dependencies are passed to a specific method of a class when that method is called.
    • Property Injection: Dependencies are set as properties of the class after it’s created.
  3. Inversion of Control (IoC): Dependency Injection is often closely related to the concept of Inversion of Control. In traditional programming, the flow of control is determined by the program’s logic. In DI, the control of how dependencies are provided and used is inverted, meaning it’s controlled by an external framework or container. This allows for better decoupling and flexibility in the code.

Why should I use dependency injection in Android development?

Using Dependency Injection (DI) in Android development offers several significant advantages that can improve the architecture, maintainability, and testability of your Android applications.

What is dependency injection in Kotlin?

Imagine you’re building a huge Lego castle. You have many different Lego pieces, and they need to fit together perfectly to create your dream castle. Each Lego piece has a unique role: some are walls, some are towers, and some are drawbridges.

Now, think of computer programs as something similar to Lego castles. Instead of Lego pieces, programs are made up of small “building blocks” called “components” or “dependencies.” These building blocks help the program do its job, just like Lego pieces help create a castle.

Hilt Dependency Injection is like having a magical assistant who understands exactly which Lego pieces (or program components) you need, where to find them, and how to put them together. This magical assistant does this to make sure your program (or Lego castle) is strong, efficient, and easy to change when you want to add something new.

Here’s how Hilt works:

  1. Identifying Building Blocks: Hilt helps you identify which building blocks your program needs. Just like you know which Lego pieces you need for your castle, Hilt knows which program components are required.
  2. Getting the Right Blocks: Hilt goes to a special place (like a magical Lego store) where all the program building blocks are kept. It picks up the right blocks and brings them to your program.
  3. Assembling the Pieces: Hilt knows how to put these building blocks together correctly, just as you know how to assemble Lego pieces to build your castle. It connects them in the right way.
  4. Upgrading Your Castle: Later, if you want to add a new tower to your Lego castle, you don’t have to worry about how to fit it. Your magical assistant (Hilt) will find the right pieces and attach them without breaking anything.

So, Hilt Dependency Injection helps programmers build computer programs by making sure they have all the right building blocks and assembling them properly. It’s like having a skilled Lego builder for your software, making it strong, efficient, and ready for future improvements.

Dependency injection is a crucial concept in modern software development, as it promotes clean and maintainable code by decoupling components and managing object creation. Hilt is a popular library for dependency injection in Android apps, built on top of Dagger 2, which simplifies the setup process and reduces boilerplate code. In this tutorial, we’ll explore how to get started with Hilt in a Kotlin Android project.

What are the key components of Hilt?

Hilt is a dependency injection (DI) library for Android, officially recommended and supported by Google. It simplifies the process of implementing DI in Android apps by providing a set of components and annotations that work seamlessly with Android’s lifecycle and dependency injection framework, Dagger 2. Here are the key components of Hilt:

  1. Hilt Component: At the core of Hilt is the Hilt component. It’s an interface annotated with @Component, which defines the dependencies and how they should be provided throughout your Android application. Hilt generates Dagger components from these Hilt components to handle dependency injection.
  2. Modules: In Hilt, you can use Dagger modules as usual to define how to create or provide instances of your dependencies. However, Hilt simplifies module setup by providing predefined entry points like @InstallIn, which specifies the Hilt component to which the module should be installed. This reduces the need for manual Dagger component setup.
  3. AndroidEntryPoint: This annotation is used to mark Android classes, such as Activities, Fragments, Services, or Views, as entry points for dependency injection. When combined with Hilt, it allows you to inject dependencies into these Android components with ease. This annotation effectively replaces the need for writing boilerplate Dagger code.
  4. ViewModelInject: To inject dependencies into ViewModels, Hilt introduces the @ViewModelInject annotation. It simplifies the creation of ViewModel instances and allows you to inject dependencies directly into them without the need for factory classes.
  5. HiltViewModel: This annotation, combined with @ViewModelInject, is used to annotate ViewModel classes to indicate that they should be created and managed by Hilt. HiltViewModels can then receive dependencies through constructor injection.
  6. HiltAndroidApp: This annotation is used to mark your application class. It initializes the Hilt component that manages the application-level dependencies, making it the root component in your application’s dependency graph.
  7. Scoped Annotations: Hilt provides a set of predefined scoping annotations, such as @Singleton, @ActivityScoped, @FragmentScoped, etc., to define the scope and lifecycle of your dependencies. Scoping ensures that instances of dependencies are created and reused appropriately throughout the app’s lifecycle.
  8. AssistedInject: Although not unique to Hilt, it is often used in conjunction with Hilt. The @AssistedInject annotation, along with Dagger’s assisted injection library, simplifies the injection of dependencies into classes that require runtime parameters.

By leveraging these key components and annotations, Hilt streamlines the process of implementing dependency injection in Android apps, making it easier to manage the creation and injection of dependencies while adhering to best practices and maintaining code quality.

How to implement Dagger Hilt in Android kotlin?


Before we dive into Hilt, ensure you have the following set up:

  1. Android Studio or a compatible IDE.
  2. A Kotlin Android project.

Step 1: Create a Compose Project

Start by creating a new Android project with Compose support. You can do this in Android Studio by selecting “Compose” as the UI framework when creating a new project.

Step 2: Add Dagger Hilt Dependencies

Open your app’s build.gradle file and add the Dagger Hilt dependencies. Make sure you’re using the latest version of Dagger Hilt. You can check for the latest version on the official Hilt website.

// Add Dagger Hilt dependencies
implementation ""
kapt ""

// Add Hilt Navigation Compose
implementation "androidx.hilt:hilt-navigation-compose:1.0.0-alpha03"

Step 3: Enable Dagger Hilt

In your app’s build.gradle file, apply the Hilt Gradle plugin and Kotlin Android Extensions plugin at the top of the file:

apply plugin: 'kotlin-kapt'
apply plugin: ''

Step 4: Configure the Application

Create a custom Application class if you don’t already have one. Annotate it with @HiltAndroidApp to enable Hilt for your application:


class MyApplication : Application()

Step 5: Define Dependencies

Now, define the dependencies that you want to inject using Dagger Hilt. For example, let’s create a simple TaskRepository:

import javax.inject.Inject

class TaskRepository @Inject constructor() {
    // Repository logic here

Step 6: Inject Dependencies into Composables

To inject dependencies into your Composables, you can use the @HiltViewModel annotation for ViewModel classes or simply use @Inject for other dependencies.

For example, if you have a Composable that needs the TaskRepository:

import androidx.compose.runtime.Composable
import javax.inject.Inject

fun TaskListScreen(taskRepository: TaskRepository) {
    // Use taskRepository to fetch and display tasks

Step 7: Create Hilt-Aware Activities

To make your Composables aware of Hilt, you should annotate your activities or fragments with @AndroidEntryPoint:

import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        setContent {
            // Your Composable content here

Step 8: Build and Run

Build your project to allow Dagger Hilt to generate the necessary code. Ensure your dependencies are properly injected and use them in your Composables as needed.

That’s it! You’ve successfully integrated Dagger Hilt into your Compose-based Android project, allowing you to manage dependencies effectively and create a clean, modular app architecture.

Hilt Scopes

When you’re building a complex software application, you often have various components or parts of your code that need access to different sets of dependencies (like objects or services).

Hilt scopes allow you to define and manage how these dependencies are created and shared across your application.

1. Scope as a “Space”:

Think of a Hilt scope as a designated “space” or “zone” within your application where a specific set of objects exists and is available. Each scope represents a particular context or purpose.

2. Objects Within a Scope:

Within each scope, you can create and provide objects (dependencies) that are relevant to that specific context. For example, you might have a scope for the “User Profile” section of your app and another scope for “Chat Messaging.”

3. Object Lifecycle:

Objects created within a scope have a lifecycle tied to that scope. They are created when the scope is first accessed and are destroyed when the scope’s lifecycle ends. This ensures that objects are available when needed and cleaned up when they’re no longer necessary.

4. Preventing Confusion and Collisions:

Hilt scopes help prevent confusion and collisions between different parts of your application. Objects within one scope are isolated from objects in other scopes, reducing the risk of unintended interactions or conflicts.

Example: User Profile and Chat Messaging

Let’s say you have a messaging app with user profiles and chat messaging features. You can use Hilt scopes like this:

  • User Profile Scope: In this scope, you provide and manage objects related to user profiles, such as user information, avatars, and settings. These objects are isolated from the chat messaging objects.
  • Chat Messaging Scope: Here, you handle objects related to chat conversations, messages, and notifications. Objects in this scope don’t interfere with the user profile objects.

Advantages of Hilt Scopes:

  • Isolation: Each scope creates a controlled environment for dependencies, reducing the chances of bugs and conflicts.
  • Lifecycle Control: Objects within a scope are automatically managed in terms of creation and destruction, simplifying resource management.
  • Improved Testing: Scopes make it easier to isolate and test specific parts of your application independently.

In summary, Hilt scopes are a powerful tool for managing dependencies within your application. They help you organize, isolate, and control the lifecycle of objects, making your code more maintainable, testable, and less prone to issues related to dependency management.

These explanations provide developers with a more technical understanding of Dagger Hilt scopes and their use cases in Android application development.

Android ClassGenerated ComponentScope
View annotated with @WithFragmentBindingsViewWithFragmentComponent@ViewScoped

What is the purpose of the @HiltAndroidApp annotation?

@HiltAndroidApp annotation is a crucial starting point for integrating Dagger Hilt into your Android application. It signals that your application is Hilt-enabled and initializes the necessary Dagger components and configurations, streamlining the dependency injection process and making your code cleaner and more maintainable.

What is constructor injection in Hilt?

Constructor injection in Dagger Hilt is a form of dependency injection where the dependencies required by a class are provided through its constructor when the class is created. Hilt automates and simplifies the process of constructor injection by generating the necessary Dagger components and modules based on annotations and declarations.

Here’s how constructor injection works in Hilt:

  1. Annotate the Constructor: In a class that needs dependencies, you annotate its constructor with @Inject. This annotation tells Hilt that the dependencies should be provided through this constructor.
class ExampleClass @Inject constructor(private val dependency: SomeDependency) {
    // Class logic using the injected dependency

2. Hilt Provides Dependencies: Hilt is responsible for generating Dagger components and modules behind the scenes. It analyzes the @Inject annotation and generates the necessary code to provide the required dependencies.

3. No Need for Manual Dagger Setup: With Hilt, you don’t need to manually create Dagger components or modules or write Dagger-specific code for dependency injection. Hilt handles these tasks for you, making your code cleaner and more concise.

4. Inject Dependencies: When you create an instance of the class (e.g., ExampleClass()), Hilt automatically provides the required dependencies to the constructor. You don’t need to pass them explicitly; Hilt takes care of it.

Constructor injection is a fundamental concept in dependency injection, and Hilt simplifies the process by automating much of the setup and configuration, allowing you to focus on your application’s logic rather than the details of dependency injection.

Can I use Hilt with Java instead of Kotlin?

Yes, you can use Hilt with Java instead of Kotlin in your Android projects. While Hilt is often associated with Kotlin due to its concise and expressive syntax, it fully supports Java as well. Many of the concepts and annotations used in Hilt are language-agnostic, and you can achieve the same dependency injection benefits in Java.

What is the role of the Hilt component?

The Hilt component, often referred to as a Dagger Hilt component, plays a central role in managing and facilitating dependency injection in your Android application. It acts as a bridge between the modules that provide dependencies and the classes that need those dependencies.

How can I test code that uses Hilt dependencies?

Testing code that uses Hilt dependencies in Android is a crucial part of ensuring your app’s functionality and stability. Hilt provides mechanisms to facilitate testing, and you can use various testing frameworks like JUnit, Espresso, and Mockito

Are there any common pitfalls or best practices when using Hilt?

When using Dagger Hilt for dependency injection in Android, there are several common pitfalls and best practices to be aware of to ensure that your code remains maintainable, efficient, and easy to test. Here are some common pitfalls to avoid and best practices to follow:

Common Pitfalls:

  1. Ignoring Scopes: Using the wrong scope (e.g., not using @ActivityScoped for dependencies tied to an activity) can lead to unexpected behavior and memory leaks. Ensure you understand and use the appropriate scope annotations for your dependencies.
  2. Complex Dependencies: Avoid overly complex dependency graphs. Strive for simplicity by breaking down your application into smaller, more focused components and modules. This makes your code easier to manage and test.
  3. Using the Application Component for Everything: While the SingletonComponent (associated with @Singleton) can be tempting for all global dependencies, be cautious. It’s best suited for true singletons. Other dependencies should have more fine-grained scopes.
  4. Circular Dependencies: Be mindful of circular dependencies, where two or more objects depend on each other. These can lead to runtime issues and should be resolved by refactoring your code.
  5. Missing @Provides Methods: Ensure that you provide dependencies either through constructor injection (annotated with @Inject) or by creating @Provides methods in Dagger modules. Not providing a binding for a dependency can lead to compilation errors.

Best Practices:

  1. Use Constructor Injection: Whenever possible, prefer constructor injection over field injection. Constructor injection makes dependencies explicit, testable, and enforces immutability.
  2. Keep Modules Simple: Modules should have a single responsibility and provide related dependencies. Avoid creating monolithic modules with multiple responsibilities.
  3. Separate Interfaces: Separate interfaces from their implementations. This makes it easier to swap out implementations for testing or future changes.
  4. Use Hilt for Testing: Leverage Hilt’s testing support for unit tests, integration tests, and UI tests. This ensures that your tests use the same dependency injection configuration as your app.
  5. Avoid Manual Component Creation: Avoid manually creating Dagger components whenever possible. Let Hilt generate components for you based on annotations and configurations.
  6. Modularization: Consider modularizing your app and creating Dagger components and modules for each module. This promotes reusability and isolation of dependencies.
  7. Mock Dependencies for Unit Testing: When unit testing, use mocking frameworks like Mockito to provide controlled test environments. This allows you to isolate the class being tested from its dependencies.
  8. Use Proguard/R8 Safely: If you’re using Proguard or R8 for code shrinking and obfuscation, be cautious about rules that might inadvertently remove or obfuscate Dagger Hilt-related classes. Ensure your Proguard/R8 rules preserve necessary Hilt classes.

Feel free to follow and join my email list at no cost. Don’t miss out — sign up now!

Please check out my earlier blog post for more insights. Happy reading!

The Innovative Fundamentals of Android App Development in 2023

How to learn Android App Development in 2023 – Full Guide For Beginners using Kotlin Language

Ultimate Guideline on How to Use ViewModel Design Pattern

What is the Repository Pattern in Android? A Comprehensive Guide

What is ViewModel in Android? A Good Guide for Beginners

The Innovative Fundamentals of Android App Development in 2023

How to Say Goodbye to Activity Lifecycle and Say Hello to Compose Lifecycle ?

How to Monitor/Observe Network Availability for Android Projects

Exploring Sealed Class vs Enum in Kotlin Which is Best for Your Code?

What is the difference between Functional Programming and OOP?

Memory Leaks in Android Development A Complete Guide

0 0 votes
Article Rating
Notify of
Inline Feedbacks
View all comments
Would love your thoughts, please comment.x