ViewModels mit Abhängigkeiten erstellen Teil von Android Jetpack
Gemäß den Best Practices für dependency Injection kann ViewModels
Abhängigkeiten als Parameter in ihrem Konstruktor berücksichtigen. Dabei handelt es sich meistens um
Domain- oder Datenschicht importieren. Da das Framework die
ViewModels erstellt wurde, ist zum Erstellen von Instanzen ein spezieller Mechanismus erforderlich. Das
ist die ViewModelProvider.Factory
-Schnittstelle. Nur Implementierungen
dieser Schnittstelle kann ViewModels im richtigen Bereich instanziieren.
ViewModels mit CreationExtras
Wenn eine ViewModel-Klasse Abhängigkeiten in ihrem Konstruktor empfängt, geben Sie eine Factory an.
zur Implementierung der ViewModelProvider.Factory
-Schnittstelle. Überschreiben Sie die
create(Class<T>, CreationExtras)
-Funktion, um eine neue Instanz von
das ViewModel.
Über CreationExtras
erhalten Sie Zugriff auf relevante Informationen, die
ein ViewModel instanziieren. 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 Klasse Application . |
SavedStateHandleSupport.DEFAULT_ARGS_KEY |
Bietet Zugriff auf das Bundle von Argumenten, die Sie zum Erstellen von SavedStateHandle verwenden sollten. |
SavedStateHandleSupport.SAVED_STATE_REGISTRY_OWNER_KEY |
Bietet Zugriff auf das SavedStateRegistryOwner , das zum Erstellen von ViewModel verwendet wird. |
SavedStateHandleSupport.VIEW_MODEL_STORE_OWNER_KEY |
Bietet Zugriff auf das ViewModelStoreOwner , das zum Erstellen von ViewModel verwendet wird. |
Um eine neue Instanz von SavedStateHandle
zu erstellen, verwenden Sie den
CreationExtras.createSavedStateHandle()
.createSavedStateHandle()) zurück
und übergeben sie an ViewModel.
Im folgenden Beispiel wird gezeigt, wie Sie eine ViewModel-Instanz bereitstellen, die
verwendet ein Repository, das auf die Klasse Application
beschränkt ist, und
SavedStateHandle
als Abhängigkeiten:
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);
}
);
}
Dann 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 einem idiomatische Kotlin API:
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 älter als 2.5.0
Falls Sie eine ältere ViewModel-Version als 2.5.0 verwenden, müssen Sie
Factorys aus einer Teilmenge von Klassen, die ViewModelProvider.Factory
erweitern
und implementieren Sie die create(Class<T>)
-Funktion. Je nachdem, welche Abhängigkeiten
die ViewModel-Anforderungen erfüllt, muss eine andere Klasse erweitert werden von:
AndroidViewModelFactory
, wenn die KlasseApplication
benötigt wird.AbstractSavedStateViewModelFactory
, wennSavedStateHandle
als Abhängigkeit übergeben werden.
Wenn Application
oder SavedStateHandle
nicht benötigt werden, erweitern Sie einfach von
ViewModelProvider.Factory
Im folgenden Beispiel wird ein AbstractSavedStateViewModelFactory
für ein
ViewModel verwendet, das ein Repository und einen SavedStateHandle
-Typ als
Abhängigkeit:
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 Ihr ViewModel mit 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 „Saved State“ für ViewModel
- UI-Status speichern
- LiveData-Übersicht