Upgrade to Pro — share decks privately, control downloads, hide ads and more …

Mike Nakhimovich: Swordfighting with Dagger

1fa9cb8c7997c8c4d3d251fb5e41f749?s=47 Realm
July 28, 2016

Mike Nakhimovich: Swordfighting with Dagger

Excerpt: Are you tired of seeing examples of CoffeeMakers? Have you ever wondered if you really need that provides method? Want to learn how to inject something besides Thermosiphon?
This talk will cover real life patterns and use cases for Dagger 2 as it’s implemented in the New York Times newsreader app. We’ll compare the Dagger Way with its unwieldy alternative and dive into project organization, simplicity in testing, object graphs, and how to never forget to save/restore your intent extras. This talk is a great sequel to Dan Lew’s talk on Dependency Injection Made Simple.
Bio: Mike’s an Android architect at the New York Times who adores reactive programming and performance tuning. In his free time, he enjoys writing about Android architecture, checking his email compulsively to see if he’s been featured in Android Weekly, and stretching out by the pool with a nice trace file.

Twitter: https://twitter.com/friendlyMikhail

1fa9cb8c7997c8c4d3d251fb5e41f749?s=128

Realm

July 28, 2016
Tweet

Transcript

  1. @NYTDevs | developers.nytimes.com Mike Nakhimovich @FriendlyMikhail Android Framework Team Swordfighting

    with Dagger Dependecy Injection Made Less Simple
  2. What is Dagger? Alternative way to instantiate and manage your

    objects • Guice - Google (Dagger v.0) • Dagger 1 - Square • Dagger 2 - Back to Google :-)
  3. Why Do We Need It? Good Code = Testable Code

  4. Why Do We Need It? More Tests = Less Anxiety

  5. Why Do We Need It? Proper Code Organization is a

    requirement for testing
  6. Untestable Code (Me in the Beginning) public class MyClass {

    private Model model; public MyClass() {this.model = new Model();} public String getName() {return model.getName();} } How can we test if model.getName() was called?
  7. Internet Told Me to Externalize My Dependencies public class MyClass

    { ... public MyClass(Model model) {this.model = model;} public String getName() {return model.getName();} }... public void testGetData(){ Model model = mock(Model.class); when(model.getName()).thenReturn( "Mike"); MyClass myClass = new MyClass(model).getName(); verify(myClass.getName()).isEq("Mike"); }
  8. Where Does Model Come From? Dependency Injection to the rescue!

  9. Dagger Helps You Externalize Object Creation @Provides Model provideModel(){ return

    new Model(); }
  10. Provide from Modules @Module public class AppModule{ } A module

    is a part of your application that provides some functionality.
  11. Provide from Modules @Module public class AppModule{ @Provides Model provideModel(){

    return new Model(); } ... A module is a part of your application that provides some functionality.
  12. Components are Composed of Modules @Singleton @Component(modules = {MyModule.class}) public

    interface AppComponent { void inject(MyActivity activity); } A Component is the manager of all your module providers
  13. Next, Create a Component Instance component = DaggerAppComponent.builder() .myModule(new MyModule(this))

    .build();
  14. Register with Component protected void onCreate(Bundle savedInstanceState) { getApplicationComponent().inject(this);

  15. Injection Fun Now you can inject dependencies as fields or

    constructor arguments @Inject Model model; @Inject public Presenter(Model model)
  16. Dagger @ NY Times Now for the fun stuff! 50%

    Recipes 50% Ramblings
  17. Dagger @ NY Times • Module/Component Architecture ◦ Working with

    libraries ◦ Build Types & Flavors • Scopes ◦ Application ◦ Activity (Now with Singletons!) • Testing ◦ Espresso ◦ Unit Testing
  18. Code Organization How Dagger manages 6 build variants & 6+

    libraries GoogleDebug AmazonDebug GoogleBeta AmazonBeta GoogleRelease AmazonRelease
  19. Application Scoped Modules • App Module • Build Type Module

    • Library Module • Flavor Module
  20. App Module Singletons ◦ Parser (configured GSON)

  21. App Module Singletons ◦ Parser (configured GSON) ◦ IO Managers

  22. App Module Singletons ◦ Parser (configured GSON) ◦ IO Managers

    ◦ Configs (Analytics,AB, E-Commerce)
  23. Example Library Module: E-Commerce @Module public class ECommModule { @Provides

    @Singleton public ECommBuilder provideECommBuilder( )
  24. E-Comm using App Module’s Dep @Module public class ECommModule {

    @Provides @Singleton public ECommBuilder provideECommBuilder(ECommConfig config){ return new ECommManagerBuilder().setConfig(config); }
  25. Amazon & Google Flavors • Amazon Variants needs Amazon E-Commerce

    • Google Variants needs to contain Google E-Commerce How can Dagger help?
  26. E-Comm Qualified Provider @Module public class ECommModule { @Provides @Singleton

    public ECommBuilder provideECommBuilder(ECommConfig config){ return new ECommManagerBuilder().setConfig(config); } @Provides @Singleton @Google public ECommManager providesGoogleEComm (ECommBuilder builder, GooglePayments googlePayments)
  27. E-Comm Qualified Provider @Module public class ECommModule { @Provides @Singleton

    public ECommBuilder provideECommBuilder(ECommConfig config){ return new ECommManagerBuilder().setConfig(config); } ... @Provides @Singleton @Amazon public ECommManager providesAmazonEComm (ECommBuilder builder, AmazonPayments amazonPayments)
  28. Flavor Module: src/google & src/Amazon @Module public class FlavorModule {

    }
  29. Flavor Module Provides Non-Qualified E-Comm @Module public class FlavorModule {

    @Singleton @Provides ECommManager provideECommManager(@Google ECommManager ecomm) } Note: Proguard strips out the other impl from Jar :-)
  30. Type Module Brings build specific dependencies/providers in Type Module

  31. Type Module Brings build specific dependencies/providers in Type Module ◦

    Logging ▪ Most logging for Beta Build ▪ No-Op Release
  32. Type Module Brings build specific dependencies/providers in Type Module ◦

    Logging ▪ Most logging for Beta Build ▪ No-Op Release ◦ Payments ▪ No-Op for debug
  33. Type Module • Brings build specific dependencies/providers in Type Module

    ◦ Logging ▪ Most logging for Beta Build ▪ No-Op Release ◦ Payments ▪ No-Op for debug ◦ Device ID ▪ Static for Debug
  34. Component Composition How we combine our modules

  35. Start with Base Component • Base Component lives in src/main

    • Contains inject(T t) for classes & Services that register with Dagger (non flavor/build specific) interface BaseComponent { void inject(NYTApplication target); }
  36. Src/Google & Src/Amazon Contain a FlavorComponent • Create FlavorComponent that

    inherits from BaseComponent • Register inject for flavor specific classes • Anything not in src/flavor that needs component registers here ie: ◦ Messaging Service ◦ Payment Activity public interface FlavorComponent extends BaseComponent { void inject(ADMessaging target); }
  37. App Component debug, beta, release One for src/debug src/beta src/release

    public interface ApplicationComponent { }
  38. App Component Inherits from Flavor Component public interface ApplicationComponent extends

    FlavorComponent { }
  39. App Component • Adds @Component @Singleton annotations @Singleton @Component public

    interface ApplicationComponent extends FlavorComponent { }
  40. App Component • Adds modules @Singleton @Component(modules = {ApplicationModule.class, FlavorModule.class,

    TypeModule.class, AnalyticsModule.class, ECommModule.class, PushClientModule.class }) public interface ApplicationComponent extends FlavorComponent { }
  41. Anything registering with App Component gains access to all providers

    for the Flavor/Type
  42. Usage of Generated App Component

  43. App Component Factory public class ComponentFactory { public AppComponent buildComponent(Application

    context) { return componentBuilder(context).build(); } // We override it for functional tests. DaggerApplicationComponent.Builder componentBuilder(Application context) { return DaggerApplicationComponent.builder() .applicationModule(new ApplicationModule(context)} }
  44. Component Instance • NYT Application retains component private void buildComponentAndInject()

    { appComponent = componentFactory().buildComponent(this); appComponent.inject(this); } public ComponentFactory componentFactory() { return new ComponentFactory(); }
  45. Introducing Activity Scope

  46. Activity Component • Inherits all “provides” from App Component •

    Allows you to add “Activity Singletons” ◦ 1 Per Activity ◦ Many views/fragments within activity can inject same instance
  47. ActivityComponent @Subcomponent(modules = {ActivityModule.class, BundleModule.class}) @ScopeActivity public interface ActivityComponent {

    void inject(ArticleView view); } Add to AppComponent: Activitycomponent plusActivityComponent(ActivityModule activityModule);
  48. ActivityComponentFactory public final class ActivityComponentFactory { public static ActivityComponent create(Activity

    activity) { return ((NYTApp)activity.getApplicationContext).getComponent() .plusActivityComponent(new ActivityModule(activity)); } }
  49. Activity Component Injection public void onCreate(@Nullable Bundle savedInstanceState) { activityComponent

    = ActivityComponentFactory.create(this); activityComponent.inject(this);
  50. Activity Component Modules

  51. Activity Module • Publish Subjects (mini bus) • Reactive Text

    Resizer • Snack Bar Util
  52. Font Resizing @Provides @ScopeActivity @FontBus PublishSubject<Integer> provideFontChangeBus() { return PublishSubject.create();

    } @Provides @ScopeActivity FontResizer provideFontResize( @FontBus PublishSubject<Integer> fontBus) { return new FontResizer(fontBus); }
  53. Usage of Font Resizer @Inject FontResizer fontResizer; private void registerForFontResizing(View

    itemView) { fontResizer.registerResize(itemView); }
  54. Usage of Font Resize “Bus” @Inject public SectionPresenter(@FontBus PublishSubject<Integer> fontBus)

    { fontBus.subscribe(fontSize -> handleFontHasChanged()); } Dagger helps us inject only what we need
  55. SnackBarUtil @ScopeActivity public class SnackbarUtil { @Inject Activity activity; public

    Snackbar makeSnackbar(String txt, int duration) { return Snackbar.make(...);} } …. In some presenter class: public void onError(Throwable error) { snackbarUtil.makeSnackbar(SaveHandler.SAVE_ERROR, SHORT).show(); }
  56. Bundle Module, A Love Story

  57. Bundle Management Passing intent arguments to fragments/views is painful •

    Need to save state • Complexity with nested fragments • Why we not inject intent arguments instead?
  58. Create Bundle Service public class BundleService { private final Bundle

    data; public BundleService(Bundle savedState, Bundle intentExtras) { data = new Bundle(); if (savedState != null) { data.putAll(savedState); } if (intentExtras != null) { data.putAll(intentExtras); } }
  59. Instantiate Bundle Service in Activity @Override protected void onCreate(@Nullable Bundle

    savedInstanceState) { bundleService = new BundleService(savedInstanceState, getIntent().getExtras()); //Never have to remember to save instance state again! protected void onSaveInstanceState(Bundle outState) { outState.putAll(bundleService.getAll());
  60. Bind Bundle Service to Bundle Module @Provides @ScopeActivity public BundleService

    provideBundleService(Activity context) { return ((Bundler) context).getBundleService(); }
  61. Provide Individualized Intent Values @Provides @ScopeActivity @AssetId public Long provideArticleId(BundleService

    bundleService) { return bundleService.get(ArticleActivity.ASSET_ID); }
  62. Inject Intent Values Directly into Views & Presenters @Inject public

    CommentPresenter(@AssetId String assetId){ //fetch comments for current article }
  63. Old Way Normally we would have to pass assetId from:

    ArticleActivity to ArticleFragment to CommentFragment to CommentView to CommentPresenter :-l
  64. Testing

  65. Simple Testing JUNIT Mockito, AssertJ @Mock AppPreferences prefs; @Before public

    void setUp() { inboxPref = new InboxPreferences(prefs); } @Test public void testGetUserChannelPreferencesEmpty() { when(prefs.getPreference(IUSER_CHANNELS,emptySet())) .thenReturn(null); assertThat(inboxPref.getUserChannel()).isEmpty(); }
  66. Testing with Dagger

  67. Dagger BaseTestCase public abstract class BaseTestCase extends TestCase { protected

    TestComponent getTestComponent() { final ApplicationModule applicationModule = getApplicationModule(); return Dagger2Helper.buildComponent( TestComponent.class, applicationModule));}
  68. TestComponent @Singleton @Component(modules = {TestModule.class,ApplicationModule.class, FlavorModule.class, TypeModule.class, AnalyticsModule.class, EcommModule.class, PushModule.class})

    public interface TestComponent { void inject(WebViewUtilTest test);
  69. Dagger Test with Mocks public class WebViewUtilTest extends BaseTestCase {

    @Inject NetworkStatus networkStatus; @Inject WebViewUtil webViewUtil; protected ApplicationModule getApplicationModule() { return new ApplicationModule(application) { protected NetworkStatus provideNetworkStatus() { return mock(NetworkStatus.class); } }; }
  70. Dagger Test with Mocks public class WebViewUtilTest extends BaseTestCase {

    @Inject NetworkStatus networkStatus; @Inject WebViewUtil webViewUtil; … @Test public void testNoValueOnOffline() throws Exception { when(networkStatus.isInternetConnected()).thenReturn(false); webViewUtil.getIntentLauncher().subscribe(intent -> {fail("intent was launched");});}
  71. Dagger Test with Mocks Gotchas • Must have provides method

    • Must be in module you are explicitly passing into Dagger
  72. Functional/Espresso Testing

  73. NYTFunctionalTestApp • Creates Component with overridden providers

  74. NYTFunctionalTestApp • Creates Component with overridden providers • Mostly no-op

    since this is global ▪ Analytics ▪ AB Manager ▪ Other Test impls (network, disk)
  75. NYTFunctionalTestApp • Creates Component with overridden providers • Mostly no-op

    since this is global ▪ Analytics ▪ AB Manager ▪ Other Test impls (network, disk) • Functional test runner uses custom FunctTestApp
  76. NYTFunctionalTestApp • Creates Component with overridden providers • Mostly no-op

    since this is global ▪ Analytics ▪ AB Manager ▪ Other Test impls (network, disk) • Functional test runner uses custom FunctTestApp • Test run end to end otherwise
  77. NYTFunctionalTestApp public class NYTFunctionalTestsApp extends NYTApplication { ComponentFactory componentFactory(Application context)

    { return new ComponentFactory() { protected DaggerApplicationComponent.Builder componentBuilder(Application context) { return super.componentBuilder(context) .applicationModule(new ApplicationModule(NYTFunctionalTestsApp.this) { protected ABManager provideABManager() { return new NoOpABManager(); }
  78. NYTFunctionalTestRunner public class NYTFunctionalTestsRunner extends AndroidJUnitRunner { @Override public Application

    newApplication(ClassLoader cl,String className, Context context) { return newApplication(NYTFunctionalTestsApp.class, context); } }
  79. Sample Espresso Test @RunWith(AndroidJUnit4.class) public class MainScreenTests { @Test public

    void openMenuAndCheckItems() { mainScreen .openMenuDialog() .assertMenuDialogContainsItemWithText(R.string.dialog_menu_font_resize) .assertMenuDialogContainsItemWithText(R.string.action_settings); }
  80. @NYTDevs | developers.nytimes.com Questions?

  81. @NYTDevs | developers.nytimes.com Thank You! (We’re hiring) @FriendlyMikhail