swordfighting-with-dagger

Here,Idorenyin Obong explains the basics concepts of dependency injection with Dagger 2

Transcript

1. SWORD FIGHTING WITH DAGGER
3. HEY! I’m Idorenyin Obong Android developer @Hotels.ng, Guest Author @Auth0
4. What is Dependency Injection ?
5. Dependency Injection • It is a design pattern.
6. Dependency Injection • It is a design pattern. • We are not initializing anything.
7. Dependency Injection • It is a design pattern. • We are not initializing anything. • Giving an object its instance variables. - James Shore
8. // before dependency injection public class Nsikak { AndroidNigeria androidNigeria = new AndroidNigeria(); public Nsikak() {} void teachMVVM(){ androidNigeria.submitC4P(); } }
9. // with dependency injection public class Nsikak { AndroidNigeria androidNigeria; public Nsikak(AndroidNigeria androidNigeria) { this.androidNigeria = androidNigeria; } void teachMVVM(){ androidNigeria.submitC4P(); } }
10. Why do we need Dependency Injection?
11. Why do we need Dependency Injection? • Unit testing
12. Why do we need Dependency Injection? • Unit testing • Scalability
13. Why do we need Dependency Injection? • Unit testing • Scalability • Reusable resources
14. Dagger’s History
15. Crash course on Dagger2 • How you provide dependencies - by using a Module class
16. The Module class • Must be annotated with @Module
17. The Module class • Must be annotated with @Module • Should contain methods annotated with @Provides or @Binds
18. The Module class • Must be annotated with @Module • Should contain methods annotated with @Provides or @Binds
19. The Module class Must be annotated with @Module Should contain methods annotated with @Provides or @Binds
20. @Binds abstract MyClass bindsClass (MyClass myClass); @Provides String provideString(){ return "Hello World"; }
21. Crash course on Dagger2 • How you provide dependencies - by using a Module class • How you request dependencies - by using the @Inject annotation
22. Crash course on Dagger2 • How you provide dependencies - by using a Module class • How you request dependencies - by using the @Inject annotation • What happens between the injection and the Module ?
23. The Component Interface happened!
24. The Component Interface • It is an interface - obviously.
25. The Component Interface • It is an interface - obviously. • It is annotated with @Component.
26. The Component Interface • It is an interface - obviously. • It is annotated with @Component. • It manages all your modules.
27. The Component Interface • It is an interface - obviously. • It is annotated with @Component. • It manages all your modules. • At runtime, Dagger generates a class that implements this interface.
28. The Component Interface • It is an interface - obviously. • It is annotated with @Component. • It manages all your modules. • At runtime, Dagger generates a class that implements this interface. • The generated class provides injected instances of the app’s modules.
29. The component interface is the magic between providing and getting dependencies.
30. Code implementation 1. Create a new Android project. 2. Add Dagger’s dependencies. implementation 'com.google.dagger:dagger:2.14.1' annotationProcessor 'com.google.dagger:dagger-compiler:2.14.1' // dagger android implementation 'com.google.dagger:dagger-android-support:2.14.1' annotationProcessor 'com.google.dagger:dagger-android-processor:2.14.1'
31. Code implementation 3. Add dependencies to the graph - create module classes.
32. @Module public abstract class AppModule { }
33. @Module public abstract class AppModule { @Provides @Singleton static ApiService providesWebService () { Retrofit.Builder builder = new Retrofit.Builder() .baseUrl(BuildConfig.END_POINT) .addConverterFactory(ScalarsConverterFactory.create()) .addConverterFactory(GsonConverterFactory.create()); Retrofit retrofit = builder .client(providesOkHttpClientBuilder()) .build(); return retrofit.create(ApiService.class); } }
34. Code implementation 3. Add dependencies to the graph - create module classes. 4. Setup the component interface.
35. public interface AppComponent { }
36. @Component(modules = {AppModule.class, AndroidSupportInjectionModule.class}) public interface AppComponent extends AndroidInjector<AppController> { }
37. @Component(modules = {AppModule.class, AndroidSupportInjectionModule.class}) public interface AppComponent extends AndroidInjector<AppController> { @Override void inject(AppController instance); }
38. @Component(modules = {AppModule.class, AndroidSupportInjectionModule.class}) public interface AppComponent extends AndroidInjector<AppController> { @Override void inject(AppController instance); @Component.Builder interface Builder { @BindsInstance AppComponent.Builder application(AppController application); AppComponent build(); } }
39. Code implementation 3. Add dependencies to the graph - create module classes. 4. Setup the component interface. 5. Configure the Application class.
40. public class AppController extends Application { }
41. public class AppController extends Application implements HasActivityInjector { @Override public void onCreate() { super.onCreate(); DaggerAppComponent.builder().application(this) .build().inject(this); } }
42. public class AppController extends Application implements HasActivityInjector { @Inject DispatchingAndroidInjector<Activity> activityDispatchingAndroidInjector; @Override public void onCreate() { super.onCreate(); DaggerAppComponent.builder().application(this) .build().inject(this); } @Override public AndroidInjector<Activity> activityInjector() { return activityDispatchingAndroidInjector; } }
43. Code implementation 3. Add dependencies to the graph - create module classes. 4. Setup the component interface. 5. Configure the Application class. 6. Prepare your activities to receive dependencies.
44. public class MainActivity extends AppCompatActivity implements HasSupportFragmentInjector { }
45. public class MainActivity extends AppCompatActivity implements HasSupportFragmentInjector { @Override public AndroidInjector<Fragment> supportFragmentInjector() { return supportFragmentInjector; } }
46. public class MainActivity extends AppCompatActivity implements HasSupportFragmentInjector { @Inject DispatchingAndroidInjector<Fragment> supportFragmentInjector; @Override public AndroidInjector<Fragment> supportFragmentInjector() { return supportFragmentInjector; } }
47. public class MainActivity extends AppCompatActivity implements HasSupportFragmentInjector { @Inject DispatchingAndroidInjector<Fragment> supportFragmentInjector; @Override protected void onCreate(Bundle savedInstanceState) { AndroidInjection.inject(this); super.onCreate(savedInstanceState); } @Override public AndroidInjector<Fragment> supportFragmentInjector() { return supportFragmentInjector; } }
48. @Module public abstract class AppModule { @ContributesAndroidInjector abstract MainActivity mainActivity(); @Provides static ApiService providesWebService () { Retrofit.Builder builder = new Retrofit.Builder() .baseUrl(BuildConfig.END_POINT) .addConverterFactory(ScalarsConverterFactory.create()) .addConverterFactory(GsonConverterFactory.create()); Retrofit retrofit = builder .client(providesOkHttpClientBuilder()) .build(); return retrofit.create(ApiService.class); }
49. Code implementation 3. Add dependencies to the graph - create module classes. 4. Setup the component interface. 5. Configure the Application class. 6. Prepare your activities to receive dependencies. 7. Call your dependencies.
50. public class MainActivity extends AppCompatActivity implements HasSupportFragmentInjector { @Inject AndroidNigeria androidNigeria; @Inject ApiService apiService; @Inject DispatchingAndroidInjector<Fragment> supportFragmentInjector; @Override protected void onCreate(Bundle savedInstanceState) { AndroidInjection.inject(this); super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); androidNigeria.submitC4P(); } @Override public AndroidInjector<Fragment> supportFragmentInjector() { return supportFragmentInjector; } }
51. public class AndroidNigeria { @Inject public AndroidNigeria() { } public void submitC4P() { } }
52. Why is it necessary to use Dagger? • It creates a dependency graph at compile time. • Offers constructor, field, and method injection.
54. Resources • https://proandroiddev.com/dagger-2-component-relationships-cu stom-scopes-8d7e05e70a37 • https://android.jlelse.eu/dagger-2-the-simplest-approach-3e2350 2c4cab
55. THANK YOU! Twitter - @kingidee Any question?