Usar o Hilt com outras bibliotecas do Jetpack

O Hilt inclui extensões para fornecer classes de outras bibliotecas do Jetpack. Atualmente, o Hilt oferece suporte aos seguintes componentes do Jetpack:

• ViewModel
• Navegação
• Compose
• WorkManager

É preciso adicionar as dependências do Hilt para aproveitar essas integrações. Para ver mais informações sobre como adicionar dependências, consulte Injeção de dependências com o Hilt.

Injetar objetos ViewModel com o Hilt

Forneça um objeto ViewModel anotando com @HiltViewModel e usando a anotação @Inject no construtor do objeto ViewModel.

@HiltViewModel
class ExampleViewModel @Inject constructor(
  private val savedStateHandle: SavedStateHandle,
  private val repository: ExampleRepository
) : ViewModel() {
  ...
}

@HiltViewModel
public class ExampleViewModel extends ViewModel {

  private final ExampleRepository repository;
  private final SavedStateHandle savedStateHandle;

  @Inject
  ExampleViewModel(
      SavedStateHandle savedStateHandle,
      ExampleRepository repository)
    {
    this.savedStateHandle = savedStateHandle;
    this.repository = repository;
  }
  ...
}

Em seguida, uma atividade ou um fragmento anotado com @AndroidEntryPoint pode receber a instância ViewModel normalmente usando ViewModelProvider ou as extensões KTX by viewModels():

@AndroidEntryPoint
class ExampleActivity : AppCompatActivity() {
  private val exampleViewModel: ExampleViewModel by viewModels()
  ...
}

@AndroidEntryPoint
public class ExampleActivity extends AppCompatActivity {

  private ExampleViewModel exampleViewModel;

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    exampleViewModel = new ViewModelProvider(this).get(ExampleViewModel.class);
  }
  ...
}

@ViewModelScoped

Todos os ViewModels do Hilt são fornecidos pelo ViewModelComponent, que segue o mesmo ciclo de vida de um ViewModel. Por isso, ele pode sobreviver às mudanças de configuração. Para definir o escopo de uma dependência para um ViewModel, use a anotação @ViewModelScoped.

Um tipo @ViewModelScoped vai fazer com que uma única instância do tipo com escopo seja fornecida em todas as dependências injetadas no ViewModel. Outras instâncias de um ViewModel que solicitam a instância com escopo vão receber uma instância diferente.

Se uma única instância tiver que ser compartilhada entre vários ViewModels, ela vai precisar ter o escopo definido usando @ActivityRetainedScoped ou @Singleton.

Integração com a biblioteca de navegação do Jetpack

Adicione estas outras dependências ao arquivo do Gradle:

app/build.gradle

dependencies {
    ...
    implementation 'androidx.hilt:hilt-navigation-fragment:1.0.0'
}

dependencies {
    ...
    implementation("androidx.hilt:hilt-navigation-fragment:1.0.0")
}

Se o ViewModel estiver com escopo definido para o gráfico de navegação, use a função hiltNavGraphViewModels que funciona com fragmentos que têm a anotação @AndroidEntryPoint.

val viewModel: ExampleViewModel by hiltNavGraphViewModels(R.id.my_graph)

NavBackStackEntry backStackEntry = navController.getBackStackEntry(R.id.my_graph);

ExampleViewModel exampleViewModel = new ViewModelProvider(
  backStackEntry,
  HiltViewModelFactory.create(context, backStackEntry)
).get(ExampleViewModel.class)

Integração com o Jetpack Compose

Para ver como o Hilt se integra ao Jetpack Compose, consulte a seção Compose e outras bibliotecas.

Injetar WorkManager com o Hilt

Adicione as seguintes dependências a mais ao arquivo do Gradle. Além da biblioteca, você precisa incluir outro processador de anotações que funcione sobre o processador Hilt:

app/build.gradle

dependencies {
  ...
  implementation 'androidx.hilt:hilt-work:1.0.0'
  // When using Kotlin.
  kapt 'androidx.hilt:hilt-compiler:1.0.0'
  // When using Java.
  annotationProcessor 'androidx.hilt:hilt-compiler:1.0.0'
}

dependencies {
    implementation("androidx.hilt:hilt-work:1.0.0")
    // When using Kotlin.
    kapt("androidx.hilt:hilt-compiler:1.0.0")
    // When using Java.
    annotationProcessor("androidx.hilt:hilt-compiler:1.0.0")
}

Injete um Worker usando a anotação @HiltWorker na classe e @AssistedInject no construtor do objeto Worker. Só é possível usar @Singleton ou vinculações sem escopo em objetos Worker. Também é necessário anotar as dependências Context e WorkerParameters com @Assisted:

@HiltWorker
class ExampleWorker @AssistedInject constructor(
  @Assisted appContext: Context,
  @Assisted workerParams: WorkerParameters,
  workerDependency: WorkerDependency
) : Worker(appContext, workerParams) { ... }

@HiltWorker
public class ExampleWorker extends Worker {

  private final WorkerDependency workerDependency;

  @AssistedInject
  ExampleWorker(
    @Assisted @NonNull Context context,
    @Assisted @NonNull WorkerParameters params,
    WorkerDependency workerDependency
  ) {
    super(context, params);
    this.workerDependency = workerDependency;
  }
  ...
}

Em seguida, faça com que a classe Application implemente a interface Configuration.Provider, injete uma instância de HiltWorkFactory e a transmita para a configuração WorkManager, da seguinte maneira:

@HiltAndroidApp
class ExampleApplication : Application(), Configuration.Provider {

  @Inject lateinit var workerFactory: HiltWorkerFactory

  override fun getWorkManagerConfiguration() =
      Configuration.Builder()
            .setWorkerFactory(workerFactory)
            .build()
}

@HiltAndroidApp
public class ExampleApplication extends Application implements Configuration.Provider {

  @Inject HiltWorkerFactory workerFactory;

  @Override
  public Configuration getWorkManagerConfiguration() {
    return new Configuration.Builder()
             .setWorkerFactory(workerFactory)
             .build();
  }
}