Dependency Injection in Android with Dagger and Hilt

Course Curriculum

Chapter 1: Introduction

Lecture 1: Introduction

Chapter 2: Fundamental Dependency Injection Techniques

Lecture 1: Dependency Injection Terminology

Lecture 2: Fundamental Dependency Injection Techniques

Lecture 3: Comparison Between Fundamental Dependency Injection Techniques

Lecture 4: Dependency Injection Puzzlers and Large-Scale Structure

Chapter 3: Dependency Injection Architectural Pattern

Lecture 1: Architectural Patterns

Lecture 2: Dependency Injection Architectural Pattern (DIAP)

Lecture 3: Fundamental Dependency Injection Techniques vs DIAP

Chapter 4: Tutorial Application

Lecture 1: Tutorial Application Demo

Lecture 2: How to Get the Source Code of the Tutorial Application

Lecture 3: Tutorial Application Code Review

Lecture 4: Tutorial Application Refactoring Rationale

Chapter 5: Journey to Dependency Injection in the Tutorial Application

Lecture 1: Extraction of the User Interface Logic into MVC View

Lecture 2: Exercise 1

Lecture 3: Base Class for MVC Views

Lecture 4: Extraction of the Domain Logic into Use Case

Lecture 5: Exercise 2

Lecture 6: Extraction of the Dialogs Management Logic into Dialogs Navigator

Lecture 7: Extraction of the Navigation Logic into Screens Navigator

Lecture 8: Model View Controller (MVC) Architectural Pattern

Lecture 9: Sharing an Instance of a Service among Multiple Clients

Lecture 10: Removing Unneeded "Proxy" Dependencies

Lecture 11: The Law of Demeter

Lecture 12: Refactoring the Use Case According to the Law of Demeter

Lecture 13: Exercise 3

Lecture 14: Application Composition Root

Lecture 15: Lazy Initialization of Services

Lecture 16: Activity Composition Root

Lecture 17: Exercise 4

Lecture 18: Exercise 4 Solution

Lecture 19: Runtime Construction Arguments

Lecture 20: Extraction of MVC Views Construction Logic into a Factory

Lecture 21: Exercise 5

Lecture 22: Presentation Composition Root

Lecture 23: Tutorial Application Refactoring Summary

Chapter 6: Pure Dependency Injection

Lecture 1: Pure Dependency Injection

Lecture 2: The Main Benefit of Dependency Injection

Lecture 3: Context Isolation

Lecture 4: Objects vs Data Structures

Lecture 5: Injecting Services "from Outside"

Lecture 6: Convention Over Configuration (CoC)

Lecture 7: Dependency Injection Frameworks

Chapter 7: Dagger 2 Tutorial

Lecture 1: Dagger 2

Lecture 2: Gradle Configuration

Lecture 3: Components and Modules

Lecture 4: Exercise 6

Lecture 5: Scopes

Lecture 6: Component as Injector

Lecture 7: Dependent Components

Lecture 8: Exercise 7

Lecture 9: Subcomponents

Lecture 10: Exercise 8

Lecture 11: Multi-Module Components

Lecture 12: Automatic Discovery of Services

Lecture 13: Provider Methods in Modules vs Automatic Discovery

Lecture 14: Workflow with Dagger

Lecture 15: Dagger Tutorial Summary

Chapter 8: Additional Dagger Conventions

Lecture 1: Android Services and Dialogs

Lecture 2: Static Provider Methods and Component Builders

Lecture 3: Type Bindings

Lecture 4: Qualifiers

Lecture 5: Providers

Chapter 9: Dagger and ViewModel

Lecture 1: ViewModel

Lecture 2: Incorrect ViewModel Integration

Lecture 3: Dedicated Factories for ViewModels

Lecture 4: Refactoring ViewModel Factories According to the Law of Demeter

Lecture 5: Centralized Factory for ViewModels

Lecture 6: Multibinding

Lecture 7: ViewModel with SavedState

Lecture 8: Why ViewModel is So Complex

Lecture 9: Simplification of ViewModel with SavedState

Chapter 10: Hilt

Lecture 1: Hilt

Lecture 2: Hilt's Fundamental Assumptions

Lecture 3: How to Get the Source Code

Lecture 4: Hilt Gradle Setup

Lecture 5: Removing Dagger Components

Lecture 6: Hilt Injection Mechanics

Lecture 7: Installing Modules into Components

Lecture 8: Hilt Scopes

Lecture 9: Providing AppCompatActivity

Lecture 10: Hilt and ViewModel

Lecture 11: Hilt Summary

Chapter 11: Course Summary

Lecture 1: Course Summary

Lecture 2: Bonus Lecture