Android Academy · Aula

Injeção de dependências com Hilt

Simplifique o gerenciamento de dependências com Hilt. Use @HiltAndroidApp, @AndroidEntryPoint, @HiltViewModel, @Module, @Provides e escopos @Singleton.

Injeção de dependências com Hilt é uma aula grátis de Android Academy no CoddyKit. Esta é a aula 6 de 6. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Android Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Android Academy inclui 6 aulas no total.

O que é injeção de dependências?

Injeção de dependências (DI) significa fornecer a um objeto aquilo de que ele precisa, em vez de fazer com que ele crie as próprias dependências.

Sem DI, uma classe cria as próprias dependências — fica fortemente acoplada e difícil de testar. Com DI, as dependências são injetadas de fora — o acoplamento é reduzido, e fica fácil testar e substituir componentes.

DI manual versus Hilt

A DI manual funciona, mas se torna difícil de manter em projetos grandes:

// 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()

Adicionando o Hilt

Adicione o Hilt ao seu projeto:

// 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

Adicione a anotação @HiltAndroidApp à sua classe Application. Esse é o ponto de entrada da hierarquia de componentes do Hilt:

@HiltAndroidApp
class MyApp : Application()

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

@AndroidEntryPoint

Adicione @AndroidEntryPoint às Activities, aos Fragments e aos Services que precisam de dependências injetadas:

@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 — injeção pelo construtor

Marque o construtor com @Inject para informar ao Hilt como criar a classe. O Hilt resolve automaticamente todos os parâmetros:

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

Adicione a anotação @HiltViewModel ao seu ViewModel e use @Inject constructor. No Fragment, obtenha-o com 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 e @Provides

Quando o Hilt não pode usar a injeção pelo construtor (por exemplo, com interfaces e classes de terceiros), forneça instâncias por meio de um @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 — vinculação de interface

Use @Binds para informar ao Hilt qual implementação deve ser usada para uma 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
}

Escopos do Hilt

Os escopos controlam por quanto tempo uma instância injetada permanece ativa:

@Singleton — uma instância durante todo o ciclo de vida do aplicativo (ApplicationComponent)
@ActivityRetainedScoped — sobrevive a mudanças de configuração
@ActivityScoped — uma instância por Activity
@FragmentScoped — uma instância por Fragment
@ViewModelScoped — uma instância por ViewModel

Testes com Hilt

Substitua dependências reais por objetos falsos nos testes usando o suporte de testes do 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)
    }
}

Verificação rápida

Qual anotação instrui o Hilt a gerar a hierarquia de componentes de DI para todo o aplicativo?

Recapitulação: injeção de dependências com Hilt

O Hilt torna a DI quase automática no Android:

@HiltAndroidApp na classe Application
@AndroidEntryPoint em Activities e Fragments
@Inject constructor para classes que podem receber injeção
@HiltViewModel + @Inject constructor para ViewModels
@Module + @Provides para classes e interfaces de terceiros
@Singleton para compartilhar uma instância em todo o aplicativo

A seguir: notificações push com o Firebase Cloud Messaging.

Perguntas Frequentes

A aula “Injeção de dependências com Hilt” é grátis?

Sim — o texto completo de “Injeção de dependências com Hilt” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Android Academy, atualize para CoddyKit PRO. O curso de Android Academy inclui 6 aulas no total.

O que vou aprender em “Injeção de dependências com Hilt”?

Simplifique o gerenciamento de dependências com Hilt. Use @HiltAndroidApp, @AndroidEntryPoint, @HiltViewModel, @Module, @Provides e escopos @Singleton. Você pratica Android Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Android Academy?

Nenhuma experiência prévia é necessária. Android Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 6 de 6.

Quanto tempo leva a aula “Injeção de dependências com Hilt”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Android Academy?

Sim. Cada aula de Android Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Android Academy