Chip

Le composant Chip est un élément d'interface utilisateur compact et interactif. Il représente des entités complexes telles qu'un contact ou un tag, souvent avec une icône et un libellé. Il peut être cochable, fermé ou cliquable.

Voici les quatre types de chips et les cas d'utilisation possibles :

  • Assistance : guide l'utilisateur pendant une tâche. Il apparaît souvent sous la forme d'un élément d'interface utilisateur temporaire en réponse à une entrée utilisateur.
  • Filtre : permet aux utilisateurs d'affiner le contenu à partir d'un ensemble d'options. Ils peuvent être sélectionnés ou désélectionnés, et peuvent inclure une icône de coche lorsqu'ils sont sélectionnés.
  • Entrée : représente les informations fournies par l'utilisateur, telles que les sélections dans un menu. Ils peuvent contenir une icône et du texte, et inclure un X pour les supprimer.
  • Suggestion : fournit des recommandations à l'utilisateur en fonction de son activité ou de ses entrées récentes. Ils s'affichent généralement sous un champ de saisie pour inviter l'utilisateur à effectuer une action.
Exemple de chacun des quatre composants de chips, avec leurs caractéristiques uniques mises en évidence.
Figure 1 : Les quatre composants de chips.

Surface d'API

Il existe quatre composables correspondant aux quatre types de chips. Les sections suivantes décrivent ces composables et leurs différences en détail. Cependant, ils partagent les paramètres suivants :

  • label : chaîne qui s'affiche sur le chip.
  • icon : icône affichée au début du chip. Certains composables spécifiques ont des paramètres leadingIcon et trailingIcon distincts.
  • onClick : lambda que le chip appelle lorsque l'utilisateur appuie dessus.

Chip d'assistance

Le composable AssistChip permet de créer facilement un chip d'assistance qui oriente l'utilisateur dans une direction particulière. L'une de ses caractéristiques est son paramètre leadingIcon, qui vous permet d'afficher une icône sur le côté gauche du chip. L'exemple suivant montre comment l'implémenter :

@Composable
fun AssistChipExample() {
    AssistChip(
        onClick = { Log.d("Assist chip", "hello world") },
        label = { Text("Assist chip") },
        leadingIcon = {
            Icon(
                painter = rememberVectorPainter(AppIcons.Settings),
                contentDescription = "Localized description",
                Modifier.size(AssistChipDefaults.IconSize)
            )
        }
    )
}

Cette implémentation est la suivante :

Figure 2. Chip d'assistance.

Élément de filtre

Le composable FilterChip nécessite que vous suiviez si le chip est sélectionné ou non. L'exemple suivant montre comment afficher une icône de coche au début uniquement lorsque l'utilisateur a sélectionné le chip :

@Composable
fun FilterChipExample() {
    var selected by remember { mutableStateOf(false) }

    FilterChip(
        onClick = { selected = !selected },
        label = {
            Text("Filter chip")
        },
        selected = selected,
        leadingIcon = if (selected) {
            {
                Icon(
                    painter = rememberVectorPainter(AppIcons.Done),
                    contentDescription = "Done icon",
                    modifier = Modifier.size(FilterChipDefaults.IconSize)
                )
            }
        } else {
            null
        },
    )
}

Cette implémentation est la suivante lorsqu'elle est sélectionnée :

Figure 3. Chip de filtre sélectionné.

Chip de saisie

Vous pouvez utiliser le composable InputChip pour créer des chips résultant d'une interaction utilisateur. Par exemple, dans un client de messagerie, lorsqu'un utilisateur rédige un e-mail, un chip de saisie peut représenter un contact qu'il a ajouté au champ "À".

L'implémentation suivante illustre un chip d'entrée qui est déjà dans un état sélectionné. L'utilisateur ferme le chip lorsqu'il appuie dessus.

@Composable
fun InputChipExample(
    text: String,
    onDismiss: () -> Unit,
) {
    var enabled by remember { mutableStateOf(true) }
    if (!enabled) return

    InputChip(
        onClick = {
            onDismiss()
            enabled = !enabled
        },
        label = { Text(text) },
        selected = enabled,
        avatar = {
            Icon(
                painter = rememberVectorPainter(AppIcons.Person),
                contentDescription = "Localized description",
                Modifier.size(InputChipDefaults.AvatarSize)
            )
        },
        trailingIcon = {
            Icon(
                painter = rememberVectorPainter(AppIcons.Close),
                contentDescription = "Localized description",
                Modifier.size(InputChipDefaults.AvatarSize)
            )
        },
    )
}

Cette implémentation est la suivante :

Figure 4. Chip de saisie.

