Search for a command to run...
Android, ViewModel, Dependency Injection, Annotation, Dagger2/Hilt, MVVM, JetPack
Senior Android Engineer from Bangladesh. Love to contribute in Open-Source. Indie Music Producer.
No comments yet. Be the first to comment.
In this series, I will write about Android App Development.
UseCases of LiveData and Flow in Modern Android Development.
A practical guide to choosing the right coroutine primitive for your Android/Kotlin projects
This guide explains what Channels are, when to use them, how to use them correctly, and when NOT to use them — in simple, professional language. 1. What problem do Channels solve? In Kotlin coroutines, you often have multiple coroutines running at t...
Learn how to build preview-safe ViewModels in Jetpack Compose using Hilt.
HandlerInterceptor vs Filter in Spring Boot: A Practical Guide with JNDI Injection Prevention
Simple In-Memory Caching: A Tiny Trick with Massive Impact
If get to know something new by reading my articles, don't forget to endorse me on LinkedIn
In our Modern Application Development, we use DI (Dagger/Dagger2/ Hilt). As we follow Depdendency Injection, we love to inject (@Inject) objects as much as possible instead of creating/destroying the objects at our own.
Specially, we might need to inject multiple instances of same type objects to the dependent module.
So, How do we resolve this scenarios by following Dependency Injection?
Simple, by using Annotations.
@Named Annotation works?@Named to differentiate between different objects of the same type bound in the same scope.
@Provides
@Named("userId")
fun provideUserId(): Int = DataHolder.userId
@Provides
@Named("profileId")
fun provideProfileId(): Int = DataHolder.profileId
Without the @Named qualifier, the injector would not know which Int to bind to which variable.
If you want to create annotations that act like @Named, use the @Qualifier annotation when creating them.
If you look at @Named, it is itself annotated with @Qualifier.
object DataHolder {
@Volatile
var userId: Int = -1
@Volatile
var profileId: Int = -1
}
We are using In-Memory holder to transfer data from one module to another module. @Volatile mark the objects to be stored in the Main Memory to access the updated instances by multiple Clients or Threads.
We will inject the stored objects instances to the Dependent Modules by using DI.
@Module
@InstallIn(ViewModelComponent::class)
object ViewModelComponent {
@Provides
@Named("userId")
fun provideUserId(): Int = DataHolder.userId
@Provides
@Named("profileId")
fun provideProfileId(): Int = DataHolder.profileId
}
Create a new Object called ViewModelComponent and mark the Object as @Module (That contributes to the object graph) and @InstallIn(ViewModelComponent::class) (That declares which component(s) the annotated class should be included in when Hilt generates the components.)
Here, we are providing the multiple values of Int Object as User ID and Profile ID to the dependent module by annotating the Functions/APIs with @Provided and @Named
@HiltViewModel
class ExampleViewModel @Inject constructor(
@Named("userId") private val userId: Int,
@Named("profileId") private val profileId: Int
) :
ViewModel() {
init {
println("$userId, $profileId provided by Hilt")
}
}
Here, the client/dependent module ExampleViewModel received the multiple instances of Int Object by Injecting (@Inject) the constructor and Annotating parameters with respective unique IDs (userId, profileId).
class TestFragment : Fragment() {
companion object {
fun newInstance(userId: Int, profileId: Int): TestFragment {
/*Store the user id to the *DataHolder**/
DataHolder.userId = userId
DataHolder.profileId = profileId
return TestFragment()
}
}
}
Finally, before creating a new instance of Fragment or Activity store the values to the DataHolder to provide the new values to the dependent modules by using Hilt.
Happy Coding...