What is dependency injection in Android (Hilt, Dagger)?

Question

Accepted Answer

**Dependency injection (DI)** is a pattern where objects receive their dependencies from outside rather than creating them — improving testability, maintainability, and flexibility. In Android, **Hilt** (built on Dagger) is the recommended DI framework.

## What DI is and why

```text
WITHOUT DI: a class CREATES its own dependencies (tightly coupled, hard to test/change):
  class UserRepo { val api = ApiService() }   // creates its own dependency — rigid
WITH DI: dependencies are PROVIDED from outside (injected):
  class UserRepo(val api: ApiService)          // receives it → flexible, testable
→ Benefits: TESTABILITY (inject mocks/fakes in tests), DECOUPLING, easier to swap
  implementations, centralized dependency management, less boilerplate (with a framework).
```

## Hilt — the recommended Android DI framework

```kotlin
// Hilt (built on Dagger) generates/manages dependency wiring for you
@HiltAndroidApp class MyApp : Application()      // set up Hilt

@AndroidEntryPoint class MainActivity : AppCompatActivity() {
  @Inject lateinit var repository: UserRepository  // Hilt INJECTS this automatically
}

// tell Hilt how to provide things
@Module @InstallIn(SingletonComponent::class)
object AppModule {
  @Provides fun provideApi(): ApiService = Retrofit.Builder()...create()
}
```

Hilt handles creating and providing dependencies (with proper scoping/lifecycles), reducing manual wiring boilerplate.

## Why DI matters for architecture

```text
✓ TESTABILITY — inject test doubles (mocks/fakes) → unit-test in isolation (the big win)
✓ Works with architecture (MVVM): inject repositories into ViewModels, data sources into
  repositories → clean, decoupled, testable layers
✓ SCOPING — manage dependency lifecycles (singleton, per-activity, etc.)
✓ Less boilerplate than manual DI; standardized; Google-recommended (Hilt)
```

## Why it matters

Understanding dependency injection is important senior-level knowledge because it's a **key pattern for testable, maintainable Android architecture**, and Hilt is the recommended framework, so it's valuable for quality Android development.

The core concept — objects **receiving their dependencies from outside** rather than creating them — provides significant benefits: most importantly **testability** (you can inject mocks or fakes in tests, enabling isolated unit testing — the major benefit, since classes that create their own dependencies are hard to test), plus **decoupling** (classes don't depend on concrete implementations), flexibility (easy to swap implementations), and centralized dependency management.

Understanding **Hilt** (the recommended Android DI framework, built on Dagger) — how it automatically creates, provides, and scopes dependencies, reducing the manual wiring boilerplate — is the practical knowledge for implementing DI in modern Android.

Understanding **why DI matters for architecture** is the key insight: it works hand-in-hand with patterns like MVVM (injecting repositories into ViewModels, data sources into repositories) to create **clean, decoupled, testable layers** — making DI essential to building the well-architected, testable apps that recommended Android architecture aims for.

Proper **scoping** (managing dependency lifecycles) and the reduced boilerplate (vs manual DI) make Hilt practical.

DI is a cornerstone of professional Android architecture because it enables the testability and decoupling that maintainable apps require.

Since DI is a key pattern for testable, maintainable architecture (its testability benefit being central to good Android development) and Hilt is the recommended framework that makes it practical, and since understanding DI and Hilt is important for building well-architected, testable apps, understanding dependency injection in Android is important senior-level knowledge — a cornerstone of professional Android architecture that enables testability and decoupling, working with patterns like MVVM to build maintainable apps, and reflecting the architectural sophistication expected for senior Android roles.