Modularizing a project is never easy, a lot of files to move and the dependencies between them is not always what we expect. Then the Dagger configuration used in a single module project often doesn't scale well to a multi module project. Hilt is opinionated about the configuration to use (we don't need to argue anymore about using component dependencies or subcomponents!) and this configuration works perfectly even in a multi module project. In this talk we'll see first an introduction to Hilt and a comparison with Dagger to understand why it's easier to configure. Then we'll see how to leverage it in a multi module project (both in a standard layered architecture and in a Clean Architecture that uses the Dependency Inversion) to improve build speed and code testability. Spoiler alert: using sample apps that include a single feature in the app helps a lot!

1. Using Hilt in a
modularized project
Fabio Collini
@fabioCollini

7. Dependency Injection
Vs
Service Locator

8. class MyClass {
private val collaborator2 = Collaborator2()
fun execute() {
val value = Collaborator1.loadSomething()
collaborator2.doSomethingElse(value)
}
}
Plaincode

9. class MyClass(serviceLocator: ServiceLocator) {
private val collaborator1 = serviceLocator.collaborator1
private val collaborator2 = serviceLocator.collaborator2
fun execute() {
val value = collaborator1.loadSomething()
collaborator2.doSomethingElse(value)
}
}
ServiceLocator

10. class MyClass(
private val collaborator1: Collaborator1,
private val collaborator2: Collaborator2
) {
fun execute() {
val value = collaborator1.loadSomething()
collaborator2.doSomethingElse(value)
}
}
DependencyInjection

11. class MyClass(
private val collaborator1: Collaborator1,
private val collaborator2: Collaborator2
) {
fun execute() {
val value = collaborator1.loadSomething()
collaborator2.doSomethingElse(value)
}
}
class MyClass(serviceLocator: ServiceLocator) {
private val collaborator1 = serviceLocator.collaborator1
private val collaborator2 = serviceLocator.collaborator2
fun execute() {
val value = collaborator1.loadSomething()
collaborator2.doSomethingElse(value)
}
}
ServiceLocatorDependencyInjection
Dependencies are
retrieved using the
Service Locator
Dependencies are
injected by the
container

12. Dagger is a Dependency Injection framework
But a Dagger component can be used as a Service Locator

13. Is Dagger a Dependency Injection framework?
What about Hilt?

14. WhatIcareabout
Dependency Injection on classes we can instantiate
Easy setup on classes instantiated by the framework
Testability

15. Objects
definition

16. Dagger&Hilt
The same syntax can be
used to define objects using
both Dagger and Hilt

17. class MyRepository(
private val api: Api
) {
fun loadData() = api.load()
}

18. class MyRepository @Inject constructor(
private val api: Api
) {
fun loadData() = api.load()
}

19. @Singleton
class MyRepository @Inject constructor(
private val api: Api
) {
fun loadData() = api.load()
}

