Android ਵਿੱਚ dependency injection ਕੀ ਹੈ (Hilt, Dagger)?

Question

IT Interview Practice · Accepted Answer

**Dependency injection (DI)** ਇੱਕ pattern ਹੈ ਜਿੱਥੇ objects ਆਪਣੀਆਂ dependencies ਨੂੰ ਬਾਹਰ ਤੋਂ ਪ੍ਰਾਪਤ ਕਰਦੇ ਹਨ ਬਜਾਏ ਉਨ੍ਹਾਂ ਨੂੰ ਆਪ ਬਣਾਉਣ ਦੇ — testability, maintainability, ਅਤੇ flexibility ਨੂੰ ਬਿਹਤਰ ਬਣਾਉਂਦਾ ਹੈ। Android ਵਿੱਚ, **Hilt** (Dagger ਉੱਤੇ ਬਣਿਆ ਹੋਇਆ) recommended DI framework ਹੈ।

## DI ਕੀ ਹੈ ਅਤੇ ਕਿਉਂ

```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 — 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 dependencies ਬਣਾਉਣ ਅਤੇ ਪ੍ਰਦਾਨ ਕਰਨ ਦੀ ਕਾਰਜ ਸੰਭਾਲਦਾ ਹੈ (proper scoping/lifecycles ਦੇ ਨਾਲ), manual wiring boilerplate ਨੂੰ ਘਟਾਉਂਦਾ ਹੈ।

## ਕਿਉਂ DI 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)
```

## ਇਹ ਮਾਇਨੇ ਰੱਖਦਾ ਹੈ

Dependency injection ਨੂੰ ਸਮਝਣਾ senior-level ਜ੍ਞਾਨ ਹੈ ਕਿਉਂਕਿ ਇਹ **testable, maintainable Android architecture ਲਈ ਇੱਕ ਮੁੱਖ pattern ਹੈ**, ਅਤੇ Hilt recommended framework ਹੈ, ਇਸ ਲਈ ਇਹ quality Android development ਲਈ ਮੁੱਲਵਾਨ ਹੈ।

Core concept — objects **ਆਪਣੀਆਂ dependencies ਬਾਹਰ ਤੋਂ ਪ੍ਰਾਪਤ ਕਰਦੇ ਹਨ** ਬਜਾਏ ਉਨ੍ਹਾਂ ਨੂੰ ਆਪ ਬਣਾਉਣ ਦੇ — ਮਹੱਤਵਪੂਰਨ ਲਾਭ ਫਰਾਹਮ ਕਰਦਾ ਹੈ: ਸਭ ਤੋਂ ਮਹੱਤਵਪੂਰਨ **testability** (ਤੁਸੀਂ tests ਵਿੱਚ mocks ਜਾਂ fakes inject ਕਰ ਸਕਦੇ ਹੋ, isolated unit testing ਨੂੰ ਸਮਰੱਥ ਬਣਾਉਂਦਾ ਹੈ — ਮੁੱਖ ਲਾਭ, ਕਿਉਂਕਿ classes ਜੋ ਆਪਣੀਆਂ dependencies ਬਣਾਉਂਦੀਆਂ ਹਨ test ਕਰਨਾ ਮੁਸ਼ਕਲ ਹੈ), ਨਾਲ ਹੀ **decoupling** (classes concrete implementations ਉੱਤੇ ਨਿਰਭਰ ਨਹੀਂ ਹਨ), flexibility (implementations ਨੂੰ ਆਸਾਨੀ ਨਾਲ ਬਦਲਣਾ), ਅਤੇ centralized dependency management।

**Hilt** (recommended Android DI framework, Dagger ਉੱਤੇ ਬਣਿਆ ਹੋਇਆ) ਨੂੰ ਸਮਝਣਾ — ਕਿ ਕਿਵੇਂ ਇਹ automatically dependencies ਬਣਾਉਂਦਾ, ਪ੍ਰਦਾਨ ਕਰਦਾ, ਅਤੇ scope ਕਰਦਾ ਹੈ, manual wiring boilerplate ਨੂੰ ਘਟਾਉਂਦਾ ਹੈ — modern Android ਵਿੱਚ DI implement ਕਰਨ ਲਈ practical ਜ੍ਞਾਨ ਹੈ।

**ਕਿਉਂ DI architecture ਲਈ ਮਾਇਨੇ ਰੱਖਦਾ ਹੈ** ਨੂੰ ਸਮਝਣਾ key insight ਹੈ: ਇਹ MVVM ਵਰਗੀਆਂ patterns ਨਾਲ ਕੰਮ ਕਰਦਾ ਹੈ (repositories ਨੂੰ ViewModels ਵਿੱਚ inject ਕਰਨਾ, data sources ਨੂੰ repositories ਵਿੱਚ) **clean, decoupled, testable layers** ਬਣਾਉਣ ਲਈ — DI ਨੂੰ well-architected, testable apps ਬਣਾਉਣ ਲਈ ਮਾਣਕ ਬਣਾਉਂਦਾ ਹੈ ਜੋ recommended Android architecture ਦਾ ਉਦੱਸ਼ ਹੈ।

Proper **scoping** (dependency lifecycles ਪ੍ਰਬੰਧਨ) ਅਤੇ reduced boilerplate (manual DI ਦੇ ਮੁਕਾਬਲੇ) Hilt ਨੂੰ practical ਬਣਾਉਂਦੇ ਹਨ।

DI professional Android architecture ਦੀ ਇੱਕ cornerstone ਹੈ ਕਿਉਂਕਿ ਇਹ testability ਅਤੇ decoupling ਨੂੰ ਸਮਰੱਥ ਬਣਾਉਂਦਾ ਹੈ ਜੋ maintainable apps ਦੀ ਲੋੜ ਹੈ।

Dependency injection Android ਵਿੱਚ senior-level ਜ੍ਞਾਨ ਹੈ ਕਿਉਂਕਿ DI testable, maintainable architecture ਲਈ ਇੱਕ ਮੁੱਖ pattern ਹੈ (ਇਸ ਦੀ testability ਲਾਭ ਚੰਗੀ Android development ਲਈ ਕੇਂਦਰੀ ਹੈ) ਅਤੇ Hilt recommended framework ਹੈ ਜੋ ਇਸ ਨੂੰ practical ਬਣਾਉਂਦਾ ਹੈ, ਅਤੇ DI ਅਤੇ Hilt ਨੂੰ ਸਮਝਣਾ well-architected, testable apps ਬਣਾਉਣ ਲਈ ਮਹੱਤਵਪੂਰਨ ਹੈ, ਤੁਹਾਡੀ ਸਮਝ professional Android architecture ਦਾ cornerstone ਹੈ ਜੋ testability ਅਤੇ decoupling ਨੂੰ ਸਮਰੱਥ ਬਣਾਉਂਦੀ ਹੈ, MVVM ਵਰਗੀਆਂ patterns ਨਾਲ maintainable apps ਬਣਾਉਂਦੀ ਹੈ, ਅਤੇ senior Android roles ਲਈ ਸਕਾਈ architectural sophistication ਨੂੰ ਦਰਸਾਉਂਦੀ ਹੈ।

DI ਕੀ ਹੈ ਅਤੇ ਕਿਉਂ

Hilt — recommended Android DI framework

ਕਿਉਂ DI architecture ਲਈ ਮਹੱਤਵਪੂਰਨ ਹੈ

ਇਹ ਮਾਇਨੇ ਰੱਖਦਾ ਹੈ

ਸੰਬੰਧਿਤ ਸਵਾਲ