Cómo usar Hilt con otras bibliotecas de Jetpack

Hilt incluye extensiones para proporcionar clases de otras bibliotecas de Jetpack. Por el momento, Hilt admite los siguientes componentes de Jetpack:

• ViewModel
• Navegación
• Compose
• WorkManager

Debes agregar las dependencias de Hilt para aprovechar estas integraciones. Para obtener más información sobre cómo agregar dependencias, consulta Inserción de dependencias con Hilt.

Cómo insertar objetos ViewModel con Hilt

Proporciona un ViewModel. Para ello, anótalo con @HiltViewModel y usa la anotación @Inject en el constructor del 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;
  }
  ...
}

Luego, una actividad o un fragmento anotado con @AndroidEntryPoint puede obtener la instancia de ViewModel de la forma habitual usando ViewModelProvider o las extensiones KTX de 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 los ViewModels de Hilt los proporciona el ViewModelComponent que sigue el mismo ciclo de vida que un ViewModel y, por lo tanto, puede conservar los cambios de configuración. Para definir el alcance de una dependencia a un ViewModel, usa la anotación @ViewModelScoped.

Un tipo @ViewModelScoped hará que se proporcione una sola instancia del tipo con alcance en todas las dependencias insertadas en ViewModel. Otras instancias de un ViewModel que soliciten la instancia con alcance recibirán una instancia diferente.

Si se debe compartir una sola instancia entre varios ViewModels, se debe definir el alcance con @ActivityRetainedScoped o @Singleton.

Integración con la biblioteca de navegación de Jetpack

Agrega las siguientes dependencias adicionales a tu archivo de Gradle:

app/build.gradle

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

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

Si tu ViewModel tiene alcance para el grafo de navegación, usa la función hiltNavGraphViewModels que funciona con fragmentos anotados con @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)

Integración con Jetpack Compose

Para ver cómo se integra Hilt con Jetpack Compose, consulta la sección de Hilt sobre Compose y otras bibliotecas.

Cómo insertar WorkManager con Hilt

Agrega las siguientes dependencias adicionales a tu archivo de Gradle. Ten en cuenta que, además de la biblioteca, debes incluir un procesador de anotaciones adicional que funcione con el procesador de anotaciones de 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")
}

Inserta un Worker con la anotación @HiltWorker en la clase y @AssistedInject en el constructor del objeto Worker. Solo puedes usar objetos @Singleton o vinculaciones sin alcance en objetos Worker. También debes anotar las dependencias Context y WorkerParameters con @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;
  }
  ...
}

Luego, haz que tu clase Application implemente la interfaz Configuration.Provider, inserta una instancia de HiltWorkFactory y pásala a la configuración WorkManager de la siguiente manera:

@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();
  }
}