Présentation des flux

La version Kotlin des API Home utilise des flux, une fonctionnalité du langage Kotlin qui offre des fonctionnalités puissantes pour gérer les flux de données asynchrones, y compris la transformation, le filtrage, le mappage, la conversion entre collections, etc.

Les coroutines sont étroitement associées aux flux. Elles fournissent une abstraction élégante pour écrire du code asynchrone et libèrent le développeur de l'obligation d'écrire explicitement des routines de rappel. Les flux fonctionnent de concert avec les coroutines, ce qui permet de récupérer des données de coroutines de manière asynchrone, sans avoir à attendre la fin d'une fonction ou d'un thread.

Les données sont récupérées à partir d'un flux par le consommateur dans un processus appelé collecte. Les flux Kotlin disposent d'une fonction collect() qui peut être utilisée à cette fin. Ce qui se passe dans un flux lors de la collecte dépend du type de flux.

Les flux Kotlin (Flow<T>) sont froids par défaut, ce qui signifie que le code du compilateur de flux ne produit des données que lorsque collect() est appelé. À l'inverse, un flux chaud produit des données immédiatement, en les mettant en mémoire tampon comme une file d'attente chaque fois qu'elles sont consommées. Étant donné qu'il conserve les données en mémoire, un flux chaud est considéré comme ayant un état.

Vous pouvez convertir des flux froids en flux chauds à l'aide de l'opérateur shareIn (voir Transformer les flux froids en flux chauds à l'aide de shareIn). Vous pouvez également utiliser SharedFlow ou StateFlow pour transformer un flux froid en flux chaud.

Comment l'application exemple utilise-t-elle les flux ?

L'application exemple utilise des modèles de vue dans Jetpack Compose connectés aux flux des API Home. De nombreux éléments d'interface utilisateur de l'application exemple sont basés sur l'état, mais peuvent être utilisés. L'application exemple combine également l'état des appareils avec un état "optimiste" dans l'UI pour une expérience utilisateur en temps réel. Le terme "optimiste" signifie que l'application suppose qu'une action donnée a réussi et met immédiatement à jour l'UI pour refléter le résultat attendu sans attendre de confirmation. Si l'action échoue, l'UI est mise à jour pour refléter l'état réel.

Dans l'application exemple, des flux sont créés pour chaque couche du modèle de vue (structures, pièces, appareils). Par exemple, il le fait pour les structures avec l'appel suivant dans GlobalViewModel.kt:

  fun getStructuresState(): StateFlow<List<StructureModel>?> =
    homeClient
      .structures()
      .map { structures -> structures.map { StructureModel(it.name, it) }.sortedBy { it.name } }
      .handleErrors()
      .flowOn(Dispatchers.IO)
      .stateIn(scope = viewModelScope, started = SharingStarted.WhileSubscribed(), null)

emitAll() collecte toutes les valeurs du flux donné et les envoie au collecteur. stateIn() partage la valeur émise la plus récemment à partir d'une seule instance en cours d'exécution du flux en amont avec plusieurs abonnés en aval. Pour en savoir plus, consultez la documentation de référence sur kotlinx.coroutines.flow.

Jetpack Compose

Pour stocker des objets de flux dans la mémoire locale et les empêcher d'être arrêtés, utilisez l'API Kotlin remember.

Dans Jetpack Compose, si vous utilisez cette méthode avec collectAsStateWithLifecycle(), Jetpack gère automatiquement l'abonnement et le désabonnement aux flux en fonction de l'état de l'UI de l'application qui affiche cet état.

Un appel simple dans l'application exemple permet de le faire. À l'aide de la fonction getStructuresState() indiquée précédemment:

val structuresList by
    remember(globalViewModel) { globalViewModel.getStructuresState() }.collectAsStateWithLifecycle()

Désormais, lorsque l'état de la structure change (par exemple, name), la fonction Composable qui l'utilise reflète automatiquement cet état mis à jour. Dans l'application exemple, il s'agit de la fonction HomeActivityContent().

Ressources

Pour en savoir plus sur Kotlin, les flux, les coroutines et Jetpack Compose, consultez les ressources suivantes:

• Développer des applications Android en Kotlin
• Découvrir Kotlin pour Android
• Coroutines Kotlin sur Android Ces ateliers de programmation spécifiques peuvent vous être utiles :
  • Atelier de programmation : Utiliser des coroutines Kotlin dans votre application Android
  • Atelier de programmation : Coroutines avancées avec Kotlin Flow et LiveData
• Flux Kotlin sur Android et plus précisément StateFlow
• État et Jetpack Compose, en particulier la fonction collectAsStateWithLifecycle(). Cette fonction gère automatiquement l'abonnement et le désabonnement aux flux en fonction de l'état de l'UI affichant cet état.
  • Atelier de programmation : État dans Jetpack
• Si vous travaillez avec l'API Automation, consultez les compilateurs Kotlin avec sûreté de typage pour comprendre le fonctionnement du DSL Automation.