How to use Dagger 2 in Android Marcelo Benites @marcelorbenites 

About Me 

Dependency Injection Dependency injection is a technique whereby one object supplies the dependencies of another object. 

Dagger 1 or 2? 

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. 

No content

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). 

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. 

How to use Dagger? 

No content

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? 

Dagger Android Pattern 

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. 

Architecture 

Architecture Android SDK Interactors Entities SQLite Retrofit Presenters Realm Dagger OkHttp Gateways 

Contacts Application 

No content

@Scope @MustBeDocumented @kotlin.annotation.Retention(value = AnnotationRetention.RUNTIME) annotation class ApplicationScope 

@ApplicationScope @Component(modules = [InteractorModule::class, GatewayModule::class]) interface ApplicationComponent 

abstract class BaseApplication : Application() { lateinit var component: ApplicationComponent override fun onCreate() { super.onCreate() component = DaggerApplicationComponent .builder() .interactorModule(InteractorModule()) .gatewayModule(GatewayModule(this)) .build() } } 

@Module class InteractorModule { @ApplicationScope @Provides fun provideContactsInteractor(contactsGateway: ContactsGateway): ContactsInteractor { return ContactsInteractor(contactsGateway) } } 

@Module class GatewayModule(private val application: Application) { @ApplicationScope @Provides fun provideContactsGateway(): ContactsGateway { return ContentResolverContactsGateway(application.contentResolver) } } 

class ContactsApplication: BaseApplication() { @Inject lateinit var contactsInteractor: ContactsInteractor override fun onCreate() { super.onCreate() component.inject(this) contactsInteractor.setup() } } 

@ApplicationScope @Component(modules = [InteractorModule::class, GatewayModule::class]) interface ApplicationComponent { fun inject(contactsApplication: ContactsApplication) } 

Contacts Presentation 

Contacts Presentation ● ContactsActivity container. ● ContactListFragment - display list of contacts. ● ContactDetailFragment - display contact detail. ● MVP architecture. ● ContactsListPresenter ● ContactDetailPresenter 

@Scope @MustBeDocumented @kotlin.annotation.Retention(value = AnnotationRetention.RUNTIME) annotation class ActivityScope 

@ActivityScope @Subcomponent(modules = [NavigatorModule::class]) interface ActivityComponent 

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) } } 

@ApplicationScope @Component(modules = [InteractorModule::class, GatewayModule::class]) interface ApplicationComponent { fun plus(navigatorModule: NavigatorModule) : ActivityComponent fun inject(contactsApplication: ContactsApplication) } 

@Module class NavigatorModule(private val activity: AppCompatActivity) { @ActivityScope @Provides fun provideContactsNavigator(): ContactsNavigator { return FragmentManagerContactsNavigator(activity.supportFragmentManager!!, R.id.activity_contacts_container) } } 

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() } } } 

@Scope @MustBeDocumented @kotlin.annotation.Retention(value = AnnotationRetention.RUNTIME) annotation class FragmentScope 

@FragmentScope @Subcomponent(modules = [PresenterModule::class]) interface FragmentComponent 

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) } } 

@ActivityScope @Subcomponent(modules = [NavigatorModule::class]) interface ActivityComponent { fun plus(presenterModule: PresenterModule) : FragmentComponent } 

@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) } } 

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() } …….. } 

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() } …... } 

@FragmentScope @Subcomponent(modules = [PresenterModule::class]) interface FragmentComponent { fun inject(contactDetailFragment: ContactDetailFragment) fun inject(contactListFragment: ContactListFragment) } 

Lifecycle ApplicationScope ActivityScope FragmentScope FragmentScope ContactsManager ContactsNavigator ContactDetail Presenter ContactList Presenter 

Functional (UI) Testing 

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() } } 

@ApplicationScope @Component(modules = [TestGatewayModule::class, InteractorModule::class]) interface TestApplicationComponent: ApplicationComponent 

class TestComponentApplication: ContactsApplication() { override fun createComponent(): ApplicationComponent { return DaggerTestApplicationComponent .builder() .interactorModule(InteractorModule()) .testGatewayModule(TestGatewayModule()) .build() } } 

class TestComponentRunner: AndroidJUnitRunner() { override fun newApplication(cl: ClassLoader?, className: String?, context: Context?): Application { return super.newApplication(cl, TestComponentApplication::class.java.name, context) } } 

android { …... defaultConfig { testInstrumentationRunner "com.yourapplication.TestComponentRunner" } } 

@Module class TestGatewayModule { @ApplicationScope @Provides fun provideContactsGateway(): ContactsGateway { return FakeContactsGateway() } } 

class FakeContactsGateway: ContactsGateway { var fakeContacts: List = arrayListOf() override fun getContacts(): List { return fakeContacts } } 

@RunWith(AndroidJUnit4::class) class ContactsActivityTest { @Rule @JvmField val rule: ActivityTestRule = 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 } } 

To inject or not to inject? 

To inject or not to inject? ● To Inject ○ Interactors ○ Gateways ○ Presenters ● Not to Inject ○ View classes (RecyclerView.Adapter, LayoutManager, Views, etc...) 

Questions?