Hilt mit anderen Jetpack-Bibliotheken verwenden

Hilt enthält Erweiterungen zur Bereitstellung von Klassen aus anderen Jetpack-Bibliotheken. Hilt unterstützt derzeit die folgenden Jetpack-Komponenten:

• ViewModel
• Navigation
• Schreiben
• WorkManager

Sie müssen die Hilt-Abhängigkeiten hinzufügen, um diese Integrationen nutzen zu können. Weitere Informationen zum Hinzufügen von Abhängigkeiten finden Sie unter Abhängigkeitsinjektion mit Zugriff.

ViewModel-Objekte mit Hilt einfügen

Geben Sie einen ViewModel an, indem Sie ihn mit @HiltViewModel annotieren und die Annotation @Inject im Konstruktor des ViewModel-Objekts verwenden.

@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;
  }
  ...
}

Anschließend kann eine Aktivität oder ein Fragment, die mit @AndroidEntryPoint annotiert ist, wie gewohnt die ViewModel-Instanz mithilfe von ViewModelProvider oder der KTX-Erweiterung by viewModels() abrufen:

@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.

Alle Hilt-ViewModels werden vom ViewModelComponent bereitgestellt, das denselben Lebenszyklus wie ein ViewModel hat und daher Konfigurationsänderungen beibehalten kann. Verwenden Sie die Annotation @ViewModelScoped, um eine Abhängigkeit auf einen ViewModel zu beschränken.

Der Typ @ViewModelScoped sorgt dafür, dass eine einzelne Instanz des Bereichs des Typs für alle Abhängigkeiten bereitgestellt wird, die in die ViewModel eingefügt werden. Andere Instanzen einer ViewModel, die die auf einen Bereich reduzierte Instanz anfordern, erhalten eine andere Instanz.

Wenn eine einzelne Instanz für verschiedene ViewModels freigegeben werden muss, sollte sie entweder mit @ActivityRetainedScoped oder @Singleton klassifiziert werden.

Einbindung in die Jetpack-Navigationsbibliothek

Fügen Sie Ihrer Gradle-Datei die folgenden zusätzlichen Abhängigkeiten hinzu:

app/build.gradle

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

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

Wenn sich das ViewModel auf das Navigationsdiagramm bezieht, verwenden Sie die Funktion hiltNavGraphViewModels. Sie funktioniert mit Fragmenten, die mit @AndroidEntryPoint annotiert sind.

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)

Einbindung in Jetpack Compose

Informationen zur Einbindung von Hilt in Jetpack Compose finden Sie im Abschnitt „Hilt“ von Compose und anderen Bibliotheken.

WorkManager mit Hilt einfügen

Fügen Sie Ihrer Gradle-Datei die folgenden zusätzlichen Abhängigkeiten hinzu. Zusätzlich zur Bibliothek müssen Sie einen zusätzlichen Annotationsprozessor hinzufügen, der auf dem Hilt-Annotations-Prozessor basiert:

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")
}

Injizieren Sie ein Worker mit der Annotation @HiltWorker in der Klasse und mit @AssistedInject im Konstruktor des Worker-Objekts. Sie können in Worker-Objekten nur @Singleton oder Bindungen ohne Bereichs verwenden. Außerdem müssen Sie die Abhängigkeiten von Context und WorkerParameters mit @Assisted annotieren:

@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;
  }
  ...
}

Anschließend muss Ihre Application-Klasse die Configuration.Provider-Schnittstelle implementieren, eine Instanz von HiltWorkFactory einschleusen und sie so an die WorkManager-Konfiguration übergeben:

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