Créer des ViewModels avec des dépendances Fait partie d'Android Jetpack.

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é.

Remarque : Si le ViewModel n'accepte aucune dépendance ou seulement le type SavedStateHandle comme dépendance, vous n'avez pas besoin de fournir une fabrique pour que le framework instancie les instances de ce type de ViewModel.

Remarque : Lorsque vous injectez des ViewModels à l'aide de Hilt comme solution d'injection de dépendances, vous n'avez pas besoin de définir manuellement une fabrique ViewModel. Hilt génère une fabrique capable de créer tous les ViewModels annotés avec @HiltViewModel au moment de la compilation. Les classes annotées avec @AndroidEntryPoint peuvent accéder directement à la fabrique générée par Hilt lors de l'appel des API ViewModel standard.

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. Ignorez la fonction create(Class<T>, CreationExtras) pour fournir une nouvelle instance du ViewModel.

CreationExtras vous permet d'accéder à des informations pertinentes pour instancier un ViewModel. Voici une liste de clés accessibles depuis Extras :

Clé	Fonctionnalité
ViewModelProvider.NewInstanceFactory.VIEW_MODEL_KEY	Fournit l'accès à la clé personnalisée que vous avez transmise à ViewModelProvider.get().
ViewModelProvider.AndroidViewModelFactory.APPLICATION_KEY	Fournit l'accès à l'instance de la classe Application.
SavedStateHandleSupport.DEFAULT_ARGS_KEY	Fournit l'accès au bundle d'arguments à utiliser pour construire SavedStateHandle.
SavedStateHandleSupport.SAVED_STATE_REGISTRY_OWNER_KEY	Fournit l'accès au SavedStateRegistryOwner utilisé pour créer le ViewModel.
SavedStateHandleSupport.VIEW_MODEL_STORE_OWNER_KEY	Fournit l'accès au ViewModelStoreOwner utilisé pour créer le ViewModel.

Pour créer une instance de SavedStateHandle, utilisez la fonction CreationExtras.createSavedStateHandle().createSavedStateHandle()) et transmettez-la au ViewModel.

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 :

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

Remarque : Nous vous recommandons de placer les fabriques ViewModel dans leur fichier ViewModel afin d'améliorer le contexte, la lisibilité et la visibilité. La même fabrique ViewModel peut être utilisée pour plusieurs ViewModels partageant des dépendances, comme c'est le cas pour l'exemple de plans d'architecture.

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
} 

Jetpack Compose

import androidx.lifecycle.viewmodel.compose.viewModel

@Composable
fun MyScreen(
    modifier: Modifier = Modifier,
    viewModel: MyViewModel = viewModel(factory = MyViewModel.Factory)
) {
    // ...
}

Vous pouvez également utiliser la DSL de fabrique de ViewModel pour créer des fabriques à l'aide d'une API Kotlin plus idiomatique :

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

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 :

• AndroidViewModelFactory si la classe Application est nécessaire.
• AbstractSavedStateViewModelFactory si SavedStateHandle doit être transmis en tant que dépendance.

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

Avertissement : Si vous utilisez une version de ViewModel antérieure à la version 2.5.0, vous aurez peut-être la possibilité d'ignorer la fonction de création avec CreationExtras en signature. N'ignorez pas cette fonction. Ignorez plutôt la fonction create qui contient les paramètres key, modelClass et savedStateHandle.

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
}

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
        )
    )
) {
    // ...
}