How to use Dagger 2 in Android

Dagger is a complex and powerful library. Because of its flexibility Dagger can be integrated in many different ways in an Android application. This talk aims to describe a pattern on how to use Dagger avoiding common pitfalls and leveraging the main advantages of Dependency Injection (DI).

Transcript

1. How to use Dagger 2 in Android Marcelo Benites @marcelorbenites
2. About Me
3. Dependency Injection Dependency injection is a technique whereby one object supplies the dependencies of another object.
4. Dagger 1 or 2?
5. Dagger 2 • Better performance. • No reflection. • First to implement the full stack with generated code. • Easier to debug. • Easy to use Proguard. • Harder to replace dependencies for testing. • Way more complex.
7. Why Dagger? • Eases DI in Android components (ContentProvider, Activity, Service, Application and BroadcastReceiver) • Eases object's lifecycle management (Scopes). • "Eases" the replacement of dependencies for Functional (UI) Testing. • Standardizes object creation (large codebases/big teams).
8. Why NOT Dagger? • Steep learning curve. • Too many features you don't necessarily need. • May cause performance problems (if misused). • Easely leaks into all layers of your application. • Hard to get rid of.
9. How to use Dagger?
11. How to use Dagger? • dagger.android module? • @Inject annotated constructor or @Provides annotated methods? • How many components? • How do I group my classes in modules? • How do I use scopes? • Multibinding? • Producers? • Subcomponents?
12. Dagger Android Pattern
13. Dagger Android Pattern • Dagger solves - and only solves - Android components injection and lifecycle problems. • Always @Produces in modules never @Inject in constructors (only for Android components dependencies). • Application component. • Activity component as Application subcomponent. • Fragment component as Activity subcomponent. • BaseActivity, BaseFragment and BaseApplication manage components lifecycle. • Three scopes ApplicationScope, ActivityScope and FragmentScope. • Modules based on your architecture.
14. Architecture
15. Architecture Android SDK Interactors Entities SQLite Retrofit Presenters Realm Dagger OkHttp Gateways
16. Contacts Application
18. @Scope @MustBeDocumented @kotlin.annotation.Retention(value = AnnotationRetention.RUNTIME) annotation class ApplicationScope
19. @ApplicationScope @Component(modules = [InteractorModule::class, GatewayModule::class]) interface ApplicationComponent
20. abstract class BaseApplication : Application() { lateinit var component: ApplicationComponent override fun onCreate() { super.onCreate() component = DaggerApplicationComponent .builder() .interactorModule(InteractorModule()) .gatewayModule(GatewayModule(this)) .build() } }
21. @Module class InteractorModule { @ApplicationScope @Provides fun provideContactsInteractor(contactsGateway: ContactsGateway): ContactsInteractor { return ContactsInteractor(contactsGateway) } }
22. @Module class GatewayModule(private val application: Application) { @ApplicationScope @Provides fun provideContactsGateway(): ContactsGateway { return ContentResolverContactsGateway(application.contentResolver) } }
23. class ContactsApplication: BaseApplication() { @Inject lateinit var contactsInteractor: ContactsInteractor override fun onCreate() { super.onCreate() component.inject(this) contactsInteractor.setup() } }
24. @ApplicationScope @Component(modules = [InteractorModule::class, GatewayModule::class]) interface ApplicationComponent { fun inject(contactsApplication: ContactsApplication) }
25. Contacts Presentation
26. Contacts Presentation • ContactsActivity container. • ContactListFragment - display list of contacts. • ContactDetailFragment - display contact detail. • MVP architecture. • ContactsListPresenter • ContactDetailPresenter
27. @Scope @MustBeDocumented @kotlin.annotation.Retention(value = AnnotationRetention.RUNTIME) annotation class ActivityScope
28. @ActivityScope @Subcomponent(modules = [NavigatorModule::class]) interface ActivityComponent
29. abstract class BaseActivity : AppCompatActivity() { lateinit var component: ActivityComponent private set override fun onCreate(savedInstanceState: Bundle?) { component = (application as BaseApplication).component.plus(NavigatorModule(this)) super.onCreate(savedInstanceState) } }
30. @ApplicationScope @Component(modules = [InteractorModule::class, GatewayModule::class]) interface ApplicationComponent { fun plus(navigatorModule: NavigatorModule) : ActivityComponent fun inject(contactsApplication: ContactsApplication) }
31. @Module class NavigatorModule(private val activity: AppCompatActivity) { @ActivityScope @Provides fun provideContactsNavigator(): ContactsNavigator { return FragmentManagerContactsNavigator(activity.supportFragmentManager!!, R.id.activity_contacts_container) } }
32. class ContactsActivity : BaseActivity() { override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) setContentView(R.layout.activity_contacts) if (savedInstanceState == null) { supportFragmentManager .beginTransaction() .replace(R.id.activity_contacts_container, ContactListFragment.create()) .commit() } } }
33. @Scope @MustBeDocumented @kotlin.annotation.Retention(value = AnnotationRetention.RUNTIME) annotation class FragmentScope
34. @FragmentScope @Subcomponent(modules = [PresenterModule::class]) interface FragmentComponent
35. abstract class BaseFragment : Fragment() { lateinit var component: FragmentComponent private set override fun onAttach(context: Context?) { component = (activity as BaseActivity).component.plus(PresenterModule(this)) super.onAttach(context) } }
36. @ActivityScope @Subcomponent(modules = [NavigatorModule::class]) interface ActivityComponent { fun plus(presenterModule: PresenterModule) : FragmentComponent }
37. @Module class PresenterModule { @FragmentScope @Provides fun provideContactListPresenter(contactsInteractor: ContactsInteractor, contactsNavigator: ContactsNavigator): ContactListPresenter { return ContactListPresenter(contactsInteractor, contactsNavigator) } @FragmentScope @Provides fun provideContactDetailPresenter(contactsInteractor: ContactsInteractor): ContactDetailPresenter { return ContactDetailPresenter(contactsInteractor) } }
38. class ContactListFragment: BaseFragment(), ContactListView { @Inject lateinit var presenter: ContactListPresenter override fun onAttach(context: Context?) { super.onAttach(context) component!!.inject(this) } override fun onResume() { super.onResume() presenter.attachView(this) } override fun onPause() { presenter.detachView() super.onPause() } …….. }
39. class ContactDetailFragment: BaseFragment(), ContactDetailView { @Inject lateinit var presenter: ContactDetailPresenter override fun onAttach(context: Context?) { super.onAttach(context) component!!.inject(this) } override fun onResume() { super.onResume() presenter.attachView(this) } override fun onPause() { presenter.detachView() super.onPause() } …... }
40. @FragmentScope @Subcomponent(modules = [PresenterModule::class]) interface FragmentComponent { fun inject(contactDetailFragment: ContactDetailFragment) fun inject(contactListFragment: ContactListFragment) }
41. Lifecycle ApplicationScope ActivityScope FragmentScope FragmentScope ContactsManager ContactsNavigator ContactDetail Presenter ContactList Presenter
42. Functional (UI) Testing
43. abstract class BaseApplication : Application() { lateinit var component: ApplicationComponent private set override fun onCreate() { super.onCreate() component = createComponent() } open fun createComponent(): ApplicationComponent { return DaggerApplicationComponent.builder() .interactorModule(InteractorModule()) .gatewayModule(GatewayModule(this)) .build() } }
44. @ApplicationScope @Component(modules = [TestGatewayModule::class, InteractorModule::class]) interface TestApplicationComponent: ApplicationComponent
45. class TestComponentApplication: ContactsApplication() { override fun createComponent(): ApplicationComponent { return DaggerTestApplicationComponent .builder() .interactorModule(InteractorModule()) .testGatewayModule(TestGatewayModule()) .build() } }
46. class TestComponentRunner: AndroidJUnitRunner() { override fun newApplication(cl: ClassLoader?, className: String?, context: Context?): Application { return super.newApplication(cl, TestComponentApplication::class.java.name, context) } }
47. android { …... defaultConfig { testInstrumentationRunner "com.yourapplication.TestComponentRunner" } }
48. @Module class TestGatewayModule { @ApplicationScope @Provides fun provideContactsGateway(): ContactsGateway { return FakeContactsGateway() } }
49. class FakeContactsGateway: ContactsGateway { var fakeContacts: List<Contact> = arrayListOf() override fun getContacts(): List<Contact> { return fakeContacts } }
50. @RunWith(AndroidJUnit4::class) class ContactsActivityTest { @Rule @JvmField val rule: ActivityTestRule<ContactsActivity> = ActivityTestRule(ContactsActivity::class.java) @Inject lateinit var contactsGateway: ContactsGateway @Test fun shouldShowContacts() { val testComponentApplication = InstrumentationRegistry.getTargetContext().applicationContext as TestComponentApplication (testComponentApplication.component as TestApplicationComponent).inject(this) (contactsGateway as FakeContactsGateway).fakeContacts = arrayListOf(Contact("Bob Marley", "+19999299299")) // Exercise the UI // Assert result } }
51. To inject or not to inject?
52. To inject or not to inject? • To Inject ◦ Interactors ◦ Gateways ◦ Presenters • Not to Inject ◦ View classes (RecyclerView.Adapter, LayoutManager, Views, etc...)
53. Questions?