Unlimited Plugins, WordPress themes, videos & courses! Unlimited asset downloads! From $16.50/m
Advertisement
  1. Code
  2. Android SDK
Code

Programmation Kotlin Réactive Avec RxJava et RxKotlin

by
Difficulty:IntermediateLength:LongLanguages:

French (Français) translation by Soleil (you can also view the original English article)

Depuis qu'il est devenu une langue officiellement prise en charge pour le développement d'Android, Kotlin a rapidement gagné en popularité auprès des développeurs Android, Google signalant une augmentation de 6x des applications créées à l'aide de Kotlin.

Si vous avez déjà utilisé RxJava ou RxAndroid et que vous souhaitez passer à Kotlin, ou si vous souhaitez démarrer une programmation réactive avec Kotlin, ce tutoriel est pour vous. Nous allons couvrir l’essentiel de la création des Observers RxJava 2.0, des Observables et des flux de données dans Kotlin, avant d’examiner comment vous pouvez réduire une tonne de code passe-partout de vos projets en combinant RxJava avec les fonctions d’extension Kotlin.

L’utilisation de RxJava avec Kotlin peut vous aider à créer des applications hautement réactives avec moins de code, mais aucun langage de programmation n’est parfait.

Pour terminer, nous allons créer une application qui montre comment utiliser RxJava pour résoudre certains des problèmes que vous rencontrez dans des projets Android réels.

Si vous découvrez RxJava pour la première fois, je vous fournirai en même temps toutes les informations de base nécessaires pour comprendre les concepts de base de RxJava. Même si vous n'avez jamais expérimenté avec RxJava, à la fin de cet article, vous comprendrez parfaitement comment utiliser cette bibliothèque dans vos projets et vous aurez créé plusieurs applications fonctionnelles, en utilisant RxJava, RxKotlin, RxAndroid. et RxBinding.

Qu'est-ce que RxJava, de toute façon?

RxJava est une implémentation open source de la bibliothèque ReactiveX qui vous aide à créer des applications dans le style de programmation réactive. Bien que RxJava soit conçu pour traiter des flux de données synchrones et asynchrones, il n'est pas limité aux types de données «traditionnels». La définition de «données» par RxJava est assez large et comprend des éléments tels que les caches, les variables, les propriétés et même les événements d’entrée utilisateur tels que les clics et les glissements. Ce n’est pas parce que votre application ne gère pas de gros volumes ou que vous n’effectuez pas de transformations de données complexes que RxJava ne peut pas vous être utile!

Pour un peu d’information sur l’utilisation de RxJava pour les applications Android, vous pouvez consulter certains de mes autres articles ici sur Envato Tuts +.

Alors, comment fonctionne RxJava?

RxJava étend le modèle de conception du logiciel Observer, qui repose sur le concept des Observers et des Observables. Pour créer un pipeline de données RxJava de base, vous devez:

  • Créer une Observable.
  • Donnez à l'Observable des données à émettre.
  • Créer un Observer
  • Abonnez-vous à Observer au Observable.

Dès que Observable aura au moins un Observer, il commencera à émettre des données. Chaque fois qu’Observable émet une donnée, il notifie son Observer assigné en appelant la méthode onNext(), et l’Observer exécute alors certaines actions en réponse à cette émission de données. Une fois que l’Observable a fini d’émettre des données, il avertira l’Observer en appelant onComplete(). L'observable se terminera alors et le flux de données se terminera.

Si une exception se produit, onError() sera appelé et Observable se terminera immédiatement sans émettre de données supplémentaires ni appeler onComplete().

Mais RxJava ne se contente pas de transmettre des données d’un Observable à un Observer! RxJava possède une énorme collection d'opérateurs que vous pouvez utiliser pour filtrer, fusionner et transformer ces données. Par exemple, imaginez que votre application possède un bouton Pay Now qui détecte les événements onClick, et vous craignez qu’un utilisateur impatient ne touche plusieurs fois le bouton, ce qui entraîne le traitement de plusieurs paiements par votre application.

RxJava vous permet de transformer ces événements onClick en un flux de données, que vous pouvez ensuite manipuler en utilisant les différents opérateurs de RxJava. Dans cet exemple, vous pouvez utiliser l'opérateur debounce() pour filtrer les émissions de données qui se succèdent rapidement. Ainsi, même si l'utilisateur refuse le bouton Pay Now, votre application n'enregistre qu'un seul paiement.

