Les subtilités de Compose
- Compléter les exercices de la semaine.
- Commencer le troisième travail
Facile : les fonctions composables commencent par une majuscule
Une fonction composable est une fonction Kotlin annotée avec @Composable. Elle décrit un élément visuel de l'interface.
@Composable
fun Salutation(nom: String) {
Text("Bonjour $nom")
}
Les fonctions composables commencent par une majuscule (ex: Row, Button, Text), contrairement à la convention habituelle de nommage en Kotlin où les fonctions commencent par une minuscule (calculerMoyenne()).
Attention à ne pas vous mélanger entre la nomenclature de Compose et les appels de constructeur !
Ex:
- Row() est un appel de compose
- Random() est un appel de constructeur
Intermédiaire : la trailing lambda
- Dans un appel de fonction classique, les arguments sont spécifiés à l'intérieur des parenthèses :
maFonction(5, 6) - En Kotlin, quand le dernier paramètre d'une fonction est une lambda, on peut écrire cette lambda après les parenthèses. On appelle cela une trailing lambda.
Exemple
Pour mieux comprendre, prenons la fonction composable Row :
@Composable
inline fun Row(
modifier: Modifier = Modifier,
horizontalArrangement: Arrangement.Horizontal = Arrangement.Start,
verticalAlignment: Alignment.Vertical = Alignment.Top,
content: @Composable RowScope.() -> Unit
): Unit
Remarquez que son dernier paramètre content, qui permet de définir le contenu de la Row, est une fonction lambda (i.e. RowScope.() -> Unit). Voici deux façons équivalentes de définir le contenu d'une Row :
// Définition du contenu à l'intérieur des parenthèses de la Row
Row(
content = {
Column { /* contenu */ }
Column { /* contenu */ }
}
)
// Utilisation du trailing lambda pour définir le contenu de la Row
Row() {
Column { /* contenu */ }
Column { /* contenu */ }
}
Seule la dernière lambda peut être déportée. Si une fonction a deux lambdas, par exemple Button(onClick = {...}) { ... }, la lambda onClick reste dans les parenthèses et la lambda content est déportée.
Button(onClick = { println("Clic") }) {
Text("Cliquez-moi")
}
Difficile : le Modifier
modifierpermet de chaîner plusieurs transformations ou décorations sur un composant.- Chaque fonction (
padding,background,fillMaxWidth, etc.) retourne un nouveauModifierqui contient les précédents plus le nouveau. - Ça permet de les enchaîner facilement.
Ce mécanisme repose sur le patron de conception Chain of Responsibility (chaîne de responsabilité), où chaque transformation modifie ou enrichit le comportement du composant.
Exemple d'utilisation de Modifier
Row(
modifier = Modifier
.padding(8.dp)
.background(Color.LightGray)
.fillMaxWidth()
) {
// contenu
}
Dans cet exemple, le Row aura un padding de 8dp, un fond gris clair et prendra toute la largeur disponible. Chaque appel retourne un nouveau Modifier enrichi, permettant de composer facilement plusieurs effets.
Les modificateurs sont appliqués dans l'ordre où ils sont écrits :
// A : marge, puis fond ==> le fond gris ne couvre pas la marge.
Modifier.padding(16.dp).background(Color.LightGray)
// B : fond, puis marge ==> le fond couvre toute la zone.
Modifier.background(Color.LightGray).padding(16.dp)
God mode : gestion de l'état avec remember
Observez le code suivant. L'affichage du compteur est-il mis à jour sur l'interface graphique ?
@Composable
fun CompteurBrise() {
var count = 0
Button(onClick = { count++ }) {
Text("Compteur : $count")
}
}
Compose redessine une fonction composable (on dit qu'il la recompose) chaque fois qu'une donnée qu'elle affiche change. Lors d'une recomposition, la fonction est exécutée de nouveau depuis le début. Or, dans le code précédent, Compose ne sait pas que count a changé, donc il ne recompose pas.
Solution
En Jetpack Compose, la fonction remember permet de conserver une valeur en mémoire à travers les recompositions d'une fonction composable. Cela signifie que la valeur stockée avec remember ne sera pas réinitialisée à chaque fois que la fonction est réévaluée, sauf si les clés de dépendance changent ou si le composant est retiré de la composition.
remember est souvent utilisé pour stocker l'état local d'un composant, comme une variable qui doit survivre aux changements d'interface mais rester propre à la composable.
Exemple d'utilisation de remember
@Composable
fun Compteur() {
var count by remember { mutableStateOf(0) }
Button(onClick = { count++ }) {
Text("Compteur : $count")
}
}
Dans cet exemple, la variable count est conservée grâce à remember. À chaque clic, la valeur est incrémentée et l'interface se met à jour, mais la valeur n'est pas perdue lors des recompositions.
mutableStateOf(0) : Crée une valeur observable. Quand elle change, Compose recompose.
remember { ... } : Conserve la valeur entre les recompositions, au lieu de la recréer.
Références :
Ouvrez le projet WhatTheCompose dans Intellij, il s'agit d'un projet en pur Kotlin.
Exercice Lambda
Pour se familiariser avec les lambda, ouvrez le fichier A-Lambdas.kt.
Rajouter:
- dans la fonction
main - crée un tableau avec les valeurs -12, 5, 2034, 55
- un appel à triBulle
- qui trie le tableau selon la longueur de la représentation textuelle de chaque nombre, du plus court au plus long
- par exemple "-12" (3 chiffres) est plus long que "55" (2 chiffres) donc sera après dans le tableau trié
Exercice lambda déportée
Se familiariser avec les trailing lambdas, ouvrez le fichier B-TrailingLambda.kt.
Exercice Café modifié
Ouvrez le fichier C-Modifier-Voodoo-Magic.kt.
- placer quelques points d'arrêts et regarder ce que fait chaque modification
- essayer d'ajouter une fonction pour mettre une vanilleFrançaise dans le café