Chip de suggestion

Le composable SuggestionChip est le plus basique des composables listés sur cette page, tant dans sa définition d'API que dans ses cas d'utilisation courants. Les chips de suggestion présentent des indices générés de manière dynamique. Par exemple, dans une application de chat IA, vous pouvez utiliser des chips de suggestion pour présenter des réponses possibles au message le plus récent.

Prenons l'implémentation suivante de SuggestionChip :

@Composable
fun SuggestionChipExample() {
    SuggestionChip(
        onClick = { Log.d("Suggestion chip", "hello world") },
        label = { Text("Suggestion chip") }
    )
}

Cette implémentation est la suivante :

Figure 5. Chip de suggestion.

Chip surélevé

Tous les exemples de ce document utilisent les composables de base qui ont une apparence plate. Si vous souhaitez un chip avec une apparence surélevée, utilisez l'un des trois composables suivants :

Mise à jour M3 Expressive

Les chips de filtre et de saisie ont été modifiés, avec des rayons d'angle plus grands et un mouvement de ressort. Les chips d'assistance et les chips de suggestion ont été fusionnés en boutons expressifs.

Pour en savoir plus sur les mises à jour de Material 3 Expressive pour les chips, consultez les consignes de Material Design 3 pour les chips.

Morphing d'angle

Les chips de filtre et de saisie sont compatibles avec le morphing des angles, en animant le rayon d'angle du conteneur de 12 dp lorsqu'il n'est pas sélectionné à un arrondi complet lorsqu'il est sélectionné.

Filtre

L'extrait de code suivant montre comment implémenter un chip de filtre avec morphing d'angle :

@Composable
fun FilterChipWithCornerMorphingSample() {
    var selected by remember { mutableStateOf(false) }
    FilterChip(
        selected = selected,
        onClick = { selected = !selected },
        label = { Text("Filter chip") },
        shapes = FilterChipDefaults.shapes(),
        leadingIcon = if (selected) {
            {
                Icon(
                    painter = rememberVectorPainter(AppIcons.Done),
                    contentDescription = null,
                    modifier = Modifier.size(FilterChipDefaults.IconSize),
                )
            }
        } else {
            null
        },
    )
}

Filtre surélevé

Les chips de filtre surélevés permettent de séparer un arrière-plan visuellement proéminent et de prendre en charge la transformation des angles. L'extrait de code suivant montre comment implémenter un chip de filtre surélevé avec morphing des angles :

@Composable
fun ElevatedFilterChipWithCornerMorphingSample() {
    var selected by remember { mutableStateOf(false) }
    ElevatedFilterChip(
        selected = selected,
        onClick = { selected = !selected },
        label = { Text("Filter chip") },
        shapes = FilterChipDefaults.shapes(),
        leadingIcon = if (selected) {
            {
                Icon(
                    painter = rememberVectorPainter(AppIcons.Done),
                    contentDescription = null,
                    modifier = Modifier.size(FilterChipDefaults.IconSize),
                )
            }
        } else {
            {
                Icon(
                    painter = rememberVectorPainter(AppIcons.Home),
                    contentDescription = null,
                    modifier = Modifier.size(FilterChipDefaults.IconSize),
                )
            }
        },
        trailingIcon = {
            Icon(
                painter = rememberVectorPainter(AppIcons.ArrowDropDown),
                contentDescription = null,
                modifier = Modifier.size(FilterChipDefaults.IconSize),
            )
        },
    )
}

Entrée

Les chips de saisie représentent des informations distinctes saisies par un utilisateur et sont également compatibles avec le morphing des angles. L'extrait de code suivant montre comment implémenter un chip de saisie avec morphing des angles :

@Composable
fun InputChipWithCornerMorphingSample() {
    var selected by remember { mutableStateOf(false) }
    InputChip(
        selected = selected,
        onClick = { selected = !selected },
        label = { Text("Input Chip") },
        shapes = InputChipDefaults.shapes(),
        avatar = {
            Icon(
                painter = rememberVectorPainter(AppIcons.Person),
                contentDescription = null,
                modifier = Modifier.size(InputChipDefaults.AvatarSize),
            )
        },
    )
}

Chips d'assistance et de suggestion

Les chips d'assistance et les chips de suggestion sont fusionnés en boutons expressifs dans Material 3. Ils sont expressifs, car ils reflètent de manière fonctionnelle les comportements des boutons à action unique. Utilisez des boutons expressifs lorsque vous avez besoin d'un comportement d'assistance ou de chip de suggestion expressif. Pour en savoir plus sur l'implémentation, consultez la documentation sur les boutons.

Ressources supplémentaires