Créer des ViewModels avec des dépendances (Views)   Inclus dans Android Jetpack.

Concepts et implémentation de Jetpack Compose

Conformément aux bonnes pratiques sur l'injection de dépendances, les ViewModels peuvent utiliser des dépendances comme paramètres dans leur constructeur. Il s'agit principalement de types issus des couches de domaines ou de données. Comme le framework fournit les ViewModels, un mécanisme spécial est nécessaire pour en créer des instances. Ce mécanisme correspond à l'interface ViewModelProvider.Factory. Seules les implémentations de cette interface peuvent instancier les ViewModels avec le champ d'application approprié.

ViewModels avec CreationExtras

Si une classe ViewModel reçoit des dépendances dans son constructeur, fournissez une fabrique qui implémente l'interface ViewModelProvider.Factory. Remplacez la fonction create(Class<T>, CreationExtras) pour fournir une nouvelle instance du ViewModel.

CreationExtras avec APPLICATION_KEY

L'exemple suivant montre comment fournir une instance d'un ViewModel qui utilise un dépôt limité à la classe Application et à SavedStateHandle en tant que dépendances :

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

Vous pouvez ensuite utiliser cette fabrique pour récupérer une instance du ViewModel :

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
}

Transmettre des paramètres personnalisés en tant que CreationExtras

Vous pouvez transmettre des dépendances à votre ViewModel via CreationExtras en créant une clé personnalisée. Cela peut être utile si votre ViewModel dépend d'objets qui ne sont pas accessibles via la classe Application et APPLICATION_KEY. Par exemple, lorsque votre ViewModel est créé dans un module Kotlin Multiplatform et n'a donc pas accès aux dépendances Android.

Dans cet exemple, ViewModel définit une clé personnalisée et l'utilise dans ViewModelProvider.Factory.

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

Vous pouvez instancier un ViewModel avec un CreationExtras.Key à partir d'un ViewModelStoreOwner tel que ComponentActivity, Fragment ou NavBackStackEntry.

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]

Fabriques pour une version de ViewModel antérieure à la version 2.5.0

Si vous utilisez une version de ViewModel antérieure à la version 2.5.0, vous devez fournir des fabriques d'un sous-ensemble de classes qui étendent le ViewModelProvider.Factory et implémentent la fonction create(Class<T>). Selon les dépendances dont le ViewModel a besoin, une autre classe doit être étendue à partir de :

Si Application ou SavedStateHandle ne sont pas nécessaires, étendez simplement depuis ViewModelProvider.Factory.

L'exemple suivant utilise une propriété AbstractSavedStateViewModelFactory pour un ViewModel qui utilise un dépôt et le type SavedStateHandle comme dépendance :

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

Vous pouvez ensuite utiliser la fabrique pour récupérer votre ViewModel :

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
}