jetpack compose est une boîte à outils d'interface utilisateur moderne pour Android. est une interface utilisateur déclarative qui remplace l' impératif (xml).

de manière classique, vous utilisez pour gérer de nombreuses activités ou cycle de vie de fragments.( onStart , onCreate , onResume …etc)

selon la doc officielle :

Le cycle de vie d'un composable est défini par les événements suivants : entrer dans la composition, être recomposé 0 fois ou plus et quitter la composition.

nous avons donc trois événements :

I. Entrez la composition

II. Se recomposer pour N fois

III. laissant la composition

Une composition ne peut être produite que par une composition initiale et mise à jour par recomposition . La seule façon de modifier une composition est par recomposition .

par exemple:

@Composable
fun MoviesScreen(movies: List<Movie>) {
    Column {
        for (movie in movies) {
            key(movie.id) { // Unique ID for this movie
                MovieOverview(movie)
            }
        }
    }
}

sinon, nous devons gérer la recoposition sans avoir besoin de rappeler la fonction.

Si un composable est déjà dans la composition, il peut ignorer la recomposition si toutes les entrées sont stables et n'ont pas changé.

alors comment faire la recomposition?

la recomposition dépend du type des variables de la fonction composable

si les variables sont de types stables (( Boolean, Int, Long, Float, Char, etc.), aucune recomposition ne se produira.

alors comment convertir ces types stables en un tel type pouvant conduire à une recomposition ?

bien, selon les docs officiels :

Les fonctions composables peuvent utiliser l' rememberAPI pour stocker un objet en mémoire. Une valeur calculée par rememberest stockée dans la composition lors de la composition initiale, et la valeur stockée est renvoyée lors de la recomposition. rememberpeut être utilisé pour stocker des objets modifiables et immuables.

nous devons donc l' interface MutableState<T> pour ajouter de la mutabilité à notre fonction de composition afin que la recomposition se produise à chaque fois que la valeur de ce type change.

la classe MutableState<T> si de type State<T>

interface MutableState<T> : State<T> {
    override var value: T
}

mutableStateOf

var list by remeber{mutableStateOf(initialValue)}
or 
val list = remember { mutableStateOf(initialValue) } // val variable will not change

import androidx.compose.runtime.getValue
import androidx.compose.runtime.setValue

list.value = ….

il existe d'autres types d' État autres que State<T> ou MutableState<T> , composez également les éléments suivants :

• Données en direct
• Couler
• RxJava2

Merci d'avoir lu :)

références :