Dependency Injection with Dagger 2

Creating the Application Component Interface

Autoplay

Up next

Building the Application Component

Previous

Creating the GitHub Browser Project

About

We're ready to dive into Dagger 2 with the Application Component. This is the "top level" Singleton Component. We'll go over what a Component is, and how to define the interface for one, which Dagger 2 will use to generate an implementation.

Instructor

Brandon Gogetap

Links

Comments

Can you explain in more details about why the @BindInstance annotation is needed?

Hi Steve!

@BindsInstance is a way to bind an instance of a dependency into the Dagger graph (make it injectable elsewhere) without needing to use a Module.

Here, we are telling Dagger that if any other object, injected by this Component, injects a Context (the type of the parameter), then give them this instance context (the value we pass when calling the Factory create method).

There will be more uses of this throughout the course which should help to solidify the concept in your mind.

Main takeaway is this is shorthand for providing a dependency without using a Module.

>

Log In or Go Pro

Lessons in Dependency Injection with Dagger 2

1. Intro to Dependency Injection - Simple example with no DI

2. Intro to Dependency Injection - Dependency Injection in Practice

3. Why we use Dependency Injection

4. How Dependency Injection frameworks help

5. What we're building - Final Product

6. Creating the GitHub Browser Project

7. Creating the Application Component Interface

8. Building the Application Component

9. Dagger codegen: Inspecting the generated Application Component

10. Adding the GitHubApi Module

11. Creating a Dagger 2 Module

12. Creating the AppRepository - The single source of data for the UI

13. Dagger codegen: Checking in on the generated Application Component

14. Unit Testing the AppRepository

15. Feature: Home Screen

16. Home Screen Repository List Setup

17. Home Screen ViewModel

18. Injecting a Jetpack ViewModel

19. Exposing Singleton Dependencies in a Modular Way

20. Home Screen Component

21. Dagger codegen: Component Dependencies

22. Dagger codegen: Multibindings

23. Dagger codegen: @Binds, @Provides, and Modules

24. Matching Dagger Component Scopes with ViewModel Scopes

25. Unit Testing HomeViewModel

26. Displaying fake data in the Home Fragment

27. Espresso tests and Dagger: Modularizing ApplicationComponent

28. Espresso tests and Dagger: Adding the TestApplicationComponent

29. Espresso tests and Dagger: Adding the Test Application and Runner

30. HomeFragment Espresso Test

31. Retrofit integration: Suspend Functions

32. Retrofit integration: Preparing for the real GitHub API

33. Retrofit integration: Swapping mock GitHubApi with implementation created by Retrofit

34. Dagger Modules: Build variants/flavors

35. Dagger codgen: Effects of Module changes

36. Feature: Repo Details Screen

37. Repo Details Component

38. RepoDetails ViewModel Part 1

39. Dagger codegen: Qualifier Annotations

40. Extending GitHub API: Single repository fetch

41. AppRepository updates: Caching and new request

42. AppRepository Unit Test Updates

43. Repo Details Contributors List Setup

44. Repo Details View States

45. Repo Details ViewModel Test

46. Hooking up RepoDetailsFragment with View States

47. RepoDetailsFragment Espresso Test

48. Preparing for screen navigation

49. Activity Scoped Component

50. Activity Screen Navigator

51. Fake ScreenNavigator: A fake navigator for tests

52. Navigating from the Home screen to the Details screen

53. Dagger codegen: Walking through all the layers

54. PowerAdapter - A Dependency Injection driven RecyclerView Adapter

55. Using PowerAdapter for the Home screen