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.

Hinweis: Wenn ViewModel keine Abhängigkeiten oder nur den SavedStateHandle-Typ als Abhängigkeit verwendet, musst du keine Factory bereitstellen, damit das Framework Instanzen dieses ViewModel-Typs instanziieren kann.

Hinweis: Wenn du ViewModels mit Hilt als Abhängigkeitsinjektionslösung einfügst, musst du keine ViewModel-Factory manuell definieren. Hilt generiert eine Factory, die weiß, wie alle ViewModels, die bei der Kompilierung mit @HiltViewModel annotiert sind, für Sie erstellt werden. Mit @AndroidEntryPoint annotierte Klassen können beim Aufrufen der regulären ViewModel APIs direkt auf die von Hilt generierte Factory zugreifen.

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

Hinweis :Es empfiehlt sich, ViewModel-Faktoren in ihre ViewModel-Datei aufzunehmen, um den Kontext, die Lesbarkeit und die Erkennung zu erleichtern. Dieselbe ViewModel-Factory kann für mehrere ViewModels verwendet werden, wenn diese Abhängigkeiten teilen, wie es beim Beispiel Architecture Blueprints der Fall ist.

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 Klasse Application benötigt wird.
• AbstractSavedStateViewModelFactory, wenn SavedStateHandle 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);
    }
}

Warnung: Wenn Sie eine ältere Version von ViewModel als 2.5.0 verwenden, können Sie eine Erstellungsfunktion möglicherweise 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 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
        )
    )
) {
    // ...
}