ViewModels mit Abhängigkeiten erstellen Teil von Android Jetpack
Gemäß den Best Practices für die Abhängigkeitsinjektion kann ViewModels Abhängigkeiten als Parameter in seinem Konstruktor verwenden. Meistens handelt es sich dabei um Typen aus der Domain- oder der Datenschicht. Da das Framework die ViewModels bereitstellt, ist ein spezieller Mechanismus erforderlich, um Instanzen dieser Modelle zu erstellen. Dies ist die ViewModelProvider.Factory
-Schnittstelle. Nur Implementierungen dieser Schnittstelle können ViewModels im richtigen Bereich instanziieren.
ViewModels mit CreationExtras
Wenn eine ViewModel-Klasse Abhängigkeiten in ihrem Konstruktor empfängt, geben Sie eine Factory an, die die ViewModelProvider.Factory
-Schnittstelle implementiert. Überschreiben Sie die Funktion create(Class<T>, CreationExtras)
, um eine neue Instanz von ViewModel bereitzustellen.
CreationExtras
ermöglicht den Zugriff auf relevante Informationen, die bei der Instanziierung eines ViewModel helfen. Hier ist eine Liste der Schlüssel, auf die über Extras zugegriffen werden kann:
Schlüssel | Funktionalität |
---|---|
ViewModelProvider.NewInstanceFactory.VIEW_MODEL_KEY |
Bietet Zugriff auf den benutzerdefinierten Schlüssel, den Sie an ViewModelProvider.get() übergeben haben. |
ViewModelProvider.AndroidViewModelFactory.APPLICATION_KEY |
Bietet Zugriff auf die Instanz der Application -Klasse. |
SavedStateHandleSupport.DEFAULT_ARGS_KEY |
Bietet Zugriff auf das Argument-Bundle, das Sie zum Erstellen von SavedStateHandle verwenden sollten. |
SavedStateHandleSupport.SAVED_STATE_REGISTRY_OWNER_KEY |
Bietet Zugriff auf das SavedStateRegistryOwner , das zum Erstellen des ViewModel verwendet wird. |
SavedStateHandleSupport.VIEW_MODEL_STORE_OWNER_KEY |
Bietet Zugriff auf das ViewModelStoreOwner , das zum Erstellen des ViewModel verwendet wird. |
Verwenden Sie zum Erstellen einer neuen Instanz von SavedStateHandle
die Funktion CreationExtras.createSavedStateHandle()
.createSavedStateHandle() und übergeben Sie sie an ViewModel.
Das folgende Beispiel zeigt, wie Sie eine Instanz einer ViewModel-Instanz bereitstellen, die ein Repository der Klasse Application
und SavedStateHandle
als Abhängigkeiten verwendet:
Kotlin
import androidx.lifecycle.SavedStateHandle
import androidx.lifecycle.ViewModel
import androidx.lifecycle.ViewModelProvider
import androidx.lifecycle.ViewModelProvider.AndroidViewModelFactory.Companion.APPLICATION_KEY
import androidx.lifecycle.createSavedStateHandle
import androidx.lifecycle.viewmodel.CreationExtras
class MyViewModel(
private val myRepository: MyRepository,
private val savedStateHandle: SavedStateHandle
) : ViewModel() {
// ViewModel logic
// ...
// Define ViewModel factory in a companion object
companion object {
val Factory: ViewModelProvider.Factory = object : ViewModelProvider.Factory {
@Suppress("UNCHECKED_CAST")
override fun <T : ViewModel> create(
modelClass: Class<T>,
extras: CreationExtras
): T {
// Get the Application object from extras
val application = checkNotNull(extras[APPLICATION_KEY])
// Create a SavedStateHandle for this ViewModel from extras
val savedStateHandle = extras.createSavedStateHandle()
return MyViewModel(
(application as MyApplication).myRepository,
savedStateHandle
) as T
}
}
}
}
Java
import static androidx.lifecycle.SavedStateHandleSupport.createSavedStateHandle;
import static androidx.lifecycle.ViewModelProvider.AndroidViewModelFactory.APPLICATION_KEY;
import androidx.lifecycle.SavedStateHandle;
import androidx.lifecycle.ViewModel;
import androidx.lifecycle.viewmodel.ViewModelInitializer;
public class MyViewModel extends ViewModel {
public MyViewModel(
MyRepository myRepository,
SavedStateHandle savedStateHandle
) { /* Init ViewModel here */ }
static final ViewModelInitializer<MyViewModel> initializer = new ViewModelInitializer<>(
MyViewModel.class,
creationExtras -> {
MyApplication app = (MyApplication) creationExtras.get(APPLICATION_KEY);
assert app != null;
SavedStateHandle savedStateHandle = createSavedStateHandle(creationExtras);
return new MyViewModel(app.getMyRepository(), savedStateHandle);
}
);
}
Anschließend können Sie diese Factory beim Abrufen einer Instanz von ViewModel verwenden:
Kotlin
import androidx.activity.viewModels
class MyActivity : AppCompatActivity() {
private val viewModel: MyViewModel by viewModels { MyViewModel.Factory }
// Rest of Activity code
}
Java
import androidx.appcompat.app.AppCompatActivity;
import androidx.lifecycle.ViewModelProvider;
public class MyActivity extends AppCompatActivity {
MyViewModel myViewModel = new ViewModelProvider(
this,
ViewModelProvider.Factory.from(MyViewModel.initializer)
).get(MyViewModel.class);
// Rest of Activity code
}
Jetpack Compose
import androidx.lifecycle.viewmodel.compose.viewModel
@Composable
fun MyScreen(
modifier: Modifier = Modifier,
viewModel: MyViewModel = viewModel(factory = MyViewModel.Factory)
) {
// ...
}
Alternativ können Sie die ViewModel Factory DSL verwenden, um Fabriken mit einer idiomatischeren Kotlin API zu erstellen:
import androidx.lifecycle.SavedStateHandle
import androidx.lifecycle.ViewModel
import androidx.lifecycle.ViewModelProvider
import androidx.lifecycle.ViewModelProvider.AndroidViewModelFactory.Companion.APPLICATION_KEY
import androidx.lifecycle.createSavedStateHandle
import androidx.lifecycle.viewmodel.initializer
import androidx.lifecycle.viewmodel.viewModelFactory
class MyViewModel(
private val myRepository: MyRepository,
private val savedStateHandle: SavedStateHandle
) : ViewModel() {
// ViewModel logic
// Define ViewModel factory in a companion object
companion object {
val Factory: ViewModelProvider.Factory = viewModelFactory {
initializer {
val savedStateHandle = createSavedStateHandle()
val myRepository = (this[APPLICATION_KEY] as MyApplication).myRepository
MyViewModel(
myRepository = myRepository,
savedStateHandle = savedStateHandle
)
}
}
}
}
Fabriken für ViewModel-Version, die älter als 2.5.0 ist
Wenn Sie eine ältere ViewModel-Version als 2.5.0 verwenden, müssen Sie Fabriken aus einer Teilmenge von Klassen bereitstellen, die ViewModelProvider.Factory
erweitern, und die Funktion create(Class<T>)
implementieren. Abhängig von den Abhängigkeiten, die ViewModel benötigt, muss eine andere Klasse erweitert werden:
AndroidViewModelFactory
, wenn die KlasseApplication
benötigt wird.AbstractSavedStateViewModelFactory
, wennSavedStateHandle
als Abhängigkeit übergeben werden muss.
Wenn Application
oder SavedStateHandle
nicht benötigt werden, erweitern Sie sie einfach von ViewModelProvider.Factory
.
Im folgenden Beispiel wird ein AbstractSavedStateViewModelFactory
für eine ViewModel verwendet, die ein Repository und einen SavedStateHandle
-Typ als Abhängigkeit verwendet:
Kotlin
class MyViewModel(
private val myRepository: MyRepository,
private val savedStateHandle: SavedStateHandle
) : ViewModel() {
// ViewModel logic ...
// Define ViewModel factory in a companion object
companion object {
fun provideFactory(
myRepository: MyRepository,
owner: SavedStateRegistryOwner,
defaultArgs: Bundle? = null,
): AbstractSavedStateViewModelFactory =
object : AbstractSavedStateViewModelFactory(owner, defaultArgs) {
@Suppress("UNCHECKED_CAST")
override fun <T : ViewModel> create(
key: String,
modelClass: Class<T>,
handle: SavedStateHandle
): T {
return MyViewModel(myRepository, handle) as T
}
}
}
}
Java
import androidx.annotation.NonNull;
import androidx.lifecycle.AbstractSavedStateViewModelFactory;
import androidx.lifecycle.SavedStateHandle;
import androidx.lifecycle.ViewModel;
public class MyViewModel extends ViewModel {
public MyViewModel(
MyRepository myRepository,
SavedStateHandle savedStateHandle
) { /* Init ViewModel here */ }
}
public class MyViewModelFactory extends AbstractSavedStateViewModelFactory {
private final MyRepository myRepository;
public MyViewModelFactory(
MyRepository myRepository
) {
this.myRepository = myRepository;
}
@SuppressWarnings("unchecked")
@NonNull
@Override
protected <T extends ViewModel> T create(
@NonNull String key, @NonNull Class<T> modelClass, @NonNull SavedStateHandle handle
) {
return (T) new MyViewModel(myRepository, handle);
}
}
Anschließend können Sie Ihre ViewModel mithilfe der Factory abrufen:
Kotlin
import androidx.activity.viewModels
class MyActivity : AppCompatActivity() {
private val viewModel: MyViewModel by viewModels {
MyViewModel.provideFactory((application as MyApplication).myRepository, this)
}
// Rest of Activity code
}
Java
import androidx.appcompat.app.AppCompatActivity;
import androidx.lifecycle.ViewModelProvider;
public class MyActivity extends AppCompatActivity {
MyViewModel myViewModel = new ViewModelProvider(
this,
ViewModelProvider.Factory.from(MyViewModel.initializer)
).get(MyViewModel.class);
// Rest of Activity code
}
Jetpack Compose
import androidx.lifecycle.viewmodel.compose.viewModel
@Composable
fun MyScreen(
modifier: Modifier = Modifier,
viewModel: MyViewModel = viewModel(
factory = MyViewModel.provideFactory(
(LocalContext.current.applicationContext as MyApplication).myRepository,
owner = LocalSavedStateRegistryOwner.current
)
)
) {
// ...
}
Empfehlungen für dich
- Hinweis: Der Linktext wird angezeigt, wenn JavaScript deaktiviert ist.
- Modul „Gespeicherter Status“ für ViewModel
- UI-Zustände speichern
- LiveData – Übersicht