Dependency injection with Hilt in depth in Android Kotlin - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is Dependency Injection (DI) in Android development?

Dependency Injection is a design pattern that helps provide objects that a class needs (its dependencies) from outside rather than creating them inside the class. This makes code easier to test, maintain, and reuse.

beginner

What is Hilt and why is it used in Android?

Hilt is a library built on top of Dagger that simplifies dependency injection in Android apps. It provides standard components and annotations to reduce boilerplate and make DI easier to implement.

intermediate

Explain the role of @HiltAndroidApp annotation.

The @HiltAndroidApp annotation is placed on the Application class. It triggers Hilt's code generation and creates a base class that manages the app-level dependency container.

intermediate

How do you inject dependencies into an Android Activity using Hilt?

You annotate the Activity with @AndroidEntryPoint. Then, you can use @Inject on fields or constructor parameters to get dependencies automatically provided by Hilt.

intermediate

What is a Hilt Module and how do you define one?

A Hilt Module is a class annotated with @Module and @InstallIn that tells Hilt how to provide certain dependencies. Inside, you define functions annotated with @Provides that return the objects to inject.

Which annotation do you use to enable Hilt in your Application class?

A @AndroidEntryPoint

B @Inject

C @HiltAndroidApp

D @Module

The @HiltAndroidApp annotation is required on the Application class to start Hilt's code generation and setup.

How do you tell Hilt to inject dependencies into an Activity?

A Call inject() manually in onCreate()

B Annotate the Activity with @AndroidEntryPoint

C Use @Provides inside the Activity

D Annotate the Activity with @HiltAndroidApp

Annotating the Activity with @AndroidEntryPoint allows Hilt to generate the necessary code to inject dependencies.

What is the purpose of a Hilt Module?

A To store UI layout files

B To replace the Application class

C To annotate Activities for injection

D To provide instructions on how to create dependencies

Modules tell Hilt how to create and provide dependencies using @Provides functions.

Which annotation is used on a function inside a Hilt Module to provide a dependency?

A @Provides

B @Inject

C @Singleton

D @EntryPoint

@Provides marks a function that returns an object Hilt can inject.

What scope annotation would you use to make a dependency live as long as the Application?

A @Singleton

B @FragmentScoped

C @ActivityScoped

D @ViewModelScoped

@Singleton scope means the dependency lives as long as the Application instance.

Describe the steps to set up Hilt in an Android app and inject a dependency into an Activity.

Think about annotations on Application, Activity, and Modules.

Explain how Hilt manages the lifecycle of dependencies and what scopes are available.

Consider how different parts of the app need different lifetimes for objects.

Practice

1. What is the primary purpose of using @Module and @Provides annotations in Hilt?

easy

A. To tell Hilt how to create and supply dependencies

B. To mark an Android Activity for injection

C. To automatically generate UI components

D. To define navigation between screens

Solution

1. Step 1: Understand the role of @Module

   @Module is used to group methods that provide dependencies to Hilt.

2. Step 2: Understand the role of @Provides

   @Provides annotates methods inside a module to tell Hilt how to create specific dependencies.

3. Final Answer:

   To tell Hilt how to create and supply dependencies -> Option A

4. Quick Check:

   @Module + @Provides = supply dependencies [OK]

Hint: Remember: @Module groups, @Provides creates dependencies [OK]

Common Mistakes:

• Confusing @Module with @AndroidEntryPoint
• Thinking @Provides creates UI elements
• Assuming @Module is for navigation

2. Which of the following is the correct way to inject a dependency into an Android Activity using Hilt?

easy

A. Annotate the Activity with @AndroidEntryPoint and use @Inject on the field

B. Use @Module on the Activity class

C. Call Hilt.inject(this) inside onCreate()

D. Add @Provides on the Activity constructor

Solution

1. Step 1: Identify how to enable injection in Activity

   Hilt requires the Activity to be annotated with @AndroidEntryPoint to generate necessary code.

