ViewModels mit Abhängigkeiten erstellen   Teil von Android Jetpack.

Gemäß den Best Practices für die Dependency Injection können ViewModels Abhängigkeiten als Parameter in ihrem Konstruktor annehmen. Diese stammen hauptsächlich aus der Domain- oder Datenschicht. Da das Framework die ViewModels bereitstellt, ist ein spezieller Mechanismus erforderlich, um Instanzen davon zu erstellen. Dieser Mechanismus ist die ViewModelProvider.Factory-Schnittstelle. Nur Implementierungen dieser Schnittstelle können ViewModels im richtigen Umfang instanziieren.

Hinweis: Wenn ViewModel keine Abhängigkeiten oder nur den SavedStateHandle-Typ als Abhängigkeit annimmt, müssen Sie keine Factory für das Framework zur Instanziierung von Instanzen dieses ViewModel-Typs angeben.

Hinweis: Wenn Sie ViewModels mit Hilt als Abhängigkeitsinjektionslösung einschleusen, müssen Sie keine ViewModel-Factory manuell definieren. Hilt generiert eine Factory, die weiß, wie alle mit @HiltViewModel annotierten ViewModels zur Kompilierungszeit erstellt werden. Mit @AndroidEntryPoint annotierte Klassen können direkt auf die von Hilt generierte Factory zugreifen, wenn sie die regulären ViewModel APIs aufrufen.

ViewModels mit CreationExtras

Wenn eine ViewModel-Klasse Abhängigkeiten in ihrem Konstruktor erhält, stellen Sie eine Fabrik bereit, die die Schnittstelle ViewModelProvider.Factory implementiert. Überschreiben Sie die Funktion create(Class<T>, CreationExtras), um eine neue Instanz des ViewModels bereitzustellen.

Mit CreationExtras können Sie auf relevante Informationen zugreifen, die Ihnen bei der Instanziierung eines ViewModels helfen. Hier ist eine Liste der Schlüssel, auf die über Extras zugegriffen werden kann:

Schlüssel	Funktionalität
ViewModelProvider.NewInstanceFactory.VIEW_MODEL_KEY	Ermöglicht den Zugriff auf den benutzerdefinierten Schlüssel, den du an ViewModelProvider.get() übergeben hast.
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	Ermöglicht den Zugriff auf den SavedStateRegistryOwner, der zum Erstellen des ViewModel verwendet wird.
SavedStateHandleSupport.VIEW_MODEL_STORE_OWNER_KEY	Ermöglicht den Zugriff auf den ViewModelStoreOwner, der zum Erstellen des ViewModel verwendet wird.

Wenn Sie eine neue Instanz von SavedStateHandle erstellen möchten, verwenden Sie die Funktion CreationExtras.createSavedStateHandle() und übergeben Sie sie an das ViewModel.

CreationExtras mit APPLICATION_KEY

Das folgende Beispiel zeigt, wie Sie eine Instanz einer ViewModel bereitstellen, die ein Repository mit Zugriffsbereich 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);
        }
    );
}

Hinweis: Es empfiehlt sich, ViewModel-Fabriken in der ViewModel-Datei zu platzieren, um den Kontext, die Lesbarkeit und die Auffindbarkeit zu verbessern. Die gleiche ViewModel-Factory kann für mehrere ViewModels verwendet werden, wenn sie gemeinsame Abhängigkeiten haben, wie es beim Beispiel für Architektur-Blueprints der Fall ist.

Diese Factory können Sie dann zum Abrufen einer Instanz des ViewModels 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 Factorys 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
                )
            }
        }
    }
}

Benutzerdefinierte Parameter als CreationExtras übergeben

Sie können Abhängigkeiten an Ihre ViewModel über CreationExtras übergeben, indem Sie einen benutzerdefinierten Schlüssel erstellen. Das kann hilfreich sein, wenn Ihre ViewModel von Objekten abhängt, auf die nicht über die Application-Klasse und APPLICATION_KEY zugegriffen werden kann. Ein Beispiel dafür ist, wenn Ihr ViewModel in einem Kotlin Multiplatform-Modul erstellt wird und daher keinen Zugriff auf Android-Abhängigkeiten hat.

