Dependency injection with Hilt in depth in Android Kotlin - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output when injecting a singleton with Hilt?

Consider a Hilt module that provides a singleton instance of a Repository class. If two different Android components inject this Repository, what will be the behavior of the injected instances?

Android Kotlin

@Module
@InstallIn(SingletonComponent::class)
object RepositoryModule {
    @Provides
    @Singleton
    fun provideRepository(): Repository = Repository()
}

class Repository {
    val id = System.identityHashCode(this)
}

@AndroidEntryPoint
class ActivityA : AppCompatActivity() {
    @Inject lateinit var repository: Repository
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        println("ActivityA Repository ID: ${repository.id}")
    }
}

@AndroidEntryPoint
class ActivityB : AppCompatActivity() {
    @Inject lateinit var repository: Repository
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        println("ActivityB Repository ID: ${repository.id}")
    }
}

A Each Activity receives a new Repository instance with different IDs.

B Both ActivityA and ActivityB receive the same Repository instance with identical IDs.

C Injection fails because Repository is not annotated with @Inject constructor.

D Both Activities receive null for Repository because it is not scoped to activities.

💡 Hint

Think about the @Singleton annotation and the component scope it is installed in.

The @Singleton annotation combined with @InstallIn(SingletonComponent::class) ensures that the same instance of Repository is shared across the entire application lifecycle. Therefore, both ActivityA and ActivityB receive the same instance, confirmed by identical identity hash codes.

📝 Syntax

intermediate

Which Hilt annotation is missing to enable constructor injection?

Given the following Kotlin class, which annotation must be added to enable Hilt to inject it via constructor injection?

Android Kotlin

class NetworkClient(private val baseUrl: String) {
    fun fetchData(): String = "Data from $baseUrl"
}

A @Inject constructor(private val baseUrl: String)

B @Provides fun NetworkClient()

C @Singleton class NetworkClient(private val baseUrl: String)

D @Module class NetworkClient(private val baseUrl: String)

💡 Hint

Constructor injection requires a specific annotation on the constructor.

To enable Hilt to inject a class via constructor injection, the constructor must be annotated with @Inject. This tells Hilt how to create instances of the class.

🔧 Debug

advanced

Why does this Hilt injection cause a runtime error?

Examine the following code snippet. What is the cause of the runtime error when injecting UserRepository into ViewModel?

Android Kotlin

@HiltViewModel
class UserViewModel @Inject constructor(
    private val userRepository: UserRepository
) : ViewModel()

class UserRepository @Inject constructor(
    private val apiService: ApiService
)

@Module
@InstallIn(ActivityComponent::class)
object NetworkModule {
    @Provides
    fun provideApiService(): ApiService = ApiService()
}

A ApiService class is missing @Inject constructor causing provider failure.

B UserRepository is missing @Singleton annotation causing multiple instances and conflict.

C ApiService is provided in ActivityComponent scope but UserViewModel is in ViewModelComponent, causing a scope mismatch.

D UserViewModel lacks @Singleton annotation causing injection failure.

💡 Hint

Check the component scopes where dependencies are provided and injected.

The ApiService is provided in ActivityComponent scope, but UserViewModel is created in ViewModelComponent scope. Hilt cannot inject a dependency from a shorter-lived component (Activity) into a longer-lived component (ViewModel), causing a runtime error.

🧠 Conceptual

advanced

What is the role of @InstallIn in Hilt modules?

Why is the @InstallIn annotation required on a Hilt module, and what does it control?

A @InstallIn is used to declare a module as a replacement for another module.

B @InstallIn marks a module as injectable via constructor injection.

C @InstallIn automatically generates a singleton instance of all provided dependencies.

D @InstallIn specifies the Hilt component(s) where the module's bindings are available, controlling the lifecycle and scope of provided dependencies.

💡 Hint

Think about how Hilt knows where to use the module's bindings.

@InstallIn tells Hilt which component(s) the module belongs to. This controls where the provided dependencies live and their lifecycle, such as SingletonComponent for app-wide singletons or ActivityComponent for activity-scoped dependencies.

❓ state_output

expert

What is the output of this Hilt assisted injection example?

Given the following code using Hilt's AssistedInject, what will be printed when creating a UserViewModel with userId = 42?

Android Kotlin

class UserRepository @Inject constructor()

class UserViewModel @AssistedInject constructor(
    private val userRepository: UserRepository,
    @Assisted private val userId: Int
) {
    fun printUser() = println("UserViewModel with userId: $userId and repo: $userRepository")
}

@AssistedFactory
interface UserViewModelFactory {
    fun create(userId: Int): UserViewModel
}

fun main() {
    // Simulate assisted injection factory usage
    val repo = UserRepository()
    val factory = object : UserViewModelFactory {
        override fun create(userId: Int) = UserViewModel(repo, userId)
    }
    val vm = factory.create(42)
    vm.printUser()
}

A UserViewModel with userId: 42 and repo: UserRepository@<hashcode>

B UserViewModel with userId: 0 and repo: UserRepository@<hashcode>

C Compilation error due to missing @Inject on UserViewModel constructor

D Runtime error because AssistedInject is not supported without Hilt setup

💡 Hint

Assisted injection allows passing runtime parameters while injecting other dependencies.

AssistedInject lets you inject dependencies and pass runtime parameters like userId. The factory creates UserViewModel with userId=42 and injected UserRepository instance, so the print shows the correct userId and repository reference.