Dagger.Android module

In this talk, we will explore the usage of the new Dagger Android functionality. We will:
1. go through the Dagger Android module and will see how it can be used in Android applications;
2. compare the differences between how code looks like with using this module and usual way of using Dagger in Android;
3. talk about how this module helps with integration tests.

Transcript

1. DAGGER.ANDROID MODULE Dmytro Khmelenko Software Engineer @ Freeletics 25 November 2017
2. DEPENDENCY INJECTION “Dependency injection is a technique whereby one object supplies the dependencies of another object.” 2
3. DAGGER • dependency injection framework started by Square, now maintained by Google • compile-time • is currently in active development 3
4. MODULE 4 @Module abstract class NetworkModule { @Provides @Singleton static Retrofit retrofit() { return new Retrofit.Builder() .baseUrl("https://api.freeletics.com") .build(); } @Provides @Singleton static FreeleticsRestClient provideRestClient(Retrofit retrofit) { return new FreeleticsRestClient(retrofit); } }
5. COMPONENT 5 @Singleton @Component(modules = {NetworkModule.class}) public interface BaseComponent { void inject(MainActivity activity); FreeleticsRestClient freeleticsClient(); }
6. INJECTION 6 public class MyApp extends Application { private BaseComponent mBaseComponent; public void onCreate() { super.onCreate(); mBaseComponent = DaggerBaseComponent.create(); } public static MyApp instance() { return (MyApp) getApplicationContext(); } public BaseComponent activityInjector() { return mBaseComponent; } }
7. INJECTION 7 public class MainActivity extends AppCompatActivity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); MyApp.instance().activityInjector().inject(this); } }
8. SO WHAT’S WRONG WITH THAT? 8 • copy-paste component/subcomponent injection in each activity/ fragment
9. SO WHAT’S WRONG WITH THAT? 9 @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); BaseComponent baseComponent = (BaseComponent) MyApp.get(this) .component(); WorkoutComponent component = baseComponent .workoutComponent(new WorkoutModule(this)); component.inject(this); }
10. SO WHAT’S WRONG WITH THAT? 10 • copy-paste component/subcomponent injection in each activity/ fragment • activity/fragment needs to be declared for injection
11. SO WHAT’S WRONG WITH THAT? 11 @Singleton @Component(modules = {NetworkModule.class}) public interface BaseComponent { void inject(MainActivity activity); void inject(AuthActivity activity); void inject(RegistrationActivity activity); void inject(WorkoutActivity activity); void inject(WelcomeFragment fragment); }
12. THERE IS A SOLUTION! 12 Dagger.Android module From Dagger 2.10 (released on 30.03.2017)
13. MODULE 13 @Module abstract class NetworkModule { @Provides @Singleton static Retrofit retrofit() { return new Retrofit.Builder() .baseUrl("https://api.freeletics.com") .build(); } @Provides @Singleton static FreeleticsRestClient provideRestClient(Retrofit retrofit) { return new FreeleticsRestClient(retrofit); } }
14. BUILDER 14 @Subcomponent(modules = {NetworkModule.class}) public interface MainActivitySubcomponent extends AndroidInjector<MainActivity> { @Subcomponent.Builder abstract class Builder extend AndroidInjector.Builder<MainActivity> { } }
15. ACTIVITY BINDING 15 @Module(subcomponents = MainActivitySubcomponent.class) public abstract class MainActivityModule { @Binds @IntoMap @ActivityKey(MainActivity.class) abstract AndroidInjector.Factory<? extends Activity> bind(MainActivitySubcomponent.Builder builder); }
16. INJECTOR FACTORIES 16 Key Value MainActivity.class Provider<MainActivitySubcomponent.Builder> AuthActivity.class Provider<AuthActivitySubcomponent.Builder>
17. ACTIVITY BINDING 17 @Subcomponent(modules = {NetworkModule.class}) public interface MainActivitySubcomponent extends AndroidInjector<MainActivity> { @Subcomponent.Builder abstract class Builder extend AndroidInjector.Builder<MainActivity> { } } @Module(subcomponents = MainActivitySubcomponent.class) public abstract class MainActivityModule { @Binds @IntoMap @ActivityKey(MainActivity.class) abstract AndroidInjector.Factory<? extends Activity> bind(MainActivitySubcomponent.Builder builder); }
18. ACTIVITY BINDING 18 @Module public abstract class MainActivityModule { @ActivityScope @ContributesAndroidInjector(modules = {NetworkModule.class}) abstract MainActivity contributeYourActivityInjector(); }
19. COMPONENT 19 @Singleton @Component(modules = {NetworkModule.class, MainActivityModule.class, AndroidSupportInjectionModule.class}) public interface BaseComponent { void inject(MyApp app); FreeleticsRestClient freeleticsClient(); }
20. INJECTION 20 public class MyApp extends Application implements HasActivityInjector { @Inject DispatchingAndroidInjector<Activity> mInjector; public void onCreate() { super.onCreate(); BaseComponent baseComponent = DaggerBaseComponent.create(); baseComponent.inject(this); } @Override public AndroidInjector<Activity> activityInjector() { return mInjector; } }
21. INJECTION 21 public class MainActivity extends AppCompatActivity { @Override protected void onCreate(Bundle savedInstanceState) { AndroidInjection.inject(this); super.onCreate(savedInstanceState); } }
22. THAT’S COOL 22 But how is it working?
23. WorkoutActivitySubcomponent SCHEMA 23 MainActivitySubcomponent DaggerBaseComponent NetworkModule MainActivityModule WorkoutActivityModule AndroidInjector
24. GOT IT! 24 How about testing?
25. TESTING 25 1. Test Application 2. testBuildType
26. TESTING 26 @Module(subcomponents = TestMainActivitySubcomponent.class) public abstract class TestMainActivityModule { @Binds @IntoMap @ActivityKey(MainActivity.class) abstract AndroidInjector.Factory<? extends Activity> bind(TestMainActivitySubcomponent.Builder builder); }
27. TESTING 27 @Singleton @Component(modules = { MockNetworkModule.class, TestMainActivityModule.class, AndroidSupportInjectionModule.class }) public interface TestComponent { void inject(TestApp app); }
28. TESTING 28 public class TestApp extends Application implements HasActivityInjector { @Inject DispatchingAndroidInjector<Activity> mActivityInjector; @Override public void onCreate() { super.onCreate(); DaggerTestComponent.create().inject(this); } @Override public DispatchingAndroidInjector<Activity> activityInjector() { return mActivityInjector; } }
29. TESTING 29 public class FreeleticsTestRunner extends AndroidJUnitRunner { @Override public Application newApplication(ClassLoader cl, String className, Context context) throws InstantiationException, IllegalAccessException, ClassNotFoundException { String appClassName = TestApp.class.getCanonicalName(); return super.newApplication(cl, appClassName, context); } }
30. TESTING 30 android { defaultConfig { testInstrumentationRunner “com.example.FreeleticsTestRunner” } }
31. SUMMARY 31 Easier injection Steep learning curve Clearer injection Less error-prone Clearer testing
32. 1. google.github.io/dagger/android.html 2. google.github.io/dagger/api/2.13 3. github.com/googlesamples/android-architecture/tree/todo-mvp-dagger 4. github.com/dkhmelenko/Varis-Android 32 RESOURCES
33. QUESTIONS? github.com/dkhmelenko twitter.com/dkhmelenko speakerdeck.com/dkhmelenko