Charger des données de manière paresseuse avec des listes et la pagination

Le chargement différé et la bibliothèque Paging vous permettent de prendre en charge de longues listes d'éléments (y compris des listes infinies) dans votre application en chargeant et en affichant les données de manière incrémentielle. Cette technique vous permet de réduire les temps de chargement initiaux et d'optimiser l'utilisation de la mémoire, ce qui améliore les performances.

Résultats

La vidéo suivante montre le comportement d'une longue liste qui récupère des données à mesure que l'utilisateur fait défiler l'écran.

Compatibilité des versions

Cette implémentation nécessite que le minSDK de votre projet soit défini sur le niveau d'API 21 ou supérieur.

Dépendances

Afficher du contenu paginé

La bibliothèque Paging vous permet de charger et d'afficher des pages de données depuis un ensemble de données plus volumineux, à partir d'un espace de stockage local ou sur réseau. Utilisez le code suivant pour afficher une liste paginée qui affiche une barre de progression pour indiquer à l'utilisateur que d'autres données sont en cours de récupération :

@Composable
fun MessageList(
    modifier: Modifier,
    pager: Pager<Int, Message>
) {
    val lazyPagingItems = pager.flow.collectAsLazyPagingItems()

    LazyColumn {
        items(
            lazyPagingItems.itemCount,
            key = lazyPagingItems.itemKey { it.id }
        ) { index ->
            val message = lazyPagingItems[index]
            if (message != null) {
                MessageRow(message)
            } else {
                MessagePlaceholder()
            }
        }
    }
    @Composable
    fun MessagePlaceholder(modifier: Modifier) {
        Box(
            Modifier
                .fillMaxWidth()
                .height(48.dp)
        ) {
            CircularProgressIndicator()
        }
    }

    @Composable
    fun MessageRow(
        modifier: Modifier,
        message: Message
    ) {
        Card(modifier = Modifier.padding(8.dp)) {
            Column(
                modifier = Modifier.padding(8.dp),
                verticalArrangement = Arrangement.Center
            ) {
                Text(message.sender)
                Text(message.text)
            }
        }
    }
}

Points clés concernant le code

  • LazyColumn : ce composable permet d'afficher efficacement une longue liste d'éléments (messages). Il n'affiche que les éléments visibles à l'écran, ce qui permet d'économiser des ressources et de la mémoire.
  • L'objet lazyPagingItems gère efficacement le chargement et la présentation des données paginées dans LazyColumn. Il transmet LazyPagingItems à items dans le composable LazyColumn.
  • MessageRow(message: Text) est chargé d'afficher les éléments de message individuels, probablement en affichant l'expéditeur et le texte du message dans une carte.
  • MessagePlaceholder() fournit un espace réservé visuel (un indicateur de chargement) pendant que les données réelles du message sont récupérées, ce qui améliore l'expérience utilisateur.

Collections contenant ce guide

Ce guide fait partie de ces collections de guides rapides qui couvrent des objectifs de développement Android plus larges :

Les listes et les grilles permettent à votre application d'afficher des collections sous une forme visuellement agréable et facile à utiliser.
Découvrez comment les fonctions composables vous permettent de créer facilement de superbes composants d'interface utilisateur basés sur le système de conception Material Design.
Cette série de vidéos présente différentes API Compose, en vous montrant rapidement ce qui est disponible et comment les utiliser.

Vous avez des questions ou des commentaires ?

Consultez notre page de questions fréquentes et découvrez nos guides rapides, ou contactez-nous pour nous faire part de vos commentaires.