It's complicated, but it doesn't have to be: a Dagger journey

https://www.youtube.com/watch?v=9fn5s8_CYJI

Dagger is a complex tool, we can all agree on that. It's also the most performant and scalable dependency injector we have available -- no wonder it's the official recommendation from Google when it comes to dependency injection for Android apps. And yet, we keep looking for simpler alternatives (usually service locators) just so we don't have to deal with it.

Even thought Dagger is complex, it doesn't have to be complicated. It's possible to keep things simple and still take advantage of what it offers at its core. There are many ways to setup Dagger, and believe it or not, some of them are quite simple. The goal of this talk is to present a simplistic approach to Dagger, where we can take advantage of dependency injection with minimal boilerplate and optimum performance. On top of that, we'll be looking in details on best practices and how to ensure you're taking the most out of Dagger.

Join me if you've had unpleasant experiences with Dagger -- or even if you're happy with your current setup -- so we can take a fresh look on how we can work with it. And if you haven't worked with Dagger before, this is the perfect opportunity to get off on the right foot!

https://androidmakers.fr/schedule/?sessionId=YYF-6635

Transcript

1. It's complicated, but it doesn't have to be: a Dagger journey ⚔ Fred Porciúncula @tfcporciuncula
2. Why Dagger?
3. public abstract class ObjectGraph { public static ObjectGraph create(Object... modules) {} public abstract ObjectGraph plus(Object... modules); public abstract void validate(); public abstract void injectStatics(); public abstract <T> T get(Class<T> type); public abstract <T> T inject(T instance); } public @interface Module { Class<?>[] injects() default {}; Class<?>[] staticInjections() default {}; Class<?>[] includes() default {}; Class<?> addsTo() default Void.class; boolean overrides() default false; boolean complete() default true; boolean library() default true; } public @interface Provides { enum Type { UNIQUE, SET } Type type() default Type.UNIQUE; } public interface Lazy<T> { T get(); } public interface MembersInjector<T> { void injectMembers(T instance); } " From The Future of Dependency Injection with Dagger 2 by Jake Wharton
4. public @interface Component { Class<?>[] modules() default {}; Class<?>[] dependencies() default {}; } public @interface Module { Class<?>[] includes() default {}; } public @interface Provides { } public @interface MapKey { boolean unwrapValue(); } ⚔ From The Future of Dependency Injection with Dagger 2 by Jake Wharton
5. public @interface Component { Class<?>[] modules() default {}; Class<?>[] dependencies() default {}; @interface Builder {} @interface Factory {} } public @interface Subcomponent { Class<?>[] modules() default {}; @interface Builder {} @interface Factory {} } public @interface Module { Class<?>[] includes() default {}; Class<?>[] subcomponents() default {} } public @interface BindsInstance {} public @interface Binds {} public @interface BindsOptionalOf {} public @interface Reusable {} public @interface Provides {} public @interface IntoSet {} public @interface ElementsIntoSet {} public @interface IntoMap {} public @interface ClassKey { Class<?> value(); } public @interface MapKey { boolean unwrapValue(); } ⚔
6. Compile time safety Scalability Performance No boilerplate
7. Compile time safety Scalability Performance No boilerplate Compile time safety
8. Compile time safety Scalability Performance No boilerplate Scalability Compile time safety
9. Compile time safety Scalability Performance No boilerplate Scalability Performance Compile time safety
10. Compile time safety Scalability Performance No boilerplate # Scalability Performance No boilerplate Compile time safety
11. Project size/complexity DI verbosity/boilerplate
12. Project size/complexity DI verbosity/boilerplate ⚔ Illustration purpose, no real data *
13. Project size/complexity DI verbosity/boilerplate ⚔ Illustration purpose, no real data *
20. Modularization
21. Modularization Forging the Dagger for the modern Android world by Lorenzo Quiroli
22. Modularization Dependency injection in a multi module project by Ben Weiss
23. ⚔
24. class BusinessUtil { ... }
25. class BusinessUtil { ... } class BusinessRunner( private val businessUtil: BusinessUtil ) { ... }
26. class BusinessUtil @Inject constructor() { ... } class BusinessRunner @Inject constructor( private val businessUtil: BusinessUtil ) { ... }
27. Constructor injection FTW Tip #1 Go with construction injection for all classes you own
28. class BusinessRunner @Inject constructor( private val businessUtil: BusinessUtil ) { ... } class BusinessUtil @Inject constructor() { ... }
29. class BusinessRunner @Inject constructor( private val businessUtil: BusinessUtil ) { ... } class BusinessUtil @Inject constructor() { ... } @Singleton class BusinessRunner @Inject constructor( private val businessUtil: BusinessUtil ) { ... }
30. class BusinessRunner @Inject constructor( private val businessUtil: BusinessUtil ) { ... } class BusinessUtil @Inject constructor() { ... } @Reusable class BusinessUtil @Inject constructor() { ... } @Singleton class BusinessRunner @Inject constructor( private val businessUtil: BusinessUtil ) { ... }
31. @Singleton is expensive Tip #2 Avoid unnecessary scoping and favor @Reusable instances
32. @Reusable class BusinessUtil @Inject constructor() { ... } @Singleton class BusinessRunner @Inject constructor( private val businessUtil: BusinessUtil ) { ... }
33. @Component interface ApplicationComponent { }
34. @Singleton @Component interface ApplicationComponent { }
35. @Singleton @Component interface ApplicationComponent { } @Component interface ApplicationComponent { val businessRunner: BusinessRunner }
36. @Singleton @Component interface ApplicationComponent { } @Component interface ApplicationComponent { val businessRunner: BusinessRunner } DaggerApplicationComponent.create()
37. @Singleton @Component interface ApplicationComponent { } @Component interface ApplicationComponent { val businessRunner: BusinessRunner } DaggerApplicationComponent.create() DaggerApplicationComponent.create().businessRunner
38. @Singleton @Component interface ApplicationComponent { } @Component interface ApplicationComponent { val businessRunner: BusinessRunner } DaggerApplicationComponent.create() DaggerApplicationComponent.create().businessRunner DaggerApplicationComponent.create().businessRunner.doBusiness()
39. @Singleton DaggerApplicationComponent.create() DaggerApplicationComponent.create().businessRunner DaggerApplicationComponent.create().businessRunner.doBusiness() @Component @Singleton interface ApplicationComponent { val businessRunner: BusinessRunner fun inject(activity: BusinessActivity) } DaggerApplicationComponent.create().businessRunner.doBusiness()
40. @Singleton DaggerApplicationComponent.create() DaggerApplicationComponent.create().businessRunner DaggerApplicationComponent.create().businessRunner.doBusiness() @Component @Singleton interface ApplicationComponent { val businessRunner: BusinessRunner fun inject(activity: BusinessActivity) } DaggerApplicationComponent.create().businessRunner.doBusiness() class BusinessActivity : AppCompatActivity() { @Inject lateinit var businessRunner: BusinessRunner }
41. @Singleton DaggerApplicationComponent.create() DaggerApplicationComponent.create().businessRunner DaggerApplicationComponent.create().businessRunner.doBusiness() @Component @Singleton interface ApplicationComponent { val businessRunner: BusinessRunner fun inject(activity: BusinessActivity) } DaggerApplicationComponent.create().businessRunner.doBusiness() class BusinessActivity : AppCompatActivity() { @Inject lateinit var businessRunner: BusinessRunner } DaggerApplicationComponent.create().inject(this)
42. @Component @Singleton interface ApplicationComponent { fun inject(activity: BusinessActivity) } @Inject lateinit var businessRunner: BusinessRunner DaggerApplicationComponent.create().inject(this)
43. @Component @Singleton interface ApplicationComponent { fun inject(activity: BusinessActivity) } @Inject lateinit var businessRunner: BusinessRunner DaggerApplicationComponent.create().inject(this) @Component @Singleton interface ApplicationComponent { fun inject(activity: BusinessActivity) } @Inject lateinit var businessRunner: BusinessRunner DaggerApplicationComponent.create().inject(this)
44. @Component @Singleton interface ApplicationComponent { fun inject(activity: BusinessActivity) } @Inject lateinit var businessRunner: BusinessRunner DaggerApplicationComponent.create().inject(this) @Component @Singleton interface ApplicationComponent { val businessRunner: BusinessRunner } private val businessRunner = DaggerApplicationComponent.create().businessRunner @Component @Singleton interface ApplicationComponent { fun inject(activity: BusinessActivity) } @Inject lateinit var businessRunner: BusinessRunner DaggerApplicationComponent.create().inject(this) @Component @Singleton interface ApplicationComponent { fun inject(activity: BusinessActivity) } @Inject lateinit var businessRunner: BusinessRunner DaggerApplicationComponent.create().inject(this)
45. @Component interface ApplicationComponent { val businessRunner: BusinessRunner }
46. @Component interface ApplicationComponent { val businessRunner: BusinessRunner } @Component interface ApplicationComponent { fun inject(activity: MainActivity1) fun inject(activity: MainActivity2) fun inject(activity: MainActivity3) fun inject(activity: MainActivity4) fun inject(activity: MainActivity5) }
47. @Component interface ApplicationComponent { val businessRunner1: BusinessRunner1 val businessRunner2: BusinessRunner2 val businessRunner3: BusinessRunner3 val businessRunner4: BusinessRunner4 val businessRunner5: BusinessRunner5 } @Component interface ApplicationComponent { fun inject(activity: MainActivity) }
48. class MainActivity : AppCompatActivity() { @Inject lateinit var businessRunner1: BusinessRunner1 @Inject lateinit var businessRunner2: BusinessRunner2 @Inject lateinit var businessRunner3: BusinessRunner3 @Inject lateinit var businessRunner4: BusinessRunner4 @Inject lateinit var businessRunner5: BusinessRunner5 ... }
49. class MainActivity : AppCompatActivity() { @Inject lateinit var viewModel: MyViewModel ... }
50. class MainActivity : AppCompatActivity() { @Inject lateinit var viewModel: MyViewModel private val viewModel = component.myViewModel ... }
51. Avoid member injection Tip #3 Favor exposing dependencies in the components
52. @Reusable class BusinessUtil @Inject constructor() { ... } @Singleton class BusinessRunner @Inject constructor( private val businessUtil: BusinessUtil ) { ... } @Singleton @Component interface ApplicationComponent { val businessRunner: BusinessRunner } private val businessRunner = DaggerApplicationComponent.create().businessRunner
53. @Reusable class BusinessUtil @Inject constructor() { ... } @Singleton class BusinessRunner @Inject constructor( private val businessUtil: BusinessUtil ) { ... } @Singleton @Component interface ApplicationComponent { val businessRunner: BusinessRunner } private val businessRunner = DaggerApplicationComponent.create().businessRunner @Singleton @Component interface ApplicationComponent { val businessRunner: BusinessRunner } private val businessRunner = DaggerApplicationComponent.create().businessRunner
54. @Reusable class BusinessUtil @Inject constructor() { ... } @Singleton class BusinessRunner @Inject constructor( private val businessUtil: BusinessUtil ) { ... } @Singleton @Component interface ApplicationComponent { val businessRunner: BusinessRunner } private val businessRunner = DaggerApplicationComponent.create().businessRunner @Reusable class BusinessUtil @Inject constructor() { ... } @Singleton class BusinessRunner @Inject constructor( private val businessUtil: BusinessUtil ) { ... }
55. class MyApplication : Application() { }
56. class MyApplication : Application() { } companion object { lateinit var component: ApplicationComponent private set }
57. class MyApplication : Application() { } companion object { lateinit var component: ApplicationComponent private set } override fun onCreate() { super.onCreate() component = DaggerApplicationComponent.create() }
58. class MyApplication : Application() { } companion object { lateinit var component: ApplicationComponent private set } override fun onCreate() { super.onCreate() component = DaggerApplicationComponent.create() } class MyActivity : AppCompatActivity() { private val businessRunner = MyApplication.component.businessRunner } companion object { lateinit var component: ApplicationComponent private set } override fun onCreate() { super.onCreate() component = DaggerApplicationComponent.create() } class MyApplication : Application() { }
59. class MyApplication : Application() { val component by lazy { DaggerApplicationComponent.create() } }
60. interface ComponentProvider { val component: ApplicationComponent } class MyApplication : Application() { val component by lazy { DaggerApplicationComponent.create() } }
61. class MyApplication : Application(), ComponentProvider { override val component by lazy { DaggerApplicationComponent.create() } } interface ComponentProvider { val component: ApplicationComponent }
62. class MyApplication : Application(), ComponentProvider { override val component by lazy { DaggerApplicationComponent.create() } } interface ComponentProvider { val component: ApplicationComponent } val Activity.injector get() = (application as ComponentProvider).component
63. class MyApplication : Application(), ComponentProvider { override val component by lazy { DaggerApplicationComponent.create() } } interface ComponentProvider { val component: ApplicationComponent } val Activity.injector get() = (application as ComponentProvider).component class MyActivity : AppCompatActivity() { private val businessRunner by lazy { injector.businessRunner } } val Activity.injector get() = (application as ComponentProvider).component class MyApplication : Application(), ComponentProvider { override val component by lazy { DaggerApplicationComponent.create() } } interface ComponentProvider { val component: ApplicationComponent }
64. External classes
65. @Module object SharedPreferencesModule { }
66. @Module object SharedPreferencesModule { } @JvmStatic @Provides fun provideLogSharedPreferences(context: Context) = context.getSharedPreferences( context.getString(R.string.log_preferences_name), Context.MODE_PRIVATE )
67. @Module object SharedPreferencesModule { } @JvmStatic @Provides fun provideLogSharedPreferences(context: Context) = context.getSharedPreferences( context.getString(R.string.log_preferences_name), Context.MODE_PRIVATE ) @Component(modules = [SharedPreferencesModule::class]) interface ApplicationComponent { ... }
68. @Module object SharedPreferencesModule { } @JvmStatic @Provides fun provideLogSharedPreferences(context: Context) = context.getSharedPreferences( context.getString(R.string.log_preferences_name), Context.MODE_PRIVATE ) @Component(modules = [SharedPreferencesModule::class]) interface ApplicationComponent { ... } @Component(modules = [SharedPreferencesModule::class]) interface ApplicationComponent { ... }
69. Always go for static @Provide methods Tip #4 No one wants your module instance
70. @Module object SharedPreferencesModule { } @JvmStatic @Provides fun provideLogSharedPreferences(context: Context) = context.getSharedPreferences( context.getString(R.string.log_preferences_name), Context.MODE_PRIVATE )
71. @Module object SharedPreferencesModule { } @JvmStatic @Provides fun provideLogSharedPreferences(context: Context) = context.getSharedPreferences( context.getString(R.string.log_preferences_name), Context.MODE_PRIVATE ) @JvmStatic @Provides fun provideLogSharedPreferences(context: Context) = context.getSharedPreferences( context.getString(R.string.log_preferences_name), Context.MODE_PRIVATE ) @Module object SharedPreferencesModule { }
72. Context
73. @Component(modules = [ApplicationModule::class]) interface ApplicationComponent { ... }
74. @Component(modules = [ApplicationModule::class]) interface ApplicationComponent { ... } @Module class ApplicationModule(private val applicationContext: Context) { @Provides fun provideApplicationContext() = applicationContext }
75. @Component(modules = [ApplicationModule::class]) interface ApplicationComponent { ... } @Module class ApplicationModule(@get:Provides val applicationContext: Context)
76. @Component(modules = [ApplicationModule::class]) interface ApplicationComponent { ... } @Module class ApplicationModule(@get:Provides val applicationContext: Context) DaggerApplicationComponent .builder() .applicationModule(ApplicationModule(applicationContext)) .build() @Component(modules = [ApplicationModule::class]) interface ApplicationComponent { ... } @Module class ApplicationModule(@get:Provides val applicationContext: Context)
77. @Component interface ApplicationComponent { ... }
78. @Component interface ApplicationComponent { ... } @Component.Builder interface Builder { } ... }
79. @Component interface ApplicationComponent { ... } @Component.Builder interface Builder { } ... } @Component.Builder interface Builder { fun build(): ApplicationComponent } ... }
80. @Component interface ApplicationComponent { ... } @Component.Builder interface Builder { } ... } @Component.Builder interface Builder { fun build(): ApplicationComponent } ... } @Component interface ApplicationComponent { @Component.Builder interface Builder { @BindsInstance fun applicationContext(applicationContext: Context): Builder fun build(): ApplicationComponent } ... }
81. @Component.Builder interface Builder { @BindsInstance fun applicationContext(applicationContext: Context): Builder fun build(): ApplicationComponent } ... } DaggerApplicationComponent .builder() .applicationContext(applicationContext) .build()
82. @Component interface ApplicationComponent { ... }
83. @Component interface ApplicationComponent { ... } @Component interface ApplicationComponent { @Component.Factory interface Factory { }
84. @Component interface ApplicationComponent { ... } @Component interface ApplicationComponent { @Component.Factory interface Factory { } @Component interface ApplicationComponent { @Component.Factory interface Factory { fun create( @BindsInstance applicationContext: Context ): ApplicationComponent }
85. interface Factory { fun create( @BindsInstance applicationContext: Context ): ApplicationComponent } ... } DaggerApplicationComponent .factory() .create(applicationContext)
86. Use the new @Component.Factory Tip #5 And avoid the lame module with constructor arguments or the old @Component.Builder
87. @Inject @Singleton @Reusable @Component @Module @BindsInstance
88. @Inject @Singleton @Reusable @Component @Module @BindsInstance @Subcomponent
89. @Subcomponent
90. @Subcomponent Encapsulation
91. @Subcomponent Scoping Encapsulation
92. @Subcomponent Scoping
93. Application Component
94. Application Component Subcomponent1 Activity1 Subcomponent2 Activity2 Subcomponent3 Activity3 ...
95. dagger-android
96. dagger-android • Great for that setup
97. dagger-android • Great for that setup • Still verbose
98. dagger-android • Great for that setup • Still verbose • Real DI
99. dagger-android • Great for that setup • Still verbose • Real DI • Member injection
100. dagger-android • Great for that setup • Still verbose • Real DI • Member injection • Decouples injection sites from injector
101. dagger-android • Great for that setup • Still verbose • Real DI • Member injection • Decouples injection sites from injector Doesn’t work with dynamic features
102. dagger-android
103. ViewModel
104. @Subcomponent $
105. class MyViewModel( private val businessRunner: BusinessRunner ) : ViewModel() { ... }
106. class MyViewModel( private val businessRunner: BusinessRunner ) : ViewModel() { ... } class MyViewModelFactory( private val businessRunner: BusinessRunner ) : ViewModelProvider.Factory { }
107. class MyViewModel( private val businessRunner: BusinessRunner ) : ViewModel() { ... } class MyViewModelFactory( private val businessRunner: BusinessRunner ) : ViewModelProvider.Factory { } class MyViewModelFactory( private val businessRunner: BusinessRunner ) : ViewModelProvider.Factory { @Suppress("UNCHECKED_CAST") override fun <T : ViewModel> create(modelClass: Class<T>) = MyViewModel(businessRunner) as T }
108. class MyViewModel( private val businessRunner: BusinessRunner ) : ViewModel() { ... } class MyViewModelFactory @Inject constructor( private val businessRunner: BusinessRunner ) : ViewModelProvider.Factory { @Suppress("UNCHECKED_CAST") override fun <T : ViewModel> create(modelClass: Class<T>) = MyViewModel(businessRunner) as T }
109. @Component interface ApplicationComponent { ... val myViewModelFactory: MyViewModelFactory }
110. @Component interface ApplicationComponent { ... val myViewModelFactory: MyViewModelFactory } private val myViewModel by lazy { ViewModelProviders .of(this, injector.myViewModelFactory) .get(MyViewModel::class.java) }
111. @Component interface ApplicationComponent { ... val myViewModelFactory: MyViewModelFactory } private val myViewModel by lazy { ViewModelProviders .of(this, injector.myViewModelFactory) .get(MyViewModel::class.java) } private val myViewModel by lazy { ViewModelProviders .of(this, injector.myViewModelFactory) .get(MyViewModel::class.java) }
112. class MyViewModel( private val businessRunner: BusinessRunner ) : ViewModel() { ... }
113. class MyViewModel @Inject constructor( private val businessRunner: BusinessRunner ) : ViewModel() { ... }
114. class MyViewModel @Inject constructor( private val businessRunner: BusinessRunner ) : ViewModel() { ... } class MyViewModelFactory @Inject constructor( private val businessRunner: BusinessRunner ) : ViewModelProvider.Factory { @Suppress("UNCHECKED_CAST") override fun <T : ViewModel> create(modelClass: Class<T>) = MyViewModel(businessRunner) as T }
115. class MyViewModel @Inject constructor( private val businessRunner: BusinessRunner ) : ViewModel() { ... } class MyViewModelFactory<T : ViewModel> @Inject constructor( private val viewModel: Provider<T> ) : ViewModelProvider.Factory { @Suppress("UNCHECKED_CAST") override fun <T : ViewModel> create(modelClass: Class<T>) = MyViewModel(businessRunner) as T } class MyViewModelFactory<T : ViewModel> @Inject constructor( private val viewModel: Provider<T> ) : ViewModelProvider.Factory { @Suppress("UNCHECKED_CAST") override fun <T : ViewModel> create(modelClass: Class<T>) = MyViewModel(businessRunner) as T }
116. class MyViewModel @Inject constructor( private val businessRunner: BusinessRunner ) : ViewModel() { ... } class MyViewModelFactory<T : ViewModel> @Inject constructor( private val viewModel: Provider<T> ) : ViewModelProvider.Factory { @Suppress("UNCHECKED_CAST") override fun <T : ViewModel> create(modelClass: Class<T>) = viewModel.get() as T } class MyViewModelFactory<T : ViewModel> @Inject constructor( private val viewModel: Provider<T> ) : ViewModelProvider.Factory { @Suppress("UNCHECKED_CAST") override fun <T : ViewModel> create(modelClass: Class<T>) = viewModel.get() as T }
117. class MyViewModel @Inject constructor( private val businessRunner: BusinessRunner ) : ViewModel() { ... } class MyViewModelFactory<T : ViewModel> @Inject constructor( private val viewModel: Provider<T> ) : ViewModelProvider.Factory { @Suppress("UNCHECKED_CAST") override fun <T : ViewModel> create(modelClass: Class<T>) = viewModel.get() as T }
118. @Component interface ApplicationComponent { ... val myViewModelFactory: MyViewModelFactory }
119. @Component interface ApplicationComponent { ... val myViewModelFactory: MyViewModelFactory } @Component interface ApplicationComponent { ... val myViewModelFactory: MyViewModelFactory<MyViewModel> }
120. @Component interface ApplicationComponent { ... val myViewModelFactory: MyViewModelFactory } @Component interface ApplicationComponent { ... val myViewModelFactory: MyViewModelFactory<MyViewModel> } private val myViewModel by lazy { ViewModelProviders .of(this, injector.myViewModelFactory) .get(MyViewModel::class.java) }
121. class MyViewModel @Inject constructor( private val businessRunner: BusinessRunner ) : ViewModel() { ... }
122. class MyViewModel @Inject constructor( private val businessRunner: BusinessRunner ) : ViewModel() { ... } @Component interface ApplicationComponent { ... val myViewModelFactory: MyViewModelFactory<MyViewModel> } class MyViewModel @Inject constructor( private val businessRunner: BusinessRunner ) : ViewModel() { ... }
123. class MyViewModel @Inject constructor( private val businessRunner: BusinessRunner ) : ViewModel() { ... } @Component interface ApplicationComponent { ... val myViewModel: MyViewModel } class MyViewModel @Inject constructor( private val businessRunner: BusinessRunner ) : ViewModel() { ... }
124. inline fun <reified T : ViewModel> FragmentActivity.getViewModel( crossinline provider: () -> T ) = ViewModelProviders.of(this, object : ViewModelProvider.Factory { override fun <T : ViewModel> create(modelClass: Class<T>) = provider() as T }).get(T::class.java)
125. inline fun <reified T : ViewModel> FragmentActivity.getViewModel( crossinline provider: () -> T ) = ViewModelProviders.of(this, object : ViewModelProvider.Factory { override fun <T : ViewModel> create(modelClass: Class<T>) = provider() as T }).get(T::class.java)
126. inline fun <reified T : ViewModel> FragmentActivity.getViewModel( crossinline provider: () -> T ) = ViewModelProviders.of(this, object : ViewModelProvider.Factory { override fun <T : ViewModel> create(modelClass: Class<T>) = provider() as T }).get(T::class.java)
127. inline fun <reified T : ViewModel> FragmentActivity.getViewModel( crossinline provider: () -> T ) = ViewModelProviders.of(this, object : ViewModelProvider.Factory { override fun <T : ViewModel> create(modelClass: Class<T>) = provider() as T }).get(T::class.java)
128. inline fun <reified T : ViewModel> FragmentActivity.getViewModel( crossinline provider: () -> T ) = ViewModelProviders.of(this, object : ViewModelProvider.Factory { override fun <T : ViewModel> create(modelClass: Class<T>) = provider() as T }).get(T::class.java)
129. inline fun <reified T : ViewModel> FragmentActivity.getViewModel( crossinline provider: () -> T ) = ViewModelProviders.of(this, object : ViewModelProvider.Factory { override fun <T : ViewModel> create(modelClass: Class<T>) = provider() as T }).get(T::class.java)
130. inline fun <reified T : ViewModel> FragmentActivity.getViewModel( crossinline provider: () -> T ) = ViewModelProviders.of(this, object : ViewModelProvider.Factory { override fun <T : ViewModel> create(modelClass: Class<T>) = provider() as T }).get(T::class.java)
131. inline fun <reified T : ViewModel> FragmentActivity.getViewModel( crossinline provider: () -> T ) = ViewModelProviders.of(this, object : ViewModelProvider.Factory { override fun <T : ViewModel> create(modelClass: Class<T>) = provider() as T }).get(T::class.java)
132. inline fun <reified T : ViewModel> FragmentActivity.getViewModel( crossinline provider: () -> T ) = ViewModelProviders.of(this, object : ViewModelProvider.Factory { override fun <T : ViewModel> create(modelClass: Class<T>) = provider() as T }).get(T::class.java) inline fun <reified T : ViewModel> FragmentActivity.getViewModel( crossinline provider: () -> T ) = ViewModelProviders.of(this, object : ViewModelProvider.Factory { override fun <T : ViewModel> create(modelClass: Class<T>) = provider() as T }).get(T::class.java) private val myViewModel by lazy { getViewModel { injector.myViewModel } }
133. inline fun <reified T : ViewModel> FragmentActivity.getViewModel( crossinline provider: () -> T ) = ViewModelProviders.of(this, object : ViewModelProvider.Factory { override fun <T : ViewModel> create(modelClass: Class<T>) = provider() as T }).get(T::class.java) inline fun <reified T : ViewModel> FragmentActivity.getViewModel( crossinline provider: () -> T ) = ViewModelProviders.of(this, object : ViewModelProvider.Factory { override fun <T : ViewModel> create(modelClass: Class<T>) = provider() as T }).get(T::class.java) private val myViewModel by lazy { getViewModel { injector.myViewModel } } private val myViewModel by lazy { getViewModel { injector.myViewModel } }
134. implementation 'androidx.activity:activity-ktx:1.0.0-alpha06' implementation 'androidx.fragment:fragment-ktx:1.1.0-alpha06'
135. inline fun <reified T : ViewModel> FragmentActivity.viewModel( crossinline provider: () -> T ) = viewModels<T> { object : ViewModelProvider.Factory { override fun <T : ViewModel> create(modelClass: Class<T>) = factory() as T } } implementation 'androidx.activity:activity-ktx:1.0.0-alpha06' implementation 'androidx.fragment:fragment-ktx:1.1.0-alpha06'
136. inline fun <reified T : ViewModel> FragmentActivity.viewModel( crossinline provider: () -> T ) = viewModels<T> { object : ViewModelProvider.Factory { override fun <T : ViewModel> create(modelClass: Class<T>) = factory() as T } } implementation 'androidx.activity:activity-ktx:1.0.0-alpha06' implementation 'androidx.fragment:fragment-ktx:1.1.0-alpha06' inline fun <reified T : ViewModel> FragmentActivity.viewModel( crossinline provider: () -> T ) = viewModels<T> { object : ViewModelProvider.Factory { override fun <T : ViewModel> create(modelClass: Class<T>) = factory() as T } }
137. private val myViewModel by viewModel { injector.myViewModel } inline fun <reified T : ViewModel> FragmentActivity.viewModel( crossinline provider: () -> T ) = viewModels<T> { object : ViewModelProvider.Factory { override fun <T : ViewModel> create(modelClass: Class<T>) = factory() as T } } implementation 'androidx.activity:activity-ktx:1.0.0-alpha06' implementation 'androidx.fragment:fragment-ktx:1.1.0-alpha06' inline fun <reified T : ViewModel> FragmentActivity.viewModel( crossinline provider: () -> T ) = viewModels<T> { object : ViewModelProvider.Factory { override fun <T : ViewModel> create(modelClass: Class<T>) = factory() as T } }
138. class MyOtherViewModel @Inject constructor( ... ) : ViewModel() { ... }
139. class MyOtherViewModel @Inject constructor( ... ) : ViewModel() { ... } @Component interface ApplicationComponent { ... val myOtherViewModel: MyOtherViewModel }
140. private val myOtherViewModel by viewModel { injector.myOtherViewModel } class MyOtherViewModel @Inject constructor( ... ) : ViewModel() { ... } @Component interface ApplicationComponent { ... val myOtherViewModel: MyOtherViewModel }
141. inline fun <reified T : ViewModel> Fragment.viewModel( crossinline provider: () -> T ) = viewModels<T> { object : ViewModelProvider.Factory { override fun <T : ViewModel> create(modelClass: Class<T>) = factory() as T } } inline fun <reified T : ViewModel> Fragment.activityViewModel( crossinline provider: () -> T ) = activityViewModels<T> { object : ViewModelProvider.Factory { override fun <T : ViewModel> create(modelClass: Class<T>) = factory() as T } }
142. inline fun <reified T : ViewModel> Fragment.viewModel( crossinline provider: () -> T ) = viewModels<T> { object : ViewModelProvider.Factory { override fun <T : ViewModel> create(modelClass: Class<T>) = factory() as T } } inline fun <reified T : ViewModel> Fragment.activityViewModel( crossinline provider: () -> T ) = activityViewModels<T> { object : ViewModelProvider.Factory { override fun <T : ViewModel> create(modelClass: Class<T>) = factory() as T } } inline fun <reified T : ViewModel> Fragment.viewModel( crossinline provider: () -> T ) = viewModels<T> { object : ViewModelProvider.Factory { override fun <T : ViewModel> create(modelClass: Class<T>) = factory() as T } } inline fun <reified T : ViewModel> Fragment.activityViewModel( crossinline provider: () -> T ) = activityViewModels<T> { object : ViewModelProvider.Factory { override fun <T : ViewModel> create(modelClass: Class<T>) = factory() as T } }
143. private val myViewModel by viewModel { injector.myViewModel } private val mySharedViewModel by activityViewModel { injector.myViewModel }
144. Control scope with ViewModels Tip #6 Take advantage of what Android gives you for free
145. class MyViewModel @Inject constructor( private val businessRunner: BusinessRunner, private val message: String ) : ViewModel() { ... }
146. component .mySubcomponentFactory() .create(intent.getStringExtra(EXTRA_MESSAGE)) .inject(this) class MyViewModel @Inject constructor( private val businessRunner: BusinessRunner, private val message: String ) : ViewModel() { ... }
147. class MyViewModel @Inject constructor( private val businessRunner: BusinessRunner ) : ViewModel() { lateinit var message: String ... }
148. class MyViewModel @Inject constructor( private val businessRunner: BusinessRunner ) : ViewModel() { lateinit var message: String ... } viewModel.message = intent.getStringExtra(EXTRA_MESSAGE)
149. class MyViewModel @Inject constructor( private val businessRunner: BusinessRunner ) : ViewModel() { lateinit var message: String ... } viewModel.message = intent.getStringExtra(EXTRA_MESSAGE) ❌
150. class MyViewModel @Inject constructor( private val businessRunner: BusinessRunner ) : ViewModel() { lateinit var message: String ... }
151. class MyViewModel @Inject constructor( private val businessRunner: BusinessRunner, private val message: String ) : ViewModel() { ... }
152. class MyViewModel @Inject constructor( private val businessRunner: BusinessRunner, private val message: String ) : ViewModel() { ... } AssistedInject class MyViewModel @Inject constructor( private val businessRunner: BusinessRunner, private val message: String ) : ViewModel() { ... }
153. class MyViewModel @Inject constructor( private val businessRunner: BusinessRunner, private val message: String ) : ViewModel() { ... }
154. class MyViewModel @AssistedInject constructor( private val businessRunner: BusinessRunner, private val message: String ) : ViewModel() { ... }
155. class MyViewModel @AssistedInject constructor( private val businessRunner: BusinessRunner, @Assisted private val message: String ) : ViewModel() { ... }
156. class MyViewModel @AssistedInject constructor( private val businessRunner: BusinessRunner, @Assisted private val message: String ) : ViewModel() { @AssistedInject.Factory interface Factory { fun create(message: String): MyViewModel } ... }
157. @Component interface ApplicationComponent { ... val myViewModelFactory: MyViewModel.Factory }
158. @Component interface ApplicationComponent { ... val myViewModelFactory: MyViewModel.Factory } private val myViewModel by viewModel { injector.myViewModel }
159. @Component interface ApplicationComponent { ... val myViewModelFactory: MyViewModel.Factory } private val myViewModel by viewModel { injector.myViewModel } private val viewModel by viewModel { injector.myViewModelFactory.create( message = intent.getStringExtra(EXTRA_MESSAGE) ) } private val myViewModel by viewModel { injector.myViewModel }
161. compileOnly 'com.squareup.inject:assisted-inject-annotations-dagger2:0.4.0' kapt 'com.squareup.inject:assisted-inject-processor-dagger2:0.4.0'
162. @AssistedModule @Module(includes = [AssistedInject_AssistedInjectModule::class]) interface AssistedInjectModule
163. @AssistedModule @Module(includes = [AssistedInject_AssistedInjectModule::class]) interface AssistedInjectModule @AssistedModule @Module(includes = [AssistedInject_ApplicationModule::class]) object ApplicationModule { ... } @AssistedModule @Module(includes = [AssistedInject_AssistedInjectModule::class]) interface AssistedInjectModule
164. Take advantage of AssistedInject Tip #7 Assisted injection is a thing in Dagger
165. Tips
166. #1 Constructor injection FTW Tips
167. #1 Constructor injection FTW #2 @Singleton is expensive Tips
168. #1 Constructor injection FTW #2 @Singleton is expensive #3 Avoid member injection Tips
169. #1 Constructor injection FTW #2 @Singleton is expensive #3 Avoid member injection #4 Always go for static @Provide methods Tips
170. #1 Constructor injection FTW #2 @Singleton is expensive #3 Avoid member injection #4 Always go for static @Provide methods #5 Use the new @Component.Factory Tips
171. #1 Constructor injection FTW #2 @Singleton is expensive #3 Avoid member injection #4 Always go for static @Provide methods #5 Use the new @Component.Factory #6 Control scope with ViewModels Tips
172. #1 Constructor injection FTW #2 @Singleton is expensive #3 Avoid member injection #4 Always go for static @Provide methods #5 Use the new @Component.Factory #6 Control scope with ViewModels #7 Take advantage of AssistedInject Tips
173. #1 Constructor injection FTW #2 @Singleton is expensive #3 Avoid member injection #4 Always go for static @Provide methods #5 Use the new @Component.Factory #6 Control scope with ViewModels #7 Take advantage of AssistedInject Tips #1 Constructor injection FTW #2 @Singleton is expensive #3 Avoid member injection #4 Always go for static @Provide methods #5 Use the new @Component.Factory #6 Control scope with ViewModels #7 Take advantage of AssistedInject
174. References That Missing Guide: How to use Dagger2 By Gabor Varadi Keeping the Daggers Sharp ⚔ by Py
175. References Dagger user's guide & semantics The Future of Dependency Injection with Dagger 2 by Jake Wharton Helping Dagger Help You by Jake Wharton Optimizing Dagger on Android by Ron Shapiro Dagger 2 by Gregory Kick Understanding Dagger 2's Generated Code by Ron Shapiro & David P. Baker Understanding Dagger 2's Codegen implementation by Gregory Kick The only Android ViewModel Factory you'll need with Dagger (by Elforama) ViewModelProviders with Dagger 2 (answer by Gabor Varadi)
176. References Dagger user's guide & semantics The Future of Dependency Injection with Dagger 2 by Jake Wharton Helping Dagger Help You by Jake Wharton Optimizing Dagger on Android by Ron Shapiro Dagger 2 by Gregory Kick Understanding Dagger 2's Generated Code by Ron Shapiro & David P. Baker Understanding Dagger 2's Codegen implementation by Gregory Kick The only Android ViewModel Factory you'll need with Dagger (by Elforama) ViewModelProviders with Dagger 2 (answer by Gabor Varadi)
177. References Dagger and the shiny new @Component.Factory Yet another way to bind instances Dagger Assisted Injection The missing piece in your Dagger setup Dagger 2 on Android: The Official Guidelines You Should Be Following Learn how to make Dagger's life easier Dagger 2 on Android: The Simple Way It’s complicated, but only if you really want to
178. bit.ly/dagger-journey
179. Thanks. bit.ly/dagger-journey @tfcporciuncula