Quels sont les avantages de l'utilisation de RxJava?

Nous avons vu comment RxJava peut vous aider à résoudre un problème spécifique, dans une application spécifique, mais qu’en est-il en général pour proposer des projets Android?

RxJava peut vous aider à simplifier votre code en vous donnant un moyen d'écrire ce que vous voulez réaliser, plutôt que d'écrire une liste d'instructions sur lesquelles votre application doit travailler. Par exemple, si vous voulez ignorer toutes les émissions de données qui se produisent pendant la même période de 500 millisecondes, vous devez écrire:

De plus, comme RxJava traite presque tout comme des données, il fournit un modèle que vous pouvez appliquer à un large éventail d'événements: créez un Observable, créez un Observer, abonnez Observer à Observable, rincez et répétez. Cette approche par formule aboutit à un code beaucoup plus simple et lisible par l'homme.

L'autre avantage majeur pour les développeurs Android est que RxJava peut éliminer une grande partie du multithreading sous Android. Les utilisateurs mobiles d’aujourd’hui s’attendent à ce que leurs applications puissent effectuer plusieurs tâches, même si c’est quelque chose d’aussi simple que de télécharger des données en arrière-plan tout en restant réactif aux entrées des utilisateurs.

Android dispose de plusieurs solutions intégrées pour créer et gérer plusieurs threads, mais aucun n’est particulièrement simple à mettre en œuvre, et ils peuvent rapidement générer un code complexe et détaillé, difficile à lire et sujet aux erreurs.

Dans RxJava, vous créez et gérez des threads supplémentaires à l'aide d'une combinaison d'opérateurs et de planificateurs. Vous pouvez facilement changer le thread où le travail est effectué, en utilisant l'opérateur subscribeOn plus un planificateur. Par exemple, nous planifions ici le travail à effectuer sur un nouveau thread:

Vous pouvez spécifier où les résultats de ce travail doivent être publiés, en utilisant l'opérateur observeOn. Ici, nous publions les résultats sur le thread d'interface utilisateur principal d'Android, à l'aide du planificateur AndroidSchedulers.mainThread, disponible dans la bibliothèque RxAndroid:

Par rapport aux solutions multithreading d’Android, l’approche de RxJava est beaucoup plus concise et plus facile à comprendre.

Encore une fois, vous pouvez en savoir plus sur le fonctionnement de RxJava et sur les avantages de l'ajout de cette bibliothèque à votre projet dans mon article Get Started With RxJava 2 pour Android.

Dois-je utiliser RxJava ou RxKotlin?

Comme Kotlin est 100% interopérable avec Java, vous pouvez utiliser la plupart des bibliothèques Java dans vos projets Kotlin sans aucune difficulté, et la bibliothèque RxJava ne fait pas exception.

Il existe une bibliothèque RxKotlin dédiée, qui est un wrapper Kotlin autour de la bibliothèque RxJava standard. Ce wrapper fournit des extensions qui optimisent RxJava pour l'environnement Kotlin et peuvent réduire davantage la quantité de code standard que vous devez écrire.

Comme vous pouvez utiliser RxJava dans Kotlin sans jamais avoir besoin de RxKotlin, nous utiliserons RxJava tout au long de cet article, sauf indication contraire.

Création de serveurs Observers et Observables simples dans Kotlin

Observers et Observables sont les blocs de construction de RxJava, commençons donc par créer:

  • Un simple Observable qui émet un court flux de données en réponse à un événement de clic de bouton.
  • Un Observable qui réagit à ces données en imprimant différents messages sur Logcat d'Android Studio.

Créez un nouveau projet avec les paramètres de votre choix, mais assurez-vous de cocher la case Include Kotlin support lorsque vous y êtes invité. Ensuite, ouvrez le fichier build.gradle de votre projet et ajoutez la bibliothèque RxJava en tant que dépendance du projet:

Ensuite, ouvrez le fichier activity_main.xml de votre projet et ajoutez le bouton qui démarrera le flux de données:

