Ce este injectarea dependențelor în Android (Hilt, Dagger)?

Question

Accepted Answer

**Injectarea dependențelor (DI)** este un pattern în care obiectele primesc dependențele lor din exterior în loc să le creeze — îmbunătățind testabilitatea, mentenabilitatea și flexibilitatea. În Android, **Hilt** (construit pe Dagger) este framework-ul DI recomandat.

## Ce este DI și de ce contează

```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 — framework-ul Android DI recomandat

```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 se ocupă de crearea și furnizarea dependențelor (cu scoping/cicluri de viață corespunzătoare), reducând boilerplate-ul manual de conectare.

## De ce DI contează pentru arhitectură

```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)
```

## De ce contează

Înțelegerea injectării dependențelor este o cunoaștere importantă la nivel senior, deoarece este un **pattern cheie pentru arhitectura Android testabilă și ușor de întreținut**, iar Hilt este framework-ul recomandat, deci este valoroasă pentru dezvoltarea Android de calitate.

Conceptul fundamental — obiectele **primesc dependențele lor din exterior** în loc să le creeze — oferă beneficii semnificative: cel mai important este **testabilitatea** (puteți injecta mock-uri sau falsuri în teste, permițând testarea unitară izolată — beneficiul major, deoarece clasele care-și creează propriile dependențe sunt greu de testat), plus **decuplarea** (clasele nu depind de implementări concrete), flexibilitate (ușor de schimbat implementări) și gestionare centralizată a dependențelor.

Înțelegerea **Hilt** (framework-ul Android DI recomandat, construit pe Dagger) — cum creează, furnizează și scoping-ează automat dependențele, reducând boilerplate-ul manual de conectare — este cunoașterea practică pentru implementarea DI în Android modern.

Înțelegerea **de ce DI contează pentru arhitectură** este insight-ul cheie: funcționează mână-n mână cu pattern-uri precum MVVM (injectând repository-uri în ViewModels, surse de date în repository-uri) pentru a crea **straturi curate, decuplate, testabile** — făcând DI esențial pentru construirea aplicațiilor bine-arhitectate și testabile pe care arhitectura Android recomandată o urmărește.

Scoping-ul corespunzător (gestionarea ciclului de viață al dependențelor) și boilerplate-ul redus (versus DI manual) fac Hilt practic.

DI este o piatră de temelie a arhitecturii profesionale Android, deoarece permite testabilitatea și decuplarea pe care aplicațiile mentenabile o necesită.

Deoarece DI este un pattern cheie pentru arhitectura testabilă și ușor de întreținut (beneficiul său de testabilitate fiind central pentru buna dezvoltare Android) și Hilt este framework-ul recomandat care o face practică, și deoarece înțelegerea DI și Hilt este importantă pentru construirea aplicațiilor bine-arhitectate și testabile, înțelegerea injectării dependențelor în Android este o cunoaștere importantă la nivel senior — o piatră de temelie a arhitecturii profesionale Android care permite testabilitatea și decuplarea, funcționând cu pattern-uri precum MVVM pentru a construi aplicații mentenabile, și reflectând sofisticația arhitecturală așteptată pentru rolurile Android senior.