Documentation about Hilt injection in the project

[Dynavy]

1. Introduction to Hilt in dependency injection:

Hilt is a dependency injection (DI) library built on top of Dagger for Android. It simplifies managing dependencies by automating much of the setup, reducing boilerplate code, and enhancing the maintainability and scalability of your app. Prior to Hilt, managing dependencies in large projects was cumbersome, requiring repetitive manual injections across multiple classes. With Hilt, dependencies are injected automatically, ensuring a clean and efficient structure.

Using Hilt allows for more modular, testable, and maintainable code, which is crucial as the app grows in complexity.

2. Using Hilt in the project:

In our project, Hilt was implemented to efficiently manage the app’s core services, repositories, and ViewModels.
The goal was to simplify the process of dependency injection and reduce the manual work of wiring dependencies across the app. This was especially important in scenarios like handling dependencies in multiple layers such as screens, services, and ViewModels.

3. AppModule file in Hilt:

The AppModule is a central place where we define and provide the dependencies needed across the entire application. This module is responsible for setting up services, repositories, and other dependencies that are used throughout the app.

Services:

We define core services like AuthService, GroupService, and ProfileService in AppModule. These services handle business logic and interact with external resources (e.g., APIs). By marking these services as @Singleton, we ensure that only a single instance of each service is used throughout the application, which is important for performance and consistency.

@Provides
@Singleton
fun provideAuthService(): AuthService {
    return AuthService(RetrofitInstance.api)
}

Repositories:

Repositories such as UserRepository, GroupRepository, and ProfileRepository manage data access and communication with the backend or local storage. These repositories often depend on services like AuthService or GroupService. By injecting the services into the repositories, we can manage data flow and ensure that the app has consistent access to its data layer.

@Provides
@Singleton
fun provideUserRepository(authService: AuthService): UserRepository {
    return UserRepository(authService)
}

4. ViewModels:

ViewModels are another crucial component that benefits from dependency injection. In Android development, ViewModels are responsible for holding and managing UI-related data. They communicate with repositories to fetch or modify data and provide it to the UI (e.g., activities or fragments). By injecting the required services and repositories directly into ViewModels, we avoid having to instantiate these dependencies manually.

For example, instead of manually creating an instance of AuthService or UserRepository in the AuthViewModel, Hilt will automatically inject them, ensuring the ViewModel has the necessary dependencies.

@HiltViewModel
class AuthViewModel @Inject constructor(
    private val authService: AuthService
) : ViewModel() {
    // ViewModel logic that interacts with the injected AuthService
}

5. Challenges we had before implementing Hilt:

Before Hilt, when adding or modifying dependencies like a new service or repository, it required manual injection across multiple layers. For example:

• Injecting a service like AuthService into a screen (e.g., AuthScreen).

• Passing it down to the AuthViewModel.

• Injecting the AuthViewModel into the UI layer (e.g., an activity or fragment).

This process often became repetitive and error-prone, leading to a situation where changes had to be made in many places across the codebase. Hilt addresses this challenge by automating the injection process, allowing us to define services and repositories in AppModule, which are then automatically injected where needed.

6. Why Hilt was implemented:

The main reason for implementing Hilt was to reduce the complexity of dependency management and to ensure that services, repositories, and ViewModels could be easily shared and injected throughout the app. The key benefits included:

• Simplified Dependency Injection: Once a service or repository is provided in AppModule, it can be injected into any class, such as ViewModels, activities, or fragments, without the need for repeated manual injection.

• Improved Code Maintainability: The centralization of dependencies in AppModule makes the code easier to maintain and scale, as changes to dependencies only need to be made in one place.

• Automatic Dependency Management: Hilt handles the lifecycle of dependencies (e.g., singleton instances), reducing the risk of memory leaks and ensuring consistent behavior across the app.

7. ViewModels and Hilt

While services and repositories are crucial for managing the app's business logic and data, ViewModels are essential for managing UI-related data.
With Hilt, ViewModels can be injected with the necessary services or repositories directly, making it easy to manage data and business logic separately from the UI layer. This separation improves code structure and testing, as the ViewModel can be tested independently of the UI.

For instance, in the AuthViewModel, instead of manually creating an instance of AuthService, we simply annotate the constructor with @Inject, and Hilt takes care of the rest:

@HiltViewModel
class AuthViewModel @Inject constructor(
    private val authService: AuthService
) : ViewModel() {
    // Logic for authentication, interacting with the AuthService
}

NOTE:
By doing this, we avoid the need for creating an instance of AuthService within the ViewModel or screen, lining the process and ensuring that dependencies are consistent and easy to manage.

8. Conclusion

Using Hilt in the project has significantly improved how injections are managed across services, repositories, and ViewModels.
The main advantage is that Hilt automates the process of dependency injection, reducing the need for repetitive manual wiring and ensuring that dependencies are easily accessible throughout the app. This has not only simplified development but also made the codebase more maintainable, modular, and scalable.

By integrating Hilt, we’ve addressed the challenges of dependency injection, making it easier to manage complex dependencies and ensuring that the app can grow without becoming harder to maintain.

[Dynavy]

08/04/2025 - Hilt Documentation

@poksyy, @krschan