#Architecture MVVM avec Compose

L’architecture MVVM sous Android se traduit par l’utilisation de ViewModel pour gérer l’état de l’UI et faire le liens avec les données.

Les viewModels sont des classes gérées par le système Android, elles sont les particularités suivantes :

• Elles sont conservées lors des changements de configuration (rotation de l’écran)
• Elles sont détruites lorsqu’elles ne sont plus utilisées (fin de l’activité ou du fragment, etc.)
• Elles sont utilisées pour gérer l’état de l’UI
• Elles sont indépendantes de la couche UI
• Les viewModels vous donne accès à un coroutineScope pour gérer des tâches asynchrones dans son cycle de vie (viewModelScope)
• Elles ne peuvent pas être instanciées directement, elles doivent être créées via un ViewModelProvider

Pour respecter la logique MVVM vos ViewModel doivent :

• Être indépendants de la couche UI
  • Les viewModels sont faits pour être observés par les composants de l’UI et non liés fortements à eux.
  • Les viewModels ne doivent pas contenir de références à des vues (TextView, Button, etc.)
• Proposer des fonctions pour modifier l’état de l’UI
  • La vue ne doit pas pouvoir modifier directement l’état du viewModel, elle doit passer par des fonctions dédiées.

#Pub/Sub (Publisher/Subscriber)

Comment lire les données d’un viewModel dans une vue ?

#Les outils

Pour pouvoir pleinement fonctionner, les viewModels se reposent sur le pattern Pub/Sub (Publisher/Subscriber) pour notifier les composants de l’UI des changements d’état. Il existe plusieurs outils pour mettre en place ce pattern sur Android / Kotlin :

• LiveData (Android Jetpack) -> Voué à disparaître au profit de StateFlow, utile pour les applications Android classiques
• StateFlow (Kotlin Flows) -> Utilisé pour les applications modernes, permet de gérer l’état de manière réactive
• MutableState (Jetpack Compose) -> Utilisé pour les applications Jetpack Compose, permet de gérer l’état de manière réactive

Les 3 outils ont leur propre particularités, mais le principe reste le même : un composant s’abonne à un Publisher (le viewModel) pour être notifié des changements d’état.

#Transmettre les événements utilisateurs

Comment transmettre les événements utilisateurs à un viewModel ?

La c’est beaucoup plus simple, il suffit de créer des fonctions dans le viewModel qui seront appelées par les composants de l’UI pour modifier l’état.

#ViewModels

#Voici un viewModel

// ViewModel.kt
class MyViewModel: ViewModel() {
    private val _counter = MutableStateFlow(0)
    val counter: StateFlow<Int> = _counter

    fun incrementCounter() {
        _counter.value++
    }
}

#Utilisé par MyComposable

// View.kt
@Composable
fun MyComposable(viewModel: MyViewModel) {
    val counter by viewModel.counter.collectAsState() // Transformation d'un événement en état

    Button(onClick = { viewModel.incrementCounter() }) {
        Text("Click me $counter")
    }
}

#Comment instancier un viewModel ?

On ne doit pas instancier directement un viewModel, on doit passer par un ViewModelProvider. Cela permet au système Android de gérer le cycle de vie du viewModel correctement.

Ainsi un viewModel qui serait déjà instancié ne le serait pas à nouveau, évitant fuite mémoire et erreur d’accès. Un viewModel qui ne serait plus utilisé serait détruit.

#Exemple d’instanciation

// View.kt
val viewModel = viewModel<MyViewModel>()

Si vous avez besoin de passer des paramètres à votre viewModel, vous pouvez utiliser la syntaxe suivante :

// View.kt
val viewModel = viewModel<MyViewModel>(factory = MyViewModel.provideFactory(param1))

Et la factory, qui par convention est un singleton interne au viewModel :

// ViewModel.kt
class MyViewModel(myParamInViewModel: String) : AndroidViewModel() {
    companion object {
        fun provideFactory(myParam: String): ViewModelProvider.Factory {
            return 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])

                    return MyViewModel(
                        myParamInViewModel = myParam,
                        (application as MyApplication)
                    ) as T
                }
            }
        }
    }

    private val _counter = MutableStateFlow(0)
    val counter: StateFlow<Int> = _counter

    fun incrementCounter() {
        _counter.value++
    }
}