Dependency Injection with Dagger 2

Activity Screen Navigator

This lesson is for PRO members.

Upgrade today to get access to all the PRO lessons.

Unlock this lesson

Autoplay

Up next

Fake ScreenNavigator: A fake navigator for tests

Previous

Activity Scoped Component

About

In this lesson we create a ScreenNavigator implementation that is tied to our Activity. This will be bound in the Dagger graph and be provided whenever another object injects the ScreenNavigator type.

Instructor

Brandon Gogetap

Links

Comments

Hi Brandon, could we have used the navigation library in place on this sort of custom navigation implementation? If so what specific advantage does this way provide us over the navigation library.

The navigator in this class was really just a simple way to demonstrate an @ActivityScope dependency; one that could be used in multiple different fragments.

So in short, no, I would not claim the navigation strategy in this app is better than Jetpack Navigation, or something like that.

That said, I do think custom navigation "libraries", whether they be wrappers around the framework/Jetpack navigation, or completely built from scratch, do have advantages. In general I prefer something on top of built-in/Jetpack navigation, but for smaller apps, I'm usually too lazy to implement anything like that :)

>

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