Il existe plusieurs manières différentes de créer un objet Observable, mais l’une des plus faciles consiste à utiliser l’opérateur just() pour convertir un objet ou une liste d’objets en objet Observable.

Dans le code suivant, nous créons un objet Observable (myObservable) et lui attribuons les éléments 1, 2, 3, 4 et 5 à émettre. Nous créons également un Observer (myObserver), en l’abonnant à myObservable, puis en lui indiquant d’imprimer un message à Logcat chaque fois qu’il reçoit une nouvelle émission.

Vous pouvez maintenant mettre cette application à l'épreuve:

  • Installez votre projet sur un smartphone ou une tablette Android physique ou sur un périphérique Android Virtua lDevice (AVD).
  • Cliquez sur le bouton Start RxJava stream.
  • Ouvrez Logcat Monitor d'Android Studio en sélectionnant l'onglet Android Monitor (où le curseur est positionné dans la capture d'écran suivante), puis en sélectionnant l'onglet Logcat.

À ce stade, Observable commencera à émettre ses données et Observer imprimera ses messages sur Logcat. Votre sortie Logcat devrait ressembler à ceci:

Check Android Studios Logcat Monitor

Vous pouvez télécharger ce projet à partir de GitHub si vous souhaitez l'essayer vous-même.

Kotlin Extensions for RxJava

Maintenant que nous avons vu comment configurer un simple pipeline RxJava dans Kotlin, voyons comment vous pouvez y parvenir en utilisant moins de code, en utilisant les fonctions d’extension de RxKotlin.

Pour utiliser la bibliothèque RxKotlin, vous devez l'ajouter en tant que dépendance de projet:

Dans l'exemple suivant, nous utilisons la fonction d'extension toObservable() de RxKotlin pour transformer un List en OBServable. Nous utilisons également la fonction d’extension subscribeBy(), car elle nous permet de construire un OBServer à l’aide d’arguments nommés, ce qui se traduit par un code plus clair.

Voici le résultat que vous devriez voir:

Every time onNext is called the data emission is printed to Android Studios Logcat

Résolution du problème d’ambiguïté SAM de RxJava

RxKotlin fournit également une solution de contournement importante pour le problème de conversion SAM pouvant survenir lorsque plusieurs surcharges de paramètres SAM sont associées à une méthode Java donnée. Cette ambiguïté SAM confond le compilateur Kotlin, car il ne peut pas déterminer l’interface qu’il est censé convertir, et par conséquent votre projet ne pourra pas être compilé.

Cette ambiguïté de SAM est un problème particulier lors de l'utilisation de RxJava 2.0 avec Kotlin, car beaucoup d'opérateurs RxJava utilisent plusieurs types compatibles SAM.

Examinons le problème de la conversion SAM en action. Dans le code suivant, nous utilisons l’opérateur zip() pour combiner la sortie de deux Observables:

Cela entraînera le compilateur Kotlin à lancer une erreur d'inférence de type. Cependant, RxKotlin fournit des méthodes d’aide et des fonctions d’extension pour les opérateurs concernés, y compris Observables.zip(), que nous utilisons dans le code suivant:

Voici la sortie de ce code:

Switch to the Observableszip operator and the Kotlin compiler will no longer throw a type inference error

Conclusion

Dans ce didacticiel, je vous ai montré comment commencer à utiliser la bibliothèque RxJava dans vos projets Kotlin, notamment en utilisant un certain nombre de bibliothèques supplémentaires, telles que RxKotlin et RxBinding. Nous avons examiné comment créer des observateurs et des observables simples dans Kotlin, tout en optimisant RxJava pour la plate-forme Kotlin, en utilisant des fonctions d'extension.

Jusqu'à présent, nous avons utilisé RxJava pour créer des observables simples qui émettent des données et des observateurs qui impriment ces données sur Logcat d'Android Studio, mais ce n'est pas comme cela que vous utiliserez RxJava dans le monde réel!

Dans le prochain article, nous allons voir comment RxJava peut aider à résoudre des problèmes concrets que vous rencontrerez lors du développement d'applications Android. Nous utiliserons RxJava avec Kotlin pour créer un écran Sign Up classique.

Advertisement
Advertisement
Looking for something to help kick start your next project?
Envato Market has a range of items for sale to help get you started.