20. Retrofit.Builder()
.baseUrl("""...")
!//!!...
.build()
.create(Api"::class.java)

21. @Provides
@Singleton
fun provideApi(): Api {
return Retrofit.Builder()
.baseUrl("""...")
!//!!...
.build()
.create(Api"::class.java)
}

22. @Module
object MyModule {
@Provides
@Singleton
fun provideApi(): Api {
return Retrofit.Builder()
.baseUrl("""...")
!//!!...
.build()
.create(Api"::class.java)
}
}
Using an object
instead of a class
Dagger generates
less code

23. @Singleton
class MyRepository @Inject constructor(
private val api: Api
) {
fun loadData() = api.load()
}

24. @Singleton
class MyRepository @Inject constructor(
private val cache: Cache,
private val api: Api
) {
fun loadData() = cache.load() "?: api.load()
}

25. interface MyRepository {
fun loadData(): Any
}
@Singleton
class MyRepositoryImpl @Inject constructor(
private val cache: Cache,
private val api: Api
) : MyRepository {
override fun loadData() = cache.load() "?: api.load()
}1

26. interface MyRepository {
fun loadData(): Any
}
@Singleton
class MyRepositoryImpl @Inject constructor(
private val cache: Cache,
private val api: Api
) : MyRepository {
override fun loadData() = cache.load() "?: api.load()
}1
@Module
interface AnotherModule {
@Binds
fun MyRepositoryImpl.bindsRepository(): MyRepository
}

29. Hilt

30. @InstallIn
@AndroidEntryPoint
@ViewModelInject
@HiltAndroidApp
@EntryPoint
Newannotations

31. @Module
object MyModule {
!//!!...
}

32. @Module
@InstallIn(SingletonComponent"::class)
object MyModule {
!//!!...
}

34. @Module
@InstallIn(SingletonComponent"::class)
object OkHttpConfigModule {
@Provides
@ElementsIntoSet
fun provideDefaultInterceptors(): Set<Interceptor> = emptySet()
@Singleton
@Provides
fun providesOkHttpClient(
interceptors: @JvmSuppressWildcards Set<Interceptor>
): OkHttpClient {
val httpClient = OkHttpClient.Builder()
interceptors.forEach {
httpClient.addInterceptor(it)
}
return httpClient.build()
}1
}2
src/main

35. @Module
@InstallIn(SingletonComponent"::class)
object OkHttpConfigModule {
@Provides
@ElementsIntoSet
fun provideDefaultInterceptors(): Set<Interceptor> = emptySet()
@Singleton
@Provides
fun providesOkHttpClient(
interceptors: @JvmSuppressWildcards Set<Interceptor>
): OkHttpClient {
val httpClient = OkHttpClient.Builder()
interceptors.forEach {
httpClient.addInterceptor(it)
}
return httpClient.build()
}1
}2
@Module
@InstallIn(SingletonComponent"::class)
object DebugOkHttpConfigModule {
@Provides
@IntoSet
fun provideDebugInterceptor(): Interceptor = HttpLoggingInterceptor()
}
src/mainsrc/debug

36. class MainActivity : AppCompatActivity() {
@Inject
lateinit var permissionManager: PermissionManager
@Inject
lateinit var mainNavigator: MainNavigator
!//!!...
}

37. @AndroidEntryPoint
class MainActivity : AppCompatActivity() {
@Inject
lateinit var permissionManager: PermissionManager
@Inject
lateinit var mainNavigator: MainNavigator
!//!!...
}

39. @AndroidEntryPoint
class MainActivity : AppCompatActivity() {
@Inject
lateinit var permissionManager: PermissionManager
@Inject
lateinit var mainNavigator: MainNavigator
!//!!...
}

40. @AndroidEntryPoint
class MainActivity : AppCompatActivity() {
private val viewModel: MyViewModel by viewModels()
@Inject
lateinit var permissionManager: PermissionManager
@Inject
lateinit var mainNavigator: MainNavigator
!//!!...
}

41. class MyViewModel @ViewModelInject constructor(
private val useCase: MyUseCase
) : ViewModel() {
!//!!...
}

42. class MyViewModel @ViewModelInject constructor(
private val useCase: MyUseCase,
@Assisted private val handle: SavedStateHandle
) : ViewModel() {
!//!!...
}

43. class MyViewModel @ViewModelInject constructor(
private val useCase: MyUseCase,
@Assisted private val handle: SavedStateHandle
) : ViewModel() {
init {
load(handle.get<String>("Id"))
}
!//!!...
}

44. class MyApp : Application() {
@Inject
lateinit var dependency: Dependency
!//!!...
}

45. @HiltAndroidApp
class MyApp : Application() {
@Inject
lateinit var dependency: Dependency
!//!!...
}

46. No more components!
(sort of…)

47. @Component(
modules = {
"//""...
}
)
@Singleton
public abstract static class SingletonC implements SingletonComponent,
"//…
{
}
@Subcomponent(
modules = {
"//""...
}
)
@ActivityScoped
public abstract static class ActivityC implements ActivityComponent,
"//""...
{
@Subcomponent.Builder
abstract interface Builder extends ActivityComponentBuilder {
}
}

48. !!/**
* A generated base class to be extended by the @dagger.hilt.android.AndroidEntryPoint annotated class.
* If using the Gradle plugin, this is swapped as the base class via bytecode transformation.
!*/
public abstract class Hilt_MainActivity extends AppCompatActivity
implements GeneratedComponentManagerHolder {
"//""...
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
((MainActivity_GeneratedInjector) this.generatedComponent())
.injectMainActivity(UnsafeCasts.<MainActivity>unsafeCast(this));
super.onCreate(savedInstanceState);
}
"//""...
}

49. !!/**
* A generated base class to be extended by the @dagger.hilt.android.AndroidEntryPoint annotated class.
* If using the Gradle plugin, this is swapped as the base class via bytecode transformation.
!*/
public abstract class Hilt_MainActivity extends AppCompatActivity
implements GeneratedComponentManagerHolder {
"//""...
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
((MainActivity_GeneratedInjector) this.generatedComponent())
.injectMainActivity(UnsafeCasts.<MainActivity>unsafeCast(this));
super.onCreate(savedInstanceState);
}
"//""...
}

50. !!/**
* A generated base class to be extended by the @dagger.hilt.android.AndroidEntryPoint annotated class.
* If using the Gradle plugin, this is swapped as the base class via bytecode transformation.
!*/
public abstract class Hilt_MainActivity extends AppCompatActivity
implements GeneratedComponentManagerHolder {
"//""...
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
((MainActivity_GeneratedInjector) this.generatedComponent())
.injectMainActivity(UnsafeCasts.<MainActivity>unsafeCast(this));
super.onCreate(savedInstanceState);
}
"//""...
}

53. MonolithicComponent
Simple
sometimes you need an extra Qualifier annotation
Less generated code
Everything can be injected everywhere
internal can be useful to limit the scope

54. @EntryPoint
@InstallIn(SingletonComponent"::class)
interface MyEntryPoint {
val myUseCase: MyUseCase
fun inject(something: Something)
}

55. @EntryPoint
@InstallIn(SingletonComponent"::class)
interface MyEntryPoint {
val myUseCase: MyUseCase
fun inject(something: Something)
}
val entryPoint = EntryPointAccessors.fromApplication(
app, MyEntryPoint"::class.java)
val useCase = entryPoint.myUseCase

56. Testing

57. class MyClass @Inject constructor(
private val collaborator1: Collaborator1,
private val collaborator2: Collaborator2
) {
fun execute() {
val value = collaborator1.loadSomething()
collaborator2.doSomethingElse(value)
}
}

58. class MyClassTest {
private val collaborator1 = mock<Collaborator1>()
private val collaborator2 = mock<Collaborator2>()
private val myObject = MyClass(collaborator1, collaborator2)
@Test
fun testSomething() {
whenever(collaborator1.loadSomething()) doReturn "something"
myObject.execute()
verify(collaborator2).doSomethingElse("something")
}
}

60. @Singleton
open class MyAnalytics @Inject constructor()
interface MyUseCase
@Singleton
class MyUseCaseImpl @Inject constructor() : MyUseCase
@Module
@InstallIn(SingletonComponent"::class)
interface MyModule {
@Binds
fun MyUseCaseImpl.bindsUseCase(): MyUseCase
}
@AndroidEntryPoint
class MyActivity : AppCompatActivity() {
@Inject
lateinit var analytics: MyAnalytics
@Inject
lateinit var useCase: MyUseCase
!//!!...
}

61. @HiltAndroidTest
class MyActivityTest {
@get:Rule1
val hiltRule = HiltAndroidRule(this)
@get:Rule
val rule = ActivityTestRule(MyActivity"::class.java, false, false)
}

62. @HiltAndroidTest
class MyActivityTest {
@get:Rule1
val hiltRule = HiltAndroidRule(this)
@get:Rule
val rule = ActivityTestRule(MyActivity"::class.java, false, false)
@Inject
lateinit var analytics: MyAnalytics
@Inject
lateinit var useCase: MyUseCase
@Test
fun startActivity() {
rule.launchActivity(null)
hiltRule.inject()
!//now the properties contain the production objects
}
}

63. @HiltAndroidTest
class MyActivityTest {
@get:Rule1
val hiltRule = HiltAndroidRule(this)
@get:Rule
val rule = ActivityTestRule(MyActivity"::class.java, false, false)
@Test
fun startActivity() {
rule.launchActivity(null)
!//!!...
}
}

64. @Module
@InstallIn(SingletonComponent"::class)
object FakeAnalyticsModule {
@Provides
fun provideAnalytics(): MyAnalytics = mock()
}
@HiltAndroidTest
class MyActivityTest {
@get:Rule1
val hiltRule = HiltAndroidRule(this)
@get:Rule
val rule = ActivityTestRule(MyActivity"::class.java, false, false)
@Test
fun startActivity() {
rule.launchActivity(null)
!//!!...
}
}

65. @HiltAndroidTest
class MyActivityTest {
@get:Rule1
val hiltRule = HiltAndroidRule(this)
@get:Rule
val rule = ActivityTestRule(MyActivity"::class.java, false, false)
@Module
@InstallIn(SingletonComponent"::class)
object FakeAnalyticsModule {
@Provides
fun provideAnalytics(): MyAnalytics = mock()
}
@Test
fun startActivity() {
rule.launchActivity(null)
!//!!...
}
}

66. @HiltAndroidTest
class MyActivityTest {
@get:Rule
val hiltRule = HiltAndroidRule(this)
@get:Rule
val rule = ActivityTestRule(MyActivity"::class.java, false, false)
@BindValue
@JvmField
val analytics: MyAnalytics = mock()
@Test
fun startActivity() {
rule.launchActivity(null)
!//!!...
}
}

67. @HiltAndroidTest
class MyActivityTest {
@get:Rule
val hiltRule = HiltAndroidRule(this)
@get:Rule
val rule = ActivityTestRule(MyActivity"::class.java, false, false)
@BindValue
@JvmField
val useCase: MyUseCase = mock()
@Test
fun startActivity() {
rule.launchActivity(null)
!//!!...
}
}
error: [Dagger/DuplicateBindings] MyUseCase is bound multiple times

68. @HiltAndroidTest
@UninstallModules(MyModule"::class)
class MyActivityTest {
@get:Rule
val hiltRule = HiltAndroidRule(this)
@get:Rule
val rule = ActivityTestRule(MyActivity"::class.java, false, false)
@BindValue
@JvmField
val useCase: MyUseCase = mock()
@Test
fun startActivity() {
rule.launchActivity(null)
!//!!...
}
}

69. Multi-module
architecture

70. It works!

73. feature3feature1 feature2
App

74. feature3feature1 feature2
AppFeature1App

75. feature1 feature2
Feature1App
feature3
App

76. Activity
Repository
Api
UseCase
ViewModel

77. entitiesentitiesentitiesentities
domain
repository
UI
data source
presenter
Activity
Repository
Api
UseCase
ViewModel

78. entitiesentitiesentitiesentities
domain
repository
UI
data source
presenter
Activity
Repository
Api
UseCase
ViewModel

79. RepositoryImplRepositoryUseCase

80. domain data
UseCase
RepositoryImpl
Repository

81. domain data
Repository RepositoryImpl
UseCase

82. Inversion
Of Control
The “I” in S.O.L.I.D.

83. https://www.youtube.com/watch?v=GlDsfq3xHvo&t=

84. domain repository
Repository RepositoryImpl
UseCase
@Inject
@Inject
Module
@Binds
Incomplete Hilt config

85. dynamic
feature3
App
feature1 feature2
@EntryPoint
@Component

86. Wrappingup
Dependency Injection on classes we can instantiate
@Inject, @Provides and @Binds
Easy setup on classes instantiated by the framework
@AndroidEntryPoint and @HiltAndroidApp
Testability
@HiltAndroidTest and HiltAndroidRule

87. Hilt is definitely a
Dependency Injection framework

88. Hilt is definitely a
Dependency Injection framework
(even if you can use an EntryPoint as a Service Locator)

89. Links&contacts
Hilt documentation
dagger.dev/hilt/
Android Developers - Dependency injection with Hilt
developer.android.com/training/dependency-injection/hilt-android
Android Developers - Hilt testing guide
developer.android.com/training/dependency-injection/hilt-testing
Manuel Vivo - Dagger and Hilt navigation support in Android Studio
medium.com/androiddevelopers/dagger-navigation-support-in-android-studio-49aa5d149ec9
Fabio Collini - Dagger dependencies beyond the basics
proandroiddev.com/dagger-dependencies-beyond-the-basics-53474e48f932
@fabioCollini
linkedin.com/in/fabiocollini
github.com/fabioCollini
medium.com/@fabioCollini

90. THANKS
FOR YOUR
ATTENTION

91. QUESTIONS?
@fabioCollini