In diesem Beispiel wird in ViewModel ein benutzerdefinierter Schlüssel definiert und in ViewModelProvider.Factory verwendet.

import androidx.lifecycle.ViewModel
import androidx.lifecycle.ViewModelProvider
import androidx.lifecycle.viewModelScope
import androidx.lifecycle.viewmodel.CreationExtras
import androidx.lifecycle.viewmodel.initializer
import androidx.lifecycle.viewmodel.viewModelFactory

class MyViewModel(
    private val myRepository: MyRepository,
) : ViewModel() {
    // ViewModel logic

    // Define ViewModel factory in a companion object
    companion object {

        // Define a custom key for your dependency
        val MY_REPOSITORY_KEY = object : CreationExtras.Key<MyRepository> {}

        val Factory: ViewModelProvider.Factory = viewModelFactory {
            initializer {
                // Get the dependency in your factory
                val myRepository = this[MY_REPOSITORY_KEY] as MyRepository
                MyViewModel(
                    myRepository = myRepository,
                )
            }
        }
    }
}

Sie können eine ViewModel mit einem CreationExtras.Key aus einem ViewModelStoreOwner wie ComponentActivity, Fragment oder NavBackStackEntry oder mit Jetpack Compose instanziieren.

Kotlin

import androidx.lifecycle.ViewModelProvider
import androidx.lifecycle.ViewModelStoreOwner
import androidx.lifecycle.viewmodel.CreationExtras
import androidx.lifecycle.viewmodel.MutableCreationExtras
// ...
    // Use from ComponentActivity, Fragment, NavBackStackEntry,
    // or another ViewModelStoreOwner.
    val viewModelStoreOwner: ViewModelStoreOwner = this
    val myViewModel: MyViewModel = ViewModelProvider.create(
        viewModelStoreOwner,
        factory = MyViewModel.Factory,
        extras = MutableCreationExtras().apply {
            set(MyViewModel.MY_REPOSITORY_KEY, myRepository)
        },
    )[MyViewModel::class]

Jetpack Compose

import androidx.lifecycle.viewmodel.MutableCreationExtras
import androidx.lifecycle.viewmodel.compose.viewModel
// ...
@Composable
fun MyApp(myRepository: MyRepository) {
    val extras = MutableCreationExtras().apply {
        set(MyViewModel.MY_REPOSITORY_KEY, myRepository)
    }
    val viewModel: MyViewModel = viewModel(
        factory = MyViewModel.Factory,
        extras = extras,
    )
}

Factories für ViewModel-Versionen älter als 2.5.0

Wenn Sie eine Version von ViewModel verwenden, die älter als 2.5.0 ist, müssen Sie Factories aus einer Teilmenge von Klassen bereitstellen, die ViewModelProvider.Factory erweitern und die create(Class<T>)-Funktion implementieren. Je nach den Abhängigkeiten, die ViewModel benötigt, muss eine andere Klasse erweitert werden:

• AndroidViewModelFactory, wenn die Klasse Application erforderlich ist.
• AbstractSavedStateViewModelFactory, wenn SavedStateHandle als Abhängigkeit übergeben werden muss.

Wenn Application oder SavedStateHandle nicht benötigt werden, verlängern Sie einfach von ViewModelProvider.Factory aus.

Im folgenden Beispiel wird ein AbstractSavedStateViewModelFactory für ein ViewModel verwendet, das ein Repository und einen SavedStateHandle-Typ als Abhängigkeit hat:

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

Warnung :Wenn Sie eine Version von ViewModel verwenden, die älter als 2.5.0 ist, können Sie möglicherweise eine create-Funktion mit CreationExtras in der Signatur überschreiben. Überschreiben Sie diese Funktion nicht. Überschreiben Sie stattdessen die Funktion create mit den Parametern key, modelClass und savedStateHandle.

Anschließend können Sie das ViewModel mit 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
        )
    )
) {
    // ...
}