Hilt mit anderen Jetpack-Bibliotheken verwenden

Hilt enthält Erweiterungen, mit denen Klassen aus anderen Jetpack-Bibliotheken bereitgestellt werden können. 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. Für Weitere Informationen zum Hinzufügen von Abhängigkeiten finden Sie unter Abhängigkeitsinjektion mit Hilt.

ViewModel-Objekte mit Hilt einfügen

Geben Sie ein ViewModel an, indem Sie mit @HiltViewModel und die Annotation @Inject in der ViewModel den Konstruktor des Objekts.

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

Dann kann eine Aktivität oder ein mit @AndroidEntryPoint annotiertes Fragment Rufen Sie die ViewModel-Instanz wie gewohnt mit ViewModelProvider oder dem by viewModels() KTX-Erweiterungen:

@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 von der ViewModelComponent bereitgestellt, die den denselben Lebenszyklus wie eine ViewModel und können daher auch Konfigurationsänderungen überleben. Um eine Abhängigkeit auf eine ViewModel festzulegen, verwenden Sie die Annotation @ViewModelScoped.

Der Typ @ViewModelScoped sorgt dafür, dass eine einzelne Instanz des wird für alle in ViewModel eingefügten Abhängigkeiten bereitgestellt. Andere Instanzen einer ViewModel, die die beschränkte Instanz anfordern, erhalten in eine andere Instanz.

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

Integration 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 Ihre ViewModel auf die Navigation beschränkt ist Grafik hiltNavGraphViewModels-Funktion verwenden, die mit Fragmenten funktioniert, kommentiert mit @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)

Jetpack Compose einbinden

Informationen zur Integration von Hilt in Jetpack Compose finden Sie im Abschnitt "Hilt" des Composer und andere Bibliotheken:

WorkManager mit Hilt einfügen

Fügen Sie Ihrer Gradle-Datei die folgenden zusätzlichen Abhängigkeiten hinzu. Beachten Sie, dass in Neben der Bibliothek müssen Sie einen zusätzlichen Annotationsprozessor der auf dem Hilt-Annotationsprozessor 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 mithilfe der @HiltWorker-Annotation in der Klasse und @AssistedInject in der Worker den Konstruktor des Objekts. Sie können nur @Singleton oder Bindungen ohne Geltungsbereich in Worker-Objekte. Sie müssen außerdem die Context und WorkerParameters annotieren. Abhängigkeiten mit @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;
  }
  ...
}

Geben Sie dann Ihren Application-Kurs ein. Configuration.Provider-Schnittstelle implementieren, eine Instanz von HiltWorkFactory und übergeben Sie ihn wie folgt an die WorkManager-Konfiguration:

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