2. Step 2: Inject dependencies with @Inject

   Fields or constructor parameters annotated with @Inject receive dependencies automatically.

3. Final Answer:

   Annotate the Activity with @AndroidEntryPoint and use @Inject on the field -> Option A

4. Quick Check:

   @AndroidEntryPoint + @Inject field = inject Activity dependency [OK]

Hint: Use @AndroidEntryPoint on Activity, then @Inject fields [OK]

Common Mistakes:

• Trying to use @Module on Activity
• Calling non-existent Hilt.inject() method
• Adding @Provides on constructors

3. Given the following code snippet, what will be the output when MyViewModel is injected?

class MyRepository @Inject constructor() {
    fun getData() = "Data from repository"
}

@HiltViewModel
class MyViewModel @Inject constructor(private val repo: MyRepository) : ViewModel() {
    fun fetch() = repo.getData()
}

medium

A. "fetch() method not found"

B. NullPointerException at runtime

C. Compilation error due to missing @Provides

D. "Data from repository"

Solution

1. Step 1: Understand constructor injection in MyRepository

   MyRepository has an @Inject constructor, so Hilt can create it automatically.

2. Step 2: MyViewModel receives MyRepository via constructor injection

   Hilt injects MyRepository instance into MyViewModel, so calling fetch() returns repo.getData() string.

3. Final Answer:

   "Data from repository" -> Option D

4. Quick Check:

   Constructor injection returns data string [OK]

Hint: If constructor has @Inject, Hilt creates instance automatically [OK]

Common Mistakes:

• Assuming @Provides is always needed
• Expecting runtime null errors with constructor injection
• Confusing method names in ViewModel

4. Identify the error in this Hilt module code:

@Module
@InstallIn(SingletonComponent::class)
object NetworkModule {
    @Provides
    fun provideHttpClient(): OkHttpClient {
        return OkHttpClient()
    }

    @Provides
    fun provideRetrofit(client: OkHttpClient): Retrofit {
        return Retrofit.Builder()
            .client(client)
            .baseUrl("https://api.example.com")
            .build()
    }
}

medium

A. Missing @Singleton annotation on provider methods

B. Retrofit.Builder() requires a converter factory

C. OkHttpClient cannot be provided without parameters

D. NetworkModule should be a class, not an object

Solution

1. Step 1: Review Retrofit.Builder usage

   Retrofit requires a converter factory (like GsonConverterFactory) to parse responses; missing here causes runtime error.

2. Step 2: Check other options for correctness

   @Singleton is optional but recommended; object is valid for modules; OkHttpClient can be created without parameters.

3. Final Answer:

   Retrofit.Builder() requires a converter factory -> Option B

4. Quick Check:

   Retrofit needs converter factory to build properly [OK]

Hint: Retrofit always needs a converter factory to avoid errors [OK]

Common Mistakes:

• Thinking @Singleton is mandatory for all providers
• Confusing object vs class for modules
• Assuming OkHttpClient needs parameters

5. You want to inject two different implementations of an interface Logger using Hilt. How can you distinguish them during injection?

hard

A. Use @Singleton on one implementation and omit on the other

B. Create two separate modules with the same provider method name

C. Use @Named qualifiers with different names on provider methods and injection points

D. Inject both implementations into a list automatically

Solution

1. Step 1: Understand multiple implementations injection

   When multiple bindings exist for the same type, Hilt requires qualifiers to distinguish them.

2. Step 2: Use @Named qualifiers

   Annotate provider methods and injection points with @Named("name") to specify which implementation to inject.

3. Final Answer:

   Use @Named qualifiers with different names on provider methods and injection points -> Option C

4. Quick Check:

   Multiple implementations need @Named qualifiers [OK]

Hint: Use @Named("tag") to differentiate implementations [OK]

Common Mistakes:

• Assuming module separation alone distinguishes implementations
• Using @Singleton to differentiate implementations
• Expecting automatic list injection without setup