Android Academy · Leçon

Injection de dépendances avec Hilt

Simplifiez la gestion des dépendances avec Hilt. Utilisez @HiltAndroidApp, @AndroidEntryPoint, @HiltViewModel, @Module, @Provides et les portées @Singleton.

Leçon 6 sur 613 étapes

Injection de dépendances avec Hilt est une leçon Android Academy gratuite sur CoddyKit. Ceci est la leçon 6 sur 6. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Android Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Android Academy comprend 6 leçons au total.

Qu'est-ce que l'injection de dépendances ?

L'injection de dépendances (DI) consiste à fournir à un objet ce dont il a besoin, plutôt qu'à lui faire créer lui-même ses dépendances.

Sans DI, une classe crée ses propres dépendances : le couplage est fort et les tests sont difficiles. Avec la DI, les dépendances sont injectées depuis l'extérieur : le couplage est faible, et il est facile de tester et de remplacer les dépendances.

DI manuelle ou Hilt

La DI manuelle fonctionne, mais devient pénible lorsque le projet prend de l'ampleur :

// Manual DI — you create and pass everything:
val db = AppDatabase.getInstance(context)
val dao = db.userDao()
val repo = UserRepository(dao)
val factory = UserViewModel.Factory(repo)
val viewModel = ViewModelProvider(this, factory)[UserViewModel::class.java]

// With Hilt:
// Just annotate, Hilt does the wiring
@HiltViewModel
class UserViewModel @Inject constructor(private val repo: UserRepository) : ViewModel()

Ajouter Hilt

Ajoutez Hilt à votre projet :

// project/build.gradle:
buildscript {
    dependencies {
        classpath 'com.google.dagger:hilt-android-gradle-plugin:2.51'
    }
}

// app/build.gradle:
plugins {
    id 'com.google.dagger.hilt.android'
    id 'kotlin-kapt'
}

dependencies {
    implementation 'com.google.dagger:hilt-android:2.51'
    kapt 'com.google.dagger:hilt-android-compiler:2.51'
}

@HiltAndroidApp

Annotez votre classe Application avec @HiltAndroidApp. Il s'agit du point d'entrée de la hiérarchie des composants Hilt :

@HiltAndroidApp
class MyApp : Application()

// Also register in AndroidManifest.xml:
// <application android:name=".MyApp" ...>

@AndroidEntryPoint

Ajoutez @AndroidEntryPoint aux activités, fragments et services qui ont besoin de dépendances injectées :

@AndroidEntryPoint
class MainActivity : AppCompatActivity() {

    @Inject lateinit var analytics: AnalyticsService

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        analytics.logEvent("app_open")
    }
}

@AndroidEntryPoint
class HomeFragment : Fragment() {
    // Fragment's parent Activity must also be @AndroidEntryPoint
}

@Inject — injection par constructeur

Marquez le constructeur avec @Inject pour indiquer à Hilt comment créer la classe. Hilt résout automatiquement tous les paramètres :

class UserRepository @Inject constructor(
    private val userDao: UserDao,
    private val apiService: ApiService
) {
    suspend fun getUsers() = userDao.getAll()
    suspend fun syncFromNetwork() {
        val users = apiService.fetchUsers()
        userDao.insertAll(users)
    }
}

// Hilt sees UserRepository needs UserDao and ApiService,
// and automatically creates and injects them.

@HiltViewModel

Annotez votre ViewModel avec @HiltViewModel et utilisez @Inject constructor. Dans le Fragment, récupérez-le avec by viewModels() :

@HiltViewModel
class UserViewModel @Inject constructor(
    private val repo: UserRepository
) : ViewModel() {

    val users = repo.getUsersFlow().asLiveData()
}

// In Fragment:
@AndroidEntryPoint
class UserFragment : Fragment() {
    private val viewModel: UserViewModel by viewModels()  // Hilt provides it
}

@Module et @Provides

Lorsque Hilt ne peut pas utiliser l'injection par constructeur (par exemple pour les interfaces ou les classes tierces), fournissez les instances via un @Module :

@Module
@InstallIn(SingletonComponent::class)   // lives for app lifetime
object NetworkModule {

    @Provides
    @Singleton
    fun provideRetrofit(): Retrofit {
        return Retrofit.Builder()
            .baseUrl("https://api.example.com/")
            .addConverterFactory(GsonConverterFactory.create())
            .build()
    }

    @Provides
    @Singleton
    fun provideApiService(retrofit: Retrofit): ApiService {
        return retrofit.create(ApiService::class.java)
    }
}

@Binds — liaison d'interface

Utilisez @Binds pour indiquer à Hilt quelle implémentation utiliser pour une interface :

interface AnalyticsService {
    fun logEvent(name: String)
}

class FirebaseAnalytics @Inject constructor() : AnalyticsService {
    override fun logEvent(name: String) { /* Firebase impl */ }
}

@Module
@InstallIn(SingletonComponent::class)
abstract class AnalyticsModule {

    @Binds
    @Singleton
    abstract fun bindAnalytics(impl: FirebaseAnalytics): AnalyticsService
}

Étendues Hilt

Les étendues contrôlent la durée de vie d'une instance injectée :

@Singleton — une seule instance pendant toute la durée de vie de l'application (ApplicationComponent)
@ActivityRetainedScoped — survit aux changements de configuration
@ActivityScoped — une instance par activité
@FragmentScoped — une instance par fragment
@ViewModelScoped — une instance par ViewModel

Tests avec Hilt

Remplacez les dépendances réelles par des fausses dépendances dans les tests grâce à la prise en charge des tests par Hilt :

@HiltAndroidTest
class UserRepositoryTest {

    @get:Rule
    val hiltRule = HiltAndroidRule(this)

    @Inject
    lateinit var repo: UserRepository

    @Before
    fun setUp() {
        hiltRule.inject()
    }

    @Test
    fun usersAreFetched() {
        assertNotNull(repo)
    }
}

Vérification rapide

Quelle annotation indique à Hilt de générer la hiérarchie des composants DI pour toute votre application ?

Réponds-y dans la leçon interactive

Récapitulatif : injection de dépendances avec Hilt

Hilt rend la DI presque automatique dans Android :

@HiltAndroidApp sur votre classe Application
@AndroidEntryPoint sur les activités et les fragments
@Inject constructor pour les classes injectables
@HiltViewModel + @Inject constructor pour les ViewModels
@Module + @Provides pour les classes tierces et les interfaces
@Singleton pour partager une instance dans toute l'application

Ensuite : les notifications push avec Firebase Cloud Messaging.

Gratuit pour commencer

Apprends Kotlin avec un tuteur IA — gratuit

Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.

Cours: 36
Leçons: 152

Commencer gratuitement Voir le cours complet

Questions Fréquemment Posées

La leçon « Injection de dépendances avec Hilt » est-elle gratuite ?

Oui — le texte complet de « Injection de dépendances avec Hilt » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Android Academy, passe à CoddyKit PRO. Le cours Android Academy comprend 6 leçons au total.

Qu'est-ce que j'apprendrai dans « Injection de dépendances avec Hilt » ?

Simplifiez la gestion des dépendances avec Hilt. Utilisez @HiltAndroidApp, @AndroidEntryPoint, @HiltViewModel, @Module, @Provides et les portées @Singleton. Tu pratiques Android Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Android Academy ?

Aucune expérience préalable n'est requise. Android Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 6 sur 6.

Combien de temps prend la leçon « Injection de dépendances avec Hilt » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Android Academy ?

Oui. Chaque leçon Android Